zdoom/gzdoom
0
0
Fork 0
mirror of https://github.com/ZDoom/gzdoom.git synced 2024-11-11 15:21:51 +00:00
Code Issues Projects Releases Packages Wiki Activity

- made win32gliface.cpp more readable.

Browse source
This commit is contained in:
Christoph Oelckers 2013-08-18 12:38:38 +02:00
parent 0a62e177d1
commit b59d82ad5b
1 changed files with 150 additions and 0 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

150
src/win32/win32gliface.cpp
View file

@ -33,6 +33,12 @@ RenderContext gl;
EXTERN_CVAR(Bool, gl_vid_compatibility)
EXTERN_CVAR(Int, vid_refreshrate)
//==========================================================================
//
//
//
//==========================================================================
Win32GLVideo::Win32GLVideo(int parm) : m_Modes(NULL), m_IsFullscreen(false)
{
#ifdef _WIN32
@ -50,16 +56,34 @@ Win32GLVideo::Win32GLVideo(int parm) : m_Modes(NULL), m_IsFullscreen(false)
}
//==========================================================================
//
//
//
//==========================================================================
Win32GLVideo::~Win32GLVideo()
{
FreeModes();
if (GLRenderer != NULL) GLRenderer->FlushTextures();
}
//==========================================================================
//
//
//
//==========================================================================
void Win32GLVideo::SetWindowedScale(float scale)
{
}
//==========================================================================
//
//
//
//==========================================================================
struct MonitorEnumState
{
int curIdx;
@ -89,6 +113,12 @@ static BOOL CALLBACK GetDisplayDeviceNameMonitorEnumProc(HMONITOR hMonitor, HDC,
return TRUE;
}
//==========================================================================
//
//
//
//==========================================================================
void Win32GLVideo::GetDisplayDeviceName()
{
// If anything goes wrong, anything at all, everything uses the primary
@ -121,6 +151,12 @@ void Win32GLVideo::GetDisplayDeviceName()
}
}
//==========================================================================
//
//
//
//==========================================================================
void Win32GLVideo::MakeModesList()
{
ModeInfo *pMode, *nextmode;
@ -153,6 +189,12 @@ void Win32GLVideo::MakeModesList()
}
}
//==========================================================================
//
//
//
//==========================================================================
void Win32GLVideo::StartModeIterator(int bits, bool fs)
{
m_IteratorMode = m_Modes;
@ -162,6 +204,12 @@ void Win32GLVideo::StartModeIterator(int bits, bool fs)
m_IteratorFS = fs;
}
//==========================================================================
//
//
//
//==========================================================================
bool Win32GLVideo::NextMode(int *width, int *height, bool *letterbox)
{
if (m_IteratorMode)
@ -184,6 +232,12 @@ bool Win32GLVideo::NextMode(int *width, int *height, bool *letterbox)
return false;
}
//==========================================================================
//
//
//
//==========================================================================
void Win32GLVideo::AddMode(int x, int y, int bits, int baseHeight, int refreshHz)
{
ModeInfo **probep = &m_Modes;
@ -213,6 +267,12 @@ void Win32GLVideo::AddMode(int x, int y, int bits, int baseHeight, int refreshHz
(*probep)->next = probe;
}
//==========================================================================
//
//
//
//==========================================================================
void Win32GLVideo::FreeModes()
{
ModeInfo *mode = m_Modes;
@ -227,6 +287,12 @@ void Win32GLVideo::FreeModes()
m_Modes = NULL;
}
//==========================================================================
//
//
//
//==========================================================================
bool Win32GLVideo::GoFullscreen(bool yes)
{
m_IsFullscreen = yes;
@ -258,6 +324,12 @@ bool Win32GLVideo::GoFullscreen(bool yes)
}
//==========================================================================
//
//
//
//==========================================================================
DFrameBuffer *Win32GLVideo::CreateFrameBuffer(int width, int height, bool fs, DFrameBuffer *old)
{
Win32GLFrameBuffer *fb;
@ -302,6 +374,12 @@ DFrameBuffer *Win32GLVideo::CreateFrameBuffer(int width, int height, bool fs, DF
return fb;
}
//==========================================================================
//
//
//
//==========================================================================
bool Win32GLVideo::SetResolution (int width, int height, int bits)
{
if (GLRenderer != NULL) GLRenderer->FlushTextures();
@ -316,6 +394,12 @@ bool Win32GLVideo::SetResolution (int width, int height, int bits)
return true; // We must return true because the old video context no longer exists.
}
//==========================================================================
//
//
//
//==========================================================================
struct DumpAdaptersState
{
unsigned index;
@ -359,6 +443,12 @@ static BOOL CALLBACK DumpAdaptersMonitorEnumProc(HMONITOR hMonitor, HDC, LPRECT,
return TRUE;
}
//==========================================================================
//
//
//
//==========================================================================
void Win32GLVideo::DumpAdapters()
{
DumpAdaptersState das;
@ -369,8 +459,20 @@ void Win32GLVideo::DumpAdapters()
EnumDisplayMonitors(0, 0, DumpAdaptersMonitorEnumProc, LPARAM(&das));
}
//==========================================================================
//
//
//
//==========================================================================
IMPLEMENT_ABSTRACT_CLASS(Win32GLFrameBuffer)
//==========================================================================
//
//
//
//==========================================================================
Win32GLFrameBuffer::Win32GLFrameBuffer(void *hMonitor, int width, int height, int bits, int refreshHz, bool fullscreen) : BaseWinFB(width, height)
{
static int localmultisample=-1;
@ -448,6 +550,12 @@ Win32GLFrameBuffer::Win32GLFrameBuffer(void *hMonitor, int width, int height, in
ReleaseDC(Window, hDC);
}
//==========================================================================
//
//
//
//==========================================================================
Win32GLFrameBuffer::~Win32GLFrameBuffer()
{
if (m_supportsGamma)
@ -470,16 +578,34 @@ Win32GLFrameBuffer::~Win32GLFrameBuffer()
}
//==========================================================================
//
//
//
//==========================================================================
void Win32GLFrameBuffer::InitializeState()
{
}
//==========================================================================
//
//
//
//==========================================================================
bool Win32GLFrameBuffer::CanUpdate()
{
if (!AppActive) return false;
return true;
}
//==========================================================================
//
//
//
//==========================================================================
void Win32GLFrameBuffer::SetGammaTable(WORD *tbl)
{
HDC hDC = GetDC(Window);
@ -487,6 +613,12 @@ void Win32GLFrameBuffer::SetGammaTable(WORD *tbl)
ReleaseDC(Window, hDC);
}
//==========================================================================
//
//
//
//==========================================================================
bool Win32GLFrameBuffer::Lock(bool buffered)
{
m_Lock++;
@ -509,6 +641,12 @@ bool Win32GLFrameBuffer::IsLocked ()
return m_Lock>0;// true;
}
//==========================================================================
//
//
//
//==========================================================================
bool Win32GLFrameBuffer::IsFullscreen()
{
return m_Fullscreen;
@ -546,11 +684,23 @@ void Win32GLFrameBuffer::ReleaseResources ()
{
}
//==========================================================================
//
//
//
//==========================================================================
void Win32GLFrameBuffer::SetVSync (bool vsync)
{
if (gl.SetVSync!=NULL) gl.SetVSync(vsync);
}
//==========================================================================
//
//
//
//==========================================================================
void Win32GLFrameBuffer::NewRefreshRate ()
{
if (m_Fullscreen)