TSRigidBody.cs

using UnityEngine;
using UnityEngine.Serialization;
using TrueSync.Physics3D;

namespace TrueSync {

    [RequireComponent(typeof(TSCollider))]
    [AddComponentMenu("TrueSync/Physics/TSRigidBody", 11)]
    public class TSRigidBody : MonoBehaviour {

        public enum InterpolateMode { None, Interpolate, Extrapolate };

        [FormerlySerializedAs("mass")]
        [SerializeField]
        private FP _mass = 1;

        public FP mass {
            get {
                if (tsCollider._body != null) {
                    return tsCollider._body.Mass;
                }

                return _mass;
            }

            set {
                _mass = value;

                if (tsCollider._body != null) {
                    tsCollider._body.Mass = value;
                }
            }
        }

        [SerializeField]
        private bool _useGravity = true;

        public bool useGravity {
            get {
                if (tsCollider.IsBodyInitialized) {
                    return tsCollider.Body.TSAffectedByGravity;
                }

                return _useGravity;
            }

            set {
                _useGravity = value;

                if (tsCollider.IsBodyInitialized) {
                    tsCollider.Body.TSAffectedByGravity = _useGravity;
                }
            }
        }

        [SerializeField]
        private bool _isKinematic;

        public bool isKinematic {
            get {
                if (tsCollider.IsBodyInitialized) {
                    return tsCollider.Body.TSIsKinematic;
                }

                return _isKinematic;
            }

            set {
                _isKinematic = value;

                if (tsCollider.IsBodyInitialized) {
                    tsCollider.Body.TSIsKinematic = _isKinematic;
                }
            }
        }

        [SerializeField]
        private FP _linearDrag;

        public FP drag {
            get {
                if (tsCollider.IsBodyInitialized) {
                    return tsCollider.Body.TSLinearDrag;
                }

                return _linearDrag;
            }

            set {
                _linearDrag = value;

                if (tsCollider.IsBodyInitialized) {
                    tsCollider.Body.TSLinearDrag = _linearDrag;
                }
            }
        }

        [SerializeField]
        private FP _angularDrag = 0.05f;

        public FP angularDrag {
            get {
                if (tsCollider.IsBodyInitialized) {
                    return tsCollider.Body.TSAngularDrag;
                }

                return _angularDrag;
            }

            set {
                _angularDrag = value;

                if (tsCollider.IsBodyInitialized) {
                    tsCollider.Body.TSAngularDrag = _angularDrag;
                }
            }
        }

        public InterpolateMode interpolation;

        [SerializeField]
        [HideInInspector]
        private TSRigidBodyConstraints _constraints = TSRigidBodyConstraints.None;

        public TSRigidBodyConstraints constraints {
            get {
                if (tsCollider.IsBodyInitialized) {
                    return tsCollider._body.FreezeConstraints;
                }

                return _constraints;
            }

            set {
                _constraints = value;

                if (tsCollider.IsBodyInitialized) {
                    tsCollider._body.FreezeConstraints = value;
                }
            }
        }

        private TSCollider _tsCollider;

        public TSCollider tsCollider {
            get {
                if (_tsCollider == null) {
                    _tsCollider = GetComponent<TSCollider>();
                }

                return _tsCollider;
            }
        }

        private TSTransform _tsTransform;

        public TSTransform tsTransform {
            get {
                if (_tsTransform == null) {
                    _tsTransform = GetComponent<TSTransform>();
                }

                return _tsTransform;
            }
        }

        public void AddForce(TSVector force) {
            AddForce(force, ForceMode.Force);
        }

        public void AddForce(TSVector force, ForceMode mode) {
            if (mode == ForceMode.Force) {
                tsCollider.Body.TSApplyForce(force);
            } else if (mode == ForceMode.Impulse) {
                tsCollider.Body.TSApplyImpulse(force);
            }
        }

        public void AddForceAtPosition(TSVector force, TSVector position) {
            AddForceAtPosition(force, position, ForceMode.Impulse);
        }

        public void AddForceAtPosition(TSVector force, TSVector position, ForceMode mode) {
            if (mode == ForceMode.Force) {
                tsCollider.Body.TSApplyForce(force, position);
            } else if (mode == ForceMode.Impulse) {
                tsCollider.Body.TSApplyImpulse(force, position);
            }
        }

        public TSVector GetPointVelocity(TSVector worldPoint) {
            TSVector directionPoint = position - tsCollider.Body.TSPosition;
            return TSVector.Cross(tsCollider.Body.TSAngularVelocity, directionPoint) + tsCollider.Body.TSLinearVelocity;
        }

        public void AddTorque(TSVector torque) {
            tsCollider.Body.TSApplyTorque(torque);
        }


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

        public void MovePosition(TSVector position) {
            this.position = position;
        }

        public void MoveRotation(TSQuaternion rot) {
            this.rotation = rot;
        }

        public TSVector position {
            get {
                return tsTransform.position;
            }

            set {
                tsTransform.position = value;
            }
        }

        public TSQuaternion rotation {
            get {
                return tsTransform.rotation;
            }

            set {
                tsTransform.rotation = value;
            }
        }

        public TSVector velocity {
            get {
                return tsCollider.Body.TSLinearVelocity;
            }

            set {
                tsCollider.Body.TSLinearVelocity = value;
            }
        }

        public TSVector angularVelocity {
            get {
                return tsCollider.Body.TSAngularVelocity;
            }

            set {
                tsCollider.Body.TSAngularVelocity = value;
            }
        }

    }

}