trunk/src/mame/drivers/raiden2.c
| r31923 | r31924 | |
| 168 | 168 | return m_maincpu->state_int(NEC_IP); |
| 169 | 169 | } |
| 170 | 170 | |
| 171 | int cnt=0, ccol = 0x6f; |
| 172 | |
| 171 | 173 | WRITE16_MEMBER(raiden2_state::cop_pgm_data_w) |
| 172 | 174 | { |
| 173 | 175 | assert(ACCESSING_BITS_0_7 && ACCESSING_BITS_8_15); |
| r31923 | r31924 | |
| 799 | 801 | |
| 800 | 802 | /* SPRITE DRAWING (move to video file) */ |
| 801 | 803 | |
| 802 | | void raiden2_state::draw_sprites(bitmap_ind16 &bitmap, bitmap_ind8 &priority, const rectangle &cliprect) |
| 804 | void raiden2_state::draw_sprites(const rectangle &cliprect) |
| 803 | 805 | { |
| 804 | | UINT16 *source = sprites; |
| 806 | UINT16 *source = sprites + sprites_cur_start/2; |
| 807 | sprite_buffer.fill(0xf, cliprect); |
| 805 | 808 | |
| 806 | 809 | gfx_element *gfx = m_gfxdecode->gfx(2); |
| 807 | 810 | |
| r31923 | r31924 | |
| 812 | 815 | 06 yyyy yyyy yyyy yyyy y = ypos |
| 813 | 816 | */ |
| 814 | 817 | |
| 815 | | while( source<sprites + sprites_cur_start/2 ){ |
| 818 | while( source > sprites ){ |
| 816 | 819 | int tile_number = source[1]; |
| 817 | 820 | int sx = source[2]; |
| 818 | 821 | int sy = source[3]; |
| r31923 | r31924 | |
| 821 | 824 | int ytlim, xtlim; |
| 822 | 825 | int xflip, yflip; |
| 823 | 826 | int xstep, ystep; |
| 824 | | int pri, pri_mask; |
| 827 | int pri; |
| 825 | 828 | |
| 826 | 829 | ytlim = (source[0] >> 12) & 0x7; |
| 827 | 830 | xtlim = (source[0] >> 8 ) & 0x7; |
| r31923 | r31924 | |
| 831 | 834 | |
| 832 | 835 | colr = source[0] & 0x3f; |
| 833 | 836 | |
| 834 | | static const UINT32 pri_masks[5] = { 0xfffe, 0xfffc, 0xfff0, 0xff00 }; |
| 835 | 837 | pri = (source[0] >> 6) & 3; |
| 836 | | pri_mask = pri_masks[pri]; |
| 837 | 838 | |
| 839 | colr |= pri << (14-4); |
| 840 | |
| 838 | 841 | ytlim += 1; |
| 839 | 842 | xtlim += 1; |
| 840 | 843 | |
| r31923 | r31924 | |
| 864 | 867 | |
| 865 | 868 | |
| 866 | 869 | |
| 867 | | gfx->prio_transpen( |
| 868 | | bitmap, |
| 870 | gfx->transpen( |
| 871 | sprite_buffer, |
| 869 | 872 | cliprect, |
| 870 | 873 | tile_number, |
| 871 | 874 | colr, |
| 872 | 875 | yflip,xflip, |
| 873 | | (sx+xstep*xtiles)&ZEROTEAM_MASK_X,(sy+ystep*ytiles)&ZEROTEAM_MASK_Y, priority, pri_mask, 15); |
| 876 | (sx+xstep*xtiles)&ZEROTEAM_MASK_X,(sy+ystep*ytiles)&ZEROTEAM_MASK_Y, 15); |
| 874 | 877 | |
| 875 | 878 | |
| 876 | | gfx->prio_transpen( |
| 877 | | bitmap, |
| 879 | gfx->transpen( |
| 880 | sprite_buffer, |
| 878 | 881 | cliprect, |
| 879 | 882 | tile_number, |
| 880 | 883 | colr, |
| 881 | 884 | yflip,xflip, |
| 882 | | ((sx+xstep*xtiles)&ZEROTEAM_MASK_X)-0x200,(sy+ystep*ytiles)&ZEROTEAM_MASK_Y, priority, pri_mask, 15); |
| 885 | ((sx+xstep*xtiles)&ZEROTEAM_MASK_X)-0x200,(sy+ystep*ytiles)&ZEROTEAM_MASK_Y, 15); |
| 883 | 886 | |
| 884 | 887 | |
| 885 | | gfx->prio_transpen( |
| 886 | | bitmap, |
| 888 | gfx->transpen( |
| 889 | sprite_buffer, |
| 887 | 890 | cliprect, |
| 888 | 891 | tile_number, |
| 889 | 892 | colr, |
| 890 | 893 | yflip,xflip, |
| 891 | | (sx+xstep*xtiles)&ZEROTEAM_MASK_X,((sy+ystep*ytiles)&ZEROTEAM_MASK_Y)-0x200, priority, pri_mask, 15); |
| 894 | (sx+xstep*xtiles)&ZEROTEAM_MASK_X,((sy+ystep*ytiles)&ZEROTEAM_MASK_Y)-0x200, 15); |
| 892 | 895 | |
| 893 | 896 | |
| 894 | | gfx->prio_transpen( |
| 895 | | bitmap, |
| 897 | gfx->transpen( |
| 898 | sprite_buffer, |
| 896 | 899 | cliprect, |
| 897 | 900 | tile_number, |
| 898 | 901 | colr, |
| 899 | 902 | yflip,xflip, |
| 900 | | ((sx+xstep*xtiles)&ZEROTEAM_MASK_X)-0x200,((sy+ystep*ytiles)&ZEROTEAM_MASK_Y)-0x200, priority, pri_mask, 15); |
| 903 | ((sx+xstep*xtiles)&ZEROTEAM_MASK_X)-0x200,((sy+ystep*ytiles)&ZEROTEAM_MASK_Y)-0x200, 15); |
| 901 | 904 | |
| 902 | 905 | |
| 903 | 906 | tile_number++; |
| 904 | 907 | } |
| 905 | 908 | } |
| 906 | 909 | |
| 907 | | source += 4; |
| 910 | source -= 4; |
| 908 | 911 | } |
| 909 | 912 | |
| 910 | 913 | } |
| r31923 | r31924 | |
| 1062 | 1065 | background_layer = &machine().tilemap().create(m_gfxdecode, tilemap_get_info_delegate(FUNC(raiden2_state::get_back_tile_info),this), TILEMAP_SCAN_ROWS, 16,16, 32,32 ); |
| 1063 | 1066 | midground_layer = &machine().tilemap().create(m_gfxdecode, tilemap_get_info_delegate(FUNC(raiden2_state::get_mid_tile_info),this), TILEMAP_SCAN_ROWS, 16,16, 32,32 ); |
| 1064 | 1067 | foreground_layer = &machine().tilemap().create(m_gfxdecode, tilemap_get_info_delegate(FUNC(raiden2_state::get_fore_tile_info),this), TILEMAP_SCAN_ROWS, 16,16, 32,32 ); |
| 1065 | | |
| 1066 | | midground_layer->set_transparent_pen(15); |
| 1067 | | foreground_layer->set_transparent_pen(15); |
| 1068 | | text_layer->set_transparent_pen(15); |
| 1069 | 1068 | } |
| 1070 | 1069 | |
| 1071 | 1070 | /* screen_update_raiden2 (move to video file) */ |
| 1072 | 1071 | |
| 1073 | | UINT32 raiden2_state::screen_update_raiden2(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect) |
| 1072 | void raiden2_state::blend_layer(bitmap_rgb32 &bitmap, const rectangle &cliprect, bitmap_ind16 &source, UINT16 layer) |
| 1074 | 1073 | { |
| 1074 | const UINT8 alpha_active[0x10] = { // MSB first |
| 1075 | //00 08 10 18 20 28 30 38 40 48 50 58 60 68 70 78 |
| 1076 | 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x00, 0x0f, 0x00, 0x00 |
| 1077 | }; |
| 1078 | |
| 1079 | const pen_t *pens = &m_palette->pen(0); |
| 1080 | layer <<= 14; |
| 1081 | for(int y = cliprect.min_y; y <= cliprect.max_y; y++) { |
| 1082 | const UINT16 *src = &source.pix16(y, cliprect.min_x); |
| 1083 | UINT32 *dst = &bitmap.pix32(y, cliprect.min_x); |
| 1084 | for(int x = cliprect.min_x; x <= cliprect.max_x; x++) { |
| 1085 | UINT16 val = *src++; |
| 1086 | if((val & 0xc000) == layer && (val & 0x000f) != 0x000f) { |
| 1087 | val &= 0x07ff; |
| 1088 | // - 04 40 38 50 25 6b |
| 1089 | // + 3f 5c 68 6f |
| 1090 | int page = val >> 4; |
| 1091 | if(((alpha_active[page >> 3] & (0x80 >> (page & 7))) || page == ccol) && (val & 0xf) == 0xe) |
| 1092 | *dst = alpha_blend_r32(*dst, pens[val], 0x7f); |
| 1093 | else |
| 1094 | *dst = pens[val]; |
| 1095 | } |
| 1096 | dst++; |
| 1097 | } |
| 1098 | } |
| 1099 | } |
| 1100 | |
| 1101 | void raiden2_state::tilemap_draw_and_blend(screen_device &screen, bitmap_rgb32 &bitmap, const rectangle &cliprect, tilemap_t *tilemap) |
| 1102 | { |
| 1103 | tilemap->draw(screen, tile_buffer, cliprect, 0, 0); |
| 1104 | blend_layer(bitmap, cliprect, tile_buffer, 0); |
| 1105 | } |
| 1106 | |
| 1107 | UINT32 raiden2_state::screen_update_raiden2(screen_device &screen, bitmap_rgb32 &bitmap, const rectangle &cliprect) |
| 1108 | { |
| 1109 | cnt++; |
| 1110 | int ocol = ccol; |
| 1111 | |
| 1112 | if((cnt & 3) == 0) { |
| 1113 | if (machine().input().code_pressed(KEYCODE_Q)) |
| 1114 | ccol--; |
| 1115 | if (machine().input().code_pressed(KEYCODE_W)) |
| 1116 | ccol++; |
| 1117 | } |
| 1118 | ccol &= 0x7f; |
| 1119 | if(ccol != ocol) |
| 1120 | popmessage("%02x", ccol); |
| 1121 | |
| 1075 | 1122 | bitmap.fill(m_palette->black_pen(), cliprect); |
| 1076 | | screen.priority().fill(0, cliprect); |
| 1123 | draw_sprites(cliprect); |
| 1077 | 1124 | |
| 1125 | blend_layer(bitmap, cliprect, sprite_buffer, 0); |
| 1126 | |
| 1078 | 1127 | if (!(raiden2_tilemap_enable & 1)) |
| 1079 | | background_layer->draw(screen, bitmap, cliprect, 0, 1); |
| 1128 | tilemap_draw_and_blend(screen, bitmap, cliprect, background_layer); |
| 1080 | 1129 | |
| 1130 | blend_layer(bitmap, cliprect, sprite_buffer, 1); |
| 1131 | |
| 1081 | 1132 | if (!(raiden2_tilemap_enable & 2)) |
| 1082 | | midground_layer->draw(screen, bitmap, cliprect, 0, 2); |
| 1133 | tilemap_draw_and_blend(screen, bitmap, cliprect, midground_layer); |
| 1083 | 1134 | |
| 1135 | blend_layer(bitmap, cliprect, sprite_buffer, 2); |
| 1136 | |
| 1084 | 1137 | if (!(raiden2_tilemap_enable & 4)) |
| 1085 | | foreground_layer->draw(screen, bitmap, cliprect, 0, 4); |
| 1138 | tilemap_draw_and_blend(screen, bitmap, cliprect, foreground_layer); |
| 1086 | 1139 | |
| 1140 | blend_layer(bitmap, cliprect, sprite_buffer, 3); |
| 1141 | |
| 1087 | 1142 | if (!(raiden2_tilemap_enable & 8)) |
| 1088 | | text_layer->draw(screen, bitmap, cliprect, 0, 8); |
| 1143 | tilemap_draw_and_blend(screen, bitmap, cliprect, text_layer); |
| 1089 | 1144 | |
| 1090 | | if (!(raiden2_tilemap_enable & 0x10)) |
| 1091 | | draw_sprites(bitmap, screen.priority(), cliprect); |
| 1092 | | |
| 1093 | 1145 | return 0; |
| 1094 | 1146 | } |
| 1095 | 1147 | |
| r31923 | r31924 | |
| 1940 | 1992 | static GFXDECODE_START( raiden2 ) |
| 1941 | 1993 | GFXDECODE_ENTRY( "gfx1", 0x00000, raiden2_charlayout, 0x700, 128 ) |
| 1942 | 1994 | GFXDECODE_ENTRY( "gfx2", 0x00000, raiden2_tilelayout, 0x400, 128 ) |
| 1943 | | GFXDECODE_ENTRY( "gfx3", 0x00000, raiden2_spritelayout, 0x000, 128 ) |
| 1995 | GFXDECODE_ENTRY( "gfx3", 0x00000, raiden2_spritelayout, 0x000, 4096 ) // really 128, but using the top bits for priority |
| 1944 | 1996 | GFXDECODE_END |
| 1945 | 1997 | |
| 1946 | 1998 | |
| r31923 | r31924 | |
| 1965 | 2017 | MCFG_SCREEN_SIZE(44*8, 34*8) |
| 1966 | 2018 | MCFG_SCREEN_VISIBLE_AREA(0*8, 40*8-1, 0, 30*8-1) |
| 1967 | 2019 | MCFG_SCREEN_UPDATE_DRIVER(raiden2_state, screen_update_raiden2) |
| 1968 | | MCFG_SCREEN_PALETTE("palette") |
| 1969 | 2020 | |
| 1970 | 2021 | MCFG_GFXDECODE_ADD("gfxdecode", "palette", raiden2) |
| 1971 | 2022 | MCFG_PALETTE_ADD("palette", 2048) |
| r31923 | r31924 | |
| 2023 | 2074 | // MCFG_SCREEN_REFRESH_RATE(55.47) /* verified on pcb */ |
| 2024 | 2075 | MCFG_SCREEN_RAW_PARAMS(XTAL_32MHz/4,546,0,40*8,264,0,32*8) /* hand-tuned to match ~55.47 */ |
| 2025 | 2076 | MCFG_SCREEN_UPDATE_DRIVER(raiden2_state, screen_update_raiden2) |
| 2026 | | MCFG_SCREEN_PALETTE("palette") |
| 2027 | 2077 | |
| 2028 | 2078 | MCFG_GFXDECODE_ADD("gfxdecode", "palette", raiden2) |
| 2029 | 2079 | MCFG_PALETTE_ADD("palette", 2048) |
trunk/src/mame/includes/raiden2.h
| r31923 | r31924 | |
| 5 | 5 | public: |
| 6 | 6 | raiden2_state(const machine_config &mconfig, device_type type, const char *tag) |
| 7 | 7 | : driver_device(mconfig, type, tag), |
| 8 | | back_data(*this, "back_data"), |
| 9 | | fore_data(*this, "fore_data"), |
| 10 | | mid_data(*this, "mid_data"), |
| 11 | | text_data(*this, "text_data"), |
| 12 | | sprites(*this, "sprites") , |
| 13 | | m_maincpu(*this, "maincpu"), |
| 14 | | m_seibu_sound(*this, "seibu_sound"), |
| 15 | | m_gfxdecode(*this, "gfxdecode"), |
| 16 | | m_palette(*this, "palette") { } |
| 8 | back_data(*this, "back_data"), |
| 9 | fore_data(*this, "fore_data"), |
| 10 | mid_data(*this, "mid_data"), |
| 11 | text_data(*this, "text_data"), |
| 12 | sprites(*this, "sprites") , |
| 13 | m_maincpu(*this, "maincpu"), |
| 14 | m_seibu_sound(*this, "seibu_sound"), |
| 15 | m_gfxdecode(*this, "gfxdecode"), |
| 16 | m_palette(*this, "palette"), |
| 17 | tile_buffer(320, 256), |
| 18 | sprite_buffer(320, 256) |
| 19 | { } |
| 17 | 20 | |
| 18 | 21 | required_shared_ptr<UINT16> back_data,fore_data,mid_data, text_data, sprites; |
| 19 | 22 | required_device<cpu_device> m_maincpu; |
| r31923 | r31924 | |
| 113 | 116 | UINT16 cop_angle_target; |
| 114 | 117 | UINT16 cop_angle_step; |
| 115 | 118 | |
| 119 | bitmap_ind16 tile_buffer, sprite_buffer; |
| 120 | |
| 116 | 121 | DECLARE_WRITE16_MEMBER( sprite_prot_x_w ); |
| 117 | 122 | DECLARE_WRITE16_MEMBER( sprite_prot_y_w ); |
| 118 | 123 | DECLARE_WRITE16_MEMBER( sprite_prot_src_seg_w ); |
| r31923 | r31924 | |
| 139 | 144 | UINT16 cop_hit_status; |
| 140 | 145 | INT16 cop_hit_val_x,cop_hit_val_y,cop_hit_val_z,cop_hit_val_unk; |
| 141 | 146 | |
| 142 | | void draw_sprites(bitmap_ind16 &bitmap, bitmap_ind8 &priority, const rectangle &cliprect); |
| 147 | void draw_sprites(const rectangle &cliprect); |
| 143 | 148 | UINT8 cop_calculate_collsion_detection(); |
| 144 | 149 | void cop_take_hit_box_params(UINT8 offs); |
| 145 | 150 | |
| r31923 | r31924 | |
| 166 | 171 | DECLARE_MACHINE_RESET(zeroteam); |
| 167 | 172 | DECLARE_MACHINE_RESET(xsedae); |
| 168 | 173 | DECLARE_MACHINE_RESET(raidendx); |
| 169 | | UINT32 screen_update_raiden2(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect); |
| 174 | UINT32 screen_update_raiden2(screen_device &screen, bitmap_rgb32 &bitmap, const rectangle &cliprect); |
| 170 | 175 | INTERRUPT_GEN_MEMBER(raiden2_interrupt); |
| 171 | 176 | UINT16 rps(); |
| 172 | 177 | UINT16 rpc(); |
| 173 | 178 | const UINT8 fade_table(int v); |
| 174 | 179 | void combine32(UINT32 *val, int offset, UINT16 data, UINT16 mem_mask); |
| 175 | 180 | void sprcpt_init(void); |
| 181 | |
| 182 | void blend_layer(bitmap_rgb32 &bitmap, const rectangle &cliprect, bitmap_ind16 &source, UINT16 layer); |
| 183 | void tilemap_draw_and_blend(screen_device &screen, bitmap_rgb32 &bitmap, const rectangle &cliprect, tilemap_t *tilemap); |
| 184 | |
| 176 | 185 | }; |
| 177 | 186 | |
| 178 | 187 | /*----------- defined in machine/r2crypt.c -----------*/ |