928 lines
36 KiB
C#
928 lines
36 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using System.Text;
|
|
using System.Threading.Tasks;
|
|
using System.Diagnostics;
|
|
|
|
using Essgee.EventArguments;
|
|
using Essgee.Utilities;
|
|
|
|
using static Essgee.Emulation.Utilities;
|
|
|
|
namespace Essgee.Emulation.Video
|
|
{
|
|
/* Sega 315-5124 (Mark III, SMS) and 315-5246 (SMS 2); differences see 'VDPDIFF' comments */
|
|
public class SegaSMSVDP : TMS99xxA
|
|
{
|
|
/* VDPDIFF: switch for Mk3/SMS1 vs SMS2/GG behavior; configurable via SetRevision, maybe still split into separate classes instead? */
|
|
protected VDPTypes vdpType = VDPTypes.Mk3SMS1;
|
|
|
|
public const int NumActiveScanlinesLow = 192;
|
|
public const int NumActiveScanlinesMed = 224;
|
|
public const int NumActiveScanlinesHigh = 240;
|
|
|
|
protected const int NumSpritesMode4 = 64;
|
|
protected const int NumSpritesPerLineMode4 = 8;
|
|
|
|
public const int PortVCounter = 0x40; // 0x7E canonically, but mirrored across bus
|
|
public const int PortHCounter = 0x41; // 0x7F canonically, but mirrored across bus
|
|
|
|
[StateRequired]
|
|
protected byte[] cram;
|
|
|
|
[StateRequired]
|
|
protected int vCounter, hCounter;
|
|
protected int nametableHeight, vCounterTableIndex;
|
|
[StateRequired]
|
|
protected int lineInterruptCounter;
|
|
protected int screenHeight;
|
|
|
|
bool isLineInterruptEnabled => IsBitSet(registers[0x00], 4);
|
|
[StateRequired]
|
|
bool isLineInterruptPending;
|
|
|
|
bool isColumn0MaskEnabled => IsBitSet(registers[0x00], 5);
|
|
bool isVScrollPartiallyDisabled => IsBitSet(registers[0x00], 7); /* Columns 24-31, i.e. pixels 192-255 */
|
|
bool isHScrollPartiallyDisabled => IsBitSet(registers[0x00], 6); /* Rows 0-1, i.e. pixels 0-15 */
|
|
|
|
bool isBitM4Set => IsBitSet(registers[0x00], 2);
|
|
|
|
protected override bool isModeGraphics1 => !(isBitM1Set || isBitM2Set || isBitM3Set || isBitM4Set);
|
|
protected override bool isModeText => (isBitM1Set && !(isBitM2Set || isBitM3Set || isBitM4Set));
|
|
protected override bool isModeGraphics2 => (isBitM2Set && !(isBitM1Set || isBitM3Set || isBitM4Set));
|
|
protected override bool isModeMulticolor => (isBitM3Set && !(isBitM1Set || isBitM2Set || isBitM4Set));
|
|
|
|
protected bool isSMS240LineMode => (!isBitM1Set && isBitM2Set && isBitM3Set && isBitM4Set);
|
|
protected bool isSMS224LineMode => (isBitM1Set && isBitM2Set && !isBitM3Set && isBitM4Set);
|
|
|
|
bool isSpriteShiftLeft8 => IsBitSet(registers[0x00], 3);
|
|
|
|
protected override ushort nametableBaseAddress
|
|
{
|
|
get
|
|
{
|
|
if (isBitM4Set)
|
|
{
|
|
if (isSMS224LineMode || isSMS240LineMode)
|
|
return (ushort)(((registers[0x02] & 0x0C) << 10) | 0x700);
|
|
else
|
|
return (ushort)((registers[0x02] & 0x0E) << 10);
|
|
}
|
|
else
|
|
return (ushort)((registers[0x02] & 0x0F) << 10);
|
|
}
|
|
}
|
|
protected override ushort spriteAttribTableBaseAddress => (ushort)((registers[0x05] & (isBitM4Set ? 0x7E : 0x7F)) << 7);
|
|
protected override ushort spritePatternGenBaseAddress => (ushort)((registers[0x06] & (isBitM4Set ? 0x04 : 0x07)) << 11);
|
|
|
|
/* http://www.smspower.org/Development/Palette */
|
|
// TODO: verify these, SMSPower has some mistakes (RGB approx correct, palette value wrong)
|
|
// (not that we'll really use this, aside from for F-16 Fighting Falcon, as SG1000 games should always be loaded into the SG1000 core...)
|
|
readonly byte[] legacyColorMap = new byte[]
|
|
{
|
|
0x00, /* Transparent */
|
|
0x00, /* Black */
|
|
0x08, /* Medium green */
|
|
0x0C, /* Light green */
|
|
0x10, /* Dark blue */
|
|
0x30, /* Light blue */
|
|
0x01, /* Dark red */
|
|
0x3C, /* Cyan */
|
|
0x02, /* Medium red */
|
|
0x03, /* Light red */
|
|
0x05, /* Dark yellow */
|
|
0x0F, /* Light yellow */
|
|
0x04, /* Dark green */
|
|
0x33, /* Magenta */
|
|
0x15, /* Gray */
|
|
0x3F /* White */
|
|
};
|
|
|
|
readonly byte[][] vCounterTables = new byte[][]
|
|
{
|
|
/* NTSC, 192 lines */
|
|
new byte[]
|
|
{
|
|
/* Top blanking */
|
|
0xD8, 0xD9, 0xDA, 0xDB, 0xDC, 0xDD, 0xDE, 0xDF, 0xE0, 0xE1, 0xE2, 0xE3, 0xE4,
|
|
|
|
/* Top border */
|
|
0xE5, 0xE6, 0xE7, 0xE8, 0xE9, 0xEA, 0xEB, 0xEC, 0xED, 0xEE, 0xEF, 0xF0, 0xF1, 0xF2, 0xF3, 0xF4,
|
|
0xF5, 0xF6, 0xF7, 0xF8, 0xF9, 0xFA, 0xFB, 0xFC, 0xFD, 0xFE, 0xFF,
|
|
|
|
/* Active display */
|
|
0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F,
|
|
0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F,
|
|
0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2A, 0x2B, 0x2C, 0x2D, 0x2E, 0x2F,
|
|
0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3A, 0x3B, 0x3C, 0x3D, 0x3E, 0x3F,
|
|
0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4A, 0x4B, 0x4C, 0x4D, 0x4E, 0x4F,
|
|
0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5A, 0x5B, 0x5C, 0x5D, 0x5E, 0x5F,
|
|
0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6A, 0x6B, 0x6C, 0x6D, 0x6E, 0x6F,
|
|
0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7A, 0x7B, 0x7C, 0x7D, 0x7E, 0x7F,
|
|
0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8A, 0x8B, 0x8C, 0x8D, 0x8E, 0x8F,
|
|
0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9A, 0x9B, 0x9C, 0x9D, 0x9E, 0x9F,
|
|
0xA0, 0xA1, 0xA2, 0xA3, 0xA4, 0xA5, 0xA6, 0xA7, 0xA8, 0xA9, 0xAA, 0xAB, 0xAC, 0xAD, 0xAE, 0xAF,
|
|
0xB0, 0xB1, 0xB2, 0xB3, 0xB4, 0xB5, 0xB6, 0xB7, 0xB8, 0xB9, 0xBA, 0xBB, 0xBC, 0xBD, 0xBE, 0xBF,
|
|
|
|
/* Bottom border */
|
|
0xC0, 0xC1, 0xC2, 0xC3, 0xC4, 0xC5, 0xC6, 0xC7, 0xC8, 0xC9, 0xCA, 0xCB, 0xCC, 0xCD, 0xCE, 0xCF,
|
|
0xD0, 0xD1, 0xD2, 0xD3, 0xD4, 0xD5, 0xD6, 0xD7,
|
|
|
|
/* Bottom blanking */
|
|
0xD8, 0xD9, 0xDA,
|
|
|
|
/* Vertical blanking */
|
|
0xD5, 0xD6, 0xD7
|
|
},
|
|
/* NTSC, 224 lines */
|
|
new byte[]
|
|
{
|
|
/* Top blanking */
|
|
0xE8, 0xE9, 0xEA, 0xEB, 0xEC, 0xED, 0xEE, 0xEF, 0xF0, 0xF1, 0xF2, 0xF3, 0xF4,
|
|
|
|
/* Top border */
|
|
0xF5, 0xF6, 0xF7, 0xF8, 0xF9, 0xFA, 0xFB, 0xFC, 0xFD, 0xFE, 0xFF,
|
|
|
|
/* Active display */
|
|
0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F,
|
|
0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F,
|
|
0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2A, 0x2B, 0x2C, 0x2D, 0x2E, 0x2F,
|
|
0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3A, 0x3B, 0x3C, 0x3D, 0x3E, 0x3F,
|
|
0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4A, 0x4B, 0x4C, 0x4D, 0x4E, 0x4F,
|
|
0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5A, 0x5B, 0x5C, 0x5D, 0x5E, 0x5F,
|
|
0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6A, 0x6B, 0x6C, 0x6D, 0x6E, 0x6F,
|
|
0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7A, 0x7B, 0x7C, 0x7D, 0x7E, 0x7F,
|
|
0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8A, 0x8B, 0x8C, 0x8D, 0x8E, 0x8F,
|
|
0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9A, 0x9B, 0x9C, 0x9D, 0x9E, 0x9F,
|
|
0xA0, 0xA1, 0xA2, 0xA3, 0xA4, 0xA5, 0xA6, 0xA7, 0xA8, 0xA9, 0xAA, 0xAB, 0xAC, 0xAD, 0xAE, 0xAF,
|
|
0xB0, 0xB1, 0xB2, 0xB3, 0xB4, 0xB5, 0xB6, 0xB7, 0xB8, 0xB9, 0xBA, 0xBB, 0xBC, 0xBD, 0xBE, 0xBF,
|
|
0xC0, 0xC1, 0xC2, 0xC3, 0xC4, 0xC5, 0xC6, 0xC7, 0xC8, 0xC9, 0xCA, 0xCB, 0xCC, 0xCD, 0xCE, 0xCF,
|
|
0xD0, 0xD1, 0xD2, 0xD3, 0xD4, 0xD5, 0xD6, 0xD7, 0xD8, 0xD9, 0xDA, 0xDB, 0xDC, 0xDD, 0xDE, 0xDF,
|
|
|
|
/* Bottom border */
|
|
0xE0, 0xE1, 0xE2, 0xE3, 0xE4, 0xE5, 0xE6, 0xE7,
|
|
|
|
/* Bottom blanking */
|
|
0xE8, 0xE9, 0xEA,
|
|
|
|
/* Vertical blanking */
|
|
0xE5, 0xE6, 0xE7,
|
|
},
|
|
/* NTSC, 240 lines (invalid) */
|
|
new byte[]
|
|
{
|
|
0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F,
|
|
0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F,
|
|
0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2A, 0x2B, 0x2C, 0x2D, 0x2E, 0x2F,
|
|
0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3A, 0x3B, 0x3C, 0x3D, 0x3E, 0x3F,
|
|
0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4A, 0x4B, 0x4C, 0x4D, 0x4E, 0x4F,
|
|
0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5A, 0x5B, 0x5C, 0x5D, 0x5E, 0x5F,
|
|
0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6A, 0x6B, 0x6C, 0x6D, 0x6E, 0x6F,
|
|
0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7A, 0x7B, 0x7C, 0x7D, 0x7E, 0x7F,
|
|
0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8A, 0x8B, 0x8C, 0x8D, 0x8E, 0x8F,
|
|
0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9A, 0x9B, 0x9C, 0x9D, 0x9E, 0x9F,
|
|
0xA0, 0xA1, 0xA2, 0xA3, 0xA4, 0xA5, 0xA6, 0xA7, 0xA8, 0xA9, 0xAA, 0xAB, 0xAC, 0xAD, 0xAE, 0xAF,
|
|
0xB0, 0xB1, 0xB2, 0xB3, 0xB4, 0xB5, 0xB6, 0xB7, 0xB8, 0xB9, 0xBA, 0xBB, 0xBC, 0xBD, 0xBE, 0xBF,
|
|
0xC0, 0xC1, 0xC2, 0xC3, 0xC4, 0xC5, 0xC6, 0xC7, 0xC8, 0xC9, 0xCA, 0xCB, 0xCC, 0xCD, 0xCE, 0xCF,
|
|
0xD0, 0xD1, 0xD2, 0xD3, 0xD4, 0xD5, 0xD6, 0xD7, 0xD8, 0xD9, 0xDA, 0xDB, 0xDC, 0xDD, 0xDE, 0xDF,
|
|
0xE0, 0xE1, 0xE2, 0xE3, 0xE4, 0xE5, 0xE6, 0xE7, 0xE8, 0xE9, 0xEA, 0xEB, 0xEC, 0xED, 0xEE, 0xEF,
|
|
0xF0, 0xF1, 0xF2, 0xF3, 0xF4, 0xF5, 0xF6, 0xF7, 0xF8, 0xF9, 0xFA, 0xFB, 0xFC, 0xFD, 0xFE, 0xFF,
|
|
0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06
|
|
},
|
|
/* PAL, 192 lines */
|
|
new byte[]
|
|
{
|
|
/* Top blanking */
|
|
0xBD, 0xBE, 0xBF, 0xC0, 0xC1, 0xC2, 0xC3, 0xC4, 0xC5, 0xC6, 0xC7, 0xC8, 0xC9,
|
|
|
|
/* Top border */
|
|
0xCA, 0xCB, 0xCC, 0xCD, 0xCE, 0xCF, 0xD0, 0xD1, 0xD2, 0xD3, 0xD4, 0xD5, 0xD6, 0xD7, 0xD8, 0xD9,
|
|
0xDA, 0xDB, 0xDC, 0xDD, 0xDE, 0xDF, 0xE0, 0xE1, 0xE2, 0xE3, 0xE4, 0xE5, 0xE6, 0xE7, 0xE8, 0xE9,
|
|
0xEA, 0xEB, 0xEC, 0xED, 0xEE, 0xEF, 0xF0, 0xF1, 0xF2, 0xF3, 0xF4, 0xF5, 0xF6, 0xF7, 0xF8, 0xF9,
|
|
0xFA, 0xFB, 0xFC, 0xFD, 0xFE, 0xFF,
|
|
|
|
/* Active display */
|
|
0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F,
|
|
0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F,
|
|
0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2A, 0x2B, 0x2C, 0x2D, 0x2E, 0x2F,
|
|
0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3A, 0x3B, 0x3C, 0x3D, 0x3E, 0x3F,
|
|
0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4A, 0x4B, 0x4C, 0x4D, 0x4E, 0x4F,
|
|
0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5A, 0x5B, 0x5C, 0x5D, 0x5E, 0x5F,
|
|
0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6A, 0x6B, 0x6C, 0x6D, 0x6E, 0x6F,
|
|
0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7A, 0x7B, 0x7C, 0x7D, 0x7E, 0x7F,
|
|
0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8A, 0x8B, 0x8C, 0x8D, 0x8E, 0x8F,
|
|
0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9A, 0x9B, 0x9C, 0x9D, 0x9E, 0x9F,
|
|
0xA0, 0xA1, 0xA2, 0xA3, 0xA4, 0xA5, 0xA6, 0xA7, 0xA8, 0xA9, 0xAA, 0xAB, 0xAC, 0xAD, 0xAE, 0xAF,
|
|
0xB0, 0xB1, 0xB2, 0xB3, 0xB4, 0xB5, 0xB6, 0xB7, 0xB8, 0xB9, 0xBA, 0xBB, 0xBC, 0xBD, 0xBE, 0xBF,
|
|
|
|
/* Bottom border */
|
|
0xC0, 0xC1, 0xC2, 0xC3, 0xC4, 0xC5, 0xC6, 0xC7, 0xC8, 0xC9, 0xCA, 0xCB, 0xCC, 0xCD, 0xCE, 0xCF,
|
|
0xD0, 0xD1, 0xD2, 0xD3, 0xD4, 0xD5, 0xD6, 0xD7, 0xD8, 0xD9, 0xDA, 0xDB, 0xDC, 0xDD, 0xDE, 0xDF,
|
|
0xE0, 0xE1, 0xE2, 0xE3, 0xE4, 0xE5, 0xE6, 0xE7, 0xE8, 0xE9, 0xEA, 0xEB, 0xEC, 0xED, 0xEE, 0xEF,
|
|
|
|
/* Bottom blanking */
|
|
0xF0, 0xF1, 0xF2,
|
|
|
|
/* Vertical blanking */
|
|
0xBA, 0xBB, 0xBC
|
|
},
|
|
/* PAL, 224 lines */
|
|
new byte[]
|
|
{
|
|
/* Top blanking */
|
|
0xCD, 0xCE, 0xCF, 0xD0, 0xD1, 0xD2, 0xD3, 0xD4, 0xD5, 0xD6, 0xD7, 0xD8, 0xD9,
|
|
|
|
/* Top border */
|
|
0xDA, 0xDB, 0xDC, 0xDD, 0xDE, 0xDF, 0xE0, 0xE1, 0xE2, 0xE3, 0xE4, 0xE5, 0xE6, 0xE7, 0xE8, 0xE9,
|
|
0xEA, 0xEB, 0xEC, 0xED, 0xEE, 0xEF, 0xF0, 0xF1, 0xF2, 0xF3, 0xF4, 0xF5, 0xF6, 0xF7, 0xF8, 0xF9,
|
|
0xFA, 0xFB, 0xFC, 0xFD, 0xFE, 0xFF,
|
|
|
|
/* Active display */
|
|
0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F,
|
|
0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F,
|
|
0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2A, 0x2B, 0x2C, 0x2D, 0x2E, 0x2F,
|
|
0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3A, 0x3B, 0x3C, 0x3D, 0x3E, 0x3F,
|
|
0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4A, 0x4B, 0x4C, 0x4D, 0x4E, 0x4F,
|
|
0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5A, 0x5B, 0x5C, 0x5D, 0x5E, 0x5F,
|
|
0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6A, 0x6B, 0x6C, 0x6D, 0x6E, 0x6F,
|
|
0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7A, 0x7B, 0x7C, 0x7D, 0x7E, 0x7F,
|
|
0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8A, 0x8B, 0x8C, 0x8D, 0x8E, 0x8F,
|
|
0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9A, 0x9B, 0x9C, 0x9D, 0x9E, 0x9F,
|
|
0xA0, 0xA1, 0xA2, 0xA3, 0xA4, 0xA5, 0xA6, 0xA7, 0xA8, 0xA9, 0xAA, 0xAB, 0xAC, 0xAD, 0xAE, 0xAF,
|
|
0xB0, 0xB1, 0xB2, 0xB3, 0xB4, 0xB5, 0xB6, 0xB7, 0xB8, 0xB9, 0xBA, 0xBB, 0xBC, 0xBD, 0xBE, 0xBF,
|
|
0xC0, 0xC1, 0xC2, 0xC3, 0xC4, 0xC5, 0xC6, 0xC7, 0xC8, 0xC9, 0xCA, 0xCB, 0xCC, 0xCD, 0xCE, 0xCF,
|
|
0xD0, 0xD1, 0xD2, 0xD3, 0xD4, 0xD5, 0xD6, 0xD7, 0xD8, 0xD9, 0xDA, 0xDB, 0xDC, 0xDD, 0xDE, 0xDF,
|
|
|
|
/* Bottom border */
|
|
0xE0, 0xE1, 0xE2, 0xE3, 0xE4, 0xE5, 0xE6, 0xE7, 0xE8, 0xE9, 0xEA, 0xEB, 0xEC, 0xED, 0xEE, 0xEF,
|
|
0xF0, 0xF1, 0xF2, 0xF3, 0xF4, 0xF5, 0xF6, 0xF7, 0xF8, 0xF9, 0xFA, 0xFB, 0xFC, 0xFD, 0xFE, 0xFF,
|
|
|
|
/* Bottom blanking */
|
|
0x00, 0x01, 0x02,
|
|
|
|
/* Vertical blanking */
|
|
0xCA, 0xCB, 0xCC,
|
|
},
|
|
/* PAL, 240 lines */
|
|
new byte[]
|
|
{
|
|
/* Top blanking */
|
|
0xD5, 0xD6, 0xD7, 0xD8, 0xD9, 0xDA, 0xDB, 0xDC, 0xDD, 0xDE, 0xDF, 0xE0, 0xE1,
|
|
|
|
/* Top border */
|
|
0xE2, 0xE3, 0xE4, 0xE5, 0xE6, 0xE7, 0xE8, 0xE9, 0xEA, 0xEB, 0xEC, 0xED, 0xEE, 0xEF, 0xF0, 0xF1,
|
|
0xF2, 0xF3, 0xF4, 0xF5, 0xF6, 0xF7, 0xF8, 0xF9, 0xFA, 0xFB, 0xFC, 0xFD, 0xFE, 0xFF,
|
|
|
|
/* Active display */
|
|
0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F,
|
|
0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F,
|
|
0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2A, 0x2B, 0x2C, 0x2D, 0x2E, 0x2F,
|
|
0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3A, 0x3B, 0x3C, 0x3D, 0x3E, 0x3F,
|
|
0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4A, 0x4B, 0x4C, 0x4D, 0x4E, 0x4F,
|
|
0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5A, 0x5B, 0x5C, 0x5D, 0x5E, 0x5F,
|
|
0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6A, 0x6B, 0x6C, 0x6D, 0x6E, 0x6F,
|
|
0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7A, 0x7B, 0x7C, 0x7D, 0x7E, 0x7F,
|
|
0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8A, 0x8B, 0x8C, 0x8D, 0x8E, 0x8F,
|
|
0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9A, 0x9B, 0x9C, 0x9D, 0x9E, 0x9F,
|
|
0xA0, 0xA1, 0xA2, 0xA3, 0xA4, 0xA5, 0xA6, 0xA7, 0xA8, 0xA9, 0xAA, 0xAB, 0xAC, 0xAD, 0xAE, 0xAF,
|
|
0xB0, 0xB1, 0xB2, 0xB3, 0xB4, 0xB5, 0xB6, 0xB7, 0xB8, 0xB9, 0xBA, 0xBB, 0xBC, 0xBD, 0xBE, 0xBF,
|
|
0xC0, 0xC1, 0xC2, 0xC3, 0xC4, 0xC5, 0xC6, 0xC7, 0xC8, 0xC9, 0xCA, 0xCB, 0xCC, 0xCD, 0xCE, 0xCF,
|
|
0xD0, 0xD1, 0xD2, 0xD3, 0xD4, 0xD5, 0xD6, 0xD7, 0xD8, 0xD9, 0xDA, 0xDB, 0xDC, 0xDD, 0xDE, 0xDF,
|
|
0xE0, 0xE1, 0xE2, 0xE3, 0xE4, 0xE5, 0xE6, 0xE7, 0xE8, 0xE9, 0xEA, 0xEB, 0xEC, 0xED, 0xEE, 0xEF,
|
|
|
|
/* Bottom border */
|
|
0xF0, 0xF1, 0xF2, 0xF3, 0xF4, 0xF5, 0xF6, 0xF7, 0xF8, 0xF9, 0xFA, 0xFB, 0xFC, 0xFD, 0xFE, 0xFF,
|
|
0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
|
|
|
|
/* Bottom blanking */
|
|
0x08, 0x09, 0x0A,
|
|
|
|
/* Vertical blanking */
|
|
0xD2, 0xD3, 0xD4,
|
|
}
|
|
};
|
|
|
|
/* For H-counter emulation */
|
|
readonly byte[] hCounterTable = new byte[]
|
|
{
|
|
0x00, 0x01, 0x02, 0x02, 0x03, 0x04, 0x05, 0x05, 0x06, 0x07, 0x08, 0x08, 0x09, 0x0A, 0x0B, 0x0B,
|
|
0x0C, 0x0D, 0x0E, 0x0E, 0x0F, 0x10, 0x11, 0x11, 0x12, 0x13, 0x14, 0x14, 0x15, 0x16, 0x17, 0x17,
|
|
0x18, 0x19, 0x1A, 0x1A, 0x1B, 0x1C, 0x1D, 0x1D, 0x1E, 0x1F, 0x20, 0x20, 0x21, 0x22, 0x23, 0x23,
|
|
0x24, 0x25, 0x26, 0x26, 0x27, 0x28, 0x29, 0x29, 0x2A, 0x2B, 0x2C, 0x2C, 0x2D, 0x2E, 0x2F, 0x2F,
|
|
0x30, 0x31, 0x32, 0x32, 0x33, 0x34, 0x35, 0x35, 0x36, 0x37, 0x38, 0x38, 0x39, 0x3A, 0x3B, 0x3B,
|
|
0x3C, 0x3D, 0x3E, 0x3E, 0x3F, 0x40, 0x41, 0x41, 0x42, 0x43, 0x44, 0x44, 0x45, 0x46, 0x47, 0x47,
|
|
0x48, 0x49, 0x4A, 0x4A, 0x4B, 0x4C, 0x4D, 0x4D, 0x4E, 0x4F, 0x50, 0x50, 0x51, 0x52, 0x53, 0x53,
|
|
0x54, 0x55, 0x56, 0x56, 0x57, 0x58, 0x59, 0x59, 0x5A, 0x5B, 0x5C, 0x5C, 0x5D, 0x5E, 0x5F, 0x5F,
|
|
0x60, 0x61, 0x62, 0x62, 0x63, 0x64, 0x65, 0x65, 0x66, 0x67, 0x68, 0x68, 0x69, 0x6A, 0x6B, 0x6B,
|
|
0x6C, 0x6D, 0x6E, 0x6E, 0x6F, 0x70, 0x71, 0x71, 0x72, 0x73, 0x74, 0x74, 0x75, 0x76, 0x77, 0x77,
|
|
0x78, 0x79, 0x7A, 0x7A, 0x7B, 0x7C, 0x7D, 0x7D, 0x7E, 0x7F, 0x80, 0x80, 0x81, 0x82, 0x83, 0x83,
|
|
0x84, 0x85, 0x86, 0x86, 0x87, 0x88, 0x89, 0x89, 0x8A, 0x8B, 0x8C, 0x8C, 0x8D, 0x8E, 0x8F, 0x8F,
|
|
0x90, 0x91, 0x92, 0x92, 0x93,
|
|
|
|
0xE9, 0xEA, 0xEA, 0xEB, 0xEC, 0xED, 0xED, 0xEE, 0xEF, 0xF0, 0xF0, 0xF1, 0xF2, 0xF3, 0xF3, 0xF4,
|
|
0xF5, 0xF6, 0xF6, 0xF7, 0xF8, 0xF9, 0xF9, 0xFA, 0xFB, 0xFC, 0xFC, 0xFD, 0xFE, 0xFF, 0xFF
|
|
};
|
|
|
|
[StateRequired]
|
|
byte horizontalScrollLatched, verticalScrollLatched;
|
|
|
|
const byte screenUsageBgLowPriority = screenUsageBackground;
|
|
const byte screenUsageBgHighPriority = (1 << 2);
|
|
|
|
public int ScreenHeight => screenHeight;
|
|
public int CurrentScanline => currentScanline;
|
|
|
|
public SegaSMSVDP() : base()
|
|
{
|
|
registers = new byte[0x0B];
|
|
cram = new byte[0x20];
|
|
|
|
spriteBuffer = new (int Number, int Y, int X, int Pattern, int Attribute)[NumActiveScanlinesHigh][];
|
|
for (int i = 0; i < spriteBuffer.Length; i++) spriteBuffer[i] = new (int Number, int Y, int X, int Pattern, int Attribute)[NumSpritesPerLineMode4];
|
|
}
|
|
|
|
public override void Reset()
|
|
{
|
|
base.Reset();
|
|
|
|
WriteRegister(0x00, 0x36);
|
|
WriteRegister(0x01, 0x80);
|
|
WriteRegister(0x02, 0xFF);
|
|
WriteRegister(0x03, 0xFF);
|
|
WriteRegister(0x04, 0xFF);
|
|
WriteRegister(0x05, 0xFF);
|
|
WriteRegister(0x06, 0xFB);
|
|
WriteRegister(0x07, 0x00);
|
|
WriteRegister(0x08, 0x00);
|
|
WriteRegister(0x09, 0x00);
|
|
WriteRegister(0x0A, 0xFF);
|
|
|
|
for (int i = 0; i < cram.Length; i++) cram[i] = 0;
|
|
|
|
vCounter = hCounter = 0;
|
|
lineInterruptCounter = registers[0x0A];
|
|
|
|
isLineInterruptPending = false;
|
|
|
|
horizontalScrollLatched = verticalScrollLatched = 0;
|
|
|
|
UpdateResolution();
|
|
}
|
|
|
|
public override void SetRevision(int rev)
|
|
{
|
|
VDPTypes type = (VDPTypes)rev;
|
|
Debug.Assert(Enum.IsDefined(typeof(VDPTypes), type), "Invalid revision", "{0} revision is invalid; only rev 0 (MK3/SMS1) or 1 (SMS2/GG) is valid", GetType().FullName);
|
|
vdpType = type;
|
|
}
|
|
|
|
protected override void ReconfigureTimings()
|
|
{
|
|
/* Calculate cycles/line */
|
|
clockCyclesPerLine = (int)Math.Round((clockRate / refreshRate) / numTotalScanlines);
|
|
|
|
/* Create arrays */
|
|
screenUsage = new byte[numVisiblePixels * numVisibleScanlines];
|
|
outputFramebuffer = new byte[(numVisiblePixels * numVisibleScanlines) * 4];
|
|
|
|
/* Update resolution/display timing */
|
|
UpdateResolution();
|
|
}
|
|
|
|
public override void Step(int clockCyclesInStep)
|
|
{
|
|
InterruptLine = (((isFrameInterruptEnabled && isFrameInterruptPending) || (isLineInterruptEnabled && isLineInterruptPending)) ? InterruptState.Assert : InterruptState.Clear);
|
|
|
|
cycleCount += clockCyclesInStep;
|
|
|
|
hCounter = hCounterTable[(int)Math.Round((cycleCount + 578) / 3.0) % hCounterTable.Length];
|
|
|
|
if (cycleCount >= clockCyclesPerLine)
|
|
{
|
|
OnEndOfScanline(EventArgs.Empty);
|
|
|
|
horizontalScrollLatched = registers[0x08];
|
|
|
|
if (currentScanline == scanlineActiveDisplay)
|
|
verticalScrollLatched = registers[0x09];
|
|
|
|
CheckSpriteOverflow(currentScanline);
|
|
|
|
RenderLine(currentScanline);
|
|
|
|
if (currentScanline >= scanlineActiveDisplay && currentScanline <= scanlineBottomBorder)
|
|
{
|
|
lineInterruptCounter--;
|
|
if (lineInterruptCounter < 0)
|
|
{
|
|
lineInterruptCounter = registers[0x0A];
|
|
isLineInterruptPending = true;
|
|
}
|
|
}
|
|
else
|
|
lineInterruptCounter = registers[0x0A];
|
|
|
|
if (currentScanline == (scanlineBottomBorder + 1))
|
|
isFrameInterruptPending = true;
|
|
|
|
vCounter = vCounterTables[vCounterTableIndex][currentScanline];
|
|
|
|
currentScanline++;
|
|
if (currentScanline == numTotalScanlines)
|
|
{
|
|
currentScanline = 0;
|
|
ClearScreenUsage();
|
|
|
|
PrepareRenderScreen();
|
|
}
|
|
|
|
ParseSpriteTable(currentScanline);
|
|
|
|
cycleCount -= clockCyclesPerLine;
|
|
if (cycleCount <= -clockCyclesPerLine) cycleCount = 0;
|
|
}
|
|
}
|
|
|
|
protected override void PrepareRenderScreen()
|
|
{
|
|
OnRenderScreen(new RenderScreenEventArgs(numVisiblePixels, numVisibleScanlines, outputFramebuffer.Clone() as byte[]));
|
|
}
|
|
|
|
protected override byte ReadVram(ushort address)
|
|
{
|
|
return vram[address & vramMask16k];
|
|
}
|
|
|
|
protected override void WriteVram(ushort address, byte value)
|
|
{
|
|
vram[address & vramMask16k] = value;
|
|
}
|
|
|
|
protected override void RenderLine(int y)
|
|
{
|
|
if (y >= scanlineTopBorder && y < scanlineActiveDisplay)
|
|
{
|
|
if (layerBordersForceEnable) SetLine(y, 1, backgroundColor);
|
|
else SetLine(y, 0x00, 0x00, 0x00);
|
|
}
|
|
else if (y >= scanlineActiveDisplay && y < scanlineBottomBorder)
|
|
{
|
|
if (layerBackgroundForceEnable)
|
|
{
|
|
if (isBitM4Set)
|
|
RenderLineMode4Background(y);
|
|
else if (isModeGraphics1)
|
|
RenderLineGraphics1Background(y);
|
|
else if (isModeGraphics2)
|
|
RenderLineGraphics2Background(y);
|
|
else if (isModeMulticolor)
|
|
RenderLineMulticolorBackground(y);
|
|
else if (isModeText)
|
|
RenderLineTextBackground(y);
|
|
}
|
|
else
|
|
SetLine(y, 0x00, 0x00, 0x00);
|
|
|
|
if (layerSpritesForceEnable)
|
|
{
|
|
if (isBitM4Set)
|
|
RenderLineMode4Sprites(y);
|
|
else if (!isModeText && !isBitM4Set)
|
|
RenderLineSprites(y);
|
|
}
|
|
|
|
RenderBorders(y);
|
|
}
|
|
else if (y >= scanlineBottomBorder && y < numVisibleScanlines)
|
|
{
|
|
if (layerBordersForceEnable) SetLine(y, 1, backgroundColor);
|
|
else SetLine(y, 0x00, 0x00, 0x00);
|
|
}
|
|
}
|
|
|
|
protected override void RenderBorders(int y)
|
|
{
|
|
for (int x = pixelLeftBorder; x < pixelActiveDisplay; x++)
|
|
{
|
|
if (layerBordersForceEnable) SetPixel(y, x, 1, backgroundColor);
|
|
else SetPixel(y, x, 0x00, 0x00, 0x00);
|
|
}
|
|
for (int x = pixelRightBorder; x < numVisiblePixels; x++)
|
|
{
|
|
if (layerBordersForceEnable) SetPixel(y, x, 1, backgroundColor);
|
|
else SetPixel(y, x, 0x00, 0x00, 0x00);
|
|
}
|
|
}
|
|
|
|
protected void SetLine(int y, int palette, int color)
|
|
{
|
|
for (int x = 0; x < numVisiblePixels; x++)
|
|
SetPixel(y, x, palette, color);
|
|
}
|
|
|
|
protected virtual void SetPixel(int y, int x, int palette, int color)
|
|
{
|
|
WriteColorToFramebuffer(palette, color, ((y * numVisiblePixels) + (x % numVisiblePixels)) * 4);
|
|
}
|
|
|
|
private void RenderLineMode4Background(int y)
|
|
{
|
|
/* Determine coordinates in active display */
|
|
int activeDisplayY = (y - scanlineActiveDisplay);
|
|
|
|
/* Determine H scrolling parameters */
|
|
int currentHorizontalScroll = ((isHScrollPartiallyDisabled && activeDisplayY < 16) ? 0 : horizontalScrollLatched);
|
|
int horizontalScrollCoarse = (currentHorizontalScroll >> 3);
|
|
int horizontalScrollFine = (currentHorizontalScroll & 0x07);
|
|
|
|
ushort currentNametableBaseAddress = nametableBaseAddress;
|
|
bool currentIsVScrollPartiallyDisabled = isVScrollPartiallyDisabled;
|
|
bool currentIsColumn0MaskEnabled = isColumn0MaskEnabled;
|
|
|
|
for (int x = 0; x < numTotalPixelsPerScanline; x++)
|
|
{
|
|
int activeDisplayX = (x - pixelActiveDisplay);
|
|
if (activeDisplayX < 0 || activeDisplayX >= NumActivePixelsPerScanline) continue;
|
|
|
|
/* Determine V scrolling parameters */
|
|
int currentVerticalScroll = ((currentIsVScrollPartiallyDisabled && activeDisplayX >= 192) ? 0 : verticalScrollLatched);
|
|
int verticalScrollCoarse = (currentVerticalScroll >> 3);
|
|
int verticalScrollFine = (currentVerticalScroll & 0x07);
|
|
|
|
/* Calculate current scrolled column and row */
|
|
int numColumns = 32;
|
|
int currentColumn = (((activeDisplayX - horizontalScrollFine) / 8) - horizontalScrollCoarse) & (numColumns - 1);
|
|
int currentRow = (((activeDisplayY + verticalScrollFine) / 8) + verticalScrollCoarse) % (nametableHeight / 8);
|
|
|
|
/* VDPDIFF: Mk3/SMS1 VDP only, adjust current row according to mask bit; http://www.smspower.org/Development/TilemapMirroring
|
|
* NOTE: Emulating this breaks 224/240-line mode games (ex. Fantastic Dizzy, Cosmic Spacehead, Micro Machines)?
|
|
*/
|
|
if (vdpType == VDPTypes.Mk3SMS1)
|
|
currentRow &= (((registers[0x02] & 0x01) << 4) | 0x0F);
|
|
|
|
/* Fetch data from nametable & extract properties */
|
|
ushort nametableAddress = (ushort)(currentNametableBaseAddress + (currentRow * (numColumns * 2)) + (currentColumn * 2));
|
|
ushort nametableData = (ushort)(ReadVram((ushort)(nametableAddress + 1)) << 8 | ReadVram(nametableAddress));
|
|
|
|
int tileIndex = (nametableData & 0x01FF);
|
|
bool hFlip = ((nametableData & 0x0200) == 0x0200);
|
|
bool vFlip = ((nametableData & 0x0400) == 0x0400);
|
|
int palette = (((nametableData & 0x0800) >> 11) & 0x0001);
|
|
bool priority = ((nametableData & 0x1000) == 0x1000);
|
|
|
|
/* Fetch pixel data for current pixel line */
|
|
int hPixel = ((activeDisplayX - horizontalScrollFine) % 8);
|
|
hPixel = (hFlip ? hPixel : (7 - hPixel));
|
|
int vPixel = ((activeDisplayY + verticalScrollFine) % 8);
|
|
vPixel = (!vFlip ? vPixel : (7 - vPixel));
|
|
|
|
ushort tileAddress = (ushort)((tileIndex << 5) + (vPixel << 2));
|
|
int c = (((ReadVram((ushort)(tileAddress + 0)) >> hPixel) & 0x01) << 0);
|
|
c |= (((ReadVram((ushort)(tileAddress + 1)) >> hPixel) & 0x01) << 1);
|
|
c |= (((ReadVram((ushort)(tileAddress + 2)) >> hPixel) & 0x01) << 2);
|
|
c |= (((ReadVram((ushort)(tileAddress + 3)) >> hPixel) & 0x01) << 3);
|
|
|
|
/* Record screen usage, write to framebuffer */
|
|
if (GetScreenUsageFlag(y, x) == screenUsageEmpty)
|
|
{
|
|
if ((currentIsColumn0MaskEnabled && (activeDisplayX / 8) == 0) || isDisplayBlanked)
|
|
SetPixel(y, x, 1, backgroundColor);
|
|
else
|
|
SetPixel(y, x, palette, c);
|
|
|
|
SetScreenUsageFlag(y, x, (c != 0 && priority) ? screenUsageBgHighPriority : screenUsageBgLowPriority);
|
|
}
|
|
}
|
|
}
|
|
|
|
protected override void CheckSpriteOverflow(int y)
|
|
{
|
|
if (!isBitM4Set)
|
|
{
|
|
/* Not in Master System video mode */
|
|
base.CheckSpriteOverflow(y);
|
|
}
|
|
else
|
|
{
|
|
/* Ensure current scanline is within active display */
|
|
if (y >= scanlineActiveDisplay && y < scanlineBottomBorder)
|
|
{
|
|
int activeDisplayY = (y - scanlineActiveDisplay);
|
|
|
|
/* If last sprite in buffer is valid, sprite overflow occured */
|
|
int lastSpriteInBuffer = spriteBuffer[activeDisplayY][NumSpritesPerLineMode4 - 1].Number;
|
|
if (lastSpriteInBuffer != -1)
|
|
{
|
|
isSpriteOverflow = true;
|
|
|
|
/* Store sprite number in status register */
|
|
/* NOTE: the last illegal sprite is *technically* only stored here in TMS99xxA modes, but still emulating it in Mode 4 should be fine */
|
|
WriteSpriteNumberToStatus(lastSpriteInBuffer);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
protected override void ParseSpriteTable(int y)
|
|
{
|
|
if (!isBitM4Set)
|
|
{
|
|
/* Not in Master System video mode */
|
|
base.ParseSpriteTable(y);
|
|
}
|
|
else
|
|
{
|
|
if (y < scanlineActiveDisplay || y >= scanlineBottomBorder) return;
|
|
|
|
/* Determine coordinates in active display */
|
|
int activeDisplayY = (y - scanlineActiveDisplay);
|
|
|
|
/* Clear sprite list for current line */
|
|
for (int i = 0; i < spriteBuffer[activeDisplayY].Length; i++) spriteBuffer[activeDisplayY][i] = (-1, 0, 0, 0, 0);
|
|
|
|
/* Determine sprite size & get zoomed sprites adjustment */
|
|
int zoomShift = (isZoomedSprites ? 1 : 0);
|
|
int spriteHeight = ((isLargeSprites ? 16 : 8) << zoomShift);
|
|
|
|
int numValidSprites = 0;
|
|
for (int sprite = 0; sprite < NumSpritesMode4; sprite++)
|
|
{
|
|
int yCoordinate = ReadVram((ushort)(spriteAttribTableBaseAddress + sprite));
|
|
|
|
/* Ignore following if Y coord is 208 in 192-line mode */
|
|
if (yCoordinate == 208 && screenHeight == NumActiveScanlinesLow)
|
|
{
|
|
/* Store first "illegal sprite" number in status register */
|
|
WriteSpriteNumberToStatus(sprite);
|
|
return;
|
|
}
|
|
|
|
/* Modify Y coord as needed */
|
|
yCoordinate++;
|
|
if (yCoordinate > screenHeight + 32) yCoordinate -= 256;
|
|
|
|
/* Ignore this sprite if on incorrect lines */
|
|
if (activeDisplayY < yCoordinate || activeDisplayY >= (yCoordinate + spriteHeight)) continue;
|
|
|
|
/* Check if maximum number of sprites per line is reached */
|
|
numValidSprites++;
|
|
if (numValidSprites > NumSpritesPerLineMode4) return;
|
|
|
|
/* Mark sprite for rendering */
|
|
int xCoordinate = ReadVram((ushort)(spriteAttribTableBaseAddress + 0x80 + (sprite * 2)));
|
|
int patternNumber = ReadVram((ushort)(spriteAttribTableBaseAddress + 0x80 + (sprite * 2) + 1));
|
|
int unusedData = ReadVram((ushort)(spriteAttribTableBaseAddress + 0x40 + (sprite * 2)));
|
|
|
|
spriteBuffer[activeDisplayY][numValidSprites - 1] = (sprite, yCoordinate, xCoordinate, patternNumber, unusedData);
|
|
}
|
|
|
|
/* Because we didn't bow out before already, store total number of sprites in status register */
|
|
WriteSpriteNumberToStatus(NumSprites - 1);
|
|
}
|
|
}
|
|
|
|
private void RenderLineMode4Sprites(int y)
|
|
{
|
|
if (y < scanlineActiveDisplay || y >= scanlineBottomBorder) return;
|
|
|
|
/* Determine coordinates in active display */
|
|
int activeDisplayY = (y - scanlineActiveDisplay);
|
|
|
|
/* Determine sprite size & get zoomed sprites adjustment */
|
|
int zoomShift = (isZoomedSprites ? 1 : 0);
|
|
int spriteHeight = ((isLargeSprites ? 16 : 8) << zoomShift);
|
|
|
|
for (int s = 0; s < spriteBuffer[activeDisplayY].Length; s++)
|
|
{
|
|
var sprite = spriteBuffer[activeDisplayY][s];
|
|
|
|
if (sprite.Number == -1) continue;
|
|
|
|
/* VDPDIFF: Mk3/SMS1 VDP zoomed sprites bug, only first four sprites (same as max sprites/line on TMS99xxA) can be zoomed horizontally
|
|
* Zoom works normally on SMS2/GG */
|
|
int spriteWidth = (8 << zoomShift);
|
|
if (vdpType == VDPTypes.Mk3SMS1 && s >= NumSpritesPerLine) spriteWidth = 8;
|
|
|
|
if (!isDisplayBlanked)
|
|
{
|
|
int yCoordinate = sprite.Y;
|
|
int xCoordinate = sprite.X;
|
|
int patternNumber = sprite.Pattern;
|
|
int unusedData = sprite.Attribute;
|
|
|
|
if (isSpriteShiftLeft8) xCoordinate -= 8;
|
|
|
|
for (int pixel = 0; pixel < spriteWidth; pixel++)
|
|
{
|
|
/* Ignore pixel if column 0 masking is enabled and sprite pixel is in column 0 */
|
|
if (isColumn0MaskEnabled && (xCoordinate + pixel) < 8) continue;
|
|
|
|
/* Check if sprite is outside active display, else continue to next sprite */
|
|
if ((xCoordinate + pixel) < 0 || (xCoordinate + pixel) >= NumActivePixelsPerScanline) continue;
|
|
|
|
/* Determine coordinate inside sprite */
|
|
int inSpriteXCoord = (pixel >> zoomShift) % spriteWidth;
|
|
int inSpriteYCoord = ((activeDisplayY - yCoordinate) >> zoomShift) % spriteHeight;
|
|
|
|
/* Calculate address and fetch pixel data */
|
|
int tileIndex = patternNumber;
|
|
if (isLargeSprites) tileIndex &= ~0x01;
|
|
ushort tileAddress = (ushort)(spritePatternGenBaseAddress + (tileIndex << 5) + (inSpriteYCoord << 2));
|
|
|
|
/* Get color & check transparency and position */
|
|
int c = (((ReadVram((ushort)(tileAddress + 0)) >> (7 - inSpriteXCoord)) & 0x1) << 0);
|
|
c |= (((ReadVram((ushort)(tileAddress + 1)) >> (7 - inSpriteXCoord)) & 0x1) << 1);
|
|
c |= (((ReadVram((ushort)(tileAddress + 2)) >> (7 - inSpriteXCoord)) & 0x1) << 2);
|
|
c |= (((ReadVram((ushort)(tileAddress + 3)) >> (7 - inSpriteXCoord)) & 0x1) << 3);
|
|
|
|
if (c == 0) continue;
|
|
|
|
int x = pixelActiveDisplay + (xCoordinate + pixel);
|
|
if (IsScreenUsageFlagSet(y, x, screenUsageSprite))
|
|
{
|
|
/* If sprite was already at this location, set sprite collision flag */
|
|
isSpriteCollision = true;
|
|
}
|
|
else if (!IsScreenUsageFlagSet(y, x, screenUsageBgHighPriority))
|
|
{
|
|
/* Draw if pixel isn't occupied by high-priority BG */
|
|
SetPixel(y, x, 1, c);
|
|
}
|
|
|
|
/* Note that there is a sprite here regardless */
|
|
|
|
/* VDPDIFF: Mk3 / SMS1 VDP zoomed sprites bug, horizontally zoomed area of sprite (i.e. pixels 9-16) is ignored by collision; do not mark location as containing a sprite
|
|
* https://www.smspower.org/forums/post109677#109677
|
|
* TODO: verify behavior somehow?
|
|
*/
|
|
if ((vdpType == VDPTypes.Mk3SMS1 && isZoomedSprites && pixel < 8) || (vdpType == VDPTypes.Mk3SMS1 && !isZoomedSprites) || vdpType == VDPTypes.SMS2GG)
|
|
SetScreenUsageFlag(y, x, screenUsageSprite);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
protected void UpdateResolution()
|
|
{
|
|
/* Check screenmode */
|
|
if (isSMS240LineMode)
|
|
{
|
|
screenHeight = NumActiveScanlinesHigh;
|
|
nametableHeight = 256;
|
|
vCounterTableIndex = (isPalChip ? 5 : 2);
|
|
}
|
|
else if (isSMS224LineMode)
|
|
{
|
|
screenHeight = NumActiveScanlinesMed;
|
|
nametableHeight = 256;
|
|
vCounterTableIndex = (isPalChip ? 4 : 1);
|
|
}
|
|
else
|
|
{
|
|
screenHeight = NumActiveScanlinesLow;
|
|
nametableHeight = 224;
|
|
vCounterTableIndex = (isPalChip ? 3 : 0);
|
|
}
|
|
|
|
/* Scanline parameters */
|
|
if (!isPalChip)
|
|
{
|
|
/* NTSC */
|
|
if (screenHeight == NumActiveScanlinesHigh)
|
|
{
|
|
/* 240 active lines, invalid on NTSC (dummy values); "Line Interrupt Test #1" mode 1 will show blue screen */
|
|
topBorderSize = 0;
|
|
verticalActiveDisplaySize = 0;
|
|
bottomBorderSize = 0;
|
|
}
|
|
else if (screenHeight == NumActiveScanlinesMed)
|
|
{
|
|
/* 224 active lines */
|
|
topBorderSize = 11;
|
|
verticalActiveDisplaySize = 224;
|
|
bottomBorderSize = 8;
|
|
}
|
|
else
|
|
{
|
|
/* 192 active lines */
|
|
topBorderSize = 27;
|
|
verticalActiveDisplaySize = 192;
|
|
bottomBorderSize = 24;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
/* PAL */
|
|
if (screenHeight == NumActiveScanlinesHigh)
|
|
{
|
|
/* 240 active lines */
|
|
topBorderSize = 30;
|
|
verticalActiveDisplaySize = 240;
|
|
bottomBorderSize = 24;
|
|
}
|
|
else if (screenHeight == NumActiveScanlinesMed)
|
|
{
|
|
/* 224 active lines */
|
|
topBorderSize = 38;
|
|
verticalActiveDisplaySize = 224;
|
|
bottomBorderSize = 32;
|
|
}
|
|
else
|
|
{
|
|
/* 192 active lines */
|
|
topBorderSize = 54;
|
|
verticalActiveDisplaySize = 192;
|
|
bottomBorderSize = 48;
|
|
}
|
|
}
|
|
|
|
scanlineTopBorder = 0;
|
|
scanlineActiveDisplay = (scanlineTopBorder + topBorderSize);
|
|
scanlineBottomBorder = (scanlineActiveDisplay + verticalActiveDisplaySize);
|
|
|
|
numVisibleScanlines = (topBorderSize + verticalActiveDisplaySize + bottomBorderSize);
|
|
|
|
/* Pixel parameters */
|
|
leftBorderSize = 13;
|
|
horizontalActiveDisplaySize = 256;
|
|
rightBorderSize = 15;
|
|
|
|
pixelLeftBorder = 0;
|
|
pixelActiveDisplay = (pixelLeftBorder + leftBorderSize);
|
|
pixelRightBorder = (pixelActiveDisplay + horizontalActiveDisplaySize);
|
|
|
|
numVisiblePixels = (leftBorderSize + horizontalActiveDisplaySize + rightBorderSize);
|
|
}
|
|
|
|
protected virtual void WriteColorToFramebuffer(int palette, int color, int address)
|
|
{
|
|
WriteColorToFramebuffer(cram[((palette * 16) + color)], address);
|
|
}
|
|
|
|
protected override void WriteColorToFramebuffer(ushort colorValue, int address)
|
|
{
|
|
/* If not in Master System video mode, color value is index into legacy colormap */
|
|
if (!isBitM4Set)
|
|
colorValue = (legacyColorMap[colorValue & 0x000F]);
|
|
|
|
RGB222toBGRA8888(colorValue, ref outputFramebuffer, address);
|
|
}
|
|
|
|
protected override void WriteDataPort(byte value)
|
|
{
|
|
isSecondControlWrite = false;
|
|
|
|
readBuffer = value;
|
|
|
|
switch (codeRegister)
|
|
{
|
|
case 0x00:
|
|
case 0x01:
|
|
case 0x02:
|
|
WriteVram(addressRegister, value);
|
|
break;
|
|
case 0x03:
|
|
cram[(addressRegister & 0x001F)] = value;
|
|
break;
|
|
}
|
|
|
|
addressRegister++;
|
|
}
|
|
|
|
protected override byte ReadControlPort()
|
|
{
|
|
byte statusCurrent = (byte)statusFlags;
|
|
|
|
statusFlags = StatusFlags.None;
|
|
isSecondControlWrite = false;
|
|
|
|
isLineInterruptPending = false;
|
|
|
|
InterruptLine = InterruptState.Clear;
|
|
|
|
return statusCurrent;
|
|
}
|
|
|
|
public override byte ReadPort(byte port)
|
|
{
|
|
if ((port & 0x40) == 0x40)
|
|
if ((port & 0x01) == 0)
|
|
return (byte)vCounter; /* V counter */
|
|
else
|
|
return (byte)hCounter; /* H counter */
|
|
else
|
|
return base.ReadPort(port);
|
|
}
|
|
|
|
protected override void WriteRegister(byte register, byte value)
|
|
{
|
|
if (register < registers.Length)
|
|
registers[register] = value;
|
|
|
|
if (register == 0x00 || register == 0x01)
|
|
UpdateResolution();
|
|
}
|
|
}
|
|
}
|