Diff
Modified: trunk/LayoutTests/ChangeLog (238686 => 238687)
--- trunk/LayoutTests/ChangeLog 2018-11-29 21:01:15 UTC (rev 238686)
+++ trunk/LayoutTests/ChangeLog 2018-11-29 21:09:08 UTC (rev 238687)
@@ -1,3 +1,19 @@
+2018-11-29 Justin Fan <justin_...@apple.com>
+
+ [WebGPU] WebGPURenderPassEncoder::setPipeline, draw, and endPass prototypes
+ https://bugs.webkit.org/show_bug.cgi?id=192134
+
+ Reviewed by Dean Jackson.
+
+ Updating the basic rendering test with more commands, and a prototype WPT-based test for WebGPURenderCommandEncoder's
+ new functionality.
+
+ * webgpu/js/basic-webgpu-functions.js:
+ (render):
+ * webgpu/render-command-encoding-expected.txt: Added.
+ * webgpu/render-command-encoding.html: Added.
+ * webgpu/render-passes.html:
+
2018-11-29 Justin Michaud <justin_mich...@apple.com>
CSS Painting API should pass 'this' correctly to paint callback, and repaint when properties change.
Modified: trunk/LayoutTests/webgpu/js/basic-webgpu-functions.js (238686 => 238687)
--- trunk/LayoutTests/webgpu/js/basic-webgpu-functions.js 2018-11-29 21:01:15 UTC (rev 238686)
+++ trunk/LayoutTests/webgpu/js/basic-webgpu-functions.js 2018-11-29 21:09:08 UTC (rev 238687)
@@ -149,5 +149,15 @@
return;
}
+ renderPassEncoder.setPipeline(renderPipeline);
+
+ // Note that we didn't attach any buffers - the shader is generating the vertices for us.
+ renderPassEncoder.draw(3, 1, 0, 0);
+ let commandBufferEnd = renderPassEncoder.endPass();
+ if (!commandBufferEnd) {
+ testFailed("Unable to create WebGPUCommandBuffer from WeGPURenderPassEncoder::endPass!");
+ return;
+ }
+
// FIXME: Rest of rendering commands to follow.
}
\ No newline at end of file
Added: trunk/LayoutTests/webgpu/render-command-encoding-expected.txt (0 => 238687)
--- trunk/LayoutTests/webgpu/render-command-encoding-expected.txt (rev 0)
+++ trunk/LayoutTests/webgpu/render-command-encoding-expected.txt 2018-11-29 21:09:08 UTC (rev 238687)
@@ -0,0 +1,4 @@
+PASS [object WebGPU] is defined.
+
+PASS WebGPURenderPassEncoder created and successfully ended
+
Added: trunk/LayoutTests/webgpu/render-command-encoding.html (0 => 238687)
--- trunk/LayoutTests/webgpu/render-command-encoding.html (rev 0)
+++ trunk/LayoutTests/webgpu/render-command-encoding.html 2018-11-29 21:09:08 UTC (rev 238687)
@@ -0,0 +1,49 @@
+<!DOCTYPE html><!-- webkit-test-runner [ experimental:WebGPUEnabled=true ] -->
+<meta charset=utf-8>
+<title>Get the WebGPUDevice and ask for the WebGPUQueue</title>
+<body>
+<script src=""
+<script src=""
+<script src=""
+<script src=""
+<script>
+'use strict';
+
+let commandBuffer, renderPassEncoder;
+
+function beginPass() {
+ // FIXME: Flesh out the rest of WebGPURenderPassDescriptor.
+ // Default a loadOp, storeOp, and clearColor in the implementation for now.
+ const renderPassDescriptor = {
+ attachment : context.getNextTexture().createDefaultTextureView()
+ }
+
+ renderPassEncoder = commandBuffer.beginRenderPass(renderPassDescriptor);
+ assert_true(renderPassEncoder instanceof WebGPURenderPassEncoder, "beginRenderPass returned a WebGPURenderPassEncoder");
+}
+
+function setUpCommandBuffer() {
+ commandBuffer = defaultDevice.createCommandBuffer();
+ assert_true(commandBuffer instanceof WebGPUCommandBuffer, "createCommandBuffer returned a WebGPUCommandBuffer");
+}
+
+function endRenderPass() {
+ renderPassEncoder.setPipeline(renderPipeline);
+
+ const commandBufferEnd = renderPassEncoder.endPass();
+ assert_true(commandBufferEnd instanceof WebGPUCommandBuffer, "endPass() returned a WebGPUCommandBuffer");
+
+ // FIXME: Should commandBufferEnd === commandBuffer?
+}
+
+promise_test(async () => {
+ const canvas = document.createElement("canvas");
+ await setUpContexts(canvas);
+ setUpPipeline();
+ setUpCommandBuffer();
+ beginPass();
+ endRenderPass();
+}, "WebGPURenderPassEncoder created and successfully ended");
+
+</script>
+</body>
Modified: trunk/LayoutTests/webgpu/render-passes.html (238686 => 238687)
--- trunk/LayoutTests/webgpu/render-passes.html 2018-11-29 21:01:15 UTC (rev 238686)
+++ trunk/LayoutTests/webgpu/render-passes.html 2018-11-29 21:09:08 UTC (rev 238687)
@@ -6,16 +6,16 @@
if (window.testRunner)
window.testRunner.dumpAsText();
-let commandBuffer, texture, textureView, renderPassDescriptor, renderPassEncoder;
+let commandBuffer, renderPassEncoder;
function setUpBasicRenderPassEncoder() {
commandBuffer = defaultDevice.createCommandBuffer();
- texture = context.getNextTexture();
- textureView = texture.createDefaultTextureView();
+ const texture = context.getNextTexture();
+ const textureView = texture.createDefaultTextureView();
// FIXME: Flesh out the rest of WebGPURenderPassDescriptor.
// Default a loadOp, storeOp, and clearColor in the implementation for now.
- renderPassDescriptor = {
+ const renderPassDescriptor = {
attachment : textureView
}
Modified: trunk/Source/WebCore/ChangeLog (238686 => 238687)
--- trunk/Source/WebCore/ChangeLog 2018-11-29 21:01:15 UTC (rev 238686)
+++ trunk/Source/WebCore/ChangeLog 2018-11-29 21:09:08 UTC (rev 238687)
@@ -1,3 +1,54 @@
+2018-11-29 Justin Fan <justin_...@apple.com>
+
+ [WebGPU] WebGPURenderPassEncoder::setPipeline, draw, and endPass prototypes
+ https://bugs.webkit.org/show_bug.cgi?id=192134
+
+ Reviewed by Dean Jackson.
+
+ Wrap up prototype features for WebGPURenderPassEncoder.
+
+ Test: webgpu/render-command-encoding.html
+
+ * Modules/webgpu/WebGPUCommandBuffer.cpp:
+ (WebCore::WebGPUCommandBuffer::beginRenderPass):
+ * Modules/webgpu/WebGPUDevice.cpp:
+ (WebCore::WebGPUDevice::createRenderPipeline const):
+ * Modules/webgpu/WebGPUProgrammablePassEncoder.cpp:
+ (WebCore::WebGPUProgrammablePassEncoder::WebGPUProgrammablePassEncoder):
+ (WebCore::WebGPUProgrammablePassEncoder::endPass): Returns a reference to the WebGPUCommandBuffer that created this encoder.
+ (WebCore::WebGPUProgrammablePassEncoder::setPipeline):
+ * Modules/webgpu/WebGPUProgrammablePassEncoder.h: Updated to support endPass and setPipeline.
+ * Modules/webgpu/WebGPUProgrammablePassEncoder.idl:
+ * Modules/webgpu/WebGPURenderPassEncoder.cpp:
+ (WebCore::WebGPURenderPassEncoder::create): Must be provided with the WebGPUCommandBuffer.
+ (WebCore::WebGPURenderPassEncoder::WebGPURenderPassEncoder):
+ (WebCore::WebGPURenderPassEncoder::draw):
+ * Modules/webgpu/WebGPURenderPassEncoder.h: Updated to cache a reference to the WebGPUCommandBuffer, and for draw.
+ * Modules/webgpu/WebGPURenderPassEncoder.idl:
+ * Modules/webgpu/WebGPURenderPipeline.cpp:
+ (WebCore::WebGPURenderPipeline::create):
+ (WebCore::WebGPURenderPipeline::WebGPURenderPipeline):
+ * Modules/webgpu/WebGPURenderPipeline.h:
+ (WebCore::WebGPURenderPipeline::renderPipeline):
+ * Modules/webgpu/WebGPUTexture.cpp:
+ * Modules/webgpu/WebGPUTexture.h: Replaced include with forward declaration.
+ * platform/graphics/gpu/GPUProgrammablePassEncoder.h: Updated to support new WebGPU_PassEncoder functionality.
+ * platform/graphics/gpu/GPURenderPassEncoder.h:
+ (WebCore::GPURenderPassEncoder::~GPURenderPassEncoder): Now ends encoding on the MTLCommandEncoder, if not already ended, before freeing it.
+ * platform/graphics/gpu/GPURenderPipeline.h: Now remembers the GPUPrimitiveTopology that it was created with.
+ (WebCore::GPURenderPipeline::primitiveTopology const):
+ * platform/graphics/gpu/cocoa/GPUProgrammablePassEncoderMetal.mm:
+ (WebCore::GPUProgrammablePassEncoder::endPass): Calls endEncoding on the backing MTLCommandEncoder, if not already ended.
+ * platform/graphics/gpu/cocoa/GPURenderPassEncoderMetal.mm:
+ (WebCore::GPURenderPassEncoder::platformPassEncoder const):
+ (WebCore::GPURenderPassEncoder::setPipeline): Added.
+ (WebCore::primitiveTypeForGPUPrimitiveTopology): Added. Helper function to convert GPUPrimitiveTopology to MTLPrimitiveType.
+ (WebCore::GPURenderPassEncoder::draw): Added. Draws using primitive topology specified during pipeline creation.
+ * platform/graphics/gpu/cocoa/GPURenderPipelineMetal.mm:
+ (WebCore::setFunctionsForPipelineDescriptor):
+ (WebCore::GPURenderPipeline::create):
+ (WebCore::GPURenderPipeline::GPURenderPipeline): Now must store the GPURenderPipelineDescriptor for later reference.
+
2018-11-29 Justin Michaud <justin_mich...@apple.com>
CSS Painting API should pass 'this' correctly to paint callback, and repaint when properties change.
Modified: trunk/Source/WebCore/Modules/webgpu/WebGPUCommandBuffer.cpp (238686 => 238687)
--- trunk/Source/WebCore/Modules/webgpu/WebGPUCommandBuffer.cpp 2018-11-29 21:01:15 UTC (rev 238686)
+++ trunk/Source/WebCore/Modules/webgpu/WebGPUCommandBuffer.cpp 2018-11-29 21:09:08 UTC (rev 238687)
@@ -63,7 +63,7 @@
if (!encoder)
return nullptr;
- return WebGPURenderPassEncoder::create(encoder.releaseNonNull());
+ return WebGPURenderPassEncoder::create(*this, encoder.releaseNonNull());
}
} // namespace WebCore
Modified: trunk/Source/WebCore/Modules/webgpu/WebGPUDevice.cpp (238686 => 238687)
--- trunk/Source/WebCore/Modules/webgpu/WebGPUDevice.cpp 2018-11-29 21:01:15 UTC (rev 238686)
+++ trunk/Source/WebCore/Modules/webgpu/WebGPUDevice.cpp 2018-11-29 21:09:08 UTC (rev 238687)
@@ -117,7 +117,12 @@
return nullptr;
}
- return WebGPURenderPipeline::create(m_device->createRenderPipeline(GPURenderPipelineDescriptor { WTFMove(vertexStage), WTFMove(fragmentStage), descriptor.primitiveTopology }));
+ auto pipeline = m_device->createRenderPipeline(GPURenderPipelineDescriptor { WTFMove(vertexStage), WTFMove(fragmentStage), descriptor.primitiveTopology });
+
+ if (!pipeline)
+ return nullptr;
+
+ return WebGPURenderPipeline::create(pipeline.releaseNonNull());
}
RefPtr<WebGPUCommandBuffer> WebGPUDevice::createCommandBuffer() const
Modified: trunk/Source/WebCore/Modules/webgpu/WebGPUProgrammablePassEncoder.cpp (238686 => 238687)
--- trunk/Source/WebCore/Modules/webgpu/WebGPUProgrammablePassEncoder.cpp 2018-11-29 21:01:15 UTC (rev 238686)
+++ trunk/Source/WebCore/Modules/webgpu/WebGPUProgrammablePassEncoder.cpp 2018-11-29 21:09:08 UTC (rev 238687)
@@ -28,8 +28,28 @@
#if ENABLE(WEBGPU)
+#include "GPUProgrammablePassEncoder.h"
+#include "WebGPUCommandBuffer.h"
+#include "WebGPURenderPipeline.h"
+
namespace WebCore {
+WebGPUProgrammablePassEncoder::WebGPUProgrammablePassEncoder(Ref<WebGPUCommandBuffer>&& creator)
+ : m_commandBuffer(WTFMove(creator))
+{
+}
+
+Ref<WebGPUCommandBuffer> WebGPUProgrammablePassEncoder::endPass()
+{
+ passEncoder().endPass();
+ return m_commandBuffer.copyRef();
+}
+
+void WebGPUProgrammablePassEncoder::setPipeline(Ref<WebGPURenderPipeline>&& pipeline)
+{
+ passEncoder().setPipeline(pipeline->renderPipeline());
+}
+
} // namespace WebCore
#endif // ENABLE(WEBGPU)
Modified: trunk/Source/WebCore/Modules/webgpu/WebGPUProgrammablePassEncoder.h (238686 => 238687)
--- trunk/Source/WebCore/Modules/webgpu/WebGPUProgrammablePassEncoder.h 2018-11-29 21:01:15 UTC (rev 238686)
+++ trunk/Source/WebCore/Modules/webgpu/WebGPUProgrammablePassEncoder.h 2018-11-29 21:09:08 UTC (rev 238687)
@@ -32,13 +32,23 @@
namespace WebCore {
class GPUProgrammablePassEncoder;
+class WebGPUCommandBuffer;
+class WebGPURenderPipeline;
class WebGPUProgrammablePassEncoder : public RefCounted<WebGPUProgrammablePassEncoder> {
public:
virtual ~WebGPUProgrammablePassEncoder() = default;
+ Ref<WebGPUCommandBuffer> endPass();
+ void setPipeline(Ref<WebGPURenderPipeline>&&);
+
protected:
+ WebGPUProgrammablePassEncoder(Ref<WebGPUCommandBuffer>&&);
+
virtual GPUProgrammablePassEncoder& passEncoder() const = 0;
+
+private:
+ Ref<WebGPUCommandBuffer> m_commandBuffer;
};
} // namespace WebCore
Modified: trunk/Source/WebCore/Modules/webgpu/WebGPUProgrammablePassEncoder.idl (238686 => 238687)
--- trunk/Source/WebCore/Modules/webgpu/WebGPUProgrammablePassEncoder.idl 2018-11-29 21:01:15 UTC (rev 238686)
+++ trunk/Source/WebCore/Modules/webgpu/WebGPUProgrammablePassEncoder.idl 2018-11-29 21:09:08 UTC (rev 238687)
@@ -29,11 +29,13 @@
EnabledAtRuntime=WebGPU,
SkipVTableValidation
] interface WebGPUProgrammablePassEncoder {
+ WebGPUCommandBuffer endPass();
+
+ // FIXME: Only support render pipelines for prototype.
+ void setPipeline(WebGPURenderPipeline pipeline);
/* Not Yet Implemented
- WebGPUCommandBuffer endPass();
// Allowed in both compute and render passes
// TODO: setPushConstants() ?
void setBindGroup(u32 index, WebGPUBindGroup bindGroup);
- void setPipeline((WebGPUComputePipeline or WebGPURenderPipeline) pipeline);
*/
};
Modified: trunk/Source/WebCore/Modules/webgpu/WebGPURenderPassEncoder.cpp (238686 => 238687)
--- trunk/Source/WebCore/Modules/webgpu/WebGPURenderPassEncoder.cpp 2018-11-29 21:01:15 UTC (rev 238686)
+++ trunk/Source/WebCore/Modules/webgpu/WebGPURenderPassEncoder.cpp 2018-11-29 21:09:08 UTC (rev 238687)
@@ -29,19 +29,27 @@
#if ENABLE(WEBGPU)
#include "GPUProgrammablePassEncoder.h"
+#include "GPURenderPassEncoder.h"
namespace WebCore {
-Ref<WebGPURenderPassEncoder> WebGPURenderPassEncoder::create(Ref<GPURenderPassEncoder>&& encoder)
+Ref<WebGPURenderPassEncoder> WebGPURenderPassEncoder::create(Ref<WebGPUCommandBuffer>&& creator, Ref<GPURenderPassEncoder>&& encoder)
{
- return adoptRef(*new WebGPURenderPassEncoder(WTFMove(encoder)));
+ return adoptRef(*new WebGPURenderPassEncoder(WTFMove(creator), WTFMove(encoder)));
}
-WebGPURenderPassEncoder::WebGPURenderPassEncoder(Ref<GPURenderPassEncoder>&& encoder)
- : m_passEncoder(WTFMove(encoder))
+WebGPURenderPassEncoder::WebGPURenderPassEncoder(Ref<WebGPUCommandBuffer>&& creator, Ref<GPURenderPassEncoder>&& encoder)
+ : WebGPUProgrammablePassEncoder(WTFMove(creator))
+ , m_passEncoder(WTFMove(encoder))
{
}
+void WebGPURenderPassEncoder::draw(unsigned long vertexCount, unsigned long instanceCount, unsigned long firstVertex, unsigned long firstInstance)
+{
+ // FIXME: What kind of validation do we need to handle here?
+ m_passEncoder->draw(vertexCount, instanceCount, firstVertex, firstInstance);
+}
+
GPUProgrammablePassEncoder& WebGPURenderPassEncoder::passEncoder() const
{
return m_passEncoder.get();
Modified: trunk/Source/WebCore/Modules/webgpu/WebGPURenderPassEncoder.h (238686 => 238687)
--- trunk/Source/WebCore/Modules/webgpu/WebGPURenderPassEncoder.h 2018-11-29 21:01:15 UTC (rev 238686)
+++ trunk/Source/WebCore/Modules/webgpu/WebGPURenderPassEncoder.h 2018-11-29 21:09:08 UTC (rev 238687)
@@ -27,7 +27,6 @@
#if ENABLE(WEBGPU)
-#include "GPURenderPassEncoder.h"
#include "WebGPUProgrammablePassEncoder.h"
#include <wtf/RefPtr.h>
@@ -35,13 +34,16 @@
namespace WebCore {
class GPUProgrammablePassEncoder;
+class GPURenderPassEncoder;
class WebGPURenderPassEncoder final : public WebGPUProgrammablePassEncoder {
public:
- static Ref<WebGPURenderPassEncoder> create(Ref<GPURenderPassEncoder>&&);
+ static Ref<WebGPURenderPassEncoder> create(Ref<WebGPUCommandBuffer>&&, Ref<GPURenderPassEncoder>&&);
+ void draw(unsigned long, unsigned long, unsigned long, unsigned long);
+
private:
- WebGPURenderPassEncoder(Ref<GPURenderPassEncoder>&&);
+ WebGPURenderPassEncoder(Ref<WebGPUCommandBuffer>&&, Ref<GPURenderPassEncoder>&&);
GPUProgrammablePassEncoder& passEncoder() const final;
Modified: trunk/Source/WebCore/Modules/webgpu/WebGPURenderPassEncoder.idl (238686 => 238687)
--- trunk/Source/WebCore/Modules/webgpu/WebGPURenderPassEncoder.idl 2018-11-29 21:01:15 UTC (rev 238686)
+++ trunk/Source/WebCore/Modules/webgpu/WebGPURenderPassEncoder.idl 2018-11-29 21:09:08 UTC (rev 238687)
@@ -24,16 +24,20 @@
*/
// https://github.com/gpuweb/gpuweb/blob/master/design/sketch.webidl
+typedef unsigned long u32;
+
[
Conditional=WEBGPU,
- EnabledAtRuntime=WebGPU
+ EnabledAtRuntime=WebGPU,
+ JSGenerateToJSObject
] interface WebGPURenderPassEncoder : WebGPUProgrammablePassEncoder {
+ void draw(u32 vertexCount, u32 instanceCount, u32 firstVertex, u32 firstInstance);
+
/* Not Yet Implemented
void setBlendColor(float r, float g, float b, float a);
void setIndexBuffer(WebGPUBuffer buffer, u32 offset);
void setVertexBuffers(u32 startSlot, sequence<WebGPUBuffer> buffers, sequence<u32> offsets);
- void draw(u32 vertexCount, u32 instanceCount, u32 firstVertex, u32 firstInstance);
void drawIndexed(u32 indexCount, u32 instanceCount, u32 firstIndex, i32 baseVertex, u32 firstInstance);
// TODO add missing commands
Modified: trunk/Source/WebCore/Modules/webgpu/WebGPURenderPipeline.cpp (238686 => 238687)
--- trunk/Source/WebCore/Modules/webgpu/WebGPURenderPipeline.cpp 2018-11-29 21:01:15 UTC (rev 238686)
+++ trunk/Source/WebCore/Modules/webgpu/WebGPURenderPipeline.cpp 2018-11-29 21:09:08 UTC (rev 238687)
@@ -32,16 +32,13 @@
namespace WebCore {
-RefPtr<WebGPURenderPipeline> WebGPURenderPipeline::create(RefPtr<GPURenderPipeline>&& pipeline)
+RefPtr<WebGPURenderPipeline> WebGPURenderPipeline::create(Ref<GPURenderPipeline>&& pipeline)
{
- if (!pipeline)
- return nullptr;
-
return adoptRef(new WebGPURenderPipeline(WTFMove(pipeline)));
}
-WebGPURenderPipeline::WebGPURenderPipeline(RefPtr<GPURenderPipeline>&& pipeline)
- : m_renderPipeline(pipeline)
+WebGPURenderPipeline::WebGPURenderPipeline(Ref<GPURenderPipeline>&& pipeline)
+ : m_renderPipeline(WTFMove(pipeline))
{
UNUSED_PARAM(m_renderPipeline);
}
Modified: trunk/Source/WebCore/Modules/webgpu/WebGPURenderPipeline.h (238686 => 238687)
--- trunk/Source/WebCore/Modules/webgpu/WebGPURenderPipeline.h 2018-11-29 21:01:15 UTC (rev 238686)
+++ trunk/Source/WebCore/Modules/webgpu/WebGPURenderPipeline.h 2018-11-29 21:09:08 UTC (rev 238687)
@@ -36,12 +36,14 @@
class WebGPURenderPipeline : public RefCounted<WebGPURenderPipeline> {
public:
- static RefPtr<WebGPURenderPipeline> create(RefPtr<GPURenderPipeline>&&);
+ static RefPtr<WebGPURenderPipeline> create(Ref<GPURenderPipeline>&&);
+ Ref<GPURenderPipeline> renderPipeline() { return m_renderPipeline.copyRef(); }
+
private:
- WebGPURenderPipeline(RefPtr<GPURenderPipeline>&&);
+ WebGPURenderPipeline(Ref<GPURenderPipeline>&&);
- RefPtr<GPURenderPipeline> m_renderPipeline;
+ Ref<GPURenderPipeline> m_renderPipeline;
};
} // namespace WebCore
Modified: trunk/Source/WebCore/Modules/webgpu/WebGPUTexture.cpp (238686 => 238687)
--- trunk/Source/WebCore/Modules/webgpu/WebGPUTexture.cpp 2018-11-29 21:01:15 UTC (rev 238686)
+++ trunk/Source/WebCore/Modules/webgpu/WebGPUTexture.cpp 2018-11-29 21:09:08 UTC (rev 238687)
@@ -28,6 +28,7 @@
#if ENABLE(WEBGPU)
+#include "GPUTexture.h"
#include "WebGPUTextureView.h"
namespace WebCore {
Modified: trunk/Source/WebCore/Modules/webgpu/WebGPUTexture.h (238686 => 238687)
--- trunk/Source/WebCore/Modules/webgpu/WebGPUTexture.h 2018-11-29 21:01:15 UTC (rev 238686)
+++ trunk/Source/WebCore/Modules/webgpu/WebGPUTexture.h 2018-11-29 21:09:08 UTC (rev 238687)
@@ -27,13 +27,12 @@
#if ENABLE(WEBGPU)
-#include "GPUTexture.h"
-
#include <wtf/RefCounted.h>
#include <wtf/RefPtr.h>
namespace WebCore {
+class GPUTexture;
class WebGPUTextureView;
class WebGPUTexture : public RefCounted<WebGPUTexture> {
Modified: trunk/Source/WebCore/platform/graphics/gpu/GPUProgrammablePassEncoder.h (238686 => 238687)
--- trunk/Source/WebCore/platform/graphics/gpu/GPUProgrammablePassEncoder.h 2018-11-29 21:01:15 UTC (rev 238686)
+++ trunk/Source/WebCore/platform/graphics/gpu/GPUProgrammablePassEncoder.h 2018-11-29 21:09:08 UTC (rev 238687)
@@ -33,6 +33,8 @@
namespace WebCore {
+class GPURenderPipeline;
+
using PlatformProgrammablePassEncoder = MTLCommandEncoder;
class GPUProgrammablePassEncoder : public RefCounted<GPUProgrammablePassEncoder> {
@@ -39,8 +41,15 @@
public:
virtual ~GPUProgrammablePassEncoder() = default;
+ void endPass();
+
+ virtual void setPipeline(Ref<GPURenderPipeline>&&) = 0;
+
protected:
virtual PlatformProgrammablePassEncoder* platformPassEncoder() const = 0;
+
+private:
+ bool m_isEncoding { true };
};
} // namespace WebCore
Modified: trunk/Source/WebCore/platform/graphics/gpu/GPURenderPassEncoder.h (238686 => 238687)
--- trunk/Source/WebCore/platform/graphics/gpu/GPURenderPassEncoder.h 2018-11-29 21:01:15 UTC (rev 238686)
+++ trunk/Source/WebCore/platform/graphics/gpu/GPURenderPassEncoder.h 2018-11-29 21:09:08 UTC (rev 238687)
@@ -38,6 +38,7 @@
namespace WebCore {
class GPUCommandBuffer;
+class GPURenderPipeline;
struct GPURenderPassDescriptor;
@@ -48,13 +49,18 @@
public:
static RefPtr<GPURenderPassEncoder> create(const GPUCommandBuffer&, GPURenderPassDescriptor&&);
+ void setPipeline(Ref<GPURenderPipeline>&&) final;
+
+ void draw(unsigned long, unsigned long, unsigned long, unsigned long);
+
private:
GPURenderPassEncoder(PlatformRenderPassEncoderSmartPtr&&);
- ~GPURenderPassEncoder();
+ ~GPURenderPassEncoder() { endPass(); } // Ensure that encoding has ended before release.
- PlatformProgrammablePassEncoder *platformPassEncoder() const final;
+ PlatformProgrammablePassEncoder* platformPassEncoder() const final;
PlatformRenderPassEncoderSmartPtr m_platformRenderPassEncoder;
+ RefPtr<GPURenderPipeline> m_pipeline;
};
} // namespace WebCore
Modified: trunk/Source/WebCore/platform/graphics/gpu/GPURenderPipeline.h (238686 => 238687)
--- trunk/Source/WebCore/platform/graphics/gpu/GPURenderPipeline.h 2018-11-29 21:01:15 UTC (rev 238686)
+++ trunk/Source/WebCore/platform/graphics/gpu/GPURenderPipeline.h 2018-11-29 21:09:08 UTC (rev 238687)
@@ -27,6 +27,8 @@
#if ENABLE(WEBGPU)
+#include "GPURenderPipelineDescriptor.h"
+
#include <wtf/RefCounted.h>
#include <wtf/RefPtr.h>
#include <wtf/RetainPtr.h>
@@ -37,10 +39,9 @@
class GPUDevice;
-struct GPURenderPipelineDescriptor;
-
using PlatformRenderPipeline = MTLRenderPipelineState;
using PlatformRenderPipelineSmartPtr = RetainPtr<MTLRenderPipelineState>;
+using PrimitiveTopology = GPURenderPipelineDescriptor::PrimitiveTopology;
class GPURenderPipeline : public RefCounted<GPURenderPipeline> {
public:
@@ -48,10 +49,13 @@
PlatformRenderPipeline* platformRenderPipeline() const { return m_platformRenderPipeline.get(); }
+ PrimitiveTopology primitiveTopology() const { return m_descriptor.primitiveTopology; }
+
private:
- GPURenderPipeline(PlatformRenderPipelineSmartPtr&&);
+ GPURenderPipeline(PlatformRenderPipelineSmartPtr&&, GPURenderPipelineDescriptor&&);
PlatformRenderPipelineSmartPtr m_platformRenderPipeline;
+ GPURenderPipelineDescriptor m_descriptor;
};
} // namespace WebCore
Modified: trunk/Source/WebCore/platform/graphics/gpu/cocoa/GPUProgrammablePassEncoderMetal.mm (238686 => 238687)
--- trunk/Source/WebCore/platform/graphics/gpu/cocoa/GPUProgrammablePassEncoderMetal.mm 2018-11-29 21:01:15 UTC (rev 238686)
+++ trunk/Source/WebCore/platform/graphics/gpu/cocoa/GPUProgrammablePassEncoderMetal.mm 2018-11-29 21:09:08 UTC (rev 238687)
@@ -28,8 +28,19 @@
#if ENABLE(WEBGPU)
+#import <Metal/Metal.h>
+
namespace WebCore {
+void GPUProgrammablePassEncoder::endPass()
+{
+ if (!m_isEncoding)
+ return;
+
+ [platformPassEncoder() endEncoding];
+ m_isEncoding = false;
+}
+
} // namespace WebCore
#endif // ENABLE(WEBGPU)
Modified: trunk/Source/WebCore/platform/graphics/gpu/cocoa/GPURenderPassEncoderMetal.mm (238686 => 238687)
--- trunk/Source/WebCore/platform/graphics/gpu/cocoa/GPURenderPassEncoderMetal.mm 2018-11-29 21:01:15 UTC (rev 238686)
+++ trunk/Source/WebCore/platform/graphics/gpu/cocoa/GPURenderPassEncoderMetal.mm 2018-11-29 21:09:08 UTC (rev 238687)
@@ -30,6 +30,7 @@
#import "GPUCommandBuffer.h"
#import "GPURenderPassDescriptor.h"
+#import "GPURenderPipeline.h"
#import "Logging.h"
#import <Metal/Metal.h>
@@ -68,18 +69,43 @@
{
}
-GPURenderPassEncoder::~GPURenderPassEncoder()
+PlatformProgrammablePassEncoder *GPURenderPassEncoder::platformPassEncoder() const
{
- // The MTLCommandEncoder must have finished encoding before it can be released.
- // FIXME: Only call this if we have not already ended encoding.
- [m_platformRenderPassEncoder endEncoding];
+ return m_platformRenderPassEncoder.get();
}
-PlatformProgrammablePassEncoder *GPURenderPassEncoder::platformPassEncoder() const
+void GPURenderPassEncoder::setPipeline(Ref<GPURenderPipeline>&& pipeline)
{
- return m_platformRenderPassEncoder.get();
+ [m_platformRenderPassEncoder setRenderPipelineState:pipeline->platformRenderPipeline()];
+ m_pipeline = WTFMove(pipeline);
}
+static MTLPrimitiveType primitiveTypeForGPUPrimitiveTopology(PrimitiveTopology type)
+{
+ switch (type) {
+ case PrimitiveTopology::PointList:
+ return MTLPrimitiveTypePoint;
+ case PrimitiveTopology::LineList:
+ return MTLPrimitiveTypeLine;
+ case PrimitiveTopology::LineStrip:
+ return MTLPrimitiveTypeLineStrip;
+ case PrimitiveTopology::TriangleList:
+ return MTLPrimitiveTypeTriangle;
+ case PrimitiveTopology::TriangleStrip:
+ return MTLPrimitiveTypeTriangleStrip;
+ }
+}
+
+void GPURenderPassEncoder::draw(unsigned long vertexCount, unsigned long instanceCount, unsigned long firstVertex, unsigned long firstInstance)
+{
+ [m_platformRenderPassEncoder
+ drawPrimitives:primitiveTypeForGPUPrimitiveTopology(m_pipeline->primitiveTopology())
+ vertexStart:firstVertex
+ vertexCount:vertexCount
+ instanceCount:instanceCount
+ baseInstance:firstInstance];
+}
+
} // namespace WebCore
#endif // ENABLE(WEBGPU)
Modified: trunk/Source/WebCore/platform/graphics/gpu/cocoa/GPURenderPipelineMetal.mm (238686 => 238687)
--- trunk/Source/WebCore/platform/graphics/gpu/cocoa/GPURenderPipelineMetal.mm 2018-11-29 21:01:15 UTC (rev 238686)
+++ trunk/Source/WebCore/platform/graphics/gpu/cocoa/GPURenderPipelineMetal.mm 2018-11-29 21:09:08 UTC (rev 238687)
@@ -28,7 +28,6 @@
#if ENABLE(WEBGPU)
-#import "GPURenderPipelineDescriptor.h"
#import "Logging.h"
#import <Metal/Metal.h>
@@ -36,7 +35,7 @@
namespace WebCore {
-static bool setFunctionsForPipelineDescriptor(const char* const functionName, MTLRenderPipelineDescriptor *mtlDescriptor, GPURenderPipelineDescriptor&& descriptor)
+static bool setFunctionsForPipelineDescriptor(const char* const functionName, MTLRenderPipelineDescriptor *mtlDescriptor, const GPURenderPipelineDescriptor& descriptor)
{
#if LOG_DISABLED
UNUSED_PARAM(functionName);
@@ -105,7 +104,7 @@
return nullptr;
}
- if (!setFunctionsForPipelineDescriptor(functionName, mtlDescriptor.get(), WTFMove(descriptor)))
+ if (!setFunctionsForPipelineDescriptor(functionName, mtlDescriptor.get(), descriptor))
return nullptr;
// FIXME: Get the pixelFormat as configured for the context/CAMetalLayer.
@@ -124,11 +123,12 @@
return nullptr;
}
- return adoptRef(new GPURenderPipeline(WTFMove(pipeline)));
+ return adoptRef(new GPURenderPipeline(WTFMove(pipeline), WTFMove(descriptor)));
}
-GPURenderPipeline::GPURenderPipeline(PlatformRenderPipelineSmartPtr&& pipeline)
+GPURenderPipeline::GPURenderPipeline(PlatformRenderPipelineSmartPtr&& pipeline, GPURenderPipelineDescriptor&& descriptor)
: m_platformRenderPipeline(WTFMove(pipeline))
+ , m_descriptor(WTFMove(descriptor))
{
}
