@galacean/engine-shader-compiler 2.0.0-alpha.43 → 2.0.0-alpha.45

package/dist/main.js

@@ -8924,7 +8924,7 @@ ShaderCompiler._shaderPositionPool = ShaderCompilerUtils.createObjectPool(Shader
 ShaderCompiler._shaderRangePool = ShaderCompilerUtils.createObjectPool(ShaderRange);
 
 //@ts-ignore
-var version = "2.0.0-alpha.43";
+var version = "2.0.0-alpha.45";
 var mode = "Release";
 console.log("Galacean Engine Shader Compiler Version: " + version + " | Mode: " + mode);
 

package/dist/main.verbose.js

@@ -9586,7 +9586,7 @@ ShaderCompiler._shaderPositionPool = ShaderCompilerUtils.createObjectPool(Shader
 ShaderCompiler._shaderRangePool = ShaderCompilerUtils.createObjectPool(ShaderRange);
 
 //@ts-ignore
-var version = "2.0.0-alpha.43";
+var version = "2.0.0-alpha.45";
 var mode = "Release";
 mode = "Verbose";
 console.log("Galacean Engine Shader Compiler Version: " + version + " | Mode: " + mode);

package/dist/module.js

@@ -8920,7 +8920,7 @@ ShaderCompiler._shaderPositionPool = ShaderCompilerUtils.createObjectPool(Shader
 ShaderCompiler._shaderRangePool = ShaderCompilerUtils.createObjectPool(ShaderRange);
 
 //@ts-ignore
-var version = "2.0.0-alpha.43";
+var version = "2.0.0-alpha.45";
 var mode = "Release";
 console.log("Galacean Engine Shader Compiler Version: " + version + " | Mode: " + mode);
 

package/dist/module.verbose.js

@@ -9582,7 +9582,7 @@ ShaderCompiler._shaderPositionPool = ShaderCompilerUtils.createObjectPool(Shader
 ShaderCompiler._shaderRangePool = ShaderCompilerUtils.createObjectPool(ShaderRange);
 
 //@ts-ignore
-var version = "2.0.0-alpha.43";
+var version = "2.0.0-alpha.45";
 var mode = "Release";
 mode = "Verbose";
 console.log("Galacean Engine Shader Compiler Version: " + version + " | Mode: " + mode);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@galacean/engine-shader-compiler",
-  "version": "2.0.0-alpha.43",
+  "version": "2.0.0-alpha.45",
   "publishConfig": {
     "access": "public",
     "registry": "https://registry.npmjs.org"
@@ -57,11 +57,11 @@
   ],
   "dependencies": {
     "@rollup/pluginutils": "^5.0.0",
-    "@galacean/engine-math": "2.0.0-alpha.43",
-    "@galacean/engine-core": "2.0.0-alpha.43"
+    "@galacean/engine-math": "2.0.0-alpha.45",
+    "@galacean/engine-core": "2.0.0-alpha.45"
   },
   "devDependencies": {
-    "@galacean/engine-design": "2.0.0-alpha.43"
+    "@galacean/engine-design": "2.0.0-alpha.45"
   },
   "scripts": {
     "build": "rollup -c rollup.config.js && node -e \"require('fs').chmodSync('bundler/cli.js', 0o755)\"",

package/types/ParserUtils.d.ts

@@ -36,4 +36,8 @@ export declare class ParserUtils {
     static typeCompatible(ta: GalaceanDataType, tb: GalaceanDataType | undefined): boolean;
     static toString(sm: GrammarSymbol): string;
     static isTerminal(sm: GrammarSymbol): boolean;
+    /**
+     * @internal
+     */
+    static printStatePool(logPath: string): void;
 }

package/types/ShaderCompiler.d.ts

@@ -18,4 +18,8 @@ export declare class ShaderCompiler {
     _parseShaderPass(source: string, vertexEntry: string, fragmentEntry: string, backend: ShaderLanguage, basePathForIncludeKey: string): IShaderProgramSource | undefined;
     _precompile(sourceCode: string, platformTarget: ShaderLanguage, basePathForIncludeKey: string): IPrecompiledShader;
     private _serializeRenderStates;
+    /**
+     * @internal
+     */
+    _logErrors(errors: Error[]): void;
 }

package/types/ShaderInstructionEncoder.d.ts

@@ -1 +1,31 @@
+import type { ShaderInstruction } from "@galacean/engine-design";
 export type { ShaderInstruction } from "@galacean/engine-design";
+/**
+ * @internal
+ */
+export declare class ShaderInstructionEncoder {
+    private static _DIRECTIVE_RE;
+    private static _FUNC_MACRO_RE;
+    static parse(glsl: string): ShaderInstruction[];
+    private static _pushConditionInstruction;
+    private static _findDirectiveStart;
+    private static _pushText;
+    /**
+     * Backfill jump offset of an IF/ELIF instruction.
+     * When onlyPlaceholder is true, only backfill if the current value is still -1
+     */
+    private static _backfillJump;
+    private static _stripLineComment;
+    private static _parseCondition;
+    private static _skipWs;
+    private static _parseOr;
+    private static _parseAnd;
+    private static _parseUnary;
+    private static _parsePrimary;
+    private static _isDigit;
+    private static _isAlnum;
+    private static _scanIdentifier;
+    private static _scanNumber;
+    private static _scanOp;
+    private static _evalNumOp;
+}

package/types/codeGen/CodeGenVisitor.d.ts

@@ -1 +1,38 @@
-export {};
+import { ShaderPosition, ShaderRange } from "../common";
+import { ASTNode } from "../parser/AST";
+import { NodeChild, StructProp } from "../parser/types";
+import { ReturnableObjectPool } from "@galacean/engine-core";
+import { TempArray } from "../TempArray";
+/**
+ * @internal
+ * The code generator
+ */
+export declare abstract class CodeGenVisitor {
+    readonly errors: Error[];
+    abstract getAttributeProp(prop: StructProp): string;
+    abstract getVaryingProp(prop: StructProp): string;
+    abstract getMRTProp(prop: StructProp): string;
+    protected static _tmpArrayPool: ReturnableObjectPool<TempArray<string>>;
+    defaultCodeGen(children: NodeChild[]): string;
+    visitPostfixExpression(node: ASTNode.PostfixExpression): string;
+    visitVariableIdentifier(node: ASTNode.VariableIdentifier): string;
+    visitFunctionCall(node: ASTNode.FunctionCall): string;
+    visitMacroCallFunction(node: ASTNode.MacroCallFunction): string;
+    visitStatementList(node: ASTNode.StatementList): string;
+    /**
+     * Code-generate a `#define` macro parsed as expression AST. Produces a `#define`
+     * directive whose value is the AST-rewritten string — so varying flattening
+     * happens naturally via `visitPostfixExpression` inside the AST walk.
+     */
+    visitMacroDefine(node: ASTNode.MacroDefine): string;
+    visitSingleDeclaration(node: ASTNode.SingleDeclaration): string;
+    visitGlobalVariableDeclaration(node: ASTNode.VariableDeclaration): string;
+    visitDeclaration(node: ASTNode.Declaration): string;
+    visitFunctionParameterList(node: ASTNode.FunctionParameterList): string;
+    visitFunctionHeader(node: ASTNode.FunctionHeader): string;
+    visitJumpStatement(node: ASTNode.JumpStatement): string;
+    visitFunctionIdentifier(node: ASTNode.FunctionIdentifier): string;
+    visitStructSpecifier(node: ASTNode.StructSpecifier): string;
+    visitFunctionDefinition(fnNode: ASTNode.FunctionDefinition): string;
+    protected _reportError(loc: ShaderRange | ShaderPosition, message: string): void;
+}

package/types/codeGen/GLESVisitor.d.ts

@@ -1 +1,33 @@
-export {};
+import type { IShaderInfo } from "@galacean/engine-design";
+import { ASTNode } from "../parser/AST";
+import { ShaderData } from "../parser/ShaderInfo";
+import { CodeGenVisitor } from "./CodeGenVisitor";
+import { ICodeSegment } from "./types";
+/**
+ * @internal
+ */
+export declare abstract class GLESVisitor extends CodeGenVisitor {
+    private _globalCodeArray;
+    private static _lookupSymbol;
+    private static _serializedGlobalKey;
+    reset(): void;
+    getOtherGlobal(data: ShaderData, out: ICodeSegment[]): void;
+    visitShaderProgram(node: ASTNode.GLShaderProgram, vertexEntry: string, fragmentEntry: string): IShaderInfo;
+    /** Populate `_structVarMap` for varying/attribute/mrt-typed variables across both stages before codegen. */
+    private _collectAllStructVars;
+    private _vertexMain;
+    private _fragmentMain;
+    private _extractLocalVarNames;
+    /**
+     * Pre-walk `#define` values in global macro declarations and register any
+     * `structVar.prop` member accesses as referenced struct props. This must run before
+     * struct codegen emits the declaration lists (`attribute …`, `varying …`, `MRT …`),
+     * otherwise properties used only from macros would be missing from the output.
+     */
+    private _preRegisterGlobalMacroRefs;
+    private _walkMacroDefineTokens;
+    private _getGlobalSymbol;
+    private _getCustomStruct;
+    private _getGlobalMacroDeclarations;
+    private _visitGlobalMacroIfStatement;
+}

package/types/codeGen/VisitorContext.d.ts

@@ -1,2 +1,49 @@
+import { BaseToken } from "../common/BaseToken";
+import { EShaderStage } from "../common/enums/ShaderStage";
+import { SymbolTable } from "../common/SymbolTable";
+import { ASTNode, TreeNode } from "../parser/AST";
+import { ESymbolType, SymbolInfo } from "../parser/symbolTable";
+import { StructProp } from "../parser/types";
 /** Role of a struct type in the shader compiler's IO flattening. */
 export type StructRole = "varying" | "attribute" | "mrt";
+/** @internal */
+export declare class VisitorContext {
+    private static _lookupSymbol;
+    private static _singleton;
+    static get context(): VisitorContext;
+    static reset(): void;
+    attributeStructs: ASTNode.StructSpecifier[];
+    attributeList: StructProp[];
+    varyingStructs: ASTNode.StructSpecifier[];
+    varyingList: StructProp[];
+    mrtStructs: ASTNode.StructSpecifier[];
+    mrtList: StructProp[];
+    stage: EShaderStage;
+    stageEntry: string;
+    _referencedAttributeList: Record<string, StructProp[]>;
+    _referencedVaryingList: Record<string, StructProp[]>;
+    _referencedMRTList: Record<string, StructProp[]>;
+    _referencedGlobals: Record<string, SymbolInfo[]>;
+    _referencedGlobalMacroASTs: TreeNode[];
+    /**
+     * Maps variable names (function params, locals, and globals whose type is a
+     * varying/attribute/mrt struct) to their role. Populated during stage setup and
+     * used by macro-value rewriting to recognize `varName.prop` patterns that should
+     * be flattened against the IO lists.
+     */
+    _structVarMap: Record<string, StructRole>;
+    _passSymbolTable: SymbolTable<SymbolInfo>;
+    reset(resetAll?: boolean): void;
+    isAttributeStruct(type: string): boolean;
+    isVaryingStruct(type: string): boolean;
+    isMRTStruct(type: string): boolean;
+    /** Return the role of a struct type, or undefined if it isn't one of the IO roles. */
+    getStructRole(typeLexeme: string): StructRole | undefined;
+    /** Register a variable as holding a value of a varying/attribute/mrt struct type. */
+    registerStructVar(varName: string, role: StructRole): void;
+    referenceAttribute(ident: BaseToken): Error | void;
+    referenceVarying(ident: BaseToken): Error | void;
+    referenceMRTProp(ident: BaseToken): Error | void;
+    referenceGlobal(ident: string, type: ESymbolType): void;
+    private _referenceProp;
+}

package/types/common/BaseLexer.d.ts

@@ -1,2 +1,51 @@
+import { ShaderPosition, ShaderRange } from ".";
 import { BaseToken } from "./BaseToken";
 export type OnToken = (token: BaseToken, scanner: BaseLexer) => void;
+/**
+ * @internal
+ */
+export declare abstract class BaseLexer {
+    static isDigit(charCode: number): boolean;
+    static isHexDigit(charCode: number): boolean;
+    static isAlpha(charCode: number): boolean;
+    static isAlnum(charCode: number): boolean;
+    static isPreprocessorStartChar(charCode: number): boolean;
+    /**
+     * If `i` points at the start of a `/* … *\/` block comment, return the index
+     * just past the closing `*\/`. Otherwise return `i` unchanged. If the
+     * comment is unterminated, returns `len` (clamped, never overshoots).
+     * Single source of truth for block-comment scanning across the lexer.
+     */
+    protected static _skipBlockComment(src: string, i: number, len: number): number;
+    /**
+     * If `i` points at the start of a `//` line comment, return the index of the
+     * terminating newline (or `len` at EOF). The newline itself is NOT consumed
+     * — callers decide whether `\n` is whitespace or a logical separator.
+     * Otherwise return `i` unchanged.
+     */
+    protected static _skipLineComment(src: string, i: number, len: number): number;
+    static isWhiteSpaceChar(charCode: number, includeBreak: boolean): boolean;
+    protected _currentIndex: number;
+    protected _source: string;
+    protected _column: number;
+    protected _line: number;
+    get currentIndex(): number;
+    get source(): string;
+    get line(): number;
+    get column(): number;
+    constructor(source?: string);
+    setSource(source: string): void;
+    getShaderPosition(backOffset?: number): ShaderPosition;
+    isEnd(): boolean;
+    getCurChar(): string;
+    getCurCharCode(): number;
+    advance(count: number): void;
+    skipSpace(includeLineBreak: boolean): void;
+    skipCommentsAndSpace(): void;
+    peek(to: number): string;
+    scanLexeme(lexeme: string): void;
+    scanTwoExpectedLexemes(lexeme1: string, lexeme2: string): string | null;
+    throwError(pos: ShaderPosition | ShaderRange, ...msgs: any[]): void;
+    scanPairedChar(left: string, right: string, balanced: boolean, skipLeading: boolean): string;
+    abstract scanToken(onToken?: OnToken): void;
+}

package/types/common/SymbolTable.d.ts

@@ -4,6 +4,10 @@ export declare class SymbolTable<T extends IBaseSymbol> {
     insert(symbol: T, isInMacroBranch?: boolean): void;
     getSymbol(symbol: T, includeMacro?: boolean): T | undefined;
     getSymbols(symbol: T, includeMacro: boolean, out: T[]): T[];
+    /**
+     * @internal
+     */
+    _getSymbols(symbol: T, includeMacro: boolean, out: T[]): T[];
     /** Iterate every registered symbol. Order within a name bucket is insertion order. */
     forEach(callback: (symbol: T) => void): void;
 }

package/types/common/SymbolTableStack.d.ts

@@ -2,6 +2,10 @@ import { IBaseSymbol } from "./IBaseSymbol";
 import { SymbolTable } from "./SymbolTable";
 export declare class SymbolTableStack<S extends IBaseSymbol, T extends SymbolTable<S>> {
     stack: T[];
+    /**
+     * @internal
+     */
+    _macroLevel: number;
     get scope(): T;
     get isInMacroBranch(): boolean;
     pushScope(scope: T): void;

package/types/parser/SemanticAnalyzer.d.ts

@@ -1,2 +1,42 @@
+import { ShaderRange } from "../common";
+import { SymbolTable } from "../common/SymbolTable";
+import { SymbolTableStack } from "../common/SymbolTableStack";
+import { SymbolInfo } from "../parser/symbolTable";
+import { ASTNode, TreeNode } from "./AST";
+import { ShaderData } from "./ShaderInfo";
 import { NodeChild } from "./types";
+import { MacroDefineList } from "../Preprocessor";
 export type TranslationRule<T = any> = (sa: SemanticAnalyzer, ...tokens: NodeChild[]) => T;
+/**
+ * @internal
+ * The semantic analyzer of `ShaderCompiler` compiler.
+ * - Build symbol table
+ * - Static analysis
+ */
+export default class SemanticAnalyzer {
+    /**
+     * @internal
+     */
+    static _lookupSymbol: SymbolInfo;
+    semanticStack: TreeNode[];
+    acceptRule?: TranslationRule;
+    symbolTableStack: SymbolTableStack<SymbolInfo, SymbolTable<SymbolInfo>>;
+    curFunctionInfo: {
+        header?: ASTNode.FunctionDeclarator;
+        returnStatement?: ASTNode.JumpStatement;
+    };
+    private _shaderData;
+    private _translationRuleTable;
+    private _macroDefineList;
+    readonly errors: Error[];
+    get shaderData(): ShaderData;
+    get macroDefineList(): MacroDefineList;
+    constructor();
+    reset(macroDefineList: MacroDefineList): void;
+    pushScope(): void;
+    popScope(): SymbolTable<SymbolInfo>;
+    addTranslationRule(pid: number, rule: TranslationRule): void;
+    getTranslationRule(pid: number): TranslationRule<any>;
+    reportError(loc: ShaderRange, message: string): void;
+    reportWarning(loc: ShaderRange, message: string): void;
+}

package/types/parser/ShaderTargetParser.d.ts

@@ -16,6 +16,8 @@ export declare class ShaderTargetParser {
     private get curState();
     private get stateActionTable();
     private get stateGotoTable();
+    /** @internal */
+    get errors(): Error[];
     static _singleton: ShaderTargetParser;
     static create(): ShaderTargetParser;
     private constructor();

package/types/sourceParser/ShaderSourceParser.d.ts

@@ -1 +1,30 @@
-export {};
+import type { IShaderSource } from "@galacean/engine-design";
+import { GSError } from "../GSError";
+/**
+ * @internal
+ */
+export declare class ShaderSourceParser {
+    static readonly errors: GSError[];
+    private static _renderStateConstMap;
+    private static _symbolTableStack;
+    private static _lexer;
+    private static _lookupSymbol;
+    static parse(sourceCode: string): IShaderSource;
+    private static _parseShader;
+    private static _parseRenderStateDeclarationOrAssignment;
+    private static _mergeRenderStates;
+    private static _parseVariableDeclaration;
+    private static _pushScope;
+    private static _popScope;
+    private static _parseRenderStateProperties;
+    private static _createCompileError;
+    private static _scanEnumConstValue;
+    private static _parseRenderStateProperty;
+    private static _parseRenderQueueDeclarationOrAssignment;
+    private static _addPendingContents;
+    private static _parseSubShader;
+    private static _parseTags;
+    private static _parsePass;
+    private static _parseRenderStateAndTags;
+    private static _parseRenderState;
+}