← Back to branch summary

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

« back to all changes in this revision

Viewing changes to src/mame/video/snk6502.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/snk6502.c
24
24
***************************************************************************/
25
25
PALETTE_INIT( snk6502 )
26
26
{
 
27
        const UINT8 *color_prom = machine.root_device().memregion("proms")->base();
27
28
        snk6502_state *state = machine.driver_data<snk6502_state>();
28
29
        int i;
29
30
 
74
75
        }
75
76
}
76
77
 
77
 
WRITE8_HANDLER( snk6502_videoram_w )
78
 
{
79
 
        snk6502_state *state = space->machine().driver_data<snk6502_state>();
80
 
 
81
 
        state->m_videoram[offset] = data;
82
 
        state->m_bg_tilemap->mark_tile_dirty(offset);
83
 
}
84
 
 
85
 
WRITE8_HANDLER( snk6502_videoram2_w )
86
 
{
87
 
        snk6502_state *state = space->machine().driver_data<snk6502_state>();
88
 
 
89
 
        state->m_videoram2[offset] = data;
90
 
        state->m_fg_tilemap->mark_tile_dirty(offset);
91
 
}
92
 
 
93
 
WRITE8_HANDLER( snk6502_colorram_w )
94
 
{
95
 
        snk6502_state *state = space->machine().driver_data<snk6502_state>();
96
 
 
97
 
        state->m_colorram[offset] = data;
98
 
        state->m_bg_tilemap->mark_tile_dirty(offset);
99
 
        state->m_fg_tilemap->mark_tile_dirty(offset);
100
 
}
101
 
 
102
 
WRITE8_HANDLER( snk6502_charram_w )
103
 
{
104
 
        snk6502_state *state = space->machine().driver_data<snk6502_state>();
105
 
 
106
 
        if (state->m_charram[offset] != data)
 
78
WRITE8_MEMBER(snk6502_state::snk6502_videoram_w)
 
79
{
 
80
 
 
81
        m_videoram[offset] = data;
 
82
        m_bg_tilemap->mark_tile_dirty(offset);
 
83
}
 
84
 
 
85
WRITE8_MEMBER(snk6502_state::snk6502_videoram2_w)
 
86
{
 
87
 
 
88
        m_videoram2[offset] = data;
 
89
        m_fg_tilemap->mark_tile_dirty(offset);
 
90
}
 
91
 
 
92
WRITE8_MEMBER(snk6502_state::snk6502_colorram_w)
 
93
{
 
94
 
 
95
        m_colorram[offset] = data;
 
96
        m_bg_tilemap->mark_tile_dirty(offset);
 
97
        m_fg_tilemap->mark_tile_dirty(offset);
 
98
}
 
99
 
 
100
WRITE8_MEMBER(snk6502_state::snk6502_charram_w)
 
101
{
 
102
 
 
103
        if (m_charram[offset] != data)
107
104
        {
108
 
                state->m_charram[offset] = data;
109
 
                gfx_element_mark_dirty(space->machine().gfx[0], (offset/8) % 256);
 
105
                m_charram[offset] = data;
 
106
                gfx_element_mark_dirty(machine().gfx[0], (offset/8) % 256);
110
107
        }
111
108
}
112
109
 
113
110
 
114
 
WRITE8_HANDLER( snk6502_flipscreen_w )
 
111
WRITE8_MEMBER(snk6502_state::snk6502_flipscreen_w)
115
112
{
116
 
        snk6502_state *state = space->machine().driver_data<snk6502_state>();
117
113
        int bank;
118
114
 
119
115
        /* bits 0-2 select background color */
120
116
 
121
 
        if (state->m_backcolor != (data & 7))
 
117
        if (m_backcolor != (data & 7))
122
118
        {
123
119
                int i;
124
120
 
125
 
                state->m_backcolor = data & 7;
 
121
                m_backcolor = data & 7;
126
122
 
127
123
                for (i = 0;i < 32;i += 4)
128
 
                        palette_set_color(space->machine(), COLOR(space->machine(), 1, i), state->m_palette[4 * state->m_backcolor + 0x20]);
 
124
                        palette_set_color(machine(), COLOR(machine(), 1, i), m_palette[4 * m_backcolor + 0x20]);
129
125
        }
130
126
 
131
127
        /* bit 3 selects char bank */
132
128
 
133
129
        bank = (~data & 0x08) >> 3;
134
130
 
135
 
        if (state->m_charbank != bank)
 
131
        if (m_charbank != bank)
136
132
        {
137
 
                state->m_charbank = bank;
138
 
                space->machine().tilemap().mark_all_dirty();
 
133
                m_charbank = bank;
 
134
                machine().tilemap().mark_all_dirty();
139
135
        }
140
136
 
141
137
        /* bit 7 flips screen */
142
138
 
143
 
        if (flip_screen_get(space->machine()) != (data & 0x80))
 
139
        if (flip_screen() != (data & 0x80))
144
140
        {
145
 
                flip_screen_set(space->machine(), data & 0x80);
146
 
                space->machine().tilemap().mark_all_dirty();
 
141
                flip_screen_set(data & 0x80);
 
142
                machine().tilemap().mark_all_dirty();
147
143
        }
148
144
}
149
145
 
150
 
WRITE8_HANDLER( snk6502_scrollx_w )
 
146
WRITE8_MEMBER(snk6502_state::snk6502_scrollx_w)
151
147
{
152
 
        snk6502_state *state = space->machine().driver_data<snk6502_state>();
153
148
 
154
 
        state->m_bg_tilemap->set_scrollx(0, data);
 
149
        m_bg_tilemap->set_scrollx(0, data);
155
150
}
156
151
 
157
 
WRITE8_HANDLER( snk6502_scrolly_w )
 
152
WRITE8_MEMBER(snk6502_state::snk6502_scrolly_w)
158
153
{
159
 
        snk6502_state *state = space->machine().driver_data<snk6502_state>();
160
154
 
161
 
        state->m_bg_tilemap->set_scrolly(0, data);
 
155
        m_bg_tilemap->set_scrolly(0, data);
162
156
}
163
157
 
164
158
 
216
210
 
217
211
PALETTE_INIT( satansat )
218
212
{
 
213
        const UINT8 *color_prom = machine.root_device().memregion("proms")->base();
219
214
        snk6502_state *state = machine.driver_data<snk6502_state>();
220
215
        int i;
221
216
 
266
261
        }
267
262
}
268
263
 
269
 
WRITE8_HANDLER( satansat_b002_w )
 
264
WRITE8_MEMBER(snk6502_state::satansat_b002_w)
270
265
{
271
 
        snk6502_state *state = space->machine().driver_data<snk6502_state>();
272
266
        /* bit 0 flips screen */
273
267
 
274
 
        if (flip_screen_get(space->machine()) != (data & 0x01))
 
268
        if (flip_screen() != (data & 0x01))
275
269
        {
276
 
                flip_screen_set(space->machine(), data & 0x01);
277
 
                space->machine().tilemap().mark_all_dirty();
 
270
                flip_screen_set(data & 0x01);
 
271
                machine().tilemap().mark_all_dirty();
278
272
        }
279
273
 
280
274
        /* bit 1 enables interrupts */
281
 
        state->m_irq_mask = data & 2;
 
275
        m_irq_mask = data & 2;
282
276
 
283
277
        /* other bits unused */
284
278
}
285
279
 
286
 
WRITE8_HANDLER( satansat_backcolor_w )
 
280
WRITE8_MEMBER(snk6502_state::satansat_backcolor_w)
287
281
{
288
 
        snk6502_state *state = space->machine().driver_data<snk6502_state>();
289
282
 
290
283
        /* bits 0-1 select background color. Other bits unused. */
291
284
 
292
 
        if (state->m_backcolor != (data & 0x03))
 
285
        if (m_backcolor != (data & 0x03))
293
286
        {
294
287
                int i;
295
288
 
296
 
                state->m_backcolor = data & 0x03;
 
289
                m_backcolor = data & 0x03;
297
290
 
298
291
                for (i = 0; i < 16; i += 4)
299
 
                        palette_set_color(space->machine(), COLOR(space->machine(), 1, i), state->m_palette[state->m_backcolor + 0x10]);
 
292
                        palette_set_color(machine(), COLOR(machine(), 1, i), m_palette[m_backcolor + 0x10]);
300
293
        }
301
294
}
302
295