Dynamitos/Seele
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Startet to terribly implement a list

Browse Source
This commit is contained in:
Dynamitos
2020-03-13 12:44:33 +01:00
parent 80b57f5134
commit a5473409c1
21 changed files with 1034 additions and 104 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/Engine/Graphics/Graphics.cpp
-9
View File
@@ -1,17 +1,8 @@
#include "Graphics.h"
#include <iostream>
#include <map>
Seele::Graphics::Graphics()
{
Array<uint8> arr;
arr.add('2');
arr.add('4');
std::cout << "Test" << std::endl;
for (auto a : arr)
{
std::cout << "Element: " << a << std::endl;
}
}
Seele::Graphics::~Graphics()
src/Engine/Graphics/Graphics.h
+1
View File
@@ -17,4 +17,5 @@ namespace Seele {
~Graphics();
friend class Window;
};
DEFINE_REF(Graphics);
}
src/Engine/Graphics/GraphicsResources.h
+47 -1
View File
@@ -1,7 +1,12 @@
#pragma once
#include "GraphicsEnums.h"
#include "Containers/Array.h"
#include <vulkan/vulkan.h>
#include "Math/MemCRC.h"
#ifdef _DEBUG
#define ENABLE_VALIDATION
#endif
namespace Seele
{
struct SePushConstantRange {
@@ -13,6 +18,31 @@ namespace Seele
struct GraphicsInitializer
{
const char* windowLayoutFile;
const char* applicationName;
const char* engineName;
/**
* layers defines the enabled Vulkan layers used in the instance,
* if ENABLE_VALIDATION is defined, standard validation is already enabled
* not yet implemented
*/
Array<const char*> layers;
Array<const char*> instanceExtensions;
Array<const char*> deviceExtensions;
GraphicsInitializer()
: applicationName("SeeleEngine")
, engineName("SeeleEngine")
, layers{ "VK_LAYER_LUNARG_standard_validation" }
, instanceExtensions{}
, deviceExtensions{ "VK_KHR_swapchain" }
{}
GraphicsInitializer(const GraphicsInitializer& other)
: applicationName(other.applicationName)
, engineName(other.engineName)
, layers(other.layers)
, instanceExtensions(other.instanceExtensions)
, deviceExtensions(other.deviceExtensions)
{
}
};
struct WindowCreateInfo
{
@@ -29,7 +59,11 @@ namespace Seele
DEFINE_REF(RenderCommandBase);
class SamplerState
{
public:
virtual ~SamplerState()
{
}
};
DEFINE_REF(SamplerState);
class DescriptorBinding
@@ -128,12 +162,20 @@ namespace Seele
DEFINE_REF(VertexDeclaration);
class GraphicsPipeline
{
public:
virtual ~GraphicsPipeline()
{
}
};
DEFINE_REF(GraphicsPipeline);
class UniformBuffer
{
public:
virtual ~UniformBuffer()
{
}
};
DEFINE_REF(UniformBuffer);
class Viewport
@@ -153,7 +195,11 @@ namespace Seele
DEFINE_REF(IndexBuffer);
class StructuredBuffer
{
public:
virtual ~StructuredBuffer()
{
}
};
DEFINE_REF(StructuredBuffer);
class Texture
src/Engine/Graphics/Vulkan/CMakeLists.txt
+3
View File
@@ -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
+26
View File
@@ -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
+43
View File
@@ -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
+133 -3
View File
@@ -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
+65 -2
View File
@@ -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
+14 -2
View File
@@ -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
+157
View File
@@ -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
+4 -70
View File
@@ -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
+48 -12
View File
@@ -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
View File
@@ -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)
{
src/Engine/Graphics/Window.cpp
+1
View File
@@ -11,6 +11,7 @@ Seele::Window::Window(const WindowCreateInfo& createInfo)
center->resizeArea(Rect(1, 1, 0, 0));
center->addView(new SceneView(graphics));
windowHandle = graphics->createWindow(createInfo);
graphics->init(GraphicsInitializer());
}
Seele::Window::~Window()