lod, prim refactor

ROADMAP.txt

@@ -1,4 +1,5 @@
 ------------ Tyra's v2.0 roadmap to publish on GitHub ------------
+- [Renderer] Test clipper
 - [Renderer] Fog
 - [Demo] Create cool demo which will show all features of Tyra
 - [General] CI in Github via docker image

demo/inc/states/intro/states/intro_press_key_state.hpp

@@ -45,6 +45,7 @@ class IntroPressKeyState : public State<IntroStateType> {
   bool _wantFinish;
   bool initialized;
 
+  constexpr static float textureWidthHeight = 512.0F;
   const static u8 mapRows = 3;
   const static u8 mapCols = 3;
 

demo/src/states/intro/states/intro_press_key_state.cpp

@@ -19,6 +19,7 @@
 using Tyra::FileUtils;
 using Tyra::Math;
 using Tyra::PngLoader;
+using Tyra::SpriteMode;
 using Tyra::Threading;
 
 namespace Demo {
@@ -44,8 +45,10 @@ void IntroPressKeyState::onStart() {
   for (u8 i = 0; i < mapRows; i++) {
     for (u8 j = 0; j < mapCols; j++) {
       mapSprites[i][j] = new Sprite;
-      mapSprites[i][j]->size.set(512.0F, 512.0F);
+      mapSprites[i][j]->setMode(SpriteMode::MODE_STRETCH);
-      mapSprites[i][j]->position.set(i * 512.0F, j * 512.0F);
+      mapSprites[i][j]->size.set(textureWidthHeight, textureWidthHeight);
+      mapSprites[i][j]->position.set(i * textureWidthHeight,
+                                     j * textureWidthHeight);
 
       std::string filename =
           "map-" + std::to_string(i) + "-" + std::to_string(j);
@@ -63,18 +66,20 @@ void IntroPressKeyState::onStart() {
 void IntroPressKeyState::update() {
   engine->renderer.beginFrame();
 
-  if (mapDirection == 0 && mapPosition.x >= 512.0F * (mapRows - 1) &&
+  if (mapDirection == 0 &&
-      mapPosition.y >= 512.0F * (mapCols - 1)) {
+      mapPosition.x >= textureWidthHeight * (mapRows - 1) &&
+      mapPosition.y >= textureWidthHeight * (mapCols - 1)) {
     mapDirection = 1;
   } else if (mapDirection == 1 && mapPosition.x <= 0.0F &&
              mapPosition.y <= 0.0F) {
     mapDirection = 0;
   }
 
+  const float offset = 0.1F;
   if (mapDirection == 0) {
-    mapPosition += .5F;
+    mapPosition += offset;
   } else if (mapDirection == 1) {
-    mapPosition -= .5F;
+    mapPosition -= offset;
   }
 
   updateMap();
@@ -92,8 +97,8 @@ IntroStateType IntroPressKeyState::onFinish() { return STATE_INTRO_END; }
 void IntroPressKeyState::updateMap() {
   for (u8 i = 0; i < mapRows; i++)
     for (u8 j = 0; j < mapCols; j++) {
-      mapSprites[i][j]->position.x = i * 512.0F - mapPosition.x;
+      mapSprites[i][j]->position.x = i * textureWidthHeight - mapPosition.x;
-      mapSprites[i][j]->position.y = j * 512.0F - mapPosition.y;
+      mapSprites[i][j]->position.y = j * textureWidthHeight - mapPosition.y;
     }
 }
 }  // namespace Demo

engine/inc/renderer/3d/pipeline/dynamic/core/dynpip_core.hpp

@@ -58,6 +58,12 @@ class DynPipCore {
   void deallocateOnUse() { qbufferRenderer.deallocateOnUse(); }
 
  private:
+  void setPrim();
+  void setLod();
+
+  prim_t prim;
+  lod_t lod;
+
   M4x4 mvp;
   RendererCore* rendererCore;
   DynPipRenderer qbufferRenderer;

engine/inc/renderer/3d/pipeline/dynamic/core/dynpip_renderer.hpp

@@ -21,7 +21,8 @@ class DynPipRenderer {
   DynPipRenderer();
   ~DynPipRenderer();
 
-  void init(RendererCore* t_core, DynPipProgramsRepository* t_programRepo);
+  void init(RendererCore* t_core, DynPipProgramsRepository* t_programRepo,
+            prim_t* prim, lod_t* lod);
 
   void reinitVU1();
 
@@ -47,6 +48,9 @@ class DynPipRenderer {
                              const u32& count);
   void sendPacket();
 
+  prim_t* prim;
+  lod_t* lod;
+
   packet2_t* packets[2];
   packet2_t* programsPacket;
   packet2_t* currentPacket;

engine/inc/renderer/3d/pipeline/minecraft/minecraft_pipeline.hpp

@@ -54,6 +54,12 @@ class MinecraftPipeline : public Renderer3DPipeline {
   const McpipBlockData& getBlockData() const { return manager.getBlockData(); }
 
  private:
+  void setPrim();
+  void setLod();
+
+  prim_t prim;
+  lod_t lod;
+
   BlockizerProgramsManager manager;
   RendererCore* rendererCore;
   RenderBBox* bbox;

engine/inc/renderer/3d/pipeline/minecraft/programs/as_is/mcpip_clip.hpp

@@ -31,7 +31,7 @@ class McpipClip {
   EEClipAlgorithmSettings algoSettings;
 
   void init(RendererCore* core, McpipBlockData* t_singleBlockData,
-            McpipBlockData* t_multiBlockData);
+            McpipBlockData* t_multiBlockData, prim_t* prim, lod_t* lod);
 
   u32 uploadVU1Program(McpipProgramsRepository* repo, const u32& addr);
 
@@ -42,6 +42,9 @@ class McpipClip {
                const u8& context);
 
  private:
+  prim_t* prim;
+  lod_t* lod;
+
   RendererCore* rendererCore;
   McpipBlockData* singleBlockData;
   McpipBlockData* multiBlockData;

engine/inc/renderer/3d/pipeline/minecraft/programs/cull/mcpip_cull.hpp

@@ -26,7 +26,8 @@ class McpipCull {
   McpipCull();
   ~McpipCull();
 
-  void init(RendererCore* core, McpipBlockData* t_blockData);
+  void init(RendererCore* core, McpipBlockData* t_blockData, prim_t* prim,
+            lod_t* lod);
 
   u32 uploadVU1Program(McpipProgramsRepository* repo, const u32& addr);
 
@@ -39,6 +40,8 @@ class McpipCull {
                RendererCoreTextureBuffers* texBuffers, bool isMulti);
 
  private:
+  prim_t* prim;
+  lod_t* lod;
   RendererCore* rendererCore;
   u16 vu1DBufferSize;
   McpipBlockData* blockData;

engine/inc/renderer/3d/pipeline/minecraft/programs/mcpip_programs_manager.hpp

@@ -36,7 +36,7 @@ class BlockizerProgramsManager {
   McpipCull culler;
   McpipClip clipper;
 
-  void init(RendererCore* core);
+  void init(RendererCore* core, prim_t* prim, lod_t* lod);
 
   void uploadVU1Programs();
 

engine/inc/renderer/3d/pipeline/static/core/stapip_core.hpp

@@ -51,6 +51,12 @@ class StaPipCore {
   void deallocateOnUse() { qbufferRenderer.deallocateOnUse(); }
 
  private:
+  void setPrim();
+  void setLod();
+
+  prim_t prim;
+  lod_t lod;
+
   u32 maxVertCount;
   RendererCore* rendererCore;
 

engine/inc/renderer/3d/pipeline/static/core/stapip_qbuffer_renderer.hpp

@@ -33,7 +33,7 @@ class StaPipQBufferRenderer {
   StaPipQBufferRenderer();
   ~StaPipQBufferRenderer();
 
-  void init(RendererCore* t_core);
+  void init(RendererCore* t_core, prim_t* prim, lod_t* lod);
 
   void reinitVU1();
 
@@ -69,6 +69,9 @@ class StaPipQBufferRenderer {
   void deallocateOnUse();
 
  private:
+  prim_t* prim;
+  lod_t* lod;
+
   bool is1stDBufferFlushTime();
   bool is2ndDBufferFlushTime();
 

engine/inc/renderer/core/2d/renderer_core_2d.hpp

@@ -31,6 +31,12 @@ class RendererCore2D {
               Texture* texture);
 
  private:
+  void setPrim();
+  void setLod();
+
+  prim_t prim;
+  lod_t lod;
+
   static const float GS_CENTER;
   static const float SCREEN_CENTER;
 

engine/inc/renderer/core/gs/renderer_core_gs.hpp

@@ -20,8 +20,6 @@ class RendererCoreGS {
   RendererCoreGS();
   ~RendererCoreGS();
 
-  prim_t prim;
-  lod_t lod;
   zbuffer_t zBuffer;
   RendererCoreGSVRam vram;
 
@@ -41,8 +39,6 @@ class RendererCoreGS {
 
   void allocateBuffers();
   void initDrawingEnvironment();
-  void setPrim();
-  void setLod();
   void initChannels();
   void updateCurrentField();
   qword_t* setXYOffset(qword_t* q, const int& drawContext, const float& x,

engine/src/renderer/3d/pipeline/dynamic/core/dynpip_core.cpp

@@ -15,13 +15,37 @@
 
 namespace Tyra {
 
-DynPipCore::DynPipCore() {}
+DynPipCore::DynPipCore() {
+  setPrim();
+  setLod();
+}
 
 DynPipCore::~DynPipCore() {}
 
 void DynPipCore::init(RendererCore* t_core) {
   rendererCore = t_core;
-  qbufferRenderer.init(t_core, &repository);
+  qbufferRenderer.init(t_core, &repository, &prim, &lod);
+}
+
+void DynPipCore::setPrim() {
+  prim.type = PRIM_TRIANGLE;
+  prim.shading = PRIM_SHADE_GOURAUD;
+  prim.mapping = DRAW_ENABLE;
+  prim.fogging = DRAW_DISABLE;
+  prim.blending = DRAW_ENABLE;
+  prim.antialiasing = DRAW_DISABLE;
+  prim.mapping_type = PRIM_MAP_ST;
+  prim.colorfix = PRIM_UNFIXED;
+}
+
+void DynPipCore::setLod() {
+  lod.calculation = LOD_USE_K;
+  lod.max_level = 0;
+  lod.mag_filter = LOD_MAG_NEAREST;
+  lod.min_filter = LOD_MIN_NEAREST;
+  lod.mipmap_select = LOD_MIPMAP_REGISTER;
+  lod.l = 0;
+  lod.k = 0.0F;
 }
 
 void DynPipCore::reinitVU1Programs() { qbufferRenderer.reinitVU1(); }

engine/src/renderer/3d/pipeline/dynamic/core/dynpip_renderer.cpp

@@ -45,8 +45,11 @@ void DynPipRenderer::deallocateOnUse() {
 }
 
 void DynPipRenderer::init(RendererCore* t_core,
-                          DynPipProgramsRepository* t_programRepo) {
+                          DynPipProgramsRepository* t_programRepo,
+                          prim_t* t_prim, lod_t* t_lod) {
   path1 = t_core->getPath1();
+  prim = t_prim;
+  lod = t_lod;
   rendererCore = t_core;
   programsRepo = t_programRepo;
 
@@ -122,7 +125,7 @@ void DynPipRenderer::sendObjectData(
     packet2_add_u32(objectDataPacket, 0);   // not used, padding
     packet2_add_u32(objectDataPacket, 0);   // not used, padding
 
-    packet2_utils_gs_add_lod(objectDataPacket, &rendererCore->gs.lod);
+    packet2_utils_gs_add_lod(objectDataPacket, lod);
 
     if (texBuffers != nullptr) {
       rendererCore->texture.updateClutBuffer(texBuffers->clut);
@@ -154,8 +157,7 @@ void DynPipRenderer::addBufferDataToPacket(DynPipVU1Program* program,
   for (u32 i = 0; i < count; i++) {
     if (bags[i]->count <= 0) continue;
 
-    program->addBufferDataToPacket(currentPacket, bags[i],
+    program->addBufferDataToPacket(currentPacket, bags[i], prim);
-                                   &rendererCore->gs.prim);
 
     if (lastProgramName != program->getName()) {
       packet2_utils_vu_add_start_program(currentPacket,

engine/src/renderer/3d/pipeline/minecraft/minecraft_pipeline.cpp

@@ -18,6 +18,8 @@ MinecraftPipeline::MinecraftPipeline() {
   latestMode = UndefinedMcpipProgram;
   spamBuffersCount = 4;
   spammerIndex = 0;
+  setPrim();
+  setLod();
 }
 
 MinecraftPipeline::~MinecraftPipeline() {
@@ -29,11 +31,32 @@ MinecraftPipeline::~MinecraftPipeline() {
 
 void MinecraftPipeline::setRenderer(RendererCore* core) {
   rendererCore = core;
-  manager.init(core);
+  manager.init(core, &prim, &lod);
 
   initBBox();
 }
 
+void MinecraftPipeline::setPrim() {
+  prim.type = PRIM_TRIANGLE;
+  prim.shading = PRIM_SHADE_FLAT;
+  prim.mapping = DRAW_ENABLE;
+  prim.fogging = DRAW_DISABLE;
+  prim.blending = DRAW_ENABLE;
+  prim.antialiasing = DRAW_DISABLE;
+  prim.mapping_type = PRIM_MAP_ST;
+  prim.colorfix = PRIM_UNFIXED;
+}
+
+void MinecraftPipeline::setLod() {
+  lod.calculation = LOD_USE_K;
+  lod.max_level = 0;
+  lod.mag_filter = LOD_MAG_NEAREST;
+  lod.min_filter = LOD_MIN_NEAREST;
+  lod.mipmap_select = LOD_MIPMAP_REGISTER;
+  lod.l = 0;
+  lod.k = 0.0F;
+}
+
 void MinecraftPipeline::onUse() {
   spamBuffers = new McpipBlock**[spamBuffersCount];
   spamCounts = new u32[spamBuffersCount];
@@ -59,7 +82,6 @@ void MinecraftPipeline::render(McpipBlock* blocks, const u32& count,
                                Texture* t_tex, const bool& isMulti,
                                const bool& fullClipChecks) {
   auto texBuffers = rendererCore->texture.useTexture(t_tex);
-  rendererCore->gs.prim.mapping = 1;
 
   manager.clearLastProgram();
   std::vector<u32> cullIndexes;

engine/src/renderer/3d/pipeline/minecraft/programs/as_is/mcpip_clip.cpp

@@ -22,7 +22,10 @@ McpipClip::McpipClip() {
 McpipClip::~McpipClip() { packet2_free(staticPacket); }
 
 void McpipClip::init(RendererCore* core, McpipBlockData* t_singleBlockData,
-                     McpipBlockData* t_multiBlockData) {
+                     McpipBlockData* t_multiBlockData, prim_t* t_prim,
+                     lod_t* t_lod) {
+  prim = t_prim;
+  lod = t_lod;
   singleBlockData = t_singleBlockData;
   multiBlockData = t_multiBlockData;
   rendererCore = core;
@@ -46,7 +49,7 @@ void McpipClip::configureVU1AndSendStaticData() {
 void McpipClip::initStaticPacket() {
   packet2_utils_vu_open_unpack(staticPacket, VU1_MCPIP_AS_IS_STATIC_LOD, false);
   {
-    packet2_utils_gs_add_lod(staticPacket, &rendererCore->gs.lod);
+    packet2_utils_gs_add_lod(staticPacket, lod);
     packet2_utils_gif_add_set(staticPacket, 1);
   }
   packet2_utils_vu_close_unpack(staticPacket);
@@ -120,7 +123,7 @@ void McpipClip::addDataToPacket(packet2_t* packet, const u8& context,
                       static_cast<float>(0xFFFFFF) / 32.0F);  // scale
     packet2_add_s32(packet, count);                           // vertex count
 
-    packet2_utils_gs_add_prim_giftag(packet, &rendererCore->gs.prim, count,
+    packet2_utils_gs_add_prim_giftag(packet, prim, count,
                                      ((u64)GIF_REG_ST) << 0 |
                                          ((u64)GIF_REG_RGBAQ) << 4 |
                                          ((u64)GIF_REG_XYZ2) << 8,

engine/src/renderer/3d/pipeline/minecraft/programs/cull/mcpip_cull.cpp

@@ -18,7 +18,10 @@ McpipCull::McpipCull() {
 
 McpipCull::~McpipCull() { packet2_free(staticPacket); }
 
-void McpipCull::init(RendererCore* core, McpipBlockData* t_blockData) {
+void McpipCull::init(RendererCore* core, McpipBlockData* t_blockData,
+                     prim_t* t_prim, lod_t* t_lod) {
+  prim = t_prim;
+  lod = t_lod;
   blockData = t_blockData;
   rendererCore = core;
   initStaticPacket();
@@ -79,9 +82,9 @@ u32 McpipCull::getMaxBlocksCountPerQBuffer() const {
 void McpipCull::initStaticPacket() {
   packet2_utils_vu_open_unpack(staticPacket, VU1_MCPIP_CULL_STATIC_LOD, false);
   {
-    packet2_utils_gs_add_lod(staticPacket, &rendererCore->gs.lod);
+    packet2_utils_gs_add_lod(staticPacket, lod);
 
-    packet2_utils_gs_add_prim_giftag(staticPacket, &rendererCore->gs.prim, 36,
+    packet2_utils_gs_add_prim_giftag(staticPacket, prim, 36,
                                      ((u64)GIF_REG_ST) << 0 |
                                          ((u64)GIF_REG_RGBAQ) << 4 |
                                          ((u64)GIF_REG_XYZ2) << 8,

engine/src/renderer/3d/pipeline/minecraft/programs/mcpip_programs_manager.cpp

@@ -36,10 +36,11 @@ BlockizerProgramsManager::~BlockizerProgramsManager() {
   packet2_free(programsPacket);
 }
 
-void BlockizerProgramsManager::init(RendererCore* core) {
+void BlockizerProgramsManager::init(RendererCore* core, prim_t* prim,
+                                    lod_t* lod) {
   rendererCore = core;
-  culler.init(core, &singleTexBlockData);
+  culler.init(core, &singleTexBlockData, prim, lod);
-  clipper.init(core, &singleTexBlockData, &multiTexBlockData);
+  clipper.init(core, &singleTexBlockData, &multiTexBlockData, prim, lod);
 }
 
 void BlockizerProgramsManager::setProgramsCache() {

engine/src/renderer/3d/pipeline/static/core/stapip_core.cpp

@@ -22,16 +22,41 @@
 
 namespace Tyra {
 
-StaPipCore::StaPipCore() { maxVertCount = 0; }
+StaPipCore::StaPipCore() {
+  maxVertCount = 0;
+  setPrim();
+  setLod();
+}
 
 StaPipCore::~StaPipCore() {}
 
 void StaPipCore::init(RendererCore* t_core) {
   rendererCore = t_core;
-  qbufferRenderer.init(t_core);
+  qbufferRenderer.init(t_core, &prim, &lod);
   packager.init(&rendererCore->renderer3D.frustumPlanes);
 }
 
+void StaPipCore::setPrim() {
+  prim.type = PRIM_TRIANGLE;
+  prim.shading = PRIM_SHADE_GOURAUD;
+  prim.mapping = DRAW_ENABLE;
+  prim.fogging = DRAW_DISABLE;
+  prim.blending = DRAW_ENABLE;
+  prim.antialiasing = DRAW_DISABLE;
+  prim.mapping_type = PRIM_MAP_ST;
+  prim.colorfix = PRIM_UNFIXED;
+}
+
+void StaPipCore::setLod() {
+  lod.calculation = LOD_USE_K;
+  lod.max_level = 0;
+  lod.mag_filter = LOD_MAG_NEAREST;
+  lod.min_filter = LOD_MIN_NEAREST;
+  lod.mipmap_select = LOD_MIPMAP_REGISTER;
+  lod.l = 0;
+  lod.k = 0.0F;
+}
+
 void StaPipCore::reinitVU1Programs() { qbufferRenderer.reinitVU1(); }
 
 u32 StaPipCore::getMaxVertCountByBag(const StaPipBag* bag) {

engine/src/renderer/3d/pipeline/static/core/stapip_qbuffer_renderer.cpp

@@ -82,10 +82,13 @@ StaPipQBufferRenderer::~StaPipQBufferRenderer() {
   if (programsPacket) packet2_free(programsPacket);
 }
 
-void StaPipQBufferRenderer::init(RendererCore* t_core) {
+void StaPipQBufferRenderer::init(RendererCore* t_core, prim_t* t_prim,
+                                 lod_t* t_lod) {
   path1 = t_core->getPath1();
   clipper.init(t_core->getSettings());
   rendererCore = t_core;
+  prim = t_prim;
+  lod = t_lod;
 
   dma_channel_initialize(DMA_CHANNEL_VIF1, NULL, 0);
   dma_channel_fast_waits(DMA_CHANNEL_VIF1);
@@ -136,7 +139,7 @@ void StaPipQBufferRenderer::sendObjectData(
     packet2_add_u32(objectDataPacket, 0);  // not used, padding
     packet2_add_u32(objectDataPacket, 0);  // not used, padding
 
-    packet2_utils_gs_add_lod(objectDataPacket, &rendererCore->gs.lod);
+    packet2_utils_gs_add_lod(objectDataPacket, lod);
 
     if (texBuffers != nullptr) {
       rendererCore->texture.updateClutBuffer(texBuffers->clut);
@@ -153,9 +156,9 @@ void StaPipQBufferRenderer::sendObjectData(
 }
 
 void StaPipQBufferRenderer::setInfo(PipelineInfoBag* bag) {
-  rendererCore->gs.prim.antialiasing = bag->antiAliasingEnabled;
+  prim->antialiasing = bag->antiAliasingEnabled;
-  rendererCore->gs.prim.blending = bag->blendingEnabled;
+  prim->blending = bag->blendingEnabled;
-  rendererCore->gs.prim.shading = bag->shadingType;
+  prim->shading = bag->shadingType;
 }
 
 void StaPipQBufferRenderer::sendStaticData() const {
@@ -286,8 +289,7 @@ void StaPipQBufferRenderer::addBufferDataToPacket(StaPipQBuffer** buffers,
   for (u32 i = 0; i < count; i++) {
     if (!buffers[i]->any()) continue;
 
-    dBufferPrograms[i]->addBufferDataToPacket(currentPacket, buffers[i],
+    dBufferPrograms[i]->addBufferDataToPacket(currentPacket, buffers[i], prim);
-                                              &rendererCore->gs.prim);
 
     if (lastProgramName != dBufferPrograms[i]->getName()) {
       packet2_utils_vu_add_start_program(

engine/src/renderer/core/2d/renderer_core_2d.cpp

@@ -20,6 +20,9 @@ RendererCore2D::RendererCore2D() {
   packets[1] = packet2_create(16, P2_TYPE_NORMAL, P2_MODE_NORMAL, 0);
   rects[0] = new texrect_t;
   rects[1] = new texrect_t;
+
+  setPrim();
+  setLod();
 }
 
 RendererCore2D::~RendererCore2D() {
@@ -32,6 +35,27 @@ RendererCore2D::~RendererCore2D() {
 const float RendererCore2D::GS_CENTER = 4096.0F;
 const float RendererCore2D::SCREEN_CENTER = 4096.0F / 2.0F;
 
+void RendererCore2D::setPrim() {
+  prim.type = PRIM_TRIANGLE;
+  prim.shading = PRIM_SHADE_GOURAUD;
+  prim.mapping = DRAW_ENABLE;
+  prim.fogging = DRAW_DISABLE;
+  prim.blending = DRAW_ENABLE;
+  prim.antialiasing = DRAW_DISABLE;
+  prim.mapping_type = PRIM_MAP_ST;
+  prim.colorfix = PRIM_UNFIXED;
+}
+
+void RendererCore2D::setLod() {
+  lod.calculation = LOD_USE_K;
+  lod.max_level = 0;
+  lod.mag_filter = LOD_MAG_LINEAR;
+  lod.min_filter = LOD_MIN_LINEAR;
+  lod.mipmap_select = LOD_MIPMAP_REGISTER;
+  lod.l = 0;
+  lod.k = 0.0F;
+}
+
 void RendererCore2D::init(RendererSettings* t_settings,
                           clutbuffer_t* t_clutBuffer) {
   settings = t_settings;
@@ -86,10 +110,14 @@ void RendererCore2D::render(Sprite* sprite,
   packet2_reset(packet, false);
   packet2_update(packet, draw_primitive_xyoffset(packet->base, 0, SCREEN_CENTER,
                                                  SCREEN_CENTER));
+
+  packet2_utils_gif_add_set(packet, 1);
+  packet2_utils_gs_add_lod(packet, &lod);
   packet2_utils_gif_add_set(packet, 1);
   packet2_utils_gs_add_texbuff_clut(packet, texBuffers.core, clutBuffer);
   draw_enable_blending();
   packet2_update(packet, draw_rect_textured(packet->next, 0, rect));
+
   packet2_update(packet, draw_primitive_xyoffset(
                              packet->next, 0,
                              SCREEN_CENTER - (settings->getWidth() / 2.0F),

engine/src/renderer/core/gs/renderer_core_gs.cpp

@@ -27,6 +27,7 @@ RendererCoreGS::RendererCoreGS() {
   context = 0;
   currentField = 0;
 }
+
 RendererCoreGS::~RendererCoreGS() {
   if (flipPacket) {
     packet2_free(flipPacket);
@@ -40,8 +41,6 @@ void RendererCoreGS::init(RendererSettings* t_settings) {
   flipPacket = packet2_create(4, P2_TYPE_UNCACHED_ACCL, P2_MODE_NORMAL, 0);
   allocateBuffers();
   initDrawingEnvironment();
-  setPrim();
-  setLod();
 
   TYRA_LOG("Renderer core initialized!");
 }
@@ -104,28 +103,6 @@ void RendererCoreGS::initDrawingEnvironment() {
   TYRA_LOG("Drawing environment initialized!");
 }
 
-void RendererCoreGS::setPrim() {
-  prim.type = PRIM_TRIANGLE;
-  prim.shading = PRIM_SHADE_GOURAUD;
-  prim.mapping = DRAW_ENABLE;
-  prim.fogging = DRAW_DISABLE;
-  prim.blending = DRAW_ENABLE;
-  prim.antialiasing = DRAW_DISABLE;
-  prim.mapping_type = PRIM_MAP_ST;
-  prim.colorfix = PRIM_UNFIXED;
-  TYRA_LOG("Prim set!");
-}
-
-void RendererCoreGS::setLod() {
-  lod.calculation = LOD_USE_K;
-  lod.max_level = 0;
-  lod.mag_filter = LOD_MAG_NEAREST;
-  lod.min_filter = LOD_MIN_NEAREST;
-  lod.l = 0;
-  lod.k = 0.0F;
-  TYRA_LOG("Lod set!");
-}
-
 qword_t* RendererCoreGS::setXYOffset(qword_t* q, const int& drawContext,
                                      const float& x, const float& y) {
   PACK_GIFTAG(q, GIF_SET_TAG(1, 0, 0, 0, GIF_FLG_PACKED, 1), GIF_REG_AD);