tobid7/palladium
1
0
Fork 0
Code Issues 6 Pull Requests Actions Packages Projects Releases Wiki Activity
d5c01b2988
palladium/source/Lithium.cpp
tobid7 d5c01b2988 - Linear Tex filter for TTF fonts 
- Format Code
2024-12-08 19:26:21 +01:00

789 lines
25 KiB
C++
Raw Blame History

#include <pd/external/stb_truetype.h>
#include <algorithm>
#include <cmath>
#include <codecvt>
#include <filesystem>
#include <fstream>
#include <pd/Lithium.hpp>
#include <pd/base/Color.hpp>
#include <pd/li7_shader.hpp>
#include <pd/palladium.hpp>
#ifndef MAX
#define MAX(a, b) ((a) > (b) ? (a) : (b))
#endif
std::wstring make_wstring(const std::string& str) {
std::wstring_convert<std::codecvt_utf8<wchar_t>, wchar_t> converter;
return converter.from_bytes(str);
}
namespace Palladium {
PDLithiumFlags LI::flags = PDLithiumFlags_Default;
const float LI::default_font_size = 24.f;
const float LI::default_text_size = 0.7f;
float LI::text_scale = 0.7f;
// Renderer Stuff
bool LI::bottom_screen = false;
NVec2 LI::screen_size;
int LI::layer = 0;
std::vector<LI::Cmd> LI::draw_lists[2];
Texture::Ref LI::active_texture;
Texture::Ref LI::single_color;
std::vector<LI::Vtx, LinearAllocator<LI::Vtx>> LI::vertex_buffer;
std::vector<unsigned short, LinearAllocator<unsigned short>> LI::idx_buffer;
size_t LI::vertex_index = 0;
size_t LI::idx_index = 0;
bool LI::font_update = false;
LIFont::Ref LI::font;
bool LI::sysfont_render = false;
std::map<std::string, LI::TextBox> LI::text_sizes;
int LI::cmd_index = 0;
// Debug
int LI::num_vertices = 0;
int LI::num_drawcalls = 0;
int LI::num_commands = 0;
int LI::num_indices = 0;
// Shader
DVLB_s* LI::li7_dvlb;
shaderProgram_s LI::li7_prog;
C3D_AttrInfo LI::li7_attr;
int LI::uLoc_proj;
void LIFont::LoadTFF(const std::string path, int px_size) {
sysfnt = false;
Palladium::Ftrace::ScopedTrace st(
"LIFont", std::filesystem::path(path).filename().string());
this->pixel_height = px_size;
if (!Palladium::FS::FileExist(path)) return;
int type = px_size * 16;
// Load TTF
stbtt_fontinfo inf;
std::ifstream loader(path, std::ios::binary);
if (!loader.is_open()) return;
loader.seekg(0, std::ios::end);
size_t len = loader.tellg();
loader.seekg(0, std::ios::beg);
unsigned char* buffer = new unsigned char[len];
loader.read(reinterpret_cast<char*>(buffer), len);
loader.close();
stbtt_InitFont(&inf, buffer, 0);
std::vector<unsigned char> fmap(type * type * 4);
float scale = stbtt_ScaleForPixelHeight(&inf, pixel_height);
int ascent, descent, lineGap;
stbtt_GetFontVMetrics(&inf, &ascent, &descent, &lineGap);
int baseline = static_cast<int>(ascent * scale);
name = path;
auto ftex = Texture::New();
NVec2 offset;
for (int c = 0; c < 255; c++) {
CPI codepoint;
if (stbtt_IsGlyphEmpty(&inf, c)) {
codepoint.codepoint = c;
codepoint.tex = ftex;
codepoint.invalid = true;
cpmap[c] = codepoint;
continue;
}
int width, height, xOffset, yOffset;
unsigned char* bitmap = stbtt_GetCodepointBitmap(
&inf, scale, scale, c, &width, &height, &xOffset, &yOffset);
int x0, y0, x1, y1;
stbtt_GetCodepointBitmapBox(&inf, c, scale, scale, &x0, &y0, &x1, &y1);
if (offset[0] + width > type) {
offset[1] += pixel_height;
offset[0] = 0;
}
codepoint.uv[0] = static_cast<float>((float)offset[0] / (float)type);
codepoint.uv[1] = 1.0f - static_cast<float>((float)offset[1] / (float)type);
codepoint.uv[2] =
static_cast<float>(float(offset[0] + width) / (float)type);
codepoint.uv[3] =
1.0f - static_cast<float>(float(offset[1] + height) / (float)type);
codepoint.tex = ftex;
codepoint.szs[0] = width;
codepoint.szs[1] = height;
codepoint.off = baseline + yOffset;
for (int y = 0; y < height; ++y) {
for (int x = 0; x < width; ++x) {
int map_pos = ((offset[1] + y) * type + (offset[0] + x)) * 4;
fmap[map_pos + 0] = 255;
fmap[map_pos + 1] = 255;
fmap[map_pos + 2] = 255;
fmap[map_pos + 3] = bitmap[x + y * width];
}
}
offset[0] += width;
if (offset[0] + width > type) {
offset[1] += pixel_height;
offset[0] = 0;
}
free(bitmap);
cpmap[c] = codepoint;
}
ftex->LoadPixels(fmap, type, type, Palladium::Texture::RGBA32,
Palladium::Texture::LINEAR);
this->tex.push_back(ftex);
}
void LIFont::LoadBitmapFont(const std::string& path) {}
void LIFont::LoadSystemFont() {
Palladium::Ftrace::ScopedTrace st("li", "sysfnt");
sysfnt = true;
name = "System Font";
// Code to Load the System Font
const auto fnt = fontGetSystemFont();
const auto fnt_info = fontGetInfo(fnt);
const auto glyph_info = fontGetGlyphInfo(fnt);
this->tex.resize(glyph_info->nSheets + 1);
pixel_height = glyph_info->cellHeight;
for (size_t i = 0; i < glyph_info->nSheets; i++) {
auto stex = Texture::New();
auto tx = new C3D_Tex;
tx->data = fontGetGlyphSheetTex(fnt, i);
tx->fmt = (GPU_TEXCOLOR)glyph_info->sheetFmt;
tx->size = glyph_info->sheetSize;
tx->width = glyph_info->sheetWidth;
tx->height = glyph_info->sheetHeight;
tx->param = GPU_TEXTURE_MAG_FILTER(GPU_LINEAR) |
GPU_TEXTURE_MIN_FILTER(GPU_LINEAR) |
GPU_TEXTURE_WRAP_S(GPU_REPEAT) | GPU_TEXTURE_WRAP_T(GPU_REPEAT);
tx->border = 0xffffffff;
tx->lodParam = 0;
stex->ExternalLoad(tx, NVec2(tx->width, tx->height), NVec4(0, 1, 1, 0));
tex[i] = stex;
}
std::vector<unsigned int> charSet;
for (auto cmap = fnt_info->cmap; cmap; cmap = cmap->next) {
if (cmap->mappingMethod == CMAP_TYPE_DIRECT) {
if (cmap->codeEnd >= cmap->codeBegin) {
charSet.reserve(charSet.size() + cmap->codeEnd - cmap->codeBegin + 1);
for (auto i = cmap->codeBegin; i <= cmap->codeEnd; ++i) {
if (cmap->indexOffset + (i - cmap->codeBegin) == 0xFFFF) break;
charSet.emplace_back(i);
}
}
} else if (cmap->mappingMethod == CMAP_TYPE_TABLE) {
if (cmap->codeEnd >= cmap->codeBegin) {
charSet.reserve(charSet.size() + cmap->codeEnd - cmap->codeBegin + 1);
for (auto i = cmap->codeBegin; i <= cmap->codeEnd; ++i) {
if (cmap->indexTable[i - cmap->codeBegin] == 0xFFFF) continue;
charSet.emplace_back(i);
}
}
} else if (cmap->mappingMethod == CMAP_TYPE_SCAN) {
charSet.reserve(charSet.size() + cmap->nScanEntries);
for (unsigned i = 0; i < cmap->nScanEntries; ++i) {
if (cmap->scanEntries[i].code >= cmap->codeBegin &&
cmap->scanEntries[i].code <= cmap->codeEnd) {
if (cmap->scanEntries[i].glyphIndex != 0xFFFF) {
charSet.emplace_back(cmap->scanEntries[i].code);
}
}
}
} else {
continue;
}
}
std::sort(charSet.begin(), charSet.end());
charSet.erase(std::unique(charSet.begin(), charSet.end()));
for (auto cp : charSet) {
int gidx = fontGlyphIndexFromCodePoint(fnt, cp);
if (gidx >= 0xFFFF) continue;
CPI codepoint;
fontGlyphPos_s dat;
fontCalcGlyphPos(&dat, fnt, gidx, GLYPH_POS_CALC_VTXCOORD, 1.f, 1.f);
codepoint.codepoint = cp;
codepoint.uv[0] = dat.texcoord.left;
codepoint.uv[1] = dat.texcoord.top;
codepoint.uv[2] = dat.texcoord.right;
codepoint.uv[3] = dat.texcoord.bottom;
if (tex.at(dat.sheetIndex) != nullptr) codepoint.tex = tex[dat.sheetIndex];
codepoint.szs[0] = dat.vtxcoord.right;
codepoint.szs[1] = dat.vtxcoord.bottom;
codepoint.off = 0;
cpmap[cp] = codepoint;
}
}
int LIFont::GetPixelHeight() { return this->pixel_height; }
LIFont::CPI LIFont::GetCodepoint(unsigned int c) {
auto res = cpmap.find(c);
if (res == cpmap.end()) return CPI(true);
return res->second;
}
void LIFont::Dump() {
// std::ofstream ofs("sdmc:/font.txt", std::ios::out);
// ofs << "LI7 Font Dump" << std::endl;
// ofs << "Pixel Height: " << (int)pixel_height << std::endl;
// for (auto& it : this->cpmap) {
// ofs << " Codepoint: " << (int)it.codepoint << std::endl;
// ofs << " Tex: " << (unsigned int)it.tex->Get() << std::endl;
// ofs << " Szs: (" << (int)it.szs[0] << ", " << (int)it.szs[1] << ")"
// << std::endl;
// ofs << " UV: (" << (float)it.uv[0] << ", " << (float)it.uv[1] << ", "
// << (float)it.uv[2] << ", " << (float)it.uv[3] << ")" << std::endl;
// }
// ofs.close();
}
void LI::Init() {
vertex_buffer.resize(4 * 4096);
idx_buffer.resize(6 * 4096);
li7_dvlb = DVLB_ParseFile((u32*)li7_shader, li7_shader_size);
shaderProgramInit(&li7_prog);
shaderProgramSetVsh(&li7_prog, &li7_dvlb->DVLE[0]);
uLoc_proj =
shaderInstanceGetUniformLocation(li7_prog.vertexShader, "projection");
AttrInfo_Init(&li7_attr);
AttrInfo_AddLoader(&li7_attr, 0, GPU_FLOAT, 3);
AttrInfo_AddLoader(&li7_attr, 1, GPU_FLOAT, 2);
AttrInfo_AddLoader(&li7_attr, 2, GPU_UNSIGNED_BYTE, 4);
single_color = Texture::New();
std::vector<unsigned char> pixels(16 * 16 * 4, 255);
single_color->LoadPixels(pixels, 16, 16);
// C3D_Tex* w = new C3D_Tex;
// C3D_TexInit(w, 16, 16, GPU_L8);
// C3D_TexLoadImage(w, pixels.data(), GPU_TEXFACE_2D, 0);
// single_color->ExternalLoad(w, NVec2(16, 16), NVec4(0, 1, 1, 0));
font = LIFont::New();
font->LoadSystemFont();
}
void LI::Exit() {
shaderProgramFree(&li7_prog);
DVLB_Free(li7_dvlb);
}
void LI::OnScreen(bool bottom) {
screen_size[0] = bottom ? 320 : 400;
screen_size[1] = 240;
bottom_screen = bottom;
}
bool LI::CompareCommands(const LI::Cmd& a, const LI::Cmd& b) {
if (a.layer == b.layer) {
if (a.tex == b.tex) return a.index < b.index;
return a.tex > b.tex;
}
return a.layer < b.layer;
}
void LI::RotateCorner(NVec2& v, float s, float c) {
float x = v[0] * c - v[1] * s;
float y = v[1] * c + v[0] * s;
v = NVec2(x, y);
}
void LI::MakeRect(NVec4& top, NVec4& bot, NVec2 pos, NVec2 szs, float angle) {
NVec2 c; // Center
NVec2 tl(-c[0], -c[1]); // Top Left Corner
NVec2 tr(-c[0] + szs[0], -c[1]); // Top Right Corner
NVec2 bl(-c[0], -c[1] + szs[1]); // Bottom Left Corner
NVec2 br(-c[0] + szs[0], -c[1] + szs[1]); // Bottom Right Corner
// Calculate Rotation if required
if (angle != 0.f) {
float s = std::sin(angle);
float c = std::cos(angle);
RotateCorner(tl, s, c);
RotateCorner(tr, s, c);
RotateCorner(bl, s, c);
RotateCorner(br, s, c);
}
// Generate top and bottom positions
top = NVec4(tl + pos + c, tr + pos + c);
bot = NVec4(bl + pos + c, br + pos + c);
}
void LI::RenderFrame(bool bottom) {
Palladium::Ftrace::ScopedTrace st(
"LI", "Render" + std::string(bottom ? "Bot" : "Top"));
// Create and Setup Projection Matrix
C3D_Mtx proj;
Mtx_OrthoTilt(&proj, 0.f, (bottom ? 320 : 400), screen_size[1], 0.f, 1.f,
-1.f, false);
C3D_FVUnifMtx4x4(GPU_VERTEX_SHADER, uLoc_proj, &proj);
// Disable Depth Test
C3D_DepthTest(false, GPU_GREATER, GPU_WRITE_ALL);
bool sfr = false;
// Set Tex Env to use Texture 0
C3D_TexEnv* env = C3D_GetTexEnv(0);
C3D_TexEnvInit(env);
C3D_TexEnvSrc(env, C3D_Both, GPU_TEXTURE0, GPU_PRIMARY_COLOR, (GPU_TEVSRC)0);
C3D_TexEnvFunc(env, C3D_Both, GPU_MODULATE);
// Setup vars for performance data
int total_vertices = 0;
int total_indices = 0;
num_drawcalls = 0;
// Get DrawCmd List and reverse it
auto& draw_cmds = draw_lists[bottom];
if (flags & PDLithiumFlags_LRS) {
std::sort(draw_cmds.begin(), draw_cmds.end(), CompareCommands);
}
num_commands = draw_cmds.size();
size_t index = 0;
// Process Command List
while (index < draw_cmds.size()) {
// Get Active Texture and Setup Vertex List for every command with same tex
C3D_Tex* texture = draw_cmds[index].tex->Get();
size_t start_vtx = vertex_index;
size_t start_idx = idx_index;
while (index < draw_cmds.size() && draw_cmds[index].tex->Get() == texture) {
auto c = draw_cmds[index];
if (c.sfr != sfr) {
if (c.sfr == 0) {
C3D_TexEnv* env = C3D_GetTexEnv(0);
C3D_TexEnvInit(env);
C3D_TexEnvSrc(env, C3D_Both, GPU_TEXTURE0, GPU_PRIMARY_COLOR,
(GPU_TEVSRC)0);
C3D_TexEnvFunc(env, C3D_Both, GPU_MODULATE);
} else if (c.sfr == 1) {
C3D_TexEnv* env = C3D_GetTexEnv(0);
C3D_TexEnvInit(env);
C3D_TexEnvSrc(env, C3D_RGB, GPU_PRIMARY_COLOR, (GPU_TEVSRC)0,
(GPU_TEVSRC)0);
C3D_TexEnvFunc(env, C3D_RGB, GPU_REPLACE);
C3D_TexEnvSrc(env, C3D_Alpha, GPU_PRIMARY_COLOR, GPU_TEXTURE0,
(GPU_TEVSRC)0);
C3D_TexEnvFunc(env, C3D_Alpha, GPU_MODULATE);
}
sfr = c.sfr;
}
// FCS
if (c.fcs) {
c.top[0] = std::floor(c.top[0]);
c.top[1] = std::floor(c.top[1]);
c.top[2] = std::ceil(c.top[2]);
c.top[3] = std::floor(c.top[3]);
c.bot[0] = std::floor(c.bot[0]);
c.bot[1] = std::ceil(c.bot[1]);
c.bot[2] = std::ceil(c.bot[2]);
c.bot[3] = std::ceil(c.bot[3]);
}
if (c.cmd_type == 1) {
// Tiangle 1
idx_buffer[idx_index++] = vertex_index + 0;
idx_buffer[idx_index++] = vertex_index + 1;
idx_buffer[idx_index++] = vertex_index + 2;
// Tirangle 2
idx_buffer[idx_index++] = vertex_index + 0;
idx_buffer[idx_index++] = vertex_index + 2;
idx_buffer[idx_index++] = vertex_index + 3;
// Vertices
vertex_buffer[vertex_index++] =
Vtx(NVec2(c.bot[2], c.bot[3]), c.uv[2], c.uv[3], c.clr);
vertex_buffer[vertex_index++] =
Vtx(NVec2(c.top[2], c.top[3]), c.uv[2], c.uv[1], c.clr);
vertex_buffer[vertex_index++] =
Vtx(NVec2(c.top[0], c.top[1]), c.uv[0], c.uv[1], c.clr);
vertex_buffer[vertex_index++] =
Vtx(NVec2(c.bot[0], c.bot[1]), c.uv[0], c.uv[3], c.clr);
} else if (c.cmd_type == 2) {
// Triangle
idx_buffer[idx_index++] = vertex_index + 0;
idx_buffer[idx_index++] = vertex_index + 1;
idx_buffer[idx_index++] = vertex_index + 2;
// Vertices
vertex_buffer[vertex_index++] =
Vtx(NVec2(c.bot[0], c.bot[1]), c.uv[0], c.uv[3], c.clr);
vertex_buffer[vertex_index++] =
Vtx(NVec2(c.top[2], c.top[3]), c.uv[2], c.uv[3], c.clr);
vertex_buffer[vertex_index++] =
Vtx(NVec2(c.top[0], c.top[1]), c.uv[0], c.uv[1], c.clr);
} else if (c.cmd_type == 3) {
for (size_t i = 1; i < (size_t)c.top[3] - 1; i++) {
idx_buffer[idx_index++] = vertex_index;
idx_buffer[idx_index++] = vertex_index + i + 1;
idx_buffer[idx_index++] = vertex_index + i;
}
float as = 2.0f * M_PI / c.top[3];
for (int i = 0; i < (int)c.top[3]; i++) {
float a = i * as;
float x = c.top[0] + c.top[2] * cos(a);
float y = c.top[1] + c.top[2] * sin(a);
vertex_buffer[vertex_index++] =
Vtx(NVec2(x, y), (cos(a) + 1) / 2, (sin(a) + 1) / 2, c.clr);
}
}
index++;
}
// Bind Texture
C3D_TexBind(0, texture);
// Setup Buffer
C3D_BufInfo* bufinfo = C3D_GetBufInfo();
BufInfo_Init(bufinfo);
BufInfo_Add(bufinfo, vertex_buffer.data(), sizeof(Vtx), 3, 0x210);
// Draw
C3D_DrawElements(GPU_TRIANGLES, idx_index - start_idx, C3D_UNSIGNED_SHORT,
idx_buffer.data() + start_idx);
num_drawcalls++;
total_vertices += vertex_index - start_vtx;
total_indices += idx_index - start_idx;
}
draw_cmds.clear();
// Enable DepthTest
C3D_DepthTest(true, GPU_GREATER, GPU_WRITE_ALL);
num_vertices = total_vertices;
num_indices = total_indices;
active_texture = nullptr;
}
void LI::Render(C3D_RenderTarget* top, C3D_RenderTarget* bot) {
Palladium::Ftrace::ScopedTrace st("Li7", "Render");
if (font_update) {
text_sizes.clear();
font_update = false;
}
vertex_index = 0;
idx_index = 0;
C3D_BindProgram(&li7_prog);
C3D_SetAttrInfo(&li7_attr);
C3D_FrameDrawOn(top);
RenderFrame(false);
int d_tmp_cmds1 = num_commands;
int d_tmp_dcls1 = num_drawcalls;
int d_tmp_vtxs1 = num_vertices;
int d_tmp_idx1 = num_indices;
C3D_FrameDrawOn(bot);
RenderFrame(true);
num_commands += d_tmp_cmds1;
num_drawcalls += d_tmp_dcls1;
num_vertices += d_tmp_vtxs1;
num_indices += d_tmp_idx1;
layer = 0;
cmd_index = 0;
if (flags & PDLithiumFlags_TMS) {
std::vector<std::string> rem;
for (auto& it : text_sizes) {
if (Palladium::GetTime() - it.second.time_created > 5)
rem.push_back(it.first);
}
for (auto it : rem) text_sizes.erase(it);
} else {
if (text_sizes.size()) text_sizes.clear();
}
}
void LI::DrawRect(NVec2 pos, NVec2 size, unsigned int clr, NVec4 uvs) {
Cmd c;
if (pos[0] > screen_size[0] || pos[0] + size[0] < 0 ||
pos[1] > screen_size[1] || pos[1] + size[1] < 0)
return;
MakeRect(c.top, c.bot, pos, size);
c.fcs = flags & PDLithiumFlags_FCS;
c.uv = uvs;
c.clr = clr;
c.tex = active_texture;
c.cmd_type = 1;
c.layer = layer;
c.sfr = sysfont_render;
c.index = cmd_index++;
sysfont_render = false;
draw_lists[bottom_screen].push_back(c);
}
void LI::DrawTriangle(NVec2 a, NVec2 b, NVec2 c, unsigned int clr) {
UseTexture();
Cmd cmd;
if ((a[0] > screen_size[0] && b[0] > screen_size[0] &&
c[0] > screen_size[0]) ||
(a[1] > screen_size[1] && b[1] > screen_size[1] &&
c[1] > screen_size[1]) ||
(a[0] < 0 && b[0] < 0 && c[0] < 0) || (a[1] < 0 && b[1] < 0 && c[1] < 0))
return;
cmd.fcs = flags & PDLithiumFlags_FCS;
cmd.top = NVec4(a, b);
cmd.bot = NVec4(c, NVec2());
cmd.uv = NVec4(0, 1, 1, 0);
cmd.layer = layer;
cmd.clr = clr;
cmd.tex = active_texture;
cmd.cmd_type = 2;
cmd.index = cmd_index++;
draw_lists[bottom_screen].push_back(cmd);
}
void LI::DrawCircle(NVec2 pos, float r, unsigned int color, int segments) {
if (segments < 3) return;
Cmd c;
// Not Tested yet ...
c.fcs = flags & PDLithiumFlags_FCS;
c.top = NVec4(pos, NVec2(r, segments));
c.bot = NVec4();
c.uv = NVec4(0, 1, 1, 0);
c.clr = color;
c.tex = active_texture;
c.layer = layer;
c.cmd_type = 3;
c.index = cmd_index++;
draw_lists[bottom_screen].push_back(c);
}
void LI::DrawLine(NVec2 a, NVec2 b, unsigned int clr, int t) {
UseTexture();
NVec2 direction = {b[0] - a[0], b[1] - a[1]};
float length =
std::sqrt(direction[0] * direction[0] + direction[1] * direction[1]);
NVec2 unit_direction = {direction[0] / length, direction[1] / length};
NVec2 perpendicular = {-unit_direction[1], unit_direction[0]};
float half_t = t / 2.0f;
NVec2 offset = {perpendicular[0] * half_t, perpendicular[1] * half_t};
// Calculate corner positions
float px0 = a[0] + offset[0];
float py0 = a[1] + offset[1];
float px1 = b[0] + offset[0];
float py1 = b[1] + offset[1];
float px2 = a[0] - offset[0];
float py2 = a[1] - offset[1];
float px3 = b[0] - offset[0];
float py3 = b[1] - offset[1];
Cmd c;
// Schould be always true as lines otherwise could disappear for some reason
c.fcs = flags & PDLithiumFlags_FCS;
c.top = NVec4(px2, py2, px3, py3);
c.bot = NVec4(px0, py0, px1, py1);
c.uv = NVec4(0, 1, 1, 0);
c.clr = clr;
c.tex = active_texture;
c.layer = layer;
c.cmd_type = 1;
c.index = cmd_index++;
draw_lists[bottom_screen].push_back(c);
}
std::string LI::WrapText(const std::string& in, int maxlen, NVec2& dim) {
if (flags & PDLithiumFlags_TMS) {
if (text_sizes.find(in) != text_sizes.end()) {
text_sizes[in].time_created = Palladium::GetTime();
dim = text_sizes[in].size;
if (text_sizes[in].optinal) return text_sizes[in].text;
}
}
std::string out;
std::string line;
int line_x = 0;
std::istringstream istream(in);
std::string temp;
while (istream >> temp) {
NVec2 dim = GetTextDimensions(line + temp);
if (line_x + dim[0] <= maxlen) {
line += temp + ' ';
line_x += dim[0];
} else {
out += line + '\n';
line = temp + ' ';
line_x = GetTextDimensions(line)[0];
}
}
out += line;
dim = GetTextDimensions(out);
if (flags & PDLithiumFlags_TMS) {
text_sizes[in] = TextBox{dim, Palladium::GetTime(), true, out};
}
return out;
}
std::string LI::ShortText(const std::string& in, int maxlen, NVec2& dim) {
auto textdim = GetTextDimensions(in);
if (textdim[0] < (float)maxlen) return in;
if (flags & PDLithiumFlags_TMS) {
if (text_sizes.find(in) != text_sizes.end()) {
text_sizes[in].time_created = Palladium::GetTime();
dim = text_sizes[in].size;
if (text_sizes[in].optinal) return text_sizes[in].text;
}
}
std::string ext = "";
std::string ph = "(...)"; // placeholder
std::string worker = in;
std::string out;
size_t ext_pos = in.find_last_of('.');
if (ext_pos != in.npos) {
ext = in.substr(ext_pos);
worker = in.substr(0, ext_pos);
}
maxlen -= GetTextDimensions(ext)[0];
maxlen -= GetTextDimensions(ph)[0];
for (auto& it : worker) {
if (GetTextDimensions(out)[0] > (float)maxlen) {
out += ph;
out += ext;
dim = GetTextDimensions(out);
if (flags & PDLithiumFlags_TMS) {
text_sizes[in] = TextBox{dim, Palladium::GetTime(), true, out};
}
return out;
}
out += it;
}
return out; // Impossible to reach
}
NVec2 LI::GetTextDimensions(const std::string& text) {
if (!font) return NVec2();
if (flags & PDLithiumFlags_TMS) {
if (text_sizes.find(text) != text_sizes.end()) {
text_sizes[text].time_created = Palladium::GetTime();
return text_sizes[text].size;
}
}
// FONT
auto txt = make_wstring(text + "\0");
NVec2 pos(0, 0); // Temp Pos
NVec2 offset;
float txt_scale = text_scale;
if (font->IsSystemFont()) txt_scale *= 0.9;
float gapm = 1;
float maxWidth = 0.f;
float ntxtszs = default_font_size * txt_scale;
float cpm = ntxtszs / font->GetPixelHeight();
float line_height = font->GetPixelHeight() * cpm;
for (size_t i = 0; i < txt.length(); i++) {
if (txt[i] == '\0') break;
auto cp = font->GetCodepoint(txt[i]);
if (cp.invalid && txt[i] != '\n' && txt[i] != ' ' && txt[i] != '\t')
continue;
bool implicitBreak = false;
if (txt[i] == '\n' || implicitBreak) {
offset[1] += line_height;
maxWidth = std::max(maxWidth, offset[0]);
offset[0] = 0;
if (implicitBreak) continue;
} else if (txt[i] == '\t') {
offset[0] = ((offset[0] / ntxtszs) / 4 + 1) * 4 * ntxtszs;
} else {
if (txt[i] == ' ') {
// this will make the space twice
if (!font->IsSystemFont()) offset[0] += 4 * gapm * txt_scale;
}
if (i == txt.length() - 1)
offset[0] += cp.szs[0] * cpm + txt_scale;
else
offset[0] += cp.szs[0] * cpm + (gapm * txt_scale);
}
}
maxWidth = std::max(maxWidth, offset[0]);
NVec2 res = NVec2(maxWidth, offset[1] + (default_font_size * txt_scale));
if (flags & PDLithiumFlags_TMS)
text_sizes[text] = TextBox{res, Palladium::GetTime(), false, ""};
return res;
}
void LI::DrawText(NVec2 pos, unsigned int color, const std::string& text,
PDTextFlags flags, NVec2 ap) {
if (!font) return;
PDLithiumFlags tmp_flags = flags;
// Do not use FCS in Text Rendering...
flags &= ~PDLithiumFlags_FCS;
std::string txt = text;
NVec2 offset;
float txt_scale = text_scale;
if (font->IsSystemFont()) txt_scale *= 0.9;
float gapm = 1;
float ntxtszs = default_font_size * txt_scale;
float cpm = ntxtszs / font->GetPixelHeight();
float line_height = font->GetPixelHeight() * cpm;
NVec2 td;
if (flags & PDTextFlags_Wrap)
txt = WrapText(text, ap[0] - pos[0], td);
else if (flags & PDTextFlags_Short)
txt = ShortText(text, ap[0] - pos[0], td);
if (td[0] == 0 && td[1] == 0) td = GetTextDimensions(text);
if (flags & PDTextFlags_AlignRight)
pos[0] -= td[0];
else if (flags & PDTextFlags_AlignMid) {
pos[0] = (ap[0] * 0.5) - (td[0] * 0.5) + pos[0];
}
std::vector<std::string> lines;
std::istringstream iss(txt);
std::string temp;
while (std::getline(iss, temp)) {
lines.push_back(temp);
}
for (auto& it : lines) {
if (pos[1] + offset[1] + line_height < 0) {
offset[1] += line_height;
continue;
} else if (pos[1] + offset[1] > screen_size[1]) {
// Break func as we dont want loop over lines that get skipped too
break;
}
auto wstr = make_wstring(it);
// Loop over line
for (auto& jt : wstr) {
auto cp = font->GetCodepoint(jt);
if (cp.invalid && jt != '\n' && jt != ' ' && jt != '\t') continue;
active_texture = cp.tex;
if (jt == '\t') {
offset[0] = ((offset[0] / ntxtszs) / 4 + 1) * 4 * ntxtszs;
} else {
if (jt != ' ') {
int lr = layer;
if (flags & PDTextFlags_Shaddow) {
sysfont_render = true;
DrawRect(
pos + NVec2(offset[0] + 1, (offset[1] + (cp.off * cpm)) + 1),
NVec2(cp.szs[0] * cpm, cp.szs[1] * cpm),
Palladium::Color::RGBA(color).is_light() ? 0xff111111
: 0xffeeeeee,
cp.uv);
layer++;
}
sysfont_render = true;
DrawRect(pos + offset + NVec2(0, (cp.off * cpm)),
NVec2(cp.szs[0] * cpm, cp.szs[1] * cpm), color, cp.uv);
layer = lr;
} else {
// this will make the space twice
if (!font->IsSystemFont()) offset[0] += 4 * gapm * txt_scale;
}
offset[0] += cp.szs[0] * cpm + (gapm * txt_scale);
}
}
offset[1] += line_height;
offset[0] = 0;
}
flags = tmp_flags;
}
} // namespace Palladium
Reference in New Issue View Git Blame Copy Permalink