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;

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

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

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

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*/

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

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

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

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

436
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;
}
/* 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;
else {
attributes[i++].ti_Data = GL_FALSE;
}
/* 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;
// 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;
}
if( this->gl_config.buffer_size ) {
attribs[i++] = GLX_BUFFER_SIZE;
attribs[i++] = this->gl_config.buffer_size;
else {
attributes[i++].ti_Data = GL_FALSE;
}
if( this->gl_config.double_buffer ) {
attribs[i++] = GLX_DOUBLEBUFFER;
// no depth buffer ?
if ( this->gl_config.depth_size == 0 ) {
attributes[i].ti_Tag = AMA_NoDepth;
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 stencil buffer ?
if ( this->gl_config.stencil_size == 0 ) {
attributes[i].ti_Tag = AMA_NoStencil;
attributes[i++].ti_Data = GL_TRUE;
}
if( this->gl_config.accum_red_size ) {
attribs[i++] = GLX_ACCUM_RED_SIZE;
attribs[i++] = this->gl_config.accum_red_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_green_size ) {
attribs[i++] = GLX_ACCUM_GREEN_SIZE;
attribs[i++] = this->gl_config.accum_green_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_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;
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;
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");
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;
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;
}
/* 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;
handle = this->gl_config.dll_handle;
void *CGX_GL_GetProcAddress(_THIS, const char *proc) {
void *func = NULL;
func = AmiGetGLProc(proc);
return func;
}
return dlsym(handle, proc);
int CGX_GL_LoadLibrary(_THIS, const char *path) {
/* Library is always open */
this->gl_config.driver_loaded = 1;
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

84
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;
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;
}

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

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

File diff suppressed because it is too large Load diff

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