react-native-wgpu 0.1.2 → 0.1.4

package/android/cpp/AndroidPlatformContext.h

@@ -1,6 +1,11 @@
 #pragma once
 
+#include <android/bitmap.h>
+#include <jni.h>
+
 #include <memory>
+#include <string>
+#include <vector>
 
 #include "webgpu/webgpu_cpp.h"
 
@@ -8,10 +13,23 @@
 #include "RNWebGPUManager.h"
 
 namespace rnwgpu {
+
+namespace jsi = facebook::jsi;
+namespace jni = facebook::jni;
+
 class AndroidPlatformContext : public PlatformContext {
+private:
+  jobject _blobModule;
+
 public:
-  AndroidPlatformContext() = default;
-  ~AndroidPlatformContext() = default;
+  explicit AndroidPlatformContext(jobject blobModule) : _blobModule(blobModule) {}
+  ~AndroidPlatformContext() {
+    if (_blobModule) {
+      JNIEnv *env = facebook::jni::Environment::current();
+      env->DeleteGlobalRef(_blobModule);
+      _blobModule = nullptr;
+    }
+  }
 
   wgpu::Surface makeSurface(wgpu::Instance instance, void *window, int width,
                             int height) override {
@@ -21,6 +39,94 @@ public:
     surfaceDescriptor.nextInChain = &androidSurfaceDesc;
     return instance.CreateSurface(&surfaceDescriptor);
   }
+
+  ImageData createImageBitmap(std::string blobId, double offset,
+                              double size) override {
+    jni::Environment::ensureCurrentThreadIsAttached();
+
+    JNIEnv *env = facebook::jni::Environment::current();
+    if (!env) {
+      throw std::runtime_error("Couldn't get JNI environment");
+    }
+
+    // Use the BlobModule instance from _blobModule
+    if (!_blobModule) {
+      throw std::runtime_error("BlobModule instance is null");
+    }
+
+    // Get the resolve method ID
+    jclass blobModuleClass = env->GetObjectClass(_blobModule);
+    if (!blobModuleClass) {
+      throw std::runtime_error("Couldn't find BlobModule class");
+    }
+
+    jmethodID resolveMethod = env->GetMethodID(blobModuleClass, "resolve",
+                                               "(Ljava/lang/String;II)[B");
+    if (!resolveMethod) {
+      throw std::runtime_error("Couldn't find resolve method in BlobModule");
+    }
+
+    // Resolve the blob data
+    jstring jBlobId = env->NewStringUTF(blobId.c_str());
+    jbyteArray blobData = (jbyteArray)env->CallObjectMethod(
+        _blobModule, resolveMethod, jBlobId, static_cast<jint>(offset),
+        static_cast<jint>(size));
+    env->DeleteLocalRef(jBlobId);
+
+    if (!blobData) {
+      throw std::runtime_error("Couldn't retrieve blob data");
+    }
+
+    // Create a Bitmap from the blob data
+    jclass bitmapFactoryClass =
+        env->FindClass("android/graphics/BitmapFactory");
+    jmethodID decodeByteArrayMethod =
+        env->GetStaticMethodID(bitmapFactoryClass, "decodeByteArray",
+                               "([BII)Landroid/graphics/Bitmap;");
+    jint blobLength = env->GetArrayLength(blobData);
+    jobject bitmap = env->CallStaticObjectMethod(
+        bitmapFactoryClass, decodeByteArrayMethod, blobData, 0, blobLength);
+
+    if (!bitmap) {
+      env->DeleteLocalRef(blobData);
+      throw std::runtime_error("Couldn't decode image");
+    }
+
+    // Get bitmap info
+    AndroidBitmapInfo bitmapInfo;
+    if (AndroidBitmap_getInfo(env, bitmap, &bitmapInfo) !=
+        ANDROID_BITMAP_RESULT_SUCCESS) {
+      env->DeleteLocalRef(blobData);
+      env->DeleteLocalRef(bitmap);
+      throw std::runtime_error("Couldn't get bitmap info");
+    }
+
+    // Lock the bitmap pixels
+    void *bitmapPixels;
+    if (AndroidBitmap_lockPixels(env, bitmap, &bitmapPixels) !=
+        ANDROID_BITMAP_RESULT_SUCCESS) {
+      env->DeleteLocalRef(blobData);
+      env->DeleteLocalRef(bitmap);
+      throw std::runtime_error("Couldn't lock bitmap pixels");
+    }
+
+    // Copy the bitmap data
+    std::vector<uint8_t> imageData(bitmapInfo.height * bitmapInfo.stride);
+    memcpy(imageData.data(), bitmapPixels, imageData.size());
+
+    // Unlock the bitmap pixels
+    AndroidBitmap_unlockPixels(env, bitmap);
+
+    // Clean up JNI references
+    env->DeleteLocalRef(blobData);
+    env->DeleteLocalRef(bitmap);
+
+    ImageData result;
+    result.width = static_cast<int>(bitmapInfo.width);
+    result.height = static_cast<int>(bitmapInfo.height);
+    result.data = imageData;
+    return result;
+  }
 };
 
 } // namespace rnwgpu

package/android/cpp/cpp-adapter.cpp

@@ -17,9 +17,12 @@
 std::shared_ptr<rnwgpu::RNWebGPUManager> manager;
 
 extern "C" JNIEXPORT void JNICALL Java_com_webgpu_WebGPUModule_initializeNative(
-    JNIEnv *env, jobject /* this */, jlong jsRuntime, jobject jsInvokerHolder) {
+    JNIEnv *env, jobject /* this */, jlong jsRuntime, jobject jsInvokerHolder,
+    jobject blobModule) {
   auto runtime = reinterpret_cast<facebook::jsi::Runtime *>(jsRuntime);
-  auto platformContext = std::make_shared<rnwgpu::AndroidPlatformContext>();
+  jobject globalBlobModule = env->NewGlobalRef(blobModule);
+  auto platformContext =
+      std::make_shared<rnwgpu::AndroidPlatformContext>(globalBlobModule);
   manager = std::make_shared<rnwgpu::RNWebGPUManager>(runtime, nullptr,
                                                       platformContext);
 }

package/android/src/main/java/com/webgpu/WebGPUModule.java

@@ -13,6 +13,8 @@ import com.facebook.react.bridge.JavaScriptContextHolder;
 import com.facebook.react.bridge.ReactMethod;
 import com.facebook.react.common.annotations.FrameworkAPI;
 import com.facebook.react.module.annotations.ReactModule;
+import com.facebook.react.modules.blob.BlobModule;
+import com.facebook.react.modules.blob.BlobProvider;
 import com.facebook.react.turbomodule.core.CallInvokerHolderImpl;
 import com.facebook.react.turbomodule.core.interfaces.CallInvokerHolder;
 
@@ -37,13 +39,17 @@ public class WebGPUModule extends NativeWebGPUModuleSpec {
     ReactApplicationContext context = getReactApplicationContext();
     JavaScriptContextHolder jsContext = context.getJavaScriptContextHolder();
     CallInvokerHolder callInvokerHolder = context.getCatalystInstance().getJSCallInvokerHolder();
-    initializeNative(jsContext.get(), (CallInvokerHolderImpl) callInvokerHolder);
+    BlobModule blobModule = getReactApplicationContext().getNativeModule(BlobModule.class);
+    if (blobModule == null) {
+      throw new RuntimeException("React Native's BlobModule was not found!");
+    }
+    initializeNative(jsContext.get(), (CallInvokerHolderImpl) callInvokerHolder, blobModule);
     return true;
   }
 
   @OptIn(markerClass = FrameworkAPI.class)
   @DoNotStrip
-  private native void initializeNative(long jsRuntime, CallInvokerHolderImpl jsInvoker);
+  private native void initializeNative(long jsRuntime, CallInvokerHolderImpl jsInvoker, BlobModule blobModule);
 
   @ReactMethod(isBlockingSynchronousMethod = true)
   public boolean createSurfaceContext(double contextId) {

package/cpp/rnwgpu/PlatformContext.h

@@ -1,9 +1,20 @@
 #pragma once
 
+#include <memory>
+#include <string>
+#include <vector>
+
 #include "webgpu/webgpu_cpp.h"
 
 namespace rnwgpu {
 
+struct ImageData {
+  std::vector<uint8_t> data;
+  size_t width;
+  size_t height;
+  wgpu::TextureFormat format;
+};
+
 class PlatformContext {
 public:
   PlatformContext() = default;
@@ -11,6 +22,8 @@ public:
 
   virtual wgpu::Surface makeSurface(wgpu::Instance instance, void *surface,
                                     int width, int height) = 0;
+  virtual ImageData createImageBitmap(std::string blobId, double offset,
+                                      double size) = 0;
 };
 
-} // namespace rnwgpu
+} // namespace rnwgpu

package/cpp/rnwgpu/RNWebGPUManager.cpp

@@ -1,7 +1,7 @@
 #include "RNWebGPUManager.h"
 
 #include "GPU.h"
-#include "Navigator.h"
+#include "RNWebGPU.h"
 
 // Enums
 #include "GPUBufferUsage.h"
@@ -22,8 +22,11 @@ RNWebGPUManager::RNWebGPUManager(
     : _jsRuntime(jsRuntime), _jsCallInvoker(jsCallInvoker),
       _platformContext(platformContext) {
 
-  _gpu = std::make_shared<GPU>();
-  auto navigator = std::make_shared<Navigator>(_gpu, _platformContext);
+  auto gpu = std::make_shared<GPU>();
+  auto rnWebGPU = std::make_shared<RNWebGPU>(gpu, _platformContext);
+  _jsRuntime->global().setProperty(
+      *_jsRuntime, "RNWebGPU",
+      jsi::Object::createFromHostObject(*_jsRuntime, rnWebGPU));
 
   auto bufferUsage = std::make_shared<GPUBufferUsage>();
   _jsRuntime->global().setProperty(
@@ -49,10 +52,6 @@ RNWebGPUManager::RNWebGPUManager(
   _jsRuntime->global().setProperty(
       *_jsRuntime, "GPUTextureUsage",
       jsi::Object::createFromHostObject(*_jsRuntime, std::move(textureUsage)));
-
-  _jsRuntime->global().setProperty(
-      *_jsRuntime, "navigator",
-      jsi::Object::createFromHostObject(*_jsRuntime, navigator));
 }
 
 RNWebGPUManager::~RNWebGPUManager() {
@@ -60,6 +59,4 @@ RNWebGPUManager::~RNWebGPUManager() {
   _jsCallInvoker = nullptr;
 }
 
-std::shared_ptr<GPU> RNWebGPUManager::getGPU() { return _gpu; }
-
 } // namespace rnwgpu

package/cpp/rnwgpu/RNWebGPUManager.h

@@ -29,13 +29,10 @@ public:
 
   SurfaceRegistry surfacesRegistry;
 
-  std::shared_ptr<GPU> getGPU();
-
 private:
   jsi::Runtime *_jsRuntime;
   std::shared_ptr<facebook::react::CallInvoker> _jsCallInvoker;
   std::shared_ptr<PlatformContext> _platformContext;
-  std::shared_ptr<GPU> _gpu;
 };
 
 } // namespace rnwgpu

package/cpp/rnwgpu/api/GPU.cpp

@@ -10,61 +10,42 @@ namespace rnwgpu {
 std::future<std::variant<std::nullptr_t, std::shared_ptr<GPUAdapter>>>
 GPU::requestAdapter(
     std::optional<std::shared_ptr<GPURequestAdapterOptions>> options) {
-  return std::async(
-      std::launch::async,
-      [this,
-       options]() -> std::variant<std::nullptr_t, std::shared_ptr<GPUAdapter>> {
-        wgpu::RequestAdapterOptions aOptions;
-        Convertor conv;
-        if (!conv(aOptions, options)) {
-          throw std::runtime_error("Failed to convert GPUDeviceDescriptor");
-        }
-        wgpu::Adapter adapter = nullptr;
-        _instance.RequestAdapter(
-            &aOptions,
-            [](WGPURequestAdapterStatus, WGPUAdapter cAdapter,
-               const char *message, void *userdata) {
-              if (message != nullptr) {
-                fprintf(stderr, "%s", message);
-                return;
-              }
-              *static_cast<wgpu::Adapter *>(userdata) =
-                  wgpu::Adapter::Acquire(cAdapter);
-            },
-            &adapter);
-        if (!adapter) {
-          return nullptr;
-        }
+  std::promise<std::variant<std::nullptr_t, std::shared_ptr<GPUAdapter>>>
+      promise;
+  auto future = promise.get_future();
 
-        return std::make_shared<GPUAdapter>(std::move(adapter), _async);
-      });
+  wgpu::RequestAdapterOptions aOptions;
+  Convertor conv;
+  if (!conv(aOptions, options)) {
+    throw std::runtime_error("Failed to convert GPUDeviceDescriptor");
+  }
+#ifdef __APPLE__
+  constexpr auto kDefaultBackendType = wgpu::BackendType::Metal;
+#else
+  constexpr auto kDefaultBackendType = wgpu::BackendType::Vulkan;
+#endif
+  aOptions.backendType = kDefaultBackendType;
+  wgpu::Adapter adapter = nullptr;
+  _instance.RequestAdapter(
+      &aOptions,
+      [](WGPURequestAdapterStatus, WGPUAdapter cAdapter, const char *message,
+         void *userdata) {
+        if (message != nullptr) {
+          fprintf(stderr, "%s", message);
+          return;
+        }
+        *static_cast<wgpu::Adapter *>(userdata) =
+            wgpu::Adapter::Acquire(cAdapter);
+      },
+      &adapter);
+  if (!adapter) {
+    promise.set_value(nullptr);
+  } else {
+    promise.set_value(std::make_shared<GPUAdapter>(std::move(adapter), _async));
+  }
+  return future;
 }
 
-// Async impl keeping here as a reference
-// std::future<std::shared_ptr<GPUAdapter>>
-// GPU::requestAdapter(std::shared_ptr<GPURequestAdapterOptions> options) {
-//   return _async->runAsync([=](wgpu::Instance *instance) {
-//     auto aOptions = options->getInstance();
-//     wgpu::Adapter adapter = nullptr;
-//     auto result = std::make_shared<GPUAdapter>(adapter, _async);
-//     wgpu::RequestAdapterCallbackInfo callback;
-//     callback.callback = [](WGPURequestAdapterStatus, WGPUAdapter cAdapter,
-//                            const char *message, void *userdata) {
-//       if (message != nullptr) {
-//         fprintf(stderr, "%s", message);
-//         return;
-//       }
-//       *static_cast<wgpu::Adapter *>(userdata) =
-//           wgpu::Adapter::Acquire(cAdapter);
-//     };
-//     callback.mode = wgpu::CallbackMode::WaitAnyOnly;
-//     callback.userdata = &(result->_instance);
-//     auto future = _instance.RequestAdapter(aOptions, callback);
-//     instance->WaitAny(future, UINT64_MAX);
-//     return result;
-//   });
-// }
-
 std::unordered_set<std::string> GPU::getWgslLanguageFeatures() {
   auto count = _instance.EnumerateWGSLLanguageFeatures(nullptr);
   std::vector<wgpu::WGSLFeatureName> features(count);

package/cpp/rnwgpu/api/GPUAdapter.cpp

@@ -13,100 +13,100 @@ namespace rnwgpu {
 
 std::future<std::shared_ptr<GPUDevice>> GPUAdapter::requestDevice(
     std::optional<std::shared_ptr<GPUDeviceDescriptor>> descriptor) {
-  return std::async(std::launch::async, [this,
-                                         descriptor = std::move(descriptor)]() {
-    wgpu::Device device = nullptr;
-    wgpu::DeviceDescriptor aDescriptor;
-    Convertor conv;
-    if (!conv(aDescriptor, descriptor)) {
-      throw std::runtime_error("Failed to convert GPUDeviceDescriptor");
+  std::promise<std::shared_ptr<GPUDevice>> promise;
+  auto future = promise.get_future();
+  wgpu::Device device = nullptr;
+  wgpu::DeviceDescriptor aDescriptor;
+  Convertor conv;
+  if (!conv(aDescriptor, descriptor)) {
+    throw std::runtime_error("Failed to convert GPUDeviceDescriptor");
+  }
+  wgpu::DeviceLostCallbackInfo info = {
+      .callback = [](WGPUDevice const *device, WGPUDeviceLostReason reason,
+                     char const *message, void *userdata) {
+        const char *lostReason = "";
+        switch (reason) {
+        case WGPUDeviceLostReason_Destroyed:
+          lostReason = "Destroyed";
+          break;
+        case WGPUDeviceLostReason_Unknown:
+          lostReason = "Unknown";
+          break;
+        default:
+          lostReason = "Unknown";
+        }
+        Logger::logToConsole("GPU Device Lost (%s): %s", lostReason, message);
+      }};
+  aDescriptor.deviceLostCallbackInfo = info;
+  wgpu::UncapturedErrorCallbackInfo errorInfo;
+  errorInfo.userdata = static_cast<void *>(_creationRuntime);
+  errorInfo.callback = [](WGPUErrorType type, const char *message,
+                          void *userdata) {
+    auto creationRuntime = static_cast<jsi::Runtime *>(userdata);
+    const char *errorType = "";
+    switch (type) {
+    case WGPUErrorType_Validation:
+      errorType = "Validation";
+      break;
+    case WGPUErrorType_OutOfMemory:
+      errorType = "Out of Memory";
+      break;
+    case WGPUErrorType_Internal:
+      errorType = "Internal";
+      break;
+    case WGPUErrorType_Unknown:
+      errorType = "Unknown";
+      break;
+    default:
+      errorType = "Unknown";
     }
-    wgpu::DeviceLostCallbackInfo info = {
-        .callback = [](WGPUDevice const *device, WGPUDeviceLostReason reason,
-                       char const *message, void *userdata) {
-          const char *lostReason = "";
-          switch (reason) {
-          case WGPUDeviceLostReason_Destroyed:
-            lostReason = "Destroyed";
-            break;
-          case WGPUDeviceLostReason_Unknown:
-            lostReason = "Unknown";
-            break;
-          default:
-            lostReason = "Unknown";
-          }
-          Logger::logToConsole("GPU Device Lost (%s): %s", lostReason, message);
-        }};
-    aDescriptor.deviceLostCallbackInfo = info;
-    wgpu::UncapturedErrorCallbackInfo errorInfo;
-    errorInfo.userdata = static_cast<void *>(_creationRuntime);
-    errorInfo.callback = [](WGPUErrorType type, const char *message,
-                            void *userdata) {
-      auto creationRuntime = static_cast<jsi::Runtime *>(userdata);
-      const char *errorType = "";
-      switch (type) {
-      case WGPUErrorType_Validation:
-        errorType = "Validation";
-        break;
-      case WGPUErrorType_OutOfMemory:
-        errorType = "Out of Memory";
-        break;
-      case WGPUErrorType_Internal:
-        errorType = "Internal";
-        break;
-      case WGPUErrorType_Unknown:
-        errorType = "Unknown";
-        break;
-      default:
-        errorType = "Unknown";
-      }
-      std::string fullMessage = std::string(errorType) + ": " + message;
-      Logger::errorToJavascriptConsole(*creationRuntime, fullMessage.c_str());
-    };
-    aDescriptor.uncapturedErrorCallbackInfo = errorInfo;
-    _instance.RequestDevice(
-        &aDescriptor,
-        [](WGPURequestDeviceStatus status, WGPUDevice cDevice,
-           const char *message, void *userdata) {
-          if (message != nullptr) {
-            fprintf(stderr, "%s", message);
-            return;
-          }
-          *static_cast<wgpu::Device *>(userdata) =
-              wgpu::Device::Acquire(cDevice);
-        },
-        &device);
+    std::string fullMessage = std::string(errorType) + ": " + message;
+    Logger::errorToJavascriptConsole(*creationRuntime, fullMessage.c_str());
+  };
+  aDescriptor.uncapturedErrorCallbackInfo = errorInfo;
+  _instance.RequestDevice(
+      &aDescriptor,
+      [](WGPURequestDeviceStatus status, WGPUDevice cDevice,
+         const char *message, void *userdata) {
+        if (message != nullptr) {
+          fprintf(stderr, "%s", message);
+          return;
+        }
+        *static_cast<wgpu::Device *>(userdata) = wgpu::Device::Acquire(cDevice);
+      },
+      &device);
 
-    if (!device) {
-      throw std::runtime_error("Failed to request device");
-    }
-    device.SetLoggingCallback(
-        [](WGPULoggingType type, const char *message, void *userdata) {
-          auto creationRuntime = static_cast<jsi::Runtime *>(userdata);
-          const char *logLevel = "";
-          switch (type) {
-          case WGPULoggingType_Warning:
-            logLevel = "Warning";
-            Logger::warnToJavascriptConsole(*creationRuntime, message);
-            break;
-          case WGPULoggingType_Error:
-            logLevel = "Error";
-            Logger::errorToJavascriptConsole(*creationRuntime, message);
-            break;
-          case WGPULoggingType_Verbose:
-            logLevel = "Verbose";
-          case WGPULoggingType_Info:
-            logLevel = "Info";
-          default:
-            logLevel = "Unknown";
-            Logger::logToConsole("%s: %s", logLevel, message);
-          }
-        },
-        _creationRuntime);
-    std::string label =
-        descriptor.has_value() ? descriptor.value()->label.value_or("") : "";
-    return std::make_shared<GPUDevice>(std::move(device), _async, label);
-  });
+  if (!device) {
+    throw std::runtime_error("Failed to request device");
+  }
+  device.SetLoggingCallback(
+      [](WGPULoggingType type, const char *message, void *userdata) {
+        auto creationRuntime = static_cast<jsi::Runtime *>(userdata);
+        const char *logLevel = "";
+        switch (type) {
+        case WGPULoggingType_Warning:
+          logLevel = "Warning";
+          Logger::warnToJavascriptConsole(*creationRuntime, message);
+          break;
+        case WGPULoggingType_Error:
+          logLevel = "Error";
+          Logger::errorToJavascriptConsole(*creationRuntime, message);
+          break;
+        case WGPULoggingType_Verbose:
+          logLevel = "Verbose";
+        case WGPULoggingType_Info:
+          logLevel = "Info";
+        default:
+          logLevel = "Unknown";
+          Logger::logToConsole("%s: %s", logLevel, message);
+        }
+      },
+      _creationRuntime);
+  std::string label =
+      descriptor.has_value() ? descriptor.value()->label.value_or("") : "";
+  promise.set_value(
+      std::make_shared<GPUDevice>(std::move(device), _async, label));
+  return future;
 }
 
 std::unordered_set<std::string> GPUAdapter::getFeatures() {

package/cpp/rnwgpu/api/GPUBuffer.h

@@ -77,4 +77,4 @@ private:
   std::vector<Mapping> mappings;
 };
 
-} // namespace rnwgpu
+} // namespace rnwgpu

package/cpp/rnwgpu/api/GPUQueue.cpp

@@ -86,8 +86,51 @@ std::future<void> GPUQueue::onSubmittedWorkDone() {
 void GPUQueue::copyExternalImageToTexture(
     std::shared_ptr<GPUImageCopyExternalImage> source,
     std::shared_ptr<GPUImageCopyTextureTagged> destination,
-    std::shared_ptr<GPUExtent3D> copySize) {
-  throw std::runtime_error("Unimplemented");
+    std::shared_ptr<GPUExtent3D> size) {
+  wgpu::ImageCopyTexture dst{};
+  wgpu::TextureDataLayout layout{};
+  wgpu::Extent3D sz{};
+  Convertor conv;
+  uint32_t bytesPerPixel =
+      source->source->getSize() /
+      (source->source->getWidth() * source->source->getHeight());
+  auto dataLayout = std::make_shared<GPUImageDataLayout>(GPUImageDataLayout{
+      std::optional<double>{0.0},
+      std::optional<double>{
+          static_cast<double>(bytesPerPixel * source->source->getWidth())},
+      std::optional<double>{static_cast<double>(source->source->getHeight())}});
+  if (!conv(dst.aspect, destination->aspect) ||
+      !conv(dst.mipLevel, destination->mipLevel) ||
+      !conv(dst.origin, destination->origin) ||
+      !conv(dst.texture, destination->texture) ||
+      !conv(layout, dataLayout) || //
+      !conv(sz, size)) {
+    throw std::runtime_error("Invalid input for GPUQueue::writeTexture()");
+  }
+
+  if (source->flipY) {
+    // Calculate the row size and total size
+    uint32_t rowSize = bytesPerPixel * source->source->getWidth();
+    uint32_t totalSize = source->source->getSize();
+
+    // Create a new buffer for the flipped data
+    std::vector<uint8_t> flippedData(totalSize);
+
+    // Flip the data vertically
+    for (uint32_t row = 0; row < source->source->getHeight(); ++row) {
+      std::memcpy(flippedData.data() +
+                      (source->source->getHeight() - 1 - row) * rowSize,
+                  static_cast<const uint8_t *>(source->source->getData()) +
+                      row * rowSize,
+                  rowSize);
+    }
+    // Use the flipped data for writing to texture
+    _instance.WriteTexture(&dst, flippedData.data(), totalSize, &layout, &sz);
+  } else {
+
+    _instance.WriteTexture(&dst, source->source->getData(),
+                           source->source->getSize(), &layout, &sz);
+  }
 }
 
 void GPUQueue::writeTexture(std::shared_ptr<GPUImageCopyTexture> destination,

package/cpp/rnwgpu/api/ImageBitmap.h

@@ -0,0 +1,34 @@
+#pragma once
+
+#include <memory>
+
+#include "webgpu/webgpu_cpp.h"
+
+#include "PlatformContext.h"
+#include "RNFHybridObject.h"
+
+namespace rnwgpu {
+
+class ImageBitmap : public margelo::HybridObject {
+public:
+  explicit ImageBitmap(ImageData &imageData)
+      : HybridObject("ImageBitmap"), _imageData(imageData) {}
+
+  size_t getWidth() { return _imageData.width; }
+
+  size_t getHeight() { return _imageData.height; }
+
+  void *getData() { return _imageData.data.data(); }
+
+  size_t getSize() { return _imageData.data.size(); }
+
+  void loadHybridMethods() override {
+    registerHybridGetter("width", &ImageBitmap::getWidth, this);
+    registerHybridGetter("height", &ImageBitmap::getHeight, this);
+  }
+
+private:
+  ImageData _imageData;
+};
+
+} // namespace rnwgpu