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, 328 insertions, 395 deletions
diff --git a/src/irrlicht_changes/CGUITTFont.cpp b/src/irrlicht_changes/CGUITTFont.cpp
index 3bd6957f5..bd4e700de 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,83 +88,76 @@ video::IImage *SGUITTGlyph::createGlyphImage(
// 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;
+ 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_data += image_pitch;
+ image->unlock();
+ break;
}
- 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);
+ 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;
}
- glyph_data += bits.pitch;
+ image->unlock();
+ break;
}
- image->unlock();
- break;
- }
- default:
- // TODO: error message?
- return 0;
+ 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);
@@ -182,10 +175,11 @@ 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?
@@ -195,20 +189,17 @@ 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.
@@ -217,7 +208,8 @@ void SGUITTGlyph::preload(u32 char_index, FT_Face face, video::IVideoDriver *dri
void SGUITTGlyph::unload()
{
- if (surface) {
+ if (surface)
+ {
surface->drop();
surface = 0;
}
@@ -226,19 +218,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;
}
@@ -249,19 +241,20 @@ 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;
}
@@ -269,14 +262,12 @@ 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);
}
@@ -284,16 +275,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();
}
@@ -303,24 +294,19 @@ CGUITTFont::CGUITTFont(IGUIEnvironment *env) :
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;
@@ -331,32 +317,23 @@ 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;
@@ -369,27 +346,22 @@ 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;
@@ -397,7 +369,9 @@ 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();
@@ -414,7 +388,8 @@ 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();
@@ -438,20 +413,21 @@ 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;
}
@@ -479,18 +455,20 @@ 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;
@@ -498,10 +476,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;
@@ -510,8 +488,7 @@ 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);
@@ -526,19 +503,13 @@ 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)) {
@@ -547,11 +518,10 @@ 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;
@@ -576,17 +546,12 @@ 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();
@@ -594,7 +559,8 @@ 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();
}
@@ -604,60 +570,62 @@ 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);
@@ -665,10 +633,9 @@ 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();
@@ -683,25 +650,21 @@ 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;
@@ -712,24 +675,22 @@ 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
@@ -748,17 +709,20 @@ 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;
}
@@ -769,7 +733,8 @@ 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)
@@ -794,19 +759,18 @@ 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
@@ -817,22 +781,19 @@ 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
@@ -845,11 +806,9 @@ 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)
@@ -858,44 +817,47 @@ 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);
@@ -924,8 +886,7 @@ 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;
@@ -935,8 +896,7 @@ s32 CGUITTFont::getKerningWidth(
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;
@@ -948,21 +908,18 @@ 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);
@@ -973,15 +930,17 @@ core::vector2di CGUITTFont::getKerning(
// 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;
@@ -995,44 +954,43 @@ 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;
@@ -1054,71 +1012,60 @@ 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
@@ -1127,8 +1074,7 @@ core::array<scene::ISceneNode *> CGUITTFont::addTextSceneNode(const wchar_t *tex
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;
@@ -1137,36 +1083,39 @@ core::array<scene::ISceneNode *> CGUITTFont::addTextSceneNode(const wchar_t *tex
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;
@@ -1177,37 +1126,25 @@ core::array<scene::ISceneNode *> CGUITTFont::addTextSceneNode(const wchar_t *tex
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);
}
@@ -1218,37 +1155,33 @@ core::array<scene::ISceneNode *> CGUITTFont::addTextSceneNode(const wchar_t *tex
}
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-07-21 02:53:33 +0000