sdl-ios-xcode: src/video/SDL_video.c comparison

comparison src/video/SDL_video.c @ 1912:8d384b647307

Setting up the OpenGL support

author	Sam Lantinga <slouken@libsdl.org>
date	Sun, 16 Jul 2006 09:34:01 +0000
parents	8f1ab2f7c722
children	83420da906a5

comparison

equal deleted inserted replaced

-:7577fd11cee4
+:8d384b647307
 }
 if (a.refresh_rate != b.refresh_rate) {
 return b.refresh_rate - a.refresh_rate;
 }
 return 0;
+}
+static void
+SDL_UninitializedVideo()
+{
+SDL_SetError("Video subsystem has not been initialized");
 }
 int
 SDL_GetNumVideoDrivers(void)
 {
 const char *
 SDL_GetCurrentVideoDriver()
 {
 if (!_this) {
+SDL_UninitializedVideo();
 return NULL;
 }
 return _this->name;
 }
 int
 SDL_GetNumVideoDisplays(void)
 {
 if (!_this) {
+SDL_UninitializedVideo();
 return 0;
 }
 return _this->num_displays;
 }
 int
 SDL_SelectVideoDisplay(int index)
 {
 if (!_this) {
-SDL_SetError("Video subsystem has not been initialized");
+SDL_UninitializedVideo();
 return (-1);
 }
 if (index >= 0) {
 if (index >= _this->num_displays) {
 SDL_SetError("index must be in the range 0 - %d",
 SDL_VideoDisplay *display;
 SDL_DisplayMode display_mode;
 int i, ncolors;
 if (!_this) {
-SDL_SetError("Video subsystem has not been initialized");
+SDL_UninitializedVideo();
 return -1;
 }
 if (!mode) {
 mode = SDL_GetDesktopDisplayMode();
 {
 SDL_VideoDisplay *display;
 int i;
 if (!_this) {
-SDL_SetError("Video subsystem has not been initialized");
+SDL_UninitializedVideo();
 return -1;
 }
 display = &SDL_CurrentDisplay;
 if (mode) {
 {
 SDL_Palette *palette;
 int status = 0;
 if (!_this) {
-SDL_SetError("Video subsystem has not been initialized");
+SDL_UninitializedVideo();
 return -1;
 }
 palette = SDL_CurrentDisplay.palette;
 if (!palette) {
 SDL_SetError("Display mode does not have a palette");
 SDL_GetDisplayPalette(SDL_Color * colors, int firstcolor, int ncolors)
 {
 SDL_Palette *palette;
 if (!_this) {
-SDL_SetError("Video subsystem has not been initialized");
+SDL_UninitializedVideo();
 return -1;
 }
 palette = SDL_CurrentDisplay.palette;
 if (!palette->ncolors) {
 SDL_Window window;
 int num_windows;
 SDL_Window *windows;
 if (!_this) {
-SDL_SetError("Video subsystem has not been initialized");
+SDL_UninitializedVideo();
+return 0;
+}
+if ((flags & SDL_WINDOW_OPENGL) && !_this->GL_CreateContext) {
+SDL_SetError("No OpenGL support in video driver");
 return 0;
 }
 SDL_zero(window);
 window.id = _this->next_object_id++;
 SDL_Window window;
 int num_windows;
 SDL_Window *windows;
 if (!_this) {
-SDL_SetError("Video subsystem has not been initialized");
+SDL_UninitializedVideo();
 return (0);
 }
 SDL_zero(window);
 window.id = _this->next_object_id++;
 SDL_GetWindowFromID(SDL_WindowID windowID)
 {
 int i, j;
 if (!_this) {
+SDL_UninitializedVideo();
 return NULL;
 }
 for (i = 0; i < _this->num_displays; ++i) {
 SDL_VideoDisplay *display = &_this->displays[i];
 SDL_VideoDisplay *
 SDL_GetDisplayFromWindow(SDL_Window * window)
 {
 if (!_this) {
+SDL_UninitializedVideo();
 return NULL;
 }
 return &_this->displays[window->display];
 }
 int
 SDL_GetRendererInfo(int index, SDL_RendererInfo * info)
 {
 if (!_this) {
+SDL_UninitializedVideo();
 return -1;
 }
 if (index >= SDL_GetNumRenderers()) {
 SDL_SetError("index must be in the range of 0 - %d",
 int hash;
 SDL_Renderer *renderer;
 SDL_Texture *texture;
 if (!_this) {
+SDL_UninitializedVideo();
 return 0;
 }
 renderer = SDL_CurrentDisplay.current_renderer;
 if (!renderer || !renderer->CreateTexture) {
 SDL_Renderer *renderer;
 SDL_Window *window;
 SDL_Rect real_rect;
 if (!_this) {
+SDL_UninitializedVideo();
 return -1;
 }
 renderer = SDL_CurrentDisplay.current_renderer;
 if (!renderer || !renderer->RenderFill) {
 SDL_RenderPresent(void)
 {
 SDL_Renderer *renderer;
 if (!_this) {
+SDL_UninitializedVideo();
 return;
 }
 renderer = SDL_CurrentDisplay.current_renderer;
 if (!renderer || !renderer->RenderPresent) {
 int hash;
 SDL_Texture *prev, *texture;
 SDL_Renderer *renderer;
 if (!_this) {
+SDL_UninitializedVideo();
 return;
 }
 /* Look up the texture in the hash table */
 hash = (textureID % SDL_arraysize(SDL_CurrentDisplay.textures));
 }
 _this->free(_this);
 _this = NULL;
 }
-/* Load the GL driver library */
 int
 SDL_GL_LoadLibrary(const char *path)
 {
 int retval;
-retval = -1;
+if (!_this) {
-if (_this == NULL) {
+SDL_UninitializedVideo();
-SDL_SetError("Video subsystem has not been initialized");
+return -1;
+}
+if (_this->GL_LoadLibrary) {
+retval = _this->GL_LoadLibrary(_this, path);
 } else {
-if (_this->GL_LoadLibrary) {
+SDL_SetError("No dynamic GL support in video driver");
-retval = _this->GL_LoadLibrary(_this, path);
+retval = -1;
-} else {
-SDL_SetError("No dynamic GL support in video driver");
-}
 }
 return (retval);
 }
 void *
 SDL_GL_GetProcAddress(const char *proc)
 {
 void *func;
+if (!_this) {
+SDL_UninitializedVideo();
+return NULL;
+}
 func = NULL;
 if (_this->GL_GetProcAddress) {
 if (_this->gl_config.driver_loaded) {
 func = _this->GL_GetProcAddress(_this, proc);
 SDL_SetError("No dynamic GL support in video driver");
 }
 return func;
 }
-/* Set the specified GL attribute for setting up a GL video mode */
 int
 SDL_GL_SetAttribute(SDL_GLattr attr, int value)
 {
 int retval;
+if (!_this) {
+SDL_UninitializedVideo();
+return -1;
+}
 retval = 0;
 switch (attr) {
 case SDL_GL_RED_SIZE:
 _this->gl_config.red_size = value;
 default:
 SDL_SetError("Unknown OpenGL attribute");
 retval = -1;
 break;
 }
-return (retval);
+return retval;
 }
-/* Retrieve an attribute value from the windowing system. */
+int
-int
+SDL_GL_GetWindowAttribute(SDL_WindowID windowID, SDL_GLattr attr, int *value)
-SDL_GL_GetAttribute(SDL_GLattr attr, int *value)
+{
-{
+SDL_Window *window = SDL_GetWindowFromID(windowID);
-int retval = -1;
+int retval;
+if (!window) {
+return -1;
+}
 if (_this->GL_GetAttribute) {
 retval = _this->GL_GetAttribute(_this, attr, value);
 } else {
 *value = 0;
 SDL_SetError("GL_GetAttribute not supported");
+retval = -1;
 }
 return retval;
 }
-/* Perform a GL buffer swap on the current GL context */
+SDL_GLContext
-void
+SDL_GL_CreateContext(SDL_WindowID windowID)
-SDL_GL_SwapBuffers(void)
+{
-{
+SDL_Window *window = SDL_GetWindowFromID(windowID);
-// FIXME: Track the current window context - do we provide N contexts, and match them to M windows, or is there a one-to-one mapping?
-_this->GL_SwapBuffers(_this);
+if (!window) {
+return NULL;
+}
+if (!(window->flags & SDL_WINDOW_OPENGL)) {
+SDL_SetError("The specified window isn't an OpenGL window");
+return NULL;
+}
+return _this->GL_CreateContext(_this, window);
+}
+int
+SDL_GL_MakeCurrent(SDL_WindowID windowID, SDL_GLContext context)
+{
+SDL_Window *window = SDL_GetWindowFromID(windowID);
+if (!window || !context) {
+return -1;
+}
+if (!(window->flags & SDL_WINDOW_OPENGL)) {
+SDL_SetError("The specified window isn't an OpenGL window");
+return -1;
+}
+return _this->GL_MakeCurrent(_this, window, context);
+}
+int
+SDL_GL_SetSwapInterval(int interval)
+{
+if (!_this) {
+SDL_UninitializedVideo();
+return -1;
+}
+if (_this->GL_SetSwapInterval) {
+return _this->GL_SetSwapInterval(_this, interval);
+} else {
+SDL_SetError("Setting the swap interval is not supported");
+return -1;
+}
+}
+int
+SDL_GL_GetSwapInterval(void)
+{
+if (!_this) {
+SDL_UninitializedVideo();
+return -1;
+}
+if (_this->GL_GetSwapInterval) {
+return _this->GL_GetSwapInterval(_this);
+} else {
+SDL_SetError("Getting the swap interval is not supported");
+return -1;
+}
+}
+void
+SDL_GL_SwapWindow(SDL_WindowID windowID)
+{
+SDL_Window *window = SDL_GetWindowFromID(windowID);
+if (!window) {
+return;
+}
+if (!(window->flags & SDL_WINDOW_OPENGL)) {
+SDL_SetError("The specified window isn't an OpenGL window");
+return;
+}
+return _this->GL_SwapWindow(_this, window);
+}
+void
+SDL_GL_DeleteContext(SDL_GLContext context)
+{
+if (!_this || !context) {
+return;
+}
+_this->GL_DeleteContext(_this, context);
 }
 #if 0                           // FIXME
 /* Utility function used by SDL_WM_SetIcon();
 * flags & 1 for color key, flags & 2 for alpha channel. */

Mercurial > sdl-ios-xcode

comparison src/video/SDL_video.c @ 1912:8d384b647307