protected override DanceMotion ReadTarget(BinaryReader reader, IReadingSession session)
{
string name = reader.ReadMoostaString();
int beatCount = reader.ReadInt32();
string[] array = new string[reader.ReadInt32()];
for (int i = 0; i < array.Length; i++)
{
array[i] = reader.ReadMoostaString();
}
string[] array2 = new string[reader.ReadInt32()];
for (int j = 0; j < array2.Length; j++)
{
array2[j] = reader.ReadMoostaString();
}
DancePose[] array3 = new DancePose[reader.ReadInt32()];
for (int k = 0; k < array3.Length; k++)
{
BoneState[] array4 = new BoneState[array2.Length];
for (int l = 0; l < array2.Length; l++)
{
array4[l] = new BoneState(new CtQuaternion(reader.ReadSingle(), reader.ReadSingle(), reader.ReadSingle(), reader.ReadSingle()));
}
array3[k] = new DancePose(array2, array4);
}
return(new DanceMotion(name, beatCount, array3, null)
{
Tags = array
});
}
public static NodeState TryGetState(Node node, Animation animation)
{
var node3D = node as Node3D;
if (node3D != null)
{
return(Node3DState.TryGetState(node3D, animation));
}
var widget = node as Widget;
if (widget != null)
{
return(WidgetState.TryGetState(widget, animation));
}
var point = node as DistortionMeshPoint;
if (point != null)
{
return(DistortionMeshPointState.TryGetState(point, animation));
}
var bone = node as Bone;
if (bone != null)
{
return(BoneState.TryGetState(bone, animation));
}
return(null);
}
void LoadBoneState(JObject bone, Dictionary <string, BoneState> states, BoneState parent)
{
string name = (string)bone["name"];
if (!states.ContainsKey(name))
{
BoneState state = new BoneState();
JObject pos = (JObject)bone["localPosition"];
state.pos = new Vector3((float)pos["x"], (float)pos["y"], (float)pos["z"]);
JObject rot = (JObject)bone["localRotation"];
state.rot = new Quaternion((float)rot["x"], (float)rot["y"], (float)rot["z"], (float)rot["w"]);
JObject sca = (JObject)bone["localScale"];
state.sca = new Vector3((float)sca["x"], (float)sca["y"], (float)sca["z"]);
state.parent = parent;
state.rot_world = state.RotWorld();
states.Add(name, state);
JArray children = (JArray)bone["children"];
for (int i = 0; i < children.Count; ++i)
{
JObject child = (JObject)children[i];
LoadBoneState(child, states, state);
}
}
}
private bool setBoneAsNativeBoneName(string boneName, BoneState boneState)
{
CtBone bone = this.Mesh.MatrixPallet.GetBone(boneName);
if (bone != null)
{
bone.TransformMatrix = CtMatrix4x4.Rotate(boneState.Rotate);
}
return(bone != null);
}
protected AvatarControl.BodyPartColor IsValidBodyPart(BodyPart bodyPart)
{
AvatarControl.BodyPartColor bodyPartColor = AvatarControl.BodyPartColor.Off;
bool flag1 = false;
int index1 = (int)bodyPart;
if (bodyPart != BodyPart.LeftFingers && bodyPart != BodyPart.RightFingers)
{
for (int index2 = 0; index2 < this.m_BodyPartHumanBone[index1].Length; ++index2)
{
if (this.m_BodyPartHumanBone[index1][index2] != -1)
{
BoneState state = this.m_Bones[this.m_BodyPartHumanBone[index1][index2]].state;
flag1 |= state == BoneState.Valid;
if (HumanTrait.RequiredBone(this.m_BodyPartHumanBone[index1][index2]) && state == BoneState.None || state != BoneState.Valid && state != BoneState.None)
{
return(AvatarControl.BodyPartColor.Red);
}
}
}
}
else
{
bool flag2 = true;
int num1 = 3;
for (int index2 = 0; index2 < this.m_BodyPartHumanBone[index1].Length / num1; ++index2)
{
bool flag3 = false;
int num2 = index2 * num1;
for (int index3 = num1 - 1; index3 >= 0; --index3)
{
bool flag4 = this.m_Bones[this.m_BodyPartHumanBone[index1][num2 + index3]].state == BoneState.Valid;
flag2 &= flag4;
if (flag3)
{
if (!flag4)
{
return(AvatarControl.BodyPartColor.Red | AvatarControl.BodyPartColor.IKRed);
}
}
else
{
flag1 |= flag3 = !flag3 && flag4;
}
}
}
bodyPartColor = !flag2 ? AvatarControl.BodyPartColor.IKRed : AvatarControl.BodyPartColor.IKGreen;
}
if (!flag1)
{
return(AvatarControl.BodyPartColor.IKRed);
}
return(AvatarControl.BodyPartColor.Green | bodyPartColor);
}
private bool setBoneAsBVHBoneName(string boneName, BoneState boneState)
{
BoneAssigner bone;
if (this.BoneTable.TryGetValue(boneName, out bone))
{
MMDDanceModel.SetBoneRotation(bone, CtMatrix4x4.Rotate(boneState.Rotate));
return(true);
}
return(false);
}
void Update()
{
if (src_bones == null || dst_bones == null || src_base_pose == null || dst_base_pose == null || bone_map == null)
{
return;
}
for (int i = 0; i < avatar_bones.Count; ++i)
{
JObject pair = (JObject)bone_map.GetValue(avatar_bones[i]);
if (pair != null)
{
string src = (string)pair.GetValue("src");
string dst = (string)pair.GetValue("dst");
if (src.Length > 0 && dst.Length > 0)
{
Transform src_bone = src_bones.Find(delegate(Transform t) {
return(src == t.name);
});
Transform dst_bone = dst_bones.Find(delegate(Transform t) {
return(dst == t.name);
});
if (src_bone && dst_bone)
{
BoneState src_base_state = src_base_pose[src];
BoneState dst_base_state = dst_base_pose[dst];
Quaternion rot = Quaternion.Inverse(src_base_state.rot) * src_bone.localRotation;
if (localRotationDirectMap)
{
dst_bone.localRotation = dst_base_state.rot * rot;
}
else
{
Vector3 euler = rot.eulerAngles;
Vector3 right = Quaternion.Inverse(dst_base_state.rot_world) * new Vector3(1, 0, 0);
Vector3 up = Quaternion.Inverse(dst_base_state.rot_world) * new Vector3(0, 1, 0);
Vector3 forward = Quaternion.Inverse(dst_base_state.rot_world) * new Vector3(0, 0, 1);
dst_bone.localRotation = dst_base_state.rot
* Quaternion.AngleAxis(euler.y, up)
* Quaternion.AngleAxis(euler.x, right)
* Quaternion.AngleAxis(euler.z, forward);
}
float scale = rootDst.localPosition.y / rootSrc.localPosition.y;
Vector3 pos = src_bone.localPosition - src_base_state.pos;
dst_bone.localPosition = dst_base_state.pos + pos * scale;
}
}
}
}
}
public void Reset(SerializedProperty humanBoneArray, Dictionary <Transform, bool> bones)
{
bone = null;
SerializedProperty property = GetSerializedProperty(humanBoneArray, false);
if (property != null)
{
string boneName = property.FindPropertyRelative(sBoneName).stringValue;
bone = bones.Keys.FirstOrDefault(b => (b != null && b.name == boneName));
}
state = BoneState.Valid;
}
private void SetPoseWithoutPivoting(DancePose pose)
{
string[] boneNames = pose.BoneNames;
for (int i = 0; i < boneNames.Length; i++)
{
string boneName = boneNames[i];
BoneState boneState = pose[boneName];
if (!this.setBoneAsNativeBoneName(boneName, boneState) && !this.setBoneViaMMDBoneName(boneName, boneState))
{
this.setBoneAsBVHBoneName(boneName, boneState);
}
}
}
/// <summary>
/// Call twice; before and after changes
/// </summary>
public void BoneChange(params IBoneNode[] bones)
{
SaveState state = new BoneState
{
_bones = bones,
_frameStates = bones.Select(x => x.FrameState).ToArray(),
_animation = SelectedCHR0,
_frameIndex = CurrentFrame,
_updateBoneOnly = CHR0Editor.chkMoveBoneOnly.Checked,
_updateBindState = CHR0Editor.chkUpdateBindPose.Checked
};
AddState(state);
}
private DancePose[] getDancePose(int frameCount, List <MFuriKeyFrameList> keyFrameLists, string[] bones)
{
DancePose[] array = new DancePose[frameCount];
for (int i = 0; i < array.Length; i++)
{
array[i] = new DancePose(bones);
foreach (MFuriKeyFrameList current in keyFrameLists)
{
BoneState value = new BoneState(current.KeyFrames[i].Rotation);
array[i][current.BoneName] = value;
}
}
return(array);
}
protected override DanceMotion ReadTarget(BinaryReader reader, IReadingSession session)
{
string name = reader.ReadMoostaString();
int beatCount = reader.ReadInt32();
int num = reader.ReadInt32();
DanceModelInfo sourceModel = (num == 0) ? null : (session.GetObject(num) as DanceModelInfo);
string[] array = new string[reader.ReadInt32()];
for (int i = 0; i < array.Length; i++)
{
array[i] = reader.ReadMoostaString();
}
string[] array2 = new string[reader.ReadInt32()];
for (int j = 0; j < array2.Length; j++)
{
array2[j] = reader.ReadMoostaString();
}
string[] array3 = new string[reader.ReadInt32()];
for (int k = 0; k < array3.Length; k++)
{
array3[k] = reader.ReadMoostaString();
}
DancePose[] array4 = new DancePose[reader.ReadInt32()];
for (int l = 0; l < array4.Length; l++)
{
CtVector3D bodyPos = new CtVector3D(reader.ReadSingle(), reader.ReadSingle(), reader.ReadSingle());
DancePoseFootState footState = (DancePoseFootState)reader.ReadInt32();
BoneState[] array5 = new BoneState[array2.Length];
for (int m = 0; m < array2.Length; m++)
{
array5[m] = new BoneState(new CtQuaternion(reader.ReadSingle(), reader.ReadSingle(), reader.ReadSingle(), reader.ReadSingle()));
}
SkinState[] array6 = new SkinState[array3.Length];
for (int n = 0; n < array3.Length; n++)
{
array6[n] = new SkinState(reader.ReadSingle());
}
array4[l] = new DancePose(array2, array5, array3, array6, bodyPos)
{
FootState = footState
};
}
return(new DanceMotion(name, beatCount, array4, sourceModel)
{
Tags = array
});
}
void ApplyBoneState(BoneState state)
{
if (TargetModel != state._targetModel)
{
_resetCamera = false;
TargetModel = state._targetModel;
}
SelectedCHR0 = state._animation;
CurrentFrame = state._frameIndex;
CHR0Editor.chkUpdateBindPose.Checked = state._updateBindState;
CHR0Editor.chkMoveBoneOnly.Checked = state._updateBoneOnly;
for (int i = 0; i < state._bones.Length; i++)
{
SelectedBone = state._bones[i];
CHR0Editor.ApplyState(state._frameStates[i]);
}
}
public void CopyFrom(Skeleton skeleton, Transform kinect, uint timestamp)
{
const float mm2m = 0.001f; // When using 0.001, we get a dwarf. Do they mean cm?
for (int i = 0; i < 32; i++)
{
var joint = skeleton.GetJoint(i);
var bone = new BoneState();
bone.position = kinect.TransformPoint(NumericsUtil.Convert(joint.Position) * mm2m);
bone.rotation = kinect.rotation * NumericsUtil.Convert(joint.Quaternion);
bone.confidenceLevel = joint.ConfidenceLevel;
bones[i] = bone;
}
this.timestamp = timestamp;
}
private static DancePose createPoseFromBvhPose(BvhNode skeleton, double[] bvhPose, string[] bones)
{
Dictionary <string, BoneState> items = new Dictionary <string, BoneState>();
int num = 0;
foreach (BvhNode current in skeleton.GetAllNodesRecursively())
{
Angle x = Angle.Deg000;
Angle y = Angle.Deg000;
Angle z = Angle.Deg000;
BvhChannels[] channels = current.Channels;
for (int i = 0; i < channels.Length; i++)
{
switch (channels[i])
{
case BvhChannels.Xrotation:
x = -Angle.FromDegree(bvhPose[num]);
break;
case BvhChannels.Yrotation:
y = -Angle.FromDegree(bvhPose[num]);
break;
case BvhChannels.Zrotation:
z = Angle.FromDegree(bvhPose[num]);
break;
}
num++;
}
BoneState value = new BoneState(x, y, z);
if (current.Name.Equals("Hips"))
{
value.Rotate = new CtQuaternion(new CtVector3D(0f, 1f, 0f), 3.1415926535897931) * value.Rotate;
}
items[current.Name] = value;
}
return(new DancePose(bones, Array.ConvertAll <string, BoneState>(bones, delegate(string name)
{
if (!items.ContainsKey(name))
{
return BoneState.Zero;
}
return items[name];
})));
}
private bool setBoneViaMMDBoneName(string boneName, BoneState boneState)
{
string text = Moosta.Common.BoneNames.TryConvertToMmdBone(boneName);
return(!string.IsNullOrEmpty(text) && this.setBoneAsNativeBoneName(text, boneState));
}
public AnimationFile(string n,int s,int tS,BoneState[] bS)
{
name = n;
samples = s;
totalSamples = tS;
bonesStates = bS;
}
/// <summary>
/// Draws the GUI for a single bone dot.
/// </summary>
/// <returns>Returns true if this is being hovered</returns>
public bool BoneDotGUI(Rect rect, Rect selectRect, Rect tooltipRect, int boneIndex, bool hasHover = false)
{
bool hover = false;
Event current = Event.current;
Color color = GUI.color;
if (!hasHover)
{
if (selectRect.Contains(current.mousePosition))
{
if (state == BoneState.Valid)
{
if (current.type == EventType.MouseDown)
{
if (bone == null)
{
state = BoneState.None;
}
else
{
Selection.activeTransform = bone;
if (bone != null)
{
EditorGUIUtility.PingObject(bone);
}
}
current.Use();
}
else
{
GUI.color = kBoneSelected;
GUI.DrawTexture(rect, DotSelection.image);
}
}
GUI.color = color;
GUI.Box(tooltipRect, boneName, EditorStyles.whiteMiniLabel);
hover = true;
}
}
switch (state)
{
case BoneState.Valid:
GUI.color = kBoneValid;
break;
case BoneState.None:
GUI.color = kBoneInactive;
break;
default:
GUI.color = kBoneInvalid;
break;
}
Texture image = HumanTrait.RequiredBone(boneIndex) ? DotFrame.image : DotFrameDotted.image;
GUI.DrawTexture(rect, image);
if (bone != null)
{
GUI.DrawTexture(rect, DotFill.image);
}
GUI.color = color;
return(hover);
}
public BoneWrapper(string boneName, Transform bone)
{
this.boneName = ObjectNames.NicifyVariableName(boneName);
this.bone = bone;
state = bone == null ? BoneState.None : BoneState.Valid;
}
public BoneWrapper(string humanBoneName, Transform bone)
{
this.m_HumanBoneName = humanBoneName;
this.bone = bone;
this.state = BoneState.Valid;
}
private static bool IsTouching(BoneState bone, KinectButton button)
{
const float threshold = 0.4f;
return(math.distance(bone.position, button.transform.position) < threshold);
}
