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

357 lines
13 KiB
C++
Raw Blame History

#include "Runtime/GuiSys/CTextRenderBuffer.hpp"
#include "Runtime/Graphics/CGX.hpp"
#include "Runtime/Graphics/CGraphics.hpp"
#include "Runtime/Graphics/CGraphicsPalette.hpp"
#include "Runtime/Graphics/CTexture.hpp"
#include "Runtime/Graphics/Shaders/CTextSupportShader.hpp"
#include "Runtime/GuiSys/CFontImageDef.hpp"
#include "Runtime/GuiSys/CFontRenderState.hpp"
#include "Runtime/GuiSys/CInstruction.hpp"
#include "Runtime/GuiSys/CRasterFont.hpp"
#include "Runtime/GuiSys/CTextExecuteBuffer.hpp"
namespace metaforce {
CTextRenderBuffer::CTextRenderBuffer(CTextRenderBuffer&&) noexcept = default;
CTextRenderBuffer::CTextRenderBuffer(EMode mode) : x0_mode(mode) {}
CTextRenderBuffer::~CTextRenderBuffer() = default;
CTextRenderBuffer& CTextRenderBuffer::operator=(CTextRenderBuffer&&) noexcept = default;
void CTextRenderBuffer::SetPrimitive(const Primitive& prim, s32 idx) {
CMemoryStreamOut out(reinterpret_cast<u8*>(x34_bytecode.data() + x24_primOffsets[idx]),
x44_blobSize - x24_primOffsets[idx]);
if (prim.x4_command == Command::ImageRender) {
out.WriteUint8(static_cast<u8>(Command::ImageRender));
out.Put(prim.x8_xPos);
out.Put(prim.xa_zPos);
out.Put(prim.xe_imageIndex);
out.Put(prim.x0_color1.toRGBA());
} else if (prim.x4_command == Command::CharacterRender) {
out.WriteUint8(static_cast<u8>(Command::CharacterRender));
out.Put(prim.x8_xPos);
out.Put(prim.xa_zPos);
out.Put(u16(prim.xc_glyph));
out.Put(prim.x0_color1.toRGBA());
}
}
CTextRenderBuffer::Primitive CTextRenderBuffer::GetPrimitive(s32 idx) const {
CMemoryInStream in(reinterpret_cast<const u8*>(x34_bytecode.data() + x24_primOffsets[idx]),
x44_blobSize - x24_primOffsets[idx]);
auto cmd = Command(in.ReadChar());
if (cmd == Command::ImageRender) {
s16 xPos = in.ReadShort();
s16 zPos = in.ReadShort();
u8 imageIndex = in.ReadChar();
CTextColor color(in.ReadUint32());
return {color, Command::ImageRender, xPos, zPos, u'\0', imageIndex};
}
if (cmd == Command::CharacterRender) {
s16 xPos = in.ReadShort();
s16 zPos = in.ReadShort();
char16_t glyph = in.ReadUint16();
CTextColor color(in.ReadUint32());
return {color, Command::CharacterRender, xPos, zPos, glyph, 0};
}
return {CTextColor(zeus::Comp32(0)), Command::Invalid, 0, 0, u'\0', 0};
}
u8* CTextRenderBuffer::GetOutStream() {
VerifyBuffer();
return reinterpret_cast<u8*>(x34_bytecode.data()) + x48_curBytecodeOffset;
}
void CTextRenderBuffer::VerifyBuffer() {
if (x34_bytecode.empty()) {
x34_bytecode.resize(x44_blobSize);
}
}
void CTextRenderBuffer::SetMode(EMode mode) { x0_mode = mode; }
int CTextRenderBuffer::GetMatchingPaletteIndex(const CGraphicsPalette& palette) {
for (int i = 0; i < x50_palettes.size(); ++i) {
if (memcmp(x50_palettes[i]->GetPaletteData(), palette.GetPaletteData(), 8) == 0) {
return i;
}
}
return -1;
}
CGraphicsPalette* CTextRenderBuffer::GetNextAvailablePalette() {
if (x254_nextPalette < 64) {
x50_palettes.push_back(std::make_unique<CGraphicsPalette>(EPaletteFormat::RGB5A3, 4));
} else {
x254_nextPalette = 0;
}
++x254_nextPalette;
return x50_palettes[x254_nextPalette - 1].get();
}
u32 CTextRenderBuffer::GetCurLen() {
VerifyBuffer();
return x44_blobSize - x48_curBytecodeOffset;
}
void CTextRenderBuffer::Render(const zeus::CColor& color, float time) {
x4c_activeFont = -1;
x4d_activePalette = -1;
CMemoryInStream in(x34_bytecode.data(), x44_blobSize);
while (in.GetReadPosition() < x44_blobSize) {
auto cmd = static_cast<Command>(in.ReadChar());
if (cmd == Command::FontChange) {
x4c_activeFont = x4e_queuedFont = in.ReadChar();
} else if (cmd == Command::CharacterRender) {
if (x4e_queuedFont != -1) {
auto font = x4_fonts[x4e_queuedFont];
if (font) {
font->SetupRenderState();
x4e_queuedFont = -1;
}
}
if (x4f_queuedPalette != -1) {
x50_palettes[x4f_queuedPalette]->Load();
x4f_queuedPalette = -1;
}
s16 offX = in.ReadShort();
s16 offY = in.ReadShort();
char16_t chr = in.ReadShort();
zeus::CColor chrColor(static_cast<zeus::Comp32>(in.ReadLong()));
if (x4c_activeFont != -1) {
auto font = x4_fonts[x4c_activeFont];
if (font && font->GetGlyph(chr) != nullptr) {
const auto* glyph = font->GetGlyph(chr);
CGX::SetTevKColor(GX::KCOLOR0, chrColor * color);
CGX::Begin(GX::TRIANGLESTRIP, GX::VTXFMT0, 4);
{
GXPosition3f32(offX, 0.f, offY);
GXTexCoord2f32(glyph->GetStartU(), glyph->GetStartV());
GXPosition3f32(offX + glyph->GetCellWidth(), 0.f, offY);
GXTexCoord2f32(glyph->GetEndU(), glyph->GetStartV());
GXPosition3f32(offX, 0.f, offY + glyph->GetCellHeight());
GXTexCoord2f32(glyph->GetStartU(), glyph->GetEndV());
GXPosition3f32(offX + glyph->GetCellWidth(), 0.f, offY + glyph->GetCellHeight());
GXTexCoord2f32(glyph->GetEndU(), glyph->GetEndV());
}
CGX::End();
}
}
} else if (cmd == Command::ImageRender) {
s16 offX = in.ReadShort();
s16 offY = in.ReadShort();
u8 imageIdx = in.ReadChar();
zeus::CColor imageColor(static_cast<zeus::Comp32>(in.ReadLong()));
auto imageDef = x14_images[imageIdx];
auto tex = imageDef.x4_texs[static_cast<u32>(time * imageDef.x0_fps) % imageDef.x4_texs.size()];
if (tex) {
tex->Load(GX::TEXMAP0, EClampMode::Clamp);
float width = imageDef.x4_texs.front()->GetWidth() * imageDef.x14_cropFactor.x();
float height = imageDef.x4_texs.front()->GetHeight() * imageDef.x14_cropFactor.y();
float cropXHalf = imageDef.x14_cropFactor.x() * 0.5f;
float cropYHalf = imageDef.x14_cropFactor.y() * 0.5f;
CGX::SetTevKAlphaSel(GX::TEVSTAGE0, GX::TEV_KASEL_K0_A);
CGX::SetTevKColorSel(GX::TEVSTAGE0, GX::TEV_KCSEL_K0);
CGX::SetTevColorIn(GX::TEVSTAGE0, GX::CC_ZERO, GX::CC_TEXC, GX::CC_KONST, GX::CC_ZERO);
CGX::SetTevAlphaIn(GX::TEVSTAGE0, GX::CA_ZERO, GX::CA_TEXA, GX::CA_KONST, GX::CA_ZERO);
CGX::SetStandardTevColorAlphaOp(GX::TEVSTAGE0);
constexpr std::array skVtxDesc{
GX::VtxDescList{GX::VA_POS, GX::DIRECT},
GX::VtxDescList{GX::VA_TEX0, GX::DIRECT},
GX::VtxDescList{},
};
CGX::SetVtxDescv(skVtxDesc.data());
CGX::SetNumChans(0);
CGX::SetNumTexGens(1);
CGX::SetNumTevStages(1);
CGX::SetTevOrder(GX::TEVSTAGE0, GX::TEXCOORD0, GX::TEXMAP0, GX::COLOR_NULL);
CGX::SetTexCoordGen(GX::TEXCOORD0, GX::TG_MTX2x4, GX::TG_TEX0, GX::IDENTITY, false, GX::PTIDENTITY);
CGX::SetTevKColor(GX::KCOLOR0, imageColor * color);
CGX::Begin(GX::TRIANGLESTRIP, GX::VTXFMT0, 4);
{
GXPosition3f32(offX, 0.f, offY);
GXTexCoord2f32(0.5f - cropXHalf, 0.5f + cropYHalf);
GXPosition3f32(offX + width, 0.f, offY);
GXTexCoord2f32(0.5f + cropXHalf, 0.5f + cropYHalf);
GXPosition3f32(offX, 0.f, offY + height);
GXTexCoord2f32(0.5f - cropXHalf, 0.5f - cropYHalf);
GXPosition3f32(offX + width, 0.f, offY + height);
GXTexCoord2f32(0.5f + cropXHalf, 0.5f - cropYHalf);
}
CGX::End();
x4e_queuedFont = x4c_activeFont;
x4f_queuedPalette = x4d_activePalette;
}
} else if (cmd == Command::PaletteChange) {
x4d_activePalette = x4f_queuedPalette = in.ReadChar();
}
}
}
void CTextRenderBuffer::AddPaletteChange(const CGraphicsPalette& palette) {
if (x0_mode == EMode::BufferFill) {
{
u8* buf = GetOutStream();
CMemoryStreamOut out(buf, GetCurLen());
s32 paletteIndex = GetMatchingPaletteIndex(palette);
if (paletteIndex == -1) {
GetNextAvailablePalette();
paletteIndex = x254_nextPalette - 1;
CGraphicsPalette* destPalette = x50_palettes[x254_nextPalette - 1].get();
u16* data = destPalette->Lock();
memcpy(data, palette.GetPaletteData(), 8);
destPalette->UnLock();
}
out.WriteUint8(static_cast<u8>(Command::PaletteChange));
out.WriteUint8(paletteIndex);
x48_curBytecodeOffset += out.GetNumWrites();
}
} else {
x44_blobSize += 2;
}
}
void CTextRenderBuffer::AddImage(const zeus::CVector2i& offset, const CFontImageDef& image) {
if (x0_mode == EMode::BufferFill) {
CMemoryStreamOut out(GetOutStream(), GetCurLen());
x24_primOffsets.reserve(x24_primOffsets.size() + 1);
u32 primCap = x24_primOffsets.capacity();
if (x24_primOffsets.capacity() <= x24_primOffsets.size()) {
x24_primOffsets.reserve(primCap != 0 ? primCap * 2 : 4);
}
x24_primOffsets.push_back(x48_curBytecodeOffset);
x14_images.reserve(x14_images.size() + 1);
u32 imgIdx = x14_images.size();
x14_images.push_back(image);
out.WriteUint8(static_cast<u8>(Command::ImageRender));
out.WriteShort(offset.x);
out.WriteShort(offset.y);
out.WriteUint8(imgIdx);
out.WriteLong(zeus::skWhite.toRGBA());
x48_curBytecodeOffset += out.GetNumWrites();
} else {
x44_blobSize += 10;
}
}
void CTextRenderBuffer::AddCharacter(const zeus::CVector2i& offset, char16_t ch, const CTextColor& color) {
if (x0_mode == EMode::BufferFill) {
CMemoryStreamOut out(GetOutStream(), GetCurLen());
x24_primOffsets.reserve(x24_primOffsets.size() + 1);
u32 primCap = x24_primOffsets.capacity();
if (x24_primOffsets.capacity() <= x24_primOffsets.size()) {
x24_primOffsets.reserve(primCap != 0 ? primCap * 2 : 4);
}
x24_primOffsets.push_back(x48_curBytecodeOffset);
out.WriteUint8(u32(Command::CharacterRender));
out.WriteShort(offset.x);
out.WriteShort(offset.y);
out.WriteShort(ch);
out.WriteUint32(color.toRGBA());
x48_curBytecodeOffset += out.GetNumWrites();
} else {
x44_blobSize += 11;
}
}
void CTextRenderBuffer::AddFontChange(const TToken<CRasterFont>& font) {
if (x0_mode == EMode::BufferFill) {
CMemoryStreamOut out(GetOutStream(), GetCurLen());
u32 fontCount = x4_fonts.size();
bool found = false;
u8 fontIndex = 0;
if (fontCount > 0) {
for (const auto& tok : x4_fonts) {
if (tok.GetObjectReference() == font.GetObjectReference()) {
out.WriteUint8(static_cast<u8>(Command::FontChange));
out.WriteUint8(fontIndex);
found = true;
break;
}
++fontIndex;
}
}
if (!found) {
x4_fonts.reserve(x4_fonts.size() + 1);
u32 fontIdx = x4_fonts.size();
x4_fonts.push_back(font);
out.WriteUint8(static_cast<u8>(Command::FontChange));
out.WriteUint8(fontIdx);
}
x48_curBytecodeOffset += out.GetNumWrites();
} else {
x44_blobSize += 2;
}
}
bool CTextRenderBuffer::HasSpaceAvailable(const zeus::CVector2i& origin, const zeus::CVector2i& extent) {
std::pair<zeus::CVector2i, zeus::CVector2i> bounds = AccumulateTextBounds();
if (bounds.first.x > bounds.second.x) {
return true;
}
if (0 < origin.y) {
return false;
}
zeus::CVector2i size = bounds.second - bounds.first;
return size.y <= extent.y;
}
std::pair<zeus::CVector2i, zeus::CVector2i> CTextRenderBuffer::AccumulateTextBounds() {
zeus::CVector2i min{INT_MAX, INT_MAX};
zeus::CVector2i max{INT_MIN, INT_MIN};
CMemoryInStream in(x34_bytecode.data(), x44_blobSize);
while (in.GetReadPosition() < x48_curBytecodeOffset) {
auto cmd = static_cast<Command>(in.ReadChar());
if (cmd == Command::FontChange) {
x4c_activeFont = in.ReadChar();
} else if (cmd == Command::CharacterRender) {
u16 offX = in.ReadShort();
u16 offY = in.ReadShort();
char16_t chr = in.ReadShort();
in.ReadLong();
if (x4c_activeFont != -1) {
auto font = x4_fonts[x4c_activeFont];
if (font) {
const auto* glyph = font->GetGlyph(chr);
if (glyph != nullptr) {
max.x = std::max(max.x, offX + glyph->GetCellWidth());
max.y = std::max(max.y, offY + glyph->GetCellHeight());
min.x = std::min<int>(min.x, offX);
min.y = std::min<int>(min.y, offY);
}
}
}
} else if (cmd == Command::ImageRender) {
u16 offX = in.ReadShort();
u16 offY = in.ReadShort();
u8 imageIdx = in.ReadChar();
in.ReadLong();
const auto& image = x14_images[imageIdx];
max.x = std::max(max.x, offX + static_cast<int>(static_cast<float>(image.x4_texs.front()->GetWidth()) *
image.x14_cropFactor.x()));
max.y = std::max(max.y, offY + static_cast<int>(static_cast<float>(image.x4_texs.front()->GetHeight()) *
image.x14_cropFactor.y()));
min.x = std::min<int>(min.x, offX);
min.y = std::min<int>(min.y, offY);
} else if (cmd == Command::PaletteChange) {
in.ReadChar();
}
}
return {min, max};
}
} // namespace metaforce
Reference in New Issue View Git Blame Copy Permalink