@rings-webgpu/core 1.0.0 → 1.0.2

package/dist/src/loader/parser/prefab/prefabData/BlendShapePropertyData.d.ts

@@ -0,0 +1,9 @@
+import { BytesArray } from "../../../..";
+export declare class BlendShapePropertyData {
+    shapeName: string;
+    shapeIndex: number;
+    frameCount: number;
+    blendPositionList: Float32Array;
+    blendNormalList: Float32Array;
+    formBytes(byteArray: BytesArray): void;
+}

package/dist/src/loader/parser/prefab/prefabData/BlendShapePropertyData.js

@@ -0,0 +1,17 @@
+/* eslint-disable */
+export class BlendShapePropertyData {
+    constructor() {
+        this.blendPositionList = new Float32Array();
+        this.blendNormalList = new Float32Array();
+    }
+    formBytes(byteArray) {
+        let bytes = byteArray.readBytesArray();
+        this.shapeName = bytes.readUTF();
+        this.shapeIndex = bytes.readInt32();
+        this.frameCount = bytes.readInt32();
+        let len = bytes.readInt32();
+        this.blendPositionList = bytes.readFloat32Array(len * 3);
+        let len2 = bytes.readInt32();
+        this.blendNormalList = bytes.readFloat32Array(len2 * 3);
+    }
+}

package/dist/src/loader/parser/prefab/prefabData/KVData.d.ts

@@ -0,0 +1,9 @@
+import { BytesArray } from "../../../../util/BytesArray";
+import { ValueEnumType } from "./ValueType";
+export declare class KV {
+    key: string;
+    type: ValueEnumType;
+    private _data;
+    getValue<T>(): T;
+    formBytes(matBytes: BytesArray): void;
+}

package/dist/src/loader/parser/prefab/prefabData/KVData.js

@@ -0,0 +1,12 @@
+import { ValueParser } from "./ValueParser";
+export class KV {
+    getValue() {
+        return this._data;
+    }
+    formBytes(matBytes) {
+        this.key = matBytes.readUTF();
+        let { t, v } = ValueParser.parser(matBytes);
+        this.type = t;
+        this._data = v;
+    }
+}

package/dist/src/loader/parser/prefab/prefabData/PrefabAvatarData.d.ts

@@ -0,0 +1,9 @@
+import { BytesArray } from "../../../../util/BytesArray";
+import { PrefabBoneData } from "./PrefabBoneData";
+export declare class PrefabAvatarData {
+    name: string;
+    count: number;
+    boneData: PrefabBoneData[];
+    boneMap: Map<string, PrefabBoneData>;
+    formBytes(bytes: BytesArray): void;
+}

package/dist/src/loader/parser/prefab/prefabData/PrefabAvatarData.js

@@ -0,0 +1,15 @@
+import { PrefabBoneData } from "./PrefabBoneData";
+export class PrefabAvatarData {
+    formBytes(bytes) {
+        this.boneData = [];
+        this.boneMap = new Map();
+        this.name = bytes.readUTF();
+        this.count = bytes.readInt32();
+        for (let i = 0; i < this.count; i++) {
+            let boneData = new PrefabBoneData();
+            boneData.formBytes(bytes.readBytesArray());
+            this.boneData[i] = boneData;
+            this.boneMap.set(boneData.boneName, boneData);
+        }
+    }
+}

package/dist/src/loader/parser/prefab/prefabData/PrefabBoneData.d.ts

@@ -0,0 +1,16 @@
+import { Quaternion } from "../../../../math/Quaternion";
+import { Vector3 } from "../../../../math/Vector3";
+import { BytesArray } from "../../../../util/BytesArray";
+export declare class PrefabBoneData {
+    boneName: string;
+    bonePath: string;
+    parentBoneName: string;
+    boneID: number;
+    parentBoneID: number;
+    instanceID: string;
+    parentInstanceID: string;
+    t: Vector3;
+    q: Quaternion;
+    s: Vector3;
+    formBytes(bytes: BytesArray): void;
+}

package/dist/src/loader/parser/prefab/prefabData/PrefabBoneData.js

@@ -0,0 +1,14 @@
+export class PrefabBoneData {
+    formBytes(bytes) {
+        this.boneName = bytes.readUTF();
+        this.bonePath = bytes.readUTF();
+        this.parentBoneName = bytes.readUTF();
+        this.boneID = bytes.readInt32();
+        this.parentBoneID = bytes.readInt32();
+        this.instanceID = bytes.readUTF();
+        this.parentInstanceID = bytes.readUTF();
+        this.t = bytes.readVector3();
+        this.q = bytes.readQuaternion();
+        this.s = bytes.readVector3();
+    }
+}

package/dist/src/loader/parser/prefab/prefabData/PrefabMeshData.d.ts

@@ -0,0 +1,19 @@
+import { Matrix4 } from "../../../..";
+import { BlendShapeData } from "./BlendShapeData";
+export declare class PrefabMeshData {
+    name: string;
+    meshName: string;
+    meshID: string;
+    vertexCount: number;
+    vertexStrip: number;
+    vertexBuffer: Float32Array;
+    indices: Uint16Array | Uint32Array;
+    attributes: {
+        attribute: string;
+        dim: number;
+        pos: number;
+    }[];
+    bones: string[];
+    bindPose: Matrix4[];
+    blendShapeData: BlendShapeData;
+}

package/dist/src/loader/parser/prefab/prefabData/PrefabMeshData.js

@@ -0,0 +1,2 @@
+export class PrefabMeshData {
+}

package/dist/src/loader/parser/prefab/prefabData/PrefabNode.d.ts

@@ -0,0 +1,19 @@
+import { Quaternion } from "../../../../math/Quaternion";
+import { Vector3 } from "../../../../math/Vector3";
+import { BytesArray } from "../../../../util/BytesArray";
+import { KV } from "./KVData";
+export declare class ComData {
+    comName: string;
+    data: KV[];
+    static parser(bytesArray: BytesArray): ComData;
+}
+export declare class PrefabNode {
+    name: string;
+    parentName: string;
+    position: Vector3;
+    rotation: Quaternion;
+    scale: Vector3;
+    comDatas: ComData[];
+    child: PrefabNode[];
+    static parser(bytesArray: BytesArray): PrefabNode;
+}

package/dist/src/loader/parser/prefab/prefabData/PrefabNode.js

@@ -0,0 +1,40 @@
+import { KV } from "./KVData";
+export class ComData {
+    static parser(bytesArray) {
+        let comBuffer = bytesArray.readBytesArray();
+        let comData = new ComData();
+        comData.comName = comBuffer.readUTF();
+        comData.data = [];
+        let count = comBuffer.readInt32();
+        for (let i = 0; i < count; i++) {
+            let kv = new KV();
+            kv.formBytes(comBuffer);
+            comData.data.push(kv);
+        }
+        return comData;
+    }
+}
+export class PrefabNode {
+    static parser(bytesArray) {
+        let nodeBytes = bytesArray.readBytesArray();
+        let prefabNode = new PrefabNode();
+        prefabNode.name = nodeBytes.readUTF();
+        prefabNode.parentName = nodeBytes.readUTF();
+        prefabNode.position = nodeBytes.readVector3();
+        prefabNode.rotation = nodeBytes.readQuaternion();
+        prefabNode.scale = nodeBytes.readVector3();
+        prefabNode.comDatas = [];
+        prefabNode.child = [];
+        let comCount = nodeBytes.readInt32();
+        for (let i = 0; i < comCount; i++) {
+            const comData = ComData.parser(nodeBytes);
+            prefabNode.comDatas.push(comData);
+        }
+        let childCount = nodeBytes.readInt32();
+        for (let i = 0; i < childCount; i++) {
+            const childNodeData = PrefabNode.parser(nodeBytes);
+            prefabNode.child.push(childNodeData);
+        }
+        return prefabNode;
+    }
+}

package/dist/src/loader/parser/prefab/prefabData/PrefabTextureData.d.ts

@@ -0,0 +1,14 @@
+import { BitmapTexture2D, Vector2 } from "../../../..";
+export declare class PrefabTextureData {
+    property: string;
+    name: string;
+    texture: BitmapTexture2D;
+    texelSize: Vector2;
+    wrapModeU: number;
+    wrapModeV: number;
+    wrapModeW: number;
+    wrapMode: number;
+    anisoLevel: number;
+    dimension: number;
+    filterMode: number;
+}

package/dist/src/loader/parser/prefab/prefabData/PrefabTextureData.js

@@ -0,0 +1,2 @@
+export class PrefabTextureData {
+}

package/dist/src/loader/parser/prefab/prefabData/ValueParser.d.ts

@@ -0,0 +1,16 @@
+import { GeometryBase, Material, PropertyAnimationClip, Texture } from "../../../..";
+import { Skeleton } from "../../../../components/anim/skeletonAnim/Skeleton";
+import { Color } from "../../../../math/Color";
+import { Quaternion } from "../../../../math/Quaternion";
+import { Vector2 } from "../../../../math/Vector2";
+import { Vector3 } from "../../../../math/Vector3";
+import { Vector4 } from "../../../../math/Vector4";
+import { BytesArray } from "../../../../util/BytesArray";
+import { ValueEnumType } from "./ValueType";
+export type CurveValueType = string | number | Vector2 | Vector3 | Vector4 | Quaternion | Color | boolean | Texture | Material | string[] | number[] | Float32Array | GeometryBase | Skeleton | PropertyAnimationClip[];
+export declare class ValueParser {
+    static parser(bytes: BytesArray): {
+        t: ValueEnumType;
+        v: CurveValueType;
+    };
+}

package/dist/src/loader/parser/prefab/prefabData/ValueParser.js

@@ -0,0 +1,117 @@
+import { PropertyAnimationClip, } from "../../../..";
+import { Engine3D } from "../../../../Engine3D";
+import { ValueEnumType } from "./ValueType";
+export class ValueParser {
+    static parser(bytes) {
+        let type = bytes.readInt32();
+        switch (type) {
+            case ValueEnumType.single:
+                return { t: ValueEnumType.single, v: bytes.readFloat32() };
+            case ValueEnumType.boolean:
+                return { t: ValueEnumType.boolean, v: bytes.readBoolean() };
+            case ValueEnumType.int:
+                return { t: ValueEnumType.int, v: bytes.readInt32() };
+            case ValueEnumType.int16:
+                return { t: ValueEnumType.int16, v: bytes.readInt16() };
+            case ValueEnumType.int32:
+                return { t: ValueEnumType.int32, v: bytes.readInt32() };
+            case ValueEnumType.float:
+                return { t: ValueEnumType.float, v: bytes.readFloat32() };
+            case ValueEnumType.long:
+                return { t: ValueEnumType.long, v: bytes.readFloat64() };
+            case ValueEnumType.uint:
+                return { t: ValueEnumType.uint, v: bytes.readUnit32() };
+            case ValueEnumType.uint32:
+                return { t: ValueEnumType.uint32, v: bytes.readUnit32() };
+            case ValueEnumType.uint64:
+                return { t: ValueEnumType.uint64, v: bytes.readUnit32() };
+            case ValueEnumType.double:
+                return { t: ValueEnumType.double, v: bytes.readFloat64() };
+            case ValueEnumType.string:
+                return { t: ValueEnumType.string, v: bytes.readUTF() };
+            case ValueEnumType.singleArray:
+                return { t: ValueEnumType.singleArray, v: bytes.readFloatArray() };
+            case ValueEnumType.stringArray:
+                return { t: ValueEnumType.stringArray, v: bytes.readStringArray() };
+            case ValueEnumType.floatArray:
+                return { t: ValueEnumType.floatArray, v: bytes.readFloatArray() };
+            case ValueEnumType.vector2:
+                return { t: ValueEnumType.vector2, v: bytes.readVector2() };
+            case ValueEnumType.vector3:
+                return { t: ValueEnumType.vector3, v: bytes.readVector3() };
+            case ValueEnumType.vector4:
+                return { t: ValueEnumType.vector4, v: bytes.readVector4() };
+            case ValueEnumType.color:
+                return { t: ValueEnumType.color, v: bytes.readColor() };
+            case ValueEnumType.color32:
+                return { t: ValueEnumType.color32, v: bytes.readColor() };
+            case ValueEnumType.animationCurve:
+                return { t: ValueEnumType.animationCurve, v: null };
+            case ValueEnumType.quaternion:
+                return { t: ValueEnumType.quaternion, v: bytes.readQuaternion() };
+            case ValueEnumType.matrix4x4:
+                return { t: ValueEnumType.matrix4x4, v: null };
+            case ValueEnumType.mesh: {
+                let id = bytes.readUTF();
+                let mesh = Engine3D.res.getGeometry(id);
+                return { t: ValueEnumType.mesh, v: mesh };
+            }
+            case ValueEnumType.texture: {
+                let id = bytes.readUTF();
+                let texture = Engine3D.res.getTexture(id);
+                return { t: ValueEnumType.texture, v: texture };
+            }
+            case ValueEnumType.material: {
+                let id = bytes.readUTF();
+                let mat = Engine3D.res.getMat(id);
+                return { t: ValueEnumType.material, v: mat };
+            }
+            case ValueEnumType.materials: {
+                let str = bytes.readStringArray();
+                let mats = [];
+                for (let i = 0; i < str.length; i++) {
+                    const element = str[i];
+                    let mat = Engine3D.res.getMat(element);
+                    mats.push(mat);
+                }
+                return { t: ValueEnumType.materials, v: mats };
+            }
+            case ValueEnumType.skeleton:
+                break;
+            case ValueEnumType.animClip: {
+                let animClipDatas = [];
+                let animClipCount = bytes.readInt32();
+                for (let i = 0; i < animClipCount; i++) {
+                    let animationClipData = new PropertyAnimationClip();
+                    animationClipData.formBytes(bytes);
+                    animClipDatas.push(animationClipData);
+                }
+                return { t: ValueEnumType.animClip, v: animClipDatas };
+            }
+            case ValueEnumType.vector2Int:
+                return { t: ValueEnumType.vector2Int, v: bytes.readVector2int() };
+                break;
+            case ValueEnumType.int32List:
+                return { t: ValueEnumType.int32List, v: bytes.readInt32List() };
+                break;
+            case ValueEnumType.colorList:
+                let len = bytes.readInt32();
+                let list = [];
+                for (let i = 0; i < len; i++) {
+                    const element = ValueParser.parser(bytes).v;
+                    list.push(element);
+                }
+                return { t: ValueEnumType.colorList, v: list };
+                break;
+            case ValueEnumType.color32List:
+                let len2 = bytes.readInt32();
+                let list2 = [];
+                for (let i = 0; i < len2; i++) {
+                    const element = ValueParser.parser(bytes).v;
+                    list2.push(element);
+                }
+                return { t: ValueEnumType.color32List, v: list2 };
+                break;
+        }
+    }
+}

package/dist/src/loader/parser/prefab/prefabData/ValueType.d.ts

@@ -0,0 +1,35 @@
+export declare enum ValueEnumType {
+    single = 0,
+    boolean = 1,
+    int = 2,
+    int16 = 3,
+    int32 = 4,
+    float = 5,
+    long = 6,
+    uint = 7,
+    uint32 = 8,
+    uint64 = 9,
+    double = 10,
+    string = 11,
+    singleArray = 12,
+    stringArray = 13,
+    floatArray = 14,
+    vector2 = 15,
+    vector3 = 16,
+    vector4 = 17,
+    color = 18,
+    color32 = 19,
+    animationCurve = 20,
+    quaternion = 21,
+    matrix4x4 = 22,
+    mesh = 23,
+    texture = 24,
+    material = 25,
+    materials = 26,
+    skeleton = 27,
+    animClip = 28,
+    vector2Int = 29,
+    int32List = 30,
+    colorList = 31,
+    color32List = 32
+}

package/dist/src/loader/parser/prefab/prefabData/ValueType.js

@@ -0,0 +1,36 @@
+export var ValueEnumType;
+(function (ValueEnumType) {
+    ValueEnumType[ValueEnumType["single"] = 0] = "single";
+    ValueEnumType[ValueEnumType["boolean"] = 1] = "boolean";
+    ValueEnumType[ValueEnumType["int"] = 2] = "int";
+    ValueEnumType[ValueEnumType["int16"] = 3] = "int16";
+    ValueEnumType[ValueEnumType["int32"] = 4] = "int32";
+    ValueEnumType[ValueEnumType["float"] = 5] = "float";
+    ValueEnumType[ValueEnumType["long"] = 6] = "long";
+    ValueEnumType[ValueEnumType["uint"] = 7] = "uint";
+    ValueEnumType[ValueEnumType["uint32"] = 8] = "uint32";
+    ValueEnumType[ValueEnumType["uint64"] = 9] = "uint64";
+    ValueEnumType[ValueEnumType["double"] = 10] = "double";
+    ValueEnumType[ValueEnumType["string"] = 11] = "string";
+    ValueEnumType[ValueEnumType["singleArray"] = 12] = "singleArray";
+    ValueEnumType[ValueEnumType["stringArray"] = 13] = "stringArray";
+    ValueEnumType[ValueEnumType["floatArray"] = 14] = "floatArray";
+    ValueEnumType[ValueEnumType["vector2"] = 15] = "vector2";
+    ValueEnumType[ValueEnumType["vector3"] = 16] = "vector3";
+    ValueEnumType[ValueEnumType["vector4"] = 17] = "vector4";
+    ValueEnumType[ValueEnumType["color"] = 18] = "color";
+    ValueEnumType[ValueEnumType["color32"] = 19] = "color32";
+    ValueEnumType[ValueEnumType["animationCurve"] = 20] = "animationCurve";
+    ValueEnumType[ValueEnumType["quaternion"] = 21] = "quaternion";
+    ValueEnumType[ValueEnumType["matrix4x4"] = 22] = "matrix4x4";
+    ValueEnumType[ValueEnumType["mesh"] = 23] = "mesh";
+    ValueEnumType[ValueEnumType["texture"] = 24] = "texture";
+    ValueEnumType[ValueEnumType["material"] = 25] = "material";
+    ValueEnumType[ValueEnumType["materials"] = 26] = "materials";
+    ValueEnumType[ValueEnumType["skeleton"] = 27] = "skeleton";
+    ValueEnumType[ValueEnumType["animClip"] = 28] = "animClip";
+    ValueEnumType[ValueEnumType["vector2Int"] = 29] = "vector2Int";
+    ValueEnumType[ValueEnumType["int32List"] = 30] = "int32List";
+    ValueEnumType[ValueEnumType["colorList"] = 31] = "colorList";
+    ValueEnumType[ValueEnumType["color32List"] = 32] = "color32List";
+})(ValueEnumType || (ValueEnumType = {}));

package/dist/src/loader/parser/tileRenderer/TileSet.d.ts

@@ -0,0 +1,45 @@
+export declare class TileSet {
+    asset: {
+        generatetool: string;
+        version: string;
+        gltfUpAxis?: any;
+    };
+    extras: {
+        scenetree: string;
+    };
+    geometricError: number;
+    properties: any;
+    refine: any;
+    root: TileSetRoot;
+}
+export declare class TileSetRoot {
+    boundingVolume: {
+        box: number[];
+    };
+    children: TileSetChild[];
+    geometricError: number;
+    transform: number[];
+}
+export declare class TileSetChild {
+    boundingVolume: {
+        box: number[];
+    };
+    geometricError: number;
+    refine: string;
+    content: {
+        uri: string;
+    };
+    contents: TileSetChildContent[];
+}
+export declare class TileSetChildContent {
+    uri: string;
+    group: number;
+    metadata: TileSetChildContentMetaData;
+}
+export declare class TileSetChildContentMetaData {
+    class: string;
+    properties: {
+        vertices: number;
+        materials: number;
+    };
+}

package/dist/src/loader/parser/tileRenderer/TileSet.js

@@ -0,0 +1,10 @@
+export class TileSet {
+}
+export class TileSetRoot {
+}
+export class TileSetChild {
+}
+export class TileSetChildContent {
+}
+export class TileSetChildContentMetaData {
+}

package/dist/src/loader/parser/tileRenderer/TilesRenderer.d.ts

@@ -0,0 +1,12 @@
+import { Object3D } from "../../../core/entities/Object3D";
+export declare class TilesRenderer {
+    readonly group: Object3D;
+    private _modelList;
+    private _tileSet;
+    private _rootPath;
+    constructor();
+    loadTileSet(rootPath: string, file: string): Promise<void>;
+    private onLoadProgress;
+    private onComplete;
+    private applyTransform;
+}

package/dist/src/loader/parser/tileRenderer/TilesRenderer.js

@@ -0,0 +1,88 @@
+import { Matrix4 } from "../../../math/Matrix4";
+import { Vector3 } from "../../../math/Vector3";
+import { Orientation3D } from "../../../math/Orientation3D";
+import { Object3D } from "../../../core/entities/Object3D";
+import { Engine3D } from "../../../Engine3D";
+export class TilesRenderer {
+    constructor() {
+        this.group = new Object3D();
+    }
+    async loadTileSet(rootPath, file) {
+        this._modelList = [];
+        this._rootPath = rootPath;
+        let combinePath = rootPath + "/" + file;
+        this._tileSet = (await Engine3D.res.loadJSON(combinePath));
+        if (this._tileSet.root.transform) {
+            let rootMatrix = new Matrix4();
+            for (let i = 0; i < 16; i++) {
+                rootMatrix.rawData[i] = this._tileSet.root.transform[i];
+            }
+        }
+        let adjustmentTransform = new Matrix4();
+        const upAxis = (this._tileSet.asset && this._tileSet.asset.gltfUpAxis) || "y";
+        switch (upAxis.toLowerCase()) {
+            case "x":
+                adjustmentTransform.makeRotationAxis(Vector3.Y_AXIS, -Math.PI / 2);
+                break;
+            case "y":
+                adjustmentTransform.makeRotationAxis(Vector3.X_AXIS, Math.PI / 2);
+                break;
+            case "z":
+                adjustmentTransform.identity();
+                break;
+        }
+        let invertMatrix = adjustmentTransform.clone();
+        invertMatrix.invert();
+        this.applyTransform(this.group.transform, invertMatrix);
+        for (let item of this._tileSet.root.children) {
+            let uriList = [];
+            if (item.content && item.content.uri) {
+                uriList.push(item.content.uri);
+            }
+            if (item.contents) {
+                for (let c of item.contents) {
+                    uriList.push(c.uri);
+                }
+            }
+            for (let uriPath of uriList) {
+                let url = this._rootPath + "/" + uriPath;
+                let functions = {
+                    onProgress: (e) => this.onLoadProgress(e),
+                    onComplete: (e) => this.onComplete(e),
+                };
+                let tileObject3D;
+                if (url.endsWith(".glb")) {
+                    tileObject3D = (await Engine3D.res.loadGltf(url, functions));
+                    this.applyTransform(tileObject3D.transform, adjustmentTransform);
+                }
+                else if (url.endsWith("tileset.json")) {
+                    let childTilesetUrl = url.replace("/tileset.json", "");
+                    let tilesRenderer = new TilesRenderer();
+                    await tilesRenderer.loadTileSet(childTilesetUrl, "tileset.json");
+                    tileObject3D = tilesRenderer.group;
+                }
+                else if (url.endsWith(".i3dm")) {
+                    tileObject3D = (await Engine3D.res.loadI3DM(url, functions, adjustmentTransform));
+                }
+                else if (url.endsWith(".b3dm")) {
+                    tileObject3D = (await Engine3D.res.loadB3DM(url, functions, adjustmentTransform));
+                }
+                if (tileObject3D) {
+                    this._modelList.push(tileObject3D);
+                    this.group.addChild(tileObject3D);
+                }
+            }
+        }
+    }
+    onLoadProgress(e) { }
+    onComplete(e) { }
+    applyTransform(transform, matrix) {
+        let prs = matrix.decompose(Orientation3D.QUATERNION);
+        transform.localRotQuat.copyFrom(prs[1]);
+        transform.localRotQuat = transform.localRotQuat;
+        transform.localPosition.copyFrom(prs[0]);
+        transform.localPosition = transform.localPosition;
+        transform.localScale.copyFrom(prs[2]);
+        transform.localScale = transform.localScale;
+    }
+}

package/dist/src/materials/BlendMode.d.ts

@@ -0,0 +1,58 @@
+export declare enum BlendMode {
+    /**
+     * Working only in WebGPU may improve the performance of large background images without alpha.
+     * The source pixel is not mixed with the target pixel, so the GPU will not read colors from the target pixel.
+     */
+    NONE = 0,
+    /**
+     * Display objects above the background. When the background is transparent,
+     * the pixel values of the displayed object are not visible.
+     */
+    ABOVE = 1,
+    /**
+     * Transparent mode
+     */
+    ALPHA = 2,
+    /**
+     * Normal blend mode
+     */
+    NORMAL = 3,
+    /**
+     * Add the values of the component colors of the displayed object to its background color
+     */
+    ADD = 4,
+    /**
+     * Add the values of the component colors of the displayed object to its background color
+     */
+    BELOW = 5,
+    /**
+     * Erase the background based on the alpha value of the displayed object.
+     */
+    ERASE = 6,
+    /**
+     * Multiply the values of the displayed object's constituent colors by the background color,
+     * and then divide by 0xFF for normalization to obtain a darker color.
+     */
+    MUL = 7,
+    /**
+     * Multiply the inverse of the components of the source and target images, and then calculate the inverse result.
+     */
+    SCREEN = 8,
+    DIVD = 9,
+    SOFT_ADD = 10
+}
+/**
+ * @internal
+ * @group Material
+ */
+export declare enum Blend {
+    src_a = 0,
+    dest_a = 1
+}
+/**
+ * @internal
+ * @group Material
+ */
+export declare class BlendFactor {
+    static getBlend(blendMode: BlendMode): any;
+}