summaryrefslogtreecommitdiffstats
path: root/src/mame/drivers/halleys.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'src/mame/drivers/halleys.cpp')
-rw-r--r--src/mame/drivers/halleys.cpp204
1 files changed, 102 insertions, 102 deletions
diff --git a/src/mame/drivers/halleys.cpp b/src/mame/drivers/halleys.cpp
index 77ed4220bc6..f94c9616cbd 100644
--- a/src/mame/drivers/halleys.cpp
+++ b/src/mame/drivers/halleys.cpp
@@ -220,21 +220,21 @@ public:
m_palette(*this, "palette"),
m_soundlatch(*this, "soundlatch") { }
- UINT16 *m_render_layer[MAX_LAYERS];
- UINT8 m_sound_fifo[MAX_SOUNDS];
- UINT8 *m_gfx_plane02;
- UINT8 *m_gfx_plane13;
- std::unique_ptr<UINT8[]> m_collision_list;
- UINT8 *m_scrolly0;
- UINT8 *m_scrollx0;
- UINT8 *m_scrolly1;
- UINT8 *m_scrollx1;
- std::unique_ptr<UINT32[]> m_internal_palette;
- std::unique_ptr<UINT32[]> m_alpha_table;
- UINT8 *m_cpu1_base;
- std::unique_ptr<UINT8[]> m_gfx1_base;
- required_shared_ptr<UINT8> m_blitter_ram;
- required_shared_ptr<UINT8> m_io_ram;
+ uint16_t *m_render_layer[MAX_LAYERS];
+ uint8_t m_sound_fifo[MAX_SOUNDS];
+ uint8_t *m_gfx_plane02;
+ uint8_t *m_gfx_plane13;
+ std::unique_ptr<uint8_t[]> m_collision_list;
+ uint8_t *m_scrolly0;
+ uint8_t *m_scrollx0;
+ uint8_t *m_scrolly1;
+ uint8_t *m_scrollx1;
+ std::unique_ptr<uint32_t[]> m_internal_palette;
+ std::unique_ptr<uint32_t[]> m_alpha_table;
+ uint8_t *m_cpu1_base;
+ std::unique_ptr<uint8_t[]> m_gfx1_base;
+ required_shared_ptr<uint8_t> m_blitter_ram;
+ required_shared_ptr<uint8_t> m_io_ram;
int m_game_id;
int m_blitter_busy;
int m_collision_count;
@@ -249,7 +249,7 @@ public:
emu_timer *m_blitter_reset_timer;
offs_t m_collision_detection;
int m_latch_delay;
- std::vector<UINT8> m_paletteram;
+ std::vector<uint8_t> m_paletteram;
DECLARE_WRITE8_MEMBER(bgtile_w);
DECLARE_READ8_MEMBER(blitter_status_r);
@@ -271,16 +271,16 @@ public:
virtual void machine_reset() override;
virtual void video_start() override;
DECLARE_PALETTE_INIT(halleys);
- UINT32 screen_update_halleys(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
- UINT32 screen_update_benberob(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
+ uint32_t screen_update_halleys(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
+ uint32_t screen_update_benberob(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
TIMER_CALLBACK_MEMBER(blitter_reset);
TIMER_DEVICE_CALLBACK_MEMBER(halleys_scanline);
TIMER_DEVICE_CALLBACK_MEMBER(benberob_scanline);
- void halleys_decode_rgb(UINT32 *r, UINT32 *g, UINT32 *b, int addr, int data);
- void copy_scroll_op(bitmap_ind16 &bitmap, UINT16 *source, int sx, int sy);
- void copy_scroll_xp(bitmap_ind16 &bitmap, UINT16 *source, int sx, int sy);
- void copy_fixed_xp(bitmap_ind16 &bitmap, UINT16 *source);
- void copy_fixed_2b(bitmap_ind16 &bitmap, UINT16 *source);
+ void halleys_decode_rgb(uint32_t *r, uint32_t *g, uint32_t *b, int addr, int data);
+ void copy_scroll_op(bitmap_ind16 &bitmap, uint16_t *source, int sx, int sy);
+ void copy_scroll_xp(bitmap_ind16 &bitmap, uint16_t *source, int sx, int sy);
+ void copy_fixed_xp(bitmap_ind16 &bitmap, uint16_t *source);
+ void copy_fixed_2b(bitmap_ind16 &bitmap, uint16_t *source);
void filter_bitmap(bitmap_ind16 &bitmap, int mask);
void init_common();
required_device<cpu_device> m_maincpu;
@@ -361,21 +361,21 @@ void halleys_state::blit(int offset)
#define XMASK (SCREEN_WIDTH-1)
#define YMASK (SCREEN_HEIGHT-1)
- static const UINT8 penxlat[16]={0x03,0x07,0x0b,0x0f,0x02,0x06,0x0a,0x0e,0x01,0x05,0x09,0x0d,0x00,0x04,0x08,0x0c};
- static const UINT8 rgbmask[16]={0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xfc,0xff,0xff,0xff,0xff,0xff};
- static const UINT8 tyremap[ 8]={ 0, 5, 9,13,16,20,24,28};
+ static const uint8_t penxlat[16]={0x03,0x07,0x0b,0x0f,0x02,0x06,0x0a,0x0e,0x01,0x05,0x09,0x0d,0x00,0x04,0x08,0x0c};
+ static const uint8_t rgbmask[16]={0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xfc,0xff,0xff,0xff,0xff,0xff};
+ static const uint8_t tyremap[ 8]={ 0, 5, 9,13,16,20,24,28};
- UINT8 *param, *src_base;
- UINT16 *dst_base;
+ uint8_t *param, *src_base;
+ uint16_t *dst_base;
int stptr, mode, color, code, y, x, h, w, src1, src2;
int status, flags, group, command, bank, layer, pen0, pen1;
int yclip, xclip, src_yskip, src_xskip, dst_skip, hclip, wclip, src_dy, src_dx;
- UINT32 *pal_ptr;
- UINT8 *src1_ptr, *src2_ptr; // esi alias, ebx alias
- UINT16 *dst_ptr; // edi alias
+ uint32_t *pal_ptr;
+ uint8_t *src1_ptr, *src2_ptr; // esi alias, ebx alias
+ uint16_t *dst_ptr; // edi alias
void *edi; // scratch
int eax, ebx, ecx, edx; // scratch
- UINT16 ax; UINT8 al, ah; // partial regs
+ uint16_t ax; uint8_t al, ah; // partial regs
param = m_blitter_ram + offset;
@@ -493,7 +493,7 @@ if (0) {
if (src1 == src2)
{
flags |= SINGLE_PEN;
- eax = (UINT32)penxlat[color & PENCOLOR];
+ eax = (uint32_t)penxlat[color & PENCOLOR];
if (eax) pen1 = pen0 + eax;
}
else if (color & PENCOLOR) flags |= RGB_MASK;
@@ -505,7 +505,7 @@ if (0) {
eax = wclip<<1; \
ecx = hclip; \
edi = dst_ptr; \
- do { memset((UINT8*)edi, 0, eax); edi = (UINT8*)edi + SCREEN_BYTEWIDTH; } while (--ecx); \
+ do { memset((uint8_t*)edi, 0, eax); edi = (uint8_t*)edi + SCREEN_BYTEWIDTH; } while (--ecx); \
}
//--------------------------------------------------------------------------
@@ -521,7 +521,7 @@ if (0) {
if (!(flags & PPCD_ON))
{
- al = ah = (UINT8)pen0;
+ al = ah = (uint8_t)pen0;
if (!(flags & BACKMODE))
{
@@ -531,7 +531,7 @@ if (0) {
src1_ptr += edx;
al |= *src2_ptr;
src2_ptr += edx;
- if (al & 0xf) { dst_ptr[ecx] = (UINT16)al; al = ah;}
+ if (al & 0xf) { dst_ptr[ecx] = (uint16_t)al; al = ah;}
}
while (++ecx);
ecx = wclip; src1_ptr += src_dy; src2_ptr += src_dy; dst_ptr += SCREEN_WIDTH;
@@ -546,7 +546,7 @@ if (0) {
src1_ptr += edx;
al |= *src2_ptr;
src2_ptr += edx;
- if (al & 0xf) { dst_ptr[ecx] = (UINT16)al | SP_2BACK; al = ah; }
+ if (al & 0xf) { dst_ptr[ecx] = (uint16_t)al | SP_2BACK; al = ah; }
}
while (++ecx);
ecx = wclip; src1_ptr += src_dy; src2_ptr += src_dy; dst_ptr += SCREEN_WIDTH;
@@ -564,7 +564,7 @@ if (0) {
src1_ptr += edx;
al |= *src2_ptr;
src2_ptr += edx;
- if (al & 0xf) { dst_ptr[ecx] = (UINT16)al | SP_COLLD; } // set collision flag on group one pixels
+ if (al & 0xf) { dst_ptr[ecx] = (uint16_t)al | SP_COLLD; } // set collision flag on group one pixels
}
while (++ecx);
ecx = wclip; src1_ptr += src_dy; src2_ptr += src_dy; dst_ptr += SCREEN_WIDTH;
@@ -579,7 +579,7 @@ if (0) {
src1_ptr += edx;
al |= *src2_ptr;
src2_ptr += edx;
- if (al & 0xf) { ax |= dst_ptr[ecx]; dst_ptr[ecx] = (UINT16)al; } // combine collision flags in ax
+ if (al & 0xf) { ax |= dst_ptr[ecx]; dst_ptr[ecx] = (uint16_t)al; } // combine collision flags in ax
}
while (++ecx);
ecx = wclip; src1_ptr += src_dy; src2_ptr += src_dy; dst_ptr += SCREEN_WIDTH;
@@ -607,7 +607,7 @@ if (0) {
if (!(flags & IGNORE_0)) BLOCK_WIPE_COMMON
dst_ptr += wclip;
ecx = wclip = -wclip;
- al = ah = (UINT8)pen0;
+ al = ah = (uint8_t)pen0;
ebx = rgbmask[color & PENCOLOR] | 0xffffff00;
do {
@@ -616,7 +616,7 @@ if (0) {
src1_ptr += src_dx;
al |= *src2_ptr;
src2_ptr += src_dx;
- if (al & 0xf) { edx = (UINT32)al; al = ah; dst_ptr[ecx] = pal_ptr[edx] & ebx; }
+ if (al & 0xf) { edx = (uint32_t)al; al = ah; dst_ptr[ecx] = pal_ptr[edx] & ebx; }
}
while (++ecx);
ecx = wclip; src1_ptr += src_dy; src2_ptr += src_dy; dst_ptr += SCREEN_WIDTH;
@@ -634,7 +634,7 @@ if (0) {
ebx = hclip;
ecx = wclip = -wclip;
edx = src_dx;
- ax = (UINT16)pen1;
+ ax = (uint16_t)pen1;
do {
do {
@@ -802,12 +802,12 @@ if (0) {
for (yclip=y+h; y<yclip; y+=16)
for (xclip=x+w; x<xclip; x+=16)
{
- edx = (UINT32)*src2_ptr;
+ edx = (uint32_t)*src2_ptr;
src2_ptr++;
if (edx)
{
- ax = (UINT16)*(src2_ptr-0x100 -1);
- ebx = (UINT32)ax;
+ ax = (uint16_t)*(src2_ptr-0x100 -1);
+ ebx = (uint32_t)ax;
ax |= BG_MONO;
if (edx & 0x01) { dst_base[C2S(x,y,ebx)] = ax; }
if (edx & 0x02) { ecx = RORB(ebx,1); dst_base[C2S(x,y,ecx)] = ax; }
@@ -835,7 +835,7 @@ if (0) {
edx = SCREEN_WIDTH - x - w;
w = -w;
- ax = (UINT16)(~src_base[src2] & 0xff);
+ ax = (uint16_t)(~src_base[src2] & 0xff);
for (yclip=y+h; y<yclip; y++)
{
@@ -844,12 +844,12 @@ if (0) {
if (edx < 0)
{
ecx = edx;
- dst_ptr = (UINT16*)edi - edx;
+ dst_ptr = (uint16_t*)edi - edx;
do { if (dst_ptr[ecx]) dst_ptr[ecx] ^= ax; } while (++ecx);
ecx = x - SCREEN_WIDTH;
} else ecx = w;
- dst_ptr = (UINT16*)edi + x - ecx;
+ dst_ptr = (uint16_t*)edi + x - ecx;
do { if (dst_ptr[ecx]) dst_ptr[ecx] ^= ax; } while (++ecx);
}
@@ -896,7 +896,7 @@ if (0) {
{
dst_ptr += x;
do {
- ax = (UINT16)src1_ptr[edx];
+ ax = (uint16_t)src1_ptr[edx];
al = src1_ptr[edx+0x10000];
ax |= BG_RGB;
if (al & 0x01) *dst_ptr = ax;
@@ -915,7 +915,7 @@ if (0) {
#define WARPMASK ((SCREEN_WIDTH<<1)-1)
do {
ecx = x & WARPMASK;
- ax = (UINT16)src1_ptr[edx];
+ ax = (uint16_t)src1_ptr[edx];
al = src1_ptr[edx+0x10000];
ax |= BG_RGB;
if (al & 0x01) dst_ptr[ecx] = ax;
@@ -946,9 +946,9 @@ if (0) {
if (command == HORIZBAR && flags & COLOR_ON && !(layer & 1))
{
#define WARP_LINE_COMMON { \
- if (ecx & 1) { ecx--; *dst_ptr = (UINT16)eax; dst_ptr++; } \
+ if (ecx & 1) { ecx--; *dst_ptr = (uint16_t)eax; dst_ptr++; } \
dst_ptr += ecx; ecx = -ecx; \
- while (ecx) { *(UINT32*)(dst_ptr+ecx) = eax; ecx += 2; } \
+ while (ecx) { *(uint32_t*)(dst_ptr+ecx) = eax; ecx += 2; } \
}
src1_ptr = src_base + src1;
@@ -976,7 +976,7 @@ if (0) {
for (yclip=y; yclip<hclip; yclip++)
{
- eax = (UINT32)*src1_ptr;
+ eax = (uint32_t)*src1_ptr;
src1_ptr += src_dx;
if (!eax) continue;
eax = eax | (eax<<16) | ((BG_RGB<<16)|BG_RGB);
@@ -985,16 +985,16 @@ if (0) {
if (edx > 0)
{
ecx = edx;
- dst_ptr = (UINT16*)edi;
+ dst_ptr = (uint16_t*)edi;
WARP_LINE_COMMON
ecx = SCREEN_WIDTH - xclip;
} else ecx = w;
- dst_ptr = (UINT16*)edi + xclip;
+ dst_ptr = (uint16_t*)edi + xclip;
WARP_LINE_COMMON
}
- edi = src1_ptr; src1_ptr = src2_ptr; src2_ptr = (UINT8*)edi;
+ edi = src1_ptr; src1_ptr = src2_ptr; src2_ptr = (uint8_t*)edi;
}
#undef WARP_LINE_COMMON
@@ -1010,8 +1010,8 @@ if (0) {
WRITE8_MEMBER(halleys_state::bgtile_w)
{
int yskip, xskip, ecx;
- UINT16 *edi;
- UINT16 ax;
+ uint16_t *edi;
+ uint16_t ax;
m_cpu1_base[0x1f00+offset] = data;
offset -= 0x18;
@@ -1026,7 +1026,7 @@ WRITE8_MEMBER(halleys_state::bgtile_w)
edi = m_render_layer[2] + (yskip<<SCREEN_WIDTH_L2) + xskip + (48<<SCREEN_WIDTH_L2);
ecx = -(48<<SCREEN_WIDTH_L2);
- ax = (UINT16)data | BG_RGB;
+ ax = (uint16_t)data | BG_RGB;
do { edi[ecx] = edi[ecx+1] = edi[ecx+2] = edi[ecx+3] = edi[ecx+4] = ax; } while (ecx += SCREEN_WIDTH);
}
@@ -1120,10 +1120,10 @@ READ8_MEMBER(halleys_state::collision_id_r)
PALETTE_INIT_MEMBER(halleys_state, halleys)
{
- UINT32 d, r, g, b, i, j, count;
+ uint32_t d, r, g, b, i, j, count;
// allocate memory for internal palette
- m_internal_palette = std::make_unique<UINT32[]>(PALETTE_SIZE);
- UINT32 *pal_ptr = m_internal_palette.get();
+ m_internal_palette = std::make_unique<uint32_t[]>(PALETTE_SIZE);
+ uint32_t *pal_ptr = m_internal_palette.get();
for (count=0; count<1024; count++)
{
@@ -1168,7 +1168,7 @@ PALETTE_INIT_MEMBER(halleys_state, halleys)
}
}
-void halleys_state::halleys_decode_rgb(UINT32 *r, UINT32 *g, UINT32 *b, int addr, int data)
+void halleys_state::halleys_decode_rgb(uint32_t *r, uint32_t *g, uint32_t *b, int addr, int data)
{
/*
proms contain:
@@ -1176,8 +1176,8 @@ void halleys_state::halleys_decode_rgb(UINT32 *r, UINT32 *g, UINT32 *b, int addr
00 00 00 00 01 61 29 26 0b f5 e2 17 57 fb cf f7
*/
int latch1_273, latch2_273;
- UINT8 *sram_189;
- UINT8 *prom_6330;
+ uint8_t *sram_189;
+ uint8_t *prom_6330;
int bit0, bit1, bit2, bit3, bit4;
@@ -1220,11 +1220,11 @@ READ8_MEMBER(halleys_state::paletteram_r)
WRITE8_MEMBER(halleys_state::paletteram_w)
{
- UINT32 d, r, g, b, i, j;
- UINT32 *pal_ptr = m_internal_palette.get();
+ uint32_t d, r, g, b, i, j;
+ uint32_t *pal_ptr = m_internal_palette.get();
m_paletteram[offset] = data;
- d = (UINT32)data;
+ d = (uint32_t)data;
j = d | BG_RGB;
pal_ptr[offset] = j;
pal_ptr[offset+SP_2BACK] = j;
@@ -1281,7 +1281,7 @@ void halleys_state::video_start()
}
-void halleys_state::copy_scroll_op(bitmap_ind16 &bitmap, UINT16 *source, int sx, int sy)
+void halleys_state::copy_scroll_op(bitmap_ind16 &bitmap, uint16_t *source, int sx, int sy)
{
sx = -sx & 0xff;
sy = -sy & 0xff;
@@ -1294,11 +1294,11 @@ void halleys_state::copy_scroll_op(bitmap_ind16 &bitmap, UINT16 *source, int sx,
if (bch < 0)
bch = 0;
- const UINT16 *src = source + CLIP_SKIP + sy * SCREEN_WIDTH;
+ const uint16_t *src = source + CLIP_SKIP + sy * SCREEN_WIDTH;
// draw top split
for (int y=0; y != bch; y++) {
- UINT16 *dest = &bitmap.pix16(VIS_MINY + y, VIS_MINX);
+ uint16_t *dest = &bitmap.pix16(VIS_MINY + y, VIS_MINX);
memcpy(dest, src+sx, 2*rcw);
memcpy(dest + rcw, src, 2*(CLIP_W - rcw));
src += SCREEN_WIDTH;
@@ -1308,7 +1308,7 @@ void halleys_state::copy_scroll_op(bitmap_ind16 &bitmap, UINT16 *source, int sx,
// draw bottom split
for (int y = bch; y != CLIP_H; y++) {
- UINT16 *dest = &bitmap.pix16(VIS_MINY + y, VIS_MINX);
+ uint16_t *dest = &bitmap.pix16(VIS_MINY + y, VIS_MINX);
memcpy(dest, src+sx, 2*rcw);
memcpy(dest + rcw, src, 2*(CLIP_W - rcw));
src += SCREEN_WIDTH;
@@ -1316,7 +1316,7 @@ void halleys_state::copy_scroll_op(bitmap_ind16 &bitmap, UINT16 *source, int sx,
}
-void halleys_state::copy_scroll_xp(bitmap_ind16 &bitmap, UINT16 *source, int sx, int sy)
+void halleys_state::copy_scroll_xp(bitmap_ind16 &bitmap, uint16_t *source, int sx, int sy)
{
sx = -sx & 0xff;
sy = -sy & 0xff;
@@ -1329,14 +1329,14 @@ void halleys_state::copy_scroll_xp(bitmap_ind16 &bitmap, UINT16 *source, int sx,
if (bch < 0)
bch = 0;
- const UINT16 *src_base = source + CLIP_SKIP + sy * SCREEN_WIDTH;
+ const uint16_t *src_base = source + CLIP_SKIP + sy * SCREEN_WIDTH;
// draw top split
for (int y=0; y != bch; y++) {
- UINT16 *dest = &bitmap.pix16(VIS_MINY + y, VIS_MINX);
- const UINT16 *src = src_base + sx;
+ uint16_t *dest = &bitmap.pix16(VIS_MINY + y, VIS_MINX);
+ const uint16_t *src = src_base + sx;
for(int x=0; x != rcw; x++) {
- UINT16 pixel = *src++;
+ uint16_t pixel = *src++;
if(pixel)
*dest = pixel;
dest++;
@@ -1345,7 +1345,7 @@ void halleys_state::copy_scroll_xp(bitmap_ind16 &bitmap, UINT16 *source, int sx,
src = src_base;
for(int x=rcw; x != CLIP_W; x++) {
- UINT16 pixel = *src++;
+ uint16_t pixel = *src++;
if(pixel)
*dest = pixel;
dest++;
@@ -1358,10 +1358,10 @@ void halleys_state::copy_scroll_xp(bitmap_ind16 &bitmap, UINT16 *source, int sx,
// draw bottom split
for (int y = bch; y != CLIP_H; y++) {
- UINT16 *dest = &bitmap.pix16(VIS_MINY + y, VIS_MINX);
- const UINT16 *src = src_base + sx;
+ uint16_t *dest = &bitmap.pix16(VIS_MINY + y, VIS_MINX);
+ const uint16_t *src = src_base + sx;
for(int x=0; x != rcw; x++) {
- UINT16 pixel = *src++;
+ uint16_t pixel = *src++;
if(pixel)
*dest = pixel;
dest++;
@@ -1370,7 +1370,7 @@ void halleys_state::copy_scroll_xp(bitmap_ind16 &bitmap, UINT16 *source, int sx,
src = src_base;
for(int x=rcw; x != CLIP_W; x++) {
- UINT16 pixel = *src++;
+ uint16_t pixel = *src++;
if(pixel)
*dest = pixel;
dest++;
@@ -1382,13 +1382,13 @@ void halleys_state::copy_scroll_xp(bitmap_ind16 &bitmap, UINT16 *source, int sx,
-void halleys_state::copy_fixed_xp(bitmap_ind16 &bitmap, UINT16 *source)
+void halleys_state::copy_fixed_xp(bitmap_ind16 &bitmap, uint16_t *source)
{
- UINT16 *src = source + CLIP_SKIP;
+ uint16_t *src = source + CLIP_SKIP;
for(int y=0; y != CLIP_H; y++) {
- UINT16 *dest = &bitmap.pix16(VIS_MINY + y, VIS_MINX);
+ uint16_t *dest = &bitmap.pix16(VIS_MINY + y, VIS_MINX);
for(int x=0; x != CLIP_W; x++) {
- UINT16 pixel = src[x];
+ uint16_t pixel = src[x];
if (pixel)
dest[x] = pixel;
@@ -1398,13 +1398,13 @@ void halleys_state::copy_fixed_xp(bitmap_ind16 &bitmap, UINT16 *source)
}
}
-void halleys_state::copy_fixed_2b(bitmap_ind16 &bitmap, UINT16 *source)
+void halleys_state::copy_fixed_2b(bitmap_ind16 &bitmap, uint16_t *source)
{
- UINT16 *src = source + CLIP_SKIP;
+ uint16_t *src = source + CLIP_SKIP;
for(int y=0; y != CLIP_H; y++) {
- UINT16 *dest = &bitmap.pix16(VIS_MINY + y, VIS_MINX);
+ uint16_t *dest = &bitmap.pix16(VIS_MINY + y, VIS_MINX);
for(int x=0; x != CLIP_W; x++) {
- UINT16 pixel = src[x];
+ uint16_t pixel = src[x];
if ((pixel && !(pixel & SP_2BACK)) || !dest[x])
dest[x] = pixel;
@@ -1419,12 +1419,12 @@ void halleys_state::filter_bitmap(bitmap_ind16 &bitmap, int mask)
return;
int dst_pitch;
- UINT32 *pal_ptr, *edi;
+ uint32_t *pal_ptr, *edi;
int esi, eax, ebx, ecx, edx;
pal_ptr = m_internal_palette.get();
esi = mask | 0xffffff00;
- edi = (UINT32*)&bitmap.pix16(VIS_MINY, VIS_MINX + CLIP_W);
+ edi = (uint32_t*)&bitmap.pix16(VIS_MINY, VIS_MINX + CLIP_W);
dst_pitch = bitmap.rowpixels() >> 1;
ecx = -(CLIP_W>>1);
edx = CLIP_H;
@@ -1455,7 +1455,7 @@ void halleys_state::filter_bitmap(bitmap_ind16 &bitmap, int mask)
}
-UINT32 halleys_state::screen_update_halleys(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect)
+uint32_t halleys_state::screen_update_halleys(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect)
{
int i, j;
@@ -1483,7 +1483,7 @@ UINT32 halleys_state::screen_update_halleys(screen_device &screen, bitmap_ind16
}
-UINT32 halleys_state::screen_update_benberob(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect)
+uint32_t halleys_state::screen_update_benberob(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect)
{
if (m_io_ram[0xa0] & 0x80)
copy_scroll_op(bitmap, m_render_layer[2], *m_scrollx1, *m_scrolly1);
@@ -2115,32 +2115,32 @@ ROM_END
void halleys_state::init_common()
{
- UINT8 *buf, *rom;
+ uint8_t *buf, *rom;
int addr, i;
- UINT8 al, ah, dl, dh;
+ uint8_t al, ah, dl, dh;
// allocate memory for unpacked graphics
- buf = auto_alloc_array(machine(), UINT8, 0x100000);
+ buf = auto_alloc_array(machine(), uint8_t, 0x100000);
m_gfx_plane02 = buf;
m_gfx_plane13 = buf + 0x80000;
// allocate memory for render layers
- buf = auto_alloc_array(machine(), UINT8, SCREEN_BYTESIZE * MAX_LAYERS);
- for (i=0; i<MAX_LAYERS; buf+=SCREEN_BYTESIZE, i++) m_render_layer[i] = (UINT16*)buf;
+ buf = auto_alloc_array(machine(), uint8_t, SCREEN_BYTESIZE * MAX_LAYERS);
+ for (i=0; i<MAX_LAYERS; buf+=SCREEN_BYTESIZE, i++) m_render_layer[i] = (uint16_t*)buf;
// allocate memory for pre-processed ROMs
- m_gfx1_base = std::make_unique<UINT8[]>(0x20000);
+ m_gfx1_base = std::make_unique<uint8_t[]>(0x20000);
// allocate memory for alpha table
- m_alpha_table = std::make_unique<UINT32[]>(0x10000);
+ m_alpha_table = std::make_unique<uint32_t[]>(0x10000);
// allocate memory for hardware collision list
- m_collision_list = std::make_unique<UINT8[]>(MAX_SPRITES);
+ m_collision_list = std::make_unique<uint8_t[]>(MAX_SPRITES);
// decrypt main program ROM