protected void ReadNodeAnimations(XmlNode node_anm_array)
        {
            if (node_anm_array == null)
            {
                return;
            }
            int size = int.Parse(node_anm_array.Attributes["size"].Value);

            if (size < 1)
            {
                return;
            }

            XmlNodeList node_anms = node_anm_array.SelectNodes("node_anm");

            foreach (XmlNode node_anm in node_anms)
            {
                int    index  = int.Parse(node_anm.Attributes["index"].Value);
                string boneID = m_Model.m_BoneTree.GetBoneByIndex(index).m_ID;

                XmlNode scale_x     = node_anm.SelectSingleNode("scale_x");
                XmlNode scale_y     = node_anm.SelectSingleNode("scale_y");
                XmlNode scale_z     = node_anm.SelectSingleNode("scale_z");
                XmlNode rotate_x    = node_anm.SelectSingleNode("rotate_x");
                XmlNode rotate_y    = node_anm.SelectSingleNode("rotate_y");
                XmlNode rotate_z    = node_anm.SelectSingleNode("rotate_z");
                XmlNode translate_x = node_anm.SelectSingleNode("translate_x");
                XmlNode translate_y = node_anm.SelectSingleNode("translate_y");
                XmlNode translate_z = node_anm.SelectSingleNode("translate_z");

                Dictionary <ModelBase.AnimationComponentType, ModelBase.AnimationComponentDataDef> animationComponentDataDefs =
                    new Dictionary <ModelBase.AnimationComponentType, ModelBase.AnimationComponentDataDef>();

                animationComponentDataDefs.Add(ModelBase.AnimationComponentType.ScaleX,
                                               ReadAnimationComponent(scale_x, ModelBase.AnimationComponentType.ScaleX, index));
                animationComponentDataDefs.Add(ModelBase.AnimationComponentType.ScaleY,
                                               ReadAnimationComponent(scale_y, ModelBase.AnimationComponentType.ScaleY, index));
                animationComponentDataDefs.Add(ModelBase.AnimationComponentType.ScaleZ,
                                               ReadAnimationComponent(scale_z, ModelBase.AnimationComponentType.ScaleZ, index));
                animationComponentDataDefs.Add(ModelBase.AnimationComponentType.RotateX,
                                               ReadAnimationComponent(rotate_x, ModelBase.AnimationComponentType.RotateX, index));
                animationComponentDataDefs.Add(ModelBase.AnimationComponentType.RotateY,
                                               ReadAnimationComponent(rotate_y, ModelBase.AnimationComponentType.RotateY, index));
                animationComponentDataDefs.Add(ModelBase.AnimationComponentType.RotateZ,
                                               ReadAnimationComponent(rotate_z, ModelBase.AnimationComponentType.RotateZ, index));
                animationComponentDataDefs.Add(ModelBase.AnimationComponentType.TranslateX,
                                               ReadAnimationComponent(translate_x, ModelBase.AnimationComponentType.TranslateX, index));
                animationComponentDataDefs.Add(ModelBase.AnimationComponentType.TranslateY,
                                               ReadAnimationComponent(translate_y, ModelBase.AnimationComponentType.TranslateY, index));
                animationComponentDataDefs.Add(ModelBase.AnimationComponentType.TranslateZ,
                                               ReadAnimationComponent(translate_z, ModelBase.AnimationComponentType.TranslateZ, index));

                ModelBase.AnimationDef animationDef = new ModelBase.AnimationDef(boneID + "-animation", boneID, this.node_anm_info.frame_size,
                                                                                 animationComponentDataDefs);
                m_Model.m_Animations.Add(animationDef.m_ID, animationDef);
            }
        }
        protected void ReadNodeAnimations(XmlNode node_anm_array)
        {
            if (node_anm_array == null) return;
            int size = int.Parse(node_anm_array.Attributes["size"].Value);
            if (size < 1) return;

            XmlNodeList node_anms = node_anm_array.SelectNodes("node_anm");

            foreach (XmlNode node_anm in node_anms)
            {
                int index = int.Parse(node_anm.Attributes["index"].Value);
                string boneID = m_Model.m_BoneTree.GetBoneByIndex(index).m_ID;

                XmlNode scale_x = node_anm.SelectSingleNode("scale_x");
                XmlNode scale_y = node_anm.SelectSingleNode("scale_y");
                XmlNode scale_z = node_anm.SelectSingleNode("scale_z");
                XmlNode rotate_x = node_anm.SelectSingleNode("rotate_x");
                XmlNode rotate_y = node_anm.SelectSingleNode("rotate_y");
                XmlNode rotate_z = node_anm.SelectSingleNode("rotate_z");
                XmlNode translate_x = node_anm.SelectSingleNode("translate_x");
                XmlNode translate_y = node_anm.SelectSingleNode("translate_y");
                XmlNode translate_z = node_anm.SelectSingleNode("translate_z");

                Dictionary<ModelBase.AnimationComponentType, ModelBase.AnimationComponentDataDef> animationComponentDataDefs =
                    new Dictionary<ModelBase.AnimationComponentType, ModelBase.AnimationComponentDataDef>();

                animationComponentDataDefs.Add(ModelBase.AnimationComponentType.ScaleX,
                    ReadAnimationComponent(scale_x, ModelBase.AnimationComponentType.ScaleX, index));
                animationComponentDataDefs.Add(ModelBase.AnimationComponentType.ScaleY,
                    ReadAnimationComponent(scale_y, ModelBase.AnimationComponentType.ScaleY, index));
                animationComponentDataDefs.Add(ModelBase.AnimationComponentType.ScaleZ,
                    ReadAnimationComponent(scale_z, ModelBase.AnimationComponentType.ScaleZ, index));
                animationComponentDataDefs.Add(ModelBase.AnimationComponentType.RotateX,
                    ReadAnimationComponent(rotate_x, ModelBase.AnimationComponentType.RotateX, index));
                animationComponentDataDefs.Add(ModelBase.AnimationComponentType.RotateY,
                    ReadAnimationComponent(rotate_y, ModelBase.AnimationComponentType.RotateY, index));
                animationComponentDataDefs.Add(ModelBase.AnimationComponentType.RotateZ,
                    ReadAnimationComponent(rotate_z, ModelBase.AnimationComponentType.RotateZ, index));
                animationComponentDataDefs.Add(ModelBase.AnimationComponentType.TranslateX,
                    ReadAnimationComponent(translate_x, ModelBase.AnimationComponentType.TranslateX, index));
                animationComponentDataDefs.Add(ModelBase.AnimationComponentType.TranslateY,
                    ReadAnimationComponent(translate_y, ModelBase.AnimationComponentType.TranslateY, index));
                animationComponentDataDefs.Add(ModelBase.AnimationComponentType.TranslateZ,
                    ReadAnimationComponent(translate_z, ModelBase.AnimationComponentType.TranslateZ, index));

                ModelBase.AnimationDef animationDef = new ModelBase.AnimationDef(boneID + "-animation", boneID, this.node_anm_info.frame_size,
                    animationComponentDataDefs);
                m_Model.m_Animations.Add(animationDef.m_ID, animationDef);
            }
        }
Ejemplo n.º 3
0
        public override ModelBase LoadModel(OpenTK.Vector3 scale)
        {
            List<ModelBase.BoneDef> flatBoneList = m_Model.m_BoneTree.GetAsList();
            for (int i = 0; i < m_BCA.m_AnimationData.Length; i++)
            {
                string boneID = flatBoneList[i].m_ID;

                BCA.SRTContainer[] boneTransformations = m_BCA.GetAllLocalSRTValuesForBone(i);

                Dictionary<ModelBase.AnimationComponentType, ModelBase.AnimationComponentDataDef> animationComponentDataDefs =
                    new Dictionary<ModelBase.AnimationComponentType, ModelBase.AnimationComponentDataDef>();

                float[] valuesSx = new float[boneTransformations.Length];
                float[] valuesSy = new float[boneTransformations.Length];
                float[] valuesSz = new float[boneTransformations.Length];
                float[] valuesRx = new float[boneTransformations.Length];
                float[] valuesRy = new float[boneTransformations.Length];
                float[] valuesRz = new float[boneTransformations.Length];
                float[] valuesTx = new float[boneTransformations.Length];
                float[] valuesTy = new float[boneTransformations.Length];
                float[] valuesTz = new float[boneTransformations.Length];
                for (int j = 0; j < boneTransformations.Length; j++)
                {
                    valuesSx[j] = boneTransformations[j].m_Scale.X;
                    valuesSy[j] = boneTransformations[j].m_Scale.Y;
                    valuesSz[j] = boneTransformations[j].m_Scale.Z;
                    valuesRx[j] = boneTransformations[j].m_Rotation.X;
                    valuesRy[j] = boneTransformations[j].m_Rotation.Y;
                    valuesRz[j] = boneTransformations[j].m_Rotation.Z;
                    valuesTx[j] = boneTransformations[j].m_Translation.X;
                    valuesTy[j] = boneTransformations[j].m_Translation.Y;
                    valuesTz[j] = boneTransformations[j].m_Translation.Z;
                }

                animationComponentDataDefs.Add(ModelBase.AnimationComponentType.ScaleX,
                    new ModelBase.AnimationComponentDataDef(valuesSx, m_BCA.m_NumFrames, false, 1, false, ModelBase.AnimationComponentType.ScaleX));
                animationComponentDataDefs.Add(ModelBase.AnimationComponentType.ScaleY,
                    new ModelBase.AnimationComponentDataDef(valuesSy, m_BCA.m_NumFrames, false, 1, false, ModelBase.AnimationComponentType.ScaleY));
                animationComponentDataDefs.Add(ModelBase.AnimationComponentType.ScaleZ,
                    new ModelBase.AnimationComponentDataDef(valuesSz, m_BCA.m_NumFrames, false, 1, false, ModelBase.AnimationComponentType.ScaleZ));
                animationComponentDataDefs.Add(ModelBase.AnimationComponentType.RotateX,
                    new ModelBase.AnimationComponentDataDef(valuesRx, m_BCA.m_NumFrames, false, 1, false, ModelBase.AnimationComponentType.RotateX));
                animationComponentDataDefs.Add(ModelBase.AnimationComponentType.RotateY,
                    new ModelBase.AnimationComponentDataDef(valuesRy, m_BCA.m_NumFrames, false, 1, false, ModelBase.AnimationComponentType.RotateY));
                animationComponentDataDefs.Add(ModelBase.AnimationComponentType.RotateZ,
                    new ModelBase.AnimationComponentDataDef(valuesRz, m_BCA.m_NumFrames, false, 1, false, ModelBase.AnimationComponentType.RotateZ));
                animationComponentDataDefs.Add(ModelBase.AnimationComponentType.TranslateX,
                    new ModelBase.AnimationComponentDataDef(valuesTx, m_BCA.m_NumFrames, false, 1, false, ModelBase.AnimationComponentType.TranslateX));
                animationComponentDataDefs.Add(ModelBase.AnimationComponentType.TranslateY,
                    new ModelBase.AnimationComponentDataDef(valuesTy, m_BCA.m_NumFrames, false, 1, false, ModelBase.AnimationComponentType.TranslateY));
                animationComponentDataDefs.Add(ModelBase.AnimationComponentType.TranslateZ,
                    new ModelBase.AnimationComponentDataDef(valuesTz, m_BCA.m_NumFrames, false, 1, false, ModelBase.AnimationComponentType.TranslateZ));

                ModelBase.AnimationDef animation = new ModelBase.AnimationDef(boneID + "-animation", boneID, m_BCA.m_NumFrames,
                    animationComponentDataDefs);
                m_Model.m_Animations.Add(animation.m_ID, animation);
            }

            return m_Model;
        }
Ejemplo n.º 4
0
        public override void WriteModel(bool save = true)
        {
            ModelBase.BoneDefRoot boneTree = m_Model.m_BoneTree;
            Dictionary <string, ModelBase.AnimationDef> boneAnimationsMap = new Dictionary <string, ModelBase.AnimationDef>();

            foreach (ModelBase.AnimationDef anim in m_Model.m_Animations.Values)
            {
                boneAnimationsMap.Add(anim.m_BoneID, anim);
            }

            if (boneAnimationsMap.Count == 0)
            {
                return;
            }

            NitroFile bca = m_ModelFile;

            bca.Clear();

            uint dataoffset    = 0x00;
            uint headersize    = 0x18;
            int  numAnimations = boneTree.Count;
            int  numFrames     = boneAnimationsMap.ElementAt(0).Value.m_NumFrames;

            int numScale = 0;

            foreach (ModelBase.BoneDef boneDef in m_Model.m_BoneTree)
            {
                if (boneAnimationsMap.ContainsKey(boneDef.m_ID))
                {
                    numScale += boneAnimationsMap[boneDef.m_ID].GetScaleValuesCount();
                }
                else
                {
                    numScale += 3;// Original X, Y, Z
                }
            }
            int numRotation = 0;

            foreach (ModelBase.BoneDef boneDef in m_Model.m_BoneTree)
            {
                if (boneAnimationsMap.ContainsKey(boneDef.m_ID))
                {
                    numRotation += boneAnimationsMap[boneDef.m_ID].GetRotateValuesCount();
                }
                else
                {
                    numRotation += 3;// Original X, Y, Z
                }
            }
            int numTranslation = 0;

            foreach (ModelBase.BoneDef boneDef in m_Model.m_BoneTree)
            {
                if (boneAnimationsMap.ContainsKey(boneDef.m_ID))
                {
                    numTranslation += boneAnimationsMap[boneDef.m_ID].GetTranslateValuesCount();
                }
                else
                {
                    numTranslation += 3;// Original X, Y, Z
                }
            }
            uint scaleValuesOffset       = headersize;
            uint rotationValuesOffset    = scaleValuesOffset + (uint)(numScale * 4);
            uint translationValuesOffset = (uint)(((rotationValuesOffset + (uint)(numRotation * 2)) + 3) & ~3);
            uint animationDataOffset     = translationValuesOffset + (uint)(numTranslation * 4);

            bca.Write16(0x00, (ushort)numAnimations);   // Number of bones to be handled (should match the number of bones in the BMD)
            bca.Write16(0x02, (ushort)numFrames);       // Number of animation frames
            bca.Write32(0x04, 1);                       // Whether the animation loops, 0 - false, 1 - true
            bca.Write32(0x08, scaleValuesOffset);       // Offset to scale values section
            bca.Write32(0x0C, rotationValuesOffset);    // Offset to rotation values section
            bca.Write32(0x10, translationValuesOffset); // Offset to translation values section
            bca.Write32(0x14, animationDataOffset);     // Offset to animation section

            dataoffset = scaleValuesOffset;

            int boneScaleValuesOffset = 0;
            Dictionary <string, int> boneScaleValuesOffsets = new Dictionary <string, int>();
            int boneRotateValuesOffset = 0;
            Dictionary <string, int> boneRotateValuesOffsets = new Dictionary <string, int>();
            int boneTranslateValuesOffset = 0;
            Dictionary <string, int> boneTranslateValuesOffsets = new Dictionary <string, int>();

            foreach (ModelBase.BoneDef bone in boneTree)
            {
                boneScaleValuesOffsets.Add(bone.m_ID, boneScaleValuesOffset);

                if (boneAnimationsMap.ContainsKey(bone.m_ID))
                {
                    ModelBase.AnimationDef anim = boneAnimationsMap[bone.m_ID];

                    bca.WriteBlock(dataoffset,
                                   anim.m_AnimationComponents[ModelBase.AnimationComponentType.ScaleX].GetFixedPointValues());
                    dataoffset += (uint)(anim.m_AnimationComponents[ModelBase.AnimationComponentType.ScaleX].GetNumValues() * 4);

                    bca.WriteBlock(dataoffset,
                                   anim.m_AnimationComponents[ModelBase.AnimationComponentType.ScaleY].GetFixedPointValues());
                    dataoffset += (uint)(anim.m_AnimationComponents[ModelBase.AnimationComponentType.ScaleY].GetNumValues() * 4);

                    bca.WriteBlock(dataoffset,
                                   anim.m_AnimationComponents[ModelBase.AnimationComponentType.ScaleZ].GetFixedPointValues());
                    dataoffset += (uint)(anim.m_AnimationComponents[ModelBase.AnimationComponentType.ScaleZ].GetNumValues() * 4);

                    boneScaleValuesOffset += anim.GetScaleValuesCount();
                }
                else
                {
                    // Write bone's scale values
                    bca.Write32(dataoffset, bone.m_20_12Scale[0]);
                    dataoffset += 4;
                    bca.Write32(dataoffset, bone.m_20_12Scale[1]);
                    dataoffset += 4;
                    bca.Write32(dataoffset, bone.m_20_12Scale[2]);
                    dataoffset += 4;

                    boneScaleValuesOffset += 3;
                }
            }

            dataoffset = rotationValuesOffset;

            // Rotation is in Radians
            foreach (ModelBase.BoneDef bone in boneTree)
            {
                boneRotateValuesOffsets.Add(bone.m_ID, boneRotateValuesOffset);

                if (boneAnimationsMap.ContainsKey(bone.m_ID))
                {
                    ModelBase.AnimationDef anim = boneAnimationsMap[bone.m_ID];

                    bca.WriteBlock(dataoffset,
                                   anim.m_AnimationComponents[ModelBase.AnimationComponentType.RotateX].GetFixedPointValues());
                    dataoffset += (uint)(anim.m_AnimationComponents[ModelBase.AnimationComponentType.RotateX].GetNumValues() * 2);

                    bca.WriteBlock(dataoffset,
                                   anim.m_AnimationComponents[ModelBase.AnimationComponentType.RotateY].GetFixedPointValues());
                    dataoffset += (uint)(anim.m_AnimationComponents[ModelBase.AnimationComponentType.RotateY].GetNumValues() * 2);

                    bca.WriteBlock(dataoffset,
                                   anim.m_AnimationComponents[ModelBase.AnimationComponentType.RotateZ].GetFixedPointValues());
                    dataoffset += (uint)(anim.m_AnimationComponents[ModelBase.AnimationComponentType.RotateZ].GetNumValues() * 2);

                    boneRotateValuesOffset += anim.GetRotateValuesCount();
                }
                else
                {
                    // Write bone's rotation values
                    bca.Write16(dataoffset, bone.m_4_12Rotation[0]);
                    dataoffset += 2;
                    bca.Write16(dataoffset, bone.m_4_12Rotation[1]);
                    dataoffset += 2;
                    bca.Write16(dataoffset, bone.m_4_12Rotation[2]);
                    dataoffset += 2;

                    boneRotateValuesOffset += 3;
                }
            }

            dataoffset = translationValuesOffset;

            foreach (ModelBase.BoneDef bone in boneTree)
            {
                boneTranslateValuesOffsets.Add(bone.m_ID, boneTranslateValuesOffset);

                if (boneAnimationsMap.ContainsKey(bone.m_ID))
                {
                    ModelBase.AnimationDef anim = boneAnimationsMap[bone.m_ID];

                    bca.WriteBlock(dataoffset,
                                   anim.m_AnimationComponents[ModelBase.AnimationComponentType.TranslateX].GetFixedPointValues());
                    dataoffset += (uint)(anim.m_AnimationComponents[ModelBase.AnimationComponentType.TranslateX].GetNumValues() * 4);

                    bca.WriteBlock(dataoffset,
                                   anim.m_AnimationComponents[ModelBase.AnimationComponentType.TranslateY].GetFixedPointValues());
                    dataoffset += (uint)(anim.m_AnimationComponents[ModelBase.AnimationComponentType.TranslateY].GetNumValues() * 4);

                    bca.WriteBlock(dataoffset,
                                   anim.m_AnimationComponents[ModelBase.AnimationComponentType.TranslateZ].GetFixedPointValues());
                    dataoffset += (uint)(anim.m_AnimationComponents[ModelBase.AnimationComponentType.TranslateZ].GetNumValues() * 4);

                    boneTranslateValuesOffset += anim.GetTranslateValuesCount();
                }
                else
                {
                    // Write bone's translation values
                    bca.Write32(dataoffset, bone.m_20_12Translation[0]);
                    dataoffset += 4;
                    bca.Write32(dataoffset, bone.m_20_12Translation[1]);
                    dataoffset += 4;
                    bca.Write32(dataoffset, bone.m_20_12Translation[2]);
                    dataoffset += 4;

                    boneTranslateValuesOffset += 3;
                }
            }

            dataoffset = animationDataOffset;

            // For each bone, write the animation descriptor for each transformation component
            foreach (ModelBase.BoneDef bone in boneTree)
            {
                if (boneAnimationsMap.ContainsKey(bone.m_ID))
                {
                    ModelBase.AnimationDef anim = boneAnimationsMap[bone.m_ID];

                    // Scale X
                    WriteBCAAnimationDescriptor(bca, dataoffset,
                                                (byte)(anim.m_AnimationComponents[ModelBase.AnimationComponentType.ScaleX].GetFrameStep() >> 1),
                                                anim.m_AnimationComponents[ModelBase.AnimationComponentType.ScaleX].GetIsConstant(),
                                                boneScaleValuesOffsets[bone.m_ID]);
                    dataoffset += 4;

                    // Scale Y
                    WriteBCAAnimationDescriptor(bca, dataoffset,
                                                (byte)(anim.m_AnimationComponents[ModelBase.AnimationComponentType.ScaleY].GetFrameStep() >> 1),
                                                anim.m_AnimationComponents[ModelBase.AnimationComponentType.ScaleY].GetIsConstant(),
                                                (boneScaleValuesOffsets[bone.m_ID] +
                                                 anim.m_AnimationComponents[ModelBase.AnimationComponentType.ScaleX].GetNumValues()));
                    dataoffset += 4;

                    // Scale Z
                    WriteBCAAnimationDescriptor(bca, dataoffset,
                                                (byte)(anim.m_AnimationComponents[ModelBase.AnimationComponentType.ScaleZ].GetFrameStep() >> 1),
                                                anim.m_AnimationComponents[ModelBase.AnimationComponentType.ScaleZ].GetIsConstant(),
                                                (boneScaleValuesOffsets[bone.m_ID] +
                                                 anim.m_AnimationComponents[ModelBase.AnimationComponentType.ScaleX].GetNumValues() +
                                                 anim.m_AnimationComponents[ModelBase.AnimationComponentType.ScaleY].GetNumValues()));
                    dataoffset += 4;

                    // Rotate X
                    WriteBCAAnimationDescriptor(bca, dataoffset,
                                                (byte)(anim.m_AnimationComponents[ModelBase.AnimationComponentType.RotateX].GetFrameStep() >> 1),
                                                anim.m_AnimationComponents[ModelBase.AnimationComponentType.RotateX].GetIsConstant(),
                                                boneRotateValuesOffsets[bone.m_ID]);
                    dataoffset += 4;

                    // Rotate Y
                    WriteBCAAnimationDescriptor(bca, dataoffset,
                                                (byte)(anim.m_AnimationComponents[ModelBase.AnimationComponentType.RotateY].GetFrameStep() >> 1),
                                                anim.m_AnimationComponents[ModelBase.AnimationComponentType.RotateY].GetIsConstant(),
                                                (boneRotateValuesOffsets[bone.m_ID] +
                                                 anim.m_AnimationComponents[ModelBase.AnimationComponentType.RotateX].GetNumValues()));
                    dataoffset += 4;

                    // Rotate Z
                    WriteBCAAnimationDescriptor(bca, dataoffset,
                                                (byte)(anim.m_AnimationComponents[ModelBase.AnimationComponentType.RotateZ].GetFrameStep() >> 1),
                                                anim.m_AnimationComponents[ModelBase.AnimationComponentType.RotateZ].GetIsConstant(),
                                                (boneRotateValuesOffsets[bone.m_ID] +
                                                 anim.m_AnimationComponents[ModelBase.AnimationComponentType.RotateX].GetNumValues() +
                                                 anim.m_AnimationComponents[ModelBase.AnimationComponentType.RotateY].GetNumValues()));
                    dataoffset += 4;

                    // Translate X
                    WriteBCAAnimationDescriptor(bca, dataoffset,
                                                (byte)(anim.m_AnimationComponents[ModelBase.AnimationComponentType.TranslateX].GetFrameStep() >> 1),
                                                anim.m_AnimationComponents[ModelBase.AnimationComponentType.TranslateX].GetIsConstant(),
                                                boneTranslateValuesOffsets[bone.m_ID]);
                    dataoffset += 4;

                    // Translate Y
                    WriteBCAAnimationDescriptor(bca, dataoffset,
                                                (byte)(anim.m_AnimationComponents[ModelBase.AnimationComponentType.TranslateY].GetFrameStep() >> 1),
                                                anim.m_AnimationComponents[ModelBase.AnimationComponentType.TranslateY].GetIsConstant(),
                                                (boneTranslateValuesOffsets[bone.m_ID] +
                                                 anim.m_AnimationComponents[ModelBase.AnimationComponentType.TranslateX].GetNumValues()));
                    dataoffset += 4;

                    // Translate Z
                    WriteBCAAnimationDescriptor(bca, dataoffset,
                                                (byte)(anim.m_AnimationComponents[ModelBase.AnimationComponentType.TranslateZ].GetFrameStep() >> 1),
                                                anim.m_AnimationComponents[ModelBase.AnimationComponentType.TranslateZ].GetIsConstant(),
                                                (boneTranslateValuesOffsets[bone.m_ID] +
                                                 anim.m_AnimationComponents[ModelBase.AnimationComponentType.TranslateX].GetNumValues() +
                                                 anim.m_AnimationComponents[ModelBase.AnimationComponentType.TranslateY].GetNumValues()));
                    dataoffset += 4;
                }
                else
                {
                    // Set to use constant values (the bone's transformation as there's no animation)

                    // Scale X
                    WriteBCAAnimationDescriptor(bca, dataoffset, 0, true, (boneScaleValuesOffsets[bone.m_ID] + 0));
                    dataoffset += 4;

                    // Scale Y
                    WriteBCAAnimationDescriptor(bca, dataoffset, 0, true, (boneScaleValuesOffsets[bone.m_ID] + 1));
                    dataoffset += 4;

                    // Scale Z
                    WriteBCAAnimationDescriptor(bca, dataoffset, 0, true, (boneScaleValuesOffsets[bone.m_ID] + 2));
                    dataoffset += 4;

                    // Rotation X
                    WriteBCAAnimationDescriptor(bca, dataoffset, 0, true, (boneRotateValuesOffsets[bone.m_ID] + 0));
                    dataoffset += 4;

                    // Rotation Y
                    WriteBCAAnimationDescriptor(bca, dataoffset, 0, true, (boneRotateValuesOffsets[bone.m_ID] + 1));
                    dataoffset += 4;

                    // Rotation Z
                    WriteBCAAnimationDescriptor(bca, dataoffset, 0, true, (boneRotateValuesOffsets[bone.m_ID] + 2));
                    dataoffset += 4;

                    // Translation X
                    WriteBCAAnimationDescriptor(bca, dataoffset, 0, true, (boneTranslateValuesOffsets[bone.m_ID] + 0));
                    dataoffset += 4;

                    // Translation Y
                    WriteBCAAnimationDescriptor(bca, dataoffset, 0, true, (boneTranslateValuesOffsets[bone.m_ID] + 1));
                    dataoffset += 4;

                    // Translation Z
                    WriteBCAAnimationDescriptor(bca, dataoffset, 0, true, (boneTranslateValuesOffsets[bone.m_ID] + 2));
                    dataoffset += 4;
                }
            }

            if (m_BCAImportationOptions.m_Optimise)
            {
                Optimise(bca);
            }
            if (save)
            {
                bca.SaveChanges();
            }
        }
Ejemplo n.º 5
0
        public override ModelBase LoadModel(float scale)
        {
            List <ModelBase.BoneDef> flatBoneList = m_Model.m_BoneTree.GetAsList();

            for (int i = 0; i < m_BCA.m_AnimationData.Length; i++)
            {
                string boneID = flatBoneList[i].m_ID;

                BCA.SRTContainer[] boneTransformations = m_BCA.GetAllLocalSRTValuesForBone(i);

                Dictionary <ModelBase.AnimationComponentType, ModelBase.AnimationComponentDataDef> animationComponentDataDefs =
                    new Dictionary <ModelBase.AnimationComponentType, ModelBase.AnimationComponentDataDef>();

                float[] valuesSx = new float[boneTransformations.Length];
                float[] valuesSy = new float[boneTransformations.Length];
                float[] valuesSz = new float[boneTransformations.Length];
                float[] valuesRx = new float[boneTransformations.Length];
                float[] valuesRy = new float[boneTransformations.Length];
                float[] valuesRz = new float[boneTransformations.Length];
                float[] valuesTx = new float[boneTransformations.Length];
                float[] valuesTy = new float[boneTransformations.Length];
                float[] valuesTz = new float[boneTransformations.Length];
                for (int j = 0; j < boneTransformations.Length; j++)
                {
                    valuesSx[j] = boneTransformations[j].m_Scale.X;
                    valuesSy[j] = boneTransformations[j].m_Scale.Y;
                    valuesSz[j] = boneTransformations[j].m_Scale.Z;
                    valuesRx[j] = boneTransformations[j].m_Rotation.X;
                    valuesRy[j] = boneTransformations[j].m_Rotation.Y;
                    valuesRz[j] = boneTransformations[j].m_Rotation.Z;
                    valuesTx[j] = boneTransformations[j].m_Translation.X;
                    valuesTy[j] = boneTransformations[j].m_Translation.Y;
                    valuesTz[j] = boneTransformations[j].m_Translation.Z;
                }

                animationComponentDataDefs.Add(ModelBase.AnimationComponentType.ScaleX,
                                               new ModelBase.AnimationComponentDataDef(valuesSx, m_BCA.m_NumFrames, false, 1, false, ModelBase.AnimationComponentType.ScaleX));
                animationComponentDataDefs.Add(ModelBase.AnimationComponentType.ScaleY,
                                               new ModelBase.AnimationComponentDataDef(valuesSy, m_BCA.m_NumFrames, false, 1, false, ModelBase.AnimationComponentType.ScaleY));
                animationComponentDataDefs.Add(ModelBase.AnimationComponentType.ScaleZ,
                                               new ModelBase.AnimationComponentDataDef(valuesSz, m_BCA.m_NumFrames, false, 1, false, ModelBase.AnimationComponentType.ScaleZ));
                animationComponentDataDefs.Add(ModelBase.AnimationComponentType.RotateX,
                                               new ModelBase.AnimationComponentDataDef(valuesRx, m_BCA.m_NumFrames, false, 1, false, ModelBase.AnimationComponentType.RotateX));
                animationComponentDataDefs.Add(ModelBase.AnimationComponentType.RotateY,
                                               new ModelBase.AnimationComponentDataDef(valuesRy, m_BCA.m_NumFrames, false, 1, false, ModelBase.AnimationComponentType.RotateY));
                animationComponentDataDefs.Add(ModelBase.AnimationComponentType.RotateZ,
                                               new ModelBase.AnimationComponentDataDef(valuesRz, m_BCA.m_NumFrames, false, 1, false, ModelBase.AnimationComponentType.RotateZ));
                animationComponentDataDefs.Add(ModelBase.AnimationComponentType.TranslateX,
                                               new ModelBase.AnimationComponentDataDef(valuesTx, m_BCA.m_NumFrames, false, 1, false, ModelBase.AnimationComponentType.TranslateX));
                animationComponentDataDefs.Add(ModelBase.AnimationComponentType.TranslateY,
                                               new ModelBase.AnimationComponentDataDef(valuesTy, m_BCA.m_NumFrames, false, 1, false, ModelBase.AnimationComponentType.TranslateY));
                animationComponentDataDefs.Add(ModelBase.AnimationComponentType.TranslateZ,
                                               new ModelBase.AnimationComponentDataDef(valuesTz, m_BCA.m_NumFrames, false, 1, false, ModelBase.AnimationComponentType.TranslateZ));

                ModelBase.AnimationDef animation = new ModelBase.AnimationDef(boneID + "-animation", boneID, m_BCA.m_NumFrames,
                                                                              animationComponentDataDefs);
                m_Model.m_Animations.Add(animation.m_ID, animation);
            }

            return(m_Model);
        }