@shopify/react-native-skia 2.4.15 → 2.4.17

package/cpp/rnwgpu/api/GPURenderBundleEncoder.h

@@ -0,0 +1,110 @@
+#pragma once
+
+#include <memory>
+#include <optional>
+#include <string>
+#include <variant>
+#include <vector>
+
+#include "descriptors/Unions.h"
+
+#include "jsi2/NativeObject.h"
+
+#include "webgpu/webgpu_cpp.h"
+
+#include "GPUBindGroup.h"
+#include "GPUBuffer.h"
+#include "GPURenderBundle.h"
+#include "descriptors/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

@@ -0,0 +1,165 @@
+#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

@@ -0,0 +1,130 @@
+#pragma once
+
+#include <memory>
+#include <optional>
+#include <string>
+#include <variant>
+#include <vector>
+
+#include "descriptors/Unions.h"
+
+#include "jsi2/NativeObject.h"
+
+#include "webgpu/webgpu_cpp.h"
+
+#include "GPUBindGroup.h"
+#include "GPUBuffer.h"
+#include "descriptors/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

@@ -0,0 +1,13 @@
+#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

@@ -0,0 +1,61 @@
+#pragma once
+
+#include <memory>
+#include <string>
+
+#include "descriptors/Unions.h"
+
+#include "jsi2/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

@@ -0,0 +1,44 @@
+#pragma once
+
+#include <string>
+
+#include "descriptors/Unions.h"
+
+#include "jsi2/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

package/cpp/rnwgpu/api/GPUShaderModule.cpp

@@ -0,0 +1,51 @@
+#include "GPUShaderModule.h"
+
+#include <memory>
+#include <utility>
+
+#include "jsi2/JSIConverter.h"
+
+namespace rnwgpu {
+
+async::AsyncTaskHandle GPUShaderModule::getCompilationInfo() {
+  auto module = _instance;
+
+  return _async->postTask(
+      [module](const async::AsyncTaskHandle::ResolveFunction &resolve,
+               const async::AsyncTaskHandle::RejectFunction &reject) {
+        auto result = std::make_shared<GPUCompilationInfo>();
+        module.GetCompilationInfo(
+            wgpu::CallbackMode::AllowProcessEvents,
+            [result, resolve,
+             reject](wgpu::CompilationInfoRequestStatus status,
+                     const wgpu::CompilationInfo *compilationInfo) mutable {
+              if (status != wgpu::CompilationInfoRequestStatus::Success ||
+                  compilationInfo == nullptr) {
+                reject("Failed to get compilation info");
+                return;
+              }
+
+              result->_messages.reserve(compilationInfo->messageCount);
+              for (size_t i = 0; i < compilationInfo->messageCount; ++i) {
+                const auto &wgpuMessage = compilationInfo->messages[i];
+                GPUCompilationMessageData message;
+                message.message =
+                    wgpuMessage.message.length ? wgpuMessage.message.data : "";
+                message.type = wgpuMessage.type;
+                message.lineNum = wgpuMessage.lineNum;
+                message.linePos = wgpuMessage.linePos;
+                message.offset = wgpuMessage.offset;
+                message.length = wgpuMessage.length;
+                result->_messages.push_back(std::move(message));
+              }
+
+              resolve([result =
+                           std::move(result)](jsi::Runtime &runtime) mutable {
+                return JSIConverter<std::shared_ptr<GPUCompilationInfo>>::toJSI(
+                    runtime, result);
+              });
+            });
+      });
+}
+
+} // namespace rnwgpu

package/cpp/rnwgpu/api/GPUShaderModule.h

@@ -0,0 +1,66 @@
+#pragma once
+
+#include <memory>
+#include <string>
+
+#include "descriptors/Unions.h"
+
+#include "jsi2/NativeObject.h"
+
+#include "rnwgpu/async/AsyncRunner.h"
+#include "rnwgpu/async/AsyncTaskHandle.h"
+
+#include "webgpu/webgpu_cpp.h"
+
+#include "GPUCompilationInfo.h"
+
+namespace rnwgpu {
+
+namespace jsi = facebook::jsi;
+
+class GPUShaderModule : public NativeObject<GPUShaderModule> {
+public:
+  static constexpr const char *CLASS_NAME = "GPUShaderModule";
+
+  explicit GPUShaderModule(wgpu::ShaderModule instance,
+                           std::shared_ptr<async::AsyncRunner> async,
+                           std::string label)
+      : NativeObject(CLASS_NAME), _instance(instance), _async(async),
+        _label(label) {}
+
+public:
+  std::string getBrand() { return CLASS_NAME; }
+
+  async::AsyncTaskHandle getCompilationInfo();
+
+  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", &GPUShaderModule::getBrand);
+    installMethod(runtime, prototype, "getCompilationInfo",
+                  &GPUShaderModule::getCompilationInfo);
+    installGetterSetter(runtime, prototype, "label", &GPUShaderModule::getLabel,
+                        &GPUShaderModule::setLabel);
+  }
+
+  inline const wgpu::ShaderModule get() { return _instance; }
+
+  size_t getMemoryPressure() override {
+    // Estimate memory usage for compiled shader module
+    // Shaders can vary widely, but a reasonable estimate is 8-16KB for typical
+    // shaders Complex shaders (with many uniforms, textures, or computations)
+    // can be much larger
+    return 12 * 1024; // 12KB estimate for average shader
+  }
+
+private:
+  wgpu::ShaderModule _instance;
+  std::shared_ptr<async::AsyncRunner> _async;
+  std::string _label;
+};
+
+} // namespace rnwgpu