Loading logic moved to Asset classes

src/Engine/Graphics/Graphics.h

@@ -2,6 +2,7 @@
 #include "MinimalEngine.h"
 #include "GraphicsResources.h"
 #include "Containers/Array.h"
+#include "RenderPass/VertexFactory.h"
 
 namespace Seele
 {

src/Engine/Graphics/GraphicsEnums.h

@@ -5,7 +5,7 @@ namespace Seele
 namespace Gfx
 {
 static constexpr bool useAsyncCompute = true;
-static constexpr bool waitIdleOnSubmit = false;
+static constexpr bool waitIdleOnSubmit = true;
 static constexpr uint32 numFramesBuffered = 3;
 
 typedef uint32_t SeFlags;

src/Engine/Graphics/GraphicsResources.cpp

@@ -126,8 +126,10 @@ IndexBuffer::IndexBuffer(PGraphics graphics, uint32 size, Gfx::SeIndexType index
 IndexBuffer::~IndexBuffer()
 {
 }
-VertexStream::VertexStream(uint32 stride, uint8 instanced)
-	: stride(stride), instanced(instanced)
+VertexStream::VertexStream()
+{}
+VertexStream::VertexStream(uint32 stride, uint32 offset, uint8 instanced, Gfx::PVertexBuffer vertexBuffer)
+	: stride(stride), instanced(instanced), offset(offset), vertexBuffer(vertexBuffer)
 {
 }
 VertexStream::~VertexStream()

src/Engine/Graphics/GraphicsResources.h

@@ -13,7 +13,7 @@
 
 namespace Seele
 {
-
+struct VertexInputStream;
 namespace Gfx
 {
 DECLARE_REF(Graphics);
@@ -297,8 +297,8 @@ DEFINE_REF(StructuredBuffer);
 class VertexStream
 {
 public:
-	VertexStream() {}
-	VertexStream(uint32 stride, uint8 instanced);
+	VertexStream();
+	VertexStream(uint32 stride, uint32 offset, uint8 instanced, Gfx::PVertexBuffer vertexBuffer);
 	~VertexStream();
 	void addVertexElement(VertexElement element);
 	const Array<VertexElement> getVertexDescriptions() const;
@@ -363,7 +363,7 @@ public:
 	virtual ~RenderCommand();
 	virtual void bindPipeline(Gfx::PGraphicsPipeline pipeline) = 0;
 	virtual void bindDescriptor(Gfx::PDescriptorSet set) = 0;
-	virtual void bindVertexBuffer(Gfx::PVertexBuffer vertexBuffer) = 0;
+	virtual void bindVertexBuffer(const Array<VertexInputStream>& streams) = 0;
 	virtual void bindIndexBuffer(Gfx::PIndexBuffer indexBuffer) = 0;
 	virtual void draw(const MeshBatchElement& data) = 0;
 };

src/Engine/Graphics/Mesh.cpp

@@ -2,8 +2,8 @@
 
 using namespace Seele;
 
-Mesh::Mesh(Gfx::PVertexBuffer vertexBuffer, Gfx::PIndexBuffer indexBuffer) 
-    : vertexBuffer(vertexBuffer)
+Mesh::Mesh(MeshDescription description, Gfx::PIndexBuffer indexBuffer) 
+    : description(description)
     , indexBuffer(indexBuffer)
 {    
 }

src/Engine/Graphics/Mesh.h

@@ -3,15 +3,54 @@
 
 namespace Seele
 {
+#define MAX_TEX_CHANNELS 4
+enum class VertexAttribute
+{
+    POSITION,
+    TEXCOORD,
+    NORMAL,
+    TANGENT,
+    BITANGENT
+};
+struct MeshDescription
+{
+    Array<VertexAttribute> layout;
+    Gfx::PVertexDeclaration declaration;
+    uint32 getStride() const
+    {
+        return getNumFloats() * sizeof(float);
+    }
+    uint32 getNumFloats() const
+    {
+        uint32 vertexSize = 0;
+        for(auto a : layout)
+        {
+            switch (a)
+            {
+            case VertexAttribute::POSITION:
+            case VertexAttribute::NORMAL:
+            case VertexAttribute::TANGENT:
+            case VertexAttribute::BITANGENT:
+                vertexSize += 3;
+                break;
+            case VertexAttribute::TEXCOORD:
+                vertexSize += 2;
+                break;
+            }
+        }
+        return vertexSize;
+    }
+};
+DECLARE_REF(MaterialAsset);
 class Mesh
 {
 public:
-    Mesh(Gfx::PVertexBuffer vertexBuffer, Gfx::PIndexBuffer indexBuffer);
+    Mesh(MeshDescription description, Gfx::PIndexBuffer indexBuffer);
     ~Mesh();
 
-private:
-    Gfx::PVertexBuffer vertexBuffer;
     Gfx::PIndexBuffer indexBuffer;
+    MeshDescription description;
+    PMaterialAsset referencedMaterial;
 };
 DEFINE_REF(Mesh);
 } // namespace Seele

src/Engine/Graphics/MeshBatch.h

@@ -50,11 +50,11 @@ struct MeshBatch
     uint8 isCastingShadow : 1;
     uint8 useWireframe : 1;
 
-    const Gfx::SePrimitiveTopology topology;
+    Gfx::SePrimitiveTopology topology;
 
-    const PVertexFactory vertexFactory;
+    PVertexFactory vertexFactory;
 
-    const PMaterial material;
+    PMaterial material;
 
     inline int32 getNumPrimitives() const
     {

src/Engine/Graphics/RenderCore.cpp

@@ -24,6 +24,7 @@ void Seele::RenderCore::init()
 	sceneViewInfo.offsetX = 0;
 	sceneViewInfo.offsetY = 0;
 	PSceneView sceneView = new SceneView(windowManager->getGraphics(), window, sceneViewInfo);
+	window->addView(sceneView);
 }
 
 void Seele::RenderCore::renderLoop()

src/Engine/Graphics/RenderPass/MeshProcessor.cpp

@@ -15,9 +15,11 @@ MeshProcessor::~MeshProcessor()
 {
 }
 
-void MeshProcessor::buildMeshDrawCommands(
+void MeshProcessor::buildMeshDrawCommand(
     const MeshBatch& meshBatch, 
-    const PPrimitiveComponent primitiveComponent, 
+    const PPrimitiveComponent primitiveComponent,
+    const Gfx::PRenderPass renderPass,
+    Gfx::PRenderCommand drawCommand,
     PMaterial material, 
     Gfx::PVertexShader vertexShader,
     Gfx::PControlShader controlShader,
@@ -37,6 +39,7 @@ void MeshProcessor::buildMeshDrawCommands(
     pipelineInitializer.evalShader = evaluationShader;
     pipelineInitializer.geometryShader = geometryShader;
     pipelineInitializer.fragmentShader = fragmentShader;
+    pipelineInitializer.renderPass = renderPass;
 
     VertexInputStreamArray vertexStreams;
     if(positionOnly)
@@ -47,8 +50,12 @@ void MeshProcessor::buildMeshDrawCommands(
     {
         vertexFactory->getStreams(vertexStreams);
     }
-    if(vertexShader != nullptr)
+    drawCommand->bindVertexBuffer(vertexStreams);
+    Gfx::PGraphicsPipeline pipeline = graphics->createGraphicsPipeline(pipelineInitializer);
+    drawCommand->bindPipeline(pipeline);
+    for(auto element : meshBatch.elements)
     {
-        
-    }    
+        drawCommand->bindIndexBuffer(element.indexBuffer);
+        drawCommand->draw(element);
+    }
 }

src/Engine/Graphics/RenderPass/MeshProcessor.h

@@ -18,9 +18,11 @@ private:
         const MeshBatch& meshBatch, 
         const PPrimitiveComponent primitiveComponent, 
         int32 staticMeshId = -1) = 0;
-    void buildMeshDrawCommands(
+    void buildMeshDrawCommand(
         const MeshBatch& meshBatch, 
-        const PPrimitiveComponent primitiveComponent, 
+        const PPrimitiveComponent primitiveComponent,
+        const Gfx::PRenderPass renderPass,
+        Gfx::PRenderCommand drawCommand,
         PMaterial material, 
         Gfx::PVertexShader vertexShader,
         Gfx::PControlShader controlShader,

src/Engine/Graphics/RenderPass/VertexFactory.cpp

@@ -1,7 +1,44 @@
 #include "VertexFactory.h"
+#include "Graphics/Mesh.h"
+#include <memory>
 
 using namespace Seele;
 
+List<PVertexFactory> VertexFactory::registeredVertexFactories;
+std::mutex VertexFactory::registeredVertexFactoryLock;
+
+VertexFactory::VertexFactory() 
+{
+    std::scoped_lock lock(registeredVertexFactoryLock);
+    registeredVertexFactories.add(this);
+}
+
+VertexFactory::VertexFactory(MeshDescription description)
+    : declaration(description.declaration)
+{
+    auto declStreams = declaration->getVertexStreams();
+    std::copy(declStreams.begin(), declStreams.end(), streams.begin());
+
+    uint32 positionStreamIndex = 0;
+    positionDeclaration = new Gfx::VertexDeclaration();
+    for (uint32 i = 0; i < declStreams.size(); i++)
+    {
+        if(description.layout[i] == VertexAttribute::POSITION)
+        {
+            positionStream[positionStreamIndex++] = declStreams[i];
+            positionDeclaration->addVertexStream(declStreams[i]);
+        }
+    }
+    
+    std::scoped_lock lock(registeredVertexFactoryLock);
+    registeredVertexFactories.add(this);
+}
+
+VertexFactory::~VertexFactory()
+{
+    registeredVertexFactories.remove(registeredVertexFactories.find(this));
+}
+
 void VertexFactory::getStreams(VertexInputStreamArray& outVertexStreams) const
 {
     for(uint32 i = 0; i < streams.size(); ++i)

src/Engine/Graphics/RenderPass/VertexFactory.h

@@ -35,7 +35,7 @@ struct VertexInputStream
     }
 };
 
-struct VertexStreamComponent
+/*struct VertexStreamComponent
 {
     const Gfx::PVertexBuffer vertexBuffer = nullptr;
 
@@ -68,21 +68,25 @@ struct VertexStreamComponent
         , type(type)
     {
     }
-};
+};*/
 
 typedef Array<VertexInputStream> VertexInputStreamArray;
+struct MeshDescription;
+DECLARE_REF(VertexFactory);
 class VertexFactory
 {
 public:
-    VertexFactory()
-    {
-    }
+    VertexFactory();
+    VertexFactory(MeshDescription description);
+    ~VertexFactory();
     void getStreams(VertexInputStreamArray& outVertexStreams) const;
     void getPositionOnlyStream(VertexInputStreamArray& outVertexStreams) const;
     virtual bool supportsTesselation() { return false; }
     Gfx::PVertexDeclaration getDeclaration() const {return declaration;}
     Gfx::PVertexDeclaration getPositionDeclaration() const {return positionDeclaration;}
 private:
+    static List<PVertexFactory> registeredVertexFactories;
+    static std::mutex registeredVertexFactoryLock;
     StaticArray<Gfx::VertexStream, 16> streams;
     StaticArray<Gfx::VertexStream, 16> positionStream;
     Gfx::PVertexDeclaration declaration;

src/Engine/Graphics/SceneRenderPath.cpp

@@ -1,12 +1,17 @@
 #include "SceneRenderPath.h"
 #include "Scene/Scene.h"
 #include "Material/Material.h"
+#include "Asset/AssetRegistry.h"
 
 using namespace Seele;
 
 SceneRenderPath::SceneRenderPath(Gfx::PGraphics graphics, Gfx::PViewport target)
 	: RenderPath(graphics, target)
 {
+	scene = new Scene();
+	PMeshAsset asset = AssetRegistry::findMesh("Unbenannt");
+	PActor rootActor = new Actor();
+	PPrimitiveComponent primitiveComponent = new PrimitiveComponent();
 }
 
 SceneRenderPath::~SceneRenderPath()

src/Engine/Graphics/SceneView.cpp

@@ -1,5 +1,6 @@
 #include "SceneView.h"
 #include "SceneRenderPath.h"
+#include "Scene/Scene.h"
 #include "Window.h"
 
 Seele::SceneView::SceneView(Gfx::PGraphics graphics, PWindow owner, const ViewportCreateInfo &createInfo)

src/Engine/Graphics/Vulkan/VulkanBuffer.cpp

@@ -129,7 +129,7 @@ void Buffer::executeOwnershipBarrier(Gfx::QueueType newOwner)
 		dynamicBarriers[i] = barrier;
 		dynamicBarriers[i].buffer = buffers[i].buffer;
 		dynamicBarriers[i].offset = 0;
-		dynamicBarriers[i].size = buffers[i].allocation->getSize();
+		dynamicBarriers[i].size = size;
 	}
 	vkCmdPipelineBarrier(srcCommand, srcStage, dstStage, 0, 0, nullptr, numBuffers, dynamicBarriers, 0, nullptr);
 	vkCmdPipelineBarrier(dstCommand, srcStage, dstStage, 0, 0, nullptr, numBuffers, dynamicBarriers, 0, nullptr);

src/Engine/Graphics/Vulkan/VulkanCommandBuffer.cpp

@@ -163,12 +163,17 @@ void SecondaryCmdBuffer::bindDescriptor(Gfx::PDescriptorSet descriptorSet)
     VkDescriptorSet setHandle = descriptorSet.cast<DescriptorSet>()->getHandle();
     vkCmdBindDescriptorSets(handle, VK_PIPELINE_BIND_POINT_GRAPHICS, pipeline->getLayout(), descriptorSet->getSetIndex(), 1, &setHandle, 0, nullptr);
 }
-void SecondaryCmdBuffer::bindVertexBuffer(Gfx::PVertexBuffer vertexBuffer)
+void SecondaryCmdBuffer::bindVertexBuffer(const Array<VertexInputStream>& streams)
 {
-    PVertexBuffer buf = vertexBuffer.cast<VertexBuffer>();
-    const VkBuffer bufHandle[1] = {buf->getHandle()};
-    const VkDeviceSize offsets[1] = {0};
-    vkCmdBindVertexBuffers(handle, 0, 1, bufHandle, offsets);
+    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>();
+        buffers[i] = buf->getHandle();
+        offsets[i] = streams[i].offset;
+    };
+    vkCmdBindVertexBuffers(handle, 0, streams.size(), buffers.data(), offsets.data());
 }
 void SecondaryCmdBuffer::bindIndexBuffer(Gfx::PIndexBuffer indexBuffer)
 {
@@ -181,7 +186,7 @@ void SecondaryCmdBuffer::draw(const MeshBatchElement& data)
 }
 
 CommandBufferManager::CommandBufferManager(PGraphics graphics, PQueue queue)
-    : graphics(graphics), queue(queue)
+    : graphics(graphics), queue(queue), queueFamilyIndex(queue->getFamilyIndex())
 {
     VkCommandPoolCreateInfo info =
         init::CommandPoolCreateInfo();

src/Engine/Graphics/Vulkan/VulkanCommandBuffer.h

@@ -4,6 +4,7 @@
 
 namespace Seele
 {
+struct VertexInputStream;
 namespace Vulkan
 {
 DECLARE_REF(RenderPass);
@@ -75,7 +76,7 @@ public:
 	void end();
 	virtual void bindPipeline(Gfx::PGraphicsPipeline pipeline) override;
 	virtual void bindDescriptor(Gfx::PDescriptorSet descriptorSet) override;
-	virtual void bindVertexBuffer(Gfx::PVertexBuffer vertexBuffer) override;
+	virtual void bindVertexBuffer(const Array<VertexInputStream>& streams) override;
 	virtual void bindIndexBuffer(Gfx::PIndexBuffer indexBuffer) override;
 	virtual void draw(const MeshBatchElement& data) override;
 

src/Engine/Graphics/Vulkan/VulkanGraphics.cpp

@@ -21,12 +21,6 @@ Graphics::Graphics()
 
 Graphics::~Graphics()
 {
-	allocator = nullptr;
-	stagingManager = nullptr;
-	graphicsCommands = nullptr;
-	computeCommands = nullptr;
-	transferCommands = nullptr;
-	dedicatedTransferCommands = nullptr;
 	viewports.clear();
 	vkDestroyDevice(handle, nullptr);
 	DestroyDebugReportCallbackEXT(instance, nullptr, callback);
@@ -41,10 +35,6 @@ void Graphics::init(GraphicsInitializer initInfo)
 	createDevice(initInfo);
 	allocator = new Allocator(this);
 	stagingManager = new StagingManager(this, allocator);
-	graphicsCommands = new CommandBufferManager(this, graphicsQueue);
-	computeCommands = new CommandBufferManager(this, computeQueue);
-	transferCommands = new CommandBufferManager(this, transferQueue);
-	dedicatedTransferCommands = new CommandBufferManager(this, dedicatedTransferQueue);
 	pipelineCache = new PipelineCache(this, "pipeline.cache");
 }
 
@@ -79,12 +69,12 @@ void Graphics::beginRenderPass(Gfx::PRenderPass renderPass)
 	{
 		framebuffer = found->value;
 	}
-	graphicsCommands->getCommands()->beginRenderPass(rp, framebuffer);
+	getGraphicsCommands()->getCommands()->beginRenderPass(rp, framebuffer);
 }
 
 void Graphics::endRenderPass()
 {
-	graphicsCommands->getCommands()->endRenderPass();
+	getGraphicsCommands()->getCommands()->endRenderPass();
 }
 
 void Graphics::executeCommands(Array<Gfx::PRenderCommand> commands)
@@ -96,7 +86,7 @@ void Graphics::executeCommands(Array<Gfx::PRenderCommand> commands)
 		buf->end();
 		cmdBuffers[i] = buf->getHandle();
 	}
-	vkCmdExecuteCommands(graphicsCommands->getCommands()->getHandle(), cmdBuffers.size(), cmdBuffers.data());
+	vkCmdExecuteCommands(getGraphicsCommands()->getCommands()->getHandle(), cmdBuffers.size(), cmdBuffers.data());
 }
 
 Gfx::PTexture2D Graphics::createTexture2D(const TextureCreateInfo &createInfo)
@@ -129,7 +119,7 @@ Gfx::PIndexBuffer Graphics::createIndexBuffer(const IndexBufferCreateInfo &bulkD
 }
 Gfx::PRenderCommand Graphics::createRenderCommand()
 {
-	PSecondaryCmdBuffer cmdBuffer = graphicsCommands->createSecondaryCmdBuffer();
+	PSecondaryCmdBuffer cmdBuffer = getGraphicsCommands()->createSecondaryCmdBuffer();
 	cmdBuffer->begin(getGraphicsCommands()->getCommands());
 	return cmdBuffer;
 }
@@ -199,33 +189,60 @@ PCommandBufferManager Graphics::getQueueCommands(Gfx::QueueType queueType)
 	switch (queueType)
 	{
 	case Gfx::QueueType::GRAPHICS:
-		return graphicsCommands;
+		return getGraphicsCommands();
 	case Gfx::QueueType::COMPUTE:
-		return computeCommands;
+		return getComputeCommands();
 	case Gfx::QueueType::TRANSFER:
-		return transferCommands;
+		return getTransferCommands();
 	case Gfx::QueueType::DEDICATED_TRANSFER:
-		return dedicatedTransferCommands;
+		return getDedicatedTransferCommands();
 	default:
 		throw new std::logic_error("invalid queue type");
 	}
 }
-
+std::mutex graphicsCommandLock;
 PCommandBufferManager Graphics::getGraphicsCommands()
 {
-	return graphicsCommands;
+	std::scoped_lock lock(graphicsCommandLock);
+	auto id = std::this_thread::get_id();
+	if(graphicsCommands.find(id) == graphicsCommands.end())
+	{
+		graphicsCommands[id] = new CommandBufferManager(this, graphicsQueue);
+	}
+	return graphicsCommands[id];
 }
+std::mutex computeCommandLock;
 PCommandBufferManager Graphics::getComputeCommands()
 {
-	return computeCommands;
+	std::scoped_lock lock(computeCommandLock);
+	auto id = std::this_thread::get_id();
+	if(computeCommands.find(id) == computeCommands.end())
+	{
+		computeCommands[id] = new CommandBufferManager(this, computeQueue);
+	}
+	return computeCommands[id];
 }
+std::mutex transferCommandLock;
 PCommandBufferManager Graphics::getTransferCommands()
 {
-	return transferCommands;
+	std::scoped_lock lock(transferCommandLock);
+	auto id = std::this_thread::get_id();
+	if(transferCommands.find(id) == transferCommands.end())
+	{
+		transferCommands[id] = new CommandBufferManager(this, transferQueue);
+	}
+	return transferCommands[id];
 }
+std::mutex dedicatedCommandLock;
 PCommandBufferManager Graphics::getDedicatedTransferCommands()
 {
-	return dedicatedTransferCommands;
+	std::scoped_lock lock(dedicatedCommandLock);
+	auto id = std::this_thread::get_id();
+	if(dedicatedTransferCommands.find(id) == dedicatedTransferCommands.end())
+	{
+		dedicatedTransferCommands[id] = new CommandBufferManager(this, dedicatedTransferQueue);
+	}
+	return dedicatedTransferCommands[id];
 }
 PAllocator Graphics::getAllocator()
 {

src/Engine/Graphics/Vulkan/VulkanGraphics.h

@@ -80,10 +80,10 @@ protected:
 	PQueue dedicatedTransferQueue;
 	QueueOwnedResourceDeletion deletionQueue;
 	PPipelineCache pipelineCache;
-	PCommandBufferManager graphicsCommands;
-	PCommandBufferManager computeCommands;
-	PCommandBufferManager transferCommands;
-	PCommandBufferManager dedicatedTransferCommands;
+	Map<std::thread::id, PCommandBufferManager> graphicsCommands;
+	Map<std::thread::id, PCommandBufferManager> computeCommands;
+	Map<std::thread::id, PCommandBufferManager> transferCommands;
+	Map<std::thread::id, PCommandBufferManager> dedicatedTransferCommands;
 	VkPhysicalDeviceProperties props;
 	VkPhysicalDeviceFeatures features;
 	VkDebugReportCallbackEXT callback;

src/Engine/Graphics/Vulkan/VulkanTexture.cpp

@@ -78,6 +78,7 @@ TextureHandle::TextureHandle(PGraphics graphics, VkImageViewType viewType,
         default:
             break;
         }
+
         info.initialLayout = layout;
         info.mipLevels = mipLevels;
         info.arrayLayers = arrayCount * layerCount;