← Back to branch summary

~ubuntu-branches/debian/wheezy/mame/wheezy

« back to all changes in this revision

Viewing changes to src/mame/video/psychic5.c

  • Committer: Bazaar Package Importer
  • Author(s): Jordi Mallach, Emmanuel Kasper, Félix Arreola Rodríguez, Jordi Mallach
  • Date: 2011-05-11 21:06:50 UTC
  • mfrom: (1.1.1 upstream)
  • Revision ID: james.westby@ubuntu.com-20110511210650-jizvh8a6x117y9hr
Tags: 0.142-1
[ Emmanuel Kasper ]
* New upstream release
* Set NOWERROR=1 to allow compiling with gcc-4.6
* Remove fix_powerpc_build.patch, as upstream has taken it in this release
* Add gnome-video-arcade front end as a suggested package

[ Félix Arreola Rodríguez ]
* Add kfreebsd-build.patch to quilt series, to fix build on kfreebsd

[ Jordi Mallach ]
* Remove unneeded and bogus addition of --with-quilt to the dh invocation.
* Add Cesare Falco (long time Ubuntu maintainer) to Uploaders, and wrap
  them into multiple lines.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/mame/video/psychic5.c
18
18
#define BG_PAL_INTENSITY_RG     0x1fe
19
19
#define BG_PAL_INTENSITY_BU     0x1ff
20
20
 
21
 
static UINT8 ps5_vram_page;
22
 
static UINT8 bg_clip_mode;
23
 
static UINT8 title_screen;
24
 
static UINT8 psychic5_bg_status;
25
 
 
26
 
static UINT8 *ps5_pagedram[2];
27
 
 
28
 
/* Paged RAM 0 */
29
 
static UINT8 *psychic5_bg_videoram;
30
 
static UINT8 *ps5_dummy_bg_ram;
31
 
 
32
 
/* Paged RAM 1 */
33
 
static UINT8 *ps5_io_ram;
34
 
static UINT8 *ps5_palette_ram;
35
 
static UINT8 *psychic5_fg_videoram;
36
 
 
37
 
static tilemap_t *bg_tilemap, *fg_tilemap;
38
 
 
39
 
static int bg_palette_ram_base;
40
 
static int bg_palette_base;
41
 
 
42
 
static UINT16 palette_intensity;
43
 
 
44
 
static UINT8 bombsa_unknown;
45
 
 
46
21
 
47
22
/***************************************************************************
48
23
  Palette color
49
24
***************************************************************************/
50
25
 
51
 
static void psychic5_change_palette(running_machine *machine, int color, int offset)
 
26
static void psychic5_change_palette(running_machine &machine, int color, int offset)
52
27
{
53
 
        UINT8 lo = ps5_palette_ram[offset & ~1];
54
 
        UINT8 hi = ps5_palette_ram[offset | 1];
55
 
        if (jal_blend_table != NULL) jal_blend_table[color] = hi & 0x0f;
 
28
        psychic5_state *state = machine.driver_data<psychic5_state>();
 
29
        UINT8 lo = state->m_ps5_palette_ram[offset & ~1];
 
30
        UINT8 hi = state->m_ps5_palette_ram[offset | 1];
 
31
        jal_blend_set(color, hi & 0x0f);
56
32
        palette_set_color_rgb(machine, color, pal4bit(lo >> 4), pal4bit(lo), pal4bit(hi >> 4));
57
33
}
58
34
 
59
 
static void psychic5_change_bg_palette(running_machine *machine, int color, int lo_offs, int hi_offs)
 
35
static void psychic5_change_bg_palette(running_machine &machine, int color, int lo_offs, int hi_offs)
60
36
{
 
37
        psychic5_state *state = machine.driver_data<psychic5_state>();
61
38
        UINT8 r,g,b,lo,hi,ir,ig,ib,ix;
62
39
        rgb_t irgb;
63
40
 
64
41
        /* red,green,blue intensities */
65
 
        ir = pal4bit(palette_intensity >> 12);
66
 
        ig = pal4bit(palette_intensity >>  8);
67
 
        ib = pal4bit(palette_intensity >>  4);
68
 
        ix = palette_intensity & 0x0f;
 
42
        ir = pal4bit(state->m_palette_intensity >> 12);
 
43
        ig = pal4bit(state->m_palette_intensity >>  8);
 
44
        ib = pal4bit(state->m_palette_intensity >>  4);
 
45
        ix = state->m_palette_intensity & 0x0f;
69
46
 
70
47
        irgb = MAKE_RGB(ir,ig,ib);
71
48
 
72
 
        lo = ps5_palette_ram[lo_offs];
73
 
        hi = ps5_palette_ram[hi_offs];
 
49
        lo = state->m_ps5_palette_ram[lo_offs];
 
50
        hi = state->m_ps5_palette_ram[hi_offs];
74
51
 
75
52
        /* red,green,blue component */
76
53
        r = pal4bit(lo >> 4);
78
55
        b = pal4bit(hi >> 4);
79
56
 
80
57
        /* Grey background enable */
81
 
        if (psychic5_bg_status & 2)
 
58
        if (state->m_bg_status & 2)
82
59
        {
83
60
                UINT8 val = (r + g + b) / 3;            /* Grey */
84
61
                /* Just leave plain grey */
87
64
        else
88
65
        {
89
66
                /* Seems fishy, but the title screen would be black otherwise... */
90
 
                if (!(title_screen & 1))
 
67
                if (!(state->m_title_screen & 1))
91
68
                {
92
69
                        /* Leave the world as-is */
93
70
                        palette_set_color(machine,color,jal_blend_func(MAKE_RGB(r,g,b),irgb,ix));
95
72
        }
96
73
}
97
74
 
98
 
static void set_background_palette_intensity(running_machine *machine)
 
75
static void set_background_palette_intensity(running_machine &machine)
99
76
{
 
77
        psychic5_state *state = machine.driver_data<psychic5_state>();
100
78
        int i;
101
 
        palette_intensity = ps5_palette_ram[BG_PAL_INTENSITY_BU] |
102
 
                                                (ps5_palette_ram[BG_PAL_INTENSITY_RG]<<8);
 
79
        state->m_palette_intensity = state->m_ps5_palette_ram[BG_PAL_INTENSITY_BU] |
 
80
                                                (state->m_ps5_palette_ram[BG_PAL_INTENSITY_RG]<<8);
103
81
 
104
82
        /* for all of the background palette */
105
83
        for (i = 0; i < 0x100; i++)
106
 
                psychic5_change_bg_palette(machine,bg_palette_base+i,bg_palette_ram_base+i*2,bg_palette_ram_base+i*2+1);
 
84
                psychic5_change_bg_palette(machine,state->m_bg_palette_base+i,state->m_bg_palette_ram_base+i*2,state->m_bg_palette_ram_base+i*2+1);
107
85
}
108
86
 
109
87
 
113
91
 
114
92
READ8_HANDLER( psychic5_vram_page_select_r )
115
93
{
116
 
        return ps5_vram_page;
 
94
        psychic5_state *state = space->machine().driver_data<psychic5_state>();
 
95
        return state->m_ps5_vram_page;
117
96
}
118
97
 
119
98
WRITE8_HANDLER( psychic5_vram_page_select_w )
120
99
{
121
 
        ps5_vram_page = data & 1;
 
100
        psychic5_state *state = space->machine().driver_data<psychic5_state>();
 
101
        state->m_ps5_vram_page = data & 1;
122
102
}
123
103
 
124
104
WRITE8_HANDLER( psychic5_title_screen_w )
125
105
{
126
 
        title_screen = data;
 
106
        psychic5_state *state = space->machine().driver_data<psychic5_state>();
 
107
        state->m_title_screen = data;
127
108
}
128
109
 
129
110
READ8_HANDLER( psychic5_paged_ram_r )
130
111
{
131
 
        if (ps5_vram_page == 1)
 
112
        psychic5_state *state = space->machine().driver_data<psychic5_state>();
 
113
        if (state->m_ps5_vram_page == 1)
132
114
        {
133
115
                switch (offset)
134
116
                {
135
 
                        case 0x00: return input_port_read(space->machine, "SYSTEM");
136
 
                        case 0x01: return input_port_read(space->machine, "P1");
137
 
                        case 0x02: return input_port_read(space->machine, "P2");
138
 
                        case 0x03: return input_port_read(space->machine, "DSW1");
139
 
                        case 0x04: return input_port_read(space->machine, "DSW2");
 
117
                        case 0x00: return input_port_read(space->machine(), "SYSTEM");
 
118
                        case 0x01: return input_port_read(space->machine(), "P1");
 
119
                        case 0x02: return input_port_read(space->machine(), "P2");
 
120
                        case 0x03: return input_port_read(space->machine(), "DSW1");
 
121
                        case 0x04: return input_port_read(space->machine(), "DSW2");
140
122
                }
141
123
        }
142
124
 
143
 
        return ps5_pagedram[ps5_vram_page][offset];
 
125
        return state->m_ps5_pagedram[state->m_ps5_vram_page][offset];
144
126
}
145
127
 
146
128
WRITE8_HANDLER( psychic5_paged_ram_w )
147
129
{
148
 
        ps5_pagedram[ps5_vram_page][offset] = data;
 
130
        psychic5_state *state = space->machine().driver_data<psychic5_state>();
 
131
        state->m_ps5_pagedram[state->m_ps5_vram_page][offset] = data;
149
132
 
150
 
        if (ps5_vram_page == 0)
 
133
        if (state->m_ps5_vram_page == 0)
151
134
        {
152
135
                if (offset <= 0xfff)
153
 
                        tilemap_mark_tile_dirty(bg_tilemap, offset >> 1);
 
136
                        tilemap_mark_tile_dirty(state->m_bg_tilemap, offset >> 1);
154
137
        }
155
138
        else
156
139
        {
157
140
                if (offset == BG_SCROLLX_LSB || offset == BG_SCROLLX_MSB)
158
141
                {
159
 
                        UINT16 bg_scrollx = ps5_io_ram[BG_SCROLLX_LSB] | (ps5_io_ram[BG_SCROLLX_MSB] << 8);
160
 
                        tilemap_set_scrollx(bg_tilemap, 0, bg_scrollx);
 
142
                        UINT16 bg_scrollx = state->m_ps5_io_ram[BG_SCROLLX_LSB] | (state->m_ps5_io_ram[BG_SCROLLX_MSB] << 8);
 
143
                        tilemap_set_scrollx(state->m_bg_tilemap, 0, bg_scrollx);
161
144
                }
162
145
                else if (offset == BG_SCROLLY_LSB || offset == BG_SCROLLY_MSB)
163
146
                {
164
 
                        UINT16 bg_scrolly = ps5_io_ram[BG_SCROLLY_LSB] | (ps5_io_ram[BG_SCROLLY_MSB] << 8);
165
 
                        tilemap_set_scrolly(bg_tilemap, 0, bg_scrolly);
 
147
                        UINT16 bg_scrolly = state->m_ps5_io_ram[BG_SCROLLY_LSB] | (state->m_ps5_io_ram[BG_SCROLLY_MSB] << 8);
 
148
                        tilemap_set_scrolly(state->m_bg_tilemap, 0, bg_scrolly);
166
149
                }
167
150
                else if (offset == BG_SCREEN_MODE)
168
151
                {
169
 
                        psychic5_bg_status = ps5_io_ram[BG_SCREEN_MODE];
 
152
                        state->m_bg_status = state->m_ps5_io_ram[BG_SCREEN_MODE];
170
153
                }
171
154
                else if (offset >= 0x400 && offset <= 0x5ff)    /* Sprite color */
172
 
                        psychic5_change_palette(space->machine,((offset >> 1) & 0xff)+0x000,offset-0x400);
 
155
                        psychic5_change_palette(space->machine(),((offset >> 1) & 0xff)+0x000,offset-0x400);
173
156
                else if (offset >= 0x800 && offset <= 0x9ff)    /* BG color */
174
 
                        psychic5_change_palette(space->machine,((offset >> 1) & 0xff)+0x100,offset-0x400);
 
157
                        psychic5_change_palette(space->machine(),((offset >> 1) & 0xff)+0x100,offset-0x400);
175
158
                else if (offset >= 0xa00 && offset <= 0xbff)    /* Text color */
176
 
                        psychic5_change_palette(space->machine,((offset >> 1) & 0xff)+0x200,offset-0x400);
 
159
                        psychic5_change_palette(space->machine(),((offset >> 1) & 0xff)+0x200,offset-0x400);
177
160
                else if (offset >= 0x1000)
178
 
                        tilemap_mark_tile_dirty(fg_tilemap, (offset-0x1000) >> 1);
 
161
                        tilemap_mark_tile_dirty(state->m_fg_tilemap, (offset-0x1000) >> 1);
179
162
        }
180
163
}
181
164
 
182
165
WRITE8_HANDLER( bombsa_paged_ram_w )
183
166
{
184
 
        ps5_pagedram[ps5_vram_page][offset] = data;
 
167
        psychic5_state *state = space->machine().driver_data<psychic5_state>();
 
168
        state->m_ps5_pagedram[state->m_ps5_vram_page][offset] = data;
185
169
 
186
 
        if (ps5_vram_page == 0)
 
170
        if (state->m_ps5_vram_page == 0)
187
171
        {
188
 
                tilemap_mark_tile_dirty(bg_tilemap, offset >> 1);
 
172
                tilemap_mark_tile_dirty(state->m_bg_tilemap, offset >> 1);
189
173
        }
190
174
        else
191
175
        {
192
176
                if (offset == BG_SCROLLX_LSB || offset == BG_SCROLLX_MSB)
193
177
                {
194
 
                        UINT16 bg_scrollx = ps5_io_ram[BG_SCROLLX_LSB] | (ps5_io_ram[BG_SCROLLX_MSB] << 8);
195
 
                        tilemap_set_scrollx(bg_tilemap, 0, bg_scrollx);
 
178
                        UINT16 bg_scrollx = state->m_ps5_io_ram[BG_SCROLLX_LSB] | (state->m_ps5_io_ram[BG_SCROLLX_MSB] << 8);
 
179
                        tilemap_set_scrollx(state->m_bg_tilemap, 0, bg_scrollx);
196
180
                }
197
181
                else if (offset == BG_SCROLLY_LSB || offset == BG_SCROLLY_MSB)
198
182
                {
199
 
                        UINT16 bg_scrolly = ps5_io_ram[BG_SCROLLY_LSB] | (ps5_io_ram[BG_SCROLLY_MSB] << 8);
200
 
                        tilemap_set_scrolly(bg_tilemap, 0, bg_scrolly);
 
183
                        UINT16 bg_scrolly = state->m_ps5_io_ram[BG_SCROLLY_LSB] | (state->m_ps5_io_ram[BG_SCROLLY_MSB] << 8);
 
184
                        tilemap_set_scrolly(state->m_bg_tilemap, 0, bg_scrolly);
201
185
                }
202
186
                else if (offset == BG_SCREEN_MODE)
203
187
                {
204
 
                        psychic5_bg_status = ps5_io_ram[BG_SCREEN_MODE];
 
188
                        state->m_bg_status = state->m_ps5_io_ram[BG_SCREEN_MODE];
205
189
                }
206
190
                else if (offset >= 0x0800 && offset <= 0x0fff)
207
 
                        tilemap_mark_tile_dirty(fg_tilemap, (offset & 0x7ff) >> 1);
 
191
                        tilemap_mark_tile_dirty(state->m_fg_tilemap, (offset & 0x7ff) >> 1);
208
192
                else if (offset >= 0x1000 && offset <= 0x15ff)
209
 
                        psychic5_change_palette(space->machine, (offset >> 1) & 0x3ff, offset-0x1000);
 
193
                        psychic5_change_palette(space->machine(), (offset >> 1) & 0x3ff, offset-0x1000);
210
194
        }
211
195
}
212
196
 
213
197
WRITE8_HANDLER( bombsa_unknown_w )
214
198
{
215
 
        bombsa_unknown = data;
 
199
        psychic5_state *state = space->machine().driver_data<psychic5_state>();
 
200
        state->m_bombsa_unknown = data;
216
201
}
217
202
 
218
203
 
222
207
 
223
208
static TILE_GET_INFO( get_bg_tile_info )
224
209
{
 
210
        psychic5_state *state = machine.driver_data<psychic5_state>();
225
211
        int offs = tile_index << 1;
226
 
        int attr = psychic5_bg_videoram[offs + 1];
227
 
        int code = psychic5_bg_videoram[offs] | ((attr & 0xc0) << 2);
 
212
        int attr = state->m_bg_videoram[offs + 1];
 
213
        int code = state->m_bg_videoram[offs] | ((attr & 0xc0) << 2);
228
214
        int color = attr & 0x0f;
229
215
        int flags = TILE_FLIPYX((attr & 0x30) >> 4);
230
216
 
233
219
 
234
220
static TILE_GET_INFO( get_fg_tile_info )
235
221
{
 
222
        psychic5_state *state = machine.driver_data<psychic5_state>();
236
223
        int offs = tile_index << 1;
237
 
        int attr = psychic5_fg_videoram[offs + 1];
238
 
        int code = psychic5_fg_videoram[offs] | ((attr & 0xc0) << 2);
 
224
        int attr = state->m_fg_videoram[offs + 1];
 
225
        int code = state->m_fg_videoram[offs] | ((attr & 0xc0) << 2);
239
226
        int color = attr & 0x0f;
240
227
        int flags = TILE_FLIPYX((attr & 0x30) >> 4);
241
228
 
249
236
 
250
237
VIDEO_START( psychic5 )
251
238
{
 
239
        psychic5_state *state = machine.driver_data<psychic5_state>();
252
240
        /*                          info              offset             w   h  col  row */
253
 
        bg_tilemap = tilemap_create(machine, get_bg_tile_info, tilemap_scan_cols, 16, 16, 64, 32);
254
 
        fg_tilemap = tilemap_create(machine, get_fg_tile_info, tilemap_scan_cols,  8,  8, 32, 32);
255
 
 
256
 
        tilemap_set_transparent_pen(fg_tilemap, 15);
257
 
 
258
 
        ps5_pagedram[0] = auto_alloc_array(machine, UINT8, 0x2000);
259
 
        ps5_pagedram[1] = auto_alloc_array(machine, UINT8, 0x2000);
260
 
 
261
 
        psychic5_bg_videoram  = &ps5_pagedram[0][0x0000];
262
 
        ps5_dummy_bg_ram      = &ps5_pagedram[0][0x1000];
263
 
        ps5_io_ram            = &ps5_pagedram[1][0x0000];
264
 
        ps5_palette_ram       = &ps5_pagedram[1][0x0400];
265
 
        psychic5_fg_videoram  = &ps5_pagedram[1][0x1000];
266
 
 
267
 
        jal_blend_table = auto_alloc_array(machine, UINT8, 0xc00);
268
 
 
269
 
        bg_palette_ram_base = 0x400;
270
 
        bg_palette_base = 0x100;
 
241
        state->m_bg_tilemap = tilemap_create(machine, get_bg_tile_info, tilemap_scan_cols, 16, 16, 64, 32);
 
242
        state->m_fg_tilemap = tilemap_create(machine, get_fg_tile_info, tilemap_scan_cols,  8,  8, 32, 32);
 
243
 
 
244
        tilemap_set_transparent_pen(state->m_fg_tilemap, 15);
 
245
 
 
246
        state->m_ps5_pagedram[0] = auto_alloc_array(machine, UINT8, 0x2000);
 
247
        state->m_ps5_pagedram[1] = auto_alloc_array(machine, UINT8, 0x2000);
 
248
 
 
249
        state->m_bg_videoram  = &state->m_ps5_pagedram[0][0x0000];
 
250
        state->m_ps5_dummy_bg_ram      = &state->m_ps5_pagedram[0][0x1000];
 
251
        state->m_ps5_io_ram            = &state->m_ps5_pagedram[1][0x0000];
 
252
        state->m_ps5_palette_ram       = &state->m_ps5_pagedram[1][0x0400];
 
253
        state->m_fg_videoram  = &state->m_ps5_pagedram[1][0x1000];
 
254
 
 
255
        jal_blend_init(machine, 1);
 
256
 
 
257
        state->m_bg_palette_ram_base = 0x400;
 
258
        state->m_bg_palette_base = 0x100;
271
259
}
272
260
 
273
261
VIDEO_START( bombsa )
274
262
{
 
263
        psychic5_state *state = machine.driver_data<psychic5_state>();
275
264
        /*                          info              offset             w   h   col  row */
276
 
        bg_tilemap = tilemap_create(machine, get_bg_tile_info, tilemap_scan_cols, 16, 16, 128, 32);
277
 
        fg_tilemap = tilemap_create(machine, get_fg_tile_info, tilemap_scan_cols,  8,  8,  32, 32);
278
 
 
279
 
        tilemap_set_transparent_pen(fg_tilemap, 15);
280
 
 
281
 
        ps5_pagedram[0] = auto_alloc_array(machine, UINT8, 0x2000);
282
 
        ps5_pagedram[1] = auto_alloc_array(machine, UINT8, 0x2000);
283
 
 
284
 
        psychic5_bg_videoram  = &ps5_pagedram[0][0x0000];
285
 
        ps5_dummy_bg_ram      = &ps5_pagedram[0][0x1000];
286
 
        ps5_io_ram            = &ps5_pagedram[1][0x0000];
287
 
        psychic5_fg_videoram  = &ps5_pagedram[1][0x0800];
288
 
        ps5_palette_ram       = &ps5_pagedram[1][0x1000];
289
 
 
290
 
        //jal_blend_table = auto_alloc_array(machine, UINT8, 0xc00);
291
 
        jal_blend_table = NULL;
292
 
 
293
 
        bg_palette_ram_base = 0x000;
294
 
        bg_palette_base = 0x000;
 
265
        state->m_bg_tilemap = tilemap_create(machine, get_bg_tile_info, tilemap_scan_cols, 16, 16, 128, 32);
 
266
        state->m_fg_tilemap = tilemap_create(machine, get_fg_tile_info, tilemap_scan_cols,  8,  8,  32, 32);
 
267
 
 
268
        tilemap_set_transparent_pen(state->m_fg_tilemap, 15);
 
269
 
 
270
        state->m_ps5_pagedram[0] = auto_alloc_array(machine, UINT8, 0x2000);
 
271
        state->m_ps5_pagedram[1] = auto_alloc_array(machine, UINT8, 0x2000);
 
272
 
 
273
        state->m_bg_videoram  = &state->m_ps5_pagedram[0][0x0000];
 
274
        state->m_ps5_dummy_bg_ram      = &state->m_ps5_pagedram[0][0x1000];
 
275
        state->m_ps5_io_ram            = &state->m_ps5_pagedram[1][0x0000];
 
276
        state->m_fg_videoram  = &state->m_ps5_pagedram[1][0x0800];
 
277
        state->m_ps5_palette_ram       = &state->m_ps5_pagedram[1][0x1000];
 
278
 
 
279
        jal_blend_init(machine, 0);
 
280
 
 
281
        state->m_bg_palette_ram_base = 0x000;
 
282
        state->m_bg_palette_base = 0x000;
295
283
}
296
284
 
297
285
VIDEO_RESET( psychic5 )
298
286
{
299
 
        bg_clip_mode = 0;
300
 
        ps5_vram_page = 0;
301
 
        psychic5_bg_status = 0;
302
 
        memset(ps5_pagedram[0],0,0x2000);
303
 
        memset(ps5_pagedram[1],0,0x2000);
304
 
        palette_intensity = 0;
305
 
        if (jal_blend_table != NULL) memset(jal_blend_table,0,0xc00);
 
287
        psychic5_state *state = machine.driver_data<psychic5_state>();
 
288
        state->m_bg_clip_mode = 0;
 
289
        state->m_ps5_vram_page = 0;
 
290
        state->m_bg_status = 0;
 
291
        memset(state->m_ps5_pagedram[0],0,0x2000);
 
292
        memset(state->m_ps5_pagedram[1],0,0x2000);
 
293
        state->m_palette_intensity = 0;
306
294
}
307
295
 
308
296
VIDEO_RESET( bombsa )
309
297
{
310
 
        ps5_vram_page = 0;
311
 
        psychic5_bg_status = 0;
312
 
        title_screen = 0;
313
 
        memset(ps5_pagedram[0],0,0x2000);
314
 
        memset(ps5_pagedram[1],0,0x2000);
315
 
        palette_intensity = 0;
316
 
        if (jal_blend_table != NULL) memset(jal_blend_table,0,0xc00);
 
298
        psychic5_state *state = machine.driver_data<psychic5_state>();
 
299
        state->m_ps5_vram_page = 0;
 
300
        state->m_bg_status = 0;
 
301
        state->m_title_screen = 0;
 
302
        memset(state->m_ps5_pagedram[0],0,0x2000);
 
303
        memset(state->m_ps5_pagedram[1],0,0x2000);
 
304
        state->m_palette_intensity = 0;
317
305
}
318
306
 
319
307
 
321
309
  Screen refresh
322
310
***************************************************************************/
323
311
 
324
 
#define DRAW_SPRITE(code, sx, sy) jal_blend_drawgfx(bitmap, cliprect, machine->gfx[0], code, color, flipx, flipy, sx, sy, 15);
 
312
#define DRAW_SPRITE(code, sx, sy) jal_blend_drawgfx(bitmap, cliprect, machine.gfx[0], code, color, flipx, flipy, sx, sy, 15);
325
313
 
326
 
static void draw_sprites(running_machine *machine, bitmap_t *bitmap, const rectangle *cliprect)
 
314
static void draw_sprites(running_machine &machine, bitmap_t *bitmap, const rectangle *cliprect)
327
315
{
328
 
        UINT8 *spriteram = machine->generic.spriteram.u8;
 
316
        psychic5_state *state = machine.driver_data<psychic5_state>();
 
317
        UINT8 *spriteram = state->m_spriteram;
329
318
        int offs;
330
319
 
331
320
        /* Draw the sprites */
332
 
        for (offs = 0; offs < machine->generic.spriteram_size; offs += 16)
 
321
        for (offs = 0; offs < state->m_spriteram_size; offs += 16)
333
322
        {
334
323
                int attr  = spriteram[offs + 13];
335
324
                int code  = spriteram[offs + 14] | ((attr & 0xc0) << 2);
376
365
        }
377
366
}
378
367
 
379
 
static void draw_background(running_machine *machine, bitmap_t *bitmap, const rectangle *cliprect)
 
368
static void draw_background(running_machine &machine, bitmap_t *bitmap, const rectangle *cliprect)
380
369
{
381
 
        UINT8 *spriteram = machine->generic.spriteram.u8;
382
 
        static int sx1 = 0, sy1 = 0, sy2 = 0;
 
370
        psychic5_state *state = machine.driver_data<psychic5_state>();
 
371
        UINT8 *spriteram = state->m_spriteram;
383
372
 
384
373
        rectangle clip = *cliprect;
385
374
 
386
375
        set_background_palette_intensity(machine);
387
376
 
388
 
        if (!(title_screen & 1))
 
377
        if (!(state->m_title_screen & 1))
389
378
        {
390
 
                bg_clip_mode = 0;
391
 
                sx1 = sy1 = sy2 = 0;
 
379
                state->m_bg_clip_mode = 0;
 
380
                state->m_sx1 = state->m_sy1 = state->m_sy2 = 0;
392
381
        }
393
382
        else
394
383
        {
395
 
                int sy1_old = sy1;
396
 
                int sx1_old = sx1;
397
 
                int sy2_old = sy2;
398
 
 
399
 
                sy1 = spriteram[11];            /* sprite 0 */
400
 
                sx1 = spriteram[12];
401
 
                sy2 = spriteram[11+128];        /* sprite 8 */
402
 
 
403
 
                switch (bg_clip_mode)
 
384
                int sy1_old = state->m_sy1;
 
385
                int sx1_old = state->m_sx1;
 
386
                int sy2_old = state->m_sy2;
 
387
 
 
388
                state->m_sy1 = spriteram[11];           /* sprite 0 */
 
389
                state->m_sx1 = spriteram[12];
 
390
                state->m_sy2 = spriteram[11+128];       /* sprite 8 */
 
391
 
 
392
                switch (state->m_bg_clip_mode)
404
393
                {
405
 
                case  0: case  4: if (sy1_old != sy1) bg_clip_mode++; break;
406
 
                case  2: case  6: if (sy2_old != sy2) bg_clip_mode++; break;
 
394
                case  0: case  4: if (sy1_old != state->m_sy1) state->m_bg_clip_mode++; break;
 
395
                case  2: case  6: if (sy2_old != state->m_sy2) state->m_bg_clip_mode++; break;
407
396
                case  8: case 10:
408
 
                case 12: case 14: if (sx1_old != sx1) bg_clip_mode++; break;
409
 
                case  1: case  5: if (sy1 == 0xf0) bg_clip_mode++; break;
410
 
                case  3: case  7: if (sy2 == 0xf0) bg_clip_mode++; break;
411
 
                case  9: case 11: if (sx1 == 0xf0) bg_clip_mode++; break;
412
 
                case 13: case 15: if (sx1_old == 0xf0) bg_clip_mode++;
413
 
                case 16: if (sy1 != 0x00) bg_clip_mode = 0; break;
 
397
                case 12: case 14: if (sx1_old != state->m_sx1) state->m_bg_clip_mode++; break;
 
398
                case  1: case  5: if (state->m_sy1 == 0xf0) state->m_bg_clip_mode++; break;
 
399
                case  3: case  7: if (state->m_sy2 == 0xf0) state->m_bg_clip_mode++; break;
 
400
                case  9: case 11: if (state->m_sx1 == 0xf0) state->m_bg_clip_mode++; break;
 
401
                case 13: case 15: if (sx1_old == 0xf0) state->m_bg_clip_mode++;
 
402
                case 16: if (state->m_sy1 != 0x00) state->m_bg_clip_mode = 0; break;
414
403
                }
415
404
 
416
 
                switch (bg_clip_mode)
 
405
                switch (state->m_bg_clip_mode)
417
406
                {
418
407
                case  0: case  4: case  8: case 12: case 16:
419
408
                        clip.min_x = clip.max_x = clip.min_y = clip.max_y = 0;
420
409
                        break;
421
 
                case  1: clip.min_y = sy1; break;
422
 
                case  3: clip.max_y = sy2; break;
423
 
                case  5: clip.max_y = sy1; break;
424
 
                case  7: clip.min_y = sy2; break;
425
 
                case  9: case 15: clip.min_x = sx1; break;
426
 
                case 11: case 13: clip.max_x = sx1; break;
 
410
                case  1: clip.min_y = state->m_sy1; break;
 
411
                case  3: clip.max_y = state->m_sy2; break;
 
412
                case  5: clip.max_y = state->m_sy1; break;
 
413
                case  7: clip.min_y = state->m_sy2; break;
 
414
                case  9: case 15: clip.min_x = state->m_sx1; break;
 
415
                case 11: case 13: clip.max_x = state->m_sx1; break;
427
416
                }
428
417
 
429
418
                if (flip_screen_get(machine))
440
429
                }
441
430
        }
442
431
 
443
 
        tilemap_draw(bitmap, &clip, bg_tilemap, 0, 0);
 
432
        tilemap_draw(bitmap, &clip, state->m_bg_tilemap, 0, 0);
444
433
}
445
434
 
446
 
VIDEO_UPDATE( psychic5 )
 
435
SCREEN_UPDATE( psychic5 )
447
436
{
448
 
        bitmap_fill(bitmap, cliprect, get_black_pen(screen->machine));
449
 
        if (psychic5_bg_status & 1)     /* Backgound enable */
450
 
                draw_background(screen->machine, bitmap, cliprect);
451
 
        if (!(title_screen & 1))
452
 
                draw_sprites(screen->machine, bitmap, cliprect);
453
 
        tilemap_draw(bitmap, cliprect, fg_tilemap, 0, 0);
 
437
        psychic5_state *state = screen->machine().driver_data<psychic5_state>();
 
438
        bitmap_fill(bitmap, cliprect, get_black_pen(screen->machine()));
 
439
        if (state->m_bg_status & 1)     /* Backgound enable */
 
440
                draw_background(screen->machine(), bitmap, cliprect);
 
441
        if (!(state->m_title_screen & 1))
 
442
                draw_sprites(screen->machine(), bitmap, cliprect);
 
443
        tilemap_draw(bitmap, cliprect, state->m_fg_tilemap, 0, 0);
454
444
        return 0;
455
445
}
456
446
 
457
 
VIDEO_UPDATE( bombsa )
 
447
SCREEN_UPDATE( bombsa )
458
448
{
459
 
        if (psychic5_bg_status & 1)     /* Backgound enable */
460
 
                tilemap_draw(bitmap, cliprect, bg_tilemap, 0, 0);
 
449
        psychic5_state *state = screen->machine().driver_data<psychic5_state>();
 
450
        if (state->m_bg_status & 1)     /* Backgound enable */
 
451
                tilemap_draw(bitmap, cliprect, state->m_bg_tilemap, 0, 0);
461
452
        else
462
 
                bitmap_fill(bitmap, cliprect, screen->machine->pens[0x0ff]);
463
 
        draw_sprites(screen->machine, bitmap, cliprect);
464
 
        tilemap_draw(bitmap, cliprect, fg_tilemap, 0, 0);
 
453
                bitmap_fill(bitmap, cliprect, screen->machine().pens[0x0ff]);
 
454
        draw_sprites(screen->machine(), bitmap, cliprect);
 
455
        tilemap_draw(bitmap, cliprect, state->m_fg_tilemap, 0, 0);
465
456
        return 0;
466
457
}