r3-legacy/src/game-lib-d3-rigid-body.js

/**
 * RigidBody Runtime
 * @param physics GameLib.GraphicsRuntime
 * @param apiRigidBody GameLib.D3.API.RigidBody
 * @constructor
 */
GameLib.D3.RigidBody = function (
    physics,
    apiRigidBody
) {

    this.physics = physics;
    this.physics.isNotCannonThrow();

    if (GameLib.Utils.UndefinedOrNull(apiRigidBody)) {
        apiRigidBody = {};
    }

    GameLib.D3.API.RigidBody.call(
        this,
        apiRigidBody.id,
        apiRigidBody.name,
		apiRigidBody.mass,
		apiRigidBody.friction,
		apiRigidBody.position,
		apiRigidBody.quaternion,
		apiRigidBody.velocity,
		apiRigidBody.angularVelocity,
		apiRigidBody.linearDamping,
		apiRigidBody.angularDamping,
		apiRigidBody.allowSleep,
		apiRigidBody.sleepSpeedLimit,
		apiRigidBody.sleepTimeLimit,
		apiRigidBody.collisionFilterGroup,
		apiRigidBody.collisionFilterMask,
		apiRigidBody.fixedRotation,
		apiRigidBody.shapes,
		apiRigidBody.kinematic,
        apiRigidBody.parentMesh,
        apiRigidBody.parentPhysicsWorld,
        apiRigidBody.parentEntity
    );

    this.position = new GameLib.Vector3(
        this.physics,
        this.position,
        this
    );

    this.quaternion = new GameLib.Quaternion(
        this.physics,
        this.quaternion,
        this
    );

    this.velocity = new GameLib.Vector3(
        this.physics,
        this.velocity,
        this
    );

    this.angularVelocity = new GameLib.Vector3(
        this.physics,
        this.angularVelocity,
        this
    );

    this.force = new GameLib.Vector3(
        this.physics
    );

    this.forcePoint = new GameLib.Vector3(
        this.physics
    );

    GameLib.Component.call(
        this,
        {
            'shapes' : [GameLib.D3.Shape],
            'parentMesh' : GameLib.D3.Mesh,
            'parentPhysicsWorld' : GameLib.D3.PhysicsWorld
        }
    );
};

GameLib.D3.RigidBody.prototype = Object.create(GameLib.Component.prototype);
GameLib.D3.RigidBody.prototype.constructor = GameLib.D3.RigidBody;

/**
 *
 * @returns {*}
 */
GameLib.D3.RigidBody.prototype.createInstance = function() {

    this.instance = new CANNON.Body(
        {
			mass : this.mass,
			friction : this.friction,
			position : this.position.instance,
			quaternion : this.quaternion.instance,
			velocity : this.velocity.instance,
			angularVelocity : this.angularVelocity.instance,
			linearDamping : this.linearDamping,
			angularDamping : this.angularDamping,
			allowSleep : this.allowSleep,
			sleepSpeedLimit : this.sleepSpeedLimit,
			sleepTimeLimit : this.sleepTimeLimit,
			collisionFilterGroup : this.collisionFilterGroup,
			collisionFilterMask : this.collisionFilterMask,
			fixedRotation : this.fixedRotation,
			kinematic : this.kinematic
        }
    );

    this.instance.addEventListener(
        "sleepy",
        function() {
            console.log(this.name + " is feeling sleepy...");
        }.bind(this)
    );

    this.instance.addEventListener(
        "sleep",
        function() {
            console.log(this.name + " fell asleep!");
        }.bind(this)
    );

    this.instance.addEventListener(
        "wakeup",
        function() {
            console.log(this.name + " woke up!");
        }.bind(this)
    );

    this.shapes.map(
        function(shape) {

            if (GameLib.Utils.UndefinedOrNull(shape)) {
                throw new Error('no shape');
            }

            if (GameLib.Utils.UndefinedOrNull(shape.instance)) {
                throw new Error('no shape instance');
            }

            this.instance.addShape(shape.instance)

        }.bind(this)
    );

    GameLib.Component.prototype.createInstance.call(this);
};

/**
 *
 */
GameLib.D3.RigidBody.prototype.updateInstance = function() {

	this.instance.mass = this.mass;
	this.instance.friction = this.friction;

	this.instance.position.x = this.position.x;
	this.instance.position.y = this.position.y;
	this.instance.position.z = this.position.z;

    this.quaternion.axis.instance.x = this.quaternion.axis.x;
    this.quaternion.axis.instance.y = this.quaternion.axis.y;
    this.quaternion.axis.instance.z = this.quaternion.axis.z;

	this.instance.quaternion.setFromAxisAngle(
	    this.quaternion.axis.instance,
        this.quaternion.angle
    );

	this.quaternion.x = this.instance.quaternion.x;
	this.quaternion.y = this.instance.quaternion.y;
	this.quaternion.z = this.instance.quaternion.z;
	this.quaternion.w = this.instance.quaternion.w;

	this.parentMesh.position.setFrom(this.position);
    this.parentMesh.quaternion.setFrom(this.quaternion);
    this.parentMesh.updateInstance();

	this.instance.velocity.x = this.velocity.x;
	this.instance.velocity.y = this.velocity.y;
	this.instance.velocity.z = this.velocity.z;

	this.instance.angularVelocity.x = this.angularVelocity.x;
	this.instance.angularVelocity.y = this.angularVelocity.y;
	this.instance.angularVelocity.z = this.angularVelocity.z;

	this.instance.linearDamping = this.linearDamping;
	this.instance.angularDamping = this.angularDamping;
	this.instance.allowSleep = this.allowSleep;
	this.instance.sleepSpeedLimit = this.sleepSpeedLimit;
	this.instance.sleepTimeLimit = this.sleepTimeLimit;
	this.instance.collisionFilterGroup = this.collisionFilterGroup;
	this.instance.collisionFilterMask = this.collisionFilterMask;
	this.instance.fixedRotation = this.fixedRotation;
	this.instance.kinematic = this.kinematic;
};

GameLib.D3.RigidBody.prototype.setFromParentMesh = function() {

    if (!this.parentMesh || !this.parentMesh.instance) {
        console.log('no parent mesh or instance');
    }

    this.instance.position.x = this.parentMesh.position.x;
    this.instance.position.y = this.parentMesh.position.y;
    this.instance.position.z = this.parentMesh.position.z;

    this.instance.quaternion.x = this.parentMesh.quaternion.x;
    this.instance.quaternion.y = this.parentMesh.quaternion.y;
    this.instance.quaternion.z = this.parentMesh.quaternion.z;
    this.instance.quaternion.w = this.parentMesh.quaternion.w;

    // this.updateInstance();

};

/**
 * GameLib.D3.RigidBody to GameLib.D3.API.RigidBody
 * @returns {GameLib.D3.API.RigidBody}
 */
GameLib.D3.RigidBody.prototype.toApiObject = function() {

    var apiRigidBody = new GameLib.D3.API.RigidBody(
        this.id,
        this.name,
		this.mass,
		this.friction,
		this.position.toApiObject(),
		this.quaternion.toApiObject(),
		this.velocity.toApiObject(),
		this.angularVelocity.toApiObject(),
		this.linearDamping,
		this.angularDamping,
		this.allowSleep,
		this.sleepSpeedLimit,
		this.sleepTimeLimit,
		this.collisionFilterGroup,
		this.collisionFilterMask,
		this.fixedRotation,
		this.shapes.map(function(shape){return GameLib.Utils.IdOrNull(shape)}),
		this.kinematic,
        GameLib.Utils.IdOrNull(this.parentMesh),
        GameLib.Utils.IdOrNull(this.parentPhysicsWorld),
        GameLib.Utils.IdOrNull(this.parentEntity)
    );

    return apiRigidBody;
};

/**
 * GameLib.D3.RigidBody from Object RigidBody
 * @param physics
 * @param objectComponent
 * @returns {GameLib.D3.RigidBody}
 * @constructor
 */
GameLib.D3.RigidBody.FromObject = function(physics, objectComponent) {

    var apiRigidBody = GameLib.D3.API.RigidBody.FromObject(objectComponent);

    return new GameLib.D3.RigidBody(
        physics,
        apiRigidBody
    );
};

GameLib.D3.RigidBody.prototype.applyForce = function() {
    this.instance.applyForce(
        this.force.instance,
        this.forcePoint.instance
    )
};


GameLib.D3.RigidBody.prototype.applyLocalForce = function() {
    this.instance.applyLocalForce(
        this.force.instance,
        this.forcePoint.instance
    )
};