@rings-webgpu/core 1.0.0 → 1.0.2

package/dist/src/loader/parser/gltf/TypeArray.js

@@ -0,0 +1,98 @@
+const isArrayBuffer = window.SharedArrayBuffer
+    ? function isArrayBufferOrSharedArrayBuffer(ary) {
+        return (ary &&
+            ary.buffer &&
+            (ary.buffer instanceof ArrayBuffer ||
+                ary.buffer instanceof window.SharedArrayBuffer));
+    }
+    : function isArrayBuffer(ary) {
+        return ary && ary.buffer && ary.buffer instanceof ArrayBuffer;
+    };
+const BYTE = 0x1400;
+const UNSIGNED_BYTE = 0x1401;
+const SHORT = 0x1402;
+const UNSIGNED_SHORT = 0x1403;
+const INT = 0x1404;
+const UNSIGNED_INT = 0x1405;
+const FLOAT = 0x1406;
+const UNSIGNED_SHORT_4_4_4_4 = 0x8033;
+const UNSIGNED_SHORT_5_5_5_1 = 0x8034;
+const UNSIGNED_SHORT_5_6_5 = 0x8363;
+const HALF_FLOAT = 0x140b;
+const UNSIGNED_INT_2_10_10_10_REV = 0x8368;
+const UNSIGNED_INT_10F_11F_11F_REV = 0x8c3b;
+const UNSIGNED_INT_5_9_9_9_REV = 0x8c3e;
+const FLOAT_32_UNSIGNED_INT_24_8_REV = 0x8dad;
+const UNSIGNED_INT_24_8 = 0x84fa;
+const glTypeToTypedArray = {};
+{
+    const tt = glTypeToTypedArray;
+    tt[BYTE] = Int8Array;
+    tt[UNSIGNED_BYTE] = Uint8Array;
+    tt[SHORT] = Int16Array;
+    tt[UNSIGNED_SHORT] = Uint16Array;
+    tt[INT] = Int32Array;
+    tt[UNSIGNED_INT] = Uint32Array;
+    tt[FLOAT] = Float32Array;
+    tt[UNSIGNED_SHORT_4_4_4_4] = Uint16Array;
+    tt[UNSIGNED_SHORT_5_5_5_1] = Uint16Array;
+    tt[UNSIGNED_SHORT_5_6_5] = Uint16Array;
+    tt[HALF_FLOAT] = Uint16Array;
+    tt[UNSIGNED_INT_2_10_10_10_REV] = Uint32Array;
+    tt[UNSIGNED_INT_10F_11F_11F_REV] = Uint32Array;
+    tt[UNSIGNED_INT_5_9_9_9_REV] = Uint32Array;
+    tt[FLOAT_32_UNSIGNED_INT_24_8_REV] = Uint32Array;
+    tt[UNSIGNED_INT_24_8] = Uint32Array;
+}
+export function getGLTypeFromTypedArrayType(typedArrayType) {
+    switch (typedArrayType) {
+        case Int8Array:
+            return BYTE;
+        case Uint8Array:
+            return UNSIGNED_BYTE;
+        case Uint8ClampedArray:
+            return UNSIGNED_BYTE;
+        case Int16Array:
+            return SHORT;
+        case Uint16Array:
+            return UNSIGNED_SHORT;
+        case Int32Array:
+            return INT;
+        case Uint32Array:
+            return UNSIGNED_INT;
+        case Float32Array:
+            return FLOAT;
+        default:
+            throw new Error("unsupported typed array type");
+    }
+}
+export function getGLTypeFromTypedArray(typedArray) {
+    if (typedArray instanceof Int8Array)
+        return BYTE;
+    if (typedArray instanceof Uint8Array)
+        return UNSIGNED_BYTE;
+    if (typedArray instanceof Uint8ClampedArray)
+        return UNSIGNED_BYTE;
+    if (typedArray instanceof Int16Array)
+        return SHORT;
+    if (typedArray instanceof Uint16Array)
+        return UNSIGNED_SHORT;
+    if (typedArray instanceof Int32Array)
+        return INT;
+    if (typedArray instanceof Uint32Array)
+        return UNSIGNED_INT;
+    if (typedArray instanceof Float32Array)
+        return FLOAT;
+    throw new Error("unsupported typed array type");
+}
+export function getTypedArrayTypeFromGLType(type) {
+    const arrayType = glTypeToTypedArray[type];
+    if (!arrayType)
+        throw new Error("unkonw gl type");
+    return arrayType;
+}
+export function getTypedArray(array, Type = Float32Array) {
+    if (isArrayBuffer(array))
+        return array;
+    return new Type(array);
+}

package/dist/src/loader/parser/gltf/extends/KHR_draco_mesh_compression.d.ts

@@ -0,0 +1,9 @@
+import { GLTF_Primitives } from "../GLTFInfo";
+import { GLTFSubParser } from "../GLTFSubParser";
+export declare class KHR_draco_mesh_compression {
+    private static _workerCode;
+    private static _workers;
+    static apply(parser: GLTFSubParser, primitive: GLTF_Primitives): Promise<any>;
+    static unload(gltf: any): void;
+    protected static initDecoder(): Promise<string>;
+}

package/dist/src/loader/parser/gltf/extends/KHR_draco_mesh_compression.js

@@ -0,0 +1,157 @@
+import { FileLoader } from "../../../FileLoader";
+export class KHR_draco_mesh_compression {
+    static { this._workers = new Map(); }
+    static async apply(parser, primitive) {
+        if (!primitive.extensions) {
+            return;
+        }
+        const extensionArgs = primitive.extensions["KHR_draco_mesh_compression"];
+        if (!extensionArgs) {
+            return;
+        }
+        let worker = this._workers.get(parser.gltf);
+        if (!worker) {
+            worker = new Worker(await this.initDecoder());
+            this._workers.set(parser.gltf, worker);
+        }
+        worker.postMessage({
+            type: "init",
+            decoderConfig: {
+            // wasmBinary: dracoDecoderWasm
+            },
+        });
+        let buffer = parser.parseBufferView(extensionArgs.bufferView);
+        if (!buffer.result) {
+            let result = await new Promise((resolve, reject) => {
+                worker.onmessage = (e) => {
+                    const msg = e.data;
+                    if (msg.type == "decode") {
+                        resolve(msg.result);
+                    }
+                    else if (msg.type == "error") {
+                        reject(msg.error);
+                    }
+                };
+                worker.postMessage({
+                    type: "decoder",
+                    buffer: buffer,
+                    attributes: extensionArgs.attributes,
+                }, [buffer]);
+            });
+            buffer.result = result;
+        }
+        return buffer.result;
+    }
+    static unload(gltf) {
+        let worker = this._workers.get(gltf);
+        if (worker) {
+            worker.terminate();
+            this._workers.delete(gltf);
+        }
+    }
+    // todo
+    static async initDecoder() {
+        if (!this._workerCode) {
+            // 后续替换
+            let dracoDecoderJs = await new FileLoader().loadTxt("https://cdn.rings.com/draco_decoder_gltf.js");
+            const blob = new Blob([dracoDecoderJs["data"], "", `(${dracoDecoderWoeker})()`], { type: "application/javascript" });
+            this._workerCode = URL.createObjectURL(blob);
+        }
+        return this._workerCode;
+    }
+}
+function dracoDecoderWoeker() {
+    let decoderConfig;
+    let decoderPending;
+    onmessage = (e) => {
+        const msg = e.data;
+        switch (msg.type) {
+            case "init":
+                decoderConfig = msg.decoderConfig;
+                decoderPending = new Promise((resolve, reject) => {
+                    decoderConfig.onModuleLoaded = (draco) => {
+                        resolve({
+                            draco: draco,
+                        });
+                    };
+                    // @ts-ignore
+                    DracoDecoderModule(decoderConfig);
+                });
+                break;
+            case "decoder":
+                const buffer = msg.buffer;
+                const attributes = msg.attributes;
+                decoderPending.then((module) => {
+                    const draco = module.draco;
+                    let decoder = new draco.Decoder();
+                    let decoderBuffer = new draco.DecoderBuffer();
+                    decoderBuffer.Init(new Int8Array(buffer), buffer.byteLength);
+                    let status, dracoGeometry;
+                    try {
+                        const geometryType = decoder.GetEncodedGeometryType(decoderBuffer);
+                        if (geometryType == draco.TRIANGULAR_MESH) {
+                            dracoGeometry = new draco.Mesh();
+                            status = decoder.DecodeBufferToMesh(decoderBuffer, dracoGeometry);
+                        } /*else if (geometryType == draco.POINT_CLOUD) {
+                                            dracoGeometry = new draco.PointCloud();
+                                            status = decoder.DecodeBufferToPointCloud(decoderBuffer, dracoGeometry);
+                                        } */
+                        else {
+                            self.postMessage(new Error("INVALID_GEOMETRY_TYPE:" + geometryType));
+                        }
+                        if (!status.ok()) {
+                            self.postMessage(new Error("DracoDecode:" + status.error_msg()));
+                        }
+                        let result = {};
+                        for (const attributeName in attributes) {
+                            let attribute = decoder.GetAttributeByUniqueId(dracoGeometry, attributes[attributeName]);
+                            const numComponents = attribute.num_components();
+                            const numPoints = dracoGeometry.num_points();
+                            const numValues = numPoints * numComponents;
+                            const byteLength = numValues * Float32Array.BYTES_PER_ELEMENT;
+                            const dataType = draco.DT_FLOAT32; // getDracoDataType(draco, Float32Array);
+                            const ptr = draco._malloc(byteLength);
+                            decoder.GetAttributeDataArrayForAllPoints(dracoGeometry, attribute, dataType, byteLength, ptr);
+                            const array = new Float32Array(draco.HEAPF32.buffer, ptr, numValues).slice();
+                            draco._free(ptr);
+                            result[attributeName] = {
+                                data: array,
+                                numComponents,
+                                normalize: false,
+                            };
+                        }
+                        {
+                            const numFaces = dracoGeometry.num_faces();
+                            const numIndices = numFaces * 3;
+                            const byteLength = numIndices * 4;
+                            const ptr = draco._malloc(byteLength);
+                            decoder.GetTrianglesUInt32Array(dracoGeometry, byteLength, ptr);
+                            const index = new Uint32Array(draco.HEAPF32.buffer, ptr, numIndices).slice();
+                            draco._free(ptr);
+                            result["indices"] = {
+                                data: index,
+                                numComponents: 1,
+                                normalize: false,
+                            };
+                        }
+                        self.postMessage({
+                            type: "decode",
+                            result,
+                        });
+                    }
+                    catch (error) {
+                        self.postMessage({
+                            type: "error",
+                            error: error.message,
+                        });
+                    }
+                    finally {
+                        draco.destroy(dracoGeometry);
+                        draco.destroy(decoder);
+                        draco.destroy(decoderBuffer);
+                    }
+                });
+                break;
+        }
+    };
+}

package/dist/src/loader/parser/gltf/extends/KHR_lights_punctual.d.ts

@@ -0,0 +1,2 @@
+export declare class KHR_lights_punctual {
+}

package/dist/src/loader/parser/gltf/extends/KHR_lights_punctual.js

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

package/dist/src/loader/parser/gltf/extends/KHR_materials_clearcoat.d.ts

@@ -0,0 +1,7 @@
+/**
+ * @internal
+ * @group Loader
+ */
+export declare class KHR_materials_clearcoat {
+    static apply(gltf: any, dmaterial: any, tMaterial: any): void;
+}

package/dist/src/loader/parser/gltf/extends/KHR_materials_clearcoat.js

@@ -0,0 +1,26 @@
+// https://github.com/KhronosGroup/glTF/tree/main/extensions/2.0/Khronos/KHR_materials_clearcoat
+/**
+ * @internal
+ * @group Loader
+ */
+export class KHR_materials_clearcoat {
+    static apply(gltf, dmaterial, tMaterial) {
+        let extensions = dmaterial.extensions;
+        if (extensions && extensions[`KHR_materials_clearcoat`]) {
+            tMaterial.shader
+                .getDefaultColorShader()
+                .setDefine("USE_CLEARCOAT", true);
+            let KHR_materials_clearcoat = extensions[`KHR_materials_clearcoat`];
+            if (`clearcoatFactor` in KHR_materials_clearcoat) {
+                dmaterial.clearcoatFactor = KHR_materials_clearcoat[`clearcoatFactor`];
+                tMaterial.clearcoatFactor = dmaterial.clearcoatFactor;
+            }
+            if (`clearcoatRoughnessFactor` in KHR_materials_clearcoat) {
+                dmaterial.clearcoatRoughnessFactor =
+                    KHR_materials_clearcoat[`clearcoatRoughnessFactor`];
+                tMaterial.clearcoatRoughnessFactor =
+                    dmaterial.clearcoatRoughnessFactor;
+            }
+        }
+    }
+}

package/dist/src/loader/parser/gltf/extends/KHR_materials_emissive_strength.d.ts

@@ -0,0 +1,3 @@
+export declare class KHR_materials_emissive_strength {
+    static apply(gltf: any, dmaterial: any, tMaterial: any): void;
+}

package/dist/src/loader/parser/gltf/extends/KHR_materials_emissive_strength.js

@@ -0,0 +1,17 @@
+//https://github.com/KhronosGroup/glTF/tree/main/extensions/2.0/Khronos/KHR_materials_emissive_strength
+import { Engine3D } from "../../../../Engine3D";
+export class KHR_materials_emissive_strength {
+    static apply(gltf, dmaterial, tMaterial) {
+        let extensions = dmaterial.extensions;
+        if (extensions && extensions[`KHR_materials_emissive_strength`]) {
+            tMaterial.emissiveIntensity =
+                extensions[`KHR_materials_emissive_strength`].emissiveStrength;
+            if (tMaterial.emissiveMap == Engine3D.res.blackTexture) {
+                tMaterial.emissiveMap = Engine3D.res.whiteTexture;
+            }
+        }
+        else {
+            tMaterial.emissiveIntensity = 1;
+        }
+    }
+}

package/dist/src/loader/parser/gltf/extends/KHR_materials_ior.d.ts

@@ -0,0 +1,2 @@
+export declare class KHR_materials_ior {
+}

package/dist/src/loader/parser/gltf/extends/KHR_materials_ior.js

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

package/dist/src/loader/parser/gltf/extends/KHR_materials_unlit.d.ts

@@ -0,0 +1,3 @@
+export declare class KHR_materials_unlit {
+    static apply(gltf: any, dmaterial: any, tMaterial: any): void;
+}

package/dist/src/loader/parser/gltf/extends/KHR_materials_unlit.js

@@ -0,0 +1,12 @@
+//https://github.com/KhronosGroup/glTF/tree/main/extensions/2.0/Khronos/KHR_materials_unlit
+export class KHR_materials_unlit {
+    static apply(gltf, dmaterial, tMaterial) {
+        let extensions = dmaterial.extensions;
+        if (extensions && extensions[`KHR_materials_unlit`]) {
+            tMaterial.supportLight = true;
+        }
+        else {
+            tMaterial.supportLight = false;
+        }
+    }
+}

package/dist/src/loader/parser/i3dm/I3DMLoader.d.ts

@@ -0,0 +1,17 @@
+import { I3DMLoaderBase } from "./I3DMLoaderBase";
+import { Matrix4 } from "../../../math/Matrix4";
+import { Quaternion } from "../../../math/Quaternion";
+import { Vector3 } from "../../../math/Vector3";
+export declare class I3DMLoader extends I3DMLoaderBase {
+    static tempFwd: Vector3;
+    static tempUp: Vector3;
+    static tempRight: Vector3;
+    static tempPos: Vector3;
+    static tempQuat: Quaternion;
+    static tempSca: Vector3;
+    static tempMat: Matrix4;
+    adjustmentTransform: Matrix4;
+    private _gltfBuffer;
+    constructor();
+    parse(buffer: ArrayBuffer): Promise<any>;
+}

package/dist/src/loader/parser/i3dm/I3DMLoader.js

@@ -0,0 +1,97 @@
+import { I3DMLoaderBase } from "./I3DMLoaderBase";
+import { InstancedMesh } from "../../../core/entities/InstancedMesh";
+import { B3DMParseUtil } from "../B3DMParser";
+import { Matrix4 } from "../../../math/Matrix4";
+import { MeshRenderer } from "../../../components/renderer/MeshRenderer";
+import { Quaternion } from "../../../math/Quaternion";
+import { Vector3 } from "../../../math/Vector3";
+export class I3DMLoader extends I3DMLoaderBase {
+    constructor() {
+        super();
+        I3DMLoader.tempFwd ||= new Vector3();
+        I3DMLoader.tempUp ||= new Vector3();
+        I3DMLoader.tempRight ||= new Vector3();
+        I3DMLoader.tempPos ||= new Vector3();
+        I3DMLoader.tempQuat ||= new Quaternion();
+        I3DMLoader.tempSca ||= new Vector3();
+        I3DMLoader.tempMat ||= new Matrix4();
+        this.adjustmentTransform = new Matrix4().identity();
+    }
+    async parse(buffer) {
+        const i3dm = await super.parse(buffer);
+        this._gltfBuffer = i3dm.glbBytes.slice().buffer;
+        let glbLoader = new B3DMParseUtil();
+        let model = await glbLoader.parseBinary(this._gltfBuffer);
+        let { batchTable, featureTable } = i3dm;
+        const adjustmentTransform = this.adjustmentTransform;
+        const INSTANCES_LENGTH = featureTable.getData("INSTANCES_LENGTH");
+        const POSITION = featureTable.getData("POSITION", INSTANCES_LENGTH, "FLOAT", "VEC3");
+        const NORMAL_UP = featureTable.getData("NORMAL_UP", INSTANCES_LENGTH, "FLOAT", "VEC3");
+        const NORMAL_RIGHT = featureTable.getData("NORMAL_RIGHT", INSTANCES_LENGTH, "FLOAT", "VEC3");
+        const SCALE_NON_UNIFORM = featureTable.getData("SCALE_NON_UNIFORM", INSTANCES_LENGTH, "FLOAT", "VEC3");
+        const SCALE = featureTable.getData("SCALE", INSTANCES_LENGTH, "FLOAT", "SCALAR");
+        const instanceMap = new Map();
+        const instances = [];
+        model.traverse((child) => {
+            let renderer;
+            renderer = child ? child.getComponent(MeshRenderer) : null;
+            if (renderer) {
+                const { geometry, material } = renderer;
+                const instancedMesh = new InstancedMesh(geometry, material, INSTANCES_LENGTH);
+                instancedMesh.localPosition = instancedMesh.localPosition.copy(child.localPosition);
+                instancedMesh.localRotation = instancedMesh.localRotation.copy(child.localRotation);
+                instancedMesh.localScale = instancedMesh.localScale.copy(child.localScale);
+                instances.push(instancedMesh);
+                instanceMap.set(child, instancedMesh);
+            }
+        });
+        const averageVector = new Vector3();
+        for (let i = 0; i < INSTANCES_LENGTH; i++) {
+            averageVector.x += POSITION[i * 3 + 0] / INSTANCES_LENGTH;
+            averageVector.y += POSITION[i * 3 + 1] / INSTANCES_LENGTH;
+            averageVector.z += POSITION[i * 3 + 2] / INSTANCES_LENGTH;
+        }
+        instanceMap.forEach((instancedMesh, oldObject) => {
+            const parent = oldObject.parent ? oldObject.parentObject : null;
+            if (parent) {
+                parent.removeChild(oldObject);
+                parent.addChild(instancedMesh);
+                instancedMesh.transform.updateWorldMatrix();
+                instancedMesh.transform.worldMatrix.transformVector4(averageVector, instancedMesh.localPosition);
+            }
+        });
+        const temp = I3DMLoader;
+        for (let i = 0; i < INSTANCES_LENGTH; i++) {
+            temp.tempMat.identity();
+            temp.tempPos.set(POSITION[i * 3 + 0] - averageVector.x, POSITION[i * 3 + 1] - averageVector.y, POSITION[i * 3 + 2] - averageVector.z);
+            if (NORMAL_UP) {
+                temp.tempUp.set(NORMAL_UP[i * 3 + 0], NORMAL_UP[i * 3 + 1], NORMAL_UP[i * 3 + 2]);
+                temp.tempRight.set(NORMAL_RIGHT[i * 3 + 0], NORMAL_RIGHT[i * 3 + 1], NORMAL_RIGHT[i * 3 + 2]);
+                temp.tempRight.crossProduct(temp.tempUp, temp.tempFwd).normalize();
+                temp.tempMat.makeBasis(temp.tempRight, temp.tempUp, temp.tempFwd);
+                temp.tempQuat.setFromRotationMatrix(temp.tempMat);
+            }
+            else {
+                temp.tempQuat.set(0, 0, 0, 1);
+            }
+            if (SCALE) {
+                temp.tempSca.setScalar(SCALE[i]);
+            }
+            else if (SCALE_NON_UNIFORM) {
+                temp.tempSca.set(SCALE_NON_UNIFORM[i * 3 + 0], SCALE_NON_UNIFORM[i * 3 + 1], SCALE_NON_UNIFORM[i * 3 + 2]);
+            }
+            else {
+                temp.tempSca.set(1, 1, 1);
+            }
+            temp.tempMat.compose(temp.tempPos, temp.tempQuat, temp.tempSca);
+            temp.tempMat.multiplyMatrices(temp.tempMat, adjustmentTransform);
+            for (let j = 0, l = instances.length; j < l; j++) {
+                const instance = instances[j];
+                instance.setMatrixAt(i, temp.tempMat);
+            }
+        }
+        model["batchTable"] = batchTable;
+        model["featureTable"] = featureTable;
+        return model;
+    }
+}

package/dist/src/loader/parser/i3dm/I3DMLoaderBase.d.ts

@@ -0,0 +1,9 @@
+import { BatchTable, FeatureTable } from "../b3dm/FeatureTable";
+export declare class I3DMLoaderBase {
+    parse(buffer: ArrayBuffer): Promise<{
+        version: number;
+        featureTable: FeatureTable;
+        batchTable: BatchTable;
+        glbBytes: Uint8Array<ArrayBuffer>;
+    }>;
+}

package/dist/src/loader/parser/i3dm/I3DMLoaderBase.js

@@ -0,0 +1,40 @@
+import { readMagicBytes } from "../b3dm/readMagicBytes";
+import { BatchTable, FeatureTable } from "../b3dm/FeatureTable";
+export class I3DMLoaderBase {
+    async parse(buffer) {
+        const dataView = new DataView(buffer);
+        // 4 bytes
+        const magic = readMagicBytes(dataView);
+        console.assert(magic === "i3dm");
+        // 4 bytes
+        const version = dataView.getUint32(4, true);
+        console.assert(version === 1);
+        // 4 bytes
+        const byteLength = dataView.getUint32(8, true);
+        console.assert(byteLength === buffer.byteLength);
+        // 4 bytes
+        const featureTableJSONByteLength = dataView.getUint32(12, true);
+        // 4 bytes
+        const featureTableBinaryByteLength = dataView.getUint32(16, true);
+        // 4 bytes
+        const batchTableJSONByteLength = dataView.getUint32(20, true);
+        // 4 bytes
+        const batchTableBinaryByteLength = dataView.getUint32(24, true);
+        // 4 bytes
+        const gltfFormat = dataView.getUint32(28, true);
+        const featureTableStart = 32;
+        const featureTable = new FeatureTable(buffer, featureTableStart, featureTableJSONByteLength, featureTableBinaryByteLength);
+        const batchTableStart = featureTableStart +
+            featureTableJSONByteLength +
+            featureTableBinaryByteLength;
+        const batchTable = new BatchTable(buffer, featureTable.getData("INSTANCES_LENGTH"), batchTableStart, batchTableJSONByteLength, batchTableBinaryByteLength);
+        const glbStart = batchTableStart + batchTableJSONByteLength + batchTableBinaryByteLength;
+        const glbBytes = new Uint8Array(buffer, glbStart, byteLength - glbStart);
+        return {
+            version,
+            featureTable,
+            batchTable,
+            glbBytes,
+        };
+    }
+}

package/dist/src/loader/parser/prefab/PrefabAvatarParser.d.ts

@@ -0,0 +1,9 @@
+import { BytesArray } from "../../../util/BytesArray";
+import { ParserBase } from "../ParserBase";
+import { ParserFormat } from "../ParserFormat";
+import { PrefabParser } from "./PrefabParser";
+export declare class PrefabAvatarParser extends ParserBase {
+    static format: ParserFormat;
+    static parser(bytesStream: BytesArray, prefabParser: PrefabParser): void;
+    verification(): boolean;
+}

package/dist/src/loader/parser/prefab/PrefabAvatarParser.js

@@ -0,0 +1,38 @@
+import { Engine3D } from "../../../Engine3D";
+import { VertexAttributeName } from "../../../core/geometry/VertexAttributeName";
+import { ParserBase } from "../ParserBase";
+import { ParserFormat } from "../ParserFormat";
+import { PrefabAvatarData } from "./prefabData/PrefabAvatarData";
+export class PrefabAvatarParser extends ParserBase {
+    static { this.format = ParserFormat.BIN; }
+    static parser(bytesStream, prefabParser) {
+        let avatarCount = bytesStream.readInt32();
+        for (let j = 0; j < avatarCount; j++) {
+            let prefabAvatarData = new PrefabAvatarData();
+            prefabAvatarData.formBytes(bytesStream.readBytesArray());
+            Engine3D.res.addObj(prefabAvatarData.name, prefabAvatarData);
+        }
+    }
+    verification() {
+        if (this.data) {
+            return true;
+        }
+        throw new Error("verify failed.");
+    }
+}
+let MeshVertexAttribute = {
+    Position: VertexAttributeName.position,
+    Normal: VertexAttributeName.normal,
+    Color: VertexAttributeName.color,
+    Tangent: VertexAttributeName.TANGENT,
+    TexCoord0: VertexAttributeName.uv,
+    TexCoord1: VertexAttributeName.TEXCOORD_1,
+    TexCoord2: VertexAttributeName.TEXCOORD_2,
+    TexCoord3: VertexAttributeName.TEXCOORD_2,
+    TexCoord4: VertexAttributeName.TEXCOORD_4,
+    TexCoord5: VertexAttributeName.TEXCOORD_5,
+    TexCoord6: VertexAttributeName.TEXCOORD_6,
+    TexCoord7: VertexAttributeName.TEXCOORD_7,
+    BlendIndices: VertexAttributeName.joints0,
+    BlendWeight: VertexAttributeName.weights0,
+};

package/dist/src/loader/parser/prefab/PrefabMaterialParser.d.ts

@@ -0,0 +1,9 @@
+import { BytesArray } from "../../../util/BytesArray";
+import { ParserBase } from "../ParserBase";
+import { ParserFormat } from "../ParserFormat";
+import { PrefabParser } from "./PrefabParser";
+export declare class PrefabMaterialParser extends ParserBase {
+    static format: ParserFormat;
+    static parserMaterial(bytesStream: BytesArray, prefabParser: PrefabParser): void;
+    verification(): boolean;
+}