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

package/dist/plugin/model-plugin.d.ts

@@ -0,0 +1,48 @@
+import type { Scene, SceneLoadOptions, Composition, RenderFrame, VFXItem } from '@galacean/effects';
+import { AbstractPlugin } from '@galacean/effects';
+export declare class ModelPlugin extends AbstractPlugin {
+    name: string;
+    deltaTime: number;
+    private runtimeEnv;
+    private compatibleMode;
+    private renderSkybox;
+    private visBoundingBox;
+    private autoAdjustScene;
+    /**
+     * 渲染插件是否启用动态排序功能
+     * 支持在渲染的时候对透明 Mesh 进行动态排序
+     */
+    private enableDynamicSort;
+    /**
+     * 3D 渲染模式，支持可视化渲染中间结果
+     * none 表示正常的渲染结果
+     */
+    private renderMode3D;
+    /**
+     * UV 渲染模式中，指定棋盘格的大小，相对于大小为 1 的纹理
+     * 取值范围(0, 1)
+     */
+    private renderMode3DUVGridSize;
+    static prepareResource(scene: Scene, options: SceneLoadOptions): Promise<void>;
+    onCompositionConstructed(composition: Composition, scene: Scene): void;
+    onCompositionWillReset(composition: Composition, renderFrame: RenderFrame): void;
+    onCompositionReset(composition: Composition, renderFrame: RenderFrame): void;
+    onCompositionDestroyed(composition: Composition): void;
+    onCompositionUpdate(composition: Composition, dt: number): void;
+    onCompositionItemLifeBegin(composition: Composition, item: VFXItem<any>): void;
+    onCompositionItemRemoved(composition: Composition, item: VFXItem<any>): void;
+    prepareRenderFrame(composition: Composition, frame: RenderFrame): boolean;
+    postProcessFrame(composition: Composition, frame: RenderFrame): void;
+    private getLightItemCount;
+    /**
+     * 更新 SceneManager 中渲染用的相机，相机参数来自 composition.camera
+     *
+     * @param composition - 当前合成对象
+     * @param sceneManager - 当前合成对象绑定的 SceneManager
+     */
+    private updateSceneCamera;
+    private getSceneManager;
+    private getCache;
+    private disposeCache;
+    private disposeSceneManager;
+}

package/dist/plugin/model-tree-item.d.ts

@@ -0,0 +1,30 @@
+import { Transform } from '@galacean/effects';
+import { PAnimationManager } from '../runtime';
+import type { ModelTreeVFXItem } from './model-tree-vfx-item';
+import type { MarsTreeOptions } from '../index';
+export interface ModelTreeNode {
+    name?: string;
+    transform: Transform;
+    children: ModelTreeNode[];
+    id: string;
+    tree: ModelTreeItem;
+}
+export declare class ModelTreeItem {
+    private allNodes;
+    private nodes;
+    private cacheMap;
+    readonly baseTransform: Transform;
+    animationManager: PAnimationManager;
+    constructor(props: MarsTreeOptions, owner: ModelTreeVFXItem);
+    tick(dt: number): void;
+    getNodes(): ModelTreeNode[];
+    getNodeById(nodeId: string | number): ModelTreeNode | undefined;
+    getNodeByName(name: string): ModelTreeNode | undefined;
+    /**
+     * if node id not found,use tree.transform
+     * @param nodeId
+     */
+    getNodeTransform(nodeId: string): Transform;
+    dispose(): void;
+    private build;
+}

package/dist/plugin/model-tree-plugin.d.ts

@@ -0,0 +1,13 @@
+import type { Scene, Composition, RenderFrame, VFXItem } from '@galacean/effects';
+import { AbstractPlugin } from '@galacean/effects';
+import type { ModelTreeItem } from './model-tree-item';
+export declare class ModelTreePlugin extends AbstractPlugin {
+    name: string;
+    order: number;
+    onCompositionConstructed(composition: Composition, scene: Scene): void;
+    onCompositionWillReset(composition: Composition, renderFrame: RenderFrame): void;
+    onCompositionDestroyed(composition: Composition): void;
+    onCompositionItemLifeBegin(composition: Composition, item: VFXItem<ModelTreeItem>): void;
+    onCompositionItemRemoved(composition: Composition, item: VFXItem<ModelTreeItem>): void;
+    private getAnimationSystem;
+}

package/dist/plugin/model-tree-vfx-item.d.ts

@@ -0,0 +1,15 @@
+import type { spec, Transform, Composition } from '@galacean/effects';
+import { VFXItem, TimelineComponent } from '@galacean/effects';
+import { ModelTreeItem } from './model-tree-item';
+import type { MarsItemTree, MarsTreeOptions } from '../index';
+export declare class ModelTreeVFXItem extends VFXItem<ModelTreeItem> {
+    options: MarsTreeOptions;
+    timeline?: TimelineComponent;
+    get type(): spec.ItemType;
+    onConstructed(props: MarsItemTree): void;
+    onLifetimeBegin(): void;
+    protected onItemRemoved(composition: Composition, content?: ModelTreeItem | undefined): void;
+    onItemUpdate(dt: number, lifetime: number): void;
+    protected doCreateContent(): ModelTreeItem;
+    getNodeTransform(itemId: string): Transform;
+}

package/dist/plugin/model-vfx-item.d.ts

@@ -0,0 +1,25 @@
+import type { HitTestBoxParams, HitTestCustomParams, HitTestSphereParams, Composition } from '@galacean/effects';
+import { VFXItem, spec, TimelineComponent } from '@galacean/effects';
+import type { MarsItemBounding, MarsItemCamera, MarsItemLight, MarsItemMesh, MarsItemSkybox } from '../index';
+import { PCamera, PLight, PSkybox } from '../runtime';
+import { PMesh } from '../runtime';
+export type ModelItem = PMesh | PCamera | PLight | PSkybox;
+export type ModelItemOptions = MarsItemMesh | MarsItemCamera | MarsItemLight | MarsItemSkybox;
+export declare class ModelVFXItem extends VFXItem<ModelItem> {
+    options?: ModelItemOptions;
+    bounding?: MarsItemBounding;
+    timeline?: TimelineComponent;
+    get type(): spec.ItemType;
+    set type(v: spec.ItemType);
+    onConstructed(options: ModelItemOptions): void;
+    handleVisibleChanged(visible: boolean): void;
+    doCreateContent(composition: Composition): PLight | PMesh | PCamera | PSkybox;
+    private overwriteSkyboxFromCache;
+    computeBoundingBox(): MarsItemBounding | undefined;
+    updateTransform(): void;
+    updateTransformPosition(x: number, y: number, z: number): void;
+    onLifetimeBegin(composition: Composition, content: ModelItem): void;
+    onItemUpdate(dt: number, lifetime: number): void;
+    onItemRemoved(composition: Composition, content?: ModelItem): void;
+    getHitTestParams(force?: boolean): HitTestBoxParams | HitTestSphereParams | HitTestCustomParams | undefined;
+}

package/dist/runtime/anim-sampler.d.ts

@@ -0,0 +1,13 @@
+export declare abstract class InterpolationSampler {
+    protected time: Float32Array;
+    protected data: Float32Array;
+    protected componentCount: number;
+    protected cachedIndex: number;
+    constructor(time: Float32Array, data: Float32Array, componentCount: number);
+    evaluate(t: number): Float32Array;
+    dispose(): void;
+    protected copySampleValue(index: number): Float32Array;
+    protected abstract intervalChanged(i1: number, t0: number, t1: number): void;
+    protected abstract interpolate(i1: number, t0: number, t: number, t1: number): Float32Array;
+}
+export declare function createAnimationSampler(type: string, times: Float32Array, data: Float32Array, size: number, path?: string): InterpolationSampler;

package/dist/runtime/animation.d.ts

@@ -0,0 +1,189 @@
+import type { Geometry, Engine } from '@galacean/effects';
+import { Texture } from '@galacean/effects';
+import type { MarsSkinOptions, MarsAnimTrackOptions, MarsAnimationOptions, MarsTreeOptions } from '../index';
+import { Matrix4 } from '../math';
+import { PObject } from './object';
+import type { PSceneManager } from './scene';
+import type { ModelTreeVFXItem } from '../plugin';
+export declare enum TextureDataMode {
+    none = 0,
+    float = 1,
+    half_float = 2
+}
+export declare class PSkin extends PObject {
+    parentItem?: ModelTreeVFXItem;
+    skeleton: number;
+    jointList: number[];
+    inverseBindMatrices: Matrix4[];
+    animationMatrices: Matrix4[];
+    textureDataMode: TextureDataMode;
+    create(options: MarsSkinOptions, engine: Engine, parentItem?: ModelTreeVFXItem): void;
+    updateSkinMatrices(): void;
+    computeMeshAnimMatrices(worldMatrix: Matrix4, matrixList: Float32Array, normalMatList: Float32Array): void;
+    updateParentItem(parentItem: ModelTreeVFXItem): void;
+    getJointCount(): number;
+    isTextureDataMode(): boolean;
+    dispose(): void;
+    private getTextureDataMode;
+}
+/**
+ * Morph 动画状态：
+ * 保存了动画状态相关的数据，包括 weights 数组数据
+ * 增加了状态数据的检查，保证数据的正确性
+ * Morph 动画非常消耗内存，谨慎使用。
+ */
+export declare class PMorph extends PObject {
+    /**
+     * weights 数组的长度，shader 中和更新的时候会用到
+     * 范围要在 `[0, 8]` 之间，否则会报错。
+     */
+    morphWeightsLength: number;
+    /**
+     * weights 数组的具体数据，来自动画控制器的每帧更新
+     * 数组的长度必须和 morphWeightsLength 相同，否则会出错。
+     */
+    morphWeightsArray?: Float32Array;
+    /**
+     * 是否有 Position 相关的 Morph 动画，shader 中需要知道
+     */
+    hasPositionMorph: boolean;
+    /**
+     * 是否有 Normal 相关的 Morph 动画，shader 中需要知道
+     */
+    hasNormalMorph: boolean;
+    /**
+     * 是否有 Tangent 相关的 Morph 动画，shader 中需要知道
+     */
+    hasTangentMorph: boolean;
+    /**
+     * 通过 Mars 的 Geometry 数据创建 Morph 动画相关状态，并进行必要的正确性检查
+     *
+     * @param geometry - Mesh 的几何对象，是否包含 Morph 动画都是可以的
+     */
+    create(geometry: Geometry): boolean;
+    dispose(): void;
+    /**
+     * 初始化 Morph target 的权重数组
+     *
+     * @param weights - glTF Mesh 的权重数组，长度必须严格一致
+     */
+    initWeights(weights: number[]): void;
+    /**
+     * 当前状态是否有 Morph 动画：
+     * 需要判断 weights 数组长度，以及 Position、Normal 和 Tangent 是否有动画
+     *
+     * @returns 返回是否有 Morph 动画
+     */
+    hasMorph(): boolean;
+    /**
+     * 两个 Morph 动画状态是否相等：
+     * 这里只比较初始状态是否一样，不考虑 weights 数组的情况，提供给 Mesh 进行 Geometry 检查使用
+     *
+     * @param morph - Morph 动画状态对象
+     * @returns 返回两个 Morph 动画状态是否相等
+     */
+    equals(morph: PMorph): boolean;
+    getMorphWeightsArray(): Float32Array;
+    /**
+     * 统计 Geometry 中 Attribute 名称个数：
+     * 主要用于统计 Morph 动画中新增的 Attribute 名称的个数，会作为最终的 weights 数组长度使用
+     *
+     * @param attributeNameList - Attribute 名数组列表，只与 Morph Target 中的属性有关
+     * @param geometry - Mars 的 Geometry 对象，是否有 Morph 动画都可以
+     * @returns 存在的 Attribute 名称数目
+     */
+    getAttributeMorphCount(attributeNameList: string[], geometry: Geometry): number;
+    /**
+     * Morph 动画中 Position 相关的 Attribute 名称
+     */
+    private static positionNameList;
+    /**
+     * Morph 动画中 Normal 相关的 Attribute 名称
+     */
+    private static normalNameList;
+    /**
+     * Morph 动画中 Tangent 相关的 Attribute 名称
+     */
+    private static tangentNameList;
+}
+export declare enum PAnimInterpType {
+    linear = 0,
+    step = 1,
+    cubicSpline = 2
+}
+export declare enum PAnimPathType {
+    translation = 0,
+    rotation = 1,
+    scale = 2,
+    weights = 3
+}
+export declare class PAnimTrack {
+    node: number;
+    timeArray: Float32Array;
+    dataArray: Float32Array;
+    path: PAnimPathType;
+    interp: PAnimInterpType;
+    component: number;
+    private sampler?;
+    constructor(options: MarsAnimTrackOptions);
+    dispose(): void;
+    tick(time: number, treeItem: ModelTreeVFXItem, sceneManager?: PSceneManager): void;
+    getEndTime(): number;
+    /**
+     * 生成 Mesh 元素的父节点
+     * 为 Mesh 元素生成 Mars 中的父节点，这里是和燃燃确定的生成方式
+     *
+     * @param parentId - 父节点 id 名称
+     * @param nodeIndex - Mesh 节点索引
+     *
+     * @returns 生成的 Mesh 节点名称
+     */
+    private genParentId;
+    private getPathInfo;
+    private getInterpInfo;
+}
+export declare class PAnimTexture {
+    private engine;
+    private isHalfFloat;
+    private width;
+    private height;
+    private buffer?;
+    private texture?;
+    constructor(engine: Engine);
+    create(jointCount: number, isHalfFloat: boolean, name: string): void;
+    update(buffer: Float32Array): void;
+    dispose(): void;
+    getSize(): number;
+    getTexture(): Texture;
+}
+export declare class PAnimation extends PObject {
+    private time;
+    private duration;
+    private tracks;
+    create(options: MarsAnimationOptions): void;
+    tick(time: number, treeItem: ModelTreeVFXItem, sceneManager?: PSceneManager): void;
+    dispose(): void;
+}
+export declare class PAnimationManager extends PObject {
+    private ownerItem;
+    private animation;
+    private speed;
+    private delay;
+    private time;
+    private animations;
+    private sceneManager;
+    constructor(treeOptions: MarsTreeOptions, ownerItem: ModelTreeVFXItem);
+    createAnimation(animationOpts: MarsAnimationOptions): PAnimation;
+    tick(deltaSeconds: number): void;
+    dispose(): void;
+    getTreeItem(): ModelTreeVFXItem;
+}
+export declare class PAnimationSystem {
+    private engine;
+    private managers;
+    constructor(engine: Engine);
+    create(treeItems: ModelTreeVFXItem[]): void;
+    insert(animationManager: PAnimationManager): void;
+    delete(animationManager: PAnimationManager): void;
+    dispose(): void;
+}

package/dist/runtime/cache.d.ts

@@ -0,0 +1,34 @@
+import type { Mesh, Geometry, TextureSourceOptions, RenderPass, spec, Engine } from '@galacean/effects';
+import { Texture } from '@galacean/effects';
+import type { MarsSkyboxOptions } from '../index';
+import type { FBOOptions } from '../utility/ri-helper';
+import type { PMaterialBase } from './material';
+import type { PSkyboxParams } from './skybox';
+export declare class CompositionCache {
+    private engine;
+    private loadSkybox;
+    private brdfLutTexture?;
+    private meshCache;
+    private textureCache;
+    private geometryCache;
+    private renderPassCache;
+    private static brdfLutTexOptions?;
+    private static skyboxOptions?;
+    static loadStaticResources(): Promise<void>;
+    static genSkyboxOptions(engine: Engine, params?: PSkyboxParams): Promise<MarsSkyboxOptions>;
+    constructor(engine: Engine);
+    setup(loadSkybox: boolean): void;
+    getTexture(name: string): Texture | undefined;
+    setTexture(name: string, tex: Texture): void;
+    getOrCreateTexture(name: string, options: TextureSourceOptions): Texture;
+    deleteTexture(name: string): boolean;
+    getOrCreateGeometry(name: string, geomJson: spec.GeometryOptionsJSON, bins: ArrayBuffer[]): Geometry;
+    getFilterMesh(name: string, material: PMaterialBase, uniformSemantics: Record<string, any>): Mesh;
+    getShadowBasePass(name: string, priority: number, meshList: Mesh[], fboOptions: FBOOptions): RenderPass;
+    getShadowFilterPass(name: string, priority: number, meshList: Mesh[], fboOptions: FBOOptions): RenderPass;
+    getRenderPass(name: string, priority: number, meshList: Mesh[], fboOptions: FBOOptions): RenderPass;
+    dispose(): void;
+    getRenderPasses(): RenderPass[];
+    getBrdfLutTexture(): Texture | undefined;
+    getSkyboxOptions(): MarsSkyboxOptions | undefined;
+}

package/dist/runtime/camera.d.ts

@@ -0,0 +1,43 @@
+import { spec } from '@galacean/effects';
+import type { ModelVFXItem } from '../plugin/model-vfx-item';
+import type { MarsItemCamera } from '../index';
+import type { Quaternion, Box3 } from '../math';
+import { Vector2, Vector3, Matrix4 } from '../math';
+import { PEntity } from './object';
+export declare class PCamera extends PEntity {
+    width: number;
+    height: number;
+    nearPlane: number;
+    farPlane: number;
+    fovy: number;
+    aspect: number;
+    clipMode: spec.CameraClipMode;
+    projectionMatrix: Matrix4;
+    viewMatrix: Matrix4;
+    constructor(camera: MarsItemCamera, width: number, height: number, ownerItem?: ModelVFXItem);
+    update(): void;
+    getNewProjectionMatrix(fov: number): Matrix4;
+    computeViewAABB(box: Box3): Box3;
+    getSize(): Vector2;
+    isReversed(): boolean;
+    getEye(): Vector3;
+    setEye(val: Vector3): void;
+}
+export declare class PCameraManager {
+    private winWidth;
+    private winHeight;
+    private cameraList;
+    private defaultCamera;
+    constructor();
+    initial(width: number, height: number): void;
+    insert(inCamera: MarsItemCamera, ownerItem?: ModelVFXItem): PCamera;
+    insertCamera(camera: PCamera): void;
+    remove(camera: PCamera | number): void;
+    dispose(): void;
+    updateDefaultCamera(fovy: number, nearPlane: number, farPlane: number, position: spec.vec3, rotation: Quaternion, clipMode: number): void;
+    getCameraList(): PCamera[];
+    getDefaultCamera(): PCamera;
+    getCameraCount(): number;
+    getActiveCamera(): PCamera;
+    getAspect(): number;
+}

package/dist/runtime/common.d.ts

@@ -0,0 +1,113 @@
+import { Transform as MarsTransform, spec } from '@galacean/effects';
+import { Quaternion, Euler, Vector3, Matrix4 } from '../math';
+import type { BaseTransform } from '../index';
+export declare enum PObjectType {
+    none = 0,
+    mesh = 1,
+    texture = 2,
+    material = 3,
+    light = 4,
+    camera = 5,
+    skybox = 6,
+    skin = 7,
+    morph = 8,
+    skeleton = 9,
+    animation = 10,
+    animationManager = 11,
+    reference = 12
+}
+export declare enum PLightType {
+    directional = 0,
+    point = 1,
+    spot = 2,
+    ambient = 3
+}
+export declare enum PTextureType {
+    none = 0,
+    t2d = 1,
+    t3d = 2,
+    cube = 3
+}
+export declare enum PMaterialType {
+    none = 0,
+    unlit = 1,
+    pbr = 2,
+    normalVis = 3,
+    simpleFilter = 4,
+    shadowBase = 5,
+    shadowFilter = 6,
+    skyboxFilter = 7
+}
+export declare enum PBlendMode {
+    opaque = 0,
+    masked = 1,
+    translucent = 2,
+    additive = 3
+}
+export declare enum PFaceSideMode {
+    both = 0,
+    front = 1,
+    back = 2
+}
+export declare enum PShadowType {
+    none = 0,
+    standard = 1,
+    variance = 2,
+    expVariance = 3
+}
+export declare class PTransform {
+    private translation;
+    private rotation;
+    private scale;
+    fromMatrix4(matrix: Matrix4): this;
+    fromMarsTransform(trans: MarsTransform | BaseTransform): this;
+    toMarsTransform(transform: MarsTransform): MarsTransform;
+    fromBaseTransform(trans: BaseTransform): this;
+    getTranslation(): Vector3;
+    setTranslation(val: Vector3 | spec.vec3): void;
+    getPosition(): Vector3;
+    setPosition(val: Vector3 | spec.vec3): void;
+    getRotation(): Quaternion;
+    setRotation(val: Quaternion | Euler | Vector3 | spec.vec4 | spec.vec3): void;
+    getScale(): Vector3;
+    setScale(val: Vector3 | spec.vec3): void;
+    getMatrix(): Matrix4;
+    setMatrix(mat: Matrix4 | spec.mat4): void;
+}
+export declare class PCoordinate {
+    origin: Vector3;
+    xAxis: Vector3;
+    yAxis: Vector3;
+    zAxis: Vector3;
+    constructor();
+    fromPTransform(trans: PTransform, inverse?: boolean): this;
+    fromRotationMatrix(matrix: Matrix4): void;
+}
+export declare class PGlobalState {
+    isWebGL2: boolean;
+    shaderShared: boolean;
+    runtimeEnv: string;
+    compatibleMode: string;
+    visBoundingBox: boolean;
+    /**
+     * 渲染输出结果模式，可以换中间渲染数据
+     */
+    renderMode3D: spec.RenderMode3D;
+    /**
+     * UV结果输出时，棋盘格的大小控制，范围(0, 1)
+     */
+    renderMode3DUVGridSize: number;
+    private static instance;
+    static getInstance(): PGlobalState;
+    private constructor();
+    reset(): void;
+    /**
+     * 是否可视化渲染中间结果
+     */
+    hasRenderMode3D(): boolean;
+    get isEditorEnv(): boolean;
+    get isDeviceEnv(): boolean;
+    get isTiny3dMode(): boolean;
+    get isOasisMode(): boolean;
+    get isGLTFMode(): boolean;
+}

package/dist/runtime/index.d.ts

@@ -0,0 +1,12 @@
+export * from './anim-sampler';
+export * from './animation';
+export * from './cache';
+export * from './camera';
+export * from './common';
+export * from './light';
+export * from './material';
+export * from './mesh';
+export * from './object';
+export * from './scene';
+export * from './shader';
+export * from './skybox';

package/dist/runtime/light.d.ts

@@ -0,0 +1,34 @@
+import type { MarsItemLight } from '../index';
+import { Vector2, Vector3 } from '../math';
+import { PLightType } from './common';
+import { PEntity } from './object';
+import type { ModelVFXItem } from '../plugin/model-vfx-item';
+export declare class PLight extends PEntity {
+    direction: Vector3;
+    range: number;
+    color: Vector3;
+    intensity: number;
+    outerConeAngle: number;
+    innerConeAngle: number;
+    lightType: PLightType;
+    padding: Vector2;
+    constructor(light: MarsItemLight, ownerItem?: ModelVFXItem);
+    tick(deltaSeconds: number): void;
+    isDirectional(): boolean;
+    isPoint(): boolean;
+    isSpot(): boolean;
+    isAmbient(): boolean;
+    get position(): Vector3;
+    getWorldPosition(): Vector3;
+    getWorldDirection(): Vector3;
+}
+export declare class PLightManager {
+    lightList: PLight[];
+    constructor();
+    tick(deltaSeconds: number): void;
+    insertItem(inLight: MarsItemLight, ownerItem?: ModelVFXItem): PLight;
+    insertLight(inLight: PLight): PLight;
+    remove(inLight: PLight): void;
+    dispose(): void;
+    get lightCount(): number;
+}

package/dist/runtime/material.d.ts

@@ -0,0 +1,101 @@
+import type { Material, Texture } from '@galacean/effects';
+import { spec } from '@galacean/effects';
+import type { MarsMaterialOptions, MarsMaterialUnlitOptions, MarsMaterialPBROptions } 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: MarsMaterialUnlitOptions): 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: MarsMaterialPBROptions): 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: MarsMaterialOptions): PMaterial;
+export declare function createInternalMaterial(options: {}): {};