← Back to branch summary

~ubuntu-branches/debian/sid/mame/sid

« back to all changes in this revision

Viewing changes to src/mame/video/tryout.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/tryout.c
8
8
#include "emu.h"
9
9
#include "includes/tryout.h"
10
10
 
11
 
static tilemap_t *fg_tilemap, *bg_tilemap;
12
 
static UINT8 vram_bank;
13
 
static UINT8 *tryout_vram, *tryout_vram_gfx;
14
 
UINT8 *tryout_gfx_control;
15
11
 
16
12
PALETTE_INIT( tryout )
17
13
{
18
14
        int i;
19
15
 
20
 
        for (i = 0;i < machine->total_colors();i++)
 
16
        for (i = 0;i < machine.total_colors();i++)
21
17
        {
22
18
                int bit0,bit1,bit2,r,g,b;
23
19
 
43
39
 
44
40
static TILE_GET_INFO( get_fg_tile_info )
45
41
{
46
 
        tryout_state *state = machine->driver_data<tryout_state>();
47
 
        UINT8 *videoram = state->videoram;
 
42
        tryout_state *state = machine.driver_data<tryout_state>();
 
43
        UINT8 *videoram = state->m_videoram;
48
44
        int code, attr, color;
49
45
 
50
46
        code = videoram[tile_index];
57
53
 
58
54
static TILE_GET_INFO( get_bg_tile_info )
59
55
{
60
 
        SET_TILE_INFO(2, tryout_vram[tile_index] & 0x7f, 2, 0);
 
56
        tryout_state *state = machine.driver_data<tryout_state>();
 
57
        SET_TILE_INFO(2, state->m_vram[tile_index] & 0x7f, 2, 0);
61
58
}
62
59
 
63
60
READ8_HANDLER( tryout_vram_r )
64
61
{
65
 
        return tryout_vram[offset]; // debug only
 
62
        tryout_state *state = space->machine().driver_data<tryout_state>();
 
63
        return state->m_vram[offset]; // debug only
66
64
}
67
65
 
68
66
WRITE8_HANDLER( tryout_videoram_w )
69
67
{
70
 
        tryout_state *state = space->machine->driver_data<tryout_state>();
71
 
        UINT8 *videoram = state->videoram;
 
68
        tryout_state *state = space->machine().driver_data<tryout_state>();
 
69
        UINT8 *videoram = state->m_videoram;
72
70
        videoram[offset] = data;
73
 
        tilemap_mark_tile_dirty(fg_tilemap, offset & 0x3ff);
 
71
        tilemap_mark_tile_dirty(state->m_fg_tilemap, offset & 0x3ff);
74
72
}
75
73
 
76
74
WRITE8_HANDLER( tryout_vram_w )
77
75
{
 
76
        tryout_state *state = space->machine().driver_data<tryout_state>();
78
77
        /*  There are eight banks of vram - in bank 0 the first 0x400 bytes
79
78
    is reserved for the tilemap.  In banks 2, 4 and 6 the game never
80
79
    writes to the first 0x400 bytes - I suspect it's either
88
87
    gfx data and then set high from that point onwards.
89
88
 
90
89
    */
91
 
        const UINT8 bank=(vram_bank>>1)&0x7;
 
90
        const UINT8 bank=(state->m_vram_bank>>1)&0x7;
92
91
 
93
92
 
94
93
        if ((bank==0 || bank==2 || bank==4 || bank==6) && (offset&0x7ff)<0x400) {
95
94
                int newoff=offset&0x3ff;
96
95
 
97
 
                tryout_vram[newoff]=data;
98
 
                tilemap_mark_tile_dirty(bg_tilemap,newoff);
 
96
                state->m_vram[newoff]=data;
 
97
                tilemap_mark_tile_dirty(state->m_bg_tilemap,newoff);
99
98
                return;
100
99
        }
101
100
 
109
108
    */
110
109
 
111
110
        offset=(offset&0x7ff) | (bank<<11);
112
 
        tryout_vram[offset]=data;
 
111
        state->m_vram[offset]=data;
113
112
 
114
113
        switch (offset&0x1c00) {
115
114
        case 0x0400:
116
 
                tryout_vram_gfx[(offset&0x3ff) + 0x0000 + ((offset&0x2000)>>1)]=(~data&0xf);
117
 
                tryout_vram_gfx[(offset&0x3ff) + 0x2000 + ((offset&0x2000)>>1)]=(~data&0xf0)>>4;
 
115
                state->m_vram_gfx[(offset&0x3ff) + 0x0000 + ((offset&0x2000)>>1)]=(~data&0xf);
 
116
                state->m_vram_gfx[(offset&0x3ff) + 0x2000 + ((offset&0x2000)>>1)]=(~data&0xf0)>>4;
118
117
                break;
119
118
        case 0x0800:
120
 
                tryout_vram_gfx[(offset&0x3ff) + 0x4000 + ((offset&0x2000)>>1)]=(~data&0xf);
121
 
                tryout_vram_gfx[(offset&0x3ff) + 0x4400 + ((offset&0x2000)>>1)]=(~data&0xf0)>>4;
 
119
                state->m_vram_gfx[(offset&0x3ff) + 0x4000 + ((offset&0x2000)>>1)]=(~data&0xf);
 
120
                state->m_vram_gfx[(offset&0x3ff) + 0x4400 + ((offset&0x2000)>>1)]=(~data&0xf0)>>4;
122
121
                break;
123
122
        case 0x0c00:
124
 
                tryout_vram_gfx[(offset&0x3ff) + 0x0400 + ((offset&0x2000)>>1)]=(~data&0xf);
125
 
                tryout_vram_gfx[(offset&0x3ff) + 0x2400 + ((offset&0x2000)>>1)]=(~data&0xf0)>>4;
 
123
                state->m_vram_gfx[(offset&0x3ff) + 0x0400 + ((offset&0x2000)>>1)]=(~data&0xf);
 
124
                state->m_vram_gfx[(offset&0x3ff) + 0x2400 + ((offset&0x2000)>>1)]=(~data&0xf0)>>4;
126
125
                break;
127
126
        case 0x1400:
128
 
                tryout_vram_gfx[(offset&0x3ff) + 0x0800 + ((offset&0x2000)>>1)]=(~data&0xf);
129
 
                tryout_vram_gfx[(offset&0x3ff) + 0x2800 + ((offset&0x2000)>>1)]=(~data&0xf0)>>4;
 
127
                state->m_vram_gfx[(offset&0x3ff) + 0x0800 + ((offset&0x2000)>>1)]=(~data&0xf);
 
128
                state->m_vram_gfx[(offset&0x3ff) + 0x2800 + ((offset&0x2000)>>1)]=(~data&0xf0)>>4;
130
129
                break;
131
130
        case 0x1800:
132
 
                tryout_vram_gfx[(offset&0x3ff) + 0x4800 + ((offset&0x2000)>>1)]=(~data&0xf);
133
 
                tryout_vram_gfx[(offset&0x3ff) + 0x4c00 + ((offset&0x2000)>>1)]=(~data&0xf0)>>4;
 
131
                state->m_vram_gfx[(offset&0x3ff) + 0x4800 + ((offset&0x2000)>>1)]=(~data&0xf);
 
132
                state->m_vram_gfx[(offset&0x3ff) + 0x4c00 + ((offset&0x2000)>>1)]=(~data&0xf0)>>4;
134
133
                break;
135
134
        case 0x1c00:
136
 
                tryout_vram_gfx[(offset&0x3ff) + 0x0c00 + ((offset&0x2000)>>1)]=(~data&0xf);
137
 
                tryout_vram_gfx[(offset&0x3ff) + 0x2c00 + ((offset&0x2000)>>1)]=(~data&0xf0)>>4;
 
135
                state->m_vram_gfx[(offset&0x3ff) + 0x0c00 + ((offset&0x2000)>>1)]=(~data&0xf);
 
136
                state->m_vram_gfx[(offset&0x3ff) + 0x2c00 + ((offset&0x2000)>>1)]=(~data&0xf0)>>4;
138
137
                break;
139
138
        }
140
139
 
141
 
        gfx_element_mark_dirty(space->machine->gfx[2], (offset-0x400/64)&0x7f);
 
140
        gfx_element_mark_dirty(space->machine().gfx[2], (offset-0x400/64)&0x7f);
142
141
}
143
142
 
144
143
WRITE8_HANDLER( tryout_vram_bankswitch_w )
145
144
{
146
 
        vram_bank = data;
 
145
        tryout_state *state = space->machine().driver_data<tryout_state>();
 
146
        state->m_vram_bank = data;
147
147
}
148
148
 
149
149
WRITE8_HANDLER( tryout_flipscreen_w )
150
150
{
151
 
        flip_screen_set(space->machine, data & 1);
 
151
        flip_screen_set(space->machine(), data & 1);
152
152
}
153
153
 
154
154
static TILEMAP_MAPPER( get_fg_memory_offset )
170
170
 
171
171
VIDEO_START( tryout )
172
172
{
173
 
        fg_tilemap = tilemap_create(machine, get_fg_tile_info,get_fg_memory_offset,8,8,32,32);
174
 
        bg_tilemap = tilemap_create(machine, get_bg_tile_info,get_bg_memory_offset,16,16,64,16);
175
 
 
176
 
        tryout_vram=auto_alloc_array(machine, UINT8, 8 * 0x800);
177
 
        tryout_vram_gfx=auto_alloc_array(machine, UINT8, 0x6000);
178
 
 
179
 
        gfx_element_set_source(machine->gfx[2], tryout_vram_gfx);
180
 
 
181
 
        tilemap_set_transparent_pen(fg_tilemap,0);
 
173
        tryout_state *state = machine.driver_data<tryout_state>();
 
174
        state->m_fg_tilemap = tilemap_create(machine, get_fg_tile_info,get_fg_memory_offset,8,8,32,32);
 
175
        state->m_bg_tilemap = tilemap_create(machine, get_bg_tile_info,get_bg_memory_offset,16,16,64,16);
 
176
 
 
177
        state->m_vram=auto_alloc_array(machine, UINT8, 8 * 0x800);
 
178
        state->m_vram_gfx=auto_alloc_array(machine, UINT8, 0x6000);
 
179
 
 
180
        gfx_element_set_source(machine.gfx[2], state->m_vram_gfx);
 
181
 
 
182
        tilemap_set_transparent_pen(state->m_fg_tilemap,0);
182
183
}
183
184
 
184
 
static void draw_sprites(running_machine *machine, bitmap_t *bitmap,const rectangle *cliprect)
 
185
static void draw_sprites(running_machine &machine, bitmap_t *bitmap,const rectangle *cliprect)
185
186
{
186
 
        UINT8 *spriteram = machine->generic.spriteram.u8;
187
 
        UINT8 *spriteram_2 = machine->generic.spriteram2.u8;
 
187
        tryout_state *state = machine.driver_data<tryout_state>();
 
188
        UINT8 *spriteram = state->m_spriteram;
 
189
        UINT8 *spriteram_2 = state->m_spriteram2;
188
190
        int offs,fx,fy,x,y,color,sprite,inc;
189
191
 
190
192
        for (offs = 0;offs < 0x7f;offs += 4)
214
216
                /* Double Height */
215
217
                if(spriteram[offs] & 0x10)
216
218
                {
217
 
                        drawgfx_transpen(bitmap,cliprect,machine->gfx[1],
 
219
                        drawgfx_transpen(bitmap,cliprect,machine.gfx[1],
218
220
                                sprite,
219
221
                                color,fx,fy,x,y + inc,0);
220
222
 
221
 
                        drawgfx_transpen(bitmap,cliprect,machine->gfx[1],
 
223
                        drawgfx_transpen(bitmap,cliprect,machine.gfx[1],
222
224
                                sprite+1,
223
225
                                color,fx,fy,x,y,0);
224
226
                }
225
227
                else
226
228
                {
227
 
                        drawgfx_transpen(bitmap,cliprect,machine->gfx[1],
 
229
                        drawgfx_transpen(bitmap,cliprect,machine.gfx[1],
228
230
                                sprite,
229
231
                                color,fx,fy,x,y,0);
230
232
                }
231
233
        }
232
234
}
233
235
 
234
 
VIDEO_UPDATE( tryout )
 
236
SCREEN_UPDATE( tryout )
235
237
{
 
238
        tryout_state *state = screen->machine().driver_data<tryout_state>();
236
239
        int scrollx = 0;
237
240
 
238
 
        if (!flip_screen_get(screen->machine))
239
 
                tilemap_set_scrollx(fg_tilemap, 0, 16); /* Assumed hard-wired */
 
241
        if (!flip_screen_get(screen->machine()))
 
242
                tilemap_set_scrollx(state->m_fg_tilemap, 0, 16); /* Assumed hard-wired */
240
243
        else
241
 
                tilemap_set_scrollx(fg_tilemap, 0, -8); /* Assumed hard-wired */
 
244
                tilemap_set_scrollx(state->m_fg_tilemap, 0, -8); /* Assumed hard-wired */
242
245
 
243
 
        scrollx = tryout_gfx_control[1] + ((tryout_gfx_control[0]&1)<<8) + ((tryout_gfx_control[0]&4)<<7) - ((tryout_gfx_control[0] & 2) ? 0 : 0x100);
 
246
        scrollx = state->m_gfx_control[1] + ((state->m_gfx_control[0]&1)<<8) + ((state->m_gfx_control[0]&4)<<7) - ((state->m_gfx_control[0] & 2) ? 0 : 0x100);
244
247
 
245
248
        /* wrap-around */
246
 
        if(tryout_gfx_control[1] == 0) { scrollx+=0x100; }
247
 
 
248
 
        tilemap_set_scrollx(bg_tilemap, 0, scrollx+2); /* why +2? hard-wired? */
249
 
        tilemap_set_scrolly(bg_tilemap, 0, -tryout_gfx_control[2]);
250
 
 
251
 
        if(!(tryout_gfx_control[0] & 0x8)) // screen disable
 
249
        if(state->m_gfx_control[1] == 0) { scrollx+=0x100; }
 
250
 
 
251
        tilemap_set_scrollx(state->m_bg_tilemap, 0, scrollx+2); /* why +2? hard-wired? */
 
252
        tilemap_set_scrolly(state->m_bg_tilemap, 0, -state->m_gfx_control[2]);
 
253
 
 
254
        if(!(state->m_gfx_control[0] & 0x8)) // screen disable
252
255
        {
253
256
                /* TODO: Color might be different, needs a video from an original pcb. */
254
 
                bitmap_fill(bitmap, cliprect, screen->machine->pens[0x10]);
 
257
                bitmap_fill(bitmap, cliprect, screen->machine().pens[0x10]);
255
258
        }
256
259
        else
257
260
        {
258
 
                tilemap_draw(bitmap,cliprect,bg_tilemap,0,0);
259
 
                tilemap_draw(bitmap,cliprect,fg_tilemap,0,0);
260
 
                draw_sprites(screen->machine, bitmap,cliprect);
 
261
                tilemap_draw(bitmap,cliprect,state->m_bg_tilemap,0,0);
 
262
                tilemap_draw(bitmap,cliprect,state->m_fg_tilemap,0,0);
 
263
                draw_sprites(screen->machine(), bitmap,cliprect);
261
264
        }
262
265
 
263
 
//  popmessage("%02x %02x %02x %02x",tryout_gfx_control[0],tryout_gfx_control[1],tryout_gfx_control[2],scrollx);
 
266
//  popmessage("%02x %02x %02x %02x",state->m_gfx_control[0],state->m_gfx_control[1],state->m_gfx_control[2],scrollx);
264
267
        return 0;
265
268
}