public override IEnumerable <Object> FetchDependencies(ISerializedFile file, bool isLog = false)
{
foreach (Object @object in base.FetchDependencies(file, isLog))
{
yield return(@object);
}
if (IsReadOffscreen(file.Version))
{
yield return(DisableAnimationWhenOffscreen.FetchDependency(file, isLog, ToLogString, "m_DisableAnimationWhenOffscreen"));
}
yield return(Mesh.FetchDependency(file, isLog, ToLogString, "m_Mesh"));
foreach (PPtr <Transform> ptr in Bones)
{
if (!ptr.IsNull)
{
yield return(ptr.GetAsset(file));
}
}
if (!RootBone.IsNull)
{
yield return(RootBone.GetAsset(file));
}
}
/// <summary>
/// Set the current animation to the given one and pause it at the given time.
/// </summary>
/// <param name="animation">The name of the animation to go to.</param>
/// <param name="time">The time in the animation to set.</param>
public void GotoAndStop(string animation, float time)
{
GotoAnimation(animation);
_currentAnimation?.SetTime(time);
if (_currentAnimation != null)
{
RootBone?.UpdateRecursive(_currentAnimation.GetCurrentState().TransformState);
}
}
public override void OnInspectorGUI()
{
HumanMuscle script = target as HumanMuscle;
if (!EditorApplication.isPlaying)
{
script.animator = (Animator)EditorGUILayout.ObjectField("Animator", script.animator, typeof(Animator), true);
script.scriptableObject = (HumanMuscleScriptableObject)EditorGUILayout.ObjectField("ScriptableObject", script.scriptableObject, typeof(HumanMuscleScriptableObject), true);
}
else
{
menuName = (MenuName)EditorGUILayout.EnumPopup("MenuName", menuName);
switch (menuName)
{
case MenuName.All:
ViewAllMenu(script);
break;
case MenuName.Body:
ViewBodyMenu(script);
break;
case MenuName.Finger:
ViewFingerMenu(script);
break;
}
if (menuName == MenuName.All || boneName == RootBone.GetInstance())
{
// 位置と角度
script.Position = transGUI.Position(script.Position);
script.Angle = transGUI.Angle();
}
else
{
if (boneName != null)
{
foreach (var key in boneName.Muscles)
{
var id = (HumanMuscleKey)key.Id;
script[id] = EditorGUILayout.Slider((id).ToString(), script[id], -1, 1);
}
// 反転コピー
if (GUILayout.Button("Mirror"))
{
boneName.Mirror(script.Muscles);
}
}
}
}
EditorUtility.SetDirty(target);
}
protected override YAMLMappingNode ExportYAMLRoot(IExportContainer container)
{
YAMLMappingNode node = base.ExportYAMLRoot(container);
node.AddSerializedVersion(GetSerializedVersion(container.ExportVersion));
node.Add(QualityName, Quality);
node.Add(UpdateWhenOffscreenName, UpdateWhenOffscreen);
node.Add(SkinnedMotionVectorsName, SkinnedMotionVectors);
node.Add(MeshName, Mesh.ExportYAML(container));
node.Add(BonesName, Bones.ExportYAML(container));
node.Add(BlendShapeWeightsName, IsReadWeights(container.Version) ? m_blendShapeWeights.ExportYAML() : YAMLSequenceNode.Empty);
node.Add(RootBoneName, RootBone.ExportYAML(container));
node.Add(AABBName, AABB.ExportYAML(container));
node.Add(DirtyAABBName, DirtyAABB);
return(node);
}
protected override YAMLMappingNode ExportYAMLRoot(IExportContainer container)
{
#warning TODO: values acording to read version (current 2017.3.0f3)
YAMLMappingNode node = base.ExportYAMLRoot(container);
node.AddSerializedVersion(GetSerializedVersion(container.Version));
node.Add("m_Quality", Quality);
node.Add("m_UpdateWhenOffscreen", UpdateWhenOffscreen);
node.Add("m_skinnedMotionVectors", SkinnedMotionVectors);
node.Add("m_Mesh", Mesh.ExportYAML(container));
node.Add("m_Bones", Bones.ExportYAML(container));
node.Add("m_BlendShapeWeights", IsReadWeights(container.Version) ? m_blendShapeWeights.ExportYAML() : YAMLSequenceNode.Empty);
node.Add("m_RootBone", RootBone.ExportYAML(container));
node.Add("m_AABB", AABB.ExportYAML(container));
node.Add("m_DirtyAABB", DirtyAABB);
return(node);
}
protected override YAMLMappingNode ExportYAMLRoot()
{
YAMLMappingNode node = base.ExportYAMLRoot();
node.AddSerializedVersion(SerializedVersion);
node.Add("m_Quality", Quality);
node.Add("m_UpdateWhenOffscreen", UpdateWhenOffscreen);
node.Add("m_skinnedMotionVectors", SkinnedMotionVectors);
node.Add("m_Mesh", Mesh.ExportYAML());
node.Add("m_Bones", m_bones.ExportYAML());
node.Add("m_BlendShapeWeights", m_blendShapeWeights.ExportYAML());
node.Add("m_RootBone", RootBone.ExportYAML());
node.Add("m_AABB", AABB.ExportYAML());
node.Add("m_DirtyAABB", DirtyAABB);
return(node);
}
public override IEnumerable <Object> FetchDependencies(bool isLog = false)
{
foreach (Object @object in base.FetchDependencies(isLog))
{
yield return(@object);
}
if (IsReadOffscreen)
{
if (!DisableAnimationWhenOffscreen.IsNull)
{
Animation anim = DisableAnimationWhenOffscreen.GetObject();
if (anim == null)
{
if (isLog)
{
Logger.Log(LogType.Warning, LogCategory.Export, $"{ToLogString()} m_DisableAnimationWhenOffscreen {DisableAnimationWhenOffscreen.ToLogString()} wasn't found ");
}
}
else
{
yield return(anim);
}
}
}
if (!Mesh.IsNull)
{
Mesh mesh = Mesh.FindObject();
if (mesh == null)
{
Logger.Log(LogType.Warning, LogCategory.Export, $"{ToLogString()} m_Mesh {Mesh.ToLogString()} wasn't found ");
}
else
{
yield return(mesh);
}
}
foreach (PPtr <Transform> ptr in Bones)
{
yield return(ptr.GetObject());
}
if (!RootBone.IsNull)
{
yield return(RootBone.GetObject());
}
}
/// <summary>
/// Populates the passed in array with the bone matrices based on the current position.
/// </summary>
/// <remarks>
/// Internal use only. The array passed in must
/// be at least as large as the number of bones.
/// Assumes animation has already been updated.
/// </remarks>
/// <param name="matrices"></param>
internal virtual void GetBoneMatrices(Matrix4[] matrices)
{
// update derived transforms
RootBone.Update(true, false);
/*
* Calculating the bone matrices
* -----------------------------
* Now that we have the derived orientations & positions in the Bone nodes, we have
* to compute the Matrix4 to apply to the vertices of a mesh.
* Because any modification of a vertex has to be relative to the bone, we must first
* reverse transform by the Bone's original derived position/orientation, then transform
* by the new derived position / orientation.
*/
var i = 0;
foreach (var bone in this.boneList.Values)
{
matrices[i++] = bone.FullTransform * bone.BindDerivedInverseTransform;
}
}
public override void Read(AssetReader reader)
{
if (IsReadRenderer(reader.Version))
{
base.Read(reader);
}
else
{
ReadBase(reader);
}
if (IsReadUpdateWhenOffscreen(reader.Version))
{
if (IsReadQualityFirst(reader.Version))
{
Quality = reader.ReadInt32();
}
UpdateWhenOffscreen = reader.ReadBoolean();
if (!IsReadQualityFirst(reader.Version))
{
Quality = reader.ReadInt32();
}
}
if (IsReadSkinNormals(reader.Version))
{
SkinNormals = reader.ReadBoolean();
}
if (IsReadSkinMotionVector(reader.Version))
{
SkinnedMotionVectors = reader.ReadBoolean();
}
if (IsAlignBools(reader.Version))
{
reader.AlignStream(AlignType.Align4);
}
if (IsReadOffscreen(reader.Version))
{
DisableAnimationWhenOffscreen.Read(reader);
}
if (IsReadMeshFirst(reader.Version))
{
Mesh.Read(reader);
}
if (IsReadAnimation(reader.Version))
{
Animation.Read(reader);
}
m_bones = reader.ReadAssetArray <PPtr <Transform> >();
if (IsAlignBones(reader.Version))
{
reader.AlignStream(AlignType.Align4);
}
if (!IsReadMeshFirst(reader.Version))
{
Mesh.Read(reader);
}
if (IsReadBindPose(reader.Version))
{
m_bindPose = reader.ReadAssetArray <Matrix4x4f>();
}
if (IsReadCurrentPose(reader.Version))
{
CurrentPose.Read(reader);
}
if (IsReadWeights(reader.Version))
{
m_blendShapeWeights = reader.ReadSingleArray();
}
if (IsReadRootBone(reader.Version))
{
RootBone.Read(reader);
}
if (IsReadAABB(reader.Version))
{
AABB.Read(reader);
DirtyAABB = reader.ReadBoolean();
if (IsAlignDirty(reader.Version))
{
reader.AlignStream(AlignType.Align4);
}
}
}
//Load model from unity, map model bones to our bone structure and create a skeleton
private void LoadModel()
{
//Clone the referenced mesh
AnimatedMesh.mesh = ReferenceMesh.sharedMesh.CloneMesh();
AnimatedMesh.GetComponent <Renderer>().materials = ReferenceMesh.GetComponent <Renderer>().materials;
_vertices = new List <Vector3>(AnimatedMesh.mesh.vertices.Length);
var basePoseVertices = new Vector3[ReferenceMesh.sharedMesh.vertices.Length];
var basePoseNormals = new Vector3[ReferenceMesh.sharedMesh.normals.Length];
var nameBoneDictionary = new Dictionary <string, BaseBone>();
BaseBone[] boneArray = new BaseBone[0];
var vertexIdBoneWeightDictionary = new Dictionary <int, Dictionary <string, float> >();
int[] boneIndexArray = new int[0];
float[] boneWeightArray = new float[0];
//Load vertices and normals for basePose
Array.Copy(ReferenceMesh.sharedMesh.vertices, basePoseVertices, basePoseVertices.Length);
Array.Copy(ReferenceMesh.sharedMesh.normals, basePoseNormals, basePoseNormals.Length);
var bindPoses = new Matrix4x4[ReferenceMesh.sharedMesh.bindposes.Length];
Array.Copy(ReferenceMesh.sharedMesh.bindposes, bindPoses, bindPoses.Length);
//bones could for example be pulled from a SkinnedMeshRenderer
boneArray = new BaseBone[ReferenceMesh.bones.Length];
for (var i = 0; i < ReferenceMesh.bones.Length; i++)
{
var localPosition = bindPoses[i].inverse.GetColumn(3);
var localRotation = bindPoses[i].inverse.rotation;
if (i == 0)
{
boneArray[i] = new RootBone(localPosition, localRotation);
ReferenceMesh.rootBone.name = "root";
nameBoneDictionary.Add(ReferenceMesh.rootBone.name, boneArray[i]);
}
else
{
var parentIndex = -1;
for (var j = 0; j < ReferenceMesh.bones.Length; j++)
{
if (ReferenceMesh.bones[j] != ReferenceMesh.bones[i].parent)
{
continue;
}
parentIndex = j;
break;
}
localRotation = (ReferenceMesh.sharedMesh.bindposes[parentIndex] * ReferenceMesh.sharedMesh.bindposes[i].inverse).rotation;
localPosition = (ReferenceMesh.sharedMesh.bindposes[parentIndex] * ReferenceMesh.sharedMesh.bindposes[i].inverse).GetColumn(3);
boneArray[i] = new Bone(localPosition, localRotation, ReferenceMesh.bones[i].parent.name);
nameBoneDictionary.Add(ReferenceMesh.bones[i].name, boneArray[i]);
}
}
//Unity BoneWeight class can assign up to four bones to each vertex, acessable via bone inicies
var boneWeights = ReferenceMesh.sharedMesh.boneWeights;
boneWeightArray = new float[basePoseVertices.Length * 4];
boneIndexArray = new int[basePoseVertices.Length * 4];
for (var i = 0; i < basePoseVertices.Length; i++)
{
Dictionary <string, float> dic = new Dictionary <string, float>();
var name0 = ReferenceMesh.bones[boneWeights[i].boneIndex0].name;
var name1 = ReferenceMesh.bones[boneWeights[i].boneIndex1].name;
var name2 = ReferenceMesh.bones[boneWeights[i].boneIndex2].name;
var name3 = ReferenceMesh.bones[boneWeights[i].boneIndex3].name;
dic.Add(name0, boneWeights[i].weight0);
if (!dic.ContainsKey(name1))
{
dic.Add(name1, boneWeights[i].weight1);
}
if (!dic.ContainsKey(name2))
{
dic.Add(name2, boneWeights[i].weight2);
}
if (!dic.ContainsKey(name3))
{
dic.Add(name3, boneWeights[i].weight3);
}
vertexIdBoneWeightDictionary.Add(i, dic);
boneWeightArray[4 * i] = boneWeights[i].weight0;
boneWeightArray[4 * i + 1] = boneWeights[i].weight1;
boneWeightArray[4 * i + 2] = boneWeights[i].weight2;
boneWeightArray[4 * i + 3] = boneWeights[i].weight3;
boneIndexArray[4 * i] = boneWeights[i].boneIndex0;
boneIndexArray[4 * i + 1] = boneWeights[i].boneIndex1;
boneIndexArray[4 * i + 2] = boneWeights[i].boneIndex2;
boneIndexArray[4 * i + 3] = boneWeights[i].boneIndex3;
}
//Create a skeleton
Skeleton = new Skeleton(nameBoneDictionary, vertexIdBoneWeightDictionary, basePoseVertices, basePoseNormals, boneArray, boneIndexArray, boneWeightArray);
//Deactivate template
ReferenceMesh.gameObject.SetActive(false);
}
public override void Read(EndianStream stream)
{
base.Read(stream);
Quality = stream.ReadInt32();
UpdateWhenOffscreen = stream.ReadBoolean();
if (IsReadSkinNormals)
{
SkinNormals = stream.ReadBoolean();
}
if (IsReadSkinMotionVector)
{
SkinnedMotionVectors = stream.ReadBoolean();
}
stream.AlignStream(AlignType.Align4);
if (IsReadOffscreen)
{
DisableAnimationWhenOffscreen.Read(stream);
}
Mesh.Read(stream);
int bonesCount = stream.ReadInt32();
m_bones = new PPtr <Transform> [bonesCount];
for (int i = 0; i < bonesCount; i++)
{
PPtr <Transform> bone = new PPtr <Transform>(AssetsFile);
bone.Read(stream);
m_bones[i] = bone;
}
stream.AlignStream(AlignType.Align4);
if (IsReadBindPose)
{
BindPose.Read(stream);
}
if (IsReadAABB)
{
if (IsReadWeights)
{
int weightCount = stream.ReadInt32();
m_blendShapeWeights = new float[weightCount];
for (int i = 0; i < weightCount; i++)
{
float weight = stream.ReadSingle();
m_blendShapeWeights[i] = weight;
}
}
if (IsReadRootBone)
{
RootBone.Read(stream);
}
AABB.Read(stream);
DirtyAABB = stream.ReadBoolean();
stream.AlignStream(AlignType.Align4);
}
}
private void ViewBodyMenu(HumanMuscle script)
{
GUILayout.BeginHorizontal();
EditorGUILayout.Space();
BoneNameButton(HeadBone.GetInstance(), 100);
EditorGUILayout.Space();
GUILayout.EndHorizontal();
GUILayout.BeginHorizontal();
EditorGUILayout.Space();
BoneNameButton(ShoulderLeftBone.GetInstance());
BoneNameButton(NeckBone.GetInstance(), 80);
BoneNameButton(ShoulderRightBone.GetInstance());
EditorGUILayout.Space();
GUILayout.EndHorizontal();
GUILayout.BeginHorizontal();
BoneNameButton(UpperArmLeftBone.GetInstance());
EditorGUILayout.Space();
BoneNameButton(UpperChestBone.GetInstance(), 100);
EditorGUILayout.Space();
BoneNameButton(UpperArmRightBone.GetInstance());
GUILayout.EndHorizontal();
GUILayout.BeginHorizontal();
BoneNameButton(LowerArmLeftBone.GetInstance());
EditorGUILayout.Space();
BoneNameButton(ChestBone.GetInstance(), 100);
EditorGUILayout.Space();
BoneNameButton(LowerArmRightBone.GetInstance());
GUILayout.EndHorizontal();
GUILayout.BeginHorizontal();
BoneNameButton(HandLeftBone.GetInstance(), 100);
EditorGUILayout.Space();
BoneNameButton(SpineBone.GetInstance(), 100);
EditorGUILayout.Space();
BoneNameButton(HandRightBone.GetInstance(), 100);
GUILayout.EndHorizontal();
GUILayout.BeginHorizontal();
EditorGUILayout.Space();
BoneNameButton(RootBone.GetInstance(), 100);
EditorGUILayout.Space();
GUILayout.EndHorizontal();
GUILayout.BeginHorizontal();
EditorGUILayout.Space();
BoneNameButton(UpperLegLeftBone.GetInstance(), 150);
BoneNameButton(UpperLegRightBone.GetInstance(), 150);
EditorGUILayout.Space();
GUILayout.EndHorizontal();
GUILayout.BeginHorizontal();
EditorGUILayout.Space();
BoneNameButton(LowerLegLeftBone.GetInstance(), 150);
EditorGUILayout.Space();
BoneNameButton(LowerLegRightBone.GetInstance(), 150);
EditorGUILayout.Space();
GUILayout.EndHorizontal();
GUILayout.BeginHorizontal();
BoneNameButton(FootLeftBone.GetInstance(), 150);
EditorGUILayout.Space();
BoneNameButton(FootRightBone.GetInstance(), 150);
GUILayout.EndHorizontal();
GUILayout.BeginHorizontal();
BoneNameButton(ToesLeftBone.GetInstance(), 150);
EditorGUILayout.Space();
BoneNameButton(ToesRightBone.GetInstance(), 150);
GUILayout.EndHorizontal();
}
