Path: blob/master/BizHawk.Emulation.Cores/Consoles/Sega/Genesis/GenVDP.Render.cs
2 views
using System;
namespace BizHawk.Emulation.Cores.Sega.Genesis
{
public partial class GenVDP
{
// Priority buffer contents have the following values:
// 0 = Backdrop color
// 1 = Plane B Low Priority
// 2 = Plane A Low Priority
// 4 = Plane B High Priority
// 5 = Plane A High Priority
// 9 = Sprite has been drawn
byte[] PriorityBuffer = new byte[320];
static readonly byte[] PalXlatTable = { 0, 0, 36, 36, 73, 73, 109, 109, 145, 145, 182, 182, 219, 219, 255, 255 };
public void RenderLine()
{
if (DisplayEnabled)
{
Array.Clear(PriorityBuffer, 0, 320);
// TODO: I would like to be able to render Scroll A before Scroll B, in order to minimize overdraw.
// But at the moment it complicates priority stuff.
if (CellBasedVertScroll == false)
{
RenderScrollB();
RenderScrollA();
}
else
{
RenderScrollBTwoCellVScroll();
RenderScrollATwoCellVScroll();
}
RenderSpritesScanline();
}
else
{
// If display is disabled, fill in with background color.
for (int i = 0; i < FrameWidth; i++)
FrameBuffer[(ScanLine * FrameWidth) + i] = BackgroundColor;
}
//if (ScanLine == 223) // shrug
// RenderPalette();
}
void RenderPalette()
{
for (int p = 0; p < 4; p++)
for (int i = 0; i < 16; i++)
FrameBuffer[(p * FrameWidth) + i] = Palette[(p * 16) + i];
}
void RenderScrollAScanline(int xScroll, int yScroll, int nameTableBase, int startPixel, int endPixel, bool window)
{
const int lowPriority = 2;
const int highPriority = 5;
int yTile = ((ScanLine + yScroll) / 8) % NameTableHeight;
int nameTableWidth = NameTableWidth;
if (window)
nameTableWidth = (DisplayWidth == 40) ? 64 : 32;
// this is hellllla slow. but not optimizing until we implement & understand
// all scrolling modes, shadow & hilight, etc.
// in thinking about this, you could convince me to optimize the PCE background renderer now.
// Its way simple in comparison. But the PCE sprite renderer is way worse than gen.
for (int x = startPixel; x < endPixel; x++)
{
int xTile = Math.Abs(((x + (1024 - xScroll)) / 8) % nameTableWidth);
int xOfs = Math.Abs((x + (1024 - xScroll)) & 7);
int yOfs = (ScanLine + yScroll) % 8;
int cellOfs = nameTableBase + (yTile * nameTableWidth * 2) + (xTile * 2);
int nameTableEntry = VRAM[cellOfs] | (VRAM[cellOfs + 1] << 8);
int patternNo = nameTableEntry & 0x7FF;
bool hFlip = ((nameTableEntry >> 11) & 1) != 0;
bool vFlip = ((nameTableEntry >> 12) & 1) != 0;
bool priority = ((nameTableEntry >> 15) & 1) != 0;
int palette = (nameTableEntry >> 13) & 3;
if (priority && PriorityBuffer[x] >= highPriority) continue;
if (!priority && PriorityBuffer[x] >= lowPriority) continue;
if (vFlip) yOfs = 7 - yOfs;
if (hFlip) xOfs = 7 - xOfs;
int texel = PatternBuffer[(patternNo * 64) + (yOfs * 8) + (xOfs)];
if (texel == 0) continue;
int pixel = Palette[(palette * 16) + texel];
FrameBuffer[(ScanLine * FrameWidth) + x] = pixel;
PriorityBuffer[x] = (byte)(priority ? highPriority : lowPriority);
}
}
void RenderScrollAScanlineTwoCellVScroll(int xScroll, int nameTableBase, int startPixel, int endPixel, bool window)
{
const int lowPriority = 2;
const int highPriority = 5;
int fineHScroll = xScroll & 15;
int nameTableWidth = NameTableWidth;
if (window)
nameTableWidth = (DisplayWidth == 40) ? 64 : 32;
for (int x = startPixel; x < endPixel; x++)
{
int vsramUnitOffset = ((x - fineHScroll) / 16) % 40;
int yScroll = VSRAM[vsramUnitOffset * 2] & 0x3FF;
int yTile = ((ScanLine + yScroll) / 8) % NameTableHeight;
int xTile = Math.Abs(((x + (1024 - xScroll)) / 8) % nameTableWidth);
int xOfs = Math.Abs((x + (1024 - xScroll)) & 7);
int yOfs = (ScanLine + yScroll) % 8;
int cellOfs = nameTableBase + (yTile * nameTableWidth * 2) + (xTile * 2);
int nameTableEntry = VRAM[cellOfs] | (VRAM[cellOfs + 1] << 8);
int patternNo = nameTableEntry & 0x7FF;
bool hFlip = ((nameTableEntry >> 11) & 1) != 0;
bool vFlip = ((nameTableEntry >> 12) & 1) != 0;
bool priority = ((nameTableEntry >> 15) & 1) != 0;
int palette = (nameTableEntry >> 13) & 3;
if (priority && PriorityBuffer[x] >= highPriority) continue;
if (!priority && PriorityBuffer[x] >= lowPriority) continue;
if (vFlip) yOfs = 7 - yOfs;
if (hFlip) xOfs = 7 - xOfs;
int texel = PatternBuffer[(patternNo * 64) + (yOfs * 8) + (xOfs)];
if (texel == 0) continue;
int pixel = Palette[(palette * 16) + texel];
FrameBuffer[(ScanLine * FrameWidth) + x] = pixel;
PriorityBuffer[x] = (byte)(priority ? highPriority : lowPriority);
}
}
void CalculateWindowScanlines(out int startScanline, out int endScanline)
{
int data = Registers[0x12];
int windowVPosition = data & 31;
bool fromTop = (data & 0x80) == 0;
if (windowVPosition == 0)
{
startScanline = -1;
endScanline = -1;
return;
}
if (fromTop)
{
startScanline = 0;
endScanline = (windowVPosition * 8);
}
else
{
startScanline = windowVPosition * 8;
endScanline = FrameHeight;
}
}
void CalculateWindowPosition(out int startPixel, out int endPixel)
{
int data = Registers[0x11];
int windowHPosition = (data & 31) * 2; // Window H position is set in 2-cell increments
bool fromLeft = (data & 0x80) == 0;
if (windowHPosition == 0)
{
startPixel = -1;
endPixel = -1;
return;
}
if (fromLeft)
{
startPixel = 0;
endPixel = (windowHPosition * 8);
if (endPixel > FrameWidth)
endPixel = FrameWidth;
}
else
{
startPixel = windowHPosition * 8;
endPixel = FrameWidth;
if (startPixel > FrameWidth)
{
startPixel = -1;
endPixel = -1;
}
}
}
void RenderScrollA()
{
// Calculate scroll offsets
int hscroll = CalcHScrollPlaneA(ScanLine);
int vscroll = VSRAM[0] & 0x3FF;
// Calculate window dimensions
int startWindowScanline, endWindowScanline;
int startWindowPixel, endWindowPixel;
CalculateWindowScanlines(out startWindowScanline, out endWindowScanline);
CalculateWindowPosition(out startWindowPixel, out endWindowPixel);
// Render scanline
if (ScanLine >= startWindowScanline && ScanLine < endWindowScanline) // Window takes up whole scanline
{
RenderScrollAScanline(0, 0, NameTableAddrWindow, 0, FrameWidth, true);
}
else if (startWindowPixel != -1) // Window takes up partial scanline
{
if (startWindowPixel == 0) // Window grows from left side
{
RenderScrollAScanline(0, 0, NameTableAddrWindow, 0, endWindowPixel, true);
RenderScrollAScanline(hscroll, vscroll, NameTableAddrA, endWindowPixel, FrameWidth, false);
}
else // Window grows from right side
{
RenderScrollAScanline(hscroll, vscroll, NameTableAddrA, 0, startWindowPixel, false);
RenderScrollAScanline(0, 0, NameTableAddrWindow, startWindowPixel, FrameWidth, true);
}
}
else // No window this scanline
{
RenderScrollAScanline(hscroll, vscroll, NameTableAddrA, 0, FrameWidth, false);
}
}
void RenderScrollATwoCellVScroll()
{
// Calculate scroll offsets
int hscroll = CalcHScrollPlaneA(ScanLine);
// Calculate window dimensions
int startWindowScanline, endWindowScanline;
int startWindowPixel, endWindowPixel;
CalculateWindowScanlines(out startWindowScanline, out endWindowScanline);
CalculateWindowPosition(out startWindowPixel, out endWindowPixel);
// Render scanline
if (ScanLine >= startWindowScanline && ScanLine < endWindowScanline) // Window takes up whole scanline
{
RenderScrollAScanline(0, 0, NameTableAddrWindow, 0, FrameWidth, true);
}
else if (startWindowPixel != -1) // Window takes up partial scanline
{
if (startWindowPixel == 0) // Window grows from left side
{
RenderScrollAScanline(0, 0, NameTableAddrWindow, 0, endWindowPixel, true);
RenderScrollAScanlineTwoCellVScroll(hscroll, NameTableAddrA, endWindowPixel, FrameWidth, false);
}
else // Window grows from right side
{
RenderScrollAScanlineTwoCellVScroll(hscroll, NameTableAddrA, 0, startWindowPixel, false);
RenderScrollAScanline(0, 0, NameTableAddrWindow, startWindowPixel, FrameWidth, true);
}
}
else // No window this scanline
{
RenderScrollAScanlineTwoCellVScroll(hscroll, NameTableAddrA, 0, FrameWidth, false);
}
}
void RenderScrollB()
{
int bgColor = BackgroundColor;
int xScroll = CalcHScrollPlaneB(ScanLine);
int yScroll = VSRAM[1] & 0x3FF;
const int lowPriority = 1;
const int highPriority = 4;
int yTile = ((ScanLine + yScroll) / 8) % NameTableHeight;
// this is hellllla slow. but not optimizing until we implement & understand
// all scrolling modes, shadow & hilight, etc.
// in thinking about this, you could convince me to optimize the PCE background renderer now.
// Its way simple in comparison. But the PCE sprite renderer is way worse than gen.
for (int x = 0; x < FrameWidth; x++)
{
int xTile = Math.Abs(((x + (1024 - xScroll)) / 8) % NameTableWidth);
int xOfs = Math.Abs((x + (1024 - xScroll)) & 7);
int yOfs = (ScanLine + yScroll) % 8;
int cellOfs = NameTableAddrB + (yTile * NameTableWidth * 2) + (xTile * 2);
int nameTableEntry = VRAM[cellOfs] | (VRAM[cellOfs + 1] << 8);
int patternNo = nameTableEntry & 0x7FF;
bool hFlip = ((nameTableEntry >> 11) & 1) != 0;
bool vFlip = ((nameTableEntry >> 12) & 1) != 0;
bool priority = ((nameTableEntry >> 15) & 1) != 0;
int palette = (nameTableEntry >> 13) & 3;
if (priority && PriorityBuffer[x] >= highPriority) continue;
if (!priority && PriorityBuffer[x] >= lowPriority) continue;
if (vFlip) yOfs = 7 - yOfs;
if (hFlip) xOfs = 7 - xOfs;
int texel = PatternBuffer[(patternNo * 64) + (yOfs * 8) + (xOfs)];
int pixel = Palette[(palette * 16) + texel];
if (texel != 0)
{
FrameBuffer[(ScanLine * FrameWidth) + x] = pixel;
PriorityBuffer[x] = (byte)(priority ? highPriority : lowPriority);
}
else
{
FrameBuffer[(ScanLine * FrameWidth) + x] = bgColor;
}
}
}
void RenderScrollBTwoCellVScroll()
{
int bgColor = BackgroundColor;
int xScroll = CalcHScrollPlaneB(ScanLine);
int fineHScroll = xScroll & 15;
const int lowPriority = 1;
const int highPriority = 4;
for (int x = 0; x < FrameWidth; x++)
{
int vsramUnitOffset = ((x - fineHScroll) / 16) % 40;
int yScroll = VSRAM[(vsramUnitOffset * 2) + 1] & 0x3FF;
int yTile = ((ScanLine + yScroll) / 8) % NameTableHeight;
int xTile = Math.Abs(((x + (1024 - xScroll)) / 8) % NameTableWidth);
int xOfs = Math.Abs((x + (1024 - xScroll)) & 7);
int yOfs = (ScanLine + yScroll) % 8;
int cellOfs = NameTableAddrB + (yTile * NameTableWidth * 2) + (xTile * 2);
int nameTableEntry = VRAM[cellOfs] | (VRAM[cellOfs + 1] << 8);
int patternNo = nameTableEntry & 0x7FF;
bool hFlip = ((nameTableEntry >> 11) & 1) != 0;
bool vFlip = ((nameTableEntry >> 12) & 1) != 0;
bool priority = ((nameTableEntry >> 15) & 1) != 0;
int palette = (nameTableEntry >> 13) & 3;
if (priority && PriorityBuffer[x] >= highPriority) continue;
if (!priority && PriorityBuffer[x] >= lowPriority) continue;
if (vFlip) yOfs = 7 - yOfs;
if (hFlip) xOfs = 7 - xOfs;
int texel = PatternBuffer[(patternNo * 64) + (yOfs * 8) + (xOfs)];
int pixel = Palette[(palette * 16) + texel];
if (texel != 0)
{
FrameBuffer[(ScanLine * FrameWidth) + x] = pixel;
PriorityBuffer[x] = (byte)(priority ? highPriority : lowPriority);
}
else
{
FrameBuffer[(ScanLine * FrameWidth) + x] = bgColor;
}
}
}
static readonly int[] SpriteSizeTable = { 8, 16, 24, 32 };
Sprite sprite;
void RenderSpritesScanline()
{
int scanLineBase = ScanLine * FrameWidth;
int processedSprites = 0;
int processedSpritesThisLine = 0;
int processedDotsThisLine = 0;
bool spriteMaskPrecursor = false;
// This is incredibly unoptimized. TODO...
FetchSprite(0);
while (true)
{
if (sprite.Y > ScanLine || sprite.Y + sprite.HeightPixels <= ScanLine)
goto nextSprite;
processedSpritesThisLine++;
processedDotsThisLine += sprite.WidthPixels;
if (sprite.X > -128)
spriteMaskPrecursor = true;
if (sprite.X == -128 && spriteMaskPrecursor)
break; // apply sprite mask
if (sprite.X + sprite.WidthPixels <= 0)
goto nextSprite;
if (sprite.HeightCells == 2)
sprite.HeightCells = 2;
int yline = ScanLine - sprite.Y;
if (sprite.VFlip)
yline = sprite.HeightPixels - 1 - yline;
int paletteBase = sprite.Palette * 16;
if (sprite.HFlip == false)
{
int pattern = sprite.PatternIndex + ((yline / 8));
for (int xi = 0; xi < sprite.WidthPixels; xi++)
{
if (sprite.X + xi < 0 || sprite.X + xi >= FrameWidth)
continue;
if (sprite.Priority == false && PriorityBuffer[sprite.X + xi] >= 3) continue;
if (PriorityBuffer[sprite.X + xi] == 9) continue;
int pixel = PatternBuffer[((pattern + ((xi / 8) * sprite.HeightCells)) * 64) + ((yline & 7) * 8) + (xi & 7)];
if (pixel != 0)
{
FrameBuffer[scanLineBase + sprite.X + xi] = Palette[paletteBase + pixel];
PriorityBuffer[sprite.X + xi] = 9;
}
}
}
else
{ // HFlip
int pattern = sprite.PatternIndex + ((yline / 8)) + (sprite.HeightCells * (sprite.WidthCells - 1));
for (int xi = 0; xi < sprite.WidthPixels; xi++)
{
if (sprite.X + xi < 0 || sprite.X + xi >= FrameWidth)
continue;
if (sprite.Priority == false && PriorityBuffer[sprite.X + xi] >= 3) continue;
if (PriorityBuffer[sprite.X + xi] == 9) continue;
int pixel = PatternBuffer[((pattern + ((-xi / 8) * sprite.HeightCells)) * 64) + ((yline & 7) * 8) + (7 - (xi & 7))];
if (pixel != 0)
{
FrameBuffer[scanLineBase + sprite.X + xi] = Palette[paletteBase + pixel];
PriorityBuffer[sprite.X + xi] = 9;
}
}
}
nextSprite:
if (sprite.Link == 0)
break;
if (++processedSprites >= SpriteLimit)
break;
if (processedSpritesThisLine >= SpritePerLineLimit)
break;
if (processedDotsThisLine >= DotsPerLineLimit)
break;
if (DisplayWidth == 32 && sprite.Link >= 64)
break;
FetchSprite(sprite.Link);
}
}
void FetchSprite(int spriteNo)
{
// Note - X/Y coordinates are 10-bits (3FF) but must be masked to 9-bits (1FF)
// In interlace mode this behavior should change
int SatBase = SpriteAttributeTableAddr + (spriteNo * 8);
sprite.Y = (VRAM[SatBase + 0] | (VRAM[SatBase + 1] << 8) & 0x1FF) - 128;
sprite.X = (VRAM[SatBase + 6] | (VRAM[SatBase + 7] << 8) & 0x1FF) - 128;
sprite.WidthPixels = SpriteSizeTable[(VRAM[SatBase + 3] >> 2) & 3];
sprite.HeightPixels = SpriteSizeTable[VRAM[SatBase + 3] & 3];
sprite.WidthCells = ((VRAM[SatBase + 3] >> 2) & 3) + 1;
sprite.HeightCells = (VRAM[SatBase + 3] & 3) + 1;
sprite.Link = VRAM[SatBase + 2] & 0x7F;
sprite.PatternIndex = (VRAM[SatBase + 4] | (VRAM[SatBase + 5] << 8)) & 0x7FF;
sprite.HFlip = ((VRAM[SatBase + 5] >> 3) & 1) != 0;
sprite.VFlip = ((VRAM[SatBase + 5] >> 4) & 1) != 0;
sprite.Palette = (VRAM[SatBase + 5] >> 5) & 3;
sprite.Priority = ((VRAM[SatBase + 5] >> 7) & 1) != 0;
}
struct Sprite
{
public int X, Y;
public int WidthPixels, HeightPixels;
public int WidthCells, HeightCells;
public int Link;
public int Palette;
public int PatternIndex;
public bool Priority;
public bool HFlip;
public bool VFlip;
}
int CalcHScrollPlaneA(int line)
{
int ofs = 0;
switch (Registers[11] & 3)
{
case 0: ofs = HScrollTableAddr; break;
case 1: ofs = HScrollTableAddr + ((line & 7) * 4); break;
case 2: ofs = HScrollTableAddr + ((line & ~7) * 4); break;
case 3: ofs = HScrollTableAddr + (line * 4); break;
}
int value = VRAM[ofs] | (VRAM[ofs + 1] << 8);
return value & 0x3FF;
}
int CalcHScrollPlaneB(int line)
{
int ofs = 0;
switch (Registers[11] & 3)
{
case 0: ofs = HScrollTableAddr; break;
case 1: ofs = HScrollTableAddr + ((line & 7) * 4); break;
case 2: ofs = HScrollTableAddr + ((line & ~7) * 4); break;
case 3: ofs = HScrollTableAddr + (line * 4); break;
}
int value = VRAM[ofs + 2] | (VRAM[ofs + 3] << 8);
return value & 0x3FF;
}
}
}