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

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;
 }

package/types/shader/ShaderProgram.d.ts

@@ -1 +1,91 @@
-export {};
+import { Engine } from "../Engine";
+import { ShaderData } from "./ShaderData";
+import { ShaderUniformBlock } from "./ShaderUniformBlock";
+import { InstanceBufferLayout } from "./ShaderFactory";
+/**
+ * Shader program, corresponding to the GPU shader program.
+ * @internal
+ */
+export declare class ShaderProgram {
+    private static _counter;
+    private static _addLineNum;
+    id: number;
+    readonly sceneUniformBlock: ShaderUniformBlock;
+    readonly cameraUniformBlock: ShaderUniformBlock;
+    readonly rendererUniformBlock: ShaderUniformBlock;
+    readonly materialUniformBlock: ShaderUniformBlock;
+    readonly renderElementUniformBlock: ShaderUniformBlock;
+    readonly otherUniformBlock: ShaderUniformBlock;
+    /** @internal */
+    _uploadRenderCount: number;
+    /** @internal */
+    _uploadSceneId: number;
+    /** @internal */
+    _uploadCameraId: number;
+    /** @internal */
+    _uploadRendererId: number;
+    /** @internal */
+    _uploadMaterialId: number;
+    /** @internal */
+    _instanceLayout: InstanceBufferLayout | null;
+    attributeLocation: Record<string, GLint>;
+    uniformBlockIds: number[];
+    private _isValid;
+    private _engine;
+    private _gl;
+    private _glProgram;
+    private _activeTextureUint;
+    /**
+     * Whether this shader program is valid.
+     */
+    get isValid(): boolean;
+    constructor(engine: Engine, vertexSource: string, fragmentSource: string, transformFeedbackVaryings?: string[]);
+    /**
+     * Upload all shader data in shader uniform block.
+     * @param uniformBlock - shader Uniform block
+     * @param shaderData - shader data
+     */
+    uploadAll(uniformBlock: ShaderUniformBlock, shaderData: ShaderData): void;
+    /**
+     * Upload constant shader data in shader uniform block.
+     * @param uniformBlock - shader Uniform block
+     * @param shaderData - shader data
+     */
+    uploadUniforms(uniformBlock: ShaderUniformBlock, shaderData: ShaderData): void;
+    /**
+     * Upload texture shader data in shader uniform block.
+     * @param uniformBlock - shader Uniform block
+     * @param shaderData - shader data
+     */
+    uploadTextures(uniformBlock: ShaderUniformBlock, shaderData: ShaderData): void;
+    /**
+     * Upload ungroup texture shader data in shader uniform block.
+     */
+    uploadUnGroupTextures(): void;
+    /**
+     * Grouping other data.
+     */
+    groupingOtherUniformBlock(): void;
+    /**
+     * Bind this shader program.
+     * @returns Whether the shader program is switched.
+     */
+    bind(): boolean;
+    /**
+     * Destroy this shader program.
+     */
+    destroy(): void;
+    private _groupingSubOtherUniforms;
+    private _groupingUniform;
+    /**
+     * Init and link program with shader.
+     */
+    private _createProgram;
+    private _createShader;
+    /**
+     * record the location of uniform/attribute.
+     */
+    private _recordLocation;
+    private _getUniformInfos;
+    private _getAttributeInfos;
+}

package/types/shader/ShaderProgramMap.d.ts

@@ -1 +1,20 @@
-export {};
+import { Engine } from "../Engine";
+import { ShaderMacroCollection } from "./ShaderMacroCollection";
+import { ShaderProgram } from "./ShaderProgram";
+/**
+ * Map keyed by ShaderMacroCollection bitmask, caching ShaderProgram instances.
+ * @internal
+ */
+export declare class ShaderProgramMap {
+    engine: Engine;
+    private _cacheHierarchyDepth;
+    private _cacheMap;
+    private _lastQueryMap;
+    private _lastQueryKey;
+    constructor(engine: Engine);
+    get(macros: ShaderMacroCollection): ShaderProgram | null;
+    cache(value: ShaderProgram): void;
+    destroy(): void;
+    private _recursiveForEach;
+    private _resizeCacheMapHierarchy;
+}

package/types/shader/ShaderProperty.d.ts

@@ -1,8 +1,11 @@
+import { ShaderDataGroup } from "./enums/ShaderDataGroup";
 import { ShaderPropertyType } from "./enums/ShaderPropertyType";
 /**
  * Shader property.
  */
 export declare class ShaderProperty {
+    /** @internal */
+    static _propertyIdMap: Record<number, ShaderProperty>;
     private static _propertyNameCounter;
     private static _propertyNameMap;
     /**
@@ -11,10 +14,24 @@ export declare class ShaderProperty {
      * @returns Shader property
      */
     static getByName(name: string): ShaderProperty;
+    /**
+     * @internal
+     */
+    static _getShaderPropertyGroup(propertyName: string): ShaderDataGroup | null;
+    /** @internal */
+    _uniqueId: number;
+    /** @internal */
+    _group: ShaderDataGroup;
+    /** @internal */
+    _type: ShaderPropertyType;
     /** Shader property name. */
     readonly name: string;
     /**
      * Shader property type.
      */
     get type(): ShaderPropertyType;
+    /**
+     * @internal
+     */
+    constructor(name: string);
 }

package/types/shader/ShaderTagKey.d.ts

@@ -12,5 +12,7 @@ export declare class ShaderTagKey {
     static getByName(name: string): ShaderTagKey;
     /** Shader tag property name. */
     readonly name: string;
+    /** @internal */
+    _uniqueId: number;
     private constructor();
 }

package/types/shader/ShaderUniform.d.ts

@@ -1 +1,49 @@
-export {};
+import { Color, Matrix, Vector2, Vector3, Vector4 } from "@galacean/engine-math";
+import { Engine } from "../Engine";
+import { Texture } from "../texture/Texture";
+import { ShaderPropertyValueType } from "./ShaderData";
+/**
+ * Shader uniform。
+ * @internal
+ */
+export declare class ShaderUniform {
+    name: string;
+    propertyId: number;
+    location: WebGLUniformLocation;
+    applyFunc: (shaderUniform: ShaderUniform, value: ShaderPropertyValueType) => void;
+    cacheValue: number | Vector2 | Vector3 | Vector4;
+    textureIndex: GLenum | GLenum[];
+    textureDefault: Texture | Texture[];
+    textureUseCompareMode: boolean;
+    private _rhi;
+    private _gl;
+    constructor(engine: Engine);
+    upload1f(shaderUniform: ShaderUniform, value: number): void;
+    upload1fv(shaderUniform: ShaderUniform, value: Float32Array): void;
+    upload2f(shaderUniform: ShaderUniform, value: Vector2 | Vector3 | Vector4 | Color): void;
+    upload2fv(shaderUniform: ShaderUniform, value: Float32Array): void;
+    upload3f(shaderUniform: ShaderUniform, value: Vector3 | Vector4 | Color): void;
+    upload3fv(shaderUniform: ShaderUniform, value: Float32Array): void;
+    upload4f(shaderUniform: ShaderUniform, value: Vector4 | Color): void;
+    upload4fv(shaderUniform: ShaderUniform, value: Float32Array): void;
+    upload1i(shaderUniform: ShaderUniform, value: number): void;
+    upload1iv(shaderUniform: ShaderUniform, value: Int32Array): void;
+    upload2i(shaderUniform: ShaderUniform, value: Vector2 | Vector3 | Vector4 | Color): void;
+    upload2iv(shaderUniform: ShaderUniform, value: Int32Array): void;
+    upload3i(shaderUniform: ShaderUniform, value: Vector3 | Vector4 | Color): void;
+    upload3iv(shaderUniform: ShaderUniform, value: Int32Array): void;
+    upload4i(shaderUniform: ShaderUniform, value: Vector4 | Color): void;
+    upload4iv(shaderUniform: ShaderUniform, value: Int32Array): void;
+    uploadMat2(shaderUniform: ShaderUniform, value: Float32Array): void;
+    uploadMat3(shaderUniform: ShaderUniform, value: Float32Array): void;
+    uploadMat4(shaderUniform: ShaderUniform, value: Matrix): void;
+    uploadMat4v(shaderUniform: ShaderUniform, value: Float32Array): void;
+    uploadMat2x3(shaderUniform: ShaderUniform, value: Float32Array): void;
+    uploadMat2x4(shaderUniform: ShaderUniform, value: Float32Array): void;
+    uploadMat3x2(shaderUniform: ShaderUniform, value: Float32Array): void;
+    uploadMat3x4(shaderUniform: ShaderUniform, value: Float32Array): void;
+    uploadMat4x2(shaderUniform: ShaderUniform, value: Float32Array): void;
+    uploadMat4x3(shaderUniform: ShaderUniform, value: Float32Array): void;
+    uploadTexture(shaderUniform: ShaderUniform, value: Texture): void;
+    uploadTextureArray(shaderUniform: ShaderUniform, value: Texture[]): void;
+}

package/types/shader/ShaderUniformBlock.d.ts

@@ -1 +1,9 @@
-export {};
+import { ShaderUniform } from "./ShaderUniform";
+/**
+ * Shader uniform block.
+ * @internal
+ */
+export declare class ShaderUniformBlock {
+    readonly constUniforms: ShaderUniform[];
+    readonly textureUniforms: ShaderUniform[];
+}

package/types/shader/enums/ConstantBufferBindingPoint.d.ts

@@ -1 +1,7 @@
-export {};
+/**
+ * @internal
+ * Constant buffer binding point allocation.
+ */
+export declare enum ConstantBufferBindingPoint {
+    RendererInstance = 0
+}

package/types/shader/state/BlendState.d.ts

@@ -1,5 +1,10 @@
 import { DataObject } from "../../base/DataObject";
+import { IHardwareRenderer } from "@galacean/engine-design";
 import { Color } from "@galacean/engine-math";
+import { RenderStateElementMap } from "../../BasicResources";
+import { ShaderData } from "../ShaderData";
+import { ShaderProperty } from "../ShaderProperty";
+import { RenderState } from "./RenderState";
 import { RenderTargetBlendState } from "./RenderTargetBlendState";
 /**
  * Blend state.
@@ -13,5 +18,14 @@ export declare class BlendState extends DataObject {
     readonly blendColor: Color;
     /** Whether to use (Alpha-to-Coverage) technology. */
     alphaToCoverage: boolean;
+    /**
+     * @internal
+     */
+    _applyShaderDataValue(renderStateDataMap: Record<number, ShaderProperty>, shaderData: ShaderData): void;
+    /**
+     * @internal
+     * Apply the current blend state by comparing with the last blend state.
+     */
+    _apply(hardwareRenderer: IHardwareRenderer, lastRenderState: RenderState, customStates?: RenderStateElementMap): void;
     private _platformApply;
 }

package/types/shader/state/DepthState.d.ts

@@ -1,5 +1,10 @@
 import { DataObject } from "../../base/DataObject";
+import { IHardwareRenderer } from "@galacean/engine-design";
+import { RenderStateElementMap } from "../../BasicResources";
+import { ShaderData } from "../ShaderData";
+import { ShaderProperty } from "../ShaderProperty";
 import { CompareFunction } from "../enums/CompareFunction";
+import { RenderState } from "./RenderState";
 /**
  * Depth state.
  */
@@ -11,5 +16,14 @@ export declare class DepthState extends DataObject {
     compareFunction: CompareFunction;
     /** Whether the depth value can be written.*/
     writeEnabled: boolean;
+    /**
+     * @internal
+     */
+    _applyShaderDataValue(renderStateDataMap: Record<number, ShaderProperty>, shaderData: ShaderData): void;
+    /**
+     * @internal
+     * Apply the current depth state by comparing with the last depth state.
+     */
+    _apply(hardwareRenderer: IHardwareRenderer, lastRenderState: RenderState, customStates?: RenderStateElementMap): void;
     private _platformApply;
 }

package/types/shader/state/RasterState.d.ts

@@ -1,5 +1,10 @@
 import { DataObject } from "../../base/DataObject";
+import { IHardwareRenderer } from "@galacean/engine-design";
+import { RenderStateElementMap } from "../../BasicResources";
+import { ShaderData } from "../ShaderData";
+import { ShaderProperty } from "../ShaderProperty";
 import { CullMode } from "../enums/CullMode";
+import { RenderState } from "./RenderState";
 /**
  * Raster state.
  */
@@ -10,5 +15,17 @@ export declare class RasterState extends DataObject {
     depthBias: number;
     /** The scale factor for the variable depth offset for each polygon. */
     slopeScaledDepthBias: number;
+    /** @internal */
+    _cullFaceEnable: boolean;
+    /** @internal */
+    _frontFaceInvert: boolean;
+    /**
+     * @internal
+     */
+    _applyShaderDataValue(renderStateDataMap: Record<number, ShaderProperty>, shaderData: ShaderData): void;
+    /**
+     * @internal
+     */
+    _apply(hardwareRenderer: IHardwareRenderer, lastRenderState: RenderState, frontFaceInvert: boolean, customStates?: RenderStateElementMap): void;
     private _platformApply;
 }

package/types/shader/state/RenderState.d.ts

@@ -1,4 +1,7 @@
 import { DataObject } from "../../base/DataObject";
+import { ShaderData, ShaderProperty } from "..";
+import { RenderStateElementMap } from "../../BasicResources";
+import { Engine } from "../../Engine";
 import { RenderQueueType } from "../enums/RenderQueueType";
 import { BlendState } from "./BlendState";
 import { DepthState } from "./DepthState";
@@ -18,4 +21,12 @@ export declare class RenderState extends DataObject {
     readonly rasterState: RasterState;
     /** Render queue type. */
     renderQueueType: RenderQueueType;
+    /**
+     * @internal
+     */
+    _applyStates(engine: Engine, frontFaceInvert: boolean, renderStateDataMap: Record<number, ShaderProperty>, shaderData: ShaderData, customRenderStates?: RenderStateElementMap): void;
+    /**
+     * @internal
+     */
+    _getRenderQueueByShaderData(renderStateDataMap: Record<number, ShaderProperty>, shaderData: ShaderData): RenderQueueType;
 }

package/types/shader/state/StencilState.d.ts

@@ -1,6 +1,11 @@
 import { DataObject } from "../../base/DataObject";
+import { IHardwareRenderer } from "@galacean/engine-design";
+import { RenderStateElementMap } from "../../BasicResources";
+import { ShaderData } from "../ShaderData";
+import { ShaderProperty } from "../ShaderProperty";
 import { CompareFunction } from "../enums/CompareFunction";
 import { StencilOperation } from "../enums/StencilOperation";
+import { RenderState } from "./RenderState";
 /**
  * Stencil state.
  */
@@ -31,5 +36,13 @@ export declare class StencilState extends DataObject {
     zFailOperationFront: StencilOperation;
     /** specifying the function to use for back face when the stencil test passes, but the depth test fails. */
     zFailOperationBack: StencilOperation;
+    /**
+     * @internal
+     */
+    _applyShaderDataValue(renderStateDataMap: Record<number, ShaderProperty>, shaderData: ShaderData): void;
+    /**
+     * @internal
+     */
+    _apply(hardwareRenderer: IHardwareRenderer, lastRenderState: RenderState, customStates?: RenderStateElementMap): void;
     private _platformApply;
 }

package/types/shadow/CascadedShadowCasterPass.d.ts

@@ -1,5 +1,6 @@
 import { Camera } from "../Camera";
 import { PipelinePass } from "../RenderPipeline/PipelinePass";
+import { RenderContext } from "../RenderPipeline/RenderContext";
 /**
  * Cascade shadow caster pass.
  */
@@ -36,6 +37,10 @@ export declare class CascadedShadowCasterPass extends PipelinePass {
     private _renderTarget;
     private _viewportOffsets;
     constructor(camera: Camera);
+    /**
+     * @internal
+     */
+    onRender(context: RenderContext): void;
     private _renderDirectShadowMap;
     private _updateReceiversShaderData;
     private _getCascadesSplitDistance;

package/types/shadow/ShadowSliceData.d.ts

@@ -1 +1,13 @@
-export {};
+import { BoundingSphere, Plane } from "@galacean/engine-math";
+import { VirtualCamera } from "../VirtualCamera";
+/**
+ * @internal
+ */
+export declare class ShadowSliceData {
+    resolution: number;
+    virtualCamera: VirtualCamera;
+    cullPlanes: Plane[];
+    cullPlaneCount: number;
+    splitBoundSphere: BoundingSphere;
+    sphereCenterZ: number;
+}

package/types/shadow/ShadowUtils.d.ts

@@ -1 +1,43 @@
-export {};
+import { BoundingBox, BoundingFrustum, Matrix, Plane, Vector2, Vector3, Vector4 } from "@galacean/engine-math";
+import { Camera } from "../Camera";
+import { RenderContext } from "../RenderPipeline/RenderContext";
+import { Renderer } from "../Renderer";
+import { DirectLight, Light } from "../lighting";
+import { TextureFormat } from "../texture";
+import { ShadowSliceData } from "./ShadowSliceData";
+import { ShadowResolution } from "./enum/ShadowResolution";
+/**
+ * @internal
+ */
+export declare class ShadowUtils {
+    private static _tempMatrix0;
+    /** @internal */
+    private static _shadowMapCoordMatrix;
+    private static _frustumCorners;
+    private static _adjustNearPlane;
+    private static _adjustFarPlane;
+    private static _backPlaneFaces;
+    private static _edgePlanePoint2;
+    /** near, far, left, right, bottom, top  */
+    private static _frustumPlaneNeighbors;
+    /** near, far, left, right, bottom, top  */
+    private static _frustumTwoPlaneCorners;
+    static readonly atlasBorderSize: number;
+    static shadowResolution(value: ShadowResolution): number;
+    static shadowDepthFormat(value: ShadowResolution, supportDepthTexture: boolean): TextureFormat;
+    static cullingRenderBounds(bounds: BoundingBox, cullPlaneCount: number, cullPlanes: Plane[]): boolean;
+    static shadowCullFrustum(context: RenderContext, light: Light, renderer: Renderer, shadowSliceData: ShadowSliceData): void;
+    static getBoundSphereByFrustum(near: number, far: number, camera: Camera, forward: Vector3, shadowSliceData: ShadowSliceData): void;
+    static getDirectionLightShadowCullPlanes(cameraFrustum: BoundingFrustum, splitDistance: number, cameraNear: number, direction: Vector3, shadowSliceData: ShadowSliceData): void;
+    static getDirectionalLightMatrices(lightUp: Vector3, lightSide: Vector3, lightForward: Vector3, cascadeIndex: number, nearPlane: number, shadowResolution: number, shadowSliceData: ShadowSliceData, outShadowMatrices: Float32Array): void;
+    static getMaxTileResolutionInAtlas(atlasWidth: number, atlasHeight: number, tileCount: number): number;
+    static getShadowBias(light: DirectLight, projectionMatrix: Matrix, shadowResolution: number, out: Vector2): void;
+    /**
+     * Apply shadow slice scale and offset
+     */
+    static applySliceTransform(tileSize: number, atlasWidth: number, atlasHeight: number, cascadeIndex: number, atlasOffset: Vector2, outShadowMatrices: Float32Array): void;
+    /**
+     * Extract scale and bias from a fade distance to achieve a linear fading of the fade distance.
+     */
+    static getScaleAndBiasForLinearDistanceFade(fadeDistance: number, border: number, outInfo: Vector4): void;
+}

package/types/sky/Sky.d.ts

@@ -1,3 +1,4 @@
+import { RenderContext } from "../RenderPipeline/RenderContext";
 import { Mesh } from "../graphic/Mesh";
 import { Material } from "../material";
 /**
@@ -19,4 +20,12 @@ export declare class Sky {
      */
     get mesh(): Mesh;
     set mesh(value: Mesh);
+    /**
+     * @internal
+     */
+    destroy(): void;
+    /**
+     * @internal
+     */
+    _render(context: RenderContext): void;
 }