physics.js

var collisionDelta = 0.01;
var mainObjectBox = 0;
var intersectsPoint = function (point, boundingInfo, delta) {

    if (boundingInfo.maximumWorld.x - point.x < delta || delta > point.x - boundingInfo.minimumWorld.x)
        return false;

    if (boundingInfo.maximumWorld.y - point.y < delta || delta > point.y - boundingInfo.minimumWorld.y)
        return false;

    if (boundingInfo.maximumWorld.z - point.z < delta || delta > point.z - boundingInfo.minimumWorld.z)
        return false;

    return true;
};


var CreatePhysicsScene = function (engine, scene, catMesh) {
    var camera = new BABYLON.FreeCamera("Camera", new BABYLON.Vector3(0, 25, -50), scene);
    camera.checkCollisions = true;
    camera.applyGravity = true;

    var light = new BABYLON.DirectionalLight("dir02", new BABYLON.Vector3(0.2, -1, 0), scene);
    light.position = new BABYLON.Vector3(0, 80, 0);

    // Material
    var materialAmiga = new BABYLON.StandardMaterial("amiga", scene);
    materialAmiga.diffuseTexture = new BABYLON.Texture("assets/amiga.jpg", scene);
    materialAmiga.emissiveColor = new BABYLON.Color3(0.5, 0.5, 0.5);
    materialAmiga.diffuseTexture.uScale = 5;
    materialAmiga.diffuseTexture.vScale = 5;

    var materialAmiga2 = new BABYLON.StandardMaterial("amiga", scene);
    materialAmiga2.diffuseTexture = new BABYLON.Texture("assets/mosaic.jpg", scene);
    materialAmiga2.emissiveColor = new BABYLON.Color3(0.5, 0.5, 0.5);

    // Shadows
    var shadowGenerator = new BABYLON.ShadowGenerator(2048, light);
  //  shadowGenerator.getShadowMap().renderList.push(box0);

    // Physics
    scene.enablePhysics();

    var mainBoxLine = [];
    var mainBoxLineIntersection = [];
    var MAIN_BOX_LINE_AMOUNT = 10;

    for (var i = 0; i < MAIN_BOX_LINE_AMOUNT; ++i) {
        var box0 = BABYLON.Mesh.CreateBox("Box" + i, 3, scene);
        box0.position = new BABYLON.Vector3(-10 + i * 3, 0, 0);
        var materialWood = new BABYLON.StandardMaterial("wood", scene);
        materialWood.diffuseTexture = new BABYLON.Texture("assets/wood.jpg", scene);
        materialWood.emissiveColor = new BABYLON.Color3(0.5, 0.5, 0.5);
        box0.material = materialWood;

        shadowGenerator.getShadowMap().renderList.push(box0);
        mainBoxLine.push(box0);
    }

    for (var i = 0; i < MAIN_BOX_LINE_AMOUNT + 1; ++i) {
        mainBoxLineIntersection[i] = new Array(MAIN_BOX_LINE_AMOUNT + 1);
    }

    for (var i = 0; i < MAIN_BOX_LINE_AMOUNT + 1; ++i) {
        for (var j = 0; j < MAIN_BOX_LINE_AMOUNT + 1; ++j) {
            mainBoxLineIntersection[i][j] = false;
        }
    }

    var mainBox = null;

    var mainBox = BABYLON.Mesh.CreateBox("Box", 3, scene);
    //var mainBox = catMesh;
    mainBox.position = new BABYLON.Vector3(0, 0, -25);
    var materialWood = new BABYLON.StandardMaterial("wood", scene);
    materialWood.diffuseTexture = new BABYLON.Texture("assets/wood.jpg", scene);
    materialWood.emissiveColor = new BABYLON.Color3(0.5, 0.0, 0.5);
    mainBox.material = materialWood;

    shadowGenerator.getShadowMap().renderList.push(mainBox);

    // Playground
    var ground = BABYLON.Mesh.CreateBox("Ground", 1, scene);
    ground.scaling = new BABYLON.Vector3(100, 1, 100);
    ground.position.y = -5.0;
    ground.checkCollisions = true;

    var border0 = BABYLON.Mesh.CreateBox("border0", 1, scene);
    border0.scaling = new BABYLON.Vector3(1, 100, 100);
    border0.position.y = -5.0;
    border0.position.x = -50.0;
    border0.checkCollisions = true;

    var border1 = BABYLON.Mesh.CreateBox("border1", 1, scene);
    border1.scaling = new BABYLON.Vector3(1, 100, 100);
    border1.position.y = -5.0;
    border1.position.x = 50.0;
    border1.checkCollisions = true;

    var border2 = BABYLON.Mesh.CreateBox("border2", 1, scene);
    border2.scaling = new BABYLON.Vector3(100, 100, 1);
    border2.position.y = -5.0;
    border2.position.z = 50.0;
    border2.checkCollisions = true;

    var border3 = BABYLON.Mesh.CreateBox("border3", 1, scene);
    border3.scaling = new BABYLON.Vector3(100, 100, 1);
    border3.position.y = -5.0;
    border3.position.z = -50.0;
    border3.checkCollisions = true;

    camera.setTarget(new BABYLON.Vector3(0, 0, 0));

    var groundMat = new BABYLON.StandardMaterial("groundMat", scene);
    groundMat.diffuseColor = new BABYLON.Color3(0.5, 0.5, 0.5);
    groundMat.emissiveColor = new BABYLON.Color3(0.2, 0.2, 0.2);
    ground.material = groundMat;
    border0.material = groundMat;
    border1.material = groundMat;
    border2.material = groundMat;
    border3.material = groundMat;
    ground.receiveShadows = true;

    // Physics
    for (var i = 0; i < MAIN_BOX_LINE_AMOUNT; ++i) {
        mainBoxLine[i].setPhysicsState({ impostor: BABYLON.PhysicsEngine.BoxImpostor, mass: 2, friction: 0.4, restitution: 0.3 });
    }

    mainBoxLine.push(mainBox);


    var amplitude = 100;
    var impX = 0.1;
    var impY = 1;
    var impZ = 0;
    mainBox.setPhysicsState({ impostor: BABYLON.PhysicsEngine.BoxImpostor, mass: 5, friction: 0.4, restitution: 0.3 });

    mainObjectBox = mainBox;

    console.log("main box");
    console.log(mainBox);
    mainBox.checkCollisions = true;

    ground.setPhysicsState({ impostor: BABYLON.PhysicsEngine.BoxImpostor, mass: 0, friction: 0.5, restitution: 0.7 });
    border0.setPhysicsState({ impostor: BABYLON.PhysicsEngine.BoxImpostor, mass: 0 });
    border1.setPhysicsState({ impostor: BABYLON.PhysicsEngine.BoxImpostor, mass: 0 });
    border2.setPhysicsState({ impostor: BABYLON.PhysicsEngine.BoxImpostor, mass: 0 });
    border3.setPhysicsState({ impostor: BABYLON.PhysicsEngine.BoxImpostor, mass: 0 });

    var boxSounds = [];
    var floorSounds = [];

    for (m = 0; m < 100; ++m) {
        boxSounds[m] = new Audio("audio/boxSound.wav");
        floorSounds[m] = new Audio("audio/floorSound.wav");
    }

    var playSound = function(soundType) {

        if (!soundType) {
            for (k = 0; k < boxSounds.length; ++k) {
                    if (boxSounds[k].ended || boxSounds[k].currentTime == 0) {
                        boxSounds[k].play();
                        break;
                    }
            }
        } else {
            for (k = 0; k < floorSounds.length; ++k) {
                    if (floorSounds[k].ended || floorSounds[k].currentTime == 0) {
                        floorSounds[k].play();
                        break;
                    }
            }
        }
    }

    var flag = false;
    var interCounter = 0;

    mainBox.playGroundIntersectionMatrix = [[],[],[],[],[]];

    for (var i = 0; i < MAIN_BOX_LINE_AMOUNT; ++i) {
        mainBoxLine[i].playGroundIntersectionMatrix = [[],[],[],[],[]];
    }

    var contains = function(arr, point) {
        //console.log(arr);
        for (var i = 0; i < arr.length; ++i) {
            var arrayPoint = arr[i];
            var arrX = arrayPoint.x;
            var arrY = arrayPoint.y;
            var arrZ = arrayPoint.z;

            var px = point.x;
            var py = point.y;
            var pz = point.z;

            var dX = Math.abs(arrX - px);
            var dY = Math.abs(arrY - py);
            var dZ = Math.abs(arrZ - pz);
            var delta = Math.sqrt(dX * dX + dY * dY + dZ * dZ);
            var eps = 0.01;

            if (delta < eps) {
                arr[i] = point;
                return true;
            } else {
                /*console.log(point);
                console.log(arrayPoint);
                */
                //console.log("huy");
            }
        }
        //console.log("returning false");
        return false;
    };

    var intersectsWith = function(border, object, index) {
        var result = false;

        var localArray = [];
        for (var i = 0; i < 8; ++i) {
            var point = object._boundingInfo.boundingBox.vectorsWorld[i];
            //console.log(border._boundingInfo.boundingBox);
            if (intersectsPoint(point, border._boundingInfo.boundingBox, collisionDelta)) {
                point = object._boundingInfo.boundingBox.vectorsWorld[i]
                if (contains(object.playGroundIntersectionMatrix[index], point)) {
                    //console.log("true");
                } else {
                    //console.log("contains returns false");
                    object.playGroundIntersectionMatrix[index].push(point);
                    result = true;
                }
                localArray.push(point);
            }
        }

        object.playGroundIntersectionMatrix[index] = localArray;
        return result;
    };

    var checkCollisionWithPlayGround = function(obj) {
        var result = false;

        if (intersectsWith(ground, obj, 0)) {
            result = true;
        }

        if (intersectsWith(border0, obj, 1)) {
            result = true;
        }

        if (intersectsWith(border1, obj, 2)) {
            result = true;
        }

        if (intersectsWith(border2, obj, 3)) {
            result = true;
        }

        if (intersectsWith(border3, obj, 4)) {
            result = true;
        }

        return result;
    };

    scene.registerBeforeRender(function () {
        var makeSound = false;
        var makeSound2 = false;
        for (var i = 0; i < MAIN_BOX_LINE_AMOUNT; ++i) {
            for (var j = i + 1; j < MAIN_BOX_LINE_AMOUNT + 1; ++j) {
                var intersect1 = null;
                var intersect2 = null;

                if (i != j) {
                    if (i == MAIN_BOX_LINE_AMOUNT) {
                        intersect1 = mainBox;
                    } else {
                        intersect1 = mainBoxLine[i];
                    }

                    if (j == MAIN_BOX_LINE_AMOUNT) {
                        intersect2 = mainBox;
                    } else {
                        intersect2 = mainBoxLine[j];
                    }

                    if (intersect1.intersectsMesh(intersect2, false)) {
                        if (!mainBoxLineIntersection[i][j]) {
                            mainBoxLineIntersection[i][j] = true;
                            makeSound = true;
                        }
                    } else {
                        if (mainBoxLineIntersection[i][j]) {
                            mainBoxLineIntersection[i][j] = false;
                        }
                    }
                }
            }
        }

        for (var i = 0; i < MAIN_BOX_LINE_AMOUNT; ++i) {
            if (checkCollisionWithPlayGround(mainBoxLine[i])) {
                makeSound2 = true;
            }
        }

        if (checkCollisionWithPlayGround(mainBox)) {
            makeSound2 = true;
        }

        if (makeSound) {
            playSound(false);
        }

        if (makeSound2) {
            playSound(true);
        }

    });

    return scene;
};