public void DeleteBone(RigResource.RigResource.Bone b, bool recursive)
{
if (b != null && mBones.Contains(b))
{
int deletedIndex = IndexOfBone(mBones, b);
RigResource.RigResource.Bone parent = b.ParentBoneIndex > -1 ? mBones[b.ParentBoneIndex] : null;
mBones.Remove(b);
OnBoneRemoved(this, new BoneActionEventArgs(b));
var trash = new List<RigResource.RigResource.Bone>();
for (int i = 0; i < mBones.Count; i++)
{
if (mBones[i].ParentBoneIndex > deletedIndex)
{
mBones[i].ParentBoneIndex--;
}
else if (mBones[i].ParentBoneIndex == deletedIndex)
{
if (recursive)
{
trash.Add(mBones[i]);
}
}
}
foreach (RigResource.RigResource.Bone item in trash) DeleteBone(item, recursive);
}
}
public RigEditorViewModel(RigResource.RigResource rig)
{
rig.ResourceChanged += OnResourceChanged;
mIsSaving = false;
mChildren = new ObservableCollection<BoneViewModel>();
mRig = rig;
mManager = new BoneManager();
mManager.Bones = mRig.Bones;
foreach (RigResource.RigResource.Bone bone in mRig.Bones)
{
if (bone.ParentBoneIndex == -1)
{
mChildren.Add(new BoneViewModel(this, this, bone, mManager));
}
}
mManager.BoneAdded += OnBoneAdded;
mManager.BoneRemoved += OnBoneRemoved;
mManager.BoneParentChanged += OnBoneParentChanged;
AddBoneCommand = new UserCommand<RigEditorViewModel>(x => true, y => y.Manager.AddBone(new RigResource.RigResource.Bone(0, null), null));
GetMatrixInfoCommand = new UserCommand<RigEditorViewModel>(x => true, ExecuteMatrixInfo);
CommitCommand = new UserCommand<RigEditorViewModel>(x => true, y =>
{
mIsSaving = true;
Application.Current.Shutdown();
});
CancelCommand = new UserCommand<RigEditorViewModel>(x => true, y =>
{
mIsSaving = false;
Application.Current.Shutdown();
});
IResourceKey key = new TGIBlock(0, null);
key.ResourceType = 0x00000000;
}
public IEnumerable<RigResource.RigResource.Bone> GetChildren(RigResource.RigResource.Bone b)
{
int ix = IndexOfBone(mBones, b);
for (int i = 0; i < mBones.Count; i++)
{
if (mBones[i].ParentBoneIndex == ix) yield return mBones[i];
}
}
public BoneViewModel(RigEditorViewModel rig, IHaveBones parent, RigResource.RigResource.Bone bone, BoneManager manager)
{
if (rig == null) throw new ArgumentNullException("rig");
if (bone == null) throw new ArgumentNullException("bone");
if (manager == null) throw new ArgumentNullException("manager");
mRig = rig;
mChildren = new ObservableCollection<BoneViewModel>();
mParent = parent;
mBone = bone;
mManager = manager;
foreach (RigResource.RigResource.Bone b in manager.GetChildren(mBone))
{
mChildren.Add(new BoneViewModel(mRig, this, b, mManager));
}
mRotation = new EulerAngle(new Quaternion(bone.Orientation.A, bone.Orientation.B, bone.Orientation.C, bone.Orientation.D));
manager.BoneAdded += OnBoneAdded;
manager.BoneRemoved += OnBoneRemoved;
manager.BoneParentChanged += OnBoneParentChanged;
mSetOppositeCommand = new UserCommand<BoneViewModel>(x => true, ExecuteSetOpposite);
}
public BoneExportViewModel(RigResource.RigResource.Bone bone, BoneManager manager)
{
mIsChecked = bone.Name.Contains("slot");
Bone = bone;
mChildren = manager.GetChildren(bone).Select(x => new BoneExportViewModel(x, manager));
// if (bone.Name.Contains("ROOT"))
// {
// Thread t = null;
// t = new Thread(
// delegate
// {
// while (t.IsAlive)
// {
// Thread.Sleep(new Random().Next(10000));
// IsChecked = !IsChecked;
// }
// });
// t.Start();
// }
}
public IEnumerable<RigResource.RigResource.Bone> GetDescendants(RigResource.RigResource.Bone b)
{
var list = new List<RigResource.RigResource.Bone>();
GetDescendantsRecursive(b, list);
return list;
}
public void AddBone(RigResource.RigResource.Bone child, RigResource.RigResource.Bone parent)
{
Bones.Add(child);
OnBoneAdded(this, new BoneActionEventArgs(child));
SetParent(child, parent);
}
private void GetDescendantsRecursive(RigResource.RigResource.Bone b, IList<RigResource.RigResource.Bone> list)
{
int ix = IndexOfBone(mBones, b);
for (int i = 0; i < mBones.Count; i++)
{
if (mBones[i].ParentBoneIndex == ix)
{
list.Add(mBones[i]);
GetDescendantsRecursive(mBones[i], list);
}
}
}
public void UpdateBone(RigResource.RigResource.Bone b)
{
OnBoneUpdated(this, new BoneActionEventArgs(b));
}
public void SetName(RigResource.RigResource.Bone b, string name)
{
if (b.Name != name)
{
b.Name = name;
OnBoneUpdated(this, new BoneActionEventArgs(b));
}
}
public int IndexOfBone(IList<RigResource.RigResource.Bone> bones, RigResource.RigResource.Bone bone)
{
for (int i = 0; i < bones.Count; i++)
{
if (bone == bones[i]) return i;
}
return -1;
}
private static void GetInfo(BoneManager manager, RigResource.RigResource.Bone bone, StringBuilder sb)
{
Matrix t = GetAbsoluteTransform(manager, bone);
Matrix ti = t.GetInverse();
sb.AppendLine("============================");
sb.AppendFormat("Name:\t{0}\r\n", bone.Name);
sb.AppendFormat("Hashed:\t0x{0:X8}\r\n", FNV32.GetHash(bone.Name));
sb.AppendLine("Absolute Transform (RSLT):");
sb.AppendLine(t.TransposedString());
sb.AppendLine("Absolute Transform Inverse (SKIN):");
sb.AppendLine(ti.ToString());
}
private static Matrix GetAbsoluteTransform(BoneManager manager, RigResource.RigResource.Bone b)
{
var transforms = new List<Matrix>();
while (b != null)
{
var q = new Quaternion(b.Orientation.A, b.Orientation.B, b.Orientation.C, b.Orientation.D);
var p = new Vector3(b.Position.X, b.Position.Y, b.Position.Z);
var s = new Vector3(b.Scaling.X, b.Scaling.Y, b.Scaling.Z);
Matrix t = Matrix.CreateTransformMatrix(q, s, p);
transforms.Add(t);
b = manager.GetParent(b);
}
transforms.Reverse();
Matrix absolute = transforms[0];
transforms.RemoveAt(0);
while (transforms.Count > 0)
{
Matrix m = transforms[0];
transforms.RemoveAt(0);
absolute = absolute*m;
}
return absolute;
}
public BoneListItem(RigResource.RigResource.Bone bone)
{
Bone = bone;
}
public BoneActionEventArgs(RigResource.RigResource.Bone bone)
{
mBone = bone;
}
public RigResource.RigResource.Bone GetParent(RigResource.RigResource.Bone b)
{
if (b.ParentBoneIndex == -1) return null;
else return mBones[b.ParentBoneIndex];
}
public void SetParent(RigResource.RigResource.Bone child, RigResource.RigResource.Bone parent)
{
if (child.ParentBoneIndex != IndexOfBone(mBones, parent))
{
child.ParentBoneIndex = parent == null ? -1 : IndexOfBone(mBones, parent);
OnBoneParentChanged(this, new BoneActionEventArgs(child));
}
}
private static void CloneHierarchy(BoneManager manager, RigResource.RigResource.Bone bone, RigResource.RigResource.Bone dest)
{
List<RigResource.RigResource.Bone> descendants = manager.GetDescendants(bone).ToList();
var clones = new List<RigResource.RigResource.Bone>();
var map = new Dictionary<RigResource.RigResource.Bone, RigResource.RigResource.Bone>();
var root = new RigResource.RigResource.Bone(0, null, bone);
map[bone] = root;
manager.AddBone(root, dest);
foreach (RigResource.RigResource.Bone descendant in descendants)
{
var clone = new RigResource.RigResource.Bone(0, null, descendant);
map[descendant] = clone;
clones.Add(clone);
manager.AddBone(clone, manager.GetParent(descendant));
}
foreach (RigResource.RigResource.Bone c in clones)
{
RigResource.RigResource.Bone parent = manager.GetParent(c);
if (map.ContainsKey(parent))
{
manager.SetParent(c, map[parent]);
}
}
}
