r3-legacy/src/game-lib-d3-look-at.js

/**
 * Entities with LookAt component looks to targetPosition (default up is 0,1,0)
 * @param graphics GameLib.D3.Graphics
 * @param parentObject
 * @param apiLookAt GameLib.D3.API.LookAt
 * @constructor
 */
GameLib.D3.LookAt = function RuntimeLookAt(
    graphics,
    parentObject,
    apiLookAt
) {
    this.graphics = graphics;
    this.graphics.isNotThreeThrow();

    if (GameLib.Utils.UndefinedOrNull(parentObject)) {
        parentObject = null;
    }
    this.parentObject = parentObject;

    GameLib.D3.API.LookAt.call(
        this,
        apiLookAt.id,
        apiLookAt.name,
        apiLookAt.currentComponent,
        apiLookAt.targetComponent,
        apiLookAt.targetPositionOffset,
        apiLookAt.rotationSpeed
    );

    this.targetPositionOffset = new GameLib.Vector3(
        this.graphics,
        this,
        this.targetPositionOffset
    );

    this.lookAtMatrix = new GameLib.Matrix4(
        this.graphics,
        this,
        this.lookAtMatrix
    );

    this.up = new GameLib.Vector3(
        this.graphics,
        this,
        this.up
    );

    this.currentRotation = new GameLib.Quaternion(
        this.graphics,
        this,
        this.currentRotation
    );

    this.targetPosition = new GameLib.Vector3(
        this.graphics,
        this,
        this.targetPosition
    );
};

GameLib.D3.LookAt.prototype = Object.create(GameLib.D3.API.LookAt.prototype);
GameLib.D3.LookAt.prototype.constructor = GameLib.D3.LookAt;

GameLib.D3.LookAt.prototype.toApiComponent = function() {

    var apiLookAt = new GameLib.D3.API.LookAt(
        this.id,
        this.name,
        GameLib.Utils.IdOrNull(this.currentComponent),
        GameLib.Utils.IdOrNull(this.targetComponent),
        this.targetPositionOffset.toApiVector(),
        this.rotationSpeed
    );

    return apiLookAt;
};

GameLib.D3.LookAt.FromObjectComponent = function(graphics, objectComponent) {

    var apiLookAt = new GameLib.D3.API.LookAt(
        objectComponent.id,
        objectComponent.name,
        objectComponent.currentComponent,
        objectComponent.targetComponent,
        objectComponent.targetPositionOffset,
        objectComponent.rotationSpeed
    );

    return new GameLib.D3.LookAt(
        graphics,
        this,
        apiLookAt
    );
};

/**
 * Updates the component
 * @param deltaTime
 */
GameLib.D3.LookAt.prototype.update = function(deltaTime) {

    if (this.currentComponent && this.targetComponent) {

        this.targetPosition.x = this.targetComponent.position.x + this.targetPositionOffset.x;
        this.targetPosition.y = this.targetComponent.position.y + this.targetPositionOffset.y;
        this.targetPosition.z = this.targetComponent.position.z + this.targetPositionOffset.z;

        this.targetPosition.updateInstance();

  //
  //       this.currentComponent.instance.lookAt(this.targetPosition);
  //
  //       this.currentComponent.instance.updateProjectionMatrix();
  //
  // //      this.currentComponent.updateInstance();
  //       return;

        this.lookAtMatrix.lookAt(
            this.currentComponent.position,
            this.targetPosition,
            this.up
        );

        this.currentRotation = new GameLib.Quaternion(this.graphics, this, new GameLib.API.Quaternion());

        this.currentRotation.setFromRotationMatrix(this.lookAtMatrix);

        // var t = deltaTime * this.rotationSpeed;
        // t = t * t * t * (t * (6.0 * t - 15.0) + 10.0);

       // this.currentRotation.slerp(this.currentRotation, t);

        this.currentRotation.normalize();

        this.currentComponent.quaternion.x = this.currentRotation.x;
        this.currentComponent.quaternion.y = this.currentRotation.y;
        this.currentComponent.quaternion.z = this.currentRotation.z;
        this.currentComponent.quaternion.w = this.currentRotation.w;

        this.currentComponent.quaternion.updateInstance();
    }

};