Skip to content

A
angle
Commit 4f3b207d by Shahbaz Youssefi Committed by Commit Bot
Options

Vulkan: Shader path for texture-to-texture copy

This change implements glCopy[Sub]TextureCHROMIUM in GPU. As with the previous change implementing glCopyTex[Sub]Image2D, it currently only selects the shader path if the texture is already defined. Bug: angleproject:2958 Change-Id: Ia1b5625f92e6c9f91807c9b601e5c34d2d5e5c30 Reviewed-on: https://chromium-review.googlesource.com/c/1392394 Commit-Queue: Shahbaz Youssefi <syoussefi@chromium.org> Reviewed-by: 's avatarYuly Novikov <ynovikov@chromium.org>
parent 29b49417
Showing with 277 additions and 235 deletions
include/platform/FeaturesVk.h
......@@ -57,6 +57,11 @@ struct FeaturesVk
// Whether the VkDevice supports the VK_KHR_incremental_present extension, on which the
// EGL_KHR_swap_buffers_with_damage extension can be layered.
bool supportsIncrementalPresent = false;
// Whether texture copies on cube map targets should be done on GPU. This is a workaround for
// Intel drivers on windows that have an issue with creating single-layer views on cube map
// textures.
bool forceCpuPathForCubeMapCopy = false;
};
} // namespace angle
......
scripts/run_code_generation_hashes.json
......@@ -102,7 +102,7 @@
"Vulkan internal shader programs:src/libANGLE/renderer/vulkan/shaders/src/ImageClear.frag":
"98d490413d20118e92dd2b160c1dfc6e",
"Vulkan internal shader programs:src/libANGLE/renderer/vulkan/shaders/src/ImageCopy.frag":
"096ccb0e3c25067ddd0347556a12d7d6",
"9b9fd690321f53163221f1ebba9f006d",
"Vulkan mandatory format support table:src/libANGLE/renderer/angle_format.py":
"b18ca0fe4835114a4a2f54977b19e798",
"Vulkan mandatory format support table:src/libANGLE/renderer/vulkan/gen_vk_mandatory_format_support_table.py":
......
src/libANGLE/renderer/vulkan/RendererVk.cpp
......@@ -825,6 +825,9 @@ void RendererVk::initFeatures(const std::vector<VkExtensionProperties> &deviceEx
#ifdef ANGLE_PLATFORM_WINDOWS
// http://anglebug.com/2838
mFeatures.extraCopyBufferRegion = IsIntel(mPhysicalDeviceProperties.vendorID);
// http://anglebug.com/3055
mFeatures.forceCpuPathForCubeMapCopy = IsIntel(mPhysicalDeviceProperties.vendorID);
#endif
angle::PlatformMethods *platform = ANGLEPlatformCurrent();
......
src/libANGLE/renderer/vulkan/TextureVk.cpp
......@@ -27,6 +27,16 @@ constexpr size_t kStagingBufferSize = 1024 * 16;
constexpr VkFormatFeatureFlags kBlitFeatureFlags =
VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT;
bool CanCopyWithDraw(RendererVk *renderer,
const vk::Format &srcFormat,
const vk::Format &destFormat)
{
return renderer->hasTextureFormatFeatureBits(srcFormat.vkTextureFormat,
VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT) &&
renderer->hasTextureFormatFeatureBits(destFormat.vkTextureFormat,
VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT);
}
} // anonymous namespace
// StagingStorage implementation.
......@@ -575,21 +585,25 @@ angle::Result TextureVk::copySubImageImpl(const gl::Context *context,
const vk::Format &destFormat = renderer->getFormat(internalFormat.sizedInternalFormat);
// TODO(syoussefi): Support draw path for when !mImage.valid(). http://anglebug.com/2958
bool canDraw = mImage.valid() &&
renderer->hasTextureFormatFeatureBits(srcFormat.vkTextureFormat,
VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT) &&
renderer->hasTextureFormatFeatureBits(destFormat.vkTextureFormat,
VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT);
bool canDraw = mImage.valid() && CanCopyWithDraw(renderer, srcFormat, destFormat);
bool forceCpuPath =
mImage.getLayerCount() > 1 && renderer->getFeatures().forceCpuPathForCubeMapCopy;
// If it's possible to perform the copy with a draw call, do that.
if (canDraw)
if (canDraw && !forceCpuPath)
{
ANGLE_TRY(ensureImageInitialized(contextVk));
RenderTargetVk *colorReadRT = framebufferVk->getColorReadRenderTarget();
bool isViewportFlipY = contextVk->isViewportFlipEnabledForDrawFBO();
// Layer count can only be 1 as the source is a framebuffer.
ASSERT(index.getLayerCount() == 1);
return copySubImageImplWithDraw(contextVk, index, modifiedDestOffset,
gl::Offset(clippedSourceArea.x, clippedSourceArea.y, 0),
gl::Extents(destArea.width, destArea.height, 1),
framebufferVk);
ANGLE_TRY(copySubImageImplWithDraw(
contextVk, index, modifiedDestOffset, 0, clippedSourceArea, isViewportFlipY, false,
false, false, &colorReadRT->getImage(), colorReadRT->getReadImageView()));
framebufferVk->getFramebuffer()->addReadDependency(&mImage);
return angle::Result::Continue;
}
// Do a CPU readback that does the conversion, and then stage the change to the pixel buffer.
......@@ -603,51 +617,6 @@ angle::Result TextureVk::copySubImageImpl(const gl::Context *context,
return angle::Result::Continue;
}
angle::Result TextureVk::copySubImageImplWithDraw(ContextVk *contextVk,
const gl::ImageIndex &index,
const gl::Offset &destOffset,
const gl::Offset &srcOffset,
const gl::Extents &extents,
FramebufferVk *source)
{
UtilsVk::CopyImageParameters params;
params.srcOffset[0] = srcOffset.x;
params.srcOffset[1] = srcOffset.y;
params.srcExtents[0] = extents.width;
params.srcExtents[1] = extents.height;
params.destOffset[0] = destOffset.x;
params.destOffset[1] = destOffset.y;
params.srcMip = 0;
params.srcHeight = source->getReadImageExtents().height;
params.flipY = contextVk->isViewportFlipEnabledForDrawFBO();
uint32_t level = index.getLevelIndex();
uint32_t baseLayer = index.hasLayer() ? index.getLayerIndex() : 0;
uint32_t layerCount = index.getLayerCount();
// TODO(syoussefi): currently this is only called from copy[Sub]Image,
// where layer count can only be 1, and source's level and layer are both 0.
// Once this code is expanded to cover copy[Sub]Texture, it should be
// adapted to get single-layer/level image views of the source as well.
// http://anglebug.com/2958
ASSERT(layerCount == 1);
vk::ImageHelper *srcImage = &source->getColorReadRenderTarget()->getImage();
vk::ImageView *srcView = source->getColorReadRenderTarget()->getReadImageView();
for (uint32_t i = 0; i < layerCount; ++i)
{
vk::ImageView *destView;
ANGLE_TRY(getLayerLevelDrawImageView(contextVk, baseLayer + i, level, &destView));
ANGLE_TRY(contextVk->getRenderer()->getUtils().copyImage(contextVk, &mImage, destView,
srcImage, srcView, params));
}
source->getFramebuffer()->addReadDependency(&mImage);
return angle::Result::Continue;
}
angle::Result TextureVk::copySubTextureImpl(ContextVk *contextVk,
const gl::ImageIndex &index,
const gl::Offset &destOffset,
......@@ -661,6 +630,28 @@ angle::Result TextureVk::copySubTextureImpl(ContextVk *contextVk,
{
RendererVk *renderer = contextVk->getRenderer();
ANGLE_TRY(source->ensureImageInitialized(contextVk));
const vk::Format &sourceVkFormat = source->getImage().getFormat();
const vk::Format &destVkFormat = renderer->getFormat(destFormat.sizedInternalFormat);
// TODO(syoussefi): Support draw path for when !mImage.valid(). http://anglebug.com/2958
bool canDraw = mImage.valid() && CanCopyWithDraw(renderer, sourceVkFormat, destVkFormat);
bool forceCpuPath =
mImage.getLayerCount() > 1 && renderer->getFeatures().forceCpuPathForCubeMapCopy;
// If it's possible to perform the copy with a draw call, do that.
if (canDraw && !forceCpuPath)
{
ANGLE_TRY(copySubImageImplWithDraw(contextVk, index, destOffset, sourceLevel, sourceArea,
false, unpackFlipY, unpackPremultiplyAlpha,
unpackUnmultiplyAlpha, &source->getImage(),
&source->getReadImageView()));
source->getImage().addReadDependency(&mImage);
return angle::Result::Continue;
}
if (sourceLevel != 0)
{
WARN() << "glCopyTextureCHROMIUM with sourceLevel != 0 not implemented.";
......@@ -671,9 +662,6 @@ angle::Result TextureVk::copySubTextureImpl(ContextVk *contextVk,
uint8_t *sourceData = nullptr;
ANGLE_TRY(source->copyImageDataToBuffer(contextVk, sourceLevel, 1, sourceArea, &sourceData));
const vk::Format &sourceVkFormat = source->getImage().getFormat();
const vk::Format &destVkFormat = renderer->getFormat(destFormat.sizedInternalFormat);
const angle::Format &sourceTextureFormat = sourceVkFormat.textureFormat();
const angle::Format &destTextureFormat = destVkFormat.textureFormat();
size_t destinationAllocationSize =
......@@ -716,6 +704,53 @@ angle::Result TextureVk::copySubTextureImpl(ContextVk *contextVk,
return angle::Result::Continue;
}
angle::Result TextureVk::copySubImageImplWithDraw(ContextVk *contextVk,
const gl::ImageIndex &index,
const gl::Offset &destOffset,
size_t sourceLevel,
const gl::Rectangle &sourceArea,
bool isSrcFlipY,
bool unpackFlipY,
bool unpackPremultiplyAlpha,
bool unpackUnmultiplyAlpha,
vk::ImageHelper *srcImage,
const vk::ImageView *srcView)
{
ANGLE_TRY(ensureImageInitialized(contextVk));
UtilsVk &utilsVk = contextVk->getRenderer()->getUtils();
UtilsVk::CopyImageParameters params;
params.srcOffset[0] = sourceArea.x;
params.srcOffset[1] = sourceArea.y;
params.srcExtents[0] = sourceArea.width;
params.srcExtents[1] = sourceArea.height;
params.destOffset[0] = destOffset.x;
params.destOffset[1] = destOffset.y;
params.srcMip = sourceLevel;
params.srcHeight = srcImage->getExtents().height;
params.srcPremultiplyAlpha = unpackPremultiplyAlpha && !unpackUnmultiplyAlpha;
params.srcUnmultiplyAlpha = unpackUnmultiplyAlpha && !unpackPremultiplyAlpha;
params.srcFlipY = isSrcFlipY;
params.destFlipY = unpackFlipY;
uint32_t level = index.getLevelIndex();
uint32_t baseLayer = index.hasLayer() ? index.getLayerIndex() : 0;
uint32_t layerCount = index.getLayerCount();
for (uint32_t layerIndex = 0; layerIndex < layerCount; ++layerIndex)
{
params.srcLayer = layerIndex;
vk::ImageView *destView;
ANGLE_TRY(getLayerLevelDrawImageView(contextVk, baseLayer + layerIndex, level, &destView));
ANGLE_TRY(utilsVk.copyImage(contextVk, &mImage, destView, srcImage, srcView, params));
}
return angle::Result::Continue;
}
angle::Result TextureVk::setStorage(const gl::Context *context,
gl::TextureType type,
size_t levels,
......
src/libANGLE/renderer/vulkan/TextureVk.h
......@@ -244,13 +244,6 @@ class TextureVk : public TextureImpl
const gl::InternalFormat &internalFormat,
gl::Framebuffer *source);
angle::Result copySubImageImplWithDraw(ContextVk *contextVk,
const gl::ImageIndex &index,
const gl::Offset &destOffset,
const gl::Offset &srcOffset,
const gl::Extents &extents,
FramebufferVk *source);
angle::Result copySubTextureImpl(ContextVk *contextVk,
const gl::ImageIndex &index,
const gl::Offset &destOffset,
......@@ -262,6 +255,18 @@ class TextureVk : public TextureImpl
bool unpackUnmultiplyAlpha,
TextureVk *source);
angle::Result copySubImageImplWithDraw(ContextVk *contextVk,
const gl::ImageIndex &index,
const gl::Offset &destOffset,
size_t sourceLevel,
const gl::Rectangle &sourceArea,
bool isSrcFlipY,
bool unpackFlipY,
bool unpackPremultiplyAlpha,
bool unpackUnmultiplyAlpha,
vk::ImageHelper *srcImage,
const vk::ImageView *srcView);
angle::Result initImage(ContextVk *contextVk,
const vk::Format &format,
const gl::Extents &extents,
......
src/libANGLE/renderer/vulkan/UtilsVk.cpp
......@@ -133,6 +133,23 @@ uint32_t GetImageCopyFlags(const vk::Format &srcFormat, const vk::Format &destFo
return flags;
}
uint32_t GetFormatDefaultChannelMask(const vk::Format &format)
{
uint32_t mask = 0;
const angle::Format &angleFormat = format.angleFormat();
const angle::Format &textureFormat = format.textureFormat();
// Red can never be introduced due to format emulation (except for luma which is handled
// especially)
ASSERT(((angleFormat.redBits > 0) == (textureFormat.redBits > 0)) || angleFormat.isLUMA());
mask |= angleFormat.greenBits == 0 && textureFormat.greenBits > 0 ? 2 : 0;
mask |= angleFormat.blueBits == 0 && textureFormat.blueBits > 0 ? 4 : 0;
mask |= angleFormat.alphaBits == 0 && textureFormat.alphaBits > 0 ? 8 : 0;
return mask;
}
} // namespace
UtilsVk::UtilsVk() = default;
......@@ -547,7 +564,7 @@ angle::Result UtilsVk::convertVertexBuffer(vk::Context *context,
angle::Result UtilsVk::startRenderPass(vk::Context *context,
vk::ImageHelper *image,
vk::ImageView *imageView,
const vk::ImageView *imageView,
const vk::RenderPassDesc &renderPassDesc,
const gl::Rectangle &renderArea,
vk::CommandBuffer **commandBufferOut)
......@@ -633,9 +650,9 @@ angle::Result UtilsVk::clearImage(ContextVk *contextVk,
angle::Result UtilsVk::copyImage(vk::Context *context,
vk::ImageHelper *dest,
vk::ImageView *destView,
const vk::ImageView *destView,
vk::ImageHelper *src,
vk::ImageView *srcView,
const vk::ImageView *srcView,
const CopyImageParameters &params)
{
RendererVk *renderer = context->getRenderer();
......@@ -646,24 +663,36 @@ angle::Result UtilsVk::copyImage(vk::Context *context,
const vk::Format &destFormat = dest->getFormat();
ImageCopyShaderParams shaderParams;
shaderParams.flipY = params.flipY;
shaderParams.flipY = params.srcFlipY || params.destFlipY;
shaderParams.premultiplyAlpha = params.srcPremultiplyAlpha;
shaderParams.unmultiplyAlpha = params.srcUnmultiplyAlpha;
shaderParams.destHasLuminance = destFormat.angleFormat().luminanceBits > 0;
shaderParams.destIsAlpha =
destFormat.angleFormat().isLUMA() && destFormat.angleFormat().alphaBits > 0;
shaderParams.srcMip = params.srcMip;
shaderParams.srcOffset[0] = params.srcOffset[0];
shaderParams.srcOffset[1] = params.srcOffset[1];
shaderParams.destOffset[0] = params.destOffset[0];
shaderParams.destOffset[1] = params.destOffset[1];
if (params.flipY)
shaderParams.destDefaultChannelsMask = GetFormatDefaultChannelMask(destFormat);
shaderParams.srcMip = params.srcMip;
shaderParams.srcLayer = params.srcLayer;
shaderParams.srcOffset[0] = params.srcOffset[0];
shaderParams.srcOffset[1] = params.srcOffset[1];
shaderParams.destOffset[0] = params.destOffset[0];
shaderParams.destOffset[1] = params.destOffset[1];
ASSERT(!(params.srcFlipY && params.destFlipY));
if (params.srcFlipY)
{
// If viewport is flipped, the shader expects srcOffset[1] to have the
// last row's index instead of the first's.
shaderParams.srcOffset[1] = params.srcHeight - shaderParams.srcOffset[1] - 1;
shaderParams.srcOffset[1] = params.srcHeight - params.srcOffset[1] - 1;
}
else if (params.destFlipY)
{
// If image is flipped during copy, the shader uses the same code path as above,
// with srcOffset being set to the last row's index instead of the first's.
shaderParams.srcOffset[1] = params.srcOffset[1] + params.srcExtents[1] - 1;
}
uint32_t flags = GetImageCopyFlags(srcFormat, destFormat);
flags |= src->getLayerCount() > 1 ? ImageCopy_frag::kSrcIsArray : 0;
VkDescriptorSet descriptorSet;
vk::SharedDescriptorPoolBinding descriptorPoolBinding;
......
src/libANGLE/renderer/vulkan/UtilsVk.h
......@@ -74,8 +74,12 @@ class UtilsVk : angle::NonCopyable
int srcExtents[2];
int destOffset[2];
int srcMip;
int srcLayer;
int srcHeight;
bool flipY;
bool srcPremultiplyAlpha;
bool srcUnmultiplyAlpha;
bool srcFlipY;
bool destFlipY;
};
angle::Result clearBuffer(vk::Context *context,
......@@ -99,9 +103,9 @@ class UtilsVk : angle::NonCopyable
angle::Result copyImage(vk::Context *context,
vk::ImageHelper *dest,
vk::ImageView *destView,
const vk::ImageView *destView,
vk::ImageHelper *src,
vk::ImageView *srcView,
const vk::ImageView *srcView,
const CopyImageParameters &params);
private:
......@@ -141,12 +145,16 @@ class UtilsVk : angle::NonCopyable
struct ImageCopyShaderParams
{
// Structure matching PushConstants in ImageCopy.frag
uint32_t flipY = 0;
uint32_t destHasLuminance = 0;
uint32_t destIsAlpha = 0;
int32_t srcMip = 0;
int32_t srcOffset[2] = {};
int32_t destOffset[2] = {};
int32_t srcOffset[2] = {};
int32_t destOffset[2] = {};
int32_t srcMip = 0;
int32_t srcLayer = 0;
uint32_t flipY = 0;
uint32_t premultiplyAlpha = 0;
uint32_t unmultiplyAlpha = 0;
uint32_t destHasLuminance = 0;
uint32_t destIsAlpha = 0;
uint32_t destDefaultChannelsMask = 0;
};
// Functions implemented by the class:
......@@ -203,7 +211,7 @@ class UtilsVk : angle::NonCopyable
angle::Result startRenderPass(vk::Context *context,
vk::ImageHelper *image,
vk::ImageView *imageView,
const vk::ImageView *imageView,
const vk::RenderPassDesc &renderPassDesc,
const gl::Rectangle &renderArea,
vk::CommandBuffer **commandBufferOut);
......@@ -220,7 +228,8 @@ class UtilsVk : angle::NonCopyable
mConvertVertexPrograms[vk::InternalShader::ConvertVertex_comp::kFlagsMask |
vk::InternalShader::ConvertVertex_comp::kConversionMask];
vk::ShaderProgramHelper mImageClearProgram;
vk::ShaderProgramHelper mImageCopyPrograms[vk::InternalShader::ImageCopy_frag::kSrcFormatMask |
vk::ShaderProgramHelper mImageCopyPrograms[vk::InternalShader::ImageCopy_frag::kFlagsMask |
vk::InternalShader::ImageCopy_frag::kSrcFormatMask |
vk::InternalShader::ImageCopy_frag::kDestFormatMask];
};
......
src/libANGLE/renderer/vulkan/shaders/gen/ImageCopy.frag.00000006.inc deleted 100644 → 0
// 7.11.3009
#pragma once
const uint32_t kImageCopy_frag_00000006[] = {
0x07230203,0x00010000,0x00080007,0x0000005a,0x00000000,0x00020011,0x00000001,0x0006000b,
0x00000001,0x4c534c47,0x6474732e,0x3035342e,0x00000000,0x0003000e,0x00000000,0x00000001,
0x0007000f,0x00000004,0x00000004,0x6e69616d,0x00000000,0x0000000d,0x00000058,0x00030010,
0x00000004,0x00000007,0x00030003,0x00000002,0x000001c2,0x000b0004,0x455f4c47,0x735f5458,
0x6c706d61,0x656c7265,0x745f7373,0x75747865,0x665f6572,0x74636e75,0x736e6f69,0x00000000,
0x00040005,0x00000004,0x6e69616d,0x00000000,0x00070005,0x00000009,0x74736564,0x49627553,
0x6567616d,0x726f6f43,0x00007364,0x00060005,0x0000000d,0x465f6c67,0x43676172,0x64726f6f,
0x00000000,0x00060005,0x00000013,0x68737550,0x736e6f43,0x746e6174,0x00000073,0x00050006,
0x00000013,0x00000000,0x70696c66,0x00000059,0x00080006,0x00000013,0x00000001,0x74736564,
0x4c736148,0x6e696d75,0x65636e61,0x00000000,0x00060006,0x00000013,0x00000002,0x74736564,
0x6c417349,0x00616870,0x00050006,0x00000013,0x00000003,0x4d637273,0x00007069,0x00060006,
0x00000013,0x00000004,0x4f637273,0x65736666,0x00000074,0x00060006,0x00000013,0x00000005,
0x74736564,0x7366664f,0x00007465,0x00040005,0x00000015,0x61726170,0x0000736d,0x00070005,
0x0000001b,0x53637273,0x6d496275,0x43656761,0x64726f6f,0x00000073,0x00050005,0x0000002e,
0x56637273,0x65756c61,0x00000000,0x00030005,0x00000031,0x00637273,0x00050005,0x0000003f,
0x74736564,0x756c6156,0x00000065,0x00040005,0x00000058,0x74736564,0x00000000,0x00040047,
0x0000000d,0x0000000b,0x0000000f,0x00050048,0x00000013,0x00000000,0x00000023,0x00000000,
0x00050048,0x00000013,0x00000001,0x00000023,0x00000004,0x00050048,0x00000013,0x00000002,
0x00000023,0x00000008,0x00050048,0x00000013,0x00000003,0x00000023,0x0000000c,0x00050048,
0x00000013,0x00000004,0x00000023,0x00000010,0x00050048,0x00000013,0x00000005,0x00000023,
0x00000018,0x00030047,0x00000013,0x00000002,0x00040047,0x00000031,0x00000022,0x00000000,
0x00040047,0x00000031,0x00000021,0x00000000,0x00040047,0x00000058,0x0000001e,0x00000000,
0x00020013,0x00000002,0x00030021,0x00000003,0x00000002,0x00040015,0x00000006,0x00000020,
0x00000001,0x00040017,0x00000007,0x00000006,0x00000002,0x00040020,0x00000008,0x00000007,
0x00000007,0x00030016,0x0000000a,0x00000020,0x00040017,0x0000000b,0x0000000a,0x00000004,
0x00040020,0x0000000c,0x00000001,0x0000000b,0x0004003b,0x0000000c,0x0000000d,0x00000001,
0x00040017,0x0000000e,0x0000000a,0x00000002,0x00040015,0x00000012,0x00000020,0x00000000,
0x0008001e,0x00000013,0x00000012,0x00000012,0x00000012,0x00000006,0x00000007,0x00000007,
0x00040020,0x00000014,0x00000009,0x00000013,0x0004003b,0x00000014,0x00000015,0x00000009,
0x0004002b,0x00000006,0x00000016,0x00000005,0x00040020,0x00000017,0x00000009,0x00000007,
0x0004002b,0x00000006,0x0000001d,0x00000000,0x00040020,0x0000001e,0x00000009,0x00000012,
0x00020014,0x00000021,0x0004002b,0x00000012,0x00000022,0x00000000,0x0004002b,0x00000012,
0x00000026,0x00000001,0x00040020,0x00000027,0x00000007,0x00000006,0x00040017,0x0000002c,
0x00000012,0x00000004,0x00040020,0x0000002d,0x00000007,0x0000002c,0x00090019,0x0000002f,
0x00000012,0x00000001,0x00000000,0x00000000,0x00000000,0x00000001,0x00000000,0x00040020,
0x00000030,0x00000000,0x0000002f,0x0004003b,0x00000030,0x00000031,0x00000000,0x0004002b,
0x00000006,0x00000033,0x00000004,0x0004002b,0x00000006,0x00000038,0x00000003,0x00040020,
0x00000039,0x00000009,0x00000006,0x00040017,0x0000003d,0x00000006,0x00000004,0x00040020,
0x0000003e,0x00000007,0x0000003d,0x0004002b,0x00000006,0x00000042,0x00000001,0x0004002b,
0x00000006,0x0000004d,0x00000002,0x0004002b,0x00000012,0x00000053,0x00000003,0x00040020,
0x00000057,0x00000003,0x0000003d,0x0004003b,0x00000057,0x00000058,0x00000003,0x00050036,
0x00000002,0x00000004,0x00000000,0x00000003,0x000200f8,0x00000005,0x0004003b,0x00000008,
0x00000009,0x00000007,0x0004003b,0x00000008,0x0000001b,0x00000007,0x0004003b,0x0000002d,
0x0000002e,0x00000007,0x0004003b,0x0000003e,0x0000003f,0x00000007,0x0004003d,0x0000000b,
0x0000000f,0x0000000d,0x0007004f,0x0000000e,0x00000010,0x0000000f,0x0000000f,0x00000000,
0x00000001,0x0004006e,0x00000007,0x00000011,0x00000010,0x00050041,0x00000017,0x00000018,
0x00000015,0x00000016,0x0004003d,0x00000007,0x00000019,0x00000018,0x00050082,0x00000007,
0x0000001a,0x00000011,0x00000019,0x0003003e,0x00000009,0x0000001a,0x0004003d,0x00000007,
0x0000001c,0x00000009,0x0003003e,0x0000001b,0x0000001c,0x00050041,0x0000001e,0x0000001f,
0x00000015,0x0000001d,0x0004003d,0x00000012,0x00000020,0x0000001f,0x000500ab,0x00000021,
0x00000023,0x00000020,0x00000022,0x000300f7,0x00000025,0x00000000,0x000400fa,0x00000023,
0x00000024,0x00000025,0x000200f8,0x00000024,0x00050041,0x00000027,0x00000028,0x0000001b,
0x00000026,0x0004003d,0x00000006,0x00000029,0x00000028,0x0004007e,0x00000006,0x0000002a,
0x00000029,0x00050041,0x00000027,0x0000002b,0x0000001b,0x00000026,0x0003003e,0x0000002b,
0x0000002a,0x000200f9,0x00000025,0x000200f8,0x00000025,0x0004003d,0x0000002f,0x00000032,
0x00000031,0x00050041,0x00000017,0x00000034,0x00000015,0x00000033,0x0004003d,0x00000007,
0x00000035,0x00000034,0x0004003d,0x00000007,0x00000036,0x0000001b,0x00050080,0x00000007,
0x00000037,0x00000035,0x00000036,0x00050041,0x00000039,0x0000003a,0x00000015,0x00000038,
0x0004003d,0x00000006,0x0000003b,0x0000003a,0x0007005f,0x0000002c,0x0000003c,0x00000032,
0x00000037,0x00000002,0x0000003b,0x0003003e,0x0000002e,0x0000003c,0x0004003d,0x0000002c,
0x00000040,0x0000002e,0x0004007c,0x0000003d,0x00000041,0x00000040,0x0003003e,0x0000003f,
0x00000041,0x00050041,0x0000001e,0x00000043,0x00000015,0x00000042,0x0004003d,0x00000012,
0x00000044,0x00000043,0x000500ab,0x00000021,0x00000045,0x00000044,0x00000022,0x000300f7,
0x00000047,0x00000000,0x000400fa,0x00000045,0x00000046,0x0000004c,0x000200f8,0x00000046,
0x0004003d,0x0000003d,0x00000048,0x0000003f,0x0007004f,0x00000007,0x00000049,0x00000048,
0x00000048,0x00000000,0x00000003,0x0004003d,0x0000003d,0x0000004a,0x0000003f,0x0009004f,
0x0000003d,0x0000004b,0x0000004a,0x00000049,0x00000004,0x00000005,0x00000002,0x00000003,
0x0003003e,0x0000003f,0x0000004b,0x000200f9,0x00000047,0x000200f8,0x0000004c,0x00050041,
0x0000001e,0x0000004e,0x00000015,0x0000004d,0x0004003d,0x00000012,0x0000004f,0x0000004e,
0x000500ab,0x00000021,0x00000050,0x0000004f,0x00000022,0x000300f7,0x00000052,0x00000000,
0x000400fa,0x00000050,0x00000051,0x00000052,0x000200f8,0x00000051,0x00050041,0x00000027,
0x00000054,0x0000003f,0x00000053,0x0004003d,0x00000006,0x00000055,0x00000054,0x00050041,
0x00000027,0x00000056,0x0000003f,0x00000022,0x0003003e,0x00000056,0x00000055,0x000200f9,
0x00000052,0x000200f8,0x00000052,0x000200f9,0x00000047,0x000200f8,0x00000047,0x0004003d,
0x0000003d,0x00000059,0x0000003f,0x0003003e,0x00000058,0x00000059,0x000100fd,0x00010038
};
#if 0 // Generated from:
#version 450 core
#extension GL_EXT_samplerless_texture_functions : require
layout(set = 0, binding = 0)uniform utexture2D src;
layout(location = 0)out ivec4 dest;
layout(push_constant)uniform PushConstants {
bool flipY;
bool destHasLuminance;
bool destIsAlpha;
int srcMip;
ivec2 srcOffset;
ivec2 destOffset;
} params;
void main()
{
ivec2 destSubImageCoords = ivec2(gl_FragCoord . xy)- params . destOffset;
ivec2 srcSubImageCoords = destSubImageCoords;
if(params . flipY)
srcSubImageCoords . y = - srcSubImageCoords . y;
uvec4 srcValue = texelFetch(src, params . srcOffset + srcSubImageCoords, params . srcMip);
ivec4 destValue = ivec4(srcValue);
if(params . destHasLuminance)
{
destValue . rg = destValue . ra;
}
else if(params . destIsAlpha)
{
destValue . r = destValue . a;
}
dest = destValue;
}
#endif // Preprocessed code
src/libANGLE/renderer/vulkan/shaders/src/ImageCopy.frag
......@@ -9,19 +9,27 @@
#extension GL_EXT_samplerless_texture_functions : require
#define MAKE_SRC_RESOURCE(prefix, type) prefix ## type
#if SrcIsFloat
#define SRC_RESOURCE(type) type
#define SrcType vec4
#elif SrcIsInt
#define SRC_RESOURCE(type) i ## type
#define SRC_RESOURCE(type) MAKE_SRC_RESOURCE(i, type)
#define SrcType ivec4
#elif SrcIsUint
#define SRC_RESOURCE(type) u ## type
#define SRC_RESOURCE(type) MAKE_SRC_RESOURCE(u, type)
#define SrcType uvec4
#else
#error "Not all source formats are accounted for"
#endif
#if SrcIsArray
#define SRC_RESOURCE_NAME texture2DArray
#else
#define SRC_RESOURCE_NAME texture2D
#endif
#if DestIsFloat
#define DestType vec4
#elif DestIsInt
......@@ -32,19 +40,27 @@
#error "Not all destinatoin formats are accounted for"
#endif
layout(set = 0, binding = 0) uniform SRC_RESOURCE(texture2D) src;
layout(set = 0, binding = 0) uniform SRC_RESOURCE(SRC_RESOURCE_NAME) src;
layout(location = 0) out DestType dest;
layout(push_constant) uniform PushConstants {
// Translation from source to destination coordinates.
ivec2 srcOffset;
ivec2 destOffset;
int srcMip;
int srcLayer;
// Whether y needs to be flipped
bool flipY;
// Premultiplied alpha conversions
bool premultiplyAlpha;
bool unmultiplyAlpha;
// Whether destination is emulated luminance/alpha.
bool destHasLuminance;
bool destIsAlpha;
// Translation from source to destination coordinates.
int srcMip;
ivec2 srcOffset;
ivec2 destOffset;
// Bits 0~3 tell whether R,G,B or A exist in destination, but as a result of format emulation.
// Bit 0 is ignored, because R is always present. For B and G, the result is set to 0 and for
// A, the result is set to 1.
int destDefaultChannelsMask;
} params;
void main()
......@@ -58,7 +74,20 @@ void main()
if (params.flipY)
srcSubImageCoords.y = -srcSubImageCoords.y;
#if SrcIsArray
SrcType srcValue = texelFetch(src, ivec3(params.srcOffset + srcSubImageCoords, params.srcLayer), params.srcMip);
#else
SrcType srcValue = texelFetch(src, params.srcOffset + srcSubImageCoords, params.srcMip);
#endif
if (params.premultiplyAlpha)
{
srcValue.rgb *= srcValue.a;
}
else if (params.unmultiplyAlpha && srcValue.a > 0)
{
srcValue.rgb /= srcValue.a;
}
// Convert value to destination type.
DestType destValue = DestType(srcValue);
......@@ -72,6 +101,22 @@ void main()
{
destValue.r = destValue.a;
}
else
{
int defaultChannelsMask = params.destDefaultChannelsMask;
if ((defaultChannelsMask & 2) != 0)
{
destValue.g = 0;
}
if ((defaultChannelsMask & 4) != 0)
{
destValue.b = 0;
}
if ((defaultChannelsMask & 8) != 0)
{
destValue.a = 1;
}
}
dest = destValue;
}
src/libANGLE/renderer/vulkan/shaders/src/ImageCopy.frag.json
......@@ -6,6 +6,9 @@
"",
"ImageCopy.frag.json: Build parameters for ImageCopy.frag."
],
"Flags": [
"SrcIsArray"
],
"SrcFormat": [
"SrcIsFloat",
"SrcIsInt",
......
src/libANGLE/renderer/vulkan/vk_helpers.cpp
......@@ -458,8 +458,6 @@ angle::Result DynamicDescriptorPool::allocateNewPool(Context *context)
if (!mDescriptorPools[poolIndex]->isReferenced() &&
!renderer->isSerialInUse(mDescriptorPools[poolIndex]->get().getSerial()))
{
// The newly allocated pool must be a different index from the current pool.
ASSERT(poolIndex != mCurrentPoolIndex);
mCurrentPoolIndex = poolIndex;
found = true;
break;
......
src/libANGLE/renderer/vulkan/vk_internal_shaders_autogen.cpp
......@@ -49,12 +49,21 @@ namespace
#include "libANGLE/renderer/vulkan/shaders/gen/ImageCopy.frag.00000000.inc"
#include "libANGLE/renderer/vulkan/shaders/gen/ImageCopy.frag.00000001.inc"
#include "libANGLE/renderer/vulkan/shaders/gen/ImageCopy.frag.00000002.inc"
#include "libANGLE/renderer/vulkan/shaders/gen/ImageCopy.frag.00000003.inc"
#include "libANGLE/renderer/vulkan/shaders/gen/ImageCopy.frag.00000004.inc"
#include "libANGLE/renderer/vulkan/shaders/gen/ImageCopy.frag.00000005.inc"
#include "libANGLE/renderer/vulkan/shaders/gen/ImageCopy.frag.00000006.inc"
#include "libANGLE/renderer/vulkan/shaders/gen/ImageCopy.frag.00000008.inc"
#include "libANGLE/renderer/vulkan/shaders/gen/ImageCopy.frag.00000009.inc"
#include "libANGLE/renderer/vulkan/shaders/gen/ImageCopy.frag.0000000A.inc"
#include "libANGLE/renderer/vulkan/shaders/gen/ImageCopy.frag.0000000B.inc"
#include "libANGLE/renderer/vulkan/shaders/gen/ImageCopy.frag.0000000C.inc"
#include "libANGLE/renderer/vulkan/shaders/gen/ImageCopy.frag.0000000D.inc"
#include "libANGLE/renderer/vulkan/shaders/gen/ImageCopy.frag.00000010.inc"
#include "libANGLE/renderer/vulkan/shaders/gen/ImageCopy.frag.00000011.inc"
#include "libANGLE/renderer/vulkan/shaders/gen/ImageCopy.frag.00000012.inc"
#include "libANGLE/renderer/vulkan/shaders/gen/ImageCopy.frag.00000013.inc"
#include "libANGLE/renderer/vulkan/shaders/gen/ImageCopy.frag.00000014.inc"
#include "libANGLE/renderer/vulkan/shaders/gen/ImageCopy.frag.00000015.inc"
// This is SPIR-V binary blob and the size.
struct ShaderBlob
......@@ -105,14 +114,25 @@ constexpr ShaderBlob kImageCopy_frag_shaders[] = {
{kImageCopy_frag_00000000, sizeof(kImageCopy_frag_00000000)},
{kImageCopy_frag_00000001, sizeof(kImageCopy_frag_00000001)},
{kImageCopy_frag_00000002, sizeof(kImageCopy_frag_00000002)},
{nullptr, 0}, // 0x00000003
{kImageCopy_frag_00000003, sizeof(kImageCopy_frag_00000003)},
{kImageCopy_frag_00000004, sizeof(kImageCopy_frag_00000004)},
{kImageCopy_frag_00000005, sizeof(kImageCopy_frag_00000005)},
{kImageCopy_frag_00000006, sizeof(kImageCopy_frag_00000006)},
{nullptr, 0}, // 0x00000006
{nullptr, 0}, // 0x00000007
{kImageCopy_frag_00000008, sizeof(kImageCopy_frag_00000008)},
{kImageCopy_frag_00000009, sizeof(kImageCopy_frag_00000009)},
{kImageCopy_frag_0000000A, sizeof(kImageCopy_frag_0000000A)},
{kImageCopy_frag_0000000B, sizeof(kImageCopy_frag_0000000B)},
{kImageCopy_frag_0000000C, sizeof(kImageCopy_frag_0000000C)},
{kImageCopy_frag_0000000D, sizeof(kImageCopy_frag_0000000D)},
{nullptr, 0}, // 0x0000000E
{nullptr, 0}, // 0x0000000F
{kImageCopy_frag_00000010, sizeof(kImageCopy_frag_00000010)},
{kImageCopy_frag_00000011, sizeof(kImageCopy_frag_00000011)},
{kImageCopy_frag_00000012, sizeof(kImageCopy_frag_00000012)},
{kImageCopy_frag_00000013, sizeof(kImageCopy_frag_00000013)},
{kImageCopy_frag_00000014, sizeof(kImageCopy_frag_00000014)},
{kImageCopy_frag_00000015, sizeof(kImageCopy_frag_00000015)},
};
angle::Result GetShader(Context *context,
......
src/libANGLE/renderer/vulkan/vk_internal_shaders_autogen.gni
......@@ -42,10 +42,19 @@ angle_vulkan_internal_shaders = [
"shaders/gen/ImageCopy.frag.00000000.inc",
"shaders/gen/ImageCopy.frag.00000001.inc",
"shaders/gen/ImageCopy.frag.00000002.inc",
"shaders/gen/ImageCopy.frag.00000003.inc",
"shaders/gen/ImageCopy.frag.00000004.inc",
"shaders/gen/ImageCopy.frag.00000005.inc",
"shaders/gen/ImageCopy.frag.00000006.inc",
"shaders/gen/ImageCopy.frag.00000008.inc",
"shaders/gen/ImageCopy.frag.00000009.inc",
"shaders/gen/ImageCopy.frag.0000000A.inc",
"shaders/gen/ImageCopy.frag.0000000B.inc",
"shaders/gen/ImageCopy.frag.0000000C.inc",
"shaders/gen/ImageCopy.frag.0000000D.inc",
"shaders/gen/ImageCopy.frag.00000010.inc",
"shaders/gen/ImageCopy.frag.00000011.inc",
"shaders/gen/ImageCopy.frag.00000012.inc",
"shaders/gen/ImageCopy.frag.00000013.inc",
"shaders/gen/ImageCopy.frag.00000014.inc",
"shaders/gen/ImageCopy.frag.00000015.inc",
]
src/libANGLE/renderer/vulkan/vk_internal_shaders_autogen.h
......@@ -70,19 +70,24 @@ namespace ImageClear_frag
namespace ImageCopy_frag
{
enum flags
{
kSrcIsArray = 0x00000001,
kFlagsMask = 0x00000001,
};
enum SrcFormat
{
kSrcIsFloat = 0x00000000,
kSrcIsInt = 0x00000001,
kSrcIsUint = 0x00000002,
kSrcFormatMask = 0x00000003,
kSrcIsInt = 0x00000002,
kSrcIsUint = 0x00000004,
kSrcFormatMask = 0x00000006,
};
enum DestFormat
{
kDestIsFloat = 0x00000000,
kDestIsInt = 0x00000004,
kDestIsUint = 0x00000008,
kDestFormatMask = 0x0000000C,
kDestIsInt = 0x00000008,
kDestIsUint = 0x00000010,
kDestFormatMask = 0x00000018,
};
} // namespace ImageCopy_frag
......@@ -123,7 +128,8 @@ class ShaderLibrary final : angle::NonCopyable
RefCounted<ShaderAndSerial> mFullScreenQuad_vert_shaders[1];
RefCounted<ShaderAndSerial> mImageClear_frag_shaders[1];
RefCounted<ShaderAndSerial>
mImageCopy_frag_shaders[InternalShader::ImageCopy_frag::kSrcFormatMask |
mImageCopy_frag_shaders[InternalShader::ImageCopy_frag::kFlagsMask |
InternalShader::ImageCopy_frag::kSrcFormatMask |
InternalShader::ImageCopy_frag::kDestFormatMask];
};
} // namespace vk
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment