Refactor ShaderBuffer

.gitmodules

@@ -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

res/shaders/ComputeFrustums.slang

@@ -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

@@ -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

@@ -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

@@ -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

@@ -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

@@ -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

@@ -14,10 +14,8 @@ target_sources(Engine
         MeshBatch.cpp
         ShaderCompiler.h
         ShaderCompiler.cpp
-        VertexShaderInput.h
+        VertexData.h
-        VertexShaderInput.cpp
+        VertexData.cpp)
-        StaticMeshVertexInput.h
-        StaticMeshVertexInput.cpp)
 
 target_sources(Engine
     PUBLIC FILE_SET HEADERS
@@ -29,9 +27,7 @@ target_sources(Engine
             Graphics.h
             Mesh.h
             MeshBatch.h
-            ShaderCompiler.h
+            ShaderCompiler.h)
-            VertexShaderInput.h
-            StaticMeshVertexInput.h)
 
 add_subdirectory(RenderPass/)
 add_subdirectory(Vulkan/)

src/Engine/Graphics/Graphics.h

@@ -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

@@ -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

@@ -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

@@ -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);
+    ShaderBuffer(QueueFamilyMapping mapping, uint32 stride, uint32 numElements, const BulkResourceData& bulkResourceData);
-    virtual ~StructuredBuffer();
+    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,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;
+    PMeshletBuffer meshlets;
-    PVertexShaderInput vertexInput;
+    PVertexData vertexData;
     PMaterialAsset referencedMaterial;
 private:
 };

src/Engine/Graphics/RenderPass/BasePass.h

@@ -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

@@ -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

@@ -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);
+    oLightIndexCounter = graphics->createShaderBuffer(structInfo);
-    tLightIndexCounter = graphics->createStructuredBuffer(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);
+    oLightIndexList = graphics->createShaderBuffer(structInfo);
-    tLightIndexList = graphics->createStructuredBuffer(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

@@ -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::PShaderBuffer frustums;
-    Gfx::PStructuredBuffer oLightIndexCounter;
+    Gfx::PShaderBuffer oLightIndexCounter;
-    Gfx::PStructuredBuffer tLightIndexCounter;
+    Gfx::PShaderBuffer tLightIndexCounter;
-    Gfx::PStructuredBuffer oLightIndexList;
+    Gfx::PShaderBuffer oLightIndexList;
-    Gfx::PStructuredBuffer tLightIndexList;
+    Gfx::PShaderBuffer tLightIndexList;
     Gfx::PTexture2D oLightGrid;
     Gfx::PTexture2D tLightGrid;
     Gfx::PDescriptorSet lightEnvDescriptorSet;

src/Engine/Graphics/RenderPass/RenderGraphResources.cpp

@@ -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

@@ -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

@@ -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

@@ -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

@@ -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.h

@@ -0,0 +1,13 @@
+#pragma once
+#include "GraphicsResources.h"
+
+namespace Seele
+{
+class VertexData
+{
+public:
+private:
+    Gfx::PShaderBuffer vertexData;
+    
+};
+}

src/Engine/Graphics/VertexShaderInput.cpp

@@ -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

@@ -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

@@ -361,8 +361,8 @@ VkAccessFlags UniformBuffer::getDestAccessMask()
     return VK_ACCESS_UNIFORM_READ_BIT;
 }
 
-StructuredBuffer::StructuredBuffer(PGraphics graphics, const StructuredBufferCreateInfo &resourceData)
+ShaderBuffer::ShaderBuffer(PGraphics graphics, const ShaderBufferCreateInfo &resourceData)
-    : Gfx::StructuredBuffer(graphics->getFamilyMapping(), resourceData.stride, resourceData.resourceData.size / resourceData.stride, resourceData.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

@@ -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>();
+    PShaderBuffer vulkanBuffer = ShaderBuffer.cast<ShaderBuffer>();
-    StructuredBuffer* cachedBuffer = reinterpret_cast<StructuredBuffer*>(cachedData[binding]);
+    ShaderBuffer* cachedBuffer = reinterpret_cast<ShaderBuffer*>(cachedData[binding]);
     if(vulkanBuffer.getHandle() == cachedBuffer)
     {
         return;

src/Engine/Graphics/Vulkan/VulkanDescriptorSets.h

@@ -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

@@ -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);
+    PShaderBuffer ShaderBuffer = new ShaderBuffer(this, bulkData);
-    return structuredBuffer;
+    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

@@ -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

@@ -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);
+    ShaderBuffer(PGraphics graphics, const ShaderBufferCreateInfo &resourceData);
-    virtual ~StructuredBuffer();
+    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

@@ -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

@@ -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;