xref: /aosp_15_r20/external/angle/src/libANGLE/renderer/vulkan/UtilsVk.h (revision 8975f5c5ed3d1c378011245431ada316dfb6f244) 
1 //
2 // Copyright 2018 The ANGLE Project Authors. All rights reserved.
3 // Use of this source code is governed by a BSD-style license that can be
4 // found in the LICENSE file.
5 //
6 // UtilsVk.h:
7 //    Defines the UtilsVk class, a helper for various internal draw/dispatch utilities such as
8 //    buffer clear and copy, image clear and copy, texture mip map generation, etc.
9 //
10 //    - Convert index buffer:
11 //      * Used by VertexArrayVk::convertIndexBufferGPU() to convert a ubyte element array to ushort
12 //    - Convert vertex buffer:
13 //      * Used by VertexArrayVk::convertVertexBufferGPU() to convert vertex attributes from
14 //        unsupported formats to their fallbacks.
15 //    - Image clear: Used by FramebufferVk::clearWithDraw().
16 //    - Image copy: Used by TextureVk::copySubImageImplWithDraw().
17 //    - Image copy bits: Used by ImageHelper::CopyImageSubData() to perform bitwise copies between
18 //      RGB formats where at least one of src and dst use RGBA as fallback.
19 //    - Color blit/resolve: Used by FramebufferVk::blit() to implement blit or multisample resolve
20 //      on color images.
21 //    - Depth/Stencil blit/resolve: Used by FramebufferVk::blit() to implement blit or multisample
22 //      resolve on depth/stencil images.
23 //    - Generate mipmap: Used by TextureVk::generateMipmapsWithCompute().
24 //    - Overlay Draw: Used by OverlayVk to draw a UI for debugging.
25 //    - Mipmap generation: Used by TextureVk to generate mipmaps more efficiently in compute.
26 //
27 
28 #ifndef LIBANGLE_RENDERER_VULKAN_UTILSVK_H_
29 #define LIBANGLE_RENDERER_VULKAN_UTILSVK_H_
30 
31 #include "libANGLE/renderer/vulkan/BufferVk.h"
32 #include "libANGLE/renderer/vulkan/vk_cache_utils.h"
33 #include "libANGLE/renderer/vulkan/vk_helpers.h"
34 #include "libANGLE/renderer/vulkan/vk_internal_shaders_autogen.h"
35 
36 namespace rx
37 {
38 class UtilsVk : angle::NonCopyable
39 {
40   public:
41     UtilsVk();
42     ~UtilsVk();
43 
44     void destroy(ContextVk *contextVk);
45 
46     struct ConvertIndexParameters
47     {
48         uint32_t srcOffset = 0;
49         uint32_t dstOffset = 0;
50         uint32_t maxIndex  = 0;
51     };
52 
53     struct ConvertIndexIndirectParameters
54     {
55         uint32_t srcIndirectBufOffset = 0;
56         uint32_t srcIndexBufOffset    = 0;
57         uint32_t dstIndexBufOffset    = 0;
58         uint32_t maxIndex             = 0;
59         uint32_t dstIndirectBufOffset = 0;
60     };
61 
62     struct ConvertLineLoopIndexIndirectParameters
63     {
64         uint32_t indirectBufferOffset    = 0;
65         uint32_t dstIndirectBufferOffset = 0;
66         uint32_t srcIndexBufferOffset    = 0;
67         uint32_t dstIndexBufferOffset    = 0;
68         uint32_t indicesBitsWidth        = 0;
69     };
70 
71     struct ConvertLineLoopArrayIndirectParameters
72     {
73         uint32_t indirectBufferOffset    = 0;
74         uint32_t dstIndirectBufferOffset = 0;
75         uint32_t dstIndexBufferOffset    = 0;
76     };
77 
78     struct OffsetAndVertexCount
79     {
80         uint32_t srcOffset;
81         uint32_t dstOffset;
82         uint32_t vertexCount;
83     };
84     using OffsetAndVertexCounts = std::vector<OffsetAndVertexCount>;
85 
86     struct ConvertVertexParameters
87     {
88         size_t vertexCount;
89         const angle::Format *srcFormat;
90         const angle::Format *dstFormat;
91         size_t srcStride;
92         size_t srcOffset;
93         size_t dstOffset;
94     };
95 
96     struct ClearFramebufferParameters
97     {
98         // Satisfy chromium-style with a constructor that does what = {} was already doing in a
99         // safer way.
100         ClearFramebufferParameters();
101 
102         gl::Rectangle clearArea;
103 
104         bool clearColor;
105         bool clearDepth;
106         bool clearStencil;
107 
108         uint8_t stencilMask;
109         VkColorComponentFlags colorMaskFlags;
110         uint32_t colorAttachmentIndexGL;
111         const angle::Format *colorFormat;
112 
113         VkClearColorValue colorClearValue;
114         VkClearDepthStencilValue depthStencilClearValue;
115     };
116 
117     struct ClearTextureParameters
118     {
119         VkImageAspectFlags aspectFlags;
120         vk::LevelIndex level;
121         uint32_t layer;
122         gl::Box clearArea;
123         VkClearValue clearValue;
124     };
125 
126     struct BlitResolveParameters
127     {
128         // |srcOffset| and |dstIndexBufferOffset| define the original blit/resolve offsets, possibly
129         // flipped.
130         int srcOffset[2];
131         int dstOffset[2];
132         // Amount to add to x and y axis for certain rotations
133         int rotatedOffsetFactor[2];
134         // |stretch| is SourceDimension / DestDimension used to transfer dst coordinates to source.
135         float stretch[2];
136         // |srcExtents| is used to normalize source coordinates for sampling.
137         int srcExtents[2];
138         // |blitArea| is the area in destination where blit happens.  It's expected that scissor
139         // and source clipping effects have already been applied to it.
140         gl::Rectangle blitArea;
141         int srcLayer;
142         // Whether linear or point sampling should be used.
143         bool linear;
144         bool flipX;
145         bool flipY;
146         SurfaceRotation rotation;
147     };
148 
149     struct ClearImageParameters
150     {
151         gl::Rectangle clearArea;
152 
153         vk::LevelIndex dstMip;
154         int dstLayer;
155 
156         VkColorComponentFlags colorMaskFlags;
157         VkClearColorValue colorClearValue;
158     };
159 
160     struct CopyImageParameters
161     {
162         int srcOffset[2];
163         int srcExtents[2];
164         int dstOffset[2];
165         int srcMip;
166         int srcLayer;
167         int srcSampleCount;
168         int srcHeight;
169         gl::LevelIndex dstMip;
170         int dstLayer;
171         bool srcPremultiplyAlpha;
172         bool srcUnmultiplyAlpha;
173         bool srcFlipY;
174         bool dstFlipY;
175         SurfaceRotation srcRotation;
176         GLenum srcColorEncoding;
177         GLenum dstColorEncoding;
178     };
179 
180     struct CopyImageBitsParameters
181     {
182         int srcOffset[3];
183         gl::LevelIndex srcLevel;
184         int dstOffset[3];
185         gl::LevelIndex dstLevel;
186         uint32_t copyExtents[3];
187     };
188 
189     struct CopyImageToBufferParameters
190     {
191         int srcOffset[2];
192         vk::LevelIndex srcMip;
193         int srcLayer;
194         uint32_t size[2];
195         ptrdiff_t outputOffset;
196         uint32_t outputPitch;
197         bool reverseRowOrder;
198         const angle::Format *outputFormat;
199     };
200 
201     struct OverlayDrawParameters
202     {
203         uint32_t textWidgetCount;
204         uint32_t graphWidgetCount;
205         bool rotateXY;
206     };
207 
208     struct GenerateMipmapParameters
209     {
210         uint32_t srcLevel;
211         uint32_t dstLevelCount;
212     };
213 
214     struct UnresolveParameters
215     {
216         gl::DrawBufferMask unresolveColorMask;
217         bool unresolveDepth;
218         bool unresolveStencil;
219     };
220 
221     struct GenerateFragmentShadingRateParameters
222     {
223         uint32_t textureWidth;
224         uint32_t textureHeight;
225         uint32_t attachmentWidth;
226         uint32_t attachmentHeight;
227         uint32_t attachmentBlockWidth;
228         uint32_t attachmentBlockHeight;
229         uint32_t numFocalPoints;
230         gl::FocalPoint focalPoints[gl::IMPLEMENTATION_MAX_FOCAL_POINTS];
231     };
232 
233     // Based on the maximum number of levels in GenerateMipmap.comp.
234     static constexpr uint32_t kGenerateMipmapMaxLevels = 6;
235     static uint32_t GetGenerateMipmapMaxLevels(ContextVk *contextVk);
236 
237     angle::Result convertIndexBuffer(ContextVk *contextVk,
238                                      vk::BufferHelper *dst,
239                                      vk::BufferHelper *src,
240                                      const ConvertIndexParameters &params);
241     angle::Result convertIndexIndirectBuffer(ContextVk *contextVk,
242                                              vk::BufferHelper *srcIndirectBuf,
243                                              vk::BufferHelper *srcIndexBuf,
244                                              vk::BufferHelper *dstIndirectBuf,
245                                              vk::BufferHelper *dstIndexBuf,
246                                              const ConvertIndexIndirectParameters &params);
247 
248     angle::Result convertLineLoopIndexIndirectBuffer(
249         ContextVk *contextVk,
250         vk::BufferHelper *srcIndirectBuffer,
251         vk::BufferHelper *srcIndexBuffer,
252         vk::BufferHelper *dstIndirectBuffer,
253         vk::BufferHelper *dstIndexBuffer,
254         const ConvertLineLoopIndexIndirectParameters &params);
255 
256     angle::Result convertLineLoopArrayIndirectBuffer(
257         ContextVk *contextVk,
258         vk::BufferHelper *srcIndirectBuffer,
259         vk::BufferHelper *dstIndirectBuffer,
260         vk::BufferHelper *dstIndexBuffer,
261         const ConvertLineLoopArrayIndirectParameters &params);
262 
263     angle::Result convertVertexBuffer(ContextVk *contextVk,
264                                       vk::BufferHelper *dst,
265                                       vk::BufferHelper *src,
266                                       const ConvertVertexParameters &params,
267                                       const OffsetAndVertexCounts &additionalOffsetVertexCounts);
268 
269     // EXT_clear_texture
270     angle::Result clearTexture(ContextVk *contextVk,
271                                vk::ImageHelper *dst,
272                                ClearTextureParameters &params);
273 
274     angle::Result clearFramebuffer(ContextVk *contextVk,
275                                    FramebufferVk *framebuffer,
276                                    const ClearFramebufferParameters &params);
277 
278     // Resolve images if multisampled.  Blit otherwise.
279     angle::Result colorBlitResolve(ContextVk *contextVk,
280                                    FramebufferVk *framebuffer,
281                                    vk::ImageHelper *src,
282                                    const vk::ImageView *srcView,
283                                    const BlitResolveParameters &params);
284     angle::Result depthStencilBlitResolve(ContextVk *contextVk,
285                                           FramebufferVk *framebuffer,
286                                           vk::ImageHelper *src,
287                                           const vk::ImageView *srcDepthView,
288                                           const vk::ImageView *srcStencilView,
289                                           const BlitResolveParameters &params);
290     angle::Result stencilBlitResolveNoShaderExport(ContextVk *contextVk,
291                                                    FramebufferVk *framebuffer,
292                                                    vk::ImageHelper *src,
293                                                    const vk::ImageView *srcStencilView,
294                                                    const BlitResolveParameters &params);
295 
296     angle::Result clearImage(ContextVk *contextVk,
297                              vk::ImageHelper *dst,
298                              const ClearImageParameters &params);
299 
300     angle::Result copyImage(ContextVk *contextVk,
301                             vk::ImageHelper *dst,
302                             const vk::ImageView *dstView,
303                             vk::ImageHelper *src,
304                             const vk::ImageView *srcView,
305                             const CopyImageParameters &params);
306 
307     angle::Result copyImageBits(ContextVk *contextVk,
308                                 vk::ImageHelper *dst,
309                                 vk::ImageHelper *src,
310                                 const CopyImageBitsParameters &params);
311 
312     angle::Result copyImageToBuffer(ContextVk *contextVk,
313                                     vk::BufferHelper *dst,
314                                     vk::ImageHelper *src,
315                                     const CopyImageToBufferParameters &params);
316 
317     angle::Result copyRgbToRgba(ContextVk *contextVk,
318                                 const angle::Format &srcFormat,
319                                 vk::BufferHelper *srcBuffer,
320                                 uint32_t srcOffset,
321                                 uint32_t pixelCount,
322                                 vk::BufferHelper *dstBuffer);
323 
324     angle::Result transCodeEtcToBc(ContextVk *contextVk,
325                                    vk::BufferHelper *srcBuffer,
326                                    vk::ImageHelper *dstImage,
327                                    const VkBufferImageCopy *copyRegion);
328 
329     using GenerateMipmapDestLevelViews =
330         std::array<const vk::ImageView *, kGenerateMipmapMaxLevels>;
331     angle::Result generateMipmap(ContextVk *contextVk,
332                                  vk::ImageHelper *src,
333                                  const vk::ImageView *srcLevelZeroView,
334                                  vk::ImageHelper *dst,
335                                  const GenerateMipmapDestLevelViews &dstLevelViews,
336                                  const vk::Sampler &sampler,
337                                  const GenerateMipmapParameters &params);
338     angle::Result generateMipmapWithDraw(ContextVk *contextVk,
339                                          vk::ImageHelper *image,
340                                          const angle::FormatID actualFormatID,
341                                          const bool isMipmapFiltered);
342 
343     angle::Result unresolve(ContextVk *contextVk,
344                             const FramebufferVk *framebuffer,
345                             const UnresolveParameters &params);
346 
347     // Overlay utilities.
348     angle::Result drawOverlay(ContextVk *contextVk,
349                               vk::BufferHelper *textWidgetsBuffer,
350                               vk::BufferHelper *graphWidgetsBuffer,
351                               vk::ImageHelper *font,
352                               const vk::ImageView *fontView,
353                               vk::ImageHelper *dst,
354                               const vk::ImageView *dstView,
355                               const OverlayDrawParameters &params);
356 
357     // Fragment shading rate utility
358     angle::Result generateFragmentShadingRate(
359         ContextVk *contextVk,
360         vk::ImageHelper *shadingRateAttachmentImageHelper,
361         vk::ImageViewHelper *shadingRateAttachmentImageViewHelper,
362         const GenerateFragmentShadingRateParameters &shadingRateParameters);
363 
364   private:
365     ANGLE_ENABLE_STRUCT_PADDING_WARNINGS
366 
367     struct ConvertIndexShaderParams
368     {
369         uint32_t srcOffset     = 0;
370         uint32_t dstOffsetDiv4 = 0;
371         uint32_t maxIndex      = 0;
372         uint32_t _padding      = 0;
373     };
374 
375     struct ConvertIndexIndirectShaderParams
376     {
377         uint32_t srcIndirectOffsetDiv4 = 0;
378         uint32_t srcOffset             = 0;
379         uint32_t dstOffsetDiv4         = 0;
380         uint32_t maxIndex              = 0;
381         uint32_t dstIndirectOffsetDiv4 = 0;
382     };
383 
384     struct ConvertIndexIndirectLineLoopShaderParams
385     {
386         uint32_t cmdOffsetDiv4    = 0;
387         uint32_t dstCmdOffsetDiv4 = 0;
388         uint32_t srcOffset        = 0;
389         uint32_t dstOffsetDiv4    = 0;
390         uint32_t isRestartEnabled = 0;
391     };
392 
393     struct ConvertIndirectLineLoopShaderParams
394     {
395         uint32_t cmdOffsetDiv4    = 0;
396         uint32_t dstCmdOffsetDiv4 = 0;
397         uint32_t dstOffsetDiv4    = 0;
398     };
399 
400     struct ConvertVertexShaderParams
401     {
402         ConvertVertexShaderParams();
403 
404         // Structure matching PushConstants in ConvertVertex.comp
405         uint32_t outputCount      = 0;
406         uint32_t componentCount   = 0;
407         uint32_t srcOffset        = 0;
408         uint32_t dstOffset        = 0;
409         uint32_t Ns               = 0;
410         uint32_t Bs               = 0;
411         uint32_t Ss               = 0;
412         uint32_t Es               = 0;
413         uint32_t Nd               = 0;
414         uint32_t Bd               = 0;
415         uint32_t Sd               = 0;
416         uint32_t Ed               = 0;
417         uint32_t srcEmulatedAlpha = 0;
418         uint32_t isSrcHDR         = 0;
419         uint32_t isSrcA2BGR10     = 0;
420         uint32_t _padding         = 0;
421     };
422 
423     struct ImageClearShaderParams
424     {
425         // Structure matching PushConstants in ImageClear.frag
426         VkClearColorValue clearValue = {};
427         float clearDepth             = 0.0f;
428     };
429 
430     struct ImageCopyShaderParams
431     {
432         ImageCopyShaderParams();
433 
434         // Structure matching PushConstants in ImageCopy.frag
435         int32_t srcOffset[2]            = {};
436         int32_t dstOffset[2]            = {};
437         int32_t srcMip                  = 0;
438         int32_t srcLayer                = 0;
439         int32_t srcSampleCount          = 0;
440         uint32_t flipX                  = 0;
441         uint32_t flipY                  = 0;
442         uint32_t premultiplyAlpha       = 0;
443         uint32_t unmultiplyAlpha        = 0;
444         uint32_t dstHasLuminance        = 0;
445         uint32_t dstIsAlpha             = 0;
446         uint32_t srcIsSRGB              = 0;
447         uint32_t dstIsSRGB              = 0;
448         uint32_t dstDefaultChannelsMask = 0;
449         uint32_t rotateXY               = 0;
450     };
451 
452     struct CopyImageToBufferShaderParams
453     {
454         // Structure matching PushConstants in CopyImageToBuffer.comp
455         int32_t srcOffset[2]     = {};
456         int32_t srcDepth         = 0;
457         uint32_t reverseRowOrder = 0;
458         uint32_t size[2]         = {};
459         uint32_t outputOffset    = 0;
460         uint32_t outputPitch     = 0;
461         uint32_t isDstSnorm      = 0;
462     };
463 
464     union BlitResolveOffset
465     {
466         int32_t resolve[2];
467         float blit[2];
468     };
469 
470     struct BlitResolveShaderParams
471     {
472         // Structure matching PushConstants in BlitResolve.frag
473         BlitResolveOffset offset = {};
474         float stretch[2]         = {};
475         float invSrcExtent[2]    = {};
476         int32_t srcLayer         = 0;
477         int32_t samples          = 0;
478         float invSamples         = 0;
479         uint32_t outputMask      = 0;
480         uint32_t flipX           = 0;
481         uint32_t flipY           = 0;
482         uint32_t rotateXY        = 0;
483     };
484 
485     struct BlitResolveStencilNoExportShaderParams
486     {
487         // Structure matching PushConstants in BlitResolveStencilNoExport.comp
488         BlitResolveOffset offset = {};
489         float stretch[2]         = {};
490         float invSrcExtent[2]    = {};
491         int32_t srcLayer         = 0;
492         int32_t srcWidth         = 0;
493         int32_t blitArea[4]      = {};
494         int32_t dstPitch         = 0;
495         uint32_t flipX           = 0;
496         uint32_t flipY           = 0;
497         uint32_t rotateXY        = 0;
498     };
499 
500     struct ExportStencilShaderParams
501     {
502         uint32_t bit = 0;
503     };
504 
505     struct OverlayDrawShaderParams
506     {
507         // Structure matching PushConstants in OverlayDraw.vert and OverlayDraw.frag
508         uint32_t viewportSize[2] = {};
509         uint32_t isText          = 0;
510         uint32_t rotateXY        = 0;
511     };
512 
513     struct GenerateMipmapShaderParams
514     {
515         // Structure matching PushConstants in GenerateMipmap.comp
516         float invSrcExtent[2] = {};
517         uint32_t levelCount   = 0;
518     };
519 
520     struct EtcToBcShaderParams
521     {
522         uint32_t offsetX;
523         uint32_t offsetY;
524         int32_t texelOffset;
525         uint32_t width;
526         uint32_t height;
527         uint32_t alphaBits;
528         uint32_t isSigned;
529         uint32_t isEacRg;
530     };
531 
532     ANGLE_DISABLE_STRUCT_PADDING_WARNINGS
533 
534     // Functions implemented by the class:
535     enum class Function
536     {
537         // Functions implemented in graphics
538         ImageClear,
539         ImageCopy,
540         BlitResolve,
541         Blit3DSrc,
542         ExportStencil,
543         OverlayDraw,
544         // Note: unresolve is special as it has a different layout per attachment count.  Depth and
545         // stencil each require a binding, so are counted separately.
546         Unresolve1Attachment,
547         Unresolve2Attachments,
548         Unresolve3Attachments,
549         Unresolve4Attachments,
550         Unresolve5Attachments,
551         Unresolve6Attachments,
552         Unresolve7Attachments,
553         Unresolve8Attachments,
554         Unresolve9Attachments,
555         Unresolve10Attachments,
556 
557         // Functions implemented in compute
558         ComputeStartIndex,  // Special value to separate draw and dispatch functions.
559         ConvertIndexBuffer = ComputeStartIndex,
560         ConvertVertexBuffer,
561         ClearTexture,
562         BlitResolveStencilNoExport,
563         ConvertIndexIndirectBuffer,
564         ConvertIndexIndirectLineLoopBuffer,
565         ConvertIndirectLineLoopBuffer,
566         GenerateMipmap,
567         TransCodeEtcToBc,
568         CopyImageToBuffer,
569         GenerateFragmentShadingRate,
570 
571         InvalidEnum,
572         EnumCount = InvalidEnum,
573     };
574 
575     struct GraphicsShaderProgramAndPipelines
576     {
577         vk::ShaderProgramHelper program;
578         CompleteGraphicsPipelineCache pipelines;
579     };
580     struct ComputeShaderProgramAndPipelines
581     {
582         vk::ShaderProgramHelper program;
583         vk::ComputePipelineCache pipelines;
584     };
585 
586     // Common functions that create the pipeline for the specified function, binds it and prepares
587     // the draw/dispatch call.
588     angle::Result setupComputeProgram(
589         ContextVk *contextVk,
590         Function function,
591         const vk::ShaderModulePtr &csShader,
592         ComputeShaderProgramAndPipelines *programAndPipelines,
593         const VkDescriptorSet descriptorSet,
594         const void *pushConstants,
595         size_t pushConstantsSize,
596         vk::OutsideRenderPassCommandBufferHelper *commandBufferHelper);
597     angle::Result setupGraphicsProgramWithLayout(
598         ContextVk *contextVk,
599         const vk::PipelineLayout &pipelineLayout,
600         const vk::ShaderModulePtr &vsShader,
601         const vk::ShaderModulePtr &fsShader,
602         GraphicsShaderProgramAndPipelines *programAndPipelines,
603         const vk::GraphicsPipelineDesc *pipelineDesc,
604         const VkDescriptorSet descriptorSet,
605         const void *pushConstants,
606         size_t pushConstantsSize,
607         vk::RenderPassCommandBuffer *commandBuffer);
608     angle::Result setupGraphicsProgram(ContextVk *contextVk,
609                                        Function function,
610                                        const vk::ShaderModulePtr &vsShader,
611                                        const vk::ShaderModulePtr &fsShader,
612                                        GraphicsShaderProgramAndPipelines *programAndPipelines,
613                                        const vk::GraphicsPipelineDesc *pipelineDesc,
614                                        const VkDescriptorSet descriptorSet,
615                                        const void *pushConstants,
616                                        size_t pushConstantsSize,
617                                        vk::RenderPassCommandBuffer *commandBuffer);
618 
619     // Initializes descriptor set layout, pipeline layout and descriptor pool corresponding to given
620     // function, if not already initialized.  Uses setSizes to create the layout.  For example, if
621     // this array has two entries {STORAGE_TEXEL_BUFFER, 1} and {UNIFORM_TEXEL_BUFFER, 3}, then the
622     // created set layout would be binding 0 for storage texel buffer and bindings 1 through 3 for
623     // uniform texel buffer.  All resources are put in set 0.
624     angle::Result ensureResourcesInitialized(ContextVk *contextVk,
625                                              Function function,
626                                              VkDescriptorPoolSize *setSizes,
627                                              size_t setSizesCount,
628                                              size_t pushConstantsSize);
629 
630     // Initializers corresponding to functions, calling into ensureResourcesInitialized with the
631     // appropriate parameters.
632     angle::Result ensureConvertIndexResourcesInitialized(ContextVk *contextVk);
633     angle::Result ensureConvertIndexIndirectResourcesInitialized(ContextVk *contextVk);
634     angle::Result ensureConvertIndexIndirectLineLoopResourcesInitialized(ContextVk *contextVk);
635     angle::Result ensureConvertIndirectLineLoopResourcesInitialized(ContextVk *contextVk);
636     angle::Result ensureConvertVertexResourcesInitialized(ContextVk *contextVk);
637     angle::Result ensureImageClearResourcesInitialized(ContextVk *contextVk);
638     angle::Result ensureImageCopyResourcesInitialized(ContextVk *contextVk);
639     angle::Result ensureCopyImageToBufferResourcesInitialized(ContextVk *contextVk);
640     angle::Result ensureBlitResolveResourcesInitialized(ContextVk *contextVk);
641     angle::Result ensureBlitResolveStencilNoExportResourcesInitialized(ContextVk *contextVk);
642     angle::Result ensureExportStencilResourcesInitialized(ContextVk *contextVk);
643     angle::Result ensureOverlayDrawResourcesInitialized(ContextVk *contextVk);
644     angle::Result ensureGenerateMipmapResourcesInitialized(ContextVk *contextVk);
645     angle::Result ensureTransCodeEtcToBcResourcesInitialized(ContextVk *contextVk);
646     angle::Result ensureUnresolveResourcesInitialized(ContextVk *contextVk,
647                                                       Function function,
648                                                       uint32_t attachmentIndex);
649 
650     angle::Result ensureImageCopyResourcesInitializedWithSampler(
651         ContextVk *contextVk,
652         const vk::SamplerDesc &samplerDesc);
653 
654     angle::Result ensureSamplersInitialized(ContextVk *context);
655 
656     angle::Result ensureGenerateFragmentShadingRateResourcesInitialized(ContextVk *contextVk);
657 
658     angle::Result startRenderPass(ContextVk *contextVk,
659                                   vk::ImageHelper *image,
660                                   const vk::ImageView *imageView,
661                                   const vk::RenderPassDesc &renderPassDesc,
662                                   const gl::Rectangle &renderArea,
663                                   const VkImageAspectFlags aspectFlags,
664                                   const VkClearValue *clearValue,
665                                   vk::RenderPassSource renderPassSource,
666                                   vk::RenderPassCommandBuffer **commandBufferOut);
667 
668     // Set up descriptor set and call dispatch.
669     angle::Result convertVertexBufferImpl(
670         ContextVk *contextVk,
671         vk::BufferHelper *dst,
672         vk::BufferHelper *src,
673         uint32_t flags,
674         vk::OutsideRenderPassCommandBufferHelper *commandBufferHelper,
675         const ConvertVertexShaderParams &shaderParams,
676         const OffsetAndVertexCounts &additionalOffsetVertexCounts);
677 
678     // Blits or resolves either color or depth/stencil, based on which view is given.
679     angle::Result blitResolveImpl(ContextVk *contextVk,
680                                   FramebufferVk *framebuffer,
681                                   vk::ImageHelper *src,
682                                   const vk::ImageView *srcColorView,
683                                   const vk::ImageView *srcDepthView,
684                                   const vk::ImageView *srcStencilView,
685                                   const BlitResolveParameters &params);
686 
687     // Allocates a single descriptor set.
688     angle::Result allocateDescriptorSetWithLayout(
689         ContextVk *contextVk,
690         vk::CommandBufferHelperCommon *commandBufferHelper,
691         vk::DynamicDescriptorPool &descriptorPool,
692         const vk::DescriptorSetLayout &descriptorSetLayout,
693         VkDescriptorSet *descriptorSetOut);
694 
695     angle::Result allocateDescriptorSet(ContextVk *contextVk,
696                                         vk::CommandBufferHelperCommon *commandBufferHelper,
697                                         Function function,
698                                         VkDescriptorSet *descriptorSetOut);
699 
700     angle::Result allocateDescriptorSetForImageCopyWithSampler(
701         ContextVk *contextVk,
702         vk::CommandBufferHelperCommon *commandBufferHelper,
703         const vk::SamplerDesc &samplerDesc,
704         VkDescriptorSet *descriptorSetOut);
705 
706     angle::PackedEnumMap<Function, vk::DescriptorSetLayoutPointerArray> mDescriptorSetLayouts;
707     angle::PackedEnumMap<Function, vk::PipelineLayoutPtr> mPipelineLayouts;
708     angle::PackedEnumMap<Function, vk::DynamicDescriptorPool> mDescriptorPools;
709 
710     std::unordered_map<vk::SamplerDesc, vk::DescriptorSetLayoutPointerArray>
711         mImageCopyWithSamplerDescriptorSetLayouts;
712     std::unordered_map<vk::SamplerDesc, vk::PipelineLayoutPtr> mImageCopyWithSamplerPipelineLayouts;
713     std::unordered_map<vk::SamplerDesc, vk::DynamicDescriptorPool>
714         mImageCopyWithSamplerDescriptorPools;
715 
716     ComputeShaderProgramAndPipelines
717         mConvertIndex[vk::InternalShader::ConvertIndex_comp::kArrayLen];
718     ComputeShaderProgramAndPipelines mConvertIndexIndirectLineLoop
719         [vk::InternalShader::ConvertIndexIndirectLineLoop_comp::kArrayLen];
720     ComputeShaderProgramAndPipelines
721         mConvertIndirectLineLoop[vk::InternalShader::ConvertIndirectLineLoop_comp::kArrayLen];
722     ComputeShaderProgramAndPipelines
723         mConvertVertex[vk::InternalShader::ConvertVertex_comp::kArrayLen];
724     GraphicsShaderProgramAndPipelines mImageClearVSOnly;
725     GraphicsShaderProgramAndPipelines mImageClear[vk::InternalShader::ImageClear_frag::kArrayLen];
726     GraphicsShaderProgramAndPipelines mImageCopy[vk::InternalShader::ImageCopy_frag::kArrayLen];
727     GraphicsShaderProgramAndPipelines mImageCopyFloat;
728     std::unordered_map<vk::SamplerDesc, GraphicsShaderProgramAndPipelines> mImageCopyWithSampler;
729     ComputeShaderProgramAndPipelines
730         mCopyImageToBuffer[vk::InternalShader::CopyImageToBuffer_comp::kArrayLen];
731     GraphicsShaderProgramAndPipelines mBlitResolve[vk::InternalShader::BlitResolve_frag::kArrayLen];
732     GraphicsShaderProgramAndPipelines mBlit3DSrc[vk::InternalShader::Blit3DSrc_frag::kArrayLen];
733     ComputeShaderProgramAndPipelines
734         mBlitResolveStencilNoExport[vk::InternalShader::BlitResolveStencilNoExport_comp::kArrayLen];
735     GraphicsShaderProgramAndPipelines mExportStencil;
736     GraphicsShaderProgramAndPipelines mOverlayDraw;
737     ComputeShaderProgramAndPipelines
738         mGenerateMipmap[vk::InternalShader::GenerateMipmap_comp::kArrayLen];
739     ComputeShaderProgramAndPipelines mEtcToBc[vk::InternalShader::EtcToBc_comp::kArrayLen];
740 
741     // Unresolve shaders are special as they are generated on the fly due to the large number of
742     // combinations.
743     std::unordered_map<uint32_t, vk::ShaderModulePtr> mUnresolveFragShaders;
744     std::unordered_map<uint32_t, GraphicsShaderProgramAndPipelines> mUnresolve;
745 
746     ComputeShaderProgramAndPipelines mGenerateFragmentShadingRateAttachment;
747 
748     vk::Sampler mPointSampler;
749     vk::Sampler mLinearSampler;
750 };
751 
752 // This class' responsibility is to create index buffers needed to support line loops in Vulkan.
753 // In the setup phase of drawing, the createIndexBuffer method should be called with the
754 // current draw call parameters. If an element array buffer is bound for an indexed draw, use
755 // createIndexBufferFromElementArrayBuffer.
756 //
757 // If the user wants to draw a loop between [v1, v2, v3], we will create an indexed buffer with
758 // these indexes: [0, 1, 2, 3, 0] to emulate the loop.
759 class LineLoopHelper final : angle::NonCopyable
760 {
761   public:
762     LineLoopHelper(vk::Renderer *renderer);
763     ~LineLoopHelper();
764 
765     angle::Result getIndexBufferForDrawArrays(ContextVk *contextVk,
766                                               uint32_t clampedVertexCount,
767                                               GLint firstVertex,
768                                               vk::BufferHelper **bufferOut);
769 
770     angle::Result getIndexBufferForElementArrayBuffer(ContextVk *contextVk,
771                                                       BufferVk *elementArrayBufferVk,
772                                                       gl::DrawElementsType glIndexType,
773                                                       int indexCount,
774                                                       intptr_t elementArrayOffset,
775                                                       vk::BufferHelper **bufferOut,
776                                                       uint32_t *indexCountOut);
777 
778     angle::Result streamIndices(ContextVk *contextVk,
779                                 gl::DrawElementsType glIndexType,
780                                 GLsizei indexCount,
781                                 const uint8_t *srcPtr,
782                                 vk::BufferHelper **bufferOut,
783                                 uint32_t *indexCountOut);
784 
785     angle::Result streamIndicesIndirect(ContextVk *contextVk,
786                                         gl::DrawElementsType glIndexType,
787                                         vk::BufferHelper *indexBuffer,
788                                         vk::BufferHelper *indirectBuffer,
789                                         VkDeviceSize indirectBufferOffset,
790                                         vk::BufferHelper **indexBufferOut,
791                                         vk::BufferHelper **indirectBufferOut);
792 
793     angle::Result streamArrayIndirect(ContextVk *contextVk,
794                                       size_t vertexCount,
795                                       vk::BufferHelper *arrayIndirectBuffer,
796                                       VkDeviceSize arrayIndirectBufferOffset,
797                                       vk::BufferHelper **indexBufferOut,
798                                       vk::BufferHelper **indexIndirectBufferOut);
799 
800     void release(ContextVk *contextVk);
801     void destroy(vk::Renderer *renderer);
802 
getCurrentIndexBuffer()803     vk::BufferHelper *getCurrentIndexBuffer() { return mDynamicIndexBuffer.getBuffer(); }
804 
Draw(uint32_t count,uint32_t baseVertex,vk::RenderPassCommandBuffer * commandBuffer)805     static void Draw(uint32_t count,
806                      uint32_t baseVertex,
807                      vk::RenderPassCommandBuffer *commandBuffer)
808     {
809         // Our first index is always 0 because that's how we set it up in createIndexBuffer*.
810         commandBuffer->drawIndexedBaseVertex(count, baseVertex);
811     }
812 
813   private:
814     ConversionBuffer mDynamicIndexBuffer;
815     ConversionBuffer mDynamicIndirectBuffer;
816 };
817 }  // namespace rx
818 
819 #endif  // LIBANGLE_RENDERER_VULKAN_UTILSVK_H_
820