Skip to content

A
angle
Commit 1c1c6b4e by Ian Elliott Committed by Commit Bot
Options

Vulkan: Cache/re-use vkImageView's per max level

For applications that frequently switch a texture's max level, cache and re-use "read view" vkImageViews per max-level. Test: NBA 2K20 Test: angle_deqp_gles3_tests --gtest_filter=dEQP.GLES3/functional_texture_mipmap_*_max_level_* --use-angle=vulkan Bug: b/161993151 Change-Id: I9a6a81d5234196040bc6c264ec627a073ba73293 Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/2321370 Commit-Queue: Ian Elliott <ianelliott@google.com> Reviewed-by: 's avatarTim Van Patten <timvp@google.com> Reviewed-by: 's avatarShahbaz Youssefi <syoussefi@chromium.org>
parent 4cf2501c
Showing with 286 additions and 149 deletions
src/libANGLE/renderer/vulkan/RenderTargetVk.cpp
......@@ -123,13 +123,11 @@ angle::Result RenderTargetVk::getAndRetainCopyImageView(ContextVk *contextVk,
retainImageViews(contextVk);
const vk::ImageViewHelper *imageViews = mImageViews;
const vk::ImageView &copyView = imageViews->getCopyImageView();
// If the source of render target is a texture or renderbuffer, this will always be valid. This
// is also where 3D or 2DArray images could be the source of the render target.
if (copyView.valid())
if (imageViews->hasCopyImageView())
{
*imageViewOut = &copyView;
*imageViewOut = &imageViews->getCopyImageView();
return angle::Result::Continue;
}
......
src/libANGLE/renderer/vulkan/TextureVk.cpp
......@@ -1688,20 +1688,17 @@ angle::Result TextureVk::updateBaseMaxLevels(ContextVk *contextVk,
// number of mip levels
if (!baseLevelChanged && (maxLevel < baseLevel + mImage->getLevelCount()))
{
// Don't need to respecify the texture; just redo the texture's vkImageViews
// Don't need to respecify the texture; but do need to update which vkImageView's are
// served up by ImageViewHelper
ASSERT(maxLevelChanged);
// Release the current vkImageViews
RendererVk *renderer = contextVk->getRenderer();
mImageViews.release(renderer);
// Track the levels in our ImageHelper
mImage->setBaseAndMaxLevels(baseLevel, maxLevel);
// Update the texture's serial so that the descriptor set is updated correctly
mSerial = contextVk->generateTextureSerial();
// Change the vkImageViews
// Update the current max level in ImageViewHelper
const gl::ImageDesc &baseLevelDesc = mState.getBaseLevelDesc();
// We use a special layer count here to handle EGLImages. They might only be
// looking at one layer of a cube or 2D array texture.
......@@ -2243,15 +2240,9 @@ angle::Result TextureVk::initImageViews(ContextVk *contextVk,
gl::SwizzleState readSwizzle = ApplySwizzle(formatSwizzle, mState.getSwizzleState());
ANGLE_TRY(mImageViews.initReadViews(contextVk, mState.getType(), *mImage, format, formatSwizzle,
readSwizzle, baseLevel, levelCount, baseLayer, layerCount));
if (mRequiresSRGBViews)
{
ASSERT((mImageCreateFlags & VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT) != 0);
ANGLE_TRY(mImageViews.initSRGBReadViews(
contextVk, mState.getType(), *mImage, format, formatSwizzle, readSwizzle, baseLevel,
levelCount, baseLayer, layerCount, mImageUsageFlags & ~VK_IMAGE_USAGE_STORAGE_BIT));
}
readSwizzle, baseLevel, levelCount, baseLayer, layerCount,
mRequiresSRGBViews,
mImageUsageFlags & ~VK_IMAGE_USAGE_STORAGE_BIT));
return angle::Result::Continue;
}
......
src/libANGLE/renderer/vulkan/vk_helpers.cpp
......@@ -434,6 +434,27 @@ uint32_t GetImageLayerCountForView(const ImageHelper &image)
return image.getExtents().depth > 1 ? image.getExtents().depth : image.getLayerCount();
}
void ReleaseImageViews(ImageViewVector *imageViewVector, std::vector<GarbageObject> *garbage)
{
for (ImageView &imageView : *imageViewVector)
{
if (imageView.valid())
{
garbage->emplace_back(GetGarbage(&imageView));
}
}
imageViewVector->clear();
}
void DestroyImageViews(ImageViewVector *imageViewVector, VkDevice device)
{
for (ImageView &imageView : *imageViewVector)
{
imageView.destroy(device);
}
imageViewVector->clear();
}
ImageView *GetLevelImageView(ImageViewVector *imageViews, uint32_t levelVK, uint32_t levelCount)
{
// Lazily allocate the storage for image views. We allocate the full level count because we
......@@ -4937,22 +4958,23 @@ void FramebufferHelper::release(ContextVk *contextVk)
}
// ImageViewHelper implementation.
ImageViewHelper::ImageViewHelper() : mLinearColorspace(true)
ImageViewHelper::ImageViewHelper() : mCurrentMaxLevel(0), mLinearColorspace(true)
{
mUse.init();
}
ImageViewHelper::ImageViewHelper(ImageViewHelper &&other)
{
std::swap(mLinearReadImageView, other.mLinearReadImageView);
std::swap(mNonLinearReadImageView, other.mNonLinearReadImageView);
std::swap(mLinearFetchImageView, other.mLinearFetchImageView);
std::swap(mNonLinearFetchImageView, other.mNonLinearFetchImageView);
std::swap(mLinearCopyImageView, other.mLinearCopyImageView);
std::swap(mNonLinearCopyImageView, other.mNonLinearCopyImageView);
std::swap(mCurrentMaxLevel, other.mCurrentMaxLevel);
std::swap(mPerLevelLinearReadImageViews, other.mPerLevelLinearReadImageViews);
std::swap(mPerLevelNonLinearReadImageViews, other.mPerLevelNonLinearReadImageViews);
std::swap(mPerLevelLinearFetchImageViews, other.mPerLevelLinearFetchImageViews);
std::swap(mPerLevelNonLinearFetchImageViews, other.mPerLevelNonLinearFetchImageViews);
std::swap(mPerLevelLinearCopyImageViews, other.mPerLevelLinearCopyImageViews);
std::swap(mPerLevelNonLinearCopyImageViews, other.mPerLevelNonLinearCopyImageViews);
std::swap(mLinearColorspace, other.mLinearColorspace);
std::swap(mStencilReadImageView, other.mStencilReadImageView);
std::swap(mPerLevelStencilReadImageViews, other.mPerLevelStencilReadImageViews);
std::swap(mLevelDrawImageViews, other.mLevelDrawImageViews);
std::swap(mLayerLevelDrawImageViews, other.mLayerLevelDrawImageViews);
std::swap(mSerialCache, other.mSerialCache);
......@@ -4967,44 +4989,19 @@ void ImageViewHelper::release(RendererVk *renderer)
{
std::vector<GarbageObject> garbage;
if (mLinearReadImageView.valid())
{
garbage.emplace_back(GetGarbage(&mLinearReadImageView));
}
if (mNonLinearReadImageView.valid())
{
garbage.emplace_back(GetGarbage(&mNonLinearReadImageView));
}
if (mLinearFetchImageView.valid())
{
garbage.emplace_back(GetGarbage(&mLinearFetchImageView));
}
if (mNonLinearFetchImageView.valid())
{
garbage.emplace_back(GetGarbage(&mNonLinearFetchImageView));
}
if (mLinearCopyImageView.valid())
{
garbage.emplace_back(GetGarbage(&mLinearCopyImageView));
}
if (mNonLinearCopyImageView.valid())
{
garbage.emplace_back(GetGarbage(&mNonLinearCopyImageView));
}
if (mStencilReadImageView.valid())
{
garbage.emplace_back(GetGarbage(&mStencilReadImageView));
}
mCurrentMaxLevel = 0;
for (ImageView &imageView : mLevelDrawImageViews)
{
if (imageView.valid())
{
garbage.emplace_back(GetGarbage(&imageView));
}
}
mLevelDrawImageViews.clear();
// Release the read views
ReleaseImageViews(&mPerLevelLinearReadImageViews, &garbage);
ReleaseImageViews(&mPerLevelNonLinearReadImageViews, &garbage);
ReleaseImageViews(&mPerLevelLinearFetchImageViews, &garbage);
ReleaseImageViews(&mPerLevelNonLinearFetchImageViews, &garbage);
ReleaseImageViews(&mPerLevelLinearCopyImageViews, &garbage);
ReleaseImageViews(&mPerLevelNonLinearCopyImageViews, &garbage);
ReleaseImageViews(&mPerLevelStencilReadImageViews, &garbage);
// Release the draw views
ReleaseImageViews(&mLevelDrawImageViews, &garbage);
for (ImageViewVector &layerViews : mLayerLevelDrawImageViews)
{
for (ImageView &imageView : layerViews)
......@@ -5030,20 +5027,19 @@ void ImageViewHelper::release(RendererVk *renderer)
void ImageViewHelper::destroy(VkDevice device)
{
mLinearReadImageView.destroy(device);
mNonLinearReadImageView.destroy(device);
mLinearFetchImageView.destroy(device);
mNonLinearFetchImageView.destroy(device);
mLinearCopyImageView.destroy(device);
mNonLinearCopyImageView.destroy(device);
mStencilReadImageView.destroy(device);
mCurrentMaxLevel = 0;
for (ImageView &imageView : mLevelDrawImageViews)
{
imageView.destroy(device);
}
mLevelDrawImageViews.clear();
// Release the read views
DestroyImageViews(&mPerLevelLinearReadImageViews, device);
DestroyImageViews(&mPerLevelNonLinearReadImageViews, device);
DestroyImageViews(&mPerLevelLinearFetchImageViews, device);
DestroyImageViews(&mPerLevelNonLinearFetchImageViews, device);
DestroyImageViews(&mPerLevelLinearCopyImageViews, device);
DestroyImageViews(&mPerLevelNonLinearCopyImageViews, device);
DestroyImageViews(&mPerLevelStencilReadImageViews, device);
// Release the draw views
DestroyImageViews(&mLevelDrawImageViews, device);
for (ImageViewVector &layerViews : mLayerLevelDrawImageViews)
{
for (ImageView &imageView : layerViews)
......@@ -5065,7 +5061,51 @@ angle::Result ImageViewHelper::initReadViews(ContextVk *contextVk,
uint32_t baseLevel,
uint32_t levelCount,
uint32_t baseLayer,
uint32_t layerCount)
uint32_t layerCount,
bool requiresSRGBViews,
VkImageUsageFlags imageUsageFlags)
{
ASSERT(levelCount > 0);
if (levelCount > mPerLevelLinearReadImageViews.size())
{
mPerLevelLinearReadImageViews.resize(levelCount);
mPerLevelNonLinearReadImageViews.resize(levelCount);
mPerLevelLinearFetchImageViews.resize(levelCount);
mPerLevelNonLinearFetchImageViews.resize(levelCount);
mPerLevelLinearCopyImageViews.resize(levelCount);
mPerLevelNonLinearCopyImageViews.resize(levelCount);
mPerLevelStencilReadImageViews.resize(levelCount);
}
mCurrentMaxLevel = levelCount - 1;
// Determine if we already have ImageView's for the new max level
if (getReadImageView().getHandle() == VK_NULL_HANDLE)
{
// Since we don't have a readImageView, we must create ImageView's for the new max level
ANGLE_TRY(initReadViewsImpl(contextVk, viewType, image, format, formatSwizzle, readSwizzle,
baseLevel, levelCount, baseLayer, layerCount));
if (requiresSRGBViews)
{
ANGLE_TRY(initSRGBReadViewsImpl(contextVk, viewType, image, format, formatSwizzle,
readSwizzle, baseLevel, levelCount, baseLayer,
layerCount, imageUsageFlags));
}
}
return angle::Result::Continue;
}
angle::Result ImageViewHelper::initReadViewsImpl(ContextVk *contextVk,
gl::TextureType viewType,
const ImageHelper &image,
const Format &format,
const gl::SwizzleState &formatSwizzle,
const gl::SwizzleState &readSwizzle,
uint32_t baseLevel,
uint32_t levelCount,
uint32_t baseLayer,
uint32_t layerCount)
{
const VkImageAspectFlags aspectFlags = GetFormatAspectFlags(format.intendedFormat());
mLinearColorspace = IsLinearFormat(format.vkImageFormat);
......@@ -5076,8 +5116,9 @@ angle::Result ImageViewHelper::initReadViews(ContextVk *contextVk,
readSwizzle, &getReadImageView(), baseLevel, levelCount,
baseLayer, layerCount));
ANGLE_TRY(image.initLayerImageView(contextVk, viewType, VK_IMAGE_ASPECT_STENCIL_BIT,
readSwizzle, &mStencilReadImageView, baseLevel,
levelCount, baseLayer, layerCount));
readSwizzle,
&mPerLevelStencilReadImageViews[mCurrentMaxLevel],
baseLevel, levelCount, baseLayer, layerCount));
}
else
{
......@@ -5105,17 +5146,17 @@ angle::Result ImageViewHelper::initReadViews(ContextVk *contextVk,
return angle::Result::Continue;
}
angle::Result ImageViewHelper::initSRGBReadViews(ContextVk *contextVk,
gl::TextureType viewType,
const ImageHelper &image,
const Format &format,
const gl::SwizzleState &formatSwizzle,
const gl::SwizzleState &readSwizzle,
uint32_t baseLevel,
uint32_t levelCount,
uint32_t baseLayer,
uint32_t layerCount,
VkImageUsageFlags imageUsageFlags)
angle::Result ImageViewHelper::initSRGBReadViewsImpl(ContextVk *contextVk,
gl::TextureType viewType,
const ImageHelper &image,
const Format &format,
const gl::SwizzleState &formatSwizzle,
const gl::SwizzleState &readSwizzle,
uint32_t baseLevel,
uint32_t levelCount,
uint32_t baseLayer,
uint32_t layerCount,
VkImageUsageFlags imageUsageFlags)
{
VkFormat nonLinearOverrideFormat = ConvertToNonLinear(image.getFormat().vkImageFormat);
VkFormat linearOverrideFormat = ConvertToLinear(image.getFormat().vkImageFormat);
......@@ -5125,17 +5166,20 @@ angle::Result ImageViewHelper::initSRGBReadViews(ContextVk *contextVk,
const VkImageAspectFlags aspectFlags = GetFormatAspectFlags(format.intendedFormat());
if (!mLinearReadImageView.valid())
if (!mPerLevelLinearReadImageViews[mCurrentMaxLevel].valid())
{
ANGLE_TRY(image.initAliasedLayerImageView(
contextVk, viewType, aspectFlags, readSwizzle, &mLinearReadImageView, baseLevel,
levelCount, baseLayer, layerCount, imageUsageFlags, linearFormat));
ANGLE_TRY(image.initAliasedLayerImageView(contextVk, viewType, aspectFlags, readSwizzle,
&mPerLevelLinearReadImageViews[mCurrentMaxLevel],
baseLevel, levelCount, baseLayer, layerCount,
imageUsageFlags, linearFormat));
}
if (nonLinearOverrideFormat != VK_FORMAT_UNDEFINED && !mNonLinearReadImageView.valid())
if (nonLinearOverrideFormat != VK_FORMAT_UNDEFINED &&
!mPerLevelNonLinearReadImageViews[mCurrentMaxLevel].valid())
{
ANGLE_TRY(image.initAliasedLayerImageView(
contextVk, viewType, aspectFlags, readSwizzle, &mNonLinearReadImageView, baseLevel,
levelCount, baseLayer, layerCount, imageUsageFlags, nonLinearOverrideFormat));
contextVk, viewType, aspectFlags, readSwizzle,
&mPerLevelNonLinearReadImageViews[mCurrentMaxLevel], baseLevel, levelCount, baseLayer,
layerCount, imageUsageFlags, nonLinearOverrideFormat));
}
gl::TextureType fetchType = viewType;
......@@ -5145,33 +5189,38 @@ angle::Result ImageViewHelper::initSRGBReadViews(ContextVk *contextVk,
{
fetchType = Get2DTextureType(layerCount, image.getSamples());
if (!mLinearFetchImageView.valid())
if (!mPerLevelLinearFetchImageViews[mCurrentMaxLevel].valid())
{
ANGLE_TRY(image.initAliasedLayerImageView(
contextVk, fetchType, aspectFlags, readSwizzle, &mLinearFetchImageView, baseLevel,
levelCount, baseLayer, layerCount, imageUsageFlags, linearFormat));
contextVk, fetchType, aspectFlags, readSwizzle,
&mPerLevelLinearFetchImageViews[mCurrentMaxLevel], baseLevel, levelCount, baseLayer,
layerCount, imageUsageFlags, linearFormat));
}
if (nonLinearOverrideFormat != VK_FORMAT_UNDEFINED && !mNonLinearFetchImageView.valid())
if (nonLinearOverrideFormat != VK_FORMAT_UNDEFINED &&
!mPerLevelNonLinearFetchImageViews[mCurrentMaxLevel].valid())
{
ANGLE_TRY(image.initAliasedLayerImageView(contextVk, fetchType, aspectFlags,
readSwizzle, &mNonLinearFetchImageView,
baseLevel, levelCount, baseLayer, layerCount,
imageUsageFlags, nonLinearOverrideFormat));
ANGLE_TRY(image.initAliasedLayerImageView(
contextVk, fetchType, aspectFlags, readSwizzle,
&mPerLevelNonLinearFetchImageViews[mCurrentMaxLevel], baseLevel, levelCount,
baseLayer, layerCount, imageUsageFlags, nonLinearOverrideFormat));
}
}
if (!mLinearCopyImageView.valid())
if (!mPerLevelLinearCopyImageViews[mCurrentMaxLevel].valid())
{
ANGLE_TRY(image.initAliasedLayerImageView(
contextVk, fetchType, aspectFlags, formatSwizzle, &mLinearCopyImageView, baseLevel,
levelCount, baseLayer, layerCount, imageUsageFlags, linearFormat));
ANGLE_TRY(image.initAliasedLayerImageView(contextVk, fetchType, aspectFlags, formatSwizzle,
&mPerLevelLinearCopyImageViews[mCurrentMaxLevel],
baseLevel, levelCount, baseLayer, layerCount,
imageUsageFlags, linearFormat));
}
if (nonLinearOverrideFormat != VK_FORMAT_UNDEFINED && !mNonLinearCopyImageView.valid())
if (nonLinearOverrideFormat != VK_FORMAT_UNDEFINED &&
!mPerLevelNonLinearCopyImageViews[mCurrentMaxLevel].valid())
{
ANGLE_TRY(image.initAliasedLayerImageView(
contextVk, fetchType, aspectFlags, formatSwizzle, &mNonLinearCopyImageView, baseLevel,
levelCount, baseLayer, layerCount, imageUsageFlags, nonLinearOverrideFormat));
contextVk, fetchType, aspectFlags, formatSwizzle,
&mPerLevelNonLinearCopyImageViews[mCurrentMaxLevel], baseLevel, levelCount, baseLayer,
layerCount, imageUsageFlags, nonLinearOverrideFormat));
}
return angle::Result::Continue;
......
src/libANGLE/renderer/vulkan/vk_helpers.h
......@@ -1583,38 +1583,93 @@ class ImageViewHelper : angle::NonCopyable
void release(RendererVk *renderer);
void destroy(VkDevice device);
const ImageView &getLinearReadImageView() const { return mLinearReadImageView; }
const ImageView &getNonLinearReadImageView() const { return mNonLinearReadImageView; }
const ImageView &getLinearFetchImageView() const { return mLinearFetchImageView; }
const ImageView &getNonLinearFetchImageView() const { return mNonLinearFetchImageView; }
const ImageView &getLinearCopyImageView() const { return mLinearCopyImageView; }
const ImageView &getNonLinearCopyImageView() const { return mNonLinearCopyImageView; }
const ImageView &getStencilReadImageView() const { return mStencilReadImageView; }
const ImageView &getLinearReadImageView() const
{
return getValidReadViewImpl(mPerLevelLinearReadImageViews);
}
const ImageView &getNonLinearReadImageView() const
{
return getValidReadViewImpl(mPerLevelNonLinearReadImageViews);
}
const ImageView &getLinearFetchImageView() const
{
return getValidReadViewImpl(mPerLevelLinearFetchImageViews);
}
const ImageView &getNonLinearFetchImageView() const
{
return getValidReadViewImpl(mPerLevelNonLinearFetchImageViews);
}
const ImageView &getLinearCopyImageView() const
{
return getValidReadViewImpl(mPerLevelLinearCopyImageViews);
}
const ImageView &getNonLinearCopyImageView() const
{
return getValidReadViewImpl(mPerLevelNonLinearCopyImageViews);
}
const ImageView &getStencilReadImageView() const
{
return getValidReadViewImpl(mPerLevelStencilReadImageViews);
}
const ImageView &getReadImageView() const
{
return mLinearColorspace ? mLinearReadImageView : mNonLinearReadImageView;
return mLinearColorspace ? getReadViewImpl(mPerLevelLinearReadImageViews)
: getReadViewImpl(mPerLevelNonLinearReadImageViews);
}
const ImageView &getFetchImageView() const
{
return mLinearColorspace ? mLinearFetchImageView : mNonLinearFetchImageView;
return mLinearColorspace ? getReadViewImpl(mPerLevelLinearFetchImageViews)
: getReadViewImpl(mPerLevelNonLinearFetchImageViews);
}
const ImageView &getCopyImageView() const
{
return mLinearColorspace ? mLinearCopyImageView : mNonLinearCopyImageView;
return mLinearColorspace ? getReadViewImpl(mPerLevelLinearCopyImageViews)
: getReadViewImpl(mPerLevelNonLinearCopyImageViews);
}
// Used when initialized RenderTargets.
bool hasStencilReadImageView() const { return mStencilReadImageView.valid(); }
bool hasStencilReadImageView() const
{
return (mCurrentMaxLevel < mPerLevelStencilReadImageViews.size())
? mPerLevelStencilReadImageViews[mCurrentMaxLevel].valid()
: false;
}
bool hasFetchImageView() const { return getFetchImageView().valid(); }
bool hasFetchImageView() const
{
if ((mLinearColorspace && (mCurrentMaxLevel < mPerLevelLinearFetchImageViews.size())) ||
(!mLinearColorspace && (mCurrentMaxLevel < mPerLevelNonLinearFetchImageViews.size())))
{
return getFetchImageView().valid();
}
else
{
return false;
}
}
bool hasCopyImageView() const
{
if ((mLinearColorspace && (mCurrentMaxLevel < mPerLevelLinearCopyImageViews.size())) ||
(!mLinearColorspace && (mCurrentMaxLevel < mPerLevelNonLinearCopyImageViews.size())))
{
return getFetchImageView().valid();
}
else
{
return false;
}
}
// Store reference to usage in graph.
void retain(ResourceUseList *resourceUseList) const { resourceUseList->add(mUse); }
// Creates views with multiple layers and levels.
// For applications that frequently switch a texture's max level, and make no other changes to
// the texture, change the currently-used max level, and potentially create new "read views"
// for the new max-level
angle::Result initReadViews(ContextVk *contextVk,
gl::TextureType viewType,
const ImageHelper &image,
......@@ -1624,20 +1679,9 @@ class ImageViewHelper : angle::NonCopyable
uint32_t baseLevel,
uint32_t levelCount,
uint32_t baseLayer,
uint32_t layerCount);
// Create SRGB-reinterpreted read views
angle::Result initSRGBReadViews(ContextVk *contextVk,
gl::TextureType viewType,
const ImageHelper &image,
const Format &format,
const gl::SwizzleState &formatSwizzle,
const gl::SwizzleState &readSwizzle,
uint32_t baseLevel,
uint32_t levelCount,
uint32_t baseLayer,
uint32_t layerCount,
VkImageUsageFlags imageUsageFlags);
uint32_t layerCount,
bool requiresSRGBViews,
VkImageUsageFlags imageUsageFlags);
// Creates a view with all layers of the level.
angle::Result getLevelDrawImageView(ContextVk *contextVk,
......@@ -1662,28 +1706,83 @@ class ImageViewHelper : angle::NonCopyable
private:
ImageView &getReadImageView()
{
return mLinearColorspace ? mLinearReadImageView : mNonLinearReadImageView;
return mLinearColorspace ? getReadViewImpl(mPerLevelLinearReadImageViews)
: getReadViewImpl(mPerLevelNonLinearReadImageViews);
}
ImageView &getFetchImageView()
{
return mLinearColorspace ? mLinearFetchImageView : mNonLinearFetchImageView;
return mLinearColorspace ? getReadViewImpl(mPerLevelLinearFetchImageViews)
: getReadViewImpl(mPerLevelNonLinearFetchImageViews);
}
ImageView &getCopyImageView()
{
return mLinearColorspace ? mLinearCopyImageView : mNonLinearCopyImageView;
return mLinearColorspace ? getReadViewImpl(mPerLevelLinearCopyImageViews)
: getReadViewImpl(mPerLevelNonLinearCopyImageViews);
}
// Used by public get*ImageView() methods to do proper assert based on vector size and validity
inline const ImageView &getValidReadViewImpl(const ImageViewVector &imageViewVector) const
{
ASSERT(mCurrentMaxLevel < imageViewVector.size() &&
imageViewVector[mCurrentMaxLevel].valid());
return imageViewVector[mCurrentMaxLevel];
}
// Used by public get*ImageView() methods to do proper assert based on vector size
inline const ImageView &getReadViewImpl(const ImageViewVector &imageViewVector) const
{
ASSERT(mCurrentMaxLevel < imageViewVector.size());
return imageViewVector[mCurrentMaxLevel];
}
// Used by private get*ImageView() methods to do proper assert based on vector size
inline ImageView &getReadViewImpl(ImageViewVector &imageViewVector)
{
ASSERT(mCurrentMaxLevel < imageViewVector.size());
return imageViewVector[mCurrentMaxLevel];
}
// Creates views with multiple layers and levels.
angle::Result initReadViewsImpl(ContextVk *contextVk,
gl::TextureType viewType,
const ImageHelper &image,
const Format &format,
const gl::SwizzleState &formatSwizzle,
const gl::SwizzleState &readSwizzle,
uint32_t baseLevel,
uint32_t levelCount,
uint32_t baseLayer,
uint32_t layerCount);
// Create SRGB-reinterpreted read views
angle::Result initSRGBReadViewsImpl(ContextVk *contextVk,
gl::TextureType viewType,
const ImageHelper &image,
const Format &format,
const gl::SwizzleState &formatSwizzle,
const gl::SwizzleState &readSwizzle,
uint32_t baseLevel,
uint32_t levelCount,
uint32_t baseLayer,
uint32_t layerCount,
VkImageUsageFlags imageUsageFlags);
// Lifetime.
SharedResourceUse mUse;
// Read views
ImageView mLinearReadImageView;
ImageView mNonLinearReadImageView;
ImageView mLinearFetchImageView;
ImageView mNonLinearFetchImageView;
ImageView mLinearCopyImageView;
ImageView mNonLinearCopyImageView;
ImageView mStencilReadImageView;
// For applications that frequently switch a texture's max level, and make no other changes to
// the texture, keep track of the currently-used max level, and keep one "read view" per
// max-level
uint32_t mCurrentMaxLevel;
// Read views (one per max-level)
ImageViewVector mPerLevelLinearReadImageViews;
ImageViewVector mPerLevelNonLinearReadImageViews;
ImageViewVector mPerLevelLinearFetchImageViews;
ImageViewVector mPerLevelNonLinearFetchImageViews;
ImageViewVector mPerLevelLinearCopyImageViews;
ImageViewVector mPerLevelNonLinearCopyImageViews;
ImageViewVector mPerLevelStencilReadImageViews;
bool mLinearColorspace;
......
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