static VALUE
Font_initialize(VALUE self, VALUE rbRealFilePath, VALUE rbSize,
VALUE rbBold, VALUE rbItalic, VALUE rbTtcIndex)
{
const char* path = StringValueCStr(rbRealFilePath);
const int size = NUM2INT(rbSize);
const bool bold = RTEST(rbBold);
const bool italic = RTEST(rbItalic);
const int ttcIndex = NUM2INT(rbTtcIndex);
Font* font;
Data_Get_Struct(self, Font, font);
font->size = size;
font->sdlFont = TTF_OpenFontIndex(path, size, ttcIndex);
if (!font->sdlFont) {
rb_raise(strb_GetStarRubyErrorClass(), "%s (%s)", TTF_GetError(), path);
}
const int style = TTF_STYLE_NORMAL |
(bold ? TTF_STYLE_BOLD : 0) | (italic ? TTF_STYLE_ITALIC : 0);
TTF_SetFontStyle(font->sdlFont, style);
return Qnil;
}
void TextView::setText(string s){
if(s.empty()){
if(textSurface != NULL)
SDL_FreeSurface( textSurface );
textSurface = NULL;
return;
}
text = s;
SDL_Surface * newTextSurface;
newTextSurface = TTF_RenderText_Blended(font, text.c_str(), textColor);
if(newTextSurface == NULL)
{
cerr << "TTF_RenderText_Blended() Failed: " << TTF_GetError() << endl;
TTF_Quit();
return;
}
if(textSurface != NULL)
SDL_FreeSurface( textSurface );
textSurface = newTextSurface;
resize(textSurface->w,textSurface->h);
}
bool init() {
bool success=true;
if(SDL_Init(SDL_INIT_VIDEO)<0) {
std::cout<<"SDL could not initialize! SDL Error: "<<SDL_GetError()<<std::endl;
success=false;
}
else {
if(!SDL_SetHint(SDL_HINT_RENDER_SCALE_QUALITY, "1")) {
std::cout<<"Warning: Linear texture filtering not enabled!";
}
gWindow=SDL_CreateWindow("Snake II", SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED, SCREEN_WIDTH, SCREEN_HEIGHT, SDL_WINDOW_SHOWN);
if(gWindow==NULL) {
std::cout<<"Window could not be created! SDL Error: "<<SDL_GetError()<<std::endl;
success=false;
}
else {
gRenderer=SDL_CreateRenderer(gWindow, -1, SDL_RENDERER_ACCELERATED);
if(gRenderer==NULL) {
std::cout<<"Renderer could not be created! SDL Error: "<<SDL_GetError()<<std::endl;
success=false;
}
else {
SDL_SetRenderDrawColor( gRenderer, 0xFF, 0xFF, 0xFF, 0xFF );
int imgFlags = IMG_INIT_PNG;
if(!(IMG_Init(imgFlags) & imgFlags)) {
std::cout<<"SDL_image could not initialize! SDL_image Error: "<<IMG_GetError()<<std::endl;
success=false;
}
if(TTF_Init()==-1) {
std::cout<<"SDL_ttf could not initialize! SDL_ttf Error: "<<TTF_GetError()<<std::endl;
success=false;
}
}
}
}
return success;
}
/** Constructor
* Creates a texture instance for rendering text.
*
* @param p_id The string identifier of the resource
* @param p_renderer The window renderer used to create the text texture
* @param p_font Pointer to a TTF_Font object used to render the text
* @param p_textureText The string to render
* @param p_textColor The color to render the text as
*/
n8::Texture::Texture(std::string p_id, SDL_Renderer* p_renderer, TTF_Font* p_font, std::string p_textureText, SDL_Color p_textColor ) : Resource(p_id)
{
SDL_Surface* textSurface = TTF_RenderText_Solid( p_font, p_textureText.c_str(), p_textColor );
if( textSurface == nullptr )
{
std::string msg( "Unable to render text surface! SDL_ttf Error: %s\n", TTF_GetError() );
n8::Log::Error(TAG, msg);
if(p_font == nullptr)
n8::Log::Error( TAG, " font was null");
else
n8::Log::Error( TAG, " font wasn't null");
string textMessage( " texture text was: %s", p_textureText.c_str());
n8::Log::Error(TAG, textMessage);
}
else
{
//Create texture from surface pixels
m_texture = SDL_CreateTextureFromSurface( p_renderer, textSurface );
if( m_texture == nullptr )
{
string textureCreationFailedMsg("Unable to create texture from rendered text! SDL Error: %s\n", SDL_GetError() );
n8::Log::Error(TAG, textureCreationFailedMsg);
}
else
{
//Get image dimensions
m_width = textSurface->w;
m_height = textSurface->h;
}
//Get rid of old surface
SDL_FreeSurface( textSurface );
}
}
bool Drawable::loadFromRenderedText( std::string textureText, SDL_Color textColor )
{
//Get rid of preexisting texture
free();
TTF_Font * gFont = TTF_OpenFont(GlobalDefs::getResource(RESOURCE_FONT, "zorque.ttf").c_str(),40);
//Render text surface
SDL_Surface* textSurface = TTF_RenderText_Solid( gFont, textureText.c_str(), textColor );
TTF_CloseFont(gFont);
if( textSurface == NULL )
{
printf( "Unable to render text surface! SDL_ttf Error: %s\n", TTF_GetError() );
}
else
{
//Create texture from surface pixels
mTexture = SDL_CreateTextureFromSurface( renderer, textSurface );
if( mTexture == NULL )
{
printf( "Unable to create texture from rendered text! SDL Error: %s\n", SDL_GetError() );
}
else
{
//Get image dimensions
image_size = {textSurface->w, textSurface->h};
render_size = image_size;
}
//Get rid of old surface
SDL_FreeSurface( textSurface );
}
//Return success
return mTexture != NULL;
}
bool Text::LoadText(std::string _textureText, SDL_Color _textColor, TTF_Font* _textureFont)
{
// Make sure to delete any previous surfaces (unlikely but just in case)
this->FreeText();
// Create the new surface by using the SDL_TTF plugin, blended so we have the lovely alpha values of the text
SDL_Surface* textSurface = TTF_RenderText_Blended(_textureFont, _textureText.c_str(), _textColor);
if (textSurface == NULL)
{
// If we can't make it then error
printf("Unable to render text surface. SDL_ttf Error: %s\n", TTF_GetError());
}
else
{
// Otherwise create and store our values for later use
this->m_textString = _textureText;
this->m_textColor = _textColor;
this->m_textFont = _textureFont;
// Create the texture we're going to draw from the surface we just created
this->m_text = SDL_CreateTextureFromSurface(this->m_render, textSurface);
if (m_text == NULL)
{
printf("Unable to create texture from rendered text. SDL Error: %s\n", SDL_GetError());
}
else
{
// Assign the sizes from the surface and store them for drawing
m_width = textSurface->w;
m_height = textSurface->h;
SDL_Rect rect = { 0, 0, m_width, m_height };
m_rect = rect;
}
SDL_FreeSurface(textSurface);
}
return this->m_text != NULL;
}
TTF_Font* FontManager::getTTF_Font(std::string filename, int pointsize)
{
TTFId id;
id.filename = filename;
id.pointsize = pointsize;
std::map<TTFId, TTF_Font*>::iterator iter;
iter = ttf_fonts.find(id);
if (iter != ttf_fonts.end())
return iter->second;
IDataSource* fontids;
fontids = FileSystem::get_instance()->ReadFile("@data/" + filename);
if (!fontids) {
perr << "Failed to open TTF: @data/" << filename << std::endl;
return 0;
}
// open font using SDL_RWops.
// Note: The RWops and IDataSource will be deleted by the TTF_Font
TTF_Font* font = TTF_OpenFontRW(fontids->getRWops(), 1, pointsize);
if (!font) {
perr << "Failed to open TTF: @data/" << filename
<< ": " << TTF_GetError() << std::endl;
return 0;
}
ttf_fonts[id] = font;
#ifdef DEBUG
pout << "Opened TTF: @data/" << filename << "." << std::endl;
#endif
return font;
}
bool NXFont::InitChars(TTF_Font *font, uint32_t color)
{
SDL_Color fgcolor;
SDL_Surface *letter;
fgcolor.r = (uint8_t)(color >> 16);
fgcolor.g = (uint8_t)(color >> 8);
fgcolor.b = (uint8_t)(color);
#ifdef _L10N_CP1251
char utf8_str[2];
#endif
char str[2];
str[1] = 0;
for(int i=1;i<NUM_LETTERS_RENDERED;i++)
{
str[0] = i;
#ifndef _L10N_CP1251
letter = TTF_RenderUTF8_Solid(font, str, fgcolor);
#else
win1251_to_utf8(str, utf8_str);
letter = TTF_RenderUTF8_Solid(font, utf8_str, fgcolor);
#endif
if (!letter)
{
staterr("InitChars: failed to render character %d: %s", i, TTF_GetError());
return 1;
}
letters[i] = SDL_DisplayFormat(letter);
SDL_FreeSurface(letter);
}
return 0;
}
bool TextureManager::load_text(const std::string & text,
const std::string & id,
const SDL_Color & color,
SDL_Renderer * renderer)
{
if (textures[id] != NULL)
SDL_DestroyTexture(textures[id]);
std::string rendered_text = " ";
TTF_Font * f = Game::get_instance() -> get_font();
//SDL_Color color = {152, 255, 255, 0};
if (text.length() > 0)
{
rendered_text = text;
}
SDL_Surface * tmp = TTF_RenderText_Solid(f, rendered_text.c_str(), color);
if (!tmp)
{
std::cerr << "Failure loading text: "
<< TTF_GetError() << std::endl;
return false;
}
SDL_Texture * new_texture = SDL_CreateTextureFromSurface(renderer, tmp);
SDL_FreeSurface(tmp);
if (!new_texture)
{
std::cerr << "Failure loading texture: "
<< SDL_GetError() << std::endl;
return false;
}
textures[id] = new_texture;
return true;
}
bool
texture_load_font_string(texture* img, char* text, SDL_Color text_color) {
// rm preexisting texture
texture_free(img);
// https://www.libsdl.org/projects/SDL_ttf/docs/SDL_ttf_43.html
s_surface* text_surface = TTF_RenderText_Solid(g_font, text, text_color);
if ( !text_surface )
{
printf("texture_load_font_string: unable to render text, ttf err: %s\n", TTF_GetError());
}
else
{
// create texture
img->ref = SDL_CreateTextureFromSurface(g_render, text_surface);
if ( !img->ref )
{
printf("texture_load_font_string: unable to create text texture, err: %s\n", SDL_GetError());
}
else
{
// get image dimensions
img->w = text_surface->w;
img->h = text_surface->h;
}
// flush surface
SDL_FreeSurface(text_surface);
}
return img->ref != 0;
}
void
TopWindow::set(LPCTSTR cls, LPCTSTR text,
int left, int top, unsigned width, unsigned height)
{
#ifdef ENABLE_SDL
int ret;
ret = ::SDL_Init(SDL_INIT_VIDEO|SDL_INIT_TIMER);
if (ret != 0)
fprintf(stderr, "SDL_Init() has failed\n");
ret = ::TTF_Init();
if (ret != 0)
fprintf(stderr, "TTF_Init() has failed: %s\n", TTF_GetError());
screen.set();
ContainerWindow::set(NULL, 0, 0, width, height);
char text2[512];
unicode2ascii(text, text2);
::SDL_WM_SetCaption(text2, NULL);
#else /* !ENABLE_SDL */
Window::set(NULL, cls, text, left, top, width, height,
(DWORD)(WS_SYSMENU|WS_CLIPCHILDREN|WS_CLIPSIBLINGS));
#if defined(GNAV) && !defined(PCGNAV)
// TODO code: release the handle?
HANDLE hTmp = LoadIcon(XCSoarInterface::hInst,
MAKEINTRESOURCE(IDI_XCSOARSWIFT));
SendMessage(hWnd, WM_SETICON,
(WPARAM)ICON_BIG, (LPARAM)hTmp);
SendMessage(hWnd, WM_SETICON,
(WPARAM)ICON_SMALL, (LPARAM)hTmp);
#endif
#endif /* !ENABLE_SDL */
}
CDebugger::CDebugger(CDisplay& Display, CSettingsManager& Settings): Display(Display)
{
/* Load the main font to be used throughout
* the debugger information.
*/
std::string font_name(Settings.GetValueAt("DebugFont"));
if(font_name == "")
/* Erroneous font name, hopefully we can
* load a safe alternative.
*/
font_name == "C:\\Windows\\Fonts\\Arial.ttf";
std::string size(Settings.GetValueAt("DebugFontSize"));
if(size == "")
/* No font size given! Most likely the font name
* check failed as well, so a 12pt Arial font
* would be just fine for debug info.
*/
size = "12";
this->debug_font = TTF_OpenFont(font_name.c_str(), atoi(size.c_str()));
if(!this->debug_font)
handleError(TTF_GetError());
/* For debug builds of the program,
* debugging is automatically on by default.
*/
#ifdef _DEBUG
this->ToggleDebugMode(true);
#else
this->ToggleDebugMode(false);
#endif // _DEBUG
}
PREFIX int spFontReload(spFontPointer font,const char* fontname,Uint32 size)
{
spLetterDelete( font->root );
font->root = NULL;
spLetterDelete( font->buttonRoot );
font->buttonRoot = NULL;
if ( font->cache.cache )
free( font->cache.cache );
TTF_CloseFont( font->font );
font->font = TTF_OpenFont( fontname, size );
if ( !(font->font) )
{
printf( "Failed to load Font \"%s\", dude...\n", fontname );
printf( " Error was: \"%s\"\n", TTF_GetError() );
free(font);
return 1;
}
font->size = size;
font->maxheight = 0;
font->cacheOffset = 0;
font->cache.cache = NULL;
spFontChangeCacheSize( font, SP_FONT_DEFAULT_CACHE );
return 0;
}
GLuint loadTextureFromFont(const std::string& fontFilename, int pointSize, const std::string& text)
{
GLuint textureID = 0;
TTF_Font * font = TTF_OpenFont(fontFilename.c_str(), pointSize);
if (!font)
{
std::cout << "Unable to load font " << fontFilename << " " << TTF_GetError();
return textureID;
}
SDL_Surface *textSurface = TTF_RenderText_Blended(font, text.c_str(), { 255, 255, 255 });
textureID = convertSDLSurfaceToGLTexture(textSurface);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
TTF_CloseFont(font);
return textureID;
}
Spaceinvader * Spaceinvader_opprett() {
/* Opprett Spaceinvader-objekt. */
Spaceinvader *s = (Spaceinvader*)malloc(sizeof(Spaceinvader));
/* Initier SDL */
if (SDL_Init(SDL_INIT_VIDEO) != 0){
printf ("SDL_Init Error: %s", SDL_GetError());
return NULL;
}
/* Initier TTF */
if (TTF_Init() != 0) {
printf ("TTF_Init Error: %s", TTF_GetError());
return NULL;
}
/* Opprett skjerm-objekt. */
s->skjerm = Skjerm_opprett(s);
if (s->skjerm == NULL) {
printf ("Skjerm_opprett Error: Systemfeil.");
return NULL;
}
s->modell = Modell_opprett(s);
s->kontrollsentral = Kontrollsentral_opprett(s);
return s;
}
bool STexture::loadFromRenderedText(std::string textureText, SDL_Color textColor)
{
//Get rid of preexisting texture
free();
TTF_Font *gFont = NULL;
//Render text surface
SDL_Surface* textSurface = TTF_RenderText_Solid(gFont, textureText.c_str(), textColor);
if (textSurface != NULL)
{
//Create texture from surface pixels
mTexture = SDL_CreateTextureFromSurface(gRenderer, textSurface);
if (mTexture == NULL)
{
printf("Unable to create texture from rendered text! SDL Error: %s\n", SDL_GetError());
}
else
{
//Get image dimensions
mWidth = textSurface->w;
mHeight = textSurface->h;
}
//Get rid of old surface
SDL_FreeSurface(textSurface);
}
else
{
printf("Unable to render text surface! SDL_ttf Error: %s\n", TTF_GetError());
}
//Return success
return mTexture != NULL;
}
bool MapView::initialize(Map * model)
{
mapModel = model;
if (SDL_Init(SDL_INIT_EVERYTHING) != 0)
{
std::cout << "SDL_Init error." << std::endl;
return false;
}
if (TTF_Init() == -1)
{
std::cout << TTF_GetError() << std::endl;
return false;
}
window = SDL_CreateWindow(WINDOW_NAME.c_str(), SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, screenWidth,
screenHeight, SDL_WINDOW_SHOWN);
if (window == nullptr)
{
std::cout << "SDL_CreateWindow error." << std::endl;
return false;
}
renderer = SDL_CreateRenderer(window, -1, SDL_RENDERER_ACCELERATED | SDL_RENDERER_PRESENTVSYNC);
if (renderer == nullptr)
{
std::cout << "SDL_CreateRenderer error." << std::endl;
return false;
}
texture.setRenderer(renderer);
texture.loadAllTextures();
text.setRenderer(renderer);
text.loadFontPaths();
loadViewComponents();
std::cout << "MapView initialization complete!" << std::endl;
return true;
}
bool LTexture::loadFromRenderedText(std::string textureText, SDL_Color textColor)
{
//Get rid of preexisting texture
free();
//Render text surface
SDL_Surface* textSurface = TTF_RenderText_Solid(gFont, textureText.c_str(), textColor);
if (textSurface != nullptr)
{
//Create texture from surface pixels
mTexture = SDL_CreateTextureFromSurface(gRenderer, textSurface);
if (mTexture == nullptr)
{
std::string err = "Unable to create texture from rendered text!! SDL_ttf Error: " + std::string(SDL_GetError());
logger.error(err.c_str());
}
else
{
//Get image dimensions
mWidth = textSurface->w;
mHeight = textSurface->h;
}
//Get rid of old surface
SDL_FreeSurface(textSurface);
}
else
{
std::string err = "Unable to render text surface! SDL_ttf Error: " + std::string(TTF_GetError());
logger.error(err.c_str());
}
//Return success
return mTexture != nullptr;
}
void Game::init() {
if (initialized) {
return;
}
initGlobals();
initialized = true;
// SDL
if (SDL_Init(SDL_INIT_VIDEO | SDL_INIT_TIMER) < 0) {
Log::message(Log::Error, SDL_GetError());
exit(0);
}
// TTF
if (TTF_Init()) {
Log::message(Log::Error, TTF_GetError());
exit(0);
}
// SDLNet
if (SDLNet_Init()) {
Log::message(Log::Error, SDLNet_GetError());
exit(0);
}
// OpenAL
if (!initOpenAL()) {
Log::message(Log::Error, alError);
exit(0);
}
initLocks();
Graphics::init();
Audio::init();
}
//=============================================================================
void InitSDL()
{
printf("INFO: Initializing SLD.\n");
if(SDL_Init(SDL_INIT_VIDEO) < 0)
throw Format("ERROR: Failed to initialize SDL (%d).", SDL_GetError());
window = SDL_CreateWindow("Monster Outrage v 0", SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED, 1024, 768, SDL_WINDOW_SHOWN);
if(!window)
throw Format("ERROR: Failed to create window (%d).", SDL_GetError());
renderer = SDL_CreateRenderer(window, 0, SDL_RENDERER_ACCELERATED | SDL_RENDERER_PRESENTVSYNC);
if(!renderer)
throw Format("ERROR: Failed to create renderer (%d).", SDL_GetError());
int imgFlags = IMG_INIT_PNG;
if(!(IMG_Init(imgFlags) & imgFlags))
throw Format("ERROR: Failed to initialize SDL_image (%d).", IMG_GetError());
SDL_SetRenderDrawColor(renderer, 0xFF, 0xFF, 0xFF, 0xFF);
if(TTF_Init() == -1)
throw Format("ERROR: Failed to initialize SDL_ttf (%d).", TTF_GetError());
}
static TTF_Font* open_font(const std::string& fname, int size)
{
std::string name;
if(!game_config::path.empty()) {
name = game_config::path + "/fonts/" + fname;
if(!filesystem::file_exists(name)) {
name = "fonts/" + fname;
if(!filesystem::file_exists(name)) {
name = fname;
if(!filesystem::file_exists(name)) {
ERR_FT << "Failed opening font: '" << name << "': No such file or directory" << std::endl;
return NULL;
}
}
}
} else {
name = "fonts/" + fname;
if(!filesystem::file_exists(name)) {
if(!filesystem::file_exists(fname)) {
ERR_FT << "Failed opening font: '" << name << "': No such file or directory" << std::endl;
return NULL;
}
name = fname;
}
}
SDL_RWops *rwops = filesystem::load_RWops(name);
TTF_Font* font = TTF_OpenFontRW(rwops, true, size); // SDL takes ownership of rwops
if(font == NULL) {
ERR_FT << "Failed opening font: TTF_OpenFont: " << TTF_GetError() << std::endl;
return NULL;
}
return font;
}
TTF_Font *read_and_alloc_font(const char *path, int pt_size)
{
TTF_Font *out;
SDL_RWops *rw;
Uint8 *data;
FILE *fp = fopen(path, "r");
size_t r;
if (!fp) {
fprintf(stderr, "Could not open font %s\n", path);
return NULL;
}
data = (Uint8*)xmalloc(1 * 1024*1024);
r = fread(data, 1, 1 * 1024 * 1024, fp);
if (r == 0 || ferror(fp))
{
free(data);
return NULL;
}
rw = SDL_RWFromMem(data, 1 * 1024 * 1024);
if (!rw)
{
fprintf(stderr, "Could not create RW: %s\n", SDL_GetError());
free(data);
return NULL;
}
out = TTF_OpenFontRW(rw, 1, pt_size);
if (!out)
{
fprintf(stderr, "TTF: Unable to create font %s (%s)\n",
path, TTF_GetError());
}
fclose(fp);
return out;
}
void Window::initialize()
{
showDebugInfo();
fprintf(stdout, "Initializing SDL system\r\n");
if(SDL_Init(SDL_INIT_VIDEO|SDL_INIT_AUDIO|SDL_INIT_TIMER) != 0)
{
fprintf(stderr, "Unable to init SDL: %s\n", SDL_GetError());
exit(1);
}
fprintf(stdout, "Initializing font system\r\n");
if(TTF_Init() == -1)
{
fprintf(stderr, "Unable to init SDL_ttf: %s\n", TTF_GetError());
exit(2);
}
fprintf(stdout, "Initializing audio system\r\n");
if (Mix_OpenAudio(44100, MIX_DEFAULT_FORMAT, 2, 4096) < 0)
{
fprintf(stderr, "Unable to open audio channel: %s\n", Mix_GetError());
exit(3);
}
}
void aff_choose_map(SDL_Surface *win)
{
SDL_Rect pos;
SDL_Surface *texte;
TTF_Font *police;
SDL_Color red;
red.r = 255;
red.g = 0;
red.b = 0;
if (TTF_Init() == -1)
{
fprintf(stderr,
"Erreur d'initialisation de TTF_Init : %s\n", TTF_GetError());
exit(EXIT_FAILURE);
}
pos.x = 250;
pos.y = 540;
police = TTF_OpenFont("./times.ttf", 30);
texte = TTF_RenderText_Blended(police, "Choississez votre map :", red);
choose_map(win, police, red, pos, texte);
TTF_CloseFont(police);
TTF_Quit();
}
Engine::Graphics::GraphicsRenderer::GraphicsRenderer(void)
: _Window(NULL), _GLContext(NULL)
{
if (SDL_Init(SDL_INIT_VIDEO) < 0)
{
throw std::exception(SDL_GetError());
}
if (TTF_Init() < 0)
{
throw std::exception(TTF_GetError());
}
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 3);
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 3);
SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, SDL_GL_CONTEXT_PROFILE_CORE);
SDL_GL_SetAttribute(SDL_GL_RED_SIZE, 8);
SDL_GL_SetAttribute(SDL_GL_GREEN_SIZE, 8);
SDL_GL_SetAttribute(SDL_GL_BLUE_SIZE, 8);
SDL_GL_SetAttribute(SDL_GL_ALPHA_SIZE, 8);
SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, 0);
SDL_GL_SetAttribute(SDL_GL_STENCIL_SIZE, 0);
SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);
}
FontRenderer::FontRenderer() {
properties = fileLoader.loadConfigFile();
std::istringstream in(properties.find("FONT_COLOR_R")->second);
in >> color.r;
in.clear();
in.str(properties.find("FONT_COLOR_G")->second);
in >> color.g;
in.clear();
in.str(properties.find("FONT_COLOR_B")->second);
fontpath = "resources/action_force_normal.ttf";
fontSize = 12;
TTF_Init();
atexit(TTF_Quit);
if (!(font = TTF_OpenFont(fontpath.c_str(), fontSize))) {
std::cout << "Error loading font: " << TTF_GetError() << std::endl;
exit(1);
}
}
int init_graphics(int argc, char *argv[])
{
if (SDL_Init(SDL_INIT_VIDEO) != 0) {
printf("Unable to initialize SDL: %s \n", SDL_GetError());
exit(1);
}
if (TTF_Init() == -1)
{
printf("Unable to initialize SDL_ttf:%s \n", TTF_GetError());
exit(1);
}
screen = SDL_SetVideoMode(SCREEN_WIDTH, SCREEN_HEIGHT, COLOR_DEPTH, SDL_DOUBLEBUF); //| SDL_FULLSCREEN);
if (screen == NULL) {
printf("Unable to set video mode: %s \n", SDL_GetError());
exit(1);
}
SDL_ShowCursor(SDL_DISABLE); //remove cursor
/*When the application exits, make sure everything is shutdown.*/
atexit(cleanup);
/*Load our media, like images and fonts*/
loadmedia();
/*Set some variables so our mainloop does the right thing*/
running = true;
gameovermode = true;
/*Enter the main loop, and when we return, exit*/
pthread_t graphics_thread;
pthread_create( &graphics_thread, NULL, mainloop, NULL);
return 0;
}
void text_layer_set_text(TextLayer *text_layer, const char *text) {
text_layer->text = text;
SDL_Surface *text_surface;
SDL_Color bgcolor = getColor(text_layer->background_color);
if(!(text_surface = TTF_RenderText(text_layer->font, text,
getColor(text_layer->text_color),
bgcolor))) {
printf("[ERROR] TTF_RenderText_Solid: %s\n", TTF_GetError());
} else {
SDL_Rect dst;
dst.x = text_layer->layer.frame.origin.x;
dst.y = text_layer->layer.frame.origin.y;
if(bgcolor.unused == 255) {
SDL_Surface *text_bgsurface = SDL_CreateRGBSurface(SDL_SWSURFACE, text_surface->w, text_surface->h, 32,
0,0,0,0);
SDL_FillRect(text_bgsurface, NULL, SDL_MapRGBA(screen->format, bgcolor.r, bgcolor.g, bgcolor.b, bgcolor.unused));
SDL_BlitSurface(text_bgsurface, NULL, screen, &dst);
SDL_FreeSurface(text_bgsurface);
}
SDL_BlitSurface(text_surface, NULL, screen, &dst);
SDL_FreeSurface(text_surface);
}
}
bool LTexture::loadFromRenderedText( Window &gWindow, std::string textureText, SDL_Color textColor, int fontSize )
{
//Get rid of preexisting texture
free();
TTF_Font *gFont = TTF_OpenFont("fonts/MOZART_0.ttf", fontSize);
//TTF_SetFontStyle(gFont, TTF_STYLE_BOLD);
//Render text surface
SDL_Surface* textSurface = TTF_RenderText_Solid( gFont, textureText.c_str(), textColor);
if( textSurface != NULL )
{
//Create texture from surface pixels
mTexture = SDL_CreateTextureFromSurface( gWindow.getRender(), textSurface );
if( mTexture == NULL )
{
printf( "Unable to create texture from rendered text! SDL Error: %s\n", SDL_GetError() );
}
else
{
//Get image dimensions
mWidth = textSurface->w;
mHeight = textSurface->h;
}
//Get rid of old surface
SDL_FreeSurface( textSurface );
}
else
{
printf( "Unable to render text surface! SDL_ttf Error: %s\n", TTF_GetError() );
}
//Return success
return mTexture != NULL;
}
MessageArea::MessageArea ( SDL_Surface* dest_surface, int sizex, int sizey, int originx, int originy ) : Widget( dest_surface, sizex, sizey, originx, originy )
{
dest.x = originx;
dest.y = originy;
dest.w = sizex;
dest.h = sizey;
font = TTF_OpenFont ( "client/data/Vera.ttf", 12 );
if ( !font )
{
std::cerr << "Error creating TTF_Font: " << TTF_GetError() << "\n";
exit ( 1 );
}
font_height = TTF_FontLineSkip ( font );
message_color.r = 255;
message_color.g = 255;
message_color.b = 0;
message_color.unused = 0;
input_received = true;
blocked = 0;
current_message = -1;
}
