mirror of
https://github.com/EsotericSoftware/spine-runtimes.git
synced 2026-03-26 22:49:01 +08:00
414 lines
11 KiB
C#
414 lines
11 KiB
C#
/*****************************************************************************
|
|
* SkeletonRagdoll added by Mitch Thompson
|
|
* Full irrevocable rights and permissions granted to Esoteric Software
|
|
*****************************************************************************/
|
|
|
|
using UnityEngine;
|
|
using System.Collections;
|
|
using System.Collections.Generic;
|
|
using Spine;
|
|
|
|
[RequireComponent(typeof(SkeletonRenderer))]
|
|
public class SkeletonRagdoll : MonoBehaviour {
|
|
private static Transform helper;
|
|
|
|
[Header("Hierarchy")]
|
|
[SpineBone]
|
|
public string startingBoneName = "";
|
|
[SpineBone]
|
|
public List<string> stopBoneNames = new List<string>();
|
|
|
|
[Header("Parameters")]
|
|
public bool applyOnStart;
|
|
[Tooltip("Set RootRigidbody IsKinematic to true when Apply is called.")]
|
|
public bool pinStartBone;
|
|
[Tooltip("Enable Collision between adjacent ragdoll elements (IE: Neck and Head)")]
|
|
public bool enableJointCollision;
|
|
public bool useGravity = true;
|
|
[Tooltip("Warning! You will have to re-enable and tune mix values manually if attempting to remove the ragdoll system.")]
|
|
public bool disableIK = true;
|
|
[Tooltip("If no BoundingBox Attachment is attached to a bone, this becomes the default Width or Radius of a Bone's ragdoll Rigidbody")]
|
|
public float thickness = 0.125f;
|
|
[Tooltip("Default rotational limit value. Min is negative this value, Max is this value.")]
|
|
public float rotationLimit = 20;
|
|
public float rootMass = 20;
|
|
[Tooltip("If your ragdoll seems unstable or uneffected by limits, try lowering this value.")]
|
|
[Range(0.01f, 1f)]
|
|
public float massFalloffFactor = 0.4f;
|
|
[Tooltip("The layer assigned to all of the rigidbody parts.")]
|
|
public int colliderLayer = 0;
|
|
[Range(0, 1)]
|
|
public float mix = 1;
|
|
|
|
public Rigidbody RootRigidbody {
|
|
get {
|
|
return this.rootRigidbody;
|
|
}
|
|
}
|
|
|
|
public Vector3 RootOffset {
|
|
get {
|
|
return this.rootOffset;
|
|
}
|
|
}
|
|
|
|
public Vector3 EstimatedSkeletonPosition {
|
|
get {
|
|
return rootRigidbody.position - rootOffset;
|
|
}
|
|
}
|
|
|
|
public bool IsActive {
|
|
get {
|
|
return this.isActive;
|
|
}
|
|
}
|
|
|
|
private Rigidbody rootRigidbody;
|
|
private ISkeletonAnimation skeletonAnim;
|
|
private Skeleton skeleton;
|
|
private Dictionary<Bone, Transform> boneTable = new Dictionary<Bone, Transform>();
|
|
private Bone startingBone;
|
|
private Transform ragdollRoot;
|
|
private Vector3 rootOffset;
|
|
private bool isActive;
|
|
|
|
IEnumerator Start () {
|
|
skeletonAnim = (ISkeletonAnimation)GetComponent<SkeletonRenderer>();
|
|
if (helper == null) {
|
|
helper = (Transform)(new GameObject("Helper")).transform;
|
|
helper.hideFlags = HideFlags.HideInHierarchy;
|
|
}
|
|
|
|
if (applyOnStart) {
|
|
yield return null;
|
|
Apply();
|
|
}
|
|
}
|
|
|
|
public Coroutine SmoothMix (float target, float duration) {
|
|
return StartCoroutine(SmoothMixCoroutine(target, duration));
|
|
}
|
|
|
|
IEnumerator SmoothMixCoroutine (float target, float duration) {
|
|
float startTime = Time.time;
|
|
float startMix = mix;
|
|
while (mix > 0) {
|
|
mix = Mathf.SmoothStep(startMix, target, (Time.time - startTime) / duration);
|
|
yield return null;
|
|
}
|
|
}
|
|
|
|
public void SetSkeletonPosition (Vector3 worldPosition) {
|
|
if (!isActive) {
|
|
Debug.LogWarning("Can't call SetSkeletonPosition while Ragdoll is not active!");
|
|
return;
|
|
}
|
|
|
|
Vector3 offset = worldPosition - transform.position;
|
|
transform.position = worldPosition;
|
|
foreach (Transform t in boneTable.Values) {
|
|
t.position -= offset;
|
|
}
|
|
|
|
UpdateWorld(null);
|
|
skeleton.UpdateWorldTransform();
|
|
}
|
|
|
|
public Rigidbody[] GetRigidbodyArray () {
|
|
if (!isActive)
|
|
return new Rigidbody[0];
|
|
|
|
Rigidbody[] arr = new Rigidbody[boneTable.Count];
|
|
int i = 0;
|
|
foreach (Transform t in boneTable.Values) {
|
|
arr[i] = t.GetComponent<Rigidbody>();
|
|
i++;
|
|
}
|
|
|
|
return arr;
|
|
}
|
|
|
|
public Rigidbody GetRigidbody (string boneName) {
|
|
var bone = skeleton.FindBone(boneName);
|
|
if (bone == null)
|
|
return null;
|
|
|
|
if (boneTable.ContainsKey(bone))
|
|
return boneTable[bone].GetComponent<Rigidbody>();
|
|
|
|
return null;
|
|
}
|
|
|
|
public void Remove () {
|
|
isActive = false;
|
|
foreach (var t in boneTable.Values) {
|
|
Destroy(t.gameObject);
|
|
}
|
|
Destroy(ragdollRoot.gameObject);
|
|
|
|
boneTable.Clear();
|
|
skeletonAnim.UpdateWorld -= UpdateWorld;
|
|
}
|
|
|
|
public void Apply () {
|
|
isActive = true;
|
|
skeleton = skeletonAnim.Skeleton;
|
|
mix = 1;
|
|
|
|
var ragdollRootBone = skeleton.FindBone(startingBoneName);
|
|
startingBone = ragdollRootBone;
|
|
RecursivelyCreateBoneProxies(ragdollRootBone);
|
|
|
|
rootRigidbody = boneTable[ragdollRootBone].GetComponent<Rigidbody>();
|
|
rootRigidbody.isKinematic = pinStartBone;
|
|
|
|
rootRigidbody.mass = rootMass;
|
|
|
|
List<Collider> boneColliders = new List<Collider>();
|
|
|
|
foreach (var pair in boneTable) {
|
|
var b = pair.Key;
|
|
var t = pair.Value;
|
|
Bone parentBone = null;
|
|
Transform parentTransform = transform;
|
|
|
|
boneColliders.Add(t.GetComponent<Collider>());
|
|
|
|
if (b != startingBone) {
|
|
parentBone = b.Parent;
|
|
parentTransform = boneTable[parentBone];
|
|
} else {
|
|
ragdollRoot = new GameObject("RagdollRoot").transform;
|
|
ragdollRoot.parent = transform;
|
|
|
|
if (b == skeleton.RootBone) {
|
|
ragdollRoot.localPosition = new Vector3(b.WorldX, b.WorldY, 0);
|
|
ragdollRoot.localRotation = Quaternion.Euler(0, 0, GetCompensatedRotationIK(b));
|
|
parentTransform = ragdollRoot;
|
|
} else {
|
|
ragdollRoot.localPosition = new Vector3(b.Parent.WorldX, b.Parent.WorldY, 0);
|
|
ragdollRoot.localRotation = Quaternion.Euler(0, 0, GetCompensatedRotationIK(b.Parent));
|
|
parentTransform = ragdollRoot;
|
|
}
|
|
|
|
rootOffset = t.position - transform.position;
|
|
}
|
|
|
|
var rbParent = parentTransform.GetComponent<Rigidbody>();
|
|
|
|
if (rbParent != null) {
|
|
var joint = t.gameObject.AddComponent<HingeJoint>();
|
|
joint.connectedBody = rbParent;
|
|
Vector3 localPos = parentTransform.InverseTransformPoint(t.position);
|
|
localPos.x *= 1;
|
|
joint.connectedAnchor = localPos;
|
|
joint.axis = Vector3.forward;
|
|
joint.GetComponent<Rigidbody>().mass = joint.connectedBody.mass * massFalloffFactor;
|
|
JointLimits limits = new JointLimits();
|
|
limits.min = -rotationLimit;
|
|
limits.max = rotationLimit;
|
|
joint.limits = limits;
|
|
joint.useLimits = true;
|
|
joint.enableCollision = enableJointCollision;
|
|
}
|
|
}
|
|
|
|
for (int x = 0; x < boneColliders.Count; x++) {
|
|
for (int y = 0; y < boneColliders.Count; y++) {
|
|
if (x == y) continue;
|
|
Physics.IgnoreCollision(boneColliders[x], boneColliders[y]);
|
|
}
|
|
}
|
|
|
|
var utilityBones = GetComponentsInChildren<SkeletonUtilityBone>();
|
|
if (utilityBones.Length > 0) {
|
|
List<string> destroyedUtilityBoneNames = new List<string>();
|
|
foreach (var ub in utilityBones) {
|
|
if (ub.mode == SkeletonUtilityBone.Mode.Override) {
|
|
destroyedUtilityBoneNames.Add(ub.gameObject.name);
|
|
Destroy(ub.gameObject);
|
|
}
|
|
}
|
|
|
|
if (destroyedUtilityBoneNames.Count > 0) {
|
|
string msg = "Destroyed Utility Bones: ";
|
|
for (int i = 0; i < destroyedUtilityBoneNames.Count; i++) {
|
|
msg += destroyedUtilityBoneNames[i];
|
|
if (i != destroyedUtilityBoneNames.Count - 1) {
|
|
msg += ",";
|
|
}
|
|
}
|
|
Debug.LogWarning(msg);
|
|
}
|
|
}
|
|
|
|
if (disableIK) {
|
|
foreach (IkConstraint ik in skeleton.IkConstraints) {
|
|
ik.Mix = 0;
|
|
}
|
|
}
|
|
|
|
skeletonAnim.UpdateWorld += UpdateWorld;
|
|
}
|
|
|
|
void RecursivelyCreateBoneProxies (Bone b) {
|
|
if (stopBoneNames.Contains(b.Data.Name))
|
|
return;
|
|
|
|
GameObject go = new GameObject(b.Data.Name);
|
|
go.layer = colliderLayer;
|
|
Transform t = go.transform;
|
|
boneTable.Add(b, t);
|
|
|
|
t.parent = transform;
|
|
|
|
t.localPosition = new Vector3(b.WorldX, b.WorldY, 0);
|
|
t.localRotation = Quaternion.Euler(0, 0, b.WorldFlipX ^ b.WorldFlipY ? -b.WorldRotation : b.WorldRotation);
|
|
t.localScale = new Vector3(b.WorldScaleX, b.WorldScaleY, 1);
|
|
|
|
float length = b.Data.Length;
|
|
|
|
var colliders = AttachBoundingBoxRagdollColliders(b);
|
|
|
|
if (length == 0) {
|
|
//physics
|
|
if (colliders.Count == 0) {
|
|
var ball = go.AddComponent<SphereCollider>();
|
|
ball.radius = thickness / 2f;
|
|
}
|
|
} else {
|
|
//physics
|
|
if (colliders.Count == 0) {
|
|
var box = go.AddComponent<BoxCollider>();
|
|
box.size = new Vector3(length, thickness, thickness);
|
|
box.center = new Vector3((b.WorldFlipX ? -length : length) / 2, 0);
|
|
}
|
|
}
|
|
|
|
var rb = go.AddComponent<Rigidbody>();
|
|
rb.constraints = RigidbodyConstraints.FreezePositionZ;
|
|
foreach (Bone child in b.Children) {
|
|
RecursivelyCreateBoneProxies(child);
|
|
}
|
|
}
|
|
|
|
List<Collider> AttachBoundingBoxRagdollColliders (Bone b) {
|
|
List<Collider> colliders = new List<Collider>();
|
|
|
|
Transform t = boneTable[b];
|
|
GameObject go = t.gameObject;
|
|
var skin = skeleton.Skin;
|
|
if (skin == null)
|
|
skin = skeleton.Data.DefaultSkin;
|
|
|
|
bool flipX = b.WorldFlipX;
|
|
bool flipY = b.WorldFlipY;
|
|
|
|
List<Attachment> attachments = new List<Attachment>();
|
|
foreach (Slot s in skeleton.Slots) {
|
|
if (s.Bone == b) {
|
|
skin.FindAttachmentsForSlot(skeleton.Slots.IndexOf(s), attachments);
|
|
foreach (var a in attachments) {
|
|
if (a is BoundingBoxAttachment) {
|
|
if (!a.Name.ToLower().Contains("ragdoll"))
|
|
continue;
|
|
|
|
var collider = go.AddComponent<BoxCollider>();
|
|
var bounds = SkeletonUtility.GetBoundingBoxBounds((BoundingBoxAttachment)a, thickness);
|
|
|
|
collider.center = bounds.center;
|
|
collider.size = bounds.size;
|
|
|
|
if (flipX || flipY) {
|
|
Vector3 center = collider.center;
|
|
|
|
if (flipX)
|
|
center.x *= -1;
|
|
|
|
if (flipY)
|
|
center.y *= -1;
|
|
|
|
collider.center = center;
|
|
}
|
|
|
|
colliders.Add(collider);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return colliders;
|
|
}
|
|
|
|
void UpdateWorld (SkeletonRenderer skeletonRenderer) {
|
|
foreach (var pair in boneTable) {
|
|
var b = pair.Key;
|
|
var t = pair.Value;
|
|
bool flip = false;
|
|
bool flipX = false; //TODO: deal with negative scale instead of Flip Key for Spine 3.0
|
|
bool flipY = false; //TODO: deal with negative scale instead of Flip Key for Spine 3.0
|
|
Bone parentBone = null;
|
|
Transform parentTransform = transform;
|
|
|
|
if (b != startingBone) {
|
|
parentBone = b.Parent;
|
|
parentTransform = boneTable[parentBone];
|
|
flipX = parentBone.WorldFlipX;
|
|
flipY = parentBone.WorldFlipY;
|
|
|
|
} else {
|
|
parentBone = b.Parent;
|
|
parentTransform = ragdollRoot;
|
|
if (b.Parent != null) {
|
|
flipX = b.worldFlipX;
|
|
flipY = b.WorldFlipY;
|
|
} else {
|
|
flipX = b.Skeleton.FlipX;
|
|
flipY = b.Skeleton.FlipY;
|
|
}
|
|
}
|
|
|
|
flip = flipX ^ flipY;
|
|
|
|
helper.position = parentTransform.position;
|
|
helper.rotation = parentTransform.rotation;
|
|
helper.localScale = new Vector3(flipX ? -parentTransform.localScale.x : parentTransform.localScale.x, flipY ? -parentTransform.localScale.y : parentTransform.localScale.y, 1);
|
|
|
|
|
|
Vector3 pos = t.position;
|
|
pos = helper.InverseTransformPoint(pos);
|
|
b.X = Mathf.Lerp(b.X, pos.x, mix);
|
|
b.Y = Mathf.Lerp(b.Y, pos.y, mix);
|
|
|
|
Vector3 right = helper.InverseTransformDirection(t.right);
|
|
|
|
float a = Mathf.Atan2(right.y, right.x) * Mathf.Rad2Deg;
|
|
|
|
if (b.WorldFlipX ^ b.WorldFlipY) {
|
|
a *= -1;
|
|
}
|
|
|
|
if (parentBone != null) {
|
|
if ((b.WorldFlipX ^ b.WorldFlipY) != flip) {
|
|
a -= GetCompensatedRotationIK(parentBone) * 2;
|
|
}
|
|
}
|
|
|
|
b.Rotation = Mathf.Lerp(b.Rotation, a, mix);
|
|
b.RotationIK = Mathf.Lerp(b.rotationIK, a, mix);
|
|
}
|
|
}
|
|
|
|
float GetCompensatedRotationIK (Bone b) {
|
|
Bone parent = b.Parent;
|
|
float a = b.RotationIK;
|
|
while (parent != null) {
|
|
a += parent.RotationIK;
|
|
parent = parent.parent;
|
|
}
|
|
|
|
return a;
|
|
}
|
|
}
|