Changeset 250114 in webkit


Ignore:
Timestamp:
Sep 19, 2019, 6:20:31 PM (6 years ago)
Author:
Devin Rousso
Message:

Web Inspector: Canvas: show WebGPU shader pipelines
​https://bugs.webkit.org/show_bug.cgi?id=201675

Reviewed by Joseph Pecoraro.

Source/JavaScriptCore:

  • inspector/protocol/Canvas.json:

Add a ProgramType enum that conveys the type of shader program/pipeline when notifying the
frontend of a new program

Source/WebCore:

Tests: inspector/canvas/requestShaderSource-webgpu.html

inspector/canvas/shaderProgram-add-remove-webgpu.html
inspector/canvas/updateShader-webgpu.html

Create common base classes for WebGPUPipeline and GPUPipeline so that Web Inspector can
instrument both render and compute shader pipelines.

Refactor InspectorShaderProgram to support both WebGLProgram and WebGPUPipeline so
that the same object can be used for all types of shader "program"s.

Keep a copy of each shader module's source, and allow the shader module to be updated.

  • Modules/webgpu/WebGPUDevice.h:
  • Modules/webgpu/WebGPUDevice.cpp:

(WebCore::WebGPUDevice::createShaderModule const):
(WebCore::WebGPUDevice::createRenderPipeline): Added.
(WebCore::WebGPUDevice::createComputePipeline): Added.
(WebCore::WebGPUDevice::createRenderPipeline const): Deleted.
(WebCore::WebGPUDevice::createComputePipeline const): Deleted.

  • Modules/webgpu/WebGPUPipeline.h: Added.

(WebCore::WebGPUPipeline::isRenderPipeline const):
(WebCore::WebGPUPipeline::isComputePipeline const):
(WebCore::WebGPUPipeline::scriptExecutionContext const):

  • Modules/webgpu/WebGPUPipeline.cpp: Added.

(WebCore::WebGPUPipeline::instancesMutex):
(WebCore::WebGPUPipeline::WebGPUPipeline):
(WebCore::WebGPUPipeline::~WebGPUPipeline):

  • platform/graphics/gpu/GPUPipeline.cpp: Added.
  • platform/graphics/gpu/GPUPipeline.h: Added.

(WebCore::GPUPipeline::isRenderPipeline const):
(WebCore::GPUPipeline::isComputePipeline const):

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

(WebCore::WebGPUComputePipeline::computePipeline const): Deleted.

  • Modules/webgpu/WebGPUComputePipeline.cpp:

(WebCore::WebGPUComputePipeline::create):
(WebCore::WebGPUComputePipeline::WebGPUComputePipeline):
(WebCore::WebGPUComputePipeline::recompile): Added.

  • platform/graphics/gpu/GPUComputePipeline.h:

(WebCore::GPUComputePipeline::isComputePipeline): Added.

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

(WebCore::GPUComputePipeline::tryCreate):
(WebCore::GPUComputePipeline::GPUComputePipeline):
(WebCore::GPUComputePipeline::recompile): Added.

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

(WebCore::WebGPURenderPipeline::renderPipeline const): Deleted.

  • Modules/webgpu/WebGPURenderPipeline.cpp:

(WebCore::WebGPURenderPipeline::create):
(WebCore::WebGPURenderPipeline::WebGPURenderPipeline):
(WebCore::WebGPURenderPipeline::recompile): Added.

  • platform/graphics/gpu/GPURenderPipeline.h:

(WebCore::GPURenderPipeline::isRenderPipeline): Added.

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

(WebCore::tryCreateMtlRenderPipelineState):
(WebCore::GPURenderPipeline::tryCreate):
(WebCore::GPURenderPipeline::GPURenderPipeline):
(WebCore::GPURenderPipeline::recompile): Added.

  • Modules/webgpu/WebGPUShaderModule.h:

(WebCore::WebGPUShaderModule::source const): Added.

  • Modules/webgpu/WebGPUShaderModule.cpp:

(WebCore::WebGPUShaderModule::update): Added.

  • Modules/webgpu/WebGPUProgrammableStageDescriptor.h:
  • platform/graphics/gpu/GPUProgrammableStageDescriptor.h:

(WebCore::GPUProgrammableStageDescriptor::GPUProgrammableStageDescriptor):

  • inspector/InspectorShaderProgram.h:
  • inspector/InspectorShaderProgram.cpp:

(WebCore::InspectorShaderProgram::create):
(WebCore::InspectorShaderProgram::InspectorShaderProgram):
(WebCore::InspectorShaderProgram::program const): Added.
(WebCore::InspectorShaderProgram::pipeline const): Added.
(WebCore::shaderForType): Added.
(WebCore::InspectorShaderProgram::requestShaderSource): Added.
(WebCore::InspectorShaderProgram::updateShader): Added.
(WebCore::InspectorShaderProgram::context const): Deleted.
(WebCore::InspectorShaderProgram::shaderForType): Deleted.

  • inspector/agents/InspectorCanvasAgent.h:
  • inspector/agents/InspectorCanvasAgent.cpp:

(WebCore::InspectorCanvasAgent::InspectorCanvasAgent):
(WebCore::InspectorCanvasAgent::discardAgent):
(WebCore::InspectorCanvasAgent::enable):
(WebCore::InspectorCanvasAgent::disable):
(WebCore::InspectorCanvasAgent::requestShaderSource):
(WebCore::InspectorCanvasAgent::updateShader):
(WebCore::InspectorCanvasAgent::setShaderProgramDisabled):
(WebCore::InspectorCanvasAgent::setShaderProgramHighlighted):
(WebCore::InspectorCanvasAgent::frameNavigated):
(WebCore::InspectorCanvasAgent::didCreateWebGLProgram): Added.
(WebCore::InspectorCanvasAgent::willDestroyWebGLProgram): Added.
(WebCore::InspectorCanvasAgent::isWebGLProgramDisabled): Added.
(WebCore::InspectorCanvasAgent::isWebGLProgramHighlighted): Added.
(WebCore::InspectorCanvasAgent::didCreateWebGPUPipeline): Added.
(WebCore::InspectorCanvasAgent::willDestroyWebGPUPipeline): Added.
(WebCore::InspectorCanvasAgent::programDestroyedTimerFired): Added.
(WebCore::InspectorCanvasAgent::reset): Added.
(WebCore::InspectorCanvasAgent::unbindProgram):
(WebCore::InspectorCanvasAgent::findInspectorProgram):
(WebCore::InspectorCanvasAgent::didCreateProgram): Deleted.
(WebCore::InspectorCanvasAgent::willDeleteProgram): Deleted.
(WebCore::InspectorCanvasAgent::isShaderProgramDisabled): Deleted.
(WebCore::InspectorCanvasAgent::isShaderProgramHighlighted): Deleted.
(WebCore::InspectorCanvasAgent::clearCanvasData): Deleted.

  • inspector/InspectorInstrumentation.h:

(WebCore::InspectorInstrumentation::didCreateWebGLProgram): Added.
(WebCore::InspectorInstrumentation::willDestroyWebGLProgram): Added.
(WebCore::InspectorInstrumentation::isWebGLProgramDisabled): Added.
(WebCore::InspectorInstrumentation::isWebGLProgramHighlighted): Added.
(WebCore::InspectorInstrumentation::didCreateWebGPUPipeline): Added.
(WebCore::InspectorInstrumentation::willDestroyWebGPUPipeline): Added.
(WebCore::InspectorInstrumentation::didCreateProgram): Deleted.
(WebCore::InspectorInstrumentation::willDeleteProgram): Deleted.
(WebCore::InspectorInstrumentation::isShaderProgramDisabled): Deleted.
(WebCore::InspectorInstrumentation::isShaderProgramHighlighted): Deleted.

  • inspector/InspectorInstrumentation.cpp:

(WebCore::InspectorInstrumentation::didCreateWebGLProgramImpl): Added.
(WebCore::InspectorInstrumentation::willDestroyWebGLProgramImpl): Added.
(WebCore::InspectorInstrumentation::isWebGLProgramDisabledImpl): Added.
(WebCore::InspectorInstrumentation::isWebGLProgramHighlightedImpl): Added.
(WebCore::InspectorInstrumentation::didCreateWebGPUPipelineImpl): Added.
(WebCore::InspectorInstrumentation::willDestroyWebGPUPipelineImpl): Added.
(WebCore::InspectorInstrumentation::didCreateProgramImpl): Deleted.
(WebCore::InspectorInstrumentation::willDeleteProgramImpl): Deleted.
(WebCore::InspectorInstrumentation::isShaderProgramDisabledImpl): Deleted.
(WebCore::InspectorInstrumentation::isShaderProgramHighlightedImpl): Deleted.

  • html/canvas/WebGLProgram.h:
  • html/canvas/WebGLProgram.cpp:

(WebCore::WebGLProgram::WebGLProgram):
(WebCore::WebGLProgram::~WebGLProgram):

  • html/canvas/WebGLRenderingContextBase.cpp:

(WebCore::InspectorScopedShaderProgramHighlight::showHightlight):
(WebCore::WebGLRenderingContextBase::createProgram):
(WebCore::WebGLRenderingContextBase::deleteProgram):
(WebCore::WebGLRenderingContextBase::drawArrays):
(WebCore::WebGLRenderingContextBase::drawElements):
Rename WebGL program instrumentation points to be less ambiguous.

  • Sources.txt:
  • WebCore.xcodeproj/project.pbxproj:

Source/WebInspectorUI:

Show WebGPU shader pipelines ("programs") underneath each corresponding WebGPU device.

Allow editing of attached shader modules for each WebGPU shader pipeline, but don't allow
highlighting/disabling, as WebGPU pipelines don't have those capabilities/concepts yet.

  • UserInterface/Protocol/CanvasObserver.js:

(WI.CanvasObserver.prototype.programCreated):

  • UserInterface/Controllers/CanvasManager.js:

(WI.CanvasManager.prototype.programCreated):

  • UserInterface/Models/Canvas.js:

(WI.Canvas.prototype.nextShaderProgramDisplayNumberForProgramType): Added.
(WI.Canvas.prototype.nextShaderProgramDisplayNumber): Deleted.

  • UserInterface/Models/ShaderProgram.js:

(WI.ShaderProgram):
(WI.ShaderProgram.contextTypeSupportsProgramType): Added.
(WI.ShaderProgram.programTypeSupportsShaderType): Added.
(WI.ShaderProgram.prototype.get programType): Added.
(WI.ShaderProgram.prototype.get displayName):
(WI.ShaderProgram.prototype.set disabled):
(WI.ShaderProgram.prototype.requestShaderSource):
(WI.ShaderProgram.prototype.updateShader):
(WI.ShaderProgram.prototype.showHighlight):
(WI.ShaderProgram.prototype.hideHighlight):
(WI.ShaderProgram.prototype.requestVertexShaderSource): Deleted.
(WI.ShaderProgram.prototype.requestFragmentShaderSource): Deleted.
(WI.ShaderProgram.prototype.updateVertexShader): Deleted.
(WI.ShaderProgram.prototype.updateFragmentShader): Deleted.
(WI.ShaderProgram.prototype._requestShaderSource): Deleted.
(WI.ShaderProgram.prototype._updateShader): Deleted.

  • UserInterface/Views/ShaderProgramContentView.js:

(WI.ShaderProgramContentView):
(WI.ShaderProgramContentView.prototype.get navigationItems): Added.
(WI.ShaderProgramContentView.prototype.shown):
(WI.ShaderProgramContentView.prototype.hidden):
(WI.ShaderProgramContentView.prototype.get saveData):
(WI.ShaderProgramContentView.prototype._refreshContent):
(WI.ShaderProgramContentView.prototype._updateShader):
(WI.ShaderProgramContentView.prototype._contentDidChange):

  • UserInterface/Views/ShaderProgramContentView.css:

(.content-view.shader-program > .shader): Added.
(.content-view.shader-program > .shader.compute): Added.
(body[dir=ltr] .content-view.shader-program > .shader.vertex,): Added.
(body[dir=ltr] .content-view.shader-program > .shader.fragment,): Added.
(.content-view.shader-program > .shader + .shader): Added.
(.content-view.shader-program > .shader > header > *): Added.
(.content-view.shader-program > .shader > header > .shader-type): Added.
(@media (prefers-color-scheme: dark) .content-view.shader-program > .shader > header): Added.
(.content-view.shader-program > .text-editor.shader): Deleted.
(body[dir=ltr] .content-view.shader-program > .text-editor.shader.vertex,): Deleted.
(body[dir=ltr] .content-view.shader-program > .text-editor.shader.fragment,): Deleted.
(body[dir=ltr] .content-view.shader-program > .text-editor.shader + .text-editor.shader): Deleted.
(body[dir=rtl] .content-view.shader-program > .text-editor.shader + .text-editor.shader): Deleted.
(.content-view.shader-program > .text-editor.shader > .type-title): Deleted.
(.content-view.shader-program > .text-editor.shader > .CodeMirror): Deleted.

  • UserInterface/Views/CodeMirrorAdditions.js:
  • UserInterface/Views/ShaderProgramTreeElement.js:

(WI.ShaderProgramTreeElement):
(WI.ShaderProgramTreeElement.prototype.onattach):
(WI.ShaderProgramTreeElement.prototype.ondetach):
(WI.ShaderProgramTreeElement.prototype.canSelectOnMouseDown):
(WI.ShaderProgramTreeElement.prototype.populateContextMenu):

  • Localizations/en.lproj/localizedStrings.js:

LayoutTests:

Split existing shader tests into WebGL and WebGPU sub-tests for different platforms.

  • inspector/canvas/requestShaderSource.html:
  • inspector/canvas/requestShaderSource-expected.txt:
  • inspector/canvas/updateShader.html:
  • inspector/canvas/updateShader-expected.txt:
  • inspector/canvas/resources/shaderProgram-utilities-webgpu.js: Added.
  • inspector/canvas/requestShaderSource-webgpu.html: Added.
  • inspector/canvas/requestShaderSource-webgpu-expected.txt: Added.
  • inspector/canvas/shaderProgram-add-remove-webgpu.html: Added.
  • inspector/canvas/shaderProgram-add-remove-webgpu-expected.txt: Added.
  • inspector/canvas/updateShader-webgpu-expected.txt: Added.
  • inspector/canvas/updateShader-webgpu.html: Added.
  • inspector/canvas/resources/shaderProgram-utilities-webgl.js: Renamed from LayoutTests/inspector/canvas/resources/shaderProgram-utilities.js.
  • inspector/canvas/console-record-webgl.html:
  • inspector/canvas/console-record-webgl2.html:
  • inspector/canvas/recording-webgl-frameCount.html:
  • inspector/canvas/recording-webgl-full.html:
  • inspector/canvas/recording-webgl-memoryLimit.html:
  • inspector/canvas/recording-webgl-snapshots.html:
  • inspector/canvas/recording-webgl2-frameCount.html:
  • inspector/canvas/recording-webgl2-full.html:
  • inspector/canvas/recording-webgl2-memoryLimit.html:
  • inspector/canvas/recording-webgl2-snapshots.html:
  • inspector/canvas/requestShaderSource-webgl.html: Added.
  • inspector/canvas/requestShaderSource-webgl-expected.txt: Added.
  • inspector/canvas/setShaderProgramDisabled.html:
  • inspector/canvas/setShaderProgramHighlighted.html:
  • inspector/canvas/shaderProgram-add-remove-webgl.html:
  • inspector/canvas/shaderProgram-add-remove-webgl2.html:
  • inspector/canvas/updateShader-webgl.html: Added.
  • inspector/canvas/updateShader-webgl-expected.txt: Added.
  • platform/gtk/TestExpectations:
  • platform/ios/TestExpectations:
  • platform/mac-wk1/TestExpectations:
  • platform/mac/TestExpectations:
  • platform/win/TestExpectations:
  • platform/wincairo/TestExpectations:
  • platform/wpe/TestExpectations:
Location:
trunk
Files:
9 added
66 edited
6 copied
1 moved

Legend:

Unmodified
Added
Removed

  • trunk/LayoutTests/ChangeLog

    r250103 r250114  
     12019-09-19  Devin Rousso  <drousso@apple.com>
     2
     3        Web Inspector: Canvas: show WebGPU shader pipelines
     4        https://bugs.webkit.org/show_bug.cgi?id=201675
     5
     6        Reviewed by Joseph Pecoraro.
     7
     8        Split existing shader tests into WebGL and WebGPU sub-tests for different platforms.
     9
     10        * inspector/canvas/requestShaderSource.html:
     11        * inspector/canvas/requestShaderSource-expected.txt:
     12        * inspector/canvas/updateShader.html:
     13        * inspector/canvas/updateShader-expected.txt:
     14
     15        * inspector/canvas/resources/shaderProgram-utilities-webgpu.js: Added.
     16        * inspector/canvas/requestShaderSource-webgpu.html: Added.
     17        * inspector/canvas/requestShaderSource-webgpu-expected.txt: Added.
     18        * inspector/canvas/shaderProgram-add-remove-webgpu.html: Added.
     19        * inspector/canvas/shaderProgram-add-remove-webgpu-expected.txt: Added.
     20        * inspector/canvas/updateShader-webgpu-expected.txt: Added.
     21        * inspector/canvas/updateShader-webgpu.html: Added.
     22
     23        * inspector/canvas/resources/shaderProgram-utilities-webgl.js: Renamed from LayoutTests/inspector/canvas/resources/shaderProgram-utilities.js.
     24        * inspector/canvas/console-record-webgl.html:
     25        * inspector/canvas/console-record-webgl2.html:
     26        * inspector/canvas/recording-webgl-frameCount.html:
     27        * inspector/canvas/recording-webgl-full.html:
     28        * inspector/canvas/recording-webgl-memoryLimit.html:
     29        * inspector/canvas/recording-webgl-snapshots.html:
     30        * inspector/canvas/recording-webgl2-frameCount.html:
     31        * inspector/canvas/recording-webgl2-full.html:
     32        * inspector/canvas/recording-webgl2-memoryLimit.html:
     33        * inspector/canvas/recording-webgl2-snapshots.html:
     34        * inspector/canvas/requestShaderSource-webgl.html: Added.
     35        * inspector/canvas/requestShaderSource-webgl-expected.txt: Added.
     36        * inspector/canvas/setShaderProgramDisabled.html:
     37        * inspector/canvas/setShaderProgramHighlighted.html:
     38        * inspector/canvas/shaderProgram-add-remove-webgl.html:
     39        * inspector/canvas/shaderProgram-add-remove-webgl2.html:
     40        * inspector/canvas/updateShader-webgl.html: Added.
     41        * inspector/canvas/updateShader-webgl-expected.txt: Added.
     42
     43        * platform/gtk/TestExpectations:
     44        * platform/ios/TestExpectations:
     45        * platform/mac-wk1/TestExpectations:
     46        * platform/mac/TestExpectations:
     47        * platform/win/TestExpectations:
     48        * platform/wincairo/TestExpectations:
     49        * platform/wpe/TestExpectations:
     50
    1512019-09-19  Said Abou-Hallawa  <sabouhallawa@apple.com>
    252

  • trunk/LayoutTests/inspector/canvas/console-record-webgl.html

    r246016 r250114  
    44<script src="../../http/tests/inspector/resources/inspector-test.js"></script>
    55<script src="resources/recording-utilities.js"></script>
    6 <script src="resources/shaderProgram-utilities.js"></script>
     6<script src="resources/shaderProgram-utilities-webgl.js"></script>
    77<script id="vertex-shader" type="x-shader/x-vertex">
    88    attribute vec4 test;

  • trunk/LayoutTests/inspector/canvas/console-record-webgl2.html

    r246016 r250114  
    44<script src="../../http/tests/inspector/resources/inspector-test.js"></script>
    55<script src="resources/recording-utilities.js"></script>
    6 <script src="resources/shaderProgram-utilities.js"></script>
     6<script src="resources/shaderProgram-utilities-webgl.js"></script>
    77<script id="vertex-shader" type="x-shader/x-vertex">
    88    attribute vec4 test;

  • trunk/LayoutTests/inspector/canvas/recording-webgl-frameCount.html

    r246016 r250114  
    44<script src="../../http/tests/inspector/resources/inspector-test.js"></script>
    55<script src="resources/recording-utilities.js"></script>
    6 <script src="resources/shaderProgram-utilities.js"></script>
     6<script src="resources/shaderProgram-utilities-webgl.js"></script>
    77<script id="vertex-shader" type="x-shader/x-vertex">
    88    attribute vec4 test;

  • trunk/LayoutTests/inspector/canvas/recording-webgl-full.html

    r246016 r250114  
    44<script src="../../http/tests/inspector/resources/inspector-test.js"></script>
    55<script src="resources/recording-utilities.js"></script>
    6 <script src="resources/shaderProgram-utilities.js"></script>
     6<script src="resources/shaderProgram-utilities-webgl.js"></script>
    77<script id="vertex-shader" type="x-shader/x-vertex">
    88    attribute vec4 test;

  • trunk/LayoutTests/inspector/canvas/recording-webgl-memoryLimit.html

    r246016 r250114  
    44<script src="../../http/tests/inspector/resources/inspector-test.js"></script>
    55<script src="resources/recording-utilities.js"></script>
    6 <script src="resources/shaderProgram-utilities.js"></script>
     6<script src="resources/shaderProgram-utilities-webgl.js"></script>
    77<script id="vertex-shader" type="x-shader/x-vertex">
    88    attribute vec4 test;

  • trunk/LayoutTests/inspector/canvas/recording-webgl-snapshots.html

    r246015 r250114  
    44<script src="../../http/tests/inspector/resources/inspector-test.js"></script>
    55<script src="resources/recording-utilities.js"></script>
    6 <script src="resources/shaderProgram-utilities.js"></script>
     6<script src="resources/shaderProgram-utilities-webgl.js"></script>
    77<script id="vertex-shader" type="x-shader/x-vertex">
    88    attribute vec3 position;

  • trunk/LayoutTests/inspector/canvas/recording-webgl2-frameCount.html

    r246016 r250114  
    44<script src="../../http/tests/inspector/resources/inspector-test.js"></script>
    55<script src="resources/recording-utilities.js"></script>
    6 <script src="resources/shaderProgram-utilities.js"></script>
     6<script src="resources/shaderProgram-utilities-webgl.js"></script>
    77<script id="vertex-shader" type="x-shader/x-vertex">
    88    attribute vec4 test;

  • trunk/LayoutTests/inspector/canvas/recording-webgl2-full.html

    r246016 r250114  
    44<script src="../../http/tests/inspector/resources/inspector-test.js"></script>
    55<script src="resources/recording-utilities.js"></script>
    6 <script src="resources/shaderProgram-utilities.js"></script>
     6<script src="resources/shaderProgram-utilities-webgl.js"></script>
    77<script id="vertex-shader" type="x-shader/x-vertex">
    88    attribute vec4 test;

  • trunk/LayoutTests/inspector/canvas/recording-webgl2-memoryLimit.html

    r246016 r250114  
    44<script src="../../http/tests/inspector/resources/inspector-test.js"></script>
    55<script src="resources/recording-utilities.js"></script>
    6 <script src="resources/shaderProgram-utilities.js"></script>
     6<script src="resources/shaderProgram-utilities-webgl.js"></script>
    77<script id="vertex-shader" type="x-shader/x-vertex">
    88    attribute vec4 test;

  • trunk/LayoutTests/inspector/canvas/recording-webgl2-snapshots.html

    r246015 r250114  
    44<script src="../../http/tests/inspector/resources/inspector-test.js"></script>
    55<script src="resources/recording-utilities.js"></script>
    6 <script src="resources/shaderProgram-utilities.js"></script>
     6<script src="resources/shaderProgram-utilities-webgl.js"></script>
    77<script id="vertex-shader" type="x-shader/x-vertex">
    88    attribute vec3 position;

  • trunk/LayoutTests/inspector/canvas/requestShaderSource-expected.txt

    r249128 r250114  
    1 Test compilation of shaders after being attached to a program, with and without syntax errors.
     1Common tests for Canvas.requestShaderSource command.
    22
    33
    4 == Running test suite: Canvas.getShaderSource
    5 -- Running test case: Canvas.requestShaderSource.vertexShader
    6 
    7     void main(void) {
    8         gl_Position = vec4(0.0, 0.0, 0.0, 1.0);
    9     }
    10 
    11 
    12 -- Running test case: Canvas.requestShaderSource.fragmentShader
    13 
    14     precision mediump float;
    15 
    16     void main(void) {
    17         gl_FragColor = vec4(1.0, 1.0, 1.0, 1.0);
    18     }
    19 
    20 
    21 -- Running test case: Canvas.requestShaderSource.invalidProgramId
     4== Running test suite: Canvas.requestShaderSource
     5-- Running test case: Canvas.requestShaderSource.ProgramId.Invalid
    226PASS: Should produce an error.
    237Error: Missing program for given programId
    248
    25 -- Running test case: Canvas.requestShaderSource.invalidShaderType
    26 PASS: Should produce an error.
    27 Error: Missing shader for given shaderType
    28 

  • trunk/LayoutTests/inspector/canvas/requestShaderSource-webgl.html

    r250113 r250114  
    33<head>
    44<script src="../../http/tests/inspector/resources/inspector-test.js"></script>
    5 <script src="resources/shaderProgram-utilities.js"></script>
     5<script src="resources/shaderProgram-utilities-webgl.js"></script>
    66<script id="vertex-shader" type="x-shader/x-vertex">
    77    void main(void) {
    … …  
    2525
    2626function test() {
    27     let suite = InspectorTest.createAsyncSuite("Canvas.getShaderSource");
     27    let suite = InspectorTest.createAsyncSuite("Canvas.requestShaderSource.WebGL");
    2828
    2929    suite.addTestCase({
    30         name: "Canvas.requestShaderSource.vertexShader",
     30        name: "Canvas.requestShaderSource.WebGL.Vertex",
    3131        description: "Tests requesting the source code of a program's vertex shader.",
    3232        test(resolve, reject) {
    … …  
    3838
    3939            CanvasAgent.requestShaderSource(shaderProgram.identifier, CanvasAgent.ShaderType.Vertex)
    40             .then(({content}) => InspectorTest.log(content))
     40            .then(({source}) => InspectorTest.log(source))
    4141            .then(resolve, reject);
    4242        }
    … …  
    4444
    4545    suite.addTestCase({
    46         name: "Canvas.requestShaderSource.fragmentShader",
     46        name: "Canvas.requestShaderSource.WebGL.Fragment",
    4747        description: "Tests requesting the source code of a program's fragment shader.",
    4848        test(resolve, reject) {
    … …  
    5454
    5555            CanvasAgent.requestShaderSource(shaderProgram.identifier, CanvasAgent.ShaderType.Fragment)
    56             .then(({content}) => InspectorTest.log(content))
     56            .then(({source}) => InspectorTest.log(source))
    5757            .then(resolve, reject);
    5858        }
    … …  
    6060
    6161    suite.addTestCase({
    62         name: "Canvas.requestShaderSource.invalidProgramId",
    63         description: "Invalid program identifiers should cause an error.",
    64         test(resolve, reject) {
    65             const programId = "INVALID_PROGRAM_ID";
    66             const shaderType = "INVALID_SHADER_TYPE";
    67             CanvasAgent.requestShaderSource(programId, shaderType, (error) => {
    68                 InspectorTest.expectThat(error, "Should produce an error.");
    69                 InspectorTest.log("Error: " + error);
    70                 resolve();
    71             });
    72         }
    73     });
    74 
    75     suite.addTestCase({
    76         name: "Canvas.requestShaderSource.invalidShaderType",
     62        name: "Canvas.requestShaderSource.WebGL.ShaderType.Invalid",
    7763        description: "Invalid shader types should cause an error.",
    7864        test(resolve, reject) {
    … …  
    9783</head>
    9884<body onload="load()">
    99     <p>Test compilation of shaders after being attached to a program, with and without syntax errors.</p>
     85<p>WebGL tests for Canvas.requestShaderSource command.</p>
    10086</body>
    10187</html>

  • trunk/LayoutTests/inspector/canvas/requestShaderSource.html

    r220294 r250114  
    33<head>
    44<script src="../../http/tests/inspector/resources/inspector-test.js"></script>
    5 <script src="resources/shaderProgram-utilities.js"></script>
    6 <script id="vertex-shader" type="x-shader/x-vertex">
    7     void main(void) {
    8         gl_Position = vec4(0.0, 0.0, 0.0, 1.0);
    9     }
    10 </script>
    11 <script id="fragment-shader" type="x-shader/x-fragment">
    12     precision mediump float;
    13 
    14     void main(void) {
    15         gl_FragColor = vec4(1.0, 1.0, 1.0, 1.0);
    16     }
    17 </script>
    185<script>
    19 function load() {
    20     createProgram("webgl");
    21     linkProgram("vertex-shader", "fragment-shader");
    22 
    23     runTest();
    24 }
    25 
    266function test() {
    27     let suite = InspectorTest.createAsyncSuite("Canvas.getShaderSource");
     7    let suite = InspectorTest.createAsyncSuite("Canvas.requestShaderSource");
    288
    299    suite.addTestCase({
    30         name: "Canvas.requestShaderSource.vertexShader",
    31         description: "Tests requesting the source code of a program's vertex shader.",
    32         test(resolve, reject) {
    33             let shaderProgram = WI.canvasManager.shaderPrograms[0];
    34             if (!shaderProgram) {
    35                 reject("Missing shader program")
    36                 return;
    37             }
    38 
    39             CanvasAgent.requestShaderSource(shaderProgram.identifier, CanvasAgent.ShaderType.Vertex)
    40             .then(({content}) => InspectorTest.log(content))
    41             .then(resolve, reject);
    42         }
    43     });
    44 
    45     suite.addTestCase({
    46         name: "Canvas.requestShaderSource.fragmentShader",
    47         description: "Tests requesting the source code of a program's fragment shader.",
    48         test(resolve, reject) {
    49             let shaderProgram = WI.canvasManager.shaderPrograms[0];
    50             if (!shaderProgram) {
    51                 reject("Missing shader program")
    52                 return;
    53             }
    54 
    55             CanvasAgent.requestShaderSource(shaderProgram.identifier, CanvasAgent.ShaderType.Fragment)
    56             .then(({content}) => InspectorTest.log(content))
    57             .then(resolve, reject);
    58         }
    59     });
    60 
    61     suite.addTestCase({
    62         name: "Canvas.requestShaderSource.invalidProgramId",
     10        name: "Canvas.requestShaderSource.ProgramId.Invalid",
    6311        description: "Invalid program identifiers should cause an error.",
    6412        test(resolve, reject) {
    … …  
    7321    });
    7422
    75     suite.addTestCase({
    76         name: "Canvas.requestShaderSource.invalidShaderType",
    77         description: "Invalid shader types should cause an error.",
    78         test(resolve, reject) {
    79             let shaderProgram = WI.canvasManager.shaderPrograms[0];
    80             if (!shaderProgram) {
    81                 reject("Missing shader program")
    82                 return;
    83             }
    84 
    85             const shaderType = "INVALID_SHADER_TYPE";
    86             CanvasAgent.requestShaderSource(shaderProgram.identifier, shaderType, (error) => {
    87                 InspectorTest.expectThat(error, "Should produce an error.");
    88                 InspectorTest.log("Error: " + error);
    89                 resolve();
    90             });
    91         }
    92     });
    93 
    9423    suite.runTestCasesAndFinish();
    9524}
    9625</script>
    9726</head>
    98 <body onload="load()">
    99     <p>Test compilation of shaders after being attached to a program, with and without syntax errors.</p>
     27<body onload="runTest()">
     28<p>Common tests for Canvas.requestShaderSource command.</p>
    10029</body>
    10130</html>

  • trunk/LayoutTests/inspector/canvas/setShaderProgramDisabled.html

    r221025 r250114  
    33<head>
    44<script src="../../http/tests/inspector/resources/inspector-test.js"></script>
    5 <script src="resources/shaderProgram-utilities.js"></script>
     5<script src="resources/shaderProgram-utilities-webgl.js"></script>
    66<script id="vertex-shader" type="x-shader/x-vertex">
    77    attribute vec3 position;

  • trunk/LayoutTests/inspector/canvas/setShaderProgramHighlighted.html

    r242225 r250114  
    33<head>
    44<script src="../../http/tests/inspector/resources/inspector-test.js"></script>
    5 <script src="resources/shaderProgram-utilities.js"></script>
     5<script src="resources/shaderProgram-utilities-webgl.js"></script>
    66<script id="vertex-shader" type="x-shader/x-vertex">
    77    attribute vec3 position;

  • trunk/LayoutTests/inspector/canvas/shaderProgram-add-remove-webgl.html

    r220233 r250114  
    33<head>
    44<script src="../../http/tests/inspector/resources/inspector-test.js"></script>
    5 <script src="resources/shaderProgram-utilities.js"></script>
     5<script src="resources/shaderProgram-utilities-webgl.js"></script>
    66<script>
    77function test() {

  • trunk/LayoutTests/inspector/canvas/shaderProgram-add-remove-webgl2.html

    r220233 r250114  
    33<head>
    44<script src="../../http/tests/inspector/resources/inspector-test.js"></script>
    5 <script src="resources/shaderProgram-utilities.js"></script>
     5<script src="resources/shaderProgram-utilities-webgl.js"></script>
    66<script>
    77if (window.internals)

  • trunk/LayoutTests/inspector/canvas/updateShader-expected.txt

    r249128 r250114  
    1 CONSOLE MESSAGE: WebGL: ERROR: 0:1: 'INVALID' : syntax error
    2 CONSOLE MESSAGE: WebGL: ERROR: 0:1: 'INVALID' : syntax error
    3 Test compilation of shaders after being attached to a program, with and without syntax errors.
     1Common tests for Canvas.updateShader command.
    42
    53
    64== Running test suite: Canvas.updateShader
    7 -- Running test case: Canvas.updateShader.vertexShaderValid
    8 
    9     void main(void) {
    10         gl_Position = vec4(1, 2, 3, 4);
    11     }
    12 
    13 
    14 -- Running test case: Canvas.updateShader.fragmentShaderValid
    15 
    16     precision mediump float;
    17 
    18     void main(void) {
    19         gl_FragColor = vec4(0.1, 0.2, 0.3, 0.4);
    20     }
    21 
    22 
    23 -- Running test case: Canvas.updateShader.invalidProgramId
     5-- Running test case: Canvas.updateShader.ProgramId.Invalid
    246PASS: Should produce an error.
    257Error: Missing program for given programId
    268
    27 -- Running test case: Canvas.updateShader.invalidShaderType
    28 PASS: Should produce an error.
    29 Error: Missing shader for given shaderType
    30 
    31 -- Running test case: Canvas.updateShader.invalidVertexShaderSource
    32 PASS: Should produce error.
    33 Error: Failed to update shader
    34 
    35 -- Running test case: Canvas.updateShader.invalidFragmentShaderSource
    36 PASS: Should produce error.
    37 Error: Failed to update shader
    38 

  • trunk/LayoutTests/inspector/canvas/updateShader-webgl.html

    r250113 r250114  
    33<head>
    44<script src="../../http/tests/inspector/resources/inspector-test.js"></script>
    5 <script src="resources/shaderProgram-utilities.js"></script>
     5<script src="resources/shaderProgram-utilities-webgl.js"></script>
    66<script id="vertex-shader" type="x-shader/x-vertex">
    77    void main(void) {
    … …  
    2525
    2626function test() {
    27     let suite = InspectorTest.createAsyncSuite("Canvas.updateShader");
     27    let suite = InspectorTest.createAsyncSuite("Canvas.updateShader.WebGL");
    2828
    2929    function validSourceTest({name, shaderType, source}) {
    … …  
    4141                CanvasAgent.updateShader(programId, shaderType, source)
    4242                .then(() => CanvasAgent.requestShaderSource(programId, shaderType))
    43                 .then(({content}) => InspectorTest.log(content))
     43                .then(({source}) => InspectorTest.log(source))
    4444                .then(resolve, reject);
    4545            }
    … …  
    4848
    4949    validSourceTest({
    50         name: "Canvas.updateShader.vertexShaderValid",
     50        name: "Canvas.updateShader.WebGL.Vertex.Valid",
    5151        shaderType: CanvasAgent.ShaderType.Vertex,
    5252        source: `
    … …  
    5858
    5959    validSourceTest({
    60         name: "Canvas.updateShader.fragmentShaderValid",
     60        name: "Canvas.updateShader.WebGL.Fragment.Valid",
    6161        shaderType: CanvasAgent.ShaderType.Fragment,
    6262        source: `
    … …  
    6767    }
    6868`,
    69     });
    70 
    71     suite.addTestCase({
    72         name: "Canvas.updateShader.invalidProgramId",
    73         description: "Invalid program identifiers should cause an error.",
    74         test(resolve, reject) {
    75             const programId = "INVALID_PROGRAM_ID";
    76             const shaderType = "INVALID_SHADER_TYPE";
    77             const source = "INVALID_SOURCE";
    78             CanvasAgent.updateShader(programId, shaderType, source, (error) => {
    79                 InspectorTest.expectThat(error, "Should produce an error.");
    80                 InspectorTest.log("Error: " + error);
    81                 resolve();
    82             });
    83         }
    84     });
    85 
    86     suite.addTestCase({
    87         name: "Canvas.updateShader.invalidShaderType",
    88         description: "Invalid shader types should cause an error.",
    89         test(resolve, reject) {
    90             let shaderProgram = WI.canvasManager.shaderPrograms[0];
    91             if (!shaderProgram) {
    92                 reject("Missing shader program")
    93                 return;
    94             }
    95 
    96             const shaderType = "INVALID_SHADER_TYPE";
    97             const source = "INVALID_SOURCE";
    98             CanvasAgent.updateShader(shaderProgram.identifier, shaderType, source, (error) => {
    99                 InspectorTest.expectThat(error, "Should produce an error.");
    100                 InspectorTest.log("Error: " + error);
    101                 resolve();
    102             });
    103         }
    10469    });
    10570
    … …  
    12489
    12590    invalidSourceTest({
    126         name: "Canvas.updateShader.invalidVertexShaderSource",
     91        name: "Canvas.updateShader.WebGL.Vertex.Invalid",
    12792        shaderType: CanvasAgent.ShaderType.Vertex,
    12893        source: "INVALID",
    … …  
    13095
    13196    invalidSourceTest({
    132         name: "Canvas.updateShader.invalidFragmentShaderSource",
     97        name: "Canvas.updateShader.WebGL.Fragment.Invalid",
    13398        shaderType: CanvasAgent.ShaderType.Fragment,
    13499        source: "INVALID",
     100    });
     101
     102    suite.addTestCase({
     103        name: "Canvas.updateShader.WebGL.ShaderType.Invalid",
     104        description: "Invalid shader types should cause an error.",
     105        test(resolve, reject) {
     106            let shaderProgram = WI.canvasManager.shaderPrograms[0];
     107            if (!shaderProgram) {
     108                reject("Missing shader program")
     109                return;
     110            }
     111
     112            const shaderType = "INVALID_SHADER_TYPE";
     113            const source = "INVALID_SOURCE";
     114            CanvasAgent.updateShader(shaderProgram.identifier, shaderType, source, (error) => {
     115                InspectorTest.expectThat(error, "Should produce an error.");
     116                InspectorTest.log("Error: " + error);
     117                resolve();
     118            });
     119        }
    135120    });
    136121
    … …  
    140125</head>
    141126<body onload="load()">
    142     <p>Test compilation of shaders after being attached to a program, with and without syntax errors.</p>
     127<p>WebGL tests for Canvas.updateShader command.</p>
    143128</body>
    144129</html>

  • trunk/LayoutTests/inspector/canvas/updateShader.html

    r220436 r250114  
    33<head>
    44<script src="../../http/tests/inspector/resources/inspector-test.js"></script>
    5 <script src="resources/shaderProgram-utilities.js"></script>
    6 <script id="vertex-shader" type="x-shader/x-vertex">
    7     void main(void) {
    8         gl_Position = vec4(0.0, 0.0, 0.0, 1.0);
    9     }
    10 </script>
    11 <script id="fragment-shader" type="x-shader/x-fragment">
    12     precision mediump float;
    13 
    14     void main(void) {
    15         gl_FragColor = vec4(1.0, 1.0, 1.0, 1.0);
    16     }
    17 </script>
    185<script>
    19 function load() {
    20     createProgram("webgl");
    21     linkProgram("vertex-shader", "fragment-shader");
    22 
    23     runTest();
    24 }
    25 
    266function test() {
    277    let suite = InspectorTest.createAsyncSuite("Canvas.updateShader");
    288
    29     function validSourceTest({name, shaderType, source}) {
    30         suite.addTestCase({
    31             name,
    32             test(resolve, reject) {
    33                 let shaderProgram = WI.canvasManager.shaderPrograms[0];
    34                 if (!shaderProgram) {
    35                     reject("Missing shader program")
    36                     return;
    37                 }
    38 
    39                 let programId = shaderProgram.identifier;
    40 
    41                 CanvasAgent.updateShader(programId, shaderType, source)
    42                 .then(() => CanvasAgent.requestShaderSource(programId, shaderType))
    43                 .then(({content}) => InspectorTest.log(content))
    44                 .then(resolve, reject);
    45             }
    46         });
    47     }
    48 
    49     validSourceTest({
    50         name: "Canvas.updateShader.vertexShaderValid",
    51         shaderType: CanvasAgent.ShaderType.Vertex,
    52         source: `
    53     void main(void) {
    54         gl_Position = vec4(1, 2, 3, 4);
    55     }
    56 `,
    57     });
    58 
    59     validSourceTest({
    60         name: "Canvas.updateShader.fragmentShaderValid",
    61         shaderType: CanvasAgent.ShaderType.Fragment,
    62         source: `
    63     precision mediump float;
    64 
    65     void main(void) {
    66         gl_FragColor = vec4(0.1, 0.2, 0.3, 0.4);
    67     }
    68 `,
    69     });
    70 
    719    suite.addTestCase({
    72         name: "Canvas.updateShader.invalidProgramId",
     10        name: "Canvas.updateShader.ProgramId.Invalid",
    7311        description: "Invalid program identifiers should cause an error.",
    7412        test(resolve, reject) {
    … …  
    8422    });
    8523
    86     suite.addTestCase({
    87         name: "Canvas.updateShader.invalidShaderType",
    88         description: "Invalid shader types should cause an error.",
    89         test(resolve, reject) {
    90             let shaderProgram = WI.canvasManager.shaderPrograms[0];
    91             if (!shaderProgram) {
    92                 reject("Missing shader program")
    93                 return;
    94             }
    95 
    96             const shaderType = "INVALID_SHADER_TYPE";
    97             const source = "INVALID_SOURCE";
    98             CanvasAgent.updateShader(shaderProgram.identifier, shaderType, source, (error) => {
    99                 InspectorTest.expectThat(error, "Should produce an error.");
    100                 InspectorTest.log("Error: " + error);
    101                 resolve();
    102             });
    103         }
    104     });
    105 
    106     function invalidSourceTest({name, shaderType, source}) {
    107         suite.addTestCase({
    108             name,
    109             test(resolve, reject) {
    110                 let shaderProgram = WI.canvasManager.shaderPrograms[0];
    111                 if (!shaderProgram) {
    112                     reject("Missing shader program")
    113                     return;
    114                 }
    115 
    116                 CanvasAgent.updateShader(shaderProgram.identifier, shaderType, source, (error) => {
    117                     InspectorTest.expectThat(error, "Should produce error.");
    118                     InspectorTest.log("Error: " + error);
    119                     resolve();
    120                 });
    121             }
    122         });
    123     }
    124 
    125     invalidSourceTest({
    126         name: "Canvas.updateShader.invalidVertexShaderSource",
    127         shaderType: CanvasAgent.ShaderType.Vertex,
    128         source: "INVALID",
    129     });
    130 
    131     invalidSourceTest({
    132         name: "Canvas.updateShader.invalidFragmentShaderSource",
    133         shaderType: CanvasAgent.ShaderType.Fragment,
    134         source: "INVALID",
    135     });
    136 
    13724    suite.runTestCasesAndFinish();
    13825}
    13926</script>
    14027</head>
    141 <body onload="load()">
    142     <p>Test compilation of shaders after being attached to a program, with and without syntax errors.</p>
     28<body onload="runTest()">
     29<p>Common tests for Canvas.updateShader command.</p>
    14330</body>
    14431</html>

  • trunk/LayoutTests/platform/gtk/TestExpectations

    r250090 r250114  
    11511151webkit.org/b/191005 inspector/canvas/create-context-webgpu.html [ Skip ]
    11521152webkit.org/b/191005 inspector/canvas/requestClientNodes-webgpu.html [ Skip ]
     1153webkit.org/b/191005 inspector/canvas/requestShaderSource-webgpu.html [ Skip ]
    11531154webkit.org/b/191005 inspector/canvas/resolveContext-webgpu.html [ Skip ]
     1155webkit.org/b/191005 inspector/canvas/shaderProgram-add-remove-webgpu.html [ Skip ]
     1156webkit.org/b/191005 inspector/canvas/updateShader-webgpu.html [ Skip ]
    11541157
    11551158# No support for resource load statistics yet

  • trunk/LayoutTests/platform/ios/TestExpectations

    r250055 r250114  
    4646inspector/canvas/create-context-webgpu.html [ Skip ]
    4747inspector/canvas/requestClientNodes-webgpu.html [ Skip ]
     48inspector/canvas/requestShaderSource-webgpu.html [ Skip ]
    4849inspector/canvas/resolveContext-webgpu.html [ Skip ]
     50inspector/canvas/shaderProgram-add-remove-webgpu.html [ Skip ]
     51inspector/canvas/updateShader-webgpu.html [ Skip ]
    4952
    5053# Encrypted Media Extensions are not enabled

  • trunk/LayoutTests/platform/mac-wk1/TestExpectations

    r249870 r250114  
    4848inspector/canvas/create-context-webgpu.html [ Skip ]
    4949inspector/canvas/requestClientNodes-webgpu.html [ Skip ]
     50inspector/canvas/requestShaderSource-webgpu.html [ Skip ]
    5051inspector/canvas/resolveContext-webgpu.html [ Skip ]
     52inspector/canvas/shaderProgram-add-remove-webgpu.html [ Skip ]
     53inspector/canvas/updateShader-webgpu.html [ Skip ]
    5154
    5255# Media Stream API testing is not supported for WK1 yet.

  • trunk/LayoutTests/platform/mac/TestExpectations

    r250044 r250114  
    17821782webkit.org/b/199275 [ HighSierra ] inspector/canvas/create-context-webgpu.html [ Skip ]
    17831783webkit.org/b/199275 [ HighSierra ] inspector/canvas/requestClientNodes-webgpu.html [ Skip ]
     1784webkit.org/b/199275 [ HighSierra ] inspector/canvas/requestShaderSource-webgpu.html [ Skip ]
    17841785webkit.org/b/199275 [ HighSierra ] inspector/canvas/resolveContext-webgpu.html [ Skip ]
     1786webkit.org/b/199275 [ HighSierra ] inspector/canvas/shaderProgram-add-remove-webgpu.html [ Skip ]
     1787webkit.org/b/199275 [ HighSierra ] inspector/canvas/updateShader-webgpu.html [ Skip ]
    17851788
    17861789webkit.org/b/189680 platform/mac/media/audio-session-category-video-paused.html [ Pass Timeout ]

  • trunk/LayoutTests/platform/win/TestExpectations

    r249918 r250114  
    20022002inspector/canvas/requestContent-webgl.html [ Skip ]
    20032003inspector/canvas/requestContent-webgl2.html [ Skip ]
    2004 inspector/canvas/requestShaderSource.html [ Skip ]
     2004inspector/canvas/requestShaderSource-webgl.html [ Skip ]
    20052005inspector/canvas/resolveContext-webgl.html [ Skip ]
    20062006inspector/canvas/resolveContext-webgl2.html [ Skip ]
    20072007inspector/canvas/shaderProgram-add-remove-webgl.html [ Skip ]
    20082008inspector/canvas/shaderProgram-add-remove-webgl2.html [ Skip ]
    2009 inspector/canvas/updateShader.html [ Skip ]
     2009inspector/canvas/updateShader-webgl.html [ Skip ]
     2010
    20102011################################################################################
    20112012#################          End WebGL Issues              #######################
    … …  
    42474248inspector/canvas/create-context-webgpu.html [ Skip ]
    42484249inspector/canvas/requestClientNodes-webgpu.html [ Skip ]
     4250inspector/canvas/requestShaderSource-webgpu.html [ Skip ]
    42494251inspector/canvas/resolveContext-webgpu.html [ Skip ]
     4252inspector/canvas/shaderProgram-add-remove-webgpu.html [ Skip ]
     4253inspector/canvas/updateShader-webgpu.html [ Skip ]
    42504254
    42514255webkit.org/b/191194 fast/block/basic/inline-content-with-floating-image.html [ Failure ]

  • trunk/LayoutTests/platform/wincairo/TestExpectations

    r249918 r250114  
    299299inspector/canvas/create-context-webgpu.html [ Skip ]
    300300inspector/canvas/requestClientNodes-webgpu.html [ Skip ]
     301inspector/canvas/requestShaderSource-webgpu.html [ Skip ]
    301302inspector/canvas/resolveContext-webgpu.html [ Skip ]
     303inspector/canvas/shaderProgram-add-remove-webgpu.html [ Skip ]
     304inspector/canvas/updateShader-webgpu.html [ Skip ]
    302305
    303306# WIRELESS_PLAYBACK_TARGET is disabled

  • trunk/LayoutTests/platform/wpe/TestExpectations

    r250090 r250114  
    303303inspector/canvas/create-context-webgpu.html [ Skip ]
    304304inspector/canvas/requestClientNodes-webgpu.html [ Skip ]
     305inspector/canvas/requestShaderSource-webgpu.html [ Skip ]
    305306inspector/canvas/resolveContext-webgpu.html [ Skip ]
     307inspector/canvas/shaderProgram-add-remove-webgpu.html [ Skip ]
     308inspector/canvas/updateShader-webgpu.html [ Skip ]
    306309
    307310# Skipped due to untestable DRM key system. ClearKey counterparts are tested instead.

  • trunk/Source/JavaScriptCore/ChangeLog

    r250112 r250114  
     12019-09-19  Devin Rousso  <drousso@apple.com>
     2
     3        Web Inspector: Canvas: show WebGPU shader pipelines
     4        https://bugs.webkit.org/show_bug.cgi?id=201675
     5
     6        Reviewed by Joseph Pecoraro.
     7
     8        * inspector/protocol/Canvas.json:
     9        Add a `ProgramType` enum that conveys the type of shader program/pipeline when notifying the
     10        frontend of a new program
     11
    1122019-09-19  Mark Lam  <mark.lam@apple.com>
    213

  • trunk/Source/JavaScriptCore/inspector/protocol/Canvas.json

    r249786 r250114  
    2121        },
    2222        {
     23            "id": "ProgramType",
     24            "type": "string",
     25            "enum": ["compute", "render"]
     26        },
     27        {
    2328            "id": "ShaderType",
    2429            "type": "string",
    25             "enum": ["fragment", "vertex"],
    26             "description": "Shader type. WebGL supports vertex and fragment shaders."
     30            "enum": ["compute", "fragment", "vertex"]
    2731        },
    2832        {
    … …  
    137141            ],
    138142            "returns": [
    139                 { "name": "content", "type": "string" }
     143                { "name": "source", "type": "string" }
    140144            ]
    141145        },
    … …  
    224228            "name": "programCreated",
    225229            "parameters": [
    226                 { "name": "canvasId", "$ref": "CanvasId", "description": "Canvas identifier." },
    227                 { "name": "programId", "$ref": "ProgramId", "description": "Program identifier." }
     230                { "name": "canvasId", "$ref": "CanvasId"} ,
     231                { "name": "programId", "$ref": "ProgramId" },
     232                { "name": "programType", "$ref": "ProgramType" }
    228233            ]
    229234        },
    … …  
    231236            "name": "programDeleted",
    232237            "parameters": [
    233                 { "name": "programId", "$ref": "ProgramId", "description": "Program identifier." }
     238                { "name": "programId", "$ref": "ProgramId" }
    234239            ]
    235240        }

  • trunk/Source/WebCore/ChangeLog

    r250104 r250114  
     12019-09-19  Devin Rousso  <drousso@apple.com>
     2
     3        Web Inspector: Canvas: show WebGPU shader pipelines
     4        https://bugs.webkit.org/show_bug.cgi?id=201675
     5
     6        Reviewed by Joseph Pecoraro.
     7
     8        Tests: inspector/canvas/requestShaderSource-webgpu.html
     9               inspector/canvas/shaderProgram-add-remove-webgpu.html
     10               inspector/canvas/updateShader-webgpu.html
     11
     12        Create common base classes for `WebGPUPipeline` and `GPUPipeline` so that Web Inspector can
     13        instrument both render and compute shader pipelines.
     14
     15        Refactor `InspectorShaderProgram` to support both `WebGLProgram` and `WebGPUPipeline` so
     16        that the same object can be used for all types of shader "program"s.
     17
     18        Keep a copy of each shader module's source, and allow the shader module to be updated.
     19
     20        * Modules/webgpu/WebGPUDevice.h:
     21        * Modules/webgpu/WebGPUDevice.cpp:
     22        (WebCore::WebGPUDevice::createShaderModule const):
     23        (WebCore::WebGPUDevice::createRenderPipeline): Added.
     24        (WebCore::WebGPUDevice::createComputePipeline): Added.
     25        (WebCore::WebGPUDevice::createRenderPipeline const): Deleted.
     26        (WebCore::WebGPUDevice::createComputePipeline const): Deleted.
     27
     28        * Modules/webgpu/WebGPUPipeline.h: Added.
     29        (WebCore::WebGPUPipeline::isRenderPipeline const):
     30        (WebCore::WebGPUPipeline::isComputePipeline const):
     31        (WebCore::WebGPUPipeline::scriptExecutionContext const):
     32        * Modules/webgpu/WebGPUPipeline.cpp: Added.
     33        (WebCore::WebGPUPipeline::instancesMutex):
     34        (WebCore::WebGPUPipeline::WebGPUPipeline):
     35        (WebCore::WebGPUPipeline::~WebGPUPipeline):
     36        * platform/graphics/gpu/GPUPipeline.cpp: Added.
     37        * platform/graphics/gpu/GPUPipeline.h: Added.
     38        (WebCore::GPUPipeline::isRenderPipeline const):
     39        (WebCore::GPUPipeline::isComputePipeline const):
     40
     41        * Modules/webgpu/WebGPUComputePipeline.idl:
     42        * Modules/webgpu/WebGPUComputePipeline.h:
     43        (WebCore::WebGPUComputePipeline::computePipeline const): Deleted.
     44        * Modules/webgpu/WebGPUComputePipeline.cpp:
     45        (WebCore::WebGPUComputePipeline::create):
     46        (WebCore::WebGPUComputePipeline::WebGPUComputePipeline):
     47        (WebCore::WebGPUComputePipeline::recompile): Added.
     48        * platform/graphics/gpu/GPUComputePipeline.h:
     49        (WebCore::GPUComputePipeline::isComputePipeline): Added.
     50        * platform/graphics/gpu/cocoa/GPUComputePipelineMetal.mm:
     51        (WebCore::GPUComputePipeline::tryCreate):
     52        (WebCore::GPUComputePipeline::GPUComputePipeline):
     53        (WebCore::GPUComputePipeline::recompile): Added.
     54
     55        * Modules/webgpu/WebGPURenderPipeline.idl:
     56        * Modules/webgpu/WebGPURenderPipeline.h:
     57        (WebCore::WebGPURenderPipeline::renderPipeline const): Deleted.
     58        * Modules/webgpu/WebGPURenderPipeline.cpp:
     59        (WebCore::WebGPURenderPipeline::create):
     60        (WebCore::WebGPURenderPipeline::WebGPURenderPipeline):
     61        (WebCore::WebGPURenderPipeline::recompile): Added.
     62        * platform/graphics/gpu/GPURenderPipeline.h:
     63        (WebCore::GPURenderPipeline::isRenderPipeline): Added.
     64        * platform/graphics/gpu/cocoa/GPURenderPipelineMetal.mm:
     65        (WebCore::tryCreateMtlRenderPipelineState):
     66        (WebCore::GPURenderPipeline::tryCreate):
     67        (WebCore::GPURenderPipeline::GPURenderPipeline):
     68        (WebCore::GPURenderPipeline::recompile): Added.
     69
     70        * Modules/webgpu/WebGPUShaderModule.h:
     71        (WebCore::WebGPUShaderModule::source const): Added.
     72        * Modules/webgpu/WebGPUShaderModule.cpp:
     73        (WebCore::WebGPUShaderModule::update): Added.
     74        * Modules/webgpu/WebGPUProgrammableStageDescriptor.h:
     75        * platform/graphics/gpu/GPUProgrammableStageDescriptor.h:
     76        (WebCore::GPUProgrammableStageDescriptor::GPUProgrammableStageDescriptor):
     77
     78        * inspector/InspectorShaderProgram.h:
     79        * inspector/InspectorShaderProgram.cpp:
     80        (WebCore::InspectorShaderProgram::create):
     81        (WebCore::InspectorShaderProgram::InspectorShaderProgram):
     82        (WebCore::InspectorShaderProgram::program const): Added.
     83        (WebCore::InspectorShaderProgram::pipeline const): Added.
     84        (WebCore::shaderForType): Added.
     85        (WebCore::InspectorShaderProgram::requestShaderSource): Added.
     86        (WebCore::InspectorShaderProgram::updateShader): Added.
     87        (WebCore::InspectorShaderProgram::context const): Deleted.
     88        (WebCore::InspectorShaderProgram::shaderForType): Deleted.
     89
     90        * inspector/agents/InspectorCanvasAgent.h:
     91        * inspector/agents/InspectorCanvasAgent.cpp:
     92        (WebCore::InspectorCanvasAgent::InspectorCanvasAgent):
     93        (WebCore::InspectorCanvasAgent::discardAgent):
     94        (WebCore::InspectorCanvasAgent::enable):
     95        (WebCore::InspectorCanvasAgent::disable):
     96        (WebCore::InspectorCanvasAgent::requestShaderSource):
     97        (WebCore::InspectorCanvasAgent::updateShader):
     98        (WebCore::InspectorCanvasAgent::setShaderProgramDisabled):
     99        (WebCore::InspectorCanvasAgent::setShaderProgramHighlighted):
     100        (WebCore::InspectorCanvasAgent::frameNavigated):
     101        (WebCore::InspectorCanvasAgent::didCreateWebGLProgram): Added.
     102        (WebCore::InspectorCanvasAgent::willDestroyWebGLProgram): Added.
     103        (WebCore::InspectorCanvasAgent::isWebGLProgramDisabled): Added.
     104        (WebCore::InspectorCanvasAgent::isWebGLProgramHighlighted): Added.
     105        (WebCore::InspectorCanvasAgent::didCreateWebGPUPipeline): Added.
     106        (WebCore::InspectorCanvasAgent::willDestroyWebGPUPipeline): Added.
     107        (WebCore::InspectorCanvasAgent::programDestroyedTimerFired): Added.
     108        (WebCore::InspectorCanvasAgent::reset): Added.
     109        (WebCore::InspectorCanvasAgent::unbindProgram):
     110        (WebCore::InspectorCanvasAgent::findInspectorProgram):
     111        (WebCore::InspectorCanvasAgent::didCreateProgram): Deleted.
     112        (WebCore::InspectorCanvasAgent::willDeleteProgram): Deleted.
     113        (WebCore::InspectorCanvasAgent::isShaderProgramDisabled): Deleted.
     114        (WebCore::InspectorCanvasAgent::isShaderProgramHighlighted): Deleted.
     115        (WebCore::InspectorCanvasAgent::clearCanvasData): Deleted.
     116        * inspector/InspectorInstrumentation.h:
     117        (WebCore::InspectorInstrumentation::didCreateWebGLProgram): Added.
     118        (WebCore::InspectorInstrumentation::willDestroyWebGLProgram): Added.
     119        (WebCore::InspectorInstrumentation::isWebGLProgramDisabled): Added.
     120        (WebCore::InspectorInstrumentation::isWebGLProgramHighlighted): Added.
     121        (WebCore::InspectorInstrumentation::didCreateWebGPUPipeline): Added.
     122        (WebCore::InspectorInstrumentation::willDestroyWebGPUPipeline): Added.
     123        (WebCore::InspectorInstrumentation::didCreateProgram): Deleted.
     124        (WebCore::InspectorInstrumentation::willDeleteProgram): Deleted.
     125        (WebCore::InspectorInstrumentation::isShaderProgramDisabled): Deleted.
     126        (WebCore::InspectorInstrumentation::isShaderProgramHighlighted): Deleted.
     127        * inspector/InspectorInstrumentation.cpp:
     128        (WebCore::InspectorInstrumentation::didCreateWebGLProgramImpl): Added.
     129        (WebCore::InspectorInstrumentation::willDestroyWebGLProgramImpl): Added.
     130        (WebCore::InspectorInstrumentation::isWebGLProgramDisabledImpl): Added.
     131        (WebCore::InspectorInstrumentation::isWebGLProgramHighlightedImpl): Added.
     132        (WebCore::InspectorInstrumentation::didCreateWebGPUPipelineImpl): Added.
     133        (WebCore::InspectorInstrumentation::willDestroyWebGPUPipelineImpl): Added.
     134        (WebCore::InspectorInstrumentation::didCreateProgramImpl): Deleted.
     135        (WebCore::InspectorInstrumentation::willDeleteProgramImpl): Deleted.
     136        (WebCore::InspectorInstrumentation::isShaderProgramDisabledImpl): Deleted.
     137        (WebCore::InspectorInstrumentation::isShaderProgramHighlightedImpl): Deleted.
     138
     139        * html/canvas/WebGLProgram.h:
     140        * html/canvas/WebGLProgram.cpp:
     141        (WebCore::WebGLProgram::WebGLProgram):
     142        (WebCore::WebGLProgram::~WebGLProgram):
     143        * html/canvas/WebGLRenderingContextBase.cpp:
     144        (WebCore::InspectorScopedShaderProgramHighlight::showHightlight):
     145        (WebCore::WebGLRenderingContextBase::createProgram):
     146        (WebCore::WebGLRenderingContextBase::deleteProgram):
     147        (WebCore::WebGLRenderingContextBase::drawArrays):
     148        (WebCore::WebGLRenderingContextBase::drawElements):
     149        Rename WebGL program instrumentation points to be less ambiguous.
     150
     151        * Sources.txt:
     152        * WebCore.xcodeproj/project.pbxproj:
     153
    11542019-09-19  Chris Dumez  <cdumez@apple.com>
    2155

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

    r249881 r250114  
    2929#if ENABLE(WEBGPU)
    3030
     31#include "GPUComputePipeline.h"
     32#include "GPUErrorScopes.h"
     33#include "GPUPipeline.h"
     34#include "GPUProgrammableStageDescriptor.h"
     35#include "WebGPUDevice.h"
     36#include <wtf/Optional.h>
     37#include <wtf/Ref.h>
     38
    3139namespace WebCore {
    3240
    33 Ref<WebGPUComputePipeline> WebGPUComputePipeline::create(RefPtr<GPUComputePipeline>&& pipeline, GPUErrorScopes& errorScopes)
     41Ref<WebGPUComputePipeline> WebGPUComputePipeline::create(WebGPUDevice& device, RefPtr<GPUComputePipeline>&& pipeline, GPUErrorScopes& errorScopes, Optional<WebGPUPipeline::ShaderData> computeShader)
    3442{
    35     return adoptRef(*new WebGPUComputePipeline(WTFMove(pipeline), errorScopes));
     43    return adoptRef(*new WebGPUComputePipeline(device, WTFMove(pipeline), errorScopes, computeShader));
    3644}
    3745
    38 WebGPUComputePipeline::WebGPUComputePipeline(RefPtr<GPUComputePipeline>&& pipeline, GPUErrorScopes& errorScopes)
    39     : GPUObjectBase(makeRef(errorScopes))
    40     , m_computePipeline { WTFMove(pipeline) }
     46WebGPUComputePipeline::WebGPUComputePipeline(WebGPUDevice& device, RefPtr<GPUComputePipeline>&& pipeline, GPUErrorScopes& errorScopes, Optional<WebGPUPipeline::ShaderData> computeShader)
     47    : WebGPUPipeline(device, errorScopes)
     48    , m_computePipeline(WTFMove(pipeline))
     49    , m_computeShader(computeShader)
    4150{
     51}
     52
     53WebGPUComputePipeline::~WebGPUComputePipeline() = default;
     54
     55bool WebGPUComputePipeline::recompile(const WebGPUDevice& device)
     56{
     57    if (m_computePipeline && m_computeShader) {
     58        if (auto& webGPUComputeShaderModule = m_computeShader.value().module) {
     59            if (auto* gpuComputeShaderModule = webGPUComputeShaderModule->module()) {
     60                GPUProgrammableStageDescriptor computeStage(makeRef(*gpuComputeShaderModule), { m_computeShader.value().entryPoint });
     61                return m_computePipeline->recompile(device.device(), WTFMove(computeStage));
     62            }
     63        }
     64    }
     65    return false;
    4266}
    4367

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

    r249881 r250114  
    2828#if ENABLE(WEBGPU)
    2929
    30 #include "GPUComputePipeline.h"
    31 #include "GPUObjectBase.h"
    32 #include <wtf/RefPtr.h>
     30#include "WebGPUPipeline.h"
     31#include <wtf/Forward.h>
    3332
    3433namespace WebCore {
    3534
    36 class WebGPUComputePipeline : public GPUObjectBase {
     35class GPUComputePipeline;
     36class GPUPipeline;
     37class GPUErrorScopes;
     38class WebGPUDevice;
     39
     40class WebGPUComputePipeline final : public WebGPUPipeline {
    3741public:
    38     static Ref<WebGPUComputePipeline> create(RefPtr<GPUComputePipeline>&&, GPUErrorScopes&);
     42    virtual ~WebGPUComputePipeline();
    3943
     44    static Ref<WebGPUComputePipeline> create(WebGPUDevice&, RefPtr<GPUComputePipeline>&&, GPUErrorScopes&, Optional<WebGPUPipeline::ShaderData> computeShader);
     45
     46    bool isComputePipeline() const { return true; }
     47
     48    bool isValid() const { return computePipeline(); }
    4049    const GPUComputePipeline* computePipeline() const { return m_computePipeline.get(); }
     50    Optional<WebGPUPipeline::ShaderData> computeShader() const { return m_computeShader; }
     51
     52    bool recompile(const WebGPUDevice&);
    4153
    4254private:
    43     WebGPUComputePipeline(RefPtr<GPUComputePipeline>&&, GPUErrorScopes&);
     55    WebGPUComputePipeline(WebGPUDevice&, RefPtr<GPUComputePipeline>&&, GPUErrorScopes&, Optional<WebGPUPipeline::ShaderData> computeShader);
    4456
    4557    RefPtr<GPUComputePipeline> m_computePipeline;
     58
     59    // Preserved for Web Inspector recompilation.
     60    Optional<WebGPUPipeline::ShaderData> m_computeShader;
    4661};
    4762
    4863} // namespace WebCore
    4964
     65SPECIALIZE_TYPE_TRAITS_WEBGPUPIPELINE(WebCore::WebGPUComputePipeline, isComputePipeline())
     66
    5067#endif // ENABLE(WEBGPU)

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

    r247293 r250114  
    2828    Conditional=WEBGPU,
    2929    EnabledAtRuntime=WebGPU,
    30     ImplementationLacksVTable,
    3130    InterfaceName=GPUComputePipeline
    3231] interface WebGPUComputePipeline {

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

    r249881 r250114  
    4040#include "GPUBufferDescriptor.h"
    4141#include "GPUCommandBuffer.h"
     42#include "GPUComputePipeline.h"
    4243#include "GPUComputePipelineDescriptor.h"
    4344#include "GPUProgrammableStageDescriptor.h"
     45#include "GPURenderPipeline.h"
    4446#include "GPURenderPipelineDescriptor.h"
    4547#include "GPUSampler.h"
    … …  
    206208    // FIXME: What can be validated here?
    207209    auto module = m_device->tryCreateShaderModule(GPUShaderModuleDescriptor { descriptor.code });
    208     return WebGPUShaderModule::create(WTFMove(module));
    209 }
    210 
    211 Ref<WebGPURenderPipeline> WebGPUDevice::createRenderPipeline(const WebGPURenderPipelineDescriptor& descriptor) const
     210    return WebGPUShaderModule::create(WTFMove(module), descriptor.code);
     211}
     212
     213Ref<WebGPURenderPipeline> WebGPUDevice::createRenderPipeline(const WebGPURenderPipelineDescriptor& descriptor)
    212214{
    213215    m_errorScopes->setErrorPrefix("GPUDevice.createRenderPipeline(): ");
    … …  
    215217    auto gpuDescriptor = descriptor.tryCreateGPURenderPipelineDescriptor(m_errorScopes);
    216218    if (!gpuDescriptor)
    217         return WebGPURenderPipeline::create(nullptr, m_errorScopes);
    218 
    219     auto pipeline = m_device->tryCreateRenderPipeline(*gpuDescriptor, m_errorScopes);
    220     return WebGPURenderPipeline::create(WTFMove(pipeline), m_errorScopes);
    221 }
    222 
    223 Ref<WebGPUComputePipeline> WebGPUDevice::createComputePipeline(const WebGPUComputePipelineDescriptor& descriptor) const
     219        return WebGPURenderPipeline::create(*this, nullptr, m_errorScopes, WTF::nullopt, WTF::nullopt);
     220
     221    auto gpuPipeline = m_device->tryCreateRenderPipeline(*gpuDescriptor, m_errorScopes);
     222
     223    WebGPUPipeline::ShaderData vertexShader = { descriptor.vertexStage.module, descriptor.vertexStage.entryPoint };
     224
     225    Optional<WebGPUPipeline::ShaderData> fragmentShader;
     226    if (descriptor.fragmentStage)
     227        fragmentShader = { { descriptor.fragmentStage.value().module, descriptor.fragmentStage.value().entryPoint } };
     228
     229    auto webGPUPipeline = WebGPURenderPipeline::create(*this, WTFMove(gpuPipeline), m_errorScopes, vertexShader, fragmentShader);
     230    if (webGPUPipeline->isValid())
     231        InspectorInstrumentation::didCreateWebGPUPipeline(*this, webGPUPipeline.get());
     232    return webGPUPipeline;
     233}
     234
     235Ref<WebGPUComputePipeline> WebGPUDevice::createComputePipeline(const WebGPUComputePipelineDescriptor& descriptor)
    224236{
    225237    m_errorScopes->setErrorPrefix("GPUDevice.createComputePipeline(): ");
    … …  
    227239    auto gpuDescriptor = descriptor.tryCreateGPUComputePipelineDescriptor(m_errorScopes);
    228240    if (!gpuDescriptor)
    229         return WebGPUComputePipeline::create(nullptr, m_errorScopes);
    230 
    231     auto pipeline = m_device->tryCreateComputePipeline(*gpuDescriptor, m_errorScopes);
    232     return WebGPUComputePipeline::create(WTFMove(pipeline), m_errorScopes);
     241        return WebGPUComputePipeline::create(*this, nullptr, m_errorScopes, WTF::nullopt);
     242
     243    auto gpuPipeline = m_device->tryCreateComputePipeline(*gpuDescriptor, m_errorScopes);
     244
     245    WebGPUPipeline::ShaderData computeShader = { descriptor.computeStage.module, descriptor.computeStage.entryPoint };
     246
     247    auto webGPUPipeline = WebGPUComputePipeline::create(*this, WTFMove(gpuPipeline), m_errorScopes, computeShader);
     248    if (webGPUPipeline->isValid())
     249        InspectorInstrumentation::didCreateWebGPUPipeline(*this, webGPUPipeline.get());
     250    return webGPUPipeline;
    233251}
    234252

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

    r249786 r250114  
    100100
    101101    Ref<WebGPUShaderModule> createShaderModule(const WebGPUShaderModuleDescriptor&) const;
    102     Ref<WebGPURenderPipeline> createRenderPipeline(const WebGPURenderPipelineDescriptor&) const;
    103     Ref<WebGPUComputePipeline> createComputePipeline(const WebGPUComputePipelineDescriptor&) const;
     102    Ref<WebGPURenderPipeline> createRenderPipeline(const WebGPURenderPipelineDescriptor&);
     103    Ref<WebGPUComputePipeline> createComputePipeline(const WebGPUComputePipelineDescriptor&);
    104104
    105105    Ref<WebGPUCommandEncoder> createCommandEncoder() const;

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

    r250113 r250114  
    2525
    2626#include "config.h"
    27 #include "WebGPUComputePipeline.h"
     27#include "WebGPUPipeline.h"
    2828
    2929#if ENABLE(WEBGPU)
    3030
     31#include "GPUErrorScopes.h"
     32#include "InspectorInstrumentation.h"
     33#include "ScriptExecutionContext.h"
     34#include "WebGPUDevice.h"
     35#include <wtf/HashMap.h>
     36#include <wtf/Lock.h>
     37#include <wtf/NeverDestroyed.h>
     38#include <wtf/Ref.h>
     39
    3140namespace WebCore {
    3241
    33 Ref<WebGPUComputePipeline> WebGPUComputePipeline::create(RefPtr<GPUComputePipeline>&& pipeline, GPUErrorScopes& errorScopes)
     42HashMap<WebGPUPipeline*, WebGPUDevice*>& WebGPUPipeline::instances(const LockHolder&)
    3443{
    35     return adoptRef(*new WebGPUComputePipeline(WTFMove(pipeline), errorScopes));
     44    static NeverDestroyed<HashMap<WebGPUPipeline*, WebGPUDevice*>> instances;
     45    return instances;
    3646}
    3747
    38 WebGPUComputePipeline::WebGPUComputePipeline(RefPtr<GPUComputePipeline>&& pipeline, GPUErrorScopes& errorScopes)
     48Lock& WebGPUPipeline::instancesMutex()
     49{
     50    static LazyNeverDestroyed<Lock> mutex;
     51    static std::once_flag initializeMutex;
     52    std::call_once(initializeMutex, [] {
     53        mutex.construct();
     54    });
     55    return mutex.get();
     56}
     57
     58WebGPUPipeline::WebGPUPipeline(WebGPUDevice& device, GPUErrorScopes& errorScopes)
    3959    : GPUObjectBase(makeRef(errorScopes))
    40     , m_computePipeline { WTFMove(pipeline) }
     60    , m_scriptExecutionContext(device.scriptExecutionContext())
    4161{
     62    LockHolder lock(instancesMutex());
     63    instances(lock).add(this, &device);
     64}
     65
     66WebGPUPipeline::~WebGPUPipeline()
     67{
     68    InspectorInstrumentation::willDestroyWebGPUPipeline(*this);
     69
     70    {
     71        LockHolder lock(instancesMutex());
     72        ASSERT(instances(lock).contains(this));
     73        instances(lock).remove(this);
     74    }
    4275}
    4376

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

    r250113 r250114  
    2828#if ENABLE(WEBGPU)
    2929
    30 #include "WHLSLPrepare.h"
    31 #include <wtf/RefCounted.h>
    32 #include <wtf/RefPtr.h>
    33 #include <wtf/RetainPtr.h>
    34 
    35 OBJC_PROTOCOL(MTLComputePipelineState);
     30#include "GPUObjectBase.h"
     31#include "WebGPUShaderModule.h"
     32#include <wtf/Forward.h>
    3633
    3734namespace WebCore {
    3835
    39 class GPUDevice;
     36class ScriptExecutionContext;
    4037class GPUErrorScopes;
     38class WebGPUDevice;
    4139
    42 struct GPUComputePipelineDescriptor;
     40class WebGPUPipeline : public GPUObjectBase {
     41public:
     42    virtual ~WebGPUPipeline();
    4343
    44 using PlatformComputePipeline = MTLComputePipelineState;
    45 using PlatformComputePipelineSmartPtr = RetainPtr<MTLComputePipelineState>;
     44    static HashMap<WebGPUPipeline*, WebGPUDevice*>& instances(const LockHolder&);
     45    static Lock& instancesMutex();
    4646
    47 class GPUComputePipeline : public RefCounted<GPUComputePipeline> {
    48 public:
    49     static RefPtr<GPUComputePipeline> tryCreate(const GPUDevice&, const GPUComputePipelineDescriptor&, GPUErrorScopes&);
     47    virtual bool isRenderPipeline() const { return false; }
     48    virtual bool isComputePipeline() const { return false; }
    5049
    51     const PlatformComputePipeline* platformComputePipeline() const { return m_platformComputePipeline.get(); }
     50    ScriptExecutionContext* scriptExecutionContext() const { return m_scriptExecutionContext; }
     51    virtual bool isValid() const = 0;
    5252
    53     WHLSL::ComputeDimensions computeDimensions() const { return m_computeDimensions; }
     53    struct ShaderData {
     54        RefPtr<WebGPUShaderModule> module;
     55        String entryPoint;
     56    };
    5457
    55 private:
    56     GPUComputePipeline(PlatformComputePipelineSmartPtr&&, WHLSL::ComputeDimensions);
     58    virtual bool recompile(const WebGPUDevice&) = 0;
    5759
    58     PlatformComputePipelineSmartPtr m_platformComputePipeline;
    59     WHLSL::ComputeDimensions m_computeDimensions { 0, 0, 0 };
     60protected:
     61    WebGPUPipeline(WebGPUDevice&, GPUErrorScopes&);
     62
     63    ScriptExecutionContext* m_scriptExecutionContext;
    6064};
    6165
    6266} // namespace WebCore
    6367
     68#define SPECIALIZE_TYPE_TRAITS_WEBGPUPIPELINE(ToValueTypeName, predicate) \
     69SPECIALIZE_TYPE_TRAITS_BEGIN(ToValueTypeName) \
     70    static bool isType(const WebCore::WebGPUPipeline& pipeline) { return pipeline.predicate; } \
     71SPECIALIZE_TYPE_TRAITS_END()
     72
    6473#endif // ENABLE(WEBGPU)

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

    r249601 r250114  
    3838    Optional<GPUProgrammableStageDescriptor> tryCreateGPUProgrammableStageDescriptor() const;
    3939
    40     RefPtr<const WebGPUShaderModule> module;
     40    RefPtr<WebGPUShaderModule> module;
    4141};
    4242

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

    r249881 r250114  
    2929#if ENABLE(WEBGPU)
    3030
     31#include "GPUErrorScopes.h"
     32#include "GPUPipeline.h"
     33#include "GPUProgrammableStageDescriptor.h"
     34#include "GPURenderPipeline.h"
     35#include "WebGPUDevice.h"
     36#include <wtf/Optional.h>
     37#include <wtf/Ref.h>
     38
    3139namespace WebCore {
    3240
    33 Ref<WebGPURenderPipeline> WebGPURenderPipeline::create(RefPtr<GPURenderPipeline>&& pipeline, GPUErrorScopes& errorScopes)
     41Ref<WebGPURenderPipeline> WebGPURenderPipeline::create(WebGPUDevice& device, RefPtr<GPURenderPipeline>&& pipeline, GPUErrorScopes& errorScopes, Optional<WebGPUPipeline::ShaderData> vertexShader, Optional<WebGPUPipeline::ShaderData> fragmentShader)
    3442{
    35     return adoptRef(*new WebGPURenderPipeline(WTFMove(pipeline), errorScopes));
     43    return adoptRef(*new WebGPURenderPipeline(device, WTFMove(pipeline), errorScopes, vertexShader, fragmentShader));
    3644}
    3745
    38 WebGPURenderPipeline::WebGPURenderPipeline(RefPtr<GPURenderPipeline>&& pipeline, GPUErrorScopes& errorScopes)
    39     : GPUObjectBase(makeRef(errorScopes))
     46WebGPURenderPipeline::WebGPURenderPipeline(WebGPUDevice& device, RefPtr<GPURenderPipeline>&& pipeline, GPUErrorScopes& errorScopes, Optional<WebGPUPipeline::ShaderData> vertexShader, Optional<WebGPUPipeline::ShaderData> fragmentShader)
     47    : WebGPUPipeline(device, errorScopes)
    4048    , m_renderPipeline(WTFMove(pipeline))
     49    , m_vertexShader(vertexShader)
     50    , m_fragmentShader(fragmentShader)
    4151{
     52}
     53
     54WebGPURenderPipeline::~WebGPURenderPipeline() = default;
     55
     56bool WebGPURenderPipeline::recompile(const WebGPUDevice& device)
     57{
     58    if (m_renderPipeline && m_vertexShader) {
     59        if (auto& webGPUVertexShaderModule = m_vertexShader.value().module) {
     60            if (auto* gpuVertexShaderModule = webGPUVertexShaderModule->module()) {
     61                GPUProgrammableStageDescriptor vertexStage(makeRef(*gpuVertexShaderModule), { m_vertexShader.value().entryPoint });
     62                Optional<GPUProgrammableStageDescriptor> fragmentStage;
     63                if (m_fragmentShader) {
     64                    if (auto& webGPUFragmentShaderModule = m_fragmentShader.value().module) {
     65                        if (auto* gpuFragmentShaderModule = webGPUFragmentShaderModule->module())
     66                            fragmentStage = GPUProgrammableStageDescriptor(makeRef(*gpuFragmentShaderModule), { m_fragmentShader.value().entryPoint });
     67                    }
     68                }
     69                return m_renderPipeline->recompile(device.device(), WTFMove(vertexStage), WTFMove(fragmentStage));
     70            }
     71        }
     72    }
     73    return false;
    4274}
    4375

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

    r249881 r250114  
    2828#if ENABLE(WEBGPU)
    2929
    30 #include "GPUObjectBase.h"
    31 #include "GPURenderPipeline.h"
    32 #include <wtf/RefPtr.h>
     30#include "WebGPUPipeline.h"
     31#include <wtf/Forward.h>
    3332
    3433namespace WebCore {
    3534
    36 class WebGPURenderPipeline : public GPUObjectBase {
     35class GPUPipeline;
     36class GPURenderPipeline;
     37class GPUErrorScopes;
     38class WebGPUDevice;
     39
     40class WebGPURenderPipeline final : public WebGPUPipeline {
    3741public:
    38     static Ref<WebGPURenderPipeline> create(RefPtr<GPURenderPipeline>&&, GPUErrorScopes&);
     42    virtual ~WebGPURenderPipeline();
    3943
     44    static Ref<WebGPURenderPipeline> create(WebGPUDevice&, RefPtr<GPURenderPipeline>&&, GPUErrorScopes&, Optional<WebGPUPipeline::ShaderData> vertexShader, Optional<WebGPUPipeline::ShaderData> fragmentShader);
     45
     46    bool isRenderPipeline() const { return true; }
     47
     48    bool isValid() const { return renderPipeline(); }
    4049    const GPURenderPipeline* renderPipeline() const { return m_renderPipeline.get(); }
     50    Optional<WebGPUPipeline::ShaderData> vertexShader() const { return m_vertexShader; }
     51    Optional<WebGPUPipeline::ShaderData> fragmentShader() const { return m_fragmentShader; }
     52
     53    bool recompile(const WebGPUDevice&);
    4154
    4255private:
    43     WebGPURenderPipeline(RefPtr<GPURenderPipeline>&&, GPUErrorScopes&);
     56    WebGPURenderPipeline(WebGPUDevice&, RefPtr<GPURenderPipeline>&&, GPUErrorScopes&, Optional<WebGPUPipeline::ShaderData> vertexShader, Optional<WebGPUPipeline::ShaderData> fragmentShader);
    4457
    4558    RefPtr<GPURenderPipeline> m_renderPipeline;
     59
     60    // Preserved for Web Inspector recompilation.
     61    Optional<WebGPUPipeline::ShaderData> m_vertexShader;
     62    Optional<WebGPUPipeline::ShaderData> m_fragmentShader;
    4663};
    4764
    4865} // namespace WebCore
    4966
     67SPECIALIZE_TYPE_TRAITS_WEBGPUPIPELINE(WebCore::WebGPURenderPipeline, isRenderPipeline())
     68
    5069#endif // ENABLE(WEBGPU)

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

    r247293 r250114  
    2828    Conditional=WEBGPU,
    2929    EnabledAtRuntime=WebGPU,
    30     ImplementationLacksVTable,
    3130    InterfaceName=GPURenderPipeline
    3231] interface WebGPURenderPipeline {

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

    r243563 r250114  
    2929#if ENABLE(WEBGPU)
    3030
     31#include "GPUShaderModuleDescriptor.h"
     32#include "WebGPUDevice.h"
     33#include <wtf/RefPtr.h>
     34
    3135namespace WebCore {
    3236
    33 Ref<WebGPUShaderModule> WebGPUShaderModule::create(RefPtr<GPUShaderModule>&& module)
     37Ref<WebGPUShaderModule> WebGPUShaderModule::create(RefPtr<GPUShaderModule>&& module, const String& source)
    3438{
    35     return adoptRef(*new WebGPUShaderModule(WTFMove(module)));
     39    return adoptRef(*new WebGPUShaderModule(WTFMove(module), source));
    3640}
    3741
    38 WebGPUShaderModule::WebGPUShaderModule(RefPtr<GPUShaderModule>&& module)
     42WebGPUShaderModule::WebGPUShaderModule(RefPtr<GPUShaderModule>&& module, const String& source)
    3943    : m_module(WTFMove(module))
     44    , m_source(source)
    4045{
     46}
     47
     48void WebGPUShaderModule::update(const WebGPUDevice& device, const String& source)
     49{
     50    m_source = source;
     51    m_module = GPUShaderModule::tryCreate(device.device(), { m_source });
    4152}
    4253

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

    r243563 r250114  
    2929
    3030#include "GPUShaderModule.h"
    31 
     31#include <wtf/Forward.h>
    3232#include <wtf/RefCounted.h>
    33 #include <wtf/RefPtr.h>
    3433
    3534namespace WebCore {
    3635
     36class WebGPUDevice;
     37
    3738class WebGPUShaderModule : public RefCounted<WebGPUShaderModule> {
    3839public:
    39     static Ref<WebGPUShaderModule> create(RefPtr<GPUShaderModule>&&);
     40    static Ref<WebGPUShaderModule> create(RefPtr<GPUShaderModule>&&, const String& source);
    4041
    41     const GPUShaderModule* module() const { return m_module.get(); }
     42    GPUShaderModule* module() const { return m_module.get(); }
     43    const String& source() const { return m_source; }
     44
     45    void update(const WebGPUDevice&, const String& source);
    4246
    4347private:
    44     WebGPUShaderModule(RefPtr<GPUShaderModule>&&);
     48    WebGPUShaderModule(RefPtr<GPUShaderModule>&&, const String& source);
    4549
    4650    RefPtr<GPUShaderModule> m_module;
     51
     52    // Preserved for Web Inspector recompilation.
     53    String m_source;
    4754};
    4855

  • trunk/Source/WebCore/Sources.txt

    r250060 r250114  
    374374Modules/webgpu/WebGPUDeviceErrorScopes.cpp
    375375Modules/webgpu/WebGPUQueue.cpp
     376Modules/webgpu/WebGPUPipeline.cpp
    376377Modules/webgpu/WebGPUPipelineLayout.cpp
    377378Modules/webgpu/WebGPUPipelineLayoutDescriptor.cpp
    … …  
    18981899platform/graphics/gpu/GPUErrorScopes.cpp
    18991900platform/graphics/gpu/GPUValidationError.cpp
     1901platform/graphics/gpu/GPUPipeline.cpp
    19001902platform/graphics/gpu/GPUPipelineLayout.cpp
    19011903platform/graphics/gpu/GPUProgrammablePassEncoder.cpp

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

    r250060 r250114  
    1040210402                9175CE5A21E281ED00DF2C27 /* InspectorAuditAccessibilityObject.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = InspectorAuditAccessibilityObject.h; sourceTree = "<group>"; };
    1040310403                9175CE5A21E281ED00DF2C28 /* JSInspectorAuditAccessibilityObject.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = JSInspectorAuditAccessibilityObject.h; sourceTree = "<group>"; };
     10404                9186F3B32329FB0500AFF857 /* GPUPipeline.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = GPUPipeline.h; sourceTree = "<group>"; };
     10405                9186F3B62329FB4E00AFF857 /* WebGPUPipeline.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = WebGPUPipeline.cpp; sourceTree = "<group>"; };
     10406                9186F3B72329FB4F00AFF857 /* WebGPUPipeline.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = WebGPUPipeline.h; sourceTree = "<group>"; };
     10407                9186F3BA2329FE6800AFF857 /* GPUPipeline.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = GPUPipeline.cpp; sourceTree = "<group>"; };
    1040410408                91B8F0B321953D65000C2B00 /* CertificateInfoBase.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = CertificateInfoBase.h; sourceTree = "<group>"; };
    1040510409                91B952221F58A58000931DC2 /* RecordingSwizzleTypes.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = RecordingSwizzleTypes.h; sourceTree = "<group>"; };
    … …  
    1838018384                                D09AFB3722D7D5C600C4538C /* GPUObjectBase.h */,
    1838118385                                D09AFB1922D6698A00C4538C /* GPUOutOfMemoryError.h */,
     18386                                9186F3BA2329FE6800AFF857 /* GPUPipeline.cpp */,
     18387                                9186F3B32329FB0500AFF857 /* GPUPipeline.h */,
    1838218388                                312FF8C421A4C2F400EB199D /* GPUPipelineDescriptorBase.h */,
    1838318389                                D003288721C9A4E500622AA6 /* GPUPipelineLayout.cpp */,
    … …  
    2611526121                                D09AC00A231735BE00187762 /* WebGPUDeviceEventHandler.h */,
    2611626122                                D09AC00B231735BE00187762 /* WebGPUDeviceEventHandler.idl */,
     26123                                9186F3B62329FB4E00AFF857 /* WebGPUPipeline.cpp */,
     26124                                9186F3B72329FB4F00AFF857 /* WebGPUPipeline.h */,
    2611726125                                D0C419F02183EB31009EC1DE /* WebGPUPipelineDescriptorBase.h */,
    2611826126                                D0C419F12183EB31009EC1DE /* WebGPUPipelineDescriptorBase.idl */,

  • trunk/Source/WebCore/html/canvas/WebGLProgram.cpp

    r242594 r250114  
    2929#if ENABLE(WEBGL)
    3030
     31#include "InspectorInstrumentation.h"
     32#include "ScriptExecutionContext.h"
    3133#include "WebGLContextGroup.h"
    3234#include "WebGLRenderingContextBase.h"
    … …  
    6163WebGLProgram::WebGLProgram(WebGLRenderingContextBase& ctx)
    6264    : WebGLSharedObject(ctx)
     65    , m_scriptExecutionContext(ctx.scriptExecutionContext())
    6366{
    6467    {
    … …  
    7275WebGLProgram::~WebGLProgram()
    7376{
     77    InspectorInstrumentation::willDestroyWebGLProgram(*this);
     78
    7479    deleteObject(0);
    7580

  • trunk/Source/WebCore/html/canvas/WebGLProgram.h

    r247452 r250114  
    3333namespace WebCore {
    3434
     35class ScriptExecutionContext;
     36class WebGLRenderingContextBase;
    3537class WebGLShader;
    3638
    … …  
    4244    static HashMap<WebGLProgram*, WebGLRenderingContextBase*>& instances(const LockHolder&);
    4345    static Lock& instancesMutex();
     46
     47    ScriptExecutionContext* scriptExecutionContext() const { return m_scriptExecutionContext; }
    4448
    4549    unsigned numActiveAttribLocations();
    … …  
    7276    void cacheInfoIfNeeded();
    7377
     78    ScriptExecutionContext* m_scriptExecutionContext;
     79
    7480    Vector<GC3Dint> m_activeAttribLocations;
    7581

  • trunk/Source/WebCore/html/canvas/WebGLRenderingContextBase.cpp

    r249007 r250114  
    412412    void showHightlight()
    413413    {
    414         if (!m_program || LIKELY(!InspectorInstrumentation::isShaderProgramHighlighted(m_context, *m_program)))
     414        if (!m_program || LIKELY(!InspectorInstrumentation::isWebGLProgramHighlighted(m_context, *m_program)))
    415415            return;
    416416
    … …  
    17551755    addSharedObject(program.get());
    17561756
    1757     InspectorInstrumentation::didCreateProgram(*this, program.get());
     1757    InspectorInstrumentation::didCreateWebGLProgram(*this, program.get());
    17581758
    17591759    return program;
    … …  
    18411841{
    18421842    if (program)
    1843         InspectorInstrumentation::willDeleteProgram(*this, *program);
     1843        InspectorInstrumentation::willDestroyWebGLProgram(*program);
    18441844
    18451845    deleteObject(program);
    … …  
    22562256        return;
    22572257
    2258     if (m_currentProgram && InspectorInstrumentation::isShaderProgramDisabled(*this, *m_currentProgram))
     2258    if (m_currentProgram && InspectorInstrumentation::isWebGLProgramDisabled(*this, *m_currentProgram))
    22592259        return;
    22602260
    … …  
    23102310        return;
    23112311
    2312     if (m_currentProgram && InspectorInstrumentation::isShaderProgramDisabled(*this, *m_currentProgram))
     2312    if (m_currentProgram && InspectorInstrumentation::isWebGLProgramDisabled(*this, *m_currentProgram))
    23132313        return;
    23142314

  • trunk/Source/WebCore/inspector/InspectorInstrumentation.cpp

    r249786 r250114  
    10801080}
    10811081
    1082 void InspectorInstrumentation::didCreateProgramImpl(InstrumentingAgents& instrumentingAgents, WebGLRenderingContextBase& contextWebGLBase, WebGLProgram& program)
     1082void InspectorInstrumentation::didCreateWebGLProgramImpl(InstrumentingAgents& instrumentingAgents, WebGLRenderingContextBase& contextWebGLBase, WebGLProgram& program)
    10831083{
    10841084    if (InspectorCanvasAgent* canvasAgent = instrumentingAgents.inspectorCanvasAgent())
    1085         canvasAgent->didCreateProgram(contextWebGLBase, program);
    1086 }
    1087 
    1088 void InspectorInstrumentation::willDeleteProgramImpl(InstrumentingAgents& instrumentingAgents, WebGLProgram& program)
     1085        canvasAgent->didCreateWebGLProgram(contextWebGLBase, program);
     1086}
     1087
     1088void InspectorInstrumentation::willDestroyWebGLProgramImpl(InstrumentingAgents& instrumentingAgents, WebGLProgram& program)
    10891089{
    10901090    if (InspectorCanvasAgent* canvasAgent = instrumentingAgents.inspectorCanvasAgent())
    1091         canvasAgent->willDeleteProgram(program);
    1092 }
    1093 
    1094 bool InspectorInstrumentation::isShaderProgramDisabledImpl(InstrumentingAgents& instrumentingAgents, WebGLProgram& program)
     1091        canvasAgent->willDestroyWebGLProgram(program);
     1092}
     1093
     1094bool InspectorInstrumentation::isWebGLProgramDisabledImpl(InstrumentingAgents& instrumentingAgents, WebGLProgram& program)
    10951095{
    10961096    if (InspectorCanvasAgent* canvasAgent = instrumentingAgents.inspectorCanvasAgent())
    1097         return canvasAgent->isShaderProgramDisabled(program);
     1097        return canvasAgent->isWebGLProgramDisabled(program);
    10981098    return false;
    10991099}
    11001100
    1101 bool InspectorInstrumentation::isShaderProgramHighlightedImpl(InstrumentingAgents& instrumentingAgents, WebGLProgram& program)
     1101bool InspectorInstrumentation::isWebGLProgramHighlightedImpl(InstrumentingAgents& instrumentingAgents, WebGLProgram& program)
    11021102{
    11031103    if (InspectorCanvasAgent* canvasAgent = instrumentingAgents.inspectorCanvasAgent())
    1104         return canvasAgent->isShaderProgramHighlighted(program);
     1104        return canvasAgent->isWebGLProgramHighlighted(program);
    11051105    return false;
    11061106}
    … …  
    11241124    if (auto* canvasAgent = instrumentingAgents.inspectorCanvasAgent())
    11251125        canvasAgent->willConfigureSwapChain(contextGPU, newSwapChain);
     1126}
     1127
     1128void InspectorInstrumentation::didCreateWebGPUPipelineImpl(InstrumentingAgents& instrumentingAgents, WebGPUDevice& device, WebGPUPipeline& pipeline)
     1129{
     1130    if (auto* canvasAgent = instrumentingAgents.inspectorCanvasAgent())
     1131        canvasAgent->didCreateWebGPUPipeline(device, pipeline);
     1132}
     1133
     1134void InspectorInstrumentation::willDestroyWebGPUPipelineImpl(InstrumentingAgents& instrumentingAgents, WebGPUPipeline& pipeline)
     1135{
     1136    if (auto* canvasAgent = instrumentingAgents.inspectorCanvasAgent())
     1137        canvasAgent->willDestroyWebGPUPipeline(pipeline);
    11261138}
    11271139#endif

  • trunk/Source/WebCore/inspector/InspectorInstrumentation.h

    r249786 r250114  
    6464#include "GPUCanvasContext.h"
    6565#include "WebGPUDevice.h"
     66#include "WebGPUPipeline.h"
    6667#endif
    6768
    … …  
    290291#if ENABLE(WEBGL)
    291292    static void didEnableExtension(WebGLRenderingContextBase&, const String&);
    292     static void didCreateProgram(WebGLRenderingContextBase&, WebGLProgram&);
    293     static void willDeleteProgram(WebGLRenderingContextBase&, WebGLProgram&);
    294     static bool isShaderProgramDisabled(WebGLRenderingContextBase&, WebGLProgram&);
    295     static bool isShaderProgramHighlighted(WebGLRenderingContextBase&, WebGLProgram&);
     293    static void didCreateWebGLProgram(WebGLRenderingContextBase&, WebGLProgram&);
     294    static void willDestroyWebGLProgram(WebGLProgram&);
     295    static bool isWebGLProgramDisabled(WebGLRenderingContextBase&, WebGLProgram&);
     296    static bool isWebGLProgramHighlighted(WebGLRenderingContextBase&, WebGLProgram&);
    296297#endif
    297298#if ENABLE(WEBGPU)
    … …  
    299300    static void willDestroyWebGPUDevice(WebGPUDevice&);
    300301    static void willConfigureSwapChain(GPUCanvasContext&, WebGPUSwapChain&);
     302    static void didCreateWebGPUPipeline(WebGPUDevice&, WebGPUPipeline&);
     303    static void willDestroyWebGPUPipeline(WebGPUPipeline&);
    301304#endif
    302305
    … …  
    482485#if ENABLE(WEBGL)
    483486    static void didEnableExtensionImpl(InstrumentingAgents&, WebGLRenderingContextBase&, const String&);
    484     static void didCreateProgramImpl(InstrumentingAgents&, WebGLRenderingContextBase&, WebGLProgram&);
    485     static void willDeleteProgramImpl(InstrumentingAgents&, WebGLProgram&);
    486     static bool isShaderProgramDisabledImpl(InstrumentingAgents&, WebGLProgram&);
    487     static bool isShaderProgramHighlightedImpl(InstrumentingAgents&, WebGLProgram&);
     487    static void didCreateWebGLProgramImpl(InstrumentingAgents&, WebGLRenderingContextBase&, WebGLProgram&);
     488    static void willDestroyWebGLProgramImpl(InstrumentingAgents&, WebGLProgram&);
     489    static bool isWebGLProgramDisabledImpl(InstrumentingAgents&, WebGLProgram&);
     490    static bool isWebGLProgramHighlightedImpl(InstrumentingAgents&, WebGLProgram&);
    488491#endif
    489492#if ENABLE(WEBGPU)
    … …  
    491494    static void willDestroyWebGPUDeviceImpl(InstrumentingAgents&, WebGPUDevice&);
    492495    static void willConfigureSwapChainImpl(InstrumentingAgents&, GPUCanvasContext&, WebGPUSwapChain&);
     496    static void didCreateWebGPUPipelineImpl(InstrumentingAgents&, WebGPUDevice&, WebGPUPipeline&);
     497    static void willDestroyWebGPUPipelineImpl(InstrumentingAgents&, WebGPUPipeline&);
    493498#endif
    494499
    … …  
    13851390}
    13861391
    1387 inline void InspectorInstrumentation::didCreateProgram(WebGLRenderingContextBase& contextWebGLBase, WebGLProgram& program)
     1392inline void InspectorInstrumentation::didCreateWebGLProgram(WebGLRenderingContextBase& contextWebGLBase, WebGLProgram& program)
    13881393{
    13891394    FAST_RETURN_IF_NO_FRONTENDS(void());
    13901395    if (InstrumentingAgents* instrumentingAgents = instrumentingAgentsForContext(contextWebGLBase.canvasBase().scriptExecutionContext()))
    1391         didCreateProgramImpl(*instrumentingAgents, contextWebGLBase, program);
    1392 }
    1393 
    1394 inline void InspectorInstrumentation::willDeleteProgram(WebGLRenderingContextBase& contextWebGLBase, WebGLProgram& program)
    1395 {
    1396     FAST_RETURN_IF_NO_FRONTENDS(void());
    1397     if (InstrumentingAgents* instrumentingAgents = instrumentingAgentsForContext(contextWebGLBase.canvasBase().scriptExecutionContext()))
    1398         willDeleteProgramImpl(*instrumentingAgents, program);
    1399 }
    1400 
    1401 inline bool InspectorInstrumentation::isShaderProgramDisabled(WebGLRenderingContextBase& contextWebGLBase, WebGLProgram& program)
     1396        didCreateWebGLProgramImpl(*instrumentingAgents, contextWebGLBase, program);
     1397}
     1398
     1399inline void InspectorInstrumentation::willDestroyWebGLProgram(WebGLProgram& program)
     1400{
     1401    FAST_RETURN_IF_NO_FRONTENDS(void());
     1402    if (InstrumentingAgents* instrumentingAgents = instrumentingAgentsForContext(program.scriptExecutionContext()))
     1403        willDestroyWebGLProgramImpl(*instrumentingAgents, program);
     1404}
     1405
     1406inline bool InspectorInstrumentation::isWebGLProgramDisabled(WebGLRenderingContextBase& contextWebGLBase, WebGLProgram& program)
    14021407{
    14031408    FAST_RETURN_IF_NO_FRONTENDS(false);
    14041409    if (InstrumentingAgents* instrumentingAgents = instrumentingAgentsForContext(contextWebGLBase.canvasBase().scriptExecutionContext()))
    1405         return isShaderProgramDisabledImpl(*instrumentingAgents, program);
     1410        return isWebGLProgramDisabledImpl(*instrumentingAgents, program);
    14061411    return false;
    14071412}
    14081413
    1409 inline bool InspectorInstrumentation::isShaderProgramHighlighted(WebGLRenderingContextBase& contextWebGLBase, WebGLProgram& program)
     1414inline bool InspectorInstrumentation::isWebGLProgramHighlighted(WebGLRenderingContextBase& contextWebGLBase, WebGLProgram& program)
    14101415{
    14111416    FAST_RETURN_IF_NO_FRONTENDS(false);
    14121417    if (InstrumentingAgents* instrumentingAgents = instrumentingAgentsForContext(contextWebGLBase.canvasBase().scriptExecutionContext()))
    1413         return isShaderProgramHighlightedImpl(*instrumentingAgents, program);
     1418        return isWebGLProgramHighlightedImpl(*instrumentingAgents, program);
    14141419    return false;
    14151420}
    … …  
    14361441    if (auto* instrumentingAgents = instrumentingAgentsForContext(contextGPU.canvasBase().scriptExecutionContext()))
    14371442        willConfigureSwapChainImpl(*instrumentingAgents, contextGPU, newSwapChain);
     1443}
     1444
     1445inline void InspectorInstrumentation::didCreateWebGPUPipeline(WebGPUDevice& device, WebGPUPipeline& pipeline)
     1446{
     1447    FAST_RETURN_IF_NO_FRONTENDS(void());
     1448    if (auto* instrumentingAgents = instrumentingAgentsForContext(device.scriptExecutionContext()))
     1449        didCreateWebGPUPipelineImpl(*instrumentingAgents, device, pipeline);
     1450}
     1451
     1452inline void InspectorInstrumentation::willDestroyWebGPUPipeline(WebGPUPipeline& pipeline)
     1453{
     1454    FAST_RETURN_IF_NO_FRONTENDS(void());
     1455    if (auto* instrumentingAgents = instrumentingAgentsForContext(pipeline.scriptExecutionContext()))
     1456        willDestroyWebGPUPipelineImpl(*instrumentingAgents, pipeline);
    14381457}
    14391458#endif

  • trunk/Source/WebCore/inspector/InspectorShaderProgram.cpp

    r249786 r250114  
    2727#include "InspectorShaderProgram.h"
    2828
    29 #if ENABLE(WEBGL)
    30 
     29#include "InspectorCanvas.h"
     30#include <JavaScriptCore/IdentifiersFactory.h>
     31#include <wtf/Optional.h>
     32#include <wtf/Ref.h>
     33#include <wtf/Variant.h>
     34#include <wtf/text/WTFString.h>
     35
     36#if ENABLE(WEBGL)
    3137#include "GraphicsContext3D.h"
    32 #include "GraphicsTypes3D.h"
    33 #include "HTMLCanvasElement.h"
    34 #include "InspectorCanvas.h"
    3538#include "WebGLProgram.h"
    3639#include "WebGLRenderingContextBase.h"
    3740#include "WebGLShader.h"
    38 #include <JavaScriptCore/IdentifiersFactory.h>
     41#endif
     42
     43#if ENABLE(WEBGPU)
     44#include "GPUShaderModule.h"
     45#include "WHLSLPrepare.h"
     46#include "WebGPUComputePipeline.h"
     47#include "WebGPUPipeline.h"
     48#include "WebGPURenderPipeline.h"
     49#include "WebGPUShaderModule.h"
     50#endif
    3951
    4052namespace WebCore {
    … …  
    4254using namespace Inspector;
    4355
     56#if ENABLE(WEBGL)
    4457Ref<InspectorShaderProgram> InspectorShaderProgram::create(WebGLProgram& program, InspectorCanvas& inspectorCanvas)
    4558{
    4659    return adoptRef(*new InspectorShaderProgram(program, inspectorCanvas));
    4760}
    48 
     61#endif
     62
     63#if ENABLE(WEBGPU)
     64Ref<InspectorShaderProgram> InspectorShaderProgram::create(WebGPUPipeline& pipeline, InspectorCanvas& inspectorCanvas)
     65{
     66    return adoptRef(*new InspectorShaderProgram(pipeline, inspectorCanvas));
     67}
     68#endif
     69
     70#if ENABLE(WEBGL)
    4971InspectorShaderProgram::InspectorShaderProgram(WebGLProgram& program, InspectorCanvas& inspectorCanvas)
    5072    : m_identifier("program:" + IdentifiersFactory::createIdentifier())
     73    , m_canvas(inspectorCanvas)
    5174    , m_program(program)
     75{
     76    ASSERT(is<WebGLRenderingContextBase>(m_canvas.canvasContext()));
     77}
     78#endif
     79
     80#if ENABLE(WEBGPU)
     81InspectorShaderProgram::InspectorShaderProgram(WebGPUPipeline& pipeline, InspectorCanvas& inspectorCanvas)
     82    : m_identifier("pipeline:" + IdentifiersFactory::createIdentifier())
    5283    , m_canvas(inspectorCanvas)
    53 {
    54 }
    55 
    56 WebGLRenderingContextBase& InspectorShaderProgram::context() const
    57 {
    58     ASSERT(m_canvas.canvasContext());
    59     ASSERT(is<WebGLRenderingContextBase>(*m_canvas.canvasContext()));
    60     return downcast<WebGLRenderingContextBase>(*m_canvas.canvasContext());
    61 }
    62 
    63 WebGLShader* InspectorShaderProgram::shaderForType(const String& protocolType)
    64 {
    65     GC3Denum shaderType;
    66     if (protocolType == "vertex")
    67         shaderType = GraphicsContext3D::VERTEX_SHADER;
    68     else if (protocolType == "fragment")
    69         shaderType = GraphicsContext3D::FRAGMENT_SHADER;
    70     else
     84    , m_program(pipeline)
     85{
     86    ASSERT(m_canvas.deviceContext());
     87}
     88#endif
     89
     90#if ENABLE(WEBGL)
     91WebGLProgram* InspectorShaderProgram::program() const
     92{
     93    if (auto* programWrapper = WTF::get_if<std::reference_wrapper<WebGLProgram>>(m_program))
     94        return &programWrapper->get();
     95    return nullptr;
     96}
     97#endif
     98
     99#if ENABLE(WEBGPU)
     100WebGPUPipeline* InspectorShaderProgram::pipeline() const
     101{
     102    if (auto* pipelineWrapper = WTF::get_if<std::reference_wrapper<WebGPUPipeline>>(m_program))
     103        return &pipelineWrapper->get();
     104    return nullptr;
     105}
     106#endif
     107
     108#if ENABLE(WEBGL)
     109static WebGLShader* shaderForType(WebGLProgram& program, Inspector::Protocol::Canvas::ShaderType shaderType)
     110{
     111    switch (shaderType) {
     112    case Inspector::Protocol::Canvas::ShaderType::Fragment:
     113        return program.getAttachedShader(GraphicsContext3D::FRAGMENT_SHADER);
     114
     115    case Inspector::Protocol::Canvas::ShaderType::Vertex:
     116        return program.getAttachedShader(GraphicsContext3D::VERTEX_SHADER);
     117
     118    // Compute shaders are a WebGPU concept.
     119    case Inspector::Protocol::Canvas::ShaderType::Compute:
    71120        return nullptr;
    72 
    73     return m_program.getAttachedShader(shaderType);
     121    }
     122
     123    ASSERT_NOT_REACHED();
     124    return nullptr;
     125}
     126#endif
     127
     128#if ENABLE(WEBGPU)
     129static Optional<WebGPUPipeline::ShaderData> shaderForType(WebGPUPipeline& pipeline, Inspector::Protocol::Canvas::ShaderType shaderType)
     130{
     131    switch (shaderType) {
     132    case Inspector::Protocol::Canvas::ShaderType::Compute:
     133        if (is<WebGPUComputePipeline>(pipeline))
     134            return downcast<WebGPUComputePipeline>(pipeline).computeShader();
     135        break;
     136
     137    case Inspector::Protocol::Canvas::ShaderType::Fragment:
     138        if (is<WebGPURenderPipeline>(pipeline))
     139            return downcast<WebGPURenderPipeline>(pipeline).fragmentShader();
     140        break;
     141
     142    case Inspector::Protocol::Canvas::ShaderType::Vertex:
     143        if (is<WebGPURenderPipeline>(pipeline))
     144            return downcast<WebGPURenderPipeline>(pipeline).vertexShader();
     145        break;
     146    }
     147
     148    ASSERT_NOT_REACHED();
     149    return WTF::nullopt;
     150}
     151#endif
     152
     153String InspectorShaderProgram::requestShaderSource(Inspector::Protocol::Canvas::ShaderType shaderType)
     154{
     155#if !ENABLE(WEBGL) && !ENABLE(WEBGPU)
     156    UNUSED_PARAM(shaderType);
     157#endif
     158
     159    return WTF::switchOn(m_program,
     160#if ENABLE(WEBGL)
     161        [&] (std::reference_wrapper<WebGLProgram> programWrapper) {
     162            auto& program = programWrapper.get();
     163            if (auto* shader = shaderForType(program, shaderType))
     164                return shader->getSource();
     165            return String();
     166        },
     167#endif
     168#if ENABLE(WEBGPU)
     169        [&] (std::reference_wrapper<WebGPUPipeline> pipelineWrapper) {
     170            auto& pipeline = pipelineWrapper.get();
     171            if (auto shaderData = shaderForType(pipeline, shaderType)) {
     172                if (auto module = shaderData.value().module)
     173                    return module->source();
     174            }
     175            return String();
     176        },
     177#endif
     178        [&] (Monostate) {
     179#if ENABLE(WEBGL) || ENABLE(WEBGPU)
     180            ASSERT_NOT_REACHED();
     181#endif
     182            return String();
     183        }
     184    );
     185}
     186
     187bool InspectorShaderProgram::updateShader(Inspector::Protocol::Canvas::ShaderType shaderType, const String& source)
     188{
     189#if !ENABLE(WEBGL) && !ENABLE(WEBGPU)
     190    UNUSED_PARAM(shaderType);
     191    UNUSED_PARAM(source);
     192#endif
     193
     194    return WTF::switchOn(m_program,
     195#if ENABLE(WEBGL)
     196        [&] (std::reference_wrapper<WebGLProgram> programWrapper) {
     197            auto& program = programWrapper.get();
     198            if (auto* shader = shaderForType(program, shaderType)) {
     199                if (auto* context = m_canvas.canvasContext()) {
     200                    if (is<WebGLRenderingContextBase>(context)) {
     201                        auto& contextWebGLBase = downcast<WebGLRenderingContextBase>(*context);
     202                        contextWebGLBase.shaderSource(shader, source);
     203                        contextWebGLBase.compileShader(shader);
     204                        if (shader->isValid()) {
     205                            contextWebGLBase.linkProgramWithoutInvalidatingAttribLocations(&program);
     206                            return true;
     207                        }
     208                    }
     209                }
     210            }
     211            return false;
     212        },
     213#endif
     214#if ENABLE(WEBGPU)
     215        [&] (std::reference_wrapper<WebGPUPipeline> pipelineWrapper) {
     216            auto& pipeline = pipelineWrapper.get();
     217            if (auto* device = m_canvas.deviceContext()) {
     218                if (auto shaderData = shaderForType(pipeline, shaderType)) {
     219                    if (auto module = shaderData.value().module) {
     220                        module->update(*device, source);
     221                        if (pipeline.recompile(*device))
     222                            return true;
     223                    }
     224                }
     225            }
     226            return false;
     227        },
     228#endif
     229        [&] (Monostate) {
     230#if ENABLE(WEBGL) || ENABLE(WEBGPU)
     231            ASSERT_NOT_REACHED();
     232#endif
     233            return false;
     234        }
     235    );
    74236}
    75237
    76238} // namespace WebCore
    77 
    78 #endif // ENABLE(WEBGL)

  • trunk/Source/WebCore/inspector/InspectorShaderProgram.h

    r230127 r250114  
    2727
    2828#include <JavaScriptCore/InspectorProtocolObjects.h>
     29#include <wtf/Forward.h>
     30#include <wtf/RefCounted.h>
    2931
    3032namespace WebCore {
    3133
    3234class InspectorCanvas;
     35
     36#if ENABLE(WEBGL)
    3337class WebGLProgram;
    3438class WebGLRenderingContextBase;
    35 class WebGLShader;
     39#endif
    3640
    37 typedef String ErrorString;
     41#if ENABLE(WEBGPU)
     42class WebGPUPipeline;
     43#endif
    3844
    3945class InspectorShaderProgram final : public RefCounted<InspectorShaderProgram> {
    4046public:
     47#if ENABLE(WEBGL)
    4148    static Ref<InspectorShaderProgram> create(WebGLProgram&, InspectorCanvas&);
     49#endif
     50#if ENABLE(WEBGPU)
     51    static Ref<InspectorShaderProgram> create(WebGPUPipeline&, InspectorCanvas&);
     52#endif
    4253
    4354    const String& identifier() const { return m_identifier; }
    4455    InspectorCanvas& canvas() const { return m_canvas; }
    45     WebGLRenderingContextBase& context() const;
    46     WebGLProgram& program() const { return m_program; }
    47     WebGLShader* shaderForType(const String&);
     56
     57#if ENABLE(WEBGL)
     58    WebGLProgram* program() const;
     59#endif
     60#if ENABLE(WEBGPU)
     61    WebGPUPipeline* pipeline() const;
     62#endif
     63
     64    String requestShaderSource(Inspector::Protocol::Canvas::ShaderType);
     65    bool updateShader(Inspector::Protocol::Canvas::ShaderType, const String& source);
    4866
    4967    bool disabled() const { return m_disabled; }
    … …  
    5371    void setHighlighted(bool value) { m_highlighted = value; }
    5472
    55     ~InspectorShaderProgram() = default;
    56 
    5773private:
     74#if ENABLE(WEBGL)
    5875    InspectorShaderProgram(WebGLProgram&, InspectorCanvas&);
     76#endif
     77#if ENABLE(WEBGPU)
     78    InspectorShaderProgram(WebGPUPipeline&, InspectorCanvas&);
     79#endif
    5980
    6081    String m_identifier;
    61     WebGLProgram& m_program;
    6282    InspectorCanvas& m_canvas;
     83
     84    Variant<
     85#if ENABLE(WEBGL)
     86        std::reference_wrapper<WebGLProgram>,
     87#endif
     88#if ENABLE(WEBGPU)
     89        std::reference_wrapper<WebGPUPipeline>,
     90#endif
     91        Monostate
     92    > m_program;
    6393
    6494    bool m_disabled { false };

  • trunk/Source/WebCore/inspector/agents/InspectorCanvasAgent.cpp

    r249786 r250114  
    3636#include "ImageBitmapRenderingContext.h"
    3737#include "InspectorDOMAgent.h"
     38#include "InspectorShaderProgram.h"
    3839#include "InstrumentingAgents.h"
    3940#include "JSExecState.h"
    … …  
    4748#include <JavaScriptCore/InspectorProtocolObjects.h>
    4849#include <JavaScriptCore/JSCInlines.h>
     50#include <wtf/HashMap.h>
    4951#include <wtf/HashSet.h>
    5052#include <wtf/Lock.h>
     53#include <wtf/Optional.h>
     54#include <wtf/RefPtr.h>
     55#include <wtf/Vector.h>
     56#include <wtf/text/WTFString.h>
    5157
    5258#if ENABLE(WEBGL)
    … …  
    5460#include "WebGLRenderingContext.h"
    5561#include "WebGLRenderingContextBase.h"
    56 #include "WebGLShader.h"
    5762#endif
    5863
    … …  
    6368#if ENABLE(WEBGPU)
    6469#include "GPUCanvasContext.h"
     70#include "WebGPUComputePipeline.h"
    6571#include "WebGPUDevice.h"
     72#include "WebGPUPipeline.h"
     73#include "WebGPURenderPipeline.h"
     74#include "WebGPUSwapChain.h"
    6675#endif
    6776
    … …  
    7786    , m_inspectedPage(context.inspectedPage)
    7887    , m_canvasDestroyedTimer(*this, &InspectorCanvasAgent::canvasDestroyedTimerFired)
     88    , m_programDestroyedTimer(*this, &InspectorCanvasAgent::programDestroyedTimerFired)
    7989{
    8090}
    … …  
    94104void InspectorCanvasAgent::discardAgent()
    95105{
    96     clearCanvasData();
     106    reset();
    97107}
    98108
    … …  
    142152        for (auto& [program, contextWebGLBase] : WebGLProgram::instances(lock)) {
    143153            if (contextWebGLBase && existsInCurrentPage(contextWebGLBase->canvasBase().scriptExecutionContext()))
    144                 didCreateProgram(*contextWebGLBase, *program);
     154                didCreateWebGLProgram(*contextWebGLBase, *program);
     155        }
     156    }
     157#endif
     158
     159#if ENABLE(WEBGPU)
     160    {
     161        LockHolder lock(WebGPUPipeline::instancesMutex());
     162        for (auto& [pipeline, device] : WebGPUPipeline::instances(lock)) {
     163            if (device && existsInCurrentPage(device->scriptExecutionContext()) && pipeline->isValid())
     164                didCreateWebGPUPipeline(*device, *pipeline);
    145165        }
    146166    }
    … …  
    152172    m_instrumentingAgents.setInspectorCanvasAgent(nullptr);
    153173
    154     clearCanvasData();
     174    reset();
    155175
    156176    m_recordingAutoCaptureFrameCount = WTF::nullopt;
    … …  
    281301}
    282302
    283 void InspectorCanvasAgent::requestShaderSource(ErrorString& errorString, const String& programId, const String& shaderType, String* content)
    284 {
    285 #if ENABLE(WEBGL)
     303void InspectorCanvasAgent::requestShaderSource(ErrorString& errorString, const String& programId, const String& shaderTypeString, String* outSource)
     304{
    286305    auto inspectorProgram = assertInspectorProgram(errorString, programId);
    287306    if (!inspectorProgram)
    288307        return;
    289308
    290     auto* shader = inspectorProgram->shaderForType(shaderType);
    291     if (!shader) {
    292         errorString = "Missing shader for given shaderType"_s;
    293         return;
    294     }
    295 
    296     *content = shader->getSource();
    297 #else
    298     UNUSED_PARAM(programId);
    299     UNUSED_PARAM(shaderType);
    300     UNUSED_PARAM(content);
    301     errorString = "Not supported"_s;
    302 #endif
    303 }
    304 
    305 void InspectorCanvasAgent::updateShader(ErrorString& errorString, const String& programId, const String& shaderType, const String& source)
    306 {
    307 #if ENABLE(WEBGL)
     309    auto shaderType = Inspector::Protocol::InspectorHelpers::parseEnumValueFromString<Inspector::Protocol::Canvas::ShaderType>(shaderTypeString);
     310    if (!shaderType) {
     311        errorString = makeString("Unknown shaderType: "_s, shaderTypeString);
     312        return;
     313    }
     314
     315    auto source = inspectorProgram->requestShaderSource(shaderType.value());
     316    if (!source) {
     317        errorString = "Missing shader of given shaderType for given programId"_s;
     318        return;
     319    }
     320
     321    *outSource = source;
     322}
     323
     324void InspectorCanvasAgent::updateShader(ErrorString& errorString, const String& programId, const String& shaderTypeString, const String& source)
     325{
    308326    auto inspectorProgram = assertInspectorProgram(errorString, programId);
    309327    if (!inspectorProgram)
    310328        return;
    311329
    312     auto* shader = inspectorProgram->shaderForType(shaderType);
    313     if (!shader) {
    314         errorString = "Missing shader for given shaderType"_s;
    315         return;
    316     }
    317 
    318     WebGLRenderingContextBase& contextWebGL = inspectorProgram->context();
    319     contextWebGL.shaderSource(shader, source);
    320     contextWebGL.compileShader(shader);
    321 
    322     if (!shader->isValid()) {
    323         errorString = "Failed to update shader"_s;
    324         return;
    325     }
    326 
    327     contextWebGL.linkProgramWithoutInvalidatingAttribLocations(&inspectorProgram->program());
    328 #else
    329     UNUSED_PARAM(programId);
    330     UNUSED_PARAM(shaderType);
    331     UNUSED_PARAM(source);
    332     errorString = "Not supported"_s;
    333 #endif
     330    auto shaderType = Inspector::Protocol::InspectorHelpers::parseEnumValueFromString<Inspector::Protocol::Canvas::ShaderType>(shaderTypeString);
     331    if (!shaderType) {
     332        errorString = makeString("Unknown shaderType: "_s, shaderTypeString);
     333        return;
     334    }
     335
     336    if (!inspectorProgram->updateShader(shaderType.value(), source))
     337        errorString = "Failed to update shader of given shaderType for given programId"_s;
    334338}
    335339
    336340void InspectorCanvasAgent::setShaderProgramDisabled(ErrorString& errorString, const String& programId, bool disabled)
    337341{
    338 #if ENABLE(WEBGL)
    339342    auto inspectorProgram = assertInspectorProgram(errorString, programId);
    340343    if (!inspectorProgram)
    … …  
    342345
    343346    inspectorProgram->setDisabled(disabled);
    344 #else
    345     UNUSED_PARAM(programId);
    346     UNUSED_PARAM(disabled);
    347     errorString = "Not supported"_s;
    348 #endif
    349347}
    350348
    351349void InspectorCanvasAgent::setShaderProgramHighlighted(ErrorString& errorString, const String& programId, bool highlighted)
    352350{
    353 #if ENABLE(WEBGL)
    354351    auto inspectorProgram = assertInspectorProgram(errorString, programId);
    355352    if (!inspectorProgram)
    … …  
    357354
    358355    inspectorProgram->setHighlighted(highlighted);
    359 #else
    360     UNUSED_PARAM(programId);
    361     UNUSED_PARAM(highlighted);
    362     errorString = "Not supported"_s;
    363 #endif
    364356}
    365357
    … …  
    367359{
    368360    if (frame.isMainFrame()) {
    369         clearCanvasData();
     361        reset();
    370362        return;
    371363    }
    … …  
    569561}
    570562
    571 void InspectorCanvasAgent::didCreateProgram(WebGLRenderingContextBase& context, WebGLProgram& program)
     563void InspectorCanvasAgent::didCreateWebGLProgram(WebGLRenderingContextBase& context, WebGLProgram& program)
    572564{
    573565    auto inspectorCanvas = findInspectorCanvas(context);
    … …  
    579571    String programIdentifier = inspectorProgram->identifier();
    580572    m_identifierToInspectorProgram.set(programIdentifier, WTFMove(inspectorProgram));
    581     m_frontendDispatcher->programCreated(inspectorCanvas->identifier(), programIdentifier);
    582 }
    583 
    584 void InspectorCanvasAgent::willDeleteProgram(WebGLProgram& program)
     573    m_frontendDispatcher->programCreated(inspectorCanvas->identifier(), programIdentifier, Inspector::Protocol::Canvas::ProgramType::Render);
     574}
     575
     576void InspectorCanvasAgent::willDestroyWebGLProgram(WebGLProgram& program)
    585577{
    586578    auto inspectorProgram = findInspectorProgram(program);
    … …  
    588580        return;
    589581
    590     String identifier = unbindProgram(*inspectorProgram);
    591     m_frontendDispatcher->programDeleted(identifier);
    592 }
    593 
    594 bool InspectorCanvasAgent::isShaderProgramDisabled(WebGLProgram& program)
     582    unbindProgram(*inspectorProgram);
     583}
     584
     585bool InspectorCanvasAgent::isWebGLProgramDisabled(WebGLProgram& program)
    595586{
    596587    auto inspectorProgram = findInspectorProgram(program);
    … …  
    602593}
    603594
    604 bool InspectorCanvasAgent::isShaderProgramHighlighted(WebGLProgram& program)
     595bool InspectorCanvasAgent::isWebGLProgramHighlighted(WebGLProgram& program)
    605596{
    606597    auto inspectorProgram = findInspectorProgram(program);
    … …  
    649640
    650641    notifyDeviceForSwapChain(newSwapChain);
     642}
     643
     644void InspectorCanvasAgent::didCreateWebGPUPipeline(WebGPUDevice& device, WebGPUPipeline& pipeline)
     645{
     646    auto inspectorCanvas = findInspectorCanvas(device);
     647    ASSERT(inspectorCanvas);
     648    if (!inspectorCanvas)
     649        return;
     650
     651    ASSERT(pipeline.isValid());
     652
     653    auto inspectorProgram = InspectorShaderProgram::create(pipeline, *inspectorCanvas);
     654    String programIdentifier = inspectorProgram->identifier();
     655    m_identifierToInspectorProgram.set(programIdentifier, WTFMove(inspectorProgram));
     656
     657    Optional<Inspector::Protocol::Canvas::ProgramType> programType;
     658    if (is<WebGPUComputePipeline>(pipeline))
     659        programType = Inspector::Protocol::Canvas::ProgramType::Compute;
     660    else if (is<WebGPURenderPipeline>(pipeline))
     661        programType = Inspector::Protocol::Canvas::ProgramType::Render;
     662    ASSERT(programType);
     663
     664    m_frontendDispatcher->programCreated(inspectorCanvas->identifier(), programIdentifier, programType.value());
     665}
     666
     667void InspectorCanvasAgent::willDestroyWebGPUPipeline(WebGPUPipeline& pipeline)
     668{
     669    auto inspectorProgram = findInspectorProgram(pipeline);
     670    if (!inspectorProgram)
     671        return;
     672
     673    unbindProgram(*inspectorProgram);
    651674}
    652675#endif
    … …  
    695718}
    696719
    697 void InspectorCanvasAgent::clearCanvasData()
     720void InspectorCanvasAgent::programDestroyedTimerFired()
     721{
     722    if (!m_removedProgramIdentifiers.size())
     723        return;
     724
     725    for (auto& identifier : m_removedProgramIdentifiers)
     726        m_frontendDispatcher->programDeleted(identifier);
     727
     728    m_removedProgramIdentifiers.clear();
     729}
     730
     731void InspectorCanvasAgent::reset()
    698732{
    699733    for (auto& inspectorCanvas : m_identifierToInspectorCanvas.values()) {
    … …  
    703737
    704738    m_identifierToInspectorCanvas.clear();
    705 #if ENABLE(WEBGL)
    706     m_identifierToInspectorProgram.clear();
    707739    m_removedCanvasIdentifiers.clear();
    708 #endif
    709 
    710740    if (m_canvasDestroyedTimer.isActive())
    711741        m_canvasDestroyedTimer.stop();
     742
     743    m_identifierToInspectorProgram.clear();
     744    m_removedProgramIdentifiers.clear();
     745    if (m_programDestroyedTimer.isActive())
     746        m_programDestroyedTimer.stop();
    712747}
    713748
    … …  
    806841#endif
    807842
    808 #if ENABLE(WEBGL)
    809 String InspectorCanvasAgent::unbindProgram(InspectorShaderProgram& inspectorProgram)
     843void InspectorCanvasAgent::unbindProgram(InspectorShaderProgram& inspectorProgram)
    810844{
    811845    String identifier = inspectorProgram.identifier();
    812846    m_identifierToInspectorProgram.remove(identifier);
    813847
    814     return identifier;
     848    // This can be called in response to GC. Due to the single-process model used in WebKit1, the
     849    // event must be dispatched from a timer to prevent the frontend from making JS allocations
     850    // while the GC is still active.
     851    m_removedProgramIdentifiers.append(identifier);
     852
     853    if (!m_programDestroyedTimer.isActive())
     854        m_programDestroyedTimer.startOneShot(0_s);
    815855}
    816856
    … …  
    825865}
    826866
     867#if ENABLE(WEBGL)
    827868RefPtr<InspectorShaderProgram> InspectorCanvasAgent::findInspectorProgram(WebGLProgram& program)
    828869{
    829870    for (auto& inspectorProgram : m_identifierToInspectorProgram.values()) {
    830         if (&inspectorProgram->program() == &program)
     871        if (inspectorProgram->program() == &program)
    831872            return inspectorProgram;
    832873    }
    … …  
    835876#endif
    836877
     878#if ENABLE(WEBGPU)
     879RefPtr<InspectorShaderProgram> InspectorCanvasAgent::findInspectorProgram(WebGPUPipeline& pipeline)
     880{
     881    for (auto& inspectorProgram : m_identifierToInspectorProgram.values()) {
     882        if (inspectorProgram->pipeline() == &pipeline)
     883            return inspectorProgram;
     884    }
     885    return nullptr;
     886}
     887#endif
     888
    837889} // namespace WebCore

  • trunk/Source/WebCore/inspector/agents/InspectorCanvasAgent.h

    r249786 r250114  
    3434#include <JavaScriptCore/InspectorFrontendDispatchers.h>
    3535#include <initializer_list>
    36 #include <wtf/HashMap.h>
    37 #include <wtf/RefPtr.h>
    38 #include <wtf/Vector.h>
    39 #include <wtf/text/WTFString.h>
    40 
    41 #if ENABLE(WEBGL)
    42 #include "InspectorShaderProgram.h"
    43 #endif
     36#include <wtf/Forward.h>
    4437
    4538namespace Inspector {
    … …  
    5043
    5144class CanvasRenderingContext;
     45class InspectorShaderProgram;
    5246#if ENABLE(WEBGL)
    5347class WebGLProgram;
    … …  
    5751class GPUCanvasContext;
    5852class WebGPUDevice;
     53class WebGPUPipeline;
    5954class WebGPUSwapChain;
    6055#endif
    … …  
    8479    void startRecording(ErrorString&, const String& canvasId, const int* frameCount, const int* memoryLimit);
    8580    void stopRecording(ErrorString&, const String& canvasId);
    86     void requestShaderSource(ErrorString&, const String& programId, const String& shaderType, String*);
     81    void requestShaderSource(ErrorString&, const String& programId, const String& shaderType, String* source);
    8782    void updateShader(ErrorString&, const String& programId, const String& shaderType, const String& source);
    8883    void setShaderProgramDisabled(ErrorString&, const String& programId, bool disabled);
    … …  
    10499#if ENABLE(WEBGL)
    105100    void didEnableExtension(WebGLRenderingContextBase&, const String&);
    106     void didCreateProgram(WebGLRenderingContextBase&, WebGLProgram&);
    107     void willDeleteProgram(WebGLProgram&);
    108     bool isShaderProgramDisabled(WebGLProgram&);
    109     bool isShaderProgramHighlighted(WebGLProgram&);
     101    void didCreateWebGLProgram(WebGLRenderingContextBase&, WebGLProgram&);
     102    void willDestroyWebGLProgram(WebGLProgram&);
     103    bool isWebGLProgramDisabled(WebGLProgram&);
     104    bool isWebGLProgramHighlighted(WebGLProgram&);
    110105#endif
    111106#if ENABLE(WEBGPU)
    … …  
    113108    void willDestroyWebGPUDevice(WebGPUDevice&);
    114109    void willConfigureSwapChain(GPUCanvasContext&, WebGPUSwapChain&);
     110    void didCreateWebGPUPipeline(WebGPUDevice&, WebGPUPipeline&);
     111    void willDestroyWebGPUPipeline(WebGPUPipeline&);
    115112#endif
    116113
    … …  
    124121
    125122    void canvasDestroyedTimerFired();
    126     void clearCanvasData();
     123    void programDestroyedTimerFired();
     124    void reset();
     125
    127126    InspectorCanvas& bindCanvas(CanvasRenderingContext&, bool captureBacktrace);
    128127#if ENABLE(WEBGPU)
    … …  
    136135#endif
    137136
     137    void unbindProgram(InspectorShaderProgram&);
     138    RefPtr<InspectorShaderProgram> assertInspectorProgram(ErrorString&, const String& programId);
    138139#if ENABLE(WEBGL)
    139     String unbindProgram(InspectorShaderProgram&);
    140     RefPtr<InspectorShaderProgram> assertInspectorProgram(ErrorString&, const String& programId);
    141140    RefPtr<InspectorShaderProgram> findInspectorProgram(WebGLProgram&);
     141#endif
     142#if ENABLE(WEBGPU)
     143    RefPtr<InspectorShaderProgram> findInspectorProgram(WebGPUPipeline&);
    142144#endif
    143145
    … …  
    149151
    150152    HashMap<String, RefPtr<InspectorCanvas>> m_identifierToInspectorCanvas;
    151 #if ENABLE(WEBGL)
     153    Vector<String> m_removedCanvasIdentifiers;
     154    Timer m_canvasDestroyedTimer;
     155
    152156    HashMap<String, RefPtr<InspectorShaderProgram>> m_identifierToInspectorProgram;
    153 #endif
    154     Vector<String> m_removedCanvasIdentifiers;
     157    Vector<String> m_removedProgramIdentifiers;
     158    Timer m_programDestroyedTimer;
    155159
    156160    Optional<size_t> m_recordingAutoCaptureFrameCount;
    157 
    158     Timer m_canvasDestroyedTimer;
    159161};
    160162

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

    r249881 r250114  
    2828#if ENABLE(WEBGPU)
    2929
     30#include "GPUPipeline.h"
     31#include "GPUProgrammableStageDescriptor.h"
    3032#include "WHLSLPrepare.h"
    3133#include <wtf/RefCounted.h>
    … …  
    3941class GPUDevice;
    4042class GPUErrorScopes;
     43class GPUPipelineLayout;
    4144
    4245struct GPUComputePipelineDescriptor;
    … …  
    4548using PlatformComputePipelineSmartPtr = RetainPtr<MTLComputePipelineState>;
    4649
    47 class GPUComputePipeline : public RefCounted<GPUComputePipeline> {
     50class GPUComputePipeline final : public GPUPipeline {
    4851public:
     52    virtual ~GPUComputePipeline();
     53
    4954    static RefPtr<GPUComputePipeline> tryCreate(const GPUDevice&, const GPUComputePipelineDescriptor&, GPUErrorScopes&);
     55
     56    bool isComputePipeline() const { return true; }
     57
     58    bool recompile(const GPUDevice&, GPUProgrammableStageDescriptor&& computeStage);
    5059
    5160    const PlatformComputePipeline* platformComputePipeline() const { return m_platformComputePipeline.get(); }
    … …  
    5463
    5564private:
    56     GPUComputePipeline(PlatformComputePipelineSmartPtr&&, WHLSL::ComputeDimensions);
     65    GPUComputePipeline(PlatformComputePipelineSmartPtr&&, WHLSL::ComputeDimensions, GPUPipelineLayout&);
    5766
    5867    PlatformComputePipelineSmartPtr m_platformComputePipeline;
    5968    WHLSL::ComputeDimensions m_computeDimensions { 0, 0, 0 };
     69
     70    // Preserved for Web Inspector recompilation.
     71    RefPtr<GPUPipelineLayout> m_layout;
    6072};
    6173
    6274} // namespace WebCore
    6375
     76SPECIALIZE_TYPE_TRAITS_GPUPIPELINE(WebCore::GPUComputePipeline, isComputePipeline())
     77
    6478#endif // ENABLE(WEBGPU)

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

    r250113 r250114  
    2323 * THE POSSIBILITY OF SUCH DAMAGE.
    2424 */
    25 // https://gpuweb.github.io/gpuweb
    2625
    27 [
    28     Conditional=WEBGPU,
    29     EnabledAtRuntime=WebGPU,
    30     ImplementationLacksVTable,
    31     InterfaceName=GPUComputePipeline
    32 ] interface WebGPUComputePipeline {
    33 };
     26#include "config.h"
     27#include "GPUPipeline.h"
     28
     29#if ENABLE(WEBGPU)
     30
     31namespace WebCore {
     32
     33GPUPipeline::~GPUPipeline() = default;
     34
     35} // namespace WebCore
     36
     37#endif // ENABLE(WEBGPU)

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

    r250113 r250114  
    2828#if ENABLE(WEBGPU)
    2929
    30 #include "GPUComputePipeline.h"
    31 #include "GPUObjectBase.h"
    32 #include <wtf/RefPtr.h>
     30#include <wtf/RefCounted.h>
    3331
    3432namespace WebCore {
    3533
    36 class WebGPUComputePipeline : public GPUObjectBase {
     34class GPUPipeline : public RefCounted<GPUPipeline> {
    3735public:
    38     static Ref<WebGPUComputePipeline> create(RefPtr<GPUComputePipeline>&&, GPUErrorScopes&);
     36    virtual ~GPUPipeline();
    3937
    40     const GPUComputePipeline* computePipeline() const { return m_computePipeline.get(); }
    41 
    42 private:
    43     WebGPUComputePipeline(RefPtr<GPUComputePipeline>&&, GPUErrorScopes&);
    44 
    45     RefPtr<GPUComputePipeline> m_computePipeline;
     38    virtual bool isRenderPipeline() const { return false; }
     39    virtual bool isComputePipeline() const { return false; }
    4640};
    4741
    4842} // namespace WebCore
    4943
     44#define SPECIALIZE_TYPE_TRAITS_GPUPIPELINE(ToValueTypeName, predicate) \
     45SPECIALIZE_TYPE_TRAITS_BEGIN(ToValueTypeName) \
     46    static bool isType(const WebCore::GPUPipeline& pipeline) { return pipeline.predicate; } \
     47SPECIALIZE_TYPE_TRAITS_END()
     48
    5049#endif // ENABLE(WEBGPU)

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

    r249601 r250114  
    3939
    4040struct GPUProgrammableStageDescriptor : GPUProgrammableStageDescriptorBase {
    41     GPUProgrammableStageDescriptor(Ref<const GPUShaderModule>&& module, const GPUProgrammableStageDescriptorBase& base)
     41    GPUProgrammableStageDescriptor(Ref<GPUShaderModule>&& module, const GPUProgrammableStageDescriptorBase& base)
    4242        : GPUProgrammableStageDescriptorBase(base)
    4343        , module { WTFMove(module) }
    … …  
    4545    }
    4646
    47     Ref<const GPUShaderModule> module;
     47    Ref<GPUShaderModule> module;
    4848};
    4949

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

    r249881 r250114  
    2828#if ENABLE(WEBGPU)
    2929
     30#include "GPUPipeline.h"
     31#include "GPUProgrammableStageDescriptor.h"
    3032#include "GPURenderPipelineDescriptor.h"
    3133#include <wtf/Optional.h>
    … …  
    4749using PlatformRenderPipelineSmartPtr = RetainPtr<MTLRenderPipelineState>;
    4850
    49 class GPURenderPipeline : public RefCounted<GPURenderPipeline> {
     51class GPURenderPipeline final : public GPUPipeline {
    5052public:
     53    virtual ~GPURenderPipeline();
     54
    5155    static RefPtr<GPURenderPipeline> tryCreate(const GPUDevice&, const GPURenderPipelineDescriptor&, GPUErrorScopes&);
     56
     57    bool isRenderPipeline() const { return true; }
     58
     59    bool recompile(const GPUDevice&, GPUProgrammableStageDescriptor&& vertexStage, Optional<GPUProgrammableStageDescriptor>&& fragmentStage);
    5260
    5361#if USE(METAL)
    … …  
    6068private:
    6169#if USE(METAL)
    62     GPURenderPipeline(RetainPtr<MTLDepthStencilState>&&, PlatformRenderPipelineSmartPtr&&, GPUPrimitiveTopology, Optional<GPUIndexFormat>);
     70    GPURenderPipeline(RetainPtr<MTLDepthStencilState>&&, PlatformRenderPipelineSmartPtr&&, GPUPrimitiveTopology, Optional<GPUIndexFormat>, GPUPipelineLayout&, const GPURenderPipelineDescriptorBase&);
    6371
    6472    RetainPtr<MTLDepthStencilState> m_depthStencilState;
    … …  
    6775    GPUPrimitiveTopology m_primitiveTopology;
    6876    Optional<GPUIndexFormat> m_indexFormat;
     77
     78    // Preserved for Web Inspector recompilation.
     79    RefPtr<GPUPipelineLayout> m_layout;
     80    GPURenderPipelineDescriptorBase m_renderDescriptorBase;
    6981};
    7082
    7183} // namespace WebCore
    7284
     85SPECIALIZE_TYPE_TRAITS_GPUPIPELINE(WebCore::GPURenderPipeline, isRenderPipeline())
     86
    7387#endif // ENABLE(WEBGPU)

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

    r249881 r250114  
    3232#import "GPUDevice.h"
    3333#import "GPUErrorScopes.h"
     34#import "GPUPipelineLayout.h"
    3435#import "GPUPipelineMetalConvertLayout.h"
    3536#import "WHLSLPrepare.h"
    … …  
    195196        return nullptr;
    196197
    197     return adoptRef(new GPUComputePipeline(WTFMove(createResult->pipelineState), createResult->computeDimensions));
    198 }
    199 
    200 GPUComputePipeline::GPUComputePipeline(RetainPtr<MTLComputePipelineState>&& pipeline, WHLSL::ComputeDimensions computeDimensions)
    201     : m_platformComputePipeline(WTFMove(pipeline))
     198    ASSERT(descriptor.layout);
     199    return adoptRef(new GPUComputePipeline(WTFMove(createResult->pipelineState), createResult->computeDimensions, *descriptor.layout));
     200}
     201
     202GPUComputePipeline::GPUComputePipeline(RetainPtr<MTLComputePipelineState>&& pipeline, WHLSL::ComputeDimensions computeDimensions, GPUPipelineLayout& layout)
     203    : GPUPipeline()
     204    , m_platformComputePipeline(WTFMove(pipeline))
    202205    , m_computeDimensions(computeDimensions)
    203 {
     206    , m_layout(makeRef(layout))
     207{
     208}
     209
     210GPUComputePipeline::~GPUComputePipeline() = default;
     211
     212bool GPUComputePipeline::recompile(const GPUDevice& device, GPUProgrammableStageDescriptor&& computeStage)
     213{
     214    if (m_layout) {
     215        GPUComputePipelineDescriptor descriptor(makeRef(*m_layout), WTFMove(computeStage));
     216        auto errorScopes = GPUErrorScopes::create([] (GPUError&&) { });
     217        if (auto createResult = tryCreateMTLComputePipelineState(device, descriptor, errorScopes)) {
     218            m_platformComputePipeline = WTFMove(createResult->pipelineState);
     219            m_computeDimensions = createResult->computeDimensions;
     220            return true;
     221        }
     222    }
     223
     224    return false;
    204225}
    205226

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

    r249881 r250114  
    3333#import "GPULimits.h"
    3434#import "GPUPipelineMetalConvertLayout.h"
     35#import "GPURenderPipelineDescriptor.h"
    3536#import "GPUUtils.h"
    3637#import "WHLSLPrepare.h"
    … …  
    484485}
    485486
    486 static RetainPtr<MTLRenderPipelineState> tryCreateMtlRenderPipelineState(const GPURenderPipelineDescriptor& descriptor, const GPUDevice& device, GPUErrorScopes& errorScopes)
     487static RetainPtr<MTLRenderPipelineState> tryCreateMtlRenderPipelineState(const GPUDevice& device, const GPURenderPipelineDescriptor& descriptor, GPUErrorScopes& errorScopes)
    487488{
    488489    if (!device.platformDevice()) {
    … …  
    523524    // FIXME: https://bugs.webkit.org/show_bug.cgi?id=198387 depthStencilAttachmentDescriptor isn't implemented yet for WHLSL compiler.
    524525
    525     auto pipeline = tryCreateMtlRenderPipelineState(descriptor, device, errorScopes);
     526    auto pipeline = tryCreateMtlRenderPipelineState(device, descriptor, errorScopes);
    526527    if (!pipeline)
    527528        return nullptr;
    528529
    529     return adoptRef(new GPURenderPipeline(WTFMove(depthStencil), WTFMove(pipeline), descriptor.primitiveTopology, descriptor.vertexInput.indexFormat));
    530 }
    531 
    532 GPURenderPipeline::GPURenderPipeline(RetainPtr<MTLDepthStencilState>&& depthStencil, RetainPtr<MTLRenderPipelineState>&& pipeline, GPUPrimitiveTopology topology, Optional<GPUIndexFormat> format)
    533     : m_depthStencilState(WTFMove(depthStencil))
     530    ASSERT(descriptor.layout);
     531    return adoptRef(new GPURenderPipeline(WTFMove(depthStencil), WTFMove(pipeline), descriptor.primitiveTopology, descriptor.vertexInput.indexFormat, *descriptor.layout, descriptor));
     532}
     533
     534GPURenderPipeline::GPURenderPipeline(RetainPtr<MTLDepthStencilState>&& depthStencil, RetainPtr<MTLRenderPipelineState>&& pipeline, GPUPrimitiveTopology topology, Optional<GPUIndexFormat> format, GPUPipelineLayout& layout, const GPURenderPipelineDescriptorBase& renderDescriptorBase)
     535    : GPUPipeline()
     536    , m_depthStencilState(WTFMove(depthStencil))
    534537    , m_platformRenderPipeline(WTFMove(pipeline))
    535538    , m_primitiveTopology(topology)
    536539    , m_indexFormat(format)
    537 {
     540    , m_layout(makeRef(layout))
     541    , m_renderDescriptorBase(renderDescriptorBase)
     542{
     543}
     544
     545GPURenderPipeline::~GPURenderPipeline() = default;
     546
     547bool GPURenderPipeline::recompile(const GPUDevice& device, GPUProgrammableStageDescriptor&& vertexStage, Optional<GPUProgrammableStageDescriptor>&& fragmentStage)
     548{
     549    if (m_layout) {
     550        GPURenderPipelineDescriptor descriptor(makeRef(*m_layout), WTFMove(vertexStage), WTFMove(fragmentStage), m_renderDescriptorBase);
     551        auto errorScopes = GPUErrorScopes::create([] (GPUError&&) { });
     552        if (auto pipeline = tryCreateMtlRenderPipelineState(device, descriptor, errorScopes)) {
     553            m_platformRenderPipeline = WTFMove(pipeline);
     554            return true;
     555        }
     556    }
     557
     558    return false;
    538559}
    539560

  • trunk/Source/WebInspectorUI/ChangeLog

    r250087 r250114  
     12019-09-19  Devin Rousso  <drousso@apple.com>
     2
     3        Web Inspector: Canvas: show WebGPU shader pipelines
     4        https://bugs.webkit.org/show_bug.cgi?id=201675
     5
     6        Reviewed by Joseph Pecoraro.
     7
     8        Show WebGPU shader pipelines ("programs") underneath each corresponding WebGPU device.
     9
     10        Allow editing of attached shader modules for each WebGPU shader pipeline, but don't allow
     11        highlighting/disabling, as WebGPU pipelines don't have those capabilities/concepts yet.
     12
     13        * UserInterface/Protocol/CanvasObserver.js:
     14        (WI.CanvasObserver.prototype.programCreated):
     15        * UserInterface/Controllers/CanvasManager.js:
     16        (WI.CanvasManager.prototype.programCreated):
     17
     18        * UserInterface/Models/Canvas.js:
     19        (WI.Canvas.prototype.nextShaderProgramDisplayNumberForProgramType): Added.
     20        (WI.Canvas.prototype.nextShaderProgramDisplayNumber): Deleted.
     21
     22        * UserInterface/Models/ShaderProgram.js:
     23        (WI.ShaderProgram):
     24        (WI.ShaderProgram.contextTypeSupportsProgramType): Added.
     25        (WI.ShaderProgram.programTypeSupportsShaderType): Added.
     26        (WI.ShaderProgram.prototype.get programType): Added.
     27        (WI.ShaderProgram.prototype.get displayName):
     28        (WI.ShaderProgram.prototype.set disabled):
     29        (WI.ShaderProgram.prototype.requestShaderSource):
     30        (WI.ShaderProgram.prototype.updateShader):
     31        (WI.ShaderProgram.prototype.showHighlight):
     32        (WI.ShaderProgram.prototype.hideHighlight):
     33        (WI.ShaderProgram.prototype.requestVertexShaderSource): Deleted.
     34        (WI.ShaderProgram.prototype.requestFragmentShaderSource): Deleted.
     35        (WI.ShaderProgram.prototype.updateVertexShader): Deleted.
     36        (WI.ShaderProgram.prototype.updateFragmentShader): Deleted.
     37        (WI.ShaderProgram.prototype._requestShaderSource): Deleted.
     38        (WI.ShaderProgram.prototype._updateShader): Deleted.
     39
     40        * UserInterface/Views/ShaderProgramContentView.js:
     41        (WI.ShaderProgramContentView):
     42        (WI.ShaderProgramContentView.prototype.get navigationItems): Added.
     43        (WI.ShaderProgramContentView.prototype.shown):
     44        (WI.ShaderProgramContentView.prototype.hidden):
     45        (WI.ShaderProgramContentView.prototype.get saveData):
     46        (WI.ShaderProgramContentView.prototype._refreshContent):
     47        (WI.ShaderProgramContentView.prototype._updateShader):
     48        (WI.ShaderProgramContentView.prototype._contentDidChange):
     49        * UserInterface/Views/ShaderProgramContentView.css:
     50        (.content-view.shader-program > .shader): Added.
     51        (.content-view.shader-program > .shader.compute): Added.
     52        (body[dir=ltr] .content-view.shader-program > .shader.vertex,): Added.
     53        (body[dir=ltr] .content-view.shader-program > .shader.fragment,): Added.
     54        (.content-view.shader-program > .shader + .shader): Added.
     55        (.content-view.shader-program > .shader > header > *): Added.
     56        (.content-view.shader-program > .shader > header > .shader-type): Added.
     57        (@media (prefers-color-scheme: dark) .content-view.shader-program > .shader > header): Added.
     58        (.content-view.shader-program > .text-editor.shader): Deleted.
     59        (body[dir=ltr] .content-view.shader-program > .text-editor.shader.vertex,): Deleted.
     60        (body[dir=ltr] .content-view.shader-program > .text-editor.shader.fragment,): Deleted.
     61        (body[dir=ltr] .content-view.shader-program > .text-editor.shader + .text-editor.shader): Deleted.
     62        (body[dir=rtl] .content-view.shader-program > .text-editor.shader + .text-editor.shader): Deleted.
     63        (.content-view.shader-program > .text-editor.shader > .type-title): Deleted.
     64        (.content-view.shader-program > .text-editor.shader > .CodeMirror): Deleted.
     65        * UserInterface/Views/CodeMirrorAdditions.js:
     66
     67        * UserInterface/Views/ShaderProgramTreeElement.js:
     68        (WI.ShaderProgramTreeElement):
     69        (WI.ShaderProgramTreeElement.prototype.onattach):
     70        (WI.ShaderProgramTreeElement.prototype.ondetach):
     71        (WI.ShaderProgramTreeElement.prototype.canSelectOnMouseDown):
     72        (WI.ShaderProgramTreeElement.prototype.populateContextMenu):
     73
     74        * Localizations/en.lproj/localizedStrings.js:
     75
    1762019-09-18  Devin Rousso  <drousso@apple.com>
    277

  • trunk/Source/WebInspectorUI/Localizations/en.lproj/localizedStrings.js

    r250087 r250114  
    267267localizedStrings["Compression"] = "Compression";
    268268localizedStrings["Compression:"] = "Compression:";
     269localizedStrings["Compute"] = "Compute";
     270localizedStrings["Compute Pipeline %d"] = "Compute Pipeline %d";
     271localizedStrings["Compute Shader"] = "Compute Shader";
    269272localizedStrings["Computed"] = "Computed";
    270273localizedStrings["Condition"] = "Condition";
    … …  
    464467localizedStrings["Entered Full-Screen Mode"] = "Entered Full-Screen Mode";
    465468localizedStrings["Entire Recording"] = "Entire Recording";
     469localizedStrings["Entry point: "] = "Entry point: ";
    466470localizedStrings["Error"] = "Error";
    467471localizedStrings["Error: "] = "Error: ";
    … …  
    882886localizedStrings["Remove this breakpoint action"] = "Remove this breakpoint action";
    883887localizedStrings["Removed descendant "] = "Removed descendant ";
     888localizedStrings["Render Pipeline %d"] = "Render Pipeline %d";
    884889localizedStrings["Rendering Frames"] = "Rendering Frames";
    885890localizedStrings["Repeating Linear Gradient"] = "Repeating Linear Gradient";
    … …  
    9981003localizedStrings["Setter"] = "Setter";
    9991004localizedStrings["Settings"] = "Settings";
    1000 localizedStrings["Shader"] = "Shader";
    10011005localizedStrings["Shader Programs"] = "Shader Programs";
    10021006localizedStrings["Shadow Content"] = "Shadow Content";

  • trunk/Source/WebInspectorUI/UserInterface/Controllers/CanvasManager.js

    r249786 r250114  
    235235    }
    236236
    237     programCreated(canvasIdentifier, programIdentifier)
     237    programCreated(canvasIdentifier, programIdentifier, programType)
    238238    {
    239239        let canvas = this._canvasIdentifierMap.get(canvasIdentifier);
    … …  
    244244        console.assert(!this._shaderProgramIdentifierMap.has(programIdentifier), `ShaderProgram already exists with id ${programIdentifier}.`);
    245245
    246         let program = new WI.ShaderProgram(programIdentifier, canvas);
     246        // COMPATIBILITY (iOS 13): `programType` did not exist yet.
     247        if (!programType)
     248            programType = WI.ShaderProgram.ProgramType.Render;
     249
     250        let program = new WI.ShaderProgram(programIdentifier, programType, canvas);
    247251        this._shaderProgramIdentifierMap.set(program.identifier, program);
    248252

  • trunk/Source/WebInspectorUI/UserInterface/Models/Canvas.js

    r249786 r250114  
    4646        this._recordingCollection = new WI.RecordingCollection;
    4747
    48         this._nextShaderProgramDisplayNumber = 1;
     48        this._nextShaderProgramDisplayNumber = null;
    4949
    5050        this._requestNodePromise = null;
    … …  
    410410    }
    411411
    412     nextShaderProgramDisplayNumber()
     412    nextShaderProgramDisplayNumberForProgramType(programType)
    413413    {
    414414        // Called from WI.ShaderProgram.
    415415
    416         return this._nextShaderProgramDisplayNumber++;
     416        if (!this._nextShaderProgramDisplayNumber)
     417            this._nextShaderProgramDisplayNumber = {};
     418
     419        this._nextShaderProgramDisplayNumber[programType] = (this._nextShaderProgramDisplayNumber[programType] || 0) + 1;
     420        return this._nextShaderProgramDisplayNumber[programType];
    417421    }
    418422};

  • trunk/Source/WebInspectorUI/UserInterface/Models/ShaderProgram.js

    r249513 r250114  
    2626WI.ShaderProgram = class ShaderProgram extends WI.Object
    2727{
    28     constructor(identifier, canvas)
     28    constructor(identifier, programType, canvas)
    2929    {
    3030        console.assert(identifier);
     31        console.assert(Object.values(ShaderProgram.ProgramType).includes(programType));
    3132        console.assert(canvas instanceof WI.Canvas);
     33        console.assert(ShaderProgram.contextTypeSupportsProgramType(canvas.contextType, programType));
    3234
    3335        super();
    3436
    3537        this._identifier = identifier;
     38        this._programType = programType;
    3639        this._canvas = canvas;
    37         this._uniqueDisplayNumber = canvas.nextShaderProgramDisplayNumber();
    3840        this._disabled = false;
     41    }
     42
     43    // Static
     44
     45    static contextTypeSupportsProgramType(contextType, programType)
     46    {
     47        switch (contextType) {
     48        case WI.Canvas.ContextType.WebGL:
     49        case WI.Canvas.ContextType.WebGL2:
     50            return programType === ShaderProgram.ProgramType.Render;
     51
     52        case WI.Canvas.ContextType.WebGPU:
     53            return programType === ShaderProgram.ProgramType.Compute
     54                || programType === ShaderProgram.ProgramType.Render;
     55        }
     56
     57        console.assert();
     58        return false;
     59    }
     60
     61    static programTypeSupportsShaderType(programType, shaderType)
     62    {
     63        switch (programType) {
     64        case ShaderProgram.ProgramType.Compute:
     65            return shaderType === ShaderProgram.ShaderType.Compute;
     66
     67        case ShaderProgram.ProgramType.Render:
     68            return shaderType === ShaderProgram.ShaderType.Fragment
     69                || shaderType === ShaderProgram.ShaderType.Vertex;
     70        }
     71
     72        console.assert();
     73        return false;
    3974    }
    4075
    … …  
    4277
    4378    get identifier() { return this._identifier; }
     79    get programType() { return this._programType; }
    4480    get canvas() { return this._canvas; }
    4581
    4682    get displayName()
    4783    {
    48         return WI.UIString("Program %d").format(this._uniqueDisplayNumber);
     84        let format = null;
     85        switch (this._canvas.contextType) {
     86        case WI.Canvas.ContextType.WebGL:
     87        case WI.Canvas.ContextType.WebGL2:
     88            format = WI.UIString("Program %d");
     89            break;
     90        case WI.Canvas.ContextType.WebGPU:
     91            switch (this._programType) {
     92            case ShaderProgram.ProgramType.Compute:
     93                format = WI.UIString("Compute Pipeline %d");
     94                break;
     95            case ShaderProgram.ProgramType.Render:
     96                format = WI.UIString("Render Pipeline %d");
     97                break;
     98            }
     99            break;
     100        }
     101        console.assert(format);
     102        if (!this._uniqueDisplayNumber)
     103            this._uniqueDisplayNumber = this._canvas.nextShaderProgramDisplayNumberForProgramType(this._programType);
     104        return format.format(this._uniqueDisplayNumber);
    49105    }
    50106
    … …  
    56112    set disabled(disabled)
    57113    {
     114        console.assert(this._programType === ShaderProgram.ProgramType.Render);
     115        console.assert(this._canvas.contextType === WI.Canvas.ContextType.WebGL || this._canvas.contextType === WI.Canvas.ContextType.WebGL2);
     116
     117        if (this._canvas.contextType === WI.Canvas.ContextType.WebGPU)
     118            return;
     119
    58120        if (this._disabled === disabled)
    59121            return;
    … …  
    66128    }
    67129
    68     requestVertexShaderSource(callback)
     130    requestShaderSource(shaderType, callback)
    69131    {
    70         this._requestShaderSource(CanvasAgent.ShaderType.Vertex, callback);
     132        console.assert(Object.values(ShaderProgram.ShaderType).includes(shaderType));
     133        console.assert(ShaderProgram.programTypeSupportsShaderType(this._programType, shaderType));
     134
     135        // COMPATIBILITY (iOS 13): `content` was renamed to `source`.
     136        CanvasAgent.requestShaderSource(this._identifier, shaderType, (error, source) => {
     137            if (error) {
     138                WI.reportInternalError(error);
     139                callback(null, null);
     140                return;
     141            }
     142
     143            callback(source);
     144        });
    71145    }
    72146
    73     requestFragmentShaderSource(callback)
     147    updateShader(shaderType, source)
    74148    {
    75         this._requestShaderSource(CanvasAgent.ShaderType.Fragment, callback);
    76     }
     149        console.assert(Object.values(ShaderProgram.ShaderType).includes(shaderType));
     150        console.assert(ShaderProgram.programTypeSupportsShaderType(this._programType, shaderType));
    77151
    78     updateVertexShader(source)
    79     {
    80         this._updateShader(CanvasAgent.ShaderType.Vertex, source);
    81     }
    82 
    83     updateFragmentShader(source)
    84     {
    85         this._updateShader(CanvasAgent.ShaderType.Fragment, source);
     152        CanvasAgent.updateShader(this._identifier, shaderType, source);
    86153    }
    87154
    88155    showHighlight()
    89156    {
    90         const highlighted = true;
    91         CanvasAgent.setShaderProgramHighlighted(this._identifier, highlighted, (error) => {
    92             console.assert(!error, error);
    93         });
     157        console.assert(this._programType === ShaderProgram.ProgramType.Render);
     158        console.assert(this._canvas.contextType === WI.Canvas.ContextType.WebGL || this._canvas.contextType === WI.Canvas.ContextType.WebGL2);
     159
     160        CanvasAgent.setShaderProgramHighlighted(this._identifier, true);
    94161    }
    95162
    96163    hideHighlight()
    97164    {
    98         const highlighted = false;
    99         CanvasAgent.setShaderProgramHighlighted(this._identifier, highlighted, (error) => {
    100             console.assert(!error, error);
    101         });
    102     }
     165        console.assert(this._programType === ShaderProgram.ProgramType.Render);
     166        console.assert(this._canvas.contextType === WI.Canvas.ContextType.WebGL || this._canvas.contextType === WI.Canvas.ContextType.WebGL2);
    103167
    104     // Private
    105 
    106     _requestShaderSource(shaderType, callback)
    107     {
    108         CanvasAgent.requestShaderSource(this._identifier, shaderType, (error, content) => {
    109             if (error) {
    110                 callback(null);
    111                 return;
    112             }
    113 
    114             callback(content);
    115         });
    116     }
    117 
    118     _updateShader(shaderType, source)
    119     {
    120         CanvasAgent.updateShader(this._identifier, shaderType, source, (error) => {
    121             console.assert(!error, error);
    122         });
     168        CanvasAgent.setShaderProgramHighlighted(this._identifier, false);
    123169    }
    124170};
    125171
     172WI.ShaderProgram.ProgramType = {
     173    Compute: "compute",
     174    Render: "render",
     175};
     176
    126177WI.ShaderProgram.ShaderType = {
    127     Fragment: "shader-type-fragment",
    128     Vertex: "shader-type-vertex",
     178    Compute: "compute",
     179    Fragment: "fragment",
     180    Vertex: "vertex",
    129181};
    130182

  • trunk/Source/WebInspectorUI/UserInterface/Protocol/CanvasObserver.js

    r249786 r250114  
    6868    }
    6969
    70     programCreated(canvasId, programId)
     70    programCreated(canvasId, programId, programType)
    7171    {
    72         WI.canvasManager.programCreated(canvasId, programId);
     72        WI.canvasManager.programCreated(canvasId, programId, programType);
    7373    }
    7474

  • trunk/Source/WebInspectorUI/UserInterface/Views/CodeMirrorAdditions.js

    r248898 r250114  
    683683        CodeMirror.defineMIME(type, {name: "javascript", json: true});
    684684    });
     685
     686    // FIXME: Add WHLSL specific modes.
     687    CodeMirror.defineMIME("x-pipeline/x-compute", "x-shader/x-vertex");
     688    CodeMirror.defineMIME("x-pipeline/x-fragment", "x-shader/x-fragment");
     689    CodeMirror.defineMIME("x-pipeline/x-vertex", "x-shader/x-vertex");
    685690})();
    686691

  • trunk/Source/WebInspectorUI/UserInterface/Views/ShaderProgramContentView.css

    r242194 r250114  
    2424 */
    2525
    26 .content-view.shader-program > .text-editor.shader {
     26.content-view.shader-program > .shader {
     27    display: flex;
     28    flex-direction: column;
    2729    position: absolute;
    2830    top: 0;
    2931    bottom: 0;
    30 
    31     --border-start-style: 1px solid lightgrey;
    3232}
    3333
    34 body[dir=ltr] .content-view.shader-program > .text-editor.shader.vertex,
    35 body[dir=rtl] .content-view.shader-program > .text-editor.shader.fragment {
     34.content-view.shader-program > .shader.compute {
     35    right: 0;
     36    left: 0;
     37}
     38
     39body[dir=ltr] .content-view.shader-program > .shader.vertex,
     40body[dir=rtl] .content-view.shader-program > .shader.fragment {
    3641    width: calc(50% - 1px);
    3742    left: 0;
    3843}
    3944
    40 body[dir=ltr] .content-view.shader-program > .text-editor.shader.fragment,
    41 body[dir=rtl] .content-view.shader-program > .text-editor.shader.vertex {
     45body[dir=ltr] .content-view.shader-program > .shader.fragment,
     46body[dir=rtl] .content-view.shader-program > .shader.vertex {
    4247    width: calc(50% + 1px);
    4348    right: 0;
    4449}
    4550
    46 body[dir=ltr] .content-view.shader-program > .text-editor.shader + .text-editor.shader {
    47     border-left: var(--border-start-style);
     51.content-view.shader-program > .shader + .shader {
     52    border-left: 1px solid var(--border-color);
    4853}
    4954
    50 body[dir=rtl] .content-view.shader-program > .text-editor.shader + .text-editor.shader {
    51     border-right: var(--border-start-style);
    52 }
    53 
    54 .content-view.shader-program > .text-editor.shader > .type-title {
     55.content-view.shader-program > .shader > header > * {
    5556    padding: 2px 4px;
    56     background-color: hsl(0, 0%, 95%);
    5757    border-bottom: 1px solid lightgrey;
    5858}
    5959
    60 .content-view.shader-program > .text-editor.shader > .CodeMirror {
    61     top: 18px;
     60.content-view.shader-program > .shader > header > .shader-type {
     61    background-color: hsl(0, 0%, 95%);
    6262}
    6363
    6464@media (prefers-color-scheme: dark) {
    65     .content-view.shader-program > .text-editor.shader {
    66         --border-start-style: 1px solid var(--text-color-quaternary);
    67     }
    68 
    69     .content-view.shader-program > .text-editor.shader > .type-title {
     65    .content-view.shader-program > .shader > header {
    7066        background-color: var(--background-color);
    7167        border-bottom-color: var(--text-color-quaternary);

  • trunk/Source/WebInspectorUI/UserInterface/Views/ShaderProgramContentView.js

    r246419 r250114  
    3232        super(shaderProgram);
    3333
     34        let isWebGPU = this.representedObject.contextType === WI.Canvas.ContextType.WebGPU;
     35
     36        this._refreshButtonNavigationItem = new WI.ButtonNavigationItem("refresh", WI.UIString("Refresh"), "Images/ReloadFull.svg", 13, 13);
     37        this._refreshButtonNavigationItem.visibilityPriority = WI.NavigationItem.VisibilityPriority.Low;
     38        this._refreshButtonNavigationItem.addEventListener(WI.ButtonNavigationItem.Event.Clicked, this._refreshContent, this);
     39
    3440        let contentDidChangeDebouncer = new Debouncer((event) => {
    3541            this._contentDidChange(event);
    3642        });
    3743
    38         this.element.classList.add("shader-program");
     44        this.element.classList.add("shader-program", this.representedObject.programType);
    3945
    4046        let createEditor = (shaderType) => {
     47            let container = this.element.appendChild(document.createElement("div"));
     48
     49            let header = container.appendChild(document.createElement("header"));
     50
     51            let shaderTypeContainer = header.appendChild(document.createElement("div"));
     52            shaderTypeContainer.classList.add("shader-type");
     53
    4154            let textEditor = new WI.TextEditor;
    4255            textEditor.readOnly = false;
    … …  
    4659                contentDidChangeDebouncer.delayForTime(250, event);
    4760            }, this);
    48             textEditor.element.classList.add("shader");
    49 
    50             let shaderTypeContainer = textEditor.element.insertAdjacentElement("afterbegin", document.createElement("div"));
    51             shaderTypeContainer.classList.add("type-title");
    5261
    5362            switch (shaderType) {
     63            case WI.ShaderProgram.ShaderType.Compute:
     64                shaderTypeContainer.textContent = WI.UIString("Compute Shader");
     65                textEditor.mimeType = isWebGPU ? "x-pipeline/x-compute" : "x-shader/x-compute";
     66                break;
     67
     68            case WI.ShaderProgram.ShaderType.Fragment:
     69                shaderTypeContainer.textContent = WI.UIString("Fragment Shader");
     70                textEditor.mimeType = isWebGPU ? "x-pipeline/x-fragment" : "x-shader/x-fragment";
     71                break;
     72
    5473            case WI.ShaderProgram.ShaderType.Vertex:
    5574                shaderTypeContainer.textContent = WI.UIString("Vertex Shader");
    56                 textEditor.mimeType = "x-shader/x-vertex";
    57                 textEditor.element.classList.add("vertex");
    58                 break;
    59 
    60             case WI.ShaderProgram.ShaderType.Fragment:
    61                 shaderTypeContainer.textContent = WI.UIString("Fragment Shader");
    62                 textEditor.mimeType = "x-shader/x-fragment";
    63                 textEditor.element.classList.add("fragment");
     75                textEditor.mimeType = isWebGPU ? "x-pipeline/x-vertex" : "x-shader/x-vertex";
    6476                break;
    6577            }
    6678
    6779            this.addSubview(textEditor);
    68             return textEditor;
     80            container.appendChild(textEditor.element);
     81            container.classList.add("shader", shaderType);
     82
     83            return {container, textEditor};
    6984        };
    7085
    71         this._vertexEditor = createEditor(WI.ShaderProgram.ShaderType.Vertex);
    72         this._fragmentEditor = createEditor(WI.ShaderProgram.ShaderType.Fragment);
    73         this._lastActiveEditor = this._vertexEditor;
     86        switch (this.representedObject.programType) {
     87        case WI.ShaderProgram.ProgramType.Compute: {
     88            let computeEditor = createEditor(WI.ShaderProgram.ShaderType.Compute);
     89            this._computeContainer = computeEditor.container;
     90            this._computeEditor = computeEditor.textEditor;
     91
     92            this._lastActiveEditor = this._computeEditor;
     93            break;
     94        }
     95
     96        case WI.ShaderProgram.ProgramType.Render: {
     97            let vertexEditor = createEditor(WI.ShaderProgram.ShaderType.Vertex);
     98            this._vertexContainer = vertexEditor.container;
     99            this._vertexEditor = vertexEditor.textEditor;
     100
     101            let fragmentEditor = createEditor(WI.ShaderProgram.ShaderType.Fragment);
     102            this._fragmentContainer = fragmentEditor.container;
     103            this._fragmentEditor = fragmentEditor.textEditor;
     104
     105            this._lastActiveEditor = this._vertexEditor;
     106            break;
     107        }
     108        }
     109    }
     110
     111    // Public
     112
     113    get navigationItems()
     114    {
     115        return [this._refreshButtonNavigationItem];
    74116    }
    75117
    … …  
    80122        super.shown();
    81123
    82         this._vertexEditor.shown();
    83         this._fragmentEditor.shown();
    84 
    85         this.representedObject.requestVertexShaderSource((content) => {
    86             this._vertexEditor.string = content || "";
    87         });
    88 
    89         this.representedObject.requestFragmentShaderSource((content) => {
    90             this._fragmentEditor.string = content || "";
    91         });
     124        switch (this.representedObject.programType) {
     125        case WI.ShaderProgram.ProgramType.Compute:
     126            this._computeEditor.shown();
     127            break;
     128
     129        case WI.ShaderProgram.ProgramType.Render:
     130            this._vertexEditor.shown();
     131            this._fragmentEditor.shown();
     132            break;
     133        }
     134
     135        this._refreshContent();
    92136    }
    93137
    94138    hidden()
    95139    {
    96         this._vertexEditor.hidden();
    97         this._fragmentEditor.hidden();
     140        switch (this.representedObject.programType) {
     141        case WI.ShaderProgram.ProgramType.Compute:
     142            this._computeEditor.hidden();
     143            break;
     144
     145        case WI.ShaderProgram.ProgramType.Render:
     146            this._vertexEditor.hidden();
     147            this._fragmentEditor.hidden();
     148            break;
     149        }
    98150
    99151        super.hidden();
    … …  
    107159    get saveData()
    108160    {
    109         let filename = WI.UIString("Shader");
    110         if (this._lastActiveEditor === this._vertexEditor)
     161        let filename = "";
     162        switch (this._lastActiveEditor) {
     163        case this._computeEditor:
     164            filename = WI.UIString("Compute");
     165            break;
     166        case this._fragmentEditor:
     167            filename = WI.UIString("Fragment");
     168            break;
     169        case this._vertexEditor:
    111170            filename = WI.UIString("Vertex");
    112         else if (this._lastActiveEditor === this._fragmentEditor)
    113             filename = WI.UIString("Fragment");
     171            break;
     172        }
     173        console.assert(filename);
     174
     175        let extension = "";
     176        switch (this.representedObject.canvas.contextType) {
     177        case WI.Canvas.ContextType.WebGL:
     178        case WI.Canvas.ContextType.WebGL2:
     179            extension = WI.unlocalizedString(".glsl");
     180            break;
     181        case WI.Canvas.ContextType.WebGPU:
     182            extension = WI.unlocalizedString(".wsl");
     183            break;
     184        }
     185        console.assert(extension);
    114186
    115187        return {
    116             url: WI.FileUtilities.inspectorURLForFilename(filename + ".glsl"),
     188            url: WI.FileUtilities.inspectorURLForFilename(filename + extension),
    117189            content: this._lastActiveEditor.string,
    118190            forceSaveAs: true,
    … …  
    172244    // Private
    173245
     246    _refreshContent()
     247    {
     248        let createCallback = (container, textEditor) => {
     249            return (source, entryPoint) => {
     250                if (source === null) {
     251                    container.remove();
     252                    return;
     253                }
     254
     255                if (!container.parentNode) {
     256                    switch (container) {
     257                    case this._computeContainer:
     258                    case this._vertexContainer:
     259                        this.element.insertAdjacentElement("afterbegin", container);
     260                        break;
     261
     262                    case this._fragmentContainer:
     263                        this.element.insertAdjacentElement("beforeend", container);
     264                        break;
     265                    }
     266                }
     267
     268                textEditor.string = source || "";
     269            };
     270        };
     271
     272        switch (this.representedObject.programType) {
     273        case WI.ShaderProgram.ProgramType.Compute:
     274            this.representedObject.requestShaderSource(WI.ShaderProgram.ShaderType.Compute, createCallback(this._computeContainer, this._computeEditor));
     275            return;
     276
     277        case WI.ShaderProgram.ProgramType.Render:
     278            this.representedObject.requestShaderSource(WI.ShaderProgram.ShaderType.Vertex, createCallback(this._vertexContainer, this._vertexEditor));
     279            this.representedObject.requestShaderSource(WI.ShaderProgram.ShaderType.Fragment, createCallback(this._fragmentContainer, this._fragmentEditor));
     280            return;
     281        }
     282
     283        console.assert();
     284    }
     285
     286    _updateShader(shaderType)
     287    {
     288        switch (shaderType) {
     289        case WI.ShaderProgram.ShaderType.Compute:
     290            this.representedObject.updateShader(shaderType, this._computeEditor.string);
     291            return;
     292
     293        case WI.ShaderProgram.ShaderType.Fragment:
     294            this.representedObject.updateShader(shaderType, this._fragmentEditor.string);
     295            return;
     296
     297        case WI.ShaderProgram.ShaderType.Vertex:
     298            this.representedObject.updateShader(shaderType, this._vertexEditor.string);
     299            return;
     300        }
     301
     302        console.assert();
     303    }
     304
    174305    _editorFocused(event)
    175306    {
    … …  
    198329    _contentDidChange(event)
    199330    {
    200         if (event.target === this._vertexEditor)
    201             this.representedObject.updateVertexShader(this._vertexEditor.string);
    202         else if (event.target === this._fragmentEditor)
    203             this.representedObject.updateFragmentShader(this._fragmentEditor.string);
     331        switch (event.target) {
     332        case this._computeEditor:
     333            this._updateShader(WI.ShaderProgram.ShaderType.Compute);
     334            return;
     335
     336        case this._fragmentEditor:
     337            this._updateShader(WI.ShaderProgram.ShaderType.Fragment);
     338            return;
     339
     340        case this._vertexEditor:
     341            this._updateShader(WI.ShaderProgram.ShaderType.Vertex);
     342            return;
     343        }
     344
     345        console.assert();
    204346    }
    205347};

  • trunk/Source/WebInspectorUI/UserInterface/Views/ShaderProgramTreeElement.js

    r249513 r250114  
    3333        super("shader-program", shaderProgram.displayName, subtitle, shaderProgram);
    3434
    35         this._disabledImageElement = document.createElement("img");
    36         this._disabledImageElement.title = WI.UIString("Disable Program");
    37         this._disabledImageElement.addEventListener("click", this._disabledImageElementClicked.bind(this));
    38         this.status = this._disabledImageElement;
     35        // FIXME: add support for disabling/highlighting WebGPU shader pipelines.
     36        let contextType = this.representedObject.canvas.contextType;
     37        if (contextType === WI.Canvas.ContextType.WebGL || contextType === WI.Canvas.ContextType.WebGL2) {
     38            this._disabledImageElement = document.createElement("img");
     39            this._disabledImageElement.title = WI.UIString("Disable Program");
     40            this._disabledImageElement.addEventListener("click", this._disabledImageElementClicked.bind(this));
     41            this.status = this._disabledImageElement;
     42        }
    3943    }
    4044
    … …  
    4549        super.onattach();
    4650
    47         this.representedObject.addEventListener(WI.ShaderProgram.Event.DisabledChanged, this._handleShaderProgramDisabledChanged, this);
     51        // FIXME: add support for disabling/highlighting WebGPU shader pipelines.
     52        let contextType = this.representedObject.canvas.contextType;
     53        if (contextType === WI.Canvas.ContextType.WebGL || contextType === WI.Canvas.ContextType.WebGL2) {
     54            this.representedObject.addEventListener(WI.ShaderProgram.Event.DisabledChanged, this._handleShaderProgramDisabledChanged, this);
    4855
    49         this.element.addEventListener("mouseover", this._handleMouseOver.bind(this));
    50         this.element.addEventListener("mouseout", this._handleMouseOut.bind(this));
     56            this.element.addEventListener("mouseover", this._handleMouseOver.bind(this));
     57            this.element.addEventListener("mouseout", this._handleMouseOut.bind(this));
     58        }
    5159    }
    5260
    5361    ondetach()
    5462    {
    55         this.representedObject.removeEventListener(WI.ShaderProgram.Event.DisabledChanged, this._handleShaderProgramDisabledChanged, this);
     63        // FIXME: add support for disabling/highlighting WebGPU shader pipelines.
     64        let contextType = this.representedObject.canvas.contextType;
     65        if (contextType === WI.Canvas.ContextType.WebGL || contextType === WI.Canvas.ContextType.WebGL2)
     66            this.representedObject.removeEventListener(WI.ShaderProgram.Event.DisabledChanged, this._handleShaderProgramDisabledChanged, this);
    5667
    5768        super.ondetach();
    … …  
    6071    canSelectOnMouseDown(event)
    6172    {
    62         if (this._disabledImageElement.contains(event.target))
     73        if (this._disabledImageElement && this._disabledImageElement.contains(event.target))
    6374            return false;
    6475        return super.canSelectOnMouseDown(event);
    … …  
    6778    populateContextMenu(contextMenu, event)
    6879    {
    69         let disabled = this.representedObject.disabled;
    70         contextMenu.appendItem(disabled ? WI.UIString("Enable Program") : WI.UIString("Disable Program"), () => {
    71             this.representedObject.disabled = !disabled;
    72         });
     80        // FIXME: add support for disabling/highlighting WebGPU shader pipelines.
     81        let contextType = this.representedObject.canvas.contextType;
     82        if (contextType === WI.Canvas.ContextType.WebGL || contextType === WI.Canvas.ContextType.WebGL2) {
     83            let disabled = this.representedObject.disabled;
     84            contextMenu.appendItem(disabled ? WI.UIString("Enable Program") : WI.UIString("Disable Program"), () => {
     85                this.representedObject.disabled = !disabled;
     86            });
    7387
    74         contextMenu.appendSeparator();
     88            contextMenu.appendSeparator();
     89        }
    7590
    7691        super.populateContextMenu(contextMenu, event);
Note: See TracChangeset for help on using the changeset viewer.