/*

SDL - Simple DirectMedia Layer

This library is free software; you can redistribute it and/or

This library is distributed in the hope that it will be useful,

but WITHOUT ANY WARRANTY; without even the implied warranty of

MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

You should have received a copy of the GNU Lesser General Public

License along with this library; if not, write to the Free Software

Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA

Sam Lantinga

/* WGL implementation of SDL OpenGL support */

#include "SDL_lowvideo.h"

#include "SDL_wingl_c.h"

#define DEFAULT_GL_DRIVER_PATH "OPENGL32.DLL"

#endif

int status = 0;

#ifndef _WIN32_WCE /* FIXME WinCE needs the UNICODE version of CreateWindow() */

/* This doesn't work with DirectX code (see CVS comments) */

/* If we were passed a window, then we can't create a new one */

/* Save the existing window attributes */

LONG style;

RECT rect = { 0, 0, 0, 0 };

style = GetWindowLong(SDL_Window, GWL_STYLE);

GetWindowRect(SDL_Window, &rect);

DestroyWindow(SDL_Window);

WIN_FlushMessageQueue();

SDL_Window = CreateWindow(SDL_Appname, SDL_Appname,

style,

rect.left, rect.top,

(rect.right - rect.left) + 1,

(rect.top - rect.bottom) + 1,

NULL, NULL, SDL_Instance, NULL);

WIN_FlushMessageQueue();

if (SDL_Window) {

status = -1;

}

} else

status = -1;

}

return (status);

const char *start;

const char *where, *terminator;

/* Extension names should not have spaces. */

if (where || *extension == '\0')

return 0;

if (!extensions)

return 0;

/* It takes a bit of care to be fool-proof about parsing the

* OpenGL extensions string. Don't be fooled by sub-strings,

* etc. */

start = extensions;

for (;;) {

if (!where)

break;

if (where == start || *(where - 1) == ' ')

if (*terminator == ' ' || *terminator == '\0')

return 1;

start = terminator;

}

return 0;

}

HWND hwnd;

HDC hdc;

HGLRC hglrc;

int pformat;

const char *(WINAPI * wglGetExtensionsStringARB) (HDC) = 0;

const char *extensions;

hwnd = CreateWindow(SDL_Appname, SDL_Appname, WS_POPUP | WS_DISABLED,

0, 0, 10, 10, NULL, NULL, SDL_Instance, NULL);

WIN_FlushMessageQueue();

pformat = ChoosePixelFormat(hdc, &GL_pfd);

SetPixelFormat(hdc, pformat, &GL_pfd);

}

wglGetExtensionsStringARB = (const char *(WINAPI *) (HDC))

if (wglGetExtensionsStringARB) {

} else {

extensions = NULL;

}

this->gl_data->WGL_ARB_pixel_format = 0;

if (ExtensionSupported("WGL_ARB_pixel_format", extensions)) {

this->gl_data->wglChoosePixelFormatARB = (BOOL(WINAPI *)

(HDC, const int *,

const FLOAT *, UINT, int *,

UINT *))

this->gl_data->wglGetProcAddress("wglChoosePixelFormatARB");

(BOOL(WINAPI *) (HDC, int, int, UINT, const int *, int *))

this->gl_data->wglGetProcAddress("wglGetPixelFormatAttribivARB");

if ((this->gl_data->wglChoosePixelFormatARB != NULL) &&

(this->gl_data->wglGetPixelFormatAttribivARB != NULL)) {

this->gl_data->WGL_ARB_pixel_format = 1;

}

}

if (hglrc) {

this->gl_data->wglMakeCurrent(NULL, NULL);

this->gl_data->wglDeleteContext(hglrc);

ReleaseDC(hwnd, hdc);

DestroyWindow(hwnd);

WIN_FlushMessageQueue();

int i;

unsigned int matching;

int iAttribs[64];

int *iAttr;

float fAttribs[1] = { 0 };

const GLubyte *(WINAPI * glGetStringFunc) (GLenum);

const char *wglext;

/* load the gl driver from a default path */

if (!this->gl_config.driver_loaded) {

/* no driver has been loaded, use default (ourselves) */

return (-1);

}

}

for (i = 0;; ++i) {

/* Get the window device context for our OpenGL drawing */

return (-1);

}

/* Set up the pixel format descriptor with our needed format */

SDL_memset(&GL_pfd, 0, sizeof(GL_pfd));

GL_pfd.nSize = sizeof(GL_pfd);

GL_pfd.nVersion = 1;

GL_pfd.dwFlags = (PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL);

if (this->gl_config.double_buffer) {

GL_pfd.dwFlags |= PFD_DOUBLEBUFFER;

}

if (this->gl_config.stereo) {

GL_pfd.dwFlags |= PFD_STEREO;

}

GL_pfd.iPixelType = PFD_TYPE_RGBA;

GL_pfd.cColorBits = this->gl_config.buffer_size;

GL_pfd.cRedBits = this->gl_config.red_size;

GL_pfd.cGreenBits = this->gl_config.green_size;

GL_pfd.cBlueBits = this->gl_config.blue_size;

GL_pfd.cAlphaBits = this->gl_config.alpha_size;

GL_pfd.cAccumRedBits = this->gl_config.accum_red_size;

GL_pfd.cAccumGreenBits = this->gl_config.accum_green_size;

GL_pfd.cAccumBlueBits = this->gl_config.accum_blue_size;

GL_pfd.cAccumAlphaBits = this->gl_config.accum_alpha_size;

GL_pfd.cAccumBits =

(GL_pfd.cAccumRedBits + GL_pfd.cAccumGreenBits +

GL_pfd.cAccumBlueBits + GL_pfd.cAccumAlphaBits);

GL_pfd.cDepthBits = this->gl_config.depth_size;

GL_pfd.cStencilBits = this->gl_config.stencil_size;

/* initialize WGL_ARB_pixel_format */

/* setup WGL_ARB_pixel_format attribs */

iAttr = &iAttribs[0];

*iAttr++ = WGL_DRAW_TO_WINDOW_ARB;

*iAttr++ = GL_TRUE;

*iAttr++ = WGL_ACCELERATION_ARB;

*iAttr++ = WGL_FULL_ACCELERATION_ARB;

*iAttr++ = WGL_RED_BITS_ARB;

*iAttr++ = this->gl_config.red_size;

*iAttr++ = WGL_GREEN_BITS_ARB;

*iAttr++ = this->gl_config.green_size;

*iAttr++ = WGL_BLUE_BITS_ARB;

*iAttr++ = this->gl_config.blue_size;

if (this->gl_config.alpha_size) {

*iAttr++ = WGL_ALPHA_BITS_ARB;

*iAttr++ = this->gl_config.alpha_size;

}

*iAttr++ = WGL_DOUBLE_BUFFER_ARB;

*iAttr++ = this->gl_config.double_buffer;

*iAttr++ = WGL_DEPTH_BITS_ARB;

*iAttr++ = this->gl_config.depth_size;

if (this->gl_config.stencil_size) {

*iAttr++ = WGL_STENCIL_BITS_ARB;

*iAttr++ = this->gl_config.stencil_size;

}

if (this->gl_config.accum_red_size) {

*iAttr++ = WGL_ACCUM_RED_BITS_ARB;

*iAttr++ = this->gl_config.accum_red_size;

}

if (this->gl_config.accum_green_size) {

*iAttr++ = WGL_ACCUM_GREEN_BITS_ARB;

*iAttr++ = this->gl_config.accum_green_size;

}

if (this->gl_config.accum_blue_size) {

*iAttr++ = WGL_ACCUM_BLUE_BITS_ARB;

*iAttr++ = this->gl_config.accum_blue_size;

}

if (this->gl_config.accum_alpha_size) {

*iAttr++ = WGL_ACCUM_ALPHA_BITS_ARB;

*iAttr++ = this->gl_config.accum_alpha_size;

}

if (this->gl_config.stereo) {

*iAttr++ = WGL_STEREO_ARB;

*iAttr++ = GL_TRUE;

}

if (this->gl_config.multisamplebuffers) {

*iAttr++ = WGL_SAMPLE_BUFFERS_ARB;

*iAttr++ = this->gl_config.multisamplebuffers;

}

if (this->gl_config.multisamplesamples) {

*iAttr++ = WGL_SAMPLES_ARB;

*iAttr++ = this->gl_config.multisamplesamples;

}

if (this->gl_config.accelerated >= 0) {

*iAttr++ = WGL_ACCELERATION_ARB;

*iAttr++ =

(this->gl_config.

accelerated ? WGL_GENERIC_ACCELERATION_ARB :

WGL_NO_ACCELERATION_ARB);

}

*iAttr = 0;

/* Choose and set the closest available pixel format */

if (!this->gl_data->WGL_ARB_pixel_format ||

!this->gl_data->wglChoosePixelFormatARB(GL_hdc, iAttribs,

fAttribs, 1,

&pixel_format, &matching)

this->gl_data->WGL_ARB_pixel_format = 0;

}

if (!pixel_format) {

return (-1);

}

if (i == 0) {

/* First time through, try resetting the window */

return (-1);

}

continue;

}

return (-1);

}

/* We either succeeded or failed by this point */

break;

}

return (-1);

}

return (-1);

}

gl_active = 1;

/* Vsync control under Windows. Checking glGetString here is

* somewhat a documented and reliable hack - it was originally

* as a feature added by mistake, but since so many people rely

* on it, it will not be removed. strstr should be safe here.*/

} else {

/* Uh oh, something is seriously wrong here... */

wglext = NULL;

}

if (wglext && SDL_strstr(wglext, "WGL_EXT_swap_control")) {

this->gl_data->wglSwapIntervalEXT =

WIN_GL_GetProcAddress(this, "wglSwapIntervalEXT");

this->gl_data->wglGetSwapIntervalEXT =

WIN_GL_GetProcAddress(this, "wglGetSwapIntervalEXT");

} else {

this->gl_data->wglSwapIntervalEXT = NULL;

this->gl_data->wglGetSwapIntervalEXT = NULL;

}

if (this->gl_config.swap_control >= 0) {

if (this->gl_data->wglSwapIntervalEXT) {

}

}

if (gl_active) {

retval = 0;

} else {

retval = -1;

}

return (retval);

}

/* Clean up OpenGL */

if (GL_hrc) {

this->gl_data->wglMakeCurrent(NULL, NULL);

this->gl_data->wglDeleteContext(GL_hrc);

GL_hrc = NULL;

}

if (GL_hdc) {

GL_hdc = NULL;

}

gl_active = 0;

}

/* Make the current context active */

int retval;

retval = 0;

if (!this->gl_data->wglMakeCurrent(GL_hdc, GL_hrc)) {

SDL_SetError("Unable to make GL context current");

retval = -1;

}

return (retval);

}

/* Get attribute data from glX. */

int retval;

if (this->gl_data->WGL_ARB_pixel_format) {

int wgl_attrib;

switch (attrib) {

case SDL_GL_RED_SIZE:

wgl_attrib = WGL_RED_BITS_ARB;

break;

case SDL_GL_GREEN_SIZE:

wgl_attrib = WGL_GREEN_BITS_ARB;

break;

case SDL_GL_BLUE_SIZE:

wgl_attrib = WGL_BLUE_BITS_ARB;

break;

case SDL_GL_ALPHA_SIZE:

wgl_attrib = WGL_ALPHA_BITS_ARB;

break;

case SDL_GL_DOUBLEBUFFER:

wgl_attrib = WGL_DOUBLE_BUFFER_ARB;

break;

case SDL_GL_BUFFER_SIZE:

wgl_attrib = WGL_COLOR_BITS_ARB;

break;

case SDL_GL_DEPTH_SIZE:

wgl_attrib = WGL_DEPTH_BITS_ARB;

break;

case SDL_GL_STENCIL_SIZE:

wgl_attrib = WGL_STENCIL_BITS_ARB;

break;

case SDL_GL_ACCUM_RED_SIZE:

wgl_attrib = WGL_ACCUM_RED_BITS_ARB;

break;

case SDL_GL_ACCUM_GREEN_SIZE:

wgl_attrib = WGL_ACCUM_GREEN_BITS_ARB;

break;

case SDL_GL_ACCUM_BLUE_SIZE:

wgl_attrib = WGL_ACCUM_BLUE_BITS_ARB;

break;

case SDL_GL_ACCUM_ALPHA_SIZE:

wgl_attrib = WGL_ACCUM_ALPHA_BITS_ARB;

break;

case SDL_GL_STEREO:

wgl_attrib = WGL_STEREO_ARB;

break;

case SDL_GL_MULTISAMPLEBUFFERS:

wgl_attrib = WGL_SAMPLE_BUFFERS_ARB;

break;

case SDL_GL_MULTISAMPLESAMPLES:

wgl_attrib = WGL_SAMPLES_ARB;

break;

case SDL_GL_ACCELERATED_VISUAL:

wgl_attrib = WGL_ACCELERATION_ARB;

this->gl_data->wglGetPixelFormatAttribivARB(GL_hdc, pixel_format,

0, 1, &wgl_attrib,

if (*value == WGL_NO_ACCELERATION_ARB) {

*value = SDL_FALSE;

} else {

*value = SDL_TRUE;

}

return 0;

break;

case SDL_GL_SWAP_CONTROL:

if (this->gl_data->wglGetSwapIntervalEXT) {

*value = this->gl_data->wglGetSwapIntervalEXT();

return 0;

} else {

return -1;

}

default:

return (-1);

}

this->gl_data->wglGetPixelFormatAttribivARB(GL_hdc, pixel_format, 0,

1, &wgl_attrib, value);

return 0;

}

retval = 0;

switch (attrib) {

case SDL_GL_RED_SIZE:

*value = GL_pfd.cRedBits;

break;

case SDL_GL_GREEN_SIZE:

*value = GL_pfd.cGreenBits;

break;

case SDL_GL_BLUE_SIZE:

*value = GL_pfd.cBlueBits;

break;

case SDL_GL_ALPHA_SIZE:

*value = GL_pfd.cAlphaBits;

break;

case SDL_GL_DOUBLEBUFFER:

if (GL_pfd.dwFlags & PFD_DOUBLEBUFFER) {

*value = 1;

} else {

*value = 0;

}

break;

case SDL_GL_BUFFER_SIZE:

*value = GL_pfd.cColorBits;

break;

case SDL_GL_DEPTH_SIZE:

*value = GL_pfd.cDepthBits;

break;

case SDL_GL_STENCIL_SIZE:

*value = GL_pfd.cStencilBits;

break;

case SDL_GL_ACCUM_RED_SIZE:

*value = GL_pfd.cAccumRedBits;

break;

case SDL_GL_ACCUM_GREEN_SIZE:

*value = GL_pfd.cAccumGreenBits;

break;

case SDL_GL_ACCUM_BLUE_SIZE:

*value = GL_pfd.cAccumBlueBits;

break;

case SDL_GL_ACCUM_ALPHA_SIZE:

*value = GL_pfd.cAccumAlphaBits;

break;

case SDL_GL_STEREO:

if (GL_pfd.dwFlags & PFD_STEREO) {

*value = 1;

} else {

*value = 0;

}

break;

case SDL_GL_MULTISAMPLEBUFFERS:

*value = 0;

break;

case SDL_GL_MULTISAMPLESAMPLES:

*value = 1;

break;

case SDL_GL_SWAP_CONTROL:

if (this->gl_data->wglGetSwapIntervalEXT) {

*value = this->gl_data->wglGetSwapIntervalEXT();

return 0;

} else {

return -1;

}

break;

default:

retval = -1;

break;

}

return retval;

}

}

this->gl_data->wglGetProcAddress = NULL;

this->gl_data->wglCreateContext = NULL;

this->gl_data->wglDeleteContext = NULL;

this->gl_data->wglMakeCurrent = NULL;

this->gl_data->wglChoosePixelFormatARB = NULL;

this->gl_data->wglGetPixelFormatAttribivARB = NULL;

this->gl_data->wglSwapIntervalEXT = NULL;

this->gl_data->wglGetSwapIntervalEXT = NULL;

this->gl_config.dll_handle = NULL;

this->gl_config.driver_loaded = 0;

}

}

/* Passing a NULL path means load pointers from the application */

HMODULE handle;

if (gl_active) {

return -1;

}

if (path == NULL) {

path = DEFAULT_GL_DRIVER_PATH;

}

return -1;

}

/* Unload the old driver and reset the pointers */

/* Load new function pointers */

GetProcAddress(handle, "wglGetProcAddress");

this->gl_data->wglCreateContext = (HGLRC(WINAPI *) (HDC))

GetProcAddress(handle, "wglCreateContext");

this->gl_data->wglDeleteContext = (BOOL(WINAPI *) (HGLRC))

GetProcAddress(handle, "wglDeleteContext");

this->gl_data->wglMakeCurrent = (BOOL(WINAPI *) (HDC, HGLRC))

GetProcAddress(handle, "wglMakeCurrent");

if ((this->gl_data->wglGetProcAddress == NULL) ||

(this->gl_data->wglCreateContext == NULL) ||

(this->gl_data->wglDeleteContext == NULL) ||

(this->gl_data->wglMakeCurrent == NULL)) {

SDL_SetError("Could not retrieve OpenGL functions");

FreeLibrary(handle);

return -1;

}

this->gl_config.dll_handle = handle;

SDL_strlcpy(this->gl_config.driver_path, path,

SDL_arraysize(this->gl_config.driver_path));

this->gl_config.driver_loaded = 1;

return 0;

}

void *func;

/* This is to pick up extensions */

if (!func) {

/* This is probably a normal GL function */

}

return func;

}