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

Basic crashing text rendering

Browse Source
This commit is contained in:
Dynamitos
2022-04-15 11:19:30 +02:00
parent 3fec36295a
commit eb23264c40
41 changed files with 895 additions and 273 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/Engine/Graphics/Vulkan/VulkanCommandBuffer.cpp
+13
View File
@@ -290,6 +290,13 @@ void RenderCommand::bindIndexBuffer(Gfx::PIndexBuffer indexBuffer)
PIndexBuffer buf = indexBuffer.cast<IndexBuffer>();
vkCmdBindIndexBuffer(handle, buf->getHandle(), 0, cast(buf->getIndexType()));
}
void RenderCommand::pushConstants(Gfx::PPipelineLayout layout, Gfx::SeShaderStageFlags stage, uint32 offset, uint32 size, const void* data)
{
assert(threadId == std::this_thread::get_id());
vkCmdPushConstants(handle, layout.cast<PipelineLayout>()->getHandle(), stage, offset, size, data);
}
void RenderCommand::draw(const MeshBatchElement& data)
{
assert(threadId == std::this_thread::get_id());
@@ -386,6 +393,12 @@ void ComputeCommand::bindDescriptor(const Array<Gfx::PDescriptorSet>& descriptor
delete[] sets;
}
void ComputeCommand::pushConstants(Gfx::PPipelineLayout layout, Gfx::SeShaderStageFlags stage, uint32 offset, uint32 size, const void* data)
{
assert(threadId == std::this_thread::get_id());
vkCmdPushConstants(handle, layout.cast<PipelineLayout>()->getHandle(), stage, offset, size, data);
}
void ComputeCommand::dispatch(uint32 threadX, uint32 threadY, uint32 threadZ)
{
assert(threadId == std::this_thread::get_id());
src/Engine/Graphics/Vulkan/VulkanCommandBuffer.h
+2
View File
@@ -89,6 +89,7 @@ public:
virtual void bindDescriptor(const Array<Gfx::PDescriptorSet>& descriptorSets) override;
virtual void bindVertexBuffer(const Array<VertexInputStream>& streams) override;
virtual void bindIndexBuffer(Gfx::PIndexBuffer indexBuffer) override;
virtual void pushConstants(Gfx::PPipelineLayout layout, Gfx::SeShaderStageFlags stage, uint32 offset, uint32 size, const void* data) override;
virtual void draw(const MeshBatchElement& data) override;
virtual void draw(uint32 vertexCount, uint32 instanceCount, int32 firstVertex, uint32 firstInstance) override;
private:
@@ -121,6 +122,7 @@ public:
virtual void bindPipeline(Gfx::PComputePipeline pipeline) override;
virtual void bindDescriptor(Gfx::PDescriptorSet set) override;
virtual void bindDescriptor(const Array<Gfx::PDescriptorSet>& sets) override;
virtual void pushConstants(Gfx::PPipelineLayout layout, Gfx::SeShaderStageFlags stage, uint32 offset, uint32 size, const void* data) override;
virtual void dispatch(uint32 threadX, uint32 threadY, uint32 threadZ) override;
private:
PComputePipeline pipeline;
src/Engine/Graphics/Vulkan/VulkanDescriptorSets.cpp
+61 -5
View File
@@ -29,6 +29,7 @@ void DescriptorLayout::create()
return;
}
bindings.resize(descriptorBindings.size());
Array<VkDescriptorBindingFlags> bindingFlags(descriptorBindings.size());
for (size_t i = 0; i < descriptorBindings.size(); ++i)
{
VkDescriptorSetLayoutBinding &binding = bindings[i];
@@ -38,9 +39,16 @@ void DescriptorLayout::create()
binding.descriptorType = cast(rhiBinding.descriptorType);
binding.stageFlags = rhiBinding.shaderStages;
binding.pImmutableSamplers = nullptr;
bindingFlags[i] = rhiBinding.bindingFlags;
}
VkDescriptorSetLayoutCreateInfo createInfo =
init::DescriptorSetLayoutCreateInfo(bindings.data(), (uint32)bindings.size());
VkDescriptorSetLayoutBindingFlagsCreateInfo bindingFlagsInfo = {};
bindingFlagsInfo.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO;
bindingFlagsInfo.pNext = nullptr;
bindingFlagsInfo.bindingCount = static_cast<uint32>(bindingFlags.size());
bindingFlagsInfo.pBindingFlags = bindingFlags.data();
createInfo.pNext = &bindingFlagsInfo;
VK_CHECK(vkCreateDescriptorSetLayout(graphics->getDevice(), &createInfo, nullptr, &layoutHandle));
allocator = new DescriptorAllocator(graphics, *this);
@@ -188,20 +196,54 @@ void DescriptorSet::updateTexture(uint32_t binding, Gfx::PTexture texture, Gfx::
imageInfo.sampler = vulkanSampler->sampler;
}
imageInfos.add(imageInfo);
VkDescriptorType descriptorType = VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE;
if(samplerState != nullptr)
{
descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER;
}
else if (vulkanTexture->getUsage() & VK_IMAGE_USAGE_STORAGE_BIT)
{
descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_IMAGE;
}
VkWriteDescriptorSet writeDescriptor =
init::WriteDescriptorSet(
setHandle,
samplerState != nullptr ? VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER : VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE,
descriptorType,
binding,
&imageInfos.back());
if (vulkanTexture->getUsage() & VK_IMAGE_USAGE_STORAGE_BIT)
{
writeDescriptor.descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_IMAGE;
}
writeDescriptors.add(writeDescriptor);
cachedData[binding] = vulkanTexture;
}
void DescriptorSet::updateTextureArray(uint32_t binding, Array<Gfx::PTexture> textures)
{
// maybe make this a parameter?
uint32 arrayElement = 0;
for(const auto& gfxTexture : textures)
{
TextureHandle* vulkanTexture = TextureBase::cast(gfxTexture);
imageInfos.add(
init::DescriptorImageInfo(
VK_NULL_HANDLE,
vulkanTexture->getView(),
cast(vulkanTexture->getLayout())));
VkDescriptorType descriptorType = VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE;
if (vulkanTexture->getUsage() & VK_IMAGE_USAGE_STORAGE_BIT)
{
descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_IMAGE;
}
VkWriteDescriptorSet& write = writeDescriptors.add(
init::WriteDescriptorSet(
setHandle,
descriptorType,
binding,
&imageInfos.back()
));
write.dstArrayElement = arrayElement++;
}
}
bool DescriptorSet::operator<(Gfx::PDescriptorSet other)
{
@@ -281,6 +323,20 @@ void DescriptorAllocator::allocateDescriptorSet(Gfx::PDescriptorSet &descriptorS
VkDescriptorSetLayout layoutHandle = layout.getHandle();
VkDescriptorSetAllocateInfo allocInfo =
init::DescriptorSetAllocateInfo(poolHandle, &layoutHandle, 1);
VkDescriptorSetVariableDescriptorCountAllocateInfo setCounts = {};
setCounts.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO;
setCounts.pNext = nullptr;
setCounts.descriptorSetCount = 1;
uint32 counts = 0;
for(const auto& binding : layout.bindings)
{
if(binding.binding & Gfx::SE_DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT)
{
counts = binding.descriptorCount;
}
}
setCounts.pDescriptorCounts = &counts;
allocInfo.pNext = &setCounts;
for(uint32 setIndex = 0; setIndex < cachedHandles.size(); ++setIndex)
{
src/Engine/Graphics/Vulkan/VulkanDescriptorSets.h
+2 -2
View File
@@ -12,11 +12,10 @@ public:
DescriptorLayout(PGraphics graphics, const std::string& name);
virtual ~DescriptorLayout();
virtual void create();
inline VkDescriptorSetLayout getHandle() const
constexpr VkDescriptorSetLayout getHandle() const
{
return layoutHandle;
}
private:
uint32 hash;
PGraphics graphics;
@@ -72,6 +71,7 @@ public:
virtual void updateBuffer(uint32_t binding, Gfx::PStructuredBuffer uniformBuffer);
virtual void updateSampler(uint32_t binding, Gfx::PSamplerState samplerState);
virtual void updateTexture(uint32_t binding, Gfx::PTexture texture, Gfx::PSamplerState sampler = nullptr);
virtual void updateTextureArray(uint32_t binding, Array<Gfx::PTexture> texture);
virtual bool operator<(Gfx::PDescriptorSet other);
inline bool isCurrentlyBound() const
src/Engine/Graphics/Vulkan/VulkanGraphics.cpp
+27 -2
View File
@@ -204,11 +204,27 @@ Gfx::PComputePipeline Graphics::createComputePipeline(const ComputePipelineCreat
return pipeline;
}
Gfx::PSamplerState Graphics::createSamplerState(const SamplerCreateInfo&)
Gfx::PSamplerState Graphics::createSamplerState(const SamplerCreateInfo& createInfo)
{
PSamplerState sampler = new SamplerState(); // TODO: proper sampler creation
PSamplerState sampler = new SamplerState();
VkSamplerCreateInfo vkInfo =
init::SamplerCreateInfo();
vkInfo.addressModeU = cast(createInfo.addressModeU);
vkInfo.addressModeV = cast(createInfo.addressModeV);
vkInfo.addressModeW = cast(createInfo.addressModeW);
vkInfo.anisotropyEnable = createInfo.anisotropyEnable;
vkInfo.borderColor = cast(createInfo.borderColor);
vkInfo.compareEnable = createInfo.compareEnable;
vkInfo.compareOp = cast(createInfo.compareOp);
vkInfo.flags = createInfo.flags;
vkInfo.magFilter = cast(createInfo.magFilter);
vkInfo.maxAnisotropy = createInfo.maxAnisotropy;
vkInfo.maxLod = createInfo.maxLod;
vkInfo.minFilter = cast(createInfo.minFilter);
vkInfo.minLod = createInfo.minLod;
vkInfo.mipLodBias = createInfo.mipLodBias;
vkInfo.mipmapMode = cast(createInfo.mipmapMode);
vkInfo.unnormalizedCoordinates = createInfo.unnormalizedCoordinates;
VK_CHECK(vkCreateSampler(handle, &vkInfo, nullptr, &sampler->sampler));
return sampler;
}
@@ -537,6 +553,15 @@ void Graphics::createDevice(GraphicsInitializer initializer)
queueInfos.data(),
(uint32)queueInfos.size(),
&features);
VkPhysicalDeviceDescriptorIndexingFeatures descriptorIndexing = {};
std::memset(&descriptorIndexing, 0, sizeof(descriptorIndexing));
descriptorIndexing.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES;
descriptorIndexing.shaderSampledImageArrayNonUniformIndexing = VK_TRUE;
descriptorIndexing.runtimeDescriptorArray = VK_TRUE;
descriptorIndexing.descriptorBindingVariableDescriptorCount = VK_TRUE;
descriptorIndexing.descriptorBindingPartiallyBound = VK_TRUE;
deviceInfo.pNext = &descriptorIndexing;
#if ENABLE_VALIDATION
VkDeviceDiagnosticsConfigCreateInfoNV crashDiagInfo;
crashDiagInfo.sType = VK_STRUCTURE_TYPE_DEVICE_DIAGNOSTICS_CONFIG_CREATE_INFO_NV;
src/Engine/Graphics/Vulkan/VulkanGraphicsEnums.cpp
+131
View File
@@ -1421,3 +1421,134 @@ Gfx::SeClearValue Seele::Vulkan::cast(const VkClearValue& clear)
}
return result;
}
VkSamplerAddressMode Seele::Vulkan::cast(const Gfx::SeSamplerAddressMode &mode)
{
switch(mode)
{
case SE_SAMPLER_ADDRESS_MODE_REPEAT:
return VK_SAMPLER_ADDRESS_MODE_REPEAT;
case SE_SAMPLER_ADDRESS_MODE_MIRRORED_REPEAT:
return VK_SAMPLER_ADDRESS_MODE_MIRRORED_REPEAT;
case SE_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE:
return VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE;
case SE_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER:
return VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER;
case SE_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE:
return VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE;
default:
return VK_SAMPLER_ADDRESS_MODE_MAX_ENUM;
}
}
Gfx::SeSamplerAddressMode Seele::Vulkan::cast(const VkSamplerAddressMode &mode)
{
switch(mode)
{
case VK_SAMPLER_ADDRESS_MODE_REPEAT:
return SE_SAMPLER_ADDRESS_MODE_REPEAT;
case VK_SAMPLER_ADDRESS_MODE_MIRRORED_REPEAT:
return SE_SAMPLER_ADDRESS_MODE_MIRRORED_REPEAT;
case VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE:
return SE_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE;
case VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER:
return SE_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER;
case VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE:
return SE_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE;
default:
return SE_SAMPLER_ADDRESS_MODE_MAX_ENUM;
}
}
VkBorderColor Seele::Vulkan::cast(const Gfx::SeBorderColor &color)
{
switch(color)
{
case SE_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK:
return VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK;
case SE_BORDER_COLOR_INT_TRANSPARENT_BLACK:
return VK_BORDER_COLOR_INT_TRANSPARENT_BLACK;
case SE_BORDER_COLOR_FLOAT_OPAQUE_BLACK:
return VK_BORDER_COLOR_FLOAT_OPAQUE_BLACK;
case SE_BORDER_COLOR_INT_OPAQUE_BLACK:
return VK_BORDER_COLOR_INT_OPAQUE_BLACK;
case SE_BORDER_COLOR_FLOAT_OPAQUE_WHITE:
return VK_BORDER_COLOR_FLOAT_OPAQUE_WHITE;
case SE_BORDER_COLOR_INT_OPAQUE_WHITE:
return VK_BORDER_COLOR_INT_OPAQUE_WHITE;
default:
return VK_BORDER_COLOR_MAX_ENUM;
}
}
Gfx::SeBorderColor Seele::Vulkan::cast(const VkBorderColor &color)
{
switch(color)
{
case VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK:
return SE_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK;
case VK_BORDER_COLOR_INT_TRANSPARENT_BLACK:
return SE_BORDER_COLOR_INT_TRANSPARENT_BLACK;
case VK_BORDER_COLOR_FLOAT_OPAQUE_BLACK:
return SE_BORDER_COLOR_FLOAT_OPAQUE_BLACK;
case VK_BORDER_COLOR_INT_OPAQUE_BLACK:
return SE_BORDER_COLOR_INT_OPAQUE_BLACK;
case VK_BORDER_COLOR_FLOAT_OPAQUE_WHITE:
return SE_BORDER_COLOR_FLOAT_OPAQUE_WHITE;
case VK_BORDER_COLOR_INT_OPAQUE_WHITE:
return SE_BORDER_COLOR_INT_OPAQUE_WHITE;
default:
return SE_BORDER_COLOR_MAX_ENUM;
}
}
VkFilter Seele::Vulkan::cast(const Gfx::SeFilter &filter)
{
switch(filter)
{
case SE_FILTER_NEAREST:
return VK_FILTER_NEAREST;
case SE_FILTER_LINEAR:
return VK_FILTER_LINEAR;
case SE_FILTER_CUBIC_IMG:
return VK_FILTER_CUBIC_IMG;
default:
return VK_FILTER_MAX_ENUM;
}
}
Gfx::SeFilter Seele::Vulkan::cast(const VkFilter &filter)
{
switch(filter)
{
case VK_FILTER_NEAREST:
return SE_FILTER_NEAREST;
case VK_FILTER_LINEAR:
return SE_FILTER_LINEAR;
case VK_FILTER_CUBIC_IMG:
return SE_FILTER_CUBIC_IMG;
default:
return SE_FILTER_MAX_ENUM;
}
}
VkSamplerMipmapMode Seele::Vulkan::cast(const Gfx::SeSamplerMipmapMode &filter)
{
switch(filter)
{
case SE_SAMPLER_MIPMAP_MODE_NEAREST:
return VK_SAMPLER_MIPMAP_MODE_NEAREST;
case SE_SAMPLER_MIPMAP_MODE_LINEAR:
return VK_SAMPLER_MIPMAP_MODE_LINEAR;
default:
return VK_SAMPLER_MIPMAP_MODE_MAX_ENUM;
}
}
Gfx::SeSamplerMipmapMode Seele::Vulkan::cast(const VkSamplerMipmapMode &filter)
{
switch(filter)
{
case VK_SAMPLER_MIPMAP_MODE_NEAREST:
return SE_SAMPLER_MIPMAP_MODE_NEAREST;
case VK_SAMPLER_MIPMAP_MODE_LINEAR:
return SE_SAMPLER_MIPMAP_MODE_LINEAR;
default:
return SE_SAMPLER_MIPMAP_MODE_MAX_ENUM;
}
}
src/Engine/Graphics/Vulkan/VulkanGraphicsEnums.h
+8
View File
@@ -54,5 +54,13 @@ VkCompareOp cast(const Gfx::SeCompareOp &op);
Gfx::SeCompareOp cast(const VkCompareOp &op);
VkClearValue cast(const Gfx::SeClearValue &clear);
Gfx::SeClearValue cast(const VkClearValue &clear);
VkSamplerAddressMode cast(const Gfx::SeSamplerAddressMode &mode);
Gfx::SeSamplerAddressMode cast(const VkSamplerAddressMode &mode);
VkBorderColor cast(const Gfx::SeBorderColor &color);
Gfx::SeBorderColor cast(const VkBorderColor &color);
VkFilter cast(const Gfx::SeFilter &filter);
Gfx::SeFilter cast(const VkFilter &filter);
VkSamplerMipmapMode cast(const Gfx::SeSamplerMipmapMode &filter);
Gfx::SeSamplerMipmapMode cast(const VkSamplerMipmapMode &filter);
} // namespace Vulkan
} // namespace Seele