← Back to branch summary

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

« back to all changes in this revision

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

  • Committer: Package Import Robot
  • Author(s): Jordi Mallach, Emmanuel Kasper, Jordi Mallach
  • Date: 2012-06-05 20:02:23 UTC
  • mfrom: (0.3.1) (0.1.4)
  • Revision ID: package-import@ubuntu.com-20120605200223-gnlpogjrg6oqe9md
Tags: 0.146-1
[ Emmanuel Kasper ]
* New upstream release
* Drop patch to fix man pages section and patches to link with flac 
  and jpeg system lib: all this has been pushed upstream by Cesare Falco
* Add DM-Upload-Allowed: yes field.

[ Jordi Mallach ]
* Create a "gnu" TARGETOS stanza that defines NO_AFFINITY_NP.
* Stop setting TARGETOS to "unix" in d/rules. It should be autodetected,
  and set to the appropriate value.
* mame_manpage_section.patch: Change mame's manpage section to 6 (games),
  in the TH declaration.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/mame/video/twincobr.c
181
181
}
182
182
 
183
183
 
184
 
WRITE16_HANDLER( twincobr_txoffs_w )
185
 
{
186
 
        twincobr_state *state = space->machine().driver_data<twincobr_state>();
187
 
 
188
 
        COMBINE_DATA(&state->m_txoffs);
189
 
        state->m_txoffs %= state->m_txvideoram_size;
190
 
}
191
 
READ16_HANDLER( twincobr_txram_r )
192
 
{
193
 
        twincobr_state *state = space->machine().driver_data<twincobr_state>();
194
 
 
195
 
        return state->m_txvideoram16[state->m_txoffs];
196
 
}
197
 
WRITE16_HANDLER( twincobr_txram_w )
198
 
{
199
 
        twincobr_state *state = space->machine().driver_data<twincobr_state>();
200
 
 
201
 
        COMBINE_DATA(&state->m_txvideoram16[state->m_txoffs]);
202
 
        state->m_tx_tilemap->mark_tile_dirty(state->m_txoffs);
203
 
}
204
 
 
205
 
WRITE16_HANDLER( twincobr_bgoffs_w )
206
 
{
207
 
        twincobr_state *state = space->machine().driver_data<twincobr_state>();
208
 
 
209
 
        COMBINE_DATA(&state->m_bgoffs);
210
 
        state->m_bgoffs %= (state->m_bgvideoram_size >> 1);
211
 
}
212
 
READ16_HANDLER( twincobr_bgram_r )
213
 
{
214
 
        twincobr_state *state = space->machine().driver_data<twincobr_state>();
215
 
 
216
 
        return state->m_bgvideoram16[state->m_bgoffs+state->m_bg_ram_bank];
217
 
}
218
 
WRITE16_HANDLER( twincobr_bgram_w )
219
 
{
220
 
        twincobr_state *state = space->machine().driver_data<twincobr_state>();
221
 
 
222
 
        COMBINE_DATA(&state->m_bgvideoram16[state->m_bgoffs+state->m_bg_ram_bank]);
223
 
        state->m_bg_tilemap->mark_tile_dirty((state->m_bgoffs+state->m_bg_ram_bank));
224
 
}
225
 
 
226
 
WRITE16_HANDLER( twincobr_fgoffs_w )
227
 
{
228
 
        twincobr_state *state = space->machine().driver_data<twincobr_state>();
229
 
 
230
 
        COMBINE_DATA(&state->m_fgoffs);
231
 
        state->m_fgoffs %= state->m_fgvideoram_size;
232
 
}
233
 
READ16_HANDLER( twincobr_fgram_r )
234
 
{
235
 
        twincobr_state *state = space->machine().driver_data<twincobr_state>();
236
 
 
237
 
        return state->m_fgvideoram16[state->m_fgoffs];
238
 
}
239
 
WRITE16_HANDLER( twincobr_fgram_w )
240
 
{
241
 
        twincobr_state *state = space->machine().driver_data<twincobr_state>();
242
 
 
243
 
        COMBINE_DATA(&state->m_fgvideoram16[state->m_fgoffs]);
244
 
        state->m_fg_tilemap->mark_tile_dirty(state->m_fgoffs);
245
 
}
246
 
 
247
 
 
248
 
WRITE16_HANDLER( twincobr_txscroll_w )
249
 
{
250
 
        twincobr_state *state = space->machine().driver_data<twincobr_state>();
251
 
 
252
 
        if (offset == 0) {
253
 
                COMBINE_DATA(&state->m_txscrollx);
254
 
                state->m_tx_tilemap->set_scrollx(0,(state->m_txscrollx+state->m_scroll_x) & 0x1ff);
255
 
        }
256
 
        else {
257
 
                COMBINE_DATA(&state->m_txscrolly);
258
 
                state->m_tx_tilemap->set_scrolly(0,(state->m_txscrolly+state->m_scroll_y) & 0x1ff);
259
 
        }
260
 
}
261
 
 
262
 
WRITE16_HANDLER( twincobr_bgscroll_w )
263
 
{
264
 
        twincobr_state *state = space->machine().driver_data<twincobr_state>();
265
 
 
266
 
        if (offset == 0) {
267
 
                COMBINE_DATA(&state->m_bgscrollx);
268
 
                state->m_bg_tilemap->set_scrollx(0,(state->m_bgscrollx+state->m_scroll_x) & 0x1ff);
269
 
        }
270
 
        else {
271
 
                COMBINE_DATA(&state->m_bgscrolly);
272
 
                state->m_bg_tilemap->set_scrolly(0,(state->m_bgscrolly+state->m_scroll_y) & 0x1ff);
273
 
        }
274
 
}
275
 
 
276
 
WRITE16_HANDLER( twincobr_fgscroll_w )
277
 
{
278
 
        twincobr_state *state = space->machine().driver_data<twincobr_state>();
279
 
 
280
 
        if (offset == 0) {
281
 
                COMBINE_DATA(&state->m_fgscrollx);
282
 
                state->m_fg_tilemap->set_scrollx(0,(state->m_fgscrollx+state->m_scroll_x) & 0x1ff);
283
 
        }
284
 
        else {
285
 
                COMBINE_DATA(&state->m_fgscrolly);
286
 
                state->m_fg_tilemap->set_scrolly(0,(state->m_fgscrolly+state->m_scroll_y) & 0x1ff);
287
 
        }
288
 
}
289
 
 
290
 
WRITE16_HANDLER( twincobr_exscroll_w )  /* Extra unused video layer */
 
184
WRITE16_MEMBER(twincobr_state::twincobr_txoffs_w)
 
185
{
 
186
 
 
187
        COMBINE_DATA(&m_txoffs);
 
188
        m_txoffs %= m_txvideoram_size;
 
189
}
 
190
READ16_MEMBER(twincobr_state::twincobr_txram_r)
 
191
{
 
192
 
 
193
        return m_txvideoram16[m_txoffs];
 
194
}
 
195
WRITE16_MEMBER(twincobr_state::twincobr_txram_w)
 
196
{
 
197
 
 
198
        COMBINE_DATA(&m_txvideoram16[m_txoffs]);
 
199
        m_tx_tilemap->mark_tile_dirty(m_txoffs);
 
200
}
 
201
 
 
202
WRITE16_MEMBER(twincobr_state::twincobr_bgoffs_w)
 
203
{
 
204
 
 
205
        COMBINE_DATA(&m_bgoffs);
 
206
        m_bgoffs %= (m_bgvideoram_size >> 1);
 
207
}
 
208
READ16_MEMBER(twincobr_state::twincobr_bgram_r)
 
209
{
 
210
 
 
211
        return m_bgvideoram16[m_bgoffs+m_bg_ram_bank];
 
212
}
 
213
WRITE16_MEMBER(twincobr_state::twincobr_bgram_w)
 
214
{
 
215
 
 
216
        COMBINE_DATA(&m_bgvideoram16[m_bgoffs+m_bg_ram_bank]);
 
217
        m_bg_tilemap->mark_tile_dirty((m_bgoffs+m_bg_ram_bank));
 
218
}
 
219
 
 
220
WRITE16_MEMBER(twincobr_state::twincobr_fgoffs_w)
 
221
{
 
222
 
 
223
        COMBINE_DATA(&m_fgoffs);
 
224
        m_fgoffs %= m_fgvideoram_size;
 
225
}
 
226
READ16_MEMBER(twincobr_state::twincobr_fgram_r)
 
227
{
 
228
 
 
229
        return m_fgvideoram16[m_fgoffs];
 
230
}
 
231
WRITE16_MEMBER(twincobr_state::twincobr_fgram_w)
 
232
{
 
233
 
 
234
        COMBINE_DATA(&m_fgvideoram16[m_fgoffs]);
 
235
        m_fg_tilemap->mark_tile_dirty(m_fgoffs);
 
236
}
 
237
 
 
238
 
 
239
WRITE16_MEMBER(twincobr_state::twincobr_txscroll_w)
 
240
{
 
241
 
 
242
        if (offset == 0) {
 
243
                COMBINE_DATA(&m_txscrollx);
 
244
                m_tx_tilemap->set_scrollx(0,(m_txscrollx+m_scroll_x) & 0x1ff);
 
245
        }
 
246
        else {
 
247
                COMBINE_DATA(&m_txscrolly);
 
248
                m_tx_tilemap->set_scrolly(0,(m_txscrolly+m_scroll_y) & 0x1ff);
 
249
        }
 
250
}
 
251
 
 
252
WRITE16_MEMBER(twincobr_state::twincobr_bgscroll_w)
 
253
{
 
254
 
 
255
        if (offset == 0) {
 
256
                COMBINE_DATA(&m_bgscrollx);
 
257
                m_bg_tilemap->set_scrollx(0,(m_bgscrollx+m_scroll_x) & 0x1ff);
 
258
        }
 
259
        else {
 
260
                COMBINE_DATA(&m_bgscrolly);
 
261
                m_bg_tilemap->set_scrolly(0,(m_bgscrolly+m_scroll_y) & 0x1ff);
 
262
        }
 
263
}
 
264
 
 
265
WRITE16_MEMBER(twincobr_state::twincobr_fgscroll_w)
 
266
{
 
267
 
 
268
        if (offset == 0) {
 
269
                COMBINE_DATA(&m_fgscrollx);
 
270
                m_fg_tilemap->set_scrollx(0,(m_fgscrollx+m_scroll_x) & 0x1ff);
 
271
        }
 
272
        else {
 
273
                COMBINE_DATA(&m_fgscrolly);
 
274
                m_fg_tilemap->set_scrolly(0,(m_fgscrolly+m_scroll_y) & 0x1ff);
 
275
        }
 
276
}
 
277
 
 
278
WRITE16_MEMBER(twincobr_state::twincobr_exscroll_w)/* Extra unused video layer */
291
279
{
292
280
        if (offset == 0) logerror("PC - write %04x to unknown video scroll Y register\n",data);
293
281
        else logerror("PC - write %04x to unknown video scroll X register\n",data);
294
282
}
295
283
 
296
284
/******************** Wardner interface to this hardware ********************/
297
 
WRITE8_HANDLER( wardner_txlayer_w )
 
285
WRITE8_MEMBER(twincobr_state::wardner_txlayer_w)
298
286
{
299
287
        int shift = 8 * (offset & 1);
300
288
        twincobr_txoffs_w(space, offset / 2, data << shift, 0xff << shift);
301
289
}
302
290
 
303
 
WRITE8_HANDLER( wardner_bglayer_w )
 
291
WRITE8_MEMBER(twincobr_state::wardner_bglayer_w)
304
292
{
305
293
        int shift = 8 * (offset & 1);
306
294
        twincobr_bgoffs_w(space, offset / 2, data << shift, 0xff << shift);
307
295
}
308
296
 
309
 
WRITE8_HANDLER( wardner_fglayer_w )
 
297
WRITE8_MEMBER(twincobr_state::wardner_fglayer_w)
310
298
{
311
299
        int shift = 8 * (offset & 1);
312
300
        twincobr_fgoffs_w(space, offset / 2, data << shift, 0xff << shift);
313
301
}
314
302
 
315
 
WRITE8_HANDLER( wardner_txscroll_w )
 
303
WRITE8_MEMBER(twincobr_state::wardner_txscroll_w)
316
304
{
317
305
        int shift = 8 * (offset & 1);
318
306
        twincobr_txscroll_w(space, offset / 2, data << shift, 0xff << shift);
319
307
}
320
308
 
321
 
WRITE8_HANDLER( wardner_bgscroll_w )
 
309
WRITE8_MEMBER(twincobr_state::wardner_bgscroll_w)
322
310
{
323
311
        int shift = 8 * (offset & 1);
324
312
        twincobr_bgscroll_w(space, offset / 2, data << shift, 0xff << shift);
325
313
}
326
314
 
327
 
WRITE8_HANDLER( wardner_fgscroll_w )
 
315
WRITE8_MEMBER(twincobr_state::wardner_fgscroll_w)
328
316
{
329
317
        int shift = 8 * (offset & 1);
330
318
        twincobr_fgscroll_w(space, offset / 2, data << shift, 0xff << shift);
331
319
}
332
320
 
333
 
WRITE8_HANDLER( wardner_exscroll_w )    /* Extra unused video layer */
 
321
WRITE8_MEMBER(twincobr_state::wardner_exscroll_w)/* Extra unused video layer */
334
322
{
335
323
        switch (offset)
336
324
        {
341
329
        }
342
330
}
343
331
 
344
 
READ8_HANDLER( wardner_videoram_r )
 
332
READ8_MEMBER(twincobr_state::wardner_videoram_r)
345
333
{
346
334
        int shift = 8 * (offset & 1);
347
335
        switch (offset/2) {
352
340
        return 0;
353
341
}
354
342
 
355
 
WRITE8_HANDLER( wardner_videoram_w )
 
343
WRITE8_MEMBER(twincobr_state::wardner_videoram_w)
356
344
{
357
345
        int shift = 8 * (offset & 1);
358
346
        switch (offset/2) {
362
350
        }
363
351
}
364
352
 
365
 
READ8_HANDLER( wardner_sprite_r )
 
353
READ8_MEMBER(twincobr_state::wardner_sprite_r)
366
354
{
 
355
        UINT16 *spriteram16 = reinterpret_cast<UINT16 *>(m_spriteram8->live());
367
356
        int shift = (offset & 1) * 8;
368
 
        return space->machine().generic.spriteram.u16[offset/2] >> shift;
 
357
        return spriteram16[offset/2] >> shift;
369
358
}
370
359
 
371
 
WRITE8_HANDLER( wardner_sprite_w )
 
360
WRITE8_MEMBER(twincobr_state::wardner_sprite_w)
372
361
{
373
 
        UINT16 *spriteram16 = space->machine().generic.spriteram.u16;
 
362
        UINT16 *spriteram16 = reinterpret_cast<UINT16 *>(m_spriteram8->live());
374
363
        if (offset & 1)
375
364
                spriteram16[offset/2] = (spriteram16[offset/2] & 0x00ff) | (data << 8);
376
365
        else
388
377
        twincobr_state *state = machine.driver_data<twincobr_state>();
389
378
 
390
379
        if (state->m_fgscrollx != state->m_bgscrollx) {
391
 
                UINT16 *buffered_spriteram16 = machine.generic.buffered_spriteram.u16;
 
380
                UINT16 *buffered_spriteram16 = reinterpret_cast<UINT16 *>(state->m_spriteram8->buffer());
392
381
                if ((state->m_fgscrollx==0x1c9) || (state->m_flip_screen && (state->m_fgscrollx==0x17a))) {     /* in the shop ? */
393
382
                        int wardner_hack = buffered_spriteram16[0x0b04/2];
394
383
                /* sprite position 0x6300 to 0x8700 -- hero on shop keeper (normal) */
465
454
 
466
455
        if (state->m_display_on)
467
456
        {
468
 
                UINT16 *buffered_spriteram16 = machine.generic.buffered_spriteram.u16;
469
 
                for (offs = 0;offs < machine.generic.spriteram_size/2;offs += 4)
 
457
                UINT16 *buffered_spriteram16;
 
458
                UINT32 bytes;
 
459
                if (state->m_spriteram16 != NULL)
 
460
                {
 
461
                        buffered_spriteram16 = state->m_spriteram16->buffer();
 
462
                        bytes = state->m_spriteram16->bytes();
 
463
                }
 
464
                else
 
465
                {
 
466
                        buffered_spriteram16 = reinterpret_cast<UINT16 *>(state->m_spriteram8->buffer());
 
467
                        bytes = state->m_spriteram8->bytes();
 
468
                }
 
469
                for (offs = 0;offs < bytes/2;offs += 4)
470
470
                {
471
471
                        int attribute,sx,sy,flipx,flipy;
472
472
                        int sprite, color;
515
515
        return 0;
516
516
}
517
517
 
518
 
 
519
 
SCREEN_VBLANK( toaplan0 )
520
 
{
521
 
        // rising edge
522
 
        if (vblank_on)
523
 
        {
524
 
                address_space *space = screen.machine().device("maincpu")->memory().space(AS_PROGRAM);
525
 
 
526
 
                /* Spriteram is always 1 frame ahead, suggesting spriteram buffering.
527
 
            There are no CPU output registers that control this so we
528
 
            assume it happens automatically every frame, at the end of vblank */
529
 
                buffer_spriteram16_w(space,0,0,0xffff);
530
 
        }
531
 
}
 
518
/* Spriteram is always 1 frame ahead, suggesting spriteram buffering.
 
519
  There are no CPU output registers that control this so we
 
520
  assume it happens automatically every frame, at the end of vblank */