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

Merge pull request 'resource_management' (#66) from resource_management into master

Browse Source 
Reviewed-on: https://git.madvoxel.net/OpenVulkano/OpenVulkano/pulls/66
This commit is contained in:
Georg Hagen
2024-07-12 11:07:35 +02:00
parent c37dc59203 ca052ef7f1
commit d88a3f9e9e
26 changed files with 532 additions and 332 deletions
Download Patch File Download Diff File Expand all files Collapse all files

9
openVulkanoCpp/Data/Containers/Array.hpp
View File

@@ -98,6 +98,15 @@ namespace OpenVulkano
Fill(defaultValue);
}
template<typename... ARGS>
Array(size_t size, ARGS... args) : size(size), data(MakeBuffer(size))
{
for(size_t i = 0; i < size; i++)
{
new (&data[i]) T(args...);
}
}
~Array() noexcept
{
ClearData();

12
openVulkanoCpp/Host/GLFW/WindowGLFW.cpp
View File

@@ -253,7 +253,11 @@ namespace OpenVulkano::GLFW
vk::SurfaceKHR WindowGLFW::CreateSurface(const vk::Instance& instance, const vk::AllocationCallbacks* pAllocator)
{
VkSurfaceKHR rawSurface;
const auto result = static_cast<vk::Result>(glfwCreateWindowSurface(static_cast<VkInstance>(instance), window, reinterpret_cast<const VkAllocationCallbacks*>(pAllocator), &rawSurface));
const vk::Result result = static_cast<vk::Result>(glfwCreateWindowSurface(static_cast<VkInstance>(instance), window, reinterpret_cast<const VkAllocationCallbacks*>(pAllocator), &rawSurface));
if (result != vk::Result::eSuccess) [[unlikely]]
{
Logger::WINDOW->error("Failed to create vulkan surface. Result: {}", vk::to_string(result));
}
return rawSurface;//createResultValue(result, rawSurface, "vk::CommandBuffer::begin");
}
@@ -282,19 +286,19 @@ namespace OpenVulkano::GLFW
void WindowGLFW::OnFocusLost()
{
Logger::WINDOW->debug("Window (id: {0}) focus lost", GetWindowId());
Logger::WINDOW->trace("Window (id: {0}) focus lost", GetWindowId());
handler->OnWindowFocusLost(this);
}
void WindowGLFW::OnFocusGained()
{
Logger::WINDOW->debug("Window (id: {0}) focus gained", GetWindowId());
Logger::WINDOW->trace("Window (id: {0}) focus gained", GetWindowId());
handler->OnWindowFocusGained(this);
}
void WindowGLFW::OnMove(const int posX, const int posY)
{
Logger::WINDOW->debug("Window (id: {0}) moved (x: {1}, y: {2})", GetWindowId(), posX, posY);
Logger::WINDOW->trace("Window (id: {0}) moved (x: {1}, y: {2})", GetWindowId(), posX, posY);
if (windowConfig.windowMode == WINDOWED || windowConfig.windowMode == BORDERLESS)
{ // Don't save window position for fullscreen
windowConfig.position.x = posX;

44
openVulkanoCpp/Host/iOS/NamedEventProcessor.mm
View File

@@ -132,36 +132,40 @@ namespace OpenVulkano
void NamedEventProcessor::Notify(const std::string& eventName, const std::vector<Parameters>& parameters) const
{
if (Class eventClass = FindGenericEventClass(m_classNamePrefixes, m_classNameSuffixes, eventName))
@autoreleasepool
{
if (SEL init = GetInitForClass(eventClass, BuildTypeName(parameters)))
if (Class eventClass = FindGenericEventClass(m_classNamePrefixes, m_classNameSuffixes, eventName))
{
NSObject* event = [eventClass alloc];
auto inv = [NSInvocation invocationWithMethodSignature:[event methodSignatureForSelector:init]];
[inv setTarget:event];
[inv setSelector:init];
for (int i = 0; i < parameters.size(); i++)
if (SEL init = GetInitForClass(eventClass, BuildTypeName(parameters)))
{
auto arg = std::visit([](auto&& arg) { return CreateValue(arg); }, parameters[i]);
[inv setArgument:&arg atIndex:(i + 2)];
NSObject* event = [eventClass alloc];
auto inv = [NSInvocation invocationWithMethodSignature:[event methodSignatureForSelector:init]];
[inv setTarget:event];
[inv setSelector:init];
for (int i = 0; i < parameters.size(); i++)
{
auto arg = std::visit([](auto&& arg) { return CreateValue(arg); }, parameters[i]);
[inv setArgument:&arg atIndex:(i + 2)];
}
[inv invoke];
for (Class clazz = eventClass; clazz && clazz != NSObject.class; clazz = class_getSuperclass(clazz))
{
NSString* notificationName;
if (m_useClassNameAsEventName) notificationName = NSStringFromClass(clazz);
else notificationName = [NSString stringWithUTF8String:eventName.c_str()];
[[NSNotificationCenter defaultCenter] postNotificationName:notificationName object:event userInfo:nil];
}
[event release];
}
[inv invoke];
for (Class clazz = eventClass; clazz && clazz != NSObject.class; clazz = class_getSuperclass(clazz))
else
{
NSString* notificationName;
if (m_useClassNameAsEventName) notificationName = NSStringFromClass(clazz);
else notificationName = [NSString stringWithUTF8String:eventName.c_str()];
[[NSNotificationCenter defaultCenter] postNotificationName:notificationName object:event userInfo:nil];
Logger::MANAGER->error("Cannot find constructor for named event %s", eventName);
}
}
else
{
Logger::MANAGER->error("Cannot find constructor for named event %s", eventName);
Logger::MANAGER->debug("Cannot find implementation for named event %s", eventName);
}
}
else
{
Logger::MANAGER->debug("Cannot find implementation for named event %s", eventName);
}
}
}

2
openVulkanoCpp/Host/iOS/OpenVulkanoView.mm
View File

@@ -6,6 +6,7 @@
#import "OpenVulkanoView.h"
#include "Base/Logger.hpp"
#include "Input/Touch/InputDeviceTouch.hpp"
#include "Input/InputManager.hpp"
#include "MetalViewWindow.h"
@@ -113,6 +114,7 @@ using namespace OpenVulkano;
m_touchDevice.Close();
[m_displayLink release];
[m_mtdelegate release];
OpenVulkano::Logger::WINDOW->info("Destroyed OpenVulkanoView");
[super dealloc];
}

6
openVulkanoCpp/Host/iOS/OpenVulkanoViewController.mm
View File

@@ -36,6 +36,12 @@ using namespace OpenVulkano;
-(void) dealloc {
manager->ShutDown();
delete manager;
app = nullptr;
//TODO figure out where these two references are held
[_openVulkanoView release];
[_openVulkanoView release];
_openVulkanoView = nil;
[super dealloc];
}

2
openVulkanoCpp/Vulkan/Context.cpp
View File

@@ -50,6 +50,8 @@ namespace OpenVulkano::Vulkan
//TODO
if (enableValidationLayer) Debug::CloseValidationLayers(instance);
instance.destroy();
initialized = false;
}

2
openVulkanoCpp/Vulkan/Device.cpp
View File

@@ -230,6 +230,8 @@ namespace OpenVulkano::Vulkan
void Device::Close()
{
device.destroyCommandPool(graphicsCommandPool);
device.destroyPipelineCache(pipelineCache);
device.destroy();
//TODO fill
}
}

2
openVulkanoCpp/Vulkan/Device.hpp
View File

@@ -45,6 +45,8 @@ namespace OpenVulkano
public:
Device(vk::PhysicalDevice& physicalDevice);
~Device() { if (device) Close(); }
[[nodiscard]] std::string GetDeviceName() const
{
return properties.deviceName.data();

5
openVulkanoCpp/Vulkan/DeviceManager.hpp
View File

@@ -26,7 +26,10 @@ namespace OpenVulkano::Vulkan
Init(instance);
}
~DeviceManager() = default;
~DeviceManager()
{
if (!devices.empty()) Close();
}
void Init(const vk::Instance& instance);

12
openVulkanoCpp/Vulkan/Renderer.cpp
View File

@@ -32,7 +32,9 @@ namespace OpenVulkano::Vulkan
for (int i = 0; i < context.swapChain.GetImageCount(); i++)
{
waitSemaphores.emplace_back();
waitSemaphores[i].renderComplete.push_back(context.device->device.createSemaphore({}));
vk::Semaphore sema = context.device->device.createSemaphore({});
semaphores.push_back(sema);
waitSemaphores[i].renderComplete.push_back(sema);
waitSemaphores[i].renderReady.resize(2);
}
resourceManager.Init(&context, context.swapChain.GetImageCount());
@@ -72,9 +74,15 @@ namespace OpenVulkano::Vulkan
void Renderer::Close()
{
context.device->WaitIdle();
for (auto& sema : semaphores)
{
context.device->device.destroySemaphore(sema);
}
uiRenderer.Close();
resourceManager.Close();
context.Close();
uiRenderer.Close();
scene = nullptr;
}
std::string Renderer::GetMainRenderDeviceName()

1
openVulkanoCpp/Vulkan/Renderer.hpp
View File

@@ -30,6 +30,7 @@ namespace OpenVulkano::Vulkan
{
Context context;
std::shared_ptr<spdlog::logger> logger;
std::vector<vk::Semaphore> semaphores;
std::vector<WaitSemaphores> waitSemaphores;
Scene::Scene* scene = nullptr;
ResourceManager resourceManager;

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

@@ -8,7 +8,7 @@
namespace OpenVulkano::Vulkan
{
struct VulkanShader;
class VulkanShader;
class IShaderOwner
{

91
openVulkanoCpp/Vulkan/Resources/ManagedResource.hpp → openVulkanoCpp/Vulkan/Resources/ManagedBuffer.hpp
View File

@@ -8,100 +8,17 @@
#define CRASH_ON_MULTIPLE_MAPPINGS_TO_SAME_ALLOCATION
#include "MemoryAllocation.hpp"
#include "MemoryPool.hpp"
#include <memory>
#include <vulkan/vulkan.hpp>
#include <functional>
#include "Base/Utils.hpp"
namespace OpenVulkano::Vulkan
{
struct MemoryAllocation
class ManagedBuffer
{
vk::DeviceMemory memory;
size_t used;
const size_t size;
const uint32_t type;
const vk::Device device;
void* mapped;
private:
uint32_t mappedCount;
static constexpr uint32_t CHILD_MAPPED_FLAG = 1u << 31;
public:
MemoryAllocation(size_t size, uint32_t type, vk::Device device):
memory(nullptr), used(0), size(size), type(type), device(device), mapped(nullptr), mappedCount(0)
{
}
~MemoryAllocation()
{
if (device && memory)
device.free(memory);
}
[[nodiscard]] size_t FreeSpace() const
{
return size - used;
}
[[nodiscard]] size_t FreeSpace(size_t alignment) const
{
return size - Utils::Align(used, alignment);
}
void HandleChildMappingValidation() const;
void* Map()
{
HandleChildMappingValidation();
if (!mapped)
{
mapped = device.mapMemory(memory, 0, size, vk::MemoryMapFlags());
}
mappedCount++;
return mapped;
}
void UnMap()
{
if (mappedCount > 0)
{
mappedCount--;
if (mappedCount == 0)
{
device.unmapMemory(memory);
}
}
}
[[nodiscard]] bool IsChildMapped() const
{
return mappedCount & CHILD_MAPPED_FLAG;
}
void* MapChild(size_t offset, vk::DeviceSize size)
{
HandleChildMappingValidation();
mappedCount |= CHILD_MAPPED_FLAG;
mappedCount++;
return device.mapMemory(memory, offset, size, vk::MemoryMapFlags());
}
void UnMapChild()
{
mappedCount &= ~CHILD_MAPPED_FLAG;
mappedCount--;
if (mappedCount == 0)
{
device.unmapMemory(memory);
}
}
};
struct ManagedBuffer
{
using Ptr = std::unique_ptr<ManagedBuffer, std::function<void(ManagedBuffer*)>>;
using Ptr = std::unique_ptr<ManagedBuffer, ManagedBufferDeleter>;
MemoryAllocation* allocation;
vk::DeviceSize offset, size;

2
openVulkanoCpp/Vulkan/Resources/ManagedResource.cpp → openVulkanoCpp/Vulkan/Resources/MemoryAllocation.cpp
View File

@@ -4,7 +4,7 @@
* file, You can obtain one at https://mozilla.org/MPL/2.0/.
*/
#include "ManagedResource.hpp"
#include "ManagedBuffer.hpp"
#include "Base/Logger.hpp"
namespace OpenVulkano::Vulkan

97
openVulkanoCpp/Vulkan/Resources/MemoryAllocation.hpp Normal file
View File

@@ -0,0 +1,97 @@
/*
* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at https://mozilla.org/MPL/2.0/.
*/
#pragma once
#include "Base/Utils.hpp"
#include <vulkan/vulkan.hpp>
namespace OpenVulkano::Vulkan
{
struct MemoryAllocation
{
vk::DeviceMemory memory;
size_t used;
const size_t size;
const uint32_t type;
const vk::Device device;
void* mapped;
private:
uint32_t mappedCount;
static constexpr uint32_t CHILD_MAPPED_FLAG = 1u << 31;
public:
MemoryAllocation(size_t size, uint32_t type, vk::Device device):
memory(nullptr), used(0), size(size), type(type), device(device), mapped(nullptr), mappedCount(0)
{
}
~MemoryAllocation()
{
if (device && memory)
device.free(memory);
}
[[nodiscard]] size_t FreeSpace() const
{
return size - used;
}
[[nodiscard]] size_t FreeSpace(size_t alignment) const
{
return size - Utils::Align(used, alignment);
}
void HandleChildMappingValidation() const;
void* Map()
{
HandleChildMappingValidation();
if (!mapped)
{
mapped = device.mapMemory(memory, 0, size, vk::MemoryMapFlags());
}
mappedCount++;
return mapped;
}
void UnMap()
{
if (mappedCount > 0)
{
mappedCount--;
if (mappedCount == 0)
{
device.unmapMemory(memory);
}
}
}
[[nodiscard]] bool IsChildMapped() const
{
return mappedCount & CHILD_MAPPED_FLAG;
}
void* MapChild(size_t offset, vk::DeviceSize size)
{
HandleChildMappingValidation();
mappedCount |= CHILD_MAPPED_FLAG;
mappedCount++;
return device.mapMemory(memory, offset, size, vk::MemoryMapFlags());
}
void UnMapChild()
{
mappedCount &= ~CHILD_MAPPED_FLAG;
mappedCount--;
if (mappedCount == 0)
{
device.unmapMemory(memory);
}
}
};
}

153
openVulkanoCpp/Vulkan/Resources/MemoryPool.cpp Normal file
View File

@@ -0,0 +1,153 @@
/*
* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at https://mozilla.org/MPL/2.0/.
*/
#include "MemoryPool.hpp"
#include "ManagedBuffer.hpp"
#include "Vulkan/Device.hpp"
#include "Base/Logger.hpp"
#include "Math/ByteSize.hpp"
namespace OpenVulkano::Vulkan
{
namespace
{
std::vector<MemoryPool*> MEM_POOLS;
}
void MemoryPool::ReleaseBuffer(OpenVulkano::Vulkan::ManagedBuffer* buffer)
{
for (MemoryPool* memPool : MEM_POOLS)
{
if (memPool->FreeBuffer(buffer)) return;
}
delete buffer;
}
MemoryPool::~MemoryPool()
{
if (!allocations.empty()) Close();
}
void MemoryPool::Close()
{
Utils::Remove(MEM_POOLS, this);
for(ManagedBuffer* buffer : recycleBuffers)
{
delete buffer;
}
recycleBuffers.clear();
for(auto& fF : toFree)
{
for(ManagedBuffer* buffer : fF)
{
delete buffer;
}
fF.clear();
}
allocations.clear();
Logger::RENDER->info("Destroyed gpu memory pool");
}
void MemoryPool::Init(Device* dev, int bufferCount)
{
device = dev;
toFree = decltype(toFree)(bufferCount);
MEM_POOLS.push_back(this);
}
void MemoryPool::StartFrame(uint64_t bufferId)
{
currentBuffer = bufferId;
for (ManagedBuffer* i : toFree[currentBuffer])
{
DoFree(i);
}
toFree[currentBuffer].clear();
}
void MemoryPool::DoFree(ManagedBuffer* buffer)
{
if (buffer->IsLast())
{
device->device.destroyBuffer(buffer->buffer);
buffer->allocation->used -= buffer->size;
}
else
{
recycleBuffers.push_back(buffer);
}
}
bool MemoryPool::FreeBuffer(ManagedBuffer* buffer)
{
if (buffer) toFree[currentBuffer].push_back(buffer);
return true;
}
MemoryAllocation* MemoryPool::CreateMemoryAllocation(size_t size, uint32_t type, bool addToCache)
{
MemoryAllocation* alloc = new MemoryAllocation(size, type, device->device);
const vk::MemoryAllocateInfo allocInfo = { size, type };
alloc->memory = device->device.allocateMemory(allocInfo);
if (addToCache) allocations.emplace_back(alloc);
return alloc;
}
MemoryAllocation* MemoryPool::GetFreeMemoryAllocation(size_t size, vk::DeviceSize alignment, uint32_t type, bool createIfAllFull)
{
MemoryAllocation* alloc = nullptr;
for (auto& allocation : allocations)
{
if (allocation->type == type && allocation->FreeSpace(alignment) >= size)
{
alloc = allocation.get();
break;
}
}
if(!alloc && createIfAllFull) alloc = CreateMemoryAllocation(64_MiB, type, true);
return alloc;
}
MemoryPool::ManagedBufferPtr MemoryPool::CreateBuffer(vk::DeviceSize size, const vk::BufferUsageFlags& usage, const vk::MemoryPropertyFlags& properties)
{
size = Utils::Align(size, 16);
vk::BufferCreateInfo bufferCreateInfo = { {}, size, usage, vk::SharingMode::eExclusive };
vk::Buffer buffer = device->device.createBuffer(bufferCreateInfo);
const vk::MemoryRequirements memoryRequirements = device->device.getBufferMemoryRequirements(buffer);
uint32_t memtype = device->GetMemoryType(memoryRequirements.memoryTypeBits, properties);
if (memoryRequirements.size != size)
{
Logger::DATA->debug("Memory Requirement Size ({0}) != Size ({1})", memoryRequirements.size, size);
size = memoryRequirements.size;
device->device.destroy(buffer);
bufferCreateInfo.size = size;
buffer = device->device.createBuffer(bufferCreateInfo);
}
MemoryAllocation* allocation = GetFreeMemoryAllocation(size, memoryRequirements.alignment, memtype);
uint32_t offset = Utils::Align(allocation->used, memoryRequirements.alignment);
device->device.bindBufferMemory(buffer, allocation->memory, offset);
allocation->used += size + (offset - allocation->used);
return ManagedBufferPtr{ new ManagedBuffer({allocation, offset, size, buffer, usage, properties, nullptr}) };
}
MemoryPool::ManagedBufferPtr MemoryPool::CreateSharedMemoryBuffer(size_t size)
{
if (!recycleBuffers.empty())
{
for(auto buff : recycleBuffers)
{
if (buff->size == size)
{
Logger::DATA->info("Recycle Buffer");
Utils::Remove(recycleBuffers, buff);
return ManagedBufferPtr{ buff };
}
}
}
return CreateBuffer(size, vk::BufferUsageFlagBits::eVertexBuffer, vk::MemoryPropertyFlagBits::eHostCoherent/* | vk::MemoryPropertyFlagBits::eDeviceLocal*/);
}
}

66
openVulkanoCpp/Vulkan/Resources/MemoryPool.hpp Normal file
View File

@@ -0,0 +1,66 @@
/*
* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at https://mozilla.org/MPL/2.0/.
*/
#pragma once
#include "Data/Containers/Array.hpp"
#include <functional>
#include <memory>
#include <vector>
#include <vulkan/vulkan.hpp>
namespace OpenVulkano::Vulkan
{
class Device;
class MemoryAllocation;
class ManagedBuffer;
struct ManagedBufferDeleter;
class MemoryPool
{
Device* device;
std::vector<std::unique_ptr<MemoryAllocation>> allocations;
Array<std::vector<ManagedBuffer*>> toFree;
std::vector<ManagedBuffer*> recycleBuffers;
std::function<void(ManagedBuffer*)> freeFunction;
uint64_t currentBuffer = 0;
void DoFree(ManagedBuffer* buffer);
bool FreeBuffer(ManagedBuffer* buffer);
public:
using ManagedBufferPtr = std::unique_ptr<ManagedBuffer, ManagedBufferDeleter>;
MemoryPool() = default;
~MemoryPool();
void Init(Device* dev, int bufferCount);
void Close();
void StartFrame(uint64_t bufferId);
MemoryAllocation* CreateMemoryAllocation(size_t size, uint32_t type, bool addToCache = true);
MemoryAllocation* GetFreeMemoryAllocation(size_t size, vk::DeviceSize alignment, uint32_t type, bool createIfAllFull = true);
ManagedBufferPtr CreateBuffer(vk::DeviceSize size, const vk::BufferUsageFlags& usage, const vk::MemoryPropertyFlags& properties);
ManagedBufferPtr CreateSharedMemoryBuffer(size_t size);
static void ReleaseBuffer(ManagedBuffer* buffer);
};
struct ManagedBufferDeleter
{
void operator()(ManagedBuffer* buffer)
{
MemoryPool::ReleaseBuffer(buffer);
}
};
}

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

@@ -5,10 +5,13 @@
*/
#include "ResourceManager.hpp"
#include "ManagedBuffer.hpp"
#include "MemoryAllocation.hpp"
#include "Scene/Vertex.hpp"
#include "Scene/Geometry.hpp"
#include "Scene/Material.hpp"
#include "Scene/UniformBuffer.hpp"
#include "Scene/Camera.hpp"
#include "Math/ByteSize.hpp"
#include "Vulkan/Context.hpp"
#include "Vulkan/Image.hpp"
@@ -23,10 +26,33 @@ namespace OpenVulkano::Vulkan
{
ResourceManager* ResourceManager::INSTANCE;
struct ResourceManager::FrameResources
{
vk::Device device;
vk::CommandPool cmdPool;
vk::CommandBuffer cmdBuffer;
vk::Semaphore semaphore;
FrameResources(Device* device)
{
this->device = device->device;
cmdPool = this->device.createCommandPool({ {}, device->queueIndices.transfer });
cmdBuffer = this->device.allocateCommandBuffers({ cmdPool, vk::CommandBufferLevel::ePrimary, 1 })[0];
semaphore = this->device.createSemaphore({});
}
~FrameResources()
{
device.freeCommandBuffers(cmdPool, 1, &cmdBuffer);
device.destroyCommandPool(cmdPool);
device.destroy(semaphore);
}
};
ResourceManager::ResourceManager()
{
static_assert(sizeof(DescriptorSetLayoutBinding) == sizeof(vk::DescriptorSetLayoutBinding));
freeFunction = [this](ManagedBuffer* buffer) { this->FreeBuffer(buffer); };
}
ResourceManager::~ResourceManager() noexcept
@@ -37,21 +63,13 @@ namespace OpenVulkano::Vulkan
void ResourceManager::Init(Context* context, int buffers)
{
this->context = context;
this->device = context->device->device;
this->buffers = buffers;
device = context->device->device;
uniformBufferAlignment = context->device->properties.limits.minUniformBufferOffsetAlignment;
frameResources = Array<FrameResources>(static_cast<size_t>(buffers), context->device.get());
cmdPools = new vk::CommandPool[buffers];
cmdBuffers = new vk::CommandBuffer[buffers];
semaphores = new vk::Semaphore[buffers];
for (int i = 0; i < buffers; i++)
{
cmdPools[i] = this->device.createCommandPool({ {}, context->device->queueIndices.transfer });
cmdBuffers[i] = this->device.allocateCommandBuffers({ cmdPools[i], vk::CommandBufferLevel::ePrimary, 1 })[0];
semaphores[i] = this->device.createSemaphore({});
}
toFree.resize(buffers);
memPool.Init(context->device.get(), buffers);
transferQueue = this->device.getQueue(context->device->queueIndices.transfer, 0);
@@ -78,49 +96,44 @@ namespace OpenVulkano::Vulkan
void ResourceManager::Close()
{
transferQueue.waitIdle();
for (int i = 0; i < buffers; i++)
{
device.freeCommandBuffers(cmdPools[i], 1, &cmdBuffers[i]);
device.destroyCommandPool(cmdPools[i]);
device.destroy(semaphores[i]);
}
cmdPools = nullptr;
cmdBuffers = nullptr;
semaphores = nullptr;
transferQueue = nullptr;
geometries.clear();
nodes.clear();
textures.clear();
cameras.clear();
uniforms.clear();
device.destroyDescriptorPool(descriptorPool);
allocations.clear();
lastAllocation = nullptr;
toFree.clear();
recycleBuffers.clear();
descriptorSetLayoutCache.clear();
for (auto& sampler : samplerCache)
{
device.destroy(sampler.second);
}
samplerCache.clear();
for(auto& layout : descriptorSetLayoutCache)
{
device.destroy(layout.second);
}
descriptorSetLayoutCache.clear();
shaders.clear();
cmdBuffers = nullptr;
cmdPools = nullptr;
transferQueue = nullptr;
memPool.Close();
device = nullptr;
}
vk::CommandBuffer& ResourceManager::GetCmdBuffer() { return frameResources[currentBuffer].cmdBuffer; }
void ResourceManager::StartFrame(uint64_t frameId)
{
currentBuffer = frameId;
FreeBuffers();
device.resetCommandPool(cmdPools[currentBuffer], {});
cmdBuffers[currentBuffer].begin({ vk::CommandBufferUsageFlagBits::eOneTimeSubmit });
memPool.StartFrame(frameId);
device.resetCommandPool(frameResources[currentBuffer].cmdPool, {});
GetCmdBuffer().begin({ vk::CommandBufferUsageFlagBits::eOneTimeSubmit });
}
vk::Semaphore ResourceManager::EndFrame()
{
cmdBuffers[currentBuffer].end();
vk::SubmitInfo si = { 0, nullptr, nullptr, 1, &cmdBuffers[currentBuffer], 1, &semaphores[currentBuffer] };
GetCmdBuffer().end();
vk::SubmitInfo si = { 0, nullptr, nullptr, 1, &frameResources[currentBuffer].cmdBuffer, 1, &frameResources[currentBuffer].semaphore };
transferQueue.submit(1, &si, vk::Fence());
return semaphores[currentBuffer];
return frameResources[currentBuffer].semaphore;
}
void ResourceManager::Resize()
@@ -136,12 +149,10 @@ namespace OpenVulkano::Vulkan
const std::unique_lock lock(mutex);
if(!geometry->renderGeo)
{
ManagedBuffer::Ptr vertexBuffer(
CreateDeviceOnlyBufferWithData(sizeof(Vertex) * geometry->GetVertexCount(), vk::BufferUsageFlagBits::eVertexBuffer, geometry->GetVertices()),
freeFunction);
ManagedBuffer::Ptr indexBuffer(
CreateDeviceOnlyBufferWithData(Utils::EnumAsInt(geometry->indexType) * geometry->GetIndexCount(), vk::BufferUsageFlagBits::eIndexBuffer, geometry->GetIndices()),
freeFunction);
ManagedBuffer::Ptr vertexBuffer =
CreateDeviceOnlyBufferWithData(sizeof(Vertex) * geometry->GetVertexCount(), vk::BufferUsageFlagBits::eVertexBuffer, geometry->GetVertices());
ManagedBuffer::Ptr 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;
@@ -164,7 +175,7 @@ namespace OpenVulkano::Vulkan
if (!node->renderNode)
{
UniformBuffer* uBuffer = new UniformBuffer();
ManagedBuffer* buffer;
ManagedBuffer::Ptr buffer;
VulkanNode* vkNode;
const vk::DeviceSize allocSize = Utils::Align(sizeof(Math::Matrix4f), uniformBufferAlignment);
vk::DeviceSize frameSize = 0;
@@ -173,7 +184,7 @@ namespace OpenVulkano::Vulkan
frameSize = allocSize;
vkNode = new VulkanNodeDynamic();
const uint32_t imgs = context->swapChain.GetImageCount();
buffer = CreateBuffer(imgs * allocSize, vk::BufferUsageFlagBits::eUniformBuffer, vk::MemoryPropertyFlagBits::eHostCoherent | vk::MemoryPropertyFlagBits::eHostVisible);
buffer = memPool.CreateBuffer(imgs * allocSize, vk::BufferUsageFlagBits::eUniformBuffer, vk::MemoryPropertyFlagBits::eHostCoherent | vk::MemoryPropertyFlagBits::eHostVisible);
buffer->Map();
}
else
@@ -182,7 +193,7 @@ namespace OpenVulkano::Vulkan
buffer = CreateDeviceOnlyBufferWithData(Scene::Node::SIZE, vk::BufferUsageFlagBits::eUniformBuffer, &node->worldMat);
}
uBuffer->Init(buffer, frameSize, allocSize, GetDescriptorLayoutSet(Scene::Node::DESCRIPTOR_SET_LAYOUT_BINDING), Scene::Node::DESCRIPTOR_SET_LAYOUT_BINDING, 0);
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);
@@ -197,12 +208,13 @@ namespace OpenVulkano::Vulkan
{
const vk::DeviceSize allocSize = Utils::Align(Scene::Camera::SIZE, uniformBufferAlignment);
const uint32_t imgs = context->swapChain.GetImageCount();
ManagedBuffer* buffer = CreateBuffer(imgs * allocSize, vk::BufferUsageFlagBits::eUniformBuffer, vk::MemoryPropertyFlagBits::eHostCoherent | vk::MemoryPropertyFlagBits::eHostVisible);
ManagedBuffer::Ptr buffer = memPool.CreateBuffer(imgs * allocSize, vk::BufferUsageFlagBits::eUniformBuffer, vk::MemoryPropertyFlagBits::eHostCoherent | vk::MemoryPropertyFlagBits::eHostVisible);
buffer->Map();
UniformBuffer* uBuffer = new UniformBuffer();
uBuffer->Init(buffer, allocSize, allocSize, GetDescriptorLayoutSet(Scene::Camera::DESCRIPTOR_SET_LAYOUT_BINDING), Scene::Camera::DESCRIPTOR_SET_LAYOUT_BINDING, 1);
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);
cameras.emplace_back(vkCam);
camera->renderCamera = vkCam;
}
return static_cast<VulkanCamera*>(camera->renderCamera);
@@ -216,7 +228,7 @@ namespace OpenVulkano::Vulkan
auto buffer = CreateDeviceOnlyBufferWithData(allocSize, vk::BufferUsageFlagBits::eUniformBuffer, data);
UniformBuffer* uBuffer = new UniformBuffer();
uBuffer->Init(buffer, 0, allocSize, GetDescriptorLayoutSet(binding), binding, setId);
uBuffer->Init(std::move(buffer), 0, allocSize, GetDescriptorLayoutSet(binding), binding, setId);
return uBuffer;
}
@@ -231,28 +243,15 @@ namespace OpenVulkano::Vulkan
return &layout;
}
ManagedBuffer* ResourceManager::CreateSharedMemoryBuffer(const size_t size)
MemoryPool::ManagedBufferPtr ResourceManager::CreateSharedMemoryBuffer(const size_t size)
{
const std::unique_lock lock(mutex);
if (!recycleBuffers.empty())
{
for(auto buff : recycleBuffers)
{
if (buff->size == size)
{
Logger::DATA->info("Recycle Buffer");
Utils::Remove(recycleBuffers, buff);
return buff;
}
}
}
ManagedBuffer* buffer = CreateBuffer(size, vk::BufferUsageFlagBits::eVertexBuffer, vk::MemoryPropertyFlagBits::eHostCoherent/* | vk::MemoryPropertyFlagBits::eDeviceLocal*/);
return buffer;
return memPool.CreateSharedMemoryBuffer(size);
}
void ResourceManager::RemoveShader(VulkanShader* shader)
{
if (!cmdPools) return;
if (!transferQueue) return;
const std::unique_lock lock(mutex);
std::vector<std::unique_ptr<VulkanShader>>::iterator object =
find_if(shaders.begin(), shaders.end(),
@@ -261,121 +260,31 @@ namespace OpenVulkano::Vulkan
shaders.erase(object);
}
void ResourceManager::FreeBuffer(ManagedBuffer* buffer)
{
if (buffer)
toFree[currentBuffer].push_back(buffer);
}
void ResourceManager::DoFreeBuffer(ManagedBuffer* buffer)
{
if (buffer->IsLast())
{
device.destroyBuffer(buffer->buffer);
buffer->allocation->used -= buffer->size;
}
else
{
recycleBuffers.push_back(buffer);
}
}
void ResourceManager::FreeBuffers()
{
for (auto& i : toFree[currentBuffer])
{
DoFreeBuffer(i);
}
toFree[currentBuffer].clear();
}
void ResourceManager::CopyDataToImage(vk::DeviceSize size, void* data, Image* image)
{
ManagedBuffer* uploadBuffer = CreateBuffer(size, vk::BufferUsageFlagBits::eTransferSrc, vk::MemoryPropertyFlagBits::eHostCoherent | vk::MemoryPropertyFlagBits::eHostVisible);
ManagedBuffer::Ptr uploadBuffer = memPool.CreateBuffer(size, vk::BufferUsageFlagBits::eTransferSrc, vk::MemoryPropertyFlagBits::eHostCoherent | vk::MemoryPropertyFlagBits::eHostVisible);
uploadBuffer->Copy(data, size, 0);
image->SetLayout(cmdBuffers[currentBuffer], vk::ImageAspectFlagBits::eColor, vk::ImageLayout::eTransferDstOptimal);
image->SetLayout(GetCmdBuffer(), vk::ImageAspectFlagBits::eColor, vk::ImageLayout::eTransferDstOptimal);
vk::BufferImageCopy region(0, 0, 0, { vk::ImageAspectFlagBits::eColor, 0, 0, 1 }, { 0, 0, 0 }, image->extent);
cmdBuffers[currentBuffer].copyBufferToImage(uploadBuffer->buffer, image->image, vk::ImageLayout::eTransferDstOptimal, 1, &region);
GetCmdBuffer().copyBufferToImage(uploadBuffer->buffer, image->image, vk::ImageLayout::eTransferDstOptimal, 1, &region);
/*vk::ImageMemoryBarrier barrier {};
barrier.oldLayout = vk::ImageLayout::eUndefined;
barrier.newLayout = vk::ImageLayout::eShaderReadOnlyOptimal;
barrier.image = image->image;
barrier.subresourceRange.aspectMask = vk::ImageAspectFlagBits::eColor;
barrier.subresourceRange.baseMipLevel = 0;
barrier.subresourceRange.levelCount = 1;
barrier.subresourceRange.baseArrayLayer = 0;
barrier.subresourceRange.layerCount = 1;
barrier.setSrcAccessMask({});
barrier.setDstAccessMask(vk::AccessFlagBits::eTransferWrite);*/
image->SetLayout(cmdBuffers[currentBuffer], vk::ImageAspectFlagBits::eColor, vk::ImageLayout::eShaderReadOnlyOptimal, vk::ImageLayout::eTransferDstOptimal);
image->SetLayout(GetCmdBuffer(), vk::ImageAspectFlagBits::eColor, vk::ImageLayout::eShaderReadOnlyOptimal, vk::ImageLayout::eTransferDstOptimal);
// TODO set access masks for mip and array layers
//cmdBuffers[currentBuffer].pipelineBarrier(vk::PipelineStageFlagBits::eTopOfPipe, vk::PipelineStageFlagBits::eTransfer, {}, 0, nullptr, 0, nullptr, 1, &barrier );
FreeBuffer(uploadBuffer);
//GetCmdBuffer().pipelineBarrier(vk::PipelineStageFlagBits::eTopOfPipe, vk::PipelineStageFlagBits::eTransfer, {}, 0, nullptr, 0, nullptr, 1, &barrier );
}
ManagedBuffer* ResourceManager::CreateDeviceOnlyBufferWithData(vk::DeviceSize size, vk::BufferUsageFlagBits usage, const void* data)
ManagedBuffer::Ptr ResourceManager::CreateDeviceOnlyBufferWithData(vk::DeviceSize size, vk::BufferUsageFlagBits usage, const void* data)
{
ManagedBuffer* target = CreateBuffer(size, usage | vk::BufferUsageFlagBits::eTransferDst, vk::MemoryPropertyFlagBits::eDeviceLocal);
ManagedBuffer* uploadBuffer = CreateBuffer(size, vk::BufferUsageFlagBits::eTransferSrc, vk::MemoryPropertyFlagBits::eHostCoherent | vk::MemoryPropertyFlagBits::eHostVisible);
ManagedBuffer::Ptr target = memPool.CreateBuffer(size, usage | vk::BufferUsageFlagBits::eTransferDst, vk::MemoryPropertyFlagBits::eDeviceLocal);
ManagedBuffer::Ptr uploadBuffer = memPool.CreateBuffer(size, vk::BufferUsageFlagBits::eTransferSrc, vk::MemoryPropertyFlagBits::eHostCoherent | vk::MemoryPropertyFlagBits::eHostVisible);
uploadBuffer->Copy(data, size, 0);
RecordCopy(uploadBuffer->buffer, target->buffer, size);
FreeBuffer(uploadBuffer);
return target;
}
ManagedBuffer* ResourceManager::CreateBuffer(vk::DeviceSize size, const vk::BufferUsageFlags& usage, const vk::MemoryPropertyFlags& properties)
{
size = Utils::Align(size, 16);
vk::BufferCreateInfo bufferCreateInfo = { {}, size, usage, vk::SharingMode::eExclusive };
vk::Buffer buffer = device.createBuffer(bufferCreateInfo);
const vk::MemoryRequirements memoryRequirements = device.getBufferMemoryRequirements(buffer);
uint32_t memtype = context->device->GetMemoryType(memoryRequirements.memoryTypeBits, properties);
if (memoryRequirements.size != size)
{
Logger::DATA->debug("Memory Requirement Size ({0}) != Size ({1})", memoryRequirements.size, size);
size = memoryRequirements.size;
device.destroy(buffer);
bufferCreateInfo.size = size;
buffer = device.createBuffer(bufferCreateInfo);
}
MemoryAllocation* allocation = GetFreeMemoryAllocation(size, memoryRequirements.alignment, memtype);
uint32_t offset = Utils::Align(allocation->used, memoryRequirements.alignment);
device.bindBufferMemory(buffer, allocation->memory, offset);
allocation->used += size + (offset - allocation->used);
return new ManagedBuffer{ allocation, offset, size, buffer, usage, properties, nullptr };
}
MemoryAllocation* ResourceManager::CreateMemoryAllocation(size_t size, uint32_t type, bool addToCache)
{
MemoryAllocation* alloc = new MemoryAllocation(size, type, device);
const vk::MemoryAllocateInfo allocInfo = { size, type };
alloc->memory = device.allocateMemory(allocInfo);
if (addToCache) allocations.emplace_back(alloc);
return alloc;
}
MemoryAllocation* ResourceManager::GetFreeMemoryAllocation(size_t size, vk::DeviceSize alignment, uint32_t type, bool createIfAllFull)
{
MemoryAllocation* alloc = nullptr;
for (auto& allocation : allocations)
{
if (allocation->type == type && allocation->FreeSpace(alignment) >= size)
{
alloc = allocation.get();
break;
}
}
if(!alloc && createIfAllFull) alloc = CreateMemoryAllocation(64_MiB, type, true);
if(alloc) lastAllocation = alloc;
return alloc;
}
VulkanShader* ResourceManager::CreateShader(Scene::Shader* shader)
{
const std::unique_lock lock(mutex);
@@ -398,6 +307,8 @@ namespace OpenVulkano::Vulkan
vkTexture->Init(this, texture, GetDescriptorLayoutSet(Scene::Texture::DESCRIPTOR_SET_LAYOUT_BINDING), Scene::Texture::DESCRIPTOR_SET_LAYOUT_BINDING);
textures.emplace_back(vkTexture);
return vkTexture;
}
@@ -407,7 +318,7 @@ namespace OpenVulkano::Vulkan
if (buffer->renderBuffer) return static_cast<VulkanUniformBuffer*>(buffer->renderBuffer);
VulkanUniformBuffer* vkBuffer;
ManagedBuffer* mBuffer;
ManagedBuffer::Ptr mBuffer;
const vk::DeviceSize allocSize = Utils::Align(buffer->size, uniformBufferAlignment);
vk::DeviceSize frameSize = 0;
if (buffer->GetUpdateFrequency() != Scene::UpdateFrequency::Never)
@@ -415,7 +326,7 @@ namespace OpenVulkano::Vulkan
frameSize = allocSize;
vkBuffer = new VulkanUniformBufferDynamic();
const uint32_t imgs = context->swapChain.GetImageCount();
mBuffer = CreateBuffer(imgs * allocSize, vk::BufferUsageFlagBits::eUniformBuffer, vk::MemoryPropertyFlagBits::eHostCoherent | vk::MemoryPropertyFlagBits::eHostVisible);
mBuffer = memPool.CreateBuffer(imgs * allocSize, vk::BufferUsageFlagBits::eUniformBuffer, vk::MemoryPropertyFlagBits::eHostCoherent | vk::MemoryPropertyFlagBits::eHostVisible);
mBuffer->Map();
}
else
@@ -427,9 +338,11 @@ namespace OpenVulkano::Vulkan
UniformBuffer* uBuffer = new UniformBuffer();
uBuffer->Init(mBuffer, 0, mBuffer->size, GetDescriptorLayoutSet(buffer->binding), buffer->binding, buffer->setId);
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;
}

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

@@ -7,18 +7,19 @@
#pragma once
// Workaround for libc++
#ifndef __cpp_lib_three_way_comparison
#define __cpp_lib_three_way_comparison 201907
#endif
#include "vulkan/vulkan.hpp"
#include "Base/ICloseable.hpp"
#include "IShaderOwner.hpp"
#include "ManagedResource.hpp"
#include "MemoryPool.hpp"
#include "Base/Wrapper.hpp"
#include "Vulkan/Image.hpp"
#include "Scene/Shader/DescriptorInputDescription.hpp"
#include "Scene/Camera.hpp"
#include <mutex>
#include <functional>
#include <vulkan/vulkan.hpp>
#include <map>
#include <memory>
#include <mutex>
namespace OpenVulkano
{
@@ -29,6 +30,7 @@ namespace OpenVulkano
class Material;
class Texture;
class Shader;
class Camera;
class UniformBuffer;
}
@@ -39,35 +41,39 @@ namespace OpenVulkano
class VulkanTexture;
class VulkanCamera;
class VulkanNode;
class VulkanShader;
class VulkanUniformBuffer;
class UniformBuffer;
class ManagedBuffer;
class MemoryAllocation;
class ResourceManager : public ICloseable, public IShaderOwner
class ResourceManager : public IShaderOwner
{
friend UniformBuffer;
friend VulkanTexture;
struct FrameResources;
Context* context;
vk::Device device = nullptr;
vk::Queue transferQueue = nullptr;
vk::CommandPool* cmdPools = nullptr;
vk::CommandBuffer* cmdBuffers = nullptr;
vk::Semaphore* semaphores = nullptr;
std::vector<std::unique_ptr<MemoryAllocation>> allocations;
std::vector<std::unique_ptr<VulkanShader>> shaders;
std::vector<std::unique_ptr<VulkanGeometry>> geometries;
std::vector<std::unique_ptr<VulkanNode>> nodes;
MemoryAllocation* lastAllocation = nullptr;
Array<FrameResources> frameResources;
MemoryPool memPool;
std::vector<Unique<VulkanShader>> shaders;
std::vector<Unique<VulkanGeometry>> geometries;
std::vector<Unique<VulkanNode>> nodes;
std::vector<Unique<VulkanTexture>> textures;
std::vector<Unique<VulkanCamera>> cameras;
std::vector<Unique<VulkanUniformBuffer>> uniforms;
std::mutex mutex;
vk::DeviceSize uniformBufferAlignment;
std::vector<std::vector<ManagedBuffer*>> toFree;
std::vector<ManagedBuffer*> recycleBuffers;
std::function<void(ManagedBuffer*)> freeFunction;
vk::DescriptorPool descriptorPool;
std::map<DescriptorSetLayoutBinding, vk::DescriptorSetLayout> descriptorSetLayoutCache;
std::map<vk::SamplerCreateInfo, vk::Sampler> samplerCache;
int buffers = -1, currentBuffer = -1;
int currentBuffer = -1;
vk::CommandBuffer& GetCmdBuffer();
public:
static ResourceManager* INSTANCE;
@@ -78,7 +84,7 @@ namespace OpenVulkano
void Init(Context* context, int buffers = 2);
void Close() override;
void Close();
void StartFrame(uint64_t frameId);
@@ -102,9 +108,7 @@ namespace OpenVulkano
void CopyDataToImage(vk::DeviceSize size, void* data, OpenVulkano::Vulkan::Image* image);
ManagedBuffer* CreateSharedMemoryBuffer(size_t size);
void FreeBuffer(ManagedBuffer* buffer);
MemoryPool::ManagedBufferPtr CreateSharedMemoryBuffer(size_t size);
[[nodiscard]] Context* GetContext() const { return context; }
@@ -115,23 +119,13 @@ namespace OpenVulkano
vk::Sampler CreateSampler(const vk::SamplerCreateInfo& samplerConfig);
protected: // Allocation management
void DoFreeBuffer(ManagedBuffer* buffer);
MemoryPool::ManagedBufferPtr CreateDeviceOnlyBufferWithData(vk::DeviceSize size, vk::BufferUsageFlagBits usage, const void* data);
void FreeBuffers();
ManagedBuffer* CreateDeviceOnlyBufferWithData(vk::DeviceSize size, vk::BufferUsageFlagBits usage, const void* data);
inline void RecordCopy(vk::Buffer src, vk::Buffer dest, vk::DeviceSize size) const
inline void RecordCopy(vk::Buffer src, vk::Buffer dest, vk::DeviceSize size)
{
vk::BufferCopy copyRegion = { 0, 0, size };
cmdBuffers[currentBuffer].copyBuffer(src, dest, 1, &copyRegion);
GetCmdBuffer().copyBuffer(src, dest, 1, &copyRegion);
}
ManagedBuffer* CreateBuffer(vk::DeviceSize size, const vk::BufferUsageFlags& usage, const vk::MemoryPropertyFlags& properties);
MemoryAllocation* CreateMemoryAllocation(size_t size, uint32_t type, bool addToCache = true);
MemoryAllocation* GetFreeMemoryAllocation(size_t size, vk::DeviceSize alignment, uint32_t type, bool createIfAllFull = true);
public:
vk::DescriptorSetLayout* GetDescriptorLayoutSet(const DescriptorSetLayoutBinding& descriptorSetLayoutBinding);

12
openVulkanoCpp/Vulkan/Resources/UniformBuffer.cpp
View File

@@ -5,25 +5,25 @@
*/
#include "UniformBuffer.hpp"
#include "ManagedResource.hpp"
#include "ManagedBuffer.hpp"
#include "ResourceManager.hpp"
#include "Vulkan/VulkanDrawContext.hpp"
#include "Vulkan/Scene/VulkanShader.hpp"
namespace OpenVulkano::Vulkan
{
void UniformBuffer::Init(ManagedBuffer* buffer, uint32_t frameOffset, uint32_t frameSize, vk::DescriptorSetLayout* descriptorSetLayout, const DescriptorSetLayoutBinding& binding, uint32_t setId)
void UniformBuffer::Init(ManagedBuffer::Ptr buffer, uint32_t frameOffset, uint32_t frameSize, vk::DescriptorSetLayout* descriptorSetLayout, const DescriptorSetLayoutBinding& binding, uint32_t setId)
{
m_buffer = buffer;
m_buffer = std::move(buffer);
m_frameOffset = frameOffset;
const vk::DescriptorSetAllocateInfo descSetAllocInfo = { ResourceManager::INSTANCE->descriptorPool, 1, descriptorSetLayout };
m_descriptorSet = buffer->allocation->device.allocateDescriptorSets(descSetAllocInfo)[0];
vk::DescriptorBufferInfo bufferInfo = { buffer->buffer, 0, frameSize };
m_descriptorSet = m_buffer->allocation->device.allocateDescriptorSets(descSetAllocInfo)[0];
vk::DescriptorBufferInfo bufferInfo = { m_buffer->buffer, 0, frameSize };
vk::WriteDescriptorSet writeDescriptorSet = { m_descriptorSet, binding.bindingId, 0, 1 };
writeDescriptorSet.descriptorType = static_cast<vk::DescriptorType>(binding.descriptorType);
writeDescriptorSet.pBufferInfo = &bufferInfo;
buffer->allocation->device.updateDescriptorSets(1, &writeDescriptorSet, 0, nullptr);
m_buffer->allocation->device.updateDescriptorSets(1, &writeDescriptorSet, 0, nullptr);
m_setOffset = setId;
m_dynamic = binding.descriptorType == DescriptorSetLayoutBinding::TYPE_UNIFORM_BUFFER_DYNAMIC || binding.descriptorType == DescriptorSetLayoutBinding::TYPE_STORAGE_BUFFER_DYNAMIC;
}

7
openVulkanoCpp/Vulkan/Resources/UniformBuffer.hpp
View File

@@ -7,15 +7,16 @@
#pragma once
#include "Base/ICloseable.hpp"
#include "Vulkan/Resources/ManagedBuffer.hpp"
#include "Vulkan/Scene/IRecordable.hpp"
namespace OpenVulkano::Vulkan
{
struct ManagedBuffer;
class ManagedBuffer;
class UniformBuffer final : public IRecordable, public ICloseable
{
ManagedBuffer* m_buffer = nullptr;
ManagedBuffer::Ptr m_buffer = nullptr;
vk::DescriptorSet m_descriptorSet;
uint32_t m_frameOffset;
uint32_t m_setOffset, m_setCount = 1;
@@ -27,7 +28,7 @@ namespace OpenVulkano::Vulkan
if (m_buffer) Close();
}
void Init(ManagedBuffer* buffer, uint32_t frameOffset, uint32_t frameSize, vk::DescriptorSetLayout* descriptorSetLayout, const DescriptorSetLayoutBinding& binding, uint32_t setId);
void Init(ManagedBuffer::Ptr buffer, uint32_t frameOffset, uint32_t frameSize, vk::DescriptorSetLayout* descriptorSetLayout, const DescriptorSetLayoutBinding& binding, uint32_t setId);
void Close() override;

5
openVulkanoCpp/Vulkan/Scene/VulkanCamera.hpp
View File

@@ -18,6 +18,8 @@ namespace OpenVulkano::Vulkan
UniformBuffer* m_buffer = nullptr;
public:
~VulkanCamera() override { if (m_camera) VulkanCamera::Close(); }
void Init(Scene::Camera* camera, UniformBuffer* uniformBuffer)
{
m_camera = camera;
@@ -32,7 +34,10 @@ namespace OpenVulkano::Vulkan
void Close() override
{
m_camera->renderCamera = nullptr;
m_buffer->Close();
m_camera = nullptr;
delete m_buffer;
}
};
}

6
openVulkanoCpp/Vulkan/Scene/VulkanGeometry.hpp
View File

@@ -9,7 +9,7 @@
#include "IRecordable.hpp"
#include "Scene/Scene.hpp"
#include "Scene/Geometry.hpp"
#include "Vulkan/Resources/ManagedResource.hpp"
#include "Vulkan/Resources/ManagedBuffer.hpp"
namespace OpenVulkano::Vulkan
{
@@ -22,8 +22,8 @@ namespace OpenVulkano::Vulkan
vk::DeviceSize m_offsets = 0;
public:
VulkanGeometry() : m_geometry(nullptr), m_vertexBuffer(nullptr, nullptr)
, m_indexBuffer(nullptr, nullptr), m_indexType(vk::IndexType::eUint32)
VulkanGeometry() : m_geometry(nullptr), m_vertexBuffer(nullptr)
, m_indexBuffer(nullptr), m_indexType(vk::IndexType::eUint32)
{}
VulkanGeometry(Scene::Geometry* geo, ManagedBuffer::Ptr& vertexBuffer, ManagedBuffer::Ptr& indexBuffer)

3
openVulkanoCpp/Vulkan/Scene/VulkanShader.hpp
View File

@@ -23,8 +23,9 @@ namespace OpenVulkano
class Context;
class IShaderOwner;
struct VulkanShader final : public ICloseable, public IRecordable
class VulkanShader final : public ICloseable, public IRecordable
{
public:
Scene::Shader* shader = nullptr;
vk::Device device;
std::vector<vk::ShaderModule> shaderModules; // TODO manage live time somewhere else to allow sharing of shader programs

5
openVulkanoCpp/Vulkan/Scene/VulkanTexture.hpp
View File

@@ -37,6 +37,11 @@ namespace OpenVulkano::Vulkan
texture->renderTexture = this;
}
virtual ~VulkanTexture() override
{
if (m_texture) Close();
}
void Close() override
{
Image::Close();

9
openVulkanoCpp/Vulkan/SwapChain.cpp
View File

@@ -10,7 +10,6 @@
#include "Base/UI/IVulkanWindow.hpp"
#include "Base/EngineConfiguration.hpp"
#include "Scene/DataFormat.hpp"
#include <algorithm>
namespace OpenVulkano::Vulkan
{
@@ -25,13 +24,17 @@ namespace OpenVulkano::Vulkan
CreateSwapChain({window->GetWidth(), window->GetHeight() });
FrameBuffer::Init(device, vk::Extent3D(size, 1));
Logger::RENDER->trace("Initialized swapchain");
}
void SwapChain::Close()
{
FrameBuffer::Close();
DestroySwapChain();
device = nullptr;
FrameBuffer::Close();
window = nullptr;
Logger::RENDER->trace("Closed swapchain");
}
void SwapChain::Resize(const uint32_t newWidth, const uint32_t newHeight)
@@ -40,6 +43,7 @@ namespace OpenVulkano::Vulkan
CreateSwapChain({ newWidth, newHeight });
FrameBuffer::Resize(vk::Extent3D(size, 1));
Logger::RENDER->trace("Resized swapchain");
}
uint32_t SwapChain::AcquireNextImage(const vk::Fence& fence)
@@ -141,6 +145,7 @@ namespace OpenVulkano::Vulkan
for (auto& semaphore : imageAvailableSemaphores)
device->device.destroySemaphore(semaphore);
imageAvailableSemaphores.clear();
Logger::RENDER->trace("Destroyed swapchain");
}
vk::PresentModeKHR SwapChain::ChosePresentMode()