← Back to branch summary

~ubuntu-branches/ubuntu/raring/mame/raring-proposed

« back to all changes in this revision

Viewing changes to mess/src/mame/video/dynduke.c

  • Committer: Package Import Robot
  • Author(s): Jordi Mallach, Jordi Mallach, Emmanuel Kasper
  • Date: 2011-12-19 22:56:27 UTC
  • mfrom: (0.1.2)
  • Revision ID: package-import@ubuntu.com-20111219225627-ub5oga1oys4ogqzm
Tags: 0.144-1
http://bugs.debian.org/651538
[ Jordi Mallach ]
* Fix syntax errors in DEP5 copyright file (lintian).
* Use a versioned copyright Format specification field.
* Update Vcs-* URLs.
* Move transitional packages to the new metapackages section, and make
  them priority extra.
* Remove references to GNU/Linux and MESS sources from copyright.
* Add build variables for s390x.
* Use .xz tarballs as it cuts 4MB for the upstream sources.
* Add nplayers.ini as a patch. Update copyright file to add CC-BY-SA-3.0.

[ Emmanuel Kasper ]
* New upstream release. Closes: #651538.
* Add Free Desktop compliant png icons of various sizes taken from
  the hydroxygen iconset
* Mess is now built from a new source package, to avoid possible source
  incompatibilities between mame and the mess overlay.
* Mame-tools are not built from the mame source package anymore, but
  from the mess source package

Show diffs side-by-side

added added

removed removed

Lines of Context:
mess/src/mame/video/dynduke.c
1
 
#include "emu.h"
2
 
#include "includes/dynduke.h"
3
 
 
4
 
 
5
 
 
6
 
/******************************************************************************/
7
 
 
8
 
WRITE16_HANDLER( dynduke_paletteram_w )
9
 
{
10
 
        int color;
11
 
 
12
 
        COMBINE_DATA(&space->machine().generic.paletteram.u16[offset]);
13
 
        color=space->machine().generic.paletteram.u16[offset];
14
 
        palette_set_color_rgb(space->machine(),offset,pal4bit(color >> 0),pal4bit(color >> 4),pal4bit(color >> 8));
15
 
}
16
 
 
17
 
WRITE16_HANDLER( dynduke_background_w )
18
 
{
19
 
        dynduke_state *state = space->machine().driver_data<dynduke_state>();
20
 
        COMBINE_DATA(&state->m_back_data[offset]);
21
 
        tilemap_mark_tile_dirty(state->m_bg_layer,offset);
22
 
}
23
 
 
24
 
WRITE16_HANDLER( dynduke_foreground_w )
25
 
{
26
 
        dynduke_state *state = space->machine().driver_data<dynduke_state>();
27
 
        COMBINE_DATA(&state->m_fore_data[offset]);
28
 
        tilemap_mark_tile_dirty(state->m_fg_layer,offset);
29
 
}
30
 
 
31
 
WRITE16_HANDLER( dynduke_text_w )
32
 
{
33
 
        dynduke_state *state = space->machine().driver_data<dynduke_state>();
34
 
        UINT16 *videoram = state->m_videoram;
35
 
        COMBINE_DATA(&videoram[offset]);
36
 
        tilemap_mark_tile_dirty(state->m_tx_layer,offset);
37
 
}
38
 
 
39
 
static TILE_GET_INFO( get_bg_tile_info )
40
 
{
41
 
        dynduke_state *state = machine.driver_data<dynduke_state>();
42
 
        int tile=state->m_back_data[tile_index];
43
 
        int color=tile >> 12;
44
 
 
45
 
        tile=tile&0xfff;
46
 
 
47
 
        SET_TILE_INFO(
48
 
                        1,
49
 
                        tile+state->m_back_bankbase,
50
 
                        color,
51
 
                        0);
52
 
}
53
 
 
54
 
static TILE_GET_INFO( get_fg_tile_info )
55
 
{
56
 
        dynduke_state *state = machine.driver_data<dynduke_state>();
57
 
        int tile=state->m_fore_data[tile_index];
58
 
        int color=tile >> 12;
59
 
 
60
 
        tile=tile&0xfff;
61
 
 
62
 
        SET_TILE_INFO(
63
 
                        2,
64
 
                        tile+state->m_fore_bankbase,
65
 
                        color,
66
 
                        0);
67
 
}
68
 
 
69
 
static TILE_GET_INFO( get_tx_tile_info )
70
 
{
71
 
        dynduke_state *state = machine.driver_data<dynduke_state>();
72
 
        UINT16 *videoram = state->m_videoram;
73
 
        int tile=videoram[tile_index];
74
 
        int color=(tile >> 8) & 0x0f;
75
 
 
76
 
        tile = (tile & 0xff) | ((tile & 0xc000) >> 6);
77
 
 
78
 
        SET_TILE_INFO(
79
 
                        0,
80
 
                        tile,
81
 
                        color,
82
 
                        0);
83
 
}
84
 
 
85
 
VIDEO_START( dynduke )
86
 
{
87
 
        dynduke_state *state = machine.driver_data<dynduke_state>();
88
 
        state->m_bg_layer = tilemap_create(machine, get_bg_tile_info,tilemap_scan_cols,      16,16,32,32);
89
 
        state->m_fg_layer = tilemap_create(machine, get_fg_tile_info,tilemap_scan_cols,16,16,32,32);
90
 
        state->m_tx_layer = tilemap_create(machine, get_tx_tile_info,tilemap_scan_rows, 8, 8,32,32);
91
 
 
92
 
        tilemap_set_transparent_pen(state->m_fg_layer,15);
93
 
        tilemap_set_transparent_pen(state->m_tx_layer,15);
94
 
}
95
 
 
96
 
WRITE16_HANDLER( dynduke_gfxbank_w )
97
 
{
98
 
        dynduke_state *state = space->machine().driver_data<dynduke_state>();
99
 
 
100
 
        if (ACCESSING_BITS_0_7)
101
 
        {
102
 
                if (data&0x01) state->m_back_bankbase=0x1000; else state->m_back_bankbase=0;
103
 
                if (data&0x10) state->m_fore_bankbase=0x1000; else state->m_fore_bankbase=0;
104
 
 
105
 
                if (state->m_back_bankbase!=state->m_old_back)
106
 
                        tilemap_mark_all_tiles_dirty(state->m_bg_layer);
107
 
                if (state->m_fore_bankbase!=state->m_old_fore)
108
 
                        tilemap_mark_all_tiles_dirty(state->m_fg_layer);
109
 
 
110
 
                state->m_old_back=state->m_back_bankbase;
111
 
                state->m_old_fore=state->m_fore_bankbase;
112
 
        }
113
 
}
114
 
 
115
 
 
116
 
WRITE16_HANDLER( dynduke_control_w )
117
 
{
118
 
        dynduke_state *state = space->machine().driver_data<dynduke_state>();
119
 
 
120
 
        if (ACCESSING_BITS_0_7)
121
 
        {
122
 
                // bit 0x80 toggles, maybe sprite buffering?
123
 
                // bit 0x40 is flipscreen
124
 
                // bit 0x20 not used?
125
 
                // bit 0x10 not used?
126
 
                // bit 0x08 is set on the title screen (sprite disable?)
127
 
                // bit 0x04 unused? txt disable?
128
 
                // bit 0x02 is used on the map screen (fore disable?)
129
 
                // bit 0x01 set when inserting coin.. bg disable?
130
 
 
131
 
                if (data&0x1) state->m_back_enable = 0; else state->m_back_enable = 1;
132
 
                if (data&0x2) state->m_fore_enable=0; else state->m_fore_enable=1;
133
 
                if (data&0x4) state->m_txt_enable = 0; else state->m_txt_enable = 1;
134
 
                if (data&0x8) state->m_sprite_enable=0; else state->m_sprite_enable=1;
135
 
 
136
 
                flip_screen_set(space->machine(), data & 0x40);
137
 
        }
138
 
}
139
 
 
140
 
static void draw_sprites(running_machine &machine, bitmap_t *bitmap,const rectangle *cliprect,int pri)
141
 
{
142
 
        dynduke_state *state = machine.driver_data<dynduke_state>();
143
 
        UINT16 *buffered_spriteram16 = machine.generic.buffered_spriteram.u16;
144
 
        int offs,fx,fy,x,y,color,sprite;
145
 
 
146
 
        if (!state->m_sprite_enable) return;
147
 
 
148
 
        for (offs = 0x800-4;offs >= 0;offs -= 4)
149
 
        {
150
 
                /* Don't draw empty sprite table entries */
151
 
                if ((buffered_spriteram16[offs+3] >> 8)!=0xf) continue;
152
 
                if (((buffered_spriteram16[offs+2]>>13)&3)!=pri) continue;
153
 
 
154
 
                fx= buffered_spriteram16[offs+0]&0x2000;
155
 
                fy= buffered_spriteram16[offs+0]&0x4000;
156
 
                y = buffered_spriteram16[offs+0] & 0xff;
157
 
                x = buffered_spriteram16[offs+2] & 0xff;
158
 
 
159
 
                if (buffered_spriteram16[offs+2]&0x100) x=0-(0x100-x);
160
 
 
161
 
                color = (buffered_spriteram16[offs+0]>>8)&0x1f;
162
 
                sprite = buffered_spriteram16[offs+1];
163
 
                sprite &= 0x3fff;
164
 
 
165
 
                if (flip_screen_get(machine)) {
166
 
                        x=240-x;
167
 
                        y=240-y;
168
 
                        if (fx) fx=0; else fx=1;
169
 
                        if (fy) fy=0; else fy=1;
170
 
                }
171
 
 
172
 
                drawgfx_transpen(bitmap,cliprect,machine.gfx[3],
173
 
                                sprite,
174
 
                                color,fx,fy,x,y,15);
175
 
        }
176
 
}
177
 
 
178
 
static void draw_background(running_machine &machine, bitmap_t *bitmap, const rectangle *cliprect, int pri )
179
 
{
180
 
        dynduke_state *state = machine.driver_data<dynduke_state>();
181
 
        /* The transparency / palette handling on the background layer is very strange */
182
 
        bitmap_t *bm = tilemap_get_pixmap(state->m_bg_layer);
183
 
        int scrolly, scrollx;
184
 
        int x,y;
185
 
 
186
 
        /* if we're disabled, don't draw */
187
 
        if (!state->m_back_enable)
188
 
        {
189
 
                bitmap_fill(bitmap,cliprect,get_black_pen(machine));
190
 
                return;
191
 
        }
192
 
 
193
 
        scrolly = ((state->m_scroll_ram[0x01]&0x30)<<4)+((state->m_scroll_ram[0x02]&0x7f)<<1)+((state->m_scroll_ram[0x02]&0x80)>>7);
194
 
        scrollx = ((state->m_scroll_ram[0x09]&0x30)<<4)+((state->m_scroll_ram[0x0a]&0x7f)<<1)+((state->m_scroll_ram[0x0a]&0x80)>>7);
195
 
 
196
 
        for (y=0;y<256;y++)
197
 
        {
198
 
                int realy = (y + scrolly) & 0x1ff;
199
 
                UINT16 *src = BITMAP_ADDR16(bm,     realy, 0);
200
 
                UINT16 *dst = BITMAP_ADDR16(bitmap, y,     0);
201
 
 
202
 
 
203
 
                for (x=0;x<256;x++)
204
 
                {
205
 
                        int realx = (x + scrollx) & 0x1ff;
206
 
                        UINT16 srcdat = src[realx];
207
 
 
208
 
                        /* 0x01 - data bits
209
 
               0x02
210
 
               0x04
211
 
               0x08
212
 
               0x10 - extra colour bit? (first boss)
213
 
               0x20 - priority over sprites
214
 
               the old driver also had 'bg_palbase' but I don't see what it's for?
215
 
            */
216
 
 
217
 
                        if ((srcdat & 0x20) == pri)
218
 
                        {
219
 
                                if (srcdat & 0x10) srcdat += 0x400;
220
 
                                //if (srcdat & 0x10) srcdat += machine.rand()&0x1f;
221
 
 
222
 
                                srcdat = (srcdat & 0x000f) | ((srcdat & 0xffc0) >> 2);
223
 
                                dst[x] = srcdat;
224
 
                        }
225
 
 
226
 
 
227
 
                }
228
 
        }
229
 
}
230
 
 
231
 
SCREEN_UPDATE( dynduke )
232
 
{
233
 
        dynduke_state *state = screen->machine().driver_data<dynduke_state>();
234
 
        /* Setup the tilemaps */
235
 
        tilemap_set_scrolly( state->m_fg_layer,0, ((state->m_scroll_ram[0x11]&0x30)<<4)+((state->m_scroll_ram[0x12]&0x7f)<<1)+((state->m_scroll_ram[0x12]&0x80)>>7) );
236
 
        tilemap_set_scrollx( state->m_fg_layer,0, ((state->m_scroll_ram[0x19]&0x30)<<4)+((state->m_scroll_ram[0x1a]&0x7f)<<1)+((state->m_scroll_ram[0x1a]&0x80)>>7) );
237
 
        tilemap_set_enable( state->m_fg_layer,state->m_fore_enable);
238
 
        tilemap_set_enable( state->m_tx_layer,state->m_txt_enable);
239
 
 
240
 
 
241
 
        draw_background(screen->machine(), bitmap, cliprect,0x00);
242
 
        draw_sprites(screen->machine(),bitmap,cliprect,0); // Untested: does anything use it? Could be behind background
243
 
        draw_sprites(screen->machine(),bitmap,cliprect,1);
244
 
        draw_background(screen->machine(), bitmap, cliprect,0x20);
245
 
 
246
 
        draw_sprites(screen->machine(),bitmap,cliprect,2);
247
 
        tilemap_draw(bitmap,cliprect,state->m_fg_layer,0,0);
248
 
        draw_sprites(screen->machine(),bitmap,cliprect,3);
249
 
        tilemap_draw(bitmap,cliprect,state->m_tx_layer,0,0);
250
 
 
251
 
        return 0;
252
 
}
253
 
 
254
 
SCREEN_EOF( dynduke )
255
 
{
256
 
        address_space *space = machine.device("maincpu")->memory().space(AS_PROGRAM);
257
 
 
258
 
        buffer_spriteram16_w(space, 0, 0, 0xffff); // Could be a memory location instead
259
 
}