Beispiel #1
0
        public static unsafe int GetBrightness(Texture tex, int xStart, int yStart, int xStep, int yStep, int count)
        {
            LockData data  = tex.Lock(LockFlags.ReadOnly);
            short *  pvSrc = (short *)data.pvSrc;
            int      num   = data.Pitch >> 1;

            pvSrc += yStart * num;
            pvSrc += xStart;
            num   *= yStep;
            num   += xStep;
            int num2 = 0;

            for (int i = 0; i < count; i++)
            {
                short num4 = pvSrc[0];
                num2  += (num4 & 0x1f) * 0x72;
                num2  += ((num4 >> 5) & 0x1f) * 0x24b;
                num2  += ((num4 >> 10) & 0x1f) * 0x12b;
                pvSrc += num;
            }
            tex.Unlock();
            num2  = num2 << 3;
            num2 /= count;
            return(num2 / 0x3e8);
        }
Beispiel #2
0
        protected unsafe Texture Construct(bool isReconstruct)
        {
            int num;
            int num2;

            if (!this.CoreLookup())
            {
                return(Texture.Empty);
            }
            this.CoreGetDimensions(out num, out num2);
            Texture tex = new Texture(num, num2, true, 0x19, 1, isReconstruct);

            if (tex.IsEmpty())
            {
                return(Texture.Empty);
            }
            LockData data = tex.Lock(LockFlags.WriteOnly);

            this.CoreProcessImage(data.Width, data.Height, data.Pitch, (ushort *)data.pvSrc, (ushort *)(data.pvSrc + (data.Width * 2)), (ushort *)(data.pvSrc + (data.Height * data.Pitch)), (data.Pitch >> 1) - data.Width, data.Pitch >> 1);
            tex.Unlock();
            this.CoreAssignArgs(tex);
            this.m_Textures.Add(tex);
            return(tex);
        }
Beispiel #3
0
        unsafe Texture IFontFactory.CreateInstance(string text, IHue hue)
        {
            int       num;
            char      ch;
            FontImage image;

            if ((text == null) || (text.Length <= 0))
            {
                return(Texture.Empty);
            }
            int yHeight = 0;
            int num3    = 0;
            int width   = 0;
            int height  = 1;

            char[] chArray = text.ToCharArray();
            for (num = 0; num < chArray.Length; num++)
            {
                ch = chArray[num];
                if ((ch >= ' ') && (ch < 'Ā'))
                {
                    image = this.m_Images[ch - ' '];
                    num3 += image.xWidth;
                    if (num3 > width)
                    {
                        width = num3;
                    }
                    if (image.yHeight > yHeight)
                    {
                        yHeight = image.yHeight;
                    }
                }
                else if (ch == '\n')
                {
                    num3 = 0;
                    height++;
                }
            }
            height *= yHeight;
            if ((width <= 0) || (height <= 0))
            {
                return(Texture.Empty);
            }
            Texture texture = new Texture(width, height, false);

            if (texture.IsEmpty())
            {
                return(Texture.Empty);
            }
            short[] numArray = new short[this.m_Palette.Length];
            fixed(short *numRef = numArray)
            {
                fixed(short *numRef2 = this.m_Palette)
                {
                    hue.CopyPixels((void *)(numRef2 + 1), (void *)(numRef + 1), this.m_Palette.Length - 1);
                }

                LockData data    = texture.Lock(LockFlags.WriteOnly);
                short *  pvSrc   = (short *)data.pvSrc;
                short *  numPtr2 = pvSrc;
                int      num6    = data.Pitch >> 1;
                int      num7    = num6 * yHeight;

                for (num = 0; num < chArray.Length; num++)
                {
                    ch = chArray[num];
                    if ((ch >= ' ') && (ch < 'Ā'))
                    {
                        image = this.m_Images[ch - ' '];
                        int    xWidth  = image.xWidth;
                        int    num11   = image.yHeight;
                        short *numPtr3 = numPtr2;
                        numPtr3 += (yHeight - num11) * num6;
                        int num8 = num6 - xWidth;
                        int num9 = image.xDelta - xWidth;
                        fixed(byte *numRef3 = image.xyPixels)
                        {
                            byte *numPtr4 = numRef3;
                            int   num12   = 0;

                            while (num12 < num11)
                            {
                                int num13 = xWidth >> 2;
                                int num14 = xWidth & 3;
                                while (--num13 >= 0)
                                {
                                    numPtr3[0] = numRef[numPtr4[0]];
                                    numPtr3[1] = numRef[numPtr4[1]];
                                    numPtr3[2] = numRef[numPtr4[2]];
                                    numPtr3[3] = numRef[numPtr4[3]];
                                    numPtr3   += 4;
                                    numPtr4   += 4;
                                }
                                while (--num14 >= 0)
                                {
                                    numPtr3++;
                                    numPtr3[0] = numRef[*(numPtr4++)];
                                }
                                num12++;
                                numPtr3 += num8;
                                numPtr4 += num9;
                            }
                        }

                        numPtr2 += image.xWidth;
                    }
                    else if (ch == '\n')
                    {
                        pvSrc  += num7;
                        numPtr2 = pvSrc;
                    }
                }
                texture.Unlock();
                return(texture);
            }
        }
Beispiel #4
0
 public unsafe void Apply(LockData ld)
 {
     ushort* pvSrc = (ushort*) ld.pvSrc;
     int height = ld.Height;
     int width = ld.Width;
     int num3 = 0;
     int num4 = (ld.Pitch >> 1) - width;
     fixed (ushort* numRef = this.m_Colors)
     {
         ushort* numPtr2 = numRef;
         while (--height >= 0)
         {
             num3 = width;
             while (--num3 >= 0)
             {
                 pvSrc++;
                 pvSrc[0] = numPtr2[pvSrc[0]];
             }
             pvSrc += num4;
         }
     }
 }
Beispiel #5
0
 public void Apply(LockData ld)
 {
     throw new InvalidOperationException();
 }
Beispiel #6
0
 public void Apply(LockData ld)
 {
 }
Beispiel #7
0
 public unsafe void Apply(LockData ld)
 {
     ushort* pvSrc = (ushort*) ld.pvSrc;
     int height = ld.Height;
     int width = ld.Width;
     int num3 = 0;
     int num4 = (ld.Pitch >> 1) - width;
     fixed (ushort* numRef = this.m_Data.colors)
     {
         ushort* numPtr2 = numRef;
         goto Label_0092;
     Label_0043:
         num3 = width;
         while (--num3 >= 0)
         {
             ushort num5 = pvSrc[0];
             if (((num5 & 0x1f) == ((num5 >> 5) & 0x1f)) && ((num5 & 0x1f) == ((num5 >> 10) & 0x1f)))
             {
                 pvSrc[0] = numPtr2[num5 >> 10];
             }
             pvSrc++;
         }
         pvSrc += num4;
     Label_008A:
         if (--height >= 0)
         {
             goto Label_0043;
         }
     Label_0092:
         if (--height >= 0)
         {
             goto Label_008A;
         }
     }
 }
Beispiel #8
0
 public unsafe void Apply(LockData ld)
 {
     ushort* pvSrc = (ushort*) ld.pvSrc;
     int num = ld.Height * (ld.Pitch >> 1);
     while (num-- != 0)
     {
         ushort color = pvSrc[0];
         if ((color & 0x8000) != 0x8000)
         {
             pvSrc++;
         }
         else
         {
             int num3 = (int) (Engine.GrayScale(color) * 1.15);
             if (num3 > 0x1f)
             {
                 num3 = 0x1f;
             }
             pvSrc++;
             pvSrc[0] = (ushort) (((num3 | (num3 << 5)) | (num3 << 10)) | (color & 0x8000));
         }
     }
 }
Beispiel #9
0
        private static unsafe void Load(int x, int y, int w, int h, int world, Texture tex)
        {
            if (m_Colors == null)
            {
                LoadColors();
            }
            if ((m_StrongReferences == null) || (m_StrongReferences.Length != (w * h)))
            {
                m_StrongReferences = new MapBlock[w * h];
            }
            if ((m_Guarded == null) || (m_Guarded.Length != ((w * h) * 0x40)))
            {
                m_Guarded = new BitArray((w * h) * 0x40);
            }
            else
            {
                m_Guarded.SetAll(false);
            }
            Region[] guardedRegions = Region.GuardedRegions;
            int      num            = x * 8;
            int      num2           = y * 8;
            int      num3           = w * 8;
            int      num4           = h * 8;

            for (int i = 0; i < guardedRegions.Length; i++)
            {
                Region      region = guardedRegions[i];
                RegionWorld world2 = region.World;
                bool        flag   = false;
                switch (world2)
                {
                case RegionWorld.Britannia:
                    flag = (world == 0) || (world == 1);
                    break;

                case RegionWorld.Felucca:
                    flag = world == 0;
                    break;

                case RegionWorld.Trammel:
                    flag = world == 1;
                    break;

                case RegionWorld.Ilshenar:
                    flag = world == 2;
                    break;

                case RegionWorld.Malas:
                    flag = world == 3;
                    break;

                case RegionWorld.Tokuno:
                    flag = world == 4;
                    break;
                }
                if (flag)
                {
                    int num6 = region.X - num;
                    int num7 = region.Y - num2;
                    if (((num6 < num3) && (num7 < num4)) && ((num6 > -region.Width) && (num7 > -region.Height)))
                    {
                        int num8 = num6 + region.Width;
                        int num9 = num7 + region.Height;
                        if (num6 < 0)
                        {
                            num6 = 0;
                        }
                        if (num7 < 0)
                        {
                            num7 = 0;
                        }
                        for (int j = num6; (j < num8) && (j < num3); j++)
                        {
                            for (int k = num7; (k < num9) && (k < num4); k++)
                            {
                                m_Guarded[(k * num3) + j] = true;
                            }
                        }
                    }
                }
            }
            TileMatrix matrix = Map.GetMatrix(world);
            LockData   data   = tex.Lock(LockFlags.WriteOnly);
            int        num12  = data.Pitch >> 1;

            fixed(short *numRef = m_Colors)
            {
                for (int m = 0; m < w; m++)
                {
                    short *numPtr = (short *)(data.pvSrc + ((m << 3) * 2));
                    for (int num14 = 0; num14 < h; num14++)
                    {
                        MapBlock block = matrix.GetBlock(x + m, y + num14);
                        m_StrongReferences[(num14 * w) + m] = block;
                        HuedTile[][][] tileArray  = (block == null) ? matrix.EmptyStaticBlock : block.m_StaticTiles;
                        Tile[]         tileArray2 = (block == null) ? matrix.InvalidLandBlock : block.m_LandTiles;
                        int            index      = 0;
                        for (int num16 = 0; index < 8; num16 += 8)
                        {
                            for (int num17 = 0; num17 < 8; num17++)
                            {
                                int num18 = -255;
                                int num19 = -255;
                                int num20 = 0;
                                int hue   = 0;
                                for (int num24 = 0; num24 < tileArray[num17][index].Length; num24++)
                                {
                                    HuedTile tile = tileArray[num17][index][num24];
                                    int      iD   = tile.ID;
                                    switch (iD)
                                    {
                                    case 0x4001:
                                    case 0x5796:
                                    case 0x61a4:
                                    case 0x6198:
                                    case 0x61bc:
                                    case 0x6199:
                                        break;

                                    default:
                                    {
                                        int z     = tile.Z;
                                        int num23 = z + Map.GetHeight(iD);
                                        if ((num23 > num18) || ((z > num19) && (num23 >= num18)))
                                        {
                                            num18 = num23;
                                            num19 = z;
                                            num20 = iD;
                                            hue   = tile.Hue;
                                        }
                                        break;
                                    }
                                    }
                                }
                                if ((tileArray2[num16 + num17].Z > num18) && (tileArray2[num16 + num17].ID != 2))
                                {
                                    num20 = tileArray2[num16 + num17].ID;
                                    hue   = 0;
                                }
                                int num26 = ((((num14 << 3) + index) * num3) + (m << 3)) + num17;
                                if (m_Guarded[num26] && ((((num26 >= 1) && !m_Guarded[num26 - 1]) || ((num26 >= num3) && !m_Guarded[num26 - num3])) || (((num26 < (m_Guarded.Length - 1)) && !m_Guarded[num26 + 1]) || ((num26 < (m_Guarded.Length - num3)) && !m_Guarded[num26 + num3]))))
                                {
                                    numPtr[num17] = -31776;
                                }
                                else if (hue == 0)
                                {
                                    numPtr[num17] = numRef[num20];
                                }
                                else
                                {
                                    numPtr[num17] = (short)Hues.Load((hue & 0x3fff) | 0x8000).Pixel((ushort)numRef[num20]);
                                }
                            }
                            numPtr += num12;
                            index++;
                        }
                    }
                }
                ArrayList items = Engine.Multis.Items;

                for (int n = 0; n < items.Count; n++)
                {
                    Item item = (Item)items[n];
                    if (item.InWorld && item.Visible)
                    {
                        CustomMultiEntry customMulti = CustomMultiLoader.GetCustomMulti(item.Serial, item.Revision);
                        Multi            multi       = null;
                        if (customMulti != null)
                        {
                            multi = customMulti.Multi;
                        }
                        if (multi == null)
                        {
                            multi = item.Multi;
                        }
                        if (multi != null)
                        {
                            short[][] radar = multi.Radar;
                            if (radar != null)
                            {
                                int num28;
                                int num29;
                                int num30;
                                int num31;
                                multi.GetBounds(out num28, out num29, out num30, out num31);
                                int num32 = 0;
                                for (int num33 = (item.Y - (y << 3)) + num29; num32 < radar.Length; num33++)
                                {
                                    if ((num33 >= 0) && (num33 < (h << 3)))
                                    {
                                        short * numPtr2   = (short *)(data.pvSrc + ((num33 * num12) * 2));
                                        short[] numArray2 = radar[num32];
                                        int     num34     = 0;
                                        for (int num35 = (item.X - (x << 3)) + num28; num34 < numArray2.Length; num35++)
                                        {
                                            if (((num35 >= 0) && (num35 < (w << 3))) && (numArray2[num34] != 0))
                                            {
                                                numPtr2[num35] = numRef[numArray2[num34]];
                                            }
                                            num34++;
                                        }
                                    }
                                    num32++;
                                }
                            }
                        }
                    }
                }
            }

            tex.Unlock();
        }
Beispiel #10
0
        protected internal override unsafe void Draw(int X, int Y)
        {
            if (this.m_ScrollTexture == null)
            {
                this.m_ScrollTexture = new Texture(0x10, 0x10, true);
                LockData data = this.m_ScrollTexture.Lock(LockFlags.WriteOnly);
                ushort   num  = Engine.C32216(GumpColors.ControlLightLight);
                ushort   num2 = Engine.C32216(GumpColors.ScrollBar);
                for (int i = 0; i < 0x10; i++)
                {
                    ushort *numPtr = (ushort *)(data.pvSrc + (i * data.Pitch));
                    for (int j = 0; j < 0x10; j++)
                    {
                        if ((((i & 1) + j) & 1) == 0)
                        {
                            numPtr++;
                            numPtr[0] = num;
                        }
                        else
                        {
                            numPtr++;
                            numPtr[0] = num2;
                        }
                    }
                }
                this.m_ScrollTexture.Unlock();
            }
            this.m_ScrollTexture.Draw(X, Y, this.Width, this.Height);
            int barHeight = this.GetBarHeight();
            int num6      = Y + 0x10;
            int num7      = this.Height - 0x20;
            int position  = base.GetPosition(num7 - barHeight);

            Renderer.SetTexture(null);
            if (this.m_State == State.LargeScrollUp)
            {
                if (position > 0)
                {
                    Renderer.SetAlphaEnable(true);
                    Renderer.SetAlpha(0.9f);
                    Renderer.SolidRect(GumpColors.ControlDarkDark, X, Y + this.Width, this.Width, position);
                    Renderer.SetAlphaEnable(false);
                    int num9 = base.PointToClient(new Point(Engine.m_xMouse, Engine.m_yMouse)).Y - 0x10;
                    if (position > num9)
                    {
                        base.Value -= base.LargeOffset;
                    }
                    else
                    {
                        this.m_State = State.Inactive;
                    }
                }
            }
            else if ((this.m_State == State.LargeScrollDown) && (((num7 - position) - barHeight) > 0))
            {
                Renderer.SetAlphaEnable(true);
                Renderer.SetAlpha(0.9f);
                Renderer.SolidRect(GumpColors.ControlDarkDark, X, (num6 + position) + barHeight, this.Width, (num7 - position) - barHeight);
                Renderer.SetAlphaEnable(false);
                int num10 = base.PointToClient(new Point(Engine.m_xMouse, Engine.m_yMouse)).Y - 0x10;
                if ((position + barHeight) < num10)
                {
                    base.Value += base.LargeOffset;
                }
                else
                {
                    this.m_State = State.Inactive;
                }
            }
            GumpPaint.DrawRaised3D(X, num6 + position, 0x10, barHeight);
            if (this.m_State == State.SmallScrollUp)
            {
                GumpPaint.DrawFlat(X, Y, this.Width, this.Width);
                Renderer.SetAlphaEnable(true);
                Renderer.SetAlpha(1f);
                Engine.m_WinScrolls[0].Draw(X + 5, Y + 7, GumpColors.ControlText);
                Renderer.SetAlphaEnable(false);
                base.Value -= base.SmallOffset;
            }
            else
            {
                GumpPaint.DrawRaised3D(X, Y, this.Width, this.Width);
                Renderer.SetAlphaEnable(true);
                Renderer.SetAlpha(1f);
                Engine.m_WinScrolls[0].Draw(X + 4, Y + 6, GumpColors.ControlText);
                Renderer.SetAlphaEnable(false);
            }
            Renderer.SetTexture(null);
            if (this.m_State == State.SmallScrollDown)
            {
                GumpPaint.DrawFlat(X, (Y + this.Height) - this.Width, this.Width, this.Width);
                Renderer.SetAlphaEnable(true);
                Renderer.SetAlpha(1f);
                Engine.m_WinScrolls[1].Draw(X + 5, ((Y + this.Height) - this.Width) + 7, GumpColors.ControlText);
                Renderer.SetAlphaEnable(false);
                base.Value += base.SmallOffset;
            }
            else
            {
                GumpPaint.DrawRaised3D(X, (Y + this.Height) - this.Width, this.Width, this.Width);
                Renderer.SetAlphaEnable(true);
                Renderer.SetAlpha(1f);
                Engine.m_WinScrolls[1].Draw(X + 4, ((Y + this.Height) - this.Width) + 6, GumpColors.ControlText);
                Renderer.SetAlphaEnable(false);
            }
        }
Beispiel #11
0
        private static unsafe CursorEntry LoadCursor(int idCursor, int idType)
        {
            int  num;
            IHue hue;

            switch (idType)
            {
            case 0:
                hue = Hues.Default;
                num = 0x606a + idCursor;
                break;

            case 1:
                hue = Hues.Default;
                num = 0x6053 + idCursor;
                break;

            case 2:
                hue = Hues.Load(0x896d);
                num = 0x606a + idCursor;
                break;

            default:
                return(null);
            }
            Texture item = hue.GetItem(num);

            if ((item == null) || item.IsEmpty())
            {
                return(new CursorEntry(0, 0, 0, 0, Texture.Empty));
            }
            if (item.m_Factory != null)
            {
                item.m_Factory.Remove(item);
                item.m_Factory     = null;
                item.m_FactoryArgs = null;
            }
            int xOffset = 0;
            int yOffset = 0;

            if (idType < 2)
            {
                LockData data    = item.Lock(LockFlags.ReadWrite);
                int      width   = data.Width;
                int      height  = data.Height;
                int      num6    = data.Pitch >> 1;
                short *  pvSrc   = (short *)data.pvSrc;
                short *  numPtr2 = (short *)(data.pvSrc + (((height - 1) * num6) * 2));
                for (int i = 0; i < width; i++)
                {
                    if ((pvSrc[0] & 0x7fff) == 0x3e0)
                    {
                        xOffset = i;
                    }
                    pvSrc++;
                    pvSrc[0] = 0;
                    numPtr2++;
                    numPtr2[0] = 0;
                }
                pvSrc   = (short *)data.pvSrc;
                numPtr2 = (short *)(data.pvSrc + ((width - 1) * 2));
                for (int j = 0; j < height; j++)
                {
                    if ((pvSrc[0] & 0x7fff) == 0x3e0)
                    {
                        yOffset = j;
                    }
                    pvSrc[0]   = 0;
                    numPtr2[0] = 0;
                    pvSrc     += num6;
                    numPtr2   += num6;
                }
                item.Unlock();
            }
            else
            {
                CursorEntry entry = m_Cursors[idCursor, 1];
                if (entry == null)
                {
                    entry = m_Cursors[idCursor, 0];
                    if (entry == null)
                    {
                        entry = m_Cursors[idCursor, 1] = LoadCursor(idCursor, 1);
                    }
                }
                xOffset = entry.m_xOffset;
                yOffset = entry.m_yOffset;
                LockData data2   = item.Lock(LockFlags.ReadWrite);
                int      num9    = data2.Width;
                int      num10   = data2.Height;
                int      num11   = data2.Pitch >> 1;
                short *  numPtr3 = (short *)data2.pvSrc;
                short *  numPtr4 = (short *)(data2.pvSrc + (((num10 - 1) * num11) * 2));
                for (int k = 0; k < num9; k++)
                {
                    numPtr3++;
                    numPtr3[0] = 0;
                    numPtr4++;
                    numPtr4[0] = 0;
                }
                numPtr3 = (short *)data2.pvSrc;
                numPtr4 = (short *)(data2.pvSrc + ((num9 - 1) * 2));
                for (int m = 0; m < num10; m++)
                {
                    numPtr3[0] = 0;
                    numPtr4[0] = 0;
                    numPtr3   += num11;
                    numPtr4   += num11;
                }
                item.Unlock();
            }
            return(new CursorEntry(idCursor, idType, xOffset, yOffset, item));
        }
Beispiel #12
0
 public unsafe void Clear(LockData ld)
 {
     int num = ld.Pitch * ld.Height;
     int num2 = num >> 2;
     num &= 3;
     int* pvSrc = (int*) ld.pvSrc;
     while (--num2 >= 0)
     {
         pvSrc++;
         pvSrc[0] = 0;
     }
     if (num != 0)
     {
         byte* numPtr2 = (byte*) ld.pvSrc;
         while (--num != 0)
         {
             *(numPtr2++) = 0;
         }
     }
 }
Beispiel #13
0
 public unsafe virtual LockData Lock(LockFlags flags)
 {
     Texture texture = this.CoreGetSurface();
     if (texture == null)
     {
         return new LockData();
     }
     LockFlags flags2 = 0x800;
     if (flags == LockFlags.ReadOnly)
     {
         flags2 |= 0x10;
     }
     int num = 0;
     GraphicsStream stream = texture.LockRectangle(0, flags2, ref num);
     LockData data = new LockData {
         Pitch = num,
         pvSrc = (void*) stream.get_InternalData(),
         Height = this.Height,
         Width = this.Width
     };
     this.m_LockStream = stream;
     return data;
 }
Beispiel #14
0
        public unsafe object Create(int realID, IHue hue)
        {
            int    length;
            int    lookup;
            int    num3;
            Stream stream;

            switch (this.ConvertRealID(ref realID))
            {
            case 1:
            {
                if (((realID < 0) || (realID >= this.m_Count)) || (realID >= this.m_Index.Length))
                {
                    return(Frames.Empty);
                }
                Entry3D entryd = this.m_Index[realID];
                length = entryd.m_Length;
                lookup = entryd.m_Lookup;
                num3   = entryd.m_Extra & 0xff;
                stream = m_Stream;
                break;
            }

            case 2:
            {
                if (((realID < 0) || (realID >= this.m_Count2)) || (realID >= this.m_Index2.Length))
                {
                    return(Frames.Empty);
                }
                Entry3D entryd2 = this.m_Index2[realID];
                length = entryd2.m_Length;
                lookup = entryd2.m_Lookup;
                num3   = entryd2.m_Extra & 0xff;
                stream = m_Stream2;
                break;
            }

            case 3:
            {
                if (((realID < 0) || (realID >= this.m_Count3)) || (realID >= this.m_Index3.Length))
                {
                    return(Frames.Empty);
                }
                Entry3D entryd3 = this.m_Index3[realID];
                length = entryd3.m_Length;
                lookup = entryd3.m_Lookup;
                num3   = entryd3.m_Extra & 0xff;
                stream = m_Stream3;
                break;
            }

            default:
            {
                if (((realID < 0) || (realID >= this.m_Count4)) || (realID >= this.m_Index4.Length))
                {
                    return(Frames.Empty);
                }
                Entry3D entryd4 = this.m_Index4[realID];
                length = entryd4.m_Length;
                lookup = entryd4.m_Lookup;
                num3   = entryd4.m_Extra & 0xff;
                stream = m_Stream4;
                break;
            }
            }
            if (((lookup < 0) || (length <= 0)) || ((num3 <= 0) || (stream == null)))
            {
                return(Frames.Empty);
            }
            if ((this.m_Data == null) || (length > this.m_Data.Length))
            {
                this.m_Data = new byte[length];
            }
            stream.Seek((long)lookup, SeekOrigin.Begin);
            stream.Read(this.m_Data, 0, length);
            fixed(short *numRef = this.m_Palette)
            {
                short *numPtr = numRef;

                fixed(byte *numRef2 = this.m_Data)
                {
                    if (hue.HueID() == 0)
                    {
                        numPtr = (short *)numRef2;
                        int *numPtr2 = (int *)numPtr;
                        int *numPtr3 = numPtr2 + 0x80;
                        while (numPtr2 < numPtr3)
                        {
                            numPtr2[0] |= -2147450880;
                            int *numPtr1 = numPtr2 + 1;
                            numPtr1[0] |= -2147450880;
                            int *numPtr9 = numPtr2 + 2;
                            numPtr9[0] |= -2147450880;
                            int *numPtr10 = numPtr2 + 3;
                            numPtr10[0] |= -2147450880;
                            numPtr2     += 4;
                        }
                    }
                    else
                    {
                        hue.CopyPixels((void *)numRef2, (void *)numPtr, 0x100);
                    }
                    Frames frames = new Frames {
                        FrameCount = num3,
                        FrameList  = new Frame[num3]
                    };

                    for (int i = 0; i < num3; i++)
                    {
                        int    num6    = (numRef2 + 0x204)[i << 2];
                        byte * numPtr4 = (numRef2 + 0x200) + num6;
                        short *numPtr5 = (short *)numPtr4;
                        int    num7    = numPtr5[0];
                        int    num8    = numPtr5[1];
                        int    width   = numPtr5[2];
                        int    height  = numPtr5[3];
                        numPtr4                    += 8;
                        frames.FrameList[i]         = new Frame();
                        frames.FrameList[i].CenterX = num7;
                        frames.FrameList[i].CenterY = num8;
                        if ((width <= 0) || (height <= 0))
                        {
                            frames.FrameList[i].Image = Texture.Empty;
                        }
                        else
                        {
                            Texture texture = new Texture(width, height, true);
                            if (texture.IsEmpty())
                            {
                                frames.FrameList[i].Image = Texture.Empty;
                            }
                            else
                            {
                                int      num11   = 0;
                                short *  numPtr6 = null;
                                int      num12   = num7 - 0x200;
                                int      num13   = (num8 + height) - 0x200;
                                LockData data    = texture.Lock(LockFlags.WriteOnly);
                                short *  pvSrc   = (short *)data.pvSrc;
                                int      num14   = data.Pitch >> 1;
                                pvSrc += num12;
                                pvSrc += num13 * num14;
                                while ((num11 = *((int *)numPtr4)) != 0x7fff7fff)
                                {
                                    numPtr4 += 4;
                                    num11   ^= -2145386496;
                                    numPtr6  = pvSrc + ((((num11 >> 12) & 0x3ff) * num14) + ((num11 >> 0x16) & 0x3ff));
                                    short *numPtr8 = numPtr6 + (num11 & 0xffc);
                                    while (numPtr6 < numPtr8)
                                    {
                                        numPtr6[0] = numPtr[numPtr4[0]];
                                        numPtr6[1] = numPtr[numPtr4[1]];
                                        numPtr6[2] = numPtr[numPtr4[2]];
                                        numPtr6[3] = numPtr[numPtr4[3]];
                                        numPtr6   += 4;
                                        numPtr4   += 4;
                                    }
                                    switch ((num11 & 3))
                                    {
                                    case 1:
                                        goto Label_04A6;

                                    case 2:
                                        break;

                                    case 3:
                                        numPtr6[2] = numPtr[numPtr4[2]];
                                        break;

                                    default:
                                        goto Label_04B5;
                                    }
                                    numPtr6[1] = numPtr[numPtr4[1]];
Label_04A6:
                                    numPtr6[0] = numPtr[numPtr4[0]];
Label_04B5:
                                    numPtr4 += num11 & 3;
                                }
                                texture.Unlock();
                                texture.SetPriority(0);
                                frames.FrameList[i].Image = texture;
                            }
                        }
                    }
                    this.m_Frames.Add(frames);
                    return(frames);
                }
            }
        }