Vulkan: Use VK_EXT_multisampled_render_to_single_sampled
Additionally, makes the emulation path not require
independentResolveNone. This was only used to select the NONE resolve
mode when the attachment format doesn't have either of depth or stencil
aspects, but it's ok to specify the same resolve mode for both aspects
even if one aspect is missing.
Bug: chromium:1088005
Change-Id: Ifc37cbf5331145179c5927853b996a0d62b871ee
Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/2743666
Reviewed-by: David Reveman <reveman@chromium.org>
Reviewed-by: Jamie Madill <jmadill@chromium.org>
Reviewed-by: Tim Van Patten <timvp@google.com>
Commit-Queue: Shahbaz Youssefi <syoussefi@chromium.org>
diff --git a/include/platform/FeaturesVk.h b/include/platform/FeaturesVk.h
index 00d404e..4c70f9c 100644
--- a/include/platform/FeaturesVk.h
+++ b/include/platform/FeaturesVk.h
@@ -218,6 +218,13 @@
"extension with the independentResolveNone feature",
&members, "http://anglebug.com/4836"};
+ // Whether the VkDevice supports the VK_EXT_multisampled_render_to_single_sampled extension.
+ // http://anglebug.com/4836
+ Feature supportsMultisampledRenderToSingleSampled = {
+ "supportsMultisampledRenderToSingleSampled", FeatureCategory::VulkanFeatures,
+ "VkDevice supports the VK_EXT_multisampled_render_to_single_sampled extension", &members,
+ "http://anglebug.com/4836"};
+
// VK_PRESENT_MODE_FIFO_KHR causes random timeouts on Linux Intel. http://anglebug.com/3153
Feature disableFifoPresentMode = {"disableFifoPresentMode", FeatureCategory::VulkanWorkarounds,
"VK_PRESENT_MODE_FIFO_KHR causes random timeouts", &members,
diff --git a/src/common/vulkan/vk_headers.h b/src/common/vulkan/vk_headers.h
index 6c9b62e..3fa5330 100644
--- a/src/common/vulkan/vk_headers.h
+++ b/src/common/vulkan/vk_headers.h
@@ -16,6 +16,36 @@
# include <vulkan/vulkan.h>
#endif
+// For the unreleased VK_EXT_multisampled_render_to_single_sampled
+#if !defined(VK_EXT_multisampled_render_to_single_sampled)
+# define VK_EXT_multisampled_render_to_single_sampled 1
+# define VK_EXT_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_SPEC_VERSION 1
+# define VK_EXT_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_EXTENSION_NAME \
+ "VK_EXT_multisampled_render_to_single_sampled"
+
+# define VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_FEATURES_EXT \
+ ((VkStructureType)(1000376000))
+# define VK_STRUCTURE_TYPE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_INFO_EXT \
+ ((VkStructureType)(1000376001))
+
+typedef struct VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT
+{
+ VkStructureType sType;
+ const void *pNext;
+ VkBool32 multisampledRenderToSingleSampled;
+} VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT;
+
+typedef struct VkMultisampledRenderToSingleSampledInfoEXT
+{
+ VkStructureType sType;
+ const void *pNext;
+ VkBool32 multisampledRenderToSingleSampledEnable;
+ VkSampleCountFlagBits rasterizationSamples;
+ VkResolveModeFlagBits depthResolveMode;
+ VkResolveModeFlagBits stencilResolveMode;
+} VkMultisampledRenderToSingleSampledInfoEXT;
+#endif /* VK_EXT_multisampled_render_to_single_sampled */
+
#if !defined(ANGLE_SHARED_LIBVULKAN)
namespace rx
diff --git a/src/libANGLE/FramebufferAttachment.h b/src/libANGLE/FramebufferAttachment.h
index 5b6219d..013a1e0 100644
--- a/src/libANGLE/FramebufferAttachment.h
+++ b/src/libANGLE/FramebufferAttachment.h
@@ -117,6 +117,10 @@
bool isMultiview() const;
GLint getBaseViewIndex() const;
+ bool isRenderToTexture() const
+ {
+ return mRenderToTextureSamples != kDefaultRenderToTextureSamples;
+ }
GLsizei getRenderToTextureSamples() const { return mRenderToTextureSamples; }
// The size of the underlying resource the attachment points to. The 'depth' value will
diff --git a/src/libANGLE/renderer/vulkan/FramebufferVk.cpp b/src/libANGLE/renderer/vulkan/FramebufferVk.cpp
index 3b858e8..b96e8de 100644
--- a/src/libANGLE/renderer/vulkan/FramebufferVk.cpp
+++ b/src/libANGLE/renderer/vulkan/FramebufferVk.cpp
@@ -1938,11 +1938,7 @@
// Add the resolve attachment, if any.
if (depthStencilRenderTarget->hasResolveAttachment())
{
- const vk::Format &format = depthStencilRenderTarget->getImageFormat();
- bool hasDepth = format.intendedFormat().depthBits > 0;
- bool hasStencil = format.intendedFormat().stencilBits > 0;
-
- mRenderPassDesc.packDepthStencilResolveAttachment(hasDepth, hasStencil);
+ mRenderPassDesc.packDepthStencilResolveAttachment();
}
}
@@ -1962,6 +1958,31 @@
mRenderPassDesc.setFramebufferFetchMode(programUsesFramebufferFetch);
}
+ if (contextVk->getFeatures().supportsMultisampledRenderToSingleSampled.enabled)
+ {
+ // Update descriptions regarding multisampled-render-to-texture use.
+ bool isRenderToTexture = false;
+ for (size_t colorIndexGL : mState.getEnabledDrawBuffers())
+ {
+ const gl::FramebufferAttachment *color = mState.getColorAttachment(colorIndexGL);
+ ASSERT(color);
+
+ if (color->isRenderToTexture())
+ {
+ isRenderToTexture = true;
+ break;
+ }
+ }
+ const gl::FramebufferAttachment *depthStencil = mState.getDepthStencilAttachment();
+ if (depthStencil && depthStencil->isRenderToTexture())
+ {
+ isRenderToTexture = true;
+ }
+
+ mCurrentFramebufferDesc.updateRenderToTexture(isRenderToTexture);
+ mRenderPassDesc.updateRenderToTexture(isRenderToTexture);
+ }
+
mCurrentFramebufferDesc.updateUnresolveMask({});
mRenderPassDesc.setWriteControlMode(mCurrentFramebufferDesc.getWriteControlMode());
}
@@ -2731,23 +2752,35 @@
return rotatedScissoredArea;
}
-RenderTargetVk *FramebufferVk::getFirstRenderTarget() const
-{
- for (auto *renderTarget : mRenderTargetCache.getColors())
- {
- if (renderTarget)
- {
- return renderTarget;
- }
- }
-
- return getDepthStencilRenderTarget();
-}
-
GLint FramebufferVk::getSamples() const
{
- RenderTargetVk *firstRT = getFirstRenderTarget();
- return firstRT ? firstRT->getImageForRenderPass().getSamples() : 1;
+ const gl::FramebufferAttachment *lastAttachment = nullptr;
+
+ for (size_t colorIndexGL : mState.getEnabledDrawBuffers())
+ {
+ const gl::FramebufferAttachment *color = mState.getColorAttachment(colorIndexGL);
+ ASSERT(color);
+
+ if (color->isRenderToTexture())
+ {
+ return color->getSamples();
+ }
+
+ lastAttachment = color;
+ }
+ const gl::FramebufferAttachment *depthStencil = mState.getDepthOrStencilAttachment();
+ if (depthStencil)
+ {
+ if (depthStencil->isRenderToTexture())
+ {
+ return depthStencil->getSamples();
+ }
+ lastAttachment = depthStencil;
+ }
+
+ // If none of the attachments are multisampled-render-to-texture, take the sample count from the
+ // last attachment (any would have worked, as they would all have the same sample count).
+ return std::max(lastAttachment ? lastAttachment->getSamples() : 1, 1);
}
angle::Result FramebufferVk::flushDeferredClears(ContextVk *contextVk)
diff --git a/src/libANGLE/renderer/vulkan/FramebufferVk.h b/src/libANGLE/renderer/vulkan/FramebufferVk.h
index e3c0266..323a097 100644
--- a/src/libANGLE/renderer/vulkan/FramebufferVk.h
+++ b/src/libANGLE/renderer/vulkan/FramebufferVk.h
@@ -141,7 +141,6 @@
vk::CommandBuffer **commandBufferOut,
bool *renderPassDescChangedOut);
- RenderTargetVk *getFirstRenderTarget() const;
GLint getSamples() const;
const vk::RenderPassDesc &getRenderPassDesc() const { return mRenderPassDesc; }
diff --git a/src/libANGLE/renderer/vulkan/RenderbufferVk.cpp b/src/libANGLE/renderer/vulkan/RenderbufferVk.cpp
index e80b6c9..fd41f51 100644
--- a/src/libANGLE/renderer/vulkan/RenderbufferVk.cpp
+++ b/src/libANGLE/renderer/vulkan/RenderbufferVk.cpp
@@ -88,13 +88,15 @@
const bool isRenderToTexture =
mode == gl::MultisamplingMode::MultisampledRenderToTexture &&
(!isDepthStencilFormat || renderer->getFeatures().supportsDepthStencilResolve.enabled);
+ const bool hasRenderToTextureEXT =
+ renderer->getFeatures().supportsMultisampledRenderToSingleSampled.enabled;
const VkImageUsageFlags usage =
VK_IMAGE_USAGE_TRANSFER_DST_BIT | VK_IMAGE_USAGE_TRANSFER_SRC_BIT |
VK_IMAGE_USAGE_SAMPLED_BIT |
(isDepthStencilFormat ? VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT
: VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT) |
- (isRenderToTexture ? VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT : 0);
+ (isRenderToTexture && !hasRenderToTextureEXT ? VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT : 0);
const uint32_t imageSamples = isRenderToTexture ? 1 : samples;
@@ -112,7 +114,7 @@
// If multisampled render to texture, an implicit multisampled image is created which is used as
// the color or depth/stencil attachment. At the end of the render pass, this image is
// automatically resolved into |mImage| and its contents are discarded.
- if (isRenderToTexture)
+ if (isRenderToTexture && !hasRenderToTextureEXT)
{
mMultisampledImageViews.init(renderer);
diff --git a/src/libANGLE/renderer/vulkan/RendererVk.cpp b/src/libANGLE/renderer/vulkan/RendererVk.cpp
index 88fb253..e83f6f2 100644
--- a/src/libANGLE/renderer/vulkan/RendererVk.cpp
+++ b/src/libANGLE/renderer/vulkan/RendererVk.cpp
@@ -991,6 +991,10 @@
mDepthStencilResolveProperties.sType =
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES;
+ mMultisampledRenderToSingleSampledFeatures = {};
+ mMultisampledRenderToSingleSampledFeatures.sType =
+ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_FEATURES_EXT;
+
mDriverProperties = {};
mDriverProperties.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES;
@@ -1077,6 +1081,13 @@
vk::AddToPNextChain(&deviceProperties, &mDepthStencilResolveProperties);
}
+ // Query multisampled render to single-sampled properties
+ if (ExtensionFound(VK_EXT_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_EXTENSION_NAME,
+ deviceExtensionNames))
+ {
+ vk::AddToPNextChain(&deviceFeatures, &mMultisampledRenderToSingleSampledFeatures);
+ }
+
// Query driver properties
if (ExtensionFound(VK_KHR_DRIVER_PROPERTIES_EXTENSION_NAME, deviceExtensionNames))
{
@@ -1112,19 +1123,20 @@
}
// Clean up pNext chains
- mLineRasterizationFeatures.pNext = nullptr;
- mMemoryReportFeatures.pNext = nullptr;
- mProvokingVertexFeatures.pNext = nullptr;
- mVertexAttributeDivisorFeatures.pNext = nullptr;
- mVertexAttributeDivisorProperties.pNext = nullptr;
- mTransformFeedbackFeatures.pNext = nullptr;
- mIndexTypeUint8Features.pNext = nullptr;
- mSubgroupProperties.pNext = nullptr;
- mExternalMemoryHostProperties.pNext = nullptr;
- mShaderFloat16Int8Features.pNext = nullptr;
- mDepthStencilResolveProperties.pNext = nullptr;
- mDriverProperties.pNext = nullptr;
- mSamplerYcbcrConversionFeatures.pNext = nullptr;
+ mLineRasterizationFeatures.pNext = nullptr;
+ mMemoryReportFeatures.pNext = nullptr;
+ mProvokingVertexFeatures.pNext = nullptr;
+ mVertexAttributeDivisorFeatures.pNext = nullptr;
+ mVertexAttributeDivisorProperties.pNext = nullptr;
+ mTransformFeedbackFeatures.pNext = nullptr;
+ mIndexTypeUint8Features.pNext = nullptr;
+ mSubgroupProperties.pNext = nullptr;
+ mExternalMemoryHostProperties.pNext = nullptr;
+ mShaderFloat16Int8Features.pNext = nullptr;
+ mDepthStencilResolveProperties.pNext = nullptr;
+ mMultisampledRenderToSingleSampledFeatures.pNext = nullptr;
+ mDriverProperties.pNext = nullptr;
+ mSamplerYcbcrConversionFeatures.pNext = nullptr;
}
angle::Result RendererVk::initializeDevice(DisplayVk *displayVk, uint32_t queueFamilyIndex)
@@ -1469,6 +1481,13 @@
enabledDeviceExtensions.push_back(VK_KHR_DEPTH_STENCIL_RESOLVE_EXTENSION_NAME);
}
+ if (getFeatures().supportsMultisampledRenderToSingleSampled.enabled)
+ {
+ enabledDeviceExtensions.push_back(
+ VK_EXT_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_EXTENSION_NAME);
+ vk::AddToPNextChain(&createInfo, &mMultisampledRenderToSingleSampledFeatures);
+ }
+
if (mMemoryReportFeatures.deviceMemoryReport &&
(getFeatures().logMemoryReportCallbacks.enabled ||
getFeatures().logMemoryReportStats.enabled))
@@ -2034,7 +2053,13 @@
ANGLE_FEATURE_CONDITION(&mFeatures, supportsDepthStencilResolve,
mFeatures.supportsRenderpass2.enabled &&
- mDepthStencilResolveProperties.independentResolveNone == VK_TRUE);
+ mDepthStencilResolveProperties.supportedDepthResolveModes != 0);
+
+ ANGLE_FEATURE_CONDITION(
+ &mFeatures, supportsMultisampledRenderToSingleSampled,
+ mFeatures.supportsRenderpass2.enabled && mFeatures.supportsDepthStencilResolve.enabled &&
+ mMultisampledRenderToSingleSampledFeatures.multisampledRenderToSingleSampled ==
+ VK_TRUE);
ANGLE_FEATURE_CONDITION(&mFeatures, emulateTransformFeedback,
(!mFeatures.supportsTransformFeedbackExtension.enabled &&
@@ -2130,8 +2155,10 @@
// - Swiftshader on mac: http://anglebug.com/4937
// - Intel on windows: http://anglebug.com/5032
// - AMD on windows: http://crbug.com/1132366
- ANGLE_FEATURE_CONDITION(&mFeatures, enableMultisampledRenderToTexture,
- !(IsApple() && isSwiftShader) && !(IsWindows() && (isIntel || isAMD)));
+ ANGLE_FEATURE_CONDITION(
+ &mFeatures, enableMultisampledRenderToTexture,
+ mFeatures.supportsMultisampledRenderToSingleSampled.enabled ||
+ !(IsApple() && isSwiftShader) && !(IsWindows() && (isIntel || isAMD)));
// Feature disabled due to driver bugs:
//
diff --git a/src/libANGLE/renderer/vulkan/RendererVk.h b/src/libANGLE/renderer/vulkan/RendererVk.h
index f6e6564..b5e7149 100644
--- a/src/libANGLE/renderer/vulkan/RendererVk.h
+++ b/src/libANGLE/renderer/vulkan/RendererVk.h
@@ -419,6 +419,8 @@
VkPhysicalDeviceExternalMemoryHostPropertiesEXT mExternalMemoryHostProperties;
VkPhysicalDeviceShaderFloat16Int8FeaturesKHR mShaderFloat16Int8Features;
VkPhysicalDeviceDepthStencilResolvePropertiesKHR mDepthStencilResolveProperties;
+ VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT
+ mMultisampledRenderToSingleSampledFeatures;
VkPhysicalDeviceDriverPropertiesKHR mDriverProperties;
VkExternalFenceProperties mExternalFenceProperties;
VkExternalSemaphoreProperties mExternalSemaphoreProperties;
diff --git a/src/libANGLE/renderer/vulkan/TextureVk.cpp b/src/libANGLE/renderer/vulkan/TextureVk.cpp
index f995fbd..2b9d2a4 100644
--- a/src/libANGLE/renderer/vulkan/TextureVk.cpp
+++ b/src/libANGLE/renderer/vulkan/TextureVk.cpp
@@ -2117,13 +2117,18 @@
levelCount));
}
+ const bool hasRenderToTextureEXT =
+ contextVk->getFeatures().supportsMultisampledRenderToSingleSampled.enabled;
+
// If samples > 1 here, we have a singlesampled texture that's being multisampled rendered to.
// In this case, create a multisampled image that is otherwise identical to the single sampled
// image. That multisampled image is used as color or depth/stencil attachment, while the
// original image is used as the resolve attachment.
const gl::RenderToTextureImageIndex renderToTextureIndex =
- static_cast<gl::RenderToTextureImageIndex>(PackSampleCount(samples));
- if (samples > 1 && !mMultisampledImages[renderToTextureIndex].valid())
+ hasRenderToTextureEXT
+ ? gl::RenderToTextureImageIndex::Default
+ : static_cast<gl::RenderToTextureImageIndex>(PackSampleCount(samples));
+ if (samples > 1 && !mMultisampledImages[renderToTextureIndex].valid() && !hasRenderToTextureEXT)
{
ASSERT(mState.getBaseLevelDesc().samples <= 1);
vk::ImageHelper *multisampledImage = &mMultisampledImages[renderToTextureIndex];
diff --git a/src/libANGLE/renderer/vulkan/vk_cache_utils.cpp b/src/libANGLE/renderer/vulkan/vk_cache_utils.cpp
index 24c2f24..2f6e379 100644
--- a/src/libANGLE/renderer/vulkan/vk_cache_utils.cpp
+++ b/src/libANGLE/renderer/vulkan/vk_cache_utils.cpp
@@ -651,6 +651,8 @@
const VkSubpassDescriptionDepthStencilResolve &depthStencilResolve,
bool unresolveDepth,
bool unresolveStencil,
+ bool isRenderToTexture,
+ uint8_t renderToTextureSamples,
RenderPass *renderPass)
{
// Convert the attachments to VkAttachmentDescription2.
@@ -735,9 +737,25 @@
&subpassDescriptions[subpass]);
}
- // Append the depth/stencil resolve attachment to the pNext chain of last subpass.
- ASSERT(depthStencilResolve.pDepthStencilResolveAttachment != nullptr);
- subpassDescriptions.back().pNext = &depthStencilResolve;
+ VkMultisampledRenderToSingleSampledInfoEXT renderToTextureInfo = {};
+ renderToTextureInfo.sType = VK_STRUCTURE_TYPE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_INFO_EXT;
+ renderToTextureInfo.multisampledRenderToSingleSampledEnable = true;
+ renderToTextureInfo.rasterizationSamples = gl_vk::GetSamples(renderToTextureSamples);
+ renderToTextureInfo.depthResolveMode = VK_RESOLVE_MODE_SAMPLE_ZERO_BIT;
+ renderToTextureInfo.stencilResolveMode = VK_RESOLVE_MODE_SAMPLE_ZERO_BIT;
+
+ // Append the depth/stencil resolve attachment to the pNext chain of last subpass, if any.
+ if (depthStencilResolve.pDepthStencilResolveAttachment != nullptr)
+ {
+ ASSERT(!isRenderToTexture);
+ subpassDescriptions.back().pNext = &depthStencilResolve;
+ }
+ else
+ {
+ ASSERT(isRenderToTexture);
+ ASSERT(subpassDescriptions.size() == 1);
+ subpassDescriptions.back().pNext = &renderToTextureInfo;
+ }
// Convert subpass dependencies to VkSubpassDependency2.
std::vector<VkSubpassDependency2KHR> subpassDependencies(createInfo.dependencyCount);
@@ -909,7 +927,12 @@
VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_2_KHR, nullptr, VK_ATTACHMENT_UNUSED,
VK_IMAGE_LAYOUT_UNDEFINED, 0};
- bool needInputAttachments = desc.getFramebufferFetchMode();
+ const bool needInputAttachments = desc.getFramebufferFetchMode();
+ const bool isRenderToTexture = desc.isRenderToTexture();
+
+ const uint8_t descSamples = desc.samples();
+ const uint8_t attachmentSamples = isRenderToTexture ? 1 : descSamples;
+ const uint8_t renderToTextureSamples = isRenderToTexture ? descSamples : 1;
// Unpack the packed and split representation into the format required by Vulkan.
gl::DrawBuffersVector<VkAttachmentReference> colorAttachmentRefs;
@@ -961,7 +984,7 @@
static_cast<ImageLayout>(ops[attachmentCount].initialLayout));
colorAttachmentRefs.push_back(colorRef);
- UnpackAttachmentDesc(&attachmentDescs[attachmentCount.get()], format, desc.samples(),
+ UnpackAttachmentDesc(&attachmentDescs[attachmentCount.get()], format, attachmentSamples,
ops[attachmentCount]);
angle::FormatID attachmentFormat = format.actualImageFormatID;
@@ -999,7 +1022,7 @@
depthStencilAttachmentRef.layout = ConvertImageLayoutToVkImageLayout(
static_cast<ImageLayout>(ops[attachmentCount].initialLayout));
- UnpackAttachmentDesc(&attachmentDescs[attachmentCount.get()], format, desc.samples(),
+ UnpackAttachmentDesc(&attachmentDescs[attachmentCount.get()], format, attachmentSamples,
ops[attachmentCount]);
isDepthInvalidated = ops[attachmentCount].isInvalidated;
@@ -1131,12 +1154,8 @@
if (desc.hasDepthStencilResolveAttachment())
{
depthStencilResolve.sType = VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE;
- depthStencilResolve.depthResolveMode = desc.hasDepthResolveAttachment()
- ? VK_RESOLVE_MODE_SAMPLE_ZERO_BIT
- : VK_RESOLVE_MODE_NONE;
- depthStencilResolve.stencilResolveMode = desc.hasStencilResolveAttachment()
- ? VK_RESOLVE_MODE_SAMPLE_ZERO_BIT
- : VK_RESOLVE_MODE_NONE;
+ depthStencilResolve.depthResolveMode = VK_RESOLVE_MODE_SAMPLE_ZERO_BIT;
+ depthStencilResolve.stencilResolveMode = VK_RESOLVE_MODE_SAMPLE_ZERO_BIT;
// If depth/stencil attachment is invalidated, try to remove its resolve attachment
// altogether.
@@ -1178,13 +1197,18 @@
createInfo.pDependencies = subpassDependencies.data();
}
+ const bool hasRenderToTextureEXT =
+ renderer->getFeatures().supportsMultisampledRenderToSingleSampled.enabled;
+
// If depth/stencil resolve is used, we need to create the render pass with
- // vkCreateRenderPass2KHR.
- if (depthStencilResolve.pDepthStencilResolveAttachment != nullptr)
+ // vkCreateRenderPass2KHR. Same when using the VK_EXT_multisampled_render_to_single_sampled
+ // extension.
+ if (depthStencilResolve.pDepthStencilResolveAttachment != nullptr || hasRenderToTextureEXT)
{
- ANGLE_TRY(CreateRenderPass2(
- contextVk, createInfo, depthStencilResolve, desc.hasDepthUnresolveAttachment(),
- desc.hasStencilUnresolveAttachment(), &renderPassHelper->getRenderPass()));
+ ANGLE_TRY(CreateRenderPass2(contextVk, createInfo, depthStencilResolve,
+ desc.hasDepthUnresolveAttachment(),
+ desc.hasStencilUnresolveAttachment(), desc.isRenderToTexture(),
+ renderToTextureSamples, &renderPassHelper->getRenderPass()));
}
else
{
@@ -1357,6 +1381,18 @@
SetBitField(mHasFramebufferFetch, hasFramebufferFetch);
}
+void RenderPassDesc::updateRenderToTexture(bool isRenderToTexture)
+{
+ if (isRenderToTexture)
+ {
+ mAttachmentFormats.back() |= kIsRenderToTexture;
+ }
+ else
+ {
+ mAttachmentFormats.back() &= ~kIsRenderToTexture;
+ }
+}
+
void RenderPassDesc::packColorAttachment(size_t colorIndexGL, angle::FormatID formatID)
{
ASSERT(colorIndexGL < mAttachmentFormats.size());
@@ -1429,22 +1465,15 @@
mColorUnresolveAttachmentMask.reset(colorIndexGL);
}
-void RenderPassDesc::packDepthStencilResolveAttachment(bool resolveDepth, bool resolveStencil)
+void RenderPassDesc::packDepthStencilResolveAttachment()
{
ASSERT(hasDepthStencilAttachment());
ASSERT(!hasDepthStencilResolveAttachment());
- static_assert((kDepthStencilFormatStorageMask & (kResolveDepthFlag | kResolveStencilFlag)) == 0,
+ static_assert((kDepthStencilFormatStorageMask & kResolveDepthStencilFlag) == 0,
"Collision in depth/stencil format and flag bits");
- if (resolveDepth)
- {
- mAttachmentFormats.back() |= kResolveDepthFlag;
- }
- if (resolveStencil)
- {
- mAttachmentFormats.back() |= kResolveStencilFlag;
- }
+ mAttachmentFormats.back() |= kResolveDepthStencilFlag;
}
void RenderPassDesc::packDepthStencilUnresolveAttachment(bool unresolveDepth, bool unresolveStencil)
@@ -3030,7 +3059,7 @@
void FramebufferDesc::updateUnresolveMask(FramebufferNonResolveAttachmentMask unresolveMask)
{
- mUnresolveAttachmentMask = unresolveMask;
+ SetBitField(mUnresolveAttachmentMask, unresolveMask.bits());
}
void FramebufferDesc::updateDepthStencil(ImageOrBufferViewSubresourceSerial serial)
@@ -3046,16 +3075,18 @@
size_t FramebufferDesc::hash() const
{
return angle::ComputeGenericHash(&mSerials, sizeof(mSerials[0]) * mMaxIndex) ^
- mHasFramebufferFetch << 25 ^ mLayerCount << 16 ^ mUnresolveAttachmentMask.bits();
+ mHasFramebufferFetch << 26 ^ mIsRenderToTexture << 25 ^ mLayerCount << 16 ^
+ mUnresolveAttachmentMask;
}
void FramebufferDesc::reset()
{
- mMaxIndex = 0;
- mHasFramebufferFetch = false;
- mLayerCount = 0;
- mUnresolveAttachmentMask.reset();
- mSrgbWriteControlMode = 0;
+ mMaxIndex = 0;
+ mHasFramebufferFetch = false;
+ mLayerCount = 0;
+ mSrgbWriteControlMode = 0;
+ mUnresolveAttachmentMask = 0;
+ mIsRenderToTexture = 0;
memset(&mSerials, 0, sizeof(mSerials));
}
@@ -3064,7 +3095,8 @@
if (mMaxIndex != other.mMaxIndex || mLayerCount != other.mLayerCount ||
mUnresolveAttachmentMask != other.mUnresolveAttachmentMask ||
mHasFramebufferFetch != other.mHasFramebufferFetch ||
- mSrgbWriteControlMode != other.mSrgbWriteControlMode)
+ mSrgbWriteControlMode != other.mSrgbWriteControlMode ||
+ mIsRenderToTexture != other.mIsRenderToTexture)
{
return false;
}
@@ -3088,7 +3120,7 @@
FramebufferNonResolveAttachmentMask FramebufferDesc::getUnresolveAttachmentMask() const
{
- return mUnresolveAttachmentMask;
+ return FramebufferNonResolveAttachmentMask(mUnresolveAttachmentMask);
}
void FramebufferDesc::updateLayerCount(uint32_t layerCount)
@@ -3101,6 +3133,11 @@
SetBitField(mHasFramebufferFetch, hasFramebufferFetch);
}
+void FramebufferDesc::updateRenderToTexture(bool isRenderToTexture)
+{
+ SetBitField(mIsRenderToTexture, isRenderToTexture);
+}
+
// SamplerDesc implementation.
SamplerDesc::SamplerDesc()
{
diff --git a/src/libANGLE/renderer/vulkan/vk_cache_utils.h b/src/libANGLE/renderer/vulkan/vk_cache_utils.h
index 1936d7e..f6455c3 100644
--- a/src/libANGLE/renderer/vulkan/vk_cache_utils.h
+++ b/src/libANGLE/renderer/vulkan/vk_cache_utils.h
@@ -157,7 +157,7 @@
void packColorUnresolveAttachment(size_t colorIndexGL);
void removeColorUnresolveAttachment(size_t colorIndexGL);
// Indicate that a depth/stencil attachment should have a corresponding resolve attachment.
- void packDepthStencilResolveAttachment(bool resolveDepth, bool resolveStencil);
+ void packDepthStencilResolveAttachment();
// Indicate that a depth/stencil attachment should take its data from the resolve attachment
// initially.
void packDepthStencilUnresolveAttachment(bool unresolveDepth, bool unresolveStencil);
@@ -187,15 +187,7 @@
}
bool hasDepthStencilResolveAttachment() const
{
- return (mAttachmentFormats.back() & (kResolveDepthFlag | kResolveStencilFlag)) != 0;
- }
- bool hasDepthResolveAttachment() const
- {
- return (mAttachmentFormats.back() & kResolveDepthFlag) != 0;
- }
- bool hasStencilResolveAttachment() const
- {
- return (mAttachmentFormats.back() & kResolveStencilFlag) != 0;
+ return (mAttachmentFormats.back() & kResolveDepthStencilFlag) != 0;
}
bool hasDepthStencilUnresolveAttachment() const
{
@@ -227,6 +219,9 @@
void setFramebufferFetchMode(bool hasFramebufferFetch);
bool getFramebufferFetchMode() const { return mHasFramebufferFetch; }
+ void updateRenderToTexture(bool isRenderToTexture);
+ bool isRenderToTexture() const { return (mAttachmentFormats.back() & kIsRenderToTexture) != 0; }
+
angle::FormatID operator[](size_t index) const
{
ASSERT(index < gl::IMPLEMENTATION_MAX_DRAW_BUFFERS + 1);
@@ -248,17 +243,14 @@
// Whether each color attachment has a corresponding resolve attachment. Color resolve
// attachments can be used to optimize resolve through glBlitFramebuffer() as well as support
// GL_EXT_multisampled_render_to_texture and GL_EXT_multisampled_render_to_texture2.
- //
- // Note that depth/stencil resolve attachments require VK_KHR_depth_stencil_resolve which is
- // currently not well supported, so ANGLE always takes a fallback path for them. When a resolve
- // path is implemented for depth/stencil attachments, another bit must be made free
- // (mAttachmentFormats is one element too large, so there are 8 bits there to take).
gl::DrawBufferMask mColorResolveAttachmentMask;
// Whether each color attachment with a corresponding resolve attachment should be initialized
// with said resolve attachment in an initial subpass. This is an optimization to avoid
// loadOp=LOAD on the implicit multisampled image used with multisampled-render-to-texture
// render targets. This operation is referred to as "unresolve".
+ //
+ // Unused when VK_EXT_multisampled_render_to_single_sampled is available.
gl::DrawBufferMask mColorUnresolveAttachmentMask;
// Color attachment formats are stored with their GL attachment indices. The depth/stencil
@@ -293,11 +285,11 @@
static constexpr uint8_t kDepthStencilFormatStorageMask = 0x7;
// Flags stored in the upper 5 bits of mAttachmentFormats.back().
- static constexpr uint8_t kResolveDepthFlag = 0x80;
- static constexpr uint8_t kResolveStencilFlag = 0x40;
- static constexpr uint8_t kUnresolveDepthFlag = 0x20;
- static constexpr uint8_t kUnresolveStencilFlag = 0x10;
- static constexpr uint8_t kSrgbWriteControlFlag = 0x08;
+ static constexpr uint8_t kIsRenderToTexture = 0x80;
+ static constexpr uint8_t kResolveDepthStencilFlag = 0x40;
+ static constexpr uint8_t kUnresolveDepthFlag = 0x20;
+ static constexpr uint8_t kUnresolveStencilFlag = 0x10;
+ static constexpr uint8_t kSrgbWriteControlFlag = 0x08;
};
bool operator==(const RenderPassDesc &lhs, const RenderPassDesc &rhs);
@@ -1195,6 +1187,8 @@
uint32_t getLayerCount() const { return mLayerCount; }
void updateFramebufferFetchMode(bool hasFramebufferFetch);
+ void updateRenderToTexture(bool isRenderToTexture);
+
private:
void reset();
void update(uint32_t index, ImageOrBufferViewSubresourceSerial serial);
@@ -1213,7 +1207,11 @@
// If the render pass contains an initial subpass to unresolve a number of attachments, the
// subpass description is derived from the following mask, specifying which attachments need
// to be unresolved. Includes both color and depth/stencil attachments.
- FramebufferNonResolveAttachmentMask mUnresolveAttachmentMask;
+ uint16_t mUnresolveAttachmentMask : kMaxFramebufferNonResolveAttachments;
+
+ // Whether this is a multisampled-render-to-single-sampled framebuffer. Only used when using
+ // VK_EXT_multisampled_render_to_single_sampled. Only one bit is used and the rest is padding.
+ uint16_t mIsRenderToTexture : 16 - kMaxFramebufferNonResolveAttachments;
FramebufferAttachmentArray<ImageOrBufferViewSubresourceSerial> mSerials;
};
