← Back to branch summary

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

« back to all changes in this revision

Viewing changes to src/mame/video/tceptor.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/tceptor.c
20
20
 
21
21
PALETTE_INIT( tceptor )
22
22
{
 
23
        const UINT8 *color_prom = machine.root_device().memregion("proms")->base();
23
24
        tceptor_state *state = machine.driver_data<tceptor_state>();
24
25
        int i;
25
26
 
115
116
        SET_TILE_INFO(0, code, color, 0);
116
117
}
117
118
 
118
 
static void tile_mark_dirty(tceptor_state *state, int offset)
 
119
void tceptor_state::tile_mark_dirty(int offset)
119
120
{
120
121
        int x = -1;
121
122
        int y = -1;
138
139
        }
139
140
 
140
141
        if (x >= 0)
141
 
                state->m_tx_tilemap->mark_tile_dirty(x * 28 + y);
 
142
                m_tx_tilemap->mark_tile_dirty(x * 28 + y);
142
143
}
143
144
 
144
145
 
145
 
WRITE8_HANDLER( tceptor_tile_ram_w )
 
146
WRITE8_MEMBER(tceptor_state::tceptor_tile_ram_w)
146
147
{
147
 
        tceptor_state *state = space->machine().driver_data<tceptor_state>();
148
 
        if (state->m_tile_ram[offset] != data)
 
148
        if (m_tile_ram[offset] != data)
149
149
        {
150
 
                state->m_tile_ram[offset] = data;
151
 
                tile_mark_dirty(state, offset);
 
150
                m_tile_ram[offset] = data;
 
151
                tile_mark_dirty(offset);
152
152
        }
153
153
}
154
154
 
155
 
WRITE8_HANDLER( tceptor_tile_attr_w )
 
155
WRITE8_MEMBER(tceptor_state::tceptor_tile_attr_w)
156
156
{
157
 
        tceptor_state *state = space->machine().driver_data<tceptor_state>();
158
 
        if (state->m_tile_attr[offset] != data)
 
157
        if (m_tile_attr[offset] != data)
159
158
        {
160
 
                state->m_tile_attr[offset] = data;
161
 
                tile_mark_dirty(state, offset);
 
159
                m_tile_attr[offset] = data;
 
160
                tile_mark_dirty(offset);
162
161
        }
163
162
}
164
163
 
185
184
        SET_TILE_INFO(state->m_bg, code, color, 0);
186
185
}
187
186
 
188
 
WRITE8_HANDLER( tceptor_bg_ram_w )
 
187
WRITE8_MEMBER(tceptor_state::tceptor_bg_ram_w)
189
188
{
190
 
        tceptor_state *state = space->machine().driver_data<tceptor_state>();
191
 
        state->m_bg_ram[offset] = data;
 
189
        m_bg_ram[offset] = data;
192
190
 
193
191
        offset /= 2;
194
192
        if (offset < 0x800)
195
 
                state->m_bg1_tilemap->mark_tile_dirty(offset);
 
193
                m_bg1_tilemap->mark_tile_dirty(offset);
196
194
        else
197
 
                state->m_bg2_tilemap->mark_tile_dirty(offset - 0x800);
 
195
                m_bg2_tilemap->mark_tile_dirty(offset - 0x800);
198
196
}
199
197
 
200
 
WRITE8_HANDLER( tceptor_bg_scroll_w )
 
198
WRITE8_MEMBER(tceptor_state::tceptor_bg_scroll_w)
201
199
{
202
 
        tceptor_state *state = space->machine().driver_data<tceptor_state>();
203
200
        switch (offset)
204
201
        {
205
202
        case 0:
206
 
                state->m_bg1_scroll_x &= 0xff;
207
 
                state->m_bg1_scroll_x |= data << 8;
 
203
                m_bg1_scroll_x &= 0xff;
 
204
                m_bg1_scroll_x |= data << 8;
208
205
                break;
209
206
        case 1:
210
 
                state->m_bg1_scroll_x &= 0xff00;
211
 
                state->m_bg1_scroll_x |= data;
 
207
                m_bg1_scroll_x &= 0xff00;
 
208
                m_bg1_scroll_x |= data;
212
209
                break;
213
210
        case 2:
214
 
                state->m_bg1_scroll_y = data;
 
211
                m_bg1_scroll_y = data;
215
212
                break;
216
213
 
217
214
        case 4:
218
 
                state->m_bg2_scroll_x &= 0xff;
219
 
                state->m_bg2_scroll_x |= data << 8;
 
215
                m_bg2_scroll_x &= 0xff;
 
216
                m_bg2_scroll_x |= data << 8;
220
217
                break;
221
218
        case 5:
222
 
                state->m_bg2_scroll_x &= 0xff00;
223
 
                state->m_bg2_scroll_x |= data;
 
219
                m_bg2_scroll_x &= 0xff00;
 
220
                m_bg2_scroll_x |= data;
224
221
                break;
225
222
        case 6:
226
 
                state->m_bg2_scroll_y = data;
 
223
                m_bg2_scroll_y = data;
227
224
                break;
228
225
        }
229
226
}
246
243
        };
247
244
 
248
245
        int gfx_index = state->m_bg;
249
 
        UINT8 *src = machine.region(region)->base() + 0x8000;
 
246
        UINT8 *src = machine.root_device().memregion(region)->base() + 0x8000;
250
247
        UINT8 *buffer;
251
248
        int len = 0x8000;
252
249
        int i;
264
261
        auto_free(machine, buffer);
265
262
 
266
263
        /* decode the graphics */
267
 
        machine.gfx[gfx_index] = gfx_element_alloc(machine, &bg_layout, machine.region(region)->base(), 64, 2048);
 
264
        machine.gfx[gfx_index] = gfx_element_alloc(machine, &bg_layout, machine.root_device().memregion(region)->base(), 64, 2048);
268
265
}
269
266
 
270
267
static void decode_sprite(running_machine &machine, int gfx_index, const gfx_layout *layout, const void *data)
294
291
                2*16*16
295
292
        };
296
293
 
297
 
        UINT8 *src = machine.region(region)->base();
298
 
        int len = machine.region(region)->bytes();
 
294
        UINT8 *src = machine.root_device().memregion(region)->base();
 
295
        int len = machine.root_device().memregion(region)->bytes();
299
296
        UINT8 *dst;
300
297
        int i, y;
301
298
 
346
343
                2*32*32
347
344
        };
348
345
 
349
 
        UINT8 *src = machine.region(region)->base();
350
 
        int len = machine.region(region)->bytes();
 
346
        UINT8 *src = machine.root_device().memregion(region)->base();
 
347
        int len = machine.root_device().memregion(region)->bytes();
351
348
        int total = spr32_layout.total;
352
349
        int size = spr32_layout.charincrement / 8;
353
350
        UINT8 *dst;