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

Changeset 243457 in webkit


Ignore:
Timestamp:
Mar 25, 2019, 2:12:25 PM (7 years ago)
Author:
Truitt Savell
Message:

Unreviewed, rolling out r243419.

Caused Mac WK2 testers to crash and become unresponsive.

Reverted changeset:

"[Web GPU] Prototype compute pipeline with MSL"
​https://bugs.webkit.org/show_bug.cgi?id=196107
​https://trac.webkit.org/changeset/243419

Location:
trunk
Files:
17 deleted
38 edited

Legend:

Unmodified
Added
Removed

  • trunk/LayoutTests/ChangeLog

    r243456 r243457  
     12019-03-25  Truitt Savell  <tsavell@apple.com>
     2
     3        Unreviewed, rolling out r243419.
     4
     5        Caused Mac WK2 testers to crash and become unresponsive.
     6
     7        Reverted changeset:
     8
     9        "[Web GPU] Prototype compute pipeline with MSL"
     10        https://bugs.webkit.org/show_bug.cgi?id=196107
     11        https://trac.webkit.org/changeset/243419
     12
    1132019-03-25  Truitt Savell  <tsavell@apple.com>
    214

  • trunk/LayoutTests/webgpu/whlsl.html

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

  • trunk/Source/WebCore/CMakeLists.txt

    r243450 r243457  
    496496    Modules/webgpu/WebGPUCommandBuffer.idl
    497497    Modules/webgpu/WebGPUCommandEncoder.idl
    498     Modules/webgpu/WebGPUComputePassEncoder.idl
    499     Modules/webgpu/WebGPUComputePipeline.idl
    500     Modules/webgpu/WebGPUComputePipelineDescriptor.idl
    501498    Modules/webgpu/WebGPUDevice.idl
    502499    Modules/webgpu/WebGPUPipelineDescriptorBase.idl

  • trunk/Source/WebCore/ChangeLog

    r243456 r243457  
     12019-03-25  Truitt Savell  <tsavell@apple.com>
     2
     3        Unreviewed, rolling out r243419.
     4
     5        Caused Mac WK2 testers to crash and become unresponsive.
     6
     7        Reverted changeset:
     8
     9        "[Web GPU] Prototype compute pipeline with MSL"
     10        https://bugs.webkit.org/show_bug.cgi?id=196107
     11        https://trac.webkit.org/changeset/243419
     12
    1132019-03-25  Truitt Savell  <tsavell@apple.com>
    214

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

    r243450 r243457  
    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
    373370$(PROJECT_DIR)/Modules/webgpu/WebGPUDevice.idl
    374371$(PROJECT_DIR)/Modules/webgpu/WebGPUIndexFormat.idl

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

    r243450 r243457  
    19321932$(BUILT_PRODUCTS_DIR)/DerivedSources/WebCore/JSWebGPUCommandEncoder.cpp
    19331933$(BUILT_PRODUCTS_DIR)/DerivedSources/WebCore/JSWebGPUCommandEncoder.h
    1934 $(BUILT_PRODUCTS_DIR)/DerivedSources/WebCore/JSWebGPUComputePassEncoder.cpp
    1935 $(BUILT_PRODUCTS_DIR)/DerivedSources/WebCore/JSWebGPUComputePassEncoder.h
    1936 $(BUILT_PRODUCTS_DIR)/DerivedSources/WebCore/JSWebGPUComputePipeline.cpp
    1937 $(BUILT_PRODUCTS_DIR)/DerivedSources/WebCore/JSWebGPUComputePipeline.h
    1938 $(BUILT_PRODUCTS_DIR)/DerivedSources/WebCore/JSWebGPUComputePipelineDescriptor.cpp
    1939 $(BUILT_PRODUCTS_DIR)/DerivedSources/WebCore/JSWebGPUComputePipelineDescriptor.h
    19401934$(BUILT_PRODUCTS_DIR)/DerivedSources/WebCore/JSWebGPUDevice.cpp
    19411935$(BUILT_PRODUCTS_DIR)/DerivedSources/WebCore/JSWebGPUDevice.h

  • trunk/Source/WebCore/DerivedSources.make

    r243450 r243457  
    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 \
    413410    $(WebCore)/Modules/webgpu/WebGPUDevice.idl \
    414411    $(WebCore)/Modules/webgpu/WebGPUQueue.idl \

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

    r243419 r243457  
    3030#include "WHLSLNameContext.h"
    3131#include "WHLSLVisitor.h"
    32 #include <wtf/HashSet.h>
    3332
    3433namespace WebCore {

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

    r243419 r243457  
    2929#if ENABLE(WEBGPU)
    3030
    31 #include "GPUComputePassEncoder.h"
    3231#include "GPURenderPassDescriptor.h"
    3332#include "GPURenderPassEncoder.h"
    3433#include "WebGPUBuffer.h"
    35 #include "WebGPUComputePassEncoder.h"
    3634#include "WebGPURenderPassDescriptor.h"
    3735#include "WebGPURenderPassEncoder.h"
    … …  
    7977    if (!m_commandBuffer) {
    8078        LOG(WebGPU, "WebGPUCommandEncoder::beginRenderPass(): Invalid operation!");
    81         return WebGPURenderPassEncoder::create(nullptr);
     79        return WebGPURenderPassEncoder::create(*this, nullptr);
    8280    }
    8381    auto gpuDescriptor = descriptor.tryCreateGPURenderPassDescriptor();
    8482    if (!gpuDescriptor)
    85         return WebGPURenderPassEncoder::create(nullptr);
     83        return WebGPURenderPassEncoder::create(*this, nullptr);
    8684
    8785    auto encoder = GPURenderPassEncoder::tryCreate(makeRef(*m_commandBuffer), WTFMove(*gpuDescriptor));
    88     return WebGPURenderPassEncoder::create(WTFMove(encoder));
    89 }
    90 
    91 Ref<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));
     86    return WebGPURenderPassEncoder::create(*this, WTFMove(encoder));
    9987}
    10088

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

    r243419 r243457  
    3636
    3737class WebGPUBuffer;
    38 class WebGPUComputePassEncoder;
    3938class WebGPURenderPassEncoder;
    4039class WebGPUTexture;
    … …  
    6059
    6160    Ref<WebGPURenderPassEncoder> beginRenderPass(WebGPURenderPassDescriptor&&);
    62     Ref<WebGPUComputePassEncoder> beginComputePass();
    6361    void copyBufferToBuffer(const WebGPUBuffer&, unsigned long srcOffset, const WebGPUBuffer&, unsigned long dstOffset, unsigned long size);
    6462    void copyBufferToTexture(const WebGPUBufferCopyView&, const WebGPUTextureCopyView&, const GPUExtent3D&);

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

    r243419 r243457  
    5757] interface WebGPUCommandEncoder {
    5858    WebGPURenderPassEncoder beginRenderPass(WebGPURenderPassDescriptor descriptor);
    59     WebGPUComputePassEncoder beginComputePass();
    6059
    6160    void copyBufferToBuffer(
    … …  
    8281
    8382    WebGPUCommandBuffer finish();
     83
     84    // Not Yet Implemented
     85    // WebGPUComputePassEncoder beginComputePass();
    8486};

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

    r243419 r243457  
    5050#include "WebGPUBufferBinding.h"
    5151#include "WebGPUCommandEncoder.h"
    52 #include "WebGPUComputePipeline.h"
    53 #include "WebGPUComputePipelineDescriptor.h"
    5452#include "WebGPUPipelineLayout.h"
    5553#include "WebGPUPipelineLayoutDescriptor.h"
    … …  
    140138}
    141139
    142 Ref<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 
    152140Ref<WebGPUCommandEncoder> WebGPUDevice::createCommandEncoder() const
    153141{

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

    r243419 r243457  
    4343class WebGPUBuffer;
    4444class WebGPUCommandEncoder;
    45 class WebGPUComputePipeline;
    4645class WebGPUPipelineLayout;
    4746class WebGPURenderPipeline;
    … …  
    5655struct GPUTextureDescriptor;
    5756struct WebGPUBindGroupDescriptor;
    58 struct WebGPUComputePipelineDescriptor;
    5957struct WebGPUPipelineLayoutDescriptor;
    6058struct WebGPURenderPipelineDescriptor;
    … …  
    7876    RefPtr<WebGPUShaderModule> createShaderModule(WebGPUShaderModuleDescriptor&&) const;
    7977    Ref<WebGPURenderPipeline> createRenderPipeline(const WebGPURenderPipelineDescriptor&) const;
    80     Ref<WebGPUComputePipeline> createComputePipeline(const WebGPUComputePipelineDescriptor&) const;
    8178
    8279    Ref<WebGPUCommandEncoder> createCommandEncoder() const;

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

    r243456 r243457  
    5454    WebGPUShaderModule createShaderModule(WebGPUShaderModuleDescriptor descriptor);
    5555    WebGPURenderPipeline createRenderPipeline(WebGPURenderPipelineDescriptor descriptor);
    56     WebGPUComputePipeline createComputePipeline(WebGPUComputePipelineDescriptor descriptor);
    5756
    5857    // FIXME: Currently, GPUCommandEncoderDescriptor is an empty dictionary.
    … …  
    6766    // readonly attribute WebGPULimits limits;
    6867
     68    // WebGPUComputePipeline createComputePipeline(WebGPUComputePipelineDescriptor descriptor);
    6969    // WebGPUFence createFence(WebGPUFenceDescriptor descriptor);
    7070

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

    r243419 r243457  
    3232#include "Logging.h"
    3333#include "WebGPUBindGroup.h"
     34#include "WebGPURenderPipeline.h"
    3435
    3536namespace WebCore {
     37
     38WebGPUProgrammablePassEncoder::WebGPUProgrammablePassEncoder(Ref<WebGPUCommandEncoder>&& creator)
     39    : m_commandBuffer(WTFMove(creator))
     40{
     41}
    3642
    3743void WebGPUProgrammablePassEncoder::endPass()
    … …  
    4450}
    4551
    46 void WebGPUProgrammablePassEncoder::setBindGroup(unsigned index, WebGPUBindGroup& bindGroup)
     52void WebGPUProgrammablePassEncoder::setBindGroup(unsigned index, WebGPUBindGroup& bindGroup) const
    4753{
    4854    if (!passEncoder()) {

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

    r243419 r243457  
    2828#if ENABLE(WEBGPU)
    2929
     30#include "WebGPUCommandEncoder.h"
    3031#include <wtf/RefCounted.h>
    3132
    … …  
    3435class GPUProgrammablePassEncoder;
    3536class WebGPUBindGroup;
     37class WebGPURenderPipeline;
    3638
    3739class WebGPUProgrammablePassEncoder : public RefCounted<WebGPUProgrammablePassEncoder> {
    … …  
    4042
    4143    void endPass();
    42     void setBindGroup(unsigned, WebGPUBindGroup&);
     44    void setBindGroup(unsigned, WebGPUBindGroup&) const;
    4345
    4446protected:
    45     WebGPUProgrammablePassEncoder() = default;
     47    WebGPUProgrammablePassEncoder(Ref<WebGPUCommandEncoder>&&);
    4648
    47     virtual GPUProgrammablePassEncoder* passEncoder() = 0;
    48     virtual const GPUProgrammablePassEncoder* passEncoder() const = 0;
     49    virtual GPUProgrammablePassEncoder* passEncoder() const = 0;
     50
     51private:
     52    Ref<WebGPUCommandEncoder> m_commandBuffer;
    4953};
    5054

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

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

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

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

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

    r243419 r243457  
    2929#if ENABLE(WEBGPU)
    3030
     31#include "GPURenderPipeline.h"
     32
    3133namespace WebCore {
    3234

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

    r243419 r243457  
    2929
    3030#include "GPURenderPipeline.h"
     31
    3132#include <wtf/RefCounted.h>
    3233#include <wtf/RefPtr.h>

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

    r243419 r243457  
    2929#if ENABLE(WEBGPU)
    3030
    31 #include "Logging.h"
     31namespace WebCore {
    3232
    33 namespace WebCore {
     33Optional<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}
    3440
    3541Optional<GPURenderPipelineDescriptor> WebGPURenderPipelineDescriptor::tryCreateGPURenderPipelineDescriptor() const

  • trunk/Source/WebCore/Sources.txt

    r243433 r243457  
    349349Modules/webgpu/WHLSL/WHLSLPrepare.cpp
    350350Modules/webgpu/WebGPU.cpp
    351 Modules/webgpu/WebGPUAdapter.cpp
    352351Modules/webgpu/WebGPUBindGroup.cpp
    353352Modules/webgpu/WebGPUBindGroupDescriptor.cpp
     353Modules/webgpu/WebGPUCommandBuffer.cpp
     354Modules/webgpu/WebGPUCommandEncoder.cpp
     355Modules/webgpu/WebGPUAdapter.cpp
    354356Modules/webgpu/WebGPUBindGroupLayout.cpp
    355357Modules/webgpu/WebGPUBuffer.cpp
    356 Modules/webgpu/WebGPUCommandBuffer.cpp
    357 Modules/webgpu/WebGPUCommandEncoder.cpp
    358 Modules/webgpu/WebGPUComputePassEncoder.cpp
    359 Modules/webgpu/WebGPUComputePipeline.cpp
    360 Modules/webgpu/WebGPUComputePipelineDescriptor.cpp
    361358Modules/webgpu/WebGPUDevice.cpp
    362359Modules/webgpu/WebGPUQueue.cpp
    363360Modules/webgpu/WebGPUPipelineLayout.cpp
    364 Modules/webgpu/WebGPUPipelineStageDescriptor.cpp
    365361Modules/webgpu/WebGPUProgrammablePassEncoder.cpp
    366362Modules/webgpu/WebGPURenderPassDescriptor.cpp
    … …  
    33373333JSWebGPUCommandBuffer.cpp
    33383334JSWebGPUCommandEncoder.cpp
    3339 JSWebGPUComputePassEncoder.cpp
    3340 JSWebGPUComputePipeline.cpp
    3341 JSWebGPUComputePipelineDescriptor.cpp
    33423335JSWebGPUDevice.cpp
    33433336JSWebGPUQueue.cpp

  • trunk/Source/WebCore/SourcesCocoa.txt

    r243419 r243457  
    323323platform/graphics/gpu/cocoa/GPUBufferMetal.mm
    324324platform/graphics/gpu/cocoa/GPUCommandBufferMetal.mm
    325 platform/graphics/gpu/cocoa/GPUComputePassEncoderMetal.mm
    326 platform/graphics/gpu/cocoa/GPUComputePipelineMetal.mm
    327325platform/graphics/gpu/cocoa/GPUDeviceMetal.mm
    328326platform/graphics/gpu/cocoa/GPUProgrammablePassEncoderMetal.mm

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

    r243456 r243457  
    1401014010                D003288721C9A4E500622AA6 /* GPUPipelineLayout.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; path = GPUPipelineLayout.cpp; sourceTree = "<group>"; };
    1401114011                D003914122248D400098998C /* GPUProgrammablePassEncoder.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; path = GPUProgrammablePassEncoder.cpp; sourceTree = "<group>"; };
    14012                 D00D77FD2242ED450043F12C /* WebGPUComputePassEncoder.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = WebGPUComputePassEncoder.h; sourceTree = "<group>"; };
    14013                 D00D77FE2242ED450043F12C /* WebGPUComputePassEncoder.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; path = WebGPUComputePassEncoder.cpp; sourceTree = "<group>"; };
    14014                 D00D77FF2242ED450043F12C /* WebGPUComputePassEncoder.idl */ = {isa = PBXFileReference; lastKnownFileType = text; path = WebGPUComputePassEncoder.idl; sourceTree = "<group>"; };
    1401514012                D00F5940216ECC7A000D71DB /* DOMWindowWebGPU.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = DOMWindowWebGPU.h; sourceTree = "<group>"; };
    1401614013                D00F5941216ECC7A000D71DB /* DOMWindowWebGPU.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; path = DOMWindowWebGPU.cpp; sourceTree = "<group>"; };
    … …  
    1415214149                D087CE3F21ACA94200BDE174 /* GPUTextureMetal.mm */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.objcpp; path = GPUTextureMetal.mm; sourceTree = "<group>"; };
    1415314150                D087CE4021ACA94200BDE174 /* GPUShaderModuleMetal.mm */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.objcpp; path = GPUShaderModuleMetal.mm; sourceTree = "<group>"; };
    14154                 D08903342240601D00F3F440 /* WebGPUComputePipelineDescriptor.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = WebGPUComputePipelineDescriptor.h; sourceTree = "<group>"; };
    14155                 D08903352240601D00F3F440 /* WebGPUComputePipelineDescriptor.idl */ = {isa = PBXFileReference; lastKnownFileType = text; path = WebGPUComputePipelineDescriptor.idl; sourceTree = "<group>"; };
    14156                 D0890337224061AC00F3F440 /* WebGPUPipelineStageDescriptor.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; path = WebGPUPipelineStageDescriptor.cpp; sourceTree = "<group>"; };
    14157                 D08903382240628900F3F440 /* WebGPUComputePipelineDescriptor.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; path = WebGPUComputePipelineDescriptor.cpp; sourceTree = "<group>"; };
    14158                 D08903392240642D00F3F440 /* GPUComputePipelineDescriptor.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = GPUComputePipelineDescriptor.h; sourceTree = "<group>"; };
    14159                 D089033A224179B500F3F440 /* GPUComputePipeline.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = GPUComputePipeline.h; sourceTree = "<group>"; };
    14160                 D089033B224179B500F3F440 /* GPUComputePipelineMetal.mm */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.objcpp; path = GPUComputePipelineMetal.mm; sourceTree = "<group>"; };
    14161                 D089033C2241A99F00F3F440 /* WebGPUComputePipeline.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = WebGPUComputePipeline.h; sourceTree = "<group>"; };
    14162                 D089033D2241A99F00F3F440 /* WebGPUComputePipeline.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; path = WebGPUComputePipeline.cpp; sourceTree = "<group>"; };
    14163                 D089033E2241A99F00F3F440 /* WebGPUComputePipeline.idl */ = {isa = PBXFileReference; lastKnownFileType = text; path = WebGPUComputePipeline.idl; sourceTree = "<group>"; };
    14164                 D089033F2241CE4600F3F440 /* GPUComputePassEncoder.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = GPUComputePassEncoder.h; sourceTree = "<group>"; };
    14165                 D08903402241CE4600F3F440 /* GPUComputePassEncoderMetal.mm */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.objcpp; path = GPUComputePassEncoderMetal.mm; sourceTree = "<group>"; };
    1416614151                D08AA02D220D0B9C0058C502 /* GPULoadOp.idl */ = {isa = PBXFileReference; lastKnownFileType = text; path = GPULoadOp.idl; sourceTree = "<group>"; };
    1416714152                D08AA02F220D0BD50058C502 /* GPULoadOp.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = GPULoadOp.h; sourceTree = "<group>"; };
    … …  
    1860918594                                312FF8BD21A4C2F100EB199D /* GPUCommandBuffer.h */,
    1861018595                                D03C849C21FFC7FC0002227F /* GPUCompareFunction.h */,
    18611                                 D089033F2241CE4600F3F440 /* GPUComputePassEncoder.h */,
    18612                                 D089033A224179B500F3F440 /* GPUComputePipeline.h */,
    18613                                 D08903392240642D00F3F440 /* GPUComputePipelineDescriptor.h */,
    1861418596                                D03C849A21FFC6670002227F /* GPUDepthStencilStateDescriptor.h */,
    1861518597                                312FF8BF21A4C2F100EB199D /* GPUDevice.cpp */,
    … …  
    2626626248                                D0EACF7621937228000FA75C /* WebGPUCommandEncoder.h */,
    2626726249                                D0EACF7821937228000FA75C /* WebGPUCommandEncoder.idl */,
    26268                                 D00D77FE2242ED450043F12C /* WebGPUComputePassEncoder.cpp */,
    26269                                 D00D77FD2242ED450043F12C /* WebGPUComputePassEncoder.h */,
    26270                                 D00D77FF2242ED450043F12C /* WebGPUComputePassEncoder.idl */,
    26271                                 D089033D2241A99F00F3F440 /* WebGPUComputePipeline.cpp */,
    26272                                 D089033C2241A99F00F3F440 /* WebGPUComputePipeline.h */,
    26273                                 D089033E2241A99F00F3F440 /* WebGPUComputePipeline.idl */,
    26274                                 D08903382240628900F3F440 /* WebGPUComputePipelineDescriptor.cpp */,
    26275                                 D08903342240601D00F3F440 /* WebGPUComputePipelineDescriptor.h */,
    26276                                 D08903352240601D00F3F440 /* WebGPUComputePipelineDescriptor.idl */,
    2627726250                                D00F595321701D8C000D71DB /* WebGPUDevice.cpp */,
    2627826251                                D00F595221701D8C000D71DB /* WebGPUDevice.h */,
    … …  
    2628626259                                D05A99E121C9B50F00032B75 /* WebGPUPipelineLayoutDescriptor.h */,
    2628726260                                D05A99E221C9B50F00032B75 /* WebGPUPipelineLayoutDescriptor.idl */,
    26288                                 D0890337224061AC00F3F440 /* WebGPUPipelineStageDescriptor.cpp */,
    2628926261                                D0C419EB2183CFA2009EC1DE /* WebGPUPipelineStageDescriptor.h */,
    2629026262                                D0C419EC2183CFA2009EC1DE /* WebGPUPipelineStageDescriptor.idl */,
    … …  
    2633626308                                D0D8649121B760C4003C983C /* GPUBufferMetal.mm */,
    2633726309                                D087CE3821ACA94200BDE174 /* GPUCommandBufferMetal.mm */,
    26338                                 D08903402241CE4600F3F440 /* GPUComputePassEncoderMetal.mm */,
    26339                                 D089033B224179B500F3F440 /* GPUComputePipelineMetal.mm */,
    2634026310                                D087CE3C21ACA94200BDE174 /* GPUDeviceMetal.mm */,
    2634126311                                D087CE3B21ACA94200BDE174 /* GPUProgrammablePassEncoderMetal.mm */,

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

    r243456 r243457  
    8787    macro(GPUCommandBuffer) \
    8888    macro(GPUCommandEncoder) \
    89     macro(GPUComputePassEncoder) \
    90     macro(GPUComputePipeline) \
    9189    macro(GPUShaderStageBit) \
    9290    macro(GPUSwapChain) \

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

    r243419 r243457  
    3535#include "PlaybackSessionModel.h"
    3636#include <wtf/CompletionHandler.h>
    37 #include <wtf/WeakPtr.h>
    3837
    3938#if PLATFORM(IOS_FAMILY)

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

    r243419 r243457  
    2828#if ENABLE(WEBGPU)
    2929
    30 #include "GPUBuffer.h"
    31 #include "GPUTexture.h"
    3230#include <wtf/RefCounted.h>
    3331#include <wtf/RefPtr.h>
    3432#include <wtf/RetainPtr.h>
    3533#include <wtf/Vector.h>
     34#include "GPUBuffer.h"
     35#include "GPUTexture.h"
    3636
    3737OBJC_PROTOCOL(MTLBuffer);
    … …  
    4646   
    4747#if USE(METAL)
    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(); }
     48    MTLBuffer *vertexArgsBuffer() { return m_vertexArgsBuffer.get(); }
     49    MTLBuffer *fragmentArgsBuffer() { return m_fragmentArgsBuffer.get(); }
    5150#endif
    5251    const Vector<Ref<GPUBuffer>>& boundBuffers() const { return m_boundBuffers; }
    … …  
    5554private:
    5655#if USE(METAL)
    57     GPUBindGroup(RetainPtr<MTLBuffer>&& vertexBuffer, RetainPtr<MTLBuffer>&& fragmentBuffer, RetainPtr<MTLBuffer>&& computeArgsBuffer, Vector<Ref<GPUBuffer>>&&, Vector<Ref<GPUTexture>>&&);
     56    GPUBindGroup(RetainPtr<MTLBuffer>&& vertexBuffer, RetainPtr<MTLBuffer>&& fragmentBuffer, Vector<Ref<GPUBuffer>>&&, Vector<Ref<GPUTexture>>&&);
    5857   
    5958    RetainPtr<MTLBuffer> m_vertexArgsBuffer;
    6059    RetainPtr<MTLBuffer> m_fragmentArgsBuffer;
    61     RetainPtr<MTLBuffer> m_computeArgsBuffer;
    6260#endif
    6361    Vector<Ref<GPUBuffer>> m_boundBuffers;

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

    r243419 r243457  
    3434#include "GPUBufferDescriptor.h"
    3535#include "GPUCommandBuffer.h"
    36 #include "GPUComputePipeline.h"
    37 #include "GPUComputePipelineDescriptor.h"
    3836#include "GPUPipelineLayout.h"
    3937#include "GPUPipelineLayoutDescriptor.h"
    … …  
    4543#include "GPUShaderModuleDescriptor.h"
    4644#include "GPUSwapChain.h"
    47 #include "GPUSwapChainDescriptor.h"
    4845#include "GPUTexture.h"
    4946#include "GPUTextureDescriptor.h"
    … …  
    8784}
    8885
    89 RefPtr<GPUComputePipeline> GPUDevice::tryCreateComputePipeline(const GPUComputePipelineDescriptor& descriptor) const
    90 {
    91     return GPUComputePipeline::tryCreate(*this, descriptor);
    92 }
    93 
    9486RefPtr<GPUCommandBuffer> GPUDevice::tryCreateCommandBuffer() const
    9587{

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

    r243419 r243457  
    2929
    3030#include "GPUQueue.h"
     31#include "GPUSwapChainDescriptor.h"
    3132#include <wtf/RefCounted.h>
    3233#include <wtf/RetainPtr.h>
    … …  
    4041class GPUBuffer;
    4142class GPUCommandBuffer;
    42 class GPUComputePipeline;
    4343class GPUPipelineLayout;
    4444class GPURenderPipeline;
    … …  
    5050struct GPUBindGroupLayoutDescriptor;
    5151struct GPUBufferDescriptor;
    52 struct GPUComputePipelineDescriptor;
    5352struct GPUPipelineLayoutDescriptor;
    5453struct GPURenderPipelineDescriptor;
    … …  
    5655struct GPUSamplerDescriptor;
    5756struct GPUShaderModuleDescriptor;
    58 struct GPUSwapChainDescriptor;
    5957struct GPUTextureDescriptor;
    6058   
    … …  
    7573    RefPtr<GPUShaderModule> createShaderModule(GPUShaderModuleDescriptor&&) const;
    7674    RefPtr<GPURenderPipeline> createRenderPipeline(GPURenderPipelineDescriptor&&) const;
    77     RefPtr<GPUComputePipeline> tryCreateComputePipeline(const GPUComputePipelineDescriptor&) const;
    7875
    7976    RefPtr<GPUCommandBuffer> tryCreateCommandBuffer() const;

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

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

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

    r243419 r243457  
    2929
    3030#include "GPUBindGroupBinding.h"
    31 #include "GPUCommandBuffer.h"
    3231#include <wtf/RefCounted.h>
    3332
    … …  
    4140
    4241class GPUBindGroup;
     42class GPUCommandBuffer;
    4343class GPURenderPipeline;
    4444
    … …  
    4949    virtual ~GPUProgrammablePassEncoder() = default;
    5050
    51     void endPass();
     51    virtual void endPass();
    5252    void setBindGroup(unsigned, GPUBindGroup&);
    5353
    … …  
    5656
    5757    GPUCommandBuffer& commandBuffer() const { return m_commandBuffer.get(); }
    58     virtual const PlatformProgrammablePassEncoder* platformPassEncoder() const = 0;
     58    virtual PlatformProgrammablePassEncoder* platformPassEncoder() const = 0;
    5959
    6060private:
    61     virtual void invalidateEncoder() = 0;
    6261#if USE(METAL)
    63     virtual void useResource(const MTLResource *, unsigned) = 0;
     62    virtual void useResource(MTLResource *, unsigned) = 0;
    6463
    6564    // Render command encoder methods.
    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) { }
     65    virtual void setVertexBuffer(MTLBuffer *, unsigned, unsigned) { }
     66    virtual void setFragmentBuffer(MTLBuffer *, unsigned, unsigned) { }
    7067#endif // USE(METAL)
    7168

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

    r243419 r243457  
    5252    static RefPtr<GPURenderPassEncoder> tryCreate(Ref<GPUCommandBuffer>&&, GPURenderPassDescriptor&&);
    5353
     54    void endPass() final;
    5455    void setPipeline(Ref<const GPURenderPipeline>&&);
     56
    5557    void setVertexBuffers(unsigned long, Vector<Ref<GPUBuffer>>&&, Vector<unsigned long long>&&);
    5658    void draw(unsigned long vertexCount, unsigned long instanceCount, unsigned long firstVertex, unsigned long firstInstance);
    … …  
    5860private:
    5961    GPURenderPassEncoder(Ref<GPUCommandBuffer>&&, PlatformRenderPassEncoderSmartPtr&&);
    60     ~GPURenderPassEncoder() { endPass(); }
     62    ~GPURenderPassEncoder() { endPass(); } // Ensure that encoding has ended before release.
    6163
     64    PlatformProgrammablePassEncoder* platformPassEncoder() const final;
     65
     66#if USE(METAL)
    6267    // GPUProgrammablePassEncoder
    63     const PlatformProgrammablePassEncoder* platformPassEncoder() const final;
    64     void invalidateEncoder() final { m_platformRenderPassEncoder = nullptr; }
    65 #if USE(METAL)
    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;
     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;
    6971#endif // USE(METAL)
    7072

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

    r243419 r243457  
    6262#endif // USE(METAL)
    6363    PlatformRenderPipelineSmartPtr m_platformRenderPipeline;
     64    RefPtr<GPUPipelineLayout> m_layout;
    6465    GPUPrimitiveTopology m_primitiveTopology;
    6566};

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

    r243419 r243457  
    3232#import "GPUBindGroupDescriptor.h"
    3333#import "GPUBindGroupLayout.h"
     34#import "GPUBuffer.h"
    3435#import "GPUSampler.h"
     36#import "GPUTexture.h"
    3537#import "Logging.h"
    3638#import <Metal/Metal.h>
    … …  
    7678}
    7779   
    78 static MTLSamplerState *tryGetResourceAsMTLSamplerState(const GPUBindingResource& resource, const char* const functionName)
     80static RefPtr<GPUSampler> tryGetResourceAsSampler(const GPUBindingResource& resource, const char* const functionName)
    7981{
    8082#if LOG_DISABLED
    … …  
    8587        return nullptr;
    8688    }
    87     auto samplerState = WTF::get<Ref<GPUSampler>>(resource)->platformSampler();
    88     if (!samplerState)
     89    auto& samplerRef = WTF::get<Ref<GPUSampler>>(resource);
     90    if (!samplerRef->platformSampler()) {
    8991        LOG(WebGPU, "%s: Invalid MTLSamplerState in GPUSampler binding!", functionName);
    90 
    91     return samplerState;
     92        return nullptr;
     93    }
     94    return samplerRef.copyRef();
    9295}
    9396
    … …  
    133136    MTLArgumentEncoder *vertexEncoder = descriptor.layout->vertexEncoder();
    134137    MTLArgumentEncoder *fragmentEncoder = descriptor.layout->fragmentEncoder();
    135     MTLArgumentEncoder *computeEncoder = descriptor.layout->computeEncoder();
     138    // FIXME: Finish support for compute.
    136139   
    137140    RetainPtr<MTLBuffer> vertexArgsBuffer;
    … …  
    145148        return nullptr;
    146149    }
    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     }
    152150   
    153151    Vector<Ref<GPUBuffer>> boundBuffers;
    … …  
    157155    const auto& layoutBindingsMap = descriptor.layout->bindingsMap();
    158156    for (const auto& resourceBinding : descriptor.bindings) {
    159         auto index = resourceBinding.binding;
    160         auto layoutIterator = layoutBindingsMap.find(index);
     157        auto layoutIterator = layoutBindingsMap.find(resourceBinding.binding);
    161158        if (layoutIterator == layoutBindingsMap.end()) {
    162             LOG(WebGPU, "%s: GPUBindGroupBinding %lu not found in GPUBindGroupLayout!", functionName, index);
     159            LOG(WebGPU, "%s: GPUBindGroupBinding %lu not found in GPUBindGroupLayout!", functionName, resourceBinding.binding);
    163160            return nullptr;
    164161        }
    … …  
    166163        if (layoutBinding.visibility == GPUShaderStageBit::Flags::None)
    167164            continue;
    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 
     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       
    186174        switch (layoutBinding.type) {
    187175        // 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.
    189176        case GPUBindingType::UniformBuffer:
    190177        case GPUBindingType::StorageBuffer: {
    … …  
    192179            if (!bufferResource)
    193180                return nullptr;
    194             if (isForVertex)
    195                 setBufferOnEncoder(vertexEncoder, *bufferResource, index);
    196             if (isForFragment)
    197                 setBufferOnEncoder(fragmentEncoder, *bufferResource, index);
    198             if (isForCompute)
    199                 setBufferOnEncoder(computeEncoder, *bufferResource, index);
     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);
    200185            boundBuffers.append(bufferResource->buffer.copyRef());
    201186            break;
    202187        }
    203188        case GPUBindingType::Sampler: {
    204             auto samplerState = tryGetResourceAsMTLSamplerState(resourceBinding.resource, functionName);
    205             if (!samplerState)
     189            auto samplerResource = tryGetResourceAsSampler(resourceBinding.resource, functionName);
     190            if (!samplerResource)
    206191                return nullptr;
    207             if (isForVertex)
    208                 setSamplerOnEncoder(vertexEncoder, samplerState, index);
    209             if (isForFragment)
    210                 setSamplerOnEncoder(fragmentEncoder, samplerState, index);
    211             if (isForCompute)
    212                 setSamplerOnEncoder(computeEncoder, samplerState, index);
     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);
    213196            break;
    214197        }
    … …  
    217200            if (!textureResource)
    218201                return nullptr;
    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);
     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);
    225206            boundTextures.append(textureResource.releaseNonNull());
    226207            break;
    … …  
    232213    }
    233214   
    234     return adoptRef(new GPUBindGroup(WTFMove(vertexArgsBuffer), WTFMove(fragmentArgsBuffer), WTFMove(computeArgsBuffer), WTFMove(boundBuffers), WTFMove(boundTextures)));
    235 }
    236    
    237 GPUBindGroup::GPUBindGroup(RetainPtr<MTLBuffer>&& vertexBuffer, RetainPtr<MTLBuffer>&& fragmentBuffer, RetainPtr<MTLBuffer>&& computeBuffer, Vector<Ref<GPUBuffer>>&& buffers, Vector<Ref<GPUTexture>>&& textures)
     215    return adoptRef(new GPUBindGroup(WTFMove(vertexArgsBuffer), WTFMove(fragmentArgsBuffer), WTFMove(boundBuffers), WTFMove(boundTextures)));
     216}
     217   
     218GPUBindGroup::GPUBindGroup(RetainPtr<MTLBuffer>&& vertexBuffer, RetainPtr<MTLBuffer>&& fragmentBuffer, Vector<Ref<GPUBuffer>>&& buffers, Vector<Ref<GPUTexture>>&& textures)
    238219    : m_vertexArgsBuffer(WTFMove(vertexBuffer))
    239220    , m_fragmentArgsBuffer(WTFMove(fragmentBuffer))
    240     , m_computeArgsBuffer(WTFMove(computeBuffer))
    241221    , m_boundBuffers(WTFMove(buffers))
    242222    , m_boundTextures(WTFMove(textures))

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

    r243419 r243457  
    3030
    3131#import "GPUBindGroup.h"
     32#import "GPUCommandBuffer.h"
    3233#import "Logging.h"
    3334#import <Metal/Metal.h>
    … …  
    3839void GPUProgrammablePassEncoder::endPass()
    3940{
    40     if (!platformPassEncoder())
    41         return;
     41    ASSERT(platformPassEncoder());
    4242
    4343    BEGIN_BLOCK_OBJC_EXCEPTIONS;
    … …  
    4545    END_BLOCK_OBJC_EXCEPTIONS;
    4646
    47     invalidateEncoder();
    4847    m_commandBuffer->setIsEncodingPass(false);
    4948}
    … …  
    6059    if (bindGroup.fragmentArgsBuffer())
    6160        setFragmentBuffer(bindGroup.fragmentArgsBuffer(), 0, index);
    62     if (bindGroup.computeArgsBuffer())
    63         setComputeBuffer(bindGroup.computeArgsBuffer(), 0, index);
    6461
    6562    for (auto& bufferRef : bindGroup.boundBuffers()) {

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

    r243419 r243457  
    179179}
    180180
    181 const MTLCommandEncoder *GPURenderPassEncoder::platformPassEncoder() const
     181MTLCommandEncoder *GPURenderPassEncoder::platformPassEncoder() const
    182182{
    183183    return m_platformRenderPassEncoder.get();
    184184}
    185185
     186void GPURenderPassEncoder::endPass()
     187{
     188    if (!m_platformRenderPassEncoder)
     189        return;
     190    GPUProgrammablePassEncoder::endPass();
     191    m_platformRenderPassEncoder = nullptr;
     192}
     193
    186194void GPURenderPassEncoder::setPipeline(Ref<const GPURenderPipeline>&& pipeline)
    187195{
    … …  
    191199    }
    192200
    193     // FIXME: Metal throws an error if the MTLPipelineState's attachment formats do not match the MTLCommandEncoder's attachment formats.
     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?
    194202
    195203    BEGIN_BLOCK_OBJC_EXCEPTIONS;
    … …  
    258266    }
    259267
    260     BEGIN_BLOCK_OBJC_EXCEPTIONS;
    261268    [m_platformRenderPassEncoder
    262269        drawPrimitives:primitiveTypeForGPUPrimitiveTopology(m_pipeline->primitiveTopology())
    … …  
    265272        instanceCount:instanceCount
    266273        baseInstance:firstInstance];
    267     END_BLOCK_OBJC_EXCEPTIONS;
    268274}
    269275
    270276#if USE(METAL)
    271277
    272 void GPURenderPassEncoder::useResource(const MTLResource *resource, unsigned usage)
    273 {
    274     ASSERT(m_platformRenderPassEncoder);
    275 
     278void GPURenderPassEncoder::useResource(MTLResource *resource, unsigned usage)
     279{
     280    if (!m_platformRenderPassEncoder) {
     281        LOG(WebGPU, "GPURenderPassEncoder: Invalid operation: Encoding is ended!");
     282        return;
     283    }
    276284    BEGIN_BLOCK_OBJC_EXCEPTIONS;
    277285    [m_platformRenderPassEncoder useResource:resource usage:usage];
    … …  
    279287}
    280288
    281 void GPURenderPassEncoder::setVertexBuffer(const MTLBuffer *buffer, unsigned offset, unsigned index)
    282 {
    283     ASSERT(m_platformRenderPassEncoder);
    284 
     289void 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    }
    285295    BEGIN_BLOCK_OBJC_EXCEPTIONS;
    286296    [m_platformRenderPassEncoder setVertexBuffer:buffer offset:offset atIndex:index];
    … …  
    288298}
    289299
    290 void GPURenderPassEncoder::setFragmentBuffer(const MTLBuffer *buffer, unsigned offset, unsigned index)
    291 {
    292     ASSERT(m_platformRenderPassEncoder);
    293 
     300void 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    }
    294306    BEGIN_BLOCK_OBJC_EXCEPTIONS;
    295307    [m_platformRenderPassEncoder setFragmentBuffer:buffer offset:offset atIndex:index];

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

    r243419 r243457  
    2929#if ENABLE(WEBGPU)
    3030
    31 #import "GPUDevice.h"
    3231#import "GPULimits.h"
    3332#import "GPUUtils.h"
    … …  
    443442    : m_depthStencilState(WTFMove(depthStencil))
    444443    , m_platformRenderPipeline(WTFMove(pipeline))
     444    , m_layout(WTFMove(descriptor.layout))
    445445    , m_primitiveTopology(descriptor.primitiveTopology)
    446446{

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

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