GPU-driven optimizations

game/commandline.cpp

@@ -107,6 +107,12 @@ CommandLine::CommandLine(int argc, const char** argv) {
       if(i<argc)
         isMeshSh = (std::string_view(argv[i])!="0" && std::string_view(argv[i])!="false");
       }
+    else if(arg=="-bl") {
+      // not to document - debug only
+      ++i;
+      if(i<argc)
+        isBindlessSh = (std::string_view(argv[i])!="0" && std::string_view(argv[i])!="false");
+      }
     else {
       Log::i("unreacognized commandline option: \"", arg, "\"");
       }

game/commandline.h

@@ -32,17 +32,18 @@ class CommandLine {
     std::u16string_view modPath() const { return gmod; }
     std::u16string      nestedPath(const std::initializer_list<const char16_t*> &name, Tempest::Dir::FileType type) const;
 
-    bool                isDevMode()        const { return devmode;   }
-    bool                isValidationMode() const { return isDebug;   }
-    bool                isWindowMode()     const { return isWindow;  }
-    bool                isRayQuery()       const { return isRQuery;  }
-    bool                isRtGi()           const { return isGi;      }
-    bool                isMeshShading()    const { return isMeshSh;  }
-    bool                doStartMenu()      const { return !noMenu;   }
-    bool                doForceG1()        const { return forceG1;   }
-    bool                doForceG2()        const { return forceG2;   }
-    bool                doForceG2NR()      const { return forceG2NR; }
-    std::string_view    defaultSave()      const { return saveDef;   }
+    bool                isDevMode()        const { return devmode;      }
+    bool                isValidationMode() const { return isDebug;      }
+    bool                isWindowMode()     const { return isWindow;     }
+    bool                isRayQuery()       const { return isRQuery;     }
+    bool                isRtGi()           const { return isGi;         }
+    bool                isMeshShading()    const { return isMeshSh;     }
+    bool                isBindless()       const { return isBindlessSh; }
+    bool                doStartMenu()      const { return !noMenu;      }
+    bool                doForceG1()        const { return forceG1;      }
+    bool                doForceG2()        const { return forceG2;      }
+    bool                doForceG2NR()      const { return forceG2NR;    }
+    std::string_view    defaultSave()      const { return saveDef;      }
 
     std::string         wrldDef;
 
@@ -54,20 +55,21 @@ class CommandLine {
     std::u16string      gscript;
     std::u16string      gcutscene;
     std::string         saveDef;
-    bool                devmode   = false;
-    bool                noMenu    = false;
-    bool                isWindow  = false;
-    bool                isDebug   = false;
+    bool                devmode      = false;
+    bool                noMenu       = false;
+    bool                isWindow     = false;
+    bool                isDebug      = false;
 #if defined(__OSX__)
-    bool                isRQuery  = false;
-    bool                isMeshSh  = false;
+    bool                isRQuery     = false;
+    bool                isMeshSh     = false;
 #else
-    bool                isRQuery  = true;
-    bool                isMeshSh  = true;
+    bool                isRQuery     = true;
+    bool                isMeshSh     = true;
 #endif
-    bool                isGi      = false;
-    bool                forceG1   = false;
-    bool                forceG2   = false;
-    bool                forceG2NR = false;
+    bool                isBindlessSh = true;
+    bool                isGi         = false;
+    bool                forceG1      = false;
+    bool                forceG2      = false;
+    bool                forceG2NR    = false;
   };
 

game/gothic.cpp

@@ -36,6 +36,13 @@ static bool hasMeshShader() {
   return false;
   }
 
+static bool hasBindless() {
+  const auto& p = Resources::device().properties();
+  if(p.descriptors.nonUniformIndexing && p.descriptors.maxTexture>=65000 && p.descriptors.maxStorage>=65000)
+    return true;
+  return false;
+  }
+
 Gothic::Gothic() {
   instance = this;
 
@@ -74,6 +81,10 @@ Gothic::Gothic() {
     opts.doMeshShading = CommandLine::inst().isMeshShading();
     }
 
+  if(hasBindless()) {
+    opts.doBindless = CommandLine::inst().isBindless();
+    }
+
   wrldDef = CommandLine::inst().wrldDef;
 
   baseIniFile.reset(new IniFile(nestedPath({u"system",u"Gothic.ini"},Dir::FT_File)));

game/gothic.h

@@ -45,6 +45,7 @@ class Gothic final {
       bool  doRayQuery          = false;
       bool  doRtGi              = false;
       bool  doMeshShading       = false;
+      bool  doBindless          = false;
 
       bool  hideFocus           = false;
       float cameraFov           = 67.5f;

game/graphics/drawbuckets.cpp

@@ -0,0 +1,97 @@
+#include "drawbuckets.h"
+
+#include <Tempest/Vec>
+
+#include "graphics/mesh/submesh/staticmesh.h"
+#include "graphics/mesh/submesh/animmesh.h"
+
+using namespace Tempest;
+
+DrawBuckets::Id::Id(DrawBuckets* owner, size_t id):owner(owner), id(uint16_t(id)) {
+  }
+
+DrawBuckets::Id::Id(Id&& other) noexcept {
+  std::swap(owner, other.owner);
+  std::swap(id,    other.id);
+  }
+
+DrawBuckets::Id& DrawBuckets::Id::operator =(Id&& other) noexcept {
+  std::swap(owner, other.owner);
+  std::swap(id,    other.id);
+  return *this;
+  }
+
+DrawBuckets::Id::~Id() {
+  }
+
+
+DrawBuckets::DrawBuckets() {
+  }
+
+DrawBuckets::Id DrawBuckets::alloc(const Material& mat, const StaticMesh& mesh) {
+  for(size_t i=0; i<bucketsCpu.size(); ++i) {
+    auto& b = bucketsCpu[i];
+    if(b.staticMesh==&mesh && b.mat==mat)
+      return Id(this, i);
+    }
+
+  Bucket bx;
+  bx.staticMesh = &mesh;
+  bx.mat        = mat;
+  bucketsCpu.emplace_back(std::move(bx));
+  bucketsDurtyBit = true;
+  return Id(this, bucketsCpu.size()-1);
+  }
+
+DrawBuckets::Id DrawBuckets::alloc(const Material& mat, const AnimMesh& mesh) {
+  for(size_t i=0; i<bucketsCpu.size(); ++i) {
+    auto& b = bucketsCpu[i];
+    if(b.animMesh==&mesh && b.mat==mat)
+      return Id(this, i);
+    }
+
+  Bucket bx;
+  bx.animMesh = &mesh;
+  bx.mat      = mat;
+
+  bucketsDurtyBit = true;
+  bucketsCpu.emplace_back(std::move(bx));
+  return Id(this, bucketsCpu.size()-1);
+  }
+
+const std::vector<DrawBuckets::Bucket>& DrawBuckets::buckets() {
+  return bucketsCpu;
+  }
+
+bool DrawBuckets::commit(Encoder<CommandBuffer>& cmd, uint8_t fId) {
+  if(!bucketsDurtyBit)
+    return false;
+  bucketsDurtyBit = false;
+
+  std::vector<BucketGpu> bucket;
+  for(auto& i:bucketsCpu) {
+    BucketGpu bx;
+    bx.texAniMapDirPeriod = i.mat.texAniMapDirPeriod;
+    bx.waveMaxAmplitude   = i.mat.waveMaxAmplitude;
+    bx.alphaWeight        = i.mat.alphaWeight;
+    bx.envMapping         = i.mat.envMapping;
+    if(i.staticMesh!=nullptr) {
+      auto& bbox    = i.staticMesh->bbox.bbox;
+      bx.bboxRadius = i.staticMesh->bbox.rConservative;
+      bx.bbox[0]    = Vec4(bbox[0].x,bbox[0].y,bbox[0].z,0.f);
+      bx.bbox[1]    = Vec4(bbox[1].x,bbox[1].y,bbox[1].z,0.f);
+      }
+    else if(i.animMesh!=nullptr) {
+      auto& bbox    = i.animMesh->bbox.bbox;
+      bx.bboxRadius = i.animMesh->bbox.rConservative;
+      bx.bbox[0]    = Vec4(bbox[0].x,bbox[0].y,bbox[0].z,0.f);
+      bx.bbox[1]    = Vec4(bbox[1].x,bbox[1].y,bbox[1].z,0.f);
+      }
+    bucket.push_back(bx);
+    }
+
+  auto& device = Resources::device();
+  Resources::recycle(std::move(bucketsGpu));
+  bucketsGpu = device.ssbo(bucket);
+  return true;
+  }

game/graphics/drawbuckets.h

@@ -0,0 +1,65 @@
+#pragma once
+
+#include <Tempest/StorageBuffer>
+
+#include "material.h"
+
+class StaticMesh;
+class AnimMesh;
+
+class DrawBuckets {
+  public:
+    DrawBuckets();
+
+    struct Bucket {
+      const StaticMesh* staticMesh = nullptr;
+      const AnimMesh*   animMesh   = nullptr;
+      Material          mat;
+      };
+
+    class Id {
+      public:
+        Id() = default;
+        Id(DrawBuckets& owner):owner(&owner){}
+        Id(Id&& other) noexcept;
+        Id& operator = (Id&& other) noexcept;
+        ~Id();
+
+        uint16_t toInt() const { return id; }
+
+        Bucket& operator *  () { return  owner->bucketsCpu[id]; }
+        Bucket* operator -> () { return &owner->bucketsCpu[id]; }
+
+      private:
+        Id(DrawBuckets* owner, size_t id);
+
+        DrawBuckets* owner = nullptr;
+        uint16_t     id    = 0;
+      friend class DrawBuckets;
+      };
+
+    Id   alloc(const Material& mat, const StaticMesh& mesh);
+    Id   alloc(const Material& mat, const AnimMesh&   mesh);
+
+    const Bucket& operator[](size_t i) { return bucketsCpu[i]; }
+
+    auto ssbo() const -> const Tempest::StorageBuffer& { return bucketsGpu; }
+    auto buckets() -> const std::vector<Bucket>&;
+
+    bool commit(Tempest::Encoder<Tempest::CommandBuffer>& cmd, uint8_t fId);
+
+  private:
+    struct BucketGpu final {
+      Tempest::Vec4  bbox[2];
+      Tempest::Point texAniMapDirPeriod;
+      float          bboxRadius       = 0;
+      float          waveMaxAmplitude = 0;
+      float          alphaWeight      = 1;
+      float          envMapping       = 0;
+      uint32_t       padd[2]          = {};
+      };
+
+    std::vector<Bucket>    bucketsCpu;
+    Tempest::StorageBuffer bucketsGpu;
+    bool                   bucketsDurtyBit = false;
+  };