1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
|
/***************************************************************************
rendlay.h
Core rendering layout parser and manager.
****************************************************************************
Copyright Aaron Giles
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are
met:
* Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in
the documentation and/or other materials provided with the
distribution.
* Neither the name 'MAME' nor the names of its contributors may be
used to endorse or promote products derived from this software
without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY AARON GILES ''AS IS'' AND ANY EXPRESS OR
IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL AARON GILES BE LIABLE FOR ANY DIRECT,
INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
POSSIBILITY OF SUCH DAMAGE.
***************************************************************************/
#ifndef __RENDLAY_H__
#define __RENDLAY_H__
#include "render.h"
//**************************************************************************
// CONSTANTS
//**************************************************************************
enum item_layer
{
ITEM_LAYER_FIRST = 0,
ITEM_LAYER_BACKDROP = ITEM_LAYER_FIRST,
ITEM_LAYER_SCREEN,
ITEM_LAYER_OVERLAY,
ITEM_LAYER_BEZEL,
ITEM_LAYER_CPANEL,
ITEM_LAYER_MARQUEE,
ITEM_LAYER_MAX
};
DECLARE_ENUM_OPERATORS(item_layer);
//**************************************************************************
// TYPE DEFINITIONS
//**************************************************************************
// ======================> layout_element
// a layout_element is a single named element, which may have multiple components
class layout_element
{
friend class simple_list<layout_element>;
public:
// construction/destruction
layout_element(running_machine &machine, xml_data_node &elemnode, const char *dirname);
virtual ~layout_element();
// getters
layout_element *next() const { return m_next; }
const char *name() const { return m_name; }
running_machine &machine() const { return m_machine; }
int default_state() const { return m_defstate; }
int maxstate() const { return m_maxstate; }
render_texture *state_texture(int state);
private:
// a component represents an image, rectangle, or disk in an element
class component
{
friend class layout_element;
friend class simple_list<component>;
public:
// construction/destruction
component(running_machine &machine, xml_data_node &compnode, const char *dirname);
~component();
// getters
component *next() const { return m_next; }
const render_bounds &bounds() const { return m_bounds; }
// operations
void draw(running_machine &machine, bitmap_argb32 &dest, const rectangle &bounds, int state);
private:
// component types
enum component_type
{
CTYPE_INVALID = 0,
CTYPE_IMAGE,
CTYPE_RECT,
CTYPE_DISK,
CTYPE_TEXT,
CTYPE_LED7SEG,
CTYPE_LED14SEG,
CTYPE_LED16SEG,
CTYPE_LED14SEGSC,
CTYPE_LED16SEGSC,
CTYPE_DOTMATRIX,
CTYPE_DOTMATRIX5DOT,
CTYPE_DOTMATRIXDOT,
CTYPE_SIMPLECOUNTER,
CTYPE_REEL,
CTYPE_MAX
};
// helpers
void draw_rect(bitmap_argb32 &dest, const rectangle &bounds);
void draw_disk(bitmap_argb32 &dest, const rectangle &bounds);
void draw_text(running_machine &machine, bitmap_argb32 &dest, const rectangle &bounds);
void draw_simplecounter(running_machine &machine, bitmap_argb32 &dest, const rectangle &bounds, int state);
void draw_reel(running_machine &machine, bitmap_argb32 &dest, const rectangle &bounds, int state);
void load_bitmap();
void load_reel_bitmap(int number);
void draw_led7seg(bitmap_argb32 &dest, const rectangle &bounds, int pattern);
void draw_led14seg(bitmap_argb32 &dest, const rectangle &bounds, int pattern);
void draw_led14segsc(bitmap_argb32 &dest, const rectangle &bounds, int pattern);
void draw_led16seg(bitmap_argb32 &dest, const rectangle &bounds, int pattern);
void draw_led16segsc(bitmap_argb32 &dest, const rectangle &bounds, int pattern);
void draw_dotmatrix(int dots,bitmap_argb32 &dest, const rectangle &bounds, int pattern);
void draw_segment_horizontal_caps(bitmap_argb32 &dest, int minx, int maxx, int midy, int width, int caps, rgb_t color);
void draw_segment_horizontal(bitmap_argb32 &dest, int minx, int maxx, int midy, int width, rgb_t color);
void draw_segment_vertical_caps(bitmap_argb32 &dest, int miny, int maxy, int midx, int width, int caps, rgb_t color);
void draw_segment_vertical(bitmap_argb32 &dest, int miny, int maxy, int midx, int width, rgb_t color);
void draw_segment_diagonal_1(bitmap_argb32 &dest, int minx, int maxx, int miny, int maxy, int width, rgb_t color);
void draw_segment_diagonal_2(bitmap_argb32 &dest, int minx, int maxx, int miny, int maxy, int width, rgb_t color);
void draw_segment_decimal(bitmap_argb32 &dest, int midx, int midy, int width, rgb_t color);
void draw_segment_comma(bitmap_argb32 &dest, int minx, int maxx, int miny, int maxy, int width, rgb_t color);
void apply_skew(bitmap_argb32 &dest, int skewwidth);
#define MAX_BITMAPS 32
// internal state
component * m_next; // link to next component
component_type m_type; // type of component
int m_state; // state where this component is visible (-1 means all states)
render_bounds m_bounds; // bounds of the element
render_color m_color; // color of the element
astring m_string; // string for text components
int m_digits; // number of digits for simple counters
int m_textalign; // text alignment to box
bitmap_argb32 m_bitmap[MAX_BITMAPS]; // source bitmap for images
astring m_dirname; // directory name of image file (for lazy loading)
emu_file * m_file[MAX_BITMAPS]; // file object for reading image/alpha files
astring m_imagefile[MAX_BITMAPS]; // name of the image file (for lazy loading)
astring m_alphafile[MAX_BITMAPS]; // name of the alpha file (for lazy loading)
bool m_hasalpha[MAX_BITMAPS]; // is there any alpha component present?
// stuff for fruit machine reels
// basically made up of multiple text strings / gfx
int m_numstops;
astring m_stopnames[MAX_BITMAPS];
int m_stateoffset;
int m_reelreversed;
int m_numsymbolsvisible;
};
// a texture encapsulates a texture for a given element in a given state
class texture
{
public:
texture();
~texture();
layout_element * m_element; // pointer back to the element
render_texture * m_texture; // texture for this state
int m_state; // associated state number
};
// internal helpers
static void element_scale(bitmap_argb32 &dest, bitmap_argb32 &source, const rectangle &sbounds, void *param);
// internal state
layout_element * m_next; // link to next element
running_machine & m_machine; // reference to the owning machine
astring m_name; // name of this element
simple_list<component> m_complist; // list of components
int m_defstate; // default state of this element
int m_maxstate; // maximum state value for all components
texture * m_elemtex; // array of element textures used for managing the scaled bitmaps
};
// ======================> layout_view
// a layout_view encapsulates a named list of items
class layout_view
{
friend class simple_list<layout_view>;
public:
// an item is a single backdrop, screen, overlay, bezel, cpanel, or marquee item
class item
{
friend class layout_view;
friend class simple_list<item>;
public:
// construction/destruction
item(running_machine &machine, xml_data_node &itemnode, simple_list<layout_element> &elemlist);
virtual ~item();
// getters
item *next() const { return m_next; }
layout_element *element() const { return m_element; }
screen_device *screen() { return m_screen; }
const render_bounds &bounds() const { return m_bounds; }
const render_color &color() const { return m_color; }
int orientation() const { return m_orientation; }
render_container *screen_container(running_machine &machine) const { return (m_screen != NULL) ? &m_screen->container() : NULL; }
bool has_input() const { return bool(m_input_tag); }
const char *input_tag_and_mask(ioport_value &mask) const { mask = m_input_mask; return m_input_tag; }
// fetch state based on configured source
int state() const;
private:
// internal state
item * m_next; // link to next item
layout_element * m_element; // pointer to the associated element (non-screens only)
astring m_output_name; // name of this item
astring m_input_tag; // input tag of this item
ioport_value m_input_mask; // input mask of this item
screen_device * m_screen; // pointer to screen
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_color m_color; // color of the item
};
// construction/destruction
layout_view(running_machine &machine, xml_data_node &viewnode, simple_list<layout_element> &elemlist);
virtual ~layout_view();
// getters
layout_view *next() const { return m_next; }
item *first_item(item_layer layer) const;
const char *name() const { return m_name; }
const render_screen_list &screens() const { return m_screens; }
bool layer_enabled(item_layer layer) const { return m_layenabled[layer]; }
//
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); }
float effective_aspect(render_layer_config config) const { return (config.zoom_to_screen() && m_screens.count() != 0) ? m_scraspect : m_aspect; }
// operations
void recompute(render_layer_config layerconfig);
private:
// internal state
layout_view * m_next; // pointer to next layout in the list
astring m_name; // name of the layout
float m_aspect; // X/Y of the layout
float m_scraspect; // X/Y of the screen areas
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
render_bounds m_expbounds; // explicit bounds of the view
bool m_layenabled[ITEM_LAYER_MAX]; // is this layer enabled?
simple_list<item> m_backdrop_list; // list of backdrop items
simple_list<item> m_screen_list; // list of screen items
simple_list<item> m_overlay_list; // list of overlay items
simple_list<item> m_bezel_list; // list of bezel items
simple_list<item> m_cpanel_list; // list of marquee items
simple_list<item> m_marquee_list; // list of marquee items
};
// ======================> layout_file
// a layout_file consists of a list of elements and a list of views
class layout_file
{
friend class simple_list<layout_file>;
public:
// construction/destruction
layout_file(running_machine &machine, xml_data_node &rootnode, const char *dirname);
virtual ~layout_file();
// getters
layout_file *next() const { return m_next; }
layout_element *first_element() const { return m_elemlist.first(); }
layout_view *first_view() const { return m_viewlist.first(); }
private:
// internal state
layout_file * m_next; // pointer to the next file in the list
simple_list<layout_element> m_elemlist; // list of shared layout elements
simple_list<layout_view> m_viewlist; // list of views
};
//**************************************************************************
// GLOBAL VARIABLES
//**************************************************************************
// no screens layouts
extern const char layout_noscreens[]; // for screenless systems
// single screen layouts
extern const char layout_horizont[]; // horizontal 4:3 screens
extern const char layout_vertical[]; // vertical 4:3 screens
// dual screen layouts
extern const char layout_dualhsxs[]; // dual 4:3 screens side-by-side
extern const char layout_dualhovu[]; // dual 4:3 screens above and below
extern const char layout_dualhuov[]; // dual 4:3 screens below and above
// triple screen layouts
extern const char layout_triphsxs[]; // triple 4:3 screens side-by-side
// quad screen layouts
extern const char layout_quadhsxs[]; // quad 4:3 screens side-by-side
// generic color overlay layouts
extern const char layout_ho20ffff[]; // horizontal 4:3 with 20,FF,FF color overlay
extern const char layout_ho2eff2e[]; // horizontal 4:3 with 2E,FF,2E color overlay
extern const char layout_ho4f893d[]; // horizontal 4:3 with 4F,89,3D color overlay
extern const char layout_ho88ffff[]; // horizontal 4:3 with 88,FF,FF color overlay
extern const char layout_hoa0a0ff[]; // horizontal 4:3 with A0,A0,FF color overlay
extern const char layout_hoffe457[]; // horizontal 4:3 with FF,E4,57 color overlay
extern const char layout_hoffff20[]; // horizontal 4:3 with FF,FF,20 color overlay
extern const char layout_voffff20[]; // vertical 4:3 with FF,FF,20 color overlay
// LCD screen layouts
extern const char layout_lcd[]; // generic 1:1 lcd screen layout
extern const char layout_lcd_rot[]; // same, for use with ROT90 or ROT270
#endif // __RENDLAY_H__
|