public void TestAnimationClip()
        {
            var clip = new AnimationClip
            {
                Duration = TimeSpan.FromSeconds(2.0f),
                RepeatMode = AnimationRepeatMode.LoopInfinite
            };

            var testCurve = new AnimationCurve<float>();
            clip.AddCurve("posx[TestNode]", testCurve);
            testCurve.InterpolationType = AnimationCurveInterpolationType.Linear;

            var time = CompressedTimeSpan.FromSeconds(0.0f);
            var value = 0.0f;
            var frame0 = new KeyFrameData<float>(time, value);
            testCurve.KeyFrames.Add(frame0);

            time = CompressedTimeSpan.FromSeconds(1.0f);
            value = 1.0f;
            var frame1 = new KeyFrameData<float>(time, value);
            testCurve.KeyFrames.Add(frame1);

            clip.Optimize();

            var optimizedCurvesFloat = (AnimationData<float>)clip.OptimizedAnimationDatas.First();

            //we should have 3 frames at this point. the last one will be added by the optimization process...
            Assert.That(optimizedCurvesFloat.AnimationSortedValueCount, Is.EqualTo(1));
            //And 2 initial frames            
            Assert.That(optimizedCurvesFloat.AnimationInitialValues[0].Value1, Is.EqualTo(frame0));
            Assert.That(optimizedCurvesFloat.AnimationInitialValues[0].Value2, Is.EqualTo(frame1));
            Assert.That(optimizedCurvesFloat.AnimationSortedValues.Length, Is.EqualTo(1));
            Assert.That(optimizedCurvesFloat.AnimationSortedValues[0].Length, Is.EqualTo(1));
            Assert.That(optimizedCurvesFloat.AnimationSortedValues[0][0].Value, Is.EqualTo(frame1));
        }
Beispiel #2
0
    /// <summary>
    /// ロードボタンを押した時
    /// </summary>
    private void OnLoadClicked()
    {
        _currentData = KeyFrameData.LoadDataFromJson(_fileNameInput.text);
        if (_currentData == null)
        {
            return;
        }
        // MEMO:キーフレームグループが増えるたび増やす
        foreach (var segment in _currentData.Segments)
        {
            switch (segment.Target)
            {
            case KeyFrameToolEnum.TargetType.None:
                break;

            case KeyFrameToolEnum.TargetType.Hoge:
                _hogeKeyFrame.ApplyKeyFrameData(segment);
                break;

            case KeyFrameToolEnum.TargetType.Fuga:
                _fugaKeyFrame.ApplyKeyFrameData(segment);
                break;
            }
        }
    }
Beispiel #3
0
    static KeyFrameData CalculateAnimationKeyFrameData(int animid, Parser.Tr2Level leveldata)
    {
        //Note: animid is a index to tranim list.

        KeyFrameData tr2framedata = new KeyFrameData();

        if (animid == leveldata.NumAnimations)
        {
            //endofanimation
            tr2framedata.endofanimation = true;
            return(tr2framedata);
        }

        if (animid == 0)
        {
            tr2framedata.bplayer = true;
        }

        Parser.Tr2Animation tr2animation = leveldata.Animations[animid];
        //create  s16 offset list of frames for this animation;
        //determine short stating offset to frames chunk of this animclip
        //calculate index into tr2frames[] and how large the frame is
        //tr2animation.FrameOffset is byte offset into Frame, make it short offset
        //tr2animation.FrameSize = (byte)((tr2frames[fo + 9] * 2) + 10);

        tr2framedata.data           = leveldata.Frames;
        tr2framedata.startoffset    = (int)tr2animation.FrameOffset / 2;
        tr2framedata.framesize      = (int)tr2animation.FrameSize; // num shorts of this frame step
        tr2framedata.time_per_frame = (float)tr2animation.FrameRate / 30f;

        if (animid < (int)leveldata.NumAnimations - 1)
        {
            Parser.Tr2Animation nexttr2animation = leveldata.Animations[animid + 1];
            int nextoffset = (int)(nexttr2animation.FrameOffset / 2);
            tr2framedata.numshorts = nextoffset - tr2framedata.startoffset;
        }
        else
        {
            tr2framedata.numshorts = (int)(leveldata.NumFrames - (uint)tr2framedata.startoffset);
        }

        if (tr2framedata.framesize != 0)
        {
            tr2framedata.numkeyframe = tr2framedata.numshorts / tr2framedata.framesize;
        }
        else
        {
            tr2framedata.numkeyframe = 0;
        }

        tr2framedata.start_animation_frame_index = tr2animation.FrameStart;// tr2animation (int)tr2framedata.startoffset / tr2framedata.framesize;

        // tr2framedata.numkeyframe = (tr2animation.FrameEnd - tr2animation.FrameStart) + 1;

        //if(tr2framedata.numkeyframe > 15)
        //Debug.Log("numkeyframe: " + tr2framedata.numkeyframe + " NextAnimation:" + tr2animation.NextAnimation);

        return(tr2framedata);
    }
Beispiel #4
0
        public void TestAnimationClip()
        {
            var clip = new AnimationClip
            {
                Duration   = TimeSpan.FromSeconds(2.0f),
                RepeatMode = AnimationRepeatMode.LoopInfinite
            };

            var testCurve = new AnimationCurve <float>();

            clip.AddCurve("posx[TestNode]", testCurve);
            testCurve.InterpolationType = AnimationCurveInterpolationType.Linear;

            var time   = CompressedTimeSpan.FromSeconds(0.0f);
            var value  = 0.0f;
            var frame0 = new KeyFrameData <float>(time, value);

            testCurve.KeyFrames.Add(frame0);

            time  = CompressedTimeSpan.FromSeconds(1.0f);
            value = 1.0f;
            var frame1 = new KeyFrameData <float>(time, value);

            testCurve.KeyFrames.Add(frame1);

            clip.Optimize();

            var optimizedCurvesFloat = (AnimationData <float>)clip.OptimizedAnimationDatas.First();

            //we should have 3 frames at this point. the last one will be added by the optimization process...
            Assert.That(optimizedCurvesFloat.AnimationSortedValueCount, Is.EqualTo(1));
            //And 2 initial frames
            Assert.That(optimizedCurvesFloat.AnimationInitialValues[0].Value1, Is.EqualTo(frame0));
            Assert.That(optimizedCurvesFloat.AnimationInitialValues[0].Value2, Is.EqualTo(frame1));
            Assert.That(optimizedCurvesFloat.AnimationSortedValues.Length, Is.EqualTo(1));
            Assert.That(optimizedCurvesFloat.AnimationSortedValues[0].Length, Is.EqualTo(1));
            Assert.That(optimizedCurvesFloat.AnimationSortedValues[0][0].Value, Is.EqualTo(frame1));
        }
Beispiel #5
0
        private void UpdateKeyFrameList(Motion m, float Key = -1)
        {
            _freeze = true;
            KeyFrameData.Rows.Clear();

            int CurrentRow = -1;
            if (Key == -1) Key = CurrentKeyFrame;
            foreach (MotionKeyFrames k in m.KeyFrames)
            {
                var rot = k.GetRotation();
                var tra = k.GetTranslation();
                KeyFrameData.Rows.Add(k.KeyTime, tra.X, tra.Y, tra.Z, rot.X, rot.Y, rot.Z, rot.W);
                if (k.KeyTime == Key) CurrentRow += KeyFrameData.Rows.Count;
            }
            if (CurrentRow == -1) CurrentRow += KeyFrameData.Rows.Count;
            
            KeyFrameData.ClearSelection();
            KeyFrameData.CurrentCell = KeyFrameData.Rows[CurrentRow].Cells[0];
            KeyFrameData.Rows[CurrentRow].Selected = true;
            CurrentKeyFrame = (float)KeyFrameData.Rows[CurrentRow].Cells[0].Value;
            txtCurrentKey.Text = KeyFrameData.Rows[CurrentRow].Cells[0].Value.ToString();
            m.CurrentKeyTime = CurrentKeyFrame;
            _freeze = false;
        }
Beispiel #6
0
        void ProcessAnimation(AnimationContent anim, ContentProcessorContext context, List <AnimationData> animations, Dictionary <string, int> indices, SkeletonData skeleton)
        {
            SortedDictionary <TimeSpan, bool>     allFrameTimes = new SortedDictionary <TimeSpan, bool>();
            SortedDictionary <TimeSpan, Matrix[]> transforms    = new SortedDictionary <TimeSpan, Matrix[]>();
            int totalChannels = 0;

            foreach (KeyValuePair <string, AnimationChannel> channelKVP in anim.Channels)
            {
                if (indices.ContainsKey(CleanBoneName(channelKVP.Key)) == false)
                {
                    continue;
                }

                AnimationChannel channel = channelKVP.Value;

                foreach (AnimationKeyframe frame in channel)
                {
                    if (allFrameTimes.ContainsKey(frame.Time) == false)
                    {
                        allFrameTimes.Add(frame.Time, true);
                    }
                }
                totalChannels++;
            }

            foreach (TimeSpan time in allFrameTimes.Keys)
            {
                transforms.Add(time, new Matrix[totalChannels]);
            }

            SortedDictionary <TimeSpan, Matrix>     keyFrames = new SortedDictionary <TimeSpan, Matrix>();
            List <KeyValuePair <TimeSpan, Matrix> > newFrames = new List <KeyValuePair <TimeSpan, Matrix> >();

            int index = 0;

            foreach (KeyValuePair <string, AnimationChannel> channelKVP in anim.Channels)
            {
                int boneIndex = 0;
                if (indices.TryGetValue(CleanBoneName(channelKVP.Key), out boneIndex) == false)
                {
                    continue;
                }

                AnimationChannel channel = channelKVP.Value;
                Matrix           transform;

                foreach (AnimationKeyframe frame in channel)
                {
                    transform = frame.Transform;

                    if (boneIndex == 0)
                    {
                        CorrectRootBoneTransform(ref transform, skeleton);
                    }
                    else
                    {
                        //remove translation
                        transform.Translation = new Vector3();
                    }

                    keyFrames.Add(frame.Time, transform);
                }

                SortedDictionary <TimeSpan, Matrix> .Enumerator frames = keyFrames.GetEnumerator();
                SortedDictionary <TimeSpan, bool> .Enumerator   times  = allFrameTimes.GetEnumerator();

                if (!times.MoveNext())
                {
                    continue;
                }
                if (!frames.MoveNext())
                {
                    continue;
                }
                TimeSpan time = frames.Current.Key;
                transform = frames.Current.Value;

                while (true)
                {
                    Matrix   previousTransform = transform;
                    TimeSpan previousTime      = time;

                    time      = frames.Current.Key;
                    transform = frames.Current.Value;

                    if (times.Current.Key.Ticks == frames.Current.Key.Ticks)
                    {
                        if (!times.MoveNext())
                        {
                            break;
                        }

                        if (!frames.MoveNext())
                        {
                            //frames ends early...
                            while (true)
                            {
                                newFrames.Add(new KeyValuePair <TimeSpan, Matrix>(times.Current.Key, transform));

                                if (!times.MoveNext())
                                {
                                    break;
                                }
                            }
                            break;
                        }
                        continue;
                    }

                    if (times.Current.Key.Ticks > frames.Current.Key.Ticks)
                    {
                        //frame is behind
                        if (!frames.MoveNext())
                        {
                            //frames ends early...
                            while (true)
                            {
                                newFrames.Add(new KeyValuePair <TimeSpan, Matrix>(times.Current.Key, transform));

                                if (!times.MoveNext())
                                {
                                    break;
                                }
                            }
                            break;
                        }
                        continue;
                    }
                    else
                    {
                        //frame is ahead.. create an inbetween

                        double amount       = (times.Current.Key - previousTime).TotalSeconds / (frames.Current.Key - previousTime).TotalSeconds;
                        Matrix newTransform = Matrix.Lerp(previousTransform, frames.Current.Value, (float)amount);
                        //Matrix newTransform = frames.Current.Value.Interpolate(ref previousTransform, (float)(1 - amount));
                        newFrames.Add(new KeyValuePair <TimeSpan, Matrix>(times.Current.Key, newTransform));

                        transform = newTransform;
                        time      = times.Current.Key;

                        if (!times.MoveNext())
                        {
                            break;
                        }
                    }
                }


                foreach (KeyValuePair <TimeSpan, Matrix> newFrame in newFrames)
                {
                    keyFrames.Add(newFrame.Key, newFrame.Value);
                }

                foreach (KeyValuePair <TimeSpan, Matrix> kvp in keyFrames)
                {
                    Matrix[] array;
                    if (transforms.TryGetValue(kvp.Key, out array))
                    {
                        array[index] = kvp.Value;
                    }
                    else
                    {
                        continue;
                    }
                }

                newFrames.Clear();
                keyFrames.Clear();

                index++;
            }

            KeyFrameData[] boneKeyFrames = new KeyFrameData[transforms.Count];
            int[]          boneIndices   = new int[totalChannels];
            index = 0;


            foreach (KeyValuePair <string, AnimationChannel> channelKVP in anim.Channels)
            {
                if (indices.ContainsKey(CleanBoneName(channelKVP.Key)) == false)
                {
                    continue;
                }
                boneIndices[index++] = indices[CleanBoneName(channelKVP.Key)];
            }

            //compute world space bone default skeleton
            Matrix[] worldBoneTransforms = skeleton.BoneLocalMatrices.ToArray();
            skeleton.TransformHierarchy(worldBoneTransforms);

            index = 0;
            float duration = 0;

            foreach (KeyValuePair <TimeSpan, Matrix[]> kvp in transforms)
            {
                float seconds = (float)kvp.Key.TotalSeconds;

                /*
                 * //make transforms realtive to skeleton
                 * //first get static bone transforms
                 * Matrix[] worldTransform = new Matrix[skeleton.BoneCount];
                 * for (int i = 0; i < worldTransform.Length; i++)
                 *      worldTransform[i] = skeleton.BoneLocalMatrices[i];
                 *
                 * //replace the animated bones..
                 * for (int i = 0; i < kvp.Value.Length; i++)
                 *      worldTransform[boneIndices[i]] = kvp.Value[i];
                 *
                 * //transform into a world space skeleton
                 * skeleton.TransformHierarchy(worldTransform);
                 *
                 * //multiply the world space transforms with the inverse of the world space static skeleton
                 * for (int i = 0; i < worldTransform.Length; i++)
                 * {
                 *      Matrix m = worldBoneTransforms[i];
                 *      Matrix.Invert(ref m, out m);
                 *
                 *      worldTransform[i] = m * worldTransform[i];
                 * }
                 *
                 * //transform back out of world space into joint space
                 * skeleton.TransformHierarchyInverse(worldTransform);
                 *
                 *
                 * for (int i = 0; i < kvp.Value.Length; i++)
                 *      kvp.Value[i] = worldTransform[boneIndices[i]];
                 */
                boneKeyFrames[index++] = new KeyFrameData(seconds, kvp.Value);
                duration = Math.Max(seconds, duration);
            }

            if (boneIndices.Length > 0 && boneKeyFrames.Length > 0)
            {
                AnimationData animation = new AnimationData(anim.Name, boneIndices, boneKeyFrames, duration, animationCompressionTolerancePercent);

                animations.Add(animation);
            }
        }
Beispiel #7
0
    //param  transformtree: number of transform used in animation clip
    //param startclipid : first animation clip index into Parser.Tr2Animation array
    //keyframeinfo: holds tr2 keyframes related info for an animation

    public static List <TRAnimationClip> CreateAnimationWithID(Tr2Moveable tr2movable, Transform[] transformtree, Parser.Tr2Level leveldata)
    {
        List <TRAnimationClip> tranimclips = new List <TRAnimationClip>();

        int ntransform   = transformtree.Length;
        int trclipoffset = tr2movable.AnimationStartOffset;

        Parser.TR2VersionType enginetype = leveldata.EngineVersion;

        //each tr anim actually  information that reffer a chunk of animation frames  contained in frames[]
        //each frame chunk contain sequential  data [key] for all of the transform of this object
        //Now question is how many animation clips there are ?

        //KeyFrameData keyframeinfo = CalculateAnimationKeyFrameData(trclipoffset, leveldata);

        /*bool shortanimation = false;
         * if (keyframeinfo.numkeyframe < 15)
         * {
         *  shortanimation = true;
         * }
         *
         * int nclip = 1;
         * if (tr2movable.ObjectID == 0)
         * {
         *  nclip = 261;
         *
         *  Debug.Log(" lara trclipoffset: " + trclipoffset);
         * }
         *
         * //Debug.Log("ID: " + tr2movable.ObjectID + " trclipoffset: " + trclipoffset);
         */


        for (int clipid = 0; clipid < tr2movable.NumClips; clipid++)
        {
            //if(shortanimation && clipid > 5) break;

            KeyFrameData        keyframeinfo = CalculateAnimationKeyFrameData(trclipoffset, leveldata);
            Parser.Tr2Animation tr2animation = leveldata.Animations[trclipoffset];

            AnimationCurve curvRelX = null;
            AnimationCurve curvRelY = null;
            AnimationCurve curvRelZ = null;

            AnimationCurve[] curvRelRotX = new AnimationCurve[ntransform];
            AnimationCurve[] curvRelRotY = new AnimationCurve[ntransform];
            AnimationCurve[] curvRelRotZ = new AnimationCurve[ntransform];
            AnimationCurve[] curvRelRotW = new AnimationCurve[ntransform];

            //prepare curves for animation
            for (int transformId = 0; transformId < ntransform; transformId++)
            {
                //create curves
                curvRelRotX[transformId] = new AnimationCurve(null);
                curvRelRotY[transformId] = new AnimationCurve(null);
                curvRelRotZ[transformId] = new AnimationCurve(null);
                curvRelRotW[transformId] = new AnimationCurve(null);

                if (transformId == 0)
                {
                    curvRelX = new AnimationCurve(null);
                    curvRelY = new AnimationCurve(null);
                    curvRelZ = new AnimationCurve(null);
                }
            }

            int numkeyframe = keyframeinfo.numkeyframe;

            for (int keyFrameCount = 0; keyFrameCount < numkeyframe; ++keyFrameCount)
            {
                int frameoffset = keyframeinfo.startoffset + (keyframeinfo.framesize * keyFrameCount);

                //extract key frme rotation
                int l = 9;   //first angle offset in this Frame
                for (int transformId = 0; transformId < ntransform; transformId++)
                {
                    ushort itmp = keyframeinfo.data[frameoffset + l];
                    ushort itmp2;
                    double angle;
                    float  rotx = 0;
                    float  roty = 0;
                    float  rotz = 0;
                    l = l + 1;
                    if (enginetype == Parser.TR2VersionType.TombRaider_1)
                    {
                        // all angles are three-axis
                        angle  = (itmp >> 4) & 0x03ff;
                        angle *= 360.0 / 1024.0;
                        rotx   = (float)angle; //keyframe rotx value

                        itmp2 = (ushort)((itmp << 6) & 0x03c0);
                        itmp  = keyframeinfo.data[frameoffset + l]; // get Z rotation
                        l     = l + 1;

                        itmp2 |= (ushort)((itmp >> 10) & 0x003f);
                        angle  = itmp2;
                        angle *= 360.0 / 1024.0;
                        roty   = (float)angle; //keyframe roty value

                        angle  = itmp & 0x3ff;
                        angle *= 360.0 / 1024.0;
                        rotz   = (float)angle;    //keyframe rotz value
                    }
                    else if ((itmp & 0xc000) > 0) // TR2, TR3, TR4 - single axis of rotation
                    {
                        if (enginetype == Parser.TR2VersionType.TombRaider_4)
                        {
                            angle  = itmp & 0x0fff;
                            angle /= 4096.0;
                            angle *= 360.0;
                        }
                        else
                        {
                            angle  = itmp & 0x3ff;
                            angle /= 1024.0;
                            angle *= 360.0;
                        }

                        switch (itmp & 0xc000)
                        {
                        case 0x4000:
                            rotx = (float)angle;
                            break;

                        case 0x8000:
                            roty = (float)angle;
                            break;

                        case 0xc000:
                            rotz = (float)angle;
                            break;
                        }
                    }
                    else   // TR2, TR3, TR4 - three axes
                    {
                        angle  = (itmp >> 4) & 0x03ff;
                        angle *= 360.0 / 1024.0;
                        rotx   = (float)angle;

                        itmp2 = (ushort)((itmp << 6) & 0x03c0);
                        itmp  = keyframeinfo.data[frameoffset + l]; // get Z rotation
                        l     = l + 1;

                        itmp2 |= (ushort)((itmp >> 10) & 0x003f);
                        angle  = itmp2;
                        angle *= 360.0 / 1024.0;
                        roty   = (float)angle;

                        angle  = itmp & 0x3ff;
                        angle *= 360.0 / 1024.0;
                        rotz   = (float)angle;
                    }

                    //if(rotx > 180)
                    //{
                    rotx = Mathf.Abs(360 - rotx);
                    //}

                    //if(rotz > 180)
                    //{
                    rotz = Mathf.Abs(360 - rotz);;
                    //}

                    //if(roty > 180)
                    //{
                    //roty= Mathf.Abs(360 - roty) ;;
                    //}

                    if (transformId == 0)
                    {
                        float ItemAnimX = (short)keyframeinfo.data[frameoffset + 6] * Settings.SceneScaling;
                        float ItemAnimY = (short)keyframeinfo.data[frameoffset + 7] * Settings.SceneScaling;
                        float ItemAnimZ = (short)keyframeinfo.data[frameoffset + 8] * Settings.SceneScaling;

                        if (numkeyframe == 1) //addition key after last key
                        {
                            curvRelX.AddKey(0, ItemAnimX);
                            curvRelY.AddKey(0, -ItemAnimY);
                            curvRelZ.AddKey(0, ItemAnimZ);

                            curvRelX.AddKey(1 * keyframeinfo.time_per_frame, ItemAnimX);
                            curvRelY.AddKey(1 * keyframeinfo.time_per_frame, -ItemAnimY);
                            curvRelZ.AddKey(1 * keyframeinfo.time_per_frame, ItemAnimZ);
                        }
                        else
                        {
                            int keylength = curvRelX.length;
                            if (keylength > 0)
                            {
                                Keyframe kx = new Keyframe(keylength * keyframeinfo.time_per_frame, ItemAnimX, Mathf.Infinity, Mathf.Infinity);
                                Keyframe ky = new Keyframe(keylength * keyframeinfo.time_per_frame, -ItemAnimY, Mathf.Infinity, Mathf.Infinity);
                                Keyframe kz = new Keyframe(keylength * keyframeinfo.time_per_frame, ItemAnimZ, Mathf.Infinity, Mathf.Infinity);
                                curvRelX.AddKey(kx);
                                curvRelY.AddKey(ky);
                                curvRelZ.AddKey(kz);
                            }
                            else
                            {
                                curvRelX.AddKey(0, ItemAnimX);
                                curvRelY.AddKey(0, -ItemAnimY);
                                curvRelZ.AddKey(0, ItemAnimZ);
                            }
                        }
                    }

                    //TODO:
                    //multiply transform with reltive rotation and translation data
                    //relative translation of animation. allready provided?
                    //problem: animation transform works in local space.Thats mean it does not work on root?Am I working in root?

                    Quaternion finalrot =
                        Quaternion.AngleAxis(roty, Vector3.up) *
                        Quaternion.AngleAxis(rotx, Vector3.right) *
                        Quaternion.AngleAxis(rotz, Vector3.forward);

                    if (numkeyframe == 1) //addition key after last key
                    {
                        curvRelRotX[transformId].AddKey(0, finalrot.x);
                        curvRelRotY[transformId].AddKey(0, finalrot.y);
                        curvRelRotZ[transformId].AddKey(0, finalrot.z);
                        curvRelRotW[transformId].AddKey(0, finalrot.w);

                        curvRelRotX[transformId].AddKey(keyframeinfo.time_per_frame, finalrot.x);
                        curvRelRotY[transformId].AddKey(keyframeinfo.time_per_frame, finalrot.y);
                        curvRelRotZ[transformId].AddKey(keyframeinfo.time_per_frame, finalrot.z);
                        curvRelRotW[transformId].AddKey(keyframeinfo.time_per_frame, finalrot.w);
                    }
                    else
                    {
                        int keylength = curvRelRotX[transformId].length;
                        if (keylength > 0)
                        {
                            //FIX: set outTangent and inTangent to Mathf.Infinity
                            Keyframe kfrotx = new Keyframe(keylength * keyframeinfo.time_per_frame, finalrot.x, Mathf.Infinity, Mathf.Infinity);
                            Keyframe kfroty = new Keyframe(keylength * keyframeinfo.time_per_frame, finalrot.y, Mathf.Infinity, Mathf.Infinity);
                            Keyframe kfrotz = new Keyframe(keylength * keyframeinfo.time_per_frame, finalrot.z, Mathf.Infinity, Mathf.Infinity);
                            Keyframe kfrotw = new Keyframe(keylength * keyframeinfo.time_per_frame, finalrot.w, Mathf.Infinity, Mathf.Infinity);

                            curvRelRotX[transformId].AddKey(kfrotx);
                            curvRelRotY[transformId].AddKey(kfroty);
                            curvRelRotZ[transformId].AddKey(kfrotz);
                            curvRelRotW[transformId].AddKey(kfrotw);
                        }
                        else
                        {
                            curvRelRotX[transformId].AddKey(0, finalrot.x);
                            curvRelRotY[transformId].AddKey(0, finalrot.y);
                            curvRelRotZ[transformId].AddKey(0, finalrot.z);
                            curvRelRotW[transformId].AddKey(0, finalrot.w);
                        }
                    }
                }
            }

            AnimationClip animClip = new AnimationClip();
//if animClip is not set to legacy set curve will not workt on vesion 4 or higher
#if UNITY_4_0
            animClip.legacy = true;
#elif UNITY_4_0_1
            animClip.legacy = true;
#elif UNITY_4_1
            animClip.legacy = true;
#elif UNITY_4_2
            animClip.legacy = true;
#elif UNITY_4_3
            animClip.legacy = true;
#elif UNITY_4_5
            animClip.legacy = true;
#elif UNITY_4_6
            animClip.legacy = true;
#elif UNITY_5_0
            animClip.legacy = true;
#endif
#if (UNITY_5_3_OR_NEWER || UNITY_5_3)
            animClip.legacy = true;
#endif

            for (int transformId = 0; transformId < ntransform; transformId++)
            {
                System.String relCurvePath = CalculateCurveRelativePath(transformtree[transformId]);
                //print("relCurvePath:"+relCurvePath);

                if (transformId != 0)
                {
                    animClip.SetCurve(relCurvePath, typeof(Transform), "localRotation.x", curvRelRotX[transformId]);
                    animClip.SetCurve(relCurvePath, typeof(Transform), "localRotation.y", curvRelRotY[transformId]);
                    animClip.SetCurve(relCurvePath, typeof(Transform), "localRotation.z", curvRelRotZ[transformId]);
                    animClip.SetCurve(relCurvePath, typeof(Transform), "localRotation.w", curvRelRotW[transformId]);
                }
                else
                {
                    animClip.SetCurve(relCurvePath, typeof(Transform), "localRotation.x", curvRelRotX[transformId]);
                    animClip.SetCurve(relCurvePath, typeof(Transform), "localRotation.y", curvRelRotY[transformId]);
                    animClip.SetCurve(relCurvePath, typeof(Transform), "localRotation.z", curvRelRotZ[transformId]);
                    animClip.SetCurve(relCurvePath, typeof(Transform), "localRotation.w", curvRelRotW[transformId]);

                    animClip.SetCurve(relCurvePath, typeof(Transform), "localPosition.x", curvRelX);
                    animClip.SetCurve(relCurvePath, typeof(Transform), "localPosition.y", curvRelY);
                    animClip.SetCurve(relCurvePath, typeof(Transform), "localPosition.z", curvRelZ);
                }
            }

            TRAnimationClip tranimclip = new TRAnimationClip(animClip, leveldata.Animations[clipid].StateID);
            tranimclip.time_per_frame = keyframeinfo.time_per_frame;
            tranimclip.starttime      = 0.0f;
            tranimclip.endtime        = keyframeinfo.numkeyframe * tranimclip.time_per_frame;
            tranimclip.framerate      = 7 - tr2animation.FrameRate;// 1f / tranimclip.time_per_frame ;
            tranimclip.index          = clipid;
            tranimclip.start_animation_frame_index = keyframeinfo.start_animation_frame_index;
            tranimclips.Add(tranimclip);
            //goto next clip
            trclipoffset++;
        }

        return(tranimclips);
    }
Beispiel #8
0
 public KeyFrameData GetKeyFrames(KeyFrameData obj, int j)
 {
     int o = __offset(8); return o != 0 ? obj.__init(__indirect(__vector(o) + j * 4), bb) : null;
 }
        private Offset <KeyFrameData>?SerializeKeyFrame(FlatBufferBuilder fbb, KeyFrame frame)
        {
            #region Linear

            if (frame is LinearKeyFrame_Int16)
            {
                var oFrame = LinearKeyFrameData_Int16.CreateLinearKeyFrameData_Int16(fbb, frame.Time, (short)frame.Value);

                return(KeyFrameData.CreateKeyFrameData(fbb, KeyFrameUnion.LinearKeyFrameData_Int16, oFrame.Value));
            }

            if (frame is LinearKeyFrame_Int32)
            {
                var oFrame = LinearKeyFrameData_Int32.CreateLinearKeyFrameData_Int32(fbb, frame.Time, (int)frame.Value);

                return(KeyFrameData.CreateKeyFrameData(fbb, KeyFrameUnion.LinearKeyFrameData_Int32, oFrame.Value));
            }

            if (frame is LinearKeyFrame_Int64)
            {
                var oFrame = LinearKeyFrameData_Int64.CreateLinearKeyFrameData_Int64(fbb, frame.Time, (long)frame.Value);

                return(KeyFrameData.CreateKeyFrameData(fbb, KeyFrameUnion.LinearKeyFrameData_Int64, oFrame.Value));
            }

            if (frame is LinearKeyFrame_Float)
            {
                var oFrame = LinearKeyFrameData_Float.CreateLinearKeyFrameData_Float(fbb, frame.Time, (float)frame.Value);

                return(KeyFrameData.CreateKeyFrameData(fbb, KeyFrameUnion.LinearKeyFrameData_Float, oFrame.Value));
            }

            #endregion

            #region Pulse

            if (frame is PulseKeyFrame <short> )
            {
                var oFrame = PulseKeyFrameData_Int16.CreatePulseKeyFrameData_Int16(fbb, frame.Time, (short)frame.Value);

                return(KeyFrameData.CreateKeyFrameData(fbb, KeyFrameUnion.PulseKeyFrameData_Int16, oFrame.Value));
            }

            if (frame is PulseKeyFrame <int> )
            {
                var oFrame = PulseKeyFrameData_Int32.CreatePulseKeyFrameData_Int32(fbb, frame.Time, (int)frame.Value);

                return(KeyFrameData.CreateKeyFrameData(fbb, KeyFrameUnion.PulseKeyFrameData_Int32, oFrame.Value));
            }

            if (frame is PulseKeyFrame <long> )
            {
                var oFrame = PulseKeyFrameData_Int64.CreatePulseKeyFrameData_Int64(fbb, frame.Time, (long)frame.Value);

                return(KeyFrameData.CreateKeyFrameData(fbb, KeyFrameUnion.PulseKeyFrameData_Int64, oFrame.Value));
            }

            if (frame is PulseKeyFrame <float> )
            {
                var oFrame = PulseKeyFrameData_Float.CreatePulseKeyFrameData_Float(fbb, frame.Time, (float)frame.Value);

                return(KeyFrameData.CreateKeyFrameData(fbb, KeyFrameUnion.PulseKeyFrameData_Float, oFrame.Value));
            }

            #endregion

            #region Step

            if (frame is StepKeyFrame <bool> )
            {
                var oFrame = StepKeyFrameData_Boolean.CreateStepKeyFrameData_Boolean(fbb, frame.Time, (bool)frame.Value);

                return(KeyFrameData.CreateKeyFrameData(fbb, KeyFrameUnion.StepKeyFrameData_Boolean, oFrame.Value));
            }

            if (frame is StepKeyFrame <short> )
            {
                var oFrame = StepKeyFrameData_Int16.CreateStepKeyFrameData_Int16(fbb, frame.Time, (short)frame.Value);

                return(KeyFrameData.CreateKeyFrameData(fbb, KeyFrameUnion.StepKeyFrameData_Int16, oFrame.Value));
            }

            if (frame is StepKeyFrame <int> )
            {
                var oFrame = StepKeyFrameData_Int32.CreateStepKeyFrameData_Int32(fbb, frame.Time, (int)frame.Value);

                return(KeyFrameData.CreateKeyFrameData(fbb, KeyFrameUnion.StepKeyFrameData_Int32, oFrame.Value));
            }

            if (frame is StepKeyFrame <long> )
            {
                var oFrame = StepKeyFrameData_Int64.CreateStepKeyFrameData_Int64(fbb, frame.Time, (long)frame.Value);

                return(KeyFrameData.CreateKeyFrameData(fbb, KeyFrameUnion.StepKeyFrameData_Int64, oFrame.Value));
            }

            if (frame is StepKeyFrame <float> )
            {
                var oFrame = StepKeyFrameData_Float.CreateStepKeyFrameData_Float(fbb, frame.Time, (float)frame.Value);

                return(KeyFrameData.CreateKeyFrameData(fbb, KeyFrameUnion.StepKeyFrameData_Float, oFrame.Value));
            }

            #endregion

            throw new NotSupportedException("KeyFrameType");
        }
Beispiel #10
0
    static KeyFrameData CalculateAnimationKeyFrameData(int animid, Parser.Tr2Level leveldata)
    {
        //Note: animid is a index to tranim list.

        KeyFrameData tr2framedata = new KeyFrameData();
        if(animid == leveldata.NumAnimations)
        {
            //endofanimation
            tr2framedata.endofanimation = true;
            return tr2framedata;
        }

        if(animid == 0)
        {
            tr2framedata.bplayer = true;
        }

        Parser.Tr2Animation tr2animation = leveldata.Animations[animid];
        //create  s16 offset list of frames for this animation;
        //determine short stating offset to frames chunk of this animclip
        //calculate index into tr2frames[] and how large the frame is
        //tr2animation.FrameOffset is byte offset into Frame, make it short offset
        //tr2animation.FrameSize = (byte)((tr2frames[fo + 9] * 2) + 10);

        tr2framedata.data = leveldata.Frames;
        tr2framedata.startoffset = (int) tr2animation.FrameOffset / 2;
        tr2framedata.framesize = (int) tr2animation.FrameSize;  // num shorts of this frame step
        tr2framedata.framerate= 1.0f/((7.0f - tr2animation.FrameRate) * 4.0f) ;

        if(animid < (int)leveldata.NumAnimations - 1)
        {
            Parser.Tr2Animation nexttr2animation = leveldata.Animations[animid + 1];
            int nextoffset = (int)(nexttr2animation.FrameOffset / 2);
            tr2framedata.numshorts = nextoffset - tr2framedata.startoffset ;
        }
        else
        {
            tr2framedata.numshorts = (int)(leveldata.NumFrames  - (uint)tr2framedata.startoffset);
        }

        if(tr2framedata.framesize!=0)
        {
            tr2framedata.numkeyframe = tr2framedata.numshorts / tr2framedata.framesize;
        }
        else
        {
            tr2framedata.numkeyframe = 0;
        }

        //if(tr2framedata.numkeyframe > 15)
        //Debug.Log("numkeyframe: " + tr2framedata.numkeyframe + " NextAnimation:" + tr2animation.NextAnimation);

        return tr2framedata;
    }
        private void DeserializeKeyFrame(Variable variable, KeyFrameData data)
        {
            switch (data.DataType)
            {
                #region Linear

            case KeyFrameUnion.LinearKeyFrameData_Int16:
            {
                var frame = data.GetData <LinearKeyFrameData_Int16>(new LinearKeyFrameData_Int16());

                AddLinearFrame((Variable <short>)variable, frame.Time, frame.Value);
            }
            break;

            case KeyFrameUnion.LinearKeyFrameData_Int32:
            {
                var frame = data.GetData <LinearKeyFrameData_Int32>(new LinearKeyFrameData_Int32());

                AddLinearFrame((Variable <int>)variable, frame.Time, frame.Value);
            }
            break;

            case KeyFrameUnion.LinearKeyFrameData_Int64:
            {
                var frame = data.GetData <LinearKeyFrameData_Int64>(new LinearKeyFrameData_Int64());

                AddLinearFrame((Variable <long>)variable, frame.Time, frame.Value);
            }
            break;

            case KeyFrameUnion.LinearKeyFrameData_Float:
            {
                var frame = data.GetData <LinearKeyFrameData_Float>(new LinearKeyFrameData_Float());

                AddLinearFrame((Variable <float>)variable, frame.Time, frame.Value);
            }
            break;

                #endregion

                #region Pulse

            case KeyFrameUnion.PulseKeyFrameData_Int16:
            {
                var frame = data.GetData <PulseKeyFrameData_Int16>(new PulseKeyFrameData_Int16());

                AddPulseFrame((Variable <short>)variable, frame.Time, frame.Value);
            }
            break;

            case KeyFrameUnion.PulseKeyFrameData_Int32:
            {
                var frame = data.GetData <PulseKeyFrameData_Int32>(new PulseKeyFrameData_Int32());

                AddPulseFrame((Variable <int>)variable, frame.Time, frame.Value);
            }
            break;

            case KeyFrameUnion.PulseKeyFrameData_Int64:
            {
                var frame = data.GetData <PulseKeyFrameData_Int64>(new PulseKeyFrameData_Int64());

                AddPulseFrame((Variable <long>)variable, frame.Time, frame.Value);
            }
            break;

            case KeyFrameUnion.PulseKeyFrameData_Float:
            {
                var frame = data.GetData <PulseKeyFrameData_Float>(new PulseKeyFrameData_Float());

                AddPulseFrame((Variable <float>)variable, frame.Time, frame.Value);
            }
            break;

                #endregion

                #region Step

            case KeyFrameUnion.StepKeyFrameData_Boolean:
            {
                var frame = data.GetData <StepKeyFrameData_Boolean>(new StepKeyFrameData_Boolean());

                AddStepFrame((Variable <bool>)variable, frame.Time, frame.Value);
            }
            break;

            case KeyFrameUnion.StepKeyFrameData_Int16:
            {
                var frame = data.GetData <StepKeyFrameData_Int16>(new StepKeyFrameData_Int16());

                AddStepFrame((Variable <short>)variable, frame.Time, frame.Value);
            }
            break;

            case KeyFrameUnion.StepKeyFrameData_Int32:
            {
                var frame = data.GetData <StepKeyFrameData_Int32>(new StepKeyFrameData_Int32());

                AddStepFrame((Variable <int>)variable, frame.Time, frame.Value);
            }
            break;

            case KeyFrameUnion.StepKeyFrameData_Int64:
            {
                var frame = data.GetData <StepKeyFrameData_Int64>(new StepKeyFrameData_Int64());

                AddStepFrame((Variable <long>)variable, frame.Time, frame.Value);
            }
            break;

            case KeyFrameUnion.StepKeyFrameData_Float:
            {
                var frame = data.GetData <StepKeyFrameData_Float>(new StepKeyFrameData_Float());

                AddStepFrame((Variable <float>)variable, frame.Time, frame.Value);
            }
            break;

                #endregion

            default:
                throw new NotSupportedException("Unknown type of keyFrame");
            }
        }