← Back to branch summary

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

« back to all changes in this revision

Viewing changes to src/mame/video/gng.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/gng.c
65
65
 
66
66
***************************************************************************/
67
67
 
68
 
WRITE8_HANDLER( gng_fgvideoram_w )
69
 
{
70
 
        gng_state *state = space->machine().driver_data<gng_state>();
71
 
        state->m_fgvideoram[offset] = data;
72
 
        state->m_fg_tilemap->mark_tile_dirty(offset & 0x3ff);
73
 
}
74
 
 
75
 
WRITE8_HANDLER( gng_bgvideoram_w )
76
 
{
77
 
        gng_state *state = space->machine().driver_data<gng_state>();
78
 
        state->m_bgvideoram[offset] = data;
79
 
        state->m_bg_tilemap->mark_tile_dirty(offset & 0x3ff);
80
 
}
81
 
 
82
 
 
83
 
WRITE8_HANDLER( gng_bgscrollx_w )
84
 
{
85
 
        gng_state *state = space->machine().driver_data<gng_state>();
86
 
        state->m_scrollx[offset] = data;
87
 
        state->m_bg_tilemap->set_scrollx(0, state->m_scrollx[0] + 256 * state->m_scrollx[1]);
88
 
}
89
 
 
90
 
WRITE8_HANDLER( gng_bgscrolly_w )
91
 
{
92
 
        gng_state *state = space->machine().driver_data<gng_state>();
93
 
        state->m_scrolly[offset] = data;
94
 
        state->m_bg_tilemap->set_scrolly(0, state->m_scrolly[0] + 256 * state->m_scrolly[1]);
95
 
}
96
 
 
97
 
 
98
 
WRITE8_HANDLER( gng_flipscreen_w )
99
 
{
100
 
        flip_screen_set(space->machine(), ~data & 1);
 
68
WRITE8_MEMBER(gng_state::gng_fgvideoram_w)
 
69
{
 
70
        m_fgvideoram[offset] = data;
 
71
        m_fg_tilemap->mark_tile_dirty(offset & 0x3ff);
 
72
}
 
73
 
 
74
WRITE8_MEMBER(gng_state::gng_bgvideoram_w)
 
75
{
 
76
        m_bgvideoram[offset] = data;
 
77
        m_bg_tilemap->mark_tile_dirty(offset & 0x3ff);
 
78
}
 
79
 
 
80
 
 
81
WRITE8_MEMBER(gng_state::gng_bgscrollx_w)
 
82
{
 
83
        m_scrollx[offset] = data;
 
84
        m_bg_tilemap->set_scrollx(0, m_scrollx[0] + 256 * m_scrollx[1]);
 
85
}
 
86
 
 
87
WRITE8_MEMBER(gng_state::gng_bgscrolly_w)
 
88
{
 
89
        m_scrolly[offset] = data;
 
90
        m_bg_tilemap->set_scrolly(0, m_scrolly[0] + 256 * m_scrolly[1]);
 
91
}
 
92
 
 
93
 
 
94
WRITE8_MEMBER(gng_state::gng_flipscreen_w)
 
95
{
 
96
        flip_screen_set(~data & 1);
101
97
}
102
98
 
103
99
 
110
106
 
111
107
static void draw_sprites( running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect )
112
108
{
113
 
        UINT8 *buffered_spriteram = machine.generic.buffered_spriteram.u8;
 
109
        gng_state *state = machine.driver_data<gng_state>();
 
110
        UINT8 *buffered_spriteram = state->m_spriteram->buffer();
114
111
        const gfx_element *gfx = machine.gfx[2];
115
112
        int offs;
116
113
 
117
114
 
118
 
        for (offs = machine.generic.spriteram_size - 4; offs >= 0; offs -= 4)
 
115
        for (offs = state->m_spriteram->bytes() - 4; offs >= 0; offs -= 4)
119
116
        {
120
117
                UINT8 attributes = buffered_spriteram[offs + 1];
121
118
                int sx = buffered_spriteram[offs + 3] - 0x100 * (attributes & 0x01);
123
120
                int flipx = attributes & 0x04;
124
121
                int flipy = attributes & 0x08;
125
122
 
126
 
                if (flip_screen_get(machine))
 
123
                if (state->flip_screen())
127
124
                {
128
125
                        sx = 240 - sx;
129
126
                        sy = 240 - sy;
149
146
        state->m_fg_tilemap->draw(bitmap, cliprect, 0, 0);
150
147
        return 0;
151
148
}
152
 
 
153
 
SCREEN_VBLANK( gng )
154
 
{
155
 
        // rising edge
156
 
        if (vblank_on)
157
 
        {
158
 
                address_space *space = screen.machine().device("maincpu")->memory().space(AS_PROGRAM);
159
 
 
160
 
                buffer_spriteram_w(space, 0, 0);
161
 
        }
162
 
}