@galacean/effects-plugin-model 0.0.0-experimental-downgrade624-20240904

package/dist/runtime/material.d.ts

@@ -0,0 +1,101 @@
+import type { Material, Texture } from '@galacean/effects';
+import { spec } from '@galacean/effects';
+import type { ModelMaterialOptions, ModelMaterialUnlitOptions, ModelMaterialPBROptions } from '../index';
+import { Vector3, Vector4, Matrix3 } from './math';
+import { PMaterialType, PBlendMode, PFaceSideMode } from './common';
+import { PObject } from './object';
+export declare abstract class PMaterialBase extends PObject {
+    materialType: PMaterialType;
+    vertexShaderCode: string;
+    fragmentShaderCode: string;
+    /**
+     * 深度是否写入，默认是写入(true)
+     */
+    depthMask: boolean;
+    depthTestHint: boolean;
+    blendMode: PBlendMode;
+    alphaCutOff: number;
+    faceSideMode: PFaceSideMode;
+    getShaderFeatures(): string[];
+    updateUniforms(material: Material): void;
+    build(inFeatureList?: string[]): void;
+    getBlendMode(mode?: spec.MaterialBlending): PBlendMode;
+    getFaceSideMode(mode?: spec.SideMode): PFaceSideMode;
+    setMaterialStates(material: Material): void;
+    protected setFaceSideStates(material: Material): void;
+    dispose(): void;
+    isValid(): boolean;
+    isOpaque(): boolean;
+    isMasked(): boolean;
+    isTranslucent(): boolean;
+    isAdditive(): boolean;
+    requireBlend(): boolean;
+    isFrontFace(): boolean;
+    isBackFace(): boolean;
+    isBothFace(): boolean;
+}
+export declare class PMaterialUnlit extends PMaterialBase {
+    private baseColorFactor;
+    private baseColorTexture?;
+    create(options: ModelMaterialUnlitOptions): void;
+    dispose(): void;
+    getShaderFeatures(): string[];
+    updateUniforms(material: Material): void;
+    hasBaseColorTexture(): boolean;
+    getBaseColorTexture(): Texture;
+    setBaseColorTexture(val: Texture): void;
+    getBaseColorFactor(): Vector4;
+    setBaseColorFactor(val: Vector4 | spec.vec4): void;
+}
+export declare class PMaterialPBR extends PMaterialBase {
+    baseColorTexture?: Texture;
+    baseColorTextureTrans?: Matrix3;
+    baseColorFactor: Vector4;
+    metallicRoughnessTexture?: Texture;
+    metallicRoughnessTextureTrans?: Matrix3;
+    useSpecularAA: boolean;
+    metallicFactor: number;
+    roughnessFactor: number;
+    normalTexture?: Texture;
+    normalTextureTrans?: Matrix3;
+    normalTextureScale: number;
+    occlusionTexture?: Texture;
+    occlusionTextureTrans?: Matrix3;
+    occlusionTextureStrength: number;
+    emissiveTexture?: Texture;
+    emissiveTextureTrans?: Matrix3;
+    emissiveFactor: Vector3;
+    emissiveIntensity: number;
+    enableShadow: boolean;
+    create(options: ModelMaterialPBROptions): void;
+    dispose(): void;
+    getShaderFeatures(): string[];
+    updateUniforms(material: Material): void;
+    hasBaseColorTexture(): boolean;
+    hasBaseColorTextureTrans(): boolean;
+    setBaseColorTexture(val: Texture): void;
+    getBaseColorFactor(): Vector4;
+    setBaseColorFactor(val: Vector4 | spec.vec4): void;
+    hasMetallicRoughnessTexture(): boolean;
+    hasMetallicRoughnessTextureTrans(): boolean;
+    getMetallicRoughnessTexture(): Texture;
+    setMetallicRoughnessTexture(val: Texture): void;
+    hasNormalTexture(): boolean;
+    hasNormalTextureTrans(): boolean;
+    getNormalTexture(): Texture;
+    setNormalTexture(val: Texture): void;
+    hasOcclusionTexture(): boolean;
+    hasOcclusionTextureTrans(): boolean;
+    getOcclusionTexture(): Texture;
+    setOcclusionTexture(val: Texture): void;
+    hasEmissiveTexture(): boolean;
+    hasEmissiveTextureTrans(): boolean;
+    getEmissiveTexture(): Texture;
+    setEmissiveTexture(val: Texture): void;
+    hasEmissiveFactor(): boolean;
+    getEmissiveFactor(): Vector3;
+    setEmissiveFactor(val: Vector3 | spec.vec3): void;
+}
+export type PMaterial = PMaterialUnlit | PMaterialPBR;
+export declare function createPluginMaterial(options: ModelMaterialOptions): PMaterial;
+export declare function createInternalMaterial(options: {}): {};

package/dist/runtime/math.d.ts

@@ -0,0 +1,8 @@
+import { math } from '@galacean/effects';
+export declare const Vector2: typeof math.Vector2, Vector3: typeof math.Vector3, Vector4: typeof math.Vector4, Matrix3: typeof math.Matrix3, Matrix4: typeof math.Matrix4, Euler: typeof math.Euler, EulerOrder: typeof math.EulerOrder, Quaternion: typeof math.Quaternion, Box3: typeof math.Box3, Sphere: typeof math.Sphere, Ray: typeof math.Ray, DEG2RAD: number;
+export type Vector2 = math.Vector2;
+export type Vector3 = math.Vector3;
+export type Vector4 = math.Vector4;
+export type Matrix3 = math.Matrix3;
+export type Matrix4 = math.Matrix4;
+export type Quaternion = math.Quaternion;

package/dist/runtime/mesh.d.ts

@@ -0,0 +1,147 @@
+import type { Geometry, Engine, math } from '@galacean/effects';
+import { spec, Mesh, Material } from '@galacean/effects';
+import type { ModelItemMesh, ModelMaterialOptions, ModelPrimitiveOptions } from '../index';
+import { PShadowType } from './common';
+import { PEntity } from './object';
+import type { PMaterial } from './material';
+import { Matrix4, Vector3, Box3 } from './math';
+import { PSkin, PMorph } from './animation';
+import type { PSceneStates } from './scene';
+import type { PSkybox } from './skybox';
+import type { PMaterialShadowBase, PShadowRuntimeOptions } from './shadow';
+import type { ModelVFXItem } from '../plugin/model-vfx-item';
+import { BoxMesh } from '../utility/ri-helper';
+import type { ModelTreeVFXItem } from '../plugin';
+type Box3 = math.Box3;
+export declare class PMesh extends PEntity {
+    private engine;
+    /**
+     * 3D 元素父节点
+     */
+    parentIndex: number;
+    /**
+     * 元素的父节点
+     */
+    parentItem?: ModelTreeVFXItem;
+    /**
+     * 元素的父节点 Id
+     */
+    parentItemId?: string;
+    skin?: PSkin;
+    /**
+     * morph 动画状态数据，主要是 weights 数组
+     */
+    morph?: PMorph;
+    primitives: PPrimitive[];
+    hide: boolean;
+    priority: number;
+    boundingBox: Box3;
+    visBoundingBox: boolean;
+    boundingBoxMesh?: BoxMesh;
+    isBuilt: boolean;
+    isDisposed: boolean;
+    constructor(engine: Engine, itemMesh: ModelItemMesh, ownerItem?: ModelVFXItem, parentItem?: ModelTreeVFXItem);
+    build(lightCount: number, uniformSemantics: {
+        [k: string]: any;
+    }, skybox?: PSkybox): void;
+    tick(deltaSeconds: number): void;
+    addToRenderObjectSet(renderObjectSet: Set<Mesh>): void;
+    dispose(): void;
+    /**
+     * 更新 Morph 动画权重
+     * 每帧都会更新 Morph 动画权重，需要小心检查 Morph 动画参数
+     * 对于数组长度对不上的情况，直接报错
+     *
+     * @param weightsArray - Morph 动画的权重数组
+     */
+    updateMorphWeights(weightsArray: Float32Array): void;
+    updateParentItem(parentItem: ModelTreeVFXItem): void;
+    updateUniformsForScene(sceneStates: PSceneStates): void;
+    updateUniformForShadow(shadowOptions: PShadowRuntimeOptions): void;
+    hitTesting(rayOrigin: Vector3, rayDirection: Vector3): Vector3[];
+    computeBoundingBox(worldMatrix: Matrix4): Box3;
+    private getItemBoundingBox;
+    getParentId(): string | undefined;
+    get hasSkin(): boolean;
+    get mriMeshs(): Mesh[];
+}
+export declare class PPrimitive {
+    private engine;
+    /**
+     * 宿主 Mesh，包含了当前 Primitive
+     */
+    private parent?;
+    private skin?;
+    /**
+     * Morph 动画状态数据，来自 Mesh 对象，这里不创建不删除
+     */
+    private morph?;
+    private geometry;
+    private material;
+    private jointMatrixList?;
+    private jointNormalMatList?;
+    private jointMatrixTexture?;
+    private jointNormalMatTexture?;
+    name: string;
+    effectsMesh: Mesh;
+    effectsPriority: number;
+    boundingBox: math.Box3;
+    isCompressed: boolean;
+    shadowType: PShadowType;
+    shadowMesh?: Mesh;
+    shadowMaterial?: PMaterialShadowBase;
+    constructor(engine: Engine);
+    create(options: ModelPrimitiveOptions, parent: PMesh): void;
+    build(lightCount: number, uniformSemantics: {
+        [k: string]: any;
+    }, skybox?: PSkybox): void;
+    private getFeatureList;
+    addToRenderObjectSet(renderObjectSet: Set<Mesh>): void;
+    dispose(): void;
+    updateUniformsForScene(worldMatrix: Matrix4, nomralMatrix: Matrix4, sceneStates: PSceneStates): void;
+    updateUniformForShadow(shadowOpts: PShadowRuntimeOptions): void;
+    hitTesting(newOrigin: Vector3, newDirection: Vector3, worldMatrix: Matrix4, invWorldMatrix: Matrix4): number | undefined;
+    computeBoundingBox(inverseWorldMatrix: Matrix4): Box3;
+    /**
+     * 渲染输出模式转成 Shader 中的宏定义
+     *
+     * @param mode - 渲染输出模式
+     * @returns none 模式返回 undefined，其他模式返回相应宏定义
+     */
+    getRenderMode3DDefine(mode: spec.RenderMode3D): string | undefined;
+    private updateUniformsByAnimation;
+    private updateUniformsByScene;
+    hasSkin(): boolean;
+    getEffectsGeometry(): Geometry;
+    setGeometry(val: PGeometry | Geometry): void;
+    setMaterial(val: PMaterial | ModelMaterialOptions): void;
+    getModelMaterial(): Material;
+    getShadowModelMaterial(): Material | undefined;
+    isEnableShadow(): boolean;
+    isUnlitMaterial(): boolean;
+    /**
+     * 是否有 Morph 动画：
+     * 需要注意 Morph 对象存在，但还是没有 Morph 动画的情况
+     *
+     * @returns 返回是否有 Morph 动画
+     */
+    hasMorph(): boolean;
+    getWorldBoundingBox(): Box3;
+}
+export declare class PGeometry {
+    geometry: Geometry;
+    attributeNames: string[];
+    constructor(geometry: Geometry);
+    dispose(): void;
+    hasAttribute(name: string): boolean;
+    setHide(hide: boolean): void;
+    isCompressed(): boolean;
+    hasPositions(): boolean;
+    hasNormals(): boolean;
+    hasTangents(): boolean;
+    hasUVCoords(index: number): boolean;
+    hasColors(): boolean;
+    hasJoints(): boolean;
+    hasWeights(): boolean;
+}
+export {};

package/dist/runtime/object.d.ts

@@ -0,0 +1,46 @@
+import type { spec, Mesh, math } from '@galacean/effects';
+import type { ModelVFXItem } from '../plugin/model-vfx-item';
+import type { BaseTransform } from '../index';
+import type { Quaternion, Euler, Vector3, Matrix4 } from './math';
+import { PObjectType, PTransform, PCoordinate } from './common';
+import type { PSceneStates } from './scene';
+type Euler = math.Euler;
+export declare abstract class PObject {
+    name: string;
+    type: PObjectType;
+    dispose(): void;
+    isNone(): boolean;
+    isValid(): boolean;
+    protected genName(name: string): string;
+}
+export declare abstract class PEntity extends PObject {
+    private _visible;
+    private _transform;
+    deleted: boolean;
+    ownerItem?: ModelVFXItem;
+    tick(deltaSeconds: number): void;
+    onVisibleChanged(visible: boolean): void;
+    addToRenderObjectSet(renderObjectSet: Set<Mesh>): void;
+    updateUniformsForScene(sceneStates: PSceneStates): void;
+    /**
+     * 仅标记不可见和删除状态，但不进行 WebGL 相关资源的释放
+     * 最终释放 WebGL 相关资源是在 plugin destroy 的时候
+     */
+    onEntityRemoved(): void;
+    get visible(): boolean;
+    set visible(val: boolean);
+    get transform(): PTransform;
+    set transform(val: PTransform | BaseTransform);
+    get translation(): Vector3;
+    set translation(val: Vector3 | spec.vec3);
+    get position(): Vector3;
+    set position(val: Vector3 | spec.vec3);
+    get rotation(): Quaternion;
+    set rotation(val: Quaternion | Euler | Vector3 | spec.vec4 | spec.vec3);
+    get scale(): Vector3;
+    set scale(val: Vector3 | spec.vec3);
+    get matrix(): Matrix4;
+    set matrix(val: Matrix4);
+    get coordinate(): PCoordinate;
+}
+export {};

package/dist/runtime/scene.d.ts

@@ -0,0 +1,133 @@
+import type { RenderFrame, Mesh, Renderer, Texture, Engine, math, CameraOptionsEx } from '@galacean/effects';
+import { spec } from '@galacean/effects';
+import type { ModelItem, ModelVFXItem } from '../plugin/model-vfx-item';
+import { PMesh } from './mesh';
+import type { PCamera } from './camera';
+import { PCameraManager } from './camera';
+import { PLight, PLightManager } from './light';
+import { Vector3, Matrix4, Box3 } from './math';
+import { PSkybox } from './skybox';
+import type { CompositionCache } from './cache';
+import { PShadowManager } from './shadow';
+import type { PEntity } from './object';
+import { TwoStatesSet } from '../utility/ts-helper';
+type Box3 = math.Box3;
+type Vector2 = math.Vector2;
+export interface PSceneOptions {
+    componentName: string;
+    renderer: Renderer;
+    sceneCache: CompositionCache;
+    wireframeOnly?: boolean;
+    runtimeEnv?: string;
+    compatibleMode?: string;
+    visBoundingBox?: boolean;
+    enableDynamicSort?: boolean;
+    renderMode3D?: spec.RenderMode3D;
+    renderMode3DUVGridSize?: number;
+    renderSkybox: boolean;
+    lightItemCount: number;
+}
+export interface PSceneStates {
+    deltaSeconds: number;
+    camera: PCamera;
+    cameraPosition: Vector3;
+    viewMatrix: Matrix4;
+    projectionMatrix: Matrix4;
+    viewProjectionMatrix: Matrix4;
+    winSize: Vector2;
+    sceneRadius: number;
+    shadowMapSizeInv?: Vector2;
+    lightViewMatrix?: Matrix4;
+    lightProjectionMatrix?: Matrix4;
+    lightViewProjectionMatrix?: Matrix4;
+    lightList: PLight[];
+    maxLightCount: number;
+    skybox?: PSkybox;
+}
+export declare class PSceneManager {
+    compName: string;
+    itemList: PEntity[];
+    meshList: PMesh[];
+    lightManager: PLightManager;
+    cameraManager: PCameraManager;
+    shadowManager: PShadowManager;
+    /**
+     * 是否动态排序 Mesh 渲染优先级
+     * 默认 false，需要和 Tiny 对齐时为 true
+     */
+    enableDynamicSort: boolean;
+    brdfLUT?: Texture;
+    skybox?: PSkybox;
+    tickCount: number;
+    lastTickSecond: number;
+    /**
+     * 当前场景包围盒缓存，在阴影渲染中使用
+     */
+    sceneAABBCache: Box3;
+    /**
+     * 场景前帧和当前帧渲染的 Mesh 集合
+     */
+    renderedMeshSet: TwoStatesSet<Mesh>;
+    /**
+     * 场景中所有渲染过的 Mesh 集合
+     */
+    allRenderedMeshSet: Set<Mesh>;
+    private renderer?;
+    private sceneCache?;
+    private parentId2Mesh;
+    private maxLightCount;
+    private renderSkybox;
+    private engine;
+    constructor(engine: Engine);
+    initial(opts: PSceneOptions): void;
+    private initGlobalState;
+    private clean;
+    dispose(): void;
+    addItem(item: ModelVFXItem): void;
+    removeItem(item: ModelVFXItem): void;
+    updateDefaultCamera(camera: CameraOptionsEx): void;
+    buildItem(item: ModelItem): void;
+    /**
+     * 编译运行时需要的 Shader 代码，包括 PBR、天空盒与阴影。
+     */
+    private build;
+    tick(deltaTime: number): void;
+    /**
+     * 更新 RI 帧对象中默认 Pass 的渲染队列
+     * 如果是动态排序模式，需要重新添加所有的 mesh，这样优先级才能生效
+     * 如果是正常模式，那就增量添加和删除
+     *
+     * @param frame - RI 帧对象
+     */
+    updateDefaultRenderPass(frame: RenderFrame): void;
+    /**
+     * 动态调整 Mesh 渲染优先级
+     * 主要是为了和 Tiny 渲染对齐，正常渲染不进行调整
+     *
+     * @param states - 场景中的状态数据
+     */
+    dynamicSortMeshes(states: PSceneStates): void;
+    /**
+     * 查询场景中的 Mesh
+     * 通过 parentId 查询 Mesh 对象，可能找不到 Mesh 对象
+     *
+     * @param parentId - Item 中定义的 parentId
+     * @returns 查询到的 PMesh，或者是没找到。如果 Mesh 不可见，也是没找到。
+     */
+    queryMesh(parentId: string): PMesh | undefined;
+    /**
+     * 删除 RenderFrame DefaultRenderPass 中添加的 Mesh，Player 要执行 Reset 操作
+     *
+     * @param renderFrame - 当前渲染帧对象
+     */
+    removeAllMeshesFromDefaultPass(renderFrame: RenderFrame): void;
+    getSceneAABB(box?: Box3): Box3;
+    printDebugInfo(): void;
+    getRenderer(): Renderer;
+    getSceneCache(): CompositionCache;
+    get activeCamera(): PCamera;
+    get lightCount(): number;
+    get shaderLightCount(): number;
+    get enableShadowPass(): boolean;
+}
+export {};

package/dist/runtime/shader-libs/standard-shader-source.d.ts

@@ -0,0 +1,3 @@
+export declare namespace StandardShaderSource {
+    function build(source: string, features: string[], isWebGL2: boolean): string;
+}

package/dist/runtime/shader-libs/standard-shader.d.ts

@@ -0,0 +1,6 @@
+import type { PShaderContext } from '../shader';
+export declare class StandardShader {
+    static environment: string;
+    static getVertexShaderCode(context: PShaderContext): string;
+    static getFragmentShaderCode(context: PShaderContext): string;
+}

package/dist/runtime/shader.d.ts

@@ -0,0 +1,18 @@
+import type { PMaterialBase } from './material';
+export interface PShaderContext {
+    material: PMaterialBase;
+    isWebGL2: boolean;
+    featureList: string[];
+}
+export interface PShaderResults {
+    vertexShaderCode: string;
+    fragmentShaderCode: string;
+}
+export type ShaderCodeFuncType = (context: PShaderContext) => PShaderResults;
+export declare class PShaderManager {
+    private funcMap;
+    private static _instance;
+    static getInstance(): PShaderManager;
+    private constructor();
+    genShaderCode(context: PShaderContext): PShaderResults;
+}

package/dist/runtime/shadow.d.ts

@@ -0,0 +1,230 @@
+import type { RenderFrame, Mesh, Material, RenderPass, SemanticMap, Renderer, Engine } from '@galacean/effects';
+import { math } from '@galacean/effects';
+import { Matrix4, Vector2, Box3 } from './math';
+import type { PShadowType } from './common';
+import type { PMesh, PPrimitive } from './mesh';
+import { PMaterialBase } from './material';
+import type { PLight } from './light';
+import type { PSceneManager, PSceneStates } from './scene';
+import { FBOOptions } from '../utility/ri-helper';
+import { TwoStatesSet } from '../utility/ts-helper';
+type Box3 = math.Box3;
+export interface PMaterialShadowBaseOptions {
+    name: string;
+    shadowType: PShadowType;
+}
+export declare class PMaterialShadowBase extends PMaterialBase {
+    shadowType: PShadowType;
+    create(options: PMaterialShadowBaseOptions): void;
+    getShaderFeatures(): string[];
+    updateUniforms(material: Material): void;
+}
+export declare class PMaterialShadowBaseTest extends PMaterialBase {
+    shadowType: PShadowType;
+    create(options: PMaterialShadowBaseOptions): void;
+    getShaderFeatures(): string[];
+    updateUniforms(material: Material): void;
+}
+export interface PMaterialShadowFilterOptions {
+    name: string;
+    blurScale: Vector2;
+}
+export declare class PMaterialShadowFilter extends PMaterialBase {
+    blurScale: Vector2;
+    create(options: PMaterialShadowFilterOptions): void;
+    getShaderFeatures(): string[];
+    updateUniforms(material: Material): void;
+}
+/**
+ * 阴影初始化选项，包括控制选项和纹理选项
+ */
+export interface PShadowInitOptions {
+    /**
+     * 控制相关的参数
+     */
+    enable?: boolean;
+    quality?: 'low' | 'medium' | 'high';
+    softness?: number;
+    /**
+     * 纹理相关的参数
+     */
+    width?: number;
+    height?: number;
+    type?: GLenum;
+    format?: GLenum;
+    filter?: GLenum;
+}
+/**
+ * 阴影运行时选项，包括 light 的变换矩阵和柔软度
+ */
+export interface PShadowRuntimeOptions {
+    viewProjectionMatrix: Matrix4;
+    softness: number;
+}
+export declare class PShadowManager {
+    /**
+     * 是否启用阴影效果，会根据硬件等情况进行设置
+     */
+    enable: boolean;
+    /**
+     * 阴影质量参数，一般都用 medium
+     */
+    quality: 'low' | 'medium' | 'high';
+    /**
+     * 阴影柔软度，范围[0, 2]
+     */
+    softness: number;
+    /**
+     * 阴影纹理相关参数
+     */
+    width: number;
+    height: number;
+    type: GLenum;
+    format: GLenum;
+    filter: GLenum;
+    /**
+     * shadow map 渲染时 FBO
+     */
+    baseFBOOpts: FBOOptions;
+    /**
+     * shadow map 滤波时 FBO
+     */
+    filterFBOOpts: FBOOptions;
+    /**
+     * 是否激活运行时阴影
+     */
+    runtimeEnable: boolean;
+    /**
+     * 启用阴影效果的 Mesh 列表，来自场景中的 Mesh 列表
+     */
+    meshList: PMesh[];
+    /**
+     * 当前帧启用阴影效果的 Primitive 列表，来自上面的 Mesh 列表
+     */
+    primitiveList: PPrimitive[];
+    viewAABB: Box3;
+    sceneAABB: Box3;
+    shadowAABB: Box3;
+    shadowLight?: PLight;
+    lightView: Matrix4;
+    lightProjection: Matrix4;
+    lightViewProjection: Matrix4;
+    renderer?: Renderer;
+    sceneManager: PSceneManager;
+    xFilterMaterial: PMaterialShadowFilter;
+    yFilterMaterial: PMaterialShadowFilter;
+    basePass?: RenderPass;
+    xFilterPass?: RenderPass;
+    yFilterPass?: RenderPass;
+    /**
+     * Primitive 与 RenderPass 的前一帧与当前帧状态缓存
+     */
+    meshCacheSet: TwoStatesSet<Mesh>;
+    renderPassCacheSet: TwoStatesSet<RenderPass>;
+    engine: Engine;
+    constructor();
+    initial(sceneManager: PSceneManager, options?: PShadowInitOptions): void;
+    build(): void;
+    tick(sceneStates: PSceneStates): void;
+    /**
+     * 更新当前阴影物体的包围盒数据
+     * TODO: 需要注意动画物体的包围盒更新
+     */
+    private updateAABBInfo;
+    private updateLightViewProjection;
+    private updateDirectionalLightViewProjection;
+    private updateSpotLightViewProjection;
+    private getShadowOptions;
+    private updateShadowUniforms;
+    private getShadowLight;
+    /**
+     * 统计场景中启用阴影的 Primitive 数目
+     *
+     * @param sceneManager - Model 场景的场景管理器
+     * @returns 启用阴影的 Primitve 数目
+     */
+    private getShadowPrimitiveCount;
+    /**
+     * 更新阴影渲染时 Pass 中渲染的对象，注意阴影有 3 个渲染 Pass
+     * 开始时 Frame 中没有阴影 Pass，会先添加阴影 Pass
+     *
+     * @param frame - RI 帧对象
+     */
+    updateRenderPass(frame: RenderFrame): void;
+    updateFrameSemantics(map: SemanticMap, addSemantic: boolean): void;
+    /**
+     * 是否启用了阴影效果
+     * 是否有需要启用阴影效果的物体，以及当前硬件是否支持启用阴影效果
+     * @return 是否启用
+     */
+    isEnable(): boolean;
+    /**
+     * 是否有需要渲染的对象，需要先启用阴影
+     * @return 是否有渲染对象
+     */
+    hasRenderObject(): boolean;
+    /**
+     * 在当前 PMesh 列表中，查找需要在阴影 Pass 中渲染的 Primitive
+     *
+     * @returns 当前阴影 Pass 要渲染的 Primitive 列表
+     */
+    getCurrentPrimitiveList(): PPrimitive[];
+    isSupportTextureOptions(): boolean;
+    /**
+     * 根据当前阴影参数生成 BasePass 的 FBO 对象
+     *
+     * @returns BasePass 的 FBO 对象
+     */
+    getBaseFBOOptions(): FBOOptions;
+    /**
+     * 根据当前阴影参数生成 FilterPass 的 FBO 对象
+     *
+     * @returns FilterPass 的 FBO 对象
+     */
+    getFilterFBOOptions(): FBOOptions;
+    /**
+     * 返回 softness 值，并检查是否在指定范围内
+     *
+     * @param options - 阴影相关的初始化参数
+     * @returns 阴影柔软度值
+     */
+    getSoftness(options?: PShadowInitOptions): number;
+    /**
+     * 返回贴图大小，并检查是否在指定范围内
+     *
+     * @param options - 阴影相关的初始化参数
+     * @returns 阴影贴图大小
+     */
+    getTextureSize(options?: PShadowInitOptions): [number, number];
+    /**
+     * 返回纹理类型，并检查是否指定类型
+     *
+     * @param options - 阴影相关的初始化参数
+     * @returns 纹理类型
+     */
+    getTextureType(options?: PShadowInitOptions): GLenum;
+    /**
+     * 返回纹理格式，并检查是否指定格式
+     *
+     * @param options - 阴影相关的初始化参数
+     * @returns 纹理格式
+     */
+    getTextureFormat(options?: PShadowInitOptions): GLenum;
+    /**
+     * 返回纹理滤波格式，并检查是否指定滤波格式
+     *
+     * @param options - 阴影相关的初始化参数
+     * @returns 纹理滤波格式
+     */
+    getTextureFilter(options?: PShadowInitOptions): GLenum;
+    get mainPassUniformSemantics(): {
+        u_ShadowSampler: string;
+    };
+    get basePassName(): string;
+    get xFilterPassName(): string;
+    get yFilterPassName(): string;
+    get xFilterMeshName(): string;
+    get yFilterMeshName(): string;
+    get shadowPassList(): RenderPass[];
+}
+export {};