public ClipBone(ModelViewerAux.AnimationClip.Bone bone, MeshBone assignedBone)
{
AssignedBone = assignedBone;
Bone = bone;
SetKeyframes();
SetPosition(0);
}
public MeshBone GetRootBone()
{
CreatureManager cur_manager = creature_renderer.creature_manager;
CreatureModule.Creature cur_creature = cur_manager.target_creature;
MeshRenderBoneComposition bone_composition = cur_creature.render_composition;
MeshBone root_bone = bone_composition.root_bone;
return(root_bone);
}
private void InitControllers()
{
if (creature_renderer == null)
{
return;
}
MeshBone root_bone = GetRootBone();
runtime_bones = root_bone.getAllChildren();
child_bodies = new List <Rigidbody2D>();
List <Collider2D> bone_colliders = new List <Collider2D>();
var parent_obj = creature_renderer.gameObject;
Collider2D parent_collider = parent_obj.GetComponent <Collider2D>();
if (parent_collider != null)
{
if (noCollisions)
{
parent_collider.enabled = false;
}
foreach (Transform child in transform)
{
var cur_body = child.GetComponent <Rigidbody2D>();
var cur_collider = child.GetComponent <Collider2D>();
if ((cur_body != null) && (cur_collider != null))
{
child_bodies.Add(cur_body);
bone_colliders.Add(cur_collider);
// Turn off collision between bone collider and parent collider
Physics2D.IgnoreCollision(cur_collider, parent_collider);
if (noCollisions)
{
cur_collider.enabled = false;
}
}
}
// Turn off collisions between bone colliders
foreach (Collider2D cur_collider1 in bone_colliders)
{
foreach (Collider2D cur_collider2 in bone_colliders)
{
if (cur_collider1 != cur_collider2)
{
Physics2D.IgnoreCollision(cur_collider1, cur_collider2);
}
}
}
}
}
public static void debugDrawBones(MeshBone bone_in)
{
XnaGeometry.Vector4 pt1 = bone_in.world_start_pt;
XnaGeometry.Vector4 pt2 = bone_in.world_end_pt;
Debug.DrawLine(new Vector3((float)pt1.X, (float)pt1.Y, 0),
new Vector3((float)pt2.X, (float)pt2.Y, 0), Color.white);
foreach (MeshBone cur_child in bone_in.children)
{
debugDrawBones(cur_child);
}
}
public void debugDrawBones(MeshBone bone_in)
{
/*
* Vector4 pt1 = bone_in.world_start_pt;
* Vector4 pt2 = bone_in.world_end_pt;
*/
/*
* Debug.DrawLine (new Vector3((float)pt1.X, (float)pt1.Y, 0),
* new Vector3((float)pt2.X, (float)pt2.Y, 0), Color.white);
*/
foreach (MeshBone cur_child in bone_in.children)
{
debugDrawBones(cur_child);
}
}
public static void Serialize(this SerializingContainer2 sc, ref MeshBone mb)
{
if (sc.IsLoading)
{
mb = new MeshBone();
}
sc.Serialize(ref mb.Name);
sc.Serialize(ref mb.Flags);
sc.Serialize(ref mb.Orientation);
sc.Serialize(ref mb.Position);
sc.Serialize(ref mb.NumChildren);
sc.Serialize(ref mb.ParentIndex);
if (sc.Game >= MEGame.ME3)
{
sc.Serialize(ref mb.BoneColor);
}
}
public void initCarryBones(MeshBone endeffector_bone)
{
if (bones_basis != null)
{
// Already bound
return;
}
bones_basis = new List <MeshBoneUtil.Tuple <XnaGeometry.Vector2, XnaGeometry.Vector2> >();
carry_bones = endeffector_bone.getAllChildren();
carry_bones.RemoveAt(0); // Remove first end_effector bone, we do not want to carry that
var base_vec_u = endeffector_bone.getWorldEndPt() - endeffector_bone.getWorldStartPt();
base_vec_u.Normalize();
var base_vec_v = new XnaGeometry.Vector4(0, 0, 0, 0);
base_vec_v.X = -base_vec_u.Y;
base_vec_v.Y = base_vec_u.X;
foreach (var cur_bone in carry_bones)
{
var basis_start = getFromBasis(
cur_bone.getWorldStartPt() - endeffector_bone.getWorldStartPt(),
base_vec_u,
base_vec_v);
var basis_end = getFromBasis(
cur_bone.getWorldEndPt() - endeffector_bone.getWorldStartPt(),
base_vec_u,
base_vec_v);
var basis_pair =
new MeshBoneUtil.Tuple <XnaGeometry.Vector2, XnaGeometry.Vector2>(basis_start, basis_end);
bones_basis.Add(basis_pair);
}
}
public void poseCarryBones(MeshBone endeffector_bone)
{
int i = 0;
foreach (var cur_bone in carry_bones)
{
var basis_pair = bones_basis[i];
var tmp_vec = endeffector_bone.getWorldEndPt() - endeffector_bone.getWorldStartPt();
var base_vec_u = new XnaGeometry.Vector2(tmp_vec.X, tmp_vec.Y);
base_vec_u.Normalize();
var base_vec_v = new XnaGeometry.Vector2(0, 0);
base_vec_v.X = -base_vec_u.Y;
base_vec_v.Y = base_vec_u.X;
var set_startpt = new XnaGeometry.Vector4(0, 0, 0, 1);
var set_endpt = new XnaGeometry.Vector4(0, 0, 0, 1);
var calcVec = new XnaGeometry.Vector2(0, 0);
calcVec = basis_pair.Item1.X * base_vec_u + basis_pair.Item1.Y * base_vec_v;
set_startpt.X = calcVec.X;
set_startpt.Y = calcVec.Y;
set_startpt += endeffector_bone.getWorldStartPt();
set_startpt.W = 1;
calcVec = basis_pair.Item2.X * base_vec_u + basis_pair.Item2.Y * base_vec_v;
set_endpt.X = calcVec.X;
set_endpt.Y = calcVec.Y;
set_endpt += endeffector_bone.getWorldStartPt();
set_endpt.W = 1;
cur_bone.setWorldStartPt(set_startpt);
cur_bone.setWorldEndPt(set_endpt);
i++;
}
}
private static List <MeshBone> ReadBones(int boneCount, BinaryReader reader)
{
var bones = new List <MeshBone>(boneCount);
for (var i = 0; i < boneCount; i++)
{
var bone = new MeshBone
{
Flags = reader.ReadInt16(),
ParentId = reader.ReadInt16(),
Name = reader.ReadFixedString(48),
FullWorldInverse = ReadMatrix4X3(reader)
};
if (bone.ParentId != -1)
{
bone.Parent = bones[bone.ParentId];
}
bones.Add(bone);
}
return(bones);
}
public MeshBone(string name, Matrix bindTransform, MeshBone parent)
{
this.Name = name;
this.parent = parent;
ComputeAbsoluteTransform (bindTransform);
SkinTransform = Matrix.Invert (AbsoluteTransform);
}
public void debugDrawBones(MeshBone bone_in)
{
XnaGeometry.Vector4 pt1 = bone_in.world_start_pt;
XnaGeometry.Vector4 pt2 = bone_in.world_end_pt;
Debug.DrawLine (new Vector3((float)pt1.X, (float)pt1.Y, 0),
new Vector3((float)pt2.X, (float)pt2.Y, 0), Color.white);
foreach(MeshBone cur_child in bone_in.children)
{
debugDrawBones(cur_child);
}
}
public static MeshBone CreateBones(Dictionary<string, object> json_obj,
string key)
{
MeshBone root_bone = null;
Dictionary<string, object> base_obj = (Dictionary<string, object>)json_obj[key];
Dictionary<int, Tuple<MeshBone, List<int> > > bone_data = new Dictionary<int, Tuple<MeshBone, List<int> > >();
Dictionary<int, int> child_set = new Dictionary<int, int>();
// layout bones
foreach(KeyValuePair<string, object> cur_node in base_obj)
{
string cur_name = cur_node.Key;
Dictionary<string, object> node_dict = (Dictionary<string, object>)cur_node.Value;
int cur_id = Convert.ToInt32(node_dict["id"]); //GetJSONNodeFromKey(*cur_node, "id")->value.toNumber();
XnaGeometry.Matrix cur_parent_mat = Utils.ReadMatrixJSON(node_dict, "restParentMat");
XnaGeometry.Vector4 cur_local_rest_start_pt = Utils.ReadVector4JSON(node_dict, "localRestStartPt");
XnaGeometry.Vector4 cur_local_rest_end_pt = Utils.ReadVector4JSON(node_dict, "localRestEndPt");
List<int> cur_children_ids = Utils.ReadIntArrayJSON(node_dict, "children");
MeshBone new_bone = new MeshBone(cur_name,
new XnaGeometry.Vector4(0,0,0,0),
new XnaGeometry.Vector4(0,0,0,0),
cur_parent_mat);
new_bone.local_rest_start_pt = cur_local_rest_start_pt;
new_bone.local_rest_end_pt = cur_local_rest_end_pt;
new_bone.calcRestData();
new_bone.setTagId(cur_id);
bone_data[cur_id] = new Tuple<MeshBone, List<int> >(new_bone, cur_children_ids);
foreach(int cur_child_id in cur_children_ids) {
child_set.Add(cur_child_id, cur_child_id);
}
}
// Find root
foreach(KeyValuePair<int, Tuple<MeshBone, List<int> >> cur_data in bone_data)
{
int cur_id = cur_data.Key;
if(child_set.ContainsKey(cur_id) == false) {
// not a child, so is root
root_bone = cur_data.Value.Item1;
break;
}
}
// construct hierarchy
foreach(KeyValuePair<int, Tuple<MeshBone, List<int> >> cur_data in bone_data)
{
MeshBone cur_bone = cur_data.Value.Item1;
List<int> children_ids = cur_data.Value.Item2;
foreach(int cur_child_id in children_ids)
{
MeshBone child_bone = bone_data[cur_child_id].Item1;
cur_bone.addChild(child_bone);
}
}
return root_bone;
}
public void CreateGameColliders()
{
if (creature_renderer == null)
{
return;
}
if (transform.childCount > 0)
{
Debug.Log("Please remove all children game colliders before running CreateGameColliders!");
return;
}
creature_renderer.InitData();
MeshBone root_bone = GetRootBone();
// Create a base rigid body that actually participates in simulation for the creature_renderer
var parent_obj = creature_renderer.gameObject;
Rigidbody2D parent_rbd = parent_obj.AddComponent <Rigidbody2D>();
parentRBD = parent_rbd;
parent_rbd.isKinematic = false;
BoxCollider2D parent_collider = parent_obj.AddComponent <BoxCollider2D>();
parent_collider.size = new UnityEngine.Vector2(simColliderWidth, simColliderHeight);
// Create rigid bodies for all the bones
List <MeshBone> all_children = root_bone.getAllChildren();
foreach (MeshBone cur_child in all_children)
{
// Create new GameObject
GameObject new_obj = new GameObject(cur_child.key);
// Add components
XnaGeometry.Vector4 spawn_center = (cur_child.getWorldStartPt() + cur_child.getWorldEndPt()) * 0.5f;
float colliderWidth = (float)(cur_child.getWorldRestEndPt() - cur_child.getWorldRestStartPt()).Length();
XnaGeometry.Vector4 spawn_dir = (cur_child.getWorldRestEndPt() - cur_child.getWorldRestStartPt());
spawn_dir.Normalize();
// Get the direction in the renderer's space
UnityEngine.Vector3 u_spawn_dir = new UnityEngine.Vector3((float)spawn_dir.X, (float)spawn_dir.Y, (float)0);
u_spawn_dir = TransformToCreatureDir(u_spawn_dir);
float startAngle = (float)Math.Atan2((double)u_spawn_dir.y, (double)u_spawn_dir.x) * Mathf.Rad2Deg;
UnityEngine.Vector3 local_pos = new UnityEngine.Vector3((float)spawn_center.X, (float)spawn_center.Y, (float)0);
Rigidbody2D new_rbd = new_obj.AddComponent <Rigidbody2D>();
new_rbd.isKinematic = true;
BoxCollider2D new_collider = new_obj.AddComponent <BoxCollider2D>();
new_collider.size = new UnityEngine.Vector2(colliderWidth, colliderHeight);
// set the position using the renderer's parent transform
new_obj.transform.position = TransformToCreaturePt(local_pos);
new_obj.transform.rotation = UnityEngine.Quaternion.AngleAxis(startAngle, new UnityEngine.Vector3(0, 0, 1));
// Make new object child of the parent
new_obj.transform.parent = gameObject.transform;
}
}
private void ObtainBones(Model model)
{
foreach (ModelBone bone in model.Bones)
{
MeshBone newBone = new MeshBone(bone.Name, bone.Transform, bone.Parent != null ? meshBones[bone.Parent.Index] : null);
meshBones.Add(newBone);
}
}
protected void ProcessMesh(Assimp.Mesh m)
{
var newMesh = new Mesh
{
Name = m.Name,
Material = _materials[m.MaterialIndex]
};
_meshes.Add(newMesh);
uint[] indices = m.GetUnsignedIndices();
var emotionIndices = new ushort[indices.Length];
for (var i = 0; i < indices.Length; i++)
{
emotionIndices[i] = (ushort)indices[i];
}
newMesh.Indices = emotionIndices;
var vertices = new VertexDataWithBones[m.VertexCount];
for (var i = 0; i < m.VertexCount; i++)
{
// todo: check if uvs exist, vert colors, normals
Vector3D vertex = m.Vertices[i];
Vector3D uv = m.TextureCoordinateChannels[0][i];
vertices[i] = new VertexDataWithBones
{
Vertex = new Vector3(vertex.X, vertex.Y, vertex.Z),
UV = new Vector2(uv.X, uv.Y),
BoneIds = new Vector4(0),
BoneWeights = new Vector4(1, 0, 0, 0)
};
}
newMesh.VerticesWithBones = vertices;
if (!m.HasBones)
{
return;
}
_boneToIndex ??= new Dictionary <string, int>();
var bones = new MeshBone[m.BoneCount];
newMesh.Bones = bones;
for (var i = 0; i < m.Bones.Count; i++)
{
Bone bone = m.Bones[i];
var emBone = new MeshBone
{
Name = bone.Name,
OffsetMatrix = AssMatrixToEmoMatrix(bone.OffsetMatrix)
};
bones[i] = emBone;
// Check if this bone has an id assigned.
if (!_boneToIndex.TryGetValue(bone.Name, out int boneIndex))
{
boneIndex = _boneToIndex.Count + 1;
_boneToIndex.Add(bone.Name, boneIndex);
}
emBone.BoneIndex = boneIndex;
for (var j = 0; j < bone.VertexWeightCount; j++)
{
VertexWeight boneDef = bone.VertexWeights[j];
ref VertexDataWithBones vertex = ref vertices[boneDef.VertexID];
// Todo: better way of doing this
if (vertex.BoneIds.X == 0)
{
vertex.BoneIds.X = boneIndex;
vertex.BoneWeights.X = boneDef.Weight;
}
else if (vertex.BoneIds.Y == 0)
{
vertex.BoneIds.Y = boneIndex;
vertex.BoneWeights.Y = boneDef.Weight;
}
else if (vertex.BoneIds.Z == 0)
{
vertex.BoneIds.Z = boneIndex;
vertex.BoneWeights.Z = boneDef.Weight;
}
else if (vertex.BoneIds.W == 0)
{
vertex.BoneIds.W = boneIndex;
vertex.BoneWeights.W = boneDef.Weight;
}
else
{
Engine.Log.Warning($"Bone {bone.Name} affects more than 4 vertices in mesh {m.Name}.", "Assimp", true);
}
}
}
