ShuriZma
/
BizHawk
mirror of https://github.com/TASEmulators/BizHawk.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
BizHawk/ExternalCoreProjects/Virtu/Video.cs

1095 lines
36 KiB
C#
Raw Permalink Blame History

using System;
namespace Jellyfish.Virtu
{
[Flags]
internal enum ScannerOptions { None = 0x0, AppleII = 0x1, Pal = 0x2 } // defaults to AppleIIe, Ntsc
public interface IVideo
{
// ReSharper disable once UnusedMember.Global
int[] GetVideoBuffer();
// ReSharper disable once UnusedMember.Global
void Reset();
void DirtyCell(int addressOffset);
void DirtyCellMixed(int addressOffset);
void DirtyCellMixedText(int addressOffset);
void DirtyScreen();
int ReadFloatingBus();
void SetCharSet();
bool IsVBlank { get; }
// ReSharper disable once UnusedMember.Global
void Sync(IComponentSerializer ser);
}
public sealed partial class Video : IVideo
{
private readonly MachineEvents _events;
private readonly IMemoryBus _memory;
private readonly int[] _colorPalette = new int[ColorPaletteCount];
private bool _isVBlank;
private int[] _framebuffer = new int[560 * 384];
private bool _isTextInversed;
private ScannerOptions _scannerOptions;
private int _cyclesPerVBlank;
private int _cyclesPerVBlankPreset;
private int _cyclesPerVSync;
private int _cyclesPerFlash;
private int _vCountPreset;
private int _vLineLeaveVBlank;
private ushort[] _charSet;
private bool _isMonochrome;
private bool[] _isCellDirty = new bool[Height * CellColumns + 1]; // includes sentinel
public Video(MachineEvents events, IMemoryBus memory)
{
_events = events;
_memory = memory;
_events.AddEventDelegate(EventCallbacks.FlushRow, FlushRowEvent);
_events.AddEventDelegate(EventCallbacks.InverseText, InverseTextEvent);
_events.AddEventDelegate(EventCallbacks.LeaveVBlank, LeaveVBlankEvent);
_events.AddEventDelegate(EventCallbacks.ResetVsync, ResetVSyncEvent);
_flushRowMode = new Action<int>[]
{
FlushRowMode0, FlushRowMode1, FlushRowMode2, FlushRowMode3, FlushRowMode4, FlushRowMode5, FlushRowMode6, FlushRowMode7,
FlushRowMode8, FlushRowMode9, FlushRowModeA, FlushRowModeB, FlushRowModeC, FlushRowModeD, FlushRowModeE, FlushRowModeF
};
unchecked
{
_colorBlack = (int)0xFF000000; // BGRA
_colorDarkBlue = (int)0xFF000099;
_colorDarkGreen = (int)0xFF117722;
_colorMediumBlue = (int)0xFF0000FF;
_colorBrown = (int)0xFF885500;
_colorLightGrey = (int)0xFF99AAAA;
_colorGreen = (int)0xFF00EE11;
_colorAquamarine = (int)0xFF55FFAA;
_colorDeepRed = (int)0xFFFF1111;
_colorPurple = (int)0xFFDD00DD;
_colorDarkGrey = (int)0xFF445555;
_colorLightBlue = (int)0xFF33AAFF;
_colorOrange = (int)0xFFFF4411;
_colorPink = (int)0xFFFF9988;
_colorYellow = (int)0xFFFFFF11;
_colorWhite = (int)0xFFFFFFFF;
_colorMonochrome = (int)0xFF00AA00;
}
SetPalette();
IsMonochrome = false;
ScannerOptions = ScannerOptions.None;
_isVBlank = true;
_events.AddEvent(_cyclesPerVBlankPreset, EventCallbacks.LeaveVBlank); // align flush events with scanner; assumes vcount preset at start of frame [3-15, 3-16]
_events.AddEvent(_cyclesPerVSync, EventCallbacks.ResetVsync);
_events.AddEvent(_cyclesPerFlash, EventCallbacks.InverseText);
}
public void Sync(IComponentSerializer ser)
{
if (ser.IsReader)
{
int option = 0;
ser.Sync(nameof(_scannerOptions), ref option);
_scannerOptions = (ScannerOptions)option;
}
else
{
int option = (int)_scannerOptions;
ser.Sync(nameof(_scannerOptions), ref option);
}
ser.Sync(nameof(_isVBlank), ref _isVBlank);
ser.Sync(nameof(_framebuffer), ref _framebuffer, false);
ser.Sync(nameof(_isTextInversed), ref _isTextInversed);
ser.Sync(nameof(_cyclesPerVBlank), ref _cyclesPerVBlank);
ser.Sync(nameof(_cyclesPerVBlankPreset), ref _cyclesPerVBlankPreset);
ser.Sync(nameof(_cyclesPerVSync), ref _cyclesPerVSync);
ser.Sync(nameof(_cyclesPerFlash), ref _cyclesPerFlash);
ser.Sync(nameof(_vCountPreset), ref _vCountPreset);
ser.Sync(nameof(_vLineLeaveVBlank), ref _vLineLeaveVBlank);
ser.Sync(nameof(_charSet), ref _charSet, false);
ser.Sync(nameof(_isCellDirty), ref _isCellDirty, false);
//ser.Sync(nameof(_isMonochrome), ref _isMonochrome);
//TODO: does this affect sync?
}
// ReSharper disable once UnusedMember.Global
public int[] GetVideoBuffer() => _framebuffer;
public void Reset()
{
SetCharSet();
DirtyScreen();
FlushScreen();
}
void IVideo.DirtyCell(int addressOffset)
{
_isCellDirty[CellIndex[addressOffset]] = true;
}
void IVideo.DirtyCellMixed(int addressOffset)
{
int cellIndex = CellIndex[addressOffset];
if (cellIndex < MixedCellIndex)
{
_isCellDirty[cellIndex] = true;
}
}
void IVideo.DirtyCellMixedText(int addressOffset)
{
int cellIndex = CellIndex[addressOffset];
if (cellIndex >= MixedCellIndex)
{
_isCellDirty[cellIndex] = true;
}
}
public void DirtyScreen()
{
for (int i = 0; i < Height * CellColumns; i++)
{
_isCellDirty[i] = true;
}
}
private void DirtyScreenText()
{
if (_memory.IsText)
{
for (int i = 0; i < MixedHeight * CellColumns; i++)
{
_isCellDirty[i] = true;
}
}
if (_memory.IsText || _memory.IsMixed)
{
for (int i = MixedHeight * CellColumns; i < Height * CellColumns; i++)
{
_isCellDirty[i] = true;
}
}
}
public int ReadFloatingBus() // [5-40]
{
// derive scanner counters from current cycles into frame; assumes hcount and vcount preset at start of frame [3-13, 3-15, 3-16]
int cycles = _cyclesPerVSync - _events.FindEvent(EventCallbacks.ResetVsync);
int hClock = cycles % CyclesPerHSync;
int hCount = (hClock != 0) ? HCountPreset + hClock - 1 : 0;
int vLine = cycles / CyclesPerHSync;
int vCount = _vCountPreset + vLine;
// derive scanner address [5-8]
int address = ((vCount << 4) & 0x0380) | ((0x0068 + (hCount & 0x0038) + (((vCount >> 1) & 0x0060) | ((vCount >> 3) & 0x0018))) & 0x0078) | (hCount & 0x0007);
if (_memory.IsHires && !(_memory.IsMixed && ((vCount & 0xA0) == 0xA0))) // hires but not actively mixed [5-13, 5-19]
{
address |= (_memory.IsVideoPage2 ? 0x4000 : 0x2000) | ((vCount << 10) & 0x1C00);
}
else
{
address |= _memory.IsVideoPage2 ? 0x0800 : 0x0400;
if (((_scannerOptions & ScannerOptions.AppleII) != 0) && (hCount < HCountLeaveHBlank))
{
address |= 0x1000;
}
}
return _memory.Read(address);
}
public void SetCharSet()
{
_charSet = !_memory.IsCharSetAlternate ? CharSetPrimary : (_memory.Monitor == MonitorType.Standard) ? CharSetSecondaryStandard : CharSetSecondaryEnhanced;
DirtyScreenText();
}
private void DrawText40(int data, int x, int y)
{
int color = IsMonochrome ? ColorMono00 : ColorWhite00;
int index = _charSet[data] * CharBitmapBytes;
int inverseMask = (_isTextInversed && !_memory.IsCharSetAlternate && (0x40 <= data) && (data <= 0x7F)) ? 0x7F : 0x00;
for (int i = 0; i < TextHeight; i++, y++)
{
data = CharBitmap[index + i] ^ inverseMask;
SetPixel(x + 0, y, color | (data & 0x01));
SetPixel(x + 1, y, color | (data & 0x01));
SetPixel(x + 2, y, color | (data & 0x02));
SetPixel(x + 3, y, color | (data & 0x02));
SetPixel(x + 4, y, color | (data & 0x04));
SetPixel(x + 5, y, color | (data & 0x04));
SetPixel(x + 6, y, color | (data & 0x08));
SetPixel(x + 7, y, color | (data & 0x08));
SetPixel(x + 8, y, color | (data & 0x10));
SetPixel(x + 9, y, color | (data & 0x10));
SetPixel(x + 10, y, color | (data & 0x20));
SetPixel(x + 11, y, color | (data & 0x20));
SetPixel(x + 12, y, color | (data & 0x40));
SetPixel(x + 13, y, color | (data & 0x40));
}
}
private void DrawText80(int data, int x, int y)
{
int color = IsMonochrome ? ColorMono00 : ColorWhite00;
int index = _charSet[data] * CharBitmapBytes;
int mask = (_isTextInversed && !_memory.IsCharSetAlternate && (0x40 <= data) && (data <= 0x7F)) ? 0x7F : 0x00;
for (int i = 0; i < TextHeight; i++, y++)
{
data = CharBitmap[index + i] ^ mask;
SetPixel(x + 0, y, color | (data & 0x01));
SetPixel(x + 1, y, color | (data & 0x02));
SetPixel(x + 2, y, color | (data & 0x04));
SetPixel(x + 3, y, color | (data & 0x08));
SetPixel(x + 4, y, color | (data & 0x10));
SetPixel(x + 5, y, color | (data & 0x20));
SetPixel(x + 6, y, color | (data & 0x40));
}
}
private void DrawLores(int data, int x, int y)
{
if (IsMonochrome)
{
if ((x & 0x02) == 0x02) // odd cell
{
data = ((data << 2) & 0xCC) | ((data >> 2) & 0x33);
}
for (int i = 0; i < LoresHeight; i++, y++)
{
SetPixel(x + 0, y, data & 0x01);
SetPixel(x + 1, y, data & 0x02);
SetPixel(x + 2, y, data & 0x04);
SetPixel(x + 3, y, data & 0x08);
SetPixel(x + 4, y, data & 0x01);
SetPixel(x + 5, y, data & 0x02);
SetPixel(x + 6, y, data & 0x04);
SetPixel(x + 7, y, data & 0x08);
SetPixel(x + 8, y, data & 0x01);
SetPixel(x + 9, y, data & 0x02);
SetPixel(x + 10, y, data & 0x04);
SetPixel(x + 11, y, data & 0x08);
SetPixel(x + 12, y, data & 0x01);
SetPixel(x + 13, y, data & 0x02);
}
for (int i = 0; i < LoresHeight; i++, y++)
{
SetPixel(x + 0, y, data & 0x10);
SetPixel(x + 1, y, data & 0x20);
SetPixel(x + 2, y, data & 0x40);
SetPixel(x + 3, y, data & 0x80);
SetPixel(x + 4, y, data & 0x10);
SetPixel(x + 5, y, data & 0x20);
SetPixel(x + 6, y, data & 0x40);
SetPixel(x + 7, y, data & 0x80);
SetPixel(x + 8, y, data & 0x10);
SetPixel(x + 9, y, data & 0x20);
SetPixel(x + 10, y, data & 0x40);
SetPixel(x + 11, y, data & 0x80);
SetPixel(x + 12, y, data & 0x10);
SetPixel(x + 13, y, data & 0x20);
}
}
else
{
int color = ColorLores[data & 0x0F];
for (int i = 0; i < LoresHeight; i++, y++)
{
SetPixel(x + 0, y, color);
SetPixel(x + 1, y, color);
SetPixel(x + 2, y, color);
SetPixel(x + 3, y, color);
SetPixel(x + 4, y, color);
SetPixel(x + 5, y, color);
SetPixel(x + 6, y, color);
SetPixel(x + 7, y, color);
SetPixel(x + 8, y, color);
SetPixel(x + 9, y, color);
SetPixel(x + 10, y, color);
SetPixel(x + 11, y, color);
SetPixel(x + 12, y, color);
SetPixel(x + 13, y, color);
}
color = ColorLores[data >> 4];
for (int i = 0; i < LoresHeight; i++, y++)
{
SetPixel(x + 0, y, color);
SetPixel(x + 1, y, color);
SetPixel(x + 2, y, color);
SetPixel(x + 3, y, color);
SetPixel(x + 4, y, color);
SetPixel(x + 5, y, color);
SetPixel(x + 6, y, color);
SetPixel(x + 7, y, color);
SetPixel(x + 8, y, color);
SetPixel(x + 9, y, color);
SetPixel(x + 10, y, color);
SetPixel(x + 11, y, color);
SetPixel(x + 12, y, color);
SetPixel(x + 13, y, color);
}
}
}
private void Draw7MLores(int data, int x, int y)
{
if (IsMonochrome)
{
if ((x & 0x02) == 0x02) // odd cell
{
data = ((data << 2) & 0xCC) | ((data >> 2) & 0x33);
}
for (int i = 0; i < LoresHeight; i++, y++)
{
SetPixel(x + 0, y, data & 0x01);
SetPixel(x + 1, y, data & 0x01);
SetPixel(x + 2, y, data & 0x02);
SetPixel(x + 3, y, data & 0x02);
SetPixel(x + 4, y, data & 0x04);
SetPixel(x + 5, y, data & 0x04);
SetPixel(x + 6, y, data & 0x08);
SetPixel(x + 7, y, data & 0x08);
SetPixel(x + 8, y, data & 0x01);
SetPixel(x + 9, y, data & 0x01);
SetPixel(x + 10, y, data & 0x02);
SetPixel(x + 11, y, data & 0x02);
SetPixel(x + 12, y, data & 0x04);
SetPixel(x + 13, y, data & 0x04);
}
for (int i = 0; i < LoresHeight; i++, y++)
{
SetPixel(x + 0, y, data & 0x10);
SetPixel(x + 1, y, data & 0x10);
SetPixel(x + 2, y, data & 0x20);
SetPixel(x + 3, y, data & 0x20);
SetPixel(x + 4, y, data & 0x40);
SetPixel(x + 5, y, data & 0x40);
SetPixel(x + 6, y, data & 0x80);
SetPixel(x + 7, y, data & 0x80);
SetPixel(x + 8, y, data & 0x10);
SetPixel(x + 9, y, data & 0x10);
SetPixel(x + 10, y, data & 0x20);
SetPixel(x + 11, y, data & 0x20);
SetPixel(x + 12, y, data & 0x40);
SetPixel(x + 13, y, data & 0x40);
}
}
else
{
int color = Color7MLores[((x & 0x02) << 3) | (data & 0x0F)];
for (int i = 0; i < LoresHeight; i++, y++)
{
SetPixel(x + 0, y, color);
SetPixel(x + 1, y, color);
SetPixel(x + 2, y, color);
SetPixel(x + 3, y, color);
SetPixel(x + 4, y, color);
SetPixel(x + 5, y, color);
SetPixel(x + 6, y, color);
SetPixel(x + 7, y, color);
SetPixel(x + 8, y, color);
SetPixel(x + 9, y, color);
SetPixel(x + 10, y, color);
SetPixel(x + 11, y, color);
SetPixel(x + 12, y, color);
SetPixel(x + 13, y, color);
}
color = Color7MLores[((x & 0x02) << 3) | (data >> 4)];
for (int i = 0; i < LoresHeight; i++, y++)
{
SetPixel(x + 0, y, color);
SetPixel(x + 1, y, color);
SetPixel(x + 2, y, color);
SetPixel(x + 3, y, color);
SetPixel(x + 4, y, color);
SetPixel(x + 5, y, color);
SetPixel(x + 6, y, color);
SetPixel(x + 7, y, color);
SetPixel(x + 8, y, color);
SetPixel(x + 9, y, color);
SetPixel(x + 10, y, color);
SetPixel(x + 11, y, color);
SetPixel(x + 12, y, color);
SetPixel(x + 13, y, color);
}
}
}
private void DrawDLores(int data, int x, int y)
{
if (IsMonochrome)
{
if ((x & 0x01) == 0x00) // even half cell
{
data = ((data << 1) & 0xEE) | ((data >> 3) & 0x11);
}
for (int i = 0; i < LoresHeight; i++, y++)
{
SetPixel(x + 0, y, data & 0x01);
SetPixel(x + 1, y, data & 0x02);
SetPixel(x + 2, y, data & 0x04);
SetPixel(x + 3, y, data & 0x08);
SetPixel(x + 4, y, data & 0x01);
SetPixel(x + 5, y, data & 0x02);
SetPixel(x + 6, y, data & 0x04);
}
for (int i = 0; i < LoresHeight; i++, y++)
{
SetPixel(x + 0, y, data & 0x10);
SetPixel(x + 1, y, data & 0x20);
SetPixel(x + 2, y, data & 0x40);
SetPixel(x + 3, y, data & 0x80);
SetPixel(x + 4, y, data & 0x10);
SetPixel(x + 5, y, data & 0x20);
SetPixel(x + 6, y, data & 0x40);
}
}
else
{
int color = ColorDLores[((x & 0x01) << 4) | (data & 0x0F)];
for (int i = 0; i < LoresHeight; i++, y++)
{
SetPixel(x + 0, y, color);
SetPixel(x + 1, y, color);
SetPixel(x + 2, y, color);
SetPixel(x + 3, y, color);
SetPixel(x + 4, y, color);
SetPixel(x + 5, y, color);
SetPixel(x + 6, y, color);
}
color = ColorDLores[((x & 0x01) << 4) | (data >> 4)];
for (int i = 0; i < LoresHeight; i++, y++)
{
SetPixel(x + 0, y, color);
SetPixel(x + 1, y, color);
SetPixel(x + 2, y, color);
SetPixel(x + 3, y, color);
SetPixel(x + 4, y, color);
SetPixel(x + 5, y, color);
SetPixel(x + 6, y, color);
}
}
}
private void DrawHires(int address, int x, int y)
{
if (IsMonochrome)
{
int data = _memory.ReadRamMainRegion02BF(address);
SetPixel(x + 0, y, data & 0x01);
SetPixel(x + 1, y, data & 0x01);
SetPixel(x + 2, y, data & 0x02);
SetPixel(x + 3, y, data & 0x02);
SetPixel(x + 4, y, data & 0x04);
SetPixel(x + 5, y, data & 0x04);
SetPixel(x + 6, y, data & 0x08);
SetPixel(x + 7, y, data & 0x08);
SetPixel(x + 8, y, data & 0x10);
SetPixel(x + 9, y, data & 0x10);
SetPixel(x + 10, y, data & 0x20);
SetPixel(x + 11, y, data & 0x20);
SetPixel(x + 12, y, data & 0x40);
SetPixel(x + 13, y, data & 0x40);
}
else
{
// 3 2 1 0
// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0
//
// - - - - - - - - 0 0 0 0 0 0 0 0 + + + + + + + +
// H 1 0 H 6 5 4 3 2 1 0 H 1 0
int data = _memory.ReadRamMainRegion02BF(address) << 8;
if (x < Width - CellWidth)
{
data |= _memory.ReadRamMainRegion02BF(address + 1);
SetPixel(x + 14, y, ColorHires[((~x & 0x02) << 3) | ((data >> 4) & 0x08) | ((data << 1) & 0x06) | ((data >> 14) & 0x01)]);
SetPixel(x + 15, y, ColorHires[((~x & 0x02) << 3) | ((data >> 4) & 0x08) | ((data << 1) & 0x06) | ((data >> 14) & 0x01)]);
}
if (x > 0)
{
data |= _memory.ReadRamMainRegion02BF(address - 1) << 16;
SetPixel(x - 2, y, ColorHires[((~x & 0x02) << 3) | ((data >> 20) & 0x08) | ((data >> 6) & 0x04) | ((data >> 21) & 0x03)]);
SetPixel(x - 1, y, ColorHires[((~x & 0x02) << 3) | ((data >> 20) & 0x08) | ((data >> 6) & 0x04) | ((data >> 21) & 0x03)]);
}
SetPixel(x + 0, y, ColorHires[((x & 0x02) << 3) | ((data >> 12) & 0x08) | ((data >> 7) & 0x06) | ((data >> 22) & 0x01)]);
SetPixel(x + 1, y, ColorHires[((x & 0x02) << 3) | ((data >> 12) & 0x08) | ((data >> 7) & 0x06) | ((data >> 22) & 0x01)]);
SetPixel(x + 2, y, ColorHires[((~x & 0x02) << 3) | ((data >> 12) & 0x08) | ((data >> 8) & 0x07)]);
SetPixel(x + 3, y, ColorHires[((~x & 0x02) << 3) | ((data >> 12) & 0x08) | ((data >> 8) & 0x07)]);
SetPixel(x + 4, y, ColorHires[((x & 0x02) << 3) | ((data >> 12) & 0x08) | ((data >> 9) & 0x07)]);
SetPixel(x + 5, y, ColorHires[((x & 0x02) << 3) | ((data >> 12) & 0x08) | ((data >> 9) & 0x07)]);
SetPixel(x + 6, y, ColorHires[((~x & 0x02) << 3) | ((data >> 12) & 0x08) | ((data >> 10) & 0x07)]);
SetPixel(x + 7, y, ColorHires[((~x & 0x02) << 3) | ((data >> 12) & 0x08) | ((data >> 10) & 0x07)]);
SetPixel(x + 8, y, ColorHires[((x & 0x02) << 3) | ((data >> 12) & 0x08) | ((data >> 11) & 0x07)]);
SetPixel(x + 9, y, ColorHires[((x & 0x02) << 3) | ((data >> 12) & 0x08) | ((data >> 11) & 0x07)]);
SetPixel(x + 10, y, ColorHires[((~x & 0x02) << 3) | ((data >> 12) & 0x0F)]);
SetPixel(x + 11, y, ColorHires[((~x & 0x02) << 3) | ((data >> 12) & 0x0F)]);
SetPixel(x + 12, y, ColorHires[((x & 0x02) << 3) | ((data >> 12) & 0x08) | ((data << 2) & 0x04) | ((data >> 13) & 0x03)]);
SetPixel(x + 13, y, ColorHires[((x & 0x02) << 3) | ((data >> 12) & 0x08) | ((data << 2) & 0x04) | ((data >> 13) & 0x03)]);
}
}
private void DrawNDHires(int address, int x, int y)
{
if (IsMonochrome)
{
int data = _memory.ReadRamMainRegion02BF(address);
SetPixel(x + 0, y, data & 0x01);
SetPixel(x + 1, y, data & 0x01);
SetPixel(x + 2, y, data & 0x02);
SetPixel(x + 3, y, data & 0x02);
SetPixel(x + 4, y, data & 0x04);
SetPixel(x + 5, y, data & 0x04);
SetPixel(x + 6, y, data & 0x08);
SetPixel(x + 7, y, data & 0x08);
SetPixel(x + 8, y, data & 0x10);
SetPixel(x + 9, y, data & 0x10);
SetPixel(x + 10, y, data & 0x20);
SetPixel(x + 11, y, data & 0x20);
SetPixel(x + 12, y, data & 0x40);
SetPixel(x + 13, y, data & 0x40);
}
else
{
// 3 2 1 0
// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0
//
// - - - - - - - - 0 0 0 0 0 0 0 0 + + + + + + + +
// X 1 0 X 6 5 4 3 2 1 0 X 1 0
int data = _memory.ReadRamMainRegion02BF(address) << 8;
if (x < Width - CellWidth)
{
data |= _memory.ReadRamMainRegion02BF(address + 1);
SetPixel(x + 14, y, ColorHires[((~x & 0x02) << 3) | ((data << 1) & 0x06) | ((data >> 14) & 0x01)]);
SetPixel(x + 15, y, ColorHires[((~x & 0x02) << 3) | ((data << 1) & 0x06) | ((data >> 14) & 0x01)]);
}
if (x > 0)
{
data |= _memory.ReadRamMainRegion02BF(address - 1) << 16;
SetPixel(x - 2, y, ColorHires[((~x & 0x02) << 3) | ((data >> 6) & 0x04) | ((data >> 21) & 0x03)]);
SetPixel(x - 1, y, ColorHires[((~x & 0x02) << 3) | ((data >> 6) & 0x04) | ((data >> 21) & 0x03)]);
}
SetPixel(x + 0, y, ColorHires[((x & 0x02) << 3) | ((data >> 7) & 0x06) | ((data >> 22) & 0x01)]);
SetPixel(x + 1, y, ColorHires[((x & 0x02) << 3) | ((data >> 7) & 0x06) | ((data >> 22) & 0x01)]);
SetPixel(x + 2, y, ColorHires[((~x & 0x02) << 3) | ((data >> 8) & 0x07)]);
SetPixel(x + 3, y, ColorHires[((~x & 0x02) << 3) | ((data >> 8) & 0x07)]);
SetPixel(x + 4, y, ColorHires[((x & 0x02) << 3) | ((data >> 9) & 0x07)]);
SetPixel(x + 5, y, ColorHires[((x & 0x02) << 3) | ((data >> 9) & 0x07)]);
SetPixel(x + 6, y, ColorHires[((~x & 0x02) << 3) | ((data >> 10) & 0x07)]);
SetPixel(x + 7, y, ColorHires[((~x & 0x02) << 3) | ((data >> 10) & 0x07)]);
SetPixel(x + 8, y, ColorHires[((x & 0x02) << 3) | ((data >> 11) & 0x07)]);
SetPixel(x + 9, y, ColorHires[((x & 0x02) << 3) | ((data >> 11) & 0x07)]);
SetPixel(x + 10, y, ColorHires[((~x & 0x02) << 3) | ((data >> 12) & 0x07)]);
SetPixel(x + 11, y, ColorHires[((~x & 0x02) << 3) | ((data >> 12) & 0x07)]);
SetPixel(x + 12, y, ColorHires[((x & 0x02) << 3) | ((data << 2) & 0x04) | ((data >> 13) & 0x03)]);
SetPixel(x + 13, y, ColorHires[((x & 0x02) << 3) | ((data << 2) & 0x04) | ((data >> 13) & 0x03)]);
}
}
private void DrawDHiresA(int address, int x, int y)
{
if (IsMonochrome)
{
if ((x & 0x2) == 0x00) // even cell
{
int data = ((_memory.ReadRamMainRegion02BF(address) << 7) & 0x80) | (_memory.ReadRamAuxRegion02BF(address) & 0x7F);
SetPixel(x + 0, y, data & 0x01);
SetPixel(x + 1, y, data & 0x02);
SetPixel(x + 2, y, data & 0x04);
SetPixel(x + 3, y, data & 0x08);
SetPixel(x + 4, y, data & 0x10);
SetPixel(x + 5, y, data & 0x20);
SetPixel(x + 6, y, data & 0x40);
SetPixel(x + 7, y, data & 0x80);
}
else
{
int data = ((_memory.ReadRamMainRegion02BF(address) << 9) & 0xE00) | ((_memory.ReadRamAuxRegion02BF(address) << 2) & 0x1FC) |
((_memory.ReadRamMainRegion02BF(address - 1) >> 5) & 0x003);
SetPixel(x - 2, y, data & 0x01);
SetPixel(x - 1, y, data & 0x02);
SetPixel(x + 0, y, data & 0x04);
SetPixel(x + 1, y, data & 0x08);
SetPixel(x + 2, y, data & 0x10);
SetPixel(x + 3, y, data & 0x20);
SetPixel(x + 4, y, data & 0x40);
SetPixel(x + 5, y, data & 0x80);
SetPixel(x + 6, y, (data >> 8) & 0x01);
SetPixel(x + 7, y, (data >> 8) & 0x02);
SetPixel(x + 8, y, (data >> 8) & 0x04);
SetPixel(x + 9, y, (data >> 8) & 0x08);
}
}
else
{
if ((x & 0x2) == 0x00) // even cell
{
int data = ((_memory.ReadRamMainRegion02BF(address) << 7) & 0x80) | (_memory.ReadRamAuxRegion02BF(address) & 0x7F);
SetPixel(x + 0, y, ColorDHires0 | (data & 0x0F));
SetPixel(x + 1, y, ColorDHires0 | (data & 0x0F));
SetPixel(x + 2, y, ColorDHires0 | (data & 0x0F));
SetPixel(x + 3, y, ColorDHires0 | (data & 0x0F));
SetPixel(x + 4, y, ColorDHires0 | (data >> 4));
SetPixel(x + 5, y, ColorDHires0 | (data >> 4));
SetPixel(x + 6, y, ColorDHires0 | (data >> 4));
SetPixel(x + 7, y, ColorDHires0 | (data >> 4));
}
else
{
int data = ((_memory.ReadRamMainRegion02BF(address) << 9) & 0xE00) | ((_memory.ReadRamAuxRegion02BF(address) << 2) & 0x1FC) |
((_memory.ReadRamMainRegion02BF(address - 1) >> 5) & 0x003);
SetPixel(x - 2, y, ColorDHires0 | (data & 0x0F));
SetPixel(x - 1, y, ColorDHires0 | (data & 0x0F));
SetPixel(x + 0, y, ColorDHires0 | (data & 0x0F));
SetPixel(x + 1, y, ColorDHires0 | (data & 0x0F));
SetPixel(x + 2, y, ColorDHires0 | ((data >> 4) & 0x0F));
SetPixel(x + 3, y, ColorDHires0 | ((data >> 4) & 0x0F));
SetPixel(x + 4, y, ColorDHires0 | ((data >> 4) & 0x0F));
SetPixel(x + 5, y, ColorDHires0 | ((data >> 4) & 0x0F));
SetPixel(x + 6, y, ColorDHires0 | (data >> 8));
SetPixel(x + 7, y, ColorDHires0 | (data >> 8));
SetPixel(x + 8, y, ColorDHires0 | (data >> 8));
SetPixel(x + 9, y, ColorDHires0 | (data >> 8));
}
}
}
private void DrawDHiresM(int address, int x, int y)
{
if (IsMonochrome)
{
if ((x & 0x2) == 0x02) // odd cell
{
int data = ((_memory.ReadRamMainRegion02BF(address) << 1) & 0xFE) | ((_memory.ReadRamAuxRegion02BF(address) >> 6) & 0x01);
SetPixel(x + 6, y, data & 0x01);
SetPixel(x + 7, y, data & 0x02);
SetPixel(x + 8, y, data & 0x04);
SetPixel(x + 9, y, data & 0x08);
SetPixel(x + 10, y, data & 0x10);
SetPixel(x + 11, y, data & 0x20);
SetPixel(x + 12, y, data & 0x40);
SetPixel(x + 13, y, data & 0x80);
}
else
{
int data = ((_memory.ReadRamAuxRegion02BF(address + 1) << 10) & 0xC00) | ((_memory.ReadRamMainRegion02BF(address) << 3) & 0x3F8) |
((_memory.ReadRamAuxRegion02BF(address) >> 4) & 0x007);
SetPixel(x + 4, y, data & 0x01);
SetPixel(x + 5, y, data & 0x02);
SetPixel(x + 6, y, data & 0x04);
SetPixel(x + 7, y, data & 0x08);
SetPixel(x + 8, y, data & 0x10);
SetPixel(x + 9, y, data & 0x20);
SetPixel(x + 10, y, data & 0x40);
SetPixel(x + 11, y, data & 0x80);
SetPixel(x + 12, y, (data >> 8) & 0x01);
SetPixel(x + 13, y, (data >> 8) & 0x02);
SetPixel(x + 14, y, (data >> 8) & 0x04);
SetPixel(x + 15, y, (data >> 8) & 0x08);
}
}
else
{
if ((x & 0x2) == 0x02) // odd cell
{
int data = ((_memory.ReadRamMainRegion02BF(address) << 1) & 0xFE) | ((_memory.ReadRamAuxRegion02BF(address) >> 6) & 0x01);
SetPixel(x + 6, y, ColorDHires0 | (data & 0x0F));
SetPixel(x + 7, y, ColorDHires0 | (data & 0x0F));
SetPixel(x + 8, y, ColorDHires0 | (data & 0x0F));
SetPixel(x + 9, y, ColorDHires0 | (data & 0x0F));
SetPixel(x + 10, y, ColorDHires0 | (data >> 4));
SetPixel(x + 11, y, ColorDHires0 | (data >> 4));
SetPixel(x + 12, y, ColorDHires0 | (data >> 4));
SetPixel(x + 13, y, ColorDHires0 | (data >> 4));
}
else
{
int data = ((_memory.ReadRamAuxRegion02BF(address + 1) << 10) & 0xC00) | ((_memory.ReadRamMainRegion02BF(address) << 3) & 0x3F8) |
((_memory.ReadRamAuxRegion02BF(address) >> 4) & 0x007);
SetPixel(x + 4, y, ColorDHires0 | (data & 0x0F));
SetPixel(x + 5, y, ColorDHires0 | (data & 0x0F));
SetPixel(x + 6, y, ColorDHires0 | (data & 0x0F));
SetPixel(x + 7, y, ColorDHires0 | (data & 0x0F));
SetPixel(x + 8, y, ColorDHires0 | ((data >> 4) & 0x0F));
SetPixel(x + 9, y, ColorDHires0 | ((data >> 4) & 0x0F));
SetPixel(x + 10, y, ColorDHires0 | ((data >> 4) & 0x0F));
SetPixel(x + 11, y, ColorDHires0 | ((data >> 4) & 0x0F));
SetPixel(x + 12, y, ColorDHires0 | (data >> 8));
SetPixel(x + 13, y, ColorDHires0 | (data >> 8));
SetPixel(x + 14, y, ColorDHires0 | (data >> 8));
SetPixel(x + 15, y, ColorDHires0 | (data >> 8));
}
}
}
private void FlushRowMode0(int y)
{
int address = (_memory.IsVideoPage2 ? 0x0800 : 0x0400) + AddressOffset[y];
for (int x = 0; x < CellColumns; x++)
{
if (_isCellDirty[CellColumns * y + x])
{
_isCellDirty[CellColumns * y + x] = false;
DrawLores(_memory.ReadRamMainRegion02BF(address + x), CellWidth * x, y); // lores
}
}
}
private void FlushRowMode1(int y)
{
int address = (_memory.IsVideoPage2 ? 0x0800 : 0x0400) + AddressOffset[y];
for (int x = 0; x < CellColumns; x++)
{
if (_isCellDirty[CellColumns * y + x])
{
_isCellDirty[CellColumns * y + x] = false;
DrawText40(_memory.ReadRamMainRegion02BF(address + x), CellWidth * x, y); // text40
}
}
}
private void FlushRowMode2(int y)
{
int address = (_memory.IsVideoPage2 ? 0x0800 : 0x0400) + AddressOffset[y];
for (int x = 0; x < 2 * CellColumns; x += 2)
{
if (_isCellDirty[CellColumns * y + x / 2])
{
_isCellDirty[CellColumns * y + x / 2] = false;
DrawText80(_memory.ReadRamAuxRegion02BF(address + x / 2), CellWidth / 2 * (x + 0), y); // text80
DrawText80(_memory.ReadRamMainRegion02BF(address + x / 2), CellWidth / 2 * (x + 1), y);
}
}
}
private void FlushRowMode3(int y)
{
if (y < MixedHeight)
{
FlushRowMode0(y); // lores
}
else
{
FlushRowMode1(y); // text40
}
}
private void FlushRowMode4(int y)
{
if (y < MixedHeight)
{
FlushRowMode0(y); // lores
}
else
{
FlushRowMode2(y); // text80
}
}
private void FlushRowMode5(int y)
{
int address = _memory.IsVideoPage2 ? 0x4000 : 0x2000;
for (int i = 0; i < CellHeight; i++, y++)
{
for (int x = 0; x < CellColumns; x++)
{
if (_isCellDirty[CellColumns * y + x])
{
_isCellDirty[CellColumns * y + x] = false;
DrawHires(address + AddressOffset[y] + x, CellWidth * x, y); // hires
}
}
}
}
private void FlushRowMode6(int y)
{
if (y < MixedHeight)
{
FlushRowMode5(y); // hires
}
else
{
FlushRowMode1(y); // text40
}
}
private void FlushRowMode7(int y)
{
if (y < MixedHeight)
{
FlushRowMode5(y); // hires
}
else
{
FlushRowMode2(y); // text80
}
}
private void FlushRowMode8(int y)
{
int address = (_memory.IsVideoPage2 ? 0x0800 : 0x0400) + AddressOffset[y];
for (int x = 0; x < CellColumns; x++)
{
if (_isCellDirty[CellColumns * y + x])
{
_isCellDirty[CellColumns * y + x] = false;
Draw7MLores(_memory.ReadRamMainRegion02BF(address + x), CellWidth * x, y); // 7mlores
}
}
}
private void FlushRowMode9(int y)
{
int address = (_memory.IsVideoPage2 ? 0x0800 : 0x0400) + AddressOffset[y];
for (int x = 0; x < 2 * CellColumns; x += 2)
{
if (_isCellDirty[CellColumns * y + x / 2])
{
_isCellDirty[CellColumns * y + x / 2] = false;
DrawDLores(_memory.ReadRamAuxRegion02BF(address + x / 2), CellWidth / 2 * (x + 0), y); // dlores
DrawDLores(_memory.ReadRamMainRegion02BF(address + x / 2), CellWidth / 2 * (x + 1), y);
}
}
}
private void FlushRowModeA(int y)
{
if (y < MixedHeight)
{
FlushRowMode8(y); // 7mlores
}
else
{
FlushRowMode1(y); // text40
}
}
private void FlushRowModeB(int y)
{
if (y < MixedHeight)
{
FlushRowMode9(y); // dlores
}
else
{
FlushRowMode2(y); // text80
}
}
private void FlushRowModeC(int y)
{
int address = _memory.IsVideoPage2 ? 0x4000 : 0x2000;
for (int i = 0; i < CellHeight; i++, y++)
{
for (int x = 0; x < CellColumns; x++)
{
if (_isCellDirty[CellColumns * y + x])
{
_isCellDirty[CellColumns * y + x] = false;
DrawNDHires(address + AddressOffset[y] + x, CellWidth * x, y); // ndhires
}
}
}
}
private void FlushRowModeD(int y)
{
int address = _memory.IsVideoPage2 ? 0x4000 : 0x2000;
for (int i = 0; i < CellHeight; i++, y++)
{
for (int x = 0; x < CellColumns; x++)
{
if (_isCellDirty[CellColumns * y + x])
{
_isCellDirty[CellColumns * y + x] = false;
DrawDHiresA(address + AddressOffset[y] + x, CellWidth * x, y); // dhires
DrawDHiresM(address + AddressOffset[y] + x, CellWidth * x, y);
}
}
}
}
private void FlushRowModeE(int y)
{
if (y < MixedHeight)
{
FlushRowModeC(y); // ndhires
}
else
{
FlushRowMode1(y); // text40
}
}
private void FlushRowModeF(int y)
{
if (y < MixedHeight)
{
FlushRowModeD(y); // dhires
}
else
{
FlushRowMode2(y); // text80
}
}
private void FlushRowEvent()
{
int y = (_cyclesPerVSync - _cyclesPerVBlankPreset - _events.FindEvent(EventCallbacks.ResetVsync)) / CyclesPerHSync;
_flushRowMode[_memory.VideoMode](y - CellHeight); // in arrears
if (y < Height)
{
_events.AddEvent(CyclesPerFlush, EventCallbacks.FlushRow);
}
else
{
_isVBlank = true;
_events.AddEvent(_cyclesPerVBlank, EventCallbacks.LeaveVBlank);
}
}
private void FlushScreen()
{
var flushRowMode = _flushRowMode[_memory.VideoMode];
for (int y = 0; y < Height; y += CellHeight)
{
flushRowMode(y);
}
}
private void InverseTextEvent()
{
_isTextInversed = !_isTextInversed;
DirtyScreenText();
_events.AddEvent(_cyclesPerFlash, EventCallbacks.InverseText);
}
private void LeaveVBlankEvent()
{
_isVBlank = false;
_events.AddEvent(CyclesPerFlush, EventCallbacks.FlushRow);
}
private void ResetVSyncEvent()
{
_events.AddEvent(_cyclesPerVSync, EventCallbacks.ResetVsync);
}
private void SetPalette()
{
_colorPalette[ColorMono00] = _colorBlack;
_colorPalette[ColorMono01] = _colorMonochrome;
_colorPalette[ColorMono02] = _colorMonochrome;
_colorPalette[ColorMono04] = _colorMonochrome;
_colorPalette[ColorMono08] = _colorMonochrome;
_colorPalette[ColorMono10] = _colorMonochrome;
_colorPalette[ColorMono20] = _colorMonochrome;
_colorPalette[ColorMono40] = _colorMonochrome;
_colorPalette[ColorMono80] = _colorMonochrome;
_colorPalette[ColorWhite00] = _colorBlack;
_colorPalette[ColorWhite01] = _colorWhite;
_colorPalette[ColorWhite02] = _colorWhite;
_colorPalette[ColorWhite04] = _colorWhite;
_colorPalette[ColorWhite08] = _colorWhite;
_colorPalette[ColorWhite10] = _colorWhite;
_colorPalette[ColorWhite20] = _colorWhite;
_colorPalette[ColorWhite40] = _colorWhite;
_colorPalette[ColorWhite80] = _colorWhite;
_colorPalette[ColorDHires0] = _colorBlack;
_colorPalette[ColorDHires1] = _colorDarkBlue;
_colorPalette[ColorDHires2] = _colorDarkGreen;
_colorPalette[ColorDHires3] = _colorMediumBlue;
_colorPalette[ColorDHires4] = _colorBrown;
_colorPalette[ColorDHires5] = _colorLightGrey;
_colorPalette[ColorDHires6] = _colorGreen;
_colorPalette[ColorDHires7] = _colorAquamarine;
_colorPalette[ColorDHires8] = _colorDeepRed;
_colorPalette[ColorDHires9] = _colorPurple;
_colorPalette[ColorDHiresA] = _colorDarkGrey;
_colorPalette[ColorDHiresB] = _colorLightBlue;
_colorPalette[ColorDHiresC] = _colorOrange;
_colorPalette[ColorDHiresD] = _colorPink;
_colorPalette[ColorDHiresE] = _colorYellow;
_colorPalette[ColorDHiresF] = _colorWhite;
DirtyScreen();
}
private void SetPixel(int x, int y, int color)
{
int i = 560 * (2 * y) + x;
_framebuffer[i] = _framebuffer[i + 560] = _colorPalette[color];
}
private void SetScanner()
{
if ((_scannerOptions & ScannerOptions.Pal) != 0)
{
_vCountPreset = VCountPresetPal;
_vLineLeaveVBlank = VLineLeaveVBlankPal;
}
else
{
_vCountPreset = VCountPresetNtsc;
_vLineLeaveVBlank = VLineLeaveVBlankNtsc;
}
_cyclesPerVBlank = (_vLineLeaveVBlank - VLineEnterVBlank) * CyclesPerHSync;
_cyclesPerVBlankPreset = (_vLineLeaveVBlank - VLineTriggerPreset) * CyclesPerHSync; // cycles during vblank after vcount preset [3-15, 3-16]
_cyclesPerVSync = _vLineLeaveVBlank * CyclesPerHSync;
_cyclesPerFlash = VSyncsPerFlash * _cyclesPerVSync;
}
public bool IsMonochrome
{
get => _isMonochrome;
set { _isMonochrome = value; DirtyScreen(); }
}
internal ScannerOptions ScannerOptions
{
get => _scannerOptions;
set { _scannerOptions = value; SetScanner(); }
}
public bool IsVBlank => _isVBlank;
private readonly int _colorBlack;
private readonly int _colorDarkBlue;
private readonly int _colorDarkGreen;
private readonly int _colorMediumBlue;
private readonly int _colorBrown;
private readonly int _colorLightGrey;
private readonly int _colorGreen;
private readonly int _colorAquamarine;
private readonly int _colorDeepRed;
private readonly int _colorPurple;
private readonly int _colorDarkGrey;
private readonly int _colorLightBlue;
private readonly int _colorOrange;
private readonly int _colorPink;
private readonly int _colorYellow;
private readonly int _colorWhite;
private readonly int _colorMonochrome;
}
}
Reference in New Issue View Git Blame Copy Permalink