Esempio n. 1
0
        private void gvSetPaletteAfter_Click(object sender, EventArgs e)
        {
            int paletteBytes = N64Graphics.PixelsToBytes(rightClickGV.Codec, rightClickGV.PixSize.Width * rightClickGV.PixSize.Height);

            setPaletteOffset(offset + paletteBytes);
            checkExtPalette.Checked = false;
        }
Esempio n. 2
0
        private void gvSetPaletteBefore_Click(object sender, EventArgs e)
        {
            int paletteBytes = N64Graphics.PixelsToBytes(gviewPalette.Codec, gviewPalette.PixSize.Width * gviewPalette.PixSize.Height);

            setPaletteOffset(offset - paletteBytes);
            checkExtPalette.Checked = false;
        }
Esempio n. 3
0
        private void advancePaletteOffset(GraphicsViewer gv, int direction, int advancePixels)
        {
            int offsetSize;

            if (advancePixels == 0)
            {
                offsetSize = N64Graphics.PixelsToBytes(gv.Codec, gv.PixSize.Width * gv.PixSize.Height);
            }
            else
            {
                offsetSize = N64Graphics.PixelsToBytes(gv.Codec, advancePixels);
            }
            int palOffset = (int)numericPalette.Value;
            int change    = direction * offsetSize;

            setPaletteOffset(palOffset + change);
        }
Esempio n. 4
0
 private void advanceOffset(GraphicsViewer gv, int direction, int advancePixels)
 {
     if (romData != null)
     {
         int offsetSize;
         if (advancePixels == 0)
         {
             offsetSize = N64Graphics.PixelsToBytes(gv.Codec, gv.GetPixelWidth() * gv.GetPixelHeight());
         }
         else
         {
             offsetSize = N64Graphics.PixelsToBytes(gv.Codec, advancePixels);
         }
         int change    = direction * offsetSize;
         int newOffset = Math.Max(0, Math.Min(romData.Length - 1, offset + change));
         numericOffset.Value = newOffset;
     }
 }
Esempio n. 5
0
        private void graphicsViewer_MouseMove(object sender, MouseEventArgs e)
        {
            if (romData != null)
            {
                GraphicsViewer gv            = (GraphicsViewer)sender;
                int            pixOffset     = (e.Y / gv.PixScale) * gv.GetPixelWidth() + e.X / gv.PixScale;
                int            byteOffset    = N64Graphics.PixelsToBytes(gv.Codec, pixOffset);
                int            nibblesPerPix = 1;
                int            select        = 0;
                int            selectBits    = 0;
                switch (gv.Codec)
                {
                case N64Codec.RGBA32:
                    nibblesPerPix = 8;
                    pixOffset    *= nibblesPerPix / 2;
                    break;

                case N64Codec.RGBA16:
                case N64Codec.IA16:
                    nibblesPerPix = 4;
                    pixOffset    *= nibblesPerPix / 2;
                    break;

                case N64Codec.IA8:
                case N64Codec.I8:
                case N64Codec.CI8:
                    nibblesPerPix = 2;
                    break;

                case N64Codec.IA4:
                case N64Codec.I4:
                case N64Codec.CI4:
                    selectBits = 4;
                    select     = pixOffset & 0x1;
                    pixOffset /= 2;
                    break;

                case N64Codec.ONEBPP:
                    selectBits = 1;
                    select     = pixOffset & 0x7;
                    pixOffset /= 8;
                    break;
                }

                byte[] colorData;
                if (gv == gviewPalette)
                {
                    colorData = curPalette;
                }
                else
                {
                    byteOffset += offset;
                    colorData   = romData;
                }
                if (byteOffset >= 0 && (byteOffset + nibblesPerPix / 2) <= colorData.Length)
                {
                    Color c     = N64Graphics.MakeColor(colorData, curPalette, byteOffset, select, gv.Codec, gv.Mode);
                    int   value = 0;
                    for (int i = 0; i < (nibblesPerPix + 1) / 2; i++)
                    {
                        value = (value << 8) | colorData[byteOffset + i];
                    }
                    switch (selectBits)
                    {
                    case 4: value = (value >> ((1 - select) * 4)) & 0xf; break;

                    case 1: value = (value >> select) & 0x1; break;
                    }
                    string hexFormat = String.Format("Hex: {{0:X0{0}}}", nibblesPerPix);
                    pictureBoxColor.BackColor = c;
                    labelColorHex.Text        = String.Format(hexFormat, value);
                    labelColorR.Text          = String.Format("R: {0}", c.R);
                    labelColorG.Text          = String.Format("G: {0}", c.G);
                    labelColorB.Text          = String.Format("B: {0}", c.B);
                    labelColorA.Text          = String.Format("A: {0}", c.A);
                }
                else
                {
                    pictureBoxColor.BackColor = Color.Empty;
                    labelColorHex.Text        = "Hex:";
                    labelColorR.Text          = "R:";
                    labelColorG.Text          = "G:";
                    labelColorB.Text          = "B:";
                    labelColorA.Text          = "A:";
                }
            }
        }