siege-song/Data/Assets/RayFire/Scripts/Components/RayfireRigid.cs

using System;
using System.Collections.Generic;
using UnityEngine;
using Random = UnityEngine.Random;

namespace RayFire
{
    [SelectionBase]
    [DisallowMultipleComponent]
    [AddComponentMenu ("RayFire/Rayfire Rigid")]
    [HelpURL ("https://rayfirestudios.com/unity-online-help/components/unity-rigid-component/")]
    public class RayfireRigid : MonoBehaviour
    {
        public enum InitType
        {
            ByMethod = 0,
            AtStart  = 1
        }

        public InitType              initialization      = InitType.ByMethod;
        public SimType               simulationType      = SimType.Dynamic;
        public ObjectType            objectType          = ObjectType.Mesh;
        public DemolitionType        demolitionType      = DemolitionType.None;
        public RFPhysic              physics             = new RFPhysic();
        public RFActivation          activation          = new RFActivation();
        public RFLimitations         limitations         = new RFLimitations();
        public RFDemolitionMesh      meshDemolition      = new RFDemolitionMesh();
        public RFDemolitionCluster   clusterDemolition   = new RFDemolitionCluster();
        public RFReferenceDemolition referenceDemolition = new RFReferenceDemolition();
        public RFSurface             materials           = new RFSurface();
        public RFDamage              damage              = new RFDamage();
        public RFFade                fading              = new RFFade();
        public RFReset               reset               = new RFReset();

        /// /////////////////////////////////////////////////////////
        /// Hidden
        /// /////////////////////////////////////////////////////////
        
        public bool                initialized;
        public bool                corState;
        public Mesh[]              meshes;
        public Vector3[]           pivots;
        public RFMesh[]            rfMeshes;
        public List<RFDictionary>  subIds;
        public List<RayfireRigid>  fragments;
        public Quaternion          cacheRotation; // NOTE. Should be public, otherwise rotation error on demolition.
        public Transform           transForm;
        public Transform           rootChild;
        public Transform           rootParent;
        public MeshFilter          meshFilter;
        public MeshRenderer        meshRenderer;
        public SkinnedMeshRenderer skinnedMeshRend;
        public List<RayfireDebris> debrisList;
        public List<RayfireDust>   dustList;
        public RayfireRestriction  restriction;
        public RayfireSound        sound;
        
        [NonSerialized] public RayfireRigid     meshRoot;
        [NonSerialized] public RayfireRigidRoot rigidRoot;
        [NonSerialized] public List<Transform>  particleList;
        
        /// /////////////////////////////////////////////////////////
        /// Events
        /// /////////////////////////////////////////////////////////

        public RFDemolitionEvent  demolitionEvent  = new RFDemolitionEvent();
        public RFActivationEvent  activationEvent  = new RFActivationEvent();
        public RFRestrictionEvent restrictionEvent = new RFRestrictionEvent();
        
        /// /////////////////////////////////////////////////////////
        /// Common
        /// /////////////////////////////////////////////////////////
        
        // Awake
        void Awake()
        {
            // Awake Mesh input
            MeshInput();
            
            // Initialize at start
            if (initialization == InitType.AtStart)
            {
                Initialize();
            }
        }
        
        // Initialize 
        public void Initialize()
        {
            if (initialized == false)
            {
                AwakeMethods();

                // Init sound
                RFSound.InitializationSound(sound, limitations.bboxSize);
            }

            // TODO add reinit for already initialized objects in case of property change
            else
            {
               
            }
        }
        
        // Awake ops
        void AwakeMethods()
        {
            // Create RayFire manager if not created
            RayfireMan.RayFireManInit();

            // Set components for mesh / skinned mesh / clusters
            SetComponentsBasic();
            
            // Set particles
            RFParticles.SetParticleComponents(this);
            
            // Init mesh root.
            if (SetupMeshRoot() == true)
                return;
            
            // Check for user mistakes
            RFLimitations.Checks(this);
            
            // Set components for mesh / skinned mesh / clusters
            SetComponentsPhysics();

            // Initialization Mesh input
            if (meshDemolition.meshInput == RFDemolitionMesh.MeshInputType.AtInitialization)
                MeshInput();
            
            // Precache meshes at awake
            RFDemolitionMesh.AwakePrecache(this); 
            
            // Prefragment object at awake
            RFDemolitionMesh.AwakePrefragment(this);
            
            // Skinned mesh FIXME
            if (objectType == ObjectType.SkinnedMesh)
            {
                // Reset rigid data
                Default();

                // Check for demolition state every frame
                if (demolitionType != DemolitionType.None)
                    StartCoroutine (limitations.DemolishableCor(this));
                
                // Reset rigid data
                Default();

                // Set physics properties
                physics.destructible = physics.Destructible;
                
                if (Application.isPlaying == true)
                    initialized = true;
            }

            // Excluded from simulation
            if (physics.exclude == true)
                return;
            
            // Set Start variables
            SetObjectType();

            // Runtime ops
            if (Application.isPlaying == true)
            {
                // Start all coroutines
                StartAllCoroutines();

                // Object initialized
                initialized = true;
            }
        }
        
        /// /////////////////////////////////////////////////////////
        /// Enable/Disable
        /// /////////////////////////////////////////////////////////
        
        // Disable
        void OnDisable()
        {
            // Set coroutines states
            corState                         = false;
            limitations.demolishableCorState = false;
            physics.physicsDataCorState      = false;
            activation.inactiveCorState      = false;
            activation.velocityCorState      = false;
            activation.offsetCorState        = false;
            fading.offsetCorState            = false;
        }

        // Activation
        void OnEnable()
        {
            // Start cors // TODO add support for fragment caching and the rest cors:skinned
            if (gameObject.activeSelf == true && initialized == true && corState == false)
            {
                StartAllCoroutines();
            }
        }

        /// /////////////////////////////////////////////////////////
        /// Setup
        /// /////////////////////////////////////////////////////////

        // Editor Setup
        public void EditorSetup()
        {
            // Setup mesh root
            if (objectType == ObjectType.MeshRoot)
                EditorSetupMeshRoot();

            // Setup clusters
            if (objectType == ObjectType.ConnectedCluster || objectType == ObjectType.NestedCluster)
                RFDemolitionCluster.ClusterizeEditor (this);
        }
        
        // Editor Reset
        public void ResetSetup()
        {
            // Reset setup for mesh root
            if (objectType == ObjectType.MeshRoot)
                ResetMeshRootSetup();
            
            // Reset Setup for clusters 
            if (objectType == ObjectType.ConnectedCluster || objectType == ObjectType.NestedCluster)
                RFDemolitionCluster.ResetClusterize (this);
        }

        /// /////////////////////////////////////////////////////////
        /// Awake ops
        /// /////////////////////////////////////////////////////////
        
        // Define basic components
        public void SetComponentsBasic()
        {
            // Set shatter component
            meshDemolition.scrShatter = meshDemolition.useShatter == true 
                ? GetComponent<RayfireShatter>() 
                : null;
            
            // Tm
            transForm = GetComponent<Transform>();
            
            // Mesh components
            if (objectType == ObjectType.Mesh)
            {
                meshFilter   = GetComponent<MeshFilter>();
                meshRenderer = GetComponent<MeshRenderer>();
            }

            // Skinned mesh
            if (objectType == ObjectType.SkinnedMesh)
                skinnedMeshRend = GetComponent<SkinnedMeshRenderer>();
            
            restriction = GetComponent<RayfireRestriction>();

            // Add missing mesh renderer
            if (meshFilter != null && meshRenderer == null)
                meshRenderer = gameObject.AddComponent<MeshRenderer>();

            // Init reset lists
            if (reset.action == RFReset.PostDemolitionType.DeactivateToReset)
                limitations.descendants = new List<RayfireRigid>();
        }
        
        // Define components
        void SetComponentsPhysics()
        {
            // Excluded from simulation
            if (physics.exclude == true)
                return;
            
            // Physics components
            physics.rigidBody = GetComponent<Rigidbody>();
            physics.meshCollider = GetComponent<Collider>();
            
            // Mesh Set collider
            if (objectType == ObjectType.Mesh)
                RFPhysic.SetRigidCollider (this);

            // Cluster check
            if (objectType == ObjectType.NestedCluster || objectType == ObjectType.ConnectedCluster) 
                RFDemolitionCluster.Clusterize (this);
            
            // Rigid body
            if (Application.isPlaying == true)
                if (simulationType != SimType.Static)
                    if (physics.rigidBody == null)
                        physics.rigidBody = gameObject.AddComponent<Rigidbody>();
        }

        /// /////////////////////////////////////////////////////////
        /// MeshRoot
        /// /////////////////////////////////////////////////////////

        // Setup mesh root editor ops
        void EditorSetupMeshRoot()
        {
            // Check if manager should be destroyed after setup
            bool destroyMan = RayfireMan.inst == null;

            // Create RayFire manager if not created
            RayfireMan.RayFireManInit();
            
            // Reset
            ResetMeshRootSetup();
                
            // Setup
            SetupMeshRoot();
                
            // Destroy manager
            if (destroyMan == true)
                DestroyImmediate (RayfireMan.inst.transform.gameObject);
        }
        
        // Init mesh root. Copy Rigid component for children with mesh
        bool SetupMeshRoot()
        {
            if (objectType == ObjectType.MeshRoot)
            {
                // Get transform for Editor setup
                if (transForm == null)
                    transForm = GetComponent<Transform>();
                
                // Stop if already initiated
                if (limitations.demolished == true || physics.exclude == true)
                    return true;
                
                // Save tm
                physics.SaveInitTransform (transForm);

                // MeshRoot Integrity check
                if (Application.isPlaying == true)
                    MeshRootCheck();

                // Add Rigid to mesh Root children
                if (HasFragments == false)
                    AddMeshRootRigid();
                
                // Init in runtime. DO not if editor setup
                if (Application.isPlaying == true)
                    for (int i = 0; i < fragments.Count; i++)
                        fragments[i].Initialize();

                // Editor only ops
                if (Application.isPlaying == false)
                {
                    for (int i = 0; i < fragments.Count; i++)
                    {
                        // Set basic fragments components for collider apply
                        fragments[i].SetComponentsBasic();

                        // Set bound and size for connection size by bounding box
                        RFLimitations.SetBound (fragments[i]);
                    }
                    
                    // Add colliders to speedup. Editor only. Frags get collider at runtime in Initialize()
                    RFPhysic.SetupMeshRootColliders (this);
                }
                
                // Ignore neib collisions
                RFPhysic.SetIgnoreColliders (physics, fragments);
                
                // Runtime only ops
                if (Application.isPlaying == true)
                {
                    // Copy components. 
                    RayfireShatter.CopyRootMeshShatter (this, fragments);
                    RFParticles.CopyRootMeshParticles (this, fragments);
                    RFSound.CopySound (sound, fragments);
                }
                
                // Set unyielding 
                RayfireUnyielding.MeshRootSetup (this);

                // Initialize connectivity
                InitConnectivity();
                
                // Turn off demolition and physics
                if (Application.isPlaying == true)
                {
                    demolitionType  = DemolitionType.None;
                    physics.exclude = true;
                    initialized     = true;
                }

                return true;
            }

            return false;
        }

        // MeshRoot Integrity check
        void MeshRootCheck()
        {
            if (HasFragments == true)
                for (int f = 0; f < fragments.Count; f++)
                    if (fragments[f] == null)
                    {
                        Debug.Log ("RayFire Rigid: " + name + " has missing fragments. Reset Setup and used Editor Setup again", gameObject);
                        fragments = new List<RayfireRigid>();
                        return;
                    }
        }
        
        // Add Rigid to mesh Root children
        void AddMeshRootRigid()
        {
            // Get children
            List<Transform> children = new List<Transform>();
            for (int i = 0; i < transForm.childCount; i++)
                children.Add (transForm.GetChild (i));
            
            // Add Rigid to child with mesh
            fragments = new List<RayfireRigid>();
            for (int i = 0; i < children.Count; i++)
            {
                MeshFilter mf = children[i].GetComponent<MeshFilter>();
                if (mf != null)
                {
                    // Get rigid
                    RayfireRigid childRigid = children[i].gameObject.GetComponent<RayfireRigid>();
                    
                    // Mark Rigid as custom Rigid component to keep it at Mesh Root Reset
                    if (childRigid != null)
                        childRigid.rootParent = transForm;

                    // Add new and copy props from parent
                    if (childRigid == null)
                    {
                        childRigid = children[i].gameObject.AddComponent<RayfireRigid>();
                        CopyPropertiesTo (childRigid);
                    }

                    // Set meshfilter
                    childRigid.meshFilter = mf;

                    // Collect
                    fragments.Add (childRigid);

                    // Set parent meshRoot. IMPORTANT needed in case of custom Rigid
                    childRigid.meshRoot = this;
                }
            }
        }
        
        // Init connectivity if has
        void InitConnectivity()
        {
            activation.connect = GetComponent<RayfireConnectivity>();
            if (activation.connect != null && activation.connect.rigidRootHost == null)
            {
                activation.connect.meshRootHost = this;
                activation.connect.Initialize();;
            }
        }
        
        // Reset MeshRoot Setup
        void ResetMeshRootSetup()
        {
            // Reset Connectivity
            if (activation.connect != null)
                activation.connect.ResetSetup();
            activation.connect = null;

            // Destroy new Rigid and clear custom Rigid components
            if (HasFragments == true)
            {
                // Destroy colliders added by setup
                HashSet<Collider> collidersHash = new HashSet<Collider>(physics.clusterColliders);
                for (int i = 0; i < fragments.Count; i++)
                    if (fragments[i].physics.meshCollider != null)
                        if (collidersHash.Contains (fragments[i].physics.meshCollider) == false)
                            DestroyImmediate (fragments[i].physics.meshCollider);
                physics.clusterColliders = null;
                
                // Destroy Rigids added by setup
                for (int i = 0; i < fragments.Count; i++)
                    if (fragments[i].rootParent == null)
                        DestroyImmediate (fragments[i]);
                    else
                    {
                        fragments[i].rootParent           = null;
                        fragments[i].meshFilter           = null;
                        fragments[i].meshRenderer         = null;
                        fragments[i].physics.meshCollider = null;
                        fragments[i].meshRoot             = null;
                    }
            }

            // Reset common
            physics.ignoreList = null;
            fragments          = null;
        }
        
        /// /////////////////////////////////////////////////////////
        /// Start ops
        /// /////////////////////////////////////////////////////////
        
        // Set Start variables
        void SetObjectType ()
        {
            if (objectType == ObjectType.Mesh ||
                objectType == ObjectType.NestedCluster ||
                objectType == ObjectType.ConnectedCluster)
            
                // Reset rigid data
                Default();
                
                // Set physics properties
                SetPhysics();
        }
        
        // Reset rigid data
        public void Default()
        {
            // Reset
            limitations.Reset();
            meshDemolition.Reset();
            if (clusterDemolition != null)
                clusterDemolition.Reset();
            
            limitations.birthTime = Time.time + Random.Range (0f, 0.05f);

            // Birth position for activation check
            physics.SaveInitTransform (transForm);

            // Set bound and size
            RFLimitations.SetBound(this);

            // Backup original layer
            RFActivation.BackupActivationLayer (this);

            // meshDemolition.properties.layerBack = gameObject.layer;
            // gameObject.tag;
        }
        
        // Set physics properties
        void SetPhysics()
        {
            // Excluded from sim
            if (physics.exclude == true)
                return;

            // MeshCollider physic material preset. Set new or take from parent 
            RFPhysic.SetColliderMaterial (this);

            // Set debris collider material
            RFPhysic.SetParticleColliderMaterial (debrisList);
            
            // Ops with rigidbody applied
            if (physics.rigidBody != null)
            {
                // Set physical simulation type. Important. Should after collider material define
                if (Application.isPlaying == true)
                    RFPhysic.SetSimulationType (physics.rigidBody, simulationType, objectType, physics.useGravity, physics.solverIterations);

                // Do not set convex, mass, drag for static
                if (simulationType == SimType.Static)
                    return;
                
                // Convex collider meshCollider. After SetSimulation Type to turn off convex for kinematic
                RFPhysic.SetColliderConvex (this);

                // Set density. After collider defined
                RFPhysic.SetDensity (this);

                // Set drag properties
                RFPhysic.SetDrag (this);
            }

            // Set material solidity and destructible
            physics.solidity     = physics.Solidity;
            physics.destructible = physics.Destructible;
        }

        /// /////////////////////////////////////////////////////////
        /// Coroutines
        /// /////////////////////////////////////////////////////////
        
        // Start all coroutines
        public void StartAllCoroutines()
        {
            // Stop if static
            if (simulationType == SimType.Static)
                return;
            
            // Inactive
            if (gameObject.activeSelf == false)
                return;
            
            // Prevent physics cors
            if (physics.exclude == true)
                return;
            
            // Check for demolition state every frame
            if (demolitionType != DemolitionType.None)
                StartCoroutine (limitations.DemolishableCor(this));
            
            // Offset fade
            if (fading.byOffset > 0)
            {
                fading.offsetEnum = RFFade.FadeOffsetCor (this);
                StartCoroutine (fading.offsetEnum);
            }

            // Start inactive coroutines
            InactiveCors();
            
            // Cache physics data for fragments 
            physics.physicsEnum = physics.PhysicsDataCor (this);
            StartCoroutine (physics.physicsEnum);
            
            // Init restriction check
            RayfireRestriction.InitRestriction (this);

            // All coroutines are running
            corState = true;
        }

        // Start inactive coroutines
        public void InactiveCors()
        {
            // Activation by velocity\offset coroutines
            if (simulationType == SimType.Inactive || simulationType == SimType.Kinematic)
            {
                if (activation.byVelocity > 0)
                {
                    activation.velocityEnum = activation.ActivationVelocityCor (this);
                    StartCoroutine (activation.velocityEnum);
                }

                if (activation.byOffset > 0)
                {
                    activation.offsetEnum = activation.ActivationOffsetCor (this);
                    StartCoroutine (activation.offsetEnum);
                }
            }

            // Init inactive every frame update coroutine
            if (simulationType == SimType.Inactive)
                //RayfireMan.inst.AddInactive (this);
                StartCoroutine (activation.InactiveCor(this));
        }
        
        /// /////////////////////////////////////////////////////////
        /// Demolition types
        /// /////////////////////////////////////////////////////////
        
        // Awake Mesh input // TODO add checks in case has input mesh but mesh input is off
        public void MeshInput()
        {
            if (objectType == ObjectType.Mesh && 
                demolitionType == DemolitionType.Runtime && 
                meshDemolition.meshInput == RFDemolitionMesh.MeshInputType.AtStart)
            {
                // Set components for mesh / skinned mesh / clusters
                SetComponentsBasic();

                // Input
                RFFragment.InputMesh (this);
            }
        }
        
        /// /////////////////////////////////////////////////////////
        /// Collision
        /// /////////////////////////////////////////////////////////

        // Collision check
        protected virtual void OnCollisionEnter (Collision collision)
        {
            // Check if collision data needed
            if (CollisionCheck() == false)
                return;
            
            // Tag check. IMPORTANT keep length check for compatibility with older builds
            if (limitations.tag.Length > 0 && limitations.tag != "Untagged" && collision.collider.CompareTag (limitations.tag) == false)
                return;
            
            // Demolish object check
            if (DemolitionState() == false) 
                return;
            
            // Check if collision demolition passed
            if (CollisionDemolition (collision) == true)
                limitations.demolitionShould = true;
        }
        
        // Check if collision demolition passed
        protected virtual bool CollisionDemolition (Collision collision)
        {
            // Final object solidity
            float finalSolidity = physics.solidity * limitations.solidity * RayfireMan.inst.globalSolidity;
            
            // Collision with kinematic object. Uses collision.impulse
            if (collision.rigidbody != null && collision.rigidbody.isKinematic == true)
            {
                if (collision.impulse.magnitude > finalSolidity * 7f) // TODO fix
                {
                    limitations.contactPoint   = collision.GetContact(0);
                    limitations.contactVector3 = limitations.contactPoint.point;
                    limitations.contactNormal  = limitations.contactPoint.normal;
                    return true;
                }
            }

            // Collision force checks. Uses relativeVelocity
            float collisionMagnitude = collision.relativeVelocity.magnitude;
            for (int i = 0; i < collision.contactCount; i++)
            {
                // Set contact point
                limitations.contactPoint   = collision.GetContact(i);
                limitations.contactVector3 = limitations.contactPoint.point;
                limitations.contactNormal  = limitations.contactPoint.normal;
                
                // Demolish if collision high enough
                if (collisionMagnitude > finalSolidity)
                    return true;
                
                // Collect damage by collision
                if (damage.enable == true && damage.collect == true)
                    if (ApplyDamage (collisionMagnitude * damage.multiplier, limitations.contactVector3, 0f, collision.contacts[i].thisCollider) == true)
                        return true;
            }

            return false;
        }
        
        // Check if collision data needed
        bool CollisionCheck()
        {
            if (limitations.byCollision == true)
                return true;
            if (damage.enable == true && damage.collect == true)
                return true;
            return false;
        }
        
        /// /////////////////////////////////////////////////////////
        /// Demolition
        /// /////////////////////////////////////////////////////////

        // Demolition available state
        public bool State ()
        {
            // Object already demolished
            if (limitations.demolished == true)
                return false;

            // Object already passed demolition state and demolishing is in progress
            if (meshDemolition.runtimeCaching.inProgress == true)
                return false;
            
            // Bad mesh check
            if (meshDemolition.badMesh > RayfireMan.inst.advancedDemolitionProperties.badMeshTry)
                return false;

            // Max amount check
            if (RayfireMan.MaxAmountCheck == false)
                return false;
            
            // Depth level check
            if (limitations.depth > 0 && limitations.currentDepth >= limitations.depth)
                return false;

            // Min Size check. Min Size should be considered and size is less than
            if (limitations.bboxSize < limitations.size)
                return false;

            // Safe frame
            if (Time.time - limitations.birthTime < limitations.time)
                return false;
            
            // Static objects can not be demolished
            if (simulationType == SimType.Static)
                return false;
            
            // Fading
            if (fading.state == 2)
                return false;
            
            return true;
        }
        
        // Check if object should be demolished
        public virtual bool DemolitionState ()
        {
            // No demolition allowed
            if (demolitionType == DemolitionType.None)
                return false;
           
            // Non destructible material
            if (physics.destructible == false)
                return false;
           
            // Visibility check
            if (limitations.visible == true)
            {
                if (meshRenderer != null && meshRenderer.isVisible == false)
                    return false;
                if (skinnedMeshRend != null && skinnedMeshRend.isVisible == false)
                    return false;
            }

            // Demolition available check
            if (State() == false)
                return false;
            
            // Per frame time check
            if (RayfireMan.inst.timeQuota > 0 && RayfireMan.inst.maxTimeThisFrame > RayfireMan.inst.timeQuota)
                return false;

            return true;
        }
        
        // Demolish object
        public void Demolish()
        {
            // Profiler.BeginSample ("Demolition");
            // Debug.Log (limitations.demolitionShould);
            
            // Initialize if not
            if (initialized == false)
                Initialize();

            // Timestamp
            float t1 = Time.realtimeSinceStartup;

            // Demolish mesh or cluster to reference
            if (RFReferenceDemolition.DemolishReference(this) == false)
                return;

            // Demolish mesh and create fragments. Stop if runtime caching or no meshes/fragments were created
            if (RFDemolitionMesh.DemolishMesh (this) == true)
            {
                // Check for inactive/kinematic fragments with unyielding
                RayfireUnyielding.SetUnyieldingFragments (this);

                // Set children with mesh as additional fragments
                RFDemolitionMesh.ChildrenToFragments(this);
                
                // Clusterize runtime fragments
                RFDemolitionMesh.ClusterizeFragments (this);
            }
            else
                return;
            
            // Demolish cluster to children nodes 
            if (RFDemolitionCluster.DemolishCluster (this) == true)
                return;

            // Check fragments and proceed TODO separate flow for connected cls demolition
            if (limitations.demolished == false)
            {
                limitations.demolitionShould = false;
                demolitionType = DemolitionType.None;
                return;
            }
            
            // Connectivity check
            activation.CheckConnectivity();
            
            // Fragments initialisation
            InitMeshFragments();
            
            // Sum total demolition time
            RayfireMan.inst.maxTimeThisFrame += Time.realtimeSinceStartup - t1;
            
            // Init particles
            RFParticles.InitDemolitionParticles(this);

            // Init sound
            RFSound.DemolitionSound(sound, limitations.bboxSize);

            // Event
            demolitionEvent.InvokeLocalEvent (this);
            RFDemolitionEvent.InvokeGlobalEvent (this);
            
            // Destroy demolished object
            RayfireMan.DestroyFragment (this, rootParent);
            
            // Debug.Log (fragments[0].fragments.Count);
            // Debug.Log (fragments[0].fragments[0], fragments[0].fragments[0].gameObject);
            
            // Timestamp
            // float t2 = Time.realtimeSinceStartup;
            // Debug.Log (t2 - t1);
            // Profiler.EndSample();
        }
        
        /// /////////////////////////////////////////////////////////
        /// Fragments
        /// /////////////////////////////////////////////////////////
        
        // Copy rigid properties from parent to fragments
        public void CopyPropertiesTo (RayfireRigid toScr)
        {
            // Set local meshRoot
            if (objectType == ObjectType.MeshRoot)
                toScr.meshRoot = this;
            else if (meshRoot != null)
                    toScr.meshRoot = meshRoot;

            // Object type
            toScr.objectType = objectType;
            if (objectType == ObjectType.MeshRoot || objectType == ObjectType.SkinnedMesh)
                toScr.objectType = ObjectType.Mesh;
            
            // Sim type
            toScr.simulationType = simulationType;
            if (objectType != ObjectType.MeshRoot)
                if (simulationType == SimType.Kinematic || simulationType == SimType.Static || simulationType == SimType.Sleeping)
                    toScr.simulationType = SimType.Dynamic;

            // Demolition type
            toScr.demolitionType = demolitionType;
            if (objectType != ObjectType.MeshRoot)
                if (demolitionType != DemolitionType.None)
                    toScr.demolitionType = DemolitionType.Runtime;
            if (demolitionType == DemolitionType.ReferenceDemolition)
                toScr.demolitionType = DemolitionType.None;
            
            // Copy physics
            toScr.physics.CopyFrom (physics);
            toScr.activation.CopyFrom (activation);
            toScr.limitations.CopyFrom (limitations);
            toScr.meshDemolition.CopyFrom (meshDemolition);
            toScr.clusterDemolition.CopyFrom (clusterDemolition);

            // Copy reference demolition props
            if (objectType == ObjectType.MeshRoot)
                toScr.referenceDemolition.CopyFrom (referenceDemolition);
            
            toScr.materials.CopyFrom (materials);
            toScr.damage.CopyFrom (damage);
            toScr.fading.CopyFrom (fading);
            toScr.reset.CopyFrom (reset, objectType);
            
            // Copy restriction
            if (restriction != null)
            {
                toScr.restriction = toScr.gameObject.AddComponent<RayfireRestriction>();
                toScr.restriction.CopyFrom (restriction);
            }
        }
        
        // Fragments initialisation
        public void InitMeshFragments()
        {
            // No fragments
            if (HasFragments == false)
                return;
            
            // Set velocity
            RFPhysic.SetFragmentsVelocity (this);
            
            // Sum total new fragments amount
            RayfireMan.inst.advancedDemolitionProperties.ChangeCurrentAmount (fragments.Count);
            
            // Set ancestor and descendants 
            RFLimitations.SetAncestor (this);
            RFLimitations.SetDescendants (this);

            // Fading. move to fragment
            if (fading.onDemolition == true)
                fading.DemolitionFade (fragments);
        }
        
        /// /////////////////////////////////////////////////////////
        /// Manual methods
        /// /////////////////////////////////////////////////////////
        
        // Predefine fragments
        public void Prefragment()
        {
            // Delete existing
            DeleteFragments();

            // Create fragments from cache
            fragments = RFDemolitionMesh.CreateFragments(this);
                
            // Stop
            if (HasFragments == false)
            {
                demolitionType = DemolitionType.None;
                return;
            }
            
            // Set physics properties
            for (int i = 0; i < fragments.Count; i++)
            {
                fragments[i].SetComponentsBasic();
                //fragments[i].SetParticleComponents();
                fragments[i].SetComponentsPhysics();
                fragments[i].SetObjectType();

                // Increment demolition depth. Disable if last
                fragments[i].limitations.currentDepth = 1;
                if (limitations.depth == 1)
                    fragments[i].demolitionType = DemolitionType.None;
            }

            // Deactivate fragments root
            if (rootChild != null)
                rootChild.gameObject.SetActive (false);
        }

        // Clear cache info
        public void DeleteCache()
        {
            meshes   = null;
            pivots   = null;
            rfMeshes = null;
            subIds   = new List<RFDictionary>();
        }
        
        // Delete fragments
        public void DeleteFragments()
        {
            // Destroy root
            if (rootChild != null)
            {
                if (Application.isPlaying == true)
                    Destroy (rootChild.gameObject);
                else
                    DestroyImmediate (rootChild.gameObject);

                // Clear ref
                rootChild = null;
            }

            // Clear array
            fragments = null;
        }
        
        /// /////////////////////////////////////////////////////////
        /// Blade
        /// /////////////////////////////////////////////////////////

        // Add new slice plane
        public void AddSlicePlane (Vector3[] slicePlane)
        {
            // Not even amount of slice data
            if (slicePlane.Length % 2 == 1)
                return;

            // Add slice plane data
            limitations.slicePlanes.AddRange (slicePlane);
        }
        
        // Slice object
        public void Slice()
        {
            // Check for slices
            if (HasSlices == false)
            {
                Debug.Log ("RayFire Rigid: " + name + " has no defined slicing planes.", gameObject);
                return;
            }
            
            // Slice
            if (objectType == ObjectType.Mesh || objectType == ObjectType.SkinnedMesh)
            {
                RFDemolitionMesh.SliceMesh (this);
                
                // Set children with mesh as additional fragments
                RFDemolitionMesh.ChildrenToFragments(this);
            }
            else if (objectType == ObjectType.ConnectedCluster)
                RFDemolitionCluster.SliceConnectedCluster (this);

            // Particles
            RFParticles.InitDemolitionParticles(this);

            // Sound
            RFSound.DemolitionSound(sound, limitations.bboxSize);
            
            // Event
            demolitionEvent.InvokeLocalEvent (this);
            RFDemolitionEvent.InvokeGlobalEvent (this);

            // Destroy original
            if (objectType == ObjectType.Mesh || objectType == ObjectType.SkinnedMesh)
                RayfireMan.DestroyFragment (this, rootParent);
        }
        
        /// /////////////////////////////////////////////////////////
        /// Caching
        /// /////////////////////////////////////////////////////////
        
        // Caching into meshes over several frames
        public void CacheFrames()
        {
            StartCoroutine (meshDemolition.RuntimeCachingCor(this));
        }

        /// /////////////////////////////////////////////////////////
        /// Public methods
        /// /////////////////////////////////////////////////////////

        // Save init transform. Birth tm for activation check and reset
        [ContextMenu("SaveInitTransform")]
        public void SaveInitTransform ()
        {
            // Rigid save tm
            if (objectType == ObjectType.Mesh)
                physics.SaveInitTransform (transForm);
            
            // Mesh Root save tm
            else if (objectType == ObjectType.MeshRoot)
            {
                if (HasFragments == true)
                {
                    // Save for Rigids
                    for (int i = 0; i < fragments.Count; i++)
                        if (fragments[i] != null)
                            fragments[i].physics.SaveInitTransform (fragments[i].transForm);

                    // Save is connectivity backup cluster
                    if (activation.connect != null && reset.connectivity == true )
                        if (activation.connect.backup != null)
                            RFBackupCluster.SaveTmRecursive (activation.connect.backup.cluster);
                }
            }
        }
        
        // Apply damage
        public bool ApplyDamage (float damageValue, Vector3 damagePoint, float damageRadius = 0f, Collider coll = null)
        {
            return RFDamage.ApplyDamage (this, damageValue, damagePoint, damageRadius, coll);
        }
        
        // Activate inactive object
        public void Activate(bool connCheck = true)
        {
            if (objectType != ObjectType.MeshRoot)
                RFActivation.ActivateRigid (this, connCheck);
            else
                for (int i = 0; i < fragments.Count; i++)
                    RFActivation.ActivateRigid (fragments[i], connCheck);
        }
        
        // Fade this object
        public void Fade()
        {
            if (objectType != ObjectType.MeshRoot)
                RFFade.FadeRigid (this);
            else
                for (int i = 0; i < fragments.Count; i++)
                    RFFade.FadeRigid (fragments[i]);
        }
        
        // Reset object
        public void ResetRigid()
        {
            RFReset.ResetRigid (this);
        }

        /// /////////////////////////////////////////////////////////
        /// Other
        /// /////////////////////////////////////////////////////////
        
        // Destroy
        public void DestroyCollider(Collider col) { Destroy (col); }
        public void DestroyObject(GameObject go) { Destroy (go); }
        public void DestroyRigid(RayfireRigid rigid) { Destroy (rigid); }
        public void DestroyRb(Rigidbody rb) { Destroy (rb); }

        /// /////////////////////////////////////////////////////////
        /// Getters
        /// /////////////////////////////////////////////////////////
        
        // Fragments/Meshes check
        public bool HasFragments { get { return fragments != null && fragments.Count > 0; } }
        public bool HasMeshes   { get { return meshes != null && meshes.Length > 0; } }
        public bool HasRfMeshes { get { return rfMeshes != null && rfMeshes.Length > 0; } }
        public bool HasDebris   { get { return debrisList != null && debrisList.Count > 0; } }
        public bool HasDust     { get { return dustList != null && dustList.Count > 0; } }
        public bool HasSlices   { get { return limitations.slicePlanes != null && limitations.slicePlanes.Count > 0; } }
        public bool IsCluster   { get { return objectType == ObjectType.ConnectedCluster || objectType == ObjectType.NestedCluster; } }

        
        // CLuster Integrity
        public float AmountIntegrity
        {
            get
            {
                if (objectType == ObjectType.ConnectedCluster)
                    return  (float)clusterDemolition.cluster.shards.Count / (float)clusterDemolition.am * 100f;
                return 0f;
            }
        }
    }
}