asrsn/assets/3dconfigurator/js/loader.js

function BabylonFileLoader(scene, babylonAssetManager, shadowGenerator) {
    // Skybox
    var skybox = BABYLON.Mesh.CreateBox("skyBox", 1000, scene);
    skybox.material = matManager.skyboxMaterial;
    skybox.isPickable = false;
    skybox.freezeWorldMatrix();
    skybox.infiniteDistance = true;
    skybox.parent = root3D;

    // Floor
    var floor = BABYLON.Mesh.CreateGround("floor", g_FloorMaxSize, g_FloorMaxSize, 1, 0, 10, scene);
    floor.material = matManager.floorMaterial;
    floor.receiveShadows = g_VisibleShadow;
    floor.enablePointerMoveEvents = true;
    floor.actionManager = new BABYLON.ActionManager(scene);
    floor.actionManager.registerAction(new BABYLON.ExecuteCodeAction(BABYLON.ActionManager.OnLeftPickTrigger, (evt)=>{
        if (g_sceneMode !== sceneMode.draw) {
            if (currentMesh && currentMesh.ruler && currentMesh.ruler.multiplyPanel.isVisible) return;

            unsetCurrentMesh();
        }
    }));

    shadowGenerator.addShadowCaster(floor);
    floor.freezeWorldMatrix();
    floor.parent = root3D;

    var mountain = BABYLON.Mesh.CreateGround("mountain", 2000, 2000, 1, 0, 10, scene);
    mountain.material = matManager.groundMaterial;
    mountain.receiveShadows = g_VisibleShadow;
    mountain.isPickable = false;
    mountain.position.y = -0.5;
    shadowGenerator.addShadowCaster(mountain);
    mountain.freezeWorldMatrix();
    mountain.parent = root3D;

    // Arrow
    const arrowTask = babylonAssetManager.addMeshTask("arrowTask", "", g_AssetPath + "environment/arrow/", "arrow.babylon");
    arrowTask.onSuccess = function (task) {
        task.loadedMeshes[0].isVisible = false;

        arrows.push(arrowSuccessCallback(task.loadedMeshes[0], 'bottom'));
        arrows.push(arrowSuccessCallback(task.loadedMeshes[0], 'left'));
        arrows.push(arrowSuccessCallback(task.loadedMeshes[0], 'top'));
        arrows.push(arrowSuccessCallback(task.loadedMeshes[0], 'right'));
    }

    // portArrow
    const portArrowTask = babylonAssetManager.addMeshTask("portArrowTask", "", g_AssetPath + "environment/arrow/", "port-arrow.babylon");
    portArrowTask.onSuccess = function (task) {
        arrow_port = task.loadedMeshes[0];
        arrow_port.id = "arrow_port";
        arrow_port.scaling = new BABYLON.Vector3(1, 1, 1);
        arrow_port.position = BABYLON.Vector3.Zero();
        arrow_port.receiveShadows = g_VisibleShadow;
        arrow_port.isPickable = false;
        arrow_port.setEnabled(false);
        arrow_port.renderingGroupId = 1;
        arrow_port.material = matManager.matPortArrow;
        shadowGenerator.addShadowCaster(arrow_port);
        arrow_port.freezeWorldMatrix();
        // arrow_port.doNotSyncBoundingInfo = true;
        arrow_port.cullingStrategy = g_CullingValue;
    }

    // lift preloading
    const liftPreloadingTask = babylonAssetManager.addMeshTask("liftPreloadingTask", "", g_AssetPath + "environment/conveyor/", "lift-preloading.babylon");
    liftPreloadingTask.onSuccess = function (task) {
        lift_preloading = onSuccesItem(task.loadedMeshes[0]);
    }

    // charging station
    const chargingStationTask = babylonAssetManager.addMeshTask("chargingStationTask", "", g_AssetPath + "environment/charger/", "charging-station.babylon");
    chargingStationTask.onSuccess = function (task) {
        carrier_charger = onSuccesItem(task.loadedMeshes[0]);
    }

    // chain conveyor
    const chainConveyorTask = babylonAssetManager.addMeshTask("chainConveyorTask", "", g_AssetPath + "environment/conveyor/", "chain-coveyor.babylon");
    chainConveyorTask.onSuccess = function (task) {
        chain_conveyor = onSuccesItem(task.loadedMeshes[0]);
    }

    // Lift-Rackings
    for (let i = 0; i < liftRackingInfo.length; i++) {
        let liftRackingTask = babylonAssetManager.addMeshTask("liftRackingTask" + i, "", g_AssetPath + "items/", liftRackingInfo[i].name + ".babylon");
        liftRackingTask.onSuccess = function (task) {
            onSuccessCallback(task.loadedMeshes[0], liftRackingInfo[i]);
        }
    }

    // Items
    for (let i = 0; i < itemInfo.length; i++) {
        const loadItemsTask = babylonAssetManager.addMeshTask("loadItemsTask" + i, "", g_AssetPath + "items/", itemInfo[i].name + ".babylon");
        loadItemsTask.onSuccess = (task) => {
            onSuccessCallback(task.loadedMeshes[0], itemInfo[i]);
        }
    }

    // ManualItems
    for (let i = 0; i < manualItemInfo.length; i++) {
        const manualItemTask = babylonAssetManager.addMeshTask("manualItemTask" + i, "", g_AssetPath + "items/", manualItemInfo[i].name + ".babylon");
        manualItemTask.onSuccess = (task) => {
            onSuccessCallback(task.loadedMeshes[0], manualItemInfo[i]);
        }
    }

    babylonAssetManager.load();

    /**
     * Do all the settings for one specific imported mesh
     * @param {BABYLON.Mesh} item 
     */
    function onSuccesItem (item) {
        item.scaling = new BABYLON.Vector3(1, 1, 1);
        item.receiveShadows = g_VisibleShadow;
        shadowGenerator.addShadowCaster(item);
        item.isPickable = false;
        // item.doNotSyncBoundingInfo = true;
        item.cullingStrategy = g_CullingValue;
        item.rotationQuaternion = null;
        item.setEnabled(false);
        item.freezeWorldMatrix();

        const kids = item.getChildren();
        for (let ii = 0; ii < matManager.materials.length; ii++) {
            if (kids.length > 0) {
                for (let i = 0; i < kids.length; i++) {
                    if (kids[i].material.subMaterials && kids[i].material.subMaterials.length !== 0) {
                        for (let mi = 0; mi < kids[i].material.subMaterials.length; mi++) {
                            if (matManager.materials[ii].name === kids[i].material.subMaterials[mi].name) {
                                kids[i].material.subMaterials[mi].dispose();
                                kids[i].material.subMaterials[mi] = matManager.materials[ii];
                            }
                        }
                    }
                }
            }
            else {
                if (item.material.subMaterials && item.material.subMaterials.length !== 0) {
                    for (let mi = 0; mi < item.material.subMaterials.length; mi++) {
                        if (matManager.materials[ii].name === item.material.subMaterials[mi].name) {
                            item.material.subMaterials[mi].dispose();
                            item.material.subMaterials[mi] = matManager.materials[ii];
                        }
                    }
                }
            }
        }

        return item;
    }

    /**
     * Do all the settings for imported mesh
     *
     * @param {BABYLON.Mesh} mesh
     * @param {itemInfo} meshData
     * @param {boolean} debug
     */
    function onSuccessCallback (mesh, meshData, debug = false) {
        var item = mesh;
        item.name = meshData.name;
        item.type = meshData.type;
        item.width = meshData.width;
        item.length = meshData.length;
        item.multiply = meshData.multiply;
        item.direction = meshData.direction;
        item.control = ITEMCONTROL.auto;
        // Set Scale
        item.scaling = new BABYLON.Vector3(1, 1, 1);

        // Set Position
        item.position = BABYLON.Vector3.Zero();

        // Set Rotation
        item.rotation = BABYLON.Vector3.Zero();
        item.rotationQuaternion = null;

        //Add shadow
        item.receiveShadows = g_VisibleShadow;

        item.isPickable = false;

        item.setEnabled(false);

        //Set material
        for (let ii = 0; ii < matManager.materials.length; ii++) {

            if (item.material.subMaterials === undefined) {
                //Single material
                if (matManager.materials[ii].name === item.material.name) {
                    item.material.dispose();
                    item.material = matManager.materials[ii];
                }
            }
            else {
                //Multi material
                for (let mi = 0; mi < item.material.subMaterials.length; mi++) {
                    if (matManager.materials[ii].name === item.material.subMaterials[mi].name) {
                        item.material.subMaterials[mi].dispose();
                        item.material.subMaterials[mi] = matManager.materials[ii];
                    }
                }
            }
        }

        meshData.originMesh = item;
        shadowGenerator.addShadowCaster(item);
        item.freezeWorldMatrix();
        // item.doNotSyncBoundingInfo = true;
        item.cullingStrategy = g_CullingValue;

        if (debug) {
            item.setEnabled(true);
        }

        return item;
    }

    /**
     * 
     * @param {BABYLON.Mesh} mesh 
     * @param {String} name 
     */
    function arrowSuccessCallback (mesh, name) {
        const arrow = mesh.clone();
        arrow.id = "arrow_" + name;
        arrow.position = BABYLON.Vector3.Zero();
        arrow.receiveShadows = g_VisibleShadow;
        arrow.isVisible = true;
        arrow.isPickable = false;
        arrow.scalingDeterminant = 1;
        arrow.setEnabled(false);
        arrow.material = matManager.matArrow;
        shadowGenerator.addShadowCaster(arrow);
        // arrow.doNotSyncBoundingInfo = true;

        switch (name) {
            case 'left':
                arrow.rotation = new BABYLON.Vector3(0, -Math.PI / 2, 0);
                arrow.type = ITEMDIRECTION.left;
                break;
            case 'right':
                arrow.rotation = new BABYLON.Vector3(0, Math.PI / 2, 0);
                arrow.type = ITEMDIRECTION.right;
                break;
            case 'top':
                arrow.rotation = new BABYLON.Vector3(0, 0, 0);
                arrow.type = ITEMDIRECTION.top;
                break;
            case 'bottom':
                arrow.rotation = new BABYLON.Vector3(0, Math.PI, 0);
                arrow.type = ITEMDIRECTION.bottom;
                break;
        }

        arrow.enablePointerMoveEvents = true;
        arrow.actionManager = new BABYLON.ActionManager(scene);
        arrow.actionManager.hoverCursor = "pointer";
        arrow.actionManager.registerAction(new BABYLON.ExecuteCodeAction(BABYLON.ActionManager.OnPointerOverTrigger, ()=>{}));
        arrow.actionManager.registerAction(new BABYLON.ExecuteCodeAction(BABYLON.ActionManager.OnLeftPickTrigger, (evt)=>{
            arrows.forEach((arrow) => {
                arrow.material = matManager.matArrow;
            });
            evt.meshUnderPointer.material = matManager.matArrowSelect;
            if (currentMesh) {
                currentArrow = evt.meshUnderPointer.type;
                previewMultiply(parseInt(currentMesh.ruler.inputNumMultiply.text));
            }
        }));

        return arrow;
    }
}