YourWishes/Dawn
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Loading fonts is done

Browse Source
This commit is contained in:
Dominic Masters
2023-06-10 12:01:14 -07:00
parent 1af1f9ef14
commit 86bca79768
12 changed files with 171 additions and 391 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
lib/freetype

Submodule lib/freetype updated: 562f348192...5c00a46805

89
src/dawn/asset/assets/NewTrueTypeAsset.cpp
View File

@ -115,29 +115,6 @@ void NewTrueTypeAsset::updateAsync() {
this->state = NEW_TRUE_TYPE_ASSET_STATE_INIT_FREETYPE;
int32_t ret = FT_Init_FreeType(&fontLibrary);
assertTrue(ret == 0);
// Convert to truetype faces
this->state = NEW_TRUE_TYPE_ASSET_STATE_CONVERTING_TO_FACES;
itStyle = assetStyles.begin();
while(itStyle != assetStyles.end()) {
struct NewTrueTypeAssetStyle &style = (*itStyle);
uint8_t *dataBuffer = (uint8_t*)memoryAllocate(sizeof(uint8_t) * style.dataSize);
this->loader.rewind();
this->loader.setPosition(style.dataOffset);
read = this->loader.read(dataBuffer, style.dataSize);
assertTrue(read == style.dataSize);
// Create the face
NewTrueTypeFace *face = new NewTrueTypeFace();
ret = FT_New_Memory_Face(this->fontLibrary, (FT_Byte*)dataBuffer, style.dataSize, 0, &face->face);
memoryFree(dataBuffer);
assertTrue(ret == 0);
// Push
this->faces[style.style] = face;
++itStyle;
}
// Done parsing!
this->state = NEW_TRUE_TYPE_ASSET_STATE_READY;
@ -145,33 +122,67 @@ void NewTrueTypeAsset::updateAsync() {
}
usagelockid_t NewTrueTypeAsset::lock(struct NewTrueTypeFaceTextureStyle style) {
// Try find style
auto it = this->faces.find(style.style);
assertTrue(it != this->faces.end());
assertTrue(this->state == NEW_TRUE_TYPE_ASSET_STATE_READY);
auto lock = it->second->lock(style);
this->locks[lock] = style;
// Try and find an existing texture that matches this style
auto it = this->textureByStyle.find(style);
NewTrueTypeFaceTexture *texture = nullptr;
if(it == this->textureByStyle.end()) {
// Does not exist, Find asset style
auto itAssetStyle = this->assetStyles.begin();
while(itAssetStyle != this->assetStyles.end()) {
if((*itAssetStyle).style == style.style) {
// Found
break;
}
++itAssetStyle;
}
assertTrue(itAssetStyle != this->assetStyles.end());
// Create and read buffer.
uint8_t *dataBuffer = (uint8_t*)memoryAllocate(sizeof(uint8_t) * itAssetStyle->dataSize);
this->loader.rewind();
this->loader.setPosition(itAssetStyle->dataOffset);
auto read = this->loader.read(dataBuffer, itAssetStyle->dataSize);
assertTrue(read == itAssetStyle->dataSize);
// Create the face
FT_Face face;
auto ret = FT_New_Memory_Face(this->fontLibrary, (FT_Byte*)dataBuffer, itAssetStyle->dataSize, 0, &face);
assertTrue(ret == 0);
texture = new NewTrueTypeFaceTexture(face, style);
memoryFree(dataBuffer);
this->textures.push_back(texture);
this->textureByStyle[style] = texture;
} else {
// Exists
texture = it->second;
}
auto lock = texture->locks.createLock();
this->textureByLock[lock] = texture;
return lock;
}
NewTrueTypeFaceTexture * NewTrueTypeAsset::getTexture(usagelockid_t id) {
auto existing = this->locks.find(id);
assertTrue(existing != this->locks.end());
return this->faces[existing->second.style]->getTexture(id);
auto it = this->textureByLock.find(id);
assertTrue(it != this->textureByLock.end());
return it->second;
}
void NewTrueTypeAsset::unlock(usagelockid_t id) {
auto existing = this->locks.find(id);
assertTrue(existing != this->locks.end());
this->faces[existing->second.style]->unlock(id);
this->locks.erase(existing);
auto it = this->textureByLock.find(id);
assertTrue(it != this->textureByLock.end());
it->second->locks.removeLock(id);
this->textureByLock.erase(it);
}
NewTrueTypeAsset::~NewTrueTypeAsset() {
auto it = this->faces.begin();
while(it != this->faces.end()) {
FT_Done_Face(it->second->face);
delete it->second;
auto it = this->textures.begin();
while(it != this->textures.end()) {
delete (*it);
it++;
}

17
src/dawn/asset/assets/NewTrueTypeAsset.hpp
View File

@ -7,7 +7,7 @@
#include "../Asset.hpp"
#include "../AssetLoader.hpp"
#include "util/flag.hpp"
#include "display/font/truetype/NewTrueTypeFace.hpp"
#include "display/font/truetype/NewTrueTypeFaceTexture.hpp"
namespace Dawn {
enum NewTrueTypeAssetState {
@ -19,7 +19,6 @@ namespace Dawn {
NEW_TRUE_TYPE_ASSET_STATE_READ_VARIANT,
NEW_TRUE_TYPE_ASSET_STATE_ADJUSTING_OFFSETS,
NEW_TRUE_TYPE_ASSET_STATE_INIT_FREETYPE,
NEW_TRUE_TYPE_ASSET_STATE_CONVERTING_TO_FACES,
NEW_TRUE_TYPE_ASSET_STATE_READY
};
@ -35,24 +34,18 @@ namespace Dawn {
FT_Library fontLibrary;
enum NewTrueTypeAssetState state = NEW_TRUE_TYPE_ASSET_STATE_INITIAL;
std::vector<struct NewTrueTypeAssetStyle> assetStyles;
std::map<flag_t, NewTrueTypeFace*> faces;
std::map<usagelockid_t, struct NewTrueTypeFaceTextureStyle> locks;
std::vector<NewTrueTypeFaceTexture*> textures;
std::map<usagelockid_t, NewTrueTypeFaceTexture*> textureByLock;
std::map<struct NewTrueTypeFaceTextureStyle, NewTrueTypeFaceTexture*> textureByStyle;
public:
NewTrueTypeAsset(AssetManager *assMan, std::string name);
void updateSync() override;
void updateAsync() override;
/**
* Locks a specific style for use later.
*
* @param style Style you want to lock.
* @return A unique lock ID for this style.
*/
usagelockid_t lock(struct NewTrueTypeFaceTextureStyle style);
NewTrueTypeFaceTexture * getTexture(usagelockid_t lock);
void unlock(usagelockid_t lock);
~NewTrueTypeAsset();

1
src/dawn/display/font/truetype/CMakeLists.txt
View File

@ -6,6 +6,5 @@
# Sources
target_sources(${DAWN_TARGET_NAME}
PRIVATE
NewTrueTypeFace.cpp
NewTrueTypeFaceTexture.cpp
)

57
src/dawn/display/font/truetype/NewTrueTypeFace.cpp
View File

@ -1,57 +0,0 @@
// Copyright (c) 2023 Dominic Masters
//
// This software is released under the MIT License.
// https://opensource.org/licenses/MIT
#include "asset/assets/NewTrueTypeAsset.hpp"
using namespace Dawn;
NewTrueTypeFace::NewTrueTypeFace() {
}
usagelockid_t NewTrueTypeFace::lock(struct NewTrueTypeFaceTextureStyle style) {
// Find by style
NewTrueTypeFaceTexture *texture = nullptr;
auto existing = this->texturesByStyle.find(style);
if(existing == this->texturesByStyle.end()) {
// Does not exist, create it.
texture = new NewTrueTypeFaceTexture(this, face, style);
this->textures.push_back(texture);
this->texturesByStyle[style] = texture;
} else {
texture = existing->second;
}
assertNotNull(texture);
auto lock = texture->locks.createLock();
this->locksByStyle[style].push_back(lock);
this->stylesByLock[lock] = style;
return lock;
}
NewTrueTypeFaceTexture * NewTrueTypeFace::getTexture(usagelockid_t lock) {
auto styleByLock = this->stylesByLock.find(lock);
assertTrue(styleByLock != this->stylesByLock.end());
auto texture = this->texturesByStyle.find(styleByLock->second);
assertTrue(texture != this->texturesByStyle.end());
return texture->second;
}
void NewTrueTypeFace::unlock(usagelockid_t lock) {
auto texture = this->getTexture(lock);
assertNotNull(texture);
texture->locks.removeLock(lock);
this->stylesByLock.erase(lock);
auto it = std::find(this->locksByStyle[texture->style].begin(), this->locksByStyle[texture->style].end(), lock);
assertTrue(it != this->locksByStyle[texture->style].end());
this->locksByStyle[texture->style].erase(it);
}
NewTrueTypeFace::~NewTrueTypeFace() {
auto it = this->textures.begin();
while(it != this->textures.end()) {
delete *it;
}
}

55
src/dawn/display/font/truetype/NewTrueTypeFace.hpp
View File

@ -1,55 +0,0 @@
// Copyright (c) 2023 Dominic Masters
//
// This software is released under the MIT License.
// https://opensource.org/licenses/MIT
#pragma once
#include "NewTrueTypeFaceTexture.hpp"
namespace Dawn {
class NewTrueTypeFace {
public:
std::vector<NewTrueTypeFaceTexture*> textures;
std::map<struct NewTrueTypeFaceTextureStyle, NewTrueTypeFaceTexture*> texturesByStyle;
std::map<struct NewTrueTypeFaceTextureStyle, std::vector<usagelockid_t>> locksByStyle;
std::map<usagelockid_t, struct NewTrueTypeFaceTextureStyle> stylesByLock;
FT_Face face;
/**
* Create a new TrueTypeFace object. TrueType face holds multiple textures
* of various styles of this face. This face may be "Arial Bold" and have
* a texture for "Arial Bold 12", "Arial Bold 14", etc.
*/
NewTrueTypeFace();
/**
* Locks a texture for use. This will create a new texture if one does not
* exist for the given style.
*
* @param style Style to lock.
* @return A unique lock ID for this style.
*/
usagelockid_t lock(struct NewTrueTypeFaceTextureStyle style);
/**
* Unlocks a previously created lock. If the texture becomes unused it
* will be deleted.
*
* @param lock Lock to remove.
*/
void unlock(usagelockid_t lock);
/**
* Gets a texture from a lock.
*
* @param lock Lock to get texture from.
* @return Texture from lock.
*/
NewTrueTypeFaceTexture * getTexture(usagelockid_t lock);
/**
* Destroys this TrueTypeFace object, and all textures associated with it.
*/
~NewTrueTypeFace();
};
}

32
src/dawn/display/font/truetype/NewTrueTypeFaceTexture.cpp
View File

@ -3,28 +3,25 @@
// This software is released under the MIT License.
// https://opensource.org/licenses/MIT
#include "NewTrueTypeFace.hpp"
#include "NewTrueTypeFaceTexture.hpp"
using namespace Dawn;
NewTrueTypeFaceTexture::NewTrueTypeFaceTexture(
NewTrueTypeFace *trueTypeFace,
FT_Face &face,
FT_Face face,
struct NewTrueTypeFaceTextureStyle style
) {
assertNotNull(trueTypeFace);
assertTrue(style.fontSize < 256);
this->trueTypeFace = trueTypeFace;
this->face = &face;
this->face = face;
this->style = style;
this->locks.onEmpty = [&]() {
delete this;
assertUnreachable();
};
// Set freetype font size prior to baking.
if(FT_Set_Pixel_Sizes(face, 0, this->style.fontSize)) {
if(FT_Set_Pixel_Sizes(face, 0, style.fontSize)) {
assertUnreachable();
}
@ -34,7 +31,8 @@ NewTrueTypeFaceTexture::NewTrueTypeFaceTexture(
// First pass, determine the textures' dimensions.
for(c = NEW_TRUETYPE_CHAR_BEGIN; c < NEW_TRUETYPE_CHAR_END; c++) {
// Load the character
if(FT_Load_Char(face, c, FT_LOAD_RENDER | FT_LOAD_MONOCHROME)) {
auto ret = FT_Load_Char(face, c, FT_LOAD_BITMAP_METRICS_ONLY);
if(ret) {
assertUnreachable();
}
@ -62,11 +60,15 @@ NewTrueTypeFaceTexture::NewTrueTypeFaceTexture(
}
// Store the character information
info.advanceX = face->glyph->advance.x;
info.advanceY = face->glyph->advance.y;
info.advanceX = (float_t)(face->glyph->advance.x >> 6);
info.advanceY = (float_t)(face->glyph->advance.y >> 6);
info.bitmapSize = glm::vec2(face->glyph->bitmap.width, face->glyph->bitmap.rows);
info.bitmapPosition = glm::vec2(face->glyph->bitmap_left, -face->glyph->bitmap_top);
info.textureY = y;
char c2 = (char)c;
if(c2 == 'H') {
std::cout << "H" << std::endl;
}
this->characterData[c] = info;
// Buffer the pixels, oh dear GOD there has to be a more efficient way.
@ -92,11 +94,5 @@ struct NewTrueTypeCharacter NewTrueTypeFaceTexture::getCharacterData(FT_ULong c)
}
NewTrueTypeFaceTexture::~NewTrueTypeFaceTexture() {
auto it = std::find(
this->trueTypeFace->textures.begin(),
this->trueTypeFace->textures.end(),
this
);
assertTrue(it != this->trueTypeFace->textures.end());
this->trueTypeFace->textures.erase(it);
FT_Done_Face(this->face);
}

17
src/dawn/display/font/truetype/NewTrueTypeFaceTexture.hpp
View File

@ -10,13 +10,11 @@
#include "util/UsageLock.hpp"
namespace Dawn {
class NewTrueTypeFace;
typedef uint32_t newtruetypelock_t;
class NewTrueTypeAsset;
struct NewTrueTypeCharacter {
int32_t advanceX;
int32_t advanceY;
float_t advanceX;
float_t advanceY;
glm::vec2 bitmapSize;
glm::vec2 bitmapPosition;
float_t textureY;
@ -33,8 +31,7 @@ namespace Dawn {
class NewTrueTypeFaceTexture {
public:
FT_Face *face;
NewTrueTypeFace *trueTypeFace;
FT_Face face;
std::map<FT_ULong, struct NewTrueTypeCharacter> characterData;
struct NewTrueTypeFaceTextureStyle style;
UsageLock locks;
@ -43,13 +40,11 @@ namespace Dawn {
/**
* Construct a new New True Type Face Texture object
*
* @param trueTypeFace Face that this texture belongs to.
* @param face The freetype face object.
* @param style Style that this font has, used for locking.
*/
NewTrueTypeFaceTexture(
NewTrueTypeFace *trueTypeFace,
FT_Face &face,
FT_Face face,
struct NewTrueTypeFaceTextureStyle style
);
@ -66,6 +61,6 @@ namespace Dawn {
*/
~NewTrueTypeFaceTexture();
friend class NewTrueTypeFace;
friend class NewTrueTypeAsset;
};
}

233
src/dawn/scene/components/ui/UILabelNew.cpp
View File

@ -18,16 +18,43 @@ UILabelNew::UILabelNew(SceneItem *item) :
}
void UILabelNew::rebufferQuads() {
std::cout << "Rebuffering" << std::endl;
this->mesh.createBuffers(QUAD_VERTICE_COUNT * 128, QUAD_INDICE_COUNT * 128);
auto texture = this->font->getTexture(this->fontLock);
texture.
glm::vec2 position(32, 32);
struct FontShaderBufferData fontData;
auto x = this->bufferQuads(
"Hello World",
fontData,
this->font->getTexture(this->fontLock),
position,
0,
0
);
fontData.colors[0] = COLOR_MAGENTA;
fontData.textures[0] = 0;
// fontData.colors[1] = COLOR_RED;
// fontData.textures[1] = 1;
// fontData.colors[2] = COLOR_GREEN;
// fontData.textures[2] = 2;
shaderBuffer.buffer(&fontData);
}
void UILabelNew::onStart() {
this->shaderBuffer.init();
useEffect([&]{
usagelockid_t newLock = -1;
if(font != nullptr) {
newLock = font->lock(NewTrueTypeFaceTextureStyle{
fontSize,
style
});
}
if(fontLock != -1) {
font.previous->unlock(fontLock);
fontLock = -1;
@ -35,62 +62,25 @@ void UILabelNew::onStart() {
if(font == nullptr) return;
fontLock = font->lock(NewTrueTypeFaceTextureStyle{
fontSize,
style
});
}, font);
fontLock = newLock;
this->rebufferQuads();
}, font)();
useEffect([&]{
if(font == nullptr) return;
auto newLock = font->lock(NewTrueTypeFaceTextureStyle{
fontSize,
style
});
if(fontLock != -1) {
font->unlock(fontLock);
fontLock = -1;
}
fontLock = font->lock(NewTrueTypeFaceTextureStyle{
fontSize,
style
});
}, { &fontSize, &style });
// struct FontShaderBufferData fontData;
// glm::vec2 position = glm::vec2(32, 32);
// mesh.createBuffers(QUAD_VERTICE_COUNT * 128, QUAD_INDICE_COUNT * 128);
// auto x = UILabelNew::bufferQuads(
// "Hello ",
// fontData,
// defFace,
// position,
// 0,
// 0
// );
// x += UILabelNew::bufferQuads(
// " World",
// fontData,
// defFaceItalics,
// position,
// x,
// 1
// );
// x += UILabelNew::bufferQuads(
// " How are you?",
// fontData,
// defFaceBold,
// position,
// x,
// 2
// );
// fontData.colors[0] = COLOR_MAGENTA;
// fontData.textures[0] = 0;
// fontData.colors[1] = COLOR_RED;
// fontData.textures[1] = 1;
// fontData.colors[2] = COLOR_GREEN;
// fontData.textures[2] = 2;
// shaderBuffer.buffer(&fontData);
fontLock = newLock;
this->rebufferQuads();
}, { &fontSize, &style })();
}
std::vector<struct ShaderPassItem> UILabelNew::getUIRenderPasses() {
@ -106,10 +96,11 @@ std::vector<struct ShaderPassItem> UILabelNew::getUIRenderPasses() {
item.parameterBuffers[shader->bufferUiCanvas] = &canvas->shaderBuffer;
item.parameterBuffers[shader->bufferFont] = &this->shaderBuffer;
item.renderFlags = RENDER_MANAGER_RENDER_FLAG_BLEND;
// item.textureSlots[0] = &defFace.texture;
item.textureSlots[0] = &this->font->getTexture(this->fontLock)->texture;
item.textureValues[shader->paramTexture0] = 0;
// item.textureSlots[1] = &defFaceItalics.texture;
// item.textureSlots[2] = &defFaceBold.texture;
// item.textureValues[shader->paramTexture0] = 0;
// item.textureValues[shader->paramTexture1] = 1;
// item.textureValues[shader->paramTexture2] = 2;
@ -133,115 +124,45 @@ float_t UILabelNew::getContentHeight() {
return 0;
}
// void UILabelNew::bakeTexture(
// struct UILabelFontDef &fontDef,
// FT_Face &face,
// uint32_t fontSize
// ) {
// fontDef.face = &face;
// fontDef.fontSize = fontSize;
// if(FT_Set_Pixel_Sizes(face, 0, fontSize)) {
// assertUnreachable();
// }
// size_t w = 0, h = 0;
// FT_ULong c;
// for(c = NEW_LABEL_CHAR_BEGIN; c < NEW_LABEL_CHAR_END; c++) {
// // Load the character
// if(FT_Load_Char(face, c, FT_LOAD_RENDER | FT_LOAD_MONOCHROME)) {
// assertUnreachable();
// }
// // Update the width and height
// w = mathMax<size_t>(w, face->glyph->bitmap.width);
// h += face->glyph->bitmap.rows;
// }
// assertTrue(w > 0);
// assertTrue(h > 0);
// // Now buffer pixels to the texture
// float_t y = 0;
// // I'd love to just buffer straight to the GPU, but it seems that is a bit
// // unstable right now.
// uint8_t *buffer = (uint8_t *)memoryFillWithZero(w * h * sizeof(uint8_t));
// size_t offset = 0;
// for(c = NEW_LABEL_CHAR_BEGIN; c < NEW_LABEL_CHAR_END; c++) {
// // Load the character
// if(FT_Load_Char(face, c, FT_LOAD_RENDER)) {
// assertUnreachable();
// }
// // Store the character information
// struct UILabelChar info;
// info.advanceX = face->glyph->advance.x;
// info.advanceY = face->glyph->advance.y;
// info.bitmapSize = glm::vec2(face->glyph->bitmap.width, face->glyph->bitmap.rows);
// info.bitmapPosition = glm::vec2(face->glyph->bitmap_left, -face->glyph->bitmap_top);
// info.textureY = y;
// fontDef.charStore[c] = info;
// // Buffer the pixels, oh dear GOD there has to be a more efficient way.
// for(int32_t i = 0; i < face->glyph->bitmap.rows; i++) {
// memoryCopy(
// (void *)(face->glyph->bitmap.buffer + (i * face->glyph->bitmap.width)),
// (void *)(buffer + offset),
// face->glyph->bitmap.width * sizeof(uint8_t)
// );
// offset += w * sizeof(uint8_t);
// assertTrue(offset <= (w * h * sizeof(uint8_t)));
// }
// y += face->glyph->bitmap.rows;
// }
// fontDef.texture.setSize(w, h, TEXTURE_FORMAT_R);
// fontDef.texture.buffer(buffer);
// memoryFree(buffer);
// }
// int32_t UILabelNew::bufferQuads(
// std::string text,
// struct FontShaderBufferData &bufferData,
// struct UILabelFontDef &fontDef,
// glm::vec2 &position,
// int32_t quadStart,
// int32_t partIndex
// ) {
// // Get string length
// int32_t len = text.length();
int32_t UILabelNew::bufferQuads(
std::string text,
struct FontShaderBufferData &bufferData,
struct NewTrueTypeFaceTexture *texture,
glm::vec2 &position,
int32_t quadStart,
int32_t partIndex
) {
// Get string length
int32_t len = text.length();
// glm::vec2 wh = glm::vec2(fontDef.texture.getWidth(), fontDef.texture.getHeight());
glm::vec2 wh = glm::vec2(texture->texture.getWidth(), texture->texture.getHeight());
// // For each char
// for(int32_t i = 0; i < len; i++) {
// char ch = text[i];
// int32_t j = quadStart + i;
// FT_ULong c = ch;
// auto &charInfo = fontDef.charStore[c];
// For each char
for(int32_t i = 0; i < len; i++) {
char ch = text[i];
int32_t j = quadStart + i;
FT_ULong c = ch;
auto charInfo = texture->getCharacterData(c);
// // Determine texture coordinates.
// glm::vec2 uv0 = glm::vec2(0.0f, charInfo.textureY) / wh;
// glm::vec2 uv1 = uv0 + (charInfo.bitmapSize / wh);
// Determine texture coordinates.
glm::vec2 uv0 = glm::vec2(0.0f, charInfo.textureY) / wh;
glm::vec2 uv1 = uv0 + (charInfo.bitmapSize / wh);
// // Buffer the quad.
// QuadMesh::bufferQuadMeshWithZ(&this->mesh,
// position + charInfo.bitmapPosition, uv0,
// position + charInfo.bitmapPosition + charInfo.bitmapSize, uv1,
// 0.0f,
// j * QUAD_VERTICE_COUNT, j * QUAD_INDICE_COUNT
// );
// Buffer the quad.
QuadMesh::bufferQuadMeshWithZ(&this->mesh,
position + charInfo.bitmapPosition, uv0,
position + charInfo.bitmapPosition + charInfo.bitmapSize, uv1,
0.0f,
j * QUAD_VERTICE_COUNT, j * QUAD_INDICE_COUNT
);
// // Move the current position along.
// position.x += (float_t)(charInfo.advanceX >> 6);
// position.y += (float_t)(charInfo.advanceY >> 6);
// Move the current position along.
position.x += charInfo.advanceX;
position.y += charInfo.advanceY;
// // Set the part index to the quad mappings
// bufferData.fontQuadMappings[j] = partIndex;
// }
// Set the part index to the quad mappings
bufferData.fontQuadMappings[j] = partIndex;
}
// return len;
// }
return len;
}

18
src/dawn/scene/components/ui/UILabelNew.hpp
View File

@ -35,20 +35,20 @@ namespace Dawn {
*
* @param text Text to buffer.
* @param bufferData The output quad mappings for the text.
* @param fontDef The font definition to use.
* @param texture The font texture definition to use.
* @param position The 2D position to buffer the quads at.
* @param quadStart The starting quad index.
* @param partIndex The part index to store for each quad buffered.
* @return The number of quads buffered, not the string length.
*/
// int32_t bufferQuads(
// std::string text,
// struct FontShaderBufferData &bufferData,
// struct UILabelFontDef &fontDef,
// glm::vec2 &position,
// int32_t quadStart,
// int32_t partIndex
// );
int32_t bufferQuads(
std::string text,
struct FontShaderBufferData &bufferData,
struct NewTrueTypeFaceTexture *texture,
glm::vec2 &position,
int32_t quadStart,
int32_t partIndex
);
void rebufferQuads();

32
src/dawnliminal/scenes/HelloWorldScene.hpp
View File

@ -29,36 +29,8 @@ namespace Dawn {
auto newLabel = newLabelItem->addComponent<UILabelNew>();
auto font = this->game->assetManager.get<NewTrueTypeAsset>("font_arial");
struct NewTrueTypeFaceTextureStyle style;
style.fontSize = 16;
style.style = 0;
// item = this->createSceneItem();
// auto meshRenderer = item->addComponent<MeshRenderer>();
// auto quadMeshHost = item->addComponent<QuadMeshHost>();
// auto material = item->addComponent<SimpleTexturedMaterial>();
// if(FT_New_Face(
// this->game->renderManager.getFontManager()->fontLibrary,
// "C:\\Windows\\Fonts\\Arial.ttf",
// 0,
// &face
// )) {
// assertUnreachable();
// }
// if(FT_Set_Pixel_Sizes(face, 0, 16)) {
// assertUnreachable();
// }
// _newTrueTypePlaceholder(face, texture, charStore);
// FT_ULong c = 'B';
// auto x = charStore[c];
// glm::vec2 wh = glm::vec2(texture.getWidth(), texture.getHeight());
// quadMeshHost->uv0 = glm::vec2(0.0f, x.textureY) / wh;
// quadMeshHost->uv1 = (glm::vec2)quadMeshHost->uv0 + (x.bitmapSize / wh);
// std::cout << "Done" << std::endl;
// material->texture = &texture;
newLabel->font = font;
newLabel->fontSize = 32;
}
std::vector<Asset*> getRequiredAssets() override {

9
src/dawntools/newtruetypetool/NewTrueTypeTool.cpp
View File

@ -9,12 +9,17 @@ using namespace Dawn;
NewTrueTypeFile::NewTrueTypeFile(std::string path) : file(path) {
this->path = path;
// Remove extension
size_t pos = path.find_last_of(".");
std::string filename = path.substr(0, pos);
style = 0;
if(path.find("bold") != std::string::npos) {
if(path.find("bold") != std::string::npos || filename.ends_with("bd") || filename.ends_with("bi")) {
style |= NEW_TRUETYPE_VARIANT_BOLD;
}
if(path.find("italics") != std::string::npos) {
if(path.find("italics") != std::string::npos || filename.ends_with("i") || filename.ends_with("bi")) {
style |= NEW_TRUETYPE_VARIANT_ITALICS;
}