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

No more shared pointers

Browse Source
This commit is contained in:
Dynamitos
2023-11-01 23:12:30 +01:00
parent 5a9cb13e74
commit 4746c0f838
69 changed files with 524 additions and 681 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/Engine/Graphics/Vulkan/Allocator.cpp
+1 -1
View File
@@ -43,7 +43,7 @@ void SubAllocation::invalidateMemory()
owner->invalidateMemory();
}
Allocation::Allocation(PGraphics graphics, Allocator *allocator, VkDeviceSize size, uint8 memoryTypeIndex,
Allocation::Allocation(PGraphics graphics, PAllocator allocator, VkDeviceSize size, uint8 memoryTypeIndex,
VkMemoryPropertyFlags properties, VkMemoryDedicatedAllocateInfo *dedicatedInfo)
: device(graphics->getDevice())
, allocator(allocator)
src/Engine/Graphics/Vulkan/Allocator.h
+5 -5
View File
@@ -95,11 +95,11 @@ public:
private:
VkDevice device;
Allocator *allocator;
PAllocator allocator;
VkDeviceSize bytesAllocated;
VkDeviceSize bytesUsed;
VkDeviceMemory allocatedMemory;
std::map<VkDeviceSize, SubAllocation *> activeAllocations;
std::map<VkDeviceSize, PSubAllocation> activeAllocations;
std::map<VkDeviceSize, PSubAllocation> freeRanges;
std::mutex lock;
void *mappedPointer;
@@ -118,9 +118,9 @@ class Allocator
public:
Allocator(PGraphics graphics);
~Allocator();
PSubAllocation allocate(const VkMemoryRequirements2 &requirements, VkMemoryPropertyFlags props,
OSubAllocation allocate(const VkMemoryRequirements2 &requirements, VkMemoryPropertyFlags props,
VkMemoryDedicatedAllocateInfo *dedicatedInfo = nullptr);
inline PSubAllocation allocate(const VkMemoryRequirements2 &requirements, VkMemoryPropertyFlags props,
OSubAllocation allocate(const VkMemoryRequirements2 &requirements, VkMemoryPropertyFlags props,
VkBuffer buffer)
{
VkMemoryDedicatedAllocateInfo allocInfo;
@@ -130,7 +130,7 @@ public:
allocInfo.image = VK_NULL_HANDLE;
return allocate(requirements, props, &allocInfo);
}
inline PSubAllocation allocate(const VkMemoryRequirements2 &requirements, VkMemoryPropertyFlags props,
OSubAllocation allocate(const VkMemoryRequirements2 &requirements, VkMemoryPropertyFlags props,
VkImage image)
{
VkMemoryDedicatedAllocateInfo allocInfo;
src/Engine/Graphics/Vulkan/Buffer.cpp
+48 -48
View File
@@ -12,9 +12,9 @@ struct PendingBuffer
bool bWriteOnly;
};
static std::map<Vulkan::ShaderBuffer *, PendingBuffer> pendingBuffers;
static std::map<Vulkan::Buffer*, PendingBuffer> pendingBuffers;
ShaderBuffer::ShaderBuffer(PGraphics graphics, uint64 size, VkBufferUsageFlags usage, Gfx::QueueType& queueType, bool bDynamic)
Buffer::Buffer(PGraphics graphics, uint64 size, VkBufferUsageFlags usage, Gfx::QueueType& queueType, bool bDynamic)
: graphics(graphics)
, currentBuffer(0)
, size(size)
@@ -57,7 +57,7 @@ ShaderBuffer::ShaderBuffer(PGraphics graphics, uint64 size, VkBufferUsageFlags u
}
}
ShaderBuffer::~ShaderBuffer()
Buffer::~Buffer()
{
//PCmdBuffer cmdBuffer = graphics->getQueueCommands(owner)->getCommands();
//VkDevice device = graphics->getDevice();
@@ -75,12 +75,12 @@ ShaderBuffer::~ShaderBuffer()
graphics = nullptr;
}
VkDeviceSize ShaderBuffer::getOffset() const
VkDeviceSize Buffer::getOffset() const
{
return buffers[currentBuffer].allocation->getOffset();
}
void ShaderBuffer::executeOwnershipBarrier(Gfx::QueueType newOwner)
void Buffer::executeOwnershipBarrier(Gfx::QueueType newOwner)
{
VkBufferMemoryBarrier barrier =
init::BufferMemoryBarrier();
@@ -146,7 +146,7 @@ void ShaderBuffer::executeOwnershipBarrier(Gfx::QueueType newOwner)
sourceManager->submitCommands();
}
void ShaderBuffer::executePipelineBarrier(VkAccessFlags srcAccess, VkPipelineStageFlags srcStage,
void Buffer::executePipelineBarrier(VkAccessFlags srcAccess, VkPipelineStageFlags srcStage,
VkAccessFlags dstAccess, VkPipelineStageFlags dstStage)
{
PCmdBuffer commandBuffer = graphics->getQueueCommands(owner)->getCommands();
@@ -166,12 +166,12 @@ void ShaderBuffer::executePipelineBarrier(VkAccessFlags srcAccess, VkPipelineSta
vkCmdPipelineBarrier(commandBuffer->getHandle(), srcStage, dstStage, 0, 0, nullptr, numBuffers, dynamicBarriers, 0, nullptr);
}
void *ShaderBuffer::lock(bool bWriteOnly)
void * Buffer::lock(bool bWriteOnly)
{
return lockRegion(0, size, bWriteOnly);
}
void *ShaderBuffer::lockRegion(uint64 regionOffset, uint64 regionSize, bool bWriteOnly)
void * Buffer::lockRegion(uint64 regionOffset, uint64 regionSize, bool bWriteOnly)
{
void *data = nullptr;
@@ -243,7 +243,7 @@ void *ShaderBuffer::lockRegion(uint64 regionOffset, uint64 regionSize, bool bWri
return data;
}
void ShaderBuffer::unlock()
void Buffer::unlock()
{
auto found = pendingBuffers.find(this);
if (found != pendingBuffers.end())
@@ -270,18 +270,18 @@ void ShaderBuffer::unlock()
}
UniformBuffer::UniformBuffer(PGraphics graphics, const UniformBufferCreateInfo &createInfo)
: Gfx::UniformBuffer(graphics->getFamilyMapping(), createInfo.resourceData)
, Vulkan::ShaderBuffer(graphics, createInfo.resourceData.size, VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT, currentOwner, createInfo.bDynamic)
: Gfx::UniformBuffer(graphics->getFamilyMapping(), createInfo.sourceData)
, Vulkan::Buffer(graphics, createInfo.sourceData.size, VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT, currentOwner, createInfo.bDynamic)
, dedicatedStagingBuffer(nullptr)
{
if(createInfo.bDynamic)
{
dedicatedStagingBuffer = graphics->getStagingManager()->allocateStagingBuffer(createInfo.resourceData.size, VK_BUFFER_USAGE_TRANSFER_SRC_BIT);
dedicatedStagingBuffer = graphics->getStagingManager()->allocateStagingBuffer(createInfo.sourceData.size, VK_BUFFER_USAGE_TRANSFER_SRC_BIT);
}
if (createInfo.resourceData.data != nullptr)
if (createInfo.sourceData.data != nullptr)
{
void *data = lock();
std::memcpy(data, createInfo.resourceData.data, createInfo.resourceData.size);
std::memcpy(data, createInfo.sourceData.data, createInfo.sourceData.size);
unlock();
}
}
@@ -290,15 +290,15 @@ UniformBuffer::~UniformBuffer()
{
}
bool UniformBuffer::updateContents(const BulkResourceData &resourceData)
bool UniformBuffer::updateContents(const DataSource &sourceData)
{
if(!Gfx::UniformBuffer::updateContents(resourceData))
if(!Gfx::UniformBuffer::updateContents(sourceData))
{
// no update was performed, skip
return false;
}
void* data = lock();
std::memcpy(data, resourceData.data, resourceData.size);
std::memcpy(data, sourceData.data, sourceData.size);
unlock();
return true;
}
@@ -308,7 +308,7 @@ void* UniformBuffer::lock(bool bWriteOnly)
{
return dedicatedStagingBuffer->getMappedPointer();
}
return ShaderBuffer::lock(bWriteOnly);
return Vulkan::Buffer::lock(bWriteOnly);
}
void UniformBuffer::unlock()
@@ -321,13 +321,13 @@ void UniformBuffer::unlock()
VkBufferCopy region;
std::memset(&region, 0, sizeof(VkBufferCopy));
region.size = ShaderBuffer::size;
region.size = Vulkan::Buffer::size;
vkCmdCopyBuffer(cmdHandle, dedicatedStagingBuffer->getHandle(), buffers[currentBuffer].buffer, 1, &region);
graphics->getQueueCommands(currentOwner)->submitCommands();
}
else
{
ShaderBuffer::unlock();
Vulkan::Buffer::unlock();
}
}
@@ -338,13 +338,13 @@ void UniformBuffer::requestOwnershipTransfer(Gfx::QueueType newOwner)
void UniformBuffer::executeOwnershipBarrier(Gfx::QueueType newOwner)
{
Vulkan::ShaderBuffer::executeOwnershipBarrier(newOwner);
Vulkan::Buffer::executeOwnershipBarrier(newOwner);
}
void UniformBuffer::executePipelineBarrier(VkAccessFlags srcAccess, VkPipelineStageFlags srcStage,
VkAccessFlags dstAccess, VkPipelineStageFlags dstStage)
{
Vulkan::ShaderBuffer::executePipelineBarrier(srcAccess, srcStage, dstAccess, dstStage);
Vulkan::Buffer::executePipelineBarrier(srcAccess, srcStage, dstAccess, dstStage);
}
VkAccessFlags UniformBuffer::getSourceAccessMask()
@@ -357,14 +357,14 @@ VkAccessFlags UniformBuffer::getDestAccessMask()
return VK_ACCESS_UNIFORM_READ_BIT;
}
ShaderBuffer::ShaderBuffer(PGraphics graphics, const ShaderBufferCreateInfo &resourceData)
: Gfx::ShaderBuffer(graphics->getFamilyMapping(), resourceData.stride, resourceData.resourceData.size / resourceData.stride, resourceData.resourceData)
, Vulkan::ShaderBuffer(graphics, resourceData.resourceData.size, VK_BUFFER_USAGE_STORAGE_BUFFER_BIT, currentOwner, resourceData.bDynamic)
ShaderBuffer::ShaderBuffer(PGraphics graphics, const ShaderBufferCreateInfo &sourceData)
: Gfx::ShaderBuffer(graphics->getFamilyMapping(), sourceData.stride, sourceData.sourceData.size / sourceData.stride, sourceData.sourceData)
, Vulkan::Buffer(graphics, sourceData.sourceData.size, VK_BUFFER_USAGE_STORAGE_BUFFER_BIT, currentOwner, sourceData.bDynamic)
{
if (resourceData.resourceData.data != nullptr)
if (sourceData.sourceData.data != nullptr)
{
void *data = lock();
std::memcpy(data, resourceData.resourceData.data, resourceData.resourceData.size);
std::memcpy(data, sourceData.sourceData.data, sourceData.sourceData.size);
unlock();
}
}
@@ -373,13 +373,13 @@ ShaderBuffer::~ShaderBuffer()
{
}
bool ShaderBuffer::updateContents(const BulkResourceData &resourceData)
bool ShaderBuffer::updateContents(const DataSource &sourceData)
{
assert(resourceData.size <= getSize());
Gfx::ShaderBuffer::updateContents(resourceData);
assert(sourceData.size <= getSize());
Gfx::ShaderBuffer::updateContents(sourceData);
//We always want to update, as the contents could be different on the GPU
void* data = lock();
std::memcpy(data, resourceData.data, resourceData.size);
std::memcpy(data, sourceData.data, sourceData.size);
unlock();
return true;
}
@@ -402,13 +402,13 @@ void ShaderBuffer::unlock()
VkBufferCopy region;
std::memset(&region, 0, sizeof(VkBufferCopy));
region.size = ShaderBuffer::size;
region.size = Vulkan::Buffer::size;
vkCmdCopyBuffer(cmdHandle, dedicatedStagingBuffer->getHandle(), buffers[currentBuffer].buffer, 1, &region);
graphics->getQueueCommands(currentOwner)->submitCommands();
}
else
{
ShaderBuffer::unlock();
Vulkan::Buffer::unlock();
}
}
@@ -438,14 +438,14 @@ VkAccessFlags ShaderBuffer::getDestAccessMask()
return VK_ACCESS_MEMORY_READ_BIT;
}
VertexBuffer::VertexBuffer(PGraphics graphics, const VertexBufferCreateInfo &resourceData)
: Gfx::VertexBuffer(graphics->getFamilyMapping(), resourceData.numVertices, resourceData.vertexSize, resourceData.resourceData.owner)
, Vulkan::ShaderBuffer(graphics, resourceData.resourceData.size, VK_BUFFER_USAGE_VERTEX_BUFFER_BIT, currentOwner)
VertexBuffer::VertexBuffer(PGraphics graphics, const VertexBufferCreateInfo &sourceData)
: Gfx::VertexBuffer(graphics->getFamilyMapping(), sourceData.numVertices, sourceData.vertexSize, sourceData.sourceData.owner)
, Vulkan::Buffer(graphics, sourceData.sourceData.size, VK_BUFFER_USAGE_VERTEX_BUFFER_BIT, currentOwner)
{
if (resourceData.resourceData.data != nullptr)
if (sourceData.sourceData.data != nullptr)
{
void *data = lock();
std::memcpy(data, resourceData.resourceData.data, resourceData.resourceData.size);
std::memcpy(data, sourceData.sourceData.data, sourceData.sourceData.size);
unlock();
}
}
@@ -454,7 +454,7 @@ VertexBuffer::~VertexBuffer()
{
}
void VertexBuffer::updateRegion(BulkResourceData update)
void VertexBuffer::updateRegion(DataSource update)
{
void* data = lockRegion(update.offset, update.size);
std::memcpy(data, update.data, update.size);
@@ -476,13 +476,13 @@ void VertexBuffer::requestOwnershipTransfer(Gfx::QueueType newOwner)
void VertexBuffer::executeOwnershipBarrier(Gfx::QueueType newOwner)
{
Vulkan::ShaderBuffer::executeOwnershipBarrier(newOwner);
Vulkan::Buffer::executeOwnershipBarrier(newOwner);
}
void VertexBuffer::executePipelineBarrier(VkAccessFlags srcAccess, VkPipelineStageFlags srcStage,
VkAccessFlags dstAccess, VkPipelineStageFlags dstStage)
{
Vulkan::ShaderBuffer::executePipelineBarrier(srcAccess, srcStage, dstAccess, dstStage);
Vulkan::Buffer::executePipelineBarrier(srcAccess, srcStage, dstAccess, dstStage);
}
VkAccessFlags VertexBuffer::getSourceAccessMask()
@@ -495,14 +495,14 @@ VkAccessFlags VertexBuffer::getDestAccessMask()
return VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT;
}
IndexBuffer::IndexBuffer(PGraphics graphics, const IndexBufferCreateInfo &resourceData)
: Gfx::IndexBuffer(graphics->getFamilyMapping(), resourceData.resourceData.size, resourceData.indexType, resourceData.resourceData.owner)
, Vulkan::ShaderBuffer(graphics, resourceData.resourceData.size, VK_BUFFER_USAGE_INDEX_BUFFER_BIT, currentOwner)
IndexBuffer::IndexBuffer(PGraphics graphics, const IndexBufferCreateInfo &sourceData)
: Gfx::IndexBuffer(graphics->getFamilyMapping(), sourceData.sourceData.size, sourceData.indexType, sourceData.sourceData.owner)
, Vulkan::Buffer(graphics, sourceData.sourceData.size, VK_BUFFER_USAGE_INDEX_BUFFER_BIT, currentOwner)
{
if (resourceData.resourceData.data != nullptr)
if (sourceData.sourceData.data != nullptr)
{
void *data = lock();
std::memcpy(data, resourceData.resourceData.data, resourceData.resourceData.size);
std::memcpy(data, sourceData.sourceData.data, sourceData.sourceData.size);
unlock();
}
}
@@ -526,13 +526,13 @@ void IndexBuffer::requestOwnershipTransfer(Gfx::QueueType newOwner)
void IndexBuffer::executeOwnershipBarrier(Gfx::QueueType newOwner)
{
Vulkan::ShaderBuffer::executeOwnershipBarrier(newOwner);
Vulkan::Buffer::executeOwnershipBarrier(newOwner);
}
void IndexBuffer::executePipelineBarrier(VkAccessFlags srcAccess, VkPipelineStageFlags srcStage,
VkAccessFlags dstAccess, VkPipelineStageFlags dstStage)
{
Vulkan::ShaderBuffer::executePipelineBarrier(srcAccess, srcStage, dstAccess, dstStage);
Vulkan::Buffer::executePipelineBarrier(srcAccess, srcStage, dstAccess, dstStage);
}
VkAccessFlags IndexBuffer::getSourceAccessMask()
src/Engine/Graphics/Vulkan/Buffer.h
+15 -15
View File
@@ -8,11 +8,11 @@ namespace Seele
namespace Vulkan
{
class ShaderBuffer
class Buffer
{
public:
ShaderBuffer(PGraphics graphics, uint64 size, VkBufferUsageFlags usage, Gfx::QueueType& queueType, bool bDynamic = false);
virtual ~ShaderBuffer();
Buffer(PGraphics graphics, uint64 size, VkBufferUsageFlags usage, Gfx::QueueType& queueType, bool bDynamic = false);
virtual ~Buffer();
VkBuffer getHandle() const
{
return buffers[currentBuffer].buffer;
@@ -52,15 +52,15 @@ protected:
virtual VkAccessFlags getSourceAccessMask() = 0;
virtual VkAccessFlags getDestAccessMask() = 0;
};
DEFINE_REF(ShaderBuffer)
DEFINE_REF(Buffer)
DECLARE_REF(StagingBuffer)
class UniformBuffer : public Gfx::UniformBuffer, public ShaderBuffer
class UniformBuffer : public Gfx::UniformBuffer, public Buffer
{
public:
UniformBuffer(PGraphics graphics, const UniformBufferCreateInfo &resourceData);
UniformBuffer(PGraphics graphics, const UniformBufferCreateInfo &sourceData);
virtual ~UniformBuffer();
virtual bool updateContents(const BulkResourceData &resourceData);
virtual bool updateContents(const DataSource &sourceData);
virtual void* lock(bool bWriteOnly = true) override;
virtual void unlock() override;
@@ -79,12 +79,12 @@ private:
};
DEFINE_REF(UniformBuffer)
class ShaderBuffer : public Gfx::ShaderBuffer, public ShaderBuffer
class ShaderBuffer : public Gfx::ShaderBuffer, public Buffer
{
public:
ShaderBuffer(PGraphics graphics, const ShaderBufferCreateInfo &resourceData);
ShaderBuffer(PGraphics graphics, const ShaderBufferCreateInfo &sourceData);
virtual ~ShaderBuffer();
virtual bool updateContents(const BulkResourceData &resourceData);
virtual bool updateContents(const DataSource &sourceData);
virtual void* lock(bool bWriteOnly = true) override;
virtual void unlock() override;
@@ -102,13 +102,13 @@ private:
};
DEFINE_REF(ShaderBuffer)
class VertexBuffer : public Gfx::VertexBuffer, public ShaderBuffer
class VertexBuffer : public Gfx::VertexBuffer, public Buffer
{
public:
VertexBuffer(PGraphics graphics, const VertexBufferCreateInfo &resourceData);
VertexBuffer(PGraphics graphics, const VertexBufferCreateInfo &sourceData);
virtual ~VertexBuffer();
virtual void updateRegion(BulkResourceData update) override;
virtual void updateRegion(DataSource update) override;
virtual void download(Array<uint8>& buffer) override;
protected:
// Inherited via Vulkan::Buffer
@@ -122,10 +122,10 @@ protected:
};
DEFINE_REF(VertexBuffer)
class IndexBuffer : public Gfx::IndexBuffer, public ShaderBuffer
class IndexBuffer : public Gfx::IndexBuffer, public Buffer
{
public:
IndexBuffer(PGraphics graphics, const IndexBufferCreateInfo &resourceData);
IndexBuffer(PGraphics graphics, const IndexBufferCreateInfo &sourceData);
virtual ~IndexBuffer();
virtual void download(Array<uint8>& buffer) override;
src/Engine/Graphics/Vulkan/CommandBuffer.cpp
+16 -12
View File
@@ -7,6 +7,7 @@
#include "RenderPass.h"
#include "Pipeline.h"
#include "DescriptorSets.h"
#include "RenderTarget.h"
using namespace Seele;
using namespace Seele::Vulkan;
@@ -277,16 +278,16 @@ void RenderCommand::bindDescriptor(const Array<Gfx::PDescriptorSet>& descriptorS
vkCmdBindDescriptorSets(handle, VK_PIPELINE_BIND_POINT_GRAPHICS, pipeline->getLayout(), 0, (uint32)descriptorSets.size(), sets, 0, nullptr);
delete[] sets;
}
void RenderCommand::bindVertexBuffer(const Array<VertexInputStream>& streams)
void RenderCommand::bindVertexBuffer(const Array<Gfx::PVertexBuffer>& streams)
{
assert(threadId == std::this_thread::get_id());
Array<VkBuffer> buffers(streams.size());
Array<VkDeviceSize> offsets(streams.size());
for(uint32 i = 0; i < streams.size(); ++i)
{
PVertexBuffer buf = streams[i].vertexBuffer.cast<VertexBuffer>();
PVertexBuffer buf = streams[i].cast<VertexBuffer>();
buffers[i] = buf->getHandle();
offsets[i] = streams[i].offset;
offsets[i] = 0;
};
vkCmdBindVertexBuffers(handle, 0, (uint32)streams.size(), buffers.data(), offsets.data());
}
@@ -424,10 +425,13 @@ CommandBufferManager::CommandBufferManager(PGraphics graphics, PQueue queue)
VK_CHECK(vkCreateCommandPool(graphics->getDevice(), &info, nullptr, &commandPool));
activeCmdBuffer = new CmdBuffer(graphics, commandPool, this);
{
std::scoped_lock lock(allocatedBufferLock);
allocatedBuffers.add(new CmdBuffer(graphics, commandPool, this));
}
activeCmdBuffer = allocatedBuffers.back();
activeCmdBuffer->begin();
std::scoped_lock lock(allocatedBufferLock);
allocatedBuffers.add(activeCmdBuffer);
}
CommandBufferManager::~CommandBufferManager()
@@ -455,10 +459,10 @@ PRenderCommand CommandBufferManager::createRenderCommand(PRenderPass renderPass,
return cmdBuffer;
}
}
PRenderCommand result = new RenderCommand(graphics, commandPool);
allocatedRenderCommands.add(new RenderCommand(graphics, commandPool));
PRenderCommand result = allocatedRenderCommands.back();
result->name = name;
result->begin(renderPass, framebuffer);
allocatedRenderCommands.add(result);
return result;
}
@@ -475,10 +479,10 @@ PComputeCommand CommandBufferManager::createComputeCommand(const std::string& na
return cmdBuffer;
}
}
PComputeCommand result = new ComputeCommand(graphics, commandPool);
allocatedComputeCommands.add(new ComputeCommand(graphics, commandPool));
PComputeCommand result = allocatedComputeCommands.back();
result->name = name;
result->begin(activeCmdBuffer);
allocatedComputeCommands.add(result);
return result;
}
@@ -517,7 +521,7 @@ void CommandBufferManager::submitCommands(PSemaphore signalSemaphore)
assert(cmdBuffer->state == CmdBuffer::State::Submitted);
}
}
activeCmdBuffer = new CmdBuffer(graphics, commandPool, this);
allocatedBuffers.add(activeCmdBuffer);
allocatedBuffers.add(new CmdBuffer(graphics, commandPool, this));
activeCmdBuffer = allocatedBuffers.back();
activeCmdBuffer->begin();
}
src/Engine/Graphics/Vulkan/CommandBuffer.h
+7 -11
View File
@@ -33,10 +33,6 @@ public:
void addWaitSemaphore(VkPipelineStageFlags stages, PSemaphore waitSemaphore);
void refreshFence();
void waitForCommand(uint32 timeToWait = 1000000u);
Fence* operator co_await()
{
return fence.getHandle();
}
PFence getFence();
PCommandBufferManager getManager();
enum State
@@ -51,7 +47,7 @@ public:
private:
PGraphics graphics;
PCommandBufferManager manager;
PFence fence;
OFence fence;
State state;
VkViewport currentViewport;
VkRect2D currentScissor;
@@ -62,7 +58,7 @@ private:
Array<VkPipelineStageFlags> waitFlags;
Array<PRenderCommand> executingRenders;
Array<PComputeCommand> executingComputes;
Array<DescriptorSet*> boundDescriptors;
Array<PDescriptorSet> boundDescriptors;
friend class RenderCommand;
friend class CommandBufferManager;
friend class Queue;
@@ -88,7 +84,7 @@ public:
virtual void bindPipeline(Gfx::PGraphicsPipeline pipeline) override;
virtual void bindDescriptor(Gfx::PDescriptorSet descriptorSet) override;
virtual void bindDescriptor(const Array<Gfx::PDescriptorSet>& descriptorSets) override;
virtual void bindVertexBuffer(const Array<PVertexBuffer>& buffers) override;
virtual void bindVertexBuffer(const Array<Gfx::PVertexBuffer>& buffers) 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(uint32 vertexCount, uint32 instanceCount, int32 firstVertex, uint32 firstInstance) override;
@@ -96,7 +92,7 @@ public:
private:
PGraphicsPipeline pipeline;
bool ready;
Array<DescriptorSet*> boundDescriptors;
Array<PDescriptorSet> boundDescriptors;
VkViewport currentViewport;
VkRect2D currentScissor;
PGraphics graphics;
@@ -163,11 +159,11 @@ private:
uint32 queueFamilyIndex;
PCmdBuffer activeCmdBuffer;
std::mutex allocatedBufferLock;
Array<PCmdBuffer> allocatedBuffers;
Array<OCmdBuffer> allocatedBuffers;
std::mutex allocatedRenderLock;
std::mutex allocatedComputeLock;
Array<PRenderCommand> allocatedRenderCommands;
Array<PComputeCommand> allocatedComputeCommands;
Array<ORenderCommand> allocatedRenderCommands;
Array<OComputeCommand> allocatedComputeCommands;
};
DEFINE_REF(CommandBufferManager)
} // namespace Vulkan
src/Engine/Graphics/Vulkan/DescriptorSets.cpp
+1 -1
View File
@@ -312,7 +312,7 @@ DescriptorAllocator::~DescriptorAllocator()
}
}
void DescriptorAllocator::allocateDescriptorSet(Gfx::PDescriptorSet &descriptorSet)
Gfx::PDescriptorSet DescriptorAllocator::allocateDescriptorSet()
{
VkDescriptorSetLayout layoutHandle = layout.getHandle();
VkDescriptorSetAllocateInfo allocInfo =
src/Engine/Graphics/Vulkan/DescriptorSets.h
+2 -2
View File
@@ -131,7 +131,7 @@ class DescriptorAllocator : public Gfx::DescriptorAllocator
public:
DescriptorAllocator(PGraphics graphics, DescriptorLayout &layout);
virtual ~DescriptorAllocator();
virtual void allocateDescriptorSet(Gfx::PDescriptorSet &descriptorSet);
virtual Gfx::PDescriptorSet allocateDescriptorSet() override;
virtual void reset();
inline VkDescriptorPool getHandle() const
@@ -147,7 +147,7 @@ private:
PGraphics graphics;
DescriptorLayout &layout;
const static int maxSets = 64;
StaticArray<PDescriptorSet, maxSets> cachedHandles;
StaticArray<ODescriptorSet, maxSets> cachedHandles;
VkDescriptorPool poolHandle;
DescriptorAllocator* nextAlloc = nullptr;
};
src/Engine/Graphics/Vulkan/Graphics.cpp
+42 -44
View File
@@ -1,24 +1,22 @@
#include "Containers/Array.h"
#include "VulkanGraphics.h"
#include "VulkanAllocator.h"
#include "VulkanQueue.h"
#include "VulkanInitializer.h"
#include "VulkanCommandBuffer.h"
#include "VulkanRenderPass.h"
#include "VulkanFramebuffer.h"
#include "VulkanPipelineCache.h"
#include "VulkanDescriptorSets.h"
#include "VulkanShader.h"
#include "Graphics/GraphicsResources.h"
#include "Graphics.h"
#include "Allocator.h"
#include "Buffer.h"
#include "PipelineCache.h"
#include "CommandBuffer.h"
#include "Initializer.h"
#include "RenderTarget.h"
#include "RenderPass.h"
#include "Framebuffer.h"
#include <GLFW/glfw3.h>
using namespace Seele;
using namespace Seele::Vulkan;
thread_local PCommandBufferManager Seele::Vulkan::Graphics::graphicsCommands = nullptr;
thread_local PCommandBufferManager Seele::Vulkan::Graphics::computeCommands = nullptr;
thread_local PCommandBufferManager Seele::Vulkan::Graphics::transferCommands = nullptr;
thread_local PCommandBufferManager Seele::Vulkan::Graphics::dedicatedTransferCommands = nullptr;
thread_local OCommandBufferManager Seele::Vulkan::Graphics::graphicsCommands = nullptr;
thread_local OCommandBufferManager Seele::Vulkan::Graphics::computeCommands = nullptr;
thread_local OCommandBufferManager Seele::Vulkan::Graphics::transferCommands = nullptr;
thread_local OCommandBufferManager Seele::Vulkan::Graphics::dedicatedTransferCommands = nullptr;
Graphics::Graphics()
: instance(VK_NULL_HANDLE)
@@ -49,22 +47,22 @@ void Graphics::init(GraphicsInitializer initInfo)
pipelineCache = new PipelineCache(this, "pipeline.cache");
}
Gfx::PWindow Graphics::createWindow(const WindowCreateInfo &createInfo)
Gfx::OWindow Graphics::createWindow(const WindowCreateInfo &createInfo)
{
PWindow result = new Window(this, createInfo);
OWindow result = new Window(this, createInfo);
return result;
}
Gfx::PViewport Graphics::createViewport(Gfx::PWindow owner, const ViewportCreateInfo &viewportInfo)
Gfx::OViewport Graphics::createViewport(Gfx::PWindow owner, const ViewportCreateInfo &viewportInfo)
{
PViewport result = new Viewport(this, owner, viewportInfo);
OViewport result = new Viewport(this, owner, viewportInfo);
std::scoped_lock lock(viewportLock);
viewports.add(result);
return result;
}
Gfx::PRenderPass Graphics::createRenderPass(Gfx::PRenderTargetLayout layout, Gfx::PViewport renderArea)
Gfx::ORenderPass Graphics::createRenderPass(Gfx::ORenderTargetLayout layout, Gfx::PViewport renderArea)
{
PRenderPass result = new RenderPass(this, layout, renderArea);
ORenderPass result = new RenderPass(this, std::move(layout), renderArea);
return result;
}
void Graphics::beginRenderPass(Gfx::PRenderPass renderPass)
@@ -77,12 +75,12 @@ void Graphics::beginRenderPass(Gfx::PRenderPass renderPass)
auto found = allocatedFramebuffers.find(framebufferHash);
if (found == allocatedFramebuffers.end())
{
framebuffer = new Framebuffer(this, rp, rp->getLayout());
allocatedFramebuffers[framebufferHash] = framebuffer;
allocatedFramebuffers[framebufferHash] = new Framebuffer(this, rp, rp->getLayout());
framebuffer = allocatedFramebuffers[framebufferHash];
}
else
{
framebuffer = found->value;
framebuffer = std::move(found->value);
}
}
getGraphicsCommands()->getCommands()->beginRenderPass(rp, framebuffer);
@@ -110,67 +108,67 @@ void Graphics::executeCommands(const Array<Gfx::PComputeCommand>& commands)
getComputeCommands()->getCommands()->executeCommands(commands);
}
Gfx::PTexture2D Graphics::createTexture2D(const TextureCreateInfo &createInfo)
Gfx::OTexture2D Graphics::createTexture2D(const TextureCreateInfo &createInfo)
{
PTexture2D result = new Texture2D(this, createInfo);
OTexture2D result = new Texture2D(this, createInfo);
return result;
}
Gfx::PTexture3D Graphics::createTexture3D(const TextureCreateInfo &createInfo)
Gfx::OTexture3D Graphics::createTexture3D(const TextureCreateInfo &createInfo)
{
PTexture3D result = new Texture3D(this, createInfo);
OTexture3D result = new Texture3D(this, createInfo);
return result;
}
Gfx::PTextureCube Graphics::createTextureCube(const TextureCreateInfo &createInfo)
Gfx::OTextureCube Graphics::createTextureCube(const TextureCreateInfo &createInfo)
{
PTextureCube result = new TextureCube(this, createInfo);
OTextureCube result = new TextureCube(this, createInfo);
return result;
}
Gfx::PUniformBuffer Graphics::createUniformBuffer(const UniformBufferCreateInfo &bulkData)
Gfx::OUniformBuffer Graphics::createUniformBuffer(const UniformBufferCreateInfo &bulkData)
{
PUniformBuffer uniformBuffer = new UniformBuffer(this, bulkData);
OUniformBuffer uniformBuffer = new UniformBuffer(this, bulkData);
return uniformBuffer;
}
Gfx::PShaderBuffer Graphics::createShaderBuffer(const ShaderBufferCreateInfo &bulkData)
Gfx::OShaderBuffer Graphics::createShaderBuffer(const ShaderBufferCreateInfo &bulkData)
{
PShaderBuffer ShaderBuffer = new ShaderBuffer(this, bulkData);
OShaderBuffer ShaderBuffer = new ShaderBuffer(this, bulkData);
return ShaderBuffer;
}
Gfx::PVertexBuffer Graphics::createVertexBuffer(const VertexBufferCreateInfo &bulkData)
Gfx::OVertexBuffer Graphics::createVertexBuffer(const VertexBufferCreateInfo &bulkData)
{
PVertexBuffer vertexBuffer = new VertexBuffer(this, bulkData);
OVertexBuffer vertexBuffer = new VertexBuffer(this, bulkData);
return vertexBuffer;
}
Gfx::PIndexBuffer Graphics::createIndexBuffer(const IndexBufferCreateInfo &bulkData)
Gfx::OIndexBuffer Graphics::createIndexBuffer(const IndexBufferCreateInfo &bulkData)
{
PIndexBuffer indexBuffer = new IndexBuffer(this, bulkData);
OIndexBuffer indexBuffer = new IndexBuffer(this, bulkData);
return indexBuffer;
}
Gfx::PRenderCommand Graphics::createRenderCommand(const std::string& name)
{
PRenderCommand cmdBuffer = getGraphicsCommands()->createRenderCommand(activeRenderPass, activeFramebuffer, name);
ORenderCommand cmdBuffer = getGraphicsCommands()->createRenderCommand(activeRenderPass, activeFramebuffer, name);
return cmdBuffer;
}
Gfx::PComputeCommand Graphics::createComputeCommand(const std::string& name)
{
PComputeCommand cmdBuffer = getComputeCommands()->createComputeCommand(name);
OComputeCommand cmdBuffer = getComputeCommands()->createComputeCommand(name);
return cmdBuffer;
}
Gfx::PVertexDeclaration Graphics::createVertexDeclaration(const Array<Gfx::VertexElement>& element)
Gfx::OVertexDeclaration Graphics::createVertexDeclaration(const Array<Gfx::VertexElement>& element)
{
PVertexDeclaration declaration = new VertexDeclaration(element);
OVertexDeclaration declaration = new VertexDeclaration(element);
return declaration;
}
Gfx::PVertexShader Graphics::createVertexShader(const ShaderCreateInfo& createInfo)
Gfx::OVertexShader Graphics::createVertexShader(const ShaderCreateInfo& createInfo)
{
PVertexShader shader = new VertexShader(this);
OVertexShader shader = new VertexShader(this);
shader->create(createInfo);
return shader;
}
src/Engine/Graphics/Vulkan/Graphics.h
+35 -33
View File
@@ -37,38 +37,40 @@ public:
// Inherited via Graphics
virtual void init(GraphicsInitializer initializer) override;
virtual Gfx::PWindow createWindow(const WindowCreateInfo &createInfo) override;
virtual Gfx::PViewport createViewport(Gfx::PWindow owner, const ViewportCreateInfo &createInfo) override;
virtual Gfx::OWindow createWindow(const WindowCreateInfo &createInfo) override;
virtual Gfx::OViewport createViewport(Gfx::PWindow owner, const ViewportCreateInfo &createInfo) override;
virtual Gfx::PRenderPass createRenderPass(Gfx::PRenderTargetLayout layout, Gfx::PViewport renderArea) override;
virtual Gfx::ORenderPass createRenderPass(Gfx::ORenderTargetLayout layout, Gfx::PViewport renderArea) override;
virtual void beginRenderPass(Gfx::PRenderPass renderPass) override;
virtual void endRenderPass() override;
virtual void executeCommands(const Array<Gfx::PRenderCommand>& commands) override;
virtual void executeCommands(const Array<Gfx::PComputeCommand>& commands) override;
virtual Gfx::PTexture2D createTexture2D(const TextureCreateInfo &createInfo) override;
virtual Gfx::PTexture3D createTexture3D(const TextureCreateInfo &createInfo) override;
virtual Gfx::PTextureCube createTextureCube(const TextureCreateInfo &createInfo) override;
virtual Gfx::PUniformBuffer createUniformBuffer(const UniformBufferCreateInfo &bulkData) override;
virtual Gfx::PShaderBuffer createShaderBuffer(const ShaderBufferCreateInfo &bulkData) override;
virtual Gfx::PVertexBuffer createVertexBuffer(const VertexBufferCreateInfo &bulkData) override;
virtual Gfx::PIndexBuffer createIndexBuffer(const IndexBufferCreateInfo &bulkData) override;
virtual Gfx::OTexture2D createTexture2D(const TextureCreateInfo &createInfo) override;
virtual Gfx::OTexture3D createTexture3D(const TextureCreateInfo &createInfo) override;
virtual Gfx::OTextureCube createTextureCube(const TextureCreateInfo &createInfo) override;
virtual Gfx::OUniformBuffer createUniformBuffer(const UniformBufferCreateInfo &bulkData) override;
virtual Gfx::OShaderBuffer createShaderBuffer(const ShaderBufferCreateInfo &bulkData) override;
virtual Gfx::OVertexBuffer createVertexBuffer(const VertexBufferCreateInfo &bulkData) override;
virtual Gfx::OIndexBuffer createIndexBuffer(const IndexBufferCreateInfo &bulkData) override;
virtual Gfx::PRenderCommand createRenderCommand(const std::string& name) override;
virtual Gfx::PComputeCommand createComputeCommand(const std::string& name) override;
virtual Gfx::PVertexDeclaration createVertexDeclaration(const Array<Gfx::VertexElement>& element) override;
virtual Gfx::PVertexShader createVertexShader(const ShaderCreateInfo& createInfo) override;
virtual Gfx::PFragmentShader createFragmentShader(const ShaderCreateInfo& createInfo) override;
virtual Gfx::PComputeShader createComputeShader(const ShaderCreateInfo& createInfo) override;
virtual Gfx::PTaskShader createTaskShader(const ShaderCreateInfo& createInfo) override;
virtual Gfx::PMeshShader createMeshShader(const ShaderCreateInfo& createInfo) override;
virtual Gfx::PGraphicsPipeline createGraphicsPipeline(const Gfx::LegacyPipelineCreateInfo& createInfo) override;
virtual Gfx::PGraphicsPipeline createGraphicsPipeline(const Gfx::MeshPipelineCreateInfo& createInfo) override;
virtual Gfx::PComputePipeline createComputePipeline(const Gfx::ComputePipelineCreateInfo& createInfo) override;
virtual Gfx::PSamplerState createSamplerState(const SamplerCreateInfo& createInfo) override;
virtual Gfx::OVertexDeclaration createVertexDeclaration(const Array<Gfx::VertexElement>& element) override;
virtual Gfx::OVertexShader createVertexShader(const ShaderCreateInfo& createInfo) override;
virtual Gfx::OFragmentShader createFragmentShader(const ShaderCreateInfo& createInfo) override;
virtual Gfx::OComputeShader createComputeShader(const ShaderCreateInfo& createInfo) override;
virtual Gfx::OTaskShader createTaskShader(const ShaderCreateInfo& createInfo) override;
virtual Gfx::OMeshShader createMeshShader(const ShaderCreateInfo& createInfo) override;
virtual Gfx::OGraphicsPipeline createGraphicsPipeline(const Gfx::LegacyPipelineCreateInfo& createInfo) override;
virtual Gfx::OGraphicsPipeline createGraphicsPipeline(const Gfx::MeshPipelineCreateInfo& createInfo) override;
virtual Gfx::OComputePipeline createComputePipeline(const Gfx::ComputePipelineCreateInfo& createInfo) override;
virtual Gfx::OSamplerState createSamplerState(const SamplerCreateInfo& createInfo) override;
virtual Gfx::PDescriptorLayout createDescriptorLayout(const std::string& name = "") override;
virtual Gfx::PPipelineLayout createPipelineLayout(Gfx::PPipelineLayout baseLayout = nullptr) override;
virtual Gfx::ODescriptorLayout createDescriptorLayout(const std::string& name = "") override;
virtual Gfx::OPipelineLayout createPipelineLayout(Gfx::PPipelineLayout baseLayout = nullptr) override;
virtual void copyTexture(Gfx::PTexture srcTexture, Gfx::PTexture dstTexture) override;
protected:
@@ -82,18 +84,18 @@ protected:
VkDevice handle;
VkPhysicalDevice physicalDevice;
PQueue graphicsQueue;
PQueue computeQueue;
PQueue transferQueue;
PQueue dedicatedTransferQueue;
PPipelineCache pipelineCache;
OQueue graphicsQueue;
OQueue computeQueue;
OQueue transferQueue;
OQueue dedicatedTransferQueue;
OPipelineCache pipelineCache;
std::mutex renderPassLock;
PRenderPass activeRenderPass;
PFramebuffer activeFramebuffer;
thread_local static PCommandBufferManager graphicsCommands;
thread_local static PCommandBufferManager computeCommands;
thread_local static PCommandBufferManager transferCommands;
thread_local static PCommandBufferManager dedicatedTransferCommands;
thread_local static OCommandBufferManager graphicsCommands;
thread_local static OCommandBufferManager computeCommands;
thread_local static OCommandBufferManager transferCommands;
thread_local static OCommandBufferManager dedicatedTransferCommands;
VkPhysicalDeviceProperties props;
VkPhysicalDeviceFeatures features;
VkDebugReportCallbackEXT callback;
@@ -101,8 +103,8 @@ protected:
Array<PViewport> viewports;
std::mutex allocatedFrameBufferLock;
Map<uint32, PFramebuffer> allocatedFramebuffers;
PAllocator allocator;
PStagingManager stagingManager;
OAllocator allocator;
OStagingManager stagingManager;
friend class Window;
};
src/Engine/Graphics/Vulkan/RenderPass.cpp
+6 -6
View File
@@ -7,8 +7,8 @@
using namespace Seele;
using namespace Seele::Vulkan;
RenderPass::RenderPass(PGraphics graphics, Gfx::PRenderTargetLayout layout, Gfx::PViewport viewport)
: Gfx::RenderPass(layout)
RenderPass::RenderPass(PGraphics graphics, Gfx::ORenderTargetLayout layout, Gfx::PViewport viewport)
: Gfx::RenderPass(std::move(layout))
, graphics(graphics)
{
renderArea.extent.width = viewport->getSizeX();
@@ -21,7 +21,7 @@ RenderPass::RenderPass(PGraphics graphics, Gfx::PRenderTargetLayout layout, Gfx:
Array<VkAttachmentReference> colorRefs;
VkAttachmentReference depthRef;
uint32 attachmentCounter = 0;
for (auto inputAttachment : layout->inputAttachments)
for (auto& inputAttachment : this->layout->inputAttachments)
{
PTexture2D image = inputAttachment->getTexture().cast<Texture2D>();
VkAttachmentDescription& desc = attachments.add();
@@ -39,7 +39,7 @@ RenderPass::RenderPass(PGraphics graphics, Gfx::PRenderTargetLayout layout, Gfx:
ref.attachment = attachmentCounter;
attachmentCounter++;
}
for (auto colorAttachment : layout->colorAttachments)
for (auto& colorAttachment : this->layout->colorAttachments)
{
VkAttachmentDescription& desc = attachments.add();
desc.flags = 0;
@@ -127,12 +127,12 @@ uint32 RenderPass::getFramebufferHash()
{
FramebufferDescription description;
std::memset(&description, 0, sizeof(FramebufferDescription));
for (auto inputAttachment : layout->inputAttachments)
for (auto& inputAttachment : layout->inputAttachments)
{
PTexture2D tex = inputAttachment->getTexture().cast<Texture2D>();
description.inputAttachments[description.numInputAttachments++] = tex->getView();
}
for (auto colorAttachment : layout->colorAttachments)
for (auto& colorAttachment : layout->colorAttachments)
{
PTexture2D tex = colorAttachment->getTexture().cast<Texture2D>();
description.colorAttachments[description.numColorAttachments++] = tex->getView();
src/Engine/Graphics/Vulkan/RenderPass.h
+1 -1
View File
@@ -9,7 +9,7 @@ namespace Vulkan
class RenderPass : public Gfx::RenderPass
{
public:
RenderPass(PGraphics graphics, Gfx::PRenderTargetLayout layout, Gfx::PViewport viewport);
RenderPass(PGraphics graphics, Gfx::ORenderTargetLayout layout, Gfx::PViewport viewport);
virtual ~RenderPass();
uint32 getFramebufferHash();
inline VkRenderPass getHandle() const
src/Engine/Graphics/Vulkan/RenderTarget.cpp
+9 -8
View File
@@ -1,8 +1,9 @@
#include "VulkanGraphicsResources.h"
#include "VulkanGraphics.h"
#include "VulkanInitializer.h"
#include "VulkanGraphicsEnums.h"
#include "VulkanCommandBuffer.h"
#include "RenderTarget.h"
#include "Resources.h"
#include "Graphics.h"
#include "Initializer.h"
#include "Enums.h"
#include "CommandBuffer.h"
#include <GLFW/glfw3.h>
using namespace Seele;
@@ -116,9 +117,9 @@ void Window::onWindowCloseEvent()
{
}
Gfx::PTexture2D Window::getBackBuffer() const
Gfx::PTexture2D Window::getBackBuffer()
{
return backBufferImages[currentImageIndex];
return PTexture2D(backBufferImages[currentImageIndex]);
}
void Window::setKeyCallback(std::function<void(KeyCode, InputAction, KeyModifier)> callback)
@@ -289,7 +290,7 @@ void Window::createSwapchain()
backBufferCreateInfo.width = getSizeX();
backBufferCreateInfo.height = getSizeY();
backBufferCreateInfo.usage = Gfx::SE_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
backBufferCreateInfo.resourceData.owner = Gfx::QueueType::GRAPHICS;
backBufferCreateInfo.sourceData.owner = Gfx::QueueType::GRAPHICS;
backBufferCreateInfo.format = cast(surfaceFormat.format);
for (uint32 i = 0; i < numSwapchainImages; ++i)
{
src/Engine/Graphics/Vulkan/RenderTarget.h
+4 -4
View File
@@ -16,7 +16,7 @@ public:
virtual ~Window();
virtual void beginFrame() override;
virtual void endFrame() override;
virtual Gfx::PTexture2D getBackBuffer() const override;
virtual Gfx::PTexture2D getBackBuffer() override;
virtual void onWindowCloseEvent() override;
virtual void setKeyCallback(std::function<void(KeyCode, InputAction, KeyModifier)> callback) override;
virtual void setMouseMoveCallback(std::function<void(double, double)> callback) override;
@@ -45,9 +45,9 @@ protected:
void chooseSurfaceFormat(const Array<VkSurfaceFormatKHR> &available, Gfx::SeFormat preferred);
void choosePresentMode(const Array<VkPresentModeKHR> &modes);
PTexture2D backBufferImages[Gfx::numFramesBuffered];
PSemaphore renderFinished[Gfx::numFramesBuffered];
PSemaphore imageAcquired[Gfx::numFramesBuffered];
OTexture2D backBufferImages[Gfx::numFramesBuffered];
OSemaphore renderFinished[Gfx::numFramesBuffered];
OSemaphore imageAcquired[Gfx::numFramesBuffered];
PSemaphore imageAcquiredSemaphore;
PGraphics graphics;
src/Engine/Graphics/Vulkan/Resources.cpp
+4 -5
View File
@@ -1,8 +1,7 @@
#include "VulkanGraphicsResources.h"
#include "VulkanInitializer.h"
#include "VulkanGraphics.h"
#include "VulkanGraphicsEnums.h"
#include "VulkanCommandBuffer.h"
#include "Resources.h"
#include "Enums.h"
#include "Initializer.h"
#include "Graphics.h"
using namespace Seele;
using namespace Seele::Vulkan;
src/Engine/Graphics/Vulkan/Shader.cpp
+2 -8
View File
@@ -1,6 +1,5 @@
#include "VulkanShader.h"
#include "VulkanGraphics.h"
#include "VulkanDescriptorSets.h"
#include "Shader.h"
#include "Graphics.h"
#include "slang.h"
#include "slang-com-ptr.h"
#include "stdlib.h"
@@ -23,11 +22,6 @@ Shader::~Shader()
}
}
Map<uint32, PDescriptorLayout> Shader::getDescriptorLayouts()
{
return descriptorSets;
}
uint32 Seele::Vulkan::Shader::getShaderHash() const
{
return hash;
src/Engine/Graphics/Vulkan/Shader.h
+2 -3
View File
@@ -26,11 +26,11 @@ public:
//SLang renames all entry points to main, so we dont need that
return "main";//entryPointName.c_str();
}
Map<uint32, PDescriptorLayout> getDescriptorLayouts();
//Map<uint32, PDescriptorLayout> getDescriptorLayouts();
uint32 getShaderHash() const;
private:
PGraphics graphics;
Map<uint32, PDescriptorLayout> descriptorSets;
//Map<uint32, PDescriptorLayout> descriptorSets;
VkShaderModule module;
ShaderType type;
VkShaderStageFlags stage;
@@ -62,6 +62,5 @@ DEFINE_REF(FragmentShader)
DEFINE_REF(ComputeShader)
DEFINE_REF(TaskShader)
DEFINE_REF(MeshShader)
} // namespace Vulkan
}
src/Engine/Graphics/Vulkan/Texture.cpp
+7 -7
View File
@@ -110,13 +110,13 @@ TextureHandle::TextureHandle(PGraphics graphics, VkImageViewType viewType,
vkBindImageMemory(graphics->getDevice(), image, allocation->getHandle(), allocation->getOffset());
}
const BulkResourceData& resourceData = createInfo.resourceData;
if(resourceData.size > 0)
const DataSource& sourceData = createInfo.sourceData;
if(sourceData.size > 0)
{
changeLayout(Gfx::SE_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL);
PStagingBuffer staging = graphics->getStagingManager()->allocateStagingBuffer(resourceData.size, VK_BUFFER_USAGE_TRANSFER_SRC_BIT);
PStagingBuffer staging = graphics->getStagingManager()->allocateStagingBuffer(sourceData.size, VK_BUFFER_USAGE_TRANSFER_SRC_BIT);
void* data = staging->getMappedPointer();
std::memcpy(data, resourceData.data, resourceData.size);
std::memcpy(data, sourceData.data, sourceData.size);
staging->flushMappedMemory();
PCommandBufferManager cmdBufferManager = graphics->getQueueCommands(currentOwner);
@@ -322,7 +322,7 @@ void TextureHandle::executePipelineBarrier(VkAccessFlags srcAccess, VkPipelineSt
}
Texture2D::Texture2D(PGraphics graphics, const TextureCreateInfo& createInfo, VkImage existingImage)
: Gfx::Texture2D(graphics->getFamilyMapping(), createInfo.resourceData.owner)
: Gfx::Texture2D(graphics->getFamilyMapping(), createInfo.sourceData.owner)
{
textureHandle = new TextureHandle(graphics, createInfo.bArray ? VK_IMAGE_VIEW_TYPE_2D_ARRAY : VK_IMAGE_VIEW_TYPE_2D,
createInfo, currentOwner, existingImage);
@@ -354,7 +354,7 @@ void Texture2D::executePipelineBarrier(VkAccessFlags srcAccess, VkPipelineStageF
}
Texture3D::Texture3D(PGraphics graphics, const TextureCreateInfo& createInfo, VkImage existingImage)
: Gfx::Texture3D(graphics->getFamilyMapping(), createInfo.resourceData.owner)
: Gfx::Texture3D(graphics->getFamilyMapping(), createInfo.sourceData.owner)
{
textureHandle = new TextureHandle(graphics, VK_IMAGE_VIEW_TYPE_3D,
createInfo, currentOwner, existingImage);
@@ -385,7 +385,7 @@ void Texture3D::executePipelineBarrier(VkAccessFlags srcAccess, VkPipelineStageF
}
TextureCube::TextureCube(PGraphics graphics, const TextureCreateInfo& createInfo, VkImage existingImage)
: Gfx::TextureCube(graphics->getFamilyMapping(), createInfo.resourceData.owner)
: Gfx::TextureCube(graphics->getFamilyMapping(), createInfo.sourceData.owner)
{
textureHandle = new TextureHandle(graphics, createInfo.bArray ? VK_IMAGE_VIEW_TYPE_CUBE_ARRAY : VK_IMAGE_VIEW_TYPE_CUBE,
createInfo, currentOwner, existingImage);
src/Engine/Graphics/Vulkan/Texture.h
+1 -1
View File
@@ -61,7 +61,7 @@ private:
//Updates via reference
Gfx::QueueType& currentOwner;
PGraphics graphics;
PSubAllocation allocation;
OSubAllocation allocation;
uint32 sizeX;
uint32 sizeY;
uint32 sizeZ;