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

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

package/types/texture/RenderTarget.d.ts

@@ -1,5 +1,6 @@
 import { GraphicsResource } from "../asset/GraphicsResource";
 import { Engine } from "../Engine";
+import { IPlatformRenderTarget } from "../renderingHardwareInterface";
 import { RenderBufferDepthFormat } from "./enums/RenderBufferDepthFormat";
 import { TextureFormat } from "./enums/TextureFormat";
 import { Texture } from "./Texture";
@@ -7,6 +8,14 @@ import { Texture } from "./Texture";
  * The render target used for off-screen rendering.
  */
 export declare class RenderTarget extends GraphicsResource {
+    /** @internal */
+    _platformRenderTarget: IPlatformRenderTarget;
+    /** @internal */
+    _depth: Texture | TextureFormat | null;
+    /** @internal */
+    _antiAliasing: number;
+    /** @internal */
+    _depthFormat: TextureFormat | null;
     private _autoGenerateMipmaps;
     private _width;
     private _height;
@@ -93,4 +102,16 @@ export declare class RenderTarget extends GraphicsResource {
      * Generate the mipmap of each attachment texture of the renderTarget according to the configuration.
      */
     generateMipmaps(): void;
+    /**
+     * @internal
+     */
+    protected _onDestroy(): void;
+    /**
+     * @internal
+     */
+    _blitRenderTarget(): void;
+    /**
+     * @internal
+     */
+    _rebuild(): void;
 }

package/types/texture/Texture.d.ts

@@ -1,5 +1,6 @@
 import { GraphicsResource } from "../asset/GraphicsResource";
 import { Engine } from "../Engine";
+import { IPlatformTexture } from "../renderingHardwareInterface";
 import { TextureDepthCompareFunction } from "./enums/TextureDepthCompareFunction";
 import { TextureFilterMode } from "./enums/TextureFilterMode";
 import { TextureFormat } from "./enums/TextureFormat";
@@ -10,6 +11,14 @@ import { TextureWrapMode } from "./enums/TextureWrapMode";
  */
 export declare abstract class Texture extends GraphicsResource {
     name: string;
+    /** @internal */
+    _platformTexture: IPlatformTexture;
+    /** @internal */
+    _mipmap: boolean;
+    /** @internal */
+    _isDepthTexture: boolean;
+    /** @internal */
+    _memorySize: number;
     protected _format: TextureFormat;
     protected _width: number;
     protected _height: number;
@@ -77,6 +86,18 @@ export declare abstract class Texture extends GraphicsResource {
      * Generate multi-level textures based on the 0th level data.
      */
     generateMipmaps(): void;
+    /**
+     * @internal
+     */
+    _setUseDepthCompareMode(value: boolean): void;
+    /**
+     * @internal
+     */
+    _rebuild(): void;
+    /**
+     * @internal
+     */
+    protected _onDestroy(): void;
     /**
      * Get the maximum mip level of the corresponding size:rounding down.
      * @remarks http://download.nvidia.com/developer/Papers/2005/NP2_Mipmapping/NP2_Mipmap_Creation.pdf

package/types/texture/Texture2D.d.ts

@@ -68,4 +68,8 @@ export declare class Texture2D extends Texture {
      * @param out - Color buffer
      */
     getPixelBuffer(x: number, y: number, width: number, height: number, mipLevel: number, out: ArrayBufferView): void;
+    /**
+     * @internal
+     */
+    _rebuild(): void;
 }

package/types/texture/Texture2DArray.d.ts

@@ -79,4 +79,8 @@ export declare class Texture2DArray extends Texture {
      * @param out - Color buffer
      */
     getPixelBuffer(elementIndex: number, x: number, y: number, width: number, height: number, mipLevel: number, out: ArrayBufferView): void;
+    /**
+     * @internal
+     */
+    _rebuild(): void;
 }

package/types/texture/TextureCube.d.ts

@@ -68,4 +68,8 @@ export declare class TextureCube extends Texture {
      * @param out - Color buffer
      */
     getPixelBuffer(face: TextureCubeFace, x: number, y: number, width: number, height: number, mipLevel: number, out: ArrayBufferView): void;
+    /**
+     * @internal
+     */
+    _rebuild(): void;
 }

package/types/texture/TextureUtils.d.ts

@@ -1 +1,16 @@
-export {};
+import { Engine } from "../Engine";
+import { TextureFormat } from "./enums/TextureFormat";
+/**
+ * @internal
+ */
+export declare class TextureUtils {
+    /**
+     * Check if the texture config supports auto mipmap generation with real correction for mipmap and isSRGBColorSpace.
+     */
+    static supportGenerateMipmapsWithCorrection(engine: Engine, width: number, height: number, format: TextureFormat, mipmap: boolean, isSRGBColorSpace: boolean): boolean;
+    static supportSRGB(format: TextureFormat): boolean;
+    static supportMipmaps(width: number, height: any, isWebGL2: boolean): boolean;
+    static supportGenerateMipmaps(format: TextureFormat, mipmap: boolean, isSRGBColorSpace: boolean, isWebGL2: boolean): boolean;
+    static getTextureByteCount(format: TextureFormat, width: number, height: number, mipmapCount: number, faceCount: number): number;
+    static getMipLevelByteCount(format: TextureFormat, width: number, height: number): number;
+}

package/types/trail/TrailRenderer.d.ts

@@ -1,4 +1,5 @@
 import { BoundingBox, Vector2 } from "@galacean/engine-math";
+import { Entity } from "../Entity";
 import { RenderContext } from "../RenderPipeline/RenderContext";
 import { Renderer } from "../Renderer";
 import { ParticleCurve } from "../particle/modules/ParticleCurve";
@@ -67,6 +68,10 @@ export declare class TrailRenderer extends Renderer {
      */
     get textureScale(): Vector2;
     set textureScale(value: Vector2);
+    /**
+     * @internal
+     */
+    constructor(entity: Entity);
     /**
      * Clear all trail points.
      */

package/types/ui/IUICanvas.d.ts

@@ -1 +1,16 @@
-export {};
+import { Camera } from "../Camera";
+import { Entity } from "../Entity";
+import { RenderContext } from "../RenderPipeline/RenderContext";
+import { RenderElement } from "../RenderPipeline/RenderElement";
+/**
+ * @internal
+ */
+export interface IUICanvas {
+    entity: Entity;
+    sortOrder: number;
+    _canvasIndex: number;
+    _renderElements: RenderElement[];
+    _batchedRenderElements: RenderElement[];
+    _canRender(camera: Camera): boolean;
+    _prepareRender(renderContext: RenderContext): void;
+}

package/types/utils/DisorderedArray.d.ts

@@ -4,6 +4,8 @@
 export declare class DisorderedArray<T> {
     /** The length of the array. */
     length: number;
+    /** @internal */
+    _elements: T[];
     private _loopCounter;
     private _blankCount;
     /**