r3-legacy/src/r3-d3-api-z-object.js

/**
 * R3.D3.Object
 * @param graphics
 * @param apiObject
 * @property objectType
 * @constructor
 */
R3.D3.Object = function (
    graphics,
    apiObject
) {
    this.graphics = graphics;
    this.graphics.isNotThreeThrow();

    if (R3.Utils.UndefinedOrNull(apiObject)) {
        apiObject = {
            objectType: R3.D3.API.Object.OBJECT_TYPE_NONE
        };
    }

	R3.D3.API.Object.call(
        this,
        apiObject.id,
        apiObject.name,
        apiObject.objectType,
        apiObject.parentEntity,
        apiObject.useQuaternion,
        apiObject.position,
        apiObject.quaternion,
        apiObject.rotation,
        apiObject.scale,
        apiObject.up,
        apiObject.lookAt
    );

    this.position = new R3.Vector3(
        this.graphics,
        this.position,
        this
    );

    this.quaternion = new R3.Quaternion(
        this.graphics,
        this.quaternion,
        this
    );

    this.rotation = new R3.Vector3(
        this.graphics,
        this.rotation,
        this
    );

    this.scale = new R3.Vector3(
        this.graphics,
        this.scale,
        this
    );

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

    this.lookAt = new R3.Vector3(
        this.graphics,
        this.lookAt,
        this
    );

    R3.Component.call(
        this,
        R3.D3.Object.GetLinkedObjects(this.objectType)
    );
};

R3.D3.Object.prototype = Object.create(R3.Component.prototype);
R3.D3.Object.prototype.constructor = R3.D3.Object;

/**
 * Get Linked Objects
 * @param objectType
 * @returns {{}}
 * @constructor
 */
R3.D3.Object.GetLinkedObjects = function(objectType) {
    var linkedObjects = {};

    switch (objectType) {
        case R3.D3.API.Object.OBJECT_TYPE_CAMERA_CUBE :
            linkedObjects.renderTarget  = R3.D3.RenderTarget;
            break;
        case R3.D3.API.Object.OBJECT_TYPE_CAMERA_STEREO :
            linkedObjects.effect        = R3.D3.Effect;
            break;
        case R3.D3.API.Object.OBJECT_TYPE_MESH :
            linkedObjects.parentMesh    = R3.D3.Mesh;
            linkedObjects.parentScene   = R3.D3.Scene;
            linkedObjects.materials     = [R3.D3.Material];
            linkedObjects.geometry      = R3.D3.Geometry;
            linkedObjects.skeleton      = R3.D3.Skeleton;
            break;
        default :
            break;
    }

    return linkedObjects;
};

/**
 * Creates a mesh instance or updates it
 */
R3.D3.Object.prototype.createInstance = function() {

    if (!this.instance) {
        this.instance = new THREE.Object3D();
    }

    this.updateInstance('position');

    if (this instanceof R3.D3.Camera) {

        if (
            this.objectType === R3.D3.API.Object.OBJECT_TYPE_CAMERA_PERSPECTIVE ||
            this.objectType === R3.D3.API.Object.OBJECT_TYPE_CAMERA_STEREO
        ) {
            this.updateInstance('lookAt');
        }

    } else {
        /**
         * We ignore 'lookAt' - since it updates the rotation etc.. We assume that after lookAt we have our orientation
         * and store /use these values instead - lookAt is more a 'runtime' thing
         */
        this.updateInstance('rotation');
    }

    this.updateInstance('scale');


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

/**
 * Updates the mesh instance
 */
R3.D3.Object.prototype.updateInstance = function(property) {

    if (R3.Utils.UndefinedOrNull(this.instance)) {
        console.warn('3d object instance not ready');
        return;
    }

    if (property === 'objectType') {
        var componentType = R3.D3.API.Object.GetComponentType(this.objectType);
        this.replace(componentType);
        return;
    }

    if (
        property === 'useQuaternion' ||
        property === 'quaternion' ||
        property === 'rotation'
    ) {
        if (this.useQuaternion) {

            if (R3.Utils.Defined(this.instance.quaternion)) {

                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.x = this.quaternion.x;
                this.instance.quaternion.y = this.quaternion.y;
                this.instance.quaternion.z = this.quaternion.z;
                this.instance.quaternion.w = this.quaternion.w;
                this.instance.quaternion.setFromAxisAngle(
                    this.quaternion.axis.instance,
                    this.quaternion.angle
                );

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

                this.rotation.instance.x = this.rotation.x;
                this.rotation.instance.y = this.rotation.y;
                this.rotation.instance.z = this.rotation.z;
            }

        } else {

            if (R3.Utils.Defined(this.instance.rotation)) {

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

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

                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.quaternion.instance.x = this.quaternion.x;
                this.quaternion.instance.y = this.quaternion.y;
                this.quaternion.instance.z = this.quaternion.z;
                this.quaternion.instance.w = this.quaternion.w;
            }
        }

        // if (!this.instance.matrixAutoUpdate) {
        //     this.instance.updateMatrixWorld();
        //     this.instance.children.map(
        //         function(child){
        //             child.updateMatrixWorld();
        //         }
        //     )
        // }

        if (R3.Utils.Defined(this.instance.updateProjectionMatrix)) {
            this.instance.updateProjectionMatrix();
        }
    }

    if (property === 'position') {

        if (R3.Utils.Defined(this.instance.position)) {

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

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

        if (R3.Utils.Defined(this.instance.updateProjectionMatrix)) {
            this.instance.updateProjectionMatrix();
        }
    }

    if (property === 'scale') {

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

        this.instance.scale.x = this.scale.x;
        this.instance.scale.y = this.scale.y;
        this.instance.scale.z = this.scale.z;
    }

    if (
        property === 'up' ||
        property === 'lookAt'
    ) {

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

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

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

        if (R3.Utils.Defined(this.instance.lookAt)) {
            this.instance.lookAt(this.lookAt.instance);
        }

        if (R3.Utils.Defined(this.instance.updateProjectionMatrix)) {
            this.instance.updateProjectionMatrix();
        }

        R3.D3.Object.prototype.updateFromInstance.call(this, 'rotation');
    }

    R3.Component.prototype.updateInstance.call(this, property);
};

/**
 * Update R3.D3.Object from its instance
 * @param property
 */
R3.D3.Object.prototype.updateFromInstance = function(property) {
    if (
        property === 'rotation' ||
        property === 'quaternion'
    ) {
        this.rotation.x = this.instance.rotation.x;
        this.rotation.y = this.instance.rotation.y;
        this.rotation.z = this.instance.rotation.z;

        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;
    }
};

/**
 * Converts a R3.D3.Object to a R3.D3.API.Object
 * @returns {R3.D3.API.Object}
 */
R3.D3.Object.prototype.toApiObject = function() {

    var apiObject = new R3.D3.API.Object(
        this.id,
        this.name,
        this.objectType,
        R3.Utils.IdOrNull(this.parentEntity),
        this.useQuaternion,
        this.position.toApiObject(),
        this.quaternion.toApiObject(),
        this.rotation.toApiObject(),
        this.scale.toApiObject(),
        this.up.toApiObject(),
        this.lookAt.toApiObject()
    );

    return apiObject;
};

R3.D3.Object.prototype.translate = function(vector3) {

    this.position.x += vector3.x;
    this.position.y += vector3.y;
    this.position.z += vector3.z;

    this.updateInstance('position');
};