Skip to content

A
angle
Commit 5deea723 by Jamie Madill Committed by Commit Bot
Options

Vulkan: Don't store device handles in wrapped objects.

BUG=angleproject:1684 Change-Id: I0ec11ec79f2e9893600a8ffd8cdbfc6040fb6f70 Reviewed-on: https://chromium-review.googlesource.com/426402 Commit-Queue: Jamie Madill <jmadill@chromium.org> Reviewed-by: 's avatarCorentin Wallez <cwallez@chromium.org>
parent abe89c7d
Showing with 355 additions and 445 deletions
src/libANGLE/renderer/vulkan/BufferVk.cpp
......@@ -24,6 +24,13 @@ BufferVk::~BufferVk()
{
}
void BufferVk::destroy(ContextImpl *contextImpl)
{
VkDevice device = GetAs<ContextVk>(contextImpl)->getDevice();
mBuffer.destroy(device);
}
gl::Error BufferVk::setData(ContextImpl *context,
GLenum target,
const void *data,
......@@ -45,8 +52,8 @@ gl::Error BufferVk::setData(ContextImpl *context,
createInfo.queueFamilyIndexCount = 0;
createInfo.pQueueFamilyIndices = nullptr;
vk::Buffer newBuffer(device);
ANGLE_TRY(newBuffer.init(createInfo));
vk::Buffer newBuffer;
ANGLE_TRY(newBuffer.init(device, createInfo));
// Find a compatible memory pool index. If the index doesn't change, we could cache it.
// Not finding a valid memory pool means an out-of-spec driver, or internal error.
......@@ -73,14 +80,14 @@ gl::Error BufferVk::setData(ContextImpl *context,
allocInfo.memoryTypeIndex = memoryTypeIndex.value();
allocInfo.allocationSize = memoryRequirements.size;
ANGLE_TRY(newBuffer.getMemory().allocate(allocInfo));
ANGLE_TRY(newBuffer.bindMemory());
ANGLE_TRY(newBuffer.getMemory().allocate(device, allocInfo));
ANGLE_TRY(newBuffer.bindMemory(device));
mBuffer = std::move(newBuffer);
mBuffer.retain(device, std::move(newBuffer));
if (data)
{
ANGLE_TRY(setDataImpl(static_cast<const uint8_t *>(data), size, 0));
ANGLE_TRY(setDataImpl(device, static_cast<const uint8_t *>(data), size, 0));
}
return gl::NoError();
......@@ -95,7 +102,9 @@ gl::Error BufferVk::setSubData(ContextImpl *context,
ASSERT(mBuffer.getHandle() != VK_NULL_HANDLE);
ASSERT(mBuffer.getMemory().getHandle() != VK_NULL_HANDLE);
ANGLE_TRY(setDataImpl(static_cast<const uint8_t *>(data), size, offset));
VkDevice device = GetAs<ContextVk>(context)->getDevice();
ANGLE_TRY(setDataImpl(device, static_cast<const uint8_t *>(data), size, offset));
return gl::NoError();
}
......@@ -115,8 +124,10 @@ gl::Error BufferVk::map(ContextImpl *context, GLenum access, GLvoid **mapPtr)
ASSERT(mBuffer.getHandle() != VK_NULL_HANDLE);
ASSERT(mBuffer.getMemory().getHandle() != VK_NULL_HANDLE);
ANGLE_TRY(
mBuffer.getMemory().map(0, mState.getSize(), 0, reinterpret_cast<uint8_t **>(mapPtr)));
VkDevice device = GetAs<ContextVk>(context)->getDevice();
ANGLE_TRY(mBuffer.getMemory().map(device, 0, mState.getSize(), 0,
reinterpret_cast<uint8_t **>(mapPtr)));
return gl::NoError();
}
......@@ -130,7 +141,10 @@ gl::Error BufferVk::mapRange(ContextImpl *context,
ASSERT(mBuffer.getHandle() != VK_NULL_HANDLE);
ASSERT(mBuffer.getMemory().getHandle() != VK_NULL_HANDLE);
ANGLE_TRY(mBuffer.getMemory().map(offset, length, 0, reinterpret_cast<uint8_t **>(mapPtr)));
VkDevice device = GetAs<ContextVk>(context)->getDevice();
ANGLE_TRY(
mBuffer.getMemory().map(device, offset, length, 0, reinterpret_cast<uint8_t **>(mapPtr)));
return gl::NoError();
}
......@@ -140,7 +154,9 @@ gl::Error BufferVk::unmap(ContextImpl *context, GLboolean *result)
ASSERT(mBuffer.getHandle() != VK_NULL_HANDLE);
ASSERT(mBuffer.getMemory().getHandle() != VK_NULL_HANDLE);
mBuffer.getMemory().unmap();
VkDevice device = GetAs<ContextVk>(context)->getDevice();
mBuffer.getMemory().unmap(device);
return gl::NoError();
}
......@@ -155,15 +171,15 @@ gl::Error BufferVk::getIndexRange(GLenum type,
return gl::Error(GL_INVALID_OPERATION);
}
vk::Error BufferVk::setDataImpl(const uint8_t *data, size_t size, size_t offset)
vk::Error BufferVk::setDataImpl(VkDevice device, const uint8_t *data, size_t size, size_t offset)
{
uint8_t *mapPointer = nullptr;
ANGLE_TRY(mBuffer.getMemory().map(offset, size, 0, &mapPointer));
ANGLE_TRY(mBuffer.getMemory().map(device, offset, size, 0, &mapPointer));
ASSERT(mapPointer);
memcpy(mapPointer, data, size);
mBuffer.getMemory().unmap();
mBuffer.getMemory().unmap(device);
return vk::NoError();
}
......
src/libANGLE/renderer/vulkan/BufferVk.h
......@@ -21,6 +21,7 @@ class BufferVk : public BufferImpl
public:
BufferVk(const gl::BufferState &state);
~BufferVk() override;
void destroy(ContextImpl *contextImpl) override;
gl::Error setData(ContextImpl *context,
GLenum target,
......@@ -54,7 +55,7 @@ class BufferVk : public BufferImpl
const vk::Buffer &getVkBuffer() const;
private:
vk::Error setDataImpl(const uint8_t *data, size_t size, size_t offset);
vk::Error setDataImpl(VkDevice device, const uint8_t *data, size_t size, size_t offset);
vk::Buffer mBuffer;
size_t mRequiredSize;
......
src/libANGLE/renderer/vulkan/ContextVk.cpp
......@@ -41,6 +41,7 @@ ContextVk::ContextVk(const gl::ContextState &state, RendererVk *renderer)
ContextVk::~ContextVk()
{
mCurrentPipeline.destroy(getDevice());
}
gl::Error ContextVk::initialize()
......@@ -259,10 +260,10 @@ gl::Error ContextVk::drawArrays(GLenum mode, GLint first, GLsizei count)
pipelineInfo.basePipelineHandle = VK_NULL_HANDLE;
pipelineInfo.basePipelineIndex = 0;
vk::Pipeline newPipeline(device);
ANGLE_TRY(newPipeline.initGraphics(pipelineInfo));
vk::Pipeline newPipeline;
ANGLE_TRY(newPipeline.initGraphics(device, pipelineInfo));
mCurrentPipeline = std::move(newPipeline);
mCurrentPipeline.retain(device, std::move(newPipeline));
vk::CommandBuffer *commandBuffer = mRenderer->getCommandBuffer();
ANGLE_TRY(vkFBO->beginRenderPass(device, commandBuffer, state));
......
src/libANGLE/renderer/vulkan/FramebufferVk.cpp
......@@ -17,6 +17,7 @@
#include "libANGLE/formatutils.h"
#include "libANGLE/renderer/renderer_utils.h"
#include "libANGLE/renderer/vulkan/ContextVk.h"
#include "libANGLE/renderer/vulkan/DisplayVk.h"
#include "libANGLE/renderer/vulkan/RenderTargetVk.h"
#include "libANGLE/renderer/vulkan/RendererVk.h"
#include "libANGLE/renderer/vulkan/SurfaceVk.h"
......@@ -79,16 +80,20 @@ FramebufferVk *FramebufferVk::CreateDefaultFBO(const gl::FramebufferState &state
FramebufferVk::FramebufferVk(const gl::FramebufferState &state)
: FramebufferImpl(state),
mBackbuffer(nullptr),
mRenderPass(VK_NULL_HANDLE),
mFramebuffer(VK_NULL_HANDLE)
mRenderPass(),
mFramebuffer(),
mDirtyRenderPass(true),
mDirtyFramebuffer(true)
{
}
FramebufferVk::FramebufferVk(const gl::FramebufferState &state, WindowSurfaceVk *backbuffer)
: FramebufferImpl(state),
mBackbuffer(backbuffer),
mRenderPass(VK_NULL_HANDLE),
mFramebuffer(VK_NULL_HANDLE)
mRenderPass(),
mFramebuffer(),
mDirtyRenderPass(true),
mDirtyFramebuffer(true)
{
}
......@@ -96,6 +101,22 @@ FramebufferVk::~FramebufferVk()
{
}
void FramebufferVk::destroy(ContextImpl *contextImpl)
{
VkDevice device = GetAs<ContextVk>(contextImpl)->getDevice();
mRenderPass.destroy(device);
mFramebuffer.destroy(device);
}
void FramebufferVk::destroyDefault(DisplayImpl *displayImpl)
{
VkDevice device = GetAs<DisplayVk>(displayImpl)->getRenderer()->getDevice();
mRenderPass.destroy(device);
mFramebuffer.destroy(device);
}
gl::Error FramebufferVk::discard(size_t count, const GLenum *attachments)
{
UNIMPLEMENTED();
......@@ -152,7 +173,7 @@ gl::Error FramebufferVk::clear(ContextImpl *context, GLbitfield mask)
const gl::Rectangle renderArea(0, 0, size.width, size.height);
vk::CommandBuffer *commandBuffer = contextVk->getCommandBuffer();
ANGLE_TRY(commandBuffer->begin());
ANGLE_TRY(commandBuffer->begin(contextVk->getDevice()));
for (const auto &colorAttachment : mState.getColorAttachments())
{
......@@ -253,15 +274,15 @@ gl::Error FramebufferVk::readPixels(ContextImpl *context,
ContextVk *contextVk = GetAs<ContextVk>(context);
RendererVk *renderer = contextVk->getRenderer();
VkDevice device = renderer->getDevice();
vk::Image *readImage = renderTarget->image;
vk::StagingImage stagingImage;
ANGLE_TRY_RESULT(renderer->createStagingImage(TextureDimension::TEX_2D, *renderTarget->format,
renderTarget->extents),
stagingImage);
ANGLE_TRY(renderer->createStagingImage(TextureDimension::TEX_2D, *renderTarget->format,
renderTarget->extents, &stagingImage));
vk::CommandBuffer *commandBuffer = contextVk->getCommandBuffer();
commandBuffer->begin();
commandBuffer->begin(device);
stagingImage.getImage().changeLayoutTop(VK_IMAGE_ASPECT_COLOR_BIT, VK_IMAGE_LAYOUT_GENERAL,
commandBuffer);
......@@ -283,7 +304,8 @@ gl::Error FramebufferVk::readPixels(ContextImpl *context,
// TODO(jmadill): parameters
uint8_t *mapPointer = nullptr;
ANGLE_TRY(stagingImage.getDeviceMemory().map(0, stagingImage.getSize(), 0, &mapPointer));
ANGLE_TRY(
stagingImage.getDeviceMemory().map(device, 0, stagingImage.getSize(), 0, &mapPointer));
const auto &angleFormat = renderTarget->format->format();
......@@ -301,7 +323,9 @@ gl::Error FramebufferVk::readPixels(ContextImpl *context,
PackPixels(params, angleFormat, inputPitch, mapPointer, reinterpret_cast<uint8_t *>(pixels));
stagingImage.getImage().destroy(renderer->getDevice());
stagingImage.getDeviceMemory().unmap();
stagingImage.getDeviceMemory().unmap(device);
stagingImage.destroy(device);
return vk::NoError();
}
......@@ -325,13 +349,13 @@ bool FramebufferVk::checkStatus() const
void FramebufferVk::syncState(const gl::Framebuffer::DirtyBits &dirtyBits)
{
// TODO(jmadill): Smarter update.
mRenderPass = vk::RenderPass();
mFramebuffer = vk::Framebuffer();
mDirtyRenderPass = true;
mDirtyFramebuffer = true;
}
gl::ErrorOrResult<vk::RenderPass *> FramebufferVk::getRenderPass(VkDevice device)
{
if (mRenderPass.valid())
if (mRenderPass.valid() && !mDirtyRenderPass)
{
return &mRenderPass;
}
......@@ -430,10 +454,12 @@ gl::ErrorOrResult<vk::RenderPass *> FramebufferVk::getRenderPass(VkDevice device
renderPassInfo.dependencyCount = 0;
renderPassInfo.pDependencies = nullptr;
vk::RenderPass renderPass(device);
ANGLE_TRY(renderPass.init(renderPassInfo));
vk::RenderPass renderPass;
ANGLE_TRY(renderPass.init(device, renderPassInfo));
mRenderPass = std::move(renderPass);
mRenderPass.retain(device, std::move(renderPass));
mDirtyRenderPass = false;
return &mRenderPass;
}
......@@ -441,7 +467,7 @@ gl::ErrorOrResult<vk::RenderPass *> FramebufferVk::getRenderPass(VkDevice device
gl::ErrorOrResult<vk::Framebuffer *> FramebufferVk::getFramebuffer(VkDevice device)
{
// If we've already created our cached Framebuffer, return it.
if (mFramebuffer.valid())
if (mFramebuffer.valid() && !mDirtyFramebuffer)
{
return &mFramebuffer;
}
......@@ -499,10 +525,12 @@ gl::ErrorOrResult<vk::Framebuffer *> FramebufferVk::getFramebuffer(VkDevice devi
framebufferInfo.height = static_cast<uint32_t>(attachmentsSize.height);
framebufferInfo.layers = 1;
vk::Framebuffer framebuffer(device);
ANGLE_TRY(static_cast<gl::Error>(framebuffer.init(framebufferInfo)));
vk::Framebuffer framebuffer;
ANGLE_TRY(static_cast<gl::Error>(framebuffer.init(device, framebufferInfo)));
mFramebuffer.retain(device, std::move(framebuffer));
mFramebuffer = std::move(framebuffer);
mDirtyFramebuffer = false;
return &mFramebuffer;
}
......@@ -544,7 +572,7 @@ gl::Error FramebufferVk::beginRenderPass(VkDevice device,
ANGLE_TRY(mState.getFirstColorAttachment()->getRenderTarget(&renderTarget));
renderTarget->image->updateLayout(VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL);
ANGLE_TRY(commandBuffer->begin());
ANGLE_TRY(commandBuffer->begin(device));
commandBuffer->beginRenderPass(*renderPass, *framebuffer, glState.getViewport(),
attachmentClearValues);
return gl::NoError();
......
src/libANGLE/renderer/vulkan/FramebufferVk.h
......@@ -31,6 +31,8 @@ class FramebufferVk : public FramebufferImpl
WindowSurfaceVk *backbuffer);
~FramebufferVk() override;
void destroy(ContextImpl *contextImpl) override;
void destroyDefault(DisplayImpl *displayImpl) override;
gl::Error discard(size_t count, const GLenum *attachments) override;
gl::Error invalidate(size_t count, const GLenum *attachments) override;
......@@ -93,6 +95,8 @@ class FramebufferVk : public FramebufferImpl
vk::RenderPass mRenderPass;
vk::Framebuffer mFramebuffer;
bool mDirtyRenderPass;
bool mDirtyFramebuffer;
};
} // namespace rx
......
src/libANGLE/renderer/vulkan/ProgramVk.cpp
......@@ -25,6 +25,15 @@ ProgramVk::~ProgramVk()
{
}
void ProgramVk::destroy(const ContextImpl *contextImpl)
{
VkDevice device = GetAs<ContextVk>(contextImpl)->getDevice();
mLinkedFragmentModule.destroy(device);
mLinkedVertexModule.destroy(device);
mPipelineLayout.destroy(device);
}
LinkResult ProgramVk::load(const ContextImpl *contextImpl,
gl::InfoLog &infoLog,
gl::BinaryInputStream *stream)
......@@ -66,8 +75,9 @@ LinkResult ProgramVk::link(ContextImpl *contextImpl,
return false;
}
vk::ShaderModule vertexModule(renderer->getDevice());
vk::ShaderModule fragmentModule(renderer->getDevice());
vk::ShaderModule vertexModule;
vk::ShaderModule fragmentModule;
VkDevice device = renderer->getDevice();
{
VkShaderModuleCreateInfo vertexShaderInfo;
......@@ -76,7 +86,7 @@ LinkResult ProgramVk::link(ContextImpl *contextImpl,
vertexShaderInfo.flags = 0;
vertexShaderInfo.codeSize = vertexCode.size() * sizeof(uint32_t);
vertexShaderInfo.pCode = vertexCode.data();
ANGLE_TRY(vertexModule.init(vertexShaderInfo));
ANGLE_TRY(vertexModule.init(device, vertexShaderInfo));
}
{
......@@ -87,11 +97,11 @@ LinkResult ProgramVk::link(ContextImpl *contextImpl,
fragmentShaderInfo.codeSize = fragmentCode.size() * sizeof(uint32_t);
fragmentShaderInfo.pCode = fragmentCode.data();
ANGLE_TRY(fragmentModule.init(fragmentShaderInfo));
ANGLE_TRY(fragmentModule.init(device, fragmentShaderInfo));
}
mLinkedVertexModule = std::move(vertexModule);
mLinkedFragmentModule = std::move(fragmentModule);
mLinkedVertexModule.retain(device, std::move(vertexModule));
mLinkedFragmentModule.retain(device, std::move(fragmentModule));
return true;
}
......@@ -274,7 +284,7 @@ const vk::ShaderModule &ProgramVk::getLinkedFragmentModule() const
gl::ErrorOrResult<vk::PipelineLayout *> ProgramVk::getPipelineLayout(VkDevice device)
{
vk::PipelineLayout newLayout(device);
vk::PipelineLayout newLayout;
// TODO(jmadill): Descriptor sets.
VkPipelineLayoutCreateInfo createInfo;
......@@ -286,9 +296,8 @@ gl::ErrorOrResult<vk::PipelineLayout *> ProgramVk::getPipelineLayout(VkDevice de
createInfo.pushConstantRangeCount = 0;
createInfo.pPushConstantRanges = nullptr;
ANGLE_TRY(newLayout.init(createInfo));
mPipelineLayout = std::move(newLayout);
ANGLE_TRY(newLayout.init(device, createInfo));
mPipelineLayout.retain(device, std::move(newLayout));
return &mPipelineLayout;
}
......
src/libANGLE/renderer/vulkan/ProgramVk.h
......@@ -21,6 +21,7 @@ class ProgramVk : public ProgramImpl
public:
ProgramVk(const gl::ProgramState &state);
~ProgramVk() override;
void destroy(const ContextImpl *contextImpl) override;
LinkResult load(const ContextImpl *contextImpl,
gl::InfoLog &infoLog,
......
src/libANGLE/renderer/vulkan/RendererVk.cpp
......@@ -106,8 +106,15 @@ RendererVk::~RendererVk()
mGlslangWrapper = nullptr;
}
mCommandBuffer.reset(nullptr);
mCommandPool.reset(nullptr);
if (mCommandBuffer.valid())
{
mCommandBuffer.destroy(mDevice);
}
if (mCommandPool.valid())
{
mCommandPool.destroy(mDevice);
}
if (mDevice)
{
......@@ -417,10 +424,9 @@ vk::Error RendererVk::initializeDevice(uint32_t queueFamilyIndex)
commandPoolInfo.flags = VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT;
commandPoolInfo.queueFamilyIndex = mCurrentQueueFamilyIndex;
mCommandPool.reset(new vk::CommandPool(mDevice));
ANGLE_TRY(mCommandPool->init(commandPoolInfo));
ANGLE_TRY(mCommandPool.init(mDevice, commandPoolInfo));
mCommandBuffer.reset(new vk::CommandBuffer(mDevice, mCommandPool.get()));
mCommandBuffer.setCommandPool(&mCommandPool);
return vk::NoError();
}
......@@ -553,7 +559,7 @@ const gl::Limitations &RendererVk::getNativeLimitations() const
vk::CommandBuffer *RendererVk::getCommandBuffer()
{
return mCommandBuffer.get();
return &mCommandBuffer;
}
vk::Error RendererVk::submitAndFinishCommandBuffer(const vk::CommandBuffer &commandBuffer)
......@@ -612,17 +618,17 @@ vk::Error RendererVk::waitThenFinishCommandBuffer(const vk::CommandBuffer &comma
return vk::NoError();
}
vk::ErrorOrResult<vk::StagingImage> RendererVk::createStagingImage(TextureDimension dimension,
const vk::Format &format,
const gl::Extents &extent)
vk::Error RendererVk::createStagingImage(TextureDimension dimension,
const vk::Format &format,
const gl::Extents &extent,
vk::StagingImage *imageOut)
{
ASSERT(mHostVisibleMemoryIndex != std::numeric_limits<uint32_t>::max());
vk::StagingImage stagingImage(mDevice);
ANGLE_TRY(stagingImage.init(mCurrentQueueFamilyIndex, mHostVisibleMemoryIndex, dimension,
format.native, extent));
ANGLE_TRY(imageOut->init(mDevice, mCurrentQueueFamilyIndex, mHostVisibleMemoryIndex, dimension,
format.native, extent));
return std::move(stagingImage);
return vk::NoError();
}
GlslangWrapper *RendererVk::getGlslangWrapper()
......
src/libANGLE/renderer/vulkan/RendererVk.h
......@@ -60,9 +60,10 @@ class RendererVk : angle::NonCopyable
const gl::Extensions &getNativeExtensions() const;
const gl::Limitations &getNativeLimitations() const;
vk::ErrorOrResult<vk::StagingImage> createStagingImage(TextureDimension dimension,
const vk::Format &format,
const gl::Extents &extent);
vk::Error createStagingImage(TextureDimension dimension,
const vk::Format &format,
const gl::Extents &extent,
vk::StagingImage *imageOut);
GlslangWrapper *getGlslangWrapper();
......@@ -90,8 +91,8 @@ class RendererVk : angle::NonCopyable
VkQueue mQueue;
uint32_t mCurrentQueueFamilyIndex;
VkDevice mDevice;
std::unique_ptr<vk::CommandPool> mCommandPool;
std::unique_ptr<vk::CommandBuffer> mCommandBuffer;
vk::CommandPool mCommandPool;
vk::CommandBuffer mCommandBuffer;
uint32_t mHostVisibleMemoryIndex;
GlslangWrapper *mGlslangWrapper;
};
......
src/libANGLE/renderer/vulkan/SurfaceVk.cpp
......@@ -133,8 +133,6 @@ WindowSurfaceVk::~WindowSurfaceVk()
{
ASSERT(mSurface == VK_NULL_HANDLE);
ASSERT(mSwapchain == VK_NULL_HANDLE);
ASSERT(mSwapchainImages.empty());
ASSERT(mSwapchainImageViews.empty());
}
void WindowSurfaceVk::destroy(const DisplayImpl *displayImpl)
......@@ -144,20 +142,23 @@ void WindowSurfaceVk::destroy(const DisplayImpl *displayImpl)
VkDevice device = rendererVk->getDevice();
VkInstance instance = rendererVk->getInstance();
mPresentCompleteSemaphore.destroy(device);
for (auto &imageView : mSwapchainImageViews)
{
imageView.destroy(device);
}
mSwapchainImageViews.clear();
// Although we don't own the swapchain image handles, we need to keep our shutdown clean.
for (auto &image : mSwapchainImages)
{
image.reset();
}
mSwapchainImages.clear();
for (auto &framebuffer : mSwapchainFramebuffers)
{
framebuffer.destroy(device);
}
if (mSwapchain)
{
......@@ -331,7 +332,7 @@ vk::Error WindowSurfaceVk::initializeImpl(RendererVk *renderer)
// CommandBuffer is a singleton in the Renderer.
vk::CommandBuffer *commandBuffer = renderer->getCommandBuffer();
ANGLE_TRY(commandBuffer->begin());
ANGLE_TRY(commandBuffer->begin(device));
VkClearColorValue transparentBlack;
transparentBlack.float32[0] = 0.0f;
......@@ -339,8 +340,13 @@ vk::Error WindowSurfaceVk::initializeImpl(RendererVk *renderer)
transparentBlack.float32[2] = 0.0f;
transparentBlack.float32[3] = 0.0f;
for (auto swapchainImage : swapchainImages)
mSwapchainImages.resize(imageCount);
mSwapchainImageViews.resize(imageCount);
for (uint32_t imageIndex = 0; imageIndex < imageCount; ++imageIndex)
{
VkImage swapchainImage = swapchainImages[imageIndex];
VkImageViewCreateInfo imageViewInfo;
imageViewInfo.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO;
imageViewInfo.pNext = nullptr;
......@@ -359,16 +365,16 @@ vk::Error WindowSurfaceVk::initializeImpl(RendererVk *renderer)
imageViewInfo.subresourceRange.layerCount = 1;
vk::Image image(swapchainImage);
vk::ImageView imageView(device);
ANGLE_TRY(imageView.init(imageViewInfo));
vk::ImageView imageView;
ANGLE_TRY(imageView.init(device, imageViewInfo));
// Set transfer dest layout, and clear the image to black.
image.changeLayoutTop(VK_IMAGE_ASPECT_COLOR_BIT, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
commandBuffer);
commandBuffer->clearSingleColorImage(image, transparentBlack);
mSwapchainImages.push_back(std::move(image));
mSwapchainImageViews.push_back(std::move(imageView));
mSwapchainImages[imageIndex].retain(device, std::move(image));
mSwapchainImageViews[imageIndex].retain(device, std::move(imageView));
}
ANGLE_TRY(commandBuffer->end());
......@@ -397,7 +403,7 @@ vk::Error WindowSurfaceVk::swapImpl(RendererVk *renderer)
auto *image = &mSwapchainImages[mCurrentSwapchainImageIndex];
currentCB->begin();
currentCB->begin(renderer->getDevice());
image->changeLayoutWithStages(VK_IMAGE_ASPECT_COLOR_BIT, VK_IMAGE_LAYOUT_PRESENT_SRC_KHR,
VK_PIPELINE_STAGE_ALL_COMMANDS_BIT,
VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT, currentCB);
......@@ -427,14 +433,14 @@ vk::Error WindowSurfaceVk::nextSwapchainImage(RendererVk *renderer)
{
VkDevice device = renderer->getDevice();
vk::Semaphore presentComplete(device);
ANGLE_TRY(presentComplete.init());
vk::Semaphore presentComplete;
ANGLE_TRY(presentComplete.init(device));
ANGLE_VK_TRY(vkAcquireNextImageKHR(device, mSwapchain, std::numeric_limits<uint64_t>::max(),
presentComplete.getHandle(), VK_NULL_HANDLE,
&mCurrentSwapchainImageIndex));
mPresentCompleteSemaphore = std::move(presentComplete);
mPresentCompleteSemaphore.retain(device, std::move(presentComplete));
// Update RenderTarget pointers.
mRenderTarget.image = &mSwapchainImages[mCurrentSwapchainImageIndex];
......@@ -522,15 +528,17 @@ gl::ErrorOrResult<vk::Framebuffer *> WindowSurfaceVk::getCurrentFramebuffer(
framebufferInfo.height = static_cast<uint32_t>(mRenderTarget.extents.height);
framebufferInfo.layers = 1;
for (const auto &imageView : mSwapchainImageViews)
mSwapchainFramebuffers.resize(mSwapchainImageViews.size());
for (size_t imageIndex = 0; imageIndex < mSwapchainFramebuffers.size(); ++imageIndex)
{
const auto &imageView = mSwapchainImageViews[imageIndex];
VkImageView imageViewHandle = imageView.getHandle();
framebufferInfo.pAttachments = &imageViewHandle;
vk::Framebuffer framebuffer(device);
ANGLE_TRY(framebuffer.init(framebufferInfo));
vk::Framebuffer framebuffer;
ANGLE_TRY(framebuffer.init(device, framebufferInfo));
mSwapchainFramebuffers.push_back(std::move(framebuffer));
mSwapchainFramebuffers[imageIndex].retain(device, std::move(framebuffer));
}
// We should only initialize framebuffers on the first swap.
......
src/libANGLE/renderer/vulkan/renderervk_utils.cpp
......@@ -9,7 +9,6 @@
#include "renderervk_utils.h"
#include "common/debug.h"
#include "libANGLE/renderer/vulkan/RendererVk.h"
namespace rx
......@@ -218,37 +217,41 @@ bool Error::isError() const
}
// CommandPool implementation.
CommandPool::CommandPool(VkDevice device) : WrappedObject(device)
CommandPool::CommandPool()
{
}
CommandPool::~CommandPool()
void CommandPool::destroy(VkDevice device)
{
if (mHandle)
if (valid())
{
ASSERT(validDevice());
vkDestroyCommandPool(mDevice, mHandle, nullptr);
vkDestroyCommandPool(device, mHandle, nullptr);
mHandle = VK_NULL_HANDLE;
}
}
Error CommandPool::init(const VkCommandPoolCreateInfo &createInfo)
Error CommandPool::init(VkDevice device, const VkCommandPoolCreateInfo &createInfo)
{
ASSERT(!valid() && validDevice());
ANGLE_VK_TRY(vkCreateCommandPool(mDevice, &createInfo, nullptr, &mHandle));
ASSERT(!valid());
ANGLE_VK_TRY(vkCreateCommandPool(device, &createInfo, nullptr, &mHandle));
return NoError();
}
// CommandBuffer implementation.
CommandBuffer::CommandBuffer(VkDevice device, CommandPool *commandPool)
: WrappedObject(device), mCommandPool(commandPool)
CommandBuffer::CommandBuffer() : mCommandPool(nullptr)
{
}
void CommandBuffer::setCommandPool(CommandPool *commandPool)
{
ASSERT(!mCommandPool && commandPool->valid());
mCommandPool = commandPool;
}
Error CommandBuffer::begin()
Error CommandBuffer::begin(VkDevice device)
{
if (mHandle == VK_NULL_HANDLE)
{
ASSERT(validDevice());
VkCommandBufferAllocateInfo commandBufferInfo;
commandBufferInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO;
commandBufferInfo.pNext = nullptr;
......@@ -256,7 +259,7 @@ Error CommandBuffer::begin()
commandBufferInfo.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY;
commandBufferInfo.commandBufferCount = 1;
ANGLE_VK_TRY(vkAllocateCommandBuffers(mDevice, &commandBufferInfo, &mHandle));
ANGLE_VK_TRY(vkAllocateCommandBuffers(device, &commandBufferInfo, &mHandle));
}
else
{
......@@ -299,12 +302,13 @@ void CommandBuffer::singleImageBarrier(VkPipelineStageFlags srcStageMask,
nullptr, 1, &imageMemoryBarrier);
}
CommandBuffer::~CommandBuffer()
void CommandBuffer::destroy(VkDevice device)
{
if (mHandle)
if (valid())
{
ASSERT(validDevice() && mCommandPool->valid());
vkFreeCommandBuffers(mDevice, mCommandPool->getHandle(), 1, &mHandle);
ASSERT(mCommandPool && mCommandPool->valid());
vkFreeCommandBuffers(device, mCommandPool->getHandle(), 1, &mHandle);
mHandle = VK_NULL_HANDLE;
}
}
......@@ -417,30 +421,14 @@ Image::Image() : mCurrentLayout(VK_IMAGE_LAYOUT_UNDEFINED)
{
}
Image::Image(VkDevice device) : WrappedObject(device), mCurrentLayout(VK_IMAGE_LAYOUT_UNDEFINED)
{
}
Image::Image(VkImage image) : mCurrentLayout(VK_IMAGE_LAYOUT_UNDEFINED)
{
mHandle = image;
}
Image::Image(Image &&other) : WrappedObject(std::move(other)), mCurrentLayout(other.mCurrentLayout)
Image::Image(VkImage image) : WrappedObject(image), mCurrentLayout(VK_IMAGE_LAYOUT_UNDEFINED)
{
other.mCurrentLayout = VK_IMAGE_LAYOUT_UNDEFINED;
}
Image &Image::operator=(Image &&other)
void Image::retain(VkDevice device, Image &&other)
{
assignOpBase(std::move(other));
WrappedObject::retain(device, std::move(other));
std::swap(mCurrentLayout, other.mCurrentLayout);
return *this;
}
Image::~Image()
{
ASSERT(mHandle == VK_NULL_HANDLE);
}
void Image::reset()
......@@ -457,10 +445,10 @@ void Image::destroy(VkDevice device)
}
}
Error Image::init(const VkImageCreateInfo &createInfo)
Error Image::init(VkDevice device, const VkImageCreateInfo &createInfo)
{
ASSERT(mHandle == VK_NULL_HANDLE && validDevice());
ANGLE_VK_TRY(vkCreateImage(mDevice, &createInfo, nullptr, &mHandle));
ASSERT(!valid());
ANGLE_VK_TRY(vkCreateImage(device, &createInfo, nullptr, &mHandle));
return NoError();
}
......@@ -529,16 +517,16 @@ void Image::changeLayoutWithStages(VkImageAspectFlags aspectMask,
mCurrentLayout = newLayout;
}
void Image::getMemoryRequirements(VkMemoryRequirements *requirementsOut) const
void Image::getMemoryRequirements(VkDevice device, VkMemoryRequirements *requirementsOut) const
{
ASSERT(valid());
vkGetImageMemoryRequirements(mDevice, mHandle, requirementsOut);
vkGetImageMemoryRequirements(device, mHandle, requirementsOut);
}
Error Image::bindMemory(const vk::DeviceMemory &deviceMemory)
Error Image::bindMemory(VkDevice device, const vk::DeviceMemory &deviceMemory)
{
ASSERT(valid() && deviceMemory.valid());
ANGLE_VK_TRY(vkBindImageMemory(mDevice, mHandle, deviceMemory.getHandle(), 0));
ANGLE_VK_TRY(vkBindImageMemory(device, mHandle, deviceMemory.getHandle(), 0));
return NoError();
}
......@@ -547,25 +535,6 @@ ImageView::ImageView()
{
}
ImageView::ImageView(VkDevice device) : WrappedObject(device)
{
}
ImageView::ImageView(ImageView &&other) : WrappedObject(std::move(other))
{
}
ImageView &ImageView::operator=(ImageView &&other)
{
assignOpBase(std::move(other));
return *this;
}
ImageView::~ImageView()
{
ASSERT(mHandle == VK_NULL_HANDLE);
}
void ImageView::destroy(VkDevice device)
{
if (valid())
......@@ -575,10 +544,9 @@ void ImageView::destroy(VkDevice device)
}
}
Error ImageView::init(const VkImageViewCreateInfo &createInfo)
Error ImageView::init(VkDevice device, const VkImageViewCreateInfo &createInfo)
{
ASSERT(validDevice());
ANGLE_VK_TRY(vkCreateImageView(mDevice, &createInfo, nullptr, &mHandle));
ANGLE_VK_TRY(vkCreateImageView(device, &createInfo, nullptr, &mHandle));
return NoError();
}
......@@ -587,39 +555,25 @@ Semaphore::Semaphore()
{
}
Semaphore::Semaphore(VkDevice device) : WrappedObject(device)
void Semaphore::destroy(VkDevice device)
{
}
Semaphore::Semaphore(Semaphore &&other) : WrappedObject(std::move(other))
{
}
Semaphore::~Semaphore()
{
if (mHandle != VK_NULL_HANDLE)
if (valid())
{
ASSERT(validDevice());
vkDestroySemaphore(mDevice, mHandle, nullptr);
vkDestroySemaphore(device, mHandle, nullptr);
mHandle = VK_NULL_HANDLE;
}
}
Semaphore &Semaphore::operator=(Semaphore &&other)
{
assignOpBase(std::move(other));
return *this;
}
Error Semaphore::init()
Error Semaphore::init(VkDevice device)
{
ASSERT(validDevice() && !valid());
ASSERT(!valid());
VkSemaphoreCreateInfo semaphoreInfo;
semaphoreInfo.sType = VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO;
semaphoreInfo.pNext = nullptr;
semaphoreInfo.flags = 0;
ANGLE_VK_TRY(vkCreateSemaphore(mDevice, &semaphoreInfo, nullptr, &mHandle));
ANGLE_VK_TRY(vkCreateSemaphore(device, &semaphoreInfo, nullptr, &mHandle));
return NoError();
}
......@@ -629,33 +583,19 @@ Framebuffer::Framebuffer()
{
}
Framebuffer::Framebuffer(VkDevice device) : WrappedObject(device)
void Framebuffer::destroy(VkDevice device)
{
}
Framebuffer::Framebuffer(Framebuffer &&other) : WrappedObject(std::move(other))
{
}
Framebuffer::~Framebuffer()
{
if (mHandle != VK_NULL_HANDLE)
if (valid())
{
ASSERT(validDevice());
vkDestroyFramebuffer(mDevice, mHandle, nullptr);
vkDestroyFramebuffer(device, mHandle, nullptr);
mHandle = VK_NULL_HANDLE;
}
}
Framebuffer &Framebuffer::operator=(Framebuffer &&other)
{
assignOpBase(std::move(other));
return *this;
}
Error Framebuffer::init(const VkFramebufferCreateInfo &createInfo)
Error Framebuffer::init(VkDevice device, const VkFramebufferCreateInfo &createInfo)
{
ASSERT(validDevice() && !valid());
ANGLE_VK_TRY(vkCreateFramebuffer(mDevice, &createInfo, nullptr, &mHandle));
ASSERT(!valid());
ANGLE_VK_TRY(vkCreateFramebuffer(device, &createInfo, nullptr, &mHandle));
return NoError();
}
......@@ -664,51 +604,38 @@ DeviceMemory::DeviceMemory()
{
}
DeviceMemory::DeviceMemory(VkDevice device) : WrappedObject(device)
void DeviceMemory::destroy(VkDevice device)
{
}
DeviceMemory::DeviceMemory(DeviceMemory &&other) : WrappedObject(std::move(other))
{
}
DeviceMemory::~DeviceMemory()
{
if (mHandle != VK_NULL_HANDLE)
if (valid())
{
ASSERT(validDevice());
vkFreeMemory(mDevice, mHandle, nullptr);
vkFreeMemory(device, mHandle, nullptr);
mHandle = VK_NULL_HANDLE;
}
}
DeviceMemory &DeviceMemory::operator=(DeviceMemory &&other)
Error DeviceMemory::allocate(VkDevice device, const VkMemoryAllocateInfo &allocInfo)
{
assignOpBase(std::move(other));
return *this;
}
Error DeviceMemory::allocate(const VkMemoryAllocateInfo &allocInfo)
{
ASSERT(validDevice() && !valid());
ANGLE_VK_TRY(vkAllocateMemory(mDevice, &allocInfo, nullptr, &mHandle));
ASSERT(!valid());
ANGLE_VK_TRY(vkAllocateMemory(device, &allocInfo, nullptr, &mHandle));
return NoError();
}
Error DeviceMemory::map(VkDeviceSize offset,
Error DeviceMemory::map(VkDevice device,
VkDeviceSize offset,
VkDeviceSize size,
VkMemoryMapFlags flags,
uint8_t **mapPointer)
{
ASSERT(valid());
ANGLE_VK_TRY(
vkMapMemory(mDevice, mHandle, offset, size, flags, reinterpret_cast<void **>(mapPointer)));
vkMapMemory(device, mHandle, offset, size, flags, reinterpret_cast<void **>(mapPointer)));
return NoError();
}
void DeviceMemory::unmap()
void DeviceMemory::unmap(VkDevice device)
{
ASSERT(valid());
vkUnmapMemory(mDevice, mHandle);
vkUnmapMemory(device, mHandle);
}
// RenderPass implementation.
......@@ -716,33 +643,19 @@ RenderPass::RenderPass()
{
}
RenderPass::RenderPass(VkDevice device) : WrappedObject(device)
{
}
RenderPass::RenderPass(RenderPass &&other) : WrappedObject(std::move(other))
void RenderPass::destroy(VkDevice device)
{
}
RenderPass::~RenderPass()
{
if (mHandle != VK_NULL_HANDLE)
if (valid())
{
ASSERT(validDevice());
vkDestroyRenderPass(mDevice, mHandle, nullptr);
vkDestroyRenderPass(device, mHandle, nullptr);
mHandle = VK_NULL_HANDLE;
}
}
RenderPass &RenderPass::operator=(RenderPass &&other)
{
assignOpBase(std::move(other));
return *this;
}
Error RenderPass::init(const VkRenderPassCreateInfo &createInfo)
Error RenderPass::init(VkDevice device, const VkRenderPassCreateInfo &createInfo)
{
ASSERT(validDevice() && !valid());
ANGLE_VK_TRY(vkCreateRenderPass(mDevice, &createInfo, nullptr, &mHandle));
ASSERT(!valid());
ANGLE_VK_TRY(vkCreateRenderPass(device, &createInfo, nullptr, &mHandle));
return NoError();
}
......@@ -751,31 +664,21 @@ StagingImage::StagingImage() : mSize(0)
{
}
StagingImage::StagingImage(VkDevice device) : mImage(device), mDeviceMemory(device), mSize(0)
{
}
StagingImage::StagingImage(StagingImage &&other)
: mImage(std::move(other.mImage)),
mDeviceMemory(std::move(other.mDeviceMemory)),
mSize(other.mSize)
void StagingImage::destroy(VkDevice device)
{
other.mSize = 0;
mImage.destroy(device);
mDeviceMemory.destroy(device);
}
StagingImage::~StagingImage()
void StagingImage::retain(VkDevice device, StagingImage &&other)
{
}
StagingImage &StagingImage::operator=(StagingImage &&other)
{
std::swap(mImage, other.mImage);
std::swap(mDeviceMemory, other.mDeviceMemory);
mImage.retain(device, std::move(other.mImage));
mDeviceMemory.retain(device, std::move(other.mDeviceMemory));
std::swap(mSize, other.mSize);
return *this;
}
Error StagingImage::init(uint32_t queueFamilyIndex,
Error StagingImage::init(VkDevice device,
uint32_t queueFamilyIndex,
uint32_t hostVisibleMemoryIndex,
TextureDimension dimension,
VkFormat format,
......@@ -801,10 +704,10 @@ Error StagingImage::init(uint32_t queueFamilyIndex,
createInfo.pQueueFamilyIndices = &queueFamilyIndex;
createInfo.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
ANGLE_TRY(mImage.init(createInfo));
ANGLE_TRY(mImage.init(device, createInfo));
VkMemoryRequirements memoryRequirements;
mImage.getMemoryRequirements(&memoryRequirements);
mImage.getMemoryRequirements(device, &memoryRequirements);
// Ensure we can read this memory.
ANGLE_VK_CHECK((memoryRequirements.memoryTypeBits & (1 << hostVisibleMemoryIndex)) != 0,
......@@ -816,8 +719,8 @@ Error StagingImage::init(uint32_t queueFamilyIndex,
allocateInfo.allocationSize = memoryRequirements.size;
allocateInfo.memoryTypeIndex = hostVisibleMemoryIndex;
ANGLE_TRY(mDeviceMemory.allocate(allocateInfo));
ANGLE_TRY(mImage.bindMemory(mDeviceMemory));
ANGLE_TRY(mDeviceMemory.allocate(device, allocateInfo));
ANGLE_TRY(mImage.bindMemory(device, mDeviceMemory));
mSize = memoryRequirements.size;
......@@ -829,42 +732,34 @@ Buffer::Buffer()
{
}
Buffer::Buffer(VkDevice device) : WrappedObject(device), mMemory(device)
{
}
Buffer::Buffer(Buffer &&other)
: WrappedObject(std::move(other)), mMemory(std::move(other.getMemory()))
void Buffer::destroy(VkDevice device)
{
}
Buffer::~Buffer()
{
if (mHandle != VK_NULL_HANDLE)
if (valid())
{
ASSERT(validDevice());
vkDestroyBuffer(mDevice, mHandle, nullptr);
mMemory.destroy(device);
vkDestroyBuffer(device, mHandle, nullptr);
mHandle = VK_NULL_HANDLE;
}
}
Buffer &Buffer::operator=(Buffer &&other)
void Buffer::retain(VkDevice device, Buffer &&other)
{
assignOpBase(std::move(other));
std::swap(mMemory, other.mMemory);
return *this;
WrappedObject::retain(device, std::move(other));
mMemory.retain(device, std::move(other.mMemory));
}
Error Buffer::init(const VkBufferCreateInfo &createInfo)
Error Buffer::init(VkDevice device, const VkBufferCreateInfo &createInfo)
{
ASSERT(validDevice() && !valid());
ANGLE_VK_TRY(vkCreateBuffer(mDevice, &createInfo, nullptr, &mHandle));
ASSERT(!valid());
ANGLE_VK_TRY(vkCreateBuffer(device, &createInfo, nullptr, &mHandle));
return NoError();
}
Error Buffer::bindMemory()
Error Buffer::bindMemory(VkDevice device)
{
ASSERT(valid() && mMemory.valid());
ANGLE_VK_TRY(vkBindBufferMemory(mDevice, mHandle, mMemory.getHandle(), 0));
ANGLE_VK_TRY(vkBindBufferMemory(device, mHandle, mMemory.getHandle(), 0));
return NoError();
}
......@@ -873,33 +768,19 @@ ShaderModule::ShaderModule()
{
}
ShaderModule::ShaderModule(VkDevice device) : WrappedObject(device)
{
}
ShaderModule::ShaderModule(ShaderModule &&other) : WrappedObject(std::move(other))
{
}
ShaderModule::~ShaderModule()
void ShaderModule::destroy(VkDevice device)
{
if (mHandle != VK_NULL_HANDLE)
{
ASSERT(validDevice());
vkDestroyShaderModule(mDevice, mHandle, nullptr);
vkDestroyShaderModule(device, mHandle, nullptr);
mHandle = VK_NULL_HANDLE;
}
}
ShaderModule &ShaderModule::operator=(ShaderModule &&other)
{
assignOpBase(std::move(other));
return *this;
}
Error ShaderModule::init(const VkShaderModuleCreateInfo &createInfo)
Error ShaderModule::init(VkDevice device, const VkShaderModuleCreateInfo &createInfo)
{
ASSERT(validDevice() && !valid());
ANGLE_VK_TRY(vkCreateShaderModule(mDevice, &createInfo, nullptr, &mHandle));
ASSERT(!valid());
ANGLE_VK_TRY(vkCreateShaderModule(device, &createInfo, nullptr, &mHandle));
return NoError();
}
......@@ -908,35 +789,20 @@ Pipeline::Pipeline()
{
}
Pipeline::Pipeline(VkDevice device) : WrappedObject(device)
void Pipeline::destroy(VkDevice device)
{
}
Pipeline::Pipeline(Pipeline &&other) : WrappedObject(std::move(other))
{
}
Pipeline::~Pipeline()
{
if (mHandle)
if (valid())
{
ASSERT(validDevice());
vkDestroyPipeline(mDevice, mHandle, nullptr);
vkDestroyPipeline(device, mHandle, nullptr);
mHandle = VK_NULL_HANDLE;
}
}
Pipeline &Pipeline::operator=(Pipeline &&other)
Error Pipeline::initGraphics(VkDevice device, const VkGraphicsPipelineCreateInfo &createInfo)
{
std::swap(mDevice, other.mDevice);
std::swap(mHandle, other.mHandle);
return *this;
}
Error Pipeline::initGraphics(const VkGraphicsPipelineCreateInfo &createInfo)
{
ASSERT(validDevice() && !valid());
ASSERT(!valid());
ANGLE_VK_TRY(
vkCreateGraphicsPipelines(mDevice, VK_NULL_HANDLE, 1, &createInfo, nullptr, &mHandle));
vkCreateGraphicsPipelines(device, VK_NULL_HANDLE, 1, &createInfo, nullptr, &mHandle));
return NoError();
}
......@@ -945,33 +811,19 @@ PipelineLayout::PipelineLayout()
{
}
PipelineLayout::PipelineLayout(VkDevice device) : WrappedObject(device)
{
}
PipelineLayout::PipelineLayout(PipelineLayout &&other) : WrappedObject(std::move(other))
void PipelineLayout::destroy(VkDevice device)
{
}
PipelineLayout::~PipelineLayout()
{
if (mHandle != VK_NULL_HANDLE)
if (valid())
{
ASSERT(validDevice());
vkDestroyPipelineLayout(mDevice, mHandle, nullptr);
vkDestroyPipelineLayout(device, mHandle, nullptr);
mHandle = VK_NULL_HANDLE;
}
}
PipelineLayout &PipelineLayout::operator=(PipelineLayout &&other)
{
assignOpBase(std::move(other));
return *this;
}
Error PipelineLayout::init(const VkPipelineLayoutCreateInfo &createInfo)
Error PipelineLayout::init(VkDevice device, const VkPipelineLayoutCreateInfo &createInfo)
{
ASSERT(validDevice() && !valid());
ANGLE_VK_TRY(vkCreatePipelineLayout(mDevice, &createInfo, nullptr, &mHandle));
ASSERT(!valid());
ANGLE_VK_TRY(vkCreatePipelineLayout(device, &createInfo, nullptr, &mHandle));
return NoError();
}
......
src/libANGLE/renderer/vulkan/renderervk_utils.h
......@@ -12,6 +12,7 @@
#include <vulkan/vulkan.h>
#include "common/debug.h"
#include "common/Optional.h"
#include "libANGLE/Error.h"
......@@ -86,51 +87,56 @@ inline Error NoError()
return Error(VK_SUCCESS);
}
template <typename HandleT>
template <typename DerivedT, typename HandleT>
class WrappedObject : angle::NonCopyable
{
public:
WrappedObject() : mDevice(VK_NULL_HANDLE), mHandle(VK_NULL_HANDLE) {}
explicit WrappedObject(VkDevice device) : mDevice(device), mHandle(VK_NULL_HANDLE) {}
WrappedObject(WrappedObject &&other) : mDevice(other.mDevice), mHandle(other.mHandle)
HandleT getHandle() const { return mHandle; }
bool valid() const { return (mHandle != VK_NULL_HANDLE); }
protected:
WrappedObject() : mHandle(VK_NULL_HANDLE) {}
WrappedObject(HandleT handle) : mHandle(handle) {}
~WrappedObject() { ASSERT(!valid()); }
// Only works to initialize empty objects, since we don't have the device handle.
WrappedObject(WrappedObject &&other) : mHandle(other.mHandle)
{
other.mDevice = VK_NULL_HANDLE;
other.mHandle = VK_NULL_HANDLE;
}
virtual ~WrappedObject() {}
HandleT getHandle() const { return mHandle; }
bool validDevice() const { return (mDevice != VK_NULL_HANDLE); }
bool valid() const { return (mHandle != VK_NULL_HANDLE) && validDevice(); }
protected:
void assignOpBase(WrappedObject &&other)
void retain(VkDevice device, DerivedT &&other)
{
std::swap(mDevice, other.mDevice);
if (valid())
{
static_cast<DerivedT *>(this)->destroy(device);
}
std::swap(mHandle, other.mHandle);
}
VkDevice mDevice;
HandleT mHandle;
};
class CommandPool final : public WrappedObject<VkCommandPool>
class CommandPool final : public WrappedObject<CommandPool, VkCommandPool>
{
public:
CommandPool(VkDevice device);
~CommandPool() override;
CommandPool();
void destroy(VkDevice device);
Error init(const VkCommandPoolCreateInfo &createInfo);
Error init(VkDevice device, const VkCommandPoolCreateInfo &createInfo);
};
// Helper class that wraps a Vulkan command buffer.
class CommandBuffer final : public WrappedObject<VkCommandBuffer>
class CommandBuffer final : public WrappedObject<CommandBuffer, VkCommandBuffer>
{
public:
CommandBuffer(VkDevice device, CommandPool *commandPool);
~CommandBuffer() override;
CommandBuffer();
Error begin();
void destroy(VkDevice device);
void setCommandPool(CommandPool *commandPool);
Error begin(VkDevice device);
Error end();
Error reset();
......@@ -166,14 +172,12 @@ class CommandBuffer final : public WrappedObject<VkCommandBuffer>
CommandPool *mCommandPool;
};
class Image final : public WrappedObject<VkImage>
class Image final : public WrappedObject<Image, VkImage>
{
public:
// Use this constructor if the lifetime of the image is not controlled by ANGLE. (SwapChain)
Image();
Image(VkDevice device);
explicit Image(VkImage image);
Image(Image &&other);
// Called on shutdown when the helper class *doesn't* own the handle to the image resource.
void reset();
......@@ -181,11 +185,9 @@ class Image final : public WrappedObject<VkImage>
// Called on shutdown when the helper class *does* own the handle to the image resource.
void destroy(VkDevice device);
Image &operator=(Image &&other);
~Image() override;
void retain(VkDevice device, Image &&other);
Error init(const VkImageCreateInfo &createInfo);
Error init(VkDevice device, const VkImageCreateInfo &createInfo);
void changeLayoutTop(VkImageAspectFlags aspectMask,
VkImageLayout newLayout,
......@@ -197,8 +199,8 @@ class Image final : public WrappedObject<VkImage>
VkPipelineStageFlags dstStageMask,
CommandBuffer *commandBuffer);
void getMemoryRequirements(VkMemoryRequirements *requirementsOut) const;
Error bindMemory(const vk::DeviceMemory &deviceMemory);
void getMemoryRequirements(VkDevice device, VkMemoryRequirements *requirementsOut) const;
Error bindMemory(VkDevice device, const vk::DeviceMemory &deviceMemory);
VkImageLayout getCurrentLayout() const { return mCurrentLayout; }
void updateLayout(VkImageLayout layout) { mCurrentLayout = layout; }
......@@ -207,82 +209,71 @@ class Image final : public WrappedObject<VkImage>
VkImageLayout mCurrentLayout;
};
class ImageView final : public WrappedObject<VkImageView>
class ImageView final : public WrappedObject<ImageView, VkImageView>
{
public:
ImageView();
explicit ImageView(VkDevice device);
ImageView(ImageView &&other);
void destroy(VkDevice device);
using WrappedObject::retain;
ImageView &operator=(ImageView &&other);
~ImageView() override;
Error init(const VkImageViewCreateInfo &createInfo);
Error init(VkDevice device, const VkImageViewCreateInfo &createInfo);
};
class Semaphore final : public WrappedObject<VkSemaphore>
class Semaphore final : public WrappedObject<Semaphore, VkSemaphore>
{
public:
Semaphore();
Semaphore(VkDevice device);
Semaphore(Semaphore &&other);
~Semaphore();
Semaphore &operator=(Semaphore &&other);
void destroy(VkDevice device);
using WrappedObject::retain;
Error init();
Error init(VkDevice device);
};
class Framebuffer final : public WrappedObject<VkFramebuffer>
class Framebuffer final : public WrappedObject<Framebuffer, VkFramebuffer>
{
public:
Framebuffer();
Framebuffer(VkDevice device);
Framebuffer(Framebuffer &&other);
~Framebuffer();
Framebuffer &operator=(Framebuffer &&other);
void destroy(VkDevice device);
using WrappedObject::retain;
Error init(const VkFramebufferCreateInfo &createInfo);
Error init(VkDevice device, const VkFramebufferCreateInfo &createInfo);
};
class DeviceMemory final : public WrappedObject<VkDeviceMemory>
class DeviceMemory final : public WrappedObject<DeviceMemory, VkDeviceMemory>
{
public:
DeviceMemory();
DeviceMemory(VkDevice device);
DeviceMemory(DeviceMemory &&other);
~DeviceMemory();
DeviceMemory &operator=(DeviceMemory &&other);
Error allocate(const VkMemoryAllocateInfo &allocInfo);
Error map(VkDeviceSize offset, VkDeviceSize size, VkMemoryMapFlags flags, uint8_t **mapPointer);
void unmap();
void destroy(VkDevice device);
using WrappedObject::retain;
Error allocate(VkDevice device, const VkMemoryAllocateInfo &allocInfo);
Error map(VkDevice device,
VkDeviceSize offset,
VkDeviceSize size,
VkMemoryMapFlags flags,
uint8_t **mapPointer);
void unmap(VkDevice device);
};
class RenderPass final : public WrappedObject<VkRenderPass>
class RenderPass final : public WrappedObject<RenderPass, VkRenderPass>
{
public:
RenderPass();
RenderPass(VkDevice device);
RenderPass(RenderPass &&other);
~RenderPass();
RenderPass &operator=(RenderPass &&other);
void destroy(VkDevice device);
using WrappedObject::retain;
Error init(const VkRenderPassCreateInfo &createInfo);
Error init(VkDevice device, const VkRenderPassCreateInfo &createInfo);
};
class StagingImage final : angle::NonCopyable
{
public:
StagingImage();
StagingImage(VkDevice device);
StagingImage(StagingImage &&other);
~StagingImage();
StagingImage &operator=(StagingImage &&other);
void destroy(VkDevice device);
void retain(VkDevice device, StagingImage &&other);
vk::Error init(uint32_t queueFamilyIndex,
vk::Error init(VkDevice device,
uint32_t queueFamilyIndex,
uint32_t hostVisibleMemoryIndex,
TextureDimension dimension,
VkFormat format,
......@@ -300,17 +291,15 @@ class StagingImage final : angle::NonCopyable
VkDeviceSize mSize;
};
class Buffer final : public WrappedObject<VkBuffer>
class Buffer final : public WrappedObject<Buffer, VkBuffer>
{
public:
Buffer();
Buffer(VkDevice device);
Buffer(Buffer &&other);
~Buffer();
Buffer &operator=(Buffer &&other);
void destroy(VkDevice device);
void retain(VkDevice device, Buffer &&other);
Error init(const VkBufferCreateInfo &createInfo);
Error bindMemory();
Error init(VkDevice device, const VkBufferCreateInfo &createInfo);
Error bindMemory(VkDevice device);
DeviceMemory &getMemory() { return mMemory; }
const DeviceMemory &getMemory() const { return mMemory; }
......@@ -319,40 +308,34 @@ class Buffer final : public WrappedObject<VkBuffer>
DeviceMemory mMemory;
};
class ShaderModule final : public WrappedObject<VkShaderModule>
class ShaderModule final : public WrappedObject<ShaderModule, VkShaderModule>
{
public:
ShaderModule();
ShaderModule(VkDevice device);
ShaderModule(ShaderModule &&other);
~ShaderModule() override;
ShaderModule &operator=(ShaderModule &&other);
void destroy(VkDevice device);
using WrappedObject::retain;
Error init(const VkShaderModuleCreateInfo &createInfo);
Error init(VkDevice device, const VkShaderModuleCreateInfo &createInfo);
};
class Pipeline final : public WrappedObject<VkPipeline>
class Pipeline final : public WrappedObject<Pipeline, VkPipeline>
{
public:
Pipeline();
Pipeline(VkDevice device);
Pipeline(Pipeline &&other);
~Pipeline();
Pipeline &operator=(Pipeline &&other);
void destroy(VkDevice device);
using WrappedObject::retain;
Error initGraphics(const VkGraphicsPipelineCreateInfo &createInfo);
Error initGraphics(VkDevice device, const VkGraphicsPipelineCreateInfo &createInfo);
};
class PipelineLayout final : public WrappedObject<VkPipelineLayout>
class PipelineLayout final : public WrappedObject<PipelineLayout, VkPipelineLayout>
{
public:
PipelineLayout();
PipelineLayout(VkDevice device);
PipelineLayout(PipelineLayout &&other);
~PipelineLayout();
PipelineLayout &operator=(PipelineLayout &&other);
void destroy(VkDevice device);
using WrappedObject::retain;
Error init(const VkPipelineLayoutCreateInfo &createInfo);
Error init(VkDevice device, const VkPipelineLayoutCreateInfo &createInfo);
};
} // namespace vk
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment