예제 #1
0
        public void SetFormat(int index, AnimDataFormat format)
        {
            switch (index)
            {
            case 0: ScaleDataFormat = format; break;

            case 1: RotationDataFormat = format; break;

            case 2: TranslationDataFormat = format; break;
            }
        }
예제 #2
0
        public static void EncodeCHR0Keyframes(KeyframeCollection kf, VoidPtr entryAddress, VoidPtr dataAddress)
        {
            AnimationCode code = kf._evalCode;
            //VoidPtr dataAddr = addr + 8;

            CHR0Entry *header = (CHR0Entry *)entryAddress;

            header->_code         = (uint)code._data;
            header->_stringOffset = 0;

            //entryAddress += 8;
            bint *pOffset = (bint *)entryAddress + 2;

            //Write values/offset and encode groups
            for (int i = 0, x = 0; i < 3; i++, x += 3)
            {
                if (code.GetExists(i))
                {
                    AnimDataFormat format = code.GetFormat(i);
                    if ((i == 0) && (code.GetIsIsotropic(i)))
                    {
                        if (code.GetIsFixed(2))
                        {
                            *(bfloat *)pOffset++ = kf._keyRoots[2]._next._value;
                        }
                        else
                        {
                            *pOffset++ = (int)(dataAddress - entryAddress);
                            dataAddress += EncodeEntry(x, format, kf, dataAddress);
                        }
                    }
                    else
                    {
                        for (int y = 0, z = x; y < 3; y++, z++)
                        {
                            if (code.GetIsFixed(z))
                            {
                                *(bfloat *)pOffset++ = kf._keyRoots[z]._next._value;
                            }
                            else
                            {
                                *pOffset++ = (int)(dataAddress - entryAddress);
                                dataAddress += EncodeEntry(z, format, kf, dataAddress);
                            }
                        }
                    }
                }
            }
        }
예제 #3
0
 public void SetFormat(int index, AnimDataFormat format)
 {
     if (index == 0)
     {
         _data = (_data & 0xF9FFFFFF) | ((uint)format << 25);
     }
     else if (index == 1)
     {
         _data = (_data & 0xC7FFFFFF) | ((uint)format << 27);
     }
     else
     {
         _data = (_data & 0x3FFFFFFF) | ((uint)format << 30);
     }
 }
예제 #4
0
        private static int EvaluateCHR0Group(ref AnimationCode code, KeyframeCollection kf, int group,
                                             ref int entrySize)
        {
            int index     = group * 3;
            int numFrames = kf.FrameLimit;
            int dataLen   = 0;
            int maxEntries;
            int evalCount;
            int scaleSpan;
            //bool useLinear = group == 1;

            bool           exist     = false;
            bool           isotropic = group == 0;
            AnimDataFormat format    = AnimDataFormat.None;

            KeyframeEntry[] roots = new KeyframeEntry[3];

            KeyframeEntry[][] arr        = new KeyframeEntry[3][];
            int[]             count      = new int[3];
            bool[]            isExist    = new bool[3];
            bool[]            isFixed    = new bool[3];
            bool[]            isScalable = new bool[3];
            float[]           floor      = new float[3];
            float[]           ceil       = new float[3];

            KeyframeEntry entry;
            int           eCount = 0;

            float min;
            float max;
            int   maxIndex = 0;

            //Initialize values
            for (int i = 0; i < 3; i++)
            {
                entry      = roots[i] = kf._keyArrays[index + i]._keyRoot;
                count[i]   = kf._keyArrays[index + i]._keyCount;
                isExist[i] = count[i] > 0;
                isFixed[i] = count[i] <= 1;

                if (!isFixed[i])
                {
                    min = float.MaxValue;
                    max = float.MinValue;

                    for (entry = entry._next; entry._index != -1; entry = entry._next)
                    {
                        min = Math.Min(entry._value, min);
                        max = Math.Max(entry._value, max);
                    }

                    floor[i] = min;
                    ceil[i]  = max;

                    maxIndex = Math.Max(entry._prev._index, maxIndex);
                }
            }

            if (exist = isExist[0] || isExist[1] || isExist[2])
            {
                if (group == 0)
                {
                    if (isFixed[0] != isFixed[1] || isFixed[0] != isFixed[2])
                    {
                        isotropic = false;
                    }
                    else if (count[0] != count[1] || count[0] != count[2])
                    {
                        isotropic = false;
                    }
                    else
                    {
                        KeyframeEntry e1 = roots[0], e2 = roots[1], e3 = roots[2];
                        for (int i = count[0]; i-- > 0;)
                        {
                            e1 = e1._next;
                            e2 = e2._next;
                            e3 = e3._next;
                            if (e1._index != e2._index || e1._index != e3._index ||
                                e1._value != e2._value || e1._value != e3._value)
                            {
                                isotropic = false;
                                break;
                            }
                        }
                    }
                }

                if (isotropic)
                {
                    evalCount  = 1;
                    maxEntries = count[0];
                }
                else
                {
                    evalCount  = 3;
                    maxEntries = Math.Max(Math.Max(count[0], count[1]), count[2]);
                    //useLinear &= (count[0] == numFrames) && (count[1] == numFrames) && (count[2] == numFrames);
                }

                scaleSpan = @group == 1 ? 255 : maxIndex <= 255 ? 4095 : maxIndex <= 2047 ? 65535 : -1;
                //scaleSpan = useLinear ? 255 : 4095;

                //Determine if values are scalable
                for (int i = 0; i < evalCount; i++)
                {
                    isScalable[i] = true;
                    if (isFixed[i] || scaleSpan == -1)
                    {
                        continue;
                    }

                    //float* pValue = value[i];
                    eCount = count[i];

                    float basev, range, step, distance, val;

                    basev = floor[i];
                    range = ceil[i] - basev;


                    //Evaluate spans until we reach a success.
                    //A success means that compression using that span is possible.
                    //No further evaluation necessary.
SpanBegin:
                    int span = scaleSpan;
                    int spanEval = scaleSpan - 32;

                    float tanScale = scaleSpan == 4095 ? 32.0f : 256.0f;
                    if (scaleSpan != 255)
                    {
                        for (entry = roots[i]._next; entry._index != -1; entry = entry._next)
                        {
                            //Ignore entries that don't need interp.
                            if (entry._index - entry._prev._index >= 1 && entry._prev._index != -1 ||
                                entry._next._index - entry._index >= 1 && entry._next._index != -1)
                            {
                                val  = entry._tangent * tanScale;
                                val += val < 0 ? -0.5f : 0.5f;
                                if (Math.Abs((int)val / tanScale - entry._tangent) > tanError)
                                {
                                    span = spanEval;
                                    break;
                                }
                            }
                        }
                    }

                    if (span > spanEval && range == 0.0f)
                    {
                        continue;
                    }

SpanStep:
                    if (span > spanEval)
                    {
                        step = range / span;

                        //if span <= 255, check every frame instead!
                        if (span <= 255)
                        {
                            for (int x = 0; x < numFrames; x++)
                            {
                                val      = kf[x, index + i];
                                distance = (val - basev) / step + 0.5f;
                                distance = Math.Abs(val - (basev + (int)distance * step));

                                //If distance is too large change span and retry
                                if (distance > scaleError)
                                {
                                    span--;
                                    goto SpanStep;
                                }
                            }
                        }
                        else
                        {
                            for (entry = roots[i]._next; entry._index != -1; entry = entry._next)
                            {
                                val      = entry._value;
                                distance = (val - basev) / step + 0.5f;
                                distance = Math.Abs(val - (basev + (int)distance * step));

                                //If distance is too large change span and retry
                                if (distance > scaleError)
                                {
                                    span--;
                                    goto SpanStep;
                                }
                            }
                        }
                    }
                    else
                    {
                        if (scaleSpan <= 255 && maxIndex <= 255)
                        {
                            scaleSpan = 4095;
                        }
                        else if (scaleSpan <= 4095 && maxIndex <= 2047)
                        {
                            scaleSpan = 65535;
                        }
                        else
                        {
                            scaleSpan     = -1;
                            isScalable[i] = false;
                            continue;
                        }

                        goto SpanBegin;
                    }
                }

                //Determine format only if there are unfixed entries
                if (!isFixed[0] || !isFixed[1] || !isFixed[2])
                {
                    bool  scale     = isotropic ? isScalable[0] : isScalable[0] && isScalable[1] && isScalable[2];
                    float frameSpan = (float)numFrames / maxEntries;

                    if (scale)
                    {
                        if (@group == 1 && scaleSpan <= 255 && frameSpan < 4.0f)
                        {
                            format = AnimDataFormat.L1;
                        }
                        else if (scaleSpan <= 4095 && maxIndex <= 255)
                        {
                            format = AnimDataFormat.I4;
                        }
                        else if (frameSpan > 1.5f && maxIndex <= 2047)
                        {
                            format = AnimDataFormat.I6;
                        }
                        else if (@group == 1 && frameSpan <= 3.0f)
                        {
                            format = AnimDataFormat.L4;
                        }
                        else
                        {
                            format = AnimDataFormat.I12;
                        }
                    }
                    else if (@group == 1 && frameSpan <= 3.0f)
                    {
                        format = AnimDataFormat.L4;
                    }
                    else
                    {
                        format = AnimDataFormat.I12;
                    }
                }

                //calculate size
                for (int i = 0; i < evalCount; i++)
                {
                    entrySize += 4;

                    if (!isFixed[i])
                    {
                        switch (format)
                        {
                        case AnimDataFormat.I12:
                            dataLen += 8 + count[i] * 12;
                            break;

                        case AnimDataFormat.I4:
                            dataLen += 16 + count[i] * 4;
                            break;

                        case AnimDataFormat.I6:
                            dataLen += (16 + count[i] * 6).Align(4);
                            break;

                        case AnimDataFormat.L1:
                            dataLen += (8 + numFrames).Align(4);
                            break;

                        case AnimDataFormat.L4:
                            dataLen += numFrames * 4;
                            break;
                        }
                    }
                }

                //Should we compress here?
            }
            else //Set isotropic to true, so it sets the default value.
            {
                isotropic = true;
            }

            if (group == 0)
            {
                code.IgnoreScale = !exist;
            }

            code.SetExists(group, exist);
            code.SetIsIsotropic(group, isotropic);
            for (int i = 0; i < 3; i++)
            {
                code.SetIsFixed(index + i, isFixed[i]);
            }

            code.SetFormat(group, format);

            return(dataLen);
        }
예제 #5
0
        private static void DecodeFrames(KeyframeCollection kf, void *dataAddr, AnimDataFormat format,
                                         params int[] arrays)
        {
            int   fCount;
            float vStep, vBase;

            switch (format)
            {
            case AnimDataFormat.I4:
            {
                I4Header *header = (I4Header *)dataAddr;
                fCount = header->_entries;
                vStep  = header->_step;
                vBase  = header->_base;

                foreach (int x in arrays)
                {
                    I4Entry *entry = header->Data;
                    for (int i = 0; i < fCount; i++, entry++)
                    {
                        kf.SetFrameValue(x, entry->FrameIndex, vBase + entry->Step * vStep, true)._tangent =
                            entry->Tangent;
                    }
                }

                break;
            }

            case AnimDataFormat.I6:
            {
                I6Header *header = (I6Header *)dataAddr;
                fCount = header->_numFrames;
                vStep  = header->_step;
                vBase  = header->_base;

                foreach (int x in arrays)
                {
                    I6Entry *entry = header->Data;
                    for (int i = 0; i < fCount; i++, entry++)
                    {
                        kf.SetFrameValue(x, entry->FrameIndex, vBase + entry->_step * vStep, true)._tangent =
                            entry->Tangent;
                    }
                }

                break;
            }

            case AnimDataFormat.I12:
            {
                I12Header *header = (I12Header *)dataAddr;
                fCount = header->_numFrames;

                foreach (int x in arrays)
                {
                    I12Entry *entry = header->Data;
                    for (int i = 0; i < fCount; i++, entry++)
                    {
                        kf.SetFrameValue(x, (int)entry->_index, entry->_value, true)._tangent = entry->_tangent;
                    }
                }

                break;
            }

            case AnimDataFormat.L1:
            {
                L1Header *header = (L1Header *)dataAddr;
                vStep = header->_step;
                vBase = header->_base;

                foreach (int x in arrays)
                {
                    byte *sPtr = header->Data;
                    for (int i = 0; i < kf.FrameLimit; i++)
                    {
                        kf.SetFrameValue(x, i, vBase + *sPtr++ *vStep, true).GenerateTangent();
                    }
                }

                break;
            }

            case AnimDataFormat.L2:
            {
                L1Header *header = (L1Header *)dataAddr;
                vStep = header->_step;
                vBase = header->_base;

                foreach (int x in arrays)
                {
                    bushort *sPtr = (bushort *)header->Data;
                    for (int i = 0; i < kf.FrameLimit; i++)
                    {
                        kf.SetFrameValue(x, i, vBase + *sPtr++ *vStep, true).GenerateTangent();
                    }
                }

                break;
            }

            case AnimDataFormat.L4:
            {
                foreach (int x in arrays)
                {
                    bfloat *sPtr = (bfloat *)dataAddr;
                    for (int i = 0; i < kf.FrameLimit; i++)
                    {
                        kf.SetFrameValue(x, i, *sPtr++, true).GenerateTangent();
                    }
                }

                break;
            }
            }
        }
예제 #6
0
        private static int EncodeEntry(int index, AnimDataFormat format, KeyframeCollection kf, VoidPtr addr)
        {
            int           numFrames = kf.FrameLimit;
            KeyframeEntry frame, root = kf._keyArrays[index]._keyRoot;
            bfloat *      pVal = (bfloat *)addr;
            float         val, frameScale = numFrames <= 1 ? 1 : 1.0f / (numFrames - 1);
            float         min, max, stride, step;
            int           span, i;
            int           keyCount = kf._keyArrays[index]._keyCount;

            if (format == AnimDataFormat.L4)
            {
                //Use all frames, just in case not all frames are key.
                for (i = 0; i < numFrames; i++)
                {
                    *pVal++ = kf[i, index];
                }

                return(numFrames * 4);
            }

            if (format == AnimDataFormat.I12)
            {
                I12Header *header = (I12Header *)addr;
                *          header = new I12Header(keyCount, frameScale);

                I12Entry *entry = header->Data;
                for (frame = root._next; frame._index != -1; frame = frame._next)
                {
                    *entry++ = new I12Entry(frame._index, frame._value, frame._tangent);
                }

                return(keyCount * 12 + 8);
            }

            //Get floor/ceil/stride
            min = float.MaxValue;
            max = float.MinValue;
            for (frame = root._next; frame != root; frame = frame._next)
            {
                val = frame._value;

                if (val > max)
                {
                    max = val;
                }

                if (val < min)
                {
                    min = val;
                }
            }

            stride = max - min;

            if (format == AnimDataFormat.L1)
            {
                //Find best span
                span = EvalSpan(255, 32, min, stride, root, true);
                step = stride / span;

                L1Header *header = (L1Header *)addr;
                *         header = new L1Header(step, min);

                byte *dPtr = header->Data;
                for (i = 0; i < numFrames; i++)
                {
                    *dPtr++ = (byte)((kf[i, index] - min) / step + 0.5f);
                }

                //Fill remaining bytes
                while ((i++ & 3) != 0)
                {
                    *dPtr++ = 0;
                }

                return((8 + numFrames).Align(4));
            }

            if (format == AnimDataFormat.I4)
            {
                //Find best span
                span = EvalSpan(4095, 32, min, stride, root, false);
                step = stride / span;

                I4Header *header = (I4Header *)addr;
                *         header = new I4Header(keyCount, frameScale, step, min);

                I4Entry *entry = header->Data;

                for (frame = root._next; frame._index != -1; frame = frame._next)
                {
                    val  = (frame._value - min) / step;
                    val += val < 0 ? -0.5f : 0.5f;

                    *entry++ = new I4Entry(frame._index, (int)val, frame._tangent);
                }

                return(keyCount * 4 + 16);
            }

            if (format == AnimDataFormat.I6)
            {
                //Find best span
                span = EvalSpan(65535, 32, min, stride, root, false);
                step = stride / span;

                I6Header *header = (I6Header *)addr;
                *         header = new I6Header(keyCount, frameScale, step, min);

                I6Entry *entry = header->Data;

                for (frame = root._next; frame._index != -1; frame = frame._next)
                {
                    val  = (frame._value - min) / step;
                    val += val < 0 ? -0.5f : 0.5f;

                    *entry++ = new I6Entry(frame._index, (int)val, frame._tangent);
                }

                //Fill remaining bytes
                if ((keyCount & 1) != 0)
                {
                    entry->_data = 0;
                }

                return((keyCount * 6 + 16).Align(4));
            }

            return(0);
        }
예제 #7
0
        private static void DecodeCHR0Frames(KeyframeCollection kf, void *dataAddr, AnimDataFormat format, KeyFrameMode mode)
        {
            int   fCount;
            float vStep, vBase;

            switch (format)
            {
            case AnimDataFormat.I4:
            {
                I4Header *header = (I4Header *)dataAddr;
                fCount = header->_entries;
                vStep  = header->_step;
                vBase  = header->_base;

                I4Entry *entry = header->Data;
                for (int i = 0; i < fCount; i++, entry++)
                {
                    kf.SetFrameValue(mode, entry->FrameIndex, vBase + (entry->Step * vStep))._tangent = entry->Tangent;
                }
                break;
            }

            case AnimDataFormat.I6:
            {
                I6Header *header = (I6Header *)dataAddr;
                fCount = header->_numFrames;
                vStep  = header->_step;
                vBase  = header->_base;

                I6Entry *entry = header->Data;
                for (int i = 0; i < fCount; i++, entry++)
                {
                    kf.SetFrameValue(mode, entry->FrameIndex, vBase + (entry->_step * vStep))._tangent = entry->Tangent;
                }
                break;
            }

            case AnimDataFormat.I12:
            {
                I12Header *header = (I12Header *)dataAddr;
                fCount = header->_numFrames;

                I12Entry *entry = header->Data;
                for (int i = 0; i < fCount; i++, entry++)
                {
                    kf.SetFrameValue(mode, (int)entry->_index, entry->_value)._tangent = entry->_tangent;
                }
                break;
            }

            case AnimDataFormat.L1:
            {
                L1Header *header = (L1Header *)dataAddr;
                vStep = header->_step;
                vBase = header->_base;

                byte *sPtr = header->Data;
                for (int i = 0; i < kf.FrameCount; i++)
                {
                    kf[mode, i] = vBase + (*sPtr++ *vStep);
                }

                KeyframeEntry root = kf._keyRoots[(int)mode & 0xF];
                for (KeyframeEntry entry = root._next; entry != root; entry = entry._next)
                {
                    entry.GenerateTangent();
                }

                break;
            }

            case AnimDataFormat.L2:
            {
                L1Header *header = (L1Header *)dataAddr;
                vStep = header->_step;
                vBase = header->_base;

                bushort *sPtr = (bushort *)header->Data;
                for (int i = 0; i < kf.FrameCount; i++)
                {
                    kf[mode, i] = vBase + (*sPtr++ *vStep);
                }

                KeyframeEntry root = kf._keyRoots[(int)mode & 0xF];
                for (KeyframeEntry entry = root._next; entry != root; entry = entry._next)
                {
                    entry.GenerateTangent();
                }

                break;
            }

            case AnimDataFormat.L4:
            {
                bfloat *sPtr = (bfloat *)dataAddr;

                for (int i = 0; i < kf.FrameCount; i++)
                {
                    kf[mode, i] = *sPtr++;
                }

                KeyframeEntry root = kf._keyRoots[(int)mode & 0xF];
                for (KeyframeEntry entry = root._next; entry != root; entry = entry._next)
                {
                    entry.GenerateTangent();
                }

                break;
            }
            }
        }
        private static int EncodeEntry(int index, AnimDataFormat format, KeyframeCollection kf, VoidPtr addr)
        {
            int numFrames = kf._frameCount;
            KeyframeEntry frame, root = kf._keyRoots[index];
            bfloat* pVal = (bfloat*)addr;
            float val, frameScale = numFrames <= 1 ? 1 : 1.0f / (numFrames - 1);
            float min, max, stride, step;
            int span, i;
            int keyCount = kf._keyCounts[index];
            KeyFrameMode mode = KeyFrameMode.ScaleX + index;

            if (format == AnimDataFormat.L4)
            {
                //Use all frames, just in case not all frames are key.
                for (i = 0; i < numFrames; i++)
                    *pVal++ = kf[mode, i];
                return numFrames * 4;
            }

            if (format == AnimDataFormat.I12)
            {
                I12Header* header = (I12Header*)addr;
                *header = new I12Header(keyCount, frameScale);

                I12Entry* entry = header->Data;
                for (frame = root._next; frame._index != -1; frame = frame._next)
                    *entry++ = new I12Entry(frame._index, frame._value, frame._tangent);

                return keyCount * 12 + 8;
            }

            //Get floor/ceil/stride
            min = float.MaxValue; max = float.MinValue;
            for (frame = root._next; frame != root; frame = frame._next)
            {
                val = frame._value;

                if (val > max) max = val;
                if (val < min) min = val;
            }
            stride = max - min;

            if (format == AnimDataFormat.L1)
            {
                //Find best span
                span = EvalSpan(255, 32, min, stride, root, true, kf._linearRot);
                step = stride / span;

                L1Header* header = (L1Header*)addr;
                *header = new L1Header(step, min);

                byte* dPtr = header->Data;
                for (i = 0; i < numFrames; i++)
                    *dPtr++ = (byte)((kf[mode, i] - min) / step + 0.5f);

                //Fill remaining bytes
                while ((i++ & 3) != 0)
                    *dPtr++ = 0;

                return (8 + numFrames).Align(4);
            }

            if (format == AnimDataFormat.I4)
            {
                //Find best span
                span = EvalSpan(4095, 32, min, stride, root, false, false);
                step = stride / span;

                I4Header* header = (I4Header*)addr;
                *header = new I4Header(keyCount, frameScale, step, min);

                I4Entry* entry = header->Data;

                for (frame = root._next; frame._index != -1; frame = frame._next)
                {
                    val = (frame._value - min) / step;
                    val += (val < 0 ? -0.5f : 0.5f);

                    *entry++ = new I4Entry(frame._index, (int)val, frame._tangent);
                }

                return keyCount * 4 + 16;
            }

            if (format == AnimDataFormat.I6)
            {
                //Find best span
                span = EvalSpan(65535, 32, min, stride, root, false, false);
                step = stride / span;

                I6Header* header = (I6Header*)addr;
                *header = new I6Header(keyCount, frameScale, step, min);

                I6Entry* entry = header->Data;

                for (frame = root._next; frame._index != -1; frame = frame._next)
                {
                    val = ((frame._value - min) / step);
                    val += (val < 0 ? -0.5f : 0.5f);

                    *entry++ = new I6Entry(frame._index, (int)val, frame._tangent);
                }

                //Fill remaining bytes
                if ((keyCount & 1) != 0)
                    entry->_data = 0;

                return ((keyCount * 6) + 16).Align(4);
            }

            return 0;
        }
        private static void DecodeCHR0Frames(KeyframeCollection kf, void* dataAddr, AnimDataFormat format, KeyFrameMode mode)
        {
            int fCount;
            float vStep, vBase;
            switch (format)
            {
                case AnimDataFormat.I4:
                    {
                        I4Header* header = (I4Header*)dataAddr;
                        fCount = header->_entries;
                        vStep = header->_step;
                        vBase = header->_base;

                        I4Entry* entry = header->Data;
                        for (int i = 0; i < fCount; i++, entry++)
                            kf.SetFrameValue(mode, entry->FrameIndex, vBase + (entry->Step * vStep))._tangent = entry->Tangent;
                        break;
                    }
                case AnimDataFormat.I6:
                    {
                        I6Header* header = (I6Header*)dataAddr;
                        fCount = header->_numFrames;
                        vStep = header->_step;
                        vBase = header->_base;

                        I6Entry* entry = header->Data;
                        for (int i = 0; i < fCount; i++, entry++)
                            kf.SetFrameValue(mode, entry->FrameIndex, vBase + (entry->_step * vStep))._tangent = entry->Tangent;
                        break;
                    }
                case AnimDataFormat.I12:
                    {
                        I12Header* header = (I12Header*)dataAddr;
                        fCount = header->_numFrames;

                        I12Entry* entry = header->Data;
                        for (int i = 0; i < fCount; i++, entry++)
                            kf.SetFrameValue(mode, (int)entry->_index, entry->_value)._tangent = entry->_tangent;
                        break;
                    }
                case AnimDataFormat.L1:
                    {
                        L1Header* header = (L1Header*)dataAddr;
                        vStep = header->_step;
                        vBase = header->_base;

                        byte* sPtr = header->Data;
                        for (int i = 0; i < kf.FrameCount; i++)
                            kf[mode, i] = vBase + (*sPtr++ * vStep);

                        KeyframeEntry root = kf._keyRoots[(int)mode & 0xF];
                        for (KeyframeEntry entry = root._next; entry != root; entry = entry._next)
                            entry.GenerateTangent();

                        break;
                    }
                case AnimDataFormat.L2:
                    {
                        L1Header* header = (L1Header*)dataAddr;
                        vStep = header->_step;
                        vBase = header->_base;

                        bushort* sPtr = (bushort*)header->Data;
                        for (int i = 0; i < kf.FrameCount; i++)
                            kf[mode, i] = vBase + (*sPtr++ * vStep);

                        KeyframeEntry root = kf._keyRoots[(int)mode & 0xF];
                        for (KeyframeEntry entry = root._next; entry != root; entry = entry._next)
                            entry.GenerateTangent();

                        break;
                    }
                case AnimDataFormat.L4:
                    {
                        bfloat* sPtr = (bfloat*)dataAddr;

                        for (int i = 0; i < kf.FrameCount; i++)
                            kf[mode, i] = *sPtr++;

                        KeyframeEntry root = kf._keyRoots[(int)mode & 0xF];
                        for (KeyframeEntry entry = root._next; entry != root; entry = entry._next)
                            entry.GenerateTangent();

                        break;
                    }
            }
        }