@galacean/engine-core 2.0.0-alpha.44 → 2.0.0-alpha.45

package/types/physics/shape/ColliderShape.d.ts

@@ -1,4 +1,5 @@
 import { DataObject } from "../../base/DataObject";
+import { IColliderShape } from "@galacean/engine-design";
 import { PhysicsMaterial } from "../PhysicsMaterial";
 import { Vector3 } from "@galacean/engine-math";
 import { Collider } from "../Collider";
@@ -8,12 +9,24 @@ import type { ICloneHook } from "../../clone/ICloneHook";
  */
 export declare abstract class ColliderShape extends DataObject implements ICloneHook<ColliderShape> {
     private static _idGenerator;
+    /** @internal */
+    _collider: Collider;
+    /** @internal */
+    _nativeShape: IColliderShape;
+    /** @internal */
+    _isShapeAttached: boolean;
     protected _id: number;
     protected _material: PhysicsMaterial;
     private _isTrigger;
     private _rotation;
     private _position;
     private _contactOffset;
+    /**
+     * @internal
+     * @beta
+     * Whether raycast can select it.
+     */
+    isSceneQuery: boolean;
     /**
      * Collider owner of this shape.
      */
@@ -60,6 +73,10 @@ export declare abstract class ColliderShape extends DataObject implements IClone
      * @inheritdoc
      */
     _onClone(target: ColliderShape): void;
+    /**
+     * @internal
+     */
+    _destroy(): void;
     protected _syncNative(): void;
     private _setPosition;
     private _setRotation;

package/types/physics/shape/MeshColliderShape.d.ts

@@ -38,6 +38,10 @@ export declare class MeshColliderShape extends ColliderShape {
      * @inheritdoc
      */
     _onClone(target: MeshColliderShape): void;
+    /**
+     * @internal
+     */
+    _destroy(): void;
     private _clearMeshData;
     private _destroyNativeShape;
     private _extractMeshData;

package/types/postProcess/FinalPass.d.ts

@@ -1 +1,19 @@
-export {};
+import { Camera } from "../Camera";
+import { Engine } from "../Engine";
+import { PipelinePass } from "../RenderPipeline/PipelinePass";
+import { RenderContext } from "../RenderPipeline/RenderContext";
+import { RenderTarget } from "../texture";
+/**
+ * @internal
+ * Processing sRGB Conversion and FXAA.
+ */
+export declare class FinalPass extends PipelinePass {
+    private _inputRenderTarget;
+    private _srgbRenderTarget;
+    private _antiAliasingMaterial;
+    private _sRGBmaterial;
+    constructor(engine: Engine);
+    onConfig(camera: Camera, inputRenderTarget: RenderTarget): void;
+    onRender(context: RenderContext): void;
+    release(): void;
+}

package/types/postProcess/PostProcess.d.ts

@@ -13,6 +13,8 @@ export declare class PostProcess extends Component {
      * The outer distance to start blending from, only takes effect when the `isGlobal` is false.
      */
     blendDistance: number;
+    /** @internal */
+    _effects: PostProcessEffect[];
     private _priority;
     private _isGlobal;
     /**

package/types/postProcess/PostProcessEffect.d.ts

@@ -17,6 +17,10 @@ export declare class PostProcessEffect extends DataObject {
      * This method can be overridden to control the effect's real validity.
      */
     isValid(): boolean;
+    /**
+     * @internal
+     */
+    _lerp(to: PostProcessEffect, factor: number): void;
     /**
      * Get all parameters of the post process effect.
      * @remarks

package/types/postProcess/PostProcessEffectParameter.d.ts

@@ -19,6 +19,10 @@ export declare abstract class PostProcessEffectParameter<T> extends DataObject {
     get value(): T;
     set value(value: T);
     constructor(value: T, needLerp?: boolean);
+    /**
+     * @internal
+     */
+    _lerp(to: T, factor: number): void;
 }
 /**
  * Represents a float parameter of a post process effect.

package/types/postProcess/PostProcessManager.d.ts

@@ -1,4 +1,8 @@
+import { Camera } from "../Camera";
 import { Scene } from "../Scene";
+import { Material } from "../material";
+import { RenderTarget } from "../texture";
+import { PostProcess } from "./PostProcess";
 import { PostProcessEffect } from "./PostProcessEffect";
 /**
  * A global manager of the PostProcess.
@@ -7,6 +11,12 @@ export declare class PostProcessManager {
     readonly scene: Scene;
     private static _tempColliders;
     private static _tempVector3;
+    /** @internal */
+    _uberMaterial: Material;
+    /** @internal */
+    _postProcessNeedSorting: boolean;
+    /** @internal */
+    _postProcessPassNeedSorting: boolean;
     private _activePostProcesses;
     private _swapRenderTarget;
     private _srcRenderTarget;
@@ -22,6 +32,23 @@ export declare class PostProcessManager {
      * @param scene - Scene to which the current PostProcessManager belongs
      */
     constructor(scene: Scene);
+    /**
+     * @internal
+     * Whether has any valid post process pass.
+     */
+    _isValid(): boolean;
+    /**
+     * @internal
+     */
+    _update(camera: Camera): void;
+    /**
+     * @internal
+     */
+    _addPostProcess(postProcess: PostProcess): void;
+    /**
+     * @internal
+     */
+    _removePostProcess(postProcess: PostProcess): void;
     /**
      * Get the blend effect by type.
      * @remarks
@@ -30,6 +57,22 @@ export declare class PostProcessManager {
      * @returns The PostProcessEffect instance found
      */
     getBlendEffect<T extends typeof PostProcessEffect>(type: T): InstanceType<T>;
+    /**
+     * @internal
+     */
+    _render(camera: Camera, srcRenderTarget: RenderTarget, destRenderTarget: RenderTarget): void;
+    /**
+     * @internal
+     */
+    _releaseSwapRenderTarget(): void;
+    /**
+     * @internal
+     */
+    _releaseOutputRenderTarget(): void;
+    /**
+     * @internal
+     */
+    _getOutputRenderTarget(camera: Camera): RenderTarget;
     private _sortActivePostProcess;
     private _resetDefaultValue;
     private _initSwapRenderTarget;

package/types/postProcess/effects/BloomEffect.d.ts

@@ -1,3 +1,4 @@
+import { ShaderMacro, ShaderProperty } from "../../shader";
 import { PostProcessEffect } from "../PostProcessEffect";
 import { PostProcessEffectBoolParameter, PostProcessEffectColorParameter, PostProcessEffectEnumParameter, PostProcessEffectFloatParameter, PostProcessEffectTextureParameter } from "../PostProcessEffectParameter";
 /**
@@ -11,6 +12,30 @@ export declare enum BloomDownScaleMode {
 }
 export declare class BloomEffect extends PostProcessEffect {
     static readonly SHADER_NAME = "PostProcess/Bloom";
+    /** @internal */
+    static _maxIterations: number;
+    /** @internal */
+    static _hqMacro: ShaderMacro;
+    /** @internal */
+    static _dirtMacro: ShaderMacro;
+    /** @internal */
+    static _bloomParams: ShaderProperty;
+    /** @internal */
+    static _lowMipTextureProp: ShaderProperty;
+    /** @internal */
+    static _lowMipTexelSizeProp: ShaderProperty;
+    /** @internal */
+    static _enableMacro: ShaderMacro;
+    /** @internal */
+    static _bloomTextureProp: ShaderProperty;
+    /** @internal */
+    static _dirtTextureProp: ShaderProperty;
+    /** @internal */
+    static _tintProp: ShaderProperty;
+    /** @internal */
+    static _bloomIntensityParams: ShaderProperty;
+    /** @internal */
+    static _dirtTilingOffsetProp: ShaderProperty;
     /**
      * Controls whether to use bicubic sampling instead of bilinear sampling for the upSampling passes.
      * @remarks This is slightly more expensive but helps getting smoother visuals.

package/types/postProcess/effects/TonemappingEffect.d.ts

@@ -1,3 +1,4 @@
+import { ShaderMacro } from "../../shader";
 import { PostProcessEffect } from "../PostProcessEffect";
 import { PostProcessEffectEnumParameter } from "../PostProcessEffectParameter";
 /**
@@ -18,6 +19,8 @@ export declare enum TonemappingMode {
     ACES = 1
 }
 export declare class TonemappingEffect extends PostProcessEffect {
+    /** @internal */
+    static _enableMacro: ShaderMacro;
     /**
      * Use this to select a tonemapping algorithm to use.
      */

package/types/renderingHardwareInterface/IPlatformTransformFeedback.d.ts

@@ -1 +1,36 @@
-export {};
+import { IPlatformBuffer } from "./IPlatformBuffer";
+/**
+ * Platform interface for Transform Feedback operations.
+ * @internal
+ */
+export interface IPlatformTransformFeedback {
+    /**
+     * Bind a buffer range as Transform Feedback output at the given index.
+     */
+    bindBufferRange(index: number, buffer: IPlatformBuffer, byteOffset: number, byteSize: number): void;
+    /**
+     * Unbind buffer from Transform Feedback output at the given index.
+     */
+    unbindBuffer(index: number): void;
+    /**
+     * Begin a Transform Feedback pass.
+     * @param primitiveMode - The primitive mode (e.g., POINTS)
+     */
+    begin(primitiveMode: number): void;
+    /**
+     * End the current Transform Feedback pass.
+     */
+    end(): void;
+    /**
+     * Bind this Transform Feedback object as the active TF.
+     */
+    bind(): void;
+    /**
+     * Unbind the Transform Feedback object.
+     */
+    unbind(): void;
+    /**
+     * Destroy native resources.
+     */
+    destroy(): void;
+}

package/types/renderingHardwareInterface/IPlatformTransformFeedbackPrimitive.d.ts

@@ -1 +1,40 @@
-export {};
+/**
+ * Platform interface for Transform Feedback primitive operations.
+ * @internal
+ */
+export interface IPlatformTransformFeedbackPrimitive {
+    /**
+     * Update vertex layout. Auto-rebuilds when program changes.
+     * @param program - Shader program (for attribute locations)
+     * @param readBinding - Current read buffer binding
+     * @param writeBinding - Current write buffer binding
+     * @param feedbackElements - Vertex elements for feedback buffer
+     * @param inputBinding - Input buffer binding
+     * @param inputElements - Vertex elements for input buffer
+     */
+    updateVertexLayout(program: any, readBinding: any, writeBinding: any, feedbackElements: any[], inputBinding: any, inputElements: any[]): void;
+    /**
+     * Bind attribute state for the given read direction.
+     * @param readIsA - Whether to use direction A as read
+     */
+    bind(readIsA: boolean): void;
+    /**
+     * Unbind attribute state.
+     */
+    unbind(): void;
+    /**
+     * Issue a draw call.
+     * @param mode - Primitive topology
+     * @param first - First vertex index
+     * @param count - Number of vertices
+     */
+    draw(mode: number, first: number, count: number): void;
+    /**
+     * Invalidate cached state, forcing rebuild on next updateVertexLayout.
+     */
+    invalidate(): void;
+    /**
+     * Destroy native resources.
+     */
+    destroy(): void;
+}

package/types/shader/Shader.d.ts

@@ -1,6 +1,8 @@
+import { IShaderCompiler, IPrecompiledShader } from "@galacean/engine-design";
 import { Engine } from "../Engine";
 import { IReferable } from "../asset/IReferable";
 import { ShaderMacro } from "./ShaderMacro";
+import { ShaderMacroCollection } from "./ShaderMacroCollection";
 import { ShaderPass } from "./ShaderPass";
 import { ShaderProperty } from "./ShaderProperty";
 import { SubShader } from "./SubShader";
@@ -10,6 +12,10 @@ import { ShaderLanguage } from "./enums/ShaderLanguage";
  */
 export declare class Shader implements IReferable {
     readonly name: string;
+    /** @internal */
+    static readonly _compileMacros: ShaderMacroCollection;
+    /** @internal */
+    static _shaderCompiler?: IShaderCompiler;
     private static _shaderMap;
     /**
      * Create a shader by source code.
@@ -53,6 +59,14 @@ export declare class Shader implements IReferable {
      * @param name - Name of the shader
      */
     static find(name: string): Shader;
+    /**
+     * @internal
+     */
+    static _createFromPrecompiled(data: IPrecompiledShader): Shader;
+    /**
+     * @internal
+     */
+    static _clear(engine: Engine): void;
     private static _resolveUsePass;
     private static _applyRenderStates;
     private static _applyConstRenderStates;
@@ -85,6 +99,14 @@ export declare class Shader implements IReferable {
      * @returns Whether the release was successful.
      */
     destroy(force?: boolean): boolean;
+    /**
+     * @internal
+     */
+    _getReferCount(): number;
+    /**
+     * @internal
+     */
+    _addReferCount(value: number): void;
     /**
      * @deprecated Please use `ShaderMacro.getByName` instead
      *

package/types/shader/ShaderBlockProperty.d.ts

@@ -1 +1,19 @@
-export {};
+/**
+ * @internal
+ * Shader block property, used to identify uniform blocks by id.
+ */
+export declare class ShaderBlockProperty {
+    private static _counter;
+    private static _nameMap;
+    /**
+     * Get shader block property by name.
+     * @param name - Name of the uniform block
+     * @returns Shader block property
+     */
+    static getByName(name: string): ShaderBlockProperty;
+    /** Uniform block name. */
+    readonly name: string;
+    /** @internal */
+    readonly _uniqueId: number;
+    private constructor();
+}

package/types/shader/ShaderData.d.ts

@@ -5,14 +5,27 @@ import { IReferable } from "../asset/IReferable";
 import type { ICloneHook } from "../clone/ICloneHook";
 import { Texture } from "../texture/Texture";
 import { ShaderMacro } from "./ShaderMacro";
+import { ShaderMacroCollection } from "./ShaderMacroCollection";
 import { ShaderProperty } from "./ShaderProperty";
+import { ShaderDataGroup } from "./enums/ShaderDataGroup";
+import { ShaderPropertyType } from "./enums/ShaderPropertyType";
 /**
  * Shader data collection,Correspondence includes shader properties data and macros data.
  */
 export declare class ShaderData extends DataObject implements IReferable, IClone, ICloneHook<ShaderData> {
+    /** @internal */
+    _group: ShaderDataGroup;
+    /** @internal */
+    _propertyValueMap: Record<number, ShaderPropertyValueType>;
+    /** @internal */
+    _macroCollection: ShaderMacroCollection;
     private _batchSharedFields;
     private _macroMap;
     private _refCount;
+    /**
+     * @internal
+     */
+    constructor(group: ShaderDataGroup);
     /**
      * Get float by shader property name.
      * @param propertyName - Shader property name
@@ -353,6 +366,22 @@ export declare class ShaderData extends DataObject implements IReferable, IClone
      * @inheritdoc
      */
     _onClone(target: ShaderData): void;
+    /**
+     * @internal
+     */
+    _setPropertyValue<T extends ShaderPropertyValueType>(property: string | ShaderProperty, type: ShaderPropertyType, value: T): void;
+    /**
+     * @internal
+     */
+    _matchesRendererBatchShared(other: ShaderData): boolean;
+    /**
+     * @internal
+     */
+    _getReferCount(): number;
+    /**
+     * @internal
+     */
+    _addReferCount(value: number): void;
     private _addTexturesReferCount;
     private _updateRendererBatchSharedFields;
 }

package/types/shader/ShaderFactory.d.ts

@@ -1,4 +1,5 @@
 import { Engine } from "../Engine";
+import { ShaderProperty } from "./ShaderProperty";
 /**
  * Shader registry and GLSL utilities. Holds the `#include` lookup table
  * the runtime preprocessor reads, the GLSL ES 100 → 300 syntax converter
@@ -53,3 +54,25 @@ export declare class ShaderFactory {
     private static _buildFieldDefines;
     private static _replaceMRTShader;
 }
+/**
+ * @internal
+ */
+export interface InstanceFieldInfo {
+    property: ShaderProperty;
+    type: string;
+    offset: number;
+    /** offset / 4, precomputed to avoid repeated division in upload loop */
+    offsetInElements: number;
+    useIntView: boolean;
+    pack: InstancePackFunc;
+}
+/**
+ * @internal
+ */
+export interface InstanceBufferLayout {
+    instanceFields: InstanceFieldInfo[];
+    instanceMaxCount: number;
+    structSize: number;
+}
+type InstancePackFunc = (view: Float32Array | Int32Array, offset: number, value: any) => void;
+export {};

package/types/shader/ShaderMacro.d.ts

@@ -1,7 +1,12 @@
+import { ShaderMacroCollection } from "./ShaderMacroCollection";
 /**
  * Shader macro。
  */
 export declare class ShaderMacro {
+    /** @internal */
+    static _macroMaskMap: ShaderMacro[][];
+    /** @internal */
+    static _macroNameIdMap: Record<string, number>;
     private static _macroNameCounter;
     private static _macroCounter;
     private static _macroMap;
@@ -18,9 +23,19 @@ export declare class ShaderMacro {
      * @returns Shader macro
      */
     static getByName(name: string, value: string): ShaderMacro;
+    /**
+     * @internal
+     */
+    static _getMacrosElements(macros: ShaderMacroCollection, out: ShaderMacro[]): void;
     /** Name. */
     readonly name: string;
     /** Value. */
     readonly value: string;
+    /** @internal */
+    _nameId: number;
+    /** @internal */
+    _maskIndex: number;
+    /** @internal */
+    _maskValue: number;
     private constructor();
 }

package/types/shader/ShaderMacroCollection.d.ts

@@ -1 +1,57 @@
-export {};
+import { ShaderMacro } from "./ShaderMacro";
+/**
+ * Shader macro collection.
+ * @internal
+ */
+export declare class ShaderMacroCollection {
+    /**
+     * Union of two macro collection.
+     * @param left - input macro collection
+     * @param right - input macro collection
+     * @param out - union output macro collection
+     */
+    static unionCollection(left: ShaderMacroCollection, right: ShaderMacroCollection, out: ShaderMacroCollection): void;
+    /** @internal */
+    _mask: number[];
+    /** @internal */
+    _length: number;
+    /**
+     * Enable one macro in this macro collection.
+     * @param macro - ShaderMacro
+     */
+    enable(macro: ShaderMacro): void;
+    /**
+     * Disable one macro in this macro collection.
+     * @param macro - ShaderMacro
+     */
+    disable(macro: ShaderMacro): void;
+    /**
+     * Union of this and other macro collection.
+     * @param macroCollection - macro collection
+     */
+    unionCollection(macroCollection: ShaderMacroCollection): void;
+    /**
+     * Complementarity of this and other macro collection.
+     * @param macroCollection - macro collection
+     */
+    complementaryCollection(macroCollection: ShaderMacroCollection): void;
+    /**
+     * Intersection of this and other macro collection.
+     * @param macroCollection - macro collection
+     */
+    intersectionCollection(macroCollection: ShaderMacroCollection): void;
+    /**
+     * Whether macro is enabled in this macro collection.
+     * @param macro - ShaderMacro
+     */
+    isEnable(macro: ShaderMacro): boolean;
+    /**
+     * Whether this macro collection is equal to another.
+     * @param other - macro collection to compare
+     */
+    isEqual(other: ShaderMacroCollection): boolean;
+    /**
+     * Clear this macro collection.
+     */
+    clear(): void;
+}

package/types/shader/ShaderMacroProcessor.d.ts

@@ -1 +1,72 @@
-export {};
+import type { ShaderInstruction } from "@galacean/engine-design";
+/**
+ * @internal
+ */
+export declare class ShaderMacroProcessor {
+    private static _valueMacros;
+    private static _funcMacros;
+    private static _shaderChunks;
+    private static _out;
+    private static _expandedNames;
+    private static _macroFirstChars;
+    private static _macroFirstCharsDirty;
+    private static _replaceWordParts;
+    private static _parsedFuncArgs;
+    /**
+     * Evaluate a flat instruction array with active macros.
+     * Macros are expanded immediately when text chunks are collected,
+     * using the current macro state at that point (conforming to GLSL/C99 §6.10 standard).
+     * @param instructions - Pre-parsed instruction array
+     * @param macros - Active runtime macros
+     * @returns Pure GLSL string with all conditionals resolved and macros expanded
+     */
+    static evaluate(instructions: ShaderInstruction[], macros: Map<string, string>): string;
+    /**
+     * Expand macros in a single text chunk using the current macro state.
+     * Returns the chunk as-is if no expandable macros exist.
+     */
+    private static _expandChunk;
+    /**
+     * Recursively expand macro substitution results until no more macros remain.
+     * @param macroExpansion - Intermediate text from a macro substitution that may contain further macro references
+     * @param valueMacros - Current value macro definitions
+     * @param funcMacros - Current function macro definitions
+     * @param expandedNames - Macro names already on the expansion chain, prevents circular references (C99 §6.10.3.4)
+     */
+    private static _recursiveExpandMacro;
+    /**
+     * Substitute function macro params in body.
+     */
+    private static _expandFuncBody;
+    /**
+     * Evaluate a compound condition tree.
+     */
+    private static _evalCondition;
+    /**
+     * Evaluate a comparison operator.
+     */
+    private static _compareValues;
+    /**
+     * Parse function macro call arguments.
+     * Returns reusable static result object to avoid allocation.
+     */
+    private static _parseFuncArgs;
+    /**
+     * Replace all whole-word occurrences of `word` in `text` with `replacement`.
+     */
+    private static _replaceWord;
+    /**
+     * Concatenate shader chunks with consecutive blank lines collapsed to a single newline.
+     */
+    private static _concatChunks;
+    /**
+     * Check if char code is a valid identifier start.
+     * Matches: [A-Z] | [a-z] | _
+     */
+    private static _isIdentifierStart;
+    /**
+     * Check if char code is a valid identifier part.
+     * Matches: [A-Z] | [a-z] | [0-9] | _
+     */
+    private static _isIdentifierPart;
+}

package/types/shader/ShaderPass.d.ts

@@ -1,10 +1,36 @@
 import type { ShaderInstruction } from "@galacean/engine-design";
+import { Engine } from "../Engine";
+import { ShaderMacroCollection } from "./ShaderMacroCollection";
 import { ShaderPart } from "./ShaderPart";
+import { ShaderProgramMap } from "./ShaderProgramMap";
+import { ShaderProgram } from "./ShaderProgram";
+import { ShaderProperty } from "./ShaderProperty";
 import { ShaderLanguage } from "./enums/ShaderLanguage";
+import { RenderState } from "./state/RenderState";
 /**
  * Shader pass containing vertex and fragment source.
  */
 export declare class ShaderPass extends ShaderPart {
+    /** @internal */
+    static _shaderPassCounter: number;
+    /** @internal */
+    static _shaderRootPath: string;
+    /** @internal */
+    _platformTarget: ShaderLanguage;
+    /** @internal - Flat instruction array for vertex shader. */
+    _vertexShaderInstructions: ShaderInstruction[];
+    /** @internal */
+    _fragmentShaderInstructions: ShaderInstruction[];
+    /** @internal */
+    _shaderPassId: number;
+    /** @internal Pass-level render state — always present, populated from ShaderLab declarations. */
+    _renderState: RenderState;
+    /** @internal */
+    _renderStateDataMap: Record<number, ShaderProperty>;
+    /** @internal */
+    _shaderProgramMaps: ShaderProgramMap[];
+    /** @internal Transform feedback output varyings (WebGL2 only). */
+    _feedbackVaryings?: string[];
     private static _shaderMacroList;
     private static _macroMap;
     /**
@@ -16,5 +42,17 @@ export declare class ShaderPass extends ShaderPart {
      * @param tags - Tags
      */
     constructor(name: string, vertexShaderInstructions: ShaderInstruction[], fragmentShaderInstructions: ShaderInstruction[], platformTarget: ShaderLanguage, tags?: Record<string, number | string | boolean>);
+    /**
+     * @internal
+     */
+    _getShaderProgram(engine: Engine, macroCollection: ShaderMacroCollection): ShaderProgram;
+    /**
+     * @internal
+     */
+    _destroy(): void;
+    /**
+     * @internal
+     */
+    _compileShaderProgram(engine: Engine, macroCollection: ShaderMacroCollection): ShaderProgram;
     private _compileShaderSource;
 }