aboutsummaryrefslogtreecommitdiffhomepage
diff options
context:
space:
mode:
Diffstat
-rw-r--r--gm/imagefromyuvtextures.cpp6
-rw-r--r--include/gpu/vk/GrVkTypes.h14
-rw-r--r--src/gpu/vk/GrVkCommandBuffer.cpp26
-rw-r--r--src/gpu/vk/GrVkCommandBuffer.h24
-rw-r--r--src/gpu/vk/GrVkGpu.cpp57
-rw-r--r--src/gpu/vk/GrVkImage.cpp46
-rw-r--r--src/gpu/vk/GrVkImage.h118
-rw-r--r--src/gpu/vk/GrVkPipelineState.cpp2
-rw-r--r--src/gpu/vk/GrVkPipelineState.h2
-rw-r--r--src/gpu/vk/GrVkRenderTarget.cpp131
-rw-r--r--src/gpu/vk/GrVkRenderTarget.h61
-rw-r--r--src/gpu/vk/GrVkStencilAttachment.cpp16
-rw-r--r--src/gpu/vk/GrVkStencilAttachment.h4
-rw-r--r--src/gpu/vk/GrVkTexture.cpp118
-rw-r--r--src/gpu/vk/GrVkTexture.h17
-rw-r--r--src/gpu/vk/GrVkTextureRenderTarget.cpp104
-rw-r--r--src/gpu/vk/GrVkTextureRenderTarget.h61
-rw-r--r--tests/VkWrapTests.cpp12
-rw-r--r--tools/viewer/sk_app/VulkanWindowContext.cpp2
19 files changed, 401 insertions, 420 deletions
diff --git a/gm/imagefromyuvtextures.cpp b/gm/imagefromyuvtextures.cpp
index a34ec6e513..5fa55da388 100644
--- a/gm/imagefromyuvtextures.cpp
+++ b/gm/imagefromyuvtextures.cpp
@@ -129,8 +129,6 @@ protected:
return;
}
- GrBackendObject yuvHandles[3];
- this->createYUVTextures(context, yuvHandles);
static const SkScalar kPad = 10.f;
@@ -142,12 +140,14 @@ protected:
SkTArray<sk_sp<SkImage>> images;
images.push_back(fRGBImage);
for (int space = kJPEG_SkYUVColorSpace; space <= kLastEnum_SkYUVColorSpace; ++space) {
+ GrBackendObject yuvHandles[3];
+ this->createYUVTextures(context, yuvHandles);
images.push_back(SkImage::MakeFromYUVTexturesCopy(context,
static_cast<SkYUVColorSpace>(space),
yuvHandles, sizes,
kTopLeft_GrSurfaceOrigin));
+ this->deleteYUVTextures(context, yuvHandles);
}
- this->deleteYUVTextures(context, yuvHandles);
for (int i = 0; i < images.count(); ++ i) {
SkScalar y = (i + 1) * kPad + i * fYUVBmps[0].height();
SkScalar x = kPad;
diff --git a/include/gpu/vk/GrVkTypes.h b/include/gpu/vk/GrVkTypes.h
index 2e6a255630..deee409e6f 100644
--- a/include/gpu/vk/GrVkTypes.h
+++ b/include/gpu/vk/GrVkTypes.h
@@ -27,18 +27,22 @@
///////////////////////////////////////////////////////////////////////////////
/**
* Types for interacting with Vulkan resources created externally to Skia. GrBackendObjects for
- * Vulkan textures are really const GrVkTextureInfo*
+ * Vulkan textures are really const GrVkImageInfo*
*/
-
-struct GrVkTextureInfo {
+struct GrVkImageInfo {
VkImage fImage;
- VkDeviceMemory fAlloc; // this may be null iff the texture is an RT and uses borrow semantics
+ VkDeviceMemory fAlloc; // can be VK_NULL_HANDLE iff Tex is an RT and uses borrow semantics
VkImageTiling fImageTiling;
VkImageLayout fImageLayout;
VkFormat fFormat;
uint32_t fLevelCount;
+
+ // This gives a way for a client to update the layout of the Image if they change the layout
+ // while we're still holding onto the wrapped texture. They will first need to get a handle
+ // to our internal GrVkImageInfo by calling getTextureHandle on a GrVkTexture.
+ void updateImageLayout(VkImageLayout layout) { fImageLayout = layout; }
};
-GR_STATIC_ASSERT(sizeof(GrBackendObject) >= sizeof(const GrVkTextureInfo*));
+GR_STATIC_ASSERT(sizeof(GrBackendObject) >= sizeof(const GrVkImageInfo*));
#endif
diff --git a/src/gpu/vk/GrVkCommandBuffer.cpp b/src/gpu/vk/GrVkCommandBuffer.cpp
index 5bd43f26b3..bc8c20f016 100644
--- a/src/gpu/vk/GrVkCommandBuffer.cpp
+++ b/src/gpu/vk/GrVkCommandBuffer.cpp
@@ -251,30 +251,32 @@ void GrVkCommandBuffer::copyImage(const GrVkGpu* gpu,
this->addResource(srcImage->resource());
this->addResource(dstImage->resource());
GR_VK_CALL(gpu->vkInterface(), CmdCopyImage(fCmdBuffer,
- srcImage->textureImage(),
+ srcImage->image(),
srcLayout,
- dstImage->textureImage(),
+ dstImage->image(),
dstLayout,
copyRegionCount,
copyRegions));
}
void GrVkCommandBuffer::blitImage(const GrVkGpu* gpu,
- const GrVkImage::Resource* srcImage,
+ const GrVkResource* srcResource,
+ VkImage srcImage,
VkImageLayout srcLayout,
- const GrVkImage::Resource* dstImage,
+ const GrVkResource* dstResource,
+ VkImage dstImage,
VkImageLayout dstLayout,
uint32_t blitRegionCount,
const VkImageBlit* blitRegions,
VkFilter filter) {
SkASSERT(fIsActive);
SkASSERT(!fActiveRenderPass);
- this->addResource(srcImage);
- this->addResource(dstImage);
+ this->addResource(srcResource);
+ this->addResource(dstResource);
GR_VK_CALL(gpu->vkInterface(), CmdBlitImage(fCmdBuffer,
- srcImage->fImage,
+ srcImage,
srcLayout,
- dstImage->fImage,
+ dstImage,
dstLayout,
blitRegionCount,
blitRegions,
@@ -292,7 +294,7 @@ void GrVkCommandBuffer::copyImageToBuffer(const GrVkGpu* gpu,
this->addResource(srcImage->resource());
this->addResource(dstBuffer->resource());
GR_VK_CALL(gpu->vkInterface(), CmdCopyImageToBuffer(fCmdBuffer,
- srcImage->textureImage(),
+ srcImage->image(),
srcLayout,
dstBuffer->buffer(),
copyRegionCount,
@@ -311,7 +313,7 @@ void GrVkCommandBuffer::copyBufferToImage(const GrVkGpu* gpu,
this->addResource(dstImage->resource());
GR_VK_CALL(gpu->vkInterface(), CmdCopyBufferToImage(fCmdBuffer,
srcBuffer->buffer(),
- dstImage->textureImage(),
+ dstImage->image(),
dstLayout,
copyRegionCount,
copyRegions));
@@ -326,7 +328,7 @@ void GrVkCommandBuffer::clearColorImage(const GrVkGpu* gpu,
SkASSERT(!fActiveRenderPass);
this->addResource(image->resource());
GR_VK_CALL(gpu->vkInterface(), CmdClearColorImage(fCmdBuffer,
- image->textureImage(),
+ image->image(),
image->currentLayout(),
color,
subRangeCount,
@@ -342,7 +344,7 @@ void GrVkCommandBuffer::clearDepthStencilImage(const GrVkGpu* gpu,
SkASSERT(!fActiveRenderPass);
this->addResource(image->resource());
GR_VK_CALL(gpu->vkInterface(), CmdClearDepthStencilImage(fCmdBuffer,
- image->textureImage(),
+ image->image(),
image->currentLayout(),
color,
subRangeCount,
diff --git a/src/gpu/vk/GrVkCommandBuffer.h b/src/gpu/vk/GrVkCommandBuffer.h
index b2f6ef013f..b513a47f29 100644
--- a/src/gpu/vk/GrVkCommandBuffer.h
+++ b/src/gpu/vk/GrVkCommandBuffer.h
@@ -127,14 +127,34 @@ public:
const VkImageCopy* copyRegions);
void blitImage(const GrVkGpu* gpu,
- const GrVkImage::Resource* srcImage,
+ const GrVkResource* srcResource,
+ VkImage srcImage,
VkImageLayout srcLayout,
- const GrVkImage::Resource* dstImage,
+ const GrVkResource* dstResource,
+ VkImage dstImage,
VkImageLayout dstLayout,
uint32_t blitRegionCount,
const VkImageBlit* blitRegions,
VkFilter filter);
+ void blitImage(const GrVkGpu* gpu,
+ const GrVkImage& srcImage,
+ const GrVkImage& dstImage,
+ uint32_t blitRegionCount,
+ const VkImageBlit* blitRegions,
+ VkFilter filter) {
+ this->blitImage(gpu,
+ srcImage.resource(),
+ srcImage.image(),
+ srcImage.currentLayout(),
+ dstImage.resource(),
+ dstImage.image(),
+ dstImage.currentLayout(),
+ blitRegionCount,
+ blitRegions,
+ filter);
+ }
+
void copyImageToBuffer(const GrVkGpu* gpu,
GrVkImage* srcImage,
VkImageLayout srcLayout,
diff --git a/src/gpu/vk/GrVkGpu.cpp b/src/gpu/vk/GrVkGpu.cpp
index c24d8c2799..f87a6f6fbd 100644
--- a/src/gpu/vk/GrVkGpu.cpp
+++ b/src/gpu/vk/GrVkGpu.cpp
@@ -326,7 +326,7 @@ bool GrVkGpu::uploadTexDataLinear(GrVkTexture* tex,
const GrVkInterface* interface = this->vkInterface();
GR_VK_CALL(interface, GetImageSubresourceLayout(fDevice,
- tex->textureImage(),
+ tex->image(),
&subres,
&layout));
@@ -334,8 +334,7 @@ bool GrVkGpu::uploadTexDataLinear(GrVkTexture* tex,
VkDeviceSize offset = texTop*layout.rowPitch + left*bpp;
VkDeviceSize size = height*layout.rowPitch;
void* mapPtr;
- err = GR_VK_CALL(interface, MapMemory(fDevice, tex->textureMemory(), offset, size, 0,
- &mapPtr));
+ err = GR_VK_CALL(interface, MapMemory(fDevice, tex->memory(), offset, size, 0, &mapPtr));
if (err) {
return false;
}
@@ -359,7 +358,7 @@ bool GrVkGpu::uploadTexDataLinear(GrVkTexture* tex,
}
}
- GR_VK_CALL(interface, UnmapMemory(fDevice, tex->textureMemory()));
+ GR_VK_CALL(interface, UnmapMemory(fDevice, tex->memory()));
return true;
}
@@ -608,11 +607,6 @@ static GrSurfaceOrigin resolve_origin(GrSurfaceOrigin origin) {
GrTexture* GrVkGpu::onWrapBackendTexture(const GrBackendTextureDesc& desc,
GrWrapOwnership ownership) {
- VkFormat format;
- if (!GrPixelConfigToVkFormat(desc.fConfig, &format)) {
- return nullptr;
- }
-
if (0 == desc.fTextureHandle) {
return nullptr;
}
@@ -622,10 +616,17 @@ GrTexture* GrVkGpu::onWrapBackendTexture(const GrBackendTextureDesc& desc,
return nullptr;
}
- const GrVkTextureInfo* info = reinterpret_cast<const GrVkTextureInfo*>(desc.fTextureHandle);
+ const GrVkImageInfo* info = reinterpret_cast<const GrVkImageInfo*>(desc.fTextureHandle);
if (VK_NULL_HANDLE == info->fImage || VK_NULL_HANDLE == info->fAlloc) {
return nullptr;
}
+#ifdef SK_DEBUG
+ VkFormat format;
+ if (!GrPixelConfigToVkFormat(desc.fConfig, &format)) {
+ return nullptr;
+ }
+ SkASSERT(format == info->fFormat);
+#endif
GrSurfaceDesc surfDesc;
// next line relies on GrBackendTextureDesc's flags matching GrTexture's
@@ -642,10 +643,9 @@ GrTexture* GrVkGpu::onWrapBackendTexture(const GrBackendTextureDesc& desc,
GrVkTexture* texture = nullptr;
if (renderTarget) {
texture = GrVkTextureRenderTarget::CreateWrappedTextureRenderTarget(this, surfDesc,
- ownership, format,
- info);
+ ownership, info);
} else {
- texture = GrVkTexture::CreateWrappedTexture(this, surfDesc, ownership, format, info);
+ texture = GrVkTexture::CreateWrappedTexture(this, surfDesc, ownership, info);
}
if (!texture) {
return nullptr;
@@ -657,8 +657,8 @@ GrTexture* GrVkGpu::onWrapBackendTexture(const GrBackendTextureDesc& desc,
GrRenderTarget* GrVkGpu::onWrapBackendRenderTarget(const GrBackendRenderTargetDesc& wrapDesc,
GrWrapOwnership ownership) {
- const GrVkTextureInfo* info =
- reinterpret_cast<const GrVkTextureInfo*>(wrapDesc.fRenderTargetHandle);
+ const GrVkImageInfo* info =
+ reinterpret_cast<const GrVkImageInfo*>(wrapDesc.fRenderTargetHandle);
if (VK_NULL_HANDLE == info->fImage ||
(VK_NULL_HANDLE == info->fAlloc && kAdopt_GrWrapOwnership == ownership)) {
return nullptr;
@@ -710,8 +710,9 @@ void GrVkGpu::generateMipmap(GrVkTexture* tex) const {
VK_ACCESS_TRANSFER_READ_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, false);
// grab handle to the original image resource
- const GrVkImage::Resource* oldResource = tex->resource();
+ const GrVkResource* oldResource = tex->resource();
oldResource->ref();
+ VkImage oldImage = tex->image();
// SkMipMap doesn't include the base level in the level count so we have to add 1
uint32_t levelCount = SkMipMap::ComputeLevelCount(tex->width(), tex->height()) + 1;
@@ -739,15 +740,17 @@ void GrVkGpu::generateMipmap(GrVkTexture* tex) const {
fCurrentCmdBuffer->blitImage(this,
oldResource,
+ oldImage,
VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
tex->resource(),
+ tex->image(),
VK_IMAGE_LAYOUT_GENERAL,
1,
&blitRegion,
VK_FILTER_LINEAR);
// setup memory barrier
- SkASSERT(GrVkFormatToPixelConfig(tex->resource()->fFormat, nullptr));
+ SkASSERT(GrVkFormatToPixelConfig(tex->imageFormat(), nullptr));
VkImageAspectFlags aspectFlags = VK_IMAGE_ASPECT_COLOR_BIT;
VkImageMemoryBarrier imageMemoryBarrier = {
VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, // sType
@@ -758,7 +761,7 @@ void GrVkGpu::generateMipmap(GrVkTexture* tex) const {
VK_IMAGE_LAYOUT_GENERAL, // newLayout
VK_QUEUE_FAMILY_IGNORED, // srcQueueFamilyIndex
VK_QUEUE_FAMILY_IGNORED, // dstQueueFamilyIndex
- tex->resource()->fImage, // image
+ tex->image(), // image
{ aspectFlags, 0, 1, 0, 1 } // subresourceRange
};
@@ -781,10 +784,8 @@ void GrVkGpu::generateMipmap(GrVkTexture* tex) const {
blitRegion.dstOffsets[0] = { 0, 0, 0 };
blitRegion.dstOffsets[1] = { width, height, 0 };
fCurrentCmdBuffer->blitImage(this,
- tex->resource(),
- VK_IMAGE_LAYOUT_GENERAL,
- tex->resource(),
- VK_IMAGE_LAYOUT_GENERAL,
+ *tex,
+ *tex,
1,
&blitRegion,
VK_FILTER_LINEAR);
@@ -947,7 +948,7 @@ GrBackendObject GrVkGpu::createTestingOnlyBackendTexture(void* srcData, int w, i
}
}
- GrVkTextureInfo* info = new GrVkTextureInfo;
+ GrVkImageInfo* info = new GrVkImageInfo;
info->fImage = image;
info->fAlloc = alloc;
info->fImageTiling = imageTiling;
@@ -959,7 +960,7 @@ GrBackendObject GrVkGpu::createTestingOnlyBackendTexture(void* srcData, int w, i
}
bool GrVkGpu::isTestingOnlyBackendTexture(GrBackendObject id) const {
- const GrVkTextureInfo* backend = reinterpret_cast<const GrVkTextureInfo*>(id);
+ const GrVkImageInfo* backend = reinterpret_cast<const GrVkImageInfo*>(id);
if (backend && backend->fImage && backend->fAlloc) {
VkMemoryRequirements req;
@@ -976,7 +977,7 @@ bool GrVkGpu::isTestingOnlyBackendTexture(GrBackendObject id) const {
}
void GrVkGpu::deleteTestingOnlyBackendTexture(GrBackendObject id, bool abandon) {
- const GrVkTextureInfo* backend = reinterpret_cast<const GrVkTextureInfo*>(id);
+ const GrVkImageInfo* backend = reinterpret_cast<const GrVkImageInfo*>(id);
if (backend) {
if (!abandon) {
@@ -1379,10 +1380,8 @@ void GrVkGpu::copySurfaceAsBlit(GrSurface* dst,
blitRegion.dstOffsets[1] = { dstRect.fRight, dstRect.fBottom, 0 };
fCurrentCmdBuffer->blitImage(this,
- srcImage->resource(),
- VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
- dstImage->resource(),
- VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
+ *srcImage,
+ *dstImage,
1,
&blitRegion,
VK_FILTER_NEAREST); // We never scale so any filter works here
diff --git a/src/gpu/vk/GrVkImage.cpp b/src/gpu/vk/GrVkImage.cpp
index 49adc574ae..9e7faf4706 100644
--- a/src/gpu/vk/GrVkImage.cpp
+++ b/src/gpu/vk/GrVkImage.cpp
@@ -31,36 +31,36 @@ void GrVkImage::setImageLayout(const GrVkGpu* gpu, VkImageLayout newLayout,
bool byRegion) {
SkASSERT(VK_IMAGE_LAYOUT_UNDEFINED != newLayout &&
VK_IMAGE_LAYOUT_PREINITIALIZED != newLayout);
+ VkImageLayout currentLayout = this->currentLayout();
// Is this reasonable? Could someone want to keep the same layout but use the masks to force
// a barrier on certain things?
- if (newLayout == fCurrentLayout) {
+ if (newLayout == currentLayout) {
return;
}
- VkAccessFlags srcAccessMask = GrVkMemory::LayoutToSrcAccessMask(fCurrentLayout);
- VkPipelineStageFlags srcStageMask = GrVkMemory::LayoutToPipelineStageFlags(fCurrentLayout);
+ VkAccessFlags srcAccessMask = GrVkMemory::LayoutToSrcAccessMask(currentLayout);
+ VkPipelineStageFlags srcStageMask = GrVkMemory::LayoutToPipelineStageFlags(currentLayout);
- VkImageAspectFlags aspectFlags = vk_format_to_aspect_flags(fResource->fFormat);
+ VkImageAspectFlags aspectFlags = vk_format_to_aspect_flags(fInfo.fFormat);
VkImageMemoryBarrier imageMemoryBarrier = {
VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, // sType
NULL, // pNext
srcAccessMask, // outputMask
dstAccessMask, // inputMask
- fCurrentLayout, // oldLayout
+ currentLayout, // oldLayout
newLayout, // newLayout
VK_QUEUE_FAMILY_IGNORED, // srcQueueFamilyIndex
VK_QUEUE_FAMILY_IGNORED, // dstQueueFamilyIndex
- fResource->fImage, // image
- { aspectFlags, 0, fResource->fLevelCount, 0, 1 } // subresourceRange
+ fInfo.fImage, // image
+ { aspectFlags, 0, fInfo.fLevelCount, 0, 1 } // subresourceRange
};
gpu->addImageMemoryBarrier(srcStageMask, dstStageMask, byRegion, &imageMemoryBarrier);
- fCurrentLayout = newLayout;
+ fInfo.fImageLayout = newLayout;
}
-const GrVkImage::Resource* GrVkImage::CreateResource(const GrVkGpu* gpu,
- const ImageDesc& imageDesc) {
+bool GrVkImage::InitImageInfo(const GrVkGpu* gpu, const ImageDesc& imageDesc, GrVkImageInfo* info) {
VkImage image = 0;
VkDeviceMemory alloc;
@@ -71,7 +71,7 @@ const GrVkImage::Resource* GrVkImage::CreateResource(const GrVkGpu* gpu,
// Create Image
VkSampleCountFlagBits vkSamples;
if (!GrSampleCountToVkSampleCount(imageDesc.fSamples, &vkSamples)) {
- return nullptr;
+ return false;
}
SkASSERT(VK_IMAGE_TILING_OPTIMAL == imageDesc.fImageTiling ||
@@ -95,18 +95,30 @@ const GrVkImage::Resource* GrVkImage::CreateResource(const GrVkGpu* gpu,
initialLayout // initialLayout
};
- GR_VK_CALL_ERRCHECK(gpu->vkInterface(), CreateImage(gpu->device(), &imageCreateInfo, nullptr, &image));
+ GR_VK_CALL_ERRCHECK(gpu->vkInterface(), CreateImage(gpu->device(), &imageCreateInfo, nullptr,
+ &image));
if (!GrVkMemory::AllocAndBindImageMemory(gpu, image, imageDesc.fMemProps, &alloc)) {
VK_CALL(gpu, DestroyImage(gpu->device(), image, nullptr));
- return nullptr;
+ return false;
}
- GrVkImage::Resource::Flags flags =
- (VK_IMAGE_TILING_LINEAR == imageDesc.fImageTiling) ? Resource::kLinearTiling_Flag
- : Resource::kNo_Flags;
+ info->fImage = image;
+ info->fAlloc = alloc;
+ info->fImageTiling = imageDesc.fImageTiling;
+ info->fImageLayout = initialLayout;
+ info->fFormat = imageDesc.fFormat;
+ info->fLevelCount = imageDesc.fLevels;
+ return true;
+}
+
+void GrVkImage::DestroyImageInfo(const GrVkGpu* gpu, GrVkImageInfo* info) {
+ VK_CALL(gpu, DestroyImage(gpu->device(), info->fImage, nullptr));
+ VK_CALL(gpu, FreeMemory(gpu->device(), info->fAlloc, nullptr));
+}
- return (new GrVkImage::Resource(image, alloc, imageDesc.fFormat, imageDesc.fLevels, flags));
+void GrVkImage::setNewResource(VkImage image, VkDeviceMemory alloc) {
+ fResource = new Resource(image, alloc);
}
GrVkImage::~GrVkImage() {
diff --git a/src/gpu/vk/GrVkImage.h b/src/gpu/vk/GrVkImage.h
index e73d314e5e..30b6b89a13 100644
--- a/src/gpu/vk/GrVkImage.h
+++ b/src/gpu/vk/GrVkImage.h
@@ -14,77 +14,41 @@
#include "SkTypes.h"
#include "vk/GrVkDefines.h"
+#include "vk/GrVkTypes.h"
class GrVkGpu;
class GrVkImage : SkNoncopyable {
-public:
- // unlike GrVkBuffer, this needs to be public so GrVkStencilAttachment can use it
- class Resource : public GrVkResource {
- public:
- enum Flags {
- kNo_Flags = 0,
- kLinearTiling_Flag = 0x01,
- kBorrowed_Flag = 0x02
- };
-
- VkImage fImage;
- VkDeviceMemory fAlloc;
- VkFormat fFormat;
- uint32_t fLevelCount;
- uint32_t fFlags;
-
- Resource()
- : INHERITED()
- , fImage(VK_NULL_HANDLE)
- , fAlloc(VK_NULL_HANDLE)
- , fFormat(VK_FORMAT_UNDEFINED)
- , fLevelCount(0)
- , fFlags(kNo_Flags) {}
-
- Resource(VkImage image, VkDeviceMemory alloc, VkFormat format, uint32_t levelCount,
- uint32_t flags)
- : fImage(image), fAlloc(alloc), fFormat(format), fLevelCount(levelCount)
- , fFlags(flags) {}
-
- ~Resource() override {}
+private:
+ class Resource;
- private:
- void freeGPUData(const GrVkGpu* gpu) const override;
-
- typedef GrVkResource INHERITED;
- };
-
- // for wrapped textures
- class BorrowedResource : public Resource {
- public:
- BorrowedResource(VkImage image, VkDeviceMemory alloc, VkFormat format, uint32_t levelCount,
- uint32_t flags)
- : Resource(image, alloc, format, levelCount, (flags | kBorrowed_Flag)) {
- }
- private:
- void freeGPUData(const GrVkGpu* gpu) const override;
+public:
+ enum Wrapped {
+ kNot_Wrapped,
+ kAdopted_Wrapped,
+ kBorrowed_Wrapped,
};
- GrVkImage(const Resource* imageResource) : fResource(imageResource) {
- if (imageResource->fFlags & Resource::kLinearTiling_Flag) {
- fCurrentLayout = VK_IMAGE_LAYOUT_PREINITIALIZED;
+ GrVkImage(const GrVkImageInfo& info, Wrapped wrapped)
+ : fInfo(info)
+ , fIsBorrowed(kBorrowed_Wrapped == wrapped) {
+ if (kBorrowed_Wrapped == wrapped) {
+ fResource = new BorrowedResource(info.fImage, info.fAlloc);
} else {
- fCurrentLayout = VK_IMAGE_LAYOUT_UNDEFINED;
+ fResource = new Resource(info.fImage, info.fAlloc);
}
- imageResource->ref();
}
-
virtual ~GrVkImage();
- VkImage textureImage() const { return fResource->fImage; }
- VkDeviceMemory textureMemory() const { return fResource->fAlloc; }
+ VkImage image() const { return fInfo.fImage; }
+ VkDeviceMemory memory() const { return fInfo.fAlloc; }
+ VkFormat imageFormat() const { return fInfo.fFormat; }
const Resource* resource() const { return fResource; }
bool isLinearTiled() const {
- return SkToBool(fResource->fFlags & Resource::kLinearTiling_Flag);
+ return SkToBool(VK_IMAGE_TILING_LINEAR == fInfo.fImageTiling);
}
- VkImageLayout currentLayout() const { return fCurrentLayout; }
+ VkImageLayout currentLayout() const { return fInfo.fImageLayout; }
void setImageLayout(const GrVkGpu* gpu,
VkImageLayout newLayout,
@@ -115,16 +79,54 @@ public:
, fMemProps(VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT) {}
};
- static const Resource* CreateResource(const GrVkGpu* gpu, const ImageDesc& imageDesc);
+ static bool InitImageInfo(const GrVkGpu* gpu, const ImageDesc& imageDesc, GrVkImageInfo*);
+ // Destroys the internal VkImage and VkDeviceMemory in the GrVkImageInfo
+ static void DestroyImageInfo(const GrVkGpu* gpu, GrVkImageInfo*);
protected:
-
void releaseImage(const GrVkGpu* gpu);
void abandonImage();
+ void setNewResource(VkImage image, VkDeviceMemory alloc);
+
+ GrVkImageInfo fInfo;
+ bool fIsBorrowed;
+
+private:
+ // unlike GrVkBuffer, this needs to be public so GrVkStencilAttachment can use it
+ class Resource : public GrVkResource {
+ public:
+ Resource()
+ : INHERITED()
+ , fImage(VK_NULL_HANDLE)
+ , fAlloc(VK_NULL_HANDLE) {
+ }
+
+ Resource(VkImage image, VkDeviceMemory alloc) : fImage(image), fAlloc(alloc) {}
+
+ ~Resource() override {}
+
+ private:
+ void freeGPUData(const GrVkGpu* gpu) const override;
+
+ VkImage fImage;
+ VkDeviceMemory fAlloc;
+
+ typedef GrVkResource INHERITED;
+ };
+
+ // for wrapped textures
+ class BorrowedResource : public Resource {
+ public:
+ BorrowedResource(VkImage image, VkDeviceMemory alloc) : Resource(image, alloc) {
+ }
+ private:
+ void freeGPUData(const GrVkGpu* gpu) const override;
+ };
+
const Resource* fResource;
- VkImageLayout fCurrentLayout;
+ friend class GrVkRenderTarget;
};
#endif
diff --git a/src/gpu/vk/GrVkPipelineState.cpp b/src/gpu/vk/GrVkPipelineState.cpp
index 0ebd1dd7fd..f27916f714 100644
--- a/src/gpu/vk/GrVkPipelineState.cpp
+++ b/src/gpu/vk/GrVkPipelineState.cpp
@@ -304,7 +304,7 @@ void GrVkPipelineState::writeSamplers(GrVkGpu* gpu,
fSamplers.push(gpu->resourceProvider().findOrCreateCompatibleSampler(params,
texture->texturePriv().maxMipMapLevel()));
- const GrVkImage::Resource* textureResource = texture->resource();
+ const GrVkResource* textureResource = texture->resource();
textureResource->ref();
fTextures.push(textureResource);
diff --git a/src/gpu/vk/GrVkPipelineState.h b/src/gpu/vk/GrVkPipelineState.h
index ea988861ef..d4cc19a9a3 100644
--- a/src/gpu/vk/GrVkPipelineState.h
+++ b/src/gpu/vk/GrVkPipelineState.h
@@ -266,7 +266,7 @@ private:
// GrVkResources used for sampling textures
SkTDArray<GrVkSampler*> fSamplers;
SkTDArray<const GrVkImageView*> fTextureViews;
- SkTDArray<const GrVkImage::Resource*> fTextures;
+ SkTDArray<const GrVkResource*> fTextures;
// Tracks the current render target uniforms stored in the vertex buffer.
RenderTargetState fRenderTargetState;
diff --git a/src/gpu/vk/GrVkRenderTarget.cpp b/src/gpu/vk/GrVkRenderTarget.cpp
index 70b73a758a..277448001e 100644
--- a/src/gpu/vk/GrVkRenderTarget.cpp
+++ b/src/gpu/vk/GrVkRenderTarget.cpp
@@ -24,17 +24,18 @@
GrVkRenderTarget::GrVkRenderTarget(GrVkGpu* gpu,
SkBudgeted budgeted,
const GrSurfaceDesc& desc,
- const GrVkImage::Resource* imageResource,
- const GrVkImage::Resource* msaaResource,
+ const GrVkImageInfo& info,
+ const GrVkImageInfo& msaaInfo,
const GrVkImageView* colorAttachmentView,
- const GrVkImageView* resolveAttachmentView)
+ const GrVkImageView* resolveAttachmentView,
+ GrVkImage::Wrapped wrapped)
: GrSurface(gpu, desc)
- , GrVkImage(imageResource)
+ , GrVkImage(info, wrapped)
// for the moment we only support 1:1 color to stencil
, GrRenderTarget(gpu, desc, kUnified_SampleConfig)
, fFramebuffer(nullptr)
, fColorAttachmentView(colorAttachmentView)
- , fMSAAImageResource(msaaResource)
+ , fMSAAImage(new GrVkImage(info, GrVkImage::kNot_Wrapped))
, fResolveAttachmentView(resolveAttachmentView)
, fCachedSimpleRenderPass(nullptr) {
SkASSERT(desc.fSampleCnt);
@@ -42,31 +43,30 @@ GrVkRenderTarget::GrVkRenderTarget(GrVkGpu* gpu,
fColorValuesPerPixel = desc.fSampleCnt + 1; // TODO: this still correct?
this->createFramebuffer(gpu);
this->registerWithCache(budgeted);
- msaaResource->ref();
}
// We're virtually derived from GrSurface (via GrRenderTarget) so its
// constructor must be explicitly called.
GrVkRenderTarget::GrVkRenderTarget(GrVkGpu* gpu,
const GrSurfaceDesc& desc,
- const GrVkImage::Resource* imageResource,
- const GrVkImage::Resource* msaaResource,
+ const GrVkImageInfo& info,
+ const GrVkImageInfo& msaaInfo,
const GrVkImageView* colorAttachmentView,
- const GrVkImageView* resolveAttachmentView)
+ const GrVkImageView* resolveAttachmentView,
+ GrVkImage::Wrapped wrapped)
: GrSurface(gpu, desc)
- , GrVkImage(imageResource)
+ , GrVkImage(info, wrapped)
// for the moment we only support 1:1 color to stencil
, GrRenderTarget(gpu, desc, kUnified_SampleConfig)
, fFramebuffer(nullptr)
, fColorAttachmentView(colorAttachmentView)
- , fMSAAImageResource(msaaResource)
+ , fMSAAImage(new GrVkImage(info, GrVkImage::kNot_Wrapped))
, fResolveAttachmentView(resolveAttachmentView)
, fCachedSimpleRenderPass(nullptr) {
SkASSERT(desc.fSampleCnt);
// The plus 1 is to account for the resolve texture.
fColorValuesPerPixel = desc.fSampleCnt + 1; // TODO: this still correct?
this->createFramebuffer(gpu);
- msaaResource->ref();
}
// We're virtually derived from GrSurface (via GrRenderTarget) so its
@@ -74,14 +74,15 @@ GrVkRenderTarget::GrVkRenderTarget(GrVkGpu* gpu,
GrVkRenderTarget::GrVkRenderTarget(GrVkGpu* gpu,
SkBudgeted budgeted,
const GrSurfaceDesc& desc,
- const GrVkImage::Resource* imageResource,
- const GrVkImageView* colorAttachmentView)
+ const GrVkImageInfo& info,
+ const GrVkImageView* colorAttachmentView,
+ GrVkImage::Wrapped wrapped)
: GrSurface(gpu, desc)
- , GrVkImage(imageResource)
+ , GrVkImage(info, wrapped)
, GrRenderTarget(gpu, desc, kUnified_SampleConfig)
, fFramebuffer(nullptr)
, fColorAttachmentView(colorAttachmentView)
- , fMSAAImageResource(nullptr)
+ , fMSAAImage(nullptr)
, fResolveAttachmentView(nullptr)
, fCachedSimpleRenderPass(nullptr) {
SkASSERT(!desc.fSampleCnt);
@@ -94,14 +95,15 @@ GrVkRenderTarget::GrVkRenderTarget(GrVkGpu* gpu,
// constructor must be explicitly called.
GrVkRenderTarget::GrVkRenderTarget(GrVkGpu* gpu,
const GrSurfaceDesc& desc,
- const GrVkImage::Resource* imageResource,
- const GrVkImageView* colorAttachmentView)
+ const GrVkImageInfo& info,
+ const GrVkImageView* colorAttachmentView,
+ GrVkImage::Wrapped wrapped)
: GrSurface(gpu, desc)
- , GrVkImage(imageResource)
+ , GrVkImage(info, wrapped)
, GrRenderTarget(gpu, desc, kUnified_SampleConfig)
, fFramebuffer(nullptr)
, fColorAttachmentView(colorAttachmentView)
- , fMSAAImageResource(nullptr)
+ , fMSAAImage(nullptr)
, fResolveAttachmentView(nullptr)
, fCachedSimpleRenderPass(nullptr) {
SkASSERT(!desc.fSampleCnt);
@@ -113,14 +115,15 @@ GrVkRenderTarget*
GrVkRenderTarget::Create(GrVkGpu* gpu,
SkBudgeted budgeted,
const GrSurfaceDesc& desc,
- const GrVkImage::Resource* imageResource) {
+ const GrVkImageInfo& info,
+ GrVkImage::Wrapped wrapped) {
VkFormat pixelFormat;
GrPixelConfigToVkFormat(desc.fConfig, &pixelFormat);
VkImage colorImage;
// create msaa surface if necessary
- const GrVkImage::Resource* msaaResource = nullptr;
+ GrVkImageInfo msInfo;
const GrVkImageView* resolveAttachmentView = nullptr;
if (desc.fSampleCnt) {
GrVkImage::ImageDesc msImageDesc;
@@ -134,46 +137,42 @@ GrVkRenderTarget::Create(GrVkGpu* gpu,
msImageDesc.fUsageFlags = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
msImageDesc.fMemProps = VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT;
- msaaResource = GrVkImage::CreateResource(gpu, msImageDesc);
-
- if (!msaaResource) {
+ if (!GrVkImage::InitImageInfo(gpu, msImageDesc, &msInfo)) {
return nullptr;
}
// Set color attachment image
- colorImage = msaaResource->fImage;
+ colorImage = msInfo.fImage;
// Create Resolve attachment view
- resolveAttachmentView = GrVkImageView::Create(gpu, imageResource->fImage, pixelFormat,
+ resolveAttachmentView = GrVkImageView::Create(gpu, info.fImage, pixelFormat,
GrVkImageView::kColor_Type, 1);
if (!resolveAttachmentView) {
- msaaResource->unref(gpu);
+ GrVkImage::DestroyImageInfo(gpu, &msInfo);
return nullptr;
}
} else {
// Set color attachment image
- colorImage = imageResource->fImage;
+ colorImage = info.fImage;
}
// Get color attachment view
const GrVkImageView* colorAttachmentView = GrVkImageView::Create(gpu, colorImage, pixelFormat,
GrVkImageView::kColor_Type, 1);
if (!colorAttachmentView) {
- if (msaaResource) {
+ if (desc.fSampleCnt) {
resolveAttachmentView->unref(gpu);
- msaaResource->unref(gpu);
+ GrVkImage::DestroyImageInfo(gpu, &msInfo);
}
- return NULL;
+ return nullptr;
}
GrVkRenderTarget* texRT;
- if (msaaResource) {
- texRT = new GrVkRenderTarget(gpu, budgeted, desc, imageResource, msaaResource,
- colorAttachmentView, resolveAttachmentView);
- msaaResource->unref(gpu);
+ if (desc.fSampleCnt) {
+ texRT = new GrVkRenderTarget(gpu, budgeted, desc, info, msInfo,
+ colorAttachmentView, resolveAttachmentView, wrapped);
} else {
- texRT = new GrVkRenderTarget(gpu, budgeted, desc, imageResource,
- colorAttachmentView);
+ texRT = new GrVkRenderTarget(gpu, budgeted, desc, info, colorAttachmentView, wrapped);
}
return texRT;
@@ -186,14 +185,16 @@ GrVkRenderTarget::CreateNewRenderTarget(GrVkGpu* gpu,
const GrVkImage::ImageDesc& imageDesc) {
SkASSERT(imageDesc.fUsageFlags & VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT);
- const GrVkImage::Resource* imageResource = GrVkImage::CreateResource(gpu, imageDesc);
- if (!imageResource) {
+ GrVkImageInfo info;
+ if (!GrVkImage::InitImageInfo(gpu, imageDesc, &info)) {
return nullptr;
}
- GrVkRenderTarget* rt = GrVkRenderTarget::Create(gpu, budgeted, desc, imageResource);
- // Create() will increment the refCount of the image resource if it succeeds
- imageResource->unref(gpu);
+ GrVkRenderTarget* rt = GrVkRenderTarget::Create(gpu, budgeted, desc, info,
+ GrVkImage::kNot_Wrapped);
+ if (!rt) {
+ GrVkImage::DestroyImageInfo(gpu, &info);
+ }
return rt;
}
@@ -201,36 +202,16 @@ GrVkRenderTarget*
GrVkRenderTarget::CreateWrappedRenderTarget(GrVkGpu* gpu,
const GrSurfaceDesc& desc,
GrWrapOwnership ownership,
- const GrVkTextureInfo* info) {
+ const GrVkImageInfo* info) {
SkASSERT(info);
// We can wrap a rendertarget without its allocation, as long as we don't take ownership
SkASSERT(VK_NULL_HANDLE != info->fImage);
SkASSERT(VK_NULL_HANDLE != info->fAlloc || kAdopt_GrWrapOwnership != ownership);
- GrVkImage::Resource::Flags flags = (VK_IMAGE_TILING_LINEAR == info->fImageTiling)
- ? Resource::kLinearTiling_Flag : Resource::kNo_Flags;
+ GrVkImage::Wrapped wrapped = kBorrow_GrWrapOwnership == ownership ? GrVkImage::kBorrowed_Wrapped
+ : GrVkImage::kAdopted_Wrapped;
- const GrVkImage::Resource* imageResource;
- if (kBorrow_GrWrapOwnership == ownership) {
- imageResource = new GrVkImage::BorrowedResource(info->fImage,
- info->fAlloc,
- info->fFormat,
- info->fLevelCount,
- flags);
- } else {
- imageResource = new GrVkImage::Resource(info->fImage, info->fAlloc, info->fFormat,
- info->fLevelCount, flags);
- }
- if (!imageResource) {
- return nullptr;
- }
-
- GrVkRenderTarget* rt = GrVkRenderTarget::Create(gpu, SkBudgeted::kNo, desc, imageResource);
- if (rt) {
- rt->fCurrentLayout = info->fImageLayout;
- }
- // Create() will increment the refCount of the image resource if it succeeds
- imageResource->unref(gpu);
+ GrVkRenderTarget* rt = GrVkRenderTarget::Create(gpu, SkBudgeted::kNo, desc, *info, wrapped);
return rt;
}
@@ -292,7 +273,7 @@ void GrVkRenderTarget::getAttachmentsDescriptor(
GrVkRenderTarget::~GrVkRenderTarget() {
// either release or abandon should have been called by the owner of this object.
- SkASSERT(!fMSAAImageResource);
+ SkASSERT(!fMSAAImage);
SkASSERT(!fResolveAttachmentView);
SkASSERT(!fColorAttachmentView);
SkASSERT(!fFramebuffer);
@@ -316,9 +297,9 @@ void GrVkRenderTarget::addResources(GrVkCommandBuffer& commandBuffer) const {
void GrVkRenderTarget::releaseInternalObjects() {
GrVkGpu* gpu = this->getVkGpu();
- if (fMSAAImageResource) {
- fMSAAImageResource->unref(gpu);
- fMSAAImageResource = nullptr;
+ if (fMSAAImage) {
+ fMSAAImage->releaseImage(gpu);
+ fMSAAImage = nullptr;
}
if (fResolveAttachmentView) {
@@ -340,9 +321,9 @@ void GrVkRenderTarget::releaseInternalObjects() {
}
void GrVkRenderTarget::abandonInternalObjects() {
- if (fMSAAImageResource) {
- fMSAAImageResource->unrefAndAbandon();
- fMSAAImageResource = nullptr;
+ if (fMSAAImage) {
+ fMSAAImage->abandonImage();
+ fMSAAImage = nullptr;
}
if (fResolveAttachmentView) {
@@ -381,7 +362,7 @@ GrBackendObject GrVkRenderTarget::getRenderTargetHandle() const {
return (GrBackendObject)&fResource;
}
-const GrVkImage::Resource* GrVkRenderTarget::stencilImageResource() const {
+const GrVkResource* GrVkRenderTarget::stencilImageResource() const {
const GrStencilAttachment* stencil = this->renderTargetPriv().getStencilAttachment();
if (stencil) {
const GrVkStencilAttachment* vkStencil = static_cast<const GrVkStencilAttachment*>(stencil);
diff --git a/src/gpu/vk/GrVkRenderTarget.h b/src/gpu/vk/GrVkRenderTarget.h
index 8c720aef86..accc677806 100644
--- a/src/gpu/vk/GrVkRenderTarget.h
+++ b/src/gpu/vk/GrVkRenderTarget.h
@@ -20,7 +20,7 @@ class GrVkGpu;
class GrVkImageView;
class GrVkStencilAttachment;
-struct GrVkTextureInfo;
+struct GrVkImageInfo;
#ifdef SK_BUILD_FOR_WIN
// Windows gives bogus warnings about inheriting asTexture/asRenderTarget via dominance.
@@ -35,15 +35,20 @@ public:
static GrVkRenderTarget* CreateWrappedRenderTarget(GrVkGpu*, const GrSurfaceDesc&,
GrWrapOwnership,
- const GrVkTextureInfo*);
+ const GrVkImageInfo*);
~GrVkRenderTarget() override;
const GrVkFramebuffer* framebuffer() const { return fFramebuffer; }
const GrVkImageView* colorAttachmentView() const { return fColorAttachmentView; }
- const GrVkImage::Resource* msaaImageResource() const { return fMSAAImageResource; }
+ const GrVkResource* msaaImageResource() const {
+ if (fMSAAImage) {
+ return fMSAAImage->fResource;
+ }
+ return nullptr;
+ }
const GrVkImageView* resolveAttachmentView() const { return fResolveAttachmentView; }
- const GrVkImage::Resource* stencilImageResource() const;
+ const GrVkResource* stencilImageResource() const;
const GrVkImageView* stencilAttachmentView() const;
const GrVkRenderPass* simpleRenderPass() const { return fCachedSimpleRenderPass; }
@@ -67,33 +72,18 @@ public:
protected:
GrVkRenderTarget(GrVkGpu* gpu,
- SkBudgeted,
const GrSurfaceDesc& desc,
- const GrVkImage::Resource* imageResource,
- const GrVkImage::Resource* msaaImageResource,
+ const GrVkImageInfo& info,
+ const GrVkImageInfo& msaaInfo,
const GrVkImageView* colorAttachmentView,
- const GrVkImageView* resolveAttachmentView);
+ const GrVkImageView* resolveAttachmentView,
+ GrVkImage::Wrapped wrapped);
GrVkRenderTarget(GrVkGpu* gpu,
const GrSurfaceDesc& desc,
- const GrVkImage::Resource* imageResource,
- const GrVkImage::Resource* msaaImageResource,
+ const GrVkImageInfo& info,
const GrVkImageView* colorAttachmentView,
- const GrVkImageView* resolveAttachmentView);
-
- GrVkRenderTarget(GrVkGpu* gpu,
- SkBudgeted,
- const GrSurfaceDesc& desc,
- const GrVkImage::Resource* imageResource,
- const GrVkImageView* colorAttachmentView);
-
- GrVkRenderTarget(GrVkGpu* gpu,
- const GrSurfaceDesc& desc,
- const GrVkImage::Resource* imageResource,
- const GrVkImageView* colorAttachmentView);
-
- static GrVkRenderTarget* Create(GrVkGpu*, SkBudgeted, const GrSurfaceDesc&,
- const GrVkImage::Resource* imageResource);
+ GrVkImage::Wrapped wrapped);
GrVkGpu* getVkGpu() const;
@@ -110,6 +100,25 @@ protected:
}
private:
+ GrVkRenderTarget(GrVkGpu* gpu,
+ SkBudgeted,
+ const GrSurfaceDesc& desc,
+ const GrVkImageInfo& info,
+ const GrVkImageInfo& msaaInfo,
+ const GrVkImageView* colorAttachmentView,
+ const GrVkImageView* resolveAttachmentView,
+ GrVkImage::Wrapped wrapped);
+
+ GrVkRenderTarget(GrVkGpu* gpu,
+ SkBudgeted,
+ const GrSurfaceDesc& desc,
+ const GrVkImageInfo& info,
+ const GrVkImageView* colorAttachmentView,
+ GrVkImage::Wrapped wrapped);
+
+ static GrVkRenderTarget* Create(GrVkGpu*, SkBudgeted, const GrSurfaceDesc&,
+ const GrVkImageInfo&, GrVkImage::Wrapped wrapped);
+
bool completeStencilAttachment() override;
void createFramebuffer(GrVkGpu* gpu);
@@ -119,7 +128,7 @@ private:
const GrVkFramebuffer* fFramebuffer;
const GrVkImageView* fColorAttachmentView;
- const GrVkImage::Resource* fMSAAImageResource;
+ GrVkImage* fMSAAImage;
const GrVkImageView* fResolveAttachmentView;
int fColorValuesPerPixel;
diff --git a/src/gpu/vk/GrVkStencilAttachment.cpp b/src/gpu/vk/GrVkStencilAttachment.cpp
index a876aea15f..5976811be4 100644
--- a/src/gpu/vk/GrVkStencilAttachment.cpp
+++ b/src/gpu/vk/GrVkStencilAttachment.cpp
@@ -16,11 +16,11 @@
GrVkStencilAttachment::GrVkStencilAttachment(GrVkGpu* gpu,
const Format& format,
const GrVkImage::ImageDesc& desc,
- const GrVkImage::Resource* imageResource,
+ const GrVkImageInfo& info,
const GrVkImageView* stencilView)
: GrStencilAttachment(gpu, desc.fWidth, desc.fHeight,
format.fStencilBits, desc.fSamples)
- , GrVkImage(imageResource)
+ , GrVkImage(info, GrVkImage::kNot_Wrapped)
, fFormat(format)
, fStencilView(stencilView) {
this->registerWithCache(SkBudgeted::kYes);
@@ -44,22 +44,22 @@ GrVkStencilAttachment* GrVkStencilAttachment::Create(GrVkGpu* gpu,
VK_IMAGE_USAGE_TRANSFER_DST_BIT;
imageDesc.fMemProps = VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT;
- const GrVkImage::Resource* imageResource = GrVkImage::CreateResource(gpu, imageDesc);
- if (!imageResource) {
+ GrVkImageInfo info;
+ if (!GrVkImage::InitImageInfo(gpu, imageDesc, &info)) {
return nullptr;
}
- const GrVkImageView* imageView = GrVkImageView::Create(gpu, imageResource->fImage,
+ const GrVkImageView* imageView = GrVkImageView::Create(gpu, info.fImage,
format.fInternalFormat,
GrVkImageView::kStencil_Type, 1);
if (!imageView) {
- imageResource->unref(gpu);
+ VK_CALL(gpu, DestroyImage(gpu->device(), info.fImage, nullptr));
+ VK_CALL(gpu, FreeMemory(gpu->device(), info.fAlloc, nullptr));
return nullptr;
}
GrVkStencilAttachment* stencil = new GrVkStencilAttachment(gpu, format, imageDesc,
- imageResource, imageView);
- imageResource->unref(gpu);
+ info, imageView);
imageView->unref(gpu);
return stencil;
diff --git a/src/gpu/vk/GrVkStencilAttachment.h b/src/gpu/vk/GrVkStencilAttachment.h
index f106c69971..f6bf19af4f 100644
--- a/src/gpu/vk/GrVkStencilAttachment.h
+++ b/src/gpu/vk/GrVkStencilAttachment.h
@@ -29,7 +29,7 @@ public:
~GrVkStencilAttachment() override;
- const GrVkImage::Resource* imageResource() const { return this->resource(); }
+ const GrVkResource* imageResource() const { return this->resource(); }
const GrVkImageView* stencilView() const { return fStencilView; }
VkFormat vkFormat() const { return fFormat.fInternalFormat; }
@@ -44,7 +44,7 @@ private:
GrVkStencilAttachment(GrVkGpu* gpu,
const Format& format,
const GrVkImage::ImageDesc&,
- const GrVkImage::Resource*,
+ const GrVkImageInfo&,
const GrVkImageView* stencilView);
GrVkGpu* getVkGpu() const;
diff --git a/src/gpu/vk/GrVkTexture.cpp b/src/gpu/vk/GrVkTexture.cpp
index c2a30a27f4..fef6b72928 100644
--- a/src/gpu/vk/GrVkTexture.cpp
+++ b/src/gpu/vk/GrVkTexture.cpp
@@ -19,10 +19,10 @@
GrVkTexture::GrVkTexture(GrVkGpu* gpu,
SkBudgeted budgeted,
const GrSurfaceDesc& desc,
- const GrVkImage::Resource* imageResource,
+ const GrVkImageInfo& info,
const GrVkImageView* view)
: GrSurface(gpu, desc)
- , GrVkImage(imageResource)
+ , GrVkImage(info, GrVkImage::kNot_Wrapped)
, INHERITED(gpu, desc, kSampler2D_GrSLType, desc.fIsMipMapped)
, fTextureView(view)
, fLinearTextureView(nullptr) {
@@ -32,10 +32,11 @@ GrVkTexture::GrVkTexture(GrVkGpu* gpu,
GrVkTexture::GrVkTexture(GrVkGpu* gpu,
Wrapped,
const GrSurfaceDesc& desc,
- const GrVkImage::Resource* imageResource,
- const GrVkImageView* view)
+ const GrVkImageInfo& info,
+ const GrVkImageView* view,
+ GrVkImage::Wrapped wrapped)
: GrSurface(gpu, desc)
- , GrVkImage(imageResource)
+ , GrVkImage(info, wrapped)
, INHERITED(gpu, desc, kSampler2D_GrSLType, desc.fIsMipMapped)
, fTextureView(view)
, fLinearTextureView(nullptr) {
@@ -45,31 +46,14 @@ GrVkTexture::GrVkTexture(GrVkGpu* gpu,
// Because this class is virtually derived from GrSurface we must explicitly call its constructor.
GrVkTexture::GrVkTexture(GrVkGpu* gpu,
const GrSurfaceDesc& desc,
- const GrVkImage::Resource* imageResource,
- const GrVkImageView* view)
+ const GrVkImageInfo& info,
+ const GrVkImageView* view,
+ GrVkImage::Wrapped wrapped)
: GrSurface(gpu, desc)
- , GrVkImage(imageResource)
+ , GrVkImage(info, wrapped)
, INHERITED(gpu, desc, kSampler2D_GrSLType, desc.fIsMipMapped)
, fTextureView(view)
- , fLinearTextureView(nullptr) {}
-
-
-template<typename ResourceType>
-GrVkTexture* GrVkTexture::Create(GrVkGpu* gpu,
- ResourceType type,
- const GrSurfaceDesc& desc,
- VkFormat format,
- const GrVkImage::Resource* imageResource) {
- VkImage image = imageResource->fImage;
-
- const GrVkImageView* imageView = GrVkImageView::Create(gpu, image, format,
- GrVkImageView::kColor_Type,
- imageResource->fLevelCount);
- if (!imageView) {
- return nullptr;
- }
-
- return new GrVkTexture(gpu, type, desc, imageResource, imageView);
+ , fLinearTextureView(nullptr) {
}
GrVkTexture* GrVkTexture::CreateNewTexture(GrVkGpu* gpu, SkBudgeted budgeted,
@@ -77,53 +61,41 @@ GrVkTexture* GrVkTexture::CreateNewTexture(GrVkGpu* gpu, SkBudgeted budgeted,
const GrVkImage::ImageDesc& imageDesc) {
SkASSERT(imageDesc.fUsageFlags & VK_IMAGE_USAGE_SAMPLED_BIT);
- const GrVkImage::Resource* imageResource = GrVkImage::CreateResource(gpu, imageDesc);
- if (!imageResource) {
+ GrVkImageInfo info;
+ if (!GrVkImage::InitImageInfo(gpu, imageDesc, &info)) {
return nullptr;
}
- GrVkTexture* texture = Create(gpu, budgeted, desc, imageDesc.fFormat, imageResource);
- // Create() will increment the refCount of the image resource if it succeeds
- imageResource->unref(gpu);
+ const GrVkImageView* imageView = GrVkImageView::Create(gpu, info.fImage, info.fFormat,
+ GrVkImageView::kColor_Type,
+ info.fLevelCount);
+ if (!imageView) {
+ GrVkImage::DestroyImageInfo(gpu, &info);
+ return nullptr;
+ }
- return texture;
+ return new GrVkTexture(gpu, budgeted, desc, info, imageView);
}
GrVkTexture* GrVkTexture::CreateWrappedTexture(GrVkGpu* gpu,
const GrSurfaceDesc& desc,
GrWrapOwnership ownership,
- VkFormat format,
- const GrVkTextureInfo* info) {
+ const GrVkImageInfo* info) {
SkASSERT(info);
// Wrapped textures require both image and allocation (because they can be mapped)
SkASSERT(VK_NULL_HANDLE != info->fImage && VK_NULL_HANDLE != info->fAlloc);
- GrVkImage::Resource::Flags flags = (VK_IMAGE_TILING_LINEAR == info->fImageTiling)
- ? Resource::kLinearTiling_Flag : Resource::kNo_Flags;
-
- const GrVkImage::Resource* imageResource;
- if (kBorrow_GrWrapOwnership == ownership) {
- imageResource = new GrVkImage::BorrowedResource(info->fImage,
- info->fAlloc,
- info->fFormat,
- info->fLevelCount,
- flags);
- } else {
- imageResource = new GrVkImage::Resource(info->fImage, info->fAlloc, info->fFormat,
- info->fLevelCount, flags);
- }
- if (!imageResource) {
+ const GrVkImageView* imageView = GrVkImageView::Create(gpu, info->fImage, info->fFormat,
+ GrVkImageView::kColor_Type,
+ info->fLevelCount);
+ if (!imageView) {
return nullptr;
}
- GrVkTexture* texture = Create(gpu, kWrapped, desc, format, imageResource);
- if (texture) {
- texture->fCurrentLayout = info->fImageLayout;
- }
- // Create() will increment the refCount of the image resource if it succeeds
- imageResource->unref(gpu);
+ GrVkImage::Wrapped wrapped = kBorrow_GrWrapOwnership == ownership ? GrVkImage::kBorrowed_Wrapped
+ : GrVkImage::kAdopted_Wrapped;
- return texture;
+ return new GrVkTexture(gpu, kWrapped, desc, *info, imageView, wrapped);
}
GrVkTexture::~GrVkTexture() {
@@ -165,8 +137,7 @@ void GrVkTexture::onAbandon() {
}
GrBackendObject GrVkTexture::getTextureHandle() const {
- // Currently just passing back the pointer to the Resource as the handle
- return (GrBackendObject)&fResource;
+ return (GrBackendObject)&fInfo;
}
GrVkGpu* GrVkTexture::getVkGpu() const {
@@ -176,14 +147,14 @@ GrVkGpu* GrVkTexture::getVkGpu() const {
const GrVkImageView* GrVkTexture::textureView(bool allowSRGB) {
VkFormat linearFormat;
- if (allowSRGB || !GrVkFormatIsSRGB(fResource->fFormat, &linearFormat)) {
+ if (allowSRGB || !GrVkFormatIsSRGB(fInfo.fFormat, &linearFormat)) {
return fTextureView;
}
if (!fLinearTextureView) {
- fLinearTextureView = GrVkImageView::Create(this->getVkGpu(), fResource->fImage,
+ fLinearTextureView = GrVkImageView::Create(this->getVkGpu(), fInfo.fImage,
linearFormat, GrVkImageView::kColor_Type,
- fResource->fLevelCount);
+ fInfo.fLevelCount);
SkASSERT(fLinearTextureView);
}
@@ -196,10 +167,10 @@ bool GrVkTexture::reallocForMipmap(const GrVkGpu* gpu, uint32_t mipLevels) {
return false;
}
- const GrVkImage::Resource* oldResource = fResource;
+ const GrVkResource* oldResource = this->resource();
// We shouldn't realloc something that doesn't belong to us
- if (GrVkImage::Resource::kBorrowed_Flag & oldResource->fFlags) {
+ if (fIsBorrowed) {
return false;
}
@@ -214,7 +185,7 @@ bool GrVkTexture::reallocForMipmap(const GrVkGpu* gpu, uint32_t mipLevels) {
GrVkImage::ImageDesc imageDesc;
imageDesc.fImageType = VK_IMAGE_TYPE_2D;
- imageDesc.fFormat = oldResource->fFormat;
+ imageDesc.fFormat = fInfo.fFormat;
imageDesc.fWidth = fDesc.fWidth;
imageDesc.fHeight = fDesc.fHeight;
imageDesc.fLevels = mipLevels;
@@ -223,18 +194,18 @@ bool GrVkTexture::reallocForMipmap(const GrVkGpu* gpu, uint32_t mipLevels) {
imageDesc.fUsageFlags = usageFlags;
imageDesc.fMemProps = VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT;
- const GrVkImage::Resource* imageResource = GrVkImage::CreateResource(gpu, imageDesc);
- if (!imageResource) {
- return false;
+ GrVkImageInfo info;
+ if (!GrVkImage::InitImageInfo(gpu, imageDesc, &info)) {
+ return nullptr;
}
// have to create a new image view for new resource
const GrVkImageView* oldView = fTextureView;
- VkImage image = imageResource->fImage;
- const GrVkImageView* textureView = GrVkImageView::Create(gpu, image, imageResource->fFormat,
+ VkImage image = info.fImage;
+ const GrVkImageView* textureView = GrVkImageView::Create(gpu, image, info.fFormat,
GrVkImageView::kColor_Type, mipLevels);
if (!textureView) {
- imageResource->unref(gpu);
+ GrVkImage::DestroyImageInfo(gpu, &info);
return false;
}
@@ -244,9 +215,10 @@ bool GrVkTexture::reallocForMipmap(const GrVkGpu* gpu, uint32_t mipLevels) {
fLinearTextureView->unref(gpu);
fLinearTextureView = nullptr;
}
- fResource = imageResource;
+
+ this->setNewResource(info.fImage, info.fAlloc);
fTextureView = textureView;
- fCurrentLayout = VK_IMAGE_LAYOUT_UNDEFINED;
+ fInfo = info;
this->texturePriv().setMaxMipMapLevel(mipLevels);
return true;
diff --git a/src/gpu/vk/GrVkTexture.h b/src/gpu/vk/GrVkTexture.h
index eae75ea131..de10a32b4c 100644
--- a/src/gpu/vk/GrVkTexture.h
+++ b/src/gpu/vk/GrVkTexture.h
@@ -14,7 +14,7 @@
class GrVkGpu;
class GrVkImageView;
-struct GrVkTextureInfo;
+struct GrVkImageInfo;
class GrVkTexture : public GrTexture, public virtual GrVkImage {
public:
@@ -22,8 +22,7 @@ public:
const GrVkImage::ImageDesc&);
static GrVkTexture* CreateWrappedTexture(GrVkGpu*, const GrSurfaceDesc&,
- GrWrapOwnership,
- VkFormat, const GrVkTextureInfo*);
+ GrWrapOwnership, const GrVkImageInfo*);
~GrVkTexture() override;
@@ -36,12 +35,8 @@ public:
bool reallocForMipmap(const GrVkGpu* gpu, uint32_t mipLevels);
protected:
- GrVkTexture(GrVkGpu*, const GrSurfaceDesc&,
- const GrVkImage::Resource*, const GrVkImageView* imageView);
-
- template<typename ResourceType>
- static GrVkTexture* Create(GrVkGpu*, ResourceType, const GrSurfaceDesc&, VkFormat,
- const GrVkImage::Resource* texImpl);
+ GrVkTexture(GrVkGpu*, const GrSurfaceDesc&, const GrVkImageInfo&, const GrVkImageView*,
+ GrVkImage::Wrapped wrapped);
GrVkGpu* getVkGpu() const;
@@ -51,9 +46,9 @@ protected:
private:
enum Wrapped { kWrapped };
GrVkTexture(GrVkGpu*, SkBudgeted, const GrSurfaceDesc&,
- const GrVkImage::Resource*, const GrVkImageView* imageView);
+ const GrVkImageInfo&, const GrVkImageView* imageView);
GrVkTexture(GrVkGpu*, Wrapped, const GrSurfaceDesc&,
- const GrVkImage::Resource*, const GrVkImageView* imageView);
+ const GrVkImageInfo&, const GrVkImageView* imageView, GrVkImage::Wrapped wrapped);
const GrVkImageView* fTextureView;
const GrVkImageView* fLinearTextureView;
diff --git a/src/gpu/vk/GrVkTextureRenderTarget.cpp b/src/gpu/vk/GrVkTextureRenderTarget.cpp
index c33a6800b8..b92ea661fb 100644
--- a/src/gpu/vk/GrVkTextureRenderTarget.cpp
+++ b/src/gpu/vk/GrVkTextureRenderTarget.cpp
@@ -18,20 +18,19 @@
#define VK_CALL(GPU, X) GR_VK_CALL(GPU->vkInterface(), X)
-template<typename ResourceType>
GrVkTextureRenderTarget* GrVkTextureRenderTarget::Create(GrVkGpu* gpu,
- ResourceType resourceType,
const GrSurfaceDesc& desc,
- VkFormat format,
- const GrVkImage::Resource* imageResource) {
- VkImage image = imageResource->fImage;
+ const GrVkImageInfo& info,
+ SkBudgeted budgeted,
+ GrVkImage::Wrapped wrapped) {
+ VkImage image = info.fImage;
// Create the texture ImageView
uint32_t mipLevels = 1;
//TODO: does a mipmapped textureRenderTarget make sense?
//if (desc.fIsMipMapped) {
// mipLevels = SkMipMap::ComputeLevelCount(this->width(), this->height()) + 1;
//}
- const GrVkImageView* imageView = GrVkImageView::Create(gpu, image, format,
+ const GrVkImageView* imageView = GrVkImageView::Create(gpu, image, info.fFormat,
GrVkImageView::kColor_Type, mipLevels);
if (!imageView) {
return nullptr;
@@ -43,7 +42,7 @@ GrVkTextureRenderTarget* GrVkTextureRenderTarget::Create(GrVkGpu* gpu,
VkImage colorImage;
// create msaa surface if necessary
- const GrVkImage::Resource* msaaImageResource = nullptr;
+ GrVkImageInfo msInfo;
const GrVkImageView* resolveAttachmentView = nullptr;
if (desc.fSampleCnt) {
GrVkImage::ImageDesc msImageDesc;
@@ -57,65 +56,74 @@ GrVkTextureRenderTarget* GrVkTextureRenderTarget::Create(GrVkGpu* gpu,
msImageDesc.fUsageFlags = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
msImageDesc.fMemProps = VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT;
- msaaImageResource = GrVkImage::CreateResource(gpu, msImageDesc);
-
- if (!msaaImageResource) {
- imageView->unref(gpu);
+ if (!GrVkImage::InitImageInfo(gpu, msImageDesc, &msInfo)) {
return nullptr;
}
// Set color attachment image
- colorImage = msaaImageResource->fImage;
+ colorImage = msInfo.fImage;
// Create resolve attachment view if necessary.
// If the format matches, this is the same as the texture imageView.
- if (pixelFormat == format) {
+ if (pixelFormat == info.fFormat) {
resolveAttachmentView = imageView;
resolveAttachmentView->ref();
} else {
resolveAttachmentView = GrVkImageView::Create(gpu, image, pixelFormat,
GrVkImageView::kColor_Type, 1);
if (!resolveAttachmentView) {
- msaaImageResource->unref(gpu);
+ GrVkImage::DestroyImageInfo(gpu, &msInfo);
imageView->unref(gpu);
return nullptr;
}
}
} else {
// Set color attachment image
- colorImage = imageResource->fImage;
+ colorImage = info.fImage;
}
const GrVkImageView* colorAttachmentView;
// Get color attachment view.
// If the format matches and there's no multisampling,
// this is the same as the texture imageView
- if (pixelFormat == format && !resolveAttachmentView) {
+ if (pixelFormat == info.fFormat && !resolveAttachmentView) {
colorAttachmentView = imageView;
colorAttachmentView->ref();
} else {
colorAttachmentView = GrVkImageView::Create(gpu, colorImage, pixelFormat,
GrVkImageView::kColor_Type, 1);
if (!colorAttachmentView) {
- if (msaaImageResource) {
+ if (desc.fSampleCnt) {
resolveAttachmentView->unref(gpu);
- msaaImageResource->unref(gpu);
+ GrVkImage::DestroyImageInfo(gpu, &msInfo);
}
imageView->unref(gpu);
return nullptr;
}
}
GrVkTextureRenderTarget* texRT;
- if (msaaImageResource) {
- texRT = new GrVkTextureRenderTarget(gpu, resourceType, desc,
- imageResource, imageView, msaaImageResource,
- colorAttachmentView,
- resolveAttachmentView);
- msaaImageResource->unref(gpu);
+ if (desc.fSampleCnt) {
+ if (GrVkImage::kNot_Wrapped == wrapped) {
+ texRT = new GrVkTextureRenderTarget(gpu, budgeted, desc,
+ info, imageView, msInfo,
+ colorAttachmentView,
+ resolveAttachmentView);
+ } else {
+ texRT = new GrVkTextureRenderTarget(gpu, desc,
+ info, imageView, msInfo,
+ colorAttachmentView,
+ resolveAttachmentView, wrapped);
+ }
} else {
- texRT = new GrVkTextureRenderTarget(gpu, resourceType, desc,
- imageResource, imageView,
- colorAttachmentView);
+ if (GrVkImage::kNot_Wrapped == wrapped) {
+ texRT = new GrVkTextureRenderTarget(gpu, budgeted, desc,
+ info, imageView,
+ colorAttachmentView);
+ } else {
+ texRT = new GrVkTextureRenderTarget(gpu, desc,
+ info, imageView,
+ colorAttachmentView, wrapped);
+ }
}
return texRT;
}
@@ -128,16 +136,15 @@ GrVkTextureRenderTarget::CreateNewTextureRenderTarget(GrVkGpu* gpu,
SkASSERT(imageDesc.fUsageFlags & VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT);
SkASSERT(imageDesc.fUsageFlags & VK_IMAGE_USAGE_SAMPLED_BIT);
- const GrVkImage::Resource* imageRsrc = GrVkImage::CreateResource(gpu, imageDesc);
-
- if (!imageRsrc) {
+ GrVkImageInfo info;
+ if (!GrVkImage::InitImageInfo(gpu, imageDesc, &info)) {
return nullptr;
}
- GrVkTextureRenderTarget* trt = Create(gpu, budgeted, desc, imageDesc.fFormat,
- imageRsrc);
- // Create() will increment the refCount of the image resource if it succeeds
- imageRsrc->unref(gpu);
+ GrVkTextureRenderTarget* trt = Create(gpu, desc, info, budgeted, GrVkImage::kNot_Wrapped);
+ if (!trt) {
+ GrVkImage::DestroyImageInfo(gpu, &info);
+ }
return trt;
}
@@ -146,35 +153,16 @@ GrVkTextureRenderTarget*
GrVkTextureRenderTarget::CreateWrappedTextureRenderTarget(GrVkGpu* gpu,
const GrSurfaceDesc& desc,
GrWrapOwnership ownership,
- VkFormat format,
- const GrVkTextureInfo* info) {
+ const GrVkImageInfo* info) {
SkASSERT(info);
// Wrapped textures require both image and allocation (because they can be mapped)
SkASSERT(VK_NULL_HANDLE != info->fImage && VK_NULL_HANDLE != info->fAlloc);
- GrVkImage::Resource::Flags flags = (VK_IMAGE_TILING_LINEAR == info->fImageTiling)
- ? Resource::kLinearTiling_Flag : Resource::kNo_Flags;
+
+ GrVkImage::Wrapped wrapped = kBorrow_GrWrapOwnership == ownership ? GrVkImage::kBorrowed_Wrapped
+ : GrVkImage::kAdopted_Wrapped;
- const GrVkImage::Resource* imageResource;
- if (kBorrow_GrWrapOwnership == ownership) {
- imageResource = new GrVkImage::BorrowedResource(info->fImage,
- info->fAlloc,
- info->fFormat,
- info->fLevelCount,
- flags);
- } else {
- imageResource = new GrVkImage::Resource(info->fImage, info->fAlloc, info->fFormat,
- info->fLevelCount, flags);
- }
- if (!imageResource) {
- return nullptr;
- }
- GrVkTextureRenderTarget* trt = Create(gpu, kWrapped, desc, format, imageResource);
- if (trt) {
- trt->fCurrentLayout = info->fImageLayout;
- }
- // Create() will increment the refCount of the image resource if it succeeds
- imageResource->unref(gpu);
+ GrVkTextureRenderTarget* trt = Create(gpu, desc, *info, SkBudgeted::kNo, wrapped);
return trt;
}
diff --git a/src/gpu/vk/GrVkTextureRenderTarget.h b/src/gpu/vk/GrVkTextureRenderTarget.h
index e888397cdd..6ea332a0ae 100644
--- a/src/gpu/vk/GrVkTextureRenderTarget.h
+++ b/src/gpu/vk/GrVkTextureRenderTarget.h
@@ -20,7 +20,7 @@
#endif
class GrVkImageView;
-struct GrVkTextureInfo;
+struct GrVkImageInfo;
class GrVkTextureRenderTarget: public GrVkTexture, public GrVkRenderTarget {
public:
@@ -31,8 +31,7 @@ public:
static GrVkTextureRenderTarget* CreateWrappedTextureRenderTarget(GrVkGpu*,
const GrSurfaceDesc&,
GrWrapOwnership,
- VkFormat,
- const GrVkTextureInfo*);
+ const GrVkImageInfo*);
protected:
void onAbandon() override {
@@ -49,67 +48,65 @@ private:
GrVkTextureRenderTarget(GrVkGpu* gpu,
SkBudgeted budgeted,
const GrSurfaceDesc& desc,
- const GrVkImage::Resource* imageResource,
+ const GrVkImageInfo& info,
const GrVkImageView* texView,
- const GrVkImage::Resource* msaaResource,
+ const GrVkImageInfo& msaaInfo,
const GrVkImageView* colorAttachmentView,
const GrVkImageView* resolveAttachmentView)
: GrSurface(gpu, desc)
- , GrVkImage(imageResource)
- , GrVkTexture(gpu, desc, imageResource, texView)
- , GrVkRenderTarget(gpu, desc, imageResource, msaaResource, colorAttachmentView,
- resolveAttachmentView) {
+ , GrVkImage(info, GrVkImage::kNot_Wrapped)
+ , GrVkTexture(gpu, desc, info, texView, GrVkImage::kNot_Wrapped)
+ , GrVkRenderTarget(gpu, desc, info, msaaInfo, colorAttachmentView,
+ resolveAttachmentView, GrVkImage::kNot_Wrapped) {
this->registerWithCache(budgeted);
}
GrVkTextureRenderTarget(GrVkGpu* gpu,
SkBudgeted budgeted,
const GrSurfaceDesc& desc,
- const GrVkImage::Resource* imageResource,
+ const GrVkImageInfo& info,
const GrVkImageView* texView,
const GrVkImageView* colorAttachmentView)
: GrSurface(gpu, desc)
- , GrVkImage(imageResource)
- , GrVkTexture(gpu, desc, imageResource, texView)
- , GrVkRenderTarget(gpu, desc, imageResource, colorAttachmentView) {
+ , GrVkImage(info, GrVkImage::kNot_Wrapped)
+ , GrVkTexture(gpu, desc, info, texView, GrVkImage::kNot_Wrapped)
+ , GrVkRenderTarget(gpu, desc, info, colorAttachmentView, GrVkImage::kNot_Wrapped) {
this->registerWithCache(budgeted);
}
- enum Wrapped { kWrapped };
GrVkTextureRenderTarget(GrVkGpu* gpu,
- Wrapped,
const GrSurfaceDesc& desc,
- const GrVkImage::Resource* imageResource,
+ const GrVkImageInfo& info,
const GrVkImageView* texView,
- const GrVkImage::Resource* msaaResource,
+ const GrVkImageInfo& msaaInfo,
const GrVkImageView* colorAttachmentView,
- const GrVkImageView* resolveAttachmentView)
+ const GrVkImageView* resolveAttachmentView,
+ GrVkImage::Wrapped wrapped)
: GrSurface(gpu, desc)
- , GrVkImage(imageResource)
- , GrVkTexture(gpu, desc, imageResource, texView)
- , GrVkRenderTarget(gpu, desc, imageResource, msaaResource, colorAttachmentView,
- resolveAttachmentView) {
+ , GrVkImage(info, wrapped)
+ , GrVkTexture(gpu, desc, info, texView, wrapped)
+ , GrVkRenderTarget(gpu, desc, info, msaaInfo, colorAttachmentView,
+ resolveAttachmentView, wrapped) {
this->registerWithCacheWrapped();
}
GrVkTextureRenderTarget(GrVkGpu* gpu,
- Wrapped,
const GrSurfaceDesc& desc,
- const GrVkImage::Resource* imageResource,
+ const GrVkImageInfo& info,
const GrVkImageView* texView,
- const GrVkImageView* colorAttachmentView)
+ const GrVkImageView* colorAttachmentView,
+ GrVkImage::Wrapped wrapped)
: GrSurface(gpu, desc)
- , GrVkImage(imageResource)
- , GrVkTexture(gpu, desc, imageResource, texView)
- , GrVkRenderTarget(gpu, desc, imageResource, colorAttachmentView) {
+ , GrVkImage(info, wrapped)
+ , GrVkTexture(gpu, desc, info, texView, wrapped)
+ , GrVkRenderTarget(gpu, desc, info, colorAttachmentView, wrapped) {
this->registerWithCacheWrapped();
}
- template <typename ResourceType>
static GrVkTextureRenderTarget* Create(GrVkGpu*,
- ResourceType,
const GrSurfaceDesc&,
- VkFormat,
- const GrVkImage::Resource* imageResource);
+ const GrVkImageInfo&,
+ SkBudgeted budgeted,
+ GrVkImage::Wrapped wrapped);
// GrGLRenderTarget accounts for the texture's memory and any MSAA renderbuffer's memory.
size_t onGpuMemorySize() const override {
diff --git a/tests/VkWrapTests.cpp b/tests/VkWrapTests.cpp
index e81ebf5f17..6122655938 100644
--- a/tests/VkWrapTests.cpp
+++ b/tests/VkWrapTests.cpp
@@ -30,7 +30,7 @@ void wrap_tex_test(skiatest::Reporter* reporter, GrContext* context) {
GrVkGpu* gpu = static_cast<GrVkGpu*>(context->getGpu());
GrBackendObject backendObj = gpu->createTestingOnlyBackendTexture(nullptr, kW, kH, kPixelConfig);
- const GrVkTextureInfo* backendTex = reinterpret_cast<const GrVkTextureInfo*>(backendObj);
+ const GrVkImageInfo* backendTex = reinterpret_cast<const GrVkImageInfo*>(backendObj);
// check basic borrowed creation
GrBackendTextureDesc desc;
@@ -43,7 +43,7 @@ void wrap_tex_test(skiatest::Reporter* reporter, GrContext* context) {
tex->unref();
// image is null
- GrVkTextureInfo backendCopy = *backendTex;
+ GrVkImageInfo backendCopy = *backendTex;
backendCopy.fImage = VK_NULL_HANDLE;
desc.fTextureHandle = (GrBackendObject) &backendCopy;
tex = gpu->wrapBackendTexture(desc, kBorrow_GrWrapOwnership);
@@ -72,7 +72,7 @@ void wrap_rt_test(skiatest::Reporter* reporter, GrContext* context) {
GrVkGpu* gpu = static_cast<GrVkGpu*>(context->getGpu());
GrBackendObject backendObj = gpu->createTestingOnlyBackendTexture(nullptr, kW, kH, kPixelConfig);
- const GrVkTextureInfo* backendTex = reinterpret_cast<const GrVkTextureInfo*>(backendObj);
+ const GrVkImageInfo* backendTex = reinterpret_cast<const GrVkImageInfo*>(backendObj);
// check basic borrowed creation
GrBackendRenderTargetDesc desc;
@@ -88,7 +88,7 @@ void wrap_rt_test(skiatest::Reporter* reporter, GrContext* context) {
rt->unref();
// image is null
- GrVkTextureInfo backendCopy = *backendTex;
+ GrVkImageInfo backendCopy = *backendTex;
backendCopy.fImage = VK_NULL_HANDLE;
desc.fRenderTargetHandle = (GrBackendObject)&backendCopy;
rt = gpu->wrapBackendRenderTarget(desc, kBorrow_GrWrapOwnership);
@@ -119,7 +119,7 @@ void wrap_trt_test(skiatest::Reporter* reporter, GrContext* context) {
GrVkGpu* gpu = static_cast<GrVkGpu*>(context->getGpu());
GrBackendObject backendObj = gpu->createTestingOnlyBackendTexture(nullptr, kW, kH, kPixelConfig);
- const GrVkTextureInfo* backendTex = reinterpret_cast<const GrVkTextureInfo*>(backendObj);
+ const GrVkImageInfo* backendTex = reinterpret_cast<const GrVkImageInfo*>(backendObj);
// check basic borrowed creation
GrBackendTextureDesc desc;
@@ -133,7 +133,7 @@ void wrap_trt_test(skiatest::Reporter* reporter, GrContext* context) {
tex->unref();
// image is null
- GrVkTextureInfo backendCopy = *backendTex;
+ GrVkImageInfo backendCopy = *backendTex;
backendCopy.fImage = VK_NULL_HANDLE;
desc.fTextureHandle = (GrBackendObject)&backendCopy;
tex = gpu->wrapBackendTexture(desc, kBorrow_GrWrapOwnership);
diff --git a/tools/viewer/sk_app/VulkanWindowContext.cpp b/tools/viewer/sk_app/VulkanWindowContext.cpp
index d2ea2bec4d..2570e826a3 100644
--- a/tools/viewer/sk_app/VulkanWindowContext.cpp
+++ b/tools/viewer/sk_app/VulkanWindowContext.cpp
@@ -255,7 +255,7 @@ void VulkanWindowContext::createBuffers(VkFormat format) {
fImageLayouts[i] = VK_IMAGE_LAYOUT_UNDEFINED;
GrBackendRenderTargetDesc desc;
- GrVkTextureInfo info;
+ GrVkImageInfo info;
info.fImage = fImages[i];
info.fAlloc = VK_NULL_HANDLE;
info.fImageLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
generated by cgit v1.2.3 (git 2.39.1) at 2024-06-07 12:33:13 +0000