@zephyr3d/device 0.1.2 → 0.2.0

package/dist/base_types.js

@@ -68,52 +68,52 @@ function makeTextureFormat(compression, r, g, b, a, depth, stencil, float, integ
     return compressionBits | colorBits | depthStencilBits | floatBits | integerBits | signedBits | srgbBits | bgrBits | blockBits;
 }
 const textureFormatMap = {
-    'unknown': 0,
-    'r8unorm': makeTextureFormat(0, true, false, false, false, false, false, false, false, false, false, false, 1, 1, 1),
-    'r8snorm': makeTextureFormat(0, true, false, false, false, false, false, false, false, true, false, false, 1, 1, 1),
-    'r16f': makeTextureFormat(0, true, false, false, false, false, false, true, false, true, false, false, 1, 1, 2),
-    'r32f': makeTextureFormat(0, true, false, false, false, false, false, true, false, true, false, false, 1, 1, 4),
-    'r8ui': makeTextureFormat(0, true, false, false, false, false, false, false, true, false, false, false, 1, 1, 1),
-    'r8i': makeTextureFormat(0, true, false, false, false, false, false, false, true, true, false, false, 1, 1, 1),
-    'r16ui': makeTextureFormat(0, true, false, false, false, false, false, false, true, false, false, false, 1, 1, 2),
-    'r16i': makeTextureFormat(0, true, false, false, false, false, false, false, true, true, false, false, 1, 1, 2),
-    'r32ui': makeTextureFormat(0, true, false, false, false, false, false, false, true, false, false, false, 1, 1, 4),
-    'r32i': makeTextureFormat(0, true, false, false, false, false, false, false, true, true, false, false, 1, 1, 4),
-    'rg8unorm': makeTextureFormat(0, true, true, false, false, false, false, false, false, false, false, false, 1, 1, 2),
-    'rg8snorm': makeTextureFormat(0, true, true, false, false, false, false, false, false, true, false, false, 1, 1, 2),
-    'rg16f': makeTextureFormat(0, true, true, false, false, false, false, true, false, true, false, false, 1, 1, 4),
-    'rg32f': makeTextureFormat(0, true, true, false, false, false, false, true, false, true, false, false, 1, 1, 8),
-    'rg8ui': makeTextureFormat(0, true, true, false, false, false, false, false, true, false, false, false, 1, 1, 2),
-    'rg8i': makeTextureFormat(0, true, true, false, false, false, false, false, true, true, false, false, 1, 1, 2),
-    'rg16ui': makeTextureFormat(0, true, true, false, false, false, false, false, true, false, false, false, 1, 1, 4),
-    'rg16i': makeTextureFormat(0, true, true, false, false, false, false, false, true, true, false, false, 1, 1, 4),
-    'rg32ui': makeTextureFormat(0, true, true, false, false, false, false, false, true, false, false, false, 1, 1, 8),
-    'rg32i': makeTextureFormat(0, true, true, false, false, false, false, false, true, true, false, false, 1, 1, 8),
-    'rgba8unorm': makeTextureFormat(0, true, true, true, true, false, false, false, false, false, false, false, 1, 1, 4),
+    unknown: 0,
+    r8unorm: makeTextureFormat(0, true, false, false, false, false, false, false, false, false, false, false, 1, 1, 1),
+    r8snorm: makeTextureFormat(0, true, false, false, false, false, false, false, false, true, false, false, 1, 1, 1),
+    r16f: makeTextureFormat(0, true, false, false, false, false, false, true, false, true, false, false, 1, 1, 2),
+    r32f: makeTextureFormat(0, true, false, false, false, false, false, true, false, true, false, false, 1, 1, 4),
+    r8ui: makeTextureFormat(0, true, false, false, false, false, false, false, true, false, false, false, 1, 1, 1),
+    r8i: makeTextureFormat(0, true, false, false, false, false, false, false, true, true, false, false, 1, 1, 1),
+    r16ui: makeTextureFormat(0, true, false, false, false, false, false, false, true, false, false, false, 1, 1, 2),
+    r16i: makeTextureFormat(0, true, false, false, false, false, false, false, true, true, false, false, 1, 1, 2),
+    r32ui: makeTextureFormat(0, true, false, false, false, false, false, false, true, false, false, false, 1, 1, 4),
+    r32i: makeTextureFormat(0, true, false, false, false, false, false, false, true, true, false, false, 1, 1, 4),
+    rg8unorm: makeTextureFormat(0, true, true, false, false, false, false, false, false, false, false, false, 1, 1, 2),
+    rg8snorm: makeTextureFormat(0, true, true, false, false, false, false, false, false, true, false, false, 1, 1, 2),
+    rg16f: makeTextureFormat(0, true, true, false, false, false, false, true, false, true, false, false, 1, 1, 4),
+    rg32f: makeTextureFormat(0, true, true, false, false, false, false, true, false, true, false, false, 1, 1, 8),
+    rg8ui: makeTextureFormat(0, true, true, false, false, false, false, false, true, false, false, false, 1, 1, 2),
+    rg8i: makeTextureFormat(0, true, true, false, false, false, false, false, true, true, false, false, 1, 1, 2),
+    rg16ui: makeTextureFormat(0, true, true, false, false, false, false, false, true, false, false, false, 1, 1, 4),
+    rg16i: makeTextureFormat(0, true, true, false, false, false, false, false, true, true, false, false, 1, 1, 4),
+    rg32ui: makeTextureFormat(0, true, true, false, false, false, false, false, true, false, false, false, 1, 1, 8),
+    rg32i: makeTextureFormat(0, true, true, false, false, false, false, false, true, true, false, false, 1, 1, 8),
+    rgba8unorm: makeTextureFormat(0, true, true, true, true, false, false, false, false, false, false, false, 1, 1, 4),
     'rgba8unorm-srgb': makeTextureFormat(0, true, true, true, true, false, false, false, false, false, true, false, 1, 1, 4),
-    'rgba8snorm': makeTextureFormat(0, true, true, true, true, false, false, false, false, true, false, false, 1, 1, 4),
-    'bgra8unorm': makeTextureFormat(0, true, true, true, true, false, false, false, false, false, false, true, 1, 1, 4),
+    rgba8snorm: makeTextureFormat(0, true, true, true, true, false, false, false, false, true, false, false, 1, 1, 4),
+    bgra8unorm: makeTextureFormat(0, true, true, true, true, false, false, false, false, false, false, true, 1, 1, 4),
     'bgra8unorm-srgb': makeTextureFormat(0, true, true, true, true, false, false, false, false, false, true, true, 1, 1, 4),
-    'rgba16f': makeTextureFormat(0, true, true, true, true, false, false, true, false, true, false, false, 1, 1, 8),
-    'rgba32f': makeTextureFormat(0, true, true, true, true, false, false, true, false, true, false, false, 1, 1, 16),
-    'rgba8ui': makeTextureFormat(0, true, true, true, true, false, false, false, true, false, false, false, 1, 1, 4),
-    'rgba8i': makeTextureFormat(0, true, true, true, true, false, false, false, true, true, false, false, 1, 1, 4),
-    'rgba16ui': makeTextureFormat(0, true, true, true, true, false, false, false, true, false, false, false, 1, 1, 8),
-    'rgba16i': makeTextureFormat(0, true, true, true, true, false, false, false, true, true, false, false, 1, 1, 8),
-    'rgba32ui': makeTextureFormat(0, true, true, true, true, false, false, false, true, false, false, false, 1, 1, 16),
-    'rgba32i': makeTextureFormat(0, true, true, true, true, false, false, false, true, true, false, false, 1, 1, 16),
-    'rg11b10uf': makeTextureFormat(0, true, true, true, false, false, false, true, false, false, false, false, 1, 1, 4),
-    'd16': makeTextureFormat(0, false, false, false, false, true, false, false, false, false, false, false, 1, 1, 2),
-    'd24': makeTextureFormat(0, false, false, false, false, true, false, false, false, false, false, false, 0, 0, 0),
-    'd32f': makeTextureFormat(0, false, false, false, false, true, false, true, false, true, false, false, 1, 1, 4),
-    'd24s8': makeTextureFormat(0, false, false, false, false, true, true, false, false, false, false, false, 1, 1, 4),
-    'd32fs8': makeTextureFormat(0, false, false, false, false, true, true, true, false, true, false, false, 1, 1, 5),
+    rgba16f: makeTextureFormat(0, true, true, true, true, false, false, true, false, true, false, false, 1, 1, 8),
+    rgba32f: makeTextureFormat(0, true, true, true, true, false, false, true, false, true, false, false, 1, 1, 16),
+    rgba8ui: makeTextureFormat(0, true, true, true, true, false, false, false, true, false, false, false, 1, 1, 4),
+    rgba8i: makeTextureFormat(0, true, true, true, true, false, false, false, true, true, false, false, 1, 1, 4),
+    rgba16ui: makeTextureFormat(0, true, true, true, true, false, false, false, true, false, false, false, 1, 1, 8),
+    rgba16i: makeTextureFormat(0, true, true, true, true, false, false, false, true, true, false, false, 1, 1, 8),
+    rgba32ui: makeTextureFormat(0, true, true, true, true, false, false, false, true, false, false, false, 1, 1, 16),
+    rgba32i: makeTextureFormat(0, true, true, true, true, false, false, false, true, true, false, false, 1, 1, 16),
+    rg11b10uf: makeTextureFormat(0, true, true, true, false, false, false, true, false, false, false, false, 1, 1, 4),
+    d16: makeTextureFormat(0, false, false, false, false, true, false, false, false, false, false, false, 1, 1, 2),
+    d24: makeTextureFormat(0, false, false, false, false, true, false, false, false, false, false, false, 0, 0, 0),
+    d32f: makeTextureFormat(0, false, false, false, false, true, false, true, false, true, false, false, 1, 1, 4),
+    d24s8: makeTextureFormat(0, false, false, false, false, true, true, false, false, false, false, false, 1, 1, 4),
+    d32fs8: makeTextureFormat(0, false, false, false, false, true, true, true, false, true, false, false, 1, 1, 5),
     // compressed texture formats
-    'dxt1': makeTextureFormat(COMPRESSION_FORMAT_BC1, true, true, true, true, false, false, false, false, false, false, false, 4, 4, 8),
+    dxt1: makeTextureFormat(COMPRESSION_FORMAT_BC1, true, true, true, true, false, false, false, false, false, false, false, 4, 4, 8),
     'dxt1-srgb': makeTextureFormat(COMPRESSION_FORMAT_BC1, true, true, true, true, false, false, false, false, false, true, false, 4, 4, 8),
-    'dxt3': makeTextureFormat(COMPRESSION_FORMAT_BC2, true, true, true, true, false, false, false, false, false, false, false, 4, 4, 16),
+    dxt3: makeTextureFormat(COMPRESSION_FORMAT_BC2, true, true, true, true, false, false, false, false, false, false, false, 4, 4, 16),
     'dxt3-srgb': makeTextureFormat(COMPRESSION_FORMAT_BC2, true, true, true, true, false, false, false, false, false, true, false, 4, 4, 16),
-    'dxt5': makeTextureFormat(COMPRESSION_FORMAT_BC3, true, true, true, true, false, false, false, false, false, false, false, 4, 4, 16),
+    dxt5: makeTextureFormat(COMPRESSION_FORMAT_BC3, true, true, true, true, false, false, false, false, false, false, false, 4, 4, 16),
     'dxt5-srgb': makeTextureFormat(COMPRESSION_FORMAT_BC3, true, true, true, true, false, false, false, false, false, true, false, 4, 4, 16)
 };
 /**

package/dist/builder/ast.js

@@ -3,18 +3,21 @@ import { semanticToAttrib } from '../gpuobject.js';
 import { PBPrimitiveTypeInfo, PBPrimitiveType, PBTextureType, PBAddressSpace, PBPointerTypeInfo, typeBool, typeF32, typeI32, typeU32, typeVoid } from './types.js';
 import { PBASTError, PBTypeCastError, PBInternalError, PBParamTypeError } from './errors.js';
 
-const BuiltinInputStructNameVS = 'uu_VSInput';
-const BuiltinOutputStructNameVS = 'uu_VSOutput';
-const BuiltinInputStructNameFS = 'uu_FSInput';
-const BuiltinOutputStructNameFS = 'uu_FSOutput';
-const BuiltinInputStructNameCS = 'uu_CSInput';
-const BuiltinOutputStructNameCS = 'uu_CSOutput';
-const BuiltinInputStructInstanceNameVS = 'uu_VSInputCpy';
-const BuiltinOutputStructInstanceNameVS = 'uu_VSOutputCpy';
-const BuiltinInputStructInstanceNameFS = 'uu_FSInputCpy';
-const BuiltinOutputStructInstanceNameFS = 'uu_FSOutputCpy';
-const BuiltinInputStructInstanceNameCS = 'uu_CSInputCpy';
-const BuiltinOutputStructInstanceNameCS = 'uu_CSOutputCpy';
+const BuiltinInputStructNameVS = 'zVSInput';
+const BuiltinOutputStructNameVS = 'zVSOutput';
+const BuiltinInputStructNameFS = 'zFSInput';
+const BuiltinOutputStructNameFS = 'zFSOutput';
+const BuiltinInputStructNameCS = 'zCSInput';
+const BuiltinOutputStructNameCS = 'zCSOutput';
+const BuiltinParamNameVS = 'zVertexInput';
+const BuiltinParamNameFS = 'zVertexOutput';
+const BuiltinParamNameCS = 'zComputeInput';
+const BuiltinInputStructInstanceNameVS = 'zVSInputCpy';
+const BuiltinOutputStructInstanceNameVS = 'zVSOutputCpy';
+const BuiltinInputStructInstanceNameFS = 'zFSInputCpy';
+const BuiltinOutputStructInstanceNameFS = 'zFSOutputCpy';
+const BuiltinInputStructInstanceNameCS = 'zCSInputCpy';
+const BuiltinOutputStructInstanceNameCS = 'zCSOutputCpy';
 var DeclareType;
 (function(DeclareType) {
     DeclareType[DeclareType["DECLARE_TYPE_NONE"] = 0] = "DECLARE_TYPE_NONE";
@@ -31,6 +34,18 @@ var ShaderPrecisionType;
     ShaderPrecisionType[ShaderPrecisionType["MEDIUM"] = 2] = "MEDIUM";
     ShaderPrecisionType[ShaderPrecisionType["LOW"] = 3] = "LOW";
 })(ShaderPrecisionType || (ShaderPrecisionType = {}));
+/** @internal */ function getBuiltinParamName(shaderType) {
+    switch(shaderType){
+        case ShaderType.Vertex:
+            return BuiltinParamNameVS;
+        case ShaderType.Fragment:
+            return BuiltinParamNameFS;
+        case ShaderType.Compute:
+            return BuiltinParamNameCS;
+        default:
+            return null;
+    }
+}
 /** @internal */ function getBuiltinInputStructInstanceName(shaderType) {
     switch(shaderType){
         case ShaderType.Vertex:
@@ -188,91 +203,91 @@ var ShaderPrecisionType;
     },
     webgpu: {
         vertexIndex: {
-            name: 'ch_builtin_vertexIndex',
+            name: 'zVertexId',
             semantic: 'vertex_index',
             type: new PBPrimitiveTypeInfo(PBPrimitiveType.U32),
             inOrOut: 'in',
             stage: 'vertex'
         },
         instanceIndex: {
-            name: 'ch_builtin_instanceIndex',
+            name: 'zInstanceId',
             semantic: 'instance_index',
             type: new PBPrimitiveTypeInfo(PBPrimitiveType.U32),
             inOrOut: 'in',
             stage: 'vertex'
         },
         position: {
-            name: 'ch_builtin_position',
+            name: 'zPosition',
             semantic: 'position',
             type: new PBPrimitiveTypeInfo(PBPrimitiveType.F32VEC4),
             inOrOut: 'out',
             stage: 'vertex'
         },
         fragCoord: {
-            name: 'ch_builtin_fragCoord',
+            name: 'zFragCoord',
             semantic: 'position',
             type: new PBPrimitiveTypeInfo(PBPrimitiveType.F32VEC4),
             inOrOut: 'in',
             stage: 'fragment'
         },
         frontFacing: {
-            name: 'ch_builtin_frontFacing',
+            name: 'zFrontFacing',
             semantic: 'front_facing',
             type: new PBPrimitiveTypeInfo(PBPrimitiveType.BOOL),
             inOrOut: 'in',
             stage: 'fragment'
         },
         fragDepth: {
-            name: 'ch_builtin_fragDepth',
+            name: 'zFragDepth',
             semantic: 'frag_depth',
             type: new PBPrimitiveTypeInfo(PBPrimitiveType.F32),
             inOrOut: 'out',
             stage: 'fragment'
         },
         localInvocationId: {
-            name: 'ch_builtin_localInvocationId',
+            name: 'zLocalInvocationId',
             semantic: 'local_invocation_id',
             type: new PBPrimitiveTypeInfo(PBPrimitiveType.U32VEC3),
             inOrOut: 'in',
             stage: 'compute'
         },
         globalInvocationId: {
-            name: 'ch_builtin_globalInvocationId',
+            name: 'zGlobalInvocationId',
             semantic: 'global_invocation_id',
             type: new PBPrimitiveTypeInfo(PBPrimitiveType.U32VEC3),
             inOrOut: 'in',
             stage: 'compute'
         },
         workGroupId: {
-            name: 'ch_builtin_workGroupId',
+            name: 'zWorkGroupId',
             semantic: 'workgroup_id',
             type: new PBPrimitiveTypeInfo(PBPrimitiveType.U32VEC3),
             inOrOut: 'in',
             stage: 'compute'
         },
         numWorkGroups: {
-            name: 'ch_builtin_numWorkGroups',
+            name: 'zNumWorkGroups',
             semantic: 'num_workgroups',
             type: new PBPrimitiveTypeInfo(PBPrimitiveType.U32VEC3),
             inOrOut: 'in',
             stage: 'compute'
         },
         sampleMaskIn: {
-            name: 'ch_builtin_sampleMaskIn',
+            name: 'zSampleMaskIn',
             semantic: 'sample_mask_in',
             type: new PBPrimitiveTypeInfo(PBPrimitiveType.U32),
             inOrOut: 'in',
             stage: 'fragment'
         },
         sampleMaskOut: {
-            name: 'ch_builtin_sampleMaskOut',
+            name: 'zSampleMaskOut',
             semantic: 'sample_mask_out',
             type: new PBPrimitiveTypeInfo(PBPrimitiveType.U32),
             inOrOut: 'out',
             stage: 'fragment'
         },
         sampleIndex: {
-            name: 'ch_builtin_sampleIndex',
+            name: 'zSampleIndex',
             semantic: 'sample_index',
             type: new PBPrimitiveTypeInfo(PBPrimitiveType.U32),
             inOrOut: 'in',
@@ -1611,13 +1626,7 @@ function unbracket(e) {
         return `${this.isStatement ? indent : ''}${this.name}(${args.join(',')})${this.isStatement ? ';\n' : ''}`;
     }
     toWGSL(indent, ctx) {
-        let thisArgs = this.args.filter((val)=>{
-            const type = val.getType();
-            if (val instanceof ASTPrimitive && type.isStructType() && ctx.types.findIndex((t)=>t instanceof ASTStructDefine && t.type.structName === type.structName) < 0) {
-                return false;
-            }
-            return true;
-        });
+        let thisArgs = this.args;
         if (this.func) {
             let argsNew;
             const convertedArgs = convertArgs(thisArgs, this.func.funcType);
@@ -1627,7 +1636,13 @@ function unbracket(e) {
             if (!argsNew) {
                 throw new Error(`no matching overloading found for function '${this.name}'`);
             }
-            thisArgs = argsNew;
+            thisArgs = argsNew.filter((val)=>{
+                const type = val.getType();
+                if (type.isStructType() && ctx.types.findIndex((t)=>t instanceof ASTStructDefine && t.type.structName === type.structName) < 0) {
+                    return false;
+                }
+                return true;
+            });
         }
         const args = thisArgs.map((arg)=>unbracket(arg.toWGSL(indent, ctx)));
         return `${this.isStatement ? indent : ''}${this.name}(${args.join(',')})${this.isStatement ? ';\n' : ''}`;
@@ -1986,10 +2001,7 @@ function unbracket(e) {
         }
     }
     toWebGL(indent, ctx) {
-        let str = `${indent}do {\n`;
-        str += super.toWebGL(indent + ' ', ctx);
-        str += `${indent}} while(${unbracket(this.condition.toWebGL(indent, ctx))});\n`;
-        return str;
+        throw new Error(`No do-while() loop support for WebGL1.0 device`);
     }
     toWebGL2(indent, ctx) {
         let str = `${indent}do {\n`;
@@ -2015,8 +2027,10 @@ function unbracket(e) {
         }
     }
     toWebGL(indent, ctx) {
-        let str = `${indent}while(${unbracket(this.condition.toWebGL(indent, ctx))}) {\n`;
-        str += super.toWebGL(indent + '  ', ctx);
+        let str = `${indent}for(int z_tmp_counter = 0; z_tmp_counter == 0; z_tmp_counter += 0) {\n`;
+        const indent2 = indent + '  ';
+        str += `${indent2}if(!(${unbracket(this.condition.toWebGL(indent, ctx))})){ break; }\n`;
+        str += super.toWebGL(indent2, ctx);
         str += `${indent}}\n`;
         return str;
     }
@@ -2131,5 +2145,5 @@ function convertArgs(args, overload) {
     };
 }
 
-export { ASTAddressOf, ASTArrayIndex, ASTAssignment, ASTBinaryFunc, ASTBreak, ASTCallFunction, ASTCast, ASTContinue, ASTDeclareVar, ASTDiscard, ASTDoWhile, ASTExpression, ASTFunction, ASTFunctionParameter, ASTGlobalScope, ASTHash, ASTIf, ASTLValue, ASTLValueArray, ASTLValueDeclare, ASTLValueHash, ASTLValueScalar, ASTNakedScope, ASTPrimitive, ASTRange, ASTReferenceOf, ASTReturn, ASTScalar, ASTScope, ASTSelect, ASTShaderExpConstructor, ASTStructDefine, ASTTouch, ASTUnaryFunc, ASTWhile, DeclareType, ShaderAST, ShaderPrecisionType, builtinVariables, genSamplerName, getBuiltinInputStructInstanceName, getBuiltinInputStructName, getBuiltinOutputStructInstanceName, getBuiltinOutputStructName, getTextureSampleType };
+export { ASTAddressOf, ASTArrayIndex, ASTAssignment, ASTBinaryFunc, ASTBreak, ASTCallFunction, ASTCast, ASTContinue, ASTDeclareVar, ASTDiscard, ASTDoWhile, ASTExpression, ASTFunction, ASTFunctionParameter, ASTGlobalScope, ASTHash, ASTIf, ASTLValue, ASTLValueArray, ASTLValueDeclare, ASTLValueHash, ASTLValueScalar, ASTNakedScope, ASTPrimitive, ASTRange, ASTReferenceOf, ASTReturn, ASTScalar, ASTScope, ASTSelect, ASTShaderExpConstructor, ASTStructDefine, ASTTouch, ASTUnaryFunc, ASTWhile, DeclareType, ShaderAST, ShaderPrecisionType, builtinVariables, genSamplerName, getBuiltinInputStructInstanceName, getBuiltinInputStructName, getBuiltinOutputStructInstanceName, getBuiltinOutputStructName, getBuiltinParamName, getTextureSampleType };
 //# sourceMappingURL=ast.js.map

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

@@ -1,4 +1,4 @@
-import { ShaderPrecisionType, ASTPrimitive, DeclareType, getTextureSampleType, ASTArrayIndex, ASTScalar, ASTCast, ASTAssignment, ASTLValueArray, ASTLValueScalar, ASTHash, ASTLValueHash, ASTShaderExpConstructor } from './ast.js';
+import { ShaderPrecisionType, ASTPrimitive, DeclareType, getTextureSampleType, ASTArrayIndex, ASTScalar, ASTCast, ASTAssignment, ASTLValueArray, ASTLValueScalar, ASTShaderExpConstructor, ASTHash, ASTLValueHash } from './ast.js';
 import { PBPointerTypeInfo, PBAddressSpace, PBArrayTypeInfo, PBPrimitiveType, PBPrimitiveTypeInfo, typeI32 } from './types.js';
 import { PBASTError } from './errors.js';
 
@@ -326,6 +326,12 @@ let uidExp = 0;
         return this;
     }
     /**
+   * Whether this is a constructor
+   * @returns true if this is a constructor
+   */ isConstructor() {
+        return this.$ast instanceof ASTShaderExpConstructor && this.$ast.args.length === 0;
+    }
+    /**
    * Determine if this variable is of vector type
    * @returns true if the variable is of vector type, otherwise false
    */ isVector() {

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

@@ -3632,6 +3632,10 @@ const builtinFunctionsAll = {
             if (!texType.isTextureType()) {
                 throw new PBParamTypeError('textureSampleLevel', 'texture');
             }
+            if (pb.getDevice().type === 'webgl' && pb.shaderKind === 'vertex') {
+                // WebGL1 does not support vertex texture lod
+                return pb.textureSample(tex, args[1]);
+            }
             if (pb.getDevice().type === 'webgpu') {
                 if (texType.isExternalTexture()) {
                     return pb.textureLoad(tex, pb.ivec2(args[1]), 0);

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

@@ -2,7 +2,7 @@ import { ShaderType } from '../base_types.js';
 import { MAX_BINDING_GROUPS, getVertexAttribByName } from '../gpuobject.js';
 import { PBReflection } from './reflection.js';
 import { setCurrentProgramBuilder, PBShaderExp, getCurrentProgramBuilder, makeConstructor, Proxiable } from './base.js';
-import { ASTAddressOf, ASTReferenceOf, ASTStructDefine, ASTShaderExpConstructor, getBuiltinInputStructName, getBuiltinOutputStructName, getBuiltinInputStructInstanceName, getBuiltinOutputStructInstanceName, builtinVariables, ASTDeclareVar, ASTScalar, ASTDiscard, DeclareType, ASTPrimitive, ASTAssignment, ASTLValueScalar, genSamplerName, ASTCallFunction, ASTTouch, ASTLValueDeclare, ASTGlobalScope, ASTFunctionParameter, ASTFunction, ASTScope, ASTReturn, ASTNakedScope, ASTIf, ASTSelect, ASTBreak, ASTContinue, ASTRange, ASTDoWhile, ASTWhile } from './ast.js';
+import { ASTAddressOf, ASTReferenceOf, ASTStructDefine, ASTShaderExpConstructor, getBuiltinInputStructName, getBuiltinOutputStructName, getBuiltinInputStructInstanceName, getBuiltinOutputStructInstanceName, builtinVariables, ASTDeclareVar, getBuiltinParamName, ASTScalar, ASTDiscard, DeclareType, ASTPrimitive, ASTAssignment, ASTLValueScalar, genSamplerName, ASTCallFunction, ASTTouch, ASTLValueDeclare, ASTGlobalScope, ASTFunctionParameter, ASTFunction, ASTScope, ASTReturn, ASTNakedScope, ASTIf, ASTSelect, ASTBreak, ASTContinue, ASTRange, ASTDoWhile, ASTWhile } from './ast.js';
 import { PBDeviceNotSupport, PBReferenceValueRequired, PBPointerValueRequired, PBParamValueError, PBInternalError, PBParamLengthError, PBParamTypeError, PBTypeCastError, PBValueOutOfRange, PBError, PBNonScopedFunctionCall, PBASTError } from './errors.js';
 import { setBuiltinFuncs } from './builtinfunc.js';
 import { setConstructors } from './constructors.js';
@@ -16,9 +16,9 @@ const SHARED_UNIFORM_NAME = 'ch_shared_uniform_block';
 const VERTEX_STORAGE_NAME = 'ch_vertex_storage_block';
 const FRAGMENT_STORAGE_NAME = 'ch_fragment_storage_block';
 const SHARED_STORAGE_NAME = 'ch_shared_storage_block';
-const input_prefix = 'uu_in_';
-const output_prefix_vs = 'uu_vsout_';
-const output_prefix_fs = 'uu_fsout_';
+const input_prefix = 'zVSInput_';
+const output_prefix_vs = 'zVSOutput_';
+const output_prefix_fs = 'zFSOutput_';
 /**
  * The program builder class
  * @public
@@ -134,6 +134,13 @@ const output_prefix_fs = 'uu_fsout_';
     /** Gets the current scope */ getCurrentScope() {
         return this._scopeStack[0];
     }
+    /** Gets the current function scope */ getCurrentFunctionScope() {
+        let funcScope = this.getCurrentScope();
+        while(funcScope && !(funcScope instanceof PBFunctionScope)){
+            funcScope = funcScope.$parent;
+        }
+        return funcScope;
+    }
     /**
    * Generates shader codes for a render program
    * @param options - The build options
@@ -289,7 +296,7 @@ const output_prefix_fs = 'uu_fsout_';
         return true;
     }
     /** @internal */ generateStructureName() {
-        return `uu_GeneratedStruct${this._autoStructureTypeIndex++}`;
+        return `zStruct${this._autoStructureTypeIndex++}`;
     }
     /** @internal */ getVertexAttributes() {
         return this._vertexAttributes;
@@ -533,7 +540,7 @@ const output_prefix_fs = 'uu_fsout_';
                 const structType = this.internalDefineStructByType(this._shaderType, false, new PBStructTypeInfo(structName, 'default', args));
                 this.findStructType(structName, shaderType).prefix = prefix;
                 const structInstance = this.struct(structName, instanceName);
-                const structInstanceIN = inOrOut === 'in' ? this.struct(structName, 'uu_AppInput') : structInstance;
+                const structInstanceIN = inOrOut === 'in' ? this.struct(structName, getBuiltinParamName(shaderType)) : structInstance;
                 return [
                     structType,
                     structInstance,
@@ -665,23 +672,35 @@ const output_prefix_fs = 'uu_fsout_';
     }
     /** @internal */ in(location, name, variable) {
         if (this._inputs[location]) {
-            throw new Error(`input location ${location} already declared`);
-        }
-        variable.$location = location;
-        variable.$declareType = DeclareType.DECLARE_TYPE_IN;
-        this._inputs[location] = [
-            name,
-            new ASTDeclareVar(new ASTPrimitive(variable))
-        ];
-        Object.defineProperty(this._inputScope, name, {
-            get: function() {
-                return variable;
-            },
-            set: function() {
-                throw new Error(`cannot assign to readonly variable: ${name}`);
+            // input already exists, create an alias
+            if (!this._inputScope[name]) {
+                Object.defineProperty(this._inputScope, name, {
+                    get: function() {
+                        return variable;
+                    },
+                    set: function() {
+                        throw new Error(`cannot assign to readonly variable: ${name}`);
+                    }
+                });
             }
-        });
-        variable.$tags.forEach((val)=>this.tagShaderExp(()=>variable, val));
+        //throw new Error(`input location ${location} already declared`);
+        } else {
+            variable.$location = location;
+            variable.$declareType = DeclareType.DECLARE_TYPE_IN;
+            this._inputs[location] = [
+                name,
+                new ASTDeclareVar(new ASTPrimitive(variable))
+            ];
+            Object.defineProperty(this._inputScope, name, {
+                get: function() {
+                    return variable;
+                },
+                set: function() {
+                    throw new Error(`cannot assign to readonly variable: ${name}`);
+                }
+            });
+            variable.$tags.forEach((val)=>this.tagShaderExp(()=>variable, val));
+        }
     }
     /** @internal */ out(location, name, variable) {
         if (this._outputs[location]) {
@@ -900,6 +919,11 @@ const output_prefix_fs = 'uu_fsout_';
         }
         body && body.call(this._globalScope, this);
         this.popScope();
+        // Global delcarations should be at the first
+        this._globalScope.$ast.statements = [
+            ...this._globalScope.$ast.statements.filter((val)=>val instanceof ASTDeclareVar || val instanceof ASTAssignment),
+            ...this._globalScope.$ast.statements.filter((val)=>!(val instanceof ASTDeclareVar) && !(val instanceof ASTAssignment))
+        ];
     }
     /** @internal */ generateRenderSource(shaderType, scope, builtinScope, inputs, outputs) {
         const context = {
@@ -1493,7 +1517,7 @@ const output_prefix_fs = 'uu_fsout_';
    * @param semantic - The vertex semantic
    * @returns The input vertex attribute or null if not exists
    */ $getVertexAttrib(semantic) {
-        return getCurrentProgramBuilder().getReflection().attribute(semantic);
+        return this.$inputs.$getVertexAttrib(semantic); // getCurrentProgramBuilder().getReflection().attribute(semantic);
     }
     /** Get the current local scope */ get $l() {
         return this.$_getLocalScope();
@@ -1744,6 +1768,11 @@ const output_prefix_fs = 'uu_fsout_';
             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) {
+            // We are setting uniform a uniform, should invoke in the global scope
+            this.$g[prop] = value;
+            return true;
+        }
         const val = this.$_scope.$localGet(prop);
         if (val === undefined) {
             const type = getCurrentProgramBuilder().guessExpValueType(value);
@@ -1816,6 +1845,9 @@ const output_prefix_fs = 'uu_fsout_';
             const v = builtinVariables[pb.getDevice().type];
             const info = v[name];
             const inout = info.inOrOut;
+            if (inout === 'in') {
+                return pb.getCurrentFunctionScope()[getBuiltinParamName(pb.shaderType)][info.name];
+            }
             const structName = inout === 'in' ? getBuiltinInputStructInstanceName(pb.shaderType) : getBuiltinOutputStructInstanceName(pb.shaderType);
             const scope = pb.getCurrentScope();
             if (!scope[structName] || !scope[structName][info.name]) {
@@ -1835,18 +1867,46 @@ const output_prefix_fs = 'uu_fsout_';
  * The input scope of a shader
  * @public
  */ class PBInputScope extends PBScope {
+    /** @internal */ $_names;
+    $_aliases;
     /** @internal */ constructor(){
         super(null);
+        this.$_names = {};
+        this.$_aliases = {};
+    }
+    /** @internal */ $getVertexAttrib(attrib) {
+        const name = this.$_names[attrib];
+        return name ? this[name] : null;
     }
     /** @internal */ $_getLocalScope() {
         return null;
     }
+    /** @internal */ $get(prop) {
+        if (prop[0] === '$') {
+            return this[prop];
+        }
+        if (this.$_aliases[prop]) {
+            prop = this.$_aliases[prop];
+        }
+        const pb = this.$builder;
+        if (pb.getDevice().type === 'webgpu') {
+            const param = pb.getCurrentFunctionScope()[getBuiltinParamName(pb.shaderType)];
+            const prefix = pb.shaderKind === 'vertex' ? input_prefix : output_prefix_vs;
+            const name = `${prefix}${prop}`;
+            if (param.$typeinfo.structMembers.findIndex((val)=>val.name === name) < 0) {
+                return undefined;
+            }
+            return param[`${prefix}${prop}`];
+        }
+        return super.$get(prop);
+    }
     /** @internal */ $set(prop, value) {
         if (prop[0] === '$') {
             this[prop] = value;
-        } else if (prop in this) {
-            throw new Error(`Can not assign to shader input variable: "${prop}"`);
         } else {
+            if (!(value instanceof PBShaderExp)) {
+                throw new Error(`invalid vertex input value`);
+            }
             const st = getCurrentProgramBuilder().shaderType;
             if (st !== ShaderType.Vertex) {
                 throw new Error(`shader input variables can only be declared in vertex shader: "${prop}"`);
@@ -1856,7 +1916,15 @@ const output_prefix_fs = 'uu_fsout_';
                 throw new Error(`can not declare shader input variable: invalid vertex attribute: "${prop}"`);
             }
             if (getCurrentProgramBuilder()._vertexAttributes.indexOf(attrib) >= 0) {
-                throw new Error(`can not declare shader input variable: attribute already declared: "${prop}"`);
+                const lastName = this.$_names[value.$attrib];
+                if (prop !== lastName) {
+                    const p = this[lastName];
+                    if (p.$typeinfo.typeId !== value.$typeinfo.typeId) {
+                        throw new Error(`can not declare shader input variable: attribute already declared with different type: "${prop}"`);
+                    }
+                    this.$_aliases[prop] = lastName;
+                }
+                return true;
             }
             if (!(value instanceof PBShaderExp) || !(value.$ast instanceof ASTShaderExpConstructor)) {
                 throw new Error(`invalid shader input variable declaration: "${prop}"`);
@@ -1865,11 +1933,12 @@ const output_prefix_fs = 'uu_fsout_';
             if (!type.isPrimitiveType() || type.isMatrixType() || type.primitiveType === PBPrimitiveType.BOOL) {
                 throw new Error(`type cannot be used as pipeline input/output: ${prop}`);
             }
+            this.$_names[value.$attrib] = prop;
             const location = getCurrentProgramBuilder()._inputs.length;
             const exp = new PBShaderExp(`${input_prefix}${prop}`, type).tag(...value.$tags);
             getCurrentProgramBuilder().in(location, prop, exp);
             getCurrentProgramBuilder()._vertexAttributes.push(attrib);
-            getCurrentProgramBuilder().getReflection().setAttrib(value.$attrib, exp);
+            //getCurrentProgramBuilder().getReflection().setAttrib(value.$attrib, exp);
             // modify input struct for webgpu
             if (getCurrentProgramBuilder().getDevice().type === 'webgpu') {
                 if (getCurrentProgramBuilder().findStructType(getBuiltinInputStructName(st), st)) {
@@ -1927,30 +1996,43 @@ const output_prefix_fs = 'uu_fsout_';
  * The global scope of a shader
  * @public
  */ class PBGlobalScope extends PBScope {
+    /** @internal */ $_inputStructInfo;
     /** @internal */ constructor(){
         super(new ASTGlobalScope());
+        this.$_inputStructInfo = null;
+    }
+    /** @internal */ get $inputStructInfo() {
+        if (!this.$_inputStructInfo) {
+            this.$_inputStructInfo = this.$builder.defineBuiltinStruct(this.$builder.shaderType, 'in');
+        }
+        return this.$_inputStructInfo;
+    }
+    /** @internal */ get $inputStruct() {
+        return this.$inputStructInfo[0];
     }
     /** @internal */ $mainFunc(body) {
         const pb = getCurrentProgramBuilder();
         if (pb.getDevice().type === 'webgpu') {
-            const inputStruct = pb.defineBuiltinStruct(pb.shaderType, 'in');
-            this.$local(inputStruct[1]);
+            const inputStruct = this.$inputStructInfo;
+            //this.$local(inputStruct[1]);
             const isCompute = pb.shaderType === ShaderType.Compute;
             const outputStruct = isCompute ? null : pb.defineBuiltinStruct(pb.shaderType, 'out');
-            if (!isCompute) {
+            if (outputStruct) {
                 this.$local(outputStruct[1]);
             }
-            this.$internalCreateFunction('chMainStub', [], false, body);
+            // this.$internalCreateFunction('chMainStub', [], false, body);
             this.$internalCreateFunction('main', inputStruct ? [
                 inputStruct[3]
             ] : [], true, function() {
-                if (inputStruct) {
-                    this[inputStruct[1].$str] = this[inputStruct[3].$str];
-                }
-                if (pb.shaderType === ShaderType.Fragment && pb.emulateDepthClamp) {
+                /*
+          if (inputStruct) {
+            this[inputStruct[1].$str] = this[inputStruct[3].$str];
+          }
+          */ if (pb.shaderType === ShaderType.Fragment && pb.emulateDepthClamp) {
                     this.$builtins.fragDepth = pb.clamp(this.$inputs.clamppedDepth, 0, 1);
                 }
-                this.chMainStub();
+                body?.call(this);
+                //this.chMainStub();
                 if (pb.shaderType === ShaderType.Vertex) {
                     if (pb.depthRangeCorrection) {
                         this.$builtins.position.z = pb.mul(pb.add(this.$builtins.position.z, this.$builtins.position.w), 0.5);
@@ -1996,6 +2078,9 @@ const output_prefix_fs = 'uu_fsout_';
     }
     /** @internal */ $internalCreateFunction(name, params, isMain, body) {
         const pb = getCurrentProgramBuilder();
+        if (pb.getDevice().type === 'webgpu' && !isMain) {
+            params.push(this.$inputStruct(getBuiltinParamName(pb.shaderType)));
+        }
         params.forEach((param)=>{
             if (!(param.$ast instanceof ASTPrimitive)) {
                 throw new Error(`${name}(): invalid function definition`);
@@ -2055,7 +2140,21 @@ const output_prefix_fs = 'uu_fsout_';
                         throw new Error(`function ${name} not found`);
                     }
                     return (...args)=>{
-                        const argsNonArray = args.map((val)=>pb.normalizeExpValue(val));
+                        let inputArg = null;
+                        if (pb.getDevice().type === 'webgpu') {
+                            let funcScope = pb.getCurrentScope();
+                            while(funcScope && !(funcScope instanceof PBFunctionScope)){
+                                funcScope = funcScope.$parent;
+                            }
+                            const funcArgs = funcScope.$ast.args;
+                            const arg = funcArgs[funcArgs.length - 1].paramAST;
+                            const name = arg.name;
+                            inputArg = funcScope[name];
+                        }
+                        const argsNonArray = (inputArg ? [
+                            ...args,
+                            inputArg
+                        ] : args).map((val)=>pb.normalizeExpValue(val));
                         const funcType = pb._getFunctionOverload(name, argsNonArray);
                         if (!funcType) {
                             throw new Error(`ERROR: no matching overloads for function ${name}`);
@@ -2193,6 +2292,9 @@ const output_prefix_fs = 'uu_fsout_';
    * @param body - Generator function for the scope that inside the do..while statment
    * @returns The scope that inside the do..while statement
    */ $do(body) {
+        if (this.$builder.getDevice().type === 'webgl') {
+            throw new Error(`No do-while() loop support for WebGL1.0 device`);
+        }
         const astDoWhile = new ASTDoWhile(null);
         this.$ast.statements.push(astDoWhile);
         return new PBDoWhileScope(this, astDoWhile, body);
@@ -2233,6 +2335,9 @@ const output_prefix_fs = 'uu_fsout_';
         body && body.call(this);
         getCurrentProgramBuilder().popScope();
     }
+    $isMain() {
+        return this.$ast.isMainFunc;
+    }
 }
 /**
  * Scope that insides a while statement

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

@@ -334,23 +334,23 @@ const textureTypeMapWGSL = {
     [PBTextureType.TEX_EXTERNAL]: 'texture_external'
 };
 const storageTexelFormatMap = {
-    'rgba8unorm': 'rgba8unorm',
-    'rgba8snorm': 'rgba8snorm',
-    'bgra8unorm': 'bgra8unorm',
-    'rgba8ui': 'rgba8uint',
-    'rgba8i': 'rgba8sint',
-    'rgba16ui': 'rgba16uint',
-    'rgba16i': 'rgba16sint',
-    'rgba16f': 'rgba16float',
-    'r32f': 'r32float',
-    'r32ui': 'r32uint',
-    'r32i': 'r32sint',
-    'rg32f': 'rg32float',
-    'rg32ui': 'rg32uint',
-    'rg32i': 'rg32sint',
-    'rgba32f': 'rgba32float',
-    'rgba32ui': 'rgba32uint',
-    'rgba32i': 'rgba32sint'
+    rgba8unorm: 'rgba8unorm',
+    rgba8snorm: 'rgba8snorm',
+    bgra8unorm: 'bgra8unorm',
+    rgba8ui: 'rgba8uint',
+    rgba8i: 'rgba8sint',
+    rgba16ui: 'rgba16uint',
+    rgba16i: 'rgba16sint',
+    rgba16f: 'rgba16float',
+    r32f: 'r32float',
+    r32ui: 'r32uint',
+    r32i: 'r32sint',
+    rg32f: 'rg32float',
+    rg32ui: 'rg32uint',
+    rg32i: 'rg32sint',
+    rgba32f: 'rgba32float',
+    rgba32ui: 'rgba32uint',
+    rgba32i: 'rgba32sint'
 };
 var PBSamplerAccessMode;
 (function(PBSamplerAccessMode) {

package/dist/helpers/font.js

@@ -36,9 +36,9 @@
     }
 }
 /**
-   * The font class
-   * @public
-   */ class Font {
+ * The font class
+ * @public
+ */ class Font {
     /** @internal */ static fontCache = {};
     /** @internal */ _name;
     /** @internal */ _nameScaled;
@@ -51,10 +51,10 @@
     /** @internal */ _bottomScaled;
     /** @internal */ _div;
     /**
-     * Creates a instance of font class from font name and the scale value
-     * @param name - The font name
-     * @param scale - The scale value
-     */ constructor(name, scale){
+   * Creates a instance of font class from font name and the scale value
+   * @param name - The font name
+   * @param scale - The scale value
+   */ constructor(name, scale){
         this._top = 0;
         this._bottom = 0;
         this._size = 0;
@@ -70,11 +70,11 @@
         }
     }
     /**
-     * Fetch a font from cache
-     * @param name - The font name
-     * @param scale - The scale value
-     * @returns The font object
-     */ static fetchFont(name, scale) {
+   * Fetch a font from cache
+   * @param name - The font name
+   * @param scale - The scale value
+   * @returns The font object
+   */ static fetchFont(name, scale) {
         let fontlist = this.fontCache[name];
         if (!fontlist) {
             fontlist = {};

package/dist/helpers/glyphmanager.js

@@ -56,7 +56,7 @@ import { TextureAtlasManager } from './textureatlas.js';
    * @param charMargin - Margin size between characters
    * @param start - Start index of the string to be clipped
    * @param font - Font of the string
-   * @returns 
+   * @returns
    */ clipStringToWidth(str, width, charMargin, start, font) {
         let sum = 0;
         let i = start;

package/dist/index.d.ts

@@ -273,11 +273,11 @@ declare abstract class PBTypeInfo<DetailType extends TypeDetailInfo = TypeDetail
      */
     isCompatibleType(other: PBTypeInfo): boolean;
     /**
-    * Creates a buffer layout from this type
-    * @param offset - Byte offset of the layout
-    * @param layout - Type of the layout
-    * @returns The created buffer layout
-    */
+     * Creates a buffer layout from this type
+     * @param offset - Byte offset of the layout
+     * @param layout - Type of the layout
+     * @returns The created buffer layout
+     */
     abstract toBufferLayout(offset: number, layout: PBStructLayout): UniformBufferLayout;
 }
 /**
@@ -1282,6 +1282,11 @@ declare class PBShaderExp extends Proxiable<PBShaderExp> {
      * @returns self
      */
     lowp(): PBShaderExp;
+    /**
+     * Whether this is a constructor
+     * @returns true if this is a constructor
+     */
+    isConstructor(): boolean;
     /**
      * Determine if this variable is of vector type
      * @returns true if the variable is of vector type, otherwise false
@@ -2102,6 +2107,8 @@ declare class ProgramBuilder {
     set emulateDepthClamp(val: boolean);
     /** Get the shader code reflection interface */
     getReflection(): PBReflection;
+    /** Gets the current function scope */
+    getCurrentFunctionScope(): PBFunctionScope;
 }
 /**
  * Base class for scope of the shader program
@@ -2178,6 +2185,7 @@ declare class PBBuiltinScope extends PBScope {
  * @public
  */
 declare class PBInputScope extends PBScope {
+    private $_aliases;
 }
 /**
  * The output scope of a shader
@@ -2253,6 +2261,7 @@ declare class PBInsideFunctionScope extends PBScope {
  * @public
  */
 declare class PBFunctionScope extends PBInsideFunctionScope {
+    $isMain(): boolean;
 }
 /**
  * Scope that insides a while statement

package/dist/index.js

@@ -3,7 +3,7 @@ export { VertexData } from './vertexdata.js';
 export { GPUResourceUsageFlags, MAX_BINDING_GROUPS, MAX_TEXCOORD_INDEX_COUNT, MAX_VERTEX_ATTRIBUTES, VERTEX_ATTRIB_BLEND_INDICES, VERTEX_ATTRIB_BLEND_WEIGHT, VERTEX_ATTRIB_DIFFUSE, VERTEX_ATTRIB_NORMAL, VERTEX_ATTRIB_POSITION, VERTEX_ATTRIB_TANGENT, VERTEX_ATTRIB_TEXCOORD0, VERTEX_ATTRIB_TEXCOORD1, VERTEX_ATTRIB_TEXCOORD2, VERTEX_ATTRIB_TEXCOORD3, VERTEX_ATTRIB_TEXCOORD4, VERTEX_ATTRIB_TEXCOORD5, VERTEX_ATTRIB_TEXCOORD6, VERTEX_ATTRIB_TEXCOORD7, genDefaultName, getVertexAttribByName, getVertexAttribFormat, getVertexAttribName, getVertexBufferAttribType, getVertexBufferAttribTypeBySemantic, getVertexBufferLength, getVertexBufferStride, getVertexFormatSize, makeVertexBufferType, semanticList, semanticToAttrib } from './gpuobject.js';
 export { BaseDevice } from './device.js';
 export { PBShaderExp, Proxiable, getCurrentProgramBuilder, makeConstructor, setCurrentProgramBuilder } from './builder/base.js';
-export { ASTAddressOf, ASTArrayIndex, ASTAssignment, ASTBinaryFunc, ASTBreak, ASTCallFunction, ASTCast, ASTContinue, ASTDeclareVar, ASTDiscard, ASTDoWhile, ASTExpression, ASTFunction, ASTFunctionParameter, ASTGlobalScope, ASTHash, ASTIf, ASTLValue, ASTLValueArray, ASTLValueDeclare, ASTLValueHash, ASTLValueScalar, ASTNakedScope, ASTPrimitive, ASTRange, ASTReferenceOf, ASTReturn, ASTScalar, ASTScope, ASTSelect, ASTShaderExpConstructor, ASTStructDefine, ASTTouch, ASTUnaryFunc, ASTWhile, DeclareType, ShaderAST, ShaderPrecisionType, builtinVariables, genSamplerName, getBuiltinInputStructInstanceName, getBuiltinInputStructName, getBuiltinOutputStructInstanceName, getBuiltinOutputStructName, getTextureSampleType } from './builder/ast.js';
+export { ASTAddressOf, ASTArrayIndex, ASTAssignment, ASTBinaryFunc, ASTBreak, ASTCallFunction, ASTCast, ASTContinue, ASTDeclareVar, ASTDiscard, ASTDoWhile, ASTExpression, ASTFunction, ASTFunctionParameter, ASTGlobalScope, ASTHash, ASTIf, ASTLValue, ASTLValueArray, ASTLValueDeclare, ASTLValueHash, ASTLValueScalar, ASTNakedScope, ASTPrimitive, ASTRange, ASTReferenceOf, ASTReturn, ASTScalar, ASTScope, ASTSelect, ASTShaderExpConstructor, ASTStructDefine, ASTTouch, ASTUnaryFunc, ASTWhile, DeclareType, ShaderAST, ShaderPrecisionType, builtinVariables, genSamplerName, getBuiltinInputStructInstanceName, getBuiltinInputStructName, getBuiltinOutputStructInstanceName, getBuiltinOutputStructName, getBuiltinParamName, getTextureSampleType } from './builder/ast.js';
 export { PBBuiltinScope, PBDoWhileScope, PBForScope, PBFunctionScope, PBGlobalScope, PBIfScope, PBInputScope, PBInsideFunctionScope, PBLocalScope, PBNakedScope, PBOutputScope, PBScope, PBWhileScope, ProgramBuilder } from './builder/programbuilder.js';
 export { PBAddressSpace, PBAnyTypeInfo, PBArrayTypeInfo, PBAtomicI32TypeInfo, PBAtomicU32TypeInfo, PBFunctionTypeInfo, PBPointerTypeInfo, PBPrimitiveType, PBPrimitiveTypeInfo, PBSamplerAccessMode, PBSamplerTypeInfo, PBStructTypeInfo, PBTextureType, PBTextureTypeInfo, PBTypeInfo, PBVoidTypeInfo, typeAny, typeAtomicI32, typeAtomicU32, typeBVec2, typeBVec3, typeBVec4, typeBool, typeF16, typeF16Vec2, typeF16Vec3, typeF16Vec4, typeF32, typeF32Vec2, typeF32Vec3, typeF32Vec4, typeFrexpResult, typeFrexpResultVec2, typeFrexpResultVec3, typeFrexpResultVec4, typeI16, typeI16Vec2, typeI16Vec2_Norm, typeI16Vec3, typeI16Vec3_Norm, typeI16Vec4, typeI16Vec4_Norm, typeI16_Norm, typeI32, typeI32Vec2, typeI32Vec2_Norm, typeI32Vec3, typeI32Vec3_Norm, typeI32Vec4, typeI32Vec4_Norm, typeI32_Norm, typeI8, typeI8Vec2, typeI8Vec2_Norm, typeI8Vec3, typeI8Vec3_Norm, typeI8Vec4, typeI8Vec4_Norm, typeI8_Norm, typeITex1D, typeITex2D, typeITex2DArray, typeITex3D, typeITexCube, typeITexCubeArray, typeITexMultisampled2D, typeMat2, typeMat2x3, typeMat2x4, typeMat3, typeMat3x2, typeMat3x4, typeMat4, typeMat4x2, typeMat4x3, typeSampler, typeSamplerComparison, typeTex1D, typeTex2D, typeTex2DArray, typeTex3D, typeTexCube, typeTexCubeArray, typeTexDepth2D, typeTexDepth2DArray, typeTexDepthCube, typeTexDepthCubeArray, typeTexDepthMultisampled2D, typeTexExternal, typeTexMultisampled2D, typeTexStorage1D_bgra8unorm, typeTexStorage1D_r32float, typeTexStorage1D_r32sint, typeTexStorage1D_r32uint, typeTexStorage1D_rg32float, typeTexStorage1D_rg32sint, typeTexStorage1D_rg32uint, typeTexStorage1D_rgba16float, typeTexStorage1D_rgba16sint, typeTexStorage1D_rgba16uint, typeTexStorage1D_rgba32float, typeTexStorage1D_rgba32sint, typeTexStorage1D_rgba32uint, typeTexStorage1D_rgba8sint, typeTexStorage1D_rgba8snorm, typeTexStorage1D_rgba8uint, typeTexStorage1D_rgba8unorm, typeTexStorage2DArray_bgra8unorm, typeTexStorage2DArray_r32float, typeTexStorage2DArray_r32sint, typeTexStorage2DArray_r32uint, typeTexStorage2DArray_rg32float, typeTexStorage2DArray_rg32sint, typeTexStorage2DArray_rg32uint, typeTexStorage2DArray_rgba16float, typeTexStorage2DArray_rgba16sint, typeTexStorage2DArray_rgba16uint, typeTexStorage2DArray_rgba32float, typeTexStorage2DArray_rgba32sint, typeTexStorage2DArray_rgba32uint, typeTexStorage2DArray_rgba8sint, typeTexStorage2DArray_rgba8snorm, typeTexStorage2DArray_rgba8uint, typeTexStorage2DArray_rgba8unorm, typeTexStorage2D_bgra8unorm, typeTexStorage2D_r32float, typeTexStorage2D_r32sint, typeTexStorage2D_r32uint, typeTexStorage2D_rg32float, typeTexStorage2D_rg32sint, typeTexStorage2D_rg32uint, typeTexStorage2D_rgba16float, typeTexStorage2D_rgba16sint, typeTexStorage2D_rgba16uint, typeTexStorage2D_rgba32float, typeTexStorage2D_rgba32sint, typeTexStorage2D_rgba32uint, typeTexStorage2D_rgba8sint, typeTexStorage2D_rgba8snorm, typeTexStorage2D_rgba8uint, typeTexStorage2D_rgba8unorm, typeTexStorage3D_bgra8unorm, typeTexStorage3D_r32float, typeTexStorage3D_r32sint, typeTexStorage3D_r32uint, typeTexStorage3D_rg32float, typeTexStorage3D_rg32sint, typeTexStorage3D_rg32uint, typeTexStorage3D_rgba16float, typeTexStorage3D_rgba16sint, typeTexStorage3D_rgba16uint, typeTexStorage3D_rgba32float, typeTexStorage3D_rgba32sint, typeTexStorage3D_rgba32uint, typeTexStorage3D_rgba8sint, typeTexStorage3D_rgba8snorm, typeTexStorage3D_rgba8uint, typeTexStorage3D_rgba8unorm, typeU16, typeU16Vec2, typeU16Vec2_Norm, typeU16Vec3, typeU16Vec3_Norm, typeU16Vec4, typeU16Vec4_Norm, typeU16_Norm, typeU32, typeU32Vec2, typeU32Vec2_Norm, typeU32Vec3, typeU32Vec3_Norm, typeU32Vec4, typeU32Vec4_Norm, typeU32_Norm, typeU8, typeU8Vec2, typeU8Vec2_Norm, typeU8Vec3, typeU8Vec3_Norm, typeU8Vec4, typeU8Vec4_Norm, typeU8_Norm, typeUTex1D, typeUTex2D, typeUTex2DArray, typeUTex3D, typeUTexCube, typeUTexCubeArray, typeUTexMultisampled2D, typeVoid } from './builder/types.js';
 export { PBReflection } from './builder/reflection.js';

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@zephyr3d/device",
-	"version": "0.1.2",
+	"version": "0.2.0",
 	"description": "base system for zephyr3d library",
 	"homepage": "https://github.com/gavinyork/zephyr3d#readme",
 	"type": "module",