feat(renderer): Convert "ImageDrawUniforms" to "ImageDrawInstance" (#12990) bb61acd900 This is just step 1: send the data for imageRects and imageMeshes via instanced vertex attribs instead of uniforms. This removes the need to re-bind uniform buffers and offsets for every image draw, and in the future (step 2), it will enable batching image draws via instanced draw calls. This is especially important for things like particle systems. Co-authored-by: Chris Dalton <99840794+csmartdalton@users.noreply.github.com>
diff --git a/.rive_head b/.rive_head index 6dc57e5..3dcf24a 100644 --- a/.rive_head +++ b/.rive_head
@@ -1 +1 @@ -cf605e8083b02b5517324dbc022faba0b5f03635 +bb61acd90005795dc12c6c7a40d8f0302f158d4a
diff --git a/renderer/include/rive/renderer/d3d/d3d_constants.hpp b/renderer/include/rive/renderer/d3d/d3d_constants.hpp index 4cf1746..0dd25c9 100644 --- a/renderer/include/rive/renderer/d3d/d3d_constants.hpp +++ b/renderer/include/rive/renderer/d3d/d3d_constants.hpp
@@ -15,4 +15,5 @@ constexpr static UINT IMAGE_RECT_VERTEX_DATA_SLOT = 2; constexpr static UINT IMAGE_MESH_VERTEX_DATA_SLOT = 3; constexpr static UINT IMAGE_MESH_UV_DATA_SLOT = 4; -} // namespace rive::gpu \ No newline at end of file +constexpr static UINT IMAGE_DRAW_INSTANCE_DATA_SLOT = 5; +} // namespace rive::gpu
diff --git a/renderer/include/rive/renderer/d3d11/render_context_d3d_impl.hpp b/renderer/include/rive/renderer/d3d11/render_context_d3d_impl.hpp index 29b00c6..60558f7 100644 --- a/renderer/include/rive/renderer/d3d11/render_context_d3d_impl.hpp +++ b/renderer/include/rive/renderer/d3d11/render_context_d3d_impl.hpp
@@ -293,7 +293,6 @@ ComPtr<ID3D11Buffer> m_flushUniforms; ComPtr<ID3D11Buffer> m_drawUniforms; - ComPtr<ID3D11Buffer> m_imageDrawUniforms; ComPtr<ID3D11SamplerState> m_linearSampler; ComPtr<ID3D11SamplerState>
diff --git a/renderer/include/rive/renderer/d3d12/d3d12_pipeline_manager.hpp b/renderer/include/rive/renderer/d3d12/d3d12_pipeline_manager.hpp index 5de08bc..48dc822 100644 --- a/renderer/include/rive/renderer/d3d12/d3d12_pipeline_manager.hpp +++ b/renderer/include/rive/renderer/d3d12/d3d12_pipeline_manager.hpp
@@ -5,6 +5,7 @@ #include "rive/renderer/d3d12/d3d12.hpp" #include "rive/renderer/d3d/pipeline_manager.hpp" #include "rive/renderer/gpu.hpp" +#include "rive/renderer/stack_vector.hpp" namespace rive::gpu { @@ -12,8 +13,9 @@ // states struct D3D12DrawVertexShader { - D3D12_INPUT_ELEMENT_DESC m_layoutDesc[2]; - uint32_t m_vertexAttribCount; + StackVector<D3D12_INPUT_ELEMENT_DESC, + gpu::ImageDrawInstance::LastAttribIdx + 1> + m_layoutDesc; ComPtr<ID3DBlob> m_shader; }; @@ -101,4 +103,4 @@ ComPtr<ID3D12RootSignature> m_rootSignature; }; -} // namespace rive::gpu \ No newline at end of file +} // namespace rive::gpu
diff --git a/renderer/include/rive/renderer/d3d12/d3d12_utils.hpp b/renderer/include/rive/renderer/d3d12/d3d12_utils.hpp index 37dd825..c7729d4 100644 --- a/renderer/include/rive/renderer/d3d12/d3d12_utils.hpp +++ b/renderer/include/rive/renderer/d3d12/d3d12_utils.hpp
@@ -564,8 +564,8 @@ D3D12ResourceManager* d3d() const; constexpr static size_t MAX_POOL_SIZE = 8; - UINT m_targetSize; UINT m_alignment; + UINT m_targetSize; }; class D3D12DescriptorHeapPool : public GPUResourcePool
diff --git a/renderer/include/rive/renderer/d3d12/render_context_d3d12_impl.hpp b/renderer/include/rive/renderer/d3d12/render_context_d3d12_impl.hpp index 7b6468e..0a608ff 100644 --- a/renderer/include/rive/renderer/d3d12/render_context_d3d12_impl.hpp +++ b/renderer/include/rive/renderer/d3d12/render_context_d3d12_impl.hpp
@@ -165,7 +165,6 @@ } IMPLEMENT_RIVE_BUFFER(FlushUniformBuffer, m_flushUniformBuffer) - IMPLEMENT_RIVE_BUFFER(ImageDrawUniformBuffer, m_imageDrawUniformBuffer) IMPLEMENT_RIVE_STRUCTURED_BUFFER(PathBuffer, m_pathBuffer) IMPLEMENT_RIVE_STRUCTURED_BUFFER(PaintBuffer, m_paintBuffer) IMPLEMENT_RIVE_STRUCTURED_BUFFER(PaintAuxBuffer, m_paintAuxBuffer) @@ -173,6 +172,7 @@ IMPLEMENT_RIVE_BUFFER(GradSpanBuffer, m_gradSpanBuffer) IMPLEMENT_RIVE_BUFFER(TessVertexSpanBuffer, m_tessSpanBuffer) IMPLEMENT_RIVE_BUFFER(TriangleVertexBuffer, m_triangleBuffer) + IMPLEMENT_RIVE_BUFFER(ImageDrawInstanceBuffer, m_imageDrawInstanceBuffer) #undef IMPLEMENT_RIVE_BUFFER #undef IMPLEMENT_RIVE_STRUCTURED_BUFFER @@ -239,7 +239,6 @@ // Rive buffer pools. These don't need to be rcp<> because the destructor of // RenderContextVulkanImpl is already synchronized. D3D12VolatileBufferPool m_flushUniformBufferPool; - D3D12VolatileBufferPool m_imageDrawUniformBufferPool; D3D12VolatileBufferPool m_pathBufferPool; D3D12VolatileBufferPool m_paintBufferPool; D3D12VolatileBufferPool m_paintAuxBufferPool; @@ -247,6 +246,7 @@ D3D12VolatileBufferPool m_gradSpanBufferPool; D3D12VolatileBufferPool m_tessSpanBufferPool; D3D12VolatileBufferPool m_triangleBufferPool; + D3D12VolatileBufferPool m_imageDrawInstanceBufferPool; // this have to be re created every frame, rtv heaps do not D3D12DescriptorHeapPool m_srvUavCbvHeapPool; @@ -255,7 +255,6 @@ // Specific Rive buffers that have been acquired for the current frame. // When the frame ends, these get recycled back in their respective pools. rcp<D3D12VolatileBuffer> m_flushUniformBuffer; - rcp<D3D12VolatileBuffer> m_imageDrawUniformBuffer; rcp<D3D12VolatileBuffer> m_pathBuffer; rcp<D3D12VolatileBuffer> m_paintBuffer; rcp<D3D12VolatileBuffer> m_paintAuxBuffer; @@ -263,6 +262,7 @@ rcp<D3D12VolatileBuffer> m_gradSpanBuffer; rcp<D3D12VolatileBuffer> m_tessSpanBuffer; rcp<D3D12VolatileBuffer> m_triangleBuffer; + rcp<D3D12VolatileBuffer> m_imageDrawInstanceBuffer; rcp<D3D12DescriptorHeap> m_srvUavCbvHeap; // mirrors m_srvUavCbvHeap, needed for clearing resourcess via ClearUAV
diff --git a/renderer/include/rive/renderer/gpu.hpp b/renderer/include/rive/renderer/gpu.hpp index f831f3c..9b5282b 100644 --- a/renderer/include/rive/renderer/gpu.hpp +++ b/renderer/include/rive/renderer/gpu.hpp
@@ -713,72 +713,6 @@ RIVE_UNREACHABLE(); } -constexpr static uint32_t PatchIndexCount(DrawType drawType) -{ - switch (drawType) - { - case DrawType::midpointFanPatches: - return kMidpointFanPatchIndexCount; - case DrawType::midpointFanCenterAAPatches: - return kMidpointFanCenterAAPatchIndexCount; - case DrawType::outerCurvePatches: - return kOuterCurvePatchIndexCount; - case DrawType::msaaStrokes: - return kMidpointFanPatchBorderIndexCount; - case DrawType::msaaMidpointFanBorrowedCoverage: - case DrawType::msaaMidpointFans: - case DrawType::msaaMidpointFanStencilReset: - case DrawType::msaaMidpointFanPathsStencil: - case DrawType::msaaMidpointFanPathsCover: - return kMidpointFanPatchIndexCount - - kMidpointFanPatchBorderIndexCount; - case DrawType::msaaOuterCubics: - return kOuterCurvePatchIndexCount - - kOuterCurvePatchBorderIndexCount; - case DrawType::interiorTriangulation: - case DrawType::atlasBlit: - case DrawType::imageRect: - case DrawType::imageMesh: - case DrawType::clipReset: - case DrawType::renderPassInitialize: - case DrawType::renderPassResolve: - RIVE_UNREACHABLE(); - } - RIVE_UNREACHABLE(); -} - -constexpr static uint32_t PatchBaseIndex(DrawType drawType) -{ - switch (drawType) - { - case DrawType::midpointFanPatches: - case DrawType::msaaStrokes: - return kMidpointFanPatchBaseIndex; - case DrawType::midpointFanCenterAAPatches: - return kMidpointFanCenterAAPatchBaseIndex; - case DrawType::outerCurvePatches: - return kOuterCurvePatchBaseIndex; - case DrawType::msaaMidpointFanBorrowedCoverage: - case DrawType::msaaMidpointFans: - case DrawType::msaaMidpointFanStencilReset: - case DrawType::msaaMidpointFanPathsStencil: - case DrawType::msaaMidpointFanPathsCover: - return kMidpointFanPatchBaseIndex + - kMidpointFanPatchBorderIndexCount; - case DrawType::msaaOuterCubics: - return kOuterCurvePatchBaseIndex + kOuterCurvePatchBorderIndexCount; - case DrawType::interiorTriangulation: - case DrawType::atlasBlit: - case DrawType::imageRect: - case DrawType::imageMesh: - case DrawType::clipReset: - case DrawType::renderPassInitialize: - case DrawType::renderPassResolve: - RIVE_UNREACHABLE(); - } - RIVE_UNREACHABLE(); -} - // Specifies what to do with the render target at the beginning of a flush. enum class LoadAction { @@ -1203,8 +1137,15 @@ const DrawType drawType; ShaderMiscFlags shaderMiscFlags; DrawContents drawContents; - uint32_t elementCount; // Vertex, index, or instance count. - uint32_t baseElement; // Base vertex, index, or instance. + // elementCount/baseElement are the "splice axis": the run that grows when + // adjacent batches combine. For instanced draws (paths, image draws) that + // is instances; for non-indexed triangle runs (interiorTriangulation, + // atlasBlit, clipReset) it is vertices. + uint32_t elementCount; // Instance count, or vertex count for triangle runs. + uint32_t baseElement; // Base instance, or base vertex for triangle runs. + // Geometry parameters for indexed-instanced types (paths and image draws). + uint32_t indexCountPerInstance = 0; + uint32_t baseIndex = 0; rive::BlendMode firstBlendMode; BarrierFlags barriers; // Barriers to execute before drawing this batch. std::optional<AABBu16> scissorRect; @@ -1212,7 +1153,6 @@ ShaderFeatures shaderFeatures = ShaderFeatures::NONE; // DrawType::imageRect and DrawType::imageMesh. - uint32_t imageDrawDataOffset = 0; Texture* imageTexture = nullptr; const ImageSampler imageSampler = ImageSampler::LinearClamp(); @@ -1697,13 +1637,23 @@ }; static_assert(sizeof(TriangleVertex) == sizeof(float) * 3); -// Per-draw uniforms used by image meshes. -struct ImageDrawUniforms +// Per-draw instanced attributes used by imageMeshes and imageRects. +struct ImageDrawInstance { public: - ImageDrawUniforms() = default; + // This data is bound to image shaders as 4 tightly-packed instanced + // attributes. The vertex shader unpacks them. + // attr 2 (float4): viewMatrix (2x2) + // attr 3 (float4): clipRectInverseMatrix (2x2) + // attr 4 (float4): translates for view & clipRectInverseMatrix + // attr 5 (uint4) : opacity (uintBitsToFloat), clipID, blendMode, zIndex + constexpr static size_t FirstAttribIdx = 2; + constexpr static size_t LastAttribIdx = 5; + constexpr static size_t AttribCount = LastAttribIdx + 1 - FirstAttribIdx; - ImageDrawUniforms(const Mat2D&, + ImageDrawInstance() = default; + + ImageDrawInstance(const Mat2D&, float opacity, const ClipRectInverseMatrix*, uint32_t clipID, @@ -1711,23 +1661,14 @@ uint32_t zIndex); private: - WRITEONLY float m_matrix[6]; + WRITEONLY float m_viewMatrix[4]; + WRITEONLY float m_clipRectInverseMatrix[4]; + WRITEONLY float m_translate[2]; + WRITEONLY float m_clipRectInverseTranslate[2]; WRITEONLY float m_opacity; - WRITEONLY float m_padding = 0; - WRITEONLY float m_clipRectInverseMatrix[6]; WRITEONLY uint32_t m_clipID; WRITEONLY uint32_t m_blendMode; - WRITEONLY uint32_t m_zIndex; // gpu::InterlockMode::msaa only. - // Uniform blocks must be multiples of 256 bytes in size. - WRITEONLY uint8_t m_padTo256Bytes[256 - 68]; - - constexpr void staticChecks() - { - static_assert(offsetof(ImageDrawUniforms, m_matrix) % 16 == 0); - static_assert( - offsetof(ImageDrawUniforms, m_clipRectInverseMatrix) % 16 == 0); - static_assert(sizeof(ImageDrawUniforms) == 256); - } + WRITEONLY uint32_t m_zIndex; }; #undef WRITEONLY
diff --git a/renderer/include/rive/renderer/gpu_resource.hpp b/renderer/include/rive/renderer/gpu_resource.hpp index 5fc3c65..b71a56b 100644 --- a/renderer/include/rive/renderer/gpu_resource.hpp +++ b/renderer/include/rive/renderer/gpu_resource.hpp
@@ -93,6 +93,14 @@ uint64_t m_currentFrameNumber = 0; uint64_t m_safeFrameNumber = 0; + // False until advanceFrameNumber() has been called at least once (including + // the shutdown transition). While false we're in the pre-first-frame + // window, where m_currentFrameNumber == m_safeFrameNumber == 0 -- otherwise + // indistinguishable from a GPU-caught-up state -- but a one-shot upload + // submitted during initialization can leave GPU work referencing a + // just-released staging resource, so such releases must go to purgatory. + bool m_didAdvanceFrameNumber = false; + // Temporary container for GPUResource instances that have been fully // released, but need to persist until their safe frame number is reached. std::deque<ZombieResource> m_resourcePurgatory;
diff --git a/renderer/include/rive/renderer/render_context.hpp b/renderer/include/rive/renderer/render_context.hpp index 75fc92f..dab3b45 100644 --- a/renderer/include/rive/renderer/render_context.hpp +++ b/renderer/include/rive/renderer/render_context.hpp
@@ -17,7 +17,6 @@ #include "rive/renderer/trivial_block_allocator.hpp" #include "rive/shapes/paint/color.hpp" #include <array> -#include <optional> #include <unordered_map> class PushRetrofittedTrianglesGMDraw; @@ -358,7 +357,6 @@ } size_t flushUniformBufferCount = 0; - size_t imageDrawUniformBufferCount = 0; size_t pathBufferCount = 0; size_t paintBufferCount = 0; size_t paintAuxBufferCount = 0; @@ -366,6 +364,7 @@ size_t gradSpanBufferCount = 0; size_t tessSpanBufferCount = 0; size_t triangleVertexBufferCount = 0; + size_t imageDrawInstanceBufferCount = 0; size_t gradTextureHeight = 0; size_t tessTextureHeight = 0; size_t atlasTextureWidth = 0; @@ -452,7 +451,7 @@ WriteOnlyMappedMemory<gpu::GradientSpan> m_gradSpanData; WriteOnlyMappedMemory<gpu::TessVertexSpan> m_tessSpanData; WriteOnlyMappedMemory<gpu::TriangleVertex> m_triangleVertexData; - WriteOnlyMappedMemory<gpu::ImageDrawUniforms> m_imageDrawUniformData; + WriteOnlyMappedMemory<gpu::ImageDrawInstance> m_imageDrawInstanceData; // Simple allocator for trivially-destructible data that needs to persist // until the current frame has completed. All memory in this allocator is
diff --git a/renderer/include/rive/renderer/render_context_helper_impl.hpp b/renderer/include/rive/renderer/render_context_helper_impl.hpp index 259bde1..2fc091d 100644 --- a/renderer/include/rive/renderer/render_context_helper_impl.hpp +++ b/renderer/include/rive/renderer/render_context_helper_impl.hpp
@@ -15,7 +15,6 @@ { public: void resizeFlushUniformBuffer(size_t sizeInBytes) override; - void resizeImageDrawUniformBuffer(size_t sizeInBytes) override; void resizePathBuffer(size_t sizeInBytes, gpu::StorageBufferStructure) override; void resizePaintBuffer(size_t sizeInBytes, @@ -27,9 +26,9 @@ void resizeGradSpanBuffer(size_t sizeInBytes) override; void resizeTessVertexSpanBuffer(size_t sizeInBytes) override; void resizeTriangleVertexBuffer(size_t sizeInBytes) override; + void resizeImageDrawInstanceBuffer(size_t sizeInBytes) override; void* mapFlushUniformBuffer(size_t mapSizeInBytes) override; - void* mapImageDrawUniformBuffer(size_t mapSizeInBytes) override; void* mapPathBuffer(size_t mapSizeInBytes) override; void* mapPaintBuffer(size_t mapSizeInBytes) override; void* mapPaintAuxBuffer(size_t mapSizeInBytes) override; @@ -37,9 +36,9 @@ void* mapGradSpanBuffer(size_t mapSizeInBytes) override; void* mapTessVertexSpanBuffer(size_t mapSizeInBytes) override; void* mapTriangleVertexBuffer(size_t mapSizeInBytes) override; + void* mapImageDrawInstanceBuffer(size_t mapSizeInBytes) override; void unmapFlushUniformBuffer(size_t mapSizeInBytes) override; - void unmapImageDrawUniformBuffer(size_t mapSizeInBytes) override; void unmapPathBuffer(size_t mapSizeInBytes) override; void unmapPaintBuffer(size_t mapSizeInBytes) override; void unmapPaintAuxBuffer(size_t mapSizeInBytes) override; @@ -47,6 +46,7 @@ void unmapGradSpanBuffer(size_t mapSizeInBytes) override; void unmapTessVertexSpanBuffer(size_t mapSizeInBytes) override; void unmapTriangleVertexBuffer(size_t mapSizeInBytes) override; + void unmapImageDrawInstanceBuffer(size_t mapSizeInBytes) override; double secondsNow() const override { @@ -56,10 +56,6 @@ protected: BufferRing* flushUniformBufferRing() { return m_flushUniformBuffer.get(); } - BufferRing* imageDrawUniformBufferRing() - { - return m_imageDrawUniformBuffer.get(); - } BufferRing* pathBufferRing() { return m_pathBuffer.get(); } BufferRing* paintBufferRing() { return m_paintBuffer.get(); } BufferRing* paintAuxBufferRing() { return m_paintAuxBuffer.get(); } @@ -67,6 +63,10 @@ BufferRing* gradSpanBufferRing() { return m_gradSpanBuffer.get(); } BufferRing* tessSpanBufferRing() { return m_tessSpanBuffer.get(); } BufferRing* triangleBufferRing() { return m_triangleBuffer.get(); } + BufferRing* imageDrawInstanceBufferRing() + { + return m_imageDrawInstanceBuffer.get(); + } virtual std::unique_ptr<BufferRing> makeUniformBufferRing( size_t capacityInBytes) = 0; @@ -78,7 +78,6 @@ private: std::unique_ptr<BufferRing> m_flushUniformBuffer; - std::unique_ptr<BufferRing> m_imageDrawUniformBuffer; std::unique_ptr<BufferRing> m_pathBuffer; std::unique_ptr<BufferRing> m_paintBuffer; std::unique_ptr<BufferRing> m_paintAuxBuffer; @@ -86,6 +85,7 @@ std::unique_ptr<BufferRing> m_gradSpanBuffer; std::unique_ptr<BufferRing> m_tessSpanBuffer; std::unique_ptr<BufferRing> m_triangleBuffer; + std::unique_ptr<BufferRing> m_imageDrawInstanceBuffer; std::chrono::steady_clock::time_point m_localEpoch = std::chrono::steady_clock::now(); };
diff --git a/renderer/include/rive/renderer/render_context_impl.hpp b/renderer/include/rive/renderer/render_context_impl.hpp index 79bf1bc..fa3c0d9 100644 --- a/renderer/include/rive/renderer/render_context_impl.hpp +++ b/renderer/include/rive/renderer/render_context_impl.hpp
@@ -95,7 +95,6 @@ // 'elementSizeInBytes' represents the size of one array element when the // shader accesses this buffer as a storage buffer. virtual void resizeFlushUniformBuffer(size_t sizeInBytes) = 0; - virtual void resizeImageDrawUniformBuffer(size_t sizeInBytes) = 0; virtual void resizePathBuffer(size_t sizeInBytes, gpu::StorageBufferStructure) = 0; virtual void resizePaintBuffer(size_t sizeInBytes, @@ -107,6 +106,7 @@ virtual void resizeGradSpanBuffer(size_t sizeInBytes) = 0; virtual void resizeTessVertexSpanBuffer(size_t sizeInBytes) = 0; virtual void resizeTriangleVertexBuffer(size_t sizeInBytes) = 0; + virtual void resizeImageDrawInstanceBuffer(size_t sizeInBytes) = 0; virtual void preBeginFrame(RenderContext*) {} @@ -142,7 +142,6 @@ // buffers in rings, in order to avoid expensive synchronization with the // GPU pipeline. See RenderContextBufferRingImpl.) virtual void* mapFlushUniformBuffer(size_t mapSizeInBytes) = 0; - virtual void* mapImageDrawUniformBuffer(size_t mapSizeInBytes) = 0; virtual void* mapPathBuffer(size_t mapSizeInBytes) = 0; virtual void* mapPaintBuffer(size_t mapSizeInBytes) = 0; virtual void* mapPaintAuxBuffer(size_t mapSizeInBytes) = 0; @@ -150,10 +149,10 @@ virtual void* mapGradSpanBuffer(size_t mapSizeInBytes) = 0; virtual void* mapTessVertexSpanBuffer(size_t mapSizeInBytes) = 0; virtual void* mapTriangleVertexBuffer(size_t mapSizeInBytes) = 0; + virtual void* mapImageDrawInstanceBuffer(size_t mapSizeInBytes) = 0; // Unmap GPU buffers. All buffers will be unmapped before flush(). virtual void unmapFlushUniformBuffer(size_t mapSizeInBytes) = 0; - virtual void unmapImageDrawUniformBuffer(size_t mapSizeInBytes) = 0; virtual void unmapPathBuffer(size_t mapSizeInBytes) = 0; virtual void unmapPaintBuffer(size_t mapSizeInBytes) = 0; virtual void unmapPaintAuxBuffer(size_t mapSizeInBytes) = 0; @@ -161,6 +160,7 @@ virtual void unmapGradSpanBuffer(size_t mapSizeInBytes) = 0; virtual void unmapTessVertexSpanBuffer(size_t mapSizeInBytes) = 0; virtual void unmapTriangleVertexBuffer(size_t mapSizeInBytes) = 0; + virtual void unmapImageDrawInstanceBuffer(size_t mapSizeInBytes) = 0; // Allocate resources that are updated and used during flush(). virtual void resizeGradientTexture(uint32_t width, uint32_t height) = 0;
diff --git a/renderer/include/rive/renderer/vulkan/render_context_vulkan_impl.hpp b/renderer/include/rive/renderer/vulkan/render_context_vulkan_impl.hpp index 0e8d4bb..1b8a735 100644 --- a/renderer/include/rive/renderer/vulkan/render_context_vulkan_impl.hpp +++ b/renderer/include/rive/renderer/vulkan/render_context_vulkan_impl.hpp
@@ -170,7 +170,6 @@ } IMPLEMENT_PLS_BUFFER(FlushUniformBuffer, m_flushUniformBuffer) - IMPLEMENT_PLS_BUFFER(ImageDrawUniformBuffer, m_imageDrawUniformBuffer) IMPLEMENT_PLS_STRUCTURED_BUFFER(PathBuffer, m_pathBuffer) IMPLEMENT_PLS_STRUCTURED_BUFFER(PaintBuffer, m_paintBuffer) IMPLEMENT_PLS_STRUCTURED_BUFFER(PaintAuxBuffer, m_paintAuxBuffer) @@ -178,6 +177,7 @@ IMPLEMENT_PLS_BUFFER(GradSpanBuffer, m_gradSpanBuffer) IMPLEMENT_PLS_BUFFER(TessVertexSpanBuffer, m_tessSpanBuffer) IMPLEMENT_PLS_BUFFER(TriangleVertexBuffer, m_triangleBuffer) + IMPLEMENT_PLS_BUFFER(ImageDrawInstanceBuffer, m_imageDrawInstanceBuffer) #undef IMPLEMENT_PLS_BUFFER #undef IMPLEMENT_PLS_STRUCTURED_BUFFER @@ -393,7 +393,6 @@ // Rive buffer pools. These don't need to be rcp<> because the destructor of // RenderContextVulkanImpl is already synchronized. vkutil::BufferPool m_flushUniformBufferPool; - vkutil::BufferPool m_imageDrawUniformBufferPool; vkutil::BufferPool m_pathBufferPool; vkutil::BufferPool m_paintBufferPool; vkutil::BufferPool m_paintAuxBufferPool; @@ -401,11 +400,11 @@ vkutil::BufferPool m_gradSpanBufferPool; vkutil::BufferPool m_tessSpanBufferPool; vkutil::BufferPool m_triangleBufferPool; + vkutil::BufferPool m_imageDrawInstanceBufferPool; // Specific Rive buffers that have been acquired for the current frame. // When the frame ends, these get recycled back in their respective pools. rcp<vkutil::Buffer> m_flushUniformBuffer; - rcp<vkutil::Buffer> m_imageDrawUniformBuffer; rcp<vkutil::Buffer> m_pathBuffer; rcp<vkutil::Buffer> m_paintBuffer; rcp<vkutil::Buffer> m_paintAuxBuffer; @@ -413,6 +412,7 @@ rcp<vkutil::Buffer> m_gradSpanBuffer; rcp<vkutil::Buffer> m_tessSpanBuffer; rcp<vkutil::Buffer> m_triangleBuffer; + rcp<vkutil::Buffer> m_imageDrawInstanceBuffer; std::chrono::steady_clock::time_point m_localEpoch = std::chrono::steady_clock::now();
diff --git a/renderer/include/rive/renderer/webgpu/render_context_webgpu_impl.hpp b/renderer/include/rive/renderer/webgpu/render_context_webgpu_impl.hpp index 4fcf8c0..26a078a 100644 --- a/renderer/include/rive/renderer/webgpu/render_context_webgpu_impl.hpp +++ b/renderer/include/rive/renderer/webgpu/render_context_webgpu_impl.hpp
@@ -190,7 +190,7 @@ constexpr static int COLOR_RAMP_BINDINGS_COUNT = 1; constexpr static int TESS_BINDINGS_COUNT = 6; constexpr static int ATLAS_BINDINGS_COUNT = 7; - constexpr static int DRAW_BINDINGS_COUNT = 11; + constexpr static int DRAW_BINDINGS_COUNT = 10; std::array<std::unique_ptr<DrawPipelineLayout>, gpu::INTERLOCK_MODE_COUNT> m_drawPipelineLayouts;
diff --git a/renderer/src/d3d/pipeline_manager.cpp b/renderer/src/d3d/pipeline_manager.cpp index 1ab053b..a830ea3 100644 --- a/renderer/src/d3d/pipeline_manager.cpp +++ b/renderer/src/d3d/pipeline_manager.cpp
@@ -8,7 +8,6 @@ #include <d3dcompiler.h> -#include "generated/shaders/image_draw_uniforms.glsl.hpp" #include "generated/shaders/flush_uniforms.glsl.hpp" #include "generated/shaders/advanced_blend.glsl.hpp" #include "generated/shaders/atomic_draw.glsl.hpp" @@ -122,10 +121,6 @@ { s << glsl::advanced_blend << '\n'; } - if (drawType == DrawType::imageMesh || drawType == DrawType::imageRect) - { - s << glsl::image_draw_uniforms << '\n'; - } if (interlockMode == InterlockMode::rasterOrdering) { switch (drawType)
diff --git a/renderer/src/d3d11/render_context_d3d_impl.cpp b/renderer/src/d3d11/render_context_d3d_impl.cpp index 69143b7..7498921 100644 --- a/renderer/src/d3d11/render_context_d3d_impl.cpp +++ b/renderer/src/d3d11/render_context_d3d_impl.cpp
@@ -10,11 +10,11 @@ #include "rive/renderer/render_canvas.hpp" #include <rive/renderer/ore/ore_context_d3d11.hpp> #endif +#include "rive/renderer/stack_vector.hpp" #include "rive/renderer/texture.hpp" #include "rive/profiler/profiler_macros.h" #include <D3DCompiler.h> -#include <mutex> #include "generated/shaders/tessellate.glsl.exports.h" @@ -250,69 +250,63 @@ std::unique_ptr<D3D11DrawVertexShader> D3D11PipelineManager:: compileVertexShaderBlobToFinalType(DrawType drawType, ComPtr<ID3DBlob> blob) { - D3D11_INPUT_ELEMENT_DESC layoutDesc[2]; - uint32_t vertexAttribCount; + StackVector<D3D11_INPUT_ELEMENT_DESC, IMAGE_LAST_ATTRIB_IDX + 1> layoutDesc; switch (drawType) { case DrawType::midpointFanPatches: case DrawType::midpointFanCenterAAPatches: case DrawType::outerCurvePatches: - layoutDesc[0] = {GLSL_a_patchVertexData, - 0, - DXGI_FORMAT_R32G32B32A32_FLOAT, - PATCH_VERTEX_DATA_SLOT, - D3D11_APPEND_ALIGNED_ELEMENT, - D3D11_INPUT_PER_VERTEX_DATA, - 0}; - layoutDesc[1] = {GLSL_a_mirroredVertexData, - 0, - DXGI_FORMAT_R32G32B32A32_FLOAT, - PATCH_VERTEX_DATA_SLOT, - D3D11_APPEND_ALIGNED_ELEMENT, - D3D11_INPUT_PER_VERTEX_DATA, - 0}; - vertexAttribCount = 2; + layoutDesc.push_back({GLSL_a_patchVertexData, + 0, + DXGI_FORMAT_R32G32B32A32_FLOAT, + PATCH_VERTEX_DATA_SLOT, + D3D11_APPEND_ALIGNED_ELEMENT, + D3D11_INPUT_PER_VERTEX_DATA, + 0}); + layoutDesc.push_back({GLSL_a_mirroredVertexData, + 0, + DXGI_FORMAT_R32G32B32A32_FLOAT, + PATCH_VERTEX_DATA_SLOT, + D3D11_APPEND_ALIGNED_ELEMENT, + D3D11_INPUT_PER_VERTEX_DATA, + 0}); break; case DrawType::interiorTriangulation: case DrawType::atlasBlit: - layoutDesc[0] = {GLSL_a_triangleVertex, - 0, - DXGI_FORMAT_R32G32B32_FLOAT, - TRIANGLE_VERTEX_DATA_SLOT, - 0, - D3D11_INPUT_PER_VERTEX_DATA, - 0}; - vertexAttribCount = 1; + layoutDesc.push_back({GLSL_a_triangleVertex, + 0, + DXGI_FORMAT_R32G32B32_FLOAT, + TRIANGLE_VERTEX_DATA_SLOT, + 0, + D3D11_INPUT_PER_VERTEX_DATA, + 0}); break; case DrawType::imageRect: - layoutDesc[0] = {GLSL_a_imageRectVertex, - 0, - DXGI_FORMAT_R32G32B32A32_FLOAT, - IMAGE_RECT_VERTEX_DATA_SLOT, - 0, - D3D11_INPUT_PER_VERTEX_DATA, - 0}; - vertexAttribCount = 1; + layoutDesc.push_back({GLSL_a_imageRectVertex, + 0, + DXGI_FORMAT_R32G32B32A32_FLOAT, + IMAGE_RECT_VERTEX_DATA_SLOT, + 0, + D3D11_INPUT_PER_VERTEX_DATA, + 0}); break; case DrawType::imageMesh: - layoutDesc[0] = {GLSL_a_position, - 0, - DXGI_FORMAT_R32G32_FLOAT, - IMAGE_MESH_VERTEX_DATA_SLOT, - D3D11_APPEND_ALIGNED_ELEMENT, - D3D11_INPUT_PER_VERTEX_DATA, - 0}; - layoutDesc[1] = {GLSL_a_texCoord, - 0, - DXGI_FORMAT_R32G32_FLOAT, - IMAGE_MESH_UV_DATA_SLOT, - D3D11_APPEND_ALIGNED_ELEMENT, - D3D11_INPUT_PER_VERTEX_DATA, - 0}; - vertexAttribCount = 2; + layoutDesc.push_back({GLSL_a_position, + 0, + DXGI_FORMAT_R32G32_FLOAT, + IMAGE_MESH_VERTEX_DATA_SLOT, + D3D11_APPEND_ALIGNED_ELEMENT, + D3D11_INPUT_PER_VERTEX_DATA, + 0}); + layoutDesc.push_back({GLSL_a_texCoord, + 0, + DXGI_FORMAT_R32G32_FLOAT, + IMAGE_MESH_UV_DATA_SLOT, + D3D11_APPEND_ALIGNED_ELEMENT, + D3D11_INPUT_PER_VERTEX_DATA, + 0}); break; case DrawType::renderPassResolve: - vertexAttribCount = 0; break; case DrawType::msaaStrokes: case DrawType::msaaMidpointFanBorrowedCoverage: @@ -326,10 +320,44 @@ RIVE_UNREACHABLE(); } + // Image draws receive their data as instanced vertex attributes, all from + // IMAGE_DRAW_INSTANCE_DATA_SLOT. See gpu::ImageDrawInstance. + if (gpu::DrawTypeIsImageDraw(drawType)) + { + layoutDesc.push_back({GLSL_a_imageDrawViewMatrix, + 0, + DXGI_FORMAT_R32G32B32A32_FLOAT, + IMAGE_DRAW_INSTANCE_DATA_SLOT, + D3D11_APPEND_ALIGNED_ELEMENT, + D3D11_INPUT_PER_INSTANCE_DATA, + 1}); + layoutDesc.push_back({GLSL_a_imageDrawClipRectInverseMatrix, + 0, + DXGI_FORMAT_R32G32B32A32_FLOAT, + IMAGE_DRAW_INSTANCE_DATA_SLOT, + D3D11_APPEND_ALIGNED_ELEMENT, + D3D11_INPUT_PER_INSTANCE_DATA, + 1}); + layoutDesc.push_back({GLSL_a_imageDrawTranslates, + 0, + DXGI_FORMAT_R32G32B32A32_FLOAT, + IMAGE_DRAW_INSTANCE_DATA_SLOT, + D3D11_APPEND_ALIGNED_ELEMENT, + D3D11_INPUT_PER_INSTANCE_DATA, + 1}); + layoutDesc.push_back({GLSL_a_imageDrawPacked, + 0, + DXGI_FORMAT_R32G32B32A32_UINT, + IMAGE_DRAW_INSTANCE_DATA_SLOT, + D3D11_APPEND_ALIGNED_ELEMENT, + D3D11_INPUT_PER_INSTANCE_DATA, + 1}); + } + auto result = std::make_unique<D3D11DrawVertexShader>(); - VERIFY_OK(device()->CreateInputLayout(layoutDesc, - vertexAttribCount, + VERIFY_OK(device()->CreateInputLayout(layoutDesc.data(), + layoutDesc.size(), blob->GetBufferPointer(), blob->GetBufferSize(), &result->layout)); @@ -666,13 +694,6 @@ VERIFY_OK(m_gpu->CreateBuffer(&desc, nullptr, m_drawUniforms.ReleaseAndGetAddressOf())); - - desc.ByteWidth = sizeof(gpu::ImageDrawUniforms); - desc.StructureByteStride = sizeof(gpu::ImageDrawUniforms); - VERIFY_OK( - m_gpu->CreateBuffer(&desc, - nullptr, - m_imageDrawUniforms.ReleaseAndGetAddressOf())); } // Create a linear sampler for the gradient & feather textures. @@ -1613,12 +1634,9 @@ 0); ID3D11Buffer* uniformBuffers[] = {m_flushUniforms.Get(), - m_drawUniforms.Get(), - m_imageDrawUniforms.Get()}; + m_drawUniforms.Get()}; static_assert(PATH_BASE_INSTANCE_UNIFORM_BUFFER_IDX == FLUSH_UNIFORM_BUFFER_IDX + 1); - static_assert(IMAGE_DRAW_UNIFORM_BUFFER_IDX == - PATH_BASE_INSTANCE_UNIFORM_BUFFER_IDX + 1); m_gpuContext->VSSetConstantBuffers(FLUSH_UNIFORM_BUFFER_IDX, std::size(uniformBuffers), uniformBuffers); @@ -2022,12 +2040,21 @@ 1, m_atlasTextureSRV.GetAddressOf()); - m_gpuContext->PSSetConstantBuffers(IMAGE_DRAW_UNIFORM_BUFFER_IDX, - 1, - m_imageDrawUniforms.GetAddressOf()); - - const char* const imageDrawUniformData = - heap_buffer_contents(imageDrawUniformBufferRing()); + if (imageDrawInstanceBufferRing() != nullptr) + { + // Bind the image-draw-attribute records as a per-instance vertex buffer + // once; each image draw selects its record via the draw call's base + // instance (batch.baseElement). + ID3D11Buffer* imageDrawInstanceBuffer = + flush_buffer(m_gpuContext.Get(), imageDrawInstanceBufferRing()); + UINT instanceStride = sizeof(gpu::ImageDrawInstance); + UINT instanceOffset = 0; + m_gpuContext->IASetVertexBuffers(IMAGE_DRAW_INSTANCE_DATA_SLOT, + 1, + &imageDrawInstanceBuffer, + &instanceStride, + &instanceOffset); + } bool renderPassHasCoalescedResolveAndTransfer = desc.interlockMode == gpu::InterlockMode::atomics && @@ -2124,9 +2151,9 @@ 0, 0); RIVE_PROF_GPUNAME_L(2, "Patches"); - m_gpuContext->DrawIndexedInstanced(PatchIndexCount(drawType), + m_gpuContext->DrawIndexedInstanced(batch.indexCountPerInstance, batch.elementCount, - PatchBaseIndex(drawType), + batch.baseIndex, 0, batch.baseElement); break; @@ -2156,16 +2183,11 @@ 0); m_gpuContext->RSSetState( m_doubleSidedRasterState[desc.wireframe].Get()); - m_gpuContext->UpdateSubresource(m_imageDrawUniforms.Get(), - 0, - NULL, - imageDrawUniformData + - batch.imageDrawDataOffset, - 0, - 0); - m_gpuContext->DrawIndexed(std::size(gpu::kImageRectIndices), - 0, - 0); + m_gpuContext->DrawIndexedInstanced(batch.indexCountPerInstance, + batch.elementCount, + batch.baseIndex, + 0, + batch.baseElement); break; } case DrawType::imageMesh: @@ -2198,16 +2220,11 @@ 0); m_gpuContext->RSSetState( m_doubleSidedRasterState[desc.wireframe].Get()); - m_gpuContext->UpdateSubresource(m_imageDrawUniforms.Get(), - 0, - NULL, - imageDrawUniformData + - batch.imageDrawDataOffset, - 0, - 0); - m_gpuContext->DrawIndexed(batch.elementCount, - batch.baseElement, - 0); + m_gpuContext->DrawIndexedInstanced(batch.indexCountPerInstance, + batch.elementCount, + batch.baseIndex, + 0, + batch.baseElement); break; } case DrawType::renderPassResolve:
diff --git a/renderer/src/d3d12/d3d12_pipeline_manager.cpp b/renderer/src/d3d12/d3d12_pipeline_manager.cpp index 4d38d76..a50bab8 100644 --- a/renderer/src/d3d12/d3d12_pipeline_manager.cpp +++ b/renderer/src/d3d12/d3d12_pipeline_manager.cpp
@@ -69,68 +69,69 @@ case DrawType::midpointFanPatches: case DrawType::midpointFanCenterAAPatches: case DrawType::outerCurvePatches: - result->m_layoutDesc[0] = { + result->m_layoutDesc.push_back({ GLSL_a_patchVertexData, 0, DXGI_FORMAT_R32G32B32A32_FLOAT, PATCH_VERTEX_DATA_SLOT, D3D12_APPEND_ALIGNED_ELEMENT, D3D12_INPUT_CLASSIFICATION_PER_VERTEX_DATA, - 0}; - result->m_layoutDesc[1] = { + 0, + }); + result->m_layoutDesc.push_back({ GLSL_a_mirroredVertexData, 0, DXGI_FORMAT_R32G32B32A32_FLOAT, PATCH_VERTEX_DATA_SLOT, D3D12_APPEND_ALIGNED_ELEMENT, D3D12_INPUT_CLASSIFICATION_PER_VERTEX_DATA, - 0}; - result->m_vertexAttribCount = 2; + 0, + }); break; case DrawType::interiorTriangulation: case DrawType::atlasBlit: - result->m_layoutDesc[0] = { + result->m_layoutDesc.push_back({ GLSL_a_triangleVertex, 0, DXGI_FORMAT_R32G32B32_FLOAT, TRIANGLE_VERTEX_DATA_SLOT, 0, D3D12_INPUT_CLASSIFICATION_PER_VERTEX_DATA, - 0}; - result->m_vertexAttribCount = 1; + 0, + }); break; case DrawType::imageRect: - result->m_layoutDesc[0] = { + result->m_layoutDesc.push_back({ GLSL_a_imageRectVertex, 0, DXGI_FORMAT_R32G32B32A32_FLOAT, IMAGE_RECT_VERTEX_DATA_SLOT, 0, D3D12_INPUT_CLASSIFICATION_PER_VERTEX_DATA, - 0}; - result->m_vertexAttribCount = 1; + 0, + }); break; case DrawType::imageMesh: - result->m_layoutDesc[0] = { + result->m_layoutDesc.push_back({ GLSL_a_position, 0, DXGI_FORMAT_R32G32_FLOAT, IMAGE_MESH_VERTEX_DATA_SLOT, D3D12_APPEND_ALIGNED_ELEMENT, D3D12_INPUT_CLASSIFICATION_PER_VERTEX_DATA, - 0}; - result->m_layoutDesc[1] = { + 0, + }); + result->m_layoutDesc.push_back({ GLSL_a_texCoord, 0, DXGI_FORMAT_R32G32_FLOAT, IMAGE_MESH_UV_DATA_SLOT, D3D12_APPEND_ALIGNED_ELEMENT, D3D12_INPUT_CLASSIFICATION_PER_VERTEX_DATA, - 0}; - result->m_vertexAttribCount = 2; + 0, + }); break; case DrawType::renderPassResolve: - result->m_vertexAttribCount = 0; break; case DrawType::msaaStrokes: case DrawType::msaaMidpointFanBorrowedCoverage: @@ -144,6 +145,44 @@ RIVE_UNREACHABLE(); } + // Image draws receive their data as instanced vertex attributes, all from + // IMAGE_DRAW_INSTANCE_DATA_SLOT. See gpu::ImageDrawInstance. + if (gpu::DrawTypeIsImageDraw(drawType)) + { + result->m_layoutDesc.push_back( + {GLSL_a_imageDrawViewMatrix, + 0, + DXGI_FORMAT_R32G32B32A32_FLOAT, + IMAGE_DRAW_INSTANCE_DATA_SLOT, + D3D12_APPEND_ALIGNED_ELEMENT, + D3D12_INPUT_CLASSIFICATION_PER_INSTANCE_DATA, + 1}); + result->m_layoutDesc.push_back( + {GLSL_a_imageDrawClipRectInverseMatrix, + 0, + DXGI_FORMAT_R32G32B32A32_FLOAT, + IMAGE_DRAW_INSTANCE_DATA_SLOT, + D3D12_APPEND_ALIGNED_ELEMENT, + D3D12_INPUT_CLASSIFICATION_PER_INSTANCE_DATA, + 1}); + result->m_layoutDesc.push_back( + {GLSL_a_imageDrawTranslates, + 0, + DXGI_FORMAT_R32G32B32A32_FLOAT, + IMAGE_DRAW_INSTANCE_DATA_SLOT, + D3D12_APPEND_ALIGNED_ELEMENT, + D3D12_INPUT_CLASSIFICATION_PER_INSTANCE_DATA, + 1}); + result->m_layoutDesc.push_back( + {GLSL_a_imageDrawPacked, + 0, + DXGI_FORMAT_R32G32B32A32_UINT, + IMAGE_DRAW_INSTANCE_DATA_SLOT, + D3D12_APPEND_ALIGNED_ELEMENT, + D3D12_INPUT_CLASSIFICATION_PER_INSTANCE_DATA, + 1}); + } + result->m_shader = blob; return result; } @@ -217,7 +256,7 @@ : 0; D3D12_GRAPHICS_PIPELINE_STATE_DESC psoDesc = {}; - psoDesc.InputLayout = {vs.m_layoutDesc, vs.m_vertexAttribCount}; + psoDesc.InputLayout = {vs.m_layoutDesc.data(), vs.m_layoutDesc.size()}; psoDesc.pRootSignature = m_rootSignature.Get(); psoDesc.VS = CD3DX12_SHADER_BYTECODE(vs.m_shader.Get()); psoDesc.PS = CD3DX12_SHADER_BYTECODE(ps.m_shader.Get());
diff --git a/renderer/src/d3d12/d3d12_utils.cpp b/renderer/src/d3d12/d3d12_utils.cpp index 6c80f9c..12da8bd 100644 --- a/renderer/src/d3d12/d3d12_utils.cpp +++ b/renderer/src/d3d12/d3d12_utils.cpp
@@ -681,8 +681,8 @@ UINT alignment, UINT size) : GPUResourcePool(std::move(manager), MAX_POOL_SIZE), - m_targetSize(std::max<UINT>(size, m_alignment)), - m_alignment(alignment) + m_alignment(alignment), + m_targetSize(std::max<UINT>(size, m_alignment)) {} inline D3D12ResourceManager* D3D12VolatileBufferPool::d3d() const
diff --git a/renderer/src/d3d12/render_context_d3d12_impl.cpp b/renderer/src/d3d12/render_context_d3d12_impl.cpp index 5b158b6..9665f77 100644 --- a/renderer/src/d3d12/render_context_d3d12_impl.cpp +++ b/renderer/src/d3d12/render_context_d3d12_impl.cpp
@@ -632,7 +632,6 @@ m_pipelineManager(device, capabilities, shaderCompilationMode), m_resourceManager(make_rcp<D3D12ResourceManager>(device)), m_flushUniformBufferPool(m_resourceManager, sizeof(FlushUniforms)), - m_imageDrawUniformBufferPool(m_resourceManager, sizeof(ImageDrawUniforms)), m_pathBufferPool(m_resourceManager), m_paintBufferPool(m_resourceManager), m_paintAuxBufferPool(m_resourceManager), @@ -640,6 +639,7 @@ m_gradSpanBufferPool(m_resourceManager), m_tessSpanBufferPool(m_resourceManager), m_triangleBufferPool(m_resourceManager), + m_imageDrawInstanceBufferPool(m_resourceManager, sizeof(ImageDrawInstance)), // this is 64kb which is the smallest heap that can be sent to gpu m_srvUavCbvHeapPool(m_resourceManager, MAX_DESCRIPTOR_HEAPS_PER_FLUSH, @@ -1004,7 +1004,6 @@ { // These should all have gotten recycled at the end of the last frame. assert(m_flushUniformBuffer == nullptr); - assert(m_imageDrawUniformBuffer == nullptr); assert(m_pathBuffer == nullptr); assert(m_paintBuffer == nullptr); assert(m_paintAuxBuffer == nullptr); @@ -1012,6 +1011,7 @@ assert(m_gradSpanBuffer == nullptr); assert(m_tessSpanBuffer == nullptr); assert(m_triangleBuffer == nullptr); + assert(m_imageDrawInstanceBuffer == nullptr); assert(m_srvUavCbvHeap == nullptr); assert(m_cpuSrvUavCbvHeap == nullptr); @@ -1030,7 +1030,6 @@ // Acquire buffers for the flush. m_flushUniformBuffer = m_flushUniformBufferPool.acquire(); - m_imageDrawUniformBuffer = m_imageDrawUniformBufferPool.acquire(); m_pathBuffer = m_pathBufferPool.acquire(); m_paintBuffer = m_paintBufferPool.acquire(); m_paintAuxBuffer = m_paintAuxBufferPool.acquire(); @@ -1038,13 +1037,13 @@ m_gradSpanBuffer = m_gradSpanBufferPool.acquire(); m_tessSpanBuffer = m_tessSpanBufferPool.acquire(); m_triangleBuffer = m_triangleBufferPool.acquire(); + m_imageDrawInstanceBuffer = m_imageDrawInstanceBufferPool.acquire(); m_srvUavCbvHeap = m_srvUavCbvHeapPool.acquire(); m_cpuSrvUavCbvHeap = m_cpuSrvUavCbvHeapPool.acquire(); m_samplerHeap = m_samplerHeapPool.acquire(); VNAME_D3D12_OBJECT(m_flushUniformBuffer); - VNAME_D3D12_OBJECT(m_imageDrawUniformBuffer); VNAME_D3D12_OBJECT(m_pathBuffer); VNAME_D3D12_OBJECT(m_paintBuffer); VNAME_D3D12_OBJECT(m_paintAuxBuffer); @@ -1052,6 +1051,7 @@ VNAME_D3D12_OBJECT(m_gradSpanBuffer); VNAME_D3D12_OBJECT(m_tessSpanBuffer); VNAME_D3D12_OBJECT(m_triangleBuffer); + VNAME_D3D12_OBJECT(m_imageDrawInstanceBuffer); m_isFirstFlushOfFrame = true; @@ -1121,7 +1121,6 @@ // sync everything first logical flush, // copies are slow, so do it all at once m_flushUniformBuffer->sync(copyCmdList, 0); - m_imageDrawUniformBuffer->sync(copyCmdList, 0); if (desc.pathCount > 0) { m_pathBuffer->sync(copyCmdList, 0); @@ -1148,6 +1147,8 @@ m_triangleBuffer->sync(copyCmdList, 0); } + m_imageDrawInstanceBuffer->sync(copyCmdList, 0); + // mark all UAVS, thse only need to happen the fist time since they // won't change per logical flush @@ -1275,6 +1276,18 @@ m_flushUniformBuffer->resource()->getGPUVirtualAddress() + desc.flushUniformDataOffsetInBytes); + // Bind the image-draw-attribute records as a per-instance vertex buffer + // once; each image draw selects its record via the draw call's base + // instance (batch.baseElement). + // NOTE: Even if there are no image draws, we have still allocated a + // single-element instance buffer. + D3D12_VERTEX_BUFFER_VIEW imageDrawInstanceVBV = + m_imageDrawInstanceBuffer->resource()->vertexBufferView( + sizeof(gpu::ImageDrawInstance)); + cmdList->IASetVertexBuffers(IMAGE_DRAW_INSTANCE_DATA_SLOT, + 1, + &imageDrawInstanceVBV); + if (desc.pathCount > 0) { m_cpuSrvUavCbvHeap->markSrvToIndex( @@ -1927,9 +1940,9 @@ VERTEX_DRAW_UNIFORM_SIG_INDEX, batch.baseElement, 0); - cmdList->DrawIndexedInstanced(PatchIndexCount(drawType), + cmdList->DrawIndexedInstanced(batch.indexCountPerInstance, batch.elementCount, - PatchBaseIndex(drawType), + batch.baseIndex, 0, batch.baseElement); break; @@ -1955,17 +1968,11 @@ auto IBV = m_imageRectIndexBuffer->indexBufferView(); cmdList->IASetIndexBuffer(&IBV); - cmdList->SetGraphicsRootConstantBufferView( - IMAGE_UNIFORM_BUFFFER_SIG_INDEX, - m_imageDrawUniformBuffer->resource() - ->getGPUVirtualAddress() + - batch.imageDrawDataOffset); - - cmdList->DrawIndexedInstanced(std::size(gpu::kImageRectIndices), - 1, + cmdList->DrawIndexedInstanced(batch.indexCountPerInstance, + batch.elementCount, + batch.baseIndex, 0, - 0, - 0); + batch.baseElement); break; } case DrawType::imageMesh: @@ -1999,17 +2006,11 @@ auto IBV = iBuffer->indexBufferView(); cmdList->IASetIndexBuffer(&IBV); - cmdList->SetGraphicsRootConstantBufferView( - IMAGE_UNIFORM_BUFFFER_SIG_INDEX, - m_imageDrawUniformBuffer->resource() - ->getGPUVirtualAddress() + - batch.imageDrawDataOffset); - - cmdList->DrawIndexedInstanced(batch.elementCount, - 1, - batch.baseElement, + cmdList->DrawIndexedInstanced(batch.indexCountPerInstance, + batch.elementCount, + batch.baseIndex, 0, - 0); + batch.baseElement); break; } case DrawType::renderPassResolve: @@ -2076,7 +2077,6 @@ { // Recycle buffers. m_flushUniformBufferPool.recycle(std::move(m_flushUniformBuffer)); - m_imageDrawUniformBufferPool.recycle(std::move(m_imageDrawUniformBuffer)); m_pathBufferPool.recycle(std::move(m_pathBuffer)); m_paintBufferPool.recycle(std::move(m_paintBuffer)); m_paintAuxBufferPool.recycle(std::move(m_paintAuxBuffer)); @@ -2084,6 +2084,7 @@ m_gradSpanBufferPool.recycle(std::move(m_gradSpanBuffer)); m_tessSpanBufferPool.recycle(std::move(m_tessSpanBuffer)); m_triangleBufferPool.recycle(std::move(m_triangleBuffer)); + m_imageDrawInstanceBufferPool.recycle(std::move(m_imageDrawInstanceBuffer)); m_srvUavCbvHeapPool.recycle(std::move(m_srvUavCbvHeap)); m_cpuSrvUavCbvHeapPool.recycle(std::move(m_cpuSrvUavCbvHeap));
diff --git a/renderer/src/gl/render_context_gl_impl.cpp b/renderer/src/gl/render_context_gl_impl.cpp index 836b816..e882e98 100644 --- a/renderer/src/gl/render_context_gl_impl.cpp +++ b/renderer/src/gl/render_context_gl_impl.cpp
@@ -22,7 +22,6 @@ #include "generated/shaders/advanced_blend.glsl.hpp" #include "generated/shaders/color_ramp.glsl.hpp" #include "generated/shaders/constants.glsl.hpp" -#include "generated/shaders/image_draw_uniforms.glsl.hpp" #include "generated/shaders/flush_uniforms.glsl.hpp" #include "generated/shaders/common.glsl.hpp" #include "generated/shaders/draw_path_common.glsl.hpp" @@ -394,6 +393,13 @@ // We draw imageRects when in atomic mode. m_state->bindVAO(m_imageRectVAO); + glEnableVertexAttribArray(0); + for (GLuint loc = IMAGE_FIRST_ATTRIB_IDX; loc <= IMAGE_LAST_ATTRIB_IDX; + ++loc) + { + glEnableVertexAttribArray(loc); + glVertexAttribDivisor(loc, 1); + } m_state->bindBuffer(GL_ARRAY_BUFFER, m_imageRectVertexBuffer); glBufferData(GL_ARRAY_BUFFER, @@ -401,7 +407,6 @@ gpu::kImageRectVertices, GL_STATIC_DRAW); - glEnableVertexAttribArray(0); glVertexAttribPointer(0, 4, GL_FLOAT, @@ -418,7 +423,12 @@ m_state->bindVAO(m_imageMeshVAO); glEnableVertexAttribArray(0); glEnableVertexAttribArray(1); - + for (GLuint loc = IMAGE_FIRST_ATTRIB_IDX; loc <= IMAGE_LAST_ATTRIB_IDX; + ++loc) + { + glEnableVertexAttribArray(loc); + glVertexAttribDivisor(loc, 1); + } if (m_plsImpl != nullptr) { m_plsImpl->init(m_state); @@ -1792,7 +1802,6 @@ sources.push_back(gpu::glsl::draw_mesh_frag); break; case gpu::DrawType::imageMesh: - sources.push_back(gpu::glsl::image_draw_uniforms); sources.push_back(gpu::glsl::draw_image_mesh_vert); sources.push_back(gpu::glsl::draw_mesh_frag); break; @@ -1812,10 +1821,6 @@ break; case gpu::InterlockMode::atomics: - if (gpu::DrawTypeIsImageDraw(drawType)) - { - sources.push_back(gpu::glsl::image_draw_uniforms); - } sources.push_back(gpu::glsl::draw_path_common); sources.push_back(gpu::glsl::atomic_draw); break; @@ -1844,7 +1849,6 @@ sources.push_back(gpu::glsl::draw_msaa_object_frag); break; case gpu::DrawType::imageMesh: - sources.push_back(glsl::image_draw_uniforms); sources.push_back(gpu::glsl::draw_image_mesh_vert); sources.push_back(gpu::glsl::draw_msaa_object_frag); break; @@ -2032,13 +2036,6 @@ enums::no_flags_set(shaderMiscFlags, gpu::ShaderMiscFlags::clipUpdateOnly | gpu::ShaderMiscFlags::borrowedCoveragePass); - if (isImageDraw) - { - glUniformBlockBinding( - m_id, - glGetUniformBlockIndex(m_id, GLSL_ImageDrawUniforms), - IMAGE_DRAW_UNIFORM_BUFFER_IDX); - } if (isTessellationDraw) { glutils::Uniform1iByName(m_id, @@ -2127,6 +2124,40 @@ return static_cast<const BufferRingGLImpl*>(bufferRing)->bufferID(); } +// Setup the per-draw gpu::ImageDrawInstance buffer. GL has no portable +// baseInstance, so point the instance attributes at this draw's record via a +// byteOffset instead. +static void setImageDrawInstanceAttribs(size_t byteOffset) +{ + glVertexAttribPointer(IMAGE_VIEW_MATRIX_ATTRIB_IDX, + 4, + GL_FLOAT, + GL_FALSE, + sizeof(gpu::ImageDrawInstance), + reinterpret_cast<const void*>(byteOffset)); + glVertexAttribPointer( + IMAGE_CLIP_RECT_INVERSE_MATRIX_ATTRIB_IDX, + 4, + GL_FLOAT, + GL_FALSE, + sizeof(gpu::ImageDrawInstance), + reinterpret_cast<const void*>(byteOffset + sizeof(uint32_t) * 4)); + glVertexAttribPointer( + IMAGE_TRANSLATES_ATTRIB_IDX, + 4, + GL_FLOAT, + GL_FALSE, + sizeof(gpu::ImageDrawInstance), + reinterpret_cast<const void*>(byteOffset + sizeof(uint32_t) * 8)); + glVertexAttribIPointer( + IMAGE_PACKED_ATTRIBS_IDX, + 4, + GL_UNSIGNED_INT, + sizeof(gpu::ImageDrawInstance), + reinterpret_cast<const void*>(byteOffset + sizeof(uint32_t) * 12)); + static_assert(sizeof(gpu::ImageDrawInstance) == sizeof(uint32_t) * 16); +} + static void bind_storage_buffer(const GLCapabilities& capabilities, const BufferRing* bufferRing, uint32_t bindingIdx, @@ -2888,8 +2919,8 @@ } drawIndexedInstancedNoInstancedAttribs( GL_TRIANGLES, - gpu::PatchIndexCount(drawType), - gpu::PatchBaseIndex(drawType), + batch.indexCountPerInstance, + batch.baseIndex, batch.elementCount, batch.baseElement, drawProgram->baseInstanceUniformLocation(), @@ -2943,15 +2974,17 @@ assert(m_plsImpl->rasterOrderingKnownDisabled()); assert(m_imageRectVAO != 0); m_state->bindVAO(m_imageRectVAO); - glBindBufferRange(GL_UNIFORM_BUFFER, - IMAGE_DRAW_UNIFORM_BUFFER_IDX, - gl_buffer_id(imageDrawUniformBufferRing()), - batch.imageDrawDataOffset, - sizeof(gpu::ImageDrawUniforms)); - glDrawElements(GL_TRIANGLES, - std::size(gpu::kImageRectIndices), - GL_UNSIGNED_SHORT, - nullptr); + m_state->bindBuffer( + GL_ARRAY_BUFFER, + gl_buffer_id(imageDrawInstanceBufferRing())); + setImageDrawInstanceAttribs(batch.baseElement * + sizeof(gpu::ImageDrawInstance)); + glDrawElementsInstanced(GL_TRIANGLES, + batch.indexCountPerInstance, + GL_UNSIGNED_SHORT, + reinterpret_cast<const void*>( + batch.baseIndex * sizeof(uint16_t)), + batch.elementCount); break; } @@ -2971,22 +3004,23 @@ glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 0, nullptr); m_state->bindBuffer(GL_ARRAY_BUFFER, uvBuffer->bufferID()); glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 0, nullptr); + m_state->bindBuffer( + GL_ARRAY_BUFFER, + gl_buffer_id(imageDrawInstanceBufferRing())); + setImageDrawInstanceAttribs(batch.baseElement * + sizeof(gpu::ImageDrawInstance)); m_state->bindBuffer(GL_ELEMENT_ARRAY_BUFFER, indexBuffer->bufferID()); - glBindBufferRange(GL_UNIFORM_BUFFER, - IMAGE_DRAW_UNIFORM_BUFFER_IDX, - gl_buffer_id(imageDrawUniformBufferRing()), - batch.imageDrawDataOffset, - sizeof(gpu::ImageDrawUniforms)); if (desc.interlockMode == gpu::InterlockMode::rasterOrdering) { m_plsImpl->ensureRasterOrderingEnabled(this, desc, true); } - glDrawElements(GL_TRIANGLES, - batch.elementCount, - GL_UNSIGNED_SHORT, - reinterpret_cast<const void*>(batch.baseElement * - sizeof(uint16_t))); + glDrawElementsInstanced(GL_TRIANGLES, + batch.indexCountPerInstance, + GL_UNSIGNED_SHORT, + reinterpret_cast<const void*>( + batch.baseIndex * sizeof(uint16_t)), + batch.elementCount); break; }
diff --git a/renderer/src/gpu.cpp b/renderer/src/gpu.cpp index c9d4835..8608221 100644 --- a/renderer/src/gpu.cpp +++ b/renderer/src/gpu.cpp
@@ -805,6 +805,24 @@ } } +// Writes just the 2x2 (scale & skew) part of a Mat2D. +static void write2x2(volatile float* dst, const Mat2D& matrix) +{ + const float* vals = matrix.values(); + for (size_t i = 0; i < 4; ++i) + { + dst[i] = vals[i]; + } +} + +// Writes just the translation part of a Mat2D. +static void writeTranslate(volatile float* dst, const Mat2D& matrix) +{ + const float* vals = matrix.values(); + dst[0] = vals[4]; + dst[1] = vals[5]; +} + void PathData::set(const Mat2D& m, float strokeRadius, float featherRadius, @@ -1004,7 +1022,7 @@ } } -ImageDrawUniforms::ImageDrawUniforms( +ImageDrawInstance::ImageDrawInstance( const Mat2D& matrix, float opacity, const ClipRectInverseMatrix* clipRectInverseMatrix, @@ -1012,12 +1030,56 @@ BlendMode blendMode, uint32_t zIndex) { - write_matrix(m_matrix, matrix); + // The backends bind the 4 attributes at byte offset i*16, relying on this + // grouping. + static_assert(ImageDrawInstance::FirstAttribIdx == IMAGE_FIRST_ATTRIB_IDX); + static_assert(ImageDrawInstance::LastAttribIdx == IMAGE_LAST_ATTRIB_IDX); + static_assert(offsetof(ImageDrawInstance, m_viewMatrix) == + (IMAGE_VIEW_MATRIX_ATTRIB_IDX - IMAGE_FIRST_ATTRIB_IDX) * + sizeof(uint32_t) * 4); + static_assert( + offsetof(ImageDrawInstance, m_clipRectInverseMatrix) == + (IMAGE_CLIP_RECT_INVERSE_MATRIX_ATTRIB_IDX - IMAGE_FIRST_ATTRIB_IDX) * + sizeof(uint32_t) * 4); + static_assert(offsetof(ImageDrawInstance, m_translate) == + (IMAGE_TRANSLATES_ATTRIB_IDX - IMAGE_FIRST_ATTRIB_IDX) * + sizeof(uint32_t) * 4); + static_assert(offsetof(ImageDrawInstance, m_opacity) == + (IMAGE_PACKED_ATTRIBS_IDX - IMAGE_FIRST_ATTRIB_IDX) * + sizeof(uint32_t) * 4); + + // When SPLIT_UINT4_ATTRIBUTES is set (Unreal RHI, whose shader compiler + // mishandles a uint4 vertex attribute), the packed uint4 is bound as four + // separate uint attributes at consecutive locations. + static_assert(IMAGE_SPLIT_OPACITY_ATTRIB_IDX == IMAGE_PACKED_ATTRIBS_IDX); + static_assert( + offsetof(ImageDrawInstance, m_clipID) == + ((IMAGE_PACKED_ATTRIBS_IDX - IMAGE_FIRST_ATTRIB_IDX) * 4 + + (IMAGE_SPLIT_CLIP_ID_ATTRIB_IDX - IMAGE_SPLIT_OPACITY_ATTRIB_IDX)) * + sizeof(uint32_t)); + static_assert( + offsetof(ImageDrawInstance, m_blendMode) == + ((IMAGE_PACKED_ATTRIBS_IDX - IMAGE_FIRST_ATTRIB_IDX) * 4 + + (IMAGE_SPLIT_BLEND_MODE_ATTRIB_IDX - IMAGE_SPLIT_OPACITY_ATTRIB_IDX)) * + sizeof(uint32_t)); + static_assert( + offsetof(ImageDrawInstance, m_zIndex) == + ((IMAGE_PACKED_ATTRIBS_IDX - IMAGE_FIRST_ATTRIB_IDX) * 4 + + (IMAGE_SPLIT_ZINDEX_ATTRIB_IDX - IMAGE_SPLIT_OPACITY_ATTRIB_IDX)) * + sizeof(uint32_t)); + static_assert(sizeof(ImageDrawInstance) == + IMAGE_ATTRIB_COUNT * sizeof(uint32_t) * 4); + + const Mat2D clipRectInverseMatrixToWrite = + clipRectInverseMatrix != nullptr + ? clipRectInverseMatrix->inverseMatrix() + : ClipRectInverseMatrix::WideOpen().inverseMatrix(); + + write2x2(m_viewMatrix, matrix); + write2x2(m_clipRectInverseMatrix, clipRectInverseMatrixToWrite); + writeTranslate(m_translate, matrix); + writeTranslate(m_clipRectInverseTranslate, clipRectInverseMatrixToWrite); m_opacity = opacity; - write_matrix(m_clipRectInverseMatrix, - clipRectInverseMatrix != nullptr - ? clipRectInverseMatrix->inverseMatrix() - : ClipRectInverseMatrix::WideOpen().inverseMatrix()); m_clipID = clipID; m_blendMode = ConvertBlendModeToPLSBlendMode(blendMode); m_zIndex = zIndex;
diff --git a/renderer/src/gpu_resource.cpp b/renderer/src/gpu_resource.cpp index ad62594..e749138 100644 --- a/renderer/src/gpu_resource.cpp +++ b/renderer/src/gpu_resource.cpp
@@ -37,6 +37,7 @@ m_currentFrameNumber = nextFrameNumber; m_safeFrameNumber = safeFrameNumber; + m_didAdvanceFrameNumber = true; // Delete all resources whose safe frame number has been reached. while (!m_resourcePurgatory.empty() && @@ -50,7 +51,18 @@ void GPUResourceManager::onRenderingResourceReleased(GPUResource* resource) { assert(resource->manager() == this); - if (m_currentFrameNumber > m_safeFrameNumber) + + // Hold the resource in purgatory (rather than freeing it now) only if GPU + // work that might reference it could still be in flight: + // * during normal rendering, while frames are unfinished + // (m_currentFrameNumber > m_safeFrameNumber); or + // * before the first frame (!m_didAdvanceFrameNumber), where a one-shot + // upload may have submitted work referencing a just-released staging + // buffer while m_currentFrameNumber == m_safeFrameNumber == 0. + // Otherwise -- the GPU has caught up to the current frame during rendering, + // or we're in a shutdown cycle (which implies m_didAdvanceFrameNumber) -- + // delete immediately. + if (m_currentFrameNumber > m_safeFrameNumber || !m_didAdvanceFrameNumber) { // Hold this resource until its safe frame number is reached. assert(resource->debugging_refcnt() == 0); @@ -61,7 +73,6 @@ } else { - // We're in a shutdown cycle. Delete immediately. delete resource; } }
diff --git a/renderer/src/metal/background_shader_compiler.mm b/renderer/src/metal/background_shader_compiler.mm index 7933ccc..d245103 100644 --- a/renderer/src/metal/background_shader_compiler.mm +++ b/renderer/src/metal/background_shader_compiler.mm
@@ -6,7 +6,6 @@ #include "generated/shaders/metal.glsl.hpp" #include "generated/shaders/constants.glsl.hpp" -#include "generated/shaders/image_draw_uniforms.glsl.hpp" #include "generated/shaders/flush_uniforms.glsl.hpp" #include "generated/shaders/common.glsl.hpp" #include "generated/shaders/advanced_blend.glsl.hpp" @@ -138,10 +137,6 @@ gpu::glsl::constants, gpu::glsl::flush_uniforms, gpu::glsl::common]; - if (drawType == DrawType::imageRect || drawType == DrawType::imageMesh) - { - [source appendFormat:@"%s\n", gpu::glsl::image_draw_uniforms]; - } if (enums::is_flag_set(shaderFeatures, ShaderFeatures::ENABLE_ADVANCED_BLEND)) {
diff --git a/renderer/src/metal/render_context_metal_impl.mm b/renderer/src/metal/render_context_metal_impl.mm index 18131db..b65100f 100644 --- a/renderer/src/metal/render_context_metal_impl.mm +++ b/renderer/src/metal/render_context_metal_impl.mm
@@ -1904,13 +1904,13 @@ length:sizeof(uint32_t) atIndex:METAL_BUFFER_IDX( PATH_BASE_INSTANCE_UNIFORM_BUFFER_IDX)]; - [encoder drawIndexedPrimitives:MTLPrimitiveTypeTriangle - indexCount:gpu::PatchIndexCount(drawType) - indexType:MTLIndexTypeUInt16 - indexBuffer:m_pathPatchIndexBuffer - indexBufferOffset:gpu::PatchBaseIndex(drawType) * - sizeof(uint16_t) - instanceCount:batch.elementCount]; + [encoder + drawIndexedPrimitives:MTLPrimitiveTypeTriangle + indexCount:batch.indexCountPerInstance + indexType:MTLIndexTypeUInt16 + indexBuffer:m_pathPatchIndexBuffer + indexBufferOffset:batch.baseIndex * sizeof(uint16_t) + instanceCount:batch.elementCount]; break; } case DrawType::interiorTriangulation: @@ -1931,15 +1931,10 @@ { [encoder setRenderPipelineState:drawPipelineState]; [encoder - setVertexBuffer:mtl_buffer(imageDrawUniformBufferRing()) - offset:batch.imageDrawDataOffset - atIndex:METAL_BUFFER_IDX( - IMAGE_DRAW_UNIFORM_BUFFER_IDX)]; - [encoder - setFragmentBuffer:mtl_buffer(imageDrawUniformBufferRing()) - offset:batch.imageDrawDataOffset - atIndex:METAL_BUFFER_IDX( - IMAGE_DRAW_UNIFORM_BUFFER_IDX)]; + setVertexBuffer:mtl_buffer(imageDrawInstanceBufferRing()) + offset:batch.baseElement * + sizeof(gpu::ImageDrawInstance) + atIndex:2]; [encoder setCullMode:MTLCullModeNone]; if (drawType == DrawType::imageRect) { @@ -1949,10 +1944,11 @@ atIndex:0]; [encoder drawIndexedPrimitives:MTLPrimitiveTypeTriangle - indexCount:std::size(gpu::kImageRectIndices) + indexCount:batch.indexCountPerInstance indexType:MTLIndexTypeUInt16 indexBuffer:m_imageRectIndexBuffer - indexBufferOffset:0]; + indexBufferOffset:batch.baseIndex * sizeof(uint16_t) + instanceCount:batch.elementCount]; } else { @@ -1971,10 +1967,10 @@ atIndex:1]; [encoder drawIndexedPrimitives:MTLPrimitiveTypeTriangle - indexCount:batch.elementCount + indexCount:batch.indexCountPerInstance indexType:MTLIndexTypeUInt16 indexBuffer:indexBuffer->submittedBuffer() - indexBufferOffset:batch.baseElement * + indexBufferOffset:batch.baseIndex * sizeof(uint16_t)]; } break;
diff --git a/renderer/src/render_context.cpp b/renderer/src/render_context.cpp index 23411c2..93a6d02 100644 --- a/renderer/src/render_context.cpp +++ b/renderer/src/render_context.cpp
@@ -776,7 +776,6 @@ // flush. const ResourceAllocationCounts resourceRequirements = { .flushUniformBufferCount = m_logicalFlushes.size(), - .imageDrawUniformBufferCount = totalFrameResourceCounts.imageDrawCount, .pathBufferCount = totalFrameResourceCounts.pathCount + layoutCounts.pathPaddingCount, .paintBufferCount = @@ -791,6 +790,7 @@ totalFrameResourceCounts.maxTessellatedSegmentCount, .triangleVertexBufferCount = totalFrameResourceCounts.maxTriangleVertexCount, + .imageDrawInstanceBufferCount = totalFrameResourceCounts.imageDrawCount, .gradTextureHeight = layoutCounts.maxGradTextureHeight, .tessTextureHeight = layoutCounts.maxTessTextureHeight, .atlasTextureWidth = layoutCounts.maxAtlasWidth, @@ -847,7 +847,6 @@ // create some slack for growth. constexpr static ResourceAllocationCounts OVERALLOC_x4 = { .flushUniformBufferCount = 5, // 125% - .imageDrawUniformBufferCount = 5, // 125% .pathBufferCount = 5, // 125% .paintBufferCount = 5, // 125% .paintAuxBufferCount = 5, // 125% @@ -855,6 +854,7 @@ .gradSpanBufferCount = 5, // 125% .tessSpanBufferCount = 5, // 125% .triangleVertexBufferCount = 5, // 125% + .imageDrawInstanceBufferCount = 5, // 125% .gradTextureHeight = 5, // 125% .tessTextureHeight = 5, // 125% .atlasTextureWidth = 5, // 125% @@ -899,7 +899,6 @@ // threshold. constexpr static ResourceAllocationCounts SHRINK_THRESHOLD_x3 = { .flushUniformBufferCount = 2, // 66.7% - .imageDrawUniformBufferCount = 2, // 66.7% .pathBufferCount = 2, // 66.7% .paintBufferCount = 2, // 66.7% .paintAuxBufferCount = 2, // 66.7% @@ -907,6 +906,7 @@ .gradSpanBufferCount = 2, // 66.7% .tessSpanBufferCount = 2, // 66.7% .triangleVertexBufferCount = 2, // 66.7% + .imageDrawInstanceBufferCount = 2, // 66.7% .gradTextureHeight = 2, // 66.7% .tessTextureHeight = 2, // 66.7% .atlasTextureWidth = 2, // 66.7% @@ -958,7 +958,7 @@ } assert(m_flushUniformData.elementsWritten() == m_logicalFlushes.size()); - assert(m_imageDrawUniformData.elementsWritten() == + assert(m_imageDrawInstanceData.elementsWritten() == totalFrameResourceCounts.imageDrawCount); assert(m_pathData.elementsWritten() == totalFrameResourceCounts.pathCount + @@ -2589,17 +2589,6 @@ sizeof(gpu::FlushUniforms)); } - LOG_BUFFER_RING_SIZE(imageDrawUniformBufferCount, - sizeof(gpu::ImageDrawUniforms)); - if (allocs.imageDrawUniformBufferCount != - m_currentResourceAllocations.imageDrawUniformBufferCount || - forceRealloc) - { - m_impl->resizeImageDrawUniformBuffer( - allocs.imageDrawUniformBufferCount * - sizeof(gpu::ImageDrawUniforms)); - } - LOG_BUFFER_RING_SIZE(pathBufferCount, sizeof(gpu::PathData)); if (allocs.pathBufferCount != m_currentResourceAllocations.pathBufferCount || @@ -2667,6 +2656,17 @@ sizeof(gpu::TriangleVertex)); } + LOG_BUFFER_RING_SIZE(imageDrawInstanceBufferCount, + sizeof(gpu::ImageDrawInstance)); + if (allocs.imageDrawInstanceBufferCount != + m_currentResourceAllocations.imageDrawInstanceBufferCount || + forceRealloc) + { + m_impl->resizeImageDrawInstanceBuffer( + allocs.imageDrawInstanceBufferCount * + sizeof(gpu::ImageDrawInstance)); + } + assert(allocs.gradTextureHeight <= kMaxTextureHeight); LOG_TEXTURE_SIZE(gradTextureHeight, gpu::kGradTextureWidth * 4); if (allocs.gradTextureHeight != @@ -2794,16 +2794,6 @@ } assert(m_flushUniformData.hasRoomFor(mapCounts.flushUniformBufferCount)); - if (mapCounts.imageDrawUniformBufferCount > 0) - { - HANDLE_MAP_FAILURE(m_imageDrawUniformData.mapElements( - m_impl.get(), - &RenderContextImpl::mapImageDrawUniformBuffer, - mapCounts.imageDrawUniformBufferCount)); - } - assert(m_imageDrawUniformData.hasRoomFor( - mapCounts.imageDrawUniformBufferCount > 0)); - if (mapCounts.pathBufferCount > 0) { HANDLE_MAP_FAILURE( @@ -2868,6 +2858,16 @@ assert( m_triangleVertexData.hasRoomFor(mapCounts.triangleVertexBufferCount)); + if (mapCounts.imageDrawInstanceBufferCount > 0) + { + HANDLE_MAP_FAILURE(m_imageDrawInstanceData.mapElements( + m_impl.get(), + &RenderContextImpl::mapImageDrawInstanceBuffer, + mapCounts.imageDrawInstanceBufferCount)); + } + assert(m_imageDrawInstanceData.hasRoomFor( + mapCounts.imageDrawInstanceBufferCount > 0)); + #undef HANDLE_MAP_FAILURE return true; } @@ -2883,13 +2883,6 @@ &RenderContextImpl::unmapFlushUniformBuffer, mapCounts.flushUniformBufferCount); } - if (m_imageDrawUniformData) - { - m_imageDrawUniformData.unmapElements( - m_impl.get(), - &RenderContextImpl::unmapImageDrawUniformBuffer, - mapCounts.imageDrawUniformBufferCount); - } if (m_pathData) { m_pathData.unmapElements(m_impl.get(), @@ -2934,6 +2927,13 @@ &RenderContextImpl::unmapTriangleVertexBuffer, mapCounts.triangleVertexBufferCount); } + if (m_imageDrawInstanceData) + { + m_imageDrawInstanceData.unmapElements( + m_impl.get(), + &RenderContextImpl::unmapImageDrawInstanceBuffer, + mapCounts.imageDrawInstanceBufferCount); + } } uint32_t RenderContext::incrementCoverageBufferPrefix( @@ -3448,22 +3448,22 @@ // with an image paint instead of calling this method. assert(!m_ctx->frameSupportsImagePaintForPaths()); - size_t imageDrawDataOffset = m_ctx->m_imageDrawUniformData.bytesWritten(); - m_ctx->m_imageDrawUniformData.emplace_back(draw->matrix(), - draw->opacity(), - draw->clipRectInverseMatrix(), - draw->clipID(), - draw->blendMode(), - m_currentZIndex); + const uint32_t imageDrawBaseInstance = + math::lossless_numeric_cast<uint32_t>( + m_ctx->m_imageDrawInstanceData.elementsWritten()); + m_ctx->m_imageDrawInstanceData.emplace_back(draw->matrix(), + draw->opacity(), + draw->clipRectInverseMatrix(), + draw->clipID(), + draw->blendMode(), + m_currentZIndex); DrawBatch& batch = pushDraw(draw, DrawType::imageRect, m_baselineShaderMiscFlags, PaintType::image, 1, - 0); - batch.imageDrawDataOffset = - math::lossless_numeric_cast<uint32_t>(imageDrawDataOffset); + imageDrawBaseInstance); return batch; } @@ -3473,25 +3473,26 @@ RIVE_PROF_SCOPE_L(2) assert(m_hasDoneLayout); - size_t imageDrawDataOffset = m_ctx->m_imageDrawUniformData.bytesWritten(); - m_ctx->m_imageDrawUniformData.emplace_back(draw->matrix(), - draw->opacity(), - draw->clipRectInverseMatrix(), - draw->clipID(), - draw->blendMode(), - m_currentZIndex); + const uint32_t imageDrawBaseInstance = + math::lossless_numeric_cast<uint32_t>( + m_ctx->m_imageDrawInstanceData.elementsWritten()); + m_ctx->m_imageDrawInstanceData.emplace_back(draw->matrix(), + draw->opacity(), + draw->clipRectInverseMatrix(), + draw->clipID(), + draw->blendMode(), + m_currentZIndex); DrawBatch& batch = pushDraw(draw, DrawType::imageMesh, m_baselineShaderMiscFlags, PaintType::image, - draw->indexCount(), - 0); + 1, // one instance (the mesh) + imageDrawBaseInstance); + batch.indexCountPerInstance = draw->indexCount(); batch.vertexBuffer = draw->vertexBuffer(); batch.uvBuffer = draw->uvBuffer(); batch.indexBuffer = draw->indexBuffer(); - batch.imageDrawDataOffset = - math::lossless_numeric_cast<uint32_t>(imageDrawDataOffset); return batch; } @@ -3621,6 +3622,107 @@ (currentImageSamplerKey == nextImageSamplerKey); } +constexpr uint32_t patchIndexCount(DrawType drawType) +{ + switch (drawType) + { + case DrawType::midpointFanPatches: + return kMidpointFanPatchIndexCount; + case DrawType::midpointFanCenterAAPatches: + return kMidpointFanCenterAAPatchIndexCount; + case DrawType::outerCurvePatches: + return kOuterCurvePatchIndexCount; + case DrawType::msaaStrokes: + return kMidpointFanPatchBorderIndexCount; + case DrawType::msaaMidpointFanBorrowedCoverage: + case DrawType::msaaMidpointFans: + case DrawType::msaaMidpointFanStencilReset: + case DrawType::msaaMidpointFanPathsStencil: + case DrawType::msaaMidpointFanPathsCover: + return kMidpointFanPatchIndexCount - + kMidpointFanPatchBorderIndexCount; + case DrawType::msaaOuterCubics: + return kOuterCurvePatchIndexCount - + kOuterCurvePatchBorderIndexCount; + case DrawType::interiorTriangulation: + case DrawType::atlasBlit: + case DrawType::imageRect: + case DrawType::imageMesh: + case DrawType::clipReset: + case DrawType::renderPassInitialize: + case DrawType::renderPassResolve: + RIVE_UNREACHABLE(); + } + RIVE_UNREACHABLE(); +} + +constexpr uint32_t patchBaseIndex(DrawType drawType) +{ + switch (drawType) + { + case DrawType::midpointFanPatches: + case DrawType::msaaStrokes: + return kMidpointFanPatchBaseIndex; + case DrawType::midpointFanCenterAAPatches: + return kMidpointFanCenterAAPatchBaseIndex; + case DrawType::outerCurvePatches: + return kOuterCurvePatchBaseIndex; + case DrawType::msaaMidpointFanBorrowedCoverage: + case DrawType::msaaMidpointFans: + case DrawType::msaaMidpointFanStencilReset: + case DrawType::msaaMidpointFanPathsStencil: + case DrawType::msaaMidpointFanPathsCover: + return kMidpointFanPatchBaseIndex + + kMidpointFanPatchBorderIndexCount; + case DrawType::msaaOuterCubics: + return kOuterCurvePatchBaseIndex + kOuterCurvePatchBorderIndexCount; + case DrawType::interiorTriangulation: + case DrawType::atlasBlit: + case DrawType::imageRect: + case DrawType::imageMesh: + case DrawType::clipReset: + case DrawType::renderPassInitialize: + case DrawType::renderPassResolve: + RIVE_UNREACHABLE(); + } + RIVE_UNREACHABLE(); +} + +static void assignDrawIndices(DrawType drawType, gpu::DrawBatch* batch) +{ + switch (drawType) + { + case DrawType::midpointFanPatches: + case DrawType::midpointFanCenterAAPatches: + case DrawType::outerCurvePatches: + case DrawType::msaaStrokes: + case DrawType::msaaMidpointFanBorrowedCoverage: + case DrawType::msaaMidpointFans: + case DrawType::msaaMidpointFanStencilReset: + case DrawType::msaaMidpointFanPathsStencil: + case DrawType::msaaMidpointFanPathsCover: + case DrawType::msaaOuterCubics: + batch->indexCountPerInstance = patchIndexCount(drawType); + batch->baseIndex = patchBaseIndex(drawType); + break; + case DrawType::imageRect: + batch->indexCountPerInstance = std::size(kImageRectIndices); + batch->baseIndex = 0; + break; + case DrawType::imageMesh: + case DrawType::interiorTriangulation: + case DrawType::atlasBlit: + case DrawType::clipReset: + case DrawType::renderPassInitialize: + case DrawType::renderPassResolve: + batch->indexCountPerInstance = 0; + batch->baseIndex = 0; + break; + default: + RIVE_UNREACHABLE(); + } +} + gpu::DrawBatch& RenderContext::LogicalFlush::pushDraw( const Draw* draw, DrawType drawType, @@ -3749,6 +3851,7 @@ draw->blendMode(), draw->imageSampler(), m_pendingBarriers); + assignDrawIndices(drawType, batch); } else {
diff --git a/renderer/src/render_context_helper_impl.cpp b/renderer/src/render_context_helper_impl.cpp index cc4c150..21b3670 100644 --- a/renderer/src/render_context_helper_impl.cpp +++ b/renderer/src/render_context_helper_impl.cpp
@@ -19,11 +19,6 @@ m_flushUniformBuffer = makeUniformBufferRing(sizeInBytes); } -void RenderContextHelperImpl::resizeImageDrawUniformBuffer(size_t sizeInBytes) -{ - m_imageDrawUniformBuffer = makeUniformBufferRing(sizeInBytes); -} - void RenderContextHelperImpl::resizePathBuffer( size_t sizeInBytes, gpu::StorageBufferStructure bufferStructure) @@ -67,16 +62,16 @@ m_triangleBuffer = makeVertexBufferRing(sizeInBytes); } +void RenderContextHelperImpl::resizeImageDrawInstanceBuffer(size_t sizeInBytes) +{ + m_imageDrawInstanceBuffer = makeVertexBufferRing(sizeInBytes); +} + void* RenderContextHelperImpl::mapFlushUniformBuffer(size_t mapSizeInBytes) { return m_flushUniformBuffer->mapBuffer(mapSizeInBytes); } -void* RenderContextHelperImpl::mapImageDrawUniformBuffer(size_t mapSizeInBytes) -{ - return m_imageDrawUniformBuffer->mapBuffer(mapSizeInBytes); -} - void* RenderContextHelperImpl::mapPathBuffer(size_t mapSizeInBytes) { return m_pathBuffer->mapBuffer(mapSizeInBytes); @@ -112,18 +107,17 @@ return m_triangleBuffer->mapBuffer(mapSizeInBytes); } +void* RenderContextHelperImpl::mapImageDrawInstanceBuffer(size_t mapSizeInBytes) +{ + return m_imageDrawInstanceBuffer->mapBuffer(mapSizeInBytes); +} + void RenderContextHelperImpl::unmapFlushUniformBuffer(size_t mapSizeInBytes) { assert(m_flushUniformBuffer->mapSizeInBytes() == mapSizeInBytes); m_flushUniformBuffer->unmapAndSubmitBuffer(); } -void RenderContextHelperImpl::unmapImageDrawUniformBuffer(size_t mapSizeInBytes) -{ - assert(m_imageDrawUniformBuffer->mapSizeInBytes() == mapSizeInBytes); - m_imageDrawUniformBuffer->unmapAndSubmitBuffer(); -} - void RenderContextHelperImpl::unmapPathBuffer(size_t mapSizeInBytes) { assert(m_pathBuffer->mapSizeInBytes() == mapSizeInBytes); @@ -165,4 +159,11 @@ assert(m_triangleBuffer->mapSizeInBytes() == mapSizeInBytes); m_triangleBuffer->unmapAndSubmitBuffer(); } + +void RenderContextHelperImpl::unmapImageDrawInstanceBuffer( + size_t mapSizeInBytes) +{ + assert(m_imageDrawInstanceBuffer->mapSizeInBytes() == mapSizeInBytes); + m_imageDrawInstanceBuffer->unmapAndSubmitBuffer(); +} } // namespace rive::gpu
diff --git a/renderer/src/shaders/atomic_draw.glsl b/renderer/src/shaders/atomic_draw.glsl index d43f6b7..151591f 100644 --- a/renderer/src/shaders/atomic_draw.glsl +++ b/renderer/src/shaders/atomic_draw.glsl
@@ -128,6 +128,22 @@ ATTR_BLOCK_BEGIN(Attrs) ATTR(0, float4, @a_imageRectVertex); ATTR_BLOCK_END + +ATTR_BLOCK_BEGIN(ImageDrawAttrs) +ATTR(IMAGE_VIEW_MATRIX_ATTRIB_IDX, float4, @a_imageDrawViewMatrix); +ATTR(IMAGE_CLIP_RECT_INVERSE_MATRIX_ATTRIB_IDX, + float4, + @a_imageDrawClipRectInverseMatrix); +ATTR(IMAGE_TRANSLATES_ATTRIB_IDX, float4, @a_imageDrawTranslates); +#ifdef SPLIT_UINT4_ATTRIBUTES +ATTR(IMAGE_SPLIT_OPACITY_ATTRIB_IDX, uint, @a_imageDrawOpacity); +ATTR(IMAGE_SPLIT_CLIP_ID_ATTRIB_IDX, uint, @a_imageDrawClipID); +ATTR(IMAGE_SPLIT_BLEND_MODE_ATTRIB_IDX, uint, @a_imageDrawBlendMode); +ATTR(IMAGE_SPLIT_ZINDEX_ATTRIB_IDX, uint, @a_imageDrawZIndex); +#else +ATTR(IMAGE_PACKED_ATTRIBS_IDX, uint4, @a_imageDrawPacked); +#endif +ATTR_BLOCK_END #endif VARYING_BLOCK_BEGIN @@ -136,25 +152,63 @@ #ifdef @ENABLE_CLIP_RECT NO_PERSPECTIVE VARYING(2, float4, v_clipRect); #endif +@OPTIONALLY_FLAT VARYING(3, half, v_imageOpacity); +#ifdef @ENABLE_CLIPPING +FLAT VARYING(4, ushort, v_imageClipID); +#endif +#ifdef @ENABLE_ADVANCED_BLEND +FLAT VARYING(5, ushort, v_imageBlendMode); +#endif VARYING_BLOCK_END #ifdef @VERTEX -IMAGE_RECT_VERTEX_MAIN(@drawVertexMain, Attrs, attrs, _vertexID, _instanceID) +IMAGE_RECT_VERTEX_MAIN(@drawVertexMain, + Attrs, + attrs, + ImageDrawAttrs, + imageDrawAttrs, + _vertexID, + _instanceID) { ATTR_UNPACK(_vertexID, attrs, @a_imageRectVertex, float4); + ATTR_UNPACK(_instanceID, imageDrawAttrs, @a_imageDrawViewMatrix, float4); + ATTR_UNPACK(_instanceID, + imageDrawAttrs, + @a_imageDrawClipRectInverseMatrix, + float4); + ATTR_UNPACK(_instanceID, imageDrawAttrs, @a_imageDrawTranslates, float4); +#ifdef SPLIT_UINT4_ATTRIBUTES + ATTR_UNPACK(_instanceID, imageDrawAttrs, @a_imageDrawOpacity, uint); + ATTR_UNPACK(_instanceID, imageDrawAttrs, @a_imageDrawClipID, uint); + ATTR_UNPACK(_instanceID, imageDrawAttrs, @a_imageDrawBlendMode, uint); + ATTR_UNPACK(_instanceID, imageDrawAttrs, @a_imageDrawZIndex, uint); + uint4 @a_imageDrawPacked = uint4(@a_imageDrawOpacity, + @a_imageDrawClipID, + @a_imageDrawBlendMode, + @a_imageDrawZIndex); +#else + ATTR_UNPACK(_instanceID, imageDrawAttrs, @a_imageDrawPacked, uint4); +#endif VARYING_INIT(v_texCoord, float2); VARYING_INIT(v_edgeCoverage, half); #ifdef @ENABLE_CLIP_RECT VARYING_INIT(v_clipRect, float4); #endif + VARYING_INIT(v_imageOpacity, half); +#ifdef @ENABLE_CLIPPING + VARYING_INIT(v_imageClipID, ushort); +#endif +#ifdef @ENABLE_ADVANCED_BLEND + VARYING_INIT(v_imageBlendMode, ushort); +#endif bool isOuterVertex = @a_imageRectVertex.z == .0 || @a_imageRectVertex.w == .0; v_edgeCoverage = isOuterVertex ? .0 : 1.; float2 vertexPosition = @a_imageRectVertex.xy; - float2x2 M = make_float2x2(imageDrawUniforms.viewMatrix); + float2x2 M = make_float2x2(@a_imageDrawViewMatrix); float2x2 MIT = transpose(inverse(M)); if (!isOuterVertex) { @@ -186,7 +240,7 @@ } v_texCoord = vertexPosition; - vertexPosition = MUL(M, vertexPosition) + imageDrawUniforms.translate; + vertexPosition = MUL(M, vertexPosition) + @a_imageDrawTranslates.xy; if (isOuterVertex) { @@ -200,12 +254,20 @@ if (@ENABLE_CLIP_RECT) { v_clipRect = find_clip_rect_coverage_distances( - make_float2x2(imageDrawUniforms.clipRectInverseMatrix), - imageDrawUniforms.clipRectInverseTranslate, + make_float2x2(@a_imageDrawClipRectInverseMatrix), + @a_imageDrawTranslates.zw, vertexPosition); } #endif + v_imageOpacity = uintBitsToFloat(@a_imageDrawPacked.x); +#ifdef @ENABLE_CLIPPING + v_imageClipID = cast_uint_to_ushort(@a_imageDrawPacked.y); +#endif +#ifdef @ENABLE_ADVANCED_BLEND + v_imageBlendMode = cast_uint_to_ushort(@a_imageDrawPacked.z); +#endif + float4 pos = RENDER_TARGET_COORD_TO_CLIP_COORD(vertexPosition); VARYING_PACK(v_texCoord); @@ -213,6 +275,13 @@ #ifdef @ENABLE_CLIP_RECT VARYING_PACK(v_clipRect); #endif + VARYING_PACK(v_imageOpacity); +#ifdef @ENABLE_CLIPPING + VARYING_PACK(v_imageClipID); +#endif +#ifdef @ENABLE_ADVANCED_BLEND + VARYING_PACK(v_imageBlendMode); +#endif EMIT_VERTEX(pos); } #endif // VERTEX @@ -226,6 +295,22 @@ ATTR_BLOCK_BEGIN(UVAttr) ATTR(1, float2, @a_texCoord); ATTR_BLOCK_END + +ATTR_BLOCK_BEGIN(ImageDrawAttrs) +ATTR(IMAGE_VIEW_MATRIX_ATTRIB_IDX, float4, @a_imageDrawViewMatrix); +ATTR(IMAGE_CLIP_RECT_INVERSE_MATRIX_ATTRIB_IDX, + float4, + @a_imageDrawClipRectInverseMatrix); +ATTR(IMAGE_TRANSLATES_ATTRIB_IDX, float4, @a_imageDrawTranslates); +#ifdef SPLIT_UINT4_ATTRIBUTES +ATTR(IMAGE_SPLIT_OPACITY_ATTRIB_IDX, uint, @a_imageDrawOpacity); +ATTR(IMAGE_SPLIT_CLIP_ID_ATTRIB_IDX, uint, @a_imageDrawClipID); +ATTR(IMAGE_SPLIT_BLEND_MODE_ATTRIB_IDX, uint, @a_imageDrawBlendMode); +ATTR(IMAGE_SPLIT_ZINDEX_ATTRIB_IDX, uint, @a_imageDrawZIndex); +#else +ATTR(IMAGE_PACKED_ATTRIBS_IDX, uint4, @a_imageDrawPacked); +#endif +ATTR_BLOCK_END #endif VARYING_BLOCK_BEGIN @@ -233,6 +318,13 @@ #ifdef @ENABLE_CLIP_RECT NO_PERSPECTIVE VARYING(1, float4, v_clipRect); #endif +@OPTIONALLY_FLAT VARYING(3, half, v_imageOpacity); +#ifdef @ENABLE_CLIPPING +FLAT VARYING(4, ushort, v_imageClipID); +#endif +#ifdef @ENABLE_ADVANCED_BLEND +FLAT VARYING(5, ushort, v_imageBlendMode); +#endif VARYING_BLOCK_END #ifdef @VERTEX @@ -241,36 +333,78 @@ position, UVAttr, uv, + ImageDrawAttrs, + imageDrawAttrs, _vertexID) { ATTR_UNPACK(_vertexID, position, @a_position, float2); ATTR_UNPACK(_vertexID, uv, @a_texCoord, float2); + ATTR_UNPACK(_instanceID, imageDrawAttrs, @a_imageDrawViewMatrix, float4); + ATTR_UNPACK(_instanceID, + imageDrawAttrs, + @a_imageDrawClipRectInverseMatrix, + float4); + ATTR_UNPACK(_instanceID, imageDrawAttrs, @a_imageDrawTranslates, float4); +#ifdef SPLIT_UINT4_ATTRIBUTES + ATTR_UNPACK(_instanceID, imageDrawAttrs, @a_imageDrawOpacity, uint); + ATTR_UNPACK(_instanceID, imageDrawAttrs, @a_imageDrawClipID, uint); + ATTR_UNPACK(_instanceID, imageDrawAttrs, @a_imageDrawBlendMode, uint); + ATTR_UNPACK(_instanceID, imageDrawAttrs, @a_imageDrawZIndex, uint); + uint4 @a_imageDrawPacked = uint4(@a_imageDrawOpacity, + @a_imageDrawClipID, + @a_imageDrawBlendMode, + @a_imageDrawZIndex); +#else + ATTR_UNPACK(_instanceID, imageDrawAttrs, @a_imageDrawPacked, uint4); +#endif VARYING_INIT(v_texCoord, float2); #ifdef @ENABLE_CLIP_RECT VARYING_INIT(v_clipRect, float4); #endif + VARYING_INIT(v_imageOpacity, half); +#ifdef @ENABLE_CLIPPING + VARYING_INIT(v_imageClipID, ushort); +#endif +#ifdef @ENABLE_ADVANCED_BLEND + VARYING_INIT(v_imageBlendMode, ushort); +#endif - float2x2 M = make_float2x2(imageDrawUniforms.viewMatrix); - float2 vertexPosition = MUL(M, @a_position) + imageDrawUniforms.translate; + float2x2 M = make_float2x2(@a_imageDrawViewMatrix); + float2 vertexPosition = MUL(M, @a_position) + @a_imageDrawTranslates.xy; v_texCoord = @a_texCoord; #ifdef @ENABLE_CLIP_RECT if (@ENABLE_CLIP_RECT) { v_clipRect = find_clip_rect_coverage_distances( - make_float2x2(imageDrawUniforms.clipRectInverseMatrix), - imageDrawUniforms.clipRectInverseTranslate, + make_float2x2(@a_imageDrawClipRectInverseMatrix), + @a_imageDrawTranslates.zw, vertexPosition); } #endif + v_imageOpacity = uintBitsToFloat(@a_imageDrawPacked.x); +#ifdef @ENABLE_CLIPPING + v_imageClipID = cast_uint_to_ushort(@a_imageDrawPacked.y); +#endif +#ifdef @ENABLE_ADVANCED_BLEND + v_imageBlendMode = cast_uint_to_ushort(@a_imageDrawPacked.z); +#endif + float4 pos = RENDER_TARGET_COORD_TO_CLIP_COORD(vertexPosition); VARYING_PACK(v_texCoord); #ifdef @ENABLE_CLIP_RECT VARYING_PACK(v_clipRect); #endif + VARYING_PACK(v_imageOpacity); +#ifdef @ENABLE_CLIPPING + VARYING_PACK(v_imageClipID); +#endif +#ifdef @ENABLE_ADVANCED_BLEND + VARYING_PACK(v_imageBlendMode); +#endif EMIT_VERTEX(pos); } #endif // VERTEX @@ -563,12 +697,9 @@ #ifdef @FIXED_FUNCTION_COLOR_OUTPUT #define ATOMIC_PLS_MAIN PLS_FRAG_COLOR_MAIN -#define ATOMIC_PLS_MAIN_WITH_IMAGE_UNIFORMS \ - PLS_FRAG_COLOR_MAIN_WITH_IMAGE_UNIFORMS #define EMIT_ATOMIC_PLS EMIT_PLS_AND_FRAG_COLOR #else // !FIXED_FUNCTION_COLOR_OUTPUT #define ATOMIC_PLS_MAIN PLS_MAIN -#define ATOMIC_PLS_MAIN_WITH_IMAGE_UNIFORMS PLS_MAIN_WITH_IMAGE_UNIFORMS #define EMIT_ATOMIC_PLS EMIT_PLS #endif @@ -767,7 +898,7 @@ #endif // @DRAW_INTERIOR_TRIANGLES || @ATLAS_BLIT #ifdef @DRAW_IMAGE -ATOMIC_PLS_MAIN_WITH_IMAGE_UNIFORMS(@drawFragmentMain) +ATOMIC_PLS_MAIN(@drawFragmentMain) { VARYING_UNPACK(v_texCoord, float2); #ifdef @DRAW_IMAGE_RECT @@ -776,6 +907,13 @@ #ifdef @ENABLE_CLIP_RECT VARYING_UNPACK(v_clipRect, float4); #endif + VARYING_UNPACK(v_imageOpacity, half); +#ifdef @ENABLE_CLIPPING + VARYING_UNPACK(v_imageClipID, ushort); +#endif +#ifdef @ENABLE_ADVANCED_BLEND + VARYING_UNPACK(v_imageBlendMode, ushort); +#endif // Start by finding the image color. We have to do this immediately instead // of allowing it to get resolved later like other draws because the @@ -808,7 +946,7 @@ #endif // TODO: consider not resolving the prior paint if we're solid and the prior // paint is not a clip update: (imageColor.a == 1. && - // imageDrawUniforms.blendMode == + // v_imageBlendMode == // BLEND_SRC_OVER && priorPaintType != // CLIP_UPDATE_PAINT_TYPE) resolve_paint(lastPathID, @@ -824,32 +962,31 @@ // the clip buffer. #ifdef @ENABLE_CLIPPING // TODO! ENABLE_IMAGE_CLIPPING in addition to // ENABLE_CLIPPING? - if (@ENABLE_CLIPPING && imageDrawUniforms.clipID != 0u) + if (@ENABLE_CLIPPING && v_imageClipID != 0u) { CLIP_VALUE_TYPE clipData = HAS_UPDATED_CLIP_VALUE(fragClipOut) ? fragClipOut : PLS_LOAD_CLIP_TYPE(clipBuffer); - apply_clip(imageDrawUniforms.clipID, clipData, imageCoverage); + apply_clip(v_imageClipID, clipData, imageCoverage); } #endif // ENABLE_CLIPPING // Prepare imageColor for premultiplied src-over blending. #if !defined(@FIXED_FUNCTION_COLOR_OUTPUT) && defined(@ENABLE_ADVANCED_BLEND) - if (@ENABLE_ADVANCED_BLEND && imageDrawUniforms.blendMode != BLEND_SRC_OVER) + if (@ENABLE_ADVANCED_BLEND && v_imageBlendMode != BLEND_SRC_OVER) { // Calculate what dstColorPremul will be after applying fragColorOut. half4 dstColorPremul = PLS_LOAD4F(colorBuffer) * (1. - fragColorOut.a) + fragColorOut; // Calculate the imageColor to emit *BEFORE* src-over blending, such // that the post-src-over-blend result is equivalent to the blendMode. - imageColor.rgb = advanced_color_blend( - unmultiply_rgb(imageColor), - dstColorPremul, - cast_uint_to_ushort(imageDrawUniforms.blendMode)) * + imageColor.rgb = advanced_color_blend(unmultiply_rgb(imageColor), + dstColorPremul, + v_imageBlendMode) * imageColor.a; } #endif // !FIXED_FUNCTION_COLOR_OUTPUT && ENABLE_ADVANCED_BLEND - imageColor *= imageCoverage * cast_float_to_half(imageDrawUniforms.opacity); + imageColor *= imageCoverage * v_imageOpacity; #if defined(@NEEDS_GAMMA_CORRECTION) imageColor = gamma_to_linear(imageColor);
diff --git a/renderer/src/shaders/constants.glsl b/renderer/src/shaders/constants.glsl index d580ca3..db798bb 100644 --- a/renderer/src/shaders/constants.glsl +++ b/renderer/src/shaders/constants.glsl
@@ -137,27 +137,28 @@ // bindings as low as 7.) #define FLUSH_UNIFORM_BUFFER_IDX 0 #define PATH_BASE_INSTANCE_UNIFORM_BUFFER_IDX 1 -#define IMAGE_DRAW_UNIFORM_BUFFER_IDX 2 -#define PATH_BUFFER_IDX 3 -#define PAINT_BUFFER_IDX 4 -#define PAINT_AUX_BUFFER_IDX 5 -#define CONTOUR_BUFFER_IDX 6 +#define PATH_BUFFER_IDX 2 +#define PAINT_BUFFER_IDX 3 +#define PAINT_AUX_BUFFER_IDX 4 +#define CONTOUR_BUFFER_IDX 5 // Coverage buffer used in coverageAtomic mode. -#define COVERAGE_BUFFER_IDX 7 -#define TESS_VERTEX_TEXTURE_IDX 8 -#define GRAD_TEXTURE_IDX 9 -#define FEATHER_TEXTURE_IDX 10 -#define ATLAS_TEXTURE_IDX 11 -#define IMAGE_TEXTURE_IDX 12 -#define DST_COLOR_TEXTURE_IDX 13 -#define DEFAULT_BINDINGS_SET_SIZE 14 +#define COVERAGE_BUFFER_IDX 6 +#define TESS_VERTEX_TEXTURE_IDX 7 +#define GRAD_TEXTURE_IDX 8 +#define FEATHER_TEXTURE_IDX 9 +#define ATLAS_TEXTURE_IDX 10 +#define IMAGE_TEXTURE_IDX 11 +#define DST_COLOR_TEXTURE_IDX 12 +#define DEFAULT_BINDINGS_SET_SIZE 13 // WebGPU needs image sampler index as a separate value. -#define WEBGPU_IMAGE_SAMPLER_IDX 14 -#define WEBGPU_BINDINGS_SET_SIZE 15 +#define WEBGPU_IMAGE_SAMPLER_IDX 13 +#define WEBGPU_BINDINGS_SET_SIZE 14 -// Metal doesn't allow us to bind buffers index 0 or 1. Offset them by 2. -#define METAL_BUFFER_IDX(IDX) (2 + IDX) +// In Metal, vertex attributes just come in as buffers. Since we use up to 3 +// vertex attrib buffers, offset the Rive resources by 3 so they don't alias +// with vertex attribs. +#define METAL_BUFFER_IDX(IDX) (3 + IDX) // PLS textures are accessed at the same index as their PLS planes, so we put // them in a separate binding set. @@ -186,6 +187,23 @@ // to alias this one. #define COALESCED_ATOMIC_RESOLVE_IDX SCRATCH_COLOR_PLANE_IDX +// Index of each instanced attribute for image draws. +#define IMAGE_FIRST_ATTRIB_IDX 2 +#define IMAGE_VIEW_MATRIX_ATTRIB_IDX 2 +#define IMAGE_CLIP_RECT_INVERSE_MATRIX_ATTRIB_IDX 3 +#define IMAGE_TRANSLATES_ATTRIB_IDX 4 +#define IMAGE_PACKED_ATTRIBS_IDX 5 +#define IMAGE_LAST_ATTRIB_IDX 5 +#define IMAGE_ATTRIB_COUNT (IMAGE_LAST_ATTRIB_IDX + 1 - IMAGE_FIRST_ATTRIB_IDX) + +// When SPLIT_UINT4_ATTRIBUTES is set (Unreal RHI, whose shader compiler +// mishandles a uint4 vertex attribute), the packed uint4 is bound as four +// separate uint attributes at these consecutive locations. +#define IMAGE_SPLIT_OPACITY_ATTRIB_IDX 5 +#define IMAGE_SPLIT_CLIP_ID_ATTRIB_IDX 6 +#define IMAGE_SPLIT_BLEND_MODE_ATTRIB_IDX 7 +#define IMAGE_SPLIT_ZINDEX_ATTRIB_IDX 8 + // MSAA attaches different resources to the framebuffer instead of PLS planes. #define MSAA_DEPTH_STENCIL_IDX 1u #define MSAA_RESOLVE_IDX 2u
diff --git a/renderer/src/shaders/d3d/root.sig b/renderer/src/shaders/d3d/root.sig index d0e66dc..9b4f3ca 100644 --- a/renderer/src/shaders/d3d/root.sig +++ b/renderer/src/shaders/d3d/root.sig
@@ -49,14 +49,13 @@ // go, to change a heap we would have to create a new one and use SetHeaps which // is very slow #define FLUSH_UNIFORM_BUFFFER_SIG_INDEX 0 -#define IMAGE_UNIFORM_BUFFFER_SIG_INDEX 1 -#define VERTEX_DRAW_UNIFORM_SIG_INDEX 2 -#define DYNAMIC_SRV_SIG_INDEX 3 -#define STATIC_SRV_SIG_INDEX 4 -#define IMAGE_SIG_INDEX 5 -#define UAV_SIG_INDEX 6 -#define SAMPLER_SIG_INDEX 7 -#define DYNAMIC_SAMPLER_SIG_INDEX 8 +#define VERTEX_DRAW_UNIFORM_SIG_INDEX 1 +#define DYNAMIC_SRV_SIG_INDEX 2 +#define STATIC_SRV_SIG_INDEX 3 +#define IMAGE_SIG_INDEX 4 +#define UAV_SIG_INDEX 5 +#define SAMPLER_SIG_INDEX 6 +#define DYNAMIC_SAMPLER_SIG_INDEX 7 #define SRV_START_HEAP_INDEX PATH_BUFFER_HEAP_OFFSET #define UAV_START_HEAP_INDEX ATOMIC_COLOR_HEAP_OFFSET @@ -68,26 +67,36 @@ #define ATLAS_RTV_HEAP_OFFSET 2 #define TARGET_RTV_HEAP_OFFSET 3 -// The root signature macro doesn't seem to support string splicing. We need to manually ensure the numbers here stay in sync with the above definitions. +// ROOT_SIG is only consumed by fxc when compiling the root signature. Guard it +// (and its constants.glsl include) out of the C++ translation units that pull in +// this file just for the heap/sig-index constants above -- they neither need +// ROOT_SIG nor should pull the shader constants into their translation unit. +#ifndef __cplusplus + +#include "../constants.glsl" +#define RIVE_STRINGIZE(X) #X +#define RIVE_STR(X) RIVE_STRINGIZE(X) + #define ROOT_SIG "RootFlags(ALLOW_INPUT_ASSEMBLER_INPUT_LAYOUT), " \ - "CBV(b0, flags=DATA_VOLATILE, visibility=SHADER_VISIBILITY_ALL), "\ - "CBV(b2, flags=DATA_VOLATILE, visibility=SHADER_VISIBILITY_ALL), "\ - "RootConstants(num32BitConstants=1, b1, visibility=SHADER_VISIBILITY_VERTEX), "\ - "DescriptorTable(SRV(t3), "\ - "SRV(t4),"\ - "SRV(t5),"\ - "SRV(t6), visibility=SHADER_VISIBILITY_ALL), "\ - "DescriptorTable(SRV(t8, flags=DESCRIPTORS_VOLATILE),"\ - "SRV(t9, flags=DESCRIPTORS_VOLATILE), "\ - "SRV(t10, flags=DESCRIPTORS_VOLATILE), " \ - "SRV(t11, flags=DESCRIPTORS_VOLATILE), visibility=SHADER_VISIBILITY_ALL), "\ - "DescriptorTable(SRV(t12, flags=DESCRIPTORS_VOLATILE), visibility=SHADER_VISIBILITY_PIXEL), "\ - "DescriptorTable(UAV(u0, flags=DESCRIPTORS_VOLATILE | DATA_VOLATILE),"\ - "UAV(u1, flags=DATA_VOLATILE),"\ - "UAV(u2, flags=DESCRIPTORS_VOLATILE | DATA_VOLATILE),"\ - "UAV(u3, flags=DATA_VOLATILE), visibility=SHADER_VISIBILITY_PIXEL),"\ - "DescriptorTable(Sampler(s8),"\ - "Sampler(s9),"\ - "Sampler(s10),"\ - "Sampler(s11), visibility=SHADER_VISIBILITY_ALL),"\ - "DescriptorTable(Sampler(s12, flags=DESCRIPTORS_VOLATILE), visibility=SHADER_VISIBILITY_PIXEL) " + "CBV(b" RIVE_STR(FLUSH_UNIFORM_BUFFER_IDX) ", flags=DATA_VOLATILE, visibility=SHADER_VISIBILITY_ALL), "\ + "RootConstants(num32BitConstants=1, b" RIVE_STR(PATH_BASE_INSTANCE_UNIFORM_BUFFER_IDX) ", visibility=SHADER_VISIBILITY_VERTEX), "\ + "DescriptorTable(SRV(t" RIVE_STR(PATH_BUFFER_IDX) "), "\ + "SRV(t" RIVE_STR(PAINT_BUFFER_IDX) "),"\ + "SRV(t" RIVE_STR(PAINT_AUX_BUFFER_IDX) "),"\ + "SRV(t" RIVE_STR(CONTOUR_BUFFER_IDX) "), visibility=SHADER_VISIBILITY_ALL), "\ + "DescriptorTable(SRV(t" RIVE_STR(TESS_VERTEX_TEXTURE_IDX) ", flags=DESCRIPTORS_VOLATILE),"\ + "SRV(t" RIVE_STR(GRAD_TEXTURE_IDX) ", flags=DESCRIPTORS_VOLATILE), "\ + "SRV(t" RIVE_STR(FEATHER_TEXTURE_IDX) ", flags=DESCRIPTORS_VOLATILE), "\ + "SRV(t" RIVE_STR(ATLAS_TEXTURE_IDX) ", flags=DESCRIPTORS_VOLATILE), visibility=SHADER_VISIBILITY_ALL), "\ + "DescriptorTable(SRV(t" RIVE_STR(IMAGE_TEXTURE_IDX) ", flags=DESCRIPTORS_VOLATILE), visibility=SHADER_VISIBILITY_PIXEL), "\ + "DescriptorTable(UAV(u" RIVE_STR(COLOR_PLANE_IDX) ", flags=DESCRIPTORS_VOLATILE | DATA_VOLATILE),"\ + "UAV(u" RIVE_STR(CLIP_PLANE_IDX) ", flags=DATA_VOLATILE),"\ + "UAV(u" RIVE_STR(SCRATCH_COLOR_PLANE_IDX) ", flags=DESCRIPTORS_VOLATILE | DATA_VOLATILE),"\ + "UAV(u" RIVE_STR(COVERAGE_PLANE_IDX) ", flags=DATA_VOLATILE), visibility=SHADER_VISIBILITY_PIXEL),"\ + "DescriptorTable(Sampler(s" RIVE_STR(TESS_VERTEX_TEXTURE_IDX) "),"\ + "Sampler(s" RIVE_STR(GRAD_TEXTURE_IDX) "),"\ + "Sampler(s" RIVE_STR(FEATHER_TEXTURE_IDX) "),"\ + "Sampler(s" RIVE_STR(ATLAS_TEXTURE_IDX) "), visibility=SHADER_VISIBILITY_ALL),"\ + "DescriptorTable(Sampler(s" RIVE_STR(IMAGE_TEXTURE_IDX) ", flags=DESCRIPTORS_VOLATILE), visibility=SHADER_VISIBILITY_PIXEL) " + +#endif // __cplusplus
diff --git a/renderer/src/shaders/draw_image_mesh.vert b/renderer/src/shaders/draw_image_mesh.vert index d29fc45..a3e96ea 100644 --- a/renderer/src/shaders/draw_image_mesh.vert +++ b/renderer/src/shaders/draw_image_mesh.vert
@@ -10,16 +10,36 @@ ATTR_BLOCK_BEGIN(UVAttr) ATTR(1, float2, @a_texCoord); ATTR_BLOCK_END + +ATTR_BLOCK_BEGIN(ImageDrawAttrs) +ATTR(IMAGE_VIEW_MATRIX_ATTRIB_IDX, float4, @a_imageDrawViewMatrix); +ATTR(IMAGE_CLIP_RECT_INVERSE_MATRIX_ATTRIB_IDX, + float4, + @a_imageDrawClipRectInverseMatrix); +ATTR(IMAGE_TRANSLATES_ATTRIB_IDX, float4, @a_imageDrawTranslates); +#ifdef SPLIT_UINT4_ATTRIBUTES +ATTR(IMAGE_SPLIT_OPACITY_ATTRIB_IDX, uint, @a_imageDrawOpacity); +ATTR(IMAGE_SPLIT_CLIP_ID_ATTRIB_IDX, uint, @a_imageDrawClipID); +ATTR(IMAGE_SPLIT_BLEND_MODE_ATTRIB_IDX, uint, @a_imageDrawBlendMode); +ATTR(IMAGE_SPLIT_ZINDEX_ATTRIB_IDX, uint, @a_imageDrawZIndex); +#else +ATTR(IMAGE_PACKED_ATTRIBS_IDX, uint4, @a_imageDrawPacked); +#endif +ATTR_BLOCK_END #endif VARYING_BLOCK_BEGIN -NO_PERSPECTIVE VARYING(0, float2, v_texCoord); +NO_PERSPECTIVE VARYING(0, float2, v_imageTexCoord); #ifdef @ENABLE_CLIPPING @OPTIONALLY_FLAT VARYING(1, half, v_clipID); #endif #if defined(@ENABLE_CLIP_RECT) && !defined(@RENDER_MODE_MSAA) NO_PERSPECTIVE VARYING(2, float4, v_clipRect); #endif +@OPTIONALLY_FLAT VARYING(3, half, v_imageOpacity); +#ifdef @ENABLE_ADVANCED_BLEND +FLAT VARYING(4, ushort, v_imageBlendMode); +#endif VARYING_BLOCK_END #ifdef @VERTEX @@ -31,28 +51,52 @@ position, UVAttr, uv, + ImageDrawAttrs, + imageDrawAttrs, _vertexID) { ATTR_UNPACK(_vertexID, position, @a_position, float2); ATTR_UNPACK(_vertexID, uv, @a_texCoord, float2); + ATTR_UNPACK(_instanceID, imageDrawAttrs, @a_imageDrawViewMatrix, float4); + ATTR_UNPACK(_instanceID, + imageDrawAttrs, + @a_imageDrawClipRectInverseMatrix, + float4); + ATTR_UNPACK(_instanceID, imageDrawAttrs, @a_imageDrawTranslates, float4); +#ifdef SPLIT_UINT4_ATTRIBUTES + ATTR_UNPACK(_instanceID, imageDrawAttrs, @a_imageDrawOpacity, uint); + ATTR_UNPACK(_instanceID, imageDrawAttrs, @a_imageDrawClipID, uint); + ATTR_UNPACK(_instanceID, imageDrawAttrs, @a_imageDrawBlendMode, uint); + ATTR_UNPACK(_instanceID, imageDrawAttrs, @a_imageDrawZIndex, uint); + uint4 @a_imageDrawPacked = uint4(@a_imageDrawOpacity, + @a_imageDrawClipID, + @a_imageDrawBlendMode, + @a_imageDrawZIndex); +#else + ATTR_UNPACK(_instanceID, imageDrawAttrs, @a_imageDrawPacked, uint4); +#endif - VARYING_INIT(v_texCoord, float2); + VARYING_INIT(v_imageTexCoord, float2); #ifdef @ENABLE_CLIPPING VARYING_INIT(v_clipID, half); #endif #if defined(@ENABLE_CLIP_RECT) && !defined(@RENDER_MODE_MSAA) VARYING_INIT(v_clipRect, float4); #endif + VARYING_INIT(v_imageOpacity, half); +#ifdef @ENABLE_ADVANCED_BLEND + VARYING_INIT(v_imageBlendMode, ushort); +#endif float2 vertexPosition = - MUL(make_float2x2(imageDrawUniforms.viewMatrix), @a_position) + - imageDrawUniforms.translate; - v_texCoord = @a_texCoord; + MUL(make_float2x2(@a_imageDrawViewMatrix), @a_position) + + @a_imageDrawTranslates.xy; + v_imageTexCoord = @a_texCoord; #ifdef @ENABLE_CLIPPING if (@ENABLE_CLIPPING) { - v_clipID = id_bits_to_f16(imageDrawUniforms.clipID, - uniforms.pathIDGranularity); + v_clipID = + id_bits_to_f16(@a_imageDrawPacked.y, uniforms.pathIDGranularity); } #endif #ifdef @ENABLE_CLIP_RECT @@ -60,13 +104,13 @@ { #ifndef @RENDER_MODE_MSAA v_clipRect = find_clip_rect_coverage_distances( - make_float2x2(imageDrawUniforms.clipRectInverseMatrix), - imageDrawUniforms.clipRectInverseTranslate, + make_float2x2(@a_imageDrawClipRectInverseMatrix), + @a_imageDrawTranslates.zw, vertexPosition CLIP_CONTEXT_UNPACK); #else set_clip_rect_plane_distances( - make_float2x2(imageDrawUniforms.clipRectInverseMatrix), - imageDrawUniforms.clipRectInverseTranslate, + make_float2x2(@a_imageDrawClipRectInverseMatrix), + @a_imageDrawTranslates.zw, vertexPosition CLIP_CONTEXT_UNPACK); #endif } @@ -76,16 +120,25 @@ pos.y = -pos.y; #endif #ifdef @RENDER_MODE_MSAA - pos.z = normalize_z_index(imageDrawUniforms.zIndex); + pos.z = normalize_z_index(@a_imageDrawPacked.w); #endif - VARYING_PACK(v_texCoord); + v_imageOpacity = uintBitsToFloat(@a_imageDrawPacked.x); +#ifdef @ENABLE_ADVANCED_BLEND + v_imageBlendMode = cast_uint_to_ushort(@a_imageDrawPacked.z); +#endif + + VARYING_PACK(v_imageTexCoord); #ifdef @ENABLE_CLIPPING VARYING_PACK(v_clipID); #endif #if defined(@ENABLE_CLIP_RECT) && !defined(@RENDER_MODE_MSAA) VARYING_PACK(v_clipRect); #endif + VARYING_PACK(v_imageOpacity); +#ifdef @ENABLE_ADVANCED_BLEND + VARYING_PACK(v_imageBlendMode); +#endif EMIT_VERTEX(pos); } #endif
diff --git a/renderer/src/shaders/draw_mesh.frag b/renderer/src/shaders/draw_mesh.frag index 85aa398..33ebd61 100644 --- a/renderer/src/shaders/draw_mesh.frag +++ b/renderer/src/shaders/draw_mesh.frag
@@ -49,13 +49,13 @@ #ifdef @FIXED_FUNCTION_COLOR_OUTPUT #ifdef @DRAW_IMAGE_MESH -PLS_FRAG_COLOR_MAIN_WITH_IMAGE_UNIFORMS(@drawFragmentMain) +PLS_FRAG_COLOR_MAIN(@drawFragmentMain) #else PLS_FRAG_COLOR_MAIN(@drawFragmentMain) #endif #else #ifdef @DRAW_IMAGE_MESH -PLS_MAIN_WITH_IMAGE_UNIFORMS(@drawFragmentMain) +PLS_MAIN(@drawFragmentMain) #else PLS_MAIN(@drawFragmentMain) #endif @@ -65,9 +65,6 @@ VARYING_UNPACK(v_paint, float4); VARYING_UNPACK(v_atlasCoord, float2); #endif -#ifdef @DRAW_IMAGE_MESH - VARYING_UNPACK(v_texCoord, float2); -#endif #ifdef @ENABLE_CLIPPING VARYING_UNPACK(v_clipID, half); #endif @@ -77,6 +74,13 @@ #if defined(@ATLAS_BLIT) && defined(@ENABLE_ADVANCED_BLEND) VARYING_UNPACK(v_blendMode, half); #endif +#ifdef @DRAW_IMAGE_MESH + VARYING_UNPACK(v_imageTexCoord, float2); + VARYING_UNPACK(v_imageOpacity, half); +#ifdef @ENABLE_ADVANCED_BLEND + VARYING_UNPACK(v_imageBlendMode, ushort); +#endif +#endif #ifdef @ATLAS_BLIT half4 color = find_paint_color(v_paint, 1. FRAGMENT_CONTEXT_UNPACK); @@ -89,7 +93,7 @@ #ifdef @DRAW_IMAGE_MESH half4 color = TEXTURE_SAMPLE_DYNAMIC_LODBIAS(@imageTexture, imageSampler, - v_texCoord, + v_imageTexCoord, uniforms.mipMapLODBias); half coverage = 1.; #endif @@ -128,7 +132,7 @@ #ifdef @DRAW_IMAGE_MESH // Apply opacity after clipping. - coverage *= imageDrawUniforms.opacity; + coverage *= v_imageOpacity; #endif #if !defined(@FIXED_FUNCTION_COLOR_OUTPUT) @@ -149,7 +153,7 @@ // We may want to experiment with dynamically not premultiplying here // and in find_paint_color() when the blend mode is srcOver. color.rgb = unmultiply_rgb(color); - ushort blendMode = cast_uint_to_ushort(imageDrawUniforms.blendMode); + ushort blendMode = v_imageBlendMode; #endif if (blendMode != BLEND_SRC_OVER)
diff --git a/renderer/src/shaders/draw_msaa_object.frag b/renderer/src/shaders/draw_msaa_object.frag index 953ec32..00d856f 100644 --- a/renderer/src/shaders/draw_msaa_object.frag +++ b/renderer/src/shaders/draw_msaa_object.frag
@@ -22,7 +22,11 @@ FRAG_DATA_MAIN(half4, @drawFragmentMain) { #ifdef @DRAW_IMAGE_MESH - VARYING_UNPACK(v_texCoord, float2); + VARYING_UNPACK(v_imageTexCoord, float2); + VARYING_UNPACK(v_imageOpacity, half); +#ifdef @ENABLE_ADVANCED_BLEND + VARYING_UNPACK(v_imageBlendMode, ushort); +#endif #else VARYING_UNPACK(v_paint, float4); #ifdef @ATLAS_BLIT @@ -36,9 +40,9 @@ #ifdef @DRAW_IMAGE_MESH half4 color = TEXTURE_SAMPLE_DYNAMIC_LODBIAS(@imageTexture, imageSampler, - v_texCoord, + v_imageTexCoord, uniforms.mipMapLODBias) * - imageDrawUniforms.opacity; + v_imageOpacity; #else half coverage = #ifdef @ATLAS_BLIT @@ -58,7 +62,7 @@ // Do the color portion of the blend mode in the shader. #ifdef @DRAW_IMAGE_MESH color.rgb = unmultiply_rgb(color); - ushort blendMode = cast_uint_to_ushort(imageDrawUniforms.blendMode); + ushort blendMode = v_imageBlendMode; #else // NOTE: for non-image-meshes, "color" is already unmultiplied because // GENERATE_PREMULTIPLIED_PAINT_COLORS is false when using advanced
diff --git a/renderer/src/shaders/glsl.glsl b/renderer/src/shaders/glsl.glsl index 31f03ff..71b913e 100644 --- a/renderer/src/shaders/glsl.glsl +++ b/renderer/src/shaders/glsl.glsl
@@ -502,10 +502,6 @@ #define PLS_FRAG_COLOR_MAIN(NAME) \ layout(location = 0, rgba8) out half4 _fragColor; \ PLS_MAIN(NAME) - -#define PLS_FRAG_COLOR_MAIN_WITH_IMAGE_UNIFORMS(NAME) \ - layout(location = 0, rgba8) out half4 _fragColor; \ - PLS_MAIN(NAME) #endif #endif @@ -634,10 +630,10 @@ int _vertexID = gl_VertexID; \ int _instanceID = INSTANCE_INDEX; -#define IMAGE_RECT_VERTEX_MAIN VERTEX_MAIN - // clang-format off -#define IMAGE_MESH_VERTEX_MAIN(NAME, PositionAttr, position, UVAttr, uv, _vertexID) \ +#define IMAGE_RECT_VERTEX_MAIN(NAME, Attrs, attrs, ImageDrawAttrs, imageDrawAttrs, _vertexID, _instanceID) \ + VERTEX_MAIN(NAME, Attrs, attrs, _vertexID, _instanceID) +#define IMAGE_MESH_VERTEX_MAIN(NAME, PositionAttr, position, UVAttr, uv, ImageDrawAttrs, imageDrawAttrs, _vertexID) \ VERTEX_MAIN(NAME, PositionAttr, position, _vertexID, _instanceID) // clang-format on @@ -686,20 +682,12 @@ PLS_STOREUI(PLANE, VALUE); #endif -#define PLS_MAIN_WITH_IMAGE_UNIFORMS(NAME) PLS_MAIN(NAME) - #ifndef PLS_FRAG_COLOR_MAIN #define PLS_FRAG_COLOR_MAIN(NAME) \ layout(location = 0) out half4 _fragColor; \ PLS_MAIN(NAME) #endif -#ifndef PLS_FRAG_COLOR_MAIN_WITH_IMAGE_UNIFORMS -#define PLS_FRAG_COLOR_MAIN_WITH_IMAGE_UNIFORMS(NAME) \ - layout(location = 0) out half4 _fragColor; \ - PLS_MAIN(NAME) -#endif - #define EMIT_PLS_AND_FRAG_COLOR EMIT_PLS #if defined(@TARGET_SPIRV) && !defined(@TARGET_WGSL)
diff --git a/renderer/src/shaders/hlsl.glsl b/renderer/src/shaders/hlsl.glsl index f45d6ff..785987d 100644 --- a/renderer/src/shaders/hlsl.glsl +++ b/renderer/src/shaders/hlsl.glsl
@@ -243,8 +243,16 @@ uint _instanceID = _instanceIDWithoutBase + baseInstance; \ Varyings _varyings; -#define IMAGE_RECT_VERTEX_MAIN(NAME, Attrs, attrs, _vertexID, _instanceID) \ - Varyings main(Attrs attrs, uint _vertexID : $SV_VertexID) \ +#define IMAGE_RECT_VERTEX_MAIN(NAME, \ + Attrs, \ + attrs, \ + ImageDrawAttrs, \ + imageDrawAttrs, \ + _vertexID, \ + _instanceID) \ + Varyings main(Attrs attrs, \ + ImageDrawAttrs imageDrawAttrs, \ + uint _vertexID : $SV_VertexID) \ { \ Varyings _varyings; \ float4 _pos; @@ -254,9 +262,12 @@ position, \ UVAttr, \ uv, \ + ImageDrawAttrs, \ + imageDrawAttrs, \ _vertexID) \ Varyings main(PositionAttr position, \ UVAttr uv, \ + ImageDrawAttrs imageDrawAttrs, \ uint _vertexID : $SV_VertexID) \ { \ Varyings _varyings; \ @@ -290,8 +301,6 @@ float2 _fragCoord = _varyings._pos.xy;\ int2 _plsCoord = int2(floor(_fragCoord)); -#define PLS_MAIN_WITH_IMAGE_UNIFORMS(NAME) PLS_MAIN(NAME) - #define EMIT_PLS } #define PLS_FRAG_COLOR_MAIN(NAME) \ @@ -301,8 +310,6 @@ int2 _plsCoord = int2(floor(_fragCoord)); \ half4 _fragColor; -#define PLS_FRAG_COLOR_MAIN_WITH_IMAGE_UNIFORMS(NAME) PLS_FRAG_COLOR_MAIN(NAME) - #define EMIT_PLS_AND_FRAG_COLOR \ } \ return _fragColor;
diff --git a/renderer/src/shaders/image_draw_uniforms.glsl b/renderer/src/shaders/image_draw_uniforms.glsl deleted file mode 100644 index 485402e..0000000 --- a/renderer/src/shaders/image_draw_uniforms.glsl +++ /dev/null
@@ -1,16 +0,0 @@ -#ifndef DRAW_IMAGE_UNIFORMS_NAME -#define DRAW_IMAGE_UNIFORMS_NAME @ImageDrawUniforms -#endif -UNIFORM_BLOCK_BEGIN(IMAGE_DRAW_UNIFORM_BUFFER_IDX, DRAW_IMAGE_UNIFORMS_NAME) -DECLARE_UNIFORM_FLOAT4(viewMatrix) -DECLARE_UNIFORM_FLOAT2(translate) -DECLARE_UNIFORM_FLOAT(opacity) -DECLARE_UNIFORM_FLOAT(padding) -// clipRectInverseMatrix transforms from pixel coordinates to a space where the -// clipRect is the normalized rectangle: [-1, -1, 1, 1]. -DECLARE_UNIFORM_FLOAT4(clipRectInverseMatrix) -DECLARE_UNIFORM_FLOAT2(clipRectInverseTranslate) -DECLARE_UNIFORM_UINT(clipID) -DECLARE_UNIFORM_UINT(blendMode) -DECLARE_UNIFORM_UINT(zIndex) -UNIFORM_BLOCK_END(imageDrawUniforms) \ No newline at end of file
diff --git a/renderer/src/shaders/metal.glsl b/renderer/src/shaders/metal.glsl index 6a2500d..17502a8 100644 --- a/renderer/src/shaders/metal.glsl +++ b/renderer/src/shaders/metal.glsl
@@ -212,14 +212,20 @@ Varyings _varyings; #endif -#define IMAGE_RECT_VERTEX_MAIN(NAME, Attrs, attrs, _vertexID, _instanceID) \ +#define IMAGE_RECT_VERTEX_MAIN(NAME, \ + Attrs, \ + attrs, \ + ImageDrawAttrs, \ + imageDrawAttrs, \ + _vertexID, \ + _instanceID) \ $__attribute__(($visibility("default"))) Varyings $vertex NAME( \ uint _vertexID [[$vertex_id]], \ + uint _instanceID [[$instance_id]], \ $constant @FlushUniforms& uniforms \ [[$buffer(METAL_BUFFER_IDX(FLUSH_UNIFORM_BUFFER_IDX))]], \ - $constant @ImageDrawUniforms& imageDrawUniforms \ - [[$buffer(METAL_BUFFER_IDX(IMAGE_DRAW_UNIFORM_BUFFER_IDX))]], \ $constant Attrs* attrs [[$buffer(0)]], \ + $constant ImageDrawAttrs* imageDrawAttrs [[$buffer(2)]], \ VertexTextures _textures, \ VertexStorageBuffers _buffers) \ { \ @@ -230,15 +236,17 @@ position, \ UVAttr, \ uv, \ + ImageDrawAttrs, \ + imageDrawAttrs, \ _vertexID) \ $__attribute__(($visibility("default"))) Varyings $vertex NAME( \ uint _vertexID [[$vertex_id]], \ + uint _instanceID [[$instance_id]], \ $constant @FlushUniforms& uniforms \ [[$buffer(METAL_BUFFER_IDX(FLUSH_UNIFORM_BUFFER_IDX))]], \ - $constant @ImageDrawUniforms& imageDrawUniforms \ - [[$buffer(METAL_BUFFER_IDX(IMAGE_DRAW_UNIFORM_BUFFER_IDX))]], \ $constant PositionAttr* position [[$buffer(0)]], \ - $constant UVAttr* uv [[$buffer(1)]]) \ + $constant UVAttr* uv [[$buffer(1)]], \ + $constant ImageDrawAttrs* imageDrawAttrs [[$buffer(2)]]) \ { \ Varyings _varyings; @@ -358,25 +366,7 @@ uint2 _plsCoord = uint2($metal::floor(_fragCoord)); \ uint _plsIdx = _plsCoord.y * uniforms.renderTargetWidth + _plsCoord.x; -#define PLS_METAL_MAIN_WITH_IMAGE_UNIFORMS(NAME) \ - $__attribute__(($visibility("default"))) $fragment NAME( \ - PLS _pls, \ - $constant @FlushUniforms& uniforms \ - [[$buffer(METAL_BUFFER_IDX(FLUSH_UNIFORM_BUFFER_IDX))]], \ - $constant @ImageDrawUniforms& imageDrawUniforms \ - [[$buffer(METAL_BUFFER_IDX(IMAGE_DRAW_UNIFORM_BUFFER_IDX))]], \ - Varyings _varyings [[$stage_in]], \ - DynamicSamplers _dynamicSampler, \ - FragmentTextures _textures, \ - FragmentStorageBuffers _buffers) \ - { \ - float2 _fragCoord = _varyings._pos.xy; \ - uint2 _plsCoord = uint2($metal::floor(_fragCoord)); \ - uint _plsIdx = _plsCoord.y * uniforms.renderTargetWidth + _plsCoord.x; - #define PLS_MAIN(NAME) void PLS_METAL_MAIN(NAME) -#define PLS_MAIN_WITH_IMAGE_UNIFORMS(NAME) \ - void PLS_METAL_MAIN_WITH_IMAGE_UNIFORMS(NAME) #define EMIT_PLS } #define PLS_FRAG_COLOR_MAIN(NAME) \ @@ -384,11 +374,6 @@ { \ half4 _fragColor; -#define PLS_FRAG_COLOR_MAIN_WITH_IMAGE_UNIFORMS(NAME) \ - half4 PLS_METAL_MAIN_WITH_IMAGE_UNIFORMS(NAME) \ - { \ - half4 _fragColor; - #define EMIT_PLS_AND_FRAG_COLOR \ } \ return _fragColor; \ @@ -454,19 +439,6 @@ FragmentTextures _textures, \ FragmentStorageBuffers _buffers) -#define PLS_MAIN_WITH_IMAGE_UNIFORMS(NAME) \ - PLS_METAL_MAIN( \ - NAME, \ - PLS _inpls, \ - $constant @FlushUniforms& uniforms \ - [[$buffer(METAL_BUFFER_IDX(FLUSH_UNIFORM_BUFFER_IDX))]], \ - Varyings _varyings [[$stage_in]], \ - FragmentTextures _textures, \ - FragmentStorageBuffers _buffers, \ - DynamicSamplers _dynamicSampler, \ - $constant @ImageDrawUniforms& imageDrawUniforms \ - [[$buffer(METAL_BUFFER_IDX(IMAGE_DRAW_UNIFORM_BUFFER_IDX))]]) - #define EMIT_PLS \ } \ return _pls; @@ -494,18 +466,6 @@ FragmentTextures _textures, \ FragmentStorageBuffers _buffers) -#define PLS_FRAG_COLOR_MAIN_WITH_IMAGE_UNIFORMS(NAME) \ - PLS_FRAG_COLOR_METAL_MAIN( \ - NAME, \ - PLS _inpls, \ - $constant @FlushUniforms& uniforms \ - [[$buffer(METAL_BUFFER_IDX(FLUSH_UNIFORM_BUFFER_IDX))]], \ - Varyings _varyings [[$stage_in]], \ - FragmentTextures _textures, \ - FragmentStorageBuffers _buffers, \ - $__VA_ARGS__ $constant @ImageDrawUniforms& imageDrawUniforms \ - [[$buffer(METAL_BUFFER_IDX(IMAGE_DRAW_UNIFORM_BUFFER_IDX))]]) - #define EMIT_PLS_AND_FRAG_COLOR \ } \ return {._color = _fragColor, ._pls = _pls};
diff --git a/renderer/src/shaders/metal/draw.metal b/renderer/src/shaders/metal/draw.metal index df9d7c7..43ebc75 100644 --- a/renderer/src/shaders/metal/draw.metal +++ b/renderer/src/shaders/metal/draw.metal
@@ -11,7 +11,6 @@ #define DRAW_IMAGE #include "flush_uniforms.minified.glsl" -#include "image_draw_uniforms.minified.glsl" #include "common.minified.glsl" #undef DRAW_IMAGE #define DRAW_PATH
diff --git a/renderer/src/shaders/rhi.glsl b/renderer/src/shaders/rhi.glsl index 769083e..0b7bbb6 100644 --- a/renderer/src/shaders/rhi.glsl +++ b/renderer/src/shaders/rhi.glsl
@@ -326,8 +326,16 @@ uint _instanceID = _instanceIDWithoutBase + $baseInstance; \ Varyings _varyings; -#define IMAGE_RECT_VERTEX_MAIN(NAME, Attrs, attrs, _vertexID, _instanceID) \ - Varyings NAME(Attrs attrs, uint _vertexID : $SV_VertexID) \ +#define IMAGE_RECT_VERTEX_MAIN(NAME, \ + Attrs, \ + attrs, \ + ImageDrawAttrs, \ + imageDrawAttrs, \ + _vertexID, \ + _instanceID) \ + Varyings NAME(Attrs attrs, \ + ImageDrawAttrs imageDrawAttrs, \ + uint _vertexID : $SV_VertexID) \ { \ Varyings _varyings; \ float4 _pos; @@ -337,9 +345,12 @@ position, \ UVAttr, \ uv, \ + ImageDrawAttrs, \ + imageDrawAttrs, \ _vertexID) \ Varyings NAME(PositionAttr position, \ UVAttr uv, \ + ImageDrawAttrs imageDrawAttrs, \ uint _vertexID : $SV_VertexID) \ { \ Varyings _varyings; \
diff --git a/renderer/src/shaders/spirv/atomic_base.glsl b/renderer/src/shaders/spirv/atomic_base.glsl index e31c36b..4eeeb2f 100644 --- a/renderer/src/shaders/spirv/atomic_base.glsl +++ b/renderer/src/shaders/spirv/atomic_base.glsl
@@ -12,7 +12,6 @@ #include "specialization.minified.glsl" #include "flush_uniforms.minified.glsl" #ifdef DRAW_IMAGE -#include "image_draw_uniforms.minified.glsl" #endif #include "common.minified.glsl" #include "advanced_blend.minified.glsl"
diff --git a/renderer/src/shaders/spirv/draw_clockwise_atomic_image_mesh.main b/renderer/src/shaders/spirv/draw_clockwise_atomic_image_mesh.main index 221a1fe..29d1d28 100644 --- a/renderer/src/shaders/spirv/draw_clockwise_atomic_image_mesh.main +++ b/renderer/src/shaders/spirv/draw_clockwise_atomic_image_mesh.main
@@ -10,7 +10,6 @@ #include "constants.minified.glsl" #include "specialization.minified.glsl" #include "flush_uniforms.minified.glsl" -#include "image_draw_uniforms.minified.glsl" #include "common.minified.glsl" #include "advanced_blend.minified.glsl" #include "draw_image_mesh.minified.vert"
diff --git a/renderer/src/shaders/spirv/draw_clockwise_image_mesh.main b/renderer/src/shaders/spirv/draw_clockwise_image_mesh.main index da72559..99daeda 100644 --- a/renderer/src/shaders/spirv/draw_clockwise_image_mesh.main +++ b/renderer/src/shaders/spirv/draw_clockwise_image_mesh.main
@@ -8,7 +8,6 @@ #include "constants.minified.glsl" #include "specialization.minified.glsl" #include "flush_uniforms.minified.glsl" -#include "image_draw_uniforms.minified.glsl" #include "common.minified.glsl" #include "advanced_blend.minified.glsl" #include "draw_image_mesh.minified.vert"
diff --git a/renderer/src/shaders/spirv/draw_image_mesh.main b/renderer/src/shaders/spirv/draw_image_mesh.main index da72559..99daeda 100644 --- a/renderer/src/shaders/spirv/draw_image_mesh.main +++ b/renderer/src/shaders/spirv/draw_image_mesh.main
@@ -8,7 +8,6 @@ #include "constants.minified.glsl" #include "specialization.minified.glsl" #include "flush_uniforms.minified.glsl" -#include "image_draw_uniforms.minified.glsl" #include "common.minified.glsl" #include "advanced_blend.minified.glsl" #include "draw_image_mesh.minified.vert"
diff --git a/renderer/src/shaders/spirv/draw_msaa_image_mesh.main b/renderer/src/shaders/spirv/draw_msaa_image_mesh.main index 929bdb9..b589e58 100644 --- a/renderer/src/shaders/spirv/draw_msaa_image_mesh.main +++ b/renderer/src/shaders/spirv/draw_msaa_image_mesh.main
@@ -9,7 +9,6 @@ #include "constants.minified.glsl" #include "specialization.minified.glsl" #include "flush_uniforms.minified.glsl" -#include "image_draw_uniforms.minified.glsl" #include "common.minified.glsl" #include "advanced_blend.minified.glsl" #include "draw_image_mesh.minified.vert"
diff --git a/renderer/src/shaders/unreal/atomic_base.ush b/renderer/src/shaders/unreal/atomic_base.ush index 38cfe07..1523d31 100644 --- a/renderer/src/shaders/unreal/atomic_base.ush +++ b/renderer/src/shaders/unreal/atomic_base.ush
@@ -9,7 +9,6 @@ #include "/Engine/Private/Common.ush" #else #include "flush_uniforms.minified.ush" -#include "image_draw_uniforms.minified.ush" #endif #include "Generated/constants.minified.ush"
diff --git a/renderer/src/shaders/unreal/atomic_draw_image_mesh.usf b/renderer/src/shaders/unreal/atomic_draw_image_mesh.usf index 8eb85ed..7635414 100644 --- a/renderer/src/shaders/unreal/atomic_draw_image_mesh.usf +++ b/renderer/src/shaders/unreal/atomic_draw_image_mesh.usf
@@ -1,4 +1,5 @@ #define DRAW_IMAGE #define DRAW_IMAGE_MESH +#define SPLIT_UINT4_ATTRIBUTES 1 #include "/Engine/Public/Platform.ush" #include "atomic_base.ush"
diff --git a/renderer/src/shaders/unreal/atomic_draw_image_rect.usf b/renderer/src/shaders/unreal/atomic_draw_image_rect.usf index 36fb167..54628ab 100644 --- a/renderer/src/shaders/unreal/atomic_draw_image_rect.usf +++ b/renderer/src/shaders/unreal/atomic_draw_image_rect.usf
@@ -1,4 +1,5 @@ #define DRAW_IMAGE #define DRAW_IMAGE_RECT +#define SPLIT_UINT4_ATTRIBUTES 1 #include "/Engine/Public/Platform.ush" #include "atomic_base.ush"
diff --git a/renderer/src/shaders/unreal/blend_texture.usf b/renderer/src/shaders/unreal/blend_texture.usf index 430590e..611de98 100644 --- a/renderer/src/shaders/unreal/blend_texture.usf +++ b/renderer/src/shaders/unreal/blend_texture.usf
@@ -11,7 +11,6 @@ #include "/Engine/Private/Common.ush" #else #include "flush_uniforms.minified.ush" -#include "image_draw_uniforms.minified.ush" #endif #include "Generated/constants.minified.ush"
diff --git a/renderer/src/shaders/unreal/draw_atlas_fill.usf b/renderer/src/shaders/unreal/draw_atlas_fill.usf index 6e5b979..482e370 100644 --- a/renderer/src/shaders/unreal/draw_atlas_fill.usf +++ b/renderer/src/shaders/unreal/draw_atlas_fill.usf
@@ -9,7 +9,6 @@ #include "/Engine/Private/Common.ush" #else #include "flush_uniforms.minified.ush" -#include "image_draw_uniforms.minified.ush" #endif #include "Generated/constants.minified.ush"
diff --git a/renderer/src/shaders/unreal/draw_atlas_stroke.usf b/renderer/src/shaders/unreal/draw_atlas_stroke.usf index e830bd0..b9d5ffe 100644 --- a/renderer/src/shaders/unreal/draw_atlas_stroke.usf +++ b/renderer/src/shaders/unreal/draw_atlas_stroke.usf
@@ -9,7 +9,6 @@ #include "/Engine/Private/Common.ush" #else #include "flush_uniforms.minified.ush" -#include "image_draw_uniforms.minified.ush" #endif #include "Generated/constants.minified.ush"
diff --git a/renderer/src/shaders/unreal/draw_clockwise_atlas_blit.usf b/renderer/src/shaders/unreal/draw_clockwise_atlas_blit.usf index d50060b..f2e1eba 100644 --- a/renderer/src/shaders/unreal/draw_clockwise_atlas_blit.usf +++ b/renderer/src/shaders/unreal/draw_clockwise_atlas_blit.usf
@@ -8,7 +8,6 @@ #include "/Engine/Private/Common.ush" #else #include "flush_uniforms.minified.ush" -#include "image_draw_uniforms.minified.ush" #endif #include "glsl.minified.glsl"
diff --git a/renderer/src/shaders/unreal/draw_clockwise_image_mesh.usf b/renderer/src/shaders/unreal/draw_clockwise_image_mesh.usf index 96ae92c..28a25ff 100644 --- a/renderer/src/shaders/unreal/draw_clockwise_image_mesh.usf +++ b/renderer/src/shaders/unreal/draw_clockwise_image_mesh.usf
@@ -8,7 +8,6 @@ #include "/Engine/Private/Common.ush" #else #include "flush_uniforms.minified.ush" -#include "image_draw_uniforms.minified.ush" #endif #include "glsl.minified.glsl"
diff --git a/renderer/src/shaders/unreal/draw_clockwise_interior_triangles.usf b/renderer/src/shaders/unreal/draw_clockwise_interior_triangles.usf index 9284e71..fa1e40d 100644 --- a/renderer/src/shaders/unreal/draw_clockwise_interior_triangles.usf +++ b/renderer/src/shaders/unreal/draw_clockwise_interior_triangles.usf
@@ -7,7 +7,6 @@ #include "/Engine/Private/Common.ush" #else #include "flush_uniforms.minified.ush" -#include "image_draw_uniforms.minified.ush" #endif #include "glsl.minified.glsl"
diff --git a/renderer/src/shaders/unreal/draw_clockwise_path.usf b/renderer/src/shaders/unreal/draw_clockwise_path.usf index 55544c4..440b979 100644 --- a/renderer/src/shaders/unreal/draw_clockwise_path.usf +++ b/renderer/src/shaders/unreal/draw_clockwise_path.usf
@@ -8,7 +8,6 @@ #include "/Engine/Private/Common.ush" #else #include "flush_uniforms.minified.ush" -#include "image_draw_uniforms.minified.ush" #endif #include "glsl.minified.glsl"
diff --git a/renderer/src/shaders/unreal/draw_image_mesh.usf b/renderer/src/shaders/unreal/draw_image_mesh.usf index 2a9e063..46fd21f 100644 --- a/renderer/src/shaders/unreal/draw_image_mesh.usf +++ b/renderer/src/shaders/unreal/draw_image_mesh.usf
@@ -2,6 +2,7 @@ #define OPTIONALLY_FLAT flat #define DRAW_IMAGE #define DRAW_IMAGE_MESH +#define SPLIT_UINT4_ATTRIBUTES 1 #define ENABLE_RASTERIZER_ORDERED_VIEWS #include "parse_environment.ush" @@ -11,7 +12,6 @@ #include "/Engine/Private/Common.ush" #else #include "flush_uniforms.minified.ush" -#include "image_draw_uniforms.minified.ush" #endif #include "Generated/constants.minified.ush"
diff --git a/renderer/src/shaders/unreal/draw_interior_triangles.usf b/renderer/src/shaders/unreal/draw_interior_triangles.usf index ff1e4b1..9bc0c88 100644 --- a/renderer/src/shaders/unreal/draw_interior_triangles.usf +++ b/renderer/src/shaders/unreal/draw_interior_triangles.usf
@@ -9,7 +9,6 @@ #include "/Engine/Private/Common.ush" #else #include "flush_uniforms.minified.ush" -#include "image_draw_uniforms.minified.ush" #endif #include "Generated/constants.minified.ush"
diff --git a/renderer/src/shaders/unreal/draw_msaa_atlas_blit.usf b/renderer/src/shaders/unreal/draw_msaa_atlas_blit.usf index d4bb99c..63ac8de 100644 --- a/renderer/src/shaders/unreal/draw_msaa_atlas_blit.usf +++ b/renderer/src/shaders/unreal/draw_msaa_atlas_blit.usf
@@ -14,7 +14,6 @@ #include "/Engine/Private/Common.ush" #else #include "flush_uniforms.minified.ush" -#include "image_draw_uniforms.minified.ush" #endif #include "Generated/constants.minified.ush"
diff --git a/renderer/src/shaders/unreal/draw_msaa_image_mesh.usf b/renderer/src/shaders/unreal/draw_msaa_image_mesh.usf index 0ed14fc..373ef7c 100644 --- a/renderer/src/shaders/unreal/draw_msaa_image_mesh.usf +++ b/renderer/src/shaders/unreal/draw_msaa_image_mesh.usf
@@ -1,6 +1,7 @@ #define OPTIONALLY_FLAT flat #define DRAW_IMAGE 1 #define DRAW_IMAGE_MESH 1 +#define SPLIT_UINT4_ATTRIBUTES 1 #define RENDER_MODE_MSAA 1 #if ENABLE_CLIP_RECT @@ -14,7 +15,6 @@ #include "/Engine/Private/Common.ush" #else #include "flush_uniforms.minified.ush" -#include "image_draw_uniforms.minified.ush" #endif #include "Generated/constants.minified.ush"
diff --git a/renderer/src/shaders/unreal/draw_msaa_path.usf b/renderer/src/shaders/unreal/draw_msaa_path.usf index 80ce081..21fe274 100644 --- a/renderer/src/shaders/unreal/draw_msaa_path.usf +++ b/renderer/src/shaders/unreal/draw_msaa_path.usf
@@ -14,7 +14,6 @@ #include "/Engine/Private/Common.ush" #else #include "flush_uniforms.minified.ush" -#include "image_draw_uniforms.minified.ush" #endif #include "Generated/constants.minified.ush"
diff --git a/renderer/src/shaders/unreal/draw_msaa_stencil.usf b/renderer/src/shaders/unreal/draw_msaa_stencil.usf index 81f387f..f20abef 100644 --- a/renderer/src/shaders/unreal/draw_msaa_stencil.usf +++ b/renderer/src/shaders/unreal/draw_msaa_stencil.usf
@@ -9,7 +9,6 @@ #include "/Engine/Private/Common.ush" #else #include "flush_uniforms.minified.ush" -#include "image_draw_uniforms.minified.ush" #endif #include "Generated/constants.minified.ush"
diff --git a/renderer/src/shaders/unreal/draw_path.usf b/renderer/src/shaders/unreal/draw_path.usf index f3d81e5..ff63eb8 100644 --- a/renderer/src/shaders/unreal/draw_path.usf +++ b/renderer/src/shaders/unreal/draw_path.usf
@@ -11,7 +11,6 @@ #include "/Engine/Private/Common.ush" #else #include "flush_uniforms.minified.ush" -#include "image_draw_uniforms.minified.ush" #endif #include "Generated/constants.minified.ush"
diff --git a/renderer/src/vulkan/common_layouts.hpp b/renderer/src/vulkan/common_layouts.hpp index c21fecd..93303ad 100644 --- a/renderer/src/vulkan/common_layouts.hpp +++ b/renderer/src/vulkan/common_layouts.hpp
@@ -1,6 +1,7 @@ #include "rive/renderer/gpu.hpp" #include "rive/renderer/vulkan/vkutil.hpp" #include "shaders/constants.glsl" +#include <array> #include <vulkan/vulkan.h> // Common layout descriptors shared by various pipelines. @@ -61,59 +62,118 @@ .pVertexAttributeDescriptions = INTERIOR_TRI_VERTEX_ATTRIBS, }; -constexpr VkVertexInputBindingDescription IMAGE_RECT_INPUT_BINDINGS[] = {{ - .binding = 0, - .stride = sizeof(rive::gpu::ImageRectVertex), - .inputRate = VK_VERTEX_INPUT_RATE_VERTEX, -}}; -constexpr VkVertexInputAttributeDescription IMAGE_RECT_VERTEX_ATTRIBS[] = { +// Concatenates the given geometryAttribs with Rive's ImageDrawInstance attribs +// (bound at 'binding'). +template <typename... GeometryAttribs> +constexpr std::array<VkVertexInputAttributeDescription, + sizeof...(GeometryAttribs) + IMAGE_ATTRIB_COUNT> +appendImageDrawInstanceAttribs(uint32_t binding, + GeometryAttribs... geometryAttribs) +{ + return {{ + geometryAttribs..., + { + .location = IMAGE_VIEW_MATRIX_ATTRIB_IDX, + .binding = binding, + .format = VK_FORMAT_R32G32B32A32_SFLOAT, + .offset = (IMAGE_VIEW_MATRIX_ATTRIB_IDX - IMAGE_FIRST_ATTRIB_IDX) * + sizeof(uint32_t) * 4, + }, + { + .location = IMAGE_CLIP_RECT_INVERSE_MATRIX_ATTRIB_IDX, + .binding = binding, + .format = VK_FORMAT_R32G32B32A32_SFLOAT, + .offset = (IMAGE_CLIP_RECT_INVERSE_MATRIX_ATTRIB_IDX - + IMAGE_FIRST_ATTRIB_IDX) * + sizeof(uint32_t) * 4, + }, + { + .location = IMAGE_TRANSLATES_ATTRIB_IDX, + .binding = binding, + .format = VK_FORMAT_R32G32B32A32_SFLOAT, + .offset = (IMAGE_TRANSLATES_ATTRIB_IDX - IMAGE_FIRST_ATTRIB_IDX) * + sizeof(uint32_t) * 4, + }, + { + .location = IMAGE_PACKED_ATTRIBS_IDX, + .binding = binding, + .format = VK_FORMAT_R32G32B32A32_UINT, + .offset = (IMAGE_PACKED_ATTRIBS_IDX - IMAGE_FIRST_ATTRIB_IDX) * + sizeof(uint32_t) * 4, + }, + }}; +} + +constexpr uint32_t ImageRectGeometryBufferBinding = 0; +constexpr uint32_t ImageRectImageAttribBufferBinding = 1; +constexpr VkVertexInputBindingDescription ImageRectInputBindings[] = { { + .binding = ImageRectGeometryBufferBinding, + .stride = sizeof(rive::gpu::ImageRectVertex), + .inputRate = VK_VERTEX_INPUT_RATE_VERTEX, + }, + { + .binding = ImageRectImageAttribBufferBinding, + .stride = sizeof(rive::gpu::ImageDrawInstance), + .inputRate = VK_VERTEX_INPUT_RATE_INSTANCE, + }, +}; +constexpr auto ImageRectVertexAttribs = appendImageDrawInstanceAttribs( + ImageRectImageAttribBufferBinding, + VkVertexInputAttributeDescription{ .location = 0, - .binding = 0, + .binding = ImageRectGeometryBufferBinding, .format = VK_FORMAT_R32G32B32A32_SFLOAT, .offset = 0, - }, -}; + }); constexpr VkPipelineVertexInputStateCreateInfo IMAGE_RECT_VERTEX_INPUT_STATE = { .sType = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO, - .vertexBindingDescriptionCount = std::size(IMAGE_RECT_INPUT_BINDINGS), - .pVertexBindingDescriptions = IMAGE_RECT_INPUT_BINDINGS, - .vertexAttributeDescriptionCount = std::size(IMAGE_RECT_VERTEX_ATTRIBS), - .pVertexAttributeDescriptions = IMAGE_RECT_VERTEX_ATTRIBS, + .vertexBindingDescriptionCount = std::size(ImageRectInputBindings), + .pVertexBindingDescriptions = ImageRectInputBindings, + .vertexAttributeDescriptionCount = std::size(ImageRectVertexAttribs), + .pVertexAttributeDescriptions = ImageRectVertexAttribs.data(), }; -constexpr VkVertexInputBindingDescription IMAGE_MESH_INPUT_BINDINGS[] = { +constexpr uint32_t ImageMeshVertexBufferBinding = 0; +constexpr uint32_t ImageMeshUVBufferBinding = 1; +constexpr uint32_t ImageMeshImageAttribBufferBinding = 2; +constexpr VkVertexInputBindingDescription ImageMeshInputBindings[] = { { - .binding = 0, + .binding = ImageMeshVertexBufferBinding, .stride = sizeof(float) * 2, .inputRate = VK_VERTEX_INPUT_RATE_VERTEX, }, { - .binding = 1, + .binding = ImageMeshUVBufferBinding, .stride = sizeof(float) * 2, .inputRate = VK_VERTEX_INPUT_RATE_VERTEX, }, -}; -constexpr VkVertexInputAttributeDescription IMAGE_MESH_VERTEX_ATTRIBS[] = { { - .location = 0, - .binding = 0, - .format = VK_FORMAT_R32G32_SFLOAT, - .offset = 0, - }, - { - .location = 1, - .binding = 1, - .format = VK_FORMAT_R32G32_SFLOAT, - .offset = 0, + .binding = ImageMeshImageAttribBufferBinding, + .stride = sizeof(rive::gpu::ImageDrawInstance), + .inputRate = VK_VERTEX_INPUT_RATE_INSTANCE, }, }; +constexpr auto ImageMeshVertexAttribs = + appendImageDrawInstanceAttribs(ImageMeshImageAttribBufferBinding, + VkVertexInputAttributeDescription{ + .location = 0, + .binding = ImageMeshVertexBufferBinding, + .format = VK_FORMAT_R32G32_SFLOAT, + .offset = 0, + }, + VkVertexInputAttributeDescription{ + .location = 1, + .binding = ImageMeshUVBufferBinding, + .format = VK_FORMAT_R32G32_SFLOAT, + .offset = 0, + }); constexpr VkPipelineVertexInputStateCreateInfo IMAGE_MESH_VERTEX_INPUT_STATE = { .sType = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO, - .vertexBindingDescriptionCount = std::size(IMAGE_MESH_INPUT_BINDINGS), - .pVertexBindingDescriptions = IMAGE_MESH_INPUT_BINDINGS, - .vertexAttributeDescriptionCount = std::size(IMAGE_MESH_VERTEX_ATTRIBS), - .pVertexAttributeDescriptions = IMAGE_MESH_VERTEX_ATTRIBS, + .vertexBindingDescriptionCount = std::size(ImageMeshInputBindings), + .pVertexBindingDescriptions = ImageMeshInputBindings, + .vertexAttributeDescriptionCount = std::size(ImageMeshVertexAttribs), + .pVertexAttributeDescriptions = ImageMeshVertexAttribs.data(), }; constexpr VkPipelineVertexInputStateCreateInfo EMPTY_VERTEX_INPUT_STATE = {
diff --git a/renderer/src/vulkan/pipeline_manager_vulkan.cpp b/renderer/src/vulkan/pipeline_manager_vulkan.cpp index dd2c699..3acd914 100644 --- a/renderer/src/vulkan/pipeline_manager_vulkan.cpp +++ b/renderer/src/vulkan/pipeline_manager_vulkan.cpp
@@ -106,13 +106,6 @@ VK_SHADER_STAGE_VERTEX_BIT | VK_SHADER_STAGE_FRAGMENT_BIT, }, { - .binding = IMAGE_DRAW_UNIFORM_BUFFER_IDX, - .descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC, - .descriptorCount = 1, - .stageFlags = - VK_SHADER_STAGE_VERTEX_BIT | VK_SHADER_STAGE_FRAGMENT_BIT, - }, - { .binding = PATH_BUFFER_IDX, .descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, .descriptorCount = 1,
diff --git a/renderer/src/vulkan/render_context_vulkan_impl.cpp b/renderer/src/vulkan/render_context_vulkan_impl.cpp index 4b14e6a..49b1a49 100644 --- a/renderer/src/vulkan/render_context_vulkan_impl.cpp +++ b/renderer/src/vulkan/render_context_vulkan_impl.cpp
@@ -40,7 +40,6 @@ constexpr uint32_t PLS_TRANSIENT_CLIP_IDX = 1u; constexpr VkDeviceSize ZERO_OFFSET[1] = {0}; -constexpr uint32_t ZERO_OFFSET_32[1] = {0}; static VkBufferUsageFlagBits render_buffer_usage_flags( RenderBufferType renderBufferType) @@ -987,7 +986,6 @@ vkutil::vendors::Qualcomm, }), m_flushUniformBufferPool(m_vk, VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT), - m_imageDrawUniformBufferPool(m_vk, VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT), m_pathBufferPool(m_vk, VK_BUFFER_USAGE_STORAGE_BUFFER_BIT), m_paintBufferPool(m_vk, VK_BUFFER_USAGE_STORAGE_BUFFER_BIT), m_paintAuxBufferPool(m_vk, VK_BUFFER_USAGE_STORAGE_BUFFER_BIT), @@ -995,6 +993,7 @@ m_gradSpanBufferPool(m_vk, VK_BUFFER_USAGE_VERTEX_BUFFER_BIT), m_tessSpanBufferPool(m_vk, VK_BUFFER_USAGE_VERTEX_BUFFER_BIT), m_triangleBufferPool(m_vk, VK_BUFFER_USAGE_VERTEX_BUFFER_BIT), + m_imageDrawInstanceBufferPool(m_vk, VK_BUFFER_USAGE_VERTEX_BUFFER_BIT), m_descriptorSetPoolPool(make_rcp<DescriptorSetPoolPool>(m_vk)) { const auto& physicalDeviceProps = m_vk->physicalDeviceProperties(); @@ -1242,7 +1241,6 @@ { // These should all have gotten recycled at the end of the last frame. assert(m_flushUniformBuffer == nullptr); - assert(m_imageDrawUniformBuffer == nullptr); assert(m_pathBuffer == nullptr); assert(m_paintBuffer == nullptr); assert(m_paintAuxBuffer == nullptr); @@ -1250,6 +1248,7 @@ assert(m_gradSpanBuffer == nullptr); assert(m_tessSpanBuffer == nullptr); assert(m_triangleBuffer == nullptr); + assert(m_imageDrawInstanceBuffer == nullptr); if (m_canvasCommandPool != VK_NULL_HANDLE) { @@ -1666,6 +1665,37 @@ { m_canvasQueue = queue; m_canvasQueueFamilyIndex = queueFamilyIndex; + + // The feather and null image textures are initialized once and only read. + // Every flush() lazily initializes them at its top, but that only does real + // work the first time and updates the CPU-side layout tracker. Later + // flushes note that these textures are already initialized and no-op. + // That's fine as long as the first flush() is also the first submit! + // + // The canvas pre-pass breaks that. The host flushes its main frame first -- + // recording the upload + transition into the main-frame command buffer and + // advancing the layout tracker -- then opens a pre-pass that flushes into + // its own command buffer, which commitCommandBuffer submits *before* the + // main-frame one (but *after* the main-frame one has been recorded). So + // these textures will still be uninitialized when the pre-pass command + // buffer executes. + // + // We have a queue here, before any frame has flushed, so initialize these + // textures eagerly in a one-shot command buffer in order to avoid + // submission-order hazards. + if (m_canvasQueue != VK_NULL_HANDLE && + (m_featherTexture->lastAccess().layout == VK_IMAGE_LAYOUT_UNDEFINED || + m_nullImageTexture->lastAccess().layout == VK_IMAGE_LAYOUT_UNDEFINED)) + { + if (void* cb = makeCommandBuffer()) + { + auto commandBuffer = reinterpret_cast<VkCommandBuffer>(cb); + m_featherTexture->prepareForVertexOrFragmentShaderRead( + commandBuffer); + m_nullImageTexture->prepareForFragmentShaderRead(commandBuffer); + commitCommandBuffer(cb); + } + } } void* RenderContextVulkanImpl::makeCommandBuffer() @@ -1731,7 +1761,6 @@ { // These should all have gotten recycled at the end of the last frame. assert(m_flushUniformBuffer == nullptr); - assert(m_imageDrawUniformBuffer == nullptr); assert(m_pathBuffer == nullptr); assert(m_paintBuffer == nullptr); assert(m_paintAuxBuffer == nullptr); @@ -1739,6 +1768,7 @@ assert(m_gradSpanBuffer == nullptr); assert(m_tessSpanBuffer == nullptr); assert(m_triangleBuffer == nullptr); + assert(m_imageDrawInstanceBuffer == nullptr); // Advance the context frame and delete resources that are no longer // referenced by in-flight command buffers. @@ -1753,7 +1783,6 @@ // Acquire buffers for the flush. m_flushUniformBuffer = m_flushUniformBufferPool.acquire(); - m_imageDrawUniformBuffer = m_imageDrawUniformBufferPool.acquire(); m_pathBuffer = m_pathBufferPool.acquire(); m_paintBuffer = m_paintBufferPool.acquire(); m_paintAuxBuffer = m_paintAuxBufferPool.acquire(); @@ -1761,6 +1790,7 @@ m_gradSpanBuffer = m_gradSpanBufferPool.acquire(); m_tessSpanBuffer = m_tessSpanBufferPool.acquire(); m_triangleBuffer = m_triangleBufferPool.acquire(); + m_imageDrawInstanceBuffer = m_imageDrawInstanceBufferPool.acquire(); } namespace descriptor_pool_limits @@ -2278,18 +2308,6 @@ m_vk->updateBufferDescriptorSets( descriptorSetAllocator.perFlushDescriptorSet(), { - .dstBinding = IMAGE_DRAW_UNIFORM_BUFFER_IDX, - .descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC, - }, - {{ - .buffer = *m_imageDrawUniformBuffer, - .offset = 0, - .range = sizeof(gpu::ImageDrawUniforms), - }}); - - m_vk->updateBufferDescriptorSets( - descriptorSetAllocator.perFlushDescriptorSet(), - { .dstBinding = PATH_BUFFER_IDX, .descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, }, @@ -2375,7 +2393,12 @@ .descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, }, {{ - .imageView = m_gradTexture->vkImageView(), + // When there are no gradients in this flush, the grad texture is + // never rendered and may still be in VK_IMAGE_LAYOUT_UNDEFINED. + // Bind the null texture as a layout satisfier. + .imageView = desc.gradSpanCount != 0 + ? m_gradTexture->vkImageView() + : m_nullImageTexture->vkImageView(), .imageLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, }}); @@ -2397,7 +2420,13 @@ .descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, }, {{ - .imageView = m_atlasTexture->vkImageView(), + // When there are no offscreen feathers in this flush, the atlas is + // never rendered and may still be in VK_IMAGE_LAYOUT_UNDEFINED. + // Bind the null texture as a layout satisfier. + .imageView = + (desc.atlasFillBatchCount | desc.atlasStrokeBatchCount) != 0 + ? m_atlasTexture->vkImageView() + : m_nullImageTexture->vkImageView(), .imageLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, }}); @@ -2435,8 +2464,8 @@ PER_FLUSH_BINDINGS_SET, 1, &descriptorSetAllocator.perFlushDescriptorSet(), - 1, - ZERO_OFFSET_32); + 0, + nullptr); m_vk->CmdBindPipeline(commandBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, @@ -2468,22 +2497,6 @@ m_gradTexture->lastAccess().layout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL; } - else - { - // The above render pass has the barriers in it, but if it was not run, - // we still are going to bind it as READ_ONLY_OPTIMAL so need to - // transition it - // TODO: Perhaps we should have a "null" texture that we can bind for - // cases like this where we need to bind all the textures but know it's - // not needed - m_gradTexture->barrier( - commandBuffer, - { - .pipelineStages = VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT, - .accessMask = VK_ACCESS_SHADER_READ_BIT, - .layout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, - }); - } // Tessellate all curves into vertices in the tessellation texture. if (desc.tessVertexSpanCount > 0) @@ -2539,8 +2552,8 @@ PER_FLUSH_BINDINGS_SET, 1, &descriptorSetAllocator.perFlushDescriptorSet(), - 1, - ZERO_OFFSET_32); + 0, + nullptr); m_vk->CmdBindPipeline(commandBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, @@ -2670,8 +2683,8 @@ PER_FLUSH_BINDINGS_SET, 1, &descriptorSetAllocator.perFlushDescriptorSet(), - 1, - ZERO_OFFSET_32); + 0, + nullptr); if (desc.atlasFillBatchCount != 0) { @@ -3314,8 +3327,8 @@ ? VULKAN_BINDINGS_SET_COUNT : VULKAN_BINDINGS_SET_COUNT - 1, drawDescriptorSets, - 1, - ZERO_OFFSET_32); + 0, + nullptr); for (int32_t y = drawBounds.top; y < drawBounds.bottom; y += virtualTileHeight) @@ -3461,22 +3474,14 @@ batch.imageSampler); } - VkDescriptorSet imageDescriptorSets[] = { - // Dynamic offset to imageDraw uniforms. - descriptorSetAllocator->perFlushDescriptorSet(), - // imageTexture. - imageDescriptorSet, - }; - static_assert(PER_DRAW_BINDINGS_SET == PER_FLUSH_BINDINGS_SET + 1); - m_vk->CmdBindDescriptorSets(commandBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, *drawRenderPass->pipelineLayout(), - PER_FLUSH_BINDINGS_SET, - std::size(imageDescriptorSets), - imageDescriptorSets, + PER_DRAW_BINDINGS_SET, 1, - &batch.imageDrawDataOffset); + &imageDescriptorSet, + 0, + nullptr); } // Setup the pipeline for this specific drawType and shaderFeatures. @@ -3647,9 +3652,9 @@ if (drawPipeline != nullptr) { m_vk->CmdDrawIndexed(commandBuffer, - gpu::PatchIndexCount(drawType), + batch.indexCountPerInstance, chunkPatchCount, - gpu::PatchBaseIndex(drawType), + batch.baseIndex, 0, chunkFirstPatch); } @@ -3683,10 +3688,16 @@ assert(desc.interlockMode == gpu::InterlockMode::atomics); m_vk->CmdBindVertexBuffers( commandBuffer, - 0, + layout::ImageRectGeometryBufferBinding, 1, m_imageRectVertexBuffer->vkBufferAddressOf(), ZERO_OFFSET); + m_vk->CmdBindVertexBuffers( + commandBuffer, + layout::ImageRectImageAttribBufferBinding, + 1, + m_imageDrawInstanceBuffer->vkBufferAddressOf(), + ZERO_OFFSET); m_vk->CmdBindIndexBuffer(commandBuffer, *m_imageRectIndexBuffer, 0, @@ -3694,11 +3705,11 @@ if (drawPipeline != nullptr) { m_vk->CmdDrawIndexed(commandBuffer, - std::size(gpu::kImageRectIndices), - 1, - batch.baseElement, + batch.indexCountPerInstance, + batch.elementCount, + batch.baseIndex, 0, - 0); + batch.baseElement); } break; } @@ -3716,16 +3727,22 @@ batch.indexBuffer); m_vk->CmdBindVertexBuffers( commandBuffer, - 0, + layout::ImageMeshVertexBufferBinding, 1, vertexBuffer->currentBuffer()->vkBufferAddressOf(), ZERO_OFFSET); m_vk->CmdBindVertexBuffers( commandBuffer, - 1, + layout::ImageMeshUVBufferBinding, 1, uvBuffer->currentBuffer()->vkBufferAddressOf(), ZERO_OFFSET); + m_vk->CmdBindVertexBuffers( + commandBuffer, + layout::ImageMeshImageAttribBufferBinding, + 1, + m_imageDrawInstanceBuffer->vkBufferAddressOf(), + ZERO_OFFSET); m_vk->CmdBindIndexBuffer(commandBuffer, *indexBuffer->currentBuffer(), 0, @@ -3733,11 +3750,11 @@ if (drawPipeline != nullptr) { m_vk->CmdDrawIndexed(commandBuffer, + batch.indexCountPerInstance, batch.elementCount, - 1, - batch.baseElement, + batch.baseIndex, 0, - 0); + batch.baseElement); } break; } @@ -3770,7 +3787,6 @@ { // Recycle buffers. m_flushUniformBufferPool.recycle(std::move(m_flushUniformBuffer)); - m_imageDrawUniformBufferPool.recycle(std::move(m_imageDrawUniformBuffer)); m_pathBufferPool.recycle(std::move(m_pathBuffer)); m_paintBufferPool.recycle(std::move(m_paintBuffer)); m_paintAuxBufferPool.recycle(std::move(m_paintAuxBuffer)); @@ -3778,6 +3794,7 @@ m_gradSpanBufferPool.recycle(std::move(m_gradSpanBuffer)); m_tessSpanBufferPool.recycle(std::move(m_tessSpanBuffer)); m_triangleBufferPool.recycle(std::move(m_triangleBuffer)); + m_imageDrawInstanceBufferPool.recycle(std::move(m_imageDrawInstanceBuffer)); } void RenderContextVulkanImpl::hotloadShaders(
diff --git a/renderer/src/webgpu/render_context_webgpu_impl.cpp b/renderer/src/webgpu/render_context_webgpu_impl.cpp index ff41da4..44dbbc4 100644 --- a/renderer/src/webgpu/render_context_webgpu_impl.cpp +++ b/renderer/src/webgpu/render_context_webgpu_impl.cpp
@@ -253,7 +253,6 @@ #include "generated/shaders/glsl.glsl.hpp" #include "generated/shaders/constants.glsl.hpp" -#include "generated/shaders/image_draw_uniforms.glsl.hpp" #include "generated/shaders/flush_uniforms.glsl.hpp" #include "generated/shaders/common.glsl.hpp" #include "generated/shaders/color_ramp.glsl.hpp" @@ -598,17 +597,6 @@ }, }, { - .binding = IMAGE_DRAW_UNIFORM_BUFFER_IDX, - .visibility = - wgpu::ShaderStage::Vertex | wgpu::ShaderStage::Fragment, - .buffer = - { - .type = wgpu::BufferBindingType::Uniform, - .hasDynamicOffset = true, - .minBindingSize = sizeof(gpu::ImageDrawUniforms), - }, - }, - { .binding = DST_COLOR_TEXTURE_IDX, .visibility = wgpu::ShaderStage::Fragment, .texture = @@ -618,7 +606,7 @@ }, }, }}; - static_assert(DRAW_BINDINGS_COUNT == 11); + static_assert(DRAW_BINDINGS_COUNT == 10); wgpu::BindGroupLayoutDescriptor perFlushBindingsDesc = { .entryCount = DRAW_BINDINGS_COUNT, @@ -1451,7 +1439,6 @@ glsl << gpu::glsl::draw_mesh_frag << '\n'; break; case DrawType::imageMesh: - glsl << gpu::glsl::image_draw_uniforms << '\n'; glsl << gpu::glsl::draw_image_mesh_vert << '\n'; glsl << gpu::glsl::draw_mesh_frag << '\n'; break; @@ -2909,6 +2896,40 @@ return m_atomicPLSCoverageBuffer; } +// Appends Rive's ImageDrawInstance attribs. The caller is responsible for +// placing these in a vertex buffer layout with WGPUVertexStepMode_Instance and +// arrayStride = sizeof(gpu::ImageDrawInstance). +template <uint32_t Capacity> +static void appendImageDrawInstanceAttribs( + StackVector<WGPUVertexAttribute, Capacity>& attrs) +{ + attrs.push_back({ + .format = WGPUVertexFormat_Float32x4, + .offset = (IMAGE_VIEW_MATRIX_ATTRIB_IDX - IMAGE_FIRST_ATTRIB_IDX) * + sizeof(uint32_t) * 4, + .shaderLocation = IMAGE_VIEW_MATRIX_ATTRIB_IDX, + }); + attrs.push_back({ + .format = WGPUVertexFormat_Float32x4, + .offset = (IMAGE_CLIP_RECT_INVERSE_MATRIX_ATTRIB_IDX - + IMAGE_FIRST_ATTRIB_IDX) * + sizeof(uint32_t) * 4, + .shaderLocation = IMAGE_CLIP_RECT_INVERSE_MATRIX_ATTRIB_IDX, + }); + attrs.push_back({ + .format = WGPUVertexFormat_Float32x4, + .offset = (IMAGE_TRANSLATES_ATTRIB_IDX - IMAGE_FIRST_ATTRIB_IDX) * + sizeof(uint32_t) * 4, + .shaderLocation = IMAGE_TRANSLATES_ATTRIB_IDX, + }); // translations + attrs.push_back({ + .format = WGPUVertexFormat_Uint32x4, + .offset = (IMAGE_PACKED_ATTRIBS_IDX - IMAGE_FIRST_ATTRIB_IDX) * + sizeof(uint32_t) * 4, + .shaderLocation = IMAGE_PACKED_ATTRIBS_IDX, + }); +} + wgpu::RenderPipeline RenderContextWebGPUImpl::makeDrawPipeline( gpu::DrawType drawType, gpu::ShaderFeatures shaderFeatures, @@ -2921,8 +2942,12 @@ const wgsl::Shader* fragmentShader, const gpu::PipelineState& pipelineState) { - std::vector<WGPUVertexAttribute> attrs; - std::vector<WGPUVertexBufferLayout> vertexBufferLayouts; + // The most vertex buffers any draw type binds is the image mesh: position, + // uv, and the per-instance attribute buffer. + StackVector<WGPUVertexBufferLayout, 3> vertexBufferLayouts; + // The image-draw attribs come last, so the most vertex attribs used across + // all 3 buffers is determined by the final image attrib. + StackVector<WGPUVertexAttribute, IMAGE_LAST_ATTRIB_IDX + 1> attrs; WGPUPrimitiveTopology topology; switch (drawType) { @@ -2937,21 +2962,19 @@ case DrawType::msaaMidpointFanPathsStencil: case DrawType::msaaMidpointFanPathsCover: { - attrs = { - WGPUVertexAttribute{ - .format = WGPUVertexFormat_Float32x4, - .offset = 0, - .shaderLocation = 0, - }, - WGPUVertexAttribute{ - .format = WGPUVertexFormat_Float32x4, - .offset = 4 * sizeof(float), - .shaderLocation = 1, - }, - }; + attrs.push_back({ + .format = WGPUVertexFormat_Float32x4, + .offset = 0, + .shaderLocation = 0, + }); + attrs.push_back({ + .format = WGPUVertexFormat_Float32x4, + .offset = 4 * sizeof(float), + .shaderLocation = 1, + }); - vertexBufferLayouts = {WGPU_VERTEX_BUFFER_LAYOUT_INIT}; - vertexBufferLayouts[0].attributeCount = std::size(attrs); + vertexBufferLayouts.push_back(WGPU_VERTEX_BUFFER_LAYOUT_INIT); + vertexBufferLayouts[0].attributeCount = attrs.size(); vertexBufferLayouts[0].attributes = attrs.data(); vertexBufferLayouts[0].arrayStride = sizeof(gpu::PatchVertex); vertexBufferLayouts[0].stepMode = WGPUVertexStepMode_Vertex; @@ -2963,16 +2986,14 @@ case DrawType::interiorTriangulation: case DrawType::atlasBlit: { - attrs = { - WGPUVertexAttribute{ - .format = WGPUVertexFormat_Float32x3, - .offset = 0, - .shaderLocation = 0, - }, - }; + attrs.push_back({ + .format = WGPUVertexFormat_Float32x3, + .offset = 0, + .shaderLocation = 0, + }); - vertexBufferLayouts = {WGPU_VERTEX_BUFFER_LAYOUT_INIT}; - vertexBufferLayouts[0].attributeCount = std::size(attrs); + vertexBufferLayouts.push_back(WGPU_VERTEX_BUFFER_LAYOUT_INIT); + vertexBufferLayouts[0].attributeCount = attrs.size(); vertexBufferLayouts[0].attributes = attrs.data(); vertexBufferLayouts[0].arrayStride = sizeof(gpu::TriangleVertex); vertexBufferLayouts[0].stepMode = WGPUVertexStepMode_Vertex; @@ -2982,40 +3003,43 @@ } case DrawType::imageRect: { - attrs = { - WGPUVertexAttribute{ - .format = WGPUVertexFormat_Float32x4, - .offset = 0, - .shaderLocation = 0, - }, - }; + attrs.push_back({ + .format = WGPUVertexFormat_Float32x4, + .offset = 0, + .shaderLocation = 0, + }); + appendImageDrawInstanceAttribs(attrs); - vertexBufferLayouts = {WGPU_VERTEX_BUFFER_LAYOUT_INIT}; - vertexBufferLayouts[0].attributeCount = std::size(attrs); - vertexBufferLayouts[0].attributes = attrs.data(); + vertexBufferLayouts.push_back_n(2, WGPU_VERTEX_BUFFER_LAYOUT_INIT); + vertexBufferLayouts[0].attributeCount = 1; + vertexBufferLayouts[0].attributes = &attrs[0]; vertexBufferLayouts[0].arrayStride = sizeof(gpu::ImageRectVertex); vertexBufferLayouts[0].stepMode = WGPUVertexStepMode_Vertex; + assert(attrs.size() == 1 + IMAGE_ATTRIB_COUNT); + vertexBufferLayouts[1].attributeCount = IMAGE_ATTRIB_COUNT; + vertexBufferLayouts[1].attributes = &attrs[1]; + vertexBufferLayouts[1].arrayStride = sizeof(gpu::ImageDrawInstance); + vertexBufferLayouts[1].stepMode = WGPUVertexStepMode_Instance; + topology = WGPUPrimitiveTopology_TriangleList; break; } case DrawType::imageMesh: { - attrs = { - WGPUVertexAttribute{ - .format = WGPUVertexFormat_Float32x2, - .offset = 0, - .shaderLocation = 0, - }, - WGPUVertexAttribute{ - .format = WGPUVertexFormat_Float32x2, - .offset = 0, - .shaderLocation = 1, - }, - }; + attrs.push_back({ + .format = WGPUVertexFormat_Float32x2, + .offset = 0, + .shaderLocation = 0, + }); + attrs.push_back({ + .format = WGPUVertexFormat_Float32x2, + .offset = 0, + .shaderLocation = 1, + }); + appendImageDrawInstanceAttribs(attrs); - vertexBufferLayouts = {WGPU_VERTEX_BUFFER_LAYOUT_INIT, - WGPU_VERTEX_BUFFER_LAYOUT_INIT}; + vertexBufferLayouts.push_back_n(3, WGPU_VERTEX_BUFFER_LAYOUT_INIT); vertexBufferLayouts[0].attributeCount = 1; vertexBufferLayouts[0].attributes = &attrs[0]; @@ -3027,6 +3051,12 @@ vertexBufferLayouts[1].arrayStride = sizeof(float) * 2; vertexBufferLayouts[1].stepMode = WGPUVertexStepMode_Vertex; + assert(attrs.size() == 2 + IMAGE_ATTRIB_COUNT); + vertexBufferLayouts[2].attributeCount = IMAGE_ATTRIB_COUNT; + vertexBufferLayouts[2].attributes = &attrs[2]; + vertexBufferLayouts[2].arrayStride = sizeof(gpu::ImageDrawInstance); + vertexBufferLayouts[2].stepMode = WGPUVertexStepMode_Instance; + topology = WGPUPrimitiveTopology_TriangleList; break; } @@ -3253,8 +3283,8 @@ .entryPoint = WGPU_STRING_VIEW("main"), .constantCount = vertexConstantCount, .constants = vertexConstantEntries, - .bufferCount = std::size(vertexBufferLayouts), - .buffers = vertexBufferLayouts.data(), + .bufferCount = vertexBufferLayouts.size(), + .buffers = vertexBufferLayouts.dataOrNull(), }, .primitive = { @@ -3965,11 +3995,6 @@ .textureView = m_gradientTextureView, }, { - .binding = IMAGE_DRAW_UNIFORM_BUFFER_IDX, - .buffer = webgpu_buffer(imageDrawUniformBufferRing()), - .size = sizeof(gpu::ImageDrawUniforms), - }, - { .binding = DST_COLOR_TEXTURE_IDX, .textureView = desc.interlockMode == gpu::InterlockMode::msaa && !desc.fixedFunctionColorOutput @@ -4271,8 +4296,15 @@ wgpu::BindGroup perFlushBindings = m_device.CreateBindGroup(&perFlushBindGroupDesc); + // The drawEncoder isn't necessarily created yet. (e.g., MSAA sometimes + // defers creation of the drawEncoder until the first barrier.) So defer + // binding the per-flush uniforms until we know the drawEncoder is valid. + bool needsPerFlushBindings = true; + + wgpu::TextureView boundImageTextureView = {}; + const ImageSampler* boundImageSampler; + // Execute the DrawList. - bool needsNewBindings = true; for (const DrawBatch& batch : *desc.drawList) { DrawType drawType = batch.drawType; @@ -4286,17 +4318,26 @@ // the barrier. Make sure to give the new drawEncoder our // current bindings. drawEncoder = renderPass->encoder(); - needsNewBindings = true; + needsPerFlushBindings = true; + boundImageTextureView = {}; } } + if (needsPerFlushBindings) + { + drawEncoder.SetBindGroup(PER_FLUSH_BINDINGS_SET, + perFlushBindings, + 0, + nullptr); + needsPerFlushBindings = false; + } + // Bind the appropriate image texture, if any. wgpu::TextureView imageTextureView = m_nullTextureView; if (auto imageTexture = static_cast<const TextureWebGPUImpl*>(batch.imageTexture)) { imageTextureView = imageTexture->textureView(); - needsNewBindings = true; } else if (drawType == gpu::DrawType::renderPassInitialize && desc.colorLoadAction == gpu::LoadAction::preserveRenderTarget) @@ -4308,7 +4349,6 @@ // attachment (not the target), so the target texture is free to // be sampled here to seed the color buffer. No dst copy needed. imageTextureView = renderTarget->targetTextureView(); - needsNewBindings = true; } else if (desc.interlockMode == gpu::InterlockMode::msaa) { @@ -4316,20 +4356,11 @@ // as the resolve target, so it seeds from the dstColorTexture // (copied from the framebuffer previously) instead. imageTextureView = renderTarget->dstColorTextureView(); - needsNewBindings = true; } } - - if (needsNewBindings || - // Image draws always re-bind because they update the dynamic offset - // to their uniforms. - gpu::DrawTypeIsImageDraw(drawType)) + if (boundImageTextureView.Get() != imageTextureView.Get() || + *boundImageSampler != batch.imageSampler) { - drawEncoder.SetBindGroup(PER_FLUSH_BINDINGS_SET, - perFlushBindings, - 1, - &batch.imageDrawDataOffset); - wgpu::BindGroupEntry perDrawBindingEntries[] = { { .binding = IMAGE_TEXTURE_IDX, @@ -4355,7 +4386,8 @@ 0, nullptr); - needsNewBindings = false; + boundImageTextureView = std::move(imageTextureView); + boundImageSampler = &batch.imageSampler; } // Setup the pipeline for this specific drawType and shaderFeatures. @@ -4483,9 +4515,9 @@ drawEncoder.SetVertexBuffer(0, m_pathPatchVertexBuffer); drawEncoder.SetIndexBuffer(m_pathPatchIndexBuffer, wgpu::IndexFormat::Uint16); - drawEncoder.DrawIndexed(gpu::PatchIndexCount(drawType), + drawEncoder.DrawIndexed(batch.indexCountPerInstance, batch.elementCount, - gpu::PatchBaseIndex(drawType), + batch.baseIndex, 0, batch.baseElement); break; @@ -4506,11 +4538,21 @@ { assert(desc.interlockMode == gpu::InterlockMode::atomics); drawEncoder.SetVertexBuffer(0, m_imageRectVertexBuffer); + // Select the batch's fistInstance by offsetting the buffer + // binding. We do this rather than "firstInstance=baseElement" + // on the draw call because baseInstance support isn't portable + // on GL, and we have seen drivers with bugs in their emulation. + drawEncoder.SetVertexBuffer( + 1, + webgpu_buffer(imageDrawInstanceBufferRing()), + batch.baseElement * sizeof(gpu::ImageDrawInstance)); drawEncoder.SetIndexBuffer(m_imageRectIndexBuffer, wgpu::IndexFormat::Uint16); - drawEncoder.DrawIndexed(std::size(gpu::kImageRectIndices), - 1, - batch.baseElement); + drawEncoder.DrawIndexed(batch.indexCountPerInstance, + batch.elementCount, + batch.baseIndex, + 0, + 0); break; } @@ -4524,11 +4566,21 @@ batch.indexBuffer); drawEncoder.SetVertexBuffer(0, vertexBuffer->submittedBuffer()); drawEncoder.SetVertexBuffer(1, uvBuffer->submittedBuffer()); + // Select the batch's fistInstance by offsetting the buffer + // binding. We do this rather than "firstInstance=baseElement" + // on the draw call because baseInstance support isn't portable + // on GL, and we have seen drivers with bugs in their emulation. + drawEncoder.SetVertexBuffer( + 2, + webgpu_buffer(imageDrawInstanceBufferRing()), + batch.baseElement * sizeof(gpu::ImageDrawInstance)); drawEncoder.SetIndexBuffer(indexBuffer->submittedBuffer(), wgpu::IndexFormat::Uint16); - drawEncoder.DrawIndexed(batch.elementCount, - 1, - batch.baseElement); + drawEncoder.DrawIndexed(batch.indexCountPerInstance, + batch.elementCount, + batch.baseIndex, + 0, + 0); break; }
diff --git a/tests/common/testing_window_android_vulkan.cpp b/tests/common/testing_window_android_vulkan.cpp index 3d773a8..2085869 100644 --- a/tests/common/testing_window_android_vulkan.cpp +++ b/tests/common/testing_window_android_vulkan.cpp
@@ -386,15 +386,13 @@ void onceAfterGM() override { - // Mali devices with a driver version before 50 have been known to run - // out of memory, so for these devices, tear down the device between - // GMs. + // Mali drivers appear to have an internal memory leak, so for these + // devices, tear down the device between tests. // Adreno devices pre 1.3 (specifically Galaxy A11, Adreno 506, running // Vulkan 1.1) also have sporadic crashes, and tearing down the device // appears to help. if (m_device != nullptr && - ((strstr(m_device->name().c_str(), "Mali") != nullptr && - m_device->driverVersion().major < 50) || + (strstr(m_device->name().c_str(), "Mali") != nullptr || (strstr(m_device->name().c_str(), "Adreno (TM) 5") != nullptr && m_device->vulkanFeatures().apiVersion < VK_API_VERSION_1_3))) {
diff --git a/tests/goldens/goldens.cpp b/tests/goldens/goldens.cpp index 5e6ba29..ac2cb54 100644 --- a/tests/goldens/goldens.cpp +++ b/tests/goldens/goldens.cpp
@@ -34,26 +34,94 @@ GoldensArguments s_args; +class RIVLoader +{ +public: + RIVLoader(const std::vector<uint8_t>& rivBytes, + const char* artboardName, + const char* stateMachineName) + { + m_file = rive::File::import(rivBytes, TestingWindow::Get()->factory()); + if (m_file == nullptr) + { + throw "Bad riv file"; + } + if (artboardName != nullptr && artboardName[0] != '\0') + { + m_artboard = m_file->artboardNamed(artboardName); + } + else + { + m_artboard = m_file->artboardDefault(); + } + if (m_artboard == nullptr) + { + throw "Can't load artboard"; + } + + // Bind the default view model instance + m_viewModelInstance = m_file->createViewModelInstance(m_artboard.get()); + m_artboard->bindViewModelInstance(m_viewModelInstance); + + if (stateMachineName != nullptr && stateMachineName[0] != '\0') + { + m_scene = m_artboard->stateMachineNamed(stateMachineName); + } + else + { + m_scene = m_artboard->defaultStateMachine(); + } + + if (m_scene == nullptr) + { + // This is a riv without any state machines. Just draw the artboard. + m_scene = std::make_unique<rive::StaticScene>(m_artboard.get()); + } + + if (m_scene != nullptr && m_viewModelInstance != nullptr) + { + m_scene->bindViewModelInstance(m_viewModelInstance); + } + } + + rive::Scene* stateMachine() const { return m_scene.get(); } + +private: + rive::rcp<rive::File> m_file; + std::unique_ptr<rive::ArtboardInstance> m_artboard; + std::unique_ptr<rive::Scene> m_scene; + rive::rcp<rive::ViewModelInstance> m_viewModelInstance; +}; + static bool render_and_dump_png(int cellSize, const char* rivName, - rive::Scene* scene) + const std::vector<uint8_t>& rivBytes, + const char* artboardName, + const char* stateMachineName) { + int windowWidth = cellSize * s_args.cols(); + int windowHeight = cellSize * s_args.rows(); + TestingWindow::Get()->resize(windowWidth, windowHeight); + if (s_args.verbose()) { printf("[goldens] Running %s...\n", rivName); } try { + RIVLoader riv(rivBytes, artboardName, stateMachineName); + rive::Scene* stateMachine = riv.stateMachine(); + const int frames = s_args.cols() * s_args.rows(); - const double duration = scene->durationSeconds(); + const double duration = stateMachine->durationSeconds(); const double frameDuration = duration / frames; const rive::AABB cellBounds = rive::AABB(0, 0, cellSize, cellSize); - // Render the scene in a grid. + // Render the stateMachine in a grid. auto renderer = TestingWindow::Get()->beginFrame({.clearColor = 0xffffffff}); renderer->save(); - scene->advanceAndApply(0); + stateMachine->advanceAndApply(0); for (int y = 0; y < s_args.rows(); ++y) { for (int x = 0; x < s_args.cols(); ++x) @@ -62,7 +130,7 @@ { TestingWindow::Get()->endFrame(); TestingWindow::Get()->beginFrame({.doClear = false}); - scene->advanceAndApply(frameDuration); + stateMachine->advanceAndApply(frameDuration); } renderer->save(); @@ -71,8 +139,8 @@ renderer->align(rive::Fit::cover, rive::Alignment::center, cellBounds, - scene->bounds()); - scene->draw(renderer.get()); + stateMachine->bounds()); + stateMachine->draw(renderer.get()); renderer->restore(); } @@ -80,13 +148,11 @@ renderer->restore(); // Save the png. - int windowWidth = s_args.cols() * cellSize; - int windowHeight = s_args.rows() * cellSize; std::vector<uint8_t> pixels; TestingWindow::Get()->endFrame(&pixels); assert(pixels.size() == windowHeight * windowWidth * 4); - std::ostringstream imageName; + std::ostringstream imageName; imageName << std::filesystem::path(rivName) .filename() .stem() @@ -150,68 +216,14 @@ fprintf(stderr, "error rendering %s\n", rivName); abort(); } + + // Allow the testing window to do any cleanup it might want to do between + // GMs + TestingWindow::Get()->onceAfterGM(); + return true; } -class RIVLoader -{ -public: - RIVLoader(const std::vector<uint8_t>& rivBytes, - const char* artboardName, - const char* stateMachineName) - { - m_file = rive::File::import(rivBytes, TestingWindow::Get()->factory()); - if (m_file == nullptr) - { - throw "Bad riv file"; - } - if (artboardName != nullptr && artboardName[0] != '\0') - { - m_artboard = m_file->artboardNamed(artboardName); - } - else - { - m_artboard = m_file->artboardDefault(); - } - if (m_artboard == nullptr) - { - throw "Can't load artboard"; - } - - // Bind the default view model instance - m_viewModelInstance = m_file->createViewModelInstance(m_artboard.get()); - m_artboard->bindViewModelInstance(m_viewModelInstance); - - if (stateMachineName != nullptr && stateMachineName[0] != '\0') - { - m_scene = m_artboard->stateMachineNamed(stateMachineName); - } - else - { - m_scene = m_artboard->defaultStateMachine(); - } - - if (m_scene == nullptr) - { - // This is a riv without any state machines. Just draw the artboard. - m_scene = std::make_unique<rive::StaticScene>(m_artboard.get()); - } - - if (m_scene != nullptr && m_viewModelInstance != nullptr) - { - m_scene->bindViewModelInstance(m_viewModelInstance); - } - } - - rive::Scene* stateMachine() const { return m_scene.get(); } - -private: - rive::rcp<rive::File> m_file; - std::unique_ptr<rive::ArtboardInstance> m_artboard; - std::unique_ptr<rive::Scene> m_scene; - rive::rcp<rive::ViewModelInstance> m_viewModelInstance; -}; - static bool process_single_golden_file(const std::string file, int cellSize) { std::ifstream stream(file, std::ios::binary); @@ -220,11 +232,12 @@ throw "Bad file"; } - RIVLoader riv( + return render_and_dump_png( + cellSize, + file.c_str(), std::vector<uint8_t>(std::istreambuf_iterator<char>(stream), {}), s_args.artboard().c_str(), s_args.stateMachine().c_str()); - return render_and_dump_png(cellSize, file.c_str(), riv.stateMachine()); } static bool is_riv_file(const std::filesystem::path& file) @@ -298,9 +311,6 @@ int cellSize = kWindowTargetSize / std::max(s_args.cols(), s_args.rows()); - int windowWidth = cellSize * s_args.cols(); - int windowHeight = cellSize * s_args.rows(); - TestingWindow::Get()->resize(windowWidth, windowHeight); // First check if the --src argument is a TCP server instead of a file. if (TestHarness::Instance().hasTCPConnection()) @@ -310,12 +320,11 @@ std::vector<uint8_t> rivBytes; while (TestHarness::Instance().fetchRivFile(rivName, rivBytes)) { - RIVLoader riv(rivBytes, - nullptr /*default artboard*/, - nullptr /*default state machine*/); if (!render_and_dump_png(cellSize, rivName.c_str(), - riv.stateMachine())) + rivBytes, + nullptr /*default artboard*/, + nullptr /*default state machine*/)) { return 0; }
diff --git a/tests/unit_tests/renderer/pls_render_context_test.cpp b/tests/unit_tests/renderer/pls_render_context_test.cpp index 46ea29f..401f287 100644 --- a/tests/unit_tests/renderer/pls_render_context_test.cpp +++ b/tests/unit_tests/renderer/pls_render_context_test.cpp
@@ -57,14 +57,14 @@ } MAKE_MAP_UNMAP(0, FlushUniformBuffer) - MAKE_MAP_UNMAP(1, ImageDrawUniformBuffer) - MAKE_MAP_UNMAP(2, PathBuffer) - MAKE_MAP_UNMAP(3, PaintBuffer) - MAKE_MAP_UNMAP(4, PaintAuxBuffer) - MAKE_MAP_UNMAP(5, ContourBuffer) - MAKE_MAP_UNMAP(6, GradSpanBuffer) - MAKE_MAP_UNMAP(7, TessVertexSpanBuffer) - MAKE_MAP_UNMAP(8, TriangleVertexBuffer) + MAKE_MAP_UNMAP(1, PathBuffer) + MAKE_MAP_UNMAP(2, PaintBuffer) + MAKE_MAP_UNMAP(3, PaintAuxBuffer) + MAKE_MAP_UNMAP(4, ContourBuffer) + MAKE_MAP_UNMAP(5, GradSpanBuffer) + MAKE_MAP_UNMAP(6, TessVertexSpanBuffer) + MAKE_MAP_UNMAP(7, TriangleVertexBuffer) + MAKE_MAP_UNMAP(8, ImageDrawInstanceBuffer) #undef MAKE_MAP_UNMAP @@ -121,7 +121,7 @@ allocs.gradSpanBufferCount = 4; allocs.tessSpanBufferCount = 5; allocs.triangleVertexBufferCount = 6; - allocs.imageDrawUniformBufferCount = 7; + allocs.imageDrawInstanceBufferCount = 7; allocs.gradTextureHeight = 8; allocs.tessTextureHeight = 9; @@ -131,7 +131,7 @@ CHECK(allocs.gradSpanBufferCount == 8); CHECK(allocs.tessSpanBufferCount == 10); CHECK(allocs.triangleVertexBufferCount == 12); - CHECK(allocs.imageDrawUniformBufferCount == 14); + CHECK(allocs.imageDrawInstanceBufferCount == 14); CHECK(allocs.gradTextureHeight == 16); CHECK(allocs.tessTextureHeight == 18); @@ -141,7 +141,7 @@ testAllocs.gradSpanBufferCount = 12; testAllocs.tessSpanBufferCount = 10; testAllocs.triangleVertexBufferCount = 8; - testAllocs.imageDrawUniformBufferCount = 6; + testAllocs.imageDrawInstanceBufferCount = 6; testAllocs.gradTextureHeight = 4; testAllocs.tessTextureHeight = 2; @@ -154,7 +154,7 @@ CHECK(allocs.gradSpanBufferCount == 12); CHECK(allocs.tessSpanBufferCount == 10); CHECK(allocs.triangleVertexBufferCount == 12 * 5); - CHECK(allocs.imageDrawUniformBufferCount == 14 * 5); + CHECK(allocs.imageDrawInstanceBufferCount == 14 * 5); CHECK(allocs.gradTextureHeight == 16 * 5); CHECK(allocs.tessTextureHeight == 18 * 5); @@ -167,7 +167,7 @@ CHECK(allocs.gradSpanBufferCount == 12); CHECK(allocs.tessSpanBufferCount == 10); CHECK(allocs.triangleVertexBufferCount == 6 * 5); - CHECK(allocs.imageDrawUniformBufferCount == 7 * 5); + CHECK(allocs.imageDrawInstanceBufferCount == 7 * 5); CHECK(allocs.gradTextureHeight == 8 * 5); CHECK(allocs.tessTextureHeight == 9 * 5); }