disable interlacing and texture cache manager

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

@@ -28,24 +28,31 @@ class RendererCoreGS {
   void flipBuffers();
 
   float getVRamFreeSpaceInMB() const {
-    return 4.0F - spaceOccupiedByFrameBuffers - spaceOccupiedByZBuffer;
+    return 4.0F - spaceOccupiedByFrameBuffers - spaceOccupiedByZBuffer -
+           vramMargin;
   }
 
  private:
   constexpr static float gsCenter = 4096.0F;
   constexpr static float screenCenter = gsCenter / 2.0F;
+  constexpr static float vramMargin =
+      0.003F;  // We don't have perfectly 4MB of VRAM
 
   float spaceOccupiedByFrameBuffers, spaceOccupiedByZBuffer;
   RendererSettings* settings;
   framebuffer_t frameBuffers[2];
   packet2_t* flipPacket;
   u8 context;
+  u8 currentField;
 
   void allocateBuffers();
   void initDrawingEnvironment();
   void setPrim();
   void setLod();
   void initChannels();
+  void updateCurrentField();
+  qword_t* setXYOffset(qword_t* q, const int& drawContext, const float& x,
+                       const float& y);
 };
 
 }  // namespace Tyra

engine/inc/renderer/renderer_settings.hpp

@@ -18,7 +18,7 @@ namespace Tyra {
 class RendererSettings {
  public:
   RendererSettings()
-      : width(640.0F),
+      : width(512.0F),
         height(448.0F),
         interlacedHeightF(height / 2),
         near(0.1F),

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

@@ -72,12 +72,13 @@ void RendererCore2D::render(Sprite* sprite,
   rect->color.q = 0;
 
   rect->v0.x = sprite->position.x;
-  rect->v0.y = sprite->position.y / 2.0F;  // interlacing
+  rect->v0.y = sprite->position.y;
+  // rect->v0.y /= 2.0F;  // interlacing
   rect->v0.z = (u32)-1;
 
   rect->v1.x = (sprite->size.x * sprite->scale) + sprite->position.x;
   rect->v1.y = (sprite->size.y * sprite->scale) + sprite->position.y;
-  rect->v1.y /= 2.0F;  // interlacing
+  // rect->v1.y /= 2.0F;  // interlacing
   rect->v1.z = (u32)-1;
 
   auto* packet = packets[context];
@@ -89,11 +90,10 @@ void RendererCore2D::render(Sprite* sprite,
   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(
+  packet2_update(packet, draw_primitive_xyoffset(
-      packet,
+                             packet->next, 0,
-      draw_primitive_xyoffset(
+                             SCREEN_CENTER - (settings->getWidth() / 2.0F),
-          packet->next, 0, SCREEN_CENTER - (settings->getWidth() / 2.0F),
+                             SCREEN_CENTER - (settings->getHeight() / 2.0F)));
-          SCREEN_CENTER - (settings->getInterlacedHeightF() / 2.0F)));
   draw_disable_blending();
   packet2_update(packet, draw_finish(packet->next));
 

engine/src/renderer/core/3d/renderer_core_3d.cpp

@@ -37,7 +37,7 @@ void RendererCore3D::setFov(const float& t_fov) {
 
 void RendererCore3D::setProjection() {
   projection = M4x4::perspective(
-      fov, settings->getWidth(), settings->getInterlacedHeightF(),
+      fov, settings->getWidth(), settings->getHeight(),
       settings->getProjectionScale(), settings->getAspectRatio(),
       settings->getNear(), settings->getFar());
 }

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

@@ -27,6 +27,7 @@ RendererCoreGS::RendererCoreGS() {
   context = 0;
   spaceOccupiedByFrameBuffers = 0;
   spaceOccupiedByZBuffer = 0;
+  currentField = 0;
 }
 RendererCoreGS::~RendererCoreGS() {
   if (flipPacket) {
@@ -52,11 +53,10 @@ void RendererCoreGS::initChannels() {
 }
 
 void RendererCoreGS::allocateBuffers() {
-  const u16 psm = 32;
-
   frameBuffers[0].width = static_cast<unsigned int>(settings->getWidth());
-  frameBuffers[0].height = settings->getInterlacedHeightUI();
+  frameBuffers[0].height = static_cast<unsigned int>(settings->getHeight());
   frameBuffers[0].mask = 0;
+  const u16 fpsm = 32;
   frameBuffers[0].psm = GS_PSM_32;
   frameBuffers[0].address =
       graph_vram_allocate(frameBuffers[0].width, frameBuffers[0].height,
@@ -73,26 +73,35 @@ void RendererCoreGS::allocateBuffers() {
   zBuffer.enable = DRAW_ENABLE;
   zBuffer.mask = 0;
   zBuffer.method = ZTEST_METHOD_GREATER_EQUAL;
+  const u16 zpsm = 32;
   zBuffer.zsm = GS_ZBUF_32;
   zBuffer.address =
       graph_vram_allocate(frameBuffers[0].width, frameBuffers[0].height,
                           zBuffer.zsm, GRAPH_ALIGN_PAGE);
 
-  graph_set_mode(GRAPH_MODE_INTERLACED, GRAPH_MODE_NTSC, GRAPH_MODE_FRAME,
+  graph_initialize(frameBuffers[1].address, frameBuffers[1].width,
-                 GRAPH_ENABLE);
+                   frameBuffers[1].height, frameBuffers[1].psm, 0, 0);
-  graph_set_screen(0, 0, static_cast<int>(settings->getWidth()),
+
-                   static_cast<int>(settings->getHeight()));
+  // Interlacing tests
-  graph_set_bgcolor(0, 0, 0);
+  // graph_set_mode(GRAPH_MODE_INTERLACED, GRAPH_MODE_NTSC, GRAPH_MODE_FRAME,
-  graph_set_framebuffer_filtered(frameBuffers[1].address, frameBuffers[1].width,
+  //                GRAPH_ENABLE);
-                                 frameBuffers[1].psm, 0, 0);
+  // graph_set_screen(0, 0, static_cast<int>(settings->getWidth()),
-  graph_enable_output();
+  //                  static_cast<int>(settings->getHeight()));
+  // graph_set_bgcolor(0, 0, 0);
+  // graph_set_framebuffer_filtered(frameBuffers[1].address,
+  // frameBuffers[1].width,
+  //                                frameBuffers[1].psm, 0, 0);
+  // graph_enable_output();
+
+  spaceOccupiedByZBuffer =
+      ((frameBuffers[0].width / 100.0F) * (frameBuffers[0].height / 100.0F) *
+       (zpsm / 100.0F)) /
+      8.0F;
 
   spaceOccupiedByFrameBuffers =
       ((frameBuffers[0].width / 100.0F) * (frameBuffers[0].height / 100.0F) *
-       (psm / 100.0F)) /
+       (fpsm / 100.0F)) /
       8.0F;
-
-  spaceOccupiedByZBuffer = spaceOccupiedByFrameBuffers;
   spaceOccupiedByFrameBuffers *= 2;
 
   TYRA_LOG("Framebuffers, zBuffer set and allocated!");
@@ -102,11 +111,10 @@ void RendererCoreGS::initDrawingEnvironment() {
   packet2_t* packet2 = packet2_create(20, P2_TYPE_NORMAL, P2_MODE_NORMAL, 0);
   packet2_update(packet2, draw_setup_environment(packet2->base, 0, frameBuffers,
                                                  &zBuffer));
-  packet2_update(
+  packet2_update(packet2, draw_primitive_xyoffset(
-      packet2,
+                              packet2->next, 0,
-      draw_primitive_xyoffset(
+                              screenCenter - (settings->getWidth() / 2.0F),
-          packet2->next, 0, screenCenter - (settings->getWidth() / 2.0F),
+                              screenCenter - (settings->getHeight() / 2.0F)));
-          screenCenter - (settings->getInterlacedHeightF() / 2.0F)));
   packet2_update(packet2, draw_finish(packet2->next));
   dma_channel_send_packet2(packet2, DMA_CHANNEL_GIF, true);
   dma_channel_wait(DMA_CHANNEL_GIF, 0);
@@ -136,6 +144,22 @@ void RendererCoreGS::setLod() {
   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);
+  q++;
+
+  int yOffset = currentField == GRAPH_FIELD_ODD ? 8 : 0;
+
+  PACK_GIFTAG(q,
+              GS_SET_XYOFFSET(static_cast<int>(x * 16.0F),
+                              static_cast<int>((y * 16.0F + yOffset))),
+              GS_REG_XYOFFSET + drawContext);
+  q++;
+
+  return q;
+}
+
 void RendererCoreGS::flipBuffers() {
   graph_set_framebuffer_filtered(frameBuffers[context].address,
                                  frameBuffers[context].width,
@@ -145,10 +169,29 @@ void RendererCoreGS::flipBuffers() {
 
   packet2_update(flipPacket,
                  draw_framebuffer(flipPacket->base, 0, &frameBuffers[context]));
+  // Interlacing test
+  // packet2_update(
+  //     flipPacket,
+  //     setXYOffset(flipPacket->next, 0,
+  //                 screenCenter - (settings->getWidth() / 2.0F),
+  //                 screenCenter - (settings->getInterlacedHeightF() / 2.0F)));
+
   packet2_update(flipPacket, draw_finish(flipPacket->next));
   dma_channel_wait(DMA_CHANNEL_GIF, 0);
   dma_channel_send_packet2(flipPacket, DMA_CHANNEL_GIF, true);
   draw_wait_finish();
+
+  // Interlacing test
+  // updateCurrentField();
+}
+
+void RendererCoreGS::updateCurrentField() {
+  if (*GS_REG_CSR & (1 << 13)) {
+    currentField = GRAPH_FIELD_ODD;
+    return;
+  }
+
+  currentField = GRAPH_FIELD_EVEN;
 }
 
 }  // namespace Tyra

engine/src/renderer/core/texture/renderer_core_texture.cpp

@@ -39,13 +39,15 @@ void RendererCoreTexture::updateClutBuffer(texbuffer_t* clutBuffer) {
 RendererCoreTextureBuffers RendererCoreTexture::useTexture(Texture* t_tex) {
   TYRA_ASSERT(t_tex != nullptr, "Provided nullptr texture!");
 
-  cacheManager.addRequestedTexture(t_tex);
+  // cacheManager.addRequestedTexture(t_tex);
 
   auto allocated = getAllocatedBuffersByTextureId(t_tex->getId());
   if (allocated.id != 0) return allocated;
 
-  while (t_tex->getSizeInMB() > sender.getFreeVRamInMB()) {
+  while ((t_tex->getSizeInMB()) > sender.getFreeVRamInMB()) {
-    auto idToDealloc = cacheManager.getTextureIdToDealloc(currentAllocations);
+    // auto idToDealloc =
+    // cacheManager.getTextureIdToDealloc(currentAllocations);
+    auto idToDealloc = currentAllocations.back().id;
     auto buffToDealloc = getAllocatedBuffersByTextureId(idToDealloc);
     sender.deallocate(buffToDealloc);
     unregisterAllocation(idToDealloc);

engine/src/renderer/core/texture/renderer_core_texture_sender.cpp

@@ -49,7 +49,7 @@ void RendererCoreTextureSender::deallocate(
   graph_vram_free(texBuffers.core->address);
   delete texBuffers.core;
 
-  if (texBuffers.clut != nullptr) {
+  if (texBuffers.clut != nullptr && texBuffers.clut->width > 0) {
     graph_vram_free(texBuffers.clut->address);
     delete texBuffers.clut;
   }

tutorials/01-hello/inc/tutorial_01.hpp

@@ -36,7 +36,8 @@ class Tutorial01 : public Game {
   DynamicMesh* warrior;
   u8 warriorsCount;
   DynamicMesh** warriors;
-  Sprite* picture;
+  u32 picturesCount;
+  Sprite** pictures;
   audsrv_adpcm_t* adpcmSample;
   Timer adpcmTimer;
 

tutorials/01-hello/src/tutorial_01.cpp

@@ -57,7 +57,7 @@ void Tutorial01 ::init() {
   warriorTex = engine->renderer.core.texture.repository.getBySpriteOrMesh(
       warrior->getMaterial(0)->getId());
 
-  warriorsCount = 12;
+  warriorsCount = 22;
   warriors = new DynamicMesh*[warriorsCount];
   for (u8 i = 0; i < warriorsCount; i++) {
     warriors[i] = new DynamicMesh(*warrior);
@@ -90,7 +90,10 @@ void Tutorial01 ::init() {
   dynpip.setRenderer(&engine->renderer.core);
   stapip.setRenderer(&engine->renderer.core);
 
-  picture = get2DPicture(&engine->renderer);
+  picturesCount = 1;
+  pictures = new Sprite*[picturesCount];
+  for (u32 i = 0; i < picturesCount; i++)
+    pictures[i] = get2DPicture(&engine->renderer);
 
   u32 rows = 16;     // 64
   u32 columns = 16;  // 64
@@ -149,28 +152,29 @@ void Tutorial01 ::loop() {
       blocks[i].model = translations[i] * rotations[i] * scales[i];
     }
 
-    // engine->renderer.renderer2D.render(picture);
+    for (u32 i = 0; i < picturesCount; i++)
+      engine->renderer.renderer2D.render(pictures[i]);
 
     engine->renderer.renderer3D.usePipeline(&stapip);
     {
-      // stapip.render(staticMesh, staOptions);
+      stapip.render(staticMesh, staOptions);
       stapip.render(skybox, skyboxOptions);
     }
 
-    // engine->renderer.renderer3D.usePipeline(&dynpip);
+    engine->renderer.renderer3D.usePipeline(&dynpip);
-    // {
+    {
-    //   dynpip.render(cube);
+      dynpip.render(cube);
-    //   Threading::switchThread();
+      Threading::switchThread();
-    //   for (u8 i = 0; i < warriorsCount; i++) {
+      for (u8 i = 0; i < warriorsCount; i++) {
-    //     dynpip.render(warriors[i], dynOptions);
+        dynpip.render(warriors[i], dynOptions);
-    //     if (i == 5) Threading::switchThread();
+        if (i == 5) Threading::switchThread();
-    //     if (i == 10) Threading::switchThread();
+        if (i == 10) Threading::switchThread();
-    //     if (i == 15) Threading::switchThread();
+        if (i == 15) Threading::switchThread();
-    //   }
+      }
-    // }
+    }
 
-    // engine->renderer.renderer3D.usePipeline(&mcPip);
+    engine->renderer.renderer3D.usePipeline(&mcPip);
-    // { mcPip.render(blocks, blocksCount, blocksTex); }
+    { mcPip.render(blocks, blocksCount, blocksTex); }
   }
   engine->renderer.endFrame();
 }
@@ -237,7 +241,7 @@ Sprite* get2DPicture(Renderer* renderer) {
   auto* sprite = new Sprite;
 
   sprite->size.set(128.0F, 128.0F);
-  sprite->position.set(500.0F, 280.0F);
+  sprite->position.set(300.0F, 280.0F);
 
   renderer->core.texture.repository.add(FileUtils::fromCwd("reward.png"))
       ->addLink(sprite->getId());