@galacean/engine-shader-compiler 2.0.0-alpha.51 → 2.0.0-alpha.53

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@galacean/engine-shader-compiler",
-  "version": "2.0.0-alpha.51",
+  "version": "2.0.0-alpha.53",
   "publishConfig": {
     "access": "public",
     "registry": "https://registry.npmjs.org"
@@ -21,6 +21,11 @@
       "require": "./dist/main.js",
       "types": "./types/index.d.ts"
     },
+    "./precompile": {
+      "import": "./dist/precompile.module.js",
+      "require": "./dist/precompile.main.js",
+      "types": "./types/precompile.d.ts"
+    },
     "./bundler/rollup": {
       "import": "./bundler/rollup.js",
       "require": "./bundler/rollup.cjs.js",
@@ -31,11 +36,6 @@
       "require": "./bundler/precompile.cjs.js",
       "types": "./types/bundler/precompile.d.ts"
     },
-    "./verbose": {
-      "import": "./dist/module.verbose.js",
-      "require": "./dist/main.verbose.js",
-      "types": "./types/index.d.ts"
-    },
     "./src/*": "./src/*.ts",
     "./package.json": "./package.json"
   },
@@ -52,19 +52,30 @@
   "files": [
     "dist/**/*",
     "bundler/**/*",
-    "types/**/*",
-    "verbose/package.json"
+    "types/**/*"
   ],
   "dependencies": {
     "@rollup/pluginutils": "^5.0.0",
-    "@galacean/engine-math": "2.0.0-alpha.51",
-    "@galacean/engine-core": "2.0.0-alpha.51"
+    "@galacean/engine-core": "2.0.0-alpha.53",
+    "@galacean/engine-design": "2.0.0-alpha.53",
+    "@galacean/engine-shader-parser": "2.0.0-alpha.53",
+    "@galacean/engine-math": "2.0.0-alpha.53"
   },
-  "devDependencies": {
-    "@galacean/engine-design": "2.0.0-alpha.51"
+  "typesVersions": {
+    "*": {
+      "precompile": [
+        "types/precompile.d.ts"
+      ],
+      "bundler/rollup": [
+        "types/bundler/rollup.d.ts"
+      ],
+      "bundler/precompile": [
+        "types/bundler/precompile.d.ts"
+      ]
+    }
   },
   "scripts": {
-    "build": "rollup -c rollup.config.js && node -e \"require('fs').chmodSync('bundler/cli.js', 0o755)\"",
+    "build": "rollup -c rollup.config.js",
     "b:types": "tsc"
   }
 }

package/types/GLESBackend.d.ts

@@ -0,0 +1,22 @@
+import type { IShaderInfo } from "@galacean/engine-design";
+import { ShaderLanguage } from "@galacean/engine-core";
+import { type ShaderClueIR, type ShaderCoreInfo } from "@galacean/engine-shader-parser/internal";
+/**
+ * Static internal facade for GLES source generation.
+ * @internal
+ */
+export declare class GLESBackend {
+    private static readonly _gles100VisitorPool;
+    private static readonly _gles300VisitorPool;
+    private constructor();
+    /**
+     * Generates one GLES program with request-owned visitor state.
+     * @param ir - Request-owned neutral parser IR consumed read-only.
+     * @param coreInfo - Entry and stage-interface facts derived from the same IR.
+     * @param target - GLES language version to emit.
+     * @returns Generated vertex and fragment source.
+     * @internal
+     */
+    static generate(ir: ShaderClueIR, coreInfo: ShaderCoreInfo, target: ShaderLanguage): IShaderInfo | undefined;
+    private static _generateWithPool;
+}

package/types/ShaderBackend.d.ts

@@ -0,0 +1,15 @@
+import type { IShaderInfo } from "@galacean/engine-design";
+import type { ShaderClueIR, ShaderCoreInfo } from "@galacean/engine-shader-parser/internal";
+/**
+ * Internal boundary implemented by shader source backends.
+ * @internal
+ */
+export interface ShaderBackend {
+    /**
+     * Generates target source from neutral shader facts.
+     * @param ir - Neutral shader IR backed by the parsed program.
+     * @param coreInfo - Entry and IO facts required by code generation.
+     * @returns Generated stage source.
+     */
+    generate(ir: ShaderClueIR, coreInfo: ShaderCoreInfo): IShaderInfo;
+}

package/types/ShaderCompilation.d.ts

@@ -0,0 +1,40 @@
+import { ShaderLanguage } from "@galacean/engine-core";
+import type { IRenderStates, IShaderSource } from "@galacean/engine-design";
+import type { IShaderProgramSource } from "@galacean/engine-design/types/shader-compiler/IShaderProgramSource";
+import { ShaderCoreInfo, type ParsedShaderPassData, type ShaderSourceParseResult } from "@galacean/engine-shader-parser/internal";
+/**
+ * Rejects a partial ShaderLab structure when source parsing produced errors.
+ * @param result - ShaderLab source-parser result.
+ * @returns Complete parsed ShaderLab structure.
+ * @throws ShaderSourceParseError when structural source diagnostics exist.
+ * @internal
+ */
+export declare function requireValidShaderSource(result: ShaderSourceParseResult): IShaderSource;
+/**
+ * Generates one backend program from a parser-owned pass without reparsing it.
+ * @param parsed - Neutral parser output.
+ * @param vertexEntry - Vertex entry name.
+ * @param fragmentEntry - Fragment entry name.
+ * @param backend - Target GLES language.
+ * @param coreInfo - Optional stage facts already derived from this exact parser result.
+ * @returns Generated program, or `undefined` when parser or entry admission fails.
+ * @internal
+ */
+export declare function generateParsedShaderPassData(parsed: ParsedShaderPassData, vertexEntry: string, fragmentEntry: string, backend: ShaderLanguage, coreInfo?: ShaderCoreInfo): IShaderProgramSource | undefined;
+/**
+ * Converts parser-owned render states into JSON-safe precompile data.
+ * @param renderStates - Parsed render-state maps.
+ * @returns Serializable constant and variable maps.
+ * @internal
+ */
+export declare function serializeRenderStates(renderStates: IRenderStates): {
+    constantMap: Record<string, number | string | boolean | number[]>;
+    variableMap: Record<string, string>;
+};
+/**
+ * Formats a parser failure with include-source attribution.
+ * @param error - Parser failure.
+ * @returns User-facing error text.
+ * @internal
+ */
+export declare function formatShaderError(error: Error): string;

package/types/ShaderCompiler.d.ts

@@ -1,25 +1,53 @@
 import { ShaderLanguage } from "@galacean/engine-core";
-import type { IPrecompiledShader, IShaderSource } from "@galacean/engine-design";
+import type { IShaderSource } from "@galacean/engine-design";
 import type { IShaderProgramSource } from "@galacean/engine-design/types/shader-compiler/IShaderProgramSource";
-import { ShaderPosition, ShaderRange } from "./common";
-import { IncludeMap } from "./Preprocessor";
+import { type IncludeMap } from "@galacean/engine-shader-parser/internal";
+import type { ParsedShaderPass } from "@galacean/engine-shader-parser/shared";
+/**
+ * Compiles ShaderLab sources into runtime GLES programs.
+ *
+ * Source parsing and backend generation remain independent of authoring diagnostics; structural
+ * source errors reject compilation before partial runtime programs can be created. Offline `.shaderc`
+ * validation lives in the bundler-only precompiler entry and is excluded from this runtime package surface.
+ */
 export declare class ShaderCompiler {
-    private static _parser;
-    private static _shaderPositionPool;
-    private static _shaderRangePool;
-    static _processingPassText?: string;
     private _includeMap;
     private readonly _chunkOutputCache;
-    /** Replace the `#include` lookup table and clear the derived chunk cache. */
+    private readonly _sourceParserObjectPool;
+    private readonly _parserObjectPool;
+    private readonly _runtimeParser;
+    /**
+     * Replaces the `#include` lookup table and clears the derived chunk cache.
+     * @param includeMap - Canonical include paths mapped to shader chunks.
+     * @internal
+     */
     _setIncludeMap(includeMap: IncludeMap): void;
-    static createPosition(index: number, line?: number, column?: number): ShaderPosition;
-    static createRange(start: ShaderPosition, end: ShaderPosition): ShaderRange;
+    /**
+     * Parses one ShaderLab document into its source structure.
+     * @param sourceCode - Complete ShaderLab source.
+     * @returns Parsed subshaders, passes, entries, and render states.
+     * @throws ShaderSourceParseError when source-structure diagnostics were produced.
+     * @internal
+     */
     _parseShaderSource(sourceCode: string): IShaderSource;
-    _parseShaderPass(source: string, vertexEntry: string, fragmentEntry: string, backend: ShaderLanguage, basePathForIncludeKey: string): IShaderProgramSource | undefined;
-    _precompile(sourceCode: string, platformTarget: ShaderLanguage, basePathForIncludeKey: string): IPrecompiledShader;
-    private _serializeRenderStates;
     /**
+     * Parses and generates one runtime ShaderLab pass.
+     * @param source - GLSL source contained by the pass.
+     * @param vertexEntry - Vertex entry function name.
+     * @param fragmentEntry - Fragment entry function name.
+     * @param backend - Target GLES language version.
+     * @param sourceFile - Optional logical source location used for relative includes and attribution.
+     * @param sourceScopeStarts - Inherited ShaderLab content boundaries from source parsing.
+     * @returns Generated stage program, or `undefined` after a blocking parser or backend error.
      * @internal
      */
-    _logErrors(errors: Error[]): void;
+    _parseShaderPass(source: string, vertexEntry: string, fragmentEntry: string, backend: ShaderLanguage, sourceFile?: string, sourceScopeStarts?: readonly number[]): IShaderProgramSource | undefined;
+    /**
+     * Generates backend source from a pass returned by `ShaderAnalyzer.analyze()` without parsing it again.
+     * @param pass - Opaque parsed-pass handle from the analyzer result.
+     * @param backend - Target GLES language version.
+     * @returns Variant-selectable instructions and unselected text for inspection, or `undefined` on validation failure.
+     * @throws TypeError when `pass` was not created by the compatible shader-parser package instance.
+     */
+    generate(pass: ParsedShaderPass, backend: ShaderLanguage): IShaderProgramSource | undefined;
 }

package/types/ShaderInstructionEncoder.d.ts

@@ -1,4 +1,5 @@
-import type { ShaderInstruction } from "@galacean/engine-design";
+import type { PreprocessorExpressionParseResult, ShaderInstruction } from "@galacean/engine-design";
+import type { DeferredDeclarationOwnership } from "@galacean/engine-shader-parser/internal";
 export type { ShaderInstruction } from "@galacean/engine-design";
 /**
  * @internal
@@ -6,9 +7,52 @@ export type { ShaderInstruction } from "@galacean/engine-design";
 export declare class ShaderInstructionEncoder {
     private static _DIRECTIVE_RE;
     private static _FUNC_MACRO_RE;
-    static parse(glsl: string): ShaderInstruction[];
+    /**
+     * Marks compiler-owned text without placing parser objects in the instruction stream.
+     * @param text - Declaration or derived declaration text.
+     * @param owner - Neutral declaration identity, if runtime selection is required.
+     * @param activate - Whether this is the declaration's original source position.
+     * @returns Intermediate source consumed by the instruction encoder.
+     * @internal
+     */
+    static declaration(text: string, owner?: DeferredDeclarationOwnership, activate?: boolean): string;
+    /**
+     * Marks derived text shared by any selected, reachable declaration without activating an owner.
+     * @param text - Shared derived declaration text.
+     * @param owners - Declarations that require the text; an empty list never retains it.
+     * @returns Intermediate source consumed by the instruction encoder.
+     * @internal
+     */
+    static sharedDeclaration(text: string, owners: readonly DeferredDeclarationOwnership[]): string;
+    /**
+     * Records a declaration dependency for variant-time reachability after ownership selection.
+     * @param from - Referencing declaration identity, or zero for a stage root.
+     * @param to - Referenced declaration identity.
+     * @returns Intermediate source consumed by the instruction encoder.
+     * @internal
+     */
+    static reference(from: number, to: number): string;
+    /**
+     * Removes private emission markers from the public source view after instruction encoding.
+     * @param source - Encoded intermediate stage source.
+     * @returns GLSL source without compiler metadata.
+     * @internal
+     */
+    static source(source: string): string;
+    /**
+     * Encodes generated GLSL directives into runtime-selectable instructions.
+     * @param glsl - Generated stage source.
+     * @param preprocessorExpressions - Parser-owned expression trees keyed by logical directive text.
+     * @returns Runtime shader instruction stream.
+     * @throws Error when a conditional directive is malformed or has a deterministic evaluation failure.
+     * @internal
+     */
+    static parse(glsl: string, preprocessorExpressions?: ReadonlyMap<string, PreprocessorExpressionParseResult>): ShaderInstruction[];
     private static _pushConditionInstruction;
+    private static _parseCondition;
     private static _findDirectiveStart;
+    private static _findLogicalLineEnd;
+    private static _findInlineWhitespace;
     private static _pushText;
     /**
      * Backfill jump offset of an IF/ELIF instruction.
@@ -16,16 +60,4 @@ export declare class ShaderInstructionEncoder {
      */
     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/ShaderPrecompiler.d.ts

@@ -0,0 +1,31 @@
+import { ShaderLanguage } from "@galacean/engine-core";
+import type { IPrecompiledShader } from "@galacean/engine-design";
+import { type IncludeMap } from "@galacean/engine-shader-parser/internal/analyzer";
+/**
+ * Offline-only ShaderLab to `.shaderc` compiler with deterministic validation.
+ *
+ * This class is intentionally excluded from the runtime compiler entry. CLI and bundler adapters import
+ * it from `@galacean/engine-shader-compiler/precompile`.
+ */
+export declare class ShaderPrecompiler {
+    private _includeMap;
+    private readonly _chunkOutputCache;
+    private readonly _sourceParserObjectPool;
+    private readonly _parserObjectPool;
+    private readonly _validatedParser;
+    /**
+     * Replaces the logical include registry used by offline compilation.
+     * @param includeMap - Canonical or normalizable include keys mapped to chunk sources.
+     * @throws Error when multiple keys collide after normalization.
+     */
+    setIncludeMap(includeMap: IncludeMap): void;
+    /**
+     * Compiles complete ShaderLab source into a serializable `.shaderc` structure.
+     * @param sourceCode - Complete ShaderLab source.
+     * @param platformTarget - Target GLES language.
+     * @param sourceFile - Optional logical root location used for relative includes and attribution.
+     * @returns Serializable precompiled shader.
+     * @throws Error when structural parsing, pass validation, or backend generation fails.
+     */
+    precompile(sourceCode: string, platformTarget: ShaderLanguage, sourceFile?: string): IPrecompiledShader;
+}

package/types/bundler/precompile.d.ts

@@ -1,5 +1,10 @@
-/** Normalize to forward slashes (Windows uses `\`; downstream regex/keys assume `/`). */
+/**
+ * Converts a filesystem path to the slash-separated form used by shader asset keys.
+ * @param p - Filesystem path.
+ * @returns Slash-separated path.
+ */
 export declare function normalizePath(p: string): string;
+/** Controls CLI and programmatic `.shaderc` generation for one source tree. */
 export interface PrecompileOptions {
     /** Absolute or relative path to the directory containing `.shader` sources. */
     input: string;
@@ -9,17 +14,35 @@ export interface PrecompileOptions {
     clean?: boolean;
     /** Watch the input dir and re-run incrementally on `.shader` / `.glsl` changes. */
     watch?: boolean;
-    /** Compile only this file (path may be relative to cwd). Skips full scan + cleanup. */
+    /** Compile only this `.shader` file inside `input` (path may be relative to cwd). Skips full scan + cleanup. */
     only?: string;
     /** Generate `<output>/index.ts` aggregating every `.shaderc` file. */
     emitIndex?: boolean;
     /** Generate raw-source indexes: `<input>/index.ts` (.shader) + sibling `ShaderLibrary/index.ts` (.glsl). */
     emitSources?: boolean;
-    /** Optional shader platform target passed through to `_precompile`. Defaults to `0`. */
+    /** Optional shader platform target passed through to `precompile`. Defaults to `0`. */
     platformTarget?: number;
 }
+/**
+ * Precompiles shaders once or starts incremental watch mode.
+ * @param options - Source, output, cleanup, watch, and artifact-generation options.
+ * @returns After a one-shot compile finishes or a watch has been installed.
+ * @throws Error when a one-shot compile has failures or the source tree is invalid.
+ */
 export declare function precompile(options: PrecompileOptions): Promise<void>;
+/**
+ * Precompiles the current shader source tree once.
+ * @param options - Source, output, cleanup, and artifact-generation options.
+ * @returns An object containing the number of shader sources that failed to compile.
+ * @throws Error when the input tree or an explicitly selected source is invalid.
+ */
 export declare function runFull(options: Omit<PrecompileOptions, "watch">): Promise<{
     failed: number;
 }>;
+/**
+ * Watches one shader source tree and serializes incremental rebuilds.
+ * @param options - Source, output, cleanup, and artifact-generation options.
+ * @returns Once the filesystem watcher has been installed.
+ * @throws Error when the initial include registry cannot be loaded.
+ */
 export declare function startWatcher(options: Omit<PrecompileOptions, "watch" | "only">): Promise<void>;

package/types/bundler/rollup.d.ts

@@ -1,4 +1,4 @@
-import type { Plugin } from "rollup";
+/** Controls the offline precompile step started by the Rollup plugin. */
 export interface ShaderPrecompileOptions {
     /** Directory containing `.shader` source files. */
     input: string;
@@ -13,6 +13,7 @@ export interface ShaderPrecompileOptions {
     /** Shader platform target. Default `0`. */
     platformTarget?: number;
 }
+/** Configures shader asset transformation and optional offline precompilation. */
 export interface ShaderPluginOptions {
     /**
      * Override the default include pattern. The plugin always matches `.glsl`,
@@ -30,6 +31,22 @@ export interface ShaderPluginOptions {
      */
     precompile?: ShaderPrecompileOptions;
 }
+/** Minimal host context shared by supported Rollup and Vite versions. */
+interface ShaderPluginContext {
+    error(message: string): never;
+    warn(message: string): void;
+    meta: {
+        watchMode: boolean;
+    };
+}
+/** The implemented hooks, without unrelated hooks tied to the build's Rollup version. */
+export interface ShaderCompilerPlugin {
+    name: string;
+    buildStart(this: ShaderPluginContext): Promise<void>;
+    transform(code: string, id: string): {
+        code: string;
+    } | null;
+}
 /**
  * Rollup plugin that transforms shader assets into JS modules.
  *
@@ -37,5 +54,9 @@ export interface ShaderPluginOptions {
  * - When `precompile` option is set: runs a full precompile in buildStart and,
  *   in watch mode, starts a background watcher that mirrors `.shader` source
  *   changes into `.shaderc` outputs and refreshes the aggregated index.
+ * @param options - Transform filter and optional offline precompile configuration.
+ * @returns Rollup plugin for shader source and artifact modules.
+ * @throws Error during `buildStart` when offline precompilation reports failures.
  */
-export declare function shaderCompiler(options?: ShaderPluginOptions): Plugin;
+export declare function shaderCompiler(options?: ShaderPluginOptions): ShaderCompilerPlugin;
+export {};

package/types/codeGen/CodeGenVisitor.d.ts

@@ -1,21 +1,26 @@
-import { ShaderPosition, ShaderRange } from "../common";
-import { ASTNode } from "../parser/AST";
-import { NodeChild, StructProp } from "../parser/types";
+import { ASTNode, TreeNode } from "@galacean/engine-shader-parser/internal";
+import { FnSymbol } from "@galacean/engine-shader-parser/internal";
+import { NodeChild, StructProp } from "@galacean/engine-shader-parser/internal";
+import type { BranchSignature, ICodeGenVisitor } from "@galacean/engine-shader-parser/internal";
+import { VisitorContext } from "./VisitorContext";
 import { ReturnableObjectPool } from "@galacean/engine-core";
 import { TempArray } from "../TempArray";
 /**
  * @internal
  * The code generator
  */
-export declare abstract class CodeGenVisitor {
-    readonly errors: Error[];
+export declare abstract class CodeGenVisitor implements ICodeGenVisitor {
     abstract getAttributeProp(prop: StructProp): string;
     abstract getVaryingProp(prop: StructProp): string;
     abstract getMRTProp(prop: StructProp): string | null;
     protected static _tmpArrayPool: ReturnableObjectPool<TempArray<string>>;
+    protected readonly context: VisitorContext;
+    cache(node: TreeNode, code: string): string;
+    getCachedCode(node: TreeNode): string | undefined;
     defaultCodeGen(children: NodeChild[]): string;
     visitPostfixExpression(node: ASTNode.PostfixExpression): string;
     visitVariableIdentifier(node: ASTNode.VariableIdentifier): string;
+    protected referenceFunction(symbol: FnSymbol, referenceIndex: number, branch: BranchSignature): void;
     visitFunctionCall(node: ASTNode.FunctionCall): string;
     visitMacroCallFunction(node: ASTNode.MacroCallFunction): string;
     visitStatementList(node: ASTNode.StatementList): string;
@@ -32,7 +37,7 @@ export declare abstract class CodeGenVisitor {
     visitFunctionHeader(node: ASTNode.FunctionHeader): string;
     visitJumpStatement(node: ASTNode.JumpStatement): string;
     visitFunctionIdentifier(node: ASTNode.FunctionIdentifier): string;
+    visitTypeSpecifier(node: ASTNode.TypeSpecifier): string;
     visitStructSpecifier(node: ASTNode.StructSpecifier): string;
     visitFunctionDefinition(fnNode: ASTNode.FunctionDefinition): string;
-    protected _reportError(loc: ShaderRange | ShaderPosition, message: string): void;
 }

package/types/codeGen/GLES100.d.ts

@@ -1,12 +1,10 @@
-import { ASTNode } from "../parser/AST";
-import { StructProp } from "../parser/types";
+import { ASTNode } from "@galacean/engine-shader-parser/internal";
+import { StructProp } from "@galacean/engine-shader-parser/internal";
 import { GLESVisitor } from "./GLESVisitor";
 export declare class GLES100Visitor extends GLESVisitor {
-    private static _singleton;
-    static getVisitor(): GLES100Visitor;
     getAttributeProp(prop: StructProp): string;
     getVaryingProp(prop: StructProp): string;
-    getMRTProp(): string | null;
+    getMRTProp(): string;
     visitPostfixExpression(node: ASTNode.PostfixExpression): string;
     visitJumpStatement(node: ASTNode.JumpStatement): string;
 }

package/types/codeGen/GLES300.d.ts

@@ -1,13 +1,14 @@
-import { ASTNode } from "../parser/AST";
-import { ShaderData } from "../parser/ShaderInfo";
-import { StructProp } from "../parser/types";
+import { ASTNode } from "@galacean/engine-shader-parser/internal";
+import { ShaderData } from "@galacean/engine-shader-parser/internal";
+import { ShaderEntryPointInfo } from "@galacean/engine-shader-parser/internal";
+import { StructProp } from "@galacean/engine-shader-parser/internal";
 import { GLESVisitor } from "./GLESVisitor";
 import { ICodeSegment } from "./types";
 export declare class GLES300Visitor extends GLESVisitor {
-    private static _singleton;
-    static getVisitor(): GLES300Visitor;
-    private _otherCodeArray;
-    private _fragColorVariableRegistered;
+    private readonly _outputDeclarations;
+    private _fragDataArrayRequired;
+    private readonly _fragDataIndices;
+    private readonly _scannedFragmentFunctions;
     reset(): void;
     getOtherGlobal(data: ShaderData, out: ICodeSegment[]): void;
     getAttributeProp(prop: StructProp): string;
@@ -15,6 +16,12 @@ export declare class GLES300Visitor extends GLESVisitor {
     getMRTProp(prop: StructProp): string;
     visitFunctionIdentifier(node: ASTNode.FunctionIdentifier): string;
     visitVariableIdentifier(node: ASTNode.VariableIdentifier): string;
+    visitPostfixExpression(node: ASTNode.PostfixExpression): string;
     visitJumpStatement(node: ASTNode.JumpStatement): string;
     private _registerFragColorVariable;
+    private _registerOutput;
+    protected prepareFragment(entryInfo: ShaderEntryPointInfo, outerGlobalMacroStatements: readonly ASTNode.GlobalDeclaration[]): void;
+    private _scanFragmentOutputs;
+    private _registerFragDataArray;
+    private _registerFragDataVariable;
 }

package/types/codeGen/GLESVisitor.d.ts

@@ -1,23 +1,53 @@
 import type { IShaderInfo } from "@galacean/engine-design";
-import { ASTNode } from "../parser/AST";
-import { ShaderData } from "../parser/ShaderInfo";
+import type { IPoolElement } from "@galacean/engine-core";
+import { ASTNode } from "@galacean/engine-shader-parser/internal";
+import { ShaderData } from "@galacean/engine-shader-parser/internal";
+import { FnSymbol } from "@galacean/engine-shader-parser/internal";
+import type { BranchSignature, ShaderClueIR, ShaderCoreInfo, ShaderEntryPointInfo, DeferredDeclarationOwnership } from "@galacean/engine-shader-parser/internal";
 import { CodeGenVisitor } from "./CodeGenVisitor";
 import { ICodeSegment } from "./types";
+import type { ShaderBackend } from "../ShaderBackend";
 /**
  * @internal
  */
-export declare abstract class GLESVisitor extends CodeGenVisitor {
+export declare abstract class GLESVisitor extends CodeGenVisitor implements ShaderBackend, IPoolElement {
     private _globalCodeArray;
-    private static _lookupSymbol;
-    private static _serializedGlobalKey;
+    private readonly _forwardFunctionDeclarations;
+    private readonly _forwardStructIndices;
+    private readonly _structCodeSegments;
+    private readonly _forwardVariableIndices;
+    private readonly _variableCodeSegments;
+    private readonly _declarationOwners;
+    private readonly _deferredPrototypes;
+    private readonly _declarationReferences;
+    private _currentDeclaration?;
+    private _sourceIR?;
+    private _outerMacroDeclarations;
+    /**
+     * Clears pass-local output retained by the pooled visitor.
+     */
     reset(): void;
+    /**
+     * Releases references retained by an idle visitor when its pool is collected.
+     * @internal
+     */
+    dispose(): void;
+    /**
+     * Emits target-specific declarations that precede generated global code.
+     * @param data - Parser-owned shader facts.
+     * @param out - Destination code segments.
+     */
     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;
+    /**
+     * Generates vertex and fragment source from neutral parser facts.
+     * @param ir - Request-owned neutral shader IR.
+     * @param coreInfo - Entry and stage-interface facts derived from the same IR.
+     * @returns Generated vertex and fragment source.
+     */
+    generate(ir: ShaderClueIR, coreInfo: ShaderCoreInfo): IShaderInfo;
     private _vertexMain;
     private _fragmentMain;
-    private _extractLocalVarNames;
+    protected prepareFragment(entryInfo: ShaderEntryPointInfo, outerGlobalMacroStatements: readonly ASTNode.GlobalDeclaration[]): void;
     /**
      * Pre-walk `#define` values in global macro declarations and register any
      * `structVar.prop` member accesses as referenced struct props. This must run before
@@ -26,8 +56,24 @@ export declare abstract class GLESVisitor extends CodeGenVisitor {
      */
     private _preRegisterGlobalMacroRefs;
     private _walkMacroDefineTokens;
+    private _registerFragmentReturns;
     private _getGlobalSymbol;
+    protected referenceFunction(symbol: FnSymbol, referenceIndex: number, branch: BranchSignature): void;
+    private _getForwardSignature;
+    private _canBranchesOverlap;
+    visitVariableIdentifier(node: ASTNode.VariableIdentifier): string;
+    private _getForwardDeclarations;
+    visitTypeSpecifier(node: ASTNode.TypeSpecifier): string;
+    private _prepareForwardTypes;
+    private _isContextIndependent;
+    private _hasDeclarationContextBarrier;
+    private _unsupportedForwardDeclaration;
     private _getCustomStruct;
     private _getGlobalMacroDeclarations;
     private _visitGlobalMacroIfStatement;
+    /** Ownership of the declaration currently generating dependencies. @internal */
+    protected get currentDeclarationOwner(): DeferredDeclarationOwnership | undefined;
+    private _referenceDeclaration;
+    private _emitDeclarationReferences;
+    private _declaration;
 }