react-native-wgpu 0.5.11 → 0.5.14

package/cpp/rnwgpu/api/GPURenderBundleEncoder.cpp

@@ -1,131 +0,0 @@
-#include "GPURenderBundleEncoder.h"
-
-#include <memory>
-#include <string>
-
-#include "Convertors.h"
-
-namespace rnwgpu {
-
-std::shared_ptr<GPURenderBundle> GPURenderBundleEncoder::finish(
-    std::optional<std::shared_ptr<GPURenderBundleDescriptor>> descriptor) {
-  wgpu::RenderBundleDescriptor desc;
-  Convertor conv;
-  if (!conv(desc, descriptor)) {
-    throw std::runtime_error("GPURenderBundleEncoder.finish(): couldn't get "
-                             "GPURenderBundleDescriptor");
-  }
-  auto bundle = _instance.Finish(&desc);
-  return std::make_shared<GPURenderBundle>(
-      bundle,
-      descriptor.has_value() ? descriptor.value()->label.value_or("") : "");
-}
-
-void GPURenderBundleEncoder::setPipeline(
-    std::shared_ptr<GPURenderPipeline> pipeline) {
-  _instance.SetPipeline(pipeline->get());
-}
-
-void GPURenderBundleEncoder::draw(uint32_t vertexCount,
-                                  std::optional<uint32_t> instanceCount,
-                                  std::optional<uint32_t> firstVertex,
-                                  std::optional<uint32_t> firstInstance) {
-  _instance.Draw(vertexCount, instanceCount.value_or(1),
-                 firstVertex.value_or(0), firstInstance.value_or(0));
-}
-
-void GPURenderBundleEncoder::setVertexBuffer(
-    uint32_t slot,
-    std::variant<std::nullptr_t, std::shared_ptr<GPUBuffer>> buffer,
-    std::optional<uint64_t> offset, std::optional<uint64_t> size) {
-  Convertor conv;
-
-  wgpu::Buffer b{};
-  uint64_t s = wgpu::kWholeSize;
-  if (!conv(b, buffer) || !conv(s, size)) {
-    return;
-  }
-  _instance.SetVertexBuffer(slot, b, offset.value_or(0), s);
-}
-
-void GPURenderBundleEncoder::setBindGroup(
-    uint32_t groupIndex,
-    std::variant<std::nullptr_t, std::shared_ptr<GPUBindGroup>> bindGroup,
-    std::optional<std::vector<uint32_t>> dynamicOffsets) {
-  auto dynOffsets = dynamicOffsets.value_or(std::vector<uint32_t>());
-  if (dynOffsets.size() == 0) {
-    if (std::holds_alternative<std::nullptr_t>(bindGroup)) {
-      _instance.SetBindGroup(groupIndex, nullptr, 0, nullptr);
-    } else {
-      auto group = std::get<std::shared_ptr<GPUBindGroup>>(bindGroup);
-      _instance.SetBindGroup(groupIndex, group->get(), 0, nullptr);
-    }
-  } else {
-    if (std::holds_alternative<std::nullptr_t>(bindGroup)) {
-      _instance.SetBindGroup(groupIndex, nullptr, dynOffsets.size(),
-                             dynamicOffsets->data());
-    } else {
-      auto group = std::get<std::shared_ptr<GPUBindGroup>>(bindGroup);
-      _instance.SetBindGroup(groupIndex, group->get(), dynOffsets.size(),
-                             dynamicOffsets->data());
-    }
-  }
-}
-
-void GPURenderBundleEncoder::setIndexBuffer(std::shared_ptr<GPUBuffer> buffer,
-                                            wgpu::IndexFormat indexFormat,
-                                            std::optional<uint64_t> offset,
-                                            std::optional<uint64_t> size) {
-  Convertor conv;
-
-  wgpu::Buffer b{};
-  wgpu::IndexFormat f{};
-  uint64_t o = 0;
-  uint64_t s = wgpu::kWholeSize;
-  if (!conv(b, buffer) ||      //
-      !conv(f, indexFormat) || //
-      !conv(o, offset) ||      //
-      !conv(s, size)) {
-    return;
-  }
-
-  _instance.SetIndexBuffer(b, f, o, s);
-}
-
-void GPURenderBundleEncoder::drawIndexed(
-    uint32_t indexCount, std::optional<uint32_t> instanceCount,
-    std::optional<uint32_t> firstIndex, std::optional<double> baseVertex,
-    std::optional<uint32_t> firstInstance) {
-  _instance.DrawIndexed(indexCount, instanceCount.value_or(1),
-                        firstIndex.value_or(0), baseVertex.value_or(0),
-                        firstInstance.value_or(0));
-}
-
-void GPURenderBundleEncoder::pushDebugGroup(std::string groupLabel) {
-  _instance.PushDebugGroup(groupLabel.c_str());
-}
-
-void GPURenderBundleEncoder::popDebugGroup() { _instance.PopDebugGroup(); }
-
-void GPURenderBundleEncoder::insertDebugMarker(std::string markerLabel) {
-  _instance.InsertDebugMarker(markerLabel.c_str());
-}
-void GPURenderBundleEncoder::drawIndirect(
-    std::shared_ptr<GPUBuffer> indirectBuffer, uint64_t indirectOffset) {
-  Convertor conv;
-  wgpu::Buffer b{};
-  if (!conv(b, indirectBuffer)) {
-    return;
-  }
-  _instance.DrawIndirect(b, indirectOffset);
-}
-void GPURenderBundleEncoder::drawIndexedIndirect(
-    std::shared_ptr<GPUBuffer> indirectBuffer, uint64_t indirectOffset) {
-  Convertor conv;
-  wgpu::Buffer b{};
-  if (!conv(b, indirectBuffer)) {
-    return;
-  }
-  _instance.DrawIndexedIndirect(b, indirectOffset);
-}
-} // namespace rnwgpu

package/cpp/rnwgpu/api/GPURenderBundleEncoder.h

@@ -1,110 +0,0 @@
-#pragma once
-
-#include <memory>
-#include <optional>
-#include <string>
-#include <variant>
-#include <vector>
-
-#include "Unions.h"
-
-#include "NativeObject.h"
-
-#include "webgpu/webgpu_cpp.h"
-
-#include "GPUBindGroup.h"
-#include "GPUBuffer.h"
-#include "GPURenderBundle.h"
-#include "GPURenderBundleDescriptor.h"
-#include "GPURenderPipeline.h"
-
-namespace rnwgpu {
-
-namespace jsi = facebook::jsi;
-
-class GPURenderBundleEncoder : public NativeObject<GPURenderBundleEncoder> {
-public:
-  static constexpr const char *CLASS_NAME = "GPURenderBundleEncoder";
-
-  explicit GPURenderBundleEncoder(wgpu::RenderBundleEncoder instance,
-                                  std::string label)
-      : NativeObject(CLASS_NAME), _instance(instance), _label(label) {}
-
-public:
-  std::string getBrand() { return CLASS_NAME; }
-
-  std::shared_ptr<GPURenderBundle>
-  finish(std::optional<std::shared_ptr<GPURenderBundleDescriptor>> descriptor);
-  void pushDebugGroup(std::string groupLabel);
-  void popDebugGroup();
-  void insertDebugMarker(std::string markerLabel);
-  void setBindGroup(
-      uint32_t index,
-      std::variant<std::nullptr_t, std::shared_ptr<GPUBindGroup>> bindGroup,
-      std::optional<std::vector<uint32_t>> dynamicOffsets);
-  void setPipeline(std::shared_ptr<GPURenderPipeline> pipeline);
-  void setIndexBuffer(std::shared_ptr<GPUBuffer> buffer,
-                      wgpu::IndexFormat indexFormat,
-                      std::optional<uint64_t> offset,
-                      std::optional<uint64_t> size);
-  void setVertexBuffer(
-      uint32_t slot,
-      std::variant<std::nullptr_t, std::shared_ptr<GPUBuffer>> buffer,
-      std::optional<uint64_t> offset, std::optional<uint64_t> size);
-  void draw(uint32_t vertexCount, std::optional<uint32_t> instanceCount,
-            std::optional<uint32_t> firstVertex,
-            std::optional<uint32_t> firstInstance);
-  void drawIndexed(uint32_t indexCount, std::optional<uint32_t> instanceCount,
-                   std::optional<uint32_t> firstIndex,
-                   std::optional<double> baseVertex,
-                   std::optional<uint32_t> firstInstance);
-  void drawIndirect(std::shared_ptr<GPUBuffer> indirectBuffer,
-                    uint64_t indirectOffset);
-  void drawIndexedIndirect(std::shared_ptr<GPUBuffer> indirectBuffer,
-                           uint64_t indirectOffset);
-
-  std::string getLabel() { return _label; }
-  void setLabel(const std::string &label) {
-    _label = label;
-    _instance.SetLabel(_label.c_str());
-  }
-
-  static void definePrototype(jsi::Runtime &runtime, jsi::Object &prototype) {
-    installGetter(runtime, prototype, "__brand",
-                  &GPURenderBundleEncoder::getBrand);
-    installMethod(runtime, prototype, "finish",
-                  &GPURenderBundleEncoder::finish);
-    installMethod(runtime, prototype, "pushDebugGroup",
-                  &GPURenderBundleEncoder::pushDebugGroup);
-    installMethod(runtime, prototype, "popDebugGroup",
-                  &GPURenderBundleEncoder::popDebugGroup);
-    installMethod(runtime, prototype, "insertDebugMarker",
-                  &GPURenderBundleEncoder::insertDebugMarker);
-    installMethod(runtime, prototype, "setBindGroup",
-                  &GPURenderBundleEncoder::setBindGroup);
-    installMethod(runtime, prototype, "setPipeline",
-                  &GPURenderBundleEncoder::setPipeline);
-    installMethod(runtime, prototype, "setIndexBuffer",
-                  &GPURenderBundleEncoder::setIndexBuffer);
-    installMethod(runtime, prototype, "setVertexBuffer",
-                  &GPURenderBundleEncoder::setVertexBuffer);
-    installMethod(runtime, prototype, "draw", &GPURenderBundleEncoder::draw);
-    installMethod(runtime, prototype, "drawIndexed",
-                  &GPURenderBundleEncoder::drawIndexed);
-    installMethod(runtime, prototype, "drawIndirect",
-                  &GPURenderBundleEncoder::drawIndirect);
-    installMethod(runtime, prototype, "drawIndexedIndirect",
-                  &GPURenderBundleEncoder::drawIndexedIndirect);
-    installGetterSetter(runtime, prototype, "label",
-                        &GPURenderBundleEncoder::getLabel,
-                        &GPURenderBundleEncoder::setLabel);
-  }
-
-  inline const wgpu::RenderBundleEncoder get() { return _instance; }
-
-private:
-  wgpu::RenderBundleEncoder _instance;
-  std::string _label;
-};
-
-} // namespace rnwgpu

package/cpp/rnwgpu/api/GPURenderPassEncoder.cpp

@@ -1,165 +0,0 @@
-#include <memory>
-#include <string>
-#include <vector>
-
-#include "Convertors.h"
-#include "GPURenderPassEncoder.h"
-
-namespace rnwgpu {
-
-void GPURenderPassEncoder::end() { _instance.End(); }
-
-void GPURenderPassEncoder::setPipeline(
-    std::shared_ptr<GPURenderPipeline> pipeline) {
-  _instance.SetPipeline(pipeline->get());
-}
-
-void GPURenderPassEncoder::draw(uint32_t vertexCount,
-                                std::optional<uint32_t> instanceCount,
-                                std::optional<uint32_t> firstVertex,
-                                std::optional<uint32_t> firstInstance) {
-  _instance.Draw(vertexCount, instanceCount.value_or(1),
-                 firstVertex.value_or(0), firstInstance.value_or(0));
-}
-void GPURenderPassEncoder::setVertexBuffer(
-    uint32_t slot,
-    std::variant<std::nullptr_t, std::shared_ptr<GPUBuffer>> buffer,
-    std::optional<uint64_t> offset, std::optional<uint64_t> size) {
-  Convertor conv;
-
-  wgpu::Buffer b{};
-  uint64_t s = wgpu::kWholeSize;
-  if (!conv(b, buffer) || !conv(s, size)) {
-    return;
-  }
-  _instance.SetVertexBuffer(slot, b, offset.value_or(0), s);
-}
-
-void GPURenderPassEncoder::setBindGroup(
-    uint32_t groupIndex,
-    std::variant<std::nullptr_t, std::shared_ptr<GPUBindGroup>> bindGroup,
-    std::optional<std::vector<uint32_t>> dynamicOffsets) {
-  auto dynOffsets = dynamicOffsets.value_or(std::vector<uint32_t>());
-  if (dynOffsets.size() == 0) {
-    if (std::holds_alternative<nullptr_t>(bindGroup)) {
-      _instance.SetBindGroup(groupIndex, nullptr, 0, nullptr);
-    } else {
-      auto group = std::get<std::shared_ptr<GPUBindGroup>>(bindGroup);
-      _instance.SetBindGroup(groupIndex, group->get(), 0, nullptr);
-    }
-  } else {
-    if (std::holds_alternative<nullptr_t>(bindGroup)) {
-      _instance.SetBindGroup(groupIndex, nullptr, dynOffsets.size(),
-                             dynamicOffsets->data());
-    } else {
-      auto group = std::get<std::shared_ptr<GPUBindGroup>>(bindGroup);
-      _instance.SetBindGroup(groupIndex, group->get(), dynOffsets.size(),
-                             dynamicOffsets->data());
-    }
-  }
-}
-
-void GPURenderPassEncoder::setIndexBuffer(std::shared_ptr<GPUBuffer> buffer,
-                                          wgpu::IndexFormat indexFormat,
-                                          std::optional<uint64_t> offset,
-                                          std::optional<uint64_t> size) {
-  Convertor conv;
-
-  wgpu::Buffer b{};
-  wgpu::IndexFormat f{};
-  uint64_t o = 0;
-  uint64_t s = wgpu::kWholeSize;
-  if (!conv(b, buffer) ||      //
-      !conv(f, indexFormat) || //
-      !conv(o, offset) ||      //
-      !conv(s, size)) {
-    return;
-  }
-
-  _instance.SetIndexBuffer(b, f, o, s);
-}
-
-void GPURenderPassEncoder::endOcclusionQuery() {
-  _instance.EndOcclusionQuery();
-}
-
-void GPURenderPassEncoder::beginOcclusionQuery(uint32_t queryIndex) {
-  _instance.BeginOcclusionQuery(queryIndex);
-}
-
-void GPURenderPassEncoder::drawIndexed(uint32_t indexCount,
-                                       std::optional<uint32_t> instanceCount,
-                                       std::optional<uint32_t> firstIndex,
-                                       std::optional<double> baseVertex,
-                                       std::optional<uint32_t> firstInstance) {
-  _instance.DrawIndexed(indexCount, instanceCount.value_or(1),
-                        firstIndex.value_or(0), baseVertex.value_or(0),
-                        firstInstance.value_or(0));
-}
-
-void GPURenderPassEncoder::executeBundles(
-    std::vector<std::shared_ptr<GPURenderBundle>> bundles_in) {
-  Convertor conv;
-
-  wgpu::RenderBundle *bundles = nullptr;
-  size_t bundleCount = 0;
-  if (!conv(bundles, bundleCount, bundles_in)) {
-    return;
-  }
-
-  _instance.ExecuteBundles(bundleCount, bundles);
-}
-
-void GPURenderPassEncoder::setScissorRect(uint32_t x, uint32_t y,
-                                          uint32_t width, uint32_t height) {
-  _instance.SetScissorRect(x, y, width, height);
-}
-
-void GPURenderPassEncoder::setViewport(double x, double y, double width,
-                                       double height, double minDepth,
-                                       double maxDepth) {
-  _instance.SetViewport(x, y, width, height, minDepth, maxDepth);
-}
-
-void GPURenderPassEncoder::setBlendConstant(std::shared_ptr<GPUColor> color) {
-  Convertor conv;
-  wgpu::Color c{};
-  if (!conv(c, color)) {
-    return;
-  }
-  _instance.SetBlendConstant(&c);
-}
-
-void GPURenderPassEncoder::setStencilReference(uint32_t reference) {
-  _instance.SetStencilReference(reference);
-}
-
-void GPURenderPassEncoder::pushDebugGroup(std::string groupLabel) {
-  _instance.PushDebugGroup(groupLabel.c_str());
-}
-
-void GPURenderPassEncoder::popDebugGroup() { _instance.PopDebugGroup(); }
-
-void GPURenderPassEncoder::insertDebugMarker(std::string markerLabel) {
-  _instance.InsertDebugMarker(markerLabel.c_str());
-}
-void GPURenderPassEncoder::drawIndirect(
-    std::shared_ptr<GPUBuffer> indirectBuffer, uint64_t indirectOffset) {
-  Convertor conv;
-  wgpu::Buffer b{};
-  if (!conv(b, indirectBuffer)) {
-    return;
-  }
-  _instance.DrawIndirect(b, indirectOffset);
-}
-void GPURenderPassEncoder::drawIndexedIndirect(
-    std::shared_ptr<GPUBuffer> indirectBuffer, uint64_t indirectOffset) {
-  Convertor conv;
-  wgpu::Buffer b{};
-  if (!conv(b, indirectBuffer)) {
-    return;
-  }
-  _instance.DrawIndexedIndirect(b, indirectOffset);
-}
-
-} // namespace rnwgpu

package/cpp/rnwgpu/api/GPURenderPassEncoder.h

@@ -1,130 +0,0 @@
-#pragma once
-
-#include <memory>
-#include <optional>
-#include <string>
-#include <variant>
-#include <vector>
-
-#include "Unions.h"
-
-#include "NativeObject.h"
-
-#include "webgpu/webgpu_cpp.h"
-
-#include "GPUBindGroup.h"
-#include "GPUBuffer.h"
-#include "GPUColor.h"
-#include "GPURenderBundle.h"
-#include "GPURenderPipeline.h"
-
-namespace rnwgpu {
-
-namespace jsi = facebook::jsi;
-
-class GPURenderPassEncoder : public NativeObject<GPURenderPassEncoder> {
-public:
-  static constexpr const char *CLASS_NAME = "GPURenderPassEncoder";
-
-  explicit GPURenderPassEncoder(wgpu::RenderPassEncoder instance,
-                                std::string label)
-      : NativeObject(CLASS_NAME), _instance(instance), _label(label) {}
-
-public:
-  std::string getBrand() { return CLASS_NAME; }
-
-  void setViewport(double x, double y, double width, double height,
-                   double minDepth, double maxDepth);
-  void setScissorRect(uint32_t x, uint32_t y, uint32_t width, uint32_t height);
-  void setBlendConstant(std::shared_ptr<GPUColor> color);
-  void setStencilReference(uint32_t reference);
-  void beginOcclusionQuery(uint32_t queryIndex);
-  void endOcclusionQuery();
-  void executeBundles(std::vector<std::shared_ptr<GPURenderBundle>> bundles);
-  void end();
-  void pushDebugGroup(std::string groupLabel);
-  void popDebugGroup();
-  void insertDebugMarker(std::string markerLabel);
-  void setBindGroup(
-      uint32_t index,
-      std::variant<std::nullptr_t, std::shared_ptr<GPUBindGroup>> bindGroup,
-      std::optional<std::vector<uint32_t>> dynamicOffsets);
-  void setPipeline(std::shared_ptr<GPURenderPipeline> pipeline);
-  void setIndexBuffer(std::shared_ptr<GPUBuffer> buffer,
-                      wgpu::IndexFormat indexFormat,
-                      std::optional<uint64_t> offset,
-                      std::optional<uint64_t> size);
-  void setVertexBuffer(
-      uint32_t slot,
-      std::variant<std::nullptr_t, std::shared_ptr<GPUBuffer>> buffer,
-      std::optional<uint64_t> offset, std::optional<uint64_t> size);
-  void draw(uint32_t vertexCount, std::optional<uint32_t> instanceCount,
-            std::optional<uint32_t> firstVertex,
-            std::optional<uint32_t> firstInstance);
-  void drawIndexed(uint32_t indexCount, std::optional<uint32_t> instanceCount,
-                   std::optional<uint32_t> firstIndex,
-                   std::optional<double> baseVertex,
-                   std::optional<uint32_t> firstInstance);
-  void drawIndirect(std::shared_ptr<GPUBuffer> indirectBuffer,
-                    uint64_t indirectOffset);
-  void drawIndexedIndirect(std::shared_ptr<GPUBuffer> indirectBuffer,
-                           uint64_t indirectOffset);
-
-  std::string getLabel() { return _label; }
-  void setLabel(const std::string &label) {
-    _label = label;
-    _instance.SetLabel(_label.c_str());
-  }
-
-  static void definePrototype(jsi::Runtime &runtime, jsi::Object &prototype) {
-    installGetter(runtime, prototype, "__brand",
-                  &GPURenderPassEncoder::getBrand);
-    installMethod(runtime, prototype, "setViewport",
-                  &GPURenderPassEncoder::setViewport);
-    installMethod(runtime, prototype, "setScissorRect",
-                  &GPURenderPassEncoder::setScissorRect);
-    installMethod(runtime, prototype, "setBlendConstant",
-                  &GPURenderPassEncoder::setBlendConstant);
-    installMethod(runtime, prototype, "setStencilReference",
-                  &GPURenderPassEncoder::setStencilReference);
-    installMethod(runtime, prototype, "beginOcclusionQuery",
-                  &GPURenderPassEncoder::beginOcclusionQuery);
-    installMethod(runtime, prototype, "endOcclusionQuery",
-                  &GPURenderPassEncoder::endOcclusionQuery);
-    installMethod(runtime, prototype, "executeBundles",
-                  &GPURenderPassEncoder::executeBundles);
-    installMethod(runtime, prototype, "end", &GPURenderPassEncoder::end);
-    installMethod(runtime, prototype, "pushDebugGroup",
-                  &GPURenderPassEncoder::pushDebugGroup);
-    installMethod(runtime, prototype, "popDebugGroup",
-                  &GPURenderPassEncoder::popDebugGroup);
-    installMethod(runtime, prototype, "insertDebugMarker",
-                  &GPURenderPassEncoder::insertDebugMarker);
-    installMethod(runtime, prototype, "setBindGroup",
-                  &GPURenderPassEncoder::setBindGroup);
-    installMethod(runtime, prototype, "setPipeline",
-                  &GPURenderPassEncoder::setPipeline);
-    installMethod(runtime, prototype, "setIndexBuffer",
-                  &GPURenderPassEncoder::setIndexBuffer);
-    installMethod(runtime, prototype, "setVertexBuffer",
-                  &GPURenderPassEncoder::setVertexBuffer);
-    installMethod(runtime, prototype, "draw", &GPURenderPassEncoder::draw);
-    installMethod(runtime, prototype, "drawIndexed",
-                  &GPURenderPassEncoder::drawIndexed);
-    installMethod(runtime, prototype, "drawIndirect",
-                  &GPURenderPassEncoder::drawIndirect);
-    installMethod(runtime, prototype, "drawIndexedIndirect",
-                  &GPURenderPassEncoder::drawIndexedIndirect);
-    installGetterSetter(runtime, prototype, "label",
-                        &GPURenderPassEncoder::getLabel,
-                        &GPURenderPassEncoder::setLabel);
-  }
-
-  inline const wgpu::RenderPassEncoder get() { return _instance; }
-
-private:
-  wgpu::RenderPassEncoder _instance;
-  std::string _label;
-};
-
-} // namespace rnwgpu

package/cpp/rnwgpu/api/GPURenderPipeline.cpp

@@ -1,13 +0,0 @@
-#include "GPURenderPipeline.h"
-
-#include <memory>
-
-namespace rnwgpu {
-
-std::shared_ptr<GPUBindGroupLayout>
-GPURenderPipeline::getBindGroupLayout(uint32_t groupIndex) {
-  auto bindGroupLayout = _instance.GetBindGroupLayout(groupIndex);
-  return std::make_shared<GPUBindGroupLayout>(bindGroupLayout, "");
-}
-
-} // namespace rnwgpu

package/cpp/rnwgpu/api/GPURenderPipeline.h

@@ -1,61 +0,0 @@
-#pragma once
-
-#include <memory>
-#include <string>
-
-#include "Unions.h"
-
-#include "NativeObject.h"
-
-#include "webgpu/webgpu_cpp.h"
-
-#include "GPUBindGroupLayout.h"
-
-namespace rnwgpu {
-
-namespace jsi = facebook::jsi;
-
-class GPURenderPipeline : public NativeObject<GPURenderPipeline> {
-public:
-  static constexpr const char *CLASS_NAME = "GPURenderPipeline";
-
-  explicit GPURenderPipeline(wgpu::RenderPipeline instance, std::string label)
-      : NativeObject(CLASS_NAME), _instance(instance), _label(label) {}
-
-public:
-  std::string getBrand() { return CLASS_NAME; }
-
-  std::shared_ptr<GPUBindGroupLayout> getBindGroupLayout(uint32_t index);
-
-  std::string getLabel() { return _label; }
-  void setLabel(const std::string &label) {
-    _label = label;
-    _instance.SetLabel(_label.c_str());
-  }
-
-  static void definePrototype(jsi::Runtime &runtime, jsi::Object &prototype) {
-    installGetter(runtime, prototype, "__brand", &GPURenderPipeline::getBrand);
-    installMethod(runtime, prototype, "getBindGroupLayout",
-                  &GPURenderPipeline::getBindGroupLayout);
-    installGetterSetter(runtime, prototype, "label",
-                        &GPURenderPipeline::getLabel,
-                        &GPURenderPipeline::setLabel);
-  }
-
-  inline const wgpu::RenderPipeline get() { return _instance; }
-
-  size_t getMemoryPressure() override {
-    // Render pipelines contain compiled shader state, vertex/fragment shaders,
-    // render state, and driver-specific optimized code
-    // Estimate: 24KB for a typical render pipeline with vertex + fragment
-    // shaders
-    return 24 * 1024;
-  }
-
-private:
-  wgpu::RenderPipeline _instance;
-  std::string _label;
-  friend class GPUDevice;
-};
-
-} // namespace rnwgpu

package/cpp/rnwgpu/api/GPUSampler.h

@@ -1,44 +0,0 @@
-#pragma once
-
-#include <string>
-
-#include "Unions.h"
-
-#include "NativeObject.h"
-
-#include "webgpu/webgpu_cpp.h"
-
-namespace rnwgpu {
-
-namespace jsi = facebook::jsi;
-
-class GPUSampler : public NativeObject<GPUSampler> {
-public:
-  static constexpr const char *CLASS_NAME = "GPUSampler";
-
-  explicit GPUSampler(wgpu::Sampler instance, std::string label)
-      : NativeObject(CLASS_NAME), _instance(instance), _label(label) {}
-
-public:
-  std::string getBrand() { return CLASS_NAME; }
-
-  std::string getLabel() { return _label; }
-  void setLabel(const std::string &label) {
-    _label = label;
-    _instance.SetLabel(_label.c_str());
-  }
-
-  static void definePrototype(jsi::Runtime &runtime, jsi::Object &prototype) {
-    installGetter(runtime, prototype, "__brand", &GPUSampler::getBrand);
-    installGetterSetter(runtime, prototype, "label", &GPUSampler::getLabel,
-                        &GPUSampler::setLabel);
-  }
-
-  inline const wgpu::Sampler get() { return _instance; }
-
-private:
-  wgpu::Sampler _instance;
-  std::string _label;
-};
-
-} // namespace rnwgpu