TSCollider2D.cs

using System;
using UnityEngine;

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

        private Physics2D.Shape shape;

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

        public bool isTrigger;

        public TSMaterial tsMaterial;

        [SerializeField]
        private TSVector2 center;

        private Vector3 scaledCenter;

        internal Physics2D.Body _body;

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

                return _body;
            }
        }

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

        public TSVector2 ScaledCenter {
            get {
                return TSVector2.Scale(center, new TSVector2(lossyScale.x, lossyScale.y));
            }
        }

        public abstract Physics2D.Shape CreateShape();

        private TSRigidBody2D tsRigidBody;

        [HideInInspector]
        public TSTransform2D tsTransform;

        public TSRigidBody2D attachedRigidbody {
            get {
                return tsRigidBody;
            }
        }

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

        public void Awake() {
            tsTransform = this.GetComponent<TSTransform2D>();
            tsRigidBody = this.GetComponent<TSRigidBody2D>();

            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(Physics2D.World world) {
            Physics2D.Body body = Physics2D.BodyFactory.CreateBody(world);
            Physics2D.Fixture fixture = body.CreateFixture(Shape);

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

            if (tsMaterial != null) {
                fixture.Friction = tsMaterial.friction;
                fixture.Restitution = tsMaterial.restitution;
            }

            if (tsRigidBody == null) {
                body.BodyType = Physics2D.BodyType.Static;
            } else {
                if (tsRigidBody.isKinematic) {
                    body.BodyType = TrueSync.Physics2D.BodyType.Kinematic;
                } else {
                    body.BodyType = Physics2D.BodyType.Dynamic;
                    body.IgnoreGravity = !tsRigidBody.useGravity;
                }

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

                body.FixedRotation = tsRigidBody.freezeZAxis;
                body.Mass = tsRigidBody.mass;
            }

            body.IsSensor = isTrigger;
            body.CollidesWith = Physics2D.Category.All;

            _body = body;
        }

        public void Initialize(Physics2D.World world) {
            CreateBody(world);
        }

        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.TSPosition.ToVector() : (transform.position + ScaledCenter.ToVector());
            Quaternion rotation = _body != null ? Quaternion.Euler(0, 0, (_body.Rotation * FP.Rad2Deg).AsFloat()) : 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;
            }
        }

    }

}