#include #include #include "Engine/Source/Frame/CSimpleRender.h" #include #include #include #include "Engine/Source/Base/ConvertUTF.h" #include "Engine/Source/FrameScript/FrameScript.h" #include "Engine/Source/Base/Coordinate.h" #include "Engine/Source/Base/Handle.h" #include "Engine/Source/Frame/CSimpleTexture.h" #include "Engine/Source/Frame/CSimpleTop.h" #include "Engine/Source/Frame/CRenderBatch.h" #include "Engine/Source/Frame/CSimpleEmbeddedTexture.h" #include "Engine/Source/Gxu/GxuFontString.h" #include "Engine/Source/Gx/CGxDevice/CGxDevice.h" #include "Engine/Source/Gx/CGxDevice/CGxShader.h" #include "Engine/Source/Gx/CGxVertexPCT.h" #include "Engine/Source/Gx/Gx.h" #include "Engine/Source/Gxu/GxuFont.h" #include "Engine/Source/Services/Texture.h" #include "Engine/Source/Tempest/C44Matrix.h" #include "Engine/Source/Services/TextBlock.h" #include "Engine/Source/Frame/CScriptObject.h" #include "Engine/Source/Frame/CScriptRegion.h" #include "Engine/Source/Storm/H/storm.h" #include "Engine/Source/lua-5.1/src/lauxlib.h" #include #include "Engine/Source/Base/Status.h" #include "Engine/Source/Frame/CSimpleFont.h" #include "Engine/Source/Frame/CSimpleFontStringAttributes.h" #include "Engine/Source/Frame/CSimpleFrame.h" #include "Engine/Source/FrameScript/Types.h" #include "Engine/Source/FrameXML/FrameXML.h" #include "Engine/Source/FrameXML/LoadXML.h" #include "Engine/Source/FrameXML/XMLTree.h" #include "Engine/Source/Tempest/CMath.h" #include "Engine/Source/Frame/CFramePoint.h" #include "Engine/Source/Frame/CSimpleRegion.h" #include "Engine/Source/Services/SysMessage.h" #include "Engine/Source/Tempest/CImVector.h" #include "Engine/Source/Tempest/CRect.h" // STATIC: 0x009EA254 static const uint8_t s_letterHasFinalConsonant[26] = { 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0 }; // STATIC: 0x009EA270 static const uint8_t s_digitHasFinalConsonant[10] = { 1, 1, 0, 1, 0, 0, 1, 1, 1, 0 }; // STATIC: 0x00B41928 static uint16_t s_languageWideBuffer[0x2000]; // STATIC: 0x00B45928 static char s_languageBuffer[0x2000]; // STATIC: 0x00AC0F14 static TSExplicitList s_embeddedTextureStorage; // STATIC: 0x00B47940 CGxShader* CSimpleRender::s_vertexShader[2]; // STATIC: 0x00B47948 int32_t CSimpleRender::s_mergeEnable; // STATIC: 0x00B47978 static char s_displayText[0x2000]; // STATIC: 0x00AC0EF4 const char* CSimpleTexture::s_objectTypeName = "Texture"; // STATIC: 0x00AC0EF8 const char* CSimpleTexture::s_imageModePixelShaderNames[2] = { "UI", "Desaturate" }; // STATIC: 0x00AC0F00 EGxTexFilter CSimpleTexture::s_textureFilterMode = GxTex_Linear; // STATIC: 0x00B47930 int32_t CSimpleTexture::s_count; // STATIC: 0x00B47934 CGxShader* CSimpleTexture::s_imageModePixelShaders[2]; // STATIC: 0x00B4793C int32_t CSimpleTexture::s_objectType; // STATIC: 0x00B4794C CDataAllocator CSimpleTexture::s_allocator(sizeof(CSimpleTexture), 0x2E0); // STATIC: 0x00AC1114 int32_t CSimpleFontString::s_metatable = LUA_NOREF; // STATIC: 0x00B4792C int32_t CSimpleFontString::s_objectType; // STATIC: 0x00AC0F10 const char* CSimpleFontString::s_objectTypeName = "FontString"; // STATIC: 0x00B47960 CDataAllocator CSimpleFontString::s_allocator(sizeof(CSimpleFontString), 809); // STATIC: 0x00B47928 static int32_t s_fontStringCount; // VERIFY: 0e98fd61 auto // OFFSET: 0x004826D0 static int32_t IsRectOffscreen(const CRect& rect) { return rect.maxY < 0.0f || rect.minY > 1.0f || rect.maxX < 0.0f || rect.minX > 1.0f; } // VERIFY: d066960a manual // OFFSET: 0x00481960 static const uint16_t* LanguageRule1ChooseParticle(uint32_t lastChar, const uint16_t* consonantForm, const uint16_t* vowelForm) { if (lastChar & 0xFF00) { if (static_cast(lastChar + 0x5400) > 0x2BA3) { return consonantForm; } int32_t syllable = static_cast(lastChar); if ((syllable - 0xAC08) % 28 == 0 && *consonantForm == 0xC73C) { return vowelForm; } return (syllable - 0xAC00) % 28 ? consonantForm : vowelForm; } if (static_cast(lastChar - '0') <= 9) { return s_digitHasFinalConsonant[static_cast(lastChar) - '0'] ? consonantForm : vowelForm; } if ((lastChar >= 'a' && lastChar <= 'z') || static_cast(lastChar - 'A') <= 25) { return s_letterHasFinalConsonant[tolower(static_cast(lastChar)) - 'a'] ? consonantForm : vowelForm; } return consonantForm; } // VERIFY: f67eabcd manual // OFFSET: 0x00481A00 static char* LanguageRule1(const char* text) { uint16_t buffer[0x2000]; uint32_t lastChar = 0; SUniConvertUTF8to16(buffer, sizeof(buffer) / sizeof(buffer[0]), text, STORM_MAX_STR, nullptr, nullptr); uint16_t* dest = s_languageWideBuffer; const uint16_t* src = buffer; if (buffer[0]) { do { uint16_t ch = *src; if (ch == '|') { src++; ch = *src; if (ch == '1' && (src[1] > '9' || src[1] < '0')) { const uint16_t* consonantForm = src + 1; const uint16_t* vowelForm = consonantForm; if (*vowelForm) { uint16_t c; do { c = *vowelForm; vowelForm++; } while (c != ';' && *vowelForm); } const uint16_t* end = vowelForm; if (*end) { uint16_t c; do { c = *end; end++; } while (c != ';' && *end); } src = end - 1; const uint16_t* particle = LanguageRule1ChooseParticle(lastChar, consonantForm, vowelForm); for (uint16_t c = *particle; c && c != ';'; c = *particle) { particle++; *dest = c; dest++; } } else { *dest = '|'; dest++; *dest = ch; dest++; if (ch == 'c' || ch == 'C') { for (uint32_t i = 0; i < 8 && src[1]; i++) { src++; *dest = *src; dest++; } } } } else { if ((ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z') || (ch >= '0' && ch <= '9') || static_cast(ch + 0x5400) <= 0x2BA3) { lastChar = ch; } *dest = ch; dest++; } src++; } while (*src); } *dest = 0; SUniConvertUTF16to8(s_languageBuffer, sizeof(s_languageBuffer), s_languageWideBuffer, STORM_MAX_STR, nullptr, nullptr); return s_languageBuffer; } // VERIFY: 8cd26535 manual // OFFSET: 0x00481BC0 static bool LanguageRule2IsVowel(uint16_t ch) { switch (ch) { case 'A': case 'E': case 'I': case 'O': case 'U': case 'a': case 'e': case 'i': case 'o': case 'u': return true; default: return (ch >= 0xC0 && ch <= 0xC6) || (ch >= 0xC8 && ch <= 0xCF) || (ch >= 0xD2 && ch <= 0xD6) || (ch >= 0xD8 && ch <= 0xDC) || (ch >= 0xE0 && ch <= 0xE6) || (ch >= 0xE8 && ch <= 0xEF) || (ch >= 0xF2 && ch <= 0xF6) || static_cast(ch - 0xF8) <= 4; } } // VERIFY: 7f584b59 manual // OFFSET: 0x00481C80 static char* LanguageRule2(const char* text) { uint16_t buffer[0x2000]; SUniConvertUTF8to16(buffer, sizeof(buffer) / sizeof(buffer[0]), text, STORM_MAX_STR, nullptr, nullptr); uint16_t* dest = s_languageWideBuffer; const uint16_t* src = buffer; if (buffer[0]) { do { if (*src == '|') { src++; if (*src == '2' && (src[1] > '9' || src[1] < '0')) { src++; while (*src == ' ') { src++; } uint16_t ch = *src; if (ch == 'L' && src[1] == '\'') { *dest++ = 'd'; *dest++ = 'e'; *dest++ = ' '; *dest++ = 'l'; *dest = '\''; src += 2; } else if (ch == 'L' && src[1] == 'e' && src[2] == ' ') { *dest++ = 'd'; *dest++ = 'u'; *dest = ' '; src += 3; } else if (ch == 'L' && src[1] == 'a' && src[2] == ' ') { *dest++ = 'd'; *dest++ = 'e'; *dest++ = ' '; *dest++ = 'l'; *dest++ = 'a'; *dest = ' '; src += 3; } else if (ch == 'L' && src[1] == 'e' && src[2] == 's' && src[3] == ' ') { *dest++ = 'd'; *dest++ = 'e'; *dest++ = 's'; *dest = ' '; src += 4; } else if (LanguageRule2IsVowel(ch) || ch == 'h' || ch == 'H' || (ch == 'y' && LanguageRule2IsVowel(src[1])) || (ch == 'Y' && LanguageRule2IsVowel(src[1]))) { *dest++ = 'd'; *dest = '\''; } else { *dest++ = 'd'; *dest++ = 'e'; *dest = ' '; } } else { *dest = '|'; } dest++; } *dest = *src; src++; dest++; } while (*src); } *dest = 0; SUniConvertUTF16to8(s_languageBuffer, sizeof(s_languageBuffer), s_languageWideBuffer, STORM_MAX_STR, nullptr, nullptr); return s_languageBuffer; } // VERIFY: 1b50c04d manual // OFFSET: 0x00481E90 static char* LanguageRule3(const char* text) { char copy[0x2000]; char word[0x400]; if (text == s_languageBuffer) { SStrCopy(copy, text, sizeof(copy)); text = copy; } const char* src = text; char* dest = s_languageBuffer; while (*src) { if (*src == '|') { src++; if (*src == '3' && (src[1] > '9' || src[1] < '0')) { if (src[1] == '-' && src[2] >= '0' && src[2] <= '9') { src += 2; } uint32_t declension = SStrToUnsigned(&src); if (*src == '(') { src++; } char* wordEnd = word; while (*src && *src != ')') { if (wordEnd < &word[sizeof(word) - 1]) { *wordEnd++ = *src; } src++; } if (!*src) { src--; } *wordEnd = 0; dest += GetDeclinedWord(word, declension, dest, &s_languageBuffer[sizeof(s_languageBuffer)] - dest); } else { *dest = '|'; dest++; *dest = *src; dest++; } } else { *dest = *src; dest++; } src++; } *dest = 0; return s_languageBuffer; } // VERIFY: 1e0898ef manual // OFFSET: 0x00481FC0 static char* LanguageRule4(const char* text) { bool wasDigit = false; int32_t number = 0; const char* src = text; char* dest = s_languageBuffer; while (*src) { char ch = *src; bool isDigit; if (ch >= '0' && ch <= '9') { number = wasDigit ? number * 10 + ch - '0' : ch - '0'; isDigit = true; } else { isDigit = false; } if (ch == '|') { src++; if (*src == '4' && (src[1] > '9' || src[1] < '0')) { src++; uint32_t index = FrameScript_GetPluralIndex(number); for (uint32_t i = 0; i < index && *src; i++) { while (*src != ':' && *src != ';') { src++; if (!*src) { break; } } if (!*src || *src == ';') { break; } src++; } while (*src == ' ') { src++; } if (!*src) { break; } while (*src != ':' && *src != ';') { *dest = *src; src++; dest++; if (!*src) { *dest = 0; return s_languageBuffer; } } while (*src != ';') { src++; if (!*src) { *dest = 0; return s_languageBuffer; } } } else { *dest = '|'; dest++; *dest = *src; dest++; } } else { *dest = ch; dest++; } src++; wasDigit = isDigit; } *dest = 0; return s_languageBuffer; } // VERIFY: 44de3423 manual // OFFSET: 0x00482110 const char* LanguageProcess(const char* text) { if (SStrLen(text) > sizeof(s_languageBuffer)) { memcpy(s_languageBuffer, text, sizeof(s_languageBuffer)); s_languageBuffer[sizeof(s_languageBuffer) - 3] = 0; s_languageBuffer[sizeof(s_languageBuffer) - 2] = 0; s_languageBuffer[sizeof(s_languageBuffer) - 1] = 0; text = s_languageBuffer; } for (;;) { const uint8_t* src = reinterpret_cast(text); int32_t chars; uint32_t ch; int32_t rule = 0; while ((ch = sgetu8(src, &chars)) != 0xFFFFFFFF) { src += chars; if (ch != '|') { continue; } if (*src == '|') { src++; continue; } if (*src >= '0' && *src <= '9') { rule = SStrToInt(reinterpret_cast(src)); if (rule >= 1 && rule <= 4) { break; } } } if (ch == 0xFFFFFFFF) { return text; } switch (rule) { case 1: text = LanguageRule1(text); break; case 2: text = LanguageRule2(text); break; case 3: text = LanguageRule3(text); break; case 4: text = LanguageRule4(text); break; } } } // INLINED int32_t CSimpleFontString::GetObjectType() { if (!CSimpleFontString::s_objectType) { CSimpleFontString::s_objectType = ++FrameScript_Object::s_objectTypes; } return CSimpleFontString::s_objectType; } // VERIFY: a08564ec auto // OFFSET: 0x00485390 bool CSimpleFontString::IsA(int32_t type) { return type == CSimpleFontString::s_objectType || type == CScriptRegion::s_objectType || type == CScriptObject::s_objectType; } // VERIFY: 9da7e913 auto // OFFSET: 0x004853C0 bool CSimpleFontString::IsA(const char* typeName) { return !SStrCmpI(typeName, CSimpleFontString::s_objectTypeName, STORM_MAX_STR) || !SStrCmpI(typeName, CScriptRegion::s_objectTypeName, STORM_MAX_STR) || !SStrCmpI(typeName, CScriptObject::s_objectTypeName, STORM_MAX_STR); } // VERIFY: 3a930695 auto // OFFSET: 0x00485420 const char* CSimpleFontString::GetObjectTypeName() { return CSimpleFontString::s_objectTypeName; } // VERIFY: 210fa960 auto // OFFSET: 0x00485430 int32_t CSimpleFontString::GetScriptMetaTable() { return CSimpleFontString::s_metatable; } // VERIFY: c3b240f1 auto // OFFSET: 0x00482270 const char* CSimpleFontString::GetFontName() { return this->m_fontHandle ? TextBlockGetFontName(this->m_fontHandle) : nullptr; } // VERIFY: b8a061b3 auto // OFFSET: 0x00482300 uint32_t CSimpleFontString::GetFontFlags() { return this->m_fontHandle ? TextBlockGetFontFlags(this->m_fontHandle) : 0; } // VERIFY: 86381625 auto // OFFSET: 0x00482E90 void CSimpleRender::Init() { g_theGxDevicePtr->ShaderCreate(CSimpleRender::s_vertexShader, GxSh_Vertex, "Shaders\\Vertex", "UI", 2); } // VERIFY: ea0ca375 manual // OFFSET: 0x00482EC0 void CSimpleRender::Destroy() { for (int32_t i = 0; i < 2; i++) { if (CSimpleRender::s_vertexShader[i]) { g_theGxDevicePtr->ShaderDestroy(CSimpleRender::s_vertexShader[i]); } } } // VERIFY: d4f7147d manual // OFFSET: 0x00482F00 int32_t CSimpleRender::CalcBatchCounts(CRenderBatch* batch, uint32_t* vertCounts, uint32_t* idxCounts) { CGxTex* textureID = reinterpret_cast(-1); int32_t alphaMode = GxBlends_Last; CGxShader* shader = nullptr; int32_t batchIndex = -1; uint32_t vertTotal = 0; uint32_t idxTotal = 0; for (uint32_t i = 0; i < batch->m_texturelist.Count(); i++) { CSimpleBatchedMesh* mesh = &batch->m_texturelist[i]; int32_t changed = 0; if (mesh->m_textureID != textureID) { textureID = mesh->m_textureID; changed = 1; } int32_t meshAlphaMode = (mesh->m_color && mesh->m_alphaMode < GxBlend_Alpha) ? GxBlend_Alpha : mesh->m_alphaMode; if (meshAlphaMode != alphaMode) { alphaMode = meshAlphaMode; changed = 1; } if (mesh->m_shader != shader) { shader = mesh->m_shader; changed = 1; } if (!CSimpleRender::s_mergeEnable || changed || idxTotal + mesh->m_idxCount >= 0x20000 || vertTotal + mesh->m_posCount >= 0x10000) { if (batchIndex > -1) { vertCounts[batchIndex] = vertTotal; idxCounts[batchIndex] = idxTotal; } batchIndex++; vertTotal = 0; idxTotal = 0; } vertTotal += mesh->m_posCount; idxTotal += mesh->m_idxCount; } if (idxTotal) { vertCounts[batchIndex] = vertTotal; idxCounts[batchIndex] = idxTotal; batchIndex++; } return batchIndex; } // VERIFY: 9b5bcef4 manual // OFFSET: 0x00484B00 void CSimpleRender::DrawBatch(CRenderBatch* batch) { uint32_t meshCount = batch->m_texturelist.Count(); if (meshCount) { CGxTex* textureID = reinterpret_cast(-1); int32_t alphaMode = GxBlends_Last; CGxShader* shader = nullptr; g_theGxDevicePtr->RsPush(); CGxShader* vertexShader = g_theGxDevicePtr->StereoEnabled() ? CSimpleRender::s_vertexShader[1] : CSimpleRender::s_vertexShader[0]; if (vertexShader && vertexShader->Valid()) { C44Matrix viewProj; GxRsSet(GxRs_VertexShader, vertexShader); GxXformViewProjNativeTranspose(viewProj); g_theGxDevicePtr->ShaderConstantsSet(GxSh_Vertex, 0, reinterpret_cast(&viewProj), 4); } else { GxRsSet(GxRs_Lighting, 0); } GxRsSet(GxRs_Fog, 0); GxRsSet(GxRs_DepthTest, 0); GxRsSet(GxRs_DepthWrite, 0); uint32_t* vertCounts = static_cast(alloca(sizeof(uint32_t) * meshCount)); uint32_t* idxCounts = static_cast(alloca(sizeof(uint32_t) * meshCount)); CSimpleRender::CalcBatchCounts(batch, vertCounts, idxCounts); CGxBuf* vertexBuf = nullptr; CGxBuf* indexBuf = nullptr; CGxVertexPCT* vertices = nullptr; uint16_t* indices = nullptr; uint32_t vertTotal = 0; int32_t idxTotal = 0; int32_t batchIndex = -1; for (uint32_t i = 0; i < meshCount; i++) { CSimpleBatchedMesh* mesh = &batch->m_texturelist[i]; int32_t changed = 0; if (mesh->m_textureID != textureID) { textureID = mesh->m_textureID; changed = 1; } int32_t meshAlphaMode = (mesh->m_color && mesh->m_alphaMode < GxBlend_Alpha) ? GxBlend_Alpha : mesh->m_alphaMode; if (meshAlphaMode != alphaMode) { alphaMode = meshAlphaMode; changed = 1; } if (mesh->m_shader != shader) { shader = mesh->m_shader; changed = 1; } bool newBatch = !CSimpleRender::s_mergeEnable || changed || idxTotal + mesh->m_idxCount >= 0x20000 || vertTotal + mesh->m_posCount >= 0x10000; if (newBatch) { if (idxTotal > 0) { GxBufUnlock(vertexBuf, 0); GxBufUnlock(indexBuf, 0); GxPrimVertexPtr(vertexBuf, GxVBF_PCT); g_theGxDevicePtr->PrimIndexPtr(indexBuf); CGxBatch gxBatch; gxBatch.m_primType = GxPrim_Triangles; gxBatch.m_start = 0; gxBatch.m_count = idxCounts[batchIndex]; gxBatch.m_minIndex = 0; gxBatch.m_maxIndex = vertCounts[batchIndex] - 1; GxDraw(&gxBatch, 1); } batchIndex++; idxTotal = 0; vertTotal = 0; GxRsSet(GxRs_Texture0, TextureGetGxTex(mesh->m_texture, 1, nullptr)); GxRsSet(GxRs_BlendingMode, alphaMode); GxUpdateAlphaRef(GxRs_AlphaRef); GxRsSet(GxRs_PixelShader, shader); } if (newBatch || !vertices) { vertexBuf = GxBufStream(GxPoolTarget_Vertex, sizeof(CGxVertexPCT), vertCounts[batchIndex]); indexBuf = GxBufStream(GxPoolTarget_Index, sizeof(uint16_t), idxCounts[batchIndex]); vertices = reinterpret_cast(GxBufLock(vertexBuf)); indices = reinterpret_cast(GxBufLock(indexBuf)); } if (!mesh->m_indices) { continue; } for (uint32_t v = 0; v < mesh->m_posCount; v++) { vertices->p = mesh->m_position[v]; if (mesh->m_color) { CImVector color = mesh->m_color[(v * mesh->m_colorCount) >> 2]; GxFormatColor(color); vertices->c = color; } else { CImVector white; white.b = 0xFF; white.g = 0xFF; white.r = 0xFF; white.a = 0xFF; vertices->c = white; } if (mesh->m_onAtlas) { vertices->tc.x = mesh->m_atlasScale * mesh->m_texCoord[v].x + mesh->m_atlasOffset.x; vertices->tc.y = mesh->m_atlasScale * mesh->m_texCoord[v].y + mesh->m_atlasOffset.y; } else { vertices->tc = mesh->m_texCoord[v]; } vertices++; } for (uint32_t j = 0; j < mesh->m_idxCount; j++) { *indices = vertTotal + mesh->m_indices[j]; indices++; } vertTotal += mesh->m_posCount; idxTotal += mesh->m_idxCount; } if (idxTotal > 0) { GxBufUnlock(vertexBuf, sizeof(CGxVertexPCT) * vertTotal); GxBufUnlock(indexBuf, sizeof(uint16_t) * idxTotal); GxPrimVertexPtr(vertexBuf, GxVBF_PCT); g_theGxDevicePtr->PrimIndexPtr(indexBuf); CGxBatch gxBatch; gxBatch.m_primType = GxPrim_Triangles; gxBatch.m_start = 0; gxBatch.m_count = idxCounts[batchIndex]; gxBatch.m_minIndex = 0; gxBatch.m_maxIndex = vertCounts[batchIndex] - 1; GxDraw(&gxBatch, 1); } g_theGxDevicePtr->RsPop(); } if (batch->m_stringbatch) { GxuFontRenderBatch(batch->m_stringbatch); } for (RENDERCALLBACKNODE* node = batch->m_callbacks.Head(); !TSList >::IsEnd(node); node = node->RawNext()) { node->m_callback(node->m_param); } } // VERIFY: e5b220d7 auto // OFFSET: 0x00482200 void CSimpleFontString::RemoveShadow() { if (this->m_styleFlags & 0x100) { this->m_styleFlags &= ~0x100u; if (this->m_string) { TextBlockRemoveShadow(this->m_string); } } } // VERIFY: e7bf854c auto // OFFSET: 0x00482290 float CSimpleFontString::GetFontHeight(bool recalculate) { float fontHeight = this->m_fontHeight; if (recalculate && this->m_fontHandle && (this->m_styleFlags & 0x200)) { float ndcHeight = GxuFontGetOneToOneHeight(TextBlockGetFontPtr(this->m_fontHandle)) / this->m_layoutScale; NDCToDDC(0.0f, ndcHeight, nullptr, &fontHeight); } return fontHeight; } // VERIFY: 323fc4f3 auto // OFFSET: 0x004834C0 void CSimpleTexture::StoreAnimPosition() { this->CSimpleRegion::StoreAnimPosition(); this->SetPosition(this->m_rect, this->m_storedPositions); memcpy(this->m_positions, this->m_storedPositions, sizeof(this->m_positions)); } // VERIFY: c6bab0dc auto // OFFSET: 0x004834F0 void CSimpleTexture::ResetAnimPosition() { this->CSimpleRegion::ResetAnimPosition(); this->SetPosition(this->m_rect, this->m_positions); } // VERIFY: 496d4923 auto // OFFSET: 0x00483A40 const char* CSimpleFontString::GetDisplayText(float width, float height) { const char* text = this->m_text && *this->m_text ? this->m_text : nullptr; if (!this->m_fontHandle || !text || !*text || width <= 0.0f) { return text; } if (!(this->m_maxLines & 0xFFFFFF) && height <= 0.0f) { return text; } float fontHeight = this->GetFontHeight(true); float lineHeight = (CSimpleTop::RoundToPixelHeight(this->m_spacing) + fontHeight) * this->m_layoutScale; if (this->m_maxLines & 0xFFFFFF) { height = lineHeight * (this->m_maxLines & 0xFFFFFF); } else if (lineHeight >= height) { height = lineHeight; } uint32_t numBytes = SStrLen(text); if (TextBlockGetMaxCharsWithinWidthAndHeight(this->m_fontHandle, text, this->m_layoutScale * fontHeight, width, height, numBytes, this->m_layoutScale * this->m_shadowOffset.x, this->m_layoutScale, this->m_layoutScale * this->m_spacing, this->m_styleFlags) >= numBytes) { return text; } if (numBytes >= sizeof(s_displayText) - 4) { numBytes = sizeof(s_displayText) - 4; } SStrCopy(s_displayText, text, sizeof(s_displayText)); uint32_t count; do { if (numBytes) { char ch; do { ch = s_displayText[numBytes - 1]; numBytes--; } while ((ch & 0xC0) == 0x80 && numBytes); } SStrCopy(&s_displayText[numBytes], "...", STORM_MAX_STR); count = TextBlockGetMaxCharsWithinWidthAndHeight(this->m_fontHandle, s_displayText, this->m_layoutScale * fontHeight, width, height, numBytes + 3, this->m_layoutScale * this->m_shadowOffset.x, this->m_layoutScale, this->m_layoutScale * this->m_spacing, this->m_styleFlags); } while (numBytes && count < numBytes + 3); return s_displayText; } // VERIFY: 586014e2 auto // OFFSET: 0x004840F0 bool CSimpleFontString::SetLayoutScale(float scale, bool force) { if (!this->CLayoutFrame::SetLayoutScale(scale, force)) { return false; } if (this->m_fontHandle) { char fontName[1024]; SStrCopy(fontName, this->GetFontName(), sizeof(fontName)); uint32_t fontFlags = this->GetFontFlags(); float fontHeight = this->m_fontHeight; HTEXTFONT font = nullptr; if (fontHeight == 0.0f || (font = TextBlockGenerateFont(fontName, fontFlags, fontHeight * this->m_layoutScale)) != nullptr) { this->m_fontHeight = fontHeight; if (this->m_string) { HandleClose(reinterpret_cast(this->m_string)); this->m_string = nullptr; } if (this->m_fontHandle) { HandleClose(reinterpret_cast(this->m_fontHandle)); } this->m_fontHandle = font; if (font) { this->m_textWidth = 0.0f; this->m_textHeight = 0.0f; if (this->m_string) { HandleClose(reinterpret_cast(this->m_string)); this->m_string = nullptr; } this->m_layoutFlags &= ~0x100u; this->Resize(0); } } } return true; } // VERIFY: 88bc13dc auto // OFFSET: 0x00485140 void CSimpleTexture::Draw(CRenderBatch* batch) { if (this->m_texture) { batch->QueueTexture(this); } } // VERIFY: 45a4d11b auto // OFFSET: 0x00485850 void CSimpleFontString::QueueTextures(CRenderBatch* batch) { for (CSimpleEmbeddedTexture* embedded = this->m_textures.Head(); !TSList >::IsEnd(embedded); embedded = this->m_textures.RawNext(embedded)) { if (embedded->m_texture && embedded->m_texture->m_texture) { batch->QueueTexture(embedded->m_texture); } } } // VERIFY: 502e17cc auto // OFFSET: 0x00485D60 void CSimpleFontString::Draw(CRenderBatch* batch) { if (this->m_fontHandle && this->m_text && *this->m_text) { batch->QueueFontString(this); this->QueueTextures(batch); } } // VERIFY: 70fe81b7 auto // OFFSET: 0x00485440 void CSimpleFontString::FreeEmbeddedTextures() { CSimpleEmbeddedTexture* embedded = this->m_textures.Head(); while (!TSList >::IsEnd(embedded)) { CSimpleEmbeddedTexture* next = this->m_textures.RawNext(embedded); this->m_textures.UnlinkNode(embedded); embedded->m_texture->m_shown = 0; embedded->m_texture->HideThis(); s_embeddedTextureStorage.LinkToTail(embedded); embedded = next; } } // VERIFY: 23bee593 manual // OFFSET: 0x004858B0 void CSimpleFontString::FreeEmbededTextureStorage() { CSimpleEmbeddedTexture* embedded = s_embeddedTextureStorage.Head(); while (!TSList >::IsEnd(embedded)) { embedded = s_embeddedTextureStorage.DeleteNode(embedded); } } // INLINED CSimpleEmbeddedTexture* CSimpleFontString::GetEmbeddedTextureFromStorage() { CSimpleEmbeddedTexture* embedded = s_embeddedTextureStorage.Head(); if (embedded) { s_embeddedTextureStorage.UnlinkNode(embedded); return embedded; } return new (SMemAlloc(sizeof(CSimpleEmbeddedTexture), __FILE__, __LINE__, 0)) CSimpleEmbeddedTexture; } // VERIFY: 947663f7 manual // OFFSET: 0x00485DA0 void CSimpleFontString::RefreshEmbeddedTextures() { const GXUEMBEDDEDTEXTUREINFO* info; uint32_t count = GxuFontStringEmbeddedTextureInfo(this->m_string ? TextBlockGetStringPtr(this->m_string) : nullptr, info); for (uint32_t i = 0; i < count; i++) { CSimpleEmbeddedTexture* embedded = CSimpleFontString::GetEmbeddedTextureFromStorage(); this->m_textures.LinkToTail(embedded); embedded->InitEmbeddedTexture(this, &info[i]); } } // INLINED void CSimpleFontString::operator delete(void* ptr) { if (ptr) { CSimpleFontString::s_allocator.PutData(ptr, nullptr, 0); } } // VERIFY: ce8bf3cc manual // OFFSET: 0x00485240 CSimpleFontString::CSimpleFontString(CSimpleFrame* frame, uint32_t drawLayer, bool show) : CSimpleRegion(frame, drawLayer, show) { this->m_spacing = 0.0f; this->m_textWidth = 0.0f; this->m_textHeight = 0.0f; this->m_fontHandle = nullptr; this->m_textMaxSize = 0; this->m_textCurSize = 0; this->m_text = nullptr; this->m_string = nullptr; this->m_shadowColor.a = 0xFF; this->m_alphaGradientStart = -1; this->m_styleFlags = 0x212; this->m_settableStyleFlags = 0x2107F; this->m_maxLines = (this->m_maxLines & 0xFE000000) | 0x1000000; s_fontStringCount++; } // VERIFY: fcafba60 auto // OFFSET: [0x00485370, 0x00485380, 0x00485600, 0x00485D30] CSimpleFontString::~CSimpleFontString() { this->FreeEmbeddedTextures(); if (this->m_text) { SMemFree(this->m_text, __FILE__, __LINE__, 0); this->m_text = nullptr; } this->SetFont(nullptr, 0.0f, 0, false); s_fontStringCount--; } // VERIFY: f646e84a manual // OFFSET: 0x004818F0 void CSimpleFontString::SetTextLength(uint32_t length) { if (length == this->m_textMaxSize) { return; } if (length) { char* text = static_cast(SMemAlloc(length + 1, __FILE__, __LINE__, 0)); *text = 0; if (this->m_text) { SMemFree(this->m_text, __FILE__, __LINE__, 0); } this->m_text = text; this->m_textCurSize = length; } this->m_textMaxSize = length; } // VERIFY: df02ba6a manual // OFFSET: 0x00482230 bool CSimpleFontString::SetAlphaGradient(int32_t start, int32_t length) { this->m_alphaGradientStart = start; this->m_alphaGradientLength = length; return !this->m_string || TextBlockSetGradient(this->m_string, start, length) < 2; } // VERIFY: 8dc263f9 auto // OFFSET: 0x00482320 void CSimpleFontString::SetWidth(float width) { this->CLayoutFrame::SetWidth(width); this->m_textWidth = 0.0f; this->m_textHeight = 0.0f; } // VERIFY: 0b7750c4 auto // OFFSET: 0x00482350 void CSimpleFontString::SetHeight(float height) { this->CLayoutFrame::SetHeight(height); this->m_textWidth = 0.0f; this->m_textHeight = 0.0f; } // VERIFY: fd665b85 auto // OFFSET: 0x00482380 float CSimpleFontString::GetTextWidth(const char* text, uint32_t numBytes) { float extent = 0.0f; if (!this->m_fontHandle) { return extent; } if (!numBytes) { numBytes = SStrLen(text); } TextBlockGetTextExtent(this->m_fontHandle, text, numBytes, this->m_layoutScale * this->GetFontHeight(true), &extent, this->m_shadowOffset.x * this->m_layoutScale, this->m_layoutScale, 0.0f, this->m_styleFlags); return extent / this->m_layoutScale; } // VERIFY: 7b82c1df manual // OFFSET: 0x00482450 uint32_t CSimpleFontString::WrapText(const char* text, float width, uint32_t* lineStarts, uint32_t maxLines) { if (!this->m_fontHandle) { return 0; } return TextBlockWrapText(this->m_fontHandle, text, this->GetFontHeight(true) * this->m_layoutScale, width * this->m_layoutScale, lineStarts, maxLines, this->m_shadowOffset.x * this->m_layoutScale, this->m_layoutScale, 0.0f, this->m_styleFlags); } // VERIFY: 92162b43 manual // OFFSET: 0x00482510 uint32_t CSimpleFontString::GetNumCharsWithinWidth(const char* text, uint32_t numBytes, float maxWidth) { if (!this->m_fontHandle) { return 0; } if (!numBytes) { numBytes = SStrLen(text); } float extent; return TextBlockGetMaxCharsWithinWidth(this->m_fontHandle, text, this->m_layoutScale * this->GetFontHeight(true), this->m_layoutScale * maxWidth, numBytes, &extent, this->m_shadowOffset.x * this->m_layoutScale, this->m_layoutScale, 0.0f, this->m_styleFlags); } // VERIFY: 211ff357 manual // OFFSET: 0x004825E0 uint32_t CSimpleFontString::GetNumCharsWithinWidthFromEnd(const char* text, uint32_t numBytes, float maxWidth) { if (!this->m_fontHandle) { return 0; } if (!numBytes) { numBytes = SStrLen(text); } float extent; return TextBlockGetMaxCharsWithinWidthFromEnd(this->m_fontHandle, text, this->m_layoutScale * this->GetFontHeight(true), this->m_layoutScale * maxWidth, numBytes, &extent, this->m_shadowOffset.x * this->m_layoutScale, this->m_layoutScale, 0.0f, this->m_styleFlags); } // VERIFY: 5d78882a auto // OFFSET: 0x004826B0 void CSimpleFontString::OnScreenSizeChanged() { this->m_textWidth = 0.0f; this->m_textHeight = 0.0f; this->Resize(0); } // VERIFY: 5cc3b167 auto // OFFSET: 0x00482720 void CSimpleFontString::AddAnimTranslation(const C2Vector& translation) { if (this->m_string) { C3Vector position = TextBlockGetStringPos(this->m_string); ApplyTranslationAnim(position, translation); TextBlockSetStringPos(this->m_string, position); } } // VERIFY: ebf55995 auto // OFFSET: 0x00482E10 void CSimpleFontString::ClearString() { this->m_textWidth = 0.0f; this->m_textHeight = 0.0f; if (this->m_string) { HandleClose(reinterpret_cast(this->m_string)); this->m_string = nullptr; } this->m_layoutFlags &= ~0x100u; this->Resize(0); } // VERIFY: 45b31c86 manual // OFFSET: 0x004836D0 void CSimpleFontString::PostLoadXML(XMLNode* node, CStatus* status) { if (!this->m_parent || this->HasAnyFramepoints()) { return; } if (this->m_styleFlags & 0x1) { this->SetPoint(FRAMEPOINT_LEFT, this->m_parent, FRAMEPOINT_LEFT, 0.0f, 0.0f, 1); } else if (this->m_styleFlags & 0x4) { this->SetPoint(FRAMEPOINT_RIGHT, this->m_parent, FRAMEPOINT_RIGHT, 0.0f, 0.0f, 1); } else { this->SetPoint(FRAMEPOINT_CENTER, this->m_parent, FRAMEPOINT_CENTER, 0.0f, 0.0f, 1); } } // VERIFY: 96073ff2 auto // OFFSET: 0x00483750 int32_t CSimpleFontString::SetFont(const char* fontName, float fontHeight, uint32_t fontFlags, bool force) { if (!force) { const char* currentName = this->GetFontName(); if (fontName && currentName && !SStrCmpI(fontName, currentName, STORM_MAX_STR) && fequal(fontHeight, this->m_fontHeight) && fontFlags == this->GetFontFlags()) { return 1; } } HTEXTFONT font = nullptr; if (fontName && fontHeight != 0.0f) { font = TextBlockGenerateFont(fontName, fontFlags, fontHeight * this->m_layoutScale); if (!font) { return 0; } } this->m_fontHeight = fontHeight; if (this->m_string) { HandleClose(reinterpret_cast(this->m_string)); this->m_string = nullptr; } if (this->m_fontHandle) { HandleClose(reinterpret_cast(this->m_fontHandle)); } this->m_fontHandle = font; if (font) { this->ClearString(); } return 1; } // VERIFY: 3d8d8078 auto // OFFSET: 0x00483890 void CSimpleFontString::SetTextHeight(float height) { if (fabsf(height - this->m_fontHeight) >= 0.00000023841858f) { this->m_fontHeight = height; this->m_styleFlags &= ~0x200u; this->ClearString(); } } // VERIFY: 5aa8ddc3 manual // OFFSET: 0x00483910 void CSimpleFontString::SetText(const char* text, int32_t process) { if (text && process) { text = LanguageProcess(text); } if ((!text || !*text) && (!this->m_text || !*this->m_text)) { return; } if (text) { if (this->m_text && !SStrCmp(text, this->m_text, STORM_MAX_STR)) { return; } if (*text) { if (this->m_textMaxSize) { SStrCopy(this->m_text, text, this->m_textMaxSize); } else { uint32_t length = SStrLen(text); if (length > this->m_textCurSize) { if (this->m_text) { SMemFree(this->m_text, __FILE__, __LINE__, 0); } this->m_text = SStrDupA(text, __FILE__, __LINE__); this->m_textCurSize = length; } else { SStrCopy(this->m_text, text, STORM_MAX_STR); } } this->ClearString(); return; } } if (this->m_text) { *this->m_text = 0; } this->ClearString(); } // VERIFY: 63874679 auto // OFFSET: 0x00483C40 void CSimpleFontString::SetJustificationOffset(float x, float y) { if (x == this->m_justificationOffset.x && this->m_justificationOffset.y == y) { return; } this->m_justificationOffset.x = x; this->m_justificationOffset.y = y; if (this->m_string) { C3Vector position; position.x = this->m_layoutScale * this->m_justificationOffset.x + this->m_rect.minX; position.y = this->m_justificationOffset.y * this->m_layoutScale + this->m_rect.minY; position.z = this->m_layoutDepth; TextBlockSetStringPos(this->m_string, position); } } // VERIFY: 273d1f7a manual // OFFSET: 0x00483CD0 void CSimpleFontString::AddShadow(const CImVector& color, const C2Vector& offset) { if ((this->m_styleFlags & 0x100) && *reinterpret_cast(&color) == *reinterpret_cast(&this->m_shadowColor) && this->m_shadowOffset.x == offset.x && this->m_shadowOffset.y == offset.y) { return; } this->m_styleFlags |= 0x100; this->m_shadowColor = color; this->m_shadowOffset = offset; if (this->m_string) { CImVector shadowColor = this->m_shadowColor; C2Vector shadowOffset; shadowOffset.x = this->m_shadowOffset.x * this->m_layoutScale; shadowOffset.y = this->m_shadowOffset.y * this->m_layoutScale; uint8_t alpha = this->m_parent->m_alpha * this->m_parent->m_parentAlpha / 255; shadowColor.a = this->m_shadowColor.a * alpha / 255; TextBlockAddShadow(this->m_string, shadowColor, shadowOffset); } } // VERIFY: e9c58d61 manual // OFFSET: 0x00483DD0 void CSimpleFontString::SetShadowOffset(const C2Vector& offset) { if (this->m_shadowOffset.x == offset.x && this->m_shadowOffset.y == offset.y) { return; } this->m_shadowOffset = offset; if (this->m_shadowOffset.x == 0.0f && this->m_shadowOffset.y == 0.0f) { this->RemoveShadow(); } else { this->AddShadow(this->m_shadowColor, this->m_shadowOffset); } this->ClearString(); } // VERIFY: 230de876 auto // OFFSET: 0x00483E80 float CSimpleFontString::GetStringWidth() { if (this->m_textWidth == 0.0f && this->m_fontHandle) { const char* text = this->GetDisplayText(this->CLayoutFrame::GetWidth() * this->m_layoutScale, this->CLayoutFrame::GetHeight() * this->m_layoutScale); if (text && *text) { TextBlockGetTextExtent(this->m_fontHandle, text, SStrLen(text), this->GetFontHeight(true) * this->m_layoutScale, &this->m_textWidth, this->m_shadowOffset.x * this->m_layoutScale, this->m_layoutScale, 0.0f, this->m_styleFlags); } } return this->m_textWidth / this->m_layoutScale; } // VERIFY: 9a3e23aa auto // OFFSET: 0x00483F30 float CSimpleFontString::GetWidth() { float width = this->CLayoutFrame::GetWidth(); if (width == 0.0f) { width = this->GetStringWidth(); } return width > NDCToDDCWidth(1.0f / (CoordinateGetAspectCompensation() * 1024.0f)) ? width : NDCToDDCWidth(1.0f / (CoordinateGetAspectCompensation() * 1024.0f)); } // VERIFY: 5c920bfb auto // OFFSET: 0x00483FA0 float CSimpleFontString::GetStringHeight() { if (this->m_textHeight == 0.0f && this->m_fontHandle) { const char* text = this->GetDisplayText(this->CLayoutFrame::GetWidth() * this->m_layoutScale, this->CLayoutFrame::GetHeight() * this->m_layoutScale); if (text && *text) { C2Vector shadowOffset; shadowOffset.x = this->m_shadowOffset.x * this->m_layoutScale; shadowOffset.y = this->m_layoutScale * this->m_shadowOffset.y; this->m_textHeight = TextBlockGetWrappedTextHeight(this->m_fontHandle, text, this->GetFontHeight(true) * this->m_layoutScale, this->GetWidth() * this->m_layoutScale, shadowOffset, this->m_layoutScale, this->m_spacing * this->m_layoutScale, this->m_styleFlags); } } return this->m_textHeight / this->m_layoutScale; } // VERIFY: 34e78a2e auto // OFFSET: 0x00484080 float CSimpleFontString::GetHeight() { float height = this->CLayoutFrame::GetHeight(); if (height == 0.0f) { height = this->GetStringHeight(); } return height > NDCToDDCWidth(1.0f / (CoordinateGetAspectCompensation() * 1024.0f)) ? height : NDCToDDCWidth(1.0f / (CoordinateGetAspectCompensation() * 1024.0f)); } // VERIFY: 4a6b69f4 auto // OFFSET: 0x00484230 bool CSimpleFontString::SetLayoutDepth(float depth, bool force) { if (!this->CLayoutFrame::SetLayoutDepth(depth, force)) { return false; } if (this->m_string) { C3Vector position; position.x = this->m_justificationOffset.x * this->m_layoutScale + this->m_rect.minX; position.y = this->m_justificationOffset.y * this->m_layoutScale + this->m_rect.minY; position.z = this->m_layoutDepth; TextBlockSetStringPos(this->m_string, position); } return true; } // VERIFY: 026ce15c manual // OFFSET: 0x004842A0 void CSimpleFontString::PreOnAnimUpdate() { if (!this->m_animating) { return; } if (this->m_string) { TextBlockSetStringPos(this->m_string, this->m_animPosition); } if (this->m_animAlpha) { uint8_t alpha = this->m_animSavedAlpha; CImVector color; this->GetVertexColor(color); color.a = alpha; this->SetVertexColor(color); } } // VERIFY: db02a088 manual // OFFSET: 0x00484300 void CSimpleFontString::StoreAnimPosition() { this->CSimpleRegion::StoreAnimPosition(); this->m_animPosition.x = this->m_justificationOffset.x * this->m_layoutScale + this->m_rect.minX; this->m_animPosition.y = this->m_justificationOffset.y * this->m_layoutScale + this->m_rect.minY; this->m_animPosition.z = this->m_layoutDepth; if (this->m_string) { TextBlockSetStringPos(this->m_string, this->m_animPosition); } } // VERIFY: c02c2d45 manual // OFFSET: 0x00484350 void CSimpleFontString::ResetAnimPosition() { this->CSimpleRegion::ResetAnimPosition(); this->m_animPosition.x = this->m_justificationOffset.x * this->m_layoutScale + this->m_rect.minX; this->m_animPosition.y = this->m_justificationOffset.y * this->m_layoutScale + this->m_rect.minY; this->m_animPosition.z = this->m_layoutDepth; if (this->m_string) { TextBlockSetStringPos(this->m_string, this->m_animPosition); } } // VERIFY: 50c246ae manual // OFFSET: 0x004856F0 void CSimpleFontString::OnColorChanged(bool changed) { this->CSimpleRegion::OnColorChanged(changed); if (this->m_string) { CImVector color; color.b = 0xFF; color.g = 0xFF; color.r = 0xFF; color.a = 0xFF; if (this->m_colorCount == 1) { color = this->m_colors[0]; } TextBlockUpdateColor(this->m_string, color); if (this->m_styleFlags & 0x100) { CImVector shadowColor = this->m_shadowColor; C2Vector shadowOffset; shadowOffset.x = this->m_shadowOffset.x * this->m_layoutScale; shadowOffset.y = this->m_shadowOffset.y * this->m_layoutScale; uint8_t alpha = this->m_parent->m_alpha * this->m_parent->m_parentAlpha / 255; shadowColor.a = this->m_shadowColor.a * alpha / 255; TextBlockAddShadow(this->m_string, shadowColor, shadowOffset); } } for (CSimpleEmbeddedTexture* embedded = this->m_textures.Head(); !TSList >::IsEnd(embedded); embedded = this->m_textures.RawNext(embedded)) { if (embedded->m_texture && embedded->m_texture->m_texture) { CImVector color; this->GetVertexColor(color); CSimpleTexture* texture = embedded->m_texture; uint8_t alpha = color.a; CImVector textureColor; texture->GetVertexColor(textureColor); textureColor.a = alpha; texture->SetVertexColor(textureColor); } } } // VERIFY: 1148256f manual // OFFSET: 0x00486B20 void CSimpleFontString::UpdateString() { if (!(this->m_layoutFlags & 0x100)) { return; } if (this->m_string) { HandleClose(reinterpret_cast(this->m_string)); this->m_string = nullptr; } this->FreeEmbeddedTextures(); if (!(this->m_rect.maxY > this->m_rect.minY) || !(this->m_rect.maxX > this->m_rect.minX)) { return; } if (this->m_fontHandle && this->m_text && *this->m_text) { C3Vector position; position.x = this->m_justificationOffset.x * this->m_layoutScale + this->m_rect.minX; position.y = this->m_justificationOffset.y * this->m_layoutScale + this->m_rect.minY; position.z = this->m_layoutDepth; float width = this->CLayoutFrame::GetWidth(); width = width != 0.0f ? width * this->m_layoutScale : this->m_textWidth; if (fnotequalz(width, this->m_rect.maxX - this->m_rect.minX, 0.00001f)) { width = this->m_rect.maxX - this->m_rect.minX; } float height = this->CLayoutFrame::GetHeight(); height = height != 0.0f ? height * this->m_layoutScale : this->m_textHeight; if (fnotequalz(height, this->m_rect.maxY - this->m_rect.minY, 0.00001f)) { height = this->m_rect.maxY - this->m_rect.minY; } const char* text = this->GetDisplayText(width, height); uint32_t styleFlags = this->m_styleFlags; CImVector color; color.b = 0xFF; color.g = 0xFF; color.r = 0xFF; color.a = 0xFF; if (!(styleFlags & 0x400)) { bool hasColorCode = false; for (int32_t i = 0; text[i]; i++) { if (text[i] == '|') { if (text[i + 1] == '|') { i++; } else if (text[i + 1] == 'C' || text[i + 1] == 'c') { hasColorCode = true; break; } } } if (!hasColorCode) { styleFlags |= 0x400; } } if (this->m_colorCount) { color = this->m_colors[0]; } this->m_string = TextBlockCreate(this->m_fontHandle, text, color, position, this->GetFontHeight(true) * this->m_layoutScale, width, height, styleFlags, 0.0f, this->m_spacing * this->m_layoutScale, this->m_layoutScale); if (this->m_styleFlags & 0x100) { CImVector shadowColor = this->m_shadowColor; uint8_t alpha = this->m_parent->GetEffectiveAlpha(); C2Vector shadowOffset; shadowOffset.x = this->m_shadowOffset.x * this->m_layoutScale; shadowOffset.y = this->m_shadowOffset.y * this->m_layoutScale; shadowColor.a = this->m_shadowColor.a * alpha / 255; TextBlockAddShadow(this->m_string, shadowColor, shadowOffset); } if (this->m_alphaGradientStart >= 0) { TextBlockSetGradient(this->m_string, this->m_alphaGradientStart, this->m_alphaGradientLength); } this->RefreshEmbeddedTextures(); if (this->m_animating) { this->m_animPosition = position; TextBlockSetStringPos(this->m_string, position); } } this->OnRegionChanged(); } // VERIFY: 39fc54f9 manual // OFFSET: 0x00486E30 void CSimpleFontString::OnFrameSizeChanged(const CRect& rect) { this->CLayoutFrame::OnFrameSizeChanged(rect); if (this->m_string && fabsf((rect.maxX - rect.minX) - (this->m_rect.maxX - this->m_rect.minX)) < 0.00001f && fabsf((rect.maxY - rect.minY) - (this->m_rect.maxY - this->m_rect.minY)) < 0.00001f) { C3Vector position; position.x = this->m_justificationOffset.x * this->m_layoutScale + this->m_rect.minX; position.y = this->m_justificationOffset.y * this->m_layoutScale + this->m_rect.minY; position.z = this->m_layoutDepth; TextBlockSetStringPos(this->m_string, position); if (IsRectOffscreen(this->m_rect) != IsRectOffscreen(rect)) { this->OnRegionChanged(); } } else { this->UpdateString(); } if (this->m_animating) { C3Vector previous = this->m_animPosition; this->m_animPosition.x = this->m_justificationOffset.x * this->m_layoutScale + this->m_rect.minX; this->m_animPosition.y = this->m_justificationOffset.y * this->m_layoutScale + this->m_rect.minY; this->m_animPosition.z = this->m_layoutDepth; if (this->m_string) { C3Vector delta = this->m_animPosition - previous; C3Vector position = TextBlockGetStringPos(this->m_string) + delta; TextBlockSetStringPos(this->m_string, position); } } if (this->m_parent) { this->m_parent->NotifyScrollParent(); } } // VERIFY: 86a4fd93 auto // OFFSET: 0x00487090 void CSimpleFontString::SetStyleFlags(uint32_t styleFlags) { uint32_t flags = (styleFlags & this->m_settableStyleFlags) | (this->m_styleFlags & ~this->m_settableStyleFlags); if (flags != this->m_styleFlags) { this->m_styleFlags = flags; if (this->m_string) { this->UpdateString(); } } } // VERIFY: ee7180a8 auto // OFFSET: 0x004870D0 void CSimpleFontString::SetSpacing(float spacing) { if (spacing < 0.0f) { spacing = 0.0f; } if (fabsf(spacing - this->m_spacing) >= 0.00000023841858f) { this->m_spacing = spacing; this->m_textHeight = 0.0f; if (this->m_string) { this->UpdateString(); } } } // VERIFY: adb869c7 auto // OFFSET: 0x00487130 void CSimpleFontString::SetShadowColor(const CImVector& color) { if (*reinterpret_cast(&color) != *reinterpret_cast(&this->m_shadowColor)) { this->m_shadowColor = color; if (this->m_string) { this->UpdateString(); } } } // VERIFY: 283d01b1 auto // OFFSET: 0x00487190 void CSimpleFontString::SetJustifyH(uint8_t justify) { this->m_settableStyleFlags &= ~0x7u; uint32_t styleFlags = (this->m_styleFlags & ~0x7u) | (justify & 0x7); if (styleFlags != this->m_styleFlags) { this->m_styleFlags = styleFlags; if (this->m_string) { this->UpdateString(); } } } // VERIFY: d976f70d auto // OFFSET: 0x004871D0 void CSimpleFontString::SetJustifyV(uint8_t justify) { this->m_settableStyleFlags &= ~0x38u; uint32_t styleFlags = (this->m_styleFlags & ~0x38u) | (justify & 0x38); if (styleFlags != this->m_styleFlags) { this->m_styleFlags = styleFlags; if (this->m_string) { this->UpdateString(); } } } // VERIFY: e9a340b1 auto // OFFSET: 0x00487210 void CSimpleFontString::SetNonWordWrap(int32_t noWrap) { this->m_settableStyleFlags &= ~0x40u; uint32_t styleFlags = noWrap ? this->m_styleFlags | 0x40 : this->m_styleFlags & ~0x40u; if (styleFlags != this->m_styleFlags) { this->m_styleFlags = styleFlags; if (this->m_string) { this->UpdateString(); } } } // VERIFY: eb8e3134 auto // OFFSET: 0x00487250 void CSimpleFontString::SetNonSpaceWrap(int32_t wrap) { this->m_settableStyleFlags &= ~0x1000u; uint32_t styleFlags = wrap ? this->m_styleFlags | 0x1000 : this->m_styleFlags & ~0x1000u; if (styleFlags != this->m_styleFlags) { this->m_styleFlags = styleFlags; if (this->m_string) { this->UpdateString(); } } } // VERIFY: 8f4f99c8 auto // OFFSET: 0x004872A0 void CSimpleFontString::SetIndented(int32_t indented) { this->m_settableStyleFlags &= ~0x20000u; uint32_t styleFlags = indented ? this->m_styleFlags | 0x20000 : this->m_styleFlags & ~0x20000u; if (styleFlags != this->m_styleFlags) { this->m_styleFlags = styleFlags; if (this->m_string) { this->UpdateString(); } } } // VERIFY: 83e312ff manual // OFFSET: 0x004873E0 void CSimpleFontString::LoadXML(XMLNode* node, CStatus* status) { const char* inherits = node->GetAttributeByName("inherits"); if (inherits && *inherits) { CSimpleFont* font = CSimpleFont::GetFont(inherits, 0); if (font) { if (this->m_maxLines & 0x1000000) { this->SetFontObject(font); } } else { const char* taint; bool locked; XMLNode* inheritNode = FrameXML_AcquireHashNode(inherits, taint, locked); if (!inheritNode) { status->Add(STATUS_WARNING, "Couldn't find inherited node: %s", inherits); } else if (locked) { status->Add(STATUS_WARNING, "Recursively inherited node: %s", inherits); } else { this->LoadXML(inheritNode, status); FrameXML_ReleaseHashNode(inherits); } } } this->CScriptRegion::LoadXML(node, status); const char* hidden = node->GetAttributeByName("hidden"); if (hidden && *hidden) { if (StringToBOOL(hidden)) { this->m_shown = 0; this->HideThis(); } else { this->m_shown = 1; this->ShowThis(); } } const char* textAttr = node->GetAttributeByName("text"); if (textAttr && *textAttr) { const char* text = FrameScript_GetText(textAttr, -1, GENDER_NOT_APPLICABLE); if (!text || !*text) { text = textAttr; } this->SetText(text, 1); } const char* nonSpaceWrap = node->GetAttributeByName("nonspacewrap"); if (nonSpaceWrap && *nonSpaceWrap) { this->SetNonSpaceWrap(StringToBOOL(nonSpaceWrap)); } const char* wordWrap = node->GetAttributeByName("wordwrap"); if (wordWrap && *wordWrap) { this->SetNonWordWrap(StringToBOOL(wordWrap) == 0); } const char* bytes = node->GetAttributeByName("bytes"); if (bytes && *bytes) { this->SetTextLength(SStrToInt(bytes)); } const char* maxLines = node->GetAttributeByName("maxLines"); if (maxLines && *maxLines) { this->m_maxLines = (this->m_maxLines & ~0xFFFFFFu) | (SStrToUnsigned(maxLines) & 0xFFFFFF); } if (!(this->m_maxLines & 0x1000000)) { return; } const char* fontName = node->GetAttributeByName("font"); if (fontName && *fontName) { CSimpleFont* font = CSimpleFont::GetFont(fontName, 0); if (font) { this->SetFontObject(font); } else { float fontHeight = 0.0f; XMLNode* heightNode = node->GetChildByName("FontHeight"); if (heightNode) { LoadXML_Value(heightNode, fontHeight, status); } if (fontHeight <= 0.00000011920929f) { status->Add(STATUS_WARNING, "FontString %s: invalid font height %f in %s element", this->GetDisplayName(), fontHeight, node->m_name.m_str); return; } uint32_t fontFlags = 0; const char* outline = node->GetAttributeByName("outline"); if (outline && *outline) { if (!SStrCmpI(outline, "NORMAL", STORM_MAX_STR)) { fontFlags = 1; } else if (!SStrCmpI(outline, "THICK", STORM_MAX_STR)) { fontFlags = 5; } } const char* monochrome = node->GetAttributeByName("monochrome"); if (monochrome && *monochrome && StringToBOOL(monochrome)) { fontFlags |= 2; } if (this->SetFont(fontName, fontHeight, fontFlags, false)) { this->m_fontableFlags &= ~0x1u; } else { status->Add(STATUS_WARNING, "FontString %s: Unable to load font file %s", this->GetDisplayName(), fontName); } } } const char* spacing = node->GetAttributeByName("spacing"); if (spacing && *spacing) { float value = SStrToFloat(spacing); this->SetSpacing(NDCToDDCWidth(value / (CoordinateGetAspectCompensation() * 1024.0f))); this->m_fontableFlags &= ~0x10u; } uint32_t justify; const char* justifyV = node->GetAttributeByName("justifyV"); if (justifyV && *justifyV && StringToJustify(justifyV, justify)) { this->SetJustifyV(justify); this->m_fontableFlags &= ~0x2u; } const char* justifyH = node->GetAttributeByName("justifyH"); if (justifyH && *justifyH && StringToJustify(justifyH, justify)) { this->SetJustifyH(justify); this->m_fontableFlags &= ~0x2u; } const char* indented = node->GetAttributeByName("indented"); if (indented && *indented) { this->SetIndented(StringToBOOL(indented)); } const char* alphaAttr = node->GetAttributeByName("alpha"); if (alphaAttr && *alphaAttr) { float alpha = SStrToFloat(alphaAttr); if (alpha < 0.0f) { alpha = 0.0f; } else if (alpha >= 1.0f) { alpha = 1.0f; } this->SetVertexAlpha(static_cast(alpha * 255.0f)); } for (XMLNode* child = node->m_child; child; child = child->m_next) { if (!SStrCmpI(child->m_name.m_str, "Color", STORM_MAX_STR)) { CImVector color; LoadXML_Color(child, color, status); this->SetVertexColor(color); this->m_fontableFlags &= ~0x4u; } else if (!SStrCmpI(child->m_name.m_str, "Shadow", STORM_MAX_STR)) { float offsetX = 0.001f; float offsetY = -0.001f; CImVector color; color.a = 0xFF; XMLNode* colorNode = child->GetChildByName("Color"); if (colorNode) { LoadXML_Color(colorNode, color, status); } XMLNode* offsetNode = child->GetChildByName("Offset"); if (offsetNode) { LoadXML_Dimensions(offsetNode, offsetX, offsetY, status); } C2Vector offset; offset.x = offsetX; offset.y = offsetY; this->AddShadow(color, offset); this->m_fontableFlags &= ~0x8u; } } } // VERIFY: 744f3b3c auto // OFFSET: 0x00487990 void CSimpleFontString::FontObjectUpdated(CSimpleFontStringAttributes& attributes) { attributes.Update(this, this->m_fontableFlags); } // INLINED int32_t CSimpleTexture::GetObjectType() { if (!CSimpleTexture::s_objectType) { CSimpleTexture::s_objectType = ++FrameScript_Object::s_objectTypes; } return CSimpleTexture::s_objectType; } // INLINED void CSimpleTexture::operator delete(void* ptr) { if (ptr) { CSimpleTexture::s_allocator.PutData(ptr, nullptr, 0); } } // VERIFY: 0a77af56 auto // OFFSET: 0x00481520 int32_t CSimpleTexture::SetTexture(CTexture* texture) { if (!this->m_texture || !texture || HandleCompare(reinterpret_cast(this->m_texture), reinterpret_cast(texture))) { CTexture* newTexture = nullptr; if (texture) { newTexture = reinterpret_cast(HandleDuplicate(reinterpret_cast(texture))); } if (this->m_texture) { HandleClose(reinterpret_cast(this->m_texture)); } this->m_texture = newTexture; this->OnRegionChanged(); } return 1; } // VERIFY: 66dd3b98 auto // OFFSET: 0x00481590 int32_t CSimpleTexture::SetTexture(const CImVector& color) { CTexture* texture = TextureCreateSolid(color); if (this->m_texture) { HandleClose(reinterpret_cast(this->m_texture)); } this->m_texture = texture; this->OnRegionChanged(); return 1; } // VERIFY: a001c950 auto // OFFSET: 0x004815E0 int32_t CSimpleTexture::GetTexture(char* buffer, uint32_t bufferLen) { if (!this->m_texture) { return 0; } const char* filename = TextureGetFilename(this->m_texture); if (!filename || !*filename) { return 0; } SStrCopy(buffer, filename, bufferLen); return 1; } // VERIFY: 289faf79 auto // OFFSET: 0x00481620 void CSimpleTexture::SetBlendMode(EGxBlend blend) { if (blend != this->m_alphaMode) { this->m_alphaMode = blend; this->OnRegionChanged(); } } // VERIFY: ced9d67c auto // OFFSET: 0x00481640 void CSimpleTexture::SetTexCoord(const C2Vector* texCoords) { this->m_texCoords[0] = texCoords[0]; this->m_texCoords[1] = texCoords[1]; this->m_texCoords[2] = texCoords[2]; this->m_texCoords[3] = texCoords[3]; } // VERIFY: d3659815 auto // OFFSET: 0x004816A0 void CSimpleTexture::GetTexCoord(C2Vector* texCoords) { texCoords[0] = this->m_texCoords[0]; texCoords[1] = this->m_texCoords[1]; texCoords[2] = this->m_texCoords[2]; texCoords[3] = this->m_texCoords[3]; } // VERIFY: 7b313c73 auto // OFFSET: 0x00481700 void CSimpleTexture::SetShader(CGxShader* shader) { if (shader != this->m_shader) { this->m_shader = shader; this->OnRegionChanged(); } } // VERIFY: 1db02c26 auto // OFFSET: 0x00481720 CGxTex* CSimpleTexture::GetGxTex() { return this->m_texture ? TextureGetGxTex(this->m_texture, 1, nullptr) : nullptr; } // VERIFY: 09cfc6ac auto // OFFSET: 0x00481740 void CSimpleTexture::AddAnimTranslation(const C2Vector& translation) { ApplyTranslationAnim(this->m_positions, translation); this->OnRegionChanged(); } // VERIFY: 0283fe37 auto // OFFSET: 0x00481770 void CSimpleTexture::AddAnimRotation(FRAMEPOINT origin, const C2Vector& offset, float radians) { ApplyRotationAnim(this->m_positions, origin, offset, radians); this->OnRegionChanged(); } // VERIFY: 2b060cdb auto // OFFSET: 0x004817A0 void CSimpleTexture::AddAnimScale(FRAMEPOINT origin, const C2Vector& offset, const C2Vector& scale) { ApplyScaleAnim(this->m_positions, origin, offset, scale); this->OnRegionChanged(); } // VERIFY: efe353c3 auto // OFFSET: 0x004817D0 float CSimpleTexture::GetWidth() { float width = this->CLayoutFrame::GetWidth(); if (width == 0.0f && this->m_texture) { uint32_t textureWidth; if (TextureGetDimensions(this->m_texture, &textureWidth, nullptr, 0)) { return NDCToDDCWidth(static_cast(textureWidth) / (CoordinateGetAspectCompensation() * 1024.0f)); } } return width; } // VERIFY: 9aa1bf92 auto // OFFSET: 0x00481850 float CSimpleTexture::GetHeight() { float height = this->CLayoutFrame::GetHeight(); if (height == 0.0f && this->m_texture) { uint32_t textureHeight; if (TextureGetDimensions(this->m_texture, nullptr, &textureHeight, 0)) { return NDCToDDCWidth(static_cast(textureHeight) / (CoordinateGetAspectCompensation() * 1024.0f)); } } return height; } // VERIFY: d5f393df auto // OFFSET: 0x004818D0 int32_t CSimpleTexture::IsObjectLoaded() { if (this->m_texture && !TextureIsLoaded(this->m_texture)) { return 0; } return 1; } // VERIFY: bced6855 auto // OFFSET: 0x00482C60 bool CSimpleTexture::IsA(int32_t type) { return type == CSimpleTexture::s_objectType || type == CScriptRegion::s_objectType || type == CScriptObject::s_objectType; } // VERIFY: 3165fe90 auto // OFFSET: 0x00482C90 bool CSimpleTexture::IsA(const char* typeName) { return !SStrCmpI(typeName, CSimpleTexture::s_objectTypeName, STORM_MAX_STR) || !SStrCmpI(typeName, CScriptRegion::s_objectTypeName, STORM_MAX_STR) || !SStrCmpI(typeName, CScriptObject::s_objectTypeName, STORM_MAX_STR); } // VERIFY: 465f6c7c auto // OFFSET: 0x00482CF0 const char* CSimpleTexture::GetObjectTypeName() { return CSimpleTexture::s_objectTypeName; } // VERIFY: 80d103be auto // OFFSET: 0x00482D00 int32_t CSimpleTexture::GetScriptMetaTable() { return CSimpleTexture::s_metatable; } // VERIFY: ec4a9c07 auto // OFFSET: [0x00482860, 0x00483010] CSimpleTexture::~CSimpleTexture() { if (this->m_texture) { HandleClose(reinterpret_cast(this->m_texture)); } CSimpleTexture::s_count--; } // VERIFY: d7f68080 auto // OFFSET: 0x00483060 void CSimpleTexture::Init() { for (uint32_t i = 0; i < 2; i++) { if (CSimpleTexture::s_imageModePixelShaderNames[i]) { g_theGxDevicePtr->ShaderCreate(&CSimpleTexture::s_imageModePixelShaders[i], GxSh_Pixel, "Shaders\\Pixel", CSimpleTexture::s_imageModePixelShaderNames[i], 1); } } } // VERIFY: 61684332 manual // OFFSET: 0x004830A0 void CSimpleTexture::Destroy() { for (int32_t i = 0; i < 2; i++) { if (CSimpleTexture::s_imageModePixelShaders[i]) { g_theGxDevicePtr->ShaderDestroy(CSimpleTexture::s_imageModePixelShaders[i]); } } } // VERIFY: 3a72f2dc manual // OFFSET: 0x004830E0 void CSimpleTexture::PostLoadXML(XMLNode* node, CStatus* status) { CSimpleFrame* parent = this->m_parent; if (!parent) { return; } for (uint32_t i = 0; i < FRAMEPOINT_NUMPOINTS; i++) { if (this->m_framePoints[i] && !(this->m_framePoints[i]->m_flags & 0x8)) { return; } } this->SetAllPoints(parent, 1); } // VERIFY: 4323d6db manual // OFFSET: 0x00483120 void CSimpleTexture::SetRotation(float radians, float centerX, float centerY) { float angle = radians - 0.78539819f; float s = sin(angle); float c = cos(angle); this->m_texCoords[0].x = s + centerX; this->m_texCoords[0].y = centerY - c; this->m_texCoords[1].x = centerX - c; this->m_texCoords[1].y = centerY - s; this->m_texCoords[2].x = c + centerX; this->m_texCoords[2].y = s + centerY; this->m_texCoords[3].x = centerX - s; this->m_texCoords[3].y = centerY + c; } // VERIFY: 8094d28a auto // OFFSET: 0x004831D0 void CSimpleTexture::SetTexCoord(const CRect& texRect) { this->m_texCoords[0].x = texRect.minX; this->m_texCoords[0].y = texRect.minY; this->m_texCoords[1].x = texRect.minX; this->m_texCoords[1].y = texRect.maxY; this->m_texCoords[2].x = texRect.maxX; this->m_texCoords[2].y = texRect.minY; this->m_texCoords[3].x = texRect.maxX; this->m_texCoords[3].y = texRect.maxY; } // VERIFY: 5a6638c2 auto // OFFSET: 0x00483220 void CSimpleTexture::SetPosition(const CRect& rect, C3Vector* position) { position[0].x = rect.minX; position[0].y = rect.maxY; position[0].z = this->m_layoutDepth; position[1].x = rect.minX; position[1].y = rect.minY; position[1].z = this->m_layoutDepth; position[2].x = rect.maxX; position[2].y = rect.maxY; position[2].z = this->m_layoutDepth; position[3].x = rect.maxX; position[3].y = rect.minY; position[3].z = this->m_layoutDepth; } // VERIFY: da5e4d9e auto // OFFSET: 0x00483290 CGxShader* CSimpleTexture::GetImageModePixelShader(TextureImageMode mode) { if (CSimpleTexture::s_imageModePixelShaders[mode] && CSimpleTexture::s_imageModePixelShaders[mode]->Valid()) { return CSimpleTexture::s_imageModePixelShaders[mode]; } return nullptr; } // VERIFY: 99978bcf manual // OFFSET: 0x004832C0 void CSimpleTexture::OnFrameSizeChanged(const CRect& rect) { this->CLayoutFrame::OnFrameSizeChanged(rect); if (this->m_animating) { C3Vector positions[4]; memcpy(positions, this->m_storedPositions, sizeof(positions)); this->SetPosition(this->m_rect, this->m_storedPositions); this->m_positions[0].x += this->m_storedPositions[0].x - positions[0].x; this->m_positions[0].y += this->m_storedPositions[0].y - positions[0].y; this->m_positions[0].z += this->m_storedPositions[0].z - positions[0].z; this->m_positions[1].x += this->m_storedPositions[1].x - positions[1].x; this->m_positions[1].y += this->m_storedPositions[1].y - positions[1].y; this->m_positions[1].z += this->m_storedPositions[1].z - positions[1].z; this->m_positions[2].x += this->m_storedPositions[2].x - positions[2].x; this->m_positions[2].y += this->m_storedPositions[2].y - positions[2].y; this->m_positions[2].z += this->m_storedPositions[2].z - positions[2].z; this->m_positions[3].x += this->m_storedPositions[3].x - positions[3].x; this->m_positions[3].y += this->m_storedPositions[3].y - positions[3].y; this->m_positions[3].z += this->m_storedPositions[3].z - positions[3].z; } else { this->SetPosition(this->m_rect, this->m_positions); } if ((this->m_textureFlags & 0x4) || (this->m_textureFlags & 0x8)) { this->m_textureFlags |= 0x2; this->OnRegionChanged(); } if (this->m_parent) { this->m_parent->NotifyScrollParent(); } } // VERIFY: a9647663 auto // OFFSET: 0x00483460 void CSimpleTexture::PreOnAnimUpdate() { if (this->m_animating) { memcpy(this->m_positions, this->m_storedPositions, sizeof(this->m_positions)); if (this->m_animAlpha) { uint8_t alpha = this->m_animSavedAlpha; CImVector color; this->GetVertexColor(color); color.a = alpha; this->SetVertexColor(color); } } } // VERIFY: e87a4320 manual // OFFSET: 0x00484470 CSimpleTexture::CSimpleTexture(CSimpleFrame* frame, uint32_t drawLayer, int32_t show) : CSimpleRegion(frame, drawLayer, show) { this->m_texture = nullptr; this->m_alphaMode = GxBlend_Alpha; this->m_shader = CSimpleTexture::s_imageModePixelShaders[ImageMode_Normal]; this->m_textureFlags &= ~0xFu; this->m_shader = CSimpleTexture::GetImageModePixelShader(ImageMode_Normal); CSimpleTexture::s_count++; this->m_texCoords[0].x = 0.0f; this->m_texCoords[0].y = 0.0f; this->m_texCoords[1].x = 0.0f; this->m_texCoords[1].y = 1.0f; this->m_texCoords[2].x = 1.0f; this->m_texCoords[2].y = 0.0f; this->m_texCoords[3].x = 1.0f; this->m_texCoords[3].y = 1.0f; } // VERIFY: 9d63630a manual // OFFSET: 0x004859E0 int32_t CSimpleTexture::SetTexture(const char* fileName, int32_t wrapU, int32_t wrapV, EGxTexFilter filter, TextureImageMode mode) { if (this->m_texture && fileName && TextureIsSame(this->m_texture, fileName)) { return 1; } CTexture* texture = nullptr; if (fileName && *fileName) { CStatus status; texture = TextureCreate(fileName, CGxTexFlags(filter, wrapU, wrapV, 0, 0, 0, 1), &status, 0x17); if (status.m_highestSeverity >= STATUS_ERROR) { HandleClose(reinterpret_cast(texture)); SysMsgAdd(&status); return 0; } this->m_shader = CSimpleTexture::GetImageModePixelShader(mode); } if (this->m_texture) { HandleClose(reinterpret_cast(this->m_texture)); } this->m_texture = texture; this->OnRegionChanged(); return 1; } // VERIFY: f1967c67 auto // OFFSET: 0x00485AF0 void CSimpleEmbeddedTexture::InitEmbeddedTexture(CSimpleFontString* string, const GXUEMBEDDEDTEXTUREINFO* info) { if (string && info) { if (!this->m_texture) { return; } char path[256]; SStrCopy(path, info->m_path, info->m_pathLength + 1); if (this->m_texture->SetTexture(path, 0, 0, CSimpleTexture::s_textureFilterMode, ImageMode_Normal)) { float top = 0.0f; float left = 0.0f; float baseLine = 0.0f; float right = 0.0f; NDCToDDC(info->m_left, info->m_baseLineHeight, &left, &baseLine); NDCToDDC(info->m_right, info->m_lineHeight, &right, &top); float offsetX = NDCToDDCWidth(info->m_offsetX); float offsetY = NDCToDDCHeight(info->m_offsetY); float width = NDCToDDCWidth(info->m_width); float height = NDCToDDCHeight(info->m_height); uint32_t styleFlags = string->m_styleFlags; float x = 0.0f; float y = 0.0f; uint32_t point = FRAMEPOINT_TOPLEFT; switch (styleFlags & 0x7) { case 0x1: x = left + offsetX; break; case 0x2: point = FRAMEPOINT_TOP; x = (right + left) * 0.5f + offsetX; break; case 0x4: point = FRAMEPOINT_TOPRIGHT; x = right + offsetX; break; } switch (styleFlags & 0x38) { case 0x8: y = top + offsetY; break; case 0x10: point += 3; y = (string->GetStringHeight() * string->m_layoutScale + height) * 0.5f + baseLine + offsetY; break; case 0x20: point += 6; y = string->GetStringHeight() + baseLine + offsetY; break; } this->m_texture->MarkFramePointsUnused(); this->m_texture->SetPoint(static_cast(point), string, static_cast(point), x, y, 1); this->m_texture->SetWidth(width); this->m_texture->SetHeight(height); this->m_texture->SetVertexAlpha(string->GetVertexAlpha()); if (info->m_hasTexCoords) { this->m_texture->SetTexCoord(info->m_texCoords); } else { CRect texRect = { 0.0f, 0.0f, 1.0f, 1.0f }; this->m_texture->SetTexCoord(texRect); } this->m_texture->m_shown = 1; this->m_texture->ShowThis(); return; } } if (this->m_texture) { this->m_texture->m_shown = 0; this->m_texture->HideThis(); } } // VERIFY: 8453c584 manual // OFFSET: 0x00485F40 void CSimpleTexture::LoadXML(XMLNode* node, CStatus* status) { const char* inherits = node->GetAttributeByName("inherits"); if (inherits && *inherits) { const char* taint; bool locked; XMLNode* inheritNode = FrameXML_AcquireHashNode(inherits, taint, locked); if (!inheritNode) { status->Add(STATUS_WARNING, "Couldn't find inherited node: %s", inherits); } else if (locked) { status->Add(STATUS_WARNING, "Recursively inherited node: %s", inherits); } else { this->LoadXML(inheritNode, status); FrameXML_ReleaseHashNode(inherits); } } this->CScriptRegion::LoadXML(node, status); CImVector color; int32_t wrapU = 0; int32_t wrapV = 0; const char* hidden = node->GetAttributeByName("hidden"); if (hidden && *hidden) { if (StringToBOOL(hidden)) { this->m_shown = 0; this->HideThis(); } else { this->m_shown = 1; this->ShowThis(); } } const char* horizTile = node->GetAttributeByName("horizTile"); if (horizTile && *horizTile) { this->m_textureFlags ^= (((StringToBOOL(horizTile) != 0) << 2) ^ this->m_textureFlags) & 0x4; wrapU = 1; } const char* vertTile = node->GetAttributeByName("vertTile"); if (vertTile && *vertTile) { this->m_textureFlags ^= (((StringToBOOL(vertTile) != 0) << 3) ^ this->m_textureFlags) & 0x8; wrapV = 1; } for (XMLNode* child = node->m_child; child; child = child->m_next) { if (!SStrCmpI(child->m_name.m_str, "TexCoords", STORM_MAX_STR)) { float ulx = 0.0f; float uly = 0.0f; float llx = 0.0f; float lly = 1.0f; float urx = 1.0f; float ury = 0.0f; float lrx = 1.0f; float lry = 1.0f; int32_t valid = 1; XMLNode* rectNode = child->GetChildByName("Rect"); if (rectNode) { const char* value = rectNode->GetAttributeByName("ULx"); if (value && *value) { ulx = SStrToFloat(value); if (ulx < -10000.0f || ulx > 10000.0f) { const char* name = this->GetName(); status->Add(STATUS_ERROR, "Texture %s: Invalid rect value (out of range)", name ? name : ""); valid = 0; } } value = rectNode->GetAttributeByName("ULy"); if (value && *value) { uly = SStrToFloat(value); if (uly < -10000.0f || uly > 10000.0f) { const char* name = this->GetName(); status->Add(STATUS_ERROR, "Texture %s: Invalid rect value (out of range)", name ? name : ""); valid = 0; } } value = rectNode->GetAttributeByName("LLx"); if (value && *value) { llx = SStrToFloat(value); if (llx < -10000.0f || llx > 10000.0f) { const char* name = this->GetName(); status->Add(STATUS_ERROR, "Texture %s: Invalid rect value (out of range)", name ? name : ""); valid = 0; } } value = rectNode->GetAttributeByName("LLy"); if (value && *value) { lly = SStrToFloat(value); if (lly < -10000.0f || lly > 10000.0f) { const char* name = this->GetName(); status->Add(STATUS_ERROR, "Texture %s: Invalid rect value (out of range)", name ? name : ""); valid = 0; } } value = rectNode->GetAttributeByName("URx"); if (value && *value) { urx = SStrToFloat(value); if (urx < -10000.0f || urx > 10000.0f) { const char* name = this->GetName(); status->Add(STATUS_ERROR, "Texture %s: Invalid rect value (out of range)", name ? name : ""); valid = 0; } } value = rectNode->GetAttributeByName("URy"); if (value && *value) { ury = SStrToFloat(value); if (ury < -10000.0f || ury > 10000.0f) { const char* name = this->GetName(); status->Add(STATUS_ERROR, "Texture %s: Invalid rect value (out of range)", name ? name : ""); valid = 0; } } value = rectNode->GetAttributeByName("LRx"); if (value && *value) { lrx = SStrToFloat(value); if (lrx < -10000.0f || lrx > 10000.0f) { const char* name = this->GetName(); status->Add(STATUS_ERROR, "Texture %s: Invalid rect value (out of range)", name ? name : ""); valid = 0; } } value = rectNode->GetAttributeByName("LRy"); if (value && *value) { lry = SStrToFloat(value); if (lry < -10000.0f || lry > 10000.0f) { const char* name = this->GetName(); status->Add(STATUS_ERROR, "Texture %s: Invalid rect value (out of range)", name ? name : ""); valid = 0; } } } const char* left = child->GetAttributeByName("left"); if (left && *left) { if (this->m_textureFlags & 0x4) { const char* name = this->GetName(); status->Add(STATUS_ERROR, "Texture %s: Invalid TexCoords value (horizTile is on)", name ? name : ""); } else { llx = SStrToFloat(left); ulx = llx; if (llx < -10000.0f || llx > 10000.0f) { const char* name = this->GetName(); status->Add(STATUS_ERROR, "Texture %s: Invalid TexCoords value (out of range)", name ? name : ""); valid = 0; } } } const char* right = child->GetAttributeByName("right"); if (right && *right) { if (this->m_textureFlags & 0x4) { const char* name = this->GetName(); status->Add(STATUS_ERROR, "Texture %s: Invalid TexCoords value (horizTile is on)", name ? name : ""); } else { lrx = SStrToFloat(right); urx = lrx; if (lrx < -10000.0f || lrx > 10000.0f) { const char* name = this->GetName(); status->Add(STATUS_ERROR, "Texture %s: Invalid TexCoords value (out of range)", name ? name : ""); valid = 0; } } } const char* top = child->GetAttributeByName("top"); if (top && *top) { if (this->m_textureFlags & 0x8) { const char* name = this->GetName(); status->Add(STATUS_ERROR, "Texture %s: Invalid TexCoords value (vertTile is on)", name ? name : ""); } else { ury = SStrToFloat(top); uly = ury; if (ury < -10000.0f || ury > 10000.0f) { const char* name = this->GetName(); status->Add(STATUS_ERROR, "Texture %s: Invalid TexCoords value (out of range)", name ? name : ""); valid = 0; } } } const char* bottom = child->GetAttributeByName("bottom"); if (bottom && *bottom) { if (this->m_textureFlags & 0x8) { const char* name = this->GetName(); status->Add(STATUS_ERROR, "Texture %s: Invalid TexCoords value (vertTile is on)", name ? name : ""); } else { lly = SStrToFloat(bottom); lry = lly; if (lly < -10000.0f || lly > 10000.0f) { const char* name = this->GetName(); status->Add(STATUS_ERROR, "Texture %s: Invalid TexCoords value (out of range)", name ? name : ""); continue; } } } if (valid) { this->m_texCoords[0].x = ulx; this->m_texCoords[0].y = uly; this->m_texCoords[1].x = llx; this->m_texCoords[1].y = lly; this->m_texCoords[2].x = urx; this->m_texCoords[2].y = ury; this->m_texCoords[3].x = lrx; this->m_texCoords[3].y = lry; if (ulx < 0.0f || ulx > 1.0f || llx < 0.0f || llx > 1.0f || urx < 0.0f || urx > 1.0f || lrx < 0.0f || lrx > 1.0f) { wrapU = 1; } if (uly < 0.0f || uly > 1.0f || lly < 0.0f || lly > 1.0f || ury < 0.0f || ury > 1.0f || lry < 0.0f || lry > 1.0f) { wrapV = 1; } } } else if (!SStrCmpI(child->m_name.m_str, "Color", STORM_MAX_STR)) { LoadXML_Color(child, color, status); this->SetTexture(color); } else if (!SStrCmpI(child->m_name.m_str, "Gradient", STORM_MAX_STR)) { ORIENTATION orientation; CImVector minColor; CImVector maxColor; LoadXML_Gradient(child, orientation, minColor, maxColor, status); this->SetVertexGradient(orientation, minColor, maxColor); } } const char* file = node->GetAttributeByName("file"); if (file && *file) { if (this->SetTexture(file, wrapU, wrapV, CSimpleTexture::s_textureFilterMode, ImageMode_Normal)) { if (*reinterpret_cast(&color)) { this->SetVertexColor(color); } } else { const char* name = this->GetName(); status->Add(STATUS_WARNING, "Texture %s: Unable to load texture file %s", name ? name : "", file); CImVector missingColor; missingColor.b = 0x00; missingColor.g = 0xFF; missingColor.r = 0x00; missingColor.a = 0xFF; this->SetTexture(missingColor); } } const char* alphaMode = node->GetAttributeByName("alphaMode"); EGxBlend blend; if (alphaMode && *alphaMode && StringToBlendMode(alphaMode, blend)) { this->SetBlendMode(blend); } const char* alpha = node->GetAttributeByName("alpha"); if (alpha && *alpha) { float value = SStrToFloat(alpha); value = value < 0.0f ? 0.0f : (value >= 1.0f ? 1.0f : value); CImVector vertexColor; this->GetVertexColor(vertexColor); vertexColor.a = static_cast(value * 255.0f); this->SetVertexColor(vertexColor); } const char* nonBlocking = node->GetAttributeByName("nonBlocking"); if (nonBlocking && *nonBlocking) { this->m_textureFlags ^= ((StringToBOOL(nonBlocking) != 0) ^ this->m_textureFlags) & 0x1; } }