@zephyr3d/device 0.2.3 → 0.2.5

package/dist/builder/ast.js

@@ -1,7 +1,9 @@
 import { ShaderType } from '../base_types.js';
 import { semanticToAttrib } from '../gpuobject.js';
-import { PBPrimitiveTypeInfo, PBPrimitiveType, PBTextureType, PBAddressSpace, PBPointerTypeInfo, typeBool, typeF32, typeI32, typeU32, typeVoid } from './types.js';
+import { PBTextureType, PBPrimitiveTypeInfo, PBPrimitiveType, PBAddressSpace, PBPointerTypeInfo, typeBool, typeF32, typeI32, typeU32, typeVoid } from './types.js';
 import { PBASTError, PBTypeCastError, PBInternalError, PBParamTypeError } from './errors.js';
+import { getCurrentProgramBuilder } from './misc.js';
+import { ASSERT } from '@zephyr3d/base';
 
 const BuiltinInputStructNameVS = 'zVSInput';
 const BuiltinOutputStructNameVS = 'zVSOutput';
@@ -18,22 +20,22 @@ const BuiltinInputStructInstanceNameFS = 'zFSInputCpy';
 const BuiltinOutputStructInstanceNameFS = 'zFSOutputCpy';
 const BuiltinInputStructInstanceNameCS = 'zCSInputCpy';
 const BuiltinOutputStructInstanceNameCS = 'zCSOutputCpy';
-var DeclareType;
-(function(DeclareType) {
+/** @internal */ var DeclareType = /*#__PURE__*/ function(DeclareType) {
     DeclareType[DeclareType["DECLARE_TYPE_NONE"] = 0] = "DECLARE_TYPE_NONE";
     DeclareType[DeclareType["DECLARE_TYPE_IN"] = 1] = "DECLARE_TYPE_IN";
     DeclareType[DeclareType["DECLARE_TYPE_OUT"] = 2] = "DECLARE_TYPE_OUT";
     DeclareType[DeclareType["DECLARE_TYPE_WORKGROUP"] = 3] = "DECLARE_TYPE_WORKGROUP";
     DeclareType[DeclareType["DECLARE_TYPE_UNIFORM"] = 4] = "DECLARE_TYPE_UNIFORM";
     DeclareType[DeclareType["DECLARE_TYPE_STORAGE"] = 5] = "DECLARE_TYPE_STORAGE";
-})(DeclareType || (DeclareType = {}));
-var ShaderPrecisionType;
-(function(ShaderPrecisionType) {
+    return DeclareType;
+}({});
+/** @internal */ var ShaderPrecisionType = /*#__PURE__*/ function(ShaderPrecisionType) {
     ShaderPrecisionType[ShaderPrecisionType["NONE"] = 0] = "NONE";
     ShaderPrecisionType[ShaderPrecisionType["HIGH"] = 1] = "HIGH";
     ShaderPrecisionType[ShaderPrecisionType["MEDIUM"] = 2] = "MEDIUM";
     ShaderPrecisionType[ShaderPrecisionType["LOW"] = 3] = "LOW";
-})(ShaderPrecisionType || (ShaderPrecisionType = {}));
+    return ShaderPrecisionType;
+}({});
 /** @internal */ function getBuiltinParamName(shaderType) {
     switch(shaderType){
         case ShaderType.Vertex:
@@ -336,16 +338,16 @@ function unbracket(e) {
     getType() {
         return null;
     }
-    toWebGL(indent, ctx) {
+    toWebGL(_indent, _ctx) {
         return '';
     }
-    toWebGL2(indent, ctx) {
+    toWebGL2(_indent, _ctx) {
         return '';
     }
-    toWGSL(indent, ctx) {
+    toWGSL(_indent, _ctx) {
         return '';
     }
-    toString(deviceType) {
+    toString(_deviceType) {
         return this.constructor.name;
     }
 }
@@ -536,12 +538,12 @@ function unbracket(e) {
     }
     getAddressSpace() {
         switch(this.value.$declareType){
-            case DeclareType.DECLARE_TYPE_UNIFORM:
+            case 4:
                 return PBAddressSpace.UNIFORM;
-            case DeclareType.DECLARE_TYPE_STORAGE:
+            case 5:
                 return PBAddressSpace.STORAGE;
-            case DeclareType.DECLARE_TYPE_IN:
-            case DeclareType.DECLARE_TYPE_OUT:
+            case 1:
+            case 2:
                 return null;
             default:
                 return this.value.$global ? PBAddressSpace.PRIVATE : PBAddressSpace.FUNCTION;
@@ -550,24 +552,24 @@ function unbracket(e) {
     getType() {
         return this.value.$typeinfo;
     }
-    toWebGL(indent, ctx) {
+    toWebGL(_indent, _ctx) {
         return this.name;
     }
-    toWebGL2(indent, ctx) {
+    toWebGL2(_indent, _ctx) {
         return this.name;
     }
     toWGSL(indent, ctx) {
-        if (this.value.$declareType === DeclareType.DECLARE_TYPE_IN) {
+        if (this.value.$declareType === 1) {
             const structName = getBuiltinInputStructInstanceName(ctx.type);
             return ctx.global[structName][this.name].$ast.toWGSL(indent, ctx);
-        } else if (this.value.$declareType === DeclareType.DECLARE_TYPE_OUT) {
+        } else if (this.value.$declareType === 2) {
             const structName = getBuiltinOutputStructInstanceName(ctx.type);
             return ctx.global[structName][this.name].$ast.toWGSL(indent, ctx);
         } else {
             return this.name;
         }
     }
-    toString(deviceType) {
+    toString(_deviceType) {
         return this.name;
     }
 }
@@ -704,13 +706,13 @@ function unbracket(e) {
     isReference() {
         return true;
     }
-    toWebGL(indent, ctx) {
+    toWebGL(_indent, _ctx) {
         let prefix = '';
         switch(this.value.value.$declareType){
-            case DeclareType.DECLARE_TYPE_IN:
-            case DeclareType.DECLARE_TYPE_OUT:
-            case DeclareType.DECLARE_TYPE_UNIFORM:
-            case DeclareType.DECLARE_TYPE_STORAGE:
+            case 1:
+            case 2:
+            case 4:
+            case 5:
                 throw new Error('invalid declare type');
             default:
                 prefix = this.value.constExp && !this.value.isWritable() && !this.getType().isStructType() ? 'const ' : '';
@@ -720,13 +722,13 @@ function unbracket(e) {
             return `${prefix}${this.getType().toTypeName('webgl', this.value.name)}`;
         }
     }
-    toWebGL2(indent, ctx) {
+    toWebGL2(_indent, _ctx) {
         let prefix = '';
         switch(this.value.value.$declareType){
-            case DeclareType.DECLARE_TYPE_IN:
-            case DeclareType.DECLARE_TYPE_OUT:
-            case DeclareType.DECLARE_TYPE_UNIFORM:
-            case DeclareType.DECLARE_TYPE_STORAGE:
+            case 1:
+            case 2:
+            case 4:
+            case 5:
                 throw new Error('invalid declare type');
             default:
                 prefix = this.value.constExp && !this.value.isWritable() && !this.getType().isStructType() ? 'const ' : '';
@@ -736,13 +738,13 @@ function unbracket(e) {
             return `${prefix}${this.getType().toTypeName('webgl2', this.value.name)}`;
         }
     }
-    toWGSL(indent, ctx) {
+    toWGSL(_indent, _ctx) {
         let prefix;
         switch(this.value.value.$declareType){
-            case DeclareType.DECLARE_TYPE_IN:
-            case DeclareType.DECLARE_TYPE_OUT:
-            case DeclareType.DECLARE_TYPE_UNIFORM:
-            case DeclareType.DECLARE_TYPE_STORAGE:
+            case 1:
+            case 2:
+            case 4:
+            case 5:
                 throw new Error('invalid declare type');
             default:
                 {
@@ -773,11 +775,12 @@ function unbracket(e) {
     /** @internal */ type;
     /** @internal */ args;
     /** @internal */ constExp;
+    /** @internal */ convertedArgs;
     constructor(type, args){
         super();
         this.type = type;
         this.args = args;
-        this.constExp = true;
+        this.convertedArgs = null;
         for (const arg of args){
             if (arg === null || arg === undefined) {
                 throw new Error('invalid constructor argument');
@@ -787,6 +790,17 @@ function unbracket(e) {
             }
             this.constExp &&= !(arg instanceof ASTExpression) || arg.isConstExp();
         }
+        const deviceType = getCurrentProgramBuilder().getDevice().type;
+        const overloads = this.type.getConstructorOverloads(deviceType);
+        for (const overload of overloads){
+            this.convertedArgs = convertArgs(this.args, overload);
+            if (this.convertedArgs) {
+                break;
+            }
+        }
+        if (!this.convertedArgs) {
+            throw new Error(`no matching overload function found for type ${this.type.toTypeName(deviceType)}`);
+        }
     }
     getType() {
         return this.type;
@@ -802,48 +816,18 @@ function unbracket(e) {
         return null;
     }
     toWebGL(indent, ctx) {
-        console.assert(!this.type.isArrayType(), 'array constructor not supported in webgl1 device');
-        console.assert(this.type.isConstructible(), `type '${this.type.toTypeName('webgl')}' is not constructible`);
-        const overloads = this.type.getConstructorOverloads('webgl');
-        for (const overload of overloads){
-            const convertedArgs = convertArgs(this.args, overload);
-            if (convertedArgs) {
-                const c = convertedArgs.args.map((arg)=>unbracket(arg.toWebGL(indent, ctx))).join(',');
-                return `${convertedArgs.name}(${c})`;
-            }
-        }
-        throw new Error(`no matching overload function found for type ${this.type.toTypeName('webgl')}`);
+        const c = this.convertedArgs.args.map((arg)=>unbracket(arg.toWebGL(indent, ctx))).join(',');
+        return `${this.convertedArgs.name}(${c})`;
     }
     toWebGL2(indent, ctx) {
-        console.assert(this.type.isConstructible(), `type '${this.type.toTypeName('webgl2')}' is not constructible`, true);
-        const overloads = this.type.getConstructorOverloads('webgl2');
-        for (const overload of overloads){
-            const convertedArgs = convertArgs(this.args, overload);
-            if (convertedArgs) {
-                const c = convertedArgs.args.map((arg)=>unbracket(arg.toWebGL2(indent, ctx))).join(',');
-                return `${convertedArgs.name}(${c})`;
-            }
-        }
-        throw new Error(`no matching overload function found for type ${this.type.toTypeName('webgl2')}`);
+        const c = this.convertedArgs.args.map((arg)=>unbracket(arg.toWebGL2(indent, ctx))).join(',');
+        return `${this.convertedArgs.name}(${c})`;
     }
     toWGSL(indent, ctx) {
-        /*
-    console.assert(
-      this.type.isConstructible(),
-      `type '${this.type.toTypeName('webgpu')}' is not constructible`,
-      true
-    );
-    */ const overloads = this.type.getConstructorOverloads('webgpu');
-        for (const overload of overloads){
-            const convertedArgs = convertArgs(this.args, overload);
-            if (convertedArgs) {
-                const c = convertedArgs.args.map((arg)=>unbracket(arg.toWGSL(indent, ctx))).join(',');
-                return `${convertedArgs.name}(${c})`;
-            }
-        }
-        throw new Error(`no matching overload function found for type ${this.type.toTypeName('webgpu')}`);
+        const c = this.convertedArgs.args.map((arg)=>unbracket(arg.toWGSL(indent, ctx))).join(',');
+        return `${this.convertedArgs.name}(${c})`;
     }
-    toString(deviceType) {
+    toString(_deviceType) {
         return 'constructor';
     }
 }
@@ -881,21 +865,21 @@ function unbracket(e) {
     getAddressSpace() {
         return null;
     }
-    toWebGL(indent, ctx) {
+    toWebGL(_indent, _ctx) {
         switch(this.type.primitiveType){
             case PBPrimitiveType.F32:
                 return toFixed(this.value);
             case PBPrimitiveType.I32:
                 return toInt(this.value);
             case PBPrimitiveType.U32:
-                return toUint(this.value);
+                return `${toUint(this.value)}u`;
             case PBPrimitiveType.BOOL:
                 return String(!!this.value);
             default:
                 throw new Error('Invalid scalar type');
         }
     }
-    toWebGL2(indent, ctx) {
+    toWebGL2(_indent, _ctx) {
         switch(this.type.primitiveType){
             case PBPrimitiveType.F32:
                 return toFixed(this.value);
@@ -909,7 +893,7 @@ function unbracket(e) {
                 throw new Error('Invalid scalar type');
         }
     }
-    toWGSL(indent, ctx) {
+    toWGSL(_indent, _ctx) {
         switch(this.type.primitiveType){
             case PBPrimitiveType.F32:
                 return toFixed(this.value);
@@ -923,7 +907,7 @@ function unbracket(e) {
                 throw new Error('Invalid scalar type');
         }
     }
-    toString(deviceType) {
+    toString(_deviceType) {
         return `${this.value}`;
     }
 }
@@ -959,14 +943,14 @@ function unbracket(e) {
         return this.source.getAddressSpace();
     }
     toWebGL(indent, ctx) {
-        return `${this.source.toWebGL(indent, ctx)}.${this.field}`;
+        return this.source instanceof ASTScalar ? `(${this.source.toWebGL(indent, ctx)}).${this.field}` : `${this.source.toWebGL(indent, ctx)}.${this.field}`;
     }
     toWebGL2(indent, ctx) {
-        return `${this.source.toWebGL2(indent, ctx)}.${this.field}`;
+        return this.source instanceof ASTScalar ? `(${this.source.toWebGL(indent, ctx)}).${this.field}` : `${this.source.toWebGL(indent, ctx)}.${this.field}`;
     }
     toWGSL(indent, ctx) {
         const source = this.source.isPointer() ? new ASTReferenceOf(this.source) : this.source;
-        return `${source.toWGSL(indent, ctx)}.${this.field}`;
+        return source instanceof ASTScalar ? `(${source.toWGSL(indent, ctx)}).${this.field}` : `${source.toWGSL(indent, ctx)}.${this.field}`;
     }
     toString(deviceType) {
         const source = this.source.isPointer() ? new ASTReferenceOf(this.source) : this.source;
@@ -1027,7 +1011,7 @@ function unbracket(e) {
     /** @internal */ type;
     constructor(value){
         super();
-        console.assert(value.isReference(), 'no pointer type for non-reference values', true);
+        ASSERT(value.isReference(), 'no pointer type for non-reference values');
         this.value = value;
         this.type = new PBPointerTypeInfo(value.getType(), value.getAddressSpace());
     }
@@ -1050,10 +1034,10 @@ function unbracket(e) {
     getAddressSpace() {
         return this.value.getAddressSpace();
     }
-    toWebGL(indent, ctx) {
+    toWebGL(_indent, _ctx) {
         throw new Error('GLSL does not support pointer type');
     }
-    toWebGL2(indent, ctx) {
+    toWebGL2(_indent, _ctx) {
         throw new Error('GLSL does not support pointer type');
     }
     toWGSL(indent, ctx) {
@@ -1275,6 +1259,15 @@ function unbracket(e) {
     /** @internal */ type;
     constructor(condition, first, second){
         super();
+        if (condition instanceof ASTCallFunction) {
+            condition.isStatement = false;
+        }
+        if (first instanceof ASTCallFunction) {
+            first.isStatement = false;
+        }
+        if (second instanceof ASTCallFunction) {
+            second.isStatement = false;
+        }
         this.condition = condition instanceof ASTExpression ? condition : new ASTScalar(condition, typeBool);
         let firstType = null;
         let secondType = null;
@@ -1398,6 +1391,14 @@ function unbracket(e) {
         if (this.rvalue instanceof ASTCallFunction) {
             this.rvalue.isStatement = false;
         }
+        const ltype = this.lvalue.getType();
+        const valueTypeLeft = ltype.isPointerType() ? ltype.pointerType : ltype;
+        const rtype = this.checkScalarType(this.rvalue, valueTypeLeft);
+        const rvalueIsPtr = rtype && rtype.isPointerType();
+        const valueTypeRight = rvalueIsPtr ? rtype.pointerType : rtype;
+        if (!valueTypeLeft.isCompatibleType(valueTypeRight)) {
+            throw new PBTypeCastError(this.rvalue instanceof ASTExpression ? this.rvalue.toString(rtype.isPointerType() ? 'webgpu' : 'webgl') : `${this.rvalue}`, rtype, ltype);
+        }
     }
     getType() {
         return null;
@@ -1503,35 +1504,35 @@ function unbracket(e) {
     }
 }
 /** @internal */ class ASTDiscard extends ShaderAST {
-    toWebGL(indent, ctx) {
+    toWebGL(indent, _ctx) {
         return `${indent}discard;\n`;
     }
-    toWebGL2(indent, ctx) {
+    toWebGL2(indent, _ctx) {
         return `${indent}discard;\n`;
     }
-    toWGSL(indent, ctx) {
+    toWGSL(indent, _ctx) {
         return `${indent}discard;\n`;
     }
 }
 /** @internal */ class ASTBreak extends ShaderAST {
-    toWebGL(indent, ctx) {
+    toWebGL(indent, _ctx) {
         return `${indent}break;\n`;
     }
-    toWebGL2(indent, ctx) {
+    toWebGL2(indent, _ctx) {
         return `${indent}break;\n`;
     }
-    toWGSL(indent, ctx) {
+    toWGSL(indent, _ctx) {
         return `${indent}break;\n`;
     }
 }
 /** @internal */ class ASTContinue extends ShaderAST {
-    toWebGL(indent, ctx) {
+    toWebGL(indent, _ctx) {
         return `${indent}continue;\n`;
     }
-    toWebGL2(indent, ctx) {
+    toWebGL2(indent, _ctx) {
         return `${indent}continue;\n`;
     }
-    toWGSL(indent, ctx) {
+    toWGSL(indent, _ctx) {
         return `${indent}continue;\n`;
     }
 }
@@ -1647,7 +1648,7 @@ function unbracket(e) {
         const args = thisArgs.map((arg)=>unbracket(arg.toWGSL(indent, ctx)));
         return `${this.isStatement ? indent : ''}${this.name}(${args.join(',')})${this.isStatement ? ';\n' : ''}`;
     }
-    toString(deviceType) {
+    toString(_deviceType) {
         return `${this.name}(...)`;
     }
 }
@@ -1673,7 +1674,7 @@ function unbracket(e) {
         let builtin = false;
         let valueType = this.value.getType();
         switch(this.value.value.$declareType){
-            case DeclareType.DECLARE_TYPE_IN:
+            case 1:
                 if (ctx.type === ShaderType.Vertex) {
                     prefix = 'attribute ';
                     ctx.defines.push(`#define ${this.value.name} ${semanticToAttrib(ctx.vertexAttributes[this.value.value.$location])}\n`);
@@ -1682,7 +1683,7 @@ function unbracket(e) {
                 // ctx.defines.push(`#define ${this.value.$str} ch_varying_${this.value.$location}\n`);
                 }
                 break;
-            case DeclareType.DECLARE_TYPE_OUT:
+            case 2:
                 if (ctx.type === ShaderType.Vertex) {
                     prefix = 'varying ';
                 // ctx.defines.push(`#define ${this.value.$str} ch_varying_${this.value.$location}\n`);
@@ -1696,11 +1697,11 @@ function unbracket(e) {
                     }
                 }
                 break;
-            case DeclareType.DECLARE_TYPE_UNIFORM:
+            case 4:
                 prefix = 'uniform ';
                 valueType = ctx.typeReplacement?.get(this.value.value) || valueType;
                 break;
-            case DeclareType.DECLARE_TYPE_STORAGE:
+            case 5:
                 throw new Error(`invalid variable declare type: ${this.value.name}`);
         }
         if (!builtin) {
@@ -1711,7 +1712,7 @@ function unbracket(e) {
         let prefix = '';
         let valueType = this.value.getType();
         switch(this.value.value.$declareType){
-            case DeclareType.DECLARE_TYPE_IN:
+            case 1:
                 if (ctx.type === ShaderType.Fragment && valueType.isPrimitiveType() && valueType.isInteger()) {
                     prefix = 'flat in ';
                 } else {
@@ -1721,7 +1722,7 @@ function unbracket(e) {
                     ctx.defines.push(`#define ${this.value.name} ${semanticToAttrib(ctx.vertexAttributes[this.value.value.$location])}\n`);
                 }
                 break;
-            case DeclareType.DECLARE_TYPE_OUT:
+            case 2:
                 if (ctx.type === ShaderType.Vertex) {
                     if (valueType.isPrimitiveType() && valueType.isInteger()) {
                         prefix = 'flat out ';
@@ -1732,7 +1733,7 @@ function unbracket(e) {
                     prefix = `layout(location = ${this.value.value.$location}) out `;
                 }
                 break;
-            case DeclareType.DECLARE_TYPE_UNIFORM:
+            case 4:
                 if (valueType.isStructType()) {
                     /*
           if (valueType.layout !== 'std140') {
@@ -1743,7 +1744,7 @@ function unbracket(e) {
                     valueType = ctx.typeReplacement?.get(this.value.value) || valueType;
                     return `${indent}uniform ${valueType.toTypeName('webgl2', this.value.name)};\n`;
                 }
-            case DeclareType.DECLARE_TYPE_STORAGE:
+            case 5:
                 throw new Error(`invalid variable declare type: ${this.value.name}`);
         }
         {
@@ -1754,18 +1755,18 @@ function unbracket(e) {
         let prefix;
         const isBlock = this.value.getType().isPrimitiveType() || this.value.getType().isStructType() || this.value.getType().isArrayType();
         switch(this.value.value.$declareType){
-            case DeclareType.DECLARE_TYPE_IN:
-            case DeclareType.DECLARE_TYPE_OUT:
+            case 1:
+            case 2:
                 // prefix = `@location(${this.value.value.$location}) var<out> `;
                 throw new Error(`Internal error`);
-            case DeclareType.DECLARE_TYPE_UNIFORM:
+            case 4:
                 prefix = `@group(${this.group}) @binding(${this.binding}) var${isBlock ? '<uniform>' : ''} `;
                 break;
-            case DeclareType.DECLARE_TYPE_STORAGE:
+            case 5:
                 prefix = `@group(${this.group}) @binding(${this.binding}) var<storage, ${this.value.value.$readonly ? 'read' : 'read_write' //this.value.isWritable() || this.value.getType().haveAtomicMembers() ? 'read_write' : 'read'
                 }> `;
                 break;
-            case DeclareType.DECLARE_TYPE_WORKGROUP:
+            case 3:
                 prefix = `var<workgroup> `;
                 break;
             default:
@@ -1943,12 +1944,14 @@ function unbracket(e) {
     /** @internal */ start;
     /** @internal */ end;
     /** @internal */ open;
-    constructor(init, start, end, open){
+    /** @internal */ reverse;
+    constructor(init, start, end, open, reverse){
         super();
         this.init = init;
         this.start = start;
         this.end = end;
         this.open = open;
+        this.reverse = reverse;
         this.statements = [];
         if (this.start instanceof ASTCallFunction) {
             this.start.isStatement = false;
@@ -1961,8 +1964,8 @@ function unbracket(e) {
         const init = this.init.getType().toTypeName('webgl', this.init.name);
         const start = unbracket(this.start.toWebGL(indent, ctx));
         const end = unbracket(this.end.toWebGL(indent, ctx));
-        const comp = this.open ? '<' : '<=';
-        let str = `${indent}for (${init} = ${start}; ${this.init.name} ${comp} ${end}; ${this.init.name}++) {\n`;
+        const comp = this.open ? this.reverse ? '>' : '<' : this.reverse ? '>=' : '<=';
+        let str = `${indent}for (${init} = ${start}; ${this.init.name} ${comp} ${end}; ${this.init.name}${this.reverse ? '--' : '++'}) {\n`;
         str += super.toWebGL(indent + '  ', ctx);
         str += `${indent}}\n`;
         return str;
@@ -1971,8 +1974,8 @@ function unbracket(e) {
         const init = this.init.getType().toTypeName('webgl2', this.init.name);
         const start = unbracket(this.start.toWebGL2(indent, ctx));
         const end = unbracket(this.end.toWebGL2(indent, ctx));
-        const comp = this.open ? '<' : '<=';
-        let str = `${indent}for (${init} = ${start}; ${this.init.name} ${comp} ${end}; ${this.init.name}++) {\n`;
+        const comp = this.open ? this.reverse ? '>' : '<' : this.reverse ? '>=' : '<=';
+        let str = `${indent}for (${init} = ${start}; ${this.init.name} ${comp} ${end}; ${this.init.name}${this.reverse ? '--' : '++'}) {\n`;
         str += super.toWebGL2(indent + '  ', ctx);
         str += `${indent}}\n`;
         return str;
@@ -1982,8 +1985,8 @@ function unbracket(e) {
         const start = unbracket(this.start.toWGSL(indent, ctx));
         const end = unbracket(this.end.toWGSL(indent, ctx));
         const incr = new ASTScalar(1, this.init.getType()).toWGSL(indent, ctx);
-        const comp = this.open ? '<' : '<=';
-        let str = `${indent}for (${init} = ${start}; ${this.init.name} ${comp} ${end}; ${this.init.name} = ${this.init.name} + ${incr}) {\n`;
+        const comp = this.open ? this.reverse ? '> ' : '<' : this.reverse ? '>=' : '<=';
+        let str = `${indent}for (${init} = ${start}; ${this.init.name} ${comp} ${end}; ${this.init.name} = ${this.init.name} ${this.reverse ? '-' : '+'} ${incr}) {\n`;
         str += super.toWGSL(indent + '  ', ctx);
         str += `${indent}}\n`;
         return str;
@@ -1998,7 +2001,7 @@ function unbracket(e) {
             this.condition.isStatement = false;
         }
     }
-    toWebGL(indent, ctx) {
+    toWebGL(_indent, _ctx) {
         throw new Error(`No do-while() loop support for WebGL1.0 device`);
     }
     toWebGL2(indent, ctx) {
@@ -2065,7 +2068,7 @@ function unbracket(e) {
     getType() {
         return this.type;
     }
-    toWebGL(indent, ctx) {
+    toWebGL(indent, _ctx) {
         if (!this.builtin) {
             let str = `${indent}struct ${this.type.structName} {\n`;
             for (const arg of this.type.structMembers){
@@ -2077,7 +2080,7 @@ function unbracket(e) {
             return '';
         }
     }
-    toWebGL2(indent, ctx) {
+    toWebGL2(indent, _ctx) {
         if (!this.builtin) {
             let str = `${indent}struct ${this.type.structName} {\n`;
             for (const arg of this.type.structMembers){
@@ -2089,7 +2092,7 @@ function unbracket(e) {
             return '';
         }
     }
-    toWGSL(indent, ctx) {
+    toWGSL(indent, _ctx) {
         if (!this.builtin) {
             let str = `${indent}struct ${this.type.structName} {\n`;
             str += this.type.structMembers.map((arg, i)=>{