1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 generated by cgit v1.2.3 (git 2.39.1) at 2025-02-13 07:37:49 +0000 2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. 3. This notice may not be removed or altered from any source distribution. The original version of this class can be located at: http://irrlicht.suckerfreegames.com/ John Norman john@suckerfreegames.com */ #include <irrlicht.h> #include <iostream> #include "CGUITTFont.h" namespace irr { namespace gui { // Manages the FT_Face cache. struct SGUITTFace : public virtual irr::IReferenceCounted { SGUITTFace() : face_buffer(0), face_buffer_size(0) { memset((void*)&face, 0, sizeof(FT_Face)); } ~SGUITTFace() { FT_Done_Face(face); delete[] face_buffer; } FT_Face face; FT_Byte* face_buffer; FT_Long face_buffer_size; }; // Static variables. FT_Library CGUITTFont::c_library; core::map<io::path, SGUITTFace*> CGUITTFont::c_faces; bool CGUITTFont::c_libraryLoaded = false; scene::IMesh* CGUITTFont::shared_plane_ptr_ = 0; scene::SMesh CGUITTFont::shared_plane_; // /** Checks that no dimension of the FT_BitMap object is negative. If either is * negative, abort execution. */ inline void checkFontBitmapSize(const FT_Bitmap &bits) { if ((s32)bits.rows < 0 || (s32)bits.width < 0) { std::cout << "Insane font glyph size. File: " << __FILE__ << " Line " << __LINE__ << std::endl; abort(); } } video::IImage* SGUITTGlyph::createGlyphImage(const FT_Bitmap& bits, video::IVideoDriver* driver) const { // Make sure our casts to s32 in the loops below will not cause problems checkFontBitmapSize(bits); // Determine what our texture size should be. // Add 1 because textures are inclusive-exclusive. core::dimension2du d(bits.width + 1, bits.rows + 1); core::dimension2du texture_size; //core::dimension2du texture_size(bits.width + 1, bits.rows + 1); // Create and load our image now. video::IImage* image = 0; switch (bits.pixel_mode) { case FT_PIXEL_MODE_MONO: { // Create a blank image and fill it with transparent pixels. texture_size = d.getOptimalSize(true, true); image = driver->createImage(video::ECF_A1R5G5B5, texture_size); image->fill(video::SColor(0, 255, 255, 255)); // Load the monochrome data in. const u32 image_pitch = image->getPitch() / sizeof(u16); u16* image_data = (u16*)image->lock(); u8* glyph_data = bits.buffer; for (s32 y = 0; y < (s32)bits.rows; ++y) { u16* row = image_data; for (s32 x = 0; x < (s32)bits.width; ++x) { // Monochrome bitmaps store 8 pixels per byte. The left-most pixel is the bit 0x80. // So, we go through the data each bit at a time. if ((glyph_data[y * bits.pitch + (x / 8)] & (0x80 >> (x % 8))) != 0) *row = 0xFFFF; ++row; } image_data += image_pitch; } image->unlock(); break; } case FT_PIXEL_MODE_GRAY: { // Create our blank image. texture_size = d.getOptimalSize(!driver->queryFeature(video::EVDF_TEXTURE_NPOT), !driver->queryFeature(video::EVDF_TEXTURE_NSQUARE), true, 0); image = driver->createImage(video::ECF_A8R8G8B8, texture_size); image->fill(video::SColor(0, 255, 255, 255)); // Load the grayscale data in. const float gray_count = static_cast<float>(bits.num_grays); const u32 image_pitch = image->getPitch() / sizeof(u32); u32* image_data = (u32*)image->lock(); u8* glyph_data = bits.buffer; for (s32 y = 0; y < (s32)bits.rows; ++y) { u8* row = glyph_data; for (s32 x = 0; x < (s32)bits.width; ++x) { image_data[y * image_pitch + x] |= static_cast<u32>(255.0f * (static_cast<float>(*row++) / gray_count)) << 24; //data[y * image_pitch + x] |= ((u32)(*bitsdata++) << 24); } glyph_data += bits.pitch; } image->unlock(); break; } default: // TODO: error message? return 0; } return image; } void SGUITTGlyph::preload(u32 char_index, FT_Face face, video::IVideoDriver* driver, u32 font_size, const FT_Int32 loadFlags) { if (isLoaded) return; // Set the size of the glyph. FT_Set_Pixel_Sizes(face, 0, font_size); // Attempt to load the glyph. if (FT_Load_Glyph(face, char_index, loadFlags) != FT_Err_Ok) // TODO: error message? return; FT_GlyphSlot glyph = face->glyph; FT_Bitmap bits = glyph->bitmap; // Setup the glyph information here: advance = glyph->advance; offset = core::vector2di(glyph->bitmap_left, glyph->bitmap_top); // Try to get the last page with available slots. CGUITTGlyphPage* page = parent->getLastGlyphPage(); // If we need to make a new page, do that now. if (!page) { page = parent->createGlyphPage(bits.pixel_mode); if (!page) // TODO: add error message? return; } glyph_page = parent->getLastGlyphPageIndex(); u32 texture_side_length = page->texture->getOriginalSize().Width; core::vector2di page_position( (page->used_slots % (texture_side_length / font_size)) * font_size, (page->used_slots / (texture_side_length / font_size)) * font_size ); source_rect.UpperLeftCorner = page_position; source_rect.LowerRightCorner = core::vector2di(page_position.X + bits.width, page_position.Y + bits.rows); page->dirty = true; ++page->used_slots; --page->available_slots; // We grab the glyph bitmap here so the data won't be removed when the next glyph is loaded. surface = createGlyphImage(bits, driver); // Set our glyph as loaded. isLoaded = true; } void SGUITTGlyph::unload() { if (surface) { surface->drop(); surface = 0; } isLoaded = false; } ////////////////////// CGUITTFont* CGUITTFont::createTTFont(IGUIEnvironment *env, const io::path& filename, const u32 size, const bool antialias, const bool transparency, const u32 shadow, const u32 shadow_alpha) { if (!c_libraryLoaded) { if (FT_Init_FreeType(&c_library)) return 0; c_libraryLoaded = true; } CGUITTFont* font = new CGUITTFont(env); bool ret = font->load(filename, size, antialias, transparency); if (!ret) { font->drop(); return 0; } font->shadow_offset = shadow; font->shadow_alpha = shadow_alpha; return font; } CGUITTFont* CGUITTFont::createTTFont(IrrlichtDevice *device, const io::path& filename, const u32 size, const bool antialias, const bool transparency) { if (!c_libraryLoaded) { if (FT_Init_FreeType(&c_library)) return 0; c_libraryLoaded = true; } CGUITTFont* font = new CGUITTFont(device->getGUIEnvironment()); font->Device = device; bool ret = font->load(filename, size, antialias, transparency); if (!ret) { font->drop(); return 0; } return font; } CGUITTFont* CGUITTFont::create(IGUIEnvironment *env, const io::path& filename, const u32 size, const bool antialias, const bool transparency) { return CGUITTFont::createTTFont(env, filename, size, antialias, transparency); } CGUITTFont* CGUITTFont::create(IrrlichtDevice *device, const io::path& filename, const u32 size, const bool antialias, const bool transparency) { return CGUITTFont::createTTFont(device, filename, size, antialias, transparency); } ////////////////////// //! Constructor. CGUITTFont::CGUITTFont(IGUIEnvironment *env) : use_monochrome(false), use_transparency(true), use_hinting(true), use_auto_hinting(true), batch_load_size(1), Device(0), Environment(env), Driver(0), GlobalKerningWidth(0), GlobalKerningHeight(0) { #ifdef _DEBUG setDebugName("CGUITTFont"); #endif if (Environment) { // don't grab environment, to avoid circular references Driver = Environment->getVideoDriver(); } if (Driver) Driver->grab(); setInvisibleCharacters(L" "); // Glyphs aren't reference counted, so don't try to delete them when we free the array. Glyphs.set_free_when_destroyed(false); } bool CGUITTFont::load(const io::path& filename, const u32 size, const bool antialias, const bool transparency) { // Some sanity checks. if (Environment == 0 || Driver == 0) return false; if (size == 0) return false; if (filename.size() == 0) return false; io::IFileSystem* filesystem = Environment->getFileSystem(); irr::ILogger* logger = (Device != 0 ? Device->getLogger() : 0); this->size = size; this->filename = filename; // Update the font loading flags when the font is first loaded. this->use_monochrome = !antialias; this->use_transparency = transparency; update_load_flags(); // Log. if (logger) logger->log(L"CGUITTFont", core::stringw(core::stringw(L"Creating new font: ") + core::ustring(filename).toWCHAR_s() + L" " + core::stringc(size) + L"pt " + (antialias ? L"+antialias " : L"-antialias ") + (transparency ? L"+transparency" : L"-transparency")).c_str(), irr::ELL_INFORMATION); // Grab the face. SGUITTFace* face = 0; core::map<io::path, SGUITTFace*>::Node* node = c_faces.find(filename); if (node == 0) { face = new SGUITTFace(); c_faces.set(filename, face); if (filesystem) { // Read in the file data. io::IReadFile* file = filesystem->createAndOpenFile(filename); if (file == 0) { if (logger) logger->log(L"CGUITTFont", L"Failed to open the file.", irr::ELL_INFORMATION); c_faces.remove(filename); delete face; face = 0; return false; } face->face_buffer = new FT_Byte[file->getSize()]; file->read(face->face_buffer, file->getSize()); face->face_buffer_size = file->getSize(); file->drop(); // Create the face. if (FT_New_Memory_Face(c_library, face->face_buffer, face->face_buffer_size, 0, &face->face)) { if (logger) logger->log(L"CGUITTFont", L"FT_New_Memory_Face failed.", irr::ELL_INFORMATION); c_faces.remove(filename); delete face; face = 0; return false; } } else { core::ustring converter(filename); if (FT_New_Face(c_library, reinterpret_cast<const char*>(converter.toUTF8_s().c_str()), 0, &face->face)) { if (logger) logger->log(L"CGUITTFont", L"FT_New_Face failed.", irr::ELL_INFORMATION); c_faces.remove(filename); delete face; face = 0; return false; } } } else { // Using another instance of this face. face = node->getValue(); face->grab(); } // Store our face. tt_face = face->face; // Store font metrics. FT_Set_Pixel_Sizes(tt_face, size, 0); font_metrics = tt_face->size->metrics; // Allocate our glyphs. Glyphs.clear(); Glyphs.reallocate(tt_face->num_glyphs); Glyphs.set_used(tt_face->num_glyphs); for (FT_Long i = 0; i < tt_face->num_glyphs; ++i) { Glyphs[i].isLoaded = false; Glyphs[i].glyph_page = 0; Glyphs[i].source_rect = core::recti(); Glyphs[i].offset = core::vector2di(); Glyphs[i].advance = FT_Vector(); Glyphs[i].surface = 0; Glyphs[i].parent = this; } // Cache the first 127 ascii characters. u32 old_size = batch_load_size; batch_load_size = 127; getGlyphIndexByChar((uchar32_t)0); batch_load_size = old_size; return true; } CGUITTFont::~CGUITTFont() { // Delete the glyphs and glyph pages. reset_images(); CGUITTAssistDelete::Delete(Glyphs); //Glyphs.clear(); // We aren't using this face anymore. core::map<io::path, SGUITTFace*>::Node* n = c_faces.find(filename); if (n) { SGUITTFace* f = n->getValue(); // Drop our face. If this was the last face, the destructor will clean up. if (f->drop()) c_faces.remove(filename); // If there are no more faces referenced by FreeType, clean up. if (c_faces.size() == 0) { FT_Done_FreeType(c_library); c_libraryLoaded = false; } } // Drop our driver now. if (Driver) Driver->drop(); } void CGUITTFont::reset_images() { // Delete the glyphs. for (u32 i = 0; i != Glyphs.size(); ++i) Glyphs[i].unload(); // Unload the glyph pages from video memory. for (u32 i = 0; i != Glyph_Pages.size(); ++i) delete Glyph_Pages[i]; Glyph_Pages.clear(); // Always update the internal FreeType loading flags after resetting. update_load_flags(); } void CGUITTFont::update_glyph_pages() const { for (u32 i = 0; i != Glyph_Pages.size(); ++i) { if (Glyph_Pages[i]->dirty) Glyph_Pages[i]->updateTexture(); } } CGUITTGlyphPage* CGUITTFont::getLastGlyphPage() const { CGUITTGlyphPage* page = 0; if (Glyph_Pages.empty()) return 0; else { page = Glyph_Pages[getLastGlyphPageIndex()]; if (page->available_slots == 0) page = 0; } return page; } CGUITTGlyphPage* CGUITTFont::createGlyphPage(const u8& pixel_mode) { CGUITTGlyphPage* page = 0; // Name of our page. io::path name("TTFontGlyphPage_"); name += tt_face->family_name; name += "."; name += tt_face->style_name; name += "."; name += size; name += "_"; name += Glyph_Pages.size(); // The newly created page will be at the end of the collection. // Create the new page. page = new CGUITTGlyphPage(Driver, name); // Determine our maximum texture size. // If we keep getting 0, set it to 1024x1024, as that number is pretty safe. core::dimension2du max_texture_size = max_page_texture_size; if (max_texture_size.Width == 0 || max_texture_size.Height == 0) max_texture_size = Driver->getMaxTextureSize(); if (max_texture_size.Width == 0 || max_texture_size.Height == 0) max_texture_size = core::dimension2du(1024, 1024); // We want to try to put at least 144 glyphs on a single texture. core::dimension2du page_texture_size; if (size <= 21) page_texture_size = core::dimension2du(256, 256); else if (size <= 42) page_texture_size = core::dimension2du(512, 512); else if (size <= 84) page_texture_size = core::dimension2du(1024, 1024); else if (size <= 168) page_texture_size = core::dimension2du(2048, 2048); else page_texture_size = core::dimension2du(4096, 4096); if (page_texture_size.Width > max_texture_size.Width || page_texture_size.Height > max_texture_size.Height) page_texture_size = max_texture_size; if (!page->createPageTexture(pixel_mode, page_texture_size)) { // TODO: add error message? delete page; return 0; } if (page) { // Determine the number of glyph slots on the page and add it to the list of pages. page->available_slots = (page_texture_size.Width / size) * (page_texture_size.Height / size); Glyph_Pages.push_back(page); } return page; } void CGUITTFont::setTransparency(const bool flag) { use_transparency = flag; reset_images(); } void CGUITTFont::setMonochrome(const bool flag) { use_monochrome = flag; reset_images(); } void CGUITTFont::setFontHinting(const bool enable, const bool enable_auto_hinting) { use_hinting = enable; use_auto_hinting = enable_auto_hinting; reset_images(); } void CGUITTFont::draw(const core::stringw& text, const core::rect<s32>& position, video::SColor color, bool hcenter, bool vcenter, const core::rect<s32>* clip) { draw(EnrichedString(std::wstring(text.c_str()), color), position, color, hcenter, vcenter, clip); } void CGUITTFont::draw(const EnrichedString &text, const core::rect<s32>& position, video::SColor color, bool hcenter, bool vcenter, const core::rect<s32>* clip) { std::vector<video::SColor> colors = text.getColors(); if (!Driver) return; // Clear the glyph pages of their render information. for (u32 i = 0; i < Glyph_Pages.size(); ++i) { Glyph_Pages[i]->render_positions.clear(); Glyph_Pages[i]->render_source_rects.clear(); } // Set up some variables. core::dimension2d<s32> textDimension; core::position2d<s32> offset = position.UpperLeftCorner; // Determine offset positions. if (hcenter || vcenter) { textDimension = getDimension(text.c_str()); if (hcenter) offset.X = ((position.getWidth() - textDimension.Width) >> 1) + offset.X; if (vcenter) offset.Y = ((position.getHeight() - textDimension.Height) >> 1) + offset.Y; } // Convert to a unicode string. core::ustring utext = text.getString(); // Set up our render map. core::map<u32, CGUITTGlyphPage*> Render_Map; // Start parsing characters. u32 n; uchar32_t previousChar = 0; core::ustring::const_iterator iter(utext); std::vector<video::SColor> applied_colors; while (!iter.atEnd()) { uchar32_t currentChar = *iter; n = getGlyphIndexByChar(currentChar); bool visible = (Invisible.findFirst(currentChar) == -1); bool lineBreak=false; if (currentChar == L'\r') // Mac or Windows breaks { lineBreak = true; if (*(iter + 1) == (uchar32_t)'\n') // Windows line breaks. currentChar = *(++iter); } else if (currentChar == (uchar32_t)'\n') // Unix breaks { lineBreak = true; } if (lineBreak) { previousChar = 0; offset.Y += font_metrics.height / 64; offset.X = position.UpperLeftCorner.X; if (hcenter) offset.X += (position.getWidth() - textDimension.Width) >> 1; ++iter; continue; } if (n > 0 && visible) { // Calculate the glyph offset. s32 offx = Glyphs[n-1].offset.X; s32 offy = (font_metrics.ascender / 64) - Glyphs[n-1].offset.Y; // Apply kerning. core::vector2di k = getKerning(currentChar, previousChar); offset.X += k.X; offset.Y += k.Y; // Determine rendering information. SGUITTGlyph& glyph = Glyphs[n-1]; CGUITTGlyphPage* const page = Glyph_Pages[glyph.glyph_page]; page->render_positions.push_back(core::position2di(offset.X + offx, offset.Y + offy)); page->render_source_rects.push_back(glyph.source_rect); Render_Map.set(glyph.glyph_page, page); u32 current_color = iter.getPos(); if (current_color < colors.size()) applied_colors.push_back(colors[current_color]); } offset.X += getWidthFromCharacter(currentChar); previousChar = currentChar; ++iter; } // Draw now. update_glyph_pages(); core::map<u32, CGUITTGlyphPage*>::Iterator j = Render_Map.getIterator(); while (!j.atEnd()) { core::map<u32, CGUITTGlyphPage*>::Node* n = j.getNode(); j++; if (n == 0) continue; CGUITTGlyphPage* page = n->getValue(); if (shadow_offset) { for (size_t i = 0; i < page->render_positions.size(); ++i) page->render_positions[i] += core::vector2di(shadow_offset, shadow_offset); Driver->draw2DImageBatch(page->texture, page->render_positions, page->render_source_rects, clip, video::SColor(shadow_alpha,0,0,0), true); for (size_t i = 0; i < page->render_positions.size(); ++i) page->render_positions[i] -= core::vector2di(shadow_offset, shadow_offset); } for (size_t i = 0; i < page->render_positions.size(); ++i) { irr::video::SColor col; if (!applied_colors.empty()) { col = applied_colors[i < applied_colors.size() ? i : 0]; } else { col = irr::video::SColor(255, 255, 255, 255); } if (!use_transparency) col.color |= 0xff000000; Driver->draw2DImage(page->texture, page->render_positions[i], page->render_source_rects[i], clip, col, true); } } } core::dimension2d<u32> CGUITTFont::getCharDimension(const wchar_t ch) const { return core::dimension2d<u32>(getWidthFromCharacter(ch), getHeightFromCharacter(ch)); } core::dimension2d<u32> CGUITTFont::getDimension(const wchar_t* text) const { return getDimension(core::ustring(text)); } core::dimension2d<u32> CGUITTFont::getDimension(const core::ustring& text) const { // Get the maximum font height. Unfortunately, we have to do this hack as // Irrlicht will draw things wrong. In FreeType, the font size is the // maximum size for a single glyph, but that glyph may hang "under" the // draw line, increasing the total font height to beyond the set size. // Irrlicht does not understand this concept when drawing fonts. Also, I // add +1 to give it a 1 pixel blank border. This makes things like // tooltips look nicer. s32 test1 = getHeightFromCharacter((uchar32_t)'g') + 1; s32 test2 = getHeightFromCharacter((uchar32_t)'j') + 1; s32 test3 = getHeightFromCharacter((uchar32_t)'_') + 1; s32 max_font_height = core::max_(test1, core::max_(test2, test3)); core::dimension2d<u32> text_dimension(0, max_font_height); core::dimension2d<u32> line(0, max_font_height); uchar32_t previousChar = 0; core::ustring::const_iterator iter = text.begin(); for (; !iter.atEnd(); ++iter) { uchar32_t p = *iter; bool lineBreak = false; if (p == '\r') // Mac or Windows line breaks. { lineBreak = true; if (*(iter + 1) == '\n') { ++iter; p = *iter; } } else if (p == '\n') // Unix line breaks. { lineBreak = true; } // Kerning. core::vector2di k = getKerning(p, previousChar); line.Width += k.X; previousChar = p; // Check for linebreak. if (lineBreak) { previousChar = 0; text_dimension.Height += line.Height; if (text_dimension.Width < line.Width) text_dimension.Width = line.Width; line.Width = 0; line.Height = max_font_height; continue; } line.Width += getWidthFromCharacter(p); } if (text_dimension.Width < line.Width) text_dimension.Width = line.Width; return text_dimension; } inline u32 CGUITTFont::getWidthFromCharacter(wchar_t c) const { return getWidthFromCharacter((uchar32_t)c); } inline u32 CGUITTFont::getWidthFromCharacter(uchar32_t c) const { // Set the size of the face. // This is because we cache faces and the face may have been set to a different size. //FT_Set_Pixel_Sizes(tt_face, 0, size); u32 n = getGlyphIndexByChar(c); if (n > 0) { int w = Glyphs[n-1].advance.x / 64; return w; } if (c >= 0x2000) return (font_metrics.ascender / 64); else return (font_metrics.ascender / 64) / 2; } inline u32 CGUITTFont::getHeightFromCharacter(wchar_t c) const { return getHeightFromCharacter((uchar32_t)c); } inline u32 CGUITTFont::getHeightFromCharacter(uchar32_t c) const { // Set the size of the face. // This is because we cache faces and the face may have been set to a different size. //FT_Set_Pixel_Sizes(tt_face, 0, size); u32 n = getGlyphIndexByChar(c); if (n > 0) { // Grab the true height of the character, taking into account underhanging glyphs. s32 height = (font_metrics.ascender / 64) - Glyphs[n-1].offset.Y + Glyphs[n-1].source_rect.getHeight(); return height; } if (c >= 0x2000) return (font_metrics.ascender / 64); else return (font_metrics.ascender / 64) / 2; } u32 CGUITTFont::getGlyphIndexByChar(wchar_t c) const { return getGlyphIndexByChar((uchar32_t)c); } u32 CGUITTFont::getGlyphIndexByChar(uchar32_t c) const { // Get the glyph. u32 glyph = FT_Get_Char_Index(tt_face, c); // Check for a valid glyph. If it is invalid, attempt to use the replacement character. if (glyph == 0) glyph = FT_Get_Char_Index(tt_face, core::unicode::UTF_REPLACEMENT_CHARACTER); // If our glyph is already loaded, don't bother doing any batch loading code. if (glyph != 0 && Glyphs[glyph - 1].isLoaded) return glyph; // Determine our batch loading positions. u32 half_size = (batch_load_size / 2); u32 start_pos = 0; if (c > half_size) start_pos = c - half_size; u32 end_pos = start_pos + batch_load_size; // Load all our characters. do { // Get the character we are going to load. u32 char_index = FT_Get_Char_Index(tt_face, start_pos); // If the glyph hasn't been loaded yet, do it now. if (char_index) { SGUITTGlyph& glyph = Glyphs[char_index - 1]; if (!glyph.isLoaded) { glyph.preload(char_index, tt_face, Driver, size, load_flags); Glyph_Pages[glyph.glyph_page]->pushGlyphToBePaged(&glyph); } } } while (++start_pos < end_pos); // Return our original character. return glyph; } s32 CGUITTFont::getCharacterFromPos(const wchar_t* text, s32 pixel_x) const { return getCharacterFromPos(core::ustring(text), pixel_x); } s32 CGUITTFont::getCharacterFromPos(const core::ustring& text, s32 pixel_x) const { s32 x = 0; //s32 idx = 0; u32 character = 0; uchar32_t previousChar = 0; core::ustring::const_iterator iter = text.begin(); while (!iter.atEnd()) { uchar32_t c = *iter; x += getWidthFromCharacter(c); // Kerning. core::vector2di k = getKerning(c, previousChar); x += k.X; if (x >= pixel_x) return character; previousChar = c; ++iter; ++character; } return -1; } void CGUITTFont::setKerningWidth(s32 kerning) { GlobalKerningWidth = kerning; } void CGUITTFont::setKerningHeight(s32 kerning) { GlobalKerningHeight = kerning; } s32 CGUITTFont::getKerningWidth(const wchar_t* thisLetter, const wchar_t* previousLetter) const { if (tt_face == 0) return GlobalKerningWidth; if (thisLetter == 0 || previousLetter == 0) return 0; return getKerningWidth((uchar32_t)*thisLetter, (uchar32_t)*previousLetter); } s32 CGUITTFont::getKerningWidth(const uchar32_t thisLetter, const uchar32_t previousLetter) const { // Return only the kerning width. return getKerning(thisLetter, previousLetter).X; } s32 CGUITTFont::getKerningHeight() const { // FreeType 2 currently doesn't return any height kerning information. return GlobalKerningHeight; } core::vector2di CGUITTFont::getKerning(const wchar_t thisLetter, const wchar_t previousLetter) const { return getKerning((uchar32_t)thisLetter, (uchar32_t)previousLetter); } core::vector2di CGUITTFont::getKerning(const uchar32_t thisLetter, const uchar32_t previousLetter) const { if (tt_face == 0 || thisLetter == 0 || previousLetter == 0) return core::vector2di(); // Set the size of the face. // This is because we cache faces and the face may have been set to a different size. FT_Set_Pixel_Sizes(tt_face, 0, size); core::vector2di ret(GlobalKerningWidth, GlobalKerningHeight); // If we don't have kerning, no point in continuing. if (!FT_HAS_KERNING(tt_face)) return ret; // Get the kerning information. FT_Vector v; FT_Get_Kerning(tt_face, getGlyphIndexByChar(previousLetter), getGlyphIndexByChar(thisLetter), FT_KERNING_DEFAULT, &v); // If we have a scalable font, the return value will be in font points. if (FT_IS_SCALABLE(tt_face)) { // Font points, so divide by 64. ret.X += (v.x / 64); ret.Y += (v.y / 64); } else { // Pixel units. ret.X += v.x; ret.Y += v.y; } return ret; } void CGUITTFont::setInvisibleCharacters(const wchar_t *s) { core::ustring us(s); Invisible = us; } void CGUITTFont::setInvisibleCharacters(const core::ustring& s) { Invisible = s; } video::IImage* CGUITTFont::createTextureFromChar(const uchar32_t& ch) { u32 n = getGlyphIndexByChar(ch); const SGUITTGlyph& glyph = Glyphs[n-1]; CGUITTGlyphPage* page = Glyph_Pages[glyph.glyph_page]; if (page->dirty) page->updateTexture(); video::ITexture* tex = page->texture; // Acquire a read-only lock of the corresponding page texture. #if IRRLICHT_VERSION_MAJOR==1 && IRRLICHT_VERSION_MINOR>=8 void* ptr = tex->lock(video::ETLM_READ_ONLY); #else void* ptr = tex->lock(true); #endif video::ECOLOR_FORMAT format = tex->getColorFormat(); core::dimension2du tex_size = tex->getOriginalSize(); video::IImage* pageholder = Driver->createImageFromData(format, tex_size, ptr, true, false); // Copy the image data out of the page texture. core::dimension2du glyph_size(glyph.source_rect.getSize()); video::IImage* image = Driver->createImage(format, glyph_size); pageholder->copyTo(image, core::position2di(0, 0), glyph.source_rect); tex->unlock(); return image; } video::ITexture* CGUITTFont::getPageTextureByIndex(const u32& page_index) const { if (page_index < Glyph_Pages.size()) return Glyph_Pages[page_index]->texture; else return 0; } void CGUITTFont::createSharedPlane() { /* 2___3 | /| | / | <-- plane mesh is like this, point 2 is (0,0), point 0 is (0, -1) |/ | <-- the texture coords of point 2 is (0,0, point 0 is (0, 1) 0---1 */ using namespace core; using namespace video; using namespace scene; S3DVertex vertices[4]; u16 indices[6] = {0,2,3,3,1,0}; vertices[0] = S3DVertex(vector3df(0,-1,0), vector3df(0,0,-1), SColor(255,255,255,255), vector2df(0,1)); vertices[1] = S3DVertex(vector3df(1,-1,0), vector3df(0,0,-1), SColor(255,255,255,255), vector2df(1,1)); vertices[2] = S3DVertex(vector3df(0, 0,0), vector3df(0,0,-1), SColor(255,255,255,255), vector2df(0,0)); vertices[3] = S3DVertex(vector3df(1, 0,0), vector3df(0,0,-1), SColor(255,255,255,255), vector2df(1,0)); SMeshBuffer* buf = new SMeshBuffer(); buf->append(vertices, 4, indices, 6); shared_plane_.addMeshBuffer( buf ); shared_plane_ptr_ = &shared_plane_; buf->drop(); //the addMeshBuffer method will grab it, so we can drop this ptr. } core::dimension2d<u32> CGUITTFont::getDimensionUntilEndOfLine(const wchar_t* p) const { core::stringw s; for (const wchar_t* temp = p; temp && *temp != '\0' && *temp != L'\r' && *temp != L'\n'; ++temp ) s.append(*temp); return getDimension(s.c_str()); } core::array<scene::ISceneNode*> CGUITTFont::addTextSceneNode(const wchar_t* text, scene::ISceneManager* smgr, scene::ISceneNode* parent, const video::SColor& color, bool center) { using namespace core; using namespace video; using namespace scene; array<scene::ISceneNode*> container; if (!Driver || !smgr) return container; if (!parent) parent = smgr->addEmptySceneNode(smgr->getRootSceneNode(), -1); // if you don't specify parent, then we add a empty node attached to the root node // this is generally undesirable. if (!shared_plane_ptr_) //this points to a static mesh that contains the plane createSharedPlane(); //if it's not initialized, we create one. dimension2d<s32> text_size(getDimension(text)); //convert from unsigned to signed. vector3df start_point(0, 0, 0), offset; /** NOTICE: Because we are considering adding texts into 3D world, all Y axis vectors are inverted. **/ // There's currently no "vertical center" concept when you apply text scene node to the 3D world. if (center) { offset.X = start_point.X = -text_size.Width / 2.f; offset.Y = start_point.Y = +text_size.Height/ 2.f; offset.X += (text_size.Width - getDimensionUntilEndOfLine(text).Width) >> 1; } // the default font material SMaterial mat; mat.setFlag(video::EMF_LIGHTING, true); mat.setFlag(video::EMF_ZWRITE_ENABLE, false); mat.setFlag(video::EMF_NORMALIZE_NORMALS, true); mat.ColorMaterial = video::ECM_NONE; mat.MaterialType = use_transparency ? video::EMT_TRANSPARENT_ALPHA_CHANNEL : video::EMT_SOLID; mat.MaterialTypeParam = 0.01f; mat.DiffuseColor = color; wchar_t current_char = 0, previous_char = 0; u32 n = 0; array<u32> glyph_indices; while (*text) { current_char = *text; bool line_break=false; if (current_char == L'\r') // Mac or Windows breaks { line_break = true; if (*(text + 1) == L'\n') // Windows line breaks. current_char = *(++text); } else if (current_char == L'\n') // Unix breaks { line_break = true; } if (line_break) { previous_char = 0; offset.Y -= tt_face->size->metrics.ascender / 64; offset.X = start_point.X; if (center) offset.X += (text_size.Width - getDimensionUntilEndOfLine(text+1).Width) >> 1; ++text; } else { n = getGlyphIndexByChar(current_char); if (n > 0) { glyph_indices.push_back( n ); // Store glyph size and offset informations. SGUITTGlyph const& glyph = Glyphs[n-1]; u32 texw = glyph.source_rect.getWidth(); u32 texh = glyph.source_rect.getHeight(); s32 offx = glyph.offset.X; s32 offy = (font_metrics.ascender / 64) - glyph.offset.Y; // Apply kerning. vector2di k = getKerning(current_char, previous_char); offset.X += k.X; offset.Y += k.Y; vector3df current_pos(offset.X + offx, offset.Y - offy, 0); dimension2d<u32> letter_size = dimension2d<u32>(texw, texh); // Now we copy planes corresponding to the letter size. IMeshManipulator* mani = smgr->getMeshManipulator(); IMesh* meshcopy = mani->createMeshCopy(shared_plane_ptr_); #if IRRLICHT_VERSION_MAJOR==1 && IRRLICHT_VERSION_MINOR>=8 mani->scale(meshcopy, vector3df((f32)letter_size.Width, (f32)letter_size.Height, 1)); #else mani->scaleMesh(meshcopy, vector3df((f32)letter_size.Width, (f32)letter_size.Height, 1)); #endif ISceneNode* current_node = smgr->addMeshSceneNode(meshcopy, parent, -1, current_pos); meshcopy->drop(); current_node->getMaterial(0) = mat; current_node->setAutomaticCulling(EAC_OFF); current_node->setIsDebugObject(true); //so the picking won't have any effect on individual letter //current_node->setDebugDataVisible(EDS_BBOX); //de-comment this when debugging container.push_back(current_node); } offset.X += getWidthFromCharacter(current_char); previous_char = current_char; ++text; } } update_glyph_pages(); //only after we update the textures can we use the glyph page textures. for (u32 i = 0; i < glyph_indices.size(); ++i) { u32 n = glyph_indices[i]; SGUITTGlyph const& glyph = Glyphs[n-1]; ITexture* current_tex = Glyph_Pages[glyph.glyph_page]->texture; f32 page_texture_size = (f32)current_tex->getSize().Width; //Now we calculate the UV position according to the texture size and the source rect. // // 2___3 // | /| // | / | <-- plane mesh is like this, point 2 is (0,0), point 0 is (0, -1) // |/ | <-- the texture coords of point 2 is (0,0, point 0 is (0, 1) // 0---1 // f32 u1 = glyph.source_rect.UpperLeftCorner.X / page_texture_size; f32 u2 = u1 + (glyph.source_rect.getWidth() / page_texture_size); f32 v1 = glyph.source_rect.UpperLeftCorner.Y / page_texture_size; f32 v2 = v1 + (glyph.source_rect.getHeight() / page_texture_size); //we can be quite sure that this is IMeshSceneNode, because we just added them in the above loop. IMeshSceneNode* node = static_cast<IMeshSceneNode*>(container[i]); S3DVertex* pv = static_cast<S3DVertex*>(node->getMesh()->getMeshBuffer(0)->getVertices()); //pv[0].TCoords.Y = pv[1].TCoords.Y = (letter_size.Height - 1) / static_cast<f32>(letter_size.Height); //pv[1].TCoords.X = pv[3].TCoords.X = (letter_size.Width - 1) / static_cast<f32>(letter_size.Width); pv[0].TCoords = vector2df(u1, v2); pv[1].TCoords = vector2df(u2, v2); pv[2].TCoords = vector2df(u1, v1); pv[3].TCoords = vector2df(u2, v1); container[i]->getMaterial(0).setTexture(0, current_tex); } return container; } } // end namespace gui } // end namespace irr |