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

Refactor ShaderBuffer

Browse Source
This commit is contained in:
Dynamitos
2023-08-28 21:23:13 +02:00
parent dcbce27fb2
commit fcc4fc12d4
35 changed files with 99 additions and 564 deletions
Download Patch File Download Diff File Expand all files Collapse all files
.gitmodules
-3
View File
@@ -10,9 +10,6 @@
[submodule "external/assimp"]
path = external/assimp
url = https://github.com/assimp/assimp.git
[submodule "external/SPIRV-Cross"]
path = external/SPIRV-Cross
url = https://github.com/KhronosGroup/SPIRV-Cross.git
[submodule "external/stb"]
path = external/stb
url = https://github.com/nothings/stb
external/SPIRV-Cross
Vendored
-1
Submodule external/SPIRV-Cross deleted from ea3cd74426
res/shaders/ComputeFrustums.slang
+1 -1
View File
@@ -17,7 +17,7 @@ cbuffer DispatchParams
uint pad1;
}
layout(set = 0, binding = 2, std430)
RWStructuredBuffer<Frustum> out_Frustums;
RWShaderBuffer<Frustum> out_Frustums;
[numthreads(BLOCK_SIZE, BLOCK_SIZE, 1)]
res/shaders/ForwardPlus.slang
+1 -1
View File
@@ -8,7 +8,7 @@ import PrimitiveSceneData;
import MaterialParameter;
layout(set = INDEX_LIGHT_ENV, binding = 4)
StructuredBuffer<uint> lightIndexList;
ShaderBuffer<uint> lightIndexList;
layout(set = INDEX_LIGHT_ENV, binding = 5)
RWTexture2D<uint2> lightGrid;
res/shaders/LightCulling.slang
+5 -5
View File
@@ -21,14 +21,14 @@ layout(set = INDEX_VIEW_PARAMS, binding = 2)
Texture2D depthTextureVS;
layout(set = INDEX_VIEW_PARAMS, binding = 3)
globallycoherent RWStructuredBuffer<uint> oLightIndexCounter;
globallycoherent RWShaderBuffer<uint> oLightIndexCounter;
layout(set = INDEX_VIEW_PARAMS, binding = 4)
globallycoherent RWStructuredBuffer<uint> tLightIndexCounter;
globallycoherent RWShaderBuffer<uint> tLightIndexCounter;
layout(set = INDEX_VIEW_PARAMS, binding = 5)
RWStructuredBuffer<uint> oLightIndexList;
RWShaderBuffer<uint> oLightIndexList;
layout(set = INDEX_VIEW_PARAMS, binding = 6)
RWStructuredBuffer<uint> tLightIndexList;
RWShaderBuffer<uint> tLightIndexList;
layout(set = INDEX_VIEW_PARAMS, binding = 7)
RWTexture2D<uint2> oLightGrid;
@@ -36,7 +36,7 @@ layout(set = INDEX_VIEW_PARAMS, binding = 8)
RWTexture2D<uint2> tLightGrid;
layout(set = INDEX_VIEW_PARAMS, binding = 9)
StructuredBuffer<Frustum> frustums;
ShaderBuffer<Frustum> frustums;
// Debug
//layout(set = INDEX_VIEW_PARAMS, binding = 10)
res/shaders/TextPass.slang
+1 -1
View File
@@ -17,7 +17,7 @@ ConstantBuffer<ViewData> viewData;
layout(set = 0, binding = 1)
SamplerState glyphSampler;
//layout(set = 1)
//StructuredBuffer<GlyphData> glyphData;
//ShaderBuffer<GlyphData> glyphData;
layout(set = 1)
Texture2D<uint> glyphTextures[];
layout(push_constant)
res/shaders/lib/LightEnv.slang
+2 -2
View File
@@ -62,10 +62,10 @@ struct PointLight : ILightEnv
};
layout(set = INDEX_LIGHT_ENV, binding = 0, std430)
StructuredBuffer<DirectionalLight> directionalLights;
ShaderBuffer<DirectionalLight> directionalLights;
layout(set = INDEX_LIGHT_ENV, binding = 1, std430)
ConstantBuffer<uint> numDirectionalLights;
layout(set = INDEX_LIGHT_ENV, binding = 2, std430)
StructuredBuffer<PointLight> pointLights;
ShaderBuffer<PointLight> pointLights;
layout(set = INDEX_LIGHT_ENV, binding = 3, std430)
ConstantBuffer<uint> numPointLights;
res/shaders/lib/PrimitiveSceneData.slang
+1 -1
View File
@@ -6,7 +6,7 @@ struct PrimitiveSceneData
};
layout(set = INDEX_SCENE_DATA, binding = 0, std430)
StructuredBuffer<PrimitiveSceneData> gSceneData;
ShaderBuffer<PrimitiveSceneData> gSceneData;
[[vk::push_constant]]
ConstantBuffer<uint> gSceneDataIndex;
src/Engine/Graphics/CMakeLists.txt
+3 -7
View File
@@ -14,10 +14,8 @@ target_sources(Engine
MeshBatch.cpp
ShaderCompiler.h
ShaderCompiler.cpp
VertexShaderInput.h
VertexShaderInput.cpp
StaticMeshVertexInput.h
StaticMeshVertexInput.cpp)
VertexData.h
VertexData.cpp)
target_sources(Engine
PUBLIC FILE_SET HEADERS
@@ -29,9 +27,7 @@ target_sources(Engine
Graphics.h
Mesh.h
MeshBatch.h
ShaderCompiler.h
VertexShaderInput.h
StaticMeshVertexInput.h)
ShaderCompiler.h)
add_subdirectory(RenderPass/)
add_subdirectory(Vulkan/)
src/Engine/Graphics/Graphics.h
+1 -1
View File
@@ -40,7 +40,7 @@ public:
virtual PTexture3D createTexture3D(const TextureCreateInfo &createInfo) = 0;
virtual PTextureCube createTextureCube(const TextureCreateInfo &createInfo) = 0;
virtual PUniformBuffer createUniformBuffer(const UniformBufferCreateInfo &bulkData) = 0;
virtual PStructuredBuffer createStructuredBuffer(const StructuredBufferCreateInfo &bulkData) = 0;
virtual PShaderBuffer createShaderBuffer(const ShaderBufferCreateInfo &bulkData) = 0;
virtual PVertexBuffer createVertexBuffer(const VertexBufferCreateInfo &bulkData) = 0;
virtual PIndexBuffer createIndexBuffer(const IndexBufferCreateInfo &bulkData) = 0;
virtual PRenderCommand createRenderCommand(const std::string& name = "") = 0;
src/Engine/Graphics/GraphicsInitializer.h
+1 -1
View File
@@ -102,7 +102,7 @@ struct UniformBufferCreateInfo
BulkResourceData resourceData = BulkResourceData();
uint8 bDynamic = 0;
};
struct StructuredBufferCreateInfo
struct ShaderBufferCreateInfo
{
BulkResourceData resourceData;
uint32 stride;
src/Engine/Graphics/GraphicsResources.cpp
+3 -3
View File
@@ -196,7 +196,7 @@ bool UniformBuffer::updateContents(const BulkResourceData& resourceData)
return true;
}
StructuredBuffer::StructuredBuffer(QueueFamilyMapping mapping, uint32 stride, uint32 numElements, const BulkResourceData& resourceData)
ShaderBuffer::ShaderBuffer(QueueFamilyMapping mapping, uint32 stride, uint32 numElements, const BulkResourceData& resourceData)
: Buffer(mapping, resourceData.owner)
, contents(resourceData.size)
, stride(stride)
@@ -207,11 +207,11 @@ StructuredBuffer::StructuredBuffer(QueueFamilyMapping mapping, uint32 stride, ui
std::memcpy(contents.data(), resourceData.data, resourceData.size);
}
}
StructuredBuffer::~StructuredBuffer()
ShaderBuffer::~ShaderBuffer()
{
}
bool StructuredBuffer::updateContents(const BulkResourceData& resourceData)
bool ShaderBuffer::updateContents(const BulkResourceData& resourceData)
{
assert(contents.size() >= resourceData.size);
if(std::memcmp(contents.data(), resourceData.data, resourceData.size) == 0)
src/Engine/Graphics/GraphicsResources.h
+7 -7
View File
@@ -178,7 +178,7 @@ public:
};
DEFINE_REF(DescriptorAllocator)
DECLARE_REF(UniformBuffer)
DECLARE_REF(StructuredBuffer)
DECLARE_REF(ShaderBuffer)
DECLARE_REF(Texture)
class DescriptorSet
{
@@ -186,7 +186,7 @@ public:
virtual ~DescriptorSet() {}
virtual void writeChanges() = 0;
virtual void updateBuffer(uint32 binding, PUniformBuffer uniformBuffer) = 0;
virtual void updateBuffer(uint32 binding, PStructuredBuffer structuredBuffer) = 0;
virtual void updateBuffer(uint32 binding, PShaderBuffer ShaderBuffer) = 0;
virtual void updateSampler(uint32 binding, PSamplerState samplerState) = 0;
virtual void updateTexture(uint32 binding, PTexture texture, PSamplerState samplerState = nullptr) = 0;
virtual void updateTextureArray(uint32_t binding, Array<PTexture> texture) = 0;
@@ -409,13 +409,13 @@ protected:
};
DEFINE_REF(IndexBuffer)
class StructuredBuffer : public Buffer
class ShaderBuffer : public Buffer
{
public:
StructuredBuffer(QueueFamilyMapping mapping, uint32 stride, uint32 numElements, const BulkResourceData& bulkResourceData);
virtual ~StructuredBuffer();
ShaderBuffer(QueueFamilyMapping mapping, uint32 stride, uint32 numElements, const BulkResourceData& bulkResourceData);
virtual ~ShaderBuffer();
virtual bool updateContents(const BulkResourceData& resourceData);
bool isDataEquals(StructuredBuffer* other)
bool isDataEquals(ShaderBuffer* other)
{
if(other == nullptr)
{
@@ -449,7 +449,7 @@ protected:
uint32 numElements;
uint32 stride;
};
DEFINE_REF(StructuredBuffer)
DEFINE_REF(ShaderBuffer)
class VertexStream
{
public:
src/Engine/Graphics/Mesh.h
+4 -4
View File
@@ -4,16 +4,16 @@
namespace Seele
{
DECLARE_REF(VertexShaderInput)
DECLARE_REF(MeshletBuffer)
DECLARE_NAME_REF(Gfx, IndexBuffer)
class Mesh
{
public:
Mesh(PVertexShaderInput vertexInput, Gfx::PIndexBuffer indexBuffer);
Mesh(PMeshletBuffer meshlets);
~Mesh();
Gfx::PIndexBuffer indexBuffer;
PVertexShaderInput vertexInput;
PMeshletBuffer meshlets;
PVertexData vertexData;
PMaterialAsset referencedMaterial;
private:
};
src/Engine/Graphics/RenderPass/BasePass.h
+2 -2
View File
@@ -29,7 +29,7 @@ DECLARE_REF(CameraActor)
struct BasePassData
{
Array<MeshBatch> staticDrawList;
Gfx::PStructuredBuffer sceneDataBuffer;
Gfx::PShaderBuffer sceneDataBuffer;
LightEnv lightEnv;
};
class BasePass : public RenderPass<BasePassData>
@@ -55,7 +55,7 @@ private:
Gfx::PPipelineLayout basePassLayout;
// Set 0: Light environment
static constexpr uint32 INDEX_LIGHT_ENV = 0;
Gfx::PStructuredBuffer oLightIndexList;
Gfx::PShaderBuffer oLightIndexList;
Gfx::PTexture oLightGrid;
Gfx::PDescriptorLayout lightLayout;
// Set 1: viewParameter
src/Engine/Graphics/RenderPass/DepthPrepass.h
+1 -1
View File
@@ -26,7 +26,7 @@ DEFINE_REF(DepthPrepassMeshProcessor)
struct DepthPrepassData
{
Array<MeshBatch> staticDrawList;
Gfx::PStructuredBuffer sceneDataBuffer;
Gfx::PShaderBuffer sceneDataBuffer;
};
class DepthPrepass : public RenderPass<DepthPrepassData>
{
src/Engine/Graphics/RenderPass/LightCullingPass.cpp
+7 -7
View File
@@ -159,7 +159,7 @@ void LightCullingPass::publishOutputs()
cullingPipeline = graphics->createComputePipeline(pipelineInfo);
uint32 counterReset = 0;
StructuredBufferCreateInfo structInfo =
ShaderBufferCreateInfo structInfo =
{
.resourceData = {
.size = sizeof(uint32),
@@ -169,8 +169,8 @@ void LightCullingPass::publishOutputs()
.stride = sizeof(uint32),
.bDynamic = true,
};
oLightIndexCounter = graphics->createStructuredBuffer(structInfo);
tLightIndexCounter = graphics->createStructuredBuffer(structInfo);
oLightIndexCounter = graphics->createShaderBuffer(structInfo);
tLightIndexCounter = graphics->createShaderBuffer(structInfo);
structInfo = {
.resourceData = {
.size = (uint32)sizeof(uint32)
@@ -183,8 +183,8 @@ void LightCullingPass::publishOutputs()
.stride = sizeof(uint32),
.bDynamic = false,
};
oLightIndexList = graphics->createStructuredBuffer(structInfo);
tLightIndexList = graphics->createStructuredBuffer(structInfo);
oLightIndexList = graphics->createShaderBuffer(structInfo);
tLightIndexList = graphics->createShaderBuffer(structInfo);
resources->registerBufferOutput("LIGHTCULLING_OLIGHTLIST", oLightIndexList);
resources->registerBufferOutput("LIGHTCULLING_TLIGHTLIST", tLightIndexList);
@@ -263,7 +263,7 @@ void LightCullingPass::setupFrustums()
uniformInfo.bDynamic = false;
dispatchParamsBuffer = graphics->createUniformBuffer(uniformInfo);
StructuredBufferCreateInfo structuredInfo = {
ShaderBufferCreateInfo structuredInfo = {
.resourceData = {
.size = sizeof(Frustum) * numThreads.x * numThreads.y * numThreads.z,
.data = nullptr,
@@ -271,7 +271,7 @@ void LightCullingPass::setupFrustums()
.stride = sizeof(Frustum),
.bDynamic = false,
};
frustumBuffer = graphics->createStructuredBuffer(structuredInfo);
frustumBuffer = graphics->createShaderBuffer(structuredInfo);
frustumDescriptorSet = frustumDescriptorLayout->allocateDescriptorSet();
frustumDescriptorSet->updateBuffer(0, viewParamsBuffer);
src/Engine/Graphics/RenderPass/LightCullingPass.h
+6 -6
View File
@@ -44,7 +44,7 @@ private:
Plane planes[4];
};
Gfx::PStructuredBuffer frustumBuffer;
Gfx::PShaderBuffer frustumBuffer;
Gfx::PUniformBuffer dispatchParamsBuffer;
Gfx::PUniformBuffer viewParamsBuffer;
Gfx::PDescriptorSet frustumDescriptorSet;
@@ -53,11 +53,11 @@ private:
Gfx::PComputePipeline frustumPipeline;
Gfx::PTexture2D depthAttachment;
Gfx::PStructuredBuffer frustums;
Gfx::PStructuredBuffer oLightIndexCounter;
Gfx::PStructuredBuffer tLightIndexCounter;
Gfx::PStructuredBuffer oLightIndexList;
Gfx::PStructuredBuffer tLightIndexList;
Gfx::PShaderBuffer frustums;
Gfx::PShaderBuffer oLightIndexCounter;
Gfx::PShaderBuffer tLightIndexCounter;
Gfx::PShaderBuffer oLightIndexList;
Gfx::PShaderBuffer tLightIndexList;
Gfx::PTexture2D oLightGrid;
Gfx::PTexture2D tLightGrid;
Gfx::PDescriptorSet lightEnvDescriptorSet;
src/Engine/Graphics/RenderPass/RenderGraphResources.cpp
+2 -2
View File
@@ -32,7 +32,7 @@ Gfx::PTexture RenderGraphResources::requestTexture(const std::string& outputName
return registeredTextures[outputName];
}
Gfx::PStructuredBuffer RenderGraphResources::requestBuffer(const std::string& outputName)
Gfx::PShaderBuffer RenderGraphResources::requestBuffer(const std::string& outputName)
{
if(registeredBuffers.find(outputName) == registeredBuffers.end())
{
@@ -62,7 +62,7 @@ void RenderGraphResources::registerTextureOutput(const std::string& outputName,
registeredTextures[outputName] = texture;
}
void RenderGraphResources::registerBufferOutput(const std::string& outputName, Gfx::PStructuredBuffer buffer)
void RenderGraphResources::registerBufferOutput(const std::string& outputName, Gfx::PShaderBuffer buffer)
{
registeredBuffers[outputName] = buffer;
}
src/Engine/Graphics/RenderPass/RenderGraphResources.h
+3 -3
View File
@@ -13,16 +13,16 @@ public:
~RenderGraphResources();
Gfx::PRenderTargetAttachment requestRenderTarget(const std::string& outputName);
Gfx::PTexture requestTexture(const std::string& outputName);
Gfx::PStructuredBuffer requestBuffer(const std::string& outputName);
Gfx::PShaderBuffer requestBuffer(const std::string& outputName);
Gfx::PUniformBuffer requestUniform(const std::string& outputName);
void registerRenderPassOutput(const std::string& outputName, Gfx::PRenderTargetAttachment attachment);
void registerTextureOutput(const std::string& outputName, Gfx::PTexture buffer);
void registerBufferOutput(const std::string& outputName, Gfx::PStructuredBuffer buffer);
void registerBufferOutput(const std::string& outputName, Gfx::PShaderBuffer buffer);
void registerUniformOutput(const std::string& outputName, Gfx::PUniformBuffer buffer);
protected:
Map<std::string, Gfx::PRenderTargetAttachment> registeredAttachments;
Map<std::string, Gfx::PTexture> registeredTextures;
Map<std::string, Gfx::PStructuredBuffer> registeredBuffers;
Map<std::string, Gfx::PShaderBuffer> registeredBuffers;
Map<std::string, Gfx::PUniformBuffer> registeredUniforms;
};
DEFINE_REF(RenderGraphResources)
src/Engine/Graphics/RenderPass/TextPass.h
+1 -1
View File
@@ -8,7 +8,7 @@ namespace Seele
{
DECLARE_NAME_REF(Gfx, Texture2D)
DECLARE_NAME_REF(Gfx, RenderTargetAttachment)
DECLARE_NAME_REF(Gfx, StructuredBuffer)
DECLARE_NAME_REF(Gfx, ShaderBuffer)
struct TextRender
{
std::string text;
src/Engine/Graphics/StaticMeshVertexInput.cpp
-81
View File
@@ -1,81 +0,0 @@
#include "StaticMeshVertexInput.h"
#include "Graphics/Graphics.h"
using namespace Seele;
StaticMeshVertexInput::StaticMeshVertexInput(std::string name)
: VertexShaderInput(name)
{
}
StaticMeshVertexInput::~StaticMeshVertexInput()
{
}
void StaticMeshVertexInput::init(Gfx::PGraphics graphics)
{
if(data.positionStream.vertexBuffer != data.tangentBasisComponents[0].vertexBuffer)
{
Array<Gfx::VertexElement> positionOnlyStreamElements;
positionOnlyStreamElements.add(accessPositionStreamComponent(data.positionStream, 0));
initPositionDeclaration(graphics, positionOnlyStreamElements);
}
Array<Gfx::VertexElement> elements;
if(data.positionStream.vertexBuffer != nullptr)
{
elements.add(accessStreamComponent(data.positionStream, 0));
}
uint8 tangentBasisAttributes[3] = {1, 2, 3};
for(int32 axisIndex = 0; axisIndex < 3; axisIndex++)
{
if(data.tangentBasisComponents[axisIndex].vertexBuffer != nullptr)
{
elements.add(accessStreamComponent(data.tangentBasisComponents[axisIndex], tangentBasisAttributes[axisIndex]));
}
}
if(data.colorComponent.vertexBuffer != nullptr)
{
elements.add(accessStreamComponent(data.colorComponent, 4));
}
else
{
elements.add(accessStreamComponent(VertexStreamComponent(graphics->getNullVertexBuffer(), 0, 0, Gfx::SE_FORMAT_R32G32B32A32_SFLOAT), 4));
}
const int32 baseTexCoordAttribute = 5;
for(uint32 coordinateIndex = 0; coordinateIndex < MAX_TEXCOORDS; ++coordinateIndex)
{
if (data.textureCoordinates[coordinateIndex].vertexBuffer == nullptr)
continue;
elements.add(accessStreamComponent(
data.textureCoordinates[coordinateIndex],
static_cast<uint8>(baseTexCoordAttribute + coordinateIndex)
));
}
initDeclaration(graphics, elements);
}
void StaticMeshVertexInput::setData(StaticMeshDataType&& _data)
{
data = std::move(_data);
}
void StaticMeshVertexInput::save(ArchiveBuffer& buffer)
{
Serialization::save(buffer, name);
Serialization::save(buffer, data);
}
void StaticMeshVertexInput::load(ArchiveBuffer& buffer)
{
Serialization::load(buffer, name);
Serialization::load(buffer, data);
init(buffer.getGraphics());
}
IMPLEMENT_VERTEX_INPUT_TYPE(StaticMeshVertexInput, "StaticMeshVertexInput")
src/Engine/Graphics/StaticMeshVertexInput.h
-58
View File
@@ -1,58 +0,0 @@
#pragma once
#include "VertexShaderInput.h"
namespace Seele
{
enum { MAX_TEXCOORDS = 4 };
struct StaticMeshDataType
{
VertexStreamComponent positionStream;
VertexStreamComponent tangentBasisComponents[3];
//Dont forget these are 4 component vectors
VertexStreamComponent textureCoordinates[4];
VertexStreamComponent colorComponent;
};
class StaticMeshVertexInput : public VertexShaderInput
{
DECLARE_VERTEX_INPUT_TYPE(StaticMeshVertexInput)
public:
StaticMeshVertexInput(std::string name);
virtual ~StaticMeshVertexInput();
virtual void init(Gfx::PGraphics graphics) override;
virtual void save(ArchiveBuffer& buffer) override;
virtual void load(ArchiveBuffer& buffer) override;
void setData(StaticMeshDataType&& data);
private:
StaticMeshDataType data;
};
DEFINE_REF(StaticMeshVertexInput)
namespace Serialization
{
static void save(ArchiveBuffer& buffer, StaticMeshDataType& type)
{
Serialization::save(buffer, type.positionStream);
Serialization::save(buffer, type.tangentBasisComponents[0]);
Serialization::save(buffer, type.tangentBasisComponents[1]);
Serialization::save(buffer, type.tangentBasisComponents[2]);
Serialization::save(buffer, type.textureCoordinates[0]);
Serialization::save(buffer, type.textureCoordinates[1]);
Serialization::save(buffer, type.textureCoordinates[2]);
Serialization::save(buffer, type.textureCoordinates[3]);
Serialization::save(buffer, type.colorComponent);
}
static void load(ArchiveBuffer& buffer, StaticMeshDataType& type)
{
Serialization::load(buffer, type.positionStream);
Serialization::load(buffer, type.tangentBasisComponents[0]);
Serialization::load(buffer, type.tangentBasisComponents[1]);
Serialization::load(buffer, type.tangentBasisComponents[2]);
Serialization::load(buffer, type.textureCoordinates[0]);
Serialization::load(buffer, type.textureCoordinates[1]);
Serialization::load(buffer, type.textureCoordinates[2]);
Serialization::load(buffer, type.textureCoordinates[3]);
Serialization::load(buffer, type.colorComponent);
}
} // namespace Serialization
} // namespace Seele
src/Engine/Graphics/VertexData.cpp
View File
src/Engine/Graphics/VertexData.h
+13
View File
@@ -0,0 +1,13 @@
#pragma once
#include "GraphicsResources.h"
namespace Seele
{
class VertexData
{
public:
private:
Gfx::PShaderBuffer vertexData;
};
}
src/Engine/Graphics/VertexShaderInput.cpp
-165
View File
@@ -1,165 +0,0 @@
#include "VertexShaderInput.h"
#include "Graphics/Mesh.h"
#include "Graphics/Graphics.h"
#include <sstream>
#include <memory>
using namespace Seele;
void Seele::Serialization::save(ArchiveBuffer& buffer, VertexStreamComponent& comp)
{
if (comp.vertexBuffer == nullptr)
{
Serialization::save(buffer, (uint32)0);
}
else
{
Serialization::save(buffer, comp.vertexBuffer->getNumVertices());
Serialization::save(buffer, comp.vertexBuffer->getVertexSize());
Array<uint8> rawBuffer;
comp.vertexBuffer->download(rawBuffer);
Serialization::save(buffer, rawBuffer);
Serialization::save(buffer, comp.streamOffset);
Serialization::save(buffer, comp.offset);
Serialization::save(buffer, comp.stride);
Serialization::save(buffer, comp.type);
}
}
void Seele::Serialization::load(ArchiveBuffer& buffer, VertexStreamComponent& comp)
{
uint32 numVertices;
Serialization::load(buffer, numVertices);
if (numVertices == 0)
{
comp.vertexBuffer = nullptr;
}
else
{
uint32 vertexSize;
Serialization::load(buffer, vertexSize);
Array<uint8> rawBuffer;
Serialization::load(buffer, rawBuffer);
VertexBufferCreateInfo createInfo = {
.resourceData = {
.size = rawBuffer.size(),
.data = rawBuffer.data(),
},
.vertexSize = vertexSize,
.numVertices = numVertices,
};
comp.vertexBuffer = buffer.getGraphics()->createVertexBuffer(createInfo);
Serialization::load(buffer, comp.streamOffset);
Serialization::load(buffer, comp.offset);
Serialization::load(buffer, comp.stride);
Serialization::load(buffer, comp.type);
}
}
List<VertexInputType*>& VertexInputType::getTypeList()
{
static List<VertexInputType*> globalTypeList;
return globalTypeList;
}
VertexInputType* VertexInputType::getVertexInputByName(const std::string& name)
{
for(auto type : getTypeList())
{
if(name.compare(type->getName()) == 0)
{
return type;
}
}
return nullptr;
}
VertexInputType::VertexInputType(const char* name,
const char* shaderFilename)
: name(name)
, shaderFilename(shaderFilename)
{
getTypeList().add(this);
}
VertexInputType::~VertexInputType()
{
getTypeList().remove(getTypeList().find(this));
}
const char* VertexInputType::getName()
{
return name;
}
std::string VertexInputType::getShaderFilename()
{
return shaderFilename;
}
VertexShaderInput::VertexShaderInput(std::string name)
: name(name)
{
declaration = new Gfx::VertexDeclaration();
positionDeclaration = new Gfx::VertexDeclaration();
}
VertexShaderInput::~VertexShaderInput()
{
}
void VertexShaderInput::init(Gfx::PGraphics) {}
void VertexShaderInput::getStreams(VertexInputStreamArray& outVertexStreams) const
{
for(uint32 i = 0; i < streams.size(); ++i)
{
const VertexStream& stream = streams[i];
if(stream.vertexBuffer == nullptr)
{
outVertexStreams.add(VertexInputStream(i, 0, nullptr));
}
else
{
outVertexStreams.add(VertexInputStream(i, stream.offset, stream.vertexBuffer));
}
}
}
void VertexShaderInput::getPositionOnlyStream(VertexInputStreamArray& outVertexStreams) const
{
for (uint32 i = 0; i < positionStreams.size(); ++i)
{
const VertexStream& stream = positionStreams[i];
outVertexStreams.add(VertexInputStream(i, stream.offset, stream.vertexBuffer));
}
}
Gfx::VertexElement VertexShaderInput::accessStreamComponent(const VertexStreamComponent& component, uint8 attributeIndex)
{
VertexStream vertexStream;
vertexStream.vertexBuffer = component.vertexBuffer;
vertexStream.stride = static_cast<uint8>(component.stride);
vertexStream.offset = static_cast<uint8>(component.offset);
return Gfx::VertexElement((uint8)streams.indexOf(streams.addUnique(vertexStream)), static_cast<uint8>(component.offset), component.type, attributeIndex, vertexStream.stride);
}
Gfx::VertexElement VertexShaderInput::accessPositionStreamComponent(const VertexStreamComponent& component, uint8 attributeIndex)
{
VertexStream vertexStream;
vertexStream.vertexBuffer = component.vertexBuffer;
vertexStream.stride = static_cast<uint8>(component.stride);
vertexStream.offset = static_cast<uint8>(component.offset);
return Gfx::VertexElement((uint8)positionStreams.indexOf(positionStreams.addUnique(vertexStream)), static_cast<uint8>(component.offset), component.type, attributeIndex, vertexStream.stride);
}
void VertexShaderInput::initDeclaration(Gfx::PGraphics graphics, Array<Gfx::VertexElement>& elements)
{
declaration = graphics->createVertexDeclaration(elements);
}
void VertexShaderInput::initPositionDeclaration(Gfx::PGraphics graphics, const Array<Gfx::VertexElement>& elements)
{
positionDeclaration = graphics->createVertexDeclaration(elements);
}
src/Engine/Graphics/VertexShaderInput.h
-166
View File
@@ -1,166 +0,0 @@
#pragma once
#include "MinimalEngine.h"
#include "GraphicsEnums.h"
#include "GraphicsResources.h"
#include "Serialization/ArchiveBuffer.h"
namespace Seele
{
// Minimal vertex source used for building commands
struct VertexInputStream
{
uint32 streamIndex : 4;
uint32 offset : 28;
Gfx::PVertexBuffer vertexBuffer;
VertexInputStream()
: streamIndex(0), offset(0), vertexBuffer(nullptr)
{
}
VertexInputStream(uint32 streamIndex, uint32 offset, Gfx::PVertexBuffer vertexBuffer)
: streamIndex(streamIndex), offset(offset), vertexBuffer(vertexBuffer)
{
assert(this->streamIndex == streamIndex && this->offset == offset);
}
inline bool operator==(const VertexInputStream &rhs) const
{
if (streamIndex != rhs.streamIndex || offset != rhs.offset || vertexBuffer != rhs.vertexBuffer)
{
return false;
}
return true;
}
inline bool operator!=(const VertexInputStream &rhs) const
{
return !(*this == rhs);
}
};
typedef Array<VertexInputStream> VertexInputStreamArray; //TODO inline allocation
// Typed data source for a vertex factory
struct VertexStreamComponent
{
// Source vertex buffer
Gfx::PVertexBuffer vertexBuffer = nullptr;
// Offset to the start of the vertex buffer fetch
uint32 streamOffset = 0;
// Offset of the data, relative to the beginnning of each element in the vertex buffer
uint32 offset = 0;
// Stride of the data
uint32 stride = 0;
Gfx::SeFormat type = Gfx::SE_FORMAT_UNDEFINED;
VertexStreamComponent()
{}
VertexStreamComponent(const Gfx::PVertexBuffer vertexBuffer, uint32 offset, uint32 stride, Gfx::SeFormat type)
: vertexBuffer(vertexBuffer)
, streamOffset(0)
, offset(offset)
, stride(stride)
, type(type)
{}
VertexStreamComponent(const Gfx::PVertexBuffer vertexBuffer, uint32 streamOffset, uint32 offset, uint32 stride, Gfx::SeFormat type)
: vertexBuffer(vertexBuffer)
, streamOffset(streamOffset)
, offset(offset)
, stride(stride)
, type(type)
{}
};
namespace Serialization
{
void save(ArchiveBuffer& buffer, VertexStreamComponent& comp);
void load(ArchiveBuffer& buffer, VertexStreamComponent& comp);
} // namespace Serialization
class VertexInputType
{
public:
static List<VertexInputType*>& getTypeList();
static VertexInputType* getVertexInputByName(const std::string& name);
VertexInputType(
const char* name,
const char* shaderFilename
);
virtual ~VertexInputType();
const char* getName();
std::string getShaderFilename();
private:
const char* name;
const char* shaderFilename;
};
#define DECLARE_VERTEX_INPUT_TYPE(inputClass) \
public: \
static VertexInputType staticType; \
virtual VertexInputType* getType() const override;
#define IMPLEMENT_VERTEX_INPUT_TYPE(inputClass, shaderFilename) \
VertexInputType inputClass::staticType( \
#inputClass, \
shaderFilename); \
VertexInputType* inputClass::getType() const { return &staticType; }
struct MeshDescription;
DECLARE_REF(VertexShaderInput)
class VertexShaderInput
{
public:
VertexShaderInput(std::string name);
virtual ~VertexShaderInput();
virtual void init(Gfx::PGraphics);
void getStreams(VertexInputStreamArray& outVertexStreams) const;
void getPositionOnlyStream(VertexInputStreamArray& outVertexStreams) const;
virtual bool supportsTesselation() { return false; }
virtual VertexInputType* getType() const { return nullptr; }
virtual void save(ArchiveBuffer& buffer) {}
virtual void load(ArchiveBuffer& buffer) {}
Gfx::PVertexDeclaration getDeclaration() const {return declaration;}
Gfx::PVertexDeclaration getPositionDeclaration() const {return positionDeclaration;}
std::string getName() const { return name; }
protected:
Gfx::VertexElement accessStreamComponent(const VertexStreamComponent& component, uint8 attributeIndex);
Gfx::VertexElement accessPositionStreamComponent(const VertexStreamComponent& component, uint8 attributeIndex);
void initDeclaration(Gfx::PGraphics graphics, Array<Gfx::VertexElement>& elements);
void initPositionDeclaration(Gfx::PGraphics graphics, const Array<Gfx::VertexElement>& elements);
static List<PVertexShaderInput> registeredInputs;
static std::mutex registeredInputsLock;
Array<Gfx::VertexAttribute> layout;
// internal helper class, basically a VertexInputStream plus stride
struct VertexStream
{
Gfx::PVertexBuffer vertexBuffer = nullptr;
uint8 stride = 0;
uint8 offset = 0;
friend bool operator==(const VertexStream& a, const VertexStream& b)
{
return a.vertexBuffer == b.vertexBuffer &&
a.stride == b.stride &&
a.offset == b.offset;
}
VertexStream()
{
}
};
Array<VertexStream> streams;
Array<VertexStream> positionStreams;
Gfx::PVertexDeclaration declaration;
Gfx::PVertexDeclaration positionDeclaration;
std::string name;
};
DEFINE_REF(VertexShaderInput)
} // namespace Seele
src/Engine/Graphics/Vulkan/VulkanBuffer.cpp
+12 -12
View File
@@ -361,8 +361,8 @@ VkAccessFlags UniformBuffer::getDestAccessMask()
return VK_ACCESS_UNIFORM_READ_BIT;
}
StructuredBuffer::StructuredBuffer(PGraphics graphics, const StructuredBufferCreateInfo &resourceData)
: Gfx::StructuredBuffer(graphics->getFamilyMapping(), resourceData.stride, resourceData.resourceData.size / resourceData.stride, resourceData.resourceData)
ShaderBuffer::ShaderBuffer(PGraphics graphics, const ShaderBufferCreateInfo &resourceData)
: Gfx::ShaderBuffer(graphics->getFamilyMapping(), resourceData.stride, resourceData.resourceData.size / resourceData.stride, resourceData.resourceData)
, Vulkan::ShaderBuffer(graphics, resourceData.resourceData.size, VK_BUFFER_USAGE_STORAGE_BUFFER_BIT, currentOwner, resourceData.bDynamic)
{
if (resourceData.resourceData.data != nullptr)
@@ -373,21 +373,21 @@ StructuredBuffer::StructuredBuffer(PGraphics graphics, const StructuredBufferCre
}
}
StructuredBuffer::~StructuredBuffer()
ShaderBuffer::~ShaderBuffer()
{
}
bool StructuredBuffer::updateContents(const BulkResourceData &resourceData)
bool ShaderBuffer::updateContents(const BulkResourceData &resourceData)
{
assert(resourceData.size <= getSize());
Gfx::StructuredBuffer::updateContents(resourceData);
Gfx::ShaderBuffer::updateContents(resourceData);
//We always want to update, as the contents could be different on the GPU
void* data = lock();
std::memcpy(data, resourceData.data, resourceData.size);
unlock();
return true;
}
void* StructuredBuffer::lock(bool bWriteOnly)
void* ShaderBuffer::lock(bool bWriteOnly)
{
if(dedicatedStagingBuffer != nullptr)
{
@@ -396,7 +396,7 @@ void* StructuredBuffer::lock(bool bWriteOnly)
return ShaderBuffer::lock(bWriteOnly);
}
void StructuredBuffer::unlock()
void ShaderBuffer::unlock()
{
if(dedicatedStagingBuffer != nullptr)
{
@@ -416,28 +416,28 @@ void StructuredBuffer::unlock()
}
}
void StructuredBuffer::requestOwnershipTransfer(Gfx::QueueType newOwner)
void ShaderBuffer::requestOwnershipTransfer(Gfx::QueueType newOwner)
{
Gfx::QueueOwnedResource::transferOwnership(newOwner);
}
void StructuredBuffer::executeOwnershipBarrier(Gfx::QueueType newOwner)
void ShaderBuffer::executeOwnershipBarrier(Gfx::QueueType newOwner)
{
Vulkan::ShaderBuffer::executeOwnershipBarrier(newOwner);
}
void StructuredBuffer::executePipelineBarrier(VkAccessFlags srcAccess, VkPipelineStageFlags srcStage,
void ShaderBuffer::executePipelineBarrier(VkAccessFlags srcAccess, VkPipelineStageFlags srcStage,
VkAccessFlags dstAccess, VkPipelineStageFlags dstStage)
{
Vulkan::ShaderBuffer::executePipelineBarrier(srcAccess, srcStage, dstAccess, dstStage);
}
VkAccessFlags StructuredBuffer::getSourceAccessMask()
VkAccessFlags ShaderBuffer::getSourceAccessMask()
{
return VK_ACCESS_MEMORY_WRITE_BIT;
}
VkAccessFlags StructuredBuffer::getDestAccessMask()
VkAccessFlags ShaderBuffer::getDestAccessMask()
{
return VK_ACCESS_MEMORY_READ_BIT;
}
src/Engine/Graphics/Vulkan/VulkanDescriptorSets.cpp
+3 -3
View File
@@ -135,10 +135,10 @@ void DescriptorSet::updateBuffer(uint32_t binding, Gfx::PUniformBuffer uniformBu
cachedData[binding] = new UniformBuffer(*vulkanBuffer.getHandle());
}
void DescriptorSet::updateBuffer(uint32_t binding, Gfx::PStructuredBuffer structuredBuffer)
void DescriptorSet::updateBuffer(uint32_t binding, Gfx::PShaderBuffer ShaderBuffer)
{
PStructuredBuffer vulkanBuffer = structuredBuffer.cast<StructuredBuffer>();
StructuredBuffer* cachedBuffer = reinterpret_cast<StructuredBuffer*>(cachedData[binding]);
PShaderBuffer vulkanBuffer = ShaderBuffer.cast<ShaderBuffer>();
ShaderBuffer* cachedBuffer = reinterpret_cast<ShaderBuffer*>(cachedData[binding]);
if(vulkanBuffer.getHandle() == cachedBuffer)
{
return;
src/Engine/Graphics/Vulkan/VulkanDescriptorSets.h
+1 -1
View File
@@ -67,7 +67,7 @@ public:
virtual ~DescriptorSet();
virtual void writeChanges();
virtual void updateBuffer(uint32_t binding, Gfx::PUniformBuffer uniformBuffer);
virtual void updateBuffer(uint32_t binding, Gfx::PStructuredBuffer uniformBuffer);
virtual void updateBuffer(uint32_t binding, Gfx::PShaderBuffer uniformBuffer);
virtual void updateSampler(uint32_t binding, Gfx::PSamplerState samplerState);
virtual void updateTexture(uint32_t binding, Gfx::PTexture texture, Gfx::PSamplerState sampler = nullptr);
virtual void updateTextureArray(uint32_t binding, Array<Gfx::PTexture> texture);
src/Engine/Graphics/Vulkan/VulkanGraphics.cpp
+4 -4
View File
@@ -134,10 +134,10 @@ Gfx::PUniformBuffer Graphics::createUniformBuffer(const UniformBufferCreateInfo
return uniformBuffer;
}
Gfx::PStructuredBuffer Graphics::createStructuredBuffer(const StructuredBufferCreateInfo &bulkData)
Gfx::PShaderBuffer Graphics::createShaderBuffer(const ShaderBufferCreateInfo &bulkData)
{
PStructuredBuffer structuredBuffer = new StructuredBuffer(this, bulkData);
return structuredBuffer;
PShaderBuffer ShaderBuffer = new ShaderBuffer(this, bulkData);
return ShaderBuffer;
}
Gfx::PVertexBuffer Graphics::createVertexBuffer(const VertexBufferCreateInfo &bulkData)
{
@@ -269,7 +269,7 @@ void Graphics::copyTexture(Gfx::PTexture srcTexture, Gfx::PTexture dstTexture)
{
/*VkMemoryRequirements imageRequirements;
vkGetImageMemoryRequirements(handle, srcHandle->getImage(), &imageRequirements);
PStructuredBuffer tempBuffer = createStructuredBuffer();
PShaderBuffer tempBuffer = createShaderBuffer();
VkBufferImageCopy bufferImageCopy;
bufferImageCopy.bufferOffset = 0;
bufferImageCopy.bufferRowLength = srcTexture->getSizeX();
src/Engine/Graphics/Vulkan/VulkanGraphics.h
+1 -1
View File
@@ -48,7 +48,7 @@ public:
virtual Gfx::PTexture3D createTexture3D(const TextureCreateInfo &createInfo) override;
virtual Gfx::PTextureCube createTextureCube(const TextureCreateInfo &createInfo) override;
virtual Gfx::PUniformBuffer createUniformBuffer(const UniformBufferCreateInfo &bulkData) override;
virtual Gfx::PStructuredBuffer createStructuredBuffer(const StructuredBufferCreateInfo &bulkData) override;
virtual Gfx::PShaderBuffer createShaderBuffer(const ShaderBufferCreateInfo &bulkData) override;
virtual Gfx::PVertexBuffer createVertexBuffer(const VertexBufferCreateInfo &bulkData) override;
virtual Gfx::PIndexBuffer createIndexBuffer(const IndexBufferCreateInfo &bulkData) override;
virtual Gfx::PRenderCommand createRenderCommand(const std::string& name) override;
src/Engine/Graphics/Vulkan/VulkanGraphicsResources.h
+4 -4
View File
@@ -140,11 +140,11 @@ private:
};
DEFINE_REF(UniformBuffer)
class StructuredBuffer : public Gfx::StructuredBuffer, public ShaderBuffer
class ShaderBuffer : public Gfx::ShaderBuffer, public ShaderBuffer
{
public:
StructuredBuffer(PGraphics graphics, const StructuredBufferCreateInfo &resourceData);
virtual ~StructuredBuffer();
ShaderBuffer(PGraphics graphics, const ShaderBufferCreateInfo &resourceData);
virtual ~ShaderBuffer();
virtual bool updateContents(const BulkResourceData &resourceData);
virtual void* lock(bool bWriteOnly = true) override;
@@ -161,7 +161,7 @@ protected:
private:
PStagingBuffer dedicatedStagingBuffer;
};
DEFINE_REF(StructuredBuffer)
DEFINE_REF(ShaderBuffer)
class VertexBuffer : public Gfx::VertexBuffer, public ShaderBuffer
{
src/Engine/Scene/Scene.cpp
+5 -5
View File
@@ -17,7 +17,7 @@ Scene::Scene(Gfx::PGraphics graphics)
, physics(registry)
{
StructuredBufferCreateInfo structInfo = {
ShaderBufferCreateInfo structInfo = {
.resourceData = {
.size = sizeof(Component::DirectionalLight) * MAX_DIRECTIONAL_LIGHTS,
.data = nullptr,
@@ -25,10 +25,10 @@ Scene::Scene(Gfx::PGraphics graphics)
.stride = sizeof(Component::DirectionalLight),
.bDynamic = true,
};
lightEnv.directionalLights = graphics->createStructuredBuffer(structInfo);
lightEnv.directionalLights = graphics->createShaderBuffer(structInfo);
structInfo.resourceData.size = sizeof(Component::PointLight) * MAX_POINT_LIGHTS;
structInfo.stride = sizeof(Component::PointLight);
lightEnv.pointLights = graphics->createStructuredBuffer(structInfo);
lightEnv.pointLights = graphics->createShaderBuffer(structInfo);
UniformBufferCreateInfo uniformInfo = {
.resourceData = {
@@ -87,14 +87,14 @@ Array<MeshBatch> Scene::getStaticMeshes()
}
if(sceneDataBuffer == nullptr || sceneDataBuffer->getNumElements() != sceneData.size())
{
StructuredBufferCreateInfo createInfo = StructuredBufferCreateInfo {
ShaderBufferCreateInfo createInfo = ShaderBufferCreateInfo {
.resourceData = {
.size = sceneData.size() * sizeof(PrimitiveSceneData),
.data = nullptr,
},
.stride = (uint32)sceneData.size(),
};
sceneDataBuffer = graphics->createStructuredBuffer(createInfo);
sceneDataBuffer = graphics->createShaderBuffer(createInfo);
}
sceneDataBuffer->updateContents(BulkResourceData {
.size = sceneData.size() * sizeof(PrimitiveSceneData),
src/Engine/Scene/Scene.h
+4 -4
View File
@@ -15,9 +15,9 @@ DECLARE_REF(Entity)
#define MAX_POINT_LIGHTS 256
struct LightEnv
{
Gfx::PStructuredBuffer directionalLights;
Gfx::PShaderBuffer directionalLights;
Gfx::PUniformBuffer numDirectional;
Gfx::PStructuredBuffer pointLights;
Gfx::PShaderBuffer pointLights;
Gfx::PUniformBuffer numPoints;
};
@@ -58,7 +58,7 @@ public:
Array<MeshBatch> getStaticMeshes();
LightEnv getLightBuffer();
Component::Skybox getSkybox();
Gfx::PStructuredBuffer getSceneDataBuffer() const { return sceneDataBuffer; }
Gfx::PShaderBuffer getSceneDataBuffer() const { return sceneDataBuffer; }
Gfx::PGraphics getGraphics() const { return graphics; }
entt::registry registry;
private:
@@ -69,7 +69,7 @@ private:
Vector4 actorLocation;
};
Array<PrimitiveSceneData> sceneData;
Gfx::PStructuredBuffer sceneDataBuffer;
Gfx::PShaderBuffer sceneDataBuffer;
LightEnv lightEnv;
PhysicsSystem physics;
Gfx::PGraphics graphics;