Changeset 238687 in webkit


Ignore:
Timestamp:
Nov 29, 2018 1:09:08 PM (5 years ago)
Author:
Justin Fan
Message:

[WebGPU] WebGPURenderPassEncoder::setPipeline, draw, and endPass prototypes
​https://bugs.webkit.org/show_bug.cgi?id=192134

Reviewed by Dean Jackson.

Source/WebCore:

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.

LayoutTests:

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:
Location:
trunk
Files:
2 added
22 edited

Legend:

Unmodified
Added
Removed

  • trunk/LayoutTests/ChangeLog

    r238686 r238687  
     12018-11-29  Justin Fan  <justin_fan@apple.com>
     2
     3        [WebGPU] WebGPURenderPassEncoder::setPipeline, draw, and endPass prototypes
     4        https://bugs.webkit.org/show_bug.cgi?id=192134
     5
     6        Reviewed by Dean Jackson.
     7
     8        Updating the basic rendering test with more commands, and a prototype WPT-based test for WebGPURenderCommandEncoder's
     9        new functionality.
     10
     11        * webgpu/js/basic-webgpu-functions.js:
     12        (render):
     13        * webgpu/render-command-encoding-expected.txt: Added.
     14        * webgpu/render-command-encoding.html: Added.
     15        * webgpu/render-passes.html:
     16
    1172018-11-29  Justin Michaud  <justin_michaud@apple.com>
    218

  • trunk/LayoutTests/webgpu/js/basic-webgpu-functions.js

    r238629 r238687  
    150150    }
    151151
     152    renderPassEncoder.setPipeline(renderPipeline);
     153
     154    // Note that we didn't attach any buffers - the shader is generating the vertices for us.
     155    renderPassEncoder.draw(3, 1, 0, 0);
     156    let commandBufferEnd = renderPassEncoder.endPass();
     157    if (!commandBufferEnd) {
     158        testFailed("Unable to create WebGPUCommandBuffer from WeGPURenderPassEncoder::endPass!");
     159        return;
     160    }
     161
    152162    // FIXME: Rest of rendering commands to follow.
    153163}

  • trunk/LayoutTests/webgpu/render-passes.html

    r238629 r238687  
    77    window.testRunner.dumpAsText();
    88
    9 let commandBuffer, texture, textureView, renderPassDescriptor, renderPassEncoder;
     9let commandBuffer, renderPassEncoder;
    1010
    1111function setUpBasicRenderPassEncoder() {
    1212    commandBuffer = defaultDevice.createCommandBuffer();
    13     texture = context.getNextTexture();
    14     textureView = texture.createDefaultTextureView();
     13    const texture = context.getNextTexture();
     14    const textureView = texture.createDefaultTextureView();
    1515
    1616    // FIXME: Flesh out the rest of WebGPURenderPassDescriptor.
    1717    // Default a loadOp, storeOp, and clearColor in the implementation for now.
    18     renderPassDescriptor = {
     18    const renderPassDescriptor = {
    1919        attachment : textureView
    2020    }

  • trunk/Source/WebCore/ChangeLog

    r238686 r238687  
     12018-11-29  Justin Fan  <justin_fan@apple.com>
     2
     3        [WebGPU] WebGPURenderPassEncoder::setPipeline, draw, and endPass prototypes
     4        https://bugs.webkit.org/show_bug.cgi?id=192134
     5
     6        Reviewed by Dean Jackson.
     7
     8        Wrap up prototype features for WebGPURenderPassEncoder.
     9
     10        Test: webgpu/render-command-encoding.html
     11
     12        * Modules/webgpu/WebGPUCommandBuffer.cpp:
     13        (WebCore::WebGPUCommandBuffer::beginRenderPass):
     14        * Modules/webgpu/WebGPUDevice.cpp:
     15        (WebCore::WebGPUDevice::createRenderPipeline const):
     16        * Modules/webgpu/WebGPUProgrammablePassEncoder.cpp:
     17        (WebCore::WebGPUProgrammablePassEncoder::WebGPUProgrammablePassEncoder):
     18        (WebCore::WebGPUProgrammablePassEncoder::endPass): Returns a reference to the WebGPUCommandBuffer that created this encoder.
     19        (WebCore::WebGPUProgrammablePassEncoder::setPipeline):
     20        * Modules/webgpu/WebGPUProgrammablePassEncoder.h: Updated to support endPass and setPipeline.
     21        * Modules/webgpu/WebGPUProgrammablePassEncoder.idl:
     22        * Modules/webgpu/WebGPURenderPassEncoder.cpp:
     23        (WebCore::WebGPURenderPassEncoder::create): Must be provided with the WebGPUCommandBuffer.
     24        (WebCore::WebGPURenderPassEncoder::WebGPURenderPassEncoder):
     25        (WebCore::WebGPURenderPassEncoder::draw):
     26        * Modules/webgpu/WebGPURenderPassEncoder.h: Updated to cache a reference to the WebGPUCommandBuffer, and for draw.
     27        * Modules/webgpu/WebGPURenderPassEncoder.idl:
     28        * Modules/webgpu/WebGPURenderPipeline.cpp:
     29        (WebCore::WebGPURenderPipeline::create):
     30        (WebCore::WebGPURenderPipeline::WebGPURenderPipeline):
     31        * Modules/webgpu/WebGPURenderPipeline.h:
     32        (WebCore::WebGPURenderPipeline::renderPipeline):
     33        * Modules/webgpu/WebGPUTexture.cpp:
     34        * Modules/webgpu/WebGPUTexture.h: Replaced include with forward declaration.
     35        * platform/graphics/gpu/GPUProgrammablePassEncoder.h: Updated to support new WebGPU_PassEncoder functionality.
     36        * platform/graphics/gpu/GPURenderPassEncoder.h:
     37        (WebCore::GPURenderPassEncoder::~GPURenderPassEncoder): Now ends encoding on the MTLCommandEncoder, if not already ended, before freeing it.
     38        * platform/graphics/gpu/GPURenderPipeline.h: Now remembers the GPUPrimitiveTopology that it was created with.
     39        (WebCore::GPURenderPipeline::primitiveTopology const):
     40        * platform/graphics/gpu/cocoa/GPUProgrammablePassEncoderMetal.mm:
     41        (WebCore::GPUProgrammablePassEncoder::endPass): Calls endEncoding on the backing MTLCommandEncoder, if not already ended.
     42        * platform/graphics/gpu/cocoa/GPURenderPassEncoderMetal.mm:
     43        (WebCore::GPURenderPassEncoder::platformPassEncoder const):
     44        (WebCore::GPURenderPassEncoder::setPipeline): Added.
     45        (WebCore::primitiveTypeForGPUPrimitiveTopology): Added. Helper function to convert GPUPrimitiveTopology to MTLPrimitiveType.
     46        (WebCore::GPURenderPassEncoder::draw): Added. Draws using primitive topology specified during pipeline creation.
     47        * platform/graphics/gpu/cocoa/GPURenderPipelineMetal.mm:
     48        (WebCore::setFunctionsForPipelineDescriptor):
     49        (WebCore::GPURenderPipeline::create):
     50        (WebCore::GPURenderPipeline::GPURenderPipeline): Now must store the GPURenderPipelineDescriptor for later reference.
     51
    1522018-11-29  Justin Michaud  <justin_michaud@apple.com>
    253

  • trunk/Source/WebCore/Modules/webgpu/WebGPUCommandBuffer.cpp

    r238629 r238687  
    6464        return nullptr;
    6565
    66     return WebGPURenderPassEncoder::create(encoder.releaseNonNull());
     66    return WebGPURenderPassEncoder::create(*this, encoder.releaseNonNull());
    6767}
    6868

  • trunk/Source/WebCore/Modules/webgpu/WebGPUDevice.cpp

    r238451 r238687  
    118118    }
    119119
    120     return WebGPURenderPipeline::create(m_device->createRenderPipeline(GPURenderPipelineDescriptor { WTFMove(vertexStage), WTFMove(fragmentStage), descriptor.primitiveTopology }));
     120    auto pipeline = m_device->createRenderPipeline(GPURenderPipelineDescriptor { WTFMove(vertexStage), WTFMove(fragmentStage), descriptor.primitiveTopology });
     121
     122    if (!pipeline)
     123        return nullptr;
     124
     125    return WebGPURenderPipeline::create(pipeline.releaseNonNull());
    121126}
    122127

  • trunk/Source/WebCore/Modules/webgpu/WebGPUProgrammablePassEncoder.cpp

    r238629 r238687  
    2929#if ENABLE(WEBGPU)
    3030
     31#include "GPUProgrammablePassEncoder.h"
     32#include "WebGPUCommandBuffer.h"
     33#include "WebGPURenderPipeline.h"
     34
    3135namespace WebCore {
     36
     37WebGPUProgrammablePassEncoder::WebGPUProgrammablePassEncoder(Ref<WebGPUCommandBuffer>&& creator)
     38    : m_commandBuffer(WTFMove(creator))
     39{
     40}
     41
     42Ref<WebGPUCommandBuffer> WebGPUProgrammablePassEncoder::endPass()
     43{
     44    passEncoder().endPass();
     45    return m_commandBuffer.copyRef();
     46}
     47
     48void WebGPUProgrammablePassEncoder::setPipeline(Ref<WebGPURenderPipeline>&& pipeline)
     49{
     50    passEncoder().setPipeline(pipeline->renderPipeline());
     51}
    3252
    3353} // namespace WebCore

  • trunk/Source/WebCore/Modules/webgpu/WebGPUProgrammablePassEncoder.h

    r238629 r238687  
    3333
    3434class GPUProgrammablePassEncoder;
     35class WebGPUCommandBuffer;
     36class WebGPURenderPipeline;
    3537
    3638class WebGPUProgrammablePassEncoder : public RefCounted<WebGPUProgrammablePassEncoder> {
    … …  
    3840    virtual ~WebGPUProgrammablePassEncoder() = default;
    3941
     42    Ref<WebGPUCommandBuffer> endPass();
     43    void setPipeline(Ref<WebGPURenderPipeline>&&);
     44
    4045protected:
     46    WebGPUProgrammablePassEncoder(Ref<WebGPUCommandBuffer>&&);
     47
    4148    virtual GPUProgrammablePassEncoder& passEncoder() const = 0;
     49
     50private:
     51    Ref<WebGPUCommandBuffer> m_commandBuffer;
    4252};
    4353

  • trunk/Source/WebCore/Modules/webgpu/WebGPUProgrammablePassEncoder.idl

    r238629 r238687  
    3030    SkipVTableValidation
    3131] interface WebGPUProgrammablePassEncoder {
     32    WebGPUCommandBuffer endPass();
     33
     34    // FIXME: Only support render pipelines for prototype.
     35    void setPipeline(WebGPURenderPipeline pipeline);
    3236/* Not Yet Implemented
    33     WebGPUCommandBuffer endPass();
    3437    // Allowed in both compute and render passes
    3538    // TODO: setPushConstants() ?
    3639    void setBindGroup(u32 index, WebGPUBindGroup bindGroup);
    37     void setPipeline((WebGPUComputePipeline or WebGPURenderPipeline) pipeline);
    3840*/
    3941};

  • trunk/Source/WebCore/Modules/webgpu/WebGPURenderPassEncoder.cpp

    r238629 r238687  
    3030
    3131#include "GPUProgrammablePassEncoder.h"
     32#include "GPURenderPassEncoder.h"
    3233
    3334namespace WebCore {
    3435
    35 Ref<WebGPURenderPassEncoder> WebGPURenderPassEncoder::create(Ref<GPURenderPassEncoder>&& encoder)
     36Ref<WebGPURenderPassEncoder> WebGPURenderPassEncoder::create(Ref<WebGPUCommandBuffer>&& creator, Ref<GPURenderPassEncoder>&& encoder)
    3637{
    37     return adoptRef(*new WebGPURenderPassEncoder(WTFMove(encoder)));
     38    return adoptRef(*new WebGPURenderPassEncoder(WTFMove(creator), WTFMove(encoder)));
    3839}
    3940
    40 WebGPURenderPassEncoder::WebGPURenderPassEncoder(Ref<GPURenderPassEncoder>&& encoder)
    41     : m_passEncoder(WTFMove(encoder))
     41WebGPURenderPassEncoder::WebGPURenderPassEncoder(Ref<WebGPUCommandBuffer>&& creator, Ref<GPURenderPassEncoder>&& encoder)
     42    : WebGPUProgrammablePassEncoder(WTFMove(creator))
     43    , m_passEncoder(WTFMove(encoder))
    4244{
     45}
     46
     47void WebGPURenderPassEncoder::draw(unsigned long vertexCount, unsigned long instanceCount, unsigned long firstVertex, unsigned long firstInstance)
     48{
     49    // FIXME: What kind of validation do we need to handle here?
     50    m_passEncoder->draw(vertexCount, instanceCount, firstVertex, firstInstance);
    4351}
    4452

  • trunk/Source/WebCore/Modules/webgpu/WebGPURenderPassEncoder.h

    r238629 r238687  
    2828#if ENABLE(WEBGPU)
    2929
    30 #include "GPURenderPassEncoder.h"
    3130#include "WebGPUProgrammablePassEncoder.h"
    3231
    … …  
    3635
    3736class GPUProgrammablePassEncoder;
     37class GPURenderPassEncoder;
    3838
    3939class WebGPURenderPassEncoder final : public WebGPUProgrammablePassEncoder {
    4040public:
    41     static Ref<WebGPURenderPassEncoder> create(Ref<GPURenderPassEncoder>&&);
     41    static Ref<WebGPURenderPassEncoder> create(Ref<WebGPUCommandBuffer>&&, Ref<GPURenderPassEncoder>&&);
     42
     43    void draw(unsigned long, unsigned long, unsigned long, unsigned long);
    4244
    4345private:
    44     WebGPURenderPassEncoder(Ref<GPURenderPassEncoder>&&);
     46    WebGPURenderPassEncoder(Ref<WebGPUCommandBuffer>&&, Ref<GPURenderPassEncoder>&&);
    4547
    4648    GPUProgrammablePassEncoder& passEncoder() const final;

  • trunk/Source/WebCore/Modules/webgpu/WebGPURenderPassEncoder.idl

    r238629 r238687  
    2525// https://github.com/gpuweb/gpuweb/blob/master/design/sketch.webidl
    2626
     27typedef unsigned long u32;
     28
    2729[
    2830    Conditional=WEBGPU,
    29     EnabledAtRuntime=WebGPU
     31    EnabledAtRuntime=WebGPU,
     32    JSGenerateToJSObject
    3033] interface WebGPURenderPassEncoder : WebGPUProgrammablePassEncoder {
     34    void draw(u32 vertexCount, u32 instanceCount, u32 firstVertex, u32 firstInstance);
     35
    3136/* Not Yet Implemented
    3237    void setBlendColor(float r, float g, float b, float a);
    … …  
    3439    void setVertexBuffers(u32 startSlot, sequence<WebGPUBuffer> buffers, sequence<u32> offsets);
    3540
    36     void draw(u32 vertexCount, u32 instanceCount, u32 firstVertex, u32 firstInstance);
    3741    void drawIndexed(u32 indexCount, u32 instanceCount, u32 firstIndex, i32 baseVertex, u32 firstInstance);
    3842

  • trunk/Source/WebCore/Modules/webgpu/WebGPURenderPipeline.cpp

    r237912 r238687  
    3333namespace WebCore {
    3434
    35 RefPtr<WebGPURenderPipeline> WebGPURenderPipeline::create(RefPtr<GPURenderPipeline>&& pipeline)
     35RefPtr<WebGPURenderPipeline> WebGPURenderPipeline::create(Ref<GPURenderPipeline>&& pipeline)
    3636{
    37     if (!pipeline)
    38         return nullptr;
    39 
    4037    return adoptRef(new WebGPURenderPipeline(WTFMove(pipeline)));
    4138}
    4239
    43 WebGPURenderPipeline::WebGPURenderPipeline(RefPtr<GPURenderPipeline>&& pipeline)
    44     : m_renderPipeline(pipeline)
     40WebGPURenderPipeline::WebGPURenderPipeline(Ref<GPURenderPipeline>&& pipeline)
     41    : m_renderPipeline(WTFMove(pipeline))
    4542{
    4643    UNUSED_PARAM(m_renderPipeline);

  • trunk/Source/WebCore/Modules/webgpu/WebGPURenderPipeline.h

    r237912 r238687  
    3737class WebGPURenderPipeline : public RefCounted<WebGPURenderPipeline> {
    3838public:
    39     static RefPtr<WebGPURenderPipeline> create(RefPtr<GPURenderPipeline>&&);
     39    static RefPtr<WebGPURenderPipeline> create(Ref<GPURenderPipeline>&&);
     40
     41    Ref<GPURenderPipeline> renderPipeline() { return m_renderPipeline.copyRef(); }
    4042
    4143private:
    42     WebGPURenderPipeline(RefPtr<GPURenderPipeline>&&);
     44    WebGPURenderPipeline(Ref<GPURenderPipeline>&&);
    4345
    44     RefPtr<GPURenderPipeline> m_renderPipeline;
     46    Ref<GPURenderPipeline> m_renderPipeline;
    4547};
    4648

  • trunk/Source/WebCore/Modules/webgpu/WebGPUTexture.cpp

    r238382 r238687  
    2929#if ENABLE(WEBGPU)
    3030
     31#include "GPUTexture.h"
    3132#include "WebGPUTextureView.h"
    3233

  • trunk/Source/WebCore/Modules/webgpu/WebGPUTexture.h

    r238382 r238687  
    2828#if ENABLE(WEBGPU)
    2929
    30 #include "GPUTexture.h"
    31 
    3230#include <wtf/RefCounted.h>
    3331#include <wtf/RefPtr.h>
    … …  
    3533namespace WebCore {
    3634
     35class GPUTexture;
    3736class WebGPUTextureView;
    3837

  • trunk/Source/WebCore/platform/graphics/gpu/GPUProgrammablePassEncoder.h

    r238629 r238687  
    3434namespace WebCore {
    3535
     36class GPURenderPipeline;
     37
    3638using PlatformProgrammablePassEncoder = MTLCommandEncoder;
    3739
    … …  
    4042    virtual ~GPUProgrammablePassEncoder() = default;
    4143
     44    void endPass();
     45
     46    virtual void setPipeline(Ref<GPURenderPipeline>&&) = 0;
     47
    4248protected:
    4349    virtual PlatformProgrammablePassEncoder* platformPassEncoder() const = 0;
     50
     51private:
     52    bool m_isEncoding { true };
    4453};
    4554

  • trunk/Source/WebCore/platform/graphics/gpu/GPURenderPassEncoder.h

    r238629 r238687  
    3939
    4040class GPUCommandBuffer;
     41class GPURenderPipeline;
    4142
    4243struct GPURenderPassDescriptor;
    … …  
    4950    static RefPtr<GPURenderPassEncoder> create(const GPUCommandBuffer&, GPURenderPassDescriptor&&);
    5051
     52    void setPipeline(Ref<GPURenderPipeline>&&) final;
     53
     54    void draw(unsigned long, unsigned long, unsigned long, unsigned long);
     55
    5156private:
    5257    GPURenderPassEncoder(PlatformRenderPassEncoderSmartPtr&&);
    53     ~GPURenderPassEncoder();
     58    ~GPURenderPassEncoder() { endPass(); } // Ensure that encoding has ended before release.
    5459
    55     PlatformProgrammablePassEncoder *platformPassEncoder() const final;
     60    PlatformProgrammablePassEncoder* platformPassEncoder() const final;
    5661
    5762    PlatformRenderPassEncoderSmartPtr m_platformRenderPassEncoder;
     63    RefPtr<GPURenderPipeline> m_pipeline;
    5864};
    5965

  • trunk/Source/WebCore/platform/graphics/gpu/GPURenderPipeline.h

    r238419 r238687  
    2828#if ENABLE(WEBGPU)
    2929
     30#include "GPURenderPipelineDescriptor.h"
     31
    3032#include <wtf/RefCounted.h>
    3133#include <wtf/RefPtr.h>
    … …  
    3840class GPUDevice;
    3941
    40 struct GPURenderPipelineDescriptor;
    41 
    4242using PlatformRenderPipeline = MTLRenderPipelineState;
    4343using PlatformRenderPipelineSmartPtr = RetainPtr<MTLRenderPipelineState>;
     44using PrimitiveTopology = GPURenderPipelineDescriptor::PrimitiveTopology;
    4445
    4546class GPURenderPipeline : public RefCounted<GPURenderPipeline> {
    … …  
    4950    PlatformRenderPipeline* platformRenderPipeline() const { return m_platformRenderPipeline.get(); }
    5051
     52    PrimitiveTopology primitiveTopology() const { return m_descriptor.primitiveTopology; }
     53
    5154private:
    52     GPURenderPipeline(PlatformRenderPipelineSmartPtr&&);
     55    GPURenderPipeline(PlatformRenderPipelineSmartPtr&&, GPURenderPipelineDescriptor&&);
    5356
    5457    PlatformRenderPipelineSmartPtr m_platformRenderPipeline;
     58    GPURenderPipelineDescriptor m_descriptor;
    5559};
    5660

  • trunk/Source/WebCore/platform/graphics/gpu/cocoa/GPUProgrammablePassEncoderMetal.mm

    r238629 r238687  
    2929#if ENABLE(WEBGPU)
    3030
     31#import <Metal/Metal.h>
     32
    3133namespace WebCore {
     34
     35void GPUProgrammablePassEncoder::endPass()
     36{
     37    if (!m_isEncoding)
     38        return;
     39
     40    [platformPassEncoder() endEncoding];
     41    m_isEncoding = false;
     42}
    3243
    3344} // namespace WebCore

  • trunk/Source/WebCore/platform/graphics/gpu/cocoa/GPURenderPassEncoderMetal.mm

    r238629 r238687  
    3131#import "GPUCommandBuffer.h"
    3232#import "GPURenderPassDescriptor.h"
     33#import "GPURenderPipeline.h"
    3334#import "Logging.h"
    3435
    … …  
    6970}
    7071
    71 GPURenderPassEncoder::~GPURenderPassEncoder()
    72 {
    73     // The MTLCommandEncoder must have finished encoding before it can be released.
    74     // FIXME: Only call this if we have not already ended encoding.
    75     [m_platformRenderPassEncoder endEncoding];
    76 }
    77 
    7872PlatformProgrammablePassEncoder *GPURenderPassEncoder::platformPassEncoder() const
    7973{
    … …  
    8175}
    8276
     77void GPURenderPassEncoder::setPipeline(Ref<GPURenderPipeline>&& pipeline)
     78{
     79    [m_platformRenderPassEncoder setRenderPipelineState:pipeline->platformRenderPipeline()];
     80    m_pipeline = WTFMove(pipeline);
     81}
     82
     83static MTLPrimitiveType primitiveTypeForGPUPrimitiveTopology(PrimitiveTopology type)
     84{
     85    switch (type) {
     86    case PrimitiveTopology::PointList:
     87        return MTLPrimitiveTypePoint;
     88    case PrimitiveTopology::LineList:
     89        return MTLPrimitiveTypeLine;
     90    case PrimitiveTopology::LineStrip:
     91        return MTLPrimitiveTypeLineStrip;
     92    case PrimitiveTopology::TriangleList:
     93        return MTLPrimitiveTypeTriangle;
     94    case PrimitiveTopology::TriangleStrip:
     95        return MTLPrimitiveTypeTriangleStrip;
     96    }
     97}
     98
     99void GPURenderPassEncoder::draw(unsigned long vertexCount, unsigned long instanceCount, unsigned long firstVertex, unsigned long firstInstance)
     100{
     101    [m_platformRenderPassEncoder
     102        drawPrimitives:primitiveTypeForGPUPrimitiveTopology(m_pipeline->primitiveTopology())
     103        vertexStart:firstVertex
     104        vertexCount:vertexCount
     105        instanceCount:instanceCount
     106        baseInstance:firstInstance];
     107}
     108
    83109} // namespace WebCore
    84110

  • trunk/Source/WebCore/platform/graphics/gpu/cocoa/GPURenderPipelineMetal.mm

    r238419 r238687  
    2929#if ENABLE(WEBGPU)
    3030
    31 #import "GPURenderPipelineDescriptor.h"
    3231#import "Logging.h"
    3332
    … …  
    3736namespace WebCore {
    3837
    39 static bool setFunctionsForPipelineDescriptor(const char* const functionName, MTLRenderPipelineDescriptor *mtlDescriptor, GPURenderPipelineDescriptor&& descriptor)
     38static bool setFunctionsForPipelineDescriptor(const char* const functionName, MTLRenderPipelineDescriptor *mtlDescriptor, const GPURenderPipelineDescriptor& descriptor)
    4039{
    4140#if LOG_DISABLED
    … …  
    106105    }
    107106
    108     if (!setFunctionsForPipelineDescriptor(functionName, mtlDescriptor.get(), WTFMove(descriptor)))
     107    if (!setFunctionsForPipelineDescriptor(functionName, mtlDescriptor.get(), descriptor))
    109108        return nullptr;
    110109
    … …  
    125124    }
    126125
    127     return adoptRef(new GPURenderPipeline(WTFMove(pipeline)));
     126    return adoptRef(new GPURenderPipeline(WTFMove(pipeline), WTFMove(descriptor)));
    128127}
    129128
    130 GPURenderPipeline::GPURenderPipeline(PlatformRenderPipelineSmartPtr&& pipeline)
     129GPURenderPipeline::GPURenderPipeline(PlatformRenderPipelineSmartPtr&& pipeline, GPURenderPipelineDescriptor&& descriptor)
    131130    : m_platformRenderPipeline(WTFMove(pipeline))
     131    , m_descriptor(WTFMove(descriptor))
    132132{
    133133}
Note: See TracChangeset for help on using the changeset viewer.