mirror of
https://github.com/libretro/snes9x2005.git
synced 2024-11-30 12:00:27 +00:00
634 lines
24 KiB
C
634 lines
24 KiB
C
#include "../copyright"
|
|
|
|
#include <stdlib.h>
|
|
|
|
#include "snes9x.h"
|
|
#include "memmap.h"
|
|
#include "ppu.h"
|
|
|
|
typedef struct
|
|
{
|
|
uint32_t Left;
|
|
uint32_t Right;
|
|
} Band;
|
|
|
|
#define BAND_EMPTY(B) (B.Left >= B.Right)
|
|
#define BANDS_INTERSECT(A,B) ((A.Left >= B.Left && A.Left < B.Right) || (B.Left >= A.Left && B.Left < A.Right))
|
|
#define OR_BANDS(R,A,B) \
|
|
{ \
|
|
R.Left = MIN(A.Left, B.Left); \
|
|
R.Right = MAX(A.Right, B.Right); \
|
|
}
|
|
|
|
#define AND_BANDS(R,A,B) \
|
|
{ \
|
|
R.Left = MAX(A.Left, B.Left); \
|
|
R.Right = MIN(A.Right, B.Right); \
|
|
}
|
|
|
|
static int32_t IntCompare(const void* d1, const void* d2)
|
|
{
|
|
return *(uint32_t*) d1 - *(uint32_t*) d2;
|
|
}
|
|
|
|
static int32_t BandCompare(const void* d1, const void* d2)
|
|
{
|
|
return ((Band*) d1)->Left - ((Band*) d2)->Left;
|
|
}
|
|
|
|
void ComputeClipWindows()
|
|
{
|
|
ClipData* pClip = &IPPU.Clip [0];
|
|
int32_t c, w, i;
|
|
|
|
// Loop around the main screen then the sub-screen.
|
|
for (c = 0; c < 2; c++, pClip++)
|
|
{
|
|
// Loop around the colour window then a clip window for each of the
|
|
// background layers.
|
|
for (w = 5; w >= 0; w--)
|
|
{
|
|
pClip->Count[w] = 0;
|
|
|
|
if (w == 5) // The colour window...
|
|
{
|
|
if (c == 0) // ... on the main screen
|
|
{
|
|
if ((Memory.FillRAM [0x2130] & 0xc0) == 0xc0)
|
|
{
|
|
// The whole of the main screen is switched off, completely clip everything.
|
|
for (i = 0; i < 6; i++)
|
|
{
|
|
IPPU.Clip [c].Count [i] = 1;
|
|
IPPU.Clip [c].Left [0][i] = 1;
|
|
IPPU.Clip [c].Right [0][i] = 0;
|
|
}
|
|
continue;
|
|
}
|
|
else if ((Memory.FillRAM [0x2130] & 0xc0) == 0x00)
|
|
continue;
|
|
}
|
|
else if ((Memory.FillRAM [0x2130] & 0x30) == 0x30) // .. colour window on the sub-screen.
|
|
{
|
|
// The sub-screen is switched off, completely clip everything.
|
|
int32_t i;
|
|
for (i = 0; i < 6; i++)
|
|
{
|
|
IPPU.Clip [1].Count [i] = 1;
|
|
IPPU.Clip [1].Left [0][i] = 1;
|
|
IPPU.Clip [1].Right [0][i] = 0;
|
|
}
|
|
return;
|
|
}
|
|
else if ((Memory.FillRAM [0x2130] & 0x30) == 0x00)
|
|
continue;
|
|
}
|
|
|
|
if (w == 5 || pClip->Count [5] || (Memory.FillRAM [0x212c + c] & Memory.FillRAM [0x212e + c] & (1 << w)))
|
|
{
|
|
Band Win1[3];
|
|
Band Win2[3];
|
|
uint32_t Window1Enabled = 0;
|
|
uint32_t Window2Enabled = 0;
|
|
bool invert = (w == 5 && ((c == 1 && (Memory.FillRAM [0x2130] & 0x30) == 0x10) || (c == 0 && (Memory.FillRAM [0x2130] & 0xc0) == 0x40)));
|
|
|
|
if (w == 5 || (Memory.FillRAM [0x212c + c] & Memory.FillRAM [0x212e + c] & (1 << w)))
|
|
{
|
|
if (PPU.ClipWindow1Enable [w])
|
|
{
|
|
if (!PPU.ClipWindow1Inside [w])
|
|
{
|
|
Win1[Window1Enabled].Left = PPU.Window1Left;
|
|
Win1[Window1Enabled++].Right = PPU.Window1Right + 1;
|
|
}
|
|
else if (PPU.Window1Left <= PPU.Window1Right)
|
|
{
|
|
if (PPU.Window1Left > 0)
|
|
{
|
|
Win1[Window1Enabled].Left = 0;
|
|
Win1[Window1Enabled++].Right = PPU.Window1Left;
|
|
}
|
|
if (PPU.Window1Right < 255)
|
|
{
|
|
Win1[Window1Enabled].Left = PPU.Window1Right + 1;
|
|
Win1[Window1Enabled++].Right = 256;
|
|
}
|
|
if (Window1Enabled == 0)
|
|
{
|
|
Win1[Window1Enabled].Left = 1;
|
|
Win1[Window1Enabled++].Right = 0;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// 'outside' a window with no range -
|
|
// appears to be the whole screen.
|
|
Win1[Window1Enabled].Left = 0;
|
|
Win1[Window1Enabled++].Right = 256;
|
|
}
|
|
}
|
|
if (PPU.ClipWindow2Enable [w])
|
|
{
|
|
if (!PPU.ClipWindow2Inside [w])
|
|
{
|
|
Win2[Window2Enabled].Left = PPU.Window2Left;
|
|
Win2[Window2Enabled++].Right = PPU.Window2Right + 1;
|
|
}
|
|
else
|
|
{
|
|
if (PPU.Window2Left <= PPU.Window2Right)
|
|
{
|
|
if (PPU.Window2Left > 0)
|
|
{
|
|
Win2[Window2Enabled].Left = 0;
|
|
Win2[Window2Enabled++].Right = PPU.Window2Left;
|
|
}
|
|
if (PPU.Window2Right < 255)
|
|
{
|
|
Win2[Window2Enabled].Left = PPU.Window2Right + 1;
|
|
Win2[Window2Enabled++].Right = 256;
|
|
}
|
|
if (Window2Enabled == 0)
|
|
{
|
|
Win2[Window2Enabled].Left = 1;
|
|
Win2[Window2Enabled++].Right = 0;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
Win2[Window2Enabled].Left = 0;
|
|
Win2[Window2Enabled++].Right = 256;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (Window1Enabled && Window2Enabled)
|
|
{
|
|
// Overlap logic
|
|
//
|
|
// Each window will be in one of three states:
|
|
// 1. <no range> (Left > Right. One band)
|
|
// 2. | ---------------- | (Left >= 0, Right <= 255, Left <= Right. One band)
|
|
// 3. |------------ ----------| (Left1 == 0, Right1 < Left2; Left2 > Right1, Right2 == 255. Two bands)
|
|
Band Bands [6];
|
|
int32_t B = 0;
|
|
switch (PPU.ClipWindowOverlapLogic [w] ^ 1)
|
|
{
|
|
case CLIP_OR:
|
|
if (Window1Enabled == 1)
|
|
{
|
|
if (BAND_EMPTY(Win1[0]))
|
|
{
|
|
B = Window2Enabled;
|
|
// memmove converted: Different stack allocations [Neb]
|
|
memcpy(Bands, Win2, sizeof(Win2[0]) * Window2Enabled);
|
|
}
|
|
else
|
|
{
|
|
if (Window2Enabled == 1)
|
|
{
|
|
if (BAND_EMPTY(Win2[0]))
|
|
Bands[B++] = Win1[0];
|
|
else if (BANDS_INTERSECT(Win1[0], Win2[0]))
|
|
{
|
|
OR_BANDS(Bands[0], Win1[0], Win2[0])
|
|
B = 1;
|
|
}
|
|
else
|
|
{
|
|
Bands[B++] = Win1[0];
|
|
Bands[B++] = Win2[0];
|
|
}
|
|
}
|
|
else if (BANDS_INTERSECT(Win1[0], Win2[0]))
|
|
{
|
|
OR_BANDS(Bands[0], Win1[0], Win2[0])
|
|
if (BANDS_INTERSECT(Win1[0], Win2[1]))
|
|
OR_BANDS(Bands[1], Win1[0], Win2[1])
|
|
else
|
|
Bands[1] = Win2[1];
|
|
B = 1;
|
|
if (BANDS_INTERSECT(Bands[0], Bands[1]))
|
|
OR_BANDS(Bands[0], Bands[0], Bands[1])
|
|
else
|
|
B = 2;
|
|
}
|
|
else if (BANDS_INTERSECT(Win1[0], Win2[1]))
|
|
{
|
|
Bands[B++] = Win2[0];
|
|
OR_BANDS(Bands[B], Win1[0], Win2[1]);
|
|
B++;
|
|
}
|
|
else
|
|
{
|
|
Bands[0] = Win2[0];
|
|
Bands[1] = Win1[0];
|
|
Bands[2] = Win2[1];
|
|
B = 3;
|
|
}
|
|
}
|
|
}
|
|
else if (Window2Enabled == 1)
|
|
{
|
|
if (BAND_EMPTY(Win2[0]))
|
|
{
|
|
// Window 2 defines an empty range - just
|
|
// use window 1 as the clipping (which
|
|
// could also be empty).
|
|
B = Window1Enabled;
|
|
// memmove converted: Different stack allocations [Neb]
|
|
memcpy(Bands, Win1, sizeof(Win1[0]) * Window1Enabled);
|
|
}
|
|
else
|
|
{
|
|
// Window 1 has two bands and Window 2 has one.
|
|
// Neither is an empty region.
|
|
if (BANDS_INTERSECT(Win2[0], Win1[0]))
|
|
{
|
|
OR_BANDS(Bands[0], Win2[0], Win1[0])
|
|
if (BANDS_INTERSECT(Win2[0], Win1[1]))
|
|
OR_BANDS(Bands[1], Win2[0], Win1[1])
|
|
else
|
|
Bands[1] = Win1[1];
|
|
B = 1;
|
|
if (BANDS_INTERSECT(Bands[0], Bands[1]))
|
|
OR_BANDS(Bands[0], Bands[0], Bands[1])
|
|
else
|
|
B = 2;
|
|
}
|
|
else if (BANDS_INTERSECT(Win2[0], Win1[1]))
|
|
{
|
|
Bands[B++] = Win1[0];
|
|
OR_BANDS(Bands[B], Win2[0], Win1[1]);
|
|
B++;
|
|
}
|
|
else
|
|
{
|
|
Bands[0] = Win1[0];
|
|
Bands[1] = Win2[0];
|
|
Bands[2] = Win1[1];
|
|
B = 3;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// Both windows have two bands
|
|
OR_BANDS(Bands[0], Win1[0], Win2[0]);
|
|
OR_BANDS(Bands[1], Win1[1], Win2[1]);
|
|
B = 1;
|
|
if (BANDS_INTERSECT(Bands[0], Bands[1]))
|
|
OR_BANDS(Bands[0], Bands[0], Bands[1])
|
|
else
|
|
B = 2;
|
|
}
|
|
break;
|
|
case CLIP_AND:
|
|
if (Window1Enabled == 1)
|
|
{
|
|
// Window 1 has one band
|
|
if (BAND_EMPTY(Win1[0]))
|
|
Bands [B++] = Win1[0];
|
|
else if (Window2Enabled == 1)
|
|
{
|
|
if (BAND_EMPTY(Win2[0]))
|
|
Bands [B++] = Win2[0];
|
|
else
|
|
{
|
|
AND_BANDS(Bands[0], Win1[0], Win2[0]);
|
|
B = 1;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
AND_BANDS(Bands[0], Win1[0], Win2[0]);
|
|
AND_BANDS(Bands[1], Win1[0], Win2[1]);
|
|
B = 2;
|
|
}
|
|
}
|
|
else if (Window2Enabled == 1)
|
|
{
|
|
if (BAND_EMPTY(Win2[0]))
|
|
Bands[B++] = Win2[0];
|
|
else
|
|
{
|
|
// Window 1 has two bands.
|
|
AND_BANDS(Bands[0], Win1[0], Win2[0]);
|
|
AND_BANDS(Bands[1], Win1[1], Win2[0]);
|
|
B = 2;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// Both windows have two bands.
|
|
AND_BANDS(Bands[0], Win1[0], Win2[0]);
|
|
AND_BANDS(Bands[1], Win1[1], Win2[1]);
|
|
B = 2;
|
|
if (BANDS_INTERSECT(Win1[0], Win2[1]))
|
|
{
|
|
AND_BANDS(Bands[2], Win1[0], Win2[1]);
|
|
B = 3;
|
|
}
|
|
else if (BANDS_INTERSECT(Win1[1], Win2[0]))
|
|
{
|
|
AND_BANDS(Bands[2], Win1[1], Win2[0]);
|
|
B = 3;
|
|
}
|
|
}
|
|
break;
|
|
case CLIP_XNOR:
|
|
invert = !invert;
|
|
// Fall...
|
|
case CLIP_XOR:
|
|
if (Window1Enabled == 1 && BAND_EMPTY(Win1[0]))
|
|
{
|
|
B = Window2Enabled;
|
|
// memmove converted: Different stack allocations [Neb]
|
|
memcpy(Bands, Win2, sizeof(Win2[0]) * Window2Enabled);
|
|
}
|
|
else if (Window2Enabled == 1 && BAND_EMPTY(Win2[0]))
|
|
{
|
|
B = Window1Enabled;
|
|
// memmove converted: Different stack allocations [Neb]
|
|
memcpy(Bands, Win1, sizeof(Win1[0]) * Window1Enabled);
|
|
}
|
|
else
|
|
{
|
|
uint32_t p = 0;
|
|
uint32_t points [10];
|
|
uint32_t i;
|
|
|
|
invert = !invert;
|
|
// Build an array of points (window edges)
|
|
points [p++] = 0;
|
|
for (i = 0; i < Window1Enabled; i++)
|
|
{
|
|
points [p++] = Win1[i].Left;
|
|
points [p++] = Win1[i].Right;
|
|
}
|
|
for (i = 0; i < Window2Enabled; i++)
|
|
{
|
|
points [p++] = Win2[i].Left;
|
|
points [p++] = Win2[i].Right;
|
|
}
|
|
points [p++] = 256;
|
|
// Sort them
|
|
qsort((void*) points, p, sizeof(points [0]), IntCompare);
|
|
for (i = 0; i < p; i += 2)
|
|
{
|
|
if (points [i] == points [i + 1])
|
|
continue;
|
|
Bands [B].Left = points [i];
|
|
while (i + 2 < p && points [i + 1] == points [i + 2])
|
|
i += 2;
|
|
Bands [B++].Right = points [i + 1];
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
if (invert)
|
|
{
|
|
int32_t b;
|
|
int32_t j = 0;
|
|
int32_t empty_band_count = 0;
|
|
|
|
// First remove all empty bands from the list.
|
|
for (b = 0; b < B; b++)
|
|
{
|
|
if (!BAND_EMPTY(Bands[b]))
|
|
{
|
|
if (b != j)
|
|
Bands[j] = Bands[b];
|
|
j++;
|
|
}
|
|
else
|
|
empty_band_count++;
|
|
}
|
|
|
|
if (j > 0)
|
|
{
|
|
if (j == 1)
|
|
{
|
|
j = 0;
|
|
// Easy case to deal with, so special case it.
|
|
if (Bands[0].Left > 0)
|
|
{
|
|
pClip->Left[j][w] = 0;
|
|
pClip->Right[j++][w] = Bands[0].Left + 1;
|
|
}
|
|
if (Bands[0].Right < 256)
|
|
{
|
|
pClip->Left[j][w] = Bands[0].Right;
|
|
pClip->Right[j++][w] = 256;
|
|
}
|
|
if (j == 0)
|
|
{
|
|
pClip->Left[j][w] = 1;
|
|
pClip->Right[j++][w] = 0;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// Now sort the bands into order
|
|
B = j;
|
|
qsort((void*) Bands, B, sizeof(Bands [0]), BandCompare);
|
|
|
|
// Now invert the area the bands cover
|
|
j = 0;
|
|
for (b = 0; b < B; b++)
|
|
{
|
|
if (b == 0 && Bands[b].Left > 0)
|
|
{
|
|
pClip->Left[j][w] = 0;
|
|
pClip->Right[j++][w] = Bands[b].Left + 1;
|
|
}
|
|
else if (b == B - 1 && Bands[b].Right < 256)
|
|
{
|
|
pClip->Left[j][w] = Bands[b].Right;
|
|
pClip->Right[j++][w] = 256;
|
|
}
|
|
if (b < B - 1)
|
|
{
|
|
pClip->Left[j][w] = Bands[b].Right;
|
|
pClip->Right[j++][w] = Bands[b + 1].Left + 1;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// Inverting a window that consisted of only
|
|
// empty bands is the whole width of the screen.
|
|
// Needed for Mario Kart's rear-view mirror display.
|
|
if (empty_band_count)
|
|
{
|
|
pClip->Left[j][w] = 0;
|
|
pClip->Right[j][w] = 256;
|
|
j++;
|
|
}
|
|
}
|
|
pClip->Count[w] = j;
|
|
}
|
|
else
|
|
{
|
|
int32_t j;
|
|
for (j = 0; j < B; j++)
|
|
{
|
|
pClip->Left[j][w] = Bands[j].Left;
|
|
pClip->Right[j][w] = Bands[j].Right;
|
|
}
|
|
pClip->Count [w] = B;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// Only one window enabled so no need to perform
|
|
// complex overlap logic...
|
|
if (Window1Enabled)
|
|
{
|
|
if (invert)
|
|
{
|
|
int32_t j = 0;
|
|
|
|
if (Window1Enabled == 1)
|
|
{
|
|
if (Win1[0].Left <= Win1[0].Right)
|
|
{
|
|
if (Win1[0].Left > 0)
|
|
{
|
|
pClip->Left[j][w] = 0;
|
|
pClip->Right[j++][w] = Win1[0].Left;
|
|
}
|
|
if (Win1[0].Right < 256)
|
|
{
|
|
pClip->Left[j][w] = Win1[0].Right;
|
|
pClip->Right[j++][w] = 256;
|
|
}
|
|
if (j == 0)
|
|
{
|
|
pClip->Left[j][w] = 1;
|
|
pClip->Right[j++][w] = 0;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
pClip->Left[j][w] = 0;
|
|
pClip->Right[j++][w] = 256;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
pClip->Left [j][w] = Win1[0].Right;
|
|
pClip->Right[j++][w] = Win1[1].Left;
|
|
}
|
|
pClip->Count [w] = j;
|
|
}
|
|
else
|
|
{
|
|
uint32_t j;
|
|
for (j = 0; j < Window1Enabled; j++)
|
|
{
|
|
pClip->Left [j][w] = Win1[j].Left;
|
|
pClip->Right [j][w] = Win1[j].Right;
|
|
}
|
|
pClip->Count [w] = Window1Enabled;
|
|
}
|
|
}
|
|
else if (Window2Enabled)
|
|
{
|
|
if (invert)
|
|
{
|
|
int32_t j = 0;
|
|
if (Window2Enabled == 1)
|
|
{
|
|
if (Win2[0].Left <= Win2[0].Right)
|
|
{
|
|
if (Win2[0].Left > 0)
|
|
{
|
|
pClip->Left[j][w] = 0;
|
|
pClip->Right[j++][w] = Win2[0].Left;
|
|
}
|
|
if (Win2[0].Right < 256)
|
|
{
|
|
pClip->Left[j][w] = Win2[0].Right;
|
|
pClip->Right[j++][w] = 256;
|
|
}
|
|
if (j == 0)
|
|
{
|
|
pClip->Left[j][w] = 1;
|
|
pClip->Right[j++][w] = 0;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
pClip->Left[j][w] = 0;
|
|
pClip->Right[j++][w] = 256;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
pClip->Left [j][w] = Win2[0].Right;
|
|
pClip->Right[j++][w] = Win2[1].Left + 1;
|
|
}
|
|
pClip->Count [w] = j;
|
|
}
|
|
else
|
|
{
|
|
uint32_t j;
|
|
for (j = 0; j < Window2Enabled; j++)
|
|
{
|
|
pClip->Left [j][w] = Win2[j].Left;
|
|
pClip->Right [j][w] = Win2[j].Right;
|
|
}
|
|
pClip->Count [w] = Window2Enabled;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (w != 5 && pClip->Count [5])
|
|
{
|
|
// Colour window enabled. Set the
|
|
// clip windows for all remaining backgrounds to be
|
|
// the same as the colour window.
|
|
if (pClip->Count [w] == 0)
|
|
{
|
|
uint32_t i;
|
|
pClip->Count [w] = pClip->Count [5];
|
|
for (i = 0; i < pClip->Count [w]; i++)
|
|
{
|
|
pClip->Left [i][w] = pClip->Left [i][5];
|
|
pClip->Right [i][w] = pClip->Right [i][5];
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// Intersect the colour window with the bg's
|
|
// own clip window.
|
|
uint32_t i, j;
|
|
for (i = 0; i < pClip->Count [w]; i++)
|
|
{
|
|
for (j = 0; j < pClip->Count [5]; j++)
|
|
{
|
|
if ((pClip->Left[i][w] >= pClip->Left[j][5] &&
|
|
pClip->Left[i][w] < pClip->Right[j][5]) ||
|
|
(pClip->Left[j][5] >= pClip->Left[i][w] &&
|
|
pClip->Left[j][5] < pClip->Right[i][w]))
|
|
{
|
|
// Found an intersection!
|
|
pClip->Left[i][w] = MAX(pClip->Left[i][w], pClip->Left[j][5]);
|
|
pClip->Right[i][w] = MIN(pClip->Right[i][w], pClip->Right[j][5]);
|
|
goto Clip_ok;
|
|
}
|
|
}
|
|
// no intersection, nullify it
|
|
pClip->Left[i][w] = 1;
|
|
pClip->Right[i][w] = 0;
|
|
Clip_ok:;
|
|
}
|
|
}
|
|
}
|
|
} // if (w == 5 || pClip->Count [5] ...
|
|
} // for (w...
|
|
} // for (c...
|
|
}
|