@galacean/engine-shaderlab 1.6.0-alpha.2 → 1.6.0-beta.1

package/types/parser/AST.d.ts

@@ -1,12 +1,12 @@
-import { BuiltinVariable } from "./builtin";
 import { ClearableObjectPool, IPoolElement } from "@galacean/engine";
 import { CodeGenVisitor } from "../codeGen";
-import { EKeyword, GalaceanDataType, ShaderRange, TokenType } from "../common";
-import { BaseToken, BaseToken as Token } from "../common/BaseToken";
+import { GalaceanDataType, ShaderRange, TokenType } from "../common";
+import { BaseToken } from "../common/BaseToken";
+import { Keyword } from "../common/enums/Keyword";
 import { NoneTerminal } from "./GrammarSymbol";
 import SemanticAnalyzer from "./SemanticAnalyzer";
 import { ShaderData } from "./ShaderInfo";
-import { FnSymbol, StructSymbol, VarSymbol } from "./symbolTable";
+import { FnSymbol, StructSymbol } from "./symbolTable";
 import { IParamInfo, NodeChild, StructProp, SymbolType } from "./types";
 export declare abstract class TreeNode implements IPoolElement {
     static pool: ClearableObjectPool<TreeNode & {
@@ -15,12 +15,24 @@ export declare abstract class TreeNode implements IPoolElement {
     /** The non-terminal in grammar. */
     nt: NoneTerminal;
     private _children;
+    private _parent;
     private _location;
+    private _codeCache;
+    /**
+     * Parent pointer for AST traversal.
+     * @remarks
+     * The parent pointer is only reliable after the entire AST has been constructed.
+     * DO NOT rely on `parent` during the `semanticAnalyze` phase, as the AST may still be under construction.
+     * It is safe to use `parent` during code generation or any phase after AST construction.
+     */
+    get parent(): TreeNode;
     get children(): NodeChild[];
     get location(): ShaderRange;
     set(loc: ShaderRange, children: NodeChild[]): void;
     init(): void;
     dispose(): void;
+    setCache(code: string): string;
+    getCache(): string;
     codeGen(visitor: CodeGenVisitor): string;
     /**
      * Do semantic analyze right after the ast node is generated.
@@ -28,6 +40,7 @@ export declare abstract class TreeNode implements IPoolElement {
     semanticAnalyze(sa: SemanticAnalyzer): void;
 }
 export declare namespace ASTNode {
+    type MacroExpression = MacroPushContext | MacroPopContext | MacroElseExpression | MacroElifExpression | MacroUndef | BaseToken;
     export type ASTNodePool = ClearableObjectPool<{
         set: (loc: ShaderRange, children: NodeChild[]) => void;
     } & IPoolElement & TreeNode>;
@@ -88,12 +101,12 @@ export declare namespace ASTNode {
     export class TypeQualifier extends TreeNode {
     }
     export class SingleTypeQualifier extends TreeNode {
-        qualifier: EKeyword;
+        qualifier: Keyword;
         lexeme: string;
         semanticAnalyze(sa: SemanticAnalyzer): void;
     }
     abstract class BasicTypeQualifier extends TreeNode {
-        qualifier: EKeyword;
+        qualifier: Keyword;
         lexeme: string;
         semanticAnalyze(sa: SemanticAnalyzer): void;
     }
@@ -143,7 +156,7 @@ export declare namespace ASTNode {
         semanticAnalyze(sa: SemanticAnalyzer): void;
     }
     export class IdentifierList extends TreeNode {
-        idList: Token[];
+        idList: BaseToken[];
         init(): void;
         semanticAnalyze(sa: SemanticAnalyzer): void;
     }
@@ -151,22 +164,21 @@ export declare namespace ASTNode {
         codeGen(visitor: CodeGenVisitor): string;
     }
     export class FunctionProtoType extends TreeNode {
-        ident: Token;
+        ident: BaseToken;
         returnType: FullySpecifiedType;
         parameterList: IParamInfo[];
-        paramSig: GalaceanDataType[];
+        paramSig: GalaceanDataType[] | undefined;
         semanticAnalyze(sa: SemanticAnalyzer): void;
-        codeGen(visitor: CodeGenVisitor): string;
     }
     export class FunctionDeclarator extends TreeNode {
-        ident: Token;
+        ident: BaseToken;
         returnType: FullySpecifiedType;
         parameterInfoList: IParamInfo[] | undefined;
         paramSig: GalaceanDataType[] | undefined;
         semanticAnalyze(sa: SemanticAnalyzer): void;
     }
     export class FunctionHeader extends TreeNode {
-        ident: Token;
+        ident: BaseToken;
         returnType: FullySpecifiedType;
         semanticAnalyze(sa: SemanticAnalyzer): void;
         codeGen(visitor: CodeGenVisitor): string;
@@ -178,15 +190,20 @@ export declare namespace ASTNode {
         semanticAnalyze(sa: SemanticAnalyzer): void;
         codeGen(visitor: CodeGenVisitor): string;
     }
+    export class MacroParamCaseList extends TreeNode {
+    }
+    export class MacroParamBlock extends TreeNode {
+    }
+    export class MacroParameterBranch extends TreeNode {
+    }
     export class ParameterDeclaration extends TreeNode {
-        typeQualifier: TypeQualifier | undefined;
-        typeInfo: SymbolType;
-        ident: Token;
+        typeInfo?: SymbolType;
+        ident?: BaseToken;
         init(): void;
         semanticAnalyze(sa: SemanticAnalyzer): void;
     }
     export class ParameterDeclarator extends TreeNode {
-        ident: Token;
+        ident: BaseToken;
         typeInfo: SymbolType;
         semanticAnalyze(sa: SemanticAnalyzer): void;
     }
@@ -205,6 +222,7 @@ export declare namespace ASTNode {
         returnStatement?: ASTNode.JumpStatement;
         protoType: FunctionProtoType;
         statements: CompoundStatementNoScope;
+        isInMacroBranch: boolean;
         init(): void;
         semanticAnalyze(sa: SemanticAnalyzer): void;
         codeGen(visitor: CodeGenVisitor): string;
@@ -220,10 +238,16 @@ export declare namespace ASTNode {
     }
     export class FunctionCallParameterList extends TreeNode {
         paramSig: GalaceanDataType[];
-        paramNodes: AssignmentExpression[];
+        paramNodes: Array<AssignmentExpression | MacroCallArgBlock>;
         init(): void;
         semanticAnalyze(sa: SemanticAnalyzer): void;
     }
+    export class MacroCallArgCaseList extends TreeNode {
+    }
+    export class MacroCallArgBlock extends TreeNode {
+    }
+    export class MacroCallArgBranch extends TreeNode {
+    }
     export class PrecisionSpecifier extends TreeNode {
         semanticAnalyze(sa: SemanticAnalyzer): void;
     }
@@ -291,23 +315,40 @@ export declare namespace ASTNode {
         semanticAnalyze(sa: SemanticAnalyzer): void;
     }
     export class StructSpecifier extends TreeNode {
-        ident?: Token;
+        ident?: BaseToken;
         propList: StructProp[];
+        macroExpressions: MacroExpression[];
+        isInMacroBranch: boolean;
         init(): void;
         semanticAnalyze(sa: SemanticAnalyzer): void;
+        codeGen(visitor: CodeGenVisitor): string;
     }
     export class StructDeclarationList extends TreeNode {
         propList: StructProp[];
+        macroExpressions: MacroExpression[];
         init(): void;
         semanticAnalyze(sa: SemanticAnalyzer): void;
     }
     export class StructDeclaration extends TreeNode {
-        typeSpecifier: TypeSpecifier;
-        declaratorList: StructDeclaratorList;
         props: StructProp[];
+        macroExpressions: MacroExpression[];
+        private _typeSpecifier?;
+        private _declaratorList?;
         init(): void;
         semanticAnalyze(sa: SemanticAnalyzer): void;
     }
+    export class MacroStructDeclaration extends TreeNode {
+        props: StructProp[];
+        macroExpressions: MacroExpression[];
+        init(): void;
+        semanticAnalyze(): void;
+    }
+    export class MacroStructBranch extends TreeNode {
+        props: StructProp[];
+        macroExpressions: MacroExpression[];
+        init(): void;
+        semanticAnalyze(): void;
+    }
     export class LayoutQualifier extends TreeNode {
         index: number;
         semanticAnalyze(sa: SemanticAnalyzer): void;
@@ -318,30 +359,90 @@ export declare namespace ASTNode {
         semanticAnalyze(sa: SemanticAnalyzer): void;
     }
     export class StructDeclarator extends TreeNode {
-        ident: Token;
+        ident: BaseToken;
         arraySpecifier: ArraySpecifier | undefined;
         init(): void;
         semanticAnalyze(sa: SemanticAnalyzer): void;
     }
     export class VariableDeclaration extends TreeNode {
         type: FullySpecifiedType;
+        isStatic: boolean;
+        init(): void;
         semanticAnalyze(sa: SemanticAnalyzer): void;
         codeGen(visitor: CodeGenVisitor): string;
     }
     export class VariableDeclarationList extends TreeNode {
         type: FullySpecifiedType;
+        variableDeclarations: VariableDeclaration[];
+        init(): void;
         semanticAnalyze(sa: SemanticAnalyzer): void;
     }
     export class VariableIdentifier extends TreeNode {
-        symbolInfo: VarSymbol | BuiltinVariable | null;
-        lexeme: string;
         typeInfo: GalaceanDataType;
+        referenceGlobalSymbolNames: string[];
+        private _symbols;
+        init(): void;
         semanticAnalyze(sa: SemanticAnalyzer): void;
         codeGen(visitor: CodeGenVisitor): string;
+        getLexeme(visitor: CodeGenVisitor): string;
     }
     export class GLShaderProgram extends TreeNode {
         shaderData: ShaderData;
         semanticAnalyze(sa: SemanticAnalyzer): void;
     }
+    export class GlobalDeclaration extends TreeNode {
+        macroExpressions: Array<MacroExpression | MacroUndef | BaseToken>;
+        init(): void;
+        semanticAnalyze(sa: SemanticAnalyzer): void;
+    }
+    export class MacroUndef extends TreeNode {
+        codeGen(visitor: CodeGenVisitor): string;
+    }
+    export class MacroPushContext extends TreeNode {
+        semanticAnalyze(sa: SemanticAnalyzer): void;
+        codeGen(visitor: CodeGenVisitor): string;
+    }
+    export class MacroPopContext extends TreeNode {
+        semanticAnalyze(sa: SemanticAnalyzer): void;
+        codeGen(visitor: CodeGenVisitor): string;
+    }
+    export class MacroElifExpression extends TreeNode {
+        codeGen(visitor: CodeGenVisitor): string;
+    }
+    export class MacroElseExpression extends TreeNode {
+        codeGen(visitor: CodeGenVisitor): string;
+    }
+    export class GlobalMacroDeclaration extends TreeNode {
+        macroExpressions: MacroExpression[];
+        init(): void;
+        semanticAnalyze(sa: SemanticAnalyzer): void;
+        codeGen(visitor: CodeGenVisitor): string;
+    }
+    export class GlobalMacroIfStatement extends TreeNode {
+        macroExpressions: MacroExpression[];
+        init(): void;
+        semanticAnalyze(sa: SemanticAnalyzer): void;
+    }
+    export class GlobalMacroBranch extends TreeNode {
+        macroExpressions: MacroExpression[];
+        init(): void;
+        semanticAnalyze(sa: SemanticAnalyzer): void;
+    }
+    export class MacroIfStatement extends TreeNode {
+    }
+    export class MacroBranch extends TreeNode {
+    }
+    export class MacroCallSymbol extends TreeNode {
+        referenceSymbolNames: string[];
+        macroName: string;
+        init(): void;
+        semanticAnalyze(sa: SemanticAnalyzer): void;
+    }
+    export class MacroCallFunction extends TreeNode {
+        referenceSymbolNames: string[];
+        macroName: string;
+        semanticAnalyze(sa: SemanticAnalyzer): void;
+        codeGen(visitor: CodeGenVisitor): string;
+    }
     export {};
 }

package/types/parser/GrammarSymbol.d.ts

@@ -101,7 +101,27 @@ export declare enum NoneTerminal {
     typename_identifier_node = 2097,
     scope_brace = 2098,
     scope_end_brace = 2099,
-    _ignore = 2100
+    macro_undef = 2100,
+    macro_push_context = 2101,
+    macro_pop_context = 2102,
+    macro_elif_expression = 2103,
+    macro_else_expression = 2104,
+    global_macro_if_statement = 2105,
+    global_macro_declaration = 2106,
+    global_macro_branch = 2107,
+    macro_struct_declaration = 2108,
+    macro_struct_branch = 2109,
+    macro_if_statement = 2110,
+    macro_branch = 2111,
+    macro_param_case_list = 2112,
+    macro_param_block = 2113,
+    macro_parameter_branch = 2114,
+    macro_call_arg_case_list = 2115,
+    macro_call_arg_block = 2116,
+    macro_call_arg_branch = 2117,
+    macro_call_symbol = 2118,
+    macro_call_function = 2119,
+    _ignore = 2120
 }
 export type GrammarSymbol = Terminal | NoneTerminal;
 export type Derivation = GrammarSymbol[];

package/types/parser/ShaderInfo.d.ts

@@ -1,8 +1,10 @@
+import { SymbolInfo, SymbolTable } from "../parser/symbolTable";
 import { ASTNode } from "./AST";
-import { TargetSymbolTable } from "../parser/symbolTable";
 export declare class ShaderData {
-    symbolTable: TargetSymbolTable;
+    symbolTable: SymbolTable<SymbolInfo>;
     vertexMain: ASTNode.FunctionDefinition;
     fragmentMain: ASTNode.FunctionDefinition;
     globalPrecisions: ASTNode.PrecisionSpecifier[];
+    globalMacroDeclarations: ASTNode.GlobalDeclaration[];
+    getOuterGlobalMacroDeclarations(): ASTNode.GlobalDeclaration[];
 }

package/types/parser/ShaderTargetParser.d.ts

@@ -1,7 +1,8 @@
-import { Grammar } from "./Grammar";
 import { BaseToken } from "../common/BaseToken";
 import { StateActionTable, StateGotoTable } from "../lalr/types";
+import { MacroDefineList } from "../Preprocessor";
 import { ASTNode } from "./AST";
+import { Grammar } from "./Grammar";
 import SematicAnalyzer from "./SemanticAnalyzer";
 /**
  * The syntax parser and sematic analyzer of `ShaderLab` compiler
@@ -18,6 +19,6 @@ export declare class ShaderTargetParser {
     static _singleton: ShaderTargetParser;
     static create(): ShaderTargetParser;
     private constructor();
-    parse(tokens: Generator<BaseToken, BaseToken>): ASTNode.GLShaderProgram | null;
+    parse(tokens: Generator<BaseToken, BaseToken>, macroDefineList: MacroDefineList): ASTNode.GLShaderProgram | null;
     private _printStack;
 }

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

@@ -1,5 +1,5 @@
 import { GalaceanDataType } from "../../common";
-import { EShaderStage } from "../../common/Enums";
+import { EShaderStage } from "../../common/enums/ShaderStage";
 export declare enum EGenType {
     GenType = 200,
     GenIntType = 201,
@@ -30,5 +30,6 @@ export declare class BuiltinFunction {
     static _create(ident: string, returnType: BuiltinType, ...args: BuiltinType[]): void;
     static _createWithScop(ident: string, returnType: BuiltinType, scope: EShaderStage, ...args: BuiltinType[]): void;
     static getFn(ident: string, parameterTypes: NonGenericGalaceanType[]): BuiltinFunction | undefined;
+    static isExist(ident: string): boolean;
 }
 export {};

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

@@ -1,5 +1,5 @@
 import { GalaceanDataType } from "../../common";
-import { EShaderStage } from "../../common/Enums";
+import { EShaderStage } from "../../common/enums/ShaderStage";
 export declare const BuiltinVariableTable: Map<string, BuiltinVariable>;
 export declare class BuiltinVariable {
     type: GalaceanDataType;

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

@@ -1,18 +1,22 @@
-import { IBaseSymbol } from "../../common/BaseSymbolTable";
+import { IBaseSymbol } from "../../common/IBaseSymbol";
 import { GalaceanDataType } from "../../common/types";
 import { ASTNode } from "../AST";
 import { SymbolDataType } from "./SymbolDataType";
 export declare enum ESymbolType {
     VAR = 0,
     FN = 1,
-    STRUCT = 2
+    STRUCT = 2,
+    Any = 3
 }
 export type SymbolAstNode = ASTNode.Initializer | ASTNode.StructSpecifier | ASTNode.FunctionDefinition | ASTNode.ParameterDeclarator | ASTNode.InitDeclaratorList | ASTNode.VariableDeclaration;
 export declare class SymbolInfo implements IBaseSymbol {
-    readonly ident: string;
-    readonly symbolType: ESymbolType;
-    readonly astNode?: SymbolAstNode;
-    readonly dataType?: SymbolDataType;
-    readonly signature?: GalaceanDataType[];
-    constructor(ident: string, symbolType: ESymbolType, astNode?: SymbolAstNode, dataType?: SymbolDataType, signature?: GalaceanDataType[]);
+    ident: string;
+    type: ESymbolType;
+    astNode?: SymbolAstNode;
+    dataType?: SymbolDataType;
+    paramSignature?: GalaceanDataType[];
+    isInMacroBranch: boolean;
+    constructor(ident: string, type: ESymbolType, astNode?: SymbolAstNode, dataType?: SymbolDataType, paramSignature?: GalaceanDataType[], isInMacroBranch?: boolean);
+    set(ident: string, symbolType: ESymbolType, astNode?: SymbolAstNode, dataType?: SymbolDataType, paramSignature?: GalaceanDataType[]): void;
+    equal(symbol: SymbolInfo): boolean;
 }

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

@@ -1,6 +1,6 @@
+export * from "././../../common/SymbolTable";
 export * from "./FnSymbol";
 export * from "./StructSymbol";
 export * from "./SymbolDataType";
 export * from "./SymbolInfo";
-export * from "./TargetSymbolTable";
 export * from "./VarSymbol";

package/types/parser/types.d.ts

@@ -1,7 +1,7 @@
-import { NoneTerminal } from "./GrammarSymbol";
-import { BaseToken } from "../common/BaseToken";
 import { GalaceanDataType } from "../common";
+import { BaseToken } from "../common/BaseToken";
 import { ASTNode, TreeNode } from "./AST";
+import { NoneTerminal } from "./GrammarSymbol";
 export type TraceStackItem = NoneTerminal | BaseToken;
 export declare class SymbolType {
     type: GalaceanDataType;
@@ -13,11 +13,12 @@ export declare class StructProp implements IParamInfo {
     typeInfo: SymbolType;
     ident: BaseToken;
     mrtIndex?: number;
-    constructor(typeInfo: SymbolType, ident: BaseToken, mrtIndex?: number);
+    isInMacroBranch: boolean;
+    constructor(typeInfo: SymbolType, ident: BaseToken, mrtIndex?: number, isInMacroBranch?: boolean);
 }
 export type NodeChild = TreeNode | BaseToken;
 export type IParamInfo = {
-    ident: BaseToken;
-    typeInfo: SymbolType;
-    astNode?: TreeNode;
+    ident?: BaseToken;
+    typeInfo?: SymbolType;
+    astNode?: ASTNode.ParameterDeclaration | ASTNode.MacroParamBlock;
 };

package/types/sourceParser/ShaderSourceFactory.d.ts

@@ -0,0 +1,8 @@
+import { IRenderStates, IShaderPassSource, IShaderSource, ISubShaderSource } from "@galacean/engine-design";
+export declare class ShaderSourceFactory {
+    static createRenderStates(): IRenderStates;
+    static createShaderSource(name: string): IShaderSource;
+    static createSubShaderSource(name: string): ISubShaderSource;
+    static createShaderPassSource(name: string): IShaderPassSource;
+    static createUsePass(name: string): IShaderPassSource;
+}

package/types/sourceParser/ShaderSourceSymbol.d.ts

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

package/types/sourceParser/SourceLexer.d.ts

@@ -0,0 +1,19 @@
+import { Color } from "@galacean/engine";
+import { ShaderPosition, ShaderRange } from "../common";
+import { BaseLexer } from "../common/BaseLexer";
+import { BaseToken } from "../common/BaseToken";
+export default class SourceLexer extends BaseLexer {
+    hasPendingContent: boolean;
+    private static _keywordLexemeTable;
+    private static _symbolLexemeTable;
+    private static _isWordSeparatorChar;
+    private static _scanDigits;
+    scanNumber(): number;
+    scanColor(): Color;
+    scanToken(): BaseToken;
+    scanToCharacter(char: string): void;
+    createCompileError(message: string, location?: ShaderPosition | ShaderRange): Error;
+    private _scanWord;
+    private _validateWordBoundaries;
+    private _isValidWordBoundary;
+}

package/types/sourceParser/index.d.ts

@@ -0,0 +1 @@
+export { ShaderSourceParser } from "./ShaderSourceParser";

package/types/common/BaseScanner.d.ts

@@ -1,2 +0,0 @@
-import { BaseToken } from "./BaseToken";
-export type OnToken = (token: BaseToken, scanner: BaseScanner) => void;

package/types/common/BaseSymbolTable.d.ts

@@ -1,18 +0,0 @@
-export interface IBaseSymbol {
-    readonly ident: string;
-}
-/**
- * The base class of `SymbolTable`
- */
-export declare abstract class BaseSymbolTable<T extends IBaseSymbol = IBaseSymbol> {
-    protected _table: Map<string, T[]>;
-    abstract insert(sm: T): void;
-}
-export declare class SymbolTableStack<S extends IBaseSymbol, T extends BaseSymbolTable<S>> {
-    stack: T[];
-    get _scope(): T;
-    newScope(scope: T): void;
-    clear(): void;
-    dropScope(): void;
-    insert(sm: S): void;
-}

package/types/common/Keywords.d.ts

@@ -1,99 +0,0 @@
-export declare enum EKeyword {
-    ATTRIBUTE = 0,
-    CONST = 1,
-    BOOL = 2,
-    FLOAT = 3,
-    DOUBLE = 4,
-    INT = 5,
-    UINT = 6,
-    BREAK = 7,
-    CONTINUE = 8,
-    DO = 9,
-    ELSE = 10,
-    FOR = 11,
-    IF = 12,
-    WHILE = 13,
-    DISCARD = 14,
-    RETURN = 15,
-    BVEC2 = 16,
-    BVEC3 = 17,
-    BVEC4 = 18,
-    IVEC2 = 19,
-    IVEC3 = 20,
-    IVEC4 = 21,
-    UVEC2 = 22,
-    UVEC3 = 23,
-    UVEC4 = 24,
-    VEC2 = 25,
-    VEC3 = 26,
-    VEC4 = 27,
-    VEC4_ARRAY = 28,
-    MAT2 = 29,
-    MAT3 = 30,
-    MAT4 = 31,
-    MAT2X3 = 32,
-    MAT2X4 = 33,
-    MAT3X2 = 34,
-    MAT3X4 = 35,
-    MAT4X2 = 36,
-    MAT4X3 = 37,
-    IN = 38,
-    OUT = 39,
-    INOUT = 40,
-    CENTROID = 41,
-    SAMPLER2D = 42,
-    SAMPLER3D = 43,
-    SAMPLER_CUBE = 44,
-    SAMPLER2D_SHADOW = 45,
-    SAMPLER_CUBE_SHADOW = 46,
-    SAMPLER2D_ARRAY = 47,
-    SAMPLER2D_ARRAY_SHADOW = 48,
-    I_SAMPLER2D = 49,
-    I_SAMPLER3D = 50,
-    I_SAMPLER_CUBE = 51,
-    I_SAMPLER2D_ARRAY = 52,
-    U_SAMPLER2D = 53,
-    U_SAMPLER3D = 54,
-    U_SAMPLER_CUBE = 55,
-    U_SAMPLER2D_ARRAY = 56,
-    STRUCT = 57,
-    LAYOUT = 58,
-    LOCATION = 59,
-    VOID = 60,
-    TRUE = 61,
-    FALSE = 62,
-    PRECISION = 63,
-    PRECISE = 64,
-    HIGHP = 65,
-    MEDIUMP = 66,
-    LOWP = 67,
-    INVARIANT = 68,
-    SMOOTH = 69,
-    FLAT = 70,
-    NOPERSPECTIVE = 71,
-    GS_RenderQueueType = 72,
-    GS_BlendState = 73,
-    GS_DepthState = 74,
-    GS_StencilState = 75,
-    GS_RasterState = 76,
-    GS_EditorProperties = 77,
-    GS_EditorMacros = 78,
-    GS_Editor = 79,
-    GS_Tags = 80,
-    GS_ReplacementTag = 81,
-    GS_LightMode = 82,
-    GS_PipelineStage = 83,
-    GS_VertexShader = 84,
-    GS_FragmentShader = 85,
-    GS_SubShader = 86,
-    GS_Pass = 87,
-    GS_BlendFactor = 88,
-    GS_BlendOperation = 89,
-    GS_Bool = 90,
-    GS_Number = 91,
-    GS_Color = 92,
-    GS_CompareFunction = 93,
-    GS_StencilOperation = 94,
-    GS_CullMode = 95,
-    GS_UsePass = 96
-}

package/types/contentParser/ContentSymbolTable.d.ts

@@ -1,10 +0,0 @@
-import { TokenType } from "../common";
-import { BaseSymbolTable, IBaseSymbol } from "../common/BaseSymbolTable";
-export interface ISymbol extends IBaseSymbol {
-    type: number;
-    value?: any;
-}
-export default class ContentSymbolTable extends BaseSymbolTable<ISymbol> {
-    insert(sm: ISymbol): void;
-    lookup(ident: string, type: TokenType): ISymbol | undefined;
-}

package/types/contentParser/KeywordMap.d.ts

@@ -1,2 +0,0 @@
-import { EKeyword } from "../common";
-export declare const KeywordMap: Map<string, EKeyword>;

package/types/contentParser/Scanner.d.ts

@@ -1,10 +0,0 @@
-import BaseScanner from "../common/BaseScanner";
-export default class Scanner extends BaseScanner {
-    constructor(source: string, kws?: Map<string, number>);
-    /**
-     * split by space
-     */
-    scanWord(): string;
-    scanNumber(): number;
-    scanToCharacter(char: string): void;
-}

package/types/contentParser/index.d.ts

@@ -1 +0,0 @@
-export { ShaderContentParser } from "./ShaderContentParser";

package/types/lexer/Utils.d.ts

@@ -1,7 +0,0 @@
-export default class LexerUtils {
-    static isNum(charCode: number): boolean;
-    static isLetter(charCode: number): boolean;
-    static isAlpha(charCode: number): boolean;
-    static isPpCharacters(charCode: number): boolean;
-    static isSpace(charCode: number): charCode is 9 | 10 | 13 | 32;
-}

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

@@ -1,13 +0,0 @@
-import { GalaceanDataType } from "../../common";
-import { BaseSymbolTable } from "../../common/BaseSymbolTable";
-import { ASTNode } from "../AST";
-import { FnSymbol } from "./FnSymbol";
-import { StructSymbol } from "./StructSymbol";
-import { ESymbolType, SymbolInfo } from "./SymbolInfo";
-import { VarSymbol } from "./VarSymbol";
-export declare class TargetSymbolTable extends BaseSymbolTable<SymbolInfo> {
-    insert(sm: SymbolInfo): void;
-    lookup<T extends ESymbolType>(ident: string, symbolType: T, signature?: GalaceanDataType[], astNode?: ASTNode.FunctionDefinition): T extends ESymbolType.FN ? FnSymbol : T extends ESymbolType.STRUCT ? StructSymbol : T extends ESymbolType.VAR ? VarSymbol : SymbolInfo;
-    getAllFnSymbols(fnIdent: string): FnSymbol[];
-    private _compareWith;
-}