Mercurial > sdl-ios-xcode
diff src/video/qnxgf/SDL_qnxgf.c @ 3087:0b6f51c29267
Date: Wed, 4 Mar 2009 15:38:22 +0200
From: "Mike Gorchak"
Subject: Re: About QNX support in SDL 1.3
Here is another batch of patches.
1) Makefile.in - added SDL_opengles.h header as header to install.
2) configure.in - Added special define to detect Common Lite OpenGL ES
library in case if Common library is not installed. Added check for
clock_gettime in libc (in QNX it is in libc).
3) SDL_config.h.in - Added SDL_VIDEO_RENDER_OPENGL_ES and
SDL_VIDEO_OPENGL_ES declarations for configure script autodetection.
4) SDL_opengles.h - Added GL_API definition if it is not defined. Added
extension GL_OES_draw_texture because OpenGL ES Renderer uses it without
declaration. Added GL_OES_vertex_buffer_object extension, which is supported
under QNX OpenGL ES. Added GL_OES_single_precision extension.
5) To the test directory I've added building OpenGL ES test applications
through the autotools suite. Was support for iPhone IDE building only.
author | Sam Lantinga <slouken@libsdl.org> |
---|---|
date | Wed, 04 Mar 2009 15:10:47 +0000 |
parents | 0bc41e0361d3 |
children | cad1aefa2ed9 |
line wrap: on
line diff
--- a/src/video/qnxgf/SDL_qnxgf.c Wed Mar 04 09:35:32 2009 +0000 +++ b/src/video/qnxgf/SDL_qnxgf.c Wed Mar 04 15:10:47 2009 +0000 @@ -23,13 +23,543 @@ #include "SDL_config.h" #include "../SDL_sysvideo.h" +#include "SDL_version.h" +#include "SDL_syswm.h" + +/* Include QNX Graphics Framework declarations */ +#include <gf/gf.h> + +#include "SDL_qnxgf.h" +#include "SDL_gf_pixelfmt.h" + +/******************************************************************************/ +/* SDL Generic video modes, which could provide GF */ +/* This is real pain in the ass. GF is just wrapper around a selected driver */ +/* some drivers could support double scan modes, like 320x200, 512x384, etc */ +/* but some drivers are not. Later we can distinguish one driver from another */ +/* Feel free to add any new custom graphics mode */ +/******************************************************************************/ +static SDL_DisplayMode generic_mode[]= +{ + {0, 320, 200, 70, NULL}, /* 320x200 modes are 70Hz and 85Hz */ + {0, 320, 200, 85, NULL}, + {0, 320, 240, 70, NULL}, /* 320x240 modes are 70Hz and 85Hz */ + {0, 320, 240, 85, NULL}, + {0, 512, 384, 60, NULL}, /* 512x384 modes are 60Hz and 70Hz */ + {0, 512, 384, 70, NULL}, + {0, 640, 480, 60, NULL}, /* 640x480 modes are 60Hz, 75Hz, 85Hz */ + {0, 640, 480, 75, NULL}, + {0, 640, 480, 85, NULL}, + {0, 800, 600, 60, NULL}, /* 800x600 modes are 60Hz, 75Hz, 85Hz */ + {0, 800, 600, 75, NULL}, + {0, 800, 600, 85, NULL}, + {0, 800, 480, 60, NULL}, /* 800x480 mode is 60Hz only */ + {0, 1024, 640, 60, NULL}, /* 1024x640 mode is 60Hz only */ + {0, 1024, 768, 60, NULL}, /* 1024x768 modes are 60Hz, 70Hz, 75Hz */ + {0, 1024, 768, 70, NULL}, + {0, 1024, 768, 75, NULL}, + {0, 1280, 720, 60, NULL}, /* 1280x720 mode is 60Hz only */ + {0, 1280, 768, 60, NULL}, /* 1280x768 mode is 60Hz only */ + {0, 1280, 800, 60, NULL}, /* 1280x800 mode is 60Hz only */ + {0, 1280, 960, 60, NULL}, /* 1280x960 mode is 60Hz only */ + {0, 1280, 1024, 60, NULL}, /* 1280x1024 mode is 60Hz only */ + {0, 1400, 1050, 60, NULL}, /* 1400x1050 mode is 60Hz only */ + {0, 1440, 900, 60, NULL}, /* 1440x900 mode is 60Hz only */ + {0, 1440, 960, 60, NULL}, /* 1440x960 mode is 60Hz only */ + {0, 1600, 1200, 60, NULL}, /* 1600x1200 mode is 60Hz only */ + {0, 1680, 1050, 60, NULL}, /* 1680x1050 mode is 60Hz only */ + {0, 1920, 1080, 60, NULL}, /* 1920x1080 mode is 60Hz only */ + {0, 1920, 1200, 60, NULL}, /* 1920x1200 mode is 60Hz only */ + {0, 2048, 1536, 60, NULL}, /* 2048x1536 mode is 60Hz only */ + {0, 2048, 1080, 60, NULL}, /* 2048x1080 mode is 60Hz only */ + {0, 0, 0, 0, NULL} /* End of generic mode list */ +}; + +/*****************************************************************************/ +/* SDL Video Device initialization functions */ +/*****************************************************************************/ + +static int qnxgf_available(void) +{ + gf_dev_t gfdev; + gf_dev_info_t gfdev_info; + int status; + + /* Try to attach to graphics device driver */ + status=gf_dev_attach(&gfdev, GF_DEVICE_INDEX(0), &gfdev_info); + if (status!=GF_ERR_OK) + { + return 0; + } + + /* Detach from graphics device driver for now */ + gf_dev_detach(gfdev); + + return 1; +} + +static void qnxgf_destroy(SDL_VideoDevice* device) +{ + SDL_VideoData* gfdata=(SDL_VideoData*) device->driverdata; + + /* Detach from graphics device driver, if it was initialized */ + if (gfdata->gfinitialized!=SDL_FALSE) + { + gf_dev_detach(gfdata->gfdev); + } + + if (device->driverdata!=NULL) + { + SDL_free(device->driverdata); + device->driverdata=NULL; + } + SDL_free(device); +} + +static SDL_VideoDevice* qnxgf_create(int devindex) +{ + SDL_VideoDevice* device; + SDL_VideoData* gfdata; + int status; + + /* Initialize SDL_VideoDevice structure */ + device = (SDL_VideoDevice*)SDL_calloc(1, sizeof(SDL_VideoDevice)); + if (device==NULL) + { + SDL_OutOfMemory(); + return NULL; + } + + /* Initialize internal GF specific data */ + gfdata = (SDL_VideoData*)SDL_calloc(1, sizeof(SDL_VideoData)); + if (gfdata==NULL) + { + SDL_OutOfMemory(); + SDL_free(device); + return NULL; + } + device->driverdata=gfdata; + + /* Try to attach to graphics device driver */ + status=gf_dev_attach(&gfdata->gfdev, GF_DEVICE_INDEX(devindex), &gfdata->gfdev_info); + if (status!=GF_ERR_OK) + { + SDL_OutOfMemory(); + SDL_free(gfdata); + SDL_free(device); + return NULL; + } + + /* Setup amount of available displays and current display */ + device->num_displays=0; + device->current_display=0; + + /* Setup device shutdown function */ + gfdata->gfinitialized=SDL_TRUE; + device->free=qnxgf_destroy; + + /* Setup all functions which we can handle */ + device->VideoInit=qnxgf_videoinit; + device->VideoQuit=qnxgf_videoquit; + device->GetDisplayModes=qnxgf_getdisplaymodes; + device->SetDisplayMode=qnxgf_setdisplaymode; + device->SetDisplayPalette=qnxgf_setdisplaypalette; + device->GetDisplayPalette=qnxgf_getdisplaypalette; + device->SetDisplayGammaRamp=qnxgf_setdisplaygammaramp; + device->GetDisplayGammaRamp=qnxgf_getdisplaygammaramp; + device->CreateWindow=qnxgf_createwindow; + device->CreateWindowFrom=qnxgf_createwindowfrom; + device->SetWindowTitle=qnxgf_setwindowtitle; + device->SetWindowIcon=qnxgf_setwindowicon; + device->SetWindowPosition=qnxgf_setwindowposition; + device->SetWindowSize=qnxgf_setwindowsize; + device->ShowWindow=qnxgf_showwindow; + device->HideWindow=qnxgf_hidewindow; + device->RaiseWindow=qnxgf_raisewindow; + device->MaximizeWindow=qnxgf_maximizewindow; + device->MinimizeWindow=qnxgf_minimizewindow; + device->RestoreWindow=qnxgf_restorewindow; + device->SetWindowGrab=qnxgf_setwindowgrab; + device->DestroyWindow=qnxgf_destroywindow; + device->GetWindowWMInfo=qnxgf_getwindowwminfo; + device->GL_LoadLibrary=qnxgf_gl_loadlibrary; + device->GL_GetProcAddress=qnxgf_gl_getprocaddres; + device->GL_UnloadLibrary=qnxgf_gl_unloadlibrary; + device->GL_CreateContext=qnxgf_gl_createcontext; + device->GL_MakeCurrent=qnxgf_gl_makecurrent; + device->GL_SetSwapInterval=qnxgf_gl_setswapinterval; + device->GL_GetSwapInterval=qnxgf_gl_getswapinterval; + device->GL_SwapWindow=qnxgf_gl_swapwindow; + device->GL_DeleteContext=qnxgf_gl_deletecontext; + device->PumpEvents=qnxgf_pumpevents; + device->SuspendScreenSaver=qnxgf_suspendscreensaver; + + return device; +} VideoBootStrap qnxgf_bootstrap= { - "QNXGF", - "QNX Graphics Framework", - NULL, - NULL + "qnxgf", + "SDL QNX Graphics Framework (GF) video driver", + qnxgf_available, + qnxgf_create }; +/*****************************************************************************/ +/* SDL Video and Display initialization/handling functions */ +/*****************************************************************************/ +int qnxgf_videoinit(_THIS) +{ + SDL_VideoData* gfdata=(SDL_VideoData*)_this->driverdata; + uint32_t it; + + /* Add each detected output to SDL */ + for (it=0; it<gfdata->gfdev_info.ndisplays; it++) + { + SDL_VideoDisplay display; + SDL_DisplayMode current_mode; + SDL_DisplayData* didata; + int status; + + didata=(SDL_DisplayData*)SDL_calloc(1, sizeof(SDL_DisplayData)); + if (didata==NULL) + { + /* memory allocation problem */ + SDL_OutOfMemory(); + return -1; + } + + status=gf_display_query(gfdata->gfdev, it, &didata->display_info); + if (status==GF_ERR_OK) + { + SDL_zero(current_mode); + current_mode.w=didata->display_info.xres; + current_mode.h=didata->display_info.yres; + current_mode.refresh_rate=didata->display_info.refresh; + current_mode.format=qnxgf_gf_to_sdl_pixelformat(didata->display_info.format); + current_mode.driverdata=NULL; + } + else + { + /* video initialization problem */ + SDL_free(didata); + SDL_SetError("Display query failed"); + return -1; + } + + /* Attach GF to selected display */ + status=gf_display_attach(&didata->display, gfdata->gfdev, it, NULL); + if (status!=GF_ERR_OK) + { + /* video initialization problem */ + SDL_free(didata); + SDL_SetError("Couldn't not attach to display"); + return -1; + } + + SDL_zero(display); + display.desktop_mode = current_mode; + display.current_mode = current_mode; + display.driverdata = didata; + SDL_AddVideoDisplay(&display); + } + + /* video has been initialized successfully */ + return 1; +} + +void qnxgf_videoquit(_THIS) +{ + SDL_DisplayData* didata; + uint32_t it; + + for(it=0; it<_this->num_displays; it++) + { + didata=_this->displays[it].driverdata; + + /* Detach from selected display */ + gf_display_detach(didata->display); + } +} + +void qnxgf_getdisplaymodes(_THIS) +{ + SDL_DisplayData* didata = (SDL_DisplayData*)SDL_CurrentDisplay.driverdata; + SDL_DisplayMode mode; + gf_modeinfo_t modeinfo; + uint32_t it=0; + uint32_t jt=0; + uint32_t kt=0; + int status; + + do { + status=gf_display_query_mode(didata->display, it, &modeinfo); + if (status==GF_ERR_OK) + { + /* Parsing current mode */ + if ((modeinfo.flags & GF_MODE_GENERIC)==GF_MODE_GENERIC) + { + /* This mode is generic, so we can add to SDL our resolutions */ + /* Only pixel format is fixed, refresh rate could be any */ + jt=0; + do { + if (generic_mode[jt].w==0) + { + break; + } + + mode.w=generic_mode[jt].w; + mode.h=generic_mode[jt].h; + mode.refresh_rate=generic_mode[jt].refresh_rate; + mode.format=qnxgf_gf_to_sdl_pixelformat(modeinfo.primary_format); + mode.driverdata=NULL; + SDL_AddDisplayMode(_this->current_display, &mode); + + jt++; + } while(1); + } + else + { + /* Add this display mode as is in case if it is non-generic */ + /* But go through the each refresh rate, supported by gf */ + jt=0; + do { + if (modeinfo.refresh[jt]!=0) + { + mode.w=modeinfo.xres; + mode.h=modeinfo.yres; + mode.refresh_rate=modeinfo.refresh[jt]; + mode.format=qnxgf_gf_to_sdl_pixelformat(modeinfo.primary_format); + mode.driverdata=NULL; + SDL_AddDisplayMode(_this->current_display, &mode); + jt++; + } + else + { + break; + } + } while(1); + } + } + else + { + if (status==GF_ERR_PARM) + { + /* out of available modes, all are listed */ + break; + } + + /* Error occured during mode listing */ + break; + } + it++; + } while(1); +} + +int qnxgf_setdisplaymode(_THIS, SDL_DisplayMode* mode) +{ + SDL_DisplayData* didata = (SDL_DisplayData*)SDL_CurrentDisplay.driverdata; + int result; + + result=gf_display_set_mode(didata->display, mode->w, mode->h, mode->refresh_rate, + qnxgf_sdl_to_gf_pixelformat(mode->format), 0); + if (result!=GF_ERR_OK) + { + /* Display mode/resolution switch has been failed */ + SDL_SetError("Mode is not supported by qnxgf driver"); + return -1; + } + + return 0; +} + +int qnxgf_setdisplaypalette(_THIS, SDL_Palette* palette) +{ + /* Palette must be set through the QNXGF renderer */ + /* It connected to surface, part of it */ + + /* Setting display palette operation has been failed */ + return -1; +} + +int qnxgf_getdisplaypalette(_THIS, SDL_Palette* palette) +{ + /* We can give to upper level palette, which it set before */ + + /* Getting display palette operation has been failed */ + return -1; +} + +int qnxgf_setdisplaygammaramp(_THIS, Uint16* ramp) +{ + SDL_DisplayData* didata = (SDL_DisplayData*)SDL_CurrentDisplay.driverdata; + int status; + + /* GF can set Color LUT independently for each color channel, but SDL */ + /* uses combined gamma ramp, set it to each channel */ + status=gf_display_set_color_lut16(didata->display, (uint16_t*)ramp, (uint16_t*)ramp, (uint16_t*)ramp); + if (status!=GF_ERR_OK) + { + /* Setting display gamma ramp operation has been failed */ + return -1; + } + + return 0; +} + +int qnxgf_getdisplaygammaramp(_THIS, Uint16* ramp) +{ + /* We need to return previous gamma set */ + + /* Getting display gamma ramp operation has been failed */ + return -1; +} + +int qnxgf_createwindow(_THIS, SDL_Window* window) +{ + /* Failed to create new window */ + return -1; +} + +int qnxgf_createwindowfrom(_THIS, SDL_Window* window, const void* data) +{ + /* Failed to create window from another window */ + return -1; +} + +void qnxgf_setwindowtitle(_THIS, SDL_Window* window) +{ +} + +void qnxgf_setwindowicon(_THIS, SDL_Window* window, SDL_Surface* icon) +{ +} + +void qnxgf_setwindowposition(_THIS, SDL_Window* window) +{ +} + +void qnxgf_setwindowsize(_THIS, SDL_Window* window) +{ +} + +void qnxgf_showwindow(_THIS, SDL_Window* window) +{ +} + +void qnxgf_hidewindow(_THIS, SDL_Window* window) +{ +} + +void qnxgf_raisewindow(_THIS, SDL_Window* window) +{ +} + +void qnxgf_maximizewindow(_THIS, SDL_Window* window) +{ +} + +void qnxgf_minimizewindow(_THIS, SDL_Window* window) +{ +} + +void qnxgf_restorewindow(_THIS, SDL_Window* window) +{ +} + +void qnxgf_setwindowgrab(_THIS, SDL_Window* window) +{ +} + +void qnxgf_destroywindow(_THIS, SDL_Window* window) +{ + printf("qnxgf_destroywindow()\n"); +} + +/*****************************************************************************/ +/* SDL Window Manager function */ +/*****************************************************************************/ +SDL_bool qnxgf_getwindowwminfo(_THIS, SDL_Window* window, struct SDL_SysWMinfo* info) +{ + if (info->version.major <= SDL_MAJOR_VERSION) + { + return SDL_TRUE; + } + else + { + SDL_SetError("Application not compiled with SDL %d.%d\n", SDL_MAJOR_VERSION, SDL_MINOR_VERSION); + return SDL_FALSE; + } + + /* Failed to get window manager information */ + return SDL_FALSE; +} + +/*****************************************************************************/ +/* SDL OpenGL/OpenGL ES functions */ +/*****************************************************************************/ +int qnxgf_gl_loadlibrary(_THIS, const char* path) +{ + /* Failed to load new GL library */ + return -1; +} + +void* qnxgf_gl_getprocaddres(_THIS, const char* proc) +{ + /* Failed to get GL function address pointer */ + return NULL; +} + +void qnxgf_gl_unloadlibrary(_THIS) +{ +} + +SDL_GLContext qnxgf_gl_createcontext(_THIS, SDL_Window* window) +{ + /* Failed to create GL context */ + return NULL; +} + +int qnxgf_gl_makecurrent(_THIS, SDL_Window* window, SDL_GLContext context) +{ + /* Failed to set current GL context */ + return -1; +} + +int qnxgf_gl_setswapinterval(_THIS, int interval) +{ + /* Failed to set swap interval */ + return -1; +} + +int qnxgf_gl_getswapinterval(_THIS) +{ + /* Failed to get default swap interval */ + return -1; +} + +void qnxgf_gl_swapwindow(_THIS, SDL_Window* window) +{ +} + +void qnxgf_gl_deletecontext(_THIS, SDL_GLContext context) +{ +} + +/*****************************************************************************/ +/* SDL Event handling function */ +/*****************************************************************************/ +void qnxgf_pumpevents(_THIS) +{ +} + +/*****************************************************************************/ +/* SDL screen saver related functions */ +/*****************************************************************************/ +void qnxgf_suspendscreensaver(_THIS) +{ + /* There is no screensaver in pure console, it may exist when running */ + /* GF under Photon, but I do not know, how to disable screensaver */ +} + /* vi: set ts=4 sw=4 expandtab: */