Support optional parameters in several GPURenderPassEncoder functions

https://bugs.webkit.org/show_bug.cgi?id=249374
<radar://61518858>

Reviewed by Dean Jackson.

As noted in https://bugs.webkit.org/show_bug.cgi?id=240219 it is currently
problematic to have an optional Size32 with a default value. Workaround
is to remove the default value and add the default value when calling
.value_or(default_value)

Pipe std::optional throughout the Web and GPU process member function
declarations and definitions as we do for other optional parameters.

* Source/WebCore/Modules/WebGPU/GPURenderBundleEncoder.cpp:
(WebCore::GPURenderBundleEncoder::setIndexBuffer):
(WebCore::GPURenderBundleEncoder::setVertexBuffer):
(WebCore::GPURenderBundleEncoder::draw):
(WebCore::GPURenderBundleEncoder::drawIndexed):
* Source/WebCore/Modules/WebGPU/GPURenderBundleEncoder.h:
* Source/WebCore/Modules/WebGPU/GPURenderEncoderBase.idl:
* Source/WebCore/Modules/WebGPU/GPURenderPassEncoder.cpp:
(WebCore::GPURenderPassEncoder::setIndexBuffer):
(WebCore::GPURenderPassEncoder::setVertexBuffer):
(WebCore::GPURenderPassEncoder::draw):
(WebCore::GPURenderPassEncoder::drawIndexed):
* Source/WebCore/Modules/WebGPU/GPURenderPassEncoder.h:
* Source/WebCore/PAL/pal/graphics/WebGPU/Impl/WebGPURenderBundleEncoderImpl.cpp:
(PAL::WebGPU::RenderBundleEncoderImpl::setIndexBuffer):
(PAL::WebGPU::RenderBundleEncoderImpl::setVertexBuffer):
(PAL::WebGPU::RenderBundleEncoderImpl::draw):
(PAL::WebGPU::RenderBundleEncoderImpl::drawIndexed):
* Source/WebCore/PAL/pal/graphics/WebGPU/Impl/WebGPURenderBundleEncoderImpl.h:
* Source/WebCore/PAL/pal/graphics/WebGPU/Impl/WebGPURenderPassEncoderImpl.cpp:
(PAL::WebGPU::RenderPassEncoderImpl::setIndexBuffer):
(PAL::WebGPU::RenderPassEncoderImpl::setVertexBuffer):
(PAL::WebGPU::RenderPassEncoderImpl::draw):
(PAL::WebGPU::RenderPassEncoderImpl::drawIndexed):
* Source/WebCore/PAL/pal/graphics/WebGPU/Impl/WebGPURenderPassEncoderImpl.h:
* Source/WebCore/PAL/pal/graphics/WebGPU/WebGPURenderBundleEncoder.h:
* Source/WebCore/PAL/pal/graphics/WebGPU/WebGPURenderPassEncoder.h:
* Source/WebKit/GPUProcess/graphics/WebGPU/RemoteRenderBundleEncoder.cpp:
(WebKit::RemoteRenderBundleEncoder::setIndexBuffer):
(WebKit::RemoteRenderBundleEncoder::setVertexBuffer):
(WebKit::RemoteRenderBundleEncoder::draw):
(WebKit::RemoteRenderBundleEncoder::drawIndexed):
* Source/WebKit/GPUProcess/graphics/WebGPU/RemoteRenderBundleEncoder.h:
* Source/WebKit/GPUProcess/graphics/WebGPU/RemoteRenderBundleEncoder.messages.in:
* Source/WebKit/GPUProcess/graphics/WebGPU/RemoteRenderPassEncoder.cpp:
(WebKit::RemoteRenderPassEncoder::setIndexBuffer):
(WebKit::RemoteRenderPassEncoder::setVertexBuffer):
(WebKit::RemoteRenderPassEncoder::draw):
(WebKit::RemoteRenderPassEncoder::drawIndexed):
* Source/WebKit/GPUProcess/graphics/WebGPU/RemoteRenderPassEncoder.h:
* Source/WebKit/GPUProcess/graphics/WebGPU/RemoteRenderPassEncoder.messages.in:
* Source/WebKit/WebProcess/GPU/graphics/WebGPU/RemoteRenderBundleEncoderProxy.cpp:
(WebKit::WebGPU::RemoteRenderBundleEncoderProxy::setIndexBuffer):
(WebKit::WebGPU::RemoteRenderBundleEncoderProxy::setVertexBuffer):
(WebKit::WebGPU::RemoteRenderBundleEncoderProxy::draw):
(WebKit::WebGPU::RemoteRenderBundleEncoderProxy::drawIndexed):
* Source/WebKit/WebProcess/GPU/graphics/WebGPU/RemoteRenderBundleEncoderProxy.h:
* Source/WebKit/WebProcess/GPU/graphics/WebGPU/RemoteRenderPassEncoderProxy.cpp:
(WebKit::WebGPU::RemoteRenderPassEncoderProxy::setIndexBuffer):
(WebKit::WebGPU::RemoteRenderPassEncoderProxy::setVertexBuffer):
(WebKit::WebGPU::RemoteRenderPassEncoderProxy::draw):
(WebKit::WebGPU::RemoteRenderPassEncoderProxy::drawIndexed):
* Source/WebKit/WebProcess/GPU/graphics/WebGPU/RemoteRenderPassEncoderProxy.h:
Pipe std::optional throughout the Web and GPU process member function
declarations and definitions as we do for other optional parameters.

* Websites/webkit.org/demos/webgpu/scripts/textured-cube.js:
(async helloCube.frameUpdate):
(async helloCube):
Update textured-cube to use the default values.

Canonical link: https://commits.webkit.org/258176@main

Source/WebCore/Modules/WebGPU/GPURenderBundleEncoder.cpp

@@ -48,26 +48,28 @@ void GPURenderBundleEncoder::setPipeline(const GPURenderPipeline& renderPipeline
     m_backing->setPipeline(renderPipeline.backing());
 }
 
-void GPURenderBundleEncoder::setIndexBuffer(const GPUBuffer& buffer, GPUIndexFormat indexFormat, GPUSize64 offset, std::optional<GPUSize64> size)
+void GPURenderBundleEncoder::setIndexBuffer(const GPUBuffer& buffer, GPUIndexFormat indexFormat, std::optional<GPUSize64> offset, std::optional<GPUSize64> size)
 {
     m_backing->setIndexBuffer(buffer.backing(), convertToBacking(indexFormat), offset, size);
 }
 
-void GPURenderBundleEncoder::setVertexBuffer(GPUIndex32 slot, const GPUBuffer& buffer, GPUSize64 offset, std::optional<GPUSize64> size)
+void GPURenderBundleEncoder::setVertexBuffer(GPUIndex32 slot, const GPUBuffer& buffer, std::optional<GPUSize64> offset, std::optional<GPUSize64> size)
 {
     m_backing->setVertexBuffer(slot, buffer.backing(), offset, size);
 }
 
-void GPURenderBundleEncoder::draw(GPUSize32 vertexCount, GPUSize32 instanceCount,
-    GPUSize32 firstVertex, GPUSize32 firstInstance)
+void GPURenderBundleEncoder::draw(GPUSize32 vertexCount,
+    std::optional<GPUSize32> instanceCount,
+    std::optional<GPUSize32> firstVertex, std::optional<GPUSize32> firstInstance)
 {
     m_backing->draw(vertexCount, instanceCount, firstVertex, firstInstance);
 }
 
-void GPURenderBundleEncoder::drawIndexed(GPUSize32 indexCount, GPUSize32 instanceCount,
-    GPUSize32 firstIndex,
-    GPUSignedOffset32 baseVertex,
-    GPUSize32 firstInstance)
+void GPURenderBundleEncoder::drawIndexed(GPUSize32 indexCount,
+    std::optional<GPUSize32> instanceCount,
+    std::optional<GPUSize32> firstIndex,
+    std::optional<GPUSignedOffset32> baseVertex,
+    std::optional<GPUSize32> firstInstance)
 {
     m_backing->drawIndexed(indexCount, instanceCount, firstIndex, baseVertex, firstInstance);
 }

Source/WebCore/Modules/WebGPU/GPURenderBundleEncoder.h

@@ -55,15 +55,15 @@ class GPURenderBundleEncoder : public RefCounted<GPURenderBundleEncoder> {
 
     void setPipeline(const GPURenderPipeline&);
 
-    void setIndexBuffer(const GPUBuffer&, GPUIndexFormat, GPUSize64 offset, std::optional<GPUSize64>);
-    void setVertexBuffer(GPUIndex32 slot, const GPUBuffer&, GPUSize64 offset, std::optional<GPUSize64>);
-
-    void draw(GPUSize32 vertexCount, GPUSize32 instanceCount,
-        GPUSize32 firstVertex, GPUSize32 firstInstance);
-    void drawIndexed(GPUSize32 indexCount, GPUSize32 instanceCount,
-        GPUSize32 firstIndex,
-        GPUSignedOffset32 baseVertex,
-        GPUSize32 firstInstance);
+    void setIndexBuffer(const GPUBuffer&, GPUIndexFormat, std::optional<GPUSize64> offset, std::optional<GPUSize64>);
+    void setVertexBuffer(GPUIndex32 slot, const GPUBuffer&, std::optional<GPUSize64> offset, std::optional<GPUSize64>);
+
+    void draw(GPUSize32 vertexCount, std::optional<GPUSize32> instanceCount,
+        std::optional<GPUSize32> firstVertex, std::optional<GPUSize32> firstInstance);
+    void drawIndexed(GPUSize32 indexCount, std::optional<GPUSize32> instanceCount,
+        std::optional<GPUSize32> firstIndex,
+        std::optional<GPUSignedOffset32> baseVertex,
+        std::optional<GPUSize32> firstInstance);
 
     void drawIndirect(const GPUBuffer& indirectBuffer, GPUSize64 indirectOffset);
     void drawIndexedIndirect(const GPUBuffer& indirectBuffer, GPUSize64 indirectOffset);

Source/WebCore/Modules/WebGPU/GPURenderEncoderBase.idl

@@ -35,15 +35,19 @@ typedef [EnforceRange] long GPUSignedOffset32;
 interface mixin GPURenderEncoderBase {
     undefined setPipeline(GPURenderPipeline pipeline);
 
-    undefined setIndexBuffer(GPUBuffer buffer, GPUIndexFormat indexFormat, optional GPUSize64 offset = 0, optional GPUSize64 size);
-    undefined setVertexBuffer(GPUIndex32 slot, GPUBuffer buffer, optional GPUSize64 offset = 0, optional GPUSize64 size);
+    // FIXME: https://bugs.webkit.org/show_bug.cgi?id=240219, last two parameters should have default value of 0
+    undefined setIndexBuffer(GPUBuffer buffer, GPUIndexFormat indexFormat, optional GPUSize64 offset, optional GPUSize64 size);
+    // FIXME: https://bugs.webkit.org/show_bug.cgi?id=240219, last two parameters should have default value of 0
+    undefined setVertexBuffer(GPUIndex32 slot, GPUBuffer buffer, optional GPUSize64 offset, optional GPUSize64 size);
 
-    undefined draw(GPUSize32 vertexCount, optional GPUSize32 instanceCount = 1,
-        optional GPUSize32 firstVertex = 0, optional GPUSize32 firstInstance = 0);
-    undefined drawIndexed(GPUSize32 indexCount, optional GPUSize32 instanceCount = 1,
-        optional GPUSize32 firstIndex = 0,
-        optional GPUSignedOffset32 baseVertex = 0,
-        optional GPUSize32 firstInstance = 0);
+    // FIXME: https://bugs.webkit.org/show_bug.cgi?id=240219, last two parameters should have default value of 0, first 1
+    undefined draw(GPUSize32 vertexCount, optional GPUSize32 instanceCount,
+        optional GPUSize32 firstVertex, optional GPUSize32 firstInstance);
+    // FIXME: https://bugs.webkit.org/show_bug.cgi?id=240219, last three parameters should have default value of 0, first 1
+    undefined drawIndexed(GPUSize32 indexCount, optional GPUSize32 instanceCount,
+        optional GPUSize32 firstIndex,
+        optional GPUSignedOffset32 baseVertex,
+        optional GPUSize32 firstInstance);
 
     undefined drawIndirect(GPUBuffer indirectBuffer, GPUSize64 indirectOffset);
     undefined drawIndexedIndirect(GPUBuffer indirectBuffer, GPUSize64 indirectOffset);

Source/WebCore/Modules/WebGPU/GPURenderPassEncoder.cpp

@@ -49,26 +49,26 @@ void GPURenderPassEncoder::setPipeline(const GPURenderPipeline& renderPipeline)
     m_backing->setPipeline(renderPipeline.backing());
 }
 
-void GPURenderPassEncoder::setIndexBuffer(const GPUBuffer& buffer, GPUIndexFormat indexFormat, GPUSize64 offset, std::optional<GPUSize64> size)
+void GPURenderPassEncoder::setIndexBuffer(const GPUBuffer& buffer, GPUIndexFormat indexFormat, std::optional<GPUSize64> offset, std::optional<GPUSize64> size)
 {
     m_backing->setIndexBuffer(buffer.backing(), convertToBacking(indexFormat), offset, size);
 }
 
-void GPURenderPassEncoder::setVertexBuffer(GPUIndex32 slot, const GPUBuffer& buffer, GPUSize64 offset, std::optional<GPUSize64> size)
+void GPURenderPassEncoder::setVertexBuffer(GPUIndex32 slot, const GPUBuffer& buffer, std::optional<GPUSize64> offset, std::optional<GPUSize64> size)
 {
     m_backing->setVertexBuffer(slot, buffer.backing(), offset, size);
 }
 
-void GPURenderPassEncoder::draw(GPUSize32 vertexCount, GPUSize32 instanceCount,
-    GPUSize32 firstVertex, GPUSize32 firstInstance)
+void GPURenderPassEncoder::draw(GPUSize32 vertexCount, std::optional<GPUSize32> instanceCount,
+    std::optional<GPUSize32> firstVertex, std::optional<GPUSize32> firstInstance)
 {
     m_backing->draw(vertexCount, instanceCount, firstVertex, firstInstance);
 }
 
-void GPURenderPassEncoder::drawIndexed(GPUSize32 indexCount, GPUSize32 instanceCount,
-    GPUSize32 firstIndex,
-    GPUSignedOffset32 baseVertex,
-    GPUSize32 firstInstance)
+void GPURenderPassEncoder::drawIndexed(GPUSize32 indexCount, std::optional<GPUSize32> instanceCount,
+    std::optional<GPUSize32> firstIndex,
+    std::optional<GPUSignedOffset32> baseVertex,
+    std::optional<GPUSize32> firstInstance)
 {
     m_backing->drawIndexed(indexCount, instanceCount, firstIndex, baseVertex, firstInstance);
 }

Source/WebCore/Modules/WebGPU/GPURenderPassEncoder.h

@@ -57,15 +57,15 @@ class GPURenderPassEncoder : public RefCounted<GPURenderPassEncoder> {
 
     void setPipeline(const GPURenderPipeline&);
 
-    void setIndexBuffer(const GPUBuffer&, GPUIndexFormat, GPUSize64 offset, std::optional<GPUSize64>);
-    void setVertexBuffer(GPUIndex32 slot, const GPUBuffer&, GPUSize64 offset, std::optional<GPUSize64>);
-
-    void draw(GPUSize32 vertexCount, GPUSize32 instanceCount,
-        GPUSize32 firstVertex, GPUSize32 firstInstance);
-    void drawIndexed(GPUSize32 indexCount, GPUSize32 instanceCount,
-        GPUSize32 firstIndex,
-        GPUSignedOffset32 baseVertex,
-        GPUSize32 firstInstance);
+    void setIndexBuffer(const GPUBuffer&, GPUIndexFormat, std::optional<GPUSize64> offset, std::optional<GPUSize64>);
+    void setVertexBuffer(GPUIndex32 slot, const GPUBuffer&, std::optional<GPUSize64> offset, std::optional<GPUSize64>);
+
+    void draw(GPUSize32 vertexCount, std::optional<GPUSize32> instanceCount,
+        std::optional<GPUSize32> firstVertex, std::optional<GPUSize32> firstInstance);
+    void drawIndexed(GPUSize32 indexCount, std::optional<GPUSize32> instanceCount,
+        std::optional<GPUSize32> firstIndex,
+        std::optional<GPUSignedOffset32> baseVertex,
+        std::optional<GPUSize32> firstInstance);
 
     void drawIndirect(const GPUBuffer& indirectBuffer, GPUSize64 indirectOffset);
     void drawIndexedIndirect(const GPUBuffer& indirectBuffer, GPUSize64 indirectOffset);

Source/WebCore/PAL/pal/graphics/WebGPU/Impl/WebGPURenderBundleEncoderImpl.cpp

@@ -53,28 +53,28 @@ void RenderBundleEncoderImpl::setPipeline(const RenderPipeline& renderPipeline)
     wgpuRenderBundleEncoderSetPipeline(m_backing, m_convertToBackingContext->convertToBacking(renderPipeline));
 }
 
-void RenderBundleEncoderImpl::setIndexBuffer(const Buffer& buffer, IndexFormat indexFormat, Size64 offset, std::optional<Size64> size)
+void RenderBundleEncoderImpl::setIndexBuffer(const Buffer& buffer, IndexFormat indexFormat, std::optional<Size64> offset, std::optional<Size64> size)
 {
-    wgpuRenderBundleEncoderSetIndexBuffer(m_backing, m_convertToBackingContext->convertToBacking(buffer), m_convertToBackingContext->convertToBacking(indexFormat), offset, size.value_or(WGPU_WHOLE_SIZE));
+    wgpuRenderBundleEncoderSetIndexBuffer(m_backing, m_convertToBackingContext->convertToBacking(buffer), m_convertToBackingContext->convertToBacking(indexFormat), offset.value_or(0), size.value_or(WGPU_WHOLE_SIZE));
 }
 
-void RenderBundleEncoderImpl::setVertexBuffer(Index32 slot, const Buffer& buffer, Size64 offset, std::optional<Size64> size)
+void RenderBundleEncoderImpl::setVertexBuffer(Index32 slot, const Buffer& buffer, std::optional<Size64> offset, std::optional<Size64> size)
 {
-    wgpuRenderBundleEncoderSetVertexBuffer(m_backing, slot, m_convertToBackingContext->convertToBacking(buffer), offset, size.value_or(WGPU_WHOLE_SIZE));
+    wgpuRenderBundleEncoderSetVertexBuffer(m_backing, slot, m_convertToBackingContext->convertToBacking(buffer), offset.value_or(0), size.value_or(WGPU_WHOLE_SIZE));
 }
 
-void RenderBundleEncoderImpl::draw(Size32 vertexCount, Size32 instanceCount,
-    Size32 firstVertex, Size32 firstInstance)
+void RenderBundleEncoderImpl::draw(Size32 vertexCount, std::optional<Size32> instanceCount,
+    std::optional<Size32> firstVertex, std::optional<Size32> firstInstance)
 {
-    wgpuRenderBundleEncoderDraw(m_backing, vertexCount, instanceCount, firstVertex, firstInstance);
+    wgpuRenderBundleEncoderDraw(m_backing, vertexCount, instanceCount.value_or(1), firstVertex.value_or(0), firstInstance.value_or(0));
 }
 
-void RenderBundleEncoderImpl::drawIndexed(Size32 indexCount, Size32 instanceCount,
-    Size32 firstIndex,
-    SignedOffset32 baseVertex,
-    Size32 firstInstance)
+void RenderBundleEncoderImpl::drawIndexed(Size32 indexCount, std::optional<Size32> instanceCount,
+    std::optional<Size32> firstIndex,
+    std::optional<SignedOffset32> baseVertex,
+    std::optional<Size32> firstInstance)
 {
-    wgpuRenderBundleEncoderDrawIndexed(m_backing, indexCount, instanceCount, firstIndex, baseVertex, firstInstance);
+    wgpuRenderBundleEncoderDrawIndexed(m_backing, indexCount, instanceCount.value_or(1), firstIndex.value_or(0), baseVertex.value_or(0), firstInstance.value_or(0));
 }
 
 void RenderBundleEncoderImpl::drawIndirect(const Buffer& indirectBuffer, Size64 indirectOffset)

Source/WebCore/PAL/pal/graphics/WebGPU/Impl/WebGPURenderBundleEncoderImpl.h

@@ -58,15 +58,15 @@ class RenderBundleEncoderImpl final : public RenderBundleEncoder {
 
     void setPipeline(const RenderPipeline&) final;
 
-    void setIndexBuffer(const Buffer&, IndexFormat, Size64 offset, std::optional<Size64>) final;
-    void setVertexBuffer(Index32 slot, const Buffer&, Size64 offset, std::optional<Size64>) final;
-
-    void draw(Size32 vertexCount, Size32 instanceCount,
-        Size32 firstVertex, Size32 firstInstance) final;
-    void drawIndexed(Size32 indexCount, Size32 instanceCount,
-        Size32 firstIndex,
-        SignedOffset32 baseVertex,
-        Size32 firstInstance) final;
+    void setIndexBuffer(const Buffer&, IndexFormat, std::optional<Size64> offset, std::optional<Size64>) final;
+    void setVertexBuffer(Index32 slot, const Buffer&, std::optional<Size64> offset, std::optional<Size64>) final;
+
+    void draw(Size32 vertexCount, std::optional<Size32> instanceCount,
+        std::optional<Size32> firstVertex, std::optional<Size32> firstInstance) final;
+    void drawIndexed(Size32 indexCount, std::optional<Size32> instanceCount,
+        std::optional<Size32> firstIndex,
+        std::optional<SignedOffset32> baseVertex,
+        std::optional<Size32> firstInstance) final;
 
     void drawIndirect(const Buffer& indirectBuffer, Size64 indirectOffset) final;
     void drawIndexedIndirect(const Buffer& indirectBuffer, Size64 indirectOffset) final;

Source/WebCore/PAL/pal/graphics/WebGPU/Impl/WebGPURenderPassEncoderImpl.cpp

@@ -54,28 +54,28 @@ void RenderPassEncoderImpl::setPipeline(const RenderPipeline& renderPipeline)
     wgpuRenderPassEncoderSetPipeline(m_backing, m_convertToBackingContext->convertToBacking(renderPipeline));
 }
 
-void RenderPassEncoderImpl::setIndexBuffer(const Buffer& buffer, IndexFormat indexFormat, Size64 offset, std::optional<Size64> size)
+void RenderPassEncoderImpl::setIndexBuffer(const Buffer& buffer, IndexFormat indexFormat, std::optional<Size64> offset, std::optional<Size64> size)
 {
-    wgpuRenderPassEncoderSetIndexBuffer(m_backing, m_convertToBackingContext->convertToBacking(buffer), m_convertToBackingContext->convertToBacking(indexFormat), offset, size.value_or(WGPU_WHOLE_SIZE));
+    wgpuRenderPassEncoderSetIndexBuffer(m_backing, m_convertToBackingContext->convertToBacking(buffer), m_convertToBackingContext->convertToBacking(indexFormat), offset.value_or(0), size.value_or(WGPU_WHOLE_SIZE));
 }
 
-void RenderPassEncoderImpl::setVertexBuffer(Index32 slot, const Buffer& buffer, Size64 offset, std::optional<Size64> size)
+void RenderPassEncoderImpl::setVertexBuffer(Index32 slot, const Buffer& buffer, std::optional<Size64> offset, std::optional<Size64> size)
 {
-    wgpuRenderPassEncoderSetVertexBuffer(m_backing, slot, m_convertToBackingContext->convertToBacking(buffer), offset, size.value_or(WGPU_WHOLE_SIZE));
+    wgpuRenderPassEncoderSetVertexBuffer(m_backing, slot, m_convertToBackingContext->convertToBacking(buffer), offset.value_or(0), size.value_or(WGPU_WHOLE_SIZE));
 }
 
-void RenderPassEncoderImpl::draw(Size32 vertexCount, Size32 instanceCount,
-    Size32 firstVertex, Size32 firstInstance)
+void RenderPassEncoderImpl::draw(Size32 vertexCount, std::optional<Size32> instanceCount,
+    std::optional<Size32> firstVertex, std::optional<Size32> firstInstance)
 {
-    wgpuRenderPassEncoderDraw(m_backing, vertexCount, instanceCount, firstVertex, firstInstance);
+    wgpuRenderPassEncoderDraw(m_backing, vertexCount, instanceCount.value_or(1), firstVertex.value_or(0), firstInstance.value_or(0));
 }
 
-void RenderPassEncoderImpl::drawIndexed(Size32 indexCount, Size32 instanceCount,
-    Size32 firstIndex,
-    SignedOffset32 baseVertex,
-    Size32 firstInstance)
+void RenderPassEncoderImpl::drawIndexed(Size32 indexCount, std::optional<Size32> instanceCount,
+    std::optional<Size32> firstIndex,
+    std::optional<SignedOffset32> baseVertex,
+    std::optional<Size32> firstInstance)
 {
-    wgpuRenderPassEncoderDrawIndexed(m_backing, indexCount, instanceCount, firstIndex, baseVertex, firstInstance);
+    wgpuRenderPassEncoderDrawIndexed(m_backing, indexCount, instanceCount.value_or(1), firstIndex.value_or(0), baseVertex.value_or(0), firstInstance.value_or(0));
 }
 
 void RenderPassEncoderImpl::drawIndirect(const Buffer& indirectBuffer, Size64 indirectOffset)

Source/WebCore/PAL/pal/graphics/WebGPU/Impl/WebGPURenderPassEncoderImpl.h

@@ -58,15 +58,15 @@ class RenderPassEncoderImpl final : public RenderPassEncoder {
 
     void setPipeline(const RenderPipeline&) final;
 
-    void setIndexBuffer(const Buffer&, IndexFormat, Size64 offset, std::optional<Size64>) final;
-    void setVertexBuffer(Index32 slot, const Buffer&, Size64 offset, std::optional<Size64>) final;
-
-    void draw(Size32 vertexCount, Size32 instanceCount,
-        Size32 firstVertex, Size32 firstInstance) final;
-    void drawIndexed(Size32 indexCount, Size32 instanceCount,
-        Size32 firstIndex,
-        SignedOffset32 baseVertex,
-        Size32 firstInstance) final;
+    void setIndexBuffer(const Buffer&, IndexFormat, std::optional<Size64> offset, std::optional<Size64>) final;
+    void setVertexBuffer(Index32 slot, const Buffer&, std::optional<Size64> offset, std::optional<Size64>) final;
+
+    void draw(Size32 vertexCount, std::optional<Size32> instanceCount,
+        std::optional<Size32> firstVertex, std::optional<Size32> firstInstance) final;
+    void drawIndexed(Size32 indexCount, std::optional<Size32> instanceCount,
+        std::optional<Size32> firstIndex,
+        std::optional<SignedOffset32> baseVertex,
+        std::optional<Size32> firstInstance) final;
 
     void drawIndirect(const Buffer& indirectBuffer, Size64 indirectOffset) final;
     void drawIndexedIndirect(const Buffer& indirectBuffer, Size64 indirectOffset) final;

Source/WebCore/PAL/pal/graphics/WebGPU/WebGPURenderBundleEncoder.h

@@ -56,15 +56,15 @@ class RenderBundleEncoder : public RefCounted<RenderBundleEncoder> {
 
     virtual void setPipeline(const RenderPipeline&) = 0;
 
-    virtual void setIndexBuffer(const Buffer&, IndexFormat, Size64 offset, std::optional<Size64>) = 0;
-    virtual void setVertexBuffer(Index32 slot, const Buffer&, Size64 offset, std::optional<Size64>) = 0;
-
-    virtual void draw(Size32 vertexCount, Size32 instanceCount,
-        Size32 firstVertex, Size32 firstInstance) = 0;
-    virtual void drawIndexed(Size32 indexCount, Size32 instanceCount,
-        Size32 firstIndex,
-        SignedOffset32 baseVertex,
-        Size32 firstInstance) = 0;
+    virtual void setIndexBuffer(const Buffer&, IndexFormat, std::optional<Size64> offset, std::optional<Size64>) = 0;
+    virtual void setVertexBuffer(Index32 slot, const Buffer&, std::optional<Size64> offset, std::optional<Size64>) = 0;
+
+    virtual void draw(Size32 vertexCount, std::optional<Size32> instanceCount,
+        std::optional<Size32> firstVertex, std::optional<Size32> firstInstance) = 0;
+    virtual void drawIndexed(Size32 indexCount, std::optional<Size32> instanceCount,
+        std::optional<Size32> firstIndex,
+        std::optional<SignedOffset32> baseVertex,
+        std::optional<Size32> firstInstance) = 0;
 
     virtual void drawIndirect(const Buffer& indirectBuffer, Size64 indirectOffset) = 0;
     virtual void drawIndexedIndirect(const Buffer& indirectBuffer, Size64 indirectOffset) = 0;

Source/WebCore/PAL/pal/graphics/WebGPU/WebGPURenderPassEncoder.h

@@ -58,15 +58,15 @@ class RenderPassEncoder : public RefCounted<RenderPassEncoder> {
 
     virtual void setPipeline(const RenderPipeline&) = 0;
 
-    virtual void setIndexBuffer(const Buffer&, IndexFormat, Size64 offset, std::optional<Size64>) = 0;
-    virtual void setVertexBuffer(Index32 slot, const Buffer&, Size64 offset, std::optional<Size64>) = 0;
-
-    virtual void draw(Size32 vertexCount, Size32 instanceCount,
-        Size32 firstVertex, Size32 firstInstance) = 0;
-    virtual void drawIndexed(Size32 indexCount, Size32 instanceCount,
-        Size32 firstIndex,
-        SignedOffset32 baseVertex,
-        Size32 firstInstance) = 0;
+    virtual void setIndexBuffer(const Buffer&, IndexFormat, std::optional<Size64> offset, std::optional<Size64>) = 0;
+    virtual void setVertexBuffer(Index32 slot, const Buffer&, std::optional<Size64> offset, std::optional<Size64>) = 0;
+
+    virtual void draw(Size32 vertexCount, std::optional<Size32> instanceCount,
+        std::optional<Size32> firstVertex, std::optional<Size32> firstInstance) = 0;
+    virtual void drawIndexed(Size32 indexCount, std::optional<Size32> instanceCount,
+        std::optional<Size32> firstIndex,
+        std::optional<SignedOffset32> baseVertex,
+        std::optional<Size32> firstInstance) = 0;
 
     virtual void drawIndirect(const Buffer& indirectBuffer, Size64 indirectOffset) = 0;
     virtual void drawIndexedIndirect(const Buffer& indirectBuffer, Size64 indirectOffset) = 0;