/// /////////////////////////////////////////////////////////
/// Manual methods
/// /////////////////////////////////////////////////////////
// Predefine fragments
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();
}
// Deactivate fragments root
if (rootChild != null)
{
rootChild.gameObject.SetActive(false);
}
}
// Copy from
public void CopyFrom(RFDemolitionMesh demolition)
{
amount = demolition.amount;
variation = demolition.variation;
depthFade = demolition.depthFade;
seed = demolition.seed;
contactBias = demolition.contactBias;
useShatter = false;
// TODO input mesh for fragments ?? turn off for now
meshInput = demolition.meshInput;
meshInput = MeshInputType.AtDemolition;
properties.CopyFrom(demolition.properties);
runtimeCaching = new RFRuntimeCaching();
Reset();
shatterMode = 1;
innerSubId = 0;
compressPrefab = true;
cacheRotationStart = Quaternion.identity;
mesh = null;
rfShatter = null;
}
// Precache meshes at awake
void AwakePrecache()
{
if (demolitionType == DemolitionType.AwakePrecache && objectType == ObjectType.Mesh)
{
RFDemolitionMesh.CacheInstant(this);
}
}
// Predefine fragments
void AwakePrefragment()
{
if (demolitionType == DemolitionType.AwakePrefragment && objectType == ObjectType.Mesh)
{
// Cache meshes
RFDemolitionMesh.CacheInstant(this);
// Predefine fragments
Prefragment();
}
}
// Slice object
public void Slice()
{
if (objectType == ObjectType.Mesh || objectType == ObjectType.SkinnedMesh)
{
RFDemolitionMesh.SliceMesh(this);
}
else if (objectType == ObjectType.ConnectedCluster)
{
RFDemolitionCluster.SliceConnectedCluster(this);
}
}
// Precache meshes in editor
public void ManualPrecache()
{
if (demolitionType == DemolitionType.ManualPrecache && objectType == ObjectType.Mesh)
{
// Set components
SetComponentsBasic();
// Set components
SetComponentsPhysics();
// Cache meshes
RFDemolitionMesh.CacheInstant(this);
}
else if (demolitionType == DemolitionType.ManualPrecache && objectType != ObjectType.Mesh)
{
Debug.Log("RayFire Rigid: " + name + " Object Type is not Mesh. Set to Mesh type to Precache.", gameObject);
}
}
// Precache meshes for prefab in editor
public void PrefabPrecache()
{
if (demolitionType == DemolitionType.ManualPrefabPrecache && objectType == ObjectType.Mesh)
{
// Set components for mesh / skinned mesh / clusters
SetComponentsBasic();
// Cache meshes
RFDemolitionMesh.CacheInstant(this);
// Convert meshes to RFmeshes
if (HasMeshes == true)
{
rfMeshes = new RFMesh[meshes.Length];
for (int i = 0; i < meshes.Length; i++)
{
rfMeshes[i] = new RFMesh(meshes[i], meshDemolition.compressPrefab);
}
}
meshes = null;
}
}
// SLice mesh
public static void SliceMesh(RayfireRigid scr)
{
// Empty lists
scr.DeleteCache();
scr.DeleteFragments();
// SLice
RFFragment.SliceMeshes(ref scr.meshes, ref scr.pivots, ref scr.subIds, scr, scr.limitations.slicePlanes);
// Remove plane info
scr.limitations.slicePlanes.Clear();
// Stop
if (scr.HasMeshes == false)
{
return;
}
// Get fragments
scr.fragments = RFDemolitionMesh.CreateSlices(scr);
// TODO check for fragments
// Set demolition
scr.limitations.demolished = true;
// Fragments initialisation
scr.InitMeshFragments();
// Event
scr.demolitionEvent.InvokeLocalEvent(scr);
RFDemolitionEvent.InvokeGlobalEvent(scr);
// Destroy original
RayfireMan.DestroyFragment(scr, scr.rootParent);
}
// Demolish object
public void Demolish()
{
// Profiler.BeginSample ("Demolition");
// Debug.Log (limitations.demolitionShould);
// Initialize if not
if (initialized == false)
{
Initialize();
}
// Timestamp
float t1 = Time.realtimeSinceStartup;
// Restore position and rotation to prevent high collision offset
transForm.position = physics.position;
transForm.rotation = physics.rotation;
// 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) == false)
{
return;
}
/* EXPERIMENTAL
* // TODO Clusterize
* bool clusterize = true;
* if (clusterize == true && objectType == ObjectType.Mesh && demolitionType == DemolitionType.Runtime)
* {
*
* foreach (var frag in fragments)
* {
* Destroy (frag.physics.rigidBody);
* Destroy (frag);
* }
*
* RayfireRigid scr = this.rootChild.gameObject.AddComponent<RayfireRigid>();
* this.CopyPropertiesTo (scr);
* scr.demolitionType = DemolitionType.Runtime;
* scr.objectType = ObjectType.ConnectedCluster;
*
* scr.limitations.contactPoint = this.limitations.contactPoint;
* scr.limitations.contactNormal = this.limitations.contactNormal;
* scr.limitations.contactVector3 = this.limitations.contactVector3;
*
* scr.physics.velocity = this.physics.velocity;
*
* scr.clusterDemolition.cluster = new RFCluster();
* scr.Initialize();
*
* scr.physics.rigidBody.velocity = this.physics.velocity;
* scr.limitations.demolitionShould = true;
* //scr.Demolish();
* RayfireMan.DestroyFragment (this, rootParent);
* 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);
// Timestamp
// float t2 = Time.realtimeSinceStartup;
// Debug.Log (t2 - t1);
// Profiler.EndSample();
}
// Demolish object
public void Demolish()
{
// Profiler.BeginSample ("Demolition");
// Debug.Log (limitations.demolitionShould);
// Initialize if not
if (initialized == false)
{
Initialize();
}
// Timestamp
float t1 = Time.realtimeSinceStartup;
// Restore position and rotation to prevent high collision offset
transForm.position = physics.position;
transForm.rotation = physics.rotation;
// 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) == false)
{
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);
// Event
demolitionEvent.InvokeLocalEvent(this);
RFDemolitionEvent.InvokeGlobalEvent(this);
// Destroy demolished object
RayfireMan.DestroyFragment(this, rootParent);
// Timestamp
// float t2 = Time.realtimeSinceStartup;
// Debug.Log (t2 - t1);
// Profiler.EndSample();
}
// Demolish object to reference
public static bool DemolishReference(RayfireRigid scr)
{
if (scr.demolitionType == DemolitionType.ReferenceDemolition)
{
// Get instance
GameObject referenceGo = scr.referenceDemolition.GetReference();
// Has reference
if (referenceGo != null)
{
// Instantiate turned off reference
bool refState = referenceGo.activeSelf;
referenceGo.SetActive(false);
GameObject fragRoot = scr.InstantiateGo(referenceGo);
referenceGo.SetActive(refState);
fragRoot.name = referenceGo.name;
// Set tm
scr.rootChild = fragRoot.transform;
scr.rootChild.position = scr.transForm.position;
scr.rootChild.rotation = scr.transForm.rotation;
scr.rootChild.transform.parent = RayfireMan.inst.transForm;
// Clear list for fragments
scr.fragments = new List <RayfireRigid>();
// Check root for rigid props
RayfireRigid rootScr = fragRoot.gameObject.GetComponent <RayfireRigid>();
// Reference Root has not rigid. Add to
if (rootScr == null && scr.referenceDemolition.addRigid == true)
{
// Add rigid and copy
rootScr = fragRoot.gameObject.AddComponent <RayfireRigid>();
rootScr.initialization = RayfireRigid.InitType.AtStart;
scr.CopyPropertiesTo(rootScr);
// Copy particles
RFParticles.CopyParticles(scr, rootScr);
// Single mesh TODO improve
if (fragRoot.transform.childCount == 0)
{
rootScr.objectType = ObjectType.Mesh;
}
// Multiple meshes
if (fragRoot.transform.childCount > 0)
{
rootScr.objectType = ObjectType.MeshRoot;
}
}
// Activate and init rigid
scr.rootChild.gameObject.SetActive(true);
// Reference has rigid
if (rootScr != null)
{
// Create rigid for root children
if (rootScr.objectType == ObjectType.MeshRoot)
{
for (int i = 0; i < rootScr.fragments.Count; i++)
{
rootScr.fragments[i].limitations.currentDepth++;
}
scr.fragments.AddRange(rootScr.fragments);
scr.DestroyRigid(rootScr);
}
// Get ref rigid
else if (rootScr.objectType == ObjectType.Mesh ||
rootScr.objectType == ObjectType.SkinnedMesh)
{
rootScr.meshDemolition.runtimeCaching.type = CachingType.Disable;
RFDemolitionMesh.DemolishMesh(rootScr);
// TODO COPY MESH DATA FROM ROOTSCR TO THIS TO REUSE
scr.fragments.AddRange(rootScr.fragments);
RayfireMan.DestroyFragment(rootScr, rootScr.rootParent, 1f);
}
// Get ref rigid
else if (rootScr.objectType == ObjectType.NestedCluster ||
rootScr.objectType == ObjectType.ConnectedCluster)
{
rootScr.Default();
rootScr.limitations.contactPoint = scr.limitations.contactPoint;
RFDemolitionCluster.DemolishCluster(rootScr);
rootScr.physics.exclude = true;
scr.fragments.AddRange(rootScr.fragments);
RayfireMan.DestroyFragment(rootScr, rootScr.rootParent, 1f);
}
// Has rigid by has No fragments. Stop demolition
if (scr.HasFragments == false)
{
scr.demolitionType = DemolitionType.None;
return(false);
}
}
}
// Has no rigid, has No fragments, but demolished
scr.limitations.demolished = true;
}
return(true);
}
// Demolish object to reference
public static bool DemolishReference(RayfireRigid scr)
{
if (scr.demolitionType == DemolitionType.ReferenceDemolition)
{
// Demolished
scr.limitations.demolished = true;
// Turn off original
scr.gameObject.SetActive(false);
// Get instance
GameObject refGo = scr.referenceDemolition.GetReference();
// Has no reference
if (refGo == null)
{
return(true);
}
// Instantiate turned off reference with null parent
GameObject instGo = Object.Instantiate(refGo, scr.transForm.position, scr.transForm.rotation);
instGo.name = refGo.name;
// Set root to manager or to the same parent
if (RayfireMan.inst != null && RayfireMan.inst.advancedDemolitionProperties.parent == RFManDemolition.FragmentParentType.Manager)
{
instGo.transform.parent = RayfireMan.inst.transform;
}
else
{
instGo.transform.parent = scr.transForm.parent;
}
// Set tm
scr.rootChild = instGo.transform;
// Copy scale
if (scr.referenceDemolition.inheritScale == true)
{
scr.rootChild.localScale = scr.transForm.localScale;
}
// Clear list for fragments
scr.fragments = new List <RayfireRigid>();
// Check root for rigid props
RayfireRigid refScr = instGo.gameObject.GetComponent <RayfireRigid>();
// Reference Root has not rigid. Add to
if (refScr == null && scr.referenceDemolition.addRigid == true)
{
// Add rigid and copy
refScr = instGo.gameObject.AddComponent <RayfireRigid>();
// Copy rigid
scr.CopyPropertiesTo(refScr);
// Copy particles
RFParticles.CopyParticles(scr, refScr);
// Single mesh TODO improve
if (instGo.transform.childCount == 0)
{
refScr.objectType = ObjectType.Mesh;
}
// Multiple meshes
if (instGo.transform.childCount > 0)
{
refScr.objectType = ObjectType.MeshRoot;
}
}
// Activate and init rigid
instGo.transform.gameObject.SetActive(true);
// Reference has rigid
if (refScr != null)
{
// Init if not initialized yet
refScr.Initialize();
// Create rigid for root children
if (refScr.objectType == ObjectType.MeshRoot)
{
for (int i = 0; i < refScr.fragments.Count; i++)
{
refScr.fragments[i].limitations.currentDepth++;
}
scr.fragments.AddRange(refScr.fragments);
scr.DestroyRigid(refScr);
}
// Get ref rigid
else if (refScr.objectType == ObjectType.Mesh ||
refScr.objectType == ObjectType.SkinnedMesh)
{
refScr.meshDemolition.runtimeCaching.type = CachingType.Disable;
RFDemolitionMesh.DemolishMesh(refScr);
// TODO COPY MESH DATA FROM ROOTSCR TO THIS TO REUSE
scr.fragments.AddRange(refScr.fragments);
RayfireMan.DestroyFragment(refScr, refScr.rootParent, 1f);
}
// Get ref rigid
else if (refScr.objectType == ObjectType.NestedCluster ||
refScr.objectType == ObjectType.ConnectedCluster)
{
refScr.Default();
// Copy contact data
refScr.limitations.contactPoint = scr.limitations.contactPoint;
refScr.limitations.contactVector3 = scr.limitations.contactVector3;
refScr.limitations.contactNormal = scr.limitations.contactNormal;
// Demolish
RFDemolitionCluster.DemolishCluster(refScr);
// Collect new fragments
scr.fragments.AddRange(refScr.fragments);
//refScr.physics.exclude = true;
//RayfireMan.DestroyFragment (refScr, refScr.rootParent, 1f);
}
}
}
return(true);
}
