Shamusworld >> Repos - virtualjaguar/blob - src/blitter.cpp

   1 //
   2 // Blitter core
   3 //
   4 // by Cal2
   5 // GCC/SDL port by Niels Wagenaar (Linux/WIN32) and Caz (BeOS)
   6 // Cleanups/fixes by James L. Hammons
   7 //
   8 bool specialLog = false;
   9
  10 #include "jaguar.h"
  11
  12 #define REG(A)  (((uint32)blitter_ram[(A)] << 24) | ((uint32)blitter_ram[(A)+1] << 16) \
  13                                 | ((uint32)blitter_ram[(A)+2] << 8) | (uint32)blitter_ram[(A)+3])
  14 #define WREG(A,D)       (blitter_ram[(A)] = ((D)>>24)&0xFF, blitter_ram[(A)+1] = ((D)>>16)&0xFF, \
  15                                         blitter_ram[(A)+2] = ((D)>>8)&0xFF, blitter_ram[(A)+3] = (D)&0xFF)
  16
  17 // Blitter registers (offsets from F02200)
  18
  19 #define A1_BASE                 ((UINT32)0x00)
  20 #define A1_FLAGS                ((UINT32)0x04)
  21 #define A1_CLIP                 ((UINT32)0x08)  // Height and width values for clipping
  22 #define A1_PIXEL                ((UINT32)0x0C)  // Integer part of the pixel (Y.i and X.i)
  23 #define A1_STEP                 ((UINT32)0x10)  // Integer part of the step
  24 #define A1_FSTEP                ((UINT32)0x14)  // Fractionnal part of the step
  25 #define A1_FPIXEL               ((UINT32)0x18)  // Fractionnal part of the pixel (Y.f and X.f)
  26 #define A1_INC                  ((UINT32)0x1C)  // Integer part of the increment
  27 #define A1_FINC                 ((UINT32)0x20)  // Fractional part of the increment
  28 #define A2_BASE                 ((UINT32)0x24)
  29 #define A2_FLAGS                ((UINT32)0x28)
  30 #define A2_MASK                 ((UINT32)0x2C)  // Modulo values for x and y (M.y  and M.x)
  31 #define A2_PIXEL                ((UINT32)0x30)  // Integer part of the pixel (no fractional part for A2)
  32 #define A2_STEP                 ((UINT32)0x34)  // Integer part of the step (no fractional part for A2)
  33 #define COMMAND                 ((UINT32)0x38)
  34 #define PIXLINECOUNTER  ((UINT32)0x3C)
  35 #define SRCDATA                 ((UINT32)0x40)
  36 #define DSTDATA                 ((UINT32)0x48)
  37 #define DSTZ                    ((UINT32)0x50)
  38 #define SRCZINT                 ((UINT32)0x58)
  39 #define SRCZFRAC                ((UINT32)0x60)
  40 #define PATTERNDATA             ((UINT32)0x68)
  41 #define INTENSITYINC    ((UINT32)0x70)
  42 #define ZINC                    ((UINT32)0x74)
  43 #define COLLISIONCTRL   ((UINT32)0x78)
  44 #define PHRASEINT3              ((UINT32)0x7C)
  45 #define PHRASEINT2              ((UINT32)0x80)
  46 #define PHRASEINT1              ((UINT32)0x84)
  47 #define PHRASEINT0              ((UINT32)0x88)
  48 #define PHRASEZ3                ((UINT32)0x8C)
  49 #define PHRASEZ2                ((UINT32)0x90)
  50 #define PHRASEZ1                ((UINT32)0x94)
  51 #define PHRASEZ0                ((UINT32)0x98)
  52
  53 // Blitter command bits
  54
  55 #define SRCEN                   (cmd & 0x00000001)
  56 #define SRCENZ                  (cmd & 0x00000002)
  57 #define SRCENX                  (cmd & 0x00000004)
  58 #define DSTEN                   (cmd & 0x00000008)
  59 #define DSTENZ                  (cmd & 0x00000010)
  60 #define DSTWRZ                  (cmd & 0x00000020)
  61 #define CLIPA1                  (cmd & 0x00000040)
  62
  63 #define UPDA1F                  (cmd & 0x00000100)
  64 #define UPDA1                   (cmd & 0x00000200)
  65 #define UPDA2                   (cmd & 0x00000400)
  66
  67 #define DSTA2                   (cmd & 0x00000800)
  68
  69 #define Z_OP_INF                (cmd & 0x00040000)
  70 #define Z_OP_EQU                (cmd & 0x00080000)
  71 #define Z_OP_SUP                (cmd & 0x00100000)
  72
  73 #define LFU_NAN                 (cmd & 0x00200000)
  74 #define LFU_NA                  (cmd & 0x00400000)
  75 #define LFU_AN                  (cmd & 0x00800000)
  76 #define LFU_A                   (cmd & 0x01000000)
  77
  78 #define CMPDST                  (cmd & 0x02000000)
  79 #define BCOMPEN                 (cmd & 0x04000000)
  80 #define DCOMPEN                 (cmd & 0x08000000)
  81
  82 #define PATDSEL                 (cmd & 0x00010000)
  83 #define INTADD                  (cmd & 0x00020000)
  84 #define TOPBEN                  (cmd & 0x00004000)
  85 #define TOPNEN                  (cmd & 0x00008000)
  86 #define BKGWREN                 (cmd & 0x10000000)
  87 #define GOURD                   (cmd & 0x00001000)
  88 #define GOURZ                   (cmd & 0x00002000)
  89 #define SRCSHADE                (cmd & 0x40000000)
  90
  91
  92 #define XADDPHR  0
  93 #define XADDPIX  1
  94 #define XADD0    2
  95 #define XADDINC  3
  96
  97 #define XSIGNSUB_A1             (REG(A1_FLAGS)&0x080000)
  98 #define XSIGNSUB_A2             (REG(A2_FLAGS)&0x080000)
  99
 100 #define YSIGNSUB_A1             (REG(A1_FLAGS)&0x100000)
 101 #define YSIGNSUB_A2             (REG(A2_FLAGS)&0x100000)
 102
 103 #define YADD1_A1                (REG(A1_FLAGS)&0x040000)
 104 #define YADD1_A2                (REG(A2_FLAGS)&0x040000)
 105
 106 //Put 'em back, once we fix the problem!!! [KO]
 107 // 1 bpp pixel read
 108 #define PIXEL_SHIFT_1(a)      (((~a##_x) >> 16) & 7)
 109 #define PIXEL_OFFSET_1(a)     (((((UINT32)a##_y >> 16) * a##_width / 8) + (((UINT32)a##_x >> 19) & ~7)) * (1 + a##_pitch) + (((UINT32)a##_x >> 19) & 7))
 110 #define READ_PIXEL_1(a)       ((JaguarReadByte(a##_addr+PIXEL_OFFSET_1(a), BLITTER) >> PIXEL_SHIFT_1(a)) & 0x01)
 111 //#define READ_PIXEL_1(a)       ((JaguarReadByte(a##_addr+PIXEL_OFFSET_1(a)) >> PIXEL_SHIFT_1(a)) & 0x01)
 112
 113 // 2 bpp pixel read
 114 #define PIXEL_SHIFT_2(a)      (((~a##_x) >> 15) & 6)
 115 #define PIXEL_OFFSET_2(a)     (((((UINT32)a##_y >> 16) * a##_width / 4) + (((UINT32)a##_x >> 18) & ~7)) * (1 + a##_pitch) + (((UINT32)a##_x >> 18) & 7))
 116 #define READ_PIXEL_2(a)       ((JaguarReadByte(a##_addr+PIXEL_OFFSET_2(a), BLITTER) >> PIXEL_SHIFT_2(a)) & 0x03)
 117 //#define READ_PIXEL_2(a)       ((JaguarReadByte(a##_addr+PIXEL_OFFSET_2(a)) >> PIXEL_SHIFT_2(a)) & 0x03)
 118
 119 // 4 bpp pixel read
 120 #define PIXEL_SHIFT_4(a)      (((~a##_x) >> 14) & 4)
 121 #define PIXEL_OFFSET_4(a)     (((((UINT32)a##_y >> 16) * (a##_width/2)) + (((UINT32)a##_x >> 17) & ~7)) * (1 + a##_pitch) + (((UINT32)a##_x >> 17) & 7))
 122 #define READ_PIXEL_4(a)       ((JaguarReadByte(a##_addr+PIXEL_OFFSET_4(a), BLITTER) >> PIXEL_SHIFT_4(a)) & 0x0f)
 123 //#define READ_PIXEL_4(a)       ((JaguarReadByte(a##_addr+PIXEL_OFFSET_4(a)) >> PIXEL_SHIFT_4(a)) & 0x0f)
 124
 125 // 8 bpp pixel read
 126 #define PIXEL_OFFSET_8(a)     (((((UINT32)a##_y >> 16) * a##_width) + (((UINT32)a##_x >> 16) & ~7)) * (1 + a##_pitch) + (((UINT32)a##_x >> 16) & 7))
 127 #define READ_PIXEL_8(a)       (JaguarReadByte(a##_addr+PIXEL_OFFSET_8(a), BLITTER))
 128 //#define READ_PIXEL_8(a)       (JaguarReadByte(a##_addr+PIXEL_OFFSET_8(a)))
 129
 130 // 16 bpp pixel read
 131 #define PIXEL_OFFSET_16(a)    (((((UINT32)a##_y >> 16) * a##_width) + (((UINT32)a##_x >> 16) & ~3)) * (1 + a##_pitch) + (((UINT32)a##_x >> 16) & 3))
 132 #define READ_PIXEL_16(a)       (JaguarReadWord(a##_addr+(PIXEL_OFFSET_16(a)<<1), BLITTER))
 133 //#define READ_PIXEL_16(a)       (JaguarReadWord(a##_addr+(PIXEL_OFFSET_16(a)<<1)))
 134
 135 // 32 bpp pixel read
 136 #define PIXEL_OFFSET_32(a)    (((((UINT32)a##_y >> 16) * a##_width) + (((UINT32)a##_x >> 16) & ~1)) * (1 + a##_pitch) + (((UINT32)a##_x >> 16) & 1))
 137 #define READ_PIXEL_32(a)      (JaguarReadLong(a##_addr+(PIXEL_OFFSET_32(a)<<2), BLITTER))
 138 //#define READ_PIXEL_32(a)      (JaguarReadLong(a##_addr+(PIXEL_OFFSET_32(a)<<2)))
 139
 140 // pixel read
 141 #define READ_PIXEL(a,f) (\
 142          (((f>>3)&0x07) == 0) ? (READ_PIXEL_1(a)) : \
 143          (((f>>3)&0x07) == 1) ? (READ_PIXEL_2(a)) : \
 144          (((f>>3)&0x07) == 2) ? (READ_PIXEL_4(a)) : \
 145          (((f>>3)&0x07) == 3) ? (READ_PIXEL_8(a)) : \
 146          (((f>>3)&0x07) == 4) ? (READ_PIXEL_16(a)) : \
 147          (((f>>3)&0x07) == 5) ? (READ_PIXEL_32(a)) : 0)
 148
 149 // 16 bpp z data read
 150 #define ZDATA_OFFSET_16(a)     (PIXEL_OFFSET_16(a) + a##_zoffs * 4)
 151 #define READ_ZDATA_16(a)       (JaguarReadWord(a##_addr+(ZDATA_OFFSET_16(a)<<1), BLITTER))
 152 //#define READ_ZDATA_16(a)       (JaguarReadWord(a##_addr+(ZDATA_OFFSET_16(a)<<1)))
 153
 154 // z data read
 155 #define READ_ZDATA(a,f) (READ_ZDATA_16(a))
 156
 157 // 16 bpp z data write
 158 #define WRITE_ZDATA_16(a,d)     {  JaguarWriteWord(a##_addr+(ZDATA_OFFSET_16(a)<<1), d, BLITTER); }
 159 //#define WRITE_ZDATA_16(a,d)     {  JaguarWriteWord(a##_addr+(ZDATA_OFFSET_16(a)<<1), d); }
 160
 161 // z data write
 162 #define WRITE_ZDATA(a,f,d) WRITE_ZDATA_16(a,d);
 163
 164 // 1 bpp r data read
 165 #define READ_RDATA_1(r,a,p)  ((p) ?  ((REG(r+(((UINT32)a##_x>>19)&4)))>>(((UINT32)a##_x>>16)&0x1f))&   0x1 : (REG(r) &    0x1))
 166
 167 // 2 bpp r data read
 168 #define READ_RDATA_2(r,a,p)  ((p) ?  ((REG(r+(((UINT32)a##_x>>18)&4)))>>(((UINT32)a##_x>>15)&0x3e))&   0x3 : (REG(r) &    0x3))
 169
 170 // 4 bpp r data read
 171 #define READ_RDATA_4(r,a,p)  ((p) ?  ((REG(r+(((UINT32)a##_x>>17)&4)))>>(((UINT32)a##_x>>14)&0x28))&   0xf : (REG(r) &    0xf))
 172
 173 // 8 bpp r data read
 174 #define READ_RDATA_8(r,a,p)  ((p) ?  ((REG(r+(((UINT32)a##_x>>16)&4)))>>(((UINT32)a##_x>>13)&0x18))&  0xff : (REG(r) &   0xff))
 175
 176 // 16 bpp r data read
 177 #define READ_RDATA_16(r,a,p)  ((p) ? ((REG(r+(((UINT32)a##_x>>15)&4)))>>(((UINT32)a##_x>>12)&0x10))&0xffff : (REG(r) & 0xffff))
 178
 179 // 32 bpp r data read
 180 #define READ_RDATA_32(r,a,p)  ((p) ? REG(r+(((UINT32)a##_x>>14)&4)) : REG(r))
 181
 182 // register data read
 183 #define READ_RDATA(r,a,f,p) (\
 184          (((f>>3)&0x07) == 0) ? (READ_RDATA_1(r,a,p)) : \
 185          (((f>>3)&0x07) == 1) ? (READ_RDATA_2(r,a,p)) : \
 186          (((f>>3)&0x07) == 2) ? (READ_RDATA_4(r,a,p)) : \
 187          (((f>>3)&0x07) == 3) ? (READ_RDATA_8(r,a,p)) : \
 188          (((f>>3)&0x07) == 4) ? (READ_RDATA_16(r,a,p)) : \
 189          (((f>>3)&0x07) == 5) ? (READ_RDATA_32(r,a,p)) : 0)
 190
 191 // 1 bpp pixel write
 192 #define WRITE_PIXEL_1(a,d)       { JaguarWriteByte(a##_addr+PIXEL_OFFSET_1(a), (JaguarReadByte(a##_addr+PIXEL_OFFSET_1(a), BLITTER)&(~(0x01 << PIXEL_SHIFT_1(a))))|(d<<PIXEL_SHIFT_1(a)), BLITTER); }
 193 //#define WRITE_PIXEL_1(a,d)       { JaguarWriteByte(a##_addr+PIXEL_OFFSET_1(a), (JaguarReadByte(a##_addr+PIXEL_OFFSET_1(a))&(~(0x01 << PIXEL_SHIFT_1(a))))|(d<<PIXEL_SHIFT_1(a))); }
 194
 195 // 2 bpp pixel write
 196 #define WRITE_PIXEL_2(a,d)       { JaguarWriteByte(a##_addr+PIXEL_OFFSET_2(a), (JaguarReadByte(a##_addr+PIXEL_OFFSET_2(a), BLITTER)&(~(0x03 << PIXEL_SHIFT_2(a))))|(d<<PIXEL_SHIFT_2(a)), BLITTER); }
 197 //#define WRITE_PIXEL_2(a,d)       { JaguarWriteByte(a##_addr+PIXEL_OFFSET_2(a), (JaguarReadByte(a##_addr+PIXEL_OFFSET_2(a))&(~(0x03 << PIXEL_SHIFT_2(a))))|(d<<PIXEL_SHIFT_2(a))); }
 198
 199 // 4 bpp pixel write
 200 #define WRITE_PIXEL_4(a,d)       { JaguarWriteByte(a##_addr+PIXEL_OFFSET_4(a), (JaguarReadByte(a##_addr+PIXEL_OFFSET_4(a), BLITTER)&(~(0x0f << PIXEL_SHIFT_4(a))))|(d<<PIXEL_SHIFT_4(a)), BLITTER); }
 201 //#define WRITE_PIXEL_4(a,d)       { JaguarWriteByte(a##_addr+PIXEL_OFFSET_4(a), (JaguarReadByte(a##_addr+PIXEL_OFFSET_4(a))&(~(0x0f << PIXEL_SHIFT_4(a))))|(d<<PIXEL_SHIFT_4(a))); }
 202
 203 // 8 bpp pixel write
 204 #define WRITE_PIXEL_8(a,d)       { JaguarWriteByte(a##_addr+PIXEL_OFFSET_8(a), d, BLITTER); }
 205 //#define WRITE_PIXEL_8(a,d)       { JaguarWriteByte(a##_addr+PIXEL_OFFSET_8(a), d); }
 206
 207 // 16 bpp pixel write
 208 //#define WRITE_PIXEL_16(a,d)     {  JaguarWriteWord(a##_addr+(PIXEL_OFFSET_16(a)<<1),d); }
 209 #define WRITE_PIXEL_16(a,d)     {  JaguarWriteWord(a##_addr+(PIXEL_OFFSET_16(a)<<1), d, BLITTER); if (specialLog) WriteLog("Pixel write address: %08X\n", a##_addr+(PIXEL_OFFSET_16(a)<<1)); }
 210 //#define WRITE_PIXEL_16(a,d)     {  JaguarWriteWord(a##_addr+(PIXEL_OFFSET_16(a)<<1), d); if (specialLog) WriteLog("Pixel write address: %08X\n", a##_addr+(PIXEL_OFFSET_16(a)<<1)); }
 211
 212 // 32 bpp pixel write
 213 #define WRITE_PIXEL_32(a,d)             { JaguarWriteLong(a##_addr+(PIXEL_OFFSET_32(a)<<2), d, BLITTER); }
 214 //#define WRITE_PIXEL_32(a,d)           { JaguarWriteLong(a##_addr+(PIXEL_OFFSET_32(a)<<2), d); }
 215
 216 // pixel write
 217 #define WRITE_PIXEL(a,f,d) {\
 218         switch ((f>>3)&0x07) { \
 219         case 0: WRITE_PIXEL_1(a,d);  break;  \
 220         case 1: WRITE_PIXEL_2(a,d);  break;  \
 221         case 2: WRITE_PIXEL_4(a,d);  break;  \
 222         case 3: WRITE_PIXEL_8(a,d);  break;  \
 223         case 4: WRITE_PIXEL_16(a,d); break;  \
 224         case 5: WRITE_PIXEL_32(a,d); break;  \
 225         }}
 226
 227 // External global variables
 228
 229 extern int jaguar_active_memory_dumps;
 230
 231 // Local global variables
 232
 233 int start_logging = 0;
 234 uint8 blitter_working = 0;
 235
 236 // Blitter register RAM (most of it is hidden from the user)
 237
 238 static uint8 blitter_ram[0x100];
 239
 240 // Width in Pixels of a Scanline
 241 // This is a pretranslation of the value found in the A1 & A2 flags: It's really a floating point value
 242 // of the form EEEEMM where MM is the mantissa with an implied "1." in front of it and the EEEE value is
 243 // the exponent. Valid values for the exponent range from 0 to 11 (decimal). It's easiest to think of it
 244 // as a floating point bit pattern being followed by a number of zeroes. So, e.g., 001101 translates to
 245 // 1.01 (the "1." being implied) x (2 ^ 3) or 1010 -> 10 in base 10 (i.e., 1.01 with the decimal place
 246 // being shifted to the right 3 places).
 247 static uint32 blitter_scanline_width[48] =
 248 {
 249      0,    0,    0,    0,                                       // Note: This would really translate to 1, 1, 1, 1
 250      2,    0,    0,    0,
 251      4,    0,    6,    0,
 252      8,   10,   12,   14,
 253     16,   20,   24,   28,
 254     32,   40,   48,   56,
 255     64,   80,   96,  112,
 256    128,  160,  192,  224,
 257    256,  320,  384,  448,
 258    512,  640,  768,  896,
 259   1024, 1280, 1536, 1792,
 260   2048, 2560, 3072, 3584
 261 };
 262
 263 //static uint8 * tom_ram_8;
 264 //static uint8 * paletteRam;
 265 static uint8 src;
 266 static uint8 dst;
 267 static uint8 misc;
 268 static uint8 a1ctl;
 269 static uint8 mode;
 270 static uint8 ity;
 271 static uint8 zop;
 272 static uint8 op;
 273 static uint8 ctrl;
 274 static uint32 a1_addr;
 275 static uint32 a2_addr;
 276 static int32 a1_zoffs;
 277 static int32 a2_zoffs;
 278 static uint32 xadd_a1_control;
 279 static uint32 xadd_a2_control;
 280 static int32 a1_pitch;
 281 static int32 a2_pitch;
 282 static uint32 n_pixels;
 283 static uint32 n_lines;
 284 static int32 a1_x;
 285 static int32 a1_y;
 286 static int32 a1_width;
 287 static int32 a2_x;
 288 static int32 a2_y;
 289 static int32 a2_width;
 290 static int32 a2_mask_x;
 291 static int32 a2_mask_y;
 292 static int32 a1_xadd;
 293 static int32 a1_yadd;
 294 static int32 a2_xadd;
 295 static int32 a2_yadd;
 296 static uint8 a1_phrase_mode;
 297 static uint8 a2_phrase_mode;
 298 static int32 a1_step_x = 0;
 299 static int32 a1_step_y = 0;
 300 static int32 a2_step_x = 0;
 301 static int32 a2_step_y = 0;
 302 static uint32 outer_loop;
 303 static uint32 inner_loop;
 304 static uint32 a2_psize;
 305 static uint32 a1_psize;
 306 static uint32 gouraud_add;
 307 //static uint32 gouraud_data;
 308 //static uint16 gint[4];
 309 //static uint16 gfrac[4];
 310 //static uint8  gcolour[4];
 311 static int gd_i[4];
 312 static int gd_c[4];
 313 static int gd_ia, gd_ca;
 314 static int colour_index = 0;
 315 static int32 zadd;
 316 static uint32 z_i[4];
 317
 318 static int32 a1_clip_x, a1_clip_y;
 319
 320 // In the spirit of "get it right first, *then* optimize" I've taken the liberty
 321 // of removing all the unnecessary code caching. If it turns out to be a good way
 322 // to optimize the blitter, then we may revisit it in the future...
 323
 324 //
 325 // Generic blit handler
 326 //
 327 void blitter_generic(uint32 cmd)
 328 {
 329 //Testing only!
 330 //uint32 logGo = ((cmd == 0x01800E01 && REG(A1_BASE) == 0x898000) ? 1 : 0);
 331         uint32 srcdata, srczdata, dstdata, dstzdata, writedata, inhibit;
 332
 333 if (specialLog)
 334 {
 335         WriteLog("About to do 8x8 blit (BM width is 448 pixels)...\n");
 336 }
 337         while (outer_loop--)
 338         {
 339 if (specialLog)
 340 {
 341         WriteLog("  A1_X/Y = %08X/%08X, A2_X/Y = %08X/%08X\n", a1_x, a1_y, a2_x, a2_y);
 342 }
 343                 uint32 a1_start = a1_x, a2_start = a2_x;
 344
 345                 inner_loop = n_pixels;
 346                 while (inner_loop--)
 347                 {
 348 if (specialLog)
 349 {
 350         WriteLog("    A1_X/Y = %08X/%08X, A2_X/Y = %08X/%08X\n", a1_x, a1_y, a2_x, a2_y);
 351 }
 352                         srcdata = srczdata = dstdata = dstzdata = writedata = inhibit = 0;
 353
 354                         if (!DSTA2)
 355                         {
 356                                 // load src data and Z
 357                                 if (SRCEN)
 358                                 {
 359                                         srcdata = READ_PIXEL(a2, REG(A2_FLAGS));
 360                                         if (SRCENZ)
 361                                                 srczdata = READ_ZDATA(a2, REG(A2_FLAGS));
 362                                         else if (cmd & 0x0001C020)
 363                                                 srczdata = READ_RDATA(SRCZINT, a2, REG(A2_FLAGS), a2_phrase_mode);
 364                                 }
 365                                 else
 366                                 {
 367                                         srcdata = READ_RDATA(SRCDATA, a2, REG(A2_FLAGS), a2_phrase_mode);
 368                                         if (cmd & 0x0001C020)
 369                                                 srczdata = READ_RDATA(SRCZINT, a2, REG(A2_FLAGS), a2_phrase_mode);
 370                                 }
 371
 372                                 // load dst data and Z
 373                                 if (DSTEN)
 374                                 {
 375                                         dstdata = READ_PIXEL(a1, REG(A1_FLAGS));
 376                                         if (DSTENZ)
 377                                                 dstzdata = READ_ZDATA(a1, REG(A1_FLAGS));
 378                                         else
 379                                                 dstzdata = READ_RDATA(DSTZ, a1, REG(A1_FLAGS), a1_phrase_mode);
 380                                 }
 381                                 else
 382                                 {
 383                                         dstdata = READ_RDATA(DSTDATA, a1, REG(A1_FLAGS), a1_phrase_mode);
 384                                         if (DSTENZ)
 385                                                 dstzdata = READ_RDATA(DSTZ, a1, REG(A1_FLAGS), a1_phrase_mode);
 386                                 }
 387
 388 /*This wasn't working...                                // a1 clipping
 389                                 if (cmd & 0x00000040)
 390                                 {
 391                                         if (a1_x < 0 || a1_y < 0 || (a1_x >> 16) >= (REG(A1_CLIP) & 0x7FFF)
 392                                                 || (a1_y >> 16) >= ((REG(A1_CLIP) >> 16) & 0x7FFF))
 393                                                 inhibit = 1;
 394                                 }//*/
 395
 396                                 if (GOURZ)
 397                                         srczdata = z_i[colour_index] >> 16;
 398
 399                                 // apply z comparator
 400                                 if (Z_OP_INF) if (srczdata <  dstzdata) inhibit = 1;
 401                                 if (Z_OP_EQU) if (srczdata == dstzdata) inhibit = 1;
 402                                 if (Z_OP_SUP) if (srczdata >  dstzdata) inhibit = 1;
 403
 404                                 // apply data comparator
 405 // Note: DCOMPEN only works in 8/16 bpp modes! !!! FIX !!!
 406 // Does BCOMPEN only work in 1 bpp mode???
 407                                 if (DCOMPEN | BCOMPEN)
 408                                 {
 409                                         if (!CMPDST)
 410                                         {
 411 //WriteLog("Blitter: BCOMPEN set on command %08X inhibit prev:%u, now:", cmd, inhibit);
 412                                                 // compare source pixel with pattern pixel
 413 /*
 414 Blit! (000B8250 <- 0012C3A0) count: 16 x 1, A1/2_FLAGS: 00014420/00012000 [cmd: 05810001]
 415  CMD -> src: SRCEN  dst:  misc:  a1ctl:  mode:  ity: PATDSEL z-op:  op: LFU_REPLACE ctrl: BCOMPEN
 416   A1 -> pitch: 1 phrases, depth: 16bpp, z-off: 0, width: 384 (22), addctl: XADDPIX YADD0 XSIGNADD YSIGNADD
 417   A2 -> pitch: 1 phrases, depth: 1bpp, z-off: 0, width: 16 (10), addctl: XADDPIX YADD0 XSIGNADD YSIGNADD
 418         x/y: 0/20
 419 ...
 420 */
 421 // AvP is still wrong, could be cuz it's doing A1 -> A2...
 422
 423 // Src is the 1bpp bitmap... DST is the PATTERN!!!
 424 // This seems to solve at least ONE of the problems with MC3D...
 425 // Why should this be inverted???
 426 // Bcuz it is. This is supposed to be used only for a bit -> pixel expansion...
 427 /*                                              if (srcdata == READ_RDATA(PATTERNDATA, a2, REG(A2_FLAGS), a2_phrase_mode))
 428 //                                              if (srcdata != READ_RDATA(PATTERNDATA, a2, REG(A2_FLAGS), a2_phrase_mode))
 429                                                         inhibit = 1;//*/
 430 /*                                              uint32 A2bpp = 1 << ((REG(A2_FLAGS) >> 3) & 0x07);
 431                                                 if (A2bpp == 1 || A2bpp == 16 || A2bpp == 8)
 432                                                         inhibit = (srcdata == 0 ? 1: 0);
 433 //                                                      inhibit = !srcdata;
 434                                                 else
 435                                                         WriteLog("Blitter: Bad BPP (%u) selected for BCOMPEN mode!\n", A2bpp);//*/
 436 // What it boils down to is this:
 437                                                 if (srcdata == 0)
 438                                                         inhibit = 1;//*/
 439                                         }
 440                                         else
 441                                         {
 442                                                 // compare destination pixel with pattern pixel
 443                                                 if (dstdata == READ_RDATA(PATTERNDATA, a1, REG(A1_FLAGS), a1_phrase_mode))
 444 //                                              if (dstdata != READ_RDATA(PATTERNDATA, a1, REG(A1_FLAGS), a1_phrase_mode))
 445                                                         inhibit = 1;
 446                                         }
 447
 448 // This is DEFINITELY WRONG
 449 //                                      if (a1_phrase_mode || a2_phrase_mode)
 450 //                                              inhibit = !inhibit;
 451                                 }
 452
 453                                 if (CLIPA1)
 454                                 {
 455                                         inhibit |= (((a1_x >> 16) < a1_clip_x && (a1_x >> 16) >= 0
 456                                                 && (a1_y >> 16) < a1_clip_y && (a1_y >> 16) >= 0) ? 0 : 1);
 457                                 }
 458
 459                                 // compute the write data and store
 460                                 if (!inhibit)
 461                                 {
 462                                         if (PATDSEL)
 463                                         {
 464                                                 // use pattern data for write data
 465                                                 writedata = READ_RDATA(PATTERNDATA, a1, REG(A1_FLAGS), a1_phrase_mode);
 466                                         }
 467                                         else if (INTADD)
 468                                         {
 469                                                 // intensity addition
 470                                                 writedata = (srcdata & 0xFF) + (dstdata & 0xFF);
 471                                                 if (!(TOPBEN) && writedata > 0xFF)
 472                                                         writedata = 0xFF;
 473                                                 writedata |= (srcdata & 0xF00) + (dstdata & 0xF00);
 474                                                 if (!(TOPNEN) && writedata > 0xFFF)
 475                                                         writedata = 0xFFF;
 476                                                 writedata |= (srcdata & 0xF000) + (dstdata & 0xF000);
 477                                         }
 478                                         else
 479                                         {
 480                                                 if (LFU_NAN) writedata |= ~srcdata & ~dstdata;
 481                                                 if (LFU_NA)  writedata |= ~srcdata & dstdata;
 482                                                 if (LFU_AN)  writedata |= srcdata  & ~dstdata;
 483                                                 if (LFU_A)       writedata |= srcdata  & dstdata;
 484                                         }
 485
 486                                         if (GOURD)
 487                                                 writedata = ((gd_c[colour_index]) << 8) | (gd_i[colour_index] >> 16);
 488
 489                                         if (SRCSHADE)
 490                                         {
 491                                                 int intensity = srcdata & 0xFF;
 492                                                 int ia = gd_ia >> 16;
 493                                                 if (ia & 0x80)
 494                                                         ia = 0xFFFFFF00 | ia;
 495                                                 intensity += ia;
 496                                                 if (intensity < 0)
 497                                                         intensity = 0;
 498                                                 if (intensity > 0xFF)
 499                                                         intensity = 0xFF;
 500                                                 writedata = (srcdata & 0xFF00) | intensity;
 501                                         }
 502                                 }
 503                                 else
 504                                 {
 505                                         writedata = dstdata;
 506                                         srczdata = dstzdata;
 507                                 }
 508
 509                                 if (/*a1_phrase_mode || */BKGWREN || !inhibit)
 510                                 {
 511 /*if (((REG(A1_FLAGS) >> 3) & 0x07) == 5)
 512 {
 513         uint32 offset = a1_addr+(PIXEL_OFFSET_32(a1)<<2);
 514 // (((((UINT32)a##_y >> 16) * a##_width) + (((UINT32)a##_x >> 16) & ~1)) * (1 + a##_pitch) + (((UINT32)a##_x >> 16) & 1))
 515         if ((offset >= 0x1FF020 && offset <= 0x1FF03F) || (offset >= 0x1FF820 && offset <= 0x1FF83F))
 516                 WriteLog("32bpp pixel write: A1 Phrase mode --> ");
 517 }//*/
 518                                         // write to the destination
 519                                         WRITE_PIXEL(a1, REG(A1_FLAGS), writedata);
 520                                         if (DSTWRZ)
 521                                                 WRITE_ZDATA(a1, REG(A1_FLAGS), srczdata);
 522                                 }
 523                         }
 524                         else    // if (DSTA2)
 525                         {
 526                                 // load src data and Z
 527                                 if (SRCEN)
 528                                 {
 529                                         srcdata = READ_PIXEL(a1, REG(A1_FLAGS));
 530                                         if (SRCENZ)
 531                                                 srczdata = READ_ZDATA(a1, REG(A1_FLAGS));
 532                                         else if (cmd & 0x0001C020)
 533                                                 srczdata = READ_RDATA(SRCZINT, a1, REG(A1_FLAGS), a1_phrase_mode);
 534                                 }
 535                                 else
 536                                 {
 537                                         srcdata = READ_RDATA(SRCDATA, a1, REG(A1_FLAGS), a1_phrase_mode);
 538                                         if (cmd & 0x001C020)
 539                                                 srczdata = READ_RDATA(SRCZINT, a1, REG(A1_FLAGS), a1_phrase_mode);
 540                                 }
 541
 542                                 // load dst data and Z
 543                                 if (DSTEN)
 544                                 {
 545                                         dstdata = READ_PIXEL(a2, REG(A2_FLAGS));
 546                                         if (DSTENZ)
 547                                                 dstzdata = READ_ZDATA(a2, REG(A2_FLAGS));
 548                                         else
 549                                                 dstzdata = READ_RDATA(DSTZ, a2, REG(A2_FLAGS), a2_phrase_mode);
 550                                 }
 551                                 else
 552                                 {
 553                                         dstdata = READ_RDATA(DSTDATA, a2, REG(A2_FLAGS), a2_phrase_mode);
 554                                         if (DSTENZ)
 555                                                 dstzdata = READ_RDATA(DSTZ, a2, REG(A2_FLAGS), a2_phrase_mode);
 556                                 }
 557
 558                                 if (GOURZ)
 559                                         srczdata = z_i[colour_index] >> 16;
 560
 561                                 // apply z comparator
 562                                 if (Z_OP_INF) if (srczdata < dstzdata)  inhibit = 1;
 563                                 if (Z_OP_EQU) if (srczdata == dstzdata) inhibit = 1;
 564                                 if (Z_OP_SUP) if (srczdata > dstzdata)  inhibit = 1;
 565
 566                                 // apply data comparator
 567 //NOTE: The bit comparator (BCOMPEN) is NOT the same at the data comparator!
 568                                 if (DCOMPEN | BCOMPEN)
 569                                 {
 570                                         if (!CMPDST)
 571                                         {
 572                                                 // compare source pixel with pattern pixel
 573 // AvP: Numbers are correct, but sprites are not!
 574 //This doesn't seem to be a problem... But could still be wrong...
 575 /*                                              if (srcdata == READ_RDATA(PATTERNDATA, a1, REG(A1_FLAGS), a1_phrase_mode))
 576 //                                              if (srcdata != READ_RDATA(PATTERNDATA, a1, REG(A1_FLAGS), a1_phrase_mode))
 577                                                         inhibit = 1;//*/
 578 // This is probably not 100% correct... It works in the 1bpp case
 579 // (in A1 <- A2 mode, that is...)
 580 // AvP: This is causing blocks to be written instead of bit patterns...
 581 // Works now...
 582 // NOTE: We really should separate out the BCOMPEN & DCOMPEN stuff!
 583 /*                                              uint32 A1bpp = 1 << ((REG(A1_FLAGS) >> 3) & 0x07);
 584                                                 if (A1bpp == 1 || A1bpp == 16 || A1bpp == 8)
 585                                                         inhibit = (srcdata == 0 ? 1: 0);
 586                                                 else
 587                                                         WriteLog("Blitter: Bad BPP (%u) selected for BCOMPEN mode!\n", A1bpp);//*/
 588 // What it boils down to is this:
 589                                                 if (srcdata == 0)
 590                                                         inhibit = 1;//*/
 591                                         }
 592                                         else
 593                                         {
 594                                                 // compare destination pixel with pattern pixel
 595                                                 if (dstdata == READ_RDATA(PATTERNDATA, a2, REG(A2_FLAGS), a2_phrase_mode))
 596 //                                              if (dstdata != READ_RDATA(PATTERNDATA, a2, REG(A2_FLAGS), a2_phrase_mode))
 597                                                         inhibit = 1;
 598                                         }
 599
 600 // This is DEFINITELY WRONG
 601 //                                      if (a1_phrase_mode || a2_phrase_mode)
 602 //                                              inhibit = !inhibit;
 603                                 }
 604
 605                                 if (CLIPA1)
 606                                 {
 607                                         inhibit |= (((a1_x >> 16) < a1_clip_x && (a1_x >> 16) >= 0
 608                                                 && (a1_y >> 16) < a1_clip_y && (a1_y >> 16) >= 0) ? 0 : 1);
 609                                 }
 610
 611                                 // compute the write data and store
 612                                 if (!inhibit)
 613                                 {
 614                                         if (PATDSEL)
 615                                         {
 616                                                 // use pattern data for write data
 617                                                 writedata= READ_RDATA(PATTERNDATA, a2, REG(A2_FLAGS), a2_phrase_mode);
 618                                         }
 619                                         else if (INTADD)
 620                                         {
 621                                                 // intensity addition
 622                                                 writedata = (srcdata & 0xFF) + (dstdata & 0xFF);
 623                                                 if (!(TOPBEN) && writedata > 0xFF)
 624                                                         writedata = 0xFF;
 625                                                 writedata |= (srcdata & 0xF00) + (dstdata & 0xF00);
 626                                                 if (!(TOPNEN) && writedata > 0xFFF)
 627                                                         writedata = 0xFFF;
 628                                                 writedata |= (srcdata & 0xF000) + (dstdata & 0xF000);
 629                                         }
 630                                         else
 631                                         {
 632                                                 if (LFU_NAN)
 633                                                         writedata |= ~srcdata & ~dstdata;
 634                                                 if (LFU_NA)
 635                                                         writedata |= ~srcdata & dstdata;
 636                                                 if (LFU_AN)
 637                                                         writedata |= srcdata & ~dstdata;
 638                                                 if (LFU_A)
 639                                                         writedata |= srcdata & dstdata;
 640                                         }
 641
 642                                         if (GOURD)
 643                                                 writedata = ((gd_c[colour_index]) << 8) | (gd_i[colour_index] >> 16);
 644
 645                                         if (SRCSHADE)
 646                                         {
 647                                                 int intensity = srcdata & 0xFF;
 648                                                 int ia = gd_ia >> 16;
 649                                                 if (ia & 0x80)
 650                                                         ia = 0xFFFFFF00 | ia;
 651                                                 intensity += ia;
 652                                                 if (intensity < 0)
 653                                                         intensity = 0;
 654                                                 if (intensity > 0xFF)
 655                                                         intensity = 0xFF;
 656                                                 writedata = (srcdata & 0xFF00) | intensity;
 657                                         }
 658                                 }
 659                                 else
 660                                 {
 661                                         writedata = dstdata;
 662                                         srczdata = dstzdata;
 663                                 }
 664
 665                                 if (/*a2_phrase_mode || */BKGWREN || !inhibit)
 666                                 {
 667 /*if (logGo)
 668 {
 669         uint32 offset = a2_addr+(PIXEL_OFFSET_16(a2)<<1);
 670 // (((((UINT32)a##_y >> 16) * a##_width) + (((UINT32)a##_x >> 16) & ~1)) * (1 + a##_pitch) + (((UINT32)a##_x >> 16) & 1))
 671         WriteLog("[%08X:%04X] ", offset, writedata);
 672 }//*/
 673                                         // write to the destination
 674                                         WRITE_PIXEL(a2, REG(A2_FLAGS), writedata);
 675                                         if (DSTWRZ)
 676                                                 WRITE_ZDATA(a2, REG(A2_FLAGS), srczdata);
 677                                 }
 678                         }
 679
 680                         // update x and y
 681                         a1_x += a1_xadd;
 682                         a1_y += a1_yadd;
 683                         a2_x = (a2_x + a2_xadd) & a2_mask_x;
 684                         a2_y = (a2_y + a2_yadd) & a2_mask_y;
 685
 686                         if (GOURZ)
 687                                 z_i[colour_index] += zadd;
 688
 689                         if (GOURD || SRCSHADE)
 690                         {
 691                                 gd_i[colour_index] += gd_ia;
 692                                 gd_c[colour_index] += gd_ca;
 693                         }
 694                         if (GOURD || SRCSHADE || GOURZ)
 695                         {
 696                                 if (a1_phrase_mode)
 697                                         colour_index = (colour_index + 1) & 0x03;
 698                         }
 699                 }
 700
 701                 //New: Phrase mode taken into account! :-p
 702                 if (a1_phrase_mode)
 703                 {
 704                         // Bump the pointer to the next phrase boundary
 705                         // Even though it works, this is crappy... Clean it up!
 706                         uint32 size = 64 / a1_psize;
 707
 708                         // Crappy kludge... ('aligning' source to destination)
 709                         if (a2_phrase_mode && DSTA2)
 710                         {
 711                                 uint32 extra = (a2_start >> 16) % size;
 712                                 a1_x += extra << 16;
 713                         }
 714
 715                         uint32 newx = (a1_x >> 16) / size;
 716                         uint32 newxrem = (a1_x >> 16) % size;
 717                         a1_x &= 0x0000FFFF;
 718                         a1_x |= (((newx + (newxrem == 0 ? 0 : 1)) * size) & 0xFFFF) << 16;
 719                 }
 720
 721                 if (a2_phrase_mode)
 722                 {
 723                         // Bump the pointer to the next phrase boundary
 724                         // Even though it works, this is crappy... Clean it up!
 725                         uint32 size = 64 / a2_psize;
 726
 727                         // Crappy kludge... ('aligning' source to destination)
 728                         // Prolly should do this for A1 channel as well...
 729                         if (a1_phrase_mode && !DSTA2)
 730                         {
 731                                 uint32 extra = (a1_start >> 16) % size;
 732                                 a2_x += extra << 16;
 733                         }
 734
 735                         uint32 newx = (a2_x >> 16) / size;
 736                         uint32 newxrem = (a2_x >> 16) % size;
 737                         a2_x &= 0x0000FFFF;
 738                         a2_x |= (((newx + (newxrem == 0 ? 0 : 1) /*+ extra*/) * size) & 0xFFFF) << 16;
 739                 }
 740
 741                 //Not entirely: This still mucks things up... !!! FIX !!!
 742                 a1_x += a1_step_x;
 743                 a1_y += a1_step_y;
 744                 a2_x += a2_step_x;
 745                 a2_y += a2_step_y;//*/
 746
 747 /*              if (a2_phrase_mode)
 748                 {
 749                         a1_x+=(64/a1_psize)*a1_xadd;
 750                 }
 751                 if (a2_phrase_mode)
 752                 {
 753                         for (int nb=0;nb<(64/a2_psize)+1;nb++)
 754                                 a2_x = (a2_x + a2_xadd) & a2_mask_x;
 755                 }
 756 */      }
 757
 758         // write values back to registers
 759         WREG(A1_PIXEL,  (a1_y & 0xFFFF0000) | ((a1_x >> 16) & 0xFFFF));
 760         WREG(A1_FPIXEL, (a1_y << 16) | (a1_x & 0xFFFF));
 761         WREG(A2_PIXEL,  (a2_y & 0xFFFF0000) | ((a2_x >> 16) & 0xFFFF));
 762 specialLog = false;
 763 }
 764
 765 void blitter_blit(uint32 cmd)
 766 {
 767         uint32 pitchValue[4] = { 0, 1, 3, 2 };
 768         colour_index = 0;
 769         src = cmd & 0x07;
 770         dst = (cmd >> 3) & 0x07;
 771         misc = (cmd >> 6) & 0x03;
 772         a1ctl = (cmd >> 8) & 0x7;
 773         mode = (cmd >> 11) & 0x07;
 774         ity = (cmd >> 14) & 0x0F;
 775         zop = (cmd >> 18) & 0x07;
 776         op = (cmd >> 21) & 0x0F;
 777         ctrl = (cmd >> 25) & 0x3F;
 778
 779         // Addresses in A1/2_BASE are *phrase* aligned, i.e., bottom three bits are ignored!
 780         // NOTE: This fixes Rayman's bad collision detection AND keeps T2K working!
 781         a1_addr = REG(A1_BASE) & 0xFFFFFFF8;
 782         a2_addr = REG(A2_BASE) & 0xFFFFFFF8;
 783
 784         a1_zoffs = (REG(A1_FLAGS) >> 6) & 7;
 785         a2_zoffs = (REG(A2_FLAGS) >> 6) & 7;
 786
 787         xadd_a1_control = (REG(A1_FLAGS) >> 16) & 0x03;
 788         xadd_a2_control = (REG(A2_FLAGS) >> 16) & 0x03;
 789 //      a1_pitch = (REG(A1_FLAGS) & 3) ^ ((REG(A1_FLAGS) & 2) >> 1);
 790 //      a2_pitch = (REG(A2_FLAGS) & 3) ^ ((REG(A2_FLAGS) & 2) >> 1);
 791         a1_pitch = pitchValue[(REG(A1_FLAGS) & 0x03)];
 792         a2_pitch = pitchValue[(REG(A2_FLAGS) & 0x03)];
 793
 794         n_pixels = REG(PIXLINECOUNTER) & 0xFFFF;
 795         n_lines = (REG(PIXLINECOUNTER) >> 16) & 0xFFFF;
 796
 797         a1_x = (REG(A1_PIXEL) << 16) | (REG(A1_FPIXEL) & 0xFFFF);
 798         a1_y = (REG(A1_PIXEL) & 0xFFFF0000) | (REG(A1_FPIXEL) >> 16);
 799 //According to the JTRM, X is restricted to 15 bits and Y is restricted to 12.
 800 //But it seems to fuck up T2K! !!! FIX !!!
 801 //Could it be sign extended??? Doesn't seem to be so according to JTRM
 802 //      a1_x &= 0x7FFFFFFF, a1_y &= 0x0FFFFFFF;
 803
 804 //      a1_width = blitter_scanline_width[((REG(A1_FLAGS) & 0x00007E00) >> 9)];
 805 // According to JTRM, this must give a *whole number* of phrases in the current
 806 // pixel size (this means the lookup above is WRONG)... !!! FIX !!!
 807         UINT32 m = (REG(A1_FLAGS) >> 9) & 0x03, e = (REG(A1_FLAGS) >> 11) & 0x0F;
 808         a1_width = ((0x04 | m) << e) >> 2;//*/
 809
 810         a2_x = (REG(A2_PIXEL) & 0x0000FFFF) << 16;
 811         a2_y = (REG(A2_PIXEL) & 0xFFFF0000);
 812 //According to the JTRM, X is restricted to 15 bits and Y is restricted to 12.
 813 //But it seems to fuck up T2K! !!! FIX !!!
 814 //      a2_x &= 0x7FFFFFFF, a2_y &= 0x0FFFFFFF;
 815
 816 //      a2_width = blitter_scanline_width[((REG(A2_FLAGS) & 0x00007E00) >> 9)];
 817 // According to JTRM, this must give a *whole number* of phrases in the current
 818 // pixel size (this means the lookup above is WRONG)... !!! FIX !!!
 819         m = (REG(A2_FLAGS) >> 9) & 0x03, e = (REG(A2_FLAGS) >> 11) & 0x0F;
 820         a2_width = ((0x04 | m) << e) >> 2;//*/
 821         a2_mask_x = ((REG(A2_MASK) & 0x0000FFFF) << 16) | 0xFFFF;
 822         a2_mask_y = (REG(A2_MASK) & 0xFFFF0000) | 0xFFFF;
 823
 824         // Check for "use mask" flag
 825         if (!(REG(A2_FLAGS) & 0x8000))
 826         {
 827                 a2_mask_x = 0xFFFFFFFF; // must be 16.16
 828                 a2_mask_y = 0xFFFFFFFF; // must be 16.16
 829         }
 830
 831         a1_phrase_mode = 0;
 832
 833         // According to the official documentation, a hardware bug ties A2's yadd bit to A1's...
 834         a2_yadd = a1_yadd = (YADD1_A1 ? 1 << 16 : 0);
 835
 836         if (YSIGNSUB_A1)
 837                 a1_yadd = -a1_yadd;
 838
 839         // determine a1_xadd
 840         switch (xadd_a1_control)
 841         {
 842         case XADDPHR:
 843 // This is a documented Jaguar bug relating to phrase mode and truncation... Look into it!
 844                 // add phrase offset to X and truncate
 845                 a1_xadd = 1 << 16;
 846                 a1_phrase_mode = 1;
 847                 break;
 848         case XADDPIX:
 849                 // add pixelsize (1) to X
 850                 a1_xadd = 1 << 16;
 851                 break;
 852         case XADD0:
 853                 // add zero (for those nice vertical lines)
 854                 a1_xadd = 0;
 855                 break;
 856         case XADDINC:
 857                 // add the contents of the increment register
 858                 a1_xadd = (REG(A1_INC) << 16)            | (REG(A1_FINC) & 0xFFFF);
 859                 a1_yadd = (REG(A1_INC) & 0xFFFF0000) | (REG(A1_FINC) >> 16);
 860                 break;
 861         }
 862         if (XSIGNSUB_A1)
 863                 a1_xadd = -a1_xadd;
 864
 865         if (YSIGNSUB_A2)
 866                 a2_yadd = -a2_yadd;
 867
 868         a2_phrase_mode = 0;
 869
 870         // determine a2_xadd
 871         switch (xadd_a2_control)
 872         {
 873         case XADDPHR:
 874                 // add phrase offset to X and truncate
 875                 a2_xadd = 1 << 16;
 876                 a2_phrase_mode = 1;
 877                 break;
 878         case XADDPIX:
 879                 // add pixelsize (1) to X
 880                 a2_xadd = 1 << 16;
 881                 break;
 882         case XADD0:
 883                 // add zero (for those nice vertical lines)
 884                 a2_xadd = 0;
 885                 break;
 886 //This really isn't a valid bit combo for A2... Shouldn't this cause the blitter to just say no?
 887         case XADDINC:
 888 WriteLog("BLIT: Asked to use invalid bit combo (XADDINC) for A2...\n");
 889                 // add the contents of the increment register
 890                 // since there is no register for a2 we just add 1
 891 //Let's do nothing, since it's not listed as a valid bit combo...
 892 //              a2_xadd = 1 << 16;
 893                 break;
 894         }
 895         if (XSIGNSUB_A2)
 896                 a2_xadd = -a2_xadd;
 897
 898         // Modify outer loop steps based on blitter command
 899
 900         a1_step_x = 0;
 901         a1_step_y = 0;
 902         a2_step_x = 0;
 903         a2_step_y = 0;
 904
 905         if (UPDA1F)
 906                 a1_step_x = (REG(A1_FSTEP) & 0xFFFF),
 907                 a1_step_y = (REG(A1_FSTEP) >> 16);
 908
 909         if (UPDA1)
 910                 a1_step_x |= ((REG(A1_STEP) & 0x0000FFFF) << 16),
 911                 a1_step_y |= ((REG(A1_STEP) & 0xFFFF0000));
 912
 913         if (UPDA2)
 914                 a2_step_x = (REG(A2_STEP) & 0x0000FFFF) << 16,
 915                 a2_step_y = (REG(A2_STEP) & 0xFFFF0000);
 916
 917         outer_loop = n_lines;
 918
 919         // Clipping...
 920
 921         if (CLIPA1)
 922                 a1_clip_x = REG(A1_CLIP) & 0x7FFF,
 923                 a1_clip_y = (REG(A1_CLIP) >> 16) & 0x7FFF;
 924
 925 // This phrase sizing is incorrect as well... !!! FIX !!!
 926 // Err, this is pixel size... (and it's OK)
 927         a2_psize = 1 << ((REG(A2_FLAGS) >> 3) & 0x07);
 928         a1_psize = 1 << ((REG(A1_FLAGS) >> 3) & 0x07);
 929
 930         // zbuffering
 931         if (GOURZ)
 932         {
 933                 zadd = JaguarReadLong(0xF02274, BLITTER);
 934
 935                 for(int v=0; v<4; v++)
 936                         z_i[v] = (int32)JaguarReadLong(0xF0228C + (v << 2), BLITTER);
 937         }
 938         if (GOURD || GOURZ || SRCSHADE)
 939         {
 940                 // gouraud shading
 941                 gouraud_add = JaguarReadLong(0xF02270, BLITTER);
 942
 943                 gd_c[0] = JaguarReadByte(0xF02268, BLITTER);
 944                 gd_i[0] = JaguarReadByte(0xF02269, BLITTER);
 945                 gd_i[0] <<= 16;
 946                 gd_i[0] |= JaguarReadWord(0xF02240, BLITTER);
 947
 948                 gd_c[1] = JaguarReadByte(0xF0226A, BLITTER);
 949                 gd_i[1] = JaguarReadByte(0xF0226B, BLITTER);
 950                 gd_i[1] <<= 16;
 951                 gd_i[1] |= JaguarReadWord(0xF02242, BLITTER);
 952
 953                 gd_c[2] = JaguarReadByte(0xF0226C, BLITTER);
 954                 gd_i[2] = JaguarReadByte(0xF0226D, BLITTER);
 955                 gd_i[2] <<= 16;
 956                 gd_i[2] |= JaguarReadWord(0xF02244, BLITTER);
 957
 958                 gd_c[3] = JaguarReadByte(0xF0226E, BLITTER);
 959                 gd_i[3] = JaguarReadByte(0xF0226F, BLITTER);
 960                 gd_i[3] <<= 16;
 961                 gd_i[3] |= JaguarReadWord(0xF02246, BLITTER);
 962
 963                 gd_ia = gouraud_add & 0xFFFFFF;
 964                 if (gd_ia & 0x800000)
 965                         gd_ia = 0xFF000000 | gd_ia;
 966
 967                 gd_ca = (gouraud_add>>24) & 0xFF;
 968                 if (gd_ca & 0x80)
 969                         gd_ca = 0xFFFFFF00 | gd_ca;
 970         }
 971
 972         // fix for zoop! and syndicate
 973 /*      if ((jaguar_mainRom_crc32==0x501be17c)||
 974                 (jaguar_mainRom_crc32==0x70895c51)||
 975                 (jaguar_mainRom_crc32==0x0f1f1497)||
 976                 (jaguar_mainRom_crc32==0xfc8f0dcd)
 977            )
 978         {
 979                 if (a1_step_x < 0)
 980                         a1_step_x = (-n_pixels) * 65536;
 981
 982                 if (a2_step_x < 0)
 983                         a2_step_x = (-n_pixels) * 65536;;
 984         }
 985         else
 986         // fix for wolfenstein 3d
 987         if (jaguar_mainRom_crc32==0x3966698f)
 988         {
 989                 if (n_pixels==24)
 990                 {
 991                         if ((a1_step_x / 65536)==-28)
 992                         {
 993                                 a1_step_x=-24*65536; // au lieu de -28
 994                                 a2_step_x=  0*65536; // au lieu de -8
 995                         }
 996                 }
 997         }
 998         else
 999         // fix for Tempest 2000
1000         if (jaguar_mainRom_crc32==0x32816d44)
1001         {
1002
1003                 if ((n_lines!=1)&&((n_pixels==288)||(n_pixels==384)))
1004                 {
1005                         WriteLog("Blit!\n");
1006                         WriteLog("  cmd      = 0x%.8x\n",cmd);
1007                         WriteLog("  a1_base  = %08X\n", a1_addr);
1008                         WriteLog("  a1_pitch = %d\n", a1_pitch);
1009                         WriteLog("  a1_psize = %d\n", a1_psize);
1010                         WriteLog("  a1_width = %d\n", a1_width);
1011                         WriteLog("  a1_xadd  = %f (phrase=%d)\n", (float)a1_xadd / 65536.0, a1_phrase_mode);
1012                         WriteLog("  a1_yadd  = %f\n", (float)a1_yadd / 65536.0);
1013                         WriteLog("  a1_xstep = %f\n", (float)a1_step_x / 65536.0);
1014                         WriteLog("  a1_ystep = %f\n", (float)a1_step_y / 65536.0);
1015                         WriteLog("  a1_x     = %f\n", (float)a1_x / 65536.0);
1016                         WriteLog("  a1_y     = %f\n", (float)a1_y / 65536.0);
1017                         WriteLog("  a1_zoffs = %i\n",a1_zoffs);
1018
1019                         WriteLog("  a2_base  = %08X\n", a2_addr);
1020                         WriteLog("  a2_pitch = %d\n", a2_pitch);
1021                         WriteLog("  a2_psize = %d\n", a2_psize);
1022                         WriteLog("  a2_width = %d\n", a2_width);
1023                         WriteLog("  a2_xadd  = %f (phrase=%d)\n", (float)a2_xadd / 65536.0, a2_phrase_mode);
1024                         WriteLog("  a2_yadd  = %f\n", (float)a2_yadd / 65536.0);
1025                         WriteLog("  a2_xstep = %f\n", (float)a2_step_x / 65536.0);
1026                         WriteLog("  a2_ystep = %f\n", (float)a2_step_y / 65536.0);
1027                         WriteLog("  a2_x     = %f\n", (float)a2_x / 65536.0);
1028                         WriteLog("  a2_y     = %f\n", (float)a2_y / 65536.0);
1029                         WriteLog("  a2_mask_x= 0x%.4x\n",a2_mask_x);
1030                         WriteLog("  a2_mask_y= 0x%.4x\n",a2_mask_y);
1031                         WriteLog("  a2_zoffs = %i\n",a2_zoffs);
1032
1033                         WriteLog("  count    = %d x %d\n", n_pixels, n_lines);
1034
1035                         WriteLog("  command  = %08X\n", cmd);
1036                         WriteLog("  dsten    = %i\n",DSTEN);
1037                         WriteLog("  srcen    = %i\n",SRCEN);
1038                         WriteLog("  patdsel  = %i\n",PATDSEL);
1039                         WriteLog("  color    = 0x%.8x\n",REG(PATTERNDATA));
1040                         WriteLog("  dcompen  = %i\n",DCOMPEN);
1041                         WriteLog("  bcompen  = %i\n",BCOMPEN);
1042                         WriteLog("  cmpdst   = %i\n",CMPDST);
1043                         WriteLog("  GOURZ    = %i\n",GOURZ);
1044                         WriteLog("  GOURD    = %i\n",GOURD);
1045                         WriteLog("  SRCSHADE = %i\n",SRCSHADE);
1046                         WriteLog("  DSTDATA  = 0x%.8x%.8x\n",REG(DSTDATA),REG(DSTDATA+4));
1047                 }
1048         }//*/
1049
1050 #ifdef LOG_BLITS
1051         if (start_logging)
1052         {
1053                 WriteLog("Blit!\n");
1054                 WriteLog("  cmd      = 0x%.8x\n",cmd);
1055                 WriteLog("  a1_base  = %08X\n", a1_addr);
1056                 WriteLog("  a1_pitch = %d\n", a1_pitch);
1057                 WriteLog("  a1_psize = %d\n", a1_psize);
1058                 WriteLog("  a1_width = %d\n", a1_width);
1059                 WriteLog("  a1_xadd  = %f (phrase=%d)\n", (float)a1_xadd / 65536.0, a1_phrase_mode);
1060                 WriteLog("  a1_yadd  = %f\n", (float)a1_yadd / 65536.0);
1061                 WriteLog("  a1_xstep = %f\n", (float)a1_step_x / 65536.0);
1062                 WriteLog("  a1_ystep = %f\n", (float)a1_step_y / 65536.0);
1063                 WriteLog("  a1_x     = %f\n", (float)a1_x / 65536.0);
1064                 WriteLog("  a1_y     = %f\n", (float)a1_y / 65536.0);
1065                 WriteLog("  a1_zoffs = %i\n",a1_zoffs);
1066
1067                 WriteLog("  a2_base  = %08X\n", a2_addr);
1068                 WriteLog("  a2_pitch = %d\n", a2_pitch);
1069                 WriteLog("  a2_psize = %d\n", a2_psize);
1070                 WriteLog("  a2_width = %d\n", a2_width);
1071                 WriteLog("  a2_xadd  = %f (phrase=%d)\n", (float)a2_xadd / 65536.0, a2_phrase_mode);
1072                 WriteLog("  a2_yadd  = %f\n", (float)a2_yadd / 65536.0);
1073                 WriteLog("  a2_xstep = %f\n", (float)a2_step_x / 65536.0);
1074                 WriteLog("  a2_ystep = %f\n", (float)a2_step_y / 65536.0);
1075                 WriteLog("  a2_x     = %f\n", (float)a2_x / 65536.0);
1076                 WriteLog("  a2_y     = %f\n", (float)a2_y / 65536.0);
1077                 WriteLog("  a2_mask_x= 0x%.4x\n",a2_mask_x);
1078                 WriteLog("  a2_mask_y= 0x%.4x\n",a2_mask_y);
1079                 WriteLog("  a2_zoffs = %i\n",a2_zoffs);
1080
1081                 WriteLog("  count    = %d x %d\n", n_pixels, n_lines);
1082
1083                 WriteLog("  command  = %08X\n", cmd);
1084                 WriteLog("  dsten    = %i\n",DSTEN);
1085                 WriteLog("  srcen    = %i\n",SRCEN);
1086                 WriteLog("  patdsel  = %i\n",PATDSEL);
1087                 WriteLog("  color    = 0x%.8x\n",REG(PATTERNDATA));
1088                 WriteLog("  dcompen  = %i\n",DCOMPEN);
1089                 WriteLog("  bcompen  = %i\n",BCOMPEN);
1090                 WriteLog("  cmpdst   = %i\n",CMPDST);
1091                 WriteLog("  GOURZ   = %i\n",GOURZ);
1092                 WriteLog("  GOURD   = %i\n",GOURD);
1093                 WriteLog("  SRCSHADE= %i\n",SRCSHADE);
1094         }
1095 #endif
1096
1097 //NOTE: Pitch is ignored!
1098
1099 //This *might* be the altimeter blits (they are)...
1100 //On captured screen, x-pos for black (inner) is 259, for pink is 257
1101 //Black is short by 3, pink is short by 1...
1102 /*
1103 Blit! (00110000 <- 000BF010) count: 9 x 31, A1/2_FLAGS: 000042E2/00010020 [cmd: 00010200]
1104  CMD -> src:  dst:  misc:  a1ctl: UPDA1  mode:  ity: PATDSEL z-op:  op: LFU_CLEAR ctrl:
1105   A1 -> pitch: 4 phrases, depth: 16bpp, z-off: 3, width: 320 (21), addctl: XADDPHR YADD0 XSIGNADD YSIGNADD
1106   A2 -> pitch: 1 phrases, depth: 16bpp, z-off: 0, width: 1 (00), addctl: XADDPIX YADD0 XSIGNADD YSIGNADD
1107         A1 x/y: 262/124, A2 x/y: 128/0
1108 Blit! (00110000 <- 000BF010) count: 5 x 38, A1/2_FLAGS: 000042E2/00010020 [cmd: 00010200]
1109  CMD -> src:  dst:  misc:  a1ctl: UPDA1  mode:  ity: PATDSEL z-op:  op: LFU_CLEAR ctrl:
1110   A1 -> pitch: 4 phrases, depth: 16bpp, z-off: 3, width: 320 (21), addctl: XADDPHR YADD0 XSIGNADD YSIGNADD
1111   A2 -> pitch: 1 phrases, depth: 16bpp, z-off: 0, width: 1 (00), addctl: XADDPIX YADD0 XSIGNADD YSIGNADD
1112         A1 x/y: 264/117, A2 x/y: 407/0
1113
1114 Blit! (00110000 <- 000BF010) count: 9 x 23, A1/2_FLAGS: 000042E2/00010020 [cmd: 00010200]
1115  CMD -> src:  dst:  misc:  a1ctl: UPDA1  mode:  ity: PATDSEL z-op:  op: LFU_CLEAR ctrl:
1116   A1 step values: -10 (X), 1 (Y)
1117   A1 -> pitch: 4(2) phrases, depth: 16bpp, z-off: 3, width: 320 (21), addctl: XADDPHR YADD0 XSIGNADD YSIGNADD
1118   A2 -> pitch: 1(0) phrases, depth: 16bpp, z-off: 0, width: 1 (00), addctl: XADDPIX YADD0 XSIGNADD YSIGNADD
1119         A1 x/y: 262/132, A2 x/y: 129/0
1120 Blit! (00110000 <- 000BF010) count: 5 x 27, A1/2_FLAGS: 000042E2/00010020 [cmd: 00010200]
1121  CMD -> src:  dst:  misc:  a1ctl: UPDA1  mode:  ity: PATDSEL z-op:  op: LFU_CLEAR ctrl:
1122   A1 step values: -8 (X), 1 (Y)
1123   A1 -> pitch: 4(2) phrases, depth: 16bpp, z-off: 3, width: 320 (21), addctl: XADDPHR YADD0 XSIGNADD YSIGNADD
1124   A2 -> pitch: 1(0) phrases, depth: 16bpp, z-off: 0, width: 1 (00), addctl: XADDPIX YADD0 XSIGNADD YSIGNADD
1125         A1 x/y: 264/128, A2 x/y: 336/0
1126
1127   264v       vCursor ends up here...
1128      xxxxx...`
1129      111122223333
1130
1131 262v         vCursor ends up here...
1132    xxxxxxxxx.'
1133  1111222233334444
1134
1135 Fixed! Now for more:
1136
1137 ; This looks like the ship icon in the upper left corner...
1138
1139 Blit! (00110000 <- 0010B2A8) count: 11 x 12, A1/2_FLAGS: 000042E2/00000020 [cmd: 09800609]
1140  CMD -> src: SRCEN  dst: DSTEN  misc:  a1ctl: UPDA1 UPDA2 mode:  ity:  z-op:  op: LFU_REPLACE ctrl: DCOMPEN
1141   A1 step values: -12 (X), 1 (Y)
1142   A2 step values: 0 (X), 0 (Y) [mask (unused): 00000000 - FFFFFFFF/FFFFFFFF]
1143   A1 -> pitch: 4 phrases, depth: 16bpp, z-off: 3, width: 320 (21), addctl: XADDPHR YADD0 XSIGNADD YSIGNADD
1144   A2 -> pitch: 1 phrases, depth: 16bpp, z-off: 0, width: 1 (00), addctl: XADDPHR YADD0 XSIGNADD YSIGNADD
1145         A1 x/y: 20/24, A2 x/y: 5780/0
1146
1147 Also fixed!
1148
1149 More (not sure this is a blitter problem as much as it's a GPU problem):
1150 All but the "M" are trashed...
1151 This does *NOT* look like a blitter problem, as it's rendering properly...
1152 Actually, if you look at the A1 step values, there IS a discrepancy!
1153
1154 ; D
1155
1156 Blit! (00110000 <- 0010B2A8) count: 12 x 12, A1/2_FLAGS: 000042E2/00000020 [cmd: 09800609]
1157  CMD -> src: SRCEN  dst: DSTEN  misc:  a1ctl: UPDA1 UPDA2 mode:  ity:  z-op:  op: LFU_REPLACE ctrl: DCOMPEN
1158   A1 step values: -14 (X), 1 (Y)
1159   A2 step values: -4 (X), 0 (Y) [mask (unused): 00000000 - FFFFFFFF/FFFFFFFF]
1160   A1 -> pitch: 4 phrases, depth: 16bpp, z-off: 3, width: 320 (21), addctl: XADDPHR YADD0 XSIGNADD YSIGNADD
1161   A2 -> pitch: 1 phrases, depth: 16bpp, z-off: 0, width: 1 (00), addctl: XADDPHR YADD0 XSIGNADD YSIGNADD
1162         A1 x/y: 134/144, A2 x/y: 2516/0
1163 ;129,146: +5,-2
1164
1165 ; E
1166
1167 Blit! (00110000 <- 0010B2A8) count: 12 x 12, A1/2_FLAGS: 000042E2/00000020 [cmd: 09800609]
1168  CMD -> src: SRCEN  dst: DSTEN  misc:  a1ctl: UPDA1 UPDA2 mode:  ity:  z-op:  op: LFU_REPLACE ctrl: DCOMPEN
1169   A1 step values: -13 (X), 1 (Y)
1170   A2 step values: -4 (X), 0 (Y) [mask (unused): 00000000 - FFFFFFFF/FFFFFFFF]
1171   A1 -> pitch: 4 phrases, depth: 16bpp, z-off: 3, width: 320 (21), addctl: XADDPHR YADD0 XSIGNADD YSIGNADD
1172   A2 -> pitch: 1 phrases, depth: 16bpp, z-off: 0, width: 1 (00), addctl: XADDPHR YADD0 XSIGNADD YSIGNADD
1173         A1 x/y: 147/144, A2 x/y: 2660/0
1174
1175 ; M
1176
1177 Blit! (00110000 <- 0010B2A8) count: 12 x 12, A1/2_FLAGS: 000042E2/00000020 [cmd: 09800609]
1178  CMD -> src: SRCEN  dst: DSTEN  misc:  a1ctl: UPDA1 UPDA2 mode:  ity:  z-op:  op: LFU_REPLACE ctrl: DCOMPEN
1179   A1 step values: -12 (X), 1 (Y)
1180   A2 step values: 0 (X), 0 (Y) [mask (unused): 00000000 - FFFFFFFF/FFFFFFFF]
1181   A1 -> pitch: 4 phrases, depth: 16bpp, z-off: 3, width: 320 (21), addctl: XADDPHR YADD0 XSIGNADD YSIGNADD
1182   A2 -> pitch: 1 phrases, depth: 16bpp, z-off: 0, width: 1 (00), addctl: XADDPHR YADD0 XSIGNADD YSIGNADD
1183         A1 x/y: 160/144, A2 x/y: 3764/0
1184
1185 ; O
1186
1187 Blit! (00110000 <- 0010B2A8) count: 12 x 12, A1/2_FLAGS: 000042E2/00000020 [cmd: 09800609]
1188  CMD -> src: SRCEN  dst: DSTEN  misc:  a1ctl: UPDA1 UPDA2 mode:  ity:  z-op:  op: LFU_REPLACE ctrl: DCOMPEN
1189   A1 step values: -15 (X), 1 (Y)
1190   A2 step values: -4 (X), 0 (Y) [mask (unused): 00000000 - FFFFFFFF/FFFFFFFF]
1191   A1 -> pitch: 4 phrases, depth: 16bpp, z-off: 3, width: 320 (21), addctl: XADDPHR YADD0 XSIGNADD YSIGNADD
1192   A2 -> pitch: 1 phrases, depth: 16bpp, z-off: 0, width: 1 (00), addctl: XADDPHR YADD0 XSIGNADD YSIGNADD
1193         A1 x/y: 173/144, A2 x/y: 4052/0
1194
1195 */
1196 extern int blit_start_log;
1197 extern int op_start_log;
1198 if (blit_start_log)
1199 {
1200         char * ctrlStr[4] = { "XADDPHR\0", "XADDPIX\0", "XADD0\0", "XADDINC\0" };
1201         char * bppStr[8] = { "1bpp\0", "2bpp\0", "4bpp\0", "8bpp\0", "16bpp\0", "32bpp\0", "???\0", "!!!\0" };
1202         char * opStr[16] = { "LFU_CLEAR", "LFU_NSAND", "LFU_NSAD", "LFU_NOTS", "LFU_SAND", "LFU_NOTD", "LFU_N_SXORD", "LFU_NSORND",
1203                 "LFU_SAD", "LFU_XOR", "LFU_D", "LFU_NSORD", "LFU_REPLACE", "LFU_SORND", "LFU_SORD", "LFU_ONE" };
1204         uint32 src = cmd & 0x07, dst = (cmd >> 3) & 0x07, misc = (cmd >> 6) & 0x03,
1205                 a1ctl = (cmd >> 8) & 0x07, mode = (cmd >> 11) & 0x07, ity = (cmd >> 14) & 0x0F,
1206                 zop = (cmd >> 18) & 0x07, op = (cmd >> 21) & 0x0F, ctrl = (cmd >> 25) & 0x3F;
1207         UINT32 a1f = REG(A1_FLAGS), a2f = REG(A2_FLAGS);
1208         uint32 p1 = a1f & 0x07, p2 = a2f & 0x07,
1209                 d1 = (a1f >> 3) & 0x07, d2 = (a2f >> 3) & 0x07,
1210                 zo1 = (a1f >> 6) & 0x07, zo2 = (a2f >> 6) & 0x07,
1211                 w1 = (a1f >> 9) & 0x3F, w2 = (a2f >> 9) & 0x3F,
1212                 ac1 = (a1f >> 16) & 0x1F, ac2 = (a2f >> 16) & 0x1F;
1213         UINT32 iw1 = ((0x04 | (w1 & 0x03)) << ((w1 & 0x3C) >> 2)) >> 2;
1214         UINT32 iw2 = ((0x04 | (w2 & 0x03)) << ((w2 & 0x3C) >> 2)) >> 2;
1215         WriteLog("Blit! (%08X %s %08X) count: %d x %d, A1/2_FLAGS: %08X/%08X [cmd: %08X]\n", a1_addr, (mode&0x01 ? "->" : "<-"), a2_addr, n_pixels, n_lines, a1f, a2f, cmd);
1216 //      WriteLog(" CMD -> src: %d, dst: %d, misc: %d, a1ctl: %d, mode: %d, ity: %1X, z-op: %d, op: %1X, ctrl: %02X\n", src, dst, misc, a1ctl, mode, ity, zop, op, ctrl);
1217
1218         WriteLog(" CMD -> src: %s%s%s ", (cmd & 0x0001 ? "SRCEN " : ""), (cmd & 0x0002 ? "SRCENZ " : ""), (cmd & 0x0004 ? "SRCENX" : ""));
1219         WriteLog("dst: %s%s%s ", (cmd & 0x0008 ? "DSTEN " : ""), (cmd & 0x0010 ? "DSTENZ " : ""), (cmd & 0x0020 ? "DSTWRZ" : ""));
1220         WriteLog("misc: %s%s ", (cmd & 0x0040 ? "CLIP_A1 " : ""), (cmd & 0x0080 ? "???" : ""));
1221         WriteLog("a1ctl: %s%s%s ", (cmd & 0x0100 ? "UPDA1F " : ""), (cmd & 0x0200 ? "UPDA1 " : ""), (cmd & 0x0400 ? "UPDA2" : ""));
1222         WriteLog("mode: %s%s%s ", (cmd & 0x0800 ? "DSTA2 " : ""), (cmd & 0x1000 ? "GOURD " : ""), (cmd & 0x2000 ? "ZBUFF" : ""));
1223         WriteLog("ity: %s%s%s ", (cmd & 0x4000 ? "TOPBEN " : ""), (cmd & 0x8000 ? "TOPNEN " : ""), (cmd & 0x00010000 ? "PATDSEL" : ""));
1224         WriteLog("z-op: %s%s%s ", (cmd & 0x00040000 ? "ZMODELT " : ""), (cmd & 0x00080000 ? "ZMODEEQ " : ""), (cmd & 0x00100000 ? "ZMODEGT" : ""));
1225         WriteLog("op: %s ", opStr[(cmd >> 21) & 0x0F]);
1226         WriteLog("ctrl: %s%s%s%s%s%s\n", (cmd & 0x02000000 ? "CMPDST " : ""), (cmd & 0x04000000 ? "BCOMPEN " : ""), (cmd & 0x08000000 ? "DCOMPEN " : ""), (cmd & 0x10000000 ? "BKGWREN " : ""), (cmd & 0x20000000 ? "BUSHI " : ""), (cmd & 0x40000000 ? "SRCSHADE" : ""));
1227
1228         if (UPDA1)
1229                 WriteLog("  A1 step values: %d (X), %d (Y)\n", a1_step_x >> 16, a1_step_y >> 16);
1230
1231         if (UPDA2)
1232                 WriteLog("  A2 step values: %d (X), %d (Y) [mask (%sused): %08X - %08X/%08X]\n", a2_step_x >> 16, a2_step_y >> 16, (a2f & 0x8000 ? "" : "un"), REG(A2_MASK), a2_mask_x, a2_mask_y);
1233
1234         WriteLog("  A1 -> pitch: %d phrases, depth: %s, z-off: %d, width: %d (%02X), addctl: %s %s %s %s\n", 1 << p1, bppStr[d1], zo1, iw1, w1, ctrlStr[ac1&0x03], (ac1&0x04 ? "YADD1" : "YADD0"), (ac1&0x08 ? "XSIGNSUB" : "XSIGNADD"), (ac1&0x10 ? "YSIGNSUB" : "YSIGNADD"));
1235         WriteLog("  A2 -> pitch: %d phrases, depth: %s, z-off: %d, width: %d (%02X), addctl: %s %s %s %s\n", 1 << p2, bppStr[d2], zo2, iw2, w2, ctrlStr[ac2&0x03], (ac2&0x04 ? "YADD1" : "YADD0"), (ac2&0x08 ? "XSIGNSUB" : "XSIGNADD"), (ac2&0x10 ? "YSIGNSUB" : "YSIGNADD"));
1236         WriteLog("        A1 x/y: %d/%d, A2 x/y: %d/%d\n", a1_x >> 16, a1_y >> 16, a2_x >> 16, a2_y >> 16);
1237 //      blit_start_log = 0;
1238 //      op_start_log = 1;
1239 }
1240
1241         blitter_working = 1;
1242 //#ifndef USE_GENERIC_BLITTER
1243 //      if (!blitter_execute_cached_code(blitter_in_cache(cmd)))
1244 //#endif
1245         blitter_generic(cmd);
1246
1247 /*if (blit_start_log)
1248 {
1249         if (a1_addr == 0xF03000 && a2_addr == 0x004D58)
1250         {
1251                 WriteLog("\nBytes at 004D58:\n");
1252                 for(int i=0x004D58; i<0x004D58+(10*127*4); i++)
1253                         WriteLog("%02X ", JaguarReadByte(i));
1254                 WriteLog("\nBytes at F03000:\n");
1255                 for(int i=0xF03000; i<0xF03000+(6*127*4); i++)
1256                         WriteLog("%02X ", JaguarReadByte(i));
1257                 WriteLog("\n\n");
1258         }
1259 }//*/
1260
1261         blitter_working = 0;
1262 }
1263
1264 void blitter_init(void)
1265 {
1266         blitter_reset();
1267 }
1268
1269 void blitter_reset(void)
1270 {
1271         memset(blitter_ram, 0x00, 0xA0);
1272 }
1273
1274 void blitter_done(void)
1275 {
1276         WriteLog("BLIT: Done.\n");
1277 }
1278
1279 uint8 BlitterReadByte(uint32 offset, uint32 who/*=UNKNOWN*/)
1280 {
1281         offset &= 0xFF;
1282
1283         // status register
1284         if (offset == (0x38 + 3))
1285                 return 0x01;    // always idle
1286
1287         return blitter_ram[offset];
1288 }
1289
1290 uint16 BlitterReadWord(uint32 offset, uint32 who/*=UNKNOWN*/)
1291 {
1292         return ((uint16)BlitterReadByte(offset, who) << 8) | (uint16)BlitterReadByte(offset+1, who);
1293 }
1294
1295 uint32 BlitterReadLong(uint32 offset, uint32 who/*=UNKNOWN*/)
1296 {
1297         return (BlitterReadWord(offset, who) << 16) | BlitterReadWord(offset+2, who);
1298 }
1299
1300 void BlitterWriteByte(uint32 offset, uint8 data, uint32 who/*=UNKNOWN*/)
1301 {
1302 /*if (offset & 0xFF == 0x7B)
1303         WriteLog("--> Wrote to B_STOP: value -> %02X\n", data);*/
1304         offset &= 0xFF;
1305
1306 //      if ((offset >= 0x7C) && (offset <= 0x9B))
1307         if ((offset >= 0x7C) && (offset <= 0x8B))
1308         {
1309                 switch (offset)
1310                 {
1311                 case 0x7C: break;
1312                 case 0x7D: blitter_ram[0x69] = data; break;
1313                 case 0x7E: blitter_ram[0x40] = data; break;
1314                 case 0x7F: blitter_ram[0x41] = data; break;
1315
1316                 case 0x80: break;
1317                 case 0x81: blitter_ram[0x6B] = data; break;
1318                 case 0x82: blitter_ram[0x42] = data; break;
1319                 case 0x83: blitter_ram[0x43] = data; break;
1320
1321                 case 0x84: break;
1322                 case 0x85: blitter_ram[0x6D] = data; break;
1323                 case 0x86: blitter_ram[0x44] = data; break;
1324                 case 0x87: blitter_ram[0x45] = data; break;
1325
1326                 case 0x88: break;
1327                 case 0x89: blitter_ram[0x6F] = data; break;
1328 //Mistyped?
1329 //              case 0x9A: blitter_ram[0x46] = data; break;
1330 //              case 0x9B: blitter_ram[0x47] = data; break;
1331                 case 0x8A: blitter_ram[0x46] = data; break;
1332                 case 0x8B: blitter_ram[0x47] = data; break;
1333                 }
1334         }
1335
1336         blitter_ram[offset] = data;
1337 }
1338
1339 void BlitterWriteWord(uint32 offset, uint16 data, uint32 who/*=UNKNOWN*/)
1340 {
1341         BlitterWriteByte(offset+0, (data>>8) & 0xFF, who);
1342         BlitterWriteByte(offset+1, data & 0xFF, who);
1343
1344         if ((offset & 0xFF) == 0x3A)
1345         // I.e., the second write of 32-bit value--not convinced this is the best way to do this!
1346         // But then again, according to the Jaguar docs, this is correct...!
1347                 blitter_blit(GET32(blitter_ram, 0x38));
1348 // Testing purposes only!
1349 //This does the clipping correctly, but not the Gouraud shading...
1350 //              blitter2_exec(GET32(blitter_ram, 0x38));
1351 }
1352 //F02278,9,A,B
1353
1354 void BlitterWriteLong(uint32 offset, uint32 data, uint32 who/*=UNKNOWN*/)
1355 {
1356         BlitterWriteWord(offset, data >> 16, who);
1357         BlitterWriteWord(offset+2, data & 0xFFFF, who);
1358 }