Sprinter/mame
2
0
Fork 0
mirror of https://github.com/holub/mame synced 2025-10-06 17:08:28 +03:00
Code Issues Actions 3 Packages Projects Releases Wiki Activity

Revert changes in layout view prior to rework of integer scaling

Browse Source
This commit is contained in:
Antonio Giner 2016-03-19 00:02:41 +01:00
parent e39daaf5bd
commit 57199a7dff
7 changed files with 23 additions and 204 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

14
src/emu/layout/horizont.lay
View File

@ -12,20 +12,6 @@
</screen>
</view>
<view name="Integer">
<bounds x="0" y="0" width="1" height="1" scaletype="3" />
<screen index="0">
<bounds left="0" top="0" right="~scr0width~" bottom="~scr0height~" aspectx="4" aspecty="3" scaletype="1" />
</screen>
</view>
<view name="Stretch-H">
<bounds x="0" y="0" width="1" height="1" scaletype="3" />
<screen index="0">
<bounds left="0" top="0" right="~scr0width~" bottom="~scr0height~" aspectx="4" aspecty="3" scaletype="2" />
</screen>
</view>
<view name="Cocktail">
<screen index="0">
<bounds x="0" y="-3.03" width="4" height="3" />

15
src/emu/layout/vertical.lay
View File

@ -1,6 +1,5 @@
<?xml version="1.0"?>
<mamelayout version="2">
<view name="Standard (3:4)">
<screen index="0">
<bounds left="0" top="0" right="3" bottom="4" />
@ -13,20 +12,6 @@
</screen>
</view>
<view name="Integer">
<bounds x="0" y="0" width="1" height="1" scaletype="3" />
<screen index="0">
<bounds left="0" top="0" right="~scr0height~" bottom="~scr0width~" aspectx="3" aspecty="4" scaletype="1" />
</screen>
</view>
<view name="Stretch-H">
<bounds x="0" y="0" width="1" height="1" scaletype="3" />
<screen index="0">
<bounds left="0" top="0" right="~scr0height~" bottom="~scr0width~" aspectx="3" aspecty="4" scaletype="2" />
</screen>
</view>
<view name="Cocktail">
<screen index="0">
<bounds x="-3.03" y="0" width="3" height="4" />

14
src/emu/render.cpp
View File

@ -933,6 +933,8 @@ render_target::render_target(render_manager &manager, const char *layoutfile, UI
// aspect and scale options
m_keepaspect = manager.machine().options().keep_aspect();
m_int_scale_x = manager.machine().options().int_scale_x();
m_int_scale_y = manager.machine().options().int_scale_y();
// determine the base orientation based on options
if (!manager.machine().options().rotate())
@ -1008,11 +1010,6 @@ void render_target::set_bounds(INT32 width, INT32 height, float pixel_aspect)
m_bounds.x0 = m_bounds.y0 = 0;
m_bounds.x1 = (float)width;
m_bounds.y1 = (float)height;
m_pixel_aspect = pixel_aspect != 0.0? pixel_aspect : 1.0;
// Check if our layout needs to be recomputed
if (m_curview != nullptr && m_curview->set_physical_size(width, height, m_pixel_aspect, m_orientation))
m_curview->recompute(m_layerconfig);
}
@ -1221,12 +1218,7 @@ void render_target::compute_minimum_size(INT32 &minwidth, INT32 &minheight)
const rectangle &visarea = (screen->screen_type() == SCREEN_TYPE_VECTOR) ? vectorvis : screen->visible_area();
// apply target orientation to the bounds
render_bounds bounds;
if (m_curview->bounds().scale_type == RENDER_SCALE_FRACTIONAL)
bounds = curitem->bounds();
else
set_render_bounds_wh(&bounds, 0, 0, 1, 1);
render_bounds bounds = curitem->bounds();
apply_orientation(bounds, m_orientation);
normalize_bounds(bounds);

17
src/emu/render.h
View File

@ -173,8 +173,6 @@ struct render_bounds
float y0; // topmost Y coordinate
float x1; // rightmost X coordinate
float y1; // bottommost Y coordinate
float aspect; // aspect ratio for this item
int scale_type; // type of scale for this item
float width() const { return x1 - x0; }
float height() const { return y1 - y0; }
@ -809,7 +807,6 @@ public:
int m_orientation; // orientation of this item
render_bounds m_bounds; // bounds of the item
render_bounds m_rawbounds; // raw (original) bounds of the item
render_bounds m_scaledbounds; // raw bounds of the item after scale is applied
render_color m_color; // color of the item
};
@ -825,7 +822,6 @@ public:
const render_bounds &screen_bounds() const { return m_scrbounds; }
const render_screen_list &screens() const { return m_screens; }
bool layer_enabled(item_layer layer) const { return m_layenabled[layer]; }
int physical_width() const { return m_physical_width; }
//
bool has_art() const { return (m_backdrop_list.count() + m_overlay_list.count() + m_bezel_list.count() + m_cpanel_list.count() + m_marquee_list.count() != 0); }
@ -833,8 +829,6 @@ public:
// operations
void recompute(render_layer_config layerconfig);
bool set_physical_size(INT32 new_width, INT32 new_height, float new_pixel_aspect, int new_orientation);
void scale_bounds(render_bounds *dest, const render_bounds *src);
// resolve tags, if any
void resolve_tags();
@ -845,13 +839,6 @@ private:
std::string m_name; // name of the layout
float m_aspect; // X/Y of the layout
float m_scraspect; // X/Y of the screen areas
int m_physical_width; // render_target's width in pixels
int m_physical_height; // render_target's height in pixels
float m_pixel_aspect; // render_target's pixel aspect
int m_orientation; // render target's orientation
bool m_keepaspect; // constrain aspect ratio
int m_int_scale_x; // horizontal integer scale factor
int m_int_scale_y; // vertical integer scale factor
render_screen_list m_screens; // list of active screens
render_bounds m_bounds; // computed bounds of the view
render_bounds m_scrbounds; // computed bounds of the screens within the view
@ -910,6 +897,7 @@ public:
UINT32 width() const { return m_width; }
UINT32 height() const { return m_height; }
float pixel_aspect() const { return m_pixel_aspect; }
int scale_type() const { return m_scale_type; }
float max_update_rate() const { return m_max_refresh; }
int orientation() const { return m_orientation; }
render_layer_config layer_config() const { return m_layerconfig; }
@ -1014,6 +1002,9 @@ private:
render_bounds m_bounds; // bounds of the target
bool m_keepaspect; // constrain aspect ratio
float m_pixel_aspect; // aspect ratio of individual pixels
int m_scale_type; // type of scale to apply
int m_int_scale_x; // horizontal integer scale factor
int m_int_scale_y; // vertical integer scale factor
float m_max_refresh; // maximum refresh rate, 0 or if none
int m_orientation; // orientation
render_layer_config m_layerconfig; // layer configuration

155
src/emu/rendlay.cpp
View File

@ -99,14 +99,6 @@ enum
//**************************************************************************
// MACROS
//**************************************************************************
#define FSWAP(var1, var2) do { float temp = var1; var1 = var2; var2 = temp; } while (0)
//**************************************************************************
// GLOBAL VARIABLES
//**************************************************************************
@ -313,11 +305,6 @@ void parse_bounds(running_machine &machine, xml_data_node *boundsnode, render_bo
}
// parse out the data
bounds.scale_type = xml_get_attribute_int_with_subst(machine, *boundsnode, "scaletype", 0);
int aspectx = xml_get_attribute_int_with_subst(machine, *boundsnode, "aspectx", 1);
int aspecty = xml_get_attribute_int_with_subst(machine, *boundsnode, "aspecty", 1);
bounds.aspect = (float)aspectx / (float)aspecty;
if (xml_get_attribute(boundsnode, "left") != nullptr)
{
// left/right/top/bottom format
@ -2145,13 +2132,7 @@ void layout_element::component::apply_skew(bitmap_argb32 &dest, int skewwidth)
layout_view::layout_view(running_machine &machine, xml_data_node &viewnode, simple_list<layout_element> &elemlist)
: m_next(nullptr),
m_aspect(1.0f),
m_scraspect(1.0f),
m_physical_width(0),
m_physical_height(0),
m_orientation(0),
m_keepaspect(machine.options().keep_aspect()),
m_int_scale_x(machine.options().int_scale_x()),
m_int_scale_y(machine.options().int_scale_y())
m_scraspect(1.0f)
{
// allocate a copy of the name
m_name = xml_get_attribute_string_with_subst(machine, viewnode, "name", "");
@ -2252,23 +2233,20 @@ void layout_view::recompute(render_layer_config layerconfig)
if (m_layenabled[layer])
for (item *curitem = first_item(layer); curitem != nullptr; curitem = curitem->next())
{
// fist apply scale to item bounds if required
scale_bounds(&curitem->m_scaledbounds, &curitem->m_rawbounds);
// accumulate bounds
if (first)
m_bounds = curitem->m_scaledbounds;
m_bounds = curitem->m_rawbounds;
else
union_render_bounds(&m_bounds, &curitem->m_scaledbounds);
union_render_bounds(&m_bounds, &curitem->m_rawbounds);
first = false;
// accumulate screen bounds
if (curitem->m_screen != nullptr)
{
if (scrfirst)
m_scrbounds = curitem->m_scaledbounds;
m_scrbounds = curitem->m_rawbounds;
else
union_render_bounds(&m_scrbounds, &curitem->m_scaledbounds);
union_render_bounds(&m_scrbounds, &curitem->m_rawbounds);
scrfirst = false;
// accumulate the screens in use while we're scanning
@ -2279,7 +2257,7 @@ void layout_view::recompute(render_layer_config layerconfig)
// if we have an explicit bounds, override it
if (m_expbounds.x1 > m_expbounds.x0)
scale_bounds(&m_bounds, &m_expbounds);
m_bounds = m_expbounds;
// if we're handling things normally, the target bounds are (0,0)-(1,1)
render_bounds target_bounds;
@ -2316,127 +2294,14 @@ void layout_view::recompute(render_layer_config layerconfig)
for (item_layer layer = ITEM_LAYER_FIRST; layer < ITEM_LAYER_MAX; ++layer)
for (item *curitem = first_item(layer); curitem != nullptr; curitem = curitem->next())
{
curitem->m_bounds.x0 = target_bounds.x0 + (curitem->m_scaledbounds.x0 - xoffs) * xscale;
curitem->m_bounds.x1 = target_bounds.x0 + (curitem->m_scaledbounds.x1 - xoffs) * xscale;
curitem->m_bounds.y0 = target_bounds.y0 + (curitem->m_scaledbounds.y0 - yoffs) * yscale;
curitem->m_bounds.y1 = target_bounds.y0 + (curitem->m_scaledbounds.y1 - yoffs) * yscale;
curitem->m_bounds.x0 = target_bounds.x0 + (curitem->m_rawbounds.x0 - xoffs) * xscale;
curitem->m_bounds.x1 = target_bounds.x0 + (curitem->m_rawbounds.x1 - xoffs) * xscale;
curitem->m_bounds.y0 = target_bounds.y0 + (curitem->m_rawbounds.y0 - yoffs) * yscale;
curitem->m_bounds.y1 = target_bounds.y0 + (curitem->m_rawbounds.y1 - yoffs) * yscale;
}
}
//-------------------------------------------------
// set_physical_size - update our physical size
// information
//-------------------------------------------------
bool layout_view::set_physical_size(INT32 new_width, INT32 new_height, float new_pixel_aspect, int new_orientation)
{
if ((new_width != 0 && new_height != 0 && new_pixel_aspect != 0.0f) &&
(new_width != m_physical_width || new_height != m_physical_height || new_pixel_aspect != m_pixel_aspect || new_orientation != m_orientation))
{
// physical size has changed
m_physical_width = new_width;
m_physical_height = new_height;
m_pixel_aspect = new_pixel_aspect;
m_orientation = new_orientation;
return true;
}
// physical size was already up-to-date
return false;
}
//-------------------------------------------------
// scale_bounds - apply proper scale type
// to render_bounds
//-------------------------------------------------
void layout_view::scale_bounds(render_bounds *dest, const render_bounds *src)
{
// Start with the raw bounds from the layout file
if (src == nullptr || dest == nullptr)
return;
*dest = *src;
// Get the physical size and properties of the render target which owns us
int target_width = m_physical_width;
int target_height = m_physical_height;
float pixel_aspect = m_keepaspect? m_pixel_aspect: 1.0;
if (target_width == 0 || target_height == 0)
return;
// Apply orientation if required
if (m_orientation & ORIENTATION_SWAP_XY)
{
FSWAP(target_width, target_height);
pixel_aspect = 1.0 / pixel_aspect;
}
// Now, based on the defined scale type for these bounds, apply different methods
switch (src->scale_type)
{
// Fractional: default for standard views (scaletype not defined), just preserve the raw bounds
case RENDER_SCALE_FRACTIONAL:
break;
// Full stretch: bounds are scaled to whole size of the render target. Used by integer scaled views
// to define the bounds of the actual "view".
case RENDER_SCALE_STRETCH_FULL:
{
dest->x0 *= target_width * pixel_aspect;
dest->y0 *= target_height;
dest->x1 *= target_width * pixel_aspect;
dest->y1 *= target_height;
break;
}
// Integer/Strecth-H: bounds are scaled by integer factors. For the Stretch-H case, integer scaling is
// only applied to the vertical axis. Used by integer scaled views, to define the bounds of the "screen".
case RENDER_SCALE_INTEGER:
case RENDER_SCALE_STRETCH_H:
{
float dest_width, dest_width_asp, dest_height, dest_height_asp, dest_aspect;
dest_width = dest_width_asp = (float)target_width;
dest_height = dest_height_asp = (float)target_height;
dest_aspect = dest_width / dest_height * pixel_aspect;
// We need to work out which one is the horizontal axis, regardless of the monitor orientation
float x_scale, y_scale;
if (dest_aspect > 1.0)
{
// x-axis matches monitor's horizontal dimension
dest_width_asp *= m_keepaspect? src->aspect / dest_aspect : 1.0;
x_scale = src->scale_type == RENDER_SCALE_INTEGER?
MAX(1, render_round_nearest(dest_width_asp / src->width())) : dest_width_asp / src->width();
y_scale = MAX(1, render_round_nearest(dest_height / src->height()));
}
else
{
// y-axis matches monitor's vertical dimension
dest_height_asp *= m_keepaspect? dest_aspect / src->aspect : 1.0;
y_scale = src->scale_type == RENDER_SCALE_INTEGER?
MAX(1, render_round_nearest(dest_height_asp / src->height())) : dest_height_asp / src->height();
x_scale = MAX(1, render_round_nearest(dest_width / src->width()));
}
// Check if we have user defined scale factors, if so use them instead
x_scale = m_int_scale_x? m_int_scale_x : x_scale;
y_scale = m_int_scale_y? m_int_scale_y : y_scale;
// Finally, apply scale to bounds
float new_width = src->width() * x_scale;
float new_height = src->height() * y_scale;
float x_border = (dest_width - new_width) / 2;
float y_border = (dest_height - new_height) / 2;
set_render_bounds_wh(dest, x_border * pixel_aspect, y_border, new_width * pixel_aspect, new_height);
break;
}
}
}
//-----------------------------
// resolve_tags - resolve tags
//-----------------------------

6
src/osd/sdl/window.cpp
View File

@ -1192,7 +1192,7 @@ osd_rect sdl_window_info::constrain_to_aspect_ratio(const osd_rect &rect, int ad
osd_monitor_info *monitor = m_monitor;
// do not constrain aspect ratio for integer scaled views
if (m_target->current_view()->bounds().scale_type != RENDER_SCALE_FRACTIONAL)
if (m_target->scale_type() != RENDER_SCALE_FRACTIONAL)
return rect;
// get the pixel aspect ratio for the target monitor
@ -1316,7 +1316,7 @@ osd_dim sdl_window_info::get_min_bounds(int constrain)
minheight += wnd_extra_height();
// if we want it constrained, figure out which one is larger
if (constrain && m_target->current_view()->bounds().scale_type == RENDER_SCALE_FRACTIONAL)
if (constrain && m_target->scale_type() == RENDER_SCALE_FRACTIONAL)
{
// first constrain with no height limit
osd_rect test1(0,0,minwidth,10000);
@ -1380,7 +1380,7 @@ osd_dim sdl_window_info::get_max_bounds(int constrain)
maximum = maximum.resize(tempw, temph);
// constrain to fit
if (constrain && m_target->current_view()->bounds().scale_type == RENDER_SCALE_FRACTIONAL)
if (constrain && m_target->scale_type() == RENDER_SCALE_FRACTIONAL)
maximum = constrain_to_aspect_ratio(maximum, WMSZ_BOTTOMRIGHT);
// remove extra window stuff

6
src/osd/windows/window.cpp
View File

@ -1663,7 +1663,7 @@ osd_rect win_window_info::constrain_to_aspect_ratio(const osd_rect &rect, int ad
assert(GetCurrentThreadId() == window_threadid);
// do not constrain aspect ratio for integer scaled views
if (m_target->current_view()->bounds().scale_type != RENDER_SCALE_FRACTIONAL)
if (m_target->scale_type() != RENDER_SCALE_FRACTIONAL)
return rect;
// get the pixel aspect ratio for the target monitor
@ -1787,7 +1787,7 @@ osd_dim win_window_info::get_min_bounds(int constrain)
minheight += wnd_extra_height();
// if we want it constrained, figure out which one is larger
if (constrain && m_target->current_view()->bounds().scale_type == RENDER_SCALE_FRACTIONAL)
if (constrain && m_target->scale_type() == RENDER_SCALE_FRACTIONAL)
{
// first constrain with no height limit
osd_rect test1(0,0,minwidth,10000);
@ -1847,7 +1847,7 @@ osd_dim win_window_info::get_max_bounds(int constrain)
maximum = maximum.resize(tempw, temph);
// constrain to fit
if (constrain && m_target->current_view()->bounds().scale_type == RENDER_SCALE_FRACTIONAL)
if (constrain && m_target->scale_type() == RENDER_SCALE_FRACTIONAL)
maximum = constrain_to_aspect_ratio(maximum, WMSZ_BOTTOMRIGHT);
return maximum.dim();