⚠ Archived content — this site is no longer maintained.   Current WebKit documentation is at docs.webkit.org.

Changeset 243419 in webkit


Ignore:
Timestamp:
Mar 23, 2019, 6:35:13 PM (7 years ago)
Author:
Justin Fan
Message:

[Web GPU] Prototype compute pipeline with MSL
​https://bugs.webkit.org/show_bug.cgi?id=196107
<rdar://problem/46289650>

Reviewed by Myles Maxfield.

Source/WebCore:

Add GPUComputePassEncoder, GPUComputePipeline, and GPUComputePipelineDescriptor.
Implement everything needed to prototype a compute pipeline in Web GPU using Metal shaders and bound resources.

Test: webgpu/compute-squares.html

Add files and symbols:

  • CMakeLists.txt:
  • DerivedSources-input.xcfilelist:
  • DerivedSources-output.xcfilelist:
  • DerivedSources.make:
  • Sources.txt:
  • SourcesCocoa.txt:
  • WebCore.xcodeproj/project.pbxproj:
  • bindings/js/WebCoreBuiltinNames.h:

Misc fixes:

  • Modules/webgpu/WHLSL/WHLSLNameResolver.h: Missing include.
  • Modules/webgpu/WHLSL/WHLSLSynthesizeConstructors.cpp: Missing include.
  • Modules/webgpu/WebGPUPipelineStageDescriptor.cpp: Added. Move pipeline stage validation logic here.

(WebCore::WebGPUPipelineStageDescriptor::tryCreateGPUPipelineStageDescriptor const):

  • Modules/webgpu/WebGPURenderPipeline.cpp: Remove unnecessary include.
  • Modules/webgpu/WebGPURenderPipeline.h:
  • Modules/webgpu/WebGPURenderPipelineDescriptor.cpp: Add missing inlcude.

(WebCore::WebGPUPipelineStageDescriptor::tryCreateGPUPipelineStageDescriptor const): Moved to WebGPUPipelineStageDescriptor.cpp.

  • platform/graphics/gpu/GPUPipelineDescriptorBase.h: Add missing include.
  • platform/graphics/gpu/cocoa/GPURenderPipelineMetal.mm: Add missing include.

(WebCore::GPURenderPipeline::GPURenderPipeline): Remove unecessary ref of GPUPipelineLayout.

  • platform/text/mac/TextEncodingRegistryMac.mm: Carbon.h was causing ambiguous reference build errors in this file.

Enable creating a GPUComputePassEncoder from a GPUCommandEncoder:

  • Modules/webgpu/WebGPUCommandEncoder.cpp:

(WebCore::WebGPUCommandEncoder::beginRenderPass): No longer passing this WebGPUCommandEncoder to pass encoders.
(WebCore::WebGPUCommandEncoder::beginComputePass): Added.

  • Modules/webgpu/WebGPUCommandEncoder.h:
  • Modules/webgpu/WebGPUCommandEncoder.idl:

Add GPUComputePassEncoder:

  • Modules/webgpu/WebGPUComputePassEncoder.cpp: Added.

(WebCore::WebGPUComputePassEncoder::create):
(WebCore::WebGPUComputePassEncoder::WebGPUComputePassEncoder):
(WebCore::WebGPUComputePassEncoder::setPipeline):
(WebCore::WebGPUComputePassEncoder::dispatch):
(WebCore::WebGPUComputePassEncoder::passEncoder):
(WebCore::WebGPUComputePassEncoder::passEncoder const):

  • Modules/webgpu/WebGPUComputePassEncoder.h: Added.
  • Modules/webgpu/WebGPUComputePassEncoder.idl: Added.
  • platform/graphics/gpu/GPUComputePassEncoder.h: Added.

(WebCore::GPUComputePassEncoder::~GPUComputePassEncoder):

  • platform/graphics/gpu/cocoa/GPUComputePassEncoderMetal.mm: Added.

(WebCore::GPUComputePassEncoder::tryCreate):
(WebCore::GPUComputePassEncoder::GPUComputePassEncoder):
(WebCore::GPUComputePassEncoder::setPipeline):
(WebCore::GPUComputePassEncoder::dispatch): Use a default calculation for threadsPerThreadgroup while MSL is still an accepted shader format.
(WebCore::GPUComputePassEncoder::platformPassEncoder const):
(WebCore::GPUComputePassEncoder::useResource):
(WebCore::GPUComputePassEncoder::setComputeBuffer):

Add GPUComputePipeline:

  • Modules/webgpu/WebGPUComputePipeline.cpp: Added.

(WebCore::WebGPUComputePipeline::create):
(WebCore::WebGPUComputePipeline::WebGPUComputePipeline):

  • Modules/webgpu/WebGPUComputePipeline.h: Added.

(WebCore::WebGPUComputePipeline::computePipeline const):

  • Modules/webgpu/WebGPUComputePipeline.idl: Added.
  • Modules/webgpu/WebGPUComputePipelineDescriptor.cpp: Added.

(WebCore::WebGPUComputePipelineDescriptor::tryCreateGPUComputePipelineDescriptor const):

  • Modules/webgpu/WebGPUComputePipelineDescriptor.h: Added.
  • Modules/webgpu/WebGPUComputePipelineDescriptor.idl: Added.
  • platform/graphics/gpu/GPUComputePipeline.h: Added.

(WebCore::GPUComputePipeline::platformComputePipeline const):

  • platform/graphics/gpu/GPUComputePipelineDescriptor.h: Added.

(WebCore::GPUComputePipelineDescriptor::GPUComputePipelineDescriptor):

  • platform/graphics/gpu/cocoa/GPUComputePipelineMetal.mm: Added.

(WebCore::tryCreateMtlComputeFunction):
(WebCore::tryCreateMTLComputePipelineState):
(WebCore::GPUComputePipeline::tryCreate):
(WebCore::GPUComputePipeline::GPUComputePipeline):

Enable creating a GPUComputePipeline from a GPUDevice:

  • Modules/webgpu/WebGPUDevice.cpp:

(WebCore::WebGPUDevice::createComputePipeline const):

  • Modules/webgpu/WebGPUDevice.h:
  • Modules/webgpu/WebGPUDevice.idl:
  • platform/graphics/gpu/GPUDevice.cpp:

(WebCore::GPUDevice::tryCreateComputePipeline const):

  • platform/graphics/gpu/GPUDevice.h:

No longer unnecessarily ref the WebGPUCommandEncoder when creating pass encoder:

  • Modules/webgpu/WebGPUProgrammablePassEncoder.cpp:

(WebCore::WebGPUProgrammablePassEncoder::setBindGroup):
(WebCore::WebGPUProgrammablePassEncoder::WebGPUProgrammablePassEncoder): Deleted.
(WebCore::WebGPUProgrammablePassEncoder::setBindGroup const): Deleted.

  • Modules/webgpu/WebGPUProgrammablePassEncoder.h:
  • Modules/webgpu/WebGPURenderPassEncoder.cpp:

(WebCore::WebGPURenderPassEncoder::create):
(WebCore::WebGPURenderPassEncoder::WebGPURenderPassEncoder):
(WebCore::WebGPURenderPassEncoder::setPipeline):
(WebCore::WebGPURenderPassEncoder::passEncoder):
(WebCore::WebGPURenderPassEncoder::passEncoder const):

  • Modules/webgpu/WebGPURenderPassEncoder.h:

Updates to GPUBindGroup and *setBindGroup for compute function arguments:

  • platform/graphics/gpu/GPUBindGroup.h:

(WebCore::GPUBindGroup::vertexArgsBuffer const):
(WebCore::GPUBindGroup::fragmentArgsBuffer const):
(WebCore::GPUBindGroup::computeArgsBuffer const):
(WebCore::GPUBindGroup::vertexArgsBuffer): Deleted. Const-qualified.
(WebCore::GPUBindGroup::fragmentArgsBuffer): Ditto.

  • platform/graphics/gpu/cocoa/GPUBindGroupMetal.mm:

(WebCore::tryGetResourceAsMTLSamplerState): Now just returns the MTLSamplerState to reduce reference churning.
(WebCore::GPUBindGroup::tryCreate):
(WebCore::GPUBindGroup::GPUBindGroup):
(WebCore::tryGetResourceAsSampler): Renamed to tryGetResourceAsMTLSamplerState.

Updates to GPUProgrammablePassEncoder and GPURenderPassEncoder:

  • platform/graphics/gpu/GPUProgrammablePassEncoder.h:

(WebCore::GPUProgrammablePassEncoder::setVertexBuffer):
(WebCore::GPUProgrammablePassEncoder::setFragmentBuffer):
(WebCore::GPUProgrammablePassEncoder::setComputeBuffer): Added.

  • platform/graphics/gpu/GPURenderPassEncoder.h:

(WebCore::GPURenderPassEncoder::~GPURenderPassEncoder):

  • platform/graphics/gpu/GPURenderPipeline.h:
  • platform/graphics/gpu/cocoa/GPUProgrammablePassEncoderMetal.mm: Remove unecessary include.

(WebCore::GPUProgrammablePassEncoder::endPass): No longer virtual. Delegates shared behavior for derived classes.
(WebCore::GPUProgrammablePassEncoder::setBindGroup):

  • platform/graphics/gpu/cocoa/GPURenderPassEncoderMetal.mm:

(WebCore::GPURenderPassEncoder::platformPassEncoder const):
(WebCore::GPURenderPassEncoder::setPipeline):
(WebCore::GPURenderPassEncoder::draw):
(WebCore::GPURenderPassEncoder::useResource): These private overrides are called only by base after checking for encoder existence.
(WebCore::GPURenderPassEncoder::setVertexBuffer): Ditto.
(WebCore::GPURenderPassEncoder::setFragmentBuffer): Ditto.
(WebCore::GPURenderPassEncoder::endPass): Deleted. Now handled by base class.

LayoutTests:

Add a basic test to create, execute, and verify the results of a Web GPU compute pipeline.

  • webgpu/compute-squares-expected.txt: Added.
  • webgpu/compute-squares.html: Added.
  • webgpu/whlsl.html: Update some function names to match API changes.
Location:
trunk
Files:
4 added
38 edited
13 copied

Legend:

Unmodified
Added
Removed

  • trunk/LayoutTests/ChangeLog

    r243416 r243419  
     12019-03-23  Justin Fan  <justin_fan@apple.com>
     2
     3        [Web GPU] Prototype compute pipeline with MSL
     4        https://bugs.webkit.org/show_bug.cgi?id=196107
     5        <rdar://problem/46289650>
     6
     7        Reviewed by Myles Maxfield.
     8
     9        Add a basic test to create, execute, and verify the results of a Web GPU compute pipeline.
     10
     11        * webgpu/compute-squares-expected.txt: Added.
     12        * webgpu/compute-squares.html: Added.
     13        * webgpu/whlsl.html: Update some function names to match API changes.
     14
    1152019-03-23  Simon Fraser  <simon.fraser@apple.com>
    216

  • trunk/LayoutTests/webgpu/whlsl.html

    r243105 r243419  
    9494    const swapChain = device.createSwapChain(swapChainDescriptor);
    9595    const outputTexture = swapChain.getCurrentTexture();
    96     const outputTextureView = outputTexture.createDefaultView(); // createDefaultView()
     96    const outputTextureView = outputTexture.createDefaultView();
    9797
    9898    const commandEncoder = device.createCommandEncoder(); // {}

  • trunk/Source/WebCore/CMakeLists.txt

    r243193 r243419  
    498498    Modules/webgpu/WebGPUCommandBuffer.idl
    499499    Modules/webgpu/WebGPUCommandEncoder.idl
     500    Modules/webgpu/WebGPUComputePassEncoder.idl
     501    Modules/webgpu/WebGPUComputePipeline.idl
     502    Modules/webgpu/WebGPUComputePipelineDescriptor.idl
    500503    Modules/webgpu/WebGPUDevice.idl
    501504    Modules/webgpu/WebGPUPipelineDescriptorBase.idl

  • trunk/Source/WebCore/ChangeLog

    r243416 r243419  
     12019-03-23  Justin Fan  <justin_fan@apple.com>
     2
     3        [Web GPU] Prototype compute pipeline with MSL
     4        https://bugs.webkit.org/show_bug.cgi?id=196107
     5        <rdar://problem/46289650>
     6
     7        Reviewed by Myles Maxfield.
     8
     9        Add GPUComputePassEncoder, GPUComputePipeline, and GPUComputePipelineDescriptor.
     10        Implement everything needed to prototype a compute pipeline in Web GPU using Metal shaders and bound resources.
     11
     12        Test: webgpu/compute-squares.html
     13
     14        Add files and symbols:
     15        * CMakeLists.txt:
     16        * DerivedSources-input.xcfilelist:
     17        * DerivedSources-output.xcfilelist:
     18        * DerivedSources.make:
     19        * Sources.txt:
     20        * SourcesCocoa.txt:
     21        * WebCore.xcodeproj/project.pbxproj:
     22        * bindings/js/WebCoreBuiltinNames.h:
     23
     24        Misc fixes:
     25        * Modules/webgpu/WHLSL/WHLSLNameResolver.h: Missing include.
     26        * Modules/webgpu/WHLSL/WHLSLSynthesizeConstructors.cpp: Missing include.
     27        * Modules/webgpu/WebGPUPipelineStageDescriptor.cpp: Added. Move pipeline stage validation logic here.
     28        (WebCore::WebGPUPipelineStageDescriptor::tryCreateGPUPipelineStageDescriptor const):
     29        * Modules/webgpu/WebGPURenderPipeline.cpp: Remove unnecessary include.
     30        * Modules/webgpu/WebGPURenderPipeline.h:
     31        * Modules/webgpu/WebGPURenderPipelineDescriptor.cpp: Add missing inlcude.
     32        (WebCore::WebGPUPipelineStageDescriptor::tryCreateGPUPipelineStageDescriptor const): Moved to WebGPUPipelineStageDescriptor.cpp.
     33        * platform/graphics/gpu/GPUPipelineDescriptorBase.h: Add missing include.
     34        * platform/graphics/gpu/cocoa/GPURenderPipelineMetal.mm: Add missing include.
     35        (WebCore::GPURenderPipeline::GPURenderPipeline): Remove unecessary ref of GPUPipelineLayout.
     36        * platform/text/mac/TextEncodingRegistryMac.mm: Carbon.h was causing ambiguous reference build errors in this file.
     37
     38        Enable creating a GPUComputePassEncoder from a GPUCommandEncoder:
     39        * Modules/webgpu/WebGPUCommandEncoder.cpp:
     40        (WebCore::WebGPUCommandEncoder::beginRenderPass): No longer passing this WebGPUCommandEncoder to pass encoders.
     41        (WebCore::WebGPUCommandEncoder::beginComputePass): Added.
     42        * Modules/webgpu/WebGPUCommandEncoder.h:
     43        * Modules/webgpu/WebGPUCommandEncoder.idl:
     44
     45        Add GPUComputePassEncoder:
     46        * Modules/webgpu/WebGPUComputePassEncoder.cpp: Added.
     47        (WebCore::WebGPUComputePassEncoder::create):
     48        (WebCore::WebGPUComputePassEncoder::WebGPUComputePassEncoder):
     49        (WebCore::WebGPUComputePassEncoder::setPipeline):
     50        (WebCore::WebGPUComputePassEncoder::dispatch):
     51        (WebCore::WebGPUComputePassEncoder::passEncoder):
     52        (WebCore::WebGPUComputePassEncoder::passEncoder const):
     53        * Modules/webgpu/WebGPUComputePassEncoder.h: Added.
     54        * Modules/webgpu/WebGPUComputePassEncoder.idl: Added.
     55        * platform/graphics/gpu/GPUComputePassEncoder.h: Added.
     56        (WebCore::GPUComputePassEncoder::~GPUComputePassEncoder):
     57        * platform/graphics/gpu/cocoa/GPUComputePassEncoderMetal.mm: Added.
     58        (WebCore::GPUComputePassEncoder::tryCreate):
     59        (WebCore::GPUComputePassEncoder::GPUComputePassEncoder):
     60        (WebCore::GPUComputePassEncoder::setPipeline):
     61        (WebCore::GPUComputePassEncoder::dispatch): Use a default calculation for threadsPerThreadgroup while MSL is still an accepted shader format.
     62        (WebCore::GPUComputePassEncoder::platformPassEncoder const):
     63        (WebCore::GPUComputePassEncoder::useResource):
     64        (WebCore::GPUComputePassEncoder::setComputeBuffer):
     65
     66        Add GPUComputePipeline:
     67        * Modules/webgpu/WebGPUComputePipeline.cpp: Added.
     68        (WebCore::WebGPUComputePipeline::create):
     69        (WebCore::WebGPUComputePipeline::WebGPUComputePipeline):
     70        * Modules/webgpu/WebGPUComputePipeline.h: Added.
     71        (WebCore::WebGPUComputePipeline::computePipeline const):
     72        * Modules/webgpu/WebGPUComputePipeline.idl: Added.
     73        * Modules/webgpu/WebGPUComputePipelineDescriptor.cpp: Added.
     74        (WebCore::WebGPUComputePipelineDescriptor::tryCreateGPUComputePipelineDescriptor const):
     75        * Modules/webgpu/WebGPUComputePipelineDescriptor.h: Added.
     76        * Modules/webgpu/WebGPUComputePipelineDescriptor.idl: Added.
     77        * platform/graphics/gpu/GPUComputePipeline.h: Added.
     78        (WebCore::GPUComputePipeline::platformComputePipeline const):
     79        * platform/graphics/gpu/GPUComputePipelineDescriptor.h: Added.
     80        (WebCore::GPUComputePipelineDescriptor::GPUComputePipelineDescriptor):
     81        * platform/graphics/gpu/cocoa/GPUComputePipelineMetal.mm: Added.
     82        (WebCore::tryCreateMtlComputeFunction):
     83        (WebCore::tryCreateMTLComputePipelineState):
     84        (WebCore::GPUComputePipeline::tryCreate):
     85        (WebCore::GPUComputePipeline::GPUComputePipeline):
     86
     87        Enable creating a GPUComputePipeline from a GPUDevice:
     88        * Modules/webgpu/WebGPUDevice.cpp:
     89        (WebCore::WebGPUDevice::createComputePipeline const):
     90        * Modules/webgpu/WebGPUDevice.h:
     91        * Modules/webgpu/WebGPUDevice.idl:
     92        * platform/graphics/gpu/GPUDevice.cpp:
     93        (WebCore::GPUDevice::tryCreateComputePipeline const):
     94        * platform/graphics/gpu/GPUDevice.h:
     95
     96        No longer unnecessarily ref the WebGPUCommandEncoder when creating pass encoder:
     97        * Modules/webgpu/WebGPUProgrammablePassEncoder.cpp:
     98        (WebCore::WebGPUProgrammablePassEncoder::setBindGroup):
     99        (WebCore::WebGPUProgrammablePassEncoder::WebGPUProgrammablePassEncoder): Deleted.
     100        (WebCore::WebGPUProgrammablePassEncoder::setBindGroup const): Deleted.
     101        * Modules/webgpu/WebGPUProgrammablePassEncoder.h:
     102        * Modules/webgpu/WebGPURenderPassEncoder.cpp:
     103        (WebCore::WebGPURenderPassEncoder::create):
     104        (WebCore::WebGPURenderPassEncoder::WebGPURenderPassEncoder):
     105        (WebCore::WebGPURenderPassEncoder::setPipeline):
     106        (WebCore::WebGPURenderPassEncoder::passEncoder):
     107        (WebCore::WebGPURenderPassEncoder::passEncoder const):
     108        * Modules/webgpu/WebGPURenderPassEncoder.h:
     109
     110        Updates to GPUBindGroup and *setBindGroup for compute function arguments:
     111        * platform/graphics/gpu/GPUBindGroup.h:
     112        (WebCore::GPUBindGroup::vertexArgsBuffer const):
     113        (WebCore::GPUBindGroup::fragmentArgsBuffer const):
     114        (WebCore::GPUBindGroup::computeArgsBuffer const):
     115        (WebCore::GPUBindGroup::vertexArgsBuffer): Deleted. Const-qualified.
     116        (WebCore::GPUBindGroup::fragmentArgsBuffer): Ditto.
     117        * platform/graphics/gpu/cocoa/GPUBindGroupMetal.mm:
     118        (WebCore::tryGetResourceAsMTLSamplerState): Now just returns the MTLSamplerState to reduce reference churning.
     119        (WebCore::GPUBindGroup::tryCreate):
     120        (WebCore::GPUBindGroup::GPUBindGroup):
     121        (WebCore::tryGetResourceAsSampler): Renamed to tryGetResourceAsMTLSamplerState.
     122
     123        Updates to GPUProgrammablePassEncoder and GPURenderPassEncoder:
     124        * platform/graphics/gpu/GPUProgrammablePassEncoder.h:
     125        (WebCore::GPUProgrammablePassEncoder::setVertexBuffer):
     126        (WebCore::GPUProgrammablePassEncoder::setFragmentBuffer):
     127        (WebCore::GPUProgrammablePassEncoder::setComputeBuffer): Added.
     128        * platform/graphics/gpu/GPURenderPassEncoder.h:
     129        (WebCore::GPURenderPassEncoder::~GPURenderPassEncoder):
     130        * platform/graphics/gpu/GPURenderPipeline.h:
     131        * platform/graphics/gpu/cocoa/GPUProgrammablePassEncoderMetal.mm: Remove unecessary include.
     132        (WebCore::GPUProgrammablePassEncoder::endPass): No longer virtual. Delegates shared behavior for derived classes.
     133        (WebCore::GPUProgrammablePassEncoder::setBindGroup):
     134        * platform/graphics/gpu/cocoa/GPURenderPassEncoderMetal.mm:
     135        (WebCore::GPURenderPassEncoder::platformPassEncoder const):
     136        (WebCore::GPURenderPassEncoder::setPipeline):
     137        (WebCore::GPURenderPassEncoder::draw):
     138        (WebCore::GPURenderPassEncoder::useResource): These private overrides are called only by base after checking for encoder existence.
     139        (WebCore::GPURenderPassEncoder::setVertexBuffer): Ditto.
     140        (WebCore::GPURenderPassEncoder::setFragmentBuffer): Ditto.
     141        (WebCore::GPURenderPassEncoder::endPass): Deleted. Now handled by base class.
     142
    11432019-03-23  Simon Fraser  <simon.fraser@apple.com>
    2144

  • trunk/Source/WebCore/DerivedSources-input.xcfilelist

    r243193 r243419  
    368368$(PROJECT_DIR)/Modules/webgpu/WebGPUCommandBuffer.idl
    369369$(PROJECT_DIR)/Modules/webgpu/WebGPUCommandEncoder.idl
     370$(PROJECT_DIR)/Modules/webgpu/WebGPUComputePassEncoder.idl
     371$(PROJECT_DIR)/Modules/webgpu/WebGPUComputePipeline.idl
     372$(PROJECT_DIR)/Modules/webgpu/WebGPUComputePipelineDescriptor.idl
    370373$(PROJECT_DIR)/Modules/webgpu/WebGPUDevice.idl
    371374$(PROJECT_DIR)/Modules/webgpu/WebGPUIndexFormat.idl

  • trunk/Source/WebCore/DerivedSources-output.xcfilelist

    r243193 r243419  
    19301930$(BUILT_PRODUCTS_DIR)/DerivedSources/WebCore/JSWebGPUCommandEncoder.cpp
    19311931$(BUILT_PRODUCTS_DIR)/DerivedSources/WebCore/JSWebGPUCommandEncoder.h
     1932$(BUILT_PRODUCTS_DIR)/DerivedSources/WebCore/JSWebGPUComputePassEncoder.cpp
     1933$(BUILT_PRODUCTS_DIR)/DerivedSources/WebCore/JSWebGPUComputePassEncoder.h
     1934$(BUILT_PRODUCTS_DIR)/DerivedSources/WebCore/JSWebGPUComputePipeline.cpp
     1935$(BUILT_PRODUCTS_DIR)/DerivedSources/WebCore/JSWebGPUComputePipeline.h
     1936$(BUILT_PRODUCTS_DIR)/DerivedSources/WebCore/JSWebGPUComputePipelineDescriptor.cpp
     1937$(BUILT_PRODUCTS_DIR)/DerivedSources/WebCore/JSWebGPUComputePipelineDescriptor.h
    19321938$(BUILT_PRODUCTS_DIR)/DerivedSources/WebCore/JSWebGPUDevice.cpp
    19331939$(BUILT_PRODUCTS_DIR)/DerivedSources/WebCore/JSWebGPUDevice.h

  • trunk/Source/WebCore/DerivedSources.make

    r243229 r243419  
    408408    $(WebCore)/Modules/webgpu/WebGPUCommandBuffer.idl \
    409409    $(WebCore)/Modules/webgpu/WebGPUCommandEncoder.idl \
     410    $(WebCore)/Modules/webgpu/WebGPUComputePassEncoder.idl \
     411    $(WebCore)/Modules/webgpu/WebGPUComputePipeline.idl \
     412    $(WebCore)/Modules/webgpu/WebGPUComputePipelineDescriptor.idl \
    410413    $(WebCore)/Modules/webgpu/WebGPUDevice.idl \
    411414    $(WebCore)/Modules/webgpu/WebGPUQueue.idl \

  • trunk/Source/WebCore/Modules/webgpu/WHLSL/WHLSLNameResolver.h

    r243091 r243419  
    3030#include "WHLSLNameContext.h"
    3131#include "WHLSLVisitor.h"
     32#include <wtf/HashSet.h>
    3233
    3334namespace WebCore {

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

    r242974 r243419  
    2929#if ENABLE(WEBGPU)
    3030
     31#include "GPUComputePassEncoder.h"
    3132#include "GPURenderPassDescriptor.h"
    3233#include "GPURenderPassEncoder.h"
    3334#include "WebGPUBuffer.h"
     35#include "WebGPUComputePassEncoder.h"
    3436#include "WebGPURenderPassDescriptor.h"
    3537#include "WebGPURenderPassEncoder.h"
    … …  
    7779    if (!m_commandBuffer) {
    7880        LOG(WebGPU, "WebGPUCommandEncoder::beginRenderPass(): Invalid operation!");
    79         return WebGPURenderPassEncoder::create(*this, nullptr);
     81        return WebGPURenderPassEncoder::create(nullptr);
    8082    }
    8183    auto gpuDescriptor = descriptor.tryCreateGPURenderPassDescriptor();
    8284    if (!gpuDescriptor)
    83         return WebGPURenderPassEncoder::create(*this, nullptr);
     85        return WebGPURenderPassEncoder::create(nullptr);
    8486
    8587    auto encoder = GPURenderPassEncoder::tryCreate(makeRef(*m_commandBuffer), WTFMove(*gpuDescriptor));
    86     return WebGPURenderPassEncoder::create(*this, WTFMove(encoder));
     88    return WebGPURenderPassEncoder::create(WTFMove(encoder));
     89}
     90
     91Ref<WebGPUComputePassEncoder> WebGPUCommandEncoder::beginComputePass()
     92{
     93    if (!m_commandBuffer) {
     94        LOG(WebGPU, "WebGPUCommandEncoder::beginComputePass(): Invalid operation!");
     95        return WebGPUComputePassEncoder::create(nullptr);
     96    }
     97    auto encoder = GPUComputePassEncoder::tryCreate(makeRef(*m_commandBuffer));
     98    return WebGPUComputePassEncoder::create(WTFMove(encoder));
    8799}
    88100

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

    r242974 r243419  
    3636
    3737class WebGPUBuffer;
     38class WebGPUComputePassEncoder;
    3839class WebGPURenderPassEncoder;
    3940class WebGPUTexture;
    … …  
    5960
    6061    Ref<WebGPURenderPassEncoder> beginRenderPass(WebGPURenderPassDescriptor&&);
     62    Ref<WebGPUComputePassEncoder> beginComputePass();
    6163    void copyBufferToBuffer(const WebGPUBuffer&, unsigned long srcOffset, const WebGPUBuffer&, unsigned long dstOffset, unsigned long size);
    6264    void copyBufferToTexture(const WebGPUBufferCopyView&, const WebGPUTextureCopyView&, const GPUExtent3D&);

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

    r242974 r243419  
    5757] interface WebGPUCommandEncoder {
    5858    WebGPURenderPassEncoder beginRenderPass(WebGPURenderPassDescriptor descriptor);
     59    WebGPUComputePassEncoder beginComputePass();
    5960
    6061    void copyBufferToBuffer(
    … …  
    8182
    8283    WebGPUCommandBuffer finish();
    83 
    84     // Not Yet Implemented
    85     // WebGPUComputePassEncoder beginComputePass();
    8684};

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

    r243418 r243419  
    11/*
    2  * Copyright (C) 2018 Apple Inc. All rights reserved.
     2 * Copyright (C) 2019 Apple Inc. All rights reserved.
    33 *
    44 * Redistribution and use in source and binary forms, with or without
    … …  
    2525
    2626#include "config.h"
    27 #include "WebGPUProgrammablePassEncoder.h"
     27#include "WebGPUComputePassEncoder.h"
    2828
    2929#if ENABLE(WEBGPU)
    3030
     31#include "GPUComputePassEncoder.h"
    3132#include "GPUProgrammablePassEncoder.h"
    32 #include "Logging.h"
    33 #include "WebGPUBindGroup.h"
    34 #include "WebGPURenderPipeline.h"
     33#include "WebGPUComputePipeline.h"
    3534
    3635namespace WebCore {
    3736
    38 WebGPUProgrammablePassEncoder::WebGPUProgrammablePassEncoder(Ref<WebGPUCommandEncoder>&& creator)
    39     : m_commandBuffer(WTFMove(creator))
     37Ref<WebGPUComputePassEncoder> WebGPUComputePassEncoder::create(RefPtr<GPUComputePassEncoder>&& encoder)
     38{
     39    return adoptRef(*new WebGPUComputePassEncoder(WTFMove(encoder)));
     40}
     41
     42WebGPUComputePassEncoder::WebGPUComputePassEncoder(RefPtr<GPUComputePassEncoder>&& encoder)
     43    : m_passEncoder { WTFMove(encoder) }
    4044{
    4145}
    4246
    43 void WebGPUProgrammablePassEncoder::endPass()
     47void WebGPUComputePassEncoder::setPipeline(const WebGPUComputePipeline& pipeline)
    4448{
    45     if (!passEncoder()) {
    46         LOG(WebGPU, "GPUProgrammablePassEncoder::endPass(): Invalid operation!");
     49    if (!m_passEncoder) {
     50        LOG(WebGPU, "GPUComputePassEncoder::setPipeline(): Invalid operation!");
    4751        return;
    4852    }
    49     passEncoder()->endPass();
     53    if (!pipeline.computePipeline()) {
     54        LOG(WebGPU, "GPUComputePassEncoder::setPipeline(): Invalid pipeline!");
     55        return;
     56    }
     57    m_passEncoder->setPipeline(makeRef(*pipeline.computePipeline()));
    5058}
    5159
    52 void WebGPUProgrammablePassEncoder::setBindGroup(unsigned index, WebGPUBindGroup& bindGroup) const
     60void WebGPUComputePassEncoder::dispatch(unsigned x, unsigned y, unsigned z)
    5361{
    54     if (!passEncoder()) {
    55         LOG(WebGPU, "GPUProgrammablePassEncoder::setBindGroup(): Invalid operation!");
     62    if (!m_passEncoder) {
     63        LOG(WebGPU, "GPUComputePassEncoder::dispatch(): Invalid operation!");
    5664        return;
    5765    }
    58     // Maximum number of bind groups supported in Web GPU.
    59     if (index >= 4) {
    60         LOG(WebGPU, "GPUProgrammablePassEncoder::setBindGroup(): Invalid index!");
    61         return;
    62     }
    63     if (!bindGroup.bindGroup()) {
    64         LOG(WebGPU, "GPUProgrammablePassEncoder::setBindGroup(): Invalid WebGPUBindGroup!");
    65         return;
    66     }
    67     // FIXME: Any validation (e.g. index duplicates, not in pipeline layout).
    68     passEncoder()->setBindGroup(index, *bindGroup.bindGroup());
     66
     67    // FIXME: Add Web GPU validation.
     68    m_passEncoder->dispatch(x, y, z);
     69}
     70
     71GPUProgrammablePassEncoder* WebGPUComputePassEncoder::passEncoder()
     72{
     73    return m_passEncoder.get();
     74}
     75
     76const GPUProgrammablePassEncoder* WebGPUComputePassEncoder::passEncoder() const
     77{
     78    return m_passEncoder.get();
    6979}
    7080

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

    r243418 r243419  
    11/*
    2  * Copyright (C) 2018 Apple Inc. All rights reserved.
     2 * Copyright (C) 2019 Apple Inc. All rights reserved.
    33 *
    44 * Redistribution and use in source and binary forms, with or without
    … …  
    2828#if ENABLE(WEBGPU)
    2929
    30 #include "WebGPUCommandEncoder.h"
    31 #include <wtf/RefCounted.h>
     30#include "WebGPUProgrammablePassEncoder.h"
     31#include <wtf/RefPtr.h>
    3232
    3333namespace WebCore {
    3434
     35class GPUComputePassEncoder;
    3536class GPUProgrammablePassEncoder;
    36 class WebGPUBindGroup;
    37 class WebGPURenderPipeline;
     37class WebGPUComputePipeline;
    3838
    39 class WebGPUProgrammablePassEncoder : public RefCounted<WebGPUProgrammablePassEncoder> {
     39class WebGPUComputePassEncoder : public WebGPUProgrammablePassEncoder {
    4040public:
    41     virtual ~WebGPUProgrammablePassEncoder() = default;
     41    static Ref<WebGPUComputePassEncoder> create(RefPtr<GPUComputePassEncoder>&&);
    4242
    43     void endPass();
    44     void setBindGroup(unsigned, WebGPUBindGroup&) const;
    45 
    46 protected:
    47     WebGPUProgrammablePassEncoder(Ref<WebGPUCommandEncoder>&&);
    48 
    49     virtual GPUProgrammablePassEncoder* passEncoder() const = 0;
     43    void setPipeline(const WebGPUComputePipeline&);
     44    void dispatch(unsigned x, unsigned y, unsigned z);
    5045
    5146private:
    52     Ref<WebGPUCommandEncoder> m_commandBuffer;
     47    WebGPUComputePassEncoder(RefPtr<GPUComputePassEncoder>&&);
     48
     49    GPUProgrammablePassEncoder* passEncoder() final;
     50    const GPUProgrammablePassEncoder* passEncoder() const final;
     51
     52    RefPtr<GPUComputePassEncoder> m_passEncoder;
    5353};
    5454

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

    r243418 r243419  
    11/*
    2  * Copyright (C) 2018 Apple Inc. All rights reserved.
     2 * Copyright (C) 2019 Apple Inc. All rights reserved.
    33 *
    44 * Redistribution and use in source and binary forms, with or without
    … …  
    2323 * THE POSSIBILITY OF SUCH DAMAGE.
    2424 */
     25// https://github.com/gpuweb/gpuweb/blob/master/design/sketch.webidl
    2526
    26 #pragma once
     27typedef unsigned long u32;
    2728
    28 #if ENABLE(WEBGPU)
     29[
     30    Conditional=WEBGPU,
     31    EnabledAtRuntime=WebGPU,
     32    InterfaceName=GPUComputePassEncoder,
     33    JSGenerateToJSObject
     34] interface WebGPUComputePassEncoder : WebGPUProgrammablePassEncoder {
     35    void setPipeline(WebGPUComputePipeline pipeline);
     36    void dispatch(u32 x, u32 y, u32 z);
    2937
    30 #include "GPUPipelineLayout.h"
    31 #include "GPUPipelineStageDescriptor.h"
    32 
    33 #include <wtf/Vector.h>
    34 
    35 namespace WebCore {
    36 
    37 struct GPUPipelineDescriptorBase {
    38     RefPtr<GPUPipelineLayout> layout;
     38    // TODO add missing commands
    3939};
    40 
    41 } // namespace WebCore
    42 
    43 #endif // ENABLE(WEBGPU)

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

    r243418 r243419  
    11/*
    2  * Copyright (C) 2018 Apple Inc. All rights reserved.
     2 * Copyright (C) 2019 Apple Inc. All rights reserved.
    33 *
    44 * Redistribution and use in source and binary forms, with or without
    … …  
    2525
    2626#include "config.h"
    27 #include "WebGPURenderPipeline.h"
     27#include "WebGPUComputePipeline.h"
    2828
    2929#if ENABLE(WEBGPU)
    3030
    31 #include "GPURenderPipeline.h"
    32 
    3331namespace WebCore {
    3432
    35 Ref<WebGPURenderPipeline> WebGPURenderPipeline::create(RefPtr<GPURenderPipeline>&& pipeline)
     33Ref<WebGPUComputePipeline> WebGPUComputePipeline::create(RefPtr<GPUComputePipeline>&& pipeline)
    3634{
    37     return adoptRef(*new WebGPURenderPipeline(WTFMove(pipeline)));
     35    return adoptRef(*new WebGPUComputePipeline(WTFMove(pipeline)));
    3836}
    3937
    40 WebGPURenderPipeline::WebGPURenderPipeline(RefPtr<GPURenderPipeline>&& pipeline)
    41     : m_renderPipeline(WTFMove(pipeline))
     38WebGPUComputePipeline::WebGPUComputePipeline(RefPtr<GPUComputePipeline>&& pipeline)
     39    : m_computePipeline { WTFMove(pipeline) }
    4240{
    4341}

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

    r243418 r243419  
    11/*
    2  * Copyright (C) 2018 Apple Inc. All rights reserved.
     2 * Copyright (C) 2019 Apple Inc. All rights reserved.
    33 *
    44 * Redistribution and use in source and binary forms, with or without
    … …  
    2828#if ENABLE(WEBGPU)
    2929
    30 #include "GPURenderPipeline.h"
    31 
     30#include "GPUComputePipeline.h"
    3231#include <wtf/RefCounted.h>
    3332#include <wtf/RefPtr.h>
    … …  
    3534namespace WebCore {
    3635
    37 class WebGPURenderPipeline : public RefCounted<WebGPURenderPipeline> {
     36class WebGPUComputePipeline : public RefCounted<WebGPUComputePipeline> {
    3837public:
    39     static Ref<WebGPURenderPipeline> create(RefPtr<GPURenderPipeline>&&);
     38    static Ref<WebGPUComputePipeline> create(RefPtr<GPUComputePipeline>&&);
    4039
    41     const GPURenderPipeline* renderPipeline() const { return m_renderPipeline.get(); }
     40    const GPUComputePipeline* computePipeline() const { return m_computePipeline.get(); }
    4241
    4342private:
    44     WebGPURenderPipeline(RefPtr<GPURenderPipeline>&&);
     43    WebGPUComputePipeline(RefPtr<GPUComputePipeline>&&);
    4544
    46     RefPtr<GPURenderPipeline> m_renderPipeline;
     45    RefPtr<GPUComputePipeline> m_computePipeline;
    4746};
    4847

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

    r243418 r243419  
    11/*
    2  * Copyright (C) 2018 Apple Inc. All rights reserved.
     2 * Copyright (C) 2019 Apple Inc. All rights reserved.
    33 *
    44 * Redistribution and use in source and binary forms, with or without
    … …  
    2323 * THE POSSIBILITY OF SUCH DAMAGE.
    2424 */
     25// https://github.com/gpuweb/gpuweb/blob/master/design/sketch.webidl
    2526
    26 #pragma once
    27 
    28 #if ENABLE(WEBGPU)
    29 
    30 #include "GPUPipelineLayout.h"
    31 #include "GPUPipelineStageDescriptor.h"
    32 
    33 #include <wtf/Vector.h>
    34 
    35 namespace WebCore {
    36 
    37 struct GPUPipelineDescriptorBase {
    38     RefPtr<GPUPipelineLayout> layout;
     27[
     28    Conditional=WEBGPU,
     29    EnabledAtRuntime=WebGPU,
     30    ImplementationLacksVTable,
     31    InterfaceName=GPUComputePipeline
     32] interface WebGPUComputePipeline {
    3933};
    40 
    41 } // namespace WebCore
    42 
    43 #endif // ENABLE(WEBGPU)

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

    r243418 r243419  
    11/*
    2  * Copyright (C) 2018 Apple Inc. All rights reserved.
     2 * Copyright (C) 2019 Apple Inc. All rights reserved.
    33 *
    44 * Redistribution and use in source and binary forms, with or without
    … …  
    2525
    2626#include "config.h"
    27 #include "WebGPURenderPipeline.h"
     27#include "WebGPUComputePipelineDescriptor.h"
    2828
    2929#if ENABLE(WEBGPU)
    3030
    31 #include "GPURenderPipeline.h"
     31#include "GPUComputePipelineDescriptor.h"
     32#include "Logging.h"
    3233
    3334namespace WebCore {
    3435
    35 Ref<WebGPURenderPipeline> WebGPURenderPipeline::create(RefPtr<GPURenderPipeline>&& pipeline)
     36Optional<GPUComputePipelineDescriptor> WebGPUComputePipelineDescriptor::tryCreateGPUComputePipelineDescriptor() const
    3637{
    37     return adoptRef(*new WebGPURenderPipeline(WTFMove(pipeline)));
    38 }
     38    auto pipelineLayout = layout ? makeRefPtr(layout->pipelineLayout()) : nullptr;
    3939
    40 WebGPURenderPipeline::WebGPURenderPipeline(RefPtr<GPURenderPipeline>&& pipeline)
    41     : m_renderPipeline(WTFMove(pipeline))
    42 {
     40    auto compute = computeStage.tryCreateGPUPipelineStageDescriptor();
     41    if (!compute) {
     42        LOG(WebGPU, "GPUDevice::createComputePipeline(): Invalid GPUPipelineStageDescriptor!");
     43        return WTF::nullopt;
     44    }
     45
     46    return GPUComputePipelineDescriptor { WTFMove(pipelineLayout), WTFMove(*compute) };
    4347}
    4448

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

    r243418 r243419  
    11/*
    2  * Copyright (C) 2018 Apple Inc. All rights reserved.
     2 * Copyright (C) 2019 Apple Inc. All rights reserved.
    33 *
    44 * Redistribution and use in source and binary forms, with or without
    … …  
    2828#if ENABLE(WEBGPU)
    2929
    30 #include "GPUPipelineLayout.h"
    31 #include "GPUPipelineStageDescriptor.h"
    32 
    33 #include <wtf/Vector.h>
     30#include "WebGPUPipelineDescriptorBase.h"
     31#include "WebGPUPipelineStageDescriptor.h"
     32#include <wtf/Optional.h>
    3433
    3534namespace WebCore {
    3635
    37 struct GPUPipelineDescriptorBase {
    38     RefPtr<GPUPipelineLayout> layout;
     36struct GPUComputePipelineDescriptor;
     37
     38struct WebGPUComputePipelineDescriptor : WebGPUPipelineDescriptorBase {
     39    Optional<GPUComputePipelineDescriptor> tryCreateGPUComputePipelineDescriptor() const;
     40
     41    WebGPUPipelineStageDescriptor computeStage;
    3942};
    4043

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

    r243418 r243419  
    11/*
    2  * Copyright (C) 2018 Apple Inc. All rights reserved.
     2 * Copyright (C) 2019 Apple Inc. All rights reserved.
    33 *
    44 * Redistribution and use in source and binary forms, with or without
    … …  
    2323 * THE POSSIBILITY OF SUCH DAMAGE.
    2424 */
     25// https://github.com/gpuweb/gpuweb/blob/master/design/sketch.webidl
    2526
    26 #pragma once
    27 
    28 #if ENABLE(WEBGPU)
    29 
    30 #include "GPUPipelineLayout.h"
    31 #include "GPUPipelineStageDescriptor.h"
    32 
    33 #include <wtf/Vector.h>
    34 
    35 namespace WebCore {
    36 
    37 struct GPUPipelineDescriptorBase {
    38     RefPtr<GPUPipelineLayout> layout;
     27[
     28    Conditional=WEBGPU,
     29    EnabledAtRuntime=WebGPU
     30] dictionary WebGPUComputePipelineDescriptor : WebGPUPipelineDescriptorBase {
     31    required WebGPUPipelineStageDescriptor computeStage;
    3932};
    40 
    41 } // namespace WebCore
    42 
    43 #endif // ENABLE(WEBGPU)

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

    r243091 r243419  
    5050#include "WebGPUBufferBinding.h"
    5151#include "WebGPUCommandEncoder.h"
     52#include "WebGPUComputePipeline.h"
     53#include "WebGPUComputePipelineDescriptor.h"
    5254#include "WebGPUPipelineLayout.h"
    5355#include "WebGPUPipelineLayoutDescriptor.h"
    … …  
    138140}
    139141
     142Ref<WebGPUComputePipeline> WebGPUDevice::createComputePipeline(const WebGPUComputePipelineDescriptor& descriptor) const
     143{
     144    auto gpuDescriptor = descriptor.tryCreateGPUComputePipelineDescriptor();
     145    if (!gpuDescriptor)
     146        return WebGPUComputePipeline::create(nullptr);
     147
     148    auto pipeline = m_device->tryCreateComputePipeline(*gpuDescriptor);
     149    return WebGPUComputePipeline::create(WTFMove(pipeline));
     150}
     151
    140152Ref<WebGPUCommandEncoder> WebGPUDevice::createCommandEncoder() const
    141153{

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

    r243090 r243419  
    4343class WebGPUBuffer;
    4444class WebGPUCommandEncoder;
     45class WebGPUComputePipeline;
    4546class WebGPUPipelineLayout;
    4647class WebGPURenderPipeline;
    … …  
    5556struct GPUTextureDescriptor;
    5657struct WebGPUBindGroupDescriptor;
     58struct WebGPUComputePipelineDescriptor;
    5759struct WebGPUPipelineLayoutDescriptor;
    5860struct WebGPURenderPipelineDescriptor;
    … …  
    7678    RefPtr<WebGPUShaderModule> createShaderModule(WebGPUShaderModuleDescriptor&&) const;
    7779    Ref<WebGPURenderPipeline> createRenderPipeline(const WebGPURenderPipelineDescriptor&) const;
     80    Ref<WebGPUComputePipeline> createComputePipeline(const WebGPUComputePipelineDescriptor&) const;
    7881
    7982    Ref<WebGPUCommandEncoder> createCommandEncoder() const;

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

    r242974 r243419  
    5454    WebGPUShaderModule createShaderModule(WebGPUShaderModuleDescriptor descriptor);
    5555    WebGPURenderPipeline createRenderPipeline(WebGPURenderPipelineDescriptor descriptor);
     56    WebGPUComputePipeline createComputePipeline(WebGPUComputePipelineDescriptor descriptor);
    5657
    5758    // FIXME: Currently, GPUCommandEncoderDescriptor is an empty dictionary.
    … …  
    6667    // readonly attribute WebGPULimits limits;
    6768
    68     // WebGPUComputePipeline createComputePipeline(WebGPUComputePipelineDescriptor descriptor);
    6969    // WebGPUFence createFence(WebGPUFenceDescriptor descriptor);
    7070

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

    r243418 r243419  
    11/*
    2  * Copyright (C) 2018 Apple Inc. All rights reserved.
     2 * Copyright (C) 2019 Apple Inc. All rights reserved.
    33 *
    44 * Redistribution and use in source and binary forms, with or without
    … …  
    2525
    2626#include "config.h"
    27 #include "WebGPURenderPipeline.h"
     27#include "WebGPUPipelineStageDescriptor.h"
    2828
    2929#if ENABLE(WEBGPU)
    3030
    31 #include "GPURenderPipeline.h"
    32 
    3331namespace WebCore {
    3432
    35 Ref<WebGPURenderPipeline> WebGPURenderPipeline::create(RefPtr<GPURenderPipeline>&& pipeline)
     33Optional<GPUPipelineStageDescriptor> WebGPUPipelineStageDescriptor::tryCreateGPUPipelineStageDescriptor() const
    3634{
    37     return adoptRef(*new WebGPURenderPipeline(WTFMove(pipeline)));
    38 }
     35    if (!module || !module->module() || entryPoint.isEmpty())
     36        return WTF::nullopt;
    3937
    40 WebGPURenderPipeline::WebGPURenderPipeline(RefPtr<GPURenderPipeline>&& pipeline)
    41     : m_renderPipeline(WTFMove(pipeline))
    42 {
     38    return GPUPipelineStageDescriptor { makeRef(*module->module()), *this };
    4339}
    4440

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

    r243089 r243419  
    3232#include "Logging.h"
    3333#include "WebGPUBindGroup.h"
    34 #include "WebGPURenderPipeline.h"
    3534
    3635namespace WebCore {
    37 
    38 WebGPUProgrammablePassEncoder::WebGPUProgrammablePassEncoder(Ref<WebGPUCommandEncoder>&& creator)
    39     : m_commandBuffer(WTFMove(creator))
    40 {
    41 }
    4236
    4337void WebGPUProgrammablePassEncoder::endPass()
    … …  
    5044}
    5145
    52 void WebGPUProgrammablePassEncoder::setBindGroup(unsigned index, WebGPUBindGroup& bindGroup) const
     46void WebGPUProgrammablePassEncoder::setBindGroup(unsigned index, WebGPUBindGroup& bindGroup)
    5347{
    5448    if (!passEncoder()) {

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

    r243089 r243419  
    2828#if ENABLE(WEBGPU)
    2929
    30 #include "WebGPUCommandEncoder.h"
    3130#include <wtf/RefCounted.h>
    3231
    … …  
    3534class GPUProgrammablePassEncoder;
    3635class WebGPUBindGroup;
    37 class WebGPURenderPipeline;
    3836
    3937class WebGPUProgrammablePassEncoder : public RefCounted<WebGPUProgrammablePassEncoder> {
    … …  
    4240
    4341    void endPass();
    44     void setBindGroup(unsigned, WebGPUBindGroup&) const;
     42    void setBindGroup(unsigned, WebGPUBindGroup&);
    4543
    4644protected:
    47     WebGPUProgrammablePassEncoder(Ref<WebGPUCommandEncoder>&&);
     45    WebGPUProgrammablePassEncoder() = default;
    4846
    49     virtual GPUProgrammablePassEncoder* passEncoder() const = 0;
    50 
    51 private:
    52     Ref<WebGPUCommandEncoder> m_commandBuffer;
     47    virtual GPUProgrammablePassEncoder* passEncoder() = 0;
     48    virtual const GPUProgrammablePassEncoder* passEncoder() const = 0;
    5349};
    5450

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

    r243089 r243419  
    3434#include "Logging.h"
    3535#include "WebGPUBuffer.h"
     36#include "WebGPURenderPipeline.h"
    3637
    3738namespace WebCore {
    3839
    39 Ref<WebGPURenderPassEncoder> WebGPURenderPassEncoder::create(Ref<WebGPUCommandEncoder>&& commandBuffer, RefPtr<GPURenderPassEncoder>&& encoder)
     40Ref<WebGPURenderPassEncoder> WebGPURenderPassEncoder::create(RefPtr<GPURenderPassEncoder>&& encoder)
    4041{
    41     return adoptRef(*new WebGPURenderPassEncoder(WTFMove(commandBuffer), WTFMove(encoder)));
     42    return adoptRef(*new WebGPURenderPassEncoder(WTFMove(encoder)));
    4243}
    4344
    44 WebGPURenderPassEncoder::WebGPURenderPassEncoder(Ref<WebGPUCommandEncoder>&& creator, RefPtr<GPURenderPassEncoder>&& encoder)
    45     : WebGPUProgrammablePassEncoder(WTFMove(creator))
    46     , m_passEncoder(WTFMove(encoder))
     45WebGPURenderPassEncoder::WebGPURenderPassEncoder(RefPtr<GPURenderPassEncoder>&& encoder)
     46    : m_passEncoder { WTFMove(encoder) }
    4747{
    4848}
    … …  
    5151{
    5252    if (!m_passEncoder) {
    53         LOG(WebGPU, "GPUProgrammablePassEncoder::setPipeline(): Invalid operation!");
     53        LOG(WebGPU, "GPURenderPassEncoder::setPipeline(): Invalid operation!");
    5454        return;
    5555    }
    5656    if (!pipeline.renderPipeline()) {
    57         LOG(WebGPU, "GPUProgrammablePassEncoder::setPipeline(): Invalid pipeline!");
     57        LOG(WebGPU, "GPURenderPassEncoder::setPipeline(): Invalid pipeline!");
    5858        return;
    5959    }
    … …  
    109109}
    110110
    111 GPUProgrammablePassEncoder* WebGPURenderPassEncoder::passEncoder() const
     111GPUProgrammablePassEncoder* WebGPURenderPassEncoder::passEncoder()
     112{
     113    return m_passEncoder.get();
     114}
     115
     116const GPUProgrammablePassEncoder* WebGPURenderPassEncoder::passEncoder() const
    112117{
    113118    return m_passEncoder.get();

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

    r243089 r243419  
    2929
    3030#include "WebGPUProgrammablePassEncoder.h"
    31 
    3231#include <wtf/RefPtr.h>
    3332#include <wtf/Vector.h>
    … …  
    3837class GPURenderPassEncoder;
    3938class WebGPUBuffer;
     39class WebGPURenderPipeline;
    4040
    4141class WebGPURenderPassEncoder final : public WebGPUProgrammablePassEncoder {
    4242public:
    43     static Ref<WebGPURenderPassEncoder> create(Ref<WebGPUCommandEncoder>&&, RefPtr<GPURenderPassEncoder>&&);
     43    static Ref<WebGPURenderPassEncoder> create(RefPtr<GPURenderPassEncoder>&&);
    4444
    4545    void setPipeline(const WebGPURenderPipeline&);
    … …  
    4848
    4949private:
    50     WebGPURenderPassEncoder(Ref<WebGPUCommandEncoder>&&, RefPtr<GPURenderPassEncoder>&&);
     50    WebGPURenderPassEncoder(RefPtr<GPURenderPassEncoder>&&);
    5151
    52     GPUProgrammablePassEncoder* passEncoder() const final;
     52    GPUProgrammablePassEncoder* passEncoder() final;
     53    const GPUProgrammablePassEncoder* passEncoder() const final;
    5354
    5455    RefPtr<GPURenderPassEncoder> m_passEncoder;

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

    r242839 r243419  
    2929#if ENABLE(WEBGPU)
    3030
    31 #include "GPURenderPipeline.h"
    32 
    3331namespace WebCore {
    3432

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

    r242839 r243419  
    2929
    3030#include "GPURenderPipeline.h"
    31 
    3231#include <wtf/RefCounted.h>
    3332#include <wtf/RefPtr.h>

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

    r242839 r243419  
    2929#if ENABLE(WEBGPU)
    3030
     31#include "Logging.h"
     32
    3133namespace WebCore {
    32 
    33 Optional<GPUPipelineStageDescriptor> WebGPUPipelineStageDescriptor::tryCreateGPUPipelineStageDescriptor() const
    34 {
    35     if (!module || !module->module() || entryPoint.isEmpty())
    36         return WTF::nullopt;
    37 
    38     return GPUPipelineStageDescriptor { makeRef(*module->module()), *this };
    39 }
    4034
    4135Optional<GPURenderPipelineDescriptor> WebGPURenderPipelineDescriptor::tryCreateGPURenderPipelineDescriptor() const

  • trunk/Source/WebCore/Sources.txt

    r243362 r243419  
    351351Modules/webgpu/WHLSL/WHLSLPrepare.cpp
    352352Modules/webgpu/WebGPU.cpp
     353Modules/webgpu/WebGPUAdapter.cpp
    353354Modules/webgpu/WebGPUBindGroup.cpp
    354355Modules/webgpu/WebGPUBindGroupDescriptor.cpp
     356Modules/webgpu/WebGPUBindGroupLayout.cpp
     357Modules/webgpu/WebGPUBuffer.cpp
    355358Modules/webgpu/WebGPUCommandBuffer.cpp
    356359Modules/webgpu/WebGPUCommandEncoder.cpp
    357 Modules/webgpu/WebGPUAdapter.cpp
    358 Modules/webgpu/WebGPUBindGroupLayout.cpp
    359 Modules/webgpu/WebGPUBuffer.cpp
     360Modules/webgpu/WebGPUComputePassEncoder.cpp
     361Modules/webgpu/WebGPUComputePipeline.cpp
     362Modules/webgpu/WebGPUComputePipelineDescriptor.cpp
    360363Modules/webgpu/WebGPUDevice.cpp
    361364Modules/webgpu/WebGPUQueue.cpp
    362365Modules/webgpu/WebGPUPipelineLayout.cpp
     366Modules/webgpu/WebGPUPipelineStageDescriptor.cpp
    363367Modules/webgpu/WebGPUProgrammablePassEncoder.cpp
    364368Modules/webgpu/WebGPURenderPassDescriptor.cpp
    … …  
    33363340JSWebGPUCommandBuffer.cpp
    33373341JSWebGPUCommandEncoder.cpp
     3342JSWebGPUComputePassEncoder.cpp
     3343JSWebGPUComputePipeline.cpp
     3344JSWebGPUComputePipelineDescriptor.cpp
    33383345JSWebGPUDevice.cpp
    33393346JSWebGPUQueue.cpp

  • trunk/Source/WebCore/SourcesCocoa.txt

    r243109 r243419  
    323323platform/graphics/gpu/cocoa/GPUBufferMetal.mm
    324324platform/graphics/gpu/cocoa/GPUCommandBufferMetal.mm
     325platform/graphics/gpu/cocoa/GPUComputePassEncoderMetal.mm
     326platform/graphics/gpu/cocoa/GPUComputePipelineMetal.mm
    325327platform/graphics/gpu/cocoa/GPUDeviceMetal.mm
    326328platform/graphics/gpu/cocoa/GPUProgrammablePassEncoderMetal.mm

  • trunk/Source/WebCore/WebCore.xcodeproj/project.pbxproj

    r243362 r243419  
    1400614006                D003288721C9A4E500622AA6 /* GPUPipelineLayout.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; path = GPUPipelineLayout.cpp; sourceTree = "<group>"; };
    1400714007                D003914122248D400098998C /* GPUProgrammablePassEncoder.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; path = GPUProgrammablePassEncoder.cpp; sourceTree = "<group>"; };
     14008                D00D77FD2242ED450043F12C /* WebGPUComputePassEncoder.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = WebGPUComputePassEncoder.h; sourceTree = "<group>"; };
     14009                D00D77FE2242ED450043F12C /* WebGPUComputePassEncoder.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; path = WebGPUComputePassEncoder.cpp; sourceTree = "<group>"; };
     14010                D00D77FF2242ED450043F12C /* WebGPUComputePassEncoder.idl */ = {isa = PBXFileReference; lastKnownFileType = text; path = WebGPUComputePassEncoder.idl; sourceTree = "<group>"; };
    1400814011                D00F5940216ECC7A000D71DB /* DOMWindowWebGPU.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = DOMWindowWebGPU.h; sourceTree = "<group>"; };
    1400914012                D00F5941216ECC7A000D71DB /* DOMWindowWebGPU.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; path = DOMWindowWebGPU.cpp; sourceTree = "<group>"; };
    … …  
    1414514148                D087CE3F21ACA94200BDE174 /* GPUTextureMetal.mm */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.objcpp; path = GPUTextureMetal.mm; sourceTree = "<group>"; };
    1414614149                D087CE4021ACA94200BDE174 /* GPUShaderModuleMetal.mm */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.objcpp; path = GPUShaderModuleMetal.mm; sourceTree = "<group>"; };
     14150                D08903342240601D00F3F440 /* WebGPUComputePipelineDescriptor.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = WebGPUComputePipelineDescriptor.h; sourceTree = "<group>"; };
     14151                D08903352240601D00F3F440 /* WebGPUComputePipelineDescriptor.idl */ = {isa = PBXFileReference; lastKnownFileType = text; path = WebGPUComputePipelineDescriptor.idl; sourceTree = "<group>"; };
     14152                D0890337224061AC00F3F440 /* WebGPUPipelineStageDescriptor.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; path = WebGPUPipelineStageDescriptor.cpp; sourceTree = "<group>"; };
     14153                D08903382240628900F3F440 /* WebGPUComputePipelineDescriptor.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; path = WebGPUComputePipelineDescriptor.cpp; sourceTree = "<group>"; };
     14154                D08903392240642D00F3F440 /* GPUComputePipelineDescriptor.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = GPUComputePipelineDescriptor.h; sourceTree = "<group>"; };
     14155                D089033A224179B500F3F440 /* GPUComputePipeline.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = GPUComputePipeline.h; sourceTree = "<group>"; };
     14156                D089033B224179B500F3F440 /* GPUComputePipelineMetal.mm */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.objcpp; path = GPUComputePipelineMetal.mm; sourceTree = "<group>"; };
     14157                D089033C2241A99F00F3F440 /* WebGPUComputePipeline.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = WebGPUComputePipeline.h; sourceTree = "<group>"; };
     14158                D089033D2241A99F00F3F440 /* WebGPUComputePipeline.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; path = WebGPUComputePipeline.cpp; sourceTree = "<group>"; };
     14159                D089033E2241A99F00F3F440 /* WebGPUComputePipeline.idl */ = {isa = PBXFileReference; lastKnownFileType = text; path = WebGPUComputePipeline.idl; sourceTree = "<group>"; };
     14160                D089033F2241CE4600F3F440 /* GPUComputePassEncoder.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = GPUComputePassEncoder.h; sourceTree = "<group>"; };
     14161                D08903402241CE4600F3F440 /* GPUComputePassEncoderMetal.mm */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.objcpp; path = GPUComputePassEncoderMetal.mm; sourceTree = "<group>"; };
    1414714162                D08AA02D220D0B9C0058C502 /* GPULoadOp.idl */ = {isa = PBXFileReference; lastKnownFileType = text; path = GPULoadOp.idl; sourceTree = "<group>"; };
    1414814163                D08AA02F220D0BD50058C502 /* GPULoadOp.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = GPULoadOp.h; sourceTree = "<group>"; };
    … …  
    1859018605                                312FF8BD21A4C2F100EB199D /* GPUCommandBuffer.h */,
    1859118606                                D03C849C21FFC7FC0002227F /* GPUCompareFunction.h */,
     18607                                D089033F2241CE4600F3F440 /* GPUComputePassEncoder.h */,
     18608                                D089033A224179B500F3F440 /* GPUComputePipeline.h */,
     18609                                D08903392240642D00F3F440 /* GPUComputePipelineDescriptor.h */,
    1859218610                                D03C849A21FFC6670002227F /* GPUDepthStencilStateDescriptor.h */,
    1859318611                                312FF8BF21A4C2F100EB199D /* GPUDevice.cpp */,
    … …  
    2624126259                                D0EACF7621937228000FA75C /* WebGPUCommandEncoder.h */,
    2624226260                                D0EACF7821937228000FA75C /* WebGPUCommandEncoder.idl */,
     26261                                D00D77FE2242ED450043F12C /* WebGPUComputePassEncoder.cpp */,
     26262                                D00D77FD2242ED450043F12C /* WebGPUComputePassEncoder.h */,
     26263                                D00D77FF2242ED450043F12C /* WebGPUComputePassEncoder.idl */,
     26264                                D089033D2241A99F00F3F440 /* WebGPUComputePipeline.cpp */,
     26265                                D089033C2241A99F00F3F440 /* WebGPUComputePipeline.h */,
     26266                                D089033E2241A99F00F3F440 /* WebGPUComputePipeline.idl */,
     26267                                D08903382240628900F3F440 /* WebGPUComputePipelineDescriptor.cpp */,
     26268                                D08903342240601D00F3F440 /* WebGPUComputePipelineDescriptor.h */,
     26269                                D08903352240601D00F3F440 /* WebGPUComputePipelineDescriptor.idl */,
    2624326270                                D00F595321701D8C000D71DB /* WebGPUDevice.cpp */,
    2624426271                                D00F595221701D8C000D71DB /* WebGPUDevice.h */,
    … …  
    2625226279                                D05A99E121C9B50F00032B75 /* WebGPUPipelineLayoutDescriptor.h */,
    2625326280                                D05A99E221C9B50F00032B75 /* WebGPUPipelineLayoutDescriptor.idl */,
     26281                                D0890337224061AC00F3F440 /* WebGPUPipelineStageDescriptor.cpp */,
    2625426282                                D0C419EB2183CFA2009EC1DE /* WebGPUPipelineStageDescriptor.h */,
    2625526283                                D0C419EC2183CFA2009EC1DE /* WebGPUPipelineStageDescriptor.idl */,
    … …  
    2630126329                                D0D8649121B760C4003C983C /* GPUBufferMetal.mm */,
    2630226330                                D087CE3821ACA94200BDE174 /* GPUCommandBufferMetal.mm */,
     26331                                D08903402241CE4600F3F440 /* GPUComputePassEncoderMetal.mm */,
     26332                                D089033B224179B500F3F440 /* GPUComputePipelineMetal.mm */,
    2630326333                                D087CE3C21ACA94200BDE174 /* GPUDeviceMetal.mm */,
    2630426334                                D087CE3B21ACA94200BDE174 /* GPUProgrammablePassEncoderMetal.mm */,

  • trunk/Source/WebCore/bindings/js/WebCoreBuiltinNames.h

    r242974 r243419  
    8787    macro(GPUCommandBuffer) \
    8888    macro(GPUCommandEncoder) \
     89    macro(GPUComputePassEncoder) \
     90    macro(GPUComputePipeline) \
    8991    macro(GPUShaderStageBit) \
    9092    macro(GPUSwapChain) \

  • trunk/Source/WebCore/platform/cocoa/VideoFullscreenModel.h

    r243298 r243419  
    3535#include "PlaybackSessionModel.h"
    3636#include <wtf/CompletionHandler.h>
     37#include <wtf/WeakPtr.h>
    3738
    3839#if PLATFORM(IOS_FAMILY)

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

    r243006 r243419  
    2828#if ENABLE(WEBGPU)
    2929
     30#include "GPUBuffer.h"
     31#include "GPUTexture.h"
    3032#include <wtf/RefCounted.h>
    3133#include <wtf/RefPtr.h>
    3234#include <wtf/RetainPtr.h>
    3335#include <wtf/Vector.h>
    34 #include "GPUBuffer.h"
    35 #include "GPUTexture.h"
    3636
    3737OBJC_PROTOCOL(MTLBuffer);
    … …  
    4646   
    4747#if USE(METAL)
    48     MTLBuffer *vertexArgsBuffer() { return m_vertexArgsBuffer.get(); }
    49     MTLBuffer *fragmentArgsBuffer() { return m_fragmentArgsBuffer.get(); }
     48    const MTLBuffer *vertexArgsBuffer() const { return m_vertexArgsBuffer.get(); }
     49    const MTLBuffer *fragmentArgsBuffer() const { return m_fragmentArgsBuffer.get(); }
     50    const MTLBuffer *computeArgsBuffer() const { return m_computeArgsBuffer.get(); }
    5051#endif
    5152    const Vector<Ref<GPUBuffer>>& boundBuffers() const { return m_boundBuffers; }
    … …  
    5455private:
    5556#if USE(METAL)
    56     GPUBindGroup(RetainPtr<MTLBuffer>&& vertexBuffer, RetainPtr<MTLBuffer>&& fragmentBuffer, Vector<Ref<GPUBuffer>>&&, Vector<Ref<GPUTexture>>&&);
     57    GPUBindGroup(RetainPtr<MTLBuffer>&& vertexBuffer, RetainPtr<MTLBuffer>&& fragmentBuffer, RetainPtr<MTLBuffer>&& computeArgsBuffer, Vector<Ref<GPUBuffer>>&&, Vector<Ref<GPUTexture>>&&);
    5758   
    5859    RetainPtr<MTLBuffer> m_vertexArgsBuffer;
    5960    RetainPtr<MTLBuffer> m_fragmentArgsBuffer;
     61    RetainPtr<MTLBuffer> m_computeArgsBuffer;
    6062#endif
    6163    Vector<Ref<GPUBuffer>> m_boundBuffers;

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

    r243418 r243419  
    2828#if ENABLE(WEBGPU)
    2929
     30#include "GPUComputePipeline.h"
     31#include "GPUProgrammablePassEncoder.h"
    3032#include <wtf/RefCounted.h>
    3133#include <wtf/RefPtr.h>
    3234#include <wtf/RetainPtr.h>
    33 #include <wtf/Vector.h>
    34 #include "GPUBuffer.h"
    35 #include "GPUTexture.h"
    3635
    37 OBJC_PROTOCOL(MTLBuffer);
     36OBJC_PROTOCOL(MTLComputeCommandEncoder);
    3837
    3938namespace WebCore {
    4039
    41 struct GPUBindGroupDescriptor;
     40using PlatformComputePassEncoder = MTLComputeCommandEncoder;
     41using PlatformComputePassEncoderSmartPtr = RetainPtr<MTLComputeCommandEncoder>;
    4242
    43 class GPUBindGroup : public RefCounted<GPUBindGroup> {
     43class GPUComputePassEncoder : public GPUProgrammablePassEncoder {
    4444public:
    45     static RefPtr<GPUBindGroup> tryCreate(const GPUBindGroupDescriptor&);
    46    
    47 #if USE(METAL)
    48     MTLBuffer *vertexArgsBuffer() { return m_vertexArgsBuffer.get(); }
    49     MTLBuffer *fragmentArgsBuffer() { return m_fragmentArgsBuffer.get(); }
    50 #endif
    51     const Vector<Ref<GPUBuffer>>& boundBuffers() const { return m_boundBuffers; }
    52     const Vector<Ref<GPUTexture>>& boundTextures() const { return m_boundTextures; }
     45    static RefPtr<GPUComputePassEncoder> tryCreate(Ref<GPUCommandBuffer>&&);
     46
     47    void setPipeline(Ref<const GPUComputePipeline>&&);
     48    void dispatch(unsigned x, unsigned y, unsigned z);
    5349
    5450private:
     51    GPUComputePassEncoder(Ref<GPUCommandBuffer>&&, PlatformComputePassEncoderSmartPtr&&);
     52    ~GPUComputePassEncoder() { endPass(); }
     53
     54    // GPUProgrammablePassEncoder
     55    const PlatformProgrammablePassEncoder* platformPassEncoder() const final;
     56    void invalidateEncoder() final { m_platformComputePassEncoder = nullptr; }
    5557#if USE(METAL)
    56     GPUBindGroup(RetainPtr<MTLBuffer>&& vertexBuffer, RetainPtr<MTLBuffer>&& fragmentBuffer, Vector<Ref<GPUBuffer>>&&, Vector<Ref<GPUTexture>>&&);
    57    
    58     RetainPtr<MTLBuffer> m_vertexArgsBuffer;
    59     RetainPtr<MTLBuffer> m_fragmentArgsBuffer;
     58    void useResource(const MTLResource *, unsigned usage) final;
     59    void setComputeBuffer(const MTLBuffer *, unsigned offset, unsigned index) final;
    6060#endif
    61     Vector<Ref<GPUBuffer>> m_boundBuffers;
    62     Vector<Ref<GPUTexture>> m_boundTextures;
     61
     62    PlatformComputePassEncoderSmartPtr m_platformComputePassEncoder;
     63    RefPtr<const GPUComputePipeline> m_pipeline;
    6364};
    6465

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

    r243418 r243419  
    11/*
    2  * Copyright (C) 2018 Apple Inc. All rights reserved.
     2 * Copyright (C) 2019 Apple Inc. All rights reserved.
    33 *
    44 * Redistribution and use in source and binary forms, with or without
    … …  
    2828#if ENABLE(WEBGPU)
    2929
    30 #include "GPURenderPipeline.h"
    31 
    3230#include <wtf/RefCounted.h>
    3331#include <wtf/RefPtr.h>
     32#include <wtf/RetainPtr.h>
     33
     34OBJC_PROTOCOL(MTLComputePipelineState);
    3435
    3536namespace WebCore {
    3637
    37 class WebGPURenderPipeline : public RefCounted<WebGPURenderPipeline> {
     38class GPUDevice;
     39
     40struct GPUComputePipelineDescriptor;
     41
     42using PlatformComputePipeline = MTLComputePipelineState;
     43using PlatformComputePipelineSmartPtr = RetainPtr<MTLComputePipelineState>;
     44
     45class GPUComputePipeline : public RefCounted<GPUComputePipeline> {
    3846public:
    39     static Ref<WebGPURenderPipeline> create(RefPtr<GPURenderPipeline>&&);
     47    static RefPtr<GPUComputePipeline> tryCreate(const GPUDevice&, const GPUComputePipelineDescriptor&);
    4048
    41     const GPURenderPipeline* renderPipeline() const { return m_renderPipeline.get(); }
     49    const PlatformComputePipeline* platformComputePipeline() const { return m_platformComputePipeline.get(); }
    4250
    4351private:
    44     WebGPURenderPipeline(RefPtr<GPURenderPipeline>&&);
     52    GPUComputePipeline(PlatformComputePipelineSmartPtr&&);
    4553
    46     RefPtr<GPURenderPipeline> m_renderPipeline;
     54    PlatformComputePipelineSmartPtr m_platformComputePipeline;
    4755};
    4856

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

    r243418 r243419  
    11/*
    2  * Copyright (C) 2018 Apple Inc. All rights reserved.
     2 * Copyright (C) 2019 Apple Inc. All rights reserved.
    33 *
    44 * Redistribution and use in source and binary forms, with or without
    … …  
    2828#if ENABLE(WEBGPU)
    2929
    30 #include "GPUPipelineLayout.h"
     30#include "GPUPipelineDescriptorBase.h"
    3131#include "GPUPipelineStageDescriptor.h"
    32 
    33 #include <wtf/Vector.h>
    3432
    3533namespace WebCore {
    3634
    37 struct GPUPipelineDescriptorBase {
    38     RefPtr<GPUPipelineLayout> layout;
     35struct GPUComputePipelineDescriptor : GPUPipelineDescriptorBase {
     36    GPUComputePipelineDescriptor(RefPtr<GPUPipelineLayout>&& layout, GPUPipelineStageDescriptor&& compute)
     37        : GPUPipelineDescriptorBase { WTFMove(layout) }
     38        , computeStage { WTFMove(compute) }
     39    {
     40    }
     41
     42    GPUPipelineStageDescriptor computeStage;
    3943};
    4044

  • trunk/Source/WebCore/platform/graphics/gpu/GPUDevice.cpp

    r242974 r243419  
    3434#include "GPUBufferDescriptor.h"
    3535#include "GPUCommandBuffer.h"
     36#include "GPUComputePipeline.h"
     37#include "GPUComputePipelineDescriptor.h"
    3638#include "GPUPipelineLayout.h"
    3739#include "GPUPipelineLayoutDescriptor.h"
    … …  
    4345#include "GPUShaderModuleDescriptor.h"
    4446#include "GPUSwapChain.h"
     47#include "GPUSwapChainDescriptor.h"
    4548#include "GPUTexture.h"
    4649#include "GPUTextureDescriptor.h"
    … …  
    8487}
    8588
     89RefPtr<GPUComputePipeline> GPUDevice::tryCreateComputePipeline(const GPUComputePipelineDescriptor& descriptor) const
     90{
     91    return GPUComputePipeline::tryCreate(*this, descriptor);
     92}
     93
    8694RefPtr<GPUCommandBuffer> GPUDevice::tryCreateCommandBuffer() const
    8795{

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

    r243090 r243419  
    2929
    3030#include "GPUQueue.h"
    31 #include "GPUSwapChainDescriptor.h"
    3231#include <wtf/RefCounted.h>
    3332#include <wtf/RetainPtr.h>
    … …  
    4140class GPUBuffer;
    4241class GPUCommandBuffer;
     42class GPUComputePipeline;
    4343class GPUPipelineLayout;
    4444class GPURenderPipeline;
    … …  
    5050struct GPUBindGroupLayoutDescriptor;
    5151struct GPUBufferDescriptor;
     52struct GPUComputePipelineDescriptor;
    5253struct GPUPipelineLayoutDescriptor;
    5354struct GPURenderPipelineDescriptor;
    … …  
    5556struct GPUSamplerDescriptor;
    5657struct GPUShaderModuleDescriptor;
     58struct GPUSwapChainDescriptor;
    5759struct GPUTextureDescriptor;
    5860   
    … …  
    7375    RefPtr<GPUShaderModule> createShaderModule(GPUShaderModuleDescriptor&&) const;
    7476    RefPtr<GPURenderPipeline> createRenderPipeline(GPURenderPipelineDescriptor&&) const;
     77    RefPtr<GPUComputePipeline> tryCreateComputePipeline(const GPUComputePipelineDescriptor&) const;
    7578
    7679    RefPtr<GPUCommandBuffer> tryCreateCommandBuffer() const;

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

    r239744 r243419  
    3030#include "GPUPipelineLayout.h"
    3131#include "GPUPipelineStageDescriptor.h"
    32 
     32#include <wtf/RefPtr.h>
    3333#include <wtf/Vector.h>
    3434

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

    r243089 r243419  
    2929
    3030#include "GPUBindGroupBinding.h"
     31#include "GPUCommandBuffer.h"
    3132#include <wtf/RefCounted.h>
    3233
    … …  
    4041
    4142class GPUBindGroup;
    42 class GPUCommandBuffer;
    4343class GPURenderPipeline;
    4444
    … …  
    4949    virtual ~GPUProgrammablePassEncoder() = default;
    5050
    51     virtual void endPass();
     51    void endPass();
    5252    void setBindGroup(unsigned, GPUBindGroup&);
    5353
    … …  
    5656
    5757    GPUCommandBuffer& commandBuffer() const { return m_commandBuffer.get(); }
    58     virtual PlatformProgrammablePassEncoder* platformPassEncoder() const = 0;
     58    virtual const PlatformProgrammablePassEncoder* platformPassEncoder() const = 0;
    5959
    6060private:
     61    virtual void invalidateEncoder() = 0;
    6162#if USE(METAL)
    62     virtual void useResource(MTLResource *, unsigned) = 0;
     63    virtual void useResource(const MTLResource *, unsigned) = 0;
    6364
    6465    // Render command encoder methods.
    65     virtual void setVertexBuffer(MTLBuffer *, unsigned, unsigned) { }
    66     virtual void setFragmentBuffer(MTLBuffer *, unsigned, unsigned) { }
     66    virtual void setVertexBuffer(const MTLBuffer *, unsigned, unsigned) { }
     67    virtual void setFragmentBuffer(const MTLBuffer *, unsigned, unsigned) { }
     68    // Compute.
     69    virtual void setComputeBuffer(const MTLBuffer *, unsigned, unsigned) { }
    6770#endif // USE(METAL)
    6871

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

    r243089 r243419  
    5252    static RefPtr<GPURenderPassEncoder> tryCreate(Ref<GPUCommandBuffer>&&, GPURenderPassDescriptor&&);
    5353
    54     void endPass() final;
    5554    void setPipeline(Ref<const GPURenderPipeline>&&);
    56 
    5755    void setVertexBuffers(unsigned long, Vector<Ref<GPUBuffer>>&&, Vector<unsigned long long>&&);
    5856    void draw(unsigned long vertexCount, unsigned long instanceCount, unsigned long firstVertex, unsigned long firstInstance);
    … …  
    6058private:
    6159    GPURenderPassEncoder(Ref<GPUCommandBuffer>&&, PlatformRenderPassEncoderSmartPtr&&);
    62     ~GPURenderPassEncoder() { endPass(); } // Ensure that encoding has ended before release.
     60    ~GPURenderPassEncoder() { endPass(); }
    6361
    64     PlatformProgrammablePassEncoder* platformPassEncoder() const final;
    65 
     62    // GPUProgrammablePassEncoder
     63    const PlatformProgrammablePassEncoder* platformPassEncoder() const final;
     64    void invalidateEncoder() final { m_platformRenderPassEncoder = nullptr; }
    6665#if USE(METAL)
    67     // GPUProgrammablePassEncoder
    68     void useResource(MTLResource *, unsigned usage) final;
    69     void setVertexBuffer(MTLBuffer *, unsigned offset, unsigned index) final;
    70     void setFragmentBuffer(MTLBuffer *, unsigned offset, unsigned index) final;
     66    void useResource(const MTLResource *, unsigned usage) final;
     67    void setVertexBuffer(const MTLBuffer *, unsigned offset, unsigned index) final;
     68    void setFragmentBuffer(const MTLBuffer *, unsigned offset, unsigned index) final;
    7169#endif // USE(METAL)
    7270

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

    r242839 r243419  
    6262#endif // USE(METAL)
    6363    PlatformRenderPipelineSmartPtr m_platformRenderPipeline;
    64     RefPtr<GPUPipelineLayout> m_layout;
    6564    GPUPrimitiveTopology m_primitiveTopology;
    6665};

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

    r243048 r243419  
    3232#import "GPUBindGroupDescriptor.h"
    3333#import "GPUBindGroupLayout.h"
    34 #import "GPUBuffer.h"
    3534#import "GPUSampler.h"
    36 #import "GPUTexture.h"
    3735#import "Logging.h"
    3836#import <Metal/Metal.h>
    … …  
    7876}
    7977   
    80 static RefPtr<GPUSampler> tryGetResourceAsSampler(const GPUBindingResource& resource, const char* const functionName)
     78static MTLSamplerState *tryGetResourceAsMTLSamplerState(const GPUBindingResource& resource, const char* const functionName)
    8179{
    8280#if LOG_DISABLED
    … …  
    8785        return nullptr;
    8886    }
    89     auto& samplerRef = WTF::get<Ref<GPUSampler>>(resource);
    90     if (!samplerRef->platformSampler()) {
     87    auto samplerState = WTF::get<Ref<GPUSampler>>(resource)->platformSampler();
     88    if (!samplerState)
    9189        LOG(WebGPU, "%s: Invalid MTLSamplerState in GPUSampler binding!", functionName);
    92         return nullptr;
    93     }
    94     return samplerRef.copyRef();
     90
     91    return samplerState;
    9592}
    9693
    … …  
    136133    MTLArgumentEncoder *vertexEncoder = descriptor.layout->vertexEncoder();
    137134    MTLArgumentEncoder *fragmentEncoder = descriptor.layout->fragmentEncoder();
    138     // FIXME: Finish support for compute.
     135    MTLArgumentEncoder *computeEncoder = descriptor.layout->computeEncoder();
    139136   
    140137    RetainPtr<MTLBuffer> vertexArgsBuffer;
    … …  
    148145        return nullptr;
    149146    }
     147    RetainPtr<MTLBuffer> computeArgsBuffer;
     148    if (computeEncoder && !(computeArgsBuffer = tryCreateArgumentBuffer(computeEncoder))) {
     149        LOG(WebGPU, "%s: Unable to create MTLBuffer for compute argument buffer!", functionName);
     150        return nullptr;
     151    }
    150152   
    151153    Vector<Ref<GPUBuffer>> boundBuffers;
    … …  
    155157    const auto& layoutBindingsMap = descriptor.layout->bindingsMap();
    156158    for (const auto& resourceBinding : descriptor.bindings) {
    157         auto layoutIterator = layoutBindingsMap.find(resourceBinding.binding);
     159        auto index = resourceBinding.binding;
     160        auto layoutIterator = layoutBindingsMap.find(index);
    158161        if (layoutIterator == layoutBindingsMap.end()) {
    159             LOG(WebGPU, "%s: GPUBindGroupBinding %lu not found in GPUBindGroupLayout!", functionName, resourceBinding.binding);
     162            LOG(WebGPU, "%s: GPUBindGroupBinding %lu not found in GPUBindGroupLayout!", functionName, index);
    160163            return nullptr;
    161164        }
    … …  
    163166        if (layoutBinding.visibility == GPUShaderStageBit::Flags::None)
    164167            continue;
    165         if ((layoutBinding.visibility & GPUShaderStageBit::Flags::Vertex) && !vertexEncoder) {
    166             LOG(WebGPU, "%s: No vertex encoder found for binding %lu!", functionName, resourceBinding.binding);
    167             return nullptr;
    168         }
    169         if ((layoutBinding.visibility & GPUShaderStageBit::Flags::Fragment) && !fragmentEncoder) {
    170             LOG(WebGPU, "%s: No fragment encoder found for binding %lu!", functionName, resourceBinding.binding);
    171             return nullptr;
    172         }
    173        
     168
     169        bool isForVertex = layoutBinding.visibility & GPUShaderStageBit::Flags::Vertex;
     170        bool isForFragment = layoutBinding.visibility & GPUShaderStageBit::Flags::Fragment;
     171        bool isForCompute = layoutBinding.visibility & GPUShaderStageBit::Flags::Compute;
     172
     173        if (isForVertex && !vertexEncoder) {
     174            LOG(WebGPU, "%s: No vertex argument encoder found for binding %lu!", functionName, index);
     175            return nullptr;
     176        }
     177        if (isForFragment && !fragmentEncoder) {
     178            LOG(WebGPU, "%s: No fragment argument encoder found for binding %lu!", functionName, index);
     179            return nullptr;
     180        }
     181        if (isForCompute && !computeEncoder) {
     182            LOG(WebGPU, "%s: No compute argument encoder found for binding %lu!", functionName, index);
     183            return nullptr;
     184        }
     185
    174186        switch (layoutBinding.type) {
    175187        // FIXME: Support more resource types.
     188        // FIXME: We could avoid this ugly switch-on-type using virtual functions if GPUBindingResource is refactored as a base class rather than a Variant.
    176189        case GPUBindingType::UniformBuffer:
    177190        case GPUBindingType::StorageBuffer: {
    … …  
    179192            if (!bufferResource)
    180193                return nullptr;
    181             if (layoutBinding.visibility & GPUShaderStageBit::Flags::Vertex)
    182                 setBufferOnEncoder(vertexEncoder, *bufferResource, resourceBinding.binding);
    183             if (layoutBinding.visibility & GPUShaderStageBit::Flags::Fragment)
    184                 setBufferOnEncoder(fragmentEncoder, *bufferResource, resourceBinding.binding);
     194            if (isForVertex)
     195                setBufferOnEncoder(vertexEncoder, *bufferResource, index);
     196            if (isForFragment)
     197                setBufferOnEncoder(fragmentEncoder, *bufferResource, index);
     198            if (isForCompute)
     199                setBufferOnEncoder(computeEncoder, *bufferResource, index);
    185200            boundBuffers.append(bufferResource->buffer.copyRef());
    186201            break;
    187202        }
    188203        case GPUBindingType::Sampler: {
    189             auto samplerResource = tryGetResourceAsSampler(resourceBinding.resource, functionName);
    190             if (!samplerResource)
     204            auto samplerState = tryGetResourceAsMTLSamplerState(resourceBinding.resource, functionName);
     205            if (!samplerState)
    191206                return nullptr;
    192             if (layoutBinding.visibility & GPUShaderStageBit::Flags::Vertex)
    193                 setSamplerOnEncoder(vertexEncoder, samplerResource->platformSampler(), resourceBinding.binding);
    194             if (layoutBinding.visibility & GPUShaderStageBit::Flags::Fragment)
    195                 setSamplerOnEncoder(fragmentEncoder, samplerResource->platformSampler(), resourceBinding.binding);
     207            if (isForVertex)
     208                setSamplerOnEncoder(vertexEncoder, samplerState, index);
     209            if (isForFragment)
     210                setSamplerOnEncoder(fragmentEncoder, samplerState, index);
     211            if (isForCompute)
     212                setSamplerOnEncoder(computeEncoder, samplerState, index);
    196213            break;
    197214        }
    … …  
    200217            if (!textureResource)
    201218                return nullptr;
    202             if (layoutBinding.visibility & GPUShaderStageBit::Flags::Vertex)
    203                 setTextureOnEncoder(vertexEncoder, textureResource->platformTexture(), resourceBinding.binding);
    204             if (layoutBinding.visibility & GPUShaderStageBit::Flags::Fragment)
    205                 setTextureOnEncoder(fragmentEncoder, textureResource->platformTexture(), resourceBinding.binding);
     219            if (isForVertex)
     220                setTextureOnEncoder(vertexEncoder, textureResource->platformTexture(), index);
     221            if (isForFragment)
     222                setTextureOnEncoder(fragmentEncoder, textureResource->platformTexture(), index);
     223            if (isForCompute)
     224                setTextureOnEncoder(computeEncoder, textureResource->platformTexture(), index);
    206225            boundTextures.append(textureResource.releaseNonNull());
    207226            break;
    … …  
    213232    }
    214233   
    215     return adoptRef(new GPUBindGroup(WTFMove(vertexArgsBuffer), WTFMove(fragmentArgsBuffer), WTFMove(boundBuffers), WTFMove(boundTextures)));
    216 }
    217    
    218 GPUBindGroup::GPUBindGroup(RetainPtr<MTLBuffer>&& vertexBuffer, RetainPtr<MTLBuffer>&& fragmentBuffer, Vector<Ref<GPUBuffer>>&& buffers, Vector<Ref<GPUTexture>>&& textures)
     234    return adoptRef(new GPUBindGroup(WTFMove(vertexArgsBuffer), WTFMove(fragmentArgsBuffer), WTFMove(computeArgsBuffer), WTFMove(boundBuffers), WTFMove(boundTextures)));
     235}
     236   
     237GPUBindGroup::GPUBindGroup(RetainPtr<MTLBuffer>&& vertexBuffer, RetainPtr<MTLBuffer>&& fragmentBuffer, RetainPtr<MTLBuffer>&& computeBuffer, Vector<Ref<GPUBuffer>>&& buffers, Vector<Ref<GPUTexture>>&& textures)
    219238    : m_vertexArgsBuffer(WTFMove(vertexBuffer))
    220239    , m_fragmentArgsBuffer(WTFMove(fragmentBuffer))
     240    , m_computeArgsBuffer(WTFMove(computeBuffer))
    221241    , m_boundBuffers(WTFMove(buffers))
    222242    , m_boundTextures(WTFMove(textures))

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

    r242766 r243419  
    3030
    3131#import "GPUBindGroup.h"
    32 #import "GPUCommandBuffer.h"
    3332#import "Logging.h"
    3433#import <Metal/Metal.h>
    … …  
    3938void GPUProgrammablePassEncoder::endPass()
    4039{
    41     ASSERT(platformPassEncoder());
     40    if (!platformPassEncoder())
     41        return;
    4242
    4343    BEGIN_BLOCK_OBJC_EXCEPTIONS;
    … …  
    4545    END_BLOCK_OBJC_EXCEPTIONS;
    4646
     47    invalidateEncoder();
    4748    m_commandBuffer->setIsEncodingPass(false);
    4849}
    … …  
    5960    if (bindGroup.fragmentArgsBuffer())
    6061        setFragmentBuffer(bindGroup.fragmentArgsBuffer(), 0, index);
     62    if (bindGroup.computeArgsBuffer())
     63        setComputeBuffer(bindGroup.computeArgsBuffer(), 0, index);
    6164
    6265    for (auto& bufferRef : bindGroup.boundBuffers()) {

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

    r242839 r243419  
    179179}
    180180
    181 MTLCommandEncoder *GPURenderPassEncoder::platformPassEncoder() const
     181const MTLCommandEncoder *GPURenderPassEncoder::platformPassEncoder() const
    182182{
    183183    return m_platformRenderPassEncoder.get();
    184 }
    185 
    186 void GPURenderPassEncoder::endPass()
    187 {
    188     if (!m_platformRenderPassEncoder)
    189         return;
    190     GPUProgrammablePassEncoder::endPass();
    191     m_platformRenderPassEncoder = nullptr;
    192184}
    193185
    … …  
    199191    }
    200192
    201     // FIXME: Metal throws an error if the MTLPipelineState's attachment formats do not match the MTLCommandEncoder's attachment formats. Does this have to be validated at the Web GPU level?
     193    // FIXME: Metal throws an error if the MTLPipelineState's attachment formats do not match the MTLCommandEncoder's attachment formats.
    202194
    203195    BEGIN_BLOCK_OBJC_EXCEPTIONS;
    … …  
    266258    }
    267259
     260    BEGIN_BLOCK_OBJC_EXCEPTIONS;
    268261    [m_platformRenderPassEncoder
    269262        drawPrimitives:primitiveTypeForGPUPrimitiveTopology(m_pipeline->primitiveTopology())
    … …  
    272265        instanceCount:instanceCount
    273266        baseInstance:firstInstance];
     267    END_BLOCK_OBJC_EXCEPTIONS;
    274268}
    275269
    276270#if USE(METAL)
    277271
    278 void GPURenderPassEncoder::useResource(MTLResource *resource, unsigned usage)
    279 {
    280     if (!m_platformRenderPassEncoder) {
    281         LOG(WebGPU, "GPURenderPassEncoder: Invalid operation: Encoding is ended!");
    282         return;
    283     }
     272void GPURenderPassEncoder::useResource(const MTLResource *resource, unsigned usage)
     273{
     274    ASSERT(m_platformRenderPassEncoder);
     275
    284276    BEGIN_BLOCK_OBJC_EXCEPTIONS;
    285277    [m_platformRenderPassEncoder useResource:resource usage:usage];
    … …  
    287279}
    288280
    289 void GPURenderPassEncoder::setVertexBuffer(MTLBuffer *buffer, unsigned offset, unsigned index)
    290 {
    291     if (!m_platformRenderPassEncoder) {
    292         LOG(WebGPU, "GPURenderPassEncoder: Invalid operation: Encoding is ended!");
    293         return;
    294     }
     281void GPURenderPassEncoder::setVertexBuffer(const MTLBuffer *buffer, unsigned offset, unsigned index)
     282{
     283    ASSERT(m_platformRenderPassEncoder);
     284
    295285    BEGIN_BLOCK_OBJC_EXCEPTIONS;
    296286    [m_platformRenderPassEncoder setVertexBuffer:buffer offset:offset atIndex:index];
    … …  
    298288}
    299289
    300 void GPURenderPassEncoder::setFragmentBuffer(MTLBuffer *buffer, unsigned offset, unsigned index)
    301 {
    302     if (!m_platformRenderPassEncoder) {
    303         LOG(WebGPU, "GPURenderPassEncoder: Invalid operation: Encoding is ended!");
    304         return;
    305     }
     290void GPURenderPassEncoder::setFragmentBuffer(const MTLBuffer *buffer, unsigned offset, unsigned index)
     291{
     292    ASSERT(m_platformRenderPassEncoder);
     293
    306294    BEGIN_BLOCK_OBJC_EXCEPTIONS;
    307295    [m_platformRenderPassEncoder setFragmentBuffer:buffer offset:offset atIndex:index];

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

    r243105 r243419  
    2929#if ENABLE(WEBGPU)
    3030
     31#import "GPUDevice.h"
    3132#import "GPULimits.h"
    3233#import "GPUUtils.h"
    … …  
    442443    : m_depthStencilState(WTFMove(depthStencil))
    443444    , m_platformRenderPipeline(WTFMove(pipeline))
    444     , m_layout(WTFMove(descriptor.layout))
    445445    , m_primitiveTopology(descriptor.primitiveTopology)
    446446{

  • trunk/Source/WebCore/platform/text/mac/TextEncodingRegistryMac.mm

    r240211 r243419  
    2929#if PLATFORM(MAC)
    3030
    31 #import <Carbon/Carbon.h>
    3231#import <wtf/spi/cf/CFStringSPI.h>
    3332
Note: See TracChangeset for help on using the changeset viewer.