react-native-wgpu 0.2.0 → 0.2.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-wgpu",
-  "version": "0.2.0",
+  "version": "0.2.2",
   "description": "React Native WebGPU",
   "main": "lib/commonjs/index",
   "module": "lib/module/index",

package/src/__tests__/Constants.spec.ts

@@ -62,16 +62,14 @@ describe("WebGPUConstants", () => {
     });
   });
   it("GPUAdapter", async () => {
-    const result = await client.eval(({ adapter, device, gpu }) => {
+    const result = await client.eval(({ device, gpu }) => {
       return [
         gpu instanceof GPU,
-        adapter instanceof GPUAdapter,
         device instanceof GPUDevice,
-        adapter instanceof GPUDevice,
         device instanceof GPUAdapter,
       ];
     });
-    expect(result).toEqual([true, true, true, false, false]);
+    expect(result).toEqual([true, true, false]);
   });
   it("instanceof", async () => {
     const result = await client.eval(

package/src/__tests__/Device.spec.ts

@@ -2,33 +2,49 @@ import { client } from "./setup";
 
 describe("Device", () => {
   it("request device (1)", async () => {
-    const result = await client.eval(({ adapter }) =>
-      adapter.requestDevice().then((device) => device !== null),
+    const result = await client.eval(({ gpu }) =>
+      gpu
+        .requestAdapter()
+        .then((adapter) =>
+          adapter!.requestDevice().then((device) => device !== null),
+        ),
     );
     expect(result).toBe(true);
   });
 
   it("request device (2)", async () => {
-    const result = await client.eval(({ adapter }) =>
-      adapter.requestDevice(undefined).then((device) => device.label),
+    const result = await client.eval(({ gpu }) =>
+      gpu
+        .requestAdapter()
+        .then((adapter) =>
+          adapter!.requestDevice(undefined).then((device) => device.label),
+        ),
     );
     expect(result).toBe("");
   });
   it("request device (3)", async () => {
-    const result = await client.eval(({ adapter }) =>
-      adapter.requestDevice({ label: "MyGPU" }).then((device) => device.label),
+    const result = await client.eval(({ gpu }) =>
+      gpu
+        .requestAdapter()
+        .then((adapter) =>
+          adapter!
+            .requestDevice({ label: "MyGPU" })
+            .then((device) => device.label),
+        ),
     );
     expect(result).toBe("MyGPU");
   });
   it("destroy device (3)", async () => {
-    const result = await client.eval(({ adapter }) =>
-      adapter.requestDevice({ label: "MyGPU" }).then((device) => {
-        device.destroy();
-        return device.lost.then((r) => ({
-          reason: r.reason,
-          message: r.message,
-        }));
-      }),
+    const result = await client.eval(({ gpu }) =>
+      gpu.requestAdapter().then((adapter) =>
+        adapter!.requestDevice({ label: "MyGPU" }).then((device) => {
+          device.destroy();
+          return device.lost.then((r) => ({
+            reason: r.reason,
+            message: r.message,
+          }));
+        }),
+      ),
     );
     expect(["unknown", "destroyed"].includes(result.reason)).toBe(true);
   });
@@ -48,17 +64,19 @@ describe("Device", () => {
   });
 
   it("resolves an awaited device.lost when device.destroy is called", async () => {
-    const result = await client.eval(({ adapter }) =>
-      adapter.requestDevice({ label: "myGPU2" }).then((device) => {
-        setTimeout(() => {
-          device.destroy();
-        }, 50);
+    const result = await client.eval(({ gpu }) =>
+      gpu.requestAdapter().then((adapter) =>
+        adapter!.requestDevice({ label: "myGPU2" }).then((device) => {
+          setTimeout(() => {
+            device.destroy();
+          }, 50);
 
-        return device.lost.then((r) => ({
-          reason: r.reason,
-          message: r.message,
-        }));
-      }),
+          return device.lost.then((r) => ({
+            reason: r.reason,
+            message: r.message,
+          }));
+        }),
+      ),
     );
 
     expect(["unknown", "destroyed"].includes(result.reason)).toBeTruthy();

package/src/__tests__/GPU.spec.ts

@@ -73,61 +73,69 @@ describe("Adapter", () => {
     expect(result!.description).toBeDefined();
   });
   it("isFallback", async () => {
-    const result = await client.eval(({ adapter }) => {
-      return adapter.isFallbackAdapter;
+    const result = await client.eval(({ gpu }) => {
+      return gpu.requestAdapter().then((adapter) => adapter!.isFallbackAdapter);
     });
     expect(result).toBe(false);
   });
   it("features", async () => {
-    const result = await client.eval(({ adapter }) => {
-      return Array.from(adapter.features);
+    const result = await client.eval(({ gpu }) => {
+      return gpu
+        .requestAdapter()
+        .then((adapter) => Array.from(adapter!.features));
     });
     expect(result.includes("depth-clip-control")).toBe(true);
     expect(result.includes("rg11b10ufloat-renderable")).toBe(true);
     expect(result.includes("texture-compression-etc2")).toBe(true);
   });
   it("requiredLimits", async () => {
-    const result = await client.eval(({ adapter }) => {
-      return adapter
-        .requestDevice({
-          requiredLimits: {
-            maxBufferSize: 1024 * 1024 * 4,
-          },
-        })
-        .then((device) => !!device);
+    const result = await client.eval(({ gpu }) => {
+      return gpu.requestAdapter().then((adapter) =>
+        adapter!
+          .requestDevice({
+            requiredLimits: {
+              maxBufferSize: 1024 * 1024 * 4,
+            },
+          })
+          .then((device) => !!device),
+      );
     });
     expect(result).toBe(true);
   });
   it("request device with timestamp queries", async () => {
-    const result = await client.eval(({ adapter }) => {
-      if (adapter.features.has("timestamp-query")) {
-        return adapter
-          .requestDevice({
-            requiredFeatures: ["timestamp-query"],
-          })
-          .then((device) => device.features.has("timestamp-query"));
-      }
-      return true;
+    const result = await client.eval(({ gpu }) => {
+      return gpu.requestAdapter().then((adapter) => {
+        if (adapter!.features.has("timestamp-query")) {
+          return adapter!
+            .requestDevice({
+              requiredFeatures: ["timestamp-query"],
+            })
+            .then((device) => device.features.has("timestamp-query"));
+        }
+        return true;
+      });
     });
     expect(result).toBe(true);
   });
   it("request device faulty input", async () => {
-    const result = await client.eval(({ adapter }) => {
-      return adapter
-        .requestDevice({
-          // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-          // @ts-expect-error
-          requiredFeatures: [["bgra8unorm-storage"]],
-          requiredLimits: {
-            maxComputeWorkgroupStorageSize: 16352,
-            maxComputeWorkgroupsPerDimension: 65535,
-            maxStorageBufferBindingSize: 268435456,
-            maxBufferSize: 268435456,
-            maxComputeWorkgroupSizeX: 512,
-            maxComputeInvocationsPerWorkgroup: 512,
-          },
-        })
-        .then((device) => !!device);
+    const result = await client.eval(({ gpu }) => {
+      return gpu.requestAdapter().then((adapter) =>
+        adapter!
+          .requestDevice({
+            // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+            // @ts-expect-error
+            requiredFeatures: [["bgra8unorm-storage"]],
+            requiredLimits: {
+              maxComputeWorkgroupStorageSize: 16352,
+              maxComputeWorkgroupsPerDimension: 65535,
+              maxStorageBufferBindingSize: 268435456,
+              maxBufferSize: 268435456,
+              maxComputeWorkgroupSizeX: 512,
+              maxComputeInvocationsPerWorkgroup: 512,
+            },
+          })
+          .then((device) => !!device),
+      );
     });
     expect(result).toBe(true);
   });
@@ -144,74 +152,76 @@ describe("Adapter", () => {
   //   expect(result).toBe(true);
   // });
   it("limits", async () => {
-    const result = await client.eval(({ adapter }) => {
-      const {
-        maxTextureDimension1D,
-        maxTextureDimension2D,
-        maxTextureDimension3D,
-        maxTextureArrayLayers,
-        maxBindGroups,
-        maxBindGroupsPlusVertexBuffers,
-        maxBindingsPerBindGroup,
-        maxDynamicUniformBuffersPerPipelineLayout,
-        maxDynamicStorageBuffersPerPipelineLayout,
-        maxSampledTexturesPerShaderStage,
-        maxSamplersPerShaderStage,
-        maxStorageBuffersPerShaderStage,
-        maxStorageTexturesPerShaderStage,
-        maxUniformBuffersPerShaderStage,
-        maxUniformBufferBindingSize,
-        maxStorageBufferBindingSize,
-        minUniformBufferOffsetAlignment,
-        minStorageBufferOffsetAlignment,
-        maxVertexBuffers,
-        maxBufferSize,
-        maxVertexAttributes,
-        maxVertexBufferArrayStride,
-        maxInterStageShaderVariables,
-        maxColorAttachments,
-        maxColorAttachmentBytesPerSample,
-        maxComputeWorkgroupStorageSize,
-        maxComputeInvocationsPerWorkgroup,
-        maxComputeWorkgroupSizeX,
-        maxComputeWorkgroupSizeY,
-        maxComputeWorkgroupSizeZ,
-        maxComputeWorkgroupsPerDimension,
-      } = adapter.limits;
-      return {
-        __brand: adapter.limits.__brand,
-        maxTextureDimension1D,
-        maxTextureDimension2D,
-        maxTextureDimension3D,
-        maxTextureArrayLayers,
-        maxBindGroups,
-        maxBindGroupsPlusVertexBuffers,
-        maxBindingsPerBindGroup,
-        maxDynamicUniformBuffersPerPipelineLayout,
-        maxDynamicStorageBuffersPerPipelineLayout,
-        maxSampledTexturesPerShaderStage,
-        maxSamplersPerShaderStage,
-        maxStorageBuffersPerShaderStage,
-        maxStorageTexturesPerShaderStage,
-        maxUniformBuffersPerShaderStage,
-        maxUniformBufferBindingSize,
-        maxStorageBufferBindingSize,
-        minUniformBufferOffsetAlignment,
-        minStorageBufferOffsetAlignment,
-        maxVertexBuffers,
-        maxBufferSize,
-        maxVertexAttributes,
-        maxVertexBufferArrayStride,
-        maxInterStageShaderVariables,
-        maxColorAttachments,
-        maxColorAttachmentBytesPerSample,
-        maxComputeWorkgroupStorageSize,
-        maxComputeInvocationsPerWorkgroup,
-        maxComputeWorkgroupSizeX,
-        maxComputeWorkgroupSizeY,
-        maxComputeWorkgroupSizeZ,
-        maxComputeWorkgroupsPerDimension,
-      };
+    const result = await client.eval(({ gpu }) => {
+      return gpu.requestAdapter().then((adapter) => {
+        const {
+          maxTextureDimension1D,
+          maxTextureDimension2D,
+          maxTextureDimension3D,
+          maxTextureArrayLayers,
+          maxBindGroups,
+          maxBindGroupsPlusVertexBuffers,
+          maxBindingsPerBindGroup,
+          maxDynamicUniformBuffersPerPipelineLayout,
+          maxDynamicStorageBuffersPerPipelineLayout,
+          maxSampledTexturesPerShaderStage,
+          maxSamplersPerShaderStage,
+          maxStorageBuffersPerShaderStage,
+          maxStorageTexturesPerShaderStage,
+          maxUniformBuffersPerShaderStage,
+          maxUniformBufferBindingSize,
+          maxStorageBufferBindingSize,
+          minUniformBufferOffsetAlignment,
+          minStorageBufferOffsetAlignment,
+          maxVertexBuffers,
+          maxBufferSize,
+          maxVertexAttributes,
+          maxVertexBufferArrayStride,
+          maxInterStageShaderVariables,
+          maxColorAttachments,
+          maxColorAttachmentBytesPerSample,
+          maxComputeWorkgroupStorageSize,
+          maxComputeInvocationsPerWorkgroup,
+          maxComputeWorkgroupSizeX,
+          maxComputeWorkgroupSizeY,
+          maxComputeWorkgroupSizeZ,
+          maxComputeWorkgroupsPerDimension,
+        } = adapter!.limits;
+        return {
+          __brand: adapter!.limits.__brand,
+          maxTextureDimension1D,
+          maxTextureDimension2D,
+          maxTextureDimension3D,
+          maxTextureArrayLayers,
+          maxBindGroups,
+          maxBindGroupsPlusVertexBuffers,
+          maxBindingsPerBindGroup,
+          maxDynamicUniformBuffersPerPipelineLayout,
+          maxDynamicStorageBuffersPerPipelineLayout,
+          maxSampledTexturesPerShaderStage,
+          maxSamplersPerShaderStage,
+          maxStorageBuffersPerShaderStage,
+          maxStorageTexturesPerShaderStage,
+          maxUniformBuffersPerShaderStage,
+          maxUniformBufferBindingSize,
+          maxStorageBufferBindingSize,
+          minUniformBufferOffsetAlignment,
+          minStorageBufferOffsetAlignment,
+          maxVertexBuffers,
+          maxBufferSize,
+          maxVertexAttributes,
+          maxVertexBufferArrayStride,
+          maxInterStageShaderVariables,
+          maxColorAttachments,
+          maxColorAttachmentBytesPerSample,
+          maxComputeWorkgroupStorageSize,
+          maxComputeInvocationsPerWorkgroup,
+          maxComputeWorkgroupSizeX,
+          maxComputeWorkgroupSizeY,
+          maxComputeWorkgroupSizeZ,
+          maxComputeWorkgroupsPerDimension,
+        };
+      });
     });
     if (result.__brand) {
       expect(result.__brand).toBe("GPUSupportedLimits");

package/src/__tests__/setup.ts

@@ -29,7 +29,6 @@ declare global {
 
 interface GPUTestingContext {
   gpu: GPU;
-  adapter: GPUAdapter;
   device: GPUDevice;
   shaders: {
     triangleVertWGSL: string;