@galacean/effects-plugin-model 0.0.1-alpha.0

package/dist/runtime/mesh.d.ts

@@ -0,0 +1,145 @@
+import type { Geometry, Engine } from '@galacean/effects';
+import { spec, Mesh, Material } from '@galacean/effects';
+import type { MarsItemMesh, MarsMaterialOptions, MarsPrimitiveOptions } 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';
+export declare class PMesh extends PEntity {
+    private engine;
+    /**
+     * 3D 元素父节点
+     */
+    parentIndex: number;
+    /**
+     * Mars 元素的父节点
+     */
+    parentItem?: ModelTreeVFXItem;
+    /**
+     * Mars 元素的父节点 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: MarsItemMesh, 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): spec.vec3[];
+    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;
+    marsMesh: Mesh;
+    marsPriority: number;
+    boundingBox: Box3;
+    isCompressed: boolean;
+    shadowType: PShadowType;
+    shadowMesh?: Mesh;
+    shadowMaterial?: PMaterialShadowBase;
+    constructor(engine: Engine);
+    create(options: MarsPrimitiveOptions, 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;
+    getMarsGeometry(): Geometry;
+    setGeometry(val: PGeometry | Geometry): void;
+    setMaterial(val: PMaterial | MarsMaterialOptions): void;
+    getMarsMaterial(): Material;
+    getShadowMarsMaterial(): 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;
+}

package/dist/runtime/object.d.ts

@@ -0,0 +1,44 @@
+import type { spec, Mesh } 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';
+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;
+}

package/dist/runtime/scene.d.ts

@@ -0,0 +1,131 @@
+import type { CameraOptions, RenderFrame, Mesh, Renderer, Texture, Engine } from '@galacean/effects';
+import { spec } from '@galacean/effects';
+import type { ModelVFXItem, ModelItem } from '../plugin/model-vfx-item';
+import { PMesh } from './mesh';
+import type { PCamera } from './camera';
+import { PCameraManager } from './camera';
+import { PLight, PLightManager } from './light';
+import type { Vector2 } from '../math';
+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';
+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: CameraOptions): 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 渲染对齐，正常 Mars 渲染不进行调整
+     *
+     * @param states - 场景中的状态数据
+     */
+    dynamicSortMeshes(states: PSceneStates): void;
+    /**
+     * 查询场景中的 Mesh
+     * 通过 Mars 的 parentId 查询 Mesh 对象，可能找不到 Mesh 对象
+     *
+     * @param parentId - Mars 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;
+}

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,227 @@
+import type { RenderFrame, Mesh, Material, RenderPass, SemanticMap, Renderer, Engine } 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';
+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[];
+}

package/dist/runtime/skybox.d.ts

@@ -0,0 +1,91 @@
+import type { Mesh, Material, TextureSourceOptions, Engine } from '@galacean/effects';
+import { Texture } from '@galacean/effects';
+import type { MarsItemSkybox, MarsSkyboxOptions } from '../index';
+import { PEntity } from './object';
+import { PMaterialBase } from './material';
+import type { CompositionCache } from './cache';
+import type { PSceneStates } from './scene';
+import type { ModelVFXItem } from '../plugin/model-vfx-item';
+export declare class PSkybox extends PEntity {
+    renderable: boolean;
+    intensity: number;
+    reflectionsIntensity: number;
+    irradianceCoeffs?: number[][];
+    diffuseImage?: Texture;
+    specularImage: Texture;
+    specularImageSize: number;
+    specularMipCount: number;
+    brdfLUT?: Texture;
+    priority: number;
+    skyboxMesh?: Mesh;
+    skyboxMaterial?: PMaterialSkyboxFilter;
+    isBuilt: boolean;
+    constructor(skybox: MarsItemSkybox, ownerItem?: ModelVFXItem);
+    setup(brdfLUT?: Texture): void;
+    build(sceneCache: CompositionCache): void;
+    dispose(): void;
+    addToRenderObjectSet(renderObjectSet: Set<Mesh>): void;
+    updateUniformsForScene(sceneStates: PSceneStates): void;
+    get available(): boolean;
+    get currentIntensity(): number;
+    get currentReflectionsIntensity(): number;
+    get hasDiffuseImage(): boolean;
+    get hasIrradianceCoeffs(): boolean;
+}
+export declare class PMaterialSkyboxFilter extends PMaterialBase {
+    intensity: number;
+    reflectionsIntensity: number;
+    brdfLUT?: Texture;
+    irradianceCoeffs?: number[][];
+    diffuseImage?: Texture;
+    specularImage: Texture;
+    specularMipCount: number;
+    create(skybox: PSkybox): void;
+    dispose(): void;
+    getShaderFeatures(): string[];
+    updateUniforms(material: Material): void;
+    setMaterialStates(material: Material): void;
+}
+export interface PImageBufferData {
+    type: 'buffer';
+    data: Uint8Array;
+    mimeType: string;
+}
+export type PImageData = string | PImageBufferData;
+export interface PSkyboxBaseParams {
+    renderable: boolean;
+    intensity: number;
+    reflectionsIntensity: number;
+    irradianceCoeffs?: number[][];
+    specularMipCount: number;
+    specularImageSize: number;
+}
+export interface PSkyboxURLParams extends PSkyboxBaseParams {
+    type: 'url';
+    diffuseImage?: string[];
+    specularImage: string[][];
+}
+export interface PSkyboxBufferParams extends PSkyboxBaseParams {
+    type: 'buffer';
+    diffuseImage?: PImageBufferData[];
+    specularImage: PImageBufferData[][];
+}
+export type PSkyboxParams = PSkyboxURLParams | PSkyboxBufferParams;
+export declare enum PSkyboxType {
+    NFT = 0,
+    FARM = 1
+}
+export declare class PSkyboxCreator {
+    static getBrdfLutTextureOptions(): Promise<TextureSourceOptions>;
+    static createBrdfLutTexture(engine: Engine): Promise<Texture>;
+    static createSkyboxOptions(engine: Engine, params: PSkyboxParams): Promise<MarsSkyboxOptions>;
+    static createSpecularCubeMap(engine: Engine, params: PSkyboxParams): Promise<Texture>;
+    static createDiffuseCubeMap(engine: Engine, params: PSkyboxParams): Promise<Texture | undefined>;
+    static getSkyboxParams(skyboxType?: PSkyboxType): PSkyboxURLParams;
+    private checkCubeMapImage;
+    private static getIrradianceCoeffs;
+    private static getDiffuseImageList;
+    private static getSpecularImageList;
+    private static getSpecularImageListNFT;
+    private static getSpecularImageListAntFarm;
+}

package/dist/utility/debug-helper.d.ts

@@ -0,0 +1,7 @@
+import type { Player } from '@galacean/effects';
+import type { PMesh } from '../runtime/mesh';
+type WebGLContext = WebGL2RenderingContext | WebGLRenderingContext;
+export declare function HookOGLFunc(ctx: WebGLContext): void;
+export declare function getRendererGPUInfo(player: Player): string;
+export declare function getPMeshList(player: Player): PMesh[];
+export {};

package/dist/utility/hit-test-helper.d.ts

@@ -0,0 +1,9 @@
+import type { Composition, Ray, Region, spec } from '@galacean/effects';
+import { Vector3 } from '../math';
+import type { MarsItemBounding } from '../index';
+declare function RayIntersectsBoxWithRotation(ray: Ray, matrixData: spec.mat4, bounding: MarsItemBounding): number[][] | undefined;
+declare function RayBoxTesting(ro: Vector3, rd: Vector3, bmin: Vector3, bmax: Vector3): number | undefined;
+declare function RayTriangleTesting(ro: Vector3, rd: Vector3, a: Vector3, b: Vector3, c: Vector3, backfaceCulling: boolean): number | undefined;
+declare function CompositionHitTest(composition: Composition, x: number, y: number): Region[];
+declare function ToggleItemBounding(composition: Composition, itemId: string): void;
+export { RayIntersectsBoxWithRotation, RayBoxTesting, RayTriangleTesting, ToggleItemBounding, CompositionHitTest };