From acc976fe8476be882be7857d326839991e4fefe8 Mon Sep 17 00:00:00 2001
From: Dynamitos <dynamitos15@gmail.com>
Date: Sat, 20 Apr 2024 21:35:43 +0200
Subject: [PATCH] this sucks, but there is hope

---
 res/shaders/Amp.dxil                          | Bin 0 -> 11932 bytes
 res/shaders/MeshletBasePass.slang             |   8 +-
 res/shaders/lib/Scene.slang                   |   1 -
 res/shaders/test.json                         |  77 ++++++++++++
 res/shaders/test.metallib                     | Bin 0 -> 13832 bytes
 src/Engine/Graphics/Descriptor.cpp            |   4 +-
 src/Engine/Graphics/Descriptor.h              |   8 +-
 src/Engine/Graphics/Graphics.h                |   4 +-
 src/Engine/Graphics/Initializer.h             |   8 +-
 src/Engine/Graphics/Metal/Buffer.h            |   4 +-
 src/Engine/Graphics/Metal/Buffer.mm           |  21 ++--
 src/Engine/Graphics/Metal/Command.mm          | 119 ++++++++++++------
 src/Engine/Graphics/Metal/Descriptor.h        |  10 +-
 src/Engine/Graphics/Metal/Descriptor.mm       | 118 +++++------------
 src/Engine/Graphics/Metal/Graphics.h          |   2 +-
 src/Engine/Graphics/Metal/Graphics.mm         |   4 +-
 src/Engine/Graphics/Metal/Pipeline.h          |   2 +-
 src/Engine/Graphics/Metal/Shader.mm           |  14 +--
 src/Engine/Graphics/Metal/Texture.mm          |   6 +-
 src/Engine/Graphics/RenderPass/BasePass.cpp   |   2 +-
 src/Engine/Graphics/RenderPass/DebugPass.cpp  |   2 +-
 .../Graphics/RenderPass/DepthPrepass.cpp      |   2 +-
 .../Graphics/RenderPass/LightCullingPass.cpp  |   7 +-
 src/Engine/Graphics/RenderPass/RenderPass.cpp |   1 +
 .../Graphics/RenderPass/SkyboxRenderPass.cpp  |   2 +-
 src/Engine/Graphics/Shader.cpp                |   4 +-
 src/Engine/Graphics/StaticMeshVertexData.cpp  |   6 +
 src/Engine/Graphics/VertexData.cpp            |  14 ++-
 src/Engine/Graphics/Vulkan/Graphics.h         |   4 +-
 src/Engine/Graphics/slang-compile.cpp         |  17 +--
 30 files changed, 279 insertions(+), 192 deletions(-)
 create mode 100755 res/shaders/Amp.dxil
 create mode 100644 res/shaders/test.json
 create mode 100644 res/shaders/test.metallib

diff --git a/res/shaders/Amp.dxil b/res/shaders/Amp.dxil
new file mode 100755
index 0000000000000000000000000000000000000000..229a32ce8f0000db3ba87e44b1e88870d4b7d303
GIT binary patch
literal 11932
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
b!iCkVAOA(cuj5V?wpia+7HOj>5_|by0uT8S

literal 0
HcmV?d00001

diff --git a/res/shaders/MeshletBasePass.slang b/res/shaders/MeshletBasePass.slang
index d29ea41..cc57793 100644
--- a/res/shaders/MeshletBasePass.slang
+++ b/res/shaders/MeshletBasePass.slang
@@ -52,7 +52,7 @@ void taskMain(
 				uint index;
 				InterlockedAdd(head, 1, index);
 				p.meshletId[index] = m;
-				p.instanceId[index] = groupID;
+				p.instanceId[index] = groupID + pScene.primitiveIndices[m];
 			}
 		}
 	}
@@ -90,9 +90,9 @@ void meshMain(
 	{
 		uint p = min(i, m.primitiveCount - 1);
 		{
-			uint local_idx0 = unpackPrimitiveIndices(m.primitiveOffset + (p * 3) + 0);
-			uint local_idx1 = unpackPrimitiveIndices(m.primitiveOffset + (p * 3) + 1);
-			uint local_idx2 = unpackPrimitiveIndices(m.primitiveOffset + (p * 3) + 2);
+			uint local_idx0 = pScene.primitiveIndices[m.primitiveOffset + (p * 3) + 0];
+			uint local_idx1 = pScene.primitiveIndices[m.primitiveOffset + (p * 3) + 1];
+			uint local_idx2 = pScene.primitiveIndices[m.primitiveOffset + (p * 3) + 2];
 			indices[p] = uint3(local_idx0, local_idx1, local_idx2);
 		}
 	}
diff --git a/res/shaders/lib/Scene.slang b/res/shaders/lib/Scene.slang
index 6b24fe5..a1157ae 100644
--- a/res/shaders/lib/Scene.slang
+++ b/res/shaders/lib/Scene.slang
@@ -42,6 +42,5 @@ struct Scene
 	StructuredBuffer<uint32_t> primitiveIndices;
 	StructuredBuffer<uint32_t> vertexIndices;
 };
-layout(set=2)
 ParameterBlock<Scene> pScene;
 
diff --git a/res/shaders/test.json b/res/shaders/test.json
new file mode 100644
index 0000000..a99e4b7
--- /dev/null
+++ b/res/shaders/test.json
@@ -0,0 +1,77 @@
+{
+  "EntryPoint": "taskMain",
+  "FunctionConstants": [],
+  "NeedsFunctionConstants": false,
+  "Resources": [
+    {
+      "abIndex": 0,
+      "slot": 0,
+      "type": "SRV"
+    },
+    {
+      "abIndex": 1,
+      "slot": 1,
+      "type": "SRV"
+    },
+    {
+      "abIndex": 2,
+      "slot": 2,
+      "type": "SRV"
+    },
+    {
+      "abIndex": 3,
+      "slot": 3,
+      "type": "SRV"
+    },
+    {
+      "abIndex": 4,
+      "slot": 0,
+      "type": "CBV"
+    }
+  ],
+  "ShaderID": "2266638404583382645",
+  "ShaderType": "Amplification",
+  "TopLevelArgumentBuffer": [
+    {
+      "EltOffset": 0,
+      "Size": 24,
+      "Slot": 0,
+      "Space": 2,
+      "Type": "SRV"
+    },
+    {
+      "EltOffset": 24,
+      "Size": 24,
+      "Slot": 1,
+      "Space": 2,
+      "Type": "SRV"
+    },
+    {
+      "EltOffset": 48,
+      "Size": 24,
+      "Slot": 2,
+      "Space": 2,
+      "Type": "SRV"
+    },
+    {
+      "EltOffset": 72,
+      "Size": 24,
+      "Slot": 3,
+      "Space": 2,
+      "Type": "SRV"
+    },
+    {
+      "EltOffset": 96,
+      "Size": 24,
+      "Slot": 0,
+      "Space": 1,
+      "Type": "CBV"
+    }
+  ],
+  "max_payload_size_in_bytes": 4096,
+  "num_threads": [
+    128,
+    1,
+    1
+  ]
+}
\ No newline at end of file
diff --git a/res/shaders/test.metallib b/res/shaders/test.metallib
new file mode 100644
index 0000000000000000000000000000000000000000..71da910be9380e0440153c43d928241ac8840440
GIT binary patch
literal 13832
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

literal 0
HcmV?d00001

diff --git a/src/Engine/Graphics/Descriptor.cpp b/src/Engine/Graphics/Descriptor.cpp
index d71fcff..1d32d32 100644
--- a/src/Engine/Graphics/Descriptor.cpp
+++ b/src/Engine/Graphics/Descriptor.cpp
@@ -43,9 +43,9 @@ DescriptorSet::DescriptorSet(PDescriptorLayout layout) : layout(layout) {}
 
 DescriptorSet::~DescriptorSet() {}
 
-PipelineLayout::PipelineLayout() {}
+PipelineLayout::PipelineLayout(const std::string& name) : name(name) {}
 
-PipelineLayout::PipelineLayout(PPipelineLayout baseLayout) {
+PipelineLayout::PipelineLayout(const std::string& name, PPipelineLayout baseLayout) : name(name){
   if (baseLayout != nullptr) {
     descriptorSetLayouts = baseLayout->descriptorSetLayouts;
     pushConstants = baseLayout->pushConstants;
diff --git a/src/Engine/Graphics/Descriptor.h b/src/Engine/Graphics/Descriptor.h
index bbd2d8a..61a356c 100644
--- a/src/Engine/Graphics/Descriptor.h
+++ b/src/Engine/Graphics/Descriptor.h
@@ -75,8 +75,8 @@ DEFINE_REF(DescriptorSet)
 
 class PipelineLayout {
 public:
-  PipelineLayout();
-  PipelineLayout(PPipelineLayout baseLayout);
+  PipelineLayout(const std::string& name);
+  PipelineLayout(const std::string& name, PPipelineLayout baseLayout);
   virtual ~PipelineLayout();
   virtual void create() = 0;
   void addDescriptorLayout(PDescriptorLayout layout);
@@ -85,12 +85,14 @@ public:
   constexpr const Map<std::string, PDescriptorLayout>& getLayouts() const { return descriptorSetLayouts; }
   constexpr uint32 findParameter(const std::string& name) const { return parameterMapping[name]; }
     void addMapping(Map<std::string, uint32> mapping);
-    
+    constexpr std::string getName() const {return name;};
+
 protected:
   uint32 layoutHash = 0;
   Map<std::string, PDescriptorLayout> descriptorSetLayouts;
     Map<std::string, uint32> parameterMapping;
   Array<SePushConstantRange> pushConstants;
+    std::string name;
 };
 DEFINE_REF(PipelineLayout)
 } // namespace Gfx
diff --git a/src/Engine/Graphics/Graphics.h b/src/Engine/Graphics/Graphics.h
index ab45350..1e96041 100644
--- a/src/Engine/Graphics/Graphics.h
+++ b/src/Engine/Graphics/Graphics.h
@@ -81,7 +81,7 @@ public:
     virtual OSampler createSampler(const SamplerCreateInfo& createInfo) = 0;
 
   	virtual ODescriptorLayout createDescriptorLayout(const std::string& name = "") = 0;
-  	virtual OPipelineLayout createPipelineLayout(PPipelineLayout baseLayout = nullptr) = 0;
+  	virtual OPipelineLayout createPipelineLayout(const std::string& name = "", PPipelineLayout baseLayout = nullptr) = 0;
 
     virtual OVertexInput createVertexInput(VertexInputStateCreateInfo createInfo) = 0;
 
@@ -96,4 +96,4 @@ protected:
 };
 DEFINE_REF(Graphics)
 } // namespace Gfx
-} // namespace Seele
\ No newline at end of file
+} // namespace Seele
diff --git a/src/Engine/Graphics/Initializer.h b/src/Engine/Graphics/Initializer.h
index fc7000c..fbf8601 100644
--- a/src/Engine/Graphics/Initializer.h
+++ b/src/Engine/Graphics/Initializer.h
@@ -94,26 +94,26 @@ struct VertexBufferCreateInfo
     // bytes per vertex
     uint32      vertexSize = 0;
     uint32      numVertices = 0;
-    std::string name;
+    std::string name = "";
 };
 struct IndexBufferCreateInfo
 {
     DataSource          sourceData = DataSource();
     Gfx::SeIndexType    indexType = Gfx::SeIndexType::SE_INDEX_TYPE_UINT16;
-    std::string name;
+    std::string name = "";
 };
 struct UniformBufferCreateInfo
 {
     DataSource  sourceData = DataSource();
     uint8       dynamic = 0;
-    std::string name;
+    std::string name = "";
 };
 struct ShaderBufferCreateInfo
 {
     DataSource  sourceData = DataSource();
     uint64      numElements = 1;
     uint8       dynamic = 0;
-    std::string name;
+    std::string name = "";
 };
 DECLARE_NAME_REF(Gfx, PipelineLayout)
 struct ShaderCreateInfo
diff --git a/src/Engine/Graphics/Metal/Buffer.h b/src/Engine/Graphics/Metal/Buffer.h
index baf1d64..d0bf020 100644
--- a/src/Engine/Graphics/Metal/Buffer.h
+++ b/src/Engine/Graphics/Metal/Buffer.h
@@ -9,7 +9,7 @@ namespace Metal {
 DECLARE_REF(Graphics)
 class Buffer {
 public:
-  Buffer(PGraphics graphics, uint64 size, void *data, bool dynamic);
+  Buffer(PGraphics graphics, uint64 size, void *data, bool dynamic, const std::string& name);
   virtual ~Buffer();
   MTL::Buffer *getHandle() const { return buffers[currentBuffer]; }
   uint64 getSize() const { return size; }
@@ -83,4 +83,4 @@ protected:
 };
 DEFINE_REF(ShaderBuffer)
 } // namespace Metal
-} // namespace Seele
\ No newline at end of file
+} // namespace Seele
diff --git a/src/Engine/Graphics/Metal/Buffer.mm b/src/Engine/Graphics/Metal/Buffer.mm
index afe9907..8da8824 100644
--- a/src/Engine/Graphics/Metal/Buffer.mm
+++ b/src/Engine/Graphics/Metal/Buffer.mm
@@ -3,10 +3,12 @@
 #include "Graphics/Buffer.h"
 #include "Graphics/Enums.h"
 #include "Graphics/Initializer.h"
+#include <iostream>
+
 using namespace Seele;
 using namespace Seele::Metal;
 
-Buffer::Buffer(PGraphics graphics, uint64 size, void* data, bool dynamic) : graphics(graphics), size(size) {
+Buffer::Buffer(PGraphics graphics, uint64 size, void* data, bool dynamic, const std::string& name) : graphics(graphics), size(size) {
   if (dynamic) {
     numBuffers = Gfx::numFramesBuffered;
   } else {
@@ -14,10 +16,11 @@ Buffer::Buffer(PGraphics graphics, uint64 size, void* data, bool dynamic) : grap
   }
   for (size_t i = 0; i < numBuffers; ++i) {
     if (data != nullptr) {
-      buffers[i] = graphics->getDevice()->newBuffer(data, size, MTL::ResourceOptionCPUCacheModeDefault);
+      buffers[i] = graphics->getDevice()->newBuffer(data, size, MTL::StorageModeShared);
     } else {
-      buffers[i] = graphics->getDevice()->newBuffer(size, MTL::ResourceOptionCPUCacheModeDefault);
+      buffers[i] = graphics->getDevice()->newBuffer(size, MTL::StorageModeShared);
     }
+      buffers[i]->setLabel(NS::String::string(name.c_str(), NS::ASCIIStringEncoding));
   }
 }
 
@@ -31,12 +34,12 @@ void* Buffer::map(bool) { return getHandle()->contents(); }
 
 void* Buffer::mapRegion(uint64 regionOffset, uint64, bool) { return (char*)getHandle()->contents() + regionOffset; }
 
-void unmap() {}
+void Buffer::unmap() {}
 
 VertexBuffer::VertexBuffer(PGraphics graphics, const VertexBufferCreateInfo& createInfo)
     : Gfx::VertexBuffer(graphics->getFamilyMapping(), createInfo.numVertices, createInfo.vertexSize,
                         createInfo.sourceData.owner),
-      Seele::Metal::Buffer(graphics, createInfo.sourceData.size, createInfo.sourceData.data, false) {}
+      Seele::Metal::Buffer(graphics, createInfo.sourceData.size, createInfo.sourceData.data, false, createInfo.name) {}
 
 VertexBuffer::~VertexBuffer() {}
 
@@ -61,7 +64,7 @@ void VertexBuffer::executePipelineBarrier(Gfx::SeAccessFlags srcAccess, Gfx::SeP
 IndexBuffer::IndexBuffer(PGraphics graphics, const IndexBufferCreateInfo& createInfo)
     : Gfx::IndexBuffer(graphics->getFamilyMapping(), createInfo.sourceData.size, createInfo.indexType,
                        createInfo.sourceData.owner),
-      Seele::Metal::Buffer(graphics, createInfo.sourceData.size, createInfo.sourceData.data, false) {}
+      Seele::Metal::Buffer(graphics, createInfo.sourceData.size, createInfo.sourceData.data, false, createInfo.name) {}
 
 IndexBuffer::~IndexBuffer() {}
 
@@ -77,7 +80,7 @@ void IndexBuffer::executePipelineBarrier(Gfx::SeAccessFlags srcAccess, Gfx::SePi
 
 UniformBuffer::UniformBuffer(PGraphics graphics, const UniformBufferCreateInfo& createInfo)
     : Gfx::UniformBuffer(graphics->getFamilyMapping(), createInfo.sourceData),
-      Seele::Metal::Buffer(graphics, createInfo.sourceData.size, createInfo.sourceData.data, createInfo.dynamic) {}
+      Seele::Metal::Buffer(graphics, createInfo.sourceData.size, createInfo.sourceData.data, createInfo.dynamic, createInfo.name) {}
 
 UniformBuffer::~UniformBuffer() {}
 
@@ -94,7 +97,7 @@ void UniformBuffer::executePipelineBarrier(Gfx::SeAccessFlags srcAccess, Gfx::Se
 
 ShaderBuffer::ShaderBuffer(PGraphics graphics, const ShaderBufferCreateInfo& createInfo)
     : Gfx::ShaderBuffer(graphics->getFamilyMapping(), createInfo.numElements, createInfo.sourceData),
-      Seele::Metal::Buffer(graphics, createInfo.sourceData.size, createInfo.sourceData.data, createInfo.dynamic) {}
+      Seele::Metal::Buffer(graphics, createInfo.sourceData.size, createInfo.sourceData.data, createInfo.dynamic, createInfo.name) {}
 
 ShaderBuffer::~ShaderBuffer() {}
 
@@ -108,4 +111,4 @@ void ShaderBuffer::executeOwnershipBarrier(Gfx::QueueType newOwner) { currentOwn
 
 
 void ShaderBuffer::executePipelineBarrier(Gfx::SeAccessFlags srcAccess, Gfx::SePipelineStageFlags srcStage,
-                                          Gfx::SeAccessFlags dstAccess, Gfx::SePipelineStageFlags dstStage) {}
\ No newline at end of file
+                                          Gfx::SeAccessFlags dstAccess, Gfx::SePipelineStageFlags dstStage) {}
diff --git a/src/Engine/Graphics/Metal/Command.mm b/src/Engine/Graphics/Metal/Command.mm
index 14fd9e5..8d5e910 100644
--- a/src/Engine/Graphics/Metal/Command.mm
+++ b/src/Engine/Graphics/Metal/Command.mm
@@ -11,6 +11,7 @@
 #include "Pipeline.h"
 #include "Resources.h"
 #include "Window.h"
+#include <iostream>
 
 using namespace Seele;
 using namespace Seele::Metal;
@@ -74,14 +75,46 @@ void RenderCommand::setViewport(Gfx::PViewport viewport) {
 void RenderCommand::bindPipeline(Gfx::PGraphicsPipeline pipeline) {
   boundPipeline = pipeline.cast<GraphicsPipeline>();
   encoder->setRenderPipelineState(boundPipeline->getHandle());
+  uint64 argBufferSize = 0;
+  for (auto [_, layout] : boundPipeline->getPipelineLayout()->getLayouts()) {
+    argBufferSize += 3 * sizeof(uint64) * layout->getBindings().size();
+  }
+  argumentBuffer = boundPipeline->graphics->getDevice()->newBuffer(argBufferSize, MTL::ResourceStorageModeShared);
+  argumentBuffer->setLabel(
+      NS::String::string(boundPipeline->getPipelineLayout()->getName().c_str(), NS::ASCIIStringEncoding));
 }
 
 void RenderCommand::bindDescriptor(Gfx::PDescriptorSet descriptorSet) {
-    uint32 parameterIndex = boundPipeline->getPipelineLayout()->findParameter(descriptorSet->getLayout()->getName());
-  encoder->setVertexBuffer(descriptorSet.cast<DescriptorSet>()->getBuffer(), 0, parameterIndex);
-  encoder->setFragmentBuffer(descriptorSet.cast<DescriptorSet>()->getBuffer(), 0, parameterIndex);
-  encoder->setMeshBuffer(descriptorSet.cast<DescriptorSet>()->getBuffer(), 0, parameterIndex);
-  encoder->setObjectBuffer(descriptorSet.cast<DescriptorSet>()->getBuffer(), 0, parameterIndex);
+  auto metalSet = descriptorSet.cast<DescriptorSet>();
+  uint32 parameterIndex = boundPipeline->getPipelineLayout()->findParameter(descriptorSet->getLayout()->getName());
+  uint64* topLevelTable = (uint64*)argumentBuffer->contents();
+  topLevelTable[parameterIndex] = metalSet->getBuffer()->gpuAddress();
+  auto bindings = metalSet->getLayout()->getBindings();
+  encoder->useResource(metalSet->getBuffer(), MTL::ResourceUsageRead);
+  for (size_t i = 0; i < bindings.size(); ++i) {
+    auto binding = bindings[i];
+    if (binding.descriptorType == Gfx::SE_DESCRIPTOR_TYPE_SAMPLER) {
+      continue;
+    }
+    MTL::ResourceUsage usage;
+    switch (binding.access) {
+    case Gfx::SE_DESCRIPTOR_ACCESS_READ_ONLY_BIT:
+      if (binding.descriptorType == Gfx::SE_DESCRIPTOR_TYPE_SAMPLED_IMAGE) {
+        usage = MTL::ResourceUsageSample;
+        break;
+      } else {
+        usage = MTL::ResourceUsageRead;
+        break;
+      }
+    case Gfx::SE_DESCRIPTOR_ACCESS_READ_WRITE_BIT:
+      usage = MTL::ResourceUsageRead | MTL::ResourceUsageWrite;
+      break;
+    case Gfx::SE_DESCRIPTOR_ACCESS_WRITE_ONLY_BIT:
+      usage = MTL::ResourceUsageWrite;
+      break;
+    }
+    encoder->useResource(metalSet->getBoundResources()[i], usage);
+  }
 }
 
 void RenderCommand::bindDescriptor(const Array<Gfx::PDescriptorSet>& descriptorSets) {
@@ -122,6 +155,10 @@ void RenderCommand::drawIndexed(uint32 indexCount, uint32 instanceCount, int32 f
 
 void RenderCommand::drawMesh(uint32 groupX, uint32 groupY, uint32 groupZ) {
   // TODO:
+  std::cout << "Draw" << std::endl;
+  encoder->setFragmentBuffer(argumentBuffer, 0, 2);
+  encoder->setMeshBuffer(argumentBuffer, 0, 2);
+  encoder->setObjectBuffer(argumentBuffer, 0, 2);
   encoder->drawMeshThreadgroups(MTL::Size(groupX, groupY, groupZ), MTL::Size(128, 1, 1), MTL::Size(32, 1, 1));
 }
 
@@ -136,46 +173,46 @@ void ComputeCommand::end() {
 }
 
 void ComputeCommand::bindPipeline(Gfx::PComputePipeline pipeline) {
-    boundPipeline = pipeline.cast<ComputePipeline>();
-    encoder->setComputePipelineState(boundPipeline->getHandle());
-    argumentBuffer = boundPipeline->graphics->getDevice()->newBuffer(sizeof(uint64) * boundPipeline->getPipelineLayout()->getLayouts().size(), MTL::ResourceOptionCPUCacheModeDefault);
+  boundPipeline = pipeline.cast<ComputePipeline>();
+  encoder->setComputePipelineState(boundPipeline->getHandle());
+  argumentBuffer = boundPipeline->graphics->getDevice()->newBuffer(
+      sizeof(uint64) * (boundPipeline->getPipelineLayout()->getLayouts().size() + 1), MTL::ResourceStorageModeShared);
+  argumentBuffer->setLabel(
+      NS::String::string(pipeline->getPipelineLayout()->getName().c_str(), NS::ASCIIStringEncoding));
 }
 
 void ComputeCommand::bindDescriptor(Gfx::PDescriptorSet set) {
   auto metalSet = set.cast<DescriptorSet>();
   metalSet->bind();
-    uint32 parameterIndex = boundPipeline->getPipelineLayout()->findParameter(set->getLayout()->getName());
-    uint64* topLevelTable = (uint64*)argumentBuffer->contents();
-    topLevelTable[parameterIndex] = metalSet->getBuffer()->gpuAddress();
-    auto bindings =metalSet->getLayout()->getBindings();
-    for(size_t i = 0; i < bindings.size(); ++i)
-    {
-        auto binding = bindings[i];
-        if(binding.descriptorType == Gfx::SE_DESCRIPTOR_TYPE_SAMPLER)
-        {
-            continue;
-        }
-        MTL::ResourceUsage usage;
-        switch(binding.access) {
-            case Gfx::SE_DESCRIPTOR_ACCESS_READ_ONLY_BIT:
-                if(binding.descriptorType == Gfx::SE_DESCRIPTOR_TYPE_SAMPLED_IMAGE)
-                {
-                    usage = MTL::ResourceUsageSample;
-                    break;
-                }else
-                {
-                    usage = MTL::ResourceUsageRead;
-                    break;
-                }
-            case Gfx::SE_DESCRIPTOR_ACCESS_READ_WRITE_BIT:
-                usage = MTL::ResourceUsageRead | MTL::ResourceUsageWrite;
-                break;
-            case Gfx::SE_DESCRIPTOR_ACCESS_WRITE_ONLY_BIT:
-                usage = MTL::ResourceUsageWrite;
-                break;
-        }
-        encoder->useResource(metalSet->getBoundResources()[i], usage);
+  uint32 parameterIndex = boundPipeline->getPipelineLayout()->findParameter(set->getLayout()->getName());
+  uint64* topLevelTable = (uint64*)argumentBuffer->contents();
+  topLevelTable[parameterIndex] = metalSet->getBuffer()->gpuAddress();
+  auto bindings = metalSet->getLayout()->getBindings();
+  encoder->useResource(metalSet->getBuffer(), MTL::ResourceUsageRead);
+  for (size_t i = 0; i < bindings.size(); ++i) {
+    auto binding = bindings[i];
+    if (binding.descriptorType == Gfx::SE_DESCRIPTOR_TYPE_SAMPLER) {
+      continue;
     }
+    MTL::ResourceUsage usage;
+    switch (binding.access) {
+    case Gfx::SE_DESCRIPTOR_ACCESS_READ_ONLY_BIT:
+      if (binding.descriptorType == Gfx::SE_DESCRIPTOR_TYPE_SAMPLED_IMAGE) {
+        usage = MTL::ResourceUsageSample;
+        break;
+      } else {
+        usage = MTL::ResourceUsageRead;
+        break;
+      }
+    case Gfx::SE_DESCRIPTOR_ACCESS_READ_WRITE_BIT:
+      usage = MTL::ResourceUsageRead | MTL::ResourceUsageWrite;
+      break;
+    case Gfx::SE_DESCRIPTOR_ACCESS_WRITE_ONLY_BIT:
+      usage = MTL::ResourceUsageWrite;
+      break;
+    }
+    encoder->useResource(metalSet->getBoundResources()[i], usage);
+  }
 }
 
 void ComputeCommand::bindDescriptor(const Array<Gfx::PDescriptorSet>& sets) {
@@ -191,15 +228,15 @@ void ComputeCommand::pushConstants(Gfx::PPipelineLayout, Gfx::SeShaderStageFlags
 
 void ComputeCommand::dispatch(uint32 threadX, uint32 threadY, uint32 threadZ) {
   // TODO
-    encoder->setBuffer(argumentBuffer, 0, 2);
+  encoder->setBuffer(argumentBuffer, 0, 2);
   encoder->dispatchThreadgroups(MTL::Size(threadX, threadY, threadZ), MTL::Size(32, 32, 1));
 }
 
 CommandQueue::CommandQueue(PGraphics graphics) : graphics(graphics) {
   queue = graphics->getDevice()->newCommandQueue();
   MTL::CommandBufferDescriptor* descriptor = MTL::CommandBufferDescriptor::alloc()->init();
-  descriptor->setErrorOptions(MTL::CommandBufferErrorOptionEncoderExecutionStatus);
   activeCommand = new Command(graphics, queue->commandBuffer(descriptor));
+  descriptor->release();
 }
 
 CommandQueue::~CommandQueue() { queue->release(); }
diff --git a/src/Engine/Graphics/Metal/Descriptor.h b/src/Engine/Graphics/Metal/Descriptor.h
index d43055b..1edd5e3 100644
--- a/src/Engine/Graphics/Metal/Descriptor.h
+++ b/src/Engine/Graphics/Metal/Descriptor.h
@@ -13,11 +13,8 @@ public:
   virtual ~DescriptorLayout();
   virtual void create() override;
 
-  NS::Array* getArguments() const { return arguments; }
-
 private:
   PGraphics graphics;
-  NS::Array* arguments;
 };
 DEFINE_REF(DescriptorLayout)
 
@@ -28,7 +25,6 @@ public:
   virtual ~DescriptorPool();
   virtual Gfx::PDescriptorSet allocateDescriptorSet() override;
   virtual void reset() override;
-  constexpr NS::Array* getArguments() const { return layout->getArguments(); }
   constexpr PDescriptorLayout getLayout() const { return layout; }
 
 private:
@@ -63,7 +59,7 @@ private:
   PGraphics graphics;
   PDescriptorPool owner;
   MTL::Buffer* buffer = nullptr;
-  MTL::ArgumentEncoder* encoder;
+    uint64* argumentBuffer = nullptr;
     Array<MTL::Resource*> boundResources;
   uint32 bindCount;
   bool currentlyInUse;
@@ -72,10 +68,10 @@ DEFINE_REF(DescriptorSet)
 
 class PipelineLayout : public Gfx::PipelineLayout {
 public:
-  PipelineLayout(PGraphics graphics, Gfx::PPipelineLayout baseLayout);
+  PipelineLayout(PGraphics graphics, const std::string& name, Gfx::PPipelineLayout baseLayout);
   virtual ~PipelineLayout();
   virtual void create() override;
-
+  Array<Array<uint32>> 
 private:
   PGraphics graphics;
 };
diff --git a/src/Engine/Graphics/Metal/Descriptor.mm b/src/Engine/Graphics/Metal/Descriptor.mm
index 3226d1d..d59a655 100644
--- a/src/Engine/Graphics/Metal/Descriptor.mm
+++ b/src/Engine/Graphics/Metal/Descriptor.mm
@@ -15,74 +15,11 @@ using namespace Seele;
 using namespace Seele::Metal;
 
 DescriptorLayout::DescriptorLayout(PGraphics graphics, const std::string& name)
-    : Gfx::DescriptorLayout(name), graphics(graphics), arguments(nullptr) {}
+    : Gfx::DescriptorLayout(name), graphics(graphics) {}
 
 DescriptorLayout::~DescriptorLayout() {}
 
 void DescriptorLayout::create() {
-  if (arguments != nullptr) {
-    return;
-  }
-  Array<NS::Object*> descriptors;
-  for (size_t i = 0; i < descriptorBindings.size(); ++i) {
-    const auto& binding = descriptorBindings[i];
-    auto desc = MTL::ArgumentDescriptor::alloc()->init();
-    desc->setAccess(cast(binding.access));
-    desc->setArrayLength(binding.descriptorCount);
-    MTL::DataType dataType;
-    switch (binding.descriptorType) {
-    case Gfx::SE_DESCRIPTOR_TYPE_SAMPLER:
-    case Gfx::SE_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER:
-    case Gfx::SE_DESCRIPTOR_TYPE_SAMPLED_IMAGE:
-    case Gfx::SE_DESCRIPTOR_TYPE_STORAGE_IMAGE:
-    case Gfx::SE_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER:
-    case Gfx::SE_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER:
-    case Gfx::SE_DESCRIPTOR_TYPE_INPUT_ATTACHMENT:
-      dataType = MTL::DataTypeTexture;
-      break;
-    case Gfx::SE_DESCRIPTOR_TYPE_UNIFORM_BUFFER:
-    case Gfx::SE_DESCRIPTOR_TYPE_STORAGE_BUFFER:
-    case Gfx::SE_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC:
-    case Gfx::SE_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC:
-    case Gfx::SE_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK_EXT:
-      dataType = MTL::DataTypePointer;
-      break;
-    case Gfx::SE_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_NV:
-      dataType = MTL::DataTypePrimitiveAccelerationStructure;
-      break;
-    default:
-      throw std::logic_error("Nooo");
-    }
-    desc->setDataType(dataType);
-    desc->setIndex(i);
-    if (dataType == MTL::DataTypeTexture) {
-      switch (binding.textureType) {
-      case Gfx::SE_IMAGE_VIEW_TYPE_1D:
-        desc->setTextureType(MTL::TextureType1D);
-        break;
-      case Gfx::SE_IMAGE_VIEW_TYPE_2D:
-        desc->setTextureType(MTL::TextureType2D);
-        break;
-      case Gfx::SE_IMAGE_VIEW_TYPE_3D:
-        desc->setTextureType(MTL::TextureType3D);
-        break;
-      case Gfx::SE_IMAGE_VIEW_TYPE_CUBE:
-        desc->setTextureType(MTL::TextureTypeCube);
-        break;
-      case Gfx::SE_IMAGE_VIEW_TYPE_1D_ARRAY:
-        desc->setTextureType(MTL::TextureType1DArray);
-        break;
-      case Gfx::SE_IMAGE_VIEW_TYPE_2D_ARRAY:
-        desc->setTextureType(MTL::TextureType2DArray);
-        break;
-      case Gfx::SE_IMAGE_VIEW_TYPE_CUBE_ARRAY:
-        desc->setTextureType(MTL::TextureTypeCubeArray);
-        break;
-      }
-    }
-    descriptors.add(desc);
-  }
-  arguments = NS::Array::array(descriptors.data(), descriptors.size());
   pool = new DescriptorPool(graphics, this);
   hash = CRC::Calculate(descriptorBindings.data(), sizeof(Gfx::DescriptorBinding) * descriptorBindings.size(),
                         CRC::CRC_32());
@@ -116,63 +53,72 @@ void DescriptorPool::reset() {
 
 DescriptorSet::DescriptorSet(PGraphics graphics, PDescriptorPool owner)
     : Gfx::DescriptorSet(owner->getLayout()), graphics(graphics), owner(owner), bindCount(0), currentlyInUse(false) {
-  if (owner->getArguments()->count() > 0) {
-      boundResources.resize(owner->getArguments()->count());
-      encoder = graphics->getDevice()->newArgumentEncoder(owner->getArguments());
-      buffer = graphics->getDevice()->newBuffer(encoder->encodedLength(), MTL::ResourceOptionCPUCacheModeDefault);
-      encoder->setArgumentBuffer(buffer, 0);
-  } else
-  {
-      buffer = graphics->getDevice()->newBuffer(8, MTL::ResourceOptionCPUCacheModeDefault);
-  }
+  boundResources.resize(owner->getLayout()->getBindings().size());
+  buffer = graphics->getDevice()->newBuffer(std::max<size_t>(8, sizeof(uint64_t) * 3 * owner->getLayout()->getBindings().size()), MTL::ResourceStorageModeShared);
+    argumentBuffer = (uint64*)buffer->contents();
+    buffer->setLabel(NS::String::string(owner->getLayout()->getName().c_str(), NS::ASCIIStringEncoding));
 }
 
-DescriptorSet::~DescriptorSet() {}
+DescriptorSet::~DescriptorSet() {buffer->release();}
 
 void DescriptorSet::writeChanges() {}
 
 void DescriptorSet::updateBuffer(uint32_t binding, Gfx::PUniformBuffer uniformBuffer) {
   PUniformBuffer metalBuffer = uniformBuffer.cast<UniformBuffer>();
-  encoder->setBuffer(metalBuffer->getHandle(), 0, binding);
+    uint64 offset = binding * 3;
+    argumentBuffer[offset + 0] = metalBuffer->getHandle()->gpuAddress();
+    argumentBuffer[offset + 1] = 0;
+    argumentBuffer[offset + 2] = (uint32)metalBuffer->getSize(); // TODO: buffer texture view, typed??
     boundResources[binding] = metalBuffer->getHandle();
 }
 void DescriptorSet::updateBuffer(uint32_t binding, Gfx::PShaderBuffer uniformBuffer) {
   PShaderBuffer metalBuffer = uniformBuffer.cast<ShaderBuffer>();
-  encoder->setBuffer(metalBuffer->getHandle(), 0, binding);
+    uint64 offset = binding * 3;
+    argumentBuffer[offset + 0] = metalBuffer->getHandle()->gpuAddress();
+    argumentBuffer[offset + 1] = 0;
+    argumentBuffer[offset + 2] = (uint32)metalBuffer->getSize(); // TODO: buffer texture view, typed??
     boundResources[binding] = metalBuffer->getHandle();
 }
 void DescriptorSet::updateSampler(uint32_t binding, Gfx::PSampler samplerState) {
   PSampler sampler = samplerState.cast<Sampler>();
-  encoder->setSamplerState(sampler->getHandle(), binding);
+    MTL::ResourceID resourceId =sampler->getHandle()->gpuResourceID();
+    uint64 offset = binding * 3;
+    argumentBuffer[offset + 0] = 0;
+    argumentBuffer[offset + 1] = *(uint64*)&resourceId;
+    argumentBuffer[offset + 2] = 0; // LOD bias
 }
 void DescriptorSet::updateTexture(uint32_t binding, Gfx::PTexture texture, Gfx::PSampler samplerState) {
   PTextureBase base = texture.cast<TextureBase>();
     if(layout->getBindings()[binding].access == Gfx::SE_DESCRIPTOR_ACCESS_READ_ONLY_BIT)
     {
-        encoder->setTexture(base->getTexture(), binding);
-        
+        MTL::ResourceID resourceId =base->getTexture()->gpuResourceID();
+        uint64 offset = binding * 3;
+        argumentBuffer[offset + 0] = 0;
+        argumentBuffer[offset + 1] = *(uint64*)&resourceId;
+        argumentBuffer[offset + 2] = 0; // min LOD clamp
     }else{
-        encoder->setBuffer(base->getTexture()->buffer(), 0, binding);
+        uint64 offset = binding * 3;
+        argumentBuffer[offset + 0] = base->getTexture()->buffer()->gpuAddress();
+        argumentBuffer[offset + 1] = 0;
+        argumentBuffer[offset + 2] = (uint32)base->getTexture()->buffer()->length(); // TODO: buffer texture view, typed??
     }
     boundResources[binding] = base->getTexture();
 }
 
 void DescriptorSet::updateTextureArray(uint32_t binding, Array<Gfx::PTexture> array) {
   for (auto& t : array) {
-    PTextureBase metalTexture = t.cast<TextureBase>();
-    encoder->setTexture(metalTexture->getTexture(), binding);
-      boundResources[binding++] = metalTexture->getTexture();
+      updateTexture(binding++, t);
   }
 }
 
-PipelineLayout::PipelineLayout(PGraphics graphics, Gfx::PPipelineLayout baseLayout)
-    : Gfx::PipelineLayout(baseLayout), graphics(graphics) {}
+PipelineLayout::PipelineLayout(PGraphics graphics, const std::string& name, Gfx::PPipelineLayout baseLayout)
+    : Gfx::PipelineLayout(name, baseLayout), graphics(graphics) {}
 
 PipelineLayout::~PipelineLayout() {}
 
 void PipelineLayout::create() {
   for (auto& [_, set] : descriptorSetLayouts) {
-    set->create();
+      assert(set->getHash() != 0);
     uint32 setHash = set->getHash();
     layoutHash = CRC::Calculate(&setHash, sizeof(uint32), CRC::CRC_32(), layoutHash);
   }
diff --git a/src/Engine/Graphics/Metal/Graphics.h b/src/Engine/Graphics/Metal/Graphics.h
index fbf6d10..aaa30ad 100644
--- a/src/Engine/Graphics/Metal/Graphics.h
+++ b/src/Engine/Graphics/Metal/Graphics.h
@@ -49,7 +49,7 @@ public:
     virtual Gfx::OSampler createSampler(const SamplerCreateInfo& createInfo) override;
 
   	virtual Gfx::ODescriptorLayout createDescriptorLayout(const std::string& name = "") override;
-  	virtual Gfx::OPipelineLayout createPipelineLayout(Gfx::PPipelineLayout baseLayout = nullptr) override;
+  	virtual Gfx::OPipelineLayout createPipelineLayout(const std::string& name = "", Gfx::PPipelineLayout baseLayout = nullptr) override;
 
     virtual Gfx::OVertexInput createVertexInput(VertexInputStateCreateInfo createInfo) override;
 
diff --git a/src/Engine/Graphics/Metal/Graphics.mm b/src/Engine/Graphics/Metal/Graphics.mm
index 6ad4d08..c095d7b 100644
--- a/src/Engine/Graphics/Metal/Graphics.mm
+++ b/src/Engine/Graphics/Metal/Graphics.mm
@@ -180,9 +180,9 @@ Gfx::ODescriptorLayout Graphics::createDescriptorLayout(const std::string& name)
   return new DescriptorLayout(this, name);
 }
 
-Gfx::OPipelineLayout Graphics::createPipelineLayout(Gfx::PPipelineLayout baseLayout)
+Gfx::OPipelineLayout Graphics::createPipelineLayout(const std::string& name, Gfx::PPipelineLayout baseLayout)
 {
-  return new PipelineLayout(this, baseLayout);
+  return new PipelineLayout(this, name, baseLayout);
 }
 
 Gfx::OVertexInput Graphics::createVertexInput(VertexInputStateCreateInfo createInfo)
diff --git a/src/Engine/Graphics/Metal/Pipeline.h b/src/Engine/Graphics/Metal/Pipeline.h
index c6b16ae..94daa92 100644
--- a/src/Engine/Graphics/Metal/Pipeline.h
+++ b/src/Engine/Graphics/Metal/Pipeline.h
@@ -19,10 +19,10 @@ public:
   virtual ~GraphicsPipeline();
   constexpr MTL::RenderPipelineState* getHandle() const { return state; }
   constexpr MTL::PrimitiveType getPrimitive() const { return primitiveType; }
-private:
   PGraphics graphics;
   MTL::RenderPipelineState* state;
   MTL::PrimitiveType primitiveType;
+private:
 };
 DEFINE_REF(GraphicsPipeline)
 class ComputePipeline : public Gfx::ComputePipeline {
diff --git a/src/Engine/Graphics/Metal/Shader.mm b/src/Engine/Graphics/Metal/Shader.mm
index 9251524..2552fce 100644
--- a/src/Engine/Graphics/Metal/Shader.mm
+++ b/src/Engine/Graphics/Metal/Shader.mm
@@ -25,15 +25,15 @@ Shader::~Shader() {
 }
 
 void Shader::create(const ShaderCreateInfo& createInfo) {
-    std::cout << "Compiling " << createInfo.name << std::endl;
-  Map<std::string, uint32> test;
-  Slang::ComPtr<slang::IBlob> kernelBlob = generateShader(createInfo, SLANG_DXIL, test);
+  std::cout << "Compiling " << createInfo.name << std::endl;
+  Map<std::string, uint32> paramMapping;
+  Slang::ComPtr<slang::IBlob> kernelBlob = generateShader(createInfo, SLANG_DXIL, paramMapping);
   hash = CRC::Calculate(kernelBlob->getBufferPointer(), kernelBlob->getBufferSize(), CRC::CRC_32());
   IRCompiler* pCompiler = IRCompilerCreate();
   IRCompilerSetMinimumGPUFamily(pCompiler, IRGPUFamilyMetal3);
   IRCompilerIgnoreRootSignature(pCompiler, true);
   IRCompilerSetEntryPointName(pCompiler, "main");
-    IRCompilerSetValidationFlags(pCompiler, IRCompilerValidationFlagAll);
+  IRCompilerSetValidationFlags(pCompiler, IRCompilerValidationFlagAll);
 
   IRObject* pDXIL = IRObjectCreateFromDXIL((const uint8*)kernelBlob->getBufferPointer(), kernelBlob->getBufferSize(),
                                            IRBytecodeOwnershipNone);
@@ -100,8 +100,8 @@ void Shader::create(const ShaderCreateInfo& createInfo) {
   descriptor.desc_1_1.pParameters = parameters.data();
   IRRootSignature* rootSignature = IRRootSignatureCreateFromDescriptor(&descriptor, &signatureError);
   assert(rootSignature);
-  IRCompilerSetGlobalRootSignature(pCompiler, rootSignature);
-  // Compile DXIL to Metal IR:
+  // IRCompilerSetGlobalRootSignature(pCompiler, rootSignature);
+  //  Compile DXIL to Metal IR:
   IRError* pError = nullptr;
   IRObject* pOutIR = IRCompilerAllocCompileAndLink(pCompiler, NULL, pDXIL, &pError);
 
@@ -131,7 +131,7 @@ void Shader::create(const ShaderCreateInfo& createInfo) {
   IRMetalLibBinary* pMetallib = IRMetalLibBinaryCreate();
   IRObjectGetMetalLibBinary(pOutIR, irStage, pMetallib);
   dispatch_data_t data = IRMetalLibGetBytecodeData(pMetallib);
-    
+
   IRShaderReflection* reflection = IRShaderReflectionCreate();
   IRObjectGetReflection(pOutIR, irStage, reflection);
   std::cout << IRShaderReflectionAllocStringAndSerialize(reflection) << std::endl;
diff --git a/src/Engine/Graphics/Metal/Texture.mm b/src/Engine/Graphics/Metal/Texture.mm
index c80a261..a5cbac1 100644
--- a/src/Engine/Graphics/Metal/Texture.mm
+++ b/src/Engine/Graphics/Metal/Texture.mm
@@ -21,7 +21,7 @@ TextureBase::TextureBase(PGraphics graphics, MTL::TextureType type,
       ownsImage(existingImage == nullptr) {
   if (existingImage == nullptr) {
     MTL::TextureUsage mtlUsage = 0;
-    if(usage & Gfx::SE_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT)
+    if(usage & Gfx::SE_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT || usage & Gfx::SE_IMAGE_USAGE_COLOR_ATTACHMENT_BIT)
     {
         mtlUsage |= MTL::TextureUsageRenderTarget;
     }
@@ -29,6 +29,10 @@ TextureBase::TextureBase(PGraphics graphics, MTL::TextureType type,
     {
         mtlUsage |= MTL::TextureUsageShaderRead;
     }
+      if(usage & Gfx::SE_IMAGE_USAGE_STORAGE_BIT)
+      {
+          mtlUsage |= MTL::TextureUsageShaderWrite;
+      }
     MTL::TextureDescriptor *descriptor =
         MTL::TextureDescriptor::alloc()->init();
     descriptor->setPixelFormat(cast(format));
diff --git a/src/Engine/Graphics/RenderPass/BasePass.cpp b/src/Engine/Graphics/RenderPass/BasePass.cpp
index 0f9c1c2..86ce23e 100644
--- a/src/Engine/Graphics/RenderPass/BasePass.cpp
+++ b/src/Engine/Graphics/RenderPass/BasePass.cpp
@@ -157,7 +157,7 @@ void BasePass::endFrame()
 
 void BasePass::publishOutputs() 
 {
-    basePassLayout = graphics->createPipelineLayout();
+    basePassLayout = graphics->createPipelineLayout("BasePassLayout");
 
     basePassLayout->addDescriptorLayout(viewParamsLayout);
     basePassLayout->addDescriptorLayout(scene->getLightEnvironment()->getDescriptorLayout());
diff --git a/src/Engine/Graphics/RenderPass/DebugPass.cpp b/src/Engine/Graphics/RenderPass/DebugPass.cpp
index 627bfbe..83d7ad2 100644
--- a/src/Engine/Graphics/RenderPass/DebugPass.cpp
+++ b/src/Engine/Graphics/RenderPass/DebugPass.cpp
@@ -119,7 +119,7 @@ void DebugPass::createRenderPass()
     };
     renderPass = graphics->createRenderPass(std::move(layout), dependency, viewport);
     
-    pipelineLayout = graphics->createPipelineLayout();
+    pipelineLayout = graphics->createPipelineLayout("DebugPassLayout");
     pipelineLayout->addDescriptorLayout(viewParamsLayout);
     pipelineLayout->create();
 
diff --git a/src/Engine/Graphics/RenderPass/DepthPrepass.cpp b/src/Engine/Graphics/RenderPass/DepthPrepass.cpp
index 1ab6bba..1aa25e6 100644
--- a/src/Engine/Graphics/RenderPass/DepthPrepass.cpp
+++ b/src/Engine/Graphics/RenderPass/DepthPrepass.cpp
@@ -16,7 +16,7 @@ DepthPrepass::DepthPrepass(Gfx::PGraphics graphics, PScene scene)
     : RenderPass(graphics, scene)
     , descriptorSets(3)
 {
-    depthPrepassLayout = graphics->createPipelineLayout();
+    depthPrepassLayout = graphics->createPipelineLayout("DepthPrepassLayout");
     depthPrepassLayout->addDescriptorLayout(viewParamsLayout);
     if (graphics->supportMeshShading())
     {
diff --git a/src/Engine/Graphics/RenderPass/LightCullingPass.cpp b/src/Engine/Graphics/RenderPass/LightCullingPass.cpp
index 2c3de74..f264efc 100644
--- a/src/Engine/Graphics/RenderPass/LightCullingPass.cpp
+++ b/src/Engine/Graphics/RenderPass/LightCullingPass.cpp
@@ -114,9 +114,11 @@ void LightCullingPass::publishOutputs()
     //t_lightGrid
     cullingDescriptorLayout->addDescriptorBinding(Gfx::DescriptorBinding{.binding = 6, .descriptorType = Gfx::SE_DESCRIPTOR_TYPE_STORAGE_IMAGE, .access = Gfx::SE_DESCRIPTOR_ACCESS_READ_WRITE_BIT});
 
+    cullingDescriptorLayout->create();
+    
     lightEnv = scene->getLightEnvironment();
 
-    cullingLayout = graphics->createPipelineLayout();
+    cullingLayout = graphics->createPipelineLayout("CullingLayout");
     cullingLayout->addDescriptorLayout(viewParamsLayout);
     cullingLayout->addDescriptorLayout(dispatchParamsLayout);
     cullingLayout->addDescriptorLayout(cullingDescriptorLayout);
@@ -213,7 +215,8 @@ void LightCullingPass::setupFrustums()
     dispatchParamsLayout = graphics->createDescriptorLayout("pDispatchParams");
     dispatchParamsLayout->addDescriptorBinding(Gfx::DescriptorBinding{.binding = 0, .descriptorType = Gfx::SE_DESCRIPTOR_TYPE_UNIFORM_BUFFER, });
     dispatchParamsLayout->addDescriptorBinding(Gfx::DescriptorBinding{.binding = 1, .descriptorType = Gfx::SE_DESCRIPTOR_TYPE_STORAGE_BUFFER, .access = Gfx::SE_DESCRIPTOR_ACCESS_WRITE_ONLY_BIT });
-    frustumLayout = graphics->createPipelineLayout();
+    dispatchParamsLayout->create();
+    frustumLayout = graphics->createPipelineLayout("FrustumLayout");
     frustumLayout->addDescriptorLayout(viewParamsLayout);
     frustumLayout->addDescriptorLayout(dispatchParamsLayout);
     Map<std::string, uint32> mapping;
diff --git a/src/Engine/Graphics/RenderPass/RenderPass.cpp b/src/Engine/Graphics/RenderPass/RenderPass.cpp
index 283cb7b..696d0a4 100644
--- a/src/Engine/Graphics/RenderPass/RenderPass.cpp
+++ b/src/Engine/Graphics/RenderPass/RenderPass.cpp
@@ -15,6 +15,7 @@ RenderPass::RenderPass(Gfx::PGraphics graphics, PScene scene)
             .data = (uint8*)&viewParams,
         },
         .dynamic = true,
+        .name = "viewParamsBuffer",
     };
     viewParamsBuffer = graphics->createUniformBuffer(uniformInitializer);
     viewParamsLayout->create();
diff --git a/src/Engine/Graphics/RenderPass/SkyboxRenderPass.cpp b/src/Engine/Graphics/RenderPass/SkyboxRenderPass.cpp
index db4b70c..b32a49b 100644
--- a/src/Engine/Graphics/RenderPass/SkyboxRenderPass.cpp
+++ b/src/Engine/Graphics/RenderPass/SkyboxRenderPass.cpp
@@ -122,7 +122,7 @@ void SkyboxRenderPass::createRenderPass()
     createInfo.entryPoint = "fragmentMain";
     fragmentShader = graphics->createFragmentShader(createInfo);
 
-    pipelineLayout = graphics->createPipelineLayout();
+    pipelineLayout = graphics->createPipelineLayout("SkyboxLayout");
     pipelineLayout->addDescriptorLayout(viewParamsLayout);
     pipelineLayout->addDescriptorLayout(skyboxDataLayout);
     pipelineLayout->addDescriptorLayout(textureLayout);
diff --git a/src/Engine/Graphics/Shader.cpp b/src/Engine/Graphics/Shader.cpp
index aa0838f..da5b592 100644
--- a/src/Engine/Graphics/Shader.cpp
+++ b/src/Engine/Graphics/Shader.cpp
@@ -77,7 +77,7 @@ void ShaderCompiler::compile()
 			{
 				for (const auto& [matName, mat] : materials)
 				{
-                    OPipelineLayout layout = graphics->createPipelineLayout(pass.baseLayout);
+                    OPipelineLayout layout = graphics->createPipelineLayout(pass.baseLayout->getName(), pass.baseLayout);
                     layout->addDescriptorLayout(vd->getVertexDataLayout());
                     layout->addDescriptorLayout(vd->getInstanceDataLayout());
                     layout->addDescriptorLayout(mat->getDescriptorLayout());
@@ -95,7 +95,7 @@ void ShaderCompiler::compile()
 			}
 			else
 			{
-                OPipelineLayout layout = graphics->createPipelineLayout(pass.baseLayout);
+                OPipelineLayout layout = graphics->createPipelineLayout(pass.baseLayout->getName(), pass.baseLayout);
                 layout->addDescriptorLayout(vd->getVertexDataLayout());
                 layout->addDescriptorLayout(vd->getInstanceDataLayout());
                 Map<std::string, uint32> mapping;
diff --git a/src/Engine/Graphics/StaticMeshVertexData.cpp b/src/Engine/Graphics/StaticMeshVertexData.cpp
index 8a22654..f1d3f4f 100644
--- a/src/Engine/Graphics/StaticMeshVertexData.cpp
+++ b/src/Engine/Graphics/StaticMeshVertexData.cpp
@@ -162,13 +162,19 @@ void StaticMeshVertexData::resizeBuffers()
         },
         .numElements = verticesAllocated * 3,
         .dynamic = true,
+        .name = "Positions",
     };
     positions = graphics->createShaderBuffer(createInfo);
+    createInfo.name = "Normals";
     normals = graphics->createShaderBuffer(createInfo);
+    createInfo.name = "Tangents";
     tangents = graphics->createShaderBuffer(createInfo);
+    createInfo.name = "BiTangents";
     biTangents = graphics->createShaderBuffer(createInfo);
+    createInfo.name = "Colors";
     colors = graphics->createShaderBuffer(createInfo);
     createInfo.sourceData.size = verticesAllocated * sizeof(Vector2);
+    createInfo.name = "TexCoords";
     createInfo.numElements = verticesAllocated * 2;
     texCoords = graphics->createShaderBuffer(createInfo);
     
diff --git a/src/Engine/Graphics/VertexData.cpp b/src/Engine/Graphics/VertexData.cpp
index 69df8fe..110c25d 100644
--- a/src/Engine/Graphics/VertexData.cpp
+++ b/src/Engine/Graphics/VertexData.cpp
@@ -108,6 +108,7 @@ void VertexData::createDescriptors()
                 },
                 .numElements = instanceData.size(),
                 .dynamic = false,
+                .name = "InstanceBuffer"
                 });
             matInst.instanceBuffer->pipelineBarrier(
                 Gfx::SE_ACCESS_TRANSFER_WRITE_BIT,
@@ -124,6 +125,7 @@ void VertexData::createDescriptors()
                 },
                 .numElements = meshes.size(),
                 .dynamic = false,
+                .name = "MeshDataBuffer"
             });
             matInst.meshDataBuffer->pipelineBarrier(
                 Gfx::SE_ACCESS_TRANSFER_WRITE_BIT,
@@ -162,7 +164,11 @@ void VertexData::loadMesh(MeshId id, Array<uint32> loadedIndices, Array<Meshlet>
             std::memcpy(vertexIndices.data() + vertexOffset, m.uniqueVertices, m.numVertices * sizeof(uint32));
             uint32 primitiveOffset = primitiveIndices.size();
             primitiveIndices.resize(primitiveOffset + (m.numPrimitives * 3));
-            std::memcpy(primitiveIndices.data() + primitiveOffset, m.primitiveLayout, m.numPrimitives * 3 * sizeof(uint8));
+            for(size_t x = 0; x < m.numPrimitives*3; ++x)
+            {
+                primitiveIndices[primitiveOffset + x] = m.primitiveLayout[x];
+            }
+            //std::memcpy(primitiveIndices.data() + primitiveOffset, m.primitiveLayout, m.numPrimitives * 3 * sizeof(uint8));
             meshlets.add(MeshletDescription{
                 .bounding = m.boundingBox.toSphere(),
                 .vertexCount = m.numVertices,
@@ -190,6 +196,7 @@ void VertexData::loadMesh(MeshId id, Array<uint32> loadedIndices, Array<Meshlet>
             .data = (uint8*)indices.data(),
         },
         .indexType = Gfx::SE_INDEX_TYPE_UINT32,
+        .name = "IndexBuffer",
     });
     meshletBuffer = graphics->createShaderBuffer(ShaderBufferCreateInfo{
         .sourceData = {
@@ -198,6 +205,7 @@ void VertexData::loadMesh(MeshId id, Array<uint32> loadedIndices, Array<Meshlet>
         },
         .numElements = meshlets.size(),
         .dynamic = false,
+        .name = "MeshletBuffer"
     });
     vertexIndicesBuffer = graphics->createShaderBuffer(ShaderBufferCreateInfo{
         .sourceData = {
@@ -206,14 +214,16 @@ void VertexData::loadMesh(MeshId id, Array<uint32> loadedIndices, Array<Meshlet>
         },
         .numElements = vertexIndices.size(),
         .dynamic = false,
+        .name = "VertexIndicesBuffer"
     });
     primitiveIndicesBuffer = graphics->createShaderBuffer(ShaderBufferCreateInfo{
         .sourceData = {
-            .size = sizeof(uint8) * primitiveIndices.size(),
+            .size = sizeof(uint32) * primitiveIndices.size(),
             .data = (uint8*)primitiveIndices.data(),
         },
         .numElements = primitiveIndices.size(),
         .dynamic = false,
+        .name = "PrimitiveIndicesBuffer",
     });
 }
 
diff --git a/src/Engine/Graphics/Vulkan/Graphics.h b/src/Engine/Graphics/Vulkan/Graphics.h
index efb15b0..2f2e507 100644
--- a/src/Engine/Graphics/Vulkan/Graphics.h
+++ b/src/Engine/Graphics/Vulkan/Graphics.h
@@ -64,7 +64,7 @@ public:
     virtual Gfx::OSampler createSampler(const SamplerCreateInfo& createInfo) override;
 
     virtual Gfx::ODescriptorLayout createDescriptorLayout(const std::string& name = "") override;
-    virtual Gfx::OPipelineLayout createPipelineLayout(Gfx::PPipelineLayout baseLayout = nullptr) override;
+    virtual Gfx::OPipelineLayout createPipelineLayout(const std::string& name = "", Gfx::PPipelineLayout baseLayout = nullptr) override;
 
     virtual Gfx::OVertexInput createVertexInput(VertexInputStateCreateInfo createInfo) override;
 
@@ -109,4 +109,4 @@ protected:
 };
 DEFINE_REF(Graphics)
 } // namespace Vulkan
-} // namespace Seele
\ No newline at end of file
+} // namespace Seele
diff --git a/src/Engine/Graphics/slang-compile.cpp b/src/Engine/Graphics/slang-compile.cpp
index add3bd3..0164610 100644
--- a/src/Engine/Graphics/slang-compile.cpp
+++ b/src/Engine/Graphics/slang-compile.cpp
@@ -28,11 +28,11 @@ Slang::ComPtr<slang::IBlob> Seele::generateShader(const ShaderCreateInfo& create
     }
     sessionDesc.preprocessorMacroCount = macros.size();
     sessionDesc.preprocessorMacros = macros.data();
-    slang::TargetDesc vulkan;
-    vulkan.profile = globalSession->findProfile("sm_6_6");
-    vulkan.format = target;
+    slang::TargetDesc targetDesc;
+    targetDesc.profile = globalSession->findProfile("sm_6_6");
+    targetDesc.format = target;
     sessionDesc.targetCount = 1;
-    sessionDesc.targets = &vulkan;
+    sessionDesc.targets = &targetDesc;
     StaticArray<const char*, 3> searchPaths = {"shaders/", "shaders/lib/", "shaders/generated/"};
     sessionDesc.searchPaths = searchPaths.data();
     sessionDesc.searchPathCount = searchPaths.size();
@@ -92,11 +92,14 @@ Slang::ComPtr<slang::IBlob> Seele::generateShader(const ShaderCreateInfo& create
     slang::ProgramLayout* signature = specializedComponent->getLayout(0, diagnostics.writeRef());
     CHECK_DIAGNOSTICS();
     auto entry = signature->findEntryPointByName(createInfo.entryPoint.c_str());
+    uint32 offset = 0;
+    if(target == SLANG_DXIL)
+    {
+      offset = 1;// idk why
+    }
     for(size_t i = 0; i < signature->getParameterCount(); ++i)
     {
-        auto param = signature->getParameterByIndex(i);
-        paramMapping[param->getName()] = param->getBindingIndex();
-        std::cout << param->getName() << " " << param->getBindingIndex() << " " << param->getSemanticIndex() << std::endl;
+        paramMapping[param->getName()] = offset++;
     }
     return kernelBlob;
 }