private static void SetGrabbersInChildren(SPCRJointDynamicsController controller)
{
if (controller._RootTransform != null)
{
controller._PointGrabberTable = controller._RootTransform.GetComponentsInChildren <SPCRJointDynamicsPointGrabber>();
}
}
static public void Push(SPCRJointDynamicsController ctrl)
{
Instance._Controllers.Add(ctrl);
Instance._DynamicsBoneCount += ctrl.PointTbl.Length;
Instance._DynamicsColliderCount += ctrl._ColliderTbl.Length;
}
static public void Pop(SPCRJointDynamicsController ctrl)
{
Instance._Controllers.Remove(ctrl);
Instance._DynamicsBoneCount -= ctrl.PointTbl.Length;
Instance._DynamicsColliderCount -= ctrl._ColliderTbl.Length;
}
void SubdivideVerticalChain(SPCRJointDynamicsController controller, int NumInsert)
{
var rnd = new System.Random();
var RootList = new List <SPCRJointDynamicsPoint>(controller._RootPointTbl);
var OriginalPoints = controller._SubDivOriginalPoints;
var InsertedPoints = controller._SubDivInsertedPoints;
var IsFirstSubdivide = (OriginalPoints.Count == 0);
foreach (var rootPoint in RootList)
{
if (IsFirstSubdivide)
{
OriginalPoints.Add(rootPoint);
}
var parentPoint = rootPoint;
while (parentPoint.transform.childCount > 0)
{
var parentTransform = parentPoint.transform;
var points = parentTransform.GetComponentsInChildren <SPCRJointDynamicsPoint>();
if (points.Length < 2)
{
break;
}
var childPoint = points[1];
if (parentPoint == childPoint)
{
Debug.LogWarning("Infinite Loop!:" + parentPoint.name);
break;
}
if (IsFirstSubdivide)
{
OriginalPoints.Add(childPoint);
}
var childTransform = childPoint.transform;
SPCRJointDynamicsPoint newPoint = null;
for (int i = 1; i <= NumInsert; i++)
{
float weight = i / (NumInsert + 1.0f);
newPoint = CreateInterpolatedPoint(parentPoint, childPoint, weight, "VSubdiv_" + rnd.Next());
InsertedPoints.Add(newPoint);
newPoint.transform.SetParent(parentTransform);
parentTransform = newPoint.transform;
}
childTransform.SetParent(newPoint.transform);
parentPoint = childPoint;
}
}
}
private static void SearchRootPoints(SPCRJointDynamicsController controller)
{
if (controller._RootTransform == null)
{
controller._RootTransform = controller.transform;
}
var PointList = new List <SPCRJointDynamicsPoint>();
SearchRootPoints(controller._RootTransform, PointList);
controller._RootPointTable = PointList.ToArray();
}
void UpdateToggle(string Label, SPCRJointDynamicsController Source, ref bool Value, bool Reverse = false)
{
if (Reverse)
{
Value = !EditorGUILayout.Toggle(Label, !Value);
}
else
{
Value = EditorGUILayout.Toggle(Label, Value);
}
}
void SearchRootPoints(SPCRJointDynamicsController controller)
{
if (controller._RootTransform != null)
{
var PointList = new List <SPCRJointDynamicsPoint>();
for (int i = 0; i < controller._RootTransform.transform.childCount; ++i)
{
var child = controller._RootTransform.transform.GetChild(i);
var point = child.GetComponent <SPCRJointDynamicsPoint>();
if (point != null)
{
PointList.Add(point);
}
}
controller._RootPointTbl = PointList.ToArray();
}
}
void SortConstraintsHorizontalRoot(SPCRJointDynamicsController controller, UpdateJointConnectionType Type)
{
switch (Type)
{
case UpdateJointConnectionType.Default:
{
}
break;
case UpdateJointConnectionType.SortNearPointXYZ:
{
var SourcePoints = new List <SPCRJointDynamicsPoint>();
var EdgeA = controller._RootPointTbl[0];
for (int i = 1; i < controller._RootPointTbl.Length; ++i)
{
SourcePoints.Add(controller._RootPointTbl[i]);
}
var SortedPoints = new List <SPCRJointDynamicsPoint>();
SortedPoints.Add(EdgeA);
while (SourcePoints.Count > 0)
{
SortedPoints.Add(GetNearestPoint(
SortedPoints[SortedPoints.Count - 1].transform.position,
ref SourcePoints,
false));
}
controller._RootPointTbl = SortedPoints.ToArray();
}
break;
case UpdateJointConnectionType.SortNearPointXZ:
{
var SourcePoints = new List <SPCRJointDynamicsPoint>();
var EdgeA = controller._RootPointTbl[0];
for (int i = 1; i < controller._RootPointTbl.Length; ++i)
{
SourcePoints.Add(controller._RootPointTbl[i]);
}
var SortedPoints = new List <SPCRJointDynamicsPoint>();
SortedPoints.Add(EdgeA);
while (SourcePoints.Count > 0)
{
SortedPoints.Add(GetNearestPoint(
SortedPoints[SortedPoints.Count - 1].transform.position,
ref SourcePoints,
true));
}
controller._RootPointTbl = SortedPoints.ToArray();
}
break;
case UpdateJointConnectionType.SortNearPointXYZ_FixedBeginEnd:
{
var SourcePoints = new List <SPCRJointDynamicsPoint>();
var EdgeA = controller._RootPointTbl[0];
var EdgeB = controller._RootPointTbl[controller._RootPointTbl.Length - 1];
for (int i = 1; i < controller._RootPointTbl.Length - 1; ++i)
{
SourcePoints.Add(controller._RootPointTbl[i]);
}
var SortedPoints = new List <SPCRJointDynamicsPoint>();
SortedPoints.Add(EdgeA);
while (SourcePoints.Count > 0)
{
SortedPoints.Add(GetNearestPoint(
SortedPoints[SortedPoints.Count - 1].transform.position,
ref SourcePoints,
false));
}
SortedPoints.Add(EdgeB);
controller._RootPointTbl = SortedPoints.ToArray();
}
break;
case UpdateJointConnectionType.SortNearPointXZ_FixedBeginEnd:
{
var SourcePoints = new List <SPCRJointDynamicsPoint>();
var EdgeA = controller._RootPointTbl[0];
var EdgeB = controller._RootPointTbl[controller._RootPointTbl.Length - 1];
for (int i = 1; i < controller._RootPointTbl.Length - 1; ++i)
{
SourcePoints.Add(controller._RootPointTbl[i]);
}
var SortedPoints = new List <SPCRJointDynamicsPoint>();
SortedPoints.Add(EdgeA);
while (SourcePoints.Count > 0)
{
SortedPoints.Add(GetNearestPoint(
SortedPoints[SortedPoints.Count - 1].transform.position,
ref SourcePoints,
true));
}
SortedPoints.Add(EdgeB);
controller._RootPointTbl = SortedPoints.ToArray();
}
break;
}
}
void UpdateCurve(string Label, SPCRJointDynamicsController Source, ref AnimationCurve Value)
{
Value = EditorGUILayout.CurveField(Label, Value);
}
public static void Load(SPCRJointDynamicsController SPCRJointDynamicsContoller)
{
SPCRJointDynamicsControllerSave spcrJointDynamicsSave = LoadBinary();
if (spcrJointDynamicsSave == null)
{
return;
}
if (string.IsNullOrEmpty(SPCRJointDynamicsContoller.Name))
{
SPCRJointDynamicsContoller.Name = spcrJointDynamicsSave.name;
}
GameObject RootGameObject = GameObject.Find(spcrJointDynamicsSave.rootTransformName);
if (RootGameObject != null)
{
SPCRJointDynamicsContoller._RootTransform = RootGameObject.transform;
}
globalUniqueIdList = GetGlobalUniqueIdComponentList();
if (spcrJointDynamicsSave.spcrChildJointDynamicsPointList != null)
{
for (int i = 0; i < spcrJointDynamicsSave.spcrChildJointDynamicsPointList.Length; i++)
{
SPCRJointDynamicsPoint point = (SPCRJointDynamicsPoint)globalUniqueIdList.Find(obj => obj.GetType() == typeof(SPCRJointDynamicsPoint) && ((SPCRJointDynamicsPoint)obj).UniqueGUIID.Equals(spcrJointDynamicsSave.spcrChildJointDynamicsPointList[i].RefUniqueID));
SPCRJointDynamicsPoint ChildPoint = (SPCRJointDynamicsPoint)globalUniqueIdList.Find(obj => obj.GetType() == typeof(SPCRJointDynamicsPoint) && ((SPCRJointDynamicsPoint)obj).UniqueGUIID.Equals(spcrJointDynamicsSave.spcrChildJointDynamicsPointList[i].refChildID));
if (point != null)
{
point._Mass = spcrJointDynamicsSave.spcrChildJointDynamicsPointList[i].mass;
point._RefChildPoint = ChildPoint;
point._IsFixed = spcrJointDynamicsSave.spcrChildJointDynamicsPointList[i].IsFixed;
point._BoneAxis = spcrJointDynamicsSave.spcrChildJointDynamicsPointList[i].BoneAxis.ToUnityVector3();
point._Depth = spcrJointDynamicsSave.spcrChildJointDynamicsPointList[i].Depth;
point._Index = spcrJointDynamicsSave.spcrChildJointDynamicsPointList[i].Index;
point._UseForSurfaceCollision = spcrJointDynamicsSave.spcrChildJointDynamicsPointList[i].UseForSurfaceCollision;
}
}
}
if (spcrJointDynamicsSave.spcrChildJointDynamicsColliderList != null)
{
List <SPCRJointDynamicsCollider> colliderTable = new List <SPCRJointDynamicsCollider>();
for (int i = 0; i < spcrJointDynamicsSave.spcrChildJointDynamicsColliderList.Length; i++)
{
SPCRJointDynamicsCollider point = (SPCRJointDynamicsCollider)globalUniqueIdList.Find(obj => obj.GetType() == typeof(SPCRJointDynamicsCollider) && ((SPCRJointDynamicsCollider)obj).UniqueGUIID.Equals(spcrJointDynamicsSave.spcrChildJointDynamicsColliderList[i].RefUniqueId));
if (point == null)
{
point = CreateNewCollider(spcrJointDynamicsSave.spcrChildJointDynamicsColliderList[i]);
}
point.RadiusRaw = spcrJointDynamicsSave.spcrChildJointDynamicsColliderList[i].Radius;
point.HeightRaw = spcrJointDynamicsSave.spcrChildJointDynamicsColliderList[i].Height;
point.FrictionRaw = spcrJointDynamicsSave.spcrChildJointDynamicsColliderList[i].Friction;
point._SurfaceColliderForce = spcrJointDynamicsSave.spcrChildJointDynamicsColliderList[i].ForceType;
if (!colliderTable.Contains(point))
{
colliderTable.Add(point);
}
}
if (colliderTable.Count > 0)
{
SPCRJointDynamicsContoller._ColliderTbl = colliderTable.ToArray();
}
}
if (spcrJointDynamicsSave.spcrChildJointDynamicsPointGtabberList != null)
{
List <SPCRJointDynamicsPointGrabber> grabberList = new List <SPCRJointDynamicsPointGrabber>();
for (int i = 0; i < spcrJointDynamicsSave.spcrChildJointDynamicsPointGtabberList.Length; i++)
{
SPCRJointDynamicsPointGrabber point = (SPCRJointDynamicsPointGrabber)globalUniqueIdList.Find(obj => obj.GetType() == typeof(SPCRJointDynamicsPointGrabber) && ((SPCRJointDynamicsPointGrabber)obj).UniqueGUIID.Equals(spcrJointDynamicsSave.spcrChildJointDynamicsPointGtabberList[i].RefUniqueGUIID));
if (point == null)
{
point = CreateNewGrabber(spcrJointDynamicsSave.spcrChildJointDynamicsPointGtabberList[i]);
}
point.IsEnabled = spcrJointDynamicsSave.spcrChildJointDynamicsPointGtabberList[i].IsEnabled;
point.RadiusRaw = spcrJointDynamicsSave.spcrChildJointDynamicsPointGtabberList[i].Radius;
point.Force = spcrJointDynamicsSave.spcrChildJointDynamicsPointGtabberList[i].Force;
grabberList.Add(point);
}
if (grabberList.Count > 0)
{
SPCRJointDynamicsContoller._PointGrabberTbl = grabberList.ToArray();
}
}
if (spcrJointDynamicsSave.RootPointTbl != null)
{
List <SPCRJointDynamicsPoint> pointList = new List <SPCRJointDynamicsPoint>();
for (int i = 0; i < spcrJointDynamicsSave.RootPointTbl.Length; i++)
{
SPCRJointDynamicsPoint point = (SPCRJointDynamicsPoint)globalUniqueIdList.Find(obj => obj.GetType() == typeof(SPCRJointDynamicsPoint) && ((SPCRJointDynamicsPoint)obj).UniqueGUIID.Equals(spcrJointDynamicsSave.RootPointTbl[i]));
if (point == null)
{
continue;
}
pointList.Add(point);
}
if (pointList.Count > 0)
{
SPCRJointDynamicsContoller._RootPointTbl = pointList.ToArray();
}
}
else
{
SPCRJointDynamicsContoller._RootPointTbl = new SPCRJointDynamicsPoint[0];
}
SPCRJointDynamicsContoller._Relaxation = spcrJointDynamicsSave.Relaxation;
SPCRJointDynamicsContoller._SubSteps = spcrJointDynamicsSave.SubSteps;
//@SPCRJointDynamicsContoller._IsEnablePointCollision = spcrJointDynamicsSave.IsEnablePointCollision;
//@SPCRJointDynamicsContoller._DetailHitDivideMax = spcrJointDynamicsSave.DetailHitDivideMax;
SPCRJointDynamicsContoller._IsCancelResetPhysics = spcrJointDynamicsSave.IsCancelResetPhysics;
SPCRJointDynamicsContoller._IsEnableSurfaceCollision = spcrJointDynamicsSave.IsEnableSurfaceCollision;
SPCRJointDynamicsContoller._SurfaceCollisionDivision = spcrJointDynamicsSave.SurfaceCollisionDivision;
SPCRJointDynamicsContoller._MassScaleCurve = GetAnimCurve(spcrJointDynamicsSave.MassScaleCurve);
SPCRJointDynamicsContoller._GravityScaleCurve = GetAnimCurve(spcrJointDynamicsSave.GravityScaleCurve);
SPCRJointDynamicsContoller._ResistanceCurve = GetAnimCurve(spcrJointDynamicsSave.ResistanceCurve);
SPCRJointDynamicsContoller._HardnessCurve = GetAnimCurve(spcrJointDynamicsSave.HardnessCurve);
SPCRJointDynamicsContoller._FrictionCurve = GetAnimCurve(spcrJointDynamicsSave.FrictionCurve);
SPCRJointDynamicsContoller._AllShrinkScaleCurve = GetAnimCurve(spcrJointDynamicsSave.AllShrinkScaleCurve);
SPCRJointDynamicsContoller._AllStretchScaleCurve = GetAnimCurve(spcrJointDynamicsSave.AllStretchScaleCurve);
SPCRJointDynamicsContoller._StructuralShrinkVerticalScaleCurve = GetAnimCurve(spcrJointDynamicsSave.StructuralShrinkVerticalScaleCurve);
SPCRJointDynamicsContoller._StructuralStretchVerticalScaleCurve = GetAnimCurve(spcrJointDynamicsSave.StructuralStretchVerticalScaleCurve);
SPCRJointDynamicsContoller._StructuralShrinkHorizontalScaleCurve = GetAnimCurve(spcrJointDynamicsSave.StructuralShrinkHorizontalScaleCurve);
SPCRJointDynamicsContoller._StructuralStretchHorizontalScaleCurve = GetAnimCurve(spcrJointDynamicsSave.StructuralStretchHorizontalScaleCurve);
SPCRJointDynamicsContoller._ShearShrinkScaleCurve = GetAnimCurve(spcrJointDynamicsSave.ShearShrinkScaleCurve);
SPCRJointDynamicsContoller._ShearStretchScaleCurve = GetAnimCurve(spcrJointDynamicsSave.ShearStretchScaleCurve);
SPCRJointDynamicsContoller._BendingShrinkVerticalScaleCurve = GetAnimCurve(spcrJointDynamicsSave.BendingShrinkVerticalScaleCurve);
SPCRJointDynamicsContoller._BendingStretchVerticalScaleCurve = GetAnimCurve(spcrJointDynamicsSave.BendingStretchVerticalScaleCurve);
SPCRJointDynamicsContoller._BendingShrinkHorizontalScaleCurve = GetAnimCurve(spcrJointDynamicsSave.BendingShrinkHorizontalScaleCurve);
SPCRJointDynamicsContoller._BendingStretchHorizontalScaleCurve = GetAnimCurve(spcrJointDynamicsSave.BendingStretchHorizontalScaleCurve);
SPCRJointDynamicsContoller._Gravity = spcrJointDynamicsSave.Gravity.ToUnityVector3();
SPCRJointDynamicsContoller._WindForce = spcrJointDynamicsSave.WindForce.ToUnityVector3();
SPCRJointDynamicsContoller._RootSlideLimit = spcrJointDynamicsSave.RootSlideLimit;
SPCRJointDynamicsContoller._RootRotateLimit = spcrJointDynamicsSave.RootRotateLimit;
SPCRJointDynamicsContoller._StructuralShrinkVertical = spcrJointDynamicsSave.StructuralShrinkVertical;
SPCRJointDynamicsContoller._StructuralStretchVertical = spcrJointDynamicsSave.StructuralStretchVertical;
SPCRJointDynamicsContoller._StructuralShrinkHorizontal = spcrJointDynamicsSave.StructuralShrinkHorizontal;
SPCRJointDynamicsContoller._StructuralStretchHorizontal = spcrJointDynamicsSave.StructuralStretchHorizontal;
SPCRJointDynamicsContoller._ShearShrink = spcrJointDynamicsSave.ShearShrink;
SPCRJointDynamicsContoller._ShearStretch = spcrJointDynamicsSave.ShearStretch;
SPCRJointDynamicsContoller._BendingShrinkVertical = spcrJointDynamicsSave.BendingShrinkVertical;
SPCRJointDynamicsContoller._BendingStretchVertical = spcrJointDynamicsSave.BendingStretchVertical;
SPCRJointDynamicsContoller._BendingShrinkHorizontal = spcrJointDynamicsSave.BendingShrinkHorizontal;
SPCRJointDynamicsContoller._BendingStretchHorizontal = spcrJointDynamicsSave.BendingStretchHorizontal;
SPCRJointDynamicsContoller._IsAllStructuralShrinkVertical = spcrJointDynamicsSave.IsAllStructuralShrinkVertical;
SPCRJointDynamicsContoller._IsAllStructuralStretchVertical = spcrJointDynamicsSave.IsAllStructuralStretchVertical;
SPCRJointDynamicsContoller._IsAllStructuralShrinkHorizontal = spcrJointDynamicsSave.IsAllStructuralShrinkHorizontal;
SPCRJointDynamicsContoller._IsAllStructuralStretchHorizontal = spcrJointDynamicsSave.IsAllStructuralStretchHorizontal;
SPCRJointDynamicsContoller._IsAllShearShrink = spcrJointDynamicsSave.IsAllShearShrink;
SPCRJointDynamicsContoller._IsAllShearStretch = spcrJointDynamicsSave.IsAllShearStretch;
SPCRJointDynamicsContoller._IsAllBendingShrinkVertical = spcrJointDynamicsSave.IsAllBendingShrinkVertical;
SPCRJointDynamicsContoller._IsAllBendingStretchVertical = spcrJointDynamicsSave.IsAllBendingStretchVertical;
SPCRJointDynamicsContoller._IsAllBendingShrinkHorizontal = spcrJointDynamicsSave.IsAllBendingShrinkHorizontal;
SPCRJointDynamicsContoller._IsAllBendingStretchHorizontal = spcrJointDynamicsSave.IsAllBendingStretchHorizontal;
SPCRJointDynamicsContoller._IsCollideStructuralVertical = spcrJointDynamicsSave.IsCollideStructuralVertical;
SPCRJointDynamicsContoller._IsCollideStructuralHorizontal = spcrJointDynamicsSave.IsCollideStructuralHorizontal;
SPCRJointDynamicsContoller._IsCollideShear = spcrJointDynamicsSave.IsCollideShear;
SPCRJointDynamicsContoller._IsLoopRootPoints = spcrJointDynamicsSave.IsLoopRootPoints;
SPCRJointDynamicsContoller._IsComputeStructuralVertical = spcrJointDynamicsSave.IsComputeStructuralVertical;
SPCRJointDynamicsContoller._IsComputeStructuralHorizontal = spcrJointDynamicsSave.IsComputeStructuralHorizontal;
SPCRJointDynamicsContoller._IsComputeShear = spcrJointDynamicsSave.IsComputeShear;
SPCRJointDynamicsContoller._IsComputeBendingVertical = spcrJointDynamicsSave.IsComputeBendingVertical;
SPCRJointDynamicsContoller._IsComputeBendingHorizontal = spcrJointDynamicsSave.IsComputeBendingHorizontal;
SPCRJointDynamicsContoller._IsDebugDraw_StructuralVertical = spcrJointDynamicsSave.IsDebugDraw_StructuralVertical;
SPCRJointDynamicsContoller._IsDebugDraw_StructuralHorizontal = spcrJointDynamicsSave.IsDebugDraw_StructuralHorizontal;
SPCRJointDynamicsContoller._IsDebugDraw_Shear = spcrJointDynamicsSave.IsDebugDraw_Shear;
SPCRJointDynamicsContoller._IsDebugDraw_BendingVertical = spcrJointDynamicsSave.IsDebugDraw_BendingVertical;
SPCRJointDynamicsContoller._IsDebugDraw_BendingHorizontal = spcrJointDynamicsSave.IsDebugDraw_BendingHorizontal;
SPCRJointDynamicsContoller._IsDebugDraw_SurfaceFace = spcrJointDynamicsSave.IsDebugDraw_SurfaceFace;
SPCRJointDynamicsContoller._Debug_SurfaceNormalLength = spcrJointDynamicsSave.Debug_SurfaceNoramlLength;
SPCRJointDynamicsContoller._IsDebugDraw_RuntimeColliderBounds = spcrJointDynamicsSave.IsDebugDraw_RuntimeColliderBounds;
if (spcrJointDynamicsSave.ConstraintTable != null)
{
SPCRJointDynamicsContoller.ConstraintTable = new SPCRJointDynamicsJob.Constraint[spcrJointDynamicsSave.ConstraintTable.Length][];
for (int i = 0; i < spcrJointDynamicsSave.ConstraintTable.Length; i++)
{
SPCRJointDynamicsContoller.ConstraintTable[i] = new SPCRJointDynamicsJob.Constraint[spcrJointDynamicsSave.ConstraintTable[i].Length];
for (int j = 0; j < spcrJointDynamicsSave.ConstraintTable[i].Length; j++)
{
SPCRJointDynamicsContoller.ConstraintTable[i][j] = spcrJointDynamicsSave.ConstraintTable[i][j].ConvertToJobConstraint();
}
}
}
SPCRJointDynamicsContoller.MaxPointDepth = spcrJointDynamicsSave.MaxPointDepth;
SPCRJointDynamicsContoller._UseLimitAngles = spcrJointDynamicsSave.UseLimitAngles;
SPCRJointDynamicsContoller._LimitAngle = spcrJointDynamicsSave.LimitAngle;
SPCRJointDynamicsContoller._LimitFromRoot = spcrJointDynamicsSave.LimitFromRoot;
SPCRJointDynamicsContoller._LimitPowerCurve = GetAnimCurve(spcrJointDynamicsSave.LimitPowerCurve);
globalUniqueIdList.Clear();
}
void CreationSubdivisionJoint(SPCRJointDynamicsController Controller, int HDivCount, int VDivCount)
{
var VCurve = new List <CurveData>();
var HCurve = new List <CurveData>();
var RootTbl = Controller._RootPointTbl;
#if UNITY_2018_3_OR_NEWER
PrefabUtility.UnpackPrefabInstance(Controller.gameObject, PrefabUnpackMode.Completely, InteractionMode.AutomatedAction);
#else//UNITY_2018_3_OR_NEWER
PrefabUtility.DisconnectPrefabInstance(Controller.gameObject);
#endif//UNITY_2018_3_OR_NEWER
for (int i = 0; i < RootTbl.Length; ++i)
{
float Length = 0.0f;
var Curve = new CurveData();
var Point = RootTbl[i];
while (Point != null)
{
Curve.Keys.Add(new CurveKey()
{
Length = Length,
Value = Point.transform.position,
});
var NextPoint = Controller.GetChildJointDynamicsPoint(Point);
if (NextPoint != null)
{
Length += (NextPoint.transform.position - Point.transform.position).magnitude;
}
Point = NextPoint;
}
Curve.CreateSpileData(Length, false);
VCurve.Add(Curve);
}
for (int v = 0; v <= VDivCount; ++v)
{
float Rate = (float)v / (float)VDivCount;
var Curve = new CurveData();
var OldPoint = VCurve[0].ComputeLinear(Rate);
float Length = 0.0f;
for (int i = 0; i < VCurve.Count; ++i)
{
var NewPoint = VCurve[i].ComputeLinear(Rate);
Length += (NewPoint - OldPoint).magnitude;
Curve.Keys.Add(new CurveKey()
{
Length = Length,
Value = NewPoint,
});
OldPoint = NewPoint;
}
Curve.CreateSpileData(Length, true);
HCurve.Add(Curve);
}
var RootPointList = new List <SPCRJointDynamicsPoint>();
for (int h = 0; h < HDivCount; ++h)
{
float Rate = (float)h / (float)HDivCount;
var parent = Controller._RootTransform;
for (int i = 0; i < HCurve.Count; ++i)
{
var Position = HCurve[i].ComputeSpline(Rate);
var go = new GameObject(h.ToString("D3") + "_" + i.ToString("D3"));
var pt = go.AddComponent <SPCRJointDynamicsPoint>();
go.transform.SetParent(parent);
go.transform.position = Position;
if (i == 0)
{
RootPointList.Add(pt);
}
parent = go.transform;
}
}
for (int i = 0; i < RootTbl.Length; ++i)
{
SetTransformScaleZero(RootTbl[i].transform);
}
Controller._RootPointTbl = RootPointList.ToArray();
Controller.UpdateJointConnection();
GenerateMeshFromBoneConstraints(Controller);
}
void RemoveInsertedPoints(SPCRJointDynamicsController controller)
{
var OriginalPoints = controller._SubDivOriginalPoints;
var InsertedPoints = controller._SubDivInsertedPoints;
if (OriginalPoints.Count == 0)
{
return;
}
controller.DeleteJointConnection();
var originalPoints = new Dictionary <int, SPCRJointDynamicsPoint>(OriginalPoints.Count);
foreach (var op in OriginalPoints)
{
int key = op.GetInstanceID();
if (!originalPoints.ContainsKey(key))
{
originalPoints.Add(key, op);
}
}
var rootList = new List <SPCRJointDynamicsPoint>();
foreach (var root in controller._RootPointTbl)
{
if (!originalPoints.ContainsKey(root.GetInstanceID()))
{
continue;
}
rootList.Add(root);
var parentPoint = root;
var chainPoint = root;
while (chainPoint != null)
{
var children = chainPoint.GetComponentsInChildren <SPCRJointDynamicsPoint>();
if (children.Length < 2)
{
break;
}
var childPoint = children[1];
if (originalPoints.ContainsKey(childPoint.GetInstanceID()))
{
childPoint.transform.SetParent(parentPoint.transform);
parentPoint = childPoint;
}
chainPoint = childPoint;
}
}
foreach (var point in InsertedPoints)
{
point._RefChildPoint = null;
point.transform.SetParent(null);
}
foreach (var point in InsertedPoints)
{
DestroyImmediate(point.gameObject);
}
controller._RootPointTbl = rootList.ToArray();
controller._SubDivOriginalPoints.Clear();
controller._SubDivInsertedPoints.Clear();
}
void UpdateToggle(string Label, SPCRJointDynamicsController Source, ref bool Value)
{
Value = EditorGUILayout.Toggle(Label, Value);
}
private static void SortConstraintsHorizontalRoot(SPCRJointDynamicsController controller, UpdateJointConnectionType Type)
{
switch (Type)
{
case UpdateJointConnectionType.Default: {
}
break;
case UpdateJointConnectionType.SortNearPointXYZ: {
var SourcePoints = new List <SPCRJointDynamicsPoint>();
for (int i = 1; i < controller._RootPointTable.Length; ++i)
{
SourcePoints.Add(controller._RootPointTable[i]);
}
var SortedPoints = new List <SPCRJointDynamicsPoint> {
controller._RootPointTable[0]
};
while (SourcePoints.Count > 0)
{
SortedPoints.Add(PopNearestPoint(
SortedPoints[SortedPoints.Count - 1].transform.position,
SourcePoints,
false));
}
controller._RootPointTable = SortedPoints.ToArray();
}
break;
case UpdateJointConnectionType.SortNearPointXZ: {
var SourcePoints = new List <SPCRJointDynamicsPoint>();
for (int i = 1; i < controller._RootPointTable.Length; ++i)
{
SourcePoints.Add(controller._RootPointTable[i]);
}
var SortedPoints = new List <SPCRJointDynamicsPoint> {
controller._RootPointTable[0]
};
while (SourcePoints.Count > 0)
{
SortedPoints.Add(PopNearestPoint(
SortedPoints[SortedPoints.Count - 1].transform.position,
SourcePoints,
true));
}
controller._RootPointTable = SortedPoints.ToArray();
}
break;
case UpdateJointConnectionType.SortNearPointXYZ_FixedBothEnds: {
var SourcePoints = new List <SPCRJointDynamicsPoint>();
var EdgeB = controller._RootPointTable[controller._RootPointTable.Length - 1];
for (int i = 1; i < controller._RootPointTable.Length - 1; ++i)
{
SourcePoints.Add(controller._RootPointTable[i]);
}
var SortedPoints = new List <SPCRJointDynamicsPoint> {
controller._RootPointTable[0]
};
while (SourcePoints.Count > 0)
{
SortedPoints.Add(PopNearestPoint(
SortedPoints[SortedPoints.Count - 1].transform.position,
SourcePoints,
false));
}
SortedPoints.Add(EdgeB);
controller._RootPointTable = SortedPoints.ToArray();
}
break;
case UpdateJointConnectionType.SortNearPointXZ_FixedBothEnds: {
var SourcePoints = new List <SPCRJointDynamicsPoint>();
var EdgeB = controller._RootPointTable[controller._RootPointTable.Length - 1];
for (int i = 1; i < controller._RootPointTable.Length - 1; ++i)
{
SourcePoints.Add(controller._RootPointTable[i]);
}
var SortedPoints = new List <SPCRJointDynamicsPoint> {
controller._RootPointTable[0]
};
while (SourcePoints.Count > 0)
{
SortedPoints.Add(PopNearestPoint(
SortedPoints[SortedPoints.Count - 1].transform.position,
SourcePoints,
true));
}
SortedPoints.Add(EdgeB);
controller._RootPointTable = SortedPoints.ToArray();
}
break;
}
}
private static void UpdateJointConnection(SPCRJointDynamicsController controller)
{
controller.UpdateJointConnection();
SceneView.RepaintAll();
}
void SubdivideHorizontalChain(SPCRJointDynamicsController controller, int NumInsert)
{
var rnd = new System.Random();
var RootList = new List <SPCRJointDynamicsPoint>(controller._RootPointTbl);
var OriginalPoints = controller._SubDivOriginalPoints;
var InsertedPoints = controller._SubDivInsertedPoints;
var IsFirstSubdivide = (OriginalPoints.Count == 0);
int Count = RootList.Count;
int Start = controller._IsLoopRootPoints ? Count : (Count - 1);
for (int iroot = Start; iroot > 0; iroot--)
{
var root0 = RootList[iroot % Count];
var root1 = RootList[iroot - 1];
for (int iin = 1; iin <= NumInsert; iin++)
{
var point0 = root0;
var point1 = root1;
var parentTransform = root0.transform.parent;
float weight = iin / (NumInsert + 1.0f);
SPCRJointDynamicsPoint newRoot = null;
while (point0 != null && point1 != null)
{
if (IsFirstSubdivide && iin == 1)
{
if (!controller._IsLoopRootPoints && iroot == Start)
{
OriginalPoints.Add(point0);
}
OriginalPoints.Add(point1);
}
var newPoint = CreateInterpolatedPoint(point0, point1, weight, "HSubdiv_" + rnd.Next());
InsertedPoints.Add(newPoint);
var newTransform = newPoint.transform;
newTransform.SetParent(parentTransform);
parentTransform = newTransform;
SPCRJointDynamicsPoint[] points;
points = point0.transform.GetComponentsInChildren <SPCRJointDynamicsPoint>();
point0 = (points.Length > 1) ? points[1] : null;
points = point1.transform.GetComponentsInChildren <SPCRJointDynamicsPoint>();
point1 = (points.Length > 1) ? points[1] : null;
if (newRoot == null)
{
newRoot = newPoint;
RootList.Insert(iroot, newRoot);
}
}
}
}
controller._RootPointTbl = RootList.ToArray();
}
void UpdateIntSlider(string Label, SPCRJointDynamicsController Source, ref int Value, int Min, int Max)
{
Value = EditorGUILayout.IntSlider(Label, Value, Min, Max);
}
void PurgeSubdivideOriginalInfo(SPCRJointDynamicsController controller)
{
controller._SubDivOriginalPoints.Clear();
controller._SubDivInsertedPoints.Clear();
}
void UpdateSlider(string Label, SPCRJointDynamicsController Source, ref float Value, float Min, float Max)
{
Value = EditorGUILayout.Slider(Label, Value, Min, Max);
}
void GenerateMeshFromBoneConstraints(SPCRJointDynamicsController Controller)
{
var vertices = new List <Vector3>();
var boneWeights = new List <BoneWeight>();
var bindposes = new List <Matrix4x4>();
var AllBones = new List <Transform>();
var HorizontalBones = new List <List <Transform> >();
for (int i = 0; i <= Controller._RootPointTbl.Length; ++i)
{
var verticalBones = new List <Transform>();
var child = Controller._RootPointTbl[i % Controller._RootPointTbl.Length];
while (child != null)
{
vertices.Add(child.transform.position);
boneWeights.Add(new BoneWeight()
{
boneIndex0 = AllBones.Count,
weight0 = 1.0f,
});
bindposes.Add(child.transform.worldToLocalMatrix);
AllBones.Add(child.transform);
verticalBones.Add(child.transform);
child = Controller.GetChildJointDynamicsPoint(child);
}
HorizontalBones.Add(verticalBones);
}
var uvs = new List <Vector2>();
for (int h = 0; h < HorizontalBones.Count; ++h)
{
for (int v = 0; v < HorizontalBones[h].Count; ++v)
{
uvs.Add(new Vector2(
(float)h / (float)(HorizontalBones.Count - 1),
(float)v / (float)(HorizontalBones[h].Count - 1)));
}
}
int index = 0;
var triangles = new List <int>();
var HorizontalCount = HorizontalBones.Count;
for (int h = 0; h < HorizontalCount - 1; ++h)
{
var Vertical0Count = HorizontalBones[h].Count;
var Vertical1Count = HorizontalBones[h + 1].Count;
if (Vertical0Count == Vertical1Count)
{
for (int v = 0; v < Vertical0Count - 1; ++v)
{
var top0 = index;
var top1 = index + Vertical0Count;
var x0y0 = top0 + v;
var x1y0 = top0 + v + 1;
var x0y1 = top1 + v;
var x1y1 = top1 + v + 1;
triangles.Add(x0y0);
triangles.Add(x1y0);
triangles.Add(x1y1);
triangles.Add(x1y1);
triangles.Add(x0y1);
triangles.Add(x0y0);
}
}
index += Vertical0Count;
}
var mesh = new Mesh();
mesh.indexFormat = vertices.Count > 65535 ? IndexFormat.UInt32 : IndexFormat.UInt16;
mesh.vertices = vertices.ToArray();
mesh.uv = uvs.ToArray();
mesh.boneWeights = boneWeights.ToArray();
mesh.bindposes = bindposes.ToArray();
mesh.triangles = triangles.ToArray();
RecalculateNormals(mesh);
var renderers = Controller.gameObject.GetComponentsInChildren <SkinnedMeshRenderer>();
if (renderers.Length != 0)
{
var Path = AssetDatabase.GetAssetPath(renderers[renderers.Length - 1].sharedMesh);
var DirName = System.IO.Path.GetDirectoryName(Path);
AssetDatabase.CreateAsset(mesh, DirName + "/" + Controller.gameObject.name + "_" + Controller.Name + ".asset");
AssetDatabase.Refresh();
}
var skinMesh = Controller.gameObject.GetComponent <SkinnedMeshRenderer>();
if (skinMesh == null)
{
skinMesh = Controller.gameObject.AddComponent <SkinnedMeshRenderer>();
}
skinMesh.bones = AllBones.ToArray();
skinMesh.sharedMesh = mesh;
skinMesh.rootBone = Controller._RootTransform;
var meshFilter = Controller.gameObject.GetComponent <MeshFilter>();
if (meshFilter == null)
{
meshFilter = Controller.gameObject.AddComponent <MeshFilter>();
}
meshFilter.mesh = mesh;
}
void UpdateFloat(string Label, SPCRJointDynamicsController Source, ref float Value)
{
Value = EditorGUILayout.FloatField(Label, Value);
}
void UpdateVector3(string Label, SPCRJointDynamicsController Source, ref Vector3 Value)
{
Value = EditorGUILayout.Vector3Field(Label, Value);
}
public static void Save(SPCRJointDynamicsController SPCRJointDynamicsContoller)
{
SPCRJointDynamicsControllerSave spcrJointDynamicsSave = new SPCRJointDynamicsControllerSave();
spcrJointDynamicsSave.name = SPCRJointDynamicsContoller.Name;
spcrJointDynamicsSave.rootTransformName = SPCRJointDynamicsContoller._RootTransform.name;
spcrJointDynamicsSave.spcrChildJointDynamicsPointList = new SPCRJointDynamicsPointSave[SPCRJointDynamicsContoller.PointTbl.Length];
for (int i = 0; i < SPCRJointDynamicsContoller.PointTbl.Length; i++)
{
spcrJointDynamicsSave.spcrChildJointDynamicsPointList[i] = new SPCRJointDynamicsPointSave(SPCRJointDynamicsContoller.PointTbl[i]);
}
spcrJointDynamicsSave.spcrChildJointDynamicsColliderList = new SPCRJointDynamicsColliderSave[SPCRJointDynamicsContoller._ColliderTbl.Length];
for (int i = 0; i < SPCRJointDynamicsContoller._ColliderTbl.Length; i++)
{
spcrJointDynamicsSave.spcrChildJointDynamicsColliderList[i] = new SPCRJointDynamicsColliderSave(SPCRJointDynamicsContoller._ColliderTbl[i]);
}
UpdateIDIfSameUniqueId(ref spcrJointDynamicsSave.spcrChildJointDynamicsColliderList);
spcrJointDynamicsSave.spcrChildJointDynamicsPointGtabberList = new SPCRJointDynamicsPointGrabberSave[SPCRJointDynamicsContoller._PointGrabberTbl.Length];
for (int i = 0; i < SPCRJointDynamicsContoller._PointGrabberTbl.Length; i++)
{
spcrJointDynamicsSave.spcrChildJointDynamicsPointGtabberList[i] = new SPCRJointDynamicsPointGrabberSave(SPCRJointDynamicsContoller._PointGrabberTbl[i]);
}
UpdateIDIfSameUniqueId(ref spcrJointDynamicsSave.spcrChildJointDynamicsPointGtabberList);
if (SPCRJointDynamicsContoller._RootPointTbl != null && SPCRJointDynamicsContoller._RootPointTbl.Length > 0)
{
spcrJointDynamicsSave.RootPointTbl = new string[SPCRJointDynamicsContoller._RootPointTbl.Length];
for (int i = 0; i < SPCRJointDynamicsContoller._RootPointTbl.Length; i++)
{
spcrJointDynamicsSave.RootPointTbl[i] = SPCRJointDynamicsContoller._RootPointTbl[i].UniqueGUIID;
}
}
spcrJointDynamicsSave.Relaxation = SPCRJointDynamicsContoller._Relaxation;
spcrJointDynamicsSave.SubSteps = SPCRJointDynamicsContoller._SubSteps;
//@spcrJointDynamicsSave.IsEnablePointCollision = SPCRJointDynamicsContoller._IsEnablePointCollision;
//@spcrJointDynamicsSave.DetailHitDivideMax = SPCRJointDynamicsContoller._DetailHitDivideMax;
spcrJointDynamicsSave.IsCancelResetPhysics = SPCRJointDynamicsContoller._IsCancelResetPhysics;
spcrJointDynamicsSave.IsEnableSurfaceCollision = SPCRJointDynamicsContoller._IsEnableSurfaceCollision;
spcrJointDynamicsSave.SurfaceCollisionDivision = SPCRJointDynamicsContoller._SurfaceCollisionDivision;
spcrJointDynamicsSave.MassScaleCurve = GetSPCRAnimaCurveKeyFrames(SPCRJointDynamicsContoller._MassScaleCurve);
spcrJointDynamicsSave.GravityScaleCurve = GetSPCRAnimaCurveKeyFrames(SPCRJointDynamicsContoller._GravityScaleCurve);
spcrJointDynamicsSave.ResistanceCurve = GetSPCRAnimaCurveKeyFrames(SPCRJointDynamicsContoller._ResistanceCurve);
spcrJointDynamicsSave.HardnessCurve = GetSPCRAnimaCurveKeyFrames(SPCRJointDynamicsContoller._HardnessCurve);
spcrJointDynamicsSave.FrictionCurve = GetSPCRAnimaCurveKeyFrames(SPCRJointDynamicsContoller._FrictionCurve);
spcrJointDynamicsSave.AllShrinkScaleCurve = GetSPCRAnimaCurveKeyFrames(SPCRJointDynamicsContoller._AllShrinkScaleCurve);
spcrJointDynamicsSave.AllStretchScaleCurve = GetSPCRAnimaCurveKeyFrames(SPCRJointDynamicsContoller._AllStretchScaleCurve);
spcrJointDynamicsSave.StructuralShrinkVerticalScaleCurve = GetSPCRAnimaCurveKeyFrames(SPCRJointDynamicsContoller._StructuralShrinkVerticalScaleCurve);
spcrJointDynamicsSave.StructuralStretchVerticalScaleCurve = GetSPCRAnimaCurveKeyFrames(SPCRJointDynamicsContoller._StructuralStretchVerticalScaleCurve);
spcrJointDynamicsSave.StructuralShrinkHorizontalScaleCurve = GetSPCRAnimaCurveKeyFrames(SPCRJointDynamicsContoller._StructuralShrinkHorizontalScaleCurve);
spcrJointDynamicsSave.StructuralStretchHorizontalScaleCurve = GetSPCRAnimaCurveKeyFrames(SPCRJointDynamicsContoller._StructuralStretchHorizontalScaleCurve);
spcrJointDynamicsSave.ShearShrinkScaleCurve = GetSPCRAnimaCurveKeyFrames(SPCRJointDynamicsContoller._ShearShrinkScaleCurve);
spcrJointDynamicsSave.ShearStretchScaleCurve = GetSPCRAnimaCurveKeyFrames(SPCRJointDynamicsContoller._ShearStretchScaleCurve);
spcrJointDynamicsSave.BendingShrinkVerticalScaleCurve = GetSPCRAnimaCurveKeyFrames(SPCRJointDynamicsContoller._BendingShrinkVerticalScaleCurve);
spcrJointDynamicsSave.BendingStretchVerticalScaleCurve = GetSPCRAnimaCurveKeyFrames(SPCRJointDynamicsContoller._BendingStretchVerticalScaleCurve);
spcrJointDynamicsSave.BendingShrinkHorizontalScaleCurve = GetSPCRAnimaCurveKeyFrames(SPCRJointDynamicsContoller._BendingShrinkHorizontalScaleCurve);
spcrJointDynamicsSave.BendingStretchHorizontalScaleCurve = GetSPCRAnimaCurveKeyFrames(SPCRJointDynamicsContoller._BendingStretchHorizontalScaleCurve);
spcrJointDynamicsSave.Gravity = new SPCRvec3(SPCRJointDynamicsContoller._Gravity);
spcrJointDynamicsSave.WindForce = new SPCRvec3(SPCRJointDynamicsContoller._WindForce);
spcrJointDynamicsSave.RootSlideLimit = SPCRJointDynamicsContoller._RootSlideLimit;
spcrJointDynamicsSave.RootRotateLimit = SPCRJointDynamicsContoller._RootRotateLimit;
spcrJointDynamicsSave.StructuralShrinkVertical = SPCRJointDynamicsContoller._StructuralShrinkVertical;
spcrJointDynamicsSave.StructuralStretchVertical = SPCRJointDynamicsContoller._StructuralStretchVertical;
spcrJointDynamicsSave.StructuralShrinkHorizontal = SPCRJointDynamicsContoller._StructuralShrinkHorizontal;
spcrJointDynamicsSave.StructuralStretchHorizontal = SPCRJointDynamicsContoller._StructuralStretchHorizontal;
spcrJointDynamicsSave.ShearShrink = SPCRJointDynamicsContoller._ShearShrink;
spcrJointDynamicsSave.ShearStretch = SPCRJointDynamicsContoller._ShearStretch;
spcrJointDynamicsSave.BendingShrinkVertical = SPCRJointDynamicsContoller._BendingShrinkVertical;
spcrJointDynamicsSave.BendingStretchVertical = SPCRJointDynamicsContoller._BendingStretchVertical;
spcrJointDynamicsSave.BendingShrinkHorizontal = SPCRJointDynamicsContoller._BendingShrinkHorizontal;
spcrJointDynamicsSave.BendingStretchHorizontal = SPCRJointDynamicsContoller._BendingStretchHorizontal;
spcrJointDynamicsSave.IsAllStructuralShrinkVertical = SPCRJointDynamicsContoller._IsAllStructuralShrinkVertical;
spcrJointDynamicsSave.IsAllStructuralStretchVertical = SPCRJointDynamicsContoller._IsAllStructuralStretchVertical;
spcrJointDynamicsSave.IsAllStructuralShrinkHorizontal = SPCRJointDynamicsContoller._IsAllStructuralShrinkHorizontal;
spcrJointDynamicsSave.IsAllStructuralStretchHorizontal = SPCRJointDynamicsContoller._IsAllStructuralStretchHorizontal;
spcrJointDynamicsSave.IsAllShearShrink = SPCRJointDynamicsContoller._IsAllShearShrink;
spcrJointDynamicsSave.IsAllShearStretch = SPCRJointDynamicsContoller._IsAllShearStretch;
spcrJointDynamicsSave.IsAllBendingShrinkVertical = SPCRJointDynamicsContoller._IsAllBendingShrinkVertical;
spcrJointDynamicsSave.IsAllBendingStretchVertical = SPCRJointDynamicsContoller._IsAllBendingStretchVertical;
spcrJointDynamicsSave.IsAllBendingShrinkHorizontal = SPCRJointDynamicsContoller._IsAllBendingShrinkHorizontal;
spcrJointDynamicsSave.IsAllBendingStretchHorizontal = SPCRJointDynamicsContoller._IsAllBendingStretchHorizontal;
spcrJointDynamicsSave.IsCollideStructuralVertical = SPCRJointDynamicsContoller._IsCollideStructuralVertical;
spcrJointDynamicsSave.IsCollideStructuralHorizontal = SPCRJointDynamicsContoller._IsCollideStructuralHorizontal;
spcrJointDynamicsSave.IsCollideShear = SPCRJointDynamicsContoller._IsCollideShear;
spcrJointDynamicsSave.PointTblIDs = new string[SPCRJointDynamicsContoller.PointTbl.Length];
spcrJointDynamicsSave.IsLoopRootPoints = SPCRJointDynamicsContoller._IsLoopRootPoints;
spcrJointDynamicsSave.IsComputeStructuralVertical = SPCRJointDynamicsContoller._IsComputeStructuralVertical;
spcrJointDynamicsSave.IsComputeStructuralHorizontal = SPCRJointDynamicsContoller._IsComputeStructuralHorizontal;
spcrJointDynamicsSave.IsComputeShear = SPCRJointDynamicsContoller._IsComputeShear;
spcrJointDynamicsSave.IsComputeBendingVertical = SPCRJointDynamicsContoller._IsComputeBendingVertical;
spcrJointDynamicsSave.IsComputeBendingHorizontal = SPCRJointDynamicsContoller._IsComputeBendingHorizontal;
spcrJointDynamicsSave.IsDebugDraw_StructuralVertical = SPCRJointDynamicsContoller._IsDebugDraw_StructuralVertical;
spcrJointDynamicsSave.IsDebugDraw_StructuralHorizontal = SPCRJointDynamicsContoller._IsDebugDraw_StructuralHorizontal;
spcrJointDynamicsSave.IsDebugDraw_Shear = SPCRJointDynamicsContoller._IsDebugDraw_Shear;
spcrJointDynamicsSave.IsDebugDraw_BendingVertical = SPCRJointDynamicsContoller._IsDebugDraw_BendingVertical;
spcrJointDynamicsSave.IsDebugDraw_BendingHorizontal = SPCRJointDynamicsContoller._IsDebugDraw_BendingHorizontal;
spcrJointDynamicsSave.IsDebugDraw_SurfaceFace = SPCRJointDynamicsContoller._IsDebugDraw_SurfaceFace;
spcrJointDynamicsSave.Debug_SurfaceNoramlLength = SPCRJointDynamicsContoller._Debug_SurfaceNormalLength;
spcrJointDynamicsSave.IsDebugDraw_RuntimeColliderBounds = SPCRJointDynamicsContoller._IsDebugDraw_RuntimeColliderBounds;
if (SPCRJointDynamicsContoller.ConstraintTable != null)
{
spcrJointDynamicsSave.ConstraintTable = new SPCRConstraintSave[SPCRJointDynamicsContoller.ConstraintTable.Length][];
for (int i = 0; i < SPCRJointDynamicsContoller.ConstraintTable.Length; i++)
{
spcrJointDynamicsSave.ConstraintTable[i] = new SPCRConstraintSave[SPCRJointDynamicsContoller.ConstraintTable[i].Length];
for (int j = 0; j < SPCRJointDynamicsContoller.ConstraintTable[i].Length; j++)
{
spcrJointDynamicsSave.ConstraintTable[i][j] = new SPCRConstraintSave(SPCRJointDynamicsContoller.ConstraintTable[i][j]);
}
}
}
spcrJointDynamicsSave.UseLimitAngles = SPCRJointDynamicsContoller._UseLimitAngles;
spcrJointDynamicsSave.LimitAngle = SPCRJointDynamicsContoller._LimitAngle;
spcrJointDynamicsSave.LimitFromRoot = SPCRJointDynamicsContoller._LimitFromRoot;
spcrJointDynamicsSave.LimitPowerCurve = GetSPCRAnimaCurveKeyFrames(SPCRJointDynamicsContoller._LimitPowerCurve);
spcrJointDynamicsSave.MaxPointDepth = SPCRJointDynamicsContoller.MaxPointDepth;
SaveIntoBinary(spcrJointDynamicsSave);
}
