aboutsummaryrefslogtreecommitdiff
path: root/src/irrlicht_changes/CGUITTFont.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'src/irrlicht_changes/CGUITTFont.cpp')
-rw-r--r--src/irrlicht_changes/CGUITTFont.cpp723
1 files changed, 395 insertions, 328 deletions
diff --git a/src/irrlicht_changes/CGUITTFont.cpp b/src/irrlicht_changes/CGUITTFont.cpp
index bd4e700de..3bd6957f5 100644
--- a/src/irrlicht_changes/CGUITTFont.cpp
+++ b/src/irrlicht_changes/CGUITTFont.cpp
@@ -43,7 +43,7 @@ struct SGUITTFace : public virtual irr::IReferenceCounted
{
SGUITTFace() : face_buffer(0), face_buffer_size(0)
{
- memset((void*)&face, 0, sizeof(FT_Face));
+ memset((void *)&face, 0, sizeof(FT_Face));
}
~SGUITTFace()
@@ -53,15 +53,15 @@ struct SGUITTFace : public virtual irr::IReferenceCounted
}
FT_Face face;
- FT_Byte* face_buffer;
+ FT_Byte *face_buffer;
FT_Long face_buffer_size;
};
// Static variables.
FT_Library CGUITTFont::c_library;
-core::map<io::path, SGUITTFace*> CGUITTFont::c_faces;
+core::map<io::path, SGUITTFace *> CGUITTFont::c_faces;
bool CGUITTFont::c_libraryLoaded = false;
-scene::IMesh* CGUITTFont::shared_plane_ptr_ = 0;
+scene::IMesh *CGUITTFont::shared_plane_ptr_ = 0;
scene::SMesh CGUITTFont::shared_plane_;
//
@@ -72,14 +72,14 @@ scene::SMesh CGUITTFont::shared_plane_;
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;
+ 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
+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);
@@ -88,76 +88,83 @@ video::IImage* SGUITTGlyph::createGlyphImage(const FT_Bitmap& bits, video::IVide
// 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);
+ // 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;
+ 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->unlock();
- break;
+ 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;
+ 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);
}
- image->unlock();
- break;
+ glyph_data += bits.pitch;
}
- default:
- // TODO: error message?
- return 0;
+ 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)
+void SGUITTGlyph::preload(u32 char_index, FT_Face face, video::IVideoDriver *driver,
+ u32 font_size, const FT_Int32 loadFlags)
{
- if (isLoaded) return;
+ if (isLoaded)
+ return;
// Set the size of the glyph.
FT_Set_Pixel_Sizes(face, 0, font_size);
@@ -175,11 +182,10 @@ void SGUITTGlyph::preload(u32 char_index, FT_Face face, video::IVideoDriver* dri
offset = core::vector2di(glyph->bitmap_left, glyph->bitmap_top);
// Try to get the last page with available slots.
- CGUITTGlyphPage* page = parent->getLastGlyphPage();
+ CGUITTGlyphPage *page = parent->getLastGlyphPage();
// If we need to make a new page, do that now.
- if (!page)
- {
+ if (!page) {
page = parent->createGlyphPage(bits.pixel_mode);
if (!page)
// TODO: add error message?
@@ -189,17 +195,20 @@ void SGUITTGlyph::preload(u32 char_index, FT_Face face, video::IVideoDriver* dri
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
- );
+ (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);
+ 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.
+ // 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.
@@ -208,8 +217,7 @@ void SGUITTGlyph::preload(u32 char_index, FT_Face face, video::IVideoDriver* dri
void SGUITTGlyph::unload()
{
- if (surface)
- {
+ if (surface) {
surface->drop();
surface = 0;
}
@@ -218,19 +226,19 @@ void SGUITTGlyph::unload()
//////////////////////
-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)
+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 (!c_libraryLoaded) {
if (FT_Init_FreeType(&c_library))
return 0;
c_libraryLoaded = true;
}
- CGUITTFont* font = new CGUITTFont(env);
+ CGUITTFont *font = new CGUITTFont(env);
bool ret = font->load(filename, size, antialias, transparency);
- if (!ret)
- {
+ if (!ret) {
font->drop();
return 0;
}
@@ -241,20 +249,19 @@ CGUITTFont* CGUITTFont::createTTFont(IGUIEnvironment *env, const io::path& filen
return font;
}
-CGUITTFont* CGUITTFont::createTTFont(IrrlichtDevice *device, const io::path& filename, const u32 size, const bool antialias, const bool transparency)
+CGUITTFont *CGUITTFont::createTTFont(IrrlichtDevice *device, const io::path &filename,
+ const u32 size, const bool antialias, const bool transparency)
{
- if (!c_libraryLoaded)
- {
+ if (!c_libraryLoaded) {
if (FT_Init_FreeType(&c_library))
return 0;
c_libraryLoaded = true;
}
- CGUITTFont* font = new CGUITTFont(device->getGUIEnvironment());
+ CGUITTFont *font = new CGUITTFont(device->getGUIEnvironment());
font->Device = device;
bool ret = font->load(filename, size, antialias, transparency);
- if (!ret)
- {
+ if (!ret) {
font->drop();
return 0;
}
@@ -262,12 +269,14 @@ CGUITTFont* CGUITTFont::createTTFont(IrrlichtDevice *device, const io::path& fil
return font;
}
-CGUITTFont* CGUITTFont::create(IGUIEnvironment *env, const io::path& filename, const u32 size, const bool antialias, const bool transparency)
+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)
+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);
}
@@ -275,16 +284,16 @@ CGUITTFont* CGUITTFont::create(IrrlichtDevice *device, const io::path& filename,
//////////////////////
//! 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)
+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
+#ifdef _DEBUG
setDebugName("CGUITTFont");
- #endif
+#endif
- if (Environment)
- {
+ if (Environment) {
// don't grab environment, to avoid circular references
Driver = Environment->getVideoDriver();
}
@@ -294,19 +303,24 @@ batch_load_size(1), Device(0), Environment(env), Driver(0), GlobalKerningWidth(0
setInvisibleCharacters(L" ");
- // Glyphs aren't reference counted, so don't try to delete them when we free the array.
+ // 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)
+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);
+ 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;
@@ -317,23 +331,32 @@ bool CGUITTFont::load(const io::path& filename, const u32 size, const bool antia
// 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);
+ 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)
- {
+ 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)
- {
+ 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);
+ 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;
@@ -346,22 +369,27 @@ bool CGUITTFont::load(const io::path& filename, const u32 size, const bool antia
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);
+ 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
- {
+ } 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);
+ 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;
@@ -369,9 +397,7 @@ bool CGUITTFont::load(const io::path& filename, const u32 size, const bool antia
return false;
}
}
- }
- else
- {
+ } else {
// Using another instance of this face.
face = node->getValue();
face->grab();
@@ -388,8 +414,7 @@ bool CGUITTFont::load(const io::path& filename, const u32 size, const bool antia
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)
- {
+ 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();
@@ -413,21 +438,20 @@ CGUITTFont::~CGUITTFont()
// Delete the glyphs and glyph pages.
reset_images();
CGUITTAssistDelete::Delete(Glyphs);
- //Glyphs.clear();
+ // 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();
+ 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.
+ // 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)
- {
+ if (c_faces.size() == 0) {
FT_Done_FreeType(c_library);
c_libraryLoaded = false;
}
@@ -455,20 +479,18 @@ void CGUITTFont::reset_images()
void CGUITTFont::update_glyph_pages() const
{
- for (u32 i = 0; i != Glyph_Pages.size(); ++i)
- {
+ for (u32 i = 0; i != Glyph_Pages.size(); ++i) {
if (Glyph_Pages[i]->dirty)
Glyph_Pages[i]->updateTexture();
}
}
-CGUITTGlyphPage* CGUITTFont::getLastGlyphPage() const
+CGUITTGlyphPage *CGUITTFont::getLastGlyphPage() const
{
- CGUITTGlyphPage* page = 0;
+ CGUITTGlyphPage *page = 0;
if (Glyph_Pages.empty())
return 0;
- else
- {
+ else {
page = Glyph_Pages[getLastGlyphPageIndex()];
if (page->available_slots == 0)
page = 0;
@@ -476,10 +498,10 @@ CGUITTGlyphPage* CGUITTFont::getLastGlyphPage() const
return page;
}
-CGUITTGlyphPage* CGUITTFont::createGlyphPage(const u8& pixel_mode)
+CGUITTGlyphPage *CGUITTFont::createGlyphPage(const u8 &pixel_mode)
{
- CGUITTGlyphPage* page = 0;
-
+ CGUITTGlyphPage *page = 0;
+
// Name of our page.
io::path name("TTFontGlyphPage_");
name += tt_face->family_name;
@@ -488,7 +510,8 @@ CGUITTGlyphPage* CGUITTFont::createGlyphPage(const u8& pixel_mode)
name += ".";
name += size;
name += "_";
- name += Glyph_Pages.size(); // The newly created page will be at the end of the collection.
+ 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);
@@ -503,13 +526,19 @@ CGUITTGlyphPage* CGUITTFont::createGlyphPage(const u8& pixel_mode)
// 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 (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)
+ 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)) {
@@ -518,10 +547,11 @@ CGUITTGlyphPage* CGUITTFont::createGlyphPage(const u8& pixel_mode)
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);
+ 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;
@@ -546,12 +576,17 @@ void CGUITTFont::setFontHinting(const bool enable, const bool enable_auto_hintin
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)
+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);
+ 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)
+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();
@@ -559,8 +594,7 @@ void CGUITTFont::draw(const EnrichedString &text, const core::rect<s32>& positio
return;
// Clear the glyph pages of their render information.
- for (u32 i = 0; i < Glyph_Pages.size(); ++i)
- {
+ for (u32 i = 0; i < Glyph_Pages.size(); ++i) {
Glyph_Pages[i]->render_positions.clear();
Glyph_Pages[i]->render_source_rects.clear();
}
@@ -570,62 +604,60 @@ void CGUITTFont::draw(const EnrichedString &text, const core::rect<s32>& positio
core::position2d<s32> offset = position.UpperLeftCorner;
// Determine offset positions.
- if (hcenter || vcenter)
- {
+ if (hcenter || vcenter) {
textDimension = getDimension(text.c_str());
if (hcenter)
- offset.X = ((position.getWidth() - textDimension.Width) >> 1) + offset.X;
+ offset.X = ((position.getWidth() - textDimension.Width) >> 1) +
+ offset.X;
if (vcenter)
- offset.Y = ((position.getHeight() - textDimension.Height) >> 1) + offset.Y;
+ 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;
+ 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())
- {
+ while (!iter.atEnd()) {
uchar32_t currentChar = *iter;
n = getGlyphIndexByChar(currentChar);
bool visible = (Invisible.findFirst(currentChar) == -1);
- bool lineBreak=false;
+ bool lineBreak = false;
if (currentChar == L'\r') // Mac or Windows breaks
{
lineBreak = true;
- if (*(iter + 1) == (uchar32_t)'\n') // Windows line breaks.
+ if (*(iter + 1) == (uchar32_t)'\n') // Windows line breaks.
currentChar = *(++iter);
- }
- else if (currentChar == (uchar32_t)'\n') // Unix breaks
+ } else if (currentChar == (uchar32_t)'\n') // Unix breaks
{
lineBreak = true;
}
- if (lineBreak)
- {
+ if (lineBreak) {
previousChar = 0;
offset.Y += font_metrics.height / 64;
offset.X = position.UpperLeftCorner.X;
if (hcenter)
- offset.X += (position.getWidth() - textDimension.Width) >> 1;
+ offset.X += (position.getWidth() - textDimension.Width) >>
+ 1;
++iter;
continue;
}
- if (n > 0 && visible)
- {
+ 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;
+ 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);
@@ -633,9 +665,10 @@ void CGUITTFont::draw(const EnrichedString &text, const core::rect<s32>& positio
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));
+ 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();
@@ -650,21 +683,25 @@ void CGUITTFont::draw(const EnrichedString &text, const core::rect<s32>& positio
// 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();
+ 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;
+ if (n == 0)
+ continue;
- CGUITTGlyphPage* page = n->getValue();
+ 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);
+ 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);
+ 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;
@@ -675,22 +712,24 @@ void CGUITTFont::draw(const EnrichedString &text, const core::rect<s32>& positio
}
if (!use_transparency)
col.color |= 0xff000000;
- Driver->draw2DImage(page->texture, page->render_positions[i], page->render_source_rects[i], clip, col, true);
+ 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));
+ return core::dimension2d<u32>(
+ getWidthFromCharacter(ch), getHeightFromCharacter(ch));
}
-core::dimension2d<u32> CGUITTFont::getDimension(const wchar_t* text) const
+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
+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
@@ -709,20 +748,17 @@ core::dimension2d<u32> CGUITTFont::getDimension(const core::ustring& text) const
uchar32_t previousChar = 0;
core::ustring::const_iterator iter = text.begin();
- for (; !iter.atEnd(); ++iter)
- {
+ for (; !iter.atEnd(); ++iter) {
uchar32_t p = *iter;
bool lineBreak = false;
- if (p == '\r') // Mac or Windows line breaks.
+ if (p == '\r') // Mac or Windows line breaks.
{
lineBreak = true;
- if (*(iter + 1) == '\n')
- {
+ if (*(iter + 1) == '\n') {
++iter;
p = *iter;
}
- }
- else if (p == '\n') // Unix line breaks.
+ } else if (p == '\n') // Unix line breaks.
{
lineBreak = true;
}
@@ -733,8 +769,7 @@ core::dimension2d<u32> CGUITTFont::getDimension(const core::ustring& text) const
previousChar = p;
// Check for linebreak.
- if (lineBreak)
- {
+ if (lineBreak) {
previousChar = 0;
text_dimension.Height += line.Height;
if (text_dimension.Width < line.Width)
@@ -759,18 +794,19 @@ inline u32 CGUITTFont::getWidthFromCharacter(wchar_t c) const
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);
+ // 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;
+ 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;
+ else
+ return (font_metrics.ascender / 64) / 2;
}
inline u32 CGUITTFont::getHeightFromCharacter(wchar_t c) const
@@ -781,19 +817,22 @@ inline u32 CGUITTFont::getHeightFromCharacter(wchar_t c) const
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);
+ // 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();
+ 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;
+ else
+ return (font_metrics.ascender / 64) / 2;
}
u32 CGUITTFont::getGlyphIndexByChar(wchar_t c) const
@@ -806,9 +845,11 @@ 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.
+ // 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);
+ 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)
@@ -817,47 +858,44 @@ u32 CGUITTFont::getGlyphIndexByChar(uchar32_t c) const
// 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;
+ if (c > half_size)
+ start_pos = c - half_size;
u32 end_pos = start_pos + batch_load_size;
// Load all our characters.
- do
- {
+ 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);
+ 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);
+ } while (++start_pos < end_pos);
// Return our original character.
return glyph;
}
-s32 CGUITTFont::getCharacterFromPos(const wchar_t* text, s32 pixel_x) const
+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 CGUITTFont::getCharacterFromPos(const core::ustring &text, s32 pixel_x) const
{
s32 x = 0;
- //s32 idx = 0;
+ // s32 idx = 0;
u32 character = 0;
uchar32_t previousChar = 0;
core::ustring::const_iterator iter = text.begin();
- while (!iter.atEnd())
- {
+ while (!iter.atEnd()) {
uchar32_t c = *iter;
x += getWidthFromCharacter(c);
@@ -886,7 +924,8 @@ void CGUITTFont::setKerningHeight(s32 kerning)
GlobalKerningHeight = kerning;
}
-s32 CGUITTFont::getKerningWidth(const wchar_t* thisLetter, const wchar_t* previousLetter) const
+s32 CGUITTFont::getKerningWidth(
+ const wchar_t *thisLetter, const wchar_t *previousLetter) const
{
if (tt_face == 0)
return GlobalKerningWidth;
@@ -896,7 +935,8 @@ s32 CGUITTFont::getKerningWidth(const wchar_t* thisLetter, const wchar_t* previo
return getKerningWidth((uchar32_t)*thisLetter, (uchar32_t)*previousLetter);
}
-s32 CGUITTFont::getKerningWidth(const uchar32_t thisLetter, const uchar32_t previousLetter) const
+s32 CGUITTFont::getKerningWidth(
+ const uchar32_t thisLetter, const uchar32_t previousLetter) const
{
// Return only the kerning width.
return getKerning(thisLetter, previousLetter).X;
@@ -908,18 +948,21 @@ s32 CGUITTFont::getKerningHeight() const
return GlobalKerningHeight;
}
-core::vector2di CGUITTFont::getKerning(const wchar_t thisLetter, const wchar_t previousLetter) const
+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
+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.
+ // 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);
@@ -930,17 +973,15 @@ core::vector2di CGUITTFont::getKerning(const uchar32_t thisLetter, const uchar32
// Get the kerning information.
FT_Vector v;
- FT_Get_Kerning(tt_face, getGlyphIndexByChar(previousLetter), getGlyphIndexByChar(thisLetter), FT_KERNING_DEFAULT, &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))
- {
+ if (FT_IS_SCALABLE(tt_face)) {
// Font points, so divide by 64.
ret.X += (v.x / 64);
ret.Y += (v.y / 64);
- }
- else
- {
+ } else {
// Pixel units.
ret.X += v.x;
ret.Y += v.y;
@@ -954,43 +995,44 @@ void CGUITTFont::setInvisibleCharacters(const wchar_t *s)
Invisible = us;
}
-void CGUITTFont::setInvisibleCharacters(const core::ustring& s)
+void CGUITTFont::setInvisibleCharacters(const core::ustring &s)
{
Invisible = s;
}
-video::IImage* CGUITTFont::createTextureFromChar(const uchar32_t& ch)
+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];
+ const SGUITTGlyph &glyph = Glyphs[n - 1];
+ CGUITTGlyphPage *page = Glyph_Pages[glyph.glyph_page];
if (page->dirty)
page->updateTexture();
- video::ITexture* tex = page->texture;
+ 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
+// 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);
+ 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);
+ 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
+video::ITexture *CGUITTFont::getPageTextureByIndex(const u32 &page_index) const
{
if (page_index < Glyph_Pages.size())
return Glyph_Pages[page_index]->texture;
@@ -1012,60 +1054,71 @@ void CGUITTFont::createSharedPlane()
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();
+ 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_.addMeshBuffer(buf);
shared_plane_ptr_ = &shared_plane_;
- buf->drop(); //the addMeshBuffer method will grab it, so we can drop this ptr.
+ 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::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 )
+ 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)
+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;
+ array<scene::ISceneNode *> container;
- if (!Driver || !smgr) return 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.
+ 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.
+ 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.
+ 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)
- {
+ // 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;
+ offset.Y = start_point.Y = +text_size.Height / 2.f;
+ offset.X += (text_size.Width - getDimensionUntilEndOfLine(text).Width) >>
+ 1;
}
// the default font material
@@ -1074,7 +1127,8 @@ core::array<scene::ISceneNode*> CGUITTFont::addTextSceneNode(const wchar_t* text
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.MaterialType = use_transparency ? video::EMT_TRANSPARENT_ALPHA_CHANNEL
+ : video::EMT_SOLID;
mat.MaterialTypeParam = 0.01f;
mat.DiffuseColor = color;
@@ -1083,39 +1137,36 @@ core::array<scene::ISceneNode*> CGUITTFont::addTextSceneNode(const wchar_t* text
array<u32> glyph_indices;
- while (*text)
- {
+ while (*text) {
current_char = *text;
- bool line_break=false;
+ 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
+ } else if (current_char == L'\n') // Unix breaks
{
line_break = true;
}
- if (line_break)
- {
+ 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;
+ offset.X += (text_size.Width - getDimensionUntilEndOfLine(
+ text + 1)
+ .Width) >>
+ 1;
++text;
- }
- else
- {
+ } else {
n = getGlyphIndexByChar(current_char);
- if (n > 0)
- {
- glyph_indices.push_back( n );
+ if (n > 0) {
+ glyph_indices.push_back(n);
// Store glyph size and offset informations.
- SGUITTGlyph const& glyph = Glyphs[n-1];
+ SGUITTGlyph const &glyph = Glyphs[n - 1];
u32 texw = glyph.source_rect.getWidth();
u32 texh = glyph.source_rect.getHeight();
s32 offx = glyph.offset.X;
@@ -1126,25 +1177,37 @@ core::array<scene::ISceneNode*> CGUITTFont::addTextSceneNode(const wchar_t* text
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);
+ 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);
+ 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
+ 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);
}
@@ -1155,33 +1218,37 @@ core::array<scene::ISceneNode*> CGUITTFont::addTextSceneNode(const wchar_t* text
}
update_glyph_pages();
- //only after we update the textures can we use the glyph page textures.
+ // only after we update the textures can we use the glyph page textures.
- for (u32 i = 0; i < glyph_indices.size(); ++i)
- {
+ 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;
+ 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.
+ // 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
+ // | / | <-- 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]);
+ // 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);
+ 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);
generated by cgit v1.2.3 (git 2.39.1) at 2025-08-01 19:29:11 +0000