trunk/src/mame/video/model3.c
| r32558 | r32559 | |
| 62 | 62 | |
| 63 | 63 | void model3_state::model3_exit() |
| 64 | 64 | { |
| 65 | #if 0 |
| 66 | FILE* file; |
| 67 | int i; |
| 68 | file = fopen("m3_texture_ram.bin","wb"); |
| 69 | for (i=0; i < 0x200000; i++) |
| 70 | { |
| 71 | fputc((UINT8)(m_texture_ram[0][i] >> 8), file); |
| 72 | fputc((UINT8)(m_texture_ram[0][i] >> 0), file); |
| 73 | } |
| 74 | for (i=0; i < 0x200000; i++) |
| 75 | { |
| 76 | fputc((UINT8)(m_texture_ram[1][i] >> 8), file); |
| 77 | fputc((UINT8)(m_texture_ram[1][i] >> 0), file); |
| 78 | } |
| 79 | fclose(file); |
| 80 | |
| 81 | file = fopen("m3_displist.bin","wb"); |
| 82 | for (i=0; i < 0x40000; i++) |
| 83 | { |
| 84 | fputc((UINT8)(m_display_list_ram[i] >> 24), file); |
| 85 | fputc((UINT8)(m_display_list_ram[i] >> 16), file); |
| 86 | fputc((UINT8)(m_display_list_ram[i] >> 8), file); |
| 87 | fputc((UINT8)(m_display_list_ram[i] >> 0), file); |
| 88 | } |
| 89 | fclose(file); |
| 90 | |
| 91 | file = fopen("m3_culling_ram.bin","wb"); |
| 92 | for (i=0; i < 0x100000; i++) |
| 93 | { |
| 94 | fputc((UINT8)(m_culling_ram[i] >> 24), file); |
| 95 | fputc((UINT8)(m_culling_ram[i] >> 16), file); |
| 96 | fputc((UINT8)(m_culling_ram[i] >> 8), file); |
| 97 | fputc((UINT8)(m_culling_ram[i] >> 0), file); |
| 98 | } |
| 99 | fclose(file); |
| 100 | |
| 101 | file = fopen("m3_polygon_ram.bin","wb"); |
| 102 | for (i=0; i < 0x100000; i++) |
| 103 | { |
| 104 | fputc((UINT8)(m_polygon_ram[i] >> 24), file); |
| 105 | fputc((UINT8)(m_polygon_ram[i] >> 16), file); |
| 106 | fputc((UINT8)(m_polygon_ram[i] >> 8), file); |
| 107 | fputc((UINT8)(m_polygon_ram[i] >> 0), file); |
| 108 | } |
| 109 | fclose(file); |
| 110 | |
| 111 | file = fopen("m3_vrom.bin","wb"); |
| 112 | for (i=0; i < 0x1000000; i++) |
| 113 | { |
| 114 | fputc((UINT8)(m_vrom[i] >> 24), file); |
| 115 | fputc((UINT8)(m_vrom[i] >> 16), file); |
| 116 | fputc((UINT8)(m_vrom[i] >> 8), file); |
| 117 | fputc((UINT8)(m_vrom[i] >> 0), file); |
| 118 | } |
| 119 | fclose(file); |
| 120 | #endif |
| 121 | |
| 65 | 122 | invalidate_texture(0, 0, 0, 6, 5); |
| 66 | 123 | invalidate_texture(1, 0, 0, 6, 5); |
| 67 | 124 | poly_free(m_poly); |
| r32558 | r32559 | |
| 69 | 126 | |
| 70 | 127 | void model3_state::video_start() |
| 71 | 128 | { |
| 129 | static const gfx_layout char4_layout = |
| 130 | { |
| 131 | 8, 8, |
| 132 | 30720, |
| 133 | 4, |
| 134 | { 0,1,2,3 }, |
| 135 | { 0*4, 1*4, 2*4, 3*4, 4*4, 5*4, 6*4, 7*4 }, |
| 136 | { 1*32, 0*32, 3*32, 2*32, 5*32, 4*32, 7*32, 6*32 }, |
| 137 | 4 * 8*8 |
| 138 | }; |
| 139 | |
| 140 | static const gfx_layout char8_layout = |
| 141 | { |
| 142 | 8, 8, |
| 143 | 15360, |
| 144 | 8, |
| 145 | { 0,1,2,3,4,5,6,7 }, |
| 146 | { 4*8, 5*8, 6*8, 7*8, 0*8, 1*8, 2*8, 3*8 }, |
| 147 | { 0*64, 1*64, 2*64, 3*64, 4*64, 5*64, 6*64, 7*64 }, |
| 148 | 8 * 8*8 |
| 149 | }; |
| 150 | |
| 72 | 151 | m_poly = poly_alloc(machine(), 4000, sizeof(poly_extra_data), 0); |
| 73 | 152 | machine().add_notifier(MACHINE_NOTIFY_EXIT, machine_notify_delegate(FUNC(model3_state::model3_exit), this)); |
| 74 | 153 | |
| r32558 | r32559 | |
| 78 | 157 | m_m3_char_ram = auto_alloc_array_clear(machine(), UINT64, 0x100000/8); |
| 79 | 158 | m_m3_tile_ram = auto_alloc_array_clear(machine(), UINT64, 0x8000/8); |
| 80 | 159 | |
| 81 | | m_pal_lookup = auto_alloc_array_clear(machine(), UINT16, 65536); |
| 82 | | |
| 83 | 160 | m_texture_fifo = auto_alloc_array_clear(machine(), UINT32, 0x100000/4); |
| 84 | 161 | |
| 85 | 162 | /* 2x 4MB texture sheets */ |
| r32558 | r32559 | |
| 103 | 180 | m_viewport_region_width = 496; |
| 104 | 181 | m_viewport_region_height = 384; |
| 105 | 182 | |
| 106 | | init_matrix_stack(); |
| 107 | | } |
| 183 | m_layer4[0] = &machine().tilemap().create(m_gfxdecode, tilemap_get_info_delegate(FUNC(model3_state::tile_info_layer0_4bit), this), TILEMAP_SCAN_ROWS, 8, 8, 64, 64); |
| 184 | m_layer8[0] = &machine().tilemap().create(m_gfxdecode, tilemap_get_info_delegate(FUNC(model3_state::tile_info_layer0_8bit), this), TILEMAP_SCAN_ROWS, 8, 8, 64, 64); |
| 185 | m_layer4[1] = &machine().tilemap().create(m_gfxdecode, tilemap_get_info_delegate(FUNC(model3_state::tile_info_layer1_4bit), this), TILEMAP_SCAN_ROWS, 8, 8, 64, 64); |
| 186 | m_layer8[1] = &machine().tilemap().create(m_gfxdecode, tilemap_get_info_delegate(FUNC(model3_state::tile_info_layer1_8bit), this), TILEMAP_SCAN_ROWS, 8, 8, 64, 64); |
| 187 | m_layer4[2] = &machine().tilemap().create(m_gfxdecode, tilemap_get_info_delegate(FUNC(model3_state::tile_info_layer2_4bit), this), TILEMAP_SCAN_ROWS, 8, 8, 64, 64); |
| 188 | m_layer8[2] = &machine().tilemap().create(m_gfxdecode, tilemap_get_info_delegate(FUNC(model3_state::tile_info_layer2_8bit), this), TILEMAP_SCAN_ROWS, 8, 8, 64, 64); |
| 189 | m_layer4[3] = &machine().tilemap().create(m_gfxdecode, tilemap_get_info_delegate(FUNC(model3_state::tile_info_layer3_4bit), this), TILEMAP_SCAN_ROWS, 8, 8, 64, 64); |
| 190 | m_layer8[3] = &machine().tilemap().create(m_gfxdecode, tilemap_get_info_delegate(FUNC(model3_state::tile_info_layer3_8bit), this), TILEMAP_SCAN_ROWS, 8, 8, 64, 64); |
| 108 | 191 | |
| 109 | | void model3_state::draw_tile_4bit(bitmap_ind16 &bitmap, int tx, int ty, int tilenum) |
| 110 | | { |
| 111 | | int x, y; |
| 112 | | UINT8 *tile_base = (UINT8*)m_m3_char_ram; |
| 113 | | UINT8 *tile; |
| 192 | // 4-bit tiles |
| 193 | m_gfxdecode->set_gfx(0, global_alloc(gfx_element(m_palette, char4_layout, (UINT8*)m_m3_char_ram, 0, m_palette->entries() / 16, 0))); |
| 114 | 194 | |
| 115 | | int data = (BYTE_REVERSE16(tilenum)); |
| 116 | | int c = data & 0x7ff0; |
| 117 | | int tile_index = ((data << 1) & 0x7ffe) | ((data >> 15) & 0x1); |
| 118 | | tile_index *= 32; |
| 195 | // 8-bit tiles |
| 196 | m_gfxdecode->set_gfx(1, global_alloc(gfx_element(m_palette, char8_layout, (UINT8*)m_m3_char_ram, 0, m_palette->entries() / 256, 0))); |
| 119 | 197 | |
| 120 | | tile = &tile_base[tile_index]; |
| 121 | | |
| 122 | | for(y = ty; y < ty+8; y++) { |
| 123 | | UINT16 *d = &bitmap.pix16(y^1); |
| 124 | | for(x = tx; x < tx+8; x+=2) { |
| 125 | | UINT8 tile0, tile1; |
| 126 | | UINT16 pix0, pix1; |
| 127 | | tile0 = *tile >> 4; |
| 128 | | tile1 = *tile & 0xf; |
| 129 | | pix0 = m_pal_lookup[c + tile0]; |
| 130 | | pix1 = m_pal_lookup[c + tile1]; |
| 131 | | if((pix0 & 0x8000) == 0) |
| 132 | | { |
| 133 | | d[x+0] = pix0; |
| 134 | | } |
| 135 | | if((pix1 & 0x8000) == 0) |
| 136 | | { |
| 137 | | d[x+1] = pix1; |
| 138 | | } |
| 139 | | ++tile; |
| 140 | | } |
| 141 | | } |
| 198 | init_matrix_stack(); |
| 142 | 199 | } |
| 143 | 200 | |
| 144 | | void model3_state::draw_tile_8bit(bitmap_ind16 &bitmap, int tx, int ty, int tilenum) |
| 145 | | { |
| 146 | | int x, y; |
| 147 | | UINT8 *tile_base = (UINT8*)m_m3_char_ram; |
| 148 | | UINT8 *tile; |
| 201 | #define MODEL3_TILE_INFO4(address) \ |
| 202 | do { \ |
| 203 | UINT16 *tiles = (UINT16*)&m_m3_tile_ram[address + (tile_index / 4)]; \ |
| 204 | UINT16 t = BYTE_REVERSE16(tiles[(tile_index & 3) ^ NATIVE_ENDIAN_VALUE_LE_BE(2,0)]); \ |
| 205 | int tile = ((t << 1) & 0x7ffe) | ((t >> 15) & 0x1); \ |
| 206 | int color = (t & 0x7ff0) >> 4; \ |
| 207 | SET_TILE_INFO_MEMBER(0, tile, color, 0); \ |
| 208 | } while (0) |
| 149 | 209 | |
| 150 | | int data = (BYTE_REVERSE16(tilenum)); |
| 151 | | int c = data & 0x7f00; |
| 152 | | int tile_index = ((data << 1) & 0x7ffe) | ((data >> 15) & 0x1); |
| 153 | | tile_index *= 32; |
| 210 | #define MODEL3_TILE_INFO8(address) \ |
| 211 | do { \ |
| 212 | UINT16 *tiles = (UINT16*)&m_m3_tile_ram[address + (tile_index / 4)]; \ |
| 213 | UINT16 t = BYTE_REVERSE16(tiles[(tile_index & 3) ^ NATIVE_ENDIAN_VALUE_LE_BE(2,0)]); \ |
| 214 | int tile = ((t << 1) & 0x7ffe) | ((t >> 15) & 0x1); \ |
| 215 | int color = (t & 0x7f00) >> 8; \ |
| 216 | SET_TILE_INFO_MEMBER(1, tile >> 1, color, 0); \ |
| 217 | } while (0) |
| 154 | 218 | |
| 155 | | tile = &tile_base[tile_index]; |
| 219 | TILE_GET_INFO_MEMBER(model3_state::tile_info_layer0_4bit) { MODEL3_TILE_INFO4(0x000); } |
| 220 | TILE_GET_INFO_MEMBER(model3_state::tile_info_layer0_8bit) { MODEL3_TILE_INFO8(0x000); } |
| 221 | TILE_GET_INFO_MEMBER(model3_state::tile_info_layer1_4bit) { MODEL3_TILE_INFO4(0x400); } |
| 222 | TILE_GET_INFO_MEMBER(model3_state::tile_info_layer1_8bit) { MODEL3_TILE_INFO8(0x400); } |
| 223 | TILE_GET_INFO_MEMBER(model3_state::tile_info_layer2_4bit) { MODEL3_TILE_INFO4(0x800); } |
| 224 | TILE_GET_INFO_MEMBER(model3_state::tile_info_layer2_8bit) { MODEL3_TILE_INFO8(0x800); } |
| 225 | TILE_GET_INFO_MEMBER(model3_state::tile_info_layer3_4bit) { MODEL3_TILE_INFO4(0xc00); } |
| 226 | TILE_GET_INFO_MEMBER(model3_state::tile_info_layer3_8bit) { MODEL3_TILE_INFO8(0xc00); } |
| 156 | 227 | |
| 157 | | for(y = ty; y < ty+8; y++) { |
| 158 | | UINT16 *d = &bitmap.pix16(y); |
| 159 | | int xx = 0; |
| 160 | | for(x = tx; x < tx+8; x++) { |
| 161 | | UINT8 tile0; |
| 162 | | UINT16 pix; |
| 163 | | tile0 = tile[xx^4]; |
| 164 | | pix = m_pal_lookup[c + tile0]; |
| 165 | | if((pix & 0x8000) == 0) |
| 166 | | { |
| 167 | | d[x] = pix; |
| 168 | | } |
| 169 | | ++xx; |
| 170 | | } |
| 171 | | tile += 8; |
| 172 | | } |
| 173 | | } |
| 174 | 228 | #ifdef UNUSED_FUNCTION |
| 175 | 229 | void model3_state::draw_texture_sheet(bitmap_ind16 &bitmap, const rectangle &cliprect) |
| 176 | 230 | { |
| r32558 | r32559 | |
| 190 | 244 | } |
| 191 | 245 | #endif |
| 192 | 246 | |
| 193 | | void model3_state::draw_layer(bitmap_ind16 &bitmap, const rectangle &cliprect, int layer, int bitdepth) |
| 247 | void model3_state::draw_layer(bitmap_rgb32 &bitmap, const rectangle &cliprect, int layer, int bitdepth, int sx, int sy) |
| 194 | 248 | { |
| 195 | | int x, y; |
| 196 | | int tile_index = 0; |
| 197 | | UINT16 *tiles = (UINT16*)&m_m3_tile_ram[layer * 0x400]; |
| 249 | tilemap_t *tmap = bitdepth ? m_layer4[layer] : m_layer8[layer]; |
| 250 | bitmap_ind16 &pixmap = tmap->pixmap(); |
| 251 | const pen_t *pens = m_palette->pens(); |
| 198 | 252 | |
| 199 | | //logerror("Layer %d: X: %d, Y: %d\n", layer, x1, y1); |
| 253 | UINT32* palram = (UINT32*)&m_paletteram64[0]; |
| 200 | 254 | |
| 201 | | if(layer > 1) { |
| 202 | | int modr = (m_layer_modulate2 >> 8) & 0xff; |
| 203 | | int modg = (m_layer_modulate2 >> 16) & 0xff; |
| 204 | | int modb = (m_layer_modulate2 >> 24) & 0xff; |
| 205 | | if(modr & 0x80) { |
| 206 | | m_layer_modulate_r = -(0x7f - (modr & 0x7f)) << 10; |
| 207 | | } else { |
| 208 | | m_layer_modulate_r = (modr & 0x7f) << 10; |
| 209 | | } |
| 210 | | if(modg & 0x80) { |
| 211 | | m_layer_modulate_g = -(0x7f - (modr & 0x7f)) << 5; |
| 212 | | } else { |
| 213 | | m_layer_modulate_g = (modr & 0x7f) << 5; |
| 214 | | } |
| 215 | | if(modb & 0x80) { |
| 216 | | m_layer_modulate_b = -(0x7f - (modr & 0x7f)); |
| 217 | | } else { |
| 218 | | m_layer_modulate_b = (modr & 0x7f); |
| 219 | | } |
| 220 | | } else { |
| 221 | | int modr = (m_layer_modulate1 >> 8) & 0xff; |
| 222 | | int modg = (m_layer_modulate1 >> 16) & 0xff; |
| 223 | | int modb = (m_layer_modulate1 >> 24) & 0xff; |
| 224 | | if(modr & 0x80) { |
| 225 | | m_layer_modulate_r = -(0x7f - (modr & 0x7f)) << 10; |
| 226 | | } else { |
| 227 | | m_layer_modulate_r = (modr & 0x7f) << 10; |
| 228 | | } |
| 229 | | if(modg & 0x80) { |
| 230 | | m_layer_modulate_g = -(0x7f - (modr & 0x7f)) << 5; |
| 231 | | } else { |
| 232 | | m_layer_modulate_g = (modr & 0x7f) << 5; |
| 233 | | } |
| 234 | | if(modb & 0x80) { |
| 235 | | m_layer_modulate_b = -(0x7f - (modr & 0x7f)); |
| 236 | | } else { |
| 237 | | m_layer_modulate_b = (modr & 0x7f); |
| 238 | | } |
| 239 | | } |
| 255 | int x1 = cliprect.min_x; |
| 256 | int y1 = cliprect.min_y; |
| 257 | int x2 = cliprect.max_x; |
| 258 | int y2 = cliprect.max_y; |
| 240 | 259 | |
| 241 | | if(bitdepth) /* 4-bit */ |
| 260 | int ix = sx; |
| 261 | int iy = sy; |
| 262 | if (ix < 0) |
| 242 | 263 | { |
| 243 | | for(y = cliprect.min_y; y <= cliprect.max_y; y+=8) |
| 244 | | { |
| 245 | | tile_index = ((y/8) * 64); |
| 246 | | for (x = cliprect.min_x; x <= cliprect.max_x; x+=8) { |
| 247 | | UINT16 tile = tiles[tile_index ^ 0x2]; |
| 248 | | draw_tile_4bit(bitmap, x, y, tile); |
| 249 | | ++tile_index; |
| 250 | | } |
| 251 | | } |
| 264 | ix = 0 - ix; |
| 252 | 265 | } |
| 253 | | else /* 8-bit */ |
| 266 | if (iy < 0) |
| 254 | 267 | { |
| 255 | | for(y = cliprect.min_y; y <= cliprect.max_y; y+=8) |
| 268 | iy = 0 - iy; |
| 269 | } |
| 270 | |
| 271 | for (int y = y1; y <= y2; y++) |
| 272 | { |
| 273 | UINT32* dst = &bitmap.pix32(y); |
| 274 | UINT16* src = &pixmap.pix16(iy & 0x1ff); |
| 275 | |
| 276 | int iix = ix; |
| 277 | |
| 278 | for (int x = x1; x <= x2; x++) |
| 256 | 279 | { |
| 257 | | tile_index = ((y/8) * 64); |
| 258 | | for (x = cliprect.min_x; x <= cliprect.max_x; x+=8) { |
| 259 | | UINT16 tile = tiles[tile_index ^ 0x2]; |
| 260 | | draw_tile_8bit(bitmap, x, y, tile); |
| 261 | | ++tile_index; |
| 280 | UINT16 p0 = src[iix & 0x1ff]; |
| 281 | if ((palram[p0^NATIVE_ENDIAN_VALUE_LE_BE(1,0)] & NATIVE_ENDIAN_VALUE_LE_BE(0x00800000,0x00008000)) == 0) |
| 282 | { |
| 283 | *dst = pens[p0]; |
| 262 | 284 | } |
| 285 | dst++; |
| 286 | iix++; |
| 263 | 287 | } |
| 264 | | } |
| 265 | | } |
| 266 | 288 | |
| 267 | | #ifdef UNUSED_FUNCTION |
| 268 | | static void copy_screen(bitmap_ind16 &bitmap, const rectangle &cliprect) |
| 269 | | { |
| 270 | | int x,y; |
| 271 | | for(y=cliprect.min_y; y <= cliprect.max_y; y++) { |
| 272 | | UINT16 *d = &bitmap.pix16(y); |
| 273 | | UINT16 *s = &m_bitmap3d.pix16(y); |
| 274 | | for(x=cliprect.min_x; x <= cliprect.max_x; x++) { |
| 275 | | UINT16 pix = s[x]; |
| 276 | | if(!(pix & 0x8000)) { |
| 277 | | d[x] = pix; |
| 278 | | } |
| 279 | | } |
| 289 | iy++; |
| 280 | 290 | } |
| 281 | 291 | } |
| 282 | | #endif |
| 283 | 292 | |
| 284 | | UINT32 model3_state::screen_update_model3(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect) |
| 293 | UINT32 model3_state::screen_update_model3(screen_device &screen, bitmap_rgb32 &bitmap, const rectangle &cliprect) |
| 285 | 294 | { |
| 286 | | #if 0 |
| 287 | 295 | int layer_scroll_x[4], layer_scroll_y[4]; |
| 288 | 296 | UINT32 layer_data[4]; |
| 289 | 297 | |
| r32558 | r32559 | |
| 291 | 299 | layer_data[1] = BYTE_REVERSE32((UINT32)(m_layer_scroll[0] >> 0)); |
| 292 | 300 | layer_data[2] = BYTE_REVERSE32((UINT32)(m_layer_scroll[1] >> 32)); |
| 293 | 301 | layer_data[3] = BYTE_REVERSE32((UINT32)(m_layer_scroll[1] >> 0)); |
| 294 | | layer_scroll_x[0] = (layer_data[0] & 0x8000) ? (layer_data[0] & 0x1ff) : -(layer_data[0] & 0x1ff); |
| 295 | | layer_scroll_y[0] = (layer_data[0] & 0x8000) ? (layer_data[0] & 0x1ff) : -(layer_data[0] & 0x1ff); |
| 296 | | layer_scroll_x[1] = (layer_data[1] & 0x8000) ? (layer_data[1] & 0x1ff) : -(layer_data[1] & 0x1ff); |
| 297 | | layer_scroll_y[1] = (layer_data[1] & 0x8000) ? (layer_data[1] & 0x1ff) : -(layer_data[1] & 0x1ff); |
| 298 | | layer_scroll_x[2] = (layer_data[2] & 0x8000) ? (layer_data[2] & 0x1ff) : -(layer_data[2] & 0x1ff); |
| 299 | | layer_scroll_y[2] = (layer_data[2] & 0x8000) ? (layer_data[2] & 0x1ff) : -(layer_data[2] & 0x1ff); |
| 300 | | layer_scroll_x[3] = (layer_data[3] & 0x8000) ? (layer_data[3] & 0x1ff) : -(layer_data[3] & 0x1ff); |
| 301 | | layer_scroll_y[3] = (layer_data[3] & 0x8000) ? (layer_data[3] & 0x1ff) : -(layer_data[3] & 0x1ff); |
| 302 | | #endif |
| 302 | layer_scroll_x[0] = layer_data[0] & 0x1ff; |
| 303 | layer_scroll_y[0] = (layer_data[0] >> 16) & 0x1ff; |
| 304 | layer_scroll_x[1] = layer_data[1] & 0x1ff; |
| 305 | layer_scroll_y[1] = (layer_data[1] >> 16) & 0x1ff; |
| 306 | layer_scroll_x[2] = layer_data[2] & 0x1ff; |
| 307 | layer_scroll_y[2] = (layer_data[2] >> 16) & 0x1ff; |
| 308 | layer_scroll_x[3] = layer_data[3] & 0x1ff; |
| 309 | layer_scroll_y[3] = (layer_data[3] >> 16) & 0x1ff; |
| 310 | |
| 303 | 311 | m_screen_clip = (rectangle*)&cliprect; |
| 304 | | |
| 305 | 312 | m_clip3d = cliprect; |
| 306 | 313 | |
| 307 | | /* layer disable debug keys */ |
| 308 | | m_tick++; |
| 309 | | if( m_tick >= 5 ) { |
| 310 | | m_tick = 0; |
| 311 | | |
| 312 | | if( machine().input().code_pressed(KEYCODE_Y) ) |
| 313 | | m_debug_layer_disable ^= 0x1; |
| 314 | | if( machine().input().code_pressed(KEYCODE_U) ) |
| 315 | | m_debug_layer_disable ^= 0x2; |
| 316 | | if( machine().input().code_pressed(KEYCODE_I) ) |
| 317 | | m_debug_layer_disable ^= 0x4; |
| 318 | | if( machine().input().code_pressed(KEYCODE_O) ) |
| 319 | | m_debug_layer_disable ^= 0x8; |
| 320 | | if( machine().input().code_pressed(KEYCODE_T) ) |
| 321 | | m_debug_layer_disable ^= 0x10; |
| 322 | | } |
| 323 | | |
| 324 | 314 | bitmap.fill(0, cliprect); |
| 325 | 315 | |
| 326 | | if (!(m_debug_layer_disable & 0x8)) |
| 327 | | draw_layer(bitmap, cliprect, 3, (m_layer_enable >> 3) & 0x1); |
| 316 | // render enabled layers with priority 0 |
| 317 | if ((layer_data[3] & 0x80000000) && (m_layer_priority & 0x8) == 0) |
| 318 | draw_layer(bitmap, cliprect, 3, m_layer_priority & 0x80, layer_scroll_x[3], layer_scroll_y[3]); |
| 319 | if ((layer_data[2] & 0x80000000) && (m_layer_priority & 0x4) == 0) |
| 320 | draw_layer(bitmap, cliprect, 2, m_layer_priority & 0x40, layer_scroll_x[2], layer_scroll_y[2]); |
| 321 | if ((layer_data[1] & 0x80000000) && (m_layer_priority & 0x2) == 0) |
| 322 | draw_layer(bitmap, cliprect, 1, m_layer_priority & 0x20, layer_scroll_x[1], layer_scroll_y[1]); |
| 323 | if ((layer_data[0] & 0x80000000) && (m_layer_priority & 0x1) == 0) |
| 324 | draw_layer(bitmap, cliprect, 0, m_layer_priority & 0x10, layer_scroll_x[0], layer_scroll_y[0]); |
| 328 | 325 | |
| 329 | | if (!(m_debug_layer_disable & 0x4)) |
| 330 | | draw_layer(bitmap, cliprect, 2, (m_layer_enable >> 2) & 0x1); |
| 326 | // render 3D |
| 327 | draw_3d_layer(bitmap, cliprect); |
| 331 | 328 | |
| 332 | | if( !(m_debug_layer_disable & 0x10) ) |
| 333 | | { |
| 334 | | #if 0 |
| 335 | | if(m_real3d_display_list) { |
| 336 | | m_zbuffer.fill(0, cliprect); |
| 337 | | m_bitmap3d.fill(0x8000, cliprect); |
| 338 | | real3d_traverse_display_list(); |
| 339 | | } |
| 340 | | #endif |
| 341 | | copybitmap_trans(bitmap, m_bitmap3d, 0, 0, 0, 0, cliprect, 0x8000); |
| 342 | | } |
| 329 | // render enabled layers with priority 1 |
| 330 | if ((layer_data[3] & 0x80000000) && (m_layer_priority & 0x8) != 0) |
| 331 | draw_layer(bitmap, cliprect, 3, m_layer_priority & 0x80, layer_scroll_x[3], layer_scroll_y[3]); |
| 332 | if ((layer_data[2] & 0x80000000) && (m_layer_priority & 0x4) != 0) |
| 333 | draw_layer(bitmap, cliprect, 2, m_layer_priority & 0x40, layer_scroll_x[2], layer_scroll_y[2]); |
| 334 | if ((layer_data[1] & 0x80000000) && (m_layer_priority & 0x2) != 0) |
| 335 | draw_layer(bitmap, cliprect, 1, m_layer_priority & 0x20, layer_scroll_x[1], layer_scroll_y[1]); |
| 336 | if ((layer_data[0] & 0x80000000) && (m_layer_priority & 0x1) != 0) |
| 337 | draw_layer(bitmap, cliprect, 0, m_layer_priority & 0x10, layer_scroll_x[0], layer_scroll_y[0]); |
| 343 | 338 | |
| 344 | | if (!(m_debug_layer_disable & 0x2)) |
| 345 | | draw_layer(bitmap, cliprect, 1, (m_layer_enable >> 1) & 0x1); |
| 346 | | |
| 347 | | if (!(m_debug_layer_disable & 0x1)) |
| 348 | | draw_layer(bitmap, cliprect, 0, (m_layer_enable >> 0) & 0x1); |
| 349 | | |
| 350 | | //copy_screen(bitmap, cliprect); |
| 351 | | |
| 352 | | //draw_texture_sheet(bitmap, cliprect); |
| 353 | | |
| 354 | 339 | m_real3d_display_list = 0; |
| 355 | 340 | return 0; |
| 356 | 341 | } |
| r32558 | r32559 | |
| 365 | 350 | WRITE64_MEMBER(model3_state::model3_char_w) |
| 366 | 351 | { |
| 367 | 352 | COMBINE_DATA(&m_m3_char_ram[offset]); |
| 353 | m_gfxdecode->gfx(0)->mark_dirty(offset / 4); |
| 354 | m_gfxdecode->gfx(1)->mark_dirty(offset / 8); |
| 368 | 355 | } |
| 369 | 356 | |
| 370 | 357 | READ64_MEMBER(model3_state::model3_tile_r) |
| r32558 | r32559 | |
| 375 | 362 | WRITE64_MEMBER(model3_state::model3_tile_w) |
| 376 | 363 | { |
| 377 | 364 | COMBINE_DATA(&m_m3_tile_ram[offset]); |
| 365 | |
| 366 | /* |
| 367 | m_layer4[0]->mark_all_dirty(); |
| 368 | m_layer8[0]->mark_all_dirty(); |
| 369 | m_layer4[1]->mark_all_dirty(); |
| 370 | m_layer8[1]->mark_all_dirty(); |
| 371 | m_layer4[2]->mark_all_dirty(); |
| 372 | m_layer8[2]->mark_all_dirty(); |
| 373 | m_layer4[3]->mark_all_dirty(); |
| 374 | m_layer8[3]->mark_all_dirty(); |
| 375 | */ |
| 376 | |
| 377 | int layer = (offset >> 10) & 0x3; |
| 378 | int tile = (offset & 0x3ff) * 4; |
| 379 | m_layer4[layer]->mark_tile_dirty(tile+0); |
| 380 | m_layer4[layer]->mark_tile_dirty(tile+1); |
| 381 | m_layer4[layer]->mark_tile_dirty(tile+2); |
| 382 | m_layer4[layer]->mark_tile_dirty(tile+3); |
| 383 | m_layer8[layer]->mark_tile_dirty(tile+0); |
| 384 | m_layer8[layer]->mark_tile_dirty(tile+1); |
| 385 | m_layer8[layer]->mark_tile_dirty(tile+2); |
| 386 | m_layer8[layer]->mark_tile_dirty(tile+3); |
| 378 | 387 | } |
| 379 | 388 | |
| 389 | /* |
| 390 | Video registers: |
| 391 | |
| 392 | 0xF1180000: ? |
| 393 | 0xF1180004: ? |
| 394 | 0xF1180008: ? |
| 395 | |
| 396 | 0xF1180010: VBL IRQ acknowledge |
| 397 | |
| 398 | 0xF1180020: -------- x------- -------- -------- Layer 3 bitdepth (0 = 8-bit, 1 = 4-bit) |
| 399 | -------- -x------ -------- -------- Layer 2 bitdepth (0 = 8-bit, 1 = 4-bit) |
| 400 | -------- --x----- -------- -------- Layer 1 bitdepth (0 = 8-bit, 1 = 4-bit) |
| 401 | -------- ---x---- -------- -------- Layer 0 bitdepth (0 = 8-bit, 1 = 4-bit) |
| 402 | -------- ----x--- -------- -------- Layer 3 priority (0 = below 3D, 1 = above 3D) |
| 403 | -------- -----x-- -------- -------- Layer 2 priority (0 = below 3D, 1 = above 3D) |
| 404 | -------- ------x- -------- -------- Layer 1 priority (0 = below 3D, 1 = above 3D) |
| 405 | -------- -------x -------- -------- Layer 0 priority (0 = below 3D, 1 = above 3D) |
| 406 | |
| 407 | 0xF1180040: Foreground layer color modulation? |
| 408 | -------- xxxxxxxx -------- -------- Red component |
| 409 | -------- -------- xxxxxxxx -------- Green component |
| 410 | -------- -------- -------- xxxxxxxx Blue component |
| 411 | |
| 412 | 0xF1180044: Background layer color modulation? |
| 413 | -------- xxxxxxxx -------- -------- Red component |
| 414 | -------- -------- xxxxxxxx -------- Green component |
| 415 | -------- -------- -------- xxxxxxxx Blue component |
| 416 | |
| 417 | 0xF1180060: x------- -------- -------- -------- Layer 0 enable |
| 418 | -------x xxxxxxxx -------- -------- Layer 0 Y scroll position |
| 419 | -------- -------- -------x xxxxxxxx Layer 0 X scroll position |
| 420 | |
| 421 | 0xF1180064: x------- -------- -------- -------- Layer 1 enable |
| 422 | -------x xxxxxxxx -------- -------- Layer 1 Y scroll position |
| 423 | -------- -------- -------x xxxxxxxx Layer 1 X scroll position |
| 424 | |
| 425 | 0xF1180068: x------- -------- -------- -------- Layer 2 enable |
| 426 | -------x xxxxxxxx -------- -------- Layer 2 Y scroll position |
| 427 | -------- -------- -------x xxxxxxxx Layer 2 X scroll position |
| 428 | |
| 429 | 0xF118006C: x------- -------- -------- -------- Layer 3 enable |
| 430 | -------x xxxxxxxx -------- -------- Layer 3 Y scroll position |
| 431 | -------- -------- -------x xxxxxxxx Layer 3 X scroll position |
| 432 | */ |
| 433 | |
| 434 | |
| 380 | 435 | READ64_MEMBER(model3_state::model3_vid_reg_r) |
| 381 | 436 | { |
| 382 | 437 | switch(offset) |
| 383 | 438 | { |
| 384 | 439 | case 0x00/8: return m_vid_reg0; |
| 385 | 440 | case 0x08/8: return U64(0xffffffffffffffff); /* ??? */ |
| 386 | | case 0x20/8: return (UINT64)m_layer_enable << 52; |
| 441 | case 0x20/8: return (UINT64)m_layer_priority << 48; |
| 387 | 442 | case 0x40/8: return ((UINT64)m_layer_modulate1 << 32) | (UINT64)m_layer_modulate2; |
| 388 | 443 | default: logerror("read reg %02X\n", offset);break; |
| 389 | 444 | } |
| r32558 | r32559 | |
| 398 | 453 | case 0x08/8: break; /* ??? */ |
| 399 | 454 | case 0x10/8: set_irq_line((data >> 56) & 0x0f, CLEAR_LINE); break; /* VBL IRQ Ack */ |
| 400 | 455 | |
| 401 | | case 0x20/8: m_layer_enable = (data >> 52); break; |
| 456 | case 0x20/8: m_layer_priority = (data >> 48); break; |
| 402 | 457 | |
| 403 | 458 | case 0x40/8: m_layer_modulate1 = (UINT32)(data >> 32); |
| 404 | 459 | m_layer_modulate2 = (UINT32)(data); |
| r32558 | r32559 | |
| 411 | 466 | |
| 412 | 467 | WRITE64_MEMBER(model3_state::model3_palette_w) |
| 413 | 468 | { |
| 414 | | int r1,g1,b1,r2,g2,b2; |
| 415 | | UINT32 data1,data2; |
| 416 | | |
| 417 | 469 | COMBINE_DATA(&m_paletteram64[offset]); |
| 418 | | data1 = BYTE_REVERSE32((UINT32)(m_paletteram64[offset] >> 32)); |
| 419 | | data2 = BYTE_REVERSE32((UINT32)(m_paletteram64[offset] >> 0)); |
| 470 | UINT32 data1 = BYTE_REVERSE32((UINT32)(m_paletteram64[offset] >> 32)); |
| 471 | UINT32 data2 = BYTE_REVERSE32((UINT32)(m_paletteram64[offset] >> 0)); |
| 420 | 472 | |
| 421 | | r1 = ((data1 >> 0) & 0x1f); |
| 422 | | g1 = ((data1 >> 5) & 0x1f); |
| 423 | | b1 = ((data1 >> 10) & 0x1f); |
| 424 | | r2 = ((data2 >> 0) & 0x1f); |
| 425 | | g2 = ((data2 >> 5) & 0x1f); |
| 426 | | b2 = ((data2 >> 10) & 0x1f); |
| 427 | | |
| 428 | | m_pal_lookup[(offset*2)+0] = (data1 & 0x8000) | (r1 << 10) | (g1 << 5) | b1; |
| 429 | | m_pal_lookup[(offset*2)+1] = (data2 & 0x8000) | (r2 << 10) | (g2 << 5) | b2; |
| 473 | m_palette->set_pen_color((offset*2)+0, pal5bit(data1 >> 0), pal5bit(data1 >> 5), pal5bit(data1 >> 10)); |
| 474 | m_palette->set_pen_color((offset*2)+1, pal5bit(data2 >> 0), pal5bit(data2 >> 5), pal5bit(data2 >> 10)); |
| 430 | 475 | } |
| 431 | 476 | |
| 432 | 477 | READ64_MEMBER(model3_state::model3_palette_r) |
| r32558 | r32559 | |
| 707 | 752 | }; |
| 708 | 753 | } |
| 709 | 754 | m_texture_fifo_pos = 0; |
| 755 | |
| 710 | 756 | m_zbuffer.fill(0); |
| 711 | | m_bitmap3d.fill(0x8000); |
| 712 | | real3d_traverse_display_list(); |
| 713 | | //m_real3d_display_list = 1; |
| 757 | m_bitmap3d.fill(0); |
| 758 | |
| 759 | real3d_traverse_display_list(); |
| 714 | 760 | } |
| 715 | 761 | |
| 716 | 762 | void model3_state::real3d_display_list1_dma(UINT32 src, UINT32 dst, int length, int byteswap) |
| r32558 | r32559 | |
| 1419 | 1465 | float /*fov_x,*/ fov_y; |
| 1420 | 1466 | |
| 1421 | 1467 | link_address = node[1]; |
| 1422 | | if (link_address == 0) |
| 1423 | | return; |
| 1424 | 1468 | |
| 1425 | 1469 | /* traverse to the link node before drawing this viewport */ |
| 1426 | 1470 | /* check this is correct as this affects the rendering order */ |
| 1427 | | if (link_address != 0x01000000) |
| 1471 | if (link_address != 0x01000000 && link_address != 0) |
| 1428 | 1472 | draw_viewport(pri, link_address); |
| 1429 | 1473 | |
| 1430 | 1474 | /* skip if this isn't the right priority */ |
| r32558 | r32559 | |
| 1482 | 1526 | |
| 1483 | 1527 | poly_wait(m_poly, "real3d_traverse_display_list"); |
| 1484 | 1528 | } |
| 1529 | |
| 1530 | void model3_state::draw_3d_layer(bitmap_rgb32 &bitmap, const rectangle &cliprect) |
| 1531 | { |
| 1532 | int i, j; |
| 1533 | |
| 1534 | for (j = cliprect.min_y; j <= cliprect.max_y; ++j) |
| 1535 | { |
| 1536 | UINT32 *dst = &bitmap.pix32(j); |
| 1537 | UINT32 *src = &m_bitmap3d.pix32(j); |
| 1538 | |
| 1539 | for (i = cliprect.min_x; i <= cliprect.max_x; ++i) |
| 1540 | { |
| 1541 | if (src[i] & 0xff000000) |
| 1542 | { |
| 1543 | dst[i] = src[i]; |
| 1544 | } |
| 1545 | } |
| 1546 | } |
| 1547 | } |
| | No newline at end of file |
trunk/src/mame/video/m3raster.inc
| r32558 | r32559 | |
| 2 | 2 | { |
| 3 | 3 | const poly_extra_data *extra = (const poly_extra_data *)extradata; |
| 4 | 4 | const cached_texture *texture = extra->texture; |
| 5 | | bitmap_ind16 *destmap = (bitmap_ind16 *)dest; |
| 6 | | UINT16 *p = &destmap->pix16(scanline); |
| 5 | bitmap_rgb32 *destmap = (bitmap_rgb32 *)dest; |
| 6 | UINT32 *p = &destmap->pix32(scanline); |
| 7 | 7 | UINT32 *d = &extra->zbuffer->pix32(scanline); |
| 8 | 8 | float ooz = extent->param[0].start; |
| 9 | 9 | float uoz = extent->param[1].start; |
| r32558 | r32559 | |
| 34 | 34 | UINT32 pix10 = texture->data[(v2 << width) + u1]; |
| 35 | 35 | UINT32 pix11 = texture->data[(v2 << width) + u2]; |
| 36 | 36 | UINT32 texel = rgba_bilinear_filter(pix00, pix01, pix10, pix11, u, v); |
| 37 | | UINT32 fr = ((texel & 0x00ff0000) * polyi) >> (8+9); |
| 38 | | UINT32 fg = ((texel & 0x0000ff00) * polyi) >> (8+6); |
| 39 | | UINT32 fb = ((texel & 0x000000ff) * polyi) >> (8+3); |
| 40 | | p[x] = (fr & 0x7c00) | (fg & 0x3e0) | (fb & 0x1f); |
| 37 | UINT32 fr = ((texel & 0x00ff0000) * polyi) >> 8; |
| 38 | UINT32 fg = ((texel & 0x0000ff00) * polyi) >> 8; |
| 39 | UINT32 fb = ((texel & 0x000000ff) * polyi) >> 8; |
| 40 | p[x] = 0xff000000 | (fr & 0xff0000) | (fg & 0xff00) | (fb & 0xff); |
| 41 | 41 | d[x] = iz; |
| 42 | 42 | } |
| 43 | 43 | |
| r32558 | r32559 | |
| 51 | 51 | { |
| 52 | 52 | const poly_extra_data *extra = (const poly_extra_data *)extradata; |
| 53 | 53 | const cached_texture *texture = extra->texture; |
| 54 | | bitmap_ind16 *destmap = (bitmap_ind16 *)dest; |
| 55 | | UINT16 *p = &destmap->pix16(scanline); |
| 54 | bitmap_rgb32 *destmap = (bitmap_rgb32 *)dest; |
| 55 | UINT32 *p = &destmap->pix32(scanline); |
| 56 | 56 | UINT32 *d = &extra->zbuffer->pix32(scanline); |
| 57 | 57 | float ooz = extent->param[0].start; |
| 58 | 58 | float uoz = extent->param[1].start; |
| r32558 | r32559 | |
| 84 | 84 | UINT32 pix10 = texture->data[(v2 << width) + u1]; |
| 85 | 85 | UINT32 pix11 = texture->data[(v2 << width) + u2]; |
| 86 | 86 | UINT32 texel = rgba_bilinear_filter(pix00, pix01, pix10, pix11, u, v); |
| 87 | | UINT32 fr = ((texel & 0x00ff0000) * polyi) >> (8+9); |
| 88 | | UINT32 fg = ((texel & 0x0000ff00) * polyi) >> (8+6); |
| 89 | | UINT32 fb = ((texel & 0x000000ff) * polyi) >> (8+3); |
| 90 | | UINT16 orig = p[x]; |
| 91 | | fr += ((orig & 0x7c00) * desttrans) >> 5; |
| 92 | | fg += ((orig & 0x03e0) * desttrans) >> 5; |
| 93 | | fb += ((orig & 0x001f) * desttrans) >> 5; |
| 94 | | p[x] = (fr & 0x7c00) | (fg & 0x3e0) | (fb & 0x1f); |
| 87 | UINT32 fr = ((texel & 0x00ff0000) * polyi) >> 8; |
| 88 | UINT32 fg = ((texel & 0x0000ff00) * polyi) >> 8; |
| 89 | UINT32 fb = ((texel & 0x000000ff) * polyi) >> 8; |
| 90 | UINT32 orig = p[x]; |
| 91 | fr += ((orig & 0x00ff0000) * desttrans) >> 5; |
| 92 | fg += ((orig & 0x0000ff00) * desttrans) >> 5; |
| 93 | fb += ((orig & 0x000000ff) * desttrans) >> 5; |
| 94 | p[x] = 0xff000000 | (fr & 0xff0000) | (fg & 0xff00) | (fb & 0xff); |
| 95 | 95 | d[x] = iz; |
| 96 | 96 | } |
| 97 | 97 | |
| r32558 | r32559 | |
| 106 | 106 | { |
| 107 | 107 | const poly_extra_data *extra = (const poly_extra_data *)extradata; |
| 108 | 108 | const cached_texture *texture = extra->texture; |
| 109 | | bitmap_ind16 *destmap = (bitmap_ind16 *)dest; |
| 110 | | UINT16 *p = &destmap->pix16(scanline); |
| 109 | bitmap_rgb32 *destmap = (bitmap_rgb32 *)dest; |
| 110 | UINT32 *p = &destmap->pix32(scanline); |
| 111 | 111 | UINT32 *d = &extra->zbuffer->pix32(scanline); |
| 112 | 112 | float ooz = extent->param[0].start; |
| 113 | 113 | float uoz = extent->param[1].start; |
| r32558 | r32559 | |
| 146 | 146 | UINT32 fr = ((texel & 0x00ff0000) * combined) >> (8+9); |
| 147 | 147 | UINT32 fg = ((texel & 0x0000ff00) * combined) >> (8+6); |
| 148 | 148 | UINT32 fb = ((texel & 0x000000ff) * combined) >> (8+3); |
| 149 | | UINT16 orig = p[x]; |
| 149 | UINT32 orig = p[x]; |
| 150 | 150 | combined = ((255 - fa) * desttrans) >> 5; |
| 151 | | fr += ((orig & 0x7c00) * combined) >> 8; |
| 152 | | fg += ((orig & 0x03e0) * combined) >> 8; |
| 153 | | fb += ((orig & 0x001f) * combined) >> 8; |
| 154 | | p[x] = (fr & 0x7c00) | (fg & 0x3e0) | (fb & 0x1f); |
| 151 | fr += ((orig & 0x00ff0000) * combined) >> 8; |
| 152 | fg += ((orig & 0x0000ff00) * combined) >> 8; |
| 153 | fb += ((orig & 0x000000ff) * combined) >> 8; |
| 154 | p[x] = 0xff000000 | (fr & 0xff0000) | (fg & 0xff00) | (fb & 0xff); |
| 155 | 155 | d[x] = iz; |
| 156 | 156 | } |
| 157 | 157 | } |
| r32558 | r32559 | |
| 167 | 167 | { |
| 168 | 168 | const poly_extra_data *extra = (const poly_extra_data *)extradata; |
| 169 | 169 | const cached_texture *texture = extra->texture; |
| 170 | | bitmap_ind16 *destmap = (bitmap_ind16 *)dest; |
| 171 | | UINT16 *p = &destmap->pix16(scanline); |
| 170 | bitmap_rgb32 *destmap = (bitmap_rgb32 *)dest; |
| 171 | UINT32 *p = &destmap->pix32(scanline); |
| 172 | 172 | UINT32 *d = &extra->zbuffer->pix32(scanline); |
| 173 | 173 | float ooz = extent->param[0].start; |
| 174 | 174 | float uoz = extent->param[1].start; |
| r32558 | r32559 | |
| 207 | 207 | UINT32 fr = ((texel & 0x00ff0000) * combined) >> (8+9); |
| 208 | 208 | UINT32 fg = ((texel & 0x0000ff00) * combined) >> (8+6); |
| 209 | 209 | UINT32 fb = ((texel & 0x000000ff) * combined) >> (8+3); |
| 210 | | UINT16 orig = p[x]; |
| 210 | UINT32 orig = p[x]; |
| 211 | 211 | combined = ((255 - fa) * desttrans) >> 8; |
| 212 | | fr += ((orig & 0x7c00) * combined) >> 5; |
| 213 | | fg += ((orig & 0x03e0) * combined) >> 5; |
| 214 | | fb += ((orig & 0x001f) * combined) >> 5; |
| 215 | | p[x] = (fr & 0x7c00) | (fg & 0x3e0) | (fb & 0x1f); |
| 212 | fr += ((orig & 0x00ff0000) * combined) >> 5; |
| 213 | fg += ((orig & 0x0000ff00) * combined) >> 5; |
| 214 | fb += ((orig & 0x000000ff) * combined) >> 5; |
| 215 | p[x] = 0xff000000 | (fr & 0xff0000) | (fg & 0xff00) | (fb & 0xff); |
| 216 | 216 | d[x] = iz; |
| 217 | 217 | } |
| 218 | 218 | } |
| r32558 | r32559 | |
| 226 | 226 | static void draw_scanline_color(void *dest, INT32 scanline, const poly_extent *extent, const void *extradata, int threadid) |
| 227 | 227 | { |
| 228 | 228 | const poly_extra_data *extra = (const poly_extra_data *)extradata; |
| 229 | | bitmap_ind16 *destmap = (bitmap_ind16 *)dest; |
| 230 | | UINT16 *p = &destmap->pix16(scanline); |
| 229 | bitmap_rgb32 *destmap = (bitmap_rgb32 *)dest; |
| 230 | UINT32 *p = &destmap->pix32(scanline); |
| 231 | 231 | UINT32 *d = &extra->zbuffer->pix32(scanline); |
| 232 | 232 | float ooz = extent->param[0].start; |
| 233 | 233 | float doozdx = extent->param[0].dpdx; |
| 234 | | int fr = extra->color & 0x7c00; |
| 235 | | int fg = extra->color & 0x03e0; |
| 236 | | int fb = extra->color & 0x001f; |
| 234 | int fr = (extra->color & 0x7c00) << 9; |
| 235 | int fg = (extra->color & 0x03e0) << 6; |
| 236 | int fb = (extra->color & 0x001f) << 3; |
| 237 | 237 | int x; |
| 238 | 238 | |
| 239 | 239 | // apply intensity |
| r32558 | r32559 | |
| 272 | 272 | UINT32 iz = ooz * 256.0f; |
| 273 | 273 | if (iz > d[x]) |
| 274 | 274 | { |
| 275 | | UINT16 orig = p[x]; |
| 276 | | int r = fr + (((orig & 0x7c00) * polytrans) >> 5); |
| 277 | | int g = fg + (((orig & 0x03e0) * polytrans) >> 5); |
| 278 | | int b = fb + (((orig & 0x001f) * polytrans) >> 5); |
| 275 | UINT32 orig = p[x]; |
| 276 | int r = fr + (((orig & 0x00ff0000) * polytrans) >> 5); |
| 277 | int g = fg + (((orig & 0x0000ff00) * polytrans) >> 5); |
| 278 | int b = fb + (((orig & 0x000000ff) * polytrans) >> 5); |
| 279 | 279 | |
| 280 | | p[x] = (r & 0x7c00) | (g & 0x3e0) | (b & 0x1f); |
| 280 | p[x] = 0xff000000 | (r & 0xff0000) | (g & 0xff00) | (b & 0xff); |
| 281 | 281 | d[x] = iz; |
| 282 | 282 | } |
| 283 | 283 | ooz += doozdx; |