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) */ /* Allow access to a raw mixing buffer (for AmigaOS) */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "SDL_endian.h" #include "SDL_endian.h"
#include "SDL_audio.h" #include "SDL_audio.h"
#include "SDL_audiomem.h" #include "SDL_audiomem.h"

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

@ -35,6 +35,8 @@ static char rcsid =
#else #else
#include <inline/exec.h> #include <inline/exec.h>
#endif #endif
#include <stdlib.h>
#include <string.h>
#include <devices/ahi.h> #include <devices/ahi.h>
#include "mydebug.h" #include "mydebug.h"
@ -47,7 +49,7 @@ struct SDL_PrivateAudioData {
/* The handle for the audio device */ /* The handle for the audio device */
struct AHIRequest *audio_req[2]; struct AHIRequest *audio_req[2];
struct MsgPort *audio_port; struct MsgPort *audio_port;
Sint32 freq,type,bytespersample; Sint32 freq,type,bytespersample,size;
Uint8 *mixbuf[2]; /* The app mixing buffer */ Uint8 *mixbuf[2]; /* The app mixing buffer */
int current_buffer; int current_buffer;
Uint32 playing; 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 <stdio.h> /* For the definition of NULL */
#include <libraries/lowlevel.h> #include <libraries/lowlevel.h>
#ifdef __SASC #if defined(__SASC) || defined(STORMC4_WOS)
#include <proto/exec.h> #include <proto/exec.h>
#include <proto/lowlevel.h> #include <proto/lowlevel.h>
#include <proto/graphics.h> #include <proto/graphics.h>
@ -72,7 +72,7 @@ ULONG joybut[]=
JPF_BUTTON_REVERSE, JPF_BUTTON_REVERSE,
}; };
struct joystick_hwdata struct joystick_hwdata
{ {
ULONG joystate; ULONG joystate;
}; };
@ -128,7 +128,7 @@ int SDL_SYS_JoystickOpen(SDL_Joystick *joystick)
for(i=0;i<20;i++) for(i=0;i<20;i++)
{ {
temp=ReadJoyPort(joystick->index); temp=ReadJoyPort(joystick->index^1); // fix to invert amiga joyports
WaitTOF(); WaitTOF();
} }
@ -152,7 +152,7 @@ int SDL_SYS_JoystickOpen(SDL_Joystick *joystick)
*/ */
void SDL_SYS_JoystickUpdate(SDL_Joystick *joystick) void SDL_SYS_JoystickUpdate(SDL_Joystick *joystick)
{ {
ULONG data; ULONG data;
int i; int i;
if(joystick->index<2) 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)); memset(sem,0,sizeof(*sem));
InitSemaphore(&sem->Sem); InitSemaphore(&sem->Sem);
return(sem); return(sem);
} }
@ -143,10 +143,14 @@ int SDL_SemWait(SDL_sem *sem)
Uint32 SDL_SemValue(SDL_sem *sem) Uint32 SDL_SemValue(SDL_sem *sem)
{ {
Uint32 value; Uint32 value;
value = 0; value = 0;
if ( sem ) { if ( sem ) {
#ifdef STORMC4_WOS
value = sem->Sem.ssppc_SS.ss_NestCount;
#else
value = sem->Sem.ss_NestCount; value = sem->Sem.ss_NestCount;
#endif
// SDL_UnlockMutex(sem->count_lock); // SDL_UnlockMutex(sem->count_lock);
} }
return value; 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.h"
#include "SDL_thread_c.h" #include "SDL_thread_c.h"
#include "SDL_systhread.h" #include "SDL_systhread.h"
#include "mydebug.h"
typedef struct { typedef struct {
int (*func)(void *); int (*func)(void *);
@ -47,10 +48,15 @@ __saveds __asm Uint32 RunThread(register __a0 char *args )
#elif defined(__PPC__) #elif defined(__PPC__)
Uint32 RunThread(char *args) Uint32 RunThread(char *args)
#else #else
Uint32 RunThread(char *args __asm("a0") ) Uint32 __saveds RunThread(char *args __asm("a0") )
#endif #endif
{ {
#ifdef STORMC4_WOS
thread_args *data=(thread_args *)args;
#else
thread_args *data=(thread_args *)atol(args); thread_args *data=(thread_args *)atol(args);
#endif
struct Task *Father; struct Task *Father;
D(bug("Received data: %lx\n",data)); D(bug("Received data: %lx\n",data));
@ -59,6 +65,7 @@ Uint32 RunThread(char *args __asm("a0") )
SDL_RunThread(data); SDL_RunThread(data);
Signal(Father,SIGBREAKF_CTRL_F); Signal(Father,SIGBREAKF_CTRL_F);
D(bug("Thread with data %lx ended\n",data));
return(0); return(0);
} }
@ -68,7 +75,7 @@ Uint32 RunThread(char *args __asm("a0") )
Uint32 RunTheThread(void) Uint32 RunTheThread(void)
{ {
thread_args *data=(thread_args *)atol(REG_A0); thread_args *data=(thread_args *)atol((char *)REG_A0);
struct Task *Father; struct Task *Father;
D(bug("Received data: %lx\n",data)); D(bug("Received data: %lx\n",data));
@ -77,16 +84,18 @@ Uint32 RunTheThread(void)
SDL_RunThread(data); SDL_RunThread(data);
Signal(Father,SIGBREAKF_CTRL_F); Signal(Father,SIGBREAKF_CTRL_F);
D(bug("Thread with data %lx ended\n",data));
return(0); return(0);
} }
struct EmulLibEntry RunThread= struct EmulLibEntry RunThreadStruct=
{ {
TRAP_LIB, TRAP_LIB,
0, 0,
RunTheThread (ULONG)RunTheThread
}; };
void *RunThread=&RunThreadStruct;
#endif #endif
@ -100,7 +109,14 @@ int SDL_SYS_CreateThread(SDL_Thread *thread, void *args)
if(args) if(args)
sprintf(buffer,"%ld",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(), thread->handle=(struct Task *)CreateNewProcTags(NP_Output,Output(),
NP_Name,(ULONG)"SDL subtask", NP_Name,(ULONG)"SDL subtask",
NP_CloseOutput, FALSE, NP_CloseOutput, FALSE,
@ -108,6 +124,8 @@ int SDL_SYS_CreateThread(SDL_Thread *thread, void *args)
NP_Entry,(ULONG)RunThread, NP_Entry,(ULONG)RunThread,
args ? NP_Arguments : TAG_IGNORE,(ULONG)buffer, args ? NP_Arguments : TAG_IGNORE,(ULONG)buffer,
TAG_DONE); TAG_DONE);
#endif
if(!thread->handle) if(!thread->handle)
{ {
SDL_SetError("Not enough resources to create thread"); 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 <exec/exec.h>
#include <dos/dos.h> #include <dos/dos.h>
#include <dos/dostags.h> #include <dos/dostags.h>
#ifdef __SASC #if defined (__SASC) || defined(STORMC4_WOS)
#include <proto/dos.h> #include <proto/dos.h>
#include <proto/exec.h> #include <proto/exec.h>
#else #else
@ -44,5 +44,25 @@ static char rcsid =
extern struct ExecBase *SysBase; extern struct ExecBase *SysBase;
extern struct DosLibrary *DOSBase; 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 <pragmas/graphics.h>
#include <clib/exec_protos.h> #include <clib/exec_protos.h>
#include <pragmas/exec.h> #include <pragmas/exec.h>
#elif defined(STORMC4_WOS)
#include <proto/dos.h>
#include <proto/exec.h>
#include <proto/graphics.h>
#else #else
#include <inline/dos.h> #include <inline/dos.h>
#include <inline/exec.h> #include <inline/exec.h>
@ -59,7 +63,7 @@ static struct GfxBase *GfxBase;
/* The first ticks value of the application */ /* The first ticks value of the application */
#ifndef __PPC__ #if !defined(__PPC__) || defined(STORMC4_WOS) || defined(MORPHOS)
static clock_t start; static clock_t start;
void SDL_StartTicks(void) void SDL_StartTicks(void)
@ -120,7 +124,7 @@ void SDL_StartTicks(void)
/* Set first ticks value */ /* Set first ticks value */
if(!MyTimer) if(!MyTimer)
PPC_TimerInit(); PPC_TimerInit();
PPCGetTimerObject(MyTimer,PPCTIMERTAG_CURRENTTICKS,start); PPCGetTimerObject(MyTimer,PPCTIMERTAG_CURRENTTICKS,start);
start[1]>>=10; start[1]>>=10;
start[1]|=((result[0]&0x3ff)<<22); start[1]|=((result[0]&0x3ff)<<22);
@ -134,7 +138,7 @@ Uint32 SDL_GetTicks (void)
// PPCAsr64p(result,10); // PPCAsr64p(result,10);
// Non va, la emulo: // Non va, la emulo:
result[1]>>=10; result[1]>>=10;
result[1]|=((result[0]&0x3ff)<<22); result[1]|=((result[0]&0x3ff)<<22);
@ -200,7 +204,7 @@ void PPC_TimerInit(void)
else else
{ {
D(bug("Errore nell'inizializzazione del timer!\n")); D(bug("Errore nell'inizializzazione del timer!\n"));
} }
} }
#endif #endif
@ -234,7 +238,7 @@ static int RunTimer(void *unused)
/* This is only called if the event thread is not running */ /* This is only called if the event thread is not running */
int SDL_SYS_TimerInit(void) 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_alive = 1;
timer_thread = SDL_CreateThread(RunTimer, NULL); 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; break;
#if 0 #if 0
/* Gaining input focus? */ /* Gaining input focus? */
case IDCMP_ACTIVEWINDOW: case IDCMP_ACTIVEWINDOW:
posted = SDL_PrivateAppActive(1, SDL_APPINPUTFOCUS); posted = SDL_PrivateAppActive(1, SDL_APPINPUTFOCUS);
/* Queue entry into fullscreen mode */ /* Queue entry into fullscreen mode */
@ -166,7 +166,7 @@ static int amiga_DispatchEvent(_THIS,struct IntuiMessage *msg)
break; break;
#endif #endif
/* Mouse motion? */ /* Mouse motion? */
case IDCMP_MOUSEMOVE: case IDCMP_MOUSEMOVE:
if ( SDL_VideoSurface ) { if ( SDL_VideoSurface ) {
posted = SDL_PrivateMouseMotion(0, 0, posted = SDL_PrivateMouseMotion(0, 0,
msg->MouseX-SDL_Window->BorderLeft, msg->MouseX-SDL_Window->BorderLeft,
@ -179,14 +179,14 @@ static int amiga_DispatchEvent(_THIS,struct IntuiMessage *msg)
if(!(code&IECODE_UP_PREFIX)) if(!(code&IECODE_UP_PREFIX))
{ {
posted = SDL_PrivateMouseButton(SDL_PRESSED, posted = SDL_PrivateMouseButton(SDL_PRESSED,
amiga_GetButton(code), 0, 0); amiga_GetButton(code), 0, 0);
} }
/* Mouse button release? */ /* Mouse button release? */
else else
{ {
code&=~IECODE_UP_PREFIX; code&=~IECODE_UP_PREFIX;
posted = SDL_PrivateMouseButton(SDL_RELEASED, posted = SDL_PrivateMouseButton(SDL_RELEASED,
amiga_GetButton(code), 0, 0); amiga_GetButton(code), 0, 0);
} }
break; break;
@ -211,7 +211,7 @@ static int amiga_DispatchEvent(_THIS,struct IntuiMessage *msg)
/* Check to see if this is a repeated key */ /* Check to see if this is a repeated key */
/* if ( ! X11_KeyRepeat(SDL_Display, &xevent) ) */ /* if ( ! X11_KeyRepeat(SDL_Display, &xevent) ) */
posted = SDL_PrivateKeyboard(SDL_RELEASED, posted = SDL_PrivateKeyboard(SDL_RELEASED,
amiga_TranslateKey(code, &keysym)); amiga_TranslateKey(code, &keysym));
} }
break; break;
@ -235,7 +235,7 @@ printf("MapNotify!\n");
posted = SDL_PrivateAppActive(1, SDL_APPACTIVE); posted = SDL_PrivateAppActive(1, SDL_APPACTIVE);
if ( SDL_VideoSurface && if ( SDL_VideoSurface &&
(SDL_VideoSurface->flags & SDL_FULLSCREEN) ) (SDL_VideoSurface->flags & SDL_FULLSCREEN) )
{ {
CGX_EnterFullScreen(this); CGX_EnterFullScreen(this);
} else { } else {
@ -254,9 +254,10 @@ printf("MapNotify!\n");
#endif #endif
/* Have we been resized? */ /* Have we been resized? */
case IDCMP_NEWSIZE: case IDCMP_NEWSIZE:
SDL_PrivateResize(SDL_Window->Width-SDL_Window->BorderLeft-SDL_Window->BorderRight, SDL_PrivateResize(SDL_Window->Width-SDL_Window->BorderLeft-SDL_Window->BorderRight,
SDL_Window->Height-SDL_Window->BorderTop-SDL_Window->BorderBottom); SDL_Window->Height-SDL_Window->BorderTop-SDL_Window->BorderBottom);
break; break;
/* Have we been requested to quit? */ /* Have we been requested to quit? */
@ -428,7 +429,11 @@ void amiga_InitKeymap(void)
SDL_keysym *amiga_TranslateKey(int code, SDL_keysym *keysym) 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; static struct Library *ConsoleDevice=NULL;
#endif
/* Get the raw keyboard scancode */ /* Get the raw keyboard scancode */
keysym->scancode = code; 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); fprintf(stderr, "Translating key 0x%.4x (%d)\n", xsym, xkey->keycode);
#endif #endif
/* Get the translated SDL virtual keysym */ /* Get the translated SDL virtual keysym */
if ( keysym->sym==SDLK_UNKNOWN ) if ( keysym->sym==SDLK_UNKNOWN )
{ {
#ifdef STORMC4_WOS
if(!KeymapBase)
#else
if(!ConsoleDevice) if(!ConsoleDevice)
#endif
{ {
#ifdef STORMC4_WOS
KeymapBase=OpenLibrary("keymap.library", 0L);
#else
if(ConPort=CreateMsgPort()) if(ConPort=CreateMsgPort())
{ {
if(ConReq=CreateIORequest(ConPort,sizeof(struct IOStdReq))) if(ConReq=CreateIORequest(ConPort,sizeof(struct IOStdReq)))
@ -460,9 +472,14 @@ SDL_keysym *amiga_TranslateKey(int code, SDL_keysym *keysym)
ConPort=NULL; ConPort=NULL;
} }
} }
#endif
} }
#ifdef STORMC4_WOS
if(KeymapBase)
#else
if(ConsoleDevice) if(ConsoleDevice)
#endif
{ {
struct InputEvent event; struct InputEvent event;
long actual; long actual;
@ -477,7 +494,11 @@ SDL_keysym *amiga_TranslateKey(int code, SDL_keysym *keysym)
event.ie_NextEvent=NULL; event.ie_NextEvent=NULL;
event.ie_Prev1DownCode=event.ie_Prev1DownQual=event.ie_Prev2DownCode=event.ie_Prev2DownQual=0; 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) if( (actual=RawKeyConvert(&event,buffer,5,NULL))>=0)
#endif
{ {
if(actual>1) 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_error.h"
#include "SDL_endian.h" #include "SDL_endian.h"
#include "SDL_sysvideo.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! // 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 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 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) #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) 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);} {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);} {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);} {BltBitMap(a,b,c,d,e,f,g,h,i,j,k);}
#endif #endif
@ -39,7 +66,7 @@ int CGX_SetHWColorKey(_THIS,SDL_Surface *surface, Uint32 key)
memset(surface->hwdata->mask,255,RASSIZE(surface->w,surface->h)); 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, if(lock=LockBitMapTags(surface->hwdata->bmap,LBMI_BASEADDRESS,(ULONG)&surface->pixels,
LBMI_BYTESPERROW,(ULONG)&pitch,TAG_DONE)) LBMI_BYTESPERROW,(ULONG)&pitch,TAG_DONE))
@ -138,7 +165,7 @@ int CGX_SetHWColorKey(_THIS,SDL_Surface *surface, Uint32 key)
ok=-1; ok=-1;
} }
UnLockBitMap(lock); UnLockBitMap(lock);
D(bug("...Colorkey costruito!\n")); D(bug("...Colorkey built!\n"));
return ok; return ok;
} }
} }

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

@ -25,189 +25,117 @@ static char rcsid =
"@(#) $Id$"; "@(#) $Id$";
#endif #endif
// #include <stdlib.h> /* For getenv() prototype */ /* StormMesa implementation of SDL OpenGL support */
// #include <string.h>
#include "SDL_events_c.h"
#include "SDL_error.h" #include "SDL_error.h"
#include "SDL_cgxvideo.h"
#include "SDL_cgxgl_c.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 */ /* Init OpenGL */
void *CGX_GL_GetVisual(_THIS) int CGX_GL_Init(_THIS)
{ {
#ifdef HAVE_OPENGL #ifdef HAVE_OPENGL
/* 64 seems nice. */ int i = 0;
int attribs[64]; struct TagItem attributes [ 14 ]; /* 14 should be more than enough :) */
int i; struct Window *win = (struct Window *)SDL_Window;
/* load the gl driver from a default path */ // default config. Always used...
if ( ! this->gl_config.driver_loaded ) { attributes[i].ti_Tag = AMA_Window; attributes[i++].ti_Data = (unsigned long)win;
/* no driver has been loaded, use default (ourselves) */ attributes[i].ti_Tag = AMA_Left; attributes[i++].ti_Data = 0;
if ( X11_GL_LoadLibrary(this, NULL) < 0 ) { attributes[i].ti_Tag = AMA_Bottom; attributes[i++].ti_Data = 0;
return NULL; 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 {
/* See if we already have a window which we must use */ attributes[i++].ti_Data = GL_FALSE;
if ( SDL_windowid ) {
XWindowAttributes a;
XVisualInfo vi_in;
int out_count;
XGetWindowAttributes(SDL_Display, SDL_Window, &a);
vi_in.screen = SDL_Screen;
vi_in.visualid = XVisualIDFromVisual(a.visual);
glx_visualinfo = XGetVisualInfo(SDL_Display,
VisualScreenMask|VisualIDMask, &vi_in, &out_count);
return glx_visualinfo;
} }
// RGB(A) Mode ?
/* Setup our GLX attributes according to the gl_config. */ attributes[i].ti_Tag = AMA_RGBMode;
i = 0; if ( this->gl_config.red_size != 0 &&
attribs[i++] = GLX_RGBA; this->gl_config.blue_size != 0 &&
attribs[i++] = GLX_RED_SIZE; this->gl_config.green_size != 0 ) {
attribs[i++] = this->gl_config.red_size; attributes[i++].ti_Data = GL_TRUE;
attribs[i++] = GLX_GREEN_SIZE;
attribs[i++] = this->gl_config.green_size;
attribs[i++] = GLX_BLUE_SIZE;
attribs[i++] = this->gl_config.blue_size;
if( this->gl_config.alpha_size ) {
attribs[i++] = GLX_ALPHA_SIZE;
attribs[i++] = this->gl_config.alpha_size;
} }
else {
if( this->gl_config.buffer_size ) { attributes[i++].ti_Data = GL_FALSE;
attribs[i++] = GLX_BUFFER_SIZE;
attribs[i++] = this->gl_config.buffer_size;
} }
// no depth buffer ?
if( this->gl_config.double_buffer ) { if ( this->gl_config.depth_size == 0 ) {
attribs[i++] = GLX_DOUBLEBUFFER; attributes[i].ti_Tag = AMA_NoDepth;
attributes[i++].ti_Data = GL_TRUE;
} }
// no stencil buffer ?
attribs[i++] = GLX_DEPTH_SIZE; if ( this->gl_config.stencil_size == 0 ) {
attribs[i++] = this->gl_config.depth_size; attributes[i].ti_Tag = AMA_NoStencil;
attributes[i++].ti_Data = GL_TRUE;
if( this->gl_config.stencil_size ) {
attribs[i++] = GLX_STENCIL_SIZE;
attribs[i++] = this->gl_config.stencil_size;
} }
// no accum buffer ?
if( this->gl_config.accum_red_size ) { if ( this->gl_config.accum_red_size != 0 &&
attribs[i++] = GLX_ACCUM_RED_SIZE; this->gl_config.accum_blue_size != 0 &&
attribs[i++] = this->gl_config.accum_red_size; 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 ) { glcont = AmigaMesaCreateContext(attributes);
attribs[i++] = GLX_ACCUM_GREEN_SIZE; if ( glcont == NULL ) {
attribs[i++] = this->gl_config.accum_green_size; 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 ) { return(0);
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;
#else #else
SDL_SetError("CGX driver is not yet supporting OpenGL"); SDL_SetError("OpenGL support not configured");
return NULL; return(-1);
#endif #endif
} }
int CGX_GL_CreateWindow(_THIS, int w, int h) /* Quit OpenGL */
void CGX_GL_Quit(_THIS)
{ {
int retval;
#ifdef HAVE_OPENGL #ifdef HAVE_OPENGL
XSetWindowAttributes attributes; if ( glcont != NULL ) {
unsigned long mask; AmigaMesaDestroyContext(glcont);
unsigned long black; glcont = NULL;
this->gl_data->gl_active = 0;
black = (glx_visualinfo->visual == DefaultVisual(SDL_Display, this->gl_config.driver_loaded = 0;
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;
} }
retval = 0;
#else
SDL_SetError("CGX driver is not yet supporting OpenGL");
retval = -1;
#endif #endif
return(retval);
} }
int CGX_GL_CreateContext(_THIS) /* Attach context to another window */
int CGX_GL_Update(_THIS)
{ {
int retval;
#ifdef HAVE_OPENGL #ifdef HAVE_OPENGL
/* We do this to create a clean separation between X and GLX errors. */ struct TagItem tags[2];
XSync( SDL_Display, False ); struct Window *win = (struct Window*)SDL_Window;
glx_context = this->gl_data->glXCreateContext(GFX_Display, if(glcont == NULL) {
glx_visualinfo, NULL, True); return -1; //should never happen
XSync( GFX_Display, False );
if (glx_context == NULL) {
SDL_SetError("Could not create GL context");
return -1;
} }
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 #else
SDL_SetError("CGX driver is not yet supporting OpenGL"); SDL_SetError("OpenGL support not configured");
return -1;
#endif #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 #ifdef HAVE_OPENGL
@ -215,175 +143,75 @@ void CGX_GL_Shutdown(_THIS)
/* Make the current context active */ /* Make the current context active */
int CGX_GL_MakeCurrent(_THIS) int CGX_GL_MakeCurrent(_THIS)
{ {
int retval; if(glcont == NULL)
return -1;
retval = 0; AmigaMesaMakeCurrent(glcont, glcont->buffer);
if ( ! this->gl_data->glXMakeCurrent(GFX_Display, return 0;
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;
} }
void CGX_GL_SwapBuffers(_THIS) 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) switch(attrib) {
{ case SDL_GL_RED_SIZE:
#ifdef HAVE_OPENGL mesa_attrib = GL_RED_BITS;
if ( this->gl_config.driver_loaded ) { break;
dlclose(this->gl_config.dll_handle); case SDL_GL_GREEN_SIZE:
mesa_attrib = GL_GREEN_BITS;
this->gl_data->glXChooseVisual = NULL; break;
this->gl_data->glXCreateContext = NULL; case SDL_GL_BLUE_SIZE:
this->gl_data->glXDestroyContext = NULL; mesa_attrib = GL_BLUE_BITS;
this->gl_data->glXMakeCurrent = NULL; break;
this->gl_data->glXSwapBuffers = NULL; case SDL_GL_ALPHA_SIZE:
mesa_attrib = GL_ALPHA_BITS;
this->gl_config.dll_handle = NULL; break;
this->gl_config.driver_loaded = 0; case SDL_GL_DOUBLEBUFFER:
} mesa_attrib = GL_DOUBLEBUFFER;
#endif break;
} case SDL_GL_DEPTH_SIZE:
mesa_attrib = GL_DEPTH_BITS;
#ifdef HAVE_OPENGL break;
case SDL_GL_STENCIL_SIZE:
/* Passing a NULL path means load pointers from the application */ mesa_attrib = GL_STENCIL_BITS;
int CGX_GL_LoadLibrary(_THIS, const char* path) break;
{ case SDL_GL_ACCUM_RED_SIZE:
void* handle; mesa_attrib = GL_ACCUM_RED_BITS;
int dlopen_flags; break;
case SDL_GL_ACCUM_GREEN_SIZE:
if ( gl_active ) { mesa_attrib = GL_ACCUM_GREEN_BITS;
SDL_SetError("OpenGL context already created"); break;
return -1; case SDL_GL_ACCUM_BLUE_SIZE:
} mesa_attrib = GL_ACCUM_BLUE_BITS;
break;
#ifdef RTLD_GLOBAL case SDL_GL_ACCUM_ALPHA_SIZE:
dlopen_flags = RTLD_LAZY | RTLD_GLOBAL; mesa_attrib = GL_ACCUM_ALPHA_BITS;
#else break;
dlopen_flags = RTLD_LAZY; default :
#endif return -1;
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 */ AmigaMesaGetConfig(glcont->visual, mesa_attrib, value);
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; return 0;
} }
void *CGX_GL_GetProcAddress(_THIS, const char* proc) void *CGX_GL_GetProcAddress(_THIS, const char *proc) {
{ void *func = NULL;
void* handle; func = AmiGetGLProc(proc);
return func;
handle = this->gl_config.dll_handle; }
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 */ #endif /* HAVE_OPENGL */

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

@ -25,74 +25,30 @@ static char rcsid =
"@(#) $Id$"; "@(#) $Id$";
#endif #endif
#include <stdio.h> /* StormMesa implementation of SDL OpenGL support */
#include "SDL_sysvideo.h"
#define _THIS SDL_VideoDevice *_this
#ifdef HAVE_OPENGL #ifdef HAVE_OPENGL
#include <GL/glx.h> #include <GL/Amigamesa.h>
#include <dlfcn.h> extern void *AmiGetGLProc(const char *proc);
#endif #endif /* HAVE_OPENGL */
#include "SDL_sysvideo.h"
struct SDL_PrivateGLData { struct SDL_PrivateGLData {
int gl_active; /* to stop switching drivers while we have a valid context */ int gl_active;
#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 */
}; };
/* 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 */ /* OpenGL functions */
extern void *CGX_GL_GetVisual(_THIS); extern int CGX_GL_Init(_THIS);
extern int CGX_GL_CreateWindow(_THIS, int w, int h); extern void CGX_GL_Quit(_THIS);
extern int CGX_GL_CreateContext(_THIS); extern int CGX_GL_Update(_THIS);
extern void CGX_GL_Shutdown(_THIS);
#ifdef HAVE_OPENGL #ifdef HAVE_OPENGL
extern int CGX_GL_MakeCurrent(_THIS); extern int CGX_GL_MakeCurrent(_THIS);
extern int CGX_GL_GetAttribute(_THIS, SDL_GLattr attrib, int* value); extern int CGX_GL_GetAttribute(_THIS, SDL_GLattr attrib, int* value);
extern void CGX_GL_SwapBuffers(_THIS); 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 #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; BOOL SafeDisp=TRUE,SafeChange=TRUE;
struct MsgPort *safeport=NULL,*dispport=NULL; struct MsgPort *safeport=NULL,*dispport=NULL;
ULONG safe_sigbit,disp_sigbit; ULONG safe_sigbit,disp_sigbit;
int use_picasso96=1;
int CGX_SetupImage(_THIS, SDL_Surface *screen) int CGX_SetupImage(_THIS, SDL_Surface *screen)
{ {
if(screen->flags&SDL_HWSURFACE) SDL_Ximage=NULL;
{
Uint32 pitch;
SDL_Ximage=NULL;
if(!screen->hwdata) if(screen->flags&SDL_HWSURFACE) {
{ ULONG pitch;
if(!screen->hwdata) {
if(!(screen->hwdata=malloc(sizeof(struct private_hwdata)))) if(!(screen->hwdata=malloc(sizeof(struct private_hwdata))))
{
return -1; return -1;
}
D(bug("Creating system accel struct\n")); 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->bmap=SDL_RastPort->BitMap;
screen->hwdata->videodata=this; screen->hwdata->videodata=this;
if(!(screen->hwdata->lock=LockBitMapTags(screen->hwdata->bmap, if(!(screen->hwdata->lock=LockBitMapTags(screen->hwdata->bmap,
LBMI_BASEADDRESS,(ULONG)&screen->pixels, LBMI_BASEADDRESS,(ULONG)&screen->pixels,
LBMI_BYTESPERROW,(ULONG)&pitch,TAG_DONE))) LBMI_BYTESPERROW,(ULONG)&pitch,TAG_DONE))) {
{
free(screen->hwdata); free(screen->hwdata);
screen->hwdata=NULL; screen->hwdata=NULL;
return -1; return -1;
} }
else else {
{
UnLockBitMap(screen->hwdata->lock); UnLockBitMap(screen->hwdata->lock);
screen->hwdata->lock=NULL; screen->hwdata->lock=NULL;
} }
@ -101,17 +100,6 @@ int CGX_SetupImage(_THIS, SDL_Surface *screen)
return(-1); 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; SDL_Ximage=screen->pixels;
if ( SDL_Ximage == NULL ) { if ( SDL_Ximage == NULL ) {
@ -132,6 +120,11 @@ void CGX_DestroyImage(_THIS, SDL_Surface *screen)
} }
if ( screen ) { if ( screen ) {
screen->pixels = NULL; 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; int retval;
D(bug("Chiamata ResizeImage!\n")); D(bug("Calling ResizeImage()\n"));
CGX_DestroyImage(this, screen); CGX_DestroyImage(this, screen);
if ( flags & SDL_OPENGL ) { /* No image when using GL */ if ( flags & SDL_OPENGL ) { /* No image when using GL */
retval = 0; retval = 0;
} else { } else {
retval = CGX_SetupImage(this, screen); retval = CGX_SetupImage(this, screen);
/* We support asynchronous blitting on the display */ /* We support asynchronous blitting on the display */
if ( flags & SDL_ASYNCBLIT ) { 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 ) { if ( num_CPU() > 1 ) {
screen->flags |= SDL_ASYNCBLIT; screen->flags |= SDL_ASYNCBLIT;
} }
@ -168,7 +156,6 @@ int CGX_ResizeImage(_THIS, SDL_Surface *screen, Uint32 flags)
return(retval); return(retval);
} }
/* We don't actually allow hardware surfaces other than the main one */
int CGX_AllocHWSurface(_THIS, SDL_Surface *surface) 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)); 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; return -1;
} }
surface->hwdata->mask=NULL;
surface->hwdata->lock=NULL; surface->hwdata->lock=NULL;
surface->hwdata->videodata=this; 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)) 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; surface->flags|=SDL_HWSURFACE;
D(bug("...OK\n")); D(bug("...OK\n"));
return 0; return 0;
@ -211,11 +201,13 @@ void CGX_FreeHWSurface(_THIS, SDL_Surface *surface)
if(surface->hwdata->mask) if(surface->hwdata->mask)
free(surface->hwdata->mask); free(surface->hwdata->mask);
if(surface->hwdata->bmap) if(surface->hwdata->bmap&&surface->hwdata->allocated)
FreeBitMap(surface->hwdata->bmap); FreeBitMap(surface->hwdata->bmap);
free(surface->hwdata); free(surface->hwdata);
surface->hwdata=NULL; surface->hwdata=NULL;
surface->pixels=NULL;
D(bug("end of free hw surface\n"));
} }
return; 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->pixels=((char *)surface->pixels)+(surface->pitch*(SDL_Window->BorderTop+SDL_Window->TopEdge)+
surface->format->BytesPerPixel*(SDL_Window->BorderLeft+SDL_Window->LeftEdge)); surface->format->BytesPerPixel*(SDL_Window->BorderLeft+SDL_Window->LeftEdge));
} }
else D(else bug("Already locked!!!\n"));
D(bug("Already locked!!!\n"));
} }
return(0); return(0);
} }
void CGX_UnlockHWSurface(_THIS, SDL_Surface *surface) void CGX_UnlockHWSurface(_THIS, SDL_Surface *surface)
{ {
if(surface->hwdata && surface->hwdata->lock) if(surface->hwdata && surface->hwdata->lock)
@ -398,7 +390,7 @@ static void CGX_NormalUpdate(_THIS, int numrects, SDL_Rect *rects)
#ifndef USE_CGX_WRITELUTPIXEL #ifndef USE_CGX_WRITELUTPIXEL
int bpp; int bpp;
#endif #endif
if(this->hidden->same_format) if(this->hidden->same_format && !use_picasso96)
{ {
format=RECTFMT_RAW; 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!) */ /* Check for endian-swapped X server, swap if necessary (VERY slow!) */
if ( swap_pixels && if ( swap_pixels &&
((this->screen->format->BytesPerPixel%2) == 0) ) { ((this->screen->format->BytesPerPixel%2) == 0) ) {
D(bug("Swappo! Lento!\n")); D(bug("Software Swapping! SLOOOW!\n"));
CGX_SwapPixels(this->screen, numrects, rects); CGX_SwapPixels(this->screen, numrects, rects);
for ( i=0; i<numrects; ++i ) { for ( i=0; i<numrects; ++i ) {
if ( ! rects[i].w ) { /* Clipped? */ if ( ! rects[i].w ) { /* Clipped? */
@ -633,7 +625,7 @@ static void CGX_NormalUpdate(_THIS, int numrects, SDL_Rect *rects)
Uint32 destpitch; Uint32 destpitch;
APTR handle; APTR handle;
// D(bug("Uso customroutine!\n")); // D(bug("Using customroutine!\n"));
if(handle=LockBitMapTags(SDL_RastPort->BitMap,LBMI_BASEADDRESS,(ULONG)&bm_address, if(handle=LockBitMapTags(SDL_RastPort->BitMap,LBMI_BASEADDRESS,(ULONG)&bm_address,
LBMI_BYTESPERROW,(ULONG)&destpitch,TAG_DONE)) 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, 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, SDL_RastPort,SDL_Window->BorderLeft+rects[i].x,SDL_Window->BorderTop+rects[i].y,
rects[i].w,rects[i].h,format); 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) void CGX_RefreshDisplay(_THIS)
@ -712,7 +692,7 @@ void CGX_RefreshDisplay(_THIS)
return; return;
} }
if(this->hidden->same_format) if(this->hidden->same_format && !use_picasso96)
{ {
format=RECTFMT_RAW; format=RECTFMT_RAW;
} }

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

@ -1,6 +1,6 @@
/* /*
SDL - Simple DirectMedia Layer 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 This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Library General Public 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, SDL_Display=GFX_Display=OpenScreenTags(NULL,SA_Width,width,SA_Height,height,
SA_Depth,depth,SA_DisplayID,idok, SA_Depth,depth,SA_DisplayID,idok,
SA_ShowTitle,FALSE,
TAG_DONE); TAG_DONE);
} }
} }
static void get_real_resolution(_THIS, int* w, int* h) static void get_real_resolution(_THIS, int* w, int* h)
{ {
*w = SDL_Display->Width; *w = /*SDL_Display->Width*/ SDL_Window->Width-SDL_Window->BorderLeft-SDL_Window->BorderRight;
*h = SDL_Display->Height; *h = /*SDL_Display->Height*/ SDL_Window->Height-SDL_Window->BorderBottom-SDL_Window->BorderTop;
} }
static void move_cursor_to(_THIS, int x, int y) 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 = (SDL_Rect **)realloc(SDL_modelist,(nmodes+1)*sizeof(SDL_Rect *));
SDL_modelist[nmodes]=NULL; SDL_modelist[nmodes]=NULL;
if ( SDL_modelist ) if ( SDL_modelist )
{ {
SDL_modelist[nmodes-1] = (SDL_Rect *)malloc(sizeof(SDL_Rect)); SDL_modelist[nmodes-1] = (SDL_Rect *)malloc(sizeof(SDL_Rect));
if ( SDL_modelist[nmodes-1] == NULL ) if ( SDL_modelist[nmodes-1] == NULL )
break; break;
SDL_modelist[nmodes-1]->x = 0; 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]->w = info.Nominal.MaxX+1;
SDL_modelist[nmodes-1]->h = info.Nominal.MaxY+1; SDL_modelist[nmodes-1]->h = info.Nominal.MaxY+1;
} }
} }
} }
} }
} }
@ -267,15 +268,18 @@ void _QueueEnterFullScreen(_THIS)
int CGX_EnterFullScreen(_THIS) int CGX_EnterFullScreen(_THIS)
{ {
int okay; int okay;
Uint32 saved_flags;
okay = 1; okay = 1;
if ( ! currently_fullscreen ) saved_flags = this->screen->flags;
if ( ! currently_fullscreen )
{ {
int real_w, real_h; int real_w, real_h;
/* Map the fullscreen window to blank the screen */ /* Map the fullscreen window to blank the screen */
get_real_resolution(this, &real_w, &real_h); get_real_resolution(this, &real_w, &real_h);
CGX_DestroyWindow(this,this->screen); CGX_DestroyWindow(this,this->screen);
set_best_resolution(this, real_w,real_h); set_best_resolution(this, real_w,real_h);
@ -297,8 +301,9 @@ int CGX_EnterFullScreen(_THIS)
#endif #endif
currently_fullscreen = 1; 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 */ /* Set the new resolution */
okay = CGX_ResizeFullScreen(this); okay = CGX_ResizeFullScreen(this);
@ -311,7 +316,7 @@ int CGX_EnterFullScreen(_THIS)
XInstallColormap(SDL_Display, SDL_XColorMap); XInstallColormap(SDL_Display, SDL_XColorMap);
} }
*/ */
} }
// CGX_GrabInputNoLock(this, this->input_grab | SDL_GRAB_FULLSCREEN); // CGX_GrabInputNoLock(this, this->input_grab | SDL_GRAB_FULLSCREEN);
return(okay); 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/scale.h>
#include <graphics/gfx.h> #include <graphics/gfx.h>
#include <intuition/intuition.h> #include <intuition/intuition.h>
#ifdef __SASC #if defined(__SASC) || defined(STORMC4_WOS)
#include <proto/exec.h> #include <proto/exec.h>
#include <proto/cybergraphics.h> #include <proto/cybergraphics.h>
#include <proto/graphics.h> #include <proto/graphics.h>
@ -177,6 +177,7 @@ struct private_hwdata
APTR lock; APTR lock;
struct SDL_VideoDevice *videodata; struct SDL_VideoDevice *videodata;
APTR mask; APTR mask;
int allocated;
}; };
int CGX_CheckHWBlit(_THIS,SDL_Surface *src,SDL_Surface *dst); int CGX_CheckHWBlit(_THIS,SDL_Surface *src,SDL_Surface *dst);