|
|
|
@@ -0,0 +1,978 @@
|
|
|
|
|
using System.Collections;
|
|
|
|
|
using System.Collections.Generic;
|
|
|
|
|
using UnityEngine;
|
|
|
|
|
|
|
|
|
|
/// <summary>
|
|
|
|
|
/// Runtime-fractures the attached mesh object using OpenFracture's <see cref="Fragmenter"/>,
|
|
|
|
|
/// then pushes every produced fragment toward a configurable direction so the pieces
|
|
|
|
|
/// "drift"/fly off. Call <see cref="Shatter()"/> (or <see cref="Shatter(Vector3)"/> to
|
|
|
|
|
/// override the direction) from your own gameplay code.
|
|
|
|
|
/// </summary>
|
|
|
|
|
[RequireComponent(typeof(MeshFilter))]
|
|
|
|
|
[RequireComponent(typeof(MeshRenderer))]
|
|
|
|
|
[RequireComponent(typeof(Rigidbody))]
|
|
|
|
|
public class FractureAndDrift : MonoBehaviour
|
|
|
|
|
{
|
|
|
|
|
/// <summary>
|
|
|
|
|
/// How the cut-plane normal is chosen at each subdivision step.
|
|
|
|
|
/// </summary>
|
|
|
|
|
public enum SliceMode
|
|
|
|
|
{
|
|
|
|
|
/// <summary>Original OpenFracture behaviour: random normal over the enabled axes.</summary>
|
|
|
|
|
Random,
|
|
|
|
|
/// <summary>Always cut perpendicular to the fragment's current longest axis. Best for avoiding stretched
|
|
|
|
|
/// pieces on long/thin objects, because long dimensions get subdivided first.</summary>
|
|
|
|
|
LongestAxis,
|
|
|
|
|
/// <summary>Random normal biased by <see cref="axisWeights"/>. Higher weight on an axis produces more cuts
|
|
|
|
|
/// perpendicular to it, i.e. that dimension is subdivided more finely.</summary>
|
|
|
|
|
AxisWeighted
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
[Header("Fracture")]
|
|
|
|
|
[Tooltip("Fragment count / axes / inside material. Same options used by OpenFracture's Fracture component.")]
|
|
|
|
|
public FractureOptions fractureOptions = new FractureOptions();
|
|
|
|
|
|
|
|
|
|
[Tooltip("Random = stock OpenFracture. LongestAxis = always cut the longest side first (best anti-stretch). " +
|
|
|
|
|
"AxisWeighted = bias cuts toward the axes with higher weight.")]
|
|
|
|
|
public SliceMode sliceMode = SliceMode.Random;
|
|
|
|
|
|
|
|
|
|
[Tooltip("Only used in AxisWeighted mode. Higher weight on an axis = that dimension is subdivided more (more cuts perpendicular to it). " +
|
|
|
|
|
"e.g. (3,1,1) cuts a long-X object roughly 3x more along X.")]
|
|
|
|
|
public Vector3 axisWeights = Vector3.one;
|
|
|
|
|
|
|
|
|
|
[Tooltip("Only used in LongestAxis mode. Random tilt (0..1) added to the cut plane so repeated cuts aren't perfectly parallel. 0 = perfectly axis-aligned cuts.")]
|
|
|
|
|
[Range(0f, 1f)]
|
|
|
|
|
public float longestAxisJitter = 0.15f;
|
|
|
|
|
|
|
|
|
|
[Tooltip("If true, logs what the controlled fracture actually did (source mesh stats, how many slices " +
|
|
|
|
|
"succeeded vs came back empty, final fragment count). Turn this on once to diagnose 'still big blocks'.")]
|
|
|
|
|
public bool fractureDebugLogs = false;
|
|
|
|
|
|
|
|
|
|
[Header("Drift")]
|
|
|
|
|
[Tooltip("Direction the fragments fly toward. Interpreted in the space set by 'Direction Is Local'.")]
|
|
|
|
|
public Vector3 driftDirection = Vector3.up;
|
|
|
|
|
|
|
|
|
|
[Tooltip("If true, driftDirection is relative to this object's rotation; if false it is world space.")]
|
|
|
|
|
public bool directionIsLocal = false;
|
|
|
|
|
|
|
|
|
|
[Tooltip("Base speed (m/s) applied to each fragment along the drift direction.")]
|
|
|
|
|
public float driftSpeed = 5f;
|
|
|
|
|
|
|
|
|
|
[Tooltip("Extra random speed [0..value] added on top of driftSpeed for a natural burst.")]
|
|
|
|
|
public float driftSpeedRandomness = 1.5f;
|
|
|
|
|
|
|
|
|
|
[Tooltip("Random sideways scatter (cone half-angle in degrees) around the drift direction. 0 = perfectly straight.")]
|
|
|
|
|
[Range(0f, 90f)]
|
|
|
|
|
public float scatterAngle = 15f;
|
|
|
|
|
|
|
|
|
|
[Tooltip("Extra outward push (m/s) from the fracture center, gives an explosion feel. 0 = disabled.")]
|
|
|
|
|
public float explosionSpeed = 0f;
|
|
|
|
|
|
|
|
|
|
[Tooltip("Random angular velocity (rad/s) applied so fragments tumble.")]
|
|
|
|
|
public float spinSpeed = 4f;
|
|
|
|
|
|
|
|
|
|
[Header("Source Physics")]
|
|
|
|
|
[Tooltip("If true, the source object's Rigidbody is frozen (kinematic, no gravity) until Shatter() is called. " +
|
|
|
|
|
"This stops the object from falling/jittering under physics before it breaks. Highly recommended: the " +
|
|
|
|
|
"source body is only used to compute fragment mass, it does not need to simulate before shattering.")]
|
|
|
|
|
public bool freezeSourceUntilShatter = true;
|
|
|
|
|
|
|
|
|
|
[Header("Fragment Physics")]
|
|
|
|
|
[Tooltip("If true, fragments are affected by Unity's global gravity (always straight down) after being launched. " +
|
|
|
|
|
"Ignored when 'Use Custom Gravity' is enabled.")]
|
|
|
|
|
public bool fragmentsUseGravity = true;
|
|
|
|
|
|
|
|
|
|
[Tooltip("Caps how fast PhysX may push a fragment when it resolves an overlap (depenetration). This is the REAL " +
|
|
|
|
|
"fix for fragments 'accelerating'/exploding: freshly cut convex hulls overlap each other and any nearby " +
|
|
|
|
|
"geometry, and by default PhysX separates them with an almost unlimited velocity, injecting huge energy. " +
|
|
|
|
|
"A small value (1-2) makes overlaps resolve gently. Applies regardless of collision layers/ignores.")]
|
|
|
|
|
public float maxDepenetrationVelocity = 1f;
|
|
|
|
|
|
|
|
|
|
[Tooltip("If true, the freshly spawned fragments collide with each other. Leave OFF for a clean drift: at birth " +
|
|
|
|
|
"the convex fragment hulls overlap, and Unity resolves that overlap with large depenetration impulses " +
|
|
|
|
|
"that blast the pieces apart. Ignoring sibling collisions removes that explosion.")]
|
|
|
|
|
public bool fragmentsCollideWithEachOther = false;
|
|
|
|
|
|
|
|
|
|
[Tooltip("If true, fragments will NOT collide with other, still-unshattered FractureAndDrift objects in the scene. " +
|
|
|
|
|
"Keep ON: otherwise fragments smash into the solid neighbouring objects and fly off chaotically, which is " +
|
|
|
|
|
"why earlier-triggered objects looked wrong while the last-triggered one (no solid neighbours left) drifted cleanly.")]
|
|
|
|
|
public bool ignoreOtherSourceObjects = true;
|
|
|
|
|
|
|
|
|
|
[Tooltip("If true, fragments ignore Unity's global gravity and are instead continuously pulled toward " +
|
|
|
|
|
"'Custom Gravity' every physics step. Use this to make pieces drift toward an arbitrary direction.")]
|
|
|
|
|
public bool useCustomGravity = false;
|
|
|
|
|
|
|
|
|
|
[Tooltip("Acceleration vector (m/s^2) applied to every fragment each physics step when 'Use Custom Gravity' is on. " +
|
|
|
|
|
"e.g. (0,-9.81,0) = normal down; (5,0,0) = pulled toward +X; interpreted in the space set by 'Custom Gravity Is Local'.")]
|
|
|
|
|
public Vector3 customGravity = new Vector3(0f, -9.81f, 0f);
|
|
|
|
|
|
|
|
|
|
[Tooltip("If true, 'Custom Gravity' is relative to this object's rotation at shatter time; if false it is world space.")]
|
|
|
|
|
public bool customGravityIsLocal = false;
|
|
|
|
|
|
|
|
|
|
[Header("Cleanup")]
|
|
|
|
|
[Tooltip("Fallback: if nothing calls ReclaimFragments() first, the fragments are auto-reclaimed this many " +
|
|
|
|
|
"seconds after shattering. <= 0 keeps them forever (until something calls ReclaimFragments()).")]
|
|
|
|
|
public float fragmentLifetime = 5f;
|
|
|
|
|
|
|
|
|
|
[Tooltip("When reclaiming, fragments are destroyed one-by-one spread across this many seconds instead of all " +
|
|
|
|
|
"at once. This is the 'async collect' behaviour. 0 = destroy the whole batch together.")]
|
|
|
|
|
public float reclaimStagger = 1f;
|
|
|
|
|
|
|
|
|
|
[Tooltip("If true, each fragment smoothly shrinks to nothing before being destroyed, for a graceful collect " +
|
|
|
|
|
"instead of a hard pop.")]
|
|
|
|
|
public bool reclaimShrink = true;
|
|
|
|
|
|
|
|
|
|
[Tooltip("If true, this GameObject is deactivated after shattering (mirrors OpenFracture behaviour).")]
|
|
|
|
|
public bool deactivateSourceAfterShatter = true;
|
|
|
|
|
|
|
|
|
|
[Header("Prewarm")]
|
|
|
|
|
[Tooltip("If true, the expensive mesh slicing runs asynchronously in Start(): the fragments are built up front " +
|
|
|
|
|
"and kept hidden & frozen. Shatter() then becomes a cheap, instant reveal + launch, so there is no " +
|
|
|
|
|
"slicing hitch at the moment the track breaks. Leave off to slice on-demand when Shatter() is called.")]
|
|
|
|
|
public bool prewarmFragmentsOnStart = false;
|
|
|
|
|
|
|
|
|
|
[Header("Debug")]
|
|
|
|
|
[Tooltip("If true, pressing 'Debug Key' triggers the shatter at runtime. For testing only.")]
|
|
|
|
|
public bool enableDebugKey = false;
|
|
|
|
|
|
|
|
|
|
[Tooltip("Key that triggers the shatter when 'Enable Debug Key' is on.")]
|
|
|
|
|
public KeyCode debugKey = KeyCode.F;
|
|
|
|
|
|
|
|
|
|
private GameObject fragmentRoot;
|
|
|
|
|
private FragmentReclaimer fragmentReclaimer;
|
|
|
|
|
private bool hasShattered;
|
|
|
|
|
|
|
|
|
|
// Prewarm state: when prewarmFragmentsOnStart is on, the fragments are built ahead of time and parked
|
|
|
|
|
// here (hidden + kinematic). Shatter() then just reveals & launches them instead of slicing on the spot.
|
|
|
|
|
private bool prewarmComplete;
|
|
|
|
|
private bool prewarmInProgress;
|
|
|
|
|
private Vector3 pendingLaunchDirection;
|
|
|
|
|
private bool launchPending;
|
|
|
|
|
|
|
|
|
|
// Name of the dedicated physics layer every fragment is placed on. The layer-collision matrix is
|
|
|
|
|
// configured so this layer ignores itself, giving global cross-batch fragment isolation for free.
|
|
|
|
|
private const string FragmentLayerName = "FractureFragment";
|
|
|
|
|
private static int cachedFragmentLayer = -1;
|
|
|
|
|
private static bool fragmentLayerResolved;
|
|
|
|
|
|
|
|
|
|
private void Awake()
|
|
|
|
|
{
|
|
|
|
|
if (freezeSourceUntilShatter)
|
|
|
|
|
{
|
|
|
|
|
// The source body is only needed to read mass for fragment computation. Freeze it so the
|
|
|
|
|
// object doesn't fall or jitter under physics before Shatter() is called.
|
|
|
|
|
var body = GetComponent<Rigidbody>();
|
|
|
|
|
if (body != null)
|
|
|
|
|
{
|
|
|
|
|
body.isKinematic = true;
|
|
|
|
|
body.useGravity = false;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
private void Start()
|
|
|
|
|
{
|
|
|
|
|
if (prewarmFragmentsOnStart)
|
|
|
|
|
{
|
|
|
|
|
StartCoroutine(PrewarmRoutine());
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
private void Update()
|
|
|
|
|
{
|
|
|
|
|
if (enableDebugKey && !hasShattered && Input.GetKeyDown(debugKey))
|
|
|
|
|
{
|
|
|
|
|
Shatter();
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/// <summary>
|
|
|
|
|
/// Fractures the object and launches the fragments along the configured drift direction.
|
|
|
|
|
/// </summary>
|
|
|
|
|
public void Shatter()
|
|
|
|
|
{
|
|
|
|
|
Shatter(ResolveDriftDirection());
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/// <summary>
|
|
|
|
|
/// Fractures the object and launches the fragments along <paramref name="worldDirection"/>.
|
|
|
|
|
/// </summary>
|
|
|
|
|
/// <param name="worldDirection">Direction in world space the fragments should fly toward.</param>
|
|
|
|
|
public void Shatter(Vector3 worldDirection)
|
|
|
|
|
{
|
|
|
|
|
if (hasShattered)
|
|
|
|
|
{
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
Vector3 direction = worldDirection.sqrMagnitude > Mathf.Epsilon
|
|
|
|
|
? worldDirection.normalized
|
|
|
|
|
: transform.up;
|
|
|
|
|
|
|
|
|
|
// Prewarm path: the expensive slicing already ran (or is running) in Start().
|
|
|
|
|
if (prewarmFragmentsOnStart)
|
|
|
|
|
{
|
|
|
|
|
if (prewarmComplete)
|
|
|
|
|
{
|
|
|
|
|
// Fragments are pre-built and parked. This is now a cheap, instant reveal + launch.
|
|
|
|
|
hasShattered = true;
|
|
|
|
|
RevealAndLaunch(direction);
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (prewarmInProgress)
|
|
|
|
|
{
|
|
|
|
|
// Slicing hasn't finished yet; remember the request and launch the moment it completes.
|
|
|
|
|
pendingLaunchDirection = direction;
|
|
|
|
|
launchPending = true;
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// Prewarm was requested but Start() hasn't run yet (or failed) — fall through to slice on-demand.
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
MeshFilter meshFilter = GetComponent<MeshFilter>();
|
|
|
|
|
if (meshFilter == null || meshFilter.sharedMesh == null)
|
|
|
|
|
{
|
|
|
|
|
Debug.LogWarning("[FractureAndDrift] No mesh to fracture.", this);
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
hasShattered = true;
|
|
|
|
|
|
|
|
|
|
CreateFragmentRoot();
|
|
|
|
|
|
|
|
|
|
GameObject fragmentTemplate = CreateFragmentTemplate();
|
|
|
|
|
|
|
|
|
|
if (sliceMode != SliceMode.Random)
|
|
|
|
|
{
|
|
|
|
|
// Custom subdivision loop that controls cut orientation to avoid stretched fragments.
|
|
|
|
|
FractureControlled(fragmentTemplate);
|
|
|
|
|
|
|
|
|
|
Destroy(fragmentTemplate);
|
|
|
|
|
LaunchFragments(direction);
|
|
|
|
|
FinishShatter();
|
|
|
|
|
}
|
|
|
|
|
else if (fractureOptions.asynchronous)
|
|
|
|
|
{
|
|
|
|
|
StartCoroutine(Fragmenter.FractureAsync(
|
|
|
|
|
gameObject,
|
|
|
|
|
fractureOptions,
|
|
|
|
|
fragmentTemplate,
|
|
|
|
|
fragmentRoot.transform,
|
|
|
|
|
() =>
|
|
|
|
|
{
|
|
|
|
|
Destroy(fragmentTemplate);
|
|
|
|
|
LaunchFragments(direction);
|
|
|
|
|
FinishShatter();
|
|
|
|
|
}));
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
Fragmenter.Fracture(
|
|
|
|
|
gameObject,
|
|
|
|
|
fractureOptions,
|
|
|
|
|
fragmentTemplate,
|
|
|
|
|
fragmentRoot.transform);
|
|
|
|
|
|
|
|
|
|
Destroy(fragmentTemplate);
|
|
|
|
|
LaunchFragments(direction);
|
|
|
|
|
FinishShatter();
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/// <summary>
|
|
|
|
|
/// Builds all fragments ahead of time in Start() and parks them hidden & inactive, so that the
|
|
|
|
|
/// actual Shatter() is a cheap reveal + launch with no slicing hitch. Runs the slicing across frames
|
|
|
|
|
/// (the async slicer yields; the controlled/sync slicers run in one frame but still off the break moment).
|
|
|
|
|
/// </summary>
|
|
|
|
|
private IEnumerator PrewarmRoutine()
|
|
|
|
|
{
|
|
|
|
|
MeshFilter meshFilter = GetComponent<MeshFilter>();
|
|
|
|
|
if (meshFilter == null || meshFilter.sharedMesh == null)
|
|
|
|
|
{
|
|
|
|
|
yield break;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
prewarmInProgress = true;
|
|
|
|
|
|
|
|
|
|
CreateFragmentRoot();
|
|
|
|
|
|
|
|
|
|
// Park the container inactive BEFORE slicing so every fragment spawns inactive and never simulates
|
|
|
|
|
// (falls/drifts) during the multi-frame prewarm. Shatter() reveals it later via SetActive(true).
|
|
|
|
|
fragmentRoot.SetActive(false);
|
|
|
|
|
|
|
|
|
|
GameObject fragmentTemplate = CreateFragmentTemplate();
|
|
|
|
|
|
|
|
|
|
if (sliceMode != SliceMode.Random)
|
|
|
|
|
{
|
|
|
|
|
FractureControlled(fragmentTemplate);
|
|
|
|
|
Destroy(fragmentTemplate);
|
|
|
|
|
}
|
|
|
|
|
else if (fractureOptions.asynchronous)
|
|
|
|
|
{
|
|
|
|
|
yield return StartCoroutine(Fragmenter.FractureAsync(
|
|
|
|
|
gameObject,
|
|
|
|
|
fractureOptions,
|
|
|
|
|
fragmentTemplate,
|
|
|
|
|
fragmentRoot.transform,
|
|
|
|
|
() => { }));
|
|
|
|
|
Destroy(fragmentTemplate);
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
Fragmenter.Fracture(
|
|
|
|
|
gameObject,
|
|
|
|
|
fractureOptions,
|
|
|
|
|
fragmentTemplate,
|
|
|
|
|
fragmentRoot.transform);
|
|
|
|
|
Destroy(fragmentTemplate);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// Container is already inactive (parked before slicing), so nothing simulated during prewarm.
|
|
|
|
|
prewarmInProgress = false;
|
|
|
|
|
prewarmComplete = true;
|
|
|
|
|
|
|
|
|
|
// If Shatter() was called while we were still slicing, honour it now.
|
|
|
|
|
if (launchPending)
|
|
|
|
|
{
|
|
|
|
|
launchPending = false;
|
|
|
|
|
hasShattered = true;
|
|
|
|
|
RevealAndLaunch(pendingLaunchDirection);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/// <summary>
|
|
|
|
|
/// Reveals the pre-built fragment container and launches its fragments. Used by the prewarm path.
|
|
|
|
|
/// </summary>
|
|
|
|
|
private void RevealAndLaunch(Vector3 direction)
|
|
|
|
|
{
|
|
|
|
|
if (fragmentRoot != null)
|
|
|
|
|
{
|
|
|
|
|
fragmentRoot.SetActive(true);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
LaunchFragments(direction);
|
|
|
|
|
FinishShatter();
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/// <summary>
|
|
|
|
|
/// Creates the collector object that holds the produced fragments (matches OpenFracture's convention).
|
|
|
|
|
/// </summary>
|
|
|
|
|
private void CreateFragmentRoot()
|
|
|
|
|
{
|
|
|
|
|
fragmentRoot = new GameObject($"{name}Fragments");
|
|
|
|
|
fragmentRoot.transform.SetParent(transform.parent);
|
|
|
|
|
fragmentRoot.transform.position = transform.position;
|
|
|
|
|
fragmentRoot.transform.rotation = transform.rotation;
|
|
|
|
|
fragmentRoot.transform.localScale = Vector3.one;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
private void FinishShatter()
|
|
|
|
|
{
|
|
|
|
|
// Attach the reclaimer to the fragment container (which stays active). It waits either for an
|
|
|
|
|
// explicit ReclaimFragments() call or, as a fallback, for fragmentLifetime to elapse, then
|
|
|
|
|
// collects the fragments asynchronously (staggered) rather than destroying them all at once.
|
|
|
|
|
if (fragmentRoot != null)
|
|
|
|
|
{
|
|
|
|
|
fragmentReclaimer = fragmentRoot.AddComponent<FragmentReclaimer>();
|
|
|
|
|
fragmentReclaimer.Configure(fragmentLifetime, reclaimStagger, reclaimShrink);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (deactivateSourceAfterShatter)
|
|
|
|
|
{
|
|
|
|
|
gameObject.SetActive(false);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/// <summary>
|
|
|
|
|
/// Begins the asynchronous, staggered collection of this track's fragments. Safe to call once the
|
|
|
|
|
/// object has shattered; a no-op otherwise. This overrides the fragmentLifetime fallback timer.
|
|
|
|
|
/// </summary>
|
|
|
|
|
public void ReclaimFragments()
|
|
|
|
|
{
|
|
|
|
|
if (fragmentReclaimer != null)
|
|
|
|
|
{
|
|
|
|
|
fragmentReclaimer.BeginReclaim();
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/// <summary>
|
|
|
|
|
/// Iterates the freshly created fragments and applies the launch velocity + spin.
|
|
|
|
|
/// </summary>
|
|
|
|
|
private void LaunchFragments(Vector3 direction)
|
|
|
|
|
{
|
|
|
|
|
if (fragmentRoot == null)
|
|
|
|
|
{
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
Vector3 center = transform.position;
|
|
|
|
|
var bodies = fragmentRoot.GetComponentsInChildren<Rigidbody>();
|
|
|
|
|
for (int i = 0; i < bodies.Length; i++)
|
|
|
|
|
{
|
|
|
|
|
Rigidbody body = bodies[i];
|
|
|
|
|
if (body == null)
|
|
|
|
|
{
|
|
|
|
|
continue;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// When custom gravity is on, disable Unity's global (down-only) gravity so the
|
|
|
|
|
// per-step custom acceleration is the only gravity acting on the fragment.
|
|
|
|
|
body.useGravity = !useCustomGravity && fragmentsUseGravity;
|
|
|
|
|
|
|
|
|
|
// Safety net: guarantee the depenetration clamp is applied to every produced body, even ones
|
|
|
|
|
// that might not have inherited it from the template (e.g. extra pieces from FindDisconnectedMeshes).
|
|
|
|
|
if (maxDepenetrationVelocity > 0f)
|
|
|
|
|
{
|
|
|
|
|
body.maxDepenetrationVelocity = maxDepenetrationVelocity;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
Vector3 launchDir = ApplyScatter(direction);
|
|
|
|
|
float speed = driftSpeed + Random.value * Mathf.Max(0f, driftSpeedRandomness);
|
|
|
|
|
Vector3 velocity = launchDir * speed;
|
|
|
|
|
|
|
|
|
|
if (explosionSpeed > 0f)
|
|
|
|
|
{
|
|
|
|
|
Vector3 fromCenter = body.worldCenterOfMass - center;
|
|
|
|
|
if (fromCenter.sqrMagnitude > Mathf.Epsilon)
|
|
|
|
|
{
|
|
|
|
|
velocity += fromCenter.normalized * explosionSpeed;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
body.linearVelocity = velocity;
|
|
|
|
|
|
|
|
|
|
if (spinSpeed > 0f)
|
|
|
|
|
{
|
|
|
|
|
body.angularVelocity = Random.insideUnitSphere * spinSpeed;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
ConfigureFragmentCollisions();
|
|
|
|
|
|
|
|
|
|
if (useCustomGravity)
|
|
|
|
|
{
|
|
|
|
|
// The source object gets deactivated after shattering, so the custom-gravity driver
|
|
|
|
|
// must live on the fragment container (which stays active) to keep applying force.
|
|
|
|
|
Vector3 gravity = customGravityIsLocal ? transform.TransformDirection(customGravity) : customGravity;
|
|
|
|
|
var driver = fragmentRoot.AddComponent<FragmentGravityField>();
|
|
|
|
|
driver.gravity = gravity;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/// <summary>
|
|
|
|
|
/// Configures fragment collisions via the physics layer-collision matrix instead of per-pair
|
|
|
|
|
/// Physics.IgnoreCollision. All fragments live on <see cref="FragmentLayerName"/>; disabling that
|
|
|
|
|
/// layer's collision with itself makes EVERY fragment ignore EVERY other fragment - same batch or a
|
|
|
|
|
/// different track's batch, at any time, with no per-collider bookkeeping. This is why the earlier
|
|
|
|
|
/// pairwise approach kept leaking cross-batch collisions: newly spawned colliders were never paired
|
|
|
|
|
/// against batches that shattered later. The matrix rule has no such ordering dependency.
|
|
|
|
|
/// </summary>
|
|
|
|
|
private void ConfigureFragmentCollisions()
|
|
|
|
|
{
|
|
|
|
|
int fragmentLayer = ResolveFragmentLayer();
|
|
|
|
|
if (fragmentLayer < 0)
|
|
|
|
|
{
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// Fragments never collide with each other (unless explicitly opted in). This is a global matrix
|
|
|
|
|
// rule, so it covers same-batch AND cross-batch (another track shattering at the same time)
|
|
|
|
|
// with no per-collider bookkeeping and no ordering dependency.
|
|
|
|
|
Physics.IgnoreLayerCollision(fragmentLayer, fragmentLayer, !fragmentsCollideWithEachOther);
|
|
|
|
|
|
|
|
|
|
if (ignoreOtherSourceObjects)
|
|
|
|
|
{
|
|
|
|
|
// Fragments ignore the still-solid source objects. Done per-collider (NOT via the layer matrix)
|
|
|
|
|
// because sources sit on shared layers like Default that the ground/platforms also use - a
|
|
|
|
|
// whole-layer ignore would let fragments fall through the floor. Per-collider keeps it precise.
|
|
|
|
|
var fragmentColliders = fragmentRoot.GetComponentsInChildren<Collider>();
|
|
|
|
|
var sources = FindObjectsByType<FractureAndDrift>(FindObjectsSortMode.None);
|
|
|
|
|
for (int s = 0; s < sources.Length; s++)
|
|
|
|
|
{
|
|
|
|
|
FractureAndDrift source = sources[s];
|
|
|
|
|
// Skip sources that already shattered - their solid collider is gone. Keep 'this' one:
|
|
|
|
|
// its collider is still active this frame and the fragments spawn right on top of it.
|
|
|
|
|
if (source == null || (source.hasShattered && source != this))
|
|
|
|
|
{
|
|
|
|
|
continue;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
var sourceCollider = source.GetComponent<Collider>();
|
|
|
|
|
if (sourceCollider == null)
|
|
|
|
|
{
|
|
|
|
|
continue;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
for (int f = 0; f < fragmentColliders.Length; f++)
|
|
|
|
|
{
|
|
|
|
|
if (fragmentColliders[f] != null)
|
|
|
|
|
{
|
|
|
|
|
Physics.IgnoreCollision(fragmentColliders[f], sourceCollider, true);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/// <summary>
|
|
|
|
|
/// Resolves the dedicated fragment layer index, caching the lookup. Returns -1 if the project has no
|
|
|
|
|
/// layer named <see cref="FragmentLayerName"/> (falls back to no layer assignment).
|
|
|
|
|
/// </summary>
|
|
|
|
|
private static int ResolveFragmentLayer()
|
|
|
|
|
{
|
|
|
|
|
if (!fragmentLayerResolved)
|
|
|
|
|
{
|
|
|
|
|
cachedFragmentLayer = LayerMask.NameToLayer(FragmentLayerName);
|
|
|
|
|
fragmentLayerResolved = true;
|
|
|
|
|
if (cachedFragmentLayer < 0)
|
|
|
|
|
{
|
|
|
|
|
Debug.LogWarning($"[FractureAndDrift] Layer '{FragmentLayerName}' not found. Add it in " +
|
|
|
|
|
"Project Settings > Tags and Layers so fragments can be isolated from collisions.");
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return cachedFragmentLayer;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/// <summary>
|
|
|
|
|
/// Rotates <paramref name="direction"/> by a random angle within the scatter cone.
|
|
|
|
|
/// </summary>
|
|
|
|
|
private Vector3 ApplyScatter(Vector3 direction)
|
|
|
|
|
{
|
|
|
|
|
if (scatterAngle <= 0f)
|
|
|
|
|
{
|
|
|
|
|
return direction;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// Random rotation within a cone of half-angle 'scatterAngle' around 'direction'.
|
|
|
|
|
float angle = Random.Range(0f, scatterAngle);
|
|
|
|
|
float roll = Random.Range(0f, 360f);
|
|
|
|
|
Quaternion cone = Quaternion.AngleAxis(angle, Vector3.right) * Quaternion.identity;
|
|
|
|
|
Quaternion spinAround = Quaternion.AngleAxis(roll, Vector3.forward);
|
|
|
|
|
Quaternion align = Quaternion.FromToRotation(Vector3.forward, direction);
|
|
|
|
|
return align * spinAround * cone * Vector3.forward;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
private Vector3 ResolveDriftDirection()
|
|
|
|
|
{
|
|
|
|
|
return directionIsLocal ? transform.TransformDirection(driftDirection) : driftDirection;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/// <summary>
|
|
|
|
|
/// Builds a template GameObject each fragment clones. Mirrors OpenFracture's Fracture.CreateFragmentTemplate.
|
|
|
|
|
/// </summary>
|
|
|
|
|
private GameObject CreateFragmentTemplate()
|
|
|
|
|
{
|
|
|
|
|
GameObject obj = new GameObject("Fragment") { tag = tag };
|
|
|
|
|
|
|
|
|
|
// Put every fragment on the dedicated fragment layer. The physics layer-collision matrix is
|
|
|
|
|
// configured (once) so this layer never collides with itself, which cleanly stops ANY fragment
|
|
|
|
|
// from colliding with ANY other fragment - same batch or a different track's batch, at any time.
|
|
|
|
|
int fragmentLayer = ResolveFragmentLayer();
|
|
|
|
|
if (fragmentLayer >= 0)
|
|
|
|
|
{
|
|
|
|
|
obj.layer = fragmentLayer;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
obj.AddComponent<MeshFilter>();
|
|
|
|
|
|
|
|
|
|
// Normal material in slot 0, cut-face material in slot 1.
|
|
|
|
|
var meshRenderer = obj.AddComponent<MeshRenderer>();
|
|
|
|
|
meshRenderer.sharedMaterials = new Material[2]
|
|
|
|
|
{
|
|
|
|
|
GetComponent<MeshRenderer>().sharedMaterial,
|
|
|
|
|
fractureOptions.insideMaterial
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
var thisCollider = GetComponent<Collider>();
|
|
|
|
|
var fragmentCollider = obj.AddComponent<MeshCollider>();
|
|
|
|
|
fragmentCollider.convex = true;
|
|
|
|
|
if (thisCollider != null)
|
|
|
|
|
{
|
|
|
|
|
fragmentCollider.sharedMaterial = thisCollider.sharedMaterial;
|
|
|
|
|
fragmentCollider.isTrigger = thisCollider.isTrigger;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
var thisRigidBody = GetComponent<Rigidbody>();
|
|
|
|
|
var fragmentRigidBody = obj.AddComponent<Rigidbody>();
|
|
|
|
|
fragmentRigidBody.linearDamping = thisRigidBody.linearDamping;
|
|
|
|
|
fragmentRigidBody.angularDamping = thisRigidBody.angularDamping;
|
|
|
|
|
fragmentRigidBody.useGravity = fragmentsUseGravity;
|
|
|
|
|
|
|
|
|
|
// Root cause of the "fragments accelerate" blast: overlapping convex hulls are separated by PhysX
|
|
|
|
|
// with a near-unlimited velocity by default. Clamp it so overlaps resolve gently instead of
|
|
|
|
|
// launching pieces. Every fragment (both fracture paths) clones this template, so setting it here
|
|
|
|
|
// covers all of them, independent of any collision-layer/ignore configuration.
|
|
|
|
|
if (maxDepenetrationVelocity > 0f)
|
|
|
|
|
{
|
|
|
|
|
fragmentRigidBody.maxDepenetrationVelocity = maxDepenetrationVelocity;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return obj;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/// <summary>
|
|
|
|
|
/// Subdivision loop that mirrors <see cref="Fragmenter.Fracture"/>, but chooses the cut-plane
|
|
|
|
|
/// normal per <see cref="sliceMode"/> instead of a fully random one. This is what lets a given
|
|
|
|
|
/// axis be subdivided more finely so long/thin fragments don't come out stretched.
|
|
|
|
|
/// </summary>
|
|
|
|
|
private void FractureControlled(GameObject fragmentTemplate)
|
|
|
|
|
{
|
|
|
|
|
Mesh srcMesh = GetComponent<MeshFilter>().sharedMesh;
|
|
|
|
|
var sourceMesh = new FragmentData(srcMesh);
|
|
|
|
|
|
|
|
|
|
if (fractureDebugLogs)
|
|
|
|
|
{
|
|
|
|
|
Debug.Log($"[FractureAndDrift] '{name}' FractureControlled start. mode={sliceMode} " +
|
|
|
|
|
$"targetCount={fractureOptions.fragmentCount} sourceVerts={srcMesh.vertexCount} " +
|
|
|
|
|
$"sourceTris={srcMesh.triangles.Length / 3} subMeshes={srcMesh.subMeshCount} " +
|
|
|
|
|
$"srcBoundsSize={srcMesh.bounds.size} readable={srcMesh.isReadable}", this);
|
|
|
|
|
if (srcMesh.subMeshCount > 1)
|
|
|
|
|
{
|
|
|
|
|
Debug.LogWarning($"[FractureAndDrift] '{name}' source mesh has {srcMesh.subMeshCount} submeshes. " +
|
|
|
|
|
"OpenFracture only slices submesh 0 — geometry in other submeshes is dropped. " +
|
|
|
|
|
"Combine the model into a single submesh/material if pieces look missing or too coarse.", this);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
var fragments = new Queue<FragmentData>();
|
|
|
|
|
fragments.Enqueue(sourceMesh);
|
|
|
|
|
|
|
|
|
|
// Subdivide the largest-remaining fragment each step until we hit the target count.
|
|
|
|
|
// Processing the largest one first (rather than stock FIFO) keeps fragment sizes even.
|
|
|
|
|
// Guard against degenerate slices: if a piece refuses to split (one side comes back empty),
|
|
|
|
|
// re-enqueuing it unchanged would spin forever AND leave that big block intact. We instead
|
|
|
|
|
// drop it into a "done" set so it stops being reconsidered, and bail out if nothing splits.
|
|
|
|
|
var done = new List<FragmentData>();
|
|
|
|
|
int guardIterations = fractureOptions.fragmentCount * 8 + 16;
|
|
|
|
|
int producedSplits = 0;
|
|
|
|
|
int degenerateSlices = 0;
|
|
|
|
|
|
|
|
|
|
while (fragments.Count + done.Count < fractureOptions.fragmentCount && fragments.Count > 0)
|
|
|
|
|
{
|
|
|
|
|
if (guardIterations-- <= 0)
|
|
|
|
|
{
|
|
|
|
|
if (fractureDebugLogs)
|
|
|
|
|
{
|
|
|
|
|
Debug.LogWarning($"[FractureAndDrift] '{name}' subdivision hit iteration guard; " +
|
|
|
|
|
"stopping early. The mesh likely can't be split further with the current settings.", this);
|
|
|
|
|
}
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
FragmentData meshData = DequeueLargest(fragments);
|
|
|
|
|
meshData.CalculateBounds();
|
|
|
|
|
|
|
|
|
|
Vector3 normal = ChooseCutNormal(meshData.Bounds);
|
|
|
|
|
|
|
|
|
|
MeshSlicer.Slice(meshData,
|
|
|
|
|
normal,
|
|
|
|
|
meshData.Bounds.center,
|
|
|
|
|
fractureOptions.textureScale,
|
|
|
|
|
fractureOptions.textureOffset,
|
|
|
|
|
out FragmentData topSlice,
|
|
|
|
|
out FragmentData bottomSlice);
|
|
|
|
|
|
|
|
|
|
bool topEmpty = topSlice.triangleCount == 0;
|
|
|
|
|
bool bottomEmpty = bottomSlice.triangleCount == 0;
|
|
|
|
|
|
|
|
|
|
// A real split yields geometry on BOTH sides. If one side is empty the plane didn't actually
|
|
|
|
|
// divide this piece, so keep it aside as finished instead of looping on it forever.
|
|
|
|
|
if (topEmpty || bottomEmpty)
|
|
|
|
|
{
|
|
|
|
|
degenerateSlices++;
|
|
|
|
|
done.Add(meshData);
|
|
|
|
|
continue;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
producedSplits++;
|
|
|
|
|
fragments.Enqueue(topSlice);
|
|
|
|
|
fragments.Enqueue(bottomSlice);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
int i = 0;
|
|
|
|
|
var parentSize = srcMesh.bounds.size;
|
|
|
|
|
var parentMass = GetComponent<Rigidbody>().mass;
|
|
|
|
|
float density = (parentSize.x * parentSize.y * parentSize.z) / Mathf.Max(parentMass, Mathf.Epsilon);
|
|
|
|
|
|
|
|
|
|
foreach (FragmentData meshData in fragments)
|
|
|
|
|
{
|
|
|
|
|
CreateControlledFragment(meshData, fragmentTemplate, density, ref i);
|
|
|
|
|
}
|
|
|
|
|
foreach (FragmentData meshData in done)
|
|
|
|
|
{
|
|
|
|
|
CreateControlledFragment(meshData, fragmentTemplate, density, ref i);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (fractureDebugLogs)
|
|
|
|
|
{
|
|
|
|
|
Debug.Log($"[FractureAndDrift] '{name}' FractureControlled done. successfulSplits={producedSplits} " +
|
|
|
|
|
$"degenerateSlices={degenerateSlices} fragmentsCreated={i}. " +
|
|
|
|
|
(degenerateSlices > producedSplits && producedSplits < 4
|
|
|
|
|
? "Most slices failed to divide the mesh -> that is why you still see big blocks. "
|
|
|
|
|
: ""), this);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/// <summary>
|
|
|
|
|
/// Picks the slice-plane normal for the next cut based on the current fragment bounds and slice mode.
|
|
|
|
|
/// </summary>
|
|
|
|
|
private Vector3 ChooseCutNormal(Bounds bounds)
|
|
|
|
|
{
|
|
|
|
|
if (sliceMode == SliceMode.LongestAxis)
|
|
|
|
|
{
|
|
|
|
|
Vector3 size = bounds.size;
|
|
|
|
|
// Normal points along the longest dimension, so the cut plane is perpendicular to it
|
|
|
|
|
// and splits that long dimension in half.
|
|
|
|
|
Vector3 normal = Vector3.right;
|
|
|
|
|
if (size.y >= size.x && size.y >= size.z) normal = Vector3.up;
|
|
|
|
|
else if (size.z >= size.x && size.z >= size.y) normal = Vector3.forward;
|
|
|
|
|
|
|
|
|
|
if (longestAxisJitter > 0f)
|
|
|
|
|
{
|
|
|
|
|
normal += Random.insideUnitSphere * longestAxisJitter;
|
|
|
|
|
}
|
|
|
|
|
return normal.sqrMagnitude > Mathf.Epsilon ? normal.normalized : Vector3.up;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// AxisWeighted: bias each component by its weight so heavier axes get more perpendicular cuts.
|
|
|
|
|
Vector3 w = axisWeights;
|
|
|
|
|
Vector3 weighted = new Vector3(
|
|
|
|
|
(fractureOptions.xAxis ? 1f : 0f) * Mathf.Max(0f, w.x) * Random.Range(-1f, 1f),
|
|
|
|
|
(fractureOptions.yAxis ? 1f : 0f) * Mathf.Max(0f, w.y) * Random.Range(-1f, 1f),
|
|
|
|
|
(fractureOptions.zAxis ? 1f : 0f) * Mathf.Max(0f, w.z) * Random.Range(-1f, 1f));
|
|
|
|
|
|
|
|
|
|
return weighted.sqrMagnitude > Mathf.Epsilon ? weighted.normalized : Vector3.up;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/// <summary>
|
|
|
|
|
/// Removes and returns the fragment with the largest bounding-box volume from the queue,
|
|
|
|
|
/// preserving the order of the remaining items.
|
|
|
|
|
/// </summary>
|
|
|
|
|
private static FragmentData DequeueLargest(Queue<FragmentData> fragments)
|
|
|
|
|
{
|
|
|
|
|
int count = fragments.Count;
|
|
|
|
|
FragmentData largest = null;
|
|
|
|
|
float largestVolume = float.MinValue;
|
|
|
|
|
|
|
|
|
|
// Rotate the queue once, tracking the largest, then rotate again dropping that one.
|
|
|
|
|
for (int i = 0; i < count; i++)
|
|
|
|
|
{
|
|
|
|
|
FragmentData candidate = fragments.Dequeue();
|
|
|
|
|
candidate.CalculateBounds();
|
|
|
|
|
Vector3 s = candidate.Bounds.size;
|
|
|
|
|
float volume = s.x * s.y * s.z;
|
|
|
|
|
if (volume > largestVolume)
|
|
|
|
|
{
|
|
|
|
|
largestVolume = volume;
|
|
|
|
|
largest = candidate;
|
|
|
|
|
}
|
|
|
|
|
fragments.Enqueue(candidate);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
for (int i = 0; i < count; i++)
|
|
|
|
|
{
|
|
|
|
|
FragmentData candidate = fragments.Dequeue();
|
|
|
|
|
if (!ReferenceEquals(candidate, largest))
|
|
|
|
|
{
|
|
|
|
|
fragments.Enqueue(candidate);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return largest;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/// <summary>
|
|
|
|
|
/// Instantiates a fragment GameObject from mesh data. Mirrors the private Fragmenter.CreateFragment.
|
|
|
|
|
/// </summary>
|
|
|
|
|
private void CreateControlledFragment(FragmentData meshData, GameObject fragmentTemplate, float density, ref int i)
|
|
|
|
|
{
|
|
|
|
|
if (meshData.triangleCount == 0)
|
|
|
|
|
{
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
Mesh[] meshes;
|
|
|
|
|
Mesh fragmentMesh = meshData.ToMesh();
|
|
|
|
|
if (fractureOptions.detectFloatingFragments)
|
|
|
|
|
{
|
|
|
|
|
meshes = MeshUtils.FindDisconnectedMeshes(fragmentMesh);
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
meshes = new Mesh[] { fragmentMesh };
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
for (int k = 0; k < meshes.Length; k++)
|
|
|
|
|
{
|
|
|
|
|
GameObject fragment = Instantiate(fragmentTemplate, fragmentRoot.transform);
|
|
|
|
|
fragment.name = $"Fragment{i}";
|
|
|
|
|
fragment.transform.localPosition = Vector3.zero;
|
|
|
|
|
fragment.transform.localRotation = Quaternion.identity;
|
|
|
|
|
fragment.transform.localScale = transform.localScale;
|
|
|
|
|
|
|
|
|
|
meshes[k].name = System.Guid.NewGuid().ToString();
|
|
|
|
|
|
|
|
|
|
fragment.GetComponent<MeshFilter>().sharedMesh = meshes[k];
|
|
|
|
|
|
|
|
|
|
var collider = fragment.GetComponent<MeshCollider>();
|
|
|
|
|
collider.sharedMesh = meshes[k];
|
|
|
|
|
collider.convex = true;
|
|
|
|
|
|
|
|
|
|
var size = meshes[k].bounds.size;
|
|
|
|
|
var rigidBody = fragment.GetComponent<Rigidbody>();
|
|
|
|
|
rigidBody.mass = (size.x * size.y * size.z) / Mathf.Max(density, Mathf.Epsilon);
|
|
|
|
|
|
|
|
|
|
i++;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/// <summary>
|
|
|
|
|
/// Continuously pulls a set of rigidbodies toward a fixed world-space acceleration every physics step.
|
|
|
|
|
/// Attached to the fragment container by <see cref="FractureAndDrift"/> when "Use Custom Gravity" is on,
|
|
|
|
|
/// so fragments drift toward an arbitrary direction instead of Unity's straight-down global gravity.
|
|
|
|
|
/// It lives on the surviving fragment root (not the source object, which is deactivated after shattering).
|
|
|
|
|
/// </summary>
|
|
|
|
|
public class FragmentGravityField : MonoBehaviour
|
|
|
|
|
{
|
|
|
|
|
/// <summary>World-space acceleration (m/s^2) applied to every fragment each FixedUpdate.</summary>
|
|
|
|
|
public Vector3 gravity;
|
|
|
|
|
|
|
|
|
|
private Rigidbody[] bodies;
|
|
|
|
|
|
|
|
|
|
private void FixedUpdate()
|
|
|
|
|
{
|
|
|
|
|
// Refresh the body list lazily: FindDisconnectedMeshes can add fragments a frame late,
|
|
|
|
|
// and null entries appear as the container is torn down at end of life.
|
|
|
|
|
if (bodies == null)
|
|
|
|
|
{
|
|
|
|
|
bodies = GetComponentsInChildren<Rigidbody>();
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
for (int i = 0; i < bodies.Length; i++)
|
|
|
|
|
{
|
|
|
|
|
Rigidbody body = bodies[i];
|
|
|
|
|
if (body == null || body.isKinematic)
|
|
|
|
|
{
|
|
|
|
|
continue;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// ForceMode.Acceleration ignores mass, so every fragment falls at the same rate (like real gravity).
|
|
|
|
|
body.AddForce(gravity, ForceMode.Acceleration);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/// <summary>
|
|
|
|
|
/// Collects (destroys) a batch of fragments asynchronously instead of all at once. Attached to the
|
|
|
|
|
/// surviving fragment container by <see cref="FractureAndDrift"/>. It either waits for an explicit
|
|
|
|
|
/// <see cref="BeginReclaim"/> call (driven by the track controller's fade timing) or, as a fallback,
|
|
|
|
|
/// auto-starts after <c>fallbackDelay</c> seconds. Fragments are destroyed one-by-one spread across
|
|
|
|
|
/// <c>stagger</c> seconds, optionally shrinking each one to nothing first for a graceful collect.
|
|
|
|
|
/// </summary>
|
|
|
|
|
public class FragmentReclaimer : MonoBehaviour
|
|
|
|
|
{
|
|
|
|
|
private float fallbackDelay;
|
|
|
|
|
private float stagger;
|
|
|
|
|
private bool shrink;
|
|
|
|
|
private bool reclaiming;
|
|
|
|
|
|
|
|
|
|
public void Configure(float fallbackDelay, float stagger, bool shrink)
|
|
|
|
|
{
|
|
|
|
|
this.fallbackDelay = fallbackDelay;
|
|
|
|
|
this.stagger = Mathf.Max(0f, stagger);
|
|
|
|
|
this.shrink = shrink;
|
|
|
|
|
|
|
|
|
|
// Fallback timer: if nothing calls BeginReclaim() first, start on our own after the delay.
|
|
|
|
|
if (fallbackDelay > 0f)
|
|
|
|
|
{
|
|
|
|
|
Invoke(nameof(BeginReclaim), fallbackDelay);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/// <summary>
|
|
|
|
|
/// Starts the staggered collection. Safe to call multiple times; only the first call takes effect.
|
|
|
|
|
/// </summary>
|
|
|
|
|
public void BeginReclaim()
|
|
|
|
|
{
|
|
|
|
|
if (reclaiming)
|
|
|
|
|
{
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
reclaiming = true;
|
|
|
|
|
CancelInvoke(nameof(BeginReclaim));
|
|
|
|
|
StartCoroutine(ReclaimRoutine());
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
private IEnumerator ReclaimRoutine()
|
|
|
|
|
{
|
|
|
|
|
// Snapshot the current fragments (skip the top-level container transform itself).
|
|
|
|
|
var fragments = new List<Transform>();
|
|
|
|
|
foreach (Transform child in transform)
|
|
|
|
|
{
|
|
|
|
|
if (child != null)
|
|
|
|
|
{
|
|
|
|
|
fragments.Add(child);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
int count = fragments.Count;
|
|
|
|
|
if (count == 0)
|
|
|
|
|
{
|
|
|
|
|
Destroy(gameObject);
|
|
|
|
|
yield break;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// Time budget between consecutive fragment removals.
|
|
|
|
|
float interval = count > 1 ? stagger / (count - 1) : 0f;
|
|
|
|
|
|
|
|
|
|
for (int i = 0; i < count; i++)
|
|
|
|
|
{
|
|
|
|
|
Transform fragment = fragments[i];
|
|
|
|
|
if (fragment != null)
|
|
|
|
|
{
|
|
|
|
|
if (shrink)
|
|
|
|
|
{
|
|
|
|
|
StartCoroutine(ShrinkAndDestroy(fragment.gameObject, Mathf.Max(0.05f, interval)));
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
Destroy(fragment.gameObject);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (interval > 0f)
|
|
|
|
|
{
|
|
|
|
|
yield return new WaitForSeconds(interval);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// Once the last fragment is gone (allow shrink time to finish), remove the container.
|
|
|
|
|
yield return new WaitForSeconds(shrink ? Mathf.Max(0.05f, interval) : 0f);
|
|
|
|
|
Destroy(gameObject);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
private IEnumerator ShrinkAndDestroy(GameObject fragment, float duration)
|
|
|
|
|
{
|
|
|
|
|
Transform t = fragment.transform;
|
|
|
|
|
Vector3 startScale = t.localScale;
|
|
|
|
|
float elapsed = 0f;
|
|
|
|
|
|
|
|
|
|
while (elapsed < duration && fragment != null)
|
|
|
|
|
{
|
|
|
|
|
elapsed += Time.deltaTime;
|
|
|
|
|
float k = Mathf.Clamp01(elapsed / duration);
|
|
|
|
|
t.localScale = Vector3.Lerp(startScale, Vector3.zero, k);
|
|
|
|
|
yield return null;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (fragment != null)
|
|
|
|
|
{
|
|
|
|
|
Destroy(fragment);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
FloatGaming