@galacean/engine-shader-compiler 2.0.0-alpha.49 → 2.0.0-alpha.50

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@galacean/engine-shader-compiler",
-  "version": "2.0.0-alpha.49",
+  "version": "2.0.0-alpha.50",
   "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.49",
-    "@galacean/engine-core": "2.0.0-alpha.49"
+    "@galacean/engine-math": "2.0.0-alpha.50",
+    "@galacean/engine-core": "2.0.0-alpha.50"
   },
   "devDependencies": {
-    "@galacean/engine-design": "2.0.0-alpha.49"
+    "@galacean/engine-design": "2.0.0-alpha.50"
   },
   "scripts": {
     "build": "rollup -c rollup.config.js && node -e \"require('fs').chmodSync('bundler/cli.js', 0o755)\"",

package/types/GSError.d.ts

@@ -3,9 +3,9 @@ import { ShaderRange } from "./common/ShaderRange";
 export declare class GSError extends Error {
     readonly location: ShaderRange | ShaderPosition;
     readonly source: string;
-    readonly file?: string;
+    readonly file?: string | undefined;
     static wrappingLineCount: number;
-    constructor(name: GSErrorName, message: string, location: ShaderRange | ShaderPosition, source: string, file?: string);
+    constructor(name: GSErrorName, message: string, location: ShaderRange | ShaderPosition, source: string, file?: string | undefined);
     toString(): string;
 }
 export declare enum GSErrorName {

package/types/codeGen/CodeGenVisitor.d.ts

@@ -11,7 +11,7 @@ export declare abstract class CodeGenVisitor {
     readonly errors: Error[];
     abstract getAttributeProp(prop: StructProp): string;
     abstract getVaryingProp(prop: StructProp): string;
-    abstract getMRTProp(prop: StructProp): string;
+    abstract getMRTProp(prop: StructProp): string | null;
     protected static _tmpArrayPool: ReturnableObjectPool<TempArray<string>>;
     defaultCodeGen(children: NodeChild[]): string;
     visitPostfixExpression(node: ASTNode.PostfixExpression): string;

package/types/codeGen/GLES100.d.ts

@@ -6,7 +6,7 @@ export declare class GLES100Visitor extends GLESVisitor {
     static getVisitor(): GLES100Visitor;
     getAttributeProp(prop: StructProp): string;
     getVaryingProp(prop: StructProp): string;
-    getMRTProp(): string;
+    getMRTProp(): string | null;
     visitPostfixExpression(node: ASTNode.PostfixExpression): string;
     visitJumpStatement(node: ASTNode.JumpStatement): string;
 }

package/types/codeGen/VisitorContext.d.ts

@@ -34,9 +34,9 @@ export declare class VisitorContext {
     _structVarMap: Record<string, StructRole>;
     _passSymbolTable: SymbolTable<SymbolInfo>;
     reset(resetAll?: boolean): void;
-    isAttributeStruct(type: string): boolean;
-    isVaryingStruct(type: string): boolean;
-    isMRTStruct(type: string): boolean;
+    isAttributeStruct(type: string | undefined): boolean;
+    isVaryingStruct(type: string | undefined): boolean;
+    isMRTStruct(type: string | undefined): 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. */

package/types/common/SymbolTable.d.ts

@@ -3,11 +3,11 @@ export declare class SymbolTable<T extends IBaseSymbol> {
     private _table;
     insert(symbol: T, isInMacroBranch?: boolean): void;
     getSymbol(symbol: T, includeMacro?: boolean): T | undefined;
-    getSymbols(symbol: T, includeMacro: boolean, out: T[]): T[];
+    getSymbols(symbol: T, includeMacro: boolean | undefined, out: T[]): T[];
     /**
      * @internal
      */
-    _getSymbols(symbol: T, includeMacro: boolean, out: T[]): T[];
+    _getSymbols(symbol: T, includeMacro: boolean | undefined, 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

@@ -13,5 +13,5 @@ export declare class SymbolTableStack<S extends IBaseSymbol, T extends SymbolTab
     popScope(): T | undefined;
     insert(symbol: S): void;
     lookup(symbol: S, includeMacro?: boolean): S | undefined;
-    lookupAll(symbol: S, includeMacro: boolean, out: S[]): S[];
+    lookupAll(symbol: S, includeMacro: boolean | undefined, out: S[]): S[];
 }

package/types/lalr/Utils.d.ts

@@ -13,7 +13,7 @@ export default class GrammarUtils {
     /** the ast node */
     astTypePool?: ClearableObjectPool<{
         set: (loc: ShaderRange, children: NodeChild[]) => void;
-    } & IPoolElement & TreeNode>): [GrammarSymbol[], TranslationRule][];
+    } & IPoolElement & TreeNode>): [GrammarSymbol[], TranslationRule | undefined][];
     static addMapSetItem<K, T>(map: Map<K, Set<T>>, k: K, v: T): void;
     static isSubSet<T>(sa: Set<T>, sb: Set<T>): boolean;
     static isActionEqual(a: ActionInfo, b: ActionInfo): boolean;

package/types/parser/AST.d.ts

@@ -87,7 +87,7 @@ export declare namespace ASTNode {
         semanticAnalyze(sa: SemanticAnalyzer): void;
     }
     export class SingleDeclaration extends TreeNode {
-        typeSpecifier: TypeSpecifier;
+        typeSpecifier: TypeSpecifier | undefined;
         arraySpecifier?: ArraySpecifier;
         init(): void;
         semanticAnalyze(sa: SemanticAnalyzer): void;
@@ -166,7 +166,7 @@ export declare namespace ASTNode {
     export class FunctionProtoType extends TreeNode {
         ident: BaseToken;
         returnType: FullySpecifiedType;
-        parameterList: IParamInfo[];
+        parameterList: IParamInfo[] | undefined;
         paramSig: GalaceanDataType[] | undefined;
         semanticAnalyze(sa: SemanticAnalyzer): void;
     }
@@ -378,7 +378,7 @@ export declare namespace ASTNode {
         semanticAnalyze(sa: SemanticAnalyzer): void;
     }
     export class VariableIdentifier extends TreeNode {
-        typeInfo: GalaceanDataType;
+        typeInfo: GalaceanDataType | undefined;
         referenceGlobalSymbolNames: string[];
         private _symbols;
         init(): void;

package/types/parser/Grammar.d.ts

@@ -6,6 +6,6 @@ export declare class Grammar {
     static create(start: NoneTerminal, productions: GrammarSymbol[][]): Grammar;
     constructor(start: NoneTerminal, productions: Production[]);
     getProductionList(nonTerminal: NoneTerminal): Production[];
-    isNullableNT(NT: NoneTerminal): Production;
-    getProductionByID(pid: number): Production;
+    isNullableNT(NT: NoneTerminal): Production | undefined;
+    getProductionByID(pid: number): Production | undefined;
 }

package/types/parser/SemanticAnalyzer.d.ts

@@ -19,11 +19,11 @@ export default class SemanticAnalyzer {
      */
     static _lookupSymbol: SymbolInfo;
     semanticStack: TreeNode[];
-    acceptRule?: TranslationRule;
+    acceptRule?: TranslationRule | undefined;
     symbolTableStack: SymbolTableStack<SymbolInfo, SymbolTable<SymbolInfo>>;
     curFunctionInfo: {
         header?: ASTNode.FunctionDeclarator;
-        returnStatement?: ASTNode.JumpStatement;
+        returnStatement?: ASTNode.JumpStatement | null;
     };
     private _shaderData;
     private _translationRuleTable;
@@ -34,9 +34,9 @@ export default class SemanticAnalyzer {
     constructor();
     reset(macroDefineList: MacroDefineList): void;
     pushScope(): void;
-    popScope(): SymbolTable<SymbolInfo>;
+    popScope(): SymbolTable<SymbolInfo> | undefined;
     addTranslationRule(pid: number, rule: TranslationRule): void;
-    getTranslationRule(pid: number): TranslationRule<any>;
+    getTranslationRule(pid: number): TranslationRule<any> | undefined;
     reportError(loc: ShaderRange, message: string): void;
     reportWarning(loc: ShaderRange, message: string): void;
 }

package/types/parser/builtin/variables.d.ts

@@ -7,5 +7,5 @@ export declare class BuiltinVariable {
     scope: EShaderStage;
     private constructor();
     static createVariable(lexeme: string, type: GalaceanDataType, scope?: EShaderStage): void;
-    static getVar(ident: string): BuiltinVariable;
+    static getVar(ident: string): BuiltinVariable | undefined;
 }

package/types/parser/symbolTable/SymbolDataType.d.ts

@@ -3,6 +3,6 @@ import { ASTNode } from "../AST";
 export declare class SymbolDataType {
     type: GalaceanDataType;
     typeLexeme: string;
-    arraySpecifier?: ASTNode.ArraySpecifier;
-    constructor(type: GalaceanDataType, typeLexeme: string, arraySpecifier?: ASTNode.ArraySpecifier);
+    arraySpecifier?: ASTNode.ArraySpecifier | undefined;
+    constructor(type: GalaceanDataType, typeLexeme: string, arraySpecifier?: ASTNode.ArraySpecifier | undefined);
 }

package/types/parser/symbolTable/SymbolInfo.d.ts

@@ -11,12 +11,12 @@ export declare enum ESymbolType {
 export type SymbolAstNode = ASTNode.Initializer | ASTNode.StructSpecifier | ASTNode.FunctionDefinition | ASTNode.ParameterDeclarator | ASTNode.InitDeclaratorList | ASTNode.VariableDeclaration;
 export declare class SymbolInfo implements IBaseSymbol {
     ident: string;
-    type: ESymbolType;
-    astNode?: SymbolAstNode;
-    dataType?: SymbolDataType;
-    paramSignature?: GalaceanDataType[];
+    type: ESymbolType | null;
+    astNode?: SymbolAstNode | undefined;
+    dataType?: SymbolDataType | undefined;
+    paramSignature?: GalaceanDataType[] | undefined;
     isInMacroBranch: boolean;
-    constructor(ident: string, type: ESymbolType, astNode?: SymbolAstNode, dataType?: SymbolDataType, paramSignature?: GalaceanDataType[], isInMacroBranch?: boolean);
+    constructor(ident: string, type: ESymbolType | null, astNode?: SymbolAstNode | undefined, dataType?: SymbolDataType | undefined, paramSignature?: GalaceanDataType[] | undefined, isInMacroBranch?: boolean);
     set(ident: string, symbolType: ESymbolType, astNode?: SymbolAstNode, dataType?: SymbolDataType, paramSignature?: GalaceanDataType[]): void;
     equal(symbol: SymbolInfo): boolean;
 }

package/types/parser/types.d.ts

@@ -6,15 +6,15 @@ export type TraceStackItem = NoneTerminal | BaseToken;
 export declare class SymbolType {
     type: GalaceanDataType;
     typeLexeme: string;
-    arraySpecifier?: ASTNode.ArraySpecifier;
-    constructor(type: GalaceanDataType, typeLexeme: string, arraySpecifier?: ASTNode.ArraySpecifier);
+    arraySpecifier?: ASTNode.ArraySpecifier | undefined;
+    constructor(type: GalaceanDataType, typeLexeme: string, arraySpecifier?: ASTNode.ArraySpecifier | undefined);
 }
 export declare class StructProp implements IParamInfo {
     typeInfo: SymbolType;
     ident: BaseToken;
-    mrtIndex?: number;
+    mrtIndex?: number | undefined;
     isInMacroBranch: boolean;
-    constructor(typeInfo: SymbolType, ident: BaseToken, mrtIndex?: number, isInMacroBranch?: boolean);
+    constructor(typeInfo: SymbolType, ident: BaseToken, mrtIndex?: number | undefined, isInMacroBranch?: boolean);
 }
 export type NodeChild = TreeNode | BaseToken;
 export type IParamInfo = {

package/types/sourceParser/ShaderSourceSymbol.d.ts

@@ -1,10 +1,10 @@
 import { IBaseSymbol } from "../common/IBaseSymbol";
 export declare class ShaderSourceSymbol implements IBaseSymbol {
     ident: string;
-    type: number;
+    type: number | null;
     value?: any;
     isInMacroBranch: boolean;
-    constructor(ident: string, type: number, value?: any);
+    constructor(ident: string, type: number | null, value?: any);
     set(ident: string, type: number, value?: any): void;
     equal(other: ShaderSourceSymbol): boolean;
 }

package/types/sourceParser/SourceLexer.d.ts

@@ -10,7 +10,7 @@ export default class SourceLexer extends BaseLexer {
     private static _scanDigits;
     scanNumber(): number;
     scanColor(): Color;
-    scanToken(): BaseToken;
+    scanToken(): BaseToken | undefined;
     scanToCharacter(char: string): void;
     createCompileError(message: string, location?: ShaderPosition | ShaderRange): Error;
     private _scanWord;