Basic meshlet generation algorithm

src/Engine/Scene/LightEnvironment.cpp

@@ -7,10 +7,33 @@ LightEnvironment::LightEnvironment(Gfx::PGraphics graphics)
     : graphics(graphics)
 {
     layout = graphics->createDescriptorLayout("LightEnvironment");
-    layout->addDescriptorBinding(0, Gfx::SE_DESCRIPTOR_TYPE_STORAGE_BUFFER);
+    layout->addDescriptorBinding(0, Gfx::SE_DESCRIPTOR_TYPE_UNIFORM_BUFFER);
     layout->addDescriptorBinding(1, Gfx::SE_DESCRIPTOR_TYPE_STORAGE_BUFFER);
     layout->addDescriptorBinding(2, Gfx::SE_DESCRIPTOR_TYPE_STORAGE_BUFFER);
-    layout->addDescriptorBinding(3, Gfx::SE_DESCRIPTOR_TYPE_STORAGE_BUFFER);
+    layout->create();
+    lightEnvBuffer = graphics->createUniformBuffer(UniformBufferCreateInfo{
+        .resourceData = {
+            .size = sizeof(LightEnv),
+            .data = (uint8*) &lightEnv,
+        },
+        .bDynamic = true,
+    });
+    directionalLights = graphics->createShaderBuffer(ShaderBufferCreateInfo{
+        .resourceData = {
+            .size = sizeof(Component::DirectionalLight) * MAX_DIRECTIONAL_LIGHTS,
+            .data = (uint8*)dirs.data(),
+        },
+        .stride = sizeof(Component::DirectionalLight),
+        .bDynamic = true,
+    });
+    pointLights = graphics->createShaderBuffer(ShaderBufferCreateInfo{
+        .resourceData = {
+            .size = sizeof(Component::PointLight) * MAX_POINT_LIGHTS,
+            .data = (uint8*)dirs.data(),
+        },
+        .stride = sizeof(Component::PointLight),
+        .bDynamic = true,
+    });
 }
 
 LightEnvironment::~LightEnvironment()
@@ -19,17 +42,39 @@ LightEnvironment::~LightEnvironment()
 
 void LightEnvironment::reset()
 {
-
+    layout->reset();
+    set = layout->allocateDescriptorSet();
+    dirs.clear();
+    points.clear();
 }
 
 void LightEnvironment::addDirectionalLight(Component::DirectionalLight dirLight)
 {
+    dirs.add(dirLight);
 }
 
 void LightEnvironment::addPointLight(Component::PointLight pointLight)
 {
+    points.add(pointLight);
 }
 
 void LightEnvironment::commit()
 {
+    lightEnv.numDirectionalLights = dirs.size();
+    lightEnv.numPointLights = points.size();
+    lightEnvBuffer->updateContents(BulkResourceData{
+        .size = sizeof(LightEnv),
+        .data = (uint8*) & lightEnv,
+        });
+    directionalLights->updateContents(BulkResourceData{
+        .size = sizeof(Component::DirectionalLight) * dirs.size(),
+        .data = (uint8*)dirs.data(),
+        });
+    pointLights->updateContents(BulkResourceData{
+        .size = sizeof(Component::PointLight) * points.size(),
+        .data = (uint8*)points.data(),
+        });
+    set->updateBuffer(0, lightEnvBuffer);
+    set->updateBuffer(1, directionalLights);
+    set->updateBuffer(2, pointLights);
 }

src/Engine/Scene/LightEnvironment.h

@@ -18,10 +18,14 @@ public:
 private:
     #define MAX_DIRECTIONAL_LIGHTS 4
     #define MAX_POINT_LIGHTS 256
+    struct LightEnv
+    {
+        uint32 numDirectionalLights;
+        uint32 numPointLights;
+    } lightEnv;
     Gfx::PShaderBuffer directionalLights;
-    Gfx::PUniformBuffer numDirectional;
+    Gfx::PUniformBuffer lightEnvBuffer;
     Gfx::PShaderBuffer pointLights;
-    Gfx::PUniformBuffer numPoints;;
     Array<Component::DirectionalLight> dirs;
     Array<Component::PointLight> points;
     Gfx::PDescriptorLayout layout;

src/Engine/Scene/Scene.cpp

@@ -15,29 +15,8 @@ using namespace Seele;
 Scene::Scene(Gfx::PGraphics graphics)
     : graphics(graphics)
     , physics(registry)
+    , lightEnv(new LightEnvironment(graphics))
 {
-    ShaderBufferCreateInfo structInfo = {
-        .resourceData = {
-            .size = sizeof(Component::DirectionalLight) * MAX_DIRECTIONAL_LIGHTS,
-            .data = nullptr,
-        },
-        .stride = sizeof(Component::DirectionalLight),
-        .bDynamic = true,
-    };
-    lightEnv.directionalLights = graphics->createShaderBuffer(structInfo);
-    structInfo.resourceData.size = sizeof(Component::PointLight) * MAX_POINT_LIGHTS;
-    structInfo.stride = sizeof(Component::PointLight);
-    lightEnv.pointLights = graphics->createShaderBuffer(structInfo);
-    
-    UniformBufferCreateInfo uniformInfo = {
-        .resourceData = {
-            .size = sizeof(uint32),
-            .data = nullptr
-        },
-        .bDynamic = true
-    };
-    lightEnv.numDirectional = graphics->createUniformBuffer(uniformInfo);
-    lightEnv.numPoints = graphics->createUniformBuffer(uniformInfo);
 }
 
 Scene::~Scene()
@@ -49,35 +28,3 @@ void Scene::update(float deltaTime)
     physics.update(deltaTime);
 }
 
-LightEnv Scene::getLightBuffer() 
-{
-    StaticArray<Component::DirectionalLight, MAX_DIRECTIONAL_LIGHTS> dirLights;
-    uint32 numDirLights = 0;
-    for(auto&& [entity, light] : registry.view<Component::DirectionalLight>().each())
-    {
-        dirLights[numDirLights++] = light;
-    }
-    lightEnv.directionalLights->updateContents({
-        .size = sizeof(Component::DirectionalLight) * numDirLights,
-        .data = (uint8*)dirLights.data(),
-    });
-    lightEnv.numDirectional->updateContents({
-        .size = sizeof(uint32),
-        .data = (uint8*)&numDirLights,
-    });
-    StaticArray<Component::PointLight, MAX_POINT_LIGHTS> pointLights;
-    uint32 numPointLights = 0;
-    for(auto&& [entity, light] : registry.view<Component::PointLight>().each())
-    {
-        pointLights[numPointLights++] = light;
-    }
-    lightEnv.pointLights->updateContents({
-        .size = sizeof(Component::PointLight) * numPointLights,
-        .data = (uint8*)pointLights.data(),
-    });
-    lightEnv.numPoints->updateContents({
-        .size = sizeof(uint32),
-        .data = (uint8*)&numPointLights,
-    });
-    return lightEnv;
-}