core renderer refactor finish

2022-07-25 20:10:46 +02:00
parent 819a7c3de3
commit 0c63de8ac9
18 changed files with 258 additions and 109 deletions
@@ -40,9 +40,9 @@ void DynamicPipeline::render(DynamicMesh* mesh, const DynPipOptions* options) {
  auto* infoBag = getInfoBag(mesh, options, &model);
  PipelineDirLightsBag* dirLights = nullptr;
  auto frustumCulling =
-      options ? options->frustumCulling : DynPipFrustumCulling_Simple;
+      options ? options->frustumCulling : PipelineFrustumCulling_Simple;

-  if (frustumCulling == DynPipFrustumCulling_Simple) {
+  if (frustumCulling == PipelineFrustumCulling_Simple) {
    auto* frameTo = mesh->getFrame(mesh->getNextAnimationFrame());
    if (frameTo->getBBox().isInFrustum(
            rendererCore->renderer3D.frustumPlanes.getAll(), model) ==
@@ -117,7 +117,7 @@ void DynamicPipeline::render(DynamicMesh* mesh, const DynPipOptions* options) {

 void DynamicPipeline::setBuffer(DynPipBag* buffers, DynPipBag* buffer,
                                u16* bufferIndex,
-                                const DynPipFrustumCulling& frustumCulling) {
+                                const PipelineFrustumCulling& frustumCulling) {
  auto isEndOf1stDBuffer = *bufferIndex == halfBuffersCount - 1;
  auto isEndOf2ndDBuffer = *bufferIndex == buffersCount - 1;

@@ -130,7 +130,7 @@ void DynamicPipeline::setBuffer(DynPipBag* buffers, DynPipBag* buffer,
      sendBuffers[i] = &buffers[offset + i];

    core.renderPart(sendBuffers, halfBuffersCount,
-                    frustumCulling == DynPipFrustumCulling_Precise);
+                    frustumCulling == PipelineFrustumCulling_Precise);

    delete[] sendBuffers;
  }
@@ -143,7 +143,7 @@ void DynamicPipeline::setBuffer(DynPipBag* buffers, DynPipBag* buffer,

 void DynamicPipeline::sendRestOfBuffers(
    DynPipBag* buffers, u16* bufferIndex,
-    const DynPipFrustumCulling& frustumCulling) {
+    const PipelineFrustumCulling& frustumCulling) {
  auto isEndOf1stDBuffer = *bufferIndex <= halfBuffersCount - 1;

  u32 offset = isEndOf1stDBuffer ? 0 : halfBuffersCount;
@@ -157,7 +157,7 @@ void DynamicPipeline::sendRestOfBuffers(
  }

  core.renderPart(sendBuffers, size,
-                  frustumCulling == DynPipFrustumCulling_Precise);
+                  frustumCulling == PipelineFrustumCulling_Precise);

  delete[] sendBuffers;
 }
@@ -14,12 +14,20 @@

 namespace Tyra {

-MinecraftPipeline::MinecraftPipeline() { latestMode = UndefinedMcpipProgram; }
+MinecraftPipeline::MinecraftPipeline() {
+  latestMode = UndefinedMcpipProgram;
+  spamBuffersCount = 4;
+  spamBuffers = new McpipBlock**[spamBuffersCount];
+  spamCounts = new u32[spamBuffersCount];
+  spammerIndex = 0;
+}

 MinecraftPipeline::~MinecraftPipeline() {
  if (bbox) {
    delete bbox;
  }
+  delete[] spamBuffers;
+  delete[] spamCounts;
 }

 void MinecraftPipeline::init(RendererCore* core) {
@@ -42,35 +50,35 @@ void MinecraftPipeline::initBBox() {

 void MinecraftPipeline::render(McpipBlock* blocks, const u32& count,
                               Texture* t_tex, const bool& isMulti,
-                               const bool& noFullClipChecks) {
+                               const bool& fullClipChecks) {
  auto texBuffers = rendererCore->texture.useTexture(t_tex);
  rendererCore->gs.prim.mapping = 1;

  manager.clearLastProgram();
  std::vector<u32> cullIndexes;

-  if (noFullClipChecks) {
+  if (!fullClipChecks) {
    for (u32 i = 0; i < count; i++) cullIndexes.push_back(i);
-    cull(blocks, cullIndexes, &texBuffers, isMulti);
+    cull(blocks, cullIndexes, &texBuffers, true, isMulti);
    return;
-  } else {
-    u32 culled = 0, clipped = 0;
-    std::vector<u32> clipIndexes;
-
-    for (u32 i = 0; i < count; i++) {
-      auto frustum = isInFrustum(blocks[i]);
-      if (frustum == CoreBBoxFrustum::IN_FRUSTUM) {
-        cullIndexes.push_back(i);
-        culled++;
-      } else if (frustum == CoreBBoxFrustum::PARTIALLY_IN_FRUSTUM) {
-        clipIndexes.push_back(i);
-        clipped++;
-      }
-    }
-
-    if (culled > 0) cull(blocks, cullIndexes, &texBuffers, isMulti);
-    if (clipped > 0) clip(blocks, clipIndexes, &texBuffers, isMulti);
  }
+
+  u32 culled = 0, clipped = 0;
+  std::vector<u32> clipIndexes;
+
+  for (u32 i = 0; i < count; i++) {
+    auto frustum = isInFrustum(blocks[i]);
+    if (frustum == CoreBBoxFrustum::IN_FRUSTUM) {
+      cullIndexes.push_back(i);
+      culled++;
+    } else if (frustum == CoreBBoxFrustum::PARTIALLY_IN_FRUSTUM) {
+      clipIndexes.push_back(i);
+      clipped++;
+    }
+  }
+
+  if (culled > 0) cull(blocks, cullIndexes, &texBuffers, false, isMulti);
+  if (clipped > 0) clip(blocks, clipIndexes, &texBuffers, isMulti);
 }

 CoreBBoxFrustum MinecraftPipeline::isInFrustum(const McpipBlock& block) const {
@@ -81,7 +89,7 @@ CoreBBoxFrustum MinecraftPipeline::isInFrustum(const McpipBlock& block) const {
 void MinecraftPipeline::cull(McpipBlock* blocks,
                             const std::vector<u32>& indexes,
                             RendererCoreTextureBuffers* texBuffers,
-                             const bool& isMulti) {
+                             const bool& isCullOnly, const bool& isMulti) {
  changeMode(McPipCull, false);

  auto maxBlocksPerQBuffer = manager.culler.getMaxBlocksCountPerQBuffer();
@@ -100,10 +108,18 @@ void MinecraftPipeline::cull(McpipBlock* blocks,
          &blocks[indexes[i * maxBlocksPerQBuffer + j]];
    }

-    manager.cull(blockPointerArray, blockPointerArrayCount, texBuffers,
-                 isMulti);
+    if (isCullOnly) {
+      addToSpammer(blockPointerArray, blockPointerArrayCount, texBuffers,
+                   isMulti);
+    } else {
+      manager.cull(blockPointerArray, blockPointerArrayCount, texBuffers,
+                   isMulti);
+      delete[] blockPointerArray;
+    }
+  }

-    delete[] blockPointerArray;
+  if (isCullOnly) {
+    flushSpammer(texBuffers, isMulti);
  }
 }

@@ -139,4 +155,38 @@ void MinecraftPipeline::changeMode(const McpipProgramName& requestedMode,
  }
 }

+void MinecraftPipeline::addToSpammer(McpipBlock** blockPointerArray,
+                                     const u32& count,
+                                     RendererCoreTextureBuffers* texBuffers,
+                                     const bool& isMulti) {
+  spamBuffers[spammerIndex] = blockPointerArray;
+  spamCounts[spammerIndex] = count;
+
+  spammerIndex++;
+
+  if (spammerIndex == spamBuffersCount) {
+    spammerIndex = 0;
+
+    manager.cullSpam(spamBuffers, spamCounts, spamBuffersCount, texBuffers,
+                     isMulti);
+
+    for (u32 i = 0; i < spamBuffersCount; i++) {
+      delete[] spamBuffers[i];
+    }
+  }
+}
+
+void MinecraftPipeline::flushSpammer(RendererCoreTextureBuffers* texBuffers,
+                                     const bool& isMulti) {
+  if (spammerIndex == 0) return;
+
+  manager.cullSpam(spamBuffers, spamCounts, spammerIndex, texBuffers, isMulti);
+
+  for (u32 i = 0; i < spammerIndex; i++) {
+    delete[] spamBuffers[i];
+  }
+
+  spammerIndex = 0;
+}
+
 }  // namespace Tyra
@@ -107,8 +107,6 @@ void McpipCull::sendVU1StaticData() {
 void McpipCull::addData(packet2_t* packet, McpipBlock** blockPointerArray,
                        u32 blockPointerArrayCount,
                        RendererCoreTextureBuffers* texBuffers, bool isMulti) {
-  packet2_reset(packet, false);
-
  rendererCore->texture.updateClutBuffer(texBuffers->clut);

  packet2_utils_vu_open_unpack(
@@ -16,8 +16,8 @@ BlockizerProgramsManager::BlockizerProgramsManager() {
  lastProgramName = UndefinedMcpipProgram;
  context = 0;
  vu1BlockData = BlockNotUploaded;
-  dynamicPackets[0] = packet2_create(100, P2_TYPE_NORMAL, P2_MODE_CHAIN, true);
-  dynamicPackets[1] = packet2_create(100, P2_TYPE_NORMAL, P2_MODE_CHAIN, true);
+  dynamicPackets[0] = packet2_create(300, P2_TYPE_NORMAL, P2_MODE_CHAIN, true);
+  dynamicPackets[1] = packet2_create(300, P2_TYPE_NORMAL, P2_MODE_CHAIN, true);
  staticPacket = packet2_create(2, P2_TYPE_NORMAL, P2_MODE_CHAIN, true);
  setProgramsCache();
 }
@@ -79,6 +79,32 @@ void BlockizerProgramsManager::uploadBlock(bool isMulti) {
  dma_channel_send_packet2(staticPacket, DMA_CHANNEL_VIF1, true);
 }

+void BlockizerProgramsManager::cullSpam(McpipBlock*** blockPointerArrays,
+                                        u32* blockPointerArrayCounts,
+                                        u32 blockPointerArraysCount,
+                                        RendererCoreTextureBuffers* texBuffers,
+                                        const bool& isMulti) {
+  uploadBlock(isMulti);
+
+  auto* currentPacket = dynamicPackets[context];
+
+  auto* program = repo.getProgram(McpipProgramName::McPipCull);
+
+  packet2_reset(currentPacket, false);
+
+  for (u32 i = 0; i < blockPointerArraysCount; i++) {
+    auto* blockPointerArray = blockPointerArrays[i];
+    auto blockPointerArrayCount = blockPointerArrayCounts[i];
+
+    culler.addData(currentPacket, blockPointerArray, blockPointerArrayCount,
+                   texBuffers, isMulti);
+
+    addProgram(program);
+  }
+
+  sendPacket(program);
+}
+
 void BlockizerProgramsManager::cull(McpipBlock** blockPointerArray,
                                    u32 blockPointerArrayCount,
                                    RendererCoreTextureBuffers* texBuffers,
@@ -89,9 +115,12 @@ void BlockizerProgramsManager::cull(McpipBlock** blockPointerArray,

  auto* program = repo.getProgram(McpipProgramName::McPipCull);

+  packet2_reset(currentPacket, false);
+
  culler.addData(currentPacket, blockPointerArray, blockPointerArrayCount,
                 texBuffers, isMulti);

+  addProgram(program);
  sendPacket(program);
 }

@@ -106,10 +135,11 @@ void BlockizerProgramsManager::clip(McpipBlock* block,

  clipper.addData(block, isMulti, texBuffers, currentPacket, context);

+  addProgram(program);
  sendPacket(program);
 }

-void BlockizerProgramsManager::sendPacket(McpipProgram* program) {
+void BlockizerProgramsManager::addProgram(McpipProgram* program) {
  auto* currentPacket = dynamicPackets[context];

  if (lastProgramName != program->getName()) {
@@ -119,6 +149,10 @@ void BlockizerProgramsManager::sendPacket(McpipProgram* program) {
  } else {
    packet2_utils_vu_add_continue_program(currentPacket);
  }
+}
+
+void BlockizerProgramsManager::sendPacket(McpipProgram* program) {
+  auto* currentPacket = dynamicPackets[context];

  packet2_utils_vu_add_end_tag(currentPacket);

@@ -100,6 +100,8 @@ StaPipBagPackage* StaPipBagPackager::create(u16* o_count,
 }

 CoreBBoxFrustum StaPipBagPackager::checkFrustum(const StaPipBagPackage& pkg) {
+  if (!renderBBox) return CoreBBoxFrustum::OUTSIDE_FRUSTUM;
+
  if (pkg.size <= (maxVertCount / 3)) {  // Is subpackage
    auto& bbox = renderBBox->getChildBBox1By3(pkg.indexOf1By3BBox);
    return bbox.clipIsInFrustum(frustumPlanes->getAll(), *pkg.bag->info->model);
@@ -47,7 +47,8 @@ u32 StaPipCore::getMaxVertCountByParams(const bool& isSingleColor,
      ->getMaxVertCount(isSingleColor, qbufferRenderer.getBufferSize());
 }

-void StaPipCore::render(StaPipBag* bag, StaPipBagPackagesBBox* bbox) {
+void StaPipCore::render(StaPipBag* bag, const bool& frustumCull,
+                        StaPipBagPackagesBBox* bbox) {
  if (bag->count <= 0) return;

  TYRA_ASSERT(bag->vertices != nullptr,
@@ -70,25 +71,33 @@ void StaPipCore::render(StaPipBag* bag, StaPipBagPackagesBBox* bbox) {
  TYRA_ASSERT(
      !bag->texture || (bag->texture->texture && bag->texture->coordinates),
      "If you want texture, please provide texture and coordinates!");
-
-  StaPipBagPackagesBBox* renderBbox;
+  TYRA_ASSERT(!(frustumCull == false && bag->info->fullClipChecks == true),
+              "Full clip checks are not supported with frustum culling = off!");

  u32 maxVertCount = getMaxVertCountByBag(bag);
-
  setMaxVertCount(maxVertCount);

-  if (!bbox)
-    renderBbox =
-        new StaPipBagPackagesBBox(bag->vertices, bag->count, maxVertCount);
-  else
-    renderBbox = bbox;
+  StaPipBagPackagesBBox* renderBbox = nullptr;
+
+  CoreBBoxFrustum frustumCheck = OUTSIDE_FRUSTUM;
+
+  if (frustumCull) {
+    if (!bbox)
+      renderBbox =
+          new StaPipBagPackagesBBox(bag->vertices, bag->count, maxVertCount);
+    else
+      renderBbox = bbox;
+
+    frustumCheck = renderBbox->getMainBBox()->clipIsInFrustum(
+        rendererCore->renderer3D.frustumPlanes.getAll(), *bag->info->model);
+
+    if (frustumCheck == OUTSIDE_FRUSTUM) return;
+  }
+
+  packager.setRenderBBox(renderBbox);

-  auto frustumCheck = renderBbox->getMainBBox()->clipIsInFrustum(
-      rendererCore->renderer3D.frustumPlanes.getAll(), *bag->info->model);
  auto mvp = rendererCore->renderer3D.getViewProj() * *bag->info->model;

-  if (frustumCheck == OUTSIDE_FRUSTUM) return;
-
  RendererCoreTextureBuffers* texBuffers = nullptr;
  if (bag->texture) {
    auto temp = rendererCore->texture.useTexture(bag->texture->texture);
@@ -99,14 +108,28 @@ void StaPipCore::render(StaPipBag* bag, StaPipBagPackagesBBox* bbox) {

  qbufferRenderer.sendObjectData(bag, &mvp, texBuffers);

-  packager.setRenderBBox(renderBbox);
-
  qbufferRenderer.setClipperMVP(&mvp);

  qbufferRenderer.setInfo(bag->info);

-  if (frustumCheck == IN_FRUSTUM ||
-      (frustumCheck == PARTIALLY_IN_FRUSTUM && bag->info->noFullClipChecks)) {
+  auto checkYesFrustumInClipYes =  // cull all
+      frustumCull && frustumCheck == IN_FRUSTUM && bag->info->fullClipChecks;
+
+  auto checkYesFrustumPartialClipYes =  // pkgs, cull + clip
+      frustumCull && frustumCheck == PARTIALLY_IN_FRUSTUM &&
+      bag->info->fullClipChecks;
+
+  auto checkYesFrustumInClipNo =  // cull all
+      frustumCull && frustumCheck == IN_FRUSTUM && !bag->info->fullClipChecks;
+
+  auto checkYesFrustumPartialClipNo =  // pkgs, cull all
+      frustumCull && frustumCheck == PARTIALLY_IN_FRUSTUM &&
+      !bag->info->fullClipChecks;
+
+  auto checkNoClipNo =  // cull all
+      !frustumCull && !bag->info->fullClipChecks;
+
+  if (checkYesFrustumInClipYes || checkYesFrustumInClipNo || checkNoClipNo) {
    u16 packagesCount = 0;
    auto biggerPkgs = packager.create(&packagesCount, bag, maxVertCount);
    Verbose("Material - in frustum. Pkgs: ", packagesCount,
@@ -118,12 +141,13 @@ void StaPipCore::render(StaPipBag* bag, StaPipBagPackagesBBox* bbox) {
      qbufferRenderer.cull(buffer);
    }
    delete[] biggerPkgs;
-  } else if (frustumCheck == PARTIALLY_IN_FRUSTUM) {
+  } else if (checkYesFrustumPartialClipYes || checkYesFrustumPartialClipNo) {
    u16 packagesCount = 0;
-    if (bag->count >= maxVertCount * 2) {
+    auto doClip = checkYesFrustumPartialClipYes;
+    if (!doClip || bag->count >= maxVertCount * 2) {
      auto packages = packager.create(&packagesCount, bag, maxVertCount);
      Verbose("Material - partial. Packages: ", packagesCount);
-      renderPkgs(packages, packagesCount);
+      renderPkgs(packages, doClip, packagesCount);
      delete[] packages;
    } else {
      auto subpkgs = packager.create(&packagesCount, bag, maxVertCount / 3);
@@ -133,7 +157,7 @@ void StaPipCore::render(StaPipBag* bag, StaPipBagPackagesBBox* bbox) {
    }
  }

-  if (!bbox) delete renderBbox;
+  if (frustumCull && !bbox) delete renderBbox;
  if (texBuffers) delete texBuffers;

  qbufferRenderer.flushBuffers();
@@ -141,14 +165,18 @@ void StaPipCore::render(StaPipBag* bag, StaPipBagPackagesBBox* bbox) {
  Verbose("Render finished");
 }

-void StaPipCore::renderPkgs(StaPipBagPackage* packages, u16 count) {
+void StaPipCore::renderPkgs(StaPipBagPackage* packages, const bool& doClip,
+                            u16 count) {
  for (u16 i = 0; i < count; i++) {
-    if (packages[i].isInFrustum == IN_FRUSTUM) {
+    auto cull = (doClip && packages[i].isInFrustum == IN_FRUSTUM) || !doClip;
+    auto doSubpkgs = doClip && packages[i].isInFrustum == PARTIALLY_IN_FRUSTUM;
+
+    if (cull) {
      Verbose(i, " - package in frustum -> cull");
      auto buffer = qbufferRenderer.getBuffer();
      buffer->fillByPointer(packages[i]);
      qbufferRenderer.cull(buffer);
-    } else if (packages[i].isInFrustum == PARTIALLY_IN_FRUSTUM) {
+    } else if (doSubpkgs) {
      u16 subpkgsSize = 0;
      auto packages1By3 =
          packager.create(&subpkgsSize, packages[i], maxVertCount / 3);
@@ -9,6 +9,7 @@
 */

 #include "renderer/3d/pipeline/static/static_pipeline.hpp"
+#include "debug/debug.hpp"

 namespace Tyra {

@@ -27,20 +28,29 @@ void StaticPipeline::render(StaticMesh* mesh, const StaPipOptions* options) {
  auto model = mesh->getModelMatrix();
  auto* infoBag = getInfoBag(mesh, options, &model);

+  auto frustumCulling =
+      options ? options->frustumCulling : PipelineFrustumCulling_Simple;
+
+  TYRA_ASSERT(
+      !(frustumCulling != PipelineFrustumCulling_Precise &&
+        infoBag->fullClipChecks == true),
+      "Full clip checks are only supported with frustum culling == Precise!");
+
+  if (frustumCulling == PipelineFrustumCulling_Simple) {
+    auto* frame = mesh->getFrame();
+    if (frame->getBBox().isInFrustum(
+            rendererCore->renderer3D.frustumPlanes.getAll(), model) ==
+        CoreBBoxFrustum::OUTSIDE_FRUSTUM) {
+      return;
+    }
+  }
+
  if (options && options->lighting) setLightingColorsCache(options->lighting);

  for (u32 i = 0; i < mesh->getMaterialsCount(); i++) {
    auto* material = mesh->getMaterial(i);
    auto* materialFrame = material->getFrame(0);

-    // 2x bufory[maxVertCount*2] -> pętla po mniejszych częściach i czestsze
-    // rendery
-
-    // TODO: Double buffering in future
-    // auto maxVertCount = core->renderer3D.getMaxVertCountByParams(
-    //     material->isSingleColorActivated(), material->getNormalFaces(),
-    //     material->getTextureCoordFaces());
-
    StaPipBag bag;
    addVertices(materialFrame, &bag);
    bag.info = infoBag;
@@ -48,7 +58,7 @@ void StaticPipeline::render(StaticMesh* mesh, const StaPipOptions* options) {
    bag.texture = getTextureBag(material, materialFrame);
    bag.lighting = getLightingBag(materialFrame, &model, options);

-    core.render(&bag);
+    core.render(&bag, frustumCulling == PipelineFrustumCulling_Precise);

    deallocDrawBags(&bag, material);
  }
@@ -71,12 +81,12 @@ PipelineInfoBag* StaticPipeline::getInfoBag(StaticMesh* mesh,
    result->antiAliasingEnabled = options->antiAliasingEnabled;
    result->blendingEnabled = options->blendingEnabled;
    result->shadingType = options->shadingType;
-    result->noFullClipChecks = options->noFullClipChecks;
+    result->fullClipChecks = options->fullClipChecks;
  } else {
    result->antiAliasingEnabled = false;
    result->blendingEnabled = true;
    result->shadingType = TyraShadingFlat;
-    result->noFullClipChecks = false;
+    result->fullClipChecks = false;
  }

  result->model = model;