@zephyr3d/device 0.2.1 → 0.2.2

package/dist/builder/ast.js

@@ -532,7 +532,7 @@ function unbracket(e) {
     }
     isWritable() {
         const type = this.getType();
-        return this.writable || type.isAtomicI32() || type.isAtomicU32() || type.isStructType() && type.isWritable();
+        return this.writable || type.isAtomicI32() || type.isAtomicU32() || type.isStructType() && type.haveAtomicMembers();
     }
     getAddressSpace() {
         switch(this.value.$declareType){
@@ -1759,13 +1759,11 @@ function unbracket(e) {
                 // prefix = `@location(${this.value.value.$location}) var<out> `;
                 throw new Error(`Internal error`);
             case DeclareType.DECLARE_TYPE_UNIFORM:
-                if (this.group === undefined) {
-                    debugger;
-                }
                 prefix = `@group(${this.group}) @binding(${this.binding}) var${isBlock ? '<uniform>' : ''} `;
                 break;
             case DeclareType.DECLARE_TYPE_STORAGE:
-                prefix = `@group(${this.group}) @binding(${this.binding}) var<storage, ${this.value.isWritable() ? 'read_write' : 'read'}> `;
+                prefix = `@group(${this.group}) @binding(${this.binding}) var<storage, ${this.value.value.$readonly ? 'read' : 'read_write' //this.value.isWritable() || this.value.getType().haveAtomicMembers() ? 'read_write' : 'read'
+                }> `;
                 break;
             case DeclareType.DECLARE_TYPE_WORKGROUP:
                 prefix = `var<workgroup> `;

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

@@ -23,7 +23,7 @@ const constructorCache = new Map();
             }
             let ctor = entries[prop];
             if (!ctor) {
-                if (elementType.isPrimitiveType() || elementType.isStructType() || elementType.isArrayType()) {
+                if (elementType.isPrimitiveType() || elementType.isStructType() || elementType.isArrayType() || elementType.isAtomicI32() || elementType.isAtomicU32()) {
                     if (prop === 'ptr') {
                         const pointerType = new PBPointerTypeInfo(elementType, PBAddressSpace.FUNCTION);
                         ctor = function pointerCtor(...args) {
@@ -99,6 +99,8 @@ let uidExp = 0;
     /** @internal */ $_group;
     /** @internal */ $declareType;
     /** @internal */ $isBuffer;
+    /** @internal */ $readonly;
+    /** @internal */ $bindingSize;
     /** @internal */ constructor(str, typeInfo){
         super();
         if (!str && typeInfo.isPointerType()) {
@@ -119,6 +121,8 @@ let uidExp = 0;
         this.$_group = null;
         this.$declareType = DeclareType.DECLARE_TYPE_NONE;
         this.$isBuffer = false;
+        this.$bindingSize = 0;
+        this.$readonly = false;
         if (typeInfo.isTextureType()) {
             if (typeInfo.isDepthTexture()) {
                 this.$sampleType = 'depth';
@@ -157,13 +161,14 @@ let uidExp = 0;
    * Point out that the variable should be an uniform buffer
    * @param group - The bind group index
    * @returns self
-   */ uniformBuffer(group) {
+   */ uniformBuffer(group, bindingSize = 0) {
         if (!this.$typeinfo.isPrimitiveType() && !this.$typeinfo.isArrayType() && !this.$typeinfo.isStructType()) {
             throw new PBASTError(this.$ast, 'only primitive type, array type or structure type can be set as uniform buffer');
         }
         this.$declareType = DeclareType.DECLARE_TYPE_UNIFORM;
         this.$group = group;
         this.$isBuffer = true;
+        this.$bindingSize = bindingSize;
         return this;
     }
     /**
@@ -188,19 +193,40 @@ let uidExp = 0;
         this.$declareType = DeclareType.DECLARE_TYPE_STORAGE;
         this.$group = group;
         this.$isBuffer = false;
+        this.$readonly = false;
+        return this;
+    }
+    /**
+   * Point out that the variable is read-only and should be in storage address space
+   * @param group - The bind group index
+   * @returns self
+   */ storageReadonly(group) {
+        this.storage(group);
+        this.$readonly = true;
         return this;
     }
     /**
    * Point out that the variable should be a storage buffer
    * @param group - The bind group index
    * @returns self
-   */ storageBuffer(group) {
-        if (!this.$typeinfo.isPrimitiveType() && !this.$typeinfo.isArrayType() && !this.$typeinfo.isStructType()) {
+   */ storageBuffer(group, bindingSize = 0) {
+        if (!this.$typeinfo.isPrimitiveType() && !this.$typeinfo.isArrayType() && !this.$typeinfo.isStructType() && !this.$typeinfo.isAtomicI32() && !this.$typeinfo.isAtomicU32()) {
             throw new PBASTError(this.$ast, 'only primitive type, array type or structure type can be set as storage buffer');
         }
         this.$declareType = DeclareType.DECLARE_TYPE_STORAGE;
         this.$group = group;
         this.$isBuffer = true;
+        this.$bindingSize = bindingSize;
+        this.$readonly = false;
+        return this;
+    }
+    /**
+   * Point out that the variable is read-only and should be a storage buffer
+   * @param group - The bind group index
+   * @returns self
+   */ storageBufferReadonly(group, bindingSize = 0) {
+        this.storageBuffer(group, bindingSize);
+        this.$readonly = true;
         return this;
     }
     inout() {

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

@@ -1,5 +1,5 @@
-import { PBPrimitiveType, typeU32, typeF32, typeAtomicI32, typeI32, typeAtomicU32, typeVoid, PBFunctionTypeInfo, typeF32Vec2, typeF32Vec3, typeF32Vec4, typeI32Vec2, typeI32Vec3, typeI32Vec4, typeU32Vec2, typeU32Vec3, typeU32Vec4, typeMat2, typeMat3x2, typeMat4x2, typeMat2x3, typeMat3, typeMat4x3, typeMat2x4, typeMat3x4, typeMat4, typeFrexpResult, typeFrexpResultVec2, typeFrexpResultVec3, typeFrexpResultVec4, typeBool, typeTex1D, typeITex1D, typeUTex1D, typeTex2D, typeITex2D, typeUTex2D, typeTex2DArray, typeITex2DArray, typeUTex2DArray, typeTex3D, typeITex3D, typeUTex3D, typeTexCube, typeITexCube, typeUTexCube, typeTexCubeArray, typeITexCubeArray, typeUTexCubeArray, typeTexMultisampled2D, typeITexMultisampled2D, typeUTexMultisampled2D, typeTexDepth2D, typeTexDepth2DArray, typeTexDepthCube, typeTexDepthCubeArray, typeTexDepthMultisampled2D, typeTexStorage1D_rgba8unorm, typeTexStorage1D_rgba8snorm, typeTexStorage1D_rgba8uint, typeTexStorage1D_rgba8sint, typeTexStorage1D_rgba16uint, typeTexStorage1D_rgba16sint, typeTexStorage1D_rgba16float, typeTexStorage1D_rgba32uint, typeTexStorage1D_rgba32sint, typeTexStorage1D_rgba32float, typeTexStorage1D_rg32uint, typeTexStorage1D_rg32sint, typeTexStorage1D_rg32float, typeTexStorage1D_r32uint, typeTexStorage1D_r32sint, typeTexStorage1D_r32float, typeTexStorage2D_rgba8unorm, typeTexStorage2D_rgba8snorm, typeTexStorage2D_rgba8uint, typeTexStorage2D_rgba8sint, typeTexStorage2D_rgba16uint, typeTexStorage2D_rgba16sint, typeTexStorage2D_rgba16float, typeTexStorage2D_rgba32uint, typeTexStorage2D_rgba32sint, typeTexStorage2D_rgba32float, typeTexStorage2D_rg32uint, typeTexStorage2D_rg32sint, typeTexStorage2D_rg32float, typeTexStorage2D_r32uint, typeTexStorage2D_r32sint, typeTexStorage2D_r32float, typeTexStorage2DArray_rgba8unorm, typeTexStorage2DArray_rgba8snorm, typeTexStorage2DArray_rgba8uint, typeTexStorage2DArray_rgba8sint, typeTexStorage2DArray_rgba16uint, typeTexStorage2DArray_rgba16sint, typeTexStorage2DArray_rgba16float, typeTexStorage2DArray_rgba32uint, typeTexStorage2DArray_rgba32sint, typeTexStorage2DArray_rgba32float, typeTexStorage2DArray_rg32uint, typeTexStorage2DArray_rg32sint, typeTexStorage2DArray_rg32float, typeTexStorage2DArray_r32uint, typeTexStorage2DArray_r32sint, typeTexStorage2DArray_r32float, typeTexStorage3D_rgba8unorm, typeTexStorage3D_rgba8snorm, typeTexStorage3D_rgba8uint, typeTexStorage3D_rgba8sint, typeTexStorage3D_rgba16uint, typeTexStorage3D_rgba16sint, typeTexStorage3D_rgba16float, typeTexStorage3D_rgba32uint, typeTexStorage3D_rgba32sint, typeTexStorage3D_rgba32float, typeTexStorage3D_rg32uint, typeTexStorage3D_rg32sint, typeTexStorage3D_rg32float, typeTexStorage3D_r32uint, typeTexStorage3D_r32sint, typeTexStorage3D_r32float, typeSampler, typeSamplerComparison, typeTexExternal, typeBVec2, typeBVec3, typeBVec4 } from './types.js';
-import { ASTAddressOf, ASTScalar, ASTFunction, ASTUnaryFunc, ASTBinaryFunc } from './ast.js';
+import { PBPrimitiveType, typeU32, typeF32, typeI32, typeAtomicI32, typeAtomicU32, typeVoid, PBFunctionTypeInfo, typeF32Vec2, typeF32Vec3, typeF32Vec4, typeI32Vec2, typeI32Vec3, typeI32Vec4, typeU32Vec2, typeU32Vec3, typeU32Vec4, typeMat2, typeMat3x2, typeMat4x2, typeMat2x3, typeMat3, typeMat4x3, typeMat2x4, typeMat3x4, typeMat4, typeFrexpResult, typeFrexpResultVec2, typeFrexpResultVec3, typeFrexpResultVec4, typeBool, typeTex1D, typeITex1D, typeUTex1D, typeTex2D, typeITex2D, typeUTex2D, typeTex2DArray, typeITex2DArray, typeUTex2DArray, typeTex3D, typeITex3D, typeUTex3D, typeTexCube, typeITexCube, typeUTexCube, typeTexCubeArray, typeITexCubeArray, typeUTexCubeArray, typeTexMultisampled2D, typeITexMultisampled2D, typeUTexMultisampled2D, typeTexDepth2D, typeTexDepth2DArray, typeTexDepthCube, typeTexDepthCubeArray, typeTexDepthMultisampled2D, typeTexStorage1D_rgba8unorm, typeTexStorage1D_rgba8snorm, typeTexStorage1D_rgba8uint, typeTexStorage1D_rgba8sint, typeTexStorage1D_rgba16uint, typeTexStorage1D_rgba16sint, typeTexStorage1D_rgba16float, typeTexStorage1D_rgba32uint, typeTexStorage1D_rgba32sint, typeTexStorage1D_rgba32float, typeTexStorage1D_rg32uint, typeTexStorage1D_rg32sint, typeTexStorage1D_rg32float, typeTexStorage1D_r32uint, typeTexStorage1D_r32sint, typeTexStorage1D_r32float, typeTexStorage2D_rgba8unorm, typeTexStorage2D_rgba8snorm, typeTexStorage2D_rgba8uint, typeTexStorage2D_rgba8sint, typeTexStorage2D_rgba16uint, typeTexStorage2D_rgba16sint, typeTexStorage2D_rgba16float, typeTexStorage2D_rgba32uint, typeTexStorage2D_rgba32sint, typeTexStorage2D_rgba32float, typeTexStorage2D_rg32uint, typeTexStorage2D_rg32sint, typeTexStorage2D_rg32float, typeTexStorage2D_r32uint, typeTexStorage2D_r32sint, typeTexStorage2D_r32float, typeTexStorage2DArray_rgba8unorm, typeTexStorage2DArray_rgba8snorm, typeTexStorage2DArray_rgba8uint, typeTexStorage2DArray_rgba8sint, typeTexStorage2DArray_rgba16uint, typeTexStorage2DArray_rgba16sint, typeTexStorage2DArray_rgba16float, typeTexStorage2DArray_rgba32uint, typeTexStorage2DArray_rgba32sint, typeTexStorage2DArray_rgba32float, typeTexStorage2DArray_rg32uint, typeTexStorage2DArray_rg32sint, typeTexStorage2DArray_rg32float, typeTexStorage2DArray_r32uint, typeTexStorage2DArray_r32sint, typeTexStorage2DArray_r32float, typeTexStorage3D_rgba8unorm, typeTexStorage3D_rgba8snorm, typeTexStorage3D_rgba8uint, typeTexStorage3D_rgba8sint, typeTexStorage3D_rgba16uint, typeTexStorage3D_rgba16sint, typeTexStorage3D_rgba16float, typeTexStorage3D_rgba32uint, typeTexStorage3D_rgba32sint, typeTexStorage3D_rgba32float, typeTexStorage3D_rg32uint, typeTexStorage3D_rg32sint, typeTexStorage3D_rg32float, typeTexStorage3D_r32uint, typeTexStorage3D_r32sint, typeTexStorage3D_r32float, typeSampler, typeSamplerComparison, typeTexStorage1D_bgra8unorm, typeTexStorage2D_bgra8unorm, typeTexStorage3D_bgra8unorm, typeTexExternal, typeBVec2, typeBVec3, typeBVec4 } from './types.js';
+import { ASTScalar, ASTAddressOf, ASTFunction, ASTUnaryFunc, ASTBinaryFunc } from './ast.js';
 import { PBShaderExp } from './base.js';
 import { PBParamLengthError, PBDeviceNotSupport, PBParamValueError, PBParamTypeError, PBOverloadingMatchError } from './errors.js';
 
@@ -1682,22 +1682,110 @@ const builtinFunctionsAll = {
     floatBitsToInt: {
         overloads: genType('floatBitsToInt', MASK_WEBGL2, 1, [
             0
-        ])
+        ]),
+        normalizeFunc (pb, name, ...args) {
+            if (args.length !== 1) {
+                throw new PBParamLengthError('floatBitsToInt');
+            }
+            if (!(args[0] instanceof PBShaderExp)) {
+                if (typeof args[0] !== 'number') {
+                    throw new PBParamValueError('floatBitsToInt', 'x');
+                }
+            } else {
+                const type = args[0].$ast.getType();
+                if (type.typeId !== typeF32.typeId) {
+                    throw new PBParamTypeError('floatBitsToInt', 'x');
+                }
+            }
+            if (pb.getDevice().type === 'webgpu') {
+                return pb.$callFunctionNoCheck('bitcast<i32>', [
+                    args[0] instanceof PBShaderExp ? args[0].$ast : new ASTScalar(args[0], typeF32)
+                ], typeI32);
+            } else {
+                return callBuiltin(pb, name, ...args);
+            }
+        }
     },
     floatBitsToUint: {
         overloads: genType('floatBitsToUint', MASK_WEBGL2, 2, [
             0
-        ])
+        ]),
+        normalizeFunc (pb, name, ...args) {
+            if (args.length !== 1) {
+                throw new PBParamLengthError('floatBitsToUint');
+            }
+            if (!(args[0] instanceof PBShaderExp)) {
+                if (typeof args[0] !== 'number') {
+                    throw new PBParamValueError('floatBitsToUint', 'x');
+                }
+            } else {
+                const type = args[0].$ast.getType();
+                if (type.typeId !== typeF32.typeId) {
+                    throw new PBParamTypeError('floatBitsToUint', 'x');
+                }
+            }
+            if (pb.getDevice().type === 'webgpu') {
+                return pb.$callFunctionNoCheck('bitcast<u32>', [
+                    args[0] instanceof PBShaderExp ? args[0].$ast : new ASTScalar(args[0], typeF32)
+                ], typeU32);
+            } else {
+                return callBuiltin(pb, name, ...args);
+            }
+        }
     },
     intBitsToFloat: {
         overloads: genType('intBitsToFloat', MASK_WEBGL2, 0, [
             1
-        ])
+        ]),
+        normalizeFunc (pb, name, ...args) {
+            if (args.length !== 1) {
+                throw new PBParamLengthError('intBitsToFloat');
+            }
+            if (!(args[0] instanceof PBShaderExp)) {
+                if (typeof args[0] !== 'number') {
+                    throw new PBParamValueError('intBitsToFloat', 'x');
+                }
+            } else {
+                const type = args[0].$ast.getType();
+                if (type.typeId !== typeI32.typeId) {
+                    throw new PBParamTypeError('intBitsToFloat', 'x');
+                }
+            }
+            if (pb.getDevice().type === 'webgpu') {
+                return pb.$callFunctionNoCheck('bitcast<f32>', [
+                    args[0] instanceof PBShaderExp ? args[0].$ast : new ASTScalar(args[0], typeI32)
+                ], typeF32);
+            } else {
+                return callBuiltin(pb, name, ...args);
+            }
+        }
     },
     uintBitsToFloat: {
         overloads: genType('uintBitsToFloat', MASK_WEBGL2, 0, [
             2
-        ])
+        ]),
+        normalizeFunc (pb, name, ...args) {
+            if (args.length !== 1) {
+                throw new PBParamLengthError('uintBitsToFloat');
+            }
+            if (!(args[0] instanceof PBShaderExp)) {
+                if (typeof args[0] !== 'number') {
+                    throw new PBParamValueError('uintBitsToFloat', 'x');
+                }
+            } else {
+                const type = args[0].$ast.getType();
+                if (type.typeId !== typeU32.typeId) {
+                    throw new PBParamTypeError('uintBitsToFloat', 'x');
+                }
+            }
+            if (pb.getDevice().type === 'webgpu') {
+                return pb.$callFunctionNoCheck('bitcast<f32>', [
+                    args[0] instanceof PBShaderExp ? args[0].$ast : new ASTScalar(args[0], typeU32)
+                ], typeF32);
+            } else {
+                return callBuiltin(pb, name, ...args);
+            }
+        }
     },
     pack4x8snorm: {
         overloads: genType('pack4x8snorm', MASK_WEBGPU, typeU32, [
@@ -2409,6 +2497,74 @@ const builtinFunctionsAll = {
                 typeI32,
                 typeI32
             ]),
+            ...genType('textureLoad', MASK_WEBGPU, typeF32Vec4, [
+                typeTexStorage1D_bgra8unorm,
+                typeI32
+            ]),
+            ...genType('textureLoad', MASK_WEBGPU, typeF32Vec4, [
+                typeTexStorage1D_r32float,
+                typeI32
+            ]),
+            ...genType('textureLoad', MASK_WEBGPU, typeI32Vec4, [
+                typeTexStorage1D_r32sint,
+                typeI32
+            ]),
+            ...genType('textureLoad', MASK_WEBGPU, typeU32Vec4, [
+                typeTexStorage1D_r32uint,
+                typeI32
+            ]),
+            ...genType('textureLoad', MASK_WEBGPU, typeF32Vec4, [
+                typeTexStorage1D_rg32float,
+                typeI32
+            ]),
+            ...genType('textureLoad', MASK_WEBGPU, typeI32Vec4, [
+                typeTexStorage1D_rg32sint,
+                typeI32
+            ]),
+            ...genType('textureLoad', MASK_WEBGPU, typeU32Vec4, [
+                typeTexStorage1D_rg32uint,
+                typeI32
+            ]),
+            ...genType('textureLoad', MASK_WEBGPU, typeF32Vec4, [
+                typeTexStorage1D_rgba16float,
+                typeI32
+            ]),
+            ...genType('textureLoad', MASK_WEBGPU, typeI32Vec4, [
+                typeTexStorage1D_rgba16sint,
+                typeI32
+            ]),
+            ...genType('textureLoad', MASK_WEBGPU, typeU32Vec4, [
+                typeTexStorage1D_rgba16uint,
+                typeI32
+            ]),
+            ...genType('textureLoad', MASK_WEBGPU, typeF32Vec4, [
+                typeTexStorage1D_rgba32float,
+                typeI32
+            ]),
+            ...genType('textureLoad', MASK_WEBGPU, typeI32Vec4, [
+                typeTexStorage1D_rgba32sint,
+                typeI32
+            ]),
+            ...genType('textureLoad', MASK_WEBGPU, typeU32Vec4, [
+                typeTexStorage1D_rgba32uint,
+                typeI32
+            ]),
+            ...genType('textureLoad', MASK_WEBGPU, typeI32Vec4, [
+                typeTexStorage1D_rgba8sint,
+                typeI32
+            ]),
+            ...genType('textureLoad', MASK_WEBGPU, typeU32Vec4, [
+                typeTexStorage1D_rgba8uint,
+                typeI32
+            ]),
+            ...genType('textureLoad', MASK_WEBGPU, typeF32Vec4, [
+                typeTexStorage1D_rgba8snorm,
+                typeI32
+            ]),
+            ...genType('textureLoad', MASK_WEBGPU, typeF32Vec4, [
+                typeTexStorage1D_rgba8unorm,
+                typeI32
+            ]),
             ...genType('textureLoad', MASK_WEBGPU, typeF32Vec4, [
                 typeTex2D,
                 typeI32Vec2,
@@ -2424,6 +2580,74 @@ const builtinFunctionsAll = {
                 typeI32Vec2,
                 typeI32
             ]),
+            ...genType('textureLoad', MASK_WEBGPU, typeF32Vec4, [
+                typeTexStorage2D_bgra8unorm,
+                typeI32Vec2
+            ]),
+            ...genType('textureLoad', MASK_WEBGPU, typeF32Vec4, [
+                typeTexStorage2D_r32float,
+                typeI32Vec2
+            ]),
+            ...genType('textureLoad', MASK_WEBGPU, typeI32Vec4, [
+                typeTexStorage2D_r32sint,
+                typeI32Vec2
+            ]),
+            ...genType('textureLoad', MASK_WEBGPU, typeU32Vec4, [
+                typeTexStorage2D_r32uint,
+                typeI32Vec2
+            ]),
+            ...genType('textureLoad', MASK_WEBGPU, typeF32Vec4, [
+                typeTexStorage2D_rg32float,
+                typeI32Vec2
+            ]),
+            ...genType('textureLoad', MASK_WEBGPU, typeI32Vec4, [
+                typeTexStorage2D_rg32sint,
+                typeI32Vec2
+            ]),
+            ...genType('textureLoad', MASK_WEBGPU, typeU32Vec4, [
+                typeTexStorage2D_rg32uint,
+                typeI32Vec2
+            ]),
+            ...genType('textureLoad', MASK_WEBGPU, typeF32Vec4, [
+                typeTexStorage2D_rgba16float,
+                typeI32Vec2
+            ]),
+            ...genType('textureLoad', MASK_WEBGPU, typeI32Vec4, [
+                typeTexStorage2D_rgba16sint,
+                typeI32Vec2
+            ]),
+            ...genType('textureLoad', MASK_WEBGPU, typeU32Vec4, [
+                typeTexStorage2D_rgba16uint,
+                typeI32Vec2
+            ]),
+            ...genType('textureLoad', MASK_WEBGPU, typeF32Vec4, [
+                typeTexStorage2D_rgba32float,
+                typeI32Vec2
+            ]),
+            ...genType('textureLoad', MASK_WEBGPU, typeI32Vec4, [
+                typeTexStorage2D_rgba32sint,
+                typeI32Vec2
+            ]),
+            ...genType('textureLoad', MASK_WEBGPU, typeU32Vec4, [
+                typeTexStorage2D_rgba32uint,
+                typeI32Vec2
+            ]),
+            ...genType('textureLoad', MASK_WEBGPU, typeI32Vec4, [
+                typeTexStorage2D_rgba8sint,
+                typeI32Vec2
+            ]),
+            ...genType('textureLoad', MASK_WEBGPU, typeU32Vec4, [
+                typeTexStorage2D_rgba8uint,
+                typeI32Vec2
+            ]),
+            ...genType('textureLoad', MASK_WEBGPU, typeF32Vec4, [
+                typeTexStorage2D_rgba8snorm,
+                typeI32Vec2
+            ]),
+            ...genType('textureLoad', MASK_WEBGPU, typeF32Vec4, [
+                typeTexStorage2D_rgba8unorm,
+                typeI32Vec2
+            ]),
             ...genType('textureLoad', MASK_WEBGPU, typeF32Vec4, [
                 typeTex3D,
                 typeI32Vec3,
@@ -2439,6 +2663,74 @@ const builtinFunctionsAll = {
                 typeI32Vec3,
                 typeI32
             ]),
+            ...genType('textureLoad', MASK_WEBGPU, typeF32Vec4, [
+                typeTexStorage3D_bgra8unorm,
+                typeI32Vec3
+            ]),
+            ...genType('textureLoad', MASK_WEBGPU, typeF32Vec4, [
+                typeTexStorage3D_r32float,
+                typeI32Vec3
+            ]),
+            ...genType('textureLoad', MASK_WEBGPU, typeI32Vec4, [
+                typeTexStorage3D_r32sint,
+                typeI32Vec3
+            ]),
+            ...genType('textureLoad', MASK_WEBGPU, typeU32Vec4, [
+                typeTexStorage3D_r32uint,
+                typeI32Vec3
+            ]),
+            ...genType('textureLoad', MASK_WEBGPU, typeF32Vec4, [
+                typeTexStorage3D_rg32float,
+                typeI32Vec3
+            ]),
+            ...genType('textureLoad', MASK_WEBGPU, typeI32Vec4, [
+                typeTexStorage3D_rg32sint,
+                typeI32Vec3
+            ]),
+            ...genType('textureLoad', MASK_WEBGPU, typeU32Vec4, [
+                typeTexStorage3D_rg32uint,
+                typeI32Vec3
+            ]),
+            ...genType('textureLoad', MASK_WEBGPU, typeF32Vec4, [
+                typeTexStorage3D_rgba16float,
+                typeI32Vec3
+            ]),
+            ...genType('textureLoad', MASK_WEBGPU, typeI32Vec4, [
+                typeTexStorage3D_rgba16sint,
+                typeI32Vec3
+            ]),
+            ...genType('textureLoad', MASK_WEBGPU, typeU32Vec4, [
+                typeTexStorage3D_rgba16uint,
+                typeI32Vec3
+            ]),
+            ...genType('textureLoad', MASK_WEBGPU, typeF32Vec4, [
+                typeTexStorage3D_rgba32float,
+                typeI32Vec3
+            ]),
+            ...genType('textureLoad', MASK_WEBGPU, typeI32Vec4, [
+                typeTexStorage3D_rgba32sint,
+                typeI32Vec3
+            ]),
+            ...genType('textureLoad', MASK_WEBGPU, typeU32Vec4, [
+                typeTexStorage3D_rgba32uint,
+                typeI32Vec3
+            ]),
+            ...genType('textureLoad', MASK_WEBGPU, typeI32Vec4, [
+                typeTexStorage3D_rgba8sint,
+                typeI32Vec3
+            ]),
+            ...genType('textureLoad', MASK_WEBGPU, typeU32Vec4, [
+                typeTexStorage3D_rgba8uint,
+                typeI32Vec3
+            ]),
+            ...genType('textureLoad', MASK_WEBGPU, typeF32Vec4, [
+                typeTexStorage3D_rgba8snorm,
+                typeI32Vec3
+            ]),
+            ...genType('textureLoad', MASK_WEBGPU, typeF32Vec4, [
+                typeTexStorage3D_rgba8unorm,
+                typeI32Vec3
+            ]),
             ...genType('textureLoad', MASK_WEBGPU, typeF32Vec4, [
                 typeTexMultisampled2D,
                 typeI32Vec2,
@@ -2549,8 +2841,13 @@ const builtinFunctionsAll = {
                     }
                     args[1] = pb.ivec2(args[1], 0);
                 }
-            } else if (pb.getDevice().type === 'webgpu' && texType.isExternalTexture()) {
-                args = args.slice(0, 2);
+            } else if (pb.getDevice().type === 'webgpu') {
+                if (texType.isExternalTexture()) {
+                    args = args.slice(0, 2);
+                }
+                if (texType.isStorageTexture()) {
+                    texType.readable = true;
+                }
             }
             return callBuiltin(pb, name, ...args);
         }
@@ -2765,6 +3062,11 @@ const builtinFunctionsAll = {
                 typeU32Vec2,
                 typeU32Vec4
             ]),
+            ...genType('textureStore', MASK_WEBGPU, typeVoid, [
+                typeTexStorage2D_r32uint,
+                typeI32Vec2,
+                typeU32Vec4
+            ]),
             ...genType('textureStore', MASK_WEBGPU, typeVoid, [
                 typeTexStorage2D_r32sint,
                 typeU32Vec2,
@@ -2855,7 +3157,19 @@ const builtinFunctionsAll = {
                 typeU32Vec3,
                 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);
+        }
     },
     // textureArrayStore(tex: PBShaderExp, coords: PBShaderExp, arrayIndex: number|PBShaderExp, value: PBShaderExp);
     textureArrayStore: {
@@ -3227,6 +3541,9 @@ const builtinFunctionsAll = {
                 throw new PBParamTypeError('textureSample', 'texture');
             }
             if (pb.getDevice().type === 'webgpu') {
+                if (texType.isStorageTexture()) {
+                    throw new PBParamTypeError('textureSample', 'texture');
+                }
                 const sampler = pb.getDefaultSampler(tex, false);
                 const coords = args[1];
                 const ret = callBuiltin(pb, name, tex, sampler, coords);
@@ -4033,7 +4350,8 @@ for (const name of [
     'atomicMin',
     'atomicAnd',
     'atomicOr',
-    'atomicXor'
+    'atomicXor',
+    'atomicExchange'
 ]){
     builtinFunctionsAll[name] = {
         overloades: [],

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/constructors.js

@@ -126,7 +126,7 @@ const texStorageCtors = {
     Object.keys(texStorageCtors).forEach((k)=>{
         cls.prototype[k] = makeStorageTextureCtor(texStorageCtors[k]);
     });
-    cls.prototype['atomic_int'] = function(...args) {
+    cls.prototype['atomic_int'] = makeConstructor(function(...args) {
         if (args.length > 1) {
             throw new PBParamLengthError('atomic_int');
         }
@@ -140,8 +140,8 @@ const texStorageCtors = {
             exp.$ast = new ASTShaderExpConstructor(exp.$typeinfo, []);
             return exp;
         }
-    };
-    cls.prototype['atomic_uint'] = function(...args) {
+    }, typeAtomicI32);
+    cls.prototype['atomic_uint'] = makeConstructor(function(...args) {
         if (args.length > 1) {
             throw new PBParamLengthError('atomic_uint');
         }
@@ -161,7 +161,7 @@ const texStorageCtors = {
             return exp;
         }
         return null;
-    };
+    }, typeAtomicU32);
 } /*
 ProgramBuilder.prototype.texStorage1D = makeStorageTextureCtor(typeinfo.PBTextureType.TEX_STORAGE_1D);
 ProgramBuilder.prototype.texStorage2D = makeStorageTextureCtor(typeinfo.PBTextureType.TEX_STORAGE_2D);

package/dist/builder/programbuilder.js

@@ -712,14 +712,19 @@ const output_prefix_fs = 'zFSOutput_';
             name,
             new ASTDeclareVar(new ASTPrimitive(variable))
         ];
-        Object.defineProperty(this._outputScope, name, {
-            get: function() {
-                return variable;
-            },
-            set: function(v) {
-                getCurrentProgramBuilder().getCurrentScope().$ast.statements.push(new ASTAssignment(new ASTLValueScalar(variable.$ast), v instanceof PBShaderExp ? v.$ast : v));
-            }
-        });
+        for (const prop of [
+            name,
+            String(location)
+        ]){
+            Object.defineProperty(this._outputScope, prop, {
+                get: function() {
+                    return variable;
+                },
+                set: function(v) {
+                    getCurrentProgramBuilder().getCurrentScope().$ast.statements.push(new ASTAssignment(new ASTLValueScalar(variable.$ast), v instanceof PBShaderExp ? v.$ast : v));
+                }
+            });
+        }
     }
     /** @internal */ getDefaultSampler(t, comparison) {
         const u = this._uniforms.findIndex((val)=>val.texture?.exp === t);
@@ -1015,6 +1020,8 @@ const output_prefix_fs = 'zFSOutput_';
                 const exp = new PBShaderExp(u.block.exp.$str, u.block.exp.$ast.getType());
                 exp.$declareType = u.block.exp.$declareType;
                 exp.$isBuffer = u.block.exp.$isBuffer;
+                exp.$bindingSize = u.block.exp.$bindingSize;
+                exp.$readonly = u.block.exp.$readonly;
                 uniformList[u.group].push({
                     member: exp,
                     uniform: i
@@ -1054,11 +1061,13 @@ const output_prefix_fs = 'zFSOutput_';
                         const uname = `${nameList[i]}_${k}_${p}`;
                         const structName = this.generateStructureName();
                         const t = getCurrentProgramBuilder().internalDefineStruct(structName, types[i], ShaderType.Compute, false, ...allLists[p].map((val)=>val.member));
+                        const readonly = i > 0 ? allLists[p].findIndex((val)=>!val.member.$readonly) < 0 : true;
                         const exp = t();
                         if (i === 0) {
-                            exp.uniformBuffer(Number(k));
+                            exp.uniformBuffer(Number(k), p > 0 ? allLists[p][0].member.$bindingSize : 0);
                         } else {
-                            exp.storageBuffer(Number(k));
+                            exp.storageBuffer(Number(k), p > 0 ? allLists[p][0].member.$bindingSize : 0);
+                            exp.$readonly = readonly;
                         }
                         globalScope[uname] = exp;
                         const index = this._uniforms.findIndex((val)=>val.block?.name === uname);
@@ -1120,6 +1129,8 @@ const output_prefix_fs = 'zFSOutput_';
                     const exp = new PBShaderExp(u.block.exp.$str, u.block.exp.$ast.getType());
                     exp.$declareType = u.block.exp.$declareType;
                     exp.$isBuffer = u.block.exp.$isBuffer;
+                    exp.$bindingSize = u.block.exp.$bindingSize;
+                    exp.$readonly = u.block.exp.$readonly;
                     sharedUniformList[u.group].push({
                         member: exp,
                         uniform: i
@@ -1132,6 +1143,8 @@ const output_prefix_fs = 'zFSOutput_';
                     const exp = new PBShaderExp(u.block.exp.$str, u.block.exp.$ast.getType());
                     exp.$declareType = u.block.exp.$declareType;
                     exp.$isBuffer = u.block.exp.$isBuffer;
+                    exp.$bindingSize = u.block.exp.$bindingSize;
+                    exp.$readonly = u.block.exp.$readonly;
                     vertexUniformList[u.group].push({
                         member: exp,
                         uniform: i
@@ -1144,6 +1157,8 @@ const output_prefix_fs = 'zFSOutput_';
                     const exp = new PBShaderExp(u.block.exp.$str, u.block.exp.$ast.getType());
                     exp.$declareType = u.block.exp.$declareType;
                     exp.$isBuffer = u.block.exp.$isBuffer;
+                    exp.$bindingSize = u.block.exp.$bindingSize;
+                    exp.$readonly = u.block.exp.$readonly;
                     fragUniformList[u.group].push({
                         member: exp,
                         uniform: i
@@ -1206,21 +1221,27 @@ const output_prefix_fs = 'zFSOutput_';
                             const uname = `${nameList[j][i]}_${k}_${p}`;
                             const structName = this.generateStructureName();
                             const t = getCurrentProgramBuilder().internalDefineStruct(structName, layoutList[j], maskList[i], false, ...allLists[p].map((val)=>val.member));
+                            const readonly = j > 0 ? allLists[p].findIndex((val)=>!val.member.$readonly) < 0 : true;
                             if (maskList[i] & ShaderType.Vertex) {
                                 const exp = t();
+                                if (j > 0 && !readonly) {
+                                    throw new Error(`Storage buffer in vertex shader must be read-only`);
+                                }
                                 if (j === 0) {
-                                    exp.uniformBuffer(Number(k));
+                                    exp.uniformBuffer(Number(k), p > 0 ? allLists[p][0].member.$bindingSize : 0);
                                 } else {
-                                    exp.storageBuffer(Number(k));
+                                    exp.storageBuffer(Number(k), p > 0 ? allLists[p][0].member.$bindingSize : 0);
+                                    exp.$readonly = readonly;
                                 }
                                 globalScopeVertex[uname] = exp;
                             }
                             if (maskList[i] & ShaderType.Fragment) {
                                 const exp = t();
                                 if (j === 0) {
-                                    exp.uniformBuffer(Number(k));
+                                    exp.uniformBuffer(Number(k), p > 0 ? allLists[p][0].member.$bindingSize : 0);
                                 } else {
-                                    exp.storageBuffer(Number(k));
+                                    exp.storageBuffer(Number(k), p > 0 ? allLists[p][0].member.$bindingSize : 0);
+                                    exp.$readonly = readonly;
                                 }
                                 globalScopeFragmet[uname] = exp;
                             }
@@ -1291,6 +1312,12 @@ const output_prefix_fs = 'zFSOutput_';
     }
     /** @internal */ createBindGroupLayouts(label) {
         const layouts = [];
+        const dynamicOffsetIndex = [
+            0,
+            0,
+            0,
+            0
+        ];
         for (const uniformInfo of this._uniforms){
             let layout = layouts[uniformInfo.group];
             if (!layout) {
@@ -1313,9 +1340,11 @@ const output_prefix_fs = 'zFSOutput_';
                 entry.type = uniformInfo.block.exp.$typeinfo.clone(this.getBlockName(uniformInfo.block.name));
                 const isStorage = uniformInfo.block.exp.$declareType === DeclareType.DECLARE_TYPE_STORAGE;
                 entry.buffer = {
-                    type: isStorage ? uniformInfo.block.exp.$ast.isWritable() ? 'storage' : 'read-only-storage' : 'uniform',
-                    hasDynamicOffset: uniformInfo.block.dynamicOffset,
-                    uniformLayout: entry.type.toBufferLayout(0, entry.type.layout)
+                    type: isStorage ? uniformInfo.block.exp.$readonly ? 'read-only-storage' : 'storage' : 'uniform',
+                    minBindingSize: uniformInfo.block.bindingSize,
+                    hasDynamicOffset: !!uniformInfo.block.bindingSize,
+                    uniformLayout: entry.type.toBufferLayout(0, entry.type.layout),
+                    dynamicOffsetIndex: !!uniformInfo.block.bindingSize ? dynamicOffsetIndex[uniformInfo.group]++ : -1
                 };
                 entry.name = uniformInfo.block.name;
             } else if (uniformInfo.texture) {
@@ -1593,7 +1622,7 @@ const output_prefix_fs = 'zFSOutput_';
         } else {
             uniformInfo.block = {
                 name: name,
-                dynamicOffset: false,
+                bindingSize: variable.$bindingSize,
                 exp: variable
             };
         // throw new Error(`unsupported uniform type: ${name}`);
@@ -1768,7 +1797,7 @@ const output_prefix_fs = 'zFSOutput_';
             this[prop] = value;
             return true;
         }
-        if (!(this.$_scope instanceof PBGlobalScope) && value instanceof PBShaderExp && (value.isConstructor() || value.$typeinfo.isTextureType() && value.$ast instanceof ASTPrimitive && !value.$ast.name) && value.$declareType === DeclareType.DECLARE_TYPE_UNIFORM) {
+        if (!(this.$_scope instanceof PBGlobalScope) && value instanceof PBShaderExp && (value.isConstructor() || value.$typeinfo.isTextureType() && value.$ast instanceof ASTPrimitive && !value.$ast.name) && (value.$declareType === DeclareType.DECLARE_TYPE_UNIFORM || value.$declareType === DeclareType.DECLARE_TYPE_STORAGE)) {
             // We are setting uniform a uniform, should invoke in the global scope
             this.$g[prop] = value;
             return true;
@@ -1783,6 +1812,8 @@ const output_prefix_fs = 'zFSOutput_';
             if (value instanceof PBShaderExp && !this.$_scope.$parent) {
                 exp.$declareType = value.$declareType;
                 exp.$isBuffer = value.$isBuffer;
+                exp.$bindingSize = value.$bindingSize;
+                exp.$readonly = value.$readonly;
                 exp.$group = value.$group;
                 exp.$attrib = value.$attrib;
                 exp.$sampleType = value.$sampleType;

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

@@ -408,6 +408,9 @@ var PBTypeClass;
     /** returns true if this is a primitive type */ isPrimitiveType() {
         return false;
     }
+    /** Wether this type have atomic members */ haveAtomicMembers() {
+        return false;
+    }
     /** returns true if this is a struct type */ isStructType() {
         return false;
     }
@@ -828,6 +831,17 @@ var PBTypeClass;
     /** Get member types of the struct type */ get structMembers() {
         return this.detail.structMembers;
     }
+    /** Whether this struct has atomic members */ haveAtomicMembers() {
+        for (const member of this.structMembers){
+            if (member.type.isStructType() && member.type.haveAtomicMembers()) {
+                return true;
+            } else if (member.type.isArrayType() && member.type.haveAtomicMembers()) {
+                return true;
+            } else {
+                return member.type.isAtomicI32() || member.type.isAtomicU32();
+            }
+        }
+    }
     /**
    * Creates a new struct type by extending this type
    * @param name - Name of the new struct type
@@ -873,17 +887,6 @@ var PBTypeClass;
             return varName ? `${this.structName} ${varName}` : this.structName;
         }
     }
-    /** @internal */ isWritable() {
-        for (const member of this.structMembers){
-            if (member.type.isAtomicI32() || member.type.isAtomicU32()) {
-                return true;
-            }
-            if (member.type.isStructType() && member.type.isWritable()) {
-                return true;
-            }
-        }
-        return false;
-    }
     /** @internal */ getLayoutAlignment(layout) {
         if (layout === 'packed') {
             return 1;
@@ -997,6 +1000,13 @@ var PBTypeClass;
     /** Get dimension of the array type */ get dimension() {
         return this.detail.dimension;
     }
+    /** Wether array have atomic members */ haveAtomicMembers() {
+        if (this.elementType.isStructType() || this.elementType.isArrayType()) {
+            return this.elementType.haveAtomicMembers();
+        } else {
+            return this.elementType.isAtomicI32() || this.elementType.isAtomicU32();
+        }
+    }
     /** {@inheritDoc PBTypeInfo.isArrayType} */ isArrayType() {
         return true;
     }
@@ -1087,6 +1097,9 @@ var PBTypeClass;
             this.id = null;
         }
     }
+    /** {@inheritDoc PBTypeInfo.haveAtomicMembers} */ haveAtomicMembers() {
+        return this.pointerType.haveAtomicMembers();
+    }
     /** {@inheritDoc PBTypeInfo.isPointerType} */ isPointerType() {
         return true;
     }
@@ -1121,6 +1134,9 @@ var PBTypeClass;
     constructor(){
         super(PBTypeClass.ATOMIC_I32, null);
     }
+    /** {@inheritDoc PBTypeInfo.isPointerType} */ haveAtomicMembers() {
+        return true;
+    }
     /** @internal */ isAtomicI32() {
         return true;
     }
@@ -1161,6 +1177,9 @@ var PBTypeClass;
     constructor(){
         super(PBTypeClass.ATOMIC_U32, null);
     }
+    /** {@inheritDoc PBTypeInfo.isPointerType} */ haveAtomicMembers() {
+        return true;
+    }
     /** @internal */ isAtomicU32() {
         return true;
     }
@@ -1250,9 +1269,15 @@ var PBTypeClass;
     /** Returns true if this is a readable storage texture type */ get readable() {
         return this.detail.readable;
     }
+    set readable(val) {
+        this.detail.readable = !!val;
+    }
     /** Returns true if this is a writable storage texture type */ get writable() {
         return this.detail.writable;
     }
+    set writable(val) {
+        this.detail.writable = !!val;
+    }
     /** @internal */ isStorable() {
         return true;
     }
@@ -1298,7 +1323,7 @@ var PBTypeClass;
             if (this.isStorageTexture()) {
                 const storageTexelFormat = storageTexelFormatMap[this.storageTexelFormat];
                 // storage textures currently only support 'write' access control
-                const accessMode = 'write'; //this.readable ? (this.writable ? 'read_write' : 'read') : 'write';
+                const accessMode = this.writable ? this.readable ? 'read_write' : 'write' : 'read'; // this.readable ? (this.writable ? 'read_write' : 'read') : 'write';
                 typename = `${typename}<${storageTexelFormat}, ${accessMode}>`;
             }
             return varName ? `${varName}: ${typename}` : typename;

package/dist/builder/types.js.map

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

package/dist/device.js

@@ -59,7 +59,8 @@ import { DrawText } from './helpers/drawtext.js';
             FPS: 0,
             drawCalls: 0,
             computeCalls: 0,
-            nextFrameCall: []
+            nextFrameCall: [],
+            nextFrameCallNext: []
         };
         this._programBuilder = new ProgramBuilder(this);
         this._cpuTimer = new CPUTimer();
@@ -222,12 +223,6 @@ import { DrawText } from './helpers/drawtext.js';
             this._frameInfo.nextFrameCall.push(f);
         }
     }
-    cancelNextFrameCall(f) {
-        const index = this._frameInfo.nextFrameCall.indexOf(f);
-        if (index >= 0) {
-            this._frameInfo.nextFrameCall.splice(index, 1);
-        }
-    }
     exitLoop() {
         if (this._runningLoop) {
             cancelAnimationFrame(this._runningLoop);
@@ -407,10 +402,13 @@ import { DrawText } from './helpers/drawtext.js';
                 this._frameInfo.elapsedTimeCPU = cpuTime;
             }
         }
-        for (const f of this._frameInfo.nextFrameCall){
+        const tmp = this._frameInfo.nextFrameCall;
+        this._frameInfo.nextFrameCall = this._frameInfo.nextFrameCallNext;
+        this._frameInfo.nextFrameCallNext = tmp;
+        for (const f of this._frameInfo.nextFrameCallNext){
             f();
         }
-        this._frameInfo.nextFrameCall.length = 0;
+        this._frameInfo.nextFrameCallNext.length = 0;
     }
     getGPUObjectList(obj) {
         let list = null;

package/dist/device.js.map

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

package/dist/index.d.ts

@@ -178,7 +178,7 @@ interface StructTypeDetail {
  */
 interface ArrayTypeDetail {
     /** Type of array elements */
-    elementType: PBPrimitiveTypeInfo | PBArrayTypeInfo | PBStructTypeInfo | PBAnyTypeInfo;
+    elementType: PBPrimitiveTypeInfo | PBArrayTypeInfo | PBStructTypeInfo | PBAnyTypeInfo | PBAtomicI32TypeInfo | PBAtomicU32TypeInfo;
     /** Array dimension */
     dimension: number;
 }
@@ -252,6 +252,8 @@ declare abstract class PBTypeInfo<DetailType extends TypeDetailInfo = TypeDetail
     isAnyType(): this is PBAnyTypeInfo;
     /** returns true if this is a primitive type */
     isPrimitiveType(): this is PBPrimitiveTypeInfo;
+    /** Wether this type have atomic members */
+    haveAtomicMembers(): boolean;
     /** returns true if this is a struct type */
     isStructType(): this is PBStructTypeInfo;
     /** returns true if this is an array type */
@@ -371,6 +373,8 @@ declare class PBStructTypeInfo extends PBTypeInfo<StructTypeDetail> {
         /** @internal */
         defaultSize: number;
     }[];
+    /** Whether this struct has atomic members */
+    haveAtomicMembers(): boolean;
     /**
      * Creates a new struct type by extending this type
      * @param name - Name of the new struct type
@@ -391,11 +395,13 @@ declare class PBStructTypeInfo extends PBTypeInfo<StructTypeDetail> {
  * @public
  */
 declare class PBArrayTypeInfo extends PBTypeInfo<ArrayTypeDetail> {
-    constructor(elementType: PBPrimitiveTypeInfo | PBArrayTypeInfo | PBStructTypeInfo | PBAnyTypeInfo, dimension?: number);
+    constructor(elementType: PBPrimitiveTypeInfo | PBArrayTypeInfo | PBStructTypeInfo | PBAnyTypeInfo | PBAtomicI32TypeInfo | PBAtomicU32TypeInfo, dimension?: number);
     /** Get the element type */
-    get elementType(): PBPrimitiveTypeInfo | PBArrayTypeInfo | PBStructTypeInfo | PBAnyTypeInfo;
+    get elementType(): PBPrimitiveTypeInfo | PBArrayTypeInfo | PBStructTypeInfo | PBAnyTypeInfo | PBAtomicI32TypeInfo | PBAtomicU32TypeInfo;
     /** Get dimension of the array type */
     get dimension(): number;
+    /** Wether array have atomic members */
+    haveAtomicMembers(): boolean;
     /** {@inheritDoc PBTypeInfo.isArrayType} */
     isArrayType(): this is PBArrayTypeInfo;
     /** {@inheritDoc PBTypeInfo.toBufferLayout} */
@@ -413,6 +419,8 @@ declare class PBPointerTypeInfo extends PBTypeInfo<PointerTypeDetail> {
     /** Get address space of the pointer */
     get addressSpace(): PBAddressSpace;
     set addressSpace(val: PBAddressSpace);
+    /** {@inheritDoc PBTypeInfo.haveAtomicMembers} */
+    haveAtomicMembers(): boolean;
     /** {@inheritDoc PBTypeInfo.isPointerType} */
     isPointerType(): this is PBPointerTypeInfo;
     /** {@inheritDoc PBTypeInfo.toBufferLayout} */
@@ -424,6 +432,8 @@ declare class PBPointerTypeInfo extends PBTypeInfo<PointerTypeDetail> {
  */
 declare class PBAtomicI32TypeInfo extends PBTypeInfo<null> {
     constructor();
+    /** {@inheritDoc PBTypeInfo.isPointerType} */
+    haveAtomicMembers(): boolean;
     /** {@inheritDoc PBTypeInfo.toBufferLayout} */
     toBufferLayout(offset: number): UniformBufferLayout;
 }
@@ -433,6 +443,8 @@ declare class PBAtomicI32TypeInfo extends PBTypeInfo<null> {
  */
 declare class PBAtomicU32TypeInfo extends PBTypeInfo<null> {
     constructor();
+    /** {@inheritDoc PBTypeInfo.isPointerType} */
+    haveAtomicMembers(): boolean;
     /** {@inheritDoc PBTypeInfo.toBufferLayout} */
     toBufferLayout(offset: number): UniformBufferLayout;
 }
@@ -459,8 +471,10 @@ declare class PBTextureTypeInfo extends PBTypeInfo<TextureTypeDetail> {
     get storageTexelFormat(): TextureFormat;
     /** Returns true if this is a readable storage texture type */
     get readable(): boolean;
+    set readable(val: boolean);
     /** Returns true if this is a writable storage texture type */
     get writable(): boolean;
+    set writable(val: boolean);
     /** Returns true if this is a 2D texture type */
     is2DTexture(): boolean;
     /** Returns true if this is a 3D texture type */
@@ -838,6 +852,8 @@ interface BufferBindingLayout {
     uniformLayout: UniformBufferLayout;
     /** minimum binding size of the buffer */
     minBindingSize?: number;
+    /** dynamic offset index */
+    dynamicOffsetIndex: number;
 }
 /**
  * Binding layout of a sampler
@@ -1117,6 +1133,7 @@ interface FrameBuffer<T = unknown> extends GPUObject<T> {
     getWidth(): number;
     getHeight(): number;
     getSampleCount(): number;
+    getHash(): string;
     setColorAttachmentCubeFace(index: number, face: CubeFace): void;
     setColorAttachmentMipLevel(index: number, level: number): void;
     setColorAttachmentLayer(index: number, layer: number): void;
@@ -1154,15 +1171,22 @@ type StructuredValue = number | TypedArray | VectorBase | {
  */
 interface BindGroup extends GPUObject<unknown> {
     getLayout(): BindGroupLayout;
+    getDynamicOffsets(): number[];
+    getGPUId(): string;
     getBuffer(name: string): GPUDataBuffer;
     getTexture(name: string): BaseTexture;
-    setBuffer(name: string, buffer: GPUDataBuffer): void;
+    setBuffer(name: string, buffer: GPUDataBuffer, offset?: number, bindOffset?: number, bindSize?: number): void;
     setValue(name: string, value: StructuredValue): any;
     setRawData(name: string, byteOffset: number, data: TypedArray, srcPos?: number, srcLength?: number): any;
     setTexture(name: string, texture: BaseTexture, sampler?: TextureSampler): any;
     setTextureView(name: string, value: BaseTexture, level?: number, face?: number, mipCount?: number, sampler?: TextureSampler): any;
     setSampler(name: string, sampler: TextureSampler): any;
 }
+/**
+ * Render bundle
+ * @public
+ */
+type RenderBundle = unknown;
 /**
  * Creates the default name for the type of given gpu object
  * @param obj - The gpu object
@@ -1213,7 +1237,7 @@ declare class PBShaderExp extends Proxiable<PBShaderExp> {
      * @param group - The bind group index
      * @returns self
      */
-    uniformBuffer(group: number): PBShaderExp;
+    uniformBuffer(group: number, bindingSize?: number): PBShaderExp;
     /**
      * Point out that the variable should be in workgroup address space
      *
@@ -1229,12 +1253,24 @@ declare class PBShaderExp extends Proxiable<PBShaderExp> {
      * @returns self
      */
     storage(group: number): PBShaderExp;
+    /**
+     * Point out that the variable is read-only and should be in storage address space
+     * @param group - The bind group index
+     * @returns self
+     */
+    storageReadonly(group: number): PBShaderExp;
     /**
      * Point out that the variable should be a storage buffer
      * @param group - The bind group index
      * @returns self
      */
-    storageBuffer(group: number): PBShaderExp;
+    storageBuffer(group: number, bindingSize?: number): PBShaderExp;
+    /**
+     * Point out that the variable is read-only and should be a storage buffer
+     * @param group - The bind group index
+     * @returns self
+     */
+    storageBufferReadonly(group: number, bindingSize?: number): PBShaderExp;
     inout(): PBShaderExp;
     out(): PBShaderExp;
     /**
@@ -1508,6 +1544,26 @@ interface ProgramBuilder {
      * @returns the 'referenceOf' expression
      */
     referenceOf(ptr: PBShaderExp): PBShaderExp;
+    /** Atomic int type variable constructors */
+    atomic_int: {
+        (): PBShaderExp;
+        (rhs: number): PBShaderExp;
+        (rhs: boolean): PBShaderExp;
+        (rhs: PBShaderExp): PBShaderExp;
+        (name: string): PBShaderExp;
+        ptr: ShaderTypeFunc;
+        [dim: number]: ShaderTypeFunc;
+    };
+    /** Atomic uint type variable constructors */
+    atomic_uint: {
+        (): PBShaderExp;
+        (rhs: number): PBShaderExp;
+        (rhs: boolean): PBShaderExp;
+        (rhs: PBShaderExp): PBShaderExp;
+        (name: string): PBShaderExp;
+        ptr: ShaderTypeFunc;
+        [dim: number]: ShaderTypeFunc;
+    };
     /** float type variable constructors */
     float: {
         (): PBShaderExp;
@@ -1968,13 +2024,13 @@ interface ProgramBuilder {
     arrayLength(x: PBShaderExp): PBShaderExp;
     /** Same as the select builtin function in WGSL, only valid for WebGPU device */
     select(x: number | PBShaderExp, y: number | PBShaderExp, cond: boolean | PBShaderExp): PBShaderExp;
-    /** Same as floatBitsToInt builtin function in GLSL, only valid for WebGL2 device */
+    /** Same as floatBitsToInt builtin function in GLSL, only valid for WebGL2 device and WebGPU device */
     floatBitsToInt(x: number | PBShaderExp): PBShaderExp;
-    /** Same as floatBitsToUint builtin function in GLSL, only valid for WebGL2 device */
+    /** Same as floatBitsToUint builtin function in GLSL, only valid for WebGL2 device and WebGPU device */
     floatBitsToUint(x: number | PBShaderExp): PBShaderExp;
-    /** Same as intBitsToFloat builtin function in GLSL, only valid for WebGL2 device */
+    /** Same as intBitsToFloat builtin function in GLSL, only valid for WebGL2 device and WebGPU device */
     intBitsToFloat(x: number | PBShaderExp): PBShaderExp;
-    /** Same as uintBitsToFloat builtin function in GLSL, only valid for WebGL2 device */
+    /** Same as uintBitsToFloat builtin function in GLSL, only valid for WebGL2 device and WebGPU device */
     uintBitsToFloat(x: number | PBShaderExp): PBShaderExp;
     /** Same as pack4x8snorm builtin function in WGSL, only valid for WebGPU device */
     pack4x8snorm(x: PBShaderExp): PBShaderExp;
@@ -2088,6 +2144,8 @@ interface ProgramBuilder {
     atomicOr(ptr: PBShaderExp, value: number | PBShaderExp): PBShaderExp;
     /** atomicXor, only valid for WebGPU device */
     atomicXor(ptr: PBShaderExp, value: number | PBShaderExp): PBShaderExp;
+    /** atomicExchange, only valid for WebGPU device */
+    atomicExchange(ptr: PBShaderExp, value: number | PBShaderExp): PBShaderExp;
 }
 /**
  * The program builder class
@@ -2564,7 +2622,9 @@ interface StencilState {
  * @public
  */
 interface RenderStateSet {
-    /** Creates a new RenderStateSet by copying this one */
+    /** Creates a new RenderStateSet object by deep copy from this object */
+    clone(): RenderStateSet;
+    /** Shallow copy existing RenderStateSet object to this */
     copyFrom(stateSet: RenderStateSet): void;
     /** Fragment output related render statements or null if the default values should be used */
     readonly colorState: ColorState;
@@ -2898,6 +2958,10 @@ interface ShaderCaps {
     maxUniformBufferSize: number;
     /** The uniform buffer offset alignment */
     uniformBufferOffsetAlignment: number;
+    /** The maximum number of bytes of storage buffer */
+    maxStorageBufferSize: number;
+    /** The storage buffer offset alignment */
+    storageBufferOffsetAlignment: number;
 }
 /**
  * Information of a texture format
@@ -3250,6 +3314,15 @@ interface AbstractDevice extends IEventTarget<DeviceEventMap> {
      * @param options - The creation options
      */
     createBuffer(sizeInBytes: number, options: BufferCreationOptions): GPUDataBuffer;
+    /**
+     * Copies a buffer to another buffer
+     * @param sourceBuffer - Source buffer
+     * @param destBuffer - destination buffer
+     * @param srcOffset - Source offset in bytes
+     * @param dstOffset - Destination offset in bytes
+     * @param bytes - How many bytes to be copy
+     */
+    copyBuffer(sourceBuffer: GPUDataBuffer, destBuffer: GPUDataBuffer, srcOffset: number, dstOffset: number, bytes: number): any;
     /**
      * Creates an index buffer
      * @param data - Data of the index buffer
@@ -3367,6 +3440,20 @@ interface AbstractDevice extends IEventTarget<DeviceEventMap> {
      * @param buffer - The output buffer
      */
     readPixelsToBuffer(index: number, x: number, y: number, w: number, h: number, buffer: GPUDataBuffer): void;
+    /**
+     * Begin capture draw commands
+     */
+    beginCapture(): void;
+    /**
+     * Executes render bundle
+     * @param renderBundle - RenderBundle to be execute
+     */
+    executeRenderBundle(renderBundle: RenderBundle): any;
+    /**
+     * End capture draw commands
+     * @returns A RenderBundle that holds the captured draw commands
+     */
+    endCapture(): RenderBundle;
     /** Get the video memory usage in bytes */
     videoMemoryUsage: number;
     /** Get the current frame information */
@@ -3450,12 +3537,6 @@ interface AbstractDevice extends IEventTarget<DeviceEventMap> {
      * @param f - The function to be scheduled
      */
     runNextFrame(f: () => void): void;
-    /**
-     * Canels a pre scheduled function
-     *
-     * @param f - The function to be cancled
-     */
-    cancelNextFrameCall(f: () => void): void;
     /** Exits from current rendering loop */
     exitLoop(): void;
     /**
@@ -3588,6 +3669,7 @@ declare abstract class BaseDevice {
     abstract createGPUProgram(params: GPUProgramConstructParams): GPUProgram;
     abstract createBindGroup(layout: BindGroupLayout): BindGroup;
     abstract createBuffer(sizeInBytes: number, options: BufferCreationOptions): GPUDataBuffer;
+    abstract copyBuffer(sourceBuffer: GPUDataBuffer, destBuffer: GPUDataBuffer, srcOffset: number, dstOffset: number, bytes: number): any;
     abstract createIndexBuffer(data: Uint16Array | Uint32Array, options?: BufferCreationOptions): IndexBuffer;
     abstract createStructuredBuffer(structureType: PBStructTypeInfo, options: BufferCreationOptions, data?: TypedArray): StructuredBuffer;
     abstract createVertexLayout(options: VertexLayoutOptions): VertexLayout;
@@ -3609,6 +3691,9 @@ declare abstract class BaseDevice {
     abstract flush(): void;
     abstract readPixels(index: number, x: number, y: number, w: number, h: number, buffer: TypedArray): Promise<void>;
     abstract readPixelsToBuffer(index: number, x: number, y: number, w: number, h: number, buffer: GPUDataBuffer): void;
+    abstract beginCapture(): void;
+    abstract endCapture(): RenderBundle;
+    abstract executeRenderBundle(renderBundle: RenderBundle): any;
     abstract looseContext(): void;
     abstract restoreContext(): void;
     protected abstract _draw(primitiveType: PrimitiveType, first: number, count: number): void;
@@ -3636,7 +3721,6 @@ declare abstract class BaseDevice {
     drawInstanced(primitiveType: PrimitiveType, first: number, count: number, numInstances: number): void;
     compute(workgroupCountX: any, workgroupCountY: any, workgroupCountZ: any): void;
     runNextFrame(f: () => void): void;
-    cancelNextFrameCall(f: () => void): void;
     exitLoop(): void;
     runLoop(func: (device: AbstractDevice) => void): void;
     pushDeviceStates(): void;
@@ -3879,4 +3963,4 @@ declare class StructuredBufferData {
     set(name: string, value: StructuredValue): void;
 }
 
-export { AbstractDevice, ArrayTypeDetail, AtlasInfo, AtomicTypeInfoDetail, BaseCreationOptions, BaseDevice, BaseTexture, BindGroup, BindGroupLayout, BindGroupLayoutEntry, BindPointInfo, BlendEquation, BlendFunc, BlendingState, BufferBindingLayout, BufferCreationOptions, BufferUsage, CPUTimer, ColorState, CompareFunc, ComputeProgramConstructParams, DataType, DepthState, DeviceBackend, DeviceCaps, DeviceEventMap, DeviceGPUObjectAddedEvent, DeviceGPUObjectRemovedEvent, DeviceGPUObjectRenameEvent, DeviceLostEvent, DeviceOptions, DeviceResizeEvent, DeviceRestoreEvent, DeviceViewport, DrawText, ExpValueNonArrayType, ExpValueType, ExternalTextureBindingLayout, FaceMode, FaceWinding, Font, FrameBuffer, FrameBufferOptions, FrameBufferTextureAttachment, FrameInfo, FramebufferCaps, FunctionTypeDetail, GPUDataBuffer, GPUObject, GPUObjectList, GPUProgram, GPUProgramConstructParams, GPUResourceUsageFlags, GlyphManager, ITimer, IndexBuffer, MiscCaps, PBAddressSpace, PBAnyTypeInfo, PBArrayTypeInfo, PBAtomicI32TypeInfo, PBAtomicU32TypeInfo, PBBuiltinScope, PBComputeOptions, PBDoWhileScope, PBForScope, PBFunctionScope, PBFunctionTypeInfo, PBGlobalScope, PBIfScope, PBInputScope, PBInsideFunctionScope, PBLocalScope, PBNakedScope, PBOutputScope, PBPointerTypeInfo, PBPrimitiveType, PBPrimitiveTypeInfo, PBReflection, PBReflectionTagGetter, PBRenderOptions, PBSamplerAccessMode, PBSamplerTypeInfo, PBScope, PBShaderExp, PBStructLayout, PBStructTypeInfo, PBTextureType, PBTextureTypeInfo, PBTypeInfo, PBVoidTypeInfo, PBWhileScope, PointerTypeDetail, PrimitiveType, PrimitiveTypeDetail, ProgramBuilder, Proxiable, RasterizerState, RenderProgramConstructParams, RenderStateSet, SamplerBindingLayout, SamplerOptions, SamplerTypeDetail, ShaderCaps, ShaderExpTagRecord, ShaderExpTagValue, ShaderKind, ShaderType, ShaderTypeFunc, StencilOp, StencilState, StorageTextureBindingLayout, StructTypeDetail, StructuredBuffer, StructuredBufferData, StructuredValue, Texture2D, Texture2DArray, Texture3D, TextureAddressMode, TextureAtlasManager, TextureBindingLayout, TextureCaps, TextureColorSpace, TextureCreationOptions, TextureCube, TextureFilterMode, TextureFormat, TextureFormatInfo, TextureImageElement, TextureMipmapData, TextureMipmapLevelData, TextureSampler, TextureType, TextureTypeDetail, TextureVideo, TypeDetailInfo, UniformBufferLayout, UniformLayout, VertexAttribFormat, VertexBufferInfo, VertexData, VertexLayout, VertexLayoutOptions, VertexSemantic, VertexStepMode, WebGLContext, genDefaultName, getTextureFormatBlockHeight, getTextureFormatBlockSize, getTextureFormatBlockWidth, getVertexAttribFormat, getVertexBufferAttribType, getVertexBufferAttribTypeBySemantic, getVertexBufferLength, getVertexBufferStride, hasAlphaChannel, hasBlueChannel, hasDepthChannel, hasGreenChannel, hasRedChannel, hasStencilChannel, isCompressedTextureFormat, isFloatTextureFormat, isIntegerTextureFormat, isSRGBTextureFormat, isSignedTextureFormat, linearTextureFormatToSRGB, makeVertexBufferType, semanticList };
+export { AbstractDevice, ArrayTypeDetail, AtlasInfo, AtomicTypeInfoDetail, BaseCreationOptions, BaseDevice, BaseTexture, BindGroup, BindGroupLayout, BindGroupLayoutEntry, BindPointInfo, BlendEquation, BlendFunc, BlendingState, BufferBindingLayout, BufferCreationOptions, BufferUsage, CPUTimer, ColorState, CompareFunc, ComputeProgramConstructParams, DataType, DepthState, DeviceBackend, DeviceCaps, DeviceEventMap, DeviceGPUObjectAddedEvent, DeviceGPUObjectRemovedEvent, DeviceGPUObjectRenameEvent, DeviceLostEvent, DeviceOptions, DeviceResizeEvent, DeviceRestoreEvent, DeviceViewport, DrawText, ExpValueNonArrayType, ExpValueType, ExternalTextureBindingLayout, FaceMode, FaceWinding, Font, FrameBuffer, FrameBufferOptions, FrameBufferTextureAttachment, FrameInfo, FramebufferCaps, FunctionTypeDetail, GPUDataBuffer, GPUObject, GPUObjectList, GPUProgram, GPUProgramConstructParams, GPUResourceUsageFlags, GlyphManager, ITimer, IndexBuffer, MiscCaps, PBAddressSpace, PBAnyTypeInfo, PBArrayTypeInfo, PBAtomicI32TypeInfo, PBAtomicU32TypeInfo, PBBuiltinScope, PBComputeOptions, PBDoWhileScope, PBForScope, PBFunctionScope, PBFunctionTypeInfo, PBGlobalScope, PBIfScope, PBInputScope, PBInsideFunctionScope, PBLocalScope, PBNakedScope, PBOutputScope, PBPointerTypeInfo, PBPrimitiveType, PBPrimitiveTypeInfo, PBReflection, PBReflectionTagGetter, PBRenderOptions, PBSamplerAccessMode, PBSamplerTypeInfo, PBScope, PBShaderExp, PBStructLayout, PBStructTypeInfo, PBTextureType, PBTextureTypeInfo, PBTypeInfo, PBVoidTypeInfo, PBWhileScope, PointerTypeDetail, PrimitiveType, PrimitiveTypeDetail, ProgramBuilder, Proxiable, RasterizerState, RenderBundle, RenderProgramConstructParams, RenderStateSet, SamplerBindingLayout, SamplerOptions, SamplerTypeDetail, ShaderCaps, ShaderExpTagRecord, ShaderExpTagValue, ShaderKind, ShaderType, ShaderTypeFunc, StencilOp, StencilState, StorageTextureBindingLayout, StructTypeDetail, StructuredBuffer, StructuredBufferData, StructuredValue, Texture2D, Texture2DArray, Texture3D, TextureAddressMode, TextureAtlasManager, TextureBindingLayout, TextureCaps, TextureColorSpace, TextureCreationOptions, TextureCube, TextureFilterMode, TextureFormat, TextureFormatInfo, TextureImageElement, TextureMipmapData, TextureMipmapLevelData, TextureSampler, TextureType, TextureTypeDetail, TextureVideo, TypeDetailInfo, UniformBufferLayout, UniformLayout, VertexAttribFormat, VertexBufferInfo, VertexData, VertexLayout, VertexLayoutOptions, VertexSemantic, VertexStepMode, WebGLContext, genDefaultName, getTextureFormatBlockHeight, getTextureFormatBlockSize, getTextureFormatBlockWidth, getVertexAttribFormat, getVertexBufferAttribType, getVertexBufferAttribTypeBySemantic, getVertexBufferLength, getVertexBufferStride, hasAlphaChannel, hasBlueChannel, hasDepthChannel, hasGreenChannel, hasRedChannel, hasStencilChannel, isCompressedTextureFormat, isFloatTextureFormat, isIntegerTextureFormat, isSRGBTextureFormat, isSignedTextureFormat, linearTextureFormatToSRGB, makeVertexBufferType, semanticList };

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@zephyr3d/device",
-	"version": "0.2.1",
+	"version": "0.2.2",
 	"description": "Device API for zephyr3d",
 	"homepage": "https://github.com/gavinyork/zephyr3d#readme",
 	"type": "module",
@@ -59,7 +59,7 @@
 	},
 	"dependencies": {
 		"@types/node": "^18.13.0",
-		"@webgpu/types": "^0.1.31"
+		"@webgpu/types": "^0.1.40"
 	},
 	"scripts": {
 		"clean": "shx rm -rf ./dist .tsbuildinfo",