pandory500/SDL-mirror
2
0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

*** empty log message ***

Browse source 
--HG--
extra : convert_revision : svn%3Ac70aab31-4412-0410-b14c-859654838e24/trunk%40310
This commit is contained in:
Sam Lantinga 2002-03-11 17:38:56 +00:00
parent d6eaf8e9f8
commit 2c07cb4d5d
4 changed files with 533 additions and 479 deletions
Download patch file Download diff file Expand all files Collapse all files

19
README.QNX
View file

@ -1,15 +1,18 @@
README by Mike Gorchak <mike@malva.ua>
OpenGL support was experimentally added in window mode (in
fullscreen mode not yet). If you have QNX RtP v6.1.0 w/ or w/o
Patch A you must download new Photon3D runtime from http://de-
velopers.qnx.com. The versions of OS before 6.1.0 are not sup-
ported.
OpenGL in window mode works well and stable, in fullscreen
mode too, but fullscreen mode has not been heavily tested.
If you have QNX RtP 6.1.0 w/ or w/o Patch A you must download
new Photon3D runtime from http://developers.qnx.com. The versions
of OS before 6.1.0 are not supported.
Problems:
1. Fullscreen mode (in OpenGL mode) has not been written yet.
2. Photon has some errors in detecting how much bits per pi-
xel videomode has.
1. While creating OpenGL context artificially selected software
renderer mode (QSSL made acceleration only for Voodoo boards
in fullscreen mode, sorry but I don't have this board, if you
want acceleration - you may remove some line in source).
2. Photon has some errors in detecting how much bits per pixel
videomode has.
3. No shared libraries yet. We need manually set flag to
'configure' --disable-shared.

97
src/video/photon/SDL_ph_modes.c
View file

@ -176,11 +176,9 @@ SDL_Rect **ph_ListModes(_THIS, SDL_PixelFormat *format, Uint32 flags)
{
if (PgGetVideoModeInfo(mode_list.modes[i], &mode_info) < 0)
{
fprintf(stderr,"error: PgGetVideoModeInfo failed on mode: 0x%x\n",
mode_list.modes[i]);
fprintf(stderr,"error: PgGetVideoModeInfo failed on mode: 0x%x\n", mode_list.modes[i]);
return NULL;
}
if(mode_info.bits_per_pixel == format->BitsPerPixel)
{
Amodelist[j].w = mode_info.width;
@ -191,7 +189,7 @@ SDL_Rect **ph_ListModes(_THIS, SDL_PixelFormat *format, Uint32 flags)
}
}
//reorder biggest for smallest, assume width dominates
/* reorder biggest for smallest, assume width dominates */
for(i=0; i<j; i++)
{
@ -281,57 +279,28 @@ static void set_best_resolution(_THIS, int width, int height)
}
}
/*
static void get_real_resolution(_THIS, int* w, int* h)
{
if ( use_vidmode ) {
//PgDisplaySettings_t settings;
PgVideoModeInfo_t current_mode_info;
PgHWCaps_t my_hwcaps;
// int unused;
// if (PgGetVideoMode( &settings ) >= 0) {
// *w = settings.xres;
// *h = settings.yres;
// return;
// }
if (PgGetGraphicsHWCaps(&my_hwcaps) >= 0)
{
if (PgGetVideoModeInfo(my_hwcaps.current_video_mode, &current_mode_info) < 0)
{
fprintf(stderr,"get_real_resolution: PgGetVideoModeInfo failed\n");
}
*w = current_mode_info.width;
*h = current_mode_info.height;
}
}
// *w = DisplayWidth(SDL_Display, SDL_Screen);
// *h = DisplayHeight(SDL_Display, SDL_Screen);
}
*/
int ph_ResizeFullScreen(_THIS)
{
if (currently_fullscreen) {
set_best_resolution(this, current_w, current_h);
}
return (1);
}
int get_mode(int width, int height, int bpp)
/* return the mode associated with width, height and bpp */
/* if there is no mode then zero is returned */
int get_mode(int width, int height, int bpp)
{
int i;
if(width<640)
{
width=640;
}
if(height<480)
{
height=480;
}
if (PgGetVideoModeList(&mode_list) < 0)
{
@ -339,7 +308,7 @@ if(height < 480)
return -1;
}
// search list for exact match
/* search list for exact match */
for (i=0;i<mode_list.num_modes;i++)
{
if (PgGetVideoModeInfo(mode_list.modes[i], &mode_info) < 0)
@ -348,7 +317,6 @@ if(height < 480)
return 0;
}
if ((mode_info.width == width) &&
(mode_info.height == height) &&
(mode_info.bits_per_pixel == bpp))
@ -356,6 +324,7 @@ if(height < 480)
return mode_list.modes[i];
}
}
return (i == mode_list.num_modes) ? 0 : mode_list.modes[i];
}
@ -430,21 +399,30 @@ void ph_QueueEnterFullScreen(_THIS);
int ph_ToggleFullScreen(_THIS, int on)
{
if (currently_fullscreen)
ph_LeaveFullScreen(this);
{
return ph_LeaveFullScreen(this);
}
else
ph_EnterFullScreen(this);
{
return ph_EnterFullScreen(this);
}
return 0;
}
int ph_EnterFullScreen(_THIS)
{
if (!currently_fullscreen)
{
if ((this->screen->flags & SDL_OPENGL)==SDL_OPENGL)
{
#ifdef HAVE_OPENGL
#endif /* HAVE_OPENGL */
return 0;
}
else
{
if (old_video_mode==-1)
{
PgGetGraphicsHWCaps(&graphics_card_caps);
@ -452,26 +430,20 @@ int ph_EnterFullScreen(_THIS)
old_refresh_rate=graphics_card_caps.current_rrate;
}
if(OCImage.direct_context == NULL)
{
OCImage.direct_context=(PdDirectContext_t*)PdCreateDirectContext();
}
if(!OCImage.direct_context)
{
fprintf(stderr, "error: Can't create direct context\n" );
/* Remove the cursor if in full screen mode */
/*
region_info.cursor_type = Ph_CURSOR_NONE;
region_info.rid=PtWidgetRid(window);
PhRegionChange(Ph_REGION_CURSOR,0,&region_info,NULL,NULL);
*/
}
PdDirectStart(OCImage.direct_context);
currently_fullscreen = 1;
}
}
return 1;
}
@ -481,11 +453,19 @@ int ph_LeaveFullScreen(_THIS )
PgDisplaySettings_t mymode_settings;
if (currently_fullscreen)
{
if ((this->screen->flags & SDL_OPENGL)==SDL_OPENGL)
{
#ifdef HAVE_OPENGL
#endif /* HAVE_OPENGL */
return 0;
}
else
{
PdDirectStop(OCImage.direct_context);
PdReleaseDirectContext(OCImage.direct_context);
//Restore old video mode
/* Restore old video mode */
if (old_video_mode != -1)
{
mymode_settings.mode= (unsigned short) old_video_mode;
@ -499,8 +479,7 @@ int ph_LeaveFullScreen(_THIS )
old_video_mode=-1;
old_refresh_rate=-1;
// Restore cursor
}
}
return 1;

332
src/video/photon/SDL_ph_video.c
View file

@ -58,18 +58,25 @@ static void ph_VideoQuit(_THIS);
static void ph_DeleteDevice(SDL_VideoDevice *device);
#ifdef HAVE_OPENGL
int ph_SetupOpenGLContext(_THIS, int width, int height, int bpp, Uint32 flags);
static void ph_GL_SwapBuffers(_THIS);
static int ph_GL_GetAttribute(_THIS, SDL_GLattr attrib, int* value);
#endif /* HAVE_OPENGL */
#ifdef HAVE_OPENGL
PdOpenGLContext_t* OGLContext=NULL;
#endif /* HAVE_OPENGL */
static int ph_Available(void)
{
int phstat=-1;
phstat=PtInit(0);
if (phstat==0)
{
return 1;
}
else
{
return 0;
}
}
static SDL_VideoDevice *ph_CreateDevice(int devindex)
{
@ -101,7 +108,7 @@ static SDL_VideoDevice *ph_CreateDevice(int devindex)
device->ToggleFullScreen = ph_ToggleFullScreen;
device->UpdateMouse = NULL;
device->SetColors = ph_SetColors;
device->UpdateRects = NULL; /* ph_ResizeImage; */
device->UpdateRects = NULL; /* ph_ResizeImage */
device->VideoQuit = ph_VideoQuit;
device->AllocHWSurface = ph_AllocHWSurface;
device->CheckHWBlit = NULL;
@ -149,13 +156,15 @@ VideoBootStrap ph_bootstrap = {
static void ph_DeleteDevice(SDL_VideoDevice *device)
{
if ( device ) {
if ( device->hidden ) {
if (device)
{
if (device->hidden)
{
free(device->hidden);
device->hidden = NULL;
}
if ( device->gl_data ) {
if (device->gl_data)
{
free(device->gl_data);
device->gl_data = NULL;
}
@ -166,81 +175,46 @@ static void ph_DeleteDevice(SDL_VideoDevice *device)
static int ph_VideoInit(_THIS, SDL_PixelFormat *vformat)
{
PtArg_t arg[1];
PhDim_t dim;
PgColor_t ph_palette[_Pg_MAX_PALETTE];
int i;
unsigned long *tempptr;
int rtnval;
// PgDisplaySettings_t mysettings;
PgVideoModeInfo_t my_mode_info;
PgHWCaps_t my_hwcaps;
window=NULL;
oglctx=NULL;
if (NULL == (event = malloc(EVENT_SIZE)))
exit( EXIT_FAILURE );
/* Create a widget 'window' to capture events */
dim.w=0; //JB test320;
dim.h=0; //JB test240;
//We need to return BytesPerPixel as it in used by CreateRGBsurface
PtSetArg(&arg[0], Pt_ARG_DIM, &dim,0);
/*
PtSetArg(&arg[1], Pt_ARG_RESIZE_FLAGS, Pt_TRUE, Pt_RESIZE_XY_AS_REQUIRED);
PtSetArg(&arg[2], Pt_ARG_WINDOW_STATE, Pt_TRUE, Ph_WM_STATE_ISFRONT |
Ph_WM_STATE_ISMAX |
Ph_WM_STATE_ISFOCUS);
PtSetArg(&arg[3], Pt_ARG_WINDOW_RENDER_FLAGS,Pt_FALSE,~0);
PtSetArg(&arg[4], Pt_ARG_WINDOW_MANAGED_FLAGS,Pt_TRUE,
Ph_WM_FFRONT |
Ph_WM_CLOSE |
Ph_WM_TOFRONT |
Ph_WM_CONSWITCH);
*/
window=PtAppInit(NULL, NULL, NULL, 1, arg);
if(window == NULL)
{
printf("Photon application init failed, probably Photon is not running.\n");
exit(EXIT_FAILURE);
}
//PgSetDrawBufferSize(16 *1024);
PgSetRegion(PtWidgetRid(window));
PgSetClipping(0,NULL);
PtRealizeWidget(window);
/* Get the available video modes */
// if(ph_GetVideoModes(this) < 0)
// return -1;
/* Create the blank cursor */
SDL_BlankCursor = this->CreateWMCursor(this, blank_cdata, blank_cmask,
(int)BLANK_CWIDTH, (int)BLANK_CHEIGHT,
(int)BLANK_CHOTX, (int)BLANK_CHOTY);
if (SDL_BlankCursor == NULL)
printf("could not create blank cursor\n");
{
printf("ph_VideoInit: could not create blank cursor\n");
}
if (PgGetGraphicsHWCaps(&my_hwcaps) < 0)
{
fprintf(stderr,"ph_VideoInit: GetGraphicsHWCaps failed!! \n");
}
if (PgGetVideoModeInfo(my_hwcaps.current_video_mode, &my_mode_info) < 0)
{
fprintf(stderr,"ph_VideoInit: PgGetVideoModeInfo failed\n");
}
//We need to return BytesPerPixel as it in used by CreateRGBsurface
/* We need to return BytesPerPixel as it in used by CreateRGBsurface */
vformat->BitsPerPixel = my_mode_info.bits_per_pixel;
vformat->BytesPerPixel = my_mode_info.bytes_per_scanline/my_mode_info.width;
//return a palette if we are in 256 color mode
/* return a palette if we are in 256 color mode */
if (vformat->BitsPerPixel == 8)
{
vformat->palette = malloc(sizeof(SDL_Palette));
@ -248,10 +222,12 @@ static int ph_VideoInit(_THIS, SDL_PixelFormat *vformat)
vformat->palette->ncolors = 256;
vformat->palette->colors = (SDL_Color *)malloc(256 *sizeof(SDL_Color));
//fill the palette
/* fill the palette */
rtnval = PgGetPalette(ph_palette);
if (rtnval < 0)
printf("ph_VideoInit: PgGetPalette failed\n");
{
fprintf(stderr, "ph_VideoInit: PgGetPalette failed\n");
}
tempptr = (unsigned long *)vformat->palette->colors;
@ -259,12 +235,9 @@ static int ph_VideoInit(_THIS, SDL_PixelFormat *vformat)
{
*tempptr = (((unsigned long)ph_palette[i]) << 8);
tempptr++;
}
}
currently_fullscreen = 0;
this->info.wm_available = 1;
@ -276,21 +249,14 @@ static SDL_Surface *ph_SetVideoMode(_THIS, SDL_Surface *current,
int width, int height, int bpp, Uint32 flags)
{
PgDisplaySettings_t settings;
int mode, actual_width, actual_height;
PtArg_t arg[5];
int mode;
PtArg_t arg[32];
PhDim_t dim;
int rtnval;
PgColor_t ph_palette[_Pg_MAX_PALETTE];
int i;
unsigned long *tempptr;
#ifdef HAVE_OPENGL
uint64_t OGLAttrib[PH_OGL_MAX_ATTRIBS];
int OGLargc;
#endif /* HAVE_OPENGL */
actual_width = width;
actual_height = height;
int pargc;
dim.w=width;
dim.h=height;
@ -298,6 +264,52 @@ static SDL_Surface *ph_SetVideoMode(_THIS, SDL_Surface *current,
/* Lock the event thread, in multi-threading environments */
SDL_Lock_EventThread();
/* create window if no OpenGL support selected */
if ((flags & SDL_OPENGL)!=SDL_OPENGL)
{
pargc=0;
PtSetArg(&arg[pargc++], Pt_ARG_DIM, &dim, 0);
PtSetArg(&arg[pargc++], Pt_ARG_RESIZE_FLAGS, Pt_FALSE, Pt_RESIZE_XY_AS_REQUIRED);
if (window!=NULL)
{
PtUnrealizeWidget(window);
PtDestroyWidget(window);
window=NULL;
}
window=PtCreateWidget(PtWindow, NULL, pargc-1, arg);
PtRealizeWidget(window);
PtFlush();
}
#ifdef HAVE_OPENGL
if (flags & SDL_OPENGL)
{
/* ph_SetupOpenGLContext creates also window as need */
if (ph_SetupOpenGLContext(this, width, height, bpp, flags)==0)
{
current->flags=flags;
/* setup OGL update function ... ugly method */
ph_ResizeImage(this, current, flags);
}
else
{
/* if context creation fail, report no OpenGL to high level */
current->flags=(flags & (~SDL_OPENGL));
}
#else
if (flags & SDL_OPENGL) /* if no built-in OpenGL support */
{
fprintf(stderr, "error: no OpenGL support, try to recompile library.\n");
current->flags=(flags & (~SDL_OPENGL));
return NULL;
#endif /* HAVE_OPENGL */
}
else
{
/* Initialize the window */
if (flags & SDL_FULLSCREEN) /* Direct Context , assume SDL_HWSURFACE also set */
{
@ -347,46 +359,6 @@ static SDL_Surface *ph_SetVideoMode(_THIS, SDL_Surface *current,
{
current->flags = (flags | SDL_RESIZABLE); /* yes we can resize as this is a software surface */
}
#ifdef HAVE_OPENGL
if (flags & SDL_OPENGL) /* for now support OpenGL in window mode only */
{
OGLargc=0;
if (this->gl_config.depth_size)
{
OGLAttrib[OGLargc++]=PHOGL_ATTRIB_DEPTH_BITS;
OGLAttrib[OGLargc++]=this->gl_config.depth_size;
}
if (this->gl_config.stencil_size)
{
OGLAttrib[OGLargc++]=PHOGL_ATTRIB_STENCIL_BITS;
OGLAttrib[OGLargc++]=this->gl_config.stencil_size;
}
OGLAttrib[OGLargc++]=PHOGL_ATTRIB_NONE;
if (this->gl_config.double_buffer)
{
OGLContext=PdCreateOpenGLContext(2, &dim, 0, OGLAttrib);
}
else
{
OGLContext=PdCreateOpenGLContext(1, &dim, 0, OGLAttrib);
}
if (OGLContext==NULL)
{
fprintf(stderr,"error: cannot create OpenGL context.\n");
exit(1);
}
PhDCSetCurrent(OGLContext);
}
#else
if (flags & SDL_OPENGL) /* if no OpenGL support */
{
fprintf(stderr, "error: no OpenGL support, try to recompile library.\n");
exit(1);
}
#endif /* HAVE_OPENGL */
}
/* If we are setting video to use the palette make sure we have allocated memory for it */
@ -405,21 +377,11 @@ static SDL_Surface *ph_SetVideoMode(_THIS, SDL_Surface *current,
{
*tempptr = (((unsigned long)ph_palette[i]) << 8);
tempptr++;
}
}
}
/* Current window dimensions */
PtGetResource( window, Pt_ARG_DIM, &dim, 0 );
/* If we need to resize the window */
if((dim.w != width)||(dim.h != height))
{
dim.w=width;
dim.h=height;
PtSetArg(&arg[0], Pt_ARG_DIM, &dim,0);
PtSetResources( window, 1, arg );
current->w = width;
current->h = height;
current->format->BitsPerPixel = bpp;
@ -427,7 +389,6 @@ static SDL_Surface *ph_SetVideoMode(_THIS, SDL_Surface *current,
current->pitch = SDL_CalculatePitch(current);
/* Must call at least once it setup image planes */
ph_ResizeImage(this, current, flags);
}
SDL_Unlock_EventThread();
@ -437,6 +398,8 @@ static SDL_Surface *ph_SetVideoMode(_THIS, SDL_Surface *current,
static void ph_VideoQuit(_THIS)
{
PhRegion_t region_info;
ph_DestroyImage(this, SDL_VideoSurface);
if (currently_fullscreen)
@ -446,8 +409,35 @@ static void ph_VideoQuit(_THIS)
directContext=0;
currently_fullscreen=0;
}
#ifdef HAVE_OPENGL
if (((this->screen->flags & SDL_FULLSCREEN)==SDL_FULLSCREEN) &&
((this->screen->flags & SDL_OPENGL)==SDL_OPENGL))
{
region_info.cursor_type=Ph_CURSOR_POINTER;
region_info.rid=PtWidgetRid(window);
PhRegionChange(Ph_REGION_CURSOR, 0, &region_info, NULL, NULL);
}
PtFlush();
#endif /* HAVE_OPENGL */
if (window)
{
PtUnrealizeWidget(window);
PtDestroyWidget(window);
window=NULL;
}
#ifdef HAVE_OPENGL
if (oglctx)
{
PhDCSetCurrent(NULL);
PhDCRelease(oglctx);
oglctx=NULL;
}
#endif /* HAVE_OPENGL */
}
static int ph_SetColors(_THIS, int firstcolor, int ncolors, SDL_Color *colors)
{
@ -508,10 +498,110 @@ static int ph_SetColors(_THIS, int firstcolor, int ncolors, SDL_Color *colors)
}
#ifdef HAVE_OPENGL
int ph_SetupOpenGLContext(_THIS, int width, int height, int bpp, Uint32 flags)
{
PtArg_t args[8];
PhDim_t dim;
uint64_t OGLAttrib[PH_OGL_MAX_ATTRIBS];
int OGLargc;
int pargc;
dim.w=width;
dim.h=height;
if (oglctx!=NULL)
{
PhDCSetCurrent(NULL);
PhDCRelease(oglctx);
oglctx=NULL;
}
OGLargc=0;
if (this->gl_config.depth_size)
{
OGLAttrib[OGLargc++]=PHOGL_ATTRIB_DEPTH_BITS;
OGLAttrib[OGLargc++]=this->gl_config.depth_size;
}
if (this->gl_config.stencil_size)
{
OGLAttrib[OGLargc++]=PHOGL_ATTRIB_STENCIL_BITS;
OGLAttrib[OGLargc++]=this->gl_config.stencil_size;
}
OGLAttrib[OGLargc++]=PHOGL_ATTRIB_FORCE_SW;
if (flags & SDL_FULLSCREEN)
{
OGLAttrib[OGLargc++]=PHOGL_ATTRIB_FULLSCREEN;
OGLAttrib[OGLargc++]=PHOGL_ATTRIB_DIRECT;
OGLAttrib[OGLargc++]=PHOGL_ATTRIB_FULLSCREEN_BEST;
OGLAttrib[OGLargc++]=PHOGL_ATTRIB_FULLSCREEN_CENTER;
}
OGLAttrib[OGLargc++]=PHOGL_ATTRIB_NONE;
if (this->gl_config.double_buffer)
{
oglctx=PdCreateOpenGLContext(2, &dim, 0, OGLAttrib);
}
else
{
oglctx=PdCreateOpenGLContext(1, &dim, 0, OGLAttrib);
}
if (oglctx==NULL)
{
fprintf(stderr,"error: cannot create OpenGL context.\n");
return (-1);
}
PhDCSetCurrent(oglctx);
pargc=0;
PtSetArg(&args[pargc++], Pt_ARG_DIM, &dim, 0);
PtSetArg(&args[pargc++], Pt_ARG_RESIZE_FLAGS, Pt_FALSE, Pt_RESIZE_XY_AS_REQUIRED);
PtSetArg(&args[pargc++], Pt_ARG_FILL_COLOR, Pg_BLACK, 0);
if (flags & SDL_FULLSCREEN)
{
PhPoint_t pos;
pos.x=0;
pos.y=0;
PtSetArg(&args[pargc++], Pt_ARG_WINDOW_RENDER_FLAGS, Pt_FALSE, ~0);
PtSetArg(&args[pargc++], Pt_ARG_WINDOW_MANAGED_FLAGS,Pt_TRUE, Ph_WM_FFRONT | Ph_WM_CLOSE | Ph_WM_TOFRONT | Ph_WM_CONSWITCH);
PtSetArg(&args[pargc++], Pt_ARG_WINDOW_STATE, Pt_TRUE, Ph_WM_STATE_ISFRONT | Ph_WM_STATE_ISFOCUS);
PtSetArg(&args[pargc++], Pt_ARG_POS, &pos, 0);
}
if (window!=NULL)
{
PtUnrealizeWidget(window);
PtDestroyWidget(window);
window=NULL;
}
window=PtCreateWidget(PtWindow, NULL, pargc-1, args);
PtRealizeWidget(window);
/* disable mouse for fullscreen */
if (flags & SDL_FULLSCREEN)
{
PhRegion_t region_info;
region_info.cursor_type=Ph_CURSOR_NONE;
region_info.rid=PtWidgetRid(window);
PhRegionChange(Ph_REGION_CURSOR, 0, &region_info, NULL, NULL);
}
PtFlush();
return 0;
}
void ph_GL_SwapBuffers(_THIS)
{
PgSetRegion(PtWidgetRid(window));
PdOpenGLContextSwapBuffers(OGLContext);
PdOpenGLContextSwapBuffers(oglctx);
}
int ph_GL_GetAttribute(_THIS, SDL_GLattr attrib, int* value)

38
src/video/photon/SDL_ph_video.h
View file

@ -19,26 +19,6 @@
Sam Lantinga
slouken@libsdl.org
*/
/*
static PhEvent_t *event;
static PtAppContext_t app;
static PtWidget_t *window;
static PgVideoModes_t modelist;
static PdOffscreenContext_t *Buff[2];
static PdDirectContext_t *directContext;
static PhRect_t screenRect,windowRect;
static PgColor_t currRGB;
static PhPoint_t zeroPoint;
static char keyque[ QUE_SIZE ],keyMatrix[256];
static int queput,queget;
static int modeSet;
static PgHWCaps_t hwCaps;
static PgDisplaySettings_t mode_settings;
static int rshift1,rshift2,gshift1,gshift2,bshift1,bshift2;
static int backPitch;
static unsigned RBitMask,GBitMask,BBitMask;
static unsigned TranslatedFillColor;
*/
#ifndef _SDL_ph_video_h
#define _SDL_ph_video_h
@ -50,7 +30,9 @@ static unsigned TranslatedFillColor;
#include "Pt.h"
#include <photon/Pg.h>
#include <photon/PdDirect.h>
#ifdef HAVE_OPENGL
#include <photon/PdGL.h>
#endif /* HAVE_OPENGL */
/* Hidden "this" pointer for the video functions */
#define _THIS SDL_VideoDevice *this
@ -76,8 +58,11 @@ struct SDL_PrivateVideoData {
int local_ph; /* Flag: true if local display */
PtAppContext_t app;
PgDisplaySettings_t mode_settings;
PtWidget_t *window; /* used to handle input events */
PtWidget_t *Window; /* used to handle input events */
PhImage_t *image; /* used to display image */
#ifdef HAVE_OPENGL
PdOpenGLContext_t* OGLContext;
#endif /* HAVE_OPENGL */
struct {
PdDirectContext_t *direct_context;
@ -100,8 +85,6 @@ struct SDL_PrivateVideoData {
PdOffscreenContext_t *Buff[2];
struct _Ph_ctrl* ctrl_channel;
PhGC_t *Pt_GC, *Pg_GC; /* Graphic contexts to switch between Pt and Pg APIs */
/* The variables used for displaying graphics */
/* The current width and height of the fullscreen mode */
@ -113,16 +96,16 @@ struct SDL_PrivateVideoData {
int x;
int y;
} mouse_last;
struct {
int numerator;
int denominator;
int threshold;
} mouse_accel;
int mouse_relative;
WMcursor* BlankCursor;
int depth; /* current visual depth (not bpp) */
int use_vidmode;
@ -142,7 +125,8 @@ struct SDL_PrivateVideoData {
#define local_ph (this->hidden->local_ph)
#define app (this->hidden->app)
#define mode_settings (this->hidden->mode_settings)
#define window (this->hidden->window)
#define window (this->hidden->Window)
#define oglctx (this->hidden->OGLContext)
#define directContext (this->hidden->directContext)
#define Buff (this->hidden->Buff)
#define ctrl_channel (this->hidden->ctrl_channel)
@ -151,8 +135,6 @@ struct SDL_PrivateVideoData {
#define old_video_mode (this->hidden->old_video_mode)
#define old_refresh_rate (this->hidden->old_refresh_rate)
#define graphics_card_caps (this->hidden->graphics_card_caps)
#define Pt_GC (this->hidden->Pt_GC)
#define Pg_GC (this->hidden->Pg_GC)
/* Old variable names */
#define swap_pixels (this->hidden->swap_pixels)