Example #1
0
        public void Compress()
        {
            // First try to find identical sets of keyframes in tracks
            for (int t = 0; t < rgbTracks.Length; ++t)
            {
                RGBTrack trackT = rgbTracks[t];
                for (int r = t + 1; r < rgbTracks.Length; ++r)
                {
                    RGBTrack trackR = rgbTracks[r];

                    // Only try to collapse tracks that are not exactly the same
                    if (!trackT.Equals(trackR))
                    {
                        if (trackR.keyFrameCount == trackT.keyFrameCount)
                        {
                            // Compare actual keyframes
                            bool kfEquals = true;
                            for (int k = 0; k < trackR.keyFrameCount; ++k)
                            {
                                var kfRk = trackR.GetKeyframe(this, (ushort)k);
                                var kfTk = trackT.GetKeyframe(this, (ushort)k);
                                if (!kfRk.Equals(kfTk))
                                {
                                    kfEquals = false;
                                    break;
                                }
                            }

                            if (kfEquals)
                            {
                                // Sweet, we can compress the keyframes
                                // Fix up any other tracks
                                for (int i = 0; i < rgbTracks.Length; ++i)
                                {
                                    RGBTrack tr = rgbTracks[i];
                                    if (tr.keyframesOffset > trackR.keyframesOffset)
                                    {
                                        tr.keyframesOffset -= trackR.keyFrameCount;
                                        rgbTracks[i]        = tr;
                                    }
                                }

                                // Remove the duplicate keyframes
                                var newKeyframes = new RGBKeyframe[keyframes.Length - trackR.keyFrameCount];
                                for (int i = 0; i < trackR.keyframesOffset; ++i)
                                {
                                    newKeyframes[i] = keyframes[i];
                                }
                                for (int i = trackR.keyframesOffset + trackR.keyFrameCount; i < keyframes.Length; ++i)
                                {
                                    newKeyframes[i - trackR.keyFrameCount] = keyframes[i];
                                }
                                keyframes = newKeyframes;

                                // And make R point to the keyframes of T
                                trackR.keyframesOffset = trackT.keyframesOffset;
                                rgbTracks[r]           = trackR;
                            }
                        }
                    }
                }
            }

            // Then remove duplicate RGB tracks
            for (int t = 0; t < rgbTracks.Length; ++t)
            {
                ref RGBTrack trackT = ref rgbTracks[t];
                for (int r = t + 1; r < rgbTracks.Length; ++r)
                {
                    ref RGBTrack trackR = ref rgbTracks[r];
                    if (trackR.Equals(trackT))
                    {
                        // Remove track R and fix anim tracks
                        // Fix up other animation tracks
                        for (int j = 0; j < tracks.Length; ++j)
                        {
                            ref AnimationTrack trj = ref tracks[j];
                            if (trj.trackOffset == r)
                            {
                                trj.trackOffset = (ushort)t;
                            }
                            else if (trj.trackOffset > r)
                            {
                                trj.trackOffset--;
                            }
                        }

                        // Remove the duplicate RGBTrack
                        var newRGBTracks = new RGBTrack[rgbTracks.Length - 1];
                        for (int j = 0; j < r; ++j)
                        {
                            newRGBTracks[j] = rgbTracks[j];
                        }
                        for (int j = r + 1; j < rgbTracks.Length; ++j)
                        {
                            newRGBTracks[j - 1] = rgbTracks[j];
                        }
                        rgbTracks = newRGBTracks;
                    }