// Token: 0x060000E2 RID: 226 RVA: 0x00005D98 File Offset: 0x00003F98
private void SetupParticles()
{
this.m_Particles.Clear();
if (this.m_Root == null)
{
return;
}
this.m_LocalGravity = this.m_Root.InverseTransformDirection(this.m_Gravity);
this.m_ObjectScale = Mathf.Abs(base.transform.lossyScale.x);
this.m_ObjectPrevPosition = base.transform.position;
this.m_ObjectMove = Vector3.zero;
this.m_BoneTotalLength = 0f;
this.AppendParticles(this.m_Root, -1, 0f);
for (int i = 0; i < this.m_Particles.Count; i++)
{
DynamicBone.Particle particle = this.m_Particles[i];
particle.m_Damping = this.m_Damping;
particle.m_Elasticity = this.m_Elasticity;
particle.m_Stiffness = this.m_Stiffness;
particle.m_Inert = this.m_Inert;
particle.m_Radius = this.m_Radius;
if (this.m_BoneTotalLength > 0f)
{
float time = particle.m_BoneLength / this.m_BoneTotalLength;
if (this.m_DampingDistrib != null && this.m_DampingDistrib.keys.Length != 0)
{
particle.m_Damping *= this.m_DampingDistrib.Evaluate(time);
}
if (this.m_ElasticityDistrib != null && this.m_ElasticityDistrib.keys.Length != 0)
{
particle.m_Elasticity *= this.m_ElasticityDistrib.Evaluate(time);
}
if (this.m_StiffnessDistrib != null && this.m_StiffnessDistrib.keys.Length != 0)
{
particle.m_Stiffness *= this.m_StiffnessDistrib.Evaluate(time);
}
if (this.m_InertDistrib != null && this.m_InertDistrib.keys.Length != 0)
{
particle.m_Inert *= this.m_InertDistrib.Evaluate(time);
}
if (this.m_RadiusDistrib != null && this.m_RadiusDistrib.keys.Length != 0)
{
particle.m_Radius *= this.m_RadiusDistrib.Evaluate(time);
}
}
particle.m_Damping = Mathf.Clamp01(particle.m_Damping);
particle.m_Elasticity = Mathf.Clamp01(particle.m_Elasticity);
particle.m_Stiffness = Mathf.Clamp01(particle.m_Stiffness);
particle.m_Inert = Mathf.Clamp01(particle.m_Inert);
particle.m_Radius = Mathf.Max(particle.m_Radius, 0f);
}
}
// Token: 0x0600000F RID: 15 RVA: 0x00002A4C File Offset: 0x00000C4C
private void InitTransforms()
{
for (int i = 0; i < this.m_Particles.Count; i++)
{
DynamicBone.Particle particle = this.m_Particles[i];
bool flag = particle.m_Transform != null;
if (flag)
{
particle.m_Transform.localPosition = particle.m_InitLocalPosition;
particle.m_Transform.localRotation = particle.m_InitLocalRotation;
}
}
}
public void ResetParticlesPosition()
{
for (int index = 0; index < this.m_Particles.Count; ++index)
{
DynamicBone.Particle particle = this.m_Particles[index];
if (Object.op_Inequality((Object)particle.m_Transform, (Object)null))
{
particle.m_Position = particle.m_PrevPosition = particle.m_Transform.get_position();
}
else
{
Transform transform = this.m_Particles[particle.m_ParentIndex].m_Transform;
particle.m_Position = particle.m_PrevPosition = transform.TransformPoint(particle.m_EndOffset);
}
}
this.m_ObjectPrevPosition = ((Component)this).get_transform().get_position();
}
public void UpdateParameters()
{
if (Object.op_Equality((Object)this.m_Root, (Object)null))
{
return;
}
this.m_LocalGravity = this.m_Root.InverseTransformDirection(this.m_Gravity);
for (int index = 0; index < this.m_Particles.Count; ++index)
{
DynamicBone.Particle particle = this.m_Particles[index];
particle.m_Damping = this.m_Damping;
particle.m_Elasticity = this.m_Elasticity;
particle.m_Stiffness = this.m_Stiffness;
particle.m_Inert = this.m_Inert;
particle.m_Radius = this.m_Radius;
if ((double)this.m_BoneTotalLength > 0.0)
{
float num = particle.m_BoneLength / this.m_BoneTotalLength;
if (this.m_DampingDistrib != null && this.m_DampingDistrib.get_keys().Length > 0)
{
particle.m_Damping *= this.m_DampingDistrib.Evaluate(num);
}
if (this.m_ElasticityDistrib != null && this.m_ElasticityDistrib.get_keys().Length > 0)
{
particle.m_Elasticity *= this.m_ElasticityDistrib.Evaluate(num);
}
if (this.m_StiffnessDistrib != null && this.m_StiffnessDistrib.get_keys().Length > 0)
{
particle.m_Stiffness *= this.m_StiffnessDistrib.Evaluate(num);
}
if (this.m_InertDistrib != null && this.m_InertDistrib.get_keys().Length > 0)
{
particle.m_Inert *= this.m_InertDistrib.Evaluate(num);
}
if (this.m_RadiusDistrib != null && this.m_RadiusDistrib.get_keys().Length > 0)
{
particle.m_Radius *= this.m_RadiusDistrib.Evaluate(num);
}
}
particle.m_Damping = Mathf.Clamp01(particle.m_Damping);
particle.m_Elasticity = Mathf.Clamp01(particle.m_Elasticity);
particle.m_Stiffness = Mathf.Clamp01(particle.m_Stiffness);
particle.m_Inert = Mathf.Clamp01(particle.m_Inert);
particle.m_Radius = Mathf.Max(particle.m_Radius, 0.0f);
}
}
private void ResetParticlesPosition()
{
for (int i = 0; i < this.m_Particles.Count; i++)
{
DynamicBone.Particle particle = this.m_Particles[i];
if (particle.m_Transform != null)
{
particle.m_Position = (particle.m_PrevPosition = particle.m_Transform.position);
}
else
{
Transform transform = this.m_Particles[particle.m_ParentIndex].m_Transform;
particle.m_Position = (particle.m_PrevPosition = transform.TransformPoint(particle.m_EndOffset));
}
}
this.m_ObjectPrevPosition = base.transform.position;
}
public void UpdateParameters()
{
if (this.m_Root == null)
{
return;
}
this.m_LocalGravity = this.m_Root.InverseTransformDirection(this.m_Gravity);
for (int i = 0; i < this.m_Particles.Count; i++)
{
DynamicBone.Particle particle = this.m_Particles[i];
particle.m_Damping = this.m_Damping;
particle.m_Elasticity = this.m_Elasticity;
particle.m_Stiffness = this.m_Stiffness;
particle.m_Inert = this.m_Inert;
particle.m_Radius = this.m_Radius;
if (this.m_BoneTotalLength > 0f)
{
float time = particle.m_BoneLength / this.m_BoneTotalLength;
if (this.m_DampingDistrib != null && this.m_DampingDistrib.keys.Length != 0)
{
particle.m_Damping *= this.m_DampingDistrib.Evaluate(time);
}
if (this.m_ElasticityDistrib != null && this.m_ElasticityDistrib.keys.Length != 0)
{
particle.m_Elasticity *= this.m_ElasticityDistrib.Evaluate(time);
}
if (this.m_StiffnessDistrib != null && this.m_StiffnessDistrib.keys.Length != 0)
{
particle.m_Stiffness *= this.m_StiffnessDistrib.Evaluate(time);
}
if (this.m_InertDistrib != null && this.m_InertDistrib.keys.Length != 0)
{
particle.m_Inert *= this.m_InertDistrib.Evaluate(time);
}
if (this.m_RadiusDistrib != null && this.m_RadiusDistrib.keys.Length != 0)
{
particle.m_Radius *= this.m_RadiusDistrib.Evaluate(time);
}
}
particle.m_Damping = Mathf.Clamp01(particle.m_Damping);
particle.m_Elasticity = Mathf.Clamp01(particle.m_Elasticity);
particle.m_Stiffness = Mathf.Clamp01(particle.m_Stiffness);
particle.m_Inert = Mathf.Clamp01(particle.m_Inert);
particle.m_Radius = Mathf.Max(particle.m_Radius, 0f);
}
}
private void ApplyParticlesToTransforms()
{
for (int index = 1; index < this.m_Particles.Count; ++index)
{
DynamicBone.Particle particle1 = this.m_Particles[index];
DynamicBone.Particle particle2 = this.m_Particles[particle1.m_ParentIndex];
if (particle2.m_Transform.get_childCount() <= 1)
{
Vector3 vector3_1 = !Object.op_Inequality((Object)particle1.m_Transform, (Object)null) ? particle1.m_EndOffset : particle1.m_Transform.get_localPosition();
Vector3 vector3_2 = Vector3.op_Subtraction(particle1.m_Position, particle2.m_Position);
Quaternion rotation = Quaternion.FromToRotation(particle2.m_Transform.TransformDirection(vector3_1), vector3_2);
particle2.m_Transform.set_rotation(Quaternion.op_Multiply(rotation, particle2.m_Transform.get_rotation()));
}
if (Object.op_Inequality((Object)particle1.m_Transform, (Object)null))
{
particle1.m_Transform.set_position(particle1.m_Position);
}
}
}
public void ApplyParticlesToTransforms(DynamicBone bone)
{
for (int i = 1; i < m_Particles.Count; ++i)
{
DynamicBone.Particle p = bone.m_Particles[i];
DynamicBone.Particle p0 = bone.m_Particles[p.m_ParentIndex];
DynamicBoneMT.Particle pMT = m_Particles[i];
DynamicBoneMT.Particle p0MT = m_Particles[pMT.m_ParentIndex];
if (p0.m_Transform.childCount <= 1)
{
Vector3 v;
if (pMT.m_Transform != null)
{
v = pMT.m_InitLocalPosition;
}
else
{
v = pMT.m_EndOffset;
}
Quaternion rot = Quaternion.FromToRotation(p0.m_Transform.TransformDirection(v), pMT.m_Position - p0MT.m_Position);
p0.m_Transform.rotation = rot * p0.m_Transform.rotation;
//todo 旋转错帧修正
}
if (p.m_Transform != null)
{
p.m_Transform.position = pMT.m_Position;
//todo 位移错帧修正
}
}
}
private void UpdateParticlesForIJob()
{
NativeArray <DynamicBone.ParticleStruct> nativeArray1;
((NativeArray <DynamicBone.ParticleStruct>) ref nativeArray1).\u002Ector(this.m_Particles.Count, (Allocator)2, (NativeArrayOptions)1);
NativeArray <DynamicBone.CollisionStruct> nativeArray2;
((NativeArray <DynamicBone.CollisionStruct>) ref nativeArray2).\u002Ector(this.m_Colliders.Count, (Allocator)2, (NativeArrayOptions)1);
for (int index = 0; index < this.m_Particles.Count; ++index)
{
DynamicBone.Particle particle = this.m_Particles[index];
((NativeArray <DynamicBone.ParticleStruct>) ref nativeArray1).set_Item(index, new DynamicBone.ParticleStruct()
{
parentIndex = particle.m_ParentIndex,
damping = particle.m_Damping,
elasticity = particle.m_Elasticity,
stiffness = particle.m_Stiffness,
inert = particle.m_Inert,
radius = particle.m_Radius,
boneLength = particle.m_BoneLength,
isTransform = !Object.op_Implicit((Object)particle.m_Transform) ? 0 : 1,
transWorldPosition = !Object.op_Implicit((Object)particle.m_Transform) ? Vector3.get_zero() : particle.m_Transform.get_position(),
transLocalPosition = !Object.op_Implicit((Object)particle.m_Transform) ? Vector3.get_zero() : particle.m_Transform.get_localPosition(),
position = particle.m_Position,
prevPosition = particle.m_PrevPosition,
endOffset = particle.m_EndOffset,
initLocalPosition = particle.m_InitLocalPosition,
initLocalRotation = particle.m_InitLocalRotation,
worldMatrix = !Object.op_Implicit((Object)particle.m_Transform) ? Matrix4x4.get_identity() : particle.m_Transform.get_localToWorldMatrix()
});
}
for (int index = 0; index < this.m_Colliders.Count; ++index)
{
DynamicBoneCollider collider = this.m_Colliders[index] as DynamicBoneCollider;
if (!Object.op_Equality((Object)collider, (Object)null) && ((Behaviour)collider).get_enabled())
{
((NativeArray <DynamicBone.CollisionStruct>) ref nativeArray2).set_Item(index, new DynamicBone.CollisionStruct()
{
direction = collider.m_Direction,
center = collider.m_Center,
bound = collider.m_Bound,
radius = collider.m_Radius,
height = collider.m_Height,
lossyScale = ((Component)collider).get_transform().get_lossyScale(),
worldMatrix = ((Component)collider).get_transform().get_localToWorldMatrix()
});
}
}
JobHandle jobHandle = IJobExtensions.Schedule <DynamicBone.CalcJob>((M0) new DynamicBone.CalcJob()
{
calcs = nativeArray1,
colls = nativeArray2,
weight = this.m_Weight,
objectScale = this.m_ObjectScale
}, (JobHandle)null);
((JobHandle) ref jobHandle).Complete();
for (int index = 0; index < this.m_Particles.Count; ++index)
{
this.m_Particles[index].m_Position = ((NativeArray <DynamicBone.ParticleStruct>) ref nativeArray1).get_Item(index).position;
}
((NativeArray <DynamicBone.ParticleStruct>) ref nativeArray1).Dispose();
((NativeArray <DynamicBone.CollisionStruct>) ref nativeArray2).Dispose();
}
private void UpdateParticles2()
{
Plane plane = (Plane)null;
for (int index1 = 1; index1 < this.m_Particles.Count; ++index1)
{
DynamicBone.Particle particle1 = this.m_Particles[index1];
DynamicBone.Particle particle2 = this.m_Particles[particle1.m_ParentIndex];
float magnitude1;
if (Object.op_Inequality((Object)particle1.m_Transform, (Object)null))
{
Vector3 vector3 = Vector3.op_Subtraction(particle2.m_Transform.get_position(), particle1.m_Transform.get_position());
magnitude1 = ((Vector3) ref vector3).get_magnitude();
}
else
{
Matrix4x4 localToWorldMatrix = particle2.m_Transform.get_localToWorldMatrix();
Vector3 vector3 = ((Matrix4x4) ref localToWorldMatrix).MultiplyVector(particle1.m_EndOffset);
magnitude1 = ((Vector3) ref vector3).get_magnitude();
}
float num1 = Mathf.Lerp(1f, particle1.m_Stiffness, this.m_Weight);
if ((double)num1 > 0.0 || (double)particle1.m_Elasticity > 0.0)
{
Matrix4x4 localToWorldMatrix = particle2.m_Transform.get_localToWorldMatrix();
((Matrix4x4) ref localToWorldMatrix).SetColumn(3, Vector4.op_Implicit(particle2.m_Position));
Vector3 vector3_1 = !Object.op_Inequality((Object)particle1.m_Transform, (Object)null) ? ((Matrix4x4) ref localToWorldMatrix).MultiplyPoint3x4(particle1.m_EndOffset) : ((Matrix4x4) ref localToWorldMatrix).MultiplyPoint3x4(particle1.m_Transform.get_localPosition());
Vector3 vector3_2 = Vector3.op_Subtraction(vector3_1, particle1.m_Position);
DynamicBone.Particle particle3 = particle1;
particle3.m_Position = Vector3.op_Addition(particle3.m_Position, Vector3.op_Multiply(vector3_2, particle1.m_Elasticity));
if ((double)num1 > 0.0)
{
Vector3 vector3_3 = Vector3.op_Subtraction(vector3_1, particle1.m_Position);
float magnitude2 = ((Vector3) ref vector3_3).get_magnitude();
float num2 = (float)((double)magnitude1 * (1.0 - (double)num1) * 2.0);
if ((double)magnitude2 > (double)num2)
{
DynamicBone.Particle particle4 = particle1;
particle4.m_Position = Vector3.op_Addition(particle4.m_Position, Vector3.op_Multiply(vector3_3, (magnitude2 - num2) / magnitude2));
}
}
}
if (this.m_Colliders != null)
{
float particleRadius = particle1.m_Radius * this.m_ObjectScale;
for (int index2 = 0; index2 < this.m_Colliders.Count; ++index2)
{
DynamicBoneColliderBase collider = this.m_Colliders[index2];
if (Object.op_Inequality((Object)collider, (Object)null) && ((Behaviour)collider).get_enabled())
{
collider.Collide(ref particle1.m_Position, particleRadius);
}
}
}
if (this.m_FreezeAxis != DynamicBone.FreezeAxis.None)
{
switch (this.m_FreezeAxis)
{
case DynamicBone.FreezeAxis.X:
((Plane) ref plane).SetNormalAndPosition(particle2.m_Transform.get_right(), particle2.m_Position);
break;
case DynamicBone.FreezeAxis.Y:
((Plane) ref plane).SetNormalAndPosition(particle2.m_Transform.get_up(), particle2.m_Position);
break;
case DynamicBone.FreezeAxis.Z:
((Plane) ref plane).SetNormalAndPosition(particle2.m_Transform.get_forward(), particle2.m_Position);
break;
}
DynamicBone.Particle particle3 = particle1;
particle3.m_Position = Vector3.op_Subtraction(particle3.m_Position, Vector3.op_Multiply(((Plane) ref plane).get_normal(), ((Plane) ref plane).GetDistanceToPoint(particle1.m_Position)));
}
Vector3 vector3_4 = Vector3.op_Subtraction(particle2.m_Position, particle1.m_Position);
float magnitude3 = ((Vector3) ref vector3_4).get_magnitude();
if ((double)magnitude3 > 0.0)
{
DynamicBone.Particle particle3 = particle1;
particle3.m_Position = Vector3.op_Addition(particle3.m_Position, Vector3.op_Multiply(vector3_4, (magnitude3 - magnitude1) / magnitude3));
}
}
}
private void AppendParticles(Transform b, int parentIndex, float boneLength)
{
DynamicBone.Particle particle = new DynamicBone.Particle();
particle.m_Transform = b;
particle.m_ParentIndex = parentIndex;
if (Object.op_Inequality((Object)b, (Object)null))
{
particle.m_Position = particle.m_PrevPosition = b.get_position();
particle.m_InitLocalPosition = b.get_localPosition();
particle.m_InitLocalRotation = b.get_localRotation();
}
else
{
Transform transform = this.m_Particles[parentIndex].m_Transform;
if ((double)this.m_EndLength > 0.0)
{
Transform parent = transform.get_parent();
particle.m_EndOffset = !Object.op_Inequality((Object)parent, (Object)null) ? new Vector3(this.m_EndLength, 0.0f, 0.0f) : Vector3.op_Multiply(transform.InverseTransformPoint(Vector3.op_Subtraction(Vector3.op_Multiply(transform.get_position(), 2f), parent.get_position())), this.m_EndLength);
}
else
{
particle.m_EndOffset = transform.InverseTransformPoint(Vector3.op_Addition(((Component)this).get_transform().TransformDirection(this.m_EndOffset), transform.get_position()));
}
particle.m_Position = particle.m_PrevPosition = transform.TransformPoint(particle.m_EndOffset);
}
if (parentIndex >= 0)
{
double num = (double)boneLength;
Vector3 vector3 = Vector3.op_Subtraction(this.m_Particles[parentIndex].m_Transform.get_position(), particle.m_Position);
double magnitude = (double)((Vector3) ref vector3).get_magnitude();
boneLength = (float)(num + magnitude);
particle.m_BoneLength = boneLength;
this.m_BoneTotalLength = Mathf.Max(this.m_BoneTotalLength, boneLength);
}
int count = this.m_Particles.Count;
this.m_Particles.Add(particle);
bool flag1 = false;
int num1 = 0;
if (!Object.op_Inequality((Object)b, (Object)null))
{
return;
}
for (int index1 = 0; index1 < b.get_childCount(); ++index1)
{
bool flag2 = false;
if (this.m_Exclusions != null)
{
for (int index2 = 0; index2 < this.m_Exclusions.Count; ++index2)
{
if (Object.op_Equality((Object)this.m_Exclusions[index2], (Object)b.GetChild(index1)))
{
flag2 = true;
break;
}
}
}
if (!flag2)
{
for (int index2 = 0; index2 < this.m_notRolls.Count; ++index2)
{
if (Object.op_Equality((Object)this.m_notRolls[index2], (Object)b.GetChild(index1)))
{
flag1 = true;
flag2 = true;
num1 = index1;
break;
}
}
}
if (!flag2)
{
this.AppendParticles(b.GetChild(index1), count, boneLength);
}
else if ((double)this.m_EndLength > 0.0 || Vector3.op_Inequality(this.m_EndOffset, Vector3.get_zero()))
{
this.AppendParticles((Transform)null, count, boneLength);
}
}
if (flag1)
{
for (int index1 = 0; index1 < b.GetChild(num1).get_childCount(); ++index1)
{
bool flag2 = false;
for (int index2 = 0; index2 < this.m_Exclusions.Count; ++index2)
{
if (Object.op_Equality((Object)this.m_Exclusions[index2], (Object)b.GetChild(num1).GetChild(index1)))
{
flag2 = true;
break;
}
}
if (!flag2)
{
for (int index2 = 0; index2 < this.m_notRolls.Count; ++index2)
{
if (Object.op_Equality((Object)this.m_notRolls[index2], (Object)b.GetChild(num1).GetChild(index1)))
{
flag2 = true;
break;
}
}
}
if (!flag2)
{
this.AppendParticles(b.GetChild(num1).GetChild(index1), count, boneLength);
}
}
}
if (b.get_childCount() != 0 || (double)this.m_EndLength <= 0.0 && !Vector3.op_Inequality(this.m_EndOffset, Vector3.get_zero()))
{
return;
}
this.AppendParticles((Transform)null, count, boneLength);
}
// Token: 0x06000013 RID: 19 RVA: 0x00003018 File Offset: 0x00001218
private void SkipUpdateParticles()
{
for (int i = 0; i < this.m_Particles.Count; i++)
{
DynamicBone.Particle particle = this.m_Particles[i];
bool flag = particle.m_ParentIndex >= 0;
if (flag)
{
particle.m_PrevPosition += this.m_ObjectMove;
particle.m_Position += this.m_ObjectMove;
DynamicBone.Particle particle2 = this.m_Particles[particle.m_ParentIndex];
bool flag2 = particle.m_Transform != null;
float magnitude;
if (flag2)
{
magnitude = (particle2.m_Transform.position - particle.m_Transform.position).magnitude;
}
else
{
magnitude = particle2.m_Transform.localToWorldMatrix.MultiplyVector(particle.m_EndOffset).magnitude;
}
float num = Mathf.Lerp(1f, particle.m_Stiffness, this.m_Weight);
bool flag3 = num > 0f;
if (flag3)
{
Matrix4x4 localToWorldMatrix = particle2.m_Transform.localToWorldMatrix;
localToWorldMatrix.SetColumn(3, particle2.m_Position);
bool flag4 = particle.m_Transform != null;
Vector3 vector;
if (flag4)
{
vector = localToWorldMatrix.MultiplyPoint3x4(particle.m_Transform.localPosition);
}
else
{
vector = localToWorldMatrix.MultiplyPoint3x4(particle.m_EndOffset);
}
Vector3 vector2 = vector - particle.m_Position;
float magnitude2 = vector2.magnitude;
float num2 = magnitude * (1f - num) * 2f;
bool flag5 = magnitude2 > num2;
if (flag5)
{
particle.m_Position += vector2 * ((magnitude2 - num2) / magnitude2);
}
}
Vector3 vector3 = particle2.m_Position - particle.m_Position;
float magnitude3 = vector3.magnitude;
bool flag6 = magnitude3 > 0f;
if (flag6)
{
particle.m_Position += vector3 * ((magnitude3 - magnitude) / magnitude3);
}
}
else
{
particle.m_PrevPosition = particle.m_Position;
particle.m_Position = particle.m_Transform.position;
}
}
}
// Token: 0x06000012 RID: 18 RVA: 0x00002CC0 File Offset: 0x00000EC0
private void UpdateParticles2()
{
Plane plane = default(Plane);
for (int i = 1; i < this.m_Particles.Count; i++)
{
DynamicBone.Particle particle = this.m_Particles[i];
DynamicBone.Particle particle2 = this.m_Particles[particle.m_ParentIndex];
bool flag = particle.m_Transform != null;
float magnitude;
if (flag)
{
magnitude = (particle2.m_Transform.position - particle.m_Transform.position).magnitude;
}
else
{
magnitude = particle2.m_Transform.localToWorldMatrix.MultiplyVector(particle.m_EndOffset).magnitude;
}
float num = Mathf.Lerp(1f, particle.m_Stiffness, this.m_Weight);
bool flag2 = num > 0f || particle.m_Elasticity > 0f;
if (flag2)
{
Matrix4x4 localToWorldMatrix = particle2.m_Transform.localToWorldMatrix;
localToWorldMatrix.SetColumn(3, particle2.m_Position);
bool flag3 = particle.m_Transform != null;
Vector3 vector;
if (flag3)
{
vector = localToWorldMatrix.MultiplyPoint3x4(particle.m_Transform.localPosition);
}
else
{
vector = localToWorldMatrix.MultiplyPoint3x4(particle.m_EndOffset);
}
Vector3 vector2 = vector - particle.m_Position;
particle.m_Position += vector2 * particle.m_Elasticity;
bool flag4 = num > 0f;
if (flag4)
{
vector2 = vector - particle.m_Position;
float magnitude2 = vector2.magnitude;
float num2 = magnitude * (1f - num) * 2f;
bool flag5 = magnitude2 > num2;
if (flag5)
{
particle.m_Position += vector2 * ((magnitude2 - num2) / magnitude2);
}
}
}
bool flag6 = this.m_Colliders != null;
if (flag6)
{
float particleRadius = particle.m_Radius * this.m_ObjectScale;
for (int j = 0; j < this.m_Colliders.Count; j++)
{
DynamicBoneCollider dynamicBoneCollider = this.m_Colliders[j];
bool flag7 = dynamicBoneCollider != null && dynamicBoneCollider.enabled;
if (flag7)
{
dynamicBoneCollider.Collide(ref particle.m_Position, particleRadius);
}
}
}
bool flag8 = this.m_FreezeAxis > DynamicBone.FreezeAxis.None;
if (flag8)
{
switch (this.m_FreezeAxis)
{
case DynamicBone.FreezeAxis.X:
plane.SetNormalAndPosition(particle2.m_Transform.right, particle2.m_Position);
break;
case DynamicBone.FreezeAxis.Y:
plane.SetNormalAndPosition(particle2.m_Transform.up, particle2.m_Position);
break;
case DynamicBone.FreezeAxis.Z:
plane.SetNormalAndPosition(particle2.m_Transform.forward, particle2.m_Position);
break;
}
particle.m_Position -= plane.normal * plane.GetDistanceToPoint(particle.m_Position);
}
Vector3 vector3 = particle2.m_Position - particle.m_Position;
float magnitude3 = vector3.magnitude;
bool flag9 = magnitude3 > 0f;
if (flag9)
{
particle.m_Position += vector3 * ((magnitude3 - magnitude) / magnitude3);
}
}
}
// Token: 0x0600000E RID: 14 RVA: 0x000027B4 File Offset: 0x000009B4
private void AppendParticles(Transform b, int parentIndex, float boneLength)
{
DynamicBone.Particle particle = new DynamicBone.Particle();
particle.m_Transform = b;
particle.m_ParentIndex = parentIndex;
bool flag = b != null;
if (flag)
{
particle.m_Position = (particle.m_PrevPosition = b.position);
particle.m_InitLocalPosition = b.localPosition;
particle.m_InitLocalRotation = b.localRotation;
}
else
{
Transform transform = this.m_Particles[parentIndex].m_Transform;
bool flag2 = this.m_EndLength > 0f;
if (flag2)
{
Transform parent = transform.parent;
bool flag3 = parent != null;
if (flag3)
{
particle.m_EndOffset = transform.InverseTransformPoint(transform.position * 2f - parent.position) * this.m_EndLength;
}
else
{
particle.m_EndOffset = new Vector3(this.m_EndLength, 0f, 0f);
}
}
else
{
particle.m_EndOffset = transform.InverseTransformPoint(base.transform.TransformDirection(this.m_EndOffset) + transform.position);
}
particle.m_Position = (particle.m_PrevPosition = transform.TransformPoint(particle.m_EndOffset));
}
bool flag4 = parentIndex >= 0;
if (flag4)
{
boneLength += (this.m_Particles[parentIndex].m_Transform.position - particle.m_Position).magnitude;
particle.m_BoneLength = boneLength;
this.m_BoneTotalLength = Mathf.Max(this.m_BoneTotalLength, boneLength);
}
int count = this.m_Particles.Count;
this.m_Particles.Add(particle);
bool flag5 = b != null;
if (flag5)
{
for (int i = 0; i < b.childCount; i++)
{
bool flag6 = false;
bool flag7 = this.m_Exclusions != null;
if (flag7)
{
for (int j = 0; j < this.m_Exclusions.Count; j++)
{
Transform transform2 = this.m_Exclusions[j];
bool flag8 = transform2 == b.GetChild(i);
if (flag8)
{
flag6 = true;
break;
}
}
}
bool flag9 = !flag6;
if (flag9)
{
this.AppendParticles(b.GetChild(i), count, boneLength);
}
}
bool flag10 = b.childCount == 0 && (this.m_EndLength > 0f || this.m_EndOffset != Vector3.zero);
if (flag10)
{
this.AppendParticles(null, count, boneLength);
}
}
}
private void UpdateParticles2()
{
Plane plane = default(Plane);
for (int i = 1; i < this.m_Particles.Count; i++)
{
DynamicBone.Particle particle = this.m_Particles[i];
DynamicBone.Particle particle2 = this.m_Particles[particle.m_ParentIndex];
float magnitude;
if (particle.m_Transform != null)
{
magnitude = (particle2.m_Transform.position - particle.m_Transform.position).magnitude;
}
else
{
magnitude = particle2.m_Transform.localToWorldMatrix.MultiplyVector(particle.m_EndOffset).magnitude;
}
float num = Mathf.Lerp(1f, particle.m_Stiffness, this.m_Weight);
if (num > 0f || particle.m_Elasticity > 0f)
{
Matrix4x4 localToWorldMatrix = particle2.m_Transform.localToWorldMatrix;
localToWorldMatrix.SetColumn(3, particle2.m_Position);
Vector3 a;
if (particle.m_Transform != null)
{
a = localToWorldMatrix.MultiplyPoint3x4(particle.m_Transform.localPosition);
}
else
{
a = localToWorldMatrix.MultiplyPoint3x4(particle.m_EndOffset);
}
Vector3 a2 = a - particle.m_Position;
particle.m_Position += a2 * particle.m_Elasticity;
if (num > 0f)
{
a2 = a - particle.m_Position;
float magnitude2 = a2.magnitude;
float num2 = magnitude * (1f - num) * 2f;
if (magnitude2 > num2)
{
particle.m_Position += a2 * ((magnitude2 - num2) / magnitude2);
}
}
}
if (this.m_Colliders != null)
{
float particleRadius = particle.m_Radius * this.m_ObjectScale;
for (int j = 0; j < this.m_Colliders.Count; j++)
{
DynamicBoneColliderBase dynamicBoneColliderBase = this.m_Colliders[j];
if (dynamicBoneColliderBase != null && dynamicBoneColliderBase.enabled)
{
dynamicBoneColliderBase.Collide(ref particle.m_Position, particleRadius);
}
}
}
if (this.m_FreezeAxis != DynamicBone.FreezeAxis.None)
{
switch (this.m_FreezeAxis)
{
case DynamicBone.FreezeAxis.X:
plane.SetNormalAndPosition(particle2.m_Transform.right, particle2.m_Position);
break;
case DynamicBone.FreezeAxis.Y:
plane.SetNormalAndPosition(particle2.m_Transform.up, particle2.m_Position);
break;
case DynamicBone.FreezeAxis.Z:
plane.SetNormalAndPosition(particle2.m_Transform.forward, particle2.m_Position);
break;
}
particle.m_Position -= plane.normal * plane.GetDistanceToPoint(particle.m_Position);
}
Vector3 a3 = particle2.m_Position - particle.m_Position;
float magnitude3 = a3.magnitude;
if (magnitude3 > 0f)
{
particle.m_Position += a3 * ((magnitude3 - magnitude) / magnitude3);
}
}
}
