tech
/
engine
2
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Added the MorphOS files. 

git-svn-id: https://svn.code.sf.net/p/fteqw/code/trunk@2066 fc73d0e0-1445-4013-8a0c-d673dee63da5
This commit is contained in:
Mark Olsen 2006-03-06 22:10:32 +00:00
parent b861dbba89
commit 7d27fc8e57
7 changed files with 2453 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

589
engine/client/in_morphos.c Normal file
View File

@ -0,0 +1,589 @@
#include <exec/exec.h>
#include <intuition/intuition.h>
#include <intuition/extensions.h>
#include <intuition/intuitionbase.h>
#include <devices/input.h>
#include <proto/exec.h>
#include <proto/intuition.h>
#include <clib/alib_protos.h>
#include "quakedef.h"
#include "input.h"
#include "in_morphos.h"
cvar_t in_xflip = {"in_xflip", "0"};
struct InputEvent imsgs[MAXIMSGS];
extern struct IntuitionBase *IntuitionBase;
extern struct Window *window;
extern struct Screen *screen;
int imsglow = 0;
int imsghigh = 0;
extern qboolean mouse_active;
static struct Interrupt InputHandler;
static struct Interrupt InputHandler;
static struct MsgPort *inputport = 0;
static struct IOStdReq *inputreq = 0;
static BYTE inputret = -1;
cvar_t m_filter = {"m_filter", "1", CVAR_ARCHIVE};
extern cvar_t _windowed_mouse;
float mouse_x, mouse_y;
float old_mouse_x, old_mouse_y;
#define DEBUGRING(x)
void IN_Shutdown(void)
{
if (inputret == 0)
{
inputreq->io_Data = (void *)&InputHandler;
inputreq->io_Command = IND_REMHANDLER;
DoIO((struct IORequest *)inputreq);
CloseDevice((struct IORequest *)inputreq);
inputret = -1;
}
if (inputreq)
{
DeleteStdIO(inputreq);
inputreq = 0;
}
if (inputport)
{
DeletePort(inputport);
inputport = 0;
}
}
void IN_Init()
{
/* Cvar_Register (&m_filter, "input controls");*/
Cvar_Register (&in_xflip, "input controls");
inputport = CreatePort(0, 0);
if (inputport == 0)
{
IN_Shutdown();
Sys_Error("Unable to create message port");
}
inputreq = CreateStdIO(inputport);
if (inputreq == 0)
{
IN_Shutdown();
Sys_Error("Unable to create IO request");
}
inputret = OpenDevice("input.device", 0, (struct IORequest *)inputreq, 0);
if (inputret != 0)
{
IN_Shutdown();
Sys_Error("Unable to open input.device");
}
InputHandler.is_Node.ln_Type = NT_INTERRUPT;
InputHandler.is_Node.ln_Pri = 100;
InputHandler.is_Node.ln_Name = "Fuhquake input handler";
InputHandler.is_Data = 0;
InputHandler.is_Code = (void(*)())&myinputhandler;
inputreq->io_Data = (void *)&InputHandler;
inputreq->io_Command = IND_ADDHANDLER;
DoIO((struct IORequest *)inputreq);
}
static void ExpireRingBuffer()
{
int i = 0;
while(imsgs[imsglow].ie_Class == IECLASS_NULL && imsglow != imsghigh)
{
imsglow++;
i++;
imsglow%= MAXIMSGS;
}
DEBUGRING(dprintf("Expired %d messages\n", i));
}
void IN_Commands(void)
{
int a;
char key;
int i;
int down;
struct InputEvent ie;
for(i = imsglow;i != imsghigh;i++, i%= MAXIMSGS)
{
DEBUGRING(dprintf("%d %d\n", i, imsghigh));
if ((window->Flags & WFLG_WINDOWACTIVE))
{
if (imsgs[i].ie_Class == IECLASS_NEWMOUSE)
{
key = 0;
if (imsgs[i].ie_Code == NM_WHEEL_UP)
key = K_MWHEELUP;
else if (imsgs[i].ie_Code == NM_WHEEL_DOWN)
key = K_MWHEELDOWN;
if (imsgs[i].ie_Code == NM_BUTTON_FOURTH)
{
Key_Event(K_MOUSE4, true);
}
else if (imsgs[i].ie_Code == (NM_BUTTON_FOURTH|IECODE_UP_PREFIX))
{
Key_Event(K_MOUSE4, false);
}
if (key)
{
Key_Event(key, 1);
Key_Event(key, 0);
}
}
else if (imsgs[i].ie_Class == IECLASS_RAWKEY)
{
down = !(imsgs[i].ie_Code&IECODE_UP_PREFIX);
imsgs[i].ie_Code&=~IECODE_UP_PREFIX;
memcpy(&ie, &imsgs[i], sizeof(ie));
key = 0;
if (imsgs[i].ie_Code <= 255)
key = keyconv[imsgs[i].ie_Code];
if (key)
Key_Event(key, down);
else
{
if (developer.value)
Con_Printf("Unknown key %d\n", imsgs[i].ie_Code);
}
}
else if (imsgs[i].ie_Class == IECLASS_RAWMOUSE)
{
if (imsgs[i].ie_Code == IECODE_LBUTTON)
Key_Event(K_MOUSE1, true);
else if (imsgs[i].ie_Code == (IECODE_LBUTTON|IECODE_UP_PREFIX))
Key_Event(K_MOUSE1, false);
else if (imsgs[i].ie_Code == IECODE_RBUTTON)
Key_Event(K_MOUSE2, true);
else if (imsgs[i].ie_Code == (IECODE_RBUTTON|IECODE_UP_PREFIX))
Key_Event(K_MOUSE2, false);
else if (imsgs[i].ie_Code == IECODE_MBUTTON)
Key_Event(K_MOUSE3, true);
else if (imsgs[i].ie_Code == (IECODE_MBUTTON|IECODE_UP_PREFIX))
Key_Event(K_MOUSE3, false);
mouse_x+= imsgs[i].ie_position.ie_xy.ie_x;
mouse_y+= imsgs[i].ie_position.ie_xy.ie_y;
}
}
imsgs[i].ie_Class = IECLASS_NULL;
}
ExpireRingBuffer();
}
void IN_Move (usercmd_t *cmd, int pnum)
{
if (pnum != 0)
return; //we're lazy today.
if (m_filter.value) {
mouse_x = (mouse_x + old_mouse_x) * 0.5;
mouse_y = (mouse_y + old_mouse_y) * 0.5;
}
old_mouse_x = mouse_x;
old_mouse_y = mouse_y;
mouse_x *= sensitivity.value;
mouse_y *= sensitivity.value;
#ifdef IN_XFLIP
if(in_xflip.value) mouse_x *= -1;
#endif
if ( (in_strafe.state[pnum] & 1) || (lookstrafe.value && (in_mlook.state[pnum] & 1) ))
{
if (cmd)
cmd->sidemove += m_side.value * mouse_x;
}
else
{
cl.viewangles[pnum][YAW] -= m_yaw.value * mouse_x;
}
if (in_mlook.state[pnum] & 1)
V_StopPitchDrift (pnum);
if ( (in_mlook.state[pnum] & 1) && !(in_strafe.state[pnum] & 1)) {
cl.viewangles[pnum][PITCH] += m_pitch.value * mouse_y;
CL_ClampPitch(pnum);
} else {
if (cmd)
{
if ((in_strafe.state[pnum] & 1) && noclip_anglehack)
cmd->upmove -= m_forward.value * mouse_y;
else
cmd->forwardmove -= m_forward.value * mouse_y;
}
}
mouse_x = mouse_y = 0.0;
}
char keyconv[] =
{
'`', /* 0 */
'1',
'2',
'3',
'4',
'5',
'6',
'7',
'8',
'9',
'0', /* 10 */
'-',
'=',
0,
0,
K_INS,
'q',
'w',
'e',
'r',
't', /* 20 */
'y',
'u',
'i',
'o',
'p',
'[',
']',
0,
K_KP_END,
K_KP_DOWNARROW, /* 30 */
K_KP_PGDN,
'a',
's',
'd',
'f',
'g',
'h',
'j',
'k',
'l', /* 40 */
';',
'\'',
'\\',
0,
K_KP_LEFTARROW,
K_KP_5,
K_KP_RIGHTARROW,
'<',
'z',
'x', /* 50 */
'c',
'v',
'b',
'n',
'm',
',',
'.',
'/',
0,
K_KP_DEL, /* 60 */
K_KP_HOME,
K_KP_UPARROW,
K_KP_PGUP,
' ',
K_BACKSPACE,
K_TAB,
K_KP_ENTER,
K_ENTER,
K_ESCAPE,
K_DEL, /* 70 */
K_INS,
K_PGUP,
K_PGDN,
K_KP_MINUS,
K_F11,
K_UPARROW,
K_DOWNARROW,
K_RIGHTARROW,
K_LEFTARROW,
K_F1, /* 80 */
K_F2,
K_F3,
K_F4,
K_F5,
K_F6,
K_F7,
K_F8,
K_F9,
K_F10,
0, /* 90 */
0,
K_KP_SLASH,
0,
K_KP_PLUS,
0,
K_SHIFT,
K_SHIFT,
0,
K_CTRL,
K_ALT, /* 100 */
K_ALT,
0,
0,
0,
0,
0,
0,
0,
0,
K_PAUSE, /* 110 */
K_F12,
K_HOME,
K_END,
0,
0,
0,
0,
0,
0,
0, /* 120 */
0,
0,
0,
0,
0,
0,
0,
0,
0,
0, /* 130 */
0,
0,
0,
0,
0,
0,
0,
0,
0,
0, /* 140 */
0,
0,
0,
0,
0,
0,
0,
0,
0,
0, /* 150 */
0,
0,
0,
0,
0,
0,
0,
0,
0,
0, /* 160 */
0,
0,
0,
0,
0,
0,
0,
0,
0,
0, /* 170 */
0,
0,
0,
0,
0,
0,
0,
0,
0,
0, /* 180 */
0,
0,
0,
0,
0,
0,
0,
0,
0,
0, /* 190 */
0,
0,
0,
0,
0,
0,
0,
0,
0,
0, /* 200 */
0,
0,
0,
0,
0,
0,
0,
0,
0,
0, /* 210 */
0,
0,
0,
0,
0,
0,
0,
0,
0,
0, /* 220 */
0,
0,
0,
0,
0,
0,
0,
0,
0,
0, /* 230 */
0,
0,
0,
0,
0,
0,
0,
0,
0,
0, /* 240 */
0,
0,
0,
0,
0,
0,
0,
0,
0,
0, /* 250 */
0,
0,
0,
0,
0,
0,
0,
0,
0
};
struct InputEvent *myinputhandler_real(void);
struct EmulLibEntry myinputhandler =
{
TRAP_LIB, 0, (void(*)(void))myinputhandler_real
};
struct InputEvent *myinputhandler_real()
{
struct InputEvent *moo = (struct InputEvent *)REG_A0;
struct InputEvent *coin;
int screeninfront;
coin = moo;
if (screen)
{
#if 0
if (IntuitionBase->LibNode.lib_Version > 50 || (IntuitionBase == 50 && IntuitionBase->LibNode.lib_Revision >= 56))
GetAttr(screen, SA_Displayed, &screeninfront);
else
#endif
screeninfront = screen==IntuitionBase->FirstScreen;
}
else
screeninfront = 1;
do
{
if (coin->ie_Class == IECLASS_RAWMOUSE || coin->ie_Class == IECLASS_RAWKEY || coin->ie_Class == IECLASS_NEWMOUSE)
{
/* kprintf("Mouse\n");*/
if ((imsghigh > imsglow && !(imsghigh == MAXIMSGS-1 && imsglow == 0)) || (imsghigh < imsglow && imsghigh != imsglow-1) || imsglow == imsghigh)
{
memcpy(&imsgs[imsghigh], coin, sizeof(imsgs[0]));
imsghigh++;
imsghigh%= MAXIMSGS;
}
else
{
DEBUGRING(kprintf("FTE: message dropped, imsglow = %d, imsghigh = %d\n", imsglow, imsghigh));
}
if (/*mouse_active && */(window->Flags & WFLG_WINDOWACTIVE) && coin->ie_Class == IECLASS_RAWMOUSE && screeninfront && window->MouseX > 0 && window->MouseY > 0)
{
if (_windowed_mouse.value)
{
#if 0
coin->ie_Class = IECLASS_NULL;
#else
coin->ie_position.ie_xy.ie_x = 0;
coin->ie_position.ie_xy.ie_y = 0;
#endif
}
}
}
coin = coin->ie_NextEvent;
} while(coin);
return moo;
}

4
engine/client/in_morphos.h Normal file
View File

@ -0,0 +1,4 @@
#define MAXIMSGS 32
extern char keyconv[];
extern struct EmulLibEntry myinputhandler;

248
engine/client/snd_morphos.c Normal file
View File

@ -0,0 +1,248 @@
#include <exec/exec.h>
#include <devices/ahi.h>
#include <proto/exec.h>
#define USE_INLINE_STDARG
#include <proto/ahi.h>
#include "quakedef.h"
#warning Remove this once Spike fixes the sound input code.
void S_UpdateCapture(void)
{
}
struct AHIChannelInfo
{
struct AHIEffChannelInfo aeci;
ULONG offset;
};
struct AHIdata
{
struct MsgPort *msgport;
struct AHIRequest *ahireq;
int ahiopen;
struct AHIAudioCtrl *audioctrl;
void *samplebuffer;
struct Hook EffectHook;
struct AHIChannelInfo aci;
unsigned int readpos;
};
ULONG EffectFunc()
{
struct Hook *hook = (struct Hook *)REG_A0;
struct AHIEffChannelInfo *aeci = (struct AHIEffChannelInfo *)REG_A1;
struct AHIdata *ad;
ad = hook->h_Data;
ad->readpos = aeci->ahieci_Offset[0];
return 0;
}
static struct EmulLibEntry EffectFunc_Gate =
{
TRAP_LIB, 0, (void (*)(void))EffectFunc
};
static void AHI_Shutdown(soundcardinfo_t *sc)
{
struct AHIdata *ad;
struct Library *AHIBase;
ad = sc->handle;
AHIBase = (struct Library *)ad->ahireq->ahir_Std.io_Device;
ad->aci.aeci.ahie_Effect = AHIET_CHANNELINFO|AHIET_CANCEL;
AHI_SetEffect(&ad->aci.aeci, ad->audioctrl);
AHI_ControlAudio(ad->audioctrl,
AHIC_Play, FALSE,
TAG_END);
AHI_FreeAudio(ad->audioctrl);
FreeVec(ad->samplebuffer);
CloseDevice((struct IORequest *)ad->ahireq);
DeleteIORequest((struct IORequest *)ad->ahireq);
DeleteMsgPort(ad->msgport);
FreeVec(ad);
}
static unsigned int AHI_GetDMAPos(soundcardinfo_t *sc)
{
struct AHIdata *ad;
ad = sc->handle;
sc->sn.samplepos = ad->readpos*sc->sn.numchannels;
return sc->sn.samplepos;
}
static void AHI_UnlockBuffer(soundcardinfo_t *sc, void *buffer)
{
}
static void *AHI_LockBuffer(soundcardinfo_t *sc)
{
return sc->sn.buffer;
}
static void AHI_SetUnderWater(soundcardinfo_t *sc, qboolean uw)
{
}
static void AHI_Submit(soundcardinfo_t *sc)
{
}
static int AHI_InitCard(soundcardinfo_t *sc, int cardnum)
{
struct AHIdata *ad;
ULONG channels;
ULONG speed;
ULONG bits;
ULONG r;
struct Library *AHIBase;
struct AHISampleInfo sample;
if (cardnum)
return 2; /* Which means "no more cards" */
ad = AllocVec(sizeof(*ad), MEMF_ANY);
if (ad)
{
ad->msgport = CreateMsgPort();
if (ad->msgport)
{
ad->ahireq = (struct AHIRequest *)CreateIORequest(ad->msgport, sizeof(struct AHIRequest));
if (ad->ahireq)
{
ad->ahiopen = !OpenDevice("ahi.device", AHI_NO_UNIT, (struct IORequest *)ad->ahireq, 0);
if (ad->ahiopen)
{
AHIBase = (struct Library *)ad->ahireq->ahir_Std.io_Device;
ad->audioctrl = AHI_AllocAudio(AHIA_AudioID, AHI_DEFAULT_ID,
AHIA_MixFreq, sc->sn.speed,
AHIA_Channels, 1,
AHIA_Sounds, 1,
TAG_END);
if (ad->audioctrl)
{
AHI_GetAudioAttrs(AHI_INVALID_ID, ad->audioctrl,
AHIDB_BufferLen, sizeof(sc->name),
AHIDB_Name, (ULONG)sc->name,
AHIDB_MaxChannels, (ULONG)&channels,
AHIDB_Bits, (ULONG)&bits,
TAG_END);
AHI_ControlAudio(ad->audioctrl,
AHIC_MixFreq_Query, (ULONG)&speed,
TAG_END);
if (bits == 8 || bits == 16)
{
if (channels > 2)
channels = 2;
sc->sn.speed = speed;
sc->sn.samplebits = bits;
sc->sn.numchannels = channels;
sc->sn.samples = speed*channels;
ad->samplebuffer = AllocVec(speed*(bits/8)*channels, MEMF_ANY);
if (ad->samplebuffer)
{
sc->sn.buffer = ad->samplebuffer;
if (channels == 1)
{
if (bits == 8)
sample.ahisi_Type = AHIST_M8S;
else
sample.ahisi_Type = AHIST_M16S;
}
else
{
if (bits == 8)
sample.ahisi_Type = AHIST_S8S;
else
sample.ahisi_Type = AHIST_S16S;
}
sample.ahisi_Address = ad->samplebuffer;
sample.ahisi_Length = (speed*(bits/8)*channels)/AHI_SampleFrameSize(sample.ahisi_Type);
r = AHI_LoadSound(0, AHIST_DYNAMICSAMPLE, &sample, ad->audioctrl);
if (r == 0)
{
r = AHI_ControlAudio(ad->audioctrl,
AHIC_Play, TRUE,
TAG_END);
if (r == 0)
{
AHI_Play(ad->audioctrl,
AHIP_BeginChannel, 0,
AHIP_Freq, speed,
AHIP_Vol, 0x10000,
AHIP_Pan, 0x8000,
AHIP_Sound, 0,
AHIP_EndChannel, NULL,
TAG_END);
ad->aci.aeci.ahie_Effect = AHIET_CHANNELINFO;
ad->aci.aeci.ahieci_Func = &ad->EffectHook;
ad->aci.aeci.ahieci_Channels = 1;
ad->EffectHook.h_Entry = (void *)&EffectFunc_Gate;
ad->EffectHook.h_Data = ad;
AHI_SetEffect(&ad->aci, ad->audioctrl);
sc->handle = ad;
sc->Lock = AHI_LockBuffer;
sc->Unlock = AHI_UnlockBuffer;
sc->SetWaterDistortion = AHI_SetUnderWater;
sc->Submit = AHI_Submit;
sc->Shutdown = AHI_Shutdown;
sc->GetDMAPos = AHI_GetDMAPos;
Con_Printf("Using AHI mode \"%s\" for audio output\n", sc->name);
Con_Printf("Channels: %d bits: %d frequency: %d\n", channels, bits, speed);
return 1;
}
}
}
FreeVec(ad->samplebuffer);
}
AHI_FreeAudio(ad->audioctrl);
}
else
Con_Printf("Failed to allocate AHI audio\n");
CloseDevice((struct IORequest *)ad->ahireq);
}
DeleteIORequest((struct IORequest *)ad->ahireq);
}
DeleteMsgPort(ad->msgport);
}
FreeVec(ad);
}
return 0;
}
sounddriver pAHI_InitCard = &AHI_InitCard;

285
engine/client/sys_morphos.c Executable file
View File

@ -0,0 +1,285 @@
#include <stdlib.h>
#include <stdio.h>
#include <stdarg.h>
#include <sys/time.h>
#include <proto/exec.h>
#include <proto/dos.h>
#include "quakedef.h"
#warning Find a better stack size
int __stack = 4*1024*1024;
struct Library *DynLoadBase;
#ifndef CLIENTONLY
qboolean isDedicated;
#endif
static void Sys_Shutdown()
{
if(DynLoadBase)
{
CloseLibrary(DynLoadBase);
DynLoadBase = 0;
}
}
void Sys_Quit (void)
{
Host_Shutdown();
Sys_Shutdown();
exit(0);
}
static void ftevprintf(const char *fmt, va_list arg)
{
char buf[4096];
unsigned char *p;
vsnprintf(buf, sizeof(buf), fmt, arg);
for (p = (unsigned char *)buf; *p; p++)
if ((*p > 128 || *p < 32) && *p != 10 && *p != 13 && *p != 9)
printf("[%02x]", *p);
else
putc(*p, stdout);
}
void Sys_Printf(char *fmt, ...)
{
va_list arg;
va_start(arg, fmt);
ftevprintf(fmt, arg);
va_end(arg);
}
void Sys_Error(const char *error, ...)
{
va_list arg;
printf("Error: ");
va_start(arg, error);
ftevprintf(error, arg);
va_end(arg);
Host_Shutdown ();
exit (1);
}
void Sys_Warn(char *warning, ...)
{
va_list arg;
printf("Warning: ");
va_start(arg, warning);
ftevprintf(warning, arg);
va_end(arg);
}
int Sys_DebugLog(char *file, char *fmt, ...)
{
va_list arg;
char buf[4096];
BPTR fh;
fh = Open(file, MODE_READWRITE);
if (fh)
{
Seek(fh, OFFSET_END, 0);
va_start(arg, fmt);
vsnprintf(buf, sizeof(buf), fmt, arg);
va_end(arg);
Write(fh, buf, strlen(buf));
Close(fh);
return true;
}
return false;
}
int secbase;
unsigned int Sys_Milliseconds(void)
{
struct timeval tp;
struct timezone tzp;
gettimeofday(&tp, &tzp);
if (!secbase)
{
secbase = tp.tv_sec;
return tp.tv_usec/1000;
}
return (tp.tv_sec - secbase)*1000 + tp.tv_usec/1000;
}
double Sys_DoubleTime(void)
{
struct timeval tp;
struct timezone tzp;
gettimeofday(&tp, &tzp);
if (!secbase)
{
secbase = tp.tv_sec;
return tp.tv_usec/1000000.0;
}
return (tp.tv_sec - secbase) + tp.tv_usec/1000000.0;
}
/* FS stuff */
int Sys_FileTime(char *path)
{
BPTR lock;
struct FileInfoBlock fib;
int ret = -1;
if (path[0] == '.' && path[1] == '/')
path+= 2;
lock = Lock(path, ACCESS_READ);
if (lock)
{
if (Examine(lock, &fib))
{
ret = ((fib.fib_Date.ds_Days+2922)*1440+fib.fib_Date.ds_Minute)*60+fib.fib_Date.ds_Tick/TICKS_PER_SECOND;
}
UnLock(lock);
}
else
dprintf("Unable to find file %s\n", path);
return ret;
}
int Sys_EnumerateFiles(char *gpath, char *match, int (*func)(char *, int, void *), void *parm)
{
return true;
}
void Sys_mkdir(char *path)
{
BPTR lock;
if (path[0] == '.' && path[1] == '/')
path+= 2;
lock = CreateDir(path);
if (lock)
{
UnLock(lock);
}
}
qboolean Sys_remove(char *path)
{
if (path[0] == '.' && path[1] == '/')
path+= 2;
return DeleteFile(path);
}
/* Quake 2 stuff */
void Sys_UnloadGame (void)
{
}
void *Sys_GetGameAPI (void *parms)
{
return NULL;
}
int main(int argc, char **argv)
{
double oldtime, newtime;
quakeparms_t parms;
int i;
COM_InitArgv(argc, argv);
TL_InitLanguages();
i = COM_CheckParm("-mem");
if (i && i < com_argc)
parms.memsize = atoi(com_argv[i+1])*1024*1024;
else
parms.memsize = 16*1024*1024;
parms.basedir = "";
parms.argc = argc;
parms.argv = argv;
parms.membase = malloc(parms.memsize);
if (parms.membase == 0)
Sys_Error("Can't allocated %d bytes\n", parms.memsize);
DynLoadBase = OpenLibrary("dynload.library", 0);
Host_Init(&parms);
oldtime = Sys_DoubleTime ();
while (1)
{
newtime = Sys_DoubleTime ();
Host_Frame(newtime - oldtime);
oldtime = newtime;
}
}
void Sys_Init()
{
}
char *Sys_GetClipboard(void)
{
return 0;
}
void Sys_CloseClipboard(char *buf)
{
}
void Sys_SaveClipboard(char *text)
{
}
qboolean Sys_InitTerminal()
{
return false;
}
void Sys_CloseTerminal()
{
}
char *Sys_ConsoleInput()
{
return 0;
}
void Sys_ServerActivity(void)
{
}
/* x86 crap */
void Sys_HighFPPrecision (void)
{
}
void Sys_LowFPPrecision (void)
{
}

655
engine/gl/gl_vidmorphos.c Normal file
View File

@ -0,0 +1,655 @@
#include <exec/exec.h>
#define SYSTEM_PRIVATE
#include <intuition/intuition.h>
#include <intuition/intuitionbase.h>
#include <intuition/extensions.h>
#include <cybergraphx/cybergraphics.h>
#include <tgl/gl.h>
#include <tgl/gla.h>
#include <proto/exec.h>
#include <proto/intuition.h>
#include <proto/cybergraphics.h>
#include <proto/tinygl.h>
#include "quakedef.h"
#include "glquake.h"
#include "gl_vidtinyglstubs.c"
#define WARP_WIDTH 320
#define WARP_HEIGHT 200
extern qboolean gammaworks;
extern unsigned short ramps[3][256];
struct Library *TinyGLBase = 0;
GLContext *__tglContext;
static int glctx = 0;
float vid_gamma = 1.0;
unsigned char *mosgammatable;
struct Window *window;
struct Screen *screen;
static void *pointermem;
static int real_width, real_height;
static void *TinyGL_GetSymbol(char *name)
{
void *ret = 0;
if (strcmp(name, "glAlphaFunc") == 0)
ret = stub_glAlphaFunc;
else if (strcmp(name, "glBegin") == 0)
ret = stub_glBegin;
else if (strcmp(name, "glBlendFunc") == 0)
ret = stub_glBlendFunc;
else if (strcmp(name, "glBindTexture") == 0)
ret = stub_glBindTexture;
else if (strcmp(name, "glClear") == 0)
ret = stub_glClear;
else if (strcmp(name, "glClearColor") == 0)
ret = stub_glClearColor;
else if (strcmp(name, "glClearDepth") == 0)
ret = stub_glClearDepth;
else if (strcmp(name, "glClearStencil") == 0)
ret = stub_glClearStencil;
else if (strcmp(name, "glColor3f") == 0)
ret = stub_glColor3f;
else if (strcmp(name, "glColor3ub") == 0)
ret = stub_glColor3ub;
else if (strcmp(name, "glColor4f") == 0)
ret = stub_glColor4f;
else if (strcmp(name, "glColor4fv") == 0)
ret = stub_glColor4fv;
else if (strcmp(name, "glColor4ub") == 0)
ret = stub_glColor4ub;
else if (strcmp(name, "glColor4ubv") == 0)
ret = stub_glColor4ubv;
else if (strcmp(name, "glColorMask") == 0)
ret = stub_glColorMask;
else if (strcmp(name, "glCopyTexImage2D") == 0)
ret = stub_glCopyTexImage2D;
else if (strcmp(name, "glCullFace") == 0)
ret = stub_glCullFace;
else if (strcmp(name, "glDepthFunc") == 0)
ret = stub_glDepthFunc;
else if (strcmp(name, "glDepthMask") == 0)
ret = stub_glDepthMask;
else if (strcmp(name, "glDepthRange") == 0)
ret = stub_glDepthRange;
else if (strcmp(name, "glDisable") == 0)
ret = stub_glDisable;
else if (strcmp(name, "glDrawBuffer") == 0)
ret = stub_glDrawBuffer;
else if (strcmp(name, "glDrawPixels") == 0)
ret = stub_glDrawPixels;
else if (strcmp(name, "glEnable") == 0)
ret = stub_glEnable;
else if (strcmp(name, "glEnd") == 0)
ret = stub_glEnd;
else if (strcmp(name, "glFinish") == 0)
ret = stub_glFinish;
else if (strcmp(name, "glFlush") == 0)
ret = stub_glFlush;
else if (strcmp(name, "glFrustum") == 0)
ret = stub_glFrustum;
else if (strcmp(name, "glGetFloatv") == 0)
ret = stub_glGetFloatv;
else if (strcmp(name, "glGetIntegerv") == 0)
ret = stub_glGetIntegerv;
else if (strcmp(name, "glGetString") == 0)
ret = stub_glGetString;
else if (strcmp(name, "glGetTexLevelParameteriv") == 0)
ret = stub_glGetTexLevelParameteriv;
else if (strcmp(name, "glHint") == 0)
ret = stub_glHint;
else if (strcmp(name, "glLoadIdentity") == 0)
ret = stub_glLoadIdentity;
else if (strcmp(name, "glLoadMatrixf") == 0)
ret = stub_glLoadMatrixf;
else if (strcmp(name, "glNormal3f") == 0)
ret = stub_glNormal3f;
else if (strcmp(name, "glNormal3fv") == 0)
ret = stub_glNormal3fv;
else if (strcmp(name, "glMatrixMode") == 0)
ret = stub_glMatrixMode;
else if (strcmp(name, "glMultMatrixf") == 0)
ret = stub_glMultMatrixf;
else if (strcmp(name, "glOrtho") == 0)
ret = stub_glOrtho;
else if (strcmp(name, "glPolygonMode") == 0)
ret = stub_glPolygonMode;
else if (strcmp(name, "glPopMatrix") == 0)
ret = stub_glPopMatrix;
else if (strcmp(name, "glPushMatrix") == 0)
ret = stub_glPushMatrix;
else if (strcmp(name, "glReadBuffer") == 0)
ret = stub_glReadBuffer;
else if (strcmp(name, "glReadPixels") == 0)
ret = stub_glReadPixels;
else if (strcmp(name, "glRotatef") == 0)
ret = stub_glRotatef;
else if (strcmp(name, "glScalef") == 0)
ret = stub_glScalef;
else if (strcmp(name, "glShadeModel") == 0)
ret = stub_glShadeModel;
else if (strcmp(name, "glTexCoord1f") == 0)
ret = stub_glTexCoord1f;
else if (strcmp(name, "glTexCoord2f") == 0)
ret = stub_glTexCoord2f;
else if (strcmp(name, "glTexCoord2fv") == 0)
ret = stub_glTexCoord2fv;
else if (strcmp(name, "glTexEnvf") == 0)
ret = stub_glTexEnvf;
else if (strcmp(name, "glTexEnvfv") == 0)
ret = stub_glTexEnvfv;
else if (strcmp(name, "glTexEnvi") == 0)
ret = stub_glTexEnvi;
else if (strcmp(name, "glTexGeni") == 0)
ret = stub_glTexGeni;
else if (strcmp(name, "glTexImage2D") == 0)
ret = stub_glTexImage2D;
else if (strcmp(name, "glTexParameteri") == 0)
ret = stub_glTexParameteri;
else if (strcmp(name, "glTexParameterf") == 0)
ret = stub_glTexParameterf;
else if (strcmp(name, "glTexSubImage2D") == 0)
ret = stub_glTexSubImage2D;
else if (strcmp(name, "glTranslatef") == 0)
ret = stub_glTranslatef;
else if (strcmp(name, "glVertex2f") == 0)
ret = stub_glVertex2f;
else if (strcmp(name, "glVertex3f") == 0)
ret = stub_glVertex3f;
else if (strcmp(name, "glVertex3fv") == 0)
ret = stub_glVertex3fv;
else if (strcmp(name, "glViewport") == 0)
ret = stub_glViewport;
else if (strcmp(name, "glGetError") == 0)
ret = stub_glGetError;
else if (strcmp(name, "glDrawElements") == 0)
ret = stub_glDrawElements;
else if (strcmp(name, "glArrayElement") == 0)
ret = stub_glArrayElement;
else if (strcmp(name, "glVertexPointer") == 0)
ret = stub_glVertexPointer;
else if (strcmp(name, "glNormalPointer") == 0)
ret = stub_glNormalPointer;
else if (strcmp(name, "glTexCoordPointer") == 0)
ret = stub_glTexCoordPointer;
else if (strcmp(name, "glColorPointer") == 0)
ret = stub_glColorPointer;
else if (strcmp(name, "glDrawArrays") == 0)
ret = stub_glDrawArrays;
else if (strcmp(name, "glEnableClientState") == 0)
ret = stub_glEnableClientState;
else if (strcmp(name, "glDisableClientState") == 0)
ret = stub_glDisableClientState;
else if (strcmp(name, "glStencilOp") == 0)
ret = stub_glStencilOp;
else if (strcmp(name, "glStencilFunc") == 0)
ret = stub_glStencilFunc;
else if (strcmp(name, "glPushAttrib") == 0)
ret = stub_glPushAttrib;
else if (strcmp(name, "glPopAttrib") == 0)
ret = stub_glPopAttrib;
else if (strcmp(name, "glScissor") == 0)
ret = stub_glScissor;
else if (strcmp(name, "glMultiTexCoord2fARB") == 0)
ret = stub_glMultiTexCoord2fARB;
else if (strcmp(name, "glMultiTexCoord3fARB") == 0)
ret = stub_glMultiTexCoord3fARB;
else if (strcmp(name, "glActiveTextureARB") == 0)
ret = stub_glActiveTextureARB;
else if (strcmp(name, "glClientActiveTextureARB") == 0)
ret = stub_glClientActiveTextureARB;
else
printf("Function \"%s\" not found\n", name);
return ret;
}
qboolean GLVID_Init (rendererstate_t *info, unsigned char *palette)
{
int argnum;
int r;
int i;
int depth = 24;
struct TagItem tgltags[] =
{
{ 0, 0 },
{ TGL_CONTEXT_STENCIL, TRUE },
{ TAG_DONE }
};
if (IntuitionBase->LibNode.lib_Version > 50 || (IntuitionBase->LibNode.lib_Version == 50 && IntuitionBase->LibNode.lib_Revision >= 74))
{
mosgammatable = AllocVec(256*3, MEMF_ANY);
if (mosgammatable)
gammaworks = 1;
}
vid.width = info->width;
vid.height = info->height;
vid.maxwarpwidth = WARP_WIDTH;
vid.maxwarpheight = WARP_HEIGHT;
vid.numpages = 3;
vid.colormap = host_colormap;
if (vid.width <= 640)
{
vid.conwidth = vid.width;
vid.conheight = vid.height;
}
else
{
vid.conwidth = vid.width/2;
vid.conheight = vid.height/2;
}
if ((i = COM_CheckParm("-conwidth")) && i + 1 < com_argc)
{
vid.conwidth = Q_atoi(com_argv[i + 1]);
// pick a conheight that matches with correct aspect
vid.conheight = vid.conwidth * 3 / 4;
}
vid.conwidth &= 0xfff8; // make it a multiple of eight
if ((i = COM_CheckParm("-conheight")) && i + 1 < com_argc)
vid.conheight = Q_atoi(com_argv[i + 1]);
if (vid.conwidth < 320)
vid.conwidth = 320;
if (vid.conheight < 200)
vid.conheight = 200;
TinyGLBase = OpenLibrary("tinygl.library", 0);
if (TinyGLBase)
{
if (TinyGLBase->lib_Version > 50 || (TinyGLBase->lib_Version == 50 && TinyGLBase->lib_Revision >= 9))
{
vid.rowbytes = vid.width;
vid.direct = 0; /* Isn't used anywhere, but whatever. */
vid.aspect = ((float)vid.height / (float)vid.width) * (320.0 / 240.0);
if (info->fullscreen)
{
screen = OpenScreenTags(0,
SA_Width, vid.width,
SA_Height, vid.height,
SA_Depth, depth,
SA_Quiet, TRUE,
SA_GammaControl, TRUE,
SA_3DSupport, TRUE,
TAG_DONE);
}
window = OpenWindowTags(0,
WA_InnerWidth, vid.width,
WA_InnerHeight, vid.height,
WA_Title, "FTEQuake",
WA_DragBar, screen?FALSE:TRUE,
WA_DepthGadget, screen?FALSE:TRUE,
WA_Borderless, screen?TRUE:FALSE,
WA_RMBTrap, TRUE,
screen?WA_PubScreen:TAG_IGNORE, (ULONG)screen,
WA_Activate, TRUE,
TAG_DONE);
if (window)
{
if (screen == 0)
gammaworks = 0;
__tglContext = GLInit();
if (__tglContext)
{
if (screen)
{
tgltags[0].ti_Tag = TGL_CONTEXT_SCREEN;
tgltags[0].ti_Data = screen;
}
else
{
tgltags[0].ti_Tag = TGL_CONTEXT_WINDOW;
tgltags[0].ti_Data = window;
}
r = GLAInitializeContext(__tglContext, tgltags);
if (r)
{
glctx = 1;
gl_canstencil = 8;
pointermem = AllocVec(256, MEMF_ANY|MEMF_CLEAR);
if (pointermem)
{
SetPointer(window, pointermem, 16, 16, 0, 0);
#if 0
lastwindowedmouse = 1;
#endif
real_width = vid.width;
real_height = vid.height;
if (vid.conheight > vid.height)
vid.conheight = vid.height;
if (vid.conwidth > vid.width)
vid.conwidth = vid.width;
vid.width = vid.conwidth;
vid.height = vid.conheight;
GL_Init(&TinyGL_GetSymbol);
VID_SetPalette(palette);
vid.recalc_refdef = 1;
return true;
}
else
{
Con_Printf("Unable to allocate memory for mouse pointer");
}
if (screen && !(TinyGLBase->lib_Version == 0 && TinyGLBase->lib_Revision < 4))
{
glADestroyContextScreen();
}
else
{
glADestroyContextWindowed();
}
glctx = 0;
}
else
{
Con_Printf("Unable to initialize GL context");
}
GLClose(__tglContext);
__tglContext = 0;
}
else
{
Con_Printf("Unable to create GL context");
}
if (screen)
{
CloseScreen(screen);
screen = 0;
}
CloseWindow(window);
window = 0;
}
else
{
Con_Printf("Unable to open window");
}
}
CloseLibrary(TinyGLBase);
TinyGLBase = 0;
}
else
{
Con_Printf("Couldn't open tinygl.library");
}
return false;
}
void GLVID_DeInit()
{
printf("1\n");
if (glctx)
{
if (screen && !(TinyGLBase->lib_Version == 0 && TinyGLBase->lib_Revision < 4))
{
glADestroyContextScreen();
}
else
{
glADestroyContextWindowed();
}
glctx = 0;
}
printf("2\n");
if (__tglContext)
{
GLClose(__tglContext);
__tglContext = 0;
}
if (window)
{
CloseWindow(window);
window = 0;
}
if (pointermem)
{
FreeVec(pointermem);
pointermem = 0;
}
if (screen)
{
CloseScreen(screen);
screen = 0;
}
if (TinyGLBase)
{
CloseLibrary(TinyGLBase);
TinyGLBase = 0;
}
if (mosgammatable)
{
FreeVec(mosgammatable);
mosgammatable = 0;
}
}
void GL_BeginRendering (int *x, int *y, int *width, int *height)
{
*x = *y = 0;
*width = real_width;
*height = real_height;
}
void GL_EndRendering (void)
{
glASwapBuffers();
}
void GL_DoSwap(void)
{
}
void GLVID_SetPalette (unsigned char *palette)
{
qbyte *pal;
unsigned int r,g,b;
int i;
unsigned *table1;
unsigned *table2;
extern qbyte gammatable[256];
Con_Printf("Converting 8to24\n");
pal = palette;
table1 = d_8to24rgbtable;
table2 = d_8to24bgrtable;
for (i=0 ; i<256 ; i++)
{
r = gammatable[pal[0]];
g = gammatable[pal[1]];
b = gammatable[pal[2]];
pal += 3;
*table1++ = LittleLong((255<<24) + (r<<0) + (g<<8) + (b<<16));
*table2++ = LittleLong((255<<24) + (r<<16) + (g<<8) + (b<<0));
}
d_8to24bgrtable[255] &= LittleLong(0xffffff); // 255 is transparent
d_8to24rgbtable[255] &= LittleLong(0xffffff); // 255 is transparent
}
void GLVID_ShiftPalette (unsigned char *palette)
{
int i;
if (gammaworks)
{
for(i=0;i<768;i++)
{
mosgammatable[i] = ramps[0][i]>>8;
}
SetAttrs(screen,
SA_GammaRed, mosgammatable,
SA_GammaGreen, mosgammatable+256,
SA_GammaBlue, mosgammatable+512,
TAG_DONE);
}
}
void GLD_BeginDirectRect (int x, int y, qbyte *pbitmap, int width, int height)
{
}
void GLD_EndDirectRect (int x, int y, int width, int height)
{
}
void GLVID_UnlockBuffer()
{
}
void GLVID_LockBuffer()
{
}
int GLVID_ForceUnlockedAndReturnState (void)
{
return 0;
}
void GLVID_ForceLockState (int lk)
{
}
void GLVID_HandlePause (qboolean pause)
{
}
void Sys_SendKeyEvents(void)
{
}

423
engine/gl/gl_vidtinyglstubs.c Normal file
View File

@ -0,0 +1,423 @@
void stub_glAlphaFunc(GLenum func, GLclampf ref)
{
glAlphaFunc(func, ref);
}
void stub_glBegin(GLenum mode)
{
glBegin(mode);
}
void stub_glBlendFunc(GLenum sfactor, GLenum dfactor)
{
glBlendFunc(sfactor, dfactor);
}
void stub_glBindTexture(GLenum target, GLuint texture)
{
glBindTexture(target, texture);
}
void stub_glClear(GLbitfield mask)
{
glClear(mask);
}
void stub_glClearColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha)
{
glClearColor(red, green, blue, alpha);
}
void stub_glClearDepth(GLclampd depth)
{
glClearDepth(depth);
}
void stub_glClearStencil(GLint s)
{
glClearStencil(s);
}
void stub_glColor3f(GLfloat red, GLfloat green, GLfloat blue)
{
glColor3f(red, green, blue);
}
void stub_glColor3ub(GLubyte red, GLubyte green, GLubyte blue)
{
glColor3ub(red, green, blue);
}
void stub_glColor4f(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
{
glColor4f(red, green, blue, alpha);
}
void stub_glColor4fv(const GLfloat *v)
{
glColor4fv(v);
}
void stub_glColor4ub(GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha)
{
glColor4ub(red, green, blue, alpha);
}
void stub_glColor4ubv(const GLubyte *v)
{
glColor4ubv(v);
}
void stub_glColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha)
{
glColorMask(red, green, blue, alpha);
}
void stub_glCopyTexImage2D(GLenum target, GLint level, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border)
{
#warning Not implemented
#if 0
glCopyTexImage2D(target, level, internalFormat, x, y, width, height, border);
#endif
}
void stub_glCullFace(GLenum mode)
{
glCullFace(mode);
}
void stub_glDepthFunc(GLenum func)
{
glDepthFunc(func);
}
void stub_glDepthMask(GLboolean flag)
{
glDepthMask(flag);
}
void stub_glDepthRange(GLclampd zNear, GLclampd zFar)
{
glDepthRange(zNear, zFar);
}
void stub_glDisable(GLenum cap)
{
glDisable(cap);
}
void stub_glDrawBuffer(GLenum mode)
{
#warning Not implemented
#if 0
glDrawBuffer(mode);
#endif
}
void stub_glDrawPixels(GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels)
{
#warning Not implemented
#if 0
glDrawPixels(width, height, format, type, pixels);
#endif
}
void stub_glEnable(GLenum cap)
{
glEnable(cap);
}
void stub_glEnd(void)
{
glEnd();
}
void stub_glFinish(void)
{
glFinish();
}
void stub_glFlush(void)
{
glFlush();
}
void stub_glFrustum(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar)
{
glFrustum(left, right, bottom, top, zNear, zFar);
}
void stub_glGetFloatv(GLenum pname, GLfloat *params)
{
glGetFloatv(pname, params);
}
void stub_glGetIntegerv(GLenum pname, GLint *params)
{
glGetIntegerv(pname, params);
}
const GLubyte *stub_glGetString(GLenum name)
{
return glGetString(name);
}
void stub_glGetTexLevelParameteriv(GLenum target, GLint level, GLenum pname, GLint *params)
{
glGetTexLevelParameteriv(target, level, pname, params);
}
void stub_glHint(GLenum target, GLenum mode)
{
glHint(target, mode);
}
void stub_glLoadIdentity(void)
{
glLoadIdentity();
}
void stub_glLoadMatrixf(const GLfloat *m)
{
glLoadMatrixf(m);
}
void stub_glNormal3f(GLfloat nx, GLfloat ny, GLfloat nz)
{
glNormal3f(nx, ny, nz);
}
void stub_glNormal3fv(const GLfloat *v)
{
glNormal3fv(v);
}
void stub_glMatrixMode(GLenum mode)
{
glMatrixMode(mode);
}
void stub_glMultMatrixf(const GLfloat *m)
{
glMultMatrixf(m);
}
void stub_glOrtho(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar)
{
glOrtho(left, right, bottom, top, zNear, zFar);
}
void stub_glPolygonMode(GLenum face, GLenum mode)
{
glPolygonMode(face, mode);
}
void stub_glPopMatrix(void)
{
glPopMatrix();
}
void stub_glPushMatrix(void)
{
glPushMatrix();
}
void stub_glReadBuffer(GLenum mode)
{
glReadBuffer(mode);
}
void stub_glReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid *pixels)
{
glReadPixels(x, y, width, height, format, type, pixels);
}
void stub_glRotatef(GLfloat angle, GLfloat x, GLfloat y, GLfloat z)
{
glRotatef(angle, x, y, z);
}
void stub_glScalef(GLfloat x, GLfloat y, GLfloat z)
{
glScalef(x, y, z);
}
void stub_glShadeModel(GLenum mode)
{
glShadeModel(mode);
}
void stub_glTexCoord1f(GLfloat s)
{
glTexCoord1f(s);
}
void stub_glTexCoord2f(GLfloat s, GLfloat t)
{
glTexCoord2f(s, t);
}
void stub_glTexCoord2fv(const GLfloat *v)
{
glTexCoord2fv(v);
}
void stub_glTexEnvf(GLenum target, GLenum pname, GLfloat param)
{
glTexEnvf(target, pname, param);
}
void stub_glTexEnvfv(GLenum target, GLenum pname, const GLfloat *params)
{
glTexEnvfv(target, pname, params);
}
void stub_glTexEnvi(GLenum target, GLenum pname, GLint param)
{
glTexEnvi(target, pname, param);
}
void stub_glTexGeni(GLenum coord, GLenum pname, GLint param)
{
glTexGeni(coord, pname, param);
}
void stub_glTexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid *pixels)
{
glTexImage2D(target, level, internalformat, width, height, border, format, type, pixels);
}
void stub_glTexParameteri(GLenum target, GLenum pname, GLint param)
{
glTexParameteri(target, pname, param);
}
void stub_glTexParameterf(GLenum target, GLenum pname, GLfloat param)
{
glTexParameterf(target, pname, param);
}
void stub_glTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels)
{
glTexSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixels);
}
void stub_glTranslatef(GLfloat x, GLfloat y, GLfloat z)
{
glTranslatef(x, y, z);
}
void stub_glVertex2f(GLfloat x, GLfloat y)
{
glVertex2f(x, y);
}
void stub_glVertex3f(GLfloat x, GLfloat y, GLfloat z)
{
glVertex3f(x, y, z);
}
void stub_glVertex3fv(const GLfloat *v)
{
glVertex3fv(v);
}
void stub_glViewport(GLint x, GLint y, GLsizei width, GLsizei height)
{
glViewport(x, y, width, height);
}
GLenum stub_glGetError(void)
{
return glGetError();
}
void stub_glDrawElements(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices)
{
glDrawElements(mode, count, type, indices);
}
void stub_glArrayElement(GLint i)
{
glArrayElement(i);
}
void stub_glVertexPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
{
glVertexPointer(size, type, stride, pointer);
}
void stub_glNormalPointer(GLenum type, GLsizei stride, const GLvoid *pointer)
{
glNormalPointer(type, stride, pointer);
}
void stub_glTexCoordPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
{
glTexCoordPointer(size, type, stride, pointer);
}
void stub_glColorPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
{
glColorPointer(size, type, stride, pointer);
}
void stub_glDrawArrays(GLenum mode, GLint first, GLsizei count)
{
glDrawArrays(mode, first, count);
}
void stub_glEnableClientState(GLenum array)
{
glEnableClientState(array);
}
void stub_glDisableClientState(GLenum array)
{
glDisableClientState(array);
}
void stub_glStencilOp(GLenum fail, GLenum zfail, GLenum zpass)
{
glStencilOp(fail, zfail, zpass);
}
void stub_glStencilFunc(GLenum func, GLint ref, GLuint mask)
{
glStencilFunc(func, ref, mask);
}
void stub_glPushAttrib(GLbitfield mask)
{
glPushAttrib(mask);
}
void stub_glPopAttrib(void)
{
glPopAttrib();
}
void stub_glScissor(GLint x, GLint y, GLsizei width, GLsizei height)
{
glScissor(x, y, width, height);
}
void stub_glMultiTexCoord2fARB(GLenum unit, GLfloat s, GLfloat t)
{
glMultiTexCoord2fARB(unit, s, t);
}
void stub_glMultiTexCoord3fARB(GLenum unit, GLfloat s, GLfloat t, GLfloat r)
{
glMultiTexCoord3fARB(unit, s, t, r);
}
void stub_glActiveTextureARB(GLenum unit)
{
glActiveTextureARB(unit);
}
void stub_glClientActiveTextureARB(GLenum unit)
{
glClientActiveTextureARB(unit);
}

249
engine/sw/vid_morphos.c Normal file
View File

@ -0,0 +1,249 @@
#include <exec/exec.h>
#include <intuition/intuition.h>
#include <graphics/gfx.h>
#include <cybergraphx/cybergraphics.h>
#include <proto/exec.h>
#include <proto/intuition.h>
#include <proto/graphics.h>
#include <proto/cybergraphics.h>
#include "quakedef.h"
#include "d_local.h"
qbyte vid_curpal[768];
static unsigned char pal[1024];
struct Window *window;
struct Screen *screen;
static void *pointermem;
static void *displaybuffer;
void ResetFrameBuffers(void)
{
int vid_surfcachesize;
void *vid_surfcache;
int buffersize;
if (d_pzbuffer)
{
D_FlushCaches();
free(d_pzbuffer);
d_pzbuffer = NULL;
}
buffersize = vid.width * vid.height * sizeof(*d_pzbuffer);
vid_surfcachesize = D_SurfaceCacheForRes (vid.width, vid.height, 0);
buffersize += vid_surfcachesize;
d_pzbuffer = malloc(buffersize);
vid_surfcache = (qbyte *) d_pzbuffer + vid.width * vid.height * sizeof(*d_pzbuffer);
D_InitCaches(vid_surfcache, vid_surfcachesize);
}
qboolean SWVID_Init (rendererstate_t *info, unsigned char *palette)
{
printf("SWVID_Init\n");
printf("Trying to open a %dx%dx%d screen\n", info->width, info->height, info->bpp);
vid.conwidth = vid.width = info->width;
vid.conheight = vid.height = info->height;
vid.aspect = ((float)vid.height / (float)vid.width) * (320.0 / 240.0);
vid.direct = 0; /* We never have direct access to the currently displayed buffer */
vid.numpages = 1;
vid.colormap = host_colormap;
r_pixbytes = info->bpp/8;
redshift = 16;
greenshift = 8;
blueshift = 0;
redbits = 8;
greenbits = 8;
bluebits = 8;
displaybuffer = AllocVec(info->width*info->height*info->bpp/8, MEMF_ANY);
if (displaybuffer)
{
memset(displaybuffer, -1, info->width*info->height*info->bpp/8);
vid.conbuffer = vid.buffer = displaybuffer;
vid.conrowbytes = vid.rowbytes = info->width*info->bpp/8;
if (info->fullscreen)
{
screen = OpenScreenTags(0,
SA_Width, vid.width,
SA_Height, vid.height,
SA_Depth, info->bpp,
SA_Quiet, TRUE,
TAG_DONE);
}
window = OpenWindowTags(0,
WA_InnerWidth, info->width,
WA_InnerHeight, info->height,
WA_Title, "FTEQuake",
WA_DragBar, screen?FALSE:TRUE,
WA_DepthGadget, screen?FALSE:TRUE,
WA_Borderless, screen?TRUE:FALSE,
WA_RMBTrap, TRUE,
screen?WA_PubScreen:TAG_IGNORE, (ULONG)screen,
WA_Activate, TRUE,
WA_ReportMouse, TRUE,
TAG_DONE);
if (window)
{
pointermem = AllocVec(256, MEMF_ANY|MEMF_CLEAR);
if (pointermem)
{
SetPointer(window, pointermem, 16, 16, 0, 0);
ResetFrameBuffers();
return true;
}
}
if (screen)
{
CloseScreen(screen);
screen = 0;
}
FreeVec(displaybuffer);
displaybuffer = 0;
}
return false;
}
void SWVID_Shutdown (void)
{
if (window)
{
CloseWindow(window);
window = 0;
}
if (screen)
{
CloseScreen(screen);
screen = 0;
}
if (pointermem)
{
FreeVec(pointermem);
pointermem = 0;
}
if (displaybuffer)
{
FreeVec(displaybuffer);
displaybuffer = 0;
}
printf("SWVID_Shutdown\n");
}
void SWVID_ShiftPalette(unsigned char *p)
{
SWVID_SetPalette(p);
}
void SWVID_SetPalette(unsigned char *palette)
{
int i;
ULONG spal[1+(256*3)+1];
if (screen)
{
spal[0] = 256<<16;
for(i=0;i<256;i++)
{
spal[1+(i*3)] = ((unsigned int)palette[i*3])<<24;
spal[2+(i*3)] = ((unsigned int)palette[i*3+1])<<24;
spal[3+(i*3)] = ((unsigned int)palette[i*3+2])<<24;
}
spal[1+(3*256)] = 0;
LoadRGB32(&screen->ViewPort, spal);
}
memcpy(vid_curpal, palette, sizeof(vid_curpal));
for(i=0;i<256;i++)
{
pal[i*4] = 0;
pal[i*4+1] = palette[i*3+0];
pal[i*4+2] = palette[i*3+1];
pal[i*4+3] = palette[i*3+2];
}
}
void SWVID_Update(vrect_t *rects)
{
#if 1
while(rects)
{
if (r_pixbytes == 1)
{
if (screen)
WritePixelArray(displaybuffer, rects->x, rects->y, vid.rowbytes, window->RPort, rects->x, rects->y, rects->width, rects->height, RECTFMT_LUT8);
else
WriteLUTPixelArray(displaybuffer, rects->x, rects->y, vid.rowbytes, window->RPort, pal, window->BorderLeft+rects->x, window->BorderTop+rects->y, rects->width, rects->height, CTABFMT_XRGB8);
}
else
#endif
WritePixelArray(displaybuffer, 0, 0, vid.rowbytes*4, window->RPort, window->BorderLeft, window->BorderTop, vid.width, vid.height, RECTFMT_ARGB);
rects = rects->pnext;
}
}
void SWVID_HandlePause (qboolean pause)
{
}
void SWVID_LockBuffer (void)
{
}
void SWVID_UnlockBuffer (void)
{
}
void SWVID_ForceLockState (int lk)
{
}
int SWVID_ForceUnlockedAndReturnState (void)
{
return 0;
}
void SWD_BeginDirectRect (int x, int y, qbyte *pbitmap, int width, int height)
{
}
void SWD_EndDirectRect (int x, int y, int width, int height)
{
}
void Sys_SendKeyEvents(void)
{
}