#include "memmap.h"
#include "ppu.h"
#include "cpuexec.h"
-#include "display.h"
#include "gfx.h"
#include "apu.h"
#include "cheats.h"
#define M7 19
#define M8 19
-void ComputeClipWindows ();
-static void S9xDisplayFrameRate ();
-static void S9xDisplayString (const char *string);
+#define GFX_PIX_SIZE 1
+
+void ComputeClipWindows();
+static void S9xDisplayFrameRate();
+static void S9xDisplayString(const char *string);
extern uint8 BitShifts[8][4];
extern uint8 TileShifts[8][4];
#define BLACK BUILD_PIXEL(0,0,0)
-bool8_32 S9xGraphicsInit ()
+bool8 S9xGraphicsInit ()
{
register uint32 PixelOdd = 1;
register uint32 PixelEven = 2;
PPU.BG_Forced = 0;
IPPU.OBJChanged = TRUE;
- if (Settings.Transparency)
- Settings.SixteenBit = TRUE;
- IPPU.DirectColourMapsNeedRebuild = TRUE;
- GFX.PixSize = 1;
- if (Settings.SixteenBit)
- {
+ IPPU.DirectColourMapsNeedRebuild = TRUE;
DrawTilePtr = DrawTile16;
DrawClippedTilePtr = DrawClippedTile16;
DrawLargePixelPtr = DrawLargePixel16;
DrawHiResTilePtr= DrawHiResTile16;
DrawHiResClippedTilePtr = DrawHiResClippedTile16;
- GFX.PPL = GFX.Pitch >> 1;
- GFX.PPLx2 = GFX.Pitch;
- }
- else
- {
- DrawTilePtr = DrawTile;
- DrawClippedTilePtr = DrawClippedTile;
- DrawLargePixelPtr = DrawLargePixel;
- DrawHiResTilePtr = DrawTile;
- DrawHiResClippedTilePtr = DrawClippedTile;
- GFX.PPL = GFX.Pitch;
- GFX.PPLx2 = GFX.Pitch * 2;
- }
- S9xFixColourBrightness ();
+ S9xFixColourBrightness();
- if (Settings.SixteenBit)
- {
if (!(GFX.X2 = (uint16 *) malloc (sizeof (uint16) * 0x10000)))
return (FALSE);
}
}
}
- }
- else
- {
- GFX.X2 = NULL;
- GFX.ZERO_OR_X2 = NULL;
- GFX.ZERO = NULL;
- }
- return (TRUE);
+ return TRUE;
}
void S9xGraphicsDeinit (void)
IPPU.DirectColourMapsNeedRebuild = FALSE;
}
-void S9xStartScreenRefresh ()
+void S9xStartScreenRefresh()
{
if (GFX.InfoStringTimeout > 0 && --GFX.InfoStringTimeout == 0) {
free(GFX.InfoString);
GFX.InfoString = NULL;
}
- if (IPPU.RenderThisFrame)
- {
-#ifndef _SNESPPC
- if (!S9xInitUpdate ())
- {
- IPPU.RenderThisFrame = FALSE;
- return;
- }
-#endif
- IPPU.RenderedFramesCount++;
- IPPU.PreviousLine = IPPU.CurrentLine = 0;
- IPPU.MaxBrightness = PPU.Brightness;
- IPPU.LatchedBlanking = PPU.ForcedBlanking;
- IPPU.LatchedInterlace = (Memory.FillRAM[0x2133] & 1);
- IPPU.RenderedScreenWidth = 256;
- IPPU.RenderedScreenHeight = PPU.ScreenHeight;
- IPPU.DoubleWidthPixels = FALSE;
- GFX.Pitch2 = GFX.Pitch = GFX.RealPitch;
- GFX.PPL = GFX.PPLx2 >> 1;
- PPU.RecomputeClipWindows = TRUE;
- GFX.DepthDelta = GFX.SubZBuffer - GFX.ZBuffer;
- GFX.Delta = (GFX.SubScreen - GFX.Screen) >> 1;
- }
- if (++IPPU.FrameCount % Memory.ROMFramesPerSecond == 0)
- {
- IPPU.DisplayedRenderedFrameCount = IPPU.RenderedFramesCount;
- IPPU.RenderedFramesCount = 0;
- IPPU.FrameCount = 0;
+ IPPU.FrameCount++;
+
+ if (IPPU.RenderThisFrame) {
+ if (!S9xInitUpdate()) {
+ IPPU.RenderThisFrame = FALSE;
+ return;
+ }
+
+ IPPU.PreviousLine = IPPU.CurrentLine = 0;
+ IPPU.MaxBrightness = PPU.Brightness;
+ IPPU.LatchedBlanking = PPU.ForcedBlanking;
+ IPPU.LatchedInterlace = (Memory.FillRAM[0x2133] & 1);
+ IPPU.RenderedScreenWidth = 256;
+ IPPU.RenderedScreenHeight = PPU.ScreenHeight;
+ IPPU.DoubleWidthPixels = FALSE;
+
+ PPU.RecomputeClipWindows = TRUE;
}
}
void S9xEndScreenRefresh()
{
- IPPU.HDMAStarted = FALSE;
+ IPPU.HDMAStarted = FALSE;
-//RC
- if (IPPU.RenderThisFrame)
- {
- FLUSH_REDRAW ();
- if (IPPU.ColorsChanged)
- {
- uint32 saved = PPU.CGDATA[0];
- if (!Settings.SixteenBit)
- {
- // Hack for Super Mario World - to get its sky blue
- // (It uses Fixed colour addition on the backdrop colour)
- if (!(Memory.FillRAM [0x2131] & 0x80) &&
- (Memory.FillRAM[0x2131] & 0x20) &&
- (PPU.FixedColourRed || PPU.FixedColourGreen ||
- PPU.FixedColourBlue))
- {
- PPU.CGDATA[0] = PPU.FixedColourRed |
- (PPU.FixedColourGreen << 5) |
- (PPU.FixedColourBlue << 10);
- }
- }
- IPPU.ColorsChanged = FALSE;
-
- S9xSetPalette ();
+ if (IPPU.RenderThisFrame) {
+ FLUSH_REDRAW ();
- PPU.CGDATA[0] = saved;
- }
- GFX.Pitch = GFX.Pitch2 = GFX.RealPitch;
- GFX.PPL = GFX.PPLx2 >> 1;
+ IPPU.RenderedFramesCount++;
+
+ if (IPPU.ColorsChanged) {
+ IPPU.ColorsChanged = FALSE;
+ }
+
+ if (Settings.DisplayFrameRate) {
+ S9xDisplayFrameRate();
+ }
- if (Settings.DisplayFrameRate)
- S9xDisplayFrameRate ();
- if (GFX.InfoString)
- S9xDisplayString (GFX.InfoString);
+ if (GFX.InfoString) {
+ S9xDisplayString(GFX.InfoString);
+ }
- S9xDeinitUpdate (IPPU.RenderedScreenWidth, IPPU.RenderedScreenHeight,
- Settings.SixteenBit);
+ S9xDeinitUpdate(IPPU.RenderedScreenWidth, IPPU.RenderedScreenHeight);
}
+
#ifndef RC_OPTIMIZED
- S9xApplyCheats ();
+ S9xApplyCheats ();
#endif
-
#ifdef DEBUGGER
if (CPU.Flags & FRAME_ADVANCE_FLAG)
{
va_end(ap);
}
-INLINE void SelectTileRenderer (bool8_32 normal)
+static inline void SelectTileRenderer (bool normal)
{
if (normal)
{
IPPU.OBJChanged = FALSE;
}
-void DrawOBJS (bool8_32 OnMain = FALSE, uint8 D = 0)
+static void DrawOBJS (bool OnMain = FALSE, uint8 D = 0)
{
uint32 O;
uint32 BaseTile, Tile;
BG.NameSelect = PPU.OBJNameSelect;
BG.DirectColourMode = FALSE;
- GFX.PixSize = 1;
-
GFX.Z1 = D + 2;
int I = 0;
{
Tile += ((Left - PPU.OBJ[S].HPos) >> 3) * TileInc;
Middle -= (Left - PPU.OBJ[S].HPos) >> 3;
- O += Left * GFX.PixSize;
+ O += Left * GFX_PIX_SIZE;
if ((Offset = (Left - PPU.OBJ[S].HPos) & 7))
{
- O -= Offset * GFX.PixSize;
+ O -= Offset * GFX_PIX_SIZE;
int W = 8 - Offset;
int Width = Right - Left;
if (W > Width)
continue;
Tile += TileInc;
Middle--;
- O += 8 * GFX.PixSize;
+ O += 8 * GFX_PIX_SIZE;
}
}
else
- O += PPU.OBJ[S].HPos * GFX.PixSize;
+ O += PPU.OBJ[S].HPos * GFX_PIX_SIZE;
if (PPU.OBJ[S].HPos + Size >= Right)
{
else
Offset = 0;
- for (int X = 0; X < Middle; X++, O += 8 * GFX.PixSize,
+ for (int X = 0; X < Middle; X++, O += 8 * GFX_PIX_SIZE,
Tile += TileInc)
{
(*DrawTilePtr) (Tile, O, TileLine, LineCount);
}
}
-void DrawBackgroundMosaic (uint32 BGMode, uint32 bg, uint8 Z1, uint8 Z2)
+static void DrawBackgroundMosaic (uint32 BGMode, uint32 bg, uint8 Z1, uint8 Z2)
{
CHECK_SOUND();
HPos = HOffset + Left;
PixWidth = PPU.Mosaic - r;
}
- uint32 s = Y * GFX.PPL + Left * GFX.PixSize;
+ uint32 s = Y * GFX.PPL + Left * GFX_PIX_SIZE;
for (uint32 x = Left; x < Right; x += PixWidth,
- s += PixWidth * GFX.PixSize,
+ s += PixWidth * GFX_PIX_SIZE,
HPos += PixWidth, PixWidth = PPU.Mosaic)
{
uint32 Quot = (HPos & OffsetMask) >> 3;
}
}
-void DrawBackgroundOffset (uint32 BGMode, uint32 bg, uint8 Z1, uint8 Z2)
+static void DrawBackgroundOffset (uint32 BGMode, uint32 bg, uint8 Z1, uint8 Z2)
{
CHECK_SOUND();
uint32 TotalCount = 0;
uint32 MaxCount = 8;
- uint32 s = Left * GFX.PixSize + Y * GFX.PPL;
- bool8_32 left_hand_edge = (Left == 0);
+ uint32 s = Left * GFX_PIX_SIZE + Y * GFX.PPL;
+ bool left_hand_edge = (Left == 0);
Width = Right - Left;
if (Left & 7)
// for the tile at the left-hand edge of the screen.
VOffset = LineData [Y].BG[bg].VOffset;
HOffset = LineHOffset;
- left_hand_edge = FALSE;
+ left_hand_edge = false;
}
else
{
if (Count > MaxCount)
Count = MaxCount;
- s -= Offset * GFX.PixSize;
+ s -= Offset * GFX_PIX_SIZE;
Tile = READ_2BYTES(t);
GFX.Z1 = GFX.Z2 = depths [(Tile & 0x2000) >> 13];
Left += Count;
TotalCount += Count;
- s += (Offset + Count) * GFX.PixSize;
+ s += (Offset + Count) * GFX_PIX_SIZE;
MaxCount = 8;
}
}
}
}
-void DrawBackgroundMode5 (uint32 /* BGMODE */, uint32 bg, uint8 Z1, uint8 Z2)
+static void DrawBackgroundMode5 (uint32 /*BGMODE*/, uint32 bg, uint8 Z1, uint8 Z2)
{
CHECK_SOUND();
- GFX.Pitch = GFX.RealPitch;
- GFX.PPL = GFX.PPLx2 >> 1;
- GFX.PixSize = 1;
uint8 depths [2] = {Z1, Z2};
uint32 Tile;
continue;
}
- uint32 s = (Left>>1) * GFX.PixSize + Y * GFX.PPL;
- uint32 HPos = (HOffset + Left * GFX.PixSize) & 0x3ff;
+ intptr_t s = (Left>>1) * GFX_PIX_SIZE + Y * GFX.PPL;
+ uint32 HPos = (HOffset + Left * GFX_PIX_SIZE) & 0x3ff;
uint32 Quot = HPos >> 3;
uint32 Count = 0;
Count = 8 - Offset;
if (Count > Width)
Count = Width;
- if (s) // XXX: Workaround for underflow (Secret of MANA)
- s -= (Offset>>1);
+ s -= (Offset>>1);
Tile = READ_2BYTES (t);
GFX.Z1 = GFX.Z2 = depths [(Tile & 0x2000) >> 13];
}
}
-void DrawBackground (uint32 BGMode, uint32 bg, uint8 Z1, uint8 Z2)
+static void DrawBackground (uint32 BGMode, uint32 bg, uint8 Z1, uint8 Z2)
{
- GFX.PixSize = 1;
-
BG.TileSize = BGSizes [PPU.BG[bg].BGSize];
BG.BitShift = BitShifts[BGMode][bg];
BG.TileShift = TileShifts[BGMode][bg];
continue;
}
- uint32 s = Left * GFX.PixSize + Y * GFX.PPL;
+ intptr_t s = Left * GFX_PIX_SIZE + Y * GFX.PPL;
uint32 HPos = (HOffset + Left) & OffsetMask;
uint32 Quot = HPos >> 3;
Count = 8 - Offset;
if (Count > Width)
Count = Width;
- s -= Offset * GFX.PixSize;
+ s -= Offset * GFX_PIX_SIZE;
Tile = READ_2BYTES(t);
GFX.Z1 = GFX.Z2 = depths [(Tile & 0x2000) >> 13];
t = b1;
}
Quot++;
- s += 8 * GFX.PixSize;
+ s += 8 * GFX_PIX_SIZE;
}
// Middle, unclipped tiles
Count = Width - Count;
int Middle = Count >> 3;
Count &= 7;
- for (int C = Middle; C > 0; s += 8 * GFX.PixSize, Quot++, C--)
+ for (int C = Middle; C > 0; s += 8 * GFX_PIX_SIZE, Quot++, C--)
{
Tile = READ_2BYTES(t);
GFX.Z1 = GFX.Z2 = depths [(Tile & 0x2000) >> 13];
RENDER_BACKGROUND_MODE7_LINE(TYPE,FUNC) \
\
-
-void DrawBGMode7Background (uint8 *Screen, int bg)
-{
- RENDER_BACKGROUND_MODE7 (uint8, (uint8) (b & bmask))
-}
-
-void DrawBGMode7Background16 (uint8 *Screen, int bg)
+static void DrawBGMode7Background16 (uint8 *Screen, int bg)
{
RENDER_BACKGROUND_MODE7 (uint16, GFX.ScreenColors [b & bmask]);
}
-void DrawBGMode7Background16Add (uint8 *Screen, int bg)
+static void DrawBGMode7Background16Add (uint8 *Screen, int bg)
{
RENDER_BACKGROUND_MODE7 (uint16, *(d + GFX.DepthDelta) ?
(*(d + GFX.DepthDelta) != 1 ?
GFX.ScreenColors [b & bmask]);
}
-void DrawBGMode7Background16Add1_2 (uint8 *Screen, int bg)
+static void DrawBGMode7Background16Add1_2 (uint8 *Screen, int bg)
{
RENDER_BACKGROUND_MODE7 (uint16, *(d + GFX.DepthDelta) ?
(*(d + GFX.DepthDelta) != 1 ?
GFX.ScreenColors [b & bmask]);
}
-void DrawBGMode7Background16Sub (uint8 *Screen, int bg)
+static void DrawBGMode7Background16Sub (uint8 *Screen, int bg)
{
RENDER_BACKGROUND_MODE7 (uint16, *(d + GFX.DepthDelta) ?
(*(d + GFX.DepthDelta) != 1 ?
GFX.ScreenColors [b & bmask]);
}
-void DrawBGMode7Background16Sub1_2 (uint8 *Screen, int bg)
+static void DrawBGMode7Background16Sub1_2 (uint8 *Screen, int bg)
{
RENDER_BACKGROUND_MODE7 (uint16, *(d + GFX.DepthDelta) ?
(*(d + GFX.DepthDelta) != 1 ?
Screen += GFX.StartY * GFX.Pitch; \
uint8 *Depth = GFX.DB + GFX.StartY * GFX.PPL; \
struct SLineMatrixData *l = &LineMatrixData [GFX.StartY]; \
- bool8_32 allowSimpleCase = FALSE; \
+ bool allowSimpleCase = false; \
if (!l->MatrixB && !l->MatrixC && (l->MatrixA == 0x0100) && (l->MatrixD == 0x0100) \
&& !LineMatrixData[GFX.EndY].MatrixB && !LineMatrixData[GFX.EndY].MatrixC \
&& (LineMatrixData[GFX.EndY].MatrixA == 0x0100) && (LineMatrixData[GFX.EndY].MatrixD == 0x0100) \
) \
- allowSimpleCase = TRUE; \
+ allowSimpleCase = true; \
\
for (uint32 Line = GFX.StartY; Line <= GFX.EndY; Line++, Screen += GFX.Pitch, Depth += GFX.PPL, l++) \
{ \
yy += (VOffset - CentreY) % 1023; \
else \
yy += VOffset - CentreY; \
- bool8_32 simpleCase = FALSE; \
+ bool simpleCase = false; \
int BB; \
int DD; \
/* Make a special case for the identity matrix, since it's a common case and */ \
{ \
BB = CentreX << 8; \
DD = (yy + CentreY) << 8; \
- simpleCase = TRUE; \
+ simpleCase = true; \
} \
else \
{ \
} \
}
-STATIC uint32 Q_INTERPOLATE(uint32 A, uint32 B, uint32 C, uint32 D)
+static inline uint32 Q_INTERPOLATE(uint32 A, uint32 B, uint32 C, uint32 D)
{
register uint32 x = ((A >> 2) & HIGH_BITS_SHIFTED_TWO_MASK) +
((B >> 2) & HIGH_BITS_SHIFTED_TWO_MASK) +
return x+y;
}
-void DrawBGMode7Background16_i (uint8 *Screen, int bg)
+static void DrawBGMode7Background16_i (uint8 *Screen, int bg)
{
RENDER_BACKGROUND_MODE7_i (uint16, theColor, (GFX.ScreenColors[b & GFX.Mode7Mask]));
}
-void DrawBGMode7Background16Add_i (uint8 *Screen, int bg)
+static void DrawBGMode7Background16Add_i (uint8 *Screen, int bg)
{
RENDER_BACKGROUND_MODE7_i (uint16, *(d + GFX.DepthDelta) ?
(*(d + GFX.DepthDelta) != 1 ?
theColor, (GFX.ScreenColors[b & GFX.Mode7Mask]));
}
-void DrawBGMode7Background16Add1_2_i (uint8 *Screen, int bg)
+static void DrawBGMode7Background16Add1_2_i (uint8 *Screen, int bg)
{
RENDER_BACKGROUND_MODE7_i (uint16, *(d + GFX.DepthDelta) ?
(*(d + GFX.DepthDelta) != 1 ?
theColor, (GFX.ScreenColors[b & GFX.Mode7Mask]));
}
-void DrawBGMode7Background16Sub_i (uint8 *Screen, int bg)
+static void DrawBGMode7Background16Sub_i (uint8 *Screen, int bg)
{
RENDER_BACKGROUND_MODE7_i (uint16, *(d + GFX.DepthDelta) ?
(*(d + GFX.DepthDelta) != 1 ?
theColor, (GFX.ScreenColors[b & GFX.Mode7Mask]));
}
-void DrawBGMode7Background16Sub1_2_i (uint8 *Screen, int bg)
+static void DrawBGMode7Background16Sub1_2_i (uint8 *Screen, int bg)
{
RENDER_BACKGROUND_MODE7_i (uint16, *(d + GFX.DepthDelta) ?
(*(d + GFX.DepthDelta) != 1 ?
HIGH_BITS_SHIFTED_TWO_MASK = (( (FIRST_COLOR_MASK | SECOND_COLOR_MASK | THIRD_COLOR_MASK) & \
~TWO_LOW_BITS_MASK ) >> 2);
-void RenderScreen (uint8 *Screen, bool8_32 sub, bool8_32 force_no_add, uint8 D)
+static void RenderScreen(uint8 *Screen, bool sub, bool force_no_add, uint8 D)
{
- bool8_32 BG0;
- bool8_32 BG1;
- bool8_32 BG2;
- bool8_32 BG3;
- bool8_32 OB;
+ bool BG0, BG1, BG2, BG3, OB;
GFX.S = Screen;
#include "font.h"
-void DisplayChar (uint8 *Screen, uint8 c)
+static void DisplayChar(uint8 *Screen, uint8 c)
{
int line = (((c & 0x7f) - 32) >> 4) * font_height;
int offset = (((c & 0x7f) - 32) & 15) * font_width;
-#ifndef _SNESPPC
- if (Settings.SixteenBit)
-#endif
- {
+
int h, w;
uint16 *s = (uint16 *) Screen;
for (h = 0; h < font_height; h++, line++,
*s = BLACK;
}
}
- }
-#ifndef _SNESPPC
- else
- {
- int h, w;
- uint8 *s = Screen;
- for (h = 0; h < font_height; h++, line++,
- s += GFX.PPL - font_width)
- {
- for (w = 0; w < font_width; w++, s++)
- {
- uint8 p = font [line][offset + w];
-
- if (p == '#')
- *s = 255;
- else
- if (p == '.')
- *s = BLACK;
- }
- }
- }
-#endif
}
-static void S9xDisplayFrameRate ()
+static void S9xDisplayFrameRate()
{
- uint8 *Screen = GFX.Screen + 2 +
- (IPPU.RenderedScreenHeight - font_height - 1) * GFX.Pitch2;
- char string [10];
- int len = 5;
-
- sprintf (string, "%02d/%02d", IPPU.DisplayedRenderedFrameCount,
- (int) Memory.ROMFramesPerSecond);
+ const unsigned int char_width = (font_width - 1) * sizeof (uint16);
+ uint8 *Screen = GFX.Screen + 2 +
+ (IPPU.RenderedScreenHeight - font_height - 1) * GFX.Pitch;
+ char string[12];
+ int len;
+
+ if (Settings.TurboMode) {
+ len = sprintf(string, "%u",
+ IPPU.DisplayedRenderedFrameCount);
+ } else {
+ len = sprintf(string, "%2u/%02u",
+ IPPU.DisplayedRenderedFrameCount,
+ (unsigned int) Memory.ROMFramesPerSecond);
+ }
- int i;
-#ifdef _SNESPPC
- Screen += (font_width - 1) * sizeof(uint16);
-#endif
- for (i = 0; i < len; i++)
- {
- DisplayChar (Screen, string [i]);
- Screen += Settings.SixteenBit ? (font_width - 1) * sizeof (uint16) :
- (font_width - 1);
- }
+ for (int i = 0; i < len; i++) {
+ DisplayChar(Screen, string[i]);
+ Screen += char_width;
+ }
}
-static void S9xDisplayString (const char *string)
+static void S9xDisplayString(const char *string)
{
+ const unsigned int char_width = (font_width - 1) * sizeof (uint16);
uint8 *Screen = GFX.Screen + 2 +
- (IPPU.RenderedScreenHeight - font_height * 5) * GFX.Pitch2;
+ (IPPU.RenderedScreenHeight - font_height * 5) * GFX.Pitch;
int len = strlen (string);
int max_chars = IPPU.RenderedScreenWidth / (font_width - 1);
int char_count = 0;
{
if (char_count >= max_chars || string [i] < 32)
{
- Screen -= Settings.SixteenBit ?
- (font_width - 1) * sizeof (uint16) * max_chars :
- (font_width - 1) * max_chars;
+ Screen -= char_width * max_chars;
Screen += font_height * GFX.Pitch;
if (Screen >= GFX.Screen + GFX.Pitch * IPPU.RenderedScreenHeight)
break;
if (string [i] < 32)
continue;
DisplayChar (Screen, string [i]);
- Screen += Settings.SixteenBit ? (font_width - 1) * sizeof (uint16) :
- (font_width - 1);
+ Screen += char_width;
}
}
uint32 endy = GFX.EndY;
#ifndef RC_OPTIMIZED
- if (Settings.SupportHiRes &&
- (PPU.BGMode == 5 || PPU.BGMode == 6 || IPPU.LatchedInterlace))
- {
- if (PPU.BGMode == 5 || PPU.BGMode == 6)
- {
+ if (Settings.SupportHiRes &&
+ (PPU.BGMode == 5 || PPU.BGMode == 6 || IPPU.LatchedInterlace)) {
+ if (PPU.BGMode == 5 || PPU.BGMode == 6) {
IPPU.RenderedScreenWidth = 512;
x2 = 2;
}
- if (IPPU.LatchedInterlace)
- {
- starty = GFX.StartY * 2;
- endy = GFX.EndY * 2 + 1;
+
+ if (IPPU.LatchedInterlace) {
+ starty = GFX.StartY * 2;
+ endy = GFX.EndY * 2 + 1;
}
- if (!IPPU.DoubleWidthPixels)
- {
- // The game has switched from lo-res to hi-res mode part way down
- // the screen. Scale any existing lo-res pixels on screen
-#ifndef _SNESPPC
- if (Settings.SixteenBit)
-#endif
- {
-#if defined (USE_GLIDE) || defined (USE_OPENGL)
- if (
-#ifdef USE_GLIDE
- (Settings.GlideEnable && GFX.Pitch == 512) ||
-#endif
-#ifdef USE_OPENGL
- (Settings.OpenGLEnable && GFX.Pitch == 512) ||
-#endif
- 0)
- {
- // Have to back out of the speed up hack where the low res.
- // SNES image was rendered into a 256x239 sized buffer,
- // ignoring the true, larger size of the buffer.
-
- for (register int32 y = (int32) GFX.StartY - 1; y >= 0; y--)
- {
- register uint16 *p = (uint16 *) (GFX.Screen + y * GFX.Pitch) + 255;
- register uint16 *q = (uint16 *) (GFX.Screen + y * GFX.RealPitch) + 510;
- for (register int x = 255; x >= 0; x--, p--, q -= 2)
- *q = *(q + 1) = *p;
- }
- }
- else
-#endif
- for (register uint32 y = 0; y < GFX.StartY; y++)
- {
- register uint16 *p = (uint16 *) (GFX.Screen + y * GFX.Pitch) + 255;
- register uint16 *q = (uint16 *) (GFX.Screen + y * GFX.Pitch) + 510;
- for (register int x = 255; x >= 0; x--, p--, q -= 2)
- *q = *(q + 1) = *p;
- }
- }
-#ifndef _SNESPPC
- else
- {
- for (register uint32 y = 0; y < GFX.StartY; y++)
- {
- register uint8 *p = GFX.Screen + y * GFX.Pitch + 255;
- register uint8 *q = GFX.Screen + y * GFX.Pitch + 510;
- for (register int x = 255; x >= 0; x--, p--, q -= 2)
+
+ if (!IPPU.DoubleWidthPixels) {
+ // The game has switched from lo-res to hi-res mode part way down
+ // the screen. Scale any existing lo-res pixels on screen
+ for (register uint32 y = 0; y < GFX.StartY; y++) {
+ register uint16 *p =
+ (uint16 *) (GFX.Screen + y * GFX.Pitch) + 255;
+ register uint16 *q =
+ (uint16 *) (GFX.Screen + y * GFX.Pitch) + 510;
+ for (register int x = 255; x >= 0; x--, p--, q -= 2) {
*q = *(q + 1) = *p;
}
- }
-#endif
- IPPU.DoubleWidthPixels = TRUE;
+ }
+
+ IPPU.DoubleWidthPixels = TRUE;
}
- }
+ }
#endif //RC_OPTIMIZED (DONT DO ABOVE)
uint32 black = BLACK | (BLACK << 16);
// Are we worrying about transparencies?
- if (Settings.Transparency && Settings.SixteenBit)
+ if (Settings.Transparency)
{
if (GFX.Pseudo)
{
{
// Colour window enabled.
-
#ifdef RC_OPTIMIZED
for (uint32 y = starty; y <= endy; y++)
{
-
ZeroMemory (GFX.SubZBuffer + y * GFX.ZPitch,
IPPU.RenderedScreenWidth);
ZeroMemory (GFX.ZBuffer + y * GFX.ZPitch,
if (IPPU.Clip [0].Count [5])
{
- memset ((GFX.SubScreen + y * GFX.Pitch2), black, IPPU.RenderedScreenWidth);
+ memset ((GFX.SubScreen + y * GFX.Pitch), black, IPPU.RenderedScreenWidth);
}
for (uint32 c = 0; c < pClip->Count [5]; c++)
{
// because there is a colour window in effect clipping
// the main screen that will allow the sub-screen
// 'underneath' to show through.
- memset ((GFX.SubScreen + y * GFX.Pitch2) + pClip->Left [c][5] * x2,
+ memset ((GFX.SubScreen + y * GFX.Pitch) + pClip->Left [c][5] * x2,
GFX.FixedColour,
pClip->Right[c][5]*x2 - pClip->Left [c][5] * x2);
}
// if there is clipping then clear subscreen to a black color
if (IPPU.Clip [0].Count [5])
{
- memset32 ((uint32_t*)(GFX.SubScreen + y * GFX.Pitch2), black, IPPU.RenderedScreenWidth>>1);
+ memset32 ((uint32_t*)(GFX.SubScreen + y * GFX.Pitch), black, IPPU.RenderedScreenWidth>>1);
}
// loop through all window clippings
// the main screen that will allow the sub-screen
// 'underneath' to show through.
- register uint16 *p = (uint16 *) (GFX.SubScreen + y * GFX.Pitch2);
+ register uint16 *p = (uint16 *) (GFX.SubScreen + y * GFX.Pitch);
register uint16 *q = p + pClip->Right [c][5] * x2;
p += pClip->Left [c][5] * x2;
}
}
#endif
-//#undef RC_OPTIMIZED
}
else
// because there is a colour window in effect clipping
// the main screen that will allow the sub-screen
// 'underneath' to show through.
- if (GFX.Pitch2 == (uint32)IPPU.RenderedScreenWidth)
+ if (GFX.Pitch == (uint32)IPPU.RenderedScreenWidth)
{
- memset ((GFX.SubScreen + starty * GFX.Pitch2),
+ memset ((GFX.SubScreen + starty * GFX.Pitch),
GFX.FixedColour | (GFX.FixedColour << 16),
- GFX.Pitch2 * (endy - starty - 1));
+ GFX.Pitch * (endy - starty - 1));
}
else
{
for (uint32 y = starty; y <= endy; y++)
{
- memset ((GFX.SubScreen + y * GFX.Pitch2),
+ memset ((GFX.SubScreen + y * GFX.Pitch),
GFX.FixedColour | (GFX.FixedColour << 16),
IPPU.RenderedScreenWidth);
}
// 'underneath' to show through.
- memset32 ((uint32_t*)(GFX.SubScreen + y * GFX.Pitch2), fixedColour,
+ memset32 ((uint32_t*)(GFX.SubScreen + y * GFX.Pitch), fixedColour,
IPPU.RenderedScreenWidth>>1);
}
}
{
for (uint32 y = starty; y <= endy; y++)
{
- register uint16 *p = (uint16 *) (GFX.Screen + y * GFX.Pitch2);
+ register uint16 *p = (uint16 *) (GFX.Screen + y * GFX.Pitch);
register uint8 *d = GFX.SubZBuffer + y * GFX.ZPitch ;
register uint8 *e = d + SNES_WIDTH;
if (GFX.r2131 & 0x40)
{
// Subtract, halving the result.
- register uint16 *p = (uint16 *) (GFX.Screen + y * GFX.Pitch2) + Left;
+ register uint16 *p = (uint16 *) (GFX.Screen + y * GFX.Pitch) + Left;
register uint8 *d = GFX.ZBuffer + y * GFX.ZPitch;
register uint8 *s = GFX.SubZBuffer + y * GFX.ZPitch + Left;
register uint8 *e = d + Right;
else
{
// Subtract
- register uint16 *p = (uint16 *) (GFX.Screen + y * GFX.Pitch2) + Left;
+ register uint16 *p = (uint16 *) (GFX.Screen + y * GFX.Pitch) + Left;
register uint8 *s = GFX.SubZBuffer + y * GFX.ZPitch + Left;
register uint8 *d = GFX.ZBuffer + y * GFX.ZPitch;
register uint8 *e = d + Right;
else
if (GFX.r2131 & 0x40)
{
- register uint16 *p = (uint16 *) (GFX.Screen + y * GFX.Pitch2) + Left;
+ register uint16 *p = (uint16 *) (GFX.Screen + y * GFX.Pitch) + Left;
register uint8 *d = GFX.ZBuffer + y * GFX.ZPitch;
register uint8 *s = GFX.SubZBuffer + y * GFX.ZPitch + Left;
register uint8 *e = d + Right;
else
if (back != 0)
{
- register uint16 *p = (uint16 *) (GFX.Screen + y * GFX.Pitch2) + Left;
+ register uint16 *p = (uint16 *) (GFX.Screen + y * GFX.Pitch) + Left;
register uint8 *d = GFX.ZBuffer + y * GFX.ZPitch;
register uint8 *s = GFX.SubZBuffer + y * GFX.ZPitch + Left;
register uint8 *e = d + Right;
// copy the sub-screen to the main screen
// or fill it with the back-drop colour if the
// sub-screen is clear.
- register uint16 *p = (uint16 *) (GFX.Screen + y * GFX.Pitch2) + Left;
+ register uint16 *p = (uint16 *) (GFX.Screen + y * GFX.Pitch) + Left;
register uint8 *d = GFX.ZBuffer + y * GFX.ZPitch;
register uint8 *s = GFX.SubZBuffer + y * GFX.ZPitch + Left;
register uint8 *e = d + Right;
{
uint32 Left = pClip->Left [b][5] * x2;
uint32 Right = pClip->Right [b][5] * x2;
- register uint16 *p = (uint16 *) (GFX.Screen + y * GFX.Pitch2) + Left;
+ register uint16 *p = (uint16 *) (GFX.Screen + y * GFX.Pitch) + Left;
register uint8 *d = GFX.ZBuffer + y * GFX.ZPitch;
register uint8 *e = d + Right;
d += Left;
{
for (uint32 y = starty; y <= endy; y++)
{
- register uint16 *p = (uint16 *) (GFX.Screen + y * GFX.Pitch2);
+ register uint16 *p = (uint16 *) (GFX.Screen + y * GFX.Pitch);
register uint8 *d = GFX.ZBuffer + y * GFX.ZPitch;
register uint8 *e = d + 256 * x2;
{
#ifdef RC_OPTIMIZED
- if (GFX.Pitch2 == (uint32)IPPU.RenderedScreenWidth)
+ if (GFX.Pitch == (uint32)IPPU.RenderedScreenWidth)
{
- memset (GFX.Screen + starty * GFX.Pitch2, black,
- GFX.Pitch2 * (endy - starty - 1));
+ memset (GFX.Screen + starty * GFX.Pitch, black,
+ GFX.Pitch * (endy - starty - 1));
}
else
{
for (uint32 y = starty; y <= endy; y++)
{
- memset (GFX.Screen + y * GFX.Pitch2, black,
- GFX.Pitch2);
+ memset (GFX.Screen + y * GFX.Pitch, black,
+ GFX.Pitch);
}
}
for (uint32 y = starty; y <= endy; y++)
if (IPPU.Clip [0].Right [c][5] > IPPU.Clip [0].Left [c][5])
{
- memset ((GFX.Screen + y * GFX.Pitch2) + IPPU.Clip [0].Left [c][5] * x2,
+ memset ((GFX.Screen + y * GFX.Pitch) + IPPU.Clip [0].Left [c][5] * x2,
back,
IPPU.Clip [0].Right [c][5] * x2 - IPPU.Clip [0].Left [c][5] * x2);
}
// loop through all of the lines that are going to be updated as part of this screen update
for (uint32 y = starty; y <= endy; y++)
{
- memset32 ((uint32_t*)(GFX.Screen + y * GFX.Pitch2), black,
+ memset32 ((uint32_t*)(GFX.Screen + y * GFX.Pitch), black,
IPPU.RenderedScreenWidth>>1);
if (black!=back)
{
if (IPPU.Clip [0].Right [c][5] > IPPU.Clip [0].Left [c][5])
{
- register uint16 *p = (uint16 *) (GFX.Screen + y * GFX.Pitch2); // get pointer to current line in screen buffer
+ register uint16 *p = (uint16 *) (GFX.Screen + y * GFX.Pitch); // get pointer to current line in screen buffer
register uint16 *q = p + IPPU.Clip [0].Right [c][5] * x2; // get pointer to end of line
p += IPPU.Clip [0].Left [c][5] * x2;
else
{
#ifdef RC_OPTIMIZED
- if (GFX.Pitch2 == (uint32)IPPU.RenderedScreenWidth)
+ if (GFX.Pitch == (uint32)IPPU.RenderedScreenWidth)
{
- memset (GFX.Screen + starty * GFX.Pitch2, back,
- GFX.Pitch2 * (endy - starty - 1));
+ memset (GFX.Screen + starty * GFX.Pitch, back,
+ GFX.Pitch * (endy - starty - 1));
}
else
{
for (uint32 y = starty; y <= endy; y++)
{
- memset (GFX.Screen + y * GFX.Pitch2, back,
- GFX.Pitch2);
+ memset (GFX.Screen + y * GFX.Pitch, back,
+ GFX.Pitch);
}
}
#else
// there is no clipping to worry about so just fill with the back colour
for (uint32 y = starty; y <= endy; y++)
{
- memset32 ((uint32_t*)(GFX.Screen + y * GFX.Pitch2), back,
+ memset32 ((uint32_t*)(GFX.Screen + y * GFX.Pitch), back,
IPPU.RenderedScreenWidth>>1);
}
#endif
}
else // Transparencys are disabled, ahh lovely ... nice and easy.
{
-#ifndef _SNESPPC
- if (Settings.SixteenBit)
-#endif
+ // get back colour to be used in clearing the screen
+ register uint32 back;
+ if (!(Memory.FillRAM [0x2131] & 0x80) &&(Memory.FillRAM[0x2131] & 0x20) &&
+ (PPU.FixedColourRed || PPU.FixedColourGreen || PPU.FixedColourBlue))
{
- // get back colour to be used in clearing the screen
- register uint32 back;
- if (!(Memory.FillRAM [0x2131] & 0x80) &&(Memory.FillRAM[0x2131] & 0x20) &&
- (PPU.FixedColourRed || PPU.FixedColourGreen || PPU.FixedColourBlue))
- {
- back = (IPPU.XB[PPU.FixedColourRed]<<11) |
- (IPPU.XB[PPU.FixedColourGreen] << 6) |
- (IPPU.XB[PPU.FixedColourBlue] << 1) | 1;
- back = (back << 16) | back;
- }
- else
- {
- back = IPPU.ScreenColors [0] | (IPPU.ScreenColors [0] << 16);
- }
-
- // if Forcedblanking in use then back colour becomes black
- if (PPU.ForcedBlanking)
- back = black;
- else
- {
- SelectTileRenderer (TRUE); //selects the tile renderers to be used
- // TRUE means to use the default
- // FALSE means use best renderer based on current
- // graphics register settings
- }
-
- // now clear all graphics lines which are being updated using the back colour
- for (register uint32 y = starty; y <= endy; y++)
- {
- memset32 ((uint32_t*)(GFX.Screen + y * GFX.Pitch2), back,
- IPPU.RenderedScreenWidth>>1);
- }
+ back = (IPPU.XB[PPU.FixedColourRed]<<11) |
+ (IPPU.XB[PPU.FixedColourGreen] << 6) |
+ (IPPU.XB[PPU.FixedColourBlue] << 1) | 1;
+ back = (back << 16) | back;
}
-#ifndef _SNESPPC
- else // Settings.SixteenBit == false
+ else
{
- // because we are in 8 bit we can just use 0 to clear the screen
- // this means we can use the Zero Memory function
-
- // Loop through all lines being updated and clear the pixels to 0
- for (uint32 y = starty; y <= endy; y++)
- {
- ZeroMemory (GFX.Screen + y * GFX.Pitch2,
- IPPU.RenderedScreenWidth);
- }
+ back = IPPU.ScreenColors [0] | (IPPU.ScreenColors [0] << 16);
}
-#endif
+
+ // if Forcedblanking in use then back colour becomes black
+ if (PPU.ForcedBlanking)
+ back = black;
+ else
+ {
+ SelectTileRenderer (TRUE); //selects the tile renderers to be used
+ // TRUE means to use the default
+ // FALSE means use best renderer based on current
+ // graphics register settings
+ }
+
+ // now clear all graphics lines which are being updated using the back colour
+ for (register uint32 y = starty; y <= endy; y++)
+ {
+ memset32 ((uint32_t*)(GFX.Screen + y * GFX.Pitch), back,
+ IPPU.RenderedScreenWidth>>1);
+ }
+
if (!PPU.ForcedBlanking)
{
// Loop through all lines being updated and clear the
bg = 0;
}
-#ifndef _SNESPPC
- if (!Settings.SixteenBit)
- DrawBGMode7Background (GFX.Screen, bg);
- else
-#endif
- {
if (!Settings.Mode7Interpolate)
{
DrawBGMode7Background16 (GFX.Screen, bg);
{
DrawBGMode7Background16_i (GFX.Screen, bg);
}
- }
}
}
}
{
// Mixure of background modes used on screen - scale width
// of all non-mode 5 and 6 pixels.
-#ifndef _SNESPPC
- if (Settings.SixteenBit)
-#endif
- {
for (register uint32 y = GFX.StartY; y <= GFX.EndY; y++)
{
register uint16 *p = (uint16 *) (GFX.Screen + y * GFX.Pitch) + 255;
for (register int x = 255; x >= 0; x--, p--, q -= 2)
*q = *(q + 1) = *p;
}
- }
-#ifndef _SNESPPC
- else
- {
- for (register uint32 y = GFX.StartY; y <= GFX.EndY; y++)
- {
- register uint8 *p = GFX.Screen + y * GFX.Pitch + 255;
- register uint8 *q = GFX.Screen + y * GFX.Pitch + 510;
- for (register int x = 255; x >= 0; x--, p--, q -= 2)
- *q = *(q + 1) = *p;
- }
- }
-#endif
}
if (IPPU.LatchedInterlace)
// pixels.
for (uint32 y = GFX.StartY; y <= GFX.EndY; y++)
{
- memcpy32 ((uint32_t*)(GFX.Screen + (y * 2 + 1) * GFX.Pitch2),
- (uint32_t*)(GFX.Screen + y * 2 * GFX.Pitch2),
- GFX.Pitch2>>2);
+ memcpy32 ((uint32_t*)(GFX.Screen + (y * 2 + 1) * GFX.Pitch),
+ (uint32_t*)(GFX.Screen + y * 2 * GFX.Pitch),
+ GFX.Pitch>>2);
}
}
}
_BUILD_PIXEL(GBR555)
_BUILD_PIXEL(RGB5551)
-bool8_32 S9xSetRenderPixelFormat (int format)
+bool8 S9xSetRenderPixelFormat (int format)
{
extern uint32 current_graphic_format;
projects / drnoksnes / blobdiff