void render_crosshair::draw(render_container &container, u8 fade)
{
// add a quad assuming a 4:3 screen (this is not perfect)
container.add_quad(m_x - 0.03f, m_y - 0.04f, m_x + 0.03f, m_y + 0.04f,
rgb_t(0xc0, fade, fade, fade),
m_texture, PRIMFLAG_BLENDMODE(BLENDMODE_ALPHA));
}
static void palette_handler(mame_ui_manager &mui, render_container &container, ui_gfx_state &state)
{
device_palette_interface *palette = state.palette.interface;
palette_device *paldev = dynamic_cast<palette_device *>(&palette->device());
int total = state.palette.which ? palette->indirect_entries() : palette->entries();
const rgb_t *raw_color = palette->palette()->entry_list_raw();
render_font *ui_font = mui.get_font();
float chwidth, chheight;
float titlewidth;
float x0, y0;
render_bounds cellboxbounds;
render_bounds boxbounds;
int x, y, skip;
// add a half character padding for the box
chheight = mui.get_line_height();
chwidth = ui_font->char_width(chheight, mui.machine().render().ui_aspect(), '0');
boxbounds.x0 = 0.0f + 0.5f * chwidth;
boxbounds.x1 = 1.0f - 0.5f * chwidth;
boxbounds.y0 = 0.0f + 0.5f * chheight;
boxbounds.y1 = 1.0f - 0.5f * chheight;
// the character cell box bounds starts a half character in from the box
cellboxbounds = boxbounds;
cellboxbounds.x0 += 0.5f * chwidth;
cellboxbounds.x1 -= 0.5f * chwidth;
cellboxbounds.y0 += 0.5f * chheight;
cellboxbounds.y1 -= 0.5f * chheight;
// add space on the left for 5 characters of text, plus a half character of padding
cellboxbounds.x0 += 5.5f * chwidth;
// add space on the top for a title, a half line of padding, a header, and another half line
cellboxbounds.y0 += 3.0f * chheight;
// compute the cell size
float cellwidth = (cellboxbounds.x1 - cellboxbounds.x0) / (float)state.palette.columns;
float cellheight = (cellboxbounds.y1 - cellboxbounds.y0) / (float)state.palette.columns;
// figure out the title
std::ostringstream title_buf;
util::stream_format(title_buf, "'%s'", palette->device().tag());
if (palette->indirect_entries() > 0)
title_buf << (state.palette.which ? _(" COLORS") : _(" PENS"));
// if the mouse pointer is over one of our cells, add some info about the corresponding palette entry
int32_t mouse_target_x, mouse_target_y;
float mouse_x, mouse_y;
bool mouse_button;
render_target *mouse_target = mui.machine().ui_input().find_mouse(&mouse_target_x, &mouse_target_y, &mouse_button);
if (mouse_target != nullptr && mouse_target->map_point_container(mouse_target_x, mouse_target_y, container, mouse_x, mouse_y)
&& cellboxbounds.x0 <= mouse_x && cellboxbounds.x1 > mouse_x
&& cellboxbounds.y0 <= mouse_y && cellboxbounds.y1 > mouse_y)
{
int index = state.palette.offset + int((mouse_x - cellboxbounds.x0) / cellwidth) + int((mouse_y - cellboxbounds.y0) / cellheight) * state.palette.columns;
if (index < total)
{
util::stream_format(title_buf, " #%X", index);
if (palette->indirect_entries() > 0 && !state.palette.which)
util::stream_format(title_buf, " => %X", palette->pen_indirect(index));
else if (paldev != nullptr && paldev->basemem().base() != nullptr)
util::stream_format(title_buf, " = %X", paldev->read_entry(index));
rgb_t col = state.palette.which ? palette->indirect_color(index) : raw_color[index];
util::stream_format(title_buf, " (R:%X G:%X B:%X)", col.r(), col.g(), col.b());
}
}
// expand the outer box to fit the title
const std::string title = title_buf.str();
titlewidth = ui_font->string_width(chheight, mui.machine().render().ui_aspect(), title.c_str());
x0 = 0.0f;
if (boxbounds.x1 - boxbounds.x0 < titlewidth + chwidth)
x0 = boxbounds.x0 - (0.5f - 0.5f * (titlewidth + chwidth));
// go ahead and draw the outer box now
mui.draw_outlined_box(container, boxbounds.x0 - x0, boxbounds.y0, boxbounds.x1 + x0, boxbounds.y1, UI_GFXVIEWER_BG_COLOR);
// draw the title
x0 = 0.5f - 0.5f * titlewidth;
y0 = boxbounds.y0 + 0.5f * chheight;
for (auto ch : title)
{
container.add_char(x0, y0, chheight, mui.machine().render().ui_aspect(), rgb_t::white(), *ui_font, ch);
x0 += ui_font->char_width(chheight, mui.machine().render().ui_aspect(), ch);
}
// draw the top column headers
skip = (int)(chwidth / cellwidth);
for (x = 0; x < state.palette.columns; x += 1 + skip)
{
x0 = boxbounds.x0 + 6.0f * chwidth + (float)x * cellwidth;
y0 = boxbounds.y0 + 2.0f * chheight;
container.add_char(x0 + 0.5f * (cellwidth - chwidth), y0, chheight, mui.machine().render().ui_aspect(), rgb_t::white(), *ui_font, "0123456789ABCDEF"[x & 0xf]);
// if we're skipping, draw a point between the character and the box to indicate which
// one it's referring to
if (skip != 0)
container.add_point(x0 + 0.5f * cellwidth, 0.5f * (y0 + chheight + cellboxbounds.y0), UI_LINE_WIDTH, rgb_t::white(), PRIMFLAG_BLENDMODE(BLENDMODE_ALPHA));
}
// draw the side column headers
skip = (int)(chheight / cellheight);
for (y = 0; y < state.palette.columns; y += 1 + skip)
// only display if there is data to show
if (state.palette.offset + y * state.palette.columns < total)
{
char buffer[10];
// if we're skipping, draw a point between the character and the box to indicate which
// one it's referring to
x0 = boxbounds.x0 + 5.5f * chwidth;
y0 = boxbounds.y0 + 3.5f * chheight + (float)y * cellheight;
if (skip != 0)
container.add_point(0.5f * (x0 + cellboxbounds.x0), y0 + 0.5f * cellheight, UI_LINE_WIDTH, rgb_t::white(), PRIMFLAG_BLENDMODE(BLENDMODE_ALPHA));
// draw the row header
sprintf(buffer, "%5X", state.palette.offset + y * state.palette.columns);
for (x = 4; x >= 0; x--)
{
x0 -= ui_font->char_width(chheight, mui.machine().render().ui_aspect(), buffer[x]);
container.add_char(x0, y0 + 0.5f * (cellheight - chheight), chheight, mui.machine().render().ui_aspect(), rgb_t::white(), *ui_font, buffer[x]);
}
}
// now add the rectangles for the colors
for (y = 0; y < state.palette.columns; y++)
for (x = 0; x < state.palette.columns; x++)
{
int index = state.palette.offset + y * state.palette.columns + x;
if (index < total)
{
pen_t pen = state.palette.which ? palette->indirect_color(index) : raw_color[index];
container.add_rect(cellboxbounds.x0 + x * cellwidth, cellboxbounds.y0 + y * cellheight,
cellboxbounds.x0 + (x + 1) * cellwidth, cellboxbounds.y0 + (y + 1) * cellheight,
0xff000000 | pen, PRIMFLAG_BLENDMODE(BLENDMODE_ALPHA));
}
}
// handle keys
palette_handle_keys(mui.machine(), state);
}
static void gfxset_handler(mame_ui_manager &mui, render_container &container, ui_gfx_state &state)
{
render_font *ui_font = mui.get_font();
int dev = state.gfxset.devindex;
int set = state.gfxset.set;
ui_gfx_info &info = state.gfxdev[dev];
device_gfx_interface &interface = *info.interface;
gfx_element &gfx = *interface.gfx(set);
float fullwidth, fullheight;
float cellwidth, cellheight;
float chwidth, chheight;
float titlewidth;
float x0, y0;
render_bounds cellboxbounds;
render_bounds boxbounds;
int cellboxwidth, cellboxheight;
int targwidth = mui.machine().render().ui_target().width();
int targheight = mui.machine().render().ui_target().height();
int cellxpix, cellypix;
int xcells, ycells;
int pixelscale = 0;
int x, y, skip;
// add a half character padding for the box
chheight = mui.get_line_height();
chwidth = ui_font->char_width(chheight, mui.machine().render().ui_aspect(), '0');
boxbounds.x0 = 0.0f + 0.5f * chwidth;
boxbounds.x1 = 1.0f - 0.5f * chwidth;
boxbounds.y0 = 0.0f + 0.5f * chheight;
boxbounds.y1 = 1.0f - 0.5f * chheight;
// the character cell box bounds starts a half character in from the box
cellboxbounds = boxbounds;
cellboxbounds.x0 += 0.5f * chwidth;
cellboxbounds.x1 -= 0.5f * chwidth;
cellboxbounds.y0 += 0.5f * chheight;
cellboxbounds.y1 -= 0.5f * chheight;
// add space on the left for 5 characters of text, plus a half character of padding
cellboxbounds.x0 += 5.5f * chwidth;
// add space on the top for a title, a half line of padding, a header, and another half line
cellboxbounds.y0 += 3.0f * chheight;
// convert back to pixels
cellboxwidth = (cellboxbounds.x1 - cellboxbounds.x0) * (float)targwidth;
cellboxheight = (cellboxbounds.y1 - cellboxbounds.y0) * (float)targheight;
// compute the number of source pixels in a cell
cellxpix = 1 + ((info.rotate[set] & ORIENTATION_SWAP_XY) ? gfx.height() : gfx.width());
cellypix = 1 + ((info.rotate[set] & ORIENTATION_SWAP_XY) ? gfx.width() : gfx.height());
// compute the largest pixel scale factor that still fits
xcells = info.columns[set];
while (xcells > 1)
{
pixelscale = (cellboxwidth / xcells) / cellxpix;
if (pixelscale != 0)
break;
xcells--;
}
info.columns[set] = xcells;
// worst case, we need a pixel scale of 1
pixelscale = std::max(1, pixelscale);
// in the Y direction, we just display as many as we can
ycells = cellboxheight / (pixelscale * cellypix);
// now determine the actual cellbox size
cellboxwidth = std::min(cellboxwidth, xcells * pixelscale * cellxpix);
cellboxheight = std::min(cellboxheight, ycells * pixelscale * cellypix);
// compute the size of a single cell at this pixel scale factor, as well as the aspect ratio
cellwidth = (cellboxwidth / (float)xcells) / (float)targwidth;
cellheight = (cellboxheight / (float)ycells) / (float)targheight;
//cellaspect = cellwidth / cellheight;
// working from the new width/height, recompute the boxbounds
fullwidth = (float)cellboxwidth / (float)targwidth + 6.5f * chwidth;
fullheight = (float)cellboxheight / (float)targheight + 4.0f * chheight;
// recompute boxbounds from this
boxbounds.x0 = (1.0f - fullwidth) * 0.5f;
boxbounds.x1 = boxbounds.x0 + fullwidth;
boxbounds.y0 = (1.0f - fullheight) * 0.5f;
boxbounds.y1 = boxbounds.y0 + fullheight;
// recompute cellboxbounds
cellboxbounds.x0 = boxbounds.x0 + 6.0f * chwidth;
cellboxbounds.x1 = cellboxbounds.x0 + (float)cellboxwidth / (float)targwidth;
cellboxbounds.y0 = boxbounds.y0 + 3.5f * chheight;
cellboxbounds.y1 = cellboxbounds.y0 + (float)cellboxheight / (float)targheight;
// figure out the title
std::ostringstream title_buf;
util::stream_format(title_buf, "'%s' %d/%d", interface.device().tag(), set, info.setcount - 1);
// if the mouse pointer is over a pixel in a tile, add some info about the tile and pixel
bool found_pixel = false;
int32_t mouse_target_x, mouse_target_y;
float mouse_x, mouse_y;
bool mouse_button;
render_target *mouse_target = mui.machine().ui_input().find_mouse(&mouse_target_x, &mouse_target_y, &mouse_button);
if (mouse_target != nullptr && mouse_target->map_point_container(mouse_target_x, mouse_target_y, container, mouse_x, mouse_y)
&& cellboxbounds.x0 <= mouse_x && cellboxbounds.x1 > mouse_x
&& cellboxbounds.y0 <= mouse_y && cellboxbounds.y1 > mouse_y)
{
int code = info.offset[set] + int((mouse_x - cellboxbounds.x0) / cellwidth) + int((mouse_y - cellboxbounds.y0) / cellheight) * xcells;
int xpixel = int((mouse_x - cellboxbounds.x0) / (cellwidth / cellxpix)) % cellxpix;
int ypixel = int((mouse_y - cellboxbounds.y0) / (cellheight / cellypix)) % cellypix;
if (code < gfx.elements() && xpixel < (cellxpix - 1) && ypixel < (cellypix - 1))
{
found_pixel = true;
if (info.rotate[set] & ORIENTATION_FLIP_X)
xpixel = (cellxpix - 2) - xpixel;
if (info.rotate[set] & ORIENTATION_FLIP_Y)
ypixel = (cellypix - 2) - ypixel;
if (info.rotate[set] & ORIENTATION_SWAP_XY)
std::swap(xpixel, ypixel);
uint8_t pixdata = gfx.get_data(code)[xpixel + ypixel * gfx.rowbytes()];
util::stream_format(title_buf, " #%X:%X @ %d,%d = %X",
code, info.color[set], xpixel, ypixel,
gfx.colorbase() + info.color[set] * gfx.granularity() + pixdata);
}
}
if (!found_pixel)
util::stream_format(title_buf, " %dx%d COLOR %X/%X", gfx.width(), gfx.height(), info.color[set], info.color_count[set]);
// expand the outer box to fit the title
const std::string title = title_buf.str();
titlewidth = ui_font->string_width(chheight, mui.machine().render().ui_aspect(), title.c_str());
x0 = 0.0f;
if (boxbounds.x1 - boxbounds.x0 < titlewidth + chwidth)
x0 = boxbounds.x0 - (0.5f - 0.5f * (titlewidth + chwidth));
// go ahead and draw the outer box now
mui.draw_outlined_box(container, boxbounds.x0 - x0, boxbounds.y0, boxbounds.x1 + x0, boxbounds.y1, UI_GFXVIEWER_BG_COLOR);
// draw the title
x0 = 0.5f - 0.5f * titlewidth;
y0 = boxbounds.y0 + 0.5f * chheight;
for (auto ch : title)
{
container.add_char(x0, y0, chheight, mui.machine().render().ui_aspect(), rgb_t::white(), *ui_font, ch);
x0 += ui_font->char_width(chheight, mui.machine().render().ui_aspect(), ch);
}
// draw the top column headers
skip = (int)(chwidth / cellwidth);
for (x = 0; x < xcells; x += 1 + skip)
{
x0 = boxbounds.x0 + 6.0f * chwidth + (float)x * cellwidth;
y0 = boxbounds.y0 + 2.0f * chheight;
container.add_char(x0 + 0.5f * (cellwidth - chwidth), y0, chheight, mui.machine().render().ui_aspect(), rgb_t::white(), *ui_font, "0123456789ABCDEF"[x & 0xf]);
// if we're skipping, draw a point between the character and the box to indicate which
// one it's referring to
if (skip != 0)
container.add_point(x0 + 0.5f * cellwidth, 0.5f * (y0 + chheight + boxbounds.y0 + 3.5f * chheight), UI_LINE_WIDTH, rgb_t::white(), PRIMFLAG_BLENDMODE(BLENDMODE_ALPHA));
}
// draw the side column headers
skip = (int)(chheight / cellheight);
for (y = 0; y < ycells; y += 1 + skip)
// only display if there is data to show
if (info.offset[set] + y * xcells < gfx.elements())
{
char buffer[10];
// if we're skipping, draw a point between the character and the box to indicate which
// one it's referring to
x0 = boxbounds.x0 + 5.5f * chwidth;
y0 = boxbounds.y0 + 3.5f * chheight + (float)y * cellheight;
if (skip != 0)
container.add_point(0.5f * (x0 + boxbounds.x0 + 6.0f * chwidth), y0 + 0.5f * cellheight, UI_LINE_WIDTH, rgb_t::white(), PRIMFLAG_BLENDMODE(BLENDMODE_ALPHA));
// draw the row header
sprintf(buffer, "%5X", info.offset[set] + y * xcells);
for (x = 4; x >= 0; x--)
{
x0 -= ui_font->char_width(chheight, mui.machine().render().ui_aspect(), buffer[x]);
container.add_char(x0, y0 + 0.5f * (cellheight - chheight), chheight, mui.machine().render().ui_aspect(), rgb_t::white(), *ui_font, buffer[x]);
}
}
// update the bitmap
gfxset_update_bitmap(mui.machine(), state, xcells, ycells, gfx);
// add the final quad
container.add_quad(cellboxbounds.x0, cellboxbounds.y0, cellboxbounds.x1, cellboxbounds.y1,
rgb_t::white(), state.texture, PRIMFLAG_BLENDMODE(BLENDMODE_ALPHA));
// handle keyboard navigation before drawing
gfxset_handle_keys(mui.machine(), state, xcells, ycells);
}
static void tilemap_handler(mame_ui_manager &mui, render_container &container, ui_gfx_state &state)
{
render_font *ui_font = mui.get_font();
float chwidth, chheight;
render_bounds mapboxbounds;
render_bounds boxbounds;
int targwidth = mui.machine().render().ui_target().width();
int targheight = mui.machine().render().ui_target().height();
float titlewidth;
float x0, y0;
int mapboxwidth, mapboxheight;
// get the size of the tilemap itself
tilemap_t *tilemap = mui.machine().tilemap().find(state.tilemap.which);
uint32_t mapwidth = tilemap->width();
uint32_t mapheight = tilemap->height();
if (state.tilemap.rotate & ORIENTATION_SWAP_XY)
std::swap(mapwidth, mapheight);
// add a half character padding for the box
chheight = mui.get_line_height();
chwidth = ui_font->char_width(chheight, mui.machine().render().ui_aspect(), '0');
boxbounds.x0 = 0.0f + 0.5f * chwidth;
boxbounds.x1 = 1.0f - 0.5f * chwidth;
boxbounds.y0 = 0.0f + 0.5f * chheight;
boxbounds.y1 = 1.0f - 0.5f * chheight;
// the tilemap box bounds starts a half character in from the box
mapboxbounds = boxbounds;
mapboxbounds.x0 += 0.5f * chwidth;
mapboxbounds.x1 -= 0.5f * chwidth;
mapboxbounds.y0 += 0.5f * chheight;
mapboxbounds.y1 -= 0.5f * chheight;
// add space on the top for a title and a half line of padding
mapboxbounds.y0 += 1.5f * chheight;
// convert back to pixels
mapboxwidth = (mapboxbounds.x1 - mapboxbounds.x0) * (float)targwidth;
mapboxheight = (mapboxbounds.y1 - mapboxbounds.y0) * (float)targheight;
// determine the maximum integral scaling factor
int pixelscale = state.tilemap.zoom;
if (pixelscale == 0)
{
int maxxscale, maxyscale;
for (maxxscale = 1; mapwidth * (maxxscale + 1) < mapboxwidth; maxxscale++) { }
for (maxyscale = 1; mapheight * (maxyscale + 1) < mapboxheight; maxyscale++) { }
pixelscale = std::min(maxxscale, maxyscale);
}
// recompute the final box size
mapboxwidth = std::min(mapboxwidth, int(mapwidth * pixelscale));
mapboxheight = std::min(mapboxheight, int(mapheight * pixelscale));
// recompute the bounds, centered within the existing bounds
mapboxbounds.x0 += 0.5f * ((mapboxbounds.x1 - mapboxbounds.x0) - (float)mapboxwidth / (float)targwidth);
mapboxbounds.x1 = mapboxbounds.x0 + (float)mapboxwidth / (float)targwidth;
mapboxbounds.y0 += 0.5f * ((mapboxbounds.y1 - mapboxbounds.y0) - (float)mapboxheight / (float)targheight);
mapboxbounds.y1 = mapboxbounds.y0 + (float)mapboxheight / (float)targheight;
// now recompute the outer box against this new info
boxbounds.x0 = mapboxbounds.x0 - 0.5f * chwidth;
boxbounds.x1 = mapboxbounds.x1 + 0.5f * chwidth;
boxbounds.y0 = mapboxbounds.y0 - 2.0f * chheight;
boxbounds.y1 = mapboxbounds.y1 + 0.5f * chheight;
// figure out the title
std::ostringstream title_buf;
util::stream_format(title_buf, "TILEMAP %d/%d", state.tilemap.which + 1, mui.machine().tilemap().count());
// if the mouse pointer is over a tile, add some info about its coordinates and color
int32_t mouse_target_x, mouse_target_y;
float mouse_x, mouse_y;
bool mouse_button;
render_target *mouse_target = mui.machine().ui_input().find_mouse(&mouse_target_x, &mouse_target_y, &mouse_button);
if (mouse_target != nullptr && mouse_target->map_point_container(mouse_target_x, mouse_target_y, container, mouse_x, mouse_y)
&& mapboxbounds.x0 <= mouse_x && mapboxbounds.x1 > mouse_x
&& mapboxbounds.y0 <= mouse_y && mapboxbounds.y1 > mouse_y)
{
int xpixel = (mouse_x - mapboxbounds.x0) * targwidth;
int ypixel = (mouse_y - mapboxbounds.y0) * targheight;
if (state.tilemap.rotate & ORIENTATION_FLIP_X)
xpixel = (mapboxwidth - 1) - xpixel;
if (state.tilemap.rotate & ORIENTATION_FLIP_Y)
ypixel = (mapboxheight - 1) - ypixel;
if (state.tilemap.rotate & ORIENTATION_SWAP_XY)
std::swap(xpixel, ypixel);
uint32_t col = ((xpixel / pixelscale + state.tilemap.xoffs) / tilemap->tilewidth()) % tilemap->cols();
uint32_t row = ((ypixel / pixelscale + state.tilemap.yoffs) / tilemap->tileheight()) % tilemap->rows();
uint8_t gfxnum;
uint32_t code, color;
tilemap->get_info_debug(col, row, gfxnum, code, color);
util::stream_format(title_buf, " @ %d,%d = GFX%d #%X:%X",
col * tilemap->tilewidth(), row * tilemap->tileheight(),
int(gfxnum), code, color);
}
else
util::stream_format(title_buf, " %dx%d OFFS %d,%d", tilemap->width(), tilemap->height(), state.tilemap.xoffs, state.tilemap.yoffs);
if (state.tilemap.flags != TILEMAP_DRAW_ALL_CATEGORIES)
util::stream_format(title_buf, " CAT %d", state.tilemap.flags);
// expand the outer box to fit the title
const std::string title = title_buf.str();
titlewidth = ui_font->string_width(chheight, mui.machine().render().ui_aspect(), title.c_str());
if (boxbounds.x1 - boxbounds.x0 < titlewidth + chwidth)
{
boxbounds.x0 = 0.5f - 0.5f * (titlewidth + chwidth);
boxbounds.x1 = boxbounds.x0 + titlewidth + chwidth;
}
// go ahead and draw the outer box now
mui.draw_outlined_box(container, boxbounds.x0, boxbounds.y0, boxbounds.x1, boxbounds.y1, UI_GFXVIEWER_BG_COLOR);
// draw the title
x0 = 0.5f - 0.5f * titlewidth;
y0 = boxbounds.y0 + 0.5f * chheight;
for (auto ch : title)
{
container.add_char(x0, y0, chheight, mui.machine().render().ui_aspect(), rgb_t::white(), *ui_font, ch);
x0 += ui_font->char_width(chheight, mui.machine().render().ui_aspect(), ch);
}
// update the bitmap
tilemap_update_bitmap(mui.machine(), state, mapboxwidth / pixelscale, mapboxheight / pixelscale);
// add the final quad
container.add_quad(mapboxbounds.x0, mapboxbounds.y0,
mapboxbounds.x1, mapboxbounds.y1,
rgb_t::white(), state.texture,
PRIMFLAG_BLENDMODE(BLENDMODE_ALPHA) | PRIMFLAG_TEXORIENT(state.tilemap.rotate));
// handle keyboard input
tilemap_handle_keys(mui.machine(), state, mapboxwidth, mapboxheight);
}
