public int ContinuousRotationAnimTest(RotationCurveType rotCurveType, float [] keyTimesInSeconds, Vector3 [] keyEulerValues)
        {
            System.Type componentType = typeof(Transform);

            string[] propertyNames       = null;
            string   testName            = componentType.ToString() + "_ContinuousRotations";
            bool     compareOriginalKeys = false;

            switch (rotCurveType)
            {
            case RotationCurveType.kEuler:
                testName     += "_Euler";
                propertyNames = AnimationTestDataClass.m_rotationEulerNames.ToArray();
                break;

            case RotationCurveType.kQuaternion:
                compareOriginalKeys = true;
                testName           += "_Quaternion";
                propertyNames       = AnimationTestDataClass.m_rotationQuaternionNames.ToArray();
                break;
            }

            KeyData keyData = new TransformKeyData {
                importSettings      = new { resampleCurves = false, animationType = ModelImporterAnimationType.Legacy, animationCompression = ModelImporterAnimationCompression.Off, importConstraints = true },
                compareOriginalKeys = compareOriginalKeys, RotationType = rotCurveType, propertyNames = propertyNames, componentType = componentType, keyTimes = keyTimesInSeconds, keyEulerValues = keyEulerValues
            };

            var tester = new AnimTester {
                keyData = keyData, testName = testName, path = GetRandomFbxFilePath()
            };

            return(tester.DoIt());
        }
Пример #2
0
        private void ApplyAnimation_Click_Bone()
        {
            var xml = XDocument.Parse(txt.Text);

            var es = xml.Root.Elements().ToList();

            BoneAnimation = new List <BoneAnimation>();

            for (int i = 0; i < es.Count(); i++)
            {
                var anim = new BoneAnimation();

                var ats = es[i].Attributes().ToList();
                var transformkeydata = new TransformKeyData();

                anim.Name = ats[1].Value;
                anim.Copy = ats[2].Value == " " ? null : ats[2].Value;
                transformkeydata.Duration = TimeSpan.FromMilliseconds(double.Parse(ats[3].Value));

                var inits = es[i].Elements().ToList()[0].Elements().ToList();
                if (inits.Count != 0)
                {
                    transformkeydata.TransformKey = new TransformKey
                    {
                        Translation = new Vector3(
                            float.Parse(inits[0].Attribute("X").Value),
                            float.Parse(inits[0].Attribute("Y").Value),
                            float.Parse(inits[0].Attribute("Z").Value)
                            ),

                        Rotation = new Vector3(
                            float.Parse(inits[1].Attribute("X").Value),
                            float.Parse(inits[1].Attribute("Y").Value),
                            float.Parse(inits[1].Attribute("Z").Value)
                            ).ToQuaternion(),

                        Scale = new Vector3(
                            float.Parse(inits[2].Attribute("X").Value),
                            float.Parse(inits[2].Attribute("Y").Value),
                            float.Parse(inits[2].Attribute("Z").Value)
                            )
                    };

                    var transformkey = es[i].Elements().ToList()[1].Elements();

                    var translationkey = transformkey.Where(_ => _.Name == "translation_key").ToList();
                    for (int j = 0; j < translationkey.Count(); j++)
                    {
                        transformkeydata.TransformKey.TKey.Add(new TKey
                        {
                            Duration    = TimeSpan.FromMilliseconds(double.Parse(translationkey[j].Attribute("tick_time").Value)),
                            Translation = new Vector3(
                                float.Parse(translationkey[j].Attribute("X").Value),
                                float.Parse(translationkey[j].Attribute("Y").Value),
                                float.Parse(translationkey[j].Attribute("Z").Value)
                                )
                        });
                    }

                    var rotationkey = transformkey.Where(_ => _.Name == "rotation_key").ToList();
                    for (int k = 0; k < rotationkey.Count(); k++)
                    {
                        transformkeydata.TransformKey.RKey.Add(new RKey
                        {
                            Duration = TimeSpan.FromMilliseconds(double.Parse(rotationkey[k].Attribute("tick_time").Value)),
                            Rotation = new Vector3(
                                float.Parse(rotationkey[k].Attribute("X").Value),
                                float.Parse(rotationkey[k].Attribute("Y").Value),
                                float.Parse(rotationkey[k].Attribute("Z").Value)
                                ).ToQuaternion()
                        });
                    }

                    var scalekey = transformkey.Where(_ => _.Name == "scale_key").ToList();
                    for (int l = 0; l < scalekey.Count(); l++)
                    {
                        transformkeydata.TransformKey.SKey.Add(new SKey
                        {
                            Duration = TimeSpan.FromMilliseconds(double.Parse(scalekey[l].Attribute("tick_time").Value)),
                            Scale    = new Vector3(
                                float.Parse(scalekey[l].Attribute("X").Value),
                                float.Parse(scalekey[l].Attribute("Y").Value),
                                float.Parse(scalekey[l].Attribute("Z").Value)
                                )
                        });
                    }
                }

                var floatkey = es[i].Elements().ToList()[2].Elements().ToList();
                for (int m = 0; m < floatkey.Count(); m++)
                {
                    transformkeydata.FloatKeys.Add(new FloatKey
                    {
                        Duration = TimeSpan.FromMilliseconds(double.Parse(floatkey[m].Attribute("tick_time").Value)),
                        Alpha    = float.Parse(floatkey[m].Attribute("alpha").Value)
                    });
                }

                anim.TransformKeyData = transformkeydata;
                BoneAnimation.Add(anim);
            }
        }