← Back to branch summary

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

« back to all changes in this revision

Viewing changes to src/mame/video/hyprduel.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/hyprduel.c
61
61
                            Palette GGGGGRRRRRBBBBBx
62
62
***************************************************************************/
63
63
 
64
 
WRITE16_HANDLER( hyprduel_paletteram_w )
 
64
WRITE16_MEMBER(hyprduel_state::hyprduel_paletteram_w)
65
65
{
66
 
        hyprduel_state *state = space->machine().driver_data<hyprduel_state>();
67
 
        data = COMBINE_DATA(&state->m_paletteram[offset]);
68
 
        palette_set_color_rgb(space->machine(), offset, pal5bit(data >> 6), pal5bit(data >> 11), pal5bit(data >> 1));
 
66
        data = COMBINE_DATA(&m_paletteram[offset]);
 
67
        palette_set_color_rgb(machine(), offset, pal5bit(data >> 6), pal5bit(data >> 11), pal5bit(data >> 1));
69
68
}
70
69
 
71
70
 
275
274
        get_tile_info_8bit(machine, tileinfo, tile_index, 2, state->m_vram_2);
276
275
}
277
276
 
278
 
WRITE16_HANDLER( hyprduel_vram_0_w )
279
 
{
280
 
        hyprduel_state *state = space->machine().driver_data<hyprduel_state>();
281
 
        hyprduel_vram_w(space->machine(), offset, data, mem_mask, 0, state->m_vram_0);
282
 
}
283
 
 
284
 
WRITE16_HANDLER( hyprduel_vram_1_w )
285
 
{
286
 
        hyprduel_state *state = space->machine().driver_data<hyprduel_state>();
287
 
        hyprduel_vram_w(space->machine(), offset, data, mem_mask, 1, state->m_vram_1);
288
 
}
289
 
 
290
 
WRITE16_HANDLER( hyprduel_vram_2_w )
291
 
{
292
 
        hyprduel_state *state = space->machine().driver_data<hyprduel_state>();
293
 
        hyprduel_vram_w(space->machine(), offset, data, mem_mask, 2, state->m_vram_2);
 
277
WRITE16_MEMBER(hyprduel_state::hyprduel_vram_0_w)
 
278
{
 
279
        hyprduel_vram_w(machine(), offset, data, mem_mask, 0, m_vram_0);
 
280
}
 
281
 
 
282
WRITE16_MEMBER(hyprduel_state::hyprduel_vram_1_w)
 
283
{
 
284
        hyprduel_vram_w(machine(), offset, data, mem_mask, 1, m_vram_1);
 
285
}
 
286
 
 
287
WRITE16_MEMBER(hyprduel_state::hyprduel_vram_2_w)
 
288
{
 
289
        hyprduel_vram_w(machine(), offset, data, mem_mask, 2, m_vram_2);
294
290
}
295
291
 
296
292
 
297
293
/* Dirty the relevant tilemap when its window changes */
298
 
WRITE16_HANDLER( hyprduel_window_w )
 
294
WRITE16_MEMBER(hyprduel_state::hyprduel_window_w)
299
295
{
300
 
        hyprduel_state *state = space->machine().driver_data<hyprduel_state>();
301
 
        UINT16 olddata = state->m_window[offset];
302
 
        UINT16 newdata = COMBINE_DATA(&state->m_window[offset]);
 
296
        UINT16 olddata = m_window[offset];
 
297
        UINT16 newdata = COMBINE_DATA(&m_window[offset]);
303
298
        if (newdata != olddata)
304
299
        {
305
300
                offset /= 2;
306
 
                state->m_bg_tilemap[offset]->mark_all_dirty();
 
301
                m_bg_tilemap[offset]->mark_all_dirty();
307
302
        }
308
303
}
309
304
 
353
348
 
354
349
static void expand_gfx1(hyprduel_state &state)
355
350
{
356
 
        UINT8 *base_gfx = state.machine().region("gfx1")->base();
357
 
        UINT32 length = 2 * state.machine().region("gfx1")->bytes();
 
351
        UINT8 *base_gfx = state.machine().root_device().memregion("gfx1")->base();
 
352
        UINT32 length = 2 * state.machine().root_device().memregion("gfx1")->bytes();
358
353
        state.m_expanded_gfx1 = auto_alloc_array(state.machine(), UINT8, length);
359
354
        for (int i = 0; i < length; i += 2)
360
355
        {
369
364
        hyprduel_state *state = machine.driver_data<hyprduel_state>();
370
365
        expand_gfx1(*state);
371
366
        alloc_empty_tiles(machine);
372
 
        state->m_tiletable_old = auto_alloc_array(machine, UINT16, state->m_tiletable_size / 2);
373
 
        state->m_dirtyindex = auto_alloc_array(machine, UINT8, state->m_tiletable_size / 4);
 
367
        state->m_tiletable_old = auto_alloc_array(machine, UINT16, state->m_tiletable.bytes() / 2);
 
368
        state->m_dirtyindex = auto_alloc_array(machine, UINT8, state->m_tiletable.bytes() / 4);
374
369
 
375
 
        state->save_pointer(NAME(state->m_tiletable_old), state->m_tiletable_size / 2);
376
 
        state->save_pointer(NAME(state->m_dirtyindex), state->m_tiletable_size / 4);
 
370
        state->save_pointer(NAME(state->m_tiletable_old), state->m_tiletable.bytes() / 2);
 
371
        state->save_pointer(NAME(state->m_dirtyindex), state->m_tiletable.bytes() / 4);
377
372
 
378
373
        state->m_bg_tilemap[0] = tilemap_create(machine, get_tile_info_0_8bit, tilemap_scan_rows, 8, 8, WIN_NX, WIN_NY);
379
374
        state->m_bg_tilemap[1] = tilemap_create(machine, get_tile_info_1_8bit, tilemap_scan_rows, 8, 8, WIN_NX, WIN_NY);
477
472
{
478
473
        hyprduel_state *state = machine.driver_data<hyprduel_state>();
479
474
        UINT8 *base_gfx4 = state->m_expanded_gfx1;
480
 
        UINT8 *base_gfx8 = machine.region("gfx1")->base();
481
 
        UINT32 gfx_size = machine.region("gfx1")->bytes();
 
475
        UINT8 *base_gfx8 = state->memregion("gfx1")->base();
 
476
        UINT32 gfx_size = state->memregion("gfx1")->bytes();
482
477
 
483
478
        int max_x = machine.primary_screen->width();
484
479
        int max_y = machine.primary_screen->height();
485
480
 
486
 
        int max_sprites = state->m_spriteram_size / 8;
 
481
        int max_sprites = state->m_spriteram.bytes() / 8;
487
482
        int sprites = state->m_videoregs[0x00 / 2] % max_sprites;
488
483
 
489
484
        int color_start = ((state->m_videoregs[0x08 / 2] & 0xf) << 4) + 0x100;
562
557
 
563
558
                        UINT32 gfxstart = (8 * 8 * 4 / 8) * (((attr & 0x000f) << 16) + code);
564
559
 
565
 
                        if (flip_screen_get(machine))
 
560
                        if (state->flip_screen())
566
561
                        {
567
562
                                flipx = !flipx;         x = max_x - x - width;
568
563
                                flipy = !flipy;         y = max_y - y - height;
616
611
                                Screen Drawing
617
612
***************************************************************************/
618
613
 
619
 
WRITE16_HANDLER( hyprduel_scrollreg_w )
 
614
WRITE16_MEMBER(hyprduel_state::hyprduel_scrollreg_w)
620
615
{
621
 
        hyprduel_state *state = space->machine().driver_data<hyprduel_state>();
622
 
        UINT16 window = state->m_window[offset];
 
616
        UINT16 window = m_window[offset];
623
617
 
624
 
        COMBINE_DATA(&state->m_scroll[offset]);
 
618
        COMBINE_DATA(&m_scroll[offset]);
625
619
 
626
620
        if (offset & 0x01)
627
 
                state->m_bg_tilemap[offset / 2]->set_scrollx(0, state->m_scroll[offset] - window - (window & 7));
 
621
                m_bg_tilemap[offset / 2]->set_scrollx(0, m_scroll[offset] - window - (window & 7));
628
622
        else
629
 
                state->m_bg_tilemap[offset / 2]->set_scrolly(0, state->m_scroll[offset] - window - (window & 7));
 
623
                m_bg_tilemap[offset / 2]->set_scrolly(0, m_scroll[offset] - window - (window & 7));
630
624
}
631
625
 
632
 
WRITE16_HANDLER( hyprduel_scrollreg_init_w )
 
626
WRITE16_MEMBER(hyprduel_state::hyprduel_scrollreg_init_w)
633
627
{
634
 
        hyprduel_state *state = space->machine().driver_data<hyprduel_state>();
635
628
        int i;
636
629
 
637
630
        for (i = 0; i < 3; i++)
638
631
        {
639
 
                UINT16 wx = state->m_window[i * 2 + 1];
640
 
                UINT16 wy = state->m_window[i * 2 + 0];
641
 
 
642
 
                state->m_scroll[i * 2 + 1] = data;
643
 
                state->m_scroll[i * 2 + 0] = data;
644
 
 
645
 
                state->m_bg_tilemap[i]->set_scrollx(0, data - wx - (wx & 7));
646
 
                state->m_bg_tilemap[i]->set_scrolly(0, data - wy - (wy & 7));
 
632
                UINT16 wx = m_window[i * 2 + 1];
 
633
                UINT16 wy = m_window[i * 2 + 0];
 
634
 
 
635
                m_scroll[i * 2 + 1] = data;
 
636
                m_scroll[i * 2 + 0] = data;
 
637
 
 
638
                m_bg_tilemap[i]->set_scrollx(0, data - wx - (wx & 7));
 
639
                m_bg_tilemap[i]->set_scrolly(0, data - wy - (wy & 7));
647
640
        }
648
641
}
649
642
 
694
687
        {
695
688
                int dirty = 0;
696
689
 
697
 
                memset(state->m_dirtyindex, 0, state->m_tiletable_size / 4);
698
 
                for (i = 0; i < state->m_tiletable_size / 4; i++)
 
690
                memset(state->m_dirtyindex, 0, state->m_tiletable.bytes() / 4);
 
691
                for (i = 0; i < state->m_tiletable.bytes() / 4; i++)
699
692
                {
700
693
                        UINT32 tile_new = (state->m_tiletable[2 * i + 0] << 16 ) + state->m_tiletable[2 * i + 1];
701
694
                        UINT32 tile_old = (state->m_tiletable_old[2 * i + 0] << 16 ) + state->m_tiletable_old[2 * i + 1];
706
699
                                dirty = 1;
707
700
                        }
708
701
                }
709
 
                memcpy(state->m_tiletable_old, state->m_tiletable, state->m_tiletable_size);
 
702
                memcpy(state->m_tiletable_old, state->m_tiletable, state->m_tiletable.bytes());
710
703
 
711
704
                if (dirty)
712
705
                {
736
729
        ---- ---- ---- ---0     Flip  Screen    */
737
730
        if (screenctrl & 2)
738
731
                return 0;
739
 
        flip_screen_set(screen.machine(), screenctrl & 1);
 
732
        state->flip_screen_set(screenctrl & 1);
740
733
 
741
734
#if 0
742
735
if (screen.machine().input().code_pressed(KEYCODE_Z))