Startet to terribly implement a list

src/Engine/Graphics/Vulkan/CMakeLists.txt

@@ -1,9 +1,12 @@
 target_sources(SeeleEngine
 	PRIVATE
+		VulkanAllocator.h
+		VulkanAllocator.cpp
 		VulkanGraphics.h
 		VulkanGraphics.cpp
 		VulkanGraphicsResources.h
 		VulkanDescriptorSets.cpp
 		VulkanGraphicsEnums.h
+		VulkanGraphicsEnums.cpp
 		VulkanInitializer.h
 		VulkanInitializer.cpp)

src/Engine/Graphics/Vulkan/VulkanAllocator.cpp

@@ -0,0 +1,26 @@
+#include "VulkanAllocator.h"
+#include "VulkanGraphics.h"
+Seele::VulkanAllocator::VulkanAllocator(PVulkanGraphics graphics)
+	: graphics(graphics)
+{
+	vkGetPhysicalDeviceMemoryProperties(graphics->getPhysicalDevice(), &memProperties);
+	heaps.resize(memProperties.memoryHeapCount);
+	for (size_t i = 0; i < memProperties.memoryHeapCount; i++)
+	{
+		std::cout << "Heap: Flags: " << memProperties.memoryHeaps[i].flags << " Size: " << memProperties.memoryHeaps[i].size << std::endl;
+	}
+	for (size_t i = 0; i < memProperties.memoryTypeCount; i++)
+	{
+		VkMemoryType& type = memProperties.memoryTypes[i];
+		std::cout << "Memory Type: Properties" << type.propertyFlags << " on Index: " << type.heapIndex << std::endl;
+	}
+}
+
+Seele::VulkanAllocator::~VulkanAllocator()
+{
+}
+
+Seele::PVulkanSubAllocation Seele::VulkanAllocator::allocate(uint64 size, VkMemoryPropertyFlags properties)
+{
+	return PVulkanSubAllocation();
+}

src/Engine/Graphics/Vulkan/VulkanAllocator.h

@@ -0,0 +1,43 @@
+#pragma once
+#include "MinimalEngine.h"
+#include "VulkanGraphicsEnums.h"
+#include "Containers/Map.h"
+#include "Containers/Array.h"
+
+namespace Seele
+{
+	DECLARE_REF(VulkanGraphics);
+	class VulkanSubAllocation
+	{
+
+	};
+	DEFINE_REF(VulkanSubAllocation);
+	class VulkanAllocation
+	{
+	private:
+		VkDeviceMemory allocatedMemory;
+		VkDeviceSize bytesAllocated;
+		VkDeviceSize bytesUsed;
+		uint8 isDedicated;
+	};
+	DEFINE_REF(VulkanAllocation);
+
+	class VulkanAllocator
+	{
+	public:
+		VulkanAllocator(PVulkanGraphics graphics);
+		~VulkanAllocator();
+		PVulkanSubAllocation allocate(uint64 size, VkMemoryPropertyFlags properties);
+	private:
+		struct HeapInfo
+		{
+			uint32 maxSize = 0;
+			Array<VulkanAllocation> allocations;
+			Array<VkMemoryType> types;
+		};
+		Array<HeapInfo> heaps;
+		PVulkanGraphics graphics;
+		VkPhysicalDeviceMemoryProperties memProperties;
+	};
+	DEFINE_REF(VulkanAllocator);
+}

src/Engine/Graphics/Vulkan/VulkanDescriptorSets.cpp

@@ -2,7 +2,6 @@
 #include "VulkanGraphicsEnums.h"
 #include "VulkanGraphics.h"
 #include "VulkanInitializer.h"
-#include <iostream>
 
 Seele::VulkanDescriptorLayout::~VulkanDescriptorLayout()
 {
@@ -36,6 +35,14 @@ void Seele::VulkanDescriptorLayout::create()
 	allocator = new VulkanDescriptorAllocator(graphics, *this);
 }
 
+Seele::VulkanPipelineLayout::~VulkanPipelineLayout()
+{
+	if (layoutHandle != VK_NULL_HANDLE)
+	{
+		vkDestroyPipelineLayout(graphics->getDevice(), layoutHandle, nullptr);
+	}
+}
+
 void Seele::VulkanPipelineLayout::create()
 {
 	vulkanDescriptorLayouts.resize(descriptorSetLayouts.size());
@@ -52,8 +59,131 @@ void Seele::VulkanPipelineLayout::create()
 	{
 		vkPushConstants[i].offset = pushConstants[i].offset;
 		vkPushConstants[i].size = pushConstants[i].size;
-		vkPushConstants[i].stageFlags = pushConstants[i].stageFlags;
+		vkPushConstants[i].stageFlags = cast((VkShaderStageFlagBits)pushConstants[i].stageFlags);
 	}
 	createInfo.pushConstantRangeCount = vkPushConstants.size();
 	createInfo.pPushConstantRanges = vkPushConstants.data();
-}
+	VK_CHECK(vkCreatePipelineLayout(graphics->getDevice(), &createInfo, nullptr, &layoutHandle));
+
+	layoutHash = memCrc32(&createInfo, sizeof(VkPipelineLayoutCreateInfo), 0);
+}
+
+Seele::VulkanDescriptorSet::~VulkanDescriptorSet()
+{
+}
+
+void Seele::VulkanDescriptorSet::updateBuffer(uint32_t binding, PUniformBuffer uniformBuffer)
+{
+	PVulkanUniformBuffer vulkanBuffer = uniformBuffer.cast<VulkanUniformBuffer>();
+//	VkDescriptorBufferInfo bufferInfo = init::DescriptorBufferInfo(vulkanBuffer->getHandle(), vulkanBuffer->getOffset(), vulkanBuffer->getSize());
+//	bufferInfos.add(bufferInfo);
+
+	VkWriteDescriptorSet writeDescriptor = init::WriteDescriptorSet(setHandle, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, binding, &bufferInfos.back());
+	writeDescriptors.add(writeDescriptor);
+}
+
+void Seele::VulkanDescriptorSet::updateBuffer(uint32_t binding, PStructuredBuffer uniformBuffer)
+{
+	PVulkanStructuredBuffer vulkanBuffer = uniformBuffer.cast<VulkanStructuredBuffer>();
+//	VkDescriptorBufferInfo bufferInfo = init::DescriptorBufferInfo(vulkanBuffer->getHandle(), vulkanBuffer->getOffset(), vulkanBuffer->getSize());
+//	bufferInfos.add(bufferInfo);
+
+	VkWriteDescriptorSet writeDescriptor = init::WriteDescriptorSet(setHandle, VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, binding, &bufferInfos.back());
+	writeDescriptors.add(writeDescriptor);
+}
+
+void Seele::VulkanDescriptorSet::updateSampler(uint32_t binding, PSamplerState samplerState)
+{
+	PVulkanSamplerState vulkanSampler = samplerState.cast<VulkanSamplerState>();
+	VkDescriptorImageInfo imageInfo =
+		init::DescriptorImageInfo(
+			vulkanSampler->sampler,
+			VK_NULL_HANDLE,
+			VK_IMAGE_LAYOUT_BEGIN_RANGE);
+	imageInfos.add(imageInfo);
+
+	VkWriteDescriptorSet writeDescriptor = init::WriteDescriptorSet(setHandle, VK_DESCRIPTOR_TYPE_SAMPLER, binding, &imageInfos.back());
+	writeDescriptors.add(writeDescriptor);
+}
+
+void Seele::VulkanDescriptorSet::updateTexture(uint32_t binding, PTexture texture, PSamplerState samplerState)
+{
+//	VulkanTextureBase* vulkanTexture = VulkanTextureBase::cast(texture);
+	//It is assumed that the image is in the correct layout
+//	VkDescriptorImageInfo imageInfo =
+//		init::DescriptorImageInfo(
+//			VK_NULL_HANDLE,
+//			vulkanTexture->defaultView.view,
+//			graphics->getRHIDevice().findLayout(vulkanTexture->surface.image));
+	if (samplerState != nullptr)
+	{
+//		PVulkanSamplerState vulkanSampler = samplerState.cast<VulkanSamplerState>();
+//		imageInfo.sampler = vulkanSampler->sampler;
+	}
+//	imageInfos.add(imageInfo);
+	VkWriteDescriptorSet writeDescriptor = init::WriteDescriptorSet(setHandle, samplerState != nullptr ? VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER : VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE, binding, &imageInfos.back());
+//	if (vulkanTexture->surface.usageFlags & TexCreate_UAV)
+	{
+//		writeDescriptor.descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_IMAGE;
+	}
+	writeDescriptors.add(writeDescriptor);
+}
+
+bool Seele::VulkanDescriptorSet::operator<(PDescriptorSet other)
+{
+	PVulkanDescriptorSet otherSet = other.cast<VulkanDescriptorSet>();
+	return setHandle < otherSet->setHandle;
+}
+
+void Seele::VulkanDescriptorSet::writeChanges()
+{
+	if (writeDescriptors.size() > 0)
+	{
+		vkUpdateDescriptorSets(graphics->getDevice(), writeDescriptors.size(), writeDescriptors.data(), 0, nullptr);
+		writeDescriptors.clear();
+		imageInfos.clear();
+		bufferInfos.clear();
+	}
+}
+
+Seele::VulkanDescriptorAllocator::VulkanDescriptorAllocator(PVulkanGraphics graphics, VulkanDescriptorLayout& layout)
+	: layout(layout)
+	, graphics(graphics)
+{
+	uint32 perTypeSizes[VK_DESCRIPTOR_TYPE_END_RANGE];
+	std::memset(perTypeSizes, 0, sizeof(perTypeSizes));
+	for (int i = 0; i < layout.getBindings().size(); ++i)
+	{
+		auto& binding = layout.getBindings()[i];
+		int typeIndex = binding.descriptorType;
+		perTypeSizes[typeIndex] += 256;
+	}
+	Array<VkDescriptorPoolSize> poolSizes;
+	for (int i = 0; i < VK_DESCRIPTOR_TYPE_END_RANGE; ++i)
+	{
+		if (perTypeSizes[i] > 0)
+		{
+			VkDescriptorPoolSize size;
+			size.descriptorCount = perTypeSizes[i];
+			size.type = (VkDescriptorType)i;
+			poolSizes.add(size);
+		}
+	}
+	VkDescriptorPoolCreateInfo createInfo = init::DescriptorPoolCreateInfo(poolSizes.size(), poolSizes.data(), maxSets);
+	VK_CHECK(vkCreateDescriptorPool(graphics->getDevice(), &createInfo, nullptr, &poolHandle));
+}
+
+Seele::VulkanDescriptorAllocator::~VulkanDescriptorAllocator()
+{
+	vkDestroyDescriptorPool(graphics->getDevice(), poolHandle, nullptr);
+}
+
+void Seele::VulkanDescriptorAllocator::allocateDescriptorSet(PDescriptorSet& descriptorSet)
+{
+	descriptorSet = new VulkanDescriptorSet(graphics, this);
+	PVulkanDescriptorSet vulkanSet = descriptorSet.cast<VulkanDescriptorSet>();
+	VkDescriptorSetLayout layoutHandle = layout.getHandle();
+	VkDescriptorSetAllocateInfo allocInfo =
+		init::DescriptorSetAllocateInfo(poolHandle, &layoutHandle, 1);
+	VK_CHECK(vkAllocateDescriptorSets(graphics->getDevice(), &allocInfo, &vulkanSet->setHandle));
+}

src/Engine/Graphics/Vulkan/VulkanGraphics.cpp

@@ -1,8 +1,38 @@
 #include "VulkanGraphics.h"
+#include "VulkanAllocator.h"
+#include "Containers/Array.h"
+#include "VulkanInitializer.h"
 #include <GLFW/glfw3.h>
 
-void Seele::VulkanGraphics::init(GraphicsInitializer initializer)
+void Seele::VulkanGraphics::init(GraphicsInitializer initInfo)
 {
+	VkApplicationInfo appInfo = {};
+	appInfo.sType = VK_STRUCTURE_TYPE_APPLICATION_INFO;
+	appInfo.pApplicationName = initInfo.applicationName;
+	appInfo.applicationVersion = VK_MAKE_VERSION(0, 0, 1);
+	appInfo.pEngineName = initInfo.engineName;
+	appInfo.engineVersion = VK_MAKE_VERSION(0, 0, 1);
+	appInfo.apiVersion = VK_API_VERSION_1_1;
+
+	VkInstanceCreateInfo info = {};
+	info.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO;
+	info.pApplicationInfo = &appInfo;
+	Array<const char*> extensions = getRequiredExtensions();
+	for (uint32 i = 0; i < initInfo.instanceExtensions.size(); ++i)
+	{
+		extensions.add(initInfo.instanceExtensions[i]);
+	}
+	info.enabledExtensionCount = (uint32)extensions.size();
+	info.ppEnabledExtensionNames = extensions.data();
+#ifdef ENABLE_VALIDATION
+	info.enabledLayerCount = (uint32)initInfo.layers.size();
+	info.ppEnabledLayerNames = initInfo.layers.data();
+#else
+	info.enabledLayerCount = 0;
+#endif
+	VK_CHECK(vkCreateInstance(&info, nullptr, &instance));
+	setupDebugCallback();
+	allocator = new VulkanAllocator(this);
 }
 
 void Seele::VulkanGraphics::beginFrame(void* windowHandle)
@@ -14,7 +44,6 @@ void Seele::VulkanGraphics::beginFrame(void* windowHandle)
 void Seele::VulkanGraphics::endFrame(void* windowHandle)
 {
 	GLFWwindow* window = static_cast<GLFWwindow*>(windowHandle);
-	
 }
 
 void* Seele::VulkanGraphics::createWindow(const WindowCreateInfo& createInfo)
@@ -33,3 +62,37 @@ Seele::VulkanGraphics::~VulkanGraphics()
 {
 	glfwTerminate();
 }
+
+VkDevice Seele::VulkanGraphics::getDevice() const
+{
+	return handle;
+}
+
+VkPhysicalDevice Seele::VulkanGraphics::getPhysicalDevice() const
+{
+	return physicalDevice;
+}
+
+Seele::Array<const char*> Seele::VulkanGraphics::getRequiredExtensions()
+{
+	Array<const char*> extensions;
+
+	unsigned int glfwExtensionCount = 0;
+	const char** glfwExtensions = glfwGetRequiredInstanceExtensions(&glfwExtensionCount);
+
+	for (unsigned int i = 0; i < glfwExtensionCount; i++) {
+		extensions.add(glfwExtensions[i]);
+	}
+#ifdef ENABLE_VALIDATION
+	extensions.add(VK_EXT_DEBUG_REPORT_EXTENSION_NAME);
+#endif // ENABLE_VALIDATION
+	return extensions;
+}
+void Seele::VulkanGraphics::setupDebugCallback()
+{
+	VkDebugReportCallbackCreateInfoEXT createInfo =
+		init::DebugReportCallbackCreateInfo(
+			VK_DEBUG_REPORT_ERROR_BIT_EXT | VK_DEBUG_REPORT_WARNING_BIT_EXT | VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT);
+
+	VK_CHECK(CreateDebugReportCallbackEXT(instance, &createInfo, nullptr, &callback));
+}

src/Engine/Graphics/Vulkan/VulkanGraphics.h

@@ -1,11 +1,16 @@
 #include "Graphics/Graphics.h"
+#include "VulkanGraphicsResources.h"
 
 namespace Seele
 {
+	DECLARE_REF(VulkanAllocator);
 	class VulkanGraphics : public Graphics
 	{
 	public:
+		VulkanGraphics();
+		virtual ~VulkanGraphics();
 		VkDevice getDevice() const;
+		VkPhysicalDevice getPhysicalDevice() const;
 
 		// Inherited via Graphics
 		virtual void init(GraphicsInitializer initializer) override;
@@ -13,8 +18,15 @@ namespace Seele
 		virtual void endFrame(void* windowHandle) override;
 		virtual void* createWindow(const WindowCreateInfo& createInfo) override;
 	protected:
-		VulkanGraphics();
-		virtual ~VulkanGraphics();
+		Array<const char*> getRequiredExtensions();
+		void setupDebugCallback();
+
+		VkDevice handle;
+		VkPhysicalDevice physicalDevice;
+		VkInstance instance;
+		VkDebugReportCallbackEXT callback;
+		PVulkanAllocator allocator;
 		friend class Window;
 	};
+	DEFINE_REF(VulkanGraphics);
 }

src/Engine/Graphics/Vulkan/VulkanGraphicsEnums.cpp

@@ -0,0 +1,157 @@
+#include "VulkanGraphicsEnums.h"
+
+using namespace Seele;
+
+VkDescriptorType Seele::cast(const SeDescriptorType& descriptorType)
+{
+	switch (descriptorType)
+	{
+	case SE_DESCRIPTOR_TYPE_SAMPLER:
+		return VK_DESCRIPTOR_TYPE_SAMPLER;
+	case SE_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER:
+		return VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER;
+	case SE_DESCRIPTOR_TYPE_SAMPLED_IMAGE:
+		return VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE;
+	case SE_DESCRIPTOR_TYPE_STORAGE_IMAGE:
+		return VK_DESCRIPTOR_TYPE_STORAGE_IMAGE;
+	case SE_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER:
+		return VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER;
+	case SE_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER:
+		return VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER;
+	case SE_DESCRIPTOR_TYPE_UNIFORM_BUFFER:
+		return VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER;
+	case SE_DESCRIPTOR_TYPE_STORAGE_BUFFER:
+		return VK_DESCRIPTOR_TYPE_STORAGE_BUFFER;
+	case SE_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC:
+		return VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC;
+	case SE_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC:
+		return VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC;
+	case SE_DESCRIPTOR_TYPE_INPUT_ATTACHMENT:
+		return VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT;
+	case SE_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK_EXT:
+		return VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK_EXT;
+	case SE_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_NV:
+		return VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_NV;
+	default:
+		break;
+	}
+}
+
+SeDescriptorType Seele::cast(const VkDescriptorType& descriptorType)
+{
+	switch (descriptorType)
+	{
+
+	case VK_DESCRIPTOR_TYPE_SAMPLER:
+		return SE_DESCRIPTOR_TYPE_SAMPLER;
+	case VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER:
+		return SE_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER;
+	case VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE:
+		return SE_DESCRIPTOR_TYPE_SAMPLED_IMAGE;
+	case VK_DESCRIPTOR_TYPE_STORAGE_IMAGE:
+		return SE_DESCRIPTOR_TYPE_STORAGE_IMAGE;
+	case VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER:
+		return SE_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER;
+	case VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER:
+		return SE_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER;
+	case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER:
+		return SE_DESCRIPTOR_TYPE_UNIFORM_BUFFER;
+	case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER:
+		return SE_DESCRIPTOR_TYPE_STORAGE_BUFFER;
+	case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC:
+		return SE_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC;
+	case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC:
+		return SE_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC;
+	case VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT:
+		return SE_DESCRIPTOR_TYPE_INPUT_ATTACHMENT;
+	case VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK_EXT:
+		return SE_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK_EXT;
+	case VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_NV:
+		return SE_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_NV;
+	default:
+		break;
+	}
+}
+
+VkShaderStageFlagBits Seele::cast(const SeShaderStageFlagBits& stage)
+{
+	switch (stage)
+	{
+
+	case SE_SHADER_STAGE_VERTEX_BIT:
+		return VK_SHADER_STAGE_VERTEX_BIT;
+	case SE_SHADER_STAGE_TESSELLATION_CONTROL_BIT:
+		return VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT;
+	case SE_SHADER_STAGE_TESSELLATION_EVALUATION_BIT:
+		return VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT;
+	case SE_SHADER_STAGE_GEOMETRY_BIT:
+		return VK_SHADER_STAGE_GEOMETRY_BIT;
+	case SE_SHADER_STAGE_FRAGMENT_BIT:
+		return VK_SHADER_STAGE_FRAGMENT_BIT;
+	case SE_SHADER_STAGE_COMPUTE_BIT:
+		return VK_SHADER_STAGE_COMPUTE_BIT;
+	case SE_SHADER_STAGE_ALL_GRAPHICS:
+		return VK_SHADER_STAGE_ALL_GRAPHICS;
+	case SE_SHADER_STAGE_ALL:
+		return VK_SHADER_STAGE_ALL;
+	case SE_SHADER_STAGE_RAYGEN_BIT_NV:
+		return VK_SHADER_STAGE_RAYGEN_BIT_NV;
+	case SE_SHADER_STAGE_ANY_HIT_BIT_NV:
+		return VK_SHADER_STAGE_ANY_HIT_BIT_NV;
+	case SE_SHADER_STAGE_CLOSEST_HIT_BIT_NV:
+		return VK_SHADER_STAGE_CLOSEST_HIT_BIT_NV;
+	case SE_SHADER_STAGE_MISS_BIT_NV:
+		return VK_SHADER_STAGE_MISS_BIT_NV;
+	case SE_SHADER_STAGE_INTERSECTION_BIT_NV:
+		return VK_SHADER_STAGE_INTERSECTION_BIT_NV;
+	case SE_SHADER_STAGE_CALLABLE_BIT_NV:
+		return VK_SHADER_STAGE_CALLABLE_BIT_NV;
+	case SE_SHADER_STAGE_TASK_BIT_NV:
+		return VK_SHADER_STAGE_TASK_BIT_NV;
+	case SE_SHADER_STAGE_MESH_BIT_NV:
+		return VK_SHADER_STAGE_MESH_BIT_NV;
+	default:
+		break;
+	}
+}
+
+SeShaderStageFlagBits Seele::cast(const VkShaderStageFlagBits& stage)
+{
+	switch (stage)
+	{
+	case VK_SHADER_STAGE_VERTEX_BIT:
+		return SE_SHADER_STAGE_VERTEX_BIT;
+	case VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT:
+		return SE_SHADER_STAGE_TESSELLATION_CONTROL_BIT;
+	case VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT:
+		return SE_SHADER_STAGE_TESSELLATION_EVALUATION_BIT;
+	case VK_SHADER_STAGE_GEOMETRY_BIT:
+		return SE_SHADER_STAGE_GEOMETRY_BIT;
+	case VK_SHADER_STAGE_FRAGMENT_BIT:
+		return SE_SHADER_STAGE_FRAGMENT_BIT;
+	case VK_SHADER_STAGE_COMPUTE_BIT:
+		return SE_SHADER_STAGE_COMPUTE_BIT;
+	case VK_SHADER_STAGE_ALL_GRAPHICS:
+		return SE_SHADER_STAGE_ALL_GRAPHICS;
+	case VK_SHADER_STAGE_ALL:
+		return SE_SHADER_STAGE_ALL;
+	case VK_SHADER_STAGE_RAYGEN_BIT_NV:
+		return SE_SHADER_STAGE_RAYGEN_BIT_NV;
+	case VK_SHADER_STAGE_ANY_HIT_BIT_NV:
+		return SE_SHADER_STAGE_ANY_HIT_BIT_NV;
+	case VK_SHADER_STAGE_CLOSEST_HIT_BIT_NV:
+		return SE_SHADER_STAGE_CLOSEST_HIT_BIT_NV;
+	case VK_SHADER_STAGE_MISS_BIT_NV:
+		return SE_SHADER_STAGE_MISS_BIT_NV;
+	case VK_SHADER_STAGE_INTERSECTION_BIT_NV:
+		return SE_SHADER_STAGE_INTERSECTION_BIT_NV;
+	case VK_SHADER_STAGE_CALLABLE_BIT_NV:
+		return SE_SHADER_STAGE_CALLABLE_BIT_NV;
+	case VK_SHADER_STAGE_TASK_BIT_NV:
+		return SE_SHADER_STAGE_TASK_BIT_NV;
+	case VK_SHADER_STAGE_MESH_BIT_NV:
+		return SE_SHADER_STAGE_MESH_BIT_NV;
+	default:
+		break;
+	}
+}

src/Engine/Graphics/Vulkan/VulkanGraphicsEnums.h

@@ -14,74 +14,8 @@
 
 namespace Seele
 {
-	VkDescriptorType cast(const SeDescriptorType& descriptorType)
-	{
-		switch (descriptorType)
-		{
-		case SE_DESCRIPTOR_TYPE_SAMPLER:
-			return VK_DESCRIPTOR_TYPE_SAMPLER;
-		case SE_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER:
-			return VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER;
-		case SE_DESCRIPTOR_TYPE_SAMPLED_IMAGE:
-			return VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE;
-		case SE_DESCRIPTOR_TYPE_STORAGE_IMAGE:
-			return VK_DESCRIPTOR_TYPE_STORAGE_IMAGE;
-		case SE_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER:
-			return VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER;
-		case SE_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER:
-			return VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER;
-		case SE_DESCRIPTOR_TYPE_UNIFORM_BUFFER:
-			return VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER;
-		case SE_DESCRIPTOR_TYPE_STORAGE_BUFFER:
-			return VK_DESCRIPTOR_TYPE_STORAGE_BUFFER;
-		case SE_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC:
-			return VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC;
-		case SE_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC:
-			return VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC;
-		case SE_DESCRIPTOR_TYPE_INPUT_ATTACHMENT:
-			return VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT;
-		case SE_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK_EXT:
-			return VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK_EXT;
-		case SE_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_NV:
-			return VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_NV;
-		default:
-			break;
-		}
-	}
-	SeDescriptorType cast(const VkDescriptorType& descriptorType)
-	{
-		switch (descriptorType)
-		{
-
-		case VK_DESCRIPTOR_TYPE_SAMPLER:
-			return SE_DESCRIPTOR_TYPE_SAMPLER;
-		case VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER:
-			return SE_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER;
-		case VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE:
-			return SE_DESCRIPTOR_TYPE_SAMPLED_IMAGE;
-		case VK_DESCRIPTOR_TYPE_STORAGE_IMAGE:
-			return SE_DESCRIPTOR_TYPE_STORAGE_IMAGE;
-		case VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER:
-			return SE_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER;
-		case VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER:
-			return SE_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER;
-		case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER:
-			return SE_DESCRIPTOR_TYPE_UNIFORM_BUFFER;
-		case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER:
-			return SE_DESCRIPTOR_TYPE_STORAGE_BUFFER;
-		case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC:
-			return SE_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC;
-		case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC:
-			return SE_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC;
-		case VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT:
-			return SE_DESCRIPTOR_TYPE_INPUT_ATTACHMENT;
-		case VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK_EXT:
-			return SE_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK_EXT;
-		case VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_NV:
-			return SE_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_NV;
-		default:
-			break;
-		}
-	}
-
+	VkDescriptorType cast(const SeDescriptorType& descriptorType);
+	SeDescriptorType cast(const VkDescriptorType& descriptorType);
+	VkShaderStageFlagBits cast(const SeShaderStageFlagBits& stage);
+	SeShaderStageFlagBits cast(const VkShaderStageFlagBits& stage);
 }

src/Engine/Graphics/Vulkan/VulkanGraphicsResources.h

@@ -1,5 +1,6 @@
 #pragma once
 #include "Graphics/GraphicsResources.h"
+#include <vulkan/vulkan.h>
 
 namespace Seele
 {
@@ -30,19 +31,16 @@ namespace Seele
 		VulkanPipelineLayout(PVulkanGraphics graphics)
 			: graphics(graphics)
 		{}
-		virtual ~VulkanPipelineLayout()
-		{
-			if (layoutHandle != VK_NULL_HANDLE)
-			{
-				vkDestroyPipelineLayout(graphics->getDevice(), layoutHandle, nullptr);
-			}
-		}
+		virtual ~VulkanPipelineLayout();
 		virtual void create();
 		inline VkPipelineLayout getHandle() const
 		{
 			return layoutHandle;
 		}
-		virtual uint32 getHash() const;
+		virtual uint32 getHash() const
+		{
+			return layoutHash;
+		}
 	private:
 		Array<VkDescriptorSetLayout> vulkanDescriptorLayouts;
 		uint32 layoutHash;
@@ -55,7 +53,7 @@ namespace Seele
 	class VulkanDescriptorSet : public DescriptorSet
 	{
 	public:
-		VulkanDescriptorSet(PVulkanGraphics device, PVulkanDescriptorAllocator owner) : device(device), owner(owner) {}
+		VulkanDescriptorSet(PVulkanGraphics graphics, PVulkanDescriptorAllocator owner) : graphics(graphics), owner(owner) {}
 		virtual ~VulkanDescriptorSet();
 		virtual void updateBuffer(uint32_t binding, PUniformBuffer uniformBuffer);
 		virtual void updateBuffer(uint32_t binding, PStructuredBuffer uniformBuffer);
@@ -73,7 +71,7 @@ namespace Seele
 		Array<VkWriteDescriptorSet> writeDescriptors;
 		VkDescriptorSet setHandle;
 		PVulkanDescriptorAllocator owner;
-		PVulkanGraphics device;
+		PVulkanGraphics graphics;
 		friend class VulkanDescriptorAllocator;
 	};
 	DEFINE_REF(VulkanDescriptorSet);
@@ -81,7 +79,7 @@ namespace Seele
 	class VulkanDescriptorAllocator : public DescriptorAllocator
 	{
 	public:
-		VulkanDescriptorAllocator(PVulkanGraphics device, VulkanDescriptorLayout& layout);
+		VulkanDescriptorAllocator(PVulkanGraphics graphics, VulkanDescriptorLayout& layout);
 		~VulkanDescriptorAllocator();
 		virtual void allocateDescriptorSet(PDescriptorSet& descriptorSet);
 
@@ -90,10 +88,48 @@ namespace Seele
 			return poolHandle;
 		}
 	private:
-		PVulkanGraphics device;
+		PVulkanGraphics graphics;
 		int maxSets = 512;
 		VkDescriptorPool poolHandle;
 		VulkanDescriptorLayout& layout;
 	};
 	DEFINE_REF(VulkanDescriptorAllocator);
+
+	class VulkanUniformBuffer : public UniformBuffer
+	{
+
+	};
+	DEFINE_REF(VulkanUniformBuffer);
+
+	class VulkanStructuredBuffer : public StructuredBuffer
+	{
+
+	};
+	DEFINE_REF(VulkanStructuredBuffer);
+
+	class VulkanTextureBase
+	{
+	private:
+		uint32 sizeX;
+		uint32 sizeY;
+		uint32 sizeZ;
+		uint32 arrayCount;
+		uint32 layerCount;
+	};
+	DEFINE_REF(VulkanTextureBase);
+
+	class VulkanTexture2D : public Texture2D
+	{
+	public:
+	private:
+		PVulkanTextureBase textureHandle;
+	};
+	DEFINE_REF(VulkanTexture2D);
+
+	class VulkanSamplerState
+	{
+	public:
+		VkSampler sampler;
+	};
+	DEFINE_REF(VulkanSamplerState);
 }

src/Engine/Graphics/Vulkan/VulkanInitializer.cpp

@@ -1,5 +1,4 @@
 #include "VulkanInitializer.h"
-#include <iostream>
 
 VkApplicationInfo Seele::init::ApplicationInfo(const char* appName, uint32_t appVersion, const char* engineName, uint32_t engineVersion, uint32_t apiVersion)
 {