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

Updated Amiga port by Gabriele Greco

Browse source 
--HG--
extra : convert_revision : svn%3Ac70aab31-4412-0410-b14c-859654838e24/trunk%40256
This commit is contained in:
Sam Lantinga 2001-12-16 20:00:27 +00:00
parent 601be8cfe2
commit 896c76ea65
15 changed files with 566 additions and 761 deletions
Download patch file Download diff file Expand all files Collapse all files

4
src/audio/amigaos/SDL_ahiaudio.c
View file

@ -29,10 +29,6 @@ static char rcsid =
/* Allow access to a raw mixing buffer (for AmigaOS) */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "SDL_endian.h"
#include "SDL_audio.h"
#include "SDL_audiomem.h"

4
src/audio/amigaos/SDL_ahiaudio.h
View file

@ -35,6 +35,8 @@ static char rcsid =
#else
#include <inline/exec.h>
#endif
#include <stdlib.h>
#include <string.h>
#include <devices/ahi.h>
#include "mydebug.h"
@ -47,7 +49,7 @@ struct SDL_PrivateAudioData {
/* The handle for the audio device */
struct AHIRequest *audio_req[2];
struct MsgPort *audio_port;
Sint32 freq,type,bytespersample;
Sint32 freq,type,bytespersample,size;
Uint8 *mixbuf[2]; /* The app mixing buffer */
int current_buffer;
Uint32 playing;

4
src/joystick/amigaos/SDL_sysjoystick.c
View file

@ -31,7 +31,7 @@ static char rcsid =
#include <stdio.h> /* For the definition of NULL */
#include <libraries/lowlevel.h>
#ifdef __SASC
#if defined(__SASC) || defined(STORMC4_WOS)
#include <proto/exec.h>
#include <proto/lowlevel.h>
#include <proto/graphics.h>
@ -128,7 +128,7 @@ int SDL_SYS_JoystickOpen(SDL_Joystick *joystick)
for(i=0;i<20;i++)
{
temp=ReadJoyPort(joystick->index);
temp=ReadJoyPort(joystick->index^1); // fix to invert amiga joyports
WaitTOF();
}

4
src/thread/amigaos/SDL_syssem.c
View file

@ -146,7 +146,11 @@ Uint32 SDL_SemValue(SDL_sem *sem)
value = 0;
if ( sem ) {
#ifdef STORMC4_WOS
value = sem->Sem.ssppc_SS.ss_NestCount;
#else
value = sem->Sem.ss_NestCount;
#endif
// SDL_UnlockMutex(sem->count_lock);
}
return value;

28
src/thread/amigaos/SDL_systhread.c
View file

@ -32,6 +32,7 @@ static char rcsid =
#include "SDL_thread.h"
#include "SDL_thread_c.h"
#include "SDL_systhread.h"
#include "mydebug.h"
typedef struct {
int (*func)(void *);
@ -47,10 +48,15 @@ __saveds __asm Uint32 RunThread(register __a0 char *args )
#elif defined(__PPC__)
Uint32 RunThread(char *args)
#else
Uint32 RunThread(char *args __asm("a0") )
Uint32 __saveds RunThread(char *args __asm("a0") )
#endif
{
#ifdef STORMC4_WOS
thread_args *data=(thread_args *)args;
#else
thread_args *data=(thread_args *)atol(args);
#endif
struct Task *Father;
D(bug("Received data: %lx\n",data));
@ -59,6 +65,7 @@ Uint32 RunThread(char *args __asm("a0") )
SDL_RunThread(data);
Signal(Father,SIGBREAKF_CTRL_F);
D(bug("Thread with data %lx ended\n",data));
return(0);
}
@ -68,7 +75,7 @@ Uint32 RunThread(char *args __asm("a0") )
Uint32 RunTheThread(void)
{
thread_args *data=(thread_args *)atol(REG_A0);
thread_args *data=(thread_args *)atol((char *)REG_A0);
struct Task *Father;
D(bug("Received data: %lx\n",data));
@ -77,16 +84,18 @@ Uint32 RunTheThread(void)
SDL_RunThread(data);
Signal(Father,SIGBREAKF_CTRL_F);
D(bug("Thread with data %lx ended\n",data));
return(0);
}
struct EmulLibEntry RunThread=
struct EmulLibEntry RunThreadStruct=
{
TRAP_LIB,
0,
RunTheThread
(ULONG)RunTheThread
};
void *RunThread=&RunThreadStruct;
#endif
@ -100,7 +109,14 @@ int SDL_SYS_CreateThread(SDL_Thread *thread, void *args)
if(args)
sprintf(buffer,"%ld",args);
#ifdef STORMC4_WOS
thread->handle=CreateTaskPPCTags(TASKATTR_CODE, RunThread,
TASKATTR_NAME, "SDL subtask",
TASKATTR_STACKSIZE, 100000,
(args ? TASKATTR_R3 : TAG_IGNORE), args,
TASKATTR_INHERITR2, TRUE,
TAG_DONE);
#else
thread->handle=(struct Task *)CreateNewProcTags(NP_Output,Output(),
NP_Name,(ULONG)"SDL subtask",
NP_CloseOutput, FALSE,
@ -108,6 +124,8 @@ int SDL_SYS_CreateThread(SDL_Thread *thread, void *args)
NP_Entry,(ULONG)RunThread,
args ? NP_Arguments : TAG_IGNORE,(ULONG)buffer,
TAG_DONE);
#endif
if(!thread->handle)
{
SDL_SetError("Not enough resources to create thread");

24
src/thread/amigaos/SDL_systhread_c.h
View file

@ -28,7 +28,7 @@ static char rcsid =
#include <exec/exec.h>
#include <dos/dos.h>
#include <dos/dostags.h>
#ifdef __SASC
#if defined (__SASC) || defined(STORMC4_WOS)
#include <proto/dos.h>
#include <proto/exec.h>
#else
@ -44,5 +44,25 @@ static char rcsid =
extern struct ExecBase *SysBase;
extern struct DosLibrary *DOSBase;
#define SYS_ThreadHandle struct Task *
#ifdef STORMC4_WOS
#include <proto/powerpc.h>
/* use powerpc.library functions instead og exec */
#define SYS_ThreadHandle struct TaskPPC *
#define Signal SignalPPC
#define Wait WaitPPC
#define Task TaskPPC
#define FindTask FindTaskPPC
#define SetSignal SetSignalPPC
#define InitSemaphore InitSemaphorePPC
#define ObtainSemaphore ObtainSemaphorePPC
#define AttemptSemaphore AttemptSemaphorePPC
#define ReleaseSemaphore ReleaseSemaphorePPC
#define SignalSemaphore SignalSemaphorePPC
#else
#define SYS_ThreadHandle struct Task *
#endif /*STORMC4_WOS*/

8
src/timer/amigaos/SDL_systimer.c
View file

@ -38,6 +38,10 @@ static char rcsid =
#include <pragmas/graphics.h>
#include <clib/exec_protos.h>
#include <pragmas/exec.h>
#elif defined(STORMC4_WOS)
#include <proto/dos.h>
#include <proto/exec.h>
#include <proto/graphics.h>
#else
#include <inline/dos.h>
#include <inline/exec.h>
@ -59,7 +63,7 @@ static struct GfxBase *GfxBase;
/* The first ticks value of the application */
#ifndef __PPC__
#if !defined(__PPC__) || defined(STORMC4_WOS) || defined(MORPHOS)
static clock_t start;
void SDL_StartTicks(void)
@ -234,7 +238,7 @@ static int RunTimer(void *unused)
/* This is only called if the event thread is not running */
int SDL_SYS_TimerInit(void)
{
D(bug("Creo il thread per il timer (NOITMER)...\n"));
D(bug("Creating thread for the timer (NOITIMER)...\n"));
timer_alive = 1;
timer_thread = SDL_CreateThread(RunTimer, NULL);

21
src/video/cybergfx/SDL_amigaevents.c
View file

@ -257,6 +257,7 @@ printf("MapNotify!\n");
case IDCMP_NEWSIZE:
SDL_PrivateResize(SDL_Window->Width-SDL_Window->BorderLeft-SDL_Window->BorderRight,
SDL_Window->Height-SDL_Window->BorderTop-SDL_Window->BorderBottom);
break;
/* Have we been requested to quit? */
@ -428,7 +429,11 @@ void amiga_InitKeymap(void)
SDL_keysym *amiga_TranslateKey(int code, SDL_keysym *keysym)
{
#ifdef STORMC4_WOS
static struct Library *KeymapBase=NULL; /* Linking failed in WOS version if ConsoleDevice was used */
#else
static struct Library *ConsoleDevice=NULL;
#endif
/* Get the raw keyboard scancode */
keysym->scancode = code;
@ -440,8 +445,15 @@ SDL_keysym *amiga_TranslateKey(int code, SDL_keysym *keysym)
/* Get the translated SDL virtual keysym */
if ( keysym->sym==SDLK_UNKNOWN )
{
#ifdef STORMC4_WOS
if(!KeymapBase)
#else
if(!ConsoleDevice)
#endif
{
#ifdef STORMC4_WOS
KeymapBase=OpenLibrary("keymap.library", 0L);
#else
if(ConPort=CreateMsgPort())
{
if(ConReq=CreateIORequest(ConPort,sizeof(struct IOStdReq)))
@ -460,9 +472,14 @@ SDL_keysym *amiga_TranslateKey(int code, SDL_keysym *keysym)
ConPort=NULL;
}
}
#endif
}
#ifdef STORMC4_WOS
if(KeymapBase)
#else
if(ConsoleDevice)
#endif
{
struct InputEvent event;
long actual;
@ -477,7 +494,11 @@ SDL_keysym *amiga_TranslateKey(int code, SDL_keysym *keysym)
event.ie_NextEvent=NULL;
event.ie_Prev1DownCode=event.ie_Prev1DownQual=event.ie_Prev2DownCode=event.ie_Prev2DownQual=0;
#ifdef STORMC4_WOS
if( (actual=MapRawKey(&event,buffer,5,NULL))>=0)
#else
if( (actual=RawKeyConvert(&event,buffer,5,NULL))>=0)
#endif
{
if(actual>1)
{

33
src/video/cybergfx/SDL_cgxaccel.c
View file

@ -1,3 +1,30 @@
/*
SDL - Simple DirectMedia Layer
Copyright (C) 1997, 1998, 1999, 2000 Sam Lantinga
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Library General Public
License as published by the Free Software Foundation; either
version 2 of the License, or (at your option) any later version.
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
Library General Public License for more details.
You should have received a copy of the GNU Library General Public
License along with this library; if not, write to the Free
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
Sam Lantinga
slouken@libsdl.org
*/
#ifdef SAVE_RCSID
static char rcsid =
"@(#) $Id$";
#endif
#include "SDL_error.h"
#include "SDL_endian.h"
#include "SDL_sysvideo.h"
@ -10,7 +37,7 @@ static int CGX_HWAccelBlit(SDL_Surface *src, SDL_Rect *srcrect,
// These are needed to avoid register troubles with gcc -O2!
#if defined(__SASC) || defined(__PPC__)
#if defined(__SASC) || defined(__PPC__) || defined(MORPHOS)
#define BMKBRP(a,b,c,d,e,f,g,h,i,j) BltMaskBitMapRastPort(a,b,c,d,e,f,g,h,i,j)
#define BBRP(a,b,c,d,e,f,g,h,i) BltBitMapRastPort(a,b,c,d,e,f,g,h,i)
#define BBB(a,b,c,d,e,f,g,h,i,j,k) BltBitMap(a,b,c,d,e,f,g,h,i,j,k)
@ -39,7 +66,7 @@ int CGX_SetHWColorKey(_THIS,SDL_Surface *surface, Uint32 key)
memset(surface->hwdata->mask,255,RASSIZE(surface->w,surface->h));
D(bug("Costruisco colorkey: colore: %ld, size: %ld x %ld, %ld bytes...Bpp:%ld\n",key,surface->w,surface->h,RASSIZE(surface->w,surface->h),surface->format->BytesPerPixel));
D(bug("Building colorkey mask: color: %ld, size: %ld x %ld, %ld bytes...Bpp:%ld\n",key,surface->w,surface->h,RASSIZE(surface->w,surface->h),surface->format->BytesPerPixel));
if(lock=LockBitMapTags(surface->hwdata->bmap,LBMI_BASEADDRESS,(ULONG)&surface->pixels,
LBMI_BYTESPERROW,(ULONG)&pitch,TAG_DONE))
@ -138,7 +165,7 @@ int CGX_SetHWColorKey(_THIS,SDL_Surface *surface, Uint32 key)
ok=-1;
}
UnLockBitMap(lock);
D(bug("...Colorkey costruito!\n"));
D(bug("...Colorkey built!\n"));
return ok;
}
}

444
src/video/cybergfx/SDL_cgxgl.c
View file

@ -25,189 +25,117 @@ static char rcsid =
"@(#) $Id$";
#endif
// #include <stdlib.h> /* For getenv() prototype */
// #include <string.h>
/* StormMesa implementation of SDL OpenGL support */
#include "SDL_events_c.h"
#include "SDL_error.h"
#include "SDL_cgxvideo.h"
#include "SDL_cgxgl_c.h"
#include "SDL_cgxvideo.h"
#define DEFAULT_OPENGL "libGL.so.1"
#ifdef HAVE_OPENGL
AmigaMesaContext glcont=NULL;
#endif
/* return the preferred visual to use for openGL graphics */
void *CGX_GL_GetVisual(_THIS)
/* Init OpenGL */
int CGX_GL_Init(_THIS)
{
#ifdef HAVE_OPENGL
/* 64 seems nice. */
int attribs[64];
int i;
int i = 0;
struct TagItem attributes [ 14 ]; /* 14 should be more than enough :) */
struct Window *win = (struct Window *)SDL_Window;
/* load the gl driver from a default path */
if ( ! this->gl_config.driver_loaded ) {
/* no driver has been loaded, use default (ourselves) */
if ( X11_GL_LoadLibrary(this, NULL) < 0 ) {
return NULL;
// default config. Always used...
attributes[i].ti_Tag = AMA_Window; attributes[i++].ti_Data = (unsigned long)win;
attributes[i].ti_Tag = AMA_Left; attributes[i++].ti_Data = 0;
attributes[i].ti_Tag = AMA_Bottom; attributes[i++].ti_Data = 0;
attributes[i].ti_Tag = AMA_Width; attributes[i++].ti_Data = win->Width-win->BorderLeft-win->BorderRight;
attributes[i].ti_Tag = AMA_Height; attributes[i++].ti_Data = win->Height-win->BorderBottom-win->BorderTop;
attributes[i].ti_Tag = AMA_DirectRender; attributes[i++].ti_Data = GL_TRUE;
// double buffer ?
attributes[i].ti_Tag = AMA_DoubleBuf;
if ( this->gl_config.double_buffer ) {
attributes[i++].ti_Data = GL_TRUE;
}
else {
attributes[i++].ti_Data = GL_FALSE;
}
/* See if we already have a window which we must use */
if ( SDL_windowid ) {
XWindowAttributes a;
XVisualInfo vi_in;
int out_count;
XGetWindowAttributes(SDL_Display, SDL_Window, &a);
vi_in.screen = SDL_Screen;
vi_in.visualid = XVisualIDFromVisual(a.visual);
glx_visualinfo = XGetVisualInfo(SDL_Display,
VisualScreenMask|VisualIDMask, &vi_in, &out_count);
return glx_visualinfo;
// RGB(A) Mode ?
attributes[i].ti_Tag = AMA_RGBMode;
if ( this->gl_config.red_size != 0 &&
this->gl_config.blue_size != 0 &&
this->gl_config.green_size != 0 ) {
attributes[i++].ti_Data = GL_TRUE;
}
/* Setup our GLX attributes according to the gl_config. */
i = 0;
attribs[i++] = GLX_RGBA;
attribs[i++] = GLX_RED_SIZE;
attribs[i++] = this->gl_config.red_size;
attribs[i++] = GLX_GREEN_SIZE;
attribs[i++] = this->gl_config.green_size;
attribs[i++] = GLX_BLUE_SIZE;
attribs[i++] = this->gl_config.blue_size;
if( this->gl_config.alpha_size ) {
attribs[i++] = GLX_ALPHA_SIZE;
attribs[i++] = this->gl_config.alpha_size;
else {
attributes[i++].ti_Data = GL_FALSE;
}
if( this->gl_config.buffer_size ) {
attribs[i++] = GLX_BUFFER_SIZE;
attribs[i++] = this->gl_config.buffer_size;
// no depth buffer ?
if ( this->gl_config.depth_size == 0 ) {
attributes[i].ti_Tag = AMA_NoDepth;
attributes[i++].ti_Data = GL_TRUE;
}
if( this->gl_config.double_buffer ) {
attribs[i++] = GLX_DOUBLEBUFFER;
// no stencil buffer ?
if ( this->gl_config.stencil_size == 0 ) {
attributes[i].ti_Tag = AMA_NoStencil;
attributes[i++].ti_Data = GL_TRUE;
}
attribs[i++] = GLX_DEPTH_SIZE;
attribs[i++] = this->gl_config.depth_size;
if( this->gl_config.stencil_size ) {
attribs[i++] = GLX_STENCIL_SIZE;
attribs[i++] = this->gl_config.stencil_size;
// no accum buffer ?
if ( this->gl_config.accum_red_size != 0 &&
this->gl_config.accum_blue_size != 0 &&
this->gl_config.accum_green_size != 0 ) {
attributes[i].ti_Tag = AMA_NoAccum;
attributes[i++].ti_Data = GL_TRUE;
}
// done...
attributes[i].ti_Tag = TAG_DONE;
if( this->gl_config.accum_red_size ) {
attribs[i++] = GLX_ACCUM_RED_SIZE;
attribs[i++] = this->gl_config.accum_red_size;
glcont = AmigaMesaCreateContext(attributes);
if ( glcont == NULL ) {
SDL_SetError("Couldn't create OpenGL context");
return(-1);
}
this->gl_data->gl_active = 1;
this->gl_config.driver_loaded = 1;
if( this->gl_config.accum_green_size ) {
attribs[i++] = GLX_ACCUM_GREEN_SIZE;
attribs[i++] = this->gl_config.accum_green_size;
}
if( this->gl_config.accum_blue_size ) {
attribs[i++] = GLX_ACCUM_BLUE_SIZE;
attribs[i++] = this->gl_config.accum_blue_size;
}
if( this->gl_config.accum_alpha_size ) {
attribs[i++] = GLX_ACCUM_ALPHA_SIZE;
attribs[i++] = this->gl_config.accum_alpha_size;
}
attribs[i++] = None;
glx_visualinfo = this->gl_data->glXChooseVisual(GFX_Display,
SDL_Screen, attribs);
if( !glx_visualinfo ) {
SDL_SetError( "Couldn't find matching GLX visual");
return NULL;
}
return glx_visualinfo;
return(0);
#else
SDL_SetError("CGX driver is not yet supporting OpenGL");
return NULL;
SDL_SetError("OpenGL support not configured");
return(-1);
#endif
}
int CGX_GL_CreateWindow(_THIS, int w, int h)
/* Quit OpenGL */
void CGX_GL_Quit(_THIS)
{
int retval;
#ifdef HAVE_OPENGL
XSetWindowAttributes attributes;
unsigned long mask;
unsigned long black;
if ( glcont != NULL ) {
AmigaMesaDestroyContext(glcont);
glcont = NULL;
this->gl_data->gl_active = 0;
this->gl_config.driver_loaded = 0;
}
#endif
}
black = (glx_visualinfo->visual == DefaultVisual(SDL_Display,
SDL_Screen))
? BlackPixel(SDL_Display, SDL_Screen) : 0;
attributes.background_pixel = black;
attributes.border_pixel = black;
attributes.colormap = SDL_XColorMap;
mask = CWBackPixel | CWBorderPixel | CWColormap;
/* Attach context to another window */
int CGX_GL_Update(_THIS)
{
#ifdef HAVE_OPENGL
struct TagItem tags[2];
struct Window *win = (struct Window*)SDL_Window;
if(glcont == NULL) {
return -1; //should never happen
}
tags[0].ti_Tag = AMA_Window;
tags[0].ti_Data = (unsigned long)win;
tags[1].ti_Tag = TAG_DONE;
AmigaMesaSetRast(glcont, tags);
SDL_Window = XCreateWindow(SDL_Display, WMwindow,
0, 0, w, h, 0, glx_visualinfo->depth,
InputOutput, glx_visualinfo->visual,
mask, &attributes);
if ( !SDL_Window ) {
SDL_SetError("Could not create window");
return 0;
#else
SDL_SetError("OpenGL support not configured");
return -1;
}
retval = 0;
#else
SDL_SetError("CGX driver is not yet supporting OpenGL");
retval = -1;
#endif
return(retval);
}
int CGX_GL_CreateContext(_THIS)
{
int retval;
#ifdef HAVE_OPENGL
/* We do this to create a clean separation between X and GLX errors. */
XSync( SDL_Display, False );
glx_context = this->gl_data->glXCreateContext(GFX_Display,
glx_visualinfo, NULL, True);
XSync( GFX_Display, False );
if (glx_context == NULL) {
SDL_SetError("Could not create GL context");
return -1;
}
gl_active = 1;
#else
SDL_SetError("CGX driver is not yet supporting OpenGL");
#endif
if ( gl_active ) {
retval = 0;
} else {
retval = -1;
}
return(retval);
}
void CGX_GL_Shutdown(_THIS)
{
#ifdef HAVE_OPENGL
/* Clean up OpenGL */
if( glx_context ) {
this->gl_data->glXMakeCurrent(GFX_Display, None, NULL);
if (glx_context != NULL)
this->gl_data->glXDestroyContext(GFX_Display, glx_context);
if( this->gl_data->glXReleaseBuffersMESA ) {
this->gl_data->glXReleaseBuffersMESA(GFX_Display,SDL_Window);
}
glx_context = NULL;
}
gl_active = 0;
#endif /* HAVE_OPENGL */
}
#ifdef HAVE_OPENGL
@ -215,175 +143,75 @@ void CGX_GL_Shutdown(_THIS)
/* Make the current context active */
int CGX_GL_MakeCurrent(_THIS)
{
int retval;
if(glcont == NULL)
return -1;
retval = 0;
if ( ! this->gl_data->glXMakeCurrent(GFX_Display,
SDL_Window, glx_context) ) {
SDL_SetError("Unable to make GL context current");
retval = -1;
}
XSync( GFX_Display, False );
/* More Voodoo X server workarounds... Grr... */
SDL_Lock_EventThread();
X11_CheckDGAMouse(this);
SDL_Unlock_EventThread();
return(retval);
}
/* Get attribute data from glX. */
int CGX_GL_GetAttribute(_THIS, SDL_GLattr attrib, int* value)
{
int retval;
int glx_attrib = None;
switch( attrib ) {
case SDL_GL_RED_SIZE:
glx_attrib = GLX_RED_SIZE;
break;
case SDL_GL_GREEN_SIZE:
glx_attrib = GLX_GREEN_SIZE;
break;
case SDL_GL_BLUE_SIZE:
glx_attrib = GLX_BLUE_SIZE;
break;
case SDL_GL_ALPHA_SIZE:
glx_attrib = GLX_ALPHA_SIZE;
break;
case SDL_GL_DOUBLEBUFFER:
glx_attrib = GLX_DOUBLEBUFFER;
break;
case SDL_GL_BUFFER_SIZE:
glx_attrib = GLX_BUFFER_SIZE;
break;
case SDL_GL_DEPTH_SIZE:
glx_attrib = GLX_DEPTH_SIZE;
break;
case SDL_GL_STENCIL_SIZE:
glx_attrib = GLX_STENCIL_SIZE;
break;
case SDL_GL_ACCUM_RED_SIZE:
glx_attrib = GLX_ACCUM_RED_SIZE;
break;
case SDL_GL_ACCUM_GREEN_SIZE:
glx_attrib = GLX_ACCUM_GREEN_SIZE;
break;
case SDL_GL_ACCUM_BLUE_SIZE:
glx_attrib = GLX_ACCUM_BLUE_SIZE;
break;
case SDL_GL_ACCUM_ALPHA_SIZE:
glx_attrib = GLX_ACCUM_ALPHA_SIZE;
break;
default:
return(-1);
}
retval = this->gl_data->glXGetConfig(GFX_Display, glx_visualinfo, glx_attrib, value);
return retval;
AmigaMesaMakeCurrent(glcont, glcont->buffer);
return 0;
}
void CGX_GL_SwapBuffers(_THIS)
{
this->gl_data->glXSwapBuffers(GFX_Display, SDL_Window);
AmigaMesaSwapBuffers(glcont);
}
#endif /* HAVE_OPENGL */
int CGX_GL_GetAttribute(_THIS, SDL_GLattr attrib, int* value) {
GLenum mesa_attrib;
void CGX_GL_UnloadLibrary(_THIS)
{
#ifdef HAVE_OPENGL
if ( this->gl_config.driver_loaded ) {
dlclose(this->gl_config.dll_handle);
this->gl_data->glXChooseVisual = NULL;
this->gl_data->glXCreateContext = NULL;
this->gl_data->glXDestroyContext = NULL;
this->gl_data->glXMakeCurrent = NULL;
this->gl_data->glXSwapBuffers = NULL;
this->gl_config.dll_handle = NULL;
this->gl_config.driver_loaded = 0;
}
#endif
}
#ifdef HAVE_OPENGL
/* Passing a NULL path means load pointers from the application */
int CGX_GL_LoadLibrary(_THIS, const char* path)
{
void* handle;
int dlopen_flags;
if ( gl_active ) {
SDL_SetError("OpenGL context already created");
switch(attrib) {
case SDL_GL_RED_SIZE:
mesa_attrib = GL_RED_BITS;
break;
case SDL_GL_GREEN_SIZE:
mesa_attrib = GL_GREEN_BITS;
break;
case SDL_GL_BLUE_SIZE:
mesa_attrib = GL_BLUE_BITS;
break;
case SDL_GL_ALPHA_SIZE:
mesa_attrib = GL_ALPHA_BITS;
break;
case SDL_GL_DOUBLEBUFFER:
mesa_attrib = GL_DOUBLEBUFFER;
break;
case SDL_GL_DEPTH_SIZE:
mesa_attrib = GL_DEPTH_BITS;
break;
case SDL_GL_STENCIL_SIZE:
mesa_attrib = GL_STENCIL_BITS;
break;
case SDL_GL_ACCUM_RED_SIZE:
mesa_attrib = GL_ACCUM_RED_BITS;
break;
case SDL_GL_ACCUM_GREEN_SIZE:
mesa_attrib = GL_ACCUM_GREEN_BITS;
break;
case SDL_GL_ACCUM_BLUE_SIZE:
mesa_attrib = GL_ACCUM_BLUE_BITS;
break;
case SDL_GL_ACCUM_ALPHA_SIZE:
mesa_attrib = GL_ACCUM_ALPHA_BITS;
break;
default :
return -1;
}
#ifdef RTLD_GLOBAL
dlopen_flags = RTLD_LAZY | RTLD_GLOBAL;
#else
dlopen_flags = RTLD_LAZY;
#endif
handle = dlopen(path, dlopen_flags);
/* Catch the case where the application isn't linked with GL */
if ( (dlsym(handle, "glXChooseVisual") == NULL) && (path == NULL) ) {
dlclose(handle);
path = getenv("SDL_VIDEO_GL_DRIVER");
if ( path == NULL ) {
path = DEFAULT_OPENGL;
}
handle = dlopen(path, dlopen_flags);
}
if ( handle == NULL ) {
SDL_SetError("Could not load OpenGL library");
return -1;
}
/* Unload the old driver and reset the pointers */
X11_GL_UnloadLibrary(this);
/* Load new function pointers */
this->gl_data->glXChooseVisual = dlsym(handle, "glXChooseVisual");
this->gl_data->glXCreateContext = dlsym(handle, "glXCreateContext");
this->gl_data->glXDestroyContext = dlsym(handle, "glXDestroyContext");
this->gl_data->glXMakeCurrent = dlsym(handle, "glXMakeCurrent");
this->gl_data->glXSwapBuffers = dlsym(handle, "glXSwapBuffers");
this->gl_data->glXGetConfig = dlsym(handle, "glXGetConfig");
/* We don't compare below for this in case we're not using Mesa. */
this->gl_data->glXReleaseBuffersMESA = dlsym( handle, "glXReleaseBuffersMESA" );
if ( (this->gl_data->glXChooseVisual == NULL) ||
(this->gl_data->glXCreateContext == NULL) ||
(this->gl_data->glXDestroyContext == NULL) ||
(this->gl_data->glXMakeCurrent == NULL) ||
(this->gl_data->glXSwapBuffers == NULL) ||
(this->gl_data->glXGetConfig == NULL) ) {
SDL_SetError("Could not retrieve OpenGL functions");
return -1;
}
this->gl_config.dll_handle = handle;
this->gl_config.driver_loaded = 1;
if ( path ) {
strncpy(this->gl_config.driver_path, path,
sizeof(this->gl_config.driver_path)-1);
} else {
strcpy(this->gl_config.driver_path, "");
}
AmigaMesaGetConfig(glcont->visual, mesa_attrib, value);
return 0;
}
void *CGX_GL_GetProcAddress(_THIS, const char* proc)
{
void* handle;
void *CGX_GL_GetProcAddress(_THIS, const char *proc) {
void *func = NULL;
func = AmiGetGLProc(proc);
return func;
}
handle = this->gl_config.dll_handle;
int CGX_GL_LoadLibrary(_THIS, const char *path) {
/* Library is always open */
this->gl_config.driver_loaded = 1;
return dlsym(handle, proc);
return 0;
}
#endif /* HAVE_OPENGL */

72
src/video/cybergfx/SDL_cgxgl_c.h
View file

@ -25,74 +25,30 @@ static char rcsid =
"@(#) $Id$";
#endif
#include <stdio.h>
/* StormMesa implementation of SDL OpenGL support */
#include "SDL_sysvideo.h"
#define _THIS SDL_VideoDevice *_this
#ifdef HAVE_OPENGL
#include <GL/glx.h>
#include <dlfcn.h>
#endif
#include "SDL_sysvideo.h"
#include <GL/Amigamesa.h>
extern void *AmiGetGLProc(const char *proc);
#endif /* HAVE_OPENGL */
struct SDL_PrivateGLData {
int gl_active; /* to stop switching drivers while we have a valid context */
#ifdef HAVE_OPENGL
GLXContext glx_context; /* Current GL context */
XVisualInfo* glx_visualinfo; /* XVisualInfo* returned by glXChooseVisual */
XVisualInfo* (*glXChooseVisual)
( Display* dpy,
int screen,
int* attribList );
GLXContext (*glXCreateContext)
( Display* dpy,
XVisualInfo* vis,
GLXContext shareList,
Bool direct );
void (*glXDestroyContext)
( Display* dpy,
GLXContext ctx );
Bool (*glXMakeCurrent)
( Display* dpy,
GLXDrawable drawable,
GLXContext ctx );
void (*glXSwapBuffers)
( Display* dpy,
GLXDrawable drawable );
int (*glXGetConfig)
( Display* dpy,
XVisualInfo* visual_info,
int attrib,
int* value );
void (*glXReleaseBuffersMESA)
( Display* dpy,
GLXDrawable drawable );
#endif /* HAVE_OPENGL */
int gl_active;
};
/* Old variable names */
#define gl_active (this->gl_data->gl_active)
#define glx_context (this->gl_data->glx_context)
#define glx_visualinfo (this->gl_data->glx_visualinfo)
/* OpenGL functions */
extern void *CGX_GL_GetVisual(_THIS);
extern int CGX_GL_CreateWindow(_THIS, int w, int h);
extern int CGX_GL_CreateContext(_THIS);
extern void CGX_GL_Shutdown(_THIS);
extern int CGX_GL_Init(_THIS);
extern void CGX_GL_Quit(_THIS);
extern int CGX_GL_Update(_THIS);
#ifdef HAVE_OPENGL
extern int CGX_GL_MakeCurrent(_THIS);
extern int CGX_GL_GetAttribute(_THIS, SDL_GLattr attrib, int* value);
extern void CGX_GL_SwapBuffers(_THIS);
extern int CGX_GL_LoadLibrary(_THIS, const char* path);
extern void *CGX_GL_GetProcAddress(_THIS, const char* proc);
extern void *CGX_GL_GetProcAddress(_THIS, const char *proc);
extern int CGX_GL_LoadLibrary(_THIS, const char *path);
#endif
extern void CGX_GL_UnloadLibrary(_THIS);
#undef _THIS

78
src/video/cybergfx/SDL_cgximage.c
View file

@ -52,36 +52,35 @@ static void CGX_FakeUpdate(_THIS, int numrects, SDL_Rect *rects);
BOOL SafeDisp=TRUE,SafeChange=TRUE;
struct MsgPort *safeport=NULL,*dispport=NULL;
ULONG safe_sigbit,disp_sigbit;
int use_picasso96=1;
int CGX_SetupImage(_THIS, SDL_Surface *screen)
{
if(screen->flags&SDL_HWSURFACE)
{
Uint32 pitch;
SDL_Ximage=NULL;
if(!screen->hwdata)
{
if(screen->flags&SDL_HWSURFACE) {
ULONG pitch;
if(!screen->hwdata) {
if(!(screen->hwdata=malloc(sizeof(struct private_hwdata))))
{
return -1;
}
D(bug("Creating system accel struct\n"));
}
screen->hwdata->lock=0;
screen->hwdata->lock=NULL;
screen->hwdata->allocated=0;
screen->hwdata->mask=NULL;
screen->hwdata->bmap=SDL_RastPort->BitMap;
screen->hwdata->videodata=this;
if(!(screen->hwdata->lock=LockBitMapTags(screen->hwdata->bmap,
LBMI_BASEADDRESS,(ULONG)&screen->pixels,
LBMI_BYTESPERROW,(ULONG)&pitch,TAG_DONE)))
{
LBMI_BYTESPERROW,(ULONG)&pitch,TAG_DONE))) {
free(screen->hwdata);
screen->hwdata=NULL;
return -1;
}
else
{
else {
UnLockBitMap(screen->hwdata->lock);
screen->hwdata->lock=NULL;
}
@ -101,17 +100,6 @@ int CGX_SetupImage(_THIS, SDL_Surface *screen)
return(-1);
}
/*
{
int bpp = screen->format->BytesPerPixel;
SDL_Ximage = XCreateImage(SDL_Display, SDL_Visual,
this->hidden->depth, ZPixmap, 0,
(char *)screen->pixels,
screen->w, screen->h,
(bpp == 3) ? 32 : bpp * 8,
0);
}
*/
SDL_Ximage=screen->pixels;
if ( SDL_Ximage == NULL ) {
@ -132,6 +120,11 @@ void CGX_DestroyImage(_THIS, SDL_Surface *screen)
}
if ( screen ) {
screen->pixels = NULL;
if(screen->hwdata) {
free(screen->hwdata);
screen->hwdata=NULL;
}
}
}
@ -145,7 +138,7 @@ int CGX_ResizeImage(_THIS, SDL_Surface *screen, Uint32 flags)
{
int retval;
D(bug("Chiamata ResizeImage!\n"));
D(bug("Calling ResizeImage()\n"));
CGX_DestroyImage(this, screen);
@ -155,11 +148,6 @@ int CGX_ResizeImage(_THIS, SDL_Surface *screen, Uint32 flags)
retval = CGX_SetupImage(this, screen);
/* We support asynchronous blitting on the display */
if ( flags & SDL_ASYNCBLIT ) {
/* This is actually slower on single-CPU systems,
probably because of CPU contention between the
X server and the application.
Note: Is this still true with XFree86 4.0?
*/
if ( num_CPU() > 1 ) {
screen->flags |= SDL_ASYNCBLIT;
}
@ -168,7 +156,6 @@ int CGX_ResizeImage(_THIS, SDL_Surface *screen, Uint32 flags)
return(retval);
}
/* We don't actually allow hardware surfaces other than the main one */
int CGX_AllocHWSurface(_THIS, SDL_Surface *surface)
{
D(bug("Alloc HW surface...%ld x %ld x %ld!\n",surface->w,surface->h,this->hidden->depth));
@ -185,11 +172,14 @@ int CGX_AllocHWSurface(_THIS, SDL_Surface *surface)
return -1;
}
surface->hwdata->mask=NULL;
surface->hwdata->lock=NULL;
surface->hwdata->videodata=this;
surface->hwdata->allocated=0;
if(surface->hwdata->bmap=AllocBitMap(surface->w,surface->h,this->hidden->depth,BMF_MINPLANES,SDL_Display->RastPort.BitMap))
{
surface->hwdata->allocated=1;
surface->flags|=SDL_HWSURFACE;
D(bug("...OK\n"));
return 0;
@ -211,11 +201,13 @@ void CGX_FreeHWSurface(_THIS, SDL_Surface *surface)
if(surface->hwdata->mask)
free(surface->hwdata->mask);
if(surface->hwdata->bmap)
if(surface->hwdata->bmap&&surface->hwdata->allocated)
FreeBitMap(surface->hwdata->bmap);
free(surface->hwdata);
surface->hwdata=NULL;
surface->pixels=NULL;
D(bug("end of free hw surface\n"));
}
return;
}
@ -242,11 +234,11 @@ int CGX_LockHWSurface(_THIS, SDL_Surface *surface)
surface->pixels=((char *)surface->pixels)+(surface->pitch*(SDL_Window->BorderTop+SDL_Window->TopEdge)+
surface->format->BytesPerPixel*(SDL_Window->BorderLeft+SDL_Window->LeftEdge));
}
else
D(bug("Already locked!!!\n"));
D(else bug("Already locked!!!\n"));
}
return(0);
}
void CGX_UnlockHWSurface(_THIS, SDL_Surface *surface)
{
if(surface->hwdata && surface->hwdata->lock)
@ -398,7 +390,7 @@ static void CGX_NormalUpdate(_THIS, int numrects, SDL_Rect *rects)
#ifndef USE_CGX_WRITELUTPIXEL
int bpp;
#endif
if(this->hidden->same_format)
if(this->hidden->same_format && !use_picasso96)
{
format=RECTFMT_RAW;
}
@ -445,7 +437,7 @@ static void CGX_NormalUpdate(_THIS, int numrects, SDL_Rect *rects)
/* Check for endian-swapped X server, swap if necessary (VERY slow!) */
if ( swap_pixels &&
((this->screen->format->BytesPerPixel%2) == 0) ) {
D(bug("Swappo! Lento!\n"));
D(bug("Software Swapping! SLOOOW!\n"));
CGX_SwapPixels(this->screen, numrects, rects);
for ( i=0; i<numrects; ++i ) {
if ( ! rects[i].w ) { /* Clipped? */
@ -633,7 +625,7 @@ static void CGX_NormalUpdate(_THIS, int numrects, SDL_Rect *rects)
Uint32 destpitch;
APTR handle;
// D(bug("Uso customroutine!\n"));
// D(bug("Using customroutine!\n"));
if(handle=LockBitMapTags(SDL_RastPort->BitMap,LBMI_BASEADDRESS,(ULONG)&bm_address,
LBMI_BYTESPERROW,(ULONG)&destpitch,TAG_DONE))
@ -685,20 +677,8 @@ static void CGX_NormalUpdate(_THIS, int numrects, SDL_Rect *rects)
USE_WPA(this->screen->pixels,rects[i].x, rects[i].y,this->screen->pitch,
SDL_RastPort,SDL_Window->BorderLeft+rects[i].x,SDL_Window->BorderTop+rects[i].y,
rects[i].w,rects[i].h,format);
/*
XPutImage(GFX_Display, SDL_Window, SDL_GC, SDL_Ximage,
rects[i].x, rects[i].y,
rects[i].x, rects[i].y, rects[i].w, rects[i].h);
*/
}
}
/*
if ( SDL_VideoSurface->flags & SDL_ASYNCBLIT ) {
++blit_queued;
} else {
}
*/
}
void CGX_RefreshDisplay(_THIS)
@ -712,7 +692,7 @@ void CGX_RefreshDisplay(_THIS)
return;
}
if(this->hidden->same_format)
if(this->hidden->same_format && !use_picasso96)
{
format=RECTFMT_RAW;
}

11
src/video/cybergfx/SDL_cgxmodes.c
View file

@ -1,6 +1,6 @@
/*
SDL - Simple DirectMedia Layer
Copyright (C) 1997, 1998, 1999, 2000, 2001 Sam Lantinga
Copyright (C) 1997, 1998, 1999, 2000 Sam Lantinga
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Library General Public
@ -66,14 +66,15 @@ static void set_best_resolution(_THIS, int width, int height)
}
SDL_Display=GFX_Display=OpenScreenTags(NULL,SA_Width,width,SA_Height,height,
SA_Depth,depth,SA_DisplayID,idok,
SA_ShowTitle,FALSE,
TAG_DONE);
}
}
static void get_real_resolution(_THIS, int* w, int* h)
{
*w = SDL_Display->Width;
*h = SDL_Display->Height;
*w = /*SDL_Display->Width*/ SDL_Window->Width-SDL_Window->BorderLeft-SDL_Window->BorderRight;
*h = /*SDL_Display->Height*/ SDL_Window->Height-SDL_Window->BorderBottom-SDL_Window->BorderTop;
}
static void move_cursor_to(_THIS, int x, int y)
@ -267,8 +268,11 @@ void _QueueEnterFullScreen(_THIS)
int CGX_EnterFullScreen(_THIS)
{
int okay;
Uint32 saved_flags;
okay = 1;
saved_flags = this->screen->flags;
if ( ! currently_fullscreen )
{
int real_w, real_h;
@ -297,6 +301,7 @@ int CGX_EnterFullScreen(_THIS)
#endif
currently_fullscreen = 1;
this->screen->flags = saved_flags;
CGX_CreateWindow(this,this->screen,real_w,real_h,GetCyberMapAttr(SDL_Display->RastPort.BitMap,CYBRMATTR_DEPTH),this->screen->flags);

483
src/video/cybergfx/SDL_cgxvideo.c
View file

@ -1,6 +1,6 @@
/*
SDL - Simple DirectMedia Layer
Copyright (C) 1997, 1998, 1999, 2000, 2001 Sam Lantinga
Copyright (C) 1997, 1998, 1999, 2000 Sam Lantinga
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Library General Public
@ -25,8 +25,10 @@ static char rcsid =
"@(#) $Id$";
#endif
/* CGX based SDL video driver implementation.
*/
/*
* CGX based SDL video driver implementation by Gabriele Greco
* gabriele.greco@aruba.it
*/
/*
#include <stdlib.h>
@ -50,6 +52,7 @@ static char rcsid =
#include "SDL_sysvideo.h"
#include "SDL_pixels_c.h"
#include "SDL_events_c.h"
#include "SDL_cgxgl_c.h"
#include "SDL_cgxvideo.h"
#include "SDL_cgxwm_c.h"
#include "SDL_amigamouse_c.h"
@ -57,7 +60,6 @@ static char rcsid =
#include "SDL_cgxmodes_c.h"
#include "SDL_cgximage_c.h"
#include "SDL_cgxyuv_c.h"
#include "SDL_cgxgl_c.h"
/* Initialization/Query functions */
static int CGX_VideoInit(_THIS, SDL_PixelFormat *vformat);
@ -73,6 +75,52 @@ struct Library *CyberGfxBase=NULL;
struct IntuitionBase *IntuitionBase=NULL;
struct GfxBase *GfxBase=NULL;
int CGX_SetGamma(_THIS, float red, float green, float blue)
{
SDL_SetError("Gamma correction not supported");
return -1;
}
int CGX_GetGamma(_THIS, float red, float green, float blue)
{
SDL_SetError("Gamma correction not supported");
return -1;
}
int CGX_SetGammaRamp(_THIS, Uint16 *ramp)
{
#if 0
Int i, ncolors;
XColor xcmap[256];
/* See if actually setting the gamma is supported */
if ( SDL_Visual->class != DirectColor ) {
SDL_SetError("Gamma correction not supported on this visual");
return(-1);
}
/* Calculate the appropriate palette for the given gamma ramp */
ncolors = SDL_Visual->map_entries;
for ( i=0; i<ncolors; ++i ) {
Uint8 c = (256 * i / ncolors);
xcmap[i].pixel = SDL_MapRGB(this->screen->format, c, c, c);
xcmap[i].red = ramp[0*256+c];
xcmap[i].green = ramp[1*256+c];
xcmap[i].blue = ramp[2*256+c];
xcmap[i].flags = (DoRed|DoGreen|DoBlue);
}
XStoreColors(GFX_Display, SDL_XColorMap, xcmap, ncolors);
XSync(GFX_Display, False);
return(0);
#else
SDL_SetError("Gamma correction not supported on this visual");
return(-1);
#endif
}
static void DestroyScreen(_THIS)
{
if(currently_fullscreen)
@ -98,20 +146,22 @@ static void DestroyScreen(_THIS)
this->hidden->SB[1]->sb_DBufInfo->dbi_SafeMessage.mn_ReplyPort=this->hidden->SB[1]->sb_DBufInfo->dbi_DispMessage.mn_ReplyPort=NULL;
if(this->hidden->SB[1])
FreeScreenBuffer(SDL_Display,this->hidden->SB[0]);
if(this->hidden->SB[0])
FreeScreenBuffer(SDL_Display,this->hidden->SB[1]);
if(this->hidden->SB[0])
FreeScreenBuffer(SDL_Display,this->hidden->SB[0]);
this->hidden->SB[0]=this->hidden->SB[1]=NULL;
if(SDL_RastPort && SDL_RastPort != &SDL_Display->RastPort)
free(SDL_RastPort);
SDL_RastPort=NULL;
this->hidden->dbuffer=0;
}
CloseScreen(GFX_Display);
currently_fullscreen=0;
}
else
else if(GFX_Display)
UnlockPubScreen(NULL,GFX_Display);
GFX_Display = NULL;
@ -121,11 +171,14 @@ static int CGX_Available(void)
{
struct Library *l;
l = OpenLibrary("cybergraphics.library",NULL);
l = OpenLibrary("cybergraphics.library",0L);
if ( l != NULL ) {
D(bug("CGX video device AVAILABLE\n"));
CloseLibrary(l);
}
D(else bug("**CGX video device UNAVAILABLE\n"));
return(l != NULL);
}
@ -157,12 +210,13 @@ static SDL_VideoDevice *CGX_CreateDevice(int devindex)
}
if ( (device == NULL) || (device->hidden == NULL) ||
(device->gl_data == NULL) ) {
D(bug("Unable to create video device!\n"));
SDL_OutOfMemory();
CGX_DeleteDevice(device);
return(0);
}
memset(device->hidden, 0, (sizeof *device->hidden));
memset(device->gl_data, 0, (sizeof *device->gl_data));
memset(device->hidden, 0, sizeof(*device->hidden));
memset(device->gl_data, 0, sizeof(*device->gl_data));
/* Set the driver flags */
device->handles_any_size = 1;
@ -188,12 +242,16 @@ static SDL_VideoDevice *CGX_CreateDevice(int devindex)
device->UnlockHWSurface = CGX_UnlockHWSurface;
device->FlipHWSurface = CGX_FlipHWSurface;
device->FreeHWSurface = CGX_FreeHWSurface;
device->SetGamma = CGX_SetGamma;
device->GetGamma = CGX_GetGamma;
device->SetGammaRamp = CGX_SetGammaRamp;
device->GetGammaRamp = NULL;
#ifdef HAVE_OPENGL
device->GL_LoadLibrary = X11_GL_LoadLibrary;
device->GL_GetProcAddress = X11_GL_GetProcAddress;
device->GL_GetAttribute = X11_GL_GetAttribute;
device->GL_MakeCurrent = X11_GL_MakeCurrent;
device->GL_SwapBuffers = X11_GL_SwapBuffers;
device->GL_LoadLibrary = CGX_GL_LoadLibrary;
device->GL_GetProcAddress = CGX_GL_GetProcAddress;
device->GL_GetAttribute = CGX_GL_GetAttribute;
device->GL_MakeCurrent = CGX_GL_MakeCurrent;
device->GL_SwapBuffers = CGX_GL_SwapBuffers;
#endif
device->SetIcon = CGX_SetIcon;
device->SetCaption = CGX_SetCaption;
@ -217,112 +275,6 @@ VideoBootStrap CGX_bootstrap = {
"CGX", "AmigaOS CyberGraphics", CGX_Available, CGX_CreateDevice
};
#if 0
/* Create auxiliary (toplevel) windows with the current visual */
static void create_aux_windows(_THIS)
{
XSetWindowAttributes xattr;
XWMHints *hints;
XTextProperty titleprop, iconprop;
int def_vis = (SDL_Visual == DefaultVisual(SDL_Display, SDL_Screen));
/* Don't create any extra windows if we are being managed */
if ( SDL_windowid ) {
FSwindow = 0;
WMwindow = strtol(SDL_windowid, NULL, 0);
return;
}
if(FSwindow)
XDestroyWindow(SDL_Display, FSwindow);
xattr.override_redirect = True;
xattr.background_pixel = def_vis ? BlackPixel(SDL_Display, SDL_Screen) : 0;
xattr.border_pixel = 0;
xattr.colormap = SDL_XColorMap;
FSwindow = XCreateWindow(SDL_Display, SDL_Root, 0, 0, 32, 32, 0,
this->hidden->depth, InputOutput, SDL_Visual,
CWOverrideRedirect | CWBackPixel | CWBorderPixel
| CWColormap,
&xattr);
XSelectInput(SDL_Display, FSwindow, StructureNotifyMask);
/* Tell KDE to keep the fullscreen window on top */
{
XEvent ev;
long mask;
memset(&ev, 0, sizeof(ev));
ev.xclient.type = ClientMessage;
ev.xclient.window = SDL_Root;
ev.xclient.message_type = XInternAtom(SDL_Display,
"KWM_KEEP_ON_TOP", False);
ev.xclient.format = 32;
ev.xclient.data.l[0] = FSwindow;
ev.xclient.data.l[1] = CurrentTime;
mask = SubstructureRedirectMask;
XSendEvent(SDL_Display, SDL_Root, False, mask, &ev);
}
hints = NULL;
titleprop.value = iconprop.value = NULL;
if(WMwindow) {
/* All window attributes must survive the recreation */
hints = XGetWMHints(SDL_Display, WMwindow);
XGetWMName(SDL_Display, WMwindow, &titleprop);
XGetWMIconName(SDL_Display, WMwindow, &iconprop);
XDestroyWindow(SDL_Display, WMwindow);
}
/* Create the window for windowed management */
/* (reusing the xattr structure above) */
WMwindow = XCreateWindow(SDL_Display, SDL_Root, 0, 0, 32, 32, 0,
this->hidden->depth, InputOutput, SDL_Visual,
CWBackPixel | CWBorderPixel | CWColormap,
&xattr);
/* Set the input hints so we get keyboard input */
if(!hints) {
hints = XAllocWMHints();
hints->input = True;
hints->flags = InputHint;
}
XSetWMHints(SDL_Display, WMwindow, hints);
XFree(hints);
if(titleprop.value) {
XSetWMName(SDL_Display, WMwindow, &titleprop);
XFree(titleprop.value);
}
if(iconprop.value) {
XSetWMIconName(SDL_Display, WMwindow, &iconprop);
XFree(iconprop.value);
}
XSelectInput(SDL_Display, WMwindow,
FocusChangeMask | KeyPressMask | KeyReleaseMask
| PropertyChangeMask | StructureNotifyMask);
/* Set the class hints so we can get an icon (AfterStep) */
{
XClassHint *classhints;
classhints = XAllocClassHint();
if(classhints != NULL) {
classhints->res_name = "SDL_App";
classhints->res_class = "SDL_App";
XSetClassHint(SDL_Display, WMwindow, classhints);
XFree(classhints);
}
}
/* Allow the window to be deleted by the window manager */
WM_DELETE_WINDOW = XInternAtom(SDL_Display, "WM_DELETE_WINDOW", False);
XSetWMProtocols(SDL_Display, WMwindow, &WM_DELETE_WINDOW, 1);
}
#endif
Uint32 MakeBitMask(_THIS,int type,int format,int *bpp)
{
D(if(type==0)bug("REAL pixel format: "));
@ -492,30 +444,50 @@ use_truecolor:
static int CGX_VideoInit(_THIS, SDL_PixelFormat *vformat)
{
int i;
struct Library *RTGBase;
if(!(IntuitionBase=(struct IntuitionBase *)OpenLibrary("intuition.library",39L)))
{
D(bug("VideoInit... Opening libraries\n"));
if(!IntuitionBase) {
if( !(IntuitionBase=(struct IntuitionBase *)OpenLibrary("intuition.library",39L))) {
SDL_SetError("Couldn't open intuition V39+");
return -1;
}
if(!(GfxBase=(struct GfxBase *)OpenLibrary("graphics.library",39L)))
{
}
if(!GfxBase) {
if( !(GfxBase=(struct GfxBase *)OpenLibrary("graphics.library",39L))) {
SDL_SetError("Couldn't open graphics V39+");
return -1;
}
if(!(CyberGfxBase=OpenLibrary("cybergraphics.library",40L)))
{
}
if(!CyberGfxBase) {
if( !(CyberGfxBase=OpenLibrary("cybergraphics.library",40L))) {
SDL_SetError("Couldn't open cybergraphics.");
return(-1);
}
}
if(RTGBase=OpenLibrary("libs:picasso96/rtg.library",0L)) {
extern int use_picasso96;
CloseLibrary(RTGBase);
use_picasso96=1;
}
D(bug("Library intialized, locking screen...\n"));
SDL_Display = LockPubScreen(NULL);
if ( SDL_Display == NULL ) {
D(bug("Cannot lock display...\n"));
SDL_SetError("Couldn't lock the display");
return(-1);
}
D(bug("Checking if we are using a CGX native display...\n"));
if(!IsCyberModeID(GetVPModeID(&SDL_Display->ViewPort)))
{
Uint32 okid=BestCModeIDTags(CYBRBIDTG_NominalWidth,SDL_Display->Width,
@ -523,6 +495,8 @@ static int CGX_VideoInit(_THIS, SDL_PixelFormat *vformat)
CYBRBIDTG_Depth,8,
TAG_DONE);
D(bug("Default visual is not CGX native!\n"));
UnlockPubScreen(NULL,SDL_Display);
GFX_Display=NULL;
@ -559,6 +533,8 @@ static int CGX_VideoInit(_THIS, SDL_PixelFormat *vformat)
swap_pixels = 1;
}
D(bug("Before GetVideoModes....\n"));
/* Get the available video modes */
if(CGX_GetVideoModes(this) < 0)
return -1;
@ -578,7 +554,7 @@ static int CGX_VideoInit(_THIS, SDL_PixelFormat *vformat)
// SDL_XColorMap = SDL_DisplayColormap;
this->hidden->depth = this->hidden->visuals[i].depth;
D(bug("Setto la profiondita' dello schermo a: %ld\n",this->hidden->depth));
D(bug("Init: Setting screen depth to: %ld\n",this->hidden->depth));
vformat->BitsPerPixel = this->hidden->visuals[i].depth; /* this->hidden->visuals[i].bpp; */
{
@ -587,10 +563,15 @@ static int CGX_VideoInit(_THIS, SDL_PixelFormat *vformat)
struct DisplayInfo info;
if(!(handle=FindDisplayInfo(this->hidden->visuals[i].visual)))
{
D(bug("Unable to get visual info...\n"));
return -1;
}
if(!GetDisplayInfoData(handle,(char *)&info,sizeof(struct DisplayInfo),DTAG_DISP,NULL))
if(!GetDisplayInfoData(handle,(char *)&info,sizeof(struct DisplayInfo),DTAG_DISP,NULL)) {
D(bug("Unable to get visual info data...\n"));
return -1;
}
form=GetCyberIDAttr(CYBRIDATTR_PIXFMT,SDL_Visual);
@ -608,9 +589,6 @@ static int CGX_VideoInit(_THIS, SDL_PixelFormat *vformat)
/* SDL_windowid = getenv("SDL_WINDOWID"); */
SDL_windowid=NULL;
/* Create the fullscreen and managed windows */
// create_aux_windows(this);
/* Create the blank cursor */
SDL_BlankCursor = AllocMem(16,MEMF_CHIP|MEMF_CLEAR);
@ -625,15 +603,24 @@ static int CGX_VideoInit(_THIS, SDL_PixelFormat *vformat)
this->hidden->same_format=0;
SDL_RastPort=&SDL_Display->RastPort;
/* We're done! */
D(bug("End of CGX_VideoInit\n"));
return(0);
}
void CGX_DestroyWindow(_THIS, SDL_Surface *screen)
{
D(bug("Destroy Window...\n"));
if ( ! SDL_windowid ) {
/* Hide the managed window */
int was_fullscreen=0;
/* Clean up OpenGL */
if ( screen ) {
screen->flags &= ~(SDL_OPENGL|SDL_OPENGLBLIT);
}
if ( screen && (screen->flags & SDL_FULLSCREEN) ) {
was_fullscreen=1;
screen->flags &= ~SDL_FULLSCREEN;
@ -701,6 +688,8 @@ int CGX_CreateWindow(_THIS, SDL_Surface *screen,
int i, depth;
Uint32 vis;
#endif
D(bug("CGX_CreateWindow\n"));
/* If a window is already present, destroy it and start fresh */
if ( SDL_Window ) {
CGX_DestroyWindow(this, screen);
@ -718,11 +707,11 @@ int CGX_CreateWindow(_THIS, SDL_Surface *screen,
/* questo l'ho spostato nell'apertura dello schermo, in quanto su Amiga le finestre
hanno il pixel mode degli schermi.
*/
if ( flags & SDL_OPENGL ) {
/*if ( flags & SDL_OPENGL ) {
SDL_SetError("OpenGL not supported by the Amiga SDL!");
return -1;
}
else {
else {*/
for ( i = 0; i < this->hidden->nvisuals; i++ ) {
if ( this->hidden->visuals[i].depth == bpp ) /* era .depth */
break;
@ -733,10 +722,10 @@ int CGX_CreateWindow(_THIS, SDL_Surface *screen,
}
vis = this->hidden->visuals[i].visual;
depth = this->hidden->visuals[i].depth;
}
// }
SDL_Visual = vis;
this->hidden->depth = depth;
D(bug("Setto la profiondita' dello schermo a: %ld\n",this->hidden->depth));
D(bug("Setting screen depth to: %ld\n",this->hidden->depth));
#endif
/* Allocate the new pixel format for this video mode */
@ -783,8 +772,8 @@ int CGX_CreateWindow(_THIS, SDL_Surface *screen,
}
*/
if ( GetCyberMapAttr(SDL_Display->RastPort.BitMap,CYBRMATTR_PIXFMT)==PIXFMT_LUT8 || bpp==8 ) {
int ncolors;
D(bug("Alloco XPixels x la palette...\n"));
int ncolors,i;
D(bug("XPixels palette allocation...\n"));
/* Allocate the pixel flags */
@ -800,46 +789,24 @@ int CGX_CreateWindow(_THIS, SDL_Surface *screen,
return -1;
}
memset(SDL_XPixels, -1, ncolors * sizeof(Sint32));
for(i=0;i<ncolors;i++)
SDL_XPixels[i]=-1;
/* always allocate a private colormap on non-default visuals */
if(bpp==8)
flags |= SDL_HWPALETTE;
if ( flags & SDL_HWPALETTE ) {
if ( flags & SDL_HWPALETTE )
screen->flags |= SDL_HWPALETTE;
/*
SDL_XColorMap = XCreateColormap(SDL_Display, SDL_Root,
SDL_Visual, AllocAll);
*/
} else {
/*
SDL_XColorMap = SDL_DisplayColormap;
*/
}
} else {
/*
SDL_XColorMap = XCreateColormap(SDL_Display, SDL_Root,
SDL_Visual, AllocNone);
*/
}
/* Recreate the auxiliary windows, if needed (required for GL) */
/*
if ( vis_change )
create_aux_windows(this);
*/
/* resize the (possibly new) window manager window */
/* Create (or use) the X11 display window */
if ( !SDL_windowid ) {
if ( flags & SDL_OPENGL ) {
return(-1);
}
else
{
if(flags & SDL_FULLSCREEN)
if( flags & SDL_FULLSCREEN )
{
SDL_Window = OpenWindowTags(NULL,WA_Width,w,WA_Height,h,
WA_Flags,WFLG_ACTIVATE|WFLG_RMBTRAP|WFLG_BORDERLESS|WFLG_BACKDROP|WFLG_REPORTMOUSE,
@ -847,27 +814,25 @@ int CGX_CreateWindow(_THIS, SDL_Surface *screen,
WA_CustomScreen,(ULONG)SDL_Display,
TAG_DONE);
D(bug("Apro finestra backdrop %ldx%ld su %lx!\n",w,h,SDL_Display));
D(bug("Opening backdrop window %ldx%ld on display %lx!\n",w,h,SDL_Display));
}
else
{
/* Create GimmeZeroZero window when OpenGL is used */
unsigned long gzz = FALSE;
if( flags & SDL_OPENGL ) {
gzz = TRUE;
}
SDL_Window = OpenWindowTags(NULL,WA_InnerWidth,w,WA_InnerHeight,h,
WA_Flags,WFLG_REPORTMOUSE|WFLG_ACTIVATE|WFLG_RMBTRAP | ((flags&SDL_NOFRAME) ? 0 : (WFLG_DEPTHGADGET|WFLG_CLOSEGADGET|WFLG_DRAGBAR | ((flags&SDL_RESIZABLE) ? WFLG_SIZEGADGET|WFLG_SIZEBBOTTOM : 0))),
WA_IDCMP,IDCMP_RAWKEY|IDCMP_CLOSEWINDOW|IDCMP_MOUSEBUTTONS|IDCMP_NEWSIZE|IDCMP_MOUSEMOVE,
WA_PubScreen,(ULONG)SDL_Display,
WA_GimmeZeroZero, gzz,
TAG_DONE);
D(bug("Apro finestra %ldx%ld sul wb!\n",w,h));
D(bug("Opening WB window of size: %ldx%ld!\n",w,h));
}
}
/* Only manage our input if we own the window */
/*
XSelectInput(SDL_Display, SDL_Window,
( EnterWindowMask | LeaveWindowMask
| ButtonPressMask | ButtonReleaseMask
| PointerMotionMask | ExposureMask ));
*/
if(!SDL_Window)
return -1;
}
@ -885,17 +850,6 @@ int CGX_CreateWindow(_THIS, SDL_Surface *screen,
return -1;
}
else SDL_RastPort=SDL_Window->RPort;
#if 0
if(screen->flags & SDL_HWPALETTE) {
/* Since the full-screen window might have got a nonzero background
colour (0 is white on some displays), we should reset the
background to 0 here since that is what the user expects
with a private colormap */
SetAPen(SDL_Window->RPort,0);
RectFill(SDL_Window->RPort,SDL_Window->BorderLeft,SDL_Window->BorderTop,w+SDL_Window->BorderLeft,h+SDL_Window->BorderTop);
}
#endif
if(flags&SDL_HWSURFACE)
screen->flags|=SDL_HWSURFACE;
@ -928,12 +882,28 @@ int CGX_CreateWindow(_THIS, SDL_Surface *screen,
screen->pitch = SDL_CalculatePitch(screen);
CGX_ResizeImage(this, screen, flags);
return(0);
/* Make OpenGL Context if needed*/
if(flags & SDL_OPENGL) {
if(this->gl_data->gl_active == 0) {
if(CGX_GL_Init(this) < 0)
return -1;
else
screen->flags |= SDL_OPENGL;
}
else {
if(CGX_GL_Update(this) < 0)
return -1;
else
screen->flags |= SDL_OPENGL;
}
}
}
int CGX_ResizeWindow(_THIS,
SDL_Surface *screen, int w, int h, Uint32 flags)
{
D(bug("CGX_ResizeWindow\n"));
if ( ! SDL_windowid ) {
/* Resize the window manager window */
CGX_SetSizeHints(this, w, h, flags);
@ -943,22 +913,6 @@ int CGX_ResizeWindow(_THIS,
ChangeWindowBox(SDL_Window,SDL_Window->LeftEdge,SDL_Window->TopEdge, w+SDL_Window->BorderLeft+SDL_Window->BorderRight,
h+SDL_Window->BorderTop+SDL_Window->BorderBottom);
/* Resize the fullscreen and display windows */
/*
if ( flags & SDL_FULLSCREEN ) {
if ( screen->flags & SDL_FULLSCREEN ) {
CGX_ResizeFullScreen(this);
} else {
screen->flags |= SDL_FULLSCREEN;
CGX_EnterFullScreen(this);
}
} else {
if ( screen->flags & SDL_FULLSCREEN ) {
screen->flags &= ~SDL_FULLSCREEN;
CGX_LeaveFullScreen(this);
}
}
*/
screen->w = w;
screen->h = h;
screen->pitch = SDL_CalculatePitch(screen);
@ -973,23 +927,25 @@ static SDL_Surface *CGX_SetVideoMode(_THIS, SDL_Surface *current,
Uint32 saved_flags;
int needcreate=0;
D(bug("CGX_SetVideoMode current:%lx\n",current));
/* Lock the event thread, in multi-threading environments */
SDL_Lock_EventThread();
// Check if the window needs to be closed or can be resized
if( (flags&SDL_FULLSCREEN) || (current->flags&SDL_FULLSCREEN && !(flags&SDL_FULLSCREEN)))
if( (flags&SDL_FULLSCREEN) || (current && current->flags&SDL_FULLSCREEN && !(flags&SDL_FULLSCREEN)))
needcreate=1;
// Check if we need to close an already existing videomode...
if(current->flags&SDL_FULLSCREEN && !(flags&SDL_FULLSCREEN))
{
if(current && current->flags&SDL_FULLSCREEN && !(flags&SDL_FULLSCREEN)) {
unsigned long i;
D(bug("Destroying image, window & screen!\n"));
CGX_DestroyImage(this,current);
CGX_DestroyWindow(this,current);
DestroyScreen(this);
D(bug("Distrutte immagine, finestra e schermo!\n"));
GFX_Display=SDL_Display=LockPubScreen(NULL);
bpp=this->hidden->depth=GetCyberMapAttr(SDL_Display->RastPort.BitMap,CYBRMATTR_DEPTH);
@ -1004,7 +960,7 @@ static SDL_Surface *CGX_SetVideoMode(_THIS, SDL_Surface *current,
}
SDL_Visual = this->hidden->visuals[i].visual;
D(bug("Setto la profiondita' dello schermo a: %ld\n",this->hidden->depth));
D(bug("Setting screen depth to: %ld\n",this->hidden->depth));
}
/* Check the combination of flags we were passed */
@ -1015,12 +971,12 @@ static SDL_Surface *CGX_SetVideoMode(_THIS, SDL_Surface *current,
if ( SDL_windowid ) {
flags &= ~SDL_FULLSCREEN;
}
else if(current->flags&SDL_FULLSCREEN )
{
else if(current && current->flags&SDL_FULLSCREEN ) {
if(current->w!=width ||
current->h!=height ||
this->hidden->depth!=bpp)
(this->hidden && this->hidden->depth!=bpp))
{
D(bug("Deleting previous window...\n"));
CGX_DestroyImage(this,current);
CGX_DestroyWindow(this,current);
DestroyScreen(this);
@ -1037,8 +993,9 @@ buildnewscreen:
GFX_Display=NULL;
D(bug("Opening screen...\n"));
if(okid!=INVALID_ID)
{
GFX_Display=OpenScreenTags(NULL,
SA_Width,width,
SA_Height,height,
@ -1046,58 +1003,50 @@ buildnewscreen:
SA_Depth,bpp,
SA_DisplayID,okid,
TAG_DONE);
}
if(!GFX_Display)
{
if(!GFX_Display) {
GFX_Display=SDL_Display;
flags &= ~SDL_FULLSCREEN;
flags &= ~SDL_DOUBLEBUF;
}
else
{
else {
UnlockPubScreen(NULL,SDL_Display);
SDL_Display=GFX_Display;
if(flags&SDL_DOUBLEBUF)
{
int ok=0;
D(bug("Screen opened.\n"));
if(this->hidden->SB[0]=AllocScreenBuffer(SDL_Display,NULL,SB_SCREEN_BITMAP))
{
if(this->hidden->SB[1]=AllocScreenBuffer(SDL_Display,NULL,0L))
{
if(flags&SDL_DOUBLEBUF) {
int ok=0;
D(bug("Start of DBuffering allocations...\n"));
if(this->hidden->SB[0]=AllocScreenBuffer(SDL_Display,NULL,SB_SCREEN_BITMAP)) {
if(this->hidden->SB[1]=AllocScreenBuffer(SDL_Display,NULL,0L)) {
extern struct MsgPort *safeport,*dispport;
safeport=CreateMsgPort();
dispport=CreateMsgPort();
if(!safeport || !dispport)
{
if(safeport)
{
if(!safeport || !dispport) {
if(safeport) {
DeleteMsgPort(safeport);
safeport=NULL;
}
if(dispport)
{
if(dispport) {
DeleteMsgPort(dispport);
dispport=NULL;
}
FreeScreenBuffer(SDL_Display,this->hidden->SB[0]);
FreeScreenBuffer(SDL_Display,this->hidden->SB[1]);
}
else
{
else {
extern ULONG safe_sigbit,disp_sigbit;
int i;
safe_sigbit=1L<< safeport->mp_SigBit;
disp_sigbit=1L<< dispport->mp_SigBit;
for(i=0;i<2;i++)
{
for(i=0;i<2;i++) {
this->hidden->SB[i]->sb_DBufInfo->dbi_SafeMessage.mn_ReplyPort=safeport;
this->hidden->SB[i]->sb_DBufInfo->dbi_DispMessage.mn_ReplyPort=dispport;
}
@ -1108,31 +1057,28 @@ buildnewscreen:
current->flags|=SDL_DOUBLEBUF;
}
}
else
{
else {
FreeScreenBuffer(SDL_Display,this->hidden->SB[1]);
this->hidden->SB[0]=NULL;
}
}
if(!ok)
{
flags&=~SDL_DOUBLEBUF;
}
}
}
if(GetCyberMapAttr(SDL_Display->RastPort.BitMap,CYBRMATTR_DEPTH)==bpp)
this->hidden->same_format=1;
}
bpp=this->hidden->depth=GetCyberMapAttr(SDL_Display->RastPort.BitMap,CYBRMATTR_DEPTH);
D(bug("Setto la profiondita' dello schermo a: %ld\n",this->hidden->depth));
D(bug("Setting screen depth to: %ld\n",this->hidden->depth));
for ( i = 0; i < this->hidden->nvisuals; i++ ) {
for ( i = 0; i < this->hidden->nvisuals; i++ )
if ( this->hidden->visuals[i].depth == bpp ) /* era .depth */
break;
}
if ( i == this->hidden->nvisuals ) {
SDL_SetError("No matching visual for requested depth");
return NULL; /* should never happen */
@ -1202,11 +1148,14 @@ static int CGX_ToggleFullScreen(_THIS, int on)
this->screen->flags &= ~SDL_FULLSCREEN;
CGX_LeaveFullScreen(this);
}
CGX_RefreshDisplay(this);
if ( event_thread ) {
SDL_Unlock_EventThread();
}
SDL_ResetKeyboard();
return(1);
}
@ -1274,7 +1223,7 @@ static void SetSingleColor(Uint32 fmt, unsigned char r, unsigned char g, unsigne
break;
default:
D(bug("Errore, SetSingleColor con PIXFMT %ld!\n",fmt));
D(bug("Error, SetSingleColor with PIXFMT %ld!\n",fmt));
}
}
@ -1368,7 +1317,7 @@ static int CGX_SetColors(_THIS, int firstcolor, int ncolors, SDL_Color *colors)
SetSingleColor(fmt,colors[firstcolor+i].r,colors[firstcolor+i].g,colors[firstcolor+i].b,(unsigned char *)&SDL_XPixels[firstcolor+i]);
}
#else
// D(bug("Eseguo remap degli XPixel(%lx): (da %ld, %ld colori) primo: r%ld g%ld b%ld\n",SDL_XPixels,firstcolor,ncolors,colors[firstcolor].r,colors[firstcolor].g,colors[firstcolor].b));
// D(bug("Executing XPixel(%lx) remapping: (from %ld, %ld colors) first: r%ld g%ld b%ld\n",SDL_XPixels,firstcolor,ncolors,colors[firstcolor].r,colors[firstcolor].g,colors[firstcolor].b));
for(i=0;i<ncolors;i++)
SDL_XPixels[i+firstcolor]=(colors[firstcolor+i].r<<16)+(colors[firstcolor+i].g<<8)+colors[firstcolor+i].b;
#endif
@ -1387,32 +1336,23 @@ static void CGX_VideoQuit(_THIS)
{
/* Shutdown everything that's still up */
/* The event thread should be done, so we can touch SDL_Display */
D(bug("CGX_VideoQuit\n"));
if ( SDL_Display != NULL ) {
/* Clean up OpenGL */
if(this->gl_data->gl_active == 1) {
CGX_GL_Quit(this);
}
/* Start shutting down the windows */
D(bug("Destroying image...\n"));
CGX_DestroyImage(this, this->screen);
D(bug("Destroying window...\n"));
CGX_DestroyWindow(this, this->screen);
// Otherwise SDL_VideoQuit will try to free it!
SDL_VideoSurface=NULL;
CGX_FreeVideoModes(this);
/*
if ( SDL_iconcolors ) {
unsigned long pixel;
int numcolors =
((this->screen->format)->palette)->ncolors;
for ( pixel=0; pixel<numcolors; ++pixel ) {
while ( SDL_iconcolors[pixel] > 0 ) {
XFreeColors(SDL_Display,
SDL_DisplayColormap,&pixel,1,0);
--SDL_iconcolors[pixel];
}
}
free(SDL_iconcolors);
SDL_iconcolors = NULL;
}
*/
/* Free that blank cursor */
if ( SDL_BlankCursor != NULL ) {
FreeMem(SDL_BlankCursor,16);
@ -1422,6 +1362,8 @@ static void CGX_VideoQuit(_THIS)
/* Close the X11 graphics connection */
this->hidden->same_format=0;
D(bug("Destroying screen...\n"));
if ( GFX_Display != NULL )
DestroyScreen(this);
@ -1431,19 +1373,18 @@ static void CGX_VideoQuit(_THIS)
/* Unload GL library after X11 shuts down */
}
if( CyberGfxBase)
{
D(bug("Closing libraries...\n"));
if( CyberGfxBase) {
CloseLibrary(CyberGfxBase);
CyberGfxBase=NULL;
}
if (IntuitionBase)
{
if (IntuitionBase) {
CloseLibrary((struct Library *)IntuitionBase);
IntuitionBase=NULL;
}
if (GfxBase)
{
if (GfxBase) {
CloseLibrary((struct Library *)GfxBase);
GfxBase=NULL;
}
@ -1452,5 +1393,7 @@ static void CGX_VideoQuit(_THIS)
/* Direct screen access, no memory buffer */
this->screen->pixels = NULL;
}
D(bug("End of CGX_VideoQuit.\n"));
}

3
src/video/cybergfx/SDL_cgxvideo.h
View file

@ -38,7 +38,7 @@ static char rcsid =
#include <graphics/scale.h>
#include <graphics/gfx.h>
#include <intuition/intuition.h>
#ifdef __SASC
#if defined(__SASC) || defined(STORMC4_WOS)
#include <proto/exec.h>
#include <proto/cybergraphics.h>
#include <proto/graphics.h>
@ -177,6 +177,7 @@ struct private_hwdata
APTR lock;
struct SDL_VideoDevice *videodata;
APTR mask;
int allocated;
};
int CGX_CheckHWBlit(_THIS,SDL_Surface *src,SDL_Surface *dst);