Textures Working

Arcane/src/Arcane/Platform/Vulkan/VulkanDescriptorSet.cpp

@@ -75,4 +75,96 @@ namespace Arcane
 			vkUpdateDescriptorSets(logicalDevice, 1, &descriptorWrite, 0, nullptr);
 		}
 	}
+
+	VulkanDescriptorSet::VulkanDescriptorSet(std::vector<VkBuffer> uniformBuffers, uint32_t size, VulkanTexture* texture)
+	{
+		Application& app = Application::Get();
+		VulkanContext* context = static_cast<VulkanContext*>(Application::Get().GetWindow().GetContext());
+		VkDevice logicalDevice = static_cast<VulkanContext*>(app.GetWindow().GetContext())->GetDevice().GetLogicalDevice();
+		VulkanSwapChain& swapchain = context->GetSwapChain();
+
+		VkDescriptorSetLayoutBinding uboBinding{};
+		uboBinding.binding = 0;
+		uboBinding.descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER;
+		uboBinding.descriptorCount = 1;
+		uboBinding.stageFlags = VK_SHADER_STAGE_FRAGMENT_BIT;
+		uboBinding.pImmutableSamplers = nullptr;
+
+		VkDescriptorSetLayoutBinding samplerLayoutBinding{};
+		samplerLayoutBinding.binding = 1;
+		samplerLayoutBinding.descriptorCount = 1;
+		samplerLayoutBinding.descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER;
+		samplerLayoutBinding.pImmutableSamplers = nullptr;
+		samplerLayoutBinding.stageFlags = VK_SHADER_STAGE_FRAGMENT_BIT;
+
+		std::array<VkDescriptorSetLayoutBinding, 2> bindings = {uboBinding, samplerLayoutBinding};
+
+		VkDescriptorSetLayoutCreateInfo layoutInfo{};
+		layoutInfo.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO;
+		layoutInfo.bindingCount = static_cast<uint32_t>(bindings.size());
+		layoutInfo.pBindings = bindings.data();
+
+		if (vkCreateDescriptorSetLayout(logicalDevice, &layoutInfo, nullptr, &m_Layout) != VK_SUCCESS) {
+			printf("Uniform Descriptor Layout Not Created\n");
+		}
+
+		std::array<VkDescriptorPoolSize, 2> poolSizes{};
+
+		poolSizes[0].type = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER;
+		poolSizes[0].descriptorCount = static_cast<uint32_t>(swapchain.GetSwapChainImagesSize());
+
+		poolSizes[1].type = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER;
+		poolSizes[1].descriptorCount = static_cast<uint32_t>(swapchain.GetSwapChainImagesSize());
+
+		VkDescriptorPoolCreateInfo poolInfo{};
+		poolInfo.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO;
+		poolInfo.poolSizeCount = static_cast<uint32_t>(poolSizes.size());
+		poolInfo.pPoolSizes = poolSizes.data();
+		poolInfo.maxSets = static_cast<uint32_t>(swapchain.GetSwapChainImagesSize());
+
+		if (vkCreateDescriptorPool(logicalDevice, &poolInfo, nullptr, &m_DescriptorPool) != VK_SUCCESS) {
+			printf("Descriptor Pool Not Created\n");
+		}
+
+		std::vector<VkDescriptorSetLayout> layouts(swapchain.GetSwapChainImagesSize(), m_Layout);
+
+		VkDescriptorSetAllocateInfo allocInfo{};
+		allocInfo.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO;
+		allocInfo.descriptorPool = m_DescriptorPool;
+		allocInfo.descriptorSetCount = swapchain.GetSwapChainImagesSize();
+		allocInfo.pSetLayouts = layouts.data();
+
+		m_DescriptorSets.resize(swapchain.GetSwapChainImagesSize());
+
+		if (vkAllocateDescriptorSets(logicalDevice, &allocInfo, m_DescriptorSets.data()) != VK_SUCCESS) {
+			printf("Failed to allocate descriptor sets\n");
+		}
+
+		for (size_t i = 0; i < swapchain.GetSwapChainImagesSize(); i++) {
+			VkDescriptorBufferInfo bufferInfo{};
+			bufferInfo.buffer = uniformBuffers[i];
+			bufferInfo.offset = 0;
+			bufferInfo.range = size;
+
+			std::array<VkWriteDescriptorSet, 2> descriptorWrites{};
+
+			descriptorWrites[0].sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
+			descriptorWrites[0].dstSet = m_DescriptorSets[i];
+			descriptorWrites[0].dstBinding = 0;
+			descriptorWrites[0].dstArrayElement = 0;
+			descriptorWrites[0].descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER;
+			descriptorWrites[0].descriptorCount = 1;
+			descriptorWrites[0].pBufferInfo = &bufferInfo;
+
+			descriptorWrites[1].sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
+			descriptorWrites[1].dstSet = m_DescriptorSets[i];
+			descriptorWrites[1].dstBinding = 1;
+			descriptorWrites[1].dstArrayElement = 0;
+			descriptorWrites[1].descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER;
+			descriptorWrites[1].descriptorCount = 1;
+			descriptorWrites[1].pImageInfo = &texture->GetImageDescriptorInfo();
+
+			vkUpdateDescriptorSets(logicalDevice, static_cast<uint32_t>(descriptorWrites.size()), descriptorWrites.data(), 0, nullptr);
+		}
+	}
 }

Arcane/src/Arcane/Platform/Vulkan/VulkanDescriptorSet.h

@@ -3,12 +3,15 @@
 #include <vulkan/vulkan.h>
 #include <vector>
 
+#include "VulkanTexture.h"
+
 namespace Arcane
 {
 	class VulkanDescriptorSet
 	{
 	public:
 		VulkanDescriptorSet(std::vector<VkBuffer> uniformBuffers, uint32_t size);
+		VulkanDescriptorSet(std::vector<VkBuffer> uniformBuffers, uint32_t size, VulkanTexture* texture);
 
 		VkDescriptorSetLayout GetLayout() { return m_Layout; }
 		std::vector<VkDescriptorSet> GetDescriptorSets() { return m_DescriptorSets; }

Arcane/src/Arcane/Platform/Vulkan/VulkanUniformBuffer.cpp

@@ -68,6 +68,52 @@ namespace Arcane
 		m_DescriptorSet = new VulkanDescriptorSet(m_UniformBuffers, size);
 	}
 
+	VulkanUniformBuffer::VulkanUniformBuffer(Texture* texture, uint32_t size)
+	{
+		VkDeviceSize bufferSize = size;
+		VulkanContext* context = static_cast<VulkanContext*>(Application::Get().GetWindow().GetContext());
+		VulkanSwapChain& swapchain = context->GetSwapChain();
+		VkDevice logicalDevice = context->GetDevice().GetLogicalDevice();
+		VulkanTexture* vulkanTexture = static_cast<VulkanTexture*>(texture);
+
+		m_UniformBuffers.resize(swapchain.GetSwapChainImagesSize());
+		m_UniformBuffersMemory.resize(swapchain.GetSwapChainImagesSize());
+
+		for (int i = 0; i < swapchain.GetSwapChainImagesSize(); i++) {
+			VkBufferCreateInfo bufferInfo{};
+			bufferInfo.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO;
+			bufferInfo.size = size;
+			bufferInfo.usage = VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT;
+			bufferInfo.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
+
+			if (vkCreateBuffer(logicalDevice, &bufferInfo, nullptr, &m_UniformBuffers[i]) != VK_SUCCESS) {
+				printf("Uniform Buffer Not Created\n");
+			}
+			else {
+				printf("Uniform Buffer Created\n");
+			}
+
+			VkMemoryRequirements memRequirements;
+			vkGetBufferMemoryRequirements(logicalDevice, m_UniformBuffers[i], &memRequirements);
+
+			VkMemoryAllocateInfo allocInfo{};
+			allocInfo.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO;
+			allocInfo.allocationSize = memRequirements.size;
+			allocInfo.memoryTypeIndex = FindMemoryType(memRequirements.memoryTypeBits, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT);
+
+			if (vkAllocateMemory(logicalDevice, &allocInfo, nullptr, &m_UniformBuffersMemory[i]) != VK_SUCCESS) {
+				printf("Failed to allocated Uniform buffer memory\n");
+			}
+			else {
+				printf("Allocated Uniform buffer memory\n");
+			}
+
+			vkBindBufferMemory(logicalDevice, m_UniformBuffers[i], m_UniformBuffersMemory[i], 0);
+		}
+
+		m_DescriptorSet = new VulkanDescriptorSet(m_UniformBuffers, size, vulkanTexture);
+	}
+
 	void VulkanUniformBuffer::WriteData(void* data, uint32_t size)
 	{
 		VulkanContext* context = static_cast<VulkanContext*>(Application::Get().GetWindow().GetContext());
@@ -79,4 +125,5 @@ namespace Arcane
 		memcpy(tempData, data,  size);
 		vkUnmapMemory(logicalDevice, m_UniformBuffersMemory[swapchain.GetImageIndex()]);
 	}
+
 }

Arcane/src/Arcane/Platform/Vulkan/VulkanUniformBuffer.h

@@ -11,6 +11,7 @@ namespace Arcane
 	{
 	public:
 		VulkanUniformBuffer(uint32_t size);
+		VulkanUniformBuffer(Texture* texture, uint32_t size);
 
 		void WriteData(void* data, uint32_t size) override;
 

Arcane/src/Arcane/Renderer/UniformBuffer.cpp

@@ -16,4 +16,14 @@ namespace Arcane
 			break;
 		}
 	}
+
+	UniformBuffer* UniformBuffer::Create(Texture* texture, uint32_t size)
+	{
+		switch (RendererAPI::Current())
+		{
+		case RendererAPIType::Vulkan: return new VulkanUniformBuffer(texture, size);
+		default:
+			break;
+		}
+	}
 }

Arcane/src/Arcane/Renderer/UniformBuffer.h

@@ -1,6 +1,7 @@
 #pragma once
 
 #include <iostream>
+#include "Texture.h"
 
 namespace Arcane
 {
@@ -10,6 +11,7 @@ namespace Arcane
 		virtual void WriteData(void* data, uint32_t size) = 0;
 
 		static UniformBuffer* Create(uint32_t size);
+		static UniformBuffer* Create(Texture* texture, uint32_t size);
 	private:
 
 	};

EnchantingTable/src/Assets/Shaders/Basic.frag

@@ -12,5 +12,5 @@ layout(location = 1) in vec2 fragTexCoord;
 layout(location = 0) out vec4 outColor;
 
 void main() {
-    outColor = vec4(fragTexCoord, 0.0, 1.0);
+    outColor = texture(texSampler, fragTexCoord);
 }

EnchantingTable/src/EditorLayer.cpp

@@ -35,7 +35,9 @@ void EditorLayer::OnAttach()
 		Arcane::VertexType::float2
 	});
 
-	m_UniformBuffer = Arcane::UniformBuffer::Create(sizeof(UniformBufferObject));
+
+	Arcane::Texture* testTexture = Arcane::Texture::Create(".\\src\\Assets\\Textures\\shield.png");
+	m_UniformBuffer = Arcane::UniformBuffer::Create(testTexture, sizeof(UniformBufferObject));
 
 	// Test Pipeline
 	Arcane::PipelineSpecification spec;
@@ -63,8 +65,6 @@ void EditorLayer::OnAttach()
 	Arcane::IndexBuffer* indexBuffer = Arcane::IndexBuffer::Create(indices.data(), indices.size());
 	m_VertexBuffer->AddIndexBuffer(indexBuffer);
 
-	Arcane::Texture* testTexture = Arcane::Texture::Create(".\\src\\Assets\\Textures\\shield.png");
-
 }
 
 void EditorLayer::OnDetach()