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

21
README.QNX
View file

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

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

@ -155,54 +155,52 @@ int ph_GetVideoModes(_THIS)
SDL_Rect **ph_ListModes(_THIS, SDL_PixelFormat *format, Uint32 flags) SDL_Rect **ph_ListModes(_THIS, SDL_PixelFormat *format, Uint32 flags)
{ {
int i = 0; int i = 0;
int j = 0; int j = 0;
SDL_Rect Amodelist[PH_MAX_VIDEOMODES]; SDL_Rect Amodelist[PH_MAX_VIDEOMODES];
for (i=0; i<PH_MAX_VIDEOMODES; i++) for (i=0; i<PH_MAX_VIDEOMODES; i++)
{
SDL_modearray[i]=&SDL_modelist[i];
}
if (PgGetVideoModeList( &mode_list ) < 0)
{
fprintf(stderr,"error: PgGetVideoModeList failed\n");
return NULL;
}
mode_info.bits_per_pixel = 0;
for (i=0; i < mode_list.num_modes; i++)
{
if (PgGetVideoModeInfo(mode_list.modes[i], &mode_info) < 0)
{ {
SDL_modearray[i]=&SDL_modelist[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;
Amodelist[j].h = mode_info.height;
Amodelist[j].x = 0;
Amodelist[j].y = 0;
j++;
}
}
if (PgGetVideoModeList( &mode_list ) < 0) /* reorder biggest for smallest, assume width dominates */
{
fprintf(stderr,"error: PgGetVideoModeList failed\n");
return NULL;
}
mode_info.bits_per_pixel = 0; for(i=0; i<j; i++)
{
SDL_modelist[i].w = Amodelist[j - i -1].w;
SDL_modelist[i].h = Amodelist[j - i -1].h;
SDL_modelist[i].x = Amodelist[j - i -1].x;
SDL_modelist[i].y = Amodelist[j - i -1].y;
}
SDL_modearray[j]=NULL;
for (i=0; i < mode_list.num_modes; i++) return SDL_modearray;
{
if (PgGetVideoModeInfo(mode_list.modes[i], &mode_info) < 0)
{
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;
Amodelist[j].h = mode_info.height;
Amodelist[j].x = 0;
Amodelist[j].y = 0;
j++;
}
}
//reorder biggest for smallest, assume width dominates
for(i=0; i< j ; i++)
{
SDL_modelist[i].w = Amodelist[j - i -1].w;
SDL_modelist[i].h = Amodelist[j - i -1].h;
SDL_modelist[i].x = Amodelist[j - i -1].x;
SDL_modelist[i].y = Amodelist[j - i -1].y;
}
SDL_modearray[j]=NULL;
return SDL_modearray;
} }
void ph_FreeVideoModes(_THIS) void ph_FreeVideoModes(_THIS)
@ -281,82 +279,53 @@ 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) int ph_ResizeFullScreen(_THIS)
{ {
if (currently_fullscreen) {
if ( currently_fullscreen ) {
set_best_resolution(this, current_w, current_h); set_best_resolution(this, current_w, current_h);
} }
return(1); return (1);
} }
int get_mode(int width, int height, int bpp)
/* return the mode associated with width, height and bpp */ /* return the mode associated with width, height and bpp */
/* if there is no mode then zero is returned */ /* if there is no mode then zero is returned */
int get_mode(int width, int height, int bpp)
{ {
int i; int i;
if(width<640)
{
width=640;
}
if(height<480)
{
height=480;
}
if(width <640) if (PgGetVideoModeList(&mode_list) < 0)
width = 640; {
if(height < 480) fprintf(stderr,"error: PgGetVideoModeList failed\n");
height = 480; return -1;
}
/* search list for exact match */
for (i=0;i<mode_list.num_modes;i++)
{
if (PgGetVideoModeInfo(mode_list.modes[i], &mode_info) < 0)
{
fprintf(stderr,"error: PgGetVideoModeInfo failed\n");
return 0;
}
if (PgGetVideoModeList( &mode_list ) < 0) if ((mode_info.width == width) &&
{ (mode_info.height == height) &&
fprintf(stderr,"error: PgGetVideoModeList failed\n"); (mode_info.bits_per_pixel == bpp))
return -1; {
} return mode_list.modes[i];
}
}
// search list for exact match return (i == mode_list.num_modes) ? 0 : mode_list.modes[i];
for (i=0;i<mode_list.num_modes;i++)
{
if (PgGetVideoModeInfo(mode_list.modes[i], &mode_info) < 0)
{
fprintf(stderr,"error: PgGetVideoModeInfo failed\n");
return 0;
}
if ((mode_info.width == width) &&
(mode_info.height == height) &&
(mode_info.bits_per_pixel == bpp))
{
return mode_list.modes[i];
}
}
return (i == mode_list.num_modes) ? 0 : mode_list.modes[i];
} }
int get_mode_any_format(int width, int height, int bpp) int get_mode_any_format(int width, int height, int bpp)
@ -421,7 +390,7 @@ int get_mode_any_format(int width, int height, int bpp)
return mode_list.modes[ closest ]; return mode_list.modes[ closest ];
} }
else else
return 0; return 0;
} }
void ph_WaitMapped(_THIS); void ph_WaitMapped(_THIS);
@ -430,78 +399,88 @@ void ph_QueueEnterFullScreen(_THIS);
int ph_ToggleFullScreen(_THIS, int on) int ph_ToggleFullScreen(_THIS, int on)
{ {
if (currently_fullscreen)
{
return ph_LeaveFullScreen(this);
}
else
{
return ph_EnterFullScreen(this);
}
if(currently_fullscreen) return 0;
ph_LeaveFullScreen(this);
else
ph_EnterFullScreen(this);
return 0;
} }
int ph_EnterFullScreen(_THIS) int ph_EnterFullScreen(_THIS)
{ {
if ( ! currently_fullscreen ) 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);
old_video_mode=graphics_card_caps.current_video_mode;
old_refresh_rate=graphics_card_caps.current_rrate;
}
if (old_video_mode==-1) if(OCImage.direct_context == NULL)
{ {
PgGetGraphicsHWCaps(&graphics_card_caps); OCImage.direct_context=(PdDirectContext_t*)PdCreateDirectContext();
old_video_mode=graphics_card_caps.current_video_mode; }
old_refresh_rate=graphics_card_caps.current_rrate; if(!OCImage.direct_context)
} {
fprintf(stderr, "error: Can't create direct context\n" );
}
PdDirectStart(OCImage.direct_context);
if(OCImage.direct_context == NULL) currently_fullscreen = 1;
OCImage.direct_context=(PdDirectContext_t*)PdCreateDirectContext(); }
if( !OCImage.direct_context ) }
fprintf(stderr, "error: Can't create direct context\n" );
return 1;
/* 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;
} }
int ph_LeaveFullScreen(_THIS ) int ph_LeaveFullScreen(_THIS )
{ {
PgDisplaySettings_t mymode_settings; PgDisplaySettings_t mymode_settings;
if ( currently_fullscreen ) if (currently_fullscreen)
{ {
PdDirectStop(OCImage.direct_context); if ((this->screen->flags & SDL_OPENGL)==SDL_OPENGL)
PdReleaseDirectContext(OCImage.direct_context); {
#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) if (old_video_mode != -1)
{ {
mymode_settings.mode= (unsigned short) old_video_mode; mymode_settings.mode= (unsigned short) old_video_mode;
mymode_settings.refresh= (unsigned short) old_refresh_rate; mymode_settings.refresh= (unsigned short) old_refresh_rate;
mymode_settings.flags = 0; mymode_settings.flags = 0;
if(PgSetVideoMode(&mymode_settings) < 0) if (PgSetVideoMode(&mymode_settings) < 0)
{ {
fprintf(stderr,"error: PgSetVideoMode failed\n"); fprintf(stderr,"error: PgSetVideoMode failed\n");
} }
} }
old_video_mode=-1; old_video_mode=-1;
old_refresh_rate=-1; old_refresh_rate=-1;
}
// Restore cursor }
return 1;
}
return 1;
} }

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

@ -58,17 +58,24 @@ static void ph_VideoQuit(_THIS);
static void ph_DeleteDevice(SDL_VideoDevice *device); static void ph_DeleteDevice(SDL_VideoDevice *device);
#ifdef HAVE_OPENGL #ifdef HAVE_OPENGL
int ph_SetupOpenGLContext(_THIS, int width, int height, int bpp, Uint32 flags);
static void ph_GL_SwapBuffers(_THIS); static void ph_GL_SwapBuffers(_THIS);
static int ph_GL_GetAttribute(_THIS, SDL_GLattr attrib, int* value); static int ph_GL_GetAttribute(_THIS, SDL_GLattr attrib, int* value);
#endif /* HAVE_OPENGL */ #endif /* HAVE_OPENGL */
#ifdef HAVE_OPENGL
PdOpenGLContext_t* OGLContext=NULL;
#endif /* HAVE_OPENGL */
static int ph_Available(void) static int ph_Available(void)
{ {
return 1; int phstat=-1;
phstat=PtInit(0);
if (phstat==0)
{
return 1;
}
else
{
return 0;
}
} }
static SDL_VideoDevice *ph_CreateDevice(int devindex) static SDL_VideoDevice *ph_CreateDevice(int devindex)
@ -77,7 +84,7 @@ static SDL_VideoDevice *ph_CreateDevice(int devindex)
/* Initialize all variables that we clean on shutdown */ /* Initialize all variables that we clean on shutdown */
device = (SDL_VideoDevice *)malloc(sizeof(SDL_VideoDevice)); device = (SDL_VideoDevice *)malloc(sizeof(SDL_VideoDevice));
if ( device ) { if (device) {
memset(device, 0, (sizeof *device)); memset(device, 0, (sizeof *device));
device->hidden = (struct SDL_PrivateVideoData *) device->hidden = (struct SDL_PrivateVideoData *)
malloc((sizeof *device->hidden)); malloc((sizeof *device->hidden));
@ -98,10 +105,10 @@ static SDL_VideoDevice *ph_CreateDevice(int devindex)
device->VideoInit = ph_VideoInit; device->VideoInit = ph_VideoInit;
device->ListModes = ph_ListModes; device->ListModes = ph_ListModes;
device->SetVideoMode = ph_SetVideoMode; device->SetVideoMode = ph_SetVideoMode;
device->ToggleFullScreen = ph_ToggleFullScreen; device->ToggleFullScreen = ph_ToggleFullScreen;
device->UpdateMouse = NULL; device->UpdateMouse = NULL;
device->SetColors = ph_SetColors; device->SetColors = ph_SetColors;
device->UpdateRects = NULL; /* ph_ResizeImage; */ device->UpdateRects = NULL; /* ph_ResizeImage */
device->VideoQuit = ph_VideoQuit; device->VideoQuit = ph_VideoQuit;
device->AllocHWSurface = ph_AllocHWSurface; device->AllocHWSurface = ph_AllocHWSurface;
device->CheckHWBlit = NULL; device->CheckHWBlit = NULL;
@ -149,13 +156,15 @@ VideoBootStrap ph_bootstrap = {
static void ph_DeleteDevice(SDL_VideoDevice *device) static void ph_DeleteDevice(SDL_VideoDevice *device)
{ {
if (device)
if ( device ) { {
if ( device->hidden ) { if (device->hidden)
{
free(device->hidden); free(device->hidden);
device->hidden = NULL; device->hidden = NULL;
} }
if ( device->gl_data ) { if (device->gl_data)
{
free(device->gl_data); free(device->gl_data);
device->gl_data = NULL; device->gl_data = NULL;
} }
@ -166,104 +175,68 @@ static void ph_DeleteDevice(SDL_VideoDevice *device)
static int ph_VideoInit(_THIS, SDL_PixelFormat *vformat) static int ph_VideoInit(_THIS, SDL_PixelFormat *vformat)
{ {
PtArg_t arg[1]; PgColor_t ph_palette[_Pg_MAX_PALETTE];
PhDim_t dim; int i;
PgColor_t ph_palette[_Pg_MAX_PALETTE]; unsigned long *tempptr;
int i; int rtnval;
unsigned long *tempptr; PgVideoModeInfo_t my_mode_info;
int rtnval; PgHWCaps_t my_hwcaps;
// PgDisplaySettings_t mysettings;
PgVideoModeInfo_t my_mode_info;
PgHWCaps_t my_hwcaps;
if( NULL == ( event = malloc( EVENT_SIZE ) ) ) window=NULL;
exit( EXIT_FAILURE ); oglctx=NULL;
/* Create a widget 'window' to capture events */ if (NULL == (event = malloc(EVENT_SIZE)))
dim.w=0; //JB test320; {
dim.h=0; //JB test240; exit(EXIT_FAILURE);
//We need to return BytesPerPixel as it in used by CreateRGBsurface }
PtSetArg(&arg[0], Pt_ARG_DIM, &dim,0); /* 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)
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 | printf("ph_VideoInit: could not create blank cursor\n");
Ph_WM_STATE_ISMAX | }
Ph_WM_STATE_ISFOCUS);
PtSetArg(&arg[3], Pt_ARG_WINDOW_RENDER_FLAGS,Pt_FALSE,~0); if (PgGetGraphicsHWCaps(&my_hwcaps) < 0)
PtSetArg(&arg[4], Pt_ARG_WINDOW_MANAGED_FLAGS,Pt_TRUE, {
Ph_WM_FFRONT | fprintf(stderr,"ph_VideoInit: GetGraphicsHWCaps failed!! \n");
Ph_WM_CLOSE | }
Ph_WM_TOFRONT |
Ph_WM_CONSWITCH);
*/
if (PgGetVideoModeInfo(my_hwcaps.current_video_mode, &my_mode_info) < 0)
{
fprintf(stderr,"ph_VideoInit: PgGetVideoModeInfo failed\n");
}
window=PtAppInit(NULL, NULL, NULL, 1, arg); /* 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;
if(window == NULL) /* return a palette if we are in 256 color mode */
{ if (vformat->BitsPerPixel == 8)
printf("Photon application init failed, probably Photon is not running.\n"); {
exit( EXIT_FAILURE ); vformat->palette = malloc(sizeof(SDL_Palette));
} memset(vformat->palette, 0, sizeof(SDL_Palette));
vformat->palette->ncolors = 256;
vformat->palette->colors = (SDL_Color *)malloc(256 *sizeof(SDL_Color));
//PgSetDrawBufferSize(16 *1024); /* fill the palette */
PgSetRegion(PtWidgetRid(window)); rtnval = PgGetPalette(ph_palette);
PgSetClipping(0,NULL); if (rtnval < 0)
PtRealizeWidget(window); {
fprintf(stderr, "ph_VideoInit: PgGetPalette failed\n");
}
tempptr = (unsigned long *)vformat->palette->colors;
/* Get the available video modes */ for(i=0;i<256; i++)
// if(ph_GetVideoModes(this) < 0) {
// return -1; *tempptr = (((unsigned long)ph_palette[i]) << 8);
tempptr++;
/* 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");
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
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
if(vformat->BitsPerPixel == 8)
{
vformat->palette = malloc(sizeof(SDL_Palette));
memset(vformat->palette, 0, sizeof(SDL_Palette));
vformat->palette->ncolors = 256;
vformat->palette->colors = (SDL_Color *)malloc(256 *sizeof(SDL_Color));
//fill the palette
rtnval = PgGetPalette(ph_palette);
if(rtnval < 0)
printf("ph_VideoInit: PgGetPalette failed\n");
tempptr = (unsigned long *)vformat->palette->colors;
for(i=0;i<256; i++)
{
*tempptr = (((unsigned long)ph_palette[i]) << 8);
tempptr++;
}
}
currently_fullscreen = 0; currently_fullscreen = 0;
@ -276,21 +249,14 @@ static SDL_Surface *ph_SetVideoMode(_THIS, SDL_Surface *current,
int width, int height, int bpp, Uint32 flags) int width, int height, int bpp, Uint32 flags)
{ {
PgDisplaySettings_t settings; PgDisplaySettings_t settings;
int mode, actual_width, actual_height; int mode;
PtArg_t arg[5]; PtArg_t arg[32];
PhDim_t dim; PhDim_t dim;
int rtnval; int rtnval;
PgColor_t ph_palette[_Pg_MAX_PALETTE]; PgColor_t ph_palette[_Pg_MAX_PALETTE];
int i; int i;
unsigned long *tempptr; unsigned long *tempptr;
int pargc;
#ifdef HAVE_OPENGL
uint64_t OGLAttrib[PH_OGL_MAX_ATTRIBS];
int OGLargc;
#endif /* HAVE_OPENGL */
actual_width = width;
actual_height = height;
dim.w=width; dim.w=width;
dim.h=height; dim.h=height;
@ -298,136 +264,131 @@ static SDL_Surface *ph_SetVideoMode(_THIS, SDL_Surface *current,
/* Lock the event thread, in multi-threading environments */ /* Lock the event thread, in multi-threading environments */
SDL_Lock_EventThread(); SDL_Lock_EventThread();
/* Initialize the window */ /* create window if no OpenGL support selected */
if (flags & SDL_FULLSCREEN) /* Direct Context , assume SDL_HWSURFACE also set */ if ((flags & SDL_OPENGL)!=SDL_OPENGL)
{ {
/* Get the video mode and set it */ pargc=0;
if (flags & SDL_ANYFORMAT)
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)
{ {
if ((mode = get_mode_any_format(width, height, bpp)) == 0) PtUnrealizeWidget(window);
{ PtDestroyWidget(window);
fprintf(stderr,"error: get_mode_any_format failed\n"); window=NULL;
exit(1); }
}
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 else
{ {
if ((mode = get_mode(width, height, bpp)) == 0) /* if context creation fail, report no OpenGL to high level */
{ current->flags=(flags & (~SDL_OPENGL));
fprintf(stderr,"error: get_mode failed\n");
exit(1);
}
} }
settings.mode = mode; #else
settings.refresh = 0; if (flags & SDL_OPENGL) /* if no built-in OpenGL support */
settings.flags = 0; {
fprintf(stderr, "error: no OpenGL support, try to recompile library.\n");
if (PgSetVideoMode( &settings ) < 0) current->flags=(flags & (~SDL_OPENGL));
{ return NULL;
fprintf(stderr,"error: PgSetVideoMode failed\n"); #endif /* HAVE_OPENGL */
} }
/* Get the true height and width */
current->flags = (flags & (~SDL_RESIZABLE)); /* no resize for Direct Context */
/* Begin direct mode */
ph_EnterFullScreen(this);
} /* end fullscreen flag */
else else
{ {
if (flags & SDL_HWSURFACE) /* Use offscreen memory iff SDL_HWSURFACE flag is set */ /* Initialize the window */
{ if (flags & SDL_FULLSCREEN) /* Direct Context , assume SDL_HWSURFACE also set */
/* Hardware surface is Offsceen Context. ph_ResizeImage handles the switch */ {
current->flags = (flags & (~SDL_RESIZABLE)); /* no stretch blit in offscreen context */ /* Get the video mode and set it */
} if (flags & SDL_ANYFORMAT)
else /* must be SDL_SWSURFACE */ {
{ if ((mode = get_mode_any_format(width, height, bpp)) == 0)
current->flags = (flags | SDL_RESIZABLE); /* yes we can resize as this is a software surface */ {
} fprintf(stderr,"error: get_mode_any_format failed\n");
exit(1);
}
}
else
{
if ((mode = get_mode(width, height, bpp)) == 0)
{
fprintf(stderr,"error: get_mode failed\n");
exit(1);
}
}
settings.mode = mode;
settings.refresh = 0;
settings.flags = 0;
#ifdef HAVE_OPENGL if (PgSetVideoMode( &settings ) < 0)
if (flags & SDL_OPENGL) /* for now support OpenGL in window mode only */ {
{ fprintf(stderr,"error: PgSetVideoMode failed\n");
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 */ /* Get the true height and width */
current->flags = (flags & (~SDL_RESIZABLE)); /* no resize for Direct Context */
/* Begin direct mode */
ph_EnterFullScreen(this);
} /* end fullscreen flag */
else
{
if (flags & SDL_HWSURFACE) /* Use offscreen memory iff SDL_HWSURFACE flag is set */
{
/* Hardware surface is Offsceen Context. ph_ResizeImage handles the switch */
current->flags = (flags & (~SDL_RESIZABLE)); /* no stretch blit in offscreen context */
}
else /* must be SDL_SWSURFACE */
{
current->flags = (flags | SDL_RESIZABLE); /* yes we can resize as this is a software surface */
}
}
/* If we are setting video to use the palette make sure we have allocated memory for it */
if (bpp==8)
{
current->format->palette = malloc(sizeof(SDL_Palette));
memset(current->format->palette, 0, sizeof(SDL_Palette));
current->format->palette->ncolors = 256;
current->format->palette->colors = (SDL_Color *)malloc(256 *sizeof(SDL_Color));
/* fill the palette */
rtnval = PgGetPalette(ph_palette);
tempptr = (unsigned long *)current->format->palette->colors;
for(i=0; i<256; i++)
{
*tempptr = (((unsigned long)ph_palette[i]) << 8);
tempptr++;
}
}
} }
/* If we are setting video to use the palette make sure we have allocated memory for it */ current->w = width;
if(bpp == 8) current->h = height;
{ current->format->BitsPerPixel = bpp;
current->format->palette = malloc(sizeof(SDL_Palette)); current->format->BytesPerPixel = (bpp+7)/8;
memset(current->format->palette, 0, sizeof(SDL_Palette)); current->pitch = SDL_CalculatePitch(current);
current->format->palette->ncolors = 256; /* Must call at least once it setup image planes */
current->format->palette->colors = (SDL_Color *)malloc(256 *sizeof(SDL_Color)); ph_ResizeImage(this, current, flags);
/* fill the palette */
rtnval = PgGetPalette(ph_palette);
tempptr = (unsigned long *)current->format->palette->colors;
for(i=0;i<256; i++)
{
*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;
current->format->BytesPerPixel = (bpp+7)/8;
current->pitch = SDL_CalculatePitch(current);
/* Must call at least once it setup image planes */
ph_ResizeImage(this, current, flags);
}
SDL_Unlock_EventThread(); SDL_Unlock_EventThread();
@ -437,17 +398,46 @@ static SDL_Surface *ph_SetVideoMode(_THIS, SDL_Surface *current,
static void ph_VideoQuit(_THIS) static void ph_VideoQuit(_THIS)
{ {
PhRegion_t region_info;
ph_DestroyImage(this, SDL_VideoSurface); ph_DestroyImage(this, SDL_VideoSurface);
if (currently_fullscreen) if (currently_fullscreen)
{ {
PdDirectStop( directContext ); PdDirectStop(directContext);
PdReleaseDirectContext( directContext ); PdReleaseDirectContext(directContext);
directContext=0; directContext=0;
currently_fullscreen = 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) 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 #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) void ph_GL_SwapBuffers(_THIS)
{ {
PgSetRegion(PtWidgetRid(window)); PgSetRegion(PtWidgetRid(window));
PdOpenGLContextSwapBuffers(OGLContext); PdOpenGLContextSwapBuffers(oglctx);
} }
int ph_GL_GetAttribute(_THIS, SDL_GLattr attrib, int* value) int ph_GL_GetAttribute(_THIS, SDL_GLattr attrib, int* value)

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

@ -19,26 +19,6 @@
Sam Lantinga Sam Lantinga
slouken@libsdl.org 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 #ifndef _SDL_ph_video_h
#define _SDL_ph_video_h #define _SDL_ph_video_h
@ -50,7 +30,9 @@ static unsigned TranslatedFillColor;
#include "Pt.h" #include "Pt.h"
#include <photon/Pg.h> #include <photon/Pg.h>
#include <photon/PdDirect.h> #include <photon/PdDirect.h>
#ifdef HAVE_OPENGL
#include <photon/PdGL.h> #include <photon/PdGL.h>
#endif /* HAVE_OPENGL */
/* Hidden "this" pointer for the video functions */ /* Hidden "this" pointer for the video functions */
#define _THIS SDL_VideoDevice *this #define _THIS SDL_VideoDevice *this
@ -76,31 +58,32 @@ struct SDL_PrivateVideoData {
int local_ph; /* Flag: true if local display */ int local_ph; /* Flag: true if local display */
PtAppContext_t app; PtAppContext_t app;
PgDisplaySettings_t mode_settings; 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 */ PhImage_t *image; /* used to display image */
#ifdef HAVE_OPENGL
PdOpenGLContext_t* OGLContext;
#endif /* HAVE_OPENGL */
struct { struct {
PdDirectContext_t *direct_context; PdDirectContext_t *direct_context;
PdOffscreenContext_t *offscreen_context; PdOffscreenContext_t *offscreen_context;
VidPtr_t dc_ptr; VidPtr_t dc_ptr;
FRAMEDATA *CurrentFrameData; FRAMEDATA *CurrentFrameData;
FRAMEDATA *FrameData0; FRAMEDATA *FrameData0;
FRAMEDATA *FrameData1; FRAMEDATA *FrameData1;
int current; int current;
long Stride; long Stride;
long flags; long flags;
} ocimage; } ocimage;
PhDrawContext_t *ScreenDC; //=NULL; PhDrawContext_t *ScreenDC; //=NULL;
signed short old_video_mode; //=-1; signed short old_video_mode; //=-1;
signed short old_refresh_rate; //=-1; signed short old_refresh_rate; //=-1;
PgHWCaps_t graphics_card_caps; PgHWCaps_t graphics_card_caps;
PdDirectContext_t *directContext; PdDirectContext_t *directContext;
PdOffscreenContext_t *Buff[2]; PdOffscreenContext_t *Buff[2];
struct _Ph_ctrl* ctrl_channel; 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 variables used for displaying graphics */
@ -113,15 +96,15 @@ struct SDL_PrivateVideoData {
int x; int x;
int y; int y;
} mouse_last; } mouse_last;
struct { struct {
int numerator; int numerator;
int denominator; int denominator;
int threshold; int threshold;
} mouse_accel; } mouse_accel;
int mouse_relative; int mouse_relative;
WMcursor* BlankCursor; WMcursor* BlankCursor;
int depth; /* current visual depth (not bpp) */ int depth; /* current visual depth (not bpp) */
@ -136,40 +119,39 @@ struct SDL_PrivateVideoData {
int blit_queued; int blit_queued;
short *iconcolors; /* List of colors used by the icon */ short *iconcolors; /* List of colors used by the icon */
PhEvent_t* event; PhEvent_t* event;
}; };
#define local_ph (this->hidden->local_ph) #define local_ph (this->hidden->local_ph)
#define app (this->hidden->app) #define app (this->hidden->app)
#define mode_settings (this->hidden->mode_settings) #define mode_settings (this->hidden->mode_settings)
#define window (this->hidden->window) #define window (this->hidden->Window)
#define directContext (this->hidden->directContext) #define oglctx (this->hidden->OGLContext)
#define Buff (this->hidden->Buff) #define directContext (this->hidden->directContext)
#define ctrl_channel (this->hidden->ctrl_channel) #define Buff (this->hidden->Buff)
#define SDL_Image (this->hidden->image) #define ctrl_channel (this->hidden->ctrl_channel)
#define OCImage (this->hidden->ocimage) #define SDL_Image (this->hidden->image)
#define old_video_mode (this->hidden->old_video_mode) #define OCImage (this->hidden->ocimage)
#define old_refresh_rate (this->hidden->old_refresh_rate) #define old_video_mode (this->hidden->old_video_mode)
#define graphics_card_caps (this->hidden->graphics_card_caps) #define old_refresh_rate (this->hidden->old_refresh_rate)
#define Pt_GC (this->hidden->Pt_GC) #define graphics_card_caps (this->hidden->graphics_card_caps)
#define Pg_GC (this->hidden->Pg_GC)
/* Old variable names */ /* Old variable names */
#define swap_pixels (this->hidden->swap_pixels) #define swap_pixels (this->hidden->swap_pixels)
#define current_w (this->hidden->current_w) #define current_w (this->hidden->current_w)
#define current_h (this->hidden->current_h) #define current_h (this->hidden->current_h)
#define mouse_last (this->hidden->mouse_last) #define mouse_last (this->hidden->mouse_last)
#define mouse_accel (this->hidden->mouse_accel) #define mouse_accel (this->hidden->mouse_accel)
#define mouse_relative (this->hidden->mouse_relative) #define mouse_relative (this->hidden->mouse_relative)
#define saved_mode (this->hidden->saved_mode) #define saved_mode (this->hidden->saved_mode)
#define saved_view (this->hidden->saved_view) #define saved_view (this->hidden->saved_view)
#define use_vidmode (this->hidden->use_vidmode) #define use_vidmode (this->hidden->use_vidmode)
#define currently_fullscreen (this->hidden->currently_fullscreen) #define currently_fullscreen (this->hidden->currently_fullscreen)
#define switch_waiting (this->hidden->switch_waiting) #define switch_waiting (this->hidden->switch_waiting)
#define switch_time (this->hidden->switch_time) #define switch_time (this->hidden->switch_time)
#define blit_queued (this->hidden->blit_queued) #define blit_queued (this->hidden->blit_queued)
#define SDL_iconcolorIs (this->hidden->iconcolors) #define SDL_iconcolorIs (this->hidden->iconcolors)
#define event (this->hidden->event) #define event (this->hidden->event)
#define SDL_BlankCursor (this->hidden->BlankCursor) #define SDL_BlankCursor (this->hidden->BlankCursor)
#endif /* _SDL_x11video_h */ #endif /* _SDL_x11video_h */