GeorgH93/OpenVulkano
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Merge branch 'wip'

Browse Source
This commit is contained in:
GeorgH93
2024-09-12 22:17:37 +02:00
parent 6ce56b9a00 35515c7902
commit f6c48edac6
24 changed files with 346 additions and 244 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
openVulkanoCpp/Vulkan/Resources/ManagedBuffer.hpp
View File

@@ -33,7 +33,7 @@ namespace OpenVulkano::Vulkan
~ManagedBuffer()
{
allocation->device.destroy(buffer);
if (allocation) [[likely]] allocation->device.destroy(buffer);
}
[[nodiscard]] bool IsLast() const

2
openVulkanoCpp/Vulkan/Resources/MemoryPool.cpp
View File

@@ -23,6 +23,8 @@ namespace OpenVulkano::Vulkan
{
if (memPool->FreeBuffer(buffer)) return;
}
Logger::RENDER->error("Attempted to released buffer to pool, but owning pool no longer exists!");
buffer->allocation = nullptr; // Allocation is no longer valid since owning pool is gone already
delete buffer;
}

45
openVulkanoCpp/Vulkan/Resources/ResourceManager.cpp
View File

@@ -98,6 +98,7 @@ namespace OpenVulkano::Vulkan
{
transferQueue.waitIdle();
transferQueue = nullptr;
OnShutdown(this); // Notify all custom resources that it's time to die
geometries.clear();
nodes.clear();
textures.clear();
@@ -153,7 +154,7 @@ namespace OpenVulkano::Vulkan
VulkanGeometry* ResourceManager::PrepareGeometry(Scene::Geometry* geometry)
{
const std::unique_lock lock(mutex);
if(!geometry->renderGeo)
if(!geometry->HasRenderResource())
{
ManagedBuffer::Ptr vertexBuffer =
CreateDeviceOnlyBufferWithData(sizeof(Vertex) * geometry->GetVertexCount(), vk::BufferUsageFlagBits::eVertexBuffer, geometry->GetVertices());
@@ -162,19 +163,18 @@ namespace OpenVulkano::Vulkan
indexBuffer = CreateDeviceOnlyBufferWithData(Utils::EnumAsInt(geometry->indexType) * geometry->GetIndexCount(), vk::BufferUsageFlagBits::eIndexBuffer, geometry->GetIndices());
VulkanGeometry* vkGeo = new VulkanGeometry(geometry, vertexBuffer, indexBuffer);
geometries.emplace_back(vkGeo);
geometry->renderGeo = vkGeo;
if (geometry->ownsMemory && geometry->freeAfterUpload)
{
geometry->Free();
}
return vkGeo;
}
return dynamic_cast<VulkanGeometry*>(geometry->renderGeo);
return geometry->GetRenderResource();
}
void ResourceManager::PrepareMaterial(Scene::Material* material)
{
if (material->texture && !material->texture->renderTexture)
if (material->texture && !material->texture->HasRenderResource())
{
PrepareTexture(material->texture);
}
@@ -183,7 +183,7 @@ namespace OpenVulkano::Vulkan
VulkanNode* ResourceManager::PrepareNode(Scene::Node* node)
{
const std::unique_lock lock(mutex);
if (!node->renderNode)
if (!node->HasRenderResource())
{
UniformBuffer* uBuffer = new UniformBuffer();
ManagedBuffer::Ptr buffer;
@@ -193,29 +193,28 @@ namespace OpenVulkano::Vulkan
if (node->GetUpdateFrequency() != Scene::UpdateFrequency::Never)
{
frameSize = allocSize;
vkNode = new VulkanNodeDynamic();
vkNode = new VulkanNodeDynamic(node, uBuffer);
const uint32_t imgs = context->swapChain.GetImageCount();
buffer = memPool.CreateBuffer(imgs * allocSize, vk::BufferUsageFlagBits::eUniformBuffer, vk::MemoryPropertyFlagBits::eHostCoherent | vk::MemoryPropertyFlagBits::eHostVisible);
buffer->Map();
}
else
{
vkNode = new VulkanNode();
buffer = CreateDeviceOnlyBufferWithData(Scene::Node::SIZE, vk::BufferUsageFlagBits::eUniformBuffer, &node->worldMat);
vkNode = new VulkanNode(node, uBuffer);
}
uBuffer->Init(std::move(buffer), frameSize, allocSize, GetDescriptorLayoutSet(Scene::Node::DESCRIPTOR_SET_LAYOUT_BINDING), Scene::Node::DESCRIPTOR_SET_LAYOUT_BINDING, 0);
vkNode->Init(node, uBuffer);
node->renderNode = vkNode;
nodes.emplace_back(vkNode);
return vkNode;
}
return static_cast<VulkanNode*>(node->renderNode);
return node->GetRenderResource();
}
VulkanCamera* ResourceManager::PrepareCamera(Scene::Camera* camera)
{
const std::unique_lock lock(mutex);
if (!camera->renderCamera)
if (!camera->HasRenderResource())
{
const vk::DeviceSize allocSize = Utils::Align(Scene::Camera::SIZE, uniformBufferAlignment);
const uint32_t imgs = context->swapChain.GetImageCount();
@@ -223,12 +222,10 @@ namespace OpenVulkano::Vulkan
buffer->Map();
UniformBuffer* uBuffer = new UniformBuffer();
uBuffer->Init(std::move(buffer), allocSize, allocSize, GetDescriptorLayoutSet(Scene::Camera::DESCRIPTOR_SET_LAYOUT_BINDING), Scene::Camera::DESCRIPTOR_SET_LAYOUT_BINDING, 1);
VulkanCamera* vkCam = new VulkanCamera();
vkCam->Init(camera, uBuffer);
VulkanCamera* vkCam = new VulkanCamera(camera, uBuffer);
cameras.emplace_back(vkCam);
camera->renderCamera = vkCam;
}
return static_cast<VulkanCamera*>(camera->renderCamera);
return static_cast<VulkanCamera*>(camera->GetRenderResource());
}
UniformBuffer* ResourceManager::CreateUniformBuffer(const DescriptorSetLayoutBinding& binding, size_t size, void* data, uint32_t setId, bool hostVis)
@@ -278,6 +275,7 @@ namespace OpenVulkano::Vulkan
find_if(shaders.begin(), shaders.end(),
[&](auto& obj){ return obj.get() == shader; }
);
object->get()->owner = nullptr;
shaders.erase(object);
}
@@ -309,9 +307,8 @@ namespace OpenVulkano::Vulkan
VulkanShader* ResourceManager::CreateShader(Scene::Shader* shader)
{
const std::unique_lock lock(mutex);
if (shader->renderShader) return static_cast<VulkanShader*>(shader->renderShader);
VulkanShader* vkShader = new VulkanShader();
vkShader->Init(context, shader, this);
if (shader->HasRenderResource()) return static_cast<VulkanShader*>(shader->GetRenderResource());
VulkanShader* vkShader = new VulkanShader(context, shader, this);
shaders.emplace_back(vkShader);
return vkShader;
}
@@ -319,7 +316,7 @@ namespace OpenVulkano::Vulkan
VulkanTexture* ResourceManager::PrepareTexture(Scene::Texture* texture)
{
const std::unique_lock lock(mutex);
if (texture->renderTexture) return static_cast<VulkanTexture*>(texture->renderTexture);
if (texture->HasRenderResource()) return static_cast<VulkanTexture*>(texture->GetRenderResource());
VulkanTexture* vkTexture;
if (texture->updateFrequency == Scene::UpdateFrequency::Never)
vkTexture = new VulkanTexture();
@@ -336,31 +333,29 @@ namespace OpenVulkano::Vulkan
VulkanUniformBuffer* ResourceManager::PrepareUniformBuffer(Scene::UniformBuffer* buffer)
{
const std::unique_lock lock(mutex);
if (buffer->renderBuffer) return static_cast<VulkanUniformBuffer*>(buffer->renderBuffer);
if (buffer->HasRenderResource()) return static_cast<VulkanUniformBuffer*>(buffer->GetRenderResource());
VulkanUniformBuffer* vkBuffer;
ManagedBuffer::Ptr mBuffer;
const vk::DeviceSize allocSize = Utils::Align(buffer->size, uniformBufferAlignment);
UniformBuffer* uBuffer = new UniformBuffer();
if (buffer->GetUpdateFrequency() != Scene::UpdateFrequency::Never)
{
vkBuffer = new VulkanUniformBufferDynamic();
const uint32_t imgs = context->swapChain.GetImageCount();
mBuffer = memPool.CreateBuffer(imgs * allocSize, vk::BufferUsageFlagBits::eUniformBuffer, vk::MemoryPropertyFlagBits::eHostCoherent | vk::MemoryPropertyFlagBits::eHostVisible);
mBuffer->Map();
vkBuffer = new VulkanUniformBufferDynamic(buffer, uBuffer);
}
else
{
vkBuffer = new VulkanUniformBuffer();
mBuffer = CreateDeviceOnlyBufferWithData(buffer->size, vk::BufferUsageFlagBits::eUniformBuffer, buffer->data);
buffer->updated = false;
vkBuffer = new VulkanUniformBuffer(buffer, uBuffer);
}
UniformBuffer* uBuffer = new UniformBuffer();
const uint64_t s = mBuffer->size;
uBuffer->Init(std::move(mBuffer), 0, s, GetDescriptorLayoutSet(buffer->binding), buffer->binding, buffer->setId);
vkBuffer->Init(buffer, uBuffer);
uniforms.emplace_back(vkBuffer);
return vkBuffer;
}

3
openVulkanoCpp/Vulkan/Resources/ResourceManager.hpp
View File

@@ -14,6 +14,7 @@
#include "IShaderOwner.hpp"
#include "MemoryPool.hpp"
#include "Base/Wrapper.hpp"
#include "Base/Event.hpp"
#include "Base/Render/IResourceManager.hpp"
#include "Vulkan/Image.hpp"
#include "Scene/Shader/DescriptorInputDescription.hpp"
@@ -134,6 +135,8 @@ namespace OpenVulkano
vk::DescriptorSetLayout* GetDescriptorLayoutSet(const DescriptorSetLayoutBinding& descriptorSetLayoutBinding);
VulkanShader* CreateShader(Scene::Shader* shader);
Event<ResourceManager*> OnShutdown;
};
}
}