@zephyr3d/device 0.1.0

package/dist/builder/programbuilder.js

@@ -0,0 +1,2323 @@
+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 { 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';
+import { PBStructTypeInfo, typeFrexpResult, typeFrexpResultVec2, typeFrexpResultVec3, typeFrexpResultVec4, PBPrimitiveType, typeBool, typeI32, typeU32, typeF32, PBArrayTypeInfo, typeTex2DArray, typeTex2D, typeTexCube, PBSamplerAccessMode, PBPointerTypeInfo, typeVoid, PBAddressSpace, PBFunctionTypeInfo } from './types.js';
+
+const COMPUTE_UNIFORM_NAME = 'ch_compute_uniform_block';
+const COMPUTE_STORAGE_NAME = 'ch_compute_storage_block';
+const VERTEX_UNIFORM_NAME = 'ch_vertex_uniform_block';
+const FRAGMENT_UNIFORM_NAME = 'ch_fragment_uniform_block';
+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_';
+/**
+ * The program builder class
+ * @public
+ */ class ProgramBuilder {
+    /** @internal */ _device;
+    /** @internal */ _workgroupSize;
+    /** @internal */ _scopeStack = [];
+    /** @internal */ _shaderType = ShaderType.Vertex | ShaderType.Fragment | ShaderType.Compute;
+    /** @internal */ _structInfo;
+    /** @internal */ _uniforms;
+    /** @internal */ _globalScope;
+    /** @internal */ _builtinScope;
+    /** @internal */ _inputScope;
+    /** @internal */ _outputScope;
+    /** @internal */ _inputs;
+    /** @internal */ _outputs;
+    /** @internal */ _vertexAttributes;
+    /** @internal */ _depthRangeCorrection;
+    /** @internal */ _emulateDepthClamp;
+    /** @internal */ _lastError;
+    /** @internal */ _reflection;
+    /** @internal */ _autoStructureTypeIndex;
+    /** @internal */ _nameMap;
+    /**
+   * Creates a program builder for given device
+   * @param device - The device
+   */ constructor(device){
+        this._device = device;
+        this._workgroupSize = null;
+        this._structInfo = {};
+        this._uniforms = [];
+        this._scopeStack = [];
+        this._globalScope = null;
+        this._builtinScope = null;
+        this._inputScope = null;
+        this._outputScope = null;
+        this._inputs = [];
+        this._outputs = [];
+        this._vertexAttributes = [];
+        this._depthRangeCorrection = device.type === 'webgpu';
+        this._emulateDepthClamp = false;
+        this._lastError = null;
+        this._reflection = new PBReflection(this);
+        this._autoStructureTypeIndex = 0;
+        this._nameMap = [];
+    }
+    /** Get last error */ get lastError() {
+        return this._lastError;
+    }
+    /** @internal */ get shaderType() {
+        return this._shaderType;
+    }
+    /** Current shader kind */ get shaderKind() {
+        return this._shaderType === ShaderType.Vertex ? 'vertex' : this._shaderType === ShaderType.Fragment ? 'fragment' : this._shaderType === ShaderType.Compute ? 'compute' : null;
+    }
+    /** Gets the global scope */ getGlobalScope() {
+        return this._globalScope;
+    }
+    /** @internal */ get builtinScope() {
+        return this._builtinScope;
+    }
+    /** @internal */ get inputScope() {
+        return this._inputScope;
+    }
+    /** @internal */ get outputScope() {
+        return this._outputScope;
+    }
+    /** @internal */ get depthRangeCorrection() {
+        return this._depthRangeCorrection;
+    }
+    get emulateDepthClamp() {
+        return this._emulateDepthClamp;
+    }
+    set emulateDepthClamp(val) {
+        this._emulateDepthClamp = val;
+    }
+    /** Get the shader code reflection interface */ getReflection() {
+        return this._reflection;
+    }
+    /** Get the device */ getDevice() {
+        return this._device;
+    }
+    /** @internal */ reset() {
+        this._workgroupSize = null;
+        this._structInfo = {};
+        this._uniforms = [];
+        this._scopeStack = [];
+        this._globalScope = null;
+        this._builtinScope = null;
+        this._inputScope = null;
+        this._outputScope = null;
+        this._inputs = [];
+        this._outputs = [];
+        this._vertexAttributes = [];
+        this._depthRangeCorrection = this._device.type === 'webgpu';
+        this._reflection = new PBReflection(this);
+        this._autoStructureTypeIndex = 0;
+        this._nameMap = [];
+    }
+    /**
+   * Query the global variable by the name
+   * @param name - Name of the variable
+   * @returns The variable or null if not exists
+   */ queryGlobal(name) {
+        return this.getReflection().tag(name);
+    }
+    /** @internal */ pushScope(scope) {
+        this._scopeStack.unshift(scope);
+    }
+    /** @internal */ popScope() {
+        return this._scopeStack.shift();
+    }
+    /** Gets the current scope */ getCurrentScope() {
+        return this._scopeStack[0];
+    }
+    /**
+   * Generates shader codes for a render program
+   * @param options - The build options
+   * @returns a tuple made by vertex shader source, fragment shader source, bind group layouts and vertex attributes used, or null if build faild
+   */ buildRender(options) {
+        setCurrentProgramBuilder(this);
+        this._lastError = null;
+        this.defineInternalStructs();
+        const ret = this.buildRenderSource(options);
+        setCurrentProgramBuilder(null);
+        this.reset();
+        return ret;
+    }
+    /**
+   * Generates shader code for a compute program
+   * @param options - The build programs
+   * @returns a tuple made by compute shader source and bind group layouts, or null if build failed
+   */ buildCompute(options) {
+        setCurrentProgramBuilder(this);
+        this._lastError = null;
+        this._workgroupSize = options.workgroupSize;
+        this.defineInternalStructs();
+        const ret = this.buildComputeSource(options);
+        setCurrentProgramBuilder(null);
+        this.reset();
+        return ret;
+    }
+    /**
+   * Creates a shader program for render
+   * @param options - The build options
+   * @returns The created program or null if build failed
+   */ buildRenderProgram(options) {
+        const ret = this.buildRender(options);
+        return ret ? this._device.createGPUProgram({
+            type: 'render',
+            label: options.label,
+            params: {
+                vs: ret[0],
+                fs: ret[1],
+                bindGroupLayouts: ret[2],
+                vertexAttributes: ret[3]
+            }
+        }) : null;
+    }
+    /**
+   * Creates a shader program for compute
+   * @param options - The build options
+   * @returns The created program or null if build failed
+   */ buildComputeProgram(options) {
+        const ret = this.buildCompute(options);
+        return ret ? this._device.createGPUProgram({
+            type: 'compute',
+            params: {
+                source: ret[0],
+                bindGroupLayouts: ret[1]
+            }
+        }) : null;
+    }
+    /**
+   * Creates a function
+   * @param name - Name of the function
+   * @param params - Parameters of the function
+   * @param body - The generator function
+   */ func(name, params, body) {
+        this.getGlobalScope().$createFunctionIfNotExists(name, params, body);
+    }
+    /**
+   * Create the main entry function of the shader
+   * @param body - The shader generator function
+   */ main(body) {
+        this.getGlobalScope().$mainFunc(body);
+    }
+    /**
+   * Create an 'AddressOf' expression for WGSL
+   * @param ref - The reference variable
+   * @returns the 'AddressOf' expression
+   */ addressOf(ref) {
+        if (this._device.type !== 'webgpu') {
+            throw new PBDeviceNotSupport('pointer shader type');
+        }
+        if (!ref.$ast.isReference()) {
+            throw new PBReferenceValueRequired(ref);
+        }
+        const exp = new PBShaderExp('', ref.$ast.getType());
+        exp.$ast = new ASTAddressOf(ref.$ast);
+        return exp;
+    }
+    /**
+   * Creates a 'referenceOf' expression for WGSL
+   * @param ptr - The pointer variable
+   * @returns the 'referenceOf' expression
+   */ referenceOf(ptr) {
+        if (this._device.type !== 'webgpu') {
+            throw new PBDeviceNotSupport('pointer shader type');
+        }
+        if (!ptr.$ast.getType().isPointerType()) {
+            throw new PBPointerValueRequired(ptr);
+        }
+        const ast = new ASTReferenceOf(ptr.$ast);
+        const exp = new PBShaderExp('', ast.getType());
+        exp.$ast = ast;
+        return exp;
+    }
+    /**
+   * Creates a structure type variable
+   * @param structName - Name of the structure type
+   * @param instanceName - Name of the variable
+   * @returns the created variable
+   */ struct(structName, instanceName) {
+        let ctor = null;
+        for (const st of [
+            ShaderType.Vertex,
+            ShaderType.Fragment,
+            ShaderType.Compute
+        ]){
+            if (st & this._shaderType) {
+                const structInfo = this._structInfo[st];
+                ctor = structInfo?.structs[structName];
+                if (ctor) {
+                    break;
+                }
+            }
+        }
+        if (!ctor) {
+            throw new PBParamValueError('struct', 'structName', `Struct type ${structName} not exists`);
+        }
+        return ctor.call(this, instanceName);
+    }
+    /** @internal */ isIdenticalStruct(a, b, checkName) {
+        if (checkName && a.structName && b.structName && a.structName !== b.structName) {
+            return false;
+        }
+        if (a.structMembers.length !== b.structMembers.length) {
+            return false;
+        }
+        for(let index = 0; index < a.structMembers.length; index++){
+            const val = a.structMembers[index];
+            const other = b.structMembers[index];
+            if (val.name !== other.name) {
+                return false;
+            }
+            if (val.type.isStructType()) {
+                if (!other.type.isStructType()) {
+                    return false;
+                }
+                if (!this.isIdenticalStruct(val.type, other.type, true)) {
+                    return false;
+                }
+            } else if (!val.type.isCompatibleType(other.type)) {
+                return false;
+            }
+        }
+        return true;
+    }
+    /** @internal */ generateStructureName() {
+        return `uu_GeneratedStruct${this._autoStructureTypeIndex++}`;
+    }
+    /** @internal */ getVertexAttributes() {
+        return this._vertexAttributes;
+    }
+    /** @internal */ defineHiddenStruct(type) {
+        for (const shaderType of [
+            ShaderType.Vertex,
+            ShaderType.Fragment,
+            ShaderType.Compute
+        ]){
+            let structInfo = this._structInfo[shaderType];
+            if (!structInfo) {
+                structInfo = {
+                    structs: {},
+                    types: []
+                };
+                this._structInfo[shaderType] = structInfo;
+            }
+            if (structInfo.structs[type.structName]) {
+                throw new PBParamValueError('defineStruct', 'structName', `cannot re-define struct '${type.structName}'`);
+            }
+            structInfo.types.push(new ASTStructDefine(type, true));
+        }
+    }
+    // /**
+    //  * Defines an uniform buffer
+    //  * @param name - Name of the uniform buffer
+    //  * @param args - Members of the buffer structure
+    //  * @returns The structure type constructor
+    //  */
+    // defineUniformBuffer(name: string, ...args: PBShaderExp[]): ShaderTypeFunc {
+    //   return this.defineStructOrUniformBuffer(name, 'std140', ...args);
+    // }
+    // /**
+    //  * Defines a structure type
+    //  * @param structName - Name of the type
+    //  * @param layout - The structure layout
+    //  * @param args - Members of the structure
+    //  * @returns The structure type constructor
+    //  */
+    // defineStruct(structName: string, ...args: PBShaderExp[]): ShaderTypeFunc {
+    //   return this.defineStructOrUniformBuffer(structName, 'default', ...args);
+    // }
+    /**
+   * Defines a structure type
+   * @param members - Members of the structure
+   * @param structName - Name of the type
+   * @returns The structure type constructor
+   */ defineStruct(members, structName) {
+        const layout = 'default';
+        const structType = new PBStructTypeInfo(structName ?? '', layout, members.map((arg)=>{
+            if (!arg.$typeinfo.isPrimitiveType() && !arg.$typeinfo.isArrayType() && !arg.$typeinfo.isStructType() && !arg.$typeinfo.isAtomicI32() && !arg.$typeinfo.isAtomicU32()) {
+                throw new Error(`invalid struct member type: '${arg.$str}'`);
+            }
+            return {
+                name: arg.$str,
+                type: arg.$typeinfo
+            };
+        }));
+        for (const shaderType of [
+            ShaderType.Vertex,
+            ShaderType.Fragment,
+            ShaderType.Compute
+        ]){
+            let structDef = null;
+            let ctor = null;
+            const structInfo = this._structInfo[shaderType];
+            if (structInfo) {
+                if (getCurrentProgramBuilder().shaderType === shaderType && structInfo.structs[structType.structName]) {
+                    throw new PBParamValueError('defineStruct', 'structName', `cannot re-define struct '${structType.structName}'`);
+                }
+                for (const type of structInfo.types){
+                    if (!type.builtin && this.isIdenticalStruct(type.getType(), structType, false)) {
+                        structDef = type;
+                        ctor = structInfo.structs[type.getType().structName];
+                        break;
+                    }
+                }
+            }
+            if (structDef) {
+                if (structDef.type.layout !== layout) {
+                    throw new Error(`Can not redefine struct ${structDef.type.structName} with different layout`);
+                }
+                if (shaderType !== getCurrentProgramBuilder().shaderType) {
+                    if (!this._structInfo[getCurrentProgramBuilder().shaderType]) {
+                        this._structInfo[getCurrentProgramBuilder().shaderType] = {
+                            structs: {},
+                            types: []
+                        };
+                    }
+                    if (this._structInfo[getCurrentProgramBuilder().shaderType].types.indexOf(structDef) < 0) {
+                        this._structInfo[getCurrentProgramBuilder().shaderType].types.push(structDef);
+                        this._structInfo[getCurrentProgramBuilder().shaderType].structs[structDef.getType().structName] = ctor;
+                    }
+                }
+                return ctor;
+            }
+        }
+        return this.internalDefineStruct(structName ?? this.generateStructureName(), layout, this._shaderType, false, ...members);
+    }
+    /**
+   * Defines a structure type
+   * @param structType - The structure type info
+   * @returns The structure type constructor
+   */ defineStructByType(structType) {
+        const typeCopy = structType.extends(structType.structName || this.generateStructureName(), []);
+        for (const shaderType of [
+            ShaderType.Vertex,
+            ShaderType.Fragment,
+            ShaderType.Compute
+        ]){
+            let structDef = null;
+            let ctor = null;
+            const structInfo = this._structInfo[shaderType];
+            if (structInfo) {
+                if (getCurrentProgramBuilder().shaderType === shaderType && structInfo.structs[typeCopy.structName]) {
+                    throw new PBParamValueError('defineStruct', 'structName', `cannot re-define struct '${typeCopy.structName}'`);
+                }
+                for (const type of structInfo.types){
+                    if (!type.builtin && this.isIdenticalStruct(type.getType(), typeCopy, false)) {
+                        structDef = type;
+                        ctor = structInfo.structs[type.getType().structName];
+                        break;
+                    }
+                }
+            }
+            if (structDef) {
+                if (structDef.type.layout !== typeCopy.layout) {
+                    throw new Error(`Can not redefine struct ${structDef.type.structName} with different layout`);
+                }
+                if (shaderType !== getCurrentProgramBuilder().shaderType) {
+                    if (!this._structInfo[getCurrentProgramBuilder().shaderType]) {
+                        this._structInfo[getCurrentProgramBuilder().shaderType] = {
+                            structs: {},
+                            types: []
+                        };
+                    }
+                    this._structInfo[getCurrentProgramBuilder().shaderType].types.push(structDef);
+                    this._structInfo[getCurrentProgramBuilder().shaderType].structs[structDef.getType().structName] = ctor;
+                }
+                return ctor;
+            }
+        }
+        return this.internalDefineStructByType(this._shaderType, false, typeCopy);
+    }
+    /** @internal */ internalDefineStruct(structName, layout, shaderTypeMask, builtin, ...args) {
+        const structType = new PBStructTypeInfo(structName, layout, args.map((arg)=>{
+            if (!arg.$typeinfo.isPrimitiveType() && !arg.$typeinfo.isArrayType() && !arg.$typeinfo.isStructType() && !arg.$typeinfo.isAtomicI32() && !arg.$typeinfo.isAtomicU32()) {
+                throw new Error(`invalid struct member type: '${arg.$str}'`);
+            }
+            return {
+                name: arg.$str,
+                type: arg.$typeinfo
+            };
+        }));
+        return this.internalDefineStructByType(shaderTypeMask, builtin, structType);
+    }
+    /** @internal */ internalDefineStructByType(shaderTypeMask, builtin, structType) {
+        const struct = makeConstructor(function structConstructor(...blockArgs) {
+            let e;
+            if (blockArgs.length === 1 && typeof blockArgs[0] === 'string') {
+                e = new PBShaderExp(blockArgs[0], structType);
+            } else {
+                e = new PBShaderExp('', structType);
+                e.$ast = new ASTShaderExpConstructor(e.$typeinfo, blockArgs.map((arg)=>arg instanceof PBShaderExp ? arg.$ast : arg));
+            }
+            return e;
+        }, structType);
+        for (const shaderType of [
+            ShaderType.Vertex,
+            ShaderType.Fragment,
+            ShaderType.Compute
+        ]){
+            if (shaderTypeMask & shaderType) {
+                let structInfo = this._structInfo[shaderType];
+                if (!structInfo) {
+                    structInfo = {
+                        structs: {},
+                        types: []
+                    };
+                    this._structInfo[shaderType] = structInfo;
+                }
+                if (structInfo.structs[structType.structName]) {
+                    throw new PBParamValueError('defineStruct', 'structName', `cannot re-define struct '${structType.structName}'`);
+                }
+                structInfo.types.push(new ASTStructDefine(structType, builtin));
+                structInfo.structs[structType.structName] = struct;
+            }
+        }
+        // this.changeStructLayout(structType, layout);
+        return struct;
+    }
+    /** @internal */ getFunction(name) {
+        return this._globalScope ? this._globalScope.$getFunctions(name) : null;
+    }
+    /** @internal */ get structInfo() {
+        return this._structInfo[this._shaderType];
+    }
+    /** @internal */ getBlockName(instanceName) {
+        return `ch_block_name_${instanceName}`;
+    }
+    /** @internal */ defineBuiltinStruct(shaderType, inOrOut) {
+        const structName = inOrOut === 'in' ? getBuiltinInputStructName(shaderType) : getBuiltinOutputStructName(shaderType);
+        const instanceName = inOrOut === 'in' ? getBuiltinInputStructInstanceName(shaderType) : getBuiltinOutputStructInstanceName(shaderType);
+        const stage = shaderType === ShaderType.Vertex ? 'vertex' : shaderType === ShaderType.Fragment ? 'fragment' : 'compute';
+        const builtinVars = builtinVariables['webgpu'];
+        const args = [];
+        const prefix = [];
+        for(const k in builtinVars){
+            if (builtinVars[k].stage === stage && builtinVars[k].inOrOut === inOrOut) {
+                args.push({
+                    name: builtinVars[k].name,
+                    type: builtinVars[k].type
+                });
+                prefix.push(`@builtin(${builtinVars[k].semantic}) `);
+            }
+        }
+        const inoutList = inOrOut === 'in' ? this._inputs : this._outputs;
+        for (const k of inoutList){
+            // for debug only
+            if (!(k[1] instanceof ASTDeclareVar)) {
+                throw new PBInternalError('defineBuiltinStruct() failed: input/output is not declare var ast node');
+            }
+            const type = k[1].value.getType();
+            if (!type.isPrimitiveType() && !type.isArrayType() && !type.isStructType()) {
+                throw new Error(`invalid in/out variable type: '${k[1].value.name}'`);
+            }
+            args.push({
+                name: k[1].value.name,
+                type: type
+            });
+            prefix.push(`@location(${k[1].value.value.$location}) ${type.isPrimitiveType() && type.isInteger() ? '@interpolate(flat) ' : ''}`);
+        }
+        if (args.length > 0) {
+            const st = this.findStructType(structName, shaderType);
+            if (st) {
+                st.getType().reset(structName, 'default', args);
+                st.prefix = prefix;
+                return null;
+            } else {
+                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;
+                return [
+                    structType,
+                    structInstance,
+                    structName,
+                    structInstanceIN
+                ];
+            }
+        } else {
+            return null;
+        }
+    }
+    /** @internal */ defineInternalStructs() {
+        this.defineHiddenStruct(typeFrexpResult);
+        this.defineHiddenStruct(typeFrexpResultVec2);
+        this.defineHiddenStruct(typeFrexpResultVec3);
+        this.defineHiddenStruct(typeFrexpResultVec4);
+    }
+    /** @internal */ array(...args) {
+        if (args.length === 0) {
+            throw new PBParamLengthError('array');
+        }
+        args = args.map((arg)=>this.normalizeExpValue(arg));
+        let typeok = true;
+        let type = null;
+        let isBool = true;
+        let isFloat = true;
+        let isInt = true;
+        let isUint = true;
+        let isComposite = false;
+        for (const arg of args){
+            if (arg instanceof PBShaderExp) {
+                const argType = arg.$ast.getType();
+                if (!argType.isConstructible()) {
+                    typeok = false;
+                    break;
+                }
+                if (!type) {
+                    type = argType;
+                } else if (!argType.isCompatibleType(type)) {
+                    typeok = false;
+                }
+            }
+        }
+        if (typeok) {
+            if (type && type.isPrimitiveType() && type.isScalarType()) {
+                isBool = type.primitiveType === PBPrimitiveType.BOOL;
+                isFloat = type.primitiveType === PBPrimitiveType.F32;
+                isUint = type.primitiveType === PBPrimitiveType.U32;
+                isInt = type.primitiveType === PBPrimitiveType.I32;
+            } else if (type) {
+                isBool = false;
+                isFloat = false;
+                isUint = false;
+                isInt = false;
+                isComposite = true;
+            }
+            for (const arg of args){
+                if (!(arg instanceof PBShaderExp) && isComposite) {
+                    typeok = false;
+                    break;
+                }
+                if (typeof arg === 'number') {
+                    isBool = false;
+                    if ((arg | 0) === arg) {
+                        if (arg < 0) {
+                            isUint = false;
+                            isInt = isInt && arg >= 0x80000000 >> 0;
+                        } else {
+                            isUint = isUint && arg <= 0xffffffff;
+                            isInt = isInt && arg <= 0x7fffffff;
+                        }
+                    }
+                } else if (typeof arg === 'boolean') {
+                    isFloat = false;
+                    isInt = false;
+                    isUint = false;
+                }
+            }
+        }
+        if (typeok && !isComposite) {
+            if (isBool) {
+                type = typeBool;
+            } else if (isInt) {
+                type = typeI32;
+            } else if (isUint) {
+                type = typeU32;
+            } else if (isFloat) {
+                type = typeF32;
+            }
+            typeok = !!type;
+        }
+        if (!typeok) {
+            throw new PBParamTypeError('array');
+        }
+        if (!type.isPrimitiveType() && !type.isArrayType() && !type.isStructType()) {
+            throw new PBParamTypeError('array');
+        }
+        const arrayType = new PBArrayTypeInfo(type, args.length);
+        const exp = new PBShaderExp('', arrayType);
+        exp.$ast = new ASTShaderExpConstructor(arrayType, args.map((arg)=>{
+            if (arg instanceof PBShaderExp) {
+                return arg.$ast;
+            }
+            if (!type.isPrimitiveType() || !type.isScalarType()) {
+                throw new PBTypeCastError(arg, typeof arg, type);
+            }
+            return new ASTScalar(arg, type);
+        }));
+        return exp;
+    }
+    /**
+   * Creates a 'discard' statement
+   */ discard() {
+        this.getCurrentScope().$ast.statements.push(new ASTDiscard());
+    }
+    /** @internal */ tagShaderExp(getter, tagValue) {
+        if (typeof tagValue === 'string') {
+            this._reflection.tag(tagValue, getter);
+        } else if (Array.isArray(tagValue)) {
+            tagValue.forEach((tag)=>this.tagShaderExp(getter, tag));
+        } else {
+            for (const k of Object.keys(tagValue)){
+                this.tagShaderExp((scope)=>{
+                    const value = getter(scope);
+                    return value[k];
+                }, tagValue[k]);
+            }
+        }
+    }
+    /** @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}`);
+            }
+        });
+        variable.$tags.forEach((val)=>this.tagShaderExp(()=>variable, val));
+    }
+    /** @internal */ out(location, name, variable) {
+        if (this._outputs[location]) {
+            throw new Error(`output location ${location} has already been used`);
+        }
+        variable.$location = location;
+        variable.$declareType = DeclareType.DECLARE_TYPE_OUT;
+        this._outputs[location] = [
+            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));
+            }
+        });
+    }
+    /** @internal */ getDefaultSampler(t, comparison) {
+        const u = this._uniforms.findIndex((val)=>val.texture?.exp === t);
+        if (u < 0) {
+            return;
+        //throw new Error('invalid texture uniform object');
+        }
+        const samplerType = comparison ? 'comparison' : 'sample';
+        if (this._uniforms[u].texture.autoBindSampler && this._uniforms[u].texture.autoBindSampler !== samplerType) {
+            throw new Error('multiple sampler not supported');
+        }
+        this._uniforms[u].texture.autoBindSampler = samplerType;
+        if (this._device.type === 'webgpu') {
+            const samplerName = genSamplerName(t.$str, comparison);
+            if (!this.getGlobalScope()[samplerName]) {
+                throw new Error(`failed to find sampler name ${samplerName}`);
+            }
+            return this.getGlobalScope()[samplerName];
+        } else {
+            return null;
+        }
+    }
+    /** @internal */ normalizeExpValue(value) {
+        if (Array.isArray(value)) {
+            const converted = value.map((val)=>Array.isArray(val) ? this.normalizeExpValue(val) : val);
+            return this.array(...converted);
+        } else {
+            return value;
+        }
+    }
+    /** @internal */ guessExpValueType(value) {
+        const val = this.normalizeExpValue(value);
+        if (typeof val === 'boolean') {
+            return typeBool;
+        } else if (typeof val === 'number') {
+            if (!Number.isInteger(val)) {
+                return typeF32;
+            } else if (val >= 0x80000000 >> 1 && val <= 0x7fffffff) {
+                return typeI32;
+            } else if (val >= 0 && val <= 0xffffffff) {
+                return typeU32;
+            } else {
+                throw new PBValueOutOfRange(val);
+            }
+        } else if (val instanceof PBShaderExp) {
+            return val.$ast?.getType() || val.$typeinfo;
+        }
+    }
+    /** @internal */ findStructType(name, shaderType) {
+        for (const st of [
+            ShaderType.Vertex,
+            ShaderType.Fragment,
+            ShaderType.Compute
+        ]){
+            if (st & shaderType) {
+                const structInfo = this._structInfo[st];
+                if (structInfo) {
+                    for (const t of structInfo.types){
+                        if (t.type.structName === name) {
+                            return t;
+                        }
+                    }
+                }
+            }
+        }
+        return null;
+    }
+    /** @internal */ findStructConstructor(name, shaderType) {
+        for (const st of [
+            ShaderType.Vertex,
+            ShaderType.Fragment,
+            ShaderType.Compute
+        ]){
+            if (st & shaderType) {
+                const structInfo = this._structInfo[st];
+                if (structInfo && structInfo.structs?.[name]) {
+                    return structInfo.structs[name];
+                }
+            }
+        }
+        return null;
+    }
+    /** @internal */ buildComputeSource(options) {
+        try {
+            this._lastError = null;
+            this._shaderType = ShaderType.Compute;
+            this._scopeStack = [];
+            this._globalScope = new PBGlobalScope();
+            this._builtinScope = new PBBuiltinScope();
+            this._inputs = [];
+            this._outputs = [];
+            this._inputScope = new PBInputScope();
+            this._outputScope = new PBOutputScope();
+            this._reflection.clear();
+            this.generate(options.compute);
+            // this.removeUnusedSamplerBindings(this._globalScope);
+            this.mergeUniformsCompute(this._globalScope);
+            this.updateUniformBindings([
+                this._globalScope
+            ], [
+                ShaderType.Compute
+            ]);
+            return [
+                this.generateComputeSource(this._globalScope, this._builtinScope),
+                this.createBindGroupLayouts(options.label)
+            ];
+        } catch (err) {
+            if (err instanceof PBError) {
+                this._lastError = err.getMessage(this._device.type);
+                console.error(this._lastError);
+                return null;
+            } else if (err instanceof Error) {
+                this._lastError = err.toString();
+                console.error(this._lastError);
+                return null;
+            } else {
+                this._lastError = Object.prototype.toString.call(err);
+                console.log(`Error: ${this._lastError}`);
+                return null;
+            }
+        }
+    }
+    /** @internal */ buildRenderSource(options) {
+        try {
+            this._lastError = null;
+            this._shaderType = ShaderType.Vertex;
+            this._scopeStack = [];
+            this._globalScope = new PBGlobalScope();
+            this._builtinScope = new PBBuiltinScope();
+            this._inputs = [];
+            this._outputs = [];
+            this._inputScope = new PBInputScope();
+            this._outputScope = new PBOutputScope();
+            this._reflection.clear();
+            this.generate(options.vertex);
+            const vertexScope = this._globalScope;
+            const vertexBuiltinScope = this._builtinScope;
+            const vertexInputs = this._inputs;
+            const vertexOutputs = this._outputs;
+            if (this._device.type === 'webgpu') {
+            // this.removeUnusedSamplerBindings(vertexScope);
+            }
+            this._shaderType = ShaderType.Fragment;
+            this._scopeStack = [];
+            this._globalScope = new PBGlobalScope();
+            this._builtinScope = new PBBuiltinScope();
+            this._inputs = [];
+            this._outputs = [];
+            this._inputScope = new PBInputScope();
+            this._outputScope = new PBOutputScope();
+            this._reflection.clear();
+            vertexOutputs.forEach((val, index)=>{
+                this.in(index, val[0], new PBShaderExp(val[1].value.name, val[1].value.getType()).tag(...val[1].value.value.$tags));
+            });
+            this.generate(options.fragment);
+            const fragScope = this._globalScope;
+            const fragBuiltinScope = this._builtinScope;
+            const fragInputs = this._inputs;
+            const fragOutputs = this._outputs;
+            if (this._device.type === 'webgpu') {
+            // this.removeUnusedSamplerBindings(fragScope);
+            }
+            this.mergeUniforms(vertexScope, fragScope);
+            this.updateUniformBindings([
+                vertexScope,
+                fragScope
+            ], [
+                ShaderType.Vertex,
+                ShaderType.Fragment
+            ]);
+            return [
+                this.generateRenderSource(ShaderType.Vertex, vertexScope, vertexBuiltinScope, vertexInputs.map((val)=>val[1]), vertexOutputs.map((val)=>val[1])),
+                this.generateRenderSource(ShaderType.Fragment, fragScope, fragBuiltinScope, fragInputs.map((val)=>val[1]), fragOutputs.map((val)=>val[1])),
+                this.createBindGroupLayouts(options.label),
+                this._vertexAttributes
+            ];
+        } catch (err) {
+            if (err instanceof PBError) {
+                this._lastError = err.getMessage(this._device.type);
+                console.error(this._lastError);
+                return null;
+            } else if (err instanceof Error) {
+                this._lastError = err.toString();
+                console.error(this._lastError);
+                return null;
+            } else {
+                this._lastError = Object.prototype.toString.call(err);
+                console.log(`Error: ${this._lastError}`);
+                return null;
+            }
+        }
+    }
+    /** @internal */ generate(body) {
+        this.pushScope(this._globalScope);
+        if (this._emulateDepthClamp && this._shaderType === ShaderType.Vertex) {
+            this._globalScope.$outputs.clamppedDepth = this.float().tag('CLAMPPED_DEPTH');
+        }
+        body && body.call(this._globalScope, this);
+        this.popScope();
+    }
+    /** @internal */ generateRenderSource(shaderType, scope, builtinScope, inputs, outputs) {
+        const context = {
+            type: shaderType,
+            mrt: shaderType === ShaderType.Fragment && outputs.length > 1,
+            defines: [],
+            extensions: new Set(),
+            builtins: [
+                ...builtinScope.$_usedBuiltins
+            ],
+            types: this._structInfo[shaderType]?.types || [],
+            typeReplacement: new Map(),
+            inputs: inputs,
+            outputs: outputs,
+            global: scope,
+            vertexAttributes: this._vertexAttributes,
+            workgroupSize: null
+        };
+        switch(this._device.type){
+            case 'webgl':
+                for (const u of this._uniforms){
+                    if (u.texture) {
+                        const type = u.texture.exp.$ast.getType();
+                        if (type.isTextureType() && type.isDepthTexture()) {
+                            if (u.texture.autoBindSampler === 'comparison') {
+                                throw new PBDeviceNotSupport('depth texture comparison');
+                            }
+                            if (u.texture.autoBindSampler === 'sample') {
+                                if (type.is2DTexture()) {
+                                    context.typeReplacement.set(u.texture.exp, typeTex2D);
+                                } else if (type.isCubeTexture()) {
+                                    context.typeReplacement.set(u.texture.exp, typeTexCube);
+                                }
+                            }
+                        }
+                    }
+                }
+                return scope.$ast.toWebGL('', context);
+            case 'webgl2':
+                for (const u of this._uniforms){
+                    if (u.texture) {
+                        const type = u.texture.exp.$ast.getType();
+                        if (type.isTextureType() && type.isDepthTexture() && u.texture.autoBindSampler === 'sample') {
+                            if (type.is2DTexture()) {
+                                context.typeReplacement.set(u.texture.exp, type.isArrayTexture() ? typeTex2DArray : typeTex2D);
+                            } else if (type.isCubeTexture()) {
+                                context.typeReplacement.set(u.texture.exp, typeTexCube);
+                            }
+                        }
+                    }
+                }
+                return scope.$ast.toWebGL2('', context);
+            case 'webgpu':
+                return scope.$ast.toWGSL('', context);
+            default:
+                return null;
+        }
+    }
+    /** @internal */ generateComputeSource(scope, builtinScope) {
+        const context = {
+            type: ShaderType.Compute,
+            mrt: false,
+            defines: [],
+            extensions: new Set(),
+            builtins: [
+                ...builtinScope.$_usedBuiltins
+            ],
+            types: this._structInfo[ShaderType.Compute]?.types || [],
+            typeReplacement: null,
+            inputs: [],
+            outputs: [],
+            global: scope,
+            vertexAttributes: [],
+            workgroupSize: this._workgroupSize
+        };
+        return scope.$ast.toWGSL('', context);
+    }
+    /** @internal */ mergeUniformsCompute(globalScope) {
+        const uniformList = [];
+        for(let i = 0; i < this._uniforms.length; i++){
+            const u = this._uniforms[i];
+            if (u.block && (u.block.exp.$declareType === DeclareType.DECLARE_TYPE_UNIFORM || u.block.exp.$declareType === DeclareType.DECLARE_TYPE_STORAGE)) {
+                if (u.block.exp.$typeinfo.isStructType() && u.block.exp.$isBuffer) {
+                    continue;
+                }
+                if (!uniformList[u.group]) {
+                    uniformList[u.group] = [];
+                }
+                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;
+                uniformList[u.group].push({
+                    member: exp,
+                    uniform: i
+                });
+            }
+        }
+        for(const k in uniformList){
+            if (uniformList[k].length > 0) {
+                const types = [
+                    'std140',
+                    'std430'
+                ];
+                const nameList = [
+                    COMPUTE_UNIFORM_NAME,
+                    COMPUTE_STORAGE_NAME
+                ];
+                const ulist = [
+                    uniformList[k].filter((val)=>val.member.$declareType === DeclareType.DECLARE_TYPE_UNIFORM),
+                    uniformList[k].filter((val)=>val.member.$declareType === DeclareType.DECLARE_TYPE_STORAGE)
+                ];
+                for(let i = 0; i < 2; i++){
+                    if (ulist[i].length === 0) {
+                        continue;
+                    }
+                    const nonBufferList = ulist[i].filter((val)=>!val.member.$isBuffer);
+                    const bufferList = ulist[i].filter((val)=>val.member.$isBuffer);
+                    const allLists = [
+                        nonBufferList,
+                        ...bufferList.map((val)=>[
+                                val
+                            ])
+                    ];
+                    for(let p = 0; p < allLists.length; p++){
+                        if (allLists[p].length === 0) {
+                            continue;
+                        }
+                        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 exp = t();
+                        if (i === 0) {
+                            exp.uniformBuffer(Number(k));
+                        } else {
+                            exp.storageBuffer(Number(k));
+                        }
+                        globalScope[uname] = exp;
+                        const index = this._uniforms.findIndex((val)=>val.block?.name === uname);
+                        this._uniforms[index].mask = ShaderType.Compute;
+                        let nameMap = this._nameMap[Number(k)];
+                        if (!nameMap) {
+                            nameMap = {};
+                            this._nameMap[Number(k)] = nameMap;
+                        }
+                        let writable = false;
+                        for(let n = allLists[p].length - 1; n >= 0; n--){
+                            const u = allLists[p][n];
+                            const exp = this._uniforms[u.uniform].block.exp;
+                            nameMap[exp.$str] = uname;
+                            exp.$str = `${uname}.${exp.$str}`;
+                            writable ||= exp.$ast.isWritable();
+                        }
+                        if (writable) {
+                            globalScope[uname].$ast.markWritable();
+                        }
+                    }
+                }
+            }
+        }
+        this._uniforms = this._uniforms.filter((val)=>{
+            return !val.block || val.block.exp.$typeinfo.isStructType() && val.block.exp.$isBuffer;
+        //return !val.block || val.block.exp.$isBuffer;
+        /*
+      if (!val.block || (val.block.exp.$declareType !== AST.DeclareType.DECLARE_TYPE_UNIFORM && val.block.exp.$declareType !== AST.DeclareType.DECLARE_TYPE_STORAGE)) {
+        return true;
+      }
+      const type = val.block.exp.$ast.getType();
+      return (
+        type.isTextureType() ||
+        type.isSamplerType() ||
+        (type.isStructType() && (type.detail.layout === 'std140' || type.detail.layout === 'std430'))
+      );
+      */ });
+    }
+    /** @internal */ mergeUniforms(globalScopeVertex, globalScopeFragmet) {
+        const vertexUniformList = [];
+        const fragUniformList = [];
+        const sharedUniformList = [];
+        //const vertexUniformList: { members: PBShaderExp[]; uniforms: number[] }[] = [];
+        //const fragUniformList: { members: PBShaderExp[]; uniforms: number[] }[] = [];
+        //const sharedUniformList: { members: PBShaderExp[]; uniforms: number[] }[] = [];
+        for(let i = 0; i < this._uniforms.length; i++){
+            const u = this._uniforms[i];
+            if (u.block && (u.block.exp.$declareType === DeclareType.DECLARE_TYPE_UNIFORM || u.block.exp.$declareType === DeclareType.DECLARE_TYPE_STORAGE)) {
+                if (u.block.exp.$typeinfo.isStructType() && u.block.exp.$isBuffer) {
+                    continue;
+                }
+                const v = !!(u.mask & ShaderType.Vertex);
+                const f = !!(u.mask & ShaderType.Fragment);
+                if (v && f) {
+                    if (!sharedUniformList[u.group]) {
+                        sharedUniformList[u.group] = []; //{ members: [], uniforms: [] };
+                    }
+                    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;
+                    sharedUniformList[u.group].push({
+                        member: exp,
+                        uniform: i
+                    });
+                //sharedUniformList[u.group].uniforms.push(i);
+                } else if (v) {
+                    if (!vertexUniformList[u.group]) {
+                        vertexUniformList[u.group] = []; //{ members: [], uniforms: [] };
+                    }
+                    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;
+                    vertexUniformList[u.group].push({
+                        member: exp,
+                        uniform: i
+                    });
+                //vertexUniformList[u.group].uniforms.push(i);
+                } else if (f) {
+                    if (!fragUniformList[u.group]) {
+                        fragUniformList[u.group] = []; //{ members: [], uniforms: [] };
+                    }
+                    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;
+                    fragUniformList[u.group].push({
+                        member: exp,
+                        uniform: i
+                    }); //members.push(exp);
+                //fragUniformList[u.group].uniforms.push(i);
+                }
+            }
+        }
+        const uniformLists = [
+            vertexUniformList,
+            fragUniformList,
+            sharedUniformList
+        ];
+        const nameListUniform = [
+            VERTEX_UNIFORM_NAME,
+            FRAGMENT_UNIFORM_NAME,
+            SHARED_UNIFORM_NAME
+        ];
+        const nameListStorage = [
+            VERTEX_STORAGE_NAME,
+            FRAGMENT_STORAGE_NAME,
+            SHARED_STORAGE_NAME
+        ];
+        const maskList = [
+            ShaderType.Vertex,
+            ShaderType.Fragment,
+            ShaderType.Vertex | ShaderType.Fragment
+        ];
+        for(let i = 0; i < 3; i++){
+            for(const k in uniformLists[i]){
+                if (uniformLists[i][k]?.length > 0) {
+                    const ulist = [
+                        uniformLists[i][k].filter((val)=>val.member.$declareType === DeclareType.DECLARE_TYPE_UNIFORM),
+                        uniformLists[i][k].filter((val)=>val.member.$declareType === DeclareType.DECLARE_TYPE_STORAGE)
+                    ];
+                    const nameList = [
+                        nameListUniform,
+                        nameListStorage
+                    ];
+                    const layoutList = [
+                        'std140',
+                        'std430'
+                    ];
+                    for(let j = 0; j < 2; j++){
+                        if (ulist[j].length === 0) {
+                            continue;
+                        }
+                        const nonBufferList = ulist[j].filter((val)=>!val.member.$isBuffer);
+                        const bufferList = ulist[j].filter((val)=>val.member.$isBuffer);
+                        const allLists = [
+                            nonBufferList,
+                            ...bufferList.map((val)=>[
+                                    val
+                                ])
+                        ];
+                        for(let p = 0; p < allLists.length; p++){
+                            if (allLists[p].length === 0) {
+                                continue;
+                            }
+                            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));
+                            if (maskList[i] & ShaderType.Vertex) {
+                                const exp = t();
+                                if (j === 0) {
+                                    exp.uniformBuffer(Number(k));
+                                } else {
+                                    exp.storageBuffer(Number(k));
+                                }
+                                globalScopeVertex[uname] = exp;
+                            }
+                            if (maskList[i] & ShaderType.Fragment) {
+                                const exp = t();
+                                if (j === 0) {
+                                    exp.uniformBuffer(Number(k));
+                                } else {
+                                    exp.storageBuffer(Number(k));
+                                }
+                                globalScopeFragmet[uname] = exp;
+                            }
+                            const index = this._uniforms.findIndex((val)=>val.block?.name === uname);
+                            this._uniforms[index].mask = maskList[i];
+                            let nameMap = this._nameMap[Number(k)];
+                            if (!nameMap) {
+                                nameMap = {};
+                                this._nameMap[Number(k)] = nameMap;
+                            }
+                            let writable = false;
+                            for(let n = allLists[p].length - 1; n >= 0; n--){
+                                const u = allLists[p][n];
+                                const exp = this._uniforms[u.uniform].block.exp;
+                                nameMap[exp.$str] = uname;
+                                exp.$str = `${uname}.${exp.$str}`;
+                                writable ||= exp.$ast.isWritable();
+                            }
+                            if (writable) {
+                                if (maskList[i] & ShaderType.Vertex) {
+                                    globalScopeVertex[uname].$ast.markWritable();
+                                } else {
+                                    globalScopeFragmet[uname].$ast.markWritable();
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        this._uniforms = this._uniforms.filter((val)=>{
+            return !val.block || val.block.exp.$typeinfo.isStructType() && val.block.exp.$isBuffer;
+        /*
+      if (!val.block) {
+        return true;
+      }
+      const type = val.block.exp.$ast.getType();
+      return (
+        type.isTextureType() ||
+        type.isSamplerType() ||
+        (type.isStructType() && (type.detail.layout === 'std140' || type.detail.layout === 'std430'))
+      );
+      */ });
+    }
+    /** @internal */ updateUniformBindings(scopes, shaderTypes) {
+        this._uniforms = this._uniforms.filter((val)=>!!val.mask);
+        const bindings = Array.from({
+            length: MAX_BINDING_GROUPS
+        }).fill(0);
+        for (const u of this._uniforms){
+            u.binding = bindings[u.group]++;
+        }
+        for(let i = 0; i < scopes.length; i++){
+            const scope = scopes[i];
+            const type = shaderTypes[i];
+            for (const u of this._uniforms){
+                if (u.mask & type) {
+                    const uniforms = scope.$ast.uniforms;
+                    const name = u.block ? u.block.name : u.texture ? u.texture.exp.$str : u.sampler.$str;
+                    const index = uniforms.findIndex((val)=>val.value.name === name);
+                    if (index < 0) {
+                        throw new Error(`updateUniformBindings() failed: unable to find uniform ${name}`);
+                    }
+                    uniforms[index].binding = u.binding;
+                }
+            }
+        }
+    }
+    /** @internal */ createBindGroupLayouts(label) {
+        const layouts = [];
+        for (const uniformInfo of this._uniforms){
+            let layout = layouts[uniformInfo.group];
+            if (!layout) {
+                layout = {
+                    label: `${label || 'unknown'}[${uniformInfo.group}]`,
+                    entries: []
+                };
+                if (this._nameMap[uniformInfo.group]) {
+                    layout.nameMap = this._nameMap[uniformInfo.group];
+                }
+                layouts[uniformInfo.group] = layout;
+            }
+            const entry = {
+                binding: uniformInfo.binding,
+                visibility: uniformInfo.mask,
+                type: null,
+                name: ''
+            };
+            if (uniformInfo.block) {
+                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)
+                };
+                entry.name = uniformInfo.block.name;
+            } else if (uniformInfo.texture) {
+                entry.type = uniformInfo.texture.exp.$typeinfo;
+                if (!entry.type.isTextureType()) {
+                    throw new Error('internal error');
+                }
+                if (entry.type.isStorageTexture()) {
+                    entry.storageTexture = {
+                        access: 'write-only',
+                        viewDimension: entry.type.is1DTexture() ? '1d' : '2d',
+                        format: entry.type.storageTexelFormat
+                    };
+                } else if (entry.type.isExternalTexture()) {
+                    entry.externalTexture = {
+                        autoBindSampler: uniformInfo.texture.autoBindSampler ? genSamplerName(uniformInfo.texture.exp.$str, false) : null
+                    };
+                } else {
+                    const sampleType = this._device.type === 'webgpu' ? uniformInfo.texture.exp.$sampleType : uniformInfo.texture.autoBindSampler && entry.type.isDepthTexture() ? 'float' : uniformInfo.texture.exp.$sampleType;
+                    let viewDimension;
+                    if (entry.type.isArrayTexture()) {
+                        viewDimension = entry.type.isCubeTexture() ? 'cube-array' : '2d-array';
+                    } else if (entry.type.is3DTexture()) {
+                        viewDimension = '3d';
+                    } else if (entry.type.isCubeTexture()) {
+                        viewDimension = 'cube';
+                    } else if (entry.type.is1DTexture()) {
+                        viewDimension = '1d';
+                    } else {
+                        viewDimension = '2d';
+                    }
+                    entry.texture = {
+                        sampleType: sampleType,
+                        viewDimension: viewDimension,
+                        multisampled: false,
+                        autoBindSampler: null,
+                        autoBindSamplerComparison: null
+                    };
+                    if (this._device.type === 'webgpu' || uniformInfo.texture.autoBindSampler === 'sample') {
+                        entry.texture.autoBindSampler = genSamplerName(uniformInfo.texture.exp.$str, false);
+                    }
+                    if (this._device.type === 'webgpu' && entry.type.isDepthTexture() || uniformInfo.texture.autoBindSampler === 'comparison') {
+                        entry.texture.autoBindSamplerComparison = genSamplerName(uniformInfo.texture.exp.$str, true);
+                    }
+                }
+                entry.name = uniformInfo.texture.exp.$str;
+            } else if (uniformInfo.sampler) {
+                entry.type = uniformInfo.sampler.$typeinfo;
+                if (!entry.type.isSamplerType()) {
+                    throw new Error('internal error');
+                }
+                entry.sampler = {
+                    type: entry.type.accessMode === PBSamplerAccessMode.SAMPLE ? uniformInfo.sampler.$sampleType === 'float' ? 'filtering' : 'non-filtering' : 'comparison'
+                };
+                entry.name = uniformInfo.sampler.$str;
+            } else {
+                throw new PBInternalError('invalid uniform entry type');
+            }
+            layout.entries.push(entry);
+        }
+        for(let i = 0; i < layouts.length; i++){
+            if (!layouts[i]) {
+                layouts[i] = {
+                    label: `${label || 'unknown'}[${i}]`,
+                    entries: []
+                };
+            }
+        }
+        return layouts;
+    }
+    /** @internal */ _getFunctionOverload(funcName, args) {
+        const thisArgs = args.filter((val)=>{
+            if (val instanceof PBShaderExp) {
+                const type = val.$ast.getType();
+                if (type.isStructType() && this._structInfo[this._shaderType]?.types.findIndex((t)=>t.type.structName === type.structName) < 0) {
+                    return false;
+                }
+            }
+            return true;
+        });
+        const fn = this.getGlobalScope().$getFunctions(funcName);
+        return fn ? this._matchFunctionOverloading(fn, thisArgs) : null;
+    }
+    /** @internal */ _matchFunctionOverloading(overloadings, args) {
+        for (const overload of overloadings){
+            if (args.length !== overload.funcType.argTypes.length) {
+                continue;
+            }
+            const result = [];
+            let matches = true;
+            for(let i = 0; i < args.length; i++){
+                const argInfo = overload.funcType.argTypes[i];
+                const argType = argInfo.byRef && argInfo.type instanceof PBPointerTypeInfo ? argInfo.type.pointerType : argInfo.type;
+                const arg = args[i];
+                if (typeof arg === 'boolean') {
+                    if (!argType.isPrimitiveType() || argType.primitiveType !== PBPrimitiveType.BOOL) {
+                        matches = false;
+                        break;
+                    }
+                    result.push(new ASTScalar(arg, typeBool));
+                } else if (typeof arg === 'number') {
+                    if (!argType.isPrimitiveType() || !argType.isScalarType() || argType.scalarType === PBPrimitiveType.BOOL) {
+                        matches = false;
+                        break;
+                    }
+                    if (argType.scalarType === PBPrimitiveType.I32) {
+                        if (!Number.isInteger(arg) || arg < 0x80000000 >> 0 || arg > 0x7fffffff) {
+                            matches = false;
+                            break;
+                        }
+                        result.push(new ASTScalar(arg, typeI32));
+                    } else if (argType.scalarType === PBPrimitiveType.U32) {
+                        if (!Number.isInteger(arg) || arg < 0 || arg > 0xffffffff) {
+                            matches = false;
+                            break;
+                        }
+                        result.push(new ASTScalar(arg, typeU32));
+                    } else {
+                        result.push(new ASTScalar(arg, argType));
+                    }
+                } else {
+                    if (!argType.isCompatibleType(arg.$ast.getType())) {
+                        matches = false;
+                        break;
+                    }
+                    result.push(arg.$ast);
+                }
+            }
+            if (matches) {
+                return [
+                    overload,
+                    result
+                ];
+            }
+        }
+        return null;
+    }
+    /** @internal */ $callFunction(funcName, args, func) {
+        if (this.getCurrentScope() === this.getGlobalScope()) {
+            throw new PBNonScopedFunctionCall(funcName);
+        }
+        const exp = new PBShaderExp('', func.returnType);
+        exp.$ast = new ASTCallFunction(funcName, args, func, getCurrentProgramBuilder().getDevice().type);
+        this.getCurrentScope().$ast.statements.push(exp.$ast);
+        return exp;
+    }
+    /** @internal */ $callFunctionNoCheck(funcName, args, retType) {
+        if (this.getCurrentScope() === this.getGlobalScope()) {
+            throw new PBNonScopedFunctionCall(funcName);
+        }
+        const exp = new PBShaderExp('', retType);
+        exp.$ast = new ASTCallFunction(funcName, args, null, getCurrentProgramBuilder().getDevice().type, retType);
+        this.getCurrentScope().$ast.statements.push(exp.$ast);
+        return exp;
+    }
+}
+/**
+ * Base class for scope of the shader program
+ * @public
+ */ class PBScope extends Proxiable {
+    /** @internal */ $_variables;
+    /** @internal */ $_parentScope;
+    /** @internal */ $_AST;
+    /** @internal */ $_localScope;
+    /** @internal */ constructor(astScope, parent){
+        super();
+        this.$_parentScope = parent || null;
+        this.$_variables = {};
+        this.$_AST = astScope;
+        this.$_localScope = null;
+    }
+    /** Get the program builder */ get $builder() {
+        return getCurrentProgramBuilder();
+    }
+    /** Returns the scope of the builtin variables */ get $builtins() {
+        return getCurrentProgramBuilder().builtinScope;
+    }
+    /** Returns the scope of the input variables */ get $inputs() {
+        return getCurrentProgramBuilder().inputScope;
+    }
+    /** Returns the scope of the output variables */ get $outputs() {
+        return getCurrentProgramBuilder().outputScope;
+    }
+    /** @internal */ get $parent() {
+        return this.$_parentScope;
+    }
+    /** @internal */ get $ast() {
+        return this.$_AST;
+    }
+    /** @internal */ set $ast(ast) {
+        this.$_AST = ast;
+    }
+    /**
+   * Get the input vertex attribute by specified semantic
+   *
+   * @remarks
+   * Can only be called only in vertex shader
+   *
+   * @param semantic - The vertex semantic
+   * @returns The input vertex attribute or null if not exists
+   */ $getVertexAttrib(semantic) {
+        return getCurrentProgramBuilder().getReflection().attribute(semantic);
+    }
+    /** Get the current local scope */ get $l() {
+        return this.$_getLocalScope();
+    }
+    /** Get the global scope */ get $g() {
+        return this.$_getGlobalScope();
+    }
+    /** @internal */ $local(variable, init) {
+        const initNonArray = getCurrentProgramBuilder().normalizeExpValue(init);
+        variable.$global = this instanceof PBGlobalScope;
+        this.$_declare(variable, initNonArray);
+    }
+    /** @internal */ $touch(exp) {
+        this.$ast.statements.push(new ASTTouch(exp.$ast));
+    }
+    /**
+   * Query the global variable by the name
+   * @param name - Name of the variable
+   * @returns The variable or null if not exists
+   */ $query(name) {
+        return this.$builder.getReflection().tag(name);
+    }
+    /** @internal */ $_declareInternal(variable, init) {
+        const key = variable.$str;
+        if (this.$_variables[key]) {
+            throw new Error(`cannot re-declare variable '${key}'`);
+        }
+        if (!(variable.$ast instanceof ASTPrimitive)) {
+            throw new Error(`invalid variable declaration: '${variable.$ast.toString(getCurrentProgramBuilder().getDevice().type)}'`);
+        }
+        const varType = variable.$typeinfo;
+        if (varType.isPointerType()) {
+            if (!init) {
+                throw new Error(`cannot declare pointer type variable without initialization: '${variable.$str}'`);
+            }
+            if (!(init instanceof PBShaderExp)) {
+                throw new Error(`invalid initialization for pointer type declaration: '${variable.$str}`);
+            }
+            const initType = init.$ast.getType();
+            if (!initType.isPointerType() || !varType.pointerType.isCompatibleType(initType.pointerType)) {
+                throw new Error(`incompatible pointer type assignment: '${variable.$str}'`);
+            }
+            variable.$typeinfo = initType;
+        }
+        this.$_registerVar(variable, key);
+        if (init === undefined || init === null) {
+            return new ASTDeclareVar(variable.$ast);
+        } else {
+            if (init instanceof PBShaderExp && init.$ast instanceof ASTShaderExpConstructor && init.$ast.args.length === 0) {
+                if (!init.$ast.getType().isCompatibleType(variable.$ast.getType())) {
+                    throw new PBTypeCastError(init, init.$ast.getType(), variable.$ast.getType());
+                }
+                return new ASTDeclareVar(variable.$ast);
+            } else {
+                return new ASTAssignment(new ASTLValueDeclare(variable.$ast), init instanceof PBShaderExp ? init.$ast : init);
+            }
+        }
+    }
+    /** @internal */ $_findOrSetUniform(variable) {
+        const name = variable.$str;
+        const uniformInfo = {
+            group: variable.$group,
+            binding: 0,
+            mask: 0
+        };
+        if (variable.$typeinfo.isTextureType()) {
+            uniformInfo.texture = {
+                autoBindSampler: null,
+                exp: variable
+            };
+        } else if (variable.$typeinfo.isSamplerType()) {
+            uniformInfo.sampler = variable;
+        } else {
+            uniformInfo.block = {
+                name: name,
+                dynamicOffset: false,
+                exp: variable
+            };
+        // throw new Error(`unsupported uniform type: ${name}`);
+        }
+        let found = false;
+        for (const u of getCurrentProgramBuilder()._uniforms){
+            if (u.group !== uniformInfo.group) {
+                continue;
+            }
+            if (uniformInfo.block && u.block && u.block.name === uniformInfo.block.name && u.block.exp.$typeinfo.isCompatibleType(uniformInfo.block.exp.$typeinfo)) {
+                u.mask |= getCurrentProgramBuilder().shaderType;
+                variable = u.block.exp;
+                // u.block.exp = variable;
+                found = true;
+                break;
+            }
+            if (uniformInfo.texture && u.texture && uniformInfo.texture.exp.$str === u.texture.exp.$str && uniformInfo.texture.exp.$typeinfo.isCompatibleType(u.texture.exp.$typeinfo)) {
+                u.mask |= getCurrentProgramBuilder().shaderType;
+                variable = u.texture.exp;
+                // u.texture.exp = variable;
+                found = true;
+                break;
+            }
+            if (uniformInfo.sampler && u.sampler && uniformInfo.sampler.$str === u.sampler.$str && uniformInfo.sampler.$typeinfo.isCompatibleType(u.sampler.$typeinfo)) {
+                u.mask |= getCurrentProgramBuilder().shaderType;
+                variable = u.sampler;
+                // u.sampler = variable;
+                found = true;
+                break;
+            }
+        }
+        if (!found) {
+            uniformInfo.mask = getCurrentProgramBuilder().shaderType;
+            getCurrentProgramBuilder()._uniforms.push(uniformInfo);
+        }
+        if (uniformInfo.texture && !uniformInfo.texture.exp.$typeinfo.isStorageTexture() && getCurrentProgramBuilder().getDevice().type === 'webgpu') {
+            // webgpu requires explicit sampler bindings
+            const isDepth = variable.$typeinfo.isTextureType() && variable.$typeinfo.isDepthTexture();
+            const samplerName = genSamplerName(variable.$str, false);
+            const samplerExp = getCurrentProgramBuilder().sampler(samplerName).uniform(uniformInfo.group).sampleType(variable.$sampleType);
+            samplerExp.$sampleType = variable.$sampleType;
+            this.$local(samplerExp);
+            if (isDepth) {
+                const samplerNameComp = genSamplerName(variable.$str, true);
+                const samplerExpComp = getCurrentProgramBuilder().samplerComparison(samplerNameComp).uniform(uniformInfo.group).sampleType(variable.$sampleType);
+                this.$local(samplerExpComp);
+            }
+        }
+        return variable;
+    }
+    /** @internal */ $_declare(variable, init) {
+        if (this.$_variables[variable.$str]) {
+            throw new PBASTError(variable.$ast, 'cannot re-declare variable');
+        }
+        if (variable.$declareType === DeclareType.DECLARE_TYPE_UNIFORM || variable.$declareType === DeclareType.DECLARE_TYPE_STORAGE) {
+            const name = variable.$ast.name;
+            if (!(this instanceof PBGlobalScope)) {
+                throw new Error(`uniform or storage variables can only be declared within global scope: ${name}`);
+            }
+            if (variable.$declareType === DeclareType.DECLARE_TYPE_UNIFORM && !variable.$typeinfo.isTextureType() && !variable.$typeinfo.isSamplerType() && (!variable.$typeinfo.isConstructible() || !variable.$typeinfo.isHostSharable())) {
+                throw new PBASTError(variable.$ast, `type '${variable.$typeinfo.toTypeName(getCurrentProgramBuilder().getDevice().type)}' cannot be declared in uniform address space`);
+            }
+            if (variable.$declareType === DeclareType.DECLARE_TYPE_STORAGE) {
+                if (getCurrentProgramBuilder().getDevice().type !== 'webgpu') {
+                    throw new PBDeviceNotSupport('storage buffer binding');
+                } else if (!variable.$typeinfo.isHostSharable()) {
+                    throw new PBASTError(variable.$ast, `type '${variable.$typeinfo.toTypeName(getCurrentProgramBuilder().getDevice().type)}' cannot be declared in storage address space`);
+                }
+            }
+            /*
+      if (
+        variable.$declareType === AST.DeclareType.DECLARE_TYPE_STORAGE &&
+        (variable.$typeinfo.isPrimitiveType() || variable.$typeinfo.isArrayType() || variable.$typeinfo.isAtomicI32() || variable.$typeinfo.isAtomicU32())
+      ) {
+        originalType = variable.$typeinfo as PBPrimitiveTypeInfo | PBArrayTypeInfo;
+        const wrappedStruct = getCurrentProgramBuilder().defineStruct(null, new PBShaderExp('value', originalType));
+        variable.$typeinfo = wrappedStruct().$typeinfo;
+      }
+      */ variable = this.$_findOrSetUniform(variable);
+            const ast = this.$_declareInternal(variable);
+            ast.group = variable.$group;
+            ast.binding = 0;
+            ast.blockName = getCurrentProgramBuilder().getBlockName(name);
+            const type = variable.$typeinfo;
+            if (type.isStructType() && variable.$isBuffer || type.isTextureType() || type.isSamplerType() || type.isStructType() && (type.detail.layout === 'std140' || type.detail.layout === 'std430')) {
+                this.$ast.uniforms.push(ast);
+            }
+            variable.$tags.forEach((val)=>{
+                getCurrentProgramBuilder().tagShaderExp(()=>variable, val);
+            });
+        } else {
+            const ast = this.$_declareInternal(variable, init);
+            this.$ast.statements.push(ast);
+        }
+    }
+    /** @internal */ $_registerVar(variable, name) {
+        const key = name || variable.$str;
+        const options = {
+            configurable: true,
+            get: function() {
+                return variable;
+            },
+            set: function(val) {
+                getCurrentProgramBuilder().getCurrentScope().$ast.statements.push(new ASTAssignment(new ASTLValueScalar(variable.$ast), val instanceof PBShaderExp ? val.$ast : val));
+            }
+        };
+        Object.defineProperty(this, key, options);
+        this.$_variables[key] = variable;
+    }
+    /** @internal */ $localGet(prop) {
+        if (typeof prop === 'string' && (prop[0] === '$' || prop in this)) {
+            return this[prop];
+        }
+        return undefined;
+    }
+    /** @internal */ $localSet(prop, value) {
+        if (prop[0] === '$' || prop in this) {
+            this[prop] = value;
+            return true;
+        }
+        return false;
+    }
+    /** @internal */ $get(prop) {
+        const ret = this.$localGet(prop);
+        return ret === undefined && this.$_parentScope ? this.$_parentScope.$thisProxy.$get(prop) : ret;
+    }
+    /** @internal */ $set(prop, value) {
+        if (prop[0] === '$') {
+            this[prop] = value;
+            return true;
+        } else {
+            let scope = this;
+            while(scope && !(prop in scope)){
+                scope = scope.$_parentScope;
+            }
+            if (scope) {
+                scope[prop] = value;
+                return true;
+            } else {
+                if (this.$l) {
+                    this.$l[prop] = value;
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+    /** @internal */ $_getLocalScope() {
+        if (!this.$_localScope) {
+            this.$_localScope = new PBLocalScope(this);
+        }
+        return this.$_localScope;
+    }
+    /** @internal */ $_getGlobalScope() {
+        return this.$builder.getGlobalScope();
+    }
+}
+/**
+ * The local scope of a shader
+ * @public
+ */ class PBLocalScope extends PBScope {
+    /** @internal */ $_scope;
+    constructor(scope){
+        super(null, null);
+        this.$_scope = scope;
+    }
+    /** @internal */ $get(prop) {
+        return prop[0] === '$' ? this[prop] : this.$_scope.$localGet(prop);
+    }
+    /** @internal */ $set(prop, value) {
+        if (prop[0] === '$') {
+            this[prop] = value;
+            return true;
+        }
+        const val = this.$_scope.$localGet(prop);
+        if (val === undefined) {
+            const type = getCurrentProgramBuilder().guessExpValueType(value);
+            if (type.isCompatibleType(typeVoid)) {
+                throw new Error(`Cannot assign void type to '${prop}'`);
+            }
+            const exp = new PBShaderExp(prop, type);
+            if (value instanceof PBShaderExp && !this.$_scope.$parent) {
+                exp.$declareType = value.$declareType;
+                exp.$isBuffer = value.$isBuffer;
+                exp.$group = value.$group;
+                exp.$attrib = value.$attrib;
+                exp.$sampleType = value.$sampleType;
+                exp.$precision = value.$precision;
+                exp.tag(...value.$tags);
+            }
+            this.$_scope.$local(exp, value);
+            return true;
+        } else {
+            return this.$_scope.$localSet(prop, value);
+        }
+    }
+    /** @internal */ $_getLocalScope() {
+        return this;
+    }
+}
+/**
+ * The builtin scope of a shader
+ * @public
+ */ class PBBuiltinScope extends PBScope {
+    /** @internal */ $_usedBuiltins;
+    /** @internal */ $_builtinVars;
+    constructor(){
+        super(null);
+        this.$_usedBuiltins = new Set();
+        const isWebGPU = getCurrentProgramBuilder().getDevice().type === 'webgpu';
+        if (!isWebGPU) {
+            this.$_builtinVars = {};
+            const v = builtinVariables[getCurrentProgramBuilder().getDevice().type];
+            for(const k in v){
+                const info = v[k];
+                this.$_builtinVars[k] = new PBShaderExp(info.name, info.type);
+            }
+        }
+        const v = builtinVariables[getCurrentProgramBuilder().getDevice().type];
+        const that = this;
+        for (const k of Object.keys(v)){
+            Object.defineProperty(this, k, {
+                get: function() {
+                    return that.$getBuiltinVar(k);
+                },
+                set: function(v) {
+                    if (typeof v !== 'number' && !(v instanceof PBShaderExp)) {
+                        throw new Error(`Invalid output value assignment`);
+                    }
+                    const exp = that.$getBuiltinVar(k);
+                    getCurrentProgramBuilder().getCurrentScope().$ast.statements.push(new ASTAssignment(new ASTLValueScalar(exp.$ast), v instanceof PBShaderExp ? v.$ast : v));
+                }
+            });
+        }
+    }
+    /** @internal */ $_getLocalScope() {
+        return null;
+    }
+    /** @internal */ $getBuiltinVar(name) {
+        const pb = getCurrentProgramBuilder();
+        this.$_usedBuiltins.add(name);
+        const isWebGPU = pb.getDevice().type === 'webgpu';
+        if (isWebGPU) {
+            const v = builtinVariables[pb.getDevice().type];
+            const info = v[name];
+            const inout = info.inOrOut;
+            const structName = inout === 'in' ? getBuiltinInputStructInstanceName(pb.shaderType) : getBuiltinOutputStructInstanceName(pb.shaderType);
+            const scope = pb.getCurrentScope();
+            if (!scope[structName] || !scope[structName][info.name]) {
+                throw new Error(`invalid use of builtin variable ${name}`);
+            }
+            return scope[structName][info.name];
+        } else {
+            if (pb.getDevice().type === 'webgl2' && (name === 'vertexIndex' || name === 'instanceIndex')) {
+                return pb.uint(this.$_builtinVars[name]);
+            } else {
+                return this.$_builtinVars[name];
+            }
+        }
+    }
+}
+/**
+ * The input scope of a shader
+ * @public
+ */ class PBInputScope extends PBScope {
+    /** @internal */ constructor(){
+        super(null);
+    }
+    /** @internal */ $_getLocalScope() {
+        return null;
+    }
+    /** @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 {
+            const st = getCurrentProgramBuilder().shaderType;
+            if (st !== ShaderType.Vertex) {
+                throw new Error(`shader input variables can only be declared in vertex shader: "${prop}"`);
+            }
+            const attrib = getVertexAttribByName(value.$attrib);
+            if (attrib === undefined) {
+                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}"`);
+            }
+            if (!(value instanceof PBShaderExp) || !(value.$ast instanceof ASTShaderExpConstructor)) {
+                throw new Error(`invalid shader input variable declaration: "${prop}"`);
+            }
+            const type = value.$ast.getType();
+            if (!type.isPrimitiveType() || type.isMatrixType() || type.primitiveType === PBPrimitiveType.BOOL) {
+                throw new Error(`type cannot be used as pipeline input/output: ${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);
+            // modify input struct for webgpu
+            if (getCurrentProgramBuilder().getDevice().type === 'webgpu') {
+                if (getCurrentProgramBuilder().findStructType(getBuiltinInputStructName(st), st)) {
+                    getCurrentProgramBuilder().defineBuiltinStruct(st, 'in');
+                }
+            }
+        }
+        return true;
+    }
+}
+/**
+ * The output scope of a shader
+ * @public
+ */ class PBOutputScope extends PBScope {
+    constructor(){
+        super(null);
+    }
+    /** @internal */ $_getLocalScope() {
+        return null;
+    }
+    /** @internal */ $set(prop, value) {
+        if (prop[0] === '$' /* || prop in this*/ ) {
+            this[prop] = value;
+        } else {
+            const pb = getCurrentProgramBuilder();
+            if (!(prop in this)) {
+                if (pb.getCurrentScope() === pb.getGlobalScope() && (!(value instanceof PBShaderExp) || !(value.$ast instanceof ASTShaderExpConstructor))) {
+                    throw new Error(`invalid shader output variable declaration: ${prop}`);
+                }
+                const type = value.$ast.getType();
+                if (!type.isPrimitiveType() || type.isMatrixType() || type.primitiveType === PBPrimitiveType.BOOL) {
+                    throw new Error(`type cannot be used as pipeline input/output: ${prop}`);
+                }
+                const location = pb._outputs.length;
+                pb.out(location, prop, new PBShaderExp(`${pb.shaderKind === 'vertex' ? output_prefix_vs : output_prefix_fs}${prop}`, type).tag(...value.$tags));
+                // modify output struct for webgpu
+                if (getCurrentProgramBuilder().getDevice().type === 'webgpu') {
+                    const st = getCurrentProgramBuilder().shaderType;
+                    if (getCurrentProgramBuilder().findStructType(getBuiltinInputStructName(st), st)) {
+                        getCurrentProgramBuilder().defineBuiltinStruct(st, 'out');
+                    }
+                }
+            }
+            if (getCurrentProgramBuilder().getCurrentScope() !== getCurrentProgramBuilder().getGlobalScope()) {
+                const ast = value.$ast;
+                if (!(ast instanceof ASTShaderExpConstructor) || ast.args.length > 0) {
+                    this[prop] = value;
+                }
+            }
+        }
+        return true;
+    }
+}
+/**
+ * The global scope of a shader
+ * @public
+ */ class PBGlobalScope extends PBScope {
+    /** @internal */ constructor(){
+        super(new ASTGlobalScope());
+    }
+    /** @internal */ $mainFunc(body) {
+        const pb = getCurrentProgramBuilder();
+        if (pb.getDevice().type === 'webgpu') {
+            const inputStruct = pb.defineBuiltinStruct(pb.shaderType, 'in');
+            this.$local(inputStruct[1]);
+            const isCompute = pb.shaderType === ShaderType.Compute;
+            const outputStruct = isCompute ? null : pb.defineBuiltinStruct(pb.shaderType, 'out');
+            if (!isCompute) {
+                this.$local(outputStruct[1]);
+            }
+            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) {
+                    this.$builtins.fragDepth = pb.clamp(this.$inputs.clamppedDepth, 0, 1);
+                }
+                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);
+                    }
+                    if (pb.emulateDepthClamp) {
+                        //z = gl_Position.z / gl_Position.w;
+                        //z = (gl_DepthRange.diff * z + gl_DepthRange.near + gl_DepthRange.far) * 0.5;
+                        this.$outputs.clamppedDepth = pb.div(this.$builtins.position.z, this.$builtins.position.w);
+                        this.$builtins.position.z = 0;
+                    }
+                }
+                if (!isCompute) {
+                    this.$return(outputStruct[1]);
+                }
+            });
+        } else {
+            this.$internalCreateFunction('main', [], true, function() {
+                if (pb.shaderType === ShaderType.Fragment && pb.emulateDepthClamp) {
+                    this.$builtins.fragDepth = pb.clamp(this.$inputs.clamppedDepth, 0, 1);
+                }
+                body?.call(this);
+                if (pb.shaderType === ShaderType.Vertex && pb.emulateDepthClamp) {
+                    this.$outputs.clamppedDepth = pb.div(pb.add(pb.div(this.$builtins.position.z, this.$builtins.position.w), 1), 2);
+                    this.$builtins.position.z = 0;
+                }
+            });
+        }
+    }
+    /** @internal */ $createFunctionIfNotExists(name, params, body) {
+        {
+            this.$internalCreateFunction(name, params, false, body);
+        }
+    }
+    /** @internal */ $getFunctions(name) {
+        return this.$ast.findFunctions(name);
+    }
+    /** @internal */ $getCurrentFunctionScope() {
+        let scope = getCurrentProgramBuilder().getCurrentScope();
+        while(scope && !(scope instanceof PBFunctionScope)){
+            scope = scope.$parent;
+        }
+        return scope;
+    }
+    /** @internal */ $internalCreateFunction(name, params, isMain, body) {
+        const pb = getCurrentProgramBuilder();
+        params.forEach((param)=>{
+            if (!(param.$ast instanceof ASTPrimitive)) {
+                throw new Error(`${name}(): invalid function definition`);
+            }
+            let ast = param.$ast;
+            if (param.$inout) {
+                if (getCurrentProgramBuilder().getDevice().type === 'webgpu') {
+                    param.$typeinfo = new PBPointerTypeInfo(param.$typeinfo, PBAddressSpace.UNKNOWN);
+                }
+                ast = new ASTReferenceOf(param.$ast);
+            }
+            param.$ast = new ASTFunctionParameter(ast);
+        });
+        const overloads = this.$getFunctions(name);
+        const currentFunctionScope = this.$getCurrentFunctionScope();
+        const astFunc = new ASTFunction(name, params.map((val)=>val.$ast), isMain, null, false);
+        if (currentFunctionScope) {
+            const curIndex = this.$ast.statements.indexOf(currentFunctionScope.$ast);
+            if (curIndex < 0) {
+                throw new Error('Internal error');
+            }
+            this.$ast.statements.splice(curIndex, 0, astFunc);
+        } else {
+            this.$ast.statements.push(astFunc);
+        }
+        new PBFunctionScope(this, params, astFunc, body);
+        if (!astFunc.returnType) {
+            astFunc.returnType = typeVoid;
+        }
+        astFunc.funcType = new PBFunctionTypeInfo(astFunc.name, astFunc.returnType, params.map((param)=>{
+            const ast = param.$ast;
+            return ast.paramAST instanceof ASTReferenceOf ? {
+                type: ast.paramAST.value.getType(),
+                byRef: ast.paramAST instanceof ASTReferenceOf
+            } : {
+                type: ast.paramAST.getType(),
+                byRef: false
+            };
+        }));
+        for (const overload of overloads){
+            if (overload.funcType.argHash === astFunc.funcType.argHash) {
+                if (overload.returnType.isCompatibleType(astFunc.returnType)) {
+                    // Function signature already exists
+                    // console.warn(`Function '${name}' already exists`);
+                    this.$ast.statements.splice(this.$ast.statements.indexOf(astFunc), 1);
+                    return;
+                } else {
+                    throw new Error(`Invalid function overloading: ${name}`);
+                }
+            }
+        }
+        if (overloads.length === 0) {
+            Object.defineProperty(this, name, {
+                get: function() {
+                    const func = this.$getFunctions(name);
+                    if (func.length === 0) {
+                        throw new Error(`function ${name} not found`);
+                    }
+                    return (...args)=>{
+                        const argsNonArray = args.map((val)=>pb.normalizeExpValue(val));
+                        const funcType = pb._getFunctionOverload(name, argsNonArray);
+                        if (!funcType) {
+                            throw new Error(`ERROR: no matching overloads for function ${name}`);
+                        }
+                        return getCurrentProgramBuilder().$callFunction(name, funcType[1], funcType[0]);
+                    };
+                }
+            });
+        }
+    }
+}
+/**
+ * Scope that is inside a function
+ * @public
+ */ class PBInsideFunctionScope extends PBScope {
+    /** @internal */ constructor(parent){
+        super(new ASTScope(), parent);
+    }
+    /**
+   * Creates a 'return' statement
+   * @param retval - The return value
+   */ $return(retval) {
+        const functionScope = this.findOwnerFunction();
+        const astFunc = functionScope.$ast;
+        let returnType = null;
+        const retValNonArray = getCurrentProgramBuilder().normalizeExpValue(retval);
+        if (retValNonArray !== undefined && retValNonArray !== null) {
+            if (typeof retValNonArray === 'number') {
+                if (astFunc.returnType) {
+                    if (astFunc.returnType.isPrimitiveType() && astFunc.returnType.isScalarType() && !astFunc.returnType.isCompatibleType(typeBool)) {
+                        returnType = astFunc.returnType;
+                    }
+                }
+                if (!returnType) {
+                    if (Number.isInteger(retValNonArray)) {
+                        if (retValNonArray < 0) {
+                            if (retValNonArray < 0x80000000 >> 0) {
+                                throw new Error(`function ${astFunc.name}: invalid return value: ${retValNonArray}`);
+                            }
+                            returnType = typeI32;
+                        } else {
+                            if (retValNonArray > 0xffffffff) {
+                                throw new Error(`function ${astFunc.name}: invalid return value: ${retValNonArray}`);
+                            }
+                            returnType = retValNonArray <= 0x7fffffff ? typeI32 : typeU32;
+                        }
+                    } else {
+                        returnType = typeF32;
+                    }
+                }
+            } else if (typeof retValNonArray === 'boolean') {
+                returnType = typeBool;
+            } else {
+                returnType = retValNonArray.$ast.getType();
+            }
+        } else {
+            returnType = typeVoid;
+        }
+        if (returnType.isPointerType()) {
+            throw new Error('function can not return pointer type');
+        }
+        if (!astFunc.returnType) {
+            astFunc.returnType = returnType;
+        } else if (!astFunc.returnType.isCompatibleType(returnType)) {
+            throw new Error(`function ${astFunc.name}: return type must be ${astFunc.returnType?.toTypeName(getCurrentProgramBuilder().getDevice().type) || 'void'}`);
+        }
+        let returnValue = null;
+        if (retValNonArray !== undefined && retValNonArray !== null) {
+            if (retValNonArray instanceof PBShaderExp) {
+                returnValue = retValNonArray.$ast;
+            } else {
+                if (!returnType.isPrimitiveType() || !returnType.isScalarType()) {
+                    throw new PBTypeCastError(retValNonArray, typeof retValNonArray, returnType);
+                }
+                returnValue = new ASTScalar(retValNonArray, returnType);
+            }
+        }
+        this.$ast.statements.push(new ASTReturn(returnValue));
+    }
+    /**
+   * Creates a new scope
+   * @param body - Generator function for the scope
+   * @returns The created scope
+   */ $scope(body) {
+        const astScope = new ASTNakedScope();
+        this.$ast.statements.push(astScope);
+        return new PBNakedScope(this, astScope, body);
+    }
+    /**
+   * Creates an 'if' statement
+   * @param condition - Condition expression for the if statement
+   * @param body - Generator function for the scope inside the if statement
+   * @returns The scope inside the if statement
+   */ $if(condition, body) {
+        const astIf = new ASTIf('if', condition instanceof PBShaderExp ? condition.$ast : new ASTScalar(condition, typeof condition === 'number' ? typeF32 : typeBool));
+        this.$ast.statements.push(astIf);
+        return new PBIfScope(this, astIf, body);
+    }
+    /**
+   * Creates a select statement: condition ? first : second
+   * @param condition - Condition expression
+   * @param first - The first value
+   * @param second - The second value
+   * @returns The first value if condition evaluates to true, otherwise returns the second value
+   */ $choice(condition, first, second) {
+        const ast = new ASTSelect(condition instanceof PBShaderExp ? condition.$ast : condition, first instanceof PBShaderExp ? first.$ast : first, second instanceof PBShaderExp ? second.$ast : second);
+        const exp = new PBShaderExp('', ast.getType());
+        exp.$ast = ast;
+        return exp;
+    }
+    /** Creates a 'break' statement */ $break() {
+        this.$ast.statements.push(new ASTBreak());
+    }
+    /** Creates a 'continue' statement */ $continue() {
+        this.$ast.statements.push(new ASTContinue());
+    }
+    /**
+   * Creates a 'for' statement
+   * @param counter - The repeat counter variable declaration
+   * @param init - initial value of the repeat counter variable
+   * @param end - end value of the counter exclusive
+   * @param body - Generator function for the scope that inside the for statement
+   */ $for(counter, init, end, body) {
+        const initializerType = counter.$ast.getType();
+        if (!initializerType.isPrimitiveType() || !initializerType.isScalarType()) {
+            throw new PBASTError(counter.$ast, 'invalid for range initializer type');
+        }
+        const initval = init instanceof PBShaderExp ? init.$ast : new ASTScalar(init, initializerType);
+        const astFor = new ASTRange(counter.$ast, initval, end instanceof PBShaderExp ? end.$ast : new ASTScalar(end, initializerType), true);
+        this.$ast.statements.push(astFor);
+        new PBForScope(this, counter, end, astFor, body);
+    }
+    /**
+   * Creates a 'do..while' statement
+   * @param body - Generator function for the scope that inside the do..while statment
+   * @returns The scope that inside the do..while statement
+   */ $do(body) {
+        const astDoWhile = new ASTDoWhile(null);
+        this.$ast.statements.push(astDoWhile);
+        return new PBDoWhileScope(this, astDoWhile, body);
+    }
+    /**
+   * Creates a 'while' statement
+   * @param condition - Condition expression for the while statement
+   * @param body - Generator function for the scope that inside the while statement
+   */ $while(condition, body) {
+        const astWhile = new ASTWhile(condition instanceof PBShaderExp ? condition.$ast : new ASTScalar(condition, typeof condition === 'number' ? typeF32 : typeBool));
+        this.$ast.statements.push(astWhile);
+        new PBWhileScope(this, astWhile, body);
+    }
+    /** @internal */ findOwnerFunction() {
+        for(let scope = this; scope; scope = scope.$parent){
+            if (scope instanceof PBFunctionScope) {
+                return scope;
+            }
+        }
+        return null;
+    }
+}
+/**
+ * Scope that insides a function
+ * @public
+ */ class PBFunctionScope extends PBInsideFunctionScope {
+    /** @internal */ $typeinfo;
+    /** @internal */ constructor(parent, params, ast, body){
+        super(parent);
+        this.$ast = ast;
+        for (const param of params){
+            if (this.$_variables[param.$str]) {
+                throw new Error('Duplicate function parameter name is not allowed');
+            }
+            this.$_registerVar(param);
+        }
+        getCurrentProgramBuilder().pushScope(this);
+        body && body.call(this);
+        getCurrentProgramBuilder().popScope();
+    }
+}
+/**
+ * Scope that insides a while statement
+ * @public
+ */ class PBWhileScope extends PBInsideFunctionScope {
+    /** @internal */ constructor(parent, ast, body){
+        super(parent);
+        this.$ast = ast;
+        getCurrentProgramBuilder().pushScope(this);
+        body && body.call(this);
+        getCurrentProgramBuilder().popScope();
+    }
+}
+/**
+ * Scope that insides a do..while statement
+ * @public
+ */ class PBDoWhileScope extends PBInsideFunctionScope {
+    /** @internal */ constructor(parent, ast, body){
+        super(parent);
+        this.$ast = ast;
+        getCurrentProgramBuilder().pushScope(this);
+        body && body.call(this);
+        getCurrentProgramBuilder().popScope();
+    }
+    $while(condition) {
+        this.$ast.condition = condition instanceof PBShaderExp ? condition.$ast : new ASTScalar(condition, typeof condition === 'number' ? typeF32 : typeBool);
+    }
+}
+/**
+ * Scope that insides a for statement
+ * @public
+ */ class PBForScope extends PBInsideFunctionScope {
+    /** @internal */ constructor(parent, counter, count, ast, body){
+        super(parent);
+        this.$ast = ast;
+        this.$_registerVar(counter);
+        getCurrentProgramBuilder().pushScope(this);
+        body && body.call(this);
+        getCurrentProgramBuilder().popScope();
+    }
+}
+/**
+ * A naked scope
+ * @public
+ */ class PBNakedScope extends PBInsideFunctionScope {
+    /** @internal */ constructor(parent, ast, body){
+        super(parent);
+        this.$ast = ast;
+        getCurrentProgramBuilder().pushScope(this);
+        body && body.call(this);
+        getCurrentProgramBuilder().popScope();
+    }
+}
+/**
+ * Scope that insides an if statement
+ * @public
+ */ class PBIfScope extends PBInsideFunctionScope {
+    /** @internal */ constructor(parent, ast, body){
+        super(parent);
+        this.$ast = ast;
+        getCurrentProgramBuilder().pushScope(this);
+        body && body.call(this);
+        getCurrentProgramBuilder().popScope();
+    }
+    /**
+   * Creates an 'else if' branch
+   * @param condition - Condition expression for the else if branch
+   * @param body - Generator function for the scope that insides the else if statement
+   * @returns The scope that insides the else if statement
+   */ $elseif(condition, body) {
+        const astElseIf = new ASTIf('else if', condition instanceof PBShaderExp ? condition.$ast : new ASTScalar(condition, typeof condition === 'number' ? typeF32 : typeBool));
+        this.$ast.nextElse = astElseIf;
+        return new PBIfScope(this.$_parentScope, astElseIf, body);
+    }
+    /**
+   * Creates an 'else' branch
+   * @param body - Generator function for the scope that insides the else statement
+   */ $else(body) {
+        const astElse = new ASTIf('else', null);
+        this.$ast.nextElse = astElse;
+        new PBIfScope(this.$_parentScope, astElse, body);
+    }
+}
+setBuiltinFuncs(ProgramBuilder);
+setConstructors(ProgramBuilder);
+
+export { PBBuiltinScope, PBDoWhileScope, PBForScope, PBFunctionScope, PBGlobalScope, PBIfScope, PBInputScope, PBInsideFunctionScope, PBLocalScope, PBNakedScope, PBOutputScope, PBScope, PBWhileScope, ProgramBuilder };
+//# sourceMappingURL=programbuilder.js.map