@zephyr3d/scene 0.1.2 → 0.3.0

package/dist/shapes/cylinder.js

@@ -19,9 +19,6 @@ import { Shape } from './shape.js';
         options.heightDetail = 1;
         options.radialDetail = 20;
         options.height = 1;
-        options.anchorX = 0.5;
-        options.anchorY = 0;
-        options.anchorZ = 0.5;
         return options;
     }
     /** @internal */ addPatch(x, y, indices) {
@@ -43,7 +40,7 @@ import { Shape } from './shape.js';
                 const sinTheta = Math.sin(theta);
                 const cosTheta = Math.cos(theta);
                 const m = 1 / Math.sqrt(sinTheta * sinTheta + slope * slope + cosTheta * cosTheta);
-                vertices.push(radius * sinTheta, v * this._options.height, radius * cosTheta);
+                vertices.push(radius * sinTheta, (v - 0.5) * this._options.height, radius * cosTheta);
                 normals.push(sinTheta * m, slope * m, cosTheta * m);
                 uvs.push(u, 1 - v);
                 if (y < this._options.heightDetail && x < this._options.radialDetail) {

package/dist/shapes/cylinder.js.map

@@ -1 +1 @@
-{"version":3,"file":"cylinder.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"cylinder.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/shapes/shape.js

@@ -13,6 +13,11 @@ import { Primitive } from '../render/primitive.js';
         this._options = this.createDefaultOptions();
         this.create(options);
     }
+    /**
+   * Creation options
+   */ get options() {
+        return this._options;
+    }
     /** @internal */ create(options) {
         if (options) {
             this._options = this.createDefaultOptions();

package/dist/shapes/shape.js.map

@@ -1 +1 @@
-{"version":3,"file":"shape.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"shape.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/shapes/sphere.js

@@ -28,6 +28,9 @@ import { Shape } from './shape.js';
         }
         return a - Math.sqrt(rSquared - bSquared);
     }
+    /** Sphere radius */ get radius() {
+        return this._options.radius ?? 1;
+    }
     /** @internal */ createDefaultOptions() {
         const options = super.createDefaultOptions();
         options.radius = 1;

package/dist/shapes/sphere.js.map

@@ -1 +1 @@
-{"version":3,"file":"sphere.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"sphere.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/shapes/torus.js

@@ -17,9 +17,9 @@ TC(n, m) = (m / M, n / N)
 
 VIndex(n, m) = n * (M + 1) + m
 Triangle(n, m) = (VIndex(n, m), VIndex(n+1, m), VIndex(n+1, m+1), VIndex(n, m), VIndex(n+1, m+1), VIndex(n, m+1))*/ /**
- * 
+ *
  * Torus shape
- * 
+ *
  * @public
  */ class TorusShape extends Shape {
     /**

package/dist/utility/bounding_volume.js

@@ -1,9 +1,9 @@
 import { AABB, Frustum, ClipState } from '@zephyr3d/base';
 import { AABBTree } from './aabbtree.js';
 
-/**
- * The bounding box class
- * @public
+/**
+ * The bounding box class
+ * @public
  */ class BoundingBox extends AABB {
     constructor(arg0, arg1){
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -25,9 +25,9 @@ import { AABBTree } from './aabbtree.js';
         return this;
     }
 }
-/**
- * Bounding box tree
- * @public
+/**
+ * Bounding box tree
+ * @public
  */ class BoundingBoxTree extends AABBTree {
     constructor(arg){
         super(arg);
@@ -54,27 +54,27 @@ import { AABBTree } from './aabbtree.js';
     /** {@inheritDoc BoundingVolume.toAABB} */ toAABB() {
         return this.getTopLevelAABB();
     }
-} /*
-export class BoundingFrustum implements BoundingVolume {
-    protected _frustum: Frustum;
-    constructor ();
-    constructor (other: BoundingFrustum|Frustum|Matrix4x4);
-    constructor (arg0?: BoundingFrustum|Frustum|Matrix4x4) {
-        if (arg0 instanceof BoundingFrustum) {
-            this._frustum = arg0._frustum ? new Frustum (arg0._frustum) : null;
-        } else if (arg0 instanceof Frustum) {
-            this._frustum = new Frustum (arg0);
-        } else if (arg0 instanceof Matrix4x4) {
-            this._frustum = new Frustum (arg0);
-        } else {
-            this._frustum = null;
-        }
-    }
-    clone (): BoundingVolume {
-        return new BoundingFrustum (this);
-    }
-    transform (matrix: Matrix4x4)
-}
+} /*
+export class BoundingFrustum implements BoundingVolume {
+    protected _frustum: Frustum;
+    constructor ();
+    constructor (other: BoundingFrustum|Frustum|Matrix4x4);
+    constructor (arg0?: BoundingFrustum|Frustum|Matrix4x4) {
+        if (arg0 instanceof BoundingFrustum) {
+            this._frustum = arg0._frustum ? new Frustum (arg0._frustum) : null;
+        } else if (arg0 instanceof Frustum) {
+            this._frustum = new Frustum (arg0);
+        } else if (arg0 instanceof Matrix4x4) {
+            this._frustum = new Frustum (arg0);
+        } else {
+            this._frustum = null;
+        }
+    }
+    clone (): BoundingVolume {
+        return new BoundingFrustum (this);
+    }
+    transform (matrix: Matrix4x4)
+}
 */
 
 export { BoundingBox, BoundingBoxTree };

package/dist/utility/pmrem.js

@@ -140,10 +140,10 @@ function createPMREMProgram(type, numSamples) {
                 ], function() {
                     this.$l.n = this.bits;
                     this.n = pb.compOr(pb.sal(this.n, 16), pb.sar(this.n, 16));
-                    this.n = pb.compOr(pb.sal(pb.compAnd(this.n, 0x55555555), 1), pb.sar(pb.compAnd(this.n, 0xAAAAAAAA), 1));
-                    this.n = pb.compOr(pb.sal(pb.compAnd(this.n, 0x33333333), 2), pb.sar(pb.compAnd(this.n, 0xCCCCCCCC), 2));
-                    this.n = pb.compOr(pb.sal(pb.compAnd(this.n, 0x0F0F0F0F), 4), pb.sar(pb.compAnd(this.n, 0xF0F0F0F0), 4));
-                    this.n = pb.compOr(pb.sal(pb.compAnd(this.n, 0x00FF00FF), 8), pb.sar(pb.compAnd(this.n, 0xFF00FF00), 8));
+                    this.n = pb.compOr(pb.sal(pb.compAnd(this.n, 0x55555555), 1), pb.sar(pb.compAnd(this.n, 0xaaaaaaaa), 1));
+                    this.n = pb.compOr(pb.sal(pb.compAnd(this.n, 0x33333333), 2), pb.sar(pb.compAnd(this.n, 0xcccccccc), 2));
+                    this.n = pb.compOr(pb.sal(pb.compAnd(this.n, 0x0f0f0f0f), 4), pb.sar(pb.compAnd(this.n, 0xf0f0f0f0), 4));
+                    this.n = pb.compOr(pb.sal(pb.compAnd(this.n, 0x00ff00ff), 8), pb.sar(pb.compAnd(this.n, 0xff00ff00), 8));
                     this.$return(pb.mul(pb.float(this.n), 2.3283064365386963e-10));
                 });
                 pb.func('hammersley2d', [

package/dist/utility/sheenlut.js

@@ -0,0 +1,196 @@
+import { Vector3, Vector2 } from '@zephyr3d/base';
+import { Application } from '../app.js';
+
+const bits = new Uint32Array(1);
+//Van der Corput radical inverse
+function radicalInverse_VdC(i) {
+    bits[0] = i;
+    bits[0] = (bits[0] << 16 | bits[0] >> 16) >>> 0;
+    bits[0] = (bits[0] & 0x55555555) << 1 | (bits[0] & 0xaaaaaaaa) >>> 1 >>> 0;
+    bits[0] = (bits[0] & 0x33333333) << 2 | (bits[0] & 0xcccccccc) >>> 2 >>> 0;
+    bits[0] = (bits[0] & 0x0f0f0f0f) << 4 | (bits[0] & 0xf0f0f0f0) >>> 4 >>> 0;
+    bits[0] = (bits[0] & 0x00ff00ff) << 8 | (bits[0] & 0xff00ff00) >>> 8 >>> 0;
+    return bits[0] * 2.3283064365386963e-10; // / 0x100000000 or / 4294967296
+}
+function hammersley(i, iN, out) {
+    out.setXY(i * iN, radicalInverse_VdC(i));
+}
+function distributionCharlie(NdotH, roughness) {
+    // roughness = Math.max(roughness, 0.000001);
+    const invAlpha = 1 / roughness;
+    const cos2h = NdotH * NdotH;
+    const sin2h = 1 - cos2h;
+    return (2 + invAlpha) * Math.pow(sin2h, invAlpha * 0.5) / (2 * Math.PI);
+}
+function visibilityAshikhmin(NdotV, NdotL) {
+    return Math.min(Math.max(1 / (4 * (NdotL + NdotV - NdotL * NdotV)), 0), 1);
+}
+function hemisphereUniformSample(u, out) {
+    const phi = 2 * Math.PI * u.x;
+    const cosTheta = 1 - u.y;
+    const sinTheta = Math.sqrt(1 - cosTheta * cosTheta);
+    out.setXYZ(sinTheta * Math.cos(phi), sinTheta * Math.sin(phi), cosTheta);
+}
+function dfvCharlieUniform(NdotV, roughness, numSamples) {
+    let r = 0;
+    const V = new Vector3(Math.sqrt(1 - NdotV * NdotV), 0, NdotV);
+    const u = new Vector2();
+    const H = new Vector3();
+    const L = new Vector3();
+    for(let i = 0; i < numSamples; i++){
+        hammersley(i, 1 / numSamples, u);
+        hemisphereUniformSample(u, H);
+        Vector3.scale(H, Vector3.dot(V, H) * 2, L).subBy(V);
+        const VdotH = Math.min(Math.max(Vector3.dot(V, H), 0), 1);
+        const NdotL = Math.min(Math.max(L.z, 0), 1);
+        const NdotH = Math.min(Math.max(H.z, 0), 1);
+        if (NdotL > 0) {
+            const v = visibilityAshikhmin(NdotV, NdotL);
+            // const v = visibilityCharlie(NdotV, NdotL, roughness);
+            const d = distributionCharlie(NdotH, roughness);
+            r += v * d * NdotL * VdotH;
+        }
+    }
+    return r * (4 * 2 * Math.PI / numSamples);
+}
+const _tables = function _generateTables() {
+    // float32 to float16 helpers
+    const buffer = new ArrayBuffer(4);
+    const floatView = new Float32Array(buffer);
+    const uint32View = new Uint32Array(buffer);
+    const baseTable = new Uint32Array(512);
+    const shiftTable = new Uint32Array(512);
+    for(let i = 0; i < 256; ++i){
+        const e = i - 127;
+        // very small number (0, -0)
+        if (e < -27) {
+            baseTable[i] = 0x0000;
+            baseTable[i | 0x100] = 0x8000;
+            shiftTable[i] = 24;
+            shiftTable[i | 0x100] = 24;
+        // small number (denorm)
+        } else if (e < -14) {
+            baseTable[i] = 0x0400 >> -e - 14;
+            baseTable[i | 0x100] = 0x0400 >> -e - 14 | 0x8000;
+            shiftTable[i] = -e - 1;
+            shiftTable[i | 0x100] = -e - 1;
+        // normal number
+        } else if (e <= 15) {
+            baseTable[i] = e + 15 << 10;
+            baseTable[i | 0x100] = e + 15 << 10 | 0x8000;
+            shiftTable[i] = 13;
+            shiftTable[i | 0x100] = 13;
+        // large number (Infinity, -Infinity)
+        } else if (e < 128) {
+            baseTable[i] = 0x7c00;
+            baseTable[i | 0x100] = 0xfc00;
+            shiftTable[i] = 24;
+            shiftTable[i | 0x100] = 24;
+        // stay (NaN, Infinity, -Infinity)
+        } else {
+            baseTable[i] = 0x7c00;
+            baseTable[i | 0x100] = 0xfc00;
+            shiftTable[i] = 13;
+            shiftTable[i | 0x100] = 13;
+        }
+    }
+    // float16 to float32 helpers
+    const mantissaTable = new Uint32Array(2048);
+    const exponentTable = new Uint32Array(64);
+    const offsetTable = new Uint32Array(64);
+    for(let i = 1; i < 1024; ++i){
+        let m = i << 13; // zero pad mantissa bits
+        let e = 0; // zero exponent
+        // normalized
+        while((m & 0x00800000) === 0){
+            m <<= 1;
+            e -= 0x00800000; // decrement exponent
+        }
+        m &= ~0x00800000; // clear leading 1 bit
+        e += 0x38800000; // adjust bias
+        mantissaTable[i] = m | e;
+    }
+    for(let i = 1024; i < 2048; ++i){
+        mantissaTable[i] = 0x38000000 + (i - 1024 << 13);
+    }
+    for(let i = 1; i < 31; ++i){
+        exponentTable[i] = i << 23;
+    }
+    exponentTable[31] = 0x47800000;
+    exponentTable[32] = 0x80000000;
+    for(let i = 33; i < 63; ++i){
+        exponentTable[i] = 0x80000000 + (i - 32 << 23);
+    }
+    exponentTable[63] = 0xc7800000;
+    for(let i = 1; i < 64; ++i){
+        if (i !== 32) {
+            offsetTable[i] = 1024;
+        }
+    }
+    return {
+        floatView: floatView,
+        uint32View: uint32View,
+        baseTable: baseTable,
+        shiftTable: shiftTable,
+        mantissaTable: mantissaTable,
+        exponentTable: exponentTable,
+        offsetTable: offsetTable
+    };
+}();
+function encodeF16(val) {
+    val = Math.min(Math.max(val, -65504), 65504);
+    _tables.floatView[0] = val;
+    const f = _tables.uint32View[0];
+    const e = f >> 23 & 0x1ff;
+    return _tables.baseTable[e] + ((f & 0x007fffff) >> _tables.shiftTable[e]);
+}
+/*
+function decodeF16(val: number) {
+  const exponent = (val & 0x7c00) >> 10;
+  const fraction = val & 0x03ff;
+  return (
+    (val >> 15 ? -1 : 1) *
+    (exponent
+      ? exponent === 0x1f
+        ? fraction
+          ? NaN
+          : Infinity
+        : Math.pow(2, exponent - 15) * (1 + fraction / 0x400)
+      : 6.103515625e-5 * (fraction / 0x400))
+  );
+}
+*/ async function createSheenLUT(textureSize, texture) {
+    if (texture) {
+        if (!texture.isTexture2D()) {
+            throw new Error('can not reload sheen lut texture: invalid texture type');
+        }
+        if (texture.format !== 'rgba16f') {
+            throw new Error('can not reload sheen lut texture: invalid texture format');
+        }
+        if (texture.width !== textureSize || texture.height !== textureSize) {
+            throw new Error('can not reload sheen lut texture: invalid texture size');
+        }
+    }
+    const tex = texture || Application.instance.device.createTexture2D('rgba16f', textureSize, textureSize);
+    const image = new Uint16Array(textureSize * textureSize * 4);
+    let p = 0;
+    const one = encodeF16(1);
+    for(let y = textureSize - 1; y >= 0; y--){
+        const coord = Math.min(Math.max((y + 0.5) / textureSize, 0), 1);
+        const roughness = coord * coord;
+        for(let x = 0; x < textureSize; x++){
+            const NdotV = Math.min(Math.max((x + 0.5) / textureSize, 0), 1);
+            const c = dfvCharlieUniform(NdotV, roughness, 512);
+            const f16 = encodeF16(c);
+            image[p++] = 0;
+            image[p++] = 0;
+            image[p++] = f16;
+            image[p++] = one;
+        }
+    }
+    tex.update(image, 0, 0, textureSize, textureSize);
+    return tex;
+}
+
+export { createSheenLUT };
+//# sourceMappingURL=sheenlut.js.map

package/dist/utility/sheenlut.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sheenlut.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/utility/shprojection.js

@@ -1,7 +1,6 @@
 import { Vector3, halfToFloat, unpackFloat3, SH, nextPowerOf2 } from '@zephyr3d/base';
 import { Application } from '../app.js';
 import { Blitter } from '../blitter/blitter.js';
-import '../shaders/framework.js';
 import '@zephyr3d/device';
 import { CopyBlitter } from '../blitter/copy.js';
 

package/dist/utility/shprojection.js.map

@@ -1 +1 @@
-{"version":3,"file":"shprojection.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"shprojection.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/values.js

@@ -1,7 +1,7 @@
 /**
  * Forward render pass type
  * @public
- */ const RENDER_PASS_TYPE_FORWARD = 0;
+ */ const RENDER_PASS_TYPE_LIGHT = 0;
 /**
  * Shadow map render pass type
  * @public
@@ -9,12 +9,7 @@
 /**
  * Depth only render pass type
  * @public
- */ const RENDER_PASS_TYPE_DEPTH_ONLY = 2;
-/**
- * Max light count for forward rendering
- * @internal
- */ const MAX_FORWARD_LIGHT_COUNT = 8;
-/** @internal */ const DEBUG_CASCADED_SHADOW_MAPS = false;
+ */ const RENDER_PASS_TYPE_DEPTH = 2;
 /**
  * Builtin texture name for sheen LUT
  * @public
@@ -43,6 +38,14 @@
  * Max light size for clustered lighting
  * @public
  */ const MAX_CLUSTERED_LIGHTS = 255;
+/**
+ * Opaque render queue type
+ * @public
+ */ const QUEUE_OPAQUE = 1;
+/**
+ * Transparent render queue type
+ * @public
+ */ const QUEUE_TRANSPARENT = 2;
 
-export { BUILTIN_ASSET_TEST_CUBEMAP, BUILTIN_ASSET_TEXTURE_SHEEN_LUT, DEBUG_CASCADED_SHADOW_MAPS, LIGHT_TYPE_DIRECTIONAL, LIGHT_TYPE_NONE, LIGHT_TYPE_POINT, LIGHT_TYPE_SPOT, MAX_CLUSTERED_LIGHTS, MAX_FORWARD_LIGHT_COUNT, RENDER_PASS_TYPE_DEPTH_ONLY, RENDER_PASS_TYPE_FORWARD, RENDER_PASS_TYPE_SHADOWMAP };
+export { BUILTIN_ASSET_TEST_CUBEMAP, BUILTIN_ASSET_TEXTURE_SHEEN_LUT, LIGHT_TYPE_DIRECTIONAL, LIGHT_TYPE_NONE, LIGHT_TYPE_POINT, LIGHT_TYPE_SPOT, MAX_CLUSTERED_LIGHTS, QUEUE_OPAQUE, QUEUE_TRANSPARENT, RENDER_PASS_TYPE_DEPTH, RENDER_PASS_TYPE_LIGHT, RENDER_PASS_TYPE_SHADOWMAP };
 //# sourceMappingURL=values.js.map

package/dist/values.js.map

@@ -1 +1 @@
-{"version":3,"file":"values.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"values.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "@zephyr3d/scene",
-	"version": "0.1.2",
-	"description": "scene system for zephyr3d",
+	"version": "0.3.0",
+	"description": "Scene API for zephyr3d",
 	"homepage": "https://github.com/gavinyork/zephyr3d#readme",
 	"type": "module",
 	"main": "./dist/index.js",
@@ -44,8 +44,8 @@
 		"@rollup/plugin-terser": "^0.4.0",
 		"@rollup/pluginutils": "^5.0.2",
 		"@swc/core": "^1.3.62",
-		"@zephyr3d/base": "^0.1.2",
-		"@zephyr3d/device": "^0.1.2",
+		"@zephyr3d/base": "^0.1.3",
+		"@zephyr3d/device": "^0.2.1",
 		"cross-env": "^7.0.3",
 		"rollup": "^3.15.0",
 		"rollup-plugin-copy": "^3.4.0",
@@ -56,8 +56,8 @@
 		"typescript": "^5.1.3"
 	},
 	"peerDependencies": {
-		"@zephyr3d/base": "^0.1.2",
-		"@zephyr3d/device": "^0.1.2"
+		"@zephyr3d/base": "^0.1.3",
+		"@zephyr3d/device": "^0.2.1"
 	},
 	"dependencies": {
 		"@webgpu/types": "^0.1.31"