chore: initial commit

src/ui/CRenderBatch.cpp

@@ -0,0 +1,220 @@
+#include "ui/CRenderBatch.hpp"
+#include "ui/CSimpleFontString.hpp"
+#include "ui/CSimpleTexture.hpp"
+#include "gx/Coordinate.hpp"
+#include "gx/Font.hpp"
+#include "gx/Shader.hpp"
+#include "gx/font/CGxStringBatch.hpp"
+#include <cstdlib>
+#include <storm/Error.hpp>
+
+int32_t SortByTexture(const void* a, const void* b) {
+    auto meshA = reinterpret_cast<const CSimpleBatchedMesh*>(a);
+    auto meshB = reinterpret_cast<const CSimpleBatchedMesh*>(b);
+
+    if (meshA->textureID != meshB->textureID) {
+        return meshA->textureID - meshB->textureID;
+    }
+
+    if (meshA->alphaMode != meshB->alphaMode) {
+        if ((meshA->alphaMode >= 2 || !meshA->color) && (meshB->alphaMode >= 2 || !meshB->color)) {
+            return meshA->alphaMode - meshB->alphaMode;
+        } else if (meshA->alphaMode >= 2 || !meshA->color) {
+            return meshA->alphaMode - 2;
+        } else if (meshB->alphaMode >= 2 || !meshB->color) {
+            return 2 - meshB->alphaMode;
+        }
+    }
+
+    if (meshA->shader != meshB->shader) {
+        return meshA->shader - meshB->shader;
+    }
+
+    return 0;
+}
+
+EGxBlend CSimpleBatchedMesh::GetAlphaMode() {
+    if (this->color && this->alphaMode < GxBlend_Alpha) {
+        return GxBlend_Alpha;
+    } else {
+        return this->alphaMode;
+    }
+}
+
+void CRenderBatch::Clear() {
+    this->m_texturelist.SetCount(0);
+
+    if (this->m_stringbatch) {
+        GxuFontDestroyBatch(this->m_stringbatch);
+        this->m_stringbatch = nullptr;
+    }
+
+    this->m_callbacks.DeleteAll();
+
+    this->m_count = 0;
+}
+
+void CRenderBatch::Finish() {
+    if (this->m_texturelist.Count() > 1) {
+        qsort(this->m_texturelist.m_data, this->m_texturelist.Count(), sizeof(CSimpleBatchedMesh), SortByTexture);
+    }
+}
+
+void CRenderBatch::Queue(CTexture* texture, EGxBlend alphaMode, int32_t posCount, const C3Vector* position, const C2Vector* texCoord, int32_t colorCount, const CImVector* color, int32_t idxCount, const uint16_t* indices, CGxShader* shader) {
+    CGxTex* textureID = TextureGetGxTex(texture, 1, nullptr);
+
+    if (!textureID) {
+        return;
+    }
+
+    CSimpleBatchedMesh* mesh = this->m_texturelist.New();
+
+    mesh->texture = texture;
+    mesh->textureID = textureID;
+    mesh->alphaMode = alphaMode;
+    mesh->shader = shader;
+    mesh->posCount = posCount;
+    mesh->position = const_cast<C3Vector*>(position);
+    mesh->texCoord = const_cast<C2Vector*>(texCoord);
+    mesh->color = const_cast<CImVector*>(color);
+    mesh->colorCount = colorCount;
+    mesh->indices = const_cast<uint16_t*>(indices);
+    mesh->idxCount = idxCount;
+
+    // TODO
+    // - implement atlas stuff
+    mesh->onAtlas = 0;
+    // mesh->onAtlas = TextureOnAtlas(texture);
+    // if (onAtlas) {
+    //     TextureGetAtlasOffsetAndScale(mesh->texture, mesh->offset, mesh->scale);
+    // }
+
+    this->m_count++;
+}
+
+void CRenderBatch::QueueCallback(void (*callback)(void*), void* param) {
+    auto node = this->m_callbacks.NewNode(2, 0, 0);
+    node->callback = callback;
+    node->param = param;
+
+    this->m_count++;
+}
+
+void CRenderBatch::QueueFontString(CSimpleFontString* string) {
+    CRect rect = { 0.0f, 0.0f, 0.0f, 0.0f };
+
+    if (!string->GetRect(&rect)) {
+        return;
+    }
+
+    if (rect.minX > 1.0f || rect.maxX < 0.0f || rect.minY > 1.0f || rect.maxY < 0.0f) {
+        return;
+    }
+
+    if (!string->m_string) {
+        return;
+    }
+
+    auto gxString = TextBlockGetStringPtr(string->m_string);
+
+    if (gxString) {
+        if (!this->m_stringbatch) {
+            this->m_stringbatch = GxuFontCreateBatch(false, false);
+            STORM_ASSERT(this->m_stringbatch);
+        }
+
+        GxuFontAddToBatch(this->m_stringbatch, gxString);
+        this->m_count++;
+    }
+}
+
+void CRenderBatch::QueueTexture(CSimpleTexture* texture) {
+    CGxTex* gxTex = TextureGetGxTex(texture->m_texture, texture->m_nonBlocking ? 0 : 2, 0);
+
+    if (!gxTex) {
+        // TODO
+        // this->OnDelayedLoad();
+
+        return;
+    }
+
+    if (texture->IsResizePending()) {
+        texture->Resize(1);
+    }
+
+    if (texture->m_updateTexCoord) {
+        C2Vector texCoord[4];
+        texture->GetTexCoord(texCoord);
+
+        CRect rect = {
+            texture->m_position[1].y,
+            texture->m_position[0].x,
+            texture->m_position[0].y,
+            texture->m_position[2].x
+        };
+
+        if (texture->m_horizTile) {
+            float width = gxTex->GetWidth();
+            float ddcWidth = CoordinateGetAspectCompensation() * 1024.0f * (rect.maxX - rect.minX);
+            float ndcWidth = DDCToNDCWidth(ddcWidth);
+
+            if (width && ndcWidth > 0.0f) {
+                if (texCoord[0].x != 0.0f) {
+                    texCoord[0].x = ndcWidth / width;
+                }
+
+                if (texCoord[1].x != 0.0f) {
+                    texCoord[1].x = ndcWidth / width;
+                }
+
+                if (texCoord[2].x != 0.0f) {
+                    texCoord[2].x = ndcWidth / width;
+                }
+
+                if (texCoord[3].x != 0.0f) {
+                    texCoord[3].x = ndcWidth / width;
+                }
+            }
+        }
+
+        if (texture->m_vertTile) {
+            float height = gxTex->GetHeight();
+            float ddcHeight = CoordinateGetAspectCompensation() * 1024.0f * (rect.maxY - rect.minY);
+            float ndcHeight = DDCToNDCWidth(ddcHeight);
+
+            if (height && ndcHeight > 0.0f) {
+                if (texCoord[0].y != 0.0f) {
+                    texCoord[0].y = ndcHeight / height;
+                }
+
+                if (texCoord[1].y != 0.0f) {
+                    texCoord[1].y = ndcHeight / height;
+                }
+
+                if (texCoord[2].y != 0.0f) {
+                    texCoord[2].y = ndcHeight / height;
+                }
+
+                if (texCoord[3].y != 0.0f) {
+                    texCoord[3].y = ndcHeight / height;
+                }
+            }
+        }
+
+        texture->m_updateTexCoord = 0;
+        texture->SetTexCoord(texCoord);
+    }
+
+    this->Queue(
+        TextureGetTexturePtr(texture->m_texture),
+        texture->m_alphaMode,
+        4,
+        texture->m_position,
+        texture->m_texCoord,
+        texture->m_colorCount > 1 ? 4 : 0,
+        texture->m_colorCount ? texture->m_color : nullptr,
+        6,
+        CSimpleTexture::s_indices,
+        texture->m_shader
+    );
+}