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

Nothing works

Browse Source
This commit is contained in:
Dynamitos
2024-05-22 10:30:45 +02:00
parent 838bd69fa7
commit 321c97efe9
15 changed files with 129 additions and 196 deletions
Download Patch File Download Diff File Expand all files Collapse all files
res/shaders/LegacyPass.slang
+1 -1
View File
@@ -7,7 +7,7 @@ import Scene;
FragmentParameter vertexMain( FragmentParameter vertexMain(
VertexInput input VertexInput input
){ ){
InstanceData inst = pScene.instances[input.instanceId]; InstanceData inst = pScene.instances[pOffsets.instanceOffset + input.instanceId];
VertexAttributes attr = pVertexData.getAttributes(input.vertexId); VertexAttributes attr = pVertexData.getAttributes(input.vertexId);
return attr.getParameter(inst.transformMatrix); return attr.getParameter(inst.transformMatrix);
} }
res/shaders/MeshletPass.slang
+3 -2
View File
@@ -18,8 +18,9 @@ void meshMain(
out vertices FragmentParameter vertices[MAX_VERTICES], out vertices FragmentParameter vertices[MAX_VERTICES],
out indices uint3 indices[MAX_PRIMITIVES] out indices uint3 indices[MAX_PRIMITIVES]
){ ){
InstanceData inst = pScene.instances[meshPayload.instanceId]; InstanceData inst = meshPayload.instanceData;
MeshletDescription m = pScene.meshletInfos[pScene.culledMeshlets[meshPayload.cullingOffset + groupID]]; MeshData data = meshPayload.meshData;
MeshletDescription m = pScene.meshletInfos[data.meshletOffset + groupID];
SetMeshOutputCounts(m.vertexCount, m.primitiveCount); SetMeshOutputCounts(m.vertexCount, m.primitiveCount);
for(uint i = threadID; i < MAX_PRIMITIVES; i += MESH_GROUP_SIZE) for(uint i = threadID; i < MAX_PRIMITIVES; i += MESH_GROUP_SIZE)
res/shaders/ViewCullingTask.slang
+18 -15
View File
@@ -28,21 +28,24 @@ void taskMain(
viewFrustum.sides[1] = computePlane(origin, corners[1], corners[3]); viewFrustum.sides[1] = computePlane(origin, corners[1], corners[3]);
viewFrustum.sides[2] = computePlane(origin, corners[0], corners[1]); viewFrustum.sides[2] = computePlane(origin, corners[0], corners[1]);
viewFrustum.sides[3] = computePlane(origin, corners[3], corners[2]); viewFrustum.sides[3] = computePlane(origin, corners[3], corners[2]);
p.instanceId = pOffsets.instanceOffset + groupID; //p.instanceId = pOffsets.instanceOffset + groupID;
p.cullingOffset = pScene.cullingOffsets[pOffsets.cullingCounterOffset + groupID]; p.instanceData = instance;
p.meshData = mesh;
//p.cullingOffset = pScene.cullingOffsets[pOffsets.cullingCounterOffset + groupID];
} }
GroupMemoryBarrierWithGroupSync(); GroupMemoryBarrierWithGroupSync();
for(uint i = threadID; i < mesh.numMeshlets; i += TASK_GROUP_SIZE) //for(uint i = threadID; i < mesh.numMeshlets; i += TASK_GROUP_SIZE)
{ //{
uint m = mesh.meshletOffset + i; // uint m = mesh.meshletOffset + i;
MeshletDescription meshlet = pScene.meshletInfos[m]; // MeshletDescription meshlet = pScene.meshletInfos[m];
if(meshlet.bounding.insideFrustum(viewFrustum)) // //if(meshlet.bounding.insideFrustum(viewFrustum))
{ // {
uint index; // uint index;
InterlockedAdd(head, 1, index); // InterlockedAdd(head, 1, index);
pScene.culledMeshlets[p.cullingOffset + index] = m; // p.culledMeshlets[index] = m;
} // //pScene.culledMeshlets[p.cullingOffset + index] = m;
} // }
GroupMemoryBarrierWithGroupSync(); //}
DispatchMesh(head, 1, 1, p); //GroupMemoryBarrierWithGroupSync();
DispatchMesh(mesh.numMeshlets, 1, 1, p);
} }
res/shaders/lib/Scene.slang
+5 -5
View File
@@ -34,7 +34,6 @@ struct InstanceData
struct DrawCallOffsets struct DrawCallOffsets
{ {
uint32_t instanceOffset; uint32_t instanceOffset;
uint32_t cullingCounterOffset;
}; };
layout(push_constant) layout(push_constant)
ConstantBuffer<DrawCallOffsets> pOffsets; ConstantBuffer<DrawCallOffsets> pOffsets;
@@ -46,15 +45,16 @@ struct Scene
StructuredBuffer<MeshletDescription> meshletInfos; StructuredBuffer<MeshletDescription> meshletInfos;
StructuredBuffer<uint8_t> primitiveIndices; StructuredBuffer<uint8_t> primitiveIndices;
StructuredBuffer<uint32_t> vertexIndices; StructuredBuffer<uint32_t> vertexIndices;
StructuredBuffer<uint32_t> cullingOffsets; // StructuredBuffer<uint32_t> cullingOffsets;
RWStructuredBuffer<uint32_t> culledMeshlets; // RWStructuredBuffer<uint32_t> culledMeshlets;
}; };
layout(set=2) layout(set=2)
ParameterBlock<Scene> pScene; ParameterBlock<Scene> pScene;
struct MeshPayload struct MeshPayload
{ {
uint instanceId; InstanceData instanceData;
uint cullingOffset; MeshData meshData;
uint culledMeshlets[2048];
}; };
src/Engine/Graphics/Buffer.cpp
+1 -33
View File
@@ -44,51 +44,19 @@ IndexBuffer::~IndexBuffer()
} }
UniformBuffer::UniformBuffer(QueueFamilyMapping mapping, const DataSource& sourceData) UniformBuffer::UniformBuffer(QueueFamilyMapping mapping, const DataSource& sourceData)
: Buffer(mapping, sourceData.owner) : Buffer(mapping, sourceData.owner)
, contents(sourceData.size) {}
{
if (sourceData.data != nullptr)
{
std::memcpy(contents.data(), sourceData.data, contents.size());
}
}
UniformBuffer::~UniformBuffer() UniformBuffer::~UniformBuffer()
{ {
} }
bool UniformBuffer::updateContents(const DataSource& sourceData)
{
assert(contents.size() == sourceData.size);
if (std::memcmp(contents.data(), sourceData.data, contents.size()) == 0)
{
return false;
}
std::memcpy(contents.data(), sourceData.data, contents.size());
return true;
}
ShaderBuffer::ShaderBuffer(QueueFamilyMapping mapping, uint32 numElements, const DataSource& sourceData) ShaderBuffer::ShaderBuffer(QueueFamilyMapping mapping, uint32 numElements, const DataSource& sourceData)
: Buffer(mapping, sourceData.owner) : Buffer(mapping, sourceData.owner)
, contents(sourceData.size)
, numElements(numElements) , numElements(numElements)
{ {
if (sourceData.data != nullptr)
{
std::memcpy(contents.data(), sourceData.data, sourceData.size);
}
} }
ShaderBuffer::~ShaderBuffer() ShaderBuffer::~ShaderBuffer()
{ {
} }
void ShaderBuffer::updateContents(const ShaderBufferCreateInfo& createInfo)
{
contents.resize(createInfo.sourceData.size);
numElements = createInfo.numElements;
if (createInfo.sourceData.data != nullptr)
{
std::memcpy(contents.data(), createInfo.sourceData.data, createInfo.sourceData.size);
}
}
src/Engine/Graphics/Buffer.h
+4 -19
View File
@@ -64,25 +64,11 @@ class UniformBuffer : public Buffer {
public: public:
UniformBuffer(QueueFamilyMapping mapping, const DataSource &sourceData); UniformBuffer(QueueFamilyMapping mapping, const DataSource &sourceData);
virtual ~UniformBuffer(); virtual ~UniformBuffer();
// returns true if an update was performed, false if the old contents == new
// contents virtual void rotateBuffer(uint64 size) = 0;
virtual bool updateContents(const DataSource &sourceData); virtual void updateContents(const DataSource &sourceData) = 0;
bool isDataEquals(PUniformBuffer other) {
if (other == nullptr) {
return false;
}
if (contents.size() != other->contents.size()) {
return false;
}
if (std::memcmp(contents.data(), other->contents.data(), contents.size()) !=
0) {
return false;
}
return true;
}
protected: protected:
Array<uint8> contents;
// Inherited via QueueOwnedResource // Inherited via QueueOwnedResource
virtual void executeOwnershipBarrier(QueueType newOwner) = 0; virtual void executeOwnershipBarrier(QueueType newOwner) = 0;
virtual void executePipelineBarrier(SeAccessFlags srcAccess, virtual void executePipelineBarrier(SeAccessFlags srcAccess,
@@ -97,7 +83,7 @@ public:
const DataSource &bulkResourceData); const DataSource &bulkResourceData);
virtual ~ShaderBuffer(); virtual ~ShaderBuffer();
virtual void rotateBuffer(uint64 size) = 0; virtual void rotateBuffer(uint64 size) = 0;
virtual void updateContents(const ShaderBufferCreateInfo &sourceData); virtual void updateContents(const ShaderBufferCreateInfo &sourceData) = 0;
constexpr uint32 getNumElements() const { return numElements; } constexpr uint32 getNumElements() const { return numElements; }
virtual void *mapRegion(uint64 offset = 0, uint64 size = -1, virtual void *mapRegion(uint64 offset = 0, uint64 size = -1,
bool writeOnly = true) = 0; bool writeOnly = true) = 0;
@@ -111,7 +97,6 @@ protected:
SeAccessFlags dstAccess, SeAccessFlags dstAccess,
SePipelineStageFlags dstStage) = 0; SePipelineStageFlags dstStage) = 0;
Array<uint8> contents;
uint32 numElements; uint32 numElements;
}; };
DEFINE_REF(ShaderBuffer) DEFINE_REF(ShaderBuffer)
src/Engine/Graphics/RenderPass/BasePass.cpp
+12 -15
View File
@@ -33,7 +33,7 @@ BasePass::BasePass(Gfx::PGraphics graphics, PScene scene)
basePassLayout->addDescriptorLayout(lightCullingLayout); basePassLayout->addDescriptorLayout(lightCullingLayout);
basePassLayout->addPushConstants(Gfx::SePushConstantRange{ basePassLayout->addPushConstants(Gfx::SePushConstantRange{
.stageFlags = Gfx::SE_SHADER_STAGE_TASK_BIT_EXT, .stageFlags = Gfx::SE_SHADER_STAGE_TASK_BIT_EXT | Gfx::SE_SHADER_STAGE_VERTEX_BIT,
.offset = 0, .offset = 0,
.size = sizeof(VertexData::DrawCallOffsets), .size = sizeof(VertexData::DrawCallOffsets),
}); });
@@ -145,7 +145,7 @@ void BasePass::render()
pipelineInfo.renderPass = renderPass; pipelineInfo.renderPass = renderPass;
pipelineInfo.depthStencilState.depthCompareOp = Gfx::SE_COMPARE_OP_GREATER_OR_EQUAL; pipelineInfo.depthStencilState.depthCompareOp = Gfx::SE_COMPARE_OP_GREATER_OR_EQUAL;
pipelineInfo.multisampleState.samples = viewport->getSamples(); pipelineInfo.multisampleState.samples = viewport->getSamples();
pipelineInfo.colorBlend.attachmentCount = 1; pipelineInfo.colorBlend.attachmentCount = 2;
Gfx::PGraphicsPipeline pipeline = graphics->createGraphicsPipeline(std::move(pipelineInfo)); Gfx::PGraphicsPipeline pipeline = graphics->createGraphicsPipeline(std::move(pipelineInfo));
command->bindPipeline(pipeline); command->bindPipeline(pipeline);
} }
@@ -153,27 +153,24 @@ void BasePass::render()
command->bindDescriptor(viewParamsSet); command->bindDescriptor(viewParamsSet);
command->bindDescriptor(scene->getLightEnvironment()->getDescriptorSet()); command->bindDescriptor(scene->getLightEnvironment()->getDescriptorSet());
command->bindDescriptor(opaqueCulling); command->bindDescriptor(opaqueCulling);
command->bindDescriptor(vertexData->getInstanceDataSet());
for (const auto& drawCall : materialData.instances) for (const auto& drawCall : materialData.instances)
{ {
command->bindDescriptor(drawCall.materialInstance->getDescriptorSet());
command->bindDescriptor(vertexData->getInstanceDataSet()); command->bindDescriptor(vertexData->getInstanceDataSet());
command->pushConstants(Gfx::SE_SHADER_STAGE_TASK_BIT_EXT, 0, sizeof(VertexData::DrawCallOffsets), &drawCall.offsets); command->bindDescriptor(drawCall.materialInstance->getDescriptorSet());
command->pushConstants(Gfx::SE_SHADER_STAGE_TASK_BIT_EXT | Gfx::SE_SHADER_STAGE_VERTEX_BIT, 0, sizeof(VertexData::DrawCallOffsets), &drawCall.offsets);
if (graphics->supportMeshShading()) if (graphics->supportMeshShading())
{ {
command->drawMesh(drawCall.numMeshes, 1, 1); command->drawMesh(drawCall.instanceMeshData.size(), 1, 1);
} }
else else
{ {
//command->bindIndexBuffer(vertexData->getIndexBuffer()); command->bindIndexBuffer(vertexData->getIndexBuffer());
//uint32 instanceOffset = 0; for (const auto& meshData : drawCall.instanceMeshData)
//for (const auto& meshData : vertexData->getMeshData(instance.meshId)) {
//{ // all meshlets of a mesh share the same indices offset
// if (meshData.numIndices > 0) command->drawIndexed(meshData.numIndices, 1, meshData.firstIndex, vertexData->getIndicesOffset(meshData.meshletOffset), 0);
// { }
// command->drawIndexed(meshData.numIndices, 1, meshData.firstIndex, meshData.indicesOffset, instanceOffset);
// }
// instanceOffset++;
//}
} }
} }
commands.add(std::move(command)); commands.add(std::move(command));
src/Engine/Graphics/RenderPass/DepthPrepass.cpp
+9 -13
View File
@@ -19,7 +19,7 @@ DepthPrepass::DepthPrepass(Gfx::PGraphics graphics, PScene scene)
depthPrepassLayout = graphics->createPipelineLayout("DepthPrepassLayout"); depthPrepassLayout = graphics->createPipelineLayout("DepthPrepassLayout");
depthPrepassLayout->addDescriptorLayout(viewParamsLayout); depthPrepassLayout->addDescriptorLayout(viewParamsLayout);
depthPrepassLayout->addPushConstants(Gfx::SePushConstantRange{ depthPrepassLayout->addPushConstants(Gfx::SePushConstantRange{
.stageFlags = Gfx::SE_SHADER_STAGE_TASK_BIT_EXT, .stageFlags = Gfx::SE_SHADER_STAGE_TASK_BIT_EXT | Gfx::SE_SHADER_STAGE_VERTEX_BIT,
.offset = 0, .offset = 0,
.size = sizeof(VertexData::DrawCallOffsets), .size = sizeof(VertexData::DrawCallOffsets),
}); });
@@ -117,23 +117,19 @@ void DepthPrepass::render()
for (const auto& drawCall : materialData.instances) for (const auto& drawCall : materialData.instances)
{ {
command->bindDescriptor(vertexData->getInstanceDataSet()); command->bindDescriptor(vertexData->getInstanceDataSet());
command->pushConstants(Gfx::SE_SHADER_STAGE_TASK_BIT_EXT, 0, sizeof(VertexData::DrawCallOffsets), &drawCall.offsets); command->pushConstants(Gfx::SE_SHADER_STAGE_TASK_BIT_EXT | Gfx::SE_SHADER_STAGE_VERTEX_BIT, 0, sizeof(VertexData::DrawCallOffsets), &drawCall.offsets);
if (graphics->supportMeshShading()) if (graphics->supportMeshShading())
{ {
command->drawMesh(drawCall.numMeshes, 1, 1); command->drawMesh(drawCall.instanceMeshData.size(), 1, 1);
} }
else else
{ {
//command->bindIndexBuffer(vertexData->getIndexBuffer()); command->bindIndexBuffer(vertexData->getIndexBuffer());
//uint32 instanceOffset = 0; for (const auto& meshData : drawCall.instanceMeshData)
//for (const auto& meshData : vertexData->getMeshData(instance.meshId)) {
//{ // all meshlets of a mesh share the same indices offset
// if (meshData.numIndices > 0) command->drawIndexed(meshData.numIndices, 1, meshData.firstIndex, vertexData->getIndicesOffset(meshData.meshletOffset), 0);
// { }
// command->drawIndexed(meshData.numIndices, 1, meshData.firstIndex, meshData.indicesOffset, instanceOffset);
// }
// instanceOffset++;
//}
} }
} }
commands.add(std::move(command)); commands.add(std::move(command));
src/Engine/Graphics/RenderPass/RenderPass.cpp
+1
View File
@@ -38,6 +38,7 @@ void RenderPass::beginFrame(const Component::Camera& cam)
.size = sizeof(ViewParameter), .size = sizeof(ViewParameter),
.data = (uint8*)&viewParams, .data = (uint8*)&viewParams,
}; };
viewParamsBuffer->rotateBuffer(sizeof(ViewParameter));
viewParamsBuffer->updateContents(uniformUpdate); viewParamsBuffer->updateContents(uniformUpdate);
viewParamsBuffer->pipelineBarrier( viewParamsBuffer->pipelineBarrier(
Gfx::SE_ACCESS_TRANSFER_WRITE_BIT, Gfx::SE_ACCESS_TRANSFER_WRITE_BIT,
src/Engine/Graphics/VertexData.cpp
+54 -55
View File
@@ -18,7 +18,7 @@ void VertexData::resetMeshData()
std::unique_lock l(materialDataLock); std::unique_lock l(materialDataLock);
for (auto& mat : materialData) for (auto& mat : materialData)
{ {
for (auto inst : mat.instances) for (auto& inst : mat.instances)
{ {
inst.instanceData.clear(); inst.instanceData.clear();
inst.instanceMeshData.clear(); inst.instanceMeshData.clear();
@@ -51,15 +51,15 @@ void VertexData::updateMesh(PMesh mesh, Component::Transform& transform)
matData.instances.resize(referencedInstance->getId() + 1); matData.instances.resize(referencedInstance->getId() + 1);
} }
BatchedDrawCall& matInstanceData = matData.instances[referencedInstance->getId()]; BatchedDrawCall& matInstanceData = matData.instances[referencedInstance->getId()];
const auto& data = meshData[mesh->id]; matInstanceData.materialInstance = referencedInstance;
Matrix4 transformMatrix = transform.toMatrix() * mesh->transform; Matrix4 transformMatrix = transform.toMatrix() * mesh->transform;
matInstanceData.instanceData.add(InstanceData{ matInstanceData.instanceData.add(InstanceData{
.transformMatrix = transformMatrix, .transformMatrix = transformMatrix,
.inverseTransformMatrix = glm::inverse(transformMatrix), .inverseTransformMatrix = glm::inverse(transformMatrix),
}); });
const auto& data = meshData[mesh->id];
matInstanceData.instanceMeshData.add(data); matInstanceData.instanceMeshData.add(data);
matInstanceData.numMeshes++;
for (size_t i = 0; i < 0; ++i) for (size_t i = 0; i < 0; ++i)
{ {
auto bounding = meshlets[data.meshletOffset + i].bounding; auto bounding = meshlets[data.meshletOffset + i].bounding;
@@ -100,7 +100,6 @@ void VertexData::updateMesh(PMesh mesh, Component::Transform& transform)
addDebugVertex(DebugVertex{ .position = corners[7], .color = meshlets[data.meshletOffset + i].color }); addDebugVertex(DebugVertex{ .position = corners[7], .color = meshlets[data.meshletOffset + i].color });
} }
matInstanceData.materialInstance = referencedInstance;
referencedInstance->updateDescriptor(); referencedInstance->updateDescriptor();
} }
@@ -111,53 +110,52 @@ void VertexData::createDescriptors()
instanceData.clear(); instanceData.clear();
instanceMeshData.clear(); instanceMeshData.clear();
uint32 numMeshlets = 0; //uint32 numMeshlets = 0;
Array<uint32> cullingOffsets; //Array<uint32> cullingOffsets;
for (auto& mat : materialData) for (auto& mat : materialData)
{ {
for (auto& instance : mat.instances) for (auto& instance : mat.instances)
{ {
instance.offsets.instanceOffset = instanceData.size(); instance.offsets.instanceOffset = instanceData.size();
instance.offsets.cullingCounterOffset = cullingOffsets.size(); //instance.offsets.cullingCounterOffset = cullingOffsets.size();
instance.numMeshes = instance.instanceData.size(); //instance.numMeshlets = 0;
instance.numMeshlets = 0;
for (size_t i = 0; i < instance.instanceData.size(); ++i) for (size_t i = 0; i < instance.instanceData.size(); ++i)
{ {
instanceData.add(instance.instanceData[i]); instanceData.add(instance.instanceData[i]);
instanceMeshData.add(instance.instanceMeshData[i]); instanceMeshData.add(instance.instanceMeshData[i]);
instance.numMeshlets += instance.instanceMeshData[i].numMeshlets; //instance.numMeshlets += instance.instanceMeshData[i].numMeshlets;
cullingOffsets.add(numMeshlets); //cullingOffsets.add(numMeshlets);
numMeshlets += instance.numMeshlets; //numMeshlets += instance.numMeshlets;
} }
} }
} }
cullingOffsetBuffer->rotateBuffer(cullingOffsets.size() * sizeof(uint32)); //cullingOffsetBuffer->rotateBuffer(cullingOffsets.size() * sizeof(uint32));
cullingOffsetBuffer->updateContents(ShaderBufferCreateInfo{ //cullingOffsetBuffer->updateContents(ShaderBufferCreateInfo{
.sourceData = { // .sourceData = {
.size = cullingOffsets.size() * sizeof(uint32), // .size = cullingOffsets.size() * sizeof(uint32),
.data = (uint8*)cullingOffsets.data(), // .data = (uint8*)cullingOffsets.data(),
}, // },
.numElements = cullingOffsets.size() // .numElements = cullingOffsets.size()
}); // });
cullingOffsetBuffer->pipelineBarrier( //cullingOffsetBuffer->pipelineBarrier(
Gfx::SE_ACCESS_TRANSFER_WRITE_BIT, // Gfx::SE_ACCESS_TRANSFER_WRITE_BIT,
Gfx::SE_PIPELINE_STAGE_TRANSFER_BIT, // Gfx::SE_PIPELINE_STAGE_TRANSFER_BIT,
Gfx::SE_ACCESS_MEMORY_READ_BIT, // Gfx::SE_ACCESS_MEMORY_READ_BIT,
Gfx::SE_PIPELINE_STAGE_TASK_SHADER_BIT_EXT // Gfx::SE_PIPELINE_STAGE_TOP_OF_PIPE_BIT
); //);
cullingBuffer->rotateBuffer(numMeshlets * sizeof(uint32)); //cullingBuffer->rotateBuffer(numMeshlets * sizeof(uint32));
cullingBuffer->updateContents(ShaderBufferCreateInfo{ //cullingBuffer->updateContents(ShaderBufferCreateInfo{
.sourceData = { // .sourceData = {
.size = numMeshlets * sizeof(uint32), // .size = numMeshlets * sizeof(uint32),
}, // },
.numElements = numMeshlets // .numElements = numMeshlets
}); // });
cullingBuffer->pipelineBarrier( //cullingBuffer->pipelineBarrier(
Gfx::SE_ACCESS_TRANSFER_WRITE_BIT, // Gfx::SE_ACCESS_TRANSFER_WRITE_BIT,
Gfx::SE_PIPELINE_STAGE_TRANSFER_BIT, // Gfx::SE_PIPELINE_STAGE_TRANSFER_BIT,
Gfx::SE_ACCESS_MEMORY_WRITE_BIT, // Gfx::SE_ACCESS_MEMORY_WRITE_BIT,
Gfx::SE_PIPELINE_STAGE_MESH_SHADER_BIT_EXT // Gfx::SE_PIPELINE_STAGE_TOP_OF_PIPE_BIT
); //);
instanceBuffer->rotateBuffer(instanceData.size() * sizeof(InstanceData)); instanceBuffer->rotateBuffer(instanceData.size() * sizeof(InstanceData));
instanceBuffer->updateContents(ShaderBufferCreateInfo{ instanceBuffer->updateContents(ShaderBufferCreateInfo{
.sourceData = { .sourceData = {
@@ -170,7 +168,7 @@ void VertexData::createDescriptors()
Gfx::SE_ACCESS_TRANSFER_WRITE_BIT, Gfx::SE_ACCESS_TRANSFER_WRITE_BIT,
Gfx::SE_PIPELINE_STAGE_TRANSFER_BIT, Gfx::SE_PIPELINE_STAGE_TRANSFER_BIT,
Gfx::SE_ACCESS_MEMORY_READ_BIT, Gfx::SE_ACCESS_MEMORY_READ_BIT,
Gfx::SE_PIPELINE_STAGE_VERTEX_SHADER_BIT | Gfx::SE_PIPELINE_STAGE_TASK_SHADER_BIT_EXT Gfx::SE_PIPELINE_STAGE_TOP_OF_PIPE_BIT
); );
instanceMeshDataBuffer->rotateBuffer(sizeof(MeshData) * instanceMeshData.size()); instanceMeshDataBuffer->rotateBuffer(sizeof(MeshData) * instanceMeshData.size());
@@ -185,7 +183,7 @@ void VertexData::createDescriptors()
Gfx::SE_ACCESS_TRANSFER_WRITE_BIT, Gfx::SE_ACCESS_TRANSFER_WRITE_BIT,
Gfx::SE_PIPELINE_STAGE_TRANSFER_BIT, Gfx::SE_PIPELINE_STAGE_TRANSFER_BIT,
Gfx::SE_ACCESS_MEMORY_READ_BIT, Gfx::SE_ACCESS_MEMORY_READ_BIT,
Gfx::SE_PIPELINE_STAGE_VERTEX_SHADER_BIT | Gfx::SE_PIPELINE_STAGE_TASK_SHADER_BIT_EXT Gfx::SE_PIPELINE_STAGE_TOP_OF_PIPE_BIT
); );
instanceDataLayout->reset(); instanceDataLayout->reset();
descriptorSet = instanceDataLayout->allocateDescriptorSet(); descriptorSet = instanceDataLayout->allocateDescriptorSet();
@@ -194,14 +192,15 @@ void VertexData::createDescriptors()
descriptorSet->updateBuffer(2, meshletBuffer); descriptorSet->updateBuffer(2, meshletBuffer);
descriptorSet->updateBuffer(3, primitiveIndicesBuffer); descriptorSet->updateBuffer(3, primitiveIndicesBuffer);
descriptorSet->updateBuffer(4, vertexIndicesBuffer); descriptorSet->updateBuffer(4, vertexIndicesBuffer);
descriptorSet->updateBuffer(5, cullingOffsetBuffer); //descriptorSet->updateBuffer(5, cullingOffsetBuffer);
descriptorSet->updateBuffer(6, cullingBuffer); //descriptorSet->updateBuffer(6, cullingBuffer);
descriptorSet->writeChanges(); descriptorSet->writeChanges();
} }
void VertexData::loadMesh(MeshId id, Array<uint32> loadedIndices, Array<Meshlet> loadedMeshlets) void VertexData::loadMesh(MeshId id, Array<uint32> loadedIndices, Array<Meshlet> loadedMeshlets)
{ {
assert(loadedMeshlets.size() < 2048);
std::unique_lock l(vertexDataLock); std::unique_lock l(vertexDataLock);
meshlets.reserve(meshlets.size() + loadedMeshlets.size()); meshlets.reserve(meshlets.size() + loadedMeshlets.size());
vertexIndices.reserve(vertexIndices.size() + loadedMeshlets.size() * Gfx::numVerticesPerMeshlet); vertexIndices.reserve(vertexIndices.size() + loadedMeshlets.size() * Gfx::numVerticesPerMeshlet);
@@ -232,10 +231,10 @@ void VertexData::loadMesh(MeshId id, Array<uint32> loadedIndices, Array<Meshlet>
.bounding = meshAABB,//.toSphere(), .bounding = meshAABB,//.toSphere(),
.numMeshlets = (uint32)loadedMeshlets.size(), .numMeshlets = (uint32)loadedMeshlets.size(),
.meshletOffset = meshletOffset, .meshletOffset = meshletOffset,
.firstIndex = (uint32)indices.size(),
.numIndices = (uint32)loadedIndices.size(),
}; };
meshData[id].firstIndex = indices.size();
meshData[id].numIndices = loadedIndices.size();
if (!graphics->supportMeshShading()) if (!graphics->supportMeshShading())
{ {
indices.resize(indices.size() + loadedIndices.size()); indices.resize(indices.size() + loadedIndices.size());
@@ -340,18 +339,18 @@ void VertexData::init(Gfx::PGraphics _graphics)
// vertexIndices // vertexIndices
instanceDataLayout->addDescriptorBinding(Gfx::DescriptorBinding{ .binding = 4, .descriptorType = Gfx::SE_DESCRIPTOR_TYPE_STORAGE_BUFFER }); instanceDataLayout->addDescriptorBinding(Gfx::DescriptorBinding{ .binding = 4, .descriptorType = Gfx::SE_DESCRIPTOR_TYPE_STORAGE_BUFFER });
// cullingList // cullingList
instanceDataLayout->addDescriptorBinding(Gfx::DescriptorBinding{ .binding = 5, .descriptorType = Gfx::SE_DESCRIPTOR_TYPE_STORAGE_BUFFER }); //instanceDataLayout->addDescriptorBinding(Gfx::DescriptorBinding{ .binding = 5, .descriptorType = Gfx::SE_DESCRIPTOR_TYPE_STORAGE_BUFFER });
// cullingOffset // cullingOffset
instanceDataLayout->addDescriptorBinding(Gfx::DescriptorBinding{ .binding = 6, .descriptorType = Gfx::SE_DESCRIPTOR_TYPE_STORAGE_BUFFER }); //instanceDataLayout->addDescriptorBinding(Gfx::DescriptorBinding{ .binding = 6, .descriptorType = Gfx::SE_DESCRIPTOR_TYPE_STORAGE_BUFFER });
cullingOffsetBuffer = graphics->createShaderBuffer(ShaderBufferCreateInfo{ //cullingOffsetBuffer = graphics->createShaderBuffer(ShaderBufferCreateInfo{
.dynamic = true, // .dynamic = true,
.name = "MeshletOffset", // .name = "MeshletOffset",
}); // });
cullingBuffer = graphics->createShaderBuffer(ShaderBufferCreateInfo{ //cullingBuffer = graphics->createShaderBuffer(ShaderBufferCreateInfo{
.dynamic = true, // .dynamic = true,
.name = "MeshletCulling", // .name = "MeshletCulling",
}); // });
instanceBuffer = graphics->createShaderBuffer(ShaderBufferCreateInfo{ instanceBuffer = graphics->createShaderBuffer(ShaderBufferCreateInfo{
.dynamic = true, .dynamic = true,
.name = "InstanceBuffer", .name = "InstanceBuffer",
src/Engine/Graphics/VertexData.h
+3 -5
View File
@@ -44,13 +44,10 @@ public:
struct DrawCallOffsets struct DrawCallOffsets
{ {
uint32 instanceOffset = 0; uint32 instanceOffset = 0;
uint32 cullingCounterOffset = 0;
}; };
struct BatchedDrawCall struct BatchedDrawCall
{ {
PMaterialInstance materialInstance; PMaterialInstance materialInstance;
uint64 numMeshes = 0;
uint64 numMeshlets = 0;
DrawCallOffsets offsets; DrawCallOffsets offsets;
Array<InstanceData> instanceData; Array<InstanceData> instanceData;
Array<MeshData> instanceMeshData; Array<MeshData> instanceMeshData;
@@ -78,6 +75,7 @@ public:
Gfx::PDescriptorSet getInstanceDataSet() { return descriptorSet; } Gfx::PDescriptorSet getInstanceDataSet() { return descriptorSet; }
const Array<MaterialData>& getMaterialData() const { return materialData; } const Array<MaterialData>& getMaterialData() const { return materialData; }
const MeshData& getMeshData(MeshId id) { return meshData[id]; } const MeshData& getMeshData(MeshId id) { return meshData[id]; }
uint64 getIndicesOffset(uint32 meshletIndex) { return meshlets[meshletIndex].indicesOffset; }
static List<VertexData*> getList(); static List<VertexData*> getList();
static VertexData* findByTypeName(std::string name); static VertexData* findByTypeName(std::string name);
virtual void init(Gfx::PGraphics graphics); virtual void init(Gfx::PGraphics graphics);
@@ -113,8 +111,8 @@ protected:
Gfx::OShaderBuffer vertexIndicesBuffer; Gfx::OShaderBuffer vertexIndicesBuffer;
Gfx::OShaderBuffer primitiveIndicesBuffer; Gfx::OShaderBuffer primitiveIndicesBuffer;
// temporary meshlet culling buffer, passed from task to mesh shader // temporary meshlet culling buffer, passed from task to mesh shader
Gfx::OShaderBuffer cullingBuffer; //Gfx::OShaderBuffer cullingBuffer;
Gfx::OShaderBuffer cullingOffsetBuffer; //Gfx::OShaderBuffer cullingOffsetBuffer;
// for legacy pipeline // for legacy pipeline
Gfx::OIndexBuffer indexBuffer; Gfx::OIndexBuffer indexBuffer;
// Material data // Material data
src/Engine/Graphics/Vulkan/Buffer.cpp
+8 -8
View File
@@ -222,6 +222,7 @@ void Buffer::unmap() {
} }
void Buffer::rotateBuffer(uint64 size) { void Buffer::rotateBuffer(uint64 size) {
assert(dynamic);
size = std::max(getSize(), size); size = std::max(getSize(), size);
for (size_t i = 0; i < buffers.size(); ++i) { for (size_t i = 0; i < buffers.size(); ++i) {
if (buffers[i]->isCurrentlyBound()) { if (buffers[i]->isCurrentlyBound()) {
@@ -316,15 +317,15 @@ UniformBuffer::UniformBuffer(PGraphics graphics,
UniformBuffer::~UniformBuffer() {} UniformBuffer::~UniformBuffer() {}
bool UniformBuffer::updateContents(const DataSource &sourceData) { void UniformBuffer::updateContents(const DataSource &sourceData) {
if (!Gfx::UniformBuffer::updateContents(sourceData)) {
// no update was performed, skip
return false;
}
void *data = map(); void *data = map();
std::memcpy(data, sourceData.data, sourceData.size); std::memcpy(data, sourceData.data, sourceData.size);
unmap(); unmap();
return true; }
void UniformBuffer::rotateBuffer(uint64 size)
{
Vulkan::Buffer::rotateBuffer(size);
} }
void UniformBuffer::requestOwnershipTransfer(Gfx::QueueType newOwner) { void UniformBuffer::requestOwnershipTransfer(Gfx::QueueType newOwner) {
@@ -368,11 +369,10 @@ ShaderBuffer::ShaderBuffer(PGraphics graphics,
ShaderBuffer::~ShaderBuffer() {} ShaderBuffer::~ShaderBuffer() {}
void ShaderBuffer::updateContents(const ShaderBufferCreateInfo &createInfo) { void ShaderBuffer::updateContents(const ShaderBufferCreateInfo &createInfo) {
Gfx::ShaderBuffer::updateContents(createInfo);
// We always want to update, as the contents could be different on the GPU
if (createInfo.sourceData.data == nullptr) { if (createInfo.sourceData.data == nullptr) {
return; return;
} }
// We always want to update, as the contents could be different on the GPU
void *data = map(); void *data = map();
std::memcpy((char*)data + createInfo.sourceData.offset, createInfo.sourceData.data, createInfo.sourceData.size); std::memcpy((char*)data + createInfo.sourceData.offset, createInfo.sourceData.data, createInfo.sourceData.size);
unmap(); unmap();
src/Engine/Graphics/Vulkan/Buffer.h
+2 -1
View File
@@ -103,7 +103,8 @@ class UniformBuffer : public Gfx::UniformBuffer, public Buffer {
public: public:
UniformBuffer(PGraphics graphics, const UniformBufferCreateInfo &sourceData); UniformBuffer(PGraphics graphics, const UniformBufferCreateInfo &sourceData);
virtual ~UniformBuffer(); virtual ~UniformBuffer();
virtual bool updateContents(const DataSource &sourceData) override; virtual void updateContents(const DataSource &sourceData) override;
virtual void rotateBuffer(uint64 size) override;
protected: protected:
// Inherited via Vulkan::Buffer // Inherited via Vulkan::Buffer
src/Engine/Graphics/Vulkan/Graphics.cpp
+2 -2
View File
@@ -399,7 +399,7 @@ void Graphics::initInstance(GraphicsInitializer initInfo)
.applicationVersion = VK_MAKE_VERSION(0, 0, 1), .applicationVersion = VK_MAKE_VERSION(0, 0, 1),
.pEngineName = initInfo.engineName, .pEngineName = initInfo.engineName,
.engineVersion = VK_MAKE_VERSION(0, 0, 1), .engineVersion = VK_MAKE_VERSION(0, 0, 1),
.apiVersion = VK_API_VERSION_1_2, .apiVersion = VK_API_VERSION_1_3,
}; };
Array<const char*> extensions = getRequiredExtensions(); Array<const char*> extensions = getRequiredExtensions();
@@ -496,7 +496,7 @@ void Graphics::pickPhysicalDevice()
{ {
if (std::strcmp(VK_EXT_MESH_SHADER_EXTENSION_NAME, extensionProps[i].extensionName) == 0) if (std::strcmp(VK_EXT_MESH_SHADER_EXTENSION_NAME, extensionProps[i].extensionName) == 0)
{ {
meshShadingEnabled = true; //meshShadingEnabled = true;
break; break;
} }
} }
src/Engine/Graphics/Vulkan/PipelineCache.cpp
+5 -21
View File
@@ -50,8 +50,12 @@ PipelineCache::~PipelineCache()
PGraphicsPipeline PipelineCache::createPipeline(Gfx::LegacyPipelineCreateInfo gfxInfo) PGraphicsPipeline PipelineCache::createPipeline(Gfx::LegacyPipelineCreateInfo gfxInfo)
{ {
uint32 hash = CRC::Calculate(&gfxInfo, sizeof(Gfx::LegacyPipelineCreateInfo), CRC::CRC_32());
if (graphicsPipelines.contains(hash))
{
return graphicsPipelines[hash];
}
PPipelineLayout layout = Gfx::PPipelineLayout(gfxInfo.pipelineLayout).cast<PipelineLayout>(); PPipelineLayout layout = Gfx::PPipelineLayout(gfxInfo.pipelineLayout).cast<PipelineLayout>();
uint32 hash = layout->getHash();
Array<VkVertexInputBindingDescription> bindings; Array<VkVertexInputBindingDescription> bindings;
Array<VkVertexInputAttributeDescription> attributes; Array<VkVertexInputAttributeDescription> attributes;
if (gfxInfo.vertexInput != nullptr) if (gfxInfo.vertexInput != nullptr)
@@ -74,8 +78,6 @@ PGraphicsPipeline PipelineCache::createPipeline(Gfx::LegacyPipelineCreateInfo gf
.offset = a.offset, .offset = a.offset,
}; };
} }
hash = CRC::Calculate(bindings.data(), sizeof(VkVertexInputBindingDescription) * bindings.size(), CRC::CRC_32(), hash);
hash = CRC::Calculate(attributes.data(), sizeof(VkVertexInputAttributeDescription) * attributes.size(), CRC::CRC_32(), hash);
} }
VkPipelineVertexInputStateCreateInfo vertexInput = { VkPipelineVertexInputStateCreateInfo vertexInput = {
.sType = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO, .sType = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO,
@@ -116,7 +118,6 @@ PGraphicsPipeline PipelineCache::createPipeline(Gfx::LegacyPipelineCreateInfo gf
.pSpecializationInfo = nullptr, .pSpecializationInfo = nullptr,
}; };
} }
hash = CRC::Calculate(stageInfos, sizeof(stageInfos), CRC::CRC_32(), hash);
VkPipelineInputAssemblyStateCreateInfo assemblyInfo = { VkPipelineInputAssemblyStateCreateInfo assemblyInfo = {
.sType = VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO, .sType = VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO,
.pNext = nullptr, .pNext = nullptr,
@@ -124,7 +125,6 @@ PGraphicsPipeline PipelineCache::createPipeline(Gfx::LegacyPipelineCreateInfo gf
.topology = cast(gfxInfo.topology), .topology = cast(gfxInfo.topology),
.primitiveRestartEnable = false, .primitiveRestartEnable = false,
}; };
hash = CRC::Calculate(&assemblyInfo, sizeof(assemblyInfo), CRC::CRC_32(), hash);
VkPipelineViewportStateCreateInfo viewportInfo = { VkPipelineViewportStateCreateInfo viewportInfo = {
.sType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO, .sType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO,
.pNext = nullptr, .pNext = nullptr,
@@ -134,7 +134,6 @@ PGraphicsPipeline PipelineCache::createPipeline(Gfx::LegacyPipelineCreateInfo gf
.scissorCount = 1, .scissorCount = 1,
.pScissors = nullptr, .pScissors = nullptr,
}; };
hash = CRC::Calculate(&viewportInfo, sizeof(viewportInfo), CRC::CRC_32(), hash);
VkPipelineRasterizationStateCreateInfo rasterizationState = { VkPipelineRasterizationStateCreateInfo rasterizationState = {
.sType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO, .sType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO,
.pNext = nullptr, .pNext = nullptr,
@@ -150,8 +149,6 @@ PGraphicsPipeline PipelineCache::createPipeline(Gfx::LegacyPipelineCreateInfo gf
.depthBiasSlopeFactor = gfxInfo.rasterizationState.depthBiasSlopeFactor, .depthBiasSlopeFactor = gfxInfo.rasterizationState.depthBiasSlopeFactor,
.lineWidth = gfxInfo.rasterizationState.lineWidth, .lineWidth = gfxInfo.rasterizationState.lineWidth,
}; };
hash = CRC::Calculate(&rasterizationState, sizeof(rasterizationState), CRC::CRC_32(), hash);
VkPipelineMultisampleStateCreateInfo multisampleState = { VkPipelineMultisampleStateCreateInfo multisampleState = {
.sType = VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO, .sType = VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO,
.pNext = nullptr, .pNext = nullptr,
@@ -162,8 +159,6 @@ PGraphicsPipeline PipelineCache::createPipeline(Gfx::LegacyPipelineCreateInfo gf
.alphaToCoverageEnable = gfxInfo.multisampleState.alphaCoverageEnable, .alphaToCoverageEnable = gfxInfo.multisampleState.alphaCoverageEnable,
.alphaToOneEnable = gfxInfo.multisampleState.alphaToOneEnable, .alphaToOneEnable = gfxInfo.multisampleState.alphaToOneEnable,
}; };
hash = CRC::Calculate(&multisampleState, sizeof(multisampleState), CRC::CRC_32(), hash);
VkPipelineDepthStencilStateCreateInfo depthStencilState = { VkPipelineDepthStencilStateCreateInfo depthStencilState = {
.sType = VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO, .sType = VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO,
.pNext = nullptr, .pNext = nullptr,
@@ -177,8 +172,6 @@ PGraphicsPipeline PipelineCache::createPipeline(Gfx::LegacyPipelineCreateInfo gf
.minDepthBounds = gfxInfo.depthStencilState.minDepthBounds, .minDepthBounds = gfxInfo.depthStencilState.minDepthBounds,
.maxDepthBounds = gfxInfo.depthStencilState.maxDepthBounds, .maxDepthBounds = gfxInfo.depthStencilState.maxDepthBounds,
}; };
hash = CRC::Calculate(&depthStencilState, sizeof(depthStencilState), CRC::CRC_32(), hash);
Array<VkPipelineColorBlendAttachmentState> blendAttachments; Array<VkPipelineColorBlendAttachmentState> blendAttachments;
for(uint32 i = 0; i < gfxInfo.colorBlend.attachmentCount; ++i) for(uint32 i = 0; i < gfxInfo.colorBlend.attachmentCount; ++i)
{ {
@@ -194,8 +187,6 @@ PGraphicsPipeline PipelineCache::createPipeline(Gfx::LegacyPipelineCreateInfo gf
.colorWriteMask = attachment.colorWriteMask, .colorWriteMask = attachment.colorWriteMask,
}; };
} }
hash = CRC::Calculate(blendAttachments.data(), blendAttachments.size() * sizeof(VkPipelineColorBlendAttachmentState), CRC::CRC_32(), hash);
VkPipelineColorBlendStateCreateInfo blendState = { VkPipelineColorBlendStateCreateInfo blendState = {
.sType = VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO, .sType = VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO,
.pNext = nullptr, .pNext = nullptr,
@@ -206,13 +197,11 @@ PGraphicsPipeline PipelineCache::createPipeline(Gfx::LegacyPipelineCreateInfo gf
.pAttachments = blendAttachments.data(), .pAttachments = blendAttachments.data(),
}; };
std::memcpy(blendState.blendConstants, gfxInfo.colorBlend.blendConstants.data(), sizeof(blendState.blendConstants)); std::memcpy(blendState.blendConstants, gfxInfo.colorBlend.blendConstants.data(), sizeof(blendState.blendConstants));
hash = CRC::Calculate(&blendState, sizeof(blendState), CRC::CRC_32(), hash);
uint32 numDynamicEnabled = 0; uint32 numDynamicEnabled = 0;
StaticArray<VkDynamicState, 2> dynamicEnabled; StaticArray<VkDynamicState, 2> dynamicEnabled;
dynamicEnabled[numDynamicEnabled++] = VK_DYNAMIC_STATE_VIEWPORT; dynamicEnabled[numDynamicEnabled++] = VK_DYNAMIC_STATE_VIEWPORT;
dynamicEnabled[numDynamicEnabled++] = VK_DYNAMIC_STATE_SCISSOR; dynamicEnabled[numDynamicEnabled++] = VK_DYNAMIC_STATE_SCISSOR;
hash = CRC::Calculate(dynamicEnabled.data(), dynamicEnabled.size() * sizeof(VkDynamicState), CRC::CRC_32(), hash);
VkPipelineDynamicStateCreateInfo dynamicState = { VkPipelineDynamicStateCreateInfo dynamicState = {
.sType = VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO, .sType = VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO,
@@ -221,11 +210,6 @@ PGraphicsPipeline PipelineCache::createPipeline(Gfx::LegacyPipelineCreateInfo gf
.dynamicStateCount = (uint32)dynamicEnabled.size(), .dynamicStateCount = (uint32)dynamicEnabled.size(),
.pDynamicStates = dynamicEnabled.data(), .pDynamicStates = dynamicEnabled.data(),
}; };
if (graphicsPipelines.contains(hash))
{
return graphicsPipelines[hash];
}
VkPipeline pipelineHandle; VkPipeline pipelineHandle;
VkGraphicsPipelineCreateInfo createInfo = { VkGraphicsPipelineCreateInfo createInfo = {