No more shared pointers

src/Editor/Asset/FontLoader.cpp

@@ -55,8 +55,8 @@ void FontLoader::import(FontImportArgs args, PFontAsset asset)
         imageData.format = Gfx::SE_FORMAT_R8_UINT;
         imageData.width = face->glyph->bitmap.width;
         imageData.height = face->glyph->bitmap.rows;
-        imageData.resourceData.data = face->glyph->bitmap.buffer;
-        imageData.resourceData.size = imageData.width * imageData.height;
+        imageData.sourceData.data = face->glyph->bitmap.buffer;
+        imageData.sourceData.size = imageData.width * imageData.height;
         if(imageData.width == 0 || imageData.height == 0)
         {
             glyph.size.x = 1;
@@ -65,8 +65,8 @@ void FontLoader::import(FontImportArgs args, PFontAsset asset)
             glyph.bearing.y = 0;
             imageData.width = 1;
             imageData.height = 1;
-            imageData.resourceData.size = sizeof(uint8);
-            imageData.resourceData.data = &transparentPixel;
+            imageData.sourceData.size = sizeof(uint8);
+            imageData.sourceData.data = &transparentPixel;
         }
         glyph.texture = graphics->createTexture2D(imageData);
     }

src/Editor/Asset/MeshLoader.cpp

@@ -245,9 +245,9 @@ void MeshLoader::loadGlobalMeshes(const aiScene* scene, const Array<PMaterialAss
 
         IndexBufferCreateInfo idxInfo;
         idxInfo.indexType = Gfx::SE_INDEX_TYPE_UINT32;
-        idxInfo.resourceData.data = (uint8 *)indices.data();
-        idxInfo.resourceData.owner = Gfx::QueueType::DEDICATED_TRANSFER;
-        idxInfo.resourceData.size = sizeof(uint32) * indices.size();
+        idxInfo.sourceData.data = (uint8 *)indices.data();
+        idxInfo.sourceData.owner = Gfx::QueueType::DEDICATED_TRANSFER;
+        idxInfo.sourceData.size = sizeof(uint32) * indices.size();
         Gfx::PIndexBuffer indexBuffer = graphics->createIndexBuffer(idxInfo);
         indexBuffer->transferOwnership(Gfx::QueueType::GRAPHICS);
 

src/Engine/Asset/FontAsset.cpp

@@ -102,7 +102,7 @@ void FontAsset::load(ArchiveBuffer& buffer)
         ktxTexture2_TranscodeBasis(kTexture, KTX_TTF_BC7_RGBA, 0);
 
         TextureCreateInfo createInfo = {
-            .resourceData = {
+            .sourceData = {
                 .size = ktxTexture_GetDataSize(ktxTexture(kTexture)),
                 .data = ktxTexture_GetData(ktxTexture(kTexture)),
                 .owner = Gfx::QueueType::GRAPHICS,

src/Engine/Asset/FontAsset.h

@@ -18,7 +18,7 @@ public:
 
     struct Glyph
     {
-        Gfx::PTexture2D texture;
+        Gfx::OTexture2D texture;
         IVector2 size;
         IVector2 bearing;
         uint32 advance;

src/Engine/Asset/TextureAsset.cpp

@@ -84,7 +84,7 @@ void TextureAsset::load(ArchiveBuffer& buffer)
     assert(e == ktx_error_code_e::KTX_SUCCESS);
 
     TextureCreateInfo createInfo = {
-            .resourceData = {
+            .sourceData = {
                 .size = ktxTexture_GetDataSize(ktxTexture(kTexture)),
                 .data = ktxTexture_GetData(ktxTexture(kTexture)),
                 .owner = Gfx::QueueType::DEDICATED_TRANSFER,

src/Engine/CMakeLists.txt

@@ -3,8 +3,7 @@ target_sources(Engine
         Concepts.h
         EngineTypes.h
         Game.h
-        MinimalEngine.h
-        MinimalEngine.cpp)
+        MinimalEngine.h)
 
 target_sources(Engine
     PUBLIC FILE_SET HEADERS

src/Engine/Containers/Array.h

@@ -319,7 +319,7 @@ public:
         {
             if (pred(_data[i]))
             {
-                return const_iterator(&_data[i]);
+                return iterator(&_data[i]);
             }
         }
         return end();

src/Engine/Graphics/Buffer.cpp

@@ -12,13 +12,13 @@ Buffer::~Buffer()
 {
 }
 
-UniformBuffer::UniformBuffer(QueueFamilyMapping mapping, const BulkResourceData& resourceData)
-	: Buffer(mapping, resourceData.owner)
-	, contents(resourceData.size)
+UniformBuffer::UniformBuffer(QueueFamilyMapping mapping, const DataSource& sourceData)
+	: Buffer(mapping, sourceData.owner)
+	, contents(sourceData.size)
 {
-	if (resourceData.data != nullptr)
+	if (sourceData.data != nullptr)
 	{
-		std::memcpy(contents.data(), resourceData.data, contents.size());
+		std::memcpy(contents.data(), sourceData.data, contents.size());
 	}
 }
 
@@ -26,40 +26,40 @@ UniformBuffer::~UniformBuffer()
 {
 }
 
-bool UniformBuffer::updateContents(const BulkResourceData& resourceData)
+bool UniformBuffer::updateContents(const DataSource& sourceData)
 {
-	assert(contents.size() == resourceData.size);
-	if (std::memcmp(contents.data(), resourceData.data, contents.size()) == 0)
+	assert(contents.size() == sourceData.size);
+	if (std::memcmp(contents.data(), sourceData.data, contents.size()) == 0)
 	{
 		return false;
 	}
-	std::memcpy(contents.data(), resourceData.data, contents.size());
+	std::memcpy(contents.data(), sourceData.data, contents.size());
 	return true;
 }
 
-ShaderBuffer::ShaderBuffer(QueueFamilyMapping mapping, uint32 stride, uint32 numElements, const BulkResourceData& resourceData)
-	: Buffer(mapping, resourceData.owner)
-	, contents(resourceData.size)
+ShaderBuffer::ShaderBuffer(QueueFamilyMapping mapping, uint32 stride, uint32 numElements, const DataSource& sourceData)
+	: Buffer(mapping, sourceData.owner)
+	, contents(sourceData.size)
 	, numElements(numElements)
 	, stride(stride)
 {
-	if (resourceData.data != nullptr)
+	if (sourceData.data != nullptr)
 	{
-		std::memcpy(contents.data(), resourceData.data, resourceData.size);
+		std::memcpy(contents.data(), sourceData.data, sourceData.size);
 	}
 }
 ShaderBuffer::~ShaderBuffer()
 {
 }
 
-bool ShaderBuffer::updateContents(const BulkResourceData& resourceData)
+bool ShaderBuffer::updateContents(const DataSource& sourceData)
 {
-	assert(contents.size() >= resourceData.size);
-	if (std::memcmp(contents.data(), resourceData.data, resourceData.size) == 0)
+	assert(contents.size() >= sourceData.size);
+	if (std::memcmp(contents.data(), sourceData.data, sourceData.size) == 0)
 	{
 		return false;
 	}
-	std::memcpy(contents.data(), resourceData.data, resourceData.size);
+	std::memcpy(contents.data(), sourceData.data, sourceData.size);
 	return true;
 }
 VertexBuffer::VertexBuffer(QueueFamilyMapping mapping, uint32 numVertices, uint32 vertexSize, QueueType startQueueType)

src/Engine/Graphics/Buffer.h

@@ -26,10 +26,10 @@ protected:
 class UniformBuffer : public Buffer
 {
 public:
-    UniformBuffer(QueueFamilyMapping mapping, const BulkResourceData& resourceData);
+    UniformBuffer(QueueFamilyMapping mapping, const DataSource& sourceData);
     virtual ~UniformBuffer();
     // returns true if an update was performed, false if the old contents == new contents
-    virtual bool updateContents(const BulkResourceData& resourceData);
+    virtual bool updateContents(const DataSource& sourceData);
     bool isDataEquals(UniformBuffer* other)
     {
         if(other == nullptr)
@@ -70,7 +70,7 @@ public:
         return vertexSize;
     }
 
-    virtual void updateRegion(BulkResourceData update) = 0;
+    virtual void updateRegion(DataSource update) = 0;
     virtual void download(Array<uint8>& buffer) = 0;
 protected:
     // Inherited via QueueOwnedResource
@@ -110,9 +110,9 @@ DEFINE_REF(IndexBuffer)
 class ShaderBuffer : public Buffer
 {
 public:
-    ShaderBuffer(QueueFamilyMapping mapping, uint32 stride, uint32 numElements, const BulkResourceData& bulkResourceData);
+    ShaderBuffer(QueueFamilyMapping mapping, uint32 stride, uint32 numElements, const DataSource& bulkResourceData);
     virtual ~ShaderBuffer();
-    virtual bool updateContents(const BulkResourceData& resourceData);
+    virtual bool updateContents(const DataSource& sourceData);
     bool isDataEquals(ShaderBuffer* other)
     {
         if(other == nullptr)

src/Engine/Graphics/Descriptor.cpp

@@ -20,9 +20,7 @@ void DescriptorLayout::addDescriptorBinding(uint32 bindingIndex, SeDescriptorTyp
 PDescriptorSet DescriptorLayout::allocateDescriptorSet()
 {
 	std::scoped_lock lock(allocatorLock);
-	PDescriptorSet result;
-	allocator->allocateDescriptorSet(result);
-	return result;
+	return allocator->allocateDescriptorSet();
 }
 
 void DescriptorLayout::reset()

src/Engine/Graphics/Descriptor.h

@@ -43,7 +43,7 @@ class DescriptorAllocator
 public:
     DescriptorAllocator() {}
     virtual ~DescriptorAllocator() {}
-    virtual void allocateDescriptorSet(PDescriptorSet& descriptorSet) = 0;
+    virtual PDescriptorSet allocateDescriptorSet() = 0;
     virtual void reset() = 0;
 };
 DEFINE_REF(DescriptorAllocator)
@@ -54,6 +54,7 @@ DECLARE_REF(SamplerState)
 class DescriptorSet
 {
 public:
+    DescriptorSet() {}
     virtual ~DescriptorSet() {}
     virtual void writeChanges() = 0;
     virtual void updateBuffer(uint32 binding, PUniformBuffer uniformBuffer) = 0;
@@ -106,7 +107,7 @@ public:
 
 protected:
     Array<DescriptorBinding> descriptorBindings;
-    PDescriptorAllocator allocator;
+    ODescriptorAllocator allocator;
     std::mutex allocatorLock;
     uint32 setIndex;
     std::string name;
@@ -117,6 +118,9 @@ DEFINE_REF(DescriptorLayout)
 class PipelineLayout
 {
 public:
+    PipelineLayout()
+    {
+    }
     PipelineLayout(PPipelineLayout baseLayout)
     {
         if (baseLayout != nullptr)
@@ -128,12 +132,12 @@ public:
     virtual ~PipelineLayout() {}
     virtual void create() = 0;
     virtual void reset() = 0;
-    void addDescriptorLayout(uint32 setIndex, PDescriptorLayout layout);
+    void addDescriptorLayout(uint32 setIndex, const PDescriptorLayout layout);
     void addPushConstants(const SePushConstantRange& pushConstants);
     virtual uint32 getHash() const = 0;
 
 protected:
-    Array<PDescriptorLayout> descriptorSetLayouts;
+    Array<const PDescriptorLayout> descriptorSetLayouts;
     Array<SePushConstantRange> pushConstants;
 };
 DEFINE_REF(PipelineLayout)

src/Engine/Graphics/Graphics.cpp

@@ -11,18 +11,3 @@ Graphics::Graphics()
 Graphics::~Graphics()
 {
 }
-
-PVertexBuffer Graphics::getNullVertexBuffer() 
-{
-    if(nullVertexBuffer == nullptr)
-    {
-        VertexBufferCreateInfo createInfo;
-        createInfo.numVertices = 1;
-        createInfo.vertexSize = sizeof(Vector4);
-        Vector4 data =  Vector4(1, 1, 1, 1);
-        createInfo.resourceData.data = reinterpret_cast<uint8*>(&data);
-        createInfo.resourceData.size = sizeof(Vector4);
-        nullVertexBuffer = createVertexBuffer(createInfo);
-    }
-    return nullVertexBuffer;
-}

src/Engine/Graphics/Graphics.h

@@ -38,52 +38,51 @@ public:
   		return queueMapping;
   	}
 
-    PShaderCompiler getShaderCompiler() const
+    PShaderCompiler getShaderCompiler()
     {
         return shaderCompiler;
     }
     
-    virtual PWindow createWindow(const WindowCreateInfo &createInfo) = 0;
-    virtual PViewport createViewport(PWindow owner, const ViewportCreateInfo &createInfo) = 0;
+    virtual OWindow createWindow(const WindowCreateInfo &createInfo) = 0;
+    virtual OViewport createViewport(PWindow owner, const ViewportCreateInfo &createInfo) = 0;
 
-    virtual PRenderPass createRenderPass(PRenderTargetLayout layout, PViewport renderArea) = 0;
+    virtual ORenderPass createRenderPass(ORenderTargetLayout layout, PViewport renderArea) = 0;
     virtual void beginRenderPass(PRenderPass renderPass) = 0;
     virtual void endRenderPass() = 0;
 
     virtual void executeCommands(const Array<PRenderCommand>& commands) = 0;
     virtual void executeCommands(const Array<PComputeCommand>& commands) = 0;
 
-    virtual PTexture2D createTexture2D(const TextureCreateInfo &createInfo) = 0;
-    virtual PTexture3D createTexture3D(const TextureCreateInfo &createInfo) = 0;
-    virtual PTextureCube createTextureCube(const TextureCreateInfo &createInfo) = 0;
-    virtual PUniformBuffer createUniformBuffer(const UniformBufferCreateInfo &bulkData) = 0;
-    virtual PShaderBuffer createShaderBuffer(const ShaderBufferCreateInfo &bulkData) = 0;
-    virtual PVertexBuffer createVertexBuffer(const VertexBufferCreateInfo &bulkData) = 0;
-    virtual PIndexBuffer createIndexBuffer(const IndexBufferCreateInfo &bulkData) = 0;
+    virtual OTexture2D createTexture2D(const TextureCreateInfo &createInfo) = 0;
+    virtual OTexture3D createTexture3D(const TextureCreateInfo &createInfo) = 0;
+    virtual OTextureCube createTextureCube(const TextureCreateInfo &createInfo) = 0;
+    virtual OUniformBuffer createUniformBuffer(const UniformBufferCreateInfo &bulkData) = 0;
+    virtual OShaderBuffer createShaderBuffer(const ShaderBufferCreateInfo &bulkData) = 0;
+    virtual OVertexBuffer createVertexBuffer(const VertexBufferCreateInfo &bulkData) = 0;
+    virtual OIndexBuffer createIndexBuffer(const IndexBufferCreateInfo &bulkData) = 0;
+    
     virtual PRenderCommand createRenderCommand(const std::string& name = "") = 0;
     virtual PComputeCommand createComputeCommand(const std::string& name = "") = 0;
-    virtual PVertexDeclaration createVertexDeclaration(const Array<VertexElement>& element) = 0;
-    virtual PVertexShader createVertexShader(const ShaderCreateInfo& createInfo) = 0;
-    virtual PFragmentShader createFragmentShader(const ShaderCreateInfo& createInfo) = 0;
-    virtual PComputeShader createComputeShader(const ShaderCreateInfo& createInfo) = 0;
-    virtual PMeshShader createMeshShader(const ShaderCreateInfo& createInfo) = 0;
-    virtual PTaskShader createTaskShader(const ShaderCreateInfo& createInfo) = 0;
-    virtual PGraphicsPipeline createGraphicsPipeline(const LegacyPipelineCreateInfo& createInfo) = 0;
-    virtual PGraphicsPipeline createGraphicsPipeline(const MeshPipelineCreateInfo& createInfo) = 0;
-    virtual PComputePipeline createComputePipeline(const ComputePipelineCreateInfo& createInfo) = 0;
-    virtual PSamplerState createSamplerState(const SamplerCreateInfo& createInfo) = 0;
     
-  	virtual PDescriptorLayout createDescriptorLayout(const std::string& name = "") = 0;
-  	virtual PPipelineLayout createPipelineLayout(PPipelineLayout baseLayout = nullptr) = 0;
+    virtual OVertexDeclaration createVertexDeclaration(const Array<VertexElement>& element) = 0;
+    virtual OVertexShader createVertexShader(const ShaderCreateInfo& createInfo) = 0;
+    virtual OFragmentShader createFragmentShader(const ShaderCreateInfo& createInfo) = 0;
+    virtual OComputeShader createComputeShader(const ShaderCreateInfo& createInfo) = 0;
+    virtual OMeshShader createMeshShader(const ShaderCreateInfo& createInfo) = 0;
+    virtual OTaskShader createTaskShader(const ShaderCreateInfo& createInfo) = 0;
+    virtual OGraphicsPipeline createGraphicsPipeline(const LegacyPipelineCreateInfo& createInfo) = 0;
+    virtual OGraphicsPipeline createGraphicsPipeline(const MeshPipelineCreateInfo& createInfo) = 0;
+    virtual OComputePipeline createComputePipeline(const ComputePipelineCreateInfo& createInfo) = 0;
+    virtual OSamplerState createSamplerState(const SamplerCreateInfo& createInfo) = 0;
+
+  	virtual ODescriptorLayout createDescriptorLayout(const std::string& name = "") = 0;
+  	virtual OPipelineLayout createPipelineLayout(PPipelineLayout baseLayout = nullptr) = 0;
 
   	virtual void copyTexture(Gfx::PTexture srcTexture, Gfx::PTexture dstTexture) = 0;
     
-    PVertexBuffer getNullVertexBuffer();
-
 protected:
-    PVertexBuffer nullVertexBuffer;
     QueueFamilyMapping queueMapping;
-    PShaderCompiler shaderCompiler;
+    OShaderCompiler shaderCompiler;
     friend class Window;
 };
 DEFINE_REF(Graphics)

src/Engine/Graphics/Initializer.h

@@ -48,7 +48,7 @@ struct ViewportCreateInfo
     float fieldOfView = 1.222f; // 70 deg
 };
 // doesnt own the data, only proxy it
-struct BulkResourceData
+struct DataSource
 {
     uint64 size = 0;
     uint64 offset = 0;
@@ -57,7 +57,7 @@ struct BulkResourceData
 };
 struct TextureCreateInfo
 {
-    BulkResourceData resourceData = BulkResourceData();
+    DataSource sourceData = DataSource();
     uint32 width = 1;
     uint32 height = 1;
     uint32 depth = 1;
@@ -89,24 +89,24 @@ struct SamplerCreateInfo
 };
 struct VertexBufferCreateInfo
 {
-    BulkResourceData resourceData = BulkResourceData();
+    DataSource sourceData = DataSource();
     // bytes per vertex
     uint32 vertexSize = 0;
     uint32 numVertices = 0;
 };
 struct IndexBufferCreateInfo
 {
-    BulkResourceData resourceData = BulkResourceData();
+    DataSource sourceData = DataSource();
     Gfx::SeIndexType indexType = Gfx::SeIndexType::SE_INDEX_TYPE_UINT16;
 };
 struct UniformBufferCreateInfo
 {
-    BulkResourceData resourceData = BulkResourceData();
+    DataSource sourceData = DataSource();
     uint8 bDynamic = 0;
 };
 struct ShaderBufferCreateInfo
 {
-    BulkResourceData resourceData;
+    DataSource sourceData = DataSource();
     uint32 stride;
     uint8 bDynamic = 0;
 };

src/Engine/Graphics/RenderPass/BasePass.cpp

@@ -36,8 +36,8 @@ BasePass::BasePass(Gfx::PGraphics graphics, PScene scene)
 
     viewLayout = graphics->createDescriptorLayout("ViewLayout");
     viewLayout->addDescriptorBinding(0, Gfx::SE_DESCRIPTOR_TYPE_UNIFORM_BUFFER);
-    uniformInitializer.resourceData.size = sizeof(ViewParameter);
-    uniformInitializer.resourceData.data = (uint8*)&viewParams;
+    uniformInitializer.sourceData.size = sizeof(ViewParameter);
+    uniformInitializer.sourceData.data = (uint8*)&viewParams;
     uniformInitializer.bDynamic = true;
     viewParamBuffer = graphics->createUniformBuffer(uniformInitializer);
     viewLayout->create();
@@ -62,7 +62,7 @@ BasePass::~BasePass()
 
 void BasePass::beginFrame(const Component::Camera& cam) 
 {
-    BulkResourceData uniformUpdate;
+    DataSource uniformUpdate;
 
     viewParams.viewMatrix = cam.getViewMatrix();
     viewParams.projectionMatrix = viewport->getProjectionMatrix();

src/Engine/Graphics/RenderPass/BasePass.h

@@ -22,21 +22,21 @@ private:
     
     Array<Gfx::PDescriptorSet> descriptorSets;
     PCameraActor source;
-    Gfx::PPipelineLayout basePassLayout;
+    Gfx::OPipelineLayout basePassLayout;
     // Set 0: Light environment
     static constexpr uint32 INDEX_LIGHT_ENV = 0;
-    Gfx::PShaderBuffer oLightIndexList;
-    Gfx::PTexture oLightGrid;
-    Gfx::PDescriptorLayout lightLayout;
+    Gfx::OShaderBuffer oLightIndexList;
+    Gfx::OTexture oLightGrid;
+    Gfx::ODescriptorLayout lightLayout;
     // Set 1: viewParameter
     static constexpr uint32 INDEX_VIEW_PARAMS = 1;
-    Gfx::PDescriptorLayout viewLayout;
-    Gfx::PUniformBuffer viewParamBuffer;
+    Gfx::ODescriptorLayout viewLayout;
+    Gfx::OUniformBuffer viewParamBuffer;
     // Set 2: materials, generated
     static constexpr uint32 INDEX_MATERIAL = 2;
     // Set 3: primitive scene data
     static constexpr uint32 INDEX_SCENE_DATA = 3;
-    Gfx::PDescriptorLayout sceneLayout;
+    Gfx::ODescriptorLayout sceneLayout;
 };
 DEFINE_REF(BasePass)
 } // namespace Seele

src/Engine/Graphics/RenderPass/DebugPass.cpp

@@ -28,7 +28,7 @@ DebugPass::~DebugPass()
 
 void DebugPass::beginFrame(const Component::Camera& cam)
 {
-    BulkResourceData uniformUpdate;
+    DataSource uniformUpdate;
 
     viewParams.viewMatrix = cam.getViewMatrix();
     viewParams.projectionMatrix = viewport->getProjectionMatrix();
@@ -43,7 +43,7 @@ void DebugPass::beginFrame(const Component::Camera& cam)
     descriptorSet->writeChanges();
     
     VertexBufferCreateInfo vertexBufferInfo = {
-        .resourceData = {
+        .sourceData = {
             .size = sizeof(DebugVertex) * passData.vertices.size(),
             .data = (uint8*)passData.vertices.data(),
         },
@@ -75,7 +75,7 @@ void DebugPass::endFrame()
 void DebugPass::publishOutputs()
 {
     UniformBufferCreateInfo viewCreateInfo = {
-        .resourceData = BulkResourceData {
+        .sourceData = DataSource {
             .size = sizeof(ViewParameter),
             .data = nullptr,
         },

src/Engine/Graphics/RenderPass/DepthPrepass.cpp

@@ -19,8 +19,8 @@ DepthPrepass::DepthPrepass(Gfx::PGraphics graphics, PScene scene)
 
     viewLayout = graphics->createDescriptorLayout("ViewLayout");
     viewLayout->addDescriptorBinding(0, Gfx::SE_DESCRIPTOR_TYPE_UNIFORM_BUFFER);
-    uniformInitializer.resourceData.size = sizeof(ViewParameter);
-    uniformInitializer.resourceData.data = (uint8*)&viewParams;
+    uniformInitializer.sourceData.size = sizeof(ViewParameter);
+    uniformInitializer.sourceData.data = (uint8*)&viewParams;
     uniformInitializer.bDynamic = true;
     viewParamBuffer = graphics->createUniformBuffer(uniformInitializer);
     viewLayout->create();
@@ -33,7 +33,7 @@ DepthPrepass::~DepthPrepass()
 
 void DepthPrepass::beginFrame(const Component::Camera& cam) 
 {
-    BulkResourceData uniformUpdate;
+    DataSource uniformUpdate;
 
     viewParams.viewMatrix = cam.getViewMatrix();
     viewParams.projectionMatrix = viewport->getProjectionMatrix();
@@ -70,7 +70,7 @@ void DepthPrepass::render()
             // VertexData => per meshtype
             // SceneData => per material instance
             Gfx::PRenderCommand command = graphics->createRenderCommand("DepthRender");
-            Gfx::PPipelineLayout layout = graphics->createPipelineLayout(depthPrepassLayout);
+            Gfx::OPipelineLayout layout = graphics->createPipelineLayout(depthPrepassLayout);
             layout->addDescriptorLayout(INDEX_MATERIAL, materialData.material->getDescriptorLayout());
             layout->addDescriptorLayout(INDEX_VERTEX_DATA, vertexData->getVertexDataLayout());
             layout->addDescriptorLayout(INDEX_SCENE_DATA, vertexData->getInstanceDataLayout());

src/Engine/Graphics/RenderPass/DepthPrepass.h

@@ -21,18 +21,18 @@ private:
 
     Array<Gfx::PDescriptorSet> descriptorSets;
     
-    Gfx::PPipelineLayout depthPrepassLayout;
+    Gfx::OPipelineLayout depthPrepassLayout;
     // Set 0: viewParameter
     static constexpr uint32 INDEX_VIEW_PARAMS = 0;
-    Gfx::PDescriptorLayout viewLayout;
-    Gfx::PUniformBuffer viewParamBuffer;
+    Gfx::ODescriptorLayout viewLayout;
+    Gfx::OUniformBuffer viewParamBuffer;
     // Set 1: materials, generated
     static constexpr uint32 INDEX_MATERIAL = 1;
     // Set 2: vertices, from VertexData
     static constexpr uint32 INDEX_VERTEX_DATA = 2;
     // Set 3: mesh data, either index buffer or meshlet data
     static constexpr uint32 INDEX_SCENE_DATA = 3;
-    Gfx::PDescriptorLayout sceneDataLayout;
+    Gfx::ODescriptorLayout sceneDataLayout;
 };
 DEFINE_REF(DepthPrepass)
 } // namespace Seele

src/Engine/Graphics/RenderPass/LightCullingPass.cpp

@@ -22,7 +22,7 @@ void LightCullingPass::beginFrame(const Component::Camera& cam)
     uint32_t viewportWidth = viewport->getSizeX();
     uint32_t viewportHeight = viewport->getSizeY();
 
-    BulkResourceData uniformUpdate;
+    DataSource uniformUpdate;
     viewParams.viewMatrix = cam.getViewMatrix();
     viewParams.projectionMatrix = viewport->getProjectionMatrix();
     viewParams.cameraPosition = Vector4(cam.getCameraPosition(), 1);
@@ -31,7 +31,7 @@ void LightCullingPass::beginFrame(const Component::Camera& cam)
     uniformUpdate.data = (uint8*)&viewParams;
     viewParamsBuffer->updateContents(uniformUpdate);
 
-    BulkResourceData counterReset;
+    DataSource counterReset;
     uint32 reset = 0;
     counterReset.data = (uint8*)&reset;
     counterReset.size = sizeof(uint32);
@@ -161,7 +161,7 @@ void LightCullingPass::publishOutputs()
     uint32 counterReset = 0;
     ShaderBufferCreateInfo structInfo = 
     {
-        .resourceData = {
+        .sourceData = {
             .size = sizeof(uint32),
             .data = (uint8*)&counterReset,
             .owner = Gfx::QueueType::COMPUTE,
@@ -172,7 +172,7 @@ void LightCullingPass::publishOutputs()
     oLightIndexCounter = graphics->createShaderBuffer(structInfo);
     tLightIndexCounter = graphics->createShaderBuffer(structInfo);
     structInfo = {
-        .resourceData = {
+        .sourceData = {
             .size = (uint32)sizeof(uint32) 
                 * dispatchParams.numThreadGroups.x 
                 * dispatchParams.numThreadGroups.y 
@@ -248,23 +248,23 @@ void LightCullingPass::setupFrustums()
     pipelineInfo.pipelineLayout = frustumLayout;
     frustumPipeline = graphics->createComputePipeline(pipelineInfo);
     
-    BulkResourceData resourceInfo;
+    DataSource resourceInfo;
     UniformBufferCreateInfo uniformInfo;
     resourceInfo.size = sizeof(ViewParameter);
     resourceInfo.data = (uint8*)&viewParams;
     resourceInfo.owner = Gfx::QueueType::COMPUTE;
-    uniformInfo.resourceData = resourceInfo;
+    uniformInfo.sourceData = resourceInfo;
     uniformInfo.bDynamic = false;
     viewParamsBuffer = graphics->createUniformBuffer(uniformInfo);
 
     resourceInfo.size = sizeof(DispatchParams);
     resourceInfo.data = (uint8*)&dispatchParams;
-    uniformInfo.resourceData = resourceInfo;
+    uniformInfo.sourceData = resourceInfo;
     uniformInfo.bDynamic = false;
     dispatchParamsBuffer = graphics->createUniformBuffer(uniformInfo);
 
     ShaderBufferCreateInfo structuredInfo = {
-        .resourceData = {
+        .sourceData = {
             .size = sizeof(Frustum) * numThreads.x * numThreads.y * numThreads.z,
             .data = nullptr,
         },

src/Engine/Graphics/RenderPass/SkyboxRenderPass.cpp

@@ -70,7 +70,7 @@ SkyboxRenderPass::SkyboxRenderPass(Gfx::PGraphics graphics, PScene scene)
     };
 
     VertexBufferCreateInfo vertexBufferInfo = {
-        .resourceData = {
+        .sourceData = {
             .size = sizeof(Vector) * vertices.size(),
             .data = (uint8*)vertices.data(),
         },
@@ -86,7 +86,7 @@ SkyboxRenderPass::~SkyboxRenderPass()
 
 void SkyboxRenderPass::beginFrame(const Component::Camera& cam)
 {
-    BulkResourceData uniformUpdate;
+    DataSource uniformUpdate;
 
     viewParams.viewMatrix = cam.getViewMatrix();
     viewParams.projectionMatrix = viewport->getProjectionMatrix();
@@ -127,7 +127,7 @@ void SkyboxRenderPass::endFrame()
 void SkyboxRenderPass::publishOutputs()
 {
     UniformBufferCreateInfo viewCreateInfo = {
-        .resourceData = BulkResourceData {
+        .sourceData = DataSource {
             .size = sizeof(ViewParameter),
             .data = nullptr,
         },

src/Engine/Graphics/RenderPass/TextPass.cpp

@@ -43,7 +43,7 @@ void TextPass::beginFrame(const Component::Camera&)
             x += (glyph.advance >> 6) * render.scale;
         }
         VertexBufferCreateInfo vbInfo = {
-            .resourceData = {
+            .sourceData = {
                 .size = static_cast<uint32>(instanceData.size() * sizeof(GlyphInstanceData)),
                 .data = reinterpret_cast<uint8*>(instanceData.data()),
                 },
@@ -60,7 +60,7 @@ void TextPass::beginFrame(const Component::Camera&)
         };
     }
     auto proj = viewport->getProjectionMatrix();
-    BulkResourceData projectionUpdate = {
+    DataSource projectionUpdate = {
         .size = sizeof(Matrix4),
         .data = (uint8*)&proj,
     };
@@ -156,7 +156,7 @@ void TextPass::createRenderPass()
     textureArrayLayout->create();
 
     projectionBuffer = graphics->createUniformBuffer({
-        .resourceData = {
+        .sourceData = {
             .size = sizeof(Matrix4),
             .data = nullptr,
         },

src/Engine/Graphics/RenderPass/UIPass.cpp

@@ -18,7 +18,7 @@ UIPass::~UIPass()
 void UIPass::beginFrame(const Component::Camera&) 
 {
     VertexBufferCreateInfo info = {
-        .resourceData = {
+        .sourceData = {
             .size = (uint32)(sizeof(UI::RenderElementStyle) * renderElements.size()),
             .data = (uint8*)renderElements.data()
         },
@@ -148,7 +148,7 @@ void UIPass::createRenderPass()
 
     Matrix4 projectionMatrix = glm::ortho(0, 1, 1, 0);
     UniformBufferCreateInfo info = {
-        .resourceData = {
+        .sourceData = {
             .size = sizeof(Matrix4),
             .data = (uint8*)&projectionMatrix,
         },
@@ -158,7 +158,7 @@ void UIPass::createRenderPass()
     Gfx::PSamplerState backgroundSampler = graphics->createSamplerState({});
 
     info = {
-        .resourceData = {
+        .sourceData = {
             .size = sizeof(uint32),
             .data = nullptr
         },

src/Engine/Graphics/RenderPass/UIPass.h

@@ -18,22 +18,22 @@ public:
     virtual void publishOutputs() override;
     virtual void createRenderPass() override;
 private:
-    Gfx::PRenderTargetAttachment renderTarget;
-    Gfx::PTexture2D colorBuffer;
-    Gfx::PRenderTargetAttachment depthAttachment;
-    Gfx::PTexture2D depthBuffer;
+    Gfx::ORenderTargetAttachment renderTarget;
+    Gfx::OTexture2D colorBuffer;
+    Gfx::ORenderTargetAttachment depthAttachment;
+    Gfx::OTexture2D depthBuffer;
 
-    Gfx::PDescriptorLayout descriptorLayout;
-    Gfx::PDescriptorSet descriptorSet;
+    Gfx::ODescriptorLayout descriptorLayout;
+    Gfx::ODescriptorSet descriptorSet;
 
-    Gfx::PUniformBuffer numTexturesBuffer;
-    Gfx::PVertexBuffer elementBuffer;
+    Gfx::OUniformBuffer numTexturesBuffer;
+    Gfx::OVertexBuffer elementBuffer;
 
-    Gfx::PVertexDeclaration declaration;
-    Gfx::PVertexShader vertexShader;
-    Gfx::PFragmentShader fragmentShader;
-    Gfx::PPipelineLayout pipelineLayout;
-    Gfx::PGraphicsPipeline pipeline;
+    Gfx::OVertexDeclaration declaration;
+    Gfx::OVertexShader vertexShader;
+    Gfx::OFragmentShader fragmentShader;
+    Gfx::OPipelineLayout pipelineLayout;
+    Gfx::OGraphicsPipeline pipeline;
 
     Array<UI::RenderElementStyle> renderElements;
     Array<Gfx::PTexture> usedTextures;

src/Engine/Graphics/RenderTarget.cpp

@@ -11,35 +11,35 @@ RenderTargetLayout::RenderTargetLayout()
 {
 }
 
-RenderTargetLayout::RenderTargetLayout(PRenderTargetAttachment depthAttachment)
+RenderTargetLayout::RenderTargetLayout(ORenderTargetAttachment depthAttachment)
 	: inputAttachments()
 	, colorAttachments()
-	, depthAttachment(depthAttachment)
+	, depthAttachment(std::move(depthAttachment))
 	, width(depthAttachment->getTexture()->getSizeX())
 	, height(depthAttachment->getTexture()->getSizeY())
 {
 }
 
-RenderTargetLayout::RenderTargetLayout(PRenderTargetAttachment colorAttachment, PRenderTargetAttachment depthAttachment)
+RenderTargetLayout::RenderTargetLayout(ORenderTargetAttachment colorAttachment, ORenderTargetAttachment depthAttachment)
 	: inputAttachments()
-	, depthAttachment(depthAttachment)
+	, depthAttachment(std::move(depthAttachment))
 	, width(depthAttachment->getTexture()->getSizeX())
 	, height(depthAttachment->getTexture()->getSizeY())
 {
 	colorAttachments.add(colorAttachment);
 }
-RenderTargetLayout::RenderTargetLayout(Array<PRenderTargetAttachment> colorAttachments, PRenderTargetAttachment depthAttachment)
+RenderTargetLayout::RenderTargetLayout(Array<ORenderTargetAttachment> colorAttachments, ORenderTargetAttachment depthAttachment)
 	: inputAttachments()
-	, colorAttachments(colorAttachments)
-	, depthAttachment(depthAttachment)
+	, colorAttachments(std::move(colorAttachments))
+	, depthAttachment(std::move(depthAttachment))
 	, width(depthAttachment->getTexture()->getSizeX())
 	, height(depthAttachment->getTexture()->getSizeY())
 {
 }
-RenderTargetLayout::RenderTargetLayout(Array<PRenderTargetAttachment> inputAttachments, Array<PRenderTargetAttachment> colorAttachments, PRenderTargetAttachment depthAttachment)
-	: inputAttachments(inputAttachments)
-	, colorAttachments(colorAttachments)
-	, depthAttachment(depthAttachment)
+RenderTargetLayout::RenderTargetLayout(Array<ORenderTargetAttachment> inputAttachments, Array<ORenderTargetAttachment> colorAttachments, ORenderTargetAttachment depthAttachment)
+	: inputAttachments(std::move(inputAttachments))
+	, colorAttachments(std::move(colorAttachments))
+	, depthAttachment(std::move(depthAttachment))
 	, width(depthAttachment->getTexture()->getSizeX())
 	, height(depthAttachment->getTexture()->getSizeY())
 {

src/Engine/Graphics/RenderTarget.h

@@ -15,7 +15,7 @@ public:
     virtual void beginFrame() = 0;
     virtual void endFrame() = 0;
     virtual void onWindowCloseEvent() = 0;
-    virtual PTexture2D getBackBuffer() const = 0;
+    virtual PTexture2D getBackBuffer() = 0;
     virtual void setKeyCallback(std::function<void(KeyCode, InputAction, KeyModifier)> callback) = 0;
     virtual void setMouseMoveCallback(std::function<void(double, double)> callback) = 0;
     virtual void setMouseButtonCallback(std::function<void(MouseButton, InputAction, KeyModifier)> callback) = 0;
@@ -167,13 +167,13 @@ class RenderTargetLayout
 {
 public:
     RenderTargetLayout();
-    RenderTargetLayout(PRenderTargetAttachment depthAttachment);
-    RenderTargetLayout(PRenderTargetAttachment colorAttachment, PRenderTargetAttachment depthAttachment);
-    RenderTargetLayout(Array<PRenderTargetAttachment> colorAttachments, PRenderTargetAttachment depthAttachmet);
-    RenderTargetLayout(Array<PRenderTargetAttachment> inputAttachments, Array<PRenderTargetAttachment> colorAttachments, PRenderTargetAttachment depthAttachment);
-    Array<PRenderTargetAttachment> inputAttachments;
-    Array<PRenderTargetAttachment> colorAttachments;
-    PRenderTargetAttachment depthAttachment;
+    RenderTargetLayout(ORenderTargetAttachment depthAttachment);
+    RenderTargetLayout(ORenderTargetAttachment colorAttachment, ORenderTargetAttachment depthAttachment);
+    RenderTargetLayout(Array<ORenderTargetAttachment> colorAttachments, ORenderTargetAttachment depthAttachmet);
+    RenderTargetLayout(Array<ORenderTargetAttachment> inputAttachments, Array<ORenderTargetAttachment> colorAttachments, ORenderTargetAttachment depthAttachment);
+    Array<ORenderTargetAttachment> inputAttachments;
+    Array<ORenderTargetAttachment> colorAttachments;
+    ORenderTargetAttachment depthAttachment;
     uint32 width;
     uint32 height;
 };
@@ -182,12 +182,12 @@ DEFINE_REF(RenderTargetLayout)
 class RenderPass
 {
 public:
-    RenderPass(PRenderTargetLayout layout) : layout(layout) {}
+    RenderPass(ORenderTargetLayout layout) : layout(std::move(layout)) {}
     virtual ~RenderPass() {}
-    inline PRenderTargetLayout getLayout() const { return layout; }
+    inline PRenderTargetLayout getLayout() { return layout; }
 
 protected:
-    PRenderTargetLayout layout;
+    ORenderTargetLayout layout;
 };
 DEFINE_REF(RenderPass)
 }

src/Engine/Graphics/Shader.cpp

@@ -1,4 +1,6 @@
 #include "Shader.h"
+#include "Graphics/RenderPass/DepthPrepass.h"
+#include "Graphics/RenderPass/BasePass.h"
 
 using namespace Seele;
 using namespace Seele::Gfx;
@@ -51,7 +53,6 @@ ShaderCollection& ShaderMap::createShaders(
 	PGraphics graphics,
 	RenderPassType renderPass,
 	PMaterial material,
-	VertexInputType* vertexInput,
 	bool /*bPositionOnly*/)
 {
 	std::scoped_lock lock(shadersLock);

src/Engine/Graphics/Shader.h

@@ -1,6 +1,7 @@
 #pragma once
 #include "Enums.h"
 #include "CRC.h"
+#include "Resources.h"
 
 namespace Seele
 {
@@ -86,9 +87,12 @@ struct PermutationId
 struct ShaderCollection
 {
     PermutationId id;
-    //PVertexDeclaration vertexDeclaration;
-    PVertexShader vertexShader;
-    PFragmentShader fragmentShader;
+
+    OVertexDeclaration vertexDeclaration;
+    OVertexShader vertexShader;
+    OTaskShader taskShader;
+    OMeshShader meshShader;
+    OFragmentShader fragmentShader;
 };
 class ShaderMap
 {

src/Engine/Graphics/StaticMeshVertexData.cpp

@@ -131,7 +131,7 @@ Gfx::PDescriptorSet StaticMeshVertexData::getVertexDataSet()
 void StaticMeshVertexData::resizeBuffers()
 {
     ShaderBufferCreateInfo createInfo = {
-        .resourceData = {
+        .sourceData = {
             .size = verticesAllocated * sizeof(Vector),
         },
         .stride = sizeof(Vector),
@@ -141,7 +141,7 @@ void StaticMeshVertexData::resizeBuffers()
     normals = graphics->createShaderBuffer(createInfo);
     tangents = graphics->createShaderBuffer(createInfo);
     biTangents = graphics->createShaderBuffer(createInfo);
-    createInfo.resourceData.size = verticesAllocated * sizeof(Vector2);
+    createInfo.sourceData.size = verticesAllocated * sizeof(Vector2);
     createInfo.stride = sizeof(Vector2);
     texCoords = graphics->createShaderBuffer(createInfo);
     
@@ -154,23 +154,23 @@ void StaticMeshVertexData::resizeBuffers()
 
 void StaticMeshVertexData::updateBuffers()
 {
-    positions->updateContents(BulkResourceData{
+    positions->updateContents(DataSource{
         .size = positionData.size() * sizeof(Vector),
         .data = (uint8*)positionData.data(),
         });
-    texCoords->updateContents(BulkResourceData{
+    texCoords->updateContents(DataSource{
         .size = texCoordsData.size() * sizeof(Vector2),
         .data = (uint8*)texCoordsData.data(),
         });
-    normals->updateContents(BulkResourceData{
+    normals->updateContents(DataSource{
         .size = normalData.size() * sizeof(Vector),
         .data = (uint8*)normalData.data(),
         });
-    tangents->updateContents(BulkResourceData{
+    tangents->updateContents(DataSource{
         .size = tangentData.size() * sizeof(Vector),
         .data = (uint8*)tangentData.data(),
         });
-    biTangents->updateContents(BulkResourceData{
+    biTangents->updateContents(DataSource{
         .size = biTangentData.size() * sizeof(Vector),
         .data = (uint8*)biTangentData.data(),
         });

src/Engine/Graphics/StaticMeshVertexData.h

@@ -24,17 +24,17 @@ public:
 private:
 	virtual void resizeBuffers() override;
 	virtual void updateBuffers() override;
-    Gfx::PShaderBuffer positions;
+    Gfx::OShaderBuffer positions;
 	Array<Vector> positionData;
-    Gfx::PShaderBuffer texCoords;
+    Gfx::OShaderBuffer texCoords;
 	Array<Vector2> texCoordsData;
-    Gfx::PShaderBuffer normals;
+    Gfx::OShaderBuffer normals;
 	Array<Vector> normalData;
-    Gfx::PShaderBuffer tangents;
+    Gfx::OShaderBuffer tangents;
 	Array<Vector> tangentData;
-    Gfx::PShaderBuffer biTangents;
+    Gfx::OShaderBuffer biTangents;
 	Array<Vector> biTangentData;
-		Gfx::PDescriptorLayout descriptorLayout;
-		Gfx::PDescriptorSet descriptorSet;
+	Gfx::ODescriptorLayout descriptorLayout;
+	Gfx::ODescriptorSet descriptorSet;
 };
 }

src/Engine/Graphics/VertexData.cpp

@@ -65,7 +65,7 @@ void VertexData::loadMesh(MeshId id, Array<Meshlet> loadedMeshlets)
         currentMesh += numMeshlets;
     }
     meshletBuffer = graphics->createShaderBuffer(ShaderBufferCreateInfo {
-        .resourceData = {
+        .sourceData = {
             .size = sizeof(MeshletDescription) * meshlets.size(),
             .data = (uint8*)meshlets.data()
         },
@@ -73,7 +73,7 @@ void VertexData::loadMesh(MeshId id, Array<Meshlet> loadedMeshlets)
         .bDynamic = true,
     });
     vertexIndicesBuffer = graphics->createShaderBuffer(ShaderBufferCreateInfo {
-        .resourceData = {
+        .sourceData = {
             .size = sizeof(uint32) * vertexIndices.size(),
             .data = (uint8*)vertexIndices.data(),
         },
@@ -81,7 +81,7 @@ void VertexData::loadMesh(MeshId id, Array<Meshlet> loadedMeshlets)
         .bDynamic = true,
     });
     primitiveIndicesBuffer = graphics->createShaderBuffer(ShaderBufferCreateInfo {
-        .resourceData = {
+        .sourceData = {
             .size = sizeof(uint8) * primitiveIndices.size(),
             .data = (uint8*)primitiveIndices.data(),
         },
@@ -108,7 +108,7 @@ void VertexData::createDescriptors()
                 }
             }
             Gfx::PShaderBuffer instanceBuffer = graphics->createShaderBuffer(ShaderBufferCreateInfo{
-                .resourceData = {
+                .sourceData = {
                     .size = sizeof(InstanceData) * instanceData.size(),
                     .data = (uint8*)instanceData.data(),
                 },
@@ -119,7 +119,7 @@ void VertexData::createDescriptors()
             if (Gfx::useMeshShading)
             {
                 Gfx::PShaderBuffer meshDataBuffer = graphics->createShaderBuffer(ShaderBufferCreateInfo{
-                    .resourceData = {
+                    .sourceData = {
                         .size = sizeof(MeshData) * meshes.size(),
                         .data = (uint8*)meshes.data(),
                     },

src/Engine/Graphics/VertexData.h

@@ -101,14 +101,14 @@ protected:
     Array<MeshletDescription> meshlets;
     Array<uint8> primitiveIndices;
     Array<uint32> vertexIndices;
-    Gfx::PGraphics graphics;
-    Gfx::PDescriptorLayout instanceDataLayout;
+    Gfx::OGraphics graphics;
+    Gfx::ODescriptorLayout instanceDataLayout;
     // for mesh shading
-    Gfx::PShaderBuffer meshletBuffer;
-    Gfx::PShaderBuffer vertexIndicesBuffer;
-    Gfx::PShaderBuffer primitiveIndicesBuffer;
+    Gfx::OShaderBuffer meshletBuffer;
+    Gfx::OShaderBuffer vertexIndicesBuffer;
+    Gfx::OShaderBuffer primitiveIndicesBuffer;
     // for legacy pipeline
-    Gfx::PIndexBuffer indexBuffer;
+    Gfx::OIndexBuffer indexBuffer;
     uint64 idCounter;
 	uint64 head;
 	uint64 verticesAllocated;

src/Engine/Graphics/Vulkan/Allocator.cpp

@@ -43,7 +43,7 @@ void SubAllocation::invalidateMemory()
     owner->invalidateMemory();
 }
 
-Allocation::Allocation(PGraphics graphics, Allocator *allocator, VkDeviceSize size, uint8 memoryTypeIndex,
+Allocation::Allocation(PGraphics graphics, PAllocator allocator, VkDeviceSize size, uint8 memoryTypeIndex,
                        VkMemoryPropertyFlags properties, VkMemoryDedicatedAllocateInfo *dedicatedInfo)
     : device(graphics->getDevice())
     , allocator(allocator)

src/Engine/Graphics/Vulkan/Allocator.h

@@ -95,11 +95,11 @@ public:
 
 private:
 	VkDevice device;
-	Allocator *allocator;
+	PAllocator allocator;
 	VkDeviceSize bytesAllocated;
 	VkDeviceSize bytesUsed;
 	VkDeviceMemory allocatedMemory;
-	std::map<VkDeviceSize, SubAllocation *> activeAllocations;
+	std::map<VkDeviceSize, PSubAllocation> activeAllocations;
 	std::map<VkDeviceSize, PSubAllocation> freeRanges;
 	std::mutex lock;
 	void *mappedPointer;
@@ -118,9 +118,9 @@ class Allocator
 public:
 	Allocator(PGraphics graphics);
 	~Allocator();
-	PSubAllocation allocate(const VkMemoryRequirements2 &requirements, VkMemoryPropertyFlags props,
+	OSubAllocation allocate(const VkMemoryRequirements2 &requirements, VkMemoryPropertyFlags props,
 							VkMemoryDedicatedAllocateInfo *dedicatedInfo = nullptr);
-	inline PSubAllocation allocate(const VkMemoryRequirements2 &requirements, VkMemoryPropertyFlags props,
+	OSubAllocation allocate(const VkMemoryRequirements2 &requirements, VkMemoryPropertyFlags props,
 								   VkBuffer buffer)
 	{
 		VkMemoryDedicatedAllocateInfo allocInfo;
@@ -130,7 +130,7 @@ public:
 		allocInfo.image = VK_NULL_HANDLE;
 		return allocate(requirements, props, &allocInfo);
 	}
-	inline PSubAllocation allocate(const VkMemoryRequirements2 &requirements, VkMemoryPropertyFlags props,
+	OSubAllocation allocate(const VkMemoryRequirements2 &requirements, VkMemoryPropertyFlags props,
 								   VkImage image)
 	{
 		VkMemoryDedicatedAllocateInfo allocInfo;

src/Engine/Graphics/Vulkan/Buffer.cpp

@@ -12,9 +12,9 @@ struct PendingBuffer
     bool bWriteOnly;
 };
 
-static std::map<Vulkan::ShaderBuffer *, PendingBuffer> pendingBuffers;
+static std::map<Vulkan::Buffer*, PendingBuffer> pendingBuffers;
 
-ShaderBuffer::ShaderBuffer(PGraphics graphics, uint64 size, VkBufferUsageFlags usage, Gfx::QueueType& queueType, bool bDynamic)
+Buffer::Buffer(PGraphics graphics, uint64 size, VkBufferUsageFlags usage, Gfx::QueueType& queueType, bool bDynamic)
     : graphics(graphics)
     , currentBuffer(0)
     , size(size)
@@ -57,7 +57,7 @@ ShaderBuffer::ShaderBuffer(PGraphics graphics, uint64 size, VkBufferUsageFlags u
     }
 }
 
-ShaderBuffer::~ShaderBuffer()
+Buffer::~Buffer()
 {
     //PCmdBuffer cmdBuffer = graphics->getQueueCommands(owner)->getCommands();
     //VkDevice device = graphics->getDevice();
@@ -75,12 +75,12 @@ ShaderBuffer::~ShaderBuffer()
     graphics = nullptr;
 }
 
-VkDeviceSize ShaderBuffer::getOffset() const
+VkDeviceSize Buffer::getOffset() const
 {
     return buffers[currentBuffer].allocation->getOffset();
 }
 
-void ShaderBuffer::executeOwnershipBarrier(Gfx::QueueType newOwner)
+void Buffer::executeOwnershipBarrier(Gfx::QueueType newOwner)
 {
     VkBufferMemoryBarrier barrier =
         init::BufferMemoryBarrier();
@@ -146,7 +146,7 @@ void ShaderBuffer::executeOwnershipBarrier(Gfx::QueueType newOwner)
     sourceManager->submitCommands();
 }
 
-void ShaderBuffer::executePipelineBarrier(VkAccessFlags srcAccess, VkPipelineStageFlags srcStage, 
+void Buffer::executePipelineBarrier(VkAccessFlags srcAccess, VkPipelineStageFlags srcStage,
         VkAccessFlags dstAccess, VkPipelineStageFlags dstStage) 
 {
     PCmdBuffer commandBuffer = graphics->getQueueCommands(owner)->getCommands();
@@ -166,12 +166,12 @@ void ShaderBuffer::executePipelineBarrier(VkAccessFlags srcAccess, VkPipelineSta
     vkCmdPipelineBarrier(commandBuffer->getHandle(), srcStage, dstStage, 0, 0, nullptr, numBuffers, dynamicBarriers, 0, nullptr);
 }
 
-void *ShaderBuffer::lock(bool bWriteOnly)
+void * Buffer::lock(bool bWriteOnly)
 {
     return lockRegion(0, size, bWriteOnly);
 }
 
-void *ShaderBuffer::lockRegion(uint64 regionOffset, uint64 regionSize, bool bWriteOnly)
+void * Buffer::lockRegion(uint64 regionOffset, uint64 regionSize, bool bWriteOnly)
 {
     void *data = nullptr;
 
@@ -243,7 +243,7 @@ void *ShaderBuffer::lockRegion(uint64 regionOffset, uint64 regionSize, bool bWri
     return data;
 }
 
-void ShaderBuffer::unlock()
+void Buffer::unlock()
 {
     auto found = pendingBuffers.find(this);
     if (found != pendingBuffers.end())
@@ -270,18 +270,18 @@ void ShaderBuffer::unlock()
 }
 
 UniformBuffer::UniformBuffer(PGraphics graphics, const UniformBufferCreateInfo &createInfo)
-    : Gfx::UniformBuffer(graphics->getFamilyMapping(), createInfo.resourceData)
-    , Vulkan::ShaderBuffer(graphics, createInfo.resourceData.size, VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT, currentOwner, createInfo.bDynamic)
+    : Gfx::UniformBuffer(graphics->getFamilyMapping(), createInfo.sourceData)
+    , Vulkan::Buffer(graphics, createInfo.sourceData.size, VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT, currentOwner, createInfo.bDynamic)
     , dedicatedStagingBuffer(nullptr)
 {
     if(createInfo.bDynamic)
     {
-        dedicatedStagingBuffer = graphics->getStagingManager()->allocateStagingBuffer(createInfo.resourceData.size, VK_BUFFER_USAGE_TRANSFER_SRC_BIT);
+        dedicatedStagingBuffer = graphics->getStagingManager()->allocateStagingBuffer(createInfo.sourceData.size, VK_BUFFER_USAGE_TRANSFER_SRC_BIT);
     }
-    if (createInfo.resourceData.data != nullptr)
+    if (createInfo.sourceData.data != nullptr)
     {
         void *data = lock();
-        std::memcpy(data, createInfo.resourceData.data, createInfo.resourceData.size);
+        std::memcpy(data, createInfo.sourceData.data, createInfo.sourceData.size);
         unlock();
     }
 }
@@ -290,15 +290,15 @@ UniformBuffer::~UniformBuffer()
 {
 }
 
-bool UniformBuffer::updateContents(const BulkResourceData &resourceData) 
+bool UniformBuffer::updateContents(const DataSource &sourceData) 
 {
-    if(!Gfx::UniformBuffer::updateContents(resourceData))
+    if(!Gfx::UniformBuffer::updateContents(sourceData))
     {
         // no update was performed, skip
         return false;
     }
     void* data = lock();
-    std::memcpy(data, resourceData.data, resourceData.size);
+    std::memcpy(data, sourceData.data, sourceData.size);
     unlock();
     return true;
 }
@@ -308,7 +308,7 @@ void* UniformBuffer::lock(bool bWriteOnly)
     {
         return dedicatedStagingBuffer->getMappedPointer();
     }
-    return ShaderBuffer::lock(bWriteOnly);
+    return Vulkan::Buffer::lock(bWriteOnly);
 }
 
 void UniformBuffer::unlock()
@@ -321,13 +321,13 @@ void UniformBuffer::unlock()
 
         VkBufferCopy region;
         std::memset(&region, 0, sizeof(VkBufferCopy));
-        region.size = ShaderBuffer::size;
+        region.size = Vulkan::Buffer::size;
         vkCmdCopyBuffer(cmdHandle, dedicatedStagingBuffer->getHandle(), buffers[currentBuffer].buffer, 1, &region);
         graphics->getQueueCommands(currentOwner)->submitCommands();
     }
     else
     {
-        ShaderBuffer::unlock();
+        Vulkan::Buffer::unlock();
     }
 }
 
@@ -338,13 +338,13 @@ void UniformBuffer::requestOwnershipTransfer(Gfx::QueueType newOwner)
 
 void UniformBuffer::executeOwnershipBarrier(Gfx::QueueType newOwner)
 {
-    Vulkan::ShaderBuffer::executeOwnershipBarrier(newOwner);
+    Vulkan::Buffer::executeOwnershipBarrier(newOwner);
 }
 
 void UniformBuffer::executePipelineBarrier(VkAccessFlags srcAccess, VkPipelineStageFlags srcStage, 
         VkAccessFlags dstAccess, VkPipelineStageFlags dstStage) 
 {
-    Vulkan::ShaderBuffer::executePipelineBarrier(srcAccess, srcStage, dstAccess, dstStage);
+    Vulkan::Buffer::executePipelineBarrier(srcAccess, srcStage, dstAccess, dstStage);
 }
 
 VkAccessFlags UniformBuffer::getSourceAccessMask()
@@ -357,14 +357,14 @@ VkAccessFlags UniformBuffer::getDestAccessMask()
     return VK_ACCESS_UNIFORM_READ_BIT;
 }
 
-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)
+ShaderBuffer::ShaderBuffer(PGraphics graphics, const ShaderBufferCreateInfo &sourceData)
+    : Gfx::ShaderBuffer(graphics->getFamilyMapping(), sourceData.stride, sourceData.sourceData.size / sourceData.stride, sourceData.sourceData)
+    , Vulkan::Buffer(graphics, sourceData.sourceData.size, VK_BUFFER_USAGE_STORAGE_BUFFER_BIT, currentOwner, sourceData.bDynamic)
 {
-    if (resourceData.resourceData.data != nullptr)
+    if (sourceData.sourceData.data != nullptr)
     {
         void *data = lock();
-        std::memcpy(data, resourceData.resourceData.data, resourceData.resourceData.size);
+        std::memcpy(data, sourceData.sourceData.data, sourceData.sourceData.size);
         unlock();
     }
 }
@@ -373,13 +373,13 @@ ShaderBuffer::~ShaderBuffer()
 {
 }
 
-bool ShaderBuffer::updateContents(const BulkResourceData &resourceData) 
+bool ShaderBuffer::updateContents(const DataSource &sourceData) 
 {
-    assert(resourceData.size <= getSize());
-    Gfx::ShaderBuffer::updateContents(resourceData);
+    assert(sourceData.size <= getSize());
+    Gfx::ShaderBuffer::updateContents(sourceData);
     //We always want to update, as the contents could be different on the GPU
     void* data = lock();
-    std::memcpy(data, resourceData.data, resourceData.size);
+    std::memcpy(data, sourceData.data, sourceData.size);
     unlock();
     return true;
 }
@@ -402,13 +402,13 @@ void ShaderBuffer::unlock()
 
         VkBufferCopy region;
         std::memset(&region, 0, sizeof(VkBufferCopy));
-        region.size = ShaderBuffer::size;
+        region.size = Vulkan::Buffer::size;
         vkCmdCopyBuffer(cmdHandle, dedicatedStagingBuffer->getHandle(), buffers[currentBuffer].buffer, 1, &region);
         graphics->getQueueCommands(currentOwner)->submitCommands();
     }
     else
     {
-        ShaderBuffer::unlock();
+        Vulkan::Buffer::unlock();
     }
 }
 
@@ -438,14 +438,14 @@ VkAccessFlags ShaderBuffer::getDestAccessMask()
     return VK_ACCESS_MEMORY_READ_BIT;
 }
 
-VertexBuffer::VertexBuffer(PGraphics graphics, const VertexBufferCreateInfo &resourceData)
-    : Gfx::VertexBuffer(graphics->getFamilyMapping(), resourceData.numVertices, resourceData.vertexSize, resourceData.resourceData.owner)
-    , Vulkan::ShaderBuffer(graphics, resourceData.resourceData.size, VK_BUFFER_USAGE_VERTEX_BUFFER_BIT, currentOwner)
+VertexBuffer::VertexBuffer(PGraphics graphics, const VertexBufferCreateInfo &sourceData)
+    : Gfx::VertexBuffer(graphics->getFamilyMapping(), sourceData.numVertices, sourceData.vertexSize, sourceData.sourceData.owner)
+    , Vulkan::Buffer(graphics, sourceData.sourceData.size, VK_BUFFER_USAGE_VERTEX_BUFFER_BIT, currentOwner)
 {
-    if (resourceData.resourceData.data != nullptr)
+    if (sourceData.sourceData.data != nullptr)
     {
         void *data = lock();
-        std::memcpy(data, resourceData.resourceData.data, resourceData.resourceData.size);
+        std::memcpy(data, sourceData.sourceData.data, sourceData.sourceData.size);
         unlock();
     }
 }
@@ -454,7 +454,7 @@ VertexBuffer::~VertexBuffer()
 {
 }
 
-void VertexBuffer::updateRegion(BulkResourceData update)
+void VertexBuffer::updateRegion(DataSource update)
 {
     void* data = lockRegion(update.offset, update.size);
     std::memcpy(data, update.data, update.size);
@@ -476,13 +476,13 @@ void VertexBuffer::requestOwnershipTransfer(Gfx::QueueType newOwner)
 
 void VertexBuffer::executeOwnershipBarrier(Gfx::QueueType newOwner)
 {
-    Vulkan::ShaderBuffer::executeOwnershipBarrier(newOwner);
+    Vulkan::Buffer::executeOwnershipBarrier(newOwner);
 }
 
 void VertexBuffer::executePipelineBarrier(VkAccessFlags srcAccess, VkPipelineStageFlags srcStage, 
         VkAccessFlags dstAccess, VkPipelineStageFlags dstStage) 
 {
-    Vulkan::ShaderBuffer::executePipelineBarrier(srcAccess, srcStage, dstAccess, dstStage);
+    Vulkan::Buffer::executePipelineBarrier(srcAccess, srcStage, dstAccess, dstStage);
 }
 
 VkAccessFlags VertexBuffer::getSourceAccessMask()
@@ -495,14 +495,14 @@ VkAccessFlags VertexBuffer::getDestAccessMask()
     return VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT;
 }
 
-IndexBuffer::IndexBuffer(PGraphics graphics, const IndexBufferCreateInfo &resourceData)
-    : Gfx::IndexBuffer(graphics->getFamilyMapping(), resourceData.resourceData.size, resourceData.indexType, resourceData.resourceData.owner)
-    , Vulkan::ShaderBuffer(graphics, resourceData.resourceData.size, VK_BUFFER_USAGE_INDEX_BUFFER_BIT, currentOwner)
+IndexBuffer::IndexBuffer(PGraphics graphics, const IndexBufferCreateInfo &sourceData)
+    : Gfx::IndexBuffer(graphics->getFamilyMapping(), sourceData.sourceData.size, sourceData.indexType, sourceData.sourceData.owner)
+    , Vulkan::Buffer(graphics, sourceData.sourceData.size, VK_BUFFER_USAGE_INDEX_BUFFER_BIT, currentOwner)
 {
-    if (resourceData.resourceData.data != nullptr)
+    if (sourceData.sourceData.data != nullptr)
     {
         void *data = lock();
-        std::memcpy(data, resourceData.resourceData.data, resourceData.resourceData.size);
+        std::memcpy(data, sourceData.sourceData.data, sourceData.sourceData.size);
         unlock();
     }
 }
@@ -526,13 +526,13 @@ void IndexBuffer::requestOwnershipTransfer(Gfx::QueueType newOwner)
 
 void IndexBuffer::executeOwnershipBarrier(Gfx::QueueType newOwner)
 {
-    Vulkan::ShaderBuffer::executeOwnershipBarrier(newOwner);
+    Vulkan::Buffer::executeOwnershipBarrier(newOwner);
 }
 
 void IndexBuffer::executePipelineBarrier(VkAccessFlags srcAccess, VkPipelineStageFlags srcStage, 
         VkAccessFlags dstAccess, VkPipelineStageFlags dstStage) 
 {
-    Vulkan::ShaderBuffer::executePipelineBarrier(srcAccess, srcStage, dstAccess, dstStage);
+    Vulkan::Buffer::executePipelineBarrier(srcAccess, srcStage, dstAccess, dstStage);
 }
 
 VkAccessFlags IndexBuffer::getSourceAccessMask()

src/Engine/Graphics/Vulkan/Buffer.h

@@ -8,11 +8,11 @@ namespace Seele
 namespace Vulkan
 {
 
-class ShaderBuffer
+class Buffer
 {
 public:
-    ShaderBuffer(PGraphics graphics, uint64 size, VkBufferUsageFlags usage, Gfx::QueueType& queueType, bool bDynamic = false);
-    virtual ~ShaderBuffer();
+    Buffer(PGraphics graphics, uint64 size, VkBufferUsageFlags usage, Gfx::QueueType& queueType, bool bDynamic = false);
+    virtual ~Buffer();
     VkBuffer getHandle() const
     {
         return buffers[currentBuffer].buffer;
@@ -52,15 +52,15 @@ protected:
     virtual VkAccessFlags getSourceAccessMask() = 0;
     virtual VkAccessFlags getDestAccessMask() = 0;
 };
-DEFINE_REF(ShaderBuffer)
+DEFINE_REF(Buffer)
 
 DECLARE_REF(StagingBuffer)
-class UniformBuffer : public Gfx::UniformBuffer, public ShaderBuffer
+class UniformBuffer : public Gfx::UniformBuffer, public Buffer
 {
 public:
-    UniformBuffer(PGraphics graphics, const UniformBufferCreateInfo &resourceData);
+    UniformBuffer(PGraphics graphics, const UniformBufferCreateInfo &sourceData);
     virtual ~UniformBuffer();
-    virtual bool updateContents(const BulkResourceData &resourceData);
+    virtual bool updateContents(const DataSource &sourceData);
     
     virtual void* lock(bool bWriteOnly = true) override;
     virtual void unlock() override;
@@ -79,12 +79,12 @@ private:
 };
 DEFINE_REF(UniformBuffer)
 
-class ShaderBuffer : public Gfx::ShaderBuffer, public ShaderBuffer
+class ShaderBuffer : public Gfx::ShaderBuffer, public Buffer
 {
 public:
-    ShaderBuffer(PGraphics graphics, const ShaderBufferCreateInfo &resourceData);
+    ShaderBuffer(PGraphics graphics, const ShaderBufferCreateInfo &sourceData);
     virtual ~ShaderBuffer();
-    virtual bool updateContents(const BulkResourceData &resourceData);
+    virtual bool updateContents(const DataSource &sourceData);
 
     virtual void* lock(bool bWriteOnly = true) override;
     virtual void unlock() override;
@@ -102,13 +102,13 @@ private:
 };
 DEFINE_REF(ShaderBuffer)
 
-class VertexBuffer : public Gfx::VertexBuffer, public ShaderBuffer
+class VertexBuffer : public Gfx::VertexBuffer, public Buffer
 {
 public:
-    VertexBuffer(PGraphics graphics, const VertexBufferCreateInfo &resourceData);
+    VertexBuffer(PGraphics graphics, const VertexBufferCreateInfo &sourceData);
     virtual ~VertexBuffer();
 
-    virtual void updateRegion(BulkResourceData update) override;
+    virtual void updateRegion(DataSource update) override;
     virtual void download(Array<uint8>& buffer) override;
 protected:
     // Inherited via Vulkan::Buffer
@@ -122,10 +122,10 @@ protected:
 };
 DEFINE_REF(VertexBuffer)
 
-class IndexBuffer : public Gfx::IndexBuffer, public ShaderBuffer
+class IndexBuffer : public Gfx::IndexBuffer, public Buffer
 {
 public:
-    IndexBuffer(PGraphics graphics, const IndexBufferCreateInfo &resourceData);
+    IndexBuffer(PGraphics graphics, const IndexBufferCreateInfo &sourceData);
     virtual ~IndexBuffer();
 
     virtual void download(Array<uint8>& buffer) override;

src/Engine/Graphics/Vulkan/CommandBuffer.cpp

@@ -7,6 +7,7 @@
 #include "RenderPass.h"
 #include "Pipeline.h"
 #include "DescriptorSets.h"
+#include "RenderTarget.h"
 
 using namespace Seele;
 using namespace Seele::Vulkan;
@@ -277,16 +278,16 @@ void RenderCommand::bindDescriptor(const Array<Gfx::PDescriptorSet>& descriptorS
     vkCmdBindDescriptorSets(handle, VK_PIPELINE_BIND_POINT_GRAPHICS, pipeline->getLayout(), 0, (uint32)descriptorSets.size(), sets, 0, nullptr);
     delete[] sets;
 }
-void RenderCommand::bindVertexBuffer(const Array<VertexInputStream>& streams)
+void RenderCommand::bindVertexBuffer(const Array<Gfx::PVertexBuffer>& streams)
 {
     assert(threadId == std::this_thread::get_id());
     Array<VkBuffer> buffers(streams.size());
     Array<VkDeviceSize> offsets(streams.size());
     for(uint32 i = 0; i < streams.size(); ++i)
     {
-        PVertexBuffer buf = streams[i].vertexBuffer.cast<VertexBuffer>();
+        PVertexBuffer buf = streams[i].cast<VertexBuffer>();
         buffers[i] = buf->getHandle();
-        offsets[i] = streams[i].offset;
+        offsets[i] = 0;
     };
     vkCmdBindVertexBuffers(handle, 0, (uint32)streams.size(), buffers.data(), offsets.data());
 }
@@ -424,10 +425,13 @@ CommandBufferManager::CommandBufferManager(PGraphics graphics, PQueue queue)
 
     VK_CHECK(vkCreateCommandPool(graphics->getDevice(), &info, nullptr, &commandPool));
 
-    activeCmdBuffer = new CmdBuffer(graphics, commandPool, this);
-    activeCmdBuffer->begin();
+    {
         std::scoped_lock lock(allocatedBufferLock);
-    allocatedBuffers.add(activeCmdBuffer);
+        allocatedBuffers.add(new CmdBuffer(graphics, commandPool, this));
+    }
+    
+    activeCmdBuffer = allocatedBuffers.back();
+    activeCmdBuffer->begin();
 }
 
 CommandBufferManager::~CommandBufferManager()
@@ -455,10 +459,10 @@ PRenderCommand CommandBufferManager::createRenderCommand(PRenderPass renderPass,
             return cmdBuffer;
         }
     }
-    PRenderCommand result = new RenderCommand(graphics, commandPool);
+    allocatedRenderCommands.add(new RenderCommand(graphics, commandPool));
+    PRenderCommand result = allocatedRenderCommands.back();
     result->name = name;
     result->begin(renderPass, framebuffer);
-    allocatedRenderCommands.add(result);
     return result;
 }
 
@@ -475,10 +479,10 @@ PComputeCommand CommandBufferManager::createComputeCommand(const std::string& na
             return cmdBuffer;
         }
     }
-    PComputeCommand result = new ComputeCommand(graphics, commandPool);
+    allocatedComputeCommands.add(new ComputeCommand(graphics, commandPool));
+    PComputeCommand result = allocatedComputeCommands.back();
     result->name = name;
     result->begin(activeCmdBuffer);
-    allocatedComputeCommands.add(result);
     return result;
 }
 
@@ -517,7 +521,7 @@ void CommandBufferManager::submitCommands(PSemaphore signalSemaphore)
             assert(cmdBuffer->state == CmdBuffer::State::Submitted);
         }
     }
-    activeCmdBuffer = new CmdBuffer(graphics, commandPool, this);
-    allocatedBuffers.add(activeCmdBuffer);
+    allocatedBuffers.add(new CmdBuffer(graphics, commandPool, this));
+    activeCmdBuffer = allocatedBuffers.back();
     activeCmdBuffer->begin();
 }

src/Engine/Graphics/Vulkan/CommandBuffer.h

@@ -33,10 +33,6 @@ public:
 	void addWaitSemaphore(VkPipelineStageFlags stages, PSemaphore waitSemaphore);
 	void refreshFence();
 	void waitForCommand(uint32 timeToWait = 1000000u);
-	Fence* operator co_await()
-	{
-		return fence.getHandle();
-	}
 	PFence getFence();
 	PCommandBufferManager getManager();
 	enum State
@@ -51,7 +47,7 @@ public:
 private:
 	PGraphics graphics;
 	PCommandBufferManager manager;
-	PFence fence;
+	OFence fence;
 	State state;
 	VkViewport currentViewport;
 	VkRect2D currentScissor;
@@ -62,7 +58,7 @@ private:
 	Array<VkPipelineStageFlags> waitFlags;
 	Array<PRenderCommand> executingRenders;
 	Array<PComputeCommand> executingComputes;
-	Array<DescriptorSet*> boundDescriptors;
+	Array<PDescriptorSet> boundDescriptors;
 	friend class RenderCommand;
 	friend class CommandBufferManager;
 	friend class Queue;
@@ -88,7 +84,7 @@ public:
 	virtual void bindPipeline(Gfx::PGraphicsPipeline pipeline) override;
 	virtual void bindDescriptor(Gfx::PDescriptorSet descriptorSet) override;
 	virtual void bindDescriptor(const Array<Gfx::PDescriptorSet>& descriptorSets) override;
-	virtual void bindVertexBuffer(const Array<PVertexBuffer>& buffers) override;
+	virtual void bindVertexBuffer(const Array<Gfx::PVertexBuffer>& buffers) override;
 	virtual void bindIndexBuffer(Gfx::PIndexBuffer indexBuffer) override;
 	virtual void pushConstants(Gfx::PPipelineLayout layout, Gfx::SeShaderStageFlags stage, uint32 offset, uint32 size, const void* data) override;
 	virtual void draw(uint32 vertexCount, uint32 instanceCount, int32 firstVertex, uint32 firstInstance) override;
@@ -96,7 +92,7 @@ public:
 private:
 	PGraphicsPipeline pipeline;
 	bool ready;
-	Array<DescriptorSet*> boundDescriptors;
+	Array<PDescriptorSet> boundDescriptors;
 	VkViewport currentViewport;
 	VkRect2D currentScissor;
 	PGraphics graphics;
@@ -163,11 +159,11 @@ private:
 	uint32 queueFamilyIndex;
 	PCmdBuffer activeCmdBuffer;
 	std::mutex allocatedBufferLock;
-	Array<PCmdBuffer> allocatedBuffers;
+	Array<OCmdBuffer> allocatedBuffers;
 	std::mutex allocatedRenderLock;
 	std::mutex allocatedComputeLock;
-	Array<PRenderCommand> allocatedRenderCommands;
-	Array<PComputeCommand> allocatedComputeCommands;
+	Array<ORenderCommand> allocatedRenderCommands;
+	Array<OComputeCommand> allocatedComputeCommands;
 };
 DEFINE_REF(CommandBufferManager)
 } // namespace Vulkan

src/Engine/Graphics/Vulkan/DescriptorSets.cpp

@@ -312,7 +312,7 @@ DescriptorAllocator::~DescriptorAllocator()
     }
 }
 
-void DescriptorAllocator::allocateDescriptorSet(Gfx::PDescriptorSet &descriptorSet)
+Gfx::PDescriptorSet DescriptorAllocator::allocateDescriptorSet()
 {
     VkDescriptorSetLayout layoutHandle = layout.getHandle();
     VkDescriptorSetAllocateInfo allocInfo =

src/Engine/Graphics/Vulkan/DescriptorSets.h

@@ -131,7 +131,7 @@ class DescriptorAllocator : public Gfx::DescriptorAllocator
 public:
     DescriptorAllocator(PGraphics graphics, DescriptorLayout &layout);
     virtual ~DescriptorAllocator();
-    virtual void allocateDescriptorSet(Gfx::PDescriptorSet &descriptorSet);
+    virtual Gfx::PDescriptorSet allocateDescriptorSet() override;
     virtual void reset();
 
     inline VkDescriptorPool getHandle() const
@@ -147,7 +147,7 @@ private:
     PGraphics graphics;
     DescriptorLayout &layout;
     const static int maxSets = 64;
-    StaticArray<PDescriptorSet, maxSets> cachedHandles;
+    StaticArray<ODescriptorSet, maxSets> cachedHandles;
     VkDescriptorPool poolHandle;
     DescriptorAllocator* nextAlloc = nullptr;
 };

src/Engine/Graphics/Vulkan/Graphics.cpp

@@ -1,24 +1,22 @@
 #include "Containers/Array.h"
-#include "VulkanGraphics.h"
-#include "VulkanAllocator.h"
-#include "VulkanQueue.h"
-#include "VulkanInitializer.h"
-#include "VulkanCommandBuffer.h"
-#include "VulkanRenderPass.h"
-#include "VulkanFramebuffer.h"
-#include "VulkanPipelineCache.h"
-#include "VulkanDescriptorSets.h"
-#include "VulkanShader.h"
-#include "Graphics/GraphicsResources.h"
+#include "Graphics.h"
+#include "Allocator.h"
+#include "Buffer.h"
+#include "PipelineCache.h"
+#include "CommandBuffer.h"
+#include "Initializer.h"
+#include "RenderTarget.h"
+#include "RenderPass.h"
+#include "Framebuffer.h"
 #include <GLFW/glfw3.h>
 
 using namespace Seele;
 using namespace Seele::Vulkan;
 
-thread_local PCommandBufferManager Seele::Vulkan::Graphics::graphicsCommands = nullptr;
-thread_local PCommandBufferManager Seele::Vulkan::Graphics::computeCommands = nullptr;
-thread_local PCommandBufferManager Seele::Vulkan::Graphics::transferCommands = nullptr;
-thread_local PCommandBufferManager Seele::Vulkan::Graphics::dedicatedTransferCommands = nullptr;
+thread_local OCommandBufferManager Seele::Vulkan::Graphics::graphicsCommands = nullptr;
+thread_local OCommandBufferManager Seele::Vulkan::Graphics::computeCommands = nullptr;
+thread_local OCommandBufferManager Seele::Vulkan::Graphics::transferCommands = nullptr;
+thread_local OCommandBufferManager Seele::Vulkan::Graphics::dedicatedTransferCommands = nullptr;
 
 Graphics::Graphics()
     : instance(VK_NULL_HANDLE)
@@ -49,22 +47,22 @@ void Graphics::init(GraphicsInitializer initInfo)
     pipelineCache = new PipelineCache(this, "pipeline.cache");
 }
 
-Gfx::PWindow Graphics::createWindow(const WindowCreateInfo &createInfo)
+Gfx::OWindow Graphics::createWindow(const WindowCreateInfo &createInfo)
 {
-    PWindow result = new Window(this, createInfo);
+    OWindow result = new Window(this, createInfo);
     return result;
 }
 
-Gfx::PViewport Graphics::createViewport(Gfx::PWindow owner, const ViewportCreateInfo &viewportInfo)
+Gfx::OViewport Graphics::createViewport(Gfx::PWindow owner, const ViewportCreateInfo &viewportInfo)
 {
-    PViewport result = new Viewport(this, owner, viewportInfo);
+    OViewport result = new Viewport(this, owner, viewportInfo);
     std::scoped_lock lock(viewportLock);
     viewports.add(result);
     return result;
 }
-Gfx::PRenderPass Graphics::createRenderPass(Gfx::PRenderTargetLayout layout, Gfx::PViewport renderArea)
+Gfx::ORenderPass Graphics::createRenderPass(Gfx::ORenderTargetLayout layout, Gfx::PViewport renderArea)
 {
-    PRenderPass result = new RenderPass(this, layout, renderArea);
+    ORenderPass result = new RenderPass(this, std::move(layout), renderArea);
     return result;
 }
 void Graphics::beginRenderPass(Gfx::PRenderPass renderPass)
@@ -77,12 +75,12 @@ void Graphics::beginRenderPass(Gfx::PRenderPass renderPass)
         auto found = allocatedFramebuffers.find(framebufferHash);
         if (found == allocatedFramebuffers.end())
         {
-            framebuffer = new Framebuffer(this, rp, rp->getLayout());
-            allocatedFramebuffers[framebufferHash] = framebuffer;
+            allocatedFramebuffers[framebufferHash] = new Framebuffer(this, rp, rp->getLayout());
+            framebuffer = allocatedFramebuffers[framebufferHash];
         }
         else
         {
-            framebuffer = found->value;
+            framebuffer = std::move(found->value);
         }
     }
     getGraphicsCommands()->getCommands()->beginRenderPass(rp, framebuffer);
@@ -110,67 +108,67 @@ void Graphics::executeCommands(const Array<Gfx::PComputeCommand>& commands)
     getComputeCommands()->getCommands()->executeCommands(commands);
 }
 
-Gfx::PTexture2D Graphics::createTexture2D(const TextureCreateInfo &createInfo)
+Gfx::OTexture2D Graphics::createTexture2D(const TextureCreateInfo &createInfo)
 {
-    PTexture2D result = new Texture2D(this, createInfo);
+    OTexture2D result = new Texture2D(this, createInfo);
     return result;
 }
 
-Gfx::PTexture3D Graphics::createTexture3D(const TextureCreateInfo &createInfo)
+Gfx::OTexture3D Graphics::createTexture3D(const TextureCreateInfo &createInfo)
 {
-    PTexture3D result = new Texture3D(this, createInfo);
+    OTexture3D result = new Texture3D(this, createInfo);
     return result;
 }
 
-Gfx::PTextureCube Graphics::createTextureCube(const TextureCreateInfo &createInfo)
+Gfx::OTextureCube Graphics::createTextureCube(const TextureCreateInfo &createInfo)
 {
-    PTextureCube result = new TextureCube(this, createInfo);
+    OTextureCube result = new TextureCube(this, createInfo);
     return result;
 }
 
-Gfx::PUniformBuffer Graphics::createUniformBuffer(const UniformBufferCreateInfo &bulkData)
+Gfx::OUniformBuffer Graphics::createUniformBuffer(const UniformBufferCreateInfo &bulkData)
 {
-    PUniformBuffer uniformBuffer = new UniformBuffer(this, bulkData);
+    OUniformBuffer uniformBuffer = new UniformBuffer(this, bulkData);
     return uniformBuffer;
 }
 
-Gfx::PShaderBuffer Graphics::createShaderBuffer(const ShaderBufferCreateInfo &bulkData)
+Gfx::OShaderBuffer Graphics::createShaderBuffer(const ShaderBufferCreateInfo &bulkData)
 {
-    PShaderBuffer ShaderBuffer = new ShaderBuffer(this, bulkData);
+    OShaderBuffer ShaderBuffer = new ShaderBuffer(this, bulkData);
     return ShaderBuffer;
 }
-Gfx::PVertexBuffer Graphics::createVertexBuffer(const VertexBufferCreateInfo &bulkData)
+Gfx::OVertexBuffer Graphics::createVertexBuffer(const VertexBufferCreateInfo &bulkData)
 {
-    PVertexBuffer vertexBuffer = new VertexBuffer(this, bulkData);
+    OVertexBuffer vertexBuffer = new VertexBuffer(this, bulkData);
     return vertexBuffer;
 }
 
-Gfx::PIndexBuffer Graphics::createIndexBuffer(const IndexBufferCreateInfo &bulkData)
+Gfx::OIndexBuffer Graphics::createIndexBuffer(const IndexBufferCreateInfo &bulkData)
 {
-    PIndexBuffer indexBuffer = new IndexBuffer(this, bulkData);
+    OIndexBuffer indexBuffer = new IndexBuffer(this, bulkData);
     return indexBuffer;
 }
 Gfx::PRenderCommand Graphics::createRenderCommand(const std::string& name)
 {
-    PRenderCommand cmdBuffer = getGraphicsCommands()->createRenderCommand(activeRenderPass, activeFramebuffer, name);
+    ORenderCommand cmdBuffer = getGraphicsCommands()->createRenderCommand(activeRenderPass, activeFramebuffer, name);
     return cmdBuffer;
 }
 
 Gfx::PComputeCommand Graphics::createComputeCommand(const std::string& name) 
 {
-    PComputeCommand cmdBuffer = getComputeCommands()->createComputeCommand(name);
+    OComputeCommand cmdBuffer = getComputeCommands()->createComputeCommand(name);
     return cmdBuffer;
 }
 
-Gfx::PVertexDeclaration Graphics::createVertexDeclaration(const Array<Gfx::VertexElement>& element) 
+Gfx::OVertexDeclaration Graphics::createVertexDeclaration(const Array<Gfx::VertexElement>& element) 
 {
-    PVertexDeclaration declaration = new VertexDeclaration(element);
+    OVertexDeclaration declaration = new VertexDeclaration(element);
     return declaration;
 }
 
-Gfx::PVertexShader Graphics::createVertexShader(const ShaderCreateInfo& createInfo)
+Gfx::OVertexShader Graphics::createVertexShader(const ShaderCreateInfo& createInfo)
 {
-    PVertexShader shader = new VertexShader(this);
+    OVertexShader shader = new VertexShader(this);
     shader->create(createInfo);
     return shader;
 }

src/Engine/Graphics/Vulkan/Graphics.h

@@ -37,38 +37,40 @@ public:
 
     // Inherited via Graphics
     virtual void init(GraphicsInitializer initializer) override;
-    virtual Gfx::PWindow createWindow(const WindowCreateInfo &createInfo) override;
-    virtual Gfx::PViewport createViewport(Gfx::PWindow owner, const ViewportCreateInfo &createInfo) override;
+    virtual Gfx::OWindow createWindow(const WindowCreateInfo &createInfo) override;
+    virtual Gfx::OViewport createViewport(Gfx::PWindow owner, const ViewportCreateInfo &createInfo) override;
 
-    virtual Gfx::PRenderPass createRenderPass(Gfx::PRenderTargetLayout layout, Gfx::PViewport renderArea) override;
+    virtual Gfx::ORenderPass createRenderPass(Gfx::ORenderTargetLayout layout, Gfx::PViewport renderArea) override;
     virtual void beginRenderPass(Gfx::PRenderPass renderPass) override;
     virtual void endRenderPass() override;
 
     virtual void executeCommands(const Array<Gfx::PRenderCommand>& commands) override;
     virtual void executeCommands(const Array<Gfx::PComputeCommand>& commands) override;
 
-    virtual Gfx::PTexture2D createTexture2D(const TextureCreateInfo &createInfo) override;
-    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::PShaderBuffer createShaderBuffer(const ShaderBufferCreateInfo &bulkData) override;
-    virtual Gfx::PVertexBuffer createVertexBuffer(const VertexBufferCreateInfo &bulkData) override;
-    virtual Gfx::PIndexBuffer createIndexBuffer(const IndexBufferCreateInfo &bulkData) override;
+    virtual Gfx::OTexture2D createTexture2D(const TextureCreateInfo &createInfo) override;
+    virtual Gfx::OTexture3D createTexture3D(const TextureCreateInfo &createInfo) override;
+    virtual Gfx::OTextureCube createTextureCube(const TextureCreateInfo &createInfo) override;
+    virtual Gfx::OUniformBuffer createUniformBuffer(const UniformBufferCreateInfo &bulkData) override;
+    virtual Gfx::OShaderBuffer createShaderBuffer(const ShaderBufferCreateInfo &bulkData) override;
+    virtual Gfx::OVertexBuffer createVertexBuffer(const VertexBufferCreateInfo &bulkData) override;
+    virtual Gfx::OIndexBuffer createIndexBuffer(const IndexBufferCreateInfo &bulkData) override;
+    
     virtual Gfx::PRenderCommand createRenderCommand(const std::string& name) override;
     virtual Gfx::PComputeCommand createComputeCommand(const std::string& name) override;
-    virtual Gfx::PVertexDeclaration createVertexDeclaration(const Array<Gfx::VertexElement>& element) override;
-    virtual Gfx::PVertexShader createVertexShader(const ShaderCreateInfo& createInfo) override;
-    virtual Gfx::PFragmentShader createFragmentShader(const ShaderCreateInfo& createInfo) override;
-    virtual Gfx::PComputeShader createComputeShader(const ShaderCreateInfo& createInfo) override;
-    virtual Gfx::PTaskShader createTaskShader(const ShaderCreateInfo& createInfo) override;
-    virtual Gfx::PMeshShader createMeshShader(const ShaderCreateInfo& createInfo) override;
-    virtual Gfx::PGraphicsPipeline createGraphicsPipeline(const Gfx::LegacyPipelineCreateInfo& createInfo) override;
-    virtual Gfx::PGraphicsPipeline createGraphicsPipeline(const Gfx::MeshPipelineCreateInfo& createInfo) override;
-    virtual Gfx::PComputePipeline createComputePipeline(const Gfx::ComputePipelineCreateInfo& createInfo) override;
-    virtual Gfx::PSamplerState createSamplerState(const SamplerCreateInfo& createInfo) override;
     
-    virtual Gfx::PDescriptorLayout createDescriptorLayout(const std::string& name = "") override;
-    virtual Gfx::PPipelineLayout createPipelineLayout(Gfx::PPipelineLayout baseLayout = nullptr) override;
+    virtual Gfx::OVertexDeclaration createVertexDeclaration(const Array<Gfx::VertexElement>& element) override;
+    virtual Gfx::OVertexShader createVertexShader(const ShaderCreateInfo& createInfo) override;
+    virtual Gfx::OFragmentShader createFragmentShader(const ShaderCreateInfo& createInfo) override;
+    virtual Gfx::OComputeShader createComputeShader(const ShaderCreateInfo& createInfo) override;
+    virtual Gfx::OTaskShader createTaskShader(const ShaderCreateInfo& createInfo) override;
+    virtual Gfx::OMeshShader createMeshShader(const ShaderCreateInfo& createInfo) override;
+    virtual Gfx::OGraphicsPipeline createGraphicsPipeline(const Gfx::LegacyPipelineCreateInfo& createInfo) override;
+    virtual Gfx::OGraphicsPipeline createGraphicsPipeline(const Gfx::MeshPipelineCreateInfo& createInfo) override;
+    virtual Gfx::OComputePipeline createComputePipeline(const Gfx::ComputePipelineCreateInfo& createInfo) override;
+    virtual Gfx::OSamplerState createSamplerState(const SamplerCreateInfo& createInfo) override;
+
+    virtual Gfx::ODescriptorLayout createDescriptorLayout(const std::string& name = "") override;
+    virtual Gfx::OPipelineLayout createPipelineLayout(Gfx::PPipelineLayout baseLayout = nullptr) override;
 
     virtual void copyTexture(Gfx::PTexture srcTexture, Gfx::PTexture dstTexture) override;
 protected:
@@ -82,18 +84,18 @@ protected:
     VkDevice handle;
     VkPhysicalDevice physicalDevice;
 
-    PQueue graphicsQueue;
-    PQueue computeQueue;
-    PQueue transferQueue;
-    PQueue dedicatedTransferQueue;
-    PPipelineCache pipelineCache;
+    OQueue graphicsQueue;
+    OQueue computeQueue;
+    OQueue transferQueue;
+    OQueue dedicatedTransferQueue;
+    OPipelineCache pipelineCache;
     std::mutex renderPassLock;
     PRenderPass activeRenderPass;
     PFramebuffer activeFramebuffer;
-    thread_local static PCommandBufferManager graphicsCommands;
-    thread_local static PCommandBufferManager computeCommands;
-    thread_local static PCommandBufferManager transferCommands;
-    thread_local static PCommandBufferManager dedicatedTransferCommands;
+    thread_local static OCommandBufferManager graphicsCommands;
+    thread_local static OCommandBufferManager computeCommands;
+    thread_local static OCommandBufferManager transferCommands;
+    thread_local static OCommandBufferManager dedicatedTransferCommands;
     VkPhysicalDeviceProperties props;
     VkPhysicalDeviceFeatures features;
     VkDebugReportCallbackEXT callback;
@@ -101,8 +103,8 @@ protected:
     Array<PViewport> viewports;
     std::mutex allocatedFrameBufferLock;
     Map<uint32, PFramebuffer> allocatedFramebuffers;
-    PAllocator allocator;
-    PStagingManager stagingManager;
+    OAllocator allocator;
+    OStagingManager stagingManager;
 
     friend class Window;
 };

src/Engine/Graphics/Vulkan/RenderPass.cpp

@@ -7,8 +7,8 @@
 using namespace Seele;
 using namespace Seele::Vulkan;
 
-RenderPass::RenderPass(PGraphics graphics, Gfx::PRenderTargetLayout layout, Gfx::PViewport viewport)
-    : Gfx::RenderPass(layout)
+RenderPass::RenderPass(PGraphics graphics, Gfx::ORenderTargetLayout layout, Gfx::PViewport viewport)
+    : Gfx::RenderPass(std::move(layout))
     , graphics(graphics)
 {
     renderArea.extent.width = viewport->getSizeX();
@@ -21,7 +21,7 @@ RenderPass::RenderPass(PGraphics graphics, Gfx::PRenderTargetLayout layout, Gfx:
     Array<VkAttachmentReference> colorRefs;
     VkAttachmentReference depthRef;
     uint32 attachmentCounter = 0;
-    for (auto inputAttachment : layout->inputAttachments)
+    for (auto& inputAttachment : this->layout->inputAttachments)
     {
         PTexture2D image = inputAttachment->getTexture().cast<Texture2D>();
         VkAttachmentDescription& desc = attachments.add();
@@ -39,7 +39,7 @@ RenderPass::RenderPass(PGraphics graphics, Gfx::PRenderTargetLayout layout, Gfx:
         ref.attachment = attachmentCounter;
         attachmentCounter++;
     }
-    for (auto colorAttachment : layout->colorAttachments)
+    for (auto& colorAttachment : this->layout->colorAttachments)
     {
         VkAttachmentDescription& desc = attachments.add();
         desc.flags = 0;
@@ -127,12 +127,12 @@ uint32 RenderPass::getFramebufferHash()
 {
     FramebufferDescription description;
     std::memset(&description, 0, sizeof(FramebufferDescription));
-    for (auto inputAttachment : layout->inputAttachments)
+    for (auto& inputAttachment : layout->inputAttachments)
     {
         PTexture2D tex = inputAttachment->getTexture().cast<Texture2D>();
         description.inputAttachments[description.numInputAttachments++] = tex->getView();
     }
-    for (auto colorAttachment : layout->colorAttachments)
+    for (auto& colorAttachment : layout->colorAttachments)
     {
         PTexture2D tex = colorAttachment->getTexture().cast<Texture2D>();
         description.colorAttachments[description.numColorAttachments++] = tex->getView();

src/Engine/Graphics/Vulkan/RenderPass.h

@@ -9,7 +9,7 @@ namespace Vulkan
 class RenderPass : public Gfx::RenderPass
 {
 public:
-    RenderPass(PGraphics graphics, Gfx::PRenderTargetLayout layout, Gfx::PViewport viewport);
+    RenderPass(PGraphics graphics, Gfx::ORenderTargetLayout layout, Gfx::PViewport viewport);
     virtual ~RenderPass();
     uint32 getFramebufferHash();
     inline VkRenderPass getHandle() const

src/Engine/Graphics/Vulkan/RenderTarget.cpp

@@ -1,8 +1,9 @@
-#include "VulkanGraphicsResources.h"
-#include "VulkanGraphics.h"
-#include "VulkanInitializer.h"
-#include "VulkanGraphicsEnums.h"
-#include "VulkanCommandBuffer.h"
+#include "RenderTarget.h"
+#include "Resources.h"
+#include "Graphics.h"
+#include "Initializer.h"
+#include "Enums.h"
+#include "CommandBuffer.h"
 #include <GLFW/glfw3.h>
 
 using namespace Seele;
@@ -116,9 +117,9 @@ void Window::onWindowCloseEvent()
 {
 }
 
-Gfx::PTexture2D Window::getBackBuffer() const
+Gfx::PTexture2D Window::getBackBuffer()
 {
-    return backBufferImages[currentImageIndex];
+    return PTexture2D(backBufferImages[currentImageIndex]);
 }
 
 void Window::setKeyCallback(std::function<void(KeyCode, InputAction, KeyModifier)> callback)
@@ -289,7 +290,7 @@ void Window::createSwapchain()
     backBufferCreateInfo.width = getSizeX();
     backBufferCreateInfo.height = getSizeY();
     backBufferCreateInfo.usage = Gfx::SE_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
-    backBufferCreateInfo.resourceData.owner = Gfx::QueueType::GRAPHICS;
+    backBufferCreateInfo.sourceData.owner = Gfx::QueueType::GRAPHICS;
     backBufferCreateInfo.format = cast(surfaceFormat.format);
     for (uint32 i = 0; i < numSwapchainImages; ++i)
     {

src/Engine/Graphics/Vulkan/RenderTarget.h

@@ -16,7 +16,7 @@ public:
     virtual ~Window();
     virtual void beginFrame() override;
     virtual void endFrame() override;
-    virtual Gfx::PTexture2D getBackBuffer() const override;
+    virtual Gfx::PTexture2D getBackBuffer() override;
     virtual void onWindowCloseEvent() override;
     virtual void setKeyCallback(std::function<void(KeyCode, InputAction, KeyModifier)> callback) override;
     virtual void setMouseMoveCallback(std::function<void(double, double)> callback) override;
@@ -45,9 +45,9 @@ protected:
     void chooseSurfaceFormat(const Array<VkSurfaceFormatKHR> &available, Gfx::SeFormat preferred);
     void choosePresentMode(const Array<VkPresentModeKHR> &modes);
 
-    PTexture2D backBufferImages[Gfx::numFramesBuffered];
-    PSemaphore renderFinished[Gfx::numFramesBuffered];
-    PSemaphore imageAcquired[Gfx::numFramesBuffered];
+    OTexture2D backBufferImages[Gfx::numFramesBuffered];
+    OSemaphore renderFinished[Gfx::numFramesBuffered];
+    OSemaphore imageAcquired[Gfx::numFramesBuffered];
     PSemaphore imageAcquiredSemaphore;
 
     PGraphics graphics;

src/Engine/Graphics/Vulkan/Resources.cpp

@@ -1,8 +1,7 @@
-#include "VulkanGraphicsResources.h"
-#include "VulkanInitializer.h"
-#include "VulkanGraphics.h"
-#include "VulkanGraphicsEnums.h"
-#include "VulkanCommandBuffer.h"
+#include "Resources.h"
+#include "Enums.h"
+#include "Initializer.h"
+#include "Graphics.h"
 
 using namespace Seele;
 using namespace Seele::Vulkan;

src/Engine/Graphics/Vulkan/Shader.cpp

@@ -1,6 +1,5 @@
-#include "VulkanShader.h"
-#include "VulkanGraphics.h"
-#include "VulkanDescriptorSets.h"
+#include "Shader.h"
+#include "Graphics.h"
 #include "slang.h"
 #include "slang-com-ptr.h"
 #include "stdlib.h"
@@ -23,11 +22,6 @@ Shader::~Shader()
     }
 }
 
-Map<uint32, PDescriptorLayout> Shader::getDescriptorLayouts()
-{
-    return descriptorSets;
-}
-
 uint32 Seele::Vulkan::Shader::getShaderHash() const
 {
     return hash;

src/Engine/Graphics/Vulkan/Shader.h

@@ -26,11 +26,11 @@ public:
         //SLang renames all entry points to main, so we dont need that
         return "main";//entryPointName.c_str();
     }
-    Map<uint32, PDescriptorLayout> getDescriptorLayouts();
+    //Map<uint32, PDescriptorLayout> getDescriptorLayouts();
     uint32 getShaderHash() const;
 private:
     PGraphics graphics;
-    Map<uint32, PDescriptorLayout> descriptorSets;
+    //Map<uint32, PDescriptorLayout> descriptorSets;
     VkShaderModule module;
     ShaderType type;
     VkShaderStageFlags stage;
@@ -62,6 +62,5 @@ DEFINE_REF(FragmentShader)
 DEFINE_REF(ComputeShader)
 DEFINE_REF(TaskShader)
 DEFINE_REF(MeshShader)
-
 } // namespace Vulkan
 }

src/Engine/Graphics/Vulkan/Texture.cpp

@@ -110,13 +110,13 @@ TextureHandle::TextureHandle(PGraphics graphics, VkImageViewType viewType,
         vkBindImageMemory(graphics->getDevice(), image, allocation->getHandle(), allocation->getOffset());
     }
 
-    const BulkResourceData& resourceData = createInfo.resourceData;
-    if(resourceData.size > 0)
+    const DataSource& sourceData = createInfo.sourceData;
+    if(sourceData.size > 0)
     {
         changeLayout(Gfx::SE_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL);
-        PStagingBuffer staging = graphics->getStagingManager()->allocateStagingBuffer(resourceData.size, VK_BUFFER_USAGE_TRANSFER_SRC_BIT);
+        PStagingBuffer staging = graphics->getStagingManager()->allocateStagingBuffer(sourceData.size, VK_BUFFER_USAGE_TRANSFER_SRC_BIT);
         void* data = staging->getMappedPointer();
-        std::memcpy(data, resourceData.data, resourceData.size);
+        std::memcpy(data, sourceData.data, sourceData.size);
         staging->flushMappedMemory();
         
         PCommandBufferManager cmdBufferManager = graphics->getQueueCommands(currentOwner);
@@ -322,7 +322,7 @@ void TextureHandle::executePipelineBarrier(VkAccessFlags srcAccess, VkPipelineSt
 }
 
 Texture2D::Texture2D(PGraphics graphics, const TextureCreateInfo& createInfo, VkImage existingImage)
-    : Gfx::Texture2D(graphics->getFamilyMapping(), createInfo.resourceData.owner)
+    : Gfx::Texture2D(graphics->getFamilyMapping(), createInfo.sourceData.owner)
 {
     textureHandle = new TextureHandle(graphics, createInfo.bArray ? VK_IMAGE_VIEW_TYPE_2D_ARRAY : VK_IMAGE_VIEW_TYPE_2D, 
         createInfo, currentOwner, existingImage);
@@ -354,7 +354,7 @@ void Texture2D::executePipelineBarrier(VkAccessFlags srcAccess, VkPipelineStageF
 }
 
 Texture3D::Texture3D(PGraphics graphics, const TextureCreateInfo& createInfo, VkImage existingImage)
-    : Gfx::Texture3D(graphics->getFamilyMapping(), createInfo.resourceData.owner)
+    : Gfx::Texture3D(graphics->getFamilyMapping(), createInfo.sourceData.owner)
 {
     textureHandle = new TextureHandle(graphics, VK_IMAGE_VIEW_TYPE_3D, 
         createInfo, currentOwner, existingImage);
@@ -385,7 +385,7 @@ void Texture3D::executePipelineBarrier(VkAccessFlags srcAccess, VkPipelineStageF
 }
 
 TextureCube::TextureCube(PGraphics graphics, const TextureCreateInfo& createInfo, VkImage existingImage)
-    : Gfx::TextureCube(graphics->getFamilyMapping(), createInfo.resourceData.owner)
+    : Gfx::TextureCube(graphics->getFamilyMapping(), createInfo.sourceData.owner)
 {
     textureHandle = new TextureHandle(graphics, createInfo.bArray ? VK_IMAGE_VIEW_TYPE_CUBE_ARRAY : VK_IMAGE_VIEW_TYPE_CUBE, 
         createInfo, currentOwner, existingImage);

src/Engine/Graphics/Vulkan/Texture.h

@@ -61,7 +61,7 @@ private:
     //Updates via reference
     Gfx::QueueType& currentOwner;
     PGraphics graphics;
-    PSubAllocation allocation;
+    OSubAllocation allocation;
     uint32 sizeX;
     uint32 sizeY;
     uint32 sizeZ;

src/Engine/Material/Material.cpp

@@ -10,20 +10,20 @@ Material::Material()
 }
 
 Material::Material(Gfx::PGraphics graphics, 
-        Array<PShaderParameter> parameter, 
-        Gfx::PDescriptorLayout layout, 
+        Array<OShaderParameter> parameter, 
+        Gfx::ODescriptorLayout layout, 
         uint32 uniformDataSize, 
         uint32 uniformBinding, 
         std::string materialName, 
-        Array<PShaderExpression> expressions, 
+        Array<OShaderExpression> expressions, 
         MaterialNode brdf)
     : graphics(graphics)
-    , parameters(parameter)
+    , parameters(std::move(parameter))
     , uniformDataSize(uniformDataSize)
     , uniformBinding(uniformBinding)
-    , layout(layout)
+    , layout(std::move(layout))
     , materialName(materialName)
-    , codeExpressions(expressions)
+    , codeExpressions(std::move(expressions))
     , brdf(brdf)
     , instanceId(0)
 {
@@ -59,6 +59,7 @@ void Material::save(ArchiveBuffer& buffer) const
         Serialization::save(buffer, binding.descriptorType);
         Serialization::save(buffer, binding.shaderStages);
     }
+    Serialization::save(buffer, instances);
 }
 
 void Material::load(ArchiveBuffer& buffer)
@@ -97,6 +98,11 @@ void Material::load(ArchiveBuffer& buffer)
         layout->addDescriptorBinding(binding, descriptorType, descriptorCount, bindingFlags, shaderStages);
     }
     layout->create();
+    Serialization::load(buffer, instances);
+    for (auto& instance : instances)
+    {
+        instance->setBaseMaterial(this);
+    }
 }
 
 void Material::compile()

src/Engine/Material/Material.h

@@ -10,17 +10,18 @@ class Material
 public:
     Material();
     Material(Gfx::PGraphics graphics, 
-        Array<PShaderParameter> parameter, 
-        Gfx::PDescriptorLayout layout, 
+        Array<OShaderParameter> parameter, 
+        Gfx::ODescriptorLayout layout, 
         uint32 uniformDataSize, 
         uint32 uniformBinding, 
         std::string materialName, 
-        Array<PShaderExpression> expressions, 
+        Array<OShaderExpression> expressions, 
         MaterialNode brdf);
     ~Material();
-    Gfx::PDescriptorLayout getDescriptorLayout() const { return layout; }
+    const Gfx::PDescriptorLayout getDescriptorLayout() const { return layout; }
     PMaterialInstance instantiate();
-    const std::string& getName() { return materialName; }
+    PMaterialInstance getInstance(uint64 instance) { return instances[instance]; }
+    const std::string& getName() const { return materialName; }
 
     void save(ArchiveBuffer& buffer) const;
     void load(ArchiveBuffer& buffer);
@@ -33,10 +34,11 @@ private:
     uint32 uniformDataSize;
     uint32 uniformBinding;
     uint64 instanceId;
-    Gfx::PDescriptorLayout layout;
+    Gfx::ODescriptorLayout layout;
     std::string materialName;
-    Array<PShaderExpression> codeExpressions;
-    Array<PShaderParameter> parameters;
+    Array<OShaderExpression> codeExpressions;
+    Array<OShaderParameter> parameters;
+    Array<OMaterialInstance> instances;
     MaterialNode brdf;
 };
 DEFINE_REF(Material)

src/Engine/Material/MaterialInstance.cpp

@@ -4,11 +4,15 @@
 
 using namespace Seele;
 
-MaterialInstance::MaterialInstance(uint64 id, Gfx::PGraphics graphics, PMaterial baseMaterial, Gfx::PDescriptorLayout descriptor, Array<PShaderParameter> params, uint32 uniformBinding, uint32 uniformSize)
+MaterialInstance::MaterialInstance()
+{
+}
+
+MaterialInstance::MaterialInstance(uint64 id, Gfx::PGraphics graphics, PMaterial baseMaterial, Gfx::PDescriptorLayout layout, Array<OShaderParameter> params, uint32 uniformBinding, uint32 uniformSize)
     : id(id), graphics(graphics), baseMaterial(baseMaterial), layout(layout), parameters(params), uniformBinding(uniformBinding)
 {
     uniformBuffer = graphics->createUniformBuffer(UniformBufferCreateInfo{
-            .resourceData = {
+            .sourceData = {
                 .size = uniformSize,
             },
             .bDynamic = true,
@@ -25,7 +29,7 @@ MaterialInstance::~MaterialInstance()
 void MaterialInstance::updateDescriptor()
 {
     descriptor = layout->allocateDescriptorSet();
-    for (auto param : parameters)
+    for (auto& param : parameters)
     {
         param->updateDescriptorSet(descriptor, uniformData.data());
     }
@@ -43,20 +47,27 @@ void MaterialInstance::save(ArchiveBuffer& buffer) const
     Serialization::save(buffer, uniformBinding);
     Serialization::save(buffer, uniformBuffer);
     Serialization::save(buffer, parameters);
-    Serialization::save(buffer, layout);
-    Serialization::save(buffer, descriptor);
-    Serialization::save(buffer, baseMaterial);
     Serialization::save(buffer, id);
 }
 
 void MaterialInstance::load(ArchiveBuffer& buffer)
 {
+    graphics = buffer.getGraphics();
     Serialization::load(buffer, uniformData);
     Serialization::load(buffer, uniformBinding);
     Serialization::load(buffer, uniformBuffer);
     Serialization::load(buffer, parameters);
-    Serialization::load(buffer, layout);
-    Serialization::load(buffer, descriptor);
-    Serialization::load(buffer, baseMaterial);
     Serialization::load(buffer, id);
 }
+
+void MaterialInstance::setBaseMaterial(PMaterial material)
+{
+    layout = material->getDescriptorLayout();
+    baseMaterial = material;
+    descriptor = layout->allocateDescriptorSet();
+    for (auto& param : parameters)
+    {
+        param->updateDescriptorSet(descriptor, uniformData.data());
+    }
+    descriptor->writeChanges();
+}

src/Engine/Material/MaterialInstance.h

@@ -7,7 +7,8 @@ namespace Seele
 class MaterialInstance
 {
 public:
-    MaterialInstance(uint64 id, Gfx::PGraphics graphics, PMaterial baseMaterial, Gfx::PDescriptorLayout descriptor, Array<PShaderParameter> params, uint32 uniformBinding, uint32 uniformSize);
+    MaterialInstance();
+    MaterialInstance(uint64 id, Gfx::PGraphics graphics, PMaterial baseMaterial, Gfx::PDescriptorLayout descriptor, Array<OShaderParameter> params, uint32 uniformBinding, uint32 uniformSize);
     ~MaterialInstance();
     void updateDescriptor();
     Gfx::PDescriptorSet getDescriptorSet() const;
@@ -16,13 +17,14 @@ public:
 
     void save(ArchiveBuffer& buffer) const;
     void load(ArchiveBuffer& buffer);
+    void setBaseMaterial(PMaterial material);
 
 private:
     Gfx::PGraphics graphics;
     Array<uint8> uniformData;
     uint32 uniformBinding;
-    Gfx::PUniformBuffer uniformBuffer;
-    Array<PShaderParameter> parameters;
+    Gfx::OUniformBuffer uniformBuffer;
+    Array<OShaderParameter> parameters;
     Gfx::PDescriptorLayout layout;
     Gfx::PDescriptorSet descriptor;
     PMaterial baseMaterial;

src/Engine/Material/ShaderExpression.h

@@ -208,21 +208,21 @@ DEFINE_REF(SampleExpression)
 struct MaterialNode
 {
     std::string profile;
-    Map<std::string, PShaderExpression> variables;
+    Map<std::string, OShaderExpression> variables;
     MaterialNode() {}
     ~MaterialNode() {}
     void save(ArchiveBuffer& buffer) const;
     void load(ArchiveBuffer& buffer);
 };
 template<>
-static void Serialization::save(ArchiveBuffer& buffer, const PShaderExpression& parameter)
+static void Serialization::save(ArchiveBuffer& buffer, const OShaderExpression& parameter)
 {
     Serialization::save(buffer, parameter->getIdentifier());
     parameter->save(buffer);
 }
 
 template<>
-static void Serialization::load(ArchiveBuffer& buffer, PShaderExpression& parameter)
+static void Serialization::load(ArchiveBuffer& buffer, OShaderExpression& parameter)
 {
     uint64 identifier = 0;
     Serialization::load(buffer, identifier);
@@ -268,14 +268,14 @@ static void Serialization::load(ArchiveBuffer& buffer, PShaderExpression& parame
 }
 
 template<>
-static void Serialization::save(ArchiveBuffer& buffer, const PShaderParameter& parameter)
+static void Serialization::save(ArchiveBuffer& buffer, const OShaderParameter& parameter)
 {
     Serialization::save(buffer, parameter->getIdentifier());
     parameter->save(buffer);
 }
 
 template<>
-static void Serialization::load(ArchiveBuffer& buffer, PShaderParameter& parameter)
+static void Serialization::load(ArchiveBuffer& buffer, OShaderParameter& parameter)
 {
     uint64 identifier = 0;
     Serialization::load(buffer, identifier);

src/Engine/MinimalEngine.cpp

@@ -1,14 +0,0 @@
-#include "MinimalEngine.h"
-#include <mutex>
-
-std::map<void*, void*>& getRegisteredObjects() 
-{
-    static std::map<void*, void*> map;
-    return map;
-}
-
-std::mutex& getRegisteredObjectLock() 
-{
-    static std::mutex lock;
-    return lock;
-}

src/Engine/MinimalEngine.h

@@ -5,13 +5,13 @@
 #define DEFINE_REF(x)           \
     typedef ::Seele::RefPtr<x> P##x;     \
     typedef ::Seele::UniquePtr<x> UP##x; \
-    typedef ::Seele::WeakPtr<x> W##x;
+    typedef ::Seele::OwningPtr<x> O##x;
 
 #define DECLARE_REF(x)          \
     class x;                    \
     typedef ::Seele::RefPtr<x> P##x;     \
     typedef ::Seele::UniquePtr<x> UP##x; \
-    typedef ::Seele::WeakPtr<x> W##x;
+    typedef ::Seele::OwningPtr<x> O##x;
 
 
 #define DECLARE_NAME_REF(nmsp, x)   \
@@ -20,86 +20,63 @@
         class x;                    \
         typedef RefPtr<x> P##x;     \
         typedef UniquePtr<x> UP##x; \
-        typedef WeakPtr<x> W##x;    \
+        typedef OwningPtr<x> O##x;  \
     }
 
-std::map<void*, void*>& getRegisteredObjects();
-std::mutex& getRegisteredObjectLock();
 
 namespace Seele
 {
-template <typename T, typename Deleter>
-class RefPtr;
-template <typename T, typename Deleter>
-class RefObject
+template <typename T, typename Deleter = std::default_delete<T>>
+class OwningPtr
 {
 public:
-    RefObject(T *ptr, Deleter&& deleter)
-        : handle(ptr)
-        , deleter(std::move(deleter))
-        , refCount(1)
+    OwningPtr()
+        : pointer(nullptr)
     {
     }
-    RefObject(const RefObject &rhs) = delete;
-    RefObject(RefObject &&rhs)
-        : handle(std::move(rhs.handle)), refCount(std::move(rhs.refCount))
+    OwningPtr(T* ptr)
+        : pointer(ptr)
+    {}
+    template<typename F>
+    OwningPtr(OwningPtr<F>&& other)
     {
+        pointer = static_cast<T*>(other.pointer);
     }
-    ~RefObject()
+    OwningPtr(const OwningPtr& other) = delete;
+    OwningPtr(OwningPtr&& other)
     {
-        {
-            std::scoped_lock lock(getRegisteredObjectLock());
-            getRegisteredObjects().erase(handle);
+        pointer = other.pointer;
+        other.pointer = nullptr;
     }
-//    #pragma warning( disable: 4150)
-        deleter(handle);
-        handle = nullptr;
-//    #pragma warning( default: 4150)
-    }
-    RefObject &operator=(const RefObject &rhs) = delete;
-    RefObject &operator=(RefObject &&rhs)
+    OwningPtr& operator=(const OwningPtr& other) = delete;
+    OwningPtr& operator=(OwningPtr&& other)
     {
-        if (*this != rhs)
+        if (this != &other)
         {
-            handle = std::move(rhs.handle);
-            refCount = std::move(rhs.refCount);
-            rhs.handle = nullptr;
-            rhs.refCount = 0;
+            pointer = other.pointer;
         }
         return *this;
     }
-    bool operator==(const RefObject &rhs) const 
+    constexpr T* operator->()
     {
-        return handle == rhs.handle;
+        return pointer;
     }
-    auto operator<=>(const RefObject& rhs) const
+    constexpr const T* operator->() const
     {
-        return handle <=> rhs.handle;
+        return pointer;
     }
-    void addRef()
+    constexpr bool operator==(const OwningPtr& rhs) const noexcept
     {
-        refCount++;
+        return pointer == rhs.pointer;
     }
-    void removeRef()
+    constexpr auto operator<=>(const OwningPtr& rhs) const noexcept
     {
-        refCount--;
-        if (refCount == 0)
-        {
-            delete this;
-        }
-    }
-    T *getHandle() const
-    {
-        return handle;
+        return pointer <=> rhs.pointer;
     }
 private:
-    T *handle;
-    Deleter deleter;
-    std::atomic_uint64_t refCount;
-    friend class RefPtr<T, Deleter>;
+    T* pointer;
 };
-
-template <typename T, typename Deleter = std::default_delete<T>>
+template <typename T>
 class RefPtr
 {
 public:
@@ -111,97 +88,48 @@ public:
         : object(nullptr)
     {
     }
-    RefPtr(T *ptr, Deleter deleter = Deleter())
+    RefPtr(T *ptr)
+        : object(ptr)
     {
-        std::scoped_lock l(getRegisteredObjectLock());
-        auto registeredObj = getRegisteredObjects().find(ptr);
-        // get here for thread safetly
-        auto registeredEnd = getRegisteredObjects().end();
-        if (registeredObj == registeredEnd)
-        {
-            object = new RefObject<T, Deleter>(ptr, std::move(deleter));
-            getRegisteredObjects()[ptr] = object;
-        }
-        else
-        {		
-            object = (RefObject<T, Deleter> *)registeredObj->second;
-            object->addRef();
-        }
-    }
-    constexpr explicit RefPtr(RefObject<T, Deleter> *other) noexcept
-        : object(other)
-    {
-        if(object != nullptr)
-        {
-            object->addRef();
-        }
     }
     constexpr RefPtr(const RefPtr &other) noexcept
         : object(other.object)
     {
-        if (object != nullptr)
-        {
-            object->addRef();
-        }
     }
     constexpr RefPtr(RefPtr &&rhs) noexcept
         : object(std::move(rhs.object))
     {
         rhs.object = nullptr;
-        //Dont change references, they stay the same
     }
     template <typename F>
     constexpr RefPtr(const RefPtr<F> &other)
     {
-        if(other == nullptr)
-        {
-            return;
+        object = other.cast<T>();
     }
-        F *f = other.getObject()->getHandle();
-        assert(static_cast<T *>(f));
-        object = (RefObject<T, Deleter> *)other.getObject();
-        object->addRef();
-    }
-
-    template <typename F, typename DeleterF = std::default_delete<F>>
-    constexpr RefPtr<F, DeleterF> cast()
+    constexpr RefPtr(OwningPtr<T>& owning)
     {
-        T *t = object->getHandle();
+        object = owning.getHandle();
+    }
+    constexpr RefPtr(const OwningPtr<T>& owning)
+    {
+        object = owning.getHandle();
+    }
+    template <typename F>
+    constexpr const RefPtr<F> cast() const
+    {
+        T *t = object;
         F *f = dynamic_cast<F *>(t);
         if (f == nullptr)
         {
             return nullptr;
         }
-        RefObject<F, DeleterF> *newObject = (RefObject<F, DeleterF> *)object;
-        return RefPtr<F, DeleterF>(newObject);
+        return RefPtr<F>(f);
     }
-
-    template <typename F, typename DeleterF = std::default_delete<F>>
-    constexpr const RefPtr<F, DeleterF> cast() const
-    {
-        T *t = object->getHandle();
-        F *f = dynamic_cast<F *>(t);
-        if (f == nullptr)
-        {
-            return nullptr;
-        }
-        RefObject<F, DeleterF> *newObject = (RefObject<F, DeleterF> *)object;
-        return RefPtr<F, DeleterF>(newObject);
-    }
-
     constexpr RefPtr &operator=(const RefPtr &other)
     {
         if (this != &other)
         {
-            if (object != nullptr)
-            {
-                object->removeRef();
-            }
             object = other.object;
-            if (object != nullptr)
-            {
-                object->addRef();
-            }
         }
         return *this;
     }
@@ -209,10 +137,6 @@ public:
     {
         if (this != &rhs)
         {
-            if (object != nullptr)
-            {
-                object->removeRef();
-            }
             object = std::move(rhs.object);
             rhs.object = nullptr;
         }
@@ -220,10 +144,6 @@ public:
     }
     constexpr ~RefPtr()
     {
-        if (object != nullptr)
-        {
-            object->removeRef();
-        }
     }
     constexpr bool operator==(const RefPtr& rhs) const noexcept
     {
@@ -235,32 +155,22 @@ public:
     }
     constexpr T *operator->()
     {
-        assert(object != nullptr);
-        return object->handle;
+        return object;
     }
     constexpr const T *operator->() const
-    {
-        assert(object != nullptr);
-        return object->handle;
-    }
-    constexpr RefObject<T, Deleter> *getObject() const noexcept
     {
         return object;
     }
     constexpr T* getHandle()
     {
-        return object->getHandle();
+        return object;
     }
     constexpr const T* getHandle() const
     {
-        return object->getHandle();
-    }
-    constexpr RefPtr<T, Deleter> clone()
-    {
-        return RefPtr<T, Deleter>(new T(*getHandle()));
+        return object;
     }
 private:
-    RefObject<T, Deleter> *object;
+    T* object;
 };
 template <typename T>
 class UniquePtr
@@ -319,31 +229,4 @@ public:
 private:
     T *handle;
 };
-//A weak pointer has no ownership over an object and thus cant delete it
-template <typename T>
-class WeakPtr
-{
-public:
-    WeakPtr()
-        : pointer(nullptr)
-    {
-    }
-    WeakPtr(RefPtr<T> &sharedPtr)
-        : pointer(sharedPtr)
-    {
-    }
-    WeakPtr &operator=(WeakPtr<T> &weakPtr)
-    {
-        pointer = weakPtr.pointer;
-        return *this;
-    }
-    WeakPtr &operator=(RefPtr<T> &sharedPtr)
-    {
-        pointer = sharedPtr;
-        return *this;
-    }
-
-private:
-    RefPtr<T> pointer;
-};
 } // namespace Seele

src/Engine/Scene/LightEnvironment.cpp

@@ -12,14 +12,14 @@ LightEnvironment::LightEnvironment(Gfx::PGraphics graphics)
     layout->addDescriptorBinding(2, Gfx::SE_DESCRIPTOR_TYPE_STORAGE_BUFFER);
     layout->create();
     lightEnvBuffer = graphics->createUniformBuffer(UniformBufferCreateInfo{
-        .resourceData = {
+        .sourceData = {
             .size = sizeof(LightEnv),
             .data = (uint8*) &lightEnv,
         },
         .bDynamic = true,
     });
     directionalLights = graphics->createShaderBuffer(ShaderBufferCreateInfo{
-        .resourceData = {
+        .sourceData = {
             .size = sizeof(Component::DirectionalLight) * MAX_DIRECTIONAL_LIGHTS,
             .data = (uint8*)dirs.data(),
         },
@@ -27,7 +27,7 @@ LightEnvironment::LightEnvironment(Gfx::PGraphics graphics)
         .bDynamic = true,
     });
     pointLights = graphics->createShaderBuffer(ShaderBufferCreateInfo{
-        .resourceData = {
+        .sourceData = {
             .size = sizeof(Component::PointLight) * MAX_POINT_LIGHTS,
             .data = (uint8*)dirs.data(),
         },
@@ -62,15 +62,15 @@ void LightEnvironment::commit()
 {
     lightEnv.numDirectionalLights = dirs.size();
     lightEnv.numPointLights = points.size();
-    lightEnvBuffer->updateContents(BulkResourceData{
+    lightEnvBuffer->updateContents(DataSource{
         .size = sizeof(LightEnv),
         .data = (uint8*) & lightEnv,
         });
-    directionalLights->updateContents(BulkResourceData{
+    directionalLights->updateContents(DataSource{
         .size = sizeof(Component::DirectionalLight) * dirs.size(),
         .data = (uint8*)dirs.data(),
         });
-    pointLights->updateContents(BulkResourceData{
+    pointLights->updateContents(DataSource{
         .size = sizeof(Component::PointLight) * points.size(),
         .data = (uint8*)points.data(),
         });

src/Engine/Scene/LightEnvironment.h

@@ -23,13 +23,13 @@ private:
         uint32 numDirectionalLights;
         uint32 numPointLights;
     } lightEnv;
-    Gfx::PShaderBuffer directionalLights;
-    Gfx::PUniformBuffer lightEnvBuffer;
-    Gfx::PShaderBuffer pointLights;
+    Gfx::OShaderBuffer directionalLights;
+    Gfx::OUniformBuffer lightEnvBuffer;
+    Gfx::OShaderBuffer pointLights;
     Array<Component::DirectionalLight> dirs;
     Array<Component::PointLight> points;
-    Gfx::PDescriptorLayout layout;
-    Gfx::PDescriptorSet set;
+    Gfx::ODescriptorLayout layout;
+    Gfx::ODescriptorSet set;
     Gfx::PGraphics graphics;
 };
 DEFINE_REF(LightEnvironment)

src/Engine/Scene/Scene.h

@@ -48,7 +48,7 @@ public:
     Gfx::PGraphics getGraphics() const { return graphics; }
     entt::registry registry;
 private:
-    PLightEnvironment lightEnv;
+    OLightEnvironment lightEnv;
     PhysicsSystem physics;
     Gfx::PGraphics graphics;
 };

src/Engine/Serialization/Serialization.h

@@ -46,9 +46,9 @@ namespace Serialization
         type.load(buffer);
     }
     template<typename T>
-    static void save(ArchiveBuffer& buffer, const RefPtr<T>& ptr);
+    static void save(ArchiveBuffer& buffer, const OwningPtr<T>& ptr);
     template<typename T>
-    static void load(ArchiveBuffer& buffer, RefPtr<T>& ptr);
+    static void load(ArchiveBuffer& buffer, OwningPtr<T>& ptr);
     static void save(ArchiveBuffer& buffer, const std::string& type)
     {
         uint64 length = type.size();

src/Engine/System/MeshUpdater.cpp

@@ -8,6 +8,10 @@ MeshUpdater::MeshUpdater(PScene scene)
 {
 }
 
+MeshUpdater::~MeshUpdater()
+{
+}
+
 void MeshUpdater::update(Component::Transform& transform, Component::Mesh& mesh)
 {
     mesh.vertexData->updateMesh(transform, mesh);

src/Engine/Window/GameView.cpp

@@ -56,7 +56,6 @@ void GameView::commitUpdate()
 
 void GameView::prepareRender()
 {
-    renderGraph.updatePassData(depthPrepassData, lightCullingData, basePassData, skyboxData);
 }
 
 void GameView::render()

src/Engine/Window/View.h

@@ -28,7 +28,7 @@ public:
 
 protected:
 	Gfx::PGraphics graphics;
-	Gfx::PViewport viewport;
+	Gfx::OViewport viewport;
 	PWindow owner;
 	std::string name;
 	

src/Engine/Window/Window.cpp

@@ -16,10 +16,7 @@ Window::~Window()
 
 void Window::addView(PView view)
 {
-    //WindowView* windowView = new WindowView(view);
-    //windowView->worker = std::thread(&Window::viewWorker, this, windowView);
     views.add(view);
-    //viewWorker(views.size() - 1);
 }
 
 void Window::render() 
@@ -37,7 +34,6 @@ void Window::render()
         }
         gfxHandle->endFrame();
     }
-    //co_return;
 }
 
 Gfx::PWindow Window::getGfxHandle()
@@ -61,22 +57,3 @@ void Window::setFocused(PView view)
         owner->notifyWindowClosed(this);
     });
 }
-
-/*void Window::viewWorker(size_t viewIndex)
-{
-    WindowView* windowView = views[viewIndex];
-    co_await windowView->view->beginUpdate();
-    co_await windowView->view->update();
-    {
-        std::scoped_lock lock(windowView->workerMutex);
-        windowView->view->commitUpdate();
-    }
-    //std::cout << "Update completed" << std::endl;
-    //windowView->updateFinished.raise();
-    // enqueue next frame update
-    if(owner->isActive())
-    {
-        viewWorker(viewIndex);
-    }
-    //co_return;
-}*/

src/Engine/Window/Window.h

@@ -4,17 +4,6 @@
 
 namespace Seele
 {
-/*struct WindowView
-{
-    PView view;
-    Event updateFinished;
-    std::mutex workerMutex;
-    WindowView(PView view)
-        : view(view)
-        , updateFinished(view->getName())
-    {}
-};*/
-//DEFINE_REF(WindowView)
 DECLARE_REF(WindowManager)
 // The logical window, with the graphics proxy
 class Window

src/Engine/Window/WindowManager.cpp

@@ -13,15 +13,16 @@ WindowManager::~WindowManager()
 
 PWindow WindowManager::addWindow(Gfx::PGraphics graphics, const WindowCreateInfo &createInfo)
 {
-    Gfx::PWindow handle = graphics->createWindow(createInfo);
-    PWindow window = new Window(this, handle);
-    windows.add(window);
-    return window;
+    Gfx::OWindow handle = graphics->createWindow(createInfo);
+    OWindow window = new Window(this, handle);
+    PWindow ref = window;
+    windows.add(std::move(window));
+    return ref;
 }
 
 void WindowManager::notifyWindowClosed(PWindow window) 
 {
-    windows.remove(windows.find(window));
+    windows.remove(windows.find([window] (OWindow w) { return window == w; }));
     if(windows.empty())
     {
         exit(0);

src/Engine/Window/WindowManager.h

@@ -18,7 +18,7 @@ public:
 	}
 
 private:
-	Array<PWindow> windows;
+	Array<OWindow> windows;
 };
 DEFINE_REF(WindowManager)
 } // namespace Seele