plugins/gpu_unai/gpulib_if.cpp

   1 /***************************************************************************
   2 *   Copyright (C) 2010 PCSX4ALL Team                                      *
   3 *   Copyright (C) 2010 Unai                                               *
   4 *   Copyright (C) 2011 notaz                                              *
   5 *   Copyright (C) 2016 Senquack (dansilsby <AT> gmail <DOT> com)          *
   6 *                                                                         *
   7 *   This program is free software; you can redistribute it and/or modify  *
   8 *   it under the terms of the GNU General Public License as published by  *
   9 *   the Free Software Foundation; either version 2 of the License, or     *
  10 *   (at your option) any later version.                                   *
  11 *                                                                         *
  12 *   This program is distributed in the hope that it will be useful,       *
  13 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
  14 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
  15 *   GNU General Public License for more details.                          *
  16 *                                                                         *
  17 *   You should have received a copy of the GNU General Public License     *
  18 *   along with this program; if not, write to the                         *
  19 *   Free Software Foundation, Inc.,                                       *
  20 *   51 Franklin Street, Fifth Floor, Boston, MA 02111-1307 USA.           *
  21 ***************************************************************************/
  22
  23 #include <stddef.h>
  24 #include <stdio.h>
  25 #include <stdlib.h>
  26 #include <string.h>
  27 #include "../gpulib/gpu.h"
  28
  29 #ifdef THREAD_RENDERING
  30 #include "../gpulib/gpulib_thread_if.h"
  31 #define do_cmd_list real_do_cmd_list
  32 #define renderer_init real_renderer_init
  33 #define renderer_finish real_renderer_finish
  34 #define renderer_sync_ecmds real_renderer_sync_ecmds
  35 #define renderer_update_caches real_renderer_update_caches
  36 #define renderer_flush_queues real_renderer_flush_queues
  37 #define renderer_set_interlace real_renderer_set_interlace
  38 #define renderer_set_config real_renderer_set_config
  39 #define renderer_notify_res_change real_renderer_notify_res_change
  40 #define renderer_notify_update_lace real_renderer_notify_update_lace
  41 #define renderer_sync real_renderer_sync
  42 #define ex_regs scratch_ex_regs
  43 #endif
  44
  45 //#include "port.h"
  46 #include "gpu_unai.h"
  47
  48 // GPU fixed point math
  49 #include "gpu_fixedpoint.h"
  50
  51 // Inner loop driver instantiation file
  52 #include "gpu_inner.h"
  53
  54 // GPU internal image drawing functions
  55 #include "gpu_raster_image.h"
  56
  57 // GPU internal line drawing functions
  58 #include "gpu_raster_line.h"
  59
  60 // GPU internal polygon drawing functions
  61 #include "gpu_raster_polygon.h"
  62
  63 // GPU internal sprite drawing functions
  64 #include "gpu_raster_sprite.h"
  65
  66 // GPU command buffer execution/store
  67 #include "gpu_command.h"
  68
  69 /////////////////////////////////////////////////////////////////////////////
  70
  71 #define DOWNSCALE_VRAM_SIZE (1024 * 512 * 2 * 2 + 4096)
  72
  73 INLINE void scale_640_to_320(uint16_t *dest, const uint16_t *src, bool isRGB24) {
  74   size_t uCount = 320;
  75
  76   if(isRGB24) {
  77     const uint8_t* src8 = (const uint8_t *)src;
  78     uint8_t* dst8 = (uint8_t *)dest;
  79
  80     do {
  81       *dst8++ = *src8++;
  82       *dst8++ = *src8++;
  83       *dst8++ = *src8;
  84       src8 += 4;
  85     } while(--uCount);
  86   } else {
  87     const uint16_t* src16 = src;
  88     uint16_t* dst16 = dest;
  89
  90     do {
  91       *dst16++ = *src16;
  92       src16 += 2;
  93     } while(--uCount);
  94   }
  95 }
  96
  97 INLINE void scale_512_to_320(uint16_t *dest, const uint16_t *src, bool isRGB24) {
  98   size_t uCount = 64;
  99
 100   if(isRGB24) {
 101     const uint8_t* src8 = (const uint8_t *)src;
 102     uint8_t* dst8 = (uint8_t *)dest;
 103
 104     do {
 105       *dst8++ = *src8++;
 106       *dst8++ = *src8++;
 107       *dst8++ = *src8++;
 108       *dst8++ = *src8++;
 109       *dst8++ = *src8++;
 110       *dst8++ = *src8;
 111       src8 += 4;
 112       *dst8++ = *src8++;
 113       *dst8++ = *src8++;
 114       *dst8++ = *src8++;
 115       *dst8++ = *src8++;
 116       *dst8++ = *src8++;
 117       *dst8++ = *src8;
 118       src8 += 4;
 119       *dst8++ = *src8++;
 120       *dst8++ = *src8++;
 121       *dst8++ = *src8;
 122       src8 += 4;
 123     } while(--uCount);
 124   } else {
 125     const uint16_t* src16 = src;
 126     uint16_t* dst16 = dest;
 127
 128     do {
 129       *dst16++ = *src16++;
 130       *dst16++ = *src16;
 131       src16 += 2;
 132       *dst16++ = *src16++;
 133       *dst16++ = *src16;
 134       src16 += 2;
 135       *dst16++ = *src16;
 136       src16 += 2;
 137     } while(--uCount);
 138   }
 139 }
 140
 141 static uint16_t *get_downscale_buffer(int *x, int *y, int *w, int *h, int *vram_h)
 142 {
 143   uint16_t *dest = gpu_unai.downscale_vram;
 144   const uint16_t *src = gpu_unai.vram;
 145   bool isRGB24 = (gpu_unai.GPU_GP1 & 0x00200000 ? true : false);
 146   int stride = 1024, dstride = 1024, lines = *h, orig_w = *w;
 147
 148   // PS1 fb read wraps around (fixes black screen in 'Tobal no. 1')
 149   unsigned int fb_mask = 1024 * 512 - 1;
 150
 151   if (*h > 240) {
 152     *h /= 2;
 153     stride *= 2;
 154     lines = *h;
 155
 156     // Ensure start at a non-skipped line
 157     while (*y & gpu_unai.ilace_mask) ++*y;
 158   }
 159
 160   unsigned int fb_offset_src = (*y * dstride + *x) & fb_mask;
 161   unsigned int fb_offset_dest = fb_offset_src;
 162
 163   if (*w == 512 || *w == 640) {
 164     *w = 320;
 165   }
 166
 167   switch(orig_w) {
 168   case 640:
 169     do {
 170       scale_640_to_320(dest + fb_offset_dest, src + fb_offset_src, isRGB24);
 171       fb_offset_src = (fb_offset_src + stride) & fb_mask;
 172       fb_offset_dest = (fb_offset_dest + dstride) & fb_mask;
 173     } while(--lines);
 174
 175     break;
 176   case 512:
 177     do {
 178       scale_512_to_320(dest + fb_offset_dest, src + fb_offset_src, isRGB24);
 179       fb_offset_src = (fb_offset_src + stride) & fb_mask;
 180       fb_offset_dest = (fb_offset_dest + dstride) & fb_mask;
 181     } while(--lines);
 182     break;
 183   default:
 184     size_t size = isRGB24 ? *w * 3 : *w * 2;
 185
 186     do {
 187       memcpy(dest + fb_offset_dest, src + fb_offset_src, size);
 188       fb_offset_src = (fb_offset_src + stride) & fb_mask;
 189       fb_offset_dest = (fb_offset_dest + dstride) & fb_mask;
 190     } while(--lines);
 191     break;
 192   }
 193
 194   return gpu_unai.downscale_vram;
 195 }
 196
 197 static void map_downscale_buffer(void)
 198 {
 199   if (gpu_unai.downscale_vram)
 200     return;
 201
 202   gpu_unai.downscale_vram = (uint16_t*)gpu.mmap(DOWNSCALE_VRAM_SIZE);
 203
 204   if (gpu_unai.downscale_vram == NULL) {
 205     fprintf(stderr, "failed to map downscale buffer\n");
 206     gpu.get_downscale_buffer = NULL;
 207   }
 208   else {
 209     gpu.get_downscale_buffer = get_downscale_buffer;
 210   }
 211 }
 212
 213 static void unmap_downscale_buffer(void)
 214 {
 215   if (gpu_unai.downscale_vram == NULL)
 216     return;
 217
 218   gpu.munmap(gpu_unai.downscale_vram, DOWNSCALE_VRAM_SIZE);
 219   gpu_unai.downscale_vram = NULL;
 220   gpu.get_downscale_buffer = NULL;
 221 }
 222
 223 int renderer_init(void)
 224 {
 225   memset((void*)&gpu_unai, 0, sizeof(gpu_unai));
 226   gpu_unai.vram = (u16*)gpu.vram;
 227
 228   // Original standalone gpu_unai initialized TextureWindow[]. I added the
 229   //  same behavior here, since it seems unsafe to leave [2],[3] unset when
 230   //  using HLE and Rearmed gpu_neon sets this similarly on init. -senquack
 231   gpu_unai.TextureWindow[0] = 0;
 232   gpu_unai.TextureWindow[1] = 0;
 233   gpu_unai.TextureWindow[2] = 255;
 234   gpu_unai.TextureWindow[3] = 255;
 235   //senquack - new vars must be updated whenever texture window is changed:
 236   //           (used for polygon-drawing in gpu_inner.h, gpu_raster_polygon.h)
 237   const u32 fb = FIXED_BITS;  // # of fractional fixed-pt bits of u4/v4
 238   gpu_unai.u_msk = (((u32)gpu_unai.TextureWindow[2]) << fb) | ((1 << fb) - 1);
 239   gpu_unai.v_msk = (((u32)gpu_unai.TextureWindow[3]) << fb) | ((1 << fb) - 1);
 240
 241   // Configuration options
 242   gpu_unai.config = gpu_unai_config_ext;
 243   //senquack - disabled, not sure this is needed and would require modifying
 244   // sprite-span functions, perhaps unnecessarily. No Abe Oddysey hack was
 245   // present in latest PCSX4ALL sources we were using.
 246   //gpu_unai.config.enableAbbeyHack = gpu_unai_config_ext.abe_hack;
 247   gpu_unai.ilace_mask = gpu_unai.config.ilace_force;
 248
 249 #ifdef GPU_UNAI_USE_INT_DIV_MULTINV
 250   // s_invTable
 251   for(int i=1;i<=(1<<TABLE_BITS);++i)
 252   {
 253     double v = 1.0 / double(i);
 254 #ifdef GPU_TABLE_10_BITS
 255     v *= double(0xffffffff>>1);
 256 #else
 257     v *= double(0x80000000);
 258 #endif
 259     s_invTable[i-1]=s32(v);
 260   }
 261 #endif
 262
 263   SetupLightLUT();
 264   SetupDitheringConstants();
 265
 266   if (gpu_unai.config.scale_hires) {
 267     map_downscale_buffer();
 268   }
 269
 270   return 0;
 271 }
 272
 273 void renderer_finish(void)
 274 {
 275   unmap_downscale_buffer();
 276 }
 277
 278 void renderer_notify_res_change(void)
 279 {
 280   if (PixelSkipEnabled()) {
 281     // Set blit_mask for high horizontal resolutions. This allows skipping
 282     //  rendering pixels that would never get displayed on low-resolution
 283     //  platforms that use simple pixel-dropping scaler.
 284
 285     switch (gpu.screen.hres)
 286     {
 287       case 512: gpu_unai.blit_mask = 0xa4; break; // GPU_BlitWWSWWSWS
 288       case 640: gpu_unai.blit_mask = 0xaa; break; // GPU_BlitWS
 289       default:  gpu_unai.blit_mask = 0;    break;
 290     }
 291   } else {
 292     gpu_unai.blit_mask = 0;
 293   }
 294
 295   if (LineSkipEnabled()) {
 296     // Set rendering line-skip (only render every other line in high-res
 297     //  480 vertical mode, or, optionally, force it for all video modes)
 298
 299     if (gpu.screen.vres == 480) {
 300       if (gpu_unai.config.ilace_force) {
 301         gpu_unai.ilace_mask = 3; // Only need 1/4 of lines
 302       } else {
 303         gpu_unai.ilace_mask = 1; // Only need 1/2 of lines
 304       }
 305     } else {
 306       // Vert resolution changed from 480 to lower one
 307       gpu_unai.ilace_mask = gpu_unai.config.ilace_force;
 308     }
 309   } else {
 310     gpu_unai.ilace_mask = 0;
 311   }
 312
 313   /*
 314   printf("res change hres: %d   vres: %d   depth: %d   ilace_mask: %d\n",
 315       gpu.screen.hres, gpu.screen.vres, (gpu.status & PSX_GPU_STATUS_RGB24) ? 24 : 15,
 316       gpu_unai.ilace_mask);
 317   */
 318 }
 319
 320 void renderer_notify_scanout_x_change(int x, int w)
 321 {
 322 }
 323
 324 #ifdef USE_GPULIB
 325 // Handles GP0 draw settings commands 0xE1...0xE6
 326 static void gpuGP0Cmd_0xEx(gpu_unai_t &gpu_unai, u32 cmd_word)
 327 {
 328   // Assume incoming GP0 command is 0xE1..0xE6, convert to 1..6
 329   u8 num = (cmd_word >> 24) & 7;
 330   gpu.ex_regs[num] = cmd_word; // Update gpulib register
 331   switch (num) {
 332     case 1: {
 333       // GP0(E1h) - Draw Mode setting (aka "Texpage")
 334       u32 cur_texpage = gpu_unai.GPU_GP1 & 0x7FF;
 335       u32 new_texpage = cmd_word & 0x7FF;
 336       if (cur_texpage != new_texpage) {
 337         gpu_unai.GPU_GP1 = (gpu_unai.GPU_GP1 & ~0x7FF) | new_texpage;
 338         gpuSetTexture(gpu_unai.GPU_GP1);
 339       }
 340     } break;
 341
 342     case 2: {
 343       // GP0(E2h) - Texture Window setting
 344       if (cmd_word != gpu_unai.TextureWindowCur) {
 345         static const u8 TextureMask[32] = {
 346           255, 7, 15, 7, 31, 7, 15, 7, 63, 7, 15, 7, 31, 7, 15, 7,
 347           127, 7, 15, 7, 31, 7, 15, 7, 63, 7, 15, 7, 31, 7, 15, 7
 348         };
 349         gpu_unai.TextureWindowCur = cmd_word;
 350         gpu_unai.TextureWindow[0] = ((cmd_word >> 10) & 0x1F) << 3;
 351         gpu_unai.TextureWindow[1] = ((cmd_word >> 15) & 0x1F) << 3;
 352         gpu_unai.TextureWindow[2] = TextureMask[(cmd_word >> 0) & 0x1F];
 353         gpu_unai.TextureWindow[3] = TextureMask[(cmd_word >> 5) & 0x1F];
 354         gpu_unai.TextureWindow[0] &= ~gpu_unai.TextureWindow[2];
 355         gpu_unai.TextureWindow[1] &= ~gpu_unai.TextureWindow[3];
 356
 357         // Inner loop vars must be updated whenever texture window is changed:
 358         const u32 fb = FIXED_BITS;  // # of fractional fixed-pt bits of u4/v4
 359         gpu_unai.u_msk = (((u32)gpu_unai.TextureWindow[2]) << fb) | ((1 << fb) - 1);
 360         gpu_unai.v_msk = (((u32)gpu_unai.TextureWindow[3]) << fb) | ((1 << fb) - 1);
 361
 362         gpuSetTexture(gpu_unai.GPU_GP1);
 363       }
 364     } break;
 365
 366     case 3: {
 367       // GP0(E3h) - Set Drawing Area top left (X1,Y1)
 368       gpu_unai.DrawingArea[0] = cmd_word         & 0x3FF;
 369       gpu_unai.DrawingArea[1] = (cmd_word >> 10) & 0x3FF;
 370     } break;
 371
 372     case 4: {
 373       // GP0(E4h) - Set Drawing Area bottom right (X2,Y2)
 374       gpu_unai.DrawingArea[2] = (cmd_word         & 0x3FF) + 1;
 375       gpu_unai.DrawingArea[3] = ((cmd_word >> 10) & 0x3FF) + 1;
 376     } break;
 377
 378     case 5: {
 379       // GP0(E5h) - Set Drawing Offset (X,Y)
 380       gpu_unai.DrawingOffset[0] = ((s32)cmd_word<<(32-11))>>(32-11);
 381       gpu_unai.DrawingOffset[1] = ((s32)cmd_word<<(32-22))>>(32-11);
 382     } break;
 383
 384     case 6: {
 385       // GP0(E6h) - Mask Bit Setting
 386       gpu_unai.Masking  = (cmd_word & 0x2) <<  1;
 387       gpu_unai.PixelMSB = (cmd_word & 0x1) <<  8;
 388     } break;
 389   }
 390 }
 391 #endif
 392
 393 extern const unsigned char cmd_lengths[256];
 394
 395 int do_cmd_list(u32 *list, int list_len, int *last_cmd)
 396 {
 397   u32 cmd = 0, len, i;
 398   u32 *list_start = list;
 399   u32 *list_end = list + list_len;
 400
 401   //TODO: set ilace_mask when resolution changes instead of every time,
 402   // eliminate #ifdef below.
 403   gpu_unai.ilace_mask = gpu_unai.config.ilace_force;
 404
 405 #ifdef HAVE_PRE_ARMV7 /* XXX */
 406   gpu_unai.ilace_mask |= !!(gpu.status & PSX_GPU_STATUS_INTERLACE);
 407 #endif
 408   if (gpu_unai.config.scale_hires) {
 409     gpu_unai.ilace_mask |= !!(gpu.status & PSX_GPU_STATUS_INTERLACE);
 410   }
 411
 412   for (; list < list_end; list += 1 + len)
 413   {
 414     cmd = *list >> 24;
 415     len = cmd_lengths[cmd];
 416     if (list + 1 + len > list_end) {
 417       cmd = -1;
 418       break;
 419     }
 420
 421     #define PRIM cmd
 422     gpu_unai.PacketBuffer.U4[0] = list[0];
 423     for (i = 1; i <= len; i++)
 424       gpu_unai.PacketBuffer.U4[i] = list[i];
 425
 426     PtrUnion packet = { .ptr = (void*)&gpu_unai.PacketBuffer };
 427
 428     switch (cmd)
 429     {
 430       case 0x02:
 431         gpuClearImage(packet);
 432         break;
 433
 434       case 0x20:
 435       case 0x21:
 436       case 0x22:
 437       case 0x23: {          // Monochrome 3-pt poly
 438         PP driver = gpuPolySpanDrivers[
 439           (gpu_unai.blit_mask?1024:0) |
 440           Blending_Mode |
 441           gpu_unai.Masking | Blending | gpu_unai.PixelMSB
 442         ];
 443         gpuDrawPolyF(packet, driver, false);
 444       } break;
 445
 446       case 0x24:
 447       case 0x25:
 448       case 0x26:
 449       case 0x27: {          // Textured 3-pt poly
 450         gpuSetCLUT   (gpu_unai.PacketBuffer.U4[2] >> 16);
 451         gpuSetTexture(gpu_unai.PacketBuffer.U4[4] >> 16);
 452
 453         u32 driver_idx =
 454           (gpu_unai.blit_mask?1024:0) |
 455           Dithering |
 456           Blending_Mode | gpu_unai.TEXT_MODE |
 457           gpu_unai.Masking | Blending | gpu_unai.PixelMSB;
 458
 459         if (!FastLightingEnabled()) {
 460           driver_idx |= Lighting;
 461         } else {
 462           if (!((gpu_unai.PacketBuffer.U1[0]>0x5F) && (gpu_unai.PacketBuffer.U1[1]>0x5F) && (gpu_unai.PacketBuffer.U1[2]>0x5F)))
 463             driver_idx |= Lighting;
 464         }
 465
 466         PP driver = gpuPolySpanDrivers[driver_idx];
 467         gpuDrawPolyFT(packet, driver, false);
 468       } break;
 469
 470       case 0x28:
 471       case 0x29:
 472       case 0x2A:
 473       case 0x2B: {          // Monochrome 4-pt poly
 474         PP driver = gpuPolySpanDrivers[
 475           (gpu_unai.blit_mask?1024:0) |
 476           Blending_Mode |
 477           gpu_unai.Masking | Blending | gpu_unai.PixelMSB
 478         ];
 479         gpuDrawPolyF(packet, driver, true); // is_quad = true
 480       } break;
 481
 482       case 0x2C:
 483       case 0x2D:
 484       case 0x2E:
 485       case 0x2F: {          // Textured 4-pt poly
 486         gpuSetCLUT   (gpu_unai.PacketBuffer.U4[2] >> 16);
 487         gpuSetTexture(gpu_unai.PacketBuffer.U4[4] >> 16);
 488
 489         u32 driver_idx =
 490           (gpu_unai.blit_mask?1024:0) |
 491           Dithering |
 492           Blending_Mode | gpu_unai.TEXT_MODE |
 493           gpu_unai.Masking | Blending | gpu_unai.PixelMSB;
 494
 495         if (!FastLightingEnabled()) {
 496           driver_idx |= Lighting;
 497         } else {
 498           if (!((gpu_unai.PacketBuffer.U1[0]>0x5F) && (gpu_unai.PacketBuffer.U1[1]>0x5F) && (gpu_unai.PacketBuffer.U1[2]>0x5F)))
 499             driver_idx |= Lighting;
 500         }
 501
 502         PP driver = gpuPolySpanDrivers[driver_idx];
 503         gpuDrawPolyFT(packet, driver, true); // is_quad = true
 504       } break;
 505
 506       case 0x30:
 507       case 0x31:
 508       case 0x32:
 509       case 0x33: {          // Gouraud-shaded 3-pt poly
 510         //NOTE: The '129' here is CF_GOURAUD | CF_LIGHT, however
 511         // this is an untextured poly, so CF_LIGHT (texture blend)
 512         // shouldn't apply. Until the original array of template
 513         // instantiation ptrs is fixed, we're stuck with this. (TODO)
 514         PP driver = gpuPolySpanDrivers[
 515           (gpu_unai.blit_mask?1024:0) |
 516           Dithering |
 517           Blending_Mode |
 518           gpu_unai.Masking | Blending | 129 | gpu_unai.PixelMSB
 519         ];
 520         gpuDrawPolyG(packet, driver, false);
 521       } break;
 522
 523       case 0x34:
 524       case 0x35:
 525       case 0x36:
 526       case 0x37: {          // Gouraud-shaded, textured 3-pt poly
 527         gpuSetCLUT    (gpu_unai.PacketBuffer.U4[2] >> 16);
 528         gpuSetTexture (gpu_unai.PacketBuffer.U4[5] >> 16);
 529         PP driver = gpuPolySpanDrivers[
 530           (gpu_unai.blit_mask?1024:0) |
 531           Dithering |
 532           Blending_Mode | gpu_unai.TEXT_MODE |
 533           gpu_unai.Masking | Blending | ((Lighting)?129:0) | gpu_unai.PixelMSB
 534         ];
 535         gpuDrawPolyGT(packet, driver, false);
 536       } break;
 537
 538       case 0x38:
 539       case 0x39:
 540       case 0x3A:
 541       case 0x3B: {          // Gouraud-shaded 4-pt poly
 542         // See notes regarding '129' for 0x30..0x33 further above -senquack
 543         PP driver = gpuPolySpanDrivers[
 544           (gpu_unai.blit_mask?1024:0) |
 545           Dithering |
 546           Blending_Mode |
 547           gpu_unai.Masking | Blending | 129 | gpu_unai.PixelMSB
 548         ];
 549         gpuDrawPolyG(packet, driver, true); // is_quad = true
 550       } break;
 551
 552       case 0x3C:
 553       case 0x3D:
 554       case 0x3E:
 555       case 0x3F: {          // Gouraud-shaded, textured 4-pt poly
 556         gpuSetCLUT    (gpu_unai.PacketBuffer.U4[2] >> 16);
 557         gpuSetTexture (gpu_unai.PacketBuffer.U4[5] >> 16);
 558         PP driver = gpuPolySpanDrivers[
 559           (gpu_unai.blit_mask?1024:0) |
 560           Dithering |
 561           Blending_Mode | gpu_unai.TEXT_MODE |
 562           gpu_unai.Masking | Blending | ((Lighting)?129:0) | gpu_unai.PixelMSB
 563         ];
 564         gpuDrawPolyGT(packet, driver, true); // is_quad = true
 565       } break;
 566
 567       case 0x40:
 568       case 0x41:
 569       case 0x42:
 570       case 0x43: {          // Monochrome line
 571         // Shift index right by one, as untextured prims don't use lighting
 572         u32 driver_idx = (Blending_Mode | gpu_unai.Masking | Blending | (gpu_unai.PixelMSB>>3)) >> 1;
 573         PSD driver = gpuPixelSpanDrivers[driver_idx];
 574         gpuDrawLineF(packet, driver);
 575       } break;
 576
 577       case 0x48 ... 0x4F: { // Monochrome line strip
 578         u32 num_vertexes = 1;
 579         u32 *list_position = &(list[2]);
 580
 581         // Shift index right by one, as untextured prims don't use lighting
 582         u32 driver_idx = (Blending_Mode | gpu_unai.Masking | Blending | (gpu_unai.PixelMSB>>3)) >> 1;
 583         PSD driver = gpuPixelSpanDrivers[driver_idx];
 584         gpuDrawLineF(packet, driver);
 585
 586         while(1)
 587         {
 588           gpu_unai.PacketBuffer.U4[1] = gpu_unai.PacketBuffer.U4[2];
 589           gpu_unai.PacketBuffer.U4[2] = *list_position++;
 590           gpuDrawLineF(packet, driver);
 591
 592           num_vertexes++;
 593           if(list_position >= list_end) {
 594             cmd = -1;
 595             goto breakloop;
 596           }
 597           if((*list_position & 0xf000f000) == 0x50005000)
 598             break;
 599         }
 600
 601         len += (num_vertexes - 2);
 602       } break;
 603
 604       case 0x50:
 605       case 0x51:
 606       case 0x52:
 607       case 0x53: {          // Gouraud-shaded line
 608         // Shift index right by one, as untextured prims don't use lighting
 609         u32 driver_idx = (Blending_Mode | gpu_unai.Masking | Blending | (gpu_unai.PixelMSB>>3)) >> 1;
 610         // Index MSB selects Gouraud-shaded PixelSpanDriver:
 611         driver_idx |= (1 << 5);
 612         PSD driver = gpuPixelSpanDrivers[driver_idx];
 613         gpuDrawLineG(packet, driver);
 614       } break;
 615
 616       case 0x58 ... 0x5F: { // Gouraud-shaded line strip
 617         u32 num_vertexes = 1;
 618         u32 *list_position = &(list[2]);
 619
 620         // Shift index right by one, as untextured prims don't use lighting
 621         u32 driver_idx = (Blending_Mode | gpu_unai.Masking | Blending | (gpu_unai.PixelMSB>>3)) >> 1;
 622         // Index MSB selects Gouraud-shaded PixelSpanDriver:
 623         driver_idx |= (1 << 5);
 624         PSD driver = gpuPixelSpanDrivers[driver_idx];
 625         gpuDrawLineG(packet, driver);
 626
 627         while(1)
 628         {
 629           gpu_unai.PacketBuffer.U4[0] = gpu_unai.PacketBuffer.U4[2];
 630           gpu_unai.PacketBuffer.U4[1] = gpu_unai.PacketBuffer.U4[3];
 631           gpu_unai.PacketBuffer.U4[2] = *list_position++;
 632           gpu_unai.PacketBuffer.U4[3] = *list_position++;
 633           gpuDrawLineG(packet, driver);
 634
 635           num_vertexes++;
 636           if(list_position >= list_end) {
 637             cmd = -1;
 638             goto breakloop;
 639           }
 640           if((*list_position & 0xf000f000) == 0x50005000)
 641             break;
 642         }
 643
 644         len += (num_vertexes - 2) * 2;
 645       } break;
 646
 647       case 0x60:
 648       case 0x61:
 649       case 0x62:
 650       case 0x63: {          // Monochrome rectangle (variable size)
 651         PT driver = gpuTileSpanDrivers[(Blending_Mode | gpu_unai.Masking | Blending | (gpu_unai.PixelMSB>>3)) >> 1];
 652         gpuDrawT(packet, driver);
 653       } break;
 654
 655       case 0x64:
 656       case 0x65:
 657       case 0x66:
 658       case 0x67: {          // Textured rectangle (variable size)
 659         gpuSetCLUT    (gpu_unai.PacketBuffer.U4[2] >> 16);
 660         u32 driver_idx = Blending_Mode | gpu_unai.TEXT_MODE | gpu_unai.Masking | Blending | (gpu_unai.PixelMSB>>1);
 661
 662         //senquack - Only color 808080h-878787h allows skipping lighting calculation:
 663         // This fixes Silent Hill running animation on loading screens:
 664         // (On PSX, color values 0x00-0x7F darken the source texture's color,
 665         //  0x81-FF lighten textures (ultimately clamped to 0x1F),
 666         //  0x80 leaves source texture color unchanged, HOWEVER,
 667         //   gpu_unai uses a simple lighting LUT whereby only the upper
 668         //   5 bits of an 8-bit color are used, so 0x80-0x87 all behave as
 669         //   0x80.
 670         //
 671         // NOTE: I've changed all textured sprite draw commands here and
 672         //  elsewhere to use proper behavior, but left poly commands
 673         //  alone, I don't want to slow rendering down too much. (TODO)
 674         //if ((gpu_unai.PacketBuffer.U1[0]>0x5F) && (gpu_unai.PacketBuffer.U1[1]>0x5F) && (gpu_unai.PacketBuffer.U1[2]>0x5F))
 675         // Strip lower 3 bits of each color and determine if lighting should be used:
 676         if ((gpu_unai.PacketBuffer.U4[0] & 0xF8F8F8) != 0x808080)
 677           driver_idx |= Lighting;
 678         PS driver = gpuSpriteSpanDrivers[driver_idx];
 679         gpuDrawS(packet, driver);
 680       } break;
 681
 682       case 0x68:
 683       case 0x69:
 684       case 0x6A:
 685       case 0x6B: {          // Monochrome rectangle (1x1 dot)
 686         gpu_unai.PacketBuffer.U4[2] = 0x00010001;
 687         PT driver = gpuTileSpanDrivers[(Blending_Mode | gpu_unai.Masking | Blending | (gpu_unai.PixelMSB>>3)) >> 1];
 688         gpuDrawT(packet, driver);
 689       } break;
 690
 691       case 0x70:
 692       case 0x71:
 693       case 0x72:
 694       case 0x73: {          // Monochrome rectangle (8x8)
 695         gpu_unai.PacketBuffer.U4[2] = 0x00080008;
 696         PT driver = gpuTileSpanDrivers[(Blending_Mode | gpu_unai.Masking | Blending | (gpu_unai.PixelMSB>>3)) >> 1];
 697         gpuDrawT(packet, driver);
 698       } break;
 699
 700       case 0x74:
 701       case 0x75:
 702       case 0x76:
 703       case 0x77: {          // Textured rectangle (8x8)
 704         gpu_unai.PacketBuffer.U4[3] = 0x00080008;
 705         gpuSetCLUT    (gpu_unai.PacketBuffer.U4[2] >> 16);
 706         u32 driver_idx = Blending_Mode | gpu_unai.TEXT_MODE | gpu_unai.Masking | Blending | (gpu_unai.PixelMSB>>1);
 707
 708         //senquack - Only color 808080h-878787h allows skipping lighting calculation:
 709         //if ((gpu_unai.PacketBuffer.U1[0]>0x5F) && (gpu_unai.PacketBuffer.U1[1]>0x5F) && (gpu_unai.PacketBuffer.U1[2]>0x5F))
 710         // Strip lower 3 bits of each color and determine if lighting should be used:
 711         if ((gpu_unai.PacketBuffer.U4[0] & 0xF8F8F8) != 0x808080)
 712           driver_idx |= Lighting;
 713         PS driver = gpuSpriteSpanDrivers[driver_idx];
 714         gpuDrawS(packet, driver);
 715       } break;
 716
 717       case 0x78:
 718       case 0x79:
 719       case 0x7A:
 720       case 0x7B: {          // Monochrome rectangle (16x16)
 721         gpu_unai.PacketBuffer.U4[2] = 0x00100010;
 722         PT driver = gpuTileSpanDrivers[(Blending_Mode | gpu_unai.Masking | Blending | (gpu_unai.PixelMSB>>3)) >> 1];
 723         gpuDrawT(packet, driver);
 724       } break;
 725
 726       case 0x7C:
 727       case 0x7D:
 728 #ifdef __arm__
 729         if ((gpu_unai.GPU_GP1 & 0x180) == 0 && (gpu_unai.Masking | gpu_unai.PixelMSB) == 0)
 730         {
 731           gpuSetCLUT    (gpu_unai.PacketBuffer.U4[2] >> 16);
 732           gpuDrawS16(packet);
 733           break;
 734         }
 735         // fallthrough
 736 #endif
 737       case 0x7E:
 738       case 0x7F: {          // Textured rectangle (16x16)
 739         gpu_unai.PacketBuffer.U4[3] = 0x00100010;
 740         gpuSetCLUT    (gpu_unai.PacketBuffer.U4[2] >> 16);
 741         u32 driver_idx = Blending_Mode | gpu_unai.TEXT_MODE | gpu_unai.Masking | Blending | (gpu_unai.PixelMSB>>1);
 742         //senquack - Only color 808080h-878787h allows skipping lighting calculation:
 743         //if ((gpu_unai.PacketBuffer.U1[0]>0x5F) && (gpu_unai.PacketBuffer.U1[1]>0x5F) && (gpu_unai.PacketBuffer.U1[2]>0x5F))
 744         // Strip lower 3 bits of each color and determine if lighting should be used:
 745         if ((gpu_unai.PacketBuffer.U4[0] & 0xF8F8F8) != 0x808080)
 746           driver_idx |= Lighting;
 747         PS driver = gpuSpriteSpanDrivers[driver_idx];
 748         gpuDrawS(packet, driver);
 749       } break;
 750
 751       case 0x80:          //  vid -> vid
 752         gpuMoveImage(packet);
 753         break;
 754
 755 #ifdef TEST
 756       case 0xA0:          //  sys -> vid
 757       {
 758         u32 load_width = list[2] & 0xffff;
 759         u32 load_height = list[2] >> 16;
 760         u32 load_size = load_width * load_height;
 761
 762         len += load_size / 2;
 763       } break;
 764
 765       case 0xC0:
 766         break;
 767 #else
 768       case 0xA0:          //  sys ->vid
 769       case 0xC0:          //  vid -> sys
 770         // Handled by gpulib
 771         goto breakloop;
 772 #endif
 773       case 0xE1 ... 0xE6: { // Draw settings
 774         gpuGP0Cmd_0xEx(gpu_unai, gpu_unai.PacketBuffer.U4[0]);
 775       } break;
 776     }
 777   }
 778
 779 breakloop:
 780   gpu.ex_regs[1] &= ~0x1ff;
 781   gpu.ex_regs[1] |= gpu_unai.GPU_GP1 & 0x1ff;
 782
 783   *last_cmd = cmd;
 784   return list - list_start;
 785 }
 786
 787 void renderer_sync_ecmds(uint32_t *ecmds)
 788 {
 789   int dummy;
 790   do_cmd_list(&ecmds[1], 6, &dummy);
 791 }
 792
 793 void renderer_update_caches(int x, int y, int w, int h, int state_changed)
 794 {
 795 }
 796
 797 void renderer_flush_queues(void)
 798 {
 799 }
 800
 801 void renderer_set_interlace(int enable, int is_odd)
 802 {
 803 }
 804
 805 #include "../../frontend/plugin_lib.h"
 806 // Handle any gpulib settings applicable to gpu_unai:
 807 void renderer_set_config(const struct rearmed_cbs *cbs)
 808 {
 809   gpu_unai.vram = (u16*)gpu.vram;
 810   gpu_unai.config.ilace_force   = cbs->gpu_unai.ilace_force;
 811   gpu_unai.config.pixel_skip    = cbs->gpu_unai.pixel_skip;
 812   gpu_unai.config.lighting      = cbs->gpu_unai.lighting;
 813   gpu_unai.config.fast_lighting = cbs->gpu_unai.fast_lighting;
 814   gpu_unai.config.blending      = cbs->gpu_unai.blending;
 815   gpu_unai.config.dithering     = cbs->gpu_unai.dithering;
 816   gpu_unai.config.scale_hires   = cbs->gpu_unai.scale_hires;
 817
 818   gpu.state.downscale_enable    = gpu_unai.config.scale_hires;
 819   if (gpu_unai.config.scale_hires) {
 820     map_downscale_buffer();
 821   } else {
 822     unmap_downscale_buffer();
 823   }
 824 }
 825
 826 void renderer_sync(void)
 827 {
 828 }
 829
 830 void renderer_notify_update_lace(int updated)
 831 {
 832 }
 833
 834 // vim:shiftwidth=2:expandtab