react-native-wgpu 0.1.0 → 0.1.3

package/cpp/rnwgpu/api/descriptors/GPUSamplerDescriptor.h

@@ -5,26 +5,36 @@
 
 #include "webgpu/webgpu_cpp.h"
 
-#include "Logger.h"
 #include "RNFJSIConverter.h"
-#include <RNFHybridObject.h>
+#include "WGPULogger.h"
+
+#include "RNFHybridObject.h"
 
 namespace jsi = facebook::jsi;
+namespace m = margelo;
 
 namespace rnwgpu {
 
-class GPUSamplerDescriptor {
-public:
-  wgpu::SamplerDescriptor *getInstance() { return &_instance; }
-
-  wgpu::SamplerDescriptor _instance;
-
-  std::string label;
+struct GPUSamplerDescriptor {
+  std::optional<wgpu::AddressMode> addressModeU;      // GPUAddressMode
+  std::optional<wgpu::AddressMode> addressModeV;      // GPUAddressMode
+  std::optional<wgpu::AddressMode> addressModeW;      // GPUAddressMode
+  std::optional<wgpu::FilterMode> magFilter;          // GPUFilterMode
+  std::optional<wgpu::FilterMode> minFilter;          // GPUFilterMode
+  std::optional<wgpu::MipmapFilterMode> mipmapFilter; // GPUMipmapFilterMode
+  std::optional<double> lodMinClamp;                  // number
+  std::optional<double> lodMaxClamp;                  // number
+  std::optional<wgpu::CompareFunction> compare;       // GPUCompareFunction
+  std::optional<double> maxAnisotropy;                // number
+  std::optional<std::string> label;                   // string
 };
+
 } // namespace rnwgpu
 
 namespace margelo {
 
+using namespace rnwgpu; // NOLINT(build/namespaces)
+
 template <> struct JSIConverter<std::shared_ptr<rnwgpu::GPUSamplerDescriptor>> {
   static std::shared_ptr<rnwgpu::GPUSamplerDescriptor>
   fromJSI(jsi::Runtime &runtime, const jsi::Value &arg, bool outOfBounds) {
@@ -32,85 +42,75 @@ template <> struct JSIConverter<std::shared_ptr<rnwgpu::GPUSamplerDescriptor>> {
     if (!outOfBounds && arg.isObject()) {
       auto value = arg.getObject(runtime);
       if (value.hasProperty(runtime, "addressModeU")) {
-        auto addressModeU = value.getProperty(runtime, "addressModeU");
+        auto prop = value.getProperty(runtime, "addressModeU");
+        result->addressModeU =
+            JSIConverter<std::optional<wgpu::AddressMode>>::fromJSI(
+                runtime, prop, false);
       }
       if (value.hasProperty(runtime, "addressModeV")) {
-        auto addressModeV = value.getProperty(runtime, "addressModeV");
+        auto prop = value.getProperty(runtime, "addressModeV");
+        result->addressModeV =
+            JSIConverter<std::optional<wgpu::AddressMode>>::fromJSI(
+                runtime, prop, false);
       }
       if (value.hasProperty(runtime, "addressModeW")) {
-        auto addressModeW = value.getProperty(runtime, "addressModeW");
+        auto prop = value.getProperty(runtime, "addressModeW");
+        result->addressModeW =
+            JSIConverter<std::optional<wgpu::AddressMode>>::fromJSI(
+                runtime, prop, false);
       }
       if (value.hasProperty(runtime, "magFilter")) {
-        auto magFilter = value.getProperty(runtime, "magFilter");
+        auto prop = value.getProperty(runtime, "magFilter");
+        result->magFilter =
+            JSIConverter<std::optional<wgpu::FilterMode>>::fromJSI(runtime,
+                                                                   prop, false);
       }
       if (value.hasProperty(runtime, "minFilter")) {
-        auto minFilter = value.getProperty(runtime, "minFilter");
+        auto prop = value.getProperty(runtime, "minFilter");
+        result->minFilter =
+            JSIConverter<std::optional<wgpu::FilterMode>>::fromJSI(runtime,
+                                                                   prop, false);
       }
       if (value.hasProperty(runtime, "mipmapFilter")) {
-        auto mipmapFilter = value.getProperty(runtime, "mipmapFilter");
+        auto prop = value.getProperty(runtime, "mipmapFilter");
+        result->mipmapFilter =
+            JSIConverter<std::optional<wgpu::MipmapFilterMode>>::fromJSI(
+                runtime, prop, false);
       }
       if (value.hasProperty(runtime, "lodMinClamp")) {
-        auto lodMinClamp = value.getProperty(runtime, "lodMinClamp");
-
-        if (lodMinClamp.isNumber()) {
-          result->_instance.lodMinClamp = lodMinClamp.getNumber();
-        }
+        auto prop = value.getProperty(runtime, "lodMinClamp");
+        result->lodMinClamp =
+            JSIConverter<std::optional<double>>::fromJSI(runtime, prop, false);
       }
       if (value.hasProperty(runtime, "lodMaxClamp")) {
-        auto lodMaxClamp = value.getProperty(runtime, "lodMaxClamp");
-
-        if (lodMaxClamp.isNumber()) {
-          result->_instance.lodMaxClamp = lodMaxClamp.getNumber();
-        }
+        auto prop = value.getProperty(runtime, "lodMaxClamp");
+        result->lodMaxClamp =
+            JSIConverter<std::optional<double>>::fromJSI(runtime, prop, false);
       }
       if (value.hasProperty(runtime, "compare")) {
-        auto compare = value.getProperty(runtime, "compare");
+        auto prop = value.getProperty(runtime, "compare");
+        result->compare =
+            JSIConverter<std::optional<wgpu::CompareFunction>>::fromJSI(
+                runtime, prop, false);
       }
       if (value.hasProperty(runtime, "maxAnisotropy")) {
-        auto maxAnisotropy = value.getProperty(runtime, "maxAnisotropy");
-
-        if (maxAnisotropy.isNumber()) {
-          result->_instance.maxAnisotropy = maxAnisotropy.getNumber();
-        }
+        auto prop = value.getProperty(runtime, "maxAnisotropy");
+        result->maxAnisotropy =
+            JSIConverter<std::optional<double>>::fromJSI(runtime, prop, false);
       }
       if (value.hasProperty(runtime, "label")) {
-        auto label = value.getProperty(runtime, "label");
-
-        if (label.isString()) {
-          auto str = label.asString(runtime).utf8(runtime);
-          result->label = str;
-          result->_instance.label = result->label.c_str();
-        }
+        auto prop = value.getProperty(runtime, "label");
+        result->label = JSIConverter<std::optional<std::string>>::fromJSI(
+            runtime, prop, false);
       }
     }
-    rnwgpu::Logger::logToConsole("GPUSamplerDescriptor::addressModeU = %f",
-                                 result->_instance.addressModeU);
-    rnwgpu::Logger::logToConsole("GPUSamplerDescriptor::addressModeV = %f",
-                                 result->_instance.addressModeV);
-    rnwgpu::Logger::logToConsole("GPUSamplerDescriptor::addressModeW = %f",
-                                 result->_instance.addressModeW);
-    rnwgpu::Logger::logToConsole("GPUSamplerDescriptor::magFilter = %f",
-                                 result->_instance.magFilter);
-    rnwgpu::Logger::logToConsole("GPUSamplerDescriptor::minFilter = %f",
-                                 result->_instance.minFilter);
-    rnwgpu::Logger::logToConsole("GPUSamplerDescriptor::mipmapFilter = %f",
-                                 result->_instance.mipmapFilter);
-    rnwgpu::Logger::logToConsole("GPUSamplerDescriptor::lodMinClamp = %f",
-                                 result->_instance.lodMinClamp);
-    rnwgpu::Logger::logToConsole("GPUSamplerDescriptor::lodMaxClamp = %f",
-                                 result->_instance.lodMaxClamp);
-    rnwgpu::Logger::logToConsole("GPUSamplerDescriptor::compare = %f",
-                                 result->_instance.compare);
-    rnwgpu::Logger::logToConsole("GPUSamplerDescriptor::maxAnisotropy = %f",
-                                 result->_instance.maxAnisotropy);
-    rnwgpu::Logger::logToConsole("GPUSamplerDescriptor::label = %f",
-                                 result->_instance.label);
+
     return result;
   }
   static jsi::Value toJSI(jsi::Runtime &runtime,
                           std::shared_ptr<rnwgpu::GPUSamplerDescriptor> arg) {
-    // No conversions here
-    return jsi::Value::null();
+    throw std::runtime_error("Invalid GPUSamplerDescriptor::toJSI()");
   }
 };
-} // namespace margelo
+
+} // namespace margelo

package/cpp/rnwgpu/api/descriptors/GPUShaderModuleCompilationHint.h

@@ -5,24 +5,30 @@
 
 #include "webgpu/webgpu_cpp.h"
 
-#include "Logger.h"
 #include "RNFJSIConverter.h"
-#include <RNFHybridObject.h>
+#include "WGPULogger.h"
+
+#include "GPUPipelineLayout.h"
+#include "RNFHybridObject.h"
 
 namespace jsi = facebook::jsi;
+namespace m = margelo;
 
 namespace rnwgpu {
 
-class GPUShaderModuleCompilationHint {
-public:
-  wgpu::ShaderModuleCompilationHint *getInstance() { return &_instance; }
-
-  wgpu::ShaderModuleCompilationHint _instance;
+struct GPUShaderModuleCompilationHint {
+  std::string entryPoint; // string
+  std::optional<
+      std::variant<std::nullptr_t, std::shared_ptr<GPUPipelineLayout>>>
+      layout; // | GPUPipelineLayout | GPUAutoLayoutMode
 };
+
 } // namespace rnwgpu
 
 namespace margelo {
 
+using namespace rnwgpu; // NOLINT(build/namespaces)
+
 template <>
 struct JSIConverter<std::shared_ptr<rnwgpu::GPUShaderModuleCompilationHint>> {
   static std::shared_ptr<rnwgpu::GPUShaderModuleCompilationHint>
@@ -31,34 +37,29 @@ struct JSIConverter<std::shared_ptr<rnwgpu::GPUShaderModuleCompilationHint>> {
     if (!outOfBounds && arg.isObject()) {
       auto value = arg.getObject(runtime);
       if (value.hasProperty(runtime, "entryPoint")) {
-        auto entryPoint = value.getProperty(runtime, "entryPoint");
-
-        if (entryPoint.isUndefined()) {
-          throw std::runtime_error(
-              "Property GPUShaderModuleCompilationHint::entryPoint is "
-              "required");
-        }
-      } else {
-        throw std::runtime_error(
-            "Property GPUShaderModuleCompilationHint::entryPoint is not "
-            "defined");
+        auto prop = value.getProperty(runtime, "entryPoint");
+        result->entryPoint =
+            JSIConverter<std::string>::fromJSI(runtime, prop, false);
       }
       if (value.hasProperty(runtime, "layout")) {
-        auto layout = value.getProperty(runtime, "layout");
+        auto prop = value.getProperty(runtime, "layout");
+        if (prop.isNull() || prop.isString()) {
+          result->layout = nullptr;
+        } else {
+          result->layout =
+              JSIConverter<std::shared_ptr<GPUPipelineLayout>>::fromJSI(
+                  runtime, prop, false);
+        }
       }
     }
-    rnwgpu::Logger::logToConsole(
-        "GPUShaderModuleCompilationHint::entryPoint = %f",
-        result->_instance.entryPoint);
-    rnwgpu::Logger::logToConsole("GPUShaderModuleCompilationHint::layout = %f",
-                                 result->_instance.layout);
+
     return result;
   }
   static jsi::Value
   toJSI(jsi::Runtime &runtime,
         std::shared_ptr<rnwgpu::GPUShaderModuleCompilationHint> arg) {
-    // No conversions here
-    return jsi::Value::null();
+    throw std::runtime_error("Invalid GPUShaderModuleCompilationHint::toJSI()");
   }
 };
-} // namespace margelo
+
+} // namespace margelo

package/cpp/rnwgpu/api/descriptors/GPUShaderModuleDescriptor.h

@@ -2,29 +2,34 @@
 
 #include <memory>
 #include <string>
+#include <vector>
 
 #include "webgpu/webgpu_cpp.h"
 
-#include "Logger.h"
 #include "RNFJSIConverter.h"
-#include <RNFHybridObject.h>
+#include "WGPULogger.h"
+
+#include "GPUShaderModuleCompilationHint.h"
+#include "RNFHybridObject.h"
 
 namespace jsi = facebook::jsi;
+namespace m = margelo;
 
 namespace rnwgpu {
 
-class GPUShaderModuleDescriptor {
-public:
-  wgpu::ShaderModuleDescriptor *getInstance() { return &_instance; }
-
-  wgpu::ShaderModuleDescriptor _instance;
-
-  std::string label;
+struct GPUShaderModuleDescriptor {
+  std::string code; // string
+  std::optional<std::vector<std::shared_ptr<GPUShaderModuleCompilationHint>>>
+      compilationHints;             // Array<GPUShaderModuleCompilationHint>
+  std::optional<std::string> label; // string
 };
+
 } // namespace rnwgpu
 
 namespace margelo {
 
+using namespace rnwgpu; // NOLINT(build/namespaces)
+
 template <>
 struct JSIConverter<std::shared_ptr<rnwgpu::GPUShaderModuleDescriptor>> {
   static std::shared_ptr<rnwgpu::GPUShaderModuleDescriptor>
@@ -33,56 +38,30 @@ struct JSIConverter<std::shared_ptr<rnwgpu::GPUShaderModuleDescriptor>> {
     if (!outOfBounds && arg.isObject()) {
       auto value = arg.getObject(runtime);
       if (value.hasProperty(runtime, "code")) {
-        auto code = value.getProperty(runtime, "code");
-
-        if (code.isUndefined()) {
-          throw std::runtime_error(
-              "Property GPUShaderModuleDescriptor::code is required");
-        }
-      } else {
-        throw std::runtime_error(
-            "Property GPUShaderModuleDescriptor::code is not defined");
-      }
-      if (value.hasProperty(runtime, "sourceMap")) {
-        auto sourceMap = value.getProperty(runtime, "sourceMap");
-
-        if (sourceMap.isUndefined()) {
-          throw std::runtime_error(
-              "Property GPUShaderModuleDescriptor::sourceMap is required");
-        }
-      } else {
-        throw std::runtime_error(
-            "Property GPUShaderModuleDescriptor::sourceMap is not defined");
+        auto prop = value.getProperty(runtime, "code");
+        result->code = JSIConverter<std::string>::fromJSI(runtime, prop, false);
       }
       if (value.hasProperty(runtime, "compilationHints")) {
-        auto compilationHints = value.getProperty(runtime, "compilationHints");
+        auto prop = value.getProperty(runtime, "compilationHints");
+        result->compilationHints = JSIConverter<std::optional<std::vector<
+            std::shared_ptr<GPUShaderModuleCompilationHint>>>>::fromJSI(runtime,
+                                                                        prop,
+                                                                        false);
       }
       if (value.hasProperty(runtime, "label")) {
-        auto label = value.getProperty(runtime, "label");
-
-        if (label.isString()) {
-          auto str = label.asString(runtime).utf8(runtime);
-          result->label = str;
-          result->_instance.label = result->label.c_str();
-        }
+        auto prop = value.getProperty(runtime, "label");
+        result->label = JSIConverter<std::optional<std::string>>::fromJSI(
+            runtime, prop, false);
       }
     }
-    rnwgpu::Logger::logToConsole("GPUShaderModuleDescriptor::code = %f",
-                                 result->_instance.code);
-    rnwgpu::Logger::logToConsole("GPUShaderModuleDescriptor::sourceMap = %f",
-                                 result->_instance.sourceMap);
-    rnwgpu::Logger::logToConsole(
-        "GPUShaderModuleDescriptor::compilationHints = %f",
-        result->_instance.compilationHints);
-    rnwgpu::Logger::logToConsole("GPUShaderModuleDescriptor::label = %f",
-                                 result->_instance.label);
+
     return result;
   }
   static jsi::Value
   toJSI(jsi::Runtime &runtime,
         std::shared_ptr<rnwgpu::GPUShaderModuleDescriptor> arg) {
-    // No conversions here
-    return jsi::Value::null();
+    throw std::runtime_error("Invalid GPUShaderModuleDescriptor::toJSI()");
   }
 };
-} // namespace margelo
+
+} // namespace margelo

package/cpp/rnwgpu/api/descriptors/GPUStencilFaceState.h

@@ -1,28 +1,32 @@
 #pragma once
 
 #include <memory>
-#include <string>
 
 #include "webgpu/webgpu_cpp.h"
 
-#include "Logger.h"
 #include "RNFJSIConverter.h"
-#include <RNFHybridObject.h>
+#include "WGPULogger.h"
+
+#include "RNFHybridObject.h"
 
 namespace jsi = facebook::jsi;
+namespace m = margelo;
 
 namespace rnwgpu {
 
-class GPUStencilFaceState {
-public:
-  wgpu::StencilFaceState *getInstance() { return &_instance; }
-
-  wgpu::StencilFaceState _instance;
+struct GPUStencilFaceState {
+  std::optional<wgpu::CompareFunction> compare;      // GPUCompareFunction
+  std::optional<wgpu::StencilOperation> failOp;      // GPUStencilOperation
+  std::optional<wgpu::StencilOperation> depthFailOp; // GPUStencilOperation
+  std::optional<wgpu::StencilOperation> passOp;      // GPUStencilOperation
 };
+
 } // namespace rnwgpu
 
 namespace margelo {
 
+using namespace rnwgpu; // NOLINT(build/namespaces)
+
 template <> struct JSIConverter<std::shared_ptr<rnwgpu::GPUStencilFaceState>> {
   static std::shared_ptr<rnwgpu::GPUStencilFaceState>
   fromJSI(jsi::Runtime &runtime, const jsi::Value &arg, bool outOfBounds) {
@@ -30,32 +34,37 @@ template <> struct JSIConverter<std::shared_ptr<rnwgpu::GPUStencilFaceState>> {
     if (!outOfBounds && arg.isObject()) {
       auto value = arg.getObject(runtime);
       if (value.hasProperty(runtime, "compare")) {
-        auto compare = value.getProperty(runtime, "compare");
+        auto prop = value.getProperty(runtime, "compare");
+        result->compare =
+            JSIConverter<std::optional<wgpu::CompareFunction>>::fromJSI(
+                runtime, prop, false);
       }
       if (value.hasProperty(runtime, "failOp")) {
-        auto failOp = value.getProperty(runtime, "failOp");
+        auto prop = value.getProperty(runtime, "failOp");
+        result->failOp =
+            JSIConverter<std::optional<wgpu::StencilOperation>>::fromJSI(
+                runtime, prop, false);
       }
       if (value.hasProperty(runtime, "depthFailOp")) {
-        auto depthFailOp = value.getProperty(runtime, "depthFailOp");
+        auto prop = value.getProperty(runtime, "depthFailOp");
+        result->depthFailOp =
+            JSIConverter<std::optional<wgpu::StencilOperation>>::fromJSI(
+                runtime, prop, false);
       }
       if (value.hasProperty(runtime, "passOp")) {
-        auto passOp = value.getProperty(runtime, "passOp");
+        auto prop = value.getProperty(runtime, "passOp");
+        result->passOp =
+            JSIConverter<std::optional<wgpu::StencilOperation>>::fromJSI(
+                runtime, prop, false);
       }
     }
-    rnwgpu::Logger::logToConsole("GPUStencilFaceState::compare = %f",
-                                 result->_instance.compare);
-    rnwgpu::Logger::logToConsole("GPUStencilFaceState::failOp = %f",
-                                 result->_instance.failOp);
-    rnwgpu::Logger::logToConsole("GPUStencilFaceState::depthFailOp = %f",
-                                 result->_instance.depthFailOp);
-    rnwgpu::Logger::logToConsole("GPUStencilFaceState::passOp = %f",
-                                 result->_instance.passOp);
+
     return result;
   }
   static jsi::Value toJSI(jsi::Runtime &runtime,
                           std::shared_ptr<rnwgpu::GPUStencilFaceState> arg) {
-    // No conversions here
-    return jsi::Value::null();
+    throw std::runtime_error("Invalid GPUStencilFaceState::toJSI()");
   }
 };
-} // namespace margelo
+
+} // namespace margelo

package/cpp/rnwgpu/api/descriptors/GPUStorageTextureBindingLayout.h

@@ -1,28 +1,32 @@
 #pragma once
 
 #include <memory>
-#include <string>
 
 #include "webgpu/webgpu_cpp.h"
 
-#include "Logger.h"
 #include "RNFJSIConverter.h"
-#include <RNFHybridObject.h>
+#include "WGPULogger.h"
+
+#include "RNFHybridObject.h"
 
 namespace jsi = facebook::jsi;
+namespace m = margelo;
 
 namespace rnwgpu {
 
-class GPUStorageTextureBindingLayout {
-public:
-  wgpu::StorageTextureBindingLayout *getInstance() { return &_instance; }
-
-  wgpu::StorageTextureBindingLayout _instance;
+struct GPUStorageTextureBindingLayout {
+  std::optional<wgpu::StorageTextureAccess> access; // GPUStorageTextureAccess
+  wgpu::TextureFormat format;                       // GPUTextureFormat
+  std::optional<wgpu::TextureViewDimension>
+      viewDimension; // GPUTextureViewDimension
 };
+
 } // namespace rnwgpu
 
 namespace margelo {
 
+using namespace rnwgpu; // NOLINT(build/namespaces)
+
 template <>
 struct JSIConverter<std::shared_ptr<rnwgpu::GPUStorageTextureBindingLayout>> {
   static std::shared_ptr<rnwgpu::GPUStorageTextureBindingLayout>
@@ -31,37 +35,31 @@ struct JSIConverter<std::shared_ptr<rnwgpu::GPUStorageTextureBindingLayout>> {
     if (!outOfBounds && arg.isObject()) {
       auto value = arg.getObject(runtime);
       if (value.hasProperty(runtime, "access")) {
-        auto access = value.getProperty(runtime, "access");
+        auto prop = value.getProperty(runtime, "access");
+        result->access =
+            JSIConverter<std::optional<wgpu::StorageTextureAccess>>::fromJSI(
+                runtime, prop, false);
       }
       if (value.hasProperty(runtime, "format")) {
-        auto format = value.getProperty(runtime, "format");
-
-        if (format.isUndefined()) {
-          throw std::runtime_error(
-              "Property GPUStorageTextureBindingLayout::format is required");
-        }
-      } else {
-        throw std::runtime_error(
-            "Property GPUStorageTextureBindingLayout::format is not defined");
+        auto prop = value.getProperty(runtime, "format");
+        result->format =
+            JSIConverter<wgpu::TextureFormat>::fromJSI(runtime, prop, false);
       }
       if (value.hasProperty(runtime, "viewDimension")) {
-        auto viewDimension = value.getProperty(runtime, "viewDimension");
+        auto prop = value.getProperty(runtime, "viewDimension");
+        result->viewDimension =
+            JSIConverter<std::optional<wgpu::TextureViewDimension>>::fromJSI(
+                runtime, prop, false);
       }
     }
-    rnwgpu::Logger::logToConsole("GPUStorageTextureBindingLayout::access = %f",
-                                 result->_instance.access);
-    rnwgpu::Logger::logToConsole("GPUStorageTextureBindingLayout::format = %f",
-                                 result->_instance.format);
-    rnwgpu::Logger::logToConsole(
-        "GPUStorageTextureBindingLayout::viewDimension = %f",
-        result->_instance.viewDimension);
+
     return result;
   }
   static jsi::Value
   toJSI(jsi::Runtime &runtime,
         std::shared_ptr<rnwgpu::GPUStorageTextureBindingLayout> arg) {
-    // No conversions here
-    return jsi::Value::null();
+    throw std::runtime_error("Invalid GPUStorageTextureBindingLayout::toJSI()");
   }
 };
-} // namespace margelo
+
+} // namespace margelo

package/cpp/rnwgpu/api/descriptors/GPUTextureBindingLayout.h

@@ -1,28 +1,32 @@
 #pragma once
 
 #include <memory>
-#include <string>
 
 #include "webgpu/webgpu_cpp.h"
 
-#include "Logger.h"
 #include "RNFJSIConverter.h"
-#include <RNFHybridObject.h>
+#include "WGPULogger.h"
+
+#include "RNFHybridObject.h"
 
 namespace jsi = facebook::jsi;
+namespace m = margelo;
 
 namespace rnwgpu {
 
-class GPUTextureBindingLayout {
-public:
-  wgpu::TextureBindingLayout *getInstance() { return &_instance; }
-
-  wgpu::TextureBindingLayout _instance;
+struct GPUTextureBindingLayout {
+  std::optional<wgpu::TextureSampleType> sampleType; // GPUTextureSampleType
+  std::optional<wgpu::TextureViewDimension>
+      viewDimension;                // GPUTextureViewDimension
+  std::optional<bool> multisampled; // boolean
 };
+
 } // namespace rnwgpu
 
 namespace margelo {
 
+using namespace rnwgpu; // NOLINT(build/namespaces)
+
 template <>
 struct JSIConverter<std::shared_ptr<rnwgpu::GPUTextureBindingLayout>> {
   static std::shared_ptr<rnwgpu::GPUTextureBindingLayout>
@@ -31,28 +35,31 @@ struct JSIConverter<std::shared_ptr<rnwgpu::GPUTextureBindingLayout>> {
     if (!outOfBounds && arg.isObject()) {
       auto value = arg.getObject(runtime);
       if (value.hasProperty(runtime, "sampleType")) {
-        auto sampleType = value.getProperty(runtime, "sampleType");
+        auto prop = value.getProperty(runtime, "sampleType");
+        result->sampleType =
+            JSIConverter<std::optional<wgpu::TextureSampleType>>::fromJSI(
+                runtime, prop, false);
       }
       if (value.hasProperty(runtime, "viewDimension")) {
-        auto viewDimension = value.getProperty(runtime, "viewDimension");
+        auto prop = value.getProperty(runtime, "viewDimension");
+        result->viewDimension =
+            JSIConverter<std::optional<wgpu::TextureViewDimension>>::fromJSI(
+                runtime, prop, false);
       }
       if (value.hasProperty(runtime, "multisampled")) {
-        auto multisampled = value.getProperty(runtime, "multisampled");
+        auto prop = value.getProperty(runtime, "multisampled");
+        result->multisampled =
+            JSIConverter<std::optional<bool>>::fromJSI(runtime, prop, false);
       }
     }
-    rnwgpu::Logger::logToConsole("GPUTextureBindingLayout::sampleType = %f",
-                                 result->_instance.sampleType);
-    rnwgpu::Logger::logToConsole("GPUTextureBindingLayout::viewDimension = %f",
-                                 result->_instance.viewDimension);
-    rnwgpu::Logger::logToConsole("GPUTextureBindingLayout::multisampled = %f",
-                                 result->_instance.multisampled);
+
     return result;
   }
   static jsi::Value
   toJSI(jsi::Runtime &runtime,
         std::shared_ptr<rnwgpu::GPUTextureBindingLayout> arg) {
-    // No conversions here
-    return jsi::Value::null();
+    throw std::runtime_error("Invalid GPUTextureBindingLayout::toJSI()");
   }
 };
-} // namespace margelo
+
+} // namespace margelo