Revert "[webgpu-headers] Define depthWriteEnabled as WGPUOptionalBool"

This reverts commit 8c230a7. Reason for revert: Probably causing roll failures on Windows build, example: https://ci.chromium.org/ui/p/chromium/builders/try/win-rel/727795/overview Original change's description: > [webgpu-headers] Define depthWriteEnabled as WGPUOptionalBool > > The following CLs must be merged before: > - https://chromium-review.googlesource.com/c/chromium/src/+/5683307 > - https://skia-review.googlesource.com/c/skia/+/874238 > > webgpu-native/webgpu-headers#308 > > Bug: 42241167 > Change-Id: Ib6266b6981fb8caf38b734977ceaeeeed2cf55f9 > Reviewed-on: https://dawn-review.googlesource.com/c/dawn/+/197214 > Reviewed-by: Austin Eng <[email protected]> > Commit-Queue: Fr <[email protected]> # Not skipping CQ checks because original CL landed > 1 day ago. Bug: 42241167 Change-Id: I4fd367f0fb2b23ded925822ba238c64c43a9c3d3 Reviewed-on: https://dawn-review.googlesource.com/c/dawn/+/203463 Reviewed-by: Austin Eng <[email protected]> Reviewed-by: Brandon Jones <[email protected]> Commit-Queue: Brandon Jones <[email protected]> Commit-Queue: Loko Kung <[email protected]>
google · Aug 23, 2024 · 9c2fb60 · 9c2fb60
1 parent 8c1014e
commit 9c2fb60
Show file tree

Hide file tree

Showing 39 changed files with 121 additions and 213 deletions.
diff --git a/generator/dawn_json_generator.py b/generator/dawn_json_generator.py
@@ -145,8 +145,7 @@ def __init__(self, is_enabled, name, json_data):
             value += prefix
 
             if value_name == "undefined":
-                if name != "optional bool":
-                    assert value == 0
+                assert value == 0
                 self.hasUndefined = True
             if value != lastValue + 1:
                 self.contiguousFromZero = False

diff --git a/generator/templates/api.h b/generator/templates/api.h
@@ -73,7 +73,6 @@
 #endif
 
 #define WGPU_BREAKING_CHANGE_DEPTH_CLIP_CONTROL
-#define WGPU_BREAKING_CHANGE_DEPTH_WRITE_ENABLED
 
 #include <stdint.h>
 #include <stddef.h>

diff --git a/generator/templates/api_cpp.h b/generator/templates/api_cpp.h
@@ -100,9 +100,7 @@ static T& AsNonConstReference(const T& value) {
     )
 {%- endmacro -%}
 
-//* Although 'optional bool' is defined as an enum value, in C++, we manually implement it to
-//* provide conversion utilities.
-{% for type in by_category["enum"] if type.name.get() != "optional bool" %}
+{% for type in by_category["enum"] %}
     {% set CppType = as_cppType(type.name) %}
     {% set CType = as_cType(type.name) %}
     enum class {{CppType}} : uint32_t {
@@ -155,67 +153,6 @@ class {{BoolCppType}} {
     {{BoolCType}} mValue = static_cast<{{BoolCType}}>(false);
 };
 
-// Special class for optional booleans in order to allow conversions.
-{% set OptionalBool = types["optional bool"] %}
-{% set OptionalBoolCppType = as_cppType(OptionalBool.name) %}
-{% set OptionalBoolCType = as_cType(OptionalBool.name) %}
-{% set OptionalBoolUndefined = as_cEnum(OptionalBool.name, find_by_name(OptionalBool.values, "undefined").name) %}
-class {{OptionalBoolCppType}} {
-  public:
-    constexpr {{OptionalBoolCppType}}() = default;
-    // NOLINTNEXTLINE(runtime/explicit) allow implicit construction
-    constexpr {{OptionalBoolCppType}}(bool value) : mValue(static_cast<{{OptionalBoolCType}}>(value)) {}
-    // NOLINTNEXTLINE(runtime/explicit) allow implicit construction
-    constexpr {{OptionalBoolCppType}}(std::optional<bool> value) :
-        mValue(value ? static_cast<{{OptionalBoolCType}}>(*value) : {{OptionalBoolUndefined}}) {}
-    // NOLINTNEXTLINE(runtime/explicit) allow implicit construction
-    constexpr {{OptionalBoolCppType}}({{OptionalBoolCType}} value): mValue(value) {}
-
-    // Define the values that are equivalent to the enums.
-    {% for value in OptionalBool.values %}
-        static const {{OptionalBoolCppType}} {{as_cppEnum(value.name)}};
-    {% endfor %}
-
-    // Assignment operators.
-    {{OptionalBoolCppType}}& operator=(const bool& value) {
-        mValue = static_cast<{{OptionalBoolCType}}>(value);
-        return *this;
-    }
-    {{OptionalBoolCppType}}& operator=(const std::optional<bool>& value) {
-        mValue = value ? static_cast<{{OptionalBoolCType}}>(*value) : {{OptionalBoolUndefined}};
-        return *this;
-    }
-    {{OptionalBoolCppType}}& operator=(const {{OptionalBoolCType}}& value) {
-        mValue = value;
-        return *this;
-    }
-
-    // Conversion functions.
-    operator {{OptionalBoolCType}}() const { return mValue; }
-    operator std::optional<bool>() const {
-        if (mValue == {{OptionalBoolUndefined}}) {
-            return std::nullopt;
-        }
-        return static_cast<bool>(mValue);
-    }
-
-    // Comparison functions.
-    bool operator==({{OptionalBoolCType}} rhs) const {
-        return mValue == rhs;
-    }
-    bool operator!=({{OptionalBoolCType}} rhs) const {
-        return mValue != rhs;
-    }
-
-  private:
-    friend struct std::hash<{{OptionalBoolCppType}}>;
-    // Default to undefined.
-    {{OptionalBoolCType}} mValue = {{OptionalBoolUndefined}};
-};
-{% for value in OptionalBool.values %}
-    inline const {{OptionalBoolCppType}} {{OptionalBoolCppType}}::{{as_cppEnum(value.name)}} = {{OptionalBoolCppType}}({{as_cEnum(OptionalBool.name, value.name)}});
-{% endfor %}
-
 // Helper class to wrap Status which allows implicit conversion to bool.
 // Used while callers switch to checking the Status enum instead of booleans.
 // TODO(crbug.com/42241199): Remove when all callers check the enum.
@@ -1015,13 +952,6 @@ struct hash<{{metadata.namespace}}::{{BoolCppType}}> {
         return hash<bool>()(v);
     }
 };
-template <>
-struct hash<{{metadata.namespace}}::{{OptionalBoolCppType}}> {
-  public:
-    size_t operator()(const {{metadata.namespace}}::{{OptionalBoolCppType}} &v) const {
-        return hash<{{OptionalBoolCType}}>()(v.mValue);
-    }
-};
 }  // namespace std
 
 #endif // {{PREFIX}}{{API}}_CPP_H_
diff --git a/generator/templates/api_cpp_print.h b/generator/templates/api_cpp_print.h
@@ -39,7 +39,7 @@
 
 namespace {{metadata.namespace}} {
 
-  {% for type in by_category["enum"] if type.name.get() != "optional bool" %}
+  {% for type in by_category["enum"] %}
       template <typename CharT, typename Traits>
       std::basic_ostream<CharT, Traits>& operator<<(std::basic_ostream<CharT, Traits>& o, {{as_cppType(type.name)}} value) {
           switch (value) {

diff --git a/generator/templates/dawn/native/ValidationUtils.cpp b/generator/templates/dawn/native/ValidationUtils.cpp
@@ -36,9 +36,9 @@ namespace {{native_namespace}} {
     {% set namespace = metadata.namespace %}
     {% for type in by_category["enum"] %}
         MaybeError Validate{{type.name.CamelCase()}}({{namespace}}::{{as_cppType(type.name)}} value) {
-            switch ({{as_cType(type.name)}}(value)) {
+            switch (value) {
                 {% for value in type.values if value.valid %}
-                    case {{as_cEnum(type.name, value.name)}}:
+                    case {{namespace}}::{{as_cppType(type.name)}}::{{as_cppEnum(value.name)}}:
                         return {};
                 {% endfor %}
                 default:

diff --git a/generator/templates/dawn/native/api_absl_format.cpp b/generator/templates/dawn/native/api_absl_format.cpp
@@ -85,17 +85,17 @@ namespace {{namespace}} {
                       absl::FormatSink* s) {
         if (spec.conversion_char() == absl::FormatConversionChar::s) {
             s->Append("{{as_cppType(type.name)}}::");
-            switch ({{as_cType(type.name)}}(value)) {
+            switch (value) {
             {% for value in type.values %}
-                case {{as_cEnum(type.name, value.name)}}:
+                case {{as_cppType(type.name)}}::{{as_cppEnum(value.name)}}:
                     s->Append("{{as_cppEnum(value.name)}}");
                     return {true};
             {% endfor %}
             default:
                 break;
             }
         }
-        s->Append(absl::StrFormat("%u", static_cast<{{as_cType(type.name)}}>(value)));
+        s->Append(absl::StrFormat("%u", static_cast<typename std::underlying_type<{{as_cppType(type.name)}}>::type>(value)));
         return {true};
     }
     {% endfor %}

diff --git a/src/dawn/common/xlib_with_undefs.h b/src/dawn/common/xlib_with_undefs.h
@@ -48,8 +48,6 @@
 #undef Always
 #undef Bool
 #undef Status
-#undef False
-#undef True
 
 using XErrorHandler = int (*)(Display*, XErrorEvent*);
 

diff --git a/src/dawn/dawn.json b/src/dawn/dawn.json
@@ -625,14 +625,6 @@
         "category": "native",
         "wasm type": "i"
     },
-    "optional bool": {
-        "category": "enum",
-        "values": [
-            {"value": 0, "name": "false"},
-            {"value": 1, "name": "true"},
-            {"value": 2, "name": "undefined", "jsrepr": "undefined"}
-        ]
-    },
     "string view": {
         "category": "structure",
         "members": [
@@ -3818,7 +3810,7 @@
         "extensible": "in",
         "members": [
             {"name": "format", "type": "texture format"},
-            {"name": "depth write enabled", "type": "optional bool", "default": "undefined"},
+            {"name": "depth write enabled", "type": "bool", "default": "false"},
             {"name": "depth compare", "type": "compare function", "default": "undefined"},
             {"name": "stencil front", "type": "stencil face state"},
             {"name": "stencil back", "type": "stencil face state"},

diff --git a/src/dawn/native/BlitBufferToDepthStencil.cpp b/src/dawn/native/BlitBufferToDepthStencil.cpp
@@ -162,7 +162,7 @@ ResultOrError<Ref<RenderPipelineBase>> GetOrCreateRG8ToDepth16UnormPipeline(Devi
 
     DepthStencilState dsState = {};
     dsState.format = wgpu::TextureFormat::Depth16Unorm;
-    dsState.depthWriteEnabled = wgpu::OptionalBool::True;
+    dsState.depthWriteEnabled = true;
     dsState.depthCompare = wgpu::CompareFunction::Always;
 
     RenderPipelineDescriptor renderPipelineDesc = {};
@@ -226,7 +226,7 @@ ResultOrError<InternalPipelineStore::BlitR8ToStencilPipelines> GetOrCreateR8ToSt
 
     DepthStencilState dsState = {};
     dsState.format = format;
-    dsState.depthWriteEnabled = wgpu::OptionalBool::False;
+    dsState.depthWriteEnabled = false;
     dsState.depthCompare = wgpu::CompareFunction::Always;
     dsState.stencilFront.passOp = wgpu::StencilOperation::Replace;
 

diff --git a/src/dawn/native/BlitColorToColorWithDraw.cpp b/src/dawn/native/BlitColorToColorWithDraw.cpp
@@ -171,7 +171,7 @@ ResultOrError<Ref<RenderPipelineBase>> GetOrCreateExpandMultisamplePipeline(
     DepthStencilState depthStencilState = {};
     if (pipelineKey.depthStencilFormat != wgpu::TextureFormat::Undefined) {
         depthStencilState.format = pipelineKey.depthStencilFormat;
-        depthStencilState.depthWriteEnabled = wgpu::OptionalBool::False;
+        depthStencilState.depthWriteEnabled = false;
         depthStencilState.depthCompare = wgpu::CompareFunction::Always;
 
         renderPipelineDesc.depthStencil = &depthStencilState;

diff --git a/src/dawn/native/BlitDepthToDepth.cpp b/src/dawn/native/BlitDepthToDepth.cpp
@@ -87,7 +87,7 @@ ResultOrError<Ref<RenderPipelineBase>> GetOrCreateDepthBlitPipeline(DeviceBase*
 
     DepthStencilState dsState = {};
     dsState.format = format;
-    dsState.depthWriteEnabled = wgpu::OptionalBool::True;
+    dsState.depthWriteEnabled = true;
     dsState.depthCompare = wgpu::CompareFunction::Always;
 
     RenderPipelineDescriptor renderPipelineDesc = {};

diff --git a/src/dawn/native/RenderPipeline.cpp b/src/dawn/native/RenderPipeline.cpp
@@ -337,19 +337,23 @@ MaybeError ValidateDepthStencilState(const DeviceBase* device,
 
     DAWN_INVALID_IF(
         format->HasDepth() && descriptor->depthCompare == wgpu::CompareFunction::Undefined &&
-            (descriptor->depthWriteEnabled == wgpu::OptionalBool::True ||
+            (descriptor->depthWriteEnabled ||
              descriptor->stencilFront.depthFailOp != wgpu::StencilOperation::Keep ||
              descriptor->stencilBack.depthFailOp != wgpu::StencilOperation::Keep),
         "Depth stencil format (%s) has a depth aspect and depthCompare is %s while it's actually "
-        "used by depthWriteEnabled (%s), or stencil front depth fail operation (%s), or "
+        "used by depthWriteEnabled (%u), or stencil front depth fail operation (%s), or "
         "stencil back depth fail operation (%s).",
         descriptor->format, wgpu::CompareFunction::Undefined, descriptor->depthWriteEnabled,
         descriptor->stencilFront.depthFailOp, descriptor->stencilBack.depthFailOp);
 
-    DAWN_INVALID_IF(
-        format->HasDepth() && descriptor->depthWriteEnabled == wgpu::OptionalBool::Undefined,
-        "Depth stencil format (%s) has a depth aspect and depthWriteEnabled is undefined.",
-        descriptor->format);
+    UnpackedPtr<DepthStencilState> unpacked;
+    DAWN_TRY_ASSIGN(unpacked, ValidateAndUnpack(descriptor));
+    if (const auto* depthWriteDefined = unpacked.Get<DepthStencilStateDepthWriteDefinedDawn>()) {
+        DAWN_INVALID_IF(
+            format->HasDepth() && !depthWriteDefined->depthWriteDefined,
+            "Depth stencil format (%s) has a depth aspect and depthWriteEnabled is undefined.",
+            descriptor->format);
+    }
 
     DAWN_INVALID_IF(
         !format->HasDepth() && descriptor->depthCompare != wgpu::CompareFunction::Always &&
@@ -360,9 +364,8 @@ MaybeError ValidateDepthStencilState(const DeviceBase* device,
         wgpu::CompareFunction::Undefined);
 
     DAWN_INVALID_IF(
-        !format->HasDepth() && descriptor->depthWriteEnabled == wgpu::OptionalBool::True,
-        "Depth stencil format (%s) doesn't have depth aspect while depthWriteEnabled (%s) "
-        "is true.",
+        !format->HasDepth() && descriptor->depthWriteEnabled,
+        "Depth stencil format (%s) doesn't have depth aspect while depthWriteEnabled (%u) is true.",
         descriptor->format, descriptor->depthWriteEnabled);
 
     if (!format->HasStencil()) {
@@ -975,16 +978,16 @@ RenderPipelineBase::RenderPipelineBase(DeviceBase* device,
         // Reify depth option for stencil-only formats
         const Format& format = device->GetValidInternalFormat(mDepthStencil.format);
         if (!format.HasDepth()) {
-            mDepthStencil.depthWriteEnabled = wgpu::OptionalBool::False;
+            mDepthStencil.depthWriteEnabled = false;
             mDepthStencil.depthCompare = wgpu::CompareFunction::Always;
         }
         if (format.HasDepth() && mDepthStencil.depthCompare == wgpu::CompareFunction::Undefined &&
-            mDepthStencil.depthWriteEnabled != wgpu::OptionalBool::True &&
+            !mDepthStencil.depthWriteEnabled &&
             mDepthStencil.stencilFront.depthFailOp == wgpu::StencilOperation::Keep &&
             mDepthStencil.stencilBack.depthFailOp == wgpu::StencilOperation::Keep) {
             mDepthStencil.depthCompare = wgpu::CompareFunction::Always;
         }
-        mWritesDepth = mDepthStencil.depthWriteEnabled == wgpu::OptionalBool::True;
+        mWritesDepth = mDepthStencil.depthWriteEnabled;
         if (mDepthStencil.stencilWriteMask) {
             if ((mPrimitive.cullMode != wgpu::CullMode::Front &&
                  (mDepthStencil.stencilFront.failOp != wgpu::StencilOperation::Keep ||

diff --git a/src/dawn/native/d3d11/RenderPipelineD3D11.cpp b/src/dawn/native/d3d11/RenderPipelineD3D11.cpp
@@ -405,13 +405,11 @@ MaybeError RenderPipeline::InitializeDepthStencilState() {
     const DepthStencilState* state = GetDepthStencilState();
 
     D3D11_DEPTH_STENCIL_DESC depthStencilDesc = {};
-    depthStencilDesc.DepthEnable = (state->depthCompare == wgpu::CompareFunction::Always &&
-                                    state->depthWriteEnabled != wgpu::OptionalBool::True)
-                                       ? FALSE
-                                       : TRUE;
-    depthStencilDesc.DepthWriteMask = state->depthWriteEnabled == wgpu::OptionalBool::True
-                                          ? D3D11_DEPTH_WRITE_MASK_ALL
-                                          : D3D11_DEPTH_WRITE_MASK_ZERO;
+    depthStencilDesc.DepthEnable =
+        (state->depthCompare == wgpu::CompareFunction::Always && !state->depthWriteEnabled) ? FALSE
+                                                                                            : TRUE;
+    depthStencilDesc.DepthWriteMask =
+        state->depthWriteEnabled ? D3D11_DEPTH_WRITE_MASK_ALL : D3D11_DEPTH_WRITE_MASK_ZERO;
     depthStencilDesc.DepthFunc = ToD3D11ComparisonFunc(state->depthCompare);
 
     depthStencilDesc.StencilEnable = UsesStencil() ? TRUE : FALSE;

diff --git a/src/dawn/native/d3d12/RenderPipelineD3D12.cpp b/src/dawn/native/d3d12/RenderPipelineD3D12.cpp
@@ -555,12 +555,11 @@ D3D12_DEPTH_STENCIL_DESC RenderPipeline::ComputeDepthStencilDesc() {
     D3D12_DEPTH_STENCIL_DESC depthStencilDescriptor = {};
     depthStencilDescriptor.DepthEnable =
         (descriptor->depthCompare == wgpu::CompareFunction::Always &&
-         descriptor->depthWriteEnabled != wgpu::OptionalBool::True)
+         !descriptor->depthWriteEnabled)
             ? FALSE
             : TRUE;
     depthStencilDescriptor.DepthWriteMask =
-        descriptor->depthWriteEnabled == wgpu::OptionalBool::True ? D3D12_DEPTH_WRITE_MASK_ALL
-                                                                  : D3D12_DEPTH_WRITE_MASK_ZERO;
+        descriptor->depthWriteEnabled ? D3D12_DEPTH_WRITE_MASK_ALL : D3D12_DEPTH_WRITE_MASK_ZERO;
     depthStencilDescriptor.DepthFunc = ToD3D12ComparisonFunc(descriptor->depthCompare);
 
     depthStencilDescriptor.StencilEnable = UsesStencil() ? TRUE : FALSE;

diff --git a/src/dawn/native/metal/RenderPipelineMTL.mm b/src/dawn/native/metal/RenderPipelineMTL.mm
@@ -546,8 +546,7 @@ MTLCullMode ToMTLCullMode(wgpu::CullMode mode) {
 
     mtlDepthStencilDescriptor.depthCompareFunction =
         ToMetalCompareFunction(descriptor->depthCompare);
-    mtlDepthStencilDescriptor.depthWriteEnabled =
-        descriptor->depthWriteEnabled == wgpu::OptionalBool::True;
+    mtlDepthStencilDescriptor.depthWriteEnabled = descriptor->depthWriteEnabled;
 
     if (UsesStencil()) {
         NSRef<MTLStencilDescriptor> backFaceStencilRef = AcquireNSRef([MTLStencilDescriptor new]);

diff --git a/src/dawn/native/opengl/RenderPipelineGL.cpp b/src/dawn/native/opengl/RenderPipelineGL.cpp
@@ -345,13 +345,13 @@ void RenderPipeline::ApplyDepthStencilState(const OpenGLFunctions& gl,
 
     // Depth writes only occur if depth is enabled
     if (descriptor->depthCompare == wgpu::CompareFunction::Always &&
-        descriptor->depthWriteEnabled != wgpu::OptionalBool::True) {
+        !descriptor->depthWriteEnabled) {
         gl.Disable(GL_DEPTH_TEST);
     } else {
         gl.Enable(GL_DEPTH_TEST);
     }
 
-    if (descriptor->depthWriteEnabled == wgpu::OptionalBool::True) {
+    if (descriptor->depthWriteEnabled) {
         gl.DepthMask(GL_TRUE);
     } else {
         gl.DepthMask(GL_FALSE);

diff --git a/src/dawn/native/vulkan/RenderPipelineVk.cpp b/src/dawn/native/vulkan/RenderPipelineVk.cpp
@@ -656,11 +656,10 @@ VkPipelineDepthStencilStateCreateInfo RenderPipeline::ComputeDepthStencilDesc()
     // Depth writes only occur if depth is enabled
     depthStencilState.depthTestEnable =
         (descriptor->depthCompare == wgpu::CompareFunction::Always &&
-         descriptor->depthWriteEnabled != wgpu::OptionalBool::True)
+         !descriptor->depthWriteEnabled)
             ? VK_FALSE
             : VK_TRUE;
-    depthStencilState.depthWriteEnable =
-        descriptor->depthWriteEnabled == wgpu::OptionalBool::True ? VK_TRUE : VK_FALSE;
+    depthStencilState.depthWriteEnable = descriptor->depthWriteEnabled ? VK_TRUE : VK_FALSE;
     depthStencilState.depthCompareOp = ToVulkanCompareOp(descriptor->depthCompare);
     depthStencilState.depthBoundsTestEnable = false;
     depthStencilState.minDepthBounds = 0.0f;

diff --git a/src/dawn/native/vulkan/ResolveTextureLoadingUtilsVk.cpp b/src/dawn/native/vulkan/ResolveTextureLoadingUtilsVk.cpp
@@ -155,7 +155,6 @@ ResultOrError<Ref<RenderPipelineBase>> GetOrCreateColorBlitPipeline(
     DepthStencilState depthStencilState = {};
     if (pipelineKey.depthStencilFormat != wgpu::TextureFormat::Undefined) {
         depthStencilState.format = pipelineKey.depthStencilFormat;
-        depthStencilState.depthWriteEnabled = wgpu::OptionalBool::False;
 
         renderPipelineDesc.depthStencil = &depthStencilState;
     }

diff --git a/src/dawn/node/binding/Converter.cpp b/src/dawn/node/binding/Converter.cpp
@@ -922,6 +922,10 @@ bool Converter::Convert(wgpu::ColorTargetState& out, const interop::GPUColorTarg
 bool Converter::Convert(wgpu::DepthStencilState& out, const interop::GPUDepthStencilState& in) {
     out = {};
 
+    auto depthWriteDefined = Allocate<wgpu::DepthStencilStateDepthWriteDefinedDawn>();
+    depthWriteDefined->depthWriteDefined = in.depthWriteEnabled.has_value();
+    out.nextInChain = depthWriteDefined;
+
     return Convert(out.format, in.format) && Convert(out.depthWriteEnabled, in.depthWriteEnabled) &&
            Convert(out.depthCompare, in.depthCompare) &&
            Convert(out.stencilFront, in.stencilFront) && Convert(out.stencilBack, in.stencilBack) &&
@@ -1730,11 +1734,6 @@ bool Converter::Convert(wgpu::Bool& out, const bool& in) {
     return true;
 }
 
-bool Converter::Convert(wgpu::OptionalBool& out, const std::optional<bool>& in) {
-    out = in;
-    return true;
-}
-
 char* Converter::ConvertStringReplacingNull(std::string_view in) {
     char* out = Allocate<char>(in.size() + 1);
     out[in.size()] = '\0';

diff --git a/src/dawn/node/binding/Converter.h b/src/dawn/node/binding/Converter.h
@@ -268,7 +268,6 @@ class Converter {
     [[nodiscard]] bool Convert(wgpu::PipelineLayout& out, const interop::GPUAutoLayoutMode& in);
 
     [[nodiscard]] bool Convert(wgpu::Bool& out, const bool& in);
-    [[nodiscard]] bool Convert(wgpu::OptionalBool& out, const std::optional<bool>& in);
 
     // Below are the various overloads of Convert() used to convert the Dawn types -> interop.
     [[nodiscard]] bool Convert(interop::GPUTextureDimension& out, wgpu::TextureDimension in);