plugins/gpu_neon/psx_gpu/psx_gpu_parse.c

   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
  17 #include "common.h"
  18
  19 #ifndef command_lengths
  20 const u8 command_lengths[256] =
  21 {
  22         0,  0,  2,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,   // 00
  23         0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,   // 10
  24         3,  3,  3,  3,  6,  6,  6,  6,  4,  4,  4,  4,  8,  8,  8,  8,   // 20
  25         5,  5,  5,  5,  8,  8,  8,  8,  7,  7,  7,  7,  11, 11, 11, 11,  // 30
  26         2,  2,  2,  2,  2,  2,  2,  2,  3,  3,  3,  3,  3,  3,  3,  3,   // 40
  27         3,  3,  3,  3,  3,  3,  3,  3,  4,  4,  4,  4,  4,  4,  4,  4,   // 50
  28         2,  2,  2,  2,  3,  3,  3,  3,  1,  1,  1,  1,  0,  0,  0,  0,   // 60
  29         1,  1,  1,  1,  2,  2,  2,  2,  1,  1,  1,  1,  2,  2,  2,  2,   // 70
  30         3,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,   // 80
  31         0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,   // 90
  32         2,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,   // a0
  33         0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,   // b0
  34         2,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,   // c0
  35         0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,   // d0
  36         0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,   // e0
  37         0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0    // f0
  38 };
  39 #endif
  40
  41 void update_texture_ptr(psx_gpu_struct *psx_gpu)
  42 {
  43   u8 *texture_base;
  44   u8 *texture_ptr;
  45
  46   switch((psx_gpu->render_state_base >> 8) & 0x3)
  47   {
  48     default:
  49     case TEXTURE_MODE_4BPP:
  50       texture_base = psx_gpu->texture_4bpp_cache[psx_gpu->current_texture_page];
  51
  52       texture_ptr = texture_base;
  53       texture_ptr += psx_gpu->texture_window_x & 0xF;
  54       texture_ptr += (psx_gpu->texture_window_y & 0xF) << 4;
  55       texture_ptr += (psx_gpu->texture_window_x >> 4) << 8;
  56       texture_ptr += (psx_gpu->texture_window_y >> 4) << 12;
  57       break;
  58
  59     case TEXTURE_MODE_8BPP:
  60       if(psx_gpu->current_texture_page & 0x1)
  61       {
  62         texture_base =
  63          psx_gpu->texture_8bpp_odd_cache[psx_gpu->current_texture_page >> 1];
  64       }
  65       else
  66       {
  67         texture_base =
  68          psx_gpu->texture_8bpp_even_cache[psx_gpu->current_texture_page >> 1];
  69       }
  70
  71       texture_ptr = texture_base;
  72       texture_ptr += psx_gpu->texture_window_x & 0xF;
  73       texture_ptr += (psx_gpu->texture_window_y & 0xF) << 4;
  74       texture_ptr += (psx_gpu->texture_window_x >> 4) << 8;
  75       texture_ptr += (psx_gpu->texture_window_y >> 4) << 12;
  76       break;
  77
  78     case TEXTURE_MODE_16BPP:
  79       texture_base = (u8 *)(psx_gpu->vram_ptr);
  80       texture_base += (psx_gpu->current_texture_page & 0xF) * 128;
  81       texture_base += ((psx_gpu->current_texture_page >> 4) * 256) * 2048;
  82
  83       texture_ptr = texture_base;
  84       texture_ptr += psx_gpu->texture_window_x * 2;
  85       texture_ptr += (psx_gpu->texture_window_y) * 2048;
  86       break;
  87   }
  88
  89   psx_gpu->texture_page_base = texture_base;
  90   psx_gpu->texture_page_ptr = texture_ptr;
  91 }
  92
  93 void set_texture(psx_gpu_struct *psx_gpu, u32 texture_settings)
  94 {
  95   texture_settings &= 0x1FF;
  96   if(psx_gpu->texture_settings != texture_settings)
  97   {
  98     u32 new_texture_page = texture_settings & 0x1F;
  99     u32 texture_mode = (texture_settings >> 7) & 0x3;
 100     u32 render_state_base = psx_gpu->render_state_base;
 101
 102     flush_render_block_buffer(psx_gpu);
 103
 104     render_state_base &= ~(0xF << 6);
 105     render_state_base |= ((texture_settings >> 5) & 0xF) << 6;
 106
 107     psx_gpu->render_state_base = render_state_base;
 108
 109     psx_gpu->current_texture_mask = 0x1 << new_texture_page;
 110
 111     if(texture_mode == TEXTURE_MODE_8BPP)
 112     {
 113       // In 8bpp mode 256x256 takes up two pages. If it's on the right edge it
 114       // wraps back around to the left edge.
 115       u32 adjacent_texture_page = ((texture_settings + 1) & 0xF) | (texture_settings & 0x10);
 116       psx_gpu->current_texture_mask |= 0x1 << adjacent_texture_page;
 117
 118       if((psx_gpu->last_8bpp_texture_page ^ new_texture_page) & 0x1)
 119       {
 120         u32 dirty_textures_8bpp_alternate_mask =
 121          psx_gpu->dirty_textures_8bpp_alternate_mask;
 122         psx_gpu->dirty_textures_8bpp_alternate_mask =
 123          psx_gpu->dirty_textures_8bpp_mask;
 124         psx_gpu->dirty_textures_8bpp_mask = dirty_textures_8bpp_alternate_mask;
 125       }
 126
 127       psx_gpu->last_8bpp_texture_page = new_texture_page;
 128     }
 129
 130     psx_gpu->current_texture_page = new_texture_page;
 131     psx_gpu->texture_settings = texture_settings;
 132
 133     update_texture_ptr(psx_gpu);
 134   }
 135 }
 136
 137 void set_clut(psx_gpu_struct *psx_gpu, u32 clut_settings)
 138 {
 139   if(psx_gpu->clut_settings != clut_settings)
 140   {
 141     flush_render_block_buffer(psx_gpu);
 142     psx_gpu->clut_settings = clut_settings;
 143     psx_gpu->clut_ptr = psx_gpu->vram_ptr + ((clut_settings & 0x7FFF) * 16);
 144   }
 145 }
 146
 147 void set_triangle_color(psx_gpu_struct *psx_gpu, u32 triangle_color)
 148 {
 149   if(psx_gpu->triangle_color != triangle_color)
 150   {
 151     flush_render_block_buffer(psx_gpu);
 152     psx_gpu->triangle_color = triangle_color;
 153   }
 154 }
 155
 156 static void do_fill(psx_gpu_struct *psx_gpu, u32 x, u32 y,
 157  u32 width, u32 height, u32 color)
 158 {
 159   x &= ~0xF;
 160   width = ((width + 0xF) & ~0xF);
 161
 162   flush_render_block_buffer(psx_gpu);
 163
 164   if(unlikely((x + width) > 1024))
 165   {
 166     u32 width_a = 1024 - x;
 167     u32 width_b = width - width_a;
 168
 169     if(unlikely((y + height) > 512))
 170     {
 171       u32 height_a = 512 - y;
 172       u32 height_b = height - height_a;
 173
 174       render_block_fill(psx_gpu, color, x, y, width_a, height_a);
 175       render_block_fill(psx_gpu, color, 0, y, width_b, height_a);
 176       render_block_fill(psx_gpu, color, x, 0, width_a, height_b);
 177       render_block_fill(psx_gpu, color, 0, 0, width_b, height_b);
 178     }
 179     else
 180     {
 181       render_block_fill(psx_gpu, color, x, y, width_a, height);
 182       render_block_fill(psx_gpu, color, 0, y, width_b, height);
 183     }
 184   }
 185   else
 186   {
 187     if(unlikely((y + height) > 512))
 188     {
 189       u32 height_a = 512 - y;
 190       u32 height_b = height - height_a;
 191
 192       render_block_fill(psx_gpu, color, x, y, width, height_a);
 193       render_block_fill(psx_gpu, color, x, 0, width, height_b);
 194     }
 195     else
 196     {
 197       render_block_fill(psx_gpu, color, x, y, width, height);
 198     }
 199   }
 200 }
 201
 202 #define sign_extend_12bit(value)                                               \
 203   (((s32)((value) << 20)) >> 20)                                               \
 204
 205 #define sign_extend_11bit(value)                                               \
 206   (((s32)((value) << 21)) >> 21)                                               \
 207
 208 #define sign_extend_10bit(value)                                               \
 209   (((s32)((value) << 22)) >> 22)                                               \
 210
 211
 212 #define get_vertex_data_xy(vertex_number, offset16)                            \
 213   vertexes[vertex_number].x =                                                  \
 214    sign_extend_12bit(list_s16[offset16]) + psx_gpu->offset_x;                  \
 215   vertexes[vertex_number].y =                                                  \
 216    sign_extend_12bit(list_s16[(offset16) + 1]) + psx_gpu->offset_y;            \
 217
 218 #define get_vertex_data_uv(vertex_number, offset16)                            \
 219   vertexes[vertex_number].u = list_s16[offset16] & 0xFF;                       \
 220   vertexes[vertex_number].v = (list_s16[offset16] >> 8) & 0xFF                 \
 221
 222 #define get_vertex_data_rgb(vertex_number, offset32)                           \
 223   vertexes[vertex_number].r = list[offset32] & 0xFF;                           \
 224   vertexes[vertex_number].g = (list[offset32] >> 8) & 0xFF;                    \
 225   vertexes[vertex_number].b = (list[offset32] >> 16) & 0xFF                    \
 226
 227 #define get_vertex_data_xy_uv(vertex_number, offset16)                         \
 228   get_vertex_data_xy(vertex_number, offset16);                                 \
 229   get_vertex_data_uv(vertex_number, (offset16) + 2)                            \
 230
 231 #define get_vertex_data_xy_rgb(vertex_number, offset16)                        \
 232   get_vertex_data_rgb(vertex_number, (offset16) / 2);                          \
 233   get_vertex_data_xy(vertex_number, (offset16) + 2);                           \
 234
 235 #define get_vertex_data_xy_uv_rgb(vertex_number, offset16)                     \
 236   get_vertex_data_rgb(vertex_number, (offset16) / 2);                          \
 237   get_vertex_data_xy(vertex_number, (offset16) + 2);                           \
 238   get_vertex_data_uv(vertex_number, (offset16) + 4);                           \
 239
 240 #define set_vertex_color_constant(vertex_number, color)                        \
 241   vertexes[vertex_number].r = color & 0xFF;                                    \
 242   vertexes[vertex_number].g = (color >> 8) & 0xFF;                             \
 243   vertexes[vertex_number].b = (color >> 16) & 0xFF                             \
 244
 245 #define get_vertex_data_xy_rgb_constant(vertex_number, offset16, color)        \
 246   get_vertex_data_xy(vertex_number, offset16);                                 \
 247   set_vertex_color_constant(vertex_number, color)                              \
 248
 249 #ifndef SET_Ex
 250 #define SET_Ex(r, v)
 251 #endif
 252
 253 vertex_struct vertexes[4] __attribute__((aligned(32)));
 254
 255 u32 gpu_parse(psx_gpu_struct *psx_gpu, u32 *list, u32 size, u32 *last_command)
 256 {
 257   u32 current_command = 0, command_length;
 258
 259   u32 *list_start = list;
 260   u32 *list_end = list + (size / 4);
 261
 262   for(; list < list_end; list += 1 + command_length)
 263   {
 264         s16 *list_s16 = (void *)list;
 265         current_command = *list >> 24;
 266         command_length = command_lengths[current_command];
 267         if (list + 1 + command_length > list_end) {
 268           current_command = (u32)-1;
 269           break;
 270         }
 271
 272         switch(current_command)
 273         {
 274                 case 0x00:
 275                         break;
 276
 277                 case 0x02:
 278       {
 279         u32 x = list_s16[2] & 0x3FF;
 280         u32 y = list_s16[3] & 0x1FF;
 281         u32 width = list_s16[4] & 0x3FF;
 282         u32 height = list_s16[5] & 0x1FF;
 283         u32 color = list[0] & 0xFFFFFF;
 284
 285         do_fill(psx_gpu, x, y, width, height, color);
 286                         break;
 287       }
 288
 289                 case 0x20 ... 0x23:
 290       {
 291         set_triangle_color(psx_gpu, list[0] & 0xFFFFFF);
 292
 293         get_vertex_data_xy(0, 2);
 294         get_vertex_data_xy(1, 4);
 295         get_vertex_data_xy(2, 6);
 296
 297         render_triangle(psx_gpu, vertexes, current_command);
 298                         break;
 299       }
 300
 301                 case 0x24 ... 0x27:
 302       {
 303         set_clut(psx_gpu, list_s16[5]);
 304         set_texture(psx_gpu, list_s16[9]);
 305         set_triangle_color(psx_gpu, list[0] & 0xFFFFFF);
 306
 307         get_vertex_data_xy_uv(0, 2);
 308         get_vertex_data_xy_uv(1, 6);
 309         get_vertex_data_xy_uv(2, 10);
 310
 311         render_triangle(psx_gpu, vertexes, current_command);
 312                         break;
 313       }
 314
 315                 case 0x28 ... 0x2B:
 316       {
 317         set_triangle_color(psx_gpu, list[0] & 0xFFFFFF);
 318
 319         get_vertex_data_xy(0, 2);
 320         get_vertex_data_xy(1, 4);
 321         get_vertex_data_xy(2, 6);
 322         get_vertex_data_xy(3, 8);
 323
 324         render_triangle(psx_gpu, vertexes, current_command);
 325         render_triangle(psx_gpu, &(vertexes[1]), current_command);
 326                         break;
 327       }
 328
 329                 case 0x2C ... 0x2F:
 330       {
 331         set_clut(psx_gpu, list_s16[5]);
 332         set_texture(psx_gpu, list_s16[9]);
 333         set_triangle_color(psx_gpu, list[0] & 0xFFFFFF);
 334
 335         get_vertex_data_xy_uv(0, 2);
 336         get_vertex_data_xy_uv(1, 6);
 337         get_vertex_data_xy_uv(2, 10);
 338         get_vertex_data_xy_uv(3, 14);
 339
 340         render_triangle(psx_gpu, vertexes, current_command);
 341         render_triangle(psx_gpu, &(vertexes[1]), current_command);
 342                         break;
 343       }
 344
 345                 case 0x30 ... 0x33:
 346       {
 347         get_vertex_data_xy_rgb(0, 0);
 348         get_vertex_data_xy_rgb(1, 4);
 349         get_vertex_data_xy_rgb(2, 8);
 350
 351         render_triangle(psx_gpu, vertexes, current_command);
 352                         break;
 353       }
 354
 355                 case 0x34:
 356                 case 0x35:
 357                 case 0x36:
 358                 case 0x37:
 359       {
 360         set_clut(psx_gpu, list_s16[5]);
 361         set_texture(psx_gpu, list_s16[11]);
 362
 363         get_vertex_data_xy_uv_rgb(0, 0);
 364         get_vertex_data_xy_uv_rgb(1, 6);
 365         get_vertex_data_xy_uv_rgb(2, 12);
 366
 367         render_triangle(psx_gpu, vertexes, current_command);
 368                         break;
 369       }
 370
 371                 case 0x38:
 372                 case 0x39:
 373                 case 0x3A:
 374                 case 0x3B:
 375       {
 376         get_vertex_data_xy_rgb(0, 0);
 377         get_vertex_data_xy_rgb(1, 4);
 378         get_vertex_data_xy_rgb(2, 8);
 379         get_vertex_data_xy_rgb(3, 12);
 380
 381         render_triangle(psx_gpu, vertexes, current_command);
 382         render_triangle(psx_gpu, &(vertexes[1]), current_command);
 383                         break;
 384       }
 385
 386                 case 0x3C:
 387                 case 0x3D:
 388                 case 0x3E:
 389                 case 0x3F:
 390       {
 391         set_clut(psx_gpu, list_s16[5]);
 392         set_texture(psx_gpu, list_s16[11]);
 393
 394         get_vertex_data_xy_uv_rgb(0, 0);
 395         get_vertex_data_xy_uv_rgb(1, 6);
 396         get_vertex_data_xy_uv_rgb(2, 12);
 397         get_vertex_data_xy_uv_rgb(3, 18);
 398
 399         render_triangle(psx_gpu, vertexes, current_command);
 400         render_triangle(psx_gpu, &(vertexes[1]), current_command);
 401                         break;
 402       }
 403
 404                 case 0x40 ... 0x47:
 405       {
 406         vertexes[0].x = list_s16[2] + psx_gpu->offset_x;
 407         vertexes[0].y = list_s16[3] + psx_gpu->offset_y;
 408         vertexes[1].x = list_s16[4] + psx_gpu->offset_x;
 409         vertexes[1].y = list_s16[5] + psx_gpu->offset_y;
 410
 411         render_line(psx_gpu, vertexes, current_command, list[0], 0);
 412                         break;
 413       }
 414
 415                 case 0x48 ... 0x4F:
 416       {
 417         u32 num_vertexes = 1;
 418         u32 *list_position = &(list[2]);
 419         u32 xy = list[1];
 420
 421         vertexes[1].x = (xy & 0xFFFF) + psx_gpu->offset_x;
 422         vertexes[1].y = (xy >> 16) + psx_gpu->offset_y;
 423
 424         xy = *list_position;
 425         while(1)
 426         {
 427           vertexes[0] = vertexes[1];
 428
 429           vertexes[1].x = (xy & 0xFFFF) + psx_gpu->offset_x;
 430           vertexes[1].y = (xy >> 16) + psx_gpu->offset_y;
 431
 432           render_line(psx_gpu, vertexes, current_command, list[0], 0);
 433
 434           list_position++;
 435           num_vertexes++;
 436
 437           if(list_position >= list_end)
 438             break;
 439
 440           xy = *list_position;
 441           if((xy & 0xF000F000) == 0x50005000)
 442             break;
 443         }
 444
 445         command_length += (num_vertexes - 2);
 446         break;
 447       }
 448
 449                 case 0x50 ... 0x57:
 450       {
 451         vertexes[0].r = list[0] & 0xFF;
 452         vertexes[0].g = (list[0] >> 8) & 0xFF;
 453         vertexes[0].b = (list[0] >> 16) & 0xFF;
 454         vertexes[0].x = list_s16[2] + psx_gpu->offset_x;
 455         vertexes[0].y = list_s16[3] + psx_gpu->offset_y;
 456
 457         vertexes[1].r = list[2] & 0xFF;
 458         vertexes[1].g = (list[2] >> 8) & 0xFF;
 459         vertexes[1].b = (list[2] >> 16) & 0xFF;
 460         vertexes[1].x = list_s16[6] + psx_gpu->offset_x;
 461         vertexes[1].y = list_s16[7] + psx_gpu->offset_y;
 462
 463         render_line(psx_gpu, vertexes, current_command, 0, 0);
 464                         break;
 465       }
 466
 467       case 0x58 ... 0x5F:
 468       {
 469         u32 num_vertexes = 1;
 470         u32 *list_position = &(list[2]);
 471         u32 color = list[0];
 472         u32 xy = list[1];
 473
 474         vertexes[1].r = color & 0xFF;
 475         vertexes[1].g = (color >> 8) & 0xFF;
 476         vertexes[1].b = (color >> 16) & 0xFF;
 477         vertexes[1].x = (xy & 0xFFFF) + psx_gpu->offset_x;
 478         vertexes[1].y = (xy >> 16) + psx_gpu->offset_y;
 479
 480         color = list_position[0];
 481         while(1)
 482         {
 483           xy = list_position[1];
 484
 485           vertexes[0] = vertexes[1];
 486
 487           vertexes[1].r = color & 0xFF;
 488           vertexes[1].g = (color >> 8) & 0xFF;
 489           vertexes[1].b = (color >> 16) & 0xFF;
 490           vertexes[1].x = (xy & 0xFFFF) + psx_gpu->offset_x;
 491           vertexes[1].y = (xy >> 16) + psx_gpu->offset_y;
 492
 493           render_line(psx_gpu, vertexes, current_command, 0, 0);
 494
 495           list_position += 2;
 496           num_vertexes++;
 497
 498           if(list_position >= list_end)
 499             break;
 500
 501           color = list_position[0];
 502           if((color & 0xF000F000) == 0x50005000)
 503             break;
 504         }
 505
 506         command_length += ((num_vertexes - 2) * 2);
 507         break;
 508       }
 509
 510                 case 0x60 ... 0x63:
 511       {
 512         u32 x = sign_extend_11bit(list_s16[2] + psx_gpu->offset_x);
 513         u32 y = sign_extend_11bit(list_s16[3] + psx_gpu->offset_y);
 514         u32 width = list_s16[4] & 0x3FF;
 515         u32 height = list_s16[5] & 0x1FF;
 516
 517         render_sprite(psx_gpu, x, y, 0, 0, width, height, current_command, list[0]);
 518                         break;
 519       }
 520
 521                 case 0x64 ... 0x67:
 522       {
 523         u32 x = sign_extend_11bit(list_s16[2] + psx_gpu->offset_x);
 524         u32 y = sign_extend_11bit(list_s16[3] + psx_gpu->offset_y);
 525         u32 uv = list_s16[4];
 526         u32 width = list_s16[6] & 0x3FF;
 527         u32 height = list_s16[7] & 0x1FF;
 528
 529         set_clut(psx_gpu, list_s16[5]);
 530
 531         render_sprite(psx_gpu, x, y, uv & 0xFF, (uv >> 8) & 0xFF, width, height,
 532          current_command, list[0]);
 533                         break;
 534       }
 535
 536                 case 0x68:
 537                 case 0x69:
 538                 case 0x6A:
 539                 case 0x6B:
 540       {
 541         s32 x = sign_extend_11bit(list_s16[2] + psx_gpu->offset_x);
 542         s32 y = sign_extend_11bit(list_s16[3] + psx_gpu->offset_y);
 543
 544         render_sprite(psx_gpu, x, y, 0, 0, 1, 1, current_command, list[0]);
 545                         break;
 546       }
 547
 548                 case 0x70:
 549                 case 0x71:
 550                 case 0x72:
 551                 case 0x73:
 552       {
 553         s32 x = sign_extend_11bit(list_s16[2] + psx_gpu->offset_x);
 554         s32 y = sign_extend_11bit(list_s16[3] + psx_gpu->offset_y);
 555
 556         render_sprite(psx_gpu, x, y, 0, 0, 8, 8, current_command, list[0]);
 557                         break;
 558       }
 559
 560                 case 0x74:
 561                 case 0x75:
 562                 case 0x76:
 563                 case 0x77:
 564       {
 565         s32 x = sign_extend_11bit(list_s16[2] + psx_gpu->offset_x);
 566         s32 y = sign_extend_11bit(list_s16[3] + psx_gpu->offset_y);
 567         u32 uv = list_s16[4];
 568
 569         set_clut(psx_gpu, list_s16[5]);
 570
 571         render_sprite(psx_gpu, x, y, uv & 0xFF, (uv >> 8) & 0xFF, 8, 8,
 572          current_command, list[0]);
 573                         break;
 574       }
 575
 576                 case 0x78:
 577                 case 0x79:
 578                 case 0x7A:
 579                 case 0x7B:
 580       {
 581         s32 x = sign_extend_11bit(list_s16[2] + psx_gpu->offset_x);
 582         s32 y = sign_extend_11bit(list_s16[3] + psx_gpu->offset_y);
 583
 584         render_sprite(psx_gpu, x, y, 0, 0, 16, 16, current_command, list[0]);
 585                         break;
 586       }
 587
 588                 case 0x7C:
 589                 case 0x7D:
 590                 case 0x7E:
 591                 case 0x7F:
 592       {
 593         s32 x = sign_extend_11bit(list_s16[2] + psx_gpu->offset_x);
 594         s32 y = sign_extend_11bit(list_s16[3] + psx_gpu->offset_y);
 595         u32 uv = list_s16[4];
 596
 597         set_clut(psx_gpu, list_s16[5]);
 598
 599         render_sprite(psx_gpu, x, y, uv & 0xFF, (uv >> 8) & 0xFF, 16, 16,
 600          current_command, list[0]);
 601                         break;
 602       }
 603
 604       case 0x80:          //  vid -> vid
 605       {
 606         u32 sx = list_s16[2] & 0x3FF;
 607         u32 sy = list_s16[3] & 0x1FF;
 608         u32 dx = list_s16[4] & 0x3FF;
 609         u32 dy = list_s16[5] & 0x1FF;
 610         u32 w = ((list_s16[6] - 1) & 0x3FF) + 1;
 611         u32 h = ((list_s16[7] - 1) & 0x1FF) + 1;
 612
 613         if (sx == dx && sy == dy && psx_gpu->mask_msb == 0)
 614           break;
 615
 616         render_block_move(psx_gpu, sx, sy, dx, dy, w, h);
 617         break;
 618       }
 619
 620 #ifdef PCSX
 621                 case 0xA0:          //  sys -> vid
 622                 case 0xC0:          //  vid -> sys
 623                         goto breakloop;
 624 #else
 625                 case 0xA0:          //  sys -> vid
 626       {
 627         u32 load_x = list_s16[2] & 0x3FF;
 628         u32 load_y = list_s16[3] & 0x1FF;
 629         u32 load_width = list_s16[4] & 0x3FF;
 630         u32 load_height = list_s16[5] & 0x1FF;
 631         u32 load_size = load_width * load_height;
 632
 633         command_length += load_size / 2;
 634
 635         if(load_size & 1)
 636           command_length++;
 637
 638         render_block_copy(psx_gpu, (u16 *)&(list_s16[6]), load_x, load_y,
 639          load_width, load_height, load_width);
 640                         break;
 641       }
 642
 643                 case 0xC0:          //  vid -> sys
 644                         break;
 645 #endif
 646
 647                 case 0xE1:
 648         set_texture(psx_gpu, list[0]);
 649
 650         if(list[0] & (1 << 9))
 651           psx_gpu->render_state_base |= RENDER_STATE_DITHER;
 652         else
 653           psx_gpu->render_state_base &= ~RENDER_STATE_DITHER;
 654
 655         psx_gpu->display_area_draw_enable = (list[0] >> 10) & 0x1;
 656                         SET_Ex(1, list[0]);
 657                         break;
 658
 659                 case 0xE2:
 660       {
 661         // TODO: Clean
 662         u32 texture_window_settings = list[0];
 663         u32 tmp, x, y, w, h;
 664
 665         if(texture_window_settings != psx_gpu->texture_window_settings)
 666         {
 667           tmp = (texture_window_settings & 0x1F) | 0x20;
 668           for(w = 8; (tmp & 1) == 0; tmp >>= 1, w <<= 1);
 669
 670           tmp = ((texture_window_settings >> 5) & 0x1f) | 0x20;
 671           for (h = 8; (tmp & 1) == 0; tmp >>= 1, h <<= 1);
 672
 673           tmp = 32 - (w >> 3);
 674           x = ((texture_window_settings >> 10) & tmp) << 3;
 675
 676           tmp = 32 - (h >> 3);
 677           y = ((texture_window_settings >> 15) & tmp) << 3;
 678
 679           flush_render_block_buffer(psx_gpu);
 680
 681           psx_gpu->texture_window_settings = texture_window_settings;
 682           psx_gpu->texture_window_x = x;
 683           psx_gpu->texture_window_y = y;
 684           psx_gpu->texture_mask_width = w - 1;
 685           psx_gpu->texture_mask_height = h - 1;
 686
 687           update_texture_ptr(psx_gpu);
 688         }
 689         SET_Ex(2, list[0]);
 690         break;
 691       }
 692
 693       case 0xE3:
 694       {
 695         s16 viewport_start_x = list[0] & 0x3FF;
 696         s16 viewport_start_y = (list[0] >> 10) & 0x1FF;
 697
 698         if(viewport_start_x == psx_gpu->viewport_start_x &&
 699          viewport_start_y == psx_gpu->viewport_start_y)
 700         {
 701           break;
 702         }
 703
 704         psx_gpu->viewport_start_x = viewport_start_x;
 705         psx_gpu->viewport_start_y = viewport_start_y;
 706
 707 #ifdef TEXTURE_CACHE_4BPP
 708         psx_gpu->viewport_mask =
 709          texture_region_mask(psx_gpu->viewport_start_x,
 710          psx_gpu->viewport_start_y, psx_gpu->viewport_end_x,
 711          psx_gpu->viewport_end_y);
 712 #endif
 713         SET_Ex(3, list[0]);
 714         break;
 715       }
 716
 717       case 0xE4:
 718       {
 719         s16 viewport_end_x = list[0] & 0x3FF;
 720         s16 viewport_end_y = (list[0] >> 10) & 0x1FF;
 721
 722         if(viewport_end_x == psx_gpu->viewport_end_x &&
 723          viewport_end_y == psx_gpu->viewport_end_y)
 724         {
 725           break;
 726         }
 727
 728         psx_gpu->viewport_end_x = viewport_end_x;
 729         psx_gpu->viewport_end_y = viewport_end_y;
 730
 731 #ifdef TEXTURE_CACHE_4BPP
 732         psx_gpu->viewport_mask =
 733          texture_region_mask(psx_gpu->viewport_start_x,
 734          psx_gpu->viewport_start_y, psx_gpu->viewport_end_x,
 735          psx_gpu->viewport_end_y);
 736 #endif
 737         SET_Ex(4, list[0]);
 738         break;
 739       }
 740
 741       case 0xE5:
 742       {
 743         s32 offset_x = list[0] << 21;
 744         s32 offset_y = list[0] << 10;
 745         psx_gpu->offset_x = offset_x >> 21;
 746         psx_gpu->offset_y = offset_y >> 21;
 747
 748                         SET_Ex(5, list[0]);
 749                         break;
 750                 }
 751
 752                 case 0xE6:
 753       {
 754         u32 mask_settings = list[0];
 755         u16 mask_msb = mask_settings << 15;
 756
 757         if(list[0] & 0x2)
 758           psx_gpu->render_state_base |= RENDER_STATE_MASK_EVALUATE;
 759         else
 760           psx_gpu->render_state_base &= ~RENDER_STATE_MASK_EVALUATE;
 761
 762         if(mask_msb != psx_gpu->mask_msb)
 763         {
 764           flush_render_block_buffer(psx_gpu);
 765           psx_gpu->mask_msb = mask_msb;
 766         }
 767
 768                         SET_Ex(6, list[0]);
 769                         break;
 770       }
 771
 772                 default:
 773                         break;
 774         }
 775   }
 776
 777 #ifdef PCSX
 778 breakloop:
 779 #endif
 780   if (last_command != NULL)
 781     *last_command = current_command;
 782   return list - list_start;
 783 }
 784
 785 #ifdef PCSX
 786
 787 #define ENH_BUF_TABLE_STEP (1024 / sizeof(psx_gpu->enhancement_buf_by_x16))
 788
 789 static void update_enhancement_buf_table_from_hres(psx_gpu_struct *psx_gpu)
 790 {
 791   u32 b, x, s;
 792
 793   b = 0;
 794   s = psx_gpu->enhancement_x_threshold;
 795   for (x = 0; x < sizeof(psx_gpu->enhancement_buf_by_x16); x++)
 796   {
 797     if (b < 3 && x * ENH_BUF_TABLE_STEP >= s - ENH_BUF_TABLE_STEP - 1)
 798     {
 799       s += psx_gpu->enhancement_x_threshold;
 800       b++;
 801     }
 802     psx_gpu->enhancement_buf_by_x16[x] = b;
 803   }
 804 }
 805
 806 static void update_enhancement_buf_table_from_x(psx_gpu_struct *psx_gpu,
 807  u32 x0, u32 len)
 808 {
 809   u32 x, b;
 810
 811   for (x = x0, b = 0; x >= len; b++)
 812     x -= len;
 813   if (b > 3)
 814     b = 3;
 815
 816   memset(psx_gpu->enhancement_buf_by_x16 + x0 / ENH_BUF_TABLE_STEP,
 817    b, (len + ENH_BUF_TABLE_STEP - 1) / ENH_BUF_TABLE_STEP);
 818 }
 819
 820 #define select_enhancement_buf(psx_gpu) \
 821   psx_gpu->enhancement_current_buf_ptr = \
 822     select_enhancement_buf_ptr(psx_gpu, psx_gpu->saved_viewport_start_x)
 823
 824 #define enhancement_disable() { \
 825   psx_gpu->vram_out_ptr = psx_gpu->vram_ptr; \
 826   psx_gpu->viewport_start_x = psx_gpu->saved_viewport_start_x; \
 827   psx_gpu->viewport_start_y = psx_gpu->saved_viewport_start_y; \
 828   psx_gpu->viewport_end_x = psx_gpu->saved_viewport_end_x; \
 829   psx_gpu->viewport_end_y = psx_gpu->saved_viewport_end_y; \
 830   psx_gpu->uvrgb_phase = 0x8000; \
 831 }
 832
 833 #define enhancement_enable() { \
 834   psx_gpu->vram_out_ptr = psx_gpu->enhancement_current_buf_ptr; \
 835   psx_gpu->viewport_start_x = psx_gpu->saved_viewport_start_x * 2; \
 836   psx_gpu->viewport_start_y = psx_gpu->saved_viewport_start_y * 2; \
 837   psx_gpu->viewport_end_x = psx_gpu->saved_viewport_end_x * 2 + 1; \
 838   psx_gpu->viewport_end_y = psx_gpu->saved_viewport_end_y * 2 + 1; \
 839   psx_gpu->uvrgb_phase = 0x1000; \
 840 }
 841
 842 #define shift_vertices3(v) { \
 843   v[0]->x *= 2; \
 844   v[0]->y *= 2; \
 845   v[1]->x *= 2; \
 846   v[1]->y *= 2; \
 847   v[2]->x *= 2; \
 848   v[2]->y *= 2; \
 849 }
 850
 851 #define unshift_vertices3(v) { \
 852   v[0]->x /= 2; \
 853   v[0]->y /= 2; \
 854   v[1]->x /= 2; \
 855   v[1]->y /= 2; \
 856   v[2]->x /= 2; \
 857   v[2]->y /= 2; \
 858 }
 859
 860 #define shift_triangle_area() \
 861   psx_gpu->triangle_area *= 4
 862
 863 extern void scale2x_tiles8(void *dst, const void *src, int w8, int h);
 864
 865 #ifndef NEON_BUILD
 866 // TODO?
 867 void scale2x_tiles8(void *dst, const void *src, int w8, int h) {}
 868 #endif
 869
 870 static int disable_main_render;
 871
 872 static void do_triangle_enhanced(psx_gpu_struct *psx_gpu,
 873  vertex_struct *vertexes, u32 current_command)
 874 {
 875   vertex_struct *vertex_ptrs[3];
 876
 877   if (!prepare_triangle(psx_gpu, vertexes, vertex_ptrs))
 878     return;
 879
 880   if (!disable_main_render)
 881     render_triangle_p(psx_gpu, vertex_ptrs, current_command);
 882
 883   enhancement_enable();
 884   shift_vertices3(vertex_ptrs);
 885   shift_triangle_area();
 886   render_triangle_p(psx_gpu, vertex_ptrs, current_command);
 887 }
 888
 889 static void do_quad_enhanced(psx_gpu_struct *psx_gpu, vertex_struct *vertexes,
 890  u32 current_command)
 891 {
 892   vertex_struct *vertex_ptrs[3];
 893
 894   if (prepare_triangle(psx_gpu, vertexes, vertex_ptrs)) {
 895     if (!disable_main_render)
 896       render_triangle_p(psx_gpu, vertex_ptrs, current_command);
 897
 898     enhancement_enable();
 899     shift_vertices3(vertex_ptrs);
 900     shift_triangle_area();
 901     render_triangle_p(psx_gpu, vertex_ptrs, current_command);
 902     unshift_vertices3(vertex_ptrs);
 903   }
 904   enhancement_disable();
 905   if (prepare_triangle(psx_gpu, &vertexes[1], vertex_ptrs)) {
 906     if (!disable_main_render)
 907       render_triangle_p(psx_gpu, vertex_ptrs, current_command);
 908
 909     enhancement_enable();
 910     shift_vertices3(vertex_ptrs);
 911     shift_triangle_area();
 912     render_triangle_p(psx_gpu, vertex_ptrs, current_command);
 913   }
 914 }
 915
 916 #if 0
 917
 918 #define fill_vertex(i, x_, y_, u_, v_, rgb_) \
 919   vertexes[i].x = x_; \
 920   vertexes[i].y = y_; \
 921   vertexes[i].u = u_; \
 922   vertexes[i].v = v_; \
 923   vertexes[i].r = rgb_; \
 924   vertexes[i].g = (rgb_) >> 8; \
 925   vertexes[i].b = (rgb_) >> 16
 926
 927 static void do_sprite_enhanced(psx_gpu_struct *psx_gpu, int x, int y,
 928  u32 u, u32 v, u32 w, u32 h, u32 cmd_rgb)
 929 {
 930   vertex_struct *vertex_ptrs[3];
 931   u32 flags = (cmd_rgb >> 24);
 932   u32 color = cmd_rgb & 0xffffff;
 933   u32 render_state_base_saved = psx_gpu->render_state_base;
 934   int x1, y1;
 935   u8 u1, v1;
 936
 937   flags &=
 938    (RENDER_FLAGS_MODULATE_TEXELS | RENDER_FLAGS_BLEND |
 939    RENDER_FLAGS_TEXTURE_MAP);
 940
 941   set_triangle_color(psx_gpu, color);
 942   if(color == 0x808080)
 943     flags |= RENDER_FLAGS_MODULATE_TEXELS;
 944
 945   psx_gpu->render_state_base &= ~RENDER_STATE_DITHER;
 946   enhancement_enable();
 947
 948   x1 = x + w;
 949   y1 = y + h;
 950   u1 = u + w;
 951   v1 = v + h;
 952   // FIXME..
 953   if (u1 < u) u1 = 0xff;
 954   if (v1 < v) v1 = 0xff;
 955
 956   // 0-2
 957   // |/
 958   // 1
 959   fill_vertex(0, x,  y,  u,  v,  color);
 960   fill_vertex(1, x,  y1, u,  v1, color);
 961   fill_vertex(2, x1, y,  u1, v,  color);
 962   if (prepare_triangle(psx_gpu, vertexes, vertex_ptrs)) {
 963     shift_vertices3(vertex_ptrs);
 964     shift_triangle_area();
 965     render_triangle_p(psx_gpu, vertex_ptrs, flags);
 966   }
 967
 968   //   0
 969   //  /|
 970   // 1-2
 971   fill_vertex(0, x1, y,  u1, v,  color);
 972   fill_vertex(1, x,  y1, u,  v1, color);
 973   fill_vertex(2, x1, y1, u1, v1, color);
 974   if (prepare_triangle(psx_gpu, vertexes, vertex_ptrs)) {
 975     shift_vertices3(vertex_ptrs);
 976     shift_triangle_area();
 977     render_triangle_p(psx_gpu, vertex_ptrs, flags);
 978   }
 979
 980   psx_gpu->render_state_base = render_state_base_saved;
 981 }
 982 #else
 983 static void do_sprite_enhanced(psx_gpu_struct *psx_gpu, int x, int y,
 984  u32 u, u32 v, u32 w, u32 h, u32 cmd_rgb)
 985 {
 986   u32 flags = (cmd_rgb >> 24);
 987   u32 color = cmd_rgb & 0xffffff;
 988
 989   render_sprite_4x(psx_gpu, x, y, u, v, w, h, flags, color);
 990 }
 991 #endif
 992
 993 u32 gpu_parse_enhanced(psx_gpu_struct *psx_gpu, u32 *list, u32 size,
 994  u32 *last_command)
 995 {
 996   u32 current_command = 0, command_length;
 997
 998   u32 *list_start = list;
 999   u32 *list_end = list + (size / 4);
1000
1001   psx_gpu->saved_viewport_start_x = psx_gpu->viewport_start_x;
1002   psx_gpu->saved_viewport_start_y = psx_gpu->viewport_start_y;
1003   psx_gpu->saved_viewport_end_x = psx_gpu->viewport_end_x;
1004   psx_gpu->saved_viewport_end_y = psx_gpu->viewport_end_y;
1005   select_enhancement_buf(psx_gpu);
1006
1007   for(; list < list_end; list += 1 + command_length)
1008   {
1009     s16 *list_s16 = (void *)list;
1010     current_command = *list >> 24;
1011     command_length = command_lengths[current_command];
1012     if (list + 1 + command_length > list_end) {
1013       current_command = (u32)-1;
1014       break;
1015     }
1016
1017     enhancement_disable();
1018
1019     switch(current_command)
1020     {
1021       case 0x00:
1022         break;
1023
1024       case 0x02:
1025       {
1026         u32 x = list_s16[2] & 0x3FF;
1027         u32 y = list_s16[3] & 0x1FF;
1028         u32 width = list_s16[4] & 0x3FF;
1029         u32 height = list_s16[5] & 0x1FF;
1030         u32 color = list[0] & 0xFFFFFF;
1031
1032         x &= ~0xF;
1033         width = ((width + 0xF) & ~0xF);
1034
1035         do_fill(psx_gpu, x, y, width, height, color);
1036
1037         psx_gpu->vram_out_ptr = select_enhancement_buf_ptr(psx_gpu, x);
1038         x *= 2;
1039         y *= 2;
1040         width *= 2;
1041         height *= 2;
1042         render_block_fill_enh(psx_gpu, color, x, y, width, height);
1043         break;
1044       }
1045
1046       case 0x20 ... 0x23:
1047       {
1048         set_triangle_color(psx_gpu, list[0] & 0xFFFFFF);
1049
1050         get_vertex_data_xy(0, 2);
1051         get_vertex_data_xy(1, 4);
1052         get_vertex_data_xy(2, 6);
1053
1054         do_triangle_enhanced(psx_gpu, vertexes, current_command);
1055         break;
1056       }
1057
1058       case 0x24 ... 0x27:
1059       {
1060         set_clut(psx_gpu, list_s16[5]);
1061         set_texture(psx_gpu, list_s16[9]);
1062         set_triangle_color(psx_gpu, list[0] & 0xFFFFFF);
1063
1064         get_vertex_data_xy_uv(0, 2);
1065         get_vertex_data_xy_uv(1, 6);
1066         get_vertex_data_xy_uv(2, 10);
1067
1068         do_triangle_enhanced(psx_gpu, vertexes, current_command);
1069         break;
1070       }
1071
1072       case 0x28 ... 0x2B:
1073       {
1074         set_triangle_color(psx_gpu, list[0] & 0xFFFFFF);
1075
1076         get_vertex_data_xy(0, 2);
1077         get_vertex_data_xy(1, 4);
1078         get_vertex_data_xy(2, 6);
1079         get_vertex_data_xy(3, 8);
1080
1081         do_quad_enhanced(psx_gpu, vertexes, current_command);
1082         break;
1083       }
1084
1085       case 0x2C ... 0x2F:
1086       {
1087         set_clut(psx_gpu, list_s16[5]);
1088         set_texture(psx_gpu, list_s16[9]);
1089         set_triangle_color(psx_gpu, list[0] & 0xFFFFFF);
1090
1091         get_vertex_data_xy_uv(0, 2);
1092         get_vertex_data_xy_uv(1, 6);
1093         get_vertex_data_xy_uv(2, 10);
1094         get_vertex_data_xy_uv(3, 14);
1095
1096         do_quad_enhanced(psx_gpu, vertexes, current_command);
1097         break;
1098       }
1099
1100       case 0x30 ... 0x33:
1101       {
1102         get_vertex_data_xy_rgb(0, 0);
1103         get_vertex_data_xy_rgb(1, 4);
1104         get_vertex_data_xy_rgb(2, 8);
1105
1106         do_triangle_enhanced(psx_gpu, vertexes, current_command);
1107         break;
1108       }
1109
1110       case 0x34:
1111       case 0x35:
1112       case 0x36:
1113       case 0x37:
1114       {
1115         set_clut(psx_gpu, list_s16[5]);
1116         set_texture(psx_gpu, list_s16[11]);
1117
1118         get_vertex_data_xy_uv_rgb(0, 0);
1119         get_vertex_data_xy_uv_rgb(1, 6);
1120         get_vertex_data_xy_uv_rgb(2, 12);
1121
1122         do_triangle_enhanced(psx_gpu, vertexes, current_command);
1123         break;
1124       }
1125
1126       case 0x38:
1127       case 0x39:
1128       case 0x3A:
1129       case 0x3B:
1130       {
1131         get_vertex_data_xy_rgb(0, 0);
1132         get_vertex_data_xy_rgb(1, 4);
1133         get_vertex_data_xy_rgb(2, 8);
1134         get_vertex_data_xy_rgb(3, 12);
1135
1136         do_quad_enhanced(psx_gpu, vertexes, current_command);
1137         break;
1138       }
1139
1140       case 0x3C:
1141       case 0x3D:
1142       case 0x3E:
1143       case 0x3F:
1144       {
1145         set_clut(psx_gpu, list_s16[5]);
1146         set_texture(psx_gpu, list_s16[11]);
1147
1148         get_vertex_data_xy_uv_rgb(0, 0);
1149         get_vertex_data_xy_uv_rgb(1, 6);
1150         get_vertex_data_xy_uv_rgb(2, 12);
1151         get_vertex_data_xy_uv_rgb(3, 18);
1152
1153         do_quad_enhanced(psx_gpu, vertexes, current_command);
1154         break;
1155       }
1156
1157       case 0x40 ... 0x47:
1158       {
1159         vertexes[0].x = list_s16[2] + psx_gpu->offset_x;
1160         vertexes[0].y = list_s16[3] + psx_gpu->offset_y;
1161         vertexes[1].x = list_s16[4] + psx_gpu->offset_x;
1162         vertexes[1].y = list_s16[5] + psx_gpu->offset_y;
1163
1164         render_line(psx_gpu, vertexes, current_command, list[0], 0);
1165         enhancement_enable();
1166         render_line(psx_gpu, vertexes, current_command, list[0], 1);
1167         break;
1168       }
1169
1170       case 0x48 ... 0x4F:
1171       {
1172         u32 num_vertexes = 1;
1173         u32 *list_position = &(list[2]);
1174         u32 xy = list[1];
1175
1176         vertexes[1].x = (xy & 0xFFFF) + psx_gpu->offset_x;
1177         vertexes[1].y = (xy >> 16) + psx_gpu->offset_y;
1178
1179         xy = *list_position;
1180         while(1)
1181         {
1182           vertexes[0] = vertexes[1];
1183
1184           vertexes[1].x = (xy & 0xFFFF) + psx_gpu->offset_x;
1185           vertexes[1].y = (xy >> 16) + psx_gpu->offset_y;
1186
1187           enhancement_disable();
1188           render_line(psx_gpu, vertexes, current_command, list[0], 0);
1189           enhancement_enable();
1190           render_line(psx_gpu, vertexes, current_command, list[0], 1);
1191
1192           list_position++;
1193           num_vertexes++;
1194
1195           if(list_position >= list_end)
1196             break;
1197
1198           xy = *list_position;
1199           if((xy & 0xF000F000) == 0x50005000)
1200             break;
1201         }
1202
1203         command_length += (num_vertexes - 2);
1204         break;
1205       }
1206
1207       case 0x50 ... 0x57:
1208       {
1209         vertexes[0].r = list[0] & 0xFF;
1210         vertexes[0].g = (list[0] >> 8) & 0xFF;
1211         vertexes[0].b = (list[0] >> 16) & 0xFF;
1212         vertexes[0].x = list_s16[2] + psx_gpu->offset_x;
1213         vertexes[0].y = list_s16[3] + psx_gpu->offset_y;
1214
1215         vertexes[1].r = list[2] & 0xFF;
1216         vertexes[1].g = (list[2] >> 8) & 0xFF;
1217         vertexes[1].b = (list[2] >> 16) & 0xFF;
1218         vertexes[1].x = list_s16[6] + psx_gpu->offset_x;
1219         vertexes[1].y = list_s16[7] + psx_gpu->offset_y;
1220
1221         render_line(psx_gpu, vertexes, current_command, 0, 0);
1222         enhancement_enable();
1223         render_line(psx_gpu, vertexes, current_command, 0, 1);
1224         break;
1225       }
1226
1227       case 0x58 ... 0x5F:
1228       {
1229         u32 num_vertexes = 1;
1230         u32 *list_position = &(list[2]);
1231         u32 color = list[0];
1232         u32 xy = list[1];
1233
1234         vertexes[1].r = color & 0xFF;
1235         vertexes[1].g = (color >> 8) & 0xFF;
1236         vertexes[1].b = (color >> 16) & 0xFF;
1237         vertexes[1].x = (xy & 0xFFFF) + psx_gpu->offset_x;
1238         vertexes[1].y = (xy >> 16) + psx_gpu->offset_y;
1239
1240         color = list_position[0];
1241         while(1)
1242         {
1243           xy = list_position[1];
1244
1245           vertexes[0] = vertexes[1];
1246
1247           vertexes[1].r = color & 0xFF;
1248           vertexes[1].g = (color >> 8) & 0xFF;
1249           vertexes[1].b = (color >> 16) & 0xFF;
1250           vertexes[1].x = (xy & 0xFFFF) + psx_gpu->offset_x;
1251           vertexes[1].y = (xy >> 16) + psx_gpu->offset_y;
1252
1253           enhancement_disable();
1254           render_line(psx_gpu, vertexes, current_command, 0, 0);
1255           enhancement_enable();
1256           render_line(psx_gpu, vertexes, current_command, 0, 1);
1257
1258           list_position += 2;
1259           num_vertexes++;
1260
1261           if(list_position >= list_end)
1262             break;
1263
1264           color = list_position[0];
1265           if((color & 0xF000F000) == 0x50005000)
1266             break;
1267         }
1268
1269         command_length += ((num_vertexes - 2) * 2);
1270         break;
1271       }
1272
1273       case 0x60 ... 0x63:
1274       {
1275         u32 x = sign_extend_11bit(list_s16[2] + psx_gpu->offset_x);
1276         u32 y = sign_extend_11bit(list_s16[3] + psx_gpu->offset_y);
1277         u32 width = list_s16[4] & 0x3FF;
1278         u32 height = list_s16[5] & 0x1FF;
1279
1280         render_sprite(psx_gpu, x, y, 0, 0, width, height, current_command, list[0]);
1281         do_sprite_enhanced(psx_gpu, x, y, 0, 0, width, height, list[0]);
1282         break;
1283       }
1284
1285       case 0x64 ... 0x67:
1286       {
1287         u32 x = sign_extend_11bit(list_s16[2] + psx_gpu->offset_x);
1288         u32 y = sign_extend_11bit(list_s16[3] + psx_gpu->offset_y);
1289         u8 u = list_s16[4];
1290         u8 v = list_s16[4] >> 8;
1291         u32 width = list_s16[6] & 0x3FF;
1292         u32 height = list_s16[7] & 0x1FF;
1293
1294         set_clut(psx_gpu, list_s16[5]);
1295
1296         render_sprite(psx_gpu, x, y, u, v, width, height,
1297          current_command, list[0]);
1298         do_sprite_enhanced(psx_gpu, x, y, u, v, width, height, list[0]);
1299         break;
1300       }
1301
1302       case 0x68:
1303       case 0x69:
1304       case 0x6A:
1305       case 0x6B:
1306       {
1307         s32 x = sign_extend_11bit(list_s16[2] + psx_gpu->offset_x);
1308         s32 y = sign_extend_11bit(list_s16[3] + psx_gpu->offset_y);
1309
1310         render_sprite(psx_gpu, x, y, 0, 0, 1, 1, current_command, list[0]);
1311         do_sprite_enhanced(psx_gpu, x, y, 0, 0, 1, 1, list[0]);
1312         break;
1313       }
1314
1315       case 0x70:
1316       case 0x71:
1317       case 0x72:
1318       case 0x73:
1319       {
1320         s32 x = sign_extend_11bit(list_s16[2] + psx_gpu->offset_x);
1321         s32 y = sign_extend_11bit(list_s16[3] + psx_gpu->offset_y);
1322
1323         render_sprite(psx_gpu, x, y, 0, 0, 8, 8, current_command, list[0]);
1324         do_sprite_enhanced(psx_gpu, x, y, 0, 0, 8, 8, list[0]);
1325         break;
1326       }
1327
1328       case 0x74:
1329       case 0x75:
1330       case 0x76:
1331       case 0x77:
1332       {
1333         s32 x = sign_extend_11bit(list_s16[2] + psx_gpu->offset_x);
1334         s32 y = sign_extend_11bit(list_s16[3] + psx_gpu->offset_y);
1335         u8 u = list_s16[4];
1336         u8 v = list_s16[4] >> 8;
1337
1338         set_clut(psx_gpu, list_s16[5]);
1339
1340         render_sprite(psx_gpu, x, y, u, v, 8, 8,
1341          current_command, list[0]);
1342         do_sprite_enhanced(psx_gpu, x, y, u, v, 8, 8, list[0]);
1343         break;
1344       }
1345
1346       case 0x78:
1347       case 0x79:
1348       case 0x7A:
1349       case 0x7B:
1350       {
1351         s32 x = sign_extend_11bit(list_s16[2] + psx_gpu->offset_x);
1352         s32 y = sign_extend_11bit(list_s16[3] + psx_gpu->offset_y);
1353
1354         render_sprite(psx_gpu, x, y, 0, 0, 16, 16, current_command, list[0]);
1355         do_sprite_enhanced(psx_gpu, x, y, 0, 0, 16, 16, list[0]);
1356         break;
1357       }
1358
1359       case 0x7C:
1360       case 0x7D:
1361       case 0x7E:
1362       case 0x7F:
1363       {
1364         s32 x = sign_extend_11bit(list_s16[2] + psx_gpu->offset_x);
1365         s32 y = sign_extend_11bit(list_s16[3] + psx_gpu->offset_y);
1366         u8 u = list_s16[4];
1367         u8 v = list_s16[4] >> 8;
1368
1369         set_clut(psx_gpu, list_s16[5]);
1370
1371         render_sprite(psx_gpu, x, y, u, v, 16, 16, current_command, list[0]);
1372         do_sprite_enhanced(psx_gpu, x, y, u, v, 16, 16, list[0]);
1373         break;
1374       }
1375
1376       case 0x80:          //  vid -> vid
1377       {
1378         u32 sx = list_s16[2] & 0x3FF;
1379         u32 sy = list_s16[3] & 0x1FF;
1380         u32 dx = list_s16[4] & 0x3FF;
1381         u32 dy = list_s16[5] & 0x1FF;
1382         u32 w = ((list_s16[6] - 1) & 0x3FF) + 1;
1383         u32 h = ((list_s16[7] - 1) & 0x1FF) + 1;
1384         u16 *buf;
1385
1386         if (sx == dx && sy == dy && psx_gpu->mask_msb == 0)
1387           break;
1388
1389         render_block_move(psx_gpu, sx, sy, dx, dy, w, h);
1390         if (dy + h > 512)
1391           h = 512 - dy;
1392         sx = sx & ~7; // FIXME?
1393         dx = dx * 2 & ~7;
1394         dy *= 2;
1395         w = (w + 7) / 8;
1396         buf = select_enhancement_buf_ptr(psx_gpu, dx / 2);
1397         scale2x_tiles8(buf + dy * 1024 + dx,
1398           psx_gpu->vram_ptr + sy * 1024 + sx, w, h);
1399         break;
1400       }
1401
1402       case 0xA0:          //  sys -> vid
1403       case 0xC0:          //  vid -> sys
1404         goto breakloop;
1405
1406       case 0xE1:
1407         set_texture(psx_gpu, list[0]);
1408
1409         if(list[0] & (1 << 9))
1410           psx_gpu->render_state_base |= RENDER_STATE_DITHER;
1411         else
1412           psx_gpu->render_state_base &= ~RENDER_STATE_DITHER;
1413
1414         psx_gpu->display_area_draw_enable = (list[0] >> 10) & 0x1;
1415         SET_Ex(1, list[0]);
1416         break;
1417
1418       case 0xE2:
1419       {
1420         // TODO: Clean
1421         u32 texture_window_settings = list[0];
1422         u32 tmp, x, y, w, h;
1423
1424         if(texture_window_settings != psx_gpu->texture_window_settings)
1425         {
1426           tmp = (texture_window_settings & 0x1F) | 0x20;
1427           for(w = 8; (tmp & 1) == 0; tmp >>= 1, w <<= 1);
1428
1429           tmp = ((texture_window_settings >> 5) & 0x1f) | 0x20;
1430           for (h = 8; (tmp & 1) == 0; tmp >>= 1, h <<= 1);
1431
1432           tmp = 32 - (w >> 3);
1433           x = ((texture_window_settings >> 10) & tmp) << 3;
1434
1435           tmp = 32 - (h >> 3);
1436           y = ((texture_window_settings >> 15) & tmp) << 3;
1437
1438           flush_render_block_buffer(psx_gpu);
1439
1440           psx_gpu->texture_window_settings = texture_window_settings;
1441           psx_gpu->texture_window_x = x;
1442           psx_gpu->texture_window_y = y;
1443           psx_gpu->texture_mask_width = w - 1;
1444           psx_gpu->texture_mask_height = h - 1;
1445
1446           update_texture_ptr(psx_gpu);
1447         }
1448         SET_Ex(2, list[0]);
1449         break;
1450       }
1451
1452       case 0xE3:
1453       {
1454         s16 viewport_start_x = list[0] & 0x3FF;
1455         s16 viewport_start_y = (list[0] >> 10) & 0x1FF;
1456         u32 w;
1457         s32 d;
1458
1459         if(viewport_start_x == psx_gpu->viewport_start_x &&
1460          viewport_start_y == psx_gpu->viewport_start_y)
1461         {
1462           break;
1463         }
1464         psx_gpu->viewport_start_x = viewport_start_x;
1465         psx_gpu->viewport_start_y = viewport_start_y;
1466         psx_gpu->saved_viewport_start_x = viewport_start_x;
1467         psx_gpu->saved_viewport_start_y = viewport_start_y;
1468
1469         w = (u32)psx_gpu->viewport_end_x - (u32)viewport_start_x + 1;
1470         d = psx_gpu->enhancement_x_threshold - w;
1471         if(-16 <= d && d <= 16)
1472         {
1473           update_enhancement_buf_table_from_x(psx_gpu,
1474            viewport_start_x, w);
1475         }
1476         select_enhancement_buf(psx_gpu);
1477
1478 #ifdef TEXTURE_CACHE_4BPP
1479         psx_gpu->viewport_mask =
1480          texture_region_mask(psx_gpu->viewport_start_x,
1481          psx_gpu->viewport_start_y, psx_gpu->viewport_end_x,
1482          psx_gpu->viewport_end_y);
1483 #endif
1484         SET_Ex(3, list[0]);
1485         break;
1486       }
1487
1488       case 0xE4:
1489       {
1490         s16 viewport_end_x = list[0] & 0x3FF;
1491         s16 viewport_end_y = (list[0] >> 10) & 0x1FF;
1492         u32 w;
1493         s32 d;
1494
1495         if(viewport_end_x == psx_gpu->viewport_end_x &&
1496          viewport_end_y == psx_gpu->viewport_end_y)
1497         {
1498           break;
1499         }
1500
1501         psx_gpu->viewport_end_x = viewport_end_x;
1502         psx_gpu->viewport_end_y = viewport_end_y;
1503         psx_gpu->saved_viewport_end_x = viewport_end_x;
1504         psx_gpu->saved_viewport_end_y = viewport_end_y;
1505
1506         w = (u32)viewport_end_x - (u32)psx_gpu->viewport_start_x + 1;
1507         d = psx_gpu->enhancement_x_threshold - w;
1508         if(-16 <= d && d <= 16)
1509         {
1510           update_enhancement_buf_table_from_x(psx_gpu,
1511            psx_gpu->viewport_start_x, w);
1512         }
1513         select_enhancement_buf(psx_gpu);
1514
1515 #ifdef TEXTURE_CACHE_4BPP
1516         psx_gpu->viewport_mask =
1517          texture_region_mask(psx_gpu->viewport_start_x,
1518          psx_gpu->viewport_start_y, psx_gpu->viewport_end_x,
1519          psx_gpu->viewport_end_y);
1520 #endif
1521         SET_Ex(4, list[0]);
1522         break;
1523       }
1524
1525       case 0xE5:
1526       {
1527         s32 offset_x = list[0] << 21;
1528         s32 offset_y = list[0] << 10;
1529         psx_gpu->offset_x = offset_x >> 21;
1530         psx_gpu->offset_y = offset_y >> 21;
1531
1532         SET_Ex(5, list[0]);
1533         break;
1534       }
1535
1536       case 0xE6:
1537       {
1538         u32 mask_settings = list[0];
1539         u16 mask_msb = mask_settings << 15;
1540
1541         if(list[0] & 0x2)
1542           psx_gpu->render_state_base |= RENDER_STATE_MASK_EVALUATE;
1543         else
1544           psx_gpu->render_state_base &= ~RENDER_STATE_MASK_EVALUATE;
1545
1546         if(mask_msb != psx_gpu->mask_msb)
1547         {
1548           flush_render_block_buffer(psx_gpu);
1549           psx_gpu->mask_msb = mask_msb;
1550         }
1551
1552         SET_Ex(6, list[0]);
1553         break;
1554       }
1555
1556       default:
1557         break;
1558     }
1559   }
1560
1561   enhancement_disable();
1562
1563 breakloop:
1564   if (last_command != NULL)
1565     *last_command = current_command;
1566   return list - list_start;
1567 }
1568
1569 #endif /* PCSX */
1570
1571 // vim:shiftwidth=2:expandtab