Dynamitos/Seele
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Basic meshlet generation algorithm

Browse Source
This commit is contained in:
Dynamitos
2023-10-31 16:16:23 +01:00
parent 7773c55e1a
commit d53492d07b
15 changed files with 350 additions and 191 deletions
Download Patch File Download Diff File Expand all files Collapse all files
res/shaders/MeshletBasePass.slang
+2 -1
View File
@@ -82,6 +82,7 @@ void meshMain(
out Indices<uint3, MAX_PRIMITIVES> indices
){
InstanceData inst = scene.instances[meshPayload.instanceId[groupID]];
MeshData md = scene.meshData[meshPayload.instanceId[groupID]];
MeshletDescription m = meshlets.meshletInfos[meshPayload.meshletId[groupID]];
const uint vertexLoops = (MAX_VERTICES + MESH_GROUP_SIZE - 1) / MESH_GROUP_SIZE;
for(uint loop = 0; loop < vertexLoops; ++loop)
@@ -91,7 +92,7 @@ void meshMain(
InterlockedMax(gs_numVertices, v + 1);
{
int vertexIndex = meshlets.vertexIndices[m.vertexOffset + v];
gs_vertices[v] = vertexData.getAttributes(vertexIndex, inst);
gs_vertices[v] = vertexData.getAttributes(md.indexOffset + vertexIndex, inst);
}
}
res/shaders/lib/Meshlet.slang
+5 -9
View File
@@ -9,18 +9,11 @@ struct MeshletDescription
uint32_t primitiveOffset;
};
struct MeshletData
{
StructuredBuffer<MeshletDescription> meshletInfos;
StructuredBuffer<uint8_t> primitiveIndices;
StructuredBuffer<uint32_t> vertexIndices;
};
struct MeshData
{
uint numMeshlets;
uint meshletOffset;
uint indicesOffset;
};
static const uint MAX_VERTICES = 64;
@@ -38,7 +31,10 @@ struct Scene
{
StructuredBuffer<InstanceData> instances;
StructuredBuffer<MeshData> meshData;
StructuredBuffer<MeshletData> meshlets;
StructuredBuffer<MeshletDescription> meshletInfos;
StructuredBuffer<uint8_t> primitiveIndices;
StructuredBuffer<uint32_t> vertexIndices;
};
layout(set = INDEX_SCENE_DATA)
src/Editor/Asset/MeshLoader.cpp
+91 -86
View File
@@ -1,11 +1,11 @@
#include "MeshLoader.h"
#include "Graphics/GraphicsResources.h"
#include "Graphics/Graphics.h"
#include "Asset/MeshAsset.h"
#include "Graphics/Mesh.h"
#include "Graphics/StaticMeshVertexInput.h"
#include "Graphics/StaticMeshVertexData.h"
#include "Asset/AssetImporter.h"
#include "Asset/MaterialAsset.h"
#include <set>
#include <fstream>
#include <iostream>
#include <nlohmann/json.hpp>
@@ -120,7 +120,6 @@ void MeshLoader::loadMaterials(const aiScene* scene, const std::string& baseName
}
}
void findMeshRoots(aiNode *node, List<aiNode *> &meshNodes)
{
if (node->mNumMeshes > 0)
@@ -133,57 +132,7 @@ void findMeshRoots(aiNode *node, List<aiNode *> &meshNodes)
findMeshRoots(node->mChildren[i], meshNodes);
}
}
VertexStreamComponent createVertexStream(uint32 size, aiVector3D* sourceData, Gfx::PGraphics graphics)
{
Array<Vector> buffer(size);
for(uint32 i = 0; i < size; ++i)
{
buffer[i] = Vector(sourceData[i].x, sourceData[i].y, sourceData[i].z);
}
VertexBufferCreateInfo vbInfo;
vbInfo.numVertices = size;
vbInfo.vertexSize = sizeof(Vector);
vbInfo.resourceData.data = (uint8 *)buffer.data();
vbInfo.resourceData.owner = Gfx::QueueType::DEDICATED_TRANSFER;
vbInfo.resourceData.size = sizeof(Vector) * buffer.size();
Gfx::PVertexBuffer vertexBuffer = graphics->createVertexBuffer(vbInfo);
vertexBuffer->transferOwnership(Gfx::QueueType::GRAPHICS);
return VertexStreamComponent(vertexBuffer, 0, vbInfo.vertexSize, Gfx::SE_FORMAT_R32G32B32_SFLOAT);
}
VertexStreamComponent createVertexStream(uint32 size, aiVector2D* sourceData, Gfx::PGraphics graphics)
{
Array<Vector2> buffer(size);
for(uint32 i = 0; i < size; ++i)
{
buffer[i] = Vector2(sourceData[i].x, sourceData[i].y);
}
VertexBufferCreateInfo vbInfo;
vbInfo.numVertices = size;
vbInfo.vertexSize = sizeof(Vector2);
vbInfo.resourceData.data = (uint8 *)buffer.data();
vbInfo.resourceData.owner = Gfx::QueueType::DEDICATED_TRANSFER;
vbInfo.resourceData.size = sizeof(Vector2) * buffer.size();
Gfx::PVertexBuffer vertexBuffer = graphics->createVertexBuffer(vbInfo);
vertexBuffer->transferOwnership(Gfx::QueueType::GRAPHICS);
return VertexStreamComponent(vertexBuffer, 0, vbInfo.vertexSize, Gfx::SE_FORMAT_R32G32_SFLOAT);
}
VertexStreamComponent createVertexStream(uint32 size, aiColor4D* sourceData, Gfx::PGraphics graphics)
{
Array<Vector4> buffer(size);
for(uint32 i = 0; i < size; ++i)
{
buffer[i] = Vector4(sourceData[i].r, sourceData[i].g, sourceData[i].b, sourceData[i].a);
}
VertexBufferCreateInfo vbInfo;
vbInfo.numVertices = size;
vbInfo.vertexSize = sizeof(Vector4);
vbInfo.resourceData.data = (uint8 *)buffer.data();
vbInfo.resourceData.owner = Gfx::QueueType::DEDICATED_TRANSFER;
vbInfo.resourceData.size = sizeof(Vector4) * buffer.size();
Gfx::PVertexBuffer vertexBuffer = graphics->createVertexBuffer(vbInfo);
vertexBuffer->transferOwnership(Gfx::QueueType::GRAPHICS);
return VertexStreamComponent(vertexBuffer, 0, vbInfo.vertexSize, Gfx::SE_FORMAT_R32G32B32A32_SFLOAT);
}
void MeshLoader::loadGlobalMeshes(const aiScene* scene, const Array<PMaterialAsset>& materials, Array<PMesh>& globalMeshes, Component::Collider& collider)
{
for (uint32 meshIndex = 0; meshIndex < scene->mNumMeshes; ++meshIndex)
@@ -192,50 +141,106 @@ void MeshLoader::loadGlobalMeshes(const aiScene* scene, const Array<PMaterialAss
collider.boundingbox.adjust(Vector(mesh->mAABB.mMin.x, mesh->mAABB.mMin.y, mesh->mAABB.mMin.z));
collider.boundingbox.adjust(Vector(mesh->mAABB.mMax.x, mesh->mAABB.mMax.y, mesh->mAABB.mMax.z));
//! \todo duplicate from createVertexStream, clean up
Array<Vector> vertices(mesh->mNumVertices);
// assume static mesh for now
Array<Vector> positions(mesh->mNumVertices);
Array<Vector2> texCoords(mesh->mNumVertices);
Array<Vector> normals(mesh->mNumVertices);
Array<Vector> tangents(mesh->mNumVertices);
Array<Vector> biTangents(mesh->mNumVertices);
StaticMeshVertexData* vertexData = StaticMeshVertexData::getInstance();
for(uint32 i = 0; i < mesh->mNumVertices; ++i)
{
vertices[i] = Vector(mesh->mVertices[i].x, mesh->mVertices[i].y, mesh->mVertices[i].z);
positions[i] = Vector(mesh->mVertices[i].x, mesh->mVertices[i].y, mesh->mVertices[i].z);
texCoords[i] = Vector2(mesh->mTextureCoords[0][i].x, mesh->mTextureCoords[0][i].x);
normals[i] = Vector(mesh->mNormals[i].x, mesh->mNormals[i].y, mesh->mNormals[i].z);
tangents[i] = Vector(mesh->mTangents[i].x, mesh->mTangents[i].y, mesh->mTangents[i].z);
biTangents[i] = Vector(mesh->mBitangents[i].x, mesh->mBitangents[i].y, mesh->mBitangents[i].z);
}
PStaticMeshVertexInput vertexShaderInput = new StaticMeshVertexInput(std::string(mesh->mName.C_Str()));
StaticMeshDataType data;
data.positionStream = createVertexStream(mesh->mNumVertices, mesh->mVertices, graphics);
for(uint32 i = 0; i < MAX_TEXCOORDS; ++i)
{
if(mesh->HasTextureCoords(i))
{
data.textureCoordinates[i] = createVertexStream(mesh->mNumVertices, mesh->mTextureCoords[i], graphics);
}
}
if(mesh->HasNormals())
{
data.tangentBasisComponents[0] = createVertexStream(mesh->mNumVertices, mesh->mNormals, graphics);
}
if(mesh->HasTangentsAndBitangents())
{
//TODO: use bitangent to calculate sign for 4th coordinate of tangentstream
data.tangentBasisComponents[1] = createVertexStream(mesh->mNumVertices, mesh->mTangents, graphics);
data.tangentBasisComponents[2] = createVertexStream(mesh->mNumVertices, mesh->mBitangents, graphics);
}
if(mesh->HasVertexColors(0))
{
data.colorComponent = createVertexStream(mesh->mNumVertices, mesh->mColors[0], graphics);
}
vertexShaderInput->setData(std::move(data));
vertexShaderInput->init(graphics);
MeshId id = vertexData->allocateVertexData(mesh->mNumVertices);
vertexData->loadPositions(id, positions);
vertexData->loadTexCoords(id, texCoords);
vertexData->loadNormals(id, normals);
vertexData->loadTangents(id, tangents);
vertexData->loadBiTangents(id, biTangents);
Array<uint32> indices(mesh->mNumFaces * 3);
for (uint32 faceIndex = 0; faceIndex < mesh->mNumFaces; ++faceIndex)
for (size_t faceIndex = 0; faceIndex < mesh->mNumFaces; ++faceIndex)
{
indices[faceIndex * 3 + 0] = mesh->mFaces[faceIndex].mIndices[0];
indices[faceIndex * 3 + 1] = mesh->mFaces[faceIndex].mIndices[1];
indices[faceIndex * 3 + 2] = mesh->mFaces[faceIndex].mIndices[2];
}
collider.physicsMesh.addCollider(vertices, indices, Matrix4(1.0f));
if (Gfx::useMeshShading)
{
Array<Meshlet> meshlets;
meshlets.reserve(indices.size() / (3ull * Gfx::numPrimitivesPerMeshlet));
std::set<uint32> uniqueVertices;
Meshlet current = {
.numVertices = 0,
.numPrimitives = 0,
};
auto insertAndGetIndex = [&uniqueVertices, &current](uint32 index) -> int8_t
{
auto [it, inserted] = uniqueVertices.insert(index);
if (inserted)
{
if (current.numVertices == Gfx::numVerticesPerMeshlet)
{
return -1;
}
current.uniqueVertices[current.numVertices] = index;
return current.numVertices++;
}
else
{
for (uint32 i = 0; i < current.numVertices; ++i)
{
if (current.uniqueVertices[i] == index)
{
return i;
}
}
assert(false);
}
};
auto completeMeshlet = [&meshlets, &current, &uniqueVertices]() {
meshlets.add(current);
current = {
.numVertices = 0,
.numPrimitives = 0,
};
uniqueVertices.clear();
};
for (size_t faceIndex = 0; faceIndex < mesh->mNumFaces; ++faceIndex)
{
auto i1 = insertAndGetIndex(mesh->mFaces[faceIndex].mIndices[0]);
auto i2 = insertAndGetIndex(mesh->mFaces[faceIndex].mIndices[1]);
auto i3 = insertAndGetIndex(mesh->mFaces[faceIndex].mIndices[2]);
if (i1 == -1 || i2 == -1 || i3 == -1)
{
completeMeshlet();
}
current.primitiveLayout[current.numPrimitives * 3 + 0] = i1;
current.primitiveLayout[current.numPrimitives * 3 + 1] = i2;
current.primitiveLayout[current.numPrimitives * 3 + 2] = i3;
current.numPrimitives++;
if (current.numPrimitives == Gfx::numPrimitivesPerMeshlet)
{
completeMeshlet();
}
}
}
else
{
// \! todo
}
collider.physicsMesh.addCollider(positions, indices, Matrix4(1.0f));
IndexBufferCreateInfo idxInfo;
idxInfo.indexType = Gfx::SE_INDEX_TYPE_UINT32;
src/Editor/Asset/TextureLoader.h
+1 -1
View File
@@ -1,7 +1,7 @@
#pragma once
#include "MinimalEngine.h"
#include "Containers/List.h"
#include "Graphics/GraphicsEnums.h"
#include "Graphics/Enums.h"
#include <filesystem>
namespace Seele
src/Engine/Graphics/Enums.h
+4
View File
@@ -167,6 +167,10 @@ static constexpr bool useAsyncCompute = true;
static constexpr bool waitIdleOnSubmit = true;
static constexpr bool useMeshShading = true;
static constexpr uint32 numFramesBuffered = 8;
// meshlet dimensions curated by NVIDIA
static constexpr uint32 numVerticesPerMeshlet = 64;
static constexpr uint32 numPrimitivesPerMeshlet = 126;
double getCurrentFrameDelta();
enum class RenderPassType : uint8
src/Engine/Graphics/Resources.h
-1
View File
@@ -4,7 +4,6 @@
#include "Containers/Array.h"
#include "Containers/List.h"
#include "Initializer.h"
#include "Buffer.h"
#include "CRC.h"
#include <functional>
src/Engine/Graphics/ShaderCompiler.cpp
-8
View File
@@ -15,12 +15,4 @@ ShaderCompiler::~ShaderCompiler()
}
void ShaderCompiler::registerMaterial(PMaterial material)
{
for(auto& type : VertexInputType::getTypeList())
{
material->createShaders(graphics, Gfx::RenderPassType::DepthPrepass, type);
material->createShaders(graphics, Gfx::RenderPassType::BasePass, type);
}
}
src/Engine/Graphics/ShaderCompiler.h
-2
View File
@@ -11,9 +11,7 @@ class ShaderCompiler
public:
ShaderCompiler(PGraphics graphics);
~ShaderCompiler();
void registerMaterial(PMaterial material);
private:
Array<PMaterial> pendingCompiles;
PGraphics graphics;
};
DEFINE_REF(ShaderCompiler)
src/Engine/Graphics/StaticMeshVertexData.cpp
+117 -4
View File
@@ -1,12 +1,15 @@
#include "StaticMeshVertexData.h"
#include "Graphics.h"
using namespace Seele;
extern List<VertexData*> vertexDataList;
StaticMeshVertexData::StaticMeshVertexData(Gfx::PGraphics graphics)
: VertexData(graphics)
, head(0)
constexpr static uint64 NUM_DEFAULT_ELEMENTS = 1024;
StaticMeshVertexData::StaticMeshVertexData()
: head(0)
, verticesAllocated(NUM_DEFAULT_ELEMENTS)
{
vertexDataList.add(this);
}
@@ -14,10 +17,120 @@ StaticMeshVertexData::StaticMeshVertexData(Gfx::PGraphics graphics)
StaticMeshVertexData::~StaticMeshVertexData()
{}
StaticMeshVertexData* Seele::StaticMeshVertexData::getInstance()
{
return ;
}
MeshId StaticMeshVertexData::allocateVertexData(uint64 numVertices)
{
MeshId res{idCounter++};
MeshId res{ idCounter++ };
meshOffsets[res] = head;
head += numVertices;
if (head > verticesAllocated)
{
ShaderBufferCreateInfo createInfo = {
.resourceData = {
.size = head * sizeof(Vector),
},
.stride = sizeof(Vector),
.bDynamic = true,
};
positions = graphics->createShaderBuffer(createInfo);
normals = graphics->createShaderBuffer(createInfo);
tangents = graphics->createShaderBuffer(createInfo);
biTangents = graphics->createShaderBuffer(createInfo);
createInfo.resourceData.size = head * sizeof(Vector2);
createInfo.stride = sizeof(Vector2);
texCoords = graphics->createShaderBuffer(createInfo);
}
positionData.resize(head);
texCoordsData.resize(head);
normalData.resize(head);
tangentData.resize(head);
biTangentData.resize(head);
return res;
}
void StaticMeshVertexData::loadPositions(MeshId id, const Array<Vector>& data)
{
uint64 offset = meshOffsets[id];
assert(offset + data.size() < head);
std::memcpy(positionData.data() + offset, data.data(), data.size() * sizeof(Vector));
dirty = true;
}
void StaticMeshVertexData::loadTexCoords(MeshId id, const Array<Vector2>& data)
{
uint64 offset = meshOffsets[id];
assert(offset + data.size() < head);
std::memcpy(texCoordsData.data() + offset, data.data(), data.size() * sizeof(Vector2));
dirty = true;
}
void StaticMeshVertexData::loadNormals(MeshId id, const Array<Vector>& data)
{
uint64 offset = meshOffsets[id];
assert(offset + data.size() < head);
std::memcpy(normalData.data() + offset, data.data(), data.size() * sizeof(Vector));
dirty = true;
}
void StaticMeshVertexData::loadTangents(MeshId id, const Array<Vector>& data)
{
uint64 offset = meshOffsets[id];
assert(offset + data.size() < head);
std::memcpy(tangentData.data() + offset, data.data(), data.size() * sizeof(Vector));
dirty = true;
}
void StaticMeshVertexData::loadBiTangents(MeshId id, const Array<Vector>& data)
{
uint64 offset = meshOffsets[id];
assert(offset + data.size() < head);
std::memcpy(biTangentData.data() + offset, data.data(), data.size() * sizeof(Vector));
dirty = true;
}
void StaticMeshVertexData::init(Gfx::PGraphics graphics)
{
VertexData::init(graphics);
ShaderBufferCreateInfo createInfo = {
.resourceData = {
.size = NUM_DEFAULT_ELEMENTS * sizeof(Vector),
},
.stride = sizeof(Vector),
.bDynamic = true,
};
positions = graphics->createShaderBuffer(createInfo);
normals = graphics->createShaderBuffer(createInfo);
tangents = graphics->createShaderBuffer(createInfo);
biTangents = graphics->createShaderBuffer(createInfo);
createInfo.resourceData.size = NUM_DEFAULT_ELEMENTS * sizeof(Vector2);
createInfo.stride = sizeof(Vector2);
texCoords = graphics->createShaderBuffer(createInfo);
}
void StaticMeshVertexData::updateBuffers()
{
positions->updateContents(BulkResourceData{
.size = positionData.size() * sizeof(Vector),
.data = (uint8*)positionData.data(),
});
texCoords->updateContents(BulkResourceData{
.size = texCoordsData.size() * sizeof(Vector2),
.data = (uint8*)texCoordsData.data(),
});
normals->updateContents(BulkResourceData{
.size = normalData.size() * sizeof(Vector),
.data = (uint8*)normalData.data(),
});
tangents->updateContents(BulkResourceData{
.size = tangentData.size() * sizeof(Vector),
.data = (uint8*)tangentData.data(),
});
biTangents->updateContents(BulkResourceData{
.size = biTangentData.size() * sizeof(Vector),
.data = (uint8*)biTangentData.data(),
});
}
src/Engine/Graphics/StaticMeshVertexData.h
+5 -1
View File
@@ -6,15 +6,18 @@ namespace Seele
class StaticMeshVertexData : public VertexData
{
public:
StaticMeshVertexData(Gfx::PGraphics graphics);
StaticMeshVertexData();
virtual ~StaticMeshVertexData();
static StaticMeshVertexData* getInstance();
virtual MeshId allocateVertexData(uint64 numVertices) override;
void loadPositions(MeshId id, const Array<Vector>& data);
void loadTexCoords(MeshId id, const Array<Vector2>& data);
void loadNormals(MeshId id, const Array<Vector>& data);
void loadTangents(MeshId id, const Array<Vector>& data);
void loadBiTangents(MeshId id, const Array<Vector>& data);
virtual void init(Gfx::PGraphics graphics) override;
private:
virtual void updateBuffers() override;
Gfx::PShaderBuffer positions;
Array<Vector> positionData;
Gfx::PShaderBuffer texCoords;
@@ -27,5 +30,6 @@ private:
Array<Vector> biTangentData;
Map<MeshId, uint64_t> meshOffsets;
uint64 head;
uint64 verticesAllocated;
};
}
src/Engine/Graphics/VertexData.cpp
+36 -3
View File
@@ -9,6 +9,10 @@ using namespace Seele;
void VertexData::resetMeshData()
{
materialData.clear();
if (dirty)
{
updateBuffers();
}
}
void VertexData::updateMesh(const Component::Transform& transform, const Component::Mesh& mesh)
@@ -24,6 +28,30 @@ void VertexData::updateMesh(const Component::Transform& transform, const Compone
});
}
void VertexData::loadMesh(MeshId id, Array<Meshlet> meshlets)
{
meshData[id].clear();
uint32 head = 0;
while (head < meshlets.size())
{
uint32 numMeshlets = std::min<uint32>(512, meshlets.size() - head);
Array<MeshletDescription> desc(numMeshlets);
for (uint32 i = 0; i < numMeshlets; ++i)
{
Meshlet& m = meshlets[head + i];
vertexIndices.resize()
desc.add(MeshletDescription{
.boundingBox = MeshletAABB(),
.vertexCount = m.numVertices,
.primitiveCount = m.numPrimitives,
});
}
meshData[id].add();
head += numMeshlets;
}
}
void VertexData::createDescriptors()
{
for (const auto& [_, mat] : materialData)
@@ -74,10 +102,9 @@ List<VertexData*> VertexData::getList()
return vertexDataList;
}
VertexData::VertexData(Gfx::PGraphics graphics)
: graphics(graphics)
, idCounter(0)
void Seele::VertexData::init(Gfx::PGraphics graphics)
{
this->graphics = graphics;
instanceDataLayout = graphics->createDescriptorLayout("VertexDataInstanceLayout");
instanceDataLayout->addDescriptorBinding(0, Gfx::SE_DESCRIPTOR_TYPE_STORAGE_BUFFER);
if (Gfx::useMeshShading)
@@ -96,3 +123,9 @@ VertexData::VertexData(Gfx::PGraphics graphics)
}
instanceDataLayout->create();
}
VertexData::VertexData()
: idCounter(0)
, dirty(false)
{
}
src/Engine/Graphics/VertexData.h
+23 -5
View File
@@ -15,6 +15,17 @@ namespace Component
struct MeshId
{
uint64 id;
std::strong_ordering operator<=>(const MeshId& other) const
{
return id <=> other.id;
}
};
struct Meshlet
{
uint32 uniqueVertices[Gfx::numVerticesPerMeshlet]; // unique vertiex indices in the vertex data
uint8 primitiveLayout[Gfx::numPrimitivesPerMeshlet * 3]; // indices into the uniqueVertices array, only uint8 needed
uint32 numVertices;
uint32 numPrimitives;
};
class VertexData
{
@@ -44,9 +55,11 @@ public:
{
uint32 numMeshlets;
uint32 meshletOffset;
uint32 vertexOffset;
};
void resetMeshData();
void updateMesh(const Component::Transform& transform, const Component::Mesh& mesh);
void loadMesh(MeshId id, Array<Meshlet> meshlets);
void createDescriptors();
virtual MeshId allocateVertexData(uint64 numVertices) = 0;
virtual void bindBuffers(Gfx::PRenderCommand command) = 0;
@@ -57,7 +70,10 @@ public:
const Map<std::string, MaterialData>& getMaterialData() const { return materialData; }
const Array<MeshData>& getMeshData(MeshId id) { return meshData[id]; }
static List<VertexData*> getList();
virtual void init(Gfx::PGraphics graphics);
protected:
virtual void updateBuffers() = 0;
VertexData();
struct MeshletAABB
{
Vector min;
@@ -65,24 +81,26 @@ protected:
Vector max;
float pad1;
};
struct MeshletData
struct MeshletDescription
{
MeshletAABB boundingBox;
uint32_t vertexCount;
uint32_t primiticeCount;
uint32_t primitiveCount;
uint32_t vertexOffset;
uint32_t primitiveOffset;
};
Map<std::string, MaterialData> materialData;
Map<MeshId, Array<MeshData>> meshData;
Array<MeshletData> meshlets;
Gfx::PDescriptorLayout instanceDataLayout;
Array<MeshletDescription> meshlets;
Array<uint8> primitiveIndices;
Array<uint32> vertexIndices;
Gfx::PGraphics graphics;
Gfx::PDescriptorLayout instanceDataLayout;
// for mesh shading
Gfx::PShaderBuffer meshletBuffer;
// for legacy pipeline
Gfx::PIndexBuffer indexBuffer;
VertexData(Gfx::PGraphics graphics);
uint64 idCounter;
bool dirty;
};
}
src/Engine/Scene/LightEnvironment.cpp
+48 -3
View File
@@ -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
+6 -2
View File
@@ -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
+1 -54
View File
@@ -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;
}