882 lines
29 KiB
C#
882 lines
29 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
|
|||
|
|
{
|
|||
|
|
/* Texas Instruments TMS99xxA family */
|
|||
|
|
public class TMS99xxA : IVideo
|
|||
|
|
{
|
|||
|
|
public const int NumTotalScanlinesPal = 313;
|
|||
|
|
public const int NumTotalScanlinesNtsc = 262;
|
|||
|
|
|
|||
|
|
public const int NumActiveScanlines = 192;
|
|||
|
|
public const int NumActivePixelsPerScanline = 256;
|
|||
|
|
|
|||
|
|
protected const string layerBackgroundOptionName = "GraphicsLayersShowBackground";
|
|||
|
|
protected const string layerSpritesOptionName = "GraphicsLayersShowSprites";
|
|||
|
|
protected const string layerBordersOptionName = "GraphicsLayersShowBorders";
|
|||
|
|
|
|||
|
|
protected readonly int numTotalPixelsPerScanline = 342;
|
|||
|
|
protected virtual int numTotalScanlines => (isPalChip ? NumTotalScanlinesPal : NumTotalScanlinesNtsc);
|
|||
|
|
|
|||
|
|
protected int topBorderSize, verticalActiveDisplaySize, bottomBorderSize;
|
|||
|
|
protected int scanlineTopBorder, scanlineActiveDisplay, scanlineBottomBorder;
|
|||
|
|
protected int numVisibleScanlines;
|
|||
|
|
|
|||
|
|
protected int leftBorderSize, horizontalActiveDisplaySize, rightBorderSize;
|
|||
|
|
protected int pixelLeftBorder, pixelActiveDisplay, pixelRightBorder;
|
|||
|
|
protected int numVisiblePixels;
|
|||
|
|
|
|||
|
|
public virtual (int X, int Y, int Width, int Height) Viewport => (0, 0, numVisiblePixels, numVisibleScanlines);
|
|||
|
|
|
|||
|
|
public virtual event EventHandler<SizeScreenEventArgs> SizeScreen;
|
|||
|
|
public virtual void OnSizeScreen(SizeScreenEventArgs e) { SizeScreen?.Invoke(this, e); }
|
|||
|
|
|
|||
|
|
public virtual event EventHandler<RenderScreenEventArgs> RenderScreen;
|
|||
|
|
public virtual void OnRenderScreen(RenderScreenEventArgs e) { RenderScreen?.Invoke(this, e); }
|
|||
|
|
|
|||
|
|
public virtual event EventHandler<EventArgs> EndOfScanline;
|
|||
|
|
public virtual void OnEndOfScanline(EventArgs e) { EndOfScanline?.Invoke(this, e); }
|
|||
|
|
|
|||
|
|
protected const int NumSprites = 32;
|
|||
|
|
protected const int NumSpritesPerLine = 4;
|
|||
|
|
|
|||
|
|
protected double clockRate, refreshRate;
|
|||
|
|
protected bool isPalChip;
|
|||
|
|
|
|||
|
|
[StateRequired]
|
|||
|
|
protected byte[] registers, vram;
|
|||
|
|
[StateRequired]
|
|||
|
|
protected (int Number, int Y, int X, int Pattern, int Attribute)[][] spriteBuffer;
|
|||
|
|
|
|||
|
|
protected ushort vramMask16k => 0x3FFF;
|
|||
|
|
protected ushort vramMask4k => 0x0FFF;
|
|||
|
|
|
|||
|
|
[StateRequired]
|
|||
|
|
protected bool isSecondControlWrite;
|
|||
|
|
[StateRequired]
|
|||
|
|
protected ushort controlWord;
|
|||
|
|
[StateRequired]
|
|||
|
|
protected byte readBuffer;
|
|||
|
|
|
|||
|
|
protected byte codeRegister => (byte)((controlWord >> 14) & 0x03);
|
|||
|
|
protected ushort addressRegister
|
|||
|
|
{
|
|||
|
|
get { return (ushort)(controlWord & 0x3FFF); }
|
|||
|
|
set { controlWord = (ushort)((controlWord & 0xC000) | (value & 0x3FFF)); }
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
[Flags]
|
|||
|
|
protected enum StatusFlags : byte
|
|||
|
|
{
|
|||
|
|
None = 0,
|
|||
|
|
SpriteCollision = (1 << 5),
|
|||
|
|
SpriteOverflow = (1 << 6),
|
|||
|
|
FrameInterruptPending = (1 << 7)
|
|||
|
|
}
|
|||
|
|
[StateRequired]
|
|||
|
|
protected StatusFlags statusFlags;
|
|||
|
|
protected bool isSpriteCollision
|
|||
|
|
{
|
|||
|
|
get { return ((statusFlags & StatusFlags.SpriteCollision) == StatusFlags.SpriteCollision); }
|
|||
|
|
set { statusFlags = ((statusFlags & ~StatusFlags.SpriteCollision) | (value ? StatusFlags.SpriteCollision : StatusFlags.None)); }
|
|||
|
|
}
|
|||
|
|
protected bool isSpriteOverflow
|
|||
|
|
{
|
|||
|
|
get { return ((statusFlags & StatusFlags.SpriteOverflow) == StatusFlags.SpriteOverflow); }
|
|||
|
|
set { statusFlags = ((statusFlags & ~StatusFlags.SpriteOverflow) | (value ? StatusFlags.SpriteOverflow : StatusFlags.None)); }
|
|||
|
|
}
|
|||
|
|
protected bool isFrameInterruptPending
|
|||
|
|
{
|
|||
|
|
get { return ((statusFlags & StatusFlags.FrameInterruptPending) == StatusFlags.FrameInterruptPending); }
|
|||
|
|
set { statusFlags = ((statusFlags & ~StatusFlags.FrameInterruptPending) | (value ? StatusFlags.FrameInterruptPending : StatusFlags.None)); }
|
|||
|
|
}
|
|||
|
|
protected bool isFrameInterruptEnabled => IsBitSet(registers[0x01], 5);
|
|||
|
|
|
|||
|
|
[StateRequired]
|
|||
|
|
public InterruptState InterruptLine { get; set; }
|
|||
|
|
|
|||
|
|
[StateRequired]
|
|||
|
|
protected int currentScanline;
|
|||
|
|
|
|||
|
|
protected bool isDisplayBlanked => !IsBitSet(registers[0x01], 6);
|
|||
|
|
|
|||
|
|
protected bool is16kVRAMEnabled => IsBitSet(registers[0x01], 7);
|
|||
|
|
|
|||
|
|
protected bool isBitM1Set => IsBitSet(registers[0x01], 4);
|
|||
|
|
protected bool isBitM2Set => IsBitSet(registers[0x00], 1);
|
|||
|
|
protected bool isBitM3Set => IsBitSet(registers[0x01], 3);
|
|||
|
|
|
|||
|
|
protected virtual bool isModeGraphics1 => !(isBitM1Set || isBitM2Set || isBitM3Set);
|
|||
|
|
protected virtual bool isModeText => (isBitM1Set && !(isBitM2Set || isBitM3Set));
|
|||
|
|
protected virtual bool isModeGraphics2 => (isBitM2Set && !(isBitM1Set || isBitM3Set));
|
|||
|
|
protected virtual bool isModeMulticolor => (isBitM3Set && !(isBitM1Set || isBitM2Set));
|
|||
|
|
|
|||
|
|
protected bool isLargeSprites => IsBitSet(registers[0x01], 1);
|
|||
|
|
protected bool isZoomedSprites => IsBitSet(registers[0x01], 0);
|
|||
|
|
|
|||
|
|
protected virtual ushort nametableBaseAddress => (ushort)((registers[0x02] & 0x0F) << 10);
|
|||
|
|
protected virtual ushort spriteAttribTableBaseAddress => (ushort)((registers[0x05] & 0x7F) << 7);
|
|||
|
|
protected virtual ushort spritePatternGenBaseAddress => (ushort)((registers[0x06] & 0x07) << 11);
|
|||
|
|
|
|||
|
|
protected byte backgroundColor => (byte)(registers[0x07] & 0x0F);
|
|||
|
|
protected byte textColor => (byte)((registers[0x07] >> 4) & 0x0F);
|
|||
|
|
|
|||
|
|
/* http://www.smspower.org/Development/Palette */
|
|||
|
|
readonly byte[][] colorValuesBgr = new byte[][]
|
|||
|
|
{
|
|||
|
|
/* B G R */
|
|||
|
|
new byte[] { 0x00, 0x00, 0x00 }, /* Transparent */
|
|||
|
|
new byte[] { 0x00, 0x00, 0x00 }, /* Black */
|
|||
|
|
new byte[] { 0x3B, 0xB7, 0x47 }, /* Medium green */
|
|||
|
|
new byte[] { 0x6F, 0xCF, 0x7C }, /* Light green */
|
|||
|
|
new byte[] { 0xFF, 0x4E, 0x5D }, /* Dark blue */
|
|||
|
|
new byte[] { 0xFF, 0x72, 0x80 }, /* Light blue */
|
|||
|
|
new byte[] { 0x47, 0x62, 0xB6 }, /* Dark red */
|
|||
|
|
new byte[] { 0xED, 0xC8, 0x5D }, /* Cyan */
|
|||
|
|
new byte[] { 0x48, 0x6B, 0xD7 }, /* Medium red */
|
|||
|
|
new byte[] { 0x6C, 0x8F, 0xFB }, /* Light red */
|
|||
|
|
new byte[] { 0x41, 0xCD, 0xC3 }, /* Dark yellow */
|
|||
|
|
new byte[] { 0x76, 0xDA, 0xD3 }, /* Light yellow */
|
|||
|
|
new byte[] { 0x2F, 0x9F, 0x3E }, /* Dark green */
|
|||
|
|
new byte[] { 0xC7, 0x64, 0xB6 }, /* Magenta */
|
|||
|
|
new byte[] { 0xCC, 0xCC, 0xCC }, /* Gray */
|
|||
|
|
new byte[] { 0xFF, 0xFF, 0xFF } /* White */
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
protected const byte screenUsageEmpty = 0;
|
|||
|
|
protected const byte screenUsageSprite = (1 << 0);
|
|||
|
|
protected const byte screenUsageBackground = (1 << 1);
|
|||
|
|
[StateRequired]
|
|||
|
|
protected byte[] screenUsage;
|
|||
|
|
|
|||
|
|
[StateRequired]
|
|||
|
|
protected int cycleCount;
|
|||
|
|
protected byte[] outputFramebuffer;
|
|||
|
|
|
|||
|
|
protected int clockCyclesPerLine;
|
|||
|
|
|
|||
|
|
public (string Name, string Description)[] RuntimeOptions => new (string name, string description)[]
|
|||
|
|
{
|
|||
|
|
(layerBackgroundOptionName, "Background"),
|
|||
|
|
(layerSpritesOptionName, "Sprites"),
|
|||
|
|
(layerBordersOptionName, "Borders"),
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
protected bool layerBackgroundForceEnable, layerSpritesForceEnable, layerBordersForceEnable;
|
|||
|
|
|
|||
|
|
public TMS99xxA()
|
|||
|
|
{
|
|||
|
|
registers = new byte[0x08];
|
|||
|
|
vram = new byte[0x4000];
|
|||
|
|
|
|||
|
|
spriteBuffer = new (int Number, int Y, int X, int Pattern, int Attribute)[NumActiveScanlines][];
|
|||
|
|
for (int i = 0; i < spriteBuffer.Length; i++) spriteBuffer[i] = new (int Number, int Y, int X, int Pattern, int Attribute)[NumSpritesPerLine];
|
|||
|
|
|
|||
|
|
layerBackgroundForceEnable = true;
|
|||
|
|
layerSpritesForceEnable = true;
|
|||
|
|
layerBordersForceEnable = true;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
public object GetRuntimeOption(string name)
|
|||
|
|
{
|
|||
|
|
switch (name)
|
|||
|
|
{
|
|||
|
|
case layerBackgroundOptionName: return layerBackgroundForceEnable;
|
|||
|
|
case layerSpritesOptionName: return layerSpritesForceEnable;
|
|||
|
|
case layerBordersOptionName: return layerBordersForceEnable;
|
|||
|
|
default: return null;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
public void SetRuntimeOption(string name, object value)
|
|||
|
|
{
|
|||
|
|
switch (name)
|
|||
|
|
{
|
|||
|
|
case layerBackgroundOptionName: layerBackgroundForceEnable = (bool)value; break;
|
|||
|
|
case layerSpritesOptionName: layerSpritesForceEnable = (bool)value; break;
|
|||
|
|
case layerBordersOptionName: layerBordersForceEnable = (bool)value; break;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
public virtual void Startup()
|
|||
|
|
{
|
|||
|
|
Reset();
|
|||
|
|
|
|||
|
|
Debug.Assert(clockRate != 0.0, "Clock rate is zero", "{0} clock rate is not configured", GetType().FullName);
|
|||
|
|
Debug.Assert(refreshRate != 0.0, "Refresh rate is zero", "{0} refresh rate is not configured", GetType().FullName);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
public virtual void Shutdown()
|
|||
|
|
{
|
|||
|
|
//
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
public virtual void Reset()
|
|||
|
|
{
|
|||
|
|
for (int i = 0; i < registers.Length; i++) registers[i] = 0;
|
|||
|
|
for (int i = 0; i < vram.Length; i++) vram[i] = 0;
|
|||
|
|
|
|||
|
|
for (int i = 0; i < spriteBuffer.Length; i++)
|
|||
|
|
for (int j = 0; j < spriteBuffer[i].Length; j++)
|
|||
|
|
spriteBuffer[i][j] = (-1, 0, 0, 0, 0);
|
|||
|
|
|
|||
|
|
isSecondControlWrite = false;
|
|||
|
|
controlWord = 0x0000;
|
|||
|
|
readBuffer = 0;
|
|||
|
|
|
|||
|
|
statusFlags = StatusFlags.None;
|
|||
|
|
|
|||
|
|
// TODO/FIXME: begin on random scanline (i.e. Vcounter for SMS/GG) on reset, http://www.smspower.org/forums/post62735#62735
|
|||
|
|
currentScanline = new Random().Next(scanlineTopBorder, numVisibleScanlines);
|
|||
|
|
|
|||
|
|
ClearScreenUsage();
|
|||
|
|
|
|||
|
|
cycleCount = 0;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
public void SetClockRate(double clock)
|
|||
|
|
{
|
|||
|
|
clockRate = clock;
|
|||
|
|
|
|||
|
|
ReconfigureTimings();
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
public void SetRefreshRate(double refresh)
|
|||
|
|
{
|
|||
|
|
refreshRate = refresh;
|
|||
|
|
isPalChip = (refreshRate <= 50.0);
|
|||
|
|
|
|||
|
|
ReconfigureTimings();
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
public virtual void SetRevision(int rev)
|
|||
|
|
{
|
|||
|
|
Debug.Assert(rev == 0, "Invalid revision", "{0} revision is invalid; only rev 0 is valid", GetType().FullName);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
protected virtual 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];
|
|||
|
|
|
|||
|
|
/* Scanline parameters */
|
|||
|
|
if (!isPalChip)
|
|||
|
|
{
|
|||
|
|
topBorderSize = 27;
|
|||
|
|
verticalActiveDisplaySize = 192;
|
|||
|
|
bottomBorderSize = 24;
|
|||
|
|
}
|
|||
|
|
else
|
|||
|
|
{
|
|||
|
|
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);
|
|||
|
|
|
|||
|
|
OnSizeScreen(new SizeScreenEventArgs(numVisiblePixels, numVisibleScanlines));
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
public virtual void Step(int clockCyclesInStep)
|
|||
|
|
{
|
|||
|
|
InterruptLine = ((isFrameInterruptEnabled && isFrameInterruptPending) ? InterruptState.Assert : InterruptState.Clear);
|
|||
|
|
|
|||
|
|
cycleCount += clockCyclesInStep;
|
|||
|
|
|
|||
|
|
if (cycleCount >= clockCyclesPerLine)
|
|||
|
|
{
|
|||
|
|
OnEndOfScanline(EventArgs.Empty);
|
|||
|
|
|
|||
|
|
CheckSpriteOverflow(currentScanline);
|
|||
|
|
|
|||
|
|
RenderLine(currentScanline);
|
|||
|
|
|
|||
|
|
if (currentScanline == (scanlineBottomBorder + 1))
|
|||
|
|
isFrameInterruptPending = true;
|
|||
|
|
|
|||
|
|
currentScanline++;
|
|||
|
|
if (currentScanline == numTotalScanlines)
|
|||
|
|
{
|
|||
|
|
currentScanline = 0;
|
|||
|
|
ClearScreenUsage();
|
|||
|
|
|
|||
|
|
PrepareRenderScreen();
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
ParseSpriteTable(currentScanline);
|
|||
|
|
|
|||
|
|
cycleCount -= clockCyclesPerLine;
|
|||
|
|
if (cycleCount <= -clockCyclesPerLine) cycleCount = 0;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
protected virtual void PrepareRenderScreen()
|
|||
|
|
{
|
|||
|
|
OnRenderScreen(new RenderScreenEventArgs(numVisiblePixels, numVisibleScanlines, outputFramebuffer.Clone() as byte[]));
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
protected virtual void ClearScreenUsage()
|
|||
|
|
{
|
|||
|
|
for (int i = 0; i < screenUsage.Length; i++)
|
|||
|
|
screenUsage[i] = screenUsageEmpty;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
protected virtual void RenderLine(int y)
|
|||
|
|
{
|
|||
|
|
if (y >= scanlineTopBorder && y < scanlineActiveDisplay)
|
|||
|
|
{
|
|||
|
|
if (layerBordersForceEnable) SetLine(y, backgroundColor);
|
|||
|
|
else SetLine(y, 0x00, 0x00, 0x00);
|
|||
|
|
}
|
|||
|
|
else if (y >= scanlineActiveDisplay && y < scanlineBottomBorder)
|
|||
|
|
{
|
|||
|
|
if (layerBackgroundForceEnable)
|
|||
|
|
{
|
|||
|
|
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 (!isModeText)
|
|||
|
|
RenderLineSprites(y);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
RenderBorders(y);
|
|||
|
|
}
|
|||
|
|
else if (y >= scanlineBottomBorder && y < numVisibleScanlines)
|
|||
|
|
{
|
|||
|
|
if (layerBordersForceEnable) SetLine(y, backgroundColor);
|
|||
|
|
else SetLine(y, 0x00, 0x00, 0x00);
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
protected virtual void RenderBorders(int y)
|
|||
|
|
{
|
|||
|
|
for (int x = pixelLeftBorder; x < pixelActiveDisplay; x++)
|
|||
|
|
{
|
|||
|
|
if (layerBordersForceEnable) SetPixel(y, x, backgroundColor);
|
|||
|
|
else SetPixel(y, x, 0x00, 0x00, 0x00);
|
|||
|
|
}
|
|||
|
|
for (int x = pixelRightBorder; x < numVisiblePixels; x++)
|
|||
|
|
{
|
|||
|
|
if (layerBordersForceEnable) SetPixel(y, x, backgroundColor);
|
|||
|
|
else SetPixel(y, x, 0x00, 0x00, 0x00);
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
protected void SetLine(int y, ushort colorValue)
|
|||
|
|
{
|
|||
|
|
for (int x = 0; x < numVisiblePixels; x++)
|
|||
|
|
SetPixel(y, x, colorValue);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
protected virtual void SetLine(int y, byte b, byte g, byte r)
|
|||
|
|
{
|
|||
|
|
for (int x = 0; x < numVisiblePixels; x++)
|
|||
|
|
SetPixel(y, x, b, g, r);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
protected void SetPixel(int y, int x, ushort colorValue)
|
|||
|
|
{
|
|||
|
|
WriteColorToFramebuffer(colorValue, ((y * numVisiblePixels) + (x % numVisiblePixels)) * 4);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
protected virtual void SetPixel(int y, int x, byte b, byte g, byte r)
|
|||
|
|
{
|
|||
|
|
WriteColorToFramebuffer(b, g, r, ((y * numVisiblePixels) + (x % numVisiblePixels)) * 4);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
protected byte GetScreenUsageFlag(int y, int x)
|
|||
|
|
{
|
|||
|
|
return screenUsage[(y * numVisiblePixels) + (x % numVisiblePixels)];
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
protected bool IsScreenUsageFlagSet(int y, int x, byte flag)
|
|||
|
|
{
|
|||
|
|
return ((GetScreenUsageFlag(y, x) & flag) == flag);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
protected void SetScreenUsageFlag(int y, int x, byte flag)
|
|||
|
|
{
|
|||
|
|
screenUsage[(y * numVisiblePixels) + (x % numVisiblePixels)] |= flag;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
protected void ClearScreenUsageFlag(int y, int x, byte flag)
|
|||
|
|
{
|
|||
|
|
screenUsage[(y * numVisiblePixels) + (x % numVisiblePixels)] &= (byte)~flag;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
protected void RenderLineGraphics1Background(int y)
|
|||
|
|
{
|
|||
|
|
/* Determine coordinates in active display */
|
|||
|
|
int activeDisplayY = (y - scanlineActiveDisplay);
|
|||
|
|
|
|||
|
|
int numColumns = 32;
|
|||
|
|
ushort patternGeneratorBaseAddress = (ushort)((registers[0x04] & 0x07) << 11);
|
|||
|
|
ushort colorTableBaseAddress = (ushort)(registers[0x03] << 6);
|
|||
|
|
|
|||
|
|
for (int column = 0; column < numColumns; column++)
|
|||
|
|
{
|
|||
|
|
/* Calculate nametable address, fetch character number */
|
|||
|
|
ushort nametableAddress = (ushort)(nametableBaseAddress + ((activeDisplayY / 8) * numColumns) + column);
|
|||
|
|
byte characterNumber = ReadVram(nametableAddress);
|
|||
|
|
|
|||
|
|
/* Fetch pixel and color data for current pixel line (1 byte, 8 pixels) */
|
|||
|
|
byte pixelLineData = ReadVram((ushort)(patternGeneratorBaseAddress + (characterNumber * 8) + (activeDisplayY % 8)));
|
|||
|
|
byte pixelLineColor = ReadVram((ushort)(colorTableBaseAddress + (characterNumber / 8)));
|
|||
|
|
|
|||
|
|
/* Extract background and foreground color indices */
|
|||
|
|
byte[] colorIndicesBackgroundForeground = new byte[2];
|
|||
|
|
colorIndicesBackgroundForeground[0] = (byte)(pixelLineColor & 0x0F);
|
|||
|
|
colorIndicesBackgroundForeground[1] = (byte)(pixelLineColor >> 4);
|
|||
|
|
|
|||
|
|
for (int pixel = 0; pixel < 8; pixel++)
|
|||
|
|
{
|
|||
|
|
/* Fetch color index for current pixel (bit clear means background, bit set means foreground color) */
|
|||
|
|
byte c = colorIndicesBackgroundForeground[((pixelLineData >> (7 - pixel)) & 0x01)];
|
|||
|
|
/* Color index 0 is transparent, use background color */
|
|||
|
|
if (c == 0 || isDisplayBlanked) c = backgroundColor;
|
|||
|
|
|
|||
|
|
/* Record screen usage, write to framebuffer */
|
|||
|
|
int x = pixelActiveDisplay + (column * 8) + pixel;
|
|||
|
|
if (GetScreenUsageFlag(y, x) == screenUsageEmpty)
|
|||
|
|
{
|
|||
|
|
SetPixel(y, x, c);
|
|||
|
|
SetScreenUsageFlag(y, x, screenUsageBackground);
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
protected void RenderLineGraphics2Background(int y)
|
|||
|
|
{
|
|||
|
|
/* Determine coordinates in active display */
|
|||
|
|
int activeDisplayY = (y - scanlineActiveDisplay);
|
|||
|
|
|
|||
|
|
int numColumns = (NumActivePixelsPerScanline / 8);
|
|||
|
|
|
|||
|
|
/* Calculate some base addresses */
|
|||
|
|
ushort patternGeneratorBaseAddress = (ushort)((registers[0x04] & 0x04) << 11);
|
|||
|
|
ushort colorTableBaseAddress = (ushort)((registers[0x03] & 0x80) << 6);
|
|||
|
|
|
|||
|
|
for (int column = 0; column < numColumns; column++)
|
|||
|
|
{
|
|||
|
|
/* Calculate nametable address */
|
|||
|
|
ushort nametableAddress = (ushort)(nametableBaseAddress + ((activeDisplayY / 8) * numColumns) + column);
|
|||
|
|
|
|||
|
|
/* Calculate character number and masks */
|
|||
|
|
ushort characterNumber = (ushort)(((activeDisplayY / 64) << 8) | ReadVram(nametableAddress));
|
|||
|
|
ushort characterNumberDataMask = (ushort)(((registers[0x04] & 0x03) << 8) | 0xFF);
|
|||
|
|
ushort characterNumberColorMask = (ushort)(((registers[0x03] & 0x7F) << 3) | 0x07);
|
|||
|
|
|
|||
|
|
/* Fetch pixel and color data for current pixel line (1 byte, 8 pixels) */
|
|||
|
|
byte pixelLineData = ReadVram((ushort)(patternGeneratorBaseAddress + ((characterNumber & characterNumberDataMask) * 8) + (activeDisplayY % 8)));
|
|||
|
|
byte pixelLineColor = ReadVram((ushort)(colorTableBaseAddress + ((characterNumber & characterNumberColorMask) * 8) + (activeDisplayY % 8)));
|
|||
|
|
|
|||
|
|
/* Extract background and foreground color indices */
|
|||
|
|
byte[] colorIndicesBackgroundForeground = new byte[2];
|
|||
|
|
colorIndicesBackgroundForeground[0] = (byte)(pixelLineColor & 0x0F);
|
|||
|
|
colorIndicesBackgroundForeground[1] = (byte)(pixelLineColor >> 4);
|
|||
|
|
|
|||
|
|
for (int pixel = 0; pixel < 8; pixel++)
|
|||
|
|
{
|
|||
|
|
/* Fetch color index for current pixel (bit clear means background, bit set means foreground color) */
|
|||
|
|
byte c = colorIndicesBackgroundForeground[((pixelLineData >> (7 - pixel)) & 0x01)];
|
|||
|
|
/* Color index 0 is transparent, use background color */
|
|||
|
|
if (c == 0 || isDisplayBlanked) c = backgroundColor;
|
|||
|
|
|
|||
|
|
/* Record screen usage, write to framebuffer */
|
|||
|
|
int x = pixelActiveDisplay + (column * 8) + pixel;
|
|||
|
|
if (GetScreenUsageFlag(y, x) == screenUsageEmpty)
|
|||
|
|
{
|
|||
|
|
SetPixel(y, x, c);
|
|||
|
|
SetScreenUsageFlag(y, x, screenUsageBackground);
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
protected void RenderLineMulticolorBackground(int y)
|
|||
|
|
{
|
|||
|
|
// TODO: check accuracy w/ games besides Smurfs Paint & Play Workshop (if there are any)
|
|||
|
|
|
|||
|
|
/* Determine coordinates in active display */
|
|||
|
|
int activeDisplayY = (y - scanlineActiveDisplay);
|
|||
|
|
|
|||
|
|
int numColumns = 32;
|
|||
|
|
int row = (activeDisplayY / 8);
|
|||
|
|
ushort patternGeneratorBaseAddress = (ushort)((registers[0x04] & 0x07) << 11);
|
|||
|
|
|
|||
|
|
for (int column = 0; column < numColumns; column++)
|
|||
|
|
{
|
|||
|
|
/* Calculate nametable address, fetch character number */
|
|||
|
|
ushort nametableAddress = (ushort)(nametableBaseAddress + (row * numColumns) + column);
|
|||
|
|
byte characterNumber = ReadVram(nametableAddress);
|
|||
|
|
|
|||
|
|
/* Calculate pattern generator address, fetch pattern data */
|
|||
|
|
ushort patternGeneratorAddress = (ushort)(patternGeneratorBaseAddress + (characterNumber * 8) + ((row & 0x03) * 2) + ((activeDisplayY / 4) % 2));
|
|||
|
|
byte patternData = ReadVram(patternGeneratorAddress);
|
|||
|
|
|
|||
|
|
for (int block = 0; block < 8; block += 4)
|
|||
|
|
{
|
|||
|
|
/* Fetch color index for current 4x4 block */
|
|||
|
|
byte c = (byte)((patternData >> (4 - block)) & 0x0F);
|
|||
|
|
|
|||
|
|
/* Color index 0 is transparent, use background color */
|
|||
|
|
if (c == 0 || isDisplayBlanked) c = backgroundColor;
|
|||
|
|
|
|||
|
|
for (int pixel = 0; pixel < 4; pixel++)
|
|||
|
|
{
|
|||
|
|
/* Record screen usage, write to framebuffer */
|
|||
|
|
int x = pixelActiveDisplay + (column * 8) + (block + pixel);
|
|||
|
|
if (GetScreenUsageFlag(y, x) == screenUsageEmpty)
|
|||
|
|
{
|
|||
|
|
SetPixel(y, x, c);
|
|||
|
|
SetScreenUsageFlag(y, x, screenUsageBackground);
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
protected void RenderLineTextBackground(int y)
|
|||
|
|
{
|
|||
|
|
/* Determine coordinates in active display */
|
|||
|
|
int activeDisplayY = (y - scanlineActiveDisplay);
|
|||
|
|
|
|||
|
|
int numColumns = 40;
|
|||
|
|
ushort patternGeneratorBaseAddress = (ushort)((registers[0x04] & 0x07) << 11);
|
|||
|
|
|
|||
|
|
/* Get background and text color indices */
|
|||
|
|
byte[] colorIndicesBackgroundForeground = new byte[2];
|
|||
|
|
colorIndicesBackgroundForeground[0] = backgroundColor;
|
|||
|
|
colorIndicesBackgroundForeground[1] = textColor;
|
|||
|
|
|
|||
|
|
/* Draw left and right 8px borders */
|
|||
|
|
for (int pixel = 0; pixel < 8; pixel++)
|
|||
|
|
{
|
|||
|
|
int x = pixelActiveDisplay + pixel;
|
|||
|
|
SetPixel(y, x + 0, backgroundColor);
|
|||
|
|
SetPixel(y, x + 8 + (numColumns * 6), backgroundColor);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/* Draw text columns */
|
|||
|
|
for (int column = 0; column < numColumns; column++)
|
|||
|
|
{
|
|||
|
|
/* Calculate nametable address, fetch character number */
|
|||
|
|
ushort nametableAddress = (ushort)(nametableBaseAddress + ((activeDisplayY / 8) * numColumns) + column);
|
|||
|
|
byte characterNumber = ReadVram(nametableAddress);
|
|||
|
|
|
|||
|
|
/* Fetch pixel data for current pixel line (1 byte, 8 pixels) */
|
|||
|
|
byte pixelLineData = ReadVram((ushort)(patternGeneratorBaseAddress + (characterNumber * 8) + (activeDisplayY % 8)));
|
|||
|
|
|
|||
|
|
for (int pixel = 0; pixel < 6; pixel++)
|
|||
|
|
{
|
|||
|
|
/* Fetch color index for current pixel (bit clear means background, bit set means text color) */
|
|||
|
|
byte c = (isDisplayBlanked ? backgroundColor : colorIndicesBackgroundForeground[((pixelLineData >> (7 - pixel)) & 0x01)]);
|
|||
|
|
|
|||
|
|
/* Record screen usage, write to framebuffer */
|
|||
|
|
int x = pixelActiveDisplay + 8 + (column * 6) + pixel;
|
|||
|
|
if (GetScreenUsageFlag(y, x) == screenUsageEmpty)
|
|||
|
|
{
|
|||
|
|
SetPixel(y, x, c);
|
|||
|
|
SetScreenUsageFlag(y, x, screenUsageBackground);
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
protected virtual void WriteSpriteNumberToStatus(int spriteNumber)
|
|||
|
|
{
|
|||
|
|
statusFlags &= (StatusFlags.FrameInterruptPending | StatusFlags.SpriteOverflow | StatusFlags.SpriteCollision);
|
|||
|
|
statusFlags |= (StatusFlags)spriteNumber;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
protected virtual void CheckSpriteOverflow(int y)
|
|||
|
|
{
|
|||
|
|
/* 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][NumSpritesPerLine - 1].Number;
|
|||
|
|
if (lastSpriteInBuffer != -1)
|
|||
|
|
{
|
|||
|
|
isSpriteOverflow = true;
|
|||
|
|
|
|||
|
|
/* Store sprite number in status register */
|
|||
|
|
WriteSpriteNumberToStatus(lastSpriteInBuffer);
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
protected virtual void ParseSpriteTable(int y)
|
|||
|
|
{
|
|||
|
|
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 < NumSprites; sprite++)
|
|||
|
|
{
|
|||
|
|
int yCoordinate = ReadVram((ushort)(spriteAttribTableBaseAddress + (sprite * 4)));
|
|||
|
|
|
|||
|
|
/* Ignore following if Y coord is 208 */
|
|||
|
|
if (yCoordinate == 208)
|
|||
|
|
{
|
|||
|
|
/* Store first "illegal sprite" number in status register */
|
|||
|
|
WriteSpriteNumberToStatus(sprite);
|
|||
|
|
return;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/* Modify Y coord as needed */
|
|||
|
|
yCoordinate++;
|
|||
|
|
if (yCoordinate > NumActiveScanlines + 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 > NumSpritesPerLine) return;
|
|||
|
|
|
|||
|
|
/* Mark sprite for rendering */
|
|||
|
|
int xCoordinate = ReadVram((ushort)(spriteAttribTableBaseAddress + (sprite * 4) + 1));
|
|||
|
|
int patternNumber = ReadVram((ushort)(spriteAttribTableBaseAddress + (sprite * 4) + 2));
|
|||
|
|
int attributes = ReadVram((ushort)(spriteAttribTableBaseAddress + (sprite * 4) + 3));
|
|||
|
|
|
|||
|
|
spriteBuffer[activeDisplayY][numValidSprites - 1] = (sprite, yCoordinate, xCoordinate, patternNumber, attributes);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/* Because we didn't bow out before already, store total number of sprites in status register */
|
|||
|
|
WriteSpriteNumberToStatus(NumSprites - 1);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
protected void RenderLineSprites(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 spriteSize = (isLargeSprites ? 16 : 8);
|
|||
|
|
int zoomShift = (isZoomedSprites ? 1 : 0);
|
|||
|
|
int numSpritePixels = (spriteSize << zoomShift);
|
|||
|
|
|
|||
|
|
foreach (var sprite in spriteBuffer[activeDisplayY])
|
|||
|
|
{
|
|||
|
|
if (sprite.Number == -1) continue;
|
|||
|
|
|
|||
|
|
if (!isDisplayBlanked)
|
|||
|
|
{
|
|||
|
|
int yCoordinate = sprite.Y;
|
|||
|
|
int xCoordinate = sprite.X;
|
|||
|
|
int patternNumber = sprite.Pattern;
|
|||
|
|
int attributes = sprite.Attribute;
|
|||
|
|
|
|||
|
|
/* Fetch sprite information, extract attributes */
|
|||
|
|
bool earlyClock = ((attributes & 0x80) == 0x80);
|
|||
|
|
int spriteColor = (attributes & 0x0F);
|
|||
|
|
|
|||
|
|
/* Adjust according to registers/attributes */
|
|||
|
|
if (earlyClock) xCoordinate -= 32;
|
|||
|
|
if (isLargeSprites) patternNumber &= 0xFC;
|
|||
|
|
|
|||
|
|
for (int pixel = 0; pixel < numSpritePixels; pixel++)
|
|||
|
|
{
|
|||
|
|
/* 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) % spriteSize;
|
|||
|
|
int inSpriteYCoord = ((activeDisplayY - yCoordinate) >> zoomShift) % spriteSize;
|
|||
|
|
|
|||
|
|
/* Calculate address and fetch pixel data */
|
|||
|
|
ushort spritePatternAddress = spritePatternGenBaseAddress;
|
|||
|
|
spritePatternAddress += (ushort)(patternNumber << 3);
|
|||
|
|
spritePatternAddress += (ushort)inSpriteYCoord;
|
|||
|
|
if (inSpriteXCoord >= 8) spritePatternAddress += 16;
|
|||
|
|
|
|||
|
|
byte pixelLineData = ReadVram(spritePatternAddress);
|
|||
|
|
|
|||
|
|
/* Check if pixel from pattern needs to be drawn, else continue to next sprite */
|
|||
|
|
if (((pixelLineData >> (7 - (inSpriteXCoord % 8))) & 0x01) == 0x00) 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 color isn't transparent, draw pixel to framebuffer */
|
|||
|
|
if (spriteColor != 0)
|
|||
|
|
SetPixel(y, x, (ushort)spriteColor);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/* Note that there is a sprite here regardless */
|
|||
|
|
SetScreenUsageFlag(y, x, screenUsageSprite);
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
protected virtual void WriteColorToFramebuffer(byte b, byte g, byte r, int address)
|
|||
|
|
{
|
|||
|
|
outputFramebuffer[address + 0] = b;
|
|||
|
|
outputFramebuffer[address + 1] = g;
|
|||
|
|
outputFramebuffer[address + 2] = r;
|
|||
|
|
outputFramebuffer[address + 3] = 0xFF;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
protected virtual void WriteColorToFramebuffer(ushort colorValue, int address)
|
|||
|
|
{
|
|||
|
|
outputFramebuffer[address + 0] = colorValuesBgr[colorValue & 0x0F][0];
|
|||
|
|
outputFramebuffer[address + 1] = colorValuesBgr[colorValue & 0x0F][1];
|
|||
|
|
outputFramebuffer[address + 2] = colorValuesBgr[colorValue & 0x0F][2];
|
|||
|
|
outputFramebuffer[address + 3] = 0xFF;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
protected virtual byte ReadVram(ushort address)
|
|||
|
|
{
|
|||
|
|
if (is16kVRAMEnabled)
|
|||
|
|
return vram[address & vramMask16k];
|
|||
|
|
else
|
|||
|
|
return vram[address & vramMask4k];
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
protected virtual void WriteVram(ushort address, byte value)
|
|||
|
|
{
|
|||
|
|
if (is16kVRAMEnabled)
|
|||
|
|
vram[address & vramMask16k] = value;
|
|||
|
|
else
|
|||
|
|
vram[address & vramMask4k] = value;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
protected virtual byte ReadDataPort()
|
|||
|
|
{
|
|||
|
|
isSecondControlWrite = false;
|
|||
|
|
statusFlags = StatusFlags.None;
|
|||
|
|
|
|||
|
|
byte data = readBuffer;
|
|||
|
|
readBuffer = ReadVram(addressRegister);
|
|||
|
|
addressRegister++;
|
|||
|
|
|
|||
|
|
return data;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
protected virtual byte ReadControlPort()
|
|||
|
|
{
|
|||
|
|
byte statusCurrent = (byte)statusFlags;
|
|||
|
|
|
|||
|
|
statusFlags = StatusFlags.None;
|
|||
|
|
isSecondControlWrite = false;
|
|||
|
|
|
|||
|
|
InterruptLine = InterruptState.Clear;
|
|||
|
|
|
|||
|
|
return statusCurrent;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
public virtual byte ReadPort(byte port)
|
|||
|
|
{
|
|||
|
|
if ((port & 0x01) == 0x00)
|
|||
|
|
return ReadDataPort();
|
|||
|
|
else
|
|||
|
|
return ReadControlPort();
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
protected virtual void WriteDataPort(byte value)
|
|||
|
|
{
|
|||
|
|
isSecondControlWrite = false;
|
|||
|
|
|
|||
|
|
readBuffer = value;
|
|||
|
|
WriteVram(addressRegister, value);
|
|||
|
|
addressRegister++;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
protected virtual void WriteControlPort(byte value)
|
|||
|
|
{
|
|||
|
|
if (!isSecondControlWrite)
|
|||
|
|
controlWord = (ushort)((controlWord & 0xFF00) | (value << 0));
|
|||
|
|
else
|
|||
|
|
{
|
|||
|
|
controlWord = (ushort)((controlWord & 0x00FF) | (value << 8));
|
|||
|
|
|
|||
|
|
switch (codeRegister)
|
|||
|
|
{
|
|||
|
|
case 0x00: readBuffer = ReadVram(addressRegister); addressRegister++; break;
|
|||
|
|
case 0x01: break;
|
|||
|
|
case 0x02: WriteRegister((byte)((controlWord >> 8) & 0x0F), (byte)(controlWord & 0x00FF)); break;
|
|||
|
|
case 0x03: break;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
isSecondControlWrite = !isSecondControlWrite;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
public virtual void WritePort(byte port, byte value)
|
|||
|
|
{
|
|||
|
|
if ((port & 0x01) == 0x00)
|
|||
|
|
WriteDataPort(value);
|
|||
|
|
else
|
|||
|
|
WriteControlPort(value);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
protected virtual void WriteRegister(byte register, byte value)
|
|||
|
|
{
|
|||
|
|
// TODO: confirm register mirroring
|
|||
|
|
registers[register & 0x07] = value;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
}
|