| | 1 | /* |
| | 2 | * Copyright (C) 2011 Gilead Kutnick "Exophase" <exophase@gmail.com> |
| | 3 | * |
| | 4 | * This program is free software; you can redistribute it and/or |
| | 5 | * modify it under the terms of the GNU General Public License as |
| | 6 | * published by the Free Software Foundation; either version 2 of |
| | 7 | * the License, or (at your option) any later version. |
| | 8 | * |
| | 9 | * This program is distributed in the hope that it will be useful, |
| | 10 | * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| | 11 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
| | 12 | * General Public License for more details. |
| | 13 | */ |
| | 14 | |
| | 15 | #include <stdio.h> |
| | 16 | #include <stdlib.h> |
| | 17 | #include <string.h> |
| | 18 | |
| | 19 | #include "common.h" |
| | 20 | |
| | 21 | u32 span_pixels = 0; |
| | 22 | u32 span_pixel_blocks = 0; |
| | 23 | u32 spans = 0; |
| | 24 | u32 triangles = 0; |
| | 25 | u32 sprites = 0; |
| | 26 | u32 sprites_4bpp = 0; |
| | 27 | u32 sprites_8bpp = 0; |
| | 28 | u32 sprites_16bpp = 0; |
| | 29 | u32 sprite_blocks = 0; |
| | 30 | u32 sprites_untextured = 0; |
| | 31 | u32 lines = 0; |
| | 32 | u32 trivial_rejects = 0; |
| | 33 | u32 texels_4bpp = 0; |
| | 34 | u32 texels_8bpp = 0; |
| | 35 | u32 texels_16bpp = 0; |
| | 36 | u32 texel_blocks_4bpp = 0; |
| | 37 | u32 texel_blocks_8bpp = 0; |
| | 38 | u32 texel_blocks_16bpp = 0; |
| | 39 | u32 texel_blocks_untextured = 0; |
| | 40 | u32 blend_blocks = 0; |
| | 41 | u32 render_buffer_flushes = 0; |
| | 42 | u32 state_changes = 0; |
| | 43 | u32 left_split_triangles = 0; |
| | 44 | u32 flat_triangles = 0; |
| | 45 | u32 clipped_triangles = 0; |
| | 46 | u32 zero_block_spans = 0; |
| | 47 | u32 texture_cache_loads = 0; |
| | 48 | u32 false_modulated_blocks = 0; |
| | 49 | |
| | 50 | /* double size for enhancement */ |
| | 51 | u32 reciprocal_table[512 * 2]; |
| | 52 | |
| | 53 | |
| | 54 | typedef s32 fixed_type; |
| | 55 | |
| | 56 | #define EDGE_STEP_BITS 32 |
| | 57 | #define FIXED_BITS 12 |
| | 58 | |
| | 59 | #define fixed_center(value) \ |
| | 60 | ((((fixed_type)(value)) << FIXED_BITS) + (1 << (FIXED_BITS - 1))) \ |
| | 61 | |
| | 62 | #define int_to_fixed(value) \ |
| | 63 | (((fixed_type)(value)) << FIXED_BITS) \ |
| | 64 | |
| | 65 | #define fixed_to_int(value) \ |
| | 66 | ((value) >> FIXED_BITS) \ |
| | 67 | |
| | 68 | #define fixed_to_double(value) \ |
| | 69 | ((value) / (double)(1 << FIXED_BITS)) \ |
| | 70 | |
| | 71 | #define double_to_fixed(value) \ |
| | 72 | (fixed_type)(((value) * (double)(1 << FIXED_BITS))) \ |
| | 73 | |
| | 74 | typedef void (setup_blocks_function_type)(psx_gpu_struct *psx_gpu); |
| | 75 | typedef void (texture_blocks_function_type)(psx_gpu_struct *psx_gpu); |
| | 76 | typedef void (shade_blocks_function_type)(psx_gpu_struct *psx_gpu); |
| | 77 | typedef void (blend_blocks_function_type)(psx_gpu_struct *psx_gpu); |
| | 78 | |
| | 79 | typedef void (setup_sprite_function_type)(psx_gpu_struct *psx_gpu, s32 x, |
| | 80 | s32 y, s32 u, s32 v, s32 width, s32 height, u32 color); |
| | 81 | |
| | 82 | struct render_block_handler_struct |
| | 83 | { |
| | 84 | void *setup_blocks; |
| | 85 | texture_blocks_function_type *texture_blocks; |
| | 86 | shade_blocks_function_type *shade_blocks; |
| | 87 | blend_blocks_function_type *blend_blocks; |
| | 88 | }; |
| | 89 | |
| | 90 | #ifndef NEON_BUILD |
| | 91 | |
| | 92 | u32 fixed_reciprocal(u32 denominator, u32 *_shift) |
| | 93 | { |
| | 94 | u32 shift = __builtin_clz(denominator); |
| | 95 | u32 denominator_normalized = denominator << shift; |
| | 96 | |
| | 97 | double numerator = (1ULL << 62) + denominator_normalized; |
| | 98 | double numerator_b; |
| | 99 | |
| | 100 | double denominator_normalized_dp_b; |
| | 101 | u64 denominator_normalized_dp_u64; |
| | 102 | |
| | 103 | u32 reciprocal; |
| | 104 | double reciprocal_dp; |
| | 105 | |
| | 106 | u64 numerator_u64 = (denominator_normalized >> 10) | |
| | 107 | ((u64)(62 + 1023) << 52); |
| | 108 | *((u64 *)(&numerator_b)) = numerator_u64; |
| | 109 | |
| | 110 | denominator_normalized_dp_u64 = |
| | 111 | (u64)(denominator_normalized << 21) | |
| | 112 | ((u64)((denominator_normalized >> 11) + ((1022 + 31) << 20)) << 32); |
| | 113 | *((u64 *)(&denominator_normalized_dp_b)) = denominator_normalized_dp_u64; |
| | 114 | |
| | 115 | // Implement with a DP divide |
| | 116 | reciprocal_dp = numerator / denominator_normalized_dp_b; |
| | 117 | reciprocal = reciprocal_dp; |
| | 118 | |
| | 119 | if(reciprocal == 0x80000001) |
| | 120 | reciprocal = 0x80000000; |
| | 121 | |
| | 122 | *_shift = 62 - shift; |
| | 123 | return reciprocal; |
| | 124 | } |
| | 125 | |
| | 126 | double reciprocal_estimate(double a) |
| | 127 | { |
| | 128 | int q, s; |
| | 129 | double r; |
| | 130 | |
| | 131 | q = (int)(a * 512.0); |
| | 132 | /* a in units of 1/512 rounded down */ |
| | 133 | r = 1.0 / (((double)q + 0.5) / 512.0); /* reciprocal r */ |
| | 134 | s = (int)(256.0 * r + 0.5); |
| | 135 | |
| | 136 | /* r in units of 1/256 rounded to nearest */ |
| | 137 | |
| | 138 | return (double)s / 256.0; |
| | 139 | } |
| | 140 | |
| | 141 | u32 reciprocal_estimate_u32(u32 value) |
| | 142 | { |
| | 143 | u64 dp_value_u64; |
| | 144 | volatile double dp_value; |
| | 145 | volatile u64 *dp_value_ptr = (volatile u64 *)&dp_value; |
| | 146 | |
| | 147 | if((value >> 31) == 0) |
| | 148 | return 0xFFFFFFFF; |
| | 149 | |
| | 150 | dp_value_u64 = (0x3FEULL << (31 + 21)) | ((u64)(value & 0x7FFFFFFF) << 21); |
| | 151 | |
| | 152 | *dp_value_ptr = dp_value_u64; |
| | 153 | |
| | 154 | dp_value = reciprocal_estimate(dp_value); |
| | 155 | dp_value_u64 = *dp_value_ptr; |
| | 156 | |
| | 157 | return (0x80000000 | ((dp_value_u64 >> 21) & 0x7FFFFFFF)); |
| | 158 | } |
| | 159 | |
| | 160 | u32 fixed_reciprocal_nr(u32 value, u32 *_shift) |
| | 161 | { |
| | 162 | u32 shift = __builtin_clz(value); |
| | 163 | u32 value_normalized = value << shift; |
| | 164 | |
| | 165 | *_shift = 62 - shift; |
| | 166 | |
| | 167 | value_normalized -= 2; |
| | 168 | |
| | 169 | u32 reciprocal_normalized = reciprocal_estimate_u32(value_normalized) >> 1; |
| | 170 | |
| | 171 | u32 temp = -(((u64)value_normalized * (u32)reciprocal_normalized) >> 31); |
| | 172 | reciprocal_normalized = (((u64)reciprocal_normalized * temp) >> 31); |
| | 173 | temp = -(((u64)value_normalized * (u32)reciprocal_normalized) >> 31); |
| | 174 | reciprocal_normalized = (((u64)reciprocal_normalized * temp) >> 31); |
| | 175 | temp = -(((u64)value_normalized * (u32)reciprocal_normalized) >> 31); |
| | 176 | reciprocal_normalized = (((u64)reciprocal_normalized * temp) >> 31); |
| | 177 | |
| | 178 | return reciprocal_normalized; |
| | 179 | } |
| | 180 | |
| | 181 | #endif |
| | 182 | |
| | 183 | |
| | 184 | s32 triangle_signed_area_x2(s32 x0, s32 y0, s32 x1, s32 y1, s32 x2, s32 y2) |
| | 185 | { |
| | 186 | return ((x1 - x0) * (y2 - y1)) - ((x2 - x1) * (y1 - y0)); |
| | 187 | } |
| | 188 | |
| | 189 | u32 texture_region_mask(s32 x1, s32 y1, s32 x2, s32 y2) |
| | 190 | { |
| | 191 | s32 coverage_x, coverage_y; |
| | 192 | |
| | 193 | u32 mask_up_left; |
| | 194 | u32 mask_down_right; |
| | 195 | |
| | 196 | coverage_x = x2 >> 6; |
| | 197 | coverage_y = y2 >> 8; |
| | 198 | |
| | 199 | if(coverage_x < 0) |
| | 200 | coverage_x = 0; |
| | 201 | |
| | 202 | if(coverage_x > 31) |
| | 203 | coverage_x = 31; |
| | 204 | |
| | 205 | mask_down_right = ~(0xFFFFFFFF << (coverage_x + 1)) & 0xFFFF; |
| | 206 | |
| | 207 | if(coverage_y >= 1) |
| | 208 | mask_down_right |= mask_down_right << 16; |
| | 209 | |
| | 210 | coverage_x = x1 >> 6; |
| | 211 | |
| | 212 | mask_up_left = 0xFFFF0000 << coverage_x; |
| | 213 | if(coverage_x < 0) |
| | 214 | mask_up_left = 0xFFFF0000; |
| | 215 | |
| | 216 | coverage_y = y1 >> 8; |
| | 217 | if(coverage_y <= 0) |
| | 218 | mask_up_left |= mask_up_left >> 16; |
| | 219 | |
| | 220 | return mask_up_left & mask_down_right; |
| | 221 | } |
| | 222 | |
| | 223 | u32 invalidate_texture_cache_region(psx_gpu_struct *psx_gpu, u32 x1, u32 y1, |
| | 224 | u32 x2, u32 y2) |
| | 225 | { |
| | 226 | u32 mask = texture_region_mask(x1, y1, x2, y2); |
| | 227 | |
| | 228 | psx_gpu->dirty_textures_4bpp_mask |= mask; |
| | 229 | psx_gpu->dirty_textures_8bpp_mask |= mask; |
| | 230 | psx_gpu->dirty_textures_8bpp_alternate_mask |= mask; |
| | 231 | |
| | 232 | return mask; |
| | 233 | } |
| | 234 | |
| | 235 | u32 invalidate_texture_cache_region_viewport(psx_gpu_struct *psx_gpu, u32 x1, |
| | 236 | u32 y1, u32 x2, u32 y2) |
| | 237 | { |
| | 238 | u32 mask = texture_region_mask(x1, y1, x2, y2) & |
| | 239 | psx_gpu->viewport_mask; |
| | 240 | |
| | 241 | psx_gpu->dirty_textures_4bpp_mask |= mask; |
| | 242 | psx_gpu->dirty_textures_8bpp_mask |= mask; |
| | 243 | psx_gpu->dirty_textures_8bpp_alternate_mask |= mask; |
| | 244 | |
| | 245 | return mask; |
| | 246 | } |
| | 247 | |
| | 248 | void update_texture_cache_region(psx_gpu_struct *psx_gpu, u32 x1, u32 y1, |
| | 249 | u32 x2, u32 y2) |
| | 250 | { |
| | 251 | u32 mask = texture_region_mask(x1, y1, x2, y2); |
| | 252 | u32 texture_page; |
| | 253 | u8 *texture_page_ptr; |
| | 254 | u16 *vram_ptr; |
| | 255 | u32 texel_block; |
| | 256 | u32 sub_x, sub_y; |
| | 257 | |
| | 258 | psx_gpu->dirty_textures_8bpp_mask |= mask; |
| | 259 | psx_gpu->dirty_textures_8bpp_alternate_mask |= mask; |
| | 260 | |
| | 261 | if ((psx_gpu->dirty_textures_4bpp_mask & mask) == 0 && |
| | 262 | (x1 & 3) == 0 && (y1 & 15) == 0 && x2 - x1 < 4 && y2 - y1 < 16) |
| | 263 | { |
| | 264 | texture_page = ((x1 / 64) & 15) + (y1 / 256) * 16; |
| | 265 | texture_page_ptr = psx_gpu->texture_4bpp_cache[texture_page]; |
| | 266 | texture_page_ptr += (x1 / 4 & 15) * 16*16 + (y1 / 16 & 15) * 16*16*16; |
| | 267 | vram_ptr = psx_gpu->vram_ptr + x1 + y1 * 1024; |
| | 268 | sub_x = 4; |
| | 269 | sub_y = 16; |
| | 270 | |
| | 271 | while(sub_y) |
| | 272 | { |
| | 273 | while(sub_x) |
| | 274 | { |
| | 275 | texel_block = *vram_ptr; |
| | 276 | |
| | 277 | texture_page_ptr[0] = texel_block & 0xF; |
| | 278 | texture_page_ptr[1] = (texel_block >> 4) & 0xF; |
| | 279 | texture_page_ptr[2] = (texel_block >> 8) & 0xF; |
| | 280 | texture_page_ptr[3] = texel_block >> 12; |
| | 281 | |
| | 282 | vram_ptr++; |
| | 283 | texture_page_ptr += 4; |
| | 284 | |
| | 285 | sub_x--; |
| | 286 | } |
| | 287 | |
| | 288 | vram_ptr -= 4; |
| | 289 | sub_x = 4; |
| | 290 | |
| | 291 | sub_y--; |
| | 292 | vram_ptr += 1024; |
| | 293 | } |
| | 294 | } |
| | 295 | else |
| | 296 | { |
| | 297 | psx_gpu->dirty_textures_4bpp_mask |= mask; |
| | 298 | } |
| | 299 | } |
| | 300 | |
| | 301 | void update_texture_8bpp_cache_slice(psx_gpu_struct *psx_gpu, |
| | 302 | u32 texture_page); |
| | 303 | |
| | 304 | #ifndef NEON_BUILD |
| | 305 | |
| | 306 | void update_texture_4bpp_cache(psx_gpu_struct *psx_gpu) |
| | 307 | { |
| | 308 | u32 current_texture_page = psx_gpu->current_texture_page; |
| | 309 | u8 *texture_page_ptr = psx_gpu->texture_page_base; |
| | 310 | u16 *vram_ptr = psx_gpu->vram_ptr; |
| | 311 | |
| | 312 | u32 texel_block; |
| | 313 | u32 tile_x, tile_y; |
| | 314 | u32 sub_x, sub_y; |
| | 315 | |
| | 316 | vram_ptr += (current_texture_page >> 4) * 256 * 1024; |
| | 317 | vram_ptr += (current_texture_page & 0xF) * 64; |
| | 318 | |
| | 319 | texture_cache_loads++; |
| | 320 | |
| | 321 | tile_y = 16; |
| | 322 | tile_x = 16; |
| | 323 | sub_x = 4; |
| | 324 | sub_y = 16; |
| | 325 | |
| | 326 | psx_gpu->dirty_textures_4bpp_mask &= ~(psx_gpu->current_texture_mask); |
| | 327 | |
| | 328 | while(tile_y) |
| | 329 | { |
| | 330 | while(tile_x) |
| | 331 | { |
| | 332 | while(sub_y) |
| | 333 | { |
| | 334 | while(sub_x) |
| | 335 | { |
| | 336 | texel_block = *vram_ptr; |
| | 337 | |
| | 338 | texture_page_ptr[0] = texel_block & 0xF; |
| | 339 | texture_page_ptr[1] = (texel_block >> 4) & 0xF; |
| | 340 | texture_page_ptr[2] = (texel_block >> 8) & 0xF; |
| | 341 | texture_page_ptr[3] = texel_block >> 12; |
| | 342 | |
| | 343 | vram_ptr++; |
| | 344 | texture_page_ptr += 4; |
| | 345 | |
| | 346 | sub_x--; |
| | 347 | } |
| | 348 | |
| | 349 | vram_ptr -= 4; |
| | 350 | sub_x = 4; |
| | 351 | |
| | 352 | sub_y--; |
| | 353 | vram_ptr += 1024; |
| | 354 | } |
| | 355 | |
| | 356 | sub_y = 16; |
| | 357 | |
| | 358 | vram_ptr -= (1024 * 16) - 4; |
| | 359 | tile_x--; |
| | 360 | } |
| | 361 | |
| | 362 | tile_x = 16; |
| | 363 | |
| | 364 | vram_ptr += (16 * 1024) - (4 * 16); |
| | 365 | tile_y--; |
| | 366 | } |
| | 367 | } |
| | 368 | |
| | 369 | void update_texture_8bpp_cache_slice(psx_gpu_struct *psx_gpu, |
| | 370 | u32 texture_page) |
| | 371 | { |
| | 372 | u16 *texture_page_ptr = psx_gpu->texture_page_base; |
| | 373 | u16 *vram_ptr = psx_gpu->vram_ptr; |
| | 374 | |
| | 375 | u32 tile_x, tile_y; |
| | 376 | u32 sub_y; |
| | 377 | |
| | 378 | vec_8x16u texels; |
| | 379 | |
| | 380 | texture_cache_loads++; |
| | 381 | |
| | 382 | vram_ptr += (texture_page >> 4) * 256 * 1024; |
| | 383 | vram_ptr += (texture_page & 0xF) * 64; |
| | 384 | |
| | 385 | if((texture_page ^ psx_gpu->current_texture_page) & 0x1) |
| | 386 | texture_page_ptr += (8 * 16) * 8; |
| | 387 | |
| | 388 | tile_x = 8; |
| | 389 | tile_y = 16; |
| | 390 | |
| | 391 | sub_y = 16; |
| | 392 | |
| | 393 | while(tile_y) |
| | 394 | { |
| | 395 | while(tile_x) |
| | 396 | { |
| | 397 | while(sub_y) |
| | 398 | { |
| | 399 | load_128b(texels, vram_ptr); |
| | 400 | store_128b(texels, texture_page_ptr); |
| | 401 | |
| | 402 | texture_page_ptr += 8; |
| | 403 | vram_ptr += 1024; |
| | 404 | |
| | 405 | sub_y--; |
| | 406 | } |
| | 407 | |
| | 408 | sub_y = 16; |
| | 409 | |
| | 410 | vram_ptr -= (1024 * 16); |
| | 411 | vram_ptr += 8; |
| | 412 | |
| | 413 | tile_x--; |
| | 414 | } |
| | 415 | |
| | 416 | tile_x = 8; |
| | 417 | |
| | 418 | vram_ptr -= (8 * 8); |
| | 419 | vram_ptr += (16 * 1024); |
| | 420 | |
| | 421 | texture_page_ptr += (8 * 16) * 8; |
| | 422 | tile_y--; |
| | 423 | } |
| | 424 | } |
| | 425 | |
| | 426 | #endif |
| | 427 | |
| | 428 | |
| | 429 | void update_texture_8bpp_cache(psx_gpu_struct *psx_gpu) |
| | 430 | { |
| | 431 | u32 current_texture_page = psx_gpu->current_texture_page; |
| | 432 | u32 update_textures = |
| | 433 | psx_gpu->dirty_textures_8bpp_mask & psx_gpu->current_texture_mask; |
| | 434 | |
| | 435 | psx_gpu->dirty_textures_8bpp_mask &= ~update_textures; |
| | 436 | |
| | 437 | if(update_textures & (1 << current_texture_page)) |
| | 438 | { |
| | 439 | update_texture_8bpp_cache_slice(psx_gpu, current_texture_page); |
| | 440 | update_textures &= ~(1 << current_texture_page); |
| | 441 | } |
| | 442 | |
| | 443 | if(update_textures) |
| | 444 | { |
| | 445 | u32 adjacent_texture_page = ((current_texture_page + 1) & 0xF) | |
| | 446 | (current_texture_page & 0x10); |
| | 447 | |
| | 448 | update_texture_8bpp_cache_slice(psx_gpu, adjacent_texture_page); |
| | 449 | } |
| | 450 | } |
| | 451 | |
| | 452 | void setup_blocks_shaded_untextured_undithered_unswizzled_indirect( |
| | 453 | psx_gpu_struct *psx_gpu); |
| | 454 | |
| | 455 | void flush_render_block_buffer(psx_gpu_struct *psx_gpu) |
| | 456 | { |
| | 457 | if((psx_gpu->render_mode & RENDER_INTERLACE_ENABLED) && |
| | 458 | (psx_gpu->primitive_type == PRIMITIVE_TYPE_SPRITE)) |
| | 459 | { |
| | 460 | u32 num_blocks_dest = 0; |
| | 461 | block_struct *block_src = psx_gpu->blocks; |
| | 462 | block_struct *block_dest = psx_gpu->blocks; |
| | 463 | |
| | 464 | u16 *vram_ptr = psx_gpu->vram_ptr; |
| | 465 | u32 i; |
| | 466 | |
| | 467 | if(psx_gpu->render_mode & RENDER_INTERLACE_ODD) |
| | 468 | { |
| | 469 | for(i = 0; i < psx_gpu->num_blocks; i++) |
| | 470 | { |
| | 471 | u32 fb_offset = (u32)((u8 *)block_src->fb_ptr - (u8 *)vram_ptr); |
| | 472 | if(fb_offset & (1 << 11)) |
| | 473 | { |
| | 474 | *block_dest = *block_src; |
| | 475 | num_blocks_dest++; |
| | 476 | block_dest++; |
| | 477 | } |
| | 478 | block_src++; |
| | 479 | } |
| | 480 | } |
| | 481 | else |
| | 482 | { |
| | 483 | for(i = 0; i < psx_gpu->num_blocks; i++) |
| | 484 | { |
| | 485 | u32 fb_offset = (u32)((u8 *)block_src->fb_ptr - (u8 *)vram_ptr); |
| | 486 | if((fb_offset & (1 << 11)) == 0) |
| | 487 | { |
| | 488 | *block_dest = *block_src; |
| | 489 | num_blocks_dest++; |
| | 490 | block_dest++; |
| | 491 | } |
| | 492 | block_src++; |
| | 493 | } |
| | 494 | } |
| | 495 | |
| | 496 | psx_gpu->num_blocks = num_blocks_dest; |
| | 497 | } |
| | 498 | |
| | 499 | if(psx_gpu->num_blocks) |
| | 500 | { |
| | 501 | render_block_handler_struct *render_block_handler = |
| | 502 | psx_gpu->render_block_handler; |
| | 503 | |
| | 504 | render_block_handler->texture_blocks(psx_gpu); |
| | 505 | render_block_handler->shade_blocks(psx_gpu); |
| | 506 | render_block_handler->blend_blocks(psx_gpu); |
| | 507 | |
| | 508 | #ifdef PROFILE |
| | 509 | span_pixel_blocks += psx_gpu->num_blocks; |
| | 510 | render_buffer_flushes++; |
| | 511 | #endif |
| | 512 | |
| | 513 | psx_gpu->num_blocks = 0; |
| | 514 | } |
| | 515 | } |
| | 516 | |
| | 517 | |
| | 518 | void compute_all_gradients(psx_gpu_struct *psx_gpu, vertex_struct *a, |
| | 519 | vertex_struct *b, vertex_struct *c); |
| | 520 | |
| | 521 | #ifndef NEON_BUILD |
| | 522 | |
| | 523 | #define setup_gradient_calculation_input(set, vertex) \ |
| | 524 | /* First type is: uvrg bxxx xxxx */\ |
| | 525 | /* Second type is: yyyy ybyy uvrg */\ |
| | 526 | /* Since x_a and y_c are the same the same variable is used for both. */\ |
| | 527 | x##set##_a_y##set##_c.e[0] = vertex->u; \ |
| | 528 | x##set##_a_y##set##_c.e[1] = vertex->v; \ |
| | 529 | x##set##_a_y##set##_c.e[2] = vertex->r; \ |
| | 530 | x##set##_a_y##set##_c.e[3] = vertex->g; \ |
| | 531 | dup_4x16b(x##set##_b, vertex->x); \ |
| | 532 | dup_4x16b(x##set##_c, vertex->x); \ |
| | 533 | dup_4x16b(y##set##_a, vertex->y); \ |
| | 534 | dup_4x16b(y##set##_b, vertex->y); \ |
| | 535 | x##set##_b.e[0] = vertex->b; \ |
| | 536 | y##set##_b.e[1] = vertex->b \ |
| | 537 | |
| | 538 | |
| | 539 | void compute_all_gradients(psx_gpu_struct *psx_gpu, vertex_struct *a, |
| | 540 | vertex_struct *b, vertex_struct *c) |
| | 541 | { |
| | 542 | u32 triangle_area = psx_gpu->triangle_area; |
| | 543 | u32 winding_mask_scalar; |
| | 544 | |
| | 545 | u32 triangle_area_shift; |
| | 546 | u64 triangle_area_reciprocal = |
| | 547 | fixed_reciprocal(triangle_area, &triangle_area_shift); |
| | 548 | triangle_area_shift = -(triangle_area_shift - FIXED_BITS); |
| | 549 | |
| | 550 | // ((x1 - x0) * (y2 - y1)) - ((x2 - x1) * (y1 - y0)) = |
| | 551 | // ( d0 * d1 ) - ( d2 * d3 ) = |
| | 552 | // ( m0 ) - ( m1 ) = gradient |
| | 553 | |
| | 554 | // This is split to do 12 elements at a time over three sets: a, b, and c. |
| | 555 | // Technically we only need to do 10 elements (uvrgb_x and uvrgb_y), so |
| | 556 | // two of the slots are unused. |
| | 557 | |
| | 558 | // Inputs are all 16-bit signed. The m0/m1 results are 32-bit signed, as |
| | 559 | // is g. |
| | 560 | |
| | 561 | vec_4x16s x0_a_y0_c, x0_b, x0_c; |
| | 562 | vec_4x16s y0_a, y0_b; |
| | 563 | vec_4x16s x1_a_y1_c, x1_b, x1_c; |
| | 564 | vec_4x16s y1_a, y1_b; |
| | 565 | vec_4x16s x2_a_y2_c, x2_b, x2_c; |
| | 566 | vec_4x16s y2_a, y2_b; |
| | 567 | |
| | 568 | vec_4x32u uvrg_base; |
| | 569 | vec_4x32u b_base; |
| | 570 | vec_4x32u uvrgb_phase; |
| | 571 | |
| | 572 | vec_4x16s d0_a_d3_c, d0_b, d0_c; |
| | 573 | vec_4x16s d1_a, d1_b, d1_c_d2_a; |
| | 574 | vec_4x16s d2_b, d2_c; |
| | 575 | vec_4x16s d3_a, d3_b; |
| | 576 | |
| | 577 | vec_4x32s m0_a, m0_b, m0_c; |
| | 578 | vec_4x32s m1_a, m1_b, m1_c; |
| | 579 | |
| | 580 | vec_4x32u gradient_area_a, gradient_area_c; |
| | 581 | vec_2x32u gradient_area_b; |
| | 582 | |
| | 583 | vec_4x32u gradient_area_sign_a, gradient_area_sign_c; |
| | 584 | vec_2x32u gradient_area_sign_b; |
| | 585 | vec_4x32u winding_mask; |
| | 586 | |
| | 587 | vec_2x64u gradient_wide_a0, gradient_wide_a1; |
| | 588 | vec_2x64u gradient_wide_c0, gradient_wide_c1; |
| | 589 | vec_2x64u gradient_wide_b; |
| | 590 | |
| | 591 | vec_4x32u gradient_a, gradient_c; |
| | 592 | vec_2x32u gradient_b; |
| | 593 | vec_16x8s gradient_shift; |
| | 594 | |
| | 595 | setup_gradient_calculation_input(0, a); |
| | 596 | setup_gradient_calculation_input(1, b); |
| | 597 | setup_gradient_calculation_input(2, c); |
| | 598 | |
| | 599 | dup_4x32b(uvrgb_phase, psx_gpu->uvrgb_phase); |
| | 600 | shl_long_4x16b(uvrg_base, x0_a_y0_c, 16); |
| | 601 | shl_long_4x16b(b_base, x0_b, 16); |
| | 602 | |
| | 603 | add_4x32b(uvrg_base, uvrg_base, uvrgb_phase); |
| | 604 | add_4x32b(b_base, b_base, uvrgb_phase); |
| | 605 | |
| | 606 | // Can probably pair these, but it'll require careful register allocation |
| | 607 | sub_4x16b(d0_a_d3_c, x1_a_y1_c, x0_a_y0_c); |
| | 608 | sub_4x16b(d1_c_d2_a, x2_a_y2_c, x1_a_y1_c); |
| | 609 | |
| | 610 | sub_4x16b(d0_b, x1_b, x0_b); |
| | 611 | sub_4x16b(d0_c, x1_c, x0_c); |
| | 612 | |
| | 613 | sub_4x16b(d1_a, y2_a, y1_a); |
| | 614 | sub_4x16b(d1_b, y2_b, y1_b); |
| | 615 | |
| | 616 | sub_4x16b(d2_b, x2_b, x1_b); |
| | 617 | sub_4x16b(d2_c, x2_c, x1_c); |
| | 618 | |
| | 619 | sub_4x16b(d3_a, y1_a, y0_a); |
| | 620 | sub_4x16b(d3_b, y1_b, y0_b); |
| | 621 | |
| | 622 | mul_long_4x16b(m0_a, d0_a_d3_c, d1_a); |
| | 623 | mul_long_4x16b(m0_b, d0_b, d1_b); |
| | 624 | mul_long_4x16b(m0_c, d0_c, d1_c_d2_a); |
| | 625 | |
| | 626 | mul_long_4x16b(m1_a, d1_c_d2_a, d3_a); |
| | 627 | mul_long_4x16b(m1_b, d2_b, d3_b); |
| | 628 | mul_long_4x16b(m1_c, d2_c, d0_a_d3_c); |
| | 629 | |
| | 630 | sub_4x32b(gradient_area_a, m0_a, m1_a); |
| | 631 | sub_2x32b(gradient_area_b, m0_b.low, m1_b.low); |
| | 632 | sub_4x32b(gradient_area_c, m0_c, m1_c); |
| | 633 | |
| | 634 | cmpltz_4x32b(gradient_area_sign_a, gradient_area_a); |
| | 635 | cmpltz_2x32b(gradient_area_sign_b, gradient_area_b); |
| | 636 | cmpltz_4x32b(gradient_area_sign_c, gradient_area_c); |
| | 637 | |
| | 638 | abs_4x32b(gradient_area_a, gradient_area_a); |
| | 639 | abs_2x32b(gradient_area_b, gradient_area_b); |
| | 640 | abs_4x32b(gradient_area_c, gradient_area_c); |
| | 641 | |
| | 642 | winding_mask_scalar = -psx_gpu->triangle_winding; |
| | 643 | |
| | 644 | dup_4x32b(winding_mask, winding_mask_scalar); |
| | 645 | eor_4x32b(gradient_area_sign_a, gradient_area_sign_a, winding_mask); |
| | 646 | eor_2x32b(gradient_area_sign_b, gradient_area_sign_b, winding_mask); |
| | 647 | eor_4x32b(gradient_area_sign_c, gradient_area_sign_c, winding_mask); |
| | 648 | |
| | 649 | mul_scalar_long_2x32b(gradient_wide_a0, |
| | 650 | vector_cast(vec_2x32s, gradient_area_a.low), |
| | 651 | (s64)triangle_area_reciprocal); |
| | 652 | mul_scalar_long_2x32b(gradient_wide_a1, |
| | 653 | vector_cast(vec_2x32s, gradient_area_a.high), |
| | 654 | (s64)triangle_area_reciprocal); |
| | 655 | mul_scalar_long_2x32b(gradient_wide_b, |
| | 656 | vector_cast(vec_2x32s, gradient_area_b), |
| | 657 | (s64)triangle_area_reciprocal); |
| | 658 | mul_scalar_long_2x32b(gradient_wide_c0, |
| | 659 | vector_cast(vec_2x32s, gradient_area_c.low), |
| | 660 | (s64)triangle_area_reciprocal); |
| | 661 | mul_scalar_long_2x32b(gradient_wide_c1, |
| | 662 | vector_cast(vec_2x32s, gradient_area_c.high), |
| | 663 | (s64)triangle_area_reciprocal); |
| | 664 | |
| | 665 | dup_16x8b(gradient_shift, triangle_area_shift); |
| | 666 | shl_reg_2x64b(gradient_wide_a0, gradient_wide_a0, |
| | 667 | vector_cast(vec_2x64u, gradient_shift)); |
| | 668 | shl_reg_2x64b(gradient_wide_a1, gradient_wide_a1, |
| | 669 | vector_cast(vec_2x64u, gradient_shift)); |
| | 670 | shl_reg_2x64b(gradient_wide_b, gradient_wide_b, |
| | 671 | vector_cast(vec_2x64u, gradient_shift)); |
| | 672 | shl_reg_2x64b(gradient_wide_c0, gradient_wide_c0, |
| | 673 | vector_cast(vec_2x64u, gradient_shift)); |
| | 674 | shl_reg_2x64b(gradient_wide_c1, gradient_wide_c1, |
| | 675 | vector_cast(vec_2x64u, gradient_shift)); |
| | 676 | |
| | 677 | mov_narrow_2x64b(gradient_a.low, gradient_wide_a0); |
| | 678 | mov_narrow_2x64b(gradient_a.high, gradient_wide_a1); |
| | 679 | mov_narrow_2x64b(gradient_b, gradient_wide_b); |
| | 680 | mov_narrow_2x64b(gradient_c.low, gradient_wide_c0); |
| | 681 | mov_narrow_2x64b(gradient_c.high, gradient_wide_c1); |
| | 682 | |
| | 683 | shl_4x32b(gradient_a, gradient_a, 4); |
| | 684 | shl_2x32b(gradient_b, gradient_b, 4); |
| | 685 | shl_4x32b(gradient_c, gradient_c, 4); |
| | 686 | |
| | 687 | eor_4x32b(gradient_a, gradient_a, gradient_area_sign_a); |
| | 688 | eor_2x32b(gradient_b, gradient_b, gradient_area_sign_b); |
| | 689 | eor_4x32b(gradient_c, gradient_c, gradient_area_sign_c); |
| | 690 | |
| | 691 | sub_4x32b(gradient_a, gradient_a, gradient_area_sign_a); |
| | 692 | sub_2x32b(gradient_b, gradient_b, gradient_area_sign_b); |
| | 693 | sub_4x32b(gradient_c, gradient_c, gradient_area_sign_c); |
| | 694 | |
| | 695 | u32 left_adjust = a->x; |
| | 696 | mls_scalar_4x32b(uvrg_base, gradient_a, left_adjust); |
| | 697 | mls_scalar_2x32b(b_base.low, gradient_b, left_adjust); |
| | 698 | |
| | 699 | vec_4x32u uvrg_dx2; |
| | 700 | vec_2x32u b_dx2; |
| | 701 | |
| | 702 | vec_4x32u uvrg_dx3; |
| | 703 | vec_2x32u b_dx3; |
| | 704 | |
| | 705 | vec_4x32u zero; |
| | 706 | |
| | 707 | eor_4x32b(zero, zero, zero); |
| | 708 | add_4x32b(uvrg_dx2, gradient_a, gradient_a); |
| | 709 | add_2x32b(b_dx2, gradient_b, gradient_b); |
| | 710 | add_4x32b(uvrg_dx3, gradient_a, uvrg_dx2); |
| | 711 | add_2x32b(b_dx3, gradient_b, b_dx2); |
| | 712 | |
| | 713 | // Can be done with vst4, assuming that the zero, dx, dx2, and dx3 are |
| | 714 | // lined up properly |
| | 715 | psx_gpu->u_block_span.e[0] = zero.e[0]; |
| | 716 | psx_gpu->u_block_span.e[1] = gradient_a.e[0]; |
| | 717 | psx_gpu->u_block_span.e[2] = uvrg_dx2.e[0]; |
| | 718 | psx_gpu->u_block_span.e[3] = uvrg_dx3.e[0]; |
| | 719 | |
| | 720 | psx_gpu->v_block_span.e[0] = zero.e[1]; |
| | 721 | psx_gpu->v_block_span.e[1] = gradient_a.e[1]; |
| | 722 | psx_gpu->v_block_span.e[2] = uvrg_dx2.e[1]; |
| | 723 | psx_gpu->v_block_span.e[3] = uvrg_dx3.e[1]; |
| | 724 | |
| | 725 | psx_gpu->r_block_span.e[0] = zero.e[2]; |
| | 726 | psx_gpu->r_block_span.e[1] = gradient_a.e[2]; |
| | 727 | psx_gpu->r_block_span.e[2] = uvrg_dx2.e[2]; |
| | 728 | psx_gpu->r_block_span.e[3] = uvrg_dx3.e[2]; |
| | 729 | |
| | 730 | psx_gpu->g_block_span.e[0] = zero.e[3]; |
| | 731 | psx_gpu->g_block_span.e[1] = gradient_a.e[3]; |
| | 732 | psx_gpu->g_block_span.e[2] = uvrg_dx2.e[3]; |
| | 733 | psx_gpu->g_block_span.e[3] = uvrg_dx3.e[3]; |
| | 734 | |
| | 735 | psx_gpu->b_block_span.e[0] = zero.e[0]; |
| | 736 | psx_gpu->b_block_span.e[1] = gradient_b.e[0]; |
| | 737 | psx_gpu->b_block_span.e[2] = b_dx2.e[0]; |
| | 738 | psx_gpu->b_block_span.e[3] = b_dx3.e[0]; |
| | 739 | |
| | 740 | psx_gpu->uvrg = uvrg_base; |
| | 741 | psx_gpu->b = b_base.e[0]; |
| | 742 | |
| | 743 | psx_gpu->uvrg_dx = gradient_a; |
| | 744 | psx_gpu->uvrg_dy = gradient_c; |
| | 745 | psx_gpu->b_dy = gradient_b.e[1]; |
| | 746 | } |
| | 747 | #endif |
| | 748 | |
| | 749 | #define vector_check(_a, _b) \ |
| | 750 | if(memcmp(&_a, &_b, sizeof(_b))) \ |
| | 751 | { \ |
| | 752 | if(sizeof(_b) == 8) \ |
| | 753 | { \ |
| | 754 | printf("mismatch on %s vs %s: (%x %x) vs (%x %x)\n", \ |
| | 755 | #_a, #_b, _a.e[0], _a.e[1], _b.e[0], _b.e[1]); \ |
| | 756 | } \ |
| | 757 | else \ |
| | 758 | { \ |
| | 759 | printf("mismatch on %s vs %s: (%x %x %x %x) vs (%x %x %x %x)\n", \ |
| | 760 | #_a, #_b, _a.e[0], _a.e[1], _a.e[2], _a.e[3], _b.e[0], _b.e[1], \ |
| | 761 | _b.e[2], _b.e[3]); \ |
| | 762 | } \ |
| | 763 | } \ |
| | 764 | |
| | 765 | #define scalar_check(_a, _b) \ |
| | 766 | if(_a != _b) \ |
| | 767 | printf("mismatch on %s %s: %x vs %x\n", #_a, #_b, _a, _b) \ |
| | 768 | |
| | 769 | |
| | 770 | #define setup_spans_prologue_alternate_yes() \ |
| | 771 | vec_2x64s alternate_x; \ |
| | 772 | vec_2x64s alternate_dx_dy; \ |
| | 773 | vec_4x32s alternate_x_32; \ |
| | 774 | vec_2x32s alternate_x_16; \ |
| | 775 | \ |
| | 776 | vec_4x16u alternate_select; \ |
| | 777 | vec_4x16s y_mid_point; \ |
| | 778 | \ |
| | 779 | s32 y_b = v_b->y; \ |
| | 780 | s64 edge_alt; \ |
| | 781 | s32 edge_dx_dy_alt; \ |
| | 782 | u32 edge_shift_alt \ |
| | 783 | |
| | 784 | #define setup_spans_prologue_alternate_no() \ |
| | 785 | |
| | 786 | #define setup_spans_prologue(alternate_active) \ |
| | 787 | edge_data_struct *span_edge_data; \ |
| | 788 | vec_4x32u *span_uvrg_offset; \ |
| | 789 | u32 *span_b_offset; \ |
| | 790 | \ |
| | 791 | s32 clip; \ |
| | 792 | \ |
| | 793 | vec_2x64s edges_xy; \ |
| | 794 | vec_2x32s edges_dx_dy; \ |
| | 795 | vec_2x32u edge_shifts; \ |
| | 796 | \ |
| | 797 | vec_2x64s left_x, right_x; \ |
| | 798 | vec_2x64s left_dx_dy, right_dx_dy; \ |
| | 799 | vec_4x32s left_x_32, right_x_32; \ |
| | 800 | vec_8x16s left_right_x_16; \ |
| | 801 | vec_4x16s y_x4; \ |
| | 802 | vec_8x16s left_edge; \ |
| | 803 | vec_8x16s right_edge; \ |
| | 804 | vec_4x16u span_shift; \ |
| | 805 | \ |
| | 806 | vec_2x32u c_0x01; \ |
| | 807 | vec_4x16u c_0x04; \ |
| | 808 | vec_4x16u c_0xFFFE; \ |
| | 809 | vec_4x16u c_0x07; \ |
| | 810 | \ |
| | 811 | vec_2x32s x_starts; \ |
| | 812 | vec_2x32s x_ends; \ |
| | 813 | \ |
| | 814 | s32 x_a = v_a->x; \ |
| | 815 | s32 x_b = v_b->x; \ |
| | 816 | s32 x_c = v_c->x; \ |
| | 817 | s32 y_a = v_a->y; \ |
| | 818 | s32 y_c = v_c->y; \ |
| | 819 | \ |
| | 820 | vec_4x32u uvrg = psx_gpu->uvrg; \ |
| | 821 | vec_4x32u uvrg_dy = psx_gpu->uvrg_dy; \ |
| | 822 | u32 b = psx_gpu->b; \ |
| | 823 | u32 b_dy = psx_gpu->b_dy; \ |
| | 824 | \ |
| | 825 | dup_2x32b(c_0x01, 0x01); \ |
| | 826 | setup_spans_prologue_alternate_##alternate_active() \ |
| | 827 | |
| | 828 | #define setup_spans_prologue_b() \ |
| | 829 | span_edge_data = psx_gpu->span_edge_data; \ |
| | 830 | span_uvrg_offset = psx_gpu->span_uvrg_offset; \ |
| | 831 | span_b_offset = psx_gpu->span_b_offset; \ |
| | 832 | \ |
| | 833 | vec_8x16u c_0x0001; \ |
| | 834 | \ |
| | 835 | dup_8x16b(c_0x0001, 0x0001); \ |
| | 836 | dup_8x16b(left_edge, psx_gpu->viewport_start_x); \ |
| | 837 | dup_8x16b(right_edge, psx_gpu->viewport_end_x); \ |
| | 838 | add_8x16b(right_edge, right_edge, c_0x0001); \ |
| | 839 | dup_4x16b(c_0x04, 0x04); \ |
| | 840 | dup_4x16b(c_0x07, 0x07); \ |
| | 841 | dup_4x16b(c_0xFFFE, 0xFFFE); \ |
| | 842 | |
| | 843 | |
| | 844 | #define compute_edge_delta_x2() \ |
| | 845 | { \ |
| | 846 | vec_2x32s heights; \ |
| | 847 | vec_2x32s height_reciprocals; \ |
| | 848 | vec_2x32s heights_b; \ |
| | 849 | vec_4x32u widths; \ |
| | 850 | \ |
| | 851 | u32 edge_shift = reciprocal_table[height]; \ |
| | 852 | \ |
| | 853 | dup_2x32b(heights, height); \ |
| | 854 | sub_2x32b(widths, x_ends, x_starts); \ |
| | 855 | \ |
| | 856 | dup_2x32b(edge_shifts, edge_shift); \ |
| | 857 | sub_2x32b(heights_b, heights, c_0x01); \ |
| | 858 | shr_2x32b(height_reciprocals, edge_shifts, 10); \ |
| | 859 | \ |
| | 860 | mla_2x32b(heights_b, x_starts, heights); \ |
| | 861 | bic_immediate_4x16b(vector_cast(vec_4x16u, edge_shifts), 0xE0); \ |
| | 862 | mul_2x32b(edges_dx_dy, widths, height_reciprocals); \ |
| | 863 | mul_long_2x32b(edges_xy, heights_b, height_reciprocals); \ |
| | 864 | } \ |
| | 865 | |
| | 866 | #define compute_edge_delta_x3(start_c, height_a, height_b) \ |
| | 867 | { \ |
| | 868 | vec_2x32s heights; \ |
| | 869 | vec_2x32s height_reciprocals; \ |
| | 870 | vec_2x32s heights_b; \ |
| | 871 | vec_2x32u widths; \ |
| | 872 | \ |
| | 873 | u32 width_alt; \ |
| | 874 | s32 height_b_alt; \ |
| | 875 | u32 height_reciprocal_alt; \ |
| | 876 | \ |
| | 877 | heights.e[0] = height_a; \ |
| | 878 | heights.e[1] = height_b; \ |
| | 879 | \ |
| | 880 | edge_shifts.e[0] = reciprocal_table[height_a]; \ |
| | 881 | edge_shifts.e[1] = reciprocal_table[height_b]; \ |
| | 882 | edge_shift_alt = reciprocal_table[height_minor_b]; \ |
| | 883 | \ |
| | 884 | sub_2x32b(widths, x_ends, x_starts); \ |
| | 885 | width_alt = x_c - start_c; \ |
| | 886 | \ |
| | 887 | shr_2x32b(height_reciprocals, edge_shifts, 10); \ |
| | 888 | height_reciprocal_alt = edge_shift_alt >> 10; \ |
| | 889 | \ |
| | 890 | bic_immediate_4x16b(vector_cast(vec_4x16u, edge_shifts), 0xE0); \ |
| | 891 | edge_shift_alt &= 0x1F; \ |
| | 892 | \ |
| | 893 | sub_2x32b(heights_b, heights, c_0x01); \ |
| | 894 | height_b_alt = height_minor_b - 1; \ |
| | 895 | \ |
| | 896 | mla_2x32b(heights_b, x_starts, heights); \ |
| | 897 | height_b_alt += height_minor_b * start_c; \ |
| | 898 | \ |
| | 899 | mul_long_2x32b(edges_xy, heights_b, height_reciprocals); \ |
| | 900 | edge_alt = (s64)height_b_alt * height_reciprocal_alt; \ |
| | 901 | \ |
| | 902 | mul_2x32b(edges_dx_dy, widths, height_reciprocals); \ |
| | 903 | edge_dx_dy_alt = width_alt * height_reciprocal_alt; \ |
| | 904 | } \ |
| | 905 | |
| | 906 | |
| | 907 | #define setup_spans_adjust_y_up() \ |
| | 908 | sub_4x32b(y_x4, y_x4, c_0x04) \ |
| | 909 | |
| | 910 | #define setup_spans_adjust_y_down() \ |
| | 911 | add_4x32b(y_x4, y_x4, c_0x04) \ |
| | 912 | |
| | 913 | #define setup_spans_adjust_interpolants_up() \ |
| | 914 | sub_4x32b(uvrg, uvrg, uvrg_dy); \ |
| | 915 | b -= b_dy \ |
| | 916 | |
| | 917 | #define setup_spans_adjust_interpolants_down() \ |
| | 918 | add_4x32b(uvrg, uvrg, uvrg_dy); \ |
| | 919 | b += b_dy \ |
| | 920 | |
| | 921 | |
| | 922 | #define setup_spans_clip_interpolants_increment() \ |
| | 923 | mla_scalar_4x32b(uvrg, uvrg_dy, clip); \ |
| | 924 | b += b_dy * clip \ |
| | 925 | |
| | 926 | #define setup_spans_clip_interpolants_decrement() \ |
| | 927 | mls_scalar_4x32b(uvrg, uvrg_dy, clip); \ |
| | 928 | b -= b_dy * clip \ |
| | 929 | |
| | 930 | #define setup_spans_clip_alternate_yes() \ |
| | 931 | edge_alt += edge_dx_dy_alt * (s64)(clip) \ |
| | 932 | |
| | 933 | #define setup_spans_clip_alternate_no() \ |
| | 934 | |
| | 935 | #define setup_spans_clip(direction, alternate_active) \ |
| | 936 | { \ |
| | 937 | clipped_triangles++; \ |
| | 938 | mla_scalar_long_2x32b(edges_xy, edges_dx_dy, (s64)clip); \ |
| | 939 | setup_spans_clip_alternate_##alternate_active(); \ |
| | 940 | setup_spans_clip_interpolants_##direction(); \ |
| | 941 | } \ |
| | 942 | |
| | 943 | |
| | 944 | #define setup_spans_adjust_edges_alternate_no(left_index, right_index) \ |
| | 945 | { \ |
| | 946 | vec_2x64u edge_shifts_64; \ |
| | 947 | vec_2x64s edges_dx_dy_64; \ |
| | 948 | \ |
| | 949 | mov_wide_2x32b(edge_shifts_64, edge_shifts); \ |
| | 950 | shl_variable_2x64b(edges_xy, edges_xy, edge_shifts_64); \ |
| | 951 | \ |
| | 952 | mov_wide_2x32b(edges_dx_dy_64, edges_dx_dy); \ |
| | 953 | shl_variable_2x64b(edges_dx_dy_64, edges_dx_dy_64, edge_shifts_64); \ |
| | 954 | \ |
| | 955 | left_x.e[0] = edges_xy.e[left_index]; \ |
| | 956 | right_x.e[0] = edges_xy.e[right_index]; \ |
| | 957 | \ |
| | 958 | left_dx_dy.e[0] = edges_dx_dy_64.e[left_index]; \ |
| | 959 | left_dx_dy.e[1] = edges_dx_dy_64.e[left_index]; \ |
| | 960 | right_dx_dy.e[0] = edges_dx_dy_64.e[right_index]; \ |
| | 961 | right_dx_dy.e[1] = edges_dx_dy_64.e[right_index]; \ |
| | 962 | \ |
| | 963 | add_1x64b(left_x.high, left_x.low, left_dx_dy.low); \ |
| | 964 | add_1x64b(right_x.high, right_x.low, right_dx_dy.low); \ |
| | 965 | \ |
| | 966 | add_2x64b(left_dx_dy, left_dx_dy, left_dx_dy); \ |
| | 967 | add_2x64b(right_dx_dy, right_dx_dy, right_dx_dy); \ |
| | 968 | } \ |
| | 969 | |
| | 970 | #define setup_spans_adjust_edges_alternate_yes(left_index, right_index) \ |
| | 971 | { \ |
| | 972 | setup_spans_adjust_edges_alternate_no(left_index, right_index); \ |
| | 973 | s64 edge_dx_dy_alt_64; \ |
| | 974 | \ |
| | 975 | dup_4x16b(y_mid_point, y_b); \ |
| | 976 | \ |
| | 977 | edge_alt <<= edge_shift_alt; \ |
| | 978 | edge_dx_dy_alt_64 = (s64)edge_dx_dy_alt << edge_shift_alt; \ |
| | 979 | \ |
| | 980 | alternate_x.e[0] = edge_alt; \ |
| | 981 | alternate_dx_dy.e[0] = edge_dx_dy_alt_64; \ |
| | 982 | alternate_dx_dy.e[1] = edge_dx_dy_alt_64; \ |
| | 983 | \ |
| | 984 | add_1x64b(alternate_x.high, alternate_x.low, alternate_dx_dy.low); \ |
| | 985 | add_2x64b(alternate_dx_dy, alternate_dx_dy, alternate_dx_dy); \ |
| | 986 | } \ |
| | 987 | |
| | 988 | |
| | 989 | #define setup_spans_y_select_up() \ |
| | 990 | cmplt_4x16b(alternate_select, y_x4, y_mid_point) \ |
| | 991 | |
| | 992 | #define setup_spans_y_select_down() \ |
| | 993 | cmpgt_4x16b(alternate_select, y_x4, y_mid_point) \ |
| | 994 | |
| | 995 | #define setup_spans_y_select_alternate_yes(direction) \ |
| | 996 | setup_spans_y_select_##direction() \ |
| | 997 | |
| | 998 | #define setup_spans_y_select_alternate_no(direction) \ |
| | 999 | |
| | 1000 | #define setup_spans_alternate_select_left() \ |
| | 1001 | bit_4x16b(left_right_x_16.low, alternate_x_16, alternate_select) \ |
| | 1002 | |
| | 1003 | #define setup_spans_alternate_select_right() \ |
| | 1004 | bit_4x16b(left_right_x_16.high, alternate_x_16, alternate_select) \ |
| | 1005 | |
| | 1006 | #define setup_spans_alternate_select_none() \ |
| | 1007 | |
| | 1008 | #define setup_spans_increment_alternate_yes() \ |
| | 1009 | shr_narrow_2x64b(alternate_x_32.low, alternate_x, 32); \ |
| | 1010 | add_2x64b(alternate_x, alternate_x, alternate_dx_dy); \ |
| | 1011 | shr_narrow_2x64b(alternate_x_32.high, alternate_x, 32); \ |
| | 1012 | add_2x64b(alternate_x, alternate_x, alternate_dx_dy); \ |
| | 1013 | mov_narrow_4x32b(alternate_x_16, alternate_x_32) \ |
| | 1014 | |
| | 1015 | #define setup_spans_increment_alternate_no() \ |
| | 1016 | |
| | 1017 | #define setup_spans_set_x4(alternate, direction, alternate_active) \ |
| | 1018 | { \ |
| | 1019 | span_uvrg_offset[0] = uvrg; \ |
| | 1020 | span_b_offset[0] = b; \ |
| | 1021 | setup_spans_adjust_interpolants_##direction(); \ |
| | 1022 | \ |
| | 1023 | span_uvrg_offset[1] = uvrg; \ |
| | 1024 | span_b_offset[1] = b; \ |
| | 1025 | setup_spans_adjust_interpolants_##direction(); \ |
| | 1026 | \ |
| | 1027 | span_uvrg_offset[2] = uvrg; \ |
| | 1028 | span_b_offset[2] = b; \ |
| | 1029 | setup_spans_adjust_interpolants_##direction(); \ |
| | 1030 | \ |
| | 1031 | span_uvrg_offset[3] = uvrg; \ |
| | 1032 | span_b_offset[3] = b; \ |
| | 1033 | setup_spans_adjust_interpolants_##direction(); \ |
| | 1034 | \ |
| | 1035 | span_uvrg_offset += 4; \ |
| | 1036 | span_b_offset += 4; \ |
| | 1037 | \ |
| | 1038 | shr_narrow_2x64b(left_x_32.low, left_x, 32); \ |
| | 1039 | shr_narrow_2x64b(right_x_32.low, right_x, 32); \ |
| | 1040 | \ |
| | 1041 | add_2x64b(left_x, left_x, left_dx_dy); \ |
| | 1042 | add_2x64b(right_x, right_x, right_dx_dy); \ |
| | 1043 | \ |
| | 1044 | shr_narrow_2x64b(left_x_32.high, left_x, 32); \ |
| | 1045 | shr_narrow_2x64b(right_x_32.high, right_x, 32); \ |
| | 1046 | \ |
| | 1047 | add_2x64b(left_x, left_x, left_dx_dy); \ |
| | 1048 | add_2x64b(right_x, right_x, right_dx_dy); \ |
| | 1049 | \ |
| | 1050 | mov_narrow_4x32b(left_right_x_16.low, left_x_32); \ |
| | 1051 | mov_narrow_4x32b(left_right_x_16.high, right_x_32); \ |
| | 1052 | \ |
| | 1053 | setup_spans_increment_alternate_##alternate_active(); \ |
| | 1054 | setup_spans_y_select_alternate_##alternate_active(direction); \ |
| | 1055 | setup_spans_alternate_select_##alternate(); \ |
| | 1056 | \ |
| | 1057 | max_8x16b(left_right_x_16, left_right_x_16, left_edge); \ |
| | 1058 | min_8x16b(left_right_x_16, left_right_x_16, right_edge); \ |
| | 1059 | \ |
| | 1060 | sub_4x16b(left_right_x_16.high, left_right_x_16.high, left_right_x_16.low); \ |
| | 1061 | add_4x16b(left_right_x_16.high, left_right_x_16.high, c_0x07); \ |
| | 1062 | and_4x16b(span_shift, left_right_x_16.high, c_0x07); \ |
| | 1063 | shl_variable_4x16b(span_shift, c_0xFFFE, span_shift); \ |
| | 1064 | shr_4x16b(left_right_x_16.high, left_right_x_16.high, 3); \ |
| | 1065 | \ |
| | 1066 | u32 i; \ |
| | 1067 | for(i = 0; i < 4; i++) \ |
| | 1068 | { \ |
| | 1069 | span_edge_data[i].left_x = left_right_x_16.low.e[i]; \ |
| | 1070 | span_edge_data[i].num_blocks = left_right_x_16.high.e[i]; \ |
| | 1071 | span_edge_data[i].right_mask = span_shift.e[i]; \ |
| | 1072 | span_edge_data[i].y = y_x4.e[i]; \ |
| | 1073 | } \ |
| | 1074 | \ |
| | 1075 | span_edge_data += 4; \ |
| | 1076 | \ |
| | 1077 | setup_spans_adjust_y_##direction(); \ |
| | 1078 | } \ |
| | 1079 | |
| | 1080 | |
| | 1081 | #define setup_spans_alternate_adjust_yes() \ |
| | 1082 | edge_alt -= edge_dx_dy_alt * (s64)height_minor_a \ |
| | 1083 | |
| | 1084 | #define setup_spans_alternate_adjust_no() \ |
| | 1085 | |
| | 1086 | |
| | 1087 | #define setup_spans_down(left_index, right_index, alternate, alternate_active) \ |
| | 1088 | setup_spans_alternate_adjust_##alternate_active(); \ |
| | 1089 | if(y_c > psx_gpu->viewport_end_y) \ |
| | 1090 | height -= y_c - psx_gpu->viewport_end_y - 1; \ |
| | 1091 | \ |
| | 1092 | clip = psx_gpu->viewport_start_y - y_a; \ |
| | 1093 | if(clip > 0) \ |
| | 1094 | { \ |
| | 1095 | height -= clip; \ |
| | 1096 | y_a += clip; \ |
| | 1097 | setup_spans_clip(increment, alternate_active); \ |
| | 1098 | } \ |
| | 1099 | \ |
| | 1100 | setup_spans_prologue_b(); \ |
| | 1101 | \ |
| | 1102 | if(height > 0) \ |
| | 1103 | { \ |
| | 1104 | y_x4.e[0] = y_a; \ |
| | 1105 | y_x4.e[1] = y_a + 1; \ |
| | 1106 | y_x4.e[2] = y_a + 2; \ |
| | 1107 | y_x4.e[3] = y_a + 3; \ |
| | 1108 | setup_spans_adjust_edges_alternate_##alternate_active(left_index, \ |
| | 1109 | right_index); \ |
| | 1110 | \ |
| | 1111 | psx_gpu->num_spans = height; \ |
| | 1112 | do \ |
| | 1113 | { \ |
| | 1114 | setup_spans_set_x4(alternate, down, alternate_active); \ |
| | 1115 | height -= 4; \ |
| | 1116 | } while(height > 0); \ |
| | 1117 | } \ |
| | 1118 | |
| | 1119 | |
| | 1120 | #define setup_spans_alternate_pre_increment_yes() \ |
| | 1121 | edge_alt += edge_dx_dy_alt \ |
| | 1122 | |
| | 1123 | #define setup_spans_alternate_pre_increment_no() \ |
| | 1124 | |
| | 1125 | #define setup_spans_up_decrement_height_yes() \ |
| | 1126 | height-- \ |
| | 1127 | |
| | 1128 | #define setup_spans_up_decrement_height_no() \ |
| | 1129 | {} \ |
| | 1130 | |
| | 1131 | #define setup_spans_up(left_index, right_index, alternate, alternate_active) \ |
| | 1132 | setup_spans_alternate_adjust_##alternate_active(); \ |
| | 1133 | y_a--; \ |
| | 1134 | \ |
| | 1135 | if(y_c < psx_gpu->viewport_start_y) \ |
| | 1136 | height -= psx_gpu->viewport_start_y - y_c; \ |
| | 1137 | else \ |
| | 1138 | setup_spans_up_decrement_height_##alternate_active(); \ |
| | 1139 | \ |
| | 1140 | clip = y_a - psx_gpu->viewport_end_y; \ |
| | 1141 | if(clip > 0) \ |
| | 1142 | { \ |
| | 1143 | height -= clip; \ |
| | 1144 | y_a -= clip; \ |
| | 1145 | setup_spans_clip(decrement, alternate_active); \ |
| | 1146 | } \ |
| | 1147 | \ |
| | 1148 | setup_spans_prologue_b(); \ |
| | 1149 | \ |
| | 1150 | if(height > 0) \ |
| | 1151 | { \ |
| | 1152 | y_x4.e[0] = y_a; \ |
| | 1153 | y_x4.e[1] = y_a - 1; \ |
| | 1154 | y_x4.e[2] = y_a - 2; \ |
| | 1155 | y_x4.e[3] = y_a - 3; \ |
| | 1156 | add_wide_2x32b(edges_xy, edges_xy, edges_dx_dy); \ |
| | 1157 | setup_spans_alternate_pre_increment_##alternate_active(); \ |
| | 1158 | setup_spans_adjust_edges_alternate_##alternate_active(left_index, \ |
| | 1159 | right_index); \ |
| | 1160 | setup_spans_adjust_interpolants_up(); \ |
| | 1161 | \ |
| | 1162 | psx_gpu->num_spans = height; \ |
| | 1163 | while(height > 0) \ |
| | 1164 | { \ |
| | 1165 | setup_spans_set_x4(alternate, up, alternate_active); \ |
| | 1166 | height -= 4; \ |
| | 1167 | } \ |
| | 1168 | } \ |
| | 1169 | |
| | 1170 | #define index_left 0 |
| | 1171 | #define index_right 1 |
| | 1172 | |
| | 1173 | #define setup_spans_up_up(minor, major) \ |
| | 1174 | setup_spans_prologue(yes); \ |
| | 1175 | s32 height_minor_a = y_a - y_b; \ |
| | 1176 | s32 height_minor_b = y_b - y_c; \ |
| | 1177 | s32 height = y_a - y_c; \ |
| | 1178 | \ |
| | 1179 | dup_2x32b(x_starts, x_a); \ |
| | 1180 | x_ends.e[0] = x_c; \ |
| | 1181 | x_ends.e[1] = x_b; \ |
| | 1182 | \ |
| | 1183 | compute_edge_delta_x3(x_b, height, height_minor_a); \ |
| | 1184 | setup_spans_up(index_##major, index_##minor, minor, yes) \ |
| | 1185 | |
| | 1186 | |
| | 1187 | void setup_spans_up_left(psx_gpu_struct *psx_gpu, vertex_struct *v_a, |
| | 1188 | vertex_struct *v_b, vertex_struct *v_c); |
| | 1189 | void setup_spans_up_right(psx_gpu_struct *psx_gpu, vertex_struct *v_a, |
| | 1190 | vertex_struct *v_b, vertex_struct *v_c); |
| | 1191 | void setup_spans_down_left(psx_gpu_struct *psx_gpu, vertex_struct *v_a, |
| | 1192 | vertex_struct *v_b, vertex_struct *v_c); |
| | 1193 | void setup_spans_down_right(psx_gpu_struct *psx_gpu, vertex_struct *v_a, |
| | 1194 | vertex_struct *v_b, vertex_struct *v_c); |
| | 1195 | void setup_spans_up_a(psx_gpu_struct *psx_gpu, vertex_struct *v_a, |
| | 1196 | vertex_struct *v_b, vertex_struct *v_c); |
| | 1197 | void setup_spans_up_b(psx_gpu_struct *psx_gpu, vertex_struct *v_a, |
| | 1198 | vertex_struct *v_b, vertex_struct *v_c); |
| | 1199 | void setup_spans_down_a(psx_gpu_struct *psx_gpu, vertex_struct *v_a, |
| | 1200 | vertex_struct *v_b, vertex_struct *v_c); |
| | 1201 | void setup_spans_down_b(psx_gpu_struct *psx_gpu, vertex_struct *v_a, |
| | 1202 | vertex_struct *v_b, vertex_struct *v_c); |
| | 1203 | void setup_spans_up_down(psx_gpu_struct *psx_gpu, vertex_struct *v_a, |
| | 1204 | vertex_struct *v_b, vertex_struct *v_c); |
| | 1205 | |
| | 1206 | |
| | 1207 | #ifndef NEON_BUILD |
| | 1208 | |
| | 1209 | void setup_spans_up_left(psx_gpu_struct *psx_gpu, vertex_struct *v_a, |
| | 1210 | vertex_struct *v_b, vertex_struct *v_c) |
| | 1211 | { |
| | 1212 | setup_spans_up_up(left, right); |
| | 1213 | } |
| | 1214 | |
| | 1215 | void setup_spans_up_right(psx_gpu_struct *psx_gpu, vertex_struct *v_a, |
| | 1216 | vertex_struct *v_b, vertex_struct *v_c) |
| | 1217 | { |
| | 1218 | setup_spans_up_up(right, left); |
| | 1219 | } |
| | 1220 | |
| | 1221 | #define setup_spans_down_down(minor, major) \ |
| | 1222 | setup_spans_prologue(yes); \ |
| | 1223 | s32 height_minor_a = y_b - y_a; \ |
| | 1224 | s32 height_minor_b = y_c - y_b; \ |
| | 1225 | s32 height = y_c - y_a; \ |
| | 1226 | \ |
| | 1227 | dup_2x32b(x_starts, x_a); \ |
| | 1228 | x_ends.e[0] = x_c; \ |
| | 1229 | x_ends.e[1] = x_b; \ |
| | 1230 | \ |
| | 1231 | compute_edge_delta_x3(x_b, height, height_minor_a); \ |
| | 1232 | setup_spans_down(index_##major, index_##minor, minor, yes) \ |
| | 1233 | |
| | 1234 | void setup_spans_down_left(psx_gpu_struct *psx_gpu, vertex_struct *v_a, |
| | 1235 | vertex_struct *v_b, vertex_struct *v_c) |
| | 1236 | { |
| | 1237 | setup_spans_down_down(left, right); |
| | 1238 | } |
| | 1239 | |
| | 1240 | void setup_spans_down_right(psx_gpu_struct *psx_gpu, vertex_struct *v_a, |
| | 1241 | vertex_struct *v_b, vertex_struct *v_c) |
| | 1242 | { |
| | 1243 | setup_spans_down_down(right, left); |
| | 1244 | } |
| | 1245 | |
| | 1246 | #define setup_spans_up_flat() \ |
| | 1247 | s32 height = y_a - y_c; \ |
| | 1248 | \ |
| | 1249 | flat_triangles++; \ |
| | 1250 | compute_edge_delta_x2(); \ |
| | 1251 | setup_spans_up(index_left, index_right, none, no) \ |
| | 1252 | |
| | 1253 | void setup_spans_up_a(psx_gpu_struct *psx_gpu, vertex_struct *v_a, |
| | 1254 | vertex_struct *v_b, vertex_struct *v_c) |
| | 1255 | { |
| | 1256 | setup_spans_prologue(no); |
| | 1257 | x_starts.e[0] = x_a; |
| | 1258 | x_starts.e[1] = x_b; |
| | 1259 | dup_2x32b(x_ends, x_c); |
| | 1260 | |
| | 1261 | setup_spans_up_flat(); |
| | 1262 | } |
| | 1263 | |
| | 1264 | void setup_spans_up_b(psx_gpu_struct *psx_gpu, vertex_struct *v_a, |
| | 1265 | vertex_struct *v_b, vertex_struct *v_c) |
| | 1266 | { |
| | 1267 | setup_spans_prologue(no); |
| | 1268 | dup_2x32b(x_starts, x_a); |
| | 1269 | x_ends.e[0] = x_b; |
| | 1270 | x_ends.e[1] = x_c; |
| | 1271 | |
| | 1272 | setup_spans_up_flat(); |
| | 1273 | } |
| | 1274 | |
| | 1275 | #define setup_spans_down_flat() \ |
| | 1276 | s32 height = y_c - y_a; \ |
| | 1277 | \ |
| | 1278 | flat_triangles++; \ |
| | 1279 | compute_edge_delta_x2(); \ |
| | 1280 | setup_spans_down(index_left, index_right, none, no) \ |
| | 1281 | |
| | 1282 | void setup_spans_down_a(psx_gpu_struct *psx_gpu, vertex_struct *v_a, |
| | 1283 | vertex_struct *v_b, vertex_struct *v_c) |
| | 1284 | { |
| | 1285 | setup_spans_prologue(no); |
| | 1286 | x_starts.e[0] = x_a; |
| | 1287 | x_starts.e[1] = x_b; |
| | 1288 | dup_2x32b(x_ends, x_c); |
| | 1289 | |
| | 1290 | setup_spans_down_flat(); |
| | 1291 | } |
| | 1292 | |
| | 1293 | void setup_spans_down_b(psx_gpu_struct *psx_gpu, vertex_struct *v_a, |
| | 1294 | vertex_struct *v_b, vertex_struct *v_c) |
| | 1295 | { |
| | 1296 | setup_spans_prologue(no); |
| | 1297 | dup_2x32b(x_starts, x_a); |
| | 1298 | x_ends.e[0] = x_b; |
| | 1299 | x_ends.e[1] = x_c; |
| | 1300 | |
| | 1301 | setup_spans_down_flat(); |
| | 1302 | } |
| | 1303 | |
| | 1304 | void setup_spans_up_down(psx_gpu_struct *psx_gpu, vertex_struct *v_a, |
| | 1305 | vertex_struct *v_b, vertex_struct *v_c) |
| | 1306 | { |
| | 1307 | setup_spans_prologue(no); |
| | 1308 | |
| | 1309 | s32 y_b = v_b->y; |
| | 1310 | s64 edge_alt; |
| | 1311 | s32 edge_dx_dy_alt; |
| | 1312 | u32 edge_shift_alt; |
| | 1313 | |
| | 1314 | s32 middle_y = y_a; |
| | 1315 | s32 height_minor_a = y_a - y_b; |
| | 1316 | s32 height_minor_b = y_c - y_a; |
| | 1317 | s32 height_major = y_c - y_b; |
| | 1318 | |
| | 1319 | vec_2x64s edges_xy_b; |
| | 1320 | vec_2x32s edges_dx_dy_b; |
| | 1321 | vec_2x32u edge_shifts_b; |
| | 1322 | |
| | 1323 | vec_2x32s height_increment; |
| | 1324 | |
| | 1325 | x_starts.e[0] = x_a; |
| | 1326 | x_starts.e[1] = x_c; |
| | 1327 | dup_2x32b(x_ends, x_b); |
| | 1328 | |
| | 1329 | compute_edge_delta_x3(x_a, height_minor_a, height_major); |
| | 1330 | |
| | 1331 | height_increment.e[0] = 0; |
| | 1332 | height_increment.e[1] = height_minor_b; |
| | 1333 | |
| | 1334 | mla_long_2x32b(edges_xy, edges_dx_dy, height_increment); |
| | 1335 | |
| | 1336 | edges_xy_b.e[0] = edge_alt; |
| | 1337 | edges_xy_b.e[1] = edges_xy.e[1]; |
| | 1338 | |
| | 1339 | edge_shifts_b = edge_shifts; |
| | 1340 | edge_shifts_b.e[0] = edge_shift_alt; |
| | 1341 | |
| | 1342 | neg_2x32b(edges_dx_dy_b, edges_dx_dy); |
| | 1343 | edges_dx_dy_b.e[0] = edge_dx_dy_alt; |
| | 1344 | |
| | 1345 | y_a--; |
| | 1346 | |
| | 1347 | if(y_b < psx_gpu->viewport_start_y) |
| | 1348 | height_minor_a -= psx_gpu->viewport_start_y - y_b; |
| | 1349 | |
| | 1350 | clip = y_a - psx_gpu->viewport_end_y; |
| | 1351 | if(clip > 0) |
| | 1352 | { |
| | 1353 | height_minor_a -= clip; |
| | 1354 | y_a -= clip; |
| | 1355 | setup_spans_clip(decrement, no); |
| | 1356 | } |
| | 1357 | |
| | 1358 | setup_spans_prologue_b(); |
| | 1359 | |
| | 1360 | if(height_minor_a > 0) |
| | 1361 | { |
| | 1362 | y_x4.e[0] = y_a; |
| | 1363 | y_x4.e[1] = y_a - 1; |
| | 1364 | y_x4.e[2] = y_a - 2; |
| | 1365 | y_x4.e[3] = y_a - 3; |
| | 1366 | add_wide_2x32b(edges_xy, edges_xy, edges_dx_dy); |
| | 1367 | setup_spans_adjust_edges_alternate_no(index_left, index_right); |
| | 1368 | setup_spans_adjust_interpolants_up(); |
| | 1369 | |
| | 1370 | psx_gpu->num_spans = height_minor_a; |
| | 1371 | while(height_minor_a > 0) |
| | 1372 | { |
| | 1373 | setup_spans_set_x4(none, up, no); |
| | 1374 | height_minor_a -= 4; |
| | 1375 | } |
| | 1376 | |
| | 1377 | span_edge_data += height_minor_a; |
| | 1378 | span_uvrg_offset += height_minor_a; |
| | 1379 | span_b_offset += height_minor_a; |
| | 1380 | } |
| | 1381 | |
| | 1382 | edges_xy = edges_xy_b; |
| | 1383 | edges_dx_dy = edges_dx_dy_b; |
| | 1384 | edge_shifts = edge_shifts_b; |
| | 1385 | |
| | 1386 | uvrg = psx_gpu->uvrg; |
| | 1387 | b = psx_gpu->b; |
| | 1388 | |
| | 1389 | y_a = middle_y; |
| | 1390 | |
| | 1391 | if(y_c > psx_gpu->viewport_end_y) |
| | 1392 | height_minor_b -= y_c - psx_gpu->viewport_end_y - 1; |
| | 1393 | |
| | 1394 | clip = psx_gpu->viewport_start_y - y_a; |
| | 1395 | if(clip > 0) |
| | 1396 | { |
| | 1397 | height_minor_b -= clip; |
| | 1398 | y_a += clip; |
| | 1399 | setup_spans_clip(increment, no); |
| | 1400 | } |
| | 1401 | |
| | 1402 | if(height_minor_b > 0) |
| | 1403 | { |
| | 1404 | y_x4.e[0] = y_a; |
| | 1405 | y_x4.e[1] = y_a + 1; |
| | 1406 | y_x4.e[2] = y_a + 2; |
| | 1407 | y_x4.e[3] = y_a + 3; |
| | 1408 | setup_spans_adjust_edges_alternate_no(index_left, index_right); |
| | 1409 | |
| | 1410 | psx_gpu->num_spans += height_minor_b; |
| | 1411 | do |
| | 1412 | { |
| | 1413 | setup_spans_set_x4(none, down, no); |
| | 1414 | height_minor_b -= 4; |
| | 1415 | } while(height_minor_b > 0); |
| | 1416 | } |
| | 1417 | |
| | 1418 | left_split_triangles++; |
| | 1419 | } |
| | 1420 | |
| | 1421 | #endif |
| | 1422 | |
| | 1423 | |
| | 1424 | #define dither_table_entry_normal(value) \ |
| | 1425 | (value) \ |
| | 1426 | |
| | 1427 | |
| | 1428 | #define setup_blocks_load_msb_mask_indirect() \ |
| | 1429 | |
| | 1430 | #define setup_blocks_load_msb_mask_direct() \ |
| | 1431 | vec_8x16u msb_mask; \ |
| | 1432 | dup_8x16b(msb_mask, psx_gpu->mask_msb); \ |
| | 1433 | |
| | 1434 | |
| | 1435 | #define setup_blocks_variables_shaded_textured(target) \ |
| | 1436 | vec_4x32u u_block; \ |
| | 1437 | vec_4x32u v_block; \ |
| | 1438 | vec_4x32u r_block; \ |
| | 1439 | vec_4x32u g_block; \ |
| | 1440 | vec_4x32u b_block; \ |
| | 1441 | vec_4x32u uvrg_dx = psx_gpu->uvrg_dx; \ |
| | 1442 | vec_4x32u uvrg_dx4; \ |
| | 1443 | vec_4x32u uvrg_dx8; \ |
| | 1444 | vec_4x32u uvrg; \ |
| | 1445 | u32 b_dx = psx_gpu->b_block_span.e[1]; \ |
| | 1446 | u32 b_dx4 = b_dx << 2; \ |
| | 1447 | u32 b_dx8 = b_dx << 3; \ |
| | 1448 | u32 b; \ |
| | 1449 | \ |
| | 1450 | vec_16x8u texture_mask; \ |
| | 1451 | shl_4x32b(uvrg_dx4, uvrg_dx, 2); \ |
| | 1452 | shl_4x32b(uvrg_dx8, uvrg_dx, 3); \ |
| | 1453 | dup_8x8b(texture_mask.low, psx_gpu->texture_mask_width); \ |
| | 1454 | dup_8x8b(texture_mask.high, psx_gpu->texture_mask_height) \ |
| | 1455 | |
| | 1456 | #define setup_blocks_variables_shaded_untextured(target) \ |
| | 1457 | vec_4x32u r_block; \ |
| | 1458 | vec_4x32u g_block; \ |
| | 1459 | vec_4x32u b_block; \ |
| | 1460 | vec_4x32u rgb_dx; \ |
| | 1461 | vec_4x32u rgb_dx4; \ |
| | 1462 | vec_4x32u rgb_dx8; \ |
| | 1463 | vec_4x32u rgb; \ |
| | 1464 | \ |
| | 1465 | vec_8x8u d64_0x07; \ |
| | 1466 | vec_8x8u d64_1; \ |
| | 1467 | vec_8x8u d64_4; \ |
| | 1468 | vec_8x8u d64_128; \ |
| | 1469 | \ |
| | 1470 | dup_8x8b(d64_0x07, 0x07); \ |
| | 1471 | dup_8x8b(d64_1, 1); \ |
| | 1472 | dup_8x8b(d64_4, 4); \ |
| | 1473 | dup_8x8b(d64_128, 128); \ |
| | 1474 | \ |
| | 1475 | rgb_dx.low = psx_gpu->uvrg_dx.high; \ |
| | 1476 | rgb_dx.e[2] = psx_gpu->b_block_span.e[1]; \ |
| | 1477 | shl_4x32b(rgb_dx4, rgb_dx, 2); \ |
| | 1478 | shl_4x32b(rgb_dx8, rgb_dx, 3) \ |
| | 1479 | |
| | 1480 | #define setup_blocks_variables_unshaded_textured(target) \ |
| | 1481 | vec_4x32u u_block; \ |
| | 1482 | vec_4x32u v_block; \ |
| | 1483 | vec_2x32u uv_dx = psx_gpu->uvrg_dx.low; \ |
| | 1484 | vec_2x32u uv_dx4; \ |
| | 1485 | vec_2x32u uv_dx8; \ |
| | 1486 | vec_2x32u uv = psx_gpu->uvrg.low; \ |
| | 1487 | \ |
| | 1488 | vec_16x8u texture_mask; \ |
| | 1489 | shl_2x32b(uv_dx4, uv_dx, 2); \ |
| | 1490 | shl_2x32b(uv_dx8, uv_dx, 3); \ |
| | 1491 | dup_8x8b(texture_mask.low, psx_gpu->texture_mask_width); \ |
| | 1492 | dup_8x8b(texture_mask.high, psx_gpu->texture_mask_height) \ |
| | 1493 | |
| | 1494 | |
| | 1495 | #define setup_blocks_variables_unshaded_untextured_direct() \ |
| | 1496 | or_8x16b(colors, colors, msb_mask) \ |
| | 1497 | |
| | 1498 | #define setup_blocks_variables_unshaded_untextured_indirect() \ |
| | 1499 | |
| | 1500 | #define setup_blocks_variables_unshaded_untextured(target) \ |
| | 1501 | u32 color = psx_gpu->triangle_color; \ |
| | 1502 | vec_8x16u colors; \ |
| | 1503 | \ |
| | 1504 | u32 color_r = color & 0xFF; \ |
| | 1505 | u32 color_g = (color >> 8) & 0xFF; \ |
| | 1506 | u32 color_b = (color >> 16) & 0xFF; \ |
| | 1507 | \ |
| | 1508 | color = (color_r >> 3) | ((color_g >> 3) << 5) | \ |
| | 1509 | ((color_b >> 3) << 10); \ |
| | 1510 | dup_8x16b(colors, color); \ |
| | 1511 | setup_blocks_variables_unshaded_untextured_##target() \ |
| | 1512 | |
| | 1513 | #define setup_blocks_span_initialize_dithered_textured() \ |
| | 1514 | vec_8x16u dither_offsets; \ |
| | 1515 | shl_long_8x8b(dither_offsets, dither_offsets_short, 4) \ |
| | 1516 | |
| | 1517 | #define setup_blocks_span_initialize_dithered_untextured() \ |
| | 1518 | vec_8x8u dither_offsets; \ |
| | 1519 | add_8x8b(dither_offsets, dither_offsets_short, d64_4) \ |
| | 1520 | |
| | 1521 | #define setup_blocks_span_initialize_dithered(texturing) \ |
| | 1522 | u32 dither_row = psx_gpu->dither_table[y & 0x3]; \ |
| | 1523 | u32 dither_shift = (span_edge_data->left_x & 0x3) * 8; \ |
| | 1524 | vec_8x8s dither_offsets_short; \ |
| | 1525 | \ |
| | 1526 | dither_row = \ |
| | 1527 | (dither_row >> dither_shift) | (dither_row << (32 - dither_shift)); \ |
| | 1528 | dup_2x32b(vector_cast(vec_2x32u, dither_offsets_short), dither_row); \ |
| | 1529 | setup_blocks_span_initialize_dithered_##texturing() \ |
| | 1530 | |
| | 1531 | #define setup_blocks_span_initialize_undithered(texturing) \ |
| | 1532 | |
| | 1533 | |
| | 1534 | #define setup_blocks_span_initialize_shaded_textured() \ |
| | 1535 | { \ |
| | 1536 | vec_4x32u block_span; \ |
| | 1537 | u32 offset = span_edge_data->left_x; \ |
| | 1538 | \ |
| | 1539 | uvrg = *span_uvrg_offset; \ |
| | 1540 | mla_scalar_4x32b(uvrg, uvrg_dx, offset); \ |
| | 1541 | b = *span_b_offset; \ |
| | 1542 | b += b_dx * offset; \ |
| | 1543 | \ |
| | 1544 | dup_4x32b(u_block, uvrg.e[0]); \ |
| | 1545 | dup_4x32b(v_block, uvrg.e[1]); \ |
| | 1546 | dup_4x32b(r_block, uvrg.e[2]); \ |
| | 1547 | dup_4x32b(g_block, uvrg.e[3]); \ |
| | 1548 | dup_4x32b(b_block, b); \ |
| | 1549 | \ |
| | 1550 | block_span = psx_gpu->u_block_span; \ |
| | 1551 | add_4x32b(u_block, u_block, block_span); \ |
| | 1552 | block_span = psx_gpu->v_block_span; \ |
| | 1553 | add_4x32b(v_block, v_block, block_span); \ |
| | 1554 | block_span = psx_gpu->r_block_span; \ |
| | 1555 | add_4x32b(r_block, r_block, block_span); \ |
| | 1556 | block_span = psx_gpu->g_block_span; \ |
| | 1557 | add_4x32b(g_block, g_block, block_span); \ |
| | 1558 | block_span = psx_gpu->b_block_span; \ |
| | 1559 | add_4x32b(b_block, b_block, block_span); \ |
| | 1560 | } |
| | 1561 | |
| | 1562 | #define setup_blocks_span_initialize_shaded_untextured() \ |
| | 1563 | { \ |
| | 1564 | vec_4x32u block_span; \ |
| | 1565 | u32 offset = span_edge_data->left_x; \ |
| | 1566 | \ |
| | 1567 | rgb.low = span_uvrg_offset->high; \ |
| | 1568 | rgb.high.e[0] = *span_b_offset; \ |
| | 1569 | mla_scalar_4x32b(rgb, rgb_dx, offset); \ |
| | 1570 | \ |
| | 1571 | dup_4x32b(r_block, rgb.e[0]); \ |
| | 1572 | dup_4x32b(g_block, rgb.e[1]); \ |
| | 1573 | dup_4x32b(b_block, rgb.e[2]); \ |
| | 1574 | \ |
| | 1575 | block_span = psx_gpu->r_block_span; \ |
| | 1576 | add_4x32b(r_block, r_block, block_span); \ |
| | 1577 | block_span = psx_gpu->g_block_span; \ |
| | 1578 | add_4x32b(g_block, g_block, block_span); \ |
| | 1579 | block_span = psx_gpu->b_block_span; \ |
| | 1580 | add_4x32b(b_block, b_block, block_span); \ |
| | 1581 | } \ |
| | 1582 | |
| | 1583 | #define setup_blocks_span_initialize_unshaded_textured() \ |
| | 1584 | { \ |
| | 1585 | vec_4x32u block_span; \ |
| | 1586 | u32 offset = span_edge_data->left_x; \ |
| | 1587 | \ |
| | 1588 | uv = span_uvrg_offset->low; \ |
| | 1589 | mla_scalar_2x32b(uv, uv_dx, offset); \ |
| | 1590 | \ |
| | 1591 | dup_4x32b(u_block, uv.e[0]); \ |
| | 1592 | dup_4x32b(v_block, uv.e[1]); \ |
| | 1593 | \ |
| | 1594 | block_span = psx_gpu->u_block_span; \ |
| | 1595 | add_4x32b(u_block, u_block, block_span); \ |
| | 1596 | block_span = psx_gpu->v_block_span; \ |
| | 1597 | add_4x32b(v_block, v_block, block_span); \ |
| | 1598 | } \ |
| | 1599 | |
| | 1600 | #define setup_blocks_span_initialize_unshaded_untextured() \ |
| | 1601 | |
| | 1602 | |
| | 1603 | #define setup_blocks_texture_swizzled() \ |
| | 1604 | { \ |
| | 1605 | vec_8x8u u_saved = u; \ |
| | 1606 | sli_8x8b(u, v, 4); \ |
| | 1607 | sri_8x8b(v, u_saved, 4); \ |
| | 1608 | } \ |
| | 1609 | |
| | 1610 | #define setup_blocks_texture_unswizzled() \ |
| | 1611 | |
| | 1612 | #define setup_blocks_store_shaded_textured(swizzling, dithering, target, \ |
| | 1613 | edge_type) \ |
| | 1614 | { \ |
| | 1615 | vec_8x16u u_whole; \ |
| | 1616 | vec_8x16u v_whole; \ |
| | 1617 | vec_8x16u r_whole; \ |
| | 1618 | vec_8x16u g_whole; \ |
| | 1619 | vec_8x16u b_whole; \ |
| | 1620 | \ |
| | 1621 | vec_8x8u u; \ |
| | 1622 | vec_8x8u v; \ |
| | 1623 | vec_8x8u r; \ |
| | 1624 | vec_8x8u g; \ |
| | 1625 | vec_8x8u b; \ |
| | 1626 | vec_8x16u uv; \ |
| | 1627 | \ |
| | 1628 | vec_4x32u dx4; \ |
| | 1629 | vec_4x32u dx8; \ |
| | 1630 | \ |
| | 1631 | shr_narrow_4x32b(u_whole.low, u_block, 16); \ |
| | 1632 | shr_narrow_4x32b(v_whole.low, v_block, 16); \ |
| | 1633 | shr_narrow_4x32b(r_whole.low, r_block, 16); \ |
| | 1634 | shr_narrow_4x32b(g_whole.low, g_block, 16); \ |
| | 1635 | shr_narrow_4x32b(b_whole.low, b_block, 16); \ |
| | 1636 | \ |
| | 1637 | dup_4x32b(dx4, uvrg_dx4.e[0]); \ |
| | 1638 | add_high_narrow_4x32b(u_whole.high, u_block, dx4); \ |
| | 1639 | dup_4x32b(dx4, uvrg_dx4.e[1]); \ |
| | 1640 | add_high_narrow_4x32b(v_whole.high, v_block, dx4); \ |
| | 1641 | dup_4x32b(dx4, uvrg_dx4.e[2]); \ |
| | 1642 | add_high_narrow_4x32b(r_whole.high, r_block, dx4); \ |
| | 1643 | dup_4x32b(dx4, uvrg_dx4.e[3]); \ |
| | 1644 | add_high_narrow_4x32b(g_whole.high, g_block, dx4); \ |
| | 1645 | dup_4x32b(dx4, b_dx4); \ |
| | 1646 | add_high_narrow_4x32b(b_whole.high, b_block, dx4); \ |
| | 1647 | \ |
| | 1648 | mov_narrow_8x16b(u, u_whole); \ |
| | 1649 | mov_narrow_8x16b(v, v_whole); \ |
| | 1650 | mov_narrow_8x16b(r, r_whole); \ |
| | 1651 | mov_narrow_8x16b(g, g_whole); \ |
| | 1652 | mov_narrow_8x16b(b, b_whole); \ |
| | 1653 | \ |
| | 1654 | dup_4x32b(dx8, uvrg_dx8.e[0]); \ |
| | 1655 | add_4x32b(u_block, u_block, dx8); \ |
| | 1656 | dup_4x32b(dx8, uvrg_dx8.e[1]); \ |
| | 1657 | add_4x32b(v_block, v_block, dx8); \ |
| | 1658 | dup_4x32b(dx8, uvrg_dx8.e[2]); \ |
| | 1659 | add_4x32b(r_block, r_block, dx8); \ |
| | 1660 | dup_4x32b(dx8, uvrg_dx8.e[3]); \ |
| | 1661 | add_4x32b(g_block, g_block, dx8); \ |
| | 1662 | dup_4x32b(dx8, b_dx8); \ |
| | 1663 | add_4x32b(b_block, b_block, dx8); \ |
| | 1664 | \ |
| | 1665 | and_8x8b(u, u, texture_mask.low); \ |
| | 1666 | and_8x8b(v, v, texture_mask.high); \ |
| | 1667 | setup_blocks_texture_##swizzling(); \ |
| | 1668 | \ |
| | 1669 | zip_8x16b(uv, u, v); \ |
| | 1670 | block->uv = uv; \ |
| | 1671 | block->r = r; \ |
| | 1672 | block->g = g; \ |
| | 1673 | block->b = b; \ |
| | 1674 | block->dither_offsets = vector_cast(vec_8x16u, dither_offsets); \ |
| | 1675 | block->fb_ptr = fb_ptr; \ |
| | 1676 | } \ |
| | 1677 | |
| | 1678 | #define setup_blocks_store_unshaded_textured(swizzling, dithering, target, \ |
| | 1679 | edge_type) \ |
| | 1680 | { \ |
| | 1681 | vec_8x16u u_whole; \ |
| | 1682 | vec_8x16u v_whole; \ |
| | 1683 | \ |
| | 1684 | vec_8x8u u; \ |
| | 1685 | vec_8x8u v; \ |
| | 1686 | vec_8x16u uv; \ |
| | 1687 | \ |
| | 1688 | vec_4x32u dx4; \ |
| | 1689 | vec_4x32u dx8; \ |
| | 1690 | \ |
| | 1691 | shr_narrow_4x32b(u_whole.low, u_block, 16); \ |
| | 1692 | shr_narrow_4x32b(v_whole.low, v_block, 16); \ |
| | 1693 | \ |
| | 1694 | dup_4x32b(dx4, uv_dx4.e[0]); \ |
| | 1695 | add_high_narrow_4x32b(u_whole.high, u_block, dx4); \ |
| | 1696 | dup_4x32b(dx4, uv_dx4.e[1]); \ |
| | 1697 | add_high_narrow_4x32b(v_whole.high, v_block, dx4); \ |
| | 1698 | \ |
| | 1699 | mov_narrow_8x16b(u, u_whole); \ |
| | 1700 | mov_narrow_8x16b(v, v_whole); \ |
| | 1701 | \ |
| | 1702 | dup_4x32b(dx8, uv_dx8.e[0]); \ |
| | 1703 | add_4x32b(u_block, u_block, dx8); \ |
| | 1704 | dup_4x32b(dx8, uv_dx8.e[1]); \ |
| | 1705 | add_4x32b(v_block, v_block, dx8); \ |
| | 1706 | \ |
| | 1707 | and_8x8b(u, u, texture_mask.low); \ |
| | 1708 | and_8x8b(v, v, texture_mask.high); \ |
| | 1709 | setup_blocks_texture_##swizzling(); \ |
| | 1710 | \ |
| | 1711 | zip_8x16b(uv, u, v); \ |
| | 1712 | block->uv = uv; \ |
| | 1713 | block->dither_offsets = vector_cast(vec_8x16u, dither_offsets); \ |
| | 1714 | block->fb_ptr = fb_ptr; \ |
| | 1715 | } \ |
| | 1716 | |
| | 1717 | #define setup_blocks_store_shaded_untextured_dithered() \ |
| | 1718 | addq_8x8b(r, r, dither_offsets); \ |
| | 1719 | addq_8x8b(g, g, dither_offsets); \ |
| | 1720 | addq_8x8b(b, b, dither_offsets); \ |
| | 1721 | \ |
| | 1722 | subq_8x8b(r, r, d64_4); \ |
| | 1723 | subq_8x8b(g, g, d64_4); \ |
| | 1724 | subq_8x8b(b, b, d64_4) \ |
| | 1725 | |
| | 1726 | #define setup_blocks_store_shaded_untextured_undithered() \ |
| | 1727 | |
| | 1728 | |
| | 1729 | #define setup_blocks_store_untextured_pixels_indirect_full(_pixels) \ |
| | 1730 | block->pixels = _pixels; \ |
| | 1731 | block->fb_ptr = fb_ptr \ |
| | 1732 | |
| | 1733 | #define setup_blocks_store_untextured_pixels_indirect_edge(_pixels) \ |
| | 1734 | block->pixels = _pixels; \ |
| | 1735 | block->fb_ptr = fb_ptr \ |
| | 1736 | |
| | 1737 | #define setup_blocks_store_shaded_untextured_seed_pixels_indirect() \ |
| | 1738 | mul_long_8x8b(pixels, r, d64_1) \ |
| | 1739 | |
| | 1740 | |
| | 1741 | #define setup_blocks_store_untextured_pixels_direct_full(_pixels) \ |
| | 1742 | store_8x16b(_pixels, fb_ptr) \ |
| | 1743 | |
| | 1744 | #define setup_blocks_store_untextured_pixels_direct_edge(_pixels) \ |
| | 1745 | { \ |
| | 1746 | vec_8x16u fb_pixels; \ |
| | 1747 | vec_8x16u draw_mask; \ |
| | 1748 | vec_8x16u test_mask = psx_gpu->test_mask; \ |
| | 1749 | \ |
| | 1750 | load_8x16b(fb_pixels, fb_ptr); \ |
| | 1751 | dup_8x16b(draw_mask, span_edge_data->right_mask); \ |
| | 1752 | tst_8x16b(draw_mask, draw_mask, test_mask); \ |
| | 1753 | bif_8x16b(fb_pixels, _pixels, draw_mask); \ |
| | 1754 | store_8x16b(fb_pixels, fb_ptr); \ |
| | 1755 | } \ |
| | 1756 | |
| | 1757 | #define setup_blocks_store_shaded_untextured_seed_pixels_direct() \ |
| | 1758 | pixels = msb_mask; \ |
| | 1759 | mla_long_8x8b(pixels, r, d64_1) \ |
| | 1760 | |
| | 1761 | |
| | 1762 | #define setup_blocks_store_shaded_untextured(swizzling, dithering, target, \ |
| | 1763 | edge_type) \ |
| | 1764 | { \ |
| | 1765 | vec_8x16u r_whole; \ |
| | 1766 | vec_8x16u g_whole; \ |
| | 1767 | vec_8x16u b_whole; \ |
| | 1768 | \ |
| | 1769 | vec_8x8u r; \ |
| | 1770 | vec_8x8u g; \ |
| | 1771 | vec_8x8u b; \ |
| | 1772 | \ |
| | 1773 | vec_4x32u dx4; \ |
| | 1774 | vec_4x32u dx8; \ |
| | 1775 | \ |
| | 1776 | vec_8x16u pixels; \ |
| | 1777 | \ |
| | 1778 | shr_narrow_4x32b(r_whole.low, r_block, 16); \ |
| | 1779 | shr_narrow_4x32b(g_whole.low, g_block, 16); \ |
| | 1780 | shr_narrow_4x32b(b_whole.low, b_block, 16); \ |
| | 1781 | \ |
| | 1782 | dup_4x32b(dx4, rgb_dx4.e[0]); \ |
| | 1783 | add_high_narrow_4x32b(r_whole.high, r_block, dx4); \ |
| | 1784 | dup_4x32b(dx4, rgb_dx4.e[1]); \ |
| | 1785 | add_high_narrow_4x32b(g_whole.high, g_block, dx4); \ |
| | 1786 | dup_4x32b(dx4, rgb_dx4.e[2]); \ |
| | 1787 | add_high_narrow_4x32b(b_whole.high, b_block, dx4); \ |
| | 1788 | \ |
| | 1789 | mov_narrow_8x16b(r, r_whole); \ |
| | 1790 | mov_narrow_8x16b(g, g_whole); \ |
| | 1791 | mov_narrow_8x16b(b, b_whole); \ |
| | 1792 | \ |
| | 1793 | dup_4x32b(dx8, rgb_dx8.e[0]); \ |
| | 1794 | add_4x32b(r_block, r_block, dx8); \ |
| | 1795 | dup_4x32b(dx8, rgb_dx8.e[1]); \ |
| | 1796 | add_4x32b(g_block, g_block, dx8); \ |
| | 1797 | dup_4x32b(dx8, rgb_dx8.e[2]); \ |
| | 1798 | add_4x32b(b_block, b_block, dx8); \ |
| | 1799 | \ |
| | 1800 | setup_blocks_store_shaded_untextured_##dithering(); \ |
| | 1801 | \ |
| | 1802 | shr_8x8b(r, r, 3); \ |
| | 1803 | bic_8x8b(g, g, d64_0x07); \ |
| | 1804 | bic_8x8b(b, b, d64_0x07); \ |
| | 1805 | \ |
| | 1806 | setup_blocks_store_shaded_untextured_seed_pixels_##target(); \ |
| | 1807 | mla_long_8x8b(pixels, g, d64_4); \ |
| | 1808 | mla_long_8x8b(pixels, b, d64_128) \ |
| | 1809 | \ |
| | 1810 | setup_blocks_store_untextured_pixels_##target##_##edge_type(pixels); \ |
| | 1811 | } \ |
| | 1812 | |
| | 1813 | #define setup_blocks_store_unshaded_untextured(swizzling, dithering, target, \ |
| | 1814 | edge_type) \ |
| | 1815 | setup_blocks_store_untextured_pixels_##target##_##edge_type(colors) \ |
| | 1816 | |
| | 1817 | |
| | 1818 | #define setup_blocks_store_draw_mask_textured_indirect(_block, bits) \ |
| | 1819 | (_block)->draw_mask_bits = bits \ |
| | 1820 | |
| | 1821 | #define setup_blocks_store_draw_mask_untextured_indirect(_block, bits) \ |
| | 1822 | { \ |
| | 1823 | vec_8x16u bits_mask; \ |
| | 1824 | vec_8x16u test_mask = psx_gpu->test_mask; \ |
| | 1825 | dup_8x16b(bits_mask, bits); \ |
| | 1826 | tst_8x16b(bits_mask, bits_mask, test_mask); \ |
| | 1827 | (_block)->draw_mask = bits_mask; \ |
| | 1828 | } \ |
| | 1829 | |
| | 1830 | #define setup_blocks_store_draw_mask_untextured_direct(_block, bits) \ |
| | 1831 | |
| | 1832 | |
| | 1833 | #define setup_blocks_add_blocks_indirect() \ |
| | 1834 | num_blocks += span_num_blocks; \ |
| | 1835 | \ |
| | 1836 | if(num_blocks > MAX_BLOCKS) \ |
| | 1837 | { \ |
| | 1838 | psx_gpu->num_blocks = num_blocks - span_num_blocks; \ |
| | 1839 | flush_render_block_buffer(psx_gpu); \ |
| | 1840 | num_blocks = span_num_blocks; \ |
| | 1841 | block = psx_gpu->blocks; \ |
| | 1842 | } \ |
| | 1843 | |
| | 1844 | #define setup_blocks_add_blocks_direct() \ |
| | 1845 | texel_blocks_untextured += span_num_blocks; \ |
| | 1846 | span_pixel_blocks += span_num_blocks \ |
| | 1847 | |
| | 1848 | |
| | 1849 | #define setup_blocks_builder(shading, texturing, dithering, sw, target) \ |
| | 1850 | void setup_blocks_##shading##_##texturing##_##dithering##_##sw##_##target( \ |
| | 1851 | psx_gpu_struct *psx_gpu) \ |
| | 1852 | { \ |
| | 1853 | setup_blocks_load_msb_mask_##target(); \ |
| | 1854 | setup_blocks_variables_##shading##_##texturing(target); \ |
| | 1855 | \ |
| | 1856 | edge_data_struct *span_edge_data = psx_gpu->span_edge_data; \ |
| | 1857 | vec_4x32u *span_uvrg_offset = psx_gpu->span_uvrg_offset; \ |
| | 1858 | u32 *span_b_offset = psx_gpu->span_b_offset; \ |
| | 1859 | \ |
| | 1860 | block_struct *block = psx_gpu->blocks + psx_gpu->num_blocks; \ |
| | 1861 | \ |
| | 1862 | u32 num_spans = psx_gpu->num_spans; \ |
| | 1863 | \ |
| | 1864 | u16 *fb_ptr; \ |
| | 1865 | u32 y; \ |
| | 1866 | \ |
| | 1867 | u32 num_blocks = psx_gpu->num_blocks; \ |
| | 1868 | u32 span_num_blocks; \ |
| | 1869 | \ |
| | 1870 | while(num_spans) \ |
| | 1871 | { \ |
| | 1872 | span_num_blocks = span_edge_data->num_blocks; \ |
| | 1873 | if(span_num_blocks) \ |
| | 1874 | { \ |
| | 1875 | y = span_edge_data->y; \ |
| | 1876 | fb_ptr = psx_gpu->vram_out_ptr + span_edge_data->left_x + (y * 1024); \ |
| | 1877 | \ |
| | 1878 | setup_blocks_span_initialize_##shading##_##texturing(); \ |
| | 1879 | setup_blocks_span_initialize_##dithering(texturing); \ |
| | 1880 | \ |
| | 1881 | setup_blocks_add_blocks_##target(); \ |
| | 1882 | \ |
| | 1883 | s32 pixel_span = span_num_blocks * 8; \ |
| | 1884 | pixel_span -= __builtin_popcount(span_edge_data->right_mask & 0xFF); \ |
| | 1885 | span_pixels += pixel_span; \ |
| | 1886 | \ |
| | 1887 | span_num_blocks--; \ |
| | 1888 | while(span_num_blocks) \ |
| | 1889 | { \ |
| | 1890 | setup_blocks_store_##shading##_##texturing(sw, dithering, target, \ |
| | 1891 | full); \ |
| | 1892 | setup_blocks_store_draw_mask_##texturing##_##target(block, 0x00); \ |
| | 1893 | \ |
| | 1894 | fb_ptr += 8; \ |
| | 1895 | block++; \ |
| | 1896 | span_num_blocks--; \ |
| | 1897 | } \ |
| | 1898 | \ |
| | 1899 | setup_blocks_store_##shading##_##texturing(sw, dithering, target, edge); \ |
| | 1900 | setup_blocks_store_draw_mask_##texturing##_##target(block, \ |
| | 1901 | span_edge_data->right_mask); \ |
| | 1902 | \ |
| | 1903 | block++; \ |
| | 1904 | } \ |
| | 1905 | else \ |
| | 1906 | { \ |
| | 1907 | zero_block_spans++; \ |
| | 1908 | } \ |
| | 1909 | \ |
| | 1910 | num_spans--; \ |
| | 1911 | span_edge_data++; \ |
| | 1912 | span_uvrg_offset++; \ |
| | 1913 | span_b_offset++; \ |
| | 1914 | } \ |
| | 1915 | \ |
| | 1916 | psx_gpu->num_blocks = num_blocks; \ |
| | 1917 | } \ |
| | 1918 | |
| | 1919 | void setup_blocks_shaded_textured_dithered_unswizzled_indirect(psx_gpu_struct |
| | 1920 | *psx_gpu); |
| | 1921 | |
| | 1922 | void setup_blocks_shaded_untextured_dithered_unswizzled_indirect(psx_gpu_struct |
| | 1923 | *psx_gpu); |
| | 1924 | void setup_blocks_shaded_untextured_undithered_unswizzled_indirect( |
| | 1925 | psx_gpu_struct *psx_gpu); |
| | 1926 | void setup_blocks_shaded_untextured_dithered_unswizzled_direct(psx_gpu_struct |
| | 1927 | *psx_gpu); |
| | 1928 | void setup_blocks_shaded_untextured_undithered_unswizzled_direct( |
| | 1929 | psx_gpu_struct *psx_gpu); |
| | 1930 | |
| | 1931 | void setup_blocks_unshaded_textured_dithered_unswizzled_indirect(psx_gpu_struct |
| | 1932 | *psx_gpu); |
| | 1933 | void setup_blocks_unshaded_untextured_undithered_unswizzled_indirect( |
| | 1934 | psx_gpu_struct *psx_gpu); |
| | 1935 | void setup_blocks_unshaded_untextured_undithered_unswizzled_direct( |
| | 1936 | psx_gpu_struct *psx_gpu); |
| | 1937 | |
| | 1938 | void setup_blocks_shaded_textured_dithered_swizzled_indirect(psx_gpu_struct |
| | 1939 | *psx_gpu); |
| | 1940 | void setup_blocks_unshaded_textured_dithered_swizzled_indirect(psx_gpu_struct |
| | 1941 | *psx_gpu); |
| | 1942 | |
| | 1943 | |
| | 1944 | //setup_blocks_builder(unshaded, untextured, undithered, unswizzled, direct); |
| | 1945 | |
| | 1946 | #ifndef NEON_BUILD |
| | 1947 | |
| | 1948 | setup_blocks_builder(shaded, textured, dithered, swizzled, indirect); |
| | 1949 | setup_blocks_builder(shaded, textured, dithered, unswizzled, indirect); |
| | 1950 | |
| | 1951 | setup_blocks_builder(unshaded, textured, dithered, unswizzled, indirect); |
| | 1952 | setup_blocks_builder(unshaded, textured, dithered, swizzled, indirect); |
| | 1953 | |
| | 1954 | setup_blocks_builder(shaded, untextured, undithered, unswizzled, indirect); |
| | 1955 | setup_blocks_builder(shaded, untextured, dithered, unswizzled, indirect); |
| | 1956 | setup_blocks_builder(shaded, untextured, undithered, unswizzled, direct); |
| | 1957 | setup_blocks_builder(shaded, untextured, dithered, unswizzled, direct); |
| | 1958 | |
| | 1959 | setup_blocks_builder(unshaded, untextured, undithered, unswizzled, indirect); |
| | 1960 | setup_blocks_builder(unshaded, untextured, undithered, unswizzled, direct); |
| | 1961 | |
| | 1962 | #endif |
| | 1963 | |
| | 1964 | void texture_blocks_untextured(psx_gpu_struct *psx_gpu); |
| | 1965 | void texture_blocks_4bpp(psx_gpu_struct *psx_gpu); |
| | 1966 | void texture_blocks_8bpp(psx_gpu_struct *psx_gpu); |
| | 1967 | void texture_blocks_16bpp(psx_gpu_struct *psx_gpu); |
| | 1968 | |
| | 1969 | #ifndef NEON_BUILD |
| | 1970 | |
| | 1971 | void texture_blocks_untextured(psx_gpu_struct *psx_gpu) |
| | 1972 | { |
| | 1973 | if(psx_gpu->primitive_type != PRIMITIVE_TYPE_SPRITE) |
| | 1974 | texel_blocks_untextured += psx_gpu->num_blocks; |
| | 1975 | } |
| | 1976 | |
| | 1977 | void texture_blocks_4bpp(psx_gpu_struct *psx_gpu) |
| | 1978 | { |
| | 1979 | block_struct *block = psx_gpu->blocks; |
| | 1980 | u32 num_blocks = psx_gpu->num_blocks; |
| | 1981 | texel_blocks_4bpp += num_blocks; |
| | 1982 | |
| | 1983 | vec_8x8u texels_low; |
| | 1984 | vec_8x8u texels_high; |
| | 1985 | vec_8x8u texels; |
| | 1986 | vec_8x16u pixels; |
| | 1987 | |
| | 1988 | vec_8x16u clut_a; |
| | 1989 | vec_8x16u clut_b; |
| | 1990 | vec_16x8u clut_low; |
| | 1991 | vec_16x8u clut_high; |
| | 1992 | |
| | 1993 | u8 *texture_ptr_8bpp = psx_gpu->texture_page_ptr; |
| | 1994 | u16 *clut_ptr = psx_gpu->clut_ptr; |
| | 1995 | |
| | 1996 | // Can be done with one deinterleaving load on NEON |
| | 1997 | load_8x16b(clut_a, clut_ptr); |
| | 1998 | load_8x16b(clut_b, clut_ptr + 8); |
| | 1999 | unzip_16x8b(clut_low, clut_high, clut_a, clut_b); |
| | 2000 | |
| | 2001 | if(psx_gpu->current_texture_mask & psx_gpu->dirty_textures_4bpp_mask) |
| | 2002 | update_texture_4bpp_cache(psx_gpu); |
| | 2003 | |
| | 2004 | while(num_blocks) |
| | 2005 | { |
| | 2006 | texels.e[0] = texture_ptr_8bpp[block->uv.e[0]]; |
| | 2007 | texels.e[1] = texture_ptr_8bpp[block->uv.e[1]]; |
| | 2008 | texels.e[2] = texture_ptr_8bpp[block->uv.e[2]]; |
| | 2009 | texels.e[3] = texture_ptr_8bpp[block->uv.e[3]]; |
| | 2010 | texels.e[4] = texture_ptr_8bpp[block->uv.e[4]]; |
| | 2011 | texels.e[5] = texture_ptr_8bpp[block->uv.e[5]]; |
| | 2012 | texels.e[6] = texture_ptr_8bpp[block->uv.e[6]]; |
| | 2013 | texels.e[7] = texture_ptr_8bpp[block->uv.e[7]]; |
| | 2014 | |
| | 2015 | tbl_16(texels_low, texels, clut_low); |
| | 2016 | tbl_16(texels_high, texels, clut_high); |
| | 2017 | |
| | 2018 | // Can be done with an interleaving store on NEON |
| | 2019 | zip_8x16b(pixels, texels_low, texels_high); |
| | 2020 | |
| | 2021 | block->texels = pixels; |
| | 2022 | |
| | 2023 | num_blocks--; |
| | 2024 | block++; |
| | 2025 | } |
| | 2026 | } |
| | 2027 | |
| | 2028 | void texture_blocks_8bpp(psx_gpu_struct *psx_gpu) |
| | 2029 | { |
| | 2030 | block_struct *block = psx_gpu->blocks; |
| | 2031 | u32 num_blocks = psx_gpu->num_blocks; |
| | 2032 | |
| | 2033 | texel_blocks_8bpp += num_blocks; |
| | 2034 | |
| | 2035 | if(psx_gpu->current_texture_mask & psx_gpu->dirty_textures_8bpp_mask) |
| | 2036 | update_texture_8bpp_cache(psx_gpu); |
| | 2037 | |
| | 2038 | vec_8x16u texels; |
| | 2039 | u8 *texture_ptr_8bpp = psx_gpu->texture_page_ptr; |
| | 2040 | |
| | 2041 | u32 texel; |
| | 2042 | u32 offset; |
| | 2043 | u32 i; |
| | 2044 | |
| | 2045 | while(num_blocks) |
| | 2046 | { |
| | 2047 | for(i = 0; i < 8; i++) |
| | 2048 | { |
| | 2049 | offset = block->uv.e[i]; |
| | 2050 | |
| | 2051 | texel = texture_ptr_8bpp[offset]; |
| | 2052 | texels.e[i] = psx_gpu->clut_ptr[texel]; |
| | 2053 | } |
| | 2054 | |
| | 2055 | block->texels = texels; |
| | 2056 | |
| | 2057 | num_blocks--; |
| | 2058 | block++; |
| | 2059 | } |
| | 2060 | } |
| | 2061 | |
| | 2062 | void texture_blocks_16bpp(psx_gpu_struct *psx_gpu) |
| | 2063 | { |
| | 2064 | block_struct *block = psx_gpu->blocks; |
| | 2065 | u32 num_blocks = psx_gpu->num_blocks; |
| | 2066 | |
| | 2067 | texel_blocks_16bpp += num_blocks; |
| | 2068 | |
| | 2069 | vec_8x16u texels; |
| | 2070 | |
| | 2071 | u16 *texture_ptr_16bpp = psx_gpu->texture_page_ptr; |
| | 2072 | u32 offset; |
| | 2073 | u32 i; |
| | 2074 | |
| | 2075 | while(num_blocks) |
| | 2076 | { |
| | 2077 | for(i = 0; i < 8; i++) |
| | 2078 | { |
| | 2079 | offset = block->uv.e[i]; |
| | 2080 | offset += ((offset & 0xFF00) * 3); |
| | 2081 | |
| | 2082 | texels.e[i] = texture_ptr_16bpp[offset]; |
| | 2083 | } |
| | 2084 | |
| | 2085 | block->texels = texels; |
| | 2086 | |
| | 2087 | num_blocks--; |
| | 2088 | block++; |
| | 2089 | } |
| | 2090 | } |
| | 2091 | |
| | 2092 | #endif |
| | 2093 | |
| | 2094 | |
| | 2095 | #define shade_blocks_load_msb_mask_indirect() \ |
| | 2096 | |
| | 2097 | #define shade_blocks_load_msb_mask_direct() \ |
| | 2098 | vec_8x16u msb_mask; \ |
| | 2099 | dup_8x16b(msb_mask, psx_gpu->mask_msb); \ |
| | 2100 | |
| | 2101 | #define shade_blocks_store_indirect(_draw_mask, _pixels) \ |
| | 2102 | block->draw_mask = _draw_mask; \ |
| | 2103 | block->pixels = _pixels \ |
| | 2104 | |
| | 2105 | #define shade_blocks_store_direct(_draw_mask, _pixels) \ |
| | 2106 | { \ |
| | 2107 | vec_8x16u fb_pixels; \ |
| | 2108 | or_8x16b(_pixels, _pixels, msb_mask); \ |
| | 2109 | load_8x16b(fb_pixels, block->fb_ptr); \ |
| | 2110 | bif_8x16b(fb_pixels, _pixels, _draw_mask); \ |
| | 2111 | store_8x16b(fb_pixels, block->fb_ptr); \ |
| | 2112 | } \ |
| | 2113 | |
| | 2114 | |
| | 2115 | #define shade_blocks_textured_false_modulated_check_dithered(target) \ |
| | 2116 | if(psx_gpu->triangle_color == 0x808080) \ |
| | 2117 | { \ |
| | 2118 | false_modulated_blocks += num_blocks; \ |
| | 2119 | } \ |
| | 2120 | |
| | 2121 | #define shade_blocks_textured_false_modulated_check_undithered(target) \ |
| | 2122 | if(psx_gpu->triangle_color == 0x808080) \ |
| | 2123 | { \ |
| | 2124 | \ |
| | 2125 | shade_blocks_textured_unmodulated_##target(psx_gpu); \ |
| | 2126 | false_modulated_blocks += num_blocks; \ |
| | 2127 | return; \ |
| | 2128 | } \ |
| | 2129 | |
| | 2130 | |
| | 2131 | #define shade_blocks_textured_modulated_shaded_primitive_load(dithering, \ |
| | 2132 | target) \ |
| | 2133 | |
| | 2134 | #define shade_blocks_textured_modulated_unshaded_primitive_load(dithering, \ |
| | 2135 | target) \ |
| | 2136 | { \ |
| | 2137 | u32 color = psx_gpu->triangle_color; \ |
| | 2138 | dup_8x8b(colors_r, color); \ |
| | 2139 | dup_8x8b(colors_g, color >> 8); \ |
| | 2140 | dup_8x8b(colors_b, color >> 16); \ |
| | 2141 | shade_blocks_textured_false_modulated_check_##dithering(target); \ |
| | 2142 | } \ |
| | 2143 | |
| | 2144 | #define shade_blocks_textured_modulated_shaded_block_load() \ |
| | 2145 | colors_r = block->r; \ |
| | 2146 | colors_g = block->g; \ |
| | 2147 | colors_b = block->b \ |
| | 2148 | |
| | 2149 | #define shade_blocks_textured_modulated_unshaded_block_load() \ |
| | 2150 | |
| | 2151 | #define shade_blocks_textured_modulate_dithered(component) \ |
| | 2152 | pixels_##component = block->dither_offsets; \ |
| | 2153 | mla_long_8x8b(pixels_##component, texels_##component, colors_##component) \ |
| | 2154 | |
| | 2155 | #define shade_blocks_textured_modulate_undithered(component) \ |
| | 2156 | mul_long_8x8b(pixels_##component, texels_##component, colors_##component) \ |
| | 2157 | |
| | 2158 | #define shade_blocks_textured_modulated_builder(shading, dithering, target) \ |
| | 2159 | void shade_blocks_##shading##_textured_modulated_##dithering##_##target( \ |
| | 2160 | psx_gpu_struct *psx_gpu) \ |
| | 2161 | { \ |
| | 2162 | block_struct *block = psx_gpu->blocks; \ |
| | 2163 | u32 num_blocks = psx_gpu->num_blocks; \ |
| | 2164 | vec_8x16u texels; \ |
| | 2165 | \ |
| | 2166 | vec_8x8u texels_r; \ |
| | 2167 | vec_8x8u texels_g; \ |
| | 2168 | vec_8x8u texels_b; \ |
| | 2169 | \ |
| | 2170 | vec_8x8u colors_r; \ |
| | 2171 | vec_8x8u colors_g; \ |
| | 2172 | vec_8x8u colors_b; \ |
| | 2173 | \ |
| | 2174 | vec_8x8u pixels_r_low; \ |
| | 2175 | vec_8x8u pixels_g_low; \ |
| | 2176 | vec_8x8u pixels_b_low; \ |
| | 2177 | vec_8x16u pixels; \ |
| | 2178 | \ |
| | 2179 | vec_8x16u pixels_r; \ |
| | 2180 | vec_8x16u pixels_g; \ |
| | 2181 | vec_8x16u pixels_b; \ |
| | 2182 | \ |
| | 2183 | vec_8x16u draw_mask; \ |
| | 2184 | vec_8x16u zero_mask; \ |
| | 2185 | \ |
| | 2186 | vec_8x8u d64_0x07; \ |
| | 2187 | vec_8x8u d64_0x1F; \ |
| | 2188 | vec_8x8u d64_1; \ |
| | 2189 | vec_8x8u d64_4; \ |
| | 2190 | vec_8x8u d64_128; \ |
| | 2191 | \ |
| | 2192 | vec_8x16u d128_0x8000; \ |
| | 2193 | \ |
| | 2194 | vec_8x16u test_mask = psx_gpu->test_mask; \ |
| | 2195 | u32 draw_mask_bits; \ |
| | 2196 | shade_blocks_load_msb_mask_##target(); \ |
| | 2197 | \ |
| | 2198 | dup_8x8b(d64_0x07, 0x07); \ |
| | 2199 | dup_8x8b(d64_0x1F, 0x1F); \ |
| | 2200 | dup_8x8b(d64_1, 1); \ |
| | 2201 | dup_8x8b(d64_4, 4); \ |
| | 2202 | dup_8x8b(d64_128, 128); \ |
| | 2203 | \ |
| | 2204 | dup_8x16b(d128_0x8000, 0x8000); \ |
| | 2205 | \ |
| | 2206 | shade_blocks_textured_modulated_##shading##_primitive_load(dithering, \ |
| | 2207 | target); \ |
| | 2208 | \ |
| | 2209 | while(num_blocks) \ |
| | 2210 | { \ |
| | 2211 | draw_mask_bits = block->draw_mask_bits; \ |
| | 2212 | dup_8x16b(draw_mask, draw_mask_bits); \ |
| | 2213 | tst_8x16b(draw_mask, draw_mask, test_mask); \ |
| | 2214 | \ |
| | 2215 | shade_blocks_textured_modulated_##shading##_block_load(); \ |
| | 2216 | \ |
| | 2217 | texels = block->texels; \ |
| | 2218 | \ |
| | 2219 | mov_narrow_8x16b(texels_r, texels); \ |
| | 2220 | shr_narrow_8x16b(texels_g, texels, 5); \ |
| | 2221 | shr_narrow_8x16b(texels_b, texels, 7); \ |
| | 2222 | \ |
| | 2223 | and_8x8b(texels_r, texels_r, d64_0x1F); \ |
| | 2224 | and_8x8b(texels_g, texels_g, d64_0x1F); \ |
| | 2225 | shr_8x8b(texels_b, texels_b, 3); \ |
| | 2226 | \ |
| | 2227 | shade_blocks_textured_modulate_##dithering(r); \ |
| | 2228 | shade_blocks_textured_modulate_##dithering(g); \ |
| | 2229 | shade_blocks_textured_modulate_##dithering(b); \ |
| | 2230 | \ |
| | 2231 | cmpeqz_8x16b(zero_mask, texels); \ |
| | 2232 | and_8x16b(pixels, texels, d128_0x8000); \ |
| | 2233 | \ |
| | 2234 | shrq_narrow_signed_8x16b(pixels_r_low, pixels_r, 4); \ |
| | 2235 | shrq_narrow_signed_8x16b(pixels_g_low, pixels_g, 4); \ |
| | 2236 | shrq_narrow_signed_8x16b(pixels_b_low, pixels_b, 4); \ |
| | 2237 | \ |
| | 2238 | or_8x16b(zero_mask, draw_mask, zero_mask); \ |
| | 2239 | \ |
| | 2240 | shr_8x8b(pixels_r_low, pixels_r_low, 3); \ |
| | 2241 | bic_8x8b(pixels_g_low, pixels_g_low, d64_0x07); \ |
| | 2242 | bic_8x8b(pixels_b_low, pixels_b_low, d64_0x07); \ |
| | 2243 | \ |
| | 2244 | mla_long_8x8b(pixels, pixels_r_low, d64_1); \ |
| | 2245 | mla_long_8x8b(pixels, pixels_g_low, d64_4); \ |
| | 2246 | mla_long_8x8b(pixels, pixels_b_low, d64_128); \ |
| | 2247 | \ |
| | 2248 | shade_blocks_store_##target(zero_mask, pixels); \ |
| | 2249 | \ |
| | 2250 | num_blocks--; \ |
| | 2251 | block++; \ |
| | 2252 | } \ |
| | 2253 | } \ |
| | 2254 | |
| | 2255 | void shade_blocks_shaded_textured_modulated_dithered_direct(psx_gpu_struct |
| | 2256 | *psx_gpu); |
| | 2257 | void shade_blocks_shaded_textured_modulated_undithered_direct(psx_gpu_struct |
| | 2258 | *psx_gpu); |
| | 2259 | void shade_blocks_unshaded_textured_modulated_dithered_direct(psx_gpu_struct |
| | 2260 | *psx_gpu); |
| | 2261 | void shade_blocks_unshaded_textured_modulated_undithered_direct(psx_gpu_struct |
| | 2262 | *psx_gpu); |
| | 2263 | |
| | 2264 | void shade_blocks_shaded_textured_modulated_dithered_indirect(psx_gpu_struct |
| | 2265 | *psx_gpu); |
| | 2266 | void shade_blocks_shaded_textured_modulated_undithered_indirect(psx_gpu_struct |
| | 2267 | *psx_gpu); |
| | 2268 | void shade_blocks_unshaded_textured_modulated_dithered_indirect(psx_gpu_struct |
| | 2269 | *psx_gpu); |
| | 2270 | void shade_blocks_unshaded_textured_modulated_undithered_indirect(psx_gpu_struct |
| | 2271 | *psx_gpu); |
| | 2272 | |
| | 2273 | void shade_blocks_textured_unmodulated_indirect(psx_gpu_struct *psx_gpu); |
| | 2274 | void shade_blocks_textured_unmodulated_direct(psx_gpu_struct *psx_gpu); |
| | 2275 | |
| | 2276 | #ifndef NEON_BUILD |
| | 2277 | |
| | 2278 | shade_blocks_textured_modulated_builder(shaded, dithered, direct); |
| | 2279 | shade_blocks_textured_modulated_builder(shaded, undithered, direct); |
| | 2280 | shade_blocks_textured_modulated_builder(unshaded, dithered, direct); |
| | 2281 | shade_blocks_textured_modulated_builder(unshaded, undithered, direct); |
| | 2282 | |
| | 2283 | shade_blocks_textured_modulated_builder(shaded, dithered, indirect); |
| | 2284 | shade_blocks_textured_modulated_builder(shaded, undithered, indirect); |
| | 2285 | shade_blocks_textured_modulated_builder(unshaded, dithered, indirect); |
| | 2286 | shade_blocks_textured_modulated_builder(unshaded, undithered, indirect); |
| | 2287 | |
| | 2288 | #endif |
| | 2289 | |
| | 2290 | |
| | 2291 | #define shade_blocks_textured_unmodulated_builder(target) \ |
| | 2292 | void shade_blocks_textured_unmodulated_##target(psx_gpu_struct *psx_gpu) \ |
| | 2293 | { \ |
| | 2294 | block_struct *block = psx_gpu->blocks; \ |
| | 2295 | u32 num_blocks = psx_gpu->num_blocks; \ |
| | 2296 | vec_8x16u draw_mask; \ |
| | 2297 | vec_8x16u test_mask = psx_gpu->test_mask; \ |
| | 2298 | u32 draw_mask_bits; \ |
| | 2299 | \ |
| | 2300 | vec_8x16u pixels; \ |
| | 2301 | shade_blocks_load_msb_mask_##target(); \ |
| | 2302 | \ |
| | 2303 | while(num_blocks) \ |
| | 2304 | { \ |
| | 2305 | vec_8x16u zero_mask; \ |
| | 2306 | \ |
| | 2307 | draw_mask_bits = block->draw_mask_bits; \ |
| | 2308 | dup_8x16b(draw_mask, draw_mask_bits); \ |
| | 2309 | tst_8x16b(draw_mask, draw_mask, test_mask); \ |
| | 2310 | \ |
| | 2311 | pixels = block->texels; \ |
| | 2312 | \ |
| | 2313 | cmpeqz_8x16b(zero_mask, pixels); \ |
| | 2314 | or_8x16b(zero_mask, draw_mask, zero_mask); \ |
| | 2315 | \ |
| | 2316 | shade_blocks_store_##target(zero_mask, pixels); \ |
| | 2317 | \ |
| | 2318 | num_blocks--; \ |
| | 2319 | block++; \ |
| | 2320 | } \ |
| | 2321 | } \ |
| | 2322 | |
| | 2323 | #define shade_blocks_textured_unmodulated_dithered_builder(target) \ |
| | 2324 | void shade_blocks_textured_unmodulated_dithered_##target(psx_gpu_struct \ |
| | 2325 | *psx_gpu) \ |
| | 2326 | { \ |
| | 2327 | block_struct *block = psx_gpu->blocks; \ |
| | 2328 | u32 num_blocks = psx_gpu->num_blocks; \ |
| | 2329 | vec_8x16u draw_mask; \ |
| | 2330 | vec_8x16u test_mask = psx_gpu->test_mask; \ |
| | 2331 | u32 draw_mask_bits; \ |
| | 2332 | \ |
| | 2333 | vec_8x16u pixels; \ |
| | 2334 | shade_blocks_load_msb_mask_##target(); \ |
| | 2335 | \ |
| | 2336 | while(num_blocks) \ |
| | 2337 | { \ |
| | 2338 | vec_8x16u zero_mask; \ |
| | 2339 | \ |
| | 2340 | draw_mask_bits = block->draw_mask_bits; \ |
| | 2341 | dup_8x16b(draw_mask, draw_mask_bits); \ |
| | 2342 | tst_8x16b(draw_mask, draw_mask, test_mask); \ |
| | 2343 | \ |
| | 2344 | pixels = block->texels; \ |
| | 2345 | \ |
| | 2346 | cmpeqz_8x16b(zero_mask, pixels); \ |
| | 2347 | or_8x16b(zero_mask, draw_mask, zero_mask); \ |
| | 2348 | \ |
| | 2349 | shade_blocks_store_##target(zero_mask, pixels); \ |
| | 2350 | \ |
| | 2351 | num_blocks--; \ |
| | 2352 | block++; \ |
| | 2353 | } \ |
| | 2354 | } \ |
| | 2355 | |
| | 2356 | #ifndef NEON_BUILD |
| | 2357 | |
| | 2358 | shade_blocks_textured_unmodulated_builder(indirect) |
| | 2359 | shade_blocks_textured_unmodulated_builder(direct) |
| | 2360 | |
| | 2361 | #endif |
| | 2362 | |
| | 2363 | |
| | 2364 | void shade_blocks_unshaded_untextured_indirect(psx_gpu_struct *psx_gpu); |
| | 2365 | void shade_blocks_unshaded_untextured_direct(psx_gpu_struct *psx_gpu); |
| | 2366 | |
| | 2367 | #ifndef NEON_BUILD |
| | 2368 | |
| | 2369 | void shade_blocks_unshaded_untextured_indirect(psx_gpu_struct *psx_gpu) |
| | 2370 | { |
| | 2371 | } |
| | 2372 | |
| | 2373 | void shade_blocks_unshaded_untextured_direct(psx_gpu_struct *psx_gpu) |
| | 2374 | { |
| | 2375 | block_struct *block = psx_gpu->blocks; |
| | 2376 | u32 num_blocks = psx_gpu->num_blocks; |
| | 2377 | |
| | 2378 | vec_8x16u pixels = block->pixels; |
| | 2379 | shade_blocks_load_msb_mask_direct(); |
| | 2380 | |
| | 2381 | while(num_blocks) |
| | 2382 | { |
| | 2383 | shade_blocks_store_direct(block->draw_mask, pixels); |
| | 2384 | |
| | 2385 | num_blocks--; |
| | 2386 | block++; |
| | 2387 | } |
| | 2388 | } |
| | 2389 | |
| | 2390 | #endif |
| | 2391 | |
| | 2392 | void shade_blocks_shaded_untextured(psx_gpu_struct *psx_gpu) |
| | 2393 | { |
| | 2394 | } |
| | 2395 | |
| | 2396 | |
| | 2397 | #define blend_blocks_mask_evaluate_on() \ |
| | 2398 | vec_8x16u mask_pixels; \ |
| | 2399 | cmpltz_8x16b(mask_pixels, framebuffer_pixels); \ |
| | 2400 | or_8x16b(draw_mask, draw_mask, mask_pixels) \ |
| | 2401 | |
| | 2402 | #define blend_blocks_mask_evaluate_off() \ |
| | 2403 | |
| | 2404 | #define blend_blocks_average() \ |
| | 2405 | { \ |
| | 2406 | vec_8x16u pixels_no_msb; \ |
| | 2407 | vec_8x16u fb_pixels_no_msb; \ |
| | 2408 | \ |
| | 2409 | vec_8x16u d128_0x0421; \ |
| | 2410 | vec_8x16u d128_0x8000; \ |
| | 2411 | \ |
| | 2412 | dup_8x16b(d128_0x0421, 0x0421); \ |
| | 2413 | dup_8x16b(d128_0x8000, 0x8000); \ |
| | 2414 | \ |
| | 2415 | eor_8x16b(blend_pixels, pixels, framebuffer_pixels); \ |
| | 2416 | bic_8x16b(pixels_no_msb, pixels, d128_0x8000); \ |
| | 2417 | and_8x16b(blend_pixels, blend_pixels, d128_0x0421); \ |
| | 2418 | sub_8x16b(blend_pixels, pixels_no_msb, blend_pixels); \ |
| | 2419 | bic_8x16b(fb_pixels_no_msb, framebuffer_pixels, d128_0x8000); \ |
| | 2420 | average_8x16b(blend_pixels, fb_pixels_no_msb, blend_pixels); \ |
| | 2421 | } \ |
| | 2422 | |
| | 2423 | #define blend_blocks_add() \ |
| | 2424 | { \ |
| | 2425 | vec_8x16u pixels_rb, pixels_g; \ |
| | 2426 | vec_8x16u fb_rb, fb_g; \ |
| | 2427 | \ |
| | 2428 | vec_8x16u d128_0x7C1F; \ |
| | 2429 | vec_8x16u d128_0x03E0; \ |
| | 2430 | \ |
| | 2431 | dup_8x16b(d128_0x7C1F, 0x7C1F); \ |
| | 2432 | dup_8x16b(d128_0x03E0, 0x03E0); \ |
| | 2433 | \ |
| | 2434 | and_8x16b(pixels_rb, pixels, d128_0x7C1F); \ |
| | 2435 | and_8x16b(pixels_g, pixels, d128_0x03E0); \ |
| | 2436 | \ |
| | 2437 | and_8x16b(fb_rb, framebuffer_pixels, d128_0x7C1F); \ |
| | 2438 | and_8x16b(fb_g, framebuffer_pixels, d128_0x03E0); \ |
| | 2439 | \ |
| | 2440 | add_8x16b(fb_rb, fb_rb, pixels_rb); \ |
| | 2441 | add_8x16b(fb_g, fb_g, pixels_g); \ |
| | 2442 | \ |
| | 2443 | min_16x8b(vector_cast(vec_16x8u, fb_rb), vector_cast(vec_16x8u, fb_rb), \ |
| | 2444 | vector_cast(vec_16x8u, d128_0x7C1F)); \ |
| | 2445 | min_8x16b(fb_g, fb_g, d128_0x03E0); \ |
| | 2446 | \ |
| | 2447 | or_8x16b(blend_pixels, fb_rb, fb_g); \ |
| | 2448 | } \ |
| | 2449 | |
| | 2450 | #define blend_blocks_subtract() \ |
| | 2451 | { \ |
| | 2452 | vec_8x16u pixels_rb, pixels_g; \ |
| | 2453 | vec_8x16u fb_rb, fb_g; \ |
| | 2454 | \ |
| | 2455 | vec_8x16u d128_0x7C1F; \ |
| | 2456 | vec_8x16u d128_0x03E0; \ |
| | 2457 | \ |
| | 2458 | dup_8x16b(d128_0x7C1F, 0x7C1F); \ |
| | 2459 | dup_8x16b(d128_0x03E0, 0x03E0); \ |
| | 2460 | \ |
| | 2461 | and_8x16b(pixels_rb, pixels, d128_0x7C1F); \ |
| | 2462 | and_8x16b(pixels_g, pixels, d128_0x03E0); \ |
| | 2463 | \ |
| | 2464 | and_8x16b(fb_rb, framebuffer_pixels, d128_0x7C1F); \ |
| | 2465 | and_8x16b(fb_g, framebuffer_pixels, d128_0x03E0); \ |
| | 2466 | \ |
| | 2467 | subs_16x8b(vector_cast(vec_16x8u, fb_rb), \ |
| | 2468 | vector_cast(vec_16x8u, fb_rb), vector_cast(vec_16x8u, pixels_rb)); \ |
| | 2469 | subs_8x16b(fb_g, fb_g, pixels_g); \ |
| | 2470 | \ |
| | 2471 | or_8x16b(blend_pixels, fb_rb, fb_g); \ |
| | 2472 | } \ |
| | 2473 | |
| | 2474 | #define blend_blocks_add_fourth() \ |
| | 2475 | { \ |
| | 2476 | vec_8x16u pixels_rb, pixels_g; \ |
| | 2477 | vec_8x16u pixels_fourth; \ |
| | 2478 | vec_8x16u fb_rb, fb_g; \ |
| | 2479 | \ |
| | 2480 | vec_8x16u d128_0x7C1F; \ |
| | 2481 | vec_8x16u d128_0x1C07; \ |
| | 2482 | vec_8x16u d128_0x03E0; \ |
| | 2483 | vec_8x16u d128_0x00E0; \ |
| | 2484 | \ |
| | 2485 | dup_8x16b(d128_0x7C1F, 0x7C1F); \ |
| | 2486 | dup_8x16b(d128_0x1C07, 0x1C07); \ |
| | 2487 | dup_8x16b(d128_0x03E0, 0x03E0); \ |
| | 2488 | dup_8x16b(d128_0x00E0, 0x00E0); \ |
| | 2489 | \ |
| | 2490 | shr_8x16b(pixels_fourth, vector_cast(vec_8x16s, pixels), 2); \ |
| | 2491 | \ |
| | 2492 | and_8x16b(fb_rb, framebuffer_pixels, d128_0x7C1F); \ |
| | 2493 | and_8x16b(fb_g, framebuffer_pixels, d128_0x03E0); \ |
| | 2494 | \ |
| | 2495 | and_8x16b(pixels_rb, pixels_fourth, d128_0x1C07); \ |
| | 2496 | and_8x16b(pixels_g, pixels_fourth, d128_0x00E0); \ |
| | 2497 | \ |
| | 2498 | add_8x16b(fb_rb, fb_rb, pixels_rb); \ |
| | 2499 | add_8x16b(fb_g, fb_g, pixels_g); \ |
| | 2500 | \ |
| | 2501 | min_16x8b(vector_cast(vec_16x8u, fb_rb), vector_cast(vec_16x8u, fb_rb), \ |
| | 2502 | vector_cast(vec_16x8u, d128_0x7C1F)); \ |
| | 2503 | min_8x16b(fb_g, fb_g, d128_0x03E0); \ |
| | 2504 | \ |
| | 2505 | or_8x16b(blend_pixels, fb_rb, fb_g); \ |
| | 2506 | } \ |
| | 2507 | |
| | 2508 | #define blend_blocks_blended_combine_textured() \ |
| | 2509 | { \ |
| | 2510 | vec_8x16u blend_mask; \ |
| | 2511 | cmpltz_8x16b(blend_mask, pixels); \ |
| | 2512 | \ |
| | 2513 | or_immediate_8x16b(blend_pixels, blend_pixels, 0x8000); \ |
| | 2514 | bif_8x16b(blend_pixels, pixels, blend_mask); \ |
| | 2515 | } \ |
| | 2516 | |
| | 2517 | #define blend_blocks_blended_combine_untextured() \ |
| | 2518 | |
| | 2519 | |
| | 2520 | #define blend_blocks_body_blend(blend_mode, texturing) \ |
| | 2521 | { \ |
| | 2522 | blend_blocks_##blend_mode(); \ |
| | 2523 | blend_blocks_blended_combine_##texturing(); \ |
| | 2524 | } \ |
| | 2525 | |
| | 2526 | #define blend_blocks_body_average(texturing) \ |
| | 2527 | blend_blocks_body_blend(average, texturing) \ |
| | 2528 | |
| | 2529 | #define blend_blocks_body_add(texturing) \ |
| | 2530 | blend_blocks_body_blend(add, texturing) \ |
| | 2531 | |
| | 2532 | #define blend_blocks_body_subtract(texturing) \ |
| | 2533 | blend_blocks_body_blend(subtract, texturing) \ |
| | 2534 | |
| | 2535 | #define blend_blocks_body_add_fourth(texturing) \ |
| | 2536 | blend_blocks_body_blend(add_fourth, texturing) \ |
| | 2537 | |
| | 2538 | #define blend_blocks_body_unblended(texturing) \ |
| | 2539 | blend_pixels = pixels \ |
| | 2540 | |
| | 2541 | |
| | 2542 | #define blend_blocks_builder(texturing, blend_mode, mask_evaluate) \ |
| | 2543 | void \ |
| | 2544 | blend_blocks_##texturing##_##blend_mode##_##mask_evaluate(psx_gpu_struct \ |
| | 2545 | *psx_gpu) \ |
| | 2546 | { \ |
| | 2547 | block_struct *block = psx_gpu->blocks; \ |
| | 2548 | u32 num_blocks = psx_gpu->num_blocks; \ |
| | 2549 | vec_8x16u draw_mask; \ |
| | 2550 | vec_8x16u pixels; \ |
| | 2551 | vec_8x16u blend_pixels; \ |
| | 2552 | vec_8x16u framebuffer_pixels; \ |
| | 2553 | vec_8x16u msb_mask; \ |
| | 2554 | \ |
| | 2555 | u16 *fb_ptr; \ |
| | 2556 | \ |
| | 2557 | dup_8x16b(msb_mask, psx_gpu->mask_msb); \ |
| | 2558 | \ |
| | 2559 | while(num_blocks) \ |
| | 2560 | { \ |
| | 2561 | pixels = block->pixels; \ |
| | 2562 | draw_mask = block->draw_mask; \ |
| | 2563 | fb_ptr = block->fb_ptr; \ |
| | 2564 | \ |
| | 2565 | load_8x16b(framebuffer_pixels, fb_ptr); \ |
| | 2566 | \ |
| | 2567 | blend_blocks_mask_evaluate_##mask_evaluate(); \ |
| | 2568 | blend_blocks_body_##blend_mode(texturing); \ |
| | 2569 | \ |
| | 2570 | or_8x16b(blend_pixels, blend_pixels, msb_mask); \ |
| | 2571 | bif_8x16b(framebuffer_pixels, blend_pixels, draw_mask); \ |
| | 2572 | store_8x16b(framebuffer_pixels, fb_ptr); \ |
| | 2573 | \ |
| | 2574 | blend_blocks++; \ |
| | 2575 | num_blocks--; \ |
| | 2576 | block++; \ |
| | 2577 | } \ |
| | 2578 | } \ |
| | 2579 | |
| | 2580 | void blend_blocks_textured_average_off(psx_gpu_struct *psx_gpu); |
| | 2581 | void blend_blocks_textured_average_on(psx_gpu_struct *psx_gpu); |
| | 2582 | void blend_blocks_textured_add_off(psx_gpu_struct *psx_gpu); |
| | 2583 | void blend_blocks_textured_add_on(psx_gpu_struct *psx_gpu); |
| | 2584 | void blend_blocks_textured_subtract_off(psx_gpu_struct *psx_gpu); |
| | 2585 | void blend_blocks_textured_subtract_on(psx_gpu_struct *psx_gpu); |
| | 2586 | void blend_blocks_textured_add_fourth_off(psx_gpu_struct *psx_gpu); |
| | 2587 | void blend_blocks_textured_add_fourth_on(psx_gpu_struct *psx_gpu); |
| | 2588 | |
| | 2589 | void blend_blocks_untextured_average_off(psx_gpu_struct *psx_gpu); |
| | 2590 | void blend_blocks_untextured_average_on(psx_gpu_struct *psx_gpu); |
| | 2591 | void blend_blocks_untextured_add_off(psx_gpu_struct *psx_gpu); |
| | 2592 | void blend_blocks_untextured_add_on(psx_gpu_struct *psx_gpu); |
| | 2593 | void blend_blocks_untextured_subtract_off(psx_gpu_struct *psx_gpu); |
| | 2594 | void blend_blocks_untextured_subtract_on(psx_gpu_struct *psx_gpu); |
| | 2595 | void blend_blocks_untextured_add_fourth_off(psx_gpu_struct *psx_gpu); |
| | 2596 | void blend_blocks_untextured_add_fourth_on(psx_gpu_struct *psx_gpu); |
| | 2597 | |
| | 2598 | void blend_blocks_textured_unblended_off(psx_gpu_struct *psx_gpu); |
| | 2599 | void blend_blocks_textured_unblended_on(psx_gpu_struct *psx_gpu); |
| | 2600 | |
| | 2601 | #ifndef NEON_BUILD |
| | 2602 | |
| | 2603 | void blend_blocks_textured_unblended_off(psx_gpu_struct *psx_gpu) |
| | 2604 | { |
| | 2605 | } |
| | 2606 | |
| | 2607 | blend_blocks_builder(textured, average, off); |
| | 2608 | blend_blocks_builder(textured, average, on); |
| | 2609 | blend_blocks_builder(textured, add, off); |
| | 2610 | blend_blocks_builder(textured, add, on); |
| | 2611 | blend_blocks_builder(textured, subtract, off); |
| | 2612 | blend_blocks_builder(textured, subtract, on); |
| | 2613 | blend_blocks_builder(textured, add_fourth, off); |
| | 2614 | blend_blocks_builder(textured, add_fourth, on); |
| | 2615 | |
| | 2616 | blend_blocks_builder(untextured, average, off); |
| | 2617 | blend_blocks_builder(untextured, average, on); |
| | 2618 | blend_blocks_builder(untextured, add, off); |
| | 2619 | blend_blocks_builder(untextured, add, on); |
| | 2620 | blend_blocks_builder(untextured, subtract, off); |
| | 2621 | blend_blocks_builder(untextured, subtract, on); |
| | 2622 | blend_blocks_builder(untextured, add_fourth, off); |
| | 2623 | blend_blocks_builder(untextured, add_fourth, on); |
| | 2624 | |
| | 2625 | blend_blocks_builder(textured, unblended, on); |
| | 2626 | |
| | 2627 | #endif |
| | 2628 | |
| | 2629 | |
| | 2630 | #define vertex_swap(_a, _b) \ |
| | 2631 | { \ |
| | 2632 | vertex_struct *temp_vertex = _a; \ |
| | 2633 | _a = _b; \ |
| | 2634 | _b = temp_vertex; \ |
| | 2635 | triangle_winding ^= 1; \ |
| | 2636 | } \ |
| | 2637 | |
| | 2638 | |
| | 2639 | // Setup blocks parametric-variables: |
| | 2640 | // SHADE TEXTURE_MAP SWIZZLING |
| | 2641 | // 0 0 x |
| | 2642 | // 0 1 0 |
| | 2643 | // 0 1 1 |
| | 2644 | // 1 0 x |
| | 2645 | // 1 1 0 |
| | 2646 | // 1 1 1 |
| | 2647 | // 8 inputs, 6 combinations |
| | 2648 | |
| | 2649 | #define setup_blocks_switch_untextured_unshaded(dithering, target) \ |
| | 2650 | setup_blocks_unshaded_untextured_undithered_unswizzled_##target \ |
| | 2651 | |
| | 2652 | #define setup_blocks_switch_untextured_shaded(dithering, target) \ |
| | 2653 | setup_blocks_shaded_untextured_##dithering##_unswizzled_##target \ |
| | 2654 | |
| | 2655 | #define setup_blocks_switch_untextured(shading, texture_mode, dithering, \ |
| | 2656 | target) \ |
| | 2657 | setup_blocks_switch_untextured_##shading(dithering, target) \ |
| | 2658 | |
| | 2659 | #define setup_blocks_switch_texture_mode_4bpp(shading) \ |
| | 2660 | setup_blocks_##shading##_textured_dithered_swizzled_indirect \ |
| | 2661 | |
| | 2662 | #define setup_blocks_switch_texture_mode_8bpp(shading) \ |
| | 2663 | setup_blocks_##shading##_textured_dithered_swizzled_indirect \ |
| | 2664 | |
| | 2665 | #define setup_blocks_switch_texture_mode_16bpp(shading) \ |
| | 2666 | setup_blocks_##shading##_textured_dithered_unswizzled_indirect \ |
| | 2667 | |
| | 2668 | #define setup_blocks_switch_textured(shading, texture_mode, dithering, target) \ |
| | 2669 | setup_blocks_switch_texture_mode_##texture_mode(shading) \ |
| | 2670 | |
| | 2671 | #define setup_blocks_switch_blended(shading, texturing, texture_mode, \ |
| | 2672 | dithering, mask_evaluate) \ |
| | 2673 | setup_blocks_switch_##texturing(shading, texture_mode, dithering, indirect) \ |
| | 2674 | |
| | 2675 | #define setup_blocks_switch_unblended_on(shading, texturing, texture_mode, \ |
| | 2676 | dithering) \ |
| | 2677 | setup_blocks_switch_##texturing(shading, texture_mode, dithering, indirect) \ |
| | 2678 | |
| | 2679 | #define setup_blocks_switch_unblended_off(shading, texturing, texture_mode, \ |
| | 2680 | dithering) \ |
| | 2681 | setup_blocks_switch_##texturing(shading, texture_mode, dithering, direct) \ |
| | 2682 | |
| | 2683 | #define setup_blocks_switch_unblended(shading, texturing, texture_mode, \ |
| | 2684 | dithering, mask_evaluate) \ |
| | 2685 | setup_blocks_switch_unblended_##mask_evaluate(shading, texturing, \ |
| | 2686 | texture_mode, dithering) \ |
| | 2687 | |
| | 2688 | #define setup_blocks_switch(shading, texturing, texture_mode, dithering, \ |
| | 2689 | blending, mask_evaluate) \ |
| | 2690 | setup_blocks_switch_##blending(shading, texturing, texture_mode, \ |
| | 2691 | dithering, mask_evaluate) \ |
| | 2692 | |
| | 2693 | |
| | 2694 | // Texture blocks: |
| | 2695 | |
| | 2696 | #define texture_blocks_switch_untextured(texture_mode) \ |
| | 2697 | texture_blocks_untextured \ |
| | 2698 | |
| | 2699 | #define texture_blocks_switch_textured(texture_mode) \ |
| | 2700 | texture_blocks_##texture_mode \ |
| | 2701 | |
| | 2702 | #define texture_blocks_switch(texturing, texture_mode) \ |
| | 2703 | texture_blocks_switch_##texturing(texture_mode) \ |
| | 2704 | |
| | 2705 | |
| | 2706 | // Shade blocks parametric-variables: |
| | 2707 | // SHADE TEXTURE_MAP MODULATE_TEXELS dither_mode |
| | 2708 | // 0 0 x x |
| | 2709 | // 0 1 0 0 |
| | 2710 | // 0 1 0 1 |
| | 2711 | // x 1 1 x |
| | 2712 | // 1 0 x 0 |
| | 2713 | // 1 0 x 1 |
| | 2714 | // 1 1 0 0 |
| | 2715 | // 1 1 0 1 |
| | 2716 | // 16 inputs, 8 combinations |
| | 2717 | |
| | 2718 | #define shade_blocks_switch_unshaded_untextured(modulation, dithering, target) \ |
| | 2719 | shade_blocks_unshaded_untextured_##target \ |
| | 2720 | |
| | 2721 | #define shade_blocks_switch_unshaded_textured_unmodulated(dithering, target) \ |
| | 2722 | shade_blocks_textured_unmodulated_##target \ |
| | 2723 | |
| | 2724 | #define shade_blocks_switch_unshaded_textured_modulated(dithering, target) \ |
| | 2725 | shade_blocks_unshaded_textured_modulated_##dithering##_##target \ |
| | 2726 | |
| | 2727 | #define shade_blocks_switch_unshaded_textured(modulation, dithering, target) \ |
| | 2728 | shade_blocks_switch_unshaded_textured_##modulation(dithering, target) \ |
| | 2729 | |
| | 2730 | #define shade_blocks_switch_unshaded(texturing, modulation, dithering, target) \ |
| | 2731 | shade_blocks_switch_unshaded_##texturing(modulation, dithering, target) \ |
| | 2732 | |
| | 2733 | #define shade_blocks_switch_shaded_untextured(modulation, dithering, target) \ |
| | 2734 | shade_blocks_shaded_untextured \ |
| | 2735 | |
| | 2736 | #define shade_blocks_switch_shaded_textured_unmodulated(dithering, target) \ |
| | 2737 | shade_blocks_textured_unmodulated_##target \ |
| | 2738 | |
| | 2739 | #define shade_blocks_switch_shaded_textured_modulated(dithering, target) \ |
| | 2740 | shade_blocks_shaded_textured_modulated_##dithering##_##target \ |
| | 2741 | |
| | 2742 | #define shade_blocks_switch_shaded_textured(modulation, dithering, target) \ |
| | 2743 | shade_blocks_switch_shaded_textured_##modulation(dithering, target) \ |
| | 2744 | |
| | 2745 | #define shade_blocks_switch_shaded(texturing, modulation, dithering, target) \ |
| | 2746 | shade_blocks_switch_shaded_##texturing(modulation, dithering, target) \ |
| | 2747 | |
| | 2748 | #define shade_blocks_switch_mask_off(shading, texturing, modulation, \ |
| | 2749 | dithering) \ |
| | 2750 | shade_blocks_switch_##shading(texturing, modulation, dithering, direct) \ |
| | 2751 | |
| | 2752 | #define shade_blocks_switch_mask_on(shading, texturing, modulation, \ |
| | 2753 | dithering) \ |
| | 2754 | shade_blocks_switch_##shading(texturing, modulation, dithering, indirect) \ |
| | 2755 | |
| | 2756 | #define shade_blocks_switch_blended(shading, texturing, modulation, dithering, \ |
| | 2757 | mask_evaluate) \ |
| | 2758 | shade_blocks_switch_##shading(texturing, modulation, dithering, indirect) \ |
| | 2759 | |
| | 2760 | #define shade_blocks_switch_unblended(shading, texturing, modulation, \ |
| | 2761 | dithering, mask_evaluate) \ |
| | 2762 | shade_blocks_switch_mask_##mask_evaluate(shading, texturing, modulation, \ |
| | 2763 | dithering) \ |
| | 2764 | |
| | 2765 | #define shade_blocks_switch(shading, texturing, modulation, dithering, \ |
| | 2766 | blending, mask_evaluate) \ |
| | 2767 | shade_blocks_switch_##blending(shading, texturing, modulation, dithering, \ |
| | 2768 | mask_evaluate) \ |
| | 2769 | |
| | 2770 | |
| | 2771 | // Blend blocks parametric-variables: |
| | 2772 | // TEXTURE_MAP BLEND BM_A BM_B mask_evaluate |
| | 2773 | // x 0 x x 0 |
| | 2774 | // x 0 x x 1 |
| | 2775 | // 0 1 0 0 0 |
| | 2776 | // 0 1 0 0 1 |
| | 2777 | // 0 1 0 1 0 |
| | 2778 | // 0 1 0 1 1 |
| | 2779 | // 0 1 1 0 0 |
| | 2780 | // 0 1 1 0 1 |
| | 2781 | // 0 1 1 1 0 |
| | 2782 | // 0 1 1 1 1 |
| | 2783 | // 1 1 0 0 0 |
| | 2784 | // 1 1 0 0 1 |
| | 2785 | // 1 1 0 1 0 |
| | 2786 | // 1 1 0 1 1 |
| | 2787 | // 1 1 1 0 0 |
| | 2788 | // 1 1 1 0 1 |
| | 2789 | // 1 1 1 1 0 |
| | 2790 | // 1 1 1 1 1 |
| | 2791 | // 32 inputs, 18 combinations |
| | 2792 | |
| | 2793 | #define blend_blocks_switch_unblended(texturing, blend_mode, mask_evaluate) \ |
| | 2794 | blend_blocks_textured_unblended_##mask_evaluate \ |
| | 2795 | |
| | 2796 | #define blend_blocks_switch_blended(texturing, blend_mode, mask_evaluate) \ |
| | 2797 | blend_blocks_##texturing##_##blend_mode##_##mask_evaluate \ |
| | 2798 | |
| | 2799 | #define blend_blocks_switch(texturing, blending, blend_mode, mask_evaluate) \ |
| | 2800 | blend_blocks_switch_##blending(texturing, blend_mode, mask_evaluate) \ |
| | 2801 | |
| | 2802 | |
| | 2803 | #define render_blocks_switch_block_modulation(texture_mode, blend_mode, \ |
| | 2804 | mask_evaluate, shading, dithering, texturing, blending, modulation) \ |
| | 2805 | { \ |
| | 2806 | setup_blocks_switch(shading, texturing, texture_mode, dithering, blending, \ |
| | 2807 | mask_evaluate), \ |
| | 2808 | texture_blocks_switch(texturing, texture_mode), \ |
| | 2809 | shade_blocks_switch(shading, texturing, modulation, dithering, blending, \ |
| | 2810 | mask_evaluate), \ |
| | 2811 | blend_blocks_switch(texturing, blending, blend_mode, mask_evaluate) \ |
| | 2812 | } \ |
| | 2813 | |
| | 2814 | #define render_blocks_switch_block_blending(texture_mode, blend_mode, \ |
| | 2815 | mask_evaluate, shading, dithering, texturing, blending) \ |
| | 2816 | render_blocks_switch_block_modulation(texture_mode, blend_mode, \ |
| | 2817 | mask_evaluate, shading, dithering, texturing, blending, modulated), \ |
| | 2818 | render_blocks_switch_block_modulation(texture_mode, blend_mode, \ |
| | 2819 | mask_evaluate, shading, dithering, texturing, blending, unmodulated) \ |
| | 2820 | |
| | 2821 | #define render_blocks_switch_block_texturing(texture_mode, blend_mode, \ |
| | 2822 | mask_evaluate, shading, dithering, texturing) \ |
| | 2823 | render_blocks_switch_block_blending(texture_mode, blend_mode, \ |
| | 2824 | mask_evaluate, shading, dithering, texturing, unblended), \ |
| | 2825 | render_blocks_switch_block_blending(texture_mode, blend_mode, \ |
| | 2826 | mask_evaluate, shading, dithering, texturing, blended) \ |
| | 2827 | |
| | 2828 | #define render_blocks_switch_block_dithering(texture_mode, blend_mode, \ |
| | 2829 | mask_evaluate, shading, dithering) \ |
| | 2830 | render_blocks_switch_block_texturing(texture_mode, blend_mode, \ |
| | 2831 | mask_evaluate, shading, dithering, untextured), \ |
| | 2832 | render_blocks_switch_block_texturing(texture_mode, blend_mode, \ |
| | 2833 | mask_evaluate, shading, dithering, textured) \ |
| | 2834 | |
| | 2835 | #define render_blocks_switch_block_shading(texture_mode, blend_mode, \ |
| | 2836 | mask_evaluate, shading) \ |
| | 2837 | render_blocks_switch_block_dithering(texture_mode, blend_mode, \ |
| | 2838 | mask_evaluate, shading, undithered), \ |
| | 2839 | render_blocks_switch_block_dithering(texture_mode, blend_mode, \ |
| | 2840 | mask_evaluate, shading, dithered) \ |
| | 2841 | |
| | 2842 | #define render_blocks_switch_block_mask_evaluate(texture_mode, blend_mode, \ |
| | 2843 | mask_evaluate) \ |
| | 2844 | render_blocks_switch_block_shading(texture_mode, blend_mode, mask_evaluate, \ |
| | 2845 | unshaded), \ |
| | 2846 | render_blocks_switch_block_shading(texture_mode, blend_mode, mask_evaluate, \ |
| | 2847 | shaded) \ |
| | 2848 | |
| | 2849 | #define render_blocks_switch_block_blend_mode(texture_mode, blend_mode) \ |
| | 2850 | render_blocks_switch_block_mask_evaluate(texture_mode, blend_mode, off), \ |
| | 2851 | render_blocks_switch_block_mask_evaluate(texture_mode, blend_mode, on) \ |
| | 2852 | |
| | 2853 | #define render_blocks_switch_block_texture_mode(texture_mode) \ |
| | 2854 | render_blocks_switch_block_blend_mode(texture_mode, average), \ |
| | 2855 | render_blocks_switch_block_blend_mode(texture_mode, add), \ |
| | 2856 | render_blocks_switch_block_blend_mode(texture_mode, subtract), \ |
| | 2857 | render_blocks_switch_block_blend_mode(texture_mode, add_fourth) \ |
| | 2858 | |
| | 2859 | #define render_blocks_switch_block() \ |
| | 2860 | render_blocks_switch_block_texture_mode(4bpp), \ |
| | 2861 | render_blocks_switch_block_texture_mode(8bpp), \ |
| | 2862 | render_blocks_switch_block_texture_mode(16bpp), \ |
| | 2863 | render_blocks_switch_block_texture_mode(4bpp) \ |
| | 2864 | |
| | 2865 | |
| | 2866 | render_block_handler_struct render_triangle_block_handlers[] = |
| | 2867 | { |
| | 2868 | render_blocks_switch_block() |
| | 2869 | }; |
| | 2870 | |
| | 2871 | #undef render_blocks_switch_block_modulation |
| | 2872 | |
| | 2873 | #define render_blocks_switch_block_modulation(texture_mode, blend_mode, \ |
| | 2874 | mask_evaluate, shading, dithering, texturing, blending, modulation) \ |
| | 2875 | "render flags:\n" \ |
| | 2876 | "texture mode: " #texture_mode "\n" \ |
| | 2877 | "blend mode: " #blend_mode "\n" \ |
| | 2878 | "mask evaluation: " #mask_evaluate "\n" \ |
| | 2879 | #shading "\n" \ |
| | 2880 | #dithering "\n" \ |
| | 2881 | #texturing "\n" \ |
| | 2882 | #blending "\n" \ |
| | 2883 | #modulation "\n" \ |
| | 2884 | |
| | 2885 | char *render_block_flag_strings[] = |
| | 2886 | { |
| | 2887 | render_blocks_switch_block() |
| | 2888 | }; |
| | 2889 | |
| | 2890 | |
| | 2891 | #define triangle_y_direction_up 1 |
| | 2892 | #define triangle_y_direction_flat 2 |
| | 2893 | #define triangle_y_direction_down 0 |
| | 2894 | |
| | 2895 | #define triangle_winding_positive 0 |
| | 2896 | #define triangle_winding_negative 1 |
| | 2897 | |
| | 2898 | #define triangle_set_direction(direction_variable, value) \ |
| | 2899 | u32 direction_variable = (u32)(value) >> 31; \ |
| | 2900 | if(value == 0) \ |
| | 2901 | direction_variable = 2 \ |
| | 2902 | |
| | 2903 | #define triangle_case(direction_a, direction_b, direction_c, winding) \ |
| | 2904 | case (triangle_y_direction_##direction_a | \ |
| | 2905 | (triangle_y_direction_##direction_b << 2) | \ |
| | 2906 | (triangle_y_direction_##direction_c << 4) | \ |
| | 2907 | (triangle_winding_##winding << 6)) \ |
| | 2908 | |
| | 2909 | static int prepare_triangle(psx_gpu_struct *psx_gpu, vertex_struct *vertexes, |
| | 2910 | vertex_struct *vertexes_out[3]) |
| | 2911 | { |
| | 2912 | s32 y_top, y_bottom; |
| | 2913 | s32 triangle_area; |
| | 2914 | u32 triangle_winding = 0; |
| | 2915 | |
| | 2916 | vertex_struct *a = &(vertexes[0]); |
| | 2917 | vertex_struct *b = &(vertexes[1]); |
| | 2918 | vertex_struct *c = &(vertexes[2]); |
| | 2919 | |
| | 2920 | triangle_area = triangle_signed_area_x2(a->x, a->y, b->x, b->y, c->x, c->y); |
| | 2921 | |
| | 2922 | #ifdef PROFILE |
| | 2923 | triangles++; |
| | 2924 | #endif |
| | 2925 | |
| | 2926 | if(triangle_area == 0) |
| | 2927 | { |
| | 2928 | #ifdef PROFILE |
| | 2929 | trivial_rejects++; |
| | 2930 | #endif |
| | 2931 | return 0; |
| | 2932 | } |
| | 2933 | |
| | 2934 | if(b->y < a->y) |
| | 2935 | vertex_swap(a, b); |
| | 2936 | |
| | 2937 | if(c->y < b->y) |
| | 2938 | { |
| | 2939 | vertex_swap(b, c); |
| | 2940 | |
| | 2941 | if(b->y < a->y) |
| | 2942 | vertex_swap(a, b); |
| | 2943 | } |
| | 2944 | |
| | 2945 | y_bottom = c->y; |
| | 2946 | y_top = a->y; |
| | 2947 | |
| | 2948 | if((y_bottom - y_top) >= 512) |
| | 2949 | { |
| | 2950 | #ifdef PROFILE |
| | 2951 | trivial_rejects++; |
| | 2952 | #endif |
| | 2953 | return 0; |
| | 2954 | } |
| | 2955 | |
| | 2956 | if(triangle_area < 0) |
| | 2957 | { |
| | 2958 | triangle_area = -triangle_area; |
| | 2959 | triangle_winding ^= 1; |
| | 2960 | vertex_swap(a, c); |
| | 2961 | } |
| | 2962 | |
| | 2963 | if(b->x < a->x) |
| | 2964 | vertex_swap(a, b); |
| | 2965 | |
| | 2966 | if(c->x < b->x) |
| | 2967 | { |
| | 2968 | vertex_swap(b, c); |
| | 2969 | |
| | 2970 | if(b->x < a->x) |
| | 2971 | vertex_swap(a, b); |
| | 2972 | } |
| | 2973 | |
| | 2974 | if((c->x - psx_gpu->offset_x) >= 1024 || (c->x - a->x) >= 1024) |
| | 2975 | { |
| | 2976 | #ifdef PROFILE |
| | 2977 | trivial_rejects++; |
| | 2978 | #endif |
| | 2979 | return 0; |
| | 2980 | } |
| | 2981 | |
| | 2982 | if(invalidate_texture_cache_region_viewport(psx_gpu, a->x, y_top, c->x, |
| | 2983 | y_bottom) == 0) |
| | 2984 | { |
| | 2985 | #ifdef PROFILE |
| | 2986 | trivial_rejects++; |
| | 2987 | #endif |
| | 2988 | return 0; |
| | 2989 | } |
| | 2990 | |
| | 2991 | psx_gpu->triangle_area = triangle_area; |
| | 2992 | psx_gpu->triangle_winding = triangle_winding; |
| | 2993 | |
| | 2994 | vertexes_out[0] = a; |
| | 2995 | vertexes_out[1] = b; |
| | 2996 | vertexes_out[2] = c; |
| | 2997 | |
| | 2998 | return 1; |
| | 2999 | } |
| | 3000 | |
| | 3001 | static void render_triangle_p(psx_gpu_struct *psx_gpu, |
| | 3002 | vertex_struct *vertex_ptrs[3], u32 flags) |
| | 3003 | { |
| | 3004 | psx_gpu->num_spans = 0; |
| | 3005 | |
| | 3006 | vertex_struct *a = vertex_ptrs[0]; |
| | 3007 | vertex_struct *b = vertex_ptrs[1]; |
| | 3008 | vertex_struct *c = vertex_ptrs[2]; |
| | 3009 | |
| | 3010 | s32 y_delta_a = b->y - a->y; |
| | 3011 | s32 y_delta_b = c->y - b->y; |
| | 3012 | s32 y_delta_c = c->y - a->y; |
| | 3013 | |
| | 3014 | triangle_set_direction(y_direction_a, y_delta_a); |
| | 3015 | triangle_set_direction(y_direction_b, y_delta_b); |
| | 3016 | triangle_set_direction(y_direction_c, y_delta_c); |
| | 3017 | |
| | 3018 | compute_all_gradients(psx_gpu, a, b, c); |
| | 3019 | |
| | 3020 | switch(y_direction_a | (y_direction_b << 2) | (y_direction_c << 4) | |
| | 3021 | (psx_gpu->triangle_winding << 6)) |
| | 3022 | { |
| | 3023 | triangle_case(up, up, up, negative): |
| | 3024 | triangle_case(up, up, flat, negative): |
| | 3025 | triangle_case(up, up, down, negative): |
| | 3026 | setup_spans_up_right(psx_gpu, a, b, c); |
| | 3027 | break; |
| | 3028 | |
| | 3029 | triangle_case(flat, up, up, negative): |
| | 3030 | triangle_case(flat, up, flat, negative): |
| | 3031 | triangle_case(flat, up, down, negative): |
| | 3032 | setup_spans_up_a(psx_gpu, a, b, c); |
| | 3033 | break; |
| | 3034 | |
| | 3035 | triangle_case(down, up, up, negative): |
| | 3036 | setup_spans_up_down(psx_gpu, a, c, b); |
| | 3037 | break; |
| | 3038 | |
| | 3039 | triangle_case(down, up, flat, negative): |
| | 3040 | setup_spans_down_a(psx_gpu, a, c, b); |
| | 3041 | break; |
| | 3042 | |
| | 3043 | triangle_case(down, up, down, negative): |
| | 3044 | setup_spans_down_right(psx_gpu, a, c, b); |
| | 3045 | break; |
| | 3046 | |
| | 3047 | triangle_case(down, flat, up, negative): |
| | 3048 | triangle_case(down, flat, flat, negative): |
| | 3049 | triangle_case(down, flat, down, negative): |
| | 3050 | setup_spans_down_b(psx_gpu, a, b, c); |
| | 3051 | break; |
| | 3052 | |
| | 3053 | triangle_case(down, down, up, negative): |
| | 3054 | triangle_case(down, down, flat, negative): |
| | 3055 | triangle_case(down, down, down, negative): |
| | 3056 | setup_spans_down_left(psx_gpu, a, b, c); |
| | 3057 | break; |
| | 3058 | |
| | 3059 | triangle_case(up, up, up, positive): |
| | 3060 | triangle_case(up, up, flat, positive): |
| | 3061 | triangle_case(up, up, down, positive): |
| | 3062 | setup_spans_up_left(psx_gpu, a, b, c); |
| | 3063 | break; |
| | 3064 | |
| | 3065 | triangle_case(up, flat, up, positive): |
| | 3066 | triangle_case(up, flat, flat, positive): |
| | 3067 | triangle_case(up, flat, down, positive): |
| | 3068 | setup_spans_up_b(psx_gpu, a, b, c); |
| | 3069 | break; |
| | 3070 | |
| | 3071 | triangle_case(up, down, up, positive): |
| | 3072 | setup_spans_up_right(psx_gpu, a, c, b); |
| | 3073 | break; |
| | 3074 | |
| | 3075 | triangle_case(up, down, flat, positive): |
| | 3076 | setup_spans_up_a(psx_gpu, a, c, b); |
| | 3077 | break; |
| | 3078 | |
| | 3079 | triangle_case(up, down, down, positive): |
| | 3080 | setup_spans_up_down(psx_gpu, a, b, c); |
| | 3081 | break; |
| | 3082 | |
| | 3083 | triangle_case(flat, down, up, positive): |
| | 3084 | triangle_case(flat, down, flat, positive): |
| | 3085 | triangle_case(flat, down, down, positive): |
| | 3086 | setup_spans_down_a(psx_gpu, a, b, c); |
| | 3087 | break; |
| | 3088 | |
| | 3089 | triangle_case(down, down, up, positive): |
| | 3090 | triangle_case(down, down, flat, positive): |
| | 3091 | triangle_case(down, down, down, positive): |
| | 3092 | setup_spans_down_right(psx_gpu, a, b, c); |
| | 3093 | break; |
| | 3094 | } |
| | 3095 | |
| | 3096 | #ifdef PROFILE |
| | 3097 | spans += psx_gpu->num_spans; |
| | 3098 | #endif |
| | 3099 | |
| | 3100 | if(unlikely(psx_gpu->render_mode & RENDER_INTERLACE_ENABLED)) |
| | 3101 | { |
| | 3102 | u32 i; |
| | 3103 | |
| | 3104 | if(psx_gpu->render_mode & RENDER_INTERLACE_ODD) |
| | 3105 | { |
| | 3106 | for(i = 0; i < psx_gpu->num_spans; i++) |
| | 3107 | { |
| | 3108 | if((psx_gpu->span_edge_data[i].y & 1) == 0) |
| | 3109 | psx_gpu->span_edge_data[i].num_blocks = 0; |
| | 3110 | } |
| | 3111 | } |
| | 3112 | else |
| | 3113 | { |
| | 3114 | for(i = 0; i < psx_gpu->num_spans; i++) |
| | 3115 | { |
| | 3116 | if(psx_gpu->span_edge_data[i].y & 1) |
| | 3117 | psx_gpu->span_edge_data[i].num_blocks = 0; |
| | 3118 | } |
| | 3119 | } |
| | 3120 | } |
| | 3121 | |
| | 3122 | u32 render_state = flags & |
| | 3123 | (RENDER_FLAGS_MODULATE_TEXELS | RENDER_FLAGS_BLEND | |
| | 3124 | RENDER_FLAGS_TEXTURE_MAP | RENDER_FLAGS_SHADE); |
| | 3125 | render_state |= psx_gpu->render_state_base; |
| | 3126 | |
| | 3127 | if((psx_gpu->render_state != render_state) || |
| | 3128 | (psx_gpu->primitive_type != PRIMITIVE_TYPE_TRIANGLE)) |
| | 3129 | { |
| | 3130 | psx_gpu->render_state = render_state; |
| | 3131 | flush_render_block_buffer(psx_gpu); |
| | 3132 | #ifdef PROFILE |
| | 3133 | state_changes++; |
| | 3134 | #endif |
| | 3135 | } |
| | 3136 | |
| | 3137 | psx_gpu->primitive_type = PRIMITIVE_TYPE_TRIANGLE; |
| | 3138 | |
| | 3139 | psx_gpu->render_block_handler = |
| | 3140 | &(render_triangle_block_handlers[render_state]); |
| | 3141 | ((setup_blocks_function_type *)psx_gpu->render_block_handler->setup_blocks) |
| | 3142 | (psx_gpu); |
| | 3143 | } |
| | 3144 | |
| | 3145 | void render_triangle(psx_gpu_struct *psx_gpu, vertex_struct *vertexes, |
| | 3146 | u32 flags) |
| | 3147 | { |
| | 3148 | vertex_struct *vertex_ptrs[3]; |
| | 3149 | if (prepare_triangle(psx_gpu, vertexes, vertex_ptrs)) |
| | 3150 | render_triangle_p(psx_gpu, vertex_ptrs, flags); |
| | 3151 | } |
| | 3152 | |
| | 3153 | |
| | 3154 | void texture_sprite_blocks_8bpp(psx_gpu_struct *psx_gpu); |
| | 3155 | |
| | 3156 | #ifndef NEON_BUILD |
| | 3157 | |
| | 3158 | void texture_sprite_blocks_8bpp(psx_gpu_struct *psx_gpu) |
| | 3159 | { |
| | 3160 | block_struct *block = psx_gpu->blocks; |
| | 3161 | u32 num_blocks = psx_gpu->num_blocks; |
| | 3162 | |
| | 3163 | vec_8x16u texels; |
| | 3164 | vec_8x8u texel_indexes; |
| | 3165 | |
| | 3166 | u16 *clut_ptr = psx_gpu->clut_ptr; |
| | 3167 | u32 i; |
| | 3168 | |
| | 3169 | while(num_blocks) |
| | 3170 | { |
| | 3171 | texel_indexes = block->r; |
| | 3172 | |
| | 3173 | for(i = 0; i < 8; i++) |
| | 3174 | { |
| | 3175 | texels.e[i] = clut_ptr[texel_indexes.e[i]]; |
| | 3176 | } |
| | 3177 | |
| | 3178 | block->texels = texels; |
| | 3179 | |
| | 3180 | num_blocks--; |
| | 3181 | block++; |
| | 3182 | } |
| | 3183 | } |
| | 3184 | |
| | 3185 | #endif |
| | 3186 | |
| | 3187 | |
| | 3188 | #define setup_sprite_tiled_initialize_4bpp() \ |
| | 3189 | u16 *clut_ptr = psx_gpu->clut_ptr; \ |
| | 3190 | vec_8x16u clut_a, clut_b; \ |
| | 3191 | vec_16x8u clut_low, clut_high; \ |
| | 3192 | \ |
| | 3193 | load_8x16b(clut_a, clut_ptr); \ |
| | 3194 | load_8x16b(clut_b, clut_ptr + 8); \ |
| | 3195 | unzip_16x8b(clut_low, clut_high, clut_a, clut_b); \ |
| | 3196 | \ |
| | 3197 | if(psx_gpu->current_texture_mask & psx_gpu->dirty_textures_4bpp_mask) \ |
| | 3198 | update_texture_4bpp_cache(psx_gpu) \ |
| | 3199 | |
| | 3200 | #define setup_sprite_tiled_initialize_8bpp() \ |
| | 3201 | if(psx_gpu->current_texture_mask & psx_gpu->dirty_textures_8bpp_mask) \ |
| | 3202 | update_texture_8bpp_cache(psx_gpu) \ |
| | 3203 | |
| | 3204 | |
| | 3205 | #define setup_sprite_tile_fetch_texel_block_8bpp(offset) \ |
| | 3206 | texture_block_ptr = psx_gpu->texture_page_ptr + \ |
| | 3207 | ((texture_offset + offset) & texture_mask); \ |
| | 3208 | \ |
| | 3209 | load_64b(texels, texture_block_ptr) \ |
| | 3210 | |
| | 3211 | |
| | 3212 | #define setup_sprite_tile_setup_block_yes(side, offset, texture_mode) \ |
| | 3213 | |
| | 3214 | #define setup_sprite_tile_setup_block_no(side, offset, texture_mode) \ |
| | 3215 | |
| | 3216 | #define setup_sprite_tile_add_blocks(tile_num_blocks) \ |
| | 3217 | num_blocks += tile_num_blocks; \ |
| | 3218 | sprite_blocks += tile_num_blocks; \ |
| | 3219 | \ |
| | 3220 | if(num_blocks > MAX_BLOCKS) \ |
| | 3221 | { \ |
| | 3222 | flush_render_block_buffer(psx_gpu); \ |
| | 3223 | num_blocks = tile_num_blocks; \ |
| | 3224 | block = psx_gpu->blocks; \ |
| | 3225 | } \ |
| | 3226 | |
| | 3227 | #define setup_sprite_tile_full_4bpp(edge) \ |
| | 3228 | { \ |
| | 3229 | vec_8x8u texels_low, texels_high; \ |
| | 3230 | vec_8x16u pixels; \ |
| | 3231 | setup_sprite_tile_add_blocks(sub_tile_height * 2); \ |
| | 3232 | \ |
| | 3233 | while(sub_tile_height) \ |
| | 3234 | { \ |
| | 3235 | setup_sprite_tile_fetch_texel_block_8bpp(0); \ |
| | 3236 | tbl_16(texels_low, texels, clut_low); \ |
| | 3237 | tbl_16(texels_high, texels, clut_high); \ |
| | 3238 | zip_8x16b(pixels, texels_low, texels_high); \ |
| | 3239 | \ |
| | 3240 | block->texels = pixels; \ |
| | 3241 | block->draw_mask_bits = left_mask_bits; \ |
| | 3242 | block->fb_ptr = fb_ptr; \ |
| | 3243 | block++; \ |
| | 3244 | \ |
| | 3245 | setup_sprite_tile_fetch_texel_block_8bpp(8); \ |
| | 3246 | tbl_16(texels_low, texels, clut_low); \ |
| | 3247 | tbl_16(texels_high, texels, clut_high); \ |
| | 3248 | zip_8x16b(pixels, texels_low, texels_high); \ |
| | 3249 | \ |
| | 3250 | block->texels = pixels; \ |
| | 3251 | block->draw_mask_bits = right_mask_bits; \ |
| | 3252 | block->fb_ptr = fb_ptr + 8; \ |
| | 3253 | block++; \ |
| | 3254 | \ |
| | 3255 | fb_ptr += 1024; \ |
| | 3256 | texture_offset += 0x10; \ |
| | 3257 | sub_tile_height--; \ |
| | 3258 | } \ |
| | 3259 | texture_offset += 0xF00; \ |
| | 3260 | psx_gpu->num_blocks = num_blocks; \ |
| | 3261 | } \ |
| | 3262 | |
| | 3263 | #define setup_sprite_tile_half_4bpp(edge) \ |
| | 3264 | { \ |
| | 3265 | vec_8x8u texels_low, texels_high; \ |
| | 3266 | vec_8x16u pixels; \ |
| | 3267 | setup_sprite_tile_add_blocks(sub_tile_height); \ |
| | 3268 | \ |
| | 3269 | while(sub_tile_height) \ |
| | 3270 | { \ |
| | 3271 | setup_sprite_tile_fetch_texel_block_8bpp(0); \ |
| | 3272 | tbl_16(texels_low, texels, clut_low); \ |
| | 3273 | tbl_16(texels_high, texels, clut_high); \ |
| | 3274 | zip_8x16b(pixels, texels_low, texels_high); \ |
| | 3275 | \ |
| | 3276 | block->texels = pixels; \ |
| | 3277 | block->draw_mask_bits = edge##_mask_bits; \ |
| | 3278 | block->fb_ptr = fb_ptr; \ |
| | 3279 | block++; \ |
| | 3280 | \ |
| | 3281 | fb_ptr += 1024; \ |
| | 3282 | texture_offset += 0x10; \ |
| | 3283 | sub_tile_height--; \ |
| | 3284 | } \ |
| | 3285 | texture_offset += 0xF00; \ |
| | 3286 | psx_gpu->num_blocks = num_blocks; \ |
| | 3287 | } \ |
| | 3288 | |
| | 3289 | |
| | 3290 | #define setup_sprite_tile_full_8bpp(edge) \ |
| | 3291 | { \ |
| | 3292 | setup_sprite_tile_add_blocks(sub_tile_height * 2); \ |
| | 3293 | \ |
| | 3294 | while(sub_tile_height) \ |
| | 3295 | { \ |
| | 3296 | setup_sprite_tile_fetch_texel_block_8bpp(0); \ |
| | 3297 | block->r = texels; \ |
| | 3298 | block->draw_mask_bits = left_mask_bits; \ |
| | 3299 | block->fb_ptr = fb_ptr; \ |
| | 3300 | block++; \ |
| | 3301 | \ |
| | 3302 | setup_sprite_tile_fetch_texel_block_8bpp(8); \ |
| | 3303 | block->r = texels; \ |
| | 3304 | block->draw_mask_bits = right_mask_bits; \ |
| | 3305 | block->fb_ptr = fb_ptr + 8; \ |
| | 3306 | block++; \ |
| | 3307 | \ |
| | 3308 | fb_ptr += 1024; \ |
| | 3309 | texture_offset += 0x10; \ |
| | 3310 | sub_tile_height--; \ |
| | 3311 | } \ |
| | 3312 | texture_offset += 0xF00; \ |
| | 3313 | psx_gpu->num_blocks = num_blocks; \ |
| | 3314 | } \ |
| | 3315 | |
| | 3316 | #define setup_sprite_tile_half_8bpp(edge) \ |
| | 3317 | { \ |
| | 3318 | setup_sprite_tile_add_blocks(sub_tile_height * 2); \ |
| | 3319 | \ |
| | 3320 | while(sub_tile_height) \ |
| | 3321 | { \ |
| | 3322 | setup_sprite_tile_fetch_texel_block_8bpp(0); \ |
| | 3323 | block->r = texels; \ |
| | 3324 | block->draw_mask_bits = edge##_mask_bits; \ |
| | 3325 | block->fb_ptr = fb_ptr; \ |
| | 3326 | block++; \ |
| | 3327 | \ |
| | 3328 | fb_ptr += 1024; \ |
| | 3329 | texture_offset += 0x10; \ |
| | 3330 | sub_tile_height--; \ |
| | 3331 | } \ |
| | 3332 | texture_offset += 0xF00; \ |
| | 3333 | psx_gpu->num_blocks = num_blocks; \ |
| | 3334 | } \ |
| | 3335 | |
| | 3336 | |
| | 3337 | #define setup_sprite_tile_column_edge_pre_adjust_half_right() \ |
| | 3338 | texture_offset = texture_offset_base + 8; \ |
| | 3339 | fb_ptr += 8 \ |
| | 3340 | |
| | 3341 | #define setup_sprite_tile_column_edge_pre_adjust_half_left() \ |
| | 3342 | texture_offset = texture_offset_base \ |
| | 3343 | |
| | 3344 | #define setup_sprite_tile_column_edge_pre_adjust_half(edge) \ |
| | 3345 | setup_sprite_tile_column_edge_pre_adjust_half_##edge() \ |
| | 3346 | |
| | 3347 | #define setup_sprite_tile_column_edge_pre_adjust_full(edge) \ |
| | 3348 | texture_offset = texture_offset_base \ |
| | 3349 | |
| | 3350 | #define setup_sprite_tile_column_edge_post_adjust_half_right() \ |
| | 3351 | fb_ptr -= 8 \ |
| | 3352 | |
| | 3353 | #define setup_sprite_tile_column_edge_post_adjust_half_left() \ |
| | 3354 | |
| | 3355 | #define setup_sprite_tile_column_edge_post_adjust_half(edge) \ |
| | 3356 | setup_sprite_tile_column_edge_post_adjust_half_##edge() \ |
| | 3357 | |
| | 3358 | #define setup_sprite_tile_column_edge_post_adjust_full(edge) \ |
| | 3359 | |
| | 3360 | |
| | 3361 | #define setup_sprite_tile_column_height_single(edge_mode, edge, texture_mode) \ |
| | 3362 | do \ |
| | 3363 | { \ |
| | 3364 | sub_tile_height = column_data; \ |
| | 3365 | setup_sprite_tile_column_edge_pre_adjust_##edge_mode(edge); \ |
| | 3366 | setup_sprite_tile_##edge_mode##_##texture_mode(edge); \ |
| | 3367 | setup_sprite_tile_column_edge_post_adjust_##edge_mode(edge); \ |
| | 3368 | } while(0) \ |
| | 3369 | |
| | 3370 | #define setup_sprite_tile_column_height_multi(edge_mode, edge, texture_mode) \ |
| | 3371 | do \ |
| | 3372 | { \ |
| | 3373 | u32 tiles_remaining = column_data >> 16; \ |
| | 3374 | sub_tile_height = column_data & 0xFF; \ |
| | 3375 | setup_sprite_tile_column_edge_pre_adjust_##edge_mode(edge); \ |
| | 3376 | setup_sprite_tile_##edge_mode##_##texture_mode(edge); \ |
| | 3377 | tiles_remaining -= 1; \ |
| | 3378 | \ |
| | 3379 | while(tiles_remaining) \ |
| | 3380 | { \ |
| | 3381 | sub_tile_height = 16; \ |
| | 3382 | setup_sprite_tile_##edge_mode##_##texture_mode(edge); \ |
| | 3383 | tiles_remaining--; \ |
| | 3384 | } \ |
| | 3385 | \ |
| | 3386 | sub_tile_height = (column_data >> 8) & 0xFF; \ |
| | 3387 | setup_sprite_tile_##edge_mode##_##texture_mode(edge); \ |
| | 3388 | setup_sprite_tile_column_edge_post_adjust_##edge_mode(edge); \ |
| | 3389 | } while(0) \ |
| | 3390 | |
| | 3391 | |
| | 3392 | #define setup_sprite_column_data_single() \ |
| | 3393 | column_data = height \ |
| | 3394 | |
| | 3395 | #define setup_sprite_column_data_multi() \ |
| | 3396 | column_data = 16 - offset_v; \ |
| | 3397 | column_data |= ((height_rounded & 0xF) + 1) << 8; \ |
| | 3398 | column_data |= (tile_height - 1) << 16 \ |
| | 3399 | |
| | 3400 | |
| | 3401 | #define setup_sprite_tile_column_width_single(texture_mode, multi_height, \ |
| | 3402 | edge_mode, edge) \ |
| | 3403 | { \ |
| | 3404 | setup_sprite_column_data_##multi_height(); \ |
| | 3405 | left_mask_bits = left_block_mask | right_block_mask; \ |
| | 3406 | right_mask_bits = left_mask_bits >> 8; \ |
| | 3407 | \ |
| | 3408 | setup_sprite_tile_column_height_##multi_height(edge_mode, edge, \ |
| | 3409 | texture_mode); \ |
| | 3410 | } \ |
| | 3411 | |
| | 3412 | #define setup_sprite_tiled_advance_column() \ |
| | 3413 | texture_offset_base += 0x100; \ |
| | 3414 | if((texture_offset_base & 0xF00) == 0) \ |
| | 3415 | texture_offset_base -= (0x100 + 0xF00) \ |
| | 3416 | |
| | 3417 | #define setup_sprite_tile_column_width_multi(texture_mode, multi_height, \ |
| | 3418 | left_mode, right_mode) \ |
| | 3419 | { \ |
| | 3420 | setup_sprite_column_data_##multi_height(); \ |
| | 3421 | s32 fb_ptr_advance_column = 16 - (1024 * height); \ |
| | 3422 | \ |
| | 3423 | tile_width -= 2; \ |
| | 3424 | left_mask_bits = left_block_mask; \ |
| | 3425 | right_mask_bits = left_mask_bits >> 8; \ |
| | 3426 | \ |
| | 3427 | setup_sprite_tile_column_height_##multi_height(left_mode, right, \ |
| | 3428 | texture_mode); \ |
| | 3429 | fb_ptr += fb_ptr_advance_column; \ |
| | 3430 | \ |
| | 3431 | left_mask_bits = 0x00; \ |
| | 3432 | right_mask_bits = 0x00; \ |
| | 3433 | \ |
| | 3434 | while(tile_width) \ |
| | 3435 | { \ |
| | 3436 | setup_sprite_tiled_advance_column(); \ |
| | 3437 | setup_sprite_tile_column_height_##multi_height(full, none, texture_mode); \ |
| | 3438 | fb_ptr += fb_ptr_advance_column; \ |
| | 3439 | tile_width--; \ |
| | 3440 | } \ |
| | 3441 | \ |
| | 3442 | left_mask_bits = right_block_mask; \ |
| | 3443 | right_mask_bits = left_mask_bits >> 8; \ |
| | 3444 | \ |
| | 3445 | setup_sprite_tiled_advance_column(); \ |
| | 3446 | setup_sprite_tile_column_height_##multi_height(right_mode, left, \ |
| | 3447 | texture_mode); \ |
| | 3448 | } \ |
| | 3449 | |
| | 3450 | |
| | 3451 | #define setup_sprite_tiled_builder(texture_mode) \ |
| | 3452 | void setup_sprite_##texture_mode(psx_gpu_struct *psx_gpu, s32 x, s32 y, \ |
| | 3453 | s32 u, s32 v, s32 width, s32 height, u32 color) \ |
| | 3454 | { \ |
| | 3455 | s32 offset_u = u & 0xF; \ |
| | 3456 | s32 offset_v = v & 0xF; \ |
| | 3457 | \ |
| | 3458 | s32 width_rounded = offset_u + width + 15; \ |
| | 3459 | s32 height_rounded = offset_v + height + 15; \ |
| | 3460 | s32 tile_height = height_rounded / 16; \ |
| | 3461 | s32 tile_width = width_rounded / 16; \ |
| | 3462 | u32 offset_u_right = width_rounded & 0xF; \ |
| | 3463 | \ |
| | 3464 | u32 left_block_mask = ~(0xFFFF << offset_u); \ |
| | 3465 | u32 right_block_mask = 0xFFFE << offset_u_right; \ |
| | 3466 | \ |
| | 3467 | u32 left_mask_bits; \ |
| | 3468 | u32 right_mask_bits; \ |
| | 3469 | \ |
| | 3470 | u32 sub_tile_height; \ |
| | 3471 | u32 column_data; \ |
| | 3472 | \ |
| | 3473 | u32 texture_mask = (psx_gpu->texture_mask_width & 0xF) | \ |
| | 3474 | ((psx_gpu->texture_mask_height & 0xF) << 4) | \ |
| | 3475 | ((psx_gpu->texture_mask_width >> 4) << 8) | \ |
| | 3476 | ((psx_gpu->texture_mask_height >> 4) << 12); \ |
| | 3477 | u32 texture_offset = ((v & 0xF) << 4) | ((u & 0xF0) << 4) | \ |
| | 3478 | ((v & 0xF0) << 8); \ |
| | 3479 | u32 texture_offset_base = texture_offset; \ |
| | 3480 | u32 control_mask; \ |
| | 3481 | \ |
| | 3482 | u16 *fb_ptr = psx_gpu->vram_ptr + (y * 1024) + (x - offset_u); \ |
| | 3483 | u32 num_blocks = psx_gpu->num_blocks; \ |
| | 3484 | block_struct *block = psx_gpu->blocks + num_blocks; \ |
| | 3485 | \ |
| | 3486 | u16 *texture_block_ptr; \ |
| | 3487 | vec_8x8u texels; \ |
| | 3488 | \ |
| | 3489 | setup_sprite_tiled_initialize_##texture_mode(); \ |
| | 3490 | \ |
| | 3491 | control_mask = tile_width == 1; \ |
| | 3492 | control_mask |= (tile_height == 1) << 1; \ |
| | 3493 | control_mask |= ((left_block_mask & 0xFF) == 0xFF) << 2; \ |
| | 3494 | control_mask |= (((right_block_mask >> 8) & 0xFF) == 0xFF) << 3; \ |
| | 3495 | \ |
| | 3496 | sprites_##texture_mode++; \ |
| | 3497 | \ |
| | 3498 | switch(control_mask) \ |
| | 3499 | { \ |
| | 3500 | default: \ |
| | 3501 | case 0x0: \ |
| | 3502 | setup_sprite_tile_column_width_multi(texture_mode, multi, full, full); \ |
| | 3503 | break; \ |
| | 3504 | \ |
| | 3505 | case 0x1: \ |
| | 3506 | setup_sprite_tile_column_width_single(texture_mode, multi, full, none); \ |
| | 3507 | break; \ |
| | 3508 | \ |
| | 3509 | case 0x2: \ |
| | 3510 | setup_sprite_tile_column_width_multi(texture_mode, single, full, full); \ |
| | 3511 | break; \ |
| | 3512 | \ |
| | 3513 | case 0x3: \ |
| | 3514 | setup_sprite_tile_column_width_single(texture_mode, single, full, none); \ |
| | 3515 | break; \ |
| | 3516 | \ |
| | 3517 | case 0x4: \ |
| | 3518 | setup_sprite_tile_column_width_multi(texture_mode, multi, half, full); \ |
| | 3519 | break; \ |
| | 3520 | \ |
| | 3521 | case 0x5: \ |
| | 3522 | setup_sprite_tile_column_width_single(texture_mode, multi, half, right); \ |
| | 3523 | break; \ |
| | 3524 | \ |
| | 3525 | case 0x6: \ |
| | 3526 | setup_sprite_tile_column_width_multi(texture_mode, single, half, full); \ |
| | 3527 | break; \ |
| | 3528 | \ |
| | 3529 | case 0x7: \ |
| | 3530 | setup_sprite_tile_column_width_single(texture_mode, single, half, right);\ |
| | 3531 | break; \ |
| | 3532 | \ |
| | 3533 | case 0x8: \ |
| | 3534 | setup_sprite_tile_column_width_multi(texture_mode, multi, full, half); \ |
| | 3535 | break; \ |
| | 3536 | \ |
| | 3537 | case 0x9: \ |
| | 3538 | setup_sprite_tile_column_width_single(texture_mode, multi, half, left); \ |
| | 3539 | break; \ |
| | 3540 | \ |
| | 3541 | case 0xA: \ |
| | 3542 | setup_sprite_tile_column_width_multi(texture_mode, single, full, half); \ |
| | 3543 | break; \ |
| | 3544 | \ |
| | 3545 | case 0xB: \ |
| | 3546 | setup_sprite_tile_column_width_single(texture_mode, single, half, left); \ |
| | 3547 | break; \ |
| | 3548 | \ |
| | 3549 | case 0xC: \ |
| | 3550 | setup_sprite_tile_column_width_multi(texture_mode, multi, half, half); \ |
| | 3551 | break; \ |
| | 3552 | \ |
| | 3553 | case 0xE: \ |
| | 3554 | setup_sprite_tile_column_width_multi(texture_mode, single, half, half); \ |
| | 3555 | break; \ |
| | 3556 | } \ |
| | 3557 | } \ |
| | 3558 | |
| | 3559 | |
| | 3560 | void setup_sprite_4bpp(psx_gpu_struct *psx_gpu, s32 x, s32 y, s32 u, s32 v, |
| | 3561 | s32 width, s32 height, u32 color); |
| | 3562 | void setup_sprite_8bpp(psx_gpu_struct *psx_gpu, s32 x, s32 y, s32 u, s32 v, |
| | 3563 | s32 width, s32 height, u32 color); |
| | 3564 | void setup_sprite_16bpp(psx_gpu_struct *psx_gpu, s32 x, s32 y, s32 u, s32 v, |
| | 3565 | s32 width, s32 height, u32 color); |
| | 3566 | |
| | 3567 | #ifndef NEON_BUILD |
| | 3568 | setup_sprite_tiled_builder(4bpp); |
| | 3569 | setup_sprite_tiled_builder(8bpp); |
| | 3570 | |
| | 3571 | void setup_sprite_16bpp(psx_gpu_struct *psx_gpu, s32 x, s32 y, s32 u, |
| | 3572 | s32 v, s32 width, s32 height, u32 color) |
| | 3573 | { |
| | 3574 | u32 left_offset = u & 0x7; |
| | 3575 | u32 width_rounded = width + left_offset + 7; |
| | 3576 | |
| | 3577 | u16 *fb_ptr = psx_gpu->vram_ptr + (y * 1024) + (s32)(x - left_offset); |
| | 3578 | u32 right_width = width_rounded & 0x7; |
| | 3579 | u32 block_width = width_rounded / 8; |
| | 3580 | u32 fb_ptr_pitch = (1024 + 8) - (block_width * 8); |
| | 3581 | |
| | 3582 | u32 left_mask_bits = ~(0xFF << left_offset); |
| | 3583 | u32 right_mask_bits = 0xFE << right_width; |
| | 3584 | |
| | 3585 | u32 texture_offset_base = u + (v * 1024); |
| | 3586 | u32 texture_mask = |
| | 3587 | psx_gpu->texture_mask_width | (psx_gpu->texture_mask_height * 1024); |
| | 3588 | |
| | 3589 | u32 blocks_remaining; |
| | 3590 | u32 num_blocks = psx_gpu->num_blocks; |
| | 3591 | block_struct *block = psx_gpu->blocks + num_blocks; |
| | 3592 | |
| | 3593 | u16 *texture_page_ptr = psx_gpu->texture_page_ptr; |
| | 3594 | u16 *texture_block_ptr; |
| | 3595 | |
| | 3596 | texture_offset_base &= ~0x7; |
| | 3597 | |
| | 3598 | sprites_16bpp++; |
| | 3599 | |
| | 3600 | if(block_width == 1) |
| | 3601 | { |
| | 3602 | u32 mask_bits = left_mask_bits | right_mask_bits; |
| | 3603 | |
| | 3604 | while(height) |
| | 3605 | { |
| | 3606 | num_blocks++; |
| | 3607 | sprite_blocks++; |
| | 3608 | |
| | 3609 | if(num_blocks > MAX_BLOCKS) |
| | 3610 | { |
| | 3611 | flush_render_block_buffer(psx_gpu); |
| | 3612 | num_blocks = 1; |
| | 3613 | block = psx_gpu->blocks; |
| | 3614 | } |
| | 3615 | |
| | 3616 | texture_block_ptr = |
| | 3617 | texture_page_ptr + (texture_offset_base & texture_mask); |
| | 3618 | |
| | 3619 | load_128b(block->texels, texture_block_ptr); |
| | 3620 | block->draw_mask_bits = mask_bits; |
| | 3621 | block->fb_ptr = fb_ptr; |
| | 3622 | |
| | 3623 | block++; |
| | 3624 | |
| | 3625 | texture_offset_base += 1024; |
| | 3626 | fb_ptr += 1024; |
| | 3627 | |
| | 3628 | height--; |
| | 3629 | psx_gpu->num_blocks = num_blocks; |
| | 3630 | } |
| | 3631 | } |
| | 3632 | else |
| | 3633 | { |
| | 3634 | u32 texture_offset; |
| | 3635 | |
| | 3636 | while(height) |
| | 3637 | { |
| | 3638 | blocks_remaining = block_width - 2; |
| | 3639 | num_blocks += block_width; |
| | 3640 | sprite_blocks += block_width; |
| | 3641 | |
| | 3642 | if(num_blocks > MAX_BLOCKS) |
| | 3643 | { |
| | 3644 | flush_render_block_buffer(psx_gpu); |
| | 3645 | num_blocks = block_width; |
| | 3646 | block = psx_gpu->blocks; |
| | 3647 | } |
| | 3648 | |
| | 3649 | texture_offset = texture_offset_base; |
| | 3650 | texture_offset_base += 1024; |
| | 3651 | |
| | 3652 | texture_block_ptr = texture_page_ptr + (texture_offset & texture_mask); |
| | 3653 | load_128b(block->texels, texture_block_ptr); |
| | 3654 | |
| | 3655 | block->draw_mask_bits = left_mask_bits; |
| | 3656 | block->fb_ptr = fb_ptr; |
| | 3657 | |
| | 3658 | texture_offset += 8; |
| | 3659 | fb_ptr += 8; |
| | 3660 | block++; |
| | 3661 | |
| | 3662 | while(blocks_remaining) |
| | 3663 | { |
| | 3664 | texture_block_ptr = texture_page_ptr + (texture_offset & texture_mask); |
| | 3665 | load_128b(block->texels, texture_block_ptr); |
| | 3666 | |
| | 3667 | block->draw_mask_bits = 0; |
| | 3668 | block->fb_ptr = fb_ptr; |
| | 3669 | |
| | 3670 | texture_offset += 8; |
| | 3671 | fb_ptr += 8; |
| | 3672 | block++; |
| | 3673 | |
| | 3674 | blocks_remaining--; |
| | 3675 | } |
| | 3676 | |
| | 3677 | texture_block_ptr = texture_page_ptr + (texture_offset & texture_mask); |
| | 3678 | load_128b(block->texels, texture_block_ptr); |
| | 3679 | |
| | 3680 | block->draw_mask_bits = right_mask_bits; |
| | 3681 | block->fb_ptr = fb_ptr; |
| | 3682 | |
| | 3683 | fb_ptr += fb_ptr_pitch; |
| | 3684 | block++; |
| | 3685 | |
| | 3686 | height--; |
| | 3687 | psx_gpu->num_blocks = num_blocks; |
| | 3688 | } |
| | 3689 | } |
| | 3690 | } |
| | 3691 | |
| | 3692 | #endif |
| | 3693 | |
| | 3694 | void setup_sprite_untextured(psx_gpu_struct *psx_gpu, s32 x, s32 y, s32 u, |
| | 3695 | s32 v, s32 width, s32 height, u32 color) |
| | 3696 | { |
| | 3697 | u32 right_width = ((width - 1) & 0x7) + 1; |
| | 3698 | u32 right_mask_bits = (0xFF << right_width); |
| | 3699 | u16 *fb_ptr = psx_gpu->vram_ptr + (y * 1024) + x; |
| | 3700 | u32 block_width = (width + 7) / 8; |
| | 3701 | u32 fb_ptr_pitch = 1024 - ((block_width - 1) * 8); |
| | 3702 | u32 blocks_remaining; |
| | 3703 | u32 num_blocks = psx_gpu->num_blocks; |
| | 3704 | block_struct *block = psx_gpu->blocks + num_blocks; |
| | 3705 | |
| | 3706 | u32 color_r = color & 0xFF; |
| | 3707 | u32 color_g = (color >> 8) & 0xFF; |
| | 3708 | u32 color_b = (color >> 16) & 0xFF; |
| | 3709 | vec_8x16u colors; |
| | 3710 | vec_8x16u right_mask; |
| | 3711 | vec_8x16u test_mask = psx_gpu->test_mask; |
| | 3712 | vec_8x16u zero_mask; |
| | 3713 | |
| | 3714 | sprites_untextured++; |
| | 3715 | |
| | 3716 | color = (color_r >> 3) | ((color_g >> 3) << 5) | ((color_b >> 3) << 10); |
| | 3717 | |
| | 3718 | dup_8x16b(colors, color); |
| | 3719 | dup_8x16b(zero_mask, 0x00); |
| | 3720 | dup_8x16b(right_mask, right_mask_bits); |
| | 3721 | tst_8x16b(right_mask, right_mask, test_mask); |
| | 3722 | |
| | 3723 | while(height) |
| | 3724 | { |
| | 3725 | blocks_remaining = block_width - 1; |
| | 3726 | num_blocks += block_width; |
| | 3727 | |
| | 3728 | #ifdef PROFILE |
| | 3729 | sprite_blocks += block_width; |
| | 3730 | #endif |
| | 3731 | |
| | 3732 | if(num_blocks > MAX_BLOCKS) |
| | 3733 | { |
| | 3734 | flush_render_block_buffer(psx_gpu); |
| | 3735 | num_blocks = block_width; |
| | 3736 | block = psx_gpu->blocks; |
| | 3737 | } |
| | 3738 | |
| | 3739 | while(blocks_remaining) |
| | 3740 | { |
| | 3741 | block->pixels = colors; |
| | 3742 | block->draw_mask = zero_mask; |
| | 3743 | block->fb_ptr = fb_ptr; |
| | 3744 | |
| | 3745 | fb_ptr += 8; |
| | 3746 | block++; |
| | 3747 | blocks_remaining--; |
| | 3748 | } |
| | 3749 | |
| | 3750 | block->pixels = colors; |
| | 3751 | block->draw_mask = right_mask; |
| | 3752 | block->fb_ptr = fb_ptr; |
| | 3753 | |
| | 3754 | block++; |
| | 3755 | fb_ptr += fb_ptr_pitch; |
| | 3756 | |
| | 3757 | height--; |
| | 3758 | psx_gpu->num_blocks = num_blocks; |
| | 3759 | } |
| | 3760 | } |
| | 3761 | |
| | 3762 | |
| | 3763 | |
| | 3764 | #define setup_sprite_blocks_switch_textured(texture_mode) \ |
| | 3765 | setup_sprite_##texture_mode \ |
| | 3766 | |
| | 3767 | #define setup_sprite_blocks_switch_untextured(texture_mode) \ |
| | 3768 | setup_sprite_untextured \ |
| | 3769 | |
| | 3770 | #define setup_sprite_blocks_switch(texturing, texture_mode) \ |
| | 3771 | setup_sprite_blocks_switch_##texturing(texture_mode) \ |
| | 3772 | |
| | 3773 | |
| | 3774 | #define texture_sprite_blocks_switch_4bpp() \ |
| | 3775 | texture_blocks_untextured \ |
| | 3776 | |
| | 3777 | #define texture_sprite_blocks_switch_8bpp() \ |
| | 3778 | texture_sprite_blocks_8bpp \ |
| | 3779 | |
| | 3780 | #define texture_sprite_blocks_switch_16bpp() \ |
| | 3781 | texture_blocks_untextured \ |
| | 3782 | |
| | 3783 | #define texture_sprite_blocks_switch_untextured(texture_mode) \ |
| | 3784 | texture_blocks_untextured \ |
| | 3785 | |
| | 3786 | #define texture_sprite_blocks_switch_textured(texture_mode) \ |
| | 3787 | texture_sprite_blocks_switch_##texture_mode() \ |
| | 3788 | |
| | 3789 | #define render_sprite_blocks_switch_block_modulation(texture_mode, blend_mode, \ |
| | 3790 | mask_evaluate, shading, dithering, texturing, blending, modulation) \ |
| | 3791 | { \ |
| | 3792 | setup_sprite_blocks_switch(texturing, texture_mode), \ |
| | 3793 | texture_sprite_blocks_switch_##texturing(texture_mode), \ |
| | 3794 | shade_blocks_switch(unshaded, texturing, modulation, undithered, blending, \ |
| | 3795 | mask_evaluate), \ |
| | 3796 | blend_blocks_switch(texturing, blending, blend_mode, mask_evaluate) \ |
| | 3797 | } \ |
| | 3798 | |
| | 3799 | #define render_sprite_blocks_switch_block_blending(texture_mode, blend_mode, \ |
| | 3800 | mask_evaluate, shading, dithering, texturing, blending) \ |
| | 3801 | render_sprite_blocks_switch_block_modulation(texture_mode, blend_mode, \ |
| | 3802 | mask_evaluate, shading, dithering, texturing, blending, modulated), \ |
| | 3803 | render_sprite_blocks_switch_block_modulation(texture_mode, blend_mode, \ |
| | 3804 | mask_evaluate, shading, dithering, texturing, blending, unmodulated) \ |
| | 3805 | |
| | 3806 | #define render_sprite_blocks_switch_block_texturing(texture_mode, blend_mode, \ |
| | 3807 | mask_evaluate, shading, dithering, texturing) \ |
| | 3808 | render_sprite_blocks_switch_block_blending(texture_mode, blend_mode, \ |
| | 3809 | mask_evaluate, shading, dithering, texturing, unblended), \ |
| | 3810 | render_sprite_blocks_switch_block_blending(texture_mode, blend_mode, \ |
| | 3811 | mask_evaluate, shading, dithering, texturing, blended) \ |
| | 3812 | |
| | 3813 | #define render_sprite_blocks_switch_block_dithering(texture_mode, blend_mode, \ |
| | 3814 | mask_evaluate, shading, dithering) \ |
| | 3815 | render_sprite_blocks_switch_block_texturing(texture_mode, blend_mode, \ |
| | 3816 | mask_evaluate, shading, dithering, untextured), \ |
| | 3817 | render_sprite_blocks_switch_block_texturing(texture_mode, blend_mode, \ |
| | 3818 | mask_evaluate, shading, dithering, textured) \ |
| | 3819 | |
| | 3820 | #define render_sprite_blocks_switch_block_shading(texture_mode, blend_mode, \ |
| | 3821 | mask_evaluate, shading) \ |
| | 3822 | render_sprite_blocks_switch_block_dithering(texture_mode, blend_mode, \ |
| | 3823 | mask_evaluate, shading, undithered), \ |
| | 3824 | render_sprite_blocks_switch_block_dithering(texture_mode, blend_mode, \ |
| | 3825 | mask_evaluate, shading, dithered) \ |
| | 3826 | |
| | 3827 | #define render_sprite_blocks_switch_block_mask_evaluate(texture_mode, \ |
| | 3828 | blend_mode, mask_evaluate) \ |
| | 3829 | render_sprite_blocks_switch_block_shading(texture_mode, blend_mode, \ |
| | 3830 | mask_evaluate, unshaded), \ |
| | 3831 | render_sprite_blocks_switch_block_shading(texture_mode, blend_mode, \ |
| | 3832 | mask_evaluate, shaded) \ |
| | 3833 | |
| | 3834 | #define render_sprite_blocks_switch_block_blend_mode(texture_mode, blend_mode) \ |
| | 3835 | render_sprite_blocks_switch_block_mask_evaluate(texture_mode, blend_mode, \ |
| | 3836 | off), \ |
| | 3837 | render_sprite_blocks_switch_block_mask_evaluate(texture_mode, blend_mode, \ |
| | 3838 | on) \ |
| | 3839 | |
| | 3840 | #define render_sprite_blocks_switch_block_texture_mode(texture_mode) \ |
| | 3841 | render_sprite_blocks_switch_block_blend_mode(texture_mode, average), \ |
| | 3842 | render_sprite_blocks_switch_block_blend_mode(texture_mode, add), \ |
| | 3843 | render_sprite_blocks_switch_block_blend_mode(texture_mode, subtract), \ |
| | 3844 | render_sprite_blocks_switch_block_blend_mode(texture_mode, add_fourth) \ |
| | 3845 | |
| | 3846 | #define render_sprite_blocks_switch_block() \ |
| | 3847 | render_sprite_blocks_switch_block_texture_mode(4bpp), \ |
| | 3848 | render_sprite_blocks_switch_block_texture_mode(8bpp), \ |
| | 3849 | render_sprite_blocks_switch_block_texture_mode(16bpp), \ |
| | 3850 | render_sprite_blocks_switch_block_texture_mode(4bpp) \ |
| | 3851 | |
| | 3852 | |
| | 3853 | render_block_handler_struct render_sprite_block_handlers[] = |
| | 3854 | { |
| | 3855 | render_sprite_blocks_switch_block() |
| | 3856 | }; |
| | 3857 | |
| | 3858 | |
| | 3859 | void render_sprite(psx_gpu_struct *psx_gpu, s32 x, s32 y, u32 u, u32 v, |
| | 3860 | s32 width, s32 height, u32 flags, u32 color) |
| | 3861 | { |
| | 3862 | s32 x_right = x + width - 1; |
| | 3863 | s32 y_bottom = y + height - 1; |
| | 3864 | |
| | 3865 | #ifdef PROFILE |
| | 3866 | sprites++; |
| | 3867 | #endif |
| | 3868 | |
| | 3869 | if(invalidate_texture_cache_region_viewport(psx_gpu, x, y, x_right, |
| | 3870 | y_bottom) == 0) |
| | 3871 | { |
| | 3872 | return; |
| | 3873 | } |
| | 3874 | |
| | 3875 | if(x < psx_gpu->viewport_start_x) |
| | 3876 | { |
| | 3877 | u32 clip = psx_gpu->viewport_start_x - x; |
| | 3878 | x += clip; |
| | 3879 | u += clip; |
| | 3880 | width -= clip; |
| | 3881 | } |
| | 3882 | |
| | 3883 | if(y < psx_gpu->viewport_start_y) |
| | 3884 | { |
| | 3885 | s32 clip = psx_gpu->viewport_start_y - y; |
| | 3886 | y += clip; |
| | 3887 | v += clip; |
| | 3888 | height -= clip; |
| | 3889 | } |
| | 3890 | |
| | 3891 | if(x_right > psx_gpu->viewport_end_x) |
| | 3892 | width -= x_right - psx_gpu->viewport_end_x; |
| | 3893 | |
| | 3894 | if(y_bottom > psx_gpu->viewport_end_y) |
| | 3895 | height -= y_bottom - psx_gpu->viewport_end_y; |
| | 3896 | |
| | 3897 | if((width <= 0) || (height <= 0)) |
| | 3898 | return; |
| | 3899 | |
| | 3900 | #ifdef PROFILE |
| | 3901 | span_pixels += width * height; |
| | 3902 | spans += height; |
| | 3903 | #endif |
| | 3904 | |
| | 3905 | u32 render_state = flags & |
| | 3906 | (RENDER_FLAGS_MODULATE_TEXELS | RENDER_FLAGS_BLEND | |
| | 3907 | RENDER_FLAGS_TEXTURE_MAP); |
| | 3908 | render_state |= |
| | 3909 | (psx_gpu->render_state_base & ~RENDER_STATE_DITHER); |
| | 3910 | |
| | 3911 | if((psx_gpu->render_state != render_state) || |
| | 3912 | (psx_gpu->primitive_type != PRIMITIVE_TYPE_SPRITE)) |
| | 3913 | { |
| | 3914 | psx_gpu->render_state = render_state; |
| | 3915 | flush_render_block_buffer(psx_gpu); |
| | 3916 | #ifdef PROFILE |
| | 3917 | state_changes++; |
| | 3918 | #endif |
| | 3919 | } |
| | 3920 | |
| | 3921 | psx_gpu->primitive_type = PRIMITIVE_TYPE_SPRITE; |
| | 3922 | |
| | 3923 | color &= 0xFFFFFF; |
| | 3924 | |
| | 3925 | if(psx_gpu->triangle_color != color) |
| | 3926 | { |
| | 3927 | flush_render_block_buffer(psx_gpu); |
| | 3928 | psx_gpu->triangle_color = color; |
| | 3929 | } |
| | 3930 | |
| | 3931 | if(color == 0x808080) |
| | 3932 | render_state |= RENDER_FLAGS_MODULATE_TEXELS; |
| | 3933 | |
| | 3934 | render_block_handler_struct *render_block_handler = |
| | 3935 | &(render_sprite_block_handlers[render_state]); |
| | 3936 | psx_gpu->render_block_handler = render_block_handler; |
| | 3937 | |
| | 3938 | ((setup_sprite_function_type *)render_block_handler->setup_blocks) |
| | 3939 | (psx_gpu, x, y, u, v, width, height, color); |
| | 3940 | } |
| | 3941 | |
| | 3942 | #define draw_pixel_line_mask_evaluate_yes() \ |
| | 3943 | if(*vram_ptr & 0x8000) \ |
| | 3944 | |
| | 3945 | #define draw_pixel_line_mask_evaluate_no() \ |
| | 3946 | |
| | 3947 | |
| | 3948 | #define draw_pixel_line_shaded() \ |
| | 3949 | { \ |
| | 3950 | color_r = fixed_to_int(current_r); \ |
| | 3951 | color_g = fixed_to_int(current_g); \ |
| | 3952 | color_b = fixed_to_int(current_b); \ |
| | 3953 | \ |
| | 3954 | current_r += gradient_r; \ |
| | 3955 | current_g += gradient_g; \ |
| | 3956 | current_b += gradient_b; \ |
| | 3957 | } \ |
| | 3958 | |
| | 3959 | #define draw_pixel_line_unshaded() \ |
| | 3960 | { \ |
| | 3961 | color_r = color & 0xFF; \ |
| | 3962 | color_g = (color >> 8) & 0xFF; \ |
| | 3963 | color_b = (color >> 16) & 0xFF; \ |
| | 3964 | } \ |
| | 3965 | |
| | 3966 | |
| | 3967 | #define draw_pixel_line_dithered(_x, _y) \ |
| | 3968 | { \ |
| | 3969 | u32 dither_xor = _x ^ _y; \ |
| | 3970 | s32 dither_offset = (dither_xor >> 1) & 0x1; \ |
| | 3971 | dither_offset |= (_y & 0x1) << 1; \ |
| | 3972 | dither_offset |= (dither_xor & 0x1) << 2; \ |
| | 3973 | dither_offset -= 4; \ |
| | 3974 | \ |
| | 3975 | color_r += dither_offset; \ |
| | 3976 | color_g += dither_offset; \ |
| | 3977 | color_b += dither_offset; \ |
| | 3978 | \ |
| | 3979 | if(color_r < 0) \ |
| | 3980 | color_r = 0; \ |
| | 3981 | \ |
| | 3982 | if(color_g < 0) \ |
| | 3983 | color_g = 0; \ |
| | 3984 | \ |
| | 3985 | if(color_b < 0) \ |
| | 3986 | color_b = 0; \ |
| | 3987 | \ |
| | 3988 | if(color_r > 255) \ |
| | 3989 | color_r = 255; \ |
| | 3990 | \ |
| | 3991 | if(color_g > 255) \ |
| | 3992 | color_g = 255; \ |
| | 3993 | \ |
| | 3994 | if(color_b > 255) \ |
| | 3995 | color_b = 255; \ |
| | 3996 | } \ |
| | 3997 | |
| | 3998 | #define draw_pixel_line_undithered(_x, _y) \ |
| | 3999 | |
| | 4000 | |
| | 4001 | #define draw_pixel_line_average() \ |
| | 4002 | color_r = (color_r + fb_r) / 2; \ |
| | 4003 | color_g = (color_g + fb_g) / 2; \ |
| | 4004 | color_b = (color_b + fb_b) / 2 \ |
| | 4005 | |
| | 4006 | #define draw_pixel_line_add() \ |
| | 4007 | color_r += fb_r; \ |
| | 4008 | color_g += fb_g; \ |
| | 4009 | color_b += fb_b; \ |
| | 4010 | \ |
| | 4011 | if(color_r > 31) \ |
| | 4012 | color_r = 31; \ |
| | 4013 | \ |
| | 4014 | if(color_g > 31) \ |
| | 4015 | color_g = 31; \ |
| | 4016 | \ |
| | 4017 | if(color_b > 31) \ |
| | 4018 | color_b = 31 \ |
| | 4019 | \ |
| | 4020 | |
| | 4021 | #define draw_pixel_line_subtract() \ |
| | 4022 | color_r = fb_r - color_r; \ |
| | 4023 | color_g = fb_g - color_g; \ |
| | 4024 | color_b = fb_b - color_b; \ |
| | 4025 | \ |
| | 4026 | if(color_r < 0) \ |
| | 4027 | color_r = 0; \ |
| | 4028 | \ |
| | 4029 | if(color_g < 0) \ |
| | 4030 | color_g = 0; \ |
| | 4031 | \ |
| | 4032 | if(color_b < 0) \ |
| | 4033 | color_b = 0 \ |
| | 4034 | |
| | 4035 | #define draw_pixel_line_add_fourth() \ |
| | 4036 | color_r = fb_r + (color_r / 4); \ |
| | 4037 | color_g = fb_g + (color_g / 4); \ |
| | 4038 | color_b = fb_b + (color_b / 4); \ |
| | 4039 | \ |
| | 4040 | if(color_r > 31) \ |
| | 4041 | color_r = 31; \ |
| | 4042 | \ |
| | 4043 | if(color_g > 31) \ |
| | 4044 | color_g = 31; \ |
| | 4045 | \ |
| | 4046 | if(color_b > 31) \ |
| | 4047 | color_b = 31 \ |
| | 4048 | |
| | 4049 | |
| | 4050 | #define draw_pixel_line_blended(blend_mode) \ |
| | 4051 | s32 fb_pixel = *vram_ptr; \ |
| | 4052 | s32 fb_r = fb_pixel & 0x1F; \ |
| | 4053 | s32 fb_g = (fb_pixel >> 5) & 0x1F; \ |
| | 4054 | s32 fb_b = (fb_pixel >> 10) & 0x1F; \ |
| | 4055 | \ |
| | 4056 | draw_pixel_line_##blend_mode() \ |
| | 4057 | |
| | 4058 | #define draw_pixel_line_unblended(blend_mode) \ |
| | 4059 | |
| | 4060 | |
| | 4061 | #define draw_pixel_line(_x, _y, shading, blending, dithering, mask_evaluate, \ |
| | 4062 | blend_mode) \ |
| | 4063 | if((_x >= psx_gpu->viewport_start_x) && (_y >= psx_gpu->viewport_start_y) && \ |
| | 4064 | (_x <= psx_gpu->viewport_end_x) && (_y <= psx_gpu->viewport_end_y)) \ |
| | 4065 | { \ |
| | 4066 | draw_pixel_line_mask_evaluate_##mask_evaluate() \ |
| | 4067 | { \ |
| | 4068 | draw_pixel_line_##shading(); \ |
| | 4069 | draw_pixel_line_##dithering(_x, _y); \ |
| | 4070 | \ |
| | 4071 | color_r >>= 3; \ |
| | 4072 | color_g >>= 3; \ |
| | 4073 | color_b >>= 3; \ |
| | 4074 | \ |
| | 4075 | draw_pixel_line_##blending(blend_mode); \ |
| | 4076 | \ |
| | 4077 | *vram_ptr = color_r | (color_g << 5) | (color_b << 10) | \ |
| | 4078 | psx_gpu->mask_msb; \ |
| | 4079 | } \ |
| | 4080 | } \ |
| | 4081 | |
| | 4082 | #define update_increment(value) \ |
| | 4083 | value++ \ |
| | 4084 | |
| | 4085 | #define update_decrement(value) \ |
| | 4086 | value-- \ |
| | 4087 | |
| | 4088 | #define update_vram_row_increment(value) \ |
| | 4089 | vram_ptr += 1024 \ |
| | 4090 | |
| | 4091 | #define update_vram_row_decrement(value) \ |
| | 4092 | vram_ptr -= 1024 \ |
| | 4093 | |
| | 4094 | #define compare_increment(a, b) \ |
| | 4095 | (a <= b) \ |
| | 4096 | |
| | 4097 | #define compare_decrement(a, b) \ |
| | 4098 | (a >= b) \ |
| | 4099 | |
| | 4100 | #define set_line_gradients(minor) \ |
| | 4101 | { \ |
| | 4102 | s32 gradient_divisor = delta_##minor; \ |
| | 4103 | if(gradient_divisor != 0) \ |
| | 4104 | { \ |
| | 4105 | gradient_r = int_to_fixed(vertex_b->r - vertex_a->r) / gradient_divisor; \ |
| | 4106 | gradient_g = int_to_fixed(vertex_b->g - vertex_a->g) / gradient_divisor; \ |
| | 4107 | gradient_b = int_to_fixed(vertex_b->b - vertex_a->b) / gradient_divisor; \ |
| | 4108 | } \ |
| | 4109 | else \ |
| | 4110 | { \ |
| | 4111 | gradient_r = 0; \ |
| | 4112 | gradient_g = 0; \ |
| | 4113 | gradient_b = 0; \ |
| | 4114 | } \ |
| | 4115 | current_r = fixed_center(vertex_a->r); \ |
| | 4116 | current_g = fixed_center(vertex_a->g); \ |
| | 4117 | current_b = fixed_center(vertex_a->b); \ |
| | 4118 | } |
| | 4119 | |
| | 4120 | #define draw_line_span_horizontal(direction, shading, blending, dithering, \ |
| | 4121 | mask_evaluate, blend_mode) \ |
| | 4122 | do \ |
| | 4123 | { \ |
| | 4124 | error_step = delta_y * 2; \ |
| | 4125 | error_wrap = delta_x * 2; \ |
| | 4126 | error = delta_x; \ |
| | 4127 | \ |
| | 4128 | current_y = y_a; \ |
| | 4129 | set_line_gradients(x); \ |
| | 4130 | \ |
| | 4131 | for(current_x = x_a; current_x <= x_b; current_x++) \ |
| | 4132 | { \ |
| | 4133 | draw_pixel_line(current_x, current_y, shading, blending, dithering, \ |
| | 4134 | mask_evaluate, blend_mode); \ |
| | 4135 | error += error_step; \ |
| | 4136 | vram_ptr++; \ |
| | 4137 | \ |
| | 4138 | if(error >= error_wrap) \ |
| | 4139 | { \ |
| | 4140 | update_##direction(current_y); \ |
| | 4141 | update_vram_row_##direction(); \ |
| | 4142 | error -= error_wrap; \ |
| | 4143 | } \ |
| | 4144 | } \ |
| | 4145 | } while(0) \ |
| | 4146 | |
| | 4147 | #define draw_line_span_vertical(direction, shading, blending, dithering, \ |
| | 4148 | mask_evaluate, blend_mode) \ |
| | 4149 | do \ |
| | 4150 | { \ |
| | 4151 | error_step = delta_x * 2; \ |
| | 4152 | error_wrap = delta_y * 2; \ |
| | 4153 | error = delta_y; \ |
| | 4154 | \ |
| | 4155 | current_x = x_a; \ |
| | 4156 | set_line_gradients(y); \ |
| | 4157 | \ |
| | 4158 | for(current_y = y_a; compare_##direction(current_y, y_b); \ |
| | 4159 | update_##direction(current_y)) \ |
| | 4160 | { \ |
| | 4161 | draw_pixel_line(current_x, current_y, shading, blending, dithering, \ |
| | 4162 | mask_evaluate, blend_mode); \ |
| | 4163 | error += error_step; \ |
| | 4164 | update_vram_row_##direction(); \ |
| | 4165 | \ |
| | 4166 | if(error > error_wrap) \ |
| | 4167 | { \ |
| | 4168 | vram_ptr++; \ |
| | 4169 | current_x++; \ |
| | 4170 | error -= error_wrap; \ |
| | 4171 | } \ |
| | 4172 | } \ |
| | 4173 | } while(0) \ |
| | 4174 | |
| | 4175 | |
| | 4176 | #define render_line_body(shading, blending, dithering, mask_evaluate, \ |
| | 4177 | blend_mode) \ |
| | 4178 | if(delta_y < 0) \ |
| | 4179 | { \ |
| | 4180 | delta_y *= -1; \ |
| | 4181 | \ |
| | 4182 | if(delta_x > delta_y) \ |
| | 4183 | { \ |
| | 4184 | draw_line_span_horizontal(decrement, shading, blending, dithering, \ |
| | 4185 | mask_evaluate, blend_mode); \ |
| | 4186 | } \ |
| | 4187 | else \ |
| | 4188 | { \ |
| | 4189 | draw_line_span_vertical(decrement, shading, blending, dithering, \ |
| | 4190 | mask_evaluate, blend_mode); \ |
| | 4191 | } \ |
| | 4192 | } \ |
| | 4193 | else \ |
| | 4194 | { \ |
| | 4195 | if(delta_x > delta_y) \ |
| | 4196 | { \ |
| | 4197 | draw_line_span_horizontal(increment, shading, blending, dithering, \ |
| | 4198 | mask_evaluate, blend_mode); \ |
| | 4199 | } \ |
| | 4200 | else \ |
| | 4201 | { \ |
| | 4202 | draw_line_span_vertical(increment, shading, blending, dithering, \ |
| | 4203 | mask_evaluate, blend_mode); \ |
| | 4204 | } \ |
| | 4205 | } \ |
| | 4206 | |
| | 4207 | |
| | 4208 | void render_line(psx_gpu_struct *psx_gpu, vertex_struct *vertexes, u32 flags, |
| | 4209 | u32 color, int double_resolution) |
| | 4210 | { |
| | 4211 | s32 color_r, color_g, color_b; |
| | 4212 | u32 triangle_winding = 0; |
| | 4213 | |
| | 4214 | fixed_type gradient_r = 0; |
| | 4215 | fixed_type gradient_g = 0; |
| | 4216 | fixed_type gradient_b = 0; |
| | 4217 | fixed_type current_r = 0; |
| | 4218 | fixed_type current_g = 0; |
| | 4219 | fixed_type current_b = 0; |
| | 4220 | |
| | 4221 | s32 y_a, y_b; |
| | 4222 | s32 x_a, x_b; |
| | 4223 | |
| | 4224 | s32 delta_x, delta_y; |
| | 4225 | |
| | 4226 | s32 current_x; |
| | 4227 | s32 current_y; |
| | 4228 | |
| | 4229 | u32 error_step; |
| | 4230 | u32 error; |
| | 4231 | u32 error_wrap; |
| | 4232 | |
| | 4233 | u16 *vram_ptr; |
| | 4234 | |
| | 4235 | flush_render_block_buffer(psx_gpu); |
| | 4236 | psx_gpu->primitive_type = PRIMITIVE_TYPE_LINE; |
| | 4237 | |
| | 4238 | vertex_struct *vertex_a = &(vertexes[0]); |
| | 4239 | vertex_struct *vertex_b = &(vertexes[1]); |
| | 4240 | |
| | 4241 | u32 control_mask; |
| | 4242 | |
| | 4243 | #ifdef PROFILE |
| | 4244 | lines++; |
| | 4245 | #endif |
| | 4246 | |
| | 4247 | if(vertex_a->x >= vertex_b->x) |
| | 4248 | { |
| | 4249 | vertex_swap(vertex_a, vertex_b); |
| | 4250 | } |
| | 4251 | |
| | 4252 | x_a = vertex_a->x; |
| | 4253 | x_b = vertex_b->x; |
| | 4254 | |
| | 4255 | y_a = vertex_a->y; |
| | 4256 | y_b = vertex_b->y; |
| | 4257 | |
| | 4258 | delta_x = x_b - x_a; |
| | 4259 | delta_y = y_b - y_a; |
| | 4260 | |
| | 4261 | if(delta_x >= 1024 || delta_y >= 512 || delta_y <= -512) |
| | 4262 | return; |
| | 4263 | |
| | 4264 | if(double_resolution) |
| | 4265 | { |
| | 4266 | x_a *= 2; |
| | 4267 | x_b *= 2; |
| | 4268 | y_a *= 2; |
| | 4269 | y_b *= 2; |
| | 4270 | delta_x *= 2; |
| | 4271 | delta_y *= 2; |
| | 4272 | } |
| | 4273 | |
| | 4274 | flags &= ~RENDER_FLAGS_TEXTURE_MAP; |
| | 4275 | |
| | 4276 | vram_ptr = psx_gpu->vram_out_ptr + (y_a * 1024) + x_a; |
| | 4277 | |
| | 4278 | control_mask = 0x0; |
| | 4279 | |
| | 4280 | if(flags & RENDER_FLAGS_SHADE) |
| | 4281 | control_mask |= 0x1; |
| | 4282 | |
| | 4283 | if(flags & RENDER_FLAGS_BLEND) |
| | 4284 | { |
| | 4285 | control_mask |= 0x2; |
| | 4286 | control_mask |= ((psx_gpu->render_state_base >> 6) & 0x3) << 4; |
| | 4287 | } |
| | 4288 | |
| | 4289 | if(psx_gpu->render_state_base & RENDER_STATE_DITHER) |
| | 4290 | control_mask |= 0x4; |
| | 4291 | |
| | 4292 | if(psx_gpu->render_state_base & RENDER_STATE_MASK_EVALUATE) |
| | 4293 | control_mask |= 0x8; |
| | 4294 | |
| | 4295 | switch(control_mask) |
| | 4296 | { |
| | 4297 | case 0x0: |
| | 4298 | render_line_body(unshaded, unblended, undithered, no, none); |
| | 4299 | break; |
| | 4300 | |
| | 4301 | case 0x1: |
| | 4302 | render_line_body(shaded, unblended, undithered, no, none); |
| | 4303 | break; |
| | 4304 | |
| | 4305 | case 0x2: |
| | 4306 | render_line_body(unshaded, blended, undithered, no, average); |
| | 4307 | break; |
| | 4308 | |
| | 4309 | case 0x3: |
| | 4310 | render_line_body(shaded, blended, undithered, no, average); |
| | 4311 | break; |
| | 4312 | |
| | 4313 | case 0x4: |
| | 4314 | render_line_body(unshaded, unblended, dithered, no, none); |
| | 4315 | break; |
| | 4316 | |
| | 4317 | case 0x5: |
| | 4318 | render_line_body(shaded, unblended, dithered, no, none); |
| | 4319 | break; |
| | 4320 | |
| | 4321 | case 0x6: |
| | 4322 | render_line_body(unshaded, blended, dithered, no, average); |
| | 4323 | break; |
| | 4324 | |
| | 4325 | case 0x7: |
| | 4326 | render_line_body(shaded, blended, dithered, no, average); |
| | 4327 | break; |
| | 4328 | |
| | 4329 | case 0x8: |
| | 4330 | render_line_body(unshaded, unblended, undithered, yes, none); |
| | 4331 | break; |
| | 4332 | |
| | 4333 | case 0x9: |
| | 4334 | render_line_body(shaded, unblended, undithered, yes, none); |
| | 4335 | break; |
| | 4336 | |
| | 4337 | case 0xA: |
| | 4338 | render_line_body(unshaded, blended, undithered, yes, average); |
| | 4339 | break; |
| | 4340 | |
| | 4341 | case 0xB: |
| | 4342 | render_line_body(shaded, blended, undithered, yes, average); |
| | 4343 | break; |
| | 4344 | |
| | 4345 | case 0xC: |
| | 4346 | render_line_body(unshaded, unblended, dithered, yes, none); |
| | 4347 | break; |
| | 4348 | |
| | 4349 | case 0xD: |
| | 4350 | render_line_body(shaded, unblended, dithered, yes, none); |
| | 4351 | break; |
| | 4352 | |
| | 4353 | case 0xE: |
| | 4354 | render_line_body(unshaded, blended, dithered, yes, average); |
| | 4355 | break; |
| | 4356 | |
| | 4357 | case 0xF: |
| | 4358 | render_line_body(shaded, blended, dithered, yes, average); |
| | 4359 | break; |
| | 4360 | |
| | 4361 | case 0x12: |
| | 4362 | render_line_body(unshaded, blended, undithered, no, add); |
| | 4363 | break; |
| | 4364 | |
| | 4365 | case 0x13: |
| | 4366 | render_line_body(shaded, blended, undithered, no, add); |
| | 4367 | break; |
| | 4368 | |
| | 4369 | case 0x16: |
| | 4370 | render_line_body(unshaded, blended, dithered, no, add); |
| | 4371 | break; |
| | 4372 | |
| | 4373 | case 0x17: |
| | 4374 | render_line_body(shaded, blended, dithered, no, add); |
| | 4375 | break; |
| | 4376 | |
| | 4377 | case 0x1A: |
| | 4378 | render_line_body(unshaded, blended, undithered, yes, add); |
| | 4379 | break; |
| | 4380 | |
| | 4381 | case 0x1B: |
| | 4382 | render_line_body(shaded, blended, undithered, yes, add); |
| | 4383 | break; |
| | 4384 | |
| | 4385 | case 0x1E: |
| | 4386 | render_line_body(unshaded, blended, dithered, yes, add); |
| | 4387 | break; |
| | 4388 | |
| | 4389 | case 0x1F: |
| | 4390 | render_line_body(shaded, blended, dithered, yes, add); |
| | 4391 | break; |
| | 4392 | |
| | 4393 | case 0x22: |
| | 4394 | render_line_body(unshaded, blended, undithered, no, subtract); |
| | 4395 | break; |
| | 4396 | |
| | 4397 | case 0x23: |
| | 4398 | render_line_body(shaded, blended, undithered, no, subtract); |
| | 4399 | break; |
| | 4400 | |
| | 4401 | case 0x26: |
| | 4402 | render_line_body(unshaded, blended, dithered, no, subtract); |
| | 4403 | break; |
| | 4404 | |
| | 4405 | case 0x27: |
| | 4406 | render_line_body(shaded, blended, dithered, no, subtract); |
| | 4407 | break; |
| | 4408 | |
| | 4409 | case 0x2A: |
| | 4410 | render_line_body(unshaded, blended, undithered, yes, subtract); |
| | 4411 | break; |
| | 4412 | |
| | 4413 | case 0x2B: |
| | 4414 | render_line_body(shaded, blended, undithered, yes, subtract); |
| | 4415 | break; |
| | 4416 | |
| | 4417 | case 0x2E: |
| | 4418 | render_line_body(unshaded, blended, dithered, yes, subtract); |
| | 4419 | break; |
| | 4420 | |
| | 4421 | case 0x2F: |
| | 4422 | render_line_body(shaded, blended, dithered, yes, subtract); |
| | 4423 | break; |
| | 4424 | |
| | 4425 | case 0x32: |
| | 4426 | render_line_body(unshaded, blended, undithered, no, add_fourth); |
| | 4427 | break; |
| | 4428 | |
| | 4429 | case 0x33: |
| | 4430 | render_line_body(shaded, blended, undithered, no, add_fourth); |
| | 4431 | break; |
| | 4432 | |
| | 4433 | case 0x36: |
| | 4434 | render_line_body(unshaded, blended, dithered, no, add_fourth); |
| | 4435 | break; |
| | 4436 | |
| | 4437 | case 0x37: |
| | 4438 | render_line_body(shaded, blended, dithered, no, add_fourth); |
| | 4439 | break; |
| | 4440 | |
| | 4441 | case 0x3A: |
| | 4442 | render_line_body(unshaded, blended, undithered, yes, add_fourth); |
| | 4443 | break; |
| | 4444 | |
| | 4445 | case 0x3B: |
| | 4446 | render_line_body(shaded, blended, undithered, yes, add_fourth); |
| | 4447 | break; |
| | 4448 | |
| | 4449 | case 0x3E: |
| | 4450 | render_line_body(unshaded, blended, dithered, yes, add_fourth); |
| | 4451 | break; |
| | 4452 | |
| | 4453 | case 0x3F: |
| | 4454 | render_line_body(shaded, blended, dithered, yes, add_fourth); |
| | 4455 | break; |
| | 4456 | } |
| | 4457 | } |
| | 4458 | |
| | 4459 | |
| | 4460 | void render_block_fill(psx_gpu_struct *psx_gpu, u32 color, u32 x, u32 y, |
| | 4461 | u32 width, u32 height) |
| | 4462 | { |
| | 4463 | if((width == 0) || (height == 0)) |
| | 4464 | return; |
| | 4465 | |
| | 4466 | invalidate_texture_cache_region(psx_gpu, x, y, x + width - 1, y + height - 1); |
| | 4467 | |
| | 4468 | u32 r = color & 0xFF; |
| | 4469 | u32 g = (color >> 8) & 0xFF; |
| | 4470 | u32 b = (color >> 16) & 0xFF; |
| | 4471 | u32 color_16bpp = (r >> 3) | ((g >> 3) << 5) | ((b >> 3) << 10) | |
| | 4472 | psx_gpu->mask_msb; |
| | 4473 | u32 color_32bpp = color_16bpp | (color_16bpp << 16); |
| | 4474 | |
| | 4475 | u32 *vram_ptr = (u32 *)(psx_gpu->vram_out_ptr + x + (y * 1024)); |
| | 4476 | |
| | 4477 | u32 pitch = 512 - (width / 2); |
| | 4478 | u32 num_width; |
| | 4479 | |
| | 4480 | if(psx_gpu->render_mode & RENDER_INTERLACE_ENABLED) |
| | 4481 | { |
| | 4482 | pitch += 512; |
| | 4483 | height /= 2; |
| | 4484 | |
| | 4485 | if(psx_gpu->render_mode & RENDER_INTERLACE_ODD) |
| | 4486 | vram_ptr += 512; |
| | 4487 | } |
| | 4488 | |
| | 4489 | while(height) |
| | 4490 | { |
| | 4491 | num_width = width; |
| | 4492 | while(num_width) |
| | 4493 | { |
| | 4494 | vram_ptr[0] = color_32bpp; |
| | 4495 | vram_ptr[1] = color_32bpp; |
| | 4496 | vram_ptr[2] = color_32bpp; |
| | 4497 | vram_ptr[3] = color_32bpp; |
| | 4498 | vram_ptr[4] = color_32bpp; |
| | 4499 | vram_ptr[5] = color_32bpp; |
| | 4500 | vram_ptr[6] = color_32bpp; |
| | 4501 | vram_ptr[7] = color_32bpp; |
| | 4502 | |
| | 4503 | vram_ptr += 8; |
| | 4504 | num_width -= 16; |
| | 4505 | } |
| | 4506 | |
| | 4507 | vram_ptr += pitch; |
| | 4508 | height--; |
| | 4509 | } |
| | 4510 | } |
| | 4511 | |
| | 4512 | void render_block_fill_enh(psx_gpu_struct *psx_gpu, u32 color, u32 x, u32 y, |
| | 4513 | u32 width, u32 height) |
| | 4514 | { |
| | 4515 | if((width == 0) || (height == 0)) |
| | 4516 | return; |
| | 4517 | |
| | 4518 | if(width > 1024) |
| | 4519 | width = 1024; |
| | 4520 | |
| | 4521 | u32 r = color & 0xFF; |
| | 4522 | u32 g = (color >> 8) & 0xFF; |
| | 4523 | u32 b = (color >> 16) & 0xFF; |
| | 4524 | u32 color_16bpp = (r >> 3) | ((g >> 3) << 5) | ((b >> 3) << 10) | |
| | 4525 | psx_gpu->mask_msb; |
| | 4526 | u32 color_32bpp = color_16bpp | (color_16bpp << 16); |
| | 4527 | |
| | 4528 | u32 *vram_ptr = (u32 *)(psx_gpu->vram_out_ptr + x + (y * 1024)); |
| | 4529 | |
| | 4530 | u32 pitch = 1024 / 2 - (width / 2); |
| | 4531 | u32 num_width; |
| | 4532 | |
| | 4533 | while(height) |
| | 4534 | { |
| | 4535 | num_width = width; |
| | 4536 | while(num_width) |
| | 4537 | { |
| | 4538 | vram_ptr[0] = color_32bpp; |
| | 4539 | vram_ptr[1] = color_32bpp; |
| | 4540 | vram_ptr[2] = color_32bpp; |
| | 4541 | vram_ptr[3] = color_32bpp; |
| | 4542 | vram_ptr[4] = color_32bpp; |
| | 4543 | vram_ptr[5] = color_32bpp; |
| | 4544 | vram_ptr[6] = color_32bpp; |
| | 4545 | vram_ptr[7] = color_32bpp; |
| | 4546 | |
| | 4547 | vram_ptr += 8; |
| | 4548 | num_width -= 16; |
| | 4549 | } |
| | 4550 | |
| | 4551 | vram_ptr += pitch; |
| | 4552 | height--; |
| | 4553 | } |
| | 4554 | } |
| | 4555 | |
| | 4556 | void render_block_copy(psx_gpu_struct *psx_gpu, u16 *source, u32 x, u32 y, |
| | 4557 | u32 width, u32 height, u32 pitch) |
| | 4558 | { |
| | 4559 | u16 *vram_ptr = psx_gpu->vram_ptr + x + (y * 1024); |
| | 4560 | u32 draw_x, draw_y; |
| | 4561 | u32 mask_msb = psx_gpu->mask_msb; |
| | 4562 | |
| | 4563 | if((width == 0) || (height == 0)) |
| | 4564 | return; |
| | 4565 | |
| | 4566 | flush_render_block_buffer(psx_gpu); |
| | 4567 | invalidate_texture_cache_region(psx_gpu, x, y, x + width - 1, y + height - 1); |
| | 4568 | |
| | 4569 | for(draw_y = 0; draw_y < height; draw_y++) |
| | 4570 | { |
| | 4571 | for(draw_x = 0; draw_x < width; draw_x++) |
| | 4572 | { |
| | 4573 | vram_ptr[draw_x] = source[draw_x] | mask_msb; |
| | 4574 | } |
| | 4575 | |
| | 4576 | source += pitch; |
| | 4577 | vram_ptr += 1024; |
| | 4578 | } |
| | 4579 | } |
| | 4580 | |
| | 4581 | void render_block_move(psx_gpu_struct *psx_gpu, u32 source_x, u32 source_y, |
| | 4582 | u32 dest_x, u32 dest_y, u32 width, u32 height) |
| | 4583 | { |
| | 4584 | render_block_copy(psx_gpu, psx_gpu->vram_ptr + source_x + (source_y * 1024), |
| | 4585 | dest_x, dest_y, width, height, 1024); |
| | 4586 | } |
| | 4587 | |
| | 4588 | |
| | 4589 | void initialize_reciprocal_table(void) |
| | 4590 | { |
| | 4591 | u32 height; |
| | 4592 | u32 height_normalized; |
| | 4593 | u32 height_reciprocal; |
| | 4594 | s32 shift; |
| | 4595 | |
| | 4596 | for(height = 1; height < sizeof(reciprocal_table) |
| | 4597 | / sizeof(reciprocal_table[0]); height++) |
| | 4598 | { |
| | 4599 | shift = __builtin_clz(height); |
| | 4600 | height_normalized = height << shift; |
| | 4601 | height_reciprocal = ((1ULL << 52) + (height_normalized - 1)) / |
| | 4602 | height_normalized; |
| | 4603 | |
| | 4604 | shift = 32 - (52 - shift); |
| | 4605 | |
| | 4606 | reciprocal_table[height] = (height_reciprocal << 10) | shift; |
| | 4607 | } |
| | 4608 | } |
| | 4609 | |
| | 4610 | |
| | 4611 | #define dither_table_row(a, b, c, d) \ |
| | 4612 | ((a & 0xFF) | ((b & 0xFF) << 8) | ((c & 0xFF) << 16) | ((d & 0xFF) << 24)) \ |
| | 4613 | |
| | 4614 | void initialize_psx_gpu(psx_gpu_struct *psx_gpu, u16 *vram) |
| | 4615 | { |
| | 4616 | vec_8x16u test_mask = |
| | 4617 | { { { 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80 } } }; |
| | 4618 | |
| | 4619 | psx_gpu->test_mask = test_mask; |
| | 4620 | |
| | 4621 | psx_gpu->dirty_textures_4bpp_mask = 0xFFFFFFFF; |
| | 4622 | psx_gpu->dirty_textures_8bpp_mask = 0xFFFFFFFF; |
| | 4623 | psx_gpu->dirty_textures_8bpp_alternate_mask = 0xFFFFFFFF; |
| | 4624 | psx_gpu->viewport_mask = 0; |
| | 4625 | psx_gpu->current_texture_page = 0; |
| | 4626 | psx_gpu->current_texture_mask = 0; |
| | 4627 | psx_gpu->last_8bpp_texture_page = 0; |
| | 4628 | |
| | 4629 | psx_gpu->clut_settings = 0; |
| | 4630 | psx_gpu->texture_settings = 0; |
| | 4631 | psx_gpu->render_state = 0; |
| | 4632 | psx_gpu->render_state_base = 0; |
| | 4633 | psx_gpu->num_blocks = 0; |
| | 4634 | psx_gpu->uvrgb_phase = 0x8000; |
| | 4635 | |
| | 4636 | psx_gpu->vram_ptr = vram; |
| | 4637 | psx_gpu->vram_out_ptr = vram; |
| | 4638 | |
| | 4639 | psx_gpu->texture_page_base = psx_gpu->vram_ptr; |
| | 4640 | psx_gpu->texture_page_ptr = psx_gpu->vram_ptr; |
| | 4641 | psx_gpu->clut_ptr = psx_gpu->vram_ptr; |
| | 4642 | |
| | 4643 | psx_gpu->mask_msb = 0; |
| | 4644 | |
| | 4645 | psx_gpu->texture_window_x = 0; |
| | 4646 | psx_gpu->texture_window_y = 0; |
| | 4647 | psx_gpu->texture_mask_width = 0xFF; |
| | 4648 | psx_gpu->texture_mask_height = 0xFF; |
| | 4649 | |
| | 4650 | psx_gpu->render_mode = 0; |
| | 4651 | |
| | 4652 | memset(psx_gpu->vram_ptr, 0, sizeof(u16) * 1024 * 512); |
| | 4653 | |
| | 4654 | initialize_reciprocal_table(); |
| | 4655 | |
| | 4656 | // 00 01 10 11 |
| | 4657 | // 00 0 4 1 5 |
| | 4658 | // 01 6 2 7 3 |
| | 4659 | // 10 1 5 0 4 |
| | 4660 | // 11 7 3 6 2 |
| | 4661 | // (minus ones(4) * 4) |
| | 4662 | |
| | 4663 | // d0: (1 3 5 7): x1 ^ y1 |
| | 4664 | // d1: (2 3 6 7): y0 |
| | 4665 | // d2: (4 5 6 7): x0 ^ y0 |
| | 4666 | |
| | 4667 | psx_gpu->dither_table[0] = dither_table_row(-4, 0, -3, 1); |
| | 4668 | psx_gpu->dither_table[1] = dither_table_row(2, -2, 3, -1); |
| | 4669 | psx_gpu->dither_table[2] = dither_table_row(-3, 1, -4, 0); |
| | 4670 | psx_gpu->dither_table[3] = dither_table_row(3, -1, 2, -2); |
| | 4671 | |
| | 4672 | psx_gpu->primitive_type = PRIMITIVE_TYPE_UNKNOWN; |
| | 4673 | |
| | 4674 | psx_gpu->enhancement_x_threshold = 256; |
| | 4675 | } |
| | 4676 | |
| | 4677 | u64 get_us(void) |
| | 4678 | { |
| | 4679 | struct timeval tv; |
| | 4680 | gettimeofday(&tv, NULL); |
| | 4681 | |
| | 4682 | return (tv.tv_sec * 1000000ULL) + tv.tv_usec; |
| | 4683 | } |
| | 4684 | |
| | 4685 | #ifdef NEON_BUILD |
| | 4686 | |
| | 4687 | u32 get_counter() |
| | 4688 | { |
| | 4689 | u32 counter; |
| | 4690 | __asm__ volatile("mrc p15, 0, %0, c9, c13, 0" : "=r"(counter)); |
| | 4691 | |
| | 4692 | return counter; |
| | 4693 | } |
| | 4694 | |
| | 4695 | void init_counter(void) |
| | 4696 | { |
| | 4697 | u32 value; |
| | 4698 | asm volatile("mrc p15, 0, %0, c9, c12, 0" : "=r"(value)); |
| | 4699 | value |= 5; // master enable, ccnt reset |
| | 4700 | value &= ~8; // ccnt divider 0 |
| | 4701 | asm volatile("mcr p15, 0, %0, c9, c12, 0" :: "r"(value)); |
| | 4702 | // enable cycle counter |
| | 4703 | asm volatile("mcr p15, 0, %0, c9, c12, 1" :: "r"(1 << 31)); |
| | 4704 | } |
| | 4705 | |
| | 4706 | void triangle_benchmark(psx_gpu_struct *psx_gpu) |
| | 4707 | { |
| | 4708 | u32 i; |
| | 4709 | |
| | 4710 | u32 ticks; |
| | 4711 | u32 ticks_elapsed; |
| | 4712 | |
| | 4713 | const u32 iterations = 500000; |
| | 4714 | |
| | 4715 | psx_gpu->num_blocks = 64; |
| | 4716 | psx_gpu->clut_ptr = psx_gpu->vram_ptr; |
| | 4717 | |
| | 4718 | for(i = 0; i < 64; i++) |
| | 4719 | { |
| | 4720 | memset(&(psx_gpu->blocks[i].r), 0, 16); |
| | 4721 | } |
| | 4722 | |
| | 4723 | init_counter(); |
| | 4724 | |
| | 4725 | ticks = get_counter(); |
| | 4726 | |
| | 4727 | for(i = 0; i < iterations; i++) |
| | 4728 | { |
| | 4729 | texture_sprite_blocks_8bpp(psx_gpu); |
| | 4730 | } |
| | 4731 | |
| | 4732 | ticks_elapsed = get_counter() - ticks; |
| | 4733 | |
| | 4734 | printf("benchmark: %lf cycles\n", (double)ticks_elapsed / (iterations * 64)); |
| | 4735 | } |
| | 4736 | |
| | 4737 | #endif |
| | 4738 | |
notaz.gp2x.de / pcsx_rearmed.git / blame_incremental