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

   1 \r
   2 #include <stdio.h>\r
   3 #include <stdlib.h>\r
   4 #include <string.h>\r
   5 #include "jaguar.h"\r
   6 \r
   7 \r
   8 //#define OP_DEBUG\r
   9 //#define OP_DEBUG_BMP\r
  10 static int cnt = 0;\r
  11 extern uint32 jaguar_mainRom_crc32;\r
  12 \r
  13 static uint8 * op_blend_y;\r
  14 static uint8 * op_blend_cc;\r
  15 \r
  16 #define BLEND_Y(dst,src) op_blend_y[(((uint16)dst)<<8) | ((uint16)(src))]\r
  17 #define BLEND_CC(dst,src) op_blend_cc[(((uint16)dst)<<8) | ((uint16)(src))]\r
  18 \r
  19 \r
  20 static uint8 objectp_ram[0x40];\r
  21 uint8 objectp_running;\r
  22 \r
  23 uint8 objectp_stop_reading_list;\r
  24 \r
  25 #define OBJECT_TYPE_BITMAP      0\r
  26 #define OBJECT_TYPE_SCALE       1\r
  27 #define OBJECT_TYPE_GPU         2\r
  28 #define OBJECT_TYPE_BRANCH      3\r
  29 #define OBJECT_TYPE_STOP        4\r
  30 \r
  31 #define CONDITION_EQUAL                 0\r
  32 #define CONDITION_LESS_THAN             1\r
  33 #define CONDITION_GREATER_THAN  2\r
  34 #define CONDITION_OP_FLAG_SET   3\r
  35 #define CONDITION_SECOND_HALF_LINE      4\r
  36 \r
  37 #define FLAGS_RELEASE           8\r
  38 #define FLAGS_TRANSPARENT       4\r
  39 #define FLAGS_READMODIFY        2\r
  40 #define FLAGS_HFLIP                     1\r
  41 \r
  42 \r
  43 static char * condition_to_str[8] = {"==","<",">","(opflag set)","(second half line)","?","?","?"};\r
  44 \r
  45 static uint8 op_bitmap_bit_depth[8]={1,           2,          4,         8,       16,      24,      32,      0      };\r
  46 static uint32 op_bitmap_bit_size[8]={0.125*65536, 0.25*65536, 0.5*65536, 1*65536, 2*65536, 1*65536, 1*65536, 1*65536};\r
  47 static uint32 op_pointer;\r
  48 static int cnt_bitmap = 0;\r
  49 \r
  50 //////////////////////////////////////////////////////////////////////////////\r
  51 //\r
  52 //////////////////////////////////////////////////////////////////////////////\r
  53 //\r
  54 //\r
  55 //\r
  56 //////////////////////////////////////////////////////////////////////////////\r
  57 void op_process_bitmap(int16 *backbuffer, int scanline, uint64 p0, uint64 p1, int render)\r
  58 {\r
  59         uint8   bitdepth=(p1>>12)&0x07;\r
  60         \r
  61         int16   ypos=(((p0>>3)&0x3ff)/2);\r
  62         int32   xpos=(((int32)((p1<<20)&0xffffffff))>>20)-tom_getHBlankWidthInPixels();\r
  63         int32   iwidth=((p1>>28)&0x3ff)*4;\r
  64         uint32  dwidth=((p1>>18)&0x3ff)*4;\r
  65         int16   height=((p0>>14)&0x3ff)-1;\r
  66         uint32  link=((p0>>24)&0x7ffff)<<3;\r
  67         uint32  ptr=(((p0>>43)&0x1fffff)<<3);\r
  68         uint32  firstPix=(p1>>49)&0x3f;\r
  69         uint8   flags=(p1>>45)&0x0f;\r
  70         uint8   idx=(p1>>38)&0x7f;\r
  71         uint32  pitch=(p1>>15)&0x07;\r
  72         int16   scanline_width=tom_getVideoModeWidth();\r
  73         uint8   *tom_ram_8=tom_get_ram_pointer();\r
  74         uint8   *current_line_buffer=&tom_ram_8[0x1800];\r
  75         uint8   *paletteRam=&tom_ram_8[0x400];\r
  76         uint8    doom_hack=0;\r
  77 \r
  78         op_pointer=link;\r
  79 \r
  80         if ((!render)||(op_pointer==0)||(height<0)||(dwidth<0)||(ptr==0)||(pitch==0))\r
  81         {\r
  82                 return;\r
  83         }\r
  84         if (iwidth==0)\r
  85         {\r
  86                 dwidth=iwidth=height;\r
  87         }\r
  88         if (jaguar_mainRom_crc32==0x5e705756) // doom\r
  89         {\r
  90                 if ((iwidth==160)&&(height==179)&&(xpos==-9)&&(ypos==24))\r
  91                 {\r
  92                         doom_hack=1;\r
  93                         xpos=0;\r
  94                 }\r
  95         }\r
  96         // il y a un offset vertical de 20 pour un des bitmaps\r
  97         // dans dinon olympics pour une raison encore inconnue\r
  98         if (jaguar_mainRom_crc32==0x3c7bfda8)\r
  99         {\r
 100                 if ((iwidth==220)&&(height==184)&&(ypos==0))\r
 101                 {\r
 102                         ypos=20;\r
 103                 }\r
 104         }\r
 105         else\r
 106         if (jaguar_mainRom_crc32==0x2f032271)\r
 107         {\r
 108                 ypos+=8;\r
 109         }\r
 110         if (op_bitmap_bit_depth[bitdepth]==24)\r
 111         {\r
 112                 iwidth*=2;\r
 113                 dwidth*=2;\r
 114         }\r
 115         if (op_bitmap_bit_depth[bitdepth]==8)\r
 116         {\r
 117                 iwidth*=2;\r
 118                 dwidth*=2;\r
 119         }\r
 120         if (op_bitmap_bit_depth[bitdepth]==4)\r
 121         {\r
 122                 iwidth*=2;\r
 123                 dwidth*=2;\r
 124         }\r
 125         if (op_bitmap_bit_depth[bitdepth]==2)\r
 126         {\r
 127                 iwidth*=2;\r
 128                 dwidth*=2;\r
 129         }\r
 130         if (op_bitmap_bit_depth[bitdepth]==1)\r
 131         {\r
 132                 iwidth*=2;\r
 133                 dwidth*=2;\r
 134         }\r
 135         // Power Drive Rally (fixed size bitmaps have a 240 lines vertical offset)\r
 136         // but could well be a modulo 240\r
 137         if (jaguar_mainRom_crc32==0x0ab88d90)\r
 138                 ypos%=240;\r
 139 \r
 140 \r
 141 #ifdef OP_DEBUG_BMP\r
 142         fprintf(log_get(),"bitmap %ix%i %ibpp at %i,%i firstpix=%i ptr=0x%.8x pitch %i hflipped=%s dwidth=%i (linked to 0x%.8x) Transluency=%s\n",iwidth,height,op_bitmap_bit_depth[bitdepth],xpos,ypos,firstPix,ptr,pitch,flags&FLAGS_HFLIP?"yes":"no",dwidth,op_pointer,(flags&FLAGS_READMODIFY)?"yes":"no");\r
 143 #endif\r
 144 \r
 145         if ((scanline<ypos)||(scanline>(ypos+height)))\r
 146         {\r
 147                 return;\r
 148         }\r
 149         // seek to the good bitmap scanline\r
 150         // not sure for palettized modes\r
 151         if (op_bitmap_bit_depth[bitdepth] > 8)\r
 152         {\r
 153                 ptr += ((dwidth * op_bitmap_bit_size[bitdepth]) >> 16) * (scanline - ypos);\r
 154         }\r
 155         else\r
 156                 ptr += dwidth * (scanline - ypos);\r
 157 \r
 158         if (xpos < 0)\r
 159         {\r
 160                 iwidth += xpos;\r
 161                 ptr += (pitch * op_bitmap_bit_size[bitdepth] * (-xpos)) >> 16;\r
 162                 xpos = 0;\r
 163         }\r
 164 \r
 165         if (iwidth <= 0)\r
 166         {\r
 167 #ifdef OP_DEBUG \r
 168         fprintf(log_get(),"not rendering because iwidth<0\n");\r
 169 #endif\r
 170                 return;\r
 171         }\r
 172         \r
 173         if (flags&FLAGS_HFLIP)\r
 174         {\r
 175                 if ((xpos<0)||((xpos-iwidth)>=scanline_width))\r
 176                         return;\r
 177 \r
 178                 if ((xpos-iwidth)<0)\r
 179                         iwidth=xpos;\r
 180         }\r
 181         else\r
 182         {\r
 183                 if (((xpos+iwidth)<0)||(xpos>=scanline_width))\r
 184                         return;\r
 185 \r
 186                 if ((xpos+iwidth)>scanline_width)\r
 187                         iwidth=scanline_width-xpos;\r
 188         }\r
 189 \r
 190 \r
 191         current_line_buffer+=(xpos*2); // 2 in 16 bpp modes (need to take the mode into account)\r
 192 \r
 193         // doom switches the resolution from 320 to 160 to double the display width\r
 194         // this is not yet supported\r
 195         if (doom_hack)\r
 196         {\r
 197                 while (iwidth)\r
 198                 {\r
 199                         uint8 d0=jaguar_byte_read(ptr+0);\r
 200                         uint8 d1=jaguar_byte_read(ptr+1);\r
 201                         *current_line_buffer++=d0;\r
 202                         *current_line_buffer++=d1;\r
 203                         *current_line_buffer++=d0;\r
 204                         *current_line_buffer++=d1;\r
 205                         ptr+=2;\r
 206                         iwidth--;\r
 207                 }\r
 208                 return;\r
 209         }\r
 210         if (op_bitmap_bit_depth[bitdepth]==1)\r
 211         {\r
 212                 if (pitch==1)\r
 213                 {\r
 214                         #include "include/fbmpop1.h"\r
 215                 }\r
 216                 else\r
 217                 {\r
 218                         #include "include/fbmpop1p.h"\r
 219                 }\r
 220         }\r
 221         else\r
 222         if (op_bitmap_bit_depth[bitdepth]==2)\r
 223         {\r
 224                 if (pitch==1)\r
 225                 {\r
 226                         #include "include/fbmpop2.h"\r
 227                 }\r
 228                 else\r
 229                 {\r
 230                         #include "include/fbmpop2p.h"\r
 231                 }\r
 232         }\r
 233         else\r
 234         if (op_bitmap_bit_depth[bitdepth]==4)\r
 235         {\r
 236                 if (pitch==1)\r
 237                 {\r
 238                         #include "include/fbmpop4.h"\r
 239                 }\r
 240                 else\r
 241                 {\r
 242                         #include "include/fbmpop4p.h"\r
 243                 }\r
 244         }\r
 245         else\r
 246         if (op_bitmap_bit_depth[bitdepth]==8)\r
 247         {\r
 248                 if (pitch==1)\r
 249                 {\r
 250                         #include "include/fbmpop8.h"\r
 251                 }\r
 252                 else\r
 253                 {\r
 254                         #include "include/fbmpop8p.h"\r
 255                 }\r
 256         }\r
 257         else\r
 258         if (op_bitmap_bit_depth[bitdepth]==16)\r
 259         {\r
 260                 if (pitch==1)\r
 261                 {\r
 262                         #include "include/fbmpop16.h"\r
 263                 }\r
 264                 else\r
 265                 {\r
 266                         #include "include/fbmpop16p.h"\r
 267                 }\r
 268         }\r
 269         else\r
 270         if (op_bitmap_bit_depth[bitdepth]==24)\r
 271         {\r
 272                 if (pitch==1)\r
 273                 {\r
 274                         #include "include/fbmpop24.h"\r
 275                 }\r
 276                 else\r
 277                 {\r
 278                         #include "include/fbmpop24p.h"\r
 279                 }\r
 280         }\r
 281 }\r
 282 //////////////////////////////////////////////////////////////////////////////\r
 283 //\r
 284 //////////////////////////////////////////////////////////////////////////////\r
 285 //\r
 286 //\r
 287 //\r
 288 //////////////////////////////////////////////////////////////////////////////\r
 289 void op_process_scaled_bitmap(int16 *backbuffer, int scanline, uint64 p0, uint64 p1, uint64 p2, int render)\r
 290 {\r
 291         int32   xpos=(((int32)((p1<<20)&0xffffffff))>>20)-tom_getHBlankWidthInPixels();\r
 292         int16   ypos=(((p0&0x3ff8)>>3)/2);\r
 293         uint16  iwidth=((p1>>28)&0x3ff)*4;\r
 294         uint16  dwidth=((p1>>18)&0x3ff)*4;\r
 295         uint16  height=(p0>>14)&0x3ff;\r
 296         uint32  link=((p0>>24)&0x7ffff)<<3;\r
 297         uint32  ptr=((p0>>43)&0x1fffff)<<3;\r
 298         uint32  firstPix=(p1>>49)&0x3f;\r
 299         uint8   flags=(p1>>45)&0x0f;\r
 300         uint8   idx=(p1>>38)&0x7f; \r
 301         uint8   pitch=(p1>>15)&0x07;\r
 302         uint8   bitdepth=(p1>>12)&0x07;\r
 303         int16   scanline_width=tom_getVideoModeWidth();\r
 304         uint8   *tom_ram_8=tom_get_ram_pointer();\r
 305         uint8   *current_line_buffer=&tom_ram_8[0x1800];\r
 306         float   vscale;\r
 307         float   hscale;\r
 308         \r
 309         uint32  vscale_fixed3p5=((p2>>8)&0xff);\r
 310         uint32  hscale_fixed3p5=(p2&0xff);\r
 311         vscale=((float)vscale_fixed3p5)/32;\r
 312         hscale=((float)hscale_fixed3p5)/32;\r
 313 \r
 314         op_pointer=link;\r
 315 \r
 316         if (jaguar_mainRom_crc32==0x5a5b9c68) // atari karts\r
 317         {\r
 318                 if (vscale == 0.0f) \r
 319                         vscale = 1.0f;\r
 320 \r
 321                 if (ypos == 0)\r
 322                         ypos = scanline;\r
 323         }\r
 324 #ifdef OP_DEBUG_BMP\r
 325         if (xpos == -3)\r
 326                 fprintf(log_get(),"[scanline %i] %ix%i scaled to %ix%i scale (%f, %f)%i bpp pitch %i at (%i,%i) @ 0x%.8x Transluency=%s\n",\r
 327                                                                                                                                                           scanline,\r
 328                                                                                                                                                           iwidth,height,\r
 329                                                                                                                                                           (int)(iwidth*hscale),\r
 330                                                                                                                                                           (int)(height*vscale),\r
 331                                                                                                                                                           hscale, vscale,\r
 332                                                                                                                                                           op_bitmap_bit_depth[bitdepth],pitch,xpos,ypos,ptr,(flags&FLAGS_READMODIFY)?"yes":"no");\r
 333 #endif\r
 334         if (jaguar_mainRom_crc32==0x2f032271)\r
 335         {\r
 336                 ypos+=8;\r
 337         }\r
 338 \r
 339         if ((render==0)||(op_pointer==0)||(height<0)||(dwidth<0)||(ptr==0)||(pitch==0))\r
 340         {\r
 341                 return;\r
 342         }\r
 343 \r
 344         if (op_bitmap_bit_depth[bitdepth]==8)\r
 345         {\r
 346                 iwidth*=2;\r
 347                 dwidth*=2;\r
 348         }\r
 349         if (op_bitmap_bit_depth[bitdepth]==4)\r
 350         {\r
 351                 iwidth*=2;\r
 352                 dwidth*=2;\r
 353         }\r
 354         if (op_bitmap_bit_depth[bitdepth]==2)\r
 355         {\r
 356                 iwidth*=2;\r
 357                 dwidth*=2;\r
 358         }\r
 359         if (op_bitmap_bit_depth[bitdepth]==1)\r
 360         {\r
 361                 iwidth*=2;\r
 362                 dwidth*=2;\r
 363         }\r
 364 \r
 365         uint16  scaled_width=iwidth*hscale;\r
 366         uint16  scaled_height=height*vscale;\r
 367 \r
 368         if (op_bitmap_bit_depth[bitdepth]==4)   // why ?\r
 369                 scaled_width*=2;\r
 370 \r
 371         if (op_bitmap_bit_depth[bitdepth]==2)   // why ?\r
 372                 scaled_width*=4;\r
 373 \r
 374         if (op_bitmap_bit_depth[bitdepth]==1)   // why ?\r
 375                 scaled_width*=8;\r
 376 \r
 377         // seek to the good bitmap scanline\r
 378         // not sure for palettized modes\r
 379         if (op_bitmap_bit_depth[bitdepth]>8)\r
 380                 ptr+=((dwidth*op_bitmap_bit_size[bitdepth])>>16)*((uint32)((scanline-ypos)/vscale));\r
 381         else\r
 382                 ptr+=dwidth*((uint32)((scanline-ypos)/vscale));\r
 383 \r
 384         // visible ?\r
 385         if ((scanline<ypos)||(scanline>(ypos+scaled_height))||((xpos+scaled_width)<0)||(xpos>=scanline_width))\r
 386                 return;\r
 387 \r
 388         \r
 389         if (xpos<0)\r
 390         {\r
 391                 scaled_width+=xpos;\r
 392                 ptr+=(pitch*op_bitmap_bit_size[bitdepth]*((uint32)((-xpos)/hscale)))>>16;\r
 393                 xpos=0;\r
 394         }\r
 395 \r
 396         if (iwidth<=0)\r
 397                 return;\r
 398 \r
 399         if (flags&FLAGS_HFLIP)\r
 400         {\r
 401                 if ((xpos<0)||((xpos-scaled_width)>=scanline_width))\r
 402                         return;\r
 403 \r
 404                 if ((xpos-scaled_width)<0)\r
 405                         scaled_width=xpos;\r
 406         }\r
 407         else\r
 408         {\r
 409                 if (((xpos+scaled_width)<0)||(xpos>=scanline_width))\r
 410                         return;\r
 411 \r
 412                 if ((xpos+scaled_width)>scanline_width)\r
 413                         scaled_width=scanline_width-xpos;\r
 414         }\r
 415         \r
 416         current_line_buffer+=(xpos*2);\r
 417 \r
 418         int32 hscale_fixed=(int32)(65536.0f/hscale);\r
 419         int32 cnt=0;\r
 420 \r
 421         if (op_bitmap_bit_depth[bitdepth]==1)\r
 422         {\r
 423                 if (pitch==1)\r
 424                 {\r
 425                         #include "include/zbmpop1.h"\r
 426                 }\r
 427                 else\r
 428                 {\r
 429                         #include "include/zbmpop1p.h"\r
 430                 }\r
 431         }\r
 432         else\r
 433         if (op_bitmap_bit_depth[bitdepth]==2)\r
 434         {\r
 435                 if (pitch==1)\r
 436                 {\r
 437                         #include "include/zbmpop2.h"\r
 438                 }\r
 439                 else\r
 440                 {\r
 441                         #include "include/zbmpop2p.h"\r
 442                 }\r
 443         }\r
 444         else\r
 445         if (op_bitmap_bit_depth[bitdepth]==4)\r
 446         {\r
 447                 if (pitch==1)\r
 448                 {\r
 449                         #include "include/zbmpop4.h"\r
 450                 }\r
 451                 else\r
 452                 {\r
 453                         #include "include/zbmpop4p.h"\r
 454                 }\r
 455         }\r
 456         else\r
 457         if (op_bitmap_bit_depth[bitdepth]==8)\r
 458         {\r
 459                 if (pitch==1)\r
 460                 {\r
 461                         #include "include/zbmpop8.h"\r
 462                 }\r
 463                 else\r
 464                 {\r
 465                         #include "include/zbmpop8p.h"\r
 466                 }\r
 467         }\r
 468         else\r
 469         if (op_bitmap_bit_depth[bitdepth]==16)\r
 470         {\r
 471                 if (pitch==1)\r
 472                 {\r
 473                         #include "include/zbmpop16.h"\r
 474                 }\r
 475                 else\r
 476                 {\r
 477                         #include "include/zbmpop16p.h"\r
 478                 }\r
 479         }\r
 480         else\r
 481                 fprintf(log_get(),"(unimplemented) %i bpp scaled bitmap\n",op_bitmap_bit_depth[bitdepth]);\r
 482 }\r
 483 //////////////////////////////////////////////////////////////////////////////\r
 484 //\r
 485 //////////////////////////////////////////////////////////////////////////////\r
 486 //\r
 487 //\r
 488 //\r
 489 //////////////////////////////////////////////////////////////////////////////\r
 490 uint64 op_load_phrase(uint32 offset)\r
 491 {\r
 492         offset &= (~0x07);                                              // 8 byte alignment\r
 493 \r
 494         uint64 data = jaguar_byte_read(offset++);\r
 495         data <<= 8;\r
 496         data |= jaguar_byte_read(offset++);\r
 497         data <<= 8;\r
 498         data |= jaguar_byte_read(offset++);\r
 499         data <<= 8;\r
 500         data |= jaguar_byte_read(offset++);\r
 501         data <<= 8;\r
 502         data |= jaguar_byte_read(offset++);\r
 503         data <<= 8;\r
 504         data |= jaguar_byte_read(offset++);\r
 505         data <<= 8;\r
 506         data |= jaguar_byte_read(offset++);\r
 507         data <<= 8;\r
 508         data |= jaguar_byte_read(offset++);\r
 509 \r
 510         return data;\r
 511 }\r
 512 //////////////////////////////////////////////////////////////////////////////\r
 513 //\r
 514 //////////////////////////////////////////////////////////////////////////////\r
 515 //\r
 516 //\r
 517 //\r
 518 //////////////////////////////////////////////////////////////////////////////\r
 519 void op_process_list(int16 * backbuffer, int scanline, int render)\r
 520 {\r
 521         uint64 p0;      \r
 522 \r
 523         cnt_bitmap = 0;\r
 524 \r
 525         if (scanline < tom_get_vdb())\r
 526                 return;\r
 527 \r
 528         if (scanline >= 525)//tom_getVideoModeHeight()+tom_get_vdb())\r
 529                 return;\r
 530 \r
 531         op_pointer = op_get_list_pointer();\r
 532 \r
 533         objectp_stop_reading_list = 0;\r
 534         cnt = 0;\r
 535 \r
 536 //      if (op_pointer) fprintf(log_get()," new op list at 0x%.8x scanline %i\n",op_pointer,scanline);\r
 537         while (op_pointer)\r
 538         {\r
 539                 if (objectp_stop_reading_list)\r
 540                         return;\r
 541                         \r
 542                 p0 = op_load_phrase(op_pointer);\r
 543                 op_pointer += 8;\r
 544                 \r
 545 \r
 546 //              fprintf(log_get(),"0x%.8x type %i\n",op_pointer,((uint8)p0&0x07));              \r
 547                 switch ((uint8)p0&0x07)\r
 548                 {\r
 549                 case OBJECT_TYPE_BITMAP:\r
 550                 {\r
 551                         uint64 p1 = op_load_phrase(op_pointer);\r
 552                         op_pointer += 8;\r
 553                         op_process_bitmap(backbuffer, scanline, p0, p1, render);\r
 554                         break;\r
 555                 }\r
 556                 case OBJECT_TYPE_SCALE:\r
 557                 {\r
 558                         uint64 p1 = op_load_phrase(op_pointer);\r
 559                         op_pointer += 8;\r
 560                         uint64 p2 = op_load_phrase(op_pointer);\r
 561                         op_pointer += 8;\r
 562                         op_process_scaled_bitmap(backbuffer, scanline, p0, p1, p2, render);\r
 563                         break;\r
 564                 }\r
 565                 case OBJECT_TYPE_GPU:\r
 566                 {\r
 567                         uint64 data = p0 >> 3;\r
 568                         op_set_current_object(p0);\r
 569                         gpu_set_irq_line(3, 1); \r
 570                         break;\r
 571                 }\r
 572                 case OBJECT_TYPE_BRANCH:\r
 573                 {\r
 574                         uint16 vcnt = (p0>>3) & 0x7FF;\r
 575                         uint8  cc   = (p0>>14) & 0x03;\r
 576                         uint32 link = ((p0>>24) & 0x1FFFFF) << 3;\r
 577                         \r
 578 //                      if ((vcnt!=507)&&(vcnt!=25))\r
 579 //                              fprintf(log_get(),"\t%i%s%i link=0x%.8x\n",scanline,condition_to_str[cc],vcnt>>1,link);\r
 580                         switch (cc)\r
 581                         {\r
 582                         case CONDITION_EQUAL:\r
 583                                 if ((vcnt != 0x7FF) && (vcnt & 0x01))\r
 584                                         vcnt ^= 0x01;\r
 585                                 if (((2*tom_get_scanline()) == vcnt) || (vcnt == 0x7FF))\r
 586                                         op_pointer=link;\r
 587                                 break;\r
 588                         case CONDITION_LESS_THAN:\r
 589                                 if ((2*tom_get_scanline()) < vcnt)\r
 590                                         op_pointer=link;\r
 591                                 break;\r
 592                         case CONDITION_GREATER_THAN:\r
 593                                 if ((2*tom_get_scanline()) > vcnt)\r
 594                                         op_pointer=link;\r
 595                                 break;\r
 596                         case CONDITION_OP_FLAG_SET:\r
 597                                 if (op_get_status_register() & 0x01)\r
 598                                         op_pointer=link;\r
 599                                 break;\r
 600                         case CONDITION_SECOND_HALF_LINE:\r
 601                                 fprintf(log_get(), "op: unexpected CONDITION_SECOND_HALF_LINE in BRANCH object\nop: shuting down\n");\r
 602                                 fclose(log_get());\r
 603                                 exit(0);\r
 604                                 break;\r
 605                         default:\r
 606                                 fprintf(log_get(),"op: unimplemented branch condition %i\n", cc);\r
 607                         }\r
 608                         break;\r
 609                 }\r
 610                 case OBJECT_TYPE_STOP:\r
 611                 {\r
 612                         // unsure\r
 613                         op_set_status_register(((p0>>3) & 0xFFFFFFFF));\r
 614                         \r
 615                         if (p0 & 0x8)\r
 616                         {\r
 617                                 tom_set_pending_object_int();\r
 618                                 if ((tom_irq_enabled(2)) && (jaguar_interrupt_handler_is_valid(64)))\r
 619                                 {\r
 620 //                                      s68000interrupt(7,64);\r
 621 //                                      s68000flushInterrupts();\r
 622                                         m68k_set_irq(7);                                // Cause an NMI to occur...\r
 623                                 }\r
 624                         }\r
 625 \r
 626                         return;\r
 627                         break;\r
 628                 }\r
 629                 default:\r
 630                 {\r
 631                         fprintf(log_get(),"op: unknown object type %i\n", ((uint8)p0 & 0x07)); \r
 632                         return;\r
 633                 }\r
 634                 }\r
 635         }\r
 636 }\r
 637 //////////////////////////////////////////////////////////////////////////////\r
 638 //\r
 639 //////////////////////////////////////////////////////////////////////////////\r
 640 //\r
 641 //\r
 642 //\r
 643 //////////////////////////////////////////////////////////////////////////////\r
 644 void op_init(void)\r
 645 {\r
 646         memory_malloc_secure((void **)&op_blend_y, 0x10000, "Jaguar Object processor Y blend lookup table");\r
 647         memory_malloc_secure((void **)&op_blend_cc, 0x10000, "Jaguar Object processor C blend lookup table");\r
 648 \r
 649         for(int i=0; i<256*256; i++)\r
 650         {\r
 651                 int y = (i >> 8) & 0xFF;\r
 652                 int dy = (int8)(i & 0xFF);\r
 653                 y += dy;\r
 654                 if (y < 0)\r
 655                         y = 0;\r
 656                 else if (y > 0xFF)\r
 657                         y = 0xFF;\r
 658                 op_blend_y[i] = y;\r
 659         }\r
 660 \r
 661         for(int i=0; i<256*256; i++)\r
 662         {\r
 663                 int cl = (i >> 8) & 0xFF;\r
 664                 int dcl = (int8)(i & 0xFF);\r
 665                 cl += dcl;\r
 666                 if (cl < 0)\r
 667                         cl = 0;\r
 668                 else if (cl > 0xFF)\r
 669                         cl = 0xFF;\r
 670                 op_blend_cc[i] = cl;\r
 671         }\r
 672         op_reset();\r
 673 }\r
 674 //////////////////////////////////////////////////////////////////////////////\r
 675 //\r
 676 //////////////////////////////////////////////////////////////////////////////\r
 677 //\r
 678 //\r
 679 //\r
 680 //////////////////////////////////////////////////////////////////////////////\r
 681 void op_reset(void)\r
 682 {\r
 683         memset(objectp_ram, 0x00, 0x18);\r
 684         objectp_running = 0;\r
 685 }\r
 686 //////////////////////////////////////////////////////////////////////////////\r
 687 //\r
 688 //////////////////////////////////////////////////////////////////////////////\r
 689 //\r
 690 //\r
 691 //\r
 692 //////////////////////////////////////////////////////////////////////////////\r
 693 void op_done(void)\r
 694 {\r
 695 }\r
 696 //////////////////////////////////////////////////////////////////////////////\r
 697 //\r
 698 //////////////////////////////////////////////////////////////////////////////\r
 699 //\r
 700 //\r
 701 //\r
 702 //////////////////////////////////////////////////////////////////////////////\r
 703 void op_byte_write(uint32 offset, uint8 data)\r
 704 {\r
 705         offset &= 0x3F;\r
 706         objectp_ram[offset] = data;\r
 707 }\r
 708 //////////////////////////////////////////////////////////////////////////////\r
 709 //\r
 710 //////////////////////////////////////////////////////////////////////////////\r
 711 //\r
 712 //\r
 713 //\r
 714 //////////////////////////////////////////////////////////////////////////////\r
 715 void op_word_write(uint32 offset, uint16 data)\r
 716 {\r
 717         offset &= 0x3F;\r
 718         objectp_ram[offset] = (data >> 8) & 0xFF;\r
 719         objectp_ram[offset+1] = data & 0xFF;\r
 720 \r
 721 }\r
 722 //////////////////////////////////////////////////////////////////////////////\r
 723 //\r
 724 //////////////////////////////////////////////////////////////////////////////\r
 725 //\r
 726 //\r
 727 //\r
 728 //////////////////////////////////////////////////////////////////////////////\r
 729 uint8 op_byte_read(uint32 offset)\r
 730 {\r
 731         offset &= 0x3F;\r
 732         return objectp_ram[offset];\r
 733 }\r
 734 //////////////////////////////////////////////////////////////////////////////\r
 735 //\r
 736 //////////////////////////////////////////////////////////////////////////////\r
 737 //\r
 738 //\r
 739 //\r
 740 //////////////////////////////////////////////////////////////////////////////\r
 741 uint16 op_word_read(uint32 offset)\r
 742 {\r
 743         return (objectp_ram[offset & 0x3F] << 8) | objectp_ram[(offset+1) & 0x3F];\r
 744 }\r
 745 //////////////////////////////////////////////////////////////////////////////\r
 746 //\r
 747 //////////////////////////////////////////////////////////////////////////////\r
 748 //\r
 749 //\r
 750 //\r
 751 //////////////////////////////////////////////////////////////////////////////\r
 752 uint32 op_get_list_pointer(void)\r
 753 {\r
 754         uint32 ptr = objectp_ram[0x22];\r
 755         ptr <<= 8;\r
 756         ptr |= objectp_ram[0x23];\r
 757         ptr <<= 8;\r
 758         ptr |= objectp_ram[0x20];\r
 759         ptr <<= 8;\r
 760         ptr |= objectp_ram[0x21];\r
 761         ptr &= ~0x07;\r
 762 \r
 763         return ptr;//*/\r
 764 //      return (objectp_ram[0x20] << 24) | (objectp_ram[0x21] << 16) | (objectp_ram[0x22] << 8) | objectp_ram[0x23];\r
 765 }\r
 766 //////////////////////////////////////////////////////////////////////////////\r
 767 //\r
 768 //////////////////////////////////////////////////////////////////////////////\r
 769 //\r
 770 //\r
 771 //\r
 772 //////////////////////////////////////////////////////////////////////////////\r
 773 uint32 op_get_status_register(void)\r
 774 {\r
 775         uint32 ptr = objectp_ram[0x26];\r
 776         ptr <<= 8;\r
 777         ptr |= objectp_ram[0x27];\r
 778         ptr <<= 8;\r
 779         ptr |= objectp_ram[0x28];\r
 780         ptr <<= 8;\r
 781         ptr |= objectp_ram[0x29];\r
 782 \r
 783         return ptr;\r
 784 }\r
 785 //////////////////////////////////////////////////////////////////////////////\r
 786 //\r
 787 //////////////////////////////////////////////////////////////////////////////\r
 788 //\r
 789 //\r
 790 //\r
 791 //////////////////////////////////////////////////////////////////////////////\r
 792 void op_set_status_register(uint32 data)\r
 793 {\r
 794         objectp_ram[0x26] = (data & 0xFF000000) >> 24;\r
 795         objectp_ram[0x27] = (data & 0x00FF0000) >> 16;\r
 796         objectp_ram[0x28] = (data & 0x0000FF00) >> 8;\r
 797         objectp_ram[0x29] |= (data & 0xFE);\r
 798 }\r
 799 //////////////////////////////////////////////////////////////////////////////\r
 800 //\r
 801 //////////////////////////////////////////////////////////////////////////////\r
 802 //\r
 803 //\r
 804 //\r
 805 //////////////////////////////////////////////////////////////////////////////\r
 806 void op_set_current_object(uint64 object)\r
 807 {\r
 808         // less significant 32 bits first\r
 809         objectp_ram[0x13] = object&0xff; object>>=8;\r
 810         objectp_ram[0x12] = object&0xff; object>>=8;\r
 811         objectp_ram[0x11] = object&0xff; object>>=8;\r
 812         objectp_ram[0x10] = object&0xff; object>>=8;\r
 813 \r
 814         objectp_ram[0x17] = object&0xff; object>>=8;\r
 815         objectp_ram[0x16] = object&0xff; object>>=8;\r
 816         objectp_ram[0x15] = object&0xff; object>>=8;\r
 817         objectp_ram[0x14] = object&0xff; \r
 818 }\r
 819 \r