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     case TEXTURE_MODE_4BPP:
  49       texture_base = psx_gpu->texture_4bpp_cache[psx_gpu->current_texture_page];
  50
  51       texture_ptr = texture_base;
  52       texture_ptr += psx_gpu->texture_window_x & 0xF;
  53       texture_ptr += (psx_gpu->texture_window_y & 0xF) << 4;
  54       texture_ptr += (psx_gpu->texture_window_x >> 4) << 8;
  55       texture_ptr += (psx_gpu->texture_window_y >> 4) << 12;
  56       break;
  57
  58     case TEXTURE_MODE_8BPP:
  59       if(psx_gpu->current_texture_page & 0x1)
  60       {
  61         texture_base =
  62          psx_gpu->texture_8bpp_odd_cache[psx_gpu->current_texture_page >> 1];
  63       }
  64       else
  65       {
  66         texture_base =
  67          psx_gpu->texture_8bpp_even_cache[psx_gpu->current_texture_page >> 1];
  68       }
  69
  70       texture_ptr = texture_base;
  71       texture_ptr += psx_gpu->texture_window_x & 0xF;
  72       texture_ptr += (psx_gpu->texture_window_y & 0xF) << 4;
  73       texture_ptr += (psx_gpu->texture_window_x >> 4) << 8;
  74       texture_ptr += (psx_gpu->texture_window_y >> 4) << 12;
  75       break;
  76
  77     default:
  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           {
 439             current_command = (u32)-1;
 440             goto breakloop;
 441           }
 442
 443           xy = *list_position;
 444           if((xy & 0xF000F000) == 0x50005000)
 445             break;
 446         }
 447
 448         command_length += (num_vertexes - 2);
 449         break;
 450       }
 451
 452                 case 0x50 ... 0x57:
 453       {
 454         vertexes[0].r = list[0] & 0xFF;
 455         vertexes[0].g = (list[0] >> 8) & 0xFF;
 456         vertexes[0].b = (list[0] >> 16) & 0xFF;
 457         vertexes[0].x = list_s16[2] + psx_gpu->offset_x;
 458         vertexes[0].y = list_s16[3] + psx_gpu->offset_y;
 459
 460         vertexes[1].r = list[2] & 0xFF;
 461         vertexes[1].g = (list[2] >> 8) & 0xFF;
 462         vertexes[1].b = (list[2] >> 16) & 0xFF;
 463         vertexes[1].x = list_s16[6] + psx_gpu->offset_x;
 464         vertexes[1].y = list_s16[7] + psx_gpu->offset_y;
 465
 466         render_line(psx_gpu, vertexes, current_command, 0, 0);
 467                         break;
 468       }
 469
 470       case 0x58 ... 0x5F:
 471       {
 472         u32 num_vertexes = 1;
 473         u32 *list_position = &(list[2]);
 474         u32 color = list[0];
 475         u32 xy = list[1];
 476
 477         vertexes[1].r = color & 0xFF;
 478         vertexes[1].g = (color >> 8) & 0xFF;
 479         vertexes[1].b = (color >> 16) & 0xFF;
 480         vertexes[1].x = (xy & 0xFFFF) + psx_gpu->offset_x;
 481         vertexes[1].y = (xy >> 16) + psx_gpu->offset_y;
 482
 483         color = list_position[0];
 484         while(1)
 485         {
 486           xy = list_position[1];
 487
 488           vertexes[0] = vertexes[1];
 489
 490           vertexes[1].r = color & 0xFF;
 491           vertexes[1].g = (color >> 8) & 0xFF;
 492           vertexes[1].b = (color >> 16) & 0xFF;
 493           vertexes[1].x = (xy & 0xFFFF) + psx_gpu->offset_x;
 494           vertexes[1].y = (xy >> 16) + psx_gpu->offset_y;
 495
 496           render_line(psx_gpu, vertexes, current_command, 0, 0);
 497
 498           list_position += 2;
 499           num_vertexes++;
 500
 501           if(list_position >= list_end)
 502           {
 503             current_command = (u32)-1;
 504             goto breakloop;
 505           }
 506
 507           color = list_position[0];
 508           if((color & 0xF000F000) == 0x50005000)
 509             break;
 510         }
 511
 512         command_length += ((num_vertexes - 2) * 2);
 513         break;
 514       }
 515
 516                 case 0x60 ... 0x63:
 517       {
 518         u32 x = sign_extend_11bit(list_s16[2] + psx_gpu->offset_x);
 519         u32 y = sign_extend_11bit(list_s16[3] + psx_gpu->offset_y);
 520         u32 width = list_s16[4] & 0x3FF;
 521         u32 height = list_s16[5] & 0x1FF;
 522
 523         render_sprite(psx_gpu, x, y, 0, 0, width, height, current_command, list[0]);
 524                         break;
 525       }
 526
 527                 case 0x64 ... 0x67:
 528       {
 529         u32 x = sign_extend_11bit(list_s16[2] + psx_gpu->offset_x);
 530         u32 y = sign_extend_11bit(list_s16[3] + psx_gpu->offset_y);
 531         u32 uv = list_s16[4];
 532         u32 width = list_s16[6] & 0x3FF;
 533         u32 height = list_s16[7] & 0x1FF;
 534
 535         set_clut(psx_gpu, list_s16[5]);
 536
 537         render_sprite(psx_gpu, x, y, uv & 0xFF, (uv >> 8) & 0xFF, width, height,
 538          current_command, list[0]);
 539                         break;
 540       }
 541
 542                 case 0x68:
 543                 case 0x69:
 544                 case 0x6A:
 545                 case 0x6B:
 546       {
 547         s32 x = sign_extend_11bit(list_s16[2] + psx_gpu->offset_x);
 548         s32 y = sign_extend_11bit(list_s16[3] + psx_gpu->offset_y);
 549
 550         render_sprite(psx_gpu, x, y, 0, 0, 1, 1, current_command, list[0]);
 551                         break;
 552       }
 553
 554                 case 0x70:
 555                 case 0x71:
 556                 case 0x72:
 557                 case 0x73:
 558       {
 559         s32 x = sign_extend_11bit(list_s16[2] + psx_gpu->offset_x);
 560         s32 y = sign_extend_11bit(list_s16[3] + psx_gpu->offset_y);
 561
 562         render_sprite(psx_gpu, x, y, 0, 0, 8, 8, current_command, list[0]);
 563                         break;
 564       }
 565
 566                 case 0x74:
 567                 case 0x75:
 568                 case 0x76:
 569                 case 0x77:
 570       {
 571         s32 x = sign_extend_11bit(list_s16[2] + psx_gpu->offset_x);
 572         s32 y = sign_extend_11bit(list_s16[3] + psx_gpu->offset_y);
 573         u32 uv = list_s16[4];
 574
 575         set_clut(psx_gpu, list_s16[5]);
 576
 577         render_sprite(psx_gpu, x, y, uv & 0xFF, (uv >> 8) & 0xFF, 8, 8,
 578          current_command, list[0]);
 579                         break;
 580       }
 581
 582                 case 0x78:
 583                 case 0x79:
 584                 case 0x7A:
 585                 case 0x7B:
 586       {
 587         s32 x = sign_extend_11bit(list_s16[2] + psx_gpu->offset_x);
 588         s32 y = sign_extend_11bit(list_s16[3] + psx_gpu->offset_y);
 589
 590         render_sprite(psx_gpu, x, y, 0, 0, 16, 16, current_command, list[0]);
 591                         break;
 592       }
 593
 594                 case 0x7C:
 595                 case 0x7D:
 596                 case 0x7E:
 597                 case 0x7F:
 598       {
 599         s32 x = sign_extend_11bit(list_s16[2] + psx_gpu->offset_x);
 600         s32 y = sign_extend_11bit(list_s16[3] + psx_gpu->offset_y);
 601         u32 uv = list_s16[4];
 602
 603         set_clut(psx_gpu, list_s16[5]);
 604
 605         render_sprite(psx_gpu, x, y, uv & 0xFF, (uv >> 8) & 0xFF, 16, 16,
 606          current_command, list[0]);
 607                         break;
 608       }
 609
 610       case 0x80:          //  vid -> vid
 611       {
 612         u32 sx = list_s16[2] & 0x3FF;
 613         u32 sy = list_s16[3] & 0x1FF;
 614         u32 dx = list_s16[4] & 0x3FF;
 615         u32 dy = list_s16[5] & 0x1FF;
 616         u32 w = ((list_s16[6] - 1) & 0x3FF) + 1;
 617         u32 h = ((list_s16[7] - 1) & 0x1FF) + 1;
 618
 619         if (sx == dx && sy == dy && psx_gpu->mask_msb == 0)
 620           break;
 621
 622         render_block_move(psx_gpu, sx, sy, dx, dy, w, h);
 623         break;
 624       }
 625
 626 #ifdef PCSX
 627                 case 0xA0:          //  sys -> vid
 628                 case 0xC0:          //  vid -> sys
 629                         goto breakloop;
 630 #else
 631                 case 0xA0:          //  sys -> vid
 632       {
 633         u32 load_x = list_s16[2] & 0x3FF;
 634         u32 load_y = list_s16[3] & 0x1FF;
 635         u32 load_width = list_s16[4] & 0x3FF;
 636         u32 load_height = list_s16[5] & 0x1FF;
 637         u32 load_size = load_width * load_height;
 638
 639         command_length += load_size / 2;
 640
 641         if(load_size & 1)
 642           command_length++;
 643
 644         render_block_copy(psx_gpu, (u16 *)&(list_s16[6]), load_x, load_y,
 645          load_width, load_height, load_width);
 646                         break;
 647       }
 648
 649                 case 0xC0:          //  vid -> sys
 650                         break;
 651 #endif
 652
 653                 case 0xE1:
 654         set_texture(psx_gpu, list[0]);
 655
 656         if(list[0] & (1 << 9))
 657           psx_gpu->render_state_base |= RENDER_STATE_DITHER;
 658         else
 659           psx_gpu->render_state_base &= ~RENDER_STATE_DITHER;
 660
 661         psx_gpu->display_area_draw_enable = (list[0] >> 10) & 0x1;
 662                         SET_Ex(1, list[0]);
 663                         break;
 664
 665                 case 0xE2:
 666       {
 667         // TODO: Clean
 668         u32 texture_window_settings = list[0];
 669         u32 tmp, x, y, w, h;
 670
 671         if(texture_window_settings != psx_gpu->texture_window_settings)
 672         {
 673           tmp = (texture_window_settings & 0x1F) | 0x20;
 674           for(w = 8; (tmp & 1) == 0; tmp >>= 1, w <<= 1);
 675
 676           tmp = ((texture_window_settings >> 5) & 0x1f) | 0x20;
 677           for (h = 8; (tmp & 1) == 0; tmp >>= 1, h <<= 1);
 678
 679           tmp = 32 - (w >> 3);
 680           x = ((texture_window_settings >> 10) & tmp) << 3;
 681
 682           tmp = 32 - (h >> 3);
 683           y = ((texture_window_settings >> 15) & tmp) << 3;
 684
 685           flush_render_block_buffer(psx_gpu);
 686
 687           psx_gpu->texture_window_settings = texture_window_settings;
 688           psx_gpu->texture_window_x = x;
 689           psx_gpu->texture_window_y = y;
 690           psx_gpu->texture_mask_width = w - 1;
 691           psx_gpu->texture_mask_height = h - 1;
 692
 693           update_texture_ptr(psx_gpu);
 694         }
 695         SET_Ex(2, list[0]);
 696         break;
 697       }
 698
 699       case 0xE3:
 700       {
 701         s16 viewport_start_x = list[0] & 0x3FF;
 702         s16 viewport_start_y = (list[0] >> 10) & 0x1FF;
 703
 704         if(viewport_start_x == psx_gpu->viewport_start_x &&
 705          viewport_start_y == psx_gpu->viewport_start_y)
 706         {
 707           break;
 708         }
 709
 710         psx_gpu->viewport_start_x = viewport_start_x;
 711         psx_gpu->viewport_start_y = viewport_start_y;
 712
 713 #ifdef TEXTURE_CACHE_4BPP
 714         psx_gpu->viewport_mask =
 715          texture_region_mask(psx_gpu->viewport_start_x,
 716          psx_gpu->viewport_start_y, psx_gpu->viewport_end_x,
 717          psx_gpu->viewport_end_y);
 718 #endif
 719         SET_Ex(3, list[0]);
 720         break;
 721       }
 722
 723       case 0xE4:
 724       {
 725         s16 viewport_end_x = list[0] & 0x3FF;
 726         s16 viewport_end_y = (list[0] >> 10) & 0x1FF;
 727
 728         if(viewport_end_x == psx_gpu->viewport_end_x &&
 729          viewport_end_y == psx_gpu->viewport_end_y)
 730         {
 731           break;
 732         }
 733
 734         psx_gpu->viewport_end_x = viewport_end_x;
 735         psx_gpu->viewport_end_y = viewport_end_y;
 736
 737 #ifdef TEXTURE_CACHE_4BPP
 738         psx_gpu->viewport_mask =
 739          texture_region_mask(psx_gpu->viewport_start_x,
 740          psx_gpu->viewport_start_y, psx_gpu->viewport_end_x,
 741          psx_gpu->viewport_end_y);
 742 #endif
 743         SET_Ex(4, list[0]);
 744         break;
 745       }
 746
 747       case 0xE5:
 748       {
 749         s32 offset_x = list[0] << 21;
 750         s32 offset_y = list[0] << 10;
 751         psx_gpu->offset_x = offset_x >> 21;
 752         psx_gpu->offset_y = offset_y >> 21;
 753
 754                         SET_Ex(5, list[0]);
 755                         break;
 756                 }
 757
 758                 case 0xE6:
 759       {
 760         u32 mask_settings = list[0];
 761         u16 mask_msb = mask_settings << 15;
 762
 763         if(list[0] & 0x2)
 764           psx_gpu->render_state_base |= RENDER_STATE_MASK_EVALUATE;
 765         else
 766           psx_gpu->render_state_base &= ~RENDER_STATE_MASK_EVALUATE;
 767
 768         if(mask_msb != psx_gpu->mask_msb)
 769         {
 770           flush_render_block_buffer(psx_gpu);
 771           psx_gpu->mask_msb = mask_msb;
 772         }
 773
 774                         SET_Ex(6, list[0]);
 775                         break;
 776       }
 777
 778                 default:
 779                         break;
 780         }
 781   }
 782
 783 breakloop:
 784   if (last_command != NULL)
 785     *last_command = current_command;
 786   return list - list_start;
 787 }
 788
 789 #ifdef PCSX
 790
 791 #define ENH_BUF_TABLE_STEP (1024 / sizeof(psx_gpu->enhancement_buf_by_x16))
 792
 793 static void update_enhancement_buf_table_from_hres(psx_gpu_struct *psx_gpu)
 794 {
 795   u32 b, x, s;
 796
 797   b = 0;
 798   s = psx_gpu->enhancement_x_threshold;
 799   for (x = 0; x < sizeof(psx_gpu->enhancement_buf_by_x16); x++)
 800   {
 801     if (b < 3 && x * ENH_BUF_TABLE_STEP >= s - ENH_BUF_TABLE_STEP - 1)
 802     {
 803       s += psx_gpu->enhancement_x_threshold;
 804       b++;
 805     }
 806     psx_gpu->enhancement_buf_by_x16[x] = b;
 807   }
 808 }
 809
 810 static void update_enhancement_buf_table_from_x(psx_gpu_struct *psx_gpu,
 811  u32 x0, u32 len)
 812 {
 813   u32 x, b;
 814
 815   for (x = x0, b = 0; x >= len; b++)
 816     x -= len;
 817   if (b > 3)
 818     b = 3;
 819
 820   memset(psx_gpu->enhancement_buf_by_x16 + x0 / ENH_BUF_TABLE_STEP,
 821    b, (len + ENH_BUF_TABLE_STEP - 1) / ENH_BUF_TABLE_STEP);
 822 }
 823
 824 #define select_enhancement_buf(psx_gpu) \
 825   psx_gpu->enhancement_current_buf_ptr = \
 826     select_enhancement_buf_ptr(psx_gpu, psx_gpu->saved_viewport_start_x)
 827
 828 #define enhancement_disable() { \
 829   psx_gpu->vram_out_ptr = psx_gpu->vram_ptr; \
 830   psx_gpu->viewport_start_x = psx_gpu->saved_viewport_start_x; \
 831   psx_gpu->viewport_start_y = psx_gpu->saved_viewport_start_y; \
 832   psx_gpu->viewport_end_x = psx_gpu->saved_viewport_end_x; \
 833   psx_gpu->viewport_end_y = psx_gpu->saved_viewport_end_y; \
 834   psx_gpu->uvrgb_phase = 0x8000; \
 835 }
 836
 837 #define enhancement_enable() { \
 838   psx_gpu->vram_out_ptr = psx_gpu->enhancement_current_buf_ptr; \
 839   psx_gpu->viewport_start_x = psx_gpu->saved_viewport_start_x * 2; \
 840   psx_gpu->viewport_start_y = psx_gpu->saved_viewport_start_y * 2; \
 841   psx_gpu->viewport_end_x = psx_gpu->saved_viewport_end_x * 2 + 1; \
 842   psx_gpu->viewport_end_y = psx_gpu->saved_viewport_end_y * 2 + 1; \
 843   psx_gpu->uvrgb_phase = 0x1000; \
 844 }
 845
 846 #define shift_vertices3(v) { \
 847   v[0]->x *= 2; \
 848   v[0]->y *= 2; \
 849   v[1]->x *= 2; \
 850   v[1]->y *= 2; \
 851   v[2]->x *= 2; \
 852   v[2]->y *= 2; \
 853 }
 854
 855 #define unshift_vertices3(v) { \
 856   v[0]->x /= 2; \
 857   v[0]->y /= 2; \
 858   v[1]->x /= 2; \
 859   v[1]->y /= 2; \
 860   v[2]->x /= 2; \
 861   v[2]->y /= 2; \
 862 }
 863
 864 #define shift_triangle_area() \
 865   psx_gpu->triangle_area *= 4
 866
 867 extern void scale2x_tiles8(void *dst, const void *src, int w8, int h);
 868
 869 #ifndef NEON_BUILD
 870 // TODO?
 871 void scale2x_tiles8(void *dst, const void *src, int w8, int h)
 872 {
 873   uint16_t* d = (uint16_t*)dst;
 874   const uint16_t* s = (const uint16_t*)src;
 875
 876   while ( h-- )
 877   {
 878     uint16_t* d_save = d;
 879     const uint16_t* s_save = s;
 880     int w = w8;
 881
 882     while ( w-- )
 883     {
 884       d[    0 ] = *s;
 885       d[    1 ] = *s;
 886       d[ 1024 ] = *s;
 887       d[ 1025 ] = *s;
 888       d += 2; s++;
 889
 890       d[    0 ] = *s;
 891       d[    1 ] = *s;
 892       d[ 1024 ] = *s;
 893       d[ 1025 ] = *s;
 894       d += 2; s++;
 895
 896       d[    0 ] = *s;
 897       d[    1 ] = *s;
 898       d[ 1024 ] = *s;
 899       d[ 1025 ] = *s;
 900       d += 2; s++;
 901
 902       d[    0 ] = *s;
 903       d[    1 ] = *s;
 904       d[ 1024 ] = *s;
 905       d[ 1025 ] = *s;
 906       d += 2; s++;
 907
 908       d[    0 ] = *s;
 909       d[    1 ] = *s;
 910       d[ 1024 ] = *s;
 911       d[ 1025 ] = *s;
 912       d += 2; s++;
 913
 914       d[    0 ] = *s;
 915       d[    1 ] = *s;
 916       d[ 1024 ] = *s;
 917       d[ 1025 ] = *s;
 918       d += 2; s++;
 919
 920       d[    0 ] = *s;
 921       d[    1 ] = *s;
 922       d[ 1024 ] = *s;
 923       d[ 1025 ] = *s;
 924       d += 2; s++;
 925
 926       d[    0 ] = *s;
 927       d[    1 ] = *s;
 928       d[ 1024 ] = *s;
 929       d[ 1025 ] = *s;
 930       d += 2; s++;
 931     }
 932
 933     d = d_save + 2048;
 934     s = s_save + 1024; /* or 512? */
 935   }
 936 }
 937 #endif
 938
 939 static int disable_main_render;
 940
 941 static void do_triangle_enhanced(psx_gpu_struct *psx_gpu,
 942  vertex_struct *vertexes, u32 current_command)
 943 {
 944   vertex_struct *vertex_ptrs[3];
 945
 946   if (!prepare_triangle(psx_gpu, vertexes, vertex_ptrs))
 947     return;
 948
 949   if (!disable_main_render)
 950     render_triangle_p(psx_gpu, vertex_ptrs, current_command);
 951
 952   enhancement_enable();
 953   shift_vertices3(vertex_ptrs);
 954   shift_triangle_area();
 955   render_triangle_p(psx_gpu, vertex_ptrs, current_command);
 956 }
 957
 958 static void do_quad_enhanced(psx_gpu_struct *psx_gpu, vertex_struct *vertexes,
 959  u32 current_command)
 960 {
 961   vertex_struct *vertex_ptrs[3];
 962
 963   if (prepare_triangle(psx_gpu, vertexes, vertex_ptrs)) {
 964     if (!disable_main_render)
 965       render_triangle_p(psx_gpu, vertex_ptrs, current_command);
 966
 967     enhancement_enable();
 968     shift_vertices3(vertex_ptrs);
 969     shift_triangle_area();
 970     render_triangle_p(psx_gpu, vertex_ptrs, current_command);
 971     unshift_vertices3(vertex_ptrs);
 972   }
 973   enhancement_disable();
 974   if (prepare_triangle(psx_gpu, &vertexes[1], vertex_ptrs)) {
 975     if (!disable_main_render)
 976       render_triangle_p(psx_gpu, vertex_ptrs, current_command);
 977
 978     enhancement_enable();
 979     shift_vertices3(vertex_ptrs);
 980     shift_triangle_area();
 981     render_triangle_p(psx_gpu, vertex_ptrs, current_command);
 982   }
 983 }
 984
 985 #if 0
 986
 987 #define fill_vertex(i, x_, y_, u_, v_, rgb_) \
 988   vertexes[i].x = x_; \
 989   vertexes[i].y = y_; \
 990   vertexes[i].u = u_; \
 991   vertexes[i].v = v_; \
 992   vertexes[i].r = rgb_; \
 993   vertexes[i].g = (rgb_) >> 8; \
 994   vertexes[i].b = (rgb_) >> 16
 995
 996 static void do_sprite_enhanced(psx_gpu_struct *psx_gpu, int x, int y,
 997  u32 u, u32 v, u32 w, u32 h, u32 cmd_rgb)
 998 {
 999   vertex_struct *vertex_ptrs[3];
1000   u32 flags = (cmd_rgb >> 24);
1001   u32 color = cmd_rgb & 0xffffff;
1002   u32 render_state_base_saved = psx_gpu->render_state_base;
1003   int x1, y1;
1004   u8 u1, v1;
1005
1006   flags &=
1007    (RENDER_FLAGS_MODULATE_TEXELS | RENDER_FLAGS_BLEND |
1008    RENDER_FLAGS_TEXTURE_MAP);
1009
1010   set_triangle_color(psx_gpu, color);
1011   if(color == 0x808080)
1012     flags |= RENDER_FLAGS_MODULATE_TEXELS;
1013
1014   psx_gpu->render_state_base &= ~RENDER_STATE_DITHER;
1015   enhancement_enable();
1016
1017   x1 = x + w;
1018   y1 = y + h;
1019   u1 = u + w;
1020   v1 = v + h;
1021   // FIXME..
1022   if (u1 < u) u1 = 0xff;
1023   if (v1 < v) v1 = 0xff;
1024
1025   // 0-2
1026   // |/
1027   // 1
1028   fill_vertex(0, x,  y,  u,  v,  color);
1029   fill_vertex(1, x,  y1, u,  v1, color);
1030   fill_vertex(2, x1, y,  u1, v,  color);
1031   if (prepare_triangle(psx_gpu, vertexes, vertex_ptrs)) {
1032     shift_vertices3(vertex_ptrs);
1033     shift_triangle_area();
1034     render_triangle_p(psx_gpu, vertex_ptrs, flags);
1035   }
1036
1037   //   0
1038   //  /|
1039   // 1-2
1040   fill_vertex(0, x1, y,  u1, v,  color);
1041   fill_vertex(1, x,  y1, u,  v1, color);
1042   fill_vertex(2, x1, y1, u1, v1, color);
1043   if (prepare_triangle(psx_gpu, vertexes, vertex_ptrs)) {
1044     shift_vertices3(vertex_ptrs);
1045     shift_triangle_area();
1046     render_triangle_p(psx_gpu, vertex_ptrs, flags);
1047   }
1048
1049   psx_gpu->render_state_base = render_state_base_saved;
1050 }
1051 #else
1052 static void do_sprite_enhanced(psx_gpu_struct *psx_gpu, int x, int y,
1053  u32 u, u32 v, u32 w, u32 h, u32 cmd_rgb)
1054 {
1055   u32 flags = (cmd_rgb >> 24);
1056   u32 color = cmd_rgb & 0xffffff;
1057
1058   render_sprite_4x(psx_gpu, x, y, u, v, w, h, flags, color);
1059 }
1060 #endif
1061
1062 u32 gpu_parse_enhanced(psx_gpu_struct *psx_gpu, u32 *list, u32 size,
1063  u32 *last_command)
1064 {
1065   u32 current_command = 0, command_length;
1066
1067   u32 *list_start = list;
1068   u32 *list_end = list + (size / 4);
1069
1070   psx_gpu->saved_viewport_start_x = psx_gpu->viewport_start_x;
1071   psx_gpu->saved_viewport_start_y = psx_gpu->viewport_start_y;
1072   psx_gpu->saved_viewport_end_x = psx_gpu->viewport_end_x;
1073   psx_gpu->saved_viewport_end_y = psx_gpu->viewport_end_y;
1074   select_enhancement_buf(psx_gpu);
1075
1076   for(; list < list_end; list += 1 + command_length)
1077   {
1078     s16 *list_s16 = (void *)list;
1079     current_command = *list >> 24;
1080     command_length = command_lengths[current_command];
1081     if (list + 1 + command_length > list_end) {
1082       current_command = (u32)-1;
1083       break;
1084     }
1085
1086     enhancement_disable();
1087
1088     switch(current_command)
1089     {
1090       case 0x00:
1091         break;
1092
1093       case 0x02:
1094       {
1095         u32 x = list_s16[2] & 0x3FF;
1096         u32 y = list_s16[3] & 0x1FF;
1097         u32 width = list_s16[4] & 0x3FF;
1098         u32 height = list_s16[5] & 0x1FF;
1099         u32 color = list[0] & 0xFFFFFF;
1100
1101         x &= ~0xF;
1102         width = ((width + 0xF) & ~0xF);
1103
1104         do_fill(psx_gpu, x, y, width, height, color);
1105
1106         psx_gpu->vram_out_ptr = select_enhancement_buf_ptr(psx_gpu, x);
1107         x *= 2;
1108         y *= 2;
1109         width *= 2;
1110         height *= 2;
1111         render_block_fill_enh(psx_gpu, color, x, y, width, height);
1112         break;
1113       }
1114
1115       case 0x20 ... 0x23:
1116       {
1117         set_triangle_color(psx_gpu, list[0] & 0xFFFFFF);
1118
1119         get_vertex_data_xy(0, 2);
1120         get_vertex_data_xy(1, 4);
1121         get_vertex_data_xy(2, 6);
1122
1123         do_triangle_enhanced(psx_gpu, vertexes, current_command);
1124         break;
1125       }
1126
1127       case 0x24 ... 0x27:
1128       {
1129         set_clut(psx_gpu, list_s16[5]);
1130         set_texture(psx_gpu, list_s16[9]);
1131         set_triangle_color(psx_gpu, list[0] & 0xFFFFFF);
1132
1133         get_vertex_data_xy_uv(0, 2);
1134         get_vertex_data_xy_uv(1, 6);
1135         get_vertex_data_xy_uv(2, 10);
1136
1137         do_triangle_enhanced(psx_gpu, vertexes, current_command);
1138         break;
1139       }
1140
1141       case 0x28 ... 0x2B:
1142       {
1143         set_triangle_color(psx_gpu, list[0] & 0xFFFFFF);
1144
1145         get_vertex_data_xy(0, 2);
1146         get_vertex_data_xy(1, 4);
1147         get_vertex_data_xy(2, 6);
1148         get_vertex_data_xy(3, 8);
1149
1150         do_quad_enhanced(psx_gpu, vertexes, current_command);
1151         break;
1152       }
1153
1154       case 0x2C ... 0x2F:
1155       {
1156         set_clut(psx_gpu, list_s16[5]);
1157         set_texture(psx_gpu, list_s16[9]);
1158         set_triangle_color(psx_gpu, list[0] & 0xFFFFFF);
1159
1160         get_vertex_data_xy_uv(0, 2);
1161         get_vertex_data_xy_uv(1, 6);
1162         get_vertex_data_xy_uv(2, 10);
1163         get_vertex_data_xy_uv(3, 14);
1164
1165         do_quad_enhanced(psx_gpu, vertexes, current_command);
1166         break;
1167       }
1168
1169       case 0x30 ... 0x33:
1170       {
1171         get_vertex_data_xy_rgb(0, 0);
1172         get_vertex_data_xy_rgb(1, 4);
1173         get_vertex_data_xy_rgb(2, 8);
1174
1175         do_triangle_enhanced(psx_gpu, vertexes, current_command);
1176         break;
1177       }
1178
1179       case 0x34:
1180       case 0x35:
1181       case 0x36:
1182       case 0x37:
1183       {
1184         set_clut(psx_gpu, list_s16[5]);
1185         set_texture(psx_gpu, list_s16[11]);
1186
1187         get_vertex_data_xy_uv_rgb(0, 0);
1188         get_vertex_data_xy_uv_rgb(1, 6);
1189         get_vertex_data_xy_uv_rgb(2, 12);
1190
1191         do_triangle_enhanced(psx_gpu, vertexes, current_command);
1192         break;
1193       }
1194
1195       case 0x38:
1196       case 0x39:
1197       case 0x3A:
1198       case 0x3B:
1199       {
1200         get_vertex_data_xy_rgb(0, 0);
1201         get_vertex_data_xy_rgb(1, 4);
1202         get_vertex_data_xy_rgb(2, 8);
1203         get_vertex_data_xy_rgb(3, 12);
1204
1205         do_quad_enhanced(psx_gpu, vertexes, current_command);
1206         break;
1207       }
1208
1209       case 0x3C:
1210       case 0x3D:
1211       case 0x3E:
1212       case 0x3F:
1213       {
1214         set_clut(psx_gpu, list_s16[5]);
1215         set_texture(psx_gpu, list_s16[11]);
1216
1217         get_vertex_data_xy_uv_rgb(0, 0);
1218         get_vertex_data_xy_uv_rgb(1, 6);
1219         get_vertex_data_xy_uv_rgb(2, 12);
1220         get_vertex_data_xy_uv_rgb(3, 18);
1221
1222         do_quad_enhanced(psx_gpu, vertexes, current_command);
1223         break;
1224       }
1225
1226       case 0x40 ... 0x47:
1227       {
1228         vertexes[0].x = list_s16[2] + psx_gpu->offset_x;
1229         vertexes[0].y = list_s16[3] + psx_gpu->offset_y;
1230         vertexes[1].x = list_s16[4] + psx_gpu->offset_x;
1231         vertexes[1].y = list_s16[5] + psx_gpu->offset_y;
1232
1233         render_line(psx_gpu, vertexes, current_command, list[0], 0);
1234         enhancement_enable();
1235         render_line(psx_gpu, vertexes, current_command, list[0], 1);
1236         break;
1237       }
1238
1239       case 0x48 ... 0x4F:
1240       {
1241         u32 num_vertexes = 1;
1242         u32 *list_position = &(list[2]);
1243         u32 xy = list[1];
1244
1245         vertexes[1].x = (xy & 0xFFFF) + psx_gpu->offset_x;
1246         vertexes[1].y = (xy >> 16) + psx_gpu->offset_y;
1247
1248         xy = *list_position;
1249         while(1)
1250         {
1251           vertexes[0] = vertexes[1];
1252
1253           vertexes[1].x = (xy & 0xFFFF) + psx_gpu->offset_x;
1254           vertexes[1].y = (xy >> 16) + psx_gpu->offset_y;
1255
1256           enhancement_disable();
1257           render_line(psx_gpu, vertexes, current_command, list[0], 0);
1258           enhancement_enable();
1259           render_line(psx_gpu, vertexes, current_command, list[0], 1);
1260
1261           list_position++;
1262           num_vertexes++;
1263
1264           if(list_position >= list_end)
1265           {
1266             current_command = (u32)-1;
1267             goto breakloop;
1268           }
1269
1270           xy = *list_position;
1271           if((xy & 0xF000F000) == 0x50005000)
1272             break;
1273         }
1274
1275         command_length += (num_vertexes - 2);
1276         break;
1277       }
1278
1279       case 0x50 ... 0x57:
1280       {
1281         vertexes[0].r = list[0] & 0xFF;
1282         vertexes[0].g = (list[0] >> 8) & 0xFF;
1283         vertexes[0].b = (list[0] >> 16) & 0xFF;
1284         vertexes[0].x = list_s16[2] + psx_gpu->offset_x;
1285         vertexes[0].y = list_s16[3] + psx_gpu->offset_y;
1286
1287         vertexes[1].r = list[2] & 0xFF;
1288         vertexes[1].g = (list[2] >> 8) & 0xFF;
1289         vertexes[1].b = (list[2] >> 16) & 0xFF;
1290         vertexes[1].x = list_s16[6] + psx_gpu->offset_x;
1291         vertexes[1].y = list_s16[7] + psx_gpu->offset_y;
1292
1293         render_line(psx_gpu, vertexes, current_command, 0, 0);
1294         enhancement_enable();
1295         render_line(psx_gpu, vertexes, current_command, 0, 1);
1296         break;
1297       }
1298
1299       case 0x58 ... 0x5F:
1300       {
1301         u32 num_vertexes = 1;
1302         u32 *list_position = &(list[2]);
1303         u32 color = list[0];
1304         u32 xy = list[1];
1305
1306         vertexes[1].r = color & 0xFF;
1307         vertexes[1].g = (color >> 8) & 0xFF;
1308         vertexes[1].b = (color >> 16) & 0xFF;
1309         vertexes[1].x = (xy & 0xFFFF) + psx_gpu->offset_x;
1310         vertexes[1].y = (xy >> 16) + psx_gpu->offset_y;
1311
1312         color = list_position[0];
1313         while(1)
1314         {
1315           xy = list_position[1];
1316
1317           vertexes[0] = vertexes[1];
1318
1319           vertexes[1].r = color & 0xFF;
1320           vertexes[1].g = (color >> 8) & 0xFF;
1321           vertexes[1].b = (color >> 16) & 0xFF;
1322           vertexes[1].x = (xy & 0xFFFF) + psx_gpu->offset_x;
1323           vertexes[1].y = (xy >> 16) + psx_gpu->offset_y;
1324
1325           enhancement_disable();
1326           render_line(psx_gpu, vertexes, current_command, 0, 0);
1327           enhancement_enable();
1328           render_line(psx_gpu, vertexes, current_command, 0, 1);
1329
1330           list_position += 2;
1331           num_vertexes++;
1332
1333           if(list_position >= list_end)
1334           {
1335             current_command = (u32)-1;
1336             goto breakloop;
1337           }
1338
1339           color = list_position[0];
1340           if((color & 0xF000F000) == 0x50005000)
1341             break;
1342         }
1343
1344         command_length += ((num_vertexes - 2) * 2);
1345         break;
1346       }
1347
1348       case 0x60 ... 0x63:
1349       {
1350         u32 x = sign_extend_11bit(list_s16[2] + psx_gpu->offset_x);
1351         u32 y = sign_extend_11bit(list_s16[3] + psx_gpu->offset_y);
1352         u32 width = list_s16[4] & 0x3FF;
1353         u32 height = list_s16[5] & 0x1FF;
1354
1355         render_sprite(psx_gpu, x, y, 0, 0, width, height, current_command, list[0]);
1356         do_sprite_enhanced(psx_gpu, x, y, 0, 0, width, height, list[0]);
1357         break;
1358       }
1359
1360       case 0x64 ... 0x67:
1361       {
1362         u32 x = sign_extend_11bit(list_s16[2] + psx_gpu->offset_x);
1363         u32 y = sign_extend_11bit(list_s16[3] + psx_gpu->offset_y);
1364         u8 u = list_s16[4];
1365         u8 v = list_s16[4] >> 8;
1366         u32 width = list_s16[6] & 0x3FF;
1367         u32 height = list_s16[7] & 0x1FF;
1368
1369         set_clut(psx_gpu, list_s16[5]);
1370
1371         render_sprite(psx_gpu, x, y, u, v, width, height,
1372          current_command, list[0]);
1373         do_sprite_enhanced(psx_gpu, x, y, u, v, width, height, list[0]);
1374         break;
1375       }
1376
1377       case 0x68:
1378       case 0x69:
1379       case 0x6A:
1380       case 0x6B:
1381       {
1382         s32 x = sign_extend_11bit(list_s16[2] + psx_gpu->offset_x);
1383         s32 y = sign_extend_11bit(list_s16[3] + psx_gpu->offset_y);
1384
1385         render_sprite(psx_gpu, x, y, 0, 0, 1, 1, current_command, list[0]);
1386         do_sprite_enhanced(psx_gpu, x, y, 0, 0, 1, 1, list[0]);
1387         break;
1388       }
1389
1390       case 0x70:
1391       case 0x71:
1392       case 0x72:
1393       case 0x73:
1394       {
1395         s32 x = sign_extend_11bit(list_s16[2] + psx_gpu->offset_x);
1396         s32 y = sign_extend_11bit(list_s16[3] + psx_gpu->offset_y);
1397
1398         render_sprite(psx_gpu, x, y, 0, 0, 8, 8, current_command, list[0]);
1399         do_sprite_enhanced(psx_gpu, x, y, 0, 0, 8, 8, list[0]);
1400         break;
1401       }
1402
1403       case 0x74:
1404       case 0x75:
1405       case 0x76:
1406       case 0x77:
1407       {
1408         s32 x = sign_extend_11bit(list_s16[2] + psx_gpu->offset_x);
1409         s32 y = sign_extend_11bit(list_s16[3] + psx_gpu->offset_y);
1410         u8 u = list_s16[4];
1411         u8 v = list_s16[4] >> 8;
1412
1413         set_clut(psx_gpu, list_s16[5]);
1414
1415         render_sprite(psx_gpu, x, y, u, v, 8, 8,
1416          current_command, list[0]);
1417         do_sprite_enhanced(psx_gpu, x, y, u, v, 8, 8, list[0]);
1418         break;
1419       }
1420
1421       case 0x78:
1422       case 0x79:
1423       case 0x7A:
1424       case 0x7B:
1425       {
1426         s32 x = sign_extend_11bit(list_s16[2] + psx_gpu->offset_x);
1427         s32 y = sign_extend_11bit(list_s16[3] + psx_gpu->offset_y);
1428
1429         render_sprite(psx_gpu, x, y, 0, 0, 16, 16, current_command, list[0]);
1430         do_sprite_enhanced(psx_gpu, x, y, 0, 0, 16, 16, list[0]);
1431         break;
1432       }
1433
1434       case 0x7C:
1435       case 0x7D:
1436       case 0x7E:
1437       case 0x7F:
1438       {
1439         s32 x = sign_extend_11bit(list_s16[2] + psx_gpu->offset_x);
1440         s32 y = sign_extend_11bit(list_s16[3] + psx_gpu->offset_y);
1441         u8 u = list_s16[4];
1442         u8 v = list_s16[4] >> 8;
1443
1444         set_clut(psx_gpu, list_s16[5]);
1445
1446         render_sprite(psx_gpu, x, y, u, v, 16, 16, current_command, list[0]);
1447         do_sprite_enhanced(psx_gpu, x, y, u, v, 16, 16, list[0]);
1448         break;
1449       }
1450
1451       case 0x80:          //  vid -> vid
1452       {
1453         u32 sx = list_s16[2] & 0x3FF;
1454         u32 sy = list_s16[3] & 0x1FF;
1455         u32 dx = list_s16[4] & 0x3FF;
1456         u32 dy = list_s16[5] & 0x1FF;
1457         u32 w = ((list_s16[6] - 1) & 0x3FF) + 1;
1458         u32 h = ((list_s16[7] - 1) & 0x1FF) + 1;
1459         u16 *buf;
1460
1461         if (sx == dx && sy == dy && psx_gpu->mask_msb == 0)
1462           break;
1463
1464         render_block_move(psx_gpu, sx, sy, dx, dy, w, h);
1465         if (dy + h > 512)
1466           h = 512 - dy;
1467         sx = sx & ~7; // FIXME?
1468         dx = dx * 2 & ~7;
1469         dy *= 2;
1470         w = (w + 7) / 8;
1471         buf = select_enhancement_buf_ptr(psx_gpu, dx / 2);
1472         scale2x_tiles8(buf + dy * 1024 + dx,
1473           psx_gpu->vram_ptr + sy * 1024 + sx, w, h);
1474         break;
1475       }
1476
1477       case 0xA0:          //  sys -> vid
1478       case 0xC0:          //  vid -> sys
1479         goto breakloop;
1480
1481       case 0xE1:
1482         set_texture(psx_gpu, list[0]);
1483
1484         if(list[0] & (1 << 9))
1485           psx_gpu->render_state_base |= RENDER_STATE_DITHER;
1486         else
1487           psx_gpu->render_state_base &= ~RENDER_STATE_DITHER;
1488
1489         psx_gpu->display_area_draw_enable = (list[0] >> 10) & 0x1;
1490         SET_Ex(1, list[0]);
1491         break;
1492
1493       case 0xE2:
1494       {
1495         // TODO: Clean
1496         u32 texture_window_settings = list[0];
1497         u32 tmp, x, y, w, h;
1498
1499         if(texture_window_settings != psx_gpu->texture_window_settings)
1500         {
1501           tmp = (texture_window_settings & 0x1F) | 0x20;
1502           for(w = 8; (tmp & 1) == 0; tmp >>= 1, w <<= 1);
1503
1504           tmp = ((texture_window_settings >> 5) & 0x1f) | 0x20;
1505           for (h = 8; (tmp & 1) == 0; tmp >>= 1, h <<= 1);
1506
1507           tmp = 32 - (w >> 3);
1508           x = ((texture_window_settings >> 10) & tmp) << 3;
1509
1510           tmp = 32 - (h >> 3);
1511           y = ((texture_window_settings >> 15) & tmp) << 3;
1512
1513           flush_render_block_buffer(psx_gpu);
1514
1515           psx_gpu->texture_window_settings = texture_window_settings;
1516           psx_gpu->texture_window_x = x;
1517           psx_gpu->texture_window_y = y;
1518           psx_gpu->texture_mask_width = w - 1;
1519           psx_gpu->texture_mask_height = h - 1;
1520
1521           update_texture_ptr(psx_gpu);
1522         }
1523         SET_Ex(2, list[0]);
1524         break;
1525       }
1526
1527       case 0xE3:
1528       {
1529         s16 viewport_start_x = list[0] & 0x3FF;
1530         s16 viewport_start_y = (list[0] >> 10) & 0x1FF;
1531         u32 w;
1532         s32 d;
1533
1534         if(viewport_start_x == psx_gpu->viewport_start_x &&
1535          viewport_start_y == psx_gpu->viewport_start_y)
1536         {
1537           break;
1538         }
1539         psx_gpu->viewport_start_x = viewport_start_x;
1540         psx_gpu->viewport_start_y = viewport_start_y;
1541         psx_gpu->saved_viewport_start_x = viewport_start_x;
1542         psx_gpu->saved_viewport_start_y = viewport_start_y;
1543
1544         w = (u32)psx_gpu->viewport_end_x - (u32)viewport_start_x + 1;
1545         d = psx_gpu->enhancement_x_threshold - w;
1546         if(-16 <= d && d <= 16)
1547         {
1548           update_enhancement_buf_table_from_x(psx_gpu,
1549            viewport_start_x, w);
1550         }
1551         select_enhancement_buf(psx_gpu);
1552
1553 #ifdef TEXTURE_CACHE_4BPP
1554         psx_gpu->viewport_mask =
1555          texture_region_mask(psx_gpu->viewport_start_x,
1556          psx_gpu->viewport_start_y, psx_gpu->viewport_end_x,
1557          psx_gpu->viewport_end_y);
1558 #endif
1559         SET_Ex(3, list[0]);
1560         break;
1561       }
1562
1563       case 0xE4:
1564       {
1565         s16 viewport_end_x = list[0] & 0x3FF;
1566         s16 viewport_end_y = (list[0] >> 10) & 0x1FF;
1567         u32 w;
1568         s32 d;
1569
1570         if(viewport_end_x == psx_gpu->viewport_end_x &&
1571          viewport_end_y == psx_gpu->viewport_end_y)
1572         {
1573           break;
1574         }
1575
1576         psx_gpu->viewport_end_x = viewport_end_x;
1577         psx_gpu->viewport_end_y = viewport_end_y;
1578         psx_gpu->saved_viewport_end_x = viewport_end_x;
1579         psx_gpu->saved_viewport_end_y = viewport_end_y;
1580
1581         w = (u32)viewport_end_x - (u32)psx_gpu->viewport_start_x + 1;
1582         d = psx_gpu->enhancement_x_threshold - w;
1583         if(-16 <= d && d <= 16)
1584         {
1585           update_enhancement_buf_table_from_x(psx_gpu,
1586            psx_gpu->viewport_start_x, w);
1587         }
1588         select_enhancement_buf(psx_gpu);
1589
1590 #ifdef TEXTURE_CACHE_4BPP
1591         psx_gpu->viewport_mask =
1592          texture_region_mask(psx_gpu->viewport_start_x,
1593          psx_gpu->viewport_start_y, psx_gpu->viewport_end_x,
1594          psx_gpu->viewport_end_y);
1595 #endif
1596         SET_Ex(4, list[0]);
1597         break;
1598       }
1599
1600       case 0xE5:
1601       {
1602         s32 offset_x = list[0] << 21;
1603         s32 offset_y = list[0] << 10;
1604         psx_gpu->offset_x = offset_x >> 21;
1605         psx_gpu->offset_y = offset_y >> 21;
1606
1607         SET_Ex(5, list[0]);
1608         break;
1609       }
1610
1611       case 0xE6:
1612       {
1613         u32 mask_settings = list[0];
1614         u16 mask_msb = mask_settings << 15;
1615
1616         if(list[0] & 0x2)
1617           psx_gpu->render_state_base |= RENDER_STATE_MASK_EVALUATE;
1618         else
1619           psx_gpu->render_state_base &= ~RENDER_STATE_MASK_EVALUATE;
1620
1621         if(mask_msb != psx_gpu->mask_msb)
1622         {
1623           flush_render_block_buffer(psx_gpu);
1624           psx_gpu->mask_msb = mask_msb;
1625         }
1626
1627         SET_Ex(6, list[0]);
1628         break;
1629       }
1630
1631       default:
1632         break;
1633     }
1634   }
1635
1636   enhancement_disable();
1637
1638 breakloop:
1639   if (last_command != NULL)
1640     *last_command = current_command;
1641   return list - list_start;
1642 }
1643
1644 #endif /* PCSX */
1645
1646 // vim:shiftwidth=2:expandtab