AxioDL
/
metaforce
mirror of https://github.com/AxioDL/metaforce.git
2
0
Fork 0
Code Issues Projects Releases Wiki Activity

FRME bug fixes and shader adjustments

This commit is contained in:
Jack Andersen 2017-01-29 18:16:20 -10:00
parent 1fbd08b7c6
commit 83176b41a9
39 changed files with 424 additions and 179 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
DataSpec/DNAMP1/FRME.cpp
View File

@ -243,7 +243,7 @@ void FRME::Widget::TXPNInfo::read(athena::io::IStreamReader& __dna_reader)
/* unk1 */
wordWrap = __dna_reader.readBool();
/* unk2 */
vertical = __dna_reader.readBool();
horizontal = __dna_reader.readBool();
/* justification */
justification = Justification(__dna_reader.readUint32Big());
/* verticalJustification */
@ -279,7 +279,7 @@ void FRME::Widget::TXPNInfo::write(athena::io::IStreamWriter& __dna_writer) cons
/* unk1 */
__dna_writer.writeBool(wordWrap);
/* unk2 */
__dna_writer.writeBool(vertical);
__dna_writer.writeBool(horizontal);
/* justification */
__dna_writer.writeUint32Big(atUint32(justification));
/* verticalJustification */
@ -608,7 +608,7 @@ bool FRME::Extract(const SpecBase &dataSpec,
"frme_obj.retro_pane_scale_center = (%f,%f,%f)\n"
"frme_obj.retro_textpane_font_path = '%s'\n"
"frme_obj.retro_textpane_word_wrap = %s\n"
"frme_obj.retro_textpane_vertical = %s\n"
"frme_obj.retro_textpane_horizontal = %s\n"
"frme_obj.retro_textpane_fill_color = (%f,%f,%f,%f)\n"
"frme_obj.retro_textpane_outline_color = (%f,%f,%f,%f)\n"
"frme_obj.retro_textpane_block_extent = (%f,%f)\n"
@ -622,7 +622,7 @@ bool FRME::Extract(const SpecBase &dataSpec,
info->scaleCenter.vec[2],
fontPath.getRelativePathUTF8().c_str(),
info->wordWrap ? "True" : "False",
info->vertical ? "True" : "False",
info->horizontal ? "True" : "False",
info->fillColor.vec[0],
info->fillColor.vec[1],
info->fillColor.vec[2],

2
DataSpec/DNAMP1/FRME.hpp
View File

@ -264,7 +264,7 @@ struct FRME : BigDNA
Value<atVec3f> scaleCenter;
UniqueID32 font;
Value<bool> wordWrap;
Value<bool> vertical;
Value<bool> horizontal;
Value<Justification> justification;
Value<VerticalJustification> verticalJustification;
Value<atVec4f> fillColor;

3
Runtime/Graphics/CGraphics.cpp
View File

@ -3,6 +3,7 @@
#include "zeus/Math.hpp"
#include "CTimeProvider.hpp"
#include "Shaders/CTextSupportShader.hpp"
#include "GuiSys/CGuiSys.hpp"
namespace urde
{
@ -456,6 +457,8 @@ void CGraphics::SetViewportResolution(const zeus::CVector2i& res)
g_CroppedViewport.xc_width = res.x;
g_CroppedViewport.x10_height = res.y;
g_ViewportResolutionHalf = {res.x / 2, res.y / 2};
if (g_GuiSys)
g_GuiSys->OnViewportResize();
}
static boo::SWindowRect CachedVP;

20
Runtime/Graphics/Shaders/CModelShadersGLSL.cpp
View File

@ -85,12 +85,24 @@ CModelShaders::GetShaderExtensionsGLSL(boo::IGraphicsDataFactory::Platform plat)
hecl::Runtime::ShaderCacheExtensions ext(plat);
/* Normal lit shading */
ext.registerExtensionSlot({LightingGLSL, "LightingFunc"}, {MainPostGLSL, "MainPostFunc"}, 3, BlockNames, 0, nullptr,
hecl::Backend::BlendFactor::Original, hecl::Backend::BlendFactor::Original);
ext.registerExtensionSlot({LightingGLSL, "LightingFunc"}, {MainPostGLSL, "MainPostFunc"},
3, BlockNames, 0, nullptr, hecl::Backend::BlendFactor::Original,
hecl::Backend::BlendFactor::Original);
/* Thermal Visor shading */
ext.registerExtensionSlot({}, {ThermalPostGLSL, "ThermalPostFunc"}, 3, ThermalBlockNames, 1, ThermalTextures,
hecl::Backend::BlendFactor::One, hecl::Backend::BlendFactor::One);
ext.registerExtensionSlot({}, {ThermalPostGLSL, "ThermalPostFunc"}, 3, ThermalBlockNames,
1, ThermalTextures, hecl::Backend::BlendFactor::One,
hecl::Backend::BlendFactor::One);
/* Forced alpha shading */
ext.registerExtensionSlot({LightingGLSL, "LightingFunc"}, {MainPostGLSL, "MainPostFunc"},
3, BlockNames, 0, nullptr, hecl::Backend::BlendFactor::SrcAlpha,
hecl::Backend::BlendFactor::InvSrcAlpha);
/* Forced additive shading */
ext.registerExtensionSlot({LightingGLSL, "LightingFunc"}, {MainPostGLSL, "MainPostFunc"},
3, BlockNames, 0, nullptr, hecl::Backend::BlendFactor::One,
hecl::Backend::BlendFactor::One);
return ext;
}

20
Runtime/Graphics/Shaders/CModelShadersHLSL.cpp
View File

@ -76,12 +76,24 @@ CModelShaders::GetShaderExtensionsHLSL(boo::IGraphicsDataFactory::Platform plat)
hecl::Runtime::ShaderCacheExtensions ext(plat);
/* Normal lit shading */
ext.registerExtensionSlot({LightingHLSL, "LightingFunc"}, {MainPostHLSL, "MainPostFunc"}, 0, nullptr, 0, nullptr,
hecl::Backend::BlendFactor::Original, hecl::Backend::BlendFactor::Original);
ext.registerExtensionSlot({LightingMetal, "LightingFunc"}, {MainPostMetal, "MainPostFunc"},
0, nullptr, 0, nullptr, hecl::Backend::BlendFactor::Original,
hecl::Backend::BlendFactor::Original);
/* Thermal Visor shading */
ext.registerExtensionSlot({}, {ThermalPostHLSL, "ThermalPostFunc"}, 0, nullptr, 1, ThermalTextures,
hecl::Backend::BlendFactor::One, hecl::Backend::BlendFactor::One);
ext.registerExtensionSlot({}, {ThermalPostMetal, "ThermalPostFunc"}, 0, nullptr,
1, ThermalTextures, hecl::Backend::BlendFactor::One,
hecl::Backend::BlendFactor::One);
/* Forced alpha shading */
ext.registerExtensionSlot({LightingMetal, "LightingFunc"}, {MainPostMetal, "MainPostFunc"},
0, nullptr, 0, nullptr, hecl::Backend::BlendFactor::SrcAlpha,
hecl::Backend::BlendFactor::InvSrcAlpha);
/* Forced additive shading */
ext.registerExtensionSlot({LightingMetal, "LightingFunc"}, {MainPostMetal, "MainPostFunc"},
0, nullptr, 0, nullptr, hecl::Backend::BlendFactor::One,
hecl::Backend::BlendFactor::One);
return ext;
}

20
Runtime/Graphics/Shaders/CModelShadersMetal.cpp
View File

@ -79,12 +79,24 @@ CModelShaders::GetShaderExtensionsMetal(boo::IGraphicsDataFactory::Platform plat
hecl::Runtime::ShaderCacheExtensions ext(plat);
/* Normal lit shading */
ext.registerExtensionSlot({LightingMetal, "LightingFunc"}, {MainPostMetal, "MainPostFunc"}, 1, BlockNames, 0, nullptr,
hecl::Backend::BlendFactor::Original, hecl::Backend::BlendFactor::Original);
ext.registerExtensionSlot({LightingMetal, "LightingFunc"}, {MainPostMetal, "MainPostFunc"},
1, BlockNames, 0, nullptr, hecl::Backend::BlendFactor::Original,
hecl::Backend::BlendFactor::Original);
/* Thermal Visor shading */
ext.registerExtensionSlot({}, {ThermalPostMetal, "ThermalPostFunc"}, 1, ThermalBlockNames, 1, ThermalTextures,
hecl::Backend::BlendFactor::One, hecl::Backend::BlendFactor::One);
ext.registerExtensionSlot({}, {ThermalPostMetal, "ThermalPostFunc"}, 1, ThermalBlockNames,
1, ThermalTextures, hecl::Backend::BlendFactor::One,
hecl::Backend::BlendFactor::One);
/* Forced alpha shading */
ext.registerExtensionSlot({LightingMetal, "LightingFunc"}, {MainPostMetal, "MainPostFunc"},
1, BlockNames, 0, nullptr, hecl::Backend::BlendFactor::SrcAlpha,
hecl::Backend::BlendFactor::InvSrcAlpha);
/* Forced additive shading */
ext.registerExtensionSlot({LightingMetal, "LightingFunc"}, {MainPostMetal, "MainPostFunc"},
1, BlockNames, 0, nullptr, hecl::Backend::BlendFactor::One,
hecl::Backend::BlendFactor::One);
return ext;
}

1
Runtime/Graphics/Shaders/CTextSupportShader.hpp
View File

@ -39,6 +39,7 @@ class CTextSupportShader
zeus::CVector3f m_uv[4];
zeus::CColor m_fontColor;
zeus::CColor m_outlineColor;
zeus::CColor m_mulColor;
void SetMetrics(const CGlyph& glyph, const zeus::CVector2i& offset);
};

25
Runtime/Graphics/Shaders/CTextSupportShaderGLSL.cpp
View File

@ -13,6 +13,7 @@ BOO_GLSL_BINDING_HEAD
"layout(location=4) in vec4 uvIn[4];\n"
"layout(location=8) in vec4 fontColorIn;\n"
"layout(location=9) in vec4 outlineColorIn;\n"
"layout(location=10) in vec4 mulColorIn;\n"
"\n"
"UBINDING0 uniform TextSupportUniform\n"
"{\n"
@ -24,6 +25,7 @@ BOO_GLSL_BINDING_HEAD
"{\n"
" vec4 fontColor;\n"
" vec4 outlineColor;\n"
" vec4 mulColor;\n"
" vec3 uv;\n"
"};\n"
"\n"
@ -32,6 +34,7 @@ BOO_GLSL_BINDING_HEAD
"{\n"
" vtf.fontColor = color * fontColorIn;\n"
" vtf.outlineColor = color * outlineColorIn;\n"
" vtf.mulColor = mulColorIn;\n"
" vtf.uv = uvIn[gl_VertexID].xyz;\n"
" gl_Position = mtx * vec4(posIn[gl_VertexID].xyz, 1.0);\n"
" gl_Position = FLIPFROMGL(gl_Position);\n"
@ -44,6 +47,7 @@ BOO_GLSL_BINDING_HEAD
"{\n"
" vec4 fontColor;\n"
" vec4 outlineColor;\n"
" vec4 mulColor;\n"
" vec3 uv;\n"
"};\n"
"\n"
@ -53,7 +57,7 @@ BOO_GLSL_BINDING_HEAD
"void main()\n"
"{\n"
" vec4 texel = texture(tex, vtf.uv);\n"
" colorOut = vtf.fontColor * texel.r + vtf.outlineColor * texel.g;\n"
" colorOut = (vtf.fontColor * texel.r + vtf.outlineColor * texel.g) * vtf.mulColor;\n"
"}\n";
static const char* ImgVS =
@ -109,14 +113,14 @@ CTextSupportShader::Initialize(boo::GLDataFactory::Context& ctx)
const char* uniNames[] = {"TextSupportUniform"};
s_TextAlphaPipeline = ctx.newShaderPipeline(TextVS, TextFS, 1, texNames, 1, uniNames, boo::BlendFactor::SrcAlpha,
boo::BlendFactor::InvSrcAlpha, boo::Primitive::TriStrips, false, false, false);
boo::BlendFactor::InvSrcAlpha, boo::Primitive::TriStrips, true, false, false);
s_TextAddPipeline = ctx.newShaderPipeline(TextVS, TextFS, 1, texNames, 1, uniNames, boo::BlendFactor::SrcAlpha,
boo::BlendFactor::One, boo::Primitive::TriStrips, false, false, false);
boo::BlendFactor::One, boo::Primitive::TriStrips, true, false, false);
s_ImageAlphaPipeline = ctx.newShaderPipeline(ImgVS, ImgFS, 1, texNames, 1, uniNames, boo::BlendFactor::SrcAlpha,
boo::BlendFactor::InvSrcAlpha, boo::Primitive::TriStrips, false, false, false);
boo::BlendFactor::InvSrcAlpha, boo::Primitive::TriStrips, true, false, false);
s_ImageAddPipeline = ctx.newShaderPipeline(ImgVS, ImgFS, 1, texNames, 1, uniNames, boo::BlendFactor::SrcAlpha,
boo::BlendFactor::One, boo::Primitive::TriStrips, false, false, false);
boo::BlendFactor::One, boo::Primitive::TriStrips, true, false, false);
return nullptr;
}
@ -137,12 +141,13 @@ CTextSupportShader::Initialize(boo::VulkanDataFactory::Context& ctx)
{nullptr, nullptr, boo::VertexSemantic::UV4 | boo::VertexSemantic::Instanced, 3},
{nullptr, nullptr, boo::VertexSemantic::Color | boo::VertexSemantic::Instanced, 0},
{nullptr, nullptr, boo::VertexSemantic::Color | boo::VertexSemantic::Instanced, 1},
{nullptr, nullptr, boo::VertexSemantic::Color | boo::VertexSemantic::Instanced, 2},
};
s_TextVtxFmt = ctx.newVertexFormat(10, TextVtxVmt);
s_TextVtxFmt = ctx.newVertexFormat(11, TextVtxVmt);
s_TextAlphaPipeline = ctx.newShaderPipeline(TextVS, TextFS, s_TextVtxFmt, boo::BlendFactor::SrcAlpha,
boo::BlendFactor::InvSrcAlpha, boo::Primitive::TriStrips, false, false, false);
boo::BlendFactor::InvSrcAlpha, boo::Primitive::TriStrips, true, false, false);
s_TextAddPipeline = ctx.newShaderPipeline(TextVS, TextFS, s_TextVtxFmt, boo::BlendFactor::SrcAlpha,
boo::BlendFactor::One, boo::Primitive::TriStrips, false, false, false);
boo::BlendFactor::One, boo::Primitive::TriStrips, true, false, false);
boo::VertexElementDescriptor ImageVtxVmt[] =
{
@ -158,9 +163,9 @@ CTextSupportShader::Initialize(boo::VulkanDataFactory::Context& ctx)
};
s_ImageVtxFmt = ctx.newVertexFormat(9, ImageVtxVmt);
s_ImageAlphaPipeline = ctx.newShaderPipeline(ImgVS, ImgFS, s_ImageVtxFmt, boo::BlendFactor::SrcAlpha,
boo::BlendFactor::InvSrcAlpha, boo::Primitive::TriStrips, false, false, false);
boo::BlendFactor::InvSrcAlpha, boo::Primitive::TriStrips, true, false, false);
s_ImageAddPipeline = ctx.newShaderPipeline(ImgVS, ImgFS, s_ImageVtxFmt, boo::BlendFactor::SrcAlpha,
boo::BlendFactor::One, boo::Primitive::TriStrips, false, false, false);
boo::BlendFactor::One, boo::Primitive::TriStrips, true, false, false);
return nullptr;
}

17
Runtime/Graphics/Shaders/CTextSupportShaderHLSL.cpp
View File

@ -13,6 +13,7 @@ static const char* TextVS =
" float4 uvIn[4] : UV;\n"
" float4 fontColorIn : COLOR0;\n"
" float4 outlineColorIn : COLOR1;\n"
" float4 mulColorIn : COLOR2;\n"
"};\n"
"\n"
"cbuffer TextSupportUniform : register(b0)\n"
@ -26,6 +27,7 @@ static const char* TextVS =
" float4 pos : SV_Position;\n"
" float4 fontColor : COLOR0;\n"
" float4 outlineColor : COLOR1;\n"
" float4 mulColor : COLOR2;\n"
" float3 uv : UV;\n"
"};\n"
"\n"
@ -34,6 +36,7 @@ static const char* TextVS =
" VertToFrag vtf;\n"
" vtf.fontColor = color * inst.fontColorIn;\n"
" vtf.outlineColor = color * inst.outlineColorIn;\n"
" vtf.mulColor = inst.mulColorIn;\n"
" vtf.uv = inst.uvIn[vertId].xyz;\n"
" vtf.pos = mul(mtx, float4(inst.posIn[vertId].xyz, 1.0));\n"
" return vtf;\n"
@ -45,6 +48,7 @@ static const char* TextFS =
" float4 pos : SV_Position;\n"
" float4 fontColor : COLOR0;\n"
" float4 outlineColor : COLOR1;\n"
" float4 mulColor : COLOR2;\n"
" float3 uv : UV;\n"
"};\n"
"\n"
@ -54,7 +58,7 @@ static const char* TextFS =
"float4 main(in VertToFrag vtf) : SV_Target0\n"
"{\n"
" float4 texel = tex.Sample(samp, vtf.uv.xyz);\n"
" return vtf.fontColor * texel.r + vtf.outlineColor * texel.g;\n"
" return (vtf.fontColor * texel.r + vtf.outlineColor * texel.g) * vtf.mulColor;\n"
"}\n";
static const char* ImgVS =
@ -119,14 +123,15 @@ CTextSupportShader::Initialize(boo::ID3DDataFactory::Context& ctx)
{nullptr, nullptr, boo::VertexSemantic::UV4 | boo::VertexSemantic::Instanced, 3},
{nullptr, nullptr, boo::VertexSemantic::Color | boo::VertexSemantic::Instanced, 0},
{nullptr, nullptr, boo::VertexSemantic::Color | boo::VertexSemantic::Instanced, 1},
{nullptr, nullptr, boo::VertexSemantic::Color | boo::VertexSemantic::Instanced, 2},
};
s_TextVtxFmt = ctx.newVertexFormat(10, TextVtxVmt);
s_TextVtxFmt = ctx.newVertexFormat(11, TextVtxVmt);
s_TextAlphaPipeline = ctx.newShaderPipeline(TextVS, TextFS, ComPtr<ID3DBlob>(), ComPtr<ID3DBlob>(), ComPtr<ID3DBlob>(),
s_TextVtxFmt, boo::BlendFactor::SrcAlpha,
boo::BlendFactor::InvSrcAlpha, boo::Primitive::TriStrips, false, false, false);
boo::BlendFactor::InvSrcAlpha, boo::Primitive::TriStrips, true, false, false);
s_TextAddPipeline = ctx.newShaderPipeline(TextVS, TextFS, ComPtr<ID3DBlob>(), ComPtr<ID3DBlob>(), ComPtr<ID3DBlob>(),
s_TextVtxFmt, boo::BlendFactor::SrcAlpha,
boo::BlendFactor::One, boo::Primitive::TriStrips, false, false, false);
boo::BlendFactor::One, boo::Primitive::TriStrips, true, false, false);
boo::VertexElementDescriptor ImageVtxVmt[] =
{
@ -143,10 +148,10 @@ CTextSupportShader::Initialize(boo::ID3DDataFactory::Context& ctx)
s_ImageVtxFmt = ctx.newVertexFormat(9, ImageVtxVmt);
s_ImageAlphaPipeline = ctx.newShaderPipeline(ImgVS, ImgFS, ComPtr<ID3DBlob>(), ComPtr<ID3DBlob>(), ComPtr<ID3DBlob>(),
s_ImageVtxFmt, boo::BlendFactor::SrcAlpha,
boo::BlendFactor::InvSrcAlpha, boo::Primitive::TriStrips, false, false, false);
boo::BlendFactor::InvSrcAlpha, boo::Primitive::TriStrips, true, false, false);
s_ImageAddPipeline = ctx.newShaderPipeline(ImgVS, ImgFS, ComPtr<ID3DBlob>(), ComPtr<ID3DBlob>(), ComPtr<ID3DBlob>(),
s_ImageVtxFmt, boo::BlendFactor::SrcAlpha,
boo::BlendFactor::One, boo::Primitive::TriStrips, false, false, false);
boo::BlendFactor::One, boo::Primitive::TriStrips, true, false, false);
return nullptr;
}

25
Runtime/Graphics/Shaders/CTextSupportShaderMetal.cpp
View File

@ -15,6 +15,7 @@ static const char* TextVS =
" float4 uvIn[4];\n"
" float4 fontColorIn;\n"
" float4 outlineColorIn;\n"
" float4 mulColorIn;\n"
"};\n"
"\n"
"struct TextSupportUniform\n"
@ -28,6 +29,7 @@ static const char* TextVS =
" float4 pos [[ position ]];\n"
" float4 fontColor;\n"
" float4 outlineColor;\n"
" float4 mulColor;\n"
" float3 uv;\n"
"};\n"
"\n"
@ -37,8 +39,9 @@ static const char* TextVS =
"{\n"
" VertToFrag vtf;\n"
" constant InstData& inst = instArr[instId];\n"
" vtf.fontColor = uData.color * inst.fontColorIn;\n"
" vtf.outlineColor = uData.color * inst.outlineColorIn;\n"
" vtf.fontColor = inst.fontColorIn * uData.color;\n"
" vtf.outlineColor = inst.outlineColorIn * uData.color;\n"
" vtf.mulColor = inst.mulColorIn;\n"
" vtf.uv = inst.uvIn[vertId].xyz;\n"
" vtf.pos = uData.mtx * float4(inst.posIn[vertId].xyz, 1.0);\n"
" return vtf;\n"
@ -47,12 +50,13 @@ static const char* TextVS =
static const char* TextFS =
"#include <metal_stdlib>\n"
"using namespace metal;\n"
"constexpr sampler samp(address::repeat);\n"
"constexpr sampler samp(address::repeat, filter::linear);\n"
"struct VertToFrag\n"
"{\n"
" float4 pos [[ position ]];\n"
" float4 fontColor;\n"
" float4 outlineColor;\n"
" float4 mulColor;\n"
" float3 uv;\n"
"};\n"
"\n"
@ -60,7 +64,7 @@ static const char* TextFS =
" texture2d_array<float> tex [[ texture(0) ]])\n"
"{\n"
" float4 texel = tex.sample(samp, vtf.uv.xy, vtf.uv.z);\n"
" return vtf.fontColor * texel.r + vtf.outlineColor * texel.g;\n"
" return (vtf.fontColor * texel.r + vtf.outlineColor * texel.g) * vtf.mulColor;\n"
"}\n";
static const char* ImgVS =
@ -101,7 +105,7 @@ static const char* ImgVS =
static const char* ImgFS =
"#include <metal_stdlib>\n"
"using namespace metal;\n"
"constexpr sampler samp(address::repeat);\n"
"constexpr sampler samp(address::repeat, filter::linear);\n"
"struct VertToFrag\n"
"{\n"
" float4 pos [[ position ]];\n"
@ -131,12 +135,13 @@ CTextSupportShader::Initialize(boo::MetalDataFactory::Context& ctx)
{nullptr, nullptr, boo::VertexSemantic::UV4 | boo::VertexSemantic::Instanced, 3},
{nullptr, nullptr, boo::VertexSemantic::Color | boo::VertexSemantic::Instanced, 0},
{nullptr, nullptr, boo::VertexSemantic::Color | boo::VertexSemantic::Instanced, 1},
{nullptr, nullptr, boo::VertexSemantic::Color | boo::VertexSemantic::Instanced, 2},
};
s_TextVtxFmt = ctx.newVertexFormat(10, TextVtxVmt);
s_TextVtxFmt = ctx.newVertexFormat(11, TextVtxVmt);
s_TextAlphaPipeline = ctx.newShaderPipeline(TextVS, TextFS, s_TextVtxFmt, CGraphics::g_ViewportSamples, boo::BlendFactor::SrcAlpha,
boo::BlendFactor::InvSrcAlpha, boo::Primitive::TriStrips, false, false, false);
boo::BlendFactor::InvSrcAlpha, boo::Primitive::TriStrips, true, false, false);
s_TextAddPipeline = ctx.newShaderPipeline(TextVS, TextFS, s_TextVtxFmt, CGraphics::g_ViewportSamples, boo::BlendFactor::SrcAlpha,
boo::BlendFactor::One, boo::Primitive::TriStrips, false, false, false);
boo::BlendFactor::One, boo::Primitive::TriStrips, true, false, false);
boo::VertexElementDescriptor ImageVtxVmt[] =
{
@ -152,9 +157,9 @@ CTextSupportShader::Initialize(boo::MetalDataFactory::Context& ctx)
};
s_ImageVtxFmt = ctx.newVertexFormat(9, ImageVtxVmt);
s_ImageAlphaPipeline = ctx.newShaderPipeline(ImgVS, ImgFS, s_ImageVtxFmt, CGraphics::g_ViewportSamples, boo::BlendFactor::SrcAlpha,
boo::BlendFactor::InvSrcAlpha, boo::Primitive::TriStrips, false, false, false);
boo::BlendFactor::InvSrcAlpha, boo::Primitive::TriStrips, true, false, false);
s_ImageAddPipeline = ctx.newShaderPipeline(ImgVS, ImgFS, s_ImageVtxFmt, CGraphics::g_ViewportSamples, boo::BlendFactor::SrcAlpha,
boo::BlendFactor::One, boo::Primitive::TriStrips, false, false, false);
boo::BlendFactor::One, boo::Primitive::TriStrips, true, false, false);
return nullptr;
}

14
Runtime/GuiSys/CFontImageDef.cpp
View File

@ -1,4 +1,5 @@
#include "CFontImageDef.hpp"
#include "Graphics/CTexture.hpp"
namespace urde
{
@ -26,4 +27,17 @@ bool CFontImageDef::IsLoaded() const
return true;
}
s32 CFontImageDef::CalculateBaseline() const
{
const CTexture* tex = x4_texs.front().GetObj();
return s32(tex->GetHeight() * x14_pointsPerTexel.y) * 2.5f / 3.f;
}
s32 CFontImageDef::CalculateHeight() const
{
const CTexture* tex = x4_texs.front().GetObj();
s32 scaledH = tex->GetHeight() * x14_pointsPerTexel.y;
return scaledH - (scaledH - CalculateBaseline());
}
}

2
Runtime/GuiSys/CFontImageDef.hpp
View File

@ -20,6 +20,8 @@ public:
const zeus::CVector2f& vec);
CFontImageDef(const TToken<CTexture>& tex, const zeus::CVector2f& vec);
bool IsLoaded() const;
s32 CalculateBaseline() const;
s32 CalculateHeight() const;
};
}

24
Runtime/GuiSys/CFontRenderState.cpp
View File

@ -6,9 +6,9 @@ namespace urde
CFontRenderState::CFontRenderState()
{
x54_[0] = zeus::CColor::skWhite;
x54_[1] = zeus::CColor::skGrey;
x54_[2] = zeus::CColor::skWhite;
x54_colors[0] = zeus::CColor::skWhite;
x54_colors[1] = zeus::CColor::skGrey;
x54_colors[2] = zeus::CColor::skWhite;
RefreshPalette();
}
@ -36,13 +36,13 @@ void CFontRenderState::SetColor(EColorType tp, const CTextColor& col)
case EColorType::Main:
case EColorType::Outline:
case EColorType::Geometry:
x54_[int(tp)] = col;
x54_colors[int(tp)] = col;
break;
case EColorType::Foreground:
x54_[0] = col;
x54_colors[0] = col;
break;
case EColorType::Background:
x54_[1] = col;
x54_colors[1] = col;
break;
}
RefreshColor(tp);
@ -61,15 +61,15 @@ void CFontRenderState::RefreshColor(EColorType tp)
case EColorType::Main:
if (!x48_font)
return;
switch (x48_font.GetObj()->GetMode())
switch (x48_font->GetMode())
{
case EColorType::Main:
if (!x64_colorOverrides[0])
x0_drawStrOpts.x4_colors[0] = ConvertToTextureSpace(x54_[0]);
x0_drawStrOpts.x4_colors[0] = ConvertToTextureSpace(x54_colors[0]);
break;
case EColorType::Outline:
if (!x64_colorOverrides[0])
x0_drawStrOpts.x4_colors[0] = ConvertToTextureSpace(x54_[0]);
x0_drawStrOpts.x4_colors[0] = ConvertToTextureSpace(x54_colors[0]);
break;
default: break;
}
@ -79,12 +79,12 @@ void CFontRenderState::RefreshColor(EColorType tp)
return;
if (x64_colorOverrides[1])
return;
if (x48_font.GetObj()->GetMode() == EColorType::Outline)
x0_drawStrOpts.x4_colors[1] = ConvertToTextureSpace(x54_[1]);
if (x48_font->GetMode() == EColorType::Outline)
x0_drawStrOpts.x4_colors[1] = ConvertToTextureSpace(x54_colors[1]);
break;
case EColorType::Geometry:
if (!x64_colorOverrides[2])
x0_drawStrOpts.x4_colors[2] = ConvertToTextureSpace(x54_[2]);
x0_drawStrOpts.x4_colors[2] = ConvertToTextureSpace(x54_colors[2]);
break;
case EColorType::Foreground:
RefreshColor(EColorType::Main);

3
Runtime/GuiSys/CGuiCamera.cpp
View File

@ -42,7 +42,8 @@ void CGuiCamera::Draw(const CGuiWidgetDrawParms& parms) const
CGraphics::SetPerspective(xfc_fov, x100_aspect, x104_znear, x108_zfar);
else
CGraphics::SetOrtho(xfc_left, x100_right, x104_top, x108_bottom, x10c_znear, x110_zfar);
CGraphics::SetViewPointMatrix(zeus::CTransform::Translate(parms.x4_cameraOffset) * x34_worldXF);
CGraphics::SetViewPointMatrix(GetGuiFrame()->GetAspectTransform() *
zeus::CTransform::Translate(parms.x4_cameraOffset) * x34_worldXF);
CGuiWidget::Draw(parms);
}

14
Runtime/GuiSys/CGuiFrame.cpp
View File

@ -20,6 +20,12 @@ CGuiFrame::CGuiFrame(ResId id, CGuiSys& sys, int a, int b, int c, CSimplePool* s
CGuiWidget::CGuiWidgetParms(this, false, 0, 0, false, false, false, zeus::CColor::skWhite,
CGuiWidget::EGuiModelDrawFlags::Alpha, false,
x8_guiSys.x8_mode != CGuiSys::EUsageMode::Zero)));
x8_guiSys.m_registeredFrames.insert(this);
}
CGuiFrame::~CGuiFrame()
{
x8_guiSys.m_registeredFrames.erase(this);
}
CGuiWidget* CGuiFrame::FindWidget(const std::string& name) const
@ -40,7 +46,7 @@ void CGuiFrame::SortDrawOrder()
std::sort(x2c_widgets.begin(), x2c_widgets.end(),
[](const std::shared_ptr<CGuiWidget>& a, const std::shared_ptr<CGuiWidget>& b) -> bool
{
return a->GetWorldPosition().y < b->GetWorldPosition().y;
return a->GetWorldPosition().y > b->GetWorldPosition().y;
});
}
@ -103,6 +109,12 @@ void CGuiFrame::Touch() const
widget->Touch();
}
void CGuiFrame::SetAspectConstraint(float c)
{
m_aspectConstraint = c;
CGuiSys::ViewportResizeFrame(this);
}
void CGuiFrame::Update(float dt)
{
xc_headWidget->Update(dt);

7
Runtime/GuiSys/CGuiFrame.hpp
View File

@ -19,6 +19,7 @@ class CSimplePool;
class CGuiFrame
{
friend class CGuiSys;
private:
ResId x0_id;
u32 x4_ = 0;
@ -34,8 +35,12 @@ private:
int x54_c;
bool x58_24_loaded : 1;
zeus::CTransform m_aspectTransform;
float m_aspectConstraint = -1.f;
public:
CGuiFrame(ResId id, CGuiSys& sys, int a, int b, int c, CSimplePool* sp);
~CGuiFrame();
CGuiSys& GetGuiSys() {return x8_guiSys;}
@ -52,6 +57,8 @@ public:
void AddLight(std::shared_ptr<CGuiLight>&& light);
bool GetIsFinishedLoading() const;
void Touch() const;
const zeus::CTransform& GetAspectTransform() const { return m_aspectTransform; }
void SetAspectConstraint(float c);
void Update(float dt);
void Draw(const CGuiWidgetDrawParms& parms) const;

6
Runtime/GuiSys/CGuiModel.cpp
View File

@ -65,36 +65,42 @@ void CGuiModel::Draw(const CGuiWidgetDrawParms& parms) const
case EGuiModelDrawFlags::Shadeless:
{
CModelFlags flags(0, 0, 3, zeus::CColor::skWhite);
flags.m_extendedShaderIdx = 0;
model->Draw(flags);
break;
}
case EGuiModelDrawFlags::Opaque:
{
CModelFlags flags(1, 0, 3, moduCol);
flags.m_extendedShaderIdx = 1;
model->Draw(flags);
break;
}
case EGuiModelDrawFlags::Alpha:
{
CModelFlags flags(4, 0, (u32(xb7_24_depthWrite) << 1) | u32(xb6_31_depthTest), moduCol);
flags.m_extendedShaderIdx = 3;
model->Draw(flags);
break;
}
case EGuiModelDrawFlags::Additive:
{
CModelFlags flags(3, 0, (u32(xb7_24_depthWrite) << 1) | u32(xb6_31_depthTest), moduCol);
flags.m_extendedShaderIdx = 4;
model->Draw(flags);
break;
}
case EGuiModelDrawFlags::AlphaAdditiveOverdraw:
{
CModelFlags flags(4, 0, xb6_31_depthTest, moduCol);
flags.m_extendedShaderIdx = 3;
model->Draw(flags);
flags.m_blendMode = 5;
flags.m_matSetIdx = 0;
flags.m_flags = (u32(xb7_24_depthWrite) << 1) | u32(xb6_31_depthTest);
flags.color = moduCol;
flags.m_extendedShaderIdx = 4;
model->Draw(flags);
break;
}

2
Runtime/GuiSys/CGuiObject.cpp
View File

@ -1,6 +1,8 @@
#include "CGuiObject.hpp"
#include "CGuiWidgetDrawParms.hpp"
#include "Graphics/CTexture.hpp"
#include "CGuiWidget.hpp"
#include "CGuiFrame.hpp"
namespace urde
{

20
Runtime/GuiSys/CGuiPane.cpp
View File

@ -5,7 +5,7 @@ namespace urde
CGuiPane::CGuiPane(const CGuiWidgetParms& parms, const zeus::CVector2f& dim,
const zeus::CVector3f& scaleCenter)
: CGuiWidget(parms), xb8_dim(dim), x108_scaleCenter(scaleCenter)
: CGuiWidget(parms), xb8_dim(dim), xc8_scaleCenter(scaleCenter)
{
InitializeBuffers();
}
@ -14,11 +14,11 @@ void CGuiPane::ScaleDimensions(const zeus::CVector3f& scale)
{
InitializeBuffers();
for (specter::View::TexShaderVert& v : x100_verts)
for (specter::View::TexShaderVert& v : xc0_verts)
{
v.m_pos -= x108_scaleCenter;
v.m_pos -= xc8_scaleCenter;
v.m_pos *= scale;
v.m_pos += x108_scaleCenter;
v.m_pos += xc8_scaleCenter;
}
}
@ -36,13 +36,13 @@ zeus::CVector2f CGuiPane::GetDimensions() const
void CGuiPane::InitializeBuffers()
{
if (x100_verts.size() < 4)
x100_verts.resize(4);
if (xc0_verts.size() < 4)
xc0_verts.resize(4);
x100_verts[0].m_pos.assign(-xb8_dim.x * 0.5f, 0.f, xb8_dim.y * 0.5f);
x100_verts[1].m_pos.assign(-xb8_dim.x * 0.5f, 0.f, -xb8_dim.y * 0.5f);
x100_verts[2].m_pos.assign(xb8_dim.x * 0.5f, 0.f, xb8_dim.y * 0.5f);
x100_verts[3].m_pos.assign(xb8_dim.x * 0.5f, 0.f, -xb8_dim.y * 0.5f);
xc0_verts[0].m_pos.assign(-xb8_dim.x * 0.5f, 0.f, xb8_dim.y * 0.5f);
xc0_verts[1].m_pos.assign(-xb8_dim.x * 0.5f, 0.f, -xb8_dim.y * 0.5f);
xc0_verts[2].m_pos.assign(xb8_dim.x * 0.5f, 0.f, xb8_dim.y * 0.5f);
xc0_verts[3].m_pos.assign(xb8_dim.x * 0.5f, 0.f, -xb8_dim.y * 0.5f);
}
void CGuiPane::WriteData(COutputStream& out, bool flag) const

4
Runtime/GuiSys/CGuiPane.hpp
View File

@ -13,10 +13,10 @@ protected:
zeus::CVector2f xb8_dim;
/* Originally a vert-buffer pointer for GX */
std::vector<specter::View::TexShaderVert> x100_verts;
std::vector<specter::View::TexShaderVert> xc0_verts;
// u32 x104_ = 4; /* vert count */
zeus::CVector3f x108_scaleCenter;
zeus::CVector3f xc8_scaleCenter;
public:
CGuiPane(const CGuiWidgetParms& parms, const zeus::CVector2f& dim, const zeus::CVector3f& scaleCenter);

27
Runtime/GuiSys/CGuiSys.cpp
View File

@ -15,6 +15,7 @@
#include "CTextParser.hpp"
#include "CSimplePool.hpp"
#include "CTextExecuteBuffer.hpp"
#include "CGuiFrame.hpp"
namespace urde
{
@ -68,4 +69,30 @@ CGuiSys::CGuiSys(IFactory& resFactory, CSimplePool& resStore, EUsageMode mode)
g_TextParser = x10_textParser.get();
}
void CGuiSys::OnViewportResize()
{
for (CGuiFrame* frame : m_registeredFrames)
ViewportResizeFrame(frame);
}
void CGuiSys::ViewportResizeFrame(CGuiFrame* frame)
{
float vpAspectRatio = CGraphics::g_ViewportResolution.x / float(CGraphics::g_ViewportResolution.y);
if (frame->m_aspectConstraint > 0.f)
{
float hPad, vPad;
if (vpAspectRatio >= frame->m_aspectConstraint)
{
hPad = frame->m_aspectConstraint / vpAspectRatio;
vPad = frame->m_aspectConstraint / 1.36f;
}
else
{
hPad = 1.f;
vPad = vpAspectRatio / 1.36f;
}
frame->m_aspectTransform = zeus::CTransform::Scale({hPad, 1.f, vPad});
}
}
}

4
Runtime/GuiSys/CGuiSys.hpp
View File

@ -36,6 +36,7 @@ private:
EUsageMode x8_mode;
std::unique_ptr<CTextExecuteBuffer> xc_textExecuteBuf;
std::unique_ptr<CTextParser> x10_textParser;
std::unordered_set<CGuiFrame*> m_registeredFrames;
static std::shared_ptr<CGuiWidget> CreateWidgetInGame(FourCC type, CInputStream& in,
CGuiFrame* frame, CSimplePool* sp);
@ -44,6 +45,9 @@ public:
CSimplePool& GetResStore() {return x4_resStore;}
EUsageMode GetUsageMode() const {return x8_mode;}
void OnViewportResize();
static void ViewportResizeFrame(CGuiFrame* frame);
};
/** Global GuiSys instance */

8
Runtime/GuiSys/CGuiTextPane.cpp
View File

@ -56,7 +56,7 @@ void CGuiTextPane::Draw(const CGuiWidgetDrawParms& parms) const
dims.y = 0.f;
zeus::CTransform local =
zeus::CTransform::Translate(x100_verts.front().m_pos + x108_scaleCenter) *
zeus::CTransform::Translate(xc0_verts.front().m_pos + xc8_scaleCenter) *
zeus::CTransform::Scale(dims.x, 1.f, dims.y);
CGraphics::SetModelMatrix(x34_worldXF * local);
@ -108,10 +108,10 @@ std::shared_ptr<CGuiWidget> CGuiTextPane::Create(CGuiFrame* frame, CInputStream&
zeus::CVector3f vec = zeus::CVector3f::ReadBig(in);
u32 fontId = in.readUint32Big();
bool wordWrap = in.readBool();
bool vertical = in.readBool();
bool horizontal = in.readBool();
EJustification justification = EJustification(in.readUint32Big());
EVerticalJustification vJustification = EVerticalJustification(in.readUint32Big());
CGuiTextProperties props(wordWrap, vertical, justification, vJustification, ETextDirection::Horizontal);
CGuiTextProperties props(wordWrap, horizontal, justification, vJustification);
zeus::CColor fontCol;
fontCol.readRGBABig(in);
zeus::CColor outlineCol;
@ -123,7 +123,7 @@ std::shared_ptr<CGuiWidget> CGuiTextPane::Create(CGuiFrame* frame, CInputStream&
fontCol, outlineCol, extentX, extentY);
ret->ParseBaseInfo(frame, in, parms);
ret->InitializeBuffers();
ret->TextSupport()->SetText(u"?\?(?\?)");
ret->TextSupport()->SetText(u"");
return ret;
}

34
Runtime/GuiSys/CGuiTextSupport.cpp
View File

@ -142,7 +142,8 @@ void CGuiTextSupport::CheckAndRebuildTextBuffer()
{
g_TextExecuteBuf->Clear();
g_TextExecuteBuf->x18_textState.x7c_enableWordWrap = x14_props.x0_wordWrap;
g_TextExecuteBuf->BeginBlock(0, 0, x34_extentX, x38_extentY, x14_props.xc_direction,
g_TextExecuteBuf->BeginBlock(0, 0, x34_extentX, x38_extentY, x30_imageBaseline,
ETextDirection(!x14_props.x1_horizontal),
x14_props.x4_justification, x14_props.x8_vertJustification);
g_TextExecuteBuf->AddColor(EColorType::Main, x24_fontColor);
g_TextExecuteBuf->AddColor(EColorType::Outline, x28_outlineColor);
@ -272,7 +273,36 @@ bool CGuiTextSupport::_GetIsTextSupportFinishedLoading() const
if (!tok.IsLoaded())
return false;
}
return x2cc_font.IsLoaded();
if (x2cc_font.IsLoaded())
return x2cc_font->IsFinishedLoading();
return false;
}
void CGuiTextSupport::SetJustification(EJustification j)
{
if (j != x14_props.x4_justification)
{
x14_props.x4_justification = j;
ClearRenderBuffer();
}
}
void CGuiTextSupport::SetVerticalJustification(EVerticalJustification j)
{
if (j != x14_props.x8_vertJustification)
{
x14_props.x8_vertJustification = j;
ClearRenderBuffer();
}
}
void CGuiTextSupport::SetImageBaseline(bool b)
{
if (b != x30_imageBaseline)
{
x30_imageBaseline = b;
ClearRenderBuffer();
}
}
bool CGuiTextSupport::GetIsTextSupportFinishedLoading() const

17
Runtime/GuiSys/CGuiTextSupport.hpp
View File

@ -63,16 +63,15 @@ class CGuiTextProperties
{
friend class CGuiTextSupport;
bool x0_wordWrap;
bool x1_multiline;
bool x1_horizontal;
EJustification x4_justification;
EVerticalJustification x8_vertJustification;
ETextDirection xc_direction;
u32 xc_;
public:
CGuiTextProperties(bool wordWrap, bool multiline, EJustification justification,
EVerticalJustification vertJustification,
ETextDirection dir=ETextDirection::Horizontal)
: x0_wordWrap(wordWrap), x1_multiline(multiline), x4_justification(justification),
x8_vertJustification(vertJustification), xc_direction(dir) {}
CGuiTextProperties(bool wordWrap, bool horizontal, EJustification justification,
EVerticalJustification vertJustification, u32 unk=0)
: x0_wordWrap(wordWrap), x1_horizontal(horizontal), x4_justification(justification),
x8_vertJustification(vertJustification), xc_(unk) {}
};
class CGuiTextSupport
@ -84,6 +83,7 @@ class CGuiTextSupport
zeus::CColor x24_fontColor;
zeus::CColor x28_outlineColor;
zeus::CColor x2c_geometryColor;
bool x30_imageBaseline = false;
s32 x34_extentX;
s32 x38_extentY;
float x3c_curTime = 0.f;
@ -131,6 +131,9 @@ public:
void AddText(const std::u16string& str);
void SetText(const std::u16string& str, bool multipage=false);
void SetText(const std::string& str, bool multipage=false);
void SetJustification(EJustification j);
void SetVerticalJustification(EVerticalJustification j);
void SetImageBaseline(bool b);
bool GetIsTextSupportFinishedLoading() const;
};

2
Runtime/GuiSys/CGuiWidget.hpp
View File

@ -129,6 +129,8 @@ public:
CGuiWidget* FindWidget(s16 id);
bool GetIsFinishedLoading() const;
void DispatchInitialize();
CGuiFrame* GetGuiFrame() const { return xb0_frame; }
};
}

78
Runtime/GuiSys/CInstruction.cpp
View File

@ -74,24 +74,39 @@ void CLineExtraSpaceInstruction::PageInvoke(CFontRenderState& state, CTextRender
Invoke(state, buf);
}
void CLineInstruction::TestLargestFont(s32 monoW, s32 monoH, s32 baseline)
void CLineInstruction::TestLargestFont(s32 w, s32 h, s32 b)
{
if (!x18_largestBaseline)
x18_largestBaseline = baseline;
if (!x18_largestMonoBaseline)
x18_largestMonoBaseline = b;
if (x14_largestMonoWidth < monoW)
monoW = x14_largestMonoWidth;
if (x14_largestMonoWidth < w)
x14_largestMonoWidth = w;
if (x10_largestMonoHeight < monoH)
if (x10_largestMonoHeight < h)
{
x10_largestMonoHeight = monoH;
x18_largestBaseline = baseline;
x10_largestMonoHeight = h;
x18_largestMonoBaseline = b;
}
}
void CLineInstruction::TestLargestImage(s32 w, s32 h, s32 b)
{
if (!x24_largestImageBaseline)
x24_largestImageBaseline = b;
if (x20_largestImageWidth < w)
x20_largestImageWidth = w;
if (x1c_largestImageHeight < h)
{
x1c_largestImageHeight = h;
x24_largestImageBaseline = b;
}
}
void CLineInstruction::InvokeLTR(CFontRenderState& state) const
{
switch (x1c_just)
switch (x28_just)
{
case EJustification::Left:
case EJustification::Full:
@ -228,17 +243,26 @@ void CImageInstruction::Invoke(CFontRenderState& state, CTextRenderBuffer* buf)
{
if (x4_image.IsLoaded() && x4_image.x4_texs.size())
{
if (state.x88_curBlock->x14_direction == ETextDirection::Horizontal)
const CTexture* tex = x4_image.x4_texs[0].GetObj();
if (state.x88_curBlock->x14_dir == ETextDirection::Horizontal)
{
const CTexture* tex = x4_image.x4_texs[0].GetObj();
if (buf)
{
zeus::CVector2i coords(state.xd4_curX,
state.xd8_curY + state.xdc_currentLineInst->x18_largestBaseline -
tex->GetHeight() * x4_image.x14_pointsPerTexel.y * 2 / 3);
int y = state.xd8_curY + state.xdc_currentLineInst->GetBaseline() - x4_image.CalculateBaseline();
zeus::CVector2i coords(state.xd4_curX, y);
buf->AddImage(coords, x4_image);
}
state.xd4_curX = state.xd4_curX + tex->GetWidth() * x4_image.x14_pointsPerTexel.x;
state.xd4_curX = state.xd4_curX + tex->GetWidth() * x4_image.x14_pointsPerTexel.y;
}
else
{
int scale = state.xdc_currentLineInst->x8_curX - tex->GetWidth() * x4_image.x14_pointsPerTexel.y;
if (buf)
{
zeus::CVector2i coords(scale / 2 + state.xd4_curX, state.xd8_curY);
buf->AddImage(coords, x4_image);
}
state.xd8_curY += x4_image.CalculateHeight();
}
}
}
@ -257,10 +281,20 @@ size_t CImageInstruction::GetAssetCount() const
void CTextInstruction::Invoke(CFontRenderState& state, CTextRenderBuffer* buf) const
{
int xOut, yOut;
state.x48_font.GetObj()->DrawString(state.x0_drawStrOpts, state.xd4_curX,
state.xdc_currentLineInst->x18_largestBaseline + state.xd8_curY,
xOut, yOut, buf, x4_str.c_str(), x4_str.size());
state.xd4_curX = xOut;
if (state.x88_curBlock->x14_dir == ETextDirection::Horizontal)
{
state.x48_font->DrawString(state.x0_drawStrOpts, state.xd4_curX,
state.xdc_currentLineInst->GetBaseline() + state.xd8_curY,
xOut, yOut, buf, x4_str.c_str(), x4_str.size());
state.xd4_curX = xOut;
}
else
{
int scale = state.xdc_currentLineInst->x8_curX - state.x48_font->GetMonoWidth();
state.x48_font->DrawString(state.x0_drawStrOpts, scale / 2 + state.xd4_curX,
state.xd8_curY, xOut, yOut, buf, x4_str.c_str(), x4_str.size());
state.xd8_curY = yOut;
}
}
void CBlockInstruction::TestLargestFont(s32 monoW, s32 monoH, s32 baseline)
@ -307,9 +341,9 @@ void CBlockInstruction::SetupPositionLTR(CFontRenderState& state) const
void CBlockInstruction::Invoke(CFontRenderState& state, CTextRenderBuffer* buf) const
{
state.x0_drawStrOpts.x0_direction = x14_direction;
state.x88_curBlock = (CBlockInstruction*)this;
if (x14_direction == ETextDirection::Horizontal)
state.x0_drawStrOpts.x0_direction = x14_dir;
state.x88_curBlock = const_cast<CBlockInstruction*>(this);
if (x14_dir == ETextDirection::Horizontal)
SetupPositionLTR(state);
}

38
Runtime/GuiSys/CInstruction.hpp
View File

@ -76,16 +76,37 @@ class CLineInstruction : public CInstruction
s32 xc_curY = 0;
s32 x10_largestMonoHeight = 0;
s32 x14_largestMonoWidth = 0;
s32 x18_largestBaseline = 0;
EJustification x1c_just;
EVerticalJustification x20_vjust;
s32 x18_largestMonoBaseline = 0;
s32 x1c_largestImageHeight = 0;
s32 x20_largestImageWidth = 0;
s32 x24_largestImageBaseline = 0;
EJustification x28_just;
EVerticalJustification x2c_vjust;
bool x30_imageBaseline;
public:
CLineInstruction(EJustification just, EVerticalJustification vjust)
: x1c_just(just), x20_vjust(vjust) {}
void TestLargestFont(s32 monoW, s32 monoH, s32 baseline);
CLineInstruction(EJustification just, EVerticalJustification vjust, bool imageBaseline)
: x28_just(just), x2c_vjust(vjust), x30_imageBaseline(imageBaseline) {}
void TestLargestFont(s32 w, s32 h, s32 b);
void TestLargestImage(s32 w, s32 h, s32 b);
void InvokeLTR(CFontRenderState& state) const;
void Invoke(CFontRenderState& state, CTextRenderBuffer* buf) const;
void PageInvoke(CFontRenderState& state, CTextRenderBuffer* buf) const;
s32 GetHeight() const
{
if (x10_largestMonoHeight && !x30_imageBaseline)
return x10_largestMonoHeight;
else
return x1c_largestImageHeight;
}
s32 GetBaseline() const
{
if (x10_largestMonoHeight && !x30_imageBaseline)
return x18_largestMonoBaseline;
else
return x24_largestImageBaseline;
}
};
class CLineSpacingInstruction : public CInstruction
@ -143,13 +164,14 @@ class CBlockInstruction : public CInstruction
friend class CTextExecuteBuffer;
friend class CLineInstruction;
friend class CImageInstruction;
friend class CTextInstruction;
friend class CWordInstruction;
s32 x4_offsetX;
s32 x8_offsetY;
s32 xc_blockExtentX;
s32 x10_blockExtentY;
ETextDirection x14_direction;
ETextDirection x14_dir;
EJustification x18_justification;
EVerticalJustification x1c_vertJustification;
s32 x20_largestMonoW = 0;
@ -162,7 +184,7 @@ public:
CBlockInstruction(s32 offX, s32 offY, s32 extX, s32 extY, ETextDirection dir,
EJustification just, EVerticalJustification vjust)
: x4_offsetX(offX), x8_offsetY(offY),
xc_blockExtentX(extX), x10_blockExtentY(extY), x14_direction(dir),
xc_blockExtentX(extX), x10_blockExtentY(extY), x14_dir(dir),
x18_justification(just), x1c_vertJustification(vjust) {}
void TestLargestFont(s32 monoW, s32 monoH, s32 baseline);
void SetupPositionLTR(CFontRenderState& state) const;

11
Runtime/GuiSys/CRasterFont.cpp
View File

@ -103,7 +103,7 @@ void CRasterFont::SinglePassDrawString(const CDrawStringOptions& opts, int x, in
{
left += x;
top += y - glyph->GetBaseline();
renderBuf->AddCharacter(zeus::CVector2i(left, top), *chr, opts.x4_colors[0]);
renderBuf->AddCharacter(zeus::CVector2i(left, top), *chr, opts.x4_colors[2]);
}
x += glyph->GetRightPadding() + glyph->GetAdvance();
}
@ -138,7 +138,6 @@ void CRasterFont::DrawString(const CDrawStringOptions& opts, int x, int y, int&
if (renderBuf)
{
/* TODO: Implement this */
/* CGraphicsPalette pal = CGraphicsPalette::CGraphcisPalette(2, 4); */
/* zeus::CColor color = zeus::CColor(0.f, 0.f, 0.f, 0.f) */
/* tmp = color.ToRGB5A3(); */
@ -148,6 +147,7 @@ void CRasterFont::DrawString(const CDrawStringOptions& opts, int x, int y, int&
/* tmp5 = tmp4.ToRGBA5A3(); */
/* pal.UnLock(); */
/* renderBuf->AddPaletteChange(pal); */
renderBuf->AddPaletteChange(opts.x4_colors[0], opts.x4_colors[1]);
}
SinglePassDrawString(opts, x, y, xout, yout, renderBuf, str, len);
@ -194,6 +194,13 @@ void CRasterFont::GetSize(const CDrawStringOptions& opts, int& width, int& heigh
}
}
bool CRasterFont::IsFinishedLoading() const
{
if (!x80_texture || !x80_texture.IsLoaded())
return false;
return true;
}
std::unique_ptr<IObj> FRasterFontFactory(const SObjectTag& tag, CInputStream& in, const CVParamTransfer& vparms,
CObjectReference* selfRef)
{

2
Runtime/GuiSys/CRasterFont.hpp
View File

@ -149,6 +149,8 @@ public:
void GetSize(const CDrawStringOptions& opts, int& width, int& height,
const char16_t* str, int len) const;
boo::ITexture* GetTexture() { return x80_texture->GetFontTexture(CTexture::EFontType(x2c_mode)); }
bool IsFinishedLoading() const;
};
std::unique_ptr<IObj> FRasterFontFactory(const SObjectTag& tag, CInputStream& in, const CVParamTransfer& vparms,

8
Runtime/GuiSys/CSaveableState.cpp
View File

@ -1,6 +1,14 @@
#include "CSaveableState.hpp"
#include "CRasterFont.hpp"
namespace urde
{
bool CSaveableState::IsFinishedLoading() const
{
if (!x48_font || !x48_font.IsLoaded())
return false;
return x48_font->IsFinishedLoading();
}
}

6
Runtime/GuiSys/CSaveableState.hpp
View File

@ -24,7 +24,7 @@ class CSaveableState
protected:
CDrawStringOptions x0_drawStrOpts;
TLockedToken<CRasterFont> x48_font;
std::vector<CTextColor> x54_;
std::vector<CTextColor> x54_colors;
std::vector<bool> x64_colorOverrides;
float x74_lineSpacing = 1.f;
s32 x78_extraLineSpace = 0;
@ -35,9 +35,11 @@ protected:
public:
CSaveableState()
{
x54_.resize(3, zeus::CColor::skBlack);
x54_colors.resize(3, zeus::CColor::skBlack);
x64_colorOverrides.resize(16);
}
bool IsFinishedLoading() const;
};
}

51
Runtime/GuiSys/CTextExecuteBuffer.cpp
View File

@ -158,9 +158,8 @@ void CTextExecuteBuffer::AddString(const char16_t* str, int count)
StartNewWord();
int w, h;
char16_t space = u' ';
x18_textState.x48_font.GetObj()->GetSize(x18_textState.x0_drawStrOpts,
w, h, &space, 1);
if (xa0_curBlock->x14_direction == ETextDirection::Horizontal)
x18_textState.x48_font->GetSize(x18_textState.x0_drawStrOpts, w, h, &space, 1);
if (xa0_curBlock->x14_dir == ETextDirection::Horizontal)
{
xa4_curLine->x8_curX += w;
xbc_spaceDistance = w;
@ -180,7 +179,7 @@ void CTextExecuteBuffer::AddString(const char16_t* str, int count)
void CTextExecuteBuffer::AddStringFragment(const char16_t* str, int len)
{
if (xa0_curBlock->x14_direction == ETextDirection::Horizontal)
if (xa0_curBlock->x14_dir == ETextDirection::Horizontal)
for (int i=0 ; i<len ;)
i += WrapOneLTR(str + i, len - i);
}
@ -193,8 +192,7 @@ int CTextExecuteBuffer::WrapOneLTR(const char16_t* str, int len)
CRasterFont* font = x18_textState.x48_font.GetObj();
int rem = len;
int w, h;
x18_textState.x48_font.GetObj()->GetSize(x18_textState.x0_drawStrOpts,
w, h, str, len);
x18_textState.x48_font->GetSize(x18_textState.x0_drawStrOpts, w, h, str, len);
if (x18_textState.x7c_enableWordWrap)
{
@ -225,8 +223,7 @@ int CTextExecuteBuffer::WrapOneLTR(const char16_t* str, int len)
}
else
{
x18_textState.x48_font.GetObj()->GetSize(x18_textState.x0_drawStrOpts,
w, h, str, rem);
x18_textState.x48_font->GetSize(x18_textState.x0_drawStrOpts, w, h, str, rem);
}
} while (w + xa4_curLine->x8_curX > xa0_curBlock->xc_blockExtentX && rem > 1);
@ -259,7 +256,7 @@ void CTextExecuteBuffer::MoveWordLTR()
TerminateLineLTR();
xa4_curLine = static_cast<CLineInstruction*>(x0_instList.emplace(xa8_curWordIt,
std::make_shared<CLineInstruction>(x18_textState.x80_just, x18_textState.x84_vjust))->get());
std::make_shared<CLineInstruction>(x18_textState.x80_just, x18_textState.x84_vjust, xc0_imageBaseline))->get());
x0_instList.emplace(xa8_curWordIt, std::make_shared<CWordInstruction>());
@ -272,7 +269,7 @@ void CTextExecuteBuffer::StartNewLine()
TerminateLine();
xa8_curWordIt = x0_instList.emplace(x0_instList.cend(),
std::make_shared<CLineInstruction>(x18_textState.x80_just, x18_textState.x84_vjust));
std::make_shared<CLineInstruction>(x18_textState.x80_just, x18_textState.x84_vjust, xc0_imageBaseline));
xa4_curLine = static_cast<CLineInstruction*>(xa8_curWordIt->get());
xbc_spaceDistance = 0;
@ -292,15 +289,16 @@ void CTextExecuteBuffer::StartNewWord()
void CTextExecuteBuffer::TerminateLine()
{
if (xa0_curBlock->x14_direction == ETextDirection::Horizontal)
if (xa0_curBlock->x14_dir == ETextDirection::Horizontal)
TerminateLineLTR();
}
void CTextExecuteBuffer::TerminateLineLTR()
{
if (!xa4_curLine->xc_curY && x18_textState.x48_font)
if (!xa4_curLine->xc_curY && x18_textState.IsFinishedLoading())
{
xa4_curLine->xc_curY = xa4_curLine->x10_largestMonoHeight;
xa4_curLine->xc_curY = std::max(xa4_curLine->GetHeight(),
x18_textState.x48_font->GetCarriageAdvance());
}
if (xa0_curBlock->x1c_vertJustification == EVerticalJustification::Full)
@ -323,8 +321,8 @@ void CTextExecuteBuffer::AddPopState()
if (!xa4_curLine->x8_curX)
{
xa4_curLine->x1c_just = x18_textState.x80_just;
xa4_curLine->x20_vjust = x18_textState.x84_vjust;
xa4_curLine->x28_just = x18_textState.x80_just;
xa4_curLine->x2c_vjust = x18_textState.x84_vjust;
}
}
@ -341,7 +339,7 @@ void CTextExecuteBuffer::AddVerticalJustification(EVerticalJustification vjust)
return;
if (xa4_curLine->x8_curX)
return;
xa4_curLine->x20_vjust = vjust;
xa4_curLine->x2c_vjust = vjust;
}
void CTextExecuteBuffer::AddJustification(EJustification just)
@ -351,7 +349,7 @@ void CTextExecuteBuffer::AddJustification(EJustification just)
return;
if (xa4_curLine->x8_curX)
return;
xa4_curLine->x1c_just = just;
xa4_curLine->x28_just = just;
}
void CTextExecuteBuffer::AddLineExtraSpace(s32 space)
@ -391,11 +389,15 @@ void CTextExecuteBuffer::AddImage(const CFontImageDef& image)
const CTexture* tex = image.x4_texs[0].GetObj();
int width = tex->GetWidth() * image.x14_pointsPerTexel.x;
int height = tex->GetHeight() * image.x14_pointsPerTexel.y;
xa4_curLine->TestLargestFont(width, height, height);
if (xa0_curBlock->x14_direction == ETextDirection::Horizontal)
if (xa4_curLine->x8_curX > width)
xa0_curBlock->x2c_lineX = xa4_curLine->x8_curX;
if (xa4_curLine->x8_curX + width > xa0_curBlock->xc_blockExtentX && xa4_curLine->x4_wordCount > 0)
StartNewLine();
xa4_curLine->TestLargestImage(width, height, image.CalculateBaseline());
xa4_curLine->x8_curX += width;
if (xa4_curLine->x8_curX > width)
xa0_curBlock->x2c_lineX = xa4_curLine->x8_curX;
}
x0_instList.emplace(x0_instList.cend(), std::make_shared<CImageInstruction>(image));
@ -425,12 +427,13 @@ void CTextExecuteBuffer::EndBlock()
xa0_curBlock = nullptr;
}
void CTextExecuteBuffer::BeginBlock(s32 offX, s32 offY, s32 padX, s32 padY,
ETextDirection dir, EJustification just,
void CTextExecuteBuffer::BeginBlock(s32 offX, s32 offY, s32 extX, s32 extY,
bool imageBaseline, ETextDirection dir, EJustification just,
EVerticalJustification vjust)
{
xc0_imageBaseline = imageBaseline;
xa0_curBlock = static_cast<CBlockInstruction*>(x0_instList.emplace(x0_instList.cend(),
std::make_shared<CBlockInstruction>(offX, offY, padX, padY, dir, just, vjust))->get());
std::make_shared<CBlockInstruction>(offX, offY, extX, extY, dir, just, vjust))->get());
if (x18_textState.x48_font)
{

6
Runtime/GuiSys/CTextExecuteBuffer.hpp
View File

@ -30,7 +30,7 @@ class CTextExecuteBuffer
s32 xb4_curWordX = 0;
s32 xb8_curWordY = 0;
s32 xbc_spaceDistance = 0;
bool xc0_ = false;
bool xc0_imageBaseline = false;
std::list<CSaveableState> xc4_stateStack;
u32 xd8_ = 0;
@ -68,8 +68,8 @@ public:
void AddImage(const CFontImageDef& image);
void AddFont(const TToken<CRasterFont>& font);
void EndBlock();
void BeginBlock(s32 offX, s32 offY, s32 padX, s32 padY,
ETextDirection dir, EJustification just,
void BeginBlock(s32 offX, s32 offY, s32 extX, s32 extY,
bool imageBaseline, ETextDirection dir, EJustification just,
EVerticalJustification vjust);
void Clear();
};

7
Runtime/GuiSys/CTextRenderBuffer.cpp
View File

@ -37,8 +37,7 @@ void CTextRenderBuffer::BooPrimitiveMark::SetOpacity(CTextRenderBuffer& rb, floa
{
BooFontCharacters& fc = rb.m_fontCharacters[m_bindIdx];
CTextSupportShader::CharacterInstance& inst = fc.m_charData[m_instIdx];
inst.m_fontColor.a = opacity;
inst.m_outlineColor.a = opacity;
inst.m_mulColor.a = opacity;
fc.m_dirty = true;
break;
}
@ -89,8 +88,9 @@ void CTextRenderBuffer::CommitResources()
{buf, nullptr, boo::VertexSemantic::UV4 | boo::VertexSemantic::Instanced, 3},
{buf, nullptr, boo::VertexSemantic::Color | boo::VertexSemantic::Instanced, 0},
{buf, nullptr, boo::VertexSemantic::Color | boo::VertexSemantic::Instanced, 1},
{buf, nullptr, boo::VertexSemantic::Color | boo::VertexSemantic::Instanced, 2},
};
vFmt = ctx.newVertexFormat(10, elems, 0, iBufInfo.second);
vFmt = ctx.newVertexFormat(11, elems, 0, iBufInfo.second);
}
boo::IGraphicsBuffer* uniforms[] = {uBufInfo.first};
@ -227,6 +227,7 @@ void CTextRenderBuffer::AddCharacter(const zeus::CVector2i& offset, char16_t ch,
inst.SetMetrics(*glyph, offset);
inst.m_fontColor = m_main * color;
inst.m_outlineColor = m_outline * color;
inst.m_mulColor = zeus::CColor::skWhite;
}
}

61
Runtime/MP1/CFrontEndUI.cpp
View File

@ -82,6 +82,8 @@ CFrontEndUI::SNewFileSelectFrame::SNewFileSelectFrame(CSaveUI* sui, u32 rnd)
void CFrontEndUI::SNewFileSelectFrame::FinishedLoading()
{
x1c_loadedFrame->SetAspectConstraint(1.78f);
x20_tablegroup_fileselect = static_cast<CGuiTableGroup*>(x1c_loadedFrame->FindWidget("tablegroup_fileselect"));
x24_model_erase = static_cast<CGuiModel*>(x1c_loadedFrame->FindWidget("model_erase"));
xf8_model_erase_position = x24_model_erase->GetLocalPosition();
@ -836,6 +838,8 @@ void CFrontEndUI::SFusionBonusFrame::SGBALinkFrame::Update(float dt)
void CFrontEndUI::SFusionBonusFrame::SGBALinkFrame::FinishedLoading()
{
x8_frme->SetAspectConstraint(1.78f);
xc_textpane_instructions = FindTextPanePair(x8_frme, "textpane_instructions");
x14_textpane_yes = static_cast<CGuiTextPane*>(x8_frme->FindWidget("textpane_yes"));
x18_textpane_no = static_cast<CGuiTextPane*>(x8_frme->FindWidget("textpane_no"));
@ -867,6 +871,8 @@ CFrontEndUI::SFusionBonusFrame::SGBALinkFrame::SGBALinkFrame(CGuiFrame* linkFram
void CFrontEndUI::SFusionBonusFrame::FinishedLoading()
{
x24_loadedFrame->SetAspectConstraint(1.78f);
x28_tablegroup_options = static_cast<CGuiTableGroup*>(x24_loadedFrame->FindWidget("tablegroup_options"));
x2c_tablegroup_fusionsuit = static_cast<CGuiTableGroup*>(x24_loadedFrame->FindWidget("tablegroup_fusionsuit"));
x30_textpane_instructions = FindTextPanePair(x24_loadedFrame, "textpane_instructions");
@ -992,11 +998,13 @@ CFrontEndUI::SFusionBonusFrame::ProcessUserInput(const CFinalInput& input, CSave
x39_fusionNotComplete = true;
else if (sui)
sui->SaveNESState();
else if (x24_loadedFrame)
x24_loadedFrame->ProcessUserInput(input);
}
}
}
else if (x24_loadedFrame)
{
x24_loadedFrame->ProcessUserInput(input);
}
}
return x8_action;
@ -1115,6 +1123,8 @@ void CFrontEndUI::FindAndSetPairText(CGuiFrame* frame, const char* name, const s
void CFrontEndUI::SFrontEndFrame::FinishedLoading()
{
x14_loadedFrme->SetAspectConstraint(1.78f);
x18_tablegroup_mainmenu = static_cast<CGuiTableGroup*>(x14_loadedFrme->FindWidget("tablegroup_mainmenu"));
x1c_gbaPair = FindTextPanePair(x14_loadedFrme, "textpane_gba");
x1c_gbaPair.SetPairText(g_MainStringTable->GetString(37));
@ -1243,8 +1253,7 @@ CFrontEndUI::SNesEmulatorFrame::SNesEmulatorFrame()
const SObjectTag* deface = g_ResFactory->GetResourceIdByName("FONT_Deface14B");
CGuiTextProperties props(false, true, EJustification::Left,
EVerticalJustification::Center,
ETextDirection::Horizontal);
EVerticalJustification::Center);
xc_textSupport = std::make_unique<CGuiTextSupport>(deface->id, props, zeus::CColor::skWhite,
zeus::CColor::skBlack, zeus::CColor::skWhite,
0, 0, g_SimplePool, CGuiWidget::EGuiModelDrawFlags::Alpha);
@ -1572,6 +1581,8 @@ void CFrontEndUI::SOptionsFrontEndFrame::SetTableColors(CGuiTableGroup* tbgp) co
void CFrontEndUI::SOptionsFrontEndFrame::FinishedLoading()
{
x1c_loadedFrame->SetAspectConstraint(1.78f);
x24_tablegroup_leftmenu = static_cast<CGuiTableGroup*>(x1c_loadedFrame->FindWidget("tablegroup_leftmenu"));
x28_tablegroup_rightmenu = static_cast<CGuiTableGroup*>(x1c_loadedFrame->FindWidget("tablegroup_rightmenu"));
x2c_tablegroup_double = static_cast<CGuiTableGroup*>(x1c_loadedFrame->FindWidget("tablegroup_double"));
@ -1912,22 +1923,24 @@ void CFrontEndUI::Draw() const
//g_Renderer->SetDepthReadWrite(false, false);
g_Renderer->SetViewportOrtho(false, -4096.f, 4096.f);
/* Correct movie aspect ratio */
float vpAspectRatio = CGraphics::g_ViewportResolution.x / float(CGraphics::g_ViewportResolution.y);
float hPad, vPad;
if (vpAspectRatio >= 1.78f)
{
hPad = 1.78f / vpAspectRatio;
vPad = 1.78f / 1.33f;
}
else
{
hPad = 1.f;
vPad = vpAspectRatio / 1.33f;
}
if (xcc_curMoviePtr && xcc_curMoviePtr->GetIsFullyCached())
{
/* Render movie */
float vpAspectRatio = CGraphics::g_ViewportResolution.x / float(CGraphics::g_ViewportResolution.y);
if (vpAspectRatio >= 1.78f)
{
float hPad = 1.78f / vpAspectRatio;
float vPad = 1.78f / 1.33f;
xcc_curMoviePtr->SetFrame({-hPad, vPad, 0.f}, {-hPad, -vPad, 0.f}, {hPad, -vPad, 0.f}, {hPad, vPad, 0.f});
}
else
{
float vPad = vpAspectRatio / 1.33f;
xcc_curMoviePtr->SetFrame({-1.f, vPad, 0.f}, {-1.f, -vPad, 0.f}, {1.f, -vPad, 0.f}, {1.f, vPad, 0.f});
}
xcc_curMoviePtr->SetFrame({-hPad, vPad, 0.f}, {-hPad, -vPad, 0.f}, {hPad, -vPad, 0.f}, {hPad, vPad, 0.f});
xcc_curMoviePtr->DrawFrame();
}
@ -1950,18 +1963,6 @@ void CFrontEndUI::Draw() const
if (x64_pressStartAlpha > 0.f && x38_pressStart.IsLoaded() && m_pressStartQuad)
{
/* Render "Press Start" */
float vpAspectRatio = CGraphics::g_ViewportResolution.x / float(CGraphics::g_ViewportResolution.y);
float hPad, vPad;
if (vpAspectRatio >= 1.78f)
{
hPad = 1.78f / vpAspectRatio;
vPad = 1.78f / 1.33f;
}
else
{
hPad = 1.f;
vPad = vpAspectRatio / 1.33f;
}
zeus::CRectangle rect(0.5f - x38_pressStart->GetWidth() / 2.f / 640.f * hPad,
0.5f + (x38_pressStart->GetHeight() / 2.f - 240.f + 72.f) / 480.f * vPad,
x38_pressStart->GetWidth() / 640.f * hPad,
@ -2003,7 +2004,7 @@ void CFrontEndUI::Draw() const
}
}
if (0 && xdc_saveUI)
if (xdc_saveUI)
{
/* Render memory card feedback strings */
if ((CanShowSaveUI() && !xdc_saveUI->IsHiddenFromFrontEnd()) ||

1
Runtime/MP1/CSaveUI.cpp
View File

@ -119,6 +119,7 @@ bool CSaveUI::PumpLoad()
return false;
x50_loadedFrame = x44_frmeGenericMenu.GetObj();
x50_loadedFrame->SetAspectConstraint(1.78f);
x54_textpane_message = static_cast<CGuiTextPane*>(x50_loadedFrame->FindWidget("textpane_message"));
x58_tablegroup_choices = static_cast<CGuiTableGroup*>(x50_loadedFrame->FindWidget("tablegroup_choices"));
x5c_textpane_choice0 = static_cast<CGuiTextPane*>(x50_loadedFrame->FindWidget("textpane_choice0"));

3
Runtime/World/CWorldTransManager.cpp
View File

@ -381,8 +381,7 @@ void CWorldTransManager::EnableTransition(ResId fontId, ResId stringId, bool b1,
x4_modelData.reset();
x44_27_ = b2;
CGuiTextProperties props(false, true, EJustification::Center,
EVerticalJustification::Center, ETextDirection::Horizontal);
CGuiTextProperties props(false, true, EJustification::Center, EVerticalJustification::Center);
x8_textData.reset(new CGuiTextSupport(fontId, props, zeus::CColor::skWhite,
zeus::CColor::skBlack, zeus::CColor::skWhite,
640, 448, g_SimplePool, CGuiWidget::EGuiModelDrawFlags::Alpha));

2
hecl

@ -1 +1 @@
Subproject commit 1dbd769296619bfa0a9534c76c43c83ae7b7eede
Subproject commit 373ec1909d30ef1ba14179a0e8681ca3bce9c725