2006-02-24 04:48:15 +00:00
|
|
|
|
|
|
|
// HEADER FILES ------------------------------------------------------------
|
|
|
|
|
|
|
|
#include "doomtype.h"
|
|
|
|
|
|
|
|
#include "templates.h"
|
|
|
|
#include "i_system.h"
|
|
|
|
#include "i_video.h"
|
|
|
|
#include "v_video.h"
|
|
|
|
#include "v_pfx.h"
|
|
|
|
#include "stats.h"
|
2008-09-19 22:34:32 +00:00
|
|
|
#include "v_palette.h"
|
2006-02-24 04:48:15 +00:00
|
|
|
#include "sdlvideo.h"
|
2011-07-07 15:37:47 +00:00
|
|
|
#include "r_swrenderer.h"
|
2006-02-24 04:48:15 +00:00
|
|
|
|
2006-04-12 01:50:09 +00:00
|
|
|
#include <SDL.h>
|
2006-02-24 04:48:15 +00:00
|
|
|
|
|
|
|
// MACROS ------------------------------------------------------------------
|
|
|
|
|
|
|
|
// TYPES -------------------------------------------------------------------
|
|
|
|
|
|
|
|
class SDLFB : public DFrameBuffer
|
|
|
|
{
|
2006-11-19 02:10:25 +00:00
|
|
|
DECLARE_CLASS(SDLFB, DFrameBuffer)
|
2006-02-24 04:48:15 +00:00
|
|
|
public:
|
|
|
|
SDLFB (int width, int height, bool fullscreen);
|
|
|
|
~SDLFB ();
|
|
|
|
|
|
|
|
bool Lock (bool buffer);
|
|
|
|
void Unlock ();
|
|
|
|
bool Relock ();
|
|
|
|
void ForceBuffering (bool force);
|
|
|
|
bool IsValid ();
|
|
|
|
void Update ();
|
|
|
|
PalEntry *GetPalette ();
|
|
|
|
void GetFlashedPalette (PalEntry pal[256]);
|
|
|
|
void UpdatePalette ();
|
|
|
|
bool SetGamma (float gamma);
|
|
|
|
bool SetFlash (PalEntry rgb, int amount);
|
|
|
|
void GetFlash (PalEntry &rgb, int &amount);
|
|
|
|
int GetPageCount ();
|
|
|
|
bool IsFullscreen ();
|
|
|
|
|
|
|
|
friend class SDLVideo;
|
|
|
|
|
|
|
|
private:
|
|
|
|
PalEntry SourcePalette[256];
|
|
|
|
BYTE GammaTable[3][256];
|
|
|
|
PalEntry Flash;
|
|
|
|
int FlashAmount;
|
|
|
|
float Gamma;
|
|
|
|
bool UpdatePending;
|
|
|
|
|
|
|
|
SDL_Surface *Screen;
|
|
|
|
|
|
|
|
bool NeedPalUpdate;
|
|
|
|
bool NeedGammaUpdate;
|
|
|
|
bool NotPaletted;
|
|
|
|
|
|
|
|
void UpdateColors ();
|
2006-11-19 02:10:25 +00:00
|
|
|
|
|
|
|
SDLFB () {}
|
2006-02-24 04:48:15 +00:00
|
|
|
};
|
2006-12-29 01:48:47 +00:00
|
|
|
IMPLEMENT_CLASS(SDLFB)
|
2006-02-24 04:48:15 +00:00
|
|
|
|
|
|
|
struct MiniModeInfo
|
|
|
|
{
|
|
|
|
WORD Width, Height;
|
|
|
|
};
|
|
|
|
|
|
|
|
// PUBLIC FUNCTION PROTOTYPES ----------------------------------------------
|
|
|
|
|
|
|
|
// PRIVATE FUNCTION PROTOTYPES ---------------------------------------------
|
|
|
|
|
|
|
|
// EXTERNAL DATA DECLARATIONS ----------------------------------------------
|
|
|
|
|
|
|
|
extern IVideo *Video;
|
2011-01-23 07:37:08 +00:00
|
|
|
extern SDL_Surface *cursorSurface;
|
|
|
|
extern SDL_Rect cursorBlit;
|
|
|
|
extern bool GUICapture;
|
2006-02-24 04:48:15 +00:00
|
|
|
|
|
|
|
EXTERN_CVAR (Float, Gamma)
|
2012-10-17 19:45:04 +00:00
|
|
|
EXTERN_CVAR (Int, vid_maxfps)
|
2012-10-22 23:42:20 +00:00
|
|
|
EXTERN_CVAR (Bool, cl_capfps)
|
2006-02-24 04:48:15 +00:00
|
|
|
|
|
|
|
// PUBLIC DATA DEFINITIONS -------------------------------------------------
|
|
|
|
|
|
|
|
CVAR (Int, vid_displaybits, 8, CVAR_ARCHIVE|CVAR_GLOBALCONFIG)
|
|
|
|
|
2013-09-21 19:30:32 +00:00
|
|
|
// vid_asyncblit needs a restart to work. SDL doesn't seem to change if the
|
|
|
|
// frame buffer is changed at run time.
|
|
|
|
CVAR (Bool, vid_asyncblit, 1, CVAR_NOINITCALL|CVAR_ARCHIVE|CVAR_GLOBALCONFIG)
|
|
|
|
|
2006-02-24 04:48:15 +00:00
|
|
|
CUSTOM_CVAR (Float, rgamma, 1.f, CVAR_ARCHIVE|CVAR_GLOBALCONFIG)
|
|
|
|
{
|
|
|
|
if (screen != NULL)
|
|
|
|
{
|
|
|
|
screen->SetGamma (Gamma);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
CUSTOM_CVAR (Float, ggamma, 1.f, CVAR_ARCHIVE|CVAR_GLOBALCONFIG)
|
|
|
|
{
|
|
|
|
if (screen != NULL)
|
|
|
|
{
|
|
|
|
screen->SetGamma (Gamma);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
CUSTOM_CVAR (Float, bgamma, 1.f, CVAR_ARCHIVE|CVAR_GLOBALCONFIG)
|
|
|
|
{
|
|
|
|
if (screen != NULL)
|
|
|
|
{
|
|
|
|
screen->SetGamma (Gamma);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// PRIVATE DATA DEFINITIONS ------------------------------------------------
|
|
|
|
|
|
|
|
// Dummy screen sizes to pass when windowed
|
|
|
|
static MiniModeInfo WinModes[] =
|
|
|
|
{
|
|
|
|
{ 320, 200 },
|
2008-04-03 10:49:54 +00:00
|
|
|
{ 320, 240 },
|
2006-12-29 05:14:19 +00:00
|
|
|
{ 400, 225 }, // 16:9
|
2008-04-03 10:49:54 +00:00
|
|
|
{ 400, 300 },
|
2006-12-29 05:14:19 +00:00
|
|
|
{ 480, 270 }, // 16:9
|
2008-04-03 10:49:54 +00:00
|
|
|
{ 480, 360 },
|
2006-12-29 05:14:19 +00:00
|
|
|
{ 512, 288 }, // 16:9
|
2008-04-03 10:49:54 +00:00
|
|
|
{ 512, 384 },
|
2006-12-29 05:14:19 +00:00
|
|
|
{ 640, 360 }, // 16:9
|
2006-02-24 04:48:15 +00:00
|
|
|
{ 640, 400 },
|
2008-04-03 10:49:54 +00:00
|
|
|
{ 640, 480 },
|
2006-12-29 05:14:19 +00:00
|
|
|
{ 720, 480 }, // 16:10
|
2008-04-03 10:49:54 +00:00
|
|
|
{ 720, 540 },
|
|
|
|
{ 800, 450 }, // 16:9
|
2006-12-29 05:14:19 +00:00
|
|
|
{ 800, 500 }, // 16:10
|
2008-04-03 10:49:54 +00:00
|
|
|
{ 800, 600 },
|
|
|
|
{ 848, 480 }, // 16:9
|
2006-12-29 05:14:19 +00:00
|
|
|
{ 960, 600 }, // 16:10
|
2008-04-03 10:49:54 +00:00
|
|
|
{ 960, 720 },
|
|
|
|
{ 1024, 576 }, // 16:9
|
2006-12-29 05:14:19 +00:00
|
|
|
{ 1024, 640 }, // 16:10
|
2008-04-03 10:49:54 +00:00
|
|
|
{ 1024, 768 },
|
|
|
|
{ 1088, 612 }, // 16:9
|
|
|
|
{ 1152, 648 }, // 16:9
|
2006-12-29 05:14:19 +00:00
|
|
|
{ 1152, 720 }, // 16:10
|
2008-04-03 10:49:54 +00:00
|
|
|
{ 1152, 864 },
|
|
|
|
{ 1280, 720 }, // 16:9
|
2006-12-29 05:14:19 +00:00
|
|
|
{ 1280, 800 }, // 16:10
|
2008-04-03 10:49:54 +00:00
|
|
|
{ 1280, 960 },
|
|
|
|
{ 1360, 768 }, // 16:9
|
|
|
|
{ 1400, 787 }, // 16:9
|
|
|
|
{ 1400, 875 }, // 16:10
|
|
|
|
{ 1400, 1050 },
|
|
|
|
{ 1600, 900 }, // 16:9
|
|
|
|
{ 1600, 1000 }, // 16:10
|
2006-12-29 05:14:19 +00:00
|
|
|
{ 1600, 1200 },
|
2011-07-07 15:37:47 +00:00
|
|
|
{ 1920, 1080 },
|
2006-02-24 04:48:15 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
static cycle_t BlitCycles;
|
|
|
|
static cycle_t SDLFlipCycles;
|
|
|
|
|
|
|
|
// CODE --------------------------------------------------------------------
|
|
|
|
|
|
|
|
SDLVideo::SDLVideo (int parm)
|
|
|
|
{
|
|
|
|
IteratorBits = 0;
|
|
|
|
IteratorFS = false;
|
|
|
|
}
|
|
|
|
|
|
|
|
SDLVideo::~SDLVideo ()
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
Note: I have not tried compiling these recent changes under Linux. I wouldn't
be surprised if it doesn't work.
- Reorganized the network startup loops so now they are event driven. There is
a single function that gets called to drive it, and it uses callbacks to
perform the different stages of the synchronization. This lets me have a nice,
responsive abort button instead of the previous unannounced hit-escape-to-
abort behavior, and I think the rearranged code is slightly easier to
understand too.
- Increased the number of bytes for version info during D_ArbitrateNetStart(),
in preparation for the day when NETGAMEVERSION requires more than one byte.
- I noticed an issue with Vista RC1 and the new fatal error setup. Even after
releasing a DirectDraw or Direct3D interface, the DWM can still use the
last image drawn using them when it composites the window. It doesn't always
do it but it does often enough that it is a real problem. At this point, I
don't know if it's a problem with the release version of Vista or not.
After messing around, I discovered the problem was caused by ~Win32Video()
hiding the window and then having it immediately shown soon after. The DWM
kept an image of the window to do the transition effect with, and then when
it didn't get a chance to do the transition, it didn't properly forget about
its saved image and kept plastering it on top of everything else
underneath.
- Added a network synchronization panel to the window during netgame startup.
- Fixed: PClass::CreateDerivedClass() must initialize StateList to NULL.
Otherwise, classic DECORATE definitions generate a big, fat crash.
- Resurrected the R_Init progress bar, now as a standard Windows control.
- Removed the sound failure dialog. The FMOD setup already defaulted to no
sound if initialization failed, so this only applies when snd_output is set
to "alternate" which now also falls back to no sound. In addition, it wasn't
working right, and I didn't feel like fixing it for the probably 0% of users
it affected.
- Fixed: The edit control used for logging output added text in reverse order
on Win9x.
- Went back to the roots and made graphics initialization one of the last
things to happen during setup. Now the startup text is visible again. More
importantly, the main window is no longer created invisible, which seems
to cause trouble with it not always appearing in the taskbar. The fatal
error dialog is now also embedded in the main window instead of being a
separate modal dialog, so you can play with the log window to see any
problems that might be reported there.
Rather than completely restoring the original startup order, I tried to
keep things as close to the way they were with early graphics startup. In
particular, V_Init() now creates a dummy screen so that things that need
screen dimensions can get them. It gets replaced by the real screen later
in I_InitGraphics(). Will need to check this under Linux to make sure it
didn't cause any problems there.
- Removed the following stubs that just called functions in Video:
- I_StartModeIterator()
- I_NextMode()
- I_DisplayType()
I_FullscreenChanged() was also removed, and a new fullscreen parameter
was added to IVideo::StartModeIterator(), since that's all it controlled.
- Renamed I_InitHardware() back to I_InitGraphics(), since that's all it's
initialized post-1.22.
SVN r416 (trunk)
2006-12-19 04:09:10 +00:00
|
|
|
void SDLVideo::StartModeIterator (int bits, bool fs)
|
2006-02-24 04:48:15 +00:00
|
|
|
{
|
|
|
|
IteratorMode = 0;
|
|
|
|
IteratorBits = bits;
|
Note: I have not tried compiling these recent changes under Linux. I wouldn't
be surprised if it doesn't work.
- Reorganized the network startup loops so now they are event driven. There is
a single function that gets called to drive it, and it uses callbacks to
perform the different stages of the synchronization. This lets me have a nice,
responsive abort button instead of the previous unannounced hit-escape-to-
abort behavior, and I think the rearranged code is slightly easier to
understand too.
- Increased the number of bytes for version info during D_ArbitrateNetStart(),
in preparation for the day when NETGAMEVERSION requires more than one byte.
- I noticed an issue with Vista RC1 and the new fatal error setup. Even after
releasing a DirectDraw or Direct3D interface, the DWM can still use the
last image drawn using them when it composites the window. It doesn't always
do it but it does often enough that it is a real problem. At this point, I
don't know if it's a problem with the release version of Vista or not.
After messing around, I discovered the problem was caused by ~Win32Video()
hiding the window and then having it immediately shown soon after. The DWM
kept an image of the window to do the transition effect with, and then when
it didn't get a chance to do the transition, it didn't properly forget about
its saved image and kept plastering it on top of everything else
underneath.
- Added a network synchronization panel to the window during netgame startup.
- Fixed: PClass::CreateDerivedClass() must initialize StateList to NULL.
Otherwise, classic DECORATE definitions generate a big, fat crash.
- Resurrected the R_Init progress bar, now as a standard Windows control.
- Removed the sound failure dialog. The FMOD setup already defaulted to no
sound if initialization failed, so this only applies when snd_output is set
to "alternate" which now also falls back to no sound. In addition, it wasn't
working right, and I didn't feel like fixing it for the probably 0% of users
it affected.
- Fixed: The edit control used for logging output added text in reverse order
on Win9x.
- Went back to the roots and made graphics initialization one of the last
things to happen during setup. Now the startup text is visible again. More
importantly, the main window is no longer created invisible, which seems
to cause trouble with it not always appearing in the taskbar. The fatal
error dialog is now also embedded in the main window instead of being a
separate modal dialog, so you can play with the log window to see any
problems that might be reported there.
Rather than completely restoring the original startup order, I tried to
keep things as close to the way they were with early graphics startup. In
particular, V_Init() now creates a dummy screen so that things that need
screen dimensions can get them. It gets replaced by the real screen later
in I_InitGraphics(). Will need to check this under Linux to make sure it
didn't cause any problems there.
- Removed the following stubs that just called functions in Video:
- I_StartModeIterator()
- I_NextMode()
- I_DisplayType()
I_FullscreenChanged() was also removed, and a new fullscreen parameter
was added to IVideo::StartModeIterator(), since that's all it controlled.
- Renamed I_InitHardware() back to I_InitGraphics(), since that's all it's
initialized post-1.22.
SVN r416 (trunk)
2006-12-19 04:09:10 +00:00
|
|
|
IteratorFS = fs;
|
2006-02-24 04:48:15 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
bool SDLVideo::NextMode (int *width, int *height, bool *letterbox)
|
|
|
|
{
|
|
|
|
if (IteratorBits != 8)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
if (!IteratorFS)
|
|
|
|
{
|
|
|
|
if ((unsigned)IteratorMode < sizeof(WinModes)/sizeof(WinModes[0]))
|
|
|
|
{
|
|
|
|
*width = WinModes[IteratorMode].Width;
|
|
|
|
*height = WinModes[IteratorMode].Height;
|
|
|
|
++IteratorMode;
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
SDL_Rect **modes = SDL_ListModes (NULL, SDL_FULLSCREEN|SDL_HWSURFACE);
|
|
|
|
if (modes != NULL && modes[IteratorMode] != NULL)
|
|
|
|
{
|
|
|
|
*width = modes[IteratorMode]->w;
|
|
|
|
*height = modes[IteratorMode]->h;
|
|
|
|
++IteratorMode;
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
DFrameBuffer *SDLVideo::CreateFrameBuffer (int width, int height, bool fullscreen, DFrameBuffer *old)
|
|
|
|
{
|
|
|
|
static int retry = 0;
|
|
|
|
static int owidth, oheight;
|
|
|
|
|
|
|
|
PalEntry flashColor;
|
|
|
|
int flashAmount;
|
|
|
|
|
|
|
|
if (old != NULL)
|
|
|
|
{ // Reuse the old framebuffer if its attributes are the same
|
|
|
|
SDLFB *fb = static_cast<SDLFB *> (old);
|
|
|
|
if (fb->Width == width &&
|
|
|
|
fb->Height == height)
|
|
|
|
{
|
|
|
|
bool fsnow = (fb->Screen->flags & SDL_FULLSCREEN) != 0;
|
|
|
|
|
|
|
|
if (fsnow != fullscreen)
|
|
|
|
{
|
|
|
|
SDL_WM_ToggleFullScreen (fb->Screen);
|
|
|
|
}
|
|
|
|
return old;
|
|
|
|
}
|
|
|
|
old->GetFlash (flashColor, flashAmount);
|
2008-03-30 09:30:34 +00:00
|
|
|
old->ObjectFlags |= OF_YesReallyDelete;
|
|
|
|
if (screen == old) screen = NULL;
|
2006-02-24 04:48:15 +00:00
|
|
|
delete old;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
flashColor = 0;
|
|
|
|
flashAmount = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
SDLFB *fb = new SDLFB (width, height, fullscreen);
|
|
|
|
retry = 0;
|
|
|
|
|
|
|
|
// If we could not create the framebuffer, try again with slightly
|
|
|
|
// different parameters in this order:
|
|
|
|
// 1. Try with the closest size
|
|
|
|
// 2. Try in the opposite screen mode with the original size
|
|
|
|
// 3. Try in the opposite screen mode with the closest size
|
|
|
|
// This is a somewhat confusing mass of recursion here.
|
|
|
|
|
|
|
|
while (fb == NULL || !fb->IsValid ())
|
|
|
|
{
|
|
|
|
if (fb != NULL)
|
|
|
|
{
|
|
|
|
delete fb;
|
|
|
|
}
|
|
|
|
|
|
|
|
switch (retry)
|
|
|
|
{
|
|
|
|
case 0:
|
|
|
|
owidth = width;
|
|
|
|
oheight = height;
|
|
|
|
case 2:
|
|
|
|
// Try a different resolution. Hopefully that will work.
|
|
|
|
I_ClosestResolution (&width, &height, 8);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case 1:
|
|
|
|
// Try changing fullscreen mode. Maybe that will work.
|
|
|
|
width = owidth;
|
|
|
|
height = oheight;
|
|
|
|
fullscreen = !fullscreen;
|
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
|
|
|
// I give up!
|
|
|
|
I_FatalError ("Could not create new screen (%d x %d)", owidth, oheight);
|
|
|
|
}
|
|
|
|
|
|
|
|
++retry;
|
|
|
|
fb = static_cast<SDLFB *>(CreateFrameBuffer (width, height, fullscreen, NULL));
|
|
|
|
}
|
|
|
|
|
|
|
|
fb->SetFlash (flashColor, flashAmount);
|
|
|
|
|
|
|
|
return fb;
|
|
|
|
}
|
|
|
|
|
|
|
|
void SDLVideo::SetWindowedScale (float scale)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
// FrameBuffer implementation -----------------------------------------------
|
|
|
|
|
|
|
|
SDLFB::SDLFB (int width, int height, bool fullscreen)
|
|
|
|
: DFrameBuffer (width, height)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
NeedPalUpdate = false;
|
|
|
|
NeedGammaUpdate = false;
|
|
|
|
UpdatePending = false;
|
|
|
|
NotPaletted = false;
|
2006-04-23 09:02:19 +00:00
|
|
|
FlashAmount = 0;
|
2006-02-24 04:48:15 +00:00
|
|
|
Screen = SDL_SetVideoMode (width, height, vid_displaybits,
|
2013-09-21 19:30:32 +00:00
|
|
|
(vid_asyncblit ? SDL_ASYNCBLIT : 0)|SDL_HWSURFACE|SDL_HWPALETTE|SDL_DOUBLEBUF|SDL_ANYFORMAT|
|
2006-02-24 04:48:15 +00:00
|
|
|
(fullscreen ? SDL_FULLSCREEN : 0));
|
|
|
|
|
|
|
|
if (Screen == NULL)
|
|
|
|
return;
|
|
|
|
|
|
|
|
for (i = 0; i < 256; i++)
|
|
|
|
{
|
|
|
|
GammaTable[0][i] = GammaTable[1][i] = GammaTable[2][i] = i;
|
|
|
|
}
|
|
|
|
if (Screen->format->palette == NULL)
|
|
|
|
{
|
|
|
|
NotPaletted = true;
|
|
|
|
GPfx.SetFormat (Screen->format->BitsPerPixel,
|
|
|
|
Screen->format->Rmask,
|
|
|
|
Screen->format->Gmask,
|
|
|
|
Screen->format->Bmask);
|
|
|
|
}
|
|
|
|
memcpy (SourcePalette, GPalette.BaseColors, sizeof(PalEntry)*256);
|
|
|
|
UpdateColors ();
|
|
|
|
}
|
|
|
|
|
|
|
|
SDLFB::~SDLFB ()
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
bool SDLFB::IsValid ()
|
|
|
|
{
|
|
|
|
return DFrameBuffer::IsValid() && Screen != NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
int SDLFB::GetPageCount ()
|
|
|
|
{
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool SDLFB::Lock (bool buffered)
|
|
|
|
{
|
|
|
|
return DSimpleCanvas::Lock ();
|
|
|
|
}
|
|
|
|
|
|
|
|
bool SDLFB::Relock ()
|
|
|
|
{
|
|
|
|
return DSimpleCanvas::Lock ();
|
|
|
|
}
|
|
|
|
|
|
|
|
void SDLFB::Unlock ()
|
|
|
|
{
|
|
|
|
if (UpdatePending && LockCount == 1)
|
|
|
|
{
|
|
|
|
Update ();
|
|
|
|
}
|
|
|
|
else if (--LockCount <= 0)
|
|
|
|
{
|
|
|
|
Buffer = NULL;
|
|
|
|
LockCount = 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void SDLFB::Update ()
|
|
|
|
{
|
|
|
|
if (LockCount != 1)
|
|
|
|
{
|
|
|
|
if (LockCount > 0)
|
|
|
|
{
|
|
|
|
UpdatePending = true;
|
|
|
|
--LockCount;
|
|
|
|
}
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
DrawRateStuff ();
|
2012-10-22 23:42:20 +00:00
|
|
|
|
2012-10-18 00:57:56 +00:00
|
|
|
#ifndef __APPLE__
|
2012-10-22 23:42:20 +00:00
|
|
|
if(vid_maxfps && !cl_capfps)
|
2012-10-17 19:45:04 +00:00
|
|
|
{
|
|
|
|
SEMAPHORE_WAIT(FPSLimitSemaphore)
|
2012-10-22 23:42:20 +00:00
|
|
|
}
|
2012-10-18 00:57:56 +00:00
|
|
|
#endif
|
2012-10-17 19:45:04 +00:00
|
|
|
|
2006-02-24 04:48:15 +00:00
|
|
|
Buffer = NULL;
|
|
|
|
LockCount = 0;
|
|
|
|
UpdatePending = false;
|
|
|
|
|
2008-08-10 03:25:08 +00:00
|
|
|
BlitCycles.Reset();
|
|
|
|
SDLFlipCycles.Reset();
|
|
|
|
BlitCycles.Clock();
|
2006-02-24 04:48:15 +00:00
|
|
|
|
|
|
|
if (SDL_LockSurface (Screen) == -1)
|
|
|
|
return;
|
|
|
|
|
|
|
|
if (NotPaletted)
|
|
|
|
{
|
|
|
|
GPfx.Convert (MemBuffer, Pitch,
|
|
|
|
Screen->pixels, Screen->pitch, Width, Height,
|
|
|
|
FRACUNIT, FRACUNIT, 0, 0);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
if (Screen->pitch == Pitch)
|
|
|
|
{
|
|
|
|
memcpy (Screen->pixels, MemBuffer, Width*Height);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
for (int y = 0; y < Height; ++y)
|
|
|
|
{
|
|
|
|
memcpy ((BYTE *)Screen->pixels+y*Screen->pitch, MemBuffer+y*Pitch, Width);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
SDL_UnlockSurface (Screen);
|
2011-01-23 07:37:08 +00:00
|
|
|
|
|
|
|
if (cursorSurface != NULL && GUICapture)
|
|
|
|
{
|
|
|
|
// SDL requires us to draw a surface to get true color cursors.
|
|
|
|
SDL_BlitSurface(cursorSurface, NULL, Screen, &cursorBlit);
|
|
|
|
}
|
|
|
|
|
2008-08-10 03:25:08 +00:00
|
|
|
SDLFlipCycles.Clock();
|
2006-02-24 04:48:15 +00:00
|
|
|
SDL_Flip (Screen);
|
2008-08-10 03:25:08 +00:00
|
|
|
SDLFlipCycles.Unclock();
|
2006-02-24 04:48:15 +00:00
|
|
|
|
2008-08-10 03:25:08 +00:00
|
|
|
BlitCycles.Unclock();
|
2006-02-24 04:48:15 +00:00
|
|
|
|
|
|
|
if (NeedGammaUpdate)
|
|
|
|
{
|
|
|
|
bool Windowed = false;
|
|
|
|
NeedGammaUpdate = false;
|
|
|
|
CalcGamma ((Windowed || rgamma == 0.f) ? Gamma : (Gamma * rgamma), GammaTable[0]);
|
|
|
|
CalcGamma ((Windowed || ggamma == 0.f) ? Gamma : (Gamma * ggamma), GammaTable[1]);
|
|
|
|
CalcGamma ((Windowed || bgamma == 0.f) ? Gamma : (Gamma * bgamma), GammaTable[2]);
|
|
|
|
NeedPalUpdate = true;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (NeedPalUpdate)
|
|
|
|
{
|
|
|
|
NeedPalUpdate = false;
|
|
|
|
UpdateColors ();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void SDLFB::UpdateColors ()
|
|
|
|
{
|
|
|
|
if (NotPaletted)
|
|
|
|
{
|
|
|
|
PalEntry palette[256];
|
|
|
|
|
|
|
|
for (int i = 0; i < 256; ++i)
|
|
|
|
{
|
|
|
|
palette[i].r = GammaTable[0][SourcePalette[i].r];
|
|
|
|
palette[i].g = GammaTable[1][SourcePalette[i].g];
|
|
|
|
palette[i].b = GammaTable[2][SourcePalette[i].b];
|
|
|
|
}
|
|
|
|
if (FlashAmount)
|
|
|
|
{
|
|
|
|
DoBlending (palette, palette,
|
|
|
|
256, GammaTable[0][Flash.r], GammaTable[1][Flash.g], GammaTable[2][Flash.b],
|
|
|
|
FlashAmount);
|
|
|
|
}
|
|
|
|
GPfx.SetPalette (palette);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
SDL_Color colors[256];
|
|
|
|
|
|
|
|
for (int i = 0; i < 256; ++i)
|
|
|
|
{
|
|
|
|
colors[i].r = GammaTable[0][SourcePalette[i].r];
|
|
|
|
colors[i].g = GammaTable[1][SourcePalette[i].g];
|
|
|
|
colors[i].b = GammaTable[2][SourcePalette[i].b];
|
|
|
|
}
|
|
|
|
if (FlashAmount)
|
|
|
|
{
|
|
|
|
DoBlending ((PalEntry *)colors, (PalEntry *)colors,
|
|
|
|
256, GammaTable[2][Flash.b], GammaTable[1][Flash.g], GammaTable[0][Flash.r],
|
|
|
|
FlashAmount);
|
|
|
|
}
|
|
|
|
SDL_SetPalette (Screen, SDL_LOGPAL|SDL_PHYSPAL, colors, 0, 256);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
PalEntry *SDLFB::GetPalette ()
|
|
|
|
{
|
|
|
|
return SourcePalette;
|
|
|
|
}
|
|
|
|
|
|
|
|
void SDLFB::UpdatePalette ()
|
|
|
|
{
|
|
|
|
NeedPalUpdate = true;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool SDLFB::SetGamma (float gamma)
|
|
|
|
{
|
|
|
|
Gamma = gamma;
|
|
|
|
NeedGammaUpdate = true;
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool SDLFB::SetFlash (PalEntry rgb, int amount)
|
|
|
|
{
|
|
|
|
Flash = rgb;
|
|
|
|
FlashAmount = amount;
|
|
|
|
NeedPalUpdate = true;
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
void SDLFB::GetFlash (PalEntry &rgb, int &amount)
|
|
|
|
{
|
|
|
|
rgb = Flash;
|
|
|
|
amount = FlashAmount;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Q: Should I gamma adjust the returned palette?
|
|
|
|
void SDLFB::GetFlashedPalette (PalEntry pal[256])
|
|
|
|
{
|
|
|
|
memcpy (pal, SourcePalette, 256*sizeof(PalEntry));
|
|
|
|
if (FlashAmount)
|
|
|
|
{
|
|
|
|
DoBlending (pal, pal, 256, Flash.r, Flash.g, Flash.b, FlashAmount);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
bool SDLFB::IsFullscreen ()
|
|
|
|
{
|
|
|
|
return (Screen->flags & SDL_FULLSCREEN) != 0;
|
|
|
|
}
|
|
|
|
|
2006-09-14 00:02:31 +00:00
|
|
|
ADD_STAT (blit)
|
2006-02-24 04:48:15 +00:00
|
|
|
{
|
2006-09-14 00:02:31 +00:00
|
|
|
FString out;
|
2008-08-10 03:25:08 +00:00
|
|
|
out.Format ("blit=%04.1f ms flip=%04.1f ms",
|
|
|
|
BlitCycles.Time() * 1e-3, SDLFlipCycles.TimeMS());
|
2006-09-14 00:02:31 +00:00
|
|
|
return out;
|
2006-02-24 04:48:15 +00:00
|
|
|
}
|