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);
}
}
}
}
protected void ResetMuscleToDefault()
{
Avatar avatar = (Avatar)null;
if ((UnityEngine.Object) this.gameObject != (UnityEngine.Object)null)
{
avatar = (this.gameObject.GetComponent(typeof(Animator)) as Animator).avatar;
}
for (int index1 = 0; index1 < this.m_MuscleCount; ++index1)
{
float muscleDefaultMin = HumanTrait.GetMuscleDefaultMin(index1);
float muscleDefaultMax = HumanTrait.GetMuscleDefaultMax(index1);
if (this.m_MuscleMin[index1] != null && this.m_MuscleMax[index1] != null)
{
this.m_MuscleMin[index1].floatValue = this.m_MuscleMinEdit[index1] = muscleDefaultMin;
this.m_MuscleMax[index1].floatValue = this.m_MuscleMaxEdit[index1] = muscleDefaultMax;
}
int index2 = HumanTrait.BoneFromMuscle(index1);
if (this.m_Modified[index2] != null && index2 != -1)
{
this.m_Modified[index2].boolValue = false;
}
if ((UnityEngine.Object)avatar != (UnityEngine.Object)null)
{
avatar.SetMuscleMinMax(index1, muscleDefaultMin, muscleDefaultMax);
}
}
this.WritePose();
}
protected void ResetMuscleToDefault()
{
Avatar avatar = null;
if (base.gameObject != null)
{
Animator component = base.gameObject.GetComponent(typeof(Animator)) as Animator;
avatar = component.avatar;
}
for (int i = 0; i < this.m_MuscleCount; i++)
{
float muscleDefaultMin = HumanTrait.GetMuscleDefaultMin(i);
float muscleDefaultMax = HumanTrait.GetMuscleDefaultMax(i);
if ((this.m_MuscleMin[i] != null) && (this.m_MuscleMax[i] != null))
{
this.m_MuscleMin[i].floatValue = this.m_MuscleMinEdit[i] = muscleDefaultMin;
this.m_MuscleMax[i].floatValue = this.m_MuscleMaxEdit[i] = muscleDefaultMax;
}
int index = HumanTrait.BoneFromMuscle(i);
if ((this.m_Modified[index] != null) && (index != -1))
{
this.m_Modified[index].boolValue = false;
}
if (avatar != null)
{
avatar.SetMuscleMinMax(i, muscleDefaultMin, muscleDefaultMax);
}
}
this.WritePose();
}
static int GetMuscleDefaultMax(IntPtr L)
{
LuaScriptMgr.CheckArgsCount(L, 1);
int arg0 = (int)LuaScriptMgr.GetNumber(L, 1);
float o = HumanTrait.GetMuscleDefaultMax(arg0);
LuaScriptMgr.Push(L, o);
return(1);
}
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 Vector2[] GetMuscleMinMaxValues()
{
Vector2[] values = new Vector2[HumanTrait.MuscleCount];
for (int i = 0; i < HumanTrait.MuscleCount; i++)
{
values [i] = new Vector2(HumanTrait.GetMuscleDefaultMin(i), HumanTrait.GetMuscleDefaultMax(i));
}
return(values);
}
// Muscle name and index lookup (See in Debug Log)
void LookUpMuscleIndex()
{
string[] muscleName = HumanTrait.MuscleName;
int i = 0;
while (i < HumanTrait.MuscleCount)
{
Debug.Log(i + ": " + muscleName[i] +
" min: " + HumanTrait.GetMuscleDefaultMin(i) + " max: " + HumanTrait.GetMuscleDefaultMax(i));
i++;
}
}
public static int GetMuscleDefaultMax_s(IntPtr l)
{
int result;
try
{
int i;
LuaObject.checkType(l, 1, out i);
float muscleDefaultMax = HumanTrait.GetMuscleDefaultMax(i);
LuaObject.pushValue(l, true);
LuaObject.pushValue(l, muscleDefaultMax);
result = 2;
}
catch (Exception e)
{
result = LuaObject.error(l, e);
}
return(result);
}
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);
}
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;
}
}
}
}
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;
}
}
}
}
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)
});
}
protected void ResetMuscleToDefault()
{
Avatar avatar = null;
// For live update, update instanciate avatar to adjust pose
if (gameObject != null)
{
Animator animator = gameObject.GetComponent(typeof(Animator)) as Animator;
avatar = animator.avatar;
}
for (int i = 0; i < m_MuscleCount; i++)
{
float min = HumanTrait.GetMuscleDefaultMin(i);
float max = HumanTrait.GetMuscleDefaultMax(i);
if (m_MuscleMin[i] != null && m_MuscleMax[i] != null)
{
m_MuscleMin[i].floatValue = m_MuscleMinEdit[i] = min;
m_MuscleMax[i].floatValue = m_MuscleMaxEdit[i] = max;
}
int humanId = HumanTrait.BoneFromMuscle(i);
if (m_Modified[humanId] != null && humanId != -1)
{
m_Modified[humanId].boolValue = false;
}
if (avatar != null)
{
avatar.SetMuscleMinMax(i, min, max);
}
}
WritePose();
}
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 static float GetMuscleDefaultMax(int muscleID)
{
return(HumanTrait.GetMuscleDefaultMax(muscleID));
}
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 override void RowGUI(RowGUIArgs args)
{
var muscleTreeViewItem = args.item as MuscleTreeItem;
if (muscleTreeViewItem != null)
{
for (var i = 0; i < args.GetNumVisibleColumns(); i++)
{
var rect = args.GetCellRect(i);
var column = (MuscleTreeColumn)args.GetColumn(i);
var labelStyle = args.selected ? EditorStyles.whiteLabel : EditorStyles.label;
var element = muscleTreeViewItem.MuscleElement;
var index = muscleTreeViewItem.MuscleElement.MuscleId;
switch (column)
{
case MuscleTreeColumn.InternalId:
break;
case MuscleTreeColumn.Id:
rect.x += 15;
EditorGUI.LabelField(rect, (index + 1).ToString(), labelStyle);
break;
case MuscleTreeColumn.CheckBox:
rect.x += 25;
element.IsExport =
EditorGUI.Toggle(rect, element.IsExport);
break;
case MuscleTreeColumn.Name:
rect.x += 35;
EditorGUI.LabelField(rect, element.MuscleName, labelStyle);
break;
case MuscleTreeColumn.FloatValue:
var value = EditorGUI.Slider(rect, element.MuscleValue,
HumanTrait.GetMuscleDefaultMin(index),
HumanTrait.GetMuscleDefaultMax(index));
element.MuscleValue = value;
this.humanPose.muscles[index] = value;
this.humanPoseHandler.SetHumanPose(ref this.humanPose);
break;
case MuscleTreeColumn.ResetButton:
if (GUI.Button(rect, "Reset"))
{
element.MuscleValue =
this.initialHumanPoseValues[index];
this.humanPose.muscles[index] =
element.MuscleValue;
this.humanPoseHandler.SetHumanPose(ref this.humanPose);
}
break;
default:
throw new ArgumentOutOfRangeException(Utility.NameOf(() => column), column, null);
}
}
}
else
{
for (var i = 0; i < args.GetNumVisibleColumns(); i++)
{
var rect = args.GetCellRect(i);
var column = (MuscleTreeColumn)args.GetColumn(i);
var boldLabelStyle = args.selected ? EditorStyles.whiteBoldLabel : EditorStyles.boldLabel;
var labelStyle = args.selected ? EditorStyles.whiteLabel : EditorStyles.label;
var itemID = args.item.id;
var value = this.muscleRootFoldToggleTable[args.item.displayName + ":" + itemID];
switch (column)
{
case MuscleTreeColumn.InternalId:
break;
case MuscleTreeColumn.Id:
rect.x += 5;
EditorGUI.LabelField(rect, args.item.id.ToString(), labelStyle);
break;
case MuscleTreeColumn.CheckBox:
rect.x += 15;
rect.xMax = rect.x + 15;
var toggle = EditorGUI.Toggle(rect, value);
if (value != toggle)
{
foreach (var treeViewItem in this.rootItem.children
.First(x => x.displayName == args.item.displayName).children
.Cast <MuscleTreeItem>())
{
treeViewItem.MuscleElement.IsExport = toggle;
}
this.muscleRootFoldToggleTable[args.item.displayName + ":" + itemID] = toggle;
}
break;
case MuscleTreeColumn.Name:
this.columnIndexForTreeFoldouts = 3;
rect.x += this.foldoutWidth + 2;
EditorGUI.LabelField(rect, args.item.displayName,
boldLabelStyle);
break;
case MuscleTreeColumn.FloatValue:
break;
case MuscleTreeColumn.ResetButton:
break;
default:
throw new ArgumentOutOfRangeException(Utility.NameOf(() => column), column, null);
}
}
}
}
