/// <summary>
/// deactivate this fragment piece
/// </summary>
public void Deactivate()
{
if (activePlayback == audioSource)
{
activePlayback = null;
}
Sleep();
ExploderUtils.SetActiveRecursively(gameObject, false);
Visible = false;
IsActive = false;
if (meshFilter && meshFilter.sharedMesh)
{
DestroyImmediate(meshFilter.sharedMesh, true);
}
// turn off particles
if (particleSystems != null)
{
foreach (var psystem in particleSystems)
{
psystem.Clear();
}
}
}
/// <summary>
/// create pool (array) of fragment game objects with all necessary components
/// </summary>
/// <param name="poolSize">number of fragments</param>
/// <param name="useMeshColliders">use mesh colliders</param>
/// <param name="use2dCollision">enable Unity 2D collision system</param>
public void Allocate(int poolSize, bool useMeshColliders, bool use2dCollision, bool useGravity)
{
ExploderUtils.Assert(poolSize > 0, "");
if (pool == null || pool.Length < poolSize || useMeshColliders != this.meshColliders)
{
DestroyFragments();
pool = new Fragment[poolSize];
this.meshColliders = useMeshColliders;
for (int i = 0; i < poolSize; i++)
{
var fragment = new GameObject("fragment_" + i);
fragment.AddComponent <MeshFilter>();
fragment.AddComponent <MeshRenderer>();
if (use2dCollision)
{
#if PHYSICS_2D
fragment.AddComponent <PolygonCollider2D>();
fragment.AddComponent <Rigidbody2D>();
#endif
}
else
{
if (useMeshColliders)
{
var meshCollider = fragment.AddComponent <MeshCollider>();
meshCollider.convex = true;
}
else
{
fragment.AddComponent <BoxCollider>();
}
Rigidbody rb = fragment.AddComponent <Rigidbody>();
rb.useGravity = useGravity;
}
fragment.AddComponent <ExploderOption>();
var fragmentComponent = fragment.AddComponent <Fragment>();
fragment.transform.parent = gameObject.transform;
pool[i] = fragmentComponent;
ExploderUtils.SetActiveRecursively(fragment.gameObject, false);
fragmentComponent.RefreshComponentsCache();
fragmentComponent.Sleep();
}
}
}
public long Explode()
{
int count = this.pool.Count;
int index = 0;
if (count == 0)
{
return(0);
}
this.watch.Start();
if (this.parameters.Callback != null)
{
this.parameters.Callback(0.0f, ExploderObject.ExplosionState.ExplosionStarted);
}
Vector3 vector3 = Vector3.get_zero();
Quaternion quaternion = Quaternion.get_identity();
if (Object.op_Implicit((Object)this.originalObject))
{
vector3 = Vector3.op_Subtraction(this.originalObject.get_transform().get_position(), this.initPos);
quaternion = Quaternion.op_Multiply(this.originalObject.get_transform().get_rotation(), Quaternion.Inverse(this.initRot));
}
while (index < count)
{
Fragment fragment = this.pool[index];
++index;
if (Object.op_Inequality((Object)this.originalObject, (Object)this.parameters.ExploderGameObject))
{
ExploderUtils.SetActiveRecursively(this.originalObject, false);
}
else
{
ExploderUtils.EnableCollider(this.originalObject, false);
ExploderUtils.SetVisible(this.originalObject, false);
}
Transform transform1 = ((Component)fragment).get_transform();
transform1.set_position(Vector3.op_Addition(transform1.get_position(), vector3));
Transform transform2 = ((Component)fragment).get_transform();
transform2.set_rotation(Quaternion.op_Multiply(transform2.get_rotation(), quaternion));
fragment.Explode(this.parameters);
}
if (this.parameters.DestroyOriginalObject && Object.op_Implicit((Object)this.originalObject) && !Object.op_Implicit((Object)this.originalObject.GetComponent <Fragment>()))
{
Object.Destroy((Object)this.originalObject);
}
if (this.parameters.ExplodeSelf && !this.parameters.DestroyOriginalObject)
{
ExploderUtils.SetActiveRecursively(this.parameters.ExploderGameObject, false);
}
if (this.parameters.HideSelf)
{
ExploderUtils.SetActiveRecursively(this.parameters.ExploderGameObject, false);
}
this.watch.Stop();
return(this.watch.ElapsedMilliseconds);
}
/// <summary>
/// this is called from exploder class to start the explosion
/// </summary>
public void Explode()
{
activeObj = true;
ExploderUtils.SetActiveRecursively(gameObject, true);
visibilityCheckTimer = 0.1f;
visible = true;
deactivateTimer = deactivateTimeout;
originalScale = transform.localScale;
if (explodable)
{
tag = ExploderObject.Tag;
}
}
public static void SetActiveRecursively(GameObject obj, bool status)
{
if (!Object.op_Implicit((Object)obj))
{
return;
}
int childCount = obj.get_transform().get_childCount();
for (int index = 0; index < childCount; ++index)
{
ExploderUtils.SetActiveRecursively(((Component)obj.get_transform().GetChild(index)).get_gameObject(), status);
}
obj.SetActive(status);
}
public void Explode(ExploderParams parameters)
{
this.settings = parameters;
this.IsActive = true;
ExploderUtils.SetActiveRecursively(((Component)this).get_gameObject(), true);
this.visibilityCheckTimer = 0.1f;
this.Visible = true;
this.Cracked = false;
this.collided = false;
this.deactivateTimer = this.settings.FragmentDeactivation.DeactivateTimeout;
this.originalScale = ((Component)this).get_transform().get_localScale();
if (this.settings.FragmentOptions.ExplodeFragments)
{
((Component)this).set_tag(ExploderObject.Tag);
}
this.Emit(true);
}
/// <summary>
/// this is called from exploder class to start the explosion
/// </summary>
public void Explode(ExploderParams parameters)
{
this.settings = parameters;
IsActive = true;
ExploderUtils.SetActiveRecursively(gameObject, true);
visibilityCheckTimer = 0.1f;
Visible = true;
Cracked = false;
collided = false;
deactivateTimer = settings.FragmentDeactivation.DeactivateTimeout;
originalScale = transform.localScale;
if (settings.FragmentOptions.ExplodeFragments)
{
tag = ExploderObject.Tag;
}
Emit(true);
}
public void Deactivate()
{
if (Object.op_Equality((Object)Fragment.activePlayback, (Object)this.audioSource))
{
Fragment.activePlayback = (AudioSource)null;
}
this.Sleep();
ExploderUtils.SetActiveRecursively(((Component)this).get_gameObject(), false);
this.Visible = false;
this.IsActive = false;
if (Object.op_Implicit((Object)this.meshFilter) && Object.op_Implicit((Object)this.meshFilter.get_sharedMesh()))
{
Object.DestroyImmediate((Object)this.meshFilter.get_sharedMesh(), true);
}
if (this.particleSystems == null)
{
return;
}
foreach (ParticleSystem particleSystem in this.particleSystems)
{
particleSystem.Clear();
}
}
void Update()
{
if (activeObj)
{
if (deactivateOptions == DeactivateOptions.DeactivateTimeout)
{
deactivateTimer -= Time.deltaTime;
if (deactivateTimer < 0.0f)
{
Sleep();
activeObj = false;
ExploderUtils.SetActiveRecursively(gameObject, false);
// return fragment to previous fadout state
switch (fadeoutOptions)
{
case FadeoutOptions.Fadeout:
break;
}
}
else
{
var t = deactivateTimer / deactivateTimeout;
switch (fadeoutOptions)
{
case FadeoutOptions.Fadeout:
if (meshRenderer.material && meshRenderer.material.HasProperty("_Color"))
{
var color = meshRenderer.material.color;
color.a = t;
meshRenderer.material.color = color;
}
break;
case FadeoutOptions.ScaleDown:
gameObject.transform.localScale = originalScale * t;
break;
}
}
}
visibilityCheckTimer -= Time.deltaTime;
if (visibilityCheckTimer < 0.0f)
{
var viewportPoint = UnityEngine.Camera.main.WorldToViewportPoint(transform.position);
if (viewportPoint.z < 0 || viewportPoint.x < 0 || viewportPoint.y < 0 ||
viewportPoint.x > 1 || viewportPoint.y > 1)
{
if (deactivateOptions == DeactivateOptions.DeactivateOutsideOfCamera)
{
Sleep();
activeObj = false;
ExploderUtils.SetActiveRecursively(gameObject, false);
}
visible = false;
}
else
{
visible = true;
}
visibilityCheckTimer = Random.Range(0.1f, 0.3f);
if (explodable)
{
var size = GetComponent <Collider>().bounds.size;
if (Mathf.Max(size.x, size.y, size.z) < minSizeToExplode)
{
tag = string.Empty;
}
}
}
}
}
public long Explode()
{
var count = pool.Count;
var poolIdx = 0;
if (count == 0)
{
return(0);
}
watch.Start();
if (parameters.Callback != null)
{
parameters.Callback(0, ExploderObject.ExplosionState.ExplosionStarted);
}
var diffPos = Vector3.zero;
var diffRot = Quaternion.identity;
if (originalObject)
{
diffPos = originalObject.transform.position - initPos;
diffRot = originalObject.transform.rotation * Quaternion.Inverse(initRot);
}
while (poolIdx < count)
{
var fragment = pool[poolIdx];
poolIdx++;
if (originalObject != parameters.ExploderGameObject)
{
ExploderUtils.SetActiveRecursively(originalObject, false);
}
else
{
ExploderUtils.EnableCollider(originalObject, false);
ExploderUtils.SetVisible(originalObject, false);
}
fragment.transform.position += diffPos;
fragment.transform.rotation *= diffRot;
fragment.Explode();
}
if (parameters.DestroyOriginalObject)
{
if (originalObject && !originalObject.GetComponent <Fragment>())
{
GameObject.Destroy(originalObject);
}
}
if (parameters.ExplodeSelf)
{
if (!parameters.DestroyOriginalObject)
{
ExploderUtils.SetActiveRecursively(parameters.ExploderGameObject, false);
}
}
if (parameters.HideSelf)
{
ExploderUtils.SetActiveRecursively(parameters.ExploderGameObject, false);
}
watch.Stop();
return(watch.ElapsedMilliseconds);
}
public override bool Run(float frameBudget)
{
var count = core.pool.Count;
while (core.poolIdx < count)
{
var fragment = core.pool[core.poolIdx];
var mesh = core.postList[core.poolIdx];
core.poolIdx++;
if (!mesh.original)
{
continue;
}
var unityMesh = mesh.mesh.ToUnityMesh();
fragment.meshFilter.sharedMesh = unityMesh;
// choose proper material
if (mesh.option && mesh.option.FragmentMaterial)
{
fragment.meshRenderer.sharedMaterial = mesh.option.FragmentMaterial;
}
else
{
if (core.parameters.FragmentOptions.FragmentMaterial != null)
{
fragment.meshRenderer.sharedMaterial = core.parameters.FragmentOptions.FragmentMaterial;
}
else
{
fragment.meshRenderer.sharedMaterial = mesh.material;
}
}
unityMesh.RecalculateBounds();
var oldParent = fragment.transform.parent;
fragment.transform.parent = mesh.parent;
fragment.transform.position = mesh.position;
fragment.transform.rotation = mesh.rotation;
fragment.transform.localScale = mesh.localScale;
fragment.transform.parent = null;
fragment.transform.parent = oldParent;
if (core.parameters.PartialExplosion)
{
}
else
{
if (mesh.original != core.parameters.ExploderGameObject)
{
ExploderUtils.SetActiveRecursively(mesh.original, false);
}
else
{
ExploderUtils.EnableCollider(mesh.original, false);
ExploderUtils.SetVisible(mesh.original, false);
}
if (mesh.skinnedOriginal && mesh.skinnedOriginal != core.parameters.ExploderGameObject)
{
ExploderUtils.SetActiveRecursively(mesh.skinnedOriginal, false);
}
else
{
ExploderUtils.EnableCollider(mesh.skinnedOriginal, false);
ExploderUtils.SetVisible(mesh.skinnedOriginal, false);
}
if (mesh.skinnedOriginal && mesh.bakeObject)
{
GameObject.DestroyObject(mesh.bakeObject, 1);
}
}
var plane = mesh.option && mesh.option.Plane2D;
var use2d = core.parameters.Use2DCollision;
if (!core.parameters.FragmentOptions.DisableColliders)
{
if (core.parameters.MeshColliders && !use2d)
{
// dont use mesh colliders for 2d plane
if (!plane)
{
fragment.meshCollider.sharedMesh = unityMesh;
}
}
else
{
if (core.parameters.Use2DCollision)
{
MeshUtils.GeneratePolygonCollider(fragment.polygonCollider2D, unityMesh);
}
else
{
fragment.boxCollider.center = unityMesh.bounds.center;
fragment.boxCollider.size = unityMesh.bounds.extents;
}
}
}
if (mesh.option)
{
mesh.option.DuplicateSettings(fragment.options);
}
fragment.Explode();
var force = core.parameters.Force;
if (mesh.option && mesh.option.UseLocalForce)
{
force = mesh.option.Force;
}
// apply force to rigid body
fragment.ApplyExplosion(mesh.transform, mesh.mesh.centroid, core.parameters.Position, core.parameters.FragmentOptions, core.parameters.UseForceVector,
core.parameters.ForceVector, force, mesh.original, core.parameters.TargetFragments);
#if SHOW_DEBUG_LINES
UnityEngine.Debug.DrawLine(settings.Position, forceVector * settings.Force, Color.yellow, 3);
#endif
if (Watch.ElapsedMilliseconds > frameBudget)
{
return(false);
}
}
if (core.parameters.DestroyOriginalObject)
{
foreach (var mesh in core.postList)
{
if (mesh.original && !mesh.original.GetComponent <Fragment>())
{
Object.Destroy(mesh.original);
}
if (mesh.skinnedOriginal)
{
Object.Destroy(mesh.skinnedOriginal);
}
}
}
if (core.parameters.ExplodeSelf)
{
if (!core.parameters.DestroyOriginalObject)
{
ExploderUtils.SetActiveRecursively(core.parameters.ExploderGameObject, false);
}
}
if (core.parameters.HideSelf)
{
ExploderUtils.SetActiveRecursively(core.parameters.ExploderGameObject, false);
}
#if DBG
ExploderUtils.Log("Explosion finished! " + postList.Count + postList[0].original.transform.gameObject.name);
#endif
// core.exploder.OnExplosionFinished(true);
Watch.Stop();
return(true);
}
void Update()
{
if (activeObj)
{
//
// clamp velocity
//
if (rigidBody)
{
if (rigidBody.velocity.sqrMagnitude > maxVelocity * maxVelocity)
{
var vel = rigidBody.velocity.normalized;
rigidBody.velocity = vel * maxVelocity;
}
}
else if (rigid2D)
{
if (rigid2D.velocity.sqrMagnitude > maxVelocity * maxVelocity)
{
var vel = rigid2D.velocity.normalized;
rigid2D.velocity = vel * maxVelocity;
}
}
if (deactivateOptions == DeactivateOptions.Timeout)
{
deactivateTimer -= Time.deltaTime;
if (deactivateTimer < 0.0f)
{
Sleep();
activeObj = false;
ExploderUtils.SetActiveRecursively(gameObject, false);
// return fragment to previous fadout state
switch (fadeoutOptions)
{
case FadeoutOptions.FadeoutAlpha:
break;
}
}
else
{
var t = deactivateTimer / deactivateTimeout;
if (emmiters != null)
{
foreach (var emitter in emmiters)
{
for (int i = 0; i < emitter.particles.Length; i++)
{
var c = emitter.particles[i].color;
c.a = 1.0f - t;
emitter.particles[i].color = c;
}
}
}
switch (fadeoutOptions)
{
case FadeoutOptions.FadeoutAlpha:
if (meshRenderer.material && meshRenderer.material.HasProperty("_Color"))
{
var color = meshRenderer.material.color;
color.a = t;
meshRenderer.material.color = color;
}
break;
case FadeoutOptions.ScaleDown:
gameObject.transform.localScale = originalScale * t;
break;
}
}
}
// emmiter timeout
if (stopEmitOnTimeout)
{
emmitersTimeout -= Time.deltaTime;
if (emmitersTimeout < 0.0f)
{
// turn off particles
if (particleChild != null)
{
var emiter = particleChild.GetComponentInChildren <ParticleEmitter>();
if (emiter)
{
emiter.emit = false;
}
}
stopEmitOnTimeout = false;
}
}
visibilityCheckTimer -= Time.deltaTime;
if (visibilityCheckTimer < 0.0f && UnityEngine.Camera.main)
{
var viewportPoint = UnityEngine.Camera.main.WorldToViewportPoint(transform.position);
if (viewportPoint.z < 0 || viewportPoint.x < 0 || viewportPoint.y < 0 ||
viewportPoint.x > 1 || viewportPoint.y > 1)
{
if (deactivateOptions == DeactivateOptions.OutsideOfCamera)
{
Sleep();
activeObj = false;
ExploderUtils.SetActiveRecursively(gameObject, false);
}
visible = false;
}
else
{
visible = true;
}
visibilityCheckTimer = Random.Range(0.1f, 0.3f);
if (explodable)
{
var size = GetComponent <Collider>().bounds.size;
if (Mathf.Max(size.x, size.y, size.z) < minSizeToExplode)
{
tag = string.Empty;
}
}
}
}
}
/// <summary>
/// create pool (array) of fragment game objects with all necessary components
/// </summary>
/// <param name="poolSize">number of fragments</param>
/// <param name="useMeshColliders">use mesh colliders</param>
/// <param name="use2dCollision">enable Unity 2D collision system</param>
public void Allocate(int poolSize, bool useMeshColliders, bool use2dCollision)
{
ExploderUtils.Assert(poolSize > 0, "");
if (pool == null || pool.Length < poolSize || useMeshColliders != this.meshColliders)
{
// if (useMeshColliders != meshColliders)
// {
// Debug.LogWarning("Re-allocating pool, mesh colliders");
// }
DestroyFragments();
pool = new Fragment[poolSize];
this.meshColliders = useMeshColliders;
GameObject fragmentPrefab = null;
var fragmentInScene = GameObject.FindObjectOfType <Fragment>();
if (fragmentInScene)
{
fragmentPrefab = fragmentInScene.gameObject;
}
else
{
var fragmentResource = Resources.Load("ExploderFragment");
if (fragmentResource)
{
fragmentPrefab = Instantiate(fragmentResource) as GameObject;
}
}
for (int i = 0; i < poolSize; i++)
{
GameObject fragment = null;
if (fragmentPrefab)
{
fragment = Instantiate(fragmentPrefab) as GameObject;
fragment.name = "fragment_" + i;
}
else
{
fragment = new GameObject("fragment_" + i);
}
fragment.AddComponent <MeshFilter>();
fragment.AddComponent <MeshRenderer>();
if (use2dCollision)
{
fragment.AddComponent <PolygonCollider2D>();
fragment.AddComponent <Rigidbody2D>();
}
else
{
if (useMeshColliders)
{
var meshCollider = fragment.AddComponent <MeshCollider>();
meshCollider.convex = true;
}
else
{
fragment.AddComponent <BoxCollider>();
}
fragment.AddComponent <Rigidbody>();
}
fragment.AddComponent <ExploderOption>();
var fragmentComponent = fragment.GetComponent <Fragment>();
if (!fragmentComponent)
{
fragmentComponent = fragment.AddComponent <Fragment>();
}
fragment.transform.parent = gameObject.transform;
pool[i] = fragmentComponent;
ExploderUtils.SetActiveRecursively(fragment.gameObject, false);
fragmentComponent.RefreshComponentsCache();
fragmentComponent.Sleep();
}
}
}
public override bool Run(float frameBudget)
{
if (crackedObject == null)
{
return(true);
}
var count = crackedObject.pool.Count;
while (core.poolIdx < count)
{
var fragment = crackedObject.pool[core.poolIdx];
var mesh = core.postList[core.poolIdx];
core.poolIdx++;
if (!mesh.original)
{
continue;
}
ExploderUtils.SetActiveRecursively(fragment.gameObject, false);
var unityMesh = mesh.mesh.ToUnityMesh();
fragment.meshFilter.sharedMesh = unityMesh;
// choose proper material
if (mesh.option && mesh.option.FragmentMaterial)
{
fragment.meshRenderer.sharedMaterial = mesh.option.FragmentMaterial;
}
else
{
if (core.parameters.FragmentOptions.FragmentMaterial != null)
{
fragment.meshRenderer.sharedMaterial = core.parameters.FragmentOptions.FragmentMaterial;
}
else
{
fragment.meshRenderer.sharedMaterial = mesh.material;
}
}
unityMesh.RecalculateBounds();
var oldParent = fragment.transform.parent;
fragment.transform.parent = mesh.parent;
fragment.transform.position = mesh.position;
fragment.transform.rotation = mesh.rotation;
fragment.transform.localScale = mesh.localScale;
fragment.transform.parent = null;
fragment.transform.parent = oldParent;
fragment.cracked = true;
var plane = mesh.option && mesh.option.Plane2D;
var use2d = core.parameters.Use2DCollision;
if (!core.parameters.FragmentOptions.DisableColliders)
{
if (core.parameters.MeshColliders && !use2d)
{
// dont use mesh colliders for 2d plane
if (!plane)
{
fragment.meshCollider.sharedMesh = unityMesh;
}
}
else
{
if (core.parameters.Use2DCollision)
{
MeshUtils.GeneratePolygonCollider(fragment.polygonCollider2D, unityMesh);
}
else
{
fragment.boxCollider.center = unityMesh.bounds.center;
fragment.boxCollider.size = unityMesh.bounds.extents;
}
}
}
if (mesh.option)
{
mesh.option.DuplicateSettings(fragment.options);
}
var force = core.parameters.Force;
if (mesh.option && mesh.option.UseLocalForce)
{
force = mesh.option.Force;
}
// apply force to rigid body
fragment.ApplyExplosion(mesh.transform, mesh.mesh.centroid, core.parameters.Position, core.parameters.FragmentOptions, core.parameters.UseForceVector,
core.parameters.ForceVector, force, mesh.original, core.parameters.TargetFragments);
#if SHOW_DEBUG_LINES
UnityEngine.Debug.DrawLine(settings.Position, forceVector * settings.Force, Color.yellow, 3);
#endif
if (Watch.ElapsedMilliseconds > frameBudget)
{
return(false);
}
}
Watch.Stop();
return(true);
}
public override bool Run(float frameBudget)
{
int count = this.core.pool.Count;
while (this.core.poolIdx < count)
{
Fragment fragment = this.core.pool[this.core.poolIdx];
MeshObject post = this.core.postList[this.core.poolIdx];
++this.core.poolIdx;
if (Object.op_Implicit((Object)post.original))
{
Mesh unityMesh = post.mesh.ToUnityMesh();
fragment.AssignMesh(unityMesh);
if (Object.op_Implicit((Object)post.option) && Object.op_Implicit((Object)post.option.FragmentMaterial))
{
((Renderer)fragment.meshRenderer).set_sharedMaterial(post.option.FragmentMaterial);
}
else if (Object.op_Inequality((Object)this.core.parameters.FragmentOptions.FragmentMaterial, (Object)null))
{
((Renderer)fragment.meshRenderer).set_sharedMaterial(this.core.parameters.FragmentOptions.FragmentMaterial);
}
else
{
((Renderer)fragment.meshRenderer).set_sharedMaterial(post.material);
}
unityMesh.RecalculateBounds();
Transform parent = ((Component)fragment).get_transform().get_parent();
((Component)fragment).get_transform().set_parent(post.parent);
((Component)fragment).get_transform().set_position(post.position);
((Component)fragment).get_transform().set_rotation(post.rotation);
((Component)fragment).get_transform().set_localScale(post.localScale);
((Component)fragment).get_transform().set_parent((Transform)null);
((Component)fragment).get_transform().set_parent(parent);
if (Object.op_Inequality((Object)post.original, (Object)this.core.parameters.ExploderGameObject))
{
ExploderUtils.SetActiveRecursively(post.original, false);
}
else
{
ExploderUtils.EnableCollider(post.original, false);
ExploderUtils.SetVisible(post.original, false);
}
if (Object.op_Implicit((Object)post.skinnedOriginal) && Object.op_Inequality((Object)post.skinnedOriginal, (Object)this.core.parameters.ExploderGameObject))
{
ExploderUtils.SetActiveRecursively(post.skinnedOriginal, false);
}
else
{
ExploderUtils.EnableCollider(post.skinnedOriginal, false);
ExploderUtils.SetVisible(post.skinnedOriginal, false);
}
if (Object.op_Implicit((Object)post.skinnedOriginal) && Object.op_Implicit((Object)post.bakeObject))
{
Object.Destroy((Object)post.bakeObject, 1f);
}
bool flag = Object.op_Implicit((Object)post.option) && post.option.Plane2D;
bool use2Dcollision = this.core.parameters.Use2DCollision;
if (!this.core.parameters.FragmentOptions.DisableColliders)
{
if (this.core.parameters.FragmentOptions.MeshColliders && !use2Dcollision)
{
if (!flag)
{
fragment.meshCollider.set_sharedMesh(unityMesh);
}
}
else if (this.core.parameters.Use2DCollision)
{
MeshUtils.GeneratePolygonCollider(fragment.polygonCollider2D, unityMesh);
}
else
{
BoxCollider boxCollider1 = fragment.boxCollider;
Bounds bounds1 = unityMesh.get_bounds();
Vector3 center = ((Bounds) ref bounds1).get_center();
boxCollider1.set_center(center);
BoxCollider boxCollider2 = fragment.boxCollider;
Bounds bounds2 = unityMesh.get_bounds();
Vector3 extents = ((Bounds) ref bounds2).get_extents();
boxCollider2.set_size(extents);
}
}
fragment.Explode(this.core.parameters);
float force = this.core.parameters.Force;
if (Object.op_Implicit((Object)post.option) && post.option.UseLocalForce)
{
force = post.option.Force;
}
fragment.ApplyExplosion(post.transform, post.mesh.centroid, force, post.original, this.core.parameters);
if ((double)this.Watch.ElapsedMilliseconds > (double)frameBudget)
{
return(false);
}
}
}
if (this.core.parameters.DestroyOriginalObject)
{
foreach (MeshObject post in this.core.postList)
{
if (Object.op_Implicit((Object)post.original) && !Object.op_Implicit((Object)post.original.GetComponent <Fragment>()))
{
Object.Destroy((Object)post.original);
}
if (Object.op_Implicit((Object)post.skinnedOriginal))
{
Object.Destroy((Object)post.skinnedOriginal);
}
}
}
if (this.core.parameters.ExplodeSelf && !this.core.parameters.DestroyOriginalObject)
{
ExploderUtils.SetActiveRecursively(this.core.parameters.ExploderGameObject, false);
}
if (this.core.parameters.HideSelf)
{
ExploderUtils.SetActiveRecursively(this.core.parameters.ExploderGameObject, false);
}
this.Watch.Stop();
return(true);
}
public void Allocate(int poolSize, bool useMeshColliders, bool use2dCollision)
{
if (this.pool != null && this.pool.Length >= poolSize && useMeshColliders == this.meshColliders)
{
return;
}
this.DestroyFragments();
this.pool = new Fragment[poolSize];
this.meshColliders = useMeshColliders;
GameObject gameObject1 = (GameObject)null;
Fragment objectOfType = (Fragment)Object.FindObjectOfType <Fragment>();
if (Object.op_Implicit((Object)objectOfType))
{
gameObject1 = ((Component)objectOfType).get_gameObject();
}
else
{
Object @object = Resources.Load("ExploderFragment");
if (Object.op_Implicit(@object))
{
gameObject1 = Object.Instantiate(@object) as GameObject;
}
}
for (int index = 0; index < poolSize; ++index)
{
GameObject gameObject2;
if (Object.op_Implicit((Object)gameObject1))
{
gameObject2 = (GameObject)Object.Instantiate <GameObject>((M0)gameObject1);
((Object)gameObject2).set_name("fragment_" + (object)index);
}
else
{
gameObject2 = new GameObject("fragment_" + (object)index);
}
gameObject2.AddComponent <MeshFilter>();
gameObject2.AddComponent <MeshRenderer>();
if (use2dCollision)
{
gameObject2.AddComponent <PolygonCollider2D>();
gameObject2.AddComponent <Rigidbody2D>();
}
else
{
if (useMeshColliders)
{
((MeshCollider)gameObject2.AddComponent <MeshCollider>()).set_convex(true);
}
else
{
gameObject2.AddComponent <BoxCollider>();
}
gameObject2.AddComponent <Rigidbody>();
}
gameObject2.AddComponent <ExploderOption>();
Fragment fragment = (Fragment)gameObject2.GetComponent <Fragment>();
if (!Object.op_Implicit((Object)fragment))
{
fragment = (Fragment)gameObject2.AddComponent <Fragment>();
}
gameObject2.get_transform().set_parent(((Component)this).get_gameObject().get_transform());
this.pool[index] = fragment;
ExploderUtils.SetActiveRecursively(gameObject2.get_gameObject(), false);
fragment.RefreshComponentsCache();
fragment.Sleep();
}
}