TSTransform.cs

using UnityEngine;

namespace TrueSync {

    [ExecuteInEditMode]
    public class TSTransform : MonoBehaviour {

        private const float DELTA_TIME_FACTOR = 10f;

        [SerializeField]
        [HideInInspector]
        [AddTracking]
        private TSVector _position;

        public TSVector position {
            get {
                if (tsCollider != null && tsCollider.Body != null) {
                    return tsCollider.Body.TSPosition - scaledCenter;
                }

                return _position;
            }
            set {
                _position = value;

                if (tsCollider != null && tsCollider.Body != null) {
                    tsCollider.Body.TSPosition = _position + scaledCenter;
                }
            }
        }

        [SerializeField]
        [HideInInspector]
        [AddTracking]
        private TSQuaternion _rotation;

        public TSQuaternion rotation {
            get {
                if (tsCollider != null && tsCollider.Body != null) {
                    return TSQuaternion.CreateFromMatrix(tsCollider.Body.TSOrientation);
                }

                return _rotation;
            }
            set {
                _rotation = value;

                if (tsCollider != null && tsCollider.Body != null) {
                    tsCollider.Body.TSOrientation = TSMatrix.CreateFromQuaternion(_rotation);
                }
            }
        }

        [SerializeField]
        [HideInInspector]
        [AddTracking]
        private TSVector _scale;

        public TSVector scale {
            get {
                return _scale;
            }
            set {
                _scale = value;
            }
        }

        [SerializeField]
        [HideInInspector]
        private bool _serialized;

        private TSVector scaledCenter {
            get {
                if (tsCollider != null) {
                    return tsCollider.ScaledCenter;
                }

                return TSVector.zero;
            }
        }

        public void LookAt(TSTransform other) {
            LookAt(other.position);
        }

        public void LookAt(TSVector target) {
            this.rotation = TSQuaternion.CreateFromMatrix(TSMatrix.CreateFromLookAt(position, target));
        }

        public void Translate(FP x, FP y, FP z) {
            Translate(x, y, z, Space.Self);
        }

        public void Translate(FP x, FP y, FP z, Space relativeTo) {
            Translate(new TSVector(x, y, z), relativeTo);
        }

        public void Translate(FP x, FP y, FP z, TSTransform relativeTo) {
            Translate(new TSVector(x, y, z), relativeTo);
        }

        public void Translate(TSVector translation) {
            Translate(translation, Space.Self);
        }

        public void Translate(TSVector translation, Space relativeTo) {
            if (relativeTo == Space.Self) {
                Translate(translation, this);
            } else {
                this.position += translation;
            }
        }

        public void Translate(TSVector translation, TSTransform relativeTo) {
            this.position += TSVector.Transform(translation, TSMatrix.CreateFromQuaternion(relativeTo.rotation));
        }

        public void RotateAround(TSVector point, TSVector axis, FP angle) {
            TSVector vector = this.position;
            TSVector vector2 = vector - point;
            vector2 = TSVector.Transform(vector2, TSMatrix.AngleAxis(angle * FP.Deg2Rad, axis));
            vector = point + vector2;
            this.position = vector;

            Rotate(axis, angle);
        }

        public void RotateAround(TSVector axis, FP angle) {
            Rotate(axis, angle);
        }

        public void Rotate(FP xAngle, FP yAngle, FP zAngle) {
            Rotate(new TSVector(xAngle, yAngle, zAngle), Space.Self);
        }

        public void Rotate(FP xAngle, FP yAngle, FP zAngle, Space relativeTo) {
            Rotate(new TSVector(xAngle, yAngle, zAngle), relativeTo);
        }

        public void Rotate(TSVector eulerAngles) {
            Rotate(eulerAngles, Space.Self);
        }

        public void Rotate(TSVector axis, FP angle) {
            Rotate(axis, angle, Space.Self);
        }

        public void Rotate(TSVector axis, FP angle, Space relativeTo) {
            TSQuaternion result = TSQuaternion.identity;

            if (relativeTo == Space.Self) {
                result = this.rotation * TSQuaternion.AngleAxis(angle, axis);
            } else {
                result = TSQuaternion.AngleAxis(angle, axis) * this.rotation;
            }

            result.Normalize();
            this.rotation = result;
        }

        public void Rotate(TSVector eulerAngles, Space relativeTo) {
            TSQuaternion result = TSQuaternion.identity;

            if (relativeTo == Space.Self) {
                result = this.rotation * TSQuaternion.Euler(eulerAngles);
            } else {
                result = TSQuaternion.Euler(eulerAngles) * this.rotation;
            }

            result.Normalize();
            this.rotation = result;
        }

        public TSVector forward {
            get {
                return TSVector.Transform(TSVector.forward, TSMatrix.CreateFromQuaternion(rotation));
            }
        }

        public TSVector right {
            get {
                return TSVector.Transform(TSVector.right, TSMatrix.CreateFromQuaternion(rotation));
            }
        }

        public TSVector up {
            get {
                return TSVector.Transform(TSVector.up, TSMatrix.CreateFromQuaternion(rotation));
            }
        }

        public TSVector eulerAngles {
            get {
                return rotation.eulerAngles;
            }
        }

        [HideInInspector]
        public TSCollider tsCollider;

        [HideInInspector]
        public TSTransform tsParent;

        private bool initialized = false;

        private TSRigidBody rb;

        public void Start() {
            if (!Application.isPlaying) {
                return;
            }

            Initialize();
            rb = GetComponent<TSRigidBody> ();
        }

        public void Initialize() {
            if (initialized) {
                return;
            }

            tsCollider = GetComponent<TSCollider>();
            if (transform.parent != null) {
                tsParent = transform.parent.GetComponent<TSTransform>();
            }

            if (!_serialized) {
                UpdateEditMode();
            }

            if (tsCollider != null) {
                if (tsCollider.IsBodyInitialized) {
                    tsCollider.Body.TSPosition = _position + scaledCenter;
                    tsCollider.Body.TSOrientation = TSMatrix.CreateFromQuaternion(_rotation);
                }
            } else {
                StateTracker.AddTracking(this);
            }

            initialized = true;
        }

        public void Update() {
            if (Application.isPlaying) {
                if (initialized) {
                    UpdatePlayMode();
                }
            } else {
                UpdateEditMode();
            }
        }

        private void UpdateEditMode() {
            if (transform.hasChanged) {
                _position = transform.position.ToTSVector();
                _rotation = transform.rotation.ToTSQuaternion();
                _scale = transform.localScale.ToTSVector();

                _serialized = true;
            }
        }

        private void UpdatePlayMode() {
            if (rb != null) {
                if (rb.interpolation == TSRigidBody.InterpolateMode.Interpolate) {
                    transform.position = Vector3.Lerp(transform.position, position.ToVector(), Time.deltaTime * DELTA_TIME_FACTOR);
                    transform.rotation = Quaternion.Lerp(transform.rotation, rotation.ToQuaternion(), Time.deltaTime * DELTA_TIME_FACTOR);
                    transform.localScale = Vector3.Lerp(transform.localScale, scale.ToVector(), Time.deltaTime * DELTA_TIME_FACTOR);
                    return;
                } else if (rb.interpolation == TSRigidBody.InterpolateMode.Extrapolate) {
                    transform.position = (position + rb.tsCollider.Body.TSLinearVelocity * Time.deltaTime * DELTA_TIME_FACTOR).ToVector();
                    transform.rotation = Quaternion.Lerp(transform.rotation, rotation.ToQuaternion(), Time.deltaTime * DELTA_TIME_FACTOR);
                    transform.localScale = Vector3.Lerp(transform.localScale, scale.ToVector(), Time.deltaTime * DELTA_TIME_FACTOR);
                    return;
                }
            }

            transform.position = position.ToVector();
            transform.rotation = rotation.ToQuaternion();
            transform.localScale = scale.ToVector();
        }

    }

}