Google GitGoogle Git
Sign in
flutter/third_party/angle/d58722eb6e8048b39a62beafe71a140d4403f5d5/./src/libANGLE/renderer/vulkan/UtilsVk.h
blob: f1f8b97dd61b6f43229b3472ec4a5b6ca33471d1 [file]
//
// Copyright 2018 The ANGLE Project Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
//
// UtilsVk.h:
// Defines the UtilsVk class, a helper for various internal draw/dispatch utilities such as
// buffer clear and copy, image clear and copy, texture mip map generation, etc.
//
// - Convert index buffer:
// * Used by VertexArrayVk::convertIndexBufferGPU() to convert a ubyte element array to ushort
// - Convert vertex buffer:
// * Used by VertexArrayVk::convertVertexBufferGPU() to convert vertex attributes from
// unsupported formats to their fallbacks.
// - Image clear: Used by FramebufferVk::clearWithDraw().
// - Image copy: Used by TextureVk::copySubImageImplWithDraw().
// - Image copy bits: Used by ImageHelper::CopyImageSubData() to perform bitwise copies between
// RGB formats where at least one of src and dst use RGBA as fallback.
// - Color blit/resolve: Used by FramebufferVk::blit() to implement blit or multisample resolve
// on color images.
// - Depth/Stencil blit/resolve: Used by FramebufferVk::blit() to implement blit or multisample
// resolve on depth/stencil images.
// - Generate mipmap: Used by TextureVk::generateMipmapsWithCompute().
// - Mipmap generation: Used by TextureVk to generate mipmaps more efficiently in compute.
//
#ifndef LIBANGLE_RENDERER_VULKAN_UTILSVK_H_
#define LIBANGLE_RENDERER_VULKAN_UTILSVK_H_
#include <array>
#include "libANGLE/renderer/vulkan/BufferVk.h"
#include "libANGLE/renderer/vulkan/vk_cache_utils.h"
#include "libANGLE/renderer/vulkan/vk_helpers.h"
#include "libANGLE/renderer/vulkan/vk_internal_shaders_autogen.h"
namespace rx
{
class UtilsVk : angle::NonCopyable
{
public:
UtilsVk();
~UtilsVk();
void destroy(ContextVk *contextVk);
struct ConvertIndexParameters
{
uint32_t srcOffset = 0;
uint32_t dstOffset = 0;
uint32_t maxIndex = 0;
};
struct ConvertIndexIndirectParameters
{
uint32_t srcIndirectBufOffset = 0;
uint32_t srcIndexBufOffset = 0;
uint32_t dstIndexBufOffset = 0;
uint32_t maxIndex = 0;
uint32_t dstIndirectBufOffset = 0;
};
struct ConvertLineLoopIndexIndirectParameters
{
uint32_t indirectBufferOffset = 0;
uint32_t dstIndirectBufferOffset = 0;
uint32_t srcIndexBufferOffset = 0;
uint32_t dstIndexBufferOffset = 0;
uint32_t indicesBitsWidth = 0;
};
struct ConvertLineLoopArrayIndirectParameters
{
uint32_t indirectBufferOffset = 0;
uint32_t dstIndirectBufferOffset = 0;
uint32_t dstIndexBufferOffset = 0;
};
struct OffsetAndVertexCount
{
uint32_t srcOffset = 0;
uint32_t dstOffset = 0;
uint32_t vertexCount = 0;
};
using OffsetAndVertexCounts = std::vector<OffsetAndVertexCount>;
struct ConvertVertexParameters
{
size_t vertexCount = 0;
const angle::Format *srcFormat = nullptr;
const angle::Format *dstFormat = nullptr;
size_t srcStride = 0;
size_t srcOffset = 0;
size_t dstOffset = 0;
};
struct ClearFramebufferParameters
{
// Satisfy chromium-style with a constructor that does what = {} was already doing in a
// safer way.
ClearFramebufferParameters();
gl::Rectangle clearArea;
bool clearColor;
bool clearDepth;
bool clearStencil;
uint8_t stencilMask;
VkColorComponentFlags colorMaskFlags;
uint32_t colorAttachmentIndexGL;
const angle::Format *colorFormat;
VkClearColorValue colorClearValue;
VkClearDepthStencilValue depthStencilClearValue;
};
struct ClearTextureParameters
{
VkImageAspectFlags aspectFlags = 0;
vk::LevelIndex level = vk::LevelIndex(0);
vk::LayerIndex layer = vk::LayerIndex(0);
gl::Box clearArea = {};
VkClearValue clearValue = {};
};
struct BlitResolveParameters
{
// |srcOffset| and |dstIndexBufferOffset| define the original blit/resolve offsets, possibly
// flipped.
int srcOffset[2] = {};
int dstOffset[2] = {};
// Amount to add to x and y axis for certain rotations
int rotatedOffsetFactor[2] = {};
// |stretch| is SourceDimension / DestDimension used to transfer dst coordinates to source.
float stretch[2] = {};
// |srcExtents| is used to normalize source coordinates for sampling.
int srcExtents[2] = {};
// render area, which maps to VkViewport
gl::Rectangle renderArea = {};
// |blitArea| is the area in destination where blit happens. It's expected that scissor
// and source clipping effects have already been applied to it.
gl::Rectangle blitArea = {};
vk::LevelIndex srcMip = vk::LevelIndex(0);
vk::LayerIndex srcLayer = vk::LayerIndex(0);
// Whether linear or point sampling should be used.
bool linear = false;
bool flipX = false;
bool flipY = false;
SurfaceRotation rotation = SurfaceRotation::Identity;
};
struct ClearImageParameters
{
gl::Rectangle clearArea = {};
vk::LevelIndex dstMip = vk::LevelIndex(0);
vk::LayerIndex dstLayer = vk::LayerIndex(0);
VkColorComponentFlags colorMaskFlags = 0;
VkClearColorValue colorClearValue = {};
};
struct CopyImageParameters
{
int srcOffset[2] = {};
int srcExtents[2] = {};
int dstOffset[2] = {};
vk::LevelIndex srcMip = vk::LevelIndex(0);
vk::LayerIndex srcLayer = vk::LayerIndex(0);
int srcSampleCount = 0;
int srcHeight = 0;
gl::OwnerLevel dstMip = gl::OwnerLevel(0);
gl::OwnerLayer dstLayer = gl::OwnerLayer(0);
bool srcPremultiplyAlpha = false;
bool srcUnmultiplyAlpha = false;
bool srcFlipY = false;
bool dstFlipY = false;
SurfaceRotation srcRotation = SurfaceRotation::Identity;
GLenum srcColorEncoding = GL_NONE;
GLenum dstColorEncoding = GL_NONE;
bool copyYuvWithoutColorConversion = false;
};
struct CopyImageBitsParameters
{
int srcOffset[3] = {};
gl::OwnerLevel srcLevel = gl::OwnerLevel(0);
int dstOffset[3] = {};
gl::OwnerLevel dstLevel = gl::OwnerLevel(0);
uint32_t copyExtents[3] = {};
};
struct CopyImageToBufferParameters
{
int srcOffset[2] = {};
vk::LevelIndex srcMip = vk::LevelIndex(0);
vk::LayerIndex srcLayer = vk::LayerIndex(0);
uint32_t size[2] = {};
ptrdiff_t outputOffset = 0;
uint32_t outputPitch = 0;
bool reverseRowOrder = false;
const angle::Format *outputFormat = nullptr;
};
struct GenerateMipmapParameters
{
uint32_t srcLevel = 0;
uint32_t dstLevelCount = 0;
};
struct UnresolveParameters
{
gl::DrawBufferMask unresolveColorMask = {};
bool unresolveDepth = false;
bool unresolveStencil = false;
bool useDynamicRendering = false;
};
struct GenerateFragmentShadingRateParameters
{
uint32_t textureWidth = 0;
uint32_t textureHeight = 0;
uint32_t attachmentWidth = 0;
uint32_t attachmentHeight = 0;
uint32_t attachmentBlockWidth = 0;
uint32_t attachmentBlockHeight = 0;
uint32_t numFocalPoints = 0;
std::array<gl::FocalPoint, gl::IMPLEMENTATION_MAX_FOCAL_POINTS> focalPoints = {};
};
// Based on the maximum number of levels in GenerateMipmap.comp.
static constexpr uint32_t kGenerateMipmapMaxLevels = 6;
static uint32_t GetGenerateMipmapMaxLevels(ContextVk *contextVk);
angle::Result convertIndexBuffer(ContextVk *contextVk,
vk::BufferHelper *dst,
vk::BufferHelper *src,
const ConvertIndexParameters &params);
angle::Result convertIndexIndirectBuffer(ContextVk *contextVk,
vk::BufferHelper *srcIndirectBuf,
vk::BufferHelper *srcIndexBuf,
vk::BufferHelper *dstIndirectBuf,
vk::BufferHelper *dstIndexBuf,
const ConvertIndexIndirectParameters &params);
angle::Result convertLineLoopIndexIndirectBuffer(
ContextVk *contextVk,
vk::BufferHelper *srcIndirectBuffer,
vk::BufferHelper *srcIndexBuffer,
vk::BufferHelper *dstIndirectBuffer,
vk::BufferHelper *dstIndexBuffer,
const ConvertLineLoopIndexIndirectParameters &params);
angle::Result convertLineLoopArrayIndirectBuffer(
ContextVk *contextVk,
vk::BufferHelper *srcIndirectBuffer,
vk::BufferHelper *dstIndirectBuffer,
vk::BufferHelper *dstIndexBuffer,
const ConvertLineLoopArrayIndirectParameters &params);
angle::Result convertVertexBuffer(ContextVk *contextVk,
vk::BufferHelper *dst,
vk::BufferHelper *src,
const ConvertVertexParameters &params,
const OffsetAndVertexCounts &additionalOffsetVertexCounts);
// For VK_QCOM_tile_memory_heap
angle::Result clearTextureNoFlush(ContextVk *contextVk,
vk::ImageHelper *dst,
const ClearTextureParameters &params);
// EXT_clear_texture
angle::Result clearTexture(ContextVk *contextVk,
vk::ImageHelper *dst,
const ClearTextureParameters &params);
angle::Result clearFramebuffer(ContextVk *contextVk,
FramebufferVk *framebuffer,
const ClearFramebufferParameters &params);
// Resolve images if multisampled. Blit otherwise.
angle::Result colorBlitResolve(ContextVk *contextVk,
FramebufferVk *framebuffer,
vk::ImageHelper *srcImage,
const vk::ImageView *srcView,
const BlitResolveParameters &params);
angle::Result depthStencilBlitResolve(ContextVk *contextVk,
vk::RenderPassCommandBufferHelper *renderPassCommands,
vk::ImageHelper *dstImage,
const vk::ImageView &dstImageView,
gl::OwnerLevel dstImageLevel,
gl::OwnerLayer dstImageLayer,
vk::ImageHelper *srcImage,
const vk::ImageView *srcDepthView,
const vk::ImageView *srcStencilView,
const BlitResolveParameters &params);
angle::Result stencilBlitResolveNoShaderExport(ContextVk *contextVk,
vk::ImageHelper *dstImage,
gl::OwnerLevel dstLevelIndex,
gl::OwnerLayer dstLayerIndex,
vk::ImageHelper *srcImage,
const vk::ImageView *srcStencilView,
const BlitResolveParameters &params);
angle::Result clearImage(ContextVk *contextVk,
vk::ImageHelper *dst,
const ClearImageParameters &params);
angle::Result copyImageFromTileMemory(ContextVk *contextVk,
const VkImageAspectFlags aspectFlags,
vk::ImageHelper *dstImage,
vk::ImageHelper *srcImage);
angle::Result copyImage(ContextVk *contextVk,
vk::ImageHelper *dst,
const vk::ImageView *dstView,
vk::ImageHelper *src,
const vk::ImageView *srcView,
const CopyImageParameters &params);
angle::Result copyImageBits(ContextVk *contextVk,
vk::ImageHelper *dst,
vk::ImageHelper *src,
const CopyImageBitsParameters &params);
angle::Result copyImageToBuffer(ContextVk *contextVk,
vk::BufferHelper *dst,
vk::ImageHelper *src,
const CopyImageToBufferParameters &params);
angle::Result copyRgbToRgba(ContextVk *contextVk,
const angle::Format &srcFormat,
vk::BufferHelper *srcBuffer,
uint32_t srcOffset,
uint32_t pixelCount,
vk::BufferHelper *dstBuffer);
angle::Result transCodeEtcToBc(ContextVk *contextVk,
vk::BufferHelper *srcBuffer,
vk::ImageHelper *dstImage,
const VkBufferImageCopy *copyRegion);
using GenerateMipmapDestLevelViews =
std::array<const vk::ImageView *, kGenerateMipmapMaxLevels>;
angle::Result generateMipmap(ContextVk *contextVk,
vk::ImageHelper *src,
const vk::ImageView *srcLevelZeroView,
vk::ImageHelper *dst,
const GenerateMipmapDestLevelViews &dstLevelViews,
const vk::Sampler &sampler,
const GenerateMipmapParameters &params);
angle::Result generateMipmapWithDraw(ContextVk *contextVk,
vk::ImageHelper *image,
const angle::FormatID actualFormatID,
const bool isMipmapFiltered);
angle::Result unresolve(ContextVk *contextVk,
const FramebufferVk *framebuffer,
const UnresolveParameters &params);
// Fragment shading rate utility
angle::Result generateFragmentShadingRate(
ContextVk *contextVk,
vk::ImageHelper *shadingRateAttachmentImageHelper,
vk::ImageViewHelper *shadingRateAttachmentImageViewHelper,
const GenerateFragmentShadingRateParameters &shadingRateParameters);
private:
ANGLE_ENABLE_STRUCT_PADDING_WARNINGS
struct ConvertIndexShaderParams
{
uint32_t srcOffset = 0;
uint32_t dstOffsetDiv4 = 0;
uint32_t maxIndex = 0;
uint32_t _padding = 0;
};
struct ConvertIndexIndirectShaderParams
{
uint32_t srcIndirectOffsetDiv4 = 0;
uint32_t srcOffset = 0;
uint32_t dstOffsetDiv4 = 0;
uint32_t maxIndex = 0;
uint32_t dstIndirectOffsetDiv4 = 0;
};
struct ConvertIndexIndirectLineLoopShaderParams
{
uint32_t cmdOffsetDiv4 = 0;
uint32_t dstCmdOffsetDiv4 = 0;
uint32_t srcOffset = 0;
uint32_t dstOffsetDiv4 = 0;
uint32_t isRestartEnabled = 0;
};
struct ConvertIndirectLineLoopShaderParams
{
uint32_t cmdOffsetDiv4 = 0;
uint32_t dstCmdOffsetDiv4 = 0;
uint32_t dstOffsetDiv4 = 0;
};
struct ConvertVertexShaderParams
{
ConvertVertexShaderParams();
// Structure matching PushConstants in ConvertVertex.comp
uint32_t outputCount = 0;
uint32_t componentCount = 0;
uint32_t srcOffset = 0;
uint32_t dstOffset = 0;
uint32_t Ns = 0;
uint32_t Bs = 0;
uint32_t Ss = 0;
uint32_t Es = 0;
uint32_t Nd = 0;
uint32_t Bd = 0;
uint32_t Sd = 0;
uint32_t Ed = 0;
uint32_t srcEmulatedAlpha = 0;
uint32_t isSrcHDR = 0;
uint32_t isSrcA2BGR10 = 0;
uint32_t _padding = 0;
};
struct ImageClearShaderParams
{
// Structure matching PushConstants in ImageClear.frag
VkClearColorValue clearValue = {};
float clearDepth = 0.0f;
};
struct ImageCopyShaderParams
{
ImageCopyShaderParams();
// Structure matching PushConstants in ImageCopy.frag
int32_t srcOffset[2] = {};
int32_t dstOffset[2] = {};
int32_t srcMip = 0;
int32_t srcLayer = 0;
int32_t srcSampleCount = 0;
uint32_t flipX = 0;
uint32_t flipY = 0;
uint32_t premultiplyAlpha = 0;
uint32_t unmultiplyAlpha = 0;
uint32_t dstHasLuminance = 0;
uint32_t dstIsAlpha = 0;
uint32_t srcIsSRGB = 0;
uint32_t dstIsSRGB = 0;
uint32_t dstDefaultChannelsMask = 0;
uint32_t rotateXY = 0;
};
struct CopyImageToBufferShaderParams
{
// Structure matching PushConstants in CopyImageToBuffer.comp
int32_t srcOffset[2] = {};
int32_t srcDepth = 0;
uint32_t reverseRowOrder = 0;
uint32_t size[2] = {};
uint32_t outputOffset = 0;
uint32_t outputPitch = 0;
uint32_t isDstSnorm = 0;
};
union BlitResolveOffset
{
std::array<int32_t, 2> resolve;
std::array<float, 2> blit;
};
struct BlitResolveShaderParams
{
// Structure matching PushConstants in BlitResolve.frag
BlitResolveOffset offset = {};
float stretch[2] = {};
float invSrcExtent[2] = {};
int32_t srcMip = 0;
int32_t srcLayer = 0;
int32_t samples = 0;
float invSamples = 0;
uint32_t outputMask = 0;
uint32_t flipX = 0;
uint32_t flipY = 0;
uint32_t rotateXY = 0;
};
struct BlitResolveStencilNoExportShaderParams
{
// Structure matching PushConstants in BlitResolveStencilNoExport.comp
BlitResolveOffset offset = {};
float stretch[2] = {};
float invSrcExtent[2] = {};
int32_t srcLayer = 0;
int32_t srcWidth = 0;
int32_t srcHeight = 0;
uint32_t flipX = 0;
uint32_t flipY = 0;
uint32_t rotateXY = 0;
int32_t blitArea[4] = {};
int32_t dstPitch = 0;
};
struct ExportStencilShaderParams
{
uint32_t bit = 0;
};
struct GenerateMipmapShaderParams
{
// Structure matching PushConstants in GenerateMipmap.comp
float invSrcExtent[2] = {};
uint32_t levelCount = 0;
};
struct EtcToBcShaderParams
{
uint32_t offsetX = 0;
uint32_t offsetY = 0;
int32_t texelOffset = 0;
uint32_t width = 0;
uint32_t height = 0;
uint32_t alphaBits = 0;
uint32_t isSigned = 0;
uint32_t isEacRg = 0;
};
ANGLE_DISABLE_STRUCT_PADDING_WARNINGS
// Functions implemented by the class:
enum class Function
{
// Functions implemented in graphics
ImageClear,
ImageCopy,
BlitResolve,
Blit3DSrc,
ExportStencil,
// Note: unresolve is special as it has a different layout per attachment count. Depth and
// stencil each require a binding, so are counted separately.
Unresolve1Attachment,
Unresolve2Attachments,
Unresolve3Attachments,
Unresolve4Attachments,
Unresolve5Attachments,
Unresolve6Attachments,
Unresolve7Attachments,
Unresolve8Attachments,
Unresolve9Attachments,
Unresolve10Attachments,
// Functions implemented in compute
ComputeStartIndex, // Special value to separate draw and dispatch functions.
ConvertIndexBuffer = ComputeStartIndex,
ConvertVertexBuffer,
ClearTexture,
BlitResolveStencilNoExport,
ConvertIndexIndirectBuffer,
ConvertIndexIndirectLineLoopBuffer,
ConvertIndirectLineLoopBuffer,
GenerateMipmap,
TransCodeEtcToBc,
CopyImageToBuffer,
GenerateFragmentShadingRate,
InvalidEnum,
EnumCount = InvalidEnum,
};
struct GraphicsShaderProgramAndPipelines
{
vk::ShaderProgramHelper program;
CompleteGraphicsPipelineCache pipelines;
};
struct ComputeShaderProgramAndPipelines
{
vk::ShaderProgramHelper program;
ComputePipelineCache pipelines;
};
// Common functions that create the pipeline for the specified function, binds it and prepares
// the draw/dispatch call.
angle::Result setupComputeProgram(
ContextVk *contextVk,
Function function,
const vk::ShaderModulePtr &csShader,
ComputeShaderProgramAndPipelines *programAndPipelines,
const VkDescriptorSet descriptorSet,
const void *pushConstants,
size_t pushConstantsSize,
vk::OutsideRenderPassCommandBufferHelper *commandBufferHelper);
angle::Result setupGraphicsProgramWithLayout(
ContextVk *contextVk,
const vk::PipelineLayout &pipelineLayout,
const vk::ShaderModulePtr &vsShader,
const vk::ShaderModulePtr &fsShader,
GraphicsShaderProgramAndPipelines *programAndPipelines,
const vk::GraphicsPipelineDesc *pipelineDesc,
const VkDescriptorSet descriptorSet,
const void *pushConstants,
size_t pushConstantsSize,
vk::RenderPassCommandBuffer *commandBuffer);
angle::Result setupGraphicsProgram(ContextVk *contextVk,
Function function,
const vk::ShaderModulePtr &vsShader,
const vk::ShaderModulePtr &fsShader,
GraphicsShaderProgramAndPipelines *programAndPipelines,
const vk::GraphicsPipelineDesc *pipelineDesc,
const VkDescriptorSet descriptorSet,
const void *pushConstants,
size_t pushConstantsSize,
vk::RenderPassCommandBuffer *commandBuffer);
// Initializes descriptor set layout, pipeline layout and descriptor pool corresponding to given
// function, if not already initialized. Uses setSizes to create the layout. For example, if
// this array has two entries {STORAGE_TEXEL_BUFFER, 1} and {UNIFORM_TEXEL_BUFFER, 3}, then the
// created set layout would be binding 0 for storage texel buffer and bindings 1 through 3 for
// uniform texel buffer. All resources are put in set 0.
angle::Result ensureResourcesInitialized(ContextVk *contextVk,
Function function,
VkDescriptorPoolSize *setSizes,
size_t setSizesCount,
size_t pushConstantsSize);
// Initializers corresponding to functions, calling into ensureResourcesInitialized with the
// appropriate parameters.
angle::Result ensureConvertIndexResourcesInitialized(ContextVk *contextVk);
angle::Result ensureConvertIndexIndirectResourcesInitialized(ContextVk *contextVk);
angle::Result ensureConvertIndexIndirectLineLoopResourcesInitialized(ContextVk *contextVk);
angle::Result ensureConvertIndirectLineLoopResourcesInitialized(ContextVk *contextVk);
angle::Result ensureConvertVertexResourcesInitialized(ContextVk *contextVk);
angle::Result ensureImageClearResourcesInitialized(ContextVk *contextVk);
angle::Result ensureImageCopyResourcesInitialized(ContextVk *contextVk);
angle::Result ensureCopyImageToBufferResourcesInitialized(ContextVk *contextVk);
angle::Result ensureBlitResolveResourcesInitialized(ContextVk *contextVk);
angle::Result ensureBlitResolveStencilNoExportResourcesInitialized(ContextVk *contextVk);
angle::Result ensureExportStencilResourcesInitialized(ContextVk *contextVk);
angle::Result ensureGenerateMipmapResourcesInitialized(ContextVk *contextVk);
angle::Result ensureTransCodeEtcToBcResourcesInitialized(ContextVk *contextVk);
angle::Result ensureUnresolveResourcesInitialized(ContextVk *contextVk,
Function function,
uint32_t attachmentIndex);
angle::Result ensureImageCopyResourcesInitializedWithSampler(
ContextVk *contextVk,
const vk::SamplerDesc &samplerDesc);
angle::Result ensureSamplersInitialized(ContextVk *context);
angle::Result ensureGenerateFragmentShadingRateResourcesInitialized(ContextVk *contextVk);
angle::Result startRenderPass(ContextVk *contextVk,
const vk::ImageView *imageView,
const vk::RenderPassDesc &renderPassDesc,
const gl::Rectangle &renderArea,
const VkImageAspectFlags aspectFlags,
const VkClearValue *clearValue,
vk::RenderPassSource renderPassSource,
vk::RenderPassCommandBuffer **commandBufferOut);
// Set up descriptor set and call dispatch.
angle::Result convertVertexBufferImpl(
ContextVk *contextVk,
vk::BufferHelper *dst,
vk::BufferHelper *src,
uint32_t flags,
vk::OutsideRenderPassCommandBufferHelper *commandBufferHelper,
const ConvertVertexShaderParams &shaderParams,
const OffsetAndVertexCounts &additionalOffsetVertexCounts);
// Allocates a single descriptor set.
angle::Result allocateDescriptorSetWithLayout(
ContextVk *contextVk,
vk::CommandBufferHelperCommon *commandBufferHelper,
vk::DynamicDescriptorPool &descriptorPool,
const vk::DescriptorSetLayout &descriptorSetLayout,
VkDescriptorSet *descriptorSetOut);
angle::Result allocateDescriptorSet(ContextVk *contextVk,
vk::CommandBufferHelperCommon *commandBufferHelper,
Function function,
VkDescriptorSet *descriptorSetOut);
angle::Result allocateDescriptorSetForImageCopyWithSampler(
ContextVk *contextVk,
vk::CommandBufferHelperCommon *commandBufferHelper,
const vk::SamplerDesc &samplerDesc,
VkDescriptorSet *descriptorSetOut);
angle::Result setupBlitResolveGraphicsProgram(ContextVk *contextVk,
const vk::ImageHelper &srcImage,
const vk::ImageView *srcColorView,
const vk::ImageView *srcDepthView,
const vk::ImageView *srcStencilView,
const vk::GraphicsPipelineDesc &pipelineDesc,
uint32_t flags,
uint32_t outputMask,
const BlitResolveParameters &params,
vk::RenderPassCommandBuffer *commandBuffer,
bool blitColor,
bool blitDepth,
bool blitStencil);
angle::PackedEnumMap<Function, vk::DescriptorSetLayoutPointerArray> mDescriptorSetLayouts;
angle::PackedEnumMap<Function, vk::PipelineLayoutPtr> mPipelineLayouts;
angle::PackedEnumMap<Function, vk::DynamicDescriptorPool> mDescriptorPools;
std::unordered_map<vk::SamplerDesc, vk::DescriptorSetLayoutPointerArray>
mImageCopyWithSamplerDescriptorSetLayouts;
std::unordered_map<vk::SamplerDesc, vk::PipelineLayoutPtr> mImageCopyWithSamplerPipelineLayouts;
std::unordered_map<vk::SamplerDesc, vk::DynamicDescriptorPool>
mImageCopyWithSamplerDescriptorPools;
std::array<ComputeShaderProgramAndPipelines, vk::InternalShader::ConvertIndex_comp::kArrayLen>
mConvertIndex;
std::array<ComputeShaderProgramAndPipelines,
vk::InternalShader::ConvertIndexIndirectLineLoop_comp::kArrayLen>
mConvertIndexIndirectLineLoop;
std::array<ComputeShaderProgramAndPipelines,
vk::InternalShader::ConvertIndirectLineLoop_comp::kArrayLen>
mConvertIndirectLineLoop;
std::array<ComputeShaderProgramAndPipelines, vk::InternalShader::ConvertVertex_comp::kArrayLen>
mConvertVertex;
GraphicsShaderProgramAndPipelines mImageClearVSOnly;
std::array<GraphicsShaderProgramAndPipelines, vk::InternalShader::ImageClear_frag::kArrayLen>
mImageClear;
std::array<GraphicsShaderProgramAndPipelines, vk::InternalShader::ImageCopy_frag::kArrayLen>
mImageCopy;
GraphicsShaderProgramAndPipelines mImageCopyFloat;
std::unordered_map<vk::SamplerDesc, GraphicsShaderProgramAndPipelines> mImageCopyWithSampler;
std::array<ComputeShaderProgramAndPipelines,
vk::InternalShader::CopyImageToBuffer_comp::kArrayLen>
mCopyImageToBuffer;
std::array<GraphicsShaderProgramAndPipelines, vk::InternalShader::BlitResolve_frag::kArrayLen>
mBlitResolve;
std::array<GraphicsShaderProgramAndPipelines, vk::InternalShader::Blit3DSrc_frag::kArrayLen>
mBlit3DSrc;
std::array<ComputeShaderProgramAndPipelines,
vk::InternalShader::BlitResolveStencilNoExport_comp::kArrayLen>
mBlitResolveStencilNoExport;
GraphicsShaderProgramAndPipelines mExportStencil;
std::array<ComputeShaderProgramAndPipelines, vk::InternalShader::GenerateMipmap_comp::kArrayLen>
mGenerateMipmap;
std::array<ComputeShaderProgramAndPipelines, vk::InternalShader::EtcToBc_comp::kArrayLen>
mEtcToBc;
// Unresolve shaders are special as they are generated on the fly due to the large number of
// combinations.
std::unordered_map<uint32_t, vk::ShaderModulePtr> mUnresolveFragShaders;
std::unordered_map<uint32_t, GraphicsShaderProgramAndPipelines> mUnresolve;
ComputeShaderProgramAndPipelines mGenerateFragmentShadingRateAttachment;
vk::Sampler mPointSampler;
vk::Sampler mLinearSampler;
};
// This class' responsibility is to create index buffers needed to support line loops in Vulkan.
// In the setup phase of drawing, the createIndexBuffer method should be called with the
// current draw call parameters. If an element array buffer is bound for an indexed draw, use
// createIndexBufferFromElementArrayBuffer.
//
// If the user wants to draw a loop between [v1, v2, v3], we will create an indexed buffer with
// these indexes: [0, 1, 2, 3, 0] to emulate the loop.
class LineLoopHelper final : angle::NonCopyable
{
public:
LineLoopHelper(vk::Renderer *renderer);
~LineLoopHelper();
angle::Result getIndexBufferForDrawArrays(ContextVk *contextVk,
uint32_t clampedVertexCount,
GLint firstVertex,
vk::BufferHelper **bufferOut);
angle::Result getIndexBufferForElementArrayBuffer(ContextVk *contextVk,
BufferVk *elementArrayBufferVk,
gl::DrawElementsType glIndexType,
int indexCount,
uintptr_t elementArrayOffset,
vk::BufferHelper **bufferOut,
uint32_t *indexCountOut);
angle::Result streamIndices(ContextVk *contextVk,
gl::DrawElementsType glIndexType,
GLsizei indexCount,
const uint8_t *srcPtr,
vk::BufferHelper **bufferOut,
uint32_t *indexCountOut);
angle::Result streamIndicesIndirect(ContextVk *contextVk,
gl::DrawElementsType glIndexType,
vk::BufferHelper *indexBuffer,
vk::BufferHelper *indirectBuffer,
VkDeviceSize indirectBufferOffset,
vk::BufferHelper **indexBufferOut,
vk::BufferHelper **indirectBufferOut);
angle::Result streamArrayIndirect(ContextVk *contextVk,
size_t vertexCount,
vk::BufferHelper *arrayIndirectBuffer,
VkDeviceSize arrayIndirectBufferOffset,
vk::BufferHelper **indexBufferOut,
vk::BufferHelper **indexIndirectBufferOut);
void release(ContextVk *contextVk);
void destroy(vk::Renderer *renderer);
vk::BufferHelper *getCurrentIndexBuffer() { return mDynamicIndexBuffer.getBuffer(); }
static void Draw(uint32_t count,
uint32_t baseVertex,
vk::RenderPassCommandBuffer *commandBuffer)
{
// Our first index is always 0 because that's how we set it up in createIndexBuffer*.
commandBuffer->drawIndexedBaseVertex(count, baseVertex);
}
private:
ConversionBuffer mDynamicIndexBuffer;
ConversionBuffer mDynamicIndirectBuffer;
};
} // namespace rx
#endif // LIBANGLE_RENDERER_VULKAN_UTILSVK_H_