@zephyr3d/device 0.2.3 → 0.2.4

package/README.md

@@ -1,4 +1,4 @@
-# @zephyr3d
+# @zephyr3d/device
 
 Zephyr3d is a set of API for 3D rendering within the browser. 
 

package/dist/builder/ast.js

@@ -1275,6 +1275,15 @@ function unbracket(e) {
     /** @internal */ type;
     constructor(condition, first, second){
         super();
+        if (condition instanceof ASTCallFunction) {
+            condition.isStatement = false;
+        }
+        if (first instanceof ASTCallFunction) {
+            first.isStatement = false;
+        }
+        if (second instanceof ASTCallFunction) {
+            second.isStatement = false;
+        }
         this.condition = condition instanceof ASTExpression ? condition : new ASTScalar(condition, typeBool);
         let firstType = null;
         let secondType = null;

package/dist/builder/ast.js.map

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

package/dist/builder/base.js

@@ -188,6 +188,12 @@ let uidExp = 0;
    * @returns self
    */ storage(group) {
         if (!this.$typeinfo.isHostSharable()) {
+            if (this.$typeinfo.isTextureType()) {
+                if (!this.$typeinfo.isStorageTexture()) {
+                    throw new PBASTError(this.$ast, 'type cannot be declared as storage texture');
+                }
+                return this.uniform(group);
+            }
             throw new PBASTError(this.$ast, 'type cannot be declared in storage address space');
         }
         this.$declareType = DeclareType.DECLARE_TYPE_STORAGE;

package/dist/builder/base.js.map

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

package/dist/builder/builtinfunc.js

@@ -2896,15 +2896,28 @@ const builtinFunctionsAll = {
             ])
         ],
         normalizeFunc (pb, name, ...args) {
+            if (args.length === 0) {
+                throw new PBParamLengthError('textureArrayLoad');
+            }
+            const tex = args[0];
+            if (!(tex instanceof PBShaderExp)) {
+                throw new PBParamValueError('textureArrayLoad', 'tex');
+            }
+            const texType = tex.$ast.getType();
+            if (!texType.isTextureType()) {
+                throw new PBParamTypeError('textureArrayLoad', 'tex');
+            }
             if (pb.getDevice().type === 'webgl2') {
                 if (args.length !== 4) {
                     throw new PBParamLengthError('textureArrayLoad');
                 }
-                const tex = args[0];
                 const coords = pb.ivec3(args[1], args[2]);
                 const level = args[3];
                 return callBuiltin(pb, name, tex, coords, level);
             } else {
+                if (texType.isStorageTexture()) {
+                    texType.readable = true;
+                }
                 return callBuiltin(pb, name, ...args);
             }
         }
@@ -3176,101 +3189,113 @@ const builtinFunctionsAll = {
         overloads: [
             ...genType('textureStore', MASK_WEBGPU, typeVoid, [
                 typeTexStorage2DArray_rgba8unorm,
-                typeI32Vec2,
+                typeU32Vec2,
                 typeI32,
                 typeF32Vec4
             ]),
             ...genType('textureStore', MASK_WEBGPU, typeVoid, [
                 typeTexStorage2DArray_rgba8snorm,
-                typeI32Vec2,
+                typeU32Vec2,
                 typeI32,
                 typeF32Vec4
             ]),
             ...genType('textureStore', MASK_WEBGPU, typeVoid, [
                 typeTexStorage2DArray_rgba8uint,
-                typeI32Vec2,
+                typeU32Vec2,
                 typeI32,
                 typeU32Vec4
             ]),
             ...genType('textureStore', MASK_WEBGPU, typeVoid, [
                 typeTexStorage2DArray_rgba8sint,
-                typeI32Vec2,
+                typeU32Vec2,
                 typeI32,
                 typeI32Vec4
             ]),
             ...genType('textureStore', MASK_WEBGPU, typeVoid, [
                 typeTexStorage2DArray_rgba16uint,
-                typeI32Vec2,
+                typeU32Vec2,
                 typeI32,
                 typeU32Vec4
             ]),
             ...genType('textureStore', MASK_WEBGPU, typeVoid, [
                 typeTexStorage2DArray_rgba16sint,
-                typeI32Vec2,
+                typeU32Vec2,
                 typeI32,
                 typeI32Vec4
             ]),
             ...genType('textureStore', MASK_WEBGPU, typeVoid, [
                 typeTexStorage2DArray_rgba16float,
-                typeI32Vec2,
+                typeU32Vec2,
                 typeI32,
                 typeF32Vec4
             ]),
             ...genType('textureStore', MASK_WEBGPU, typeVoid, [
                 typeTexStorage2DArray_rgba32uint,
-                typeI32Vec2,
+                typeU32Vec2,
                 typeI32,
                 typeU32Vec4
             ]),
             ...genType('textureStore', MASK_WEBGPU, typeVoid, [
                 typeTexStorage2DArray_rgba32sint,
-                typeI32Vec2,
+                typeU32Vec2,
                 typeI32,
                 typeI32Vec4
             ]),
             ...genType('textureStore', MASK_WEBGPU, typeVoid, [
                 typeTexStorage2DArray_rgba32float,
-                typeI32Vec2,
+                typeU32Vec2,
                 typeI32,
                 typeF32Vec4
             ]),
             ...genType('textureStore', MASK_WEBGPU, typeVoid, [
                 typeTexStorage2DArray_rg32uint,
-                typeI32Vec2,
+                typeU32Vec2,
                 typeI32,
                 typeU32Vec4
             ]),
             ...genType('textureStore', MASK_WEBGPU, typeVoid, [
                 typeTexStorage2DArray_rg32sint,
-                typeI32Vec2,
+                typeU32Vec2,
                 typeI32,
                 typeI32Vec4
             ]),
             ...genType('textureStore', MASK_WEBGPU, typeVoid, [
                 typeTexStorage2DArray_rg32float,
-                typeI32Vec2,
+                typeU32Vec2,
                 typeI32,
                 typeF32Vec4
             ]),
             ...genType('textureStore', MASK_WEBGPU, typeVoid, [
                 typeTexStorage2DArray_r32uint,
-                typeI32Vec2,
+                typeU32Vec2,
                 typeI32,
                 typeU32Vec4
             ]),
             ...genType('textureStore', MASK_WEBGPU, typeVoid, [
                 typeTexStorage2DArray_r32sint,
-                typeI32Vec2,
+                typeU32Vec2,
                 typeI32,
                 typeI32Vec4
             ]),
             ...genType('textureStore', MASK_WEBGPU, typeVoid, [
                 typeTexStorage2DArray_r32float,
-                typeI32Vec2,
+                typeU32Vec2,
                 typeI32,
                 typeF32Vec4
             ])
-        ]
+        ],
+        normalizeFunc (pb, name, ...args) {
+            if (pb.getDevice().type === 'webgpu') {
+                const tex = args[0];
+                if (tex instanceof PBShaderExp) {
+                    const texType = tex.$ast.getType();
+                    if (texType?.isTextureType() && texType.isStorageTexture()) {
+                        texType.writable = true;
+                    }
+                }
+            }
+            return callBuiltin(pb, name, ...args);
+        }
     },
     // textureNumLayers(tex: PBShaderExp);
     textureNumLayers: {

package/dist/builder/builtinfunc.js.map

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

package/dist/builder/programbuilder.js

@@ -1353,9 +1353,21 @@ const output_prefix_fs = 'zFSOutput_';
                     throw new Error('internal error');
                 }
                 if (entry.type.isStorageTexture()) {
+                    let viewDimension;
+                    if (entry.type.isArrayTexture()) {
+                        viewDimension = entry.type.isCubeTexture() ? 'cube-array' : '2d-array';
+                    } else if (entry.type.is3DTexture()) {
+                        viewDimension = '3d';
+                    } else if (entry.type.isCubeTexture()) {
+                        viewDimension = 'cube';
+                    } else if (entry.type.is1DTexture()) {
+                        viewDimension = '1d';
+                    } else {
+                        viewDimension = '2d';
+                    }
                     entry.storageTexture = {
                         access: 'write-only',
-                        viewDimension: entry.type.is1DTexture() ? '1d' : '2d',
+                        viewDimension: viewDimension,
                         format: entry.type.storageTexelFormat
                     };
                 } else if (entry.type.isExternalTexture()) {
@@ -2188,7 +2200,13 @@ const output_prefix_fs = 'zFSOutput_';
                         ] : args).map((val)=>pb.normalizeExpValue(val));
                         const funcType = pb._getFunctionOverload(name, argsNonArray);
                         if (!funcType) {
-                            throw new Error(`ERROR: no matching overloads for function ${name}`);
+                            throw new Error(`ERROR: no matching overloads for function ${name}(${argsNonArray.map((val)=>{
+                                if (val instanceof PBShaderExp) {
+                                    return val.$ast?.getType()?.toTypeName() ?? '?';
+                                } else {
+                                    return typeof val;
+                                }
+                            }).join(', ')})`);
                         }
                         return getCurrentProgramBuilder().$callFunction(name, funcType[1], funcType[0]);
                     };

package/dist/builder/programbuilder.js.map

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

package/dist/builder/types.js

@@ -462,7 +462,7 @@ var PBTypeClass;
     /** {@inheritDoc PBTypeInfo.isVoidType} */ isVoidType() {
         return true;
     }
-    /** @internal */ toTypeName(deviceType, varName) {
+    /** @internal */ toTypeName() {
         return 'void';
     }
     /** @internal */ genTypeId() {
@@ -482,7 +482,7 @@ var PBTypeClass;
     /** {@inheritDoc PBTypeInfo.isAnyType} */ isAnyType() {
         return true;
     }
-    /** @internal */ toTypeName(deviceType, varName) {
+    /** @internal */ toTypeName() {
         return 'any';
     }
     /** @internal */ genTypeId() {
@@ -1337,7 +1337,7 @@ var PBTypeClass;
         return null;
     }
     /** @internal */ genTypeId() {
-        return `TEXTURE:${this.textureType}`;
+        return `TEXTURE:${this.textureType}:${this.textureType & BITFLAG_STORAGE ? this.storageTexelFormat : ''}`;
     }
 }
 /**
@@ -1369,7 +1369,7 @@ var PBTypeClass;
     /** {@inheritDoc PBTypeInfo.toBufferLayout} */ toBufferLayout(offset) {
         return null;
     }
-    /** @internal */ toTypeName(deviceType, varName) {
+    /** @internal */ toTypeName() {
         throw new Error('not supported');
     }
 }

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import { TypedArray, IEventTarget, CubeFace, VectorBase, Vector4 } from '@zephyr3d/base';
+import { TypedArray, IEventTarget, CubeFace, VectorBase, MaybeArray, Vector4 } from '@zephyr3d/base';
 
 /**
  * Struct layout types
@@ -909,7 +909,7 @@ interface StorageTextureBindingLayout {
     /** The texture format */
     format: TextureFormat;
     /** View dimension */
-    viewDimension: '1d' | '2d';
+    viewDimension: '1d' | '2d' | '2d-array' | 'cube' | 'cube-array' | '3d';
 }
 /**
  * Binding layout of an external texture
@@ -1156,11 +1156,17 @@ interface FrameBuffer<T = unknown> extends GPUObject<T> {
     getSampleCount(): number;
     getHash(): string;
     setColorAttachmentCubeFace(index: number, face: CubeFace): void;
+    getColorAttachmentCubeFace(index: number): CubeFace;
     setColorAttachmentMipLevel(index: number, level: number): void;
+    getColorAttachmentMipLevel(index: number): number;
     setColorAttachmentLayer(index: number, layer: number): void;
+    getColorAttachmentLayer(index: number): number;
     setColorAttachmentGenerateMipmaps(index: number, generateMipmaps: boolean): void;
+    getColorAttachmentGenerateMipmaps(index: number): boolean;
     setDepthAttachmentCubeFace(face: CubeFace): void;
+    getDepthAttachmentCubeFace(): CubeFace;
     setDepthAttachmentLayer(layer: number): void;
+    getDepthAttachmentLayer(): number;
     getColorAttachments(): BaseTexture[];
     getDepthAttachment(): BaseTexture;
     bind(): boolean;
@@ -2729,7 +2735,7 @@ declare class Pool {
      * @param mipmapping - Whether this texture support mipmapping
      * @returns The fetched Texture2D object.
      */
-    fetchTemporalTexture2D(autoRelease: boolean, format: TextureFormat, width: number, height: number, mipmapping: boolean): Texture2D;
+    fetchTemporalTexture2D(autoRelease: boolean, format: TextureFormat, width: number, height: number, mipmapping?: boolean): Texture2D;
     /**
      * Fetch a temporal 2D array texture from the object pool.
      * @param autoRelease - Whether the texture should be automatically released at the next frame.
@@ -2740,7 +2746,7 @@ declare class Pool {
      * @param mipmapping - Whether this texture support mipmapping
      * @returns The fetched Texture2DArray object.
      */
-    fetchTemporalTexture2DArray(autoRelease: boolean, format: TextureFormat, width: number, height: number, numLayers: number, mipmapping: boolean): Texture2DArray;
+    fetchTemporalTexture2DArray(autoRelease: boolean, format: TextureFormat, width: number, height: number, numLayers: number, mipmapping?: boolean): Texture2DArray;
     /**
      * Fetch a temporal Cube texture from the object pool.
      * @param autoRelease - Whether the texture should be automatically released at the next frame.
@@ -2749,67 +2755,36 @@ declare class Pool {
      * @param mipmapping - Whether this texture support mipmapping
      * @returns The fetched TextureCube object.
      */
-    fetchTemporalTextureCube(autoRelease: boolean, format: TextureFormat, size: number, mipmapping: boolean): TextureCube;
-    /**
-     * Fetch a temporal framebuffer from the object pool.
-     * @param autoRelease - Whether the framebuffer should be automatically released at the next frame.
-     * @param colorFormat - Texture format for color attachment.
-     * @param depthFormat - Texture format for depth attachment.
-     * @param sampleCount - The sample count for the framebuffer.
-     * @param ignoreDepthStencil - Whether to ignore depth stencil.
-     * @returns The fetched FrameBuffer object.
-     */
-    fetchTemporalFramebuffer(autoRelease: boolean, width: number, height: number, colorFormat: TextureFormat, depthFormat?: TextureFormat, mipmapping?: boolean, sampleCount?: number, ignoreDepthStencil?: boolean): FrameBuffer;
-    /**
-     * Fetch a temporal framebuffer from the object pool.
-     * @param autoRelease - Whether the framebuffer should be automatically released at the next frame.
-     * @param colorFormat - Texture format for color attachment.
-     * @param depthTex - depth attachment.
-     * @param sampleCount - The sample count for the framebuffer.
-     * @param ignoreDepthStencil - Whether to ignore depth stencil.
-     * @returns The fetched FrameBuffer object.
-     */
-    fetchTemporalFramebuffer<T extends BaseTexture<unknown>>(autoRelease: boolean, width: number, height: number, colorFormat: TextureFormat, depthTex?: T, mipmapping?: boolean, sampleCount?: number, ignoreDepthStencil?: boolean): FrameBuffer;
-    /**
-     * Fetch a temporal framebuffer from the object pool.
-     * @param autoRelease - Whether the framebuffer should be automatically released at the next frame.
-     * @param colorTex - color attachment.
-     * @param depthFormat - Texture format for depth attachment.
-     * @param sampleCount - The sample count for the framebuffer.
-     * @param ignoreDepthStencil - Whether to ignore depth stencil.
-     * @returns The fetched FrameBuffer object.
-     */
-    fetchTemporalFramebuffer<T extends BaseTexture<unknown>>(autoRelease: boolean, width: number, height: number, colorTex: T, depthFormat?: TextureFormat, mipmapping?: boolean, sampleCount?: number, ignoreDepthStencil?: boolean): FrameBuffer;
-    /**
-     * Fetch a temporal framebuffer from the object pool.
-     * @param autoRelease - Whether the framebuffer should be automatically released at the next frame.
-     * @param colorTex - color attachment.
-     * @param depthTex - depth attachment.
-     * @param sampleCount - The sample count for the framebuffer.
-     * @param ignoreDepthStencil - Whether to ignore depth stencil.
-     * @returns The fetched FrameBuffer object.
-     */
-    fetchTemporalFramebuffer<T extends BaseTexture<unknown>>(autoRelease: boolean, width: number, height: number, colorTex: T, depthTex?: T, mipmapping?: boolean, sampleCount?: number, ignoreDepthStencil?: boolean): FrameBuffer;
+    fetchTemporalTextureCube(autoRelease: boolean, format: TextureFormat, size: number, mipmapping?: boolean): TextureCube;
     /**
-     * Fetch a temporal framebuffer from the object pool.
+     * Creates a temporal framebuffer from the object pool.
      * @param autoRelease - Whether the framebuffer should be automatically released at the next frame.
-     * @param colorTexOrFormat - color attachment or texture format.
-     * @param depthTexOrFormat - depth attachment or texture format.
-     * @param sampleCount - The sample count for the framebuffer.
-     * @param ignoreDepthStencil - Whether to ignore depth stencil.
+     * @param width - Width of the framebuffer
+     * @param height - Height of the framebuffer
+     * @param colorAttachments - Array of color attachments or texture format of the framebuffer.
+     * @param depthAttachment - Depth attachment or texture format of the framebuffer.
+     * @param mipmapping - Whether mipmapping should be enabled when creating color attachment textures, default is false.
+     * @param sampleCount - The sample count for the framebuffer, default is 1.
+     * @param ignoreDepthStencil - Whether to ignore depth stencil when resolving msaa framebuffer, default is true.
+     * @param attachmentMipLevel - The mipmap level to which the color attachment will render, default is 0
+     * @param attachmentCubeface - The cubemap face to which the color attachment will render, default is 0
+     * @param attachmentLayer - The texture layer to which the color attachment will render, default is 0
      * @returns The fetched FrameBuffer object.
      */
-    fetchTemporalFramebuffer<T extends BaseTexture<unknown>>(autoRelease: boolean, width: number, height: number, colorTexOrFormat: TextureFormat | T, depthTexOrFormat?: TextureFormat | T, mipmapping?: boolean, sampleCount?: number, ignoreDepthStencil?: boolean): FrameBuffer;
+    fetchTemporalFramebuffer<T extends BaseTexture<unknown>>(autoRelease: boolean, width: number, height: number, colorTexOrFormat: MaybeArray<TextureFormat | T>, depthTexOrFormat?: TextureFormat | T, mipmapping?: boolean, sampleCount?: number, ignoreDepthStencil?: boolean, attachmentMipLevel?: number, attachmentCubeface?: number, attachmentLayer?: number): FrameBuffer;
     /**
      * Creates a temporal framebuffer from the object pool.
      * @param autoRelease - Whether the framebuffer should be automatically released at the next frame.
      * @param colorAttachments - Array of color attachments for the framebuffer.
      * @param depthAttachment - Depth attachment for the framebuffer.
-     * @param sampleCount - The sample count for the framebuffer.
-     * @param ignoreDepthStencil - Whether to ignore depth stencil.
+     * @param sampleCount - The sample count for the framebuffer, default is 1.
+     * @param ignoreDepthStencil - Whether to ignore depth stencil when resolving msaa framebuffer, default is true.
+     * @param attachmentMipLevel - The mipmap level to which the color attachment will render, default is 0.
+     * @param attachmentCubeface - The cubemap face to which the color attachment will render, default is 0.
+     * @param attachmentLayer - The texture layer to which the color attachment will render, default is 0.
      * @returns The fetched FrameBuffer object.
      */
-    createTemporalFramebuffer(autoRelease: boolean, colorAttachments: BaseTexture[], depthAttachment?: BaseTexture, sampleCount?: number, ignoreDepthStencil?: boolean): FrameBuffer<unknown>;
+    createTemporalFramebuffer(autoRelease: boolean, colorAttachments: BaseTexture[], depthAttachment?: BaseTexture, sampleCount?: number, ignoreDepthStencil?: boolean, attachmentMipLevel?: number, attachmentCubeface?: number, attachmentLayer?: number): FrameBuffer<unknown>;
     /**
      * Dispose a texture that is allocated from the object pool.
      * @param texture - The texture to dispose.
@@ -3367,6 +3342,16 @@ interface AbstractDevice extends IEventTarget<DeviceEventMap> {
     clearFrameBuffer(clearColor: Vector4, clearDepth: number, clearStencil: number): any;
     /** Creates a render state set object */
     createRenderStateSet(): RenderStateSet;
+    /** Creates a blending state object */
+    createBlendingState(): BlendingState;
+    /** Creates a color state object */
+    createColorState(): ColorState;
+    /** Creates a rasterizer state object */
+    createRasterizerState(): RasterizerState;
+    /** Creates a depth state object */
+    createDepthState(): DepthState;
+    /** Creates a stencil state object */
+    createStencilState(): StencilState;
     /**
      * Creates a texture sampler object
      * @param options - The creation options
@@ -3449,6 +3434,30 @@ interface AbstractDevice extends IEventTarget<DeviceEventMap> {
      * @param el - The video element
      */
     createTextureVideo(el: HTMLVideoElement, samplerOptions?: SamplerOptions): TextureVideo;
+    /**
+     * Copies a 2d texture to another texture.
+     *
+     * @remarks
+     * The two textures must have the same size and format
+     *
+     * @param src - Texture that will be copied from.
+     * @param srcLevel - Which mipmap level to be copied from.
+     * @param dst - Texture that will be copied to.
+     * @param dstLevel - Which mipmap level to be copied to.
+     */
+    copyTexture2D(src: Texture2D, srcLevel: number, dst: Texture2D, dstLevel: number): any;
+    /**
+     * Copies a color attachment of a framebuffer to a mipmap level of a texture.
+     *
+     * @remarks
+     * The color attachment and the mipmap level must have the same size and format
+     *
+     * @param src - Framebuffer that will be copied from.
+     * @param index - Color attachment index of the framebuffer.
+     * @param dst - Texture that will be copied to.
+     * @param level - Which mipmap level should be copied to.
+     */
+    copyFramebufferToTexture2D(src: FrameBuffer, index: number, dst: Texture2D, level: number): any;
     /**
      * Set wether to reverse the winding order
      *
@@ -3838,6 +3847,11 @@ declare abstract class BaseDevice {
     abstract clearFrameBuffer(clearColor: Vector4, clearDepth: number, clearStencil: number): any;
     abstract createGPUTimer(): ITimer;
     abstract createRenderStateSet(): RenderStateSet;
+    abstract createBlendingState(): BlendingState;
+    abstract createColorState(): ColorState;
+    abstract createRasterizerState(): RasterizerState;
+    abstract createDepthState(): DepthState;
+    abstract createStencilState(): StencilState;
     abstract createSampler(options: SamplerOptions): TextureSampler;
     abstract createTextureFromMipmapData<T extends BaseTexture>(data: TextureMipmapData, sRGB: boolean, options?: TextureCreationOptions): T;
     abstract createTexture2D(format: TextureFormat, width: number, height: number, options?: TextureCreationOptions): Texture2D;
@@ -3852,6 +3866,8 @@ declare abstract class BaseDevice {
     abstract createTextureVideo(el: HTMLVideoElement, samplerOptions?: SamplerOptions): TextureVideo;
     abstract reverseVertexWindingOrder(reverse: boolean): void;
     abstract isWindingOrderReversed(): boolean;
+    abstract copyTexture2D(src: Texture2D, srcLevel: number, dst: Texture2D, dstLevel: number): any;
+    abstract copyFramebufferToTexture2D(src: FrameBuffer, index: number, dst: Texture2D, level: number): any;
     abstract createGPUProgram(params: GPUProgramConstructParams): GPUProgram;
     abstract createBindGroup(layout: BindGroupLayout): BindGroup;
     abstract createBuffer(sizeInBytes: number, options: BufferCreationOptions): GPUDataBuffer;

package/dist/pool.js

@@ -49,7 +49,7 @@
    * @param height - The height of the texture.
    * @param mipmapping - Whether this texture support mipmapping
    * @returns The fetched Texture2D object.
-   */ fetchTemporalTexture2D(autoRelease, format, width, height, mipmapping) {
+   */ fetchTemporalTexture2D(autoRelease, format, width, height, mipmapping = false) {
         const hash = `2d:${format}:${width}:${height}:${mipmapping ? 1 : 0}`;
         let texture = null;
         const list = this._freeTextures[hash];
@@ -63,7 +63,7 @@
         } else {
             texture = list.pop();
             if (list.length === 0) {
-                delete this._freeTextures[hash];
+                this._freeTextures[hash] = undefined;
             }
         }
         this._allocatedTextures.set(texture, {
@@ -85,7 +85,7 @@
    * @param numLayers - Layer count of the texture
    * @param mipmapping - Whether this texture support mipmapping
    * @returns The fetched Texture2DArray object.
-   */ fetchTemporalTexture2DArray(autoRelease, format, width, height, numLayers, mipmapping) {
+   */ fetchTemporalTexture2DArray(autoRelease, format, width, height, numLayers, mipmapping = false) {
         const hash = `2darray:${format}:${width}:${height}:${numLayers}:${mipmapping ? 1 : 0}`;
         let texture = null;
         const list = this._freeTextures[hash];
@@ -99,7 +99,7 @@
         } else {
             texture = list.pop();
             if (list.length === 0) {
-                delete this._freeTextures[hash];
+                this._freeTextures[hash] = undefined;
             }
         }
         this._allocatedTextures.set(texture, {
@@ -119,7 +119,7 @@
    * @param size - size of the texture.
    * @param mipmapping - Whether this texture support mipmapping
    * @returns The fetched TextureCube object.
-   */ fetchTemporalTextureCube(autoRelease, format, size, mipmapping) {
+   */ fetchTemporalTextureCube(autoRelease, format, size, mipmapping = false) {
         const hash = `cube:${format}:${size}:${mipmapping ? 1 : 0}`;
         let texture = null;
         const list = this._freeTextures[hash];
@@ -133,7 +133,7 @@
         } else {
             texture = list.pop();
             if (list.length === 0) {
-                delete this._freeTextures[hash];
+                this._freeTextures[hash] = undefined;
             }
         }
         this._allocatedTextures.set(texture, {
@@ -146,16 +146,33 @@
         }
         return texture;
     }
-    fetchTemporalFramebuffer(autoRelease, width, height, colorTexOrFormat, depthTexOrFormat, mipmapping, sampleCount, ignoreDepthStencil) {
-        const colorAttachments = typeof colorTexOrFormat === 'string' ? [
-            this.fetchTemporalTexture2D(false, colorTexOrFormat, width, height, mipmapping)
-        ] : colorTexOrFormat ? [
+    /**
+   * Creates a temporal framebuffer from the object pool.
+   * @param autoRelease - Whether the framebuffer should be automatically released at the next frame.
+   * @param width - Width of the framebuffer
+   * @param height - Height of the framebuffer
+   * @param colorAttachments - Array of color attachments or texture format of the framebuffer.
+   * @param depthAttachment - Depth attachment or texture format of the framebuffer.
+   * @param mipmapping - Whether mipmapping should be enabled when creating color attachment textures, default is false.
+   * @param sampleCount - The sample count for the framebuffer, default is 1.
+   * @param ignoreDepthStencil - Whether to ignore depth stencil when resolving msaa framebuffer, default is true.
+   * @param attachmentMipLevel - The mipmap level to which the color attachment will render, default is 0
+   * @param attachmentCubeface - The cubemap face to which the color attachment will render, default is 0
+   * @param attachmentLayer - The texture layer to which the color attachment will render, default is 0
+   * @returns The fetched FrameBuffer object.
+   */ fetchTemporalFramebuffer(autoRelease, width, height, colorTexOrFormat, depthTexOrFormat = null, mipmapping = false, sampleCount = 1, ignoreDepthStencil = true, attachmentMipLevel = 0, attachmentCubeface = 0, attachmentLayer = 0) {
+        const colors = Array.isArray(colorTexOrFormat) ? colorTexOrFormat : colorTexOrFormat ? [
             colorTexOrFormat
-        ] : null;
+        ] : [];
+        const colorAttachments = colors.map((val)=>{
+            return typeof val === 'string' ? this.fetchTemporalTexture2D(false, val, width, height, mipmapping) : val;
+        });
         const depthAttachment = typeof depthTexOrFormat === 'string' ? this.fetchTemporalTexture2D(false, depthTexOrFormat, width, height, false) : depthTexOrFormat;
-        const fb = this.createTemporalFramebuffer(autoRelease, colorAttachments, depthAttachment, sampleCount, ignoreDepthStencil);
-        if (typeof colorTexOrFormat === 'string') {
-            this.releaseTexture(colorAttachments[0]);
+        const fb = this.createTemporalFramebuffer(autoRelease, colorAttachments, depthAttachment, sampleCount, ignoreDepthStencil, attachmentMipLevel, attachmentCubeface, attachmentLayer);
+        for(let i = 0; i < colors.length; i++){
+            if (typeof colors[i] === 'string') {
+                this.releaseTexture(colorAttachments[i]);
+            }
         }
         if (typeof depthTexOrFormat === 'string') {
             this.releaseTexture(depthAttachment);
@@ -167,14 +184,20 @@
    * @param autoRelease - Whether the framebuffer should be automatically released at the next frame.
    * @param colorAttachments - Array of color attachments for the framebuffer.
    * @param depthAttachment - Depth attachment for the framebuffer.
-   * @param sampleCount - The sample count for the framebuffer.
-   * @param ignoreDepthStencil - Whether to ignore depth stencil.
+   * @param sampleCount - The sample count for the framebuffer, default is 1.
+   * @param ignoreDepthStencil - Whether to ignore depth stencil when resolving msaa framebuffer, default is true.
+   * @param attachmentMipLevel - The mipmap level to which the color attachment will render, default is 0.
+   * @param attachmentCubeface - The cubemap face to which the color attachment will render, default is 0.
+   * @param attachmentLayer - The texture layer to which the color attachment will render, default is 0.
    * @returns The fetched FrameBuffer object.
-   */ createTemporalFramebuffer(autoRelease, colorAttachments, depthAttachment, sampleCount, ignoreDepthStencil) {
+   */ createTemporalFramebuffer(autoRelease, colorAttachments, depthAttachment = null, sampleCount = 1, ignoreDepthStencil = true, attachmentMipLevel = 0, attachmentCubeface = 0, attachmentLayer = 0) {
         colorAttachments = colorAttachments ?? [];
         let hash = `${depthAttachment?.uid ?? 0}:${sampleCount ?? 1}:${ignoreDepthStencil ? 1 : 0}`;
-        for (const tex of colorAttachments){
-            hash += `:${tex.uid}`;
+        if (colorAttachments.length > 0) {
+            hash += `:${attachmentMipLevel}:${attachmentCubeface}:${attachmentLayer}`;
+            for (const tex of colorAttachments){
+                hash += `:${tex.uid}`;
+            }
         }
         let fb = null;
         const list = this._freeFramebuffers[hash];
@@ -183,10 +206,15 @@
                 ignoreDepthStencil,
                 sampleCount
             });
+            for(let i = 0; i < fb.getColorAttachments().length; i++){
+                fb.setColorAttachmentMipLevel(i, attachmentMipLevel);
+                fb.setColorAttachmentCubeFace(i, attachmentCubeface);
+                fb.setColorAttachmentLayer(i, attachmentLayer);
+            }
         } else {
             fb = list.pop();
             if (list.length === 0) {
-                delete this._freeFramebuffers[hash];
+                this._freeFramebuffers[hash] = undefined;
             }
         }
         // Mark referenced textures

package/dist/pool.js.map

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

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@zephyr3d/device",
-	"version": "0.2.3",
+	"version": "0.2.4",
 	"description": "Device API for zephyr3d",
 	"homepage": "https://github.com/gavinyork/zephyr3d#readme",
 	"type": "module",
@@ -44,7 +44,6 @@
 		"@rollup/plugin-terser": "^0.4.0",
 		"@rollup/pluginutils": "^5.0.2",
 		"@swc/core": "^1.3.62",
-		"@zephyr3d/base": "^0.1.4",
 		"cross-env": "^7.0.3",
 		"rollup": "^3.15.0",
 		"rollup-plugin-copy": "^3.4.0",
@@ -54,12 +53,10 @@
 		"shx": "^0.3.4",
 		"typescript": "^5.1.3"
 	},
-	"peerDependencies": {
-		"@zephyr3d/base": "^0.1.4"
-	},
 	"dependencies": {
-		"@types/node": "^18.13.0",
-		"@webgpu/types": "^0.1.40"
+		"@zephyr3d/base": "^0.1.5",
+		"@webgpu/types": "^0.1.40",
+		"@types/node": "^18.13.0"
 	},
 	"scripts": {
 		"clean": "shx rm -rf ./dist .tsbuildinfo",