示例#1
0
        private void SaveBones(Node parentBone, STBone bone, STSkeleton skeleton)
        {
            Node boneNode = new Node(bone.Text);

            parentBone.Children.Add(boneNode);

            boneNode.Transform = AssimpHelper.GetBoneMatrix(bone);

            foreach (STBone child in bone.GetChildren())
            {
                SaveBones(boneNode, child, skeleton);
            }
        }
示例#2
0
        public List <STBone> getBoneTreeOrder()
        {
            List <STBone>  bone = new List <STBone>();
            Queue <STBone> q    = new Queue <STBone>();

            q.Enqueue(bones[0]);

            while (q.Count > 0)
            {
                STBone b = q.Dequeue();
                foreach (STBone bo in b.GetChildren())
                {
                    q.Enqueue(bo);
                }
                bone.Add(b);
            }
            return(bone);
        }
示例#3
0
        public void update(bool reset = false)
        {
            Updated = true;
            List <STBone> nodesToProcess = new List <STBone>();

            // Add all root nodes from the VBN
            foreach (STBone b in bones)
            {
                if (b.parentIndex == -1)
                {
                    nodesToProcess.Add(b);
                }
            }

            // some special processing for the root bones before we start
            foreach (STBone b in nodesToProcess)
            {
                b.Transform = Matrix4.CreateScale(b.sca) * Matrix4.CreateFromQuaternion(b.rot) * Matrix4.CreateTranslation(b.pos);

                // scale down the model in its entirety only when mid-animation (i.e. reset == false)
                if (!reset)
                {
                    b.Transform *= Matrix4.CreateScale(1);
                }
            }

            // Process as a tree from the root node's children and beyond. These
            // all use the same processing, unlike the root nodes.
            int numRootNodes = nodesToProcess.Count;

            for (int i = 0; i < numRootNodes; i++)
            {
                nodesToProcess.AddRange(nodesToProcess[0].GetChildren());
                nodesToProcess.RemoveAt(0);
            }
            while (nodesToProcess.Count > 0)
            {
                // DFS
                STBone Bone = nodesToProcess[0];
                nodesToProcess.RemoveAt(0);
                nodesToProcess.AddRange(Bone.GetChildren());

                // Process this node
                Bone.Transform = Matrix4.CreateScale(Bone.sca) * Matrix4.CreateFromQuaternion(Bone.rot) * Matrix4.CreateTranslation(Bone.pos);
                if (Bone.parentIndex != -1)
                {
                    if (Bone.UseSegmentScaleCompensate && Bone.Parent != null &&
                        Bone.Parent is STBone)
                    {
                        Bone.Transform *= Matrix4.CreateScale(
                            1f / ((STBone)Bone.Parent).GetScale().X,
                            1f / ((STBone)Bone.Parent).GetScale().Y,
                            1f / ((STBone)Bone.Parent).GetScale().Z);

                        Bone.Transform *= ((STBone)Bone.Parent).Transform;
                    }
                    else
                    {
                        Bone.Transform = Bone.Transform * ((STBone)Bone.Parent).Transform;
                    }
                }
            }
        }