// // Initialize the game state void Renderer::Init(int width, int height) { 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_DOUBLEBUFFER, 1); TTF_Init(); surface_ = SDL_SetVideoMode(width, height, 32, SDL_OPENGL); if (!surface_) { Die("Could not create SDL surface"); } glViewport(0, 0, width, height); glEnable(GL_BLEND); glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); width_ = width; height_ = height; Pack& pack = app_->pack(); if (pack.contains("fonts/VeraBd.ttf")) { PackEntry entry = pack["fonts/VeraBd.ttf"]; SDL_RWops *rwops = SDL_RWFromMem(entry.data, entry.length); font_ = TTF_OpenFontRW(rwops, 1, 16); } }
/** * 初期化します。 */ int initTextRenderer(SDL_RWops *src,int default_fontsize){ Font = TTF_OpenFontRW(src,1,default_fontsize); //十分に大きな領域を確保 makeEmptySprite(&RenderingSprite,default_fontsize<<3,default_fontsize<<4,TRUE,TRUE); if(Font != NULL) return TRUE; return FALSE; }
/** * @brief Initializes the font system. */ void TextSurface::initialize() { TTF_Init(); // first determine the available fonts IniFile ini("text/fonts.dat", IniFile::READ); for (ini.start_group_iteration(); ini.has_more_groups(); ini.next_group()) { // get the font metadata std::string font_id = ini.get_group(); std::string file_name = ini.get_string_value("file", ""); Debug::check_assertion(file_name.size() > 0, StringConcat() << "Missing font file name in file 'text/fonts.dat' for group '" << font_id << "'"); int font_size = ini.get_integer_value("size", 0); Debug::check_assertion(font_size > 0, StringConcat() << "Missing font size in file 'text/fonts.dat' for group '" << font_id << "'"); fonts[font_id].file_name = file_name; fonts[font_id].font_size = font_size; if (ini.get_boolean_value("default", false)) { default_font_id = font_id; } // load the font size_t size; FileTools::data_file_open_buffer(file_name, &fonts[font_id].buffer, &size); fonts[font_id].rw = SDL_RWFromMem(fonts[font_id].buffer, int(size)); fonts[font_id].internal_font = TTF_OpenFontRW(fonts[font_id].rw, 0, font_size); Debug::check_assertion(fonts[font_id].internal_font != NULL, StringConcat() << "Cannot load font from file '" << file_name << "': " << TTF_GetError()); } Debug::check_assertion(default_font_id.size() > 0, "No default font set in file 'text/fonts.dat'"); }
static TTF_Font *read_font(const char *path, int font_size) { TTF_Font *out; SDL_RWops *rw; Uint8 *data = (Uint8*)malloc(1 * 1024*1024); FILE *fp = fopen(path, "r"); if (!data) { write_log("Malloc failed\n"); exit(1); } if (!fp) { write_log("Could not open font\n"); exit(1); } fread(data, 1, 1 * 1024 * 1024, fp); rw = SDL_RWFromMem(data, 1 * 1024 * 1024); if (!rw) { write_log("Could not create RW: %s\n", SDL_GetError()); exit(1); } out = TTF_OpenFontRW(rw, 1, font_size); if (!out) { write_log("Unable to open font %s\n", path); exit(1); } fclose(fp); return out; }
/** * \brief Returns an outline font with the specified size. * \param font_id Id of the outline font to get. It must exist. * \param size Size to use. * \return The font. */ TTF_Font& FontResource::get_outline_font(const std::string& font_id, int size) { if (!fonts_loaded) { load_fonts(); } const auto& kvp = fonts.find(font_id); Debug::check_assertion(kvp != fonts.end(), std::string("No such font: '") + font_id + "'"); FontFile& font = kvp->second; Debug::check_assertion(font.bitmap_font == nullptr, std::string("This is not an outline font: '") + font_id + "'"); std::map<int, OutlineFontReader>& outline_fonts = kvp->second.outline_fonts; const auto& kvp2 = outline_fonts.find(size); if (kvp2 != outline_fonts.end()) { return *kvp2->second.outline_font; } // First time we want this font with this particular size. SDL_RWops_UniquePtr rw = SDL_RWops_UniquePtr(SDL_RWFromMem( const_cast<char*>(font.buffer.data()), (int) font.buffer.size() )); TTF_Font_UniquePtr outline_font(TTF_OpenFontRW(rw.get(), 0, size)); Debug::check_assertion(outline_font != nullptr, std::string("Cannot load font from file '") + font.file_name + "': " + TTF_GetError() ); OutlineFontReader reader = { std::move(rw), std::move(outline_font) }; outline_fonts.emplace(size, std::move(reader)); return *outline_fonts.at(size).outline_font; }
int load_font(char *fname, int size) { char *p; free_font(); font = TTF_OpenFont(fname, size); if (!font) { //Try to open the in memory font SDL_RWops *s; s = SDL_RWFromMem(dejavu_sans_ttf, dejavu_sans_ttf_len); font = TTF_OpenFontRW(s, 0, size); if (font) { __android_log_print(ANDROID_LOG_INFO, "BroovPlayer", "Open font from memory successful"); } else { __android_log_print(ANDROID_LOG_INFO, "BroovPlayer", "Open font from memory failed:%s", TTF_GetError()); return 3; } } /* print some metrics and attributes */ //printf("size : %d\n",size); //printf("TTF_FontHeight : %d\n",TTF_FontHeight(font)); //printf("TTF_FontAscent : %d\n",TTF_FontAscent(font)); //printf("TTF_FontDescent : %d\n",TTF_FontDescent(font)); //printf("TTF_FontLineSkip : %d\n",TTF_FontLineSkip(font)); //printf("TTF_FontFaceIsFixedWidth: %d\n",TTF_FontFaceIsFixedWidth(font)); /* cache new glyphs */ cache_glyphs(); return 0; }
d_define_method(fonts, add_font)(struct s_object *self, unsigned int id, struct s_object *stream, int size) { d_using(fonts); struct s_stream_attributes *stream_attributes = d_cast(stream, stream); char buffer[d_string_buffer_size]; SDL_RWops *font_block; if (fonts_attributes->fonts[id].font) { TTF_CloseFont(fonts_attributes->fonts[id].font); munmap(fonts_attributes->fonts[id].font_block, fonts_attributes->fonts[id].file_stats.st_size); } fstat(stream_attributes->descriptor, &(fonts_attributes->fonts[id].file_stats)); if ((fonts_attributes->fonts[id].font_block = mmap(NULL, fonts_attributes->fonts[id].file_stats.st_size, PROT_READ, MAP_SHARED, stream_attributes->descriptor, 0)) != MAP_FAILED) { font_block = SDL_RWFromMem(fonts_attributes->fonts[id].font_block, fonts_attributes->fonts[id].file_stats.st_size); if (!(fonts_attributes->fonts[id].font = TTF_OpenFontRW(font_block, d_true, size))) { munmap(fonts_attributes->fonts[id].font_block, fonts_attributes->fonts[id].file_stats.st_size); snprintf(buffer, d_string_buffer_size, "ungenerable TTF for font %s exception", d_string_cstring(stream_attributes->string_name)); d_throw(v_exception_ttf, buffer); } } else { snprintf(buffer, d_string_buffer_size, "wrong type for file %s exception", d_string_cstring(stream_attributes->string_name)); d_throw(v_exception_wrong_type, buffer); } return self; }
static TTF_Font * Load_Font(int ptsize) { SDL_RWops *sdlrwmem = NULL; sdlrwmem = SDL_RWFromConstMem(&FontDump, FontSize); return TTF_OpenFontRW(sdlrwmem, 1, ptsize); }
TTF_Font * CTrueTypeFont::loadFont(const JsonNode &config) { int pointSize = config["size"].Float(); if(!TTF_WasInit() && TTF_Init()==-1) throw std::runtime_error(std::string("Failed to initialize true type support: ") + TTF_GetError() + "\n"); return TTF_OpenFontRW(SDL_RWFromConstMem(data.first.get(), data.second), 1, pointSize); }
void CFont::Load(const char *filepath) { TiXmlDocument doc(filepath); if(!doc.LoadFile()) { common->Error("Failed to load font '%s'\n", filepath); } TiXmlElement *root = doc.FirstChildElement("Font"); /* do a "do { ... } while(0)" loop here we break the loop if we are sure of an syntax error in the font file */ do { if(!root) { break; } const char *location = NULL; TiXmlElement *elem; FOR_EACH_ELEM(root, elem) { if(strcmp(elem->Value(), "Size") == 0) { TiXmlText *text = elem->FirstChild()->ToText(); if(!text) { continue; } size = atoi(text->Value()); } else if(strcmp(elem->Value(), "Location") == 0) { TiXmlText *text = elem->FirstChild()->ToText(); if(!text) { continue; } location = text->Value(); } } /* Break if any of these are missing */ if(!location || !size) { break; } /* Load the font. TTF will free the memory for us */ unsigned int dsize = 0; void *data = fileSystem_local.ReadFile(StrUtl::FormatString("data/res/font/%s", location).c_str(), dsize); font = TTF_OpenFontRW(SDL_RWFromMem(data, (int)dsize), 1, size); if(!font) { common->Error("Failed to load font data %s: %s\n", filepath, TTF_GetError()); } return; } while(0); common->Error("The font config file has invalid syntax %s\n", filepath); }
_TTF_Font *SharedFontState::getFont(std::string family, int size) { /* Check for substitutions */ if (p->subs.contains(family)) family = p->subs[family]; /* Find out if the font asset exists */ const FontSet &req = p->sets[family]; if (req.regular.empty() && req.other.empty()) { /* Doesn't exist; use built-in font */ family = ""; } FontKey key(family, size); TTF_Font *font = p->pool.value(key); if (font) return font; /* Not in pool; open new handle */ SDL_RWops *ops; if (family.empty()) { /* Built-in font */ ops = openBundledFont(); } else { /* Use 'other' path as alternative in case * we have no 'regular' styled font asset */ const char *path = !req.regular.empty() ? req.regular.c_str() : req.other.c_str(); ops = SDL_AllocRW(); shState->fileSystem().openReadRaw(*ops, path, true); } // FIXME 0.9 is guesswork at this point // float gamma = (96.0/45.0)*(5.0/14.0)*(size-5); // font = TTF_OpenFontRW(ops, 1, gamma /** .90*/); font = TTF_OpenFontRW(ops, 1, size* .90); if (!font) throw Exception(Exception::SDLError, "%s", SDL_GetError()); p->pool.insert(key, font); return font; }
static mrb_value mrb_sdl2_ttf_font_initialize(mrb_state *mrb, mrb_value self) { TTF_Font *font = NULL; mrb_sdl2_ttf_font_data_t *data = (mrb_sdl2_ttf_font_data_t*)DATA_PTR(self); if (NULL == data) { data = (mrb_sdl2_ttf_font_data_t*)mrb_malloc(mrb, sizeof(mrb_sdl2_ttf_font_data_t)); if (NULL == data) { mrb_raise(mrb, E_RUNTIME_ERROR, "insufficient memory."); } data->font = NULL; } if (2 == mrb->c->ci->argc) { SDL_RWops *rwops; mrb_value object; mrb_int size; mrb_get_args(mrb, "oi", &object, &size); if (mrb_obj_is_kind_of(mrb, object, mrb_class_get_under(mrb, mrb->object_class, "String"))) { font = TTF_OpenFont(RSTRING_PTR(object), size); } else if (mrb_obj_is_kind_of(mrb, object, mrb_class_get_under(mrb, mod_SDL2, "RWops"))) { rwops = mrb_sdl2_rwops_get_ptr(mrb, object); font = TTF_OpenFontRW(rwops, 0, size); } } else if (3 == mrb->c->ci->argc) { SDL_RWops *rwops; mrb_value object; mrb_int size, index; mrb_get_args(mrb, "oii", &object, &size, &index); if (mrb_obj_is_kind_of(mrb, object, mrb_class_get_under(mrb, mrb->object_class, "String"))) { font = TTF_OpenFontIndex(RSTRING_PTR(object), size, index); } else if (mrb_obj_is_kind_of(mrb, object, mrb_class_get_under(mrb, mod_SDL2, "RWops"))) { rwops = mrb_sdl2_rwops_get_ptr(mrb, object); font = TTF_OpenFontIndexRW(rwops, 0, size, index); } } else { mrb_free(mrb, data); mrb_raise(mrb, E_ARGUMENT_ERROR, "wrong number of arguments."); } if (NULL == font) { mrb_free(mrb, data); mruby_sdl2_raise_error(mrb); } data->font = font; DATA_PTR(self) = data; DATA_TYPE(self) = &mrb_sdl2_ttf_font_data_type; return self; }
void *archive_load_font( const char *filename, int size ) { void *asset; TTF_Font *font; char buf[264]; if ( asset_acquire((void*)filename) != NULL ) return (void*)filename; font = TTF_OpenFontRW( archive_open_file(filename), 1, size ); if ( font == NULL ) { fatal( "Failed to load font %s:\n%s\n", filename, TTF_GetError() ); } SDL_snprintf( buf, 256, "%s:%d", filename, size ); return asset_create( buf, font, ASSET_FONT ); }
TTF_Font* LoadFont(const String &file, int fontSize) { TTF_Font *font = nullptr; #if defined(__ANDROID__) SDL_RWops *f = SDL_RWFromFile(file.c_str(), "rb"); font = TTF_OpenFontRW(f, 1, fontSize); #elif defined(_WIN32) font = TTF_OpenFont(file.c_str(), fontSize); #endif if (font == nullptr) logSDLError(std::cout, "OpenFont"); return font; }
// Load new texture from file path TTF_Font* const Fonts::load(const char* path, int size) { TTF_Font* font = TTF_OpenFontRW(app->fs->load(path), 1, size); if (font == NULL) { LOG("Could not load TTF font with path: %s. TTF_OpenFont: %s", path, TTF_GetError()); } else { LOG("Successfully loaded font %s size %d", path, size); fonts.push_back(font); } return font; }
TTF_Font *loadFontFromPak(char *name, int fontSize) { unsigned long size; unsigned char *buffer; SDL_RWops *rw; TTF_Font *font; buffer = uncompressFileRW(name, &size); rw = SDL_RWFromMem(buffer, size); font = TTF_OpenFontRW(rw, TRUE, fontSize); /*free(buffer);*/ return font; }
CachedFont* CText::GetOrOpenFont(FontType font, float size) { Math::IntPoint windowSize = m_engine->GetWindowSize(); int pointSize = static_cast<int>(size * (windowSize.Length() / REFERENCE_SIZE.Length())); if (m_lastCachedFont != nullptr) { if (m_lastFontType == font && m_lastFontSize == pointSize) return m_lastCachedFont; } auto it = m_fonts.find(font); if (it == m_fonts.end()) { m_error = std::string("Invalid font type ") + StrUtils::ToString<int>(static_cast<int>(font)); return nullptr; } MultisizeFont* mf = (*it).second; auto jt = mf->fonts.find(pointSize); if (jt != mf->fonts.end()) { m_lastCachedFont = (*jt).second; m_lastFontType = font; m_lastFontSize = pointSize; return m_lastCachedFont; } m_lastCachedFont = new CachedFont(); SDL_RWops* file = CResourceManager::GetSDLFileHandler(mf->fileName); if(file == nullptr) { m_error = std::string("Unable to open file"); return nullptr; } m_lastCachedFont->font = TTF_OpenFontRW(file, 1, pointSize); if (m_lastCachedFont->font == nullptr) m_error = std::string("TTF_OpenFont error ") + std::string(TTF_GetError()); mf->fonts[pointSize] = m_lastCachedFont; return m_lastCachedFont; }
Font::Font(const void* data, int data_size, int font_size) { // Try to load a font from memory, throw exception on failure. // Create a SDL_RWops object from memory (SDL_TTF can load fonts from RWops, but not firectly from memory) SDL_RWops* font_rw = SDL_RWFromConstMem(data, data_size); if(NULL == font_rw) // Check if the creation of rwops succeeded { throw std::runtime_error(SDL_GetError()); } // Attempt to load the font from rwops m_font = TTF_OpenFontRW(font_rw, 1, font_size); if(NULL == m_font) { throw std::runtime_error(TTF_GetError()); } }
static int open_font(lua_State * L) { const char * filename; lua_Integer fontsize; TTF_Font * font; TTF_Font ** ud; char adjusted_filename[MAX_ADJUSTED_FILENAME_LEN]; SDL_RWops * file; filename = luaL_checkstring(L, 1); prepend_data_path(adjusted_filename, filename, MAX_ADJUSTED_FILENAME_LEN); file = SDL_RWFromFile(adjusted_filename, "rt"); fontsize = luaL_checkinteger(L, 2); font = TTF_OpenFontRW(file, 1, fontsize); if (!font) fatal(TTF_GetError()); ud = (TTF_Font **) lua_newuserdata(L, sizeof(TTF_Font *)); if (ud == NULL) fatal("ud NULL in open_font"); *ud = font; return 1; }
void SharedFontState::initFontSetCB(SDL_RWops &ops, const std::string &filename) { TTF_Font *font = TTF_OpenFontRW(&ops, 0, 0); if (!font) return; std::string family = TTF_FontFaceFamilyName(font); std::string style = TTF_FontFaceStyleName(font); TTF_CloseFont(font); FontSet &set = p->sets[family]; if (style == "Regular") set.regular = filename; else set.other = filename; }
TextButton::TextButton() : GuiButton() { Name = ClassName; TextTransparency = 0; #ifndef OPENBLOX_NO_GRAPHICS needsRecalc = false; Font = TTF_OpenFontRW(OpenBlox::AssetLocator::getInstance()->openSDLRW("res://fonts/OpenSans-Regular.ttf"), 0, 20); tex = 0; #endif TextBounds = new ob_type::Vector2(0, 0); TextColor3 = new ob_type::Color3(); TextXAlignment = ob_enum::TextXAlignment::Left; TextYAlignment = ob_enum::TextYAlignment::Top; tw = 0; th = 0; Text = ""; }
void *FontInfo::openFont( char *font_file, int ratio1, int ratio2 ) { int font_size; if ( font_size_xy[0] < font_size_xy[1] ) font_size = font_size_xy[0]; else font_size = font_size_xy[1]; FontContainer *fc = &root_font_container; while( fc->next ){ if ( fc->next->size == font_size ) break; fc = fc->next; } if ( !fc->next ){ fc->next = new FontContainer(); fc->next->size = font_size; FILE *fp = fopen( font_file, "r" ); if ( fp == NULL ) return NULL; fclose( fp ); #if defined(PSP) fc->next->rw_ops = SDL_RWFromFile(font_file, "r"); fc->next->font = TTF_OpenFontRW( fc->next->rw_ops, SDL_TRUE, font_size * ratio1 / ratio2 ); fc->next->power_resume_number = psp_power_resume_number; strcpy(fc->next->name, font_file); #else fc->next->font = TTF_OpenFont( font_file, font_size * ratio1 / ratio2 ); #endif } #if defined(PSP) else if (fc->next->power_resume_number != psp_power_resume_number){ FILE *fp = fopen(fc->next->name, "r"); fc->next->rw_ops->hidden.stdio.fp = fp; fc->next->power_resume_number = psp_power_resume_number; } #endif ttf_font = (void*)fc->next->font; return fc->next->font; }
/** * \brief Function called by the Lua data file to add a font. * * - Argument 1 (table): properties of the font. * * \param l the Lua context that is calling this function * \return number of values to return to Lua */ int TextSurface::l_font(lua_State* l) { luaL_checktype(l, 1, LUA_TTABLE); const std::string& font_id = LuaContext::check_string_field(l, 1, "id"); const std::string& file_name = LuaContext::check_string_field(l, 1, "file"); int font_size = LuaContext::opt_int_field(l, 1, "size", 11); bool is_default = LuaContext::opt_boolean_field(l, 1, "default", false); fonts[font_id].file_name = file_name; fonts[font_id].font_size = font_size; if (is_default || default_font_id.empty()) { default_font_id = font_id; } // Load the font. size_t index = file_name.rfind('.'); std::string extension; if (index != std::string::npos) { extension = file_name.substr(index); } if (extension == ".png" || extension == ".PNG") { // It's a bitmap font. fonts[font_id].bitmap = new Surface(file_name, Surface::DIR_DATA); } else { // It's a normal font. size_t size; FileTools::data_file_open_buffer(file_name, &fonts[font_id].buffer, &size); fonts[font_id].bitmap = NULL; fonts[font_id].rw = SDL_RWFromMem(fonts[font_id].buffer, int(size)); fonts[font_id].internal_font = TTF_OpenFontRW(fonts[font_id].rw, 0, font_size); Debug::check_assertion(fonts[font_id].internal_font != NULL, StringConcat() << "Cannot load font from file '" << file_name << "': " << TTF_GetError()); } return 0; }
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; }
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; }
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; }
Typeface::Typeface(const std::string& path, int pt) : Asset(path) { font = TTF_OpenFontRW(file, 0, pt); if (font == NULL) { throw std::runtime_error(TTF_GetError()); } }
void setup (void) { SDL_Surface * image; TTF_Font *temp1, *temp2; SDL_Color color; SDL_Rect rect, rect2; int g; char buffer_file[8192]; char *systemdata_path = get_systemdata_path (); /* Inicializar el Video SDL */ if (SDL_Init(SDL_INIT_VIDEO) < 0) { fprintf (stderr, _("Error: Can't initialize the video subsystem\n" "The error returned by SDL is:\n" "%s\n"), SDL_GetError()); exit (1); } sprintf (buffer_file, "%simages/icon.png", systemdata_path); image = IMG_Load (buffer_file); if (image) { SDL_WM_SetIcon (image, NULL); SDL_FreeSurface (image); } SDL_WM_SetCaption (_("Paddle Puffle"), _("Paddle Puffle")); /* Crear la pantalla de dibujado */ screen = set_video_mode (0); if (screen == NULL) { fprintf (stderr, _("Error: Can't setup 760x480 video mode.\n" "The error returned by SDL is:\n" "%s\n"), SDL_GetError()); exit (1); } use_sound = 1; if (SDL_InitSubSystem (SDL_INIT_AUDIO) < 0) { fprintf (stdout, _("Warning: Can't initialize the audio subsystem\n" "Continuing...\n")); use_sound = 0; } if (use_sound) { /* Inicializar el sonido */ if (Mix_OpenAudio (22050, AUDIO_S16, 2, 4096) < 0) { fprintf (stdout, _("Warning: Can't initialize the SDL Mixer library\n")); use_sound = 0; } } for (g = 0; g < NUM_IMAGES; g++) { sprintf (buffer_file, "%s%s", systemdata_path, images_names[g]); image = IMG_Load (buffer_file); if (image == NULL) { fprintf (stderr, _("Failed to load data file:\n" "%s\n" "The error returned by SDL is:\n" "%s\n"), buffer_file, SDL_GetError()); SDL_Quit (); exit (1); } images[g] = image; /* TODO: Mostrar la carga de porcentaje */ } /* Pre-Dibujar la pantalla gris */ grey_screen = SDL_CreateRGBSurface (SDL_SWSURFACE | SDL_SRCALPHA, 760, 480, 32, 0, 0, 0, 0); SDL_FillRect (grey_screen, NULL, SDL_MapRGB (grey_screen->format, 0, 0, 0)); /* Negro */ SDL_SetAlpha (grey_screen, SDL_SRCALPHA, 128); /* Alpha al 50 % */ if (use_sound) { for (g = 0; g < NUM_SOUNDS; g++) { sprintf (buffer_file, "%s%s", systemdata_path, sound_names[g]); sounds[g] = Mix_LoadWAV (buffer_file); if (sounds[g] == NULL) { fprintf (stderr, _("Failed to load data file:\n" "%s\n" "The error returned by SDL is:\n" "%s\n"), buffer_file, SDL_GetError ()); SDL_Quit (); exit (1); } Mix_VolumeChunk (sounds[g], MIX_MAX_VOLUME / 2); } /* Cargar la música */ sprintf (buffer_file, "%s%s", systemdata_path, MUS_CARNIE); mus_carnie = Mix_LoadMUS (buffer_file); if (mus_carnie == NULL) { fprintf (stderr, _("Failed to load data file:\n" "%s\n" "The error returned by SDL is:\n" "%s\n"), buffer_file, SDL_GetError ()); SDL_Quit (); exit (1); } } if (TTF_Init () < 0) { fprintf (stderr, _("Error: Can't initialize the SDL TTF library\n" "%s\n"), TTF_GetError ()); SDL_Quit (); exit (1); } /* Tipografias 10, 14, 16, 26 */ sprintf (buffer_file, "%s%s", systemdata_path, "ccfacefront.ttf"); ttf_facefront = SDL_RWFromFile (buffer_file, "rb"); if (ttf_facefront == NULL) { fprintf (stderr, _("Failed to load font file 'CCFaceFront'\n" "The error returned by SDL is:\n" "%s\n"), TTF_GetError ()); SDL_Quit (); exit (1); } SDL_RWseek (ttf_facefront, 0, RW_SEEK_SET); temp1 = TTF_OpenFontRW (ttf_facefront, 0, 10); SDL_RWseek (ttf_facefront, 0, RW_SEEK_SET); ttf14_normal = TTF_OpenFontRW (ttf_facefront, 0, 14); SDL_RWseek (ttf_facefront, 0, RW_SEEK_SET); ttf16_normal = TTF_OpenFontRW (ttf_facefront, 0, 16); SDL_RWseek (ttf_facefront, 0, RW_SEEK_SET); ttf26_normal = TTF_OpenFontRW (ttf_facefront, 0, 26); if (!temp1 || !ttf14_normal || !ttf16_normal || !ttf26_normal) { SDL_Quit (); exit (1); } SDL_RWseek (ttf_facefront, 0, RW_SEEK_SET); ttf20_normal = TTF_OpenFontRW (ttf_facefront, 0, 20); SDL_RWseek (ttf_facefront, 0, RW_SEEK_SET); ttf20_outline = TTF_OpenFontRW (ttf_facefront, 0, 20); SDL_RWseek (ttf_facefront, 0, RW_SEEK_SET); ttf16_outline = TTF_OpenFontRW (ttf_facefront, 1, 16); if (!ttf20_normal || !ttf20_outline || !ttf16_outline) { SDL_Quit (); exit (1); } TTF_SetFontStyle (temp1, TTF_STYLE_ITALIC); TTF_SetFontStyle (ttf14_normal, TTF_STYLE_ITALIC); TTF_SetFontStyle (ttf16_normal, TTF_STYLE_ITALIC); TTF_SetFontStyle (ttf26_normal, TTF_STYLE_ITALIC); TTF_SetFontStyle (ttf16_outline, TTF_STYLE_ITALIC); TTF_SetFontStyle (ttf20_outline, TTF_STYLE_ITALIC); TTF_SetFontStyle (ttf20_normal, TTF_STYLE_ITALIC); TTF_SetFontOutline (ttf16_outline, OUTLINE_TEXT); TTF_SetFontOutline (ttf20_outline, OUTLINE_TEXT); /* Generar textos */ bind_textdomain_codeset (PACKAGE, "UTF-8"); color.r = color.g = color.b = 0; /* Negro */ for (g = 0; g < NUM_TEXTS; g++) { switch (text_info [g]) { case 10: temp2 = temp1; break; case 14: temp2 = ttf14_normal; break; case 16: temp2 = ttf16_normal; break; case 26: temp2 = ttf26_normal; break; default: temp2 = ttf16_normal; } texts[g] = draw_text (temp2, _(text_strings[g]), &color); } /* Copiar la palabra "Tickets" en el background */ /* También copiar el nombre del juego al titulo y al fondo */ rect.x = 607 + ((135 - texts[TEXT_TICKETS]->w) / 2); rect.y = 38; rect.w = texts[TEXT_TICKETS]->w; rect.h = texts[TEXT_TICKETS]->h; rect2.x = 191; rect2.y = 96; rect2.w = images[IMG_TITLE]->w; rect2.h = images[IMG_TITLE]->h; for (g = IMG_BACKGROUND_NORMAL; g <= IMG_BACKGROUND_FAIL_1; g++) { SDL_BlitSurface (texts[TEXT_TICKETS], NULL, images[g], &rect); SDL_BlitSurface (images[IMG_TITLE], NULL, images[g], &rect2); } /* X = 84.35, Y = 50.85 */ rect2.x = 84; rect2.y = 51; SDL_BlitSurface (images[IMG_TITLE], NULL, images[IMG_TITLE_OPENING], &rect2); TTF_CloseFont (temp1); /* Generador de números aleatorios */ srand ((unsigned int) getpid ()); }
bool font_init(void) { bool error = false; // we'll be bypassing the NXSurface automatic scaling features // and drawing at the real resolution so we can get better-looking fonts. // sdl_screen = screen->GetSDLSurface(); // at 320x240 switch to bitmap fonts for better appearance #ifdef CONFIG_ENABLE_TTF if (SCALE == 1) #endif { stat("fonts: using bitmapped from %s", bmpfontfile); SDL_RWops* rwops = fileopen_SDL_RWops_RO(bmpfontfile); if (!rwops) { staterr("Couldn't open bitmap font file %s: SDL_RWFromFP: %s", bmpfontfile, SDL_GetError()); return 1; } SDL_Surface *sheet = SDL_LoadBMP_RW(rwops, 1); if (!sheet) { staterr("Couldn't open bitmap font file: SDL_LoadBMP_RW: %s", SDL_GetError()); return 1; } uint32_t fgindex = SDL_MapRGB(sheet->format, 255, 255, 255); error = error || whitefont.InitBitmapChars(sheet, fgindex, 0xffffff); error = error || greenfont.InitBitmapChars(sheet, fgindex, 0x00ff80); error = error || bluefont.InitBitmapChars(sheet, fgindex, 0xa0b5de); error = error || shadowfont.InitBitmapCharsShadowed(sheet, fgindex, 0xffffff, 0x000000); } #ifdef CONFIG_ENABLE_TTF else { // It will get size 8, 17, 26, 35, ... // Hope ot will look nice on higher resolutions int pointsize = 8 + 9 * (SCALE - 1); stat("fonts: using truetype at %dpt", pointsize); // initilize normal TTF fonts if (TTF_Init() < 0) { staterr("Couldn't initialize SDL_ttf: %s", TTF_GetError()); return 1; } TTF_Font *font = TTF_OpenFontRW(SDL_RWFromFP(fileopenRO(ttffontfile), SDL_TRUE), 1, pointsize); if (!font) { staterr("Couldn't open font: '%s'", ttffontfile); return 1; } error = error || whitefont.InitChars(font, 0xffffff); error = error || greenfont.InitChars(font, 0x00ff80); error = error || bluefont.InitChars(font, 0xa0b5de); error = error || shadowfont.InitCharsShadowed(font, 0xffffff, 0x000000); TTF_CloseFont(font); } #endif error = error || whitefont.InitTextures(); error = error || greenfont.InitTextures(); error = error || bluefont.InitTextures(); error = error || shadowfont.InitTextures(); error = error || create_shade_sfc(); if (error) return 1; fontheight = (whitefont.letters['M']->h / SCALE); initilized = true; return 0; }
int main(int argc, char ** argv) { SDL_Window * window; SDL_Renderer * renderer; KW_GUI * gui; TTF_Font * dejavu; SDL_Rect framegeom, editgeom, labelgeom, buttongeom; KW_Widget * editbx, * label, * button, * kthxbai, * frame, * buttonsframe; int hinting; /* initialize window and renderer */ SDL_Init(SDL_INIT_EVERYTHING); SDL_CreateWindowAndRenderer(320, 240, 0, &window, &renderer); SDL_SetRenderDrawColor(renderer, 118, 152, 162, 1); TTF_Init(); /* load tilesets */ setalloy = IMG_Load_RW(SDL_RWFromFile("tileset-alloy.png", "r"), SDL_TRUE); setfutter = IMG_Load_RW(SDL_RWFromFile("tileset-futterpedia.png", "r"), SDL_TRUE); setflat = IMG_Load_RW(SDL_RWFromFile("tileset-flat.png", "r"), SDL_TRUE); set = IMG_Load_RW(SDL_RWFromFile("tileset.png", "r"), SDL_TRUE); /* initialize gui */ gui = KW_Init(renderer, setfutter); fontin = TTF_OpenFontRW(SDL_RWFromFile("Fontin-Regular.ttf", "r"), SDL_TRUE, 12); sourcepro = TTF_OpenFontRW(SDL_RWFromFile("SourceSansPro-Semibold.ttf", "r"), SDL_TRUE, 12); dejavu = TTF_OpenFontRW(SDL_RWFromFile("DejaVuSans.ttf", "r"), SDL_TRUE, 11); hinting = TTF_HINTING_NONE; TTF_SetFontHinting(fontin, hinting); TTF_SetFontHinting(sourcepro, hinting); TTF_SetFontHinting(dejavu, hinting); KW_SetFont(gui, fontin); /* top frame */ framegeom.x = 10, framegeom.y = 10, framegeom.w = 300, framegeom.h = 220; frame = KW_CreateFrame(gui, NULL, &framegeom); /* buttons frame */ framegeom.x = 10, framegeom.y = 160, framegeom.w = 280, framegeom.h = 48; buttonsframe = KW_CreateFrame(gui, frame, &framegeom); /* buttons */ button = NULL; buttongeom.x = 10, buttongeom.y = 8, buttongeom.w = 32, buttongeom.h = 32; button = KW_CreateButton(gui, buttonsframe, "", &buttongeom); KW_SetWidgetTilesetSurface(button, set); KW_AddWidgetMouseDownHandler(button, SwitchNormalClicked); buttongeom.x += 290/4; button = KW_CreateButton(gui, buttonsframe, "", &buttongeom); KW_SetWidgetTilesetSurface(button, setalloy); KW_AddWidgetMouseDownHandler(button, SwitchAlloyClicked); buttongeom.x += 290/4; button = KW_CreateButton(gui, buttonsframe, "", &buttongeom); KW_SetWidgetTilesetSurface(button, setfutter); KW_AddWidgetMouseDownHandler(button, SwitchFutterClicked); buttongeom.x += 290/4; button = KW_CreateButton(gui, buttonsframe, "", &buttongeom); KW_SetWidgetTilesetSurface(button, setflat); KW_AddWidgetMouseDownHandler(button, SwitchFlatClicked); /* reset framegeom */ framegeom.x = 10, framegeom.y = 10, framegeom.w = 300, framegeom.h = 220; framegeom.w -= 20; framegeom.h = 100; /* create the editbox frames */ editgeom.x = 120, editgeom.y = 20, editgeom.w = 150, editgeom.h = 35; labelgeom.x = 10, labelgeom.y = 20, labelgeom.w = 110, labelgeom.h = 35; frame = KW_CreateFrame(gui, frame, &framegeom); editbx = KW_CreateEditbox(gui, frame, "βέβαιος (sure)", &editgeom); KW_SetEditboxFont(editbx, dejavu); label = KW_CreateLabel(gui, frame, "Can you do UTF-8?", &labelgeom); KW_SetLabelAlignment(label, KW_LABEL_ALIGN_RIGHT, 0, KW_LABEL_ALIGN_MIDDLE, 0); buttongeom = editgeom; buttongeom.y = 60; buttongeom.h -= 10; kthxbai = KW_CreateButton(gui, frame, "kthxbai", &buttongeom); KW_AddWidgetMouseDownHandler(kthxbai, kthxbaiClicked); while (!SDL_QuitRequested() && !quit) { SDL_RenderClear(renderer); KW_Paint(gui); SDL_RenderPresent(renderer); SDL_Delay(1); } /* free stuff */ KW_Quit(gui); TTF_CloseFont(fontin); TTF_CloseFont(dejavu); SDL_FreeSurface(set); SDL_FreeSurface(setalloy); SDL_FreeSurface(setflat); SDL_FreeSurface(setfutter); TTF_Quit(); SDL_Quit(); return 0; }