@fps-games/editor 0.2.0-beta.3 → 0.2.1-beta.1

package/node_modules/@babylonjs/loaders/BVH/bvhFileLoader.metadata.d.ts

@@ -0,0 +1,8 @@
+export declare const BVHFileLoaderMetadata: {
+    readonly name: "bvh";
+    readonly extensions: {
+        readonly ".bvh": {
+            readonly isBinary: false;
+        };
+    };
+};

package/node_modules/@babylonjs/loaders/BVH/bvhFileLoader.metadata.js

@@ -0,0 +1,7 @@
+export const BVHFileLoaderMetadata = {
+    name: "bvh",
+    extensions: {
+        // eslint-disable-next-line @typescript-eslint/naming-convention
+        ".bvh": { isBinary: false },
+    },
+};

package/node_modules/@babylonjs/loaders/BVH/bvhLoader.d.ts

@@ -0,0 +1,14 @@
+import { Skeleton } from "@babylonjs/core/Bones/skeleton.js";
+import type { Scene } from "@babylonjs/core/scene.js";
+import type { Nullable } from "@babylonjs/core/types.js";
+import type { BVHLoadingOptions } from "./bvhLoadingOptions.js";
+import type { AssetContainer } from "@babylonjs/core/assetContainer.js";
+/**
+ * Reads a BVH file, returns a skeleton
+ * @param text - The BVH file content
+ * @param scene - The scene to add the skeleton to
+ * @param assetContainer - The asset container to add the skeleton to
+ * @param loadingOptions - The loading options
+ * @returns The skeleton
+ */
+export declare function ReadBvh(text: string, scene: Scene, assetContainer: Nullable<AssetContainer>, loadingOptions: BVHLoadingOptions): Skeleton;

package/node_modules/@babylonjs/loaders/BVH/bvhLoader.js

@@ -0,0 +1,328 @@
+import { Animation } from "@babylonjs/core/Animations/animation.js";
+import { Bone } from "@babylonjs/core/Bones/bone.js";
+import { Skeleton } from "@babylonjs/core/Bones/skeleton.js";
+import { Matrix, Quaternion, Vector3 } from "@babylonjs/core/Maths/math.vector.js";
+import { Tools } from "@babylonjs/core/Misc/tools.js";
+const _XPosition = "Xposition";
+const _YPosition = "Yposition";
+const _ZPosition = "Zposition";
+const _XRotation = "Xrotation";
+const _YRotation = "Yrotation";
+const _ZRotation = "Zrotation";
+const _HierarchyNode = "HIERARCHY";
+const _MotionNode = "MOTION";
+class LoaderContext {
+    constructor(skeleton) {
+        this.loopMode = Animation.ANIMATIONLOOPMODE_CYCLE;
+        this.list = [];
+        this.root = CreateBVHNode();
+        this.numFrames = 0;
+        this.frameRate = 0;
+        this.skeleton = skeleton;
+    }
+}
+function CreateBVHNode() {
+    return {
+        name: "",
+        type: "",
+        offset: new Vector3(),
+        channels: [],
+        children: [],
+        frames: [],
+        parent: null,
+    };
+}
+function CreateBVHKeyFrame() {
+    return {
+        frame: 0,
+        position: new Vector3(),
+        rotation: new Quaternion(),
+    };
+}
+/**
+ * Converts the BVH node's offset to a Babylon matrix
+ * @param node - The BVH node to convert
+ * @returns The converted matrix
+ */
+function BoneOffset(node) {
+    const x = node.offset.x;
+    const y = node.offset.y;
+    const z = node.offset.z;
+    return Matrix.Translation(x, y, z);
+}
+/**
+ * Creates animations for the BVH node
+ * @param node - The BVH node to create animations for
+ * @param context - The loader context
+ * @returns The created animations
+ */
+function CreateAnimations(node, context) {
+    if (node.frames.length === 0) {
+        return [];
+    }
+    const animations = [];
+    // Create position animation if there are position channels
+    const hasPosition = node.channels.some((c) => c === _XPosition || c === _YPosition || c === _ZPosition);
+    // Create rotation animation if there are rotation channels
+    const hasRotation = node.channels.some((c) => c === _XRotation || c === _YRotation || c === _ZRotation);
+    const posAnim = new Animation(`${node.name}_pos`, "position", context.frameRate, Animation.ANIMATIONTYPE_VECTOR3, context.loopMode);
+    const rotAnim = new Animation(`${node.name}_rot`, "rotationQuaternion", context.frameRate, Animation.ANIMATIONTYPE_QUATERNION, context.loopMode);
+    const posKeys = [];
+    const rotKeys = [];
+    for (let i = 0; i < node.frames.length; i++) {
+        const frame = node.frames[i];
+        if (hasPosition && frame.position) {
+            posKeys.push({
+                frame: frame.frame,
+                value: frame.position.clone(),
+            });
+        }
+        if (hasRotation) {
+            rotKeys.push({
+                frame: frame.frame,
+                value: frame.rotation.clone(),
+            });
+        }
+    }
+    if (posKeys.length > 0) {
+        posAnim.setKeys(posKeys);
+        animations.push(posAnim);
+    }
+    if (rotKeys.length > 0) {
+        rotAnim.setKeys(rotKeys);
+        animations.push(rotAnim);
+    }
+    return animations;
+}
+/**
+ * Converts a BVH node to a Babylon bone
+ * @param node - The BVH node to convert
+ * @param parent - The parent bone
+ * @param context - The loader context
+ */
+function ConvertNode(node, parent, context) {
+    const matrix = BoneOffset(node);
+    const bone = new Bone(node.name, context.skeleton, parent, matrix);
+    // Create animation for this bone
+    const animations = CreateAnimations(node, context);
+    for (const animation of animations) {
+        if (animation.getKeys() && animation.getKeys().length > 0) {
+            bone.animations.push(animation);
+        }
+    }
+    for (const child of node.children) {
+        ConvertNode(child, bone, context);
+    }
+}
+/**
+ * Recursively reads data from a single frame into the bone hierarchy.
+ * The bone hierarchy has to be structured in the same order as the BVH file.
+ * keyframe data is stored in bone.frames.
+ * @param data - splitted string array (frame values), values are shift()ed
+ * @param frameNumber - playback time for this keyframe
+ * @param bone - the bone to read frame data from
+ * @param tokenIndex - the index of the token to read
+ */
+function ReadFrameData(data, frameNumber, bone, tokenIndex) {
+    if (bone.type === "ENDSITE") {
+        // end sites have no motion data
+        return;
+    }
+    // add keyframe
+    const keyframe = CreateBVHKeyFrame();
+    keyframe.frame = frameNumber;
+    keyframe.position = new Vector3();
+    keyframe.rotation = new Quaternion();
+    bone.frames.push(keyframe);
+    let combinedRotation = Matrix.Identity();
+    // parse values for each channel in node
+    for (let i = 0; i < bone.channels.length; ++i) {
+        const channel = bone.channels[i];
+        const value = data[tokenIndex.i++];
+        if (!value) {
+            continue;
+        }
+        const parsedValue = parseFloat(value.trim());
+        if (channel.endsWith("position")) {
+            switch (channel) {
+                case _XPosition:
+                    keyframe.position.x = parsedValue;
+                    break;
+                case _YPosition:
+                    keyframe.position.y = parsedValue;
+                    break;
+                case _ZPosition:
+                    keyframe.position.z = parsedValue;
+                    break;
+            }
+        }
+        else if (channel.endsWith("rotation")) {
+            const angle = Tools.ToRadians(parsedValue);
+            let rotationMatrix;
+            switch (channel) {
+                case _XRotation:
+                    rotationMatrix = Matrix.RotationX(angle);
+                    break;
+                case _YRotation:
+                    rotationMatrix = Matrix.RotationY(angle);
+                    break;
+                case _ZRotation:
+                    rotationMatrix = Matrix.RotationZ(angle);
+                    break;
+            }
+            combinedRotation = rotationMatrix.multiply(combinedRotation);
+        }
+    }
+    Quaternion.FromRotationMatrixToRef(combinedRotation, keyframe.rotation);
+    // parse child nodes
+    for (const child of bone.children) {
+        ReadFrameData(data, frameNumber, child, tokenIndex);
+    }
+}
+/**
+ * Recursively parses the HIERARCHY section of the BVH file
+ * @param lines - all lines of the file. lines are consumed as we go along
+ * @param firstLine - line containing the node type and name e.g. "JOINT hip"
+ * @param parent - the parent node for hierarchy
+ * @param context - the loader context containing the list of nodes and other data
+ * @returns a BVH node including children
+ */
+function ReadNode(lines, firstLine, parent, context) {
+    const node = CreateBVHNode();
+    node.parent = parent;
+    context.list.push(node);
+    // parse node type and name.
+    let tokens = firstLine.trim().split(/\s+/);
+    if (tokens[0].toUpperCase() === "END" && tokens[1].toUpperCase() === "SITE") {
+        node.type = "ENDSITE";
+        node.name = "ENDSITE"; // bvh end sites have no name
+    }
+    else {
+        node.name = tokens[1];
+        node.type = tokens[0].toUpperCase();
+    }
+    // opening bracket
+    if (lines.shift()?.trim() != "{") {
+        throw new Error("Expected opening { after type & name");
+    }
+    // parse OFFSET
+    const tokensSplit = lines.shift()?.trim().split(/\s+/);
+    if (!tokensSplit) {
+        throw new Error("Unexpected end of file: missing OFFSET");
+    }
+    tokens = tokensSplit;
+    if (tokens[0].toUpperCase() != "OFFSET") {
+        throw new Error("Expected OFFSET, but got: " + tokens[0]);
+    }
+    if (tokens.length != 4) {
+        throw new Error("OFFSET: Invalid number of values");
+    }
+    const offset = new Vector3(parseFloat(tokens[1]), parseFloat(tokens[2]), parseFloat(tokens[3]));
+    if (isNaN(offset.x) || isNaN(offset.y) || isNaN(offset.z)) {
+        throw new Error("OFFSET: Invalid values");
+    }
+    node.offset = offset;
+    // parse CHANNELS definitions
+    if (node.type != "ENDSITE") {
+        tokens = lines.shift()?.trim().split(/\s+/);
+        if (!tokens) {
+            throw new Error("Unexpected end of file: missing CHANNELS");
+        }
+        if (tokens[0].toUpperCase() != "CHANNELS") {
+            throw new Error("Expected CHANNELS definition");
+        }
+        const numChannels = parseInt(tokens[1]);
+        // Skip CHANNELS and the number of channels
+        node.channels = tokens.splice(2, numChannels);
+        node.children = [];
+    }
+    // read children
+    while (lines.length > 0) {
+        const line = lines.shift()?.trim();
+        if (line === "}") {
+            // Finish reading the node
+            return node;
+        }
+        else if (line) {
+            node.children.push(ReadNode(lines, line, node, context));
+        }
+    }
+    throw new Error("Unexpected end of file: missing closing brace");
+}
+/**
+ * Reads a BVH file, returns a skeleton
+ * @param text - The BVH file content
+ * @param scene - The scene to add the skeleton to
+ * @param assetContainer - The asset container to add the skeleton to
+ * @param loadingOptions - The loading options
+ * @returns The skeleton
+ */
+export function ReadBvh(text, scene, assetContainer, loadingOptions) {
+    const lines = text.split("\n");
+    const { loopMode } = loadingOptions;
+    scene._blockEntityCollection = !!assetContainer;
+    const skeleton = new Skeleton("", "", scene);
+    skeleton._parentContainer = assetContainer;
+    scene._blockEntityCollection = false;
+    const context = new LoaderContext(skeleton);
+    context.loopMode = loopMode;
+    // read model structure
+    const firstLine = lines.shift();
+    if (!firstLine || firstLine.trim().toUpperCase() !== _HierarchyNode) {
+        throw new Error("HIERARCHY expected");
+    }
+    const nodeLine = lines.shift();
+    if (!nodeLine) {
+        throw new Error("Unexpected end of file after HIERARCHY");
+    }
+    const root = ReadNode(lines, nodeLine.trim(), null, context);
+    // read motion data
+    const motionLine = lines.shift();
+    if (!motionLine || motionLine.trim().toUpperCase() !== _MotionNode) {
+        throw new Error("MOTION expected");
+    }
+    const framesLine = lines.shift();
+    if (!framesLine) {
+        throw new Error("Unexpected end of file before frame count");
+    }
+    const framesTokens = framesLine.trim().split(/[\s]+/);
+    if (framesTokens.length < 2) {
+        throw new Error("Invalid frame count line");
+    }
+    // number of frames
+    const numFrames = parseInt(framesTokens[1]);
+    if (isNaN(numFrames)) {
+        throw new Error("Failed to read number of frames.");
+    }
+    context.numFrames = numFrames;
+    // frame time
+    const frameTimeLine = lines.shift();
+    if (!frameTimeLine) {
+        throw new Error("Unexpected end of file before frame time");
+    }
+    const frameTimeTokens = frameTimeLine.trim().split(/[\s]+/);
+    if (frameTimeTokens.length < 3) {
+        throw new Error("Invalid frame time line");
+    }
+    const frameTime = parseFloat(frameTimeTokens[2]);
+    if (isNaN(frameTime)) {
+        throw new Error("Failed to read frame time.");
+    }
+    if (frameTime <= 0) {
+        throw new Error("Failed to read frame time. Invalid value " + frameTime);
+    }
+    context.frameRate = 1 / frameTime;
+    // read frame data line by line
+    for (let i = 0; i < numFrames; ++i) {
+        const frameLine = lines.shift();
+        if (!frameLine) {
+            continue;
+        }
+        const tokens = frameLine.trim().split(/[\s]+/) || [];
+        ReadFrameData(tokens, i, root, { i: 0 });
+    }
+    context.root = root;
+    ConvertNode(context.root, null, context);
+    context.skeleton.returnToRest();
+    return context.skeleton;
+}

package/node_modules/@babylonjs/loaders/BVH/bvhLoadingOptions.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Options for loading BVH files
+ */
+export type BVHLoadingOptions = {
+    /**
+     * Defines the loop mode of the animation to load.
+     */
+    loopMode: number;
+};

package/node_modules/@babylonjs/loaders/BVH/bvhLoadingOptions.js

@@ -0,0 +1 @@
+export {};

package/node_modules/@babylonjs/loaders/BVH/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./bvhLoader.js";
+export * from "./bvhFileLoader.js";

package/node_modules/@babylonjs/loaders/BVH/index.js

@@ -0,0 +1,3 @@
+/* eslint-disable @typescript-eslint/no-restricted-imports */
+export * from "./bvhLoader.js";
+export * from "./bvhFileLoader.js";

package/node_modules/@babylonjs/loaders/OBJ/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./mtlFileLoader.js";
+export * from "./objLoadingOptions.js";
+export * from "./solidParser.js";
+export * from "./objFileLoader.js";

package/node_modules/@babylonjs/loaders/OBJ/index.js

@@ -0,0 +1,4 @@
+export * from "./mtlFileLoader.js";
+export * from "./objLoadingOptions.js";
+export * from "./solidParser.js";
+export * from "./objFileLoader.js";

package/node_modules/@babylonjs/loaders/OBJ/mtlFileLoader.d.ts

@@ -0,0 +1,41 @@
+import type { Nullable } from "@babylonjs/core/types.js";
+import { StandardMaterial } from "@babylonjs/core/Materials/standardMaterial.js";
+import type { Scene } from "@babylonjs/core/scene.js";
+import type { AssetContainer } from "@babylonjs/core/assetContainer.js";
+/**
+ * Class reading and parsing the MTL file bundled with the obj file.
+ */
+export declare class MTLFileLoader {
+    /**
+     * Invert Y-Axis of referenced textures on load
+     */
+    static INVERT_TEXTURE_Y: boolean;
+    /**
+     * All material loaded from the mtl will be set here
+     */
+    materials: StandardMaterial[];
+    /**
+     * This function will read the mtl file and create each material described inside
+     * This function could be improve by adding :
+     * -some component missing (Ni, Tf...)
+     * -including the specific options available
+     *
+     * @param scene defines the scene the material will be created in
+     * @param data defines the mtl data to parse
+     * @param rootUrl defines the rooturl to use in order to load relative dependencies
+     * @param assetContainer defines the asset container to store the material in (can be null)
+     */
+    parseMTL(scene: Scene, data: string | ArrayBuffer, rootUrl: string, assetContainer: Nullable<AssetContainer>): void;
+    /**
+     * Gets the texture for the material.
+     *
+     * If the material is imported from input file,
+     * We sanitize the url to ensure it takes the texture from aside the material.
+     *
+     * @param rootUrl The root url to load from
+     * @param value The value stored in the mtl
+     * @param scene
+     * @returns The Texture
+     */
+    private static _GetTexture;
+}

package/node_modules/@babylonjs/loaders/OBJ/mtlFileLoader.js

@@ -0,0 +1,230 @@
+import { Color3 } from "@babylonjs/core/Maths/math.color.js";
+import { Texture } from "@babylonjs/core/Materials/Textures/texture.js";
+import { StandardMaterial } from "@babylonjs/core/Materials/standardMaterial.js";
+/**
+ * Class reading and parsing the MTL file bundled with the obj file.
+ */
+export class MTLFileLoader {
+    constructor() {
+        /**
+         * All material loaded from the mtl will be set here
+         */
+        this.materials = [];
+    }
+    /**
+     * This function will read the mtl file and create each material described inside
+     * This function could be improve by adding :
+     * -some component missing (Ni, Tf...)
+     * -including the specific options available
+     *
+     * @param scene defines the scene the material will be created in
+     * @param data defines the mtl data to parse
+     * @param rootUrl defines the rooturl to use in order to load relative dependencies
+     * @param assetContainer defines the asset container to store the material in (can be null)
+     */
+    parseMTL(scene, data, rootUrl, assetContainer) {
+        if (data instanceof ArrayBuffer) {
+            return;
+        }
+        //Split the lines from the file
+        const lines = data.split("\n");
+        // whitespace char ie: [ \t\r\n\f]
+        const delimiterPattern = /\s+/;
+        //Array with RGB colors
+        let color;
+        //New material
+        let material = null;
+        //Look at each line
+        for (let i = 0; i < lines.length; i++) {
+            const line = lines[i].trim();
+            // Blank line or comment
+            if (line.length === 0 || line.charAt(0) === "#") {
+                continue;
+            }
+            //Get the first parameter (keyword)
+            const pos = line.indexOf(" ");
+            let key = pos >= 0 ? line.substring(0, pos) : line;
+            key = key.toLowerCase();
+            //Get the data following the key
+            const value = pos >= 0 ? line.substring(pos + 1).trim() : "";
+            //This mtl keyword will create the new material
+            if (key === "newmtl") {
+                //Check if it is the first material.
+                // Materials specifications are described after this keyword.
+                if (material) {
+                    //Add the previous material in the material array.
+                    this.materials.push(material);
+                }
+                //Create a new material.
+                // value is the name of the material read in the mtl file
+                scene._blockEntityCollection = !!assetContainer;
+                material = new StandardMaterial(value, scene);
+                material._parentContainer = assetContainer;
+                scene._blockEntityCollection = false;
+            }
+            else if (key === "kd" && material) {
+                // Diffuse color (color under white light) using RGB values
+                //value  = "r g b"
+                color = value.split(delimiterPattern, 3).map(parseFloat);
+                //color = [r,g,b]
+                //Set tghe color into the material
+                material.diffuseColor = Color3.FromArray(color);
+            }
+            else if (key === "ka" && material) {
+                // Ambient color (color under shadow) using RGB values
+                //value = "r g b"
+                color = value.split(delimiterPattern, 3).map(parseFloat);
+                //color = [r,g,b]
+                //Set tghe color into the material
+                material.ambientColor = Color3.FromArray(color);
+            }
+            else if (key === "ks" && material) {
+                // Specular color (color when light is reflected from shiny surface) using RGB values
+                //value = "r g b"
+                color = value.split(delimiterPattern, 3).map(parseFloat);
+                //color = [r,g,b]
+                //Set the color into the material
+                material.specularColor = Color3.FromArray(color);
+            }
+            else if (key === "ke" && material) {
+                // Emissive color using RGB values
+                color = value.split(delimiterPattern, 3).map(parseFloat);
+                material.emissiveColor = Color3.FromArray(color);
+            }
+            else if (key === "ns" && material) {
+                //value = "Integer"
+                material.specularPower = parseFloat(value);
+            }
+            else if (key === "d" && material) {
+                //d is dissolve for current material. It mean alpha for BABYLON
+                material.alpha = parseFloat(value);
+                //Texture
+                //This part can be improved by adding the possible options of texture
+            }
+            else if (key === "map_ka" && material) {
+                // ambient texture map with a loaded image
+                //We must first get the folder of the image
+                material.ambientTexture = MTLFileLoader._GetTexture(rootUrl, value, scene);
+            }
+            else if (key === "map_kd" && material) {
+                // Diffuse texture map with a loaded image
+                material.diffuseTexture = MTLFileLoader._GetTexture(rootUrl, value, scene);
+            }
+            else if (key === "map_ks" && material) {
+                // Specular texture map with a loaded image
+                //We must first get the folder of the image
+                material.specularTexture = MTLFileLoader._GetTexture(rootUrl, value, scene);
+            }
+            else if (key === "map_ns") {
+                //Specular
+                //Specular highlight component
+                //We must first get the folder of the image
+                //
+                //Not supported by BABYLON
+                //
+                //    continue;
+            }
+            else if (key === "map_bump" && material) {
+                //The bump texture
+                const values = value.split(delimiterPattern);
+                const bumpMultiplierIndex = values.indexOf("-bm");
+                let bumpMultiplier = null;
+                if (bumpMultiplierIndex >= 0) {
+                    bumpMultiplier = values[bumpMultiplierIndex + 1];
+                    values.splice(bumpMultiplierIndex, 2); // remove
+                }
+                material.bumpTexture = MTLFileLoader._GetTexture(rootUrl, values.join(" "), scene);
+                if (material.bumpTexture && bumpMultiplier !== null) {
+                    material.bumpTexture.level = parseFloat(bumpMultiplier);
+                }
+            }
+            else if (key === "map_d" && material) {
+                // The dissolve of the material
+                material.opacityTexture = MTLFileLoader._GetTexture(rootUrl, value, scene);
+                //Options for illumination
+            }
+            else if (key === "illum") {
+                //Illumination
+                if (value === "0") {
+                    //That mean Kd == Kd
+                }
+                else if (value === "1") {
+                    //Color on and Ambient on
+                }
+                else if (value === "2") {
+                    //Highlight on
+                }
+                else if (value === "3") {
+                    //Reflection on and Ray trace on
+                }
+                else if (value === "4") {
+                    //Transparency: Glass on, Reflection: Ray trace on
+                }
+                else if (value === "5") {
+                    //Reflection: Fresnel on and Ray trace on
+                }
+                else if (value === "6") {
+                    //Transparency: Refraction on, Reflection: Fresnel off and Ray trace on
+                }
+                else if (value === "7") {
+                    //Transparency: Refraction on, Reflection: Fresnel on and Ray trace on
+                }
+                else if (value === "8") {
+                    //Reflection on and Ray trace off
+                }
+                else if (value === "9") {
+                    //Transparency: Glass on, Reflection: Ray trace off
+                }
+                else if (value === "10") {
+                    //Casts shadows onto invisible surfaces
+                }
+            }
+            else {
+                // console.log("Unhandled expression at line : " + i +'\n' + "with value : " + line);
+            }
+        }
+        //At the end of the file, add the last material
+        if (material) {
+            this.materials.push(material);
+        }
+    }
+    /**
+     * Gets the texture for the material.
+     *
+     * If the material is imported from input file,
+     * We sanitize the url to ensure it takes the texture from aside the material.
+     *
+     * @param rootUrl The root url to load from
+     * @param value The value stored in the mtl
+     * @param scene
+     * @returns The Texture
+     */
+    static _GetTexture(rootUrl, value, scene) {
+        if (!value) {
+            return null;
+        }
+        let url = rootUrl;
+        // Load from input file.
+        if (rootUrl === "file:") {
+            let lastDelimiter = value.lastIndexOf("\\");
+            if (lastDelimiter === -1) {
+                lastDelimiter = value.lastIndexOf("/");
+            }
+            if (lastDelimiter > -1) {
+                url += value.substring(lastDelimiter + 1);
+            }
+            else {
+                url += value;
+            }
+        }
+        // Not from input file.
+        else {
+            url += value;
+        }
+        return new Texture(url, scene, false, MTLFileLoader.INVERT_TEXTURE_Y);
+    }
+}
+/**
+ * Invert Y-Axis of referenced textures on load
+ */
+MTLFileLoader.INVERT_TEXTURE_Y = true;