1490 lines
51 KiB
C#
1490 lines
51 KiB
C#
//TODO - disable scanline controls if box is unchecked
|
|
//TODO - overhaul the BG display box if its mode7 or direct color (mode7 more important)
|
|
//TODO - draw `1024` label in red if your content is being scaled down.
|
|
//TODO - maybe draw a label (in lieu of above, also) showing what scale the content is at: 2x or 1x or 1/2x
|
|
//TODO - add eDisplayType for BG1-Tiles, BG2-Tiles, etc. which show the tiles available to a BG. more concise than viewing all tiles and illustrating the relevant accessible areas
|
|
// . could this apply to the palette too?
|
|
//TODO - show the priority list for the current mode. make the priority list have checkboxes, and use that to control whether that item displays (does bsnes have that granularity? maybe)
|
|
//TODO - use custom checkboxes for register-viewing checkboxes to make them green and checked
|
|
//TODO - make freeze actually save the info caches, and re-render in realtime, so that you can pick something you want to see animate without having to hover your mouse just right. also add a checkbox to do the literal freeze (stop it from updating)
|
|
//TODO - sprite wrapping is not correct
|
|
//TODO - add "scroll&screen" checkbox which changes BG1/2/3/4 display modes to render scrolled and limited to 256x224 (for matching obj screen)
|
|
// alternatively - add "BG1 Screen" as a complement to BG1
|
|
//TODO - make Sprites mode respect priority toggles
|
|
//TODO - add "mode" display to BG info (in addition to bpp) so we can readily see if its mode7 or unavailable
|
|
|
|
//DEFERRED:
|
|
//. 256bpp modes (difficult to use)
|
|
//. non-mode7 directcolor (no known examples, perhaps due to difficulty using the requisite 256bpp modes)
|
|
|
|
//http://stackoverflow.com/questions/1101149/displaying-thumbnail-icons-128x128-pixels-or-larger-in-a-grid-in-listview
|
|
|
|
//hiding the tab control headers.. once this design gets solid, ill get rid of them
|
|
//http://www.mostthingsweb.com/2011/01/hiding-tab-headers-on-a-tabcontrol-in-c/
|
|
|
|
using System;
|
|
using System.Collections;
|
|
using System.Collections.Generic;
|
|
using System.Drawing;
|
|
using System.Reflection;
|
|
using System.Windows.Forms;
|
|
|
|
using BizHawk.Common;
|
|
using BizHawk.Client.Common;
|
|
using BizHawk.Emulation.Cores.Nintendo.SNES;
|
|
using BizHawk.Client.EmuHawk; //TODO: What??
|
|
|
|
namespace BizHawk.Client.EmuHawk
|
|
{
|
|
public unsafe partial class SNESGraphicsDebugger : Form, IToolForm
|
|
{
|
|
int defaultWidth; //For saving the default size of the dialog, so the user can restore if desired
|
|
int defaultHeight;
|
|
|
|
List<DisplayTypeItem> displayTypeItems = new List<DisplayTypeItem>();
|
|
|
|
public bool UpdateBefore { get { return false; } }
|
|
public bool AskSave() { return true; }
|
|
|
|
public void Restart()
|
|
{
|
|
if (Global.Emulator is LibsnesCore)
|
|
{
|
|
//TODO: shouldn't something be done here?
|
|
}
|
|
else
|
|
{
|
|
Close();
|
|
}
|
|
}
|
|
|
|
public SNESGraphicsDebugger()
|
|
{
|
|
InitializeComponent();
|
|
Closing += (o, e) => SaveConfigSettings();
|
|
viewerTile.ScaleImage = true;
|
|
|
|
viewer.ScaleImage = false;
|
|
|
|
displayTypeItems.Add(new DisplayTypeItem("Sprites", eDisplayType.Sprites));
|
|
displayTypeItems.Add(new DisplayTypeItem("OBJ", eDisplayType.OBJ));
|
|
|
|
displayTypeItems.Add(new DisplayTypeItem("BG1 Screen", eDisplayType.BG1));
|
|
displayTypeItems.Add(new DisplayTypeItem("BG2 Screen", eDisplayType.BG2));
|
|
displayTypeItems.Add(new DisplayTypeItem("BG3 Screen", eDisplayType.BG3));
|
|
displayTypeItems.Add(new DisplayTypeItem("BG4 Screen", eDisplayType.BG4));
|
|
|
|
displayTypeItems.Add(new DisplayTypeItem("BG1", eDisplayType.BG1));
|
|
displayTypeItems.Add(new DisplayTypeItem("BG2",eDisplayType.BG2));
|
|
displayTypeItems.Add(new DisplayTypeItem("BG3",eDisplayType.BG3));
|
|
displayTypeItems.Add(new DisplayTypeItem("BG4",eDisplayType.BG4));
|
|
displayTypeItems.Add(new DisplayTypeItem("OBJ Tiles",eDisplayType.OBJTiles0));
|
|
displayTypeItems.Add(new DisplayTypeItem("2bpp tiles",eDisplayType.Tiles2bpp));
|
|
displayTypeItems.Add(new DisplayTypeItem("4bpp tiles",eDisplayType.Tiles4bpp));
|
|
displayTypeItems.Add(new DisplayTypeItem("8bpp tiles",eDisplayType.Tiles8bpp));
|
|
displayTypeItems.Add(new DisplayTypeItem("Mode7 tiles",eDisplayType.TilesMode7));
|
|
displayTypeItems.Add(new DisplayTypeItem("Mode7Ext tiles",eDisplayType.TilesMode7Ext));
|
|
displayTypeItems.Add(new DisplayTypeItem("Mode7 tiles (DC)", eDisplayType.TilesMode7DC));
|
|
comboDisplayType.DataSource = displayTypeItems;
|
|
comboDisplayType.SelectedIndex = 2;
|
|
|
|
var paletteTypeItems = new List<PaletteTypeItem>();
|
|
paletteTypeItems.Add(new PaletteTypeItem("BizHawk", SnesColors.ColorType.BizHawk));
|
|
paletteTypeItems.Add(new PaletteTypeItem("bsnes", SnesColors.ColorType.BSNES));
|
|
paletteTypeItems.Add(new PaletteTypeItem("Snes9X", SnesColors.ColorType.Snes9x));
|
|
suppression = true;
|
|
comboPalette.DataSource = paletteTypeItems;
|
|
comboPalette.SelectedIndex = 0;
|
|
suppression = false;
|
|
|
|
comboBGProps.SelectedIndex = 0;
|
|
|
|
SyncViewerSize();
|
|
SyncColorSelection();
|
|
|
|
//tabctrlDetails.SelectedIndex = 1;
|
|
SetTab(null);
|
|
}
|
|
|
|
LibsnesCore currentSnesCore;
|
|
protected override void OnClosed(EventArgs e)
|
|
{
|
|
base.OnClosed(e);
|
|
if (currentSnesCore != null)
|
|
currentSnesCore.ScanlineHookManager.Unregister(this);
|
|
currentSnesCore = null;
|
|
}
|
|
|
|
string FormatBpp(int bpp)
|
|
{
|
|
if (bpp == 0) return "---";
|
|
else return bpp.ToString();
|
|
}
|
|
|
|
string FormatVramAddress(int address)
|
|
{
|
|
int excess = address & 1023;
|
|
if (excess != 0) return "@" + address.ToHexString(4);
|
|
else return string.Format("@{0} ({1}K)", address.ToHexString(4), address / 1024);
|
|
}
|
|
|
|
public void UpdateValues()
|
|
{
|
|
if (Global.Emulator is LibsnesCore)
|
|
{
|
|
SyncCore();
|
|
if (Visible && !checkScanlineControl.Checked)
|
|
{
|
|
RegenerateData();
|
|
InternalUpdateValues();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
Close();
|
|
}
|
|
}
|
|
|
|
public void UpdateToolsLoadstate()
|
|
{
|
|
SyncCore();
|
|
if (Visible)
|
|
{
|
|
RegenerateData();
|
|
InternalUpdateValues();
|
|
}
|
|
}
|
|
|
|
private void nudScanline_ValueChanged(object sender, EventArgs e)
|
|
{
|
|
if (suppression) return;
|
|
SyncCore();
|
|
suppression = true;
|
|
sliderScanline.Value = 224 - (int)nudScanline.Value;
|
|
suppression = false;
|
|
}
|
|
|
|
private void sliderScanline_ValueChanged(object sender, EventArgs e)
|
|
{
|
|
if (suppression) return;
|
|
checkScanlineControl.Checked = true;
|
|
SyncCore();
|
|
suppression = true;
|
|
nudScanline.Value = 224 - sliderScanline.Value;
|
|
suppression = false;
|
|
}
|
|
|
|
void SyncCore()
|
|
{
|
|
LibsnesCore core = Global.Emulator as LibsnesCore;
|
|
if (currentSnesCore != core && currentSnesCore != null)
|
|
{
|
|
currentSnesCore.ScanlineHookManager.Unregister(this);
|
|
}
|
|
|
|
if(currentSnesCore != core && core != null)
|
|
{
|
|
suppression = true;
|
|
comboPalette.SelectedValue = core.CurrPalette;
|
|
RefreshBGENCheckStatesFromConfig();
|
|
suppression = false;
|
|
}
|
|
|
|
currentSnesCore = core;
|
|
|
|
if (currentSnesCore != null)
|
|
{
|
|
if (Visible && checkScanlineControl.Checked)
|
|
currentSnesCore.ScanlineHookManager.Register(this, ScanlineHook);
|
|
else
|
|
currentSnesCore.ScanlineHookManager.Unregister(this);
|
|
}
|
|
}
|
|
|
|
void ScanlineHook(int line)
|
|
{
|
|
int target = (int)nudScanline.Value;
|
|
if (target == line)
|
|
{
|
|
RegenerateData();
|
|
InternalUpdateValues();
|
|
}
|
|
}
|
|
|
|
SNESGraphicsDecoder gd;
|
|
SNESGraphicsDecoder.ScreenInfo si;
|
|
SNESGraphicsDecoder.TileEntry[] map;
|
|
byte[,] spriteMap = new byte[256, 224];
|
|
SNESGraphicsDecoder.BGMode viewBgMode;
|
|
|
|
void RegenerateData()
|
|
{
|
|
if (gd != null) gd.Dispose();
|
|
gd = null;
|
|
if (currentSnesCore == null) return;
|
|
gd = NewDecoder();
|
|
if(checkBackdropColor.Checked)
|
|
gd.SetBackColor(DecodeWinformsColorToSNES(pnBackdropColor.BackColor));
|
|
gd.CacheTiles();
|
|
si = gd.ScanScreenInfo();
|
|
}
|
|
|
|
private void InternalUpdateValues()
|
|
{
|
|
if (currentSnesCore == null) return;
|
|
|
|
txtOBSELSizeBits.Text = si.OBSEL_Size.ToString();
|
|
txtOBSELBaseBits.Text = si.OBSEL_NameBase.ToString();
|
|
txtOBSELT1OfsBits.Text = si.OBSEL_NameSel.ToString();
|
|
txtOBSELSizeDescr.Text = string.Format("{0}, {1}", SNESGraphicsDecoder.ObjSizes[si.OBSEL_Size, 0], SNESGraphicsDecoder.ObjSizes[si.OBSEL_Size, 1]);
|
|
txtOBSELBaseDescr.Text = FormatVramAddress(si.OBJTable0Addr);
|
|
txtOBSELT1OfsDescr.Text = FormatVramAddress(si.OBJTable1Addr);
|
|
|
|
checkScreenExtbg.Checked = si.SETINI_Mode7ExtBG;
|
|
checkScreenHires.Checked = si.SETINI_HiRes;
|
|
checkScreenOverscan.Checked = si.SETINI_Overscan;
|
|
checkScreenObjInterlace.Checked = si.SETINI_ObjInterlace;
|
|
checkScreenInterlace.Checked = si.SETINI_ScreenInterlace;
|
|
|
|
txtScreenCGWSEL_ColorMask.Text = si.CGWSEL_ColorMask.ToString();
|
|
txtScreenCGWSEL_ColorSubMask.Text = si.CGWSEL_ColorSubMask.ToString();
|
|
txtScreenCGWSEL_MathFixed.Text = si.CGWSEL_AddSubMode.ToString();
|
|
checkScreenCGWSEL_DirectColor.Checked = si.CGWSEL_DirectColor;
|
|
txtScreenCGADSUB_AddSub.Text = si.CGWSEL_AddSubMode.ToString();
|
|
txtScreenCGADSUB_AddSub_Descr.Text = si.CGADSUB_AddSub == 1 ? "SUB" : "ADD";
|
|
txtScreenCGADSUB_Half.Checked = si.CGADSUB_Half;
|
|
|
|
txtModeBits.Text = si.Mode.MODE.ToString();
|
|
txtScreenBG1Bpp.Text = FormatBpp(si.BG.BG1.Bpp);
|
|
txtScreenBG2Bpp.Text = FormatBpp(si.BG.BG2.Bpp);
|
|
txtScreenBG3Bpp.Text = FormatBpp(si.BG.BG3.Bpp);
|
|
txtScreenBG4Bpp.Text = FormatBpp(si.BG.BG4.Bpp);
|
|
txtScreenBG1TSize.Text = FormatBpp(si.BG.BG1.TileSize);
|
|
txtScreenBG2TSize.Text = FormatBpp(si.BG.BG2.TileSize);
|
|
txtScreenBG3TSize.Text = FormatBpp(si.BG.BG3.TileSize);
|
|
txtScreenBG4TSize.Text = FormatBpp(si.BG.BG4.TileSize);
|
|
|
|
int bgnum = comboBGProps.SelectedIndex + 1;
|
|
|
|
var bg = si.BG[bgnum];
|
|
txtBG1TSizeBits.Text = bg.TILESIZE.ToString();
|
|
txtBG1TSizeDescr.Text = string.Format("{0}x{0}", bg.TileSize);
|
|
txtBG1Bpp.Text = FormatBpp(bg.Bpp);
|
|
txtBG1SizeBits.Text = bg.SCSIZE.ToString();
|
|
txtBG1SizeInTiles.Text = bg.ScreenSizeInTiles.ToString();
|
|
int size = bg.ScreenSizeInTiles.Width * bg.ScreenSizeInTiles.Height * 2 / 1024;
|
|
txtBG1MapSizeBytes.Text = string.Format("({0}K)", size);
|
|
txtBG1SCAddrBits.Text = bg.SCADDR.ToString();
|
|
txtBG1SCAddrDescr.Text = FormatVramAddress(bg.ScreenAddr);
|
|
txtBG1Colors.Text = (1 << bg.Bpp).ToString();
|
|
if (bg.Bpp == 8 && si.CGWSEL_DirectColor) txtBG1Colors.Text = "(Direct Color)";
|
|
txtBG1TDAddrBits.Text = bg.TDADDR.ToString();
|
|
txtBG1TDAddrDescr.Text = FormatVramAddress(bg.TiledataAddr);
|
|
|
|
txtBG1Scroll.Text = string.Format("({0},{1})", bg.HOFS, bg.VOFS);
|
|
|
|
if (bg.Bpp != 0)
|
|
{
|
|
var pi = bg.PaletteSelection;
|
|
txtBGPaletteInfo.Text = string.Format("{0} colors from ${1:X2} - ${2:X2}", pi.size, pi.start, pi.start + pi.size - 1);
|
|
}
|
|
else txtBGPaletteInfo.Text = "";
|
|
|
|
var sizeInPixels = bg.ScreenSizeInPixels;
|
|
txtBG1SizeInPixels.Text = string.Format("{0}x{1}", sizeInPixels.Width, sizeInPixels.Height);
|
|
|
|
checkTMOBJ.Checked = si.OBJ_MainEnabled;
|
|
checkTMBG1.Checked = si.BG.BG1.MainEnabled;
|
|
checkTMBG2.Checked = si.BG.BG2.MainEnabled;
|
|
checkTMBG3.Checked = si.BG.BG3.MainEnabled;
|
|
checkTMBG4.Checked = si.BG.BG4.MainEnabled;
|
|
checkTMOBJ.Checked = si.OBJ_SubEnabled;
|
|
checkTSBG1.Checked = si.BG.BG1.SubEnabled;
|
|
checkTSBG2.Checked = si.BG.BG2.SubEnabled;
|
|
checkTSBG3.Checked = si.BG.BG3.SubEnabled;
|
|
checkTSBG4.Checked = si.BG.BG4.SubEnabled;
|
|
checkTSOBJ.Checked = si.OBJ_MainEnabled;
|
|
checkMathOBJ.Checked = si.OBJ_MathEnabled;
|
|
checkMathBK.Checked = si.BK_MathEnabled;
|
|
checkMathBG1.Checked = si.BG.BG1.MathEnabled;
|
|
checkMathBG2.Checked = si.BG.BG2.MathEnabled;
|
|
checkMathBG3.Checked = si.BG.BG3.MathEnabled;
|
|
checkMathBG4.Checked = si.BG.BG4.MathEnabled;
|
|
|
|
if (si.Mode.MODE == 1 && si.Mode1_BG3_Priority)
|
|
{
|
|
lblBG3.ForeColor = Color.Red;
|
|
if (toolTip1.GetToolTip(lblBG3) != "Mode 1 BG3 priority toggle bit of $2105 is SET")
|
|
toolTip1.SetToolTip(lblBG3, "Mode 1 BG3 priority toggle bit of $2105 is SET");
|
|
}
|
|
else
|
|
{
|
|
lblBG3.ForeColor = Color.Black;
|
|
if (toolTip1.GetToolTip(lblBG3) != "Mode 1 BG3 priority toggle bit of $2105 is CLEAR")
|
|
toolTip1.SetToolTip(lblBG3, "Mode 1 BG3 priority toggle bit of $2105 is CLEAR");
|
|
}
|
|
|
|
SyncColorSelection();
|
|
RenderView();
|
|
RenderPalette();
|
|
RenderTileView();
|
|
//these are likely to be changing all the time
|
|
UpdateColorDetails();
|
|
UpdateOBJDetails();
|
|
//maybe bg settings changed, or something
|
|
UpdateMapEntryDetails();
|
|
UpdateTileDetails();
|
|
}
|
|
|
|
eDisplayType CurrDisplaySelection { get { return (comboDisplayType.SelectedValue as eDisplayType?).Value; } }
|
|
|
|
//todo - something smarter to cycle through bitmaps without repeatedly trashing them (use the dispose callback on the viewer)
|
|
private void RenderView()
|
|
{
|
|
Bitmap bmp = null;
|
|
System.Drawing.Imaging.BitmapData bmpdata = null;
|
|
int* pixelptr = null;
|
|
int stride = 0;
|
|
|
|
Action<int, int> allocate = (w, h) =>
|
|
{
|
|
bmp = new Bitmap(w, h);
|
|
bmpdata = bmp.LockBits(new Rectangle(0, 0, w, h), System.Drawing.Imaging.ImageLockMode.WriteOnly, System.Drawing.Imaging.PixelFormat.Format32bppArgb);
|
|
pixelptr = (int*)bmpdata.Scan0.ToPointer();
|
|
stride = bmpdata.Stride;
|
|
};
|
|
|
|
var selection = CurrDisplaySelection;
|
|
if (selection == eDisplayType.OBJ)
|
|
{
|
|
var objBounds = si.ObjSizeBounds;
|
|
int width = objBounds.Width * 8;
|
|
int height = objBounds.Height * 16;
|
|
allocate(width, height);
|
|
for (int i = 0; i < 128; i++)
|
|
{
|
|
int tx = i % 8;
|
|
int ty = i / 8;
|
|
int x = tx * objBounds.Width;
|
|
int y = ty * objBounds.Height;
|
|
gd.RenderSpriteToScreen(pixelptr, stride / 4, x,y, si, i);
|
|
}
|
|
}
|
|
if (selection == eDisplayType.Sprites)
|
|
{
|
|
//render sprites in-place
|
|
allocate(256, 224);
|
|
for (int y = 0; y < 224; y++) for (int x = 0; x < 256; x++) spriteMap[x, y] = 0xFF;
|
|
for(int i=127;i>=0;i--)
|
|
{
|
|
var oam = new SNESGraphicsDecoder.OAMInfo(gd, si, i);
|
|
gd.RenderSpriteToScreen(pixelptr, stride / 4, oam.X, oam.Y, si, i, oam, 256, 224, spriteMap);
|
|
}
|
|
}
|
|
if (selection == eDisplayType.OBJTiles0 || selection == eDisplayType.OBJTiles1)
|
|
{
|
|
allocate(128, 256);
|
|
int startTile;
|
|
startTile = si.OBJTable0Addr / 32;
|
|
gd.RenderTilesToScreen(pixelptr, 16, 16, stride / 4, 4, currPaletteSelection.start, startTile, 256, true);
|
|
startTile = si.OBJTable1Addr / 32;
|
|
gd.RenderTilesToScreen(pixelptr + (stride/4*8*16), 16, 16, stride / 4, 4, currPaletteSelection.start, startTile, 256, true);
|
|
}
|
|
if (selection == eDisplayType.Tiles2bpp)
|
|
{
|
|
allocate(512, 512);
|
|
gd.RenderTilesToScreen(pixelptr, 64, 64, stride / 4, 2, currPaletteSelection.start);
|
|
}
|
|
if (selection == eDisplayType.Tiles4bpp)
|
|
{
|
|
allocate(512, 512);
|
|
gd.RenderTilesToScreen(pixelptr, 64, 32, stride / 4, 4, currPaletteSelection.start);
|
|
}
|
|
if (selection == eDisplayType.Tiles8bpp)
|
|
{
|
|
allocate(256, 256);
|
|
gd.RenderTilesToScreen(pixelptr, 32, 32, stride / 4, 8, currPaletteSelection.start);
|
|
}
|
|
if (selection == eDisplayType.TilesMode7)
|
|
{
|
|
//256 tiles
|
|
allocate(128, 128);
|
|
gd.RenderMode7TilesToScreen(pixelptr, stride / 4, false, false);
|
|
}
|
|
if (selection == eDisplayType.TilesMode7Ext)
|
|
{
|
|
//256 tiles
|
|
allocate(128, 128);
|
|
gd.RenderMode7TilesToScreen(pixelptr, stride / 4, true, false);
|
|
}
|
|
if (selection == eDisplayType.TilesMode7DC)
|
|
{
|
|
//256 tiles
|
|
allocate(128, 128);
|
|
gd.RenderMode7TilesToScreen(pixelptr, stride / 4, false, true);
|
|
}
|
|
if (IsDisplayTypeBG(selection))
|
|
{
|
|
int bgnum = (int)selection;
|
|
var bg = si.BG[bgnum];
|
|
|
|
map = new SNESGraphicsDecoder.TileEntry[0];
|
|
viewBgMode = bg.BGMode;
|
|
|
|
//bool handled = false;
|
|
if (bg.Enabled)
|
|
{
|
|
//TODO - directColor in normal BG renderer
|
|
bool DirectColor = si.CGWSEL_DirectColor && bg.Bpp == 8; //any exceptions?
|
|
int numPixels = 0;
|
|
//TODO - could use BGMode property on BG... too much chaos to deal with it now
|
|
if (si.Mode.MODE == 7)
|
|
{
|
|
bool mode7 = bgnum == 1;
|
|
bool mode7extbg = (bgnum == 2 && si.SETINI_Mode7ExtBG);
|
|
if (mode7 || mode7extbg)
|
|
{
|
|
//handled = true;
|
|
allocate(1024, 1024);
|
|
gd.DecodeMode7BG(pixelptr, stride / 4, mode7extbg);
|
|
numPixels = 128 * 128 * 8 * 8;
|
|
if (DirectColor) gd.DirectColorify(pixelptr, numPixels);
|
|
else gd.Paletteize(pixelptr, 0, 0, numPixels);
|
|
|
|
//get a fake map, since mode7 doesnt really have a map
|
|
map = gd.FetchMode7Tilemap();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
//handled = true;
|
|
var dims = bg.ScreenSizeInPixels;
|
|
dims.Height = dims.Width = Math.Max(dims.Width, dims.Height);
|
|
allocate(dims.Width, dims.Height);
|
|
numPixels = dims.Width * dims.Height;
|
|
System.Diagnostics.Debug.Assert(stride / 4 == dims.Width);
|
|
|
|
map = gd.FetchTilemap(bg.ScreenAddr, bg.ScreenSize);
|
|
int paletteStart = 0;
|
|
gd.DecodeBG(pixelptr, stride / 4, map, bg.TiledataAddr, bg.ScreenSize, bg.Bpp, bg.TileSize, paletteStart);
|
|
gd.Paletteize(pixelptr, 0, 0, numPixels);
|
|
}
|
|
|
|
gd.Colorize(pixelptr, 0, numPixels);
|
|
}
|
|
}
|
|
|
|
if (bmp != null)
|
|
{
|
|
bmp.UnlockBits(bmpdata);
|
|
viewer.SetBitmap(bmp);
|
|
}
|
|
}
|
|
|
|
enum eDisplayType
|
|
{
|
|
BG1 = 1, BG2 = 2, BG3 = 3, BG4 = 4, OBJTiles0, OBJTiles1, Tiles2bpp, Tiles4bpp, Tiles8bpp, TilesMode7, TilesMode7Ext, TilesMode7DC, Sprites, OBJ,
|
|
BG1Screen = 101, BG2Screen = 102, BG3Screen = 103, BG4Screen = 104,
|
|
}
|
|
static bool IsDisplayTypeBG(eDisplayType type) { return type == eDisplayType.BG1 || type == eDisplayType.BG2 || type == eDisplayType.BG3 || type == eDisplayType.BG4; }
|
|
static bool IsDisplayTypeOBJ(eDisplayType type) { return type == eDisplayType.OBJTiles0 || type == eDisplayType.OBJTiles1; }
|
|
static int DisplayTypeBGNum(eDisplayType type) { if(IsDisplayTypeBG(type)) return (int)type; else return -1; }
|
|
static SNESGraphicsDecoder.BGMode BGModeForDisplayType(eDisplayType type)
|
|
{
|
|
switch (type)
|
|
{
|
|
case eDisplayType.Tiles2bpp: return SNESGraphicsDecoder.BGMode.Text;
|
|
case eDisplayType.Tiles4bpp: return SNESGraphicsDecoder.BGMode.Text;
|
|
case eDisplayType.Tiles8bpp: return SNESGraphicsDecoder.BGMode.Text;
|
|
case eDisplayType.TilesMode7: return SNESGraphicsDecoder.BGMode.Mode7;
|
|
case eDisplayType.TilesMode7Ext: return SNESGraphicsDecoder.BGMode.Mode7Ext;
|
|
case eDisplayType.TilesMode7DC: return SNESGraphicsDecoder.BGMode.Mode7DC;
|
|
case eDisplayType.OBJTiles0: return SNESGraphicsDecoder.BGMode.OBJ;
|
|
case eDisplayType.OBJTiles1: return SNESGraphicsDecoder.BGMode.OBJ;
|
|
default: throw new InvalidOperationException();
|
|
}
|
|
}
|
|
|
|
class DisplayTypeItem
|
|
{
|
|
public eDisplayType Type { get; private set; }
|
|
public string Descr { get; private set; }
|
|
public DisplayTypeItem(string descr, eDisplayType type)
|
|
{
|
|
Type = type;
|
|
Descr = descr;
|
|
}
|
|
}
|
|
|
|
class PaletteTypeItem
|
|
{
|
|
public SnesColors.ColorType Type { get; private set; }
|
|
public string Descr { get; private set; }
|
|
public PaletteTypeItem(string descr, SnesColors.ColorType type)
|
|
{
|
|
Type = type;
|
|
Descr = descr;
|
|
}
|
|
}
|
|
|
|
private void comboDisplayType_SelectedIndexChanged(object sender, EventArgs e)
|
|
{
|
|
InternalUpdateValues();
|
|
|
|
//change the bg props viewer to match
|
|
if (IsDisplayTypeBG(CurrDisplaySelection))
|
|
comboBGProps.SelectedIndex = DisplayTypeBGNum(CurrDisplaySelection) - 1;
|
|
}
|
|
|
|
private void exitToolStripMenuItem_Click(object sender, EventArgs e)
|
|
{
|
|
Close();
|
|
}
|
|
|
|
private void optionsToolStripMenuItem_DropDownOpened(object sender, EventArgs e)
|
|
{
|
|
autoloadToolStripMenuItem.Checked = Global.Config.AutoLoadSNESGraphicsDebugger;
|
|
saveWindowPositionToolStripMenuItem.Checked = Global.Config.SNESGraphicsDebuggerSaveWindowPosition;
|
|
}
|
|
|
|
private void autoloadToolStripMenuItem_Click(object sender, EventArgs e)
|
|
{
|
|
Global.Config.AutoLoadSNESGraphicsDebugger ^= true;
|
|
}
|
|
|
|
private void saveWindowPositionToolStripMenuItem_Click(object sender, EventArgs e)
|
|
{
|
|
Global.Config.SNESGraphicsDebuggerSaveWindowPosition ^= true;
|
|
}
|
|
|
|
private void SNESGraphicsDebugger_Load(object sender, EventArgs e)
|
|
{
|
|
defaultWidth = Size.Width; //Save these first so that the user can restore to its original size
|
|
defaultHeight = Size.Height;
|
|
|
|
if (Global.Config.SNESGraphicsDebuggerSaveWindowPosition && Global.Config.SNESGraphicsDebuggerWndx >= 0 && Global.Config.SNESGraphicsDebuggerWndy >= 0)
|
|
{
|
|
Location = new Point(Global.Config.SNESGraphicsDebuggerWndx, Global.Config.SNESGraphicsDebuggerWndy);
|
|
}
|
|
|
|
checkBackdropColor.Checked = Global.Config.SNESGraphicsUseUserBackdropColor;
|
|
if (Global.Config.SNESGraphicsUserBackdropColor != -1)
|
|
{
|
|
pnBackdropColor.BackColor = Color.FromArgb(Global.Config.SNESGraphicsUserBackdropColor);
|
|
}
|
|
if (checkBackdropColor.Checked)
|
|
{
|
|
SyncBackdropColor();
|
|
}
|
|
|
|
UpdateToolsLoadstate();
|
|
}
|
|
|
|
private void SaveConfigSettings()
|
|
{
|
|
Global.Config.SNESGraphicsDebuggerWndx = Location.X;
|
|
Global.Config.SNESGraphicsDebuggerWndy = Location.Y;
|
|
}
|
|
|
|
bool suppression = false;
|
|
private void rbBGX_CheckedChanged(object sender, EventArgs e)
|
|
{
|
|
if (suppression) return;
|
|
//sync the comboBGProps dropdown with the result of this check
|
|
suppression = true;
|
|
if (rbBG1.Checked) comboBGProps.SelectedIndex = 0;
|
|
if (rbBG2.Checked) comboBGProps.SelectedIndex = 1;
|
|
if (rbBG3.Checked) comboBGProps.SelectedIndex = 2;
|
|
if (rbBG4.Checked) comboBGProps.SelectedIndex = 3;
|
|
suppression = false;
|
|
InternalUpdateValues();
|
|
}
|
|
|
|
private void comboBGProps_SelectedIndexChanged(object sender, EventArgs e)
|
|
{
|
|
if (suppression) return;
|
|
|
|
//sync the radiobuttons with this selection
|
|
suppression = true;
|
|
if (comboBGProps.SelectedIndex == 0) rbBG1.Checked = true;
|
|
if (comboBGProps.SelectedIndex == 1) rbBG2.Checked = true;
|
|
if (comboBGProps.SelectedIndex == 2) rbBG3.Checked = true;
|
|
if (comboBGProps.SelectedIndex == 3) rbBG4.Checked = true;
|
|
suppression = false;
|
|
InternalUpdateValues();
|
|
}
|
|
|
|
const int paletteCellSize = 16;
|
|
const int paletteCellSpacing = 3;
|
|
|
|
int[] lastPalette;
|
|
int lastColorNum = 0;
|
|
int selectedColorNum = 0;
|
|
SNESGraphicsDecoder.PaletteSelection currPaletteSelection;
|
|
|
|
Rectangle GetPaletteRegion(int start, int num)
|
|
{
|
|
var ret = new Rectangle();
|
|
ret.X = start % 16;
|
|
ret.Y = start / 16;
|
|
ret.Width = num;
|
|
ret.Height = num / 16;
|
|
if (ret.Height == 0) ret.Height = 1;
|
|
if (ret.Width > 16) ret.Width = 16;
|
|
return ret;
|
|
}
|
|
|
|
Rectangle GetPaletteRegion(SNESGraphicsDecoder.PaletteSelection sel)
|
|
{
|
|
int start = sel.start, num = sel.size;
|
|
return GetPaletteRegion(start, num);
|
|
}
|
|
|
|
void DrawPaletteRegion(Graphics g, Color color, Rectangle region)
|
|
{
|
|
int cellTotalSize = (paletteCellSize + paletteCellSpacing);
|
|
|
|
int x = paletteCellSpacing + region.X * cellTotalSize - 2;
|
|
int y = paletteCellSpacing + region.Y * cellTotalSize - 2;
|
|
int width = cellTotalSize * region.Width;
|
|
int height = cellTotalSize * region.Height;
|
|
|
|
var rect = new Rectangle(x, y, width, height);
|
|
using (var pen = new Pen(color))
|
|
g.DrawRectangle(pen, rect);
|
|
}
|
|
|
|
//if a tile set is being displayed, this will adapt the user's color selection into a palette to be used for rendering the tiles
|
|
SNESGraphicsDecoder.PaletteSelection GetPaletteSelectionForTileDisplay(int colorSelection)
|
|
{
|
|
int bpp = 0;
|
|
var selection = CurrDisplaySelection;
|
|
if (selection == eDisplayType.Tiles2bpp) bpp = 2;
|
|
if (selection == eDisplayType.Tiles4bpp) bpp = 4;
|
|
if (selection == eDisplayType.Tiles8bpp) bpp = 8;
|
|
if (selection == eDisplayType.TilesMode7) bpp = 8;
|
|
if (selection == eDisplayType.TilesMode7Ext) bpp = 7;
|
|
if (selection == eDisplayType.OBJTiles0) bpp = 4;
|
|
if (selection == eDisplayType.OBJTiles1) bpp = 4;
|
|
|
|
SNESGraphicsDecoder.PaletteSelection ret = new SNESGraphicsDecoder.PaletteSelection();
|
|
if(bpp == 0) return ret;
|
|
|
|
//mode7 ext is fixed to use the top 128 colors
|
|
if (bpp == 7)
|
|
{
|
|
ret.size = 128;
|
|
ret.start = 0;
|
|
return ret;
|
|
}
|
|
|
|
ret.size = 1 << bpp;
|
|
ret.start = colorSelection & (~(ret.size - 1));
|
|
return ret;
|
|
}
|
|
|
|
SNESGraphicsDecoder NewDecoder()
|
|
{
|
|
//wtf to do? now we need an api all the time
|
|
if (currentSnesCore != null)
|
|
return new SNESGraphicsDecoder(currentSnesCore.api, currentSnesCore.CurrPalette);
|
|
else return new SNESGraphicsDecoder(currentSnesCore.api, SnesColors.ColorType.BizHawk);
|
|
}
|
|
|
|
void RenderPalette()
|
|
{
|
|
//var gd = NewDecoder(); //??
|
|
lastPalette = gd.GetPalette();
|
|
|
|
int pixsize = paletteCellSize * 16 + paletteCellSpacing * 17;
|
|
int cellTotalSize = (paletteCellSize + paletteCellSpacing);
|
|
var bmp = new Bitmap(pixsize, pixsize, System.Drawing.Imaging.PixelFormat.Format32bppArgb);
|
|
using (var g = Graphics.FromImage(bmp))
|
|
{
|
|
for (int y = 0; y < 16; y++)
|
|
{
|
|
for (int x = 0; x < 16; x++)
|
|
{
|
|
int rgb555 = lastPalette[y * 16 + x];
|
|
int color = gd.Colorize(rgb555);
|
|
using (var brush = new SolidBrush(Color.FromArgb(color)))
|
|
{
|
|
g.FillRectangle(brush, new Rectangle(paletteCellSpacing + x * cellTotalSize, paletteCellSpacing + y * cellTotalSize, paletteCellSize, paletteCellSize));
|
|
}
|
|
}
|
|
}
|
|
|
|
//draw selection boxes:
|
|
//first, draw the current selection
|
|
var region = GetPaletteRegion(selectedColorNum, 1);
|
|
DrawPaletteRegion(g, Color.Red, region);
|
|
//next, draw the rectangle that advises you which colors could possibly be used for a bg
|
|
if (IsDisplayTypeBG(CurrDisplaySelection))
|
|
{
|
|
var ps = si.BG[DisplayTypeBGNum(CurrDisplaySelection)].PaletteSelection;
|
|
region = GetPaletteRegion(ps);
|
|
DrawPaletteRegion(g, Color.FromArgb(192, 128, 255, 255), region);
|
|
}
|
|
if (IsDisplayTypeOBJ(CurrDisplaySelection))
|
|
{
|
|
var ps = new SNESGraphicsDecoder.PaletteSelection(128, 128);
|
|
region = GetPaletteRegion(ps);
|
|
DrawPaletteRegion(g, Color.FromArgb(192, 128, 255, 255), region);
|
|
}
|
|
//finally, draw the palette the user has chosen, in case he's viewing tiles
|
|
if (currPaletteSelection.size != 0)
|
|
{
|
|
region = GetPaletteRegion(currPaletteSelection.start, currPaletteSelection.size);
|
|
DrawPaletteRegion(g, Color.FromArgb(192,255,255,255), region);
|
|
}
|
|
}
|
|
|
|
paletteViewer.SetBitmap(bmp);
|
|
}
|
|
|
|
static string BGModeShortName(SNESGraphicsDecoder.BGMode mode, int bpp)
|
|
{
|
|
if (mode == SNESGraphicsDecoder.BGMode.Unavailable) return "Unavailable";
|
|
if (mode == SNESGraphicsDecoder.BGMode.Text) return string.Format("Text{0}bpp", bpp);
|
|
if (mode == SNESGraphicsDecoder.BGMode.OBJ) return string.Format("OBJ", bpp);
|
|
if (mode == SNESGraphicsDecoder.BGMode.Mode7) return "Mode7";
|
|
if (mode == SNESGraphicsDecoder.BGMode.Mode7Ext) return "Mode7Ext";
|
|
if (mode == SNESGraphicsDecoder.BGMode.Mode7DC) return "Mode7DC";
|
|
throw new InvalidOperationException();
|
|
}
|
|
|
|
void UpdateOBJDetails()
|
|
{
|
|
if (currObjDataState == null) return;
|
|
var oam = new SNESGraphicsDecoder.OAMInfo(gd, si, currObjDataState.Number);
|
|
txtObjNumber.Text = string.Format("#${0:X2}", currObjDataState.Number);
|
|
txtObjCoord.Text = string.Format("({0}, {1})",oam.X,oam.Y);
|
|
cbObjHFlip.Checked = oam.HFlip;
|
|
cbObjVFlip.Checked = oam.VFlip;
|
|
cbObjLarge.Checked = oam.Size == 1;
|
|
txtObjSize.Text = SNESGraphicsDecoder.ObjSizes[si.OBSEL_Size, oam.Size].ToString();
|
|
txtObjPriority.Text = oam.Priority.ToString();
|
|
txtObjPalette.Text = oam.Palette.ToString();
|
|
txtObjPaletteMemo.Text = string.Format("${0:X2}", oam.Palette * 16 + 128);
|
|
txtObjName.Text = string.Format("#${0:X3}", oam.Tile);
|
|
txtObjNameAddr.Text = string.Format("@{0:X4}", oam.Address);
|
|
}
|
|
|
|
void UpdateTileDetails()
|
|
{
|
|
if (currTileDataState == null) return;
|
|
var mode = BGModeForDisplayType(currTileDataState.Type);
|
|
int bpp = currTileDataState.Bpp;
|
|
txtTileMode.Text = BGModeShortName(mode, bpp);
|
|
txtTileBpp.Text = currTileDataState.Bpp.ToString();
|
|
txtTileColors.Text = (1 << currTileDataState.Bpp).ToString();
|
|
txtTileNumber.Text = string.Format("#${0:X3}", currTileDataState.Tile);
|
|
txtTileAddress.Text = string.Format("@{0:X4}", currTileDataState.Address);
|
|
txtTilePalette.Text = string.Format("#{0:X2}", currTileDataState.Palette);
|
|
}
|
|
|
|
void UpdateMapEntryDetails()
|
|
{
|
|
if (currMapEntryState == null) return;
|
|
txtMapEntryLocation.Text = string.Format("({0},{1}), @{2:X4}", currMapEntryState.Location.X, currMapEntryState.Location.Y, currMapEntryState.entry.address);
|
|
txtMapEntryTileNum.Text = string.Format("${0:X3}", currMapEntryState.entry.tilenum);
|
|
txtMapEntryPrio.Text = string.Format("{0}", (currMapEntryState.entry.flags & SNESGraphicsDecoder.TileEntryFlags.Priority)!=0?1:0);
|
|
txtMapEntryPalette.Text = string.Format("{0}", currMapEntryState.entry.palette);
|
|
checkMapEntryHFlip.Checked = (currMapEntryState.entry.flags & SNESGraphicsDecoder.TileEntryFlags.Horz) != 0;
|
|
checkMapEntryVFlip.Checked = (currMapEntryState.entry.flags & SNESGraphicsDecoder.TileEntryFlags.Vert) != 0;
|
|
|
|
//calculate address of tile
|
|
var bg = si.BG[currMapEntryState.bgnum];
|
|
int bpp = bg.Bpp;
|
|
int tiledataBaseAddr = bg.TiledataAddr;
|
|
int tileSizeBytes = 8 * bpp;
|
|
int baseTileNum = tiledataBaseAddr / tileSizeBytes;
|
|
int tileNum = baseTileNum + currMapEntryState.entry.tilenum;
|
|
int addr = tileNum * tileSizeBytes;
|
|
|
|
//mode7 takes up 128 bytes per tile because its interleaved with the screen data
|
|
if (bg.BGModeIsMode7Type)
|
|
addr *= 2;
|
|
|
|
addr &= 0xFFFF;
|
|
txtMapEntryTileAddr.Text = "@" + addr.ToHexString(4);
|
|
}
|
|
|
|
void UpdateColorDetails()
|
|
{
|
|
if (lastPalette == null) return;
|
|
|
|
int rgb555 = lastPalette[lastColorNum];
|
|
//var gd = NewDecoder(); //??
|
|
int color = gd.Colorize(rgb555);
|
|
pnDetailsPaletteColor.BackColor = Color.FromArgb(color);
|
|
|
|
txtDetailsPaletteColor.Text = string.Format("${0:X4}", rgb555);
|
|
txtDetailsPaletteColorHex.Text = string.Format("#{0:X6}", color & 0xFFFFFF);
|
|
txtDetailsPaletteColorRGB.Text = string.Format("({0},{1},{2})", (color >> 16) & 0xFF, (color >> 8) & 0xFF, (color & 0xFF));
|
|
|
|
txtPaletteDetailsIndexHex.Text = string.Format("${0:X2}", lastColorNum);
|
|
txtPaletteDetailsIndex.Text = string.Format("{0}", lastColorNum);
|
|
|
|
//not being used anymore
|
|
//if (lastColorNum < 128) lblDetailsOBJOrBG.Text = "(BG:)"; else lblDetailsOBJOrBG.Text = "(OBJ:)";
|
|
//txtPaletteDetailsIndexHexSpecific.Text = string.Format("${0:X2}", lastColorNum & 0x7F);
|
|
//txtPaletteDetailsIndexSpecific.Text = string.Format("{0}", lastColorNum & 0x7F);
|
|
|
|
txtPaletteDetailsAddress.Text = string.Format("${0:X3}", lastColorNum * 2);
|
|
|
|
string test = string.Format(@"Pal# ${0:X2} @{1:X3}", lastColorNum, lastColorNum * 2);
|
|
}
|
|
|
|
|
|
bool TranslatePaletteCoord(Point pt, out Point outpoint)
|
|
{
|
|
pt.X -= paletteCellSpacing;
|
|
pt.Y -= paletteCellSpacing;
|
|
int tx = pt.X / (paletteCellSize + paletteCellSpacing);
|
|
int ty = pt.Y / (paletteCellSize + paletteCellSpacing);
|
|
outpoint = new Point(tx, ty);
|
|
if (tx >= 16 || ty >= 16) return false;
|
|
return true;
|
|
}
|
|
|
|
private void paletteViewer_MouseClick(object sender, MouseEventArgs e)
|
|
{
|
|
Point pt;
|
|
bool valid = TranslatePaletteCoord(e.Location, out pt);
|
|
if (!valid) return;
|
|
selectedColorNum = pt.Y * 16 + pt.X;
|
|
|
|
if (currTileDataState != null)
|
|
{
|
|
currTileDataState.Palette = currPaletteSelection.start;
|
|
}
|
|
|
|
SyncColorSelection();
|
|
InternalUpdateValues();
|
|
}
|
|
|
|
void SyncColorSelection()
|
|
{
|
|
currPaletteSelection = GetPaletteSelectionForTileDisplay(selectedColorNum);
|
|
}
|
|
|
|
private void pnDetailsPaletteColor_DoubleClick(object sender, EventArgs e)
|
|
{
|
|
//not workign real well...
|
|
//var cd = new ColorDialog();
|
|
//cd.Color = pnDetailsPaletteColor.BackColor;
|
|
//cd.ShowDialog(this);
|
|
}
|
|
|
|
private void rbQuad_CheckedChanged(object sender, EventArgs e)
|
|
{
|
|
SyncViewerSize();
|
|
}
|
|
|
|
void SyncViewerSize()
|
|
{
|
|
if (check2x.Checked)
|
|
|
|
viewer.Size = new Size(1024, 1024);
|
|
else
|
|
viewer.Size = new Size(512, 512);
|
|
}
|
|
|
|
private void checkScanlineControl_CheckedChanged(object sender, EventArgs e)
|
|
{
|
|
SyncCore();
|
|
}
|
|
|
|
private void check2x_CheckedChanged(object sender, EventArgs e)
|
|
{
|
|
SyncViewerSize();
|
|
}
|
|
|
|
bool viewerPan = false;
|
|
Point panStartLocation;
|
|
private void viewer_MouseDown(object sender, MouseEventArgs e)
|
|
{
|
|
viewer.Capture = true;
|
|
if ((e.Button & System.Windows.Forms.MouseButtons.Middle) != 0)
|
|
{
|
|
viewerPan = true;
|
|
panStartLocation = viewer.PointToScreen(e.Location);
|
|
Cursor = Cursors.SizeAll;
|
|
}
|
|
|
|
if ((e.Button & System.Windows.Forms.MouseButtons.Right) != 0)
|
|
Freeze();
|
|
}
|
|
|
|
void Freeze()
|
|
{
|
|
groupFreeze.SuspendLayout();
|
|
|
|
Win32.SendMessage(groupFreeze.Handle, 11, 0, 0); //WM_SETREDRAW false
|
|
|
|
var tp = tabctrlDetails.SelectedTab;
|
|
|
|
//clone the currently selected tab page into the destination
|
|
var oldControls = new ArrayList(pnGroupFreeze.Controls);
|
|
pnGroupFreeze.Controls.Clear();
|
|
foreach (var control in tp.Controls)
|
|
pnGroupFreeze.Controls.Add((control as Control).Clone());
|
|
foreach (var control in oldControls)
|
|
(control as Control).Dispose();
|
|
|
|
//set the freeze caption accordingly
|
|
if (tp == tpMapEntry) groupFreeze.Text = "Freeze - Map Entry";
|
|
if (tp == tpPalette) groupFreeze.Text = "Freeze - Color";
|
|
if (tp == tpTile) groupFreeze.Text = "Freeze - Tile";
|
|
if (tp == tpOBJ) groupFreeze.Text = "Freeze - OBJ";
|
|
|
|
groupFreeze.ResumeLayout();
|
|
|
|
Win32.SendMessage(groupFreeze.Handle, 11, 1, 0); //WM_SETREDRAW true
|
|
groupFreeze.Refresh();
|
|
}
|
|
|
|
enum eFreezeTarget
|
|
{
|
|
MainViewer
|
|
}
|
|
|
|
private void viewer_MouseUp(object sender, MouseEventArgs e)
|
|
{
|
|
viewerPan = false;
|
|
viewer.Capture = false;
|
|
Cursor = Cursors.Default;
|
|
}
|
|
|
|
private void viewer_MouseMove(object sender, MouseEventArgs e)
|
|
{
|
|
if (viewerPan)
|
|
{
|
|
var loc = viewer.PointToScreen(e.Location);
|
|
int dx = loc.X - panStartLocation.X;
|
|
int dy = loc.Y - panStartLocation.Y;
|
|
panStartLocation = loc;
|
|
|
|
int x = viewerPanel.AutoScrollPosition.X;
|
|
int y = viewerPanel.AutoScrollPosition.Y;
|
|
x += dx;
|
|
y += dy;
|
|
viewerPanel.AutoScrollPosition = new Point(-x, -y);
|
|
}
|
|
else
|
|
{
|
|
if(si != null)
|
|
UpdateViewerMouseover(e.Location);
|
|
}
|
|
}
|
|
|
|
class MapEntryState
|
|
{
|
|
public SNESGraphicsDecoder.TileEntry entry;
|
|
public int bgnum;
|
|
public Point Location;
|
|
}
|
|
MapEntryState currMapEntryState;
|
|
|
|
class TileDataState
|
|
{
|
|
public eDisplayType Type;
|
|
public int Bpp;
|
|
public int Tile;
|
|
public int Address;
|
|
public int Palette;
|
|
}
|
|
TileDataState currTileDataState;
|
|
|
|
class ObjDataState
|
|
{
|
|
public int Number;
|
|
}
|
|
ObjDataState currObjDataState;
|
|
|
|
void RenderTileView()
|
|
{
|
|
if (currMapEntryState != null)
|
|
{
|
|
//view a BG tile
|
|
int paletteStart = 0;
|
|
var bmp = new Bitmap(8, 8, System.Drawing.Imaging.PixelFormat.Format32bppArgb);
|
|
var bmpdata = bmp.LockBits(new Rectangle(0, 0, 8, 8), System.Drawing.Imaging.ImageLockMode.WriteOnly, System.Drawing.Imaging.PixelFormat.Format32bppArgb);
|
|
var bgs = currMapEntryState;
|
|
var oneTileEntry = new SNESGraphicsDecoder.TileEntry[] { bgs.entry };
|
|
|
|
if (viewBgMode == SNESGraphicsDecoder.BGMode.Mode7)
|
|
gd.RenderMode7TilesToScreen((int*)bmpdata.Scan0, bmpdata.Stride / 4, false, false, 1, currMapEntryState.entry.tilenum, 1);
|
|
else if (viewBgMode == SNESGraphicsDecoder.BGMode.Mode7Ext)
|
|
gd.RenderMode7TilesToScreen((int*)bmpdata.Scan0, bmpdata.Stride / 4, true, false, 1, currMapEntryState.entry.tilenum, 1);
|
|
else if (viewBgMode == SNESGraphicsDecoder.BGMode.Mode7DC)
|
|
gd.RenderMode7TilesToScreen((int*)bmpdata.Scan0, bmpdata.Stride / 4, false, true, 1, currMapEntryState.entry.tilenum, 1);
|
|
else
|
|
{
|
|
gd.DecodeBG((int*)bmpdata.Scan0, bmpdata.Stride / 4, oneTileEntry, si.BG[bgs.bgnum].TiledataAddr, SNESGraphicsDecoder.ScreenSize.Hacky_1x1, si.BG[bgs.bgnum].Bpp, 8, paletteStart);
|
|
gd.Paletteize((int*)bmpdata.Scan0, 0, 0, 64);
|
|
gd.Colorize((int*)bmpdata.Scan0, 0, 64);
|
|
}
|
|
|
|
bmp.UnlockBits(bmpdata);
|
|
viewerMapEntryTile.SetBitmap(bmp);
|
|
}
|
|
else if (currTileDataState != null)
|
|
{
|
|
//view a tileset tile
|
|
int bpp = currTileDataState.Bpp;
|
|
|
|
var bmp = new Bitmap(8, 8, System.Drawing.Imaging.PixelFormat.Format32bppArgb);
|
|
var bmpdata = bmp.LockBits(new Rectangle(0, 0, 8, 8), System.Drawing.Imaging.ImageLockMode.WriteOnly, System.Drawing.Imaging.PixelFormat.Format32bppArgb);
|
|
if (currTileDataState.Type == eDisplayType.TilesMode7)
|
|
gd.RenderMode7TilesToScreen((int*)bmpdata.Scan0, bmpdata.Stride / 4, false, false, 1, currTileDataState.Tile, 1);
|
|
else if (currTileDataState.Type == eDisplayType.TilesMode7Ext)
|
|
gd.RenderMode7TilesToScreen((int*)bmpdata.Scan0, bmpdata.Stride / 4, true, false, 1, currTileDataState.Tile, 1);
|
|
else if (currTileDataState.Type == eDisplayType.TilesMode7DC)
|
|
gd.RenderMode7TilesToScreen((int*)bmpdata.Scan0, bmpdata.Stride / 4, false, true, 1, currTileDataState.Tile, 1);
|
|
else if (currTileDataState.Type == eDisplayType.OBJTiles0 || currTileDataState.Type == eDisplayType.OBJTiles1)
|
|
{
|
|
//render an obj tile
|
|
int tile = currTileDataState.Address / 32;
|
|
gd.RenderTilesToScreen((int*)bmpdata.Scan0, 1, 1, bmpdata.Stride / 4, bpp, currPaletteSelection.start, tile, 1);
|
|
}
|
|
else gd.RenderTilesToScreen((int*)bmpdata.Scan0, 1, 1, bmpdata.Stride / 4, bpp, currPaletteSelection.start, currTileDataState.Tile, 1);
|
|
|
|
bmp.UnlockBits(bmpdata);
|
|
viewerTile.SetBitmap(bmp);
|
|
}
|
|
else if (currObjDataState != null)
|
|
{
|
|
var bounds = si.ObjSizeBoundsSquare;
|
|
int width = bounds.Width;
|
|
int height = bounds.Height;
|
|
var bmp = new Bitmap(width, height, System.Drawing.Imaging.PixelFormat.Format32bppArgb);
|
|
var bmpdata = bmp.LockBits(new Rectangle(0, 0, width, height), System.Drawing.Imaging.ImageLockMode.WriteOnly, System.Drawing.Imaging.PixelFormat.Format32bppArgb);
|
|
gd.RenderSpriteToScreen((int*)bmpdata.Scan0, bmpdata.Stride / 4, 0, 0, si, currObjDataState.Number);
|
|
bmp.UnlockBits(bmpdata);
|
|
viewerObj.SetBitmap(bmp);
|
|
}
|
|
else
|
|
{
|
|
var bmp = new Bitmap(8, 8, System.Drawing.Imaging.PixelFormat.Format32bppArgb);
|
|
viewerTile.SetBitmap(bmp);
|
|
}
|
|
}
|
|
|
|
void HandleTileViewMouseOver(int pxacross, int pxtall, int bpp, int tx, int ty)
|
|
{
|
|
int tilestride = pxacross / 8;
|
|
int tilesTall = pxtall / 8;
|
|
if (tx < 0 || ty < 0 || tx >= tilestride || ty >= tilesTall)
|
|
return;
|
|
int tilenum = ty * tilestride + tx;
|
|
currTileDataState = new TileDataState();
|
|
currTileDataState.Bpp = bpp;
|
|
currTileDataState.Type = CurrDisplaySelection;
|
|
currTileDataState.Tile = tilenum;
|
|
currTileDataState.Address = (bpp==7?8:bpp) * 8 * currTileDataState.Tile;
|
|
currTileDataState.Palette = currPaletteSelection.start;
|
|
if (CurrDisplaySelection == eDisplayType.OBJTiles0 || CurrDisplaySelection == eDisplayType.OBJTiles1)
|
|
{
|
|
if (tilenum < 256)
|
|
currTileDataState.Address += si.OBJTable0Addr;
|
|
else
|
|
currTileDataState.Address += si.OBJTable1Addr - (256*32);
|
|
|
|
currTileDataState.Address &= 0xFFFF;
|
|
}
|
|
else if (SNESGraphicsDecoder.BGModeIsMode7Type(BGModeForDisplayType(CurrDisplaySelection)))
|
|
{
|
|
currTileDataState.Address *= 2;
|
|
}
|
|
|
|
SetTab(tpTile);
|
|
}
|
|
|
|
void HandleSpriteMouseOver(int px, int py)
|
|
{
|
|
if (px < 0 || py < 0 || px >= 256 || py >= 224) return;
|
|
|
|
int sprite = spriteMap[px,py];
|
|
if(sprite == 0xFF) return;
|
|
|
|
currObjDataState = new ObjDataState();
|
|
currObjDataState.Number = sprite;
|
|
|
|
SetTab(tpOBJ);
|
|
}
|
|
|
|
void HandleObjMouseOver(int px, int py)
|
|
{
|
|
int ox = px / si.ObjSizeBounds.Width;
|
|
int oy = py / si.ObjSizeBounds.Height;
|
|
|
|
if (ox < 0 || oy < 0 || ox >= 8 || oy >= 16)
|
|
return;
|
|
|
|
int objNum = oy * 8 + ox;
|
|
|
|
currObjDataState = new ObjDataState();
|
|
currObjDataState.Number = objNum;
|
|
|
|
//RenderView(); //remember, we were going to highlight the selected sprite somehow as we hover over it
|
|
SetTab(tpOBJ);
|
|
}
|
|
|
|
void SetTab(TabPage tpSet)
|
|
{
|
|
//doesnt work well
|
|
//foreach (var tp in tabctrlDetails.TabPages)
|
|
// ((TabPage)tp).Visible = tpSet != null;
|
|
if (tpSet != null)
|
|
{
|
|
tpSet.Visible = true;
|
|
tabctrlDetails.SelectedTab = tpSet;
|
|
}
|
|
}
|
|
|
|
void UpdateViewerMouseover(Point loc)
|
|
{
|
|
currMapEntryState = null;
|
|
currTileDataState = null;
|
|
currObjDataState = null;
|
|
|
|
int tx = loc.X / 8;
|
|
int ty = loc.Y / 8;
|
|
|
|
switch (CurrDisplaySelection)
|
|
{
|
|
case eDisplayType.OBJTiles0:
|
|
case eDisplayType.OBJTiles1:
|
|
HandleTileViewMouseOver(128, 256, 4, tx, ty);
|
|
break;
|
|
case eDisplayType.OBJ:
|
|
HandleObjMouseOver(loc.X, loc.Y);
|
|
break;
|
|
case eDisplayType.Sprites:
|
|
HandleSpriteMouseOver(loc.X, loc.Y);
|
|
break;
|
|
case eDisplayType.Tiles2bpp:
|
|
HandleTileViewMouseOver(512, 512, 2, tx, ty);
|
|
break;
|
|
case eDisplayType.Tiles4bpp:
|
|
HandleTileViewMouseOver(512, 256, 4, tx, ty);
|
|
break;
|
|
case eDisplayType.Tiles8bpp:
|
|
HandleTileViewMouseOver(256, 256, 8, tx, ty);
|
|
break;
|
|
case eDisplayType.TilesMode7:
|
|
case eDisplayType.TilesMode7DC:
|
|
HandleTileViewMouseOver(128, 128, 8, tx, ty);
|
|
break;
|
|
case eDisplayType.TilesMode7Ext:
|
|
HandleTileViewMouseOver(128, 128, 7, tx, ty);
|
|
break;
|
|
case eDisplayType.BG1:
|
|
case eDisplayType.BG2:
|
|
case eDisplayType.BG3:
|
|
case eDisplayType.BG4:
|
|
{
|
|
var bg = si.BG[(int)CurrDisplaySelection];
|
|
|
|
if (bg.TileSize == 16) { tx /= 2; ty /= 2; } //worry about this later. need to pass a different flag into `currViewingTile`
|
|
|
|
int tloc = ty * bg.ScreenSizeInTiles.Width + tx;
|
|
if (tloc > map.Length) break;
|
|
|
|
currMapEntryState = new MapEntryState();
|
|
currMapEntryState.bgnum = (int)CurrDisplaySelection;
|
|
currMapEntryState.entry = map[tloc];
|
|
currMapEntryState.Location = new Point(tx, ty);
|
|
|
|
//public void DecodeBG(int* screen, int stride, TileEntry[] map, int tiledataBaseAddr, ScreenSize size, int bpp, int tilesize, int paletteStart)
|
|
|
|
|
|
//var map = gd.FetchTilemap(bg.ScreenAddr, bg.ScreenSize);
|
|
//int paletteStart = 0;
|
|
//gd.DecodeBG(pixelptr, stride / 4, map, bg.TiledataAddr, bg.ScreenSize, bg.Bpp, bg.TileSize, paletteStart);
|
|
//gd.Paletteize(pixelptr, 0, 0, numPixels);
|
|
|
|
SetTab(tpMapEntry);
|
|
}
|
|
break;
|
|
}
|
|
|
|
RenderTileView();
|
|
UpdateMapEntryDetails();
|
|
UpdateTileDetails();
|
|
UpdateOBJDetails();
|
|
}
|
|
|
|
private void viewer_MouseLeave(object sender, EventArgs e)
|
|
{
|
|
SetTab(null);
|
|
}
|
|
|
|
private void paletteViewer_MouseDown(object sender, MouseEventArgs e)
|
|
{
|
|
if ((e.Button & System.Windows.Forms.MouseButtons.Right) != 0)
|
|
Freeze();
|
|
}
|
|
|
|
private void paletteViewer_MouseEnter(object sender, EventArgs e)
|
|
{
|
|
tabctrlDetails.SelectedIndex = 0;
|
|
}
|
|
|
|
private void paletteViewer_MouseLeave(object sender, EventArgs e)
|
|
{
|
|
SetTab(null);
|
|
}
|
|
|
|
private void paletteViewer_MouseMove(object sender, MouseEventArgs e)
|
|
{
|
|
Point pt;
|
|
bool valid = TranslatePaletteCoord(e.Location, out pt);
|
|
if (!valid) return;
|
|
lastColorNum = pt.Y * 16 + pt.X;
|
|
UpdateColorDetails();
|
|
SetTab(tpPalette);
|
|
}
|
|
|
|
static int DecodeWinformsColorToSNES(Color winforms)
|
|
{
|
|
int r = winforms.R;
|
|
int g = winforms.G;
|
|
int b = winforms.B;
|
|
r >>= 3;
|
|
g >>= 3;
|
|
b >>= 3;
|
|
int col = r | (g << 5) | (b << 10);
|
|
return col;
|
|
}
|
|
|
|
void SyncBackdropColor()
|
|
{
|
|
//TODO
|
|
//if (checkBackdropColor.Checked)
|
|
//{
|
|
// int col = DecodeWinformsColorToSNES(pnBackdropColor.BackColor);
|
|
// LibsnesDll.snes_set_backdropColor(col);
|
|
//}
|
|
//else
|
|
//{
|
|
// LibsnesDll.snes_set_backdropColor(-1);
|
|
//}
|
|
}
|
|
|
|
private void checkBackdropColor_CheckedChanged(object sender, EventArgs e)
|
|
{
|
|
Global.Config.SNESGraphicsUseUserBackdropColor = checkBackdropColor.Checked;
|
|
SyncBackdropColor();
|
|
RegenerateData();
|
|
}
|
|
|
|
private void pnBackdropColor_MouseDoubleClick(object sender, MouseEventArgs e)
|
|
{
|
|
var cd = new ColorDialog();
|
|
cd.Color = pnBackdropColor.BackColor;
|
|
if (cd.ShowDialog(this) == System.Windows.Forms.DialogResult.OK)
|
|
{
|
|
pnBackdropColor.BackColor = cd.Color;
|
|
Global.Config.SNESGraphicsUserBackdropColor = pnBackdropColor.BackColor.ToArgb();
|
|
SyncBackdropColor();
|
|
}
|
|
}
|
|
|
|
protected override bool ProcessCmdKey(ref Message msg, Keys keyData)
|
|
{
|
|
if(keyData == (Keys.C | Keys.Control))
|
|
{
|
|
// find the control under the mouse
|
|
Point m = System.Windows.Forms.Cursor.Position;
|
|
Control top = this;
|
|
Control found = null;
|
|
do
|
|
{
|
|
found = top.GetChildAtPoint(top.PointToClient(m), GetChildAtPointSkip.Invisible);
|
|
top = found;
|
|
} while (found != null && found.HasChildren);
|
|
|
|
if (found != null && found is SNESGraphicsViewer)
|
|
{
|
|
var v = found as SNESGraphicsViewer;
|
|
lock (v)
|
|
{
|
|
var bmp = v.GetBitmap();
|
|
Clipboard.SetImage(bmp);
|
|
}
|
|
string label = "";
|
|
if (found.Name == "viewer")
|
|
label = displayTypeItems.Find((x) => x.Type == CurrDisplaySelection).Descr;
|
|
if (found.Name == "viewerTile")
|
|
label = "Tile";
|
|
if (found.Name == "viewerMapEntryTile")
|
|
label = "Map Entry";
|
|
if (found.Name == "paletteViewer")
|
|
label = "Palette";
|
|
labelClipboard.Text = label + " copied to clipboard.";
|
|
messagetimer.Stop();
|
|
messagetimer.Start();
|
|
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return base.ProcessCmdKey(ref msg, keyData);
|
|
}
|
|
|
|
|
|
private void messagetimer_Tick(object sender, EventArgs e)
|
|
{
|
|
messagetimer.Stop();
|
|
labelClipboard.Text = "CTRL+C copies the pane under the mouse.";
|
|
}
|
|
|
|
private void comboPalette_SelectedIndexChanged(object sender, EventArgs e)
|
|
{
|
|
if (suppression) return;
|
|
var pal = (SnesColors.ColorType)comboPalette.SelectedValue;
|
|
Console.WriteLine("set {0}", pal);
|
|
var s = (LibsnesCore.SnesSettings)Global.Emulator.GetSettings();
|
|
s.Palette = pal.ToString();
|
|
if (currentSnesCore != null)
|
|
{
|
|
currentSnesCore.PutSettings(s);
|
|
}
|
|
RegenerateData();
|
|
RenderView();
|
|
RenderPalette();
|
|
RenderTileView();
|
|
}
|
|
|
|
void RefreshBGENCheckStatesFromConfig()
|
|
{
|
|
var s = (LibsnesCore.SnesSettings)Global.Emulator.GetSettings();
|
|
checkEN0_BG1.Checked = s.ShowBG1_0;
|
|
checkEN0_BG2.Checked = s.ShowBG2_0;
|
|
checkEN0_BG3.Checked = s.ShowBG3_0;
|
|
checkEN0_BG4.Checked = s.ShowBG4_0;
|
|
checkEN1_BG1.Checked = s.ShowBG1_1;
|
|
checkEN1_BG2.Checked = s.ShowBG2_1;
|
|
checkEN1_BG3.Checked = s.ShowBG3_1;
|
|
checkEN1_BG4.Checked = s.ShowBG4_1;
|
|
checkEN0_OBJ.Checked = s.ShowOBJ_0;
|
|
checkEN1_OBJ.Checked = s.ShowOBJ_1;
|
|
checkEN2_OBJ.Checked = s.ShowOBJ_2;
|
|
checkEN3_OBJ.Checked = s.ShowOBJ_3;
|
|
}
|
|
|
|
private void checkEN_CheckedChanged(object sender, EventArgs e)
|
|
{
|
|
if(suppression) return;
|
|
var s = (LibsnesCore.SnesSettings)Global.Emulator.GetSettings();
|
|
if (sender == checkEN0_BG1) s.ShowBG1_0 = checkEN0_BG1.Checked;
|
|
if (sender == checkEN0_BG2) s.ShowBG2_0 = checkEN0_BG2.Checked;
|
|
if (sender == checkEN0_BG3) s.ShowBG3_0 = checkEN0_BG3.Checked;
|
|
if (sender == checkEN0_BG4) s.ShowBG4_0 = checkEN0_BG4.Checked;
|
|
if (sender == checkEN1_BG1) s.ShowBG1_1 = checkEN1_BG1.Checked;
|
|
if (sender == checkEN1_BG2) s.ShowBG2_1 = checkEN1_BG2.Checked;
|
|
if (sender == checkEN1_BG3) s.ShowBG3_1 = checkEN1_BG3.Checked;
|
|
if (sender == checkEN1_BG4) s.ShowBG4_1 = checkEN1_BG4.Checked;
|
|
if (sender == checkEN0_OBJ) s.ShowOBJ_0 = checkEN0_OBJ.Checked;
|
|
if (sender == checkEN1_OBJ) s.ShowOBJ_1 = checkEN1_OBJ.Checked;
|
|
if (sender == checkEN2_OBJ) s.ShowOBJ_2 = checkEN2_OBJ.Checked;
|
|
if (sender == checkEN3_OBJ) s.ShowOBJ_3 = checkEN3_OBJ.Checked;
|
|
|
|
if ((Control.ModifierKeys & Keys.Shift) != 0)
|
|
{
|
|
if (sender == checkEN0_BG1) s.ShowBG1_1 = s.ShowBG1_0;
|
|
if (sender == checkEN1_BG1) s.ShowBG1_0 = s.ShowBG1_1;
|
|
if (sender == checkEN0_BG2) s.ShowBG2_1 = s.ShowBG2_0;
|
|
if (sender == checkEN1_BG2) s.ShowBG2_0 = s.ShowBG2_1;
|
|
if (sender == checkEN0_BG3) s.ShowBG3_1 = s.ShowBG3_0;
|
|
if (sender == checkEN1_BG3) s.ShowBG3_0 = s.ShowBG3_1;
|
|
if (sender == checkEN0_BG4) s.ShowBG4_1 = s.ShowBG4_0;
|
|
if (sender == checkEN1_BG4) s.ShowBG4_0 = s.ShowBG4_1;
|
|
if (sender == checkEN0_OBJ) s.ShowOBJ_1 = s.ShowOBJ_2 = s.ShowOBJ_3 = s.ShowOBJ_0;
|
|
if (sender == checkEN1_OBJ) s.ShowOBJ_0 = s.ShowOBJ_2 = s.ShowOBJ_3 = s.ShowOBJ_1;
|
|
if (sender == checkEN2_OBJ) s.ShowOBJ_0 = s.ShowOBJ_1 = s.ShowOBJ_3 = s.ShowOBJ_2;
|
|
if (sender == checkEN3_OBJ) s.ShowOBJ_0 = s.ShowOBJ_1 = s.ShowOBJ_2 = s.ShowOBJ_3;
|
|
suppression = true;
|
|
RefreshBGENCheckStatesFromConfig();
|
|
suppression = false;
|
|
}
|
|
Global.Emulator.PutSettings(s);
|
|
}
|
|
|
|
private void lblEnPrio0_Click(object sender, EventArgs e)
|
|
{
|
|
bool any = checkEN0_OBJ.Checked || checkEN0_BG1.Checked || checkEN0_BG2.Checked || checkEN0_BG3.Checked || checkEN0_BG4.Checked;
|
|
bool all = checkEN0_OBJ.Checked && checkEN0_BG1.Checked && checkEN0_BG2.Checked && checkEN0_BG3.Checked && checkEN0_BG4.Checked;
|
|
bool newval;
|
|
if (all) newval = false;
|
|
else newval = true;
|
|
checkEN0_OBJ.Checked = checkEN0_BG1.Checked = checkEN0_BG2.Checked = checkEN0_BG3.Checked = checkEN0_BG4.Checked = newval;
|
|
|
|
}
|
|
|
|
private void lblEnPrio1_Click(object sender, EventArgs e)
|
|
{
|
|
bool any = checkEN1_OBJ.Checked || checkEN1_BG1.Checked || checkEN1_BG2.Checked || checkEN1_BG3.Checked || checkEN1_BG4.Checked;
|
|
bool all = checkEN1_OBJ.Checked && checkEN1_BG1.Checked && checkEN1_BG2.Checked && checkEN1_BG3.Checked && checkEN1_BG4.Checked;
|
|
bool newval;
|
|
if (all) newval = false;
|
|
else newval = true;
|
|
checkEN1_OBJ.Checked = checkEN1_BG1.Checked = checkEN1_BG2.Checked = checkEN1_BG3.Checked = checkEN1_BG4.Checked = newval;
|
|
|
|
}
|
|
|
|
private void lblEnPrio2_Click(object sender, EventArgs e)
|
|
{
|
|
checkEN2_OBJ.Checked ^= true;
|
|
}
|
|
|
|
private void lblEnPrio3_Click(object sender, EventArgs e)
|
|
{
|
|
checkEN3_OBJ.Checked ^= true;
|
|
}
|
|
|
|
} //class SNESGraphicsDebugger
|
|
} //namespace BizHawk.Client.EmuHawk
|
|
|
|
|
|
static class ControlExtensions
|
|
{
|
|
static string[] secondPass = new[] { "Size" };
|
|
public static T Clone<T>(this T controlToClone)
|
|
where T : Control
|
|
{
|
|
PropertyInfo[] controlProperties = typeof(T).GetProperties(BindingFlags.Public | BindingFlags.Instance);
|
|
|
|
Type t = controlToClone.GetType();
|
|
T instance = Activator.CreateInstance(t) as T;
|
|
|
|
t.GetProperty("AutoSize").SetValue(instance, false, null);
|
|
|
|
for (int i = 0; i < 3; i++)
|
|
{
|
|
foreach (PropertyInfo propInfo in controlProperties)
|
|
{
|
|
if (!propInfo.CanWrite)
|
|
continue;
|
|
|
|
if (propInfo.Name == "AutoSize")
|
|
{ }
|
|
else if (propInfo.Name == "WindowTarget")
|
|
{ }
|
|
else
|
|
propInfo.SetValue(instance, propInfo.GetValue(controlToClone, null), null);
|
|
}
|
|
}
|
|
|
|
if (instance is RetainedViewportPanel)
|
|
{
|
|
var clonebmp = ((controlToClone) as RetainedViewportPanel).GetBitmap().Clone() as Bitmap;
|
|
((instance) as RetainedViewportPanel).SetBitmap(clonebmp);
|
|
}
|
|
|
|
return instance;
|
|
}
|
|
} |