Update WebGPU: GPURenderPassDepthStencilAttachment (#16429)

* Update WebGPU: GPURenderPassDepthStencilAttachment

* include cmath instead

* fixes multiple load op, store op; remove deprecations clear colors etc.

* fix StoreOp helper

* fix loadOp, storeOp library_webgpu impl

* add support for deprecated

* fix loadOp int

* small fixes

* fix compile issue; use new depth/stencil clear value for deprecated fields

Co-authored-by: Kai Ninomiya <[email protected]>

Author: shrekshao

src/library_webgpu.js

@@ -112,8 +112,14 @@
       Fifo: 2,
     },
     LoadOp: {
-      Clear: 0,
-      Load: 1,
+      Undefined: 0,
+      Clear: 1,
+      Load: 2,
+    },
+    StoreOp: {
+      Undefined: 0,
+      Store: 1,
+      Discard: 2,
     },
     MapMode: {
       None: 0,
@@ -391,6 +397,11 @@ var LibraryWebGPU = {
       'uint16',
       'uint32',
     ],
+    LoadOp: [
+      undefined,
+      'clear',
+      'load',
+    ],
     PipelineStatisticName: [
       'vertex-shader-invocations',
       'clipper-invocations',
@@ -1491,19 +1502,26 @@ var LibraryWebGPU = {
     function makeColorAttachment(caPtr) {
       var loadOpInt = {{{ gpu.makeGetU32('caPtr', C_STRUCTS.WGPURenderPassColorAttachment.loadOp) }}};
       #if ASSERTIONS
-          assert(loadOpInt === {{{ gpu.LoadOp.Clear }}} || loadOpInt === {{{ gpu.LoadOp.Load }}});
+          assert(loadOpInt !== {{{ gpu.LoadOp.Undefined }}});
+      #endif
+
+      var storeOpInt = {{{ gpu.makeGetU32('caPtr', C_STRUCTS.WGPURenderPassColorAttachment.storeOp) }}};
+      #if ASSERTIONS
+          assert(storeOpInt !== {{{ gpu.StoreOp.Undefined }}});
       #endif
-      var loadValue = loadOpInt ? 'load' :
-        WebGPU.makeColor(caPtr + {{{ C_STRUCTS.WGPURenderPassColorAttachment.clearColor }}});
+
+      var clearValue = WebGPU.makeColor(caPtr + {{{ C_STRUCTS.WGPURenderPassColorAttachment.clearValue }}});
 
       return {
         "view": WebGPU.mgrTextureView.get(
           {{{ gpu.makeGetU32('caPtr', C_STRUCTS.WGPURenderPassColorAttachment.view) }}}),
         "resolveTarget": WebGPU.mgrTextureView.get(
           {{{ gpu.makeGetU32('caPtr', C_STRUCTS.WGPURenderPassColorAttachment.resolveTarget) }}}),
-        "storeOp": WebGPU.StoreOp[
-          {{{ gpu.makeGetU32('caPtr', C_STRUCTS.WGPURenderPassColorAttachment.storeOp) }}}],
-        "loadValue": loadValue,
+        "clearValue": clearValue,
+        "loadOp":  WebGPU.LoadOp[loadOpInt],
+        "storeOp": WebGPU.StoreOp[storeOpInt],
+        // TODO(shrekshao): remove deprecated path once browser (chrome) API update comes to stable (M101)
+        "loadValue": loadOpInt === {{{ gpu.LoadOp.Load }}} ? 'load' : clearValue,
       };
     }
 
@@ -1519,30 +1537,26 @@ var LibraryWebGPU = {
       if (dsaPtr === 0) return undefined;
 
       var depthLoadOpInt = {{{ gpu.makeGetU32('dsaPtr', C_STRUCTS.WGPURenderPassDepthStencilAttachment.depthLoadOp) }}};
-      #if ASSERTIONS
-          assert(depthLoadOpInt === {{{ gpu.LoadOp.Clear }}} || depthLoadOpInt === {{{ gpu.LoadOp.Load }}});
-      #endif
-      var depthLoadValue = depthLoadOpInt ? 'load' :
-        {{{ makeGetValue('dsaPtr', C_STRUCTS.WGPURenderPassDepthStencilAttachment.clearDepth, 'float') }}};
-
+      var depthClearValue = {{{ makeGetValue('dsaPtr', C_STRUCTS.WGPURenderPassDepthStencilAttachment.depthClearValue, 'float') }}};
       var stencilLoadOpInt = {{{ gpu.makeGetU32('dsaPtr', C_STRUCTS.WGPURenderPassDepthStencilAttachment.stencilLoadOp) }}};
-      #if ASSERTIONS
-          assert(stencilLoadOpInt === {{{ gpu.LoadOp.Clear }}} || stencilLoadOpInt === {{{ gpu.LoadOp.Load }}});
-      #endif
-      var stencilLoadValue = stencilLoadOpInt ? 'load' :
-        {{{ gpu.makeGetU32('dsaPtr', C_STRUCTS.WGPURenderPassDepthStencilAttachment.clearStencil) }}};
+      var stencilClearValue = {{{ gpu.makeGetU32('dsaPtr', C_STRUCTS.WGPURenderPassDepthStencilAttachment.stencilClearValue) }}};
 
       return {
         "view": WebGPU.mgrTextureView.get(
           {{{ gpu.makeGetU32('dsaPtr', C_STRUCTS.WGPURenderPassDepthStencilAttachment.view) }}}),
+        "depthClearValue": depthClearValue,
+        "depthLoadOp": WebGPU.LoadOp[depthLoadOpInt],
         "depthStoreOp": WebGPU.StoreOp[
           {{{ gpu.makeGetU32('dsaPtr', C_STRUCTS.WGPURenderPassDepthStencilAttachment.depthStoreOp) }}}],
-        "depthLoadValue": depthLoadValue,
         "depthReadOnly": {{{ gpu.makeGetBool('dsaPtr', C_STRUCTS.WGPURenderPassDepthStencilAttachment.depthReadOnly) }}},
+        "stencilClearValue": stencilClearValue,
+        "stencilLoadOp": WebGPU.LoadOp[stencilLoadOpInt],
         "stencilStoreOp": WebGPU.StoreOp[
           {{{ gpu.makeGetU32('dsaPtr', C_STRUCTS.WGPURenderPassDepthStencilAttachment.stencilStoreOp) }}}],
-        "stencilLoadValue": stencilLoadValue,
         "stencilReadOnly": {{{ gpu.makeGetBool('dsaPtr', C_STRUCTS.WGPURenderPassDepthStencilAttachment.stencilReadOnly) }}},
+        // TODO(shrekshao): remove deprecated path once browser (chrome) API update comes to stable (M101)
+        "depthLoadValue": depthLoadOpInt === {{{ gpu.LoadOp.Load }}} ? 'load' : depthClearValue,
+        "stencilLoadValue": stencilLoadOpInt === {{{ gpu.LoadOp.Load }}} ? 'load' : stencilClearValue,
       };
     }
 
@@ -1576,9 +1590,9 @@ var LibraryWebGPU = {
 
     var buffer = WebGPU.mgrBuffer.get(bufferId);
     commandEncoder["clearBuffer"](
-      buffer, 
+      buffer,
       {{{ gpu.makeU64ToNumber('offset_low', 'offset_high') }}},
-      {{{ gpu.makeU64ToNumber('size_low', 'size_high') }}} 
+      {{{ gpu.makeU64ToNumber('size_low', 'size_high') }}}
     );
   },
 

src/struct_info.json

@@ -1288,11 +1288,11 @@
                 "view",
                 "depthLoadOp",
                 "depthStoreOp",
-                "clearDepth",
+                "depthClearValue",
                 "depthReadOnly",
                 "stencilLoadOp",
                 "stencilStoreOp",
-                "clearStencil",
+                "stencilClearValue",
                 "stencilReadOnly"
             ],
             "WGPURequestAdapterOptions": [
@@ -1451,7 +1451,7 @@
                 "resolveTarget",
                 "loadOp",
                 "storeOp",
-                "clearColor"
+                "clearValue"
             ],
             "WGPURequiredLimits": [
                 "nextInChain",

system/include/webgpu/webgpu.h

@@ -808,11 +808,11 @@ typedef struct WGPURenderPassDepthStencilAttachment {
     WGPUTextureView view;
     WGPULoadOp depthLoadOp;
     WGPUStoreOp depthStoreOp;
-    float clearDepth;
+    float depthClearValue;
     bool depthReadOnly;
     WGPULoadOp stencilLoadOp;
     WGPUStoreOp stencilStoreOp;
-    uint32_t clearStencil;
+    uint32_t stencilClearValue;
     bool stencilReadOnly;
 } WGPURenderPassDepthStencilAttachment;
 
@@ -995,7 +995,7 @@ typedef struct WGPURenderPassColorAttachment {
     WGPUTextureView resolveTarget;
     WGPULoadOp loadOp;
     WGPUStoreOp storeOp;
-    WGPUColor clearColor;
+    WGPUColor clearValue;
 } WGPURenderPassColorAttachment;
 
 typedef struct WGPURequiredLimits {

system/include/webgpu/webgpu_cpp.h

@@ -4,6 +4,7 @@
 #include "webgpu/webgpu.h"
 
 #include <type_traits>
+#include <cmath>
 
 namespace wgpu {
 
@@ -1372,11 +1373,11 @@ namespace wgpu {
         TextureView view;
         LoadOp depthLoadOp = LoadOp::Undefined;
         StoreOp depthStoreOp = StoreOp::Undefined;
-        float clearDepth = 0;
+        float depthClearValue = 0;
         bool depthReadOnly = false;
         LoadOp stencilLoadOp = LoadOp::Undefined;
         StoreOp stencilStoreOp = StoreOp::Undefined;
-        uint32_t clearStencil = 0;
+        uint32_t stencilClearValue = 0;
         bool stencilReadOnly = false;
     };
 
@@ -1565,7 +1566,7 @@ namespace wgpu {
         TextureView resolveTarget = nullptr;
         LoadOp loadOp;
         StoreOp storeOp;
-        Color clearColor;
+        Color clearValue;
     };
 
     struct RequiredLimits {

system/lib/webgpu/webgpu_cpp.cpp

@@ -998,16 +998,16 @@ namespace wgpu {
             "offsetof mismatch for RenderPassDepthStencilAttachment::depthLoadOp");
     static_assert(offsetof(RenderPassDepthStencilAttachment, depthStoreOp) == offsetof(WGPURenderPassDepthStencilAttachment, depthStoreOp),
             "offsetof mismatch for RenderPassDepthStencilAttachment::depthStoreOp");
-    static_assert(offsetof(RenderPassDepthStencilAttachment, clearDepth) == offsetof(WGPURenderPassDepthStencilAttachment, clearDepth),
-            "offsetof mismatch for RenderPassDepthStencilAttachment::clearDepth");
+    static_assert(offsetof(RenderPassDepthStencilAttachment, depthClearValue) == offsetof(WGPURenderPassDepthStencilAttachment, depthClearValue),
+            "offsetof mismatch for RenderPassDepthStencilAttachment::depthClearValue");
     static_assert(offsetof(RenderPassDepthStencilAttachment, depthReadOnly) == offsetof(WGPURenderPassDepthStencilAttachment, depthReadOnly),
             "offsetof mismatch for RenderPassDepthStencilAttachment::depthReadOnly");
     static_assert(offsetof(RenderPassDepthStencilAttachment, stencilLoadOp) == offsetof(WGPURenderPassDepthStencilAttachment, stencilLoadOp),
             "offsetof mismatch for RenderPassDepthStencilAttachment::stencilLoadOp");
     static_assert(offsetof(RenderPassDepthStencilAttachment, stencilStoreOp) == offsetof(WGPURenderPassDepthStencilAttachment, stencilStoreOp),
             "offsetof mismatch for RenderPassDepthStencilAttachment::stencilStoreOp");
-    static_assert(offsetof(RenderPassDepthStencilAttachment, clearStencil) == offsetof(WGPURenderPassDepthStencilAttachment, clearStencil),
-            "offsetof mismatch for RenderPassDepthStencilAttachment::clearStencil");
+    static_assert(offsetof(RenderPassDepthStencilAttachment, stencilClearValue) == offsetof(WGPURenderPassDepthStencilAttachment, stencilClearValue),
+            "offsetof mismatch for RenderPassDepthStencilAttachment::stencilClearValue");
     static_assert(offsetof(RenderPassDepthStencilAttachment, stencilReadOnly) == offsetof(WGPURenderPassDepthStencilAttachment, stencilReadOnly),
             "offsetof mismatch for RenderPassDepthStencilAttachment::stencilReadOnly");
 
@@ -1366,8 +1366,8 @@ namespace wgpu {
             "offsetof mismatch for RenderPassColorAttachment::loadOp");
     static_assert(offsetof(RenderPassColorAttachment, storeOp) == offsetof(WGPURenderPassColorAttachment, storeOp),
             "offsetof mismatch for RenderPassColorAttachment::storeOp");
-    static_assert(offsetof(RenderPassColorAttachment, clearColor) == offsetof(WGPURenderPassColorAttachment, clearColor),
-            "offsetof mismatch for RenderPassColorAttachment::clearColor");
+    static_assert(offsetof(RenderPassColorAttachment, clearValue) == offsetof(WGPURenderPassColorAttachment, clearValue),
+            "offsetof mismatch for RenderPassColorAttachment::clearValue");
 
     // RequiredLimits
 

tests/reference_struct_info.json

@@ -1015,19 +1015,19 @@
         },
         "WGPURenderPassColorAttachment": {
             "__size__": 48,
-            "clearColor": 16,
+            "clearValue": 16,
             "loadOp": 8,
             "resolveTarget": 4,
             "storeOp": 12,
             "view": 0
         },
         "WGPURenderPassDepthStencilAttachment": {
             "__size__": 36,
-            "clearDepth": 12,
-            "clearStencil": 28,
+            "depthClearValue": 12,
             "depthLoadOp": 4,
             "depthReadOnly": 16,
             "depthStoreOp": 8,
+            "stencilClearValue": 28,
             "stencilLoadOp": 20,
             "stencilReadOnly": 32,
             "stencilStoreOp": 24,

tests/webgpu_basic_rendering.cpp

@@ -121,7 +121,7 @@ void render(wgpu::TextureView view) {
     attachment.view = view;
     attachment.loadOp = wgpu::LoadOp::Clear;
     attachment.storeOp = wgpu::StoreOp::Store;
-    attachment.clearColor = {0, 0, 0, 1};
+    attachment.clearValue = {0, 0, 0, 1};
 
     wgpu::RenderPassDescriptor renderpass{};
     renderpass.colorAttachmentCount = 1;