@rings-webgpu/core 1.0.1 → 1.0.2

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

@@ -0,0 +1,115 @@
+import { Engine3D } from "../../..";
+import { ParserBase } from "../ParserBase";
+import { ParserFormat } from "../ParserFormat";
+import { MaterialUtilities } from "./mats/MaterialUtilities";
+import { KV } from "./prefabData/KVData";
+import { PrefabTextureData } from "./prefabData/PrefabTextureData";
+export class PrefabMaterialParser extends ParserBase {
+    static { this.format = ParserFormat.TEXT; }
+    static parserMaterial(bytesStream, prefabParser) {
+        let matCount = bytesStream.readInt32();
+        for (let i = 0; i < matCount; i++) {
+            let matBytes = bytesStream.readBytesArray();
+            let matName = matBytes.readUTF();
+            let id = matBytes.readUTF();
+            let renderType = matBytes.readUTF();
+            let defines = matBytes.readStringArray();
+            let transformUV1 = matBytes.readVector4();
+            let uvTransform_2 = matBytes.readVector4();
+            let shaderName = matBytes.readUTF();
+            let properties = [];
+            let textures = [];
+            let propertyCount = matBytes.readInt32();
+            for (let j = 0; j < propertyCount; j++) {
+                let kv = new KV();
+                kv.formBytes(matBytes);
+                properties.push(kv);
+            }
+            let textureCount = matBytes.readInt32();
+            for (let j = 0; j < textureCount; j++) {
+                let texBytes = matBytes.readBytesArray();
+                let textureData = new PrefabTextureData();
+                textureData.property = texBytes.readUTF();
+                textureData.name = texBytes.readUTF();
+                textureData.texture = Engine3D.res.getTexture(textureData.name);
+                textureData.texelSize = texBytes.readVector2();
+                textureData.wrapModeU = texBytes.readUnit32();
+                textureData.wrapModeV = texBytes.readUnit32();
+                textureData.wrapModeW = texBytes.readUnit32();
+                textureData.wrapMode = texBytes.readUnit32();
+                textureData.anisoLevel = texBytes.readUnit32();
+                textureData.dimension = texBytes.readUnit32();
+                textureData.filterMode = texBytes.readUnit32();
+                textures.push(textureData);
+            }
+            let mat = MaterialUtilities.GetMaterial(shaderName);
+            mat.name = matName;
+            for (let i = 0; i < defines.length; i++) {
+                const define = defines[i];
+                mat.shader.setDefine(define, true);
+            }
+            MaterialUtilities.applyMaterialTexture(mat, textures);
+            MaterialUtilities.applyMaterialProperties(mat, properties);
+            Engine3D.res.addMat(id, mat);
+        }
+    }
+    verification() {
+        if (this.data) {
+            return true;
+        }
+        throw new Error("verify failed.");
+    }
+}
+class Texture_transformer {
+    _MainTex(tex, material) {
+        material.shader.setDefine("USE_SRGB_ALBEDO", true);
+        return {
+            property: "baseMap",
+            value: tex.texture,
+        };
+    }
+    _MetallicGlossMap(tex) {
+        return {
+            property: "maskMap",
+            value: tex.texture,
+        };
+    }
+    _BumpMap(tex) {
+        return {
+            property: "normalMap",
+            value: tex.texture,
+        };
+    }
+    _OcclusionMap(tex, mat) {
+        mat.shader.setDefine("USE_AOTEX", true);
+        mat.ao = 1.0;
+        return {
+            property: "aoMap",
+            value: tex.texture,
+        };
+    }
+}
+class Material_transformer {
+    _Color(kv, material) {
+        material.baseColor = kv.getValue();
+    }
+    _GlossMapScale(kv, material) {
+        material.roughness = kv.getValue()[0];
+    }
+    _Metallic(kv, material) {
+        if (!material.maskMap) {
+            material.metallic = kv.getValue()[0];
+        }
+        else {
+            material.metallic = 1.0;
+        }
+    }
+    _SmoothnessTextureChannel(kv, material) {
+        let channel = kv.getValue();
+        let type = channel == 0 ? `USE_ROUGHNESS_A` : "USE_ALBEDO_A";
+        let type2 = `USE_METALLIC_R`;
+        material.shader.setDefine(type, true);
+        material.shader.setDefine(type2, true);
+    }
+}
+let TextureChannel = ["A", "R", "G", "B"];

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

@@ -0,0 +1,10 @@
+import { BytesArray } from "../../../util/BytesArray";
+import { ParserBase } from "../ParserBase";
+import { ParserFormat } from "../ParserFormat";
+import { PrefabParser } from "./PrefabParser";
+export declare class PrefabMeshParser extends ParserBase {
+    static format: ParserFormat;
+    parseBuffer(buffer: ArrayBuffer): Promise<void>;
+    static parserMeshs(bytesStream: BytesArray, prefabParser: PrefabParser): void;
+    verification(): boolean;
+}

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

@@ -0,0 +1,133 @@
+import { Engine3D } from "../../../Engine3D";
+import { GeometryBase, } from "../../../core/geometry/GeometryBase";
+import { GeometryVertexType } from "../../../core/geometry/GeometryVertexType";
+import { VertexAttributeName } from "../../../core/geometry/VertexAttributeName";
+import { ParserBase } from "../ParserBase";
+import { ParserFormat } from "../ParserFormat";
+import { BlendShapeData } from "./prefabData/BlendShapeData";
+import { PrefabMeshData } from "./prefabData/PrefabMeshData";
+export class PrefabMeshParser extends ParserBase {
+    static { this.format = ParserFormat.BIN; }
+    async parseBuffer(buffer) { }
+    static parserMeshs(bytesStream, prefabParser) {
+        let meshCount = bytesStream.readInt32();
+        for (let j = 0; j < meshCount; j++) {
+            let prefabMesh = new PrefabMeshData();
+            let meshBytesArray = bytesStream.readBytesArray();
+            prefabMesh.meshName = meshBytesArray.readUTF();
+            prefabMesh.meshID = meshBytesArray.readUTF();
+            let useTangent = meshBytesArray.readFloat32() > 0;
+            let useColor = meshBytesArray.readFloat32() > 0;
+            let useSecondUV = meshBytesArray.readFloat32() > 0;
+            let useSkeleton = meshBytesArray.readFloat32() > 0;
+            let useBlendShape = meshBytesArray.readFloat32() > 0;
+            if (useSkeleton) {
+                prefabMesh.bones = meshBytesArray.readStringArray();
+                prefabMesh.bindPose = meshBytesArray.readMatrix44Array();
+            }
+            if (useBlendShape) {
+                prefabMesh.blendShapeData = new BlendShapeData();
+                prefabMesh.blendShapeData.formBytes(meshBytesArray);
+            }
+            let vertexBlock = meshBytesArray.readBytesArray();
+            let vertexBuffer = meshBytesArray.readBytesArray();
+            let attCount = vertexBlock.readInt32();
+            let vertex_dim = 0;
+            let attributes = [];
+            for (let i = 0; i < attCount; i++) {
+                attributes[i] = {};
+                attributes[i].att = MeshVertexAttribute[vertexBlock.readUTF()];
+                attributes[i].dim = vertexBlock.readInt32();
+                vertex_dim += attributes[i].dim;
+                attributes[i].format = vertexBlock.readUTF();
+            }
+            prefabMesh.vertexCount = vertexBlock.readInt32();
+            prefabMesh.vertexBuffer = vertexBuffer.getFloat32Array();
+            let tmpIndices = meshBytesArray.readInt32Array();
+            let subMesh = [];
+            let subMeshCount = meshBytesArray.readInt32();
+            for (let jj = 0; jj < subMeshCount; jj++) {
+                let subMesh_topology = meshBytesArray.readInt32();
+                let subMesh_indexStart = meshBytesArray.readInt32();
+                let subMesh_indexCount = meshBytesArray.readInt32();
+                let subMesh_baseVertex = meshBytesArray.readInt32();
+                let subMesh_firstVertex = meshBytesArray.readInt32();
+                let subMesh_vertexCount = meshBytesArray.readInt32();
+                let subMesh_boundMin = meshBytesArray.readVector3();
+                let subMesh_boundMax = meshBytesArray.readVector3();
+                let subDes = {
+                    indexStart: subMesh_indexStart,
+                    indexCount: subMesh_indexCount,
+                    vertexStart: subMesh_baseVertex,
+                    vertexCount: subMesh_vertexCount,
+                    firstStart: subMesh_firstVertex,
+                    topology: subMesh_topology,
+                    index: jj,
+                };
+                subMesh.push(subDes);
+            }
+            if (tmpIndices.length > 65535) {
+                prefabMesh.indices = new Uint32Array(tmpIndices);
+            }
+            else {
+                prefabMesh.indices = new Uint16Array(tmpIndices);
+            }
+            let geometry = new GeometryBase();
+            geometry.vertexDim = vertex_dim;
+            geometry.geometryType = GeometryVertexType.compose_bin;
+            geometry.setIndices(prefabMesh.indices);
+            geometry.setAttribute(VertexAttributeName.all, prefabMesh.vertexBuffer);
+            if (useSkeleton) {
+                geometry.skinNames = prefabMesh.bones;
+                geometry.bindPose = prefabMesh.bindPose;
+            }
+            if (useBlendShape) {
+                geometry.blendShapeData = prefabMesh.blendShapeData;
+                geometry.morphTargetsRelative = true;
+                geometry.morphTargetDictionary = {};
+                for (let i = 0; i < prefabMesh.blendShapeData.blendCount; i++) {
+                    geometry.setAttribute("a_morphPositions_" + i, prefabMesh.blendShapeData.blendShapePropertyDatas[i]
+                        .blendPositionList);
+                    geometry.setAttribute("a_morphNormals_" + i, prefabMesh.blendShapeData.blendShapePropertyDatas[i].blendNormalList);
+                    for (let i = 0; i < prefabMesh.blendShapeData.blendCount; i++) {
+                        let blendName = prefabMesh.blendShapeData.shapeNames[i];
+                        let blendIndex = prefabMesh.blendShapeData.shapeIndexs[i];
+                        geometry.morphTargetDictionary[blendName] = blendIndex;
+                    }
+                }
+            }
+            for (let ii = 0; ii < attributes.length; ii++) {
+                const element = attributes[ii].att;
+                geometry.setAttribute(element, null); //3
+            }
+            for (let kk = 0; kk < subMesh.length; kk++) {
+                const element = subMesh[kk];
+                geometry.addSubGeometry(element);
+            }
+            geometry.name = prefabMesh.meshName;
+            Engine3D.res.addGeometry(prefabMesh.meshID, geometry);
+        }
+    }
+    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.vIndex,
+    BlendIndices: VertexAttributeName.joints0,
+    BlendWeight: VertexAttributeName.weights0,
+};

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

@@ -0,0 +1,16 @@
+import { ParserBase } from "../ParserBase";
+import { ParserFormat } from "../ParserFormat";
+import { PrefabAvatarData } from "./prefabData/PrefabAvatarData";
+import { PrefabNode } from "./prefabData/PrefabNode";
+export declare class PrefabParser extends ParserBase {
+    static useWebp: boolean;
+    static format: ParserFormat;
+    avatarDic: {
+        [name: string]: PrefabAvatarData;
+    };
+    nodeData: PrefabNode;
+    parseBuffer(buffer: ArrayBuffer): Promise<void>;
+    private parserPrefabNode;
+    private parserNodeTree;
+    verification(): boolean;
+}

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

@@ -0,0 +1,72 @@
+import { Object3D } from "../../../core/entities/Object3D";
+import { Quaternion } from "../../../math/Quaternion";
+import { Vector3 } from "../../../math/Vector3";
+import { BytesArray } from "../../../util/BytesArray";
+import { GetComponentClass } from "../../../util/SerializeDecoration";
+import { ParserBase } from "../ParserBase";
+import { ParserFormat } from "../ParserFormat";
+import { PrefabAvatarParser } from "./PrefabAvatarParser";
+import { PrefabMaterialParser } from "./PrefabMaterialParser";
+import { PrefabMeshParser } from "./PrefabMeshParser";
+import { PrefabTextureParser } from "./PrefabTextureParser";
+import { LitSSSShader } from "./mats/shader/LitSSSShader";
+import { LitShader } from "./mats/shader/LitShader";
+import { PrefabNode } from "./prefabData/PrefabNode";
+LitShader;
+LitSSSShader;
+export class PrefabParser extends ParserBase {
+    static { this.useWebp = true; }
+    static { this.format = ParserFormat.BIN; }
+    async parseBuffer(buffer) {
+        this.avatarDic = {};
+        let bytesStream = new BytesArray(buffer, 0);
+        await PrefabTextureParser.parserTexture(bytesStream, this, this.loaderFunctions);
+        PrefabAvatarParser.parser(bytesStream, this);
+        PrefabMeshParser.parserMeshs(bytesStream, this);
+        PrefabMaterialParser.parserMaterial(bytesStream, this);
+        this.nodeData = this.parserPrefabNode(bytesStream);
+        this.data = this.data = this.parserNodeTree(this.nodeData);
+    }
+    parserPrefabNode(bytesStream) {
+        let rootNodeData = PrefabNode.parser(bytesStream);
+        return rootNodeData;
+    }
+    parserNodeTree(nodeData) {
+        let root = new Object3D();
+        root.localPosition = Vector3.serialize(nodeData.position);
+        root.localQuaternion = Quaternion.serialize(nodeData.rotation);
+        root.localScale = Vector3.serialize(nodeData.scale);
+        root.name = nodeData.name;
+        if (nodeData.comDatas) {
+            for (let i = 0; i < nodeData.comDatas.length; i++) {
+                const comData = nodeData.comDatas[i];
+                let com = null;
+                let comClass = GetComponentClass(comData.comName);
+                if (comClass) {
+                    com = root.getOrAddComponent(comClass);
+                    for (let j = 0; j < comData.data.length; j++) {
+                        const kv = comData.data[j];
+                        if (kv.key in com) {
+                            com[kv.key] = kv.getValue();
+                        }
+                    }
+                }
+                else {
+                }
+            }
+        }
+        if (nodeData.child && nodeData.child.length > 0) {
+            for (let j = 0; j < nodeData.child.length; j++) {
+                let child = this.parserNodeTree(nodeData.child[j]);
+                root.addChild(child);
+            }
+        }
+        return root;
+    }
+    verification() {
+        if (this.data) {
+            return true;
+        }
+        throw new Error("verify failed.");
+    }
+}

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

@@ -0,0 +1,12 @@
+export declare class PrefabStringUtil {
+    static getNumber(st: string): number;
+    static getInt(st: string): number;
+    static getBoolean(st: string): boolean;
+    static getNumberArray(st: string): string;
+    static getStringArray(st: string): string[];
+    static getVector2(st: string): void;
+    static getVector3(st: string): void;
+    static getVector4(st: string): void;
+    static getQuaternion(st: string): void;
+    static getColor(st: string): void;
+}

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

@@ -0,0 +1,41 @@
+export class PrefabStringUtil {
+    static getNumber(st) {
+        let v = parseFloat(st);
+        return v;
+    }
+    static getInt(st) {
+        let v = parseInt(st);
+        return v;
+    }
+    static getBoolean(st) {
+        let v = st == "true" ? true : false;
+        return v;
+    }
+    static getNumberArray(st) {
+        let v = st.replaceAll("[", "");
+        v = v.replaceAll("]", "");
+        let list = v.split(",");
+        let ret = [];
+        for (let i = 0; i < list.length; i++) {
+            const element = parseFloat(list[i]);
+            ret.push(element);
+        }
+        return v;
+    }
+    static getStringArray(st) {
+        let v = st.replaceAll("[", "");
+        v = v.replaceAll("]", "");
+        let list = v.split(",");
+        let ret = [];
+        for (let i = 0; i < list.length; i++) {
+            const element = list[i];
+            ret.push(element);
+        }
+        return ret;
+    }
+    static getVector2(st) { }
+    static getVector3(st) { }
+    static getVector4(st) { }
+    static getQuaternion(st) { }
+    static getColor(st) { }
+}

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

@@ -0,0 +1,10 @@
+import { BytesArray } from "../../../util/BytesArray";
+import { LoaderFunctions } from "../../LoaderFunctions";
+import { ParserBase } from "../ParserBase";
+import { ParserFormat } from "../ParserFormat";
+import { PrefabParser } from "./PrefabParser";
+export declare class PrefabTextureParser extends ParserBase {
+    static format: ParserFormat;
+    static parserTexture(bytesStream: BytesArray, prefabParser: PrefabParser, loaderFunctions: LoaderFunctions): Promise<void>;
+    verification(): boolean;
+}

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

@@ -0,0 +1,32 @@
+import { Engine3D } from "../../../Engine3D";
+import { ParserBase } from "../ParserBase";
+import { ParserFormat } from "../ParserFormat";
+import { PrefabParser } from "./PrefabParser";
+export class PrefabTextureParser extends ParserBase {
+    static { this.format = ParserFormat.TEXT; }
+    static async parserTexture(bytesStream, prefabParser, loaderFunctions) {
+        let preTextureCount = bytesStream.readInt32();
+        let textures = [];
+        for (let i = 0; i < preTextureCount; i++) {
+            let texName = bytesStream.readUTF();
+            if (PrefabParser.useWebp) {
+                texName = texName.replace("png", "webp");
+                texName = texName.replace("jpb", "webp");
+                textures.push(prefabParser.baseUrl + `webp\/` + texName);
+            }
+            else {
+                textures.push(prefabParser.baseUrl + texName);
+            }
+        }
+        let textureList = await Engine3D.res.loadBitmapTextures(textures, Engine3D.setting.loader.numConcurrent, loaderFunctions, true);
+        for (const tex of textureList) {
+            Engine3D.res.addTexture(tex.name, tex);
+        }
+    }
+    verification() {
+        if (this.data) {
+            return true;
+        }
+        throw new Error("verify failed.");
+    }
+}

package/dist/src/loader/parser/prefab/mats/MaterialUtilities.d.ts

@@ -0,0 +1,8 @@
+import { Material } from "../../../../materials/Material";
+import { KV } from "../prefabData/KVData";
+import { PrefabTextureData } from "../prefabData/PrefabTextureData";
+export declare class MaterialUtilities {
+    static GetMaterial(shaderName: string): Material;
+    static applyMaterialTexture(mat: Material, textures: PrefabTextureData[]): void;
+    static applyMaterialProperties(mat: Material, properties: KV[]): void;
+}

package/dist/src/loader/parser/prefab/mats/MaterialUtilities.js

@@ -0,0 +1,138 @@
+import { Material } from "../../../../materials/Material";
+import { GetShader } from "../../../../util/SerializeDecoration";
+import { ValueEnumType } from "../prefabData/ValueType";
+export class MaterialUtilities {
+    static GetMaterial(shaderName) {
+        let name = shaderName;
+        let list = name.split("/");
+        name = list[list.length - 1];
+        list = name.split(".");
+        name = list[list.length - 1];
+        let shader = GetShader(name);
+        if (shader) {
+            let material = new Material();
+            material.shader = new shader();
+            return material;
+        }
+        else {
+            throw new Error("not found shader, shader name is " + name);
+        }
+    }
+    static applyMaterialTexture(mat, textures) {
+        for (let ii = 0; ii < textures.length; ii++) {
+            const texInfo = textures[ii];
+            if (texInfo.property in mat) {
+                mat[texInfo.property] = texInfo.texture;
+            }
+            else if (texInfo.property in mat.shader) {
+                mat.shader[texInfo.property] = texInfo.texture;
+            }
+            else {
+                mat.setTexture(texInfo.property, texInfo.texture);
+            }
+        }
+    }
+    static applyMaterialProperties(mat, properties) {
+        for (let ii = 0; ii < properties.length; ii++) {
+            const propertyInfo = properties[ii];
+            const key = propertyInfo.key;
+            switch (propertyInfo.type) {
+                case ValueEnumType.color:
+                case ValueEnumType.color32:
+                    {
+                        let value = propertyInfo.getValue();
+                        if (key in mat) {
+                            mat[key] = value;
+                        }
+                        else if (key in mat.shader) {
+                            mat.shader[key] = value;
+                        }
+                        else {
+                            mat.setUniformColor(key, value);
+                        }
+                    }
+                    break;
+                case ValueEnumType.single:
+                case ValueEnumType.float:
+                case ValueEnumType.int:
+                case ValueEnumType.int16:
+                case ValueEnumType.int32:
+                case ValueEnumType.uint:
+                case ValueEnumType.uint32:
+                case ValueEnumType.uint64:
+                    {
+                        let value = propertyInfo.getValue();
+                        if (key in mat) {
+                            mat[key] = value;
+                        }
+                        else if (key in mat.shader) {
+                            mat.shader[key] = value;
+                        }
+                        else {
+                            mat.setUniformFloat(key, value);
+                        }
+                    }
+                    break;
+                case ValueEnumType.singleArray:
+                    {
+                        let value = propertyInfo.getValue()[0];
+                        if (key in mat) {
+                            mat[key] = value;
+                        }
+                        else if (key in mat.shader) {
+                            mat.shader[key] = value;
+                        }
+                        else {
+                            mat.setUniformFloat(key, value);
+                        }
+                    }
+                    break;
+                case ValueEnumType.vector2:
+                case ValueEnumType.vector2Int:
+                    {
+                        let value = propertyInfo.getValue();
+                        if (key in mat) {
+                            mat[key] = value;
+                        }
+                        else if (key in mat.shader) {
+                            mat.shader[key] = value;
+                        }
+                        else {
+                            mat.setUniformVector2(key, value);
+                        }
+                    }
+                    break;
+                case ValueEnumType.vector3:
+                    {
+                        let value = propertyInfo.getValue();
+                        if (key in mat) {
+                            mat[key] = value;
+                        }
+                        else if (key in mat.shader) {
+                            mat.shader[key] = value;
+                        }
+                        else {
+                            mat.setUniformVector3(key, value);
+                        }
+                    }
+                    break;
+                case ValueEnumType.vector4:
+                    {
+                        let value = propertyInfo.getValue();
+                        if (key in mat) {
+                            mat[key] = value;
+                        }
+                        else if (key in mat.shader) {
+                            mat.shader[key] = value;
+                        }
+                        else {
+                            mat.setUniformVector4(key, value);
+                        }
+                    }
+                    break;
+                default:
+                    break;
+            }
+        }
+    }
+}

package/dist/src/loader/parser/prefab/mats/shader/LitSSSShader.d.ts

@@ -0,0 +1,24 @@
+import { Color } from "../../../../../math/Color";
+import { Vector4 } from "../../../../../math/Vector4";
+import { Shader } from "../../../../../gfx/graphics/webGpu/shader/Shader";
+import { Texture } from "../../../../../gfx/graphics/webGpu/core/texture/Texture";
+export declare class LitSSSShader extends Shader {
+    constructor();
+    setDefault(): void;
+    set _MainTex(value: Texture);
+    set _BumpMap(value: Texture);
+    set _SSSMap(value: Texture);
+    set _MaskTex(value: Texture);
+    set _UVTransform(value: Vector4);
+    set _Metallic(value: number);
+    set _Roughness(value: number);
+    set _MainColor(value: Color);
+    set _AlphaCutoff(value: number);
+    set _DoubleSidedEnable(value: number);
+    set _SkinColor(value: Color);
+    set _SkinPower(value: number);
+    set _SkinColorIns(value: number);
+    set curveFactor(value: number);
+    set _SurfaceType(value: number);
+    set _AlphaCutoffEnable(value: number);
+}