Updated Amiga port by Gabriele Greco

--HG--
extra : convert_revision : svn%3Ac70aab31-4412-0410-b14c-859654838e24/trunk%40256

src/audio/amigaos/SDL_ahiaudio.c

@@ -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"

src/audio/amigaos/SDL_ahiaudio.h

@@ -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;

src/joystick/amigaos/SDL_sysjoystick.c

@@ -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>
@@ -72,7 +72,7 @@ ULONG joybut[]=
 	JPF_BUTTON_REVERSE,
 };
 
-struct joystick_hwdata 
+struct joystick_hwdata
 {
 	ULONG joystate;
 };
@@ -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();
 	}
 
@@ -152,7 +152,7 @@ int SDL_SYS_JoystickOpen(SDL_Joystick *joystick)
  */
 void SDL_SYS_JoystickUpdate(SDL_Joystick *joystick)
 {
-	ULONG data;	
+	ULONG data;
 	int i;
 
 	if(joystick->index<2)

src/thread/amigaos/SDL_syssem.c

@@ -61,7 +61,7 @@ SDL_sem *SDL_CreateSemaphore(Uint32 initial_value)
 	memset(sem,0,sizeof(*sem));
 
 	InitSemaphore(&sem->Sem);
-	
+
 	return(sem);
 }
 
@@ -143,10 +143,14 @@ int SDL_SemWait(SDL_sem *sem)
 Uint32 SDL_SemValue(SDL_sem *sem)
 {
 	Uint32 value;
-	
+
 	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;

src/thread/amigaos/SDL_systhread.c

@@ -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");

src/thread/amigaos/SDL_systhread_c.h

@@ -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;
 
+#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*/
 

src/timer/amigaos/SDL_systimer.c

@@ -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)
@@ -120,7 +124,7 @@ void SDL_StartTicks(void)
 	/* Set first ticks value */
 	if(!MyTimer)
 		PPC_TimerInit();
-	
+
 	PPCGetTimerObject(MyTimer,PPCTIMERTAG_CURRENTTICKS,start);
 	start[1]>>=10;
 	start[1]|=((result[0]&0x3ff)<<22);
@@ -134,7 +138,7 @@ Uint32 SDL_GetTicks (void)
 
 //	PPCAsr64p(result,10);
 // Non va, la emulo:
-	
+
 	result[1]>>=10;
 	result[1]|=((result[0]&0x3ff)<<22);
 
@@ -200,7 +204,7 @@ void PPC_TimerInit(void)
 	else
 	{
 		D(bug("Errore nell'inizializzazione del timer!\n"));
-	}	
+	}
 }
 
 #endif
@@ -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);

src/video/cybergfx/SDL_amigaevents.c

@@ -148,7 +148,7 @@ static int amiga_DispatchEvent(_THIS,struct IntuiMessage *msg)
 			break;
 #if 0
 	    /* Gaining input focus? */
-	    case IDCMP_ACTIVEWINDOW: 
+	    case IDCMP_ACTIVEWINDOW:
 			posted = SDL_PrivateAppActive(1, SDL_APPINPUTFOCUS);
 
 			/* Queue entry into fullscreen mode */
@@ -166,7 +166,7 @@ static int amiga_DispatchEvent(_THIS,struct IntuiMessage *msg)
 		    break;
 #endif
 	    /* Mouse motion? */
-	    case IDCMP_MOUSEMOVE: 
+	    case IDCMP_MOUSEMOVE:
 			if ( SDL_VideoSurface ) {
 				posted = SDL_PrivateMouseMotion(0, 0,
 						msg->MouseX-SDL_Window->BorderLeft,
@@ -179,14 +179,14 @@ static int amiga_DispatchEvent(_THIS,struct IntuiMessage *msg)
 
 			if(!(code&IECODE_UP_PREFIX))
 			{
-				posted = SDL_PrivateMouseButton(SDL_PRESSED, 
+				posted = SDL_PrivateMouseButton(SDL_PRESSED,
 						amiga_GetButton(code), 0, 0);
 			    }
 	    /* Mouse button release? */
 			else
 			{
 				code&=~IECODE_UP_PREFIX;
-				posted = SDL_PrivateMouseButton(SDL_RELEASED, 
+				posted = SDL_PrivateMouseButton(SDL_RELEASED,
 						amiga_GetButton(code), 0, 0);
 			}
 			break;
@@ -211,7 +211,7 @@ static int amiga_DispatchEvent(_THIS,struct IntuiMessage *msg)
 			/* Check to see if this is a repeated key */
 /*			if ( ! X11_KeyRepeat(SDL_Display, &xevent) )  */
 
-				posted = SDL_PrivateKeyboard(SDL_RELEASED, 
+				posted = SDL_PrivateKeyboard(SDL_RELEASED,
 					amiga_TranslateKey(code, &keysym));
 		    }
 		    break;
@@ -235,7 +235,7 @@ printf("MapNotify!\n");
 		posted = SDL_PrivateAppActive(1, SDL_APPACTIVE);
 
 		if ( SDL_VideoSurface &&
-		     (SDL_VideoSurface->flags & SDL_FULLSCREEN) ) 
+		     (SDL_VideoSurface->flags & SDL_FULLSCREEN) )
 		{
 			CGX_EnterFullScreen(this);
 		} else {
@@ -254,9 +254,10 @@ printf("MapNotify!\n");
 #endif
 
 	    /* Have we been resized? */
-	    case IDCMP_NEWSIZE: 
+	    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;
@@ -438,10 +443,17 @@ SDL_keysym *amiga_TranslateKey(int code, SDL_keysym *keysym)
 	fprintf(stderr, "Translating key 0x%.4x (%d)\n", xsym, xkey->keycode);
 #endif
 	/* Get the translated SDL virtual keysym */
-	if ( keysym->sym==SDLK_UNKNOWN ) 
+	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)
 				{

src/video/cybergfx/SDL_cgxaccel.c

+/*
+    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)
@@ -18,10 +45,10 @@ static int CGX_HWAccelBlit(SDL_Surface *src, SDL_Rect *srcrect,
 void BMKBRP(struct BitMap *a,WORD b, WORD c,struct RastPort *d,WORD e,WORD f,WORD g,WORD h,UBYTE i,APTR j)
 {BltMaskBitMapRastPort(a,b,c,d,e,f,g,h,i,j);}
 
-void BBRP(struct BitMap *a,WORD b, WORD c,struct RastPort *d,WORD e,WORD f,WORD g,WORD h,UBYTE i) 
+void BBRP(struct BitMap *a,WORD b, WORD c,struct RastPort *d,WORD e,WORD f,WORD g,WORD h,UBYTE i)
 {BltBitMapRastPort(a,b,c,d,e,f,g,h,i);}
 
-void BBB(struct BitMap *a,WORD b, WORD c,struct BitMap *d,WORD e,WORD f,WORD g,WORD h,UBYTE i,UBYTE j,UWORD *k) 
+void BBB(struct BitMap *a,WORD b, WORD c,struct BitMap *d,WORD e,WORD f,WORD g,WORD h,UBYTE i,UBYTE j,UWORD *k)
 {BltBitMap(a,b,c,d,e,f,g,h,i,j,k);}
 #endif
 
@@ -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;
 			}
 		}

src/video/cybergfx/SDL_cgxgl.c

@@ -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;
-
-	/* 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;
-		}
-	}
-
-	/* 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;
-	}
-
-        /* 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;
-	}
-
-	if( this->gl_config.buffer_size ) {
-                attribs[i++] = GLX_BUFFER_SIZE;
-	        attribs[i++] = this->gl_config.buffer_size;
-	}
-
-	if( this->gl_config.double_buffer ) {
-		attribs[i++] = GLX_DOUBLEBUFFER;
-	}
-
-	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;
-	}
-
-	if( this->gl_config.accum_red_size ) {
-	        attribs[i++] = GLX_ACCUM_RED_SIZE;
-		attribs[i++] = this->gl_config.accum_red_size;
-	}
-
-	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;
+   int i = 0;
+	struct TagItem attributes [ 14 ]; /* 14 should be more than enough :) */
+   struct Window *win = (struct Window *)SDL_Window;
+
+	// 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;
+	}
+	// 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;
+	}
+	else {
+		attributes[i++].ti_Data = GL_FALSE;
+	}
+	// no depth buffer ?
+	if ( this->gl_config.depth_size == 0 ) {
+		attributes[i].ti_Tag = AMA_NoDepth;
+		attributes[i++].ti_Data = GL_TRUE;
+	}
+	// no stencil buffer ?
+	if ( this->gl_config.stencil_size == 0 ) {
+		attributes[i].ti_Tag = AMA_NoStencil;
+		attributes[i++].ti_Data = GL_TRUE;
+	}
+	// 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;
+
+	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;
 
-	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;
-
-	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;
-
-	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 -1;
+	if ( glcont != NULL ) {
+		AmigaMesaDestroyContext(glcont);
+		glcont = NULL;
+		this->gl_data->gl_active = 0;
+		this->gl_config.driver_loaded = 0;
 	}
-	retval = 0;
-#else
-	SDL_SetError("CGX driver is not yet supporting OpenGL");
-	retval = -1;
 #endif
-	return(retval);
 }
 
-int CGX_GL_CreateContext(_THIS)
+/* Attach context to another window */
+int CGX_GL_Update(_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;
+	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);
 
-	gl_active = 1;
+	return 0;
 #else
-	SDL_SetError("CGX driver is not yet supporting OpenGL");
+	SDL_SetError("OpenGL support not configured");
+	return -1;
 #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;
-
-	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);
+	if(glcont == NULL)
+		return -1;
 
-	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 */
-
-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
+int CGX_GL_GetAttribute(_THIS, SDL_GLattr attrib, int* value) {
+	GLenum mesa_attrib;
+
+	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;
+	}
+
+	AmigaMesaGetConfig(glcont->visual, mesa_attrib, value);
+	return 0;
 }
 
-#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");
- 		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, "");
-	}
-	return 0;
+void *CGX_GL_GetProcAddress(_THIS, const char *proc) {
+	void *func = NULL;
+	func = AmiGetGLProc(proc);
+	return func;
 }
 
-void *CGX_GL_GetProcAddress(_THIS, const char* proc)
-{
-	void* handle;
-	
-	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 */
+

src/video/cybergfx/SDL_cgxgl_c.h

@@ -25,74 +25,30 @@ static char rcsid =
  "@(#) $Id$";
 #endif
 
-#include <stdio.h>
+/* StormMesa implementation of SDL OpenGL support */
 
-#ifdef HAVE_OPENGL
-#include <GL/glx.h>
-#include <dlfcn.h>
-#endif
 #include "SDL_sysvideo.h"
-
-struct SDL_PrivateGLData {
-    int gl_active; /* to stop switching drivers while we have a valid context */
+#define _THIS   SDL_VideoDevice *_this
 
 #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 );
-
+#include <GL/Amigamesa.h>
+extern void *AmiGetGLProc(const char *proc);
 #endif /* HAVE_OPENGL */
-};
 
-/* 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)
+struct SDL_PrivateGLData {
+	int gl_active;
+};
 
 /* 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

src/video/cybergfx/SDL_cgximage.c

@@ -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;
+	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,21 +138,16 @@ 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);
 
-    if ( flags & SDL_OPENGL ) {  /* No image when using GL */
+	if ( flags & SDL_OPENGL ) {  /* No image when using GL */
         	retval = 0;
-    } else {
+	} else {
 		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;
 	}

src/video/cybergfx/SDL_cgxmodes.c

 /*
     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)
@@ -144,11 +145,11 @@ int CGX_GetVideoModes(_THIS)
 						SDL_modelist = (SDL_Rect **)realloc(SDL_modelist,(nmodes+1)*sizeof(SDL_Rect *));
 						SDL_modelist[nmodes]=NULL;
 
-						if ( SDL_modelist ) 
+						if ( SDL_modelist )
 						{
 							SDL_modelist[nmodes-1] = (SDL_Rect *)malloc(sizeof(SDL_Rect));
 
-							if ( SDL_modelist[nmodes-1] == NULL ) 
+							if ( SDL_modelist[nmodes-1] == NULL )
 								break;
 
 							SDL_modelist[nmodes-1]->x = 0;
@@ -156,7 +157,7 @@ int CGX_GetVideoModes(_THIS)
 							SDL_modelist[nmodes-1]->w = info.Nominal.MaxX+1;
 							SDL_modelist[nmodes-1]->h = info.Nominal.MaxY+1;
 						}
-					}																	
+					}
 				}
 			}
 		}
@@ -267,15 +268,18 @@ void _QueueEnterFullScreen(_THIS)
 int CGX_EnterFullScreen(_THIS)
 {
     int okay;
+	 Uint32 saved_flags;
 
     okay = 1;
-    if ( ! currently_fullscreen ) 
+    saved_flags = this->screen->flags;
+
+    if ( ! currently_fullscreen )
 	{
         int real_w, real_h;
 
         /* Map the fullscreen window to blank the screen */
         get_real_resolution(this, &real_w, &real_h);
-		
+
 		CGX_DestroyWindow(this,this->screen);
 		set_best_resolution(this, real_w,real_h);
 
@@ -297,8 +301,9 @@ 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);
+		  CGX_CreateWindow(this,this->screen,real_w,real_h,GetCyberMapAttr(SDL_Display->RastPort.BitMap,CYBRMATTR_DEPTH),this->screen->flags);
 
         /* Set the new resolution */
         okay = CGX_ResizeFullScreen(this);
@@ -311,7 +316,7 @@ int CGX_EnterFullScreen(_THIS)
 			XInstallColormap(SDL_Display, SDL_XColorMap);
 		}
 */
-    }    
+    }
 //    CGX_GrabInputNoLock(this, this->input_grab | SDL_GRAB_FULLSCREEN);
     return(okay);
 }

src/video/cybergfx/SDL_cgxvideo.c

 /*
     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;
-			free(SDL_RastPort);
+
+			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,17 +242,21 @@ 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;
 	device->IconifyWindow = NULL; /* CGX_IconifyWindow; */
-	device->GrabInput = NULL /* CGX_GrabInput*/; 
+	device->GrabInput = NULL /* CGX_GrabInput*/;
 	device->GetWMInfo = CGX_GetWMInfo;
 	device->FreeWMCursor = amiga_FreeWMCursor;
 	device->CreateWMCursor = amiga_CreateWMCursor;
@@ -217,119 +275,13 @@ 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: "));
 
 	if(this->hidden->depth==*bpp)
 	{
-		
+
 	switch(format)
     	{
 		case PIXFMT_LUT8:
@@ -447,7 +399,7 @@ Uint32 MakeBitMask(_THIS,int type,int format,int *bpp)
 	else
 	{
 		D(if(type==0)bug("DIFFERENT from screen.\nAllocated screen format: "));
-	
+
 		switch(*bpp)
 		{
 			case 32:
@@ -479,43 +431,63 @@ use_truecolor:
 				D(if(type==0) bug("Not supported, switching to 24bit!\n"));
 				*bpp=24;
 				goto use_truecolor;
-				break;				
+				break;
 			default:
 				D(if(type==0)bug("This is a chunky display\n"));
 // For chunky display mask is always 0;
 				return 0;
 		}
-	} 
+	}
 	return 0;
 }
 
 static int CGX_VideoInit(_THIS, SDL_PixelFormat *vformat)
 {
 	int i;
+	struct Library *RTGBase;
 
-	if(!(IntuitionBase=(struct IntuitionBase *)OpenLibrary("intuition.library",39L)))
-	{
-		SDL_SetError("Couldn't open intuition V39+");
-		return -1;
+	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)))
-	{
-		SDL_SetError("Couldn't open graphics V39+");
-		return -1;
+
+	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)))
-	{
-		SDL_SetError("Couldn't open cybergraphics.");
-		return(-1);
+
+	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;
@@ -556,9 +530,11 @@ static int CGX_VideoInit(_THIS, SDL_PixelFormat *vformat)
 // Non e' detto che sia cosi' pero', alcune schede potrebbero gestire i modi in modo differente
 
 	if ( SDL_BYTEORDER == SDL_LIL_ENDIAN ) {
-			swap_pixels = 1;
+		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,16 +563,21 @@ 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);
 
 // In this case I use makebitmask in a way that I'm sure I'll get PIXFMT pixel mask
 
-		if ( vformat->BitsPerPixel > 8 ) 
+		if ( vformat->BitsPerPixel > 8 )
 		{
 			vformat->Rmask = MakeBitMask(this,0,form,&this->hidden->depth);
 	  		vformat->Gmask = MakeBitMask(this,1,form,&this->hidden->depth);
@@ -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,16 +603,25 @@ 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;
 
-		if ( screen && (screen->flags & SDL_FULLSCREEN) ) {	
+		/* Clean up OpenGL */
+		if ( screen ) {
+		screen->flags &= ~(SDL_OPENGL|SDL_OPENGLBLIT);
+		}
+
+		if ( screen && (screen->flags & SDL_FULLSCREEN) ) {
 			was_fullscreen=1;
 			screen->flags &= ~SDL_FULLSCREEN;
 //			CGX_LeaveFullScreen(this); tolto x crash
@@ -660,7 +647,7 @@ void CGX_DestroyWindow(_THIS, SDL_Surface *screen)
 
 				if(!was_fullscreen&&this->hidden->depth==8)
 				{
-					for ( pixel=0; pixel<numcolors; pixel++ ) 
+					for ( pixel=0; pixel<numcolors; pixel++ )
 					{
 						if(SDL_XPixels[pixel]>=0)
 							ReleasePen(GFX_Display->ViewPort.ColorMap,SDL_XPixels[pixel]);
@@ -669,7 +656,7 @@ void CGX_DestroyWindow(_THIS, SDL_Surface *screen)
 			}
 			free(SDL_XPixels);
 			SDL_XPixels = NULL;
-		} 
+		}
 	}
 }
 
@@ -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 */
@@ -766,7 +755,7 @@ int CGX_CreateWindow(_THIS, SDL_Surface *screen,
 
 /* With this call if needed I'll revert the wanted bpp to a bpp best suited for the display, actually occurs
    only with requested format 15/16bit and display format != 15/16bit
- */	
+ */
 
 		if ( ! SDL_ReallocFormat(screen, bpp,
 				MakeBitMask(this,0,form,&bpp), MakeBitMask(this,1,form,&bpp), MakeBitMask(this,2,form,&bpp), 0) )
@@ -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 */
 
@@ -794,52 +783,30 @@ int CGX_CreateWindow(_THIS, SDL_Surface *screen,
 		ncolors = 1 << screen->format->BitsPerPixel;
 
 	    SDL_XPixels = (Sint32 *)malloc(ncolors * sizeof(Sint32));
-		
+
 	    if(SDL_XPixels == NULL) {
 		SDL_OutOfMemory();
 		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... 
+// 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,23 +960,23 @@ 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 */
 	if ( flags & SDL_FULLSCREEN ) {
 		int i;
-	
+
 		/* Clear fullscreen flag if not supported */
 		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;
+	
+				D(bug("Screen opened.\n"));
 
-				if(flags&SDL_DOUBLEBUF)
-				{
+				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))
-						{
+					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;				
+				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));
 	}
 }
 
@@ -1292,11 +1241,11 @@ static void CGX_UpdateMouse(_THIS)
 	else
 	{
 		if(	SDL_Display->MouseX>=(SDL_Window->LeftEdge+SDL_Window->BorderLeft) && SDL_Display->MouseX<(SDL_Window->LeftEdge+SDL_Window->Width-SDL_Window->BorderRight) &&
-			SDL_Display->MouseY>=(SDL_Window->TopEdge+SDL_Window->BorderLeft) && SDL_Display->MouseY<(SDL_Window->TopEdge+SDL_Window->Height-SDL_Window->BorderBottom) 
+			SDL_Display->MouseY>=(SDL_Window->TopEdge+SDL_Window->BorderLeft) && SDL_Display->MouseY<(SDL_Window->TopEdge+SDL_Window->Height-SDL_Window->BorderBottom)
 			)
 		{
 			SDL_PrivateAppActive(1, SDL_APPMOUSEFOCUS);
-			SDL_PrivateMouseMotion(0, 0, SDL_Display->MouseX-SDL_Window->LeftEdge-SDL_Window->BorderLeft, 
+			SDL_PrivateMouseMotion(0, 0, SDL_Display->MouseX-SDL_Window->LeftEdge-SDL_Window->BorderLeft,
 										SDL_Display->MouseY-SDL_Window->TopEdge-SDL_Window->BorderTop);
 		}
 		else
@@ -1314,7 +1263,7 @@ static int CGX_SetColors(_THIS, int firstcolor, int ncolors, SDL_Color *colors)
 	/* Check to make sure we have a colormap allocated */
 
 	/* It's easy if we have a hidden colormap */
-	if ( (this->screen->flags & SDL_HWPALETTE) && currently_fullscreen ) 
+	if ( (this->screen->flags & SDL_HWPALETTE) && currently_fullscreen )
 	{
 		ULONG  xcmap[256*3+2];
 
@@ -1343,7 +1292,7 @@ static int CGX_SetColors(_THIS, int firstcolor, int ncolors, SDL_Color *colors)
 		{
 // In this case I have to unalloc and realloc the full palette
 			D(bug("Obtaining %ld colors on the screen\n",ncolors));
-	
+
 		/* Free existing allocated colors */
 			for ( pixel=0; pixel<this->screen->format->palette->ncolors; ++pixel ) {
 				if(SDL_XPixels[pixel]>=0)
@@ -1356,7 +1305,7 @@ static int CGX_SetColors(_THIS, int firstcolor, int ncolors, SDL_Color *colors)
 			}
 		}
 		else
-		{			
+		{
 #ifndef USE_CGX_WRITELUTPIXEL
 			Uint32 fmt;
 			D(bug("Preparing a conversion pixel table...\n"));
@@ -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"));
+
 }
 

src/video/cybergfx/SDL_cgxvideo.h

@@ -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);