![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to vdp.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Generator SEGA Genesis emulator] / generator / main|
Return to vdp.c CVS log | Up to [Generator SEGA Genesis emulator] / generator / main |
1.1 ! root 1: /* Generator is (c) James Ponder, 1997-2001 http://www.squish.net/generator/ */ ! 2: ! 3: /* video display processor emulation */ ! 4: ! 5: /* for dma 'bytes per line' stuff we use 'memory to vram' figures as a baseline ! 6: and double the number of real bytes for 'vram copy' in order to adjust to ! 7: our model; also there is a subtraction of one for vram fill to compensate ! 8: there too - probably being far too picky and it isn't exactly perfect ! 9: anyway */ ! 10: ! 11: /* to do: fix F flag in status register */ ! 12: ! 13: #include <stdlib.h> ! 14: #include <stdio.h> ! 15: #include <string.h> ! 16: ! 17: #include "generator.h" ! 18: #include "vdp.h" ! 19: #include "cpu68k.h" ! 20: #include "ui.h" ! 21: #include "event.h" ! 22: ! 23: #undef DEBUG_VDP ! 24: #undef DEBUG_VDPDMA ! 25: #undef DEBUG_VDPDATA ! 26: #undef DEBUG_VDPCRAM ! 27: ! 28: /*** variables externed ***/ ! 29: ! 30: unsigned int vdp_event; ! 31: unsigned int vdp_vislines; ! 32: unsigned int vdp_visstartline; ! 33: unsigned int vdp_visendline; ! 34: unsigned int vdp_totlines; ! 35: unsigned int vdp_framerate; ! 36: unsigned int vdp_clock; ! 37: unsigned int vdp_68kclock; ! 38: unsigned int vdp_clksperline_68k; ! 39: unsigned int vdp_oddframe = 0; /* odd/even frame */ ! 40: unsigned int vdp_vblank = 0; /* set during vertical blanking */ ! 41: unsigned int vdp_hblank = 0; /* set during horizontal blanking */ ! 42: unsigned int vdp_line = 0; /* current line number */ ! 43: unsigned int vdp_vsync = 0; /* a vsync just happened */ ! 44: unsigned int vdp_dmabusy = 0; /* dma busy flag */ ! 45: unsigned int vdp_pal = 0; /* set for pal mode */ ! 46: unsigned int vdp_overseas = 1; /* set for overseas model */ ! 47: unsigned int vdp_layerB = 1; /* flag */ ! 48: unsigned int vdp_layerBp = 1; /* flag */ ! 49: unsigned int vdp_layerA = 1; /* flag */ ! 50: unsigned int vdp_layerAp = 1; /* flag */ ! 51: unsigned int vdp_layerW = 1; /* flag */ ! 52: unsigned int vdp_layerWp = 1; /* flag */ ! 53: unsigned int vdp_layerH = 1; /* flag */ ! 54: unsigned int vdp_layerS = 1; /* flag */ ! 55: unsigned int vdp_layerSp = 1; /* flag */ ! 56: uint8 vdp_cram[LEN_CRAM]; ! 57: uint8 vdp_vsram[LEN_VSRAM]; ! 58: uint8 vdp_vram[LEN_VRAM]; ! 59: uint8 vdp_cramf[LEN_CRAM/2]; ! 60: unsigned int vdp_event_start; ! 61: unsigned int vdp_event_vint; ! 62: unsigned int vdp_event_hint; ! 63: unsigned int vdp_event_hdisplay; ! 64: unsigned int vdp_event_end; ! 65: signed int vdp_nextevent = 0; ! 66: sint32 vdp_dmabytes = 0; /* bytes left in DMA - must be fixed size */ ! 67: signed int vdp_hskip_countdown = 0; /* actual countdown */ ! 68: uint16 vdp_address; /* address for data/dma transfers */ ! 69: t_code vdp_code; /* code number for data/dma transfers CD3-CD0 */ ! 70: unsigned int vdp_ctrlflag; /* set inbetween ctrl writes */ ! 71: uint16 vdp_first; /* first word of address set */ ! 72: uint16 vdp_second; /* second word of address set */ ! 73: ! 74: /*** global variables ***/ ! 75: ! 76: uint8 vdp_reg[25]; ! 77: static int vdp_collision; /* set during a sprite collision */ ! 78: static int vdp_overflow; /* set when too many sprites in one line */ ! 79: static int vdp_fifofull; /* set when write fifo full */ ! 80: static int vdp_fifoempty; /* set when write fifo empty */ ! 81: static int vdp_complex; /* set when simple routines can't cope */ ! 82: ! 83: /*** forward references ***/ ! 84: ! 85: void vdp_ramcopy_vram(int type); ! 86: void vdp_dma_vramcopy(void); ! 87: void vdp_dma_fill(uint8 data); ! 88: void vdp_showregs(void); ! 89: void vdp_describe(void); ! 90: void vdp_eventinit(void); ! 91: void vdp_layer_simple(unsigned int layer, unsigned int priority, ! 92: uint8 *fielddata, unsigned int lineoffset); ! 93: inline void vdp_plotcell(uint8 *patloc, uint8 palette, uint8 flags, ! 94: uint8 *cellloc, unsigned int lineoffset); ! 95: void vdp_sprites(unsigned int line, uint8 *pridata, uint8 *outdata); ! 96: inline void vdp_spritelayer(unsigned int line, uint8 *spritedata, ! 97: uint8 *pridata, uint8 *linedata, ! 98: unsigned int priority); ! 99: int vdp_sprite_simple(unsigned int priority, uint8 *framedata, ! 100: unsigned int lineoffset, unsigned int number, ! 101: uint8 *spritelist, uint8 *sprite); ! 102: void vdp_sprites_simple(unsigned int priority, uint8 *framedata, ! 103: unsigned int lineoffset); ! 104: void vdp_shadow_simple(uint8 *framedata, unsigned int lineoffset); ! 105: void vdp_window(unsigned int line, unsigned int priority, uint8 *linedata); ! 106: void vdp_newlayer(unsigned int line, uint8 *pridata, uint8 *outdata, ! 107: unsigned int layer); ! 108: void vdp_newwindow(unsigned int line, uint8 *pridata, uint8 *outdata); ! 109: ! 110: #define PRIBIT_LAYERB 0 ! 111: #define PRIBIT_LAYERA 1 ! 112: #define PRIBIT_SPRITE 2 ! 113: ! 114: /*** vdp_init - initialise this sub-unit ***/ ! 115: ! 116: int vdp_init(void) ! 117: { ! 118: vdp_reset(); ! 119: return 0; ! 120: } ! 121: ! 122: /*** vdp_setupvideo - setup parameters dependant on vdp_pal ***/ ! 123: ! 124: void vdp_setupvideo(void) ! 125: { ! 126: int v30 = (vdp_reg[1] & 1<<3) ? 1 : 0; ! 127: ! 128: if (!vdp_pal && v30) ! 129: ui_err("Impossible VDP mode - vertical 30 cell NTSC"); ! 130: ! 131: vdp_clock = vdp_pal ? 53200000 : 53693100; /* What speed is the PAL clock? */ ! 132: vdp_68kclock = vdp_clock / 7; ! 133: vdp_vislines = v30 ? 240 : 224; ! 134: vdp_visstartline = v30 ? 46 : (vdp_pal ? 54 : 19); ! 135: vdp_visendline = vdp_visstartline + vdp_vislines; ! 136: vdp_totlines = vdp_pal ? 312 : 262; ! 137: vdp_framerate = vdp_pal ? 50 : 60; ! 138: vdp_clksperline_68k = (vdp_68kclock/vdp_framerate/vdp_totlines); ! 139: } ! 140: ! 141: /*** vdp_softreset - soft reset ***/ ! 142: ! 143: void vdp_softreset(void) ! 144: { ! 145: /* a soft reset involves resetting the cpu so we need to reset the ! 146: vdp event timers */ ! 147: vdp_eventinit(); ! 148: } ! 149: ! 150: /*** vdp_reset - reset vdp sub-unit ***/ ! 151: ! 152: void vdp_reset(void) ! 153: { ! 154: int i; ! 155: ! 156: /* clear registers */ ! 157: ! 158: for (i = 0; i < 25; i++) ! 159: vdp_reg[i] = 0; ! 160: ! 161: /* set PAL/NTSC variables */ ! 162: ! 163: vdp_setupvideo(); ! 164: vdp_vblank = 0; ! 165: vdp_hblank = 0; ! 166: vdp_oddframe = 0; ! 167: vdp_collision = 0; ! 168: vdp_overflow = 0; ! 169: vdp_vsync = 0; ! 170: vdp_fifofull = 0; ! 171: vdp_fifoempty = 0; ! 172: vdp_ctrlflag = 0; ! 173: ! 174: memset(vdp_cram, 0, LEN_CRAM); ! 175: memset(vdp_vsram, 0, LEN_VSRAM); ! 176: memset(vdp_vram, 0, LEN_VRAM); ! 177: ! 178: /* clear CRAM */ ! 179: ! 180: for (i = 0; i < 64; i++) { ! 181: (vdp_cram+i*2)[0] = (i & 7)<<1; ! 182: (vdp_cram+i*2)[1] = (i & 7)<<5 | (i & 7)<<1; ! 183: vdp_cramf[i] = 1; ! 184: } ! 185: vdp_eventinit(); ! 186: LOG_VERBOSE(("VDP: totlines = %d (%s)", vdp_totlines, vdp_pal ? ! 187: "PAL" : "NTSC")); ! 188: } ! 189: ! 190: uint16 vdp_status(void) ! 191: { ! 192: uint16 ret; ! 193: ! 194: /* bit meaning (when set) ! 195: * 0 0:ntsc 1:pal ! 196: * 1 dma busy ! 197: * 2 during h blanking ! 198: * 3 during v blanking ! 199: * 4 frame in interlace mode - 0:even 1:odd ! 200: * 5 collision happened between non-zero pixels in two sprites ! 201: * 6 too many sprites in one line ! 202: * 7 v interrupt has happened ! 203: * 8 write fifo full ! 204: * 9 write fifo empty ! 205: * 10-15 are next word on bus, i.e. next word in ROM - CM ! 206: */ ! 207: ret = vdp_pal | vdp_dmabusy<<1 | vdp_hblank<<2 | vdp_vblank<<3 | ! 208: vdp_oddframe<<4 | vdp_collision<<5 | vdp_overflow<<6 | vdp_vsync<<7 | ! 209: vdp_fifofull<<8 | vdp_fifoempty<<9; ! 210: ! 211: #ifdef DEBUG_VDP ! 212: if (vdp_collision) ! 213: LOG_VERBOSE(("%08X Collision read", vdp_collision)); ! 214: #endif ! 215: ! 216: vdp_vsync = vdp_collision = vdp_overflow = 0; ! 217: vdp_ctrlflag = 0; /* Charles MacDonald - so he claims ;) */ ! 218: ! 219: LOG_DEBUG1(("%08X STATUS READ %02X", regs.pc, ret)); ! 220: ! 221: return (ret); ! 222: } ! 223: ! 224: void vdp_storectrl(uint16 data) ! 225: { ! 226: uint8 reg; ! 227: uint8 regdata; ! 228: ! 229: if (!vdp_ctrlflag) { ! 230: if ((data & 0xE000) == 0x8000) { ! 231: /* register set */ ! 232: reg = (data>>8) & 31; ! 233: regdata = data & 255; ! 234: if (reg > 24) { ! 235: LOG_NORMAL(("%08X [VDP] Invalid register (%d)", regs.pc, ! 236: ((data>>8) & 31))); ! 237: return; ! 238: } ! 239: vdp_reg[reg] = regdata; ! 240: vdp_code = 0; ! 241: #ifdef DEBUG_VDP ! 242: LOG_VERBOSE(("%08X [VDP] Register %d set to %04X", regs.pc, ! 243: reg, regdata)); ! 244: #endif ! 245: return; ! 246: } else { ! 247: vdp_ctrlflag = 1; ! 248: vdp_first = data; ! 249: return; ! 250: } ! 251: } else { ! 252: vdp_second = data; ! 253: vdp_ctrlflag = 0; ! 254: vdp_code = ((vdp_first>>14) & 3) | ((data>>2) & (3<<2)); ! 255: vdp_address = (vdp_first & 0x3FFF) | (data<<14 & 0xC000); ! 256: ! 257: if ((data & 1<<7) && (vdp_reg[1] & 1<<4)) { /* CD5 - DMA ? */ ! 258: if (vdp_dmabusy) { ! 259: vdp_dmabusy = 1; /* null statement to avoid gcc warnings */ ! 260: LOG_DEBUG1(("DMA initiation during DMA!")); ! 261: } ! 262: /* CD4 - not read - need to verify */ ! 263: vdp_dmabusy = 1; ! 264: switch((vdp_reg[23] >> 6) & 3) { ! 265: case 0: ! 266: case 1: /* ram to vram */ ! 267: switch (vdp_code) { ! 268: case 1: /* ram copy to vram */ ! 269: vdp_ramcopy_vram(0); ! 270: break; ! 271: case 3: /* ram copy to cram */ ! 272: vdp_ramcopy_vram(1); ! 273: break; ! 274: case 5: /* ram copy to vsram */ ! 275: vdp_ramcopy_vram(2); ! 276: break; ! 277: default: /* undefined */ ! 278: LOG_NORMAL(("%08X [VDP] start of type %d to address %X", ! 279: regs.pc, vdp_code, vdp_address)); ! 280: break; ! 281: } ! 282: vdp_dmabusy = 0; /* 68k was frozen */ ! 283: break; ! 284: case 2: /* VRAM fill */ ! 285: /* later folks */ ! 286: break; ! 287: case 3: /* VRAM copy */ ! 288: vdp_dma_vramcopy(); ! 289: /* vdp_dmabusy is cleared when vdp_dmabytes is empty */ ! 290: break; ! 291: } ! 292: } ! 293: } ! 294: } ! 295: ! 296: void vdp_ramcopy_vram_obsolete(int type) ! 297: { ! 298: uint16 length = vdp_reg[19] | vdp_reg[20]<<8; ! 299: uint8 srcbank = vdp_reg[23]; ! 300: uint16 srcoffset = vdp_reg[21] | vdp_reg[22]<<8; ! 301: uint8 increment = vdp_reg[15]; ! 302: uint16 *srcmemory; ! 303: uint16 data; ! 304: uint8 *memory; ! 305: uint16 length_t; ! 306: uint16 vdp_address_t; ! 307: uint32 vdp_address_mask; ! 308: ! 309: /* VRAM (type 0): reads are word-wide, writes are byte-wide */ ! 310: /* CRAM (type 1) WSRAM (type 2): reads are word-wide, writes are byte-wide */ ! 311: ! 312: if (srcbank & 1<<6) { ! 313: /* this is a ram source - note altered beast uses E00000 upwards */ ! 314: srcmemory = (uint16 *)cpu68k_ram; ! 315: srcoffset&= 0x7fff; ! 316: #ifdef DEBUG_VDP ! 317: LOG_VERBOSE(("%08X [VDP] ramcopy from RAM offset %08X type=%d " ! 318: "vdpaddr=%08X length=%d", ! 319: regs.pc, srcoffset*2, type, vdp_address, length)); ! 320: #endif ! 321: } else { ! 322: /* this is a rom source - each bank is 128k, srcoffset is in words */ ! 323: srcmemory = (uint16 *)(cpu68k_rom + srcbank*0x20000); ! 324: #ifdef DEBUG_VDP ! 325: LOG_VERBOSE(("%08X [VDP] ramcopy from ROM offset %08X type=%d " ! 326: "vdpaddr=%08X length=%d", ! 327: regs.pc, srcbank*0x20000+srcoffset*2, type, vdp_address, ! 328: length)); ! 329: #endif ! 330: } ! 331: ! 332: switch(type) { ! 333: case 0: ! 334: memory = vdp_vram; ! 335: vdp_address_mask = LEN_VRAM-1; ! 336: break; ! 337: case 1: ! 338: length&= 0xff; /* maybe this or maybe we just stop at the end */ ! 339: memory = vdp_cram; ! 340: vdp_address_mask = LEN_CRAM-1; ! 341: length_t = length; ! 342: vdp_address_t = vdp_address & vdp_address_mask; ! 343: for(; length_t; length_t--) { ! 344: vdp_cramf[vdp_address_t>>1] = 1; ! 345: vdp_address_t+= increment; ! 346: vdp_address_t&= vdp_address_mask; ! 347: } ! 348: break; ! 349: case 2: ! 350: length&= 0xff; /* maybe this or maybe we just stop at the end */ ! 351: memory = vdp_vsram; ! 352: vdp_address_mask = 255; ! 353: if (vdp_address + (length * increment) > LEN_VSRAM) { ! 354: LOG_CRITICAL(("%08X [VDP] write to out of bounds vsram addr=$%X " ! 355: "len=$%X inc=$%X end=$%X", regs.pc, vdp_address, ! 356: length, increment, LEN_VSRAM)); ! 357: } ! 358: break; ! 359: default: ! 360: LOG_NORMAL(("%08X [VDP] Bad type %d", regs.pc, type)); ! 361: return; ! 362: } ! 363: vdp_address_t = vdp_address & vdp_address_mask; ! 364: for(; length; length--) { ! 365: data = LOCENDIAN16(srcmemory[srcoffset]); ! 366: #ifdef DEBUG_VDPDMA ! 367: /* ! 368: LOG_VERBOSE(("%08X [VDP] data %04X (ram/rom+2*%04X) -> %04X", ! 369: regs.pc, data, srcoffset, vdp_address_t)); ! 370: */ ! 371: #endif ! 372: memory[vdp_address_t] = data>>8; ! 373: memory[vdp_address_t+1] = data & 0xff; ! 374: srcoffset+= 1; ! 375: vdp_address_t+= increment; ! 376: vdp_address_t&= vdp_address_mask; ! 377: } ! 378: /* don't think about writing vdp_address_t into registers - T2 is a good ! 379: example of something that doesn't like that */ ! 380: } ! 381: ! 382: void vdp_ramcopy_vram(int type) ! 383: { ! 384: uint16 length = vdp_reg[19] | vdp_reg[20]<<8; ! 385: uint8 srcbank = vdp_reg[23]; ! 386: uint16 srcoffset = vdp_reg[21] | vdp_reg[22]<<8; ! 387: uint8 increment = vdp_reg[15]; ! 388: uint16 *srcmemory; ! 389: uint16 srcmask; ! 390: uint16 data; ! 391: unsigned int i; ! 392: ! 393: #ifdef DEBUG_VDP ! 394: LOG_VERBOSE(("%08X [VDP] VRAM copy from source %08X " ! 395: "vdpaddr=%08X length=%d", ! 396: regs.pc, (srcbank*0x10000+srcoffset)*2, vdp_address, length)); ! 397: #endif ! 398: ! 399: if (srcbank & 1<<6) { ! 400: srcmemory = (uint16 *)cpu68k_ram; ! 401: srcmask = 0x7fff; /* 32k words = 64k */ ! 402: } else { ! 403: srcmemory = (uint16 *)(cpu68k_rom + srcbank*0x20000); ! 404: srcmask = 0xffff; /* 64k words = 128k */ ! 405: } ! 406: for (i = 0; i < length; i++) { ! 407: data = LOCENDIAN16(srcmemory[srcoffset & srcmask]); ! 408: switch (type) { ! 409: case 0: /* VRAM */ ! 410: vdp_vram[vdp_address] = data>>8; ! 411: vdp_vram[vdp_address ^ 1] = data & 0xff; ! 412: break; ! 413: case 1: /* CRAM */ ! 414: vdp_cram[vdp_address & 0x7e] = data>>8; ! 415: vdp_cram[(vdp_address & 0x7e) | 1] = data & 0xff; ! 416: vdp_cramf[vdp_address>>1] = 1; ! 417: break; ! 418: case 2: /* VSRAM */ ! 419: if ((vdp_address & 0x7e) < LEN_VSRAM) { ! 420: vdp_vsram[vdp_address & 0x7e] = data>>8; ! 421: vdp_vsram[(vdp_address & 0x7e) | 1] = data & 0xff; ! 422: } ! 423: break; ! 424: } ! 425: srcoffset+=1; ! 426: vdp_address+= increment; ! 427: } ! 428: vdp_reg[19] = 0; ! 429: vdp_reg[20] = 0; ! 430: vdp_reg[22] = (srcoffset >> 8) & 0xff; ! 431: vdp_reg[21] = srcoffset & 0xff; ! 432: /* vram sends bytes, cram/vsram send words so are twice as efficient */ ! 433: event_freeze(type == 0 ? length*2 : length); ! 434: } ! 435: ! 436: void vdp_dma_vramcopy() ! 437: { ! 438: uint32 length = vdp_reg[19] | vdp_reg[20]<<8; ! 439: uint8 increment = vdp_reg[15]; ! 440: uint16 srcaddr = vdp_reg[21] | vdp_reg[22]<<8; ! 441: unsigned int i; ! 442: ! 443: if (length == 0) { ! 444: LOG_NORMAL(("%08X [VDP] Warning - length of 0 used in vram copy")); ! 445: length = 0x10000; /* could be 0xffff */ ! 446: } ! 447: ! 448: #ifdef DEBUG_VDPDMA ! 449: LOG_VERBOSE(("%08X [VDP] COPY length %04X dstaddr %08X inc %02X " ! 450: "srcaddr %04X", regs.pc, length, vdp_address, increment, ! 451: srcaddr)); ! 452: #endif ! 453: ! 454: for (i = 0; i < length; i++) { ! 455: vdp_vram[vdp_address] = vdp_vram[srcaddr++]; ! 456: vdp_address+= increment; ! 457: } ! 458: ! 459: vdp_reg[19] = 0; ! 460: vdp_reg[20] = 0; ! 461: vdp_reg[22] = (srcaddr >> 8) & 0xff; ! 462: vdp_reg[21] = srcaddr & 0xff; ! 463: vdp_dmabytes = length*2; /* factor of 2 vram copy to vram fill (p36) */ ! 464: } ! 465: ! 466: void vdp_dma_fill(uint8 data) ! 467: { ! 468: uint16 length = vdp_reg[19] | vdp_reg[20]<<8; ! 469: uint8 increment = vdp_reg[15]; ! 470: unsigned int screencells = (vdp_reg[12] & 1) ? 40 : 32; ! 471: unsigned int i; ! 472: ! 473: if (increment != 1 && increment != 2) ! 474: LOG_NORMAL(("VDP fill used with strange increment %d", increment)); ! 475: ! 476: for (i = 0; i < length; i++) { ! 477: vdp_vram[vdp_address] = data; ! 478: vdp_address+= increment; /* 16 bit wrap */ ! 479: } ! 480: vdp_reg[19] = 0; ! 481: vdp_reg[20] = 0; ! 482: vdp_dmabytes = length+1; /* extra byte used (see p36) */ ! 483: } ! 484: ! 485: uint16 vdp_fetchdata_obsolete(void) ! 486: { ! 487: uint8 *memory; ! 488: uint32 size; ! 489: uint16 data; ! 490: ! 491: switch(vdp_code) { ! 492: case cd_vram_fetch: ! 493: #ifdef DEBUG_VDPDATA ! 494: LOG_VERBOSE(("%08X [VDP] VRAM fetch from address %X", regs.pc, ! 495: vdp_address)); ! 496: #endif ! 497: memory = vdp_vram; ! 498: size = LEN_VRAM; ! 499: break; ! 500: case cd_vsram_fetch: ! 501: #ifdef DEBUG_VDPDATA ! 502: LOG_VERBOSE(("%08X [VDP] VSRAM fetch from address %X", ! 503: regs.pc, vdp_address)); ! 504: #endif ! 505: memory = vdp_vsram; ! 506: size = LEN_VSRAM; ! 507: break; ! 508: case cd_cram_fetch: ! 509: #ifdef DEBUG_VDPDATA ! 510: LOG_VERBOSE(("%08X [VDP] CRAM fetch from address %X", regs.pc, ! 511: vdp_address)); ! 512: #endif ! 513: memory = vdp_cram; ! 514: size = LEN_CRAM; ! 515: break; ! 516: default: ! 517: LOG_NORMAL(("%08X [VDP] Fetch in invalid mode %d", regs.pc, ! 518: vdp_code)); ! 519: return 0; ! 520: } ! 521: if (vdp_address>=size) { ! 522: LOG_VERBOSE(("%08X [VDP] Address (%08X) out of bounds (%08X)", ! 523: regs.pc, vdp_address, size)); ! 524: } ! 525: data = LOCENDIAN16(*(uint16 *)(memory+(vdp_address & ~1))); ! 526: #ifdef DEBUG_VDPDATA ! 527: LOG_VERBOSE(("%08X [VDP] Fetch %04X from %08X", regs.pc, data, ! 528: vdp_address & ~1)); ! 529: #endif ! 530: vdp_address+= vdp_reg[15]; ! 531: vdp_ctrlflag = 0; ! 532: return data; ! 533: } ! 534: ! 535: void vdp_storedata(uint16 data) ! 536: { ! 537: uint16 address; ! 538: uint16 sdata; ! 539: ! 540: if (vdp_ctrlflag) { ! 541: LOG_NORMAL(("%08X [VDP] Unterminated ctrl setting %04X/%04X", regs.pc, ! 542: vdp_first, vdp_second)); ! 543: vdp_storectrl(vdp_second); ! 544: } ! 545: ! 546: switch(vdp_code) { ! 547: case cd_vram_store: ! 548: sdata = (vdp_address & 1) ? SWAP16(data) : data; /* only for VRAM */ ! 549: *(uint16 *)(vdp_vram+(vdp_address & 0xfffe)) = LOCENDIAN16(sdata); ! 550: break; ! 551: case cd_cram_store: ! 552: address = vdp_address & 0x7e; /* address lines used */ ! 553: *(uint16 *)(vdp_cram+address) = LOCENDIAN16(data); ! 554: vdp_cramf[address>>1] = 1; ! 555: break; ! 556: case cd_vsram_store: ! 557: address = vdp_address & 0x7e; /* address lines used */ ! 558: if (address < LEN_VSRAM) ! 559: *(uint16 *)(vdp_vsram+address) = LOCENDIAN16(data); ! 560: break; ! 561: default: /* undefined */ ! 562: LOG_NORMAL(("%08X [VDP] Bad word store to %08X of type %d data = %04X", ! 563: regs.pc, vdp_address, vdp_code, data)); ! 564: break; ! 565: } ! 566: vdp_address+= vdp_reg[15]; /* 16 bit wrap */ ! 567: ! 568: if (vdp_dmabusy) { ! 569: if (vdp_code == 1) ! 570: /* other vdp_codes consume time but don't result in fills */ ! 571: /* vdp_dmabusy is cleared when vdp_dmabytes is empty */ ! 572: vdp_dma_fill((data >> 8) & 0xff); ! 573: } ! 574: } ! 575: ! 576: uint16 vdp_fetchdata(void) ! 577: { ! 578: uint16 address; ! 579: uint16 data; ! 580: ! 581: if (vdp_ctrlflag) { ! 582: LOG_NORMAL(("%08X [VDP] Unterminated ctrl setting %04X/%04X", regs.pc, ! 583: vdp_first, vdp_second)); ! 584: vdp_storectrl(vdp_second); ! 585: } ! 586: ! 587: switch(vdp_code) { ! 588: case cd_vram_fetch: ! 589: data = LOCENDIAN16(*(uint16 *)(vdp_vram+(vdp_address & 0xfffe))); ! 590: break; ! 591: case cd_cram_fetch: ! 592: address = vdp_address & 0x7e; /* address lines used */ ! 593: data = LOCENDIAN16(*(uint16 *)(vdp_cram+address)); ! 594: break; ! 595: case cd_vsram_fetch: ! 596: address = vdp_address & 0x7e; /* address lines used */ ! 597: if (address < LEN_VSRAM) ! 598: data = LOCENDIAN16(*(uint16 *)(vdp_vsram+address)); ! 599: else ! 600: data = 0; /* tests show this range appears random (although I'm sure it ! 601: isn't) */ ! 602: break; ! 603: default: /* undefined */ ! 604: /* reading in write mode suspends 68000 on a real machine */ ! 605: LOG_NORMAL(("%08X [VDP] Bad word fetch of %08X of type %d", ! 606: regs.pc, vdp_address, vdp_code)); ! 607: data = 0; ! 608: break; ! 609: } ! 610: vdp_address+= vdp_reg[15]; /* 16 bit wrap */ ! 611: return data; ! 612: } ! 613: ! 614: #define LINEDATA(offset, value, palette, priority) \ ! 615: if (value) { \ ! 616: linedata[offset] = (palette)*16 + value; \ ! 617: } else if (priority) { \ ! 618: linedata[offset] = (linedata[offset] & 63); \ ! 619: } ! 620: ! 621: #define LINEDATASPR(offset, value, palette, priority) \ ! 622: if (value) { \ ! 623: if (outdata[offset] < 62) \ ! 624: vdp_collision = 1; \ ! 625: if (priority) \ ! 626: pridata[offset]|= 1<<PRIBIT_SPRITE; \ ! 627: else \ ! 628: pridata[offset]&= ~(1<<PRIBIT_SPRITE); \ ! 629: outdata[offset] = (palette)*16 + value; \ ! 630: } ! 631: ! 632: #define LINEDATALAYER(offset, value, palette, priority) \ ! 633: if (priority) \ ! 634: pridata[offset]|= layer ? 1<<PRIBIT_LAYERB : 1<<PRIBIT_LAYERA; \ ! 635: if (value) \ ! 636: outdata[offset] = (palette)*16 + value; \ ! 637: else \ ! 638: outdata[offset] = 0; ! 639: ! 640: void vdp_sprites(unsigned int line, uint8 *pridata, uint8 *outdata) ! 641: { ! 642: uint8 interlace = (vdp_reg[12]>>1) & 3; ! 643: uint8 *spritelist = vdp_vram + ((vdp_reg[5] & 0x7F)<<9); ! 644: t_spriteinfo si[128]; /* 128 - max sprites supported per line */ ! 645: unsigned int sprites; ! 646: unsigned int idx; ! 647: int i; ! 648: uint8 link; ! 649: uint8 *sprite = spritelist; ! 650: int plotter; /* flag */ ! 651: unsigned int screencells = (vdp_reg[12] & 1) ? 40 : 32; ! 652: unsigned int maxspl = (vdp_reg[12] & 1) ? 20 : 16; /* max sprs/line */ ! 653: unsigned int cells; ! 654: uint8 loops = 0; ! 655: ! 656: for (idx = 0; loops < 255 && idx < maxspl; loops++) { ! 657: link = sprite[3] & 0x7F; ! 658: si[idx].sprite = sprite; ! 659: if (interlace == 3) ! 660: si[idx].vpos = (LOCENDIAN16(*(uint16 *)(sprite)) & 0x3FF) - 0x100; ! 661: else ! 662: si[idx].vpos = (LOCENDIAN16(*(uint16 *)(sprite)) & 0x1FF) - 0x080; ! 663: if ((signed int)line < si[idx].vpos) ! 664: goto next; ! 665: si[idx].vsize = 1+(sprite[2] & 3); ! 666: if (interlace == 3) ! 667: si[idx].vsize<<= 1; ! 668: si[idx].vmax = si[idx].vpos + si[idx].vsize*8; ! 669: if ((signed int)line >= si[idx].vmax) ! 670: goto next; ! 671: si[idx].hpos = (LOCENDIAN16(*(uint16 *)(sprite+6)) & 0x1FF) - 0x80; ! 672: si[idx].hsize = 1+((sprite[2]>>2) & 3); ! 673: si[idx].hplot = si[idx].hsize; ! 674: si[idx].hmax = si[idx].hpos + si[idx].hsize*8; ! 675: idx++; ! 676: next: ! 677: if (!link) ! 678: break; ! 679: sprite = spritelist + (link<<3); ! 680: ! 681: } ! 682: if (idx < 1) ! 683: return; ! 684: sprites = idx; ! 685: plotter = 1; ! 686: cells = (vdp_reg[12] & 1) ? 40 : 32; /* 320 or 256 pixels */ ! 687: /* loop masking */ ! 688: for (i = 0; i < (signed int)sprites; i++) { ! 689: if (plotter == 0) { ! 690: sprites = i; ! 691: break; ! 692: } ! 693: if (si[i].hpos == -128) { ! 694: /* mask sprite - but does it? */ ! 695: if (i > 0) { ! 696: /* is there a higher priority sprite? */ ! 697: if (si[i-1].vpos <= (signed int)line && ! 698: si[i-1].vmax > (signed int)line) { ! 699: /* match, mask time */ ! 700: plotter = 0; ! 701: } ! 702: } else { ! 703: /* higest priority sprite, so mask */ ! 704: plotter = 0; ! 705: } ! 706: si[i].hplot = 0; ! 707: } ! 708: if (si[i].hpos == -127) { ! 709: LOG_VERBOSE(("Warning: Use of hpos = 1 in plotter")); ! 710: plotter = 1; ! 711: } ! 712: if (cells >= si[i].hplot) { ! 713: cells-= si[i].hplot; ! 714: } else { ! 715: si[i].hplot = cells; /* only room for this many */ ! 716: cells = 0; ! 717: } ! 718: } ! 719: ! 720: { ! 721: sint16 hpos, vpos; ! 722: uint16 hsize, vsize, hplot; ! 723: sint16 hmax, vmax; ! 724: uint16 cellinfo; ! 725: uint16 pattern; ! 726: uint8 palette; ! 727: uint8 *cellline; ! 728: uint32 data; ! 729: uint8 pixel; ! 730: uint8 priority; ! 731: int j, k; ! 732: ! 733: /* loop around sprites until end of list marker or no more */ ! 734: for (i = sprites-1; i >= 0; i--) { ! 735: hpos = si[i].hpos; ! 736: vpos = si[i].vpos; ! 737: vsize = si[i].vsize; /* doubled when in interlace mode */ ! 738: hsize = si[i].hsize; ! 739: hmax = si[i].hmax; ! 740: vmax = si[i].vmax; ! 741: hplot = si[i].hplot; /* number of cells to plot for this sprite */ ! 742: cellinfo = LOCENDIAN16(*(uint16 *)(si[i].sprite+4)); ! 743: pattern = cellinfo & 0x7FF; ! 744: palette = (cellinfo >> 13) & 3; ! 745: priority = (cellinfo >> 15) & 1; ! 746: ! 747: cellline = vdp_vram + ((interlace == 3) ? (pattern<<6) : (pattern<<5)); ! 748: if (cellinfo & 1<<12) /* vertical flip */ ! 749: cellline+= (vmax-line-1)*4; ! 750: else ! 751: cellline+= (line-vpos)*4; ! 752: for (k = 0; k < hsize && hplot--; k++) { ! 753: if (hpos > -8 && hpos < 0) { ! 754: if (cellinfo & 1<<11) { ! 755: /* horizontal flip */ ! 756: data = LOCENDIAN32(*(uint32 *)(cellline+ ! 757: (hsize-k*2-1)*(vsize<<5))); ! 758: data>>= (-hpos)*4; /* get first pixel in bottom 4 bits */ ! 759: for (j = 0; j < 8+hpos; j++) { ! 760: pixel = data & 15; ! 761: LINEDATASPR(j, pixel, palette, priority); ! 762: data>>= 4; ! 763: } ! 764: } else { ! 765: data = LOCENDIAN32(*(uint32 *)cellline); ! 766: data<<= (-hpos)*4; /* get first pixel in top 4 bits */ ! 767: for (j = 0; j < 8+hpos; j++) { ! 768: pixel = (data>>28) & 15; ! 769: LINEDATASPR(j, pixel, palette, priority); ! 770: data<<= 4; ! 771: } ! 772: } ! 773: } else if (hpos >= 0 && hpos <= (signed int)(screencells-1)*8) { ! 774: if (cellinfo & 1<<11) { ! 775: /* horizontal flip */ ! 776: data = LOCENDIAN32(*(uint32 *)(cellline+ ! 777: (hsize-k*2-1)*(vsize<<5))); ! 778: for (j = 0; j < 8; j++) { ! 779: pixel = data & 15; ! 780: LINEDATASPR(hpos+j, pixel, palette, priority); ! 781: data>>= 4; ! 782: } ! 783: } else { ! 784: data = LOCENDIAN32(*(uint32 *)cellline); ! 785: for (j = 0; j < 8; j++) { ! 786: pixel = (data>>28) & 15; ! 787: LINEDATASPR(hpos+j, pixel, palette, priority); ! 788: data<<= 4; ! 789: } ! 790: } ! 791: } else if (hpos > (signed int)(screencells-1)*8 && ! 792: hpos < (signed int)screencells*8) { ! 793: if (cellinfo & 1<<11) { ! 794: /* horizontal flip */ ! 795: data = LOCENDIAN32(*(uint32 *)(cellline+ ! 796: (hsize-k*2-1)*(vsize<<5))); ! 797: for (j = 0; j < (signed int)(screencells*8 - hpos); j++) { ! 798: pixel = data & 15; ! 799: LINEDATASPR(hpos+j, pixel, palette, priority); ! 800: data>>= 4; ! 801: } ! 802: } else { ! 803: data = LOCENDIAN32(*(uint32 *)cellline); ! 804: for (j = 0; j < (signed int)(screencells*8 - hpos); j++) { ! 805: pixel = (data>>28) & 15; ! 806: LINEDATASPR(hpos+j, pixel, palette, priority); ! 807: data<<= 4; ! 808: } ! 809: } ! 810: } ! 811: cellline+= vsize<<5; /* 32 bytes per cell (note vsize is doubled ! 812: when interlaced) */ ! 813: hpos+= 8; ! 814: } ! 815: } ! 816: } ! 817: } ! 818: ! 819: inline void vdp_spritelayer(unsigned int line, uint8 *spritedata, ! 820: uint8 *pridata, uint8 *linedata, ! 821: unsigned int priority) ! 822: { ! 823: int i; ! 824: ! 825: if (vdp_reg[12] & 1<<3) { /* s/ten = 1 */ ! 826: for (i = 0; i < 320; i++) { ! 827: if (pridata[i] == priority) { ! 828: if (spritedata[i]) { ! 829: if (spritedata[i] == 62) { /* pal=3, val=14 */ ! 830: linedata[i] = (linedata[i] & 63) + 64; ! 831: } else if (spritedata[i] == 63) { /* pal=3, val=15 */ ! 832: linedata[i] = (linedata[i] & 63) + 128; ! 833: } else { ! 834: linedata[i] = spritedata[i]; ! 835: } ! 836: } ! 837: } ! 838: } ! 839: } else { ! 840: for (i = 0; i < 320; i++) { ! 841: if (pridata[i] == priority) { ! 842: if (spritedata[i]) { ! 843: linedata[i] = spritedata[i]; ! 844: } ! 845: } ! 846: } ! 847: } ! 848: } ! 849: ! 850: /* layer 0 = A (top), layer 1 = B (bottom) */ ! 851: ! 852: void vdp_newlayer(unsigned int line, uint8 *pridata, uint8 *outdata, ! 853: unsigned int layer) ! 854: { ! 855: int i, j; ! 856: uint8 hsize = vdp_reg[16] & 3; ! 857: uint8 vsize = (vdp_reg[16] >> 4) & 3; ! 858: uint8 hmode = vdp_reg[11] & 3; ! 859: uint8 vmode = (vdp_reg[11] >> 2) & 1; ! 860: uint16 vramoffset = (layer ? ((vdp_reg[4] & 7) << 13) : ! 861: ((vdp_reg[2] & (7<<3)) << 10)); ! 862: uint16 *patterndata = (uint16 *)(vdp_vram + vramoffset); ! 863: uint16 *hscrolldata = (uint16 *)(((vdp_reg[13] & 63) << 10) ! 864: + vdp_vram + layer*2); ! 865: uint8 screencells = (vdp_reg[12] & 1) ? 40 : 32; ! 866: uint16 hwidth, vwidth, vmask, hoffset, voffset; ! 867: uint16 cellinfo; ! 868: uint8 *pattern; ! 869: uint32 data; ! 870: uint8 palette; ! 871: uint8 pixel; ! 872: uint8 winvpos; ! 873: uint8 priority; ! 874: int interlace = (vdp_reg[12] >> 1) & 3; ! 875: int realline = interlace ? line >> 1 : line; ! 876: ! 877: if (layer == 0) { ! 878: int vcell = realline >> 3; ! 879: int topbottom = vdp_reg[18] & 0x80; ! 880: int winvpos = vdp_reg[18] & 0x1f; ! 881: int leftright = vdp_reg[17] & 0x80; ! 882: int winhpos = vdp_reg[17] & 0x1f; ! 883: ! 884: /* sometimes the window covers the whole line, so we skip layer A for ! 885: that bit - for lines where layer A appears even for just one cell we ! 886: plot the entire line - would it be worth improving this? */ ! 887: ! 888: if (topbottom ? (vcell >= winvpos) : (vcell < winvpos)) ! 889: return; /* window is on the whole line */ ! 890: ! 891: /* it could be that the vdp is in such a state that there is no whole line ! 892: part to the window, but reg[17] is either 00 or 1F, meaning that ! 893: infact there is (this is one way of turning on/off window) in which ! 894: case we really should optimise this case otherwise we could be ! 895: drawing layer A pointlessly as window will just clobber all our work) */ ! 896: ! 897: if (leftright ? (winhpos == 0) : (winhpos >= (screencells<<1))) ! 898: return; /* window is on the whole line */ ! 899: } ! 900: ! 901: /* isn't this bug fixed now? */ ! 902: /* BUG: layer A is still displayed left/right when window is on, ! 903: only apparent with high-priority layer A and low-priority window */ ! 904: ! 905: /* select horizontal scrolling offset based on mode */ ! 906: ! 907: switch(hmode) { ! 908: case 0: /* full screen */ ! 909: hoffset = (0x400 - LOCENDIAN16(hscrolldata[0])) & 0x3FF; ! 910: break; ! 911: case 2: /* cell scroll */ ! 912: hoffset = (0x400 - LOCENDIAN16(hscrolldata[2*(realline & ~7)])) & 0x3FF; ! 913: break; ! 914: case 3: /* line scroll */ ! 915: hoffset = (0x400 - LOCENDIAN16(hscrolldata[2*realline])) & 0x3FF; ! 916: break; ! 917: default: ! 918: LOG_NORMAL(("prohibited HSCR/LSCR")); ! 919: hoffset = 0; ! 920: break; ! 921: } ! 922: hwidth = (hsize+1) << 5; ! 923: vwidth = ((vsize+1) << 5) * (interlace ? 2 : 1); ! 924: vmask = (vwidth << 3) - 1; /* to put offsets into range */ ! 925: hoffset&= (hwidth << 3)-1; /* put offset in range */ ! 926: voffset = (line + LOCENDIAN16( ((uint16 *)vdp_vsram)[layer] )) & vmask; ! 927: cellinfo = LOCENDIAN16(patterndata[(hoffset>>3)+ ! 928: hwidth*((voffset>>3)>>(interlace ? 1 : 0))]); ! 929: /* 32 bytes per pattern or 64 in interlace mode */ ! 930: pattern = vdp_vram + (((cellinfo & 2047)<<5) << (interlace ? 1 : 0)); ! 931: /* now get correct line from pattern data */ ! 932: switch (interlace) { ! 933: case 0: /* no interlace */ ! 934: case 1: /* ?? */ ! 935: case 2: /* ?? */ ! 936: if (cellinfo & 1<<12) { ! 937: /* vertical flip */ ! 938: pattern+= 4*(7-(voffset & 7)); ! 939: } else { ! 940: /* no vertical flip */ ! 941: pattern+= 4*(voffset & 7); ! 942: } ! 943: break; ! 944: case 3: /* interlace with double height cells */ ! 945: if (cellinfo & 1<<12) { ! 946: /* vertical flip */ ! 947: pattern+= 4*(15-(voffset & 15)); ! 948: } else { ! 949: /* no vertical flip */ ! 950: pattern+= 4*(voffset & 15); ! 951: } ! 952: break; ! 953: } ! 954: priority = (cellinfo >> 15) & 1; ! 955: palette = (cellinfo >> 13) & 3; ! 956: data = LOCENDIAN32(*(uint32 *)pattern); ! 957: if (cellinfo & 1<<11) { ! 958: /* horizontal flip */ ! 959: data>>= (hoffset & 7)*4; /* get first pixel in bottom 4 bits */ ! 960: for (i = 0; i < 8-(hoffset & 7); i++) { ! 961: pixel = data & 15; ! 962: LINEDATALAYER(i, pixel, palette, priority); ! 963: data>>= 4; ! 964: } ! 965: } else { ! 966: data<<= (hoffset & 7)*4; /* get first pixel in top 4 bits */ ! 967: for (i = 0; i < 8-(hoffset & 7); i++) { ! 968: pixel = (data>>28) & 15; ! 969: LINEDATALAYER(i, pixel, palette, priority); ! 970: data<<= 4; ! 971: } ! 972: } ! 973: outdata+= 8-(hoffset & 7); ! 974: pridata+= 8-(hoffset & 7); ! 975: hoffset+= 8; ! 976: hoffset&= (hwidth*8)-1; /* put offset in range */ ! 977: for (j = 1; j < screencells; j++) { ! 978: if (vmode) { ! 979: /* 2-cell scroll */ ! 980: /* DEBUG DEBUG DEBUG awooga awooga */ ! 981: voffset = (line + LOCENDIAN16( ((uint16 *)vdp_vsram) ! 982: [(j&~1)+layer] )) & vmask; ! 983: } else { ! 984: /* full screen */ ! 985: voffset = (line + LOCENDIAN16( ((uint16 *)vdp_vsram)[layer] )) & vmask; ! 986: } ! 987: cellinfo = LOCENDIAN16(patterndata[(hoffset>>3)+ ! 988: hwidth*((voffset>>3)>>(interlace ? 1 : 0))]); ! 989: priority = (cellinfo >> 15) & 1; ! 990: /* printf("hoff: %04X voff: %04X hwid: %04X cell: %08X info: %04X\n", ! 991: hoffset, voffset, hwidth, (hoffset>>3)+hwidth*(voffset>>3), ! 992: cellinfo); */ ! 993: /* printf("loc %08X cellinfo %08X\n", ! 994: (hoffset>>3)+hwidth*(voffset>>3), ! 995: cellinfo); */ ! 996: palette = (cellinfo >> 13) & 3; ! 997: /* 32 bytes per pattern or 64 in interlace mode */ ! 998: pattern = vdp_vram + (((cellinfo & 2047)<<5) << (interlace ? 1 : 0)); ! 999: /* now get correct line from pattern data */ ! 1000: switch (interlace) { ! 1001: case 0: /* no interlace */ ! 1002: case 1: /* ?? */ ! 1003: case 2: /* ?? */ ! 1004: if (cellinfo & 1<<12) { ! 1005: /* vertical flip */ ! 1006: pattern+= 4*(7-(voffset & 7)); ! 1007: } else { ! 1008: /* no vertical flip */ ! 1009: pattern+= 4*(voffset & 7); ! 1010: } ! 1011: break; ! 1012: case 3: /* interlace with double height cells */ ! 1013: if (cellinfo & 1<<12) { ! 1014: /* vertical flip */ ! 1015: pattern+= 4*(15-(voffset & 15)); ! 1016: } else { ! 1017: /* no vertical flip */ ! 1018: pattern+= 4*(voffset & 15); ! 1019: } ! 1020: break; ! 1021: } ! 1022: data = LOCENDIAN32(*(uint32 *)pattern); ! 1023: if (cellinfo & 1<<11) { ! 1024: /* horizontal flip */ ! 1025: for (i = 0; i < 8; i++) { ! 1026: pixel = data & 15; ! 1027: LINEDATALAYER(i, pixel, palette, priority); ! 1028: data>>= 4; ! 1029: } ! 1030: } else { ! 1031: for (i = 0; i < 8; i++) { ! 1032: pixel = (data>>28) & 15; ! 1033: LINEDATALAYER(i, pixel, palette, priority); ! 1034: data<<= 4; ! 1035: } ! 1036: } ! 1037: outdata+= 8; ! 1038: pridata+= 8; ! 1039: hoffset+= 8; ! 1040: hoffset&= (hwidth*8)-1; /* put offset in range */ ! 1041: } ! 1042: if (hoffset & 7) { ! 1043: if (vmode) { ! 1044: /* 2-cell scroll - note use last offset, not next */ ! 1045: /* DEBUG DEBUG DEBUG awooga awooga */ ! 1046: voffset = (line + LOCENDIAN16( ((uint16 *)vdp_vsram) ! 1047: [(screencells-2)+layer] )) & vmask; ! 1048: } else { ! 1049: /* full screen */ ! 1050: voffset = (line + LOCENDIAN16( ((uint16 *)vdp_vsram)[layer] )) & vmask; ! 1051: } ! 1052: cellinfo = LOCENDIAN16(patterndata[(hoffset>>3)+ ! 1053: hwidth*((voffset>>3)>>(interlace ? 1 : 0))]); ! 1054: priority = (cellinfo >> 15) & 1; ! 1055: palette = (cellinfo >> 13) & 3; ! 1056: /* 32 bytes per pattern or 64 in interlace mode */ ! 1057: pattern = vdp_vram + (((cellinfo & 2047)<<5) << (interlace ? 1 : 0)); ! 1058: /* now get correct line from pattern data */ ! 1059: switch (interlace) { ! 1060: case 0: /* no interlace */ ! 1061: case 1: /* ?? */ ! 1062: case 2: /* ?? */ ! 1063: if (cellinfo & 1<<12) { ! 1064: /* vertical flip */ ! 1065: pattern+= 4*(7-(voffset & 7)); ! 1066: } else { ! 1067: /* no vertical flip */ ! 1068: pattern+= 4*(voffset & 7); ! 1069: } ! 1070: break; ! 1071: case 3: /* interlace with double height cells */ ! 1072: if (cellinfo & 1<<12) { ! 1073: /* vertical flip */ ! 1074: pattern+= 4*(15-(voffset & 15)); ! 1075: } else { ! 1076: /* no vertical flip */ ! 1077: pattern+= 4*(voffset & 15); ! 1078: } ! 1079: break; ! 1080: } ! 1081: data = LOCENDIAN32(*(uint32 *)pattern); ! 1082: if (cellinfo & 1<<11) { ! 1083: /* horizontal flip */ ! 1084: for (i = 0; i < (hoffset & 7); i++) { ! 1085: pixel = data & 15; ! 1086: LINEDATALAYER(i, pixel, palette, priority); ! 1087: data>>= 4; ! 1088: } ! 1089: } else { ! 1090: for (i = 0; i < (hoffset & 7); i++) { ! 1091: pixel = (data>>28) & 15; ! 1092: LINEDATALAYER(i, pixel, palette, priority); ! 1093: data<<= 4; ! 1094: } ! 1095: } ! 1096: } ! 1097: } ! 1098: ! 1099: /* this function updates outdata/pridata which came from the layerA generation ! 1100: routines */ ! 1101: ! 1102: void vdp_newwindow(unsigned int line, uint8 *pridata, uint8 *outdata) ! 1103: { ! 1104: uint16 *patterndata = (uint16 *)(vdp_vram + ((vdp_reg[3] & 0x3e) << 10)); ! 1105: uint8 winhpos = vdp_reg[17] & 0x1f; ! 1106: uint8 winvpos = vdp_reg[18] & 0x1f; ! 1107: uint8 vcell = line / 8; ! 1108: uint8 hcell; ! 1109: uint8 voffset = line & 7; ! 1110: uint8 screencells = (vdp_reg[12] & 1) ? 40 : 32; ! 1111: uint8 topbottom = vdp_reg[18] & 0x80; ! 1112: uint8 leftright = vdp_reg[17] & 0x80; ! 1113: uint8 patternshift = (vdp_reg[12] & 1) ? 6 : 5; ! 1114: uint16 cellinfo; ! 1115: uint8 *pattern; ! 1116: uint32 data; ! 1117: uint8 palette; ! 1118: uint8 pixel; ! 1119: unsigned int i; ! 1120: unsigned int wholeline = 0; ! 1121: uint8 priority; ! 1122: int layer = 0; /* for LINEDATALAYER macro */ ! 1123: ! 1124: /* if topbottom is set then the wholeline part of the window is to the ! 1125: bottom, if it is clear then it is to the top ! 1126: in the other part of the window, if leftright is set then the window ! 1127: is on the right in this part of the screen ! 1128: this section below is repeated in the main renderline code, so that ! 1129: layerA is not unnecessarily calculated */ ! 1130: ! 1131: if (topbottom ? (vcell >= winvpos) : (vcell < winvpos)) ! 1132: wholeline = 1; ! 1133: ! 1134: if (!wholeline) { ! 1135: if (winhpos >= 20) ! 1136: winhpos = 20; /* 0x1F might be special? */ ! 1137: if (leftright) { ! 1138: /* clear out priority bits on right of line (winhpos units of 16 pix */ ! 1139: for (i = winhpos*4; i < 320/4; i++) /* winhpos units of 16 pix */ ! 1140: ((uint32 *)pridata)[i]&= (0xffffffff - (0x01010101<<PRIBIT_LAYERA)); ! 1141: memset(outdata+winhpos*16, 0, 320-(winhpos*16)); ! 1142: } else { ! 1143: /* clear out priority bits on left of line (winhpos units of 16 pix) */ ! 1144: for (i = 0; i < (unsigned int)(winhpos/4); i++) ! 1145: ((uint32 *)pridata)[i]&= (0xffffffff - (0x01010101<<PRIBIT_LAYERA)); ! 1146: memset(outdata, 0, winhpos*16); ! 1147: } ! 1148: } ! 1149: for (hcell = 0; hcell < screencells; hcell++, outdata+=8, pridata+=8) { ! 1150: if (!wholeline) { ! 1151: if (leftright) { ! 1152: if ((hcell>>1) < winhpos) ! 1153: continue; ! 1154: } else { ! 1155: if ((hcell>>1) >= winhpos) ! 1156: continue; ! 1157: } ! 1158: } ! 1159: cellinfo = LOCENDIAN16(patterndata[vcell<<patternshift | hcell]); ! 1160: priority = (cellinfo >> 15) & 1; ! 1161: palette = (cellinfo >> 13) & 3; ! 1162: /* 32 bytes per pattern */ ! 1163: pattern = vdp_vram + ((cellinfo & 2047)<<5); /* fix for interlace */ ! 1164: if (cellinfo & 1<<12) { ! 1165: /* vertical flip */ ! 1166: pattern+= 4*(7-(voffset & 7)); ! 1167: } else { ! 1168: /* no vertical flip */ ! 1169: pattern+= 4*(voffset & 7); ! 1170: } ! 1171: data = LOCENDIAN32(*(uint32 *)pattern); ! 1172: if (cellinfo & 1<<11) { ! 1173: /* horizontal flip */ ! 1174: for (i = 0; i < 8; i++) { ! 1175: pixel = data & 15; ! 1176: LINEDATALAYER(i, pixel, palette, priority); ! 1177: data>>= 4; ! 1178: } ! 1179: } else { ! 1180: for (i = 0; i < 8; i++) { ! 1181: pixel = (data>>28) & 15; ! 1182: LINEDATALAYER(i, pixel, palette, priority); ! 1183: data<<= 4; ! 1184: } ! 1185: } ! 1186: } /* hcell */ ! 1187: } ! 1188: ! 1189: inline void vdp_shadow(unsigned int line, uint8 *linedata) ! 1190: { ! 1191: int i; ! 1192: ! 1193: /* this could be done 4 bytes at a time */ ! 1194: for (i = 0; i < 320; i++) ! 1195: linedata[i] = (linedata[i] & 63) + 128; ! 1196: } ! 1197: ! 1198: void vdp_window(unsigned int line, unsigned int priority, uint8 *linedata) ! 1199: { ! 1200: uint16 *patterndata = (uint16 *)(vdp_vram + ((vdp_reg[3] & 0x3e) << 10)); ! 1201: uint8 winhpos = vdp_reg[17] & 0x1f; ! 1202: uint8 winvpos = vdp_reg[18] & 0x1f; ! 1203: uint8 vcell = line / 8; ! 1204: uint8 hcell; ! 1205: uint8 voffset = line & 7; ! 1206: uint8 screencells = (vdp_reg[12] & 1) ? 40 : 32; ! 1207: uint8 topbottom = vdp_reg[18] & 0x80; ! 1208: uint8 leftright = vdp_reg[17] & 0x80; ! 1209: uint8 patternshift = (vdp_reg[12] & 1) ? 6 : 5; ! 1210: uint16 cellinfo; ! 1211: uint8 *pattern; ! 1212: uint32 data; ! 1213: uint8 palette; ! 1214: uint8 pixel; ! 1215: unsigned int i; ! 1216: unsigned int wholeline = 0; ! 1217: ! 1218: if (topbottom) { ! 1219: /* bottom part */ ! 1220: /* Battle Tank sets winvpos to 0x1F and expects layer A to be off */ ! 1221: if (winvpos == 0x1F || vcell >= winvpos) ! 1222: wholeline = 1; ! 1223: } else { ! 1224: /* top part */ ! 1225: if (vcell < winvpos) ! 1226: wholeline = 1; ! 1227: } ! 1228: for (hcell = 0; hcell < screencells; hcell++, linedata+=8) { ! 1229: if (!wholeline) { ! 1230: if (leftright) { ! 1231: if ((hcell>>1) < winhpos) ! 1232: continue; ! 1233: } else { ! 1234: if ((hcell>>1) >= winhpos) ! 1235: continue; ! 1236: } ! 1237: } ! 1238: cellinfo = LOCENDIAN16(patterndata[vcell<<patternshift | hcell]); ! 1239: if (((uint8)((cellinfo & 1<<15) ? 1 : 0)) == priority) { ! 1240: palette = (cellinfo >> 13) & 3; ! 1241: pattern = vdp_vram + ((cellinfo & 2047)<<5); /* 32 bytes per pattern */ ! 1242: if (cellinfo & 1<<12) { ! 1243: /* vertical flip */ ! 1244: pattern+= 4*(7-(voffset & 7)); ! 1245: } else { ! 1246: /* no vertical flip */ ! 1247: pattern+= 4*(voffset & 7); ! 1248: } ! 1249: data = LOCENDIAN32(*(uint32 *)pattern); ! 1250: if (cellinfo & 1<<11) { ! 1251: /* horizontal flip */ ! 1252: for (i = 0; i < 8; i++) { ! 1253: pixel = data & 15; ! 1254: LINEDATA(i, pixel, palette, priority); ! 1255: data>>= 4; ! 1256: } ! 1257: } else { ! 1258: for (i = 0; i < 8; i++) { ! 1259: pixel = (data>>28) & 15; ! 1260: LINEDATA(i, pixel, palette, priority); ! 1261: data<<= 4; ! 1262: } ! 1263: } ! 1264: } ! 1265: } /* hcell */ ! 1266: } ! 1267: ! 1268: void vdp_layer_interlace(unsigned int line, unsigned int layer, ! 1269: unsigned int priority, uint8 *linedata) ! 1270: { ! 1271: int i, j; ! 1272: uint8 hsize = vdp_reg[16] & 3; ! 1273: uint8 vsize = (vdp_reg[16] >> 4) & 3; ! 1274: uint8 hmode = vdp_reg[11] & 3; ! 1275: uint8 vmode = (vdp_reg[11] >> 2) & 1; ! 1276: uint16 vramoffset = (layer ? ((vdp_reg[4] & 7) << 13) : ! 1277: ((vdp_reg[2] & (7<<3)) << 10)); ! 1278: uint16 *patterndata = (uint16 *)(vdp_vram + vramoffset); ! 1279: uint16 *hscrolldata = (uint16 *)(((vdp_reg[13] & 63) << 10) ! 1280: + vdp_vram + layer*2); ! 1281: uint8 screencells = (vdp_reg[12] & 1) ? 40 : 32; ! 1282: uint16 hwidth, vwidth, hoffset, voffset; ! 1283: uint16 cellinfo; ! 1284: uint8 *pattern; ! 1285: uint32 data; ! 1286: uint8 palette; ! 1287: uint8 pixel; ! 1288: uint8 topbottom, leftright, winhpos, winvpos; ! 1289: ! 1290: if (layer == 0) { ! 1291: /* turn off A when window is on */ ! 1292: topbottom = vdp_reg[18] & 0x80; ! 1293: leftright = vdp_reg[17] & 0x80; ! 1294: winhpos = vdp_reg[17] & 0x1f; ! 1295: winvpos = vdp_reg[18] & 0x1f; ! 1296: if (topbottom) { ! 1297: if ((line>>4) >= winvpos) ! 1298: return; ! 1299: } else { ! 1300: if ((line>>4) < winvpos) ! 1301: return; ! 1302: } ! 1303: } ! 1304: ! 1305: /* BUG: layer A is still displayed left/right when window is on, ! 1306: only apparent with high-priority layer A and low-priority window */ ! 1307: ! 1308: switch(hmode) { ! 1309: case 0: /* full screen */ ! 1310: hoffset = (0x400 - LOCENDIAN16(hscrolldata[0])) & 0x3FF; ! 1311: break; ! 1312: case 2: /* cell scroll */ ! 1313: /* interlace we use the actual line for the hscroll */ ! 1314: hoffset = (0x400 - LOCENDIAN16(hscrolldata[2*((line>>1) & ~7)])) & 0x3FF; ! 1315: break; ! 1316: case 3: /* line scroll */ ! 1317: /* interlace we use the actual line for the hscroll */ ! 1318: hoffset = (0x400 - LOCENDIAN16(hscrolldata[2*(line>>1)])) & 0x3FF; ! 1319: break; ! 1320: default: ! 1321: LOG_NORMAL(("prohibited HSCR/LSCR")); ! 1322: hoffset = 0; ! 1323: break; ! 1324: } ! 1325: hwidth = 32+hsize*32; ! 1326: vwidth = 32+vsize*32; ! 1327: hoffset&= (hwidth*8)-1; /* put offset in range */ ! 1328: voffset = (line + LOCENDIAN16( ((uint16 *)vdp_vsram)[layer] )) & 0x7FF; ! 1329: voffset&= (vwidth*16)-1; /* put offset in range */ ! 1330: ! 1331: cellinfo = LOCENDIAN16(patterndata[(hoffset>>3)+hwidth*(voffset>>4)]); ! 1332: if (((uint8)((cellinfo & 1<<15) ? 1 : 0)) == priority) { ! 1333: palette = (cellinfo >> 13) & 3; ! 1334: pattern = vdp_vram + ((cellinfo & 2047)<<6); /* 64 bytes per pattern */ ! 1335: if (cellinfo & 1<<12) { ! 1336: /* vertical flip */ ! 1337: pattern+= 4*(15-(voffset & 15)); ! 1338: } else { ! 1339: /* no vertical flip */ ! 1340: pattern+= 4*(voffset & 15); ! 1341: } ! 1342: data = LOCENDIAN32(*(uint32 *)pattern); ! 1343: if (cellinfo & 1<<11) { ! 1344: /* horizontal flip */ ! 1345: data>>= (hoffset & 7)*4; /* get first pixel in bottom 4 bits */ ! 1346: for (i = 0; i < 8-(hoffset & 7); i++) { ! 1347: pixel = data & 15; ! 1348: LINEDATA(i, pixel, palette, priority); ! 1349: data>>= 4; ! 1350: } ! 1351: } else { ! 1352: data<<= (hoffset & 7)*4; /* get first pixel in top 4 bits */ ! 1353: for (i = 0; i < 8-(hoffset & 7); i++) { ! 1354: pixel = (data>>28) & 15; ! 1355: LINEDATA(i, pixel, palette, priority); ! 1356: data<<= 4; ! 1357: } ! 1358: } ! 1359: } ! 1360: linedata+= 8-(hoffset & 7); ! 1361: hoffset+= 8; ! 1362: hoffset&= (hwidth*8)-1; /* put offset in range */ ! 1363: for (j = 0; j < screencells-1; j++) { ! 1364: if (vmode) { ! 1365: /* 2-cell scroll */ ! 1366: /* DEBUG DEBUG DEBUG awooga awooga */ ! 1367: voffset = (line + LOCENDIAN16( ((uint16 *)vdp_vsram) ! 1368: [2*(j>>1)+layer] )) & 0x7FF; ! 1369: } else { ! 1370: /* full screen */ ! 1371: voffset = (line + LOCENDIAN16( ((uint16 *)vdp_vsram)[layer] )) & 0x7FF; ! 1372: } ! 1373: voffset&= (vwidth*16)-1; /* put offset in range */ ! 1374: cellinfo = LOCENDIAN16(patterndata[(hoffset>>3)+hwidth*(voffset>>4)]); ! 1375: /* printf("hoff: %04X voff: %04X hwid: %04X cell: %08X info: %04X\n", ! 1376: hoffset, voffset, hwidth, (hoffset>>3)+hwidth*(voffset>>4), ! 1377: cellinfo); */ ! 1378: /* printf("loc %08X cellinfo %08X\n", ! 1379: (hoffset>>3)+hwidth*(voffset>>4), ! 1380: cellinfo); */ ! 1381: if (((uint8)((cellinfo & 1<<15) ? 1 : 0)) == priority) { ! 1382: palette = (cellinfo >> 13) & 3; ! 1383: pattern = vdp_vram + ((cellinfo & 2047)<<6); /* 64 bytes per pattern */ ! 1384: if (cellinfo & 1<<12) { ! 1385: /* vertical flip */ ! 1386: pattern+= 4*(15-(voffset & 15)); ! 1387: } else { ! 1388: /* no vertical flip */ ! 1389: pattern+= 4*(voffset & 15); ! 1390: } ! 1391: data = LOCENDIAN32(*(uint32 *)pattern); ! 1392: if (cellinfo & 1<<11) { ! 1393: /* horizontal flip */ ! 1394: for (i = 0; i < 8; i++) { ! 1395: pixel = data & 15; ! 1396: LINEDATA(i, pixel, palette, priority); ! 1397: data>>= 4; ! 1398: } ! 1399: } else { ! 1400: for (i = 0; i < 8; i++) { ! 1401: pixel = (data>>28) & 15; ! 1402: LINEDATA(i, pixel, palette, priority); ! 1403: data<<= 4; ! 1404: } ! 1405: } ! 1406: } ! 1407: linedata+= 8; ! 1408: hoffset+= 8; ! 1409: hoffset&= (hwidth*8)-1; /* put offset in range */ ! 1410: } ! 1411: if (hoffset & 7) { ! 1412: if (vmode) { ! 1413: /* 2-cell scroll - note use last offset, not next */ ! 1414: /* DEBUG DEBUG DEBUG awooga awooga */ ! 1415: voffset = (line + LOCENDIAN16( ((uint16 *)vdp_vsram) ! 1416: [2*(j>>1)+layer] )) & 0x7FF; ! 1417: } else { ! 1418: /* full screen */ ! 1419: voffset = (line + LOCENDIAN16( ((uint16 *)vdp_vsram)[layer] )) & 0x7FF; ! 1420: } ! 1421: voffset&= (vwidth*16)-1; /* put offset in range */ ! 1422: cellinfo = LOCENDIAN16(patterndata[(hoffset>>3)+hwidth*(voffset>>4)]); ! 1423: if (((uint8)((cellinfo & 1<<15) ? 1 : 0)) == priority) { ! 1424: palette = (cellinfo >> 13) & 3; ! 1425: pattern = vdp_vram + ((cellinfo & 2047)<<6); /* 64 bytes per pattern */ ! 1426: if (cellinfo & 1<<12) { ! 1427: /* vertical flip */ ! 1428: pattern+= 4*(15-(voffset & 15)); ! 1429: } else { ! 1430: /* no vertical flip */ ! 1431: pattern+= 4*(voffset & 15); ! 1432: } ! 1433: data = LOCENDIAN32(*(uint32 *)pattern); ! 1434: if (cellinfo & 1<<11) { ! 1435: /* horizontal flip */ ! 1436: for (i = 0; i < (hoffset & 7); i++) { ! 1437: pixel = data & 15; ! 1438: LINEDATA(i, pixel, palette, priority); ! 1439: data>>= 4; ! 1440: } ! 1441: } else { ! 1442: for (i = 0; i < (hoffset & 7); i++) { ! 1443: pixel = (data>>28) & 15; ! 1444: LINEDATA(i, pixel, palette, priority); ! 1445: data<<= 4; ! 1446: } ! 1447: } ! 1448: } ! 1449: linedata+= 8; ! 1450: } ! 1451: } ! 1452: ! 1453: void vdp_renderline(unsigned int line, uint8 *linedata, unsigned int odd) ! 1454: { ! 1455: int i; ! 1456: uint8 datablock[320*4]; ! 1457: uint8 *data_sprite = datablock; ! 1458: uint8 *data_layerA = datablock + 320; ! 1459: uint8 *data_layerB = datablock + 320*2; ! 1460: uint8 *priorities = datablock + 320*3; ! 1461: uint8 bg = vdp_reg[7] & 63; ! 1462: unsigned int winvpos = vdp_reg[18] & 0x1f; ! 1463: unsigned int interlace = (vdp_reg[12] >> 1) & 3; ! 1464: ! 1465: memset(datablock, 0, sizeof(datablock)); ! 1466: ! 1467: if ((vdp_reg[1] & 1<<6) == 0) { ! 1468: /* screen is disabled */ ! 1469: for (i = 0; i < 320; i++) ! 1470: linedata[i] = bg; ! 1471: return; ! 1472: } ! 1473: ! 1474: if (vdp_layerS || vdp_layerSp) ! 1475: vdp_sprites(interlace ? (line*2+odd) : line, priorities, data_sprite); ! 1476: if (vdp_layerA || vdp_layerAp) { ! 1477: vdp_newlayer(interlace ? (line*2+odd) : line, priorities, data_layerA, 0); ! 1478: if (vdp_layerW || vdp_layerWp) ! 1479: vdp_newwindow(line, priorities, data_layerA); ! 1480: } ! 1481: if (vdp_layerB || vdp_layerBp) ! 1482: vdp_newlayer(interlace ? (line*2+odd) : line, priorities, data_layerB, 1); ! 1483: ! 1484: for (i = 0; i < 320; i++) { ! 1485: switch(priorities[i] | (vdp_reg[12] & 1<<3)) { ! 1486: case 0: /* s/ten=0, B=0, A=0, S=0 */ ! 1487: if (data_sprite[i]) ! 1488: linedata[i] = data_sprite[i]; ! 1489: else if (data_layerA[i]) ! 1490: linedata[i] = data_layerA[i]; ! 1491: else if (data_layerB[i]) ! 1492: linedata[i] = data_layerB[i]; ! 1493: else ! 1494: linedata[i] = bg; ! 1495: break; ! 1496: case 1: /* s/ten=0, B=1, A=0, S=0 */ ! 1497: if (data_layerB[i]) ! 1498: linedata[i] = data_layerB[i]; ! 1499: else if (data_sprite[i]) ! 1500: linedata[i] = data_sprite[i]; ! 1501: else if (data_layerA[i]) ! 1502: linedata[i] = data_layerA[i]; ! 1503: else ! 1504: linedata[i] = bg; ! 1505: break; ! 1506: case 2: /* s/ten=0, B=0, A=1, S=0 */ ! 1507: if (data_layerA[i]) ! 1508: linedata[i] = data_layerA[i]; ! 1509: else if (data_sprite[i]) ! 1510: linedata[i] = data_sprite[i]; ! 1511: else if (data_layerB[i]) ! 1512: linedata[i] = data_layerB[i]; ! 1513: else ! 1514: linedata[i] = bg; ! 1515: break; ! 1516: case 3: /* s/ten=0, B=1, A=1, S=0 */ ! 1517: if (data_layerA[i]) ! 1518: linedata[i] = data_layerA[i]; ! 1519: else if (data_layerB[i]) ! 1520: linedata[i] = data_layerB[i]; ! 1521: else if (data_sprite[i]) ! 1522: linedata[i] = data_sprite[i]; ! 1523: else ! 1524: linedata[i] = bg; ! 1525: break; ! 1526: case 4: /* s/ten=0, B=0, A=0, S=1 */ ! 1527: if (data_sprite[i]) ! 1528: linedata[i] = data_sprite[i]; ! 1529: else if (data_layerA[i]) ! 1530: linedata[i] = data_layerA[i]; ! 1531: else if (data_layerB[i]) ! 1532: linedata[i] = data_layerB[i]; ! 1533: else ! 1534: linedata[i] = bg; ! 1535: break; ! 1536: case 5: /* s/ten=0, B=1, A=0, S=1 */ ! 1537: if (data_sprite[i]) ! 1538: linedata[i] = data_sprite[i]; ! 1539: else if (data_layerB[i]) ! 1540: linedata[i] = data_layerB[i]; ! 1541: else if (data_layerA[i]) ! 1542: linedata[i] = data_layerA[i]; ! 1543: else ! 1544: linedata[i] = bg; ! 1545: break; ! 1546: case 6: /* s/ten=0, B=0, A=1, S=1 */ ! 1547: if (data_sprite[i]) ! 1548: linedata[i] = data_sprite[i]; ! 1549: else if (data_layerA[i]) ! 1550: linedata[i] = data_layerA[i]; ! 1551: else if (data_layerB[i]) ! 1552: linedata[i] = data_layerB[i]; ! 1553: else ! 1554: linedata[i] = bg; ! 1555: break; ! 1556: case 7: /* s/ten=0, B=1, A=1, S=1 */ ! 1557: if (data_sprite[i]) ! 1558: linedata[i] = data_sprite[i]; ! 1559: else if (data_layerA[i]) ! 1560: linedata[i] = data_layerA[i]; ! 1561: else if (data_layerB[i]) ! 1562: linedata[i] = data_layerB[i]; ! 1563: else ! 1564: linedata[i] = bg; ! 1565: break; ! 1566: case 8: /* s/ten=1, B=0, A=0, S=0 */ ! 1567: if (data_sprite[i]) { ! 1568: if (data_sprite[i] == 63) { /* shadow operator */ ! 1569: if (data_layerA[i]) ! 1570: linedata[i] = data_layerA[i] | 128; /* shadow */ ! 1571: else if (data_layerB[i]) ! 1572: linedata[i] = data_layerB[i] | 128; /* shadow */ ! 1573: else ! 1574: linedata[i] = bg | 128; /* shadow */ ! 1575: } else if (data_sprite[i] == 62) { /* highlight operator */ ! 1576: if (data_layerA[i]) ! 1577: linedata[i] = data_layerA[i]; /* normal */ ! 1578: else if (data_layerB[i]) ! 1579: linedata[i] = data_layerB[i]; /* normal */ ! 1580: else ! 1581: linedata[i] = bg; /* normal */ ! 1582: } else { ! 1583: linedata[i] = data_sprite[i] | 128; /* shadow */ ! 1584: } ! 1585: } else { ! 1586: if (data_layerA[i]) ! 1587: linedata[i] = data_layerA[i] | 128; /* shadow */ ! 1588: else if (data_layerB[i]) ! 1589: linedata[i] = data_layerB[i] | 128; /* shadow */ ! 1590: else ! 1591: linedata[i] = bg | 128; /* shadow */ ! 1592: } ! 1593: break; ! 1594: case 9: /* s/ten=1, B=1, A=0, S=0 */ ! 1595: if (data_layerB[i]) { ! 1596: linedata[i] = data_layerB[i]; /* normal */ ! 1597: } else { ! 1598: if (data_sprite[i]) { ! 1599: if (data_sprite[i] == 63) { /* shadow operator */ ! 1600: if (data_layerA[i]) ! 1601: linedata[i] = data_layerA[i] | 128; /* shadow */ ! 1602: else ! 1603: linedata[i] = bg | 128; /* shadow */ ! 1604: } else if (data_sprite[i] == 62) { /* highlight operator */ ! 1605: if (data_layerA[i]) ! 1606: linedata[i] = data_layerA[i] | 64; /* highlight */ ! 1607: else ! 1608: linedata[i] = bg | 64; /* highlight */ ! 1609: } else { ! 1610: linedata[i] = data_sprite[i]; /* normal */ ! 1611: } ! 1612: } else { ! 1613: if (data_layerA[i]) ! 1614: linedata[i] = data_layerA[i]; /* normal */ ! 1615: else ! 1616: linedata[i] = bg; /* normal */ ! 1617: } ! 1618: } ! 1619: break; ! 1620: case 10: /* s/ten=1, B=0, A=1, S=0 */ ! 1621: if (data_layerA[i]) { ! 1622: linedata[i] = data_layerA[i]; /* normal */ ! 1623: } else { ! 1624: if (data_sprite[i]) { ! 1625: if (data_sprite[i] == 63) { /* shadow operator */ ! 1626: if (data_layerB[i]) ! 1627: linedata[i] = data_layerB[i] | 128; /* shadow */ ! 1628: else ! 1629: linedata[i] = bg | 128; /* shadow */ ! 1630: } else if (data_sprite[i] == 62) { /* highlight operator */ ! 1631: if (data_layerB[i]) ! 1632: linedata[i] = data_layerB[i] | 64; /* highlight */ ! 1633: else ! 1634: linedata[i] = bg | 64; /* highlight */ ! 1635: } else { ! 1636: linedata[i] = data_sprite[i]; /* normal */ ! 1637: } ! 1638: } else { ! 1639: if (data_layerB[i]) ! 1640: linedata[i] = data_layerB[i]; /* normal */ ! 1641: else ! 1642: linedata[i] = bg; /* normal */ ! 1643: } ! 1644: } ! 1645: break; ! 1646: case 11: /* s/ten=1, B=1, A=1, S=0 */ ! 1647: if (data_layerA[i]) { ! 1648: linedata[i] = data_layerA[i]; /* normal */ ! 1649: } else if (data_layerB[i]) { ! 1650: linedata[i] = data_layerB[i]; /* normal */ ! 1651: } else if (data_sprite[i]) { ! 1652: if (data_sprite[i] == 63) /* shadow operator */ ! 1653: linedata[i] = bg | 128; /* shadow */ ! 1654: else if (data_sprite[i] == 62) /* highlight operator */ ! 1655: linedata[i] = bg | 64; /* highlight */ ! 1656: else ! 1657: linedata[i] = data_sprite[i]; /* normal */ ! 1658: } else { ! 1659: linedata[i] = bg; /* normal */ ! 1660: } ! 1661: break; ! 1662: case 12: /* s/ten=0, B=0, A=0, S=1 */ ! 1663: if (data_sprite[i]) { ! 1664: if (data_sprite[i] == 63) { /* shadow operator */ ! 1665: if (data_layerA[i]) ! 1666: linedata[i] = data_layerA[i] | 128; /* shadow */ ! 1667: else if (data_layerB[i]) ! 1668: linedata[i] = data_layerB[i] | 128; /* shadow */ ! 1669: else ! 1670: linedata[i] = bg | 128; /* shadow */ ! 1671: } else if (data_sprite[i] == 62) { /* highlight operator */ ! 1672: if (data_layerA[i]) ! 1673: linedata[i] = data_layerA[i]; /* normal */ ! 1674: else if (data_layerB[i]) ! 1675: linedata[i] = data_layerB[i]; /* normal */ ! 1676: else ! 1677: linedata[i] = bg; /* normal */ ! 1678: } else { ! 1679: linedata[i] = data_sprite[i]; /* normal */ ! 1680: } ! 1681: } else if (data_layerA[i]) { ! 1682: linedata[i] = data_layerA[i] | 128; /* shadow */ ! 1683: } else if (data_layerB[i]) { ! 1684: linedata[i] = data_layerB[i] | 128; /* shadow */ ! 1685: } else { ! 1686: linedata[i] = bg | 128; /* shadow */ ! 1687: } ! 1688: break; ! 1689: case 13: /* s/ten=1, B=1, A=0, S=1 */ ! 1690: if (data_sprite[i]) { ! 1691: if (data_sprite[i] == 63) { /* shadow operator */ ! 1692: if (data_layerB[i]) ! 1693: linedata[i] = data_layerB[i] | 128; /* shadow */ ! 1694: else if (data_layerA[i]) ! 1695: linedata[i] = data_layerA[i] | 128; /* shadow */ ! 1696: else ! 1697: linedata[i] = bg | 128; /* shadow */ ! 1698: } else if (data_sprite[i] == 62) { /* highlight operator */ ! 1699: if (data_layerB[i]) ! 1700: linedata[i] = data_layerB[i] | 64; /* highlight */ ! 1701: else if (data_layerA[i]) ! 1702: linedata[i] = data_layerA[i] | 64; /* highlight */ ! 1703: else ! 1704: linedata[i] = bg | 64; /* highlight */ ! 1705: } else { ! 1706: linedata[i] = data_sprite[i]; /* normal */ ! 1707: } ! 1708: } else if (data_layerB[i]) { ! 1709: linedata[i] = data_layerB[i]; /* normal */ ! 1710: } else if (data_layerA[i]) { ! 1711: linedata[i] = data_layerA[i]; /* normal */ ! 1712: } ! 1713: break; ! 1714: case 14: /* s/ten=1, B=0, A=1, S=1 */ ! 1715: if (data_sprite[i]) { ! 1716: if (data_sprite[i] == 63) { /* shadow operator */ ! 1717: if (data_layerA[i]) ! 1718: linedata[i] = data_layerA[i] | 128; /* shadow */ ! 1719: else if (data_layerB[i]) ! 1720: linedata[i] = data_layerB[i] | 128; /* shadow */ ! 1721: else ! 1722: linedata[i] = bg | 128; /* shadow */ ! 1723: } else if (data_sprite[i] == 62) { /* highlight operator */ ! 1724: if (data_layerA[i]) ! 1725: linedata[i] = data_layerA[i] | 64; /* highlight */ ! 1726: else if (data_layerB[i]) ! 1727: linedata[i] = data_layerB[i] | 64; /* highlight */ ! 1728: else ! 1729: linedata[i] = bg | 64; /* highlight */ ! 1730: } else { ! 1731: linedata[i] = data_sprite[i]; /* normal */ ! 1732: } ! 1733: } else if (data_layerA[i]) { ! 1734: linedata[i] = data_layerA[i]; /* normal */ ! 1735: } else if (data_layerB[i]) { ! 1736: linedata[i] = data_layerB[i]; /* normal */ ! 1737: } ! 1738: break; ! 1739: case 15: /* s/ten=1, B=1, A=1, S=1 */ ! 1740: if (data_sprite[i]) { ! 1741: if (data_sprite[i] == 63) { /* shadow operator */ ! 1742: if (data_layerA[i]) ! 1743: linedata[i] = data_layerA[i] | 128; /* shadow */ ! 1744: else if (data_layerB[i]) ! 1745: linedata[i] = data_layerB[i] | 128; /* shadow */ ! 1746: else ! 1747: linedata[i] = bg | 128; /* shadow */ ! 1748: } else if (data_sprite[i] == 62) { /* highlight operator */ ! 1749: if (data_layerA[i]) ! 1750: linedata[i] = data_layerA[i] | 64; /* highlight */ ! 1751: else if (data_layerB[i]) ! 1752: linedata[i] = data_layerB[i] | 64; /* highlight */ ! 1753: else ! 1754: linedata[i] = bg | 64; /* highlight */ ! 1755: } else { ! 1756: linedata[i] = data_sprite[i]; /* normal */ ! 1757: } ! 1758: } else if (data_layerA[i]) { ! 1759: linedata[i] = data_layerA[i]; /* normal */ ! 1760: } else if (data_layerB[i]) { ! 1761: linedata[i] = data_layerB[i]; /* normal */ ! 1762: } ! 1763: break; ! 1764: } ! 1765: } ! 1766: } ! 1767: ! 1768: void vdp_renderline_interlace2(unsigned int line, uint8 *linedata) ! 1769: { ! 1770: int i; ! 1771: uint8 pridata[640]; ! 1772: uint8 *spritedata = pridata + 320; ! 1773: ! 1774: memset(pridata, 0, 640); ! 1775: memset(linedata, vdp_reg[7] & 63, 320); ! 1776: ! 1777: if (vdp_reg[1] & 1<<6) { ! 1778: vdp_sprites(line, pridata, spritedata); ! 1779: ; ! 1780: if (vdp_layerB) ! 1781: vdp_layer_interlace(line, 1, 0, linedata); ! 1782: if (vdp_layerA) ! 1783: vdp_layer_interlace(line, 0, 0, linedata); ! 1784: /* ! 1785: if (vdp_layerW) ! 1786: vdp_window(line, 0, linedata); ! 1787: */ ! 1788: if (vdp_layerH && (vdp_reg[12] & 1<<3)) ! 1789: vdp_shadow(line, linedata); ! 1790: if (vdp_layerS) ! 1791: vdp_spritelayer(line, spritedata, pridata, linedata, 0); ! 1792: if (vdp_layerBp) ! 1793: vdp_layer_interlace(line, 1, 1, linedata); ! 1794: if (vdp_layerAp) ! 1795: vdp_layer_interlace(line, 0, 1, linedata); ! 1796: /* ! 1797: if (vdp_layerWp) ! 1798: vdp_window(line, 1, linedata); ! 1799: */ ! 1800: if (vdp_layerSp) ! 1801: vdp_spritelayer(line, spritedata, pridata, linedata, 1); ! 1802: } ! 1803: } ! 1804: ! 1805: void vdp_renderframe(uint8 *framedata, unsigned int lineoffset) ! 1806: { ! 1807: unsigned int i, line; ! 1808: uint32 background; ! 1809: unsigned int vertcells = vdp_reg[1] & 1<<3 ? 30 : 28; ! 1810: uint8 *linedata; ! 1811: ! 1812: /* fill in background */ ! 1813: ! 1814: background = vdp_reg[7] & 63; ! 1815: background|= background<<8; ! 1816: background|= background<<16; ! 1817: ! 1818: for (line = 0; line < vertcells*8; line++) { ! 1819: linedata = framedata + line*lineoffset; ! 1820: for (i = 0; i < (320 / 4); i++) { ! 1821: ((uint32 *)linedata)[i] = background; ! 1822: } ! 1823: } ! 1824: ! 1825: if (vdp_reg[1] & 1<<6) { ! 1826: if (vdp_layerB) ! 1827: vdp_layer_simple(1, 0, framedata, lineoffset); ! 1828: if (vdp_layerA) ! 1829: vdp_layer_simple(0, 0, framedata, lineoffset); ! 1830: if (vdp_layerH && (vdp_reg[12] & 1<<3)) ! 1831: vdp_shadow_simple(framedata, lineoffset); ! 1832: if (vdp_layerS) ! 1833: vdp_sprites_simple(0, framedata, lineoffset); ! 1834: if (vdp_layerBp) ! 1835: vdp_layer_simple(1, 1, framedata, lineoffset); ! 1836: if (vdp_layerAp) ! 1837: vdp_layer_simple(0, 1, framedata, lineoffset); ! 1838: if (vdp_layerSp) ! 1839: vdp_sprites_simple(1, framedata, lineoffset); ! 1840: } ! 1841: } ! 1842: ! 1843: void vdp_showregs(void) ! 1844: { ! 1845: int i; ! 1846: ! 1847: for (i = 0; i < 25; i++) { ! 1848: printf("[%02d] %02X: ", i, vdp_reg[i]); ! 1849: switch(i) { ! 1850: case 0: ! 1851: printf("%s ", vdp_reg[0] & 1<<1 ? "HV-stop" : "HV-enable"); ! 1852: printf("%s ", vdp_reg[0] & 1<<4 ? "HInt-enable" : "HInt-disable"); ! 1853: break; ! 1854: case 1: ! 1855: printf("%s ", vdp_reg[1] & 1<<3 ? "30-cell" : "28-cell"); ! 1856: printf("%s ", vdp_reg[1] & 1<<4 ? "DMA-enable" : "DMA-disable"); ! 1857: printf("%s ", vdp_reg[1] & 1<<5 ? "VInt-enable" : "VInt-disable"); ! 1858: printf("%s ", vdp_reg[1] & 1<<6 ? "Disp-enable" : "Disp-disable"); ! 1859: break; ! 1860: case 2: ! 1861: printf("Scroll A @ %04X", (vdp_reg[2] & 0x38)<<10); ! 1862: break; ! 1863: case 3: ! 1864: printf("Window @ %04X", (vdp_reg[3] & 0x3E)<<10); ! 1865: break; ! 1866: case 4: ! 1867: printf("Scroll B @ %04X", (vdp_reg[4] & 7)<<13); ! 1868: break; ! 1869: case 5: ! 1870: printf("Sprites @ %04X", (vdp_reg[5] & 0x7F)<<9); ! 1871: break; ! 1872: case 7: ! 1873: printf("bgpal %d col %d", (vdp_reg[7]>>4 & 3), (vdp_reg[7] & 15)); ! 1874: break; ! 1875: case 10: ! 1876: printf("hintreg %04X", vdp_reg[10]); ! 1877: break; ! 1878: case 11: ! 1879: printf("V-mode %d H-mode %d ", (vdp_reg[11]>>2) & 1, (vdp_reg[11] & 3)); ! 1880: printf("%s", (vdp_reg[11] & 1<<3) ? "ExtInt-enable" : "ExtInt-disable"); ! 1881: break; ! 1882: case 12: ! 1883: printf("Interlace %d ", (vdp_reg[12]>>1) & 3); ! 1884: printf("%s ", (vdp_reg[12] & 1<<0) ? "40-cell" : "32-cell"); ! 1885: printf("%s ", (vdp_reg[12] & 1<<3) ? "Shadow-enable" : "Shadow-disable"); ! 1886: break; ! 1887: case 13: ! 1888: printf("Scroll A @ %04X", (vdp_reg[13] & 0x3F)<<10); ! 1889: break; ! 1890: case 15: ! 1891: printf("Autoinc %d", vdp_reg[15]); ! 1892: break; ! 1893: case 16: ! 1894: printf("Vsize %d Hsize %d", (vdp_reg[16]>>4) & 3, (vdp_reg[16] & 3)); ! 1895: break; ! 1896: case 17: ! 1897: printf("Window H %s ", (vdp_reg[17] & 1<<7) ? "right" : "left"); ! 1898: printf("%d", vdp_reg[17] & 0x1F); ! 1899: break; ! 1900: case 18: ! 1901: printf("Window V %s ", (vdp_reg[18] & 1<<7) ? "lower" : "upper"); ! 1902: printf("%d", vdp_reg[18] & 0x1F); ! 1903: break; ! 1904: case 19: ! 1905: printf("DMA-length-low %02X", vdp_reg[19]); ! 1906: break; ! 1907: case 20: ! 1908: printf("DMA-length-high %02X", vdp_reg[20]); ! 1909: break; ! 1910: case 21: ! 1911: printf("DMA-source-low %02X", vdp_reg[21]); ! 1912: break; ! 1913: case 22: ! 1914: printf("DMA-source-mid %02X", vdp_reg[22]); ! 1915: break; ! 1916: case 23: ! 1917: printf("DMA-source-high %02X", vdp_reg[23]); ! 1918: break; ! 1919: } ! 1920: printf("\n"); ! 1921: } ! 1922: } ! 1923: ! 1924: void vdp_spritelist(void) ! 1925: { ! 1926: uint8 *spritelist = vdp_vram + ((vdp_reg[5] & 0x7F)<<9); ! 1927: uint8 *sprite; ! 1928: uint8 link = 0; ! 1929: uint16 pattern; ! 1930: uint8 palette; ! 1931: uint16 cellinfo; ! 1932: sint16 vpos, hpos, vmax; ! 1933: uint8 vsize, hsize; ! 1934: ! 1935: LOG_REQUEST(("SPRITE DUMP: (base=vram+%X)", ! 1936: (vdp_reg[5] & 0x7f)<<9)); ! 1937: do { ! 1938: sprite = spritelist + (link<<3); ! 1939: hpos = (LOCENDIAN16(*(uint16 *)(sprite+6)) & 0x1FF) - 0x80; ! 1940: vpos = (LOCENDIAN16(*(uint16 *)(sprite)) & 0x3FF) - 0x80; ! 1941: vsize = 1+(sprite[2] & 3); ! 1942: hsize = 1+((sprite[2]>>2) & 3); ! 1943: cellinfo = LOCENDIAN16(*(uint16 *)(sprite+4)); ! 1944: pattern = cellinfo & 0x7FF; ! 1945: palette = (cellinfo >> 13) & 3; ! 1946: vmax = vpos + vsize*8; ! 1947: ! 1948: LOG_REQUEST(("Sprite %d @ %X", link, ! 1949: (link<<3) | (vdp_reg[5] & 0x7f)<<9)); ! 1950: LOG_REQUEST((" Pos: %d,%d", hpos, vpos)); ! 1951: LOG_REQUEST((" Size: %d,%d", hsize, vsize)); ! 1952: LOG_REQUEST((" Pri: %d, Pal: %d, Vflip: %d, Hflip: %d", ! 1953: (cellinfo>>15 & 1), (cellinfo>>13 & 3), (cellinfo>>12 & 1), ! 1954: (cellinfo>>11 & 1))); ! 1955: LOG_REQUEST((" Pattern: %d (%x) @ vram+%X (%X if interlaced)", ! 1956: (cellinfo & 0x7FF), (cellinfo & 0x7FF), ! 1957: (cellinfo & 0x7FF)*32, (cellinfo & 0x7FF)*32)); ! 1958: link = sprite[3] & 0x7F; ! 1959: } while (link); ! 1960: } ! 1961: ! 1962: void vdp_describe(void) ! 1963: { ! 1964: int layer; ! 1965: unsigned int line; ! 1966: uint32 o_patterndata, o_hscrolldata; ! 1967: uint16 *patterndata, *hscrolldata; ! 1968: uint8 hsize = vdp_reg[16] & 3; ! 1969: uint8 vsize = (vdp_reg[16] >> 4) & 3; ! 1970: uint8 hmode = vdp_reg[11] & 3; ! 1971: uint8 vmode = (vdp_reg[11] >> 2) & 1; ! 1972: uint16 hwidth, vwidth, hoffset, voffset, raw_hoffset; ! 1973: ! 1974: hwidth = 32+hsize*32; ! 1975: vwidth = 32+vsize*32; ! 1976: LOG_REQUEST(("VDP description:")); ! 1977: LOG_REQUEST((" hsize = %d (ie. width=%d)", hsize, hwidth)); ! 1978: LOG_REQUEST((" vsize = %d (ie. width=%d)", vsize, vwidth)); ! 1979: LOG_REQUEST((" hmode = %d (0=full, 2=cell, 3=line)", hmode)); ! 1980: LOG_REQUEST((" vmode = %d (0=full, 1=2cell", vmode)); ! 1981: ! 1982: for (layer = 0; layer < 2; layer++) { ! 1983: LOG_REQUEST((" Layer %s:", layer == 0 ? "A" : "B")); ! 1984: o_patterndata = (layer == 0 ? ((vdp_reg[2] & 0x38)<<10) : ! 1985: ((vdp_reg[4] & 7)<<13)); ! 1986: o_hscrolldata = layer*2 + ((vdp_reg[13] & 63)<<10); ! 1987: LOG_REQUEST((" Pattern data @ vram+%08X", o_patterndata)); ! 1988: LOG_REQUEST((" Hscroll data @ vram+%08X", o_hscrolldata)); ! 1989: patterndata = (uint16 *)(vdp_vram + o_patterndata); ! 1990: hscrolldata = (uint16 *)(vdp_vram + o_hscrolldata); ! 1991: for (line = 0; line < vdp_vislines; line++) { ! 1992: switch(hmode) { ! 1993: case 0: /* full screen */ ! 1994: hoffset = (0x400 - LOCENDIAN16(hscrolldata[0])) & 0x3FF; ! 1995: break; ! 1996: case 2: /* cell scroll */ ! 1997: hoffset = (0x400 - LOCENDIAN16(hscrolldata[2*(line & ~7)])) & 0x3FF; ! 1998: break; ! 1999: case 3: /* line scroll */ ! 2000: hoffset = (0x400 - LOCENDIAN16(hscrolldata[2*line])) & 0x3FF; ! 2001: break; ! 2002: default: ! 2003: LOG_REQUEST(("prohibited HSCR/LSCR on line %d", line)); ! 2004: hoffset = 0; ! 2005: break; ! 2006: } ! 2007: raw_hoffset = hoffset; ! 2008: hoffset&= (hwidth*8)-1; /* put offset in range */ ! 2009: voffset = (line + LOCENDIAN16( ((uint16 *)vdp_vsram)[layer] )) & 0x3FF; ! 2010: voffset&= (vwidth*8)-1; /* put offset in range */ ! 2011: LOG_REQUEST((" line %d: hoffset=%d=%d, voffset=%d, " ! 2012: "firstcell=vram+%08X", line, raw_hoffset, hoffset, voffset, ! 2013: o_patterndata+2*((hoffset>>3)+hwidth*(voffset>>3)))); ! 2014: } ! 2015: } ! 2016: } ! 2017: ! 2018: void vdp_eventinit(void) ! 2019: { ! 2020: /* Facts from documentation: ! 2021: H-Blank is 73.7 clock cycles long. ! 2022: The VDP settings are aquired 36 clocks after start of H-Blank. ! 2023: The display period is 413.3 clocks in duration. ! 2024: V-Int occurs 14.7us after H-Int (which is 112 clock cycles) ! 2025: Facts from clock data: ! 2026: One line takes 488 clocks (vdp_clksperline_68k) ! 2027: Assumptions: (not sure if these are true anymore) ! 2028: We 'approximate' and make H-Int occur at the same time as H-Blank. ! 2029: V-Blank starts at V-Int and ends at the start of line 0. ! 2030: ! 2031: vdp_event_start = start of line, end of v-blank ! 2032: vdp_event_vint = v-int time on line 224 (or 240) ! 2033: (112 clocks after h-int) ! 2034: vdp_event_hint = h-int time at end of each line ! 2035: vdp_event_hdisplay = settings are aquired and current line displayed ! 2036: vdp_event_end = end of line, end of h-blank ! 2037: ! 2038: Note that if the program stays in H-Int 224 longer than 112 clocks, V-Int ! 2039: is not supposed to occur due to the processor acknowledging the wrong ! 2040: interrupt from the VDP, thus programs disable H-Ints on 223 to prevent ! 2041: this problem. We don't worry about this. ! 2042: */ ! 2043: vdp_event = 0; ! 2044: vdp_event_start = 0; ! 2045: vdp_event_vint = 112-74; ! 2046: vdp_event_hint = vdp_clksperline_68k-74; ! 2047: vdp_event_hdisplay = vdp_event_hint+36; ! 2048: vdp_event_end = vdp_clksperline_68k; ! 2049: vdp_nextevent = 0; ! 2050: } ! 2051: ! 2052: void vdp_endfield(void) ! 2053: { ! 2054: vdp_line = 0; ! 2055: vdp_eventinit(); ! 2056: vdp_oddframe^= 1; /* toggle */ ! 2057: /* printf("(%d,%d,%d,%d,%d)\n", vdp_event_type, ! 2058: vdp_event_startline, vdp_event_hint, vdp_event_vdpplot, ! 2059: vdp_event_endline); */ ! 2060: } ! 2061: ! 2062: inline void vdp_plotcell(uint8 *patloc, uint8 palette, uint8 flags, ! 2063: uint8 *cellloc, unsigned int lineoffset) ! 2064: { ! 2065: int y, x; ! 2066: uint8 value; ! 2067: uint32 data; ! 2068: ! 2069: switch(flags) { ! 2070: case 0: ! 2071: /* normal tile - no s/ten */ ! 2072: for (y = 0; y < 8; y++, cellloc+= lineoffset) { ! 2073: data = LOCENDIAN32(((uint32 *)patloc)[y]); ! 2074: for (x = 0; x < 8; x++, data<<= 4) { ! 2075: value = data>>28; ! 2076: if (value) ! 2077: cellloc[x] = palette*16 + value; ! 2078: } ! 2079: } ! 2080: break; ! 2081: case 1: ! 2082: /* h flipped tile - no s/ten */ ! 2083: for (y = 0; y < 8; y++, cellloc+= lineoffset) { ! 2084: data = LOCENDIAN32(((uint32 *)patloc)[y]); ! 2085: for (x = 0; x < 8; x++, data>>= 4) { ! 2086: value = data & 15; ! 2087: if (value) ! 2088: cellloc[x] = palette*16 + value; ! 2089: } ! 2090: } ! 2091: break; ! 2092: case 2: ! 2093: /* v flipped tile - no s/ten */ ! 2094: for (y = 0; y < 8; y++, cellloc+= lineoffset) { ! 2095: data = LOCENDIAN32(((uint32 *)patloc)[7-y]); ! 2096: for (x = 0; x < 8; x++, data<<= 4) { ! 2097: value = data>>28; ! 2098: if (value) ! 2099: cellloc[x] = palette*16 + value; ! 2100: } ! 2101: } ! 2102: break; ! 2103: case 3: ! 2104: /* h and v flipped tile - no s/ten */ ! 2105: for (y = 0; y < 8; y++, cellloc+= lineoffset) { ! 2106: data = LOCENDIAN32(((uint32 *)patloc)[7-y]); ! 2107: for (x = 0; x < 8; x++, data>>= 4) { ! 2108: value = data & 15; ! 2109: if (value) ! 2110: cellloc[x] = palette*16 + value; ! 2111: } ! 2112: } ! 2113: break; ! 2114: case 4: ! 2115: /* normal tile - s/ten enabled */ ! 2116: for (y = 0; y < 8; y++, cellloc+= lineoffset) { ! 2117: data = LOCENDIAN32(((uint32 *)patloc)[y]); ! 2118: for (x = 0; x < 8; x++, data<<= 4) { ! 2119: value = data>>28; ! 2120: if (value) { ! 2121: if (palette == 3 && value == 14) { ! 2122: cellloc[x] = (cellloc[x] & 63) + 64; ! 2123: } else if (palette == 3 && value == 15) { ! 2124: cellloc[x] = (cellloc[x] & 63) + 128; ! 2125: } else { ! 2126: cellloc[x] = palette*16 + value; ! 2127: } ! 2128: } ! 2129: } ! 2130: } ! 2131: break; ! 2132: case 5: ! 2133: /* h flipped tile - s/ten */ ! 2134: for (y = 0; y < 8; y++, cellloc+= lineoffset) { ! 2135: data = LOCENDIAN32(((uint32 *)patloc)[y]); ! 2136: for (x = 0; x < 8; x++, data>>= 4) { ! 2137: value = data & 15; ! 2138: if (value) { ! 2139: if (palette == 3 && value == 14) { ! 2140: cellloc[x] = (cellloc[x] & 63) + 64; ! 2141: } else if (palette == 3 && value == 15) { ! 2142: cellloc[x] = (cellloc[x] & 63) + 128; ! 2143: } else { ! 2144: cellloc[x] = palette*16 + value; ! 2145: } ! 2146: } ! 2147: } ! 2148: } ! 2149: break; ! 2150: case 6: ! 2151: /* v flipped tile - s/ten enabled */ ! 2152: for (y = 0; y < 8; y++, cellloc+= lineoffset) { ! 2153: data = LOCENDIAN32(((uint32 *)patloc)[7-y]); ! 2154: for (x = 0; x < 8; x++, data<<= 4) { ! 2155: value = data>>28; ! 2156: if (value) { ! 2157: if (palette == 3 && value == 14) { ! 2158: cellloc[x] = (cellloc[x] & 63) + 64; ! 2159: } else if (palette == 3 && value == 15) { ! 2160: cellloc[x] = (cellloc[x] & 63) + 128; ! 2161: } else { ! 2162: cellloc[x] = palette*16 + value; ! 2163: } ! 2164: } ! 2165: } ! 2166: } ! 2167: break; ! 2168: case 7: ! 2169: /* h and v flipped tile - s/ten enabled */ ! 2170: for (y = 0; y < 8; y++, cellloc+= lineoffset) { ! 2171: data = LOCENDIAN32(((uint32 *)patloc)[7-y]); ! 2172: for (x = 0; x < 8; x++, data>>= 4) { ! 2173: value = data & 15; ! 2174: if (value) { ! 2175: if (palette == 3 && value == 14) { ! 2176: cellloc[x] = (cellloc[x] & 63) + 64; ! 2177: } else if (palette == 3 && value == 15) { ! 2178: cellloc[x] = (cellloc[x] & 63) + 128; ! 2179: } else { ! 2180: cellloc[x] = palette*16 + value; ! 2181: } ! 2182: } ! 2183: } ! 2184: } ! 2185: break; ! 2186: default: ! 2187: ui_err("Unknown plotcell flags"); ! 2188: } ! 2189: } ! 2190: ! 2191: /* must be 8*lineoffset bytes scrap before and after fielddata and also ! 2192: 8 bytes before each line and 8 bytes after each line */ ! 2193: ! 2194: void vdp_layer_simple(unsigned int layer, unsigned int priority, ! 2195: uint8 *framedata, unsigned int lineoffset) ! 2196: { ! 2197: int i, j; ! 2198: uint8 hsize = vdp_reg[16] & 3; ! 2199: uint8 vsize = (vdp_reg[16] >> 4) & 3; ! 2200: uint8 hmode = vdp_reg[11] & 3; ! 2201: uint8 vmode = (vdp_reg[11] >> 2) & 1; ! 2202: uint16 vramoffset = (layer ? ((vdp_reg[4] & 7) << 13) : ! 2203: ((vdp_reg[2] & (7<<3)) << 10)); ! 2204: uint16 *patterndata = (uint16 *)(vdp_vram + vramoffset); ! 2205: uint16 *hscrolldata = (uint16 *)(((vdp_reg[13] & 63) << 10) ! 2206: + vdp_vram + layer*2); ! 2207: uint8 screencells = (vdp_reg[12] & 1) ? 40 : 32; ! 2208: uint16 hwidth = 32+hsize*32; ! 2209: uint16 vwidth = 32+vsize*32; ! 2210: uint16 hoffset, voffset; ! 2211: uint16 cellinfo; ! 2212: uint8 *pattern; ! 2213: uint32 data; ! 2214: uint8 palette; ! 2215: uint8 value; ! 2216: unsigned int xcell, ycell; ! 2217: unsigned int pos; ! 2218: uint8 *toploc, *cellloc; ! 2219: uint8 flags; ! 2220: uint32 hscroll, vscroll; ! 2221: unsigned int x, y; ! 2222: int topbottom = vdp_reg[18] & 0x80; ! 2223: int winvpos = vdp_reg[18] & 0x1f; ! 2224: int leftright = vdp_reg[17] & 0x80; ! 2225: int winhpos = vdp_reg[17] & 0x1f; ! 2226: ! 2227: if (layer == 0 && ! 2228: ((vdp_reg[18] == 0x9F && vdp_reg[17] == 0x9F) || ! 2229: (vdp_reg[18] == 0x9F && vdp_reg[17] == 0x80) || ! 2230: (vdp_reg[18] == 0x80) || ! 2231: (vdp_reg[18] == 0x00 && vdp_reg[17] > (screencells << 1)))) ! 2232: /* quick hack to remove layer A when it definitely shouldn't be plotted */ ! 2233: return; ! 2234: ! 2235: for (xcell = 0; xcell <= screencells; xcell++) { ! 2236: if (vmode) { ! 2237: /* 2-cell scroll */ ! 2238: vscroll = ((xcell >= screencells ? xcell-2 : xcell) & ~1) + layer; ! 2239: } else { ! 2240: /* full screen */ ! 2241: vscroll = layer; ! 2242: } ! 2243: voffset = LOCENDIAN16( ((uint16 *)vdp_vsram)[vscroll] ) & 0x3FF; ! 2244: toploc = framedata - lineoffset*(voffset & 7); ! 2245: for (ycell = 0; ycell <= 28; ycell++, voffset+=8, toploc+=lineoffset*8) { ! 2246: switch(hmode) { ! 2247: case 0: /* full screen */ ! 2248: hscroll = 0; ! 2249: break; ! 2250: case 2: /* cell scroll */ ! 2251: hscroll = 2 * (ycell >= 28 ? ycell-2 : ycell) * 8; ! 2252: break; ! 2253: case 3: /* line scroll - approximation */ ! 2254: hscroll = 2 * (ycell >= 28 ? ycell-2 : ycell) * 8; ! 2255: vdp_complex = 1; ! 2256: break; ! 2257: default: ! 2258: LOG_NORMAL(("prohibited HSCR/LSCR")); ! 2259: hscroll = 0; ! 2260: break; ! 2261: } ! 2262: voffset &= (vwidth*8)-1; ! 2263: hoffset = (0x400 - LOCENDIAN16(hscrolldata[hscroll])) & 0x3FF; ! 2264: hoffset = (hoffset+xcell*8) & ((hwidth*8)-1); ! 2265: cellinfo = LOCENDIAN16(patterndata[(hoffset>>3)+hwidth*(voffset>>3)]); ! 2266: if (((uint8)((cellinfo & 1<<15) ? 1 : 0)) == priority) { ! 2267: /* plot cell */ ! 2268: palette = (cellinfo >> 13) & 3; ! 2269: pattern = vdp_vram + ((cellinfo & 2047)<<5); ! 2270: flags = (cellinfo>>11) & 3; /* bit0=H flip, bit1=V flip */ ! 2271: cellloc = toploc - (hoffset&7) + xcell*8; ! 2272: vdp_plotcell(pattern, palette, flags, cellloc, lineoffset); ! 2273: } ! 2274: } /* ycell */ ! 2275: } /* xcell */ ! 2276: } ! 2277: ! 2278: void vdp_shadow_simple(uint8 *framedata, unsigned int lineoffset) ! 2279: { ! 2280: unsigned int vertcells = vdp_reg[1] & 1<<3 ? 30 : 28; ! 2281: uint8 *linedata; ! 2282: unsigned int line; ! 2283: int i; ! 2284: ! 2285: for (line = 0; line < vertcells*8; line++) { ! 2286: linedata = framedata + line*lineoffset; ! 2287: /* this could be done 4 bytes at a time */ ! 2288: for (i = 0; i < 320; i++) ! 2289: linedata[i] = (linedata[i] & 63) + 128; ! 2290: } ! 2291: } ! 2292: ! 2293: void vdp_sprites_simple(unsigned int priority, uint8 *framedata, ! 2294: unsigned int lineoffset) ! 2295: { ! 2296: uint8 *spritelist = vdp_vram + ((vdp_reg[5] & 0x7F)<<9); ! 2297: ! 2298: vdp_sprite_simple(priority, framedata, lineoffset, 1, ! 2299: spritelist, spritelist); ! 2300: } ! 2301: ! 2302: int vdp_sprite_simple(unsigned int priority, uint8 *framedata, ! 2303: unsigned int lineoffset, unsigned int number, ! 2304: uint8 *spritelist, uint8 *sprite) ! 2305: { ! 2306: int i, j; ! 2307: int plotted = 1; ! 2308: uint8 screencells = (vdp_reg[12] & 1) ? 40 : 32; ! 2309: uint8 link; ! 2310: uint16 pattern; ! 2311: uint32 data; ! 2312: uint8 palette; ! 2313: uint16 cellinfo; ! 2314: sint16 vpos, hpos, vmax; ! 2315: uint16 xcell, ycell; ! 2316: uint8 vsize, hsize; ! 2317: uint8 *cellloc; ! 2318: uint8 flags; ! 2319: uint8 *patloc; ! 2320: ! 2321: if (number > 80) { ! 2322: LOG_VERBOSE(("%08X [VDP] Maximum of 80 sprites exceeded", regs.pc)); ! 2323: return 0; ! 2324: } ! 2325: ! 2326: link = sprite[3] & 0x7F; ! 2327: hpos = (LOCENDIAN16(*(uint16 *)(sprite+6)) & 0x1FF) - 0x80; ! 2328: vpos = (LOCENDIAN16(*(uint16 *)(sprite)) & 0x3FF) - 0x80; ! 2329: vsize = 1+(sprite[2] & 3); ! 2330: hsize = 1+((sprite[2]>>2) & 3); ! 2331: cellinfo = LOCENDIAN16(*(uint16 *)(sprite+4)); ! 2332: pattern = cellinfo & 0x7FF; ! 2333: palette = (cellinfo >> 13) & 3; ! 2334: vmax = vpos + vsize*8; ! 2335: ! 2336: if (link) { ! 2337: if (hpos == -128) ! 2338: /* we do not support 'masking' in simple mode */ ! 2339: vdp_complex = 1; ! 2340: plotted = vdp_sprite_simple(priority, framedata, lineoffset, number+1, ! 2341: spritelist, spritelist + (link<<3)); ! 2342: plotted++; ! 2343: } ! 2344: ! 2345: if (((uint8)((cellinfo & 1<<15) ? 1 : 0)) != priority) ! 2346: return plotted; ! 2347: if (vpos >= 240 || hpos >= 320 || vpos+vsize*8 <= 0 || hpos+hsize*8 <= 0) ! 2348: /* sprite is not on screen */ ! 2349: return plotted; ! 2350: flags = (cellinfo>>11) & 3; /* bit0=H flip, bit1=V flip */ ! 2351: if (vdp_reg[12] & 1<<3) /* s/ten enabled? */ ! 2352: flags|= 1<<2; ! 2353: switch(flags) { ! 2354: case 0: ! 2355: case 4: ! 2356: /* normal orientation */ ! 2357: for (ycell = 0; ycell < vsize; ycell++) { ! 2358: if (ycell*8+vpos < -7 || ycell*8+vpos >= 240) ! 2359: /* cell out of plotting area (remember scrap area) */ ! 2360: continue; ! 2361: patloc = vdp_vram + (pattern<<5) + ycell*32; ! 2362: for (xcell = 0; xcell < hsize; xcell++, patloc+= vsize*32) { ! 2363: if (xcell*8+hpos < -7 || xcell*8+hpos >= 320) ! 2364: /* cell out of plotting area */ ! 2365: continue; ! 2366: cellloc = framedata + ((vpos+ycell*8)*lineoffset + ! 2367: (hpos+xcell*8)); ! 2368: vdp_plotcell(patloc, palette, flags, cellloc, lineoffset); ! 2369: } ! 2370: } ! 2371: break; ! 2372: case 1: ! 2373: case 5: ! 2374: /* H flip */ ! 2375: for (ycell = 0; ycell < vsize; ycell++) { ! 2376: if (ycell*8+vpos < -7 || ycell*8+vpos >= 240) ! 2377: /* cell out of plotting area (remember scrap area) */ ! 2378: continue; ! 2379: patloc = vdp_vram + (pattern<<5) + ycell*32 + vsize*32*(hsize-1); ! 2380: for (xcell = 0; xcell < hsize; xcell++, patloc-= vsize*32) { ! 2381: if (xcell*8+hpos < -7 || xcell*8+hpos >= 320) ! 2382: /* cell out of plotting area */ ! 2383: continue; ! 2384: cellloc = framedata + ((vpos+ycell*8)*lineoffset + ! 2385: (hpos+xcell*8)); ! 2386: vdp_plotcell(patloc, palette, flags, cellloc, lineoffset); ! 2387: } ! 2388: } ! 2389: break; ! 2390: case 2: ! 2391: case 6: ! 2392: /* V flip */ ! 2393: for (ycell = 0; ycell < vsize; ycell++) { ! 2394: if (ycell*8+vpos < -7 || ycell*8+vpos >= 240) ! 2395: /* cell out of plotting area (remember scrap area) */ ! 2396: continue; ! 2397: patloc = vdp_vram + (pattern<<5) + (vsize-ycell-1)*32; ! 2398: for (xcell = 0; xcell < hsize; xcell++, patloc+= vsize*32) { ! 2399: if (xcell*8+hpos < -7 || xcell*8+hpos >= 320) ! 2400: /* cell out of plotting area */ ! 2401: continue; ! 2402: cellloc = framedata + ((vpos+ycell*8)*lineoffset + ! 2403: (hpos+xcell*8)); ! 2404: vdp_plotcell(patloc, palette, flags, cellloc, lineoffset); ! 2405: } ! 2406: } ! 2407: break; ! 2408: case 3: ! 2409: case 7: ! 2410: /* H and V flip */ ! 2411: for (ycell = 0; ycell < vsize; ycell++) { ! 2412: if (ycell*8+vpos < -7 || ycell*8+vpos >= 240) ! 2413: /* cell out of plotting area (remember scrap area) */ ! 2414: continue; ! 2415: patloc = vdp_vram + (pattern<<5) + ((vsize-ycell-1)*32 + ! 2416: vsize*32*(hsize-1)); ! 2417: for (xcell = 0; xcell < hsize; xcell++, patloc-= vsize*32) { ! 2418: if (xcell*8+hpos < -7 || xcell*8+hpos >= 320) ! 2419: /* cell out of plotting area */ ! 2420: continue; ! 2421: cellloc = framedata + ((vpos+ycell*8)*lineoffset + ! 2422: (hpos+xcell*8)); ! 2423: vdp_plotcell(patloc, palette, flags, cellloc, lineoffset); ! 2424: } ! 2425: } ! 2426: break; ! 2427: } ! 2428: return plotted; ! 2429: } ! 2430: ! 2431: uint8 vdp_gethpos(void) { ! 2432: float percent; ! 2433: ! 2434: /* vdp_event = 0/1/2 -> beginning of line until 74 clocks before end ! 2435: 3 -> between hint and hdisplay (36 clocks) ! 2436: 4 -> between hdisplay and end (38 clocks) ! 2437: This routine goes from 0 to the maximum number allowed not within ! 2438: H-blank, and then goes slightly beyond up to hdisplay. Then ! 2439: between hdisplay and end we go negative. I'm not sure how negative ! 2440: it is supposed to be, this goes from -38 to 0. ! 2441: ! 2442: 40 horizontal cells, H goes from $00 to $B6, $E4 to $FF ! 2443: 32 horizontal cells, H goes from $00 to $93, $E8 to $FF ! 2444: ! 2445: this is such a bodge - any changes, check '3 Ninjas kick back' ! 2446: */ ! 2447: LOG_DEBUG1(("gethpos %X: clocks=%X : startofline=%X : hint=%X : " ! 2448: "end=%X", vdp_event, cpu68k_clocks, ! 2449: vdp_event_start, ! 2450: vdp_event_hint, vdp_event_end)); ! 2451: if (vdp_event < 3) { ! 2452: percent = ((float)(cpu68k_clocks-vdp_event_start)/ ! 2453: (float)(vdp_event_hint-vdp_event_start)); ! 2454: if (vdp_reg[12] & 1) ! 2455: return (cpu68k_clocks > vdp_event_hint) ? 0xE4 : percent*0xB6; ! 2456: else ! 2457: return (cpu68k_clocks > vdp_event_hint) ? 0xE8 : percent*0x93; ! 2458: } else { ! 2459: percent = ((float)(cpu68k_clocks-vdp_event_hint)/ ! 2460: (float)(vdp_event_end-vdp_event_hint)); ! 2461: if (vdp_reg[12] & 1) ! 2462: return ((cpu68k_clocks > vdp_event_end) ? 0 : ! 2463: ((0xE4+(uint8)percent*28) & 0xff)); ! 2464: else ! 2465: return ((cpu68k_clocks > vdp_event_end) ? 0 : ! 2466: ((0xE8+(uint8)percent*24) & 0xff)); ! 2467: } ! 2468: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.