Renderer transformation refactor

profiles/common/scriptvars.lua

@@ -76,9 +76,11 @@ root.ScriptVars = {
     SW_MASK3ALPHA_OFS=2788,
     SW_BGEFF1_OFSX=2800,
     SW_BGEFF1_OFSY=2801,
-    SW_BGEFF1_ALPHA_OFS=2806,
     SW_BGEFF1_SIZE_OFS=2802,
+    SW_BGEFF1_ROTX_OFS=2803,
+    SW_BGEFF1_ROTY_OFS=2804,
     SW_BGEFF1_ROTZ_OFS=2805,
+    SW_BGEFF1_ALPHA_OFS=2806,
     SW_BGEFF1_MASK_VERTEX1_OFSX=2809,
     SW_BGEFF1_MASK_VERTEX1_OFSY=2810,
     SW_MAINTHDP=3304,
@@ -347,6 +349,8 @@ root.ScriptVars = {
     SW_BGEFF1_MASK_TYPE=6612,
     SW_BGEFF1_FADECT=6613,
     SW_BGEFF1_MODE=6614,
+    SW_BGEFF1_ROTX=6615,
+    SW_BGEFF1_ROTY=6616,
     SW_BGEFF1_ROTZ=6617,
     SW_BGEFF1_ALPHA=6618,
     SW_BGEFF1_MASKNO=6619,

src/background2d.cpp

@@ -169,9 +169,13 @@ void Background2D::RenderBgEff(int bgId, int layer) {
   FadeCount = ScrWork[SW_BGEFF1_FADECT + structOffset];
   FadeRange = ScrWork[SW_BGEFF1_MASKFADERANGE + structOffset];
 
-  Angle = (ScrWork[SW_BGEFF1_ROTZ + structOffset] +
-           ScrWork[SW_BGEFF1_ROTZ_OFS + structOfsOffset]) *
-          (float)(2.0f * M_PI / (float)(1 << 16));
+  Rotation = ScrWorkAnglesToQuaternion(
+      ScrWork[SW_BGEFF1_ROTX + structOffset] +
+          ScrWork[SW_BGEFF1_ROTX_OFS + structOfsOffset],
+      ScrWork[SW_BGEFF1_ROTY + structOffset] +
+          ScrWork[SW_BGEFF1_ROTY_OFS + structOfsOffset],
+      ScrWork[SW_BGEFF1_ROTZ + structOffset] +
+          ScrWork[SW_BGEFF1_ROTZ_OFS + structOfsOffset]);
 
   Scale = glm::vec2((ScrWork[SW_BGEFF1_SIZE + structOffset] +
                      ScrWork[SW_BGEFF1_SIZE_OFS + structOfsOffset]) /
@@ -222,6 +226,14 @@ void Background2D::RenderBgEff(int bgId, int layer) {
   Origin = {0.0f, 0.0f};
   for (const glm::vec2 vertex : vertices) Origin += vertex / (float)vertexCount;
 
+  // Transform vertices
+  const glm::mat4 transformation = TransformationMatrix(
+      Origin, Scale, {Origin, 0.0f}, Rotation, DisplayCoords);
+  std::transform(vertices.begin(), vertices.end(), vertices.begin(),
+                 [transformation](const glm::vec2 vertex) {
+                   return transformation * glm::vec4(vertex, 0.0f, 1.0f);
+                 });
+
   // Draw
   if (maskType == 0) {  // Rectangle
     const glm::vec2 maskDimensions = vertices[3] - vertices[0];
@@ -241,43 +253,43 @@ void Background2D::RenderBgEff(int bgId, int layer) {
 }
 
 void Background2D::RenderRegular() {
-  Renderer->DrawSpriteOffset(BgSprite, DisplayCoords, Origin, Tint, Scale,
-                             Angle, false);
+  const glm::mat4 transformation = TransformationMatrix(
+      Origin, Scale, {Origin, 0.0f}, Rotation, DisplayCoords);
+  Renderer->DrawSprite(BgSprite, transformation, Tint, false);
 
   for (int i = 0; i < MaxLinkedBgBuffers; i++) {
     if (Links[i].Direction != LD_Off && Links[i].LinkedBuffer != NULL) {
-      Renderer->DrawSpriteOffset(Links[i].LinkedBuffer->BgSprite,
-                                 Links[i].DisplayCoords, Origin, Tint, Scale,
-                                 Angle, false);
+      const glm::mat4 linkTransformation =
+          transformation *
+          glm::translate(glm::mat4(1.0f), {Links[i].DisplayCoords, 0.0f});
+
+      Renderer->DrawSprite(Links[i].LinkedBuffer->BgSprite, transformation,
+                           Tint, false);
     }
   }
 }
 
 void Background2D::RenderMasked() {
-  Renderer->DrawMaskedSpriteOffset(BgSprite, Masks2D[MaskNumber].MaskSprite,
-                                   DisplayCoords, Origin, FadeCount, FadeRange,
-                                   Tint, Scale, Angle, false, false, false);
+  const glm::mat4 transformation = TransformationMatrix(
+      Origin, Scale, {Origin, 0.0f}, Rotation, DisplayCoords);
+
+  Renderer->DrawMaskedSprite(BgSprite, Masks2D[MaskNumber].MaskSprite,
+                             FadeCount, FadeRange, transformation, Tint, false,
+                             false);
 }
 
 void Background2D::RenderMaskedInverted() {
-  Renderer->DrawMaskedSpriteOffset(BgSprite, Masks2D[MaskNumber].MaskSprite,
-                                   DisplayCoords, Origin, FadeCount, FadeRange,
-                                   Tint, Scale, Angle, false, true, false);
+  const glm::mat4 transformation = TransformationMatrix(
+      Origin, Scale, {Origin, 0.0f}, Rotation, DisplayCoords);
+  Renderer->DrawMaskedSprite(BgSprite, Masks2D[MaskNumber].MaskSprite,
+                             FadeCount, FadeRange, transformation, Tint, true,
+                             false);
 }
 
 void Background2D::RenderFade() {
   Tint.a *= FadeCount / 256.0f;
 
-  Renderer->DrawSpriteOffset(BgSprite, DisplayCoords, Origin, Tint, Scale,
-                             Angle, false);
-
-  for (int i = 0; i < MaxLinkedBgBuffers; i++) {
-    if (Links[i].Direction != LD_Off && Links[i].LinkedBuffer != NULL) {
-      Renderer->DrawSpriteOffset(Links[i].LinkedBuffer->BgSprite,
-                                 Links[i].DisplayCoords, Origin, Tint, Scale,
-                                 Angle, false);
-    }
-  }
+  RenderRegular();
 }
 
 }  // namespace Impacto

src/background2d.h

@@ -39,7 +39,7 @@ class Background2D : public Loadable<Background2D> {
   glm::vec2 DisplayCoords;
   glm::vec2 Origin = {0.0f, 0.0f};
   glm::vec2 Scale = {1.0f, 1.0f};
-  float Angle = 0.0f;
+  glm::quat Rotation = glm::quat();
   glm::vec4 Tint = glm::vec4(1.0f);
   int MaskNumber;
 

src/character2d.cpp

@@ -37,7 +37,7 @@ bool Character2D::LoadSync(uint32_t charaId) {
     // Skip to state data
     stream->Seek(0x68, SEEK_CUR);
 
-    MvlVerticesCount = Io::ReadLE<int>(stream);
+    int vertexCount = Io::ReadLE<int>(stream);
     int vertexOffset = Io::ReadLE<int>(stream);
 
     for (int i = 0; i < stateCount; i++) {
@@ -79,8 +79,18 @@ bool Character2D::LoadSync(uint32_t charaId) {
     // They seem to use the whole vertex array in all states, so... read it once
     // and forget about it?
     stream->Seek(vertexOffset, SEEK_SET);
-    MvlVertices.resize(MvlVerticesCount * 5);
-    Io::ReadArrayLE<float>(MvlVertices.data(), stream, MvlVerticesCount * 5);
+    std::vector<float> mvlVertexInfo(vertexCount * 5);
+    Io::ReadArrayLE<float>(mvlVertexInfo.data(), stream, vertexCount * 5);
+
+    MvlVertices.resize(vertexCount);
+    for (size_t i = 0; i < vertexCount; i++) {
+      MvlVertices[i] = VertexBufferSprites{
+          .Position = {mvlVertexInfo[i * 5], mvlVertexInfo[i * 5 + 1]},
+          .UV = glm::vec2(mvlVertexInfo[i * 5 + 3], mvlVertexInfo[i * 5 + 4]),
+          .Tint = Tint,
+      };
+    }
+
     delete stream;
   } else {
     // LAY format
@@ -146,7 +156,7 @@ void Character2D::UnloadSync() {
   Show = false;
   std::fill(Layers.begin(), Layers.end(), -1);
   MvlVertices.clear();
-  MvlIndicesCount = 0;
+  MvlIndices.clear();
   States.clear();
   StatesToDraw.clear();
 }
@@ -165,7 +175,7 @@ void Character2D::MainThreadOnLoad() {
 
 void Character2D::Update(float dt) {
   if (Profile::CharaIsMvl) {
-    MvlIndicesCount = 0;
+    MvlIndices.clear();
     StatesToDraw.clear();
     StatesToDraw.push_back((Face & 0xFFFF0000) >> 16);  // face
     StatesToDraw.push_back(0x40000000 | ((Face & 0xFFFF0000) >> 8) |
@@ -178,9 +188,8 @@ void Character2D::Update(float dt) {
         Character2DState const& state = stateItr->second;
         auto& stateIndices =
             std::get_if<Character2DState::MVLData>(&state.Data)->Indices;
-        std::copy(stateIndices.get(), stateIndices.get() + state.Count,
-                  MvlIndices.begin() + MvlIndicesCount);
-        MvlIndicesCount += state.Count;
+        MvlIndices.insert(MvlIndices.end(), stateIndices.get(),
+                          stateIndices.get() + state.Count);
       }
     }
   } else {
@@ -202,10 +211,10 @@ void Character2D::Render(int layer) {
   if (Status != LS_Loaded || !OnLayer(layer) || !Show) return;
 
   if (Profile::CharaIsMvl) {
-    Renderer->DrawCharacterMvl(CharaSprite, glm::vec2(OffsetX, OffsetY),
-                               MvlVerticesCount, MvlVertices.data(),
-                               MvlIndicesCount, MvlIndices.data(), false, Tint,
-                               glm::vec2(ScaleX, ScaleY));
+    const glm::mat4 transformation = TransformationMatrix(
+        {0.0f, 0.0f}, {ScaleX, ScaleY}, {0.0f, 0.0f}, 0.0f, {OffsetX, OffsetY});
+    Renderer->DrawVertices(CharaSpriteSheet, MvlVertices, MvlIndices,
+                           transformation);
   } else {
     for (auto id : StatesToDraw) {
       if (auto stateItr = States.find(id); stateItr != States.end()) {

src/character2d.h

@@ -45,8 +45,6 @@ struct Character2DState {
   }
 };
 
-int constexpr MaxMvlIndices = 128 * 1024;
-
 class Character2D : public Loadable<Character2D> {
   friend class Loadable<Character2D>;
 
@@ -86,10 +84,8 @@ class Character2D : public Loadable<Character2D> {
   ankerl::unordered_dense::map<int, Character2DState> States;
   std::vector<int> StatesToDraw;
 
-  int MvlVerticesCount;
-  std::vector<float> MvlVertices;
-  std::array<uint16_t, MaxMvlIndices> MvlIndices;
-  int MvlIndicesCount;
+  std::vector<VertexBufferSprites> MvlVertices;
+  std::vector<uint16_t> MvlIndices;
 };
 
 int constexpr MaxCharacters2D = 16;

src/game.cpp

@@ -370,7 +370,7 @@ static void RenderMain() {
         }
         glm::vec4 col = ScrWorkGetColor(SW_MASK1COLOR);
         col.a = glm::min(maskAlpha / 255.0f, 1.0f);
-        Renderer->DrawRect(RectF(maskPosX, maskPosY, maskSizeX, maskSizeY),
+        Renderer->DrawQuad(RectF(maskPosX, maskPosY, maskSizeX, maskSizeY),
                            col);
       }
     }
@@ -522,7 +522,7 @@ void Render() {
           break;
         }
         case DrawComponentType::Mask: {
-          Renderer->DrawRect(
+          Renderer->DrawQuad(
               RectF(0.0f, 0.0f, Profile::DesignWidth, Profile::DesignHeight),
               glm::vec4(0.0f, 0.0f, 0.0f, (ScrWork[SW_RESTARTMASK] / 256.0f)));
           break;

src/games/cc/dialoguebox.cpp

@@ -41,7 +41,7 @@ void DialogueBox::Render(DialoguePageMode mode, bool hasName, float nameWidth,
     }
   } else {
     glm::vec4 nvlBoxTint(0.0f, 0.0f, 0.0f, opacity * NVLBoxMaxOpacity);
-    Renderer->DrawRect(RectF(0, 0, Profile::DesignWidth, Profile::DesignHeight),
+    Renderer->DrawQuad(RectF(0, 0, Profile::DesignWidth, Profile::DesignHeight),
                        nvlBoxTint);
   }
 }

src/games/cc/titlemenu.cpp

@@ -252,7 +252,7 @@ void TitleMenu::Render() {
             OverlaySprite,
             RectF(0.0f, 0.0f, Profile::DesignWidth, Profile::DesignHeight));
         DrawSmoke(SmokeOpacityNormal);
-        Renderer->DrawRect(
+        Renderer->DrawQuad(
             RectF(0.0f, 0.0f, Profile::DesignWidth, Profile::DesignHeight),
             glm::vec4(1.0f, 1.0f, 1.0f,
                       1.0f - ScrWork[SW_TITLEDISPCT] / 60.0f));