internal void ResetValuesFromProperties()
{
this.m_ArmTwistFactor = this.m_ArmTwistProperty.floatValue;
this.m_ForeArmTwistFactor = this.m_ForeArmTwistProperty.floatValue;
this.m_UpperLegTwistFactor = this.m_UpperLegTwistProperty.floatValue;
this.m_LegTwistFactor = this.m_LegTwistProperty.floatValue;
this.m_ArmStretchFactor = this.m_ArmStretchProperty.floatValue;
this.m_LegStretchFactor = this.m_LegStretchProperty.floatValue;
this.m_FeetSpacingFactor = this.m_FeetSpacingProperty.floatValue;
for (int i = 0; i < this.m_Bones.Length; i++)
{
if (this.m_Modified[i] != null)
{
bool boolValue = this.m_Modified[i].boolValue;
int num = HumanTrait.MuscleFromBone(i, 0);
int num2 = HumanTrait.MuscleFromBone(i, 1);
int num3 = HumanTrait.MuscleFromBone(i, 2);
if (num != -1)
{
this.m_MuscleMinEdit[num] = ((!boolValue) ? HumanTrait.GetMuscleDefaultMin(num) : this.m_MuscleMin[num].floatValue);
this.m_MuscleMaxEdit[num] = ((!boolValue) ? HumanTrait.GetMuscleDefaultMax(num) : this.m_MuscleMax[num].floatValue);
}
if (num2 != -1)
{
this.m_MuscleMinEdit[num2] = ((!boolValue) ? HumanTrait.GetMuscleDefaultMin(num2) : this.m_MuscleMin[num2].floatValue);
this.m_MuscleMaxEdit[num2] = ((!boolValue) ? HumanTrait.GetMuscleDefaultMax(num2) : this.m_MuscleMax[num2].floatValue);
}
if (num3 != -1)
{
this.m_MuscleMinEdit[num3] = ((!boolValue) ? HumanTrait.GetMuscleDefaultMin(num3) : this.m_MuscleMin[num3].floatValue);
this.m_MuscleMaxEdit[num3] = ((!boolValue) ? HumanTrait.GetMuscleDefaultMax(num3) : this.m_MuscleMax[num3].floatValue);
}
}
}
}
public void Add(MusclePropertyName musclePropertyName, PoseTemplate srcPoseTemplate)
{
var handPose = new HandPoseData();
handPose.name = srcPoseTemplate.name;
{
var beginMuscle = HumanTrait.MuscleFromBone((int)HumanBodyBones.LeftThumbProximal, 2);
var endMuscle = HumanTrait.MuscleFromBone((int)HumanBodyBones.LeftLittleDistal, 2);
var muscleDic = new Dictionary <string, float>();
for (int muscle = beginMuscle; muscle <= endMuscle; muscle++)
{
var index = ArrayUtility.IndexOf(srcPoseTemplate.musclePropertyNames, musclePropertyName.PropertyNames[muscle]);
if (index < 0)
{
continue;
}
muscleDic.Add(srcPoseTemplate.musclePropertyNames[index], srcPoseTemplate.muscleValues[index]);
}
handPose.musclePropertyNames = muscleDic.Keys.ToArray();
handPose.muscleValues = muscleDic.Values.ToArray();
}
if (list == null)
{
list = new List <HandPoseData>();
}
list.Add(handPose);
}
// clears the animation curves before the recording starts
private void InitAnimationCurves()
{
if (avatarModel == null)
{
return;
}
animTime = 0f;
muscleCurves.Clear();
rootPoseCurves.Clear();
List <HumanBodyBones> mecanimBones = avatarModel.GetMecanimBones();
foreach (HumanBodyBones boneType in mecanimBones)
{
for (int i = 0; i < 3; i++)
{
int muscle = HumanTrait.MuscleFromBone((int)boneType, i);
if (muscle != -1)
{
muscleCurves.Add(muscle, new AnimationCurve());
}
}
}
rootPoseCurves.Add("RootT.x", new AnimationCurve());
rootPoseCurves.Add("RootT.y", new AnimationCurve());
rootPoseCurves.Add("RootT.z", new AnimationCurve());
rootPoseCurves.Add("RootQ.x", new AnimationCurve());
rootPoseCurves.Add("RootQ.y", new AnimationCurve());
rootPoseCurves.Add("RootQ.z", new AnimationCurve());
rootPoseCurves.Add("RootQ.w", new AnimationCurve());
}
static int MuscleFromBone(IntPtr L)
{
LuaScriptMgr.CheckArgsCount(L, 2);
int arg0 = (int)LuaScriptMgr.GetNumber(L, 1);
int arg1 = (int)LuaScriptMgr.GetNumber(L, 2);
int o = HumanTrait.MuscleFromBone(arg0, arg1);
LuaScriptMgr.Push(L, o);
return(1);
}
static AnimRecorder()
{
for (int i = 0; i < HumanTrait.BoneCount; i++)
{
for (int j = 0; j < 3; j++)
{
MuscleFromBone[i, j] = HumanTrait.MuscleFromBone(i, j);
}
}
}
public void SetTarget(GameObject target)
{
this.target = target;
selected = -1;
if (target == null)
{
return;
}
Animator animator = target.GetComponent(typeof(Animator)) as Animator;
if (animator == null)
{
return;
}
avatar = animator.avatar;
if (avatar == null || !avatar.isValid || !avatar.isHuman)
{
return;
}
muscleMinMaxValues = PSMuscleDefine.GetMuscleMinMaxValues();
Array boneArray = Enum.GetValues(typeof(HumanBodyBones));
Array.Sort(boneArray);
boneInfos = new BoneInfo[HumanTrait.BoneCount];
for (int i = 0; i < HumanTrait.BoneCount; i++)
{
BoneInfo info = new BoneInfo();
info.bone = animator.GetBoneTransform((HumanBodyBones)boneArray.GetValue(i));
info.humanBoneName = HumanTrait.BoneName [i];
info.boneId = i;
info.muscleXId = HumanTrait.MuscleFromBone(info.boneId, 0);
info.muscleYId = HumanTrait.MuscleFromBone(info.boneId, 1);
info.muscleZId = HumanTrait.MuscleFromBone(info.boneId, 2);
if (info.muscleXId != -1 || info.muscleYId != -1 || info.muscleZId != -1)
{
boneInfos [i] = info;
}
}
// get avatar methods
getAxisLength = avatar.GetType().GetMethod("GetAxisLength", flags);
getPreRotation = avatar.GetType().GetMethod("GetPreRotation", flags);
getPostRotation = avatar.GetType().GetMethod("GetPostRotation", flags);
getZYRoll = avatar.GetType().GetMethod("GetZYRoll", flags);
getLimitSign = avatar.GetType().GetMethod("GetLimitSign", flags);
getZYPostQ = avatar.GetType().GetMethod("GetZYPostQ", flags);
}
protected bool UpdateMuscle(int muscleId, float min, float max)
{
Undo.RegisterCompleteObjectUndo(this, "Updated muscle range");
m_MuscleMin[muscleId].floatValue = min;
m_MuscleMax[muscleId].floatValue = max;
int humanId = HumanTrait.BoneFromMuscle(muscleId);
if (humanId != -1)
{
if (!m_Modified[humanId].boolValue)
{
int mx = HumanTrait.MuscleFromBone(humanId, 0);
int my = HumanTrait.MuscleFromBone(humanId, 1);
int mz = HumanTrait.MuscleFromBone(humanId, 2);
if (mx != -1 && mx != muscleId)
{
m_MuscleMin[mx].floatValue = HumanTrait.GetMuscleDefaultMin(mx);
m_MuscleMax[mx].floatValue = HumanTrait.GetMuscleDefaultMax(mx);
}
if (my != -1 && my != muscleId)
{
m_MuscleMin[my].floatValue = HumanTrait.GetMuscleDefaultMin(my);
m_MuscleMax[my].floatValue = HumanTrait.GetMuscleDefaultMax(my);
}
if (mz != -1 && mz != muscleId)
{
m_MuscleMin[mz].floatValue = HumanTrait.GetMuscleDefaultMin(mz);
m_MuscleMax[mz].floatValue = HumanTrait.GetMuscleDefaultMax(mz);
}
}
m_Modified[humanId].boolValue = true;
}
// OnSceneGUI need focused muscle to know which one to draw
m_FocusedMuscle = muscleId;
// For live update, update instanciate avatar to adjust pose
if (gameObject != null)
{
Animator animator = gameObject.GetComponent(typeof(Animator)) as Animator;
Avatar avatar = animator.avatar;
avatar.SetMuscleMinMax(muscleId, min, max);
}
// Need to repaint scene to update muscle range handle
SceneView.RepaintAll();
return(gameObject != null);
}
public static void SetHipsPositionRotation(ref HumanPose pose, Vector3 hipsT, Quaternion hipsQ, float humanScale)
{
var spreadQ = Quaternion.identity;
foreach (var(i, scale) in spreadMassQ)
{
spreadQ *= HumanAxes.SwingTwist(new Vector3(
pose.muscles[HumanTrait.MuscleFromBone(i, 0)] * scale[0],
pose.muscles[HumanTrait.MuscleFromBone(i, 1)] * scale[1],
pose.muscles[HumanTrait.MuscleFromBone(i, 2)] * scale[2]));
}
var t = Quaternion.LookRotation(Vector3.right, Vector3.forward);
pose.bodyPosition = hipsT / humanScale;
pose.bodyRotation = hipsQ * (t * spreadQ * Quaternion.Inverse(t));
}
internal void InitializeProperties()
{
m_ArmTwistProperty = serializedObject.FindProperty(sArmTwist);
m_ForeArmTwistProperty = serializedObject.FindProperty(sForeArmTwist);
m_UpperLegTwistProperty = serializedObject.FindProperty(sUpperLegTwist);
m_LegTwistProperty = serializedObject.FindProperty(sLegTwist);
m_ArmStretchProperty = serializedObject.FindProperty(sArmStretch);
m_LegStretchProperty = serializedObject.FindProperty(sLegStretch);
m_FeetSpacingProperty = serializedObject.FindProperty(sFeetSpacing);
m_HasTranslationDoFProperty = serializedObject.FindProperty(sHasTranslationDoF);
for (int i = 0; i < m_Bones.Length; i++)
{
SerializedProperty bone = m_Bones[i].GetSerializedProperty(serializedObject, false);
if (bone != null)
{
m_Modified[i] = bone.FindPropertyRelative(sModified);
int dx = HumanTrait.MuscleFromBone(i, 0);
int dy = HumanTrait.MuscleFromBone(i, 1);
int dz = HumanTrait.MuscleFromBone(i, 2);
if (dx != -1)
{
m_MuscleMin[dx] = bone.FindPropertyRelative(sMinX);
m_MuscleMax[dx] = bone.FindPropertyRelative(sMaxX);
}
if (dy != -1)
{
m_MuscleMin[dy] = bone.FindPropertyRelative(sMinY);
m_MuscleMax[dy] = bone.FindPropertyRelative(sMaxY);
}
if (dz != -1)
{
m_MuscleMin[dz] = bone.FindPropertyRelative(sMinZ);
m_MuscleMax[dz] = bone.FindPropertyRelative(sMaxZ);
}
}
}
}
internal void ResetValuesFromProperties()
{
m_ArmTwistFactor = m_ArmTwistProperty.floatValue;
m_ForeArmTwistFactor = m_ForeArmTwistProperty.floatValue;
m_UpperLegTwistFactor = m_UpperLegTwistProperty.floatValue;
m_LegTwistFactor = m_LegTwistProperty.floatValue;
m_ArmStretchFactor = m_ArmStretchProperty.floatValue;
m_LegStretchFactor = m_LegStretchProperty.floatValue;
m_FeetSpacingFactor = m_FeetSpacingProperty.floatValue;
m_HasTranslationDoF = m_HasTranslationDoFProperty.boolValue;
// limit is a special case, because they are added dynamicly by the editor
// all the default value are wrong, we must explictly query mecanim to get the default value when
// m_Modified is set to false.
for (int i = 0; i < m_Bones.Length; i++)
{
if (m_Modified[i] != null)
{
bool modified = m_Modified[i].boolValue;
int dx = HumanTrait.MuscleFromBone(i, 0);
int dy = HumanTrait.MuscleFromBone(i, 1);
int dz = HumanTrait.MuscleFromBone(i, 2);
if (dx != -1)
{
m_MuscleMinEdit[dx] = modified ? m_MuscleMin[dx].floatValue : HumanTrait.GetMuscleDefaultMin(dx);
m_MuscleMaxEdit[dx] = modified ? m_MuscleMax[dx].floatValue : HumanTrait.GetMuscleDefaultMax(dx);
}
if (dy != -1)
{
m_MuscleMinEdit[dy] = modified ? m_MuscleMin[dy].floatValue : HumanTrait.GetMuscleDefaultMin(dy);
m_MuscleMaxEdit[dy] = modified ? m_MuscleMax[dy].floatValue : HumanTrait.GetMuscleDefaultMax(dy);
}
if (dz != -1)
{
m_MuscleMinEdit[dz] = modified ? m_MuscleMin[dz].floatValue : HumanTrait.GetMuscleDefaultMin(dz);
m_MuscleMaxEdit[dz] = modified ? m_MuscleMax[dz].floatValue : HumanTrait.GetMuscleDefaultMax(dz);
}
}
}
}
protected bool UpdateMuscle(int muscleId, float min, float max)
{
Undo.RegisterCompleteObjectUndo(this, "Updated muscle range");
this.m_MuscleMin[muscleId].floatValue = min;
this.m_MuscleMax[muscleId].floatValue = max;
int num = HumanTrait.BoneFromMuscle(muscleId);
if (num != -1)
{
if (!this.m_Modified[num].boolValue)
{
int num2 = HumanTrait.MuscleFromBone(num, 0);
int num3 = HumanTrait.MuscleFromBone(num, 1);
int num4 = HumanTrait.MuscleFromBone(num, 2);
if (num2 != -1 && num2 != muscleId)
{
this.m_MuscleMin[num2].floatValue = HumanTrait.GetMuscleDefaultMin(num2);
this.m_MuscleMax[num2].floatValue = HumanTrait.GetMuscleDefaultMax(num2);
}
if (num3 != -1 && num3 != muscleId)
{
this.m_MuscleMin[num3].floatValue = HumanTrait.GetMuscleDefaultMin(num3);
this.m_MuscleMax[num3].floatValue = HumanTrait.GetMuscleDefaultMax(num3);
}
if (num4 != -1 && num4 != muscleId)
{
this.m_MuscleMin[num4].floatValue = HumanTrait.GetMuscleDefaultMin(num4);
this.m_MuscleMax[num4].floatValue = HumanTrait.GetMuscleDefaultMax(num4);
}
}
this.m_Modified[num].boolValue = true;
}
this.m_FocusedMuscle = muscleId;
if (base.gameObject != null)
{
Animator animator = base.gameObject.GetComponent(typeof(Animator)) as Animator;
Avatar avatar = animator.avatar;
avatar.SetMuscleMinMax(muscleId, min, max);
}
SceneView.RepaintAll();
return(base.gameObject != null);
}
public static int MuscleFromBone_s(IntPtr l)
{
int result;
try
{
int i;
LuaObject.checkType(l, 1, out i);
int dofIndex;
LuaObject.checkType(l, 2, out dofIndex);
int i2 = HumanTrait.MuscleFromBone(i, dofIndex);
LuaObject.pushValue(l, true);
LuaObject.pushValue(l, i2);
result = 2;
}
catch (Exception e)
{
result = LuaObject.error(l, e);
}
return(result);
}
internal void ResetValuesFromProperties()
{
this.m_ArmTwistFactor = this.m_ArmTwistProperty.floatValue;
this.m_ForeArmTwistFactor = this.m_ForeArmTwistProperty.floatValue;
this.m_UpperLegTwistFactor = this.m_UpperLegTwistProperty.floatValue;
this.m_LegTwistFactor = this.m_LegTwistProperty.floatValue;
this.m_ArmStretchFactor = this.m_ArmStretchProperty.floatValue;
this.m_LegStretchFactor = this.m_LegStretchProperty.floatValue;
this.m_FeetSpacingFactor = this.m_FeetSpacingProperty.floatValue;
this.m_HasTranslationDoF = this.m_HasTranslationDoFProperty.boolValue;
for (int i = 0; i < this.m_Bones.Length; i++)
{
if (this.m_Modified[i] != null)
{
bool boolValue = this.m_Modified[i].boolValue;
int index = HumanTrait.MuscleFromBone(i, 0);
int num3 = HumanTrait.MuscleFromBone(i, 1);
int num4 = HumanTrait.MuscleFromBone(i, 2);
if (index != -1)
{
this.m_MuscleMinEdit[index] = !boolValue?HumanTrait.GetMuscleDefaultMin(index) : this.m_MuscleMin[index].floatValue;
this.m_MuscleMaxEdit[index] = !boolValue?HumanTrait.GetMuscleDefaultMax(index) : this.m_MuscleMax[index].floatValue;
}
if (num3 != -1)
{
this.m_MuscleMinEdit[num3] = !boolValue?HumanTrait.GetMuscleDefaultMin(num3) : this.m_MuscleMin[num3].floatValue;
this.m_MuscleMaxEdit[num3] = !boolValue?HumanTrait.GetMuscleDefaultMax(num3) : this.m_MuscleMax[num3].floatValue;
}
if (num4 != -1)
{
this.m_MuscleMinEdit[num4] = !boolValue?HumanTrait.GetMuscleDefaultMin(num4) : this.m_MuscleMin[num4].floatValue;
this.m_MuscleMaxEdit[num4] = !boolValue?HumanTrait.GetMuscleDefaultMax(num4) : this.m_MuscleMax[num4].floatValue;
}
}
}
}
internal void ResetValuesFromProperties()
{
this.m_ArmTwistFactor = this.m_ArmTwistProperty.floatValue;
this.m_ForeArmTwistFactor = this.m_ForeArmTwistProperty.floatValue;
this.m_UpperLegTwistFactor = this.m_UpperLegTwistProperty.floatValue;
this.m_LegTwistFactor = this.m_LegTwistProperty.floatValue;
this.m_ArmStretchFactor = this.m_ArmStretchProperty.floatValue;
this.m_LegStretchFactor = this.m_LegStretchProperty.floatValue;
this.m_FeetSpacingFactor = this.m_FeetSpacingProperty.floatValue;
this.m_HasTranslationDoF = this.m_HasTranslationDoFProperty.boolValue;
for (int i1 = 0; i1 < this.m_Bones.Length; ++i1)
{
if (this.m_Modified[i1] != null)
{
bool boolValue = this.m_Modified[i1].boolValue;
int i2 = HumanTrait.MuscleFromBone(i1, 0);
int i3 = HumanTrait.MuscleFromBone(i1, 1);
int i4 = HumanTrait.MuscleFromBone(i1, 2);
if (i2 != -1)
{
this.m_MuscleMinEdit[i2] = !boolValue?HumanTrait.GetMuscleDefaultMin(i2) : this.m_MuscleMin[i2].floatValue;
this.m_MuscleMaxEdit[i2] = !boolValue?HumanTrait.GetMuscleDefaultMax(i2) : this.m_MuscleMax[i2].floatValue;
}
if (i3 != -1)
{
this.m_MuscleMinEdit[i3] = !boolValue?HumanTrait.GetMuscleDefaultMin(i3) : this.m_MuscleMin[i3].floatValue;
this.m_MuscleMaxEdit[i3] = !boolValue?HumanTrait.GetMuscleDefaultMax(i3) : this.m_MuscleMax[i3].floatValue;
}
if (i4 != -1)
{
this.m_MuscleMinEdit[i4] = !boolValue?HumanTrait.GetMuscleDefaultMin(i4) : this.m_MuscleMin[i4].floatValue;
this.m_MuscleMaxEdit[i4] = !boolValue?HumanTrait.GetMuscleDefaultMax(i4) : this.m_MuscleMax[i4].floatValue;
}
}
}
}
public HumanoidRecoder(Animator animator, HumanBodyBones[] humanBodyBones)
{
rootOffset = animator.transform.position;
humanPoseHandler = new HumanPoseHandler(animator.avatar, animator.transform);
foreach (HumanBodyBones unityBoneType in humanBodyBones)
{
for (int dofIndex = 0; dofIndex < 3; dofIndex++)
{
int muscle = HumanTrait.MuscleFromBone((int)unityBoneType, dofIndex);
if (muscle != -1)
{
muscleCurves.Add(muscle, new AnimationCurve());
}
}
}
rootCurves.Add("RootT.x", new AnimationCurve());
rootCurves.Add("RootT.y", new AnimationCurve());
rootCurves.Add("RootT.z", new AnimationCurve());
}
static Vector3 GetLimitSignFull(Avatar avatar, HumanBodyBones humanBone)
{
var sign = Vector3.zero;
for (var b = humanBone; (int)b >= 0;)
{
var s = (Vector3)GetLimitSign.Invoke(avatar, new object[] { b });
for (int i = 0; i < 3; i++)
{
if (HumanTrait.MuscleFromBone((int)b, i) < 0)
{
s[i] = 0;
}
else if (sign[i] == 0)
{
sign[i] = s[i];
}
}
if (s.x * s.y * s.z != 0)
{
// match orientation
for (int i = 0; i < 3 && (sign.x * sign.y * sign.z) != (s.x * s.y * s.z); i++)
{
if (HumanTrait.MuscleFromBone((int)humanBone, i) < 0)
{
sign[i] *= -1;
}
}
return(sign);
}
b = b == HumanBodyBones.LeftShoulder ? HumanBodyBones.LeftUpperArm :
b == HumanBodyBones.RightShoulder ? HumanBodyBones.RightUpperArm :
(HumanBodyBones)HumanTrait.GetParentBone((int)b);
}
return(Vector3.one);
}
public MuscleLimit GetMuscleLimitNonError(Avatar avatar, HumanBodyBones humanoidIndex)
{
var ml = GetMuscleLimit(avatar, humanoidIndex);
if (ml != null)
{
return(ml);
}
var muscleX = HumanTrait.MuscleFromBone((int)humanoidIndex, 0);
var muscleY = HumanTrait.MuscleFromBone((int)humanoidIndex, 1);
var muscleZ = HumanTrait.MuscleFromBone((int)humanoidIndex, 2);
return(new MuscleLimit()
{
min = new Vector3(muscleX >= 0 ? HumanTrait.GetMuscleDefaultMin(muscleX) : 0f,
muscleY >= 0 ? HumanTrait.GetMuscleDefaultMin(muscleY) : 0f,
muscleZ >= 0 ? HumanTrait.GetMuscleDefaultMin(muscleZ) : 0f),
max = new Vector3(muscleX >= 0 ? HumanTrait.GetMuscleDefaultMax(muscleX) : 0f,
muscleY >= 0 ? HumanTrait.GetMuscleDefaultMax(muscleY) : 0f,
muscleZ >= 0 ? HumanTrait.GetMuscleDefaultMax(muscleZ) : 0f)
});
}
internal void InitializeProperties()
{
this.m_ArmTwistProperty = base.serializedObject.FindProperty("m_HumanDescription.m_ArmTwist");
this.m_ForeArmTwistProperty = base.serializedObject.FindProperty("m_HumanDescription.m_ForeArmTwist");
this.m_UpperLegTwistProperty = base.serializedObject.FindProperty("m_HumanDescription.m_UpperLegTwist");
this.m_LegTwistProperty = base.serializedObject.FindProperty("m_HumanDescription.m_LegTwist");
this.m_ArmStretchProperty = base.serializedObject.FindProperty("m_HumanDescription.m_ArmStretch");
this.m_LegStretchProperty = base.serializedObject.FindProperty("m_HumanDescription.m_LegStretch");
this.m_FeetSpacingProperty = base.serializedObject.FindProperty("m_HumanDescription.m_FeetSpacing");
this.m_HasTranslationDoFProperty = base.serializedObject.FindProperty("m_HumanDescription.m_HasTranslationDoF");
for (int i = 0; i < this.m_Bones.Length; i++)
{
SerializedProperty serializedProperty = this.m_Bones[i].GetSerializedProperty(base.serializedObject, false);
if (serializedProperty != null)
{
this.m_Modified[i] = serializedProperty.FindPropertyRelative("m_Limit.m_Modified");
int index = HumanTrait.MuscleFromBone(i, 0);
int num3 = HumanTrait.MuscleFromBone(i, 1);
int num4 = HumanTrait.MuscleFromBone(i, 2);
if (index != -1)
{
this.m_MuscleMin[index] = serializedProperty.FindPropertyRelative("m_Limit.m_Min.x");
this.m_MuscleMax[index] = serializedProperty.FindPropertyRelative("m_Limit.m_Max.x");
}
if (num3 != -1)
{
this.m_MuscleMin[num3] = serializedProperty.FindPropertyRelative("m_Limit.m_Min.y");
this.m_MuscleMax[num3] = serializedProperty.FindPropertyRelative("m_Limit.m_Max.y");
}
if (num4 != -1)
{
this.m_MuscleMin[num4] = serializedProperty.FindPropertyRelative("m_Limit.m_Min.z");
this.m_MuscleMax[num4] = serializedProperty.FindPropertyRelative("m_Limit.m_Max.z");
}
}
}
}
static HumanLimit GetHumanLimit(Avatar avatar, HumanBodyBones humanBone)
{
var limit = new HumanLimit {
useDefaultValues = true
};
#if UNITY_EDITOR // this can be improved when avatar.humanDescription is exposed in unity 2019
var importer = AssetImporter.GetAtPath(AssetDatabase.GetAssetPath(avatar)) as ModelImporter;
var human = (importer?.humanDescription)?.human;
if (human != null)
{
for (int i = 0; i < human.Length; i++)
{
if (human[i].humanName == HumanTrait.BoneName[(int)humanBone])
{
limit = human[i].limit;
break;
}
}
}
#endif
limit.axisLength = (float)GetAxisLength.Invoke(avatar, new object[] { humanBone }); // not in humanDescription
if (limit.useDefaultValues)
{
Vector3 min = new Vector3(), max = new Vector3();
for (int i = 0; i < 3; i++)
{
var m = HumanTrait.MuscleFromBone((int)humanBone, i);
min[i] = m >= 0 ? HumanTrait.GetMuscleDefaultMin(m) : 0; // invalid input will crash
max[i] = m >= 0 ? HumanTrait.GetMuscleDefaultMax(m) : 0;
}
limit.min = min;
limit.max = max;
}
return(limit);
}
public void DrawMuscleHandle(Transform t, int humanId)
{
Vector3 vector2;
Animator component = base.gameObject.GetComponent(typeof(Animator)) as Animator;
Avatar avatar = component.avatar;
int index = HumanTrait.MuscleFromBone(humanId, 0);
int num2 = HumanTrait.MuscleFromBone(humanId, 1);
int num3 = HumanTrait.MuscleFromBone(humanId, 2);
float axisLength = avatar.GetAxisLength(humanId);
Quaternion preRotation = avatar.GetPreRotation(humanId);
Quaternion postRotation = avatar.GetPostRotation(humanId);
preRotation = t.parent.rotation * preRotation;
postRotation = t.rotation * postRotation;
Color color = new Color(1f, 1f, 1f, 0.5f);
Quaternion zYRoll = avatar.GetZYRoll(humanId, Vector3.zero);
Vector3 limitSign = avatar.GetLimitSign(humanId);
Vector3 axis = (Vector3)(postRotation * Vector3.right);
Vector3 vector4 = t.position + ((Vector3)(axis * axisLength));
Handles.color = Color.white;
Handles.DrawLine(t.position, vector4);
if (index != -1)
{
Quaternion quaternion4 = avatar.GetZYPostQ(humanId, t.parent.rotation, t.rotation);
float angle = this.m_MuscleMinEdit[index];
float num6 = this.m_MuscleMaxEdit[index];
axis = (Vector3)(postRotation * Vector3.right);
vector2 = (Vector3)(quaternion4 * Vector3.forward);
Handles.color = Color.black;
Vector3 center = t.position + ((Vector3)((axis * axisLength) * 0.75f));
axis = (Vector3)((postRotation * Vector3.right) * limitSign.x);
vector2 = (Vector3)(Quaternion.AngleAxis(angle, axis) * vector2);
Handles.color = Color.yellow;
Handles.color = Handles.xAxisColor * color;
Handles.DrawSolidArc(center, axis, vector2, num6 - angle, axisLength * 0.25f);
vector2 = (Vector3)(postRotation * Vector3.forward);
Handles.color = Handles.centerColor;
Handles.DrawLine(center, center + ((Vector3)((vector2 * axisLength) * 0.25f)));
}
if (num2 != -1)
{
float num7 = this.m_MuscleMinEdit[num2];
float num8 = this.m_MuscleMaxEdit[num2];
axis = (Vector3)((preRotation * Vector3.up) * limitSign.y);
vector2 = (Vector3)((preRotation * zYRoll) * Vector3.right);
Handles.color = Color.black;
vector2 = (Vector3)(Quaternion.AngleAxis(num7, axis) * vector2);
Handles.color = Color.yellow;
Handles.color = Handles.yAxisColor * color;
Handles.DrawSolidArc(t.position, axis, vector2, num8 - num7, axisLength * 0.25f);
}
if (num3 != -1)
{
float num9 = this.m_MuscleMinEdit[num3];
float num10 = this.m_MuscleMaxEdit[num3];
axis = (Vector3)((preRotation * Vector3.forward) * limitSign.z);
vector2 = (Vector3)((preRotation * zYRoll) * Vector3.right);
Handles.color = Color.black;
vector2 = (Vector3)(Quaternion.AngleAxis(num9, axis) * vector2);
Handles.color = Color.yellow;
Handles.color = Handles.zAxisColor * color;
Handles.DrawSolidArc(t.position, axis, vector2, num10 - num9, axisLength * 0.25f);
}
}
public void DrawMuscleHandle(Transform t, int humanId)
{
Avatar avatar = (this.gameObject.GetComponent(typeof(Animator)) as Animator).avatar;
int index1 = HumanTrait.MuscleFromBone(humanId, 0);
int index2 = HumanTrait.MuscleFromBone(humanId, 1);
int index3 = HumanTrait.MuscleFromBone(humanId, 2);
float axisLength = avatar.GetAxisLength(humanId);
Quaternion preRotation = avatar.GetPreRotation(humanId);
Quaternion postRotation = avatar.GetPostRotation(humanId);
Quaternion quaternion1 = t.parent.rotation * preRotation;
Quaternion quaternion2 = t.rotation * postRotation;
Color color = new Color(1f, 1f, 1f, 0.5f);
Quaternion zyRoll = avatar.GetZYRoll(humanId, Vector3.zero);
Vector3 limitSign = avatar.GetLimitSign(humanId);
Vector3 vector3_1 = quaternion2 * Vector3.right;
Vector3 p2 = t.position + vector3_1 * axisLength;
Handles.color = Color.white;
Handles.DrawLine(t.position, p2);
if (index1 != -1)
{
Quaternion zyPostQ = avatar.GetZYPostQ(humanId, t.parent.rotation, t.rotation);
float angle = this.m_MuscleMinEdit[index1];
float num = this.m_MuscleMaxEdit[index1];
Vector3 vector3_2 = quaternion2 * Vector3.right;
Vector3 vector3_3 = zyPostQ * Vector3.forward;
Handles.color = Color.black;
Vector3 vector3_4 = t.position + vector3_2 * axisLength * 0.75f;
Vector3 vector3_5 = quaternion2 * Vector3.right * limitSign.x;
Vector3 from = Quaternion.AngleAxis(angle, vector3_5) * vector3_3;
Handles.color = Color.yellow;
Handles.color = Handles.xAxisColor * color;
Handles.DrawSolidArc(vector3_4, vector3_5, from, num - angle, axisLength * 0.25f);
Vector3 vector3_6 = quaternion2 * Vector3.forward;
Handles.color = Handles.centerColor;
Handles.DrawLine(vector3_4, vector3_4 + vector3_6 * axisLength * 0.25f);
}
if (index2 != -1)
{
float angle = this.m_MuscleMinEdit[index2];
float num = this.m_MuscleMaxEdit[index2];
Vector3 vector3_2 = quaternion1 * Vector3.up * limitSign.y;
Vector3 vector3_3 = quaternion1 * zyRoll * Vector3.right;
Handles.color = Color.black;
Vector3 from = Quaternion.AngleAxis(angle, vector3_2) * vector3_3;
Handles.color = Color.yellow;
Handles.color = Handles.yAxisColor * color;
Handles.DrawSolidArc(t.position, vector3_2, from, num - angle, axisLength * 0.25f);
}
if (index3 == -1)
{
return;
}
float angle1 = this.m_MuscleMinEdit[index3];
float num1 = this.m_MuscleMaxEdit[index3];
Vector3 vector3_7 = quaternion1 * Vector3.forward * limitSign.z;
Vector3 vector3_8 = quaternion1 * zyRoll * Vector3.right;
Handles.color = Color.black;
Vector3 from1 = Quaternion.AngleAxis(angle1, vector3_7) * vector3_8;
Handles.color = Color.yellow;
Handles.color = Handles.zAxisColor * color;
Handles.DrawSolidArc(t.position, vector3_7, from1, num1 - angle1, axisLength * 0.25f);
}
public void DrawMuscleHandle(Transform t, int humanId)
{
Animator animator = base.gameObject.GetComponent(typeof(Animator)) as Animator;
Avatar avatar = animator.avatar;
int num = HumanTrait.MuscleFromBone(humanId, 0);
int num2 = HumanTrait.MuscleFromBone(humanId, 1);
int num3 = HumanTrait.MuscleFromBone(humanId, 2);
float axisLength = avatar.GetAxisLength(humanId);
Quaternion quaternion = avatar.GetPreRotation(humanId);
Quaternion quaternion2 = avatar.GetPostRotation(humanId);
quaternion = t.parent.rotation * quaternion;
quaternion2 = t.rotation * quaternion2;
Color b = new Color(1f, 1f, 1f, 0.5f);
Quaternion zYRoll = avatar.GetZYRoll(humanId, Vector3.zero);
Vector3 limitSign = avatar.GetLimitSign(humanId);
Vector3 vector = quaternion2 * Vector3.right;
Vector3 p = t.position + vector * axisLength;
Handles.color = Color.white;
Handles.DrawLine(t.position, p);
if (num != -1)
{
Quaternion zYPostQ = avatar.GetZYPostQ(humanId, t.parent.rotation, t.rotation);
float num4 = this.m_MuscleMinEdit[num];
float num5 = this.m_MuscleMaxEdit[num];
vector = quaternion2 * Vector3.right;
Vector3 vector2 = zYPostQ * Vector3.forward;
Handles.color = Color.black;
Vector3 vector3 = t.position + vector * axisLength * 0.75f;
vector = quaternion2 * Vector3.right * limitSign.x;
Quaternion rotation = Quaternion.AngleAxis(num4, vector);
vector2 = rotation * vector2;
Handles.color = Color.yellow;
Handles.color = Handles.xAxisColor * b;
Handles.DrawSolidArc(vector3, vector, vector2, num5 - num4, axisLength * 0.25f);
vector2 = quaternion2 * Vector3.forward;
Handles.color = Handles.centerColor;
Handles.DrawLine(vector3, vector3 + vector2 * axisLength * 0.25f);
}
if (num2 != -1)
{
float num6 = this.m_MuscleMinEdit[num2];
float num7 = this.m_MuscleMaxEdit[num2];
vector = quaternion * Vector3.up * limitSign.y;
Vector3 vector2 = quaternion * zYRoll * Vector3.right;
Handles.color = Color.black;
Quaternion rotation2 = Quaternion.AngleAxis(num6, vector);
vector2 = rotation2 * vector2;
Handles.color = Color.yellow;
Handles.color = Handles.yAxisColor * b;
Handles.DrawSolidArc(t.position, vector, vector2, num7 - num6, axisLength * 0.25f);
}
if (num3 != -1)
{
float num8 = this.m_MuscleMinEdit[num3];
float num9 = this.m_MuscleMaxEdit[num3];
vector = quaternion * Vector3.forward * limitSign.z;
Vector3 vector2 = quaternion * zYRoll * Vector3.right;
Handles.color = Color.black;
Quaternion rotation3 = Quaternion.AngleAxis(num8, vector);
vector2 = rotation3 * vector2;
Handles.color = Color.yellow;
Handles.color = Handles.zAxisColor * b;
Handles.DrawSolidArc(t.position, vector, vector2, num9 - num8, axisLength * 0.25f);
}
}
public static int GetMuscleFromBone(HumanBodyBones boneID, int dofID)
{
return(HumanTrait.MuscleFromBone((int)boneID, dofID));
}
public void DrawMuscleHandle(Transform t, int humanId)
{
Animator animator = gameObject.GetComponent(typeof(Animator)) as Animator;
Avatar avatar = animator.avatar;
int mx = HumanTrait.MuscleFromBone(humanId, 0);
int my = HumanTrait.MuscleFromBone(humanId, 1);
int mz = HumanTrait.MuscleFromBone(humanId, 2);
float axisLen = avatar.GetAxisLength(humanId);
Quaternion preQ = avatar.GetPreRotation(humanId);
Quaternion postQ = avatar.GetPostRotation(humanId);
preQ = t.parent.rotation * preQ;
postQ = t.rotation * postQ;
Vector3 normal;
Vector3 from;
Color alpha = new Color(1, 1, 1, 0.5f);
Quaternion zyRoll = avatar.GetZYRoll(humanId, Vector3.zero);
Vector3 sign = avatar.GetLimitSign(humanId);
// Draw axis
normal = postQ * Vector3.right;
Vector3 axisEnd = t.position + (normal * axisLen);
Handles.color = Color.white;
Handles.DrawLine(t.position, axisEnd);
if (mx != -1)
{
Quaternion zyPostQ = avatar.GetZYPostQ(humanId, t.parent.rotation, t.rotation);
float minx = m_MuscleMinEdit[mx];
float maxx = m_MuscleMaxEdit[mx];
normal = postQ * Vector3.right;
from = zyPostQ * Vector3.forward;
Handles.color = Color.black;
//Handles.DrawLine (t.position, t.position + (from * axisLen * 0.75f));
Vector3 xDoF = t.position + (normal * axisLen * 0.75f);
normal = postQ * Vector3.right * sign.x;
Quaternion q = Quaternion.AngleAxis(minx, normal);
from = q * from;
Handles.color = Color.yellow;
//Handles.DrawLine (t.position, t.position + (from * axisLen * 0.75f));
// Draw Muscle range
Handles.color = Handles.xAxisColor * alpha;
Handles.DrawSolidArc(xDoF, normal, from, maxx - minx, axisLen * 0.25f);
from = postQ * Vector3.forward;
Handles.color = Handles.centerColor;
Handles.DrawLine(xDoF, xDoF + (from * axisLen * 0.25f));
}
if (my != -1)
{
float miny = m_MuscleMinEdit[my];
float maxy = m_MuscleMaxEdit[my];
normal = preQ * Vector3.up * sign.y;
from = preQ * zyRoll * Vector3.right;
Handles.color = Color.black;
//Handles.DrawLine (t.position, t.position + (from * axisLen * 0.75f));
Quaternion q = Quaternion.AngleAxis(miny, normal);
from = q * from;
Handles.color = Color.yellow;
//Handles.DrawLine (t.position, t.position + (from * axisLen * 0.75f));
// Draw Muscle range
Handles.color = Handles.yAxisColor * alpha;
Handles.DrawSolidArc(t.position, normal, from, maxy - miny, axisLen * 0.25f);
}
if (mz != -1)
{
float minz = m_MuscleMinEdit[mz];
float maxz = m_MuscleMaxEdit[mz];
normal = preQ * Vector3.forward * sign.z;
from = preQ * zyRoll * Vector3.right;
Handles.color = Color.black;
//Handles.DrawLine (t.position, t.position + (from * axisLen * 0.75f));
Quaternion q = Quaternion.AngleAxis(minz, normal);
from = q * from;
Handles.color = Color.yellow;
//Handles.DrawLine (t.position, t.position + (from * axisLen * 0.75f));
// Draw Muscle range
Handles.color = Handles.zAxisColor * alpha;
Handles.DrawSolidArc(t.position, normal, from, maxz - minz, axisLen * 0.25f);
}
}
