TSCollider.cs

using System;
using System.Linq;
using UnityEngine;

namespace TrueSync {
    [RequireComponent(typeof(TSTransform))]
    [Serializable]
    [ExecuteInEditMode]
    public abstract class TSCollider : MonoBehaviour, ICollider {

        private Shape shape;

        public Shape Shape {
            get {
                if (shape == null)
                    shape = CreateShape();
                return shape;
            }
            protected set { shape = value; }
        }

        public bool isTrigger;

        public TSMaterial tsMaterial;

        [SerializeField]
        private TSVector center;

        private Vector3 scaledCenter;

        internal RigidBody _body;

        public TSVector Center {
            get {
                return center;
            }
            set {
                center = value;
            }
        }

        public TSVector ScaledCenter {
            get {
                return TSVector.Scale (Center, lossyScale);
            }
        }

        public abstract Shape CreateShape();

        private TSRigidBody tsRigidBody;

        public TSRigidBody attachedRigidbody {
            get {
                return tsRigidBody;
            }
        }

        public TSBBox bounds {
            get {
                return this._body.BoundingBox;
            }
        }

        public IBody3D Body {
            get {
                if (_body == null) {
                    CheckPhysics();
                }

                return _body;
            }
        }

        [SerializeField]
        [HideInInspector]
        protected TSVector lossyScale = TSVector.one;

        [HideInInspector]
        public TSTransform tsTransform;

        public void Awake() {
            tsTransform = this.GetComponent<TSTransform>();
            tsRigidBody = this.GetComponent<TSRigidBody>();

            if (lossyScale == TSVector.one) {
                lossyScale = TSVector.Abs(transform.localScale.ToTSVector());
            }
        }

        public void Update() {
            if (!Application.isPlaying) {
                lossyScale = TSVector.Abs(transform.lossyScale.ToTSVector());
            }
        }

        private void CreateBody() {
            RigidBody newBody = new RigidBody(Shape);

            if (tsMaterial == null) {
                tsMaterial = GetComponent<TSMaterial>();
            }

            if (tsMaterial != null) {
                newBody.Material = new BodyMaterial();
                newBody.Material.KineticFriction = tsMaterial.friction;
                newBody.Material.StaticFriction = tsMaterial.friction;
                newBody.Material.Restitution = tsMaterial.restitution;
            }

            newBody.IsColliderOnly = isTrigger;
            newBody.IsKinematic = tsRigidBody != null && tsRigidBody.isKinematic;

            bool isStatic = tsRigidBody == null || tsRigidBody.isKinematic;

            if (isStatic) {
                newBody.AffectedByGravity = false;
                newBody.IsStatic = true;
            } else if (tsRigidBody != null) {
                newBody.AffectedByGravity = tsRigidBody.useGravity;

                if (tsRigidBody.mass <= 0) {
                    tsRigidBody.mass = 1;
                }

                newBody.Mass = tsRigidBody.mass;
            } else {
                newBody.SetMassProperties();
            }

            _body = newBody;
        }

        public void Initialize() {
            CreateBody();
        }

        private void CheckPhysics() {
            if (_body == null && PhysicsManager.instance != null) {
                PhysicsManager.instance.AddBody(this);
            }
        }

        public virtual void OnDrawGizmos() {
            if (!this.enabled) {
                return;
            }

            Vector3 position = _body != null ? _body.Position.ToVector() : (transform.position + ScaledCenter.ToVector());
            Quaternion rotation = _body != null ? _body.Orientation.ToQuaternion() : transform.rotation;

            Gizmos.color = Color.yellow;

            Matrix4x4 cubeTransform = Matrix4x4.TRS(position, rotation, GetGizmosSize());
            Matrix4x4 oldGizmosMatrix = Gizmos.matrix;

            Gizmos.matrix *= cubeTransform;

            DrawGizmos();

            Gizmos.matrix = oldGizmosMatrix;
        }

        protected abstract Vector3 GetGizmosSize();

        protected abstract void DrawGizmos();

        public bool IsBodyInitialized {
            get {
                return _body != null;
            }
        }
    }

}