jordan/dealornodeal
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Add stock(mix recovered) files

Browse Source
This commit is contained in:
jordan
2025-05-26 12:43:41 -04:00
commit 68b7934ba6
2203 changed files with 441541 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
.gitattributes vendored Normal file
View File

@@ -0,0 +1,4 @@
*.tar.gz filter=lfs diff=lfs merge=lfs -text
*.g3 filter=lfs diff=lfs merge=lfs -text
*.wav filter=lfs diff=lfs merge=lfs -text
*.sfk filter=lfs diff=lfs merge=lfs -text

5
.gitignore vendored Normal file
View File

@@ -0,0 +1,5 @@
.DS_Store
game
sources.tar.gz
linux/tmp/*.o

242
dond/core/cab.c Executable file
View File

@@ -0,0 +1,242 @@
// cab.c
// Play Mechanix - Video Game System
// Copyright (c) 2005 Play Mechanix Inc. All Rights Reserved
//
// MTM 20 Jan 05
// JFL 17 Feb 05; moved into core, cleanup
#include "pm.h"
#include "mem.h"
#include "str.h"
#include "cab.h"
#include "aud.h"
#include "gun.h"
#include "sys.h"
#include "snd.h"
#include "inp.h"
#include <jamma.h>
CabGlobal CabG; // cabinet structure
//
// CabInit
// called once at game power-up
//
// in:
// out:
// global:
//
// MTM 20 Jan 05
int CabInit(void)
{
int i;
CabGun *gun;
MEMZ(CabG);
for(i=0;i<CAB_GUNS;i++)
{
if(!(gun=CabGetGun(i)))
{BP(BP_CABINIT);continue;}
gun->gunnum=i;
gun->gunSpeed=1;
} // for
return 0;
} // CabInit
// MTM 20 Jan 05
void CabReset(void)
{
} // CabReset
// MTM 20 Jan 05
void CabFinal(void)
{
} // CabFinal
// MTM 20 Jan 05
// JFL 17 Feb 05
CabPl* CabGetPl(int n)
{
if(n>=COUNT(CabG.pl))
{BP(BP_CABGETPL);n=0;}
return &CabG.pl[n];
} // CabGetPl
// JFL 17 Feb 05
CabGun* CabGetGun(int n)
{
if((n>=COUNT(CabG.gun))||(n<0))
{BP(BP_CABGETGUN);n=0;}
return &CabG.gun[n];
} // CabGetGun
// JFL 17 Feb 05
int CabPlAttach(int cabnum,void *pl)
{
CabPl* cabpl;
cabpl=CabGetPl(cabnum);
cabpl->pl=pl;
return 0;
} // CabPlAttach()
// JFL 17 Feb 05
void* CabPlDetach(int cabnum)
{
CabPl* cabpl;
void *d;
cabpl=CabGetPl(cabnum);
d=cabpl->pl;
cabpl->pl=NUL;
return d;
} // CabPlDetach()
// JFL 17 Feb 05
int CabChangeState(int state)
{
CabG.state=state;
return 0;
} // CabChangeState()
// JFL 17 Feb 05
int CabOp(int op,int n,void *d,void *d2)
{
BP(BP_CABOP);
return 0;
} // CabOp()
int CabPlaying(int cNum)
{
int ec;
CabPl* cabpl;
if(cNum > CAB_PLAYERS)
berr(-1);
cabpl=CabGetPl(cNum);
if( cabpl->flags & M_CABPLFLAGS_PLAYING)
ec = 1;
else
ec = 0;
BAIL:
return ec;
}
// JFL 17 Feb 05
// JFL 25 Mar 05
int CabLoop(void)
{
int i,j,k,guni;
int m;
CabGun *gun;
InpRec *ir;
if(!(ir=InpGet(0)))
goto BAIL;
for(guni=0;guni<CAB_GUNS;guni++)
{
gun=CabGetGun(guni); // get the gun
if(!gun||!(gun->flags&M_CABGUN_ON)) // make sure it's on
continue;
//
// handle input
//
if(!guni)
j=INPSW_G0_TRIGGER0;
else if(guni==1)
j=INPSW_G1_TRIGGER0;
else
{BP(BP_CABLOOP);continue;}
for(i=0;i<CAB_TRIGGERS;i++)
{
if(gun->triggers[i]==ir->count[i+j])
continue;
gun->triggers[i]=ir->count[i+j];
m=0;
if(gun->triggers[i]&1)
m|=M_GUNFUNC_TRIGDOWN;
// jjj -- once we have a real gun attached, review this
if(!(gun->flags&M_CABGUN_POSSET))
{
// position gun from input record
k=INPGUNTRIG_POS(guni,i);
gun->pos[0]=ir->gunpos[k];
gun->pos[1]=ir->gunpos[k+1];
gun->pos[2]=ir->gunpos[k+2];
}
gun->flags&=~M_CABGUN_POSSET;
if(gun->gunfunc)
(*gun->gunfunc)(m|(GUNFUNC_TRIG0+i),gun,NUL,NUL);
} // for
} // for
BAIL:
return 0;
} // CabLoop()
//
// CabCreditsToCurrencyText
//
//
// in:
// out:
// global:
//
// MTM 23 Jul 01
//
float CabCreditsToCurrencyText(int32 credits)
{
float currency;
currency = (float)credits / 4.0;
// currency = (float)credits /(float)(Adj.coinsPerBill.val * Adj.unitsPerCredit.val);
return currency;
//DONE("CabCreditsToCurrencyText")
} // CabCreditsToCurrencyText
//
// CabUnusedStarts
//
//
// in:
// out:
// global:
//
// MTM 11 Apr 05
//
int CabUnusedStarts(void)
{
int rVal;
if(Coin.credits >= 4)
rVal=1;
else
rVal=0;
return rVal;
//DONE("CabUnusedStarts")
} // CabUnusedStarts
void CabDeductCoins(int coinVal)
{
AudSetCredits(Coin.credits - coinVal);
}
// EOF

82
dond/core/cab.h Executable file
View File

@@ -0,0 +1,82 @@
#ifndef CAB_H
#define CAB_H
// cab.h
// Play Mechanix - Video Game System
// Copyright (c) 2005 Play Mechanix Inc. All Rights Reserved
//
// MTM 20 Jan 05
// JFL 17 Feb 05
#define CAB_PLAYERS 2 // number of player control sets on cabinet
#define CAB_GUNS 2 // number of guns on the cabinet
#define CAB_TRIGGERS 3 // number of triggers per gun
#define CAB_NAME_SIZE 16
#define M_CABGUN_ON 0x0001
#define M_CABGUN_POSSET 0x0002
typedef struct {
uns8 flags;
uns8 gunnum;
uns8 xx2;
uns triggers[CAB_TRIGGERS];
int guntype;
void *gundata; // data field
ftype4 *gunfunc; // gun function
crd pos[3];
float gunSpeed; // world units per millisecond
} CabGun;
#define M_CABPLFLAGS_ALREADYIN 0x01 //already in, continue is possible
#define M_CABPLFLAGS_PLAYING 0x02 //player is currently playing
typedef struct {
uns8 pnum;
uns8 flags;
uns16 xx1;
void *pl;
} CabPl;
enum {
CABSTATE_NONE,
CABSTATE_ATTRACT,
CABSTATE_SELECT_CHARGE,
CABSTATE_CONTINUE,
CABSTATE_GAME,
};
typedef struct {
CabPl pl[CAB_PLAYERS];
CabGun gun[CAB_GUNS];
uns flags;
uns8 state;
uns8 xx1;
uns16 xx2;
} CabGlobal;
enum {
CABOP_NONE,
};
#define M_CABOP 0xff
// extern routines
extern int CabInit(void);
extern void CabFinal(void);
extern void CabReset(void);
extern CabPl* CabGetPl(int cabnum);
extern CabGun* CabGetGun(int gunnum);
extern int CabPlAttach(int cabnum,void *pl);
extern void* CabPlDetach(int cabnum);
extern int CabChangeState(int state);
extern int CabOp(int op,int n,void *d,void *d2);
extern int CabLoop(void);
extern int CabUnusedStarts();
extern float CabCreditsToCurrencyText(int32 credits);
extern void CabDeductCoins(int coinVal);
extern int CabPlaying(int cNum);
extern CabGlobal CabG; // does this need to be global??
#endif // ndef CAB_H
// EOF

68
dond/core/cam.c Executable file
View File

@@ -0,0 +1,68 @@
// cam.c
// Play Mechanix - Video Game System
// Copyright (c) 2004 Play Mechanix Inc. All Rights Reserved
//
// JFL 19 Oct 04
#include "pm.h"
#include "vec.h"
#include "obj.h"
#include "cam.h"
// JFL 26 May 05
void CamBuildLookM3(crd *dstm,ObjCam *cam)
{
crd m1[M3_SIZE],m2[M3_SIZE];
M3BuildRot(m1,cam->rot[0],0);
M3BuildRot(m2,cam->rot[1],1);
M3Mul(m1,m1,m2);
M3BuildRot(m2,cam->rot[2],2);
M3Mul(dstm,m1,m2);
} // CamBuildLookM3()
// JFL 26 May 05
// JFL 08 Jun 05
// JFL 28 Jul 05; shake
void CamBuildVM(crd *dstm,ObjCam *cam)
{
crd m1[M3_SIZE],m2[M3_SIZE],v[3];
M3BuildRot(m1,-cam->rot[0],0);
M3BuildRot(m2,-cam->rot[1],1);
M3Mul(m1,m1,m2);
M3BuildRot(m2,-cam->rot[2],2);
M3Mul(dstm+VM_11,m1,m2);
if(cam->shake[0]||cam->shake[1]||cam->shake[2])
{
MathNrmToRot(&cam->nrmkFrust[4*CLIP_NEAR],v); // to get to camera's rotation
M3BuildObj(m1,v); // build matrix
V3RotM3(v,cam->shake,m1); // rotate shake vector to match camera rots
V3Add(v,v,cam->trans);
V3RotM3(dstm+VM_X,v,dstm+VM_11);
} // shake
else
V3RotM3(dstm+VM_X,cam->trans,dstm+VM_11);
dstm[VM_X]=-dstm[VM_X];
dstm[VM_Y]=-dstm[VM_Y];
dstm[VM_Z]=-dstm[VM_Z];
} // CamBuildVM()
// JFL 09 Jun 05
void CamInvM3(crd *dstm,ObjCam *cam)
{
crd m1[M3_SIZE],m2[M3_SIZE];
M3BuildRot(m1,cam->rot[2],0);
M3BuildRot(m2,cam->rot[1],1);
M3Mul(m1,m1,m2);
M3BuildRot(m2,cam->rot[0],2);
M3Mul(dstm,m1,m2);
} // CamInvM3()
// EOF

12
dond/core/cam.h Executable file
View File

@@ -0,0 +1,12 @@
#ifndef CAM_H
#define CAM_H
// cam.h
// Copyright 2004 Play Mechanix Inc. All Rights Reserved
//
// JFL 19 Oct 04
extern void CamBuildLookM3(crd *dstm,ObjCam *cam);
extern void CamBuildVM(crd *dstm,ObjCam *cam);
extern void CamInvM3(crd *dstm,ObjCam *cam);
#endif // ndef CAM_H

128
dond/core/draw.h Executable file
View File

@@ -0,0 +1,128 @@
#ifndef DRAW_H
#define DRAW_H
// draw.h
// Copyright 2005 Play Mechanix Inc. All Rights Reserved
//
// JFL 25 Feb 05
#ifndef RES_H
#include "res.h"
#endif
///////////////////////////////////////////////////////////////////////////////
// SYSTEM DEPENDENT
//-----------------------------------------------------------------------------
// SYS_GL
#if SYS_GL
#define M_SRFRAMEFLAGS_AMBIENT 0x0001
#define M_SRFRAMEFLAGS_DBG_GCOL 0x0002
#define M_SRFRAMEFLAGS_GOTMATRICES 0x0004
#define M_SRFRAMEFLAGS_HASLIGHTS 0x0008
#define M_SRFRAMEFLAGS_SHADOWDIR 0x0010
#define M_SRFRAMEFLAGS_SHADOWPOS 0x0020
#define M_SRFRAMEFLAGS_CULLPLANES 0x0040
#define M_SRFRAMEFLAGS_ORTHOPROJ 0x0080 //current projection is orthographic
typedef struct {
uns32 tex;
uns16 mode;
uns16 frameflags;
uns16 camNum;
ObjCam *ocam;
ObjStartSortBuf *sort;
uns lightMask;
int matDepth;
float shadowLight[3];
N2 afterShadList;
crd *cullPlaneEqs; // only if M_SRFRAMEFLAGS_CULLPLANES, nrmk * CLIP_NUM
crd cullPlaneXYZ[3*CLIP_NUM]; // only if M_SRFRAMEFLAGS_CULLPLANES, xyz * CLIP_NUM
uns culled;
uns32 bBlend;
uns32 bColorMaterial;
uns32 curTex;
uns32 bTex2D;
uns32 bAlphaTest;
uns32 bLighting;
uns32 glShadeModel;
uns32 glTexEnv;
uns32 glAlphaFunc;
uns8 colorR;
uns8 colorG;
uns8 colorB;
uns8 colorA;
uns32 bLights[VID_MAXLIGHTS];
uns32 draw1;
uns32 draw2;
uns32 draw3;
uns32 draw2Tris;
uns32 draw2Quads;
uns32 draw2Basic;
uns32 draw2Lists;
uns32 draw2Matrix;
uns32 draw2MaxTris;
uns32 draw2MinTris;
uns32 draw2MaxQuads;
uns32 draw2MinQuads;
uns32 draw3Tris;
uns32 draw3Quads;
uns32 draw3Basic;
uns32 draw3Lists;
uns32 draw3MaxTris;
uns32 draw3MinTris;
uns32 draw3MaxQuads;
uns32 draw3MinQuads;
uns32 draw3Mixed;
} StateRec;
#define M_DRAWDISP_DEFAULT 0x00
#define M_DRAWDISP_NOMAT 0x01
#define M_DRAWDISP_NOSORT 0x02
#define M_DRAWDISP_BLENDPASS 0x04
#define M_DRAWDISP_ONEQUAD 0x08
#define M_DRAWDISP_ONETRI 0x10
#define M_DRAWDISP_ONEPASS 0x20
#define M_DRAWDISP_AFTERSHADOWS 0x40
#define M_DRAWDISP_DRAWSORTONCE 0x80
#define M_DRAWDISP_INDEX 0xfffff000
#define S_DRAWDISP_INDEX 12
#define M_DRAWPOS_DST 0x000f
#define M_DRAWPOS_DSTVM 0x0001
#define M_DRAWPOS_DSTRTS 0x0002
#define M_DRAWPOS_DSTRTSP 0x0003
#define M_DRAWPOS_DSTM3 0x0004
#endif // SYS_GL
//-----------------------------------------------------------------------------
///////////////////////////////////////////////////////////////////////////////
// SYSTEM INDEPENDENT
// extern routines
extern int DrawInit(void);
extern int DrawReset(uns reset);
extern void DrawDisp1(StateRec *sr,ResDataDisp1 *disp1);
extern void DrawDisp2(StateRec *sr,Obj *o,ResDataDisp2 *disp2,uns flags);
extern void DrawDisp3(StateRec *sr,Obj *o,ResDataDisp3 *disp3,uns flags);
extern void DrawCol(StateRec *sr,ObjColRes *ocr,ResDataCol *col);
extern void DrawShadows(StateRec *sr,ObjTmpLink *otl);
extern void DrawAfterShadows(StateRec *sr,ObjTmpLink *otl);
extern void DrawStr(StateRec *sr,ObjStr *ostr,uns flags);
extern void DrawSortBuf(StateRec *sr);
extern void DrawFreeSortBuf(ObjStartSortBuf *sort);
extern int DrawAllocSortBuf(StateRec *sr,ObjStartSortBuf *sort);
extern void DrawResetFrame(StateRec *sr);
extern void DrawResetObj(void);
extern int DrawPos(void *dst,crd *scale,ObjDispRes *odr,uns flags);
extern int DrawEmitParticles(StateRec *sr, void *oepv);
extern void DrawInitSortOnce(void);
extern void DrawAccountDisp2SortOnce(Res *r, ResDataDisp2 *d2);
extern void DrawAllocateSortOnce(void);
extern void DrawHideSortOnce(void);
extern void DrawUnhideSortOnce(void);
// extern vars and mem
#endif // ndef DRAW_H

112
dond/core/fb.h Executable file
View File

@@ -0,0 +1,112 @@
#ifndef FB_H
#define FB_H
// fb.h
// Copyright 1998-2004 Play Mechanix Inc. All Rights Reserved
//
// JFL 29 Aug 04
enum
{
FB_RESOLUTION_320x240,
FB_RESOLUTION_400x256,
FB_RESOLUTION_512x384,
FB_RESOLUTION_640x480,
FB_RESOLUTION_1366x768,
FB_RESOLUTION_Dev, // development resolution only
FB_NUM_RESOLUTION,
};
///////////////////////////////////////////////////////////////////////////////
// SYSTEM DEPENDENT
//-----------------------------------------------------------------------------
// SYS_JP5500
#if SYS_JP5500
// frame buffer support
#define NUM_FRAMEBUFFERS 2
#define MAX_FRAMEBUFFER_STRIDE 1024 // 1024 for vga development mode, else 512
#define MAX_FRAMEBUFFER_HEIGHT 512
//
// screen resolution info
//
typedef struct
{
uns16 bytesPerPixel;
uns16 strideInPixels;
uns16 screenW;
uns16 screenH;
float dispMulX;
float dispMulY;
uns32 crtcReg0;
uns32 crtcReg1;
uns32 gfxSetupReg;
uns32 *modeTable100;
uns32 *modeTable120;
} FbResInfo;
#define FB_ORIGINAL_WIDTH 640
#define FB_ORIGINAL_HEIGHT 480
#define MapDX(x) (((x) * FbRes->screenW) / FB_ORIGINAL_WIDTH)
#define MapDY(y) (((y) * FbRes->screenH) / FB_ORIGINAL_HEIGHT)
#define M_DISP_INTFLASH_REQUEST 0x01
#define M_DISP_INTFLASH_WHITEGUNS 0x02
#define M_DISP_INTFLASH_SCREENWASWHITE 0x04
#define M_DISP_INTFLASH_ONESHOT_FAKEFLASH 0x08
extern void FbIntHandler(void);
extern FbResInfo *FbRes;
extern volatile uns8* FbDrawBuf;
extern volatile uns FbIntFlipReq; // request flip from Vblank Int
extern volatile int DispIntFlash;
#endif // SYS_JP5500
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
// SYS_PC
#if SYS_PC|SYS_BB
#define NUM_FRAMEBUFFERS 2
//
// screen resolution info
//
typedef struct
{
uns16 bytesPerPixel;
uns16 strideInPixels;
uns16 screenW;
uns16 screenH;
float dispMulX;
float dispMulY;
} FbResInfo;
#define FB_ORIGINAL_WIDTH 640
#define FB_ORIGINAL_HEIGHT 480
#define MapDX(x) (((x) * FbRes->screenW) / FB_ORIGINAL_WIDTH)
#define MapDY(y) (((y) * FbRes->screenH) / FB_ORIGINAL_HEIGHT)
extern int FbSetMode(int res);
extern void FbWriteDbgInfo(void);
extern volatile uns FbIntFlipReq; // request flip from Vblank Int
#endif // SYS_PC|SYS_BB
//-----------------------------------------------------------------------------
///////////////////////////////////////////////////////////////////////////////
// SYSTEM INDEPENDENT
extern int FbInit(void);
extern void FbFinal(void);
extern int FbReset(uns reset);
extern void FbWriteDbgInfo(void);
extern FbResInfo *FbRes;
#endif // ndef FB_H

216
dond/core/fc.c Executable file
View File

@@ -0,0 +1,216 @@
// fc.c
// Play Mechanix - Video Game System
// Copyright (c) 2005 Play Mechanix Inc. All Rights Reserved
//
// JFL 17 Jan 05
#include "pm.h"
#include "res.h"
extern int GConFCJoe();
extern int AtFCAtStart();
extern int FCCounterSet();
extern int FCCounterDecr();
extern int FCScale();
extern int fcScaleAxis();
extern int fcRot();
extern int fcBlend();
extern int fcRandVel();
extern int fcSmoke();
extern int fcCredits();
extern int fcDiag();
extern int fc3DText();
extern int fcRandSnd();
extern int fcRandSndVol();
extern int fcRandNum();
extern int fcText3dCircleInit();
extern int fcText3dCircle();
extern int fcText3dResolve();
extern int fcCamShake();
extern int fcKillSecondaries();
extern int fcTextAdd();
extern int fcTextSet();
extern int fcTextFlashOn();
extern int fcTextFlashOff();
extern int fcAniWait();
extern int fcAniRand();
extern int fcTapOutReset();
extern int fcTapOut();
extern int fcPrompt();
extern int fcPromptInit();
extern int fcCreditShow();
extern int fcCreditRoll();
extern int fcCreditKill();
extern int fcCredDone();
extern int fcDondFirstCaseDone();
extern int fcDondFadeOut();
extern int fcDondCaseRevealDone();
extern int fcDondRedrawValues();
extern int fcDondFinalCaseDraw();
extern int fcDondOnTitleDone();
extern int fcDondDrawCaseValue();
extern int fcDondSend();
extern int fcDondListObjects();
extern int fcDondUpdateCasesLeftText();
extern int fcDondAskChoicesLeft();
extern int fcDondUpdateBankerText();
extern int fcDondDoGameOver();
extern int fcDondTestBanker();
extern int fcDondAskCredits();
extern int fcDondStartTimer();
extern int fcDondPlayGradedReveal();
extern int fcDondAskGradedReveal();
extern int fcDondAskVideoFrame();
extern int fcDondFadeKillReveal();
extern int fcDondPlayGradedAudio();
extern int fcDondPlayGradedCrowdAudio();
extern int fcDondUnloadVideos();
extern int fcDondOnDiagStart();
extern int fcDondShowPrevOffers();
extern int fcDondAskPrevOffers();
extern int fcDondShowTicketsWon();
extern int fcDondPlayCaseOpenVocal();
extern int fcDondShowContinueText();
extern int fcDondDoContinue();
extern int fcDondAskToContinue();
extern int fcDondInput();
extern int fcDondSetGameState();
extern int fcDondAskWRGirl();
extern int fcDondAskAtrMode();
extern int fcDondPlayPCaseRV();
extern int fcDondAttractText();
extern int fcDondAskCoupOrTick();
extern int fcDondClearGameText();
extern int fcDondPlayNDWR();
extern int fcDondAnimLED();
extern int fcDondSetLamp();
extern int fcDondAskSwitchCount();
extern int fcDondSetCorrectVol();
extern int fcDondAskAtrSound();
extern int fcDondAskGoodGame();
extern int fcDondSetTapFlag();
extern int fcDondAskTapFlag();
extern int fcDondAskBufferedInput();
extern int fcDondAskNumCredits();
extern int fcDondAskCollectWait();
extern int fcDondSetLampWrite();
extern int fcDondAskForFun();
extern int fcDondShCan();
extern int fcDondAskSkillGame();
extern int fcDondIncShCaseAnim();
extern int fcDondAskShCaseAnim();
extern int fcDondAskNJS();
extern int fcDondAskHFA();
ResDataFTOne resFTSysList[] =
{
{"fcgeorge",NUL,},
{"fcjoe",GConFCJoe,FTYPE_3,},
{"fcAtStart",AtFCAtStart,FTYPE_3,},
{"fcCounterSet",FCCounterSet,FTYPE_3,},
{"fcCounterDecr",FCCounterDecr,FTYPE_3,},
{"fcScale",FCScale,FTYPE_3,},
{"fcScaleAxis",fcScaleAxis,FTYPE_3,},
{"fcRot",fcRot,FTYPE_3,},
{"fcBlend",fcBlend,FTYPE_3,},
{"fcRandVel",fcRandVel,FTYPE_3,},
{"fcSmoke",fcSmoke,FTYPE_3,},
{"fcCredits",fcCredits,FTYPE_3,},
{"fcDiag",fcDiag,FTYPE_3,},
{"fc3DText",fc3DText,FTYPE_3,},
{"fcRandSnd",fcRandSnd,FTYPE_3,},
{"fcRandSndVol",fcRandSndVol,FTYPE_3,},
{"fcRandNum",fcRandNum,FTYPE_3,},
{"fcText3dCircleInit",fcText3dCircleInit,FTYPE_3,},
{"fcText3dCircle",fcText3dCircle,FTYPE_3,},
{"fcText3dResolve",fcText3dResolve,FTYPE_3,},
{"fcCamShake",fcCamShake,FTYPE_3,},
{"fcKillSecondaries",fcKillSecondaries,FTYPE_3,},
{"fcTextAdd",fcTextAdd,FTYPE_3,},
{"fcTextSet",fcTextSet,FTYPE_3,},
{"fcTextFlashOn",fcTextFlashOn,FTYPE_3,},
{"fcTextFlashOff",fcTextFlashOff,FTYPE_3,},
{"fcAniWait",fcAniWait,FTYPE_3,},
{"fcAniRand",fcAniRand,FTYPE_3,},
{"fcTapOutReset",fcTapOutReset,FTYPE_3,},
{"fcTapOut",fcTapOut,FTYPE_3,},
{"fcPrompt",fcPrompt,FTYPE_3,},
{"fcPromptInit",fcPromptInit,FTYPE_3,},
{"fcCreditShow",fcCreditShow,FTYPE_3,},
{"fcCreditRoll",fcCreditRoll,FTYPE_3,},
{"fcCreditKill",fcCreditKill,FTYPE_3,},
{"fcCredDone",fcCredDone,FTYPE_3,},
{"fcDondFirstCaseDone", fcDondFirstCaseDone, FTYPE_3,},
{"fcDondFadeOut", fcDondFadeOut, FTYPE_3,},
{"fcDondCaseRevealDone", fcDondCaseRevealDone, FTYPE_3,},
{"fcDondRedrawValues", fcDondRedrawValues, FTYPE_3,},
{"fcDondFinalCaseDraw", fcDondFinalCaseDraw, FTYPE_3,},
{"fcDondOnTitleDone", fcDondOnTitleDone, FTYPE_3,},
{"fcDondDrawCaseValue", fcDondDrawCaseValue, FTYPE_3,},
{"fcDondSend", fcDondSend, FTYPE_3,},
{"fcDondListObjects", fcDondListObjects, FTYPE_3,},
{"fcDondUpdateCasesLeftText", fcDondUpdateCasesLeftText, FTYPE_3,},
{"fcDondAskChoicesLeft", fcDondAskChoicesLeft, FTYPE_3,},
{"fcDondUpdateBankerText", fcDondUpdateBankerText, FTYPE_3,},
{"fcDondDoGameOver", fcDondDoGameOver, FTYPE_3,},
{"fcDondTestBanker", fcDondTestBanker, FTYPE_3,},
{"fcDondAskCredits", fcDondAskCredits, FTYPE_3,},
{"fcDondStartTimer", fcDondStartTimer, FTYPE_3,},
{"fcDondPlayGradedReveal", fcDondPlayGradedReveal, FTYPE_3,},
{"fcDondPlayGradedAudio", fcDondPlayGradedAudio, FTYPE_3,},
{"fcDondAskGradedReveal", fcDondAskGradedReveal, FTYPE_3,},
{"fcDondAskVideoFrame", fcDondAskVideoFrame, FTYPE_3,},
{"fcDondFadeKillReveal", fcDondFadeKillReveal, FTYPE_3,},
{"fcDondPlayGradedCrowdAudio", fcDondPlayGradedCrowdAudio, FTYPE_3,},
{"fcDondUnloadVideos", fcDondUnloadVideos, FTYPE_3,},
{"fcDondOnDiagStart", fcDondOnDiagStart, FTYPE_3,},
{"fcDondShowPrevOffers", fcDondShowPrevOffers, FTYPE_3,},
{"fcDondAskPrevOffers", fcDondAskPrevOffers, FTYPE_3,},
{"fcDondShowTicketsWon", fcDondShowTicketsWon, FTYPE_3,},
{"fcDondPlayCaseOpenVocal", fcDondPlayCaseOpenVocal, FTYPE_3,},
{"fcDondShowContinueText", fcDondShowContinueText, FTYPE_3,},
{"fcDondDoContinue", fcDondDoContinue, FTYPE_3,},
{"fcDondAskToContinue", fcDondAskToContinue, FTYPE_3,},
{"fcDondInput", fcDondInput, FTYPE_3,},
{"fcDondSetGameState", fcDondSetGameState, FTYPE_3,},
{"fcDondAskWRGirl", fcDondAskWRGirl, FTYPE_3,},
{"fcDondAskAtrMode", fcDondAskAtrMode, FTYPE_3,},
{"fcDondPlayPCaseRV", fcDondPlayPCaseRV, FTYPE_3,},
{"fcDondAttractText", fcDondAttractText, FTYPE_3,},
{"fcDondAskCoupOrTick", fcDondAskCoupOrTick, FTYPE_3,},
{"fcDondClearGameText", fcDondClearGameText, FTYPE_3,},
{"fcDondPlayNDWR", fcDondPlayNDWR, FTYPE_3,},
{"fcDondAnimLED", fcDondAnimLED, FTYPE_3,},
{"fcDondSetLamp", fcDondSetLamp, FTYPE_3,},
{"fcDondAskSwitchCount", fcDondAskSwitchCount, FTYPE_3,},
{"fcDondSetCorrectVol", fcDondSetCorrectVol, FTYPE_3,},
{"fcDondAskAtrSound", fcDondAskAtrSound, FTYPE_3,},
{"fcDondAskGoodGame", fcDondAskGoodGame, FTYPE_3,},
{"fcDondSetTapFlag", fcDondSetTapFlag, FTYPE_3,},
{"fcDondAskTapFlag", fcDondAskTapFlag, FTYPE_3,},
{"fcDondAskBufferedInput", fcDondAskBufferedInput, FTYPE_3,},
{"fcDondAskNumCredits", fcDondAskNumCredits, FTYPE_3,},
{"fcDondAskCollectWait", fcDondAskCollectWait, FTYPE_3,},
{"fcDondSetLampWrite", fcDondSetLampWrite, FTYPE_3,},
{"fcDondAskForFun", fcDondAskForFun, FTYPE_3,},
{"fcDondShCan", fcDondShCan, FTYPE_3,},
{"fcDondAskSkillGame", fcDondAskSkillGame, FTYPE_3,},
{"fcDondIncShCaseAnim", fcDondIncShCaseAnim, FTYPE_3,},
{"fcDondAskShCaseAnim", fcDondAskShCaseAnim, FTYPE_3,},
{"fcDondAskNJS", fcDondAskNJS, FTYPE_3,},
{"fcDondAskHFA", fcDondAskHFA, FTYPE_3,},
};
struct {
ResDataFType ftype;
ResDataFTOne list;
} ResFTypeSysList =
{
COUNT(resFTSysList),
0, // xx1
resFTSysList // ftypes
};
// EOF

167
dond/core/font.h Executable file
View File

@@ -0,0 +1,167 @@
#ifndef FONT_H
#define FONT_H
// font.h
// Copyright 2004 Play Mechanix Inc. All Rights Reserved
//
// JFL 11 Oct 04
///////////////////////////////////////////////////////////////////////////////
// SYSTEM DEPENDENT
//-----------------------------------------------------------------------------
// SYS_JP5500
#if SYS_JP5500
#endif // SYS_JP5500
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
// SYS_PC
#if SYS_PC|SYS_BB
// jjj -- check this out..
#define TB_SCROLL 0x000100
#define TB_TITLEBAR 0x000200
#define TB_KILLABLE 0x000400
#define TB_MOVING 0x000800
#define TB_TEXT 0x001000
#define TB_RESIZING 0x002000
#define TB_RESIZING_L 0x004000
#define TB_RESIZING_T 0x008000
#define TB_RESIZING_R 0x010000
#define TB_RESIZING_B 0x020000
#define TB_MPICK_ACTIVE 0x040000
#define TB_DIALOG 0x080000
#define ANI_LOOP 0x000100
#define ANI_SYNC 0x000200
#define ANI_SNAP 0x000400
#define ANI_BRIDGE 0x000800
#define ANI_LOOP_OFF 0x001000
typedef struct {
void *text1;
uns16 flags;
int isDown;
int hiliteLine;
char anchor[32];
char mString[32];
void *drawFunc;
} Menu;
typedef struct {
void *realObj;
char selected;
void *selObj;
void *selFuncObj;
} OTxtTab;
typedef struct _EditTextBox{
void *text1;
uns32 flags;
int objn;
int objtop;
int objbot;
int xOff;
int yOff;
void *selTB; //point to the EditTextBox struct we're selecting obj's from
void (*tbFunc)(struct _EditTextBox *tb);
OTxtTab winTab[512];
Menu *menu1;
Menu *menu2;
Menu *menu3;
} EditTextBox;
typedef struct {
char aniName[32];
int startFrame;
int aniFrame;
uns aniFlags;
float aniSpeed;
} aniPt;
#if SYS_BB
// drawing bitmap on linux side needs more space -- not sure why
#define FONT_SYSSPACE 2
#else // !SYS_BB
#define FONT_SYSSPACE 0
#endif // !SYS_BB
#endif // SYS_PC|SYS_BB
//-----------------------------------------------------------------------------
///////////////////////////////////////////////////////////////////////////////
// SYSTEM INDEPENDENT
extern int FontInit(void);
extern void FontFinal(void);
extern int FontReset(uns reset);
extern int FontColor(uns32 rgb);
extern int FontSet(char *s1,char *s2);
#define M_FONTGAMESTR_CREATE 0x01
#define M_FONTGAMESTR_NUMC 0x02 // pass in numc
#define M_FONTGAMESTR_HJUST0 0x04
#define M_FONTGAMESTR_HJUST1 0x08
#define M_FONTGAMESTR_VJUST0 0x10
#define M_FONTGAMESTR_VJUST1 0x20
#define M_FONTGAMESTR_HLEFT (M_FONTGAMESTR_HJUST0)
#define M_FONTGAMESTR_HCENTER (M_FONTGAMESTR_HJUST1)
#define M_FONTGAMESTR_HRIGHT (M_FONTGAMESTR_HJUST0|M_FONTGAMESTR_HJUST1)
#define M_FONTGAMESTR_VTOP (M_FONTGAMESTR_VJUST0)
#define M_FONTGAMESTR_VCENTER (M_FONTGAMESTR_VJUST1)
#define M_FONTGAMESTR_VBOTTOM (M_FONTGAMESTR_VJUST0|M_FONTGAMESTR_VJUST1)
#define S_FONTGAMESTR_N 8
//
// M_FONTSYSFLAG_
// flags for usage in FontSys()
//
#define M_FONTSYSFLAG_NOBLEND 0x01
extern int FontGameStr(char *s1,char *s2,uns flags,float xs, float ys, void *ostr);
extern int FontSys(char *str,int x,int y,int w,int h,uns flags,void *colobj);
#define FontSysSimple(str,x,y) FontSys((str),(x),(y),VidDisp.screenW,VidDisp.screenH,0,NUL)
#define FontSysSimpleFlags(str,x,y,flags) FontSys((str),(x),(y),VidDisp.screenW,VidDisp.screenH,(flags),NUL)
extern int FontObjText(void *objtext);
extern void* FontXYStr(float x,float y,char *str);
// pass in 'l'=left-justify 'r'=right-justify 'h'=horiz-center
// pass in 't'=top-justify 'b'=bottom-justify 'v'=vert-center
// pass in 0x00RRGGBB
extern void* FontXYJCStr(float x,float y,char hjust,char vjust,uns32 rgb,char *str);
enum {
FONTINFO_NONE,
FONTINFO_CHAR_WIDTH_HEIGHT, // int size[2];
};
//extern int FontObjInfo(void *objtext,int info,void *res);
extern int FontObjInfo();
///////////////////////////////////////////////////////////////////////////////
// TEXT BOX
//extern int TBDrawTextBox(void *objtext, void *tb, uns32 flags);
//extern int TBDrawMenu(void *objtext, void *m);
//extern void DrawSelBox(void *text, int n, char *namebuf);
//extern void TBDrawSliderBar(void *text, void *tb);
//extern int TBDrawMousePickBox(void *text, uns32 flags);
extern void FontOutlineBox(char *buf, crd *s, int boxHalfWid, int col);
extern int TBDrawTextBox();
extern int TBDrawMenu();
extern void DrawSelBox();
extern void TBDrawSliderBar();
extern int TBDrawMousePickBox();
extern int TBDrawDeerAnimBox(void *vtext, uns flags, void* vpap, int numAniPts,
float splspeed);
extern void FontConOutputStart(void);
extern void FontConOutputFinish(void);
#endif // ndef FONT_H

140
dond/core/fs.c Executable file
View File

@@ -0,0 +1,140 @@
// fs.c
// Play Mechanix - Video Game System
// Copyright (c) 2005 Play Mechanix Inc. All Rights Reserved
//
// JFL 20 Apr 05
#include "pm.h"
#include "sys.h"
#include "str.h"
#include "fs.h"
char *ext_adj=".adj";
char *ext_aud=".aud";
char *ext_cf=".cf";
char *ext_trn=".trn";
char *ext_plr=".plr";
char *ext_lbd=".lbd";
// JFL 21 Apr 05
int FsOp(FsH *fh,char *name,uns type,uns op,void *buf,uns bufSize)
{
int ec;
FsH fhmem;
char *ext,*path,*s2;
char namebuf[PM_NAME_SIZE+8];
char pathbuf[PM_FILEPATH_MAX];
uns8 fisopen=0;
uns f;
namebuf[0]=0;
switch(type)
{
case FSOPTYPE_ADJ:
ext=ext_adj;
path=SysG.adjpath;
break;
case FSOPTYPE_AUD:
ext=ext_aud;
path=SysG.audpath;
break;
case FSOPTYPE_CF:
ext=ext_cf;
path=SysG.cfpath;
break;
case FSOPTYPE_TRNY:
ext=ext_trn;
path=SysG.trnpath;
break;
case FSOPTYPE_PLAYER:
ext=ext_plr;
path=SysG.plrpath;
break;
case FSOPTYPE_LBOARD:
ext=ext_lbd;
path=SysG.lbdpath;
break;
} // switch
szncat2(namebuf,name,ext,sizeof(namebuf));
switch(op&M_FSOP)
{
case FSOP_OPENREADCLOSE:
fh=&fhmem;
case FSOP_OPEN:
if(!fh)
{
BP(BP_FSOP);
break;
}
// build path & open
if((ec=FsFindOpen(fh,path,namebuf,0,NUL,0))<0)
goto BAIL;
if((op&M_FSOP)==FSOP_OPEN)
err(0);
fisopen=1;
if((ec=FsRead(fh,buf,bufSize))<0)
goto BAIL;
break;
case FSOP_CREATEWRITECLOSE:
fh=&fhmem;
case FSOP_CREATE:
if(!fh)
{
BP(BP_FSOP2);
break;
}
// if multiple paths, use first
if((s2=szskipto(path,";,")))
sz2ncpy(pathbuf,path,s2,sizeof(pathbuf));
else
szncpy(pathbuf,path,sizeof(pathbuf));
if(1
&& ((ec=szlen(pathbuf))>0)
&& (ec<sizeof(pathbuf))
&& (pathbuf[ec-1]!='/')
&& (pathbuf[ec-1]!='\\'))
{
pathbuf[ec++]=FS_DIR_SLASH; // assume this slash works..
pathbuf[ec]=0;
}
szncat2(pathbuf,namebuf,NUL,sizeof(pathbuf));
f=M_FSOPEN_WRITABLE|M_FSOPEN_CREATEIFNOTFOUND|M_FSOPEN_DELETEDATA;
if(op&M_FSOP_ATOMIC)
f|=M_FSOPEN_ATOMIC;
if((ec=FsOpen(fh,pathbuf,f))<0)
goto BAIL;
if((op&M_FSOP)==FSOP_CREATE)
err(0);
fisopen=1;
if((ec=FsWrite(fh,buf,bufSize))<0)
goto BAIL;
case FSOP_CLOSE:
if((ec=FsClose(fh))<0)
goto BAIL;
break;
} // switch
ec=0;
BAIL:
if(fisopen)
FsClose(fh);
return ec;
} // FsOp()
// EOF

116
dond/core/fs.h Executable file
View File

@@ -0,0 +1,116 @@
#ifndef FS_H
#define FS_H
// fs.h
// Copyright 1998-2004 Play Mechanix Inc. All Rights Reserved
//
// JFL 26 Aug 04
///////////////////////////////////////////////////////////////////////////////
// SYSTEM DEPENDENT
//-----------------------------------------------------------------------------
// SYS_JP5500
#if SYS_JP5500
typedef struct {
uns x[16]; // private structe
} FsH;
typedef struct {
uns x[8]; // private structe
} FfH;
extern int ide_intenable(int enable);
extern int ide_inthandler(void);
#endif // SYS_JP5500
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
// SYS_PC SYS_BB
#if SYS_PC|SYS_BB
typedef struct {
uns x[16]; // private structe
} FsH;
typedef struct {
uns x[8]; // private structe
} FfH;
#define FS_DIR_SLASH '/'
#endif // SYS_PC|SYS_BB
//-----------------------------------------------------------------------------
///////////////////////////////////////////////////////////////////////////////
// SYSTEM INDEPENDENT
#define FSDIR_FIRST 0x01
#define FSDIR_NEXT 0x02
#define FSDIR_SAME 0x04
#define M_FSOPEN_CREATEIFNOTFOUND 0x01
#define M_FSOPEN_DELETEDATA 0x02
#define M_FSOPEN_WRITABLE 0x04
#define M_FSOPEN_APPEND 0x08
#define M_FSOPEN_ATOMIC 0x10
enum {
FSINFO_NONE,
FSINFO_SECTOR_SIZE,
FSINFO_CLUSTER_SIZE,
};
extern int FsInit(void);
extern void FsFinal(void);
extern int FsReset(uns reset);
extern int FsOpen(FsH *fh,char *path,uns flags);
extern int FsFindOpen(FsH *fh,char *pathlist,char *name,uns flags,
char *foundpath,int foundpathsize);
extern int FsDelete(char *path);
extern int FsRename(char *oldpath,char *newpath);
extern int FsClose(FsH *fh);
extern int FsFlush(FsH *fh);
extern int FsRead(FsH *fh,void *buf,uns32 size);
extern int FsWrite(FsH *fh,void *buf,uns32 size);
extern int FsDefrag(FsH *fh,int set);
extern int FsSeek(FsH *fh,uns32 off);
extern uns FsSize(FsH *fh);
extern int FsDiskSize(FsH *fh,int set,uns *sizep);
extern int FsDir(FsH *fh,uns n,char *buf,uns bufsize);
extern int FsCurDir(int num,int set,char *buf,uns bufsize);
extern sto FsInfo(int info);
#define M_FF_ALIGN (3)
extern int FfPrep(FfH *ff,FsH *fh);
extern int FfRead(FfH *ff,void *buf,uns32 size);
extern int FfWrite(FfH *ff,void *abuf,uns32 size);
extern int FfSeek(FfH *ff,uns32 off);
enum {
FSOPTYPE_NONE,
FSOPTYPE_ADJ,
FSOPTYPE_AUD,
FSOPTYPE_CF,
FSOPTYPE_TRNY,
FSOPTYPE_PLAYER,
FSOPTYPE_LBOARD,
};
enum {
FSOP_NONE,
FSOP_OPEN,
FSOP_CREATE,
FSOP_CLOSE,
FSOP_OPENREADCLOSE,
FSOP_CREATEWRITECLOSE,
};
#define M_FSOP 0xff
#define M_FSOP_ATOMIC 0x0100
extern int FsOp(FsH *fh,char *name,uns type,uns op,void *buf,uns bufSize);
#endif // ndef FS_H

643
dond/core/ftp.c Executable file
View File

@@ -0,0 +1,643 @@
// ftp.c
// Play Mechanix - Video Game System
// Copyright (c) 2004 Play Mechanix Inc. All Rights Reserved
//
// JFL 30 Sep 04
#include "pm.h"
#include "fs.h"
#include "mem.h"
#include "net.h"
#include "str.h"
#include "ftp.h"
// forwards
struct {
NetPH ftpctl;
NetPH ftpdat;
int bufCount;
} ftpG;
uns8 ftpcmdmem[128];
#define NUM_FTPBUFS 8
NetBuf bufs[NUM_FTPBUFS];
N2 bufList;
#define M_NETBUF_UFLAGS_ALLOC 0x40
#define M_NETBUF_UFLAGS_FUNC 0x10
enum {
NETBUF_UVAL_NONE,
NETBUF_UVAL_FTPLIST,
};
// JFL 01 Oct 04
int FTPInit(void)
{
return 0;
} // FTPInit()
// JFL 01 Oct 04
void FTPFinal(void)
{
} // FTPFinal()
// JFL 01 Oct 04
int FTPReset(uns reset)
{
int i;
NetBuf *nb;
MEMZ(ftpG);
N2Head(&bufList);
nb=&bufs[0];
for(i=0;i<NUM_FTPBUFS;i++,nb++)
{
nb->lnk.type = N2TYPE_UNK;
N2LinkAfter(&bufList,nb);
} // for
return 0;
} // FTPReset()
// JFL 01 Oct 04
int ftpBufGet(NetBuf **bufp)
{
NetBuf *nb;
if(!(nb=bufList.next) || !(nb->lnk.type))
{
LOCKUP(BP_FTPBUFGET); // out of bufs
return -1;
}
N2Unlink(nb);
MemZero(nb,sizeof(NetBuf));
*bufp=nb;
ftpG.bufCount++;
return 0;
} // ftpBufGet()
// JFL 01 Oct 04
void ftpBufFree(NetBuf *nb)
{
if(nb->uflags&M_NETBUF_UFLAGS_ALLOC)
MemDFree(MEMPOOL_NET,nb->buf);
ftpG.bufCount--;
N2LinkAfter(&bufList,nb);
} // ftpBufFree()
typedef struct {
uns16 portB;
uns8 ipB[4];
} phFTPCTL;
#define M_PH_ALLOC 0x0100
#define M_PH_LISTENING 0x0200
#define M_PH_SENDING 0x0400
// JFL 02 Oct 04
void phFree(NetPH *ph)
{
if(ph->p1 && ph->flags&M_PH_ALLOC)
{
MemDFree(MEMPOOL_NET,ph->p1);
ph->flags&=~M_PH_ALLOC;
ph->p1=NUL;
}
if(ph->flags&(M_PH_LISTENING|M_PH_SENDING))
{
NetPortRem(ph);
ph->flags&=~(M_PH_LISTENING|M_PH_SENDING);
}
} // phFree()
// JFL 01 Oct 04
int FTPOpen(int open)
{
int ec;
NetPH *ph;
if(open)
{
ph=&ftpG.ftpctl;
ph->flags=0;
ph->p1=NUL;
ph->port=NETPORT_FTPCTL;
if((ec=MemDAlloc(MEMPOOL_NET,sizeof(phFTPCTL),&ph->p1))<0)
goto BAIL;
ph->flags|=M_PH_ALLOC;
if((ec=NetPortAddListener(ph,NETPORT_FTPCTL,M_NETPORTADD_SENDBACK))<0)
goto BAIL;
ph->flags|=M_PH_LISTENING;
}
else
{
ph=&ftpG.ftpctl;
phFree(ph);
}
ec=0;
BAIL:
return ec;
} // FTPOpen()
///////////////////////////////////////////////////////////////////////////////
//
// strings -- keep all even lengths
char *ftp200FTP="200 FTP ready.\r\n";
#define FTP200FTP_LEN 16
char *ftp200PORT="200 Port OK.\r\n";
#define FTP200PORT_LEN 14
char *ftp200TYPEA="200 Ascii OK..\r\n";
char *ftp200TYPEB="200 Binary OK.\r\n";
#define FTP200TYPE_LEN 16
char *ftp200CWD="200 Cwd OK..\r\n";
#define FTP200CWD_LEN 14
const char *ftp150="150 Ready.\r\n";
#define FTP150_LEN 12
const char *ftp215="215 UNIX\r\n";
#define FTP215_LEN 10
const char *ftp221="221 Bye.\r\n";
#define FTP221_LEN 10
const char *ftp226="226 Complete..\r\n";
#define FTP226_LEN 16
const char *ftp231="231 User OK.\r\n";
#define FTP231_LEN 14
const char *ftp500="500 Syntax unrecognized.\r\n";
#define FTP500_LEN 26
const char *ftp501="501 Syntax invalid..\r\n";
#define FTP501_LEN 22
const char *ftp550="550 Error.\r\n";
#define FTP550_LEN 12
// JFL 03 Oct 04
int ftpPWD(NetPH *ph)
{
int ec;
NetBuf *nb;
char *buf;
int buflen;
if((ec=ftpBufGet(&nb))<0)
goto BAIL;
nb->bufSize=512;
if((ec=MemDAlloc(MEMPOOL_NET,nb->bufSize,&nb->buf))<0)
{
nb->bufSize=0;
goto BAIL;
}
else
nb->uflags|=M_NETBUF_UFLAGS_ALLOC;
buf=nb->buf;
buflen=nb->bufSize-4-4;
buf[0]='2';
buf[1]='3';
buf[2]='1';
buf[3]=' ';
buf+=4;
if((ec=FsCurDir(0,0,buf,buflen))<0)
{
MemDFree(MEMPOOL_NET,nb->buf);
nb->uflags&=~M_NETBUF_UFLAGS_ALLOC;
goto BAIL;
}
if(ec&1) buf[ec++]=' ';
buf[ec++]='\r';
buf[ec++]='\n';
nb->bufLen=4+ec;
if((ec=NetPortAddSdBuf(ph,nb,0))<0)
goto BAIL;
ec=0;
BAIL:
return ec;
} // ftpPWD()
// JFL 03 Oct 04
void szlinefill(char *buf,int buflen,int linelen,char *eols,int zeroterm)
{
int i,k,numeols;
char c;
for(numeols=0;eols[numeols];numeols++)
/* skip till end */ ;
c='a';
for(i=0;i<buflen;i++)
{
buf[i]=c;
if(c=='z') c='A';
else if(c=='Z') c='0';
else if(c=='9') c=' ';
else if(c==' ') c='a';
else c++;
} // for
for(i=linelen-numeols;(i+numeols)<buflen;i+=linelen)
{
for(k=0;k<numeols;k++)
buf[i+k]=eols[k];
} // for
// terminate buffer with XYZ(eol)
i=buflen-numeols-3;
if(i>0)
{
buf[i++]='X';
buf[i++]='Y';
buf[i++]='Z';
for(k=0;k<numeols;k++)
buf[i++]=eols[k];
}
if(zeroterm)
buf[buflen-1]=0;
} // szlinefill()
// JFL 03 Oct 04
int ftpLIST(NetPH *phc)
{
int ec;
NetBuf *nb=NUL;
char *buf=NUL;
int buflen;
NetPH *ph2;
uns8 *mac,*ip;
phFTPCTL *phfc;
if(!(phfc=phc->p1))
{
LOCKUP(BP_FTPLIST);
err(-2);
}
ph2=&ftpG.ftpdat;
if(ph2->port)
err(1);
ph2->port=NETPORT_FTPDAT;
ph2->flags=0;
ph2->p1=NUL;
if((ec=NetPortInfo(NUL,NETPORTINFO_OFF_THEIRMAC))<0)
goto BAIL;
mac=(void*)(ec+(memu)phc);
if((ec=NetPortInfo(NUL,NETPORTINFO_OFF_THEIRIP))<0)
goto BAIL;
ip=(void*)(ec+(memu)phc);
if((ec=NetPortAddSender(ph2,NETPORT_FTPDAT,0,mac,ip,phfc->portB))<0)
goto BAIL;
phc->phOther=ph2;
ph2->phOther=phc;
//
//
//
if((ec=ftpBufGet(&nb))<0)
goto BAIL;
buflen=1024*2;
if((ec=MemDAlloc(MEMPOOL_NET,buflen,&buf))<0)
goto BAIL;
szlinefill(buf,buflen,20,"\r\n",0);
nb->buf=buf;
nb->bufLen=nb->bufSize=buflen;
nb->uflags|=M_NETBUF_UFLAGS_ALLOC|M_NETBUF_UFLAGS_FUNC;
nb->uval=NETBUF_UVAL_FTPLIST;
if((ec=NetPortAddSdBuf(ph2,nb,M_NETPORTADD_FIN))<0)
goto BAIL;
nb=NUL;
buf=NUL;
ec=0;
BAIL:
if(nb)
ftpBufFree(nb);
if(buf)
MemDFree(MEMPOOL_NET,buf);
return ec;
} // ftpLIST()
// JFL 01 Oct 04
int ftpRvCTL(NetPH *ph,NetBuf *nbr)
{
int ec;
NetBuf *nb=NUL;
char c,*str;
uns8 *buf;
int buflen;
uns8 *sd=NUL;
uns16 sdlen;
phFTPCTL *phfc=ph->p1;
uns flags=0;
if((ec=ftpBufGet(&nb))<0)
{
LOCKUP(BP_FTPRVCTL);
goto BAIL;
}
buf=nbr->buf;
buflen=nbr->bufLen;
c = *buf++;if(c>='a'&&c<='z') c=c-'a'+'A';
str=szskiptowhite(buf);
str=szskipwhite(str);
if(c=='C') goto cwd;
if(c=='L') goto list;
if(c=='P')
{
c = *buf++;if(c>='a'&&c<='z') c=c-'a'+'A';
if(c=='O') goto port;
else goto pwd;
} // P
if(c=='Q') goto quit;
if(c=='S')
{
c = *buf++;if(c>='a'&&c<='z') c=c-'a'+'A';
if(c=='T') goto stor;
else goto syst;
} // S
if(c=='T') goto type;
if(c=='U') goto user;
if(c=='X')
{
c = *buf++;if(c>='a'&&c<='z') c=c-'a'+'A';
if(c=='C') goto cwd;
else goto pwd;
} // X
// not handled..
BP(BP_FTPRVCTL3);
goto syntax;
user:
sd=(void*)ftp231;
sdlen=FTP231_LEN;
goto send;
quit:
sd=(void*)ftp221;
sdlen=FTP221_LEN;
flags|=M_NETPORTADD_FIN;
goto send;
port:
if(!phfc)
goto error;
str=szto( str,NUL,'c',10,(void*)(0+(memu)&phfc->ipB)); // bytes
str=szto(1+str,NUL,'c',10,(void*)(1+(memu)&phfc->ipB));
str=szto(1+str,NUL,'c',10,(void*)(2+(memu)&phfc->ipB));
str=szto(1+str,NUL,'c',10,(void*)(3+(memu)&phfc->ipB));
str=szto(1+str,NUL,'c',10,(void*)(1+(memu)&phfc->portB)); // port
str=szto(1+str,NUL,'c',10,(void*)&phfc->portB);
sd=(void*)ftp200PORT;
sdlen=FTP200PORT_LEN;
goto send;
list:
ec=ftpLIST(ph);
if(ec>=0)
{
sd=(void*)ftp150; // Ready..
sdlen=FTP150_LEN;
goto send;
}
goto BAIL;
type:
c = *str++;if(c>='a'&&c<='z') c=c-'a'+'A';
if(c=='A')
sd=(void*)ftp200TYPEA;
else
sd=(void*)ftp200TYPEB;
sdlen=FTP200TYPE_LEN;
goto send;
syst:
// not done
sd=(void*)ftp215;
sdlen=FTP215_LEN;
goto send;
stor:
goto send;
pwd:
ec=ftpPWD(ph);
goto BAIL;
cwd:
buf = str;
buflen = nbr->bufLen;
buflen -= (memu)buf-(memu)nbr->buf;
if((ec=FsCurDir(0,1,buf,buflen))<0)
goto error;
sd=(void*)ftp200CWD;
sdlen=FTP200CWD_LEN;
goto send;
if(0)
{
error:
syntax:
sd=(void*)ftp500;
sdlen=FTP500_LEN;
send:
nb->buf=sd;
nb->bufLen=sdlen;
if((ec=NetPortAddSdBuf(ph,nb,flags))<0)
LOCKUP(BP_FTPRVCTL2);
nb=NUL;
} // send
ec=0;
BAIL:
if(nb)
ftpBufFree(nb);
return ec;
} // ftpRvCTL()
// JFL 04 Oct 04
int ftpNetBufFunc(NetPH *ph,uns cmd)
{
int ec;
NetPH *ph2;
NetBuf *nb2;
switch(cmd)
{
case NETPORTSTACK_SENT_AND_UNLINKED:
// NETBUF_UVAL_FTPLIST
if(!(ph2=ph->phOther))
{
LOCKUP(BP_FTPNETBUFFUNC1); // missing other
break;
}
if(ph2->port!=NETPORT_FTPCTL)
{
LOCKUP(BP_FTPNETBUFFUNC2); // must be control port
break;
}
if((ec=ftpBufGet(&nb2))<0)
{
LOCKUP(BP_FTPNETBUFFUNC3);
goto BAIL;
}
nb2->buf=(void*)ftp226;
nb2->bufLen=FTP226_LEN;
if((ec=NetPortAddSdBuf(ph2,nb2,0))<0)
LOCKUP(BP_FTPNETBUFFUNC4);
break;
} // switch
ec=0;
BAIL:
return ec;
} // ftpNetBufFunc()
///////////////////////////////////////////////////////////////////////////////
//
// JFL 01 Oct 04
int FTPLoop(void)
{
int ec;
sto args[NETPORTSTACK_ARGBUF_NUM];
NetPH *ph;
NetBuf *nb;
while((ec=NetPortPop(&ph,&args[0]))>0)
{
switch(ec)
{
case NETPORTSTACK_REMOTE_TRYING_TO_OPEN:
// respond
// create a receive buffer
if((ec=ftpBufGet(&nb))<0)
goto BAIL;
nb->bufSize=128;
if((ec=MemDAlloc(MEMPOOL_NET,nb->bufSize,&nb->buf))<0)
{
nb->bufSize=0;
LOCKUP(BP_FTPLOOP1);
}
else
nb->uflags|=M_NETBUF_UFLAGS_ALLOC;
NetPortAddRvBuf(ph,nb);
if(ph->port==NETPORT_FTPCTL)
{
if((ec=ftpBufGet(&nb))<0)
goto BAIL;
nb->buf=ftp200FTP;
nb->bufLen=FTP200FTP_LEN;
if((ec=NetPortAddSdBuf(ph,nb,0))<0)
LOCKUP(BP_FTPLOOP2);
} // ftpctl
break;// NETPORTSTACK_REMOTE_TRYING_TO_OPEN
case NETPORTSTACK_CLOSING:
if((ec=ftpBufGet(&nb))<0)
goto BAIL;
if((ec=NetPortAddSdBuf(ph,nb,0))<0)
LOCKUP(BP_FTPLOOP3);
break; // NETPORTSTACK_CLOSING
case NETPORTSTACK_UNLINKED:
nb=(void*)args[0]; // buf is unlinked
ftpBufFree(nb); // add it back into free list
break; // NETPORTSTACK_CLOSED_AND_UNLINKED
case NETPORTSTACK_RECEIVED_AND_UNLINKED:
nb=(void*)args[0]; // buf is unlinked
// buf of received data
if(ph->port==NETPORT_FTPCTL)
ftpRvCTL(ph,nb);
NetPortAddRvBuf(ph,nb); // pass it back to net system
break; // NETPORTSTACK_FILLED_AND_UNLINKED
case NETPORTSTACK_SENT_AND_UNLINKED:
nb=(void*)args[0]; // buf is unlinked
// buf has been sent
if(nb->uflags & M_NETBUF_UFLAGS_FUNC)
{
ftpNetBufFunc(ph,NETPORTSTACK_SENT_AND_UNLINKED);
ftpBufFree(nb); // add it back into free list
NetPortRem(ph);
ph->port=0;
}
else
{
ftpBufFree(nb); // add it back into free list
}
break; // NETPORTSTACK_SENT_AND_UNLINKED
case NETPORTSTACK_ERROR:
break; // NETPORTSTACK_ERROR
} // switch
} // while
ec=0;
BAIL:
return ec;
} // FTPLoop()
// EOF

18
dond/core/ftp.h Executable file
View File

@@ -0,0 +1,18 @@
#ifndef FTP_H
#define FTP_H
// net.h
// Copyright 2004 Play Mechanix Inc. All Rights Reserved
//
// JFL 08 Sep 04
///////////////////////////////////////////////////////////////////////////////
// SYSTEM INDEPENDENT
extern int FTPInit(void);
extern void FTPFinal(void);
extern int FTPReset(uns reset);
extern int FTPOpen(int open);
extern int FTPLoop(void);
#endif // ndef FTP_H

146
dond/core/gun.c Executable file
View File

@@ -0,0 +1,146 @@
// gun.c
// Play Mechanix - Video Game System
// Copyright (c) 2005 Play Mechanix Inc. All Rights Reserved
//
// JFL 24 Mar 05
#include "pm.h"
#include "mem.h"
#include "inp.h"
#include "cab.h"
#include "gun.h"
#include <jamma.h>
typedef struct {
int dummy;
} gunGlobals;
gunGlobals gunG;
// JFL 24 Mar 05
int GunInit(void)
{
return 0;
} // GunInit()
// JFL 24 Mar 05
int GunReset(uns reset)
{
MEMZ(gunG);
return 0;
} // GunReset()
// JFL 24 Mar 05
void GunFinal(void)
{
} // GunFinal()
// JFL 24 Mar 05
int GunSetXY(int guni,int x,int y)
{
CabGun *gun;
if(!(gun=CabGetGun(guni))) // get the gun
{BP(BP_GUNSETXY);return -1;}
gun->pos[0]=x;
gun->pos[1]=y;
gun->pos[2]=0;
gun->flags|=M_CABGUN_POSSET;
return 0;
} // GunSetXY()
// JFL 17 Feb 05
int GunOp(int op,int n,void *d,void *d2)
{
int ec;
int i,j;
CabGun *gun;
InpRec *ir;
switch(op&M_CABOP)
{
case GUNOP_SETGUNFUNCDATA:
gun=CabGetGun(n);
gun->gunfunc=d;
gun->gundata=d2;
break;
case GUNOP_SETGUNDATA:
gun=CabGetGun(n);
gun->gundata=d;
break;
case GUNOP_GUN_ON:
gun=CabGetGun(n);
gun->flags|=M_CABGUN_ON;
JammaOp(JAMMAOP_GUNONOFF,n,1);
if(!(ir=InpGet(0)))
break;
if(!n)
j=INPSW_G0_TRIGGER0;
else if(n==1)
j=INPSW_G1_TRIGGER0;
else
{
BP(BP_GUNOP1);
break;
}
// copy current trigger counts
for(i=0;i<CAB_TRIGGERS;i++)
gun->triggers[i]=ir->count[i+j];
break;
case GUNOP_GUN_OFF:
gun=CabGetGun(n);
gun->flags&=~M_CABGUN_ON;
JammaOp(JAMMAOP_GUNONOFF,n,0);
break;
case GUNOP_ALLGUNS_ON:
for(n=0;n<CAB_GUNS;n++)
{
gun=CabGetGun(n);
gun->flags|=M_CABGUN_ON;
JammaOp(JAMMAOP_GUNONOFF,n,1);
if(!(ir=InpGet(0)))
break;
if(!n)
j=INPSW_G0_TRIGGER0;
else if(n==1)
j=INPSW_G1_TRIGGER0;
else
{
BP(BP_GUNOP2);
continue;
}
// copy current trigger counts
for(i=0;i<CAB_TRIGGERS;i++)
gun->triggers[i]=ir->count[i+j];
} // for
break;
case GUNOP_ALLGUNS_OFF:
for(n=0;n<CAB_GUNS;n++)
{
gun=CabGetGun(n);
gun->flags&=~M_CABGUN_ON;
JammaOp(JAMMAOP_GUNONOFF,n,0);
} // for
break;
default:
BP(BP_GUNOP3);
err(-1);
} // switch
ec=0;
BAIL:
return ec;
} // GunOp()
// EOF

43
dond/core/gun.h Executable file
View File

@@ -0,0 +1,43 @@
#ifndef GUN_H
#define GUN_H
// gun.h
// Copyright 2005 Play Mechanix Inc. All Rights Reserved
//
// JFL 24 Mar 05
///////////////////////////////////////////////////////////////////////////////
//
//
// GUN -- this will be split into its own file soon..
//
enum {
GUNFUNC_NONE,
GUNFUNC_TRIG0, // (..,CabGun*,NUL,NUL)
GUNFUNC_TRIG1,
GUNFUNC_TRIG2,
};
#define M_GUNFUNC 0xff
#define M_GUNFUNC_TRIGDOWN 0x100
enum {
GUNOP_NONE,
GUNOP_SETGUNFUNCDATA,
GUNOP_SETGUNDATA,
GUNOP_GUN_ON,
GUNOP_GUN_OFF,
GUNOP_ALLGUNS_ON,
GUNOP_ALLGUNS_OFF,
};
#define M_GUNOP 0xff
// gun routines
extern int GunOp(int op,int n,void *d,void *d2);
extern int GunInit(void);
extern void GunFinal(void);
extern int GunReset(uns reset);
extern int GunTrigger(void *gun,uns n);
#endif // ndef GUN_H

1022
dond/core/inp.c Executable file
View File

File diff suppressed because it is too large Load Diff

233
dond/core/inp.h Executable file
View File

@@ -0,0 +1,233 @@
#ifndef INP_H
#define INP_H
// inp.h
// Copyright 2004 Play Mechanix Inc. All Rights Reserved
//
// JFL 18 Oct 04
///////////////////////////////////////////////////////////////////////////////
// SYSTEM INDEPENDENT
enum {
INP_GUN0,
INP_GUN1,
INP_GUNS,
};
enum {
INP_GUNTRIG0,
INP_GUNTRIG1,
INP_GUNTRIG2,
INP_GUNTRIGS,
};
enum {
INPLOWEVENT_NONE,
INPLOWEVENT_NOP,
INPLOWEVENT_MOUSE_LB_DOWN,
INPLOWEVENT_MOUSE_LB_UP,
INPLOWEVENT_MOUSE_CB_DOWN,
INPLOWEVENT_MOUSE_CB_UP,
INPLOWEVENT_MOUSE_RB_DOWN,
INPLOWEVENT_MOUSE_RB_UP,
INPLOWEVENT_MOUSE2_LB_DOWN,
INPLOWEVENT_MOUSE2_LB_UP,
INPLOWEVENT_MOUSE2_RB_DOWN,
INPLOWEVENT_MOUSE2_RB_UP,
INPLOWEVENT_MOUSE_MOVE_XY,
INPLOWEVENT_MOUSE_DELTA_Z,
INPLOWEVENT_P0_TRIG0_DOWN, // down
INPLOWEVENT_P0_TRIG0_UP, // before up assumed..
INPLOWEVENT_P0_TRIG1_DOWN,
INPLOWEVENT_P0_TRIG1_UP,
INPLOWEVENT_G0_RAW0_DOWN,
INPLOWEVENT_G0_RAW0_UP,
INPLOWEVENT_G1_RAW0_DOWN,
INPLOWEVENT_G1_RAW0_UP,
INPLOWEVENT_P0_L_DOWN,
INPLOWEVENT_P0_L_UP,
INPLOWEVENT_P0_R_DOWN,
INPLOWEVENT_P0_R_UP,
INPLOWEVENT_P0_U_DOWN,
INPLOWEVENT_P0_U_UP,
INPLOWEVENT_P0_D_DOWN,
INPLOWEVENT_P0_D_UP,
INPLOWEVENT_P0_U2_DOWN,
INPLOWEVENT_P0_U2_UP,
INPLOWEVENT_P0_D2_DOWN,
INPLOWEVENT_P0_D2_UP,
INPLOWEVENT_P0_START_DOWN,
INPLOWEVENT_P0_START_UP,
INPLOWEVENT_P1_TRIG0_DOWN,
INPLOWEVENT_P1_TRIG0_UP,
INPLOWEVENT_P1_TRIG1_DOWN,
INPLOWEVENT_P1_TRIG1_UP,
INPLOWEVENT_P1_START_DOWN,
INPLOWEVENT_P1_START_UP,
INPLOWEVENT_COIN1_DOWN,
INPLOWEVENT_COIN1_UP,
INPLOWEVENT_COIN2_DOWN,
INPLOWEVENT_COIN2_UP,
INPLOWEVENT_DIAG_DOWN,
INPLOWEVENT_DIAG_UP,
INPLOWEVENT_VOLUP_DOWN,
INPLOWEVENT_VOLUP_UP,
INPLOWEVENT_VOLDOWN_DOWN,
INPLOWEVENT_VOLDOWN_UP,
INPLOWEVENT_BILL_DOWN,
INPLOWEVENT_BILL_UP,
INPLOWEVENT_SERVICE_DOWN,
INPLOWEVENT_SERVICE_UP,
INPLOWEVENT_SYS_ESC_DOWN,
INPLOWEVENT_SYS_ESC_UP,
INPLOWEVENT_SYS_MODE_DOWN,
INPLOWEVENT_SYS_MODE_UP,
INPLOWEVENT_SYS_KEYS_DOWN,
INPLOWEVENT_SYS_KEYS_UP,
INPLOWEVENT_FLAGS,
INPLOWEVENT_GUNPOS,
};
#define M_INPLOWEVENT 0x00ff
#define M_INPLOWEVENT_SHF 0x0100
#define M_INPLOWEVENT_CTL 0x0200
#define M_INPLOWEVENT_ALT 0x0400
#define M_INP_MOUSE_LB 0x00000001
#define M_INP_MOUSE_CB 0x00000002
#define M_INP_MOUSE_RB 0x00000004
#define M_INP_MOUSE_MOVE_XY 0x00000008
#define M_INP_MOUSE_MOVE_Z 0x00000010
#define M_INP_P0_L 0x00000020
#define M_INP_P0_R 0x00000040
#define M_INP_P0_U 0x00000080
#define M_INP_P0_D 0x00000100
#define M_INP_P0_U2 0x00000200
#define M_INP_P0_D2 0x00000400
#define M_INP_ESC 0x00000800
#define M_INP_MODE 0x00001000
#define M_INP_KEYS 0x00002000
#define M_INP_SHF 0x00004000
#define M_INP_ALT 0x00008000
#define M_INP_CTL 0x00010000
#define M_INPREC_MOUSE 0x0001
#define M_INPREC_KEYBOARD 0x0002
#define M_INPREC_DONTCLEARKEYS 0x0004
#define M_INPREC_DIPSTATEVALID 0x0008
enum {
INPSW_NONE,
INPSW_P0_L,
INPSW_P0_R,
INPSW_P0_U,
INPSW_P0_D,
INPSW_P0_U2,
INPSW_P0_D2,
INPSW_P0_START,
INPSW_P1_START,
INPSW_MOUSE_LB,
INPSW_MOUSE_CB,
INPSW_MOUSE_RB,
INPSW_MOUSE2_LB,
INPSW_MOUSE2_RB,
INPSW_MODE,
INPSW_ESC,
INPSW_G0_TRIGGER0, // CabLoop() -- assumes order -- primary trigger
INPSW_G0_TRIGGER1, // CabLoop() -- reload
INPSW_G0_TRIGGER2, // CabLoop() -- rocket launcher (if ever)
INPSW_G1_TRIGGER0, // CabLoop() --
INPSW_G1_TRIGGER1, // CabLoop() --
INPSW_G1_TRIGGER2, // CabLoop() --
INPSW_G0_RAW0,
INPSW_G1_RAW0,
INPSW_COIN1,
INPSW_COIN2,
INPSW_DIAG, // aka 'test'
INPSW_VOLUP,
INPSW_VOLDOWN,
INPSW_BILL,
INPSW_SERVICE,
INPSW_NUM,
};
typedef struct {
uns count;
ftype6 *func; // int (ftype6)(int,void*);
} inpswFunc;
typedef struct {
N2 lnk;
uns16 flags;
uns8 keyi;
uns8 xx1;
crd mx;
crd my;
crd mz;
uns32 state;
uns32 change;
uns8 keys[32];
uns count[INPSW_NUM];
inpswFunc swfuncs[INPSW_NUM];
crd gunpos[3*INP_GUNTRIGS*INP_GUNS]; // xyz for each gun trigger
uns16 dipState; // only if M_INPREC_DIPSTATEVALID
} InpRec;
enum {
INPREC_NONE,
INPREC_GAME,
INPREC_DEBUG,
};
enum {
INPKEY_F1=0xf0,
INPKEY_F2,
INPKEY_F3,
INPKEY_F4,
INPKEY_F5,
INPKEY_F6,
INPKEY_F7,
INPKEY_F8,
INPKEY_F9,
INPKEY_F10,
INPKEY_F11,
INPKEY_F12,
INPKEY_FMAX,
};
#define INPKEY_IS_FKEY(c) (((uns8)(c))>=INPKEY_F1 && ((uns8)(c))<INPKEY_FMAX)
// gun & trigger number
#define INPGUNTRIG_POS(g,t) ((g*3*3)+(t*3))
///////////////////////////////////////////////////////////////////////////////
//
extern int InpInit(void);
extern void InpFinal(void);
extern int InpReset(uns reset);
extern InpRec* InpGet(uns id);
extern int InpLoop(void);
extern int InpLoopEnd(void);
extern void InpForceDipswitchRead(void);
enum {
INPOP_NONE,
INPOP_GETKEYS,
INPOP_KEYBOARD_ON,
INPOP_KEYBOARD_OFF,
INPOP_MOUSE_ON,
INPOP_MOUSE_OFF,
INPOP_SETSWITCHFUNC,
INPOP_FLUSH,
};
#define M_INPOP 0xff
#define M_INPOP_CLEARKEYS 0x0100
#define S_INPOP_N 12
#define M_INPOP_N 0xffff
extern int InpOp(InpRec *ir,uns op,char *buf,int bufsize);
extern int InpLowEvent();
extern int xInpLowScan(void);
#endif // ndef INP_H

51
dond/core/int.h Executable file
View File

@@ -0,0 +1,51 @@
#ifndef INT_H
#define INT_H
// int.h
// Copyright 1998-2004 Play Mechanix Inc. All Rights Reserved
//
// GNP 05 May 00
// JFL 26 Aug 04
#define CLOCKHZ 1000 // timer is millisecond resolution
#define CLOCK_MSECS_PER_TICK 1000/CLOCKHZ
#define CLOCK_TICKS_PER_SECOND CLOCKHZ
#define CLOCK_TICKS_PER_60HZ CLOCKHZ/60
#define INT60_PER_SECOND 57 //number of interrupts per second
#define INT60_PER_SECOND_FLT 57.0f //number of interrupts per second, float
#define INT60_PER_SECOND_INV 1.0f/INT60_PER_SECOND_FLT //number of interrupts per second inverted
#define INT60_PER_FRAME 1 //number of interrupts per frame
#define INT60_PER_FRAME_FLT 1.0f //number of interrupts per frame, float
#define INT60_PER_FRAME_INV 1.0f/INT60_PER_FRAME_FLT
///////////////////////////////////////////////////////////////////////////////
// SYSTEM DEPENDENT
//-----------------------------------------------------------------------------
// SYS_JP5500
#if SYS_JP5500
#define M_INT_VBLANK 0x0001
#define M_INT_IDE 0x0002
#define M_INT_RENDER 0x0004
#define M_INT_ETHERNET 0x0008
#define M_INT_SERIAL0 0x0010
extern volatile uns32 IntRawTick;
#endif // SYS_JP5500
//-----------------------------------------------------------------------------
///////////////////////////////////////////////////////////////////////////////
// SYSTEM INDEPENDENT
// extern routines
extern int IntInit(void);
extern void IntFinal(void);
extern int IntReset(uns reset);
extern int IntAttach(void);
extern void IntDetach(void);
extern void IntEnable(uns intMask,int enable);
#endif // ndef INT_H

217
dond/core/main.c Executable file
View File

@@ -0,0 +1,217 @@
// main.c
// Play Mechanix - Video Game System
// Copyright 1998-2004 Play Mechanix Inc. All Rights Reserved
//
// JFL 26 Aug 04
#include "pm.h"
#include "pm_vp.h"
#include "int.h"
#include "sys.h"
#include "mem.h"
#include "fs.h"
#include "fb.h"
#include "vid.h"
#include "draw.h"
#include "game.h"
#include "net.h"
#include "ftp.h"
#include "main.h"
// strings for time and date stamp of build
#define BUILD_TIME __TIME__
#define BUILD_DATE __DATE__
// notes --
//
// - isolate system dependencies to files (not #ifs or #ifdefs)
// file names -- use name_vp.c/h files and .s for assembly
// identifiers -- prepend an x to system specific identifiers
//
// - files & examples
// sys.h sets the primary system define (e.g. SYS_JP5500)
// include sys.h at the top of all .h files that need the system def
//
// example frame buffer module:
// fb.c for system independent code
// fb.h for system independent interface
// this file includes "sys.h" and uses #if SYS_JP5500 to present
// the system independent interface
// fb_vp.c contains the specific code for the VP
// fb_vp.h contains the interface info specifically for the VP
//
// - BREAK()
// a development breakpoint
// when hit, this macro will stop the program and pop up the debugger
// will always continue -- write code to handle this
// production version will log address & continue
// take these out as development continues
// production version will use LOCKUP()
//
// - LOCKUP()
// an error condition that should not happen
// when hit, this macro will stop the program and pop up the debugger
// will always continue -- write code to handle this
// production version will log address & continue
// will stay in for production versions
//
// - FATAL()
// an error condition that should not happen
// when hit, this macro will stop the program and pop up the debugger
// production version will log address
// will never continue
// production version will reset the system
//
// - keep system dependencies to named files
// using #if / #ifdef make code too confusing & hard to update
//
// - comments
// the big idea on what code is suppose to do
// keep the comments up to date
//
// - goal: fast startup
// - goal: fast load of data
//
// - nodes, linked lists
// use the N2 node typedef
// call the first link field lnk
//
// - easy to setup / transfer env to a new system
// minimize & document outside links to .h .lib .o
// minimize & document env vars
//
// - on return per function
// unless the function is extremely simple
// document at the bottom if function has multiple returns
//
// - every file starts with a block of DBG_ defines
// this are used in that file to turn code on/off
//
// - alignment
// if the alignment definition is a mask or begins with M_ then
// the alignment is guaranteed at (1+mask) bytes
// e.g. #define M_FF_ALIGN 0x1ff means alignment at 0x000, 0x200, 0x400, etc.
//
// - tabs
// tabsize=2 indentsize=2
//
// - init/final/reset
// the init function is called once at startup, final called once at shutdown
// the reset function is called to reset that module's state
// init --
// must be called first
// will not fail unless there is something catastrophically wrong
// does not assume any other modules have been initialized
// this means it does not call any other modules
// init is not meant to do anything except zero all the state info
//
// JFL 26 Aug 04
int main (int argc, char **argv)
{
int ec;
FsH fhmem;
FfH ffmem;
uns32 i,u;
void *abuf;
//
// GUARANTEED INITS
//
SysWatchdogDisable();
MEMZ(fhmem);
MEMZ(ffmem);
//
// INIT ALL SYSTEMS
//
ec=0;
if(SysInit()<0) ec=1;
if(IntInit()<0) ec=1;
if(MemInit()<0) ec=1;
if(FsInit()<0) ec=1;
if(FbInit()<0) ec=1;
if(VidInit()<0) ec=1;
if(DrawInit()<0) ec=1;
if(VidMovieInit()<0) ec=1;
if(NetInit()<0) ec=1;
if(FTPInit()<0) ec=1;
if(GameInit()<0) ec=1;
if(ec)
goto BAIL;
//
// RESET ALL SYSTEMS TO THEIR NORMAL STATE
//
if(MemReset(0)<0) ec=1;
if(SysReset(0)<0) ec=1;
if(IntReset(0)<0) ec=1;
if(FsReset(0)<0) ec=1;
if(FbReset(0)<0) ec=1;
if(VidReset(0)<0) ec=1;
if(DrawReset(0)<0) ec=1;
if(NetReset(0)<0) ec=1;
if(FTPReset(0)<0) ec=1;
if(ec)
goto BAIL;
//
// STARTUP
//
if((ec=IntAttach())<0)
goto BAIL;
// check dipswitch for screen mode
u = ~((uns32)(*DIPS1_ADDR));
i = u&M_DIPS1_SYNC;
u &= M_DIPS1_RESOLUTION;
u >>= S_DIPS1_RESOLUTION;
u++;
if(u>=FB_NUM_RESOLUTION)
{
LOCKUP();
u=FB_RESOLUTION_320x240;
}
if((ec=FbSetMode(u,i))<0)
goto BAIL;
if((ec=VidStart())<0)
goto BAIL;
//
// ENABLE INTERRUPTS
//
IntEnable(M_INT_SERIAL0|M_INT_VBLANK|M_INT_IDE|M_INT_RENDER|M_INT_ETHERNET,1);
xSysIntEnable();
//
//
//
GameLoop();
//
//
//
BAIL:
IntEnable(~0,0);
GameFinal();
FTPFinal();
NetFinal();
VidMovieFinal();
VidFinal();
FbFinal();
FsFinal();
MemFinal();
IntFinal();
SysFinal();
return ec;
} // main()
// EOF

956
dond/core/mem.c Executable file
View File

@@ -0,0 +1,956 @@
// mem.c
// Play Mechanix - Video Game System
// Copyright (c) 2004 Play Mechanix Inc. All Rights Reserved
//
// JFL 26 Aug 04
#include "pm.h"
#include "str.h"
#include "mem.h"
MemSysInfoRec MemSysInfo;
extern unsigned char *MemHeap;
#define ALIGN_MEM_4BYTE (3) //make sure memory is aligned on M_ALIGN_MEM+1 byte boundry
#define ALIGN4BYTE(ADR) ((((long) ADR) + ALIGN_MEM_4BYTE) & ~ALIGN_MEM_4BYTE)
///// DOC BLOCK ///////////////////////////////////////////////////////////////
//
// all sizes are in bytes
// allocations must align & pad memory their own memory
//
// this system handles all types of memory
// and presents a common interface to the game
//
// there are different conceptual types of memory
// the type of memory may be physically different or may just be a concept
// in any case, the memory type is the functional descriptor used
// heap memory
// this is a block of CPU memory for general use
// this is always present
// video image memory
// video palette memory
// sound buffer memory
//
// a memory pool is a block of continuous memory
// pools are defined depending on the target system and game requirements
// this system supports management of any number of pools
//
// ability of each pool to reset its memory
//
// MemTotal[] is an aligned array of bytes
//
///////////////////////////////////////////////////////////////////////////////
struct {
uns reset;
uns map;
} memG;
//
// STACK
//
//
// memS
// stack memory
//
// GNP 25 May 00
// JFL 22 Sep 04
typedef struct
{
memu low;
memu high;
memu levelBot[MEM_SAVEPOINTS];
memu levelTop[MEM_SAVEPOINTS];
} memS;
//
// FIFO
//
// MemF
//
// JFL 22 Sep 04
typedef struct {
memu low;
memu high;
memu oldest;
memu next;
} memF;
//
// DYNAMIC
//
//
// MN_
// dynamic memory node
//
// GNP 01 Jun 00
//
typedef struct
{
uns32 link; // link is very specialized
} MN;
typedef uns32 MN_WORD;
#define S_MNLINK_NEG 16
#define M_MNLINK_POS 0x7fff
#define M_MNLINK_USED 0x8000
#define M_MNLINK_UPOS 0xffff
#define MN_SIZE sizeof(MN)/sizeof(MN_WORD)
#define MN_MINSIZE MN_SIZE*2
#define MN_MINSPLIT 3+MN_SIZE*2
//
// MemD
// dynamic memory pool structure
//
// GNP 25 May 00
// JFL 26 Aug 04
typedef struct
{
memu low;
memu high;
memu startp;
memu startn;
} memD;
///////////////////////////////////////////////////////////////////////////////
// MEM MAPS
enum {
MEMKIND_STACK,
MEMKIND_FIFO,
MEMKIND_DYN,
MEMKIND_MAX
};
typedef struct {
struct {
memu mem;
uns size;
} pool[MEMPOOL_MAX];
} memMap;
///////////////////////////////////////////////////////////////////////////////
// MEMMAP_STARTUP
// the idea behind this memory map
// MEMPOOL_HEAP
// MEMPOOL_VID
// MEMPOOL_NET
// MEMPOOL_PERM
// MEMPOOL_WAVE
// MEMPOOL_SUBW
// memMap[] defines the memory pool structure
// the following defines define how much each pool gets
// MEMHEAP_SIZE is in mem.h & defines total memory grabbed by system
// N1_HEAP gets everything left over
#define N1_TOT MEMHEAP_SIZE // in mem.h
#define N1_HEAP (N1_TOT-N1_VID-N1_NET-N1_PERM-N1_WAVE-N1_SUBW)
#define N1_VID (1024+256)*KBYTES
#define N1_NET 1*KBYTES
#define N1_PERM 4*MBYTES
#define N1_WAVE 12*MBYTES
#define N1_SUBW 1*MBYTES
memMap memMaps[MEMMAP_MAX];
// - memMapsDim contains the offset and size of each memory pool
int memMapsDim[MEMPOOL_MAX * 2] = {
0x000000, N1_HEAP,
N1_HEAP, N1_VID,
N1_HEAP+N1_VID, N1_NET,
N1_HEAP+N1_VID+N1_NET, N1_PERM,
N1_HEAP+N1_VID+N1_NET+N1_PERM, N1_WAVE,
N1_HEAP+N1_VID+N1_NET+N1_PERM+N1_WAVE, N1_SUBW
};
//
// memory pool names as character strings for info
//
char memPoolNames[MEMPOOL_MAX][4] =
{
"HP ",
"VID",
"NET",
"PRM",
"WAV",
"SWV",
};
///////////////////////////////////////////////////////////////////////////////
//
uns8 memPoolMap[MEMPOOL_MAXMAP-MEMPOOL_MAP];
///////////////////////////////////////////////////////////////////////////////
// forwards
int memDPoolFirstNode(memD* mempoolp,memu low,memu high);
int memDynPAlloc(memD* mempoolp,uns32 size, void **memp);
int memDynFree(memD* mempoolp,MN_WORD *mem);
int memDynCheck(memD* mempoolp,uns32 *availp,uns32 *usedp,uns32 *countp);
static memS memSPool[MEMPOOL_MAX];
static memF memFPool[MEMPOOL_MAX];
static memD memDPool[MEMPOOL_MAX];
// JFL 26 Aug 04
int MemInit(void)
{
int i;
MemHeap = malloc(sizeof(unsigned char) * MEMHEAP_SIZE);
// - read the offset and size data for each memory pool
for (i = 0; i < MEMPOOL_MAX; i++)
{
memMaps[MEMMAP_STARTUP].pool[i].mem = (memu)(MemHeap + memMapsDim[(i * 2) + 0]);
memMaps[MEMMAP_STARTUP].pool[i].size = memMapsDim[(i * 2) + 1];
}
MEMZ(memG);
MEMZ(memSPool);
MEMZ(memFPool);
MEMZ(memDPool);
MEMZ(memPoolMap);
MEMZ(MemSysInfo);
return 0;
} // MemInit()
// JFL 26 Aug 04
void MemFinal(void)
{
free(MemHeap);
} // MemFinal()
// JFL 22 Sep 04
// JFL 30 Dec 04; level
int MemPoolReset(uns pool,uns reset)
{
uns stack;
memu memu;
memMap *mm;
int k;
mm=&memMaps[0];
// free/reset all memory
// find start & end of pool
memu = mm->pool[pool].mem;
stack = mm->pool[pool].size;
// setup for stack
memSPool[pool].low=memu;
memu+=stack;
memSPool[pool].high=memu;
for(k=0;k<MEM_SAVEPOINTS;k++)
{
memSPool[pool].levelBot[k]=0;
memSPool[pool].levelTop[k]=0;
} // for
// reset fifo & dyn pools
MEMZ(memFPool[pool]);
MEMZ(memDPool[pool]);
return 0;
} // MemPoolReset()
// JFL 26 Sep 04
int MemReset(uns reset)
{
int i;
memG.reset=reset;
for(i=0;i<MEMPOOL_MAX;i++)
MemPoolReset(i,reset);
if(!reset)
{
for(i=0;i<(MEMPOOL_MAXMAP-MEMPOOL_MAP);i++)
memPoolMap[i]=0;
}
return 0;
} // MemReset()
// JFL 30 Dec 04
// JFL 02 Feb 05
int MemStackRestore(int savepoint)
{
int pool;
memu top,bot;
if((savepoint<0)||(savepoint>=MEM_SAVEPOINTS))
{BP(BP_MEMSTACKRESTORE);return -1;}
// the idea is to reset the stack memory for this pool
// to the top of the lower level (i.e. reset at this level)
for(pool=0;pool<MEMPOOL_MAX;pool++)
{
bot=memSPool[pool].levelBot[savepoint];
top=memSPool[pool].levelTop[savepoint];
memSPool[pool].low=bot;
memSPool[pool].high=top;
} // for
return 0;
} // MemStackRestore()
// JFL 30 Dec 04
// JFL 02 Feb 05
int MemStackSave(int savepoint)
{
int pool;
memu low,high;
if((savepoint<0)||(savepoint>=MEM_SAVEPOINTS))
{BP(BP_MEMSTACKSAVE);return -1;}
// save at this level
for(pool=0;pool<MEMPOOL_MAX;pool++)
{
low=memSPool[pool].low;
high=memSPool[pool].high;
memSPool[pool].levelBot[savepoint]=low;
memSPool[pool].levelTop[savepoint]=high;
} // for
return 0;
} // MemStackSave()
// JFL 14 Oct 04
int MemPoolMap(uns pool,uns mapto)
{
if(pool<=MEMPOOL_MAP || pool>=MEMPOOL_MAXMAP)
return -1;
if(mapto>=MEMPOOL_MAX)
return -2;
memPoolMap[pool-MEMPOOL_MAP]=mapto;
return 0;
} // MemPoolMap()
// JFL 02 Feb 05
int MemInfo(char *buf,int bufSize)
{
int ec,pool;
uns32 s,avail,count,used,total;
if(!buf || !bufSize)
return 1;
buf[0]=0;
total=0;
for(pool=0;pool<MEMPOOL_MAX;pool++)
{
if((s=memSPool[pool].high-memSPool[pool].low))
{
total+=s;
szbuild(buf,bufSize,"<-cat>%s %x %x\n",memPoolNames[pool],
memSPool[pool].low,memSPool[pool].high);
}
else
{
szbuild(buf,bufSize,"<-cat>%s (empty) %x\n",memPoolNames[pool],
memSPool[pool].low);
}
} // for
szbuild(buf,bufSize,"<-cat>stack: avail=%x\n",total);
total=0;
for(pool=0;pool<MEMPOOL_MAX;pool++)
{
if((ec=memDynCheck(&memDPool[pool],&avail,&used,&count))<0)
{
szbuild(buf,bufSize,"<-cat>%s (empty) %x\n",memPoolNames[pool],
memDPool[pool].low);
}
else
{
szbuild(buf,bufSize,"<-cat>%s %x %x %x\n",memPoolNames[pool],
avail,used,count);
total+=avail;
}
} // for
szbuild(buf,bufSize,"<-cat>dynamic: avail=%x\n",total);
szbuild(buf,bufSize,"<-cat>jps: o=%x c=%d l=%x\n",
MemSysInfo.jpsOutstanding,MemSysInfo.jpsCount,MemSysInfo.jpsLargest);
return 0;
} // MemInfo()
///////////////////////////////////////////////////////////////////////////////
//
// JFL 26 Aug 04
void MemZero(void *mem,uns size)
{
while(size--)
((char*)mem)[size]=0;
} // MemZero()
// JFL 28 Oct 04
void MemCopy(void *dst,void *src,uns size)
{
while(size--)
((uns8*)dst)[size]=((uns8*)src)[size];
} // MemCopy()
///////////////////////////////////////////////////////////////////////////////
// STACK ALLOCATOR
//
// MemSLow
// allocate static memory from the bottom of the stack
//
// in:
// pool = memory pool from which to allocate
// size = size of allocation in bytes
// *memp = ptr for return
// out:
// global:
//
// JFL 26 Aug 04
// GNP 30 Nov 05; always align size to 4 bytes
//
int MemSLow(uns pool,uns size,void *memp)
{
memu mem;
// stack based alloc from low end
if(pool>MEMPOOL_MAP)
pool=memPoolMap[pool-MEMPOOL_MAP];
size = ALIGN4BYTE(size);
mem=memSPool[pool].low;
if(mem+size>memSPool[pool].high)
return ERR_MEM_ALLOC;
memSPool[pool].low+=size;
*((void**)memp)=(void*)mem;
return 0;
//DONE("MemSLow")
} // MemSLow
//
// MemSHigh
// allocate static memory from the top of the stack
//
// in:
// pool = memory pool from which to allocate
// size = size of allocation in bytes
// *memp = ptr for return
// out:
// global:
//
// JFL 26 Aug 04
// GNP 30 Nov 05; always align size to 4 bytes
//
int MemSHigh(uns pool,uns size,void *memp)
{
memu mem;
// stack based alloc from high end
if(pool>MEMPOOL_MAP)
pool=memPoolMap[pool-MEMPOOL_MAP];
size = ALIGN4BYTE(size);
mem=memSPool[pool].high-size;
if(mem<memSPool[pool].low)
return ERR_MEM_ALLOC;
memSPool[pool].high=mem;
*((void**)memp)=(void*)mem;
return 0;
//DONE("MemSHigh")
} // MemSHigh
// JFL 26 Aug 04
void* MemSLowGet(uns pool)
{
if(pool>MEMPOOL_MAP)
pool=memPoolMap[pool-MEMPOOL_MAP];
// get stack low pointer
return (void*)memSPool[pool].low;
} // MemSLowGet()
// JFL 26 Aug 04
void MemSLowSet(uns pool,void *mem)
{
if(pool>MEMPOOL_MAP)
pool=memPoolMap[pool-MEMPOOL_MAP];
// set stack low pointer
memSPool[pool].low = (memu)mem;
} // MemSLowSet()
// JFL 26 Aug 04
void* MemSHighGet(uns pool)
{
if(pool>MEMPOOL_MAP)
pool=memPoolMap[pool-MEMPOOL_MAP];
// get stack high pointer
return (void*)memSPool[pool].high;
} // MemSHighGet()
// JFL 26 Aug 04
void MemSHighSet(uns pool,void *mem)
{
if(pool>MEMPOOL_MAP)
pool=memPoolMap[pool-MEMPOOL_MAP];
// set stack high pointer
memSPool[pool].high = (memu)mem;
} // MemSHighSet()
// JFL 22 Sep 04
uns MemSAvail(uns pool)
{
if(pool>MEMPOOL_MAP)
pool=memPoolMap[pool-MEMPOOL_MAP];
return memSPool[pool].high-memSPool[pool].low;
} // MemSAvail()
///////////////////////////////////////////////////////////////////////////////
// DYNAMIC ALLOCATOR
// JFL 22 Sep 04
int MemDSetup(uns pool,void *mem,uns size)
{
if(pool>MEMPOOL_MAP)
{
LOCKUP(BP_MEMDSETUP); // don't use mapped pools here..
pool=memPoolMap[pool-MEMPOOL_MAP];
}
return memDPoolFirstNode(&memDPool[pool],(memu)mem,(memu)&((uns8*)mem)[size]);
} // MemDSetup()
// JFL 22 Sep 04
int MemDAlloc(uns pool,uns size,void *memp)
{
if(pool>MEMPOOL_MAP)
pool=memPoolMap[pool-MEMPOOL_MAP];
return memDynPAlloc(&memDPool[pool],size,memp);
} // MemDAlloc()
// JFL 22 Sep 04
int MemDAlloz(uns pool,uns size,void *memp)
{
int ec;
if(pool>MEMPOOL_MAP)
pool=memPoolMap[pool-MEMPOOL_MAP];
if((ec=memDynPAlloc(&memDPool[pool],size,memp))>=0)
{
MemZero(*((void**)memp),size);
}
return ec;
} // MemDAlloz()
// JFL 22 Sep 04
int MemDFree(uns pool,void *mem)
{
if(pool>MEMPOOL_MAP)
pool=memPoolMap[pool-MEMPOOL_MAP];
return memDynFree(&memDPool[pool],mem);
} // MemDFree()
//
// memDPoolFirstNode
// all necessary setup for the dynamic system for the given pool
// does not link the node into the list of 'user' pools
//
// in:
// low = low address of pool
// high = high address of pool
// mempoolp = ptr to dynamic memory pool
// out:
// <0 error
// ~
//
// GNP 01 Jun 00
// JFL 22 Sep 04
int memDPoolFirstNode(memD* mempoolp,memu low,memu high)
{
int16 ec;
MN* mnp;
uns32 size;
uns32 len;
uns32 prev;
MN_WORD* memt;
// initialize boundries
// force alignment
low+=3;
low&=~3;
high&=~3;
mempoolp->low = low;
mempoolp->startp = low;
mempoolp->high = high;
mnp = (MN*)mempoolp->high;
mnp--;
mempoolp->startn = (memu)mnp;
// setup 1st node
size = mempoolp->high - mempoolp->low;
size >>= 2; // size in MN_WORDSIZE words
if (size < MN_MINSIZE)
{
LOCKUP(BP_MEMDPOOLFIRSTNODE);
err(ERR_MEM_POOL_EMPTY);
}
size -= MN_SIZE; // room for first node
memt = (void*)mempoolp->low;
prev = 0;
for (;size>0;size -= len)
{
size -= MN_SIZE; // room for next node
len=size;
if (len > M_MNLINK_POS)
len = M_MNLINK_POS;
mnp = (MN*)memt;
mnp->link = len|prev; // (neg:pos)
memt += (len + MN_SIZE);
prev = len<<S_MNLINK_NEG; // neg:0
} // for
if(size)
{
LOCKUP(BP_MEMDPOOLFIRSTNODE2); // size must be zero at end
// do something here to patch memory..
}
mnp = (MN*)memt;
mnp->link = prev; // (neg:0)
ec=0;
BAIL:
return ec;
} // memDPoolFirstNode()
//
// memDynPAlloc
// system call, use memd_alloc
// allocate a block of memory of given size
//
// in:
// size = bytes (must be MN_WORDSIZE aligned)
// memp = handle to memory ptr
// mempoolp = ptr to dynamic memory pool
// out:
// <0 = fail
// global:
//
// GNP 04 Jun 00
// JFL 22 Sep 04
int memDynPAlloc(memD* mempoolp,uns32 size,void **memp)
{
int16 ec;
uns32 mnlink;
uns32 mnlinkc;
MN_WORD* memt;
if (!mempoolp->startp)
err(ERR_MEM_POOL_NOT_INITIALIZED);
size+=3;size>>=2; // size into MN_WORDSIZE
if (size > M_MNLINK_POS)
err(ERR_MEM_ALLOC); // bigger than max size of block
memt = (void*) mempoolp->startp;
for (mnlink=((MN*)memt)->link;;
memt += (mnlink + MN_SIZE),mnlink=((MN*)memt)->link)
{
mnlinkc = mnlink;
mnlink &= M_MNLINK_POS; // size of block
if (!mnlink)
break; // end of list
if (mnlinkc & M_MNLINK_USED)
continue; // block currently in use
if (mnlink > size)
goto MDPA_PROCESS_NODE_LEFT; // block large enough
} // for
// end of list in positive direction reached
// no node found, try other direction from where we started
memt = (void*)mempoolp->startp;
for (mnlinkc=((MN*)memt)->link;mnlinkc;)
{
mnlinkc >>= S_MNLINK_NEG;
if (!mnlinkc)
break; // end of list
memt -= (mnlinkc + MN_SIZE); // back-up to previous node
mnlink = mnlinkc = ((MN*)memt)->link;
if (mnlink & M_MNLINK_USED)
continue; // block currently in use
mnlink &= M_MNLINK_POS;
if (mnlink > size)
goto MDPA_PROCESS_NODE_RIGHT; // block big enough
} // for
// error, no node found
*memp = NUL;
err(ERR_MEM_ALLOC); // no memory of requested size found
// we have node, determine what to do
// mnlink = size of found node
MDPA_PROCESS_NODE_RIGHT:
mnlink -= (size+MN_SIZE); // size of remaining space
if (mnlink < MN_MINSPLIT)
goto MDPA_SUCCESS_RIGHT; // too small to split, possible little hole here
// left node is unused part
mnlinkc = ((MN*)memt)->link;
mnlinkc &= ~M_MNLINK_UPOS;
((MN*)memt)->link = mnlinkc | mnlink;
// middle node, returned
memt += mnlink+MN_SIZE;
mnlinkc = (mnlink<<S_MNLINK_NEG) | M_MNLINK_USED | size;
((MN*)memt)->link = mnlinkc;
*memp = memt + MN_SIZE; // return memory ptr
// next starting is middle
mempoolp->startn = (memu)memt; // next start
// right node
memt += size+MN_SIZE;
mnlinkc = size<<S_MNLINK_NEG;
mnlinkc += (((MN*)memt)->link & M_MNLINK_UPOS);
((MN*)memt)->link = mnlinkc;
goto MDPA_SUCCESS;
MDPA_SUCCESS_RIGHT:
*memp = memt + MN_SIZE; // return memory ptr
((MN*)memt)->link |= M_MNLINK_USED; // set block in-use
goto MDPA_SUCCESS;
// node found while travelling in a positive direction
// return pointer to memory. split block by adding
// and MNLINK after size of memory requested. update
// n field of MNLINK for block after.
// if block is too small to split (i.e. there is no
// room for adding an MNLINK, then do not split.
//
// mnlink = size of found node
// memt = ptr to block
MDPA_PROCESS_NODE_LEFT:
*memp = memt + MN_SIZE; // return memory ptr
((MN*)memt)->link |= M_MNLINK_USED; // set block in-use
mnlink -= (size+MN_SIZE); // remaining size of block
if (mnlink < MN_MINSPLIT)
goto MDPA_SUCCESS; // too small to split, possible little hole here
// left node
mnlinkc = ((MN*)memt)->link; // current n:p
mnlinkc &= ~M_MNLINK_POS; // n:0
mnlinkc |= (size|M_MNLINK_USED); // n:p and in-use
((MN*)memt)->link = mnlinkc;
// find address of new node
memt += (size + MN_SIZE);
// next starting is middle
mempoolp->startp = (memu)memt; // next start
// middle node, currently free
mnlinkc = size << S_MNLINK_NEG; // n:0
mnlinkc |= mnlink; // n:p
((MN*)memt)->link = mnlinkc;
// right node
memt += mnlink+MN_SIZE; // next node
mnlink <<= S_MNLINK_NEG; // n:0
mnlinkc = ((MN*)memt)->link;
mnlinkc &= M_MNLINK_UPOS; // 0:p
((MN*)memt)->link = mnlinkc | mnlink; // n:p
// we are done
MDPA_SUCCESS:
ec=0;
BAIL:
return ec;
} // memDynPAlloc
//
// memDynFree
//
//
// in:
// mem = memory to be free'd
// mempoolp = ptr to dynamic memory pool
// out:
// <0 = fail
// global:
//
// GNP 05 Jun 00
// JFL 22 Sep 04
int memDynFree(memD* mempoolp,MN_WORD *memt)
{
MN_WORD* nodesave;
MN_WORD* nodelow;
MN_WORD* nodehigh;
uns32 mnlink;
uns32 size;
uns32 nsize;
memt -= MN_SIZE;
nodesave = nodehigh = nodelow = memt;
// clear in-use bit
mnlink = ((MN*)memt)->link;
((MN*)memt)->link = mnlink & ~M_MNLINK_USED;
// try to join free node with next (right)
size = mnlink & M_MNLINK_POS;
memt += (size + MN_SIZE);
mnlink = ((MN*)memt)->link;
// if next node is not in-use
if (!(mnlink & M_MNLINK_USED))
{
// join two nodes if new node will not be too large
nsize = mnlink & M_MNLINK_POS;
if ( nsize && ((size + nsize + MN_SIZE) <= M_MNLINK_POS))
{
// link free
nsize += size+MN_SIZE;
mnlink = ((MN*)nodesave)->link & ~M_MNLINK_POS;
((MN*)nodesave)->link = mnlink | nsize;
// link right
memt = nodesave + nsize + MN_SIZE;
nsize <<= S_MNLINK_NEG;
mnlink = ((MN*)memt)->link & M_MNLINK_UPOS;
((MN*)memt)->link = mnlink | nsize;
nodehigh = memt;
}
} // if
// try to join free node with previous (left)
mnlink = ((MN*)nodesave)->link; // re-load in case size changed
size = mnlink & M_MNLINK_POS;
// if end of list not reached
if ((mnlink >>= S_MNLINK_NEG))
{
memt = nodesave - mnlink - MN_SIZE; // previous node
nsize = ((MN*)memt)->link;
if (!(nsize & M_MNLINK_USED))
{
nsize &= M_MNLINK_POS;
nsize += size+MN_SIZE;
// if new node is not too large for system
if (nsize < M_MNLINK_POS)
{
// link left
nodelow = memt;
mnlink = ((MN*)memt)->link & ~M_MNLINK_UPOS; //n:0
((MN*)memt)->link = mnlink | nsize; //n:p
// link free
memt += nsize + MN_SIZE; // next node
nsize <<= S_MNLINK_NEG;
mnlink = ((MN*)memt)->link & M_MNLINK_UPOS;
((MN*)memt)->link = mnlink | nsize;
nodehigh = memt;
}
}
} // if
if (mempoolp->startn < (memu)nodehigh)
mempoolp->startn = (memu)nodehigh;
if (mempoolp->startp > (memu)nodelow)
mempoolp->startp = (memu)nodelow;
return 0;
} // memDynFree
//
// memDynCheck
// scan dynamic pool
//
// in:
// mempoolp = ptr to dynamic memory pool
// out:
// <0 = fail
// global:
//
// JFL 02 Feb 05
int memDynCheck(memD* mempoolp,uns32 *availp,uns32 *usedp,uns32 *countp)
{
int16 ec;
uns32 avail,used,count;
uns32 mnlink;
uns32 mnlinkc;
MN_WORD* memt;
if (!mempoolp->startp)
err(ERR_MEM_POOL_NOT_INITIALIZED);
avail=used=count=0;
memt = (void*) mempoolp->startp;
for (mnlink=((MN*)memt)->link;;
memt += (mnlink + MN_SIZE),mnlink=((MN*)memt)->link)
{
mnlinkc = mnlink;
mnlink &= M_MNLINK_POS; // size of block
count++;
if (!mnlink)
break; // end of list
if (mnlinkc & M_MNLINK_USED)
used+=mnlink;
else
avail+=mnlink;
} // for
if(availp)
*availp=avail;
if(usedp)
*usedp=used;
if(countp)
*countp=count;
ec=0;
BAIL:
return ec;
} // memDynCheck
// EOF

89
dond/core/mem.h Executable file
View File

@@ -0,0 +1,89 @@
#ifndef MEM_H
#define MEM_H
// mem.h
// Copyright 1998-2004 Play Mechanix Inc. All Rights Reserved
//
// GNP 05 May 00
// JFL 26 Aug 04
///////////////////////////////////////////////////////////////////////////////
// SYSTEM DEPENDENT
#ifndef SYS_H
#include "sys.h"
#endif // ndef SYS_H
///////////////////////////////////////////////////////////////////////////////
// SYSTEM INDEPENDENT
// memory sizes in bytes (1MB=0x100000)
#define KBYTES 1024
#define MBYTES 1024*1024
#define MEMHEAP_SIZE 64*MBYTES
enum {
// pools of memory
MEMPOOL_HEAP,
MEMPOOL_VID,
MEMPOOL_NET,
MEMPOOL_PERM,
MEMPOOL_WAVE,
MEMPOOL_SUBW,
MEMPOOL_MAX,
// remapped pools
MEMPOOL_MAP=0x80,
MEMPOOL_RES,
MEMPOOL_OBJ,
MEMPOOL_MAXMAP
};
enum {
// memory maps for different requirements
MEMMAP_STARTUP,
MEMMAP_GAME,
MEMMAP_MAX
};
#define MEM_SAVEPOINTS 16
extern int MemInit(void);
extern void MemFinal(void);
extern int MemReset(uns reset);
extern int MemInfo(char *buf,int bufSize);
extern int MemStackRestore(int savepoint);
extern int MemStackSave(int savepoint);
extern int MemPoolMap(uns pool,uns mapto);
#define MemCpy MemCopy
extern void MemCopy(void *dst,void *src,uns size);
extern void MemZero(void *mem,uns size);
#define MEMZ(_mem_) MemZero(&(_mem_),sizeof(_mem_))
extern int MemPoolReset(uns pool,uns reset);
// stack allocator
extern int MemSLow(uns pool,uns size,void *memp);
extern int MemSHigh(uns pool,uns size,void *memp);
extern void* MemSLowGet(uns pool);
extern void MemSLowSet(uns pool,void *mem);
extern void* MemSHighGet(uns pool);
extern void MemSHighSet(uns pool,void *mem);
extern uns MemSAvail(uns pool);
// dynamic allocator
extern int MemDAlloc(uns pool,uns size,void *memp);
extern int MemDAlloz(uns pool,uns size,void *memp);
extern int MemDFree(uns pool,void *mem);
extern int MemDSetup(uns pool,void *mem,uns size);
typedef struct
{
int jpsOutstanding;
int jpsCount;
int jpsLargest;
} MemSysInfoRec;
extern MemSysInfoRec MemSysInfo;
#endif // ndef MEM_H

12
dond/core/mem_data.c Executable file
View File

@@ -0,0 +1,12 @@
// mem_data.c
// Play Mechanix - Video Game System
// Copyright (c) 2004 Play Mechanix Inc. All Rights Reserved
//
// JFL 22 Sep 04
#include "pm.h"
#include "mem.h"
unsigned char *MemHeap;
// EOF

36
dond/core/msg.h Executable file
View File

@@ -0,0 +1,36 @@
#ifndef MSG_H
#define MSG_H
// msg.h
// Copyright 2005 Play Mechanix Inc. All Rights Reserved
//
// JFL 09 Feb 05
///////////////////////////////////////////////////////////////////////////////
// SYSTEM INDEPENDENT
enum {
MSGSUB_NONE,
MSGSUB_COL,
MSGSUB_MAX
};
typedef struct {
N2 lnk;
} Msg;
enum {
MSGCOLFUNC_NONE,
MSGCOLFUNC_CI, // (-,ObjColAct*,ObjColInfo*,NUL)
};
typedef struct {
N2 lnk;
uns8 flags;
uns8 xx1;
uns16 xx2;
void *cola; // ObjColAct
void *block; // ResDataCBXZMM
void *poly; // ResDataCBPoly
} MsgColInfo;
#endif // MSG_H

112
dond/core/net.h Executable file
View File

@@ -0,0 +1,112 @@
#ifndef NET_H
#define NET_H
// net.h
// Copyright 2004 Play Mechanix Inc. All Rights Reserved
//
// JFL 08 Sep 04
///////////////////////////////////////////////////////////////////////////////
// SYSTEM DEPENDENT
// ----------------------------------------------------------------------------
// SYS_JP5500
#if SYS_JP5500
typedef struct {
uns8 sys[256]; // must start with system memory
uns16 port;
uns16 flags;
void *p1;
void *phOther;
} NetPH;
extern int net_intenable(int enable);
extern int net_inthandler(void);
#endif // SYS_JP5500
// ----------------------------------------------------------------------------
// ----------------------------------------------------------------------------
// SYS_PC SYS_BB
#if SYS_PC|SYS_BB
typedef struct {
uns8 sys[256]; // must start with system memory
uns16 port;
uns16 flags;
void *p1;
void *phOther;
} NetPH;
#endif // SYS_PC|SYS_BB
// ----------------------------------------------------------------------------
///////////////////////////////////////////////////////////////////////////////
// SYSTEM INDEPENDENT
// rfc 1700 "Port Assignments"
#define NETPORT_FTPDAT 20
#define NETPORT_FTPCTL 21
#define NETPORTSTACK_ARGBUF_NUM 8
enum {
NETPORTSTACK_EMPTY,
NETPORTSTACK_ERROR,
NETPORTSTACK_REMOTE_TRYING_TO_OPEN,
NETPORTSTACK_CLOSING,
NETPORTSTACK_RECEIVED_AND_UNLINKED,
NETPORTSTACK_SENT_AND_UNLINKED,
NETPORTSTACK_UNLINKED,
};
enum {
NETPORTINFO_NONE,
NETPORTINFO_OFF_THEIRIP,
NETPORTINFO_OFF_THEIRMAC,
};
enum {
NETBUFSTATE_NONE,
NETBUFSTATE_READYTOREAD,
NETBUFSTATE_READYTOSEND,
NETBUFSTATE_SENDING,
NETBUFSTATE_WAITINGFORACK,
NETBUFSTATE_FILLING,
NETBUFSTATE_FILLED,
NETBUFSTATE_DONESENDING,
};
#define M_NETPORTADD_FIN 0x01
typedef struct {
N2 lnk;
uns8 state; // state
uns8 sflags; // system flags
uns8 uflags; // user flags
uns8 uval; // user value
uns8 *buf; // buffer
uns bufLen; // len of data in buffer
uns bufSize; // size of buffer
mtime stateTime;
uns32 seqLo; // seq start if sending
uns32 seqHi; // seq end if sending, ack needed if receiving
} NetBuf;
#define M_NETPORTADD_SENDBACK 0x0001
extern int NetInit(void);
extern void NetFinal(void);
extern int NetReset(uns reset);
extern int NetLoop(void);
extern int NetPortAddListener(NetPH *ph,uns port,uns flags);
extern int NetPortAddSender(NetPH *ph,uns port,uns flags,uns8 *dmac,uns8 *dip,uns16 dport);
extern int NetPortRem(NetPH *ph);
extern int NetPortAddRvBuf(NetPH *ph,NetBuf *nb);
extern int NetPortAddSdBuf(NetPH *ph,NetBuf *nb,uns flags);
extern int NetPortRemBuf(NetPH *ph,NetBuf *nb);
extern int NetPortPop(NetPH **php,sto *argbuf);
extern int NetPortInfo(NetPH *ph,uns info);
#endif // ndef NET_H

2729
dond/core/obj.c Executable file
View File

File diff suppressed because it is too large Load Diff

774
dond/core/obj.h Executable file
View File

@@ -0,0 +1,774 @@
#ifndef OBJ_H
#define OBJ_H
// obj.h
// Copyright 2004 Play Mechanix Inc. All Rights Reserved
//
// JFL 08 Oct 04
///////////////////////////////////////////////////////////////////////////////
// SYSTEM INDEPENDENT
// see ADDING NEW OBJ TYPES
enum {
// must match resObjSubTable[], resObjSubSizes[]
OBJSUB_NONE,
OBJSUB_FRAMESTART,
OBJSUB_FORCEFRAMEEND,
OBJSUB_CAM,
OBJSUB_STR,
OBJSUB_TEXT,
OBJSUB_FUNC,
OBJSUB_DISPRES,
OBJSUB_IMGRES,
OBJSUB_VIDRES,
OBJSUB_STARTSORTBUF,
OBJSUB_DRAWSORTBUF,
OBJSUB_ANIRES,
OBJSUB_COLDEF,
OBJSUB_SKELRES,
OBJSUB_COLRES,
OBJSUB_BUF,
OBJSUB_SEQRES,
OBJSUB_LIGHTRES, // 0x10
OBJSUB_MARKER,
OBJSUB_VEL,
OBJSUB_COLACT,
OBJSUB_GROUP,
OBJSUB_DISPSAVE,
OBJSUB_DRAWSHADOWS,
OBJSUB_UNKNOWN,
OBJSUB_EMIT,
OBJSUB_PARTICLES,
OBJSUB_LOD,
OBJSUB_MAX
// must match resObjSubTable[], resObjSubSizes[]
};
#define OBJSUB_TMPLINK OBJSUB_UNKNOWN
enum {
OBJL2_PROJECTILE, // collision
OBJL2_BOUNCER, // collision
OBJL2_EMIT, // emitter
OBJL2_PARTICLES, // update & draw particles
OBJL2_NUM
};
#define M_OBJL2 0xff
#define OBJL2_FIRST_COLLISION OBJL2_PROJECTILE
#define OBJL2_LAST_COLLISION OBJL2_BOUNCER
// careful about using M_N2 fields
#if M_N2_TYPE != 0x0f00
#error -- type uses 4 bits of flags
these are flags the type can share with the N2 structure
o->lnk.flags
you must be careful when using these flags to only use those
flags set in the M_N2_TYPE define
search on M_N2 to find all uses
#endif // M_N2_TYPE
#define OBJ_LIST_DEPTH 4
#define M_N2OBJ_RESOLVED 0x0100 // shared using M_N2_TYPE
#define M_N2OBJ_PUSHPOPMAT 0x0400 // shared using M_N2_TYPE
typedef struct {
N2 lnk;
} Obj;
typedef struct {
N2 lnk;
char name[PM_SHORTNAME_SIZE];
} ObjGroup;
#define M_OBJFRAMESTART_CLEAR 0x01
#define M_OBJFRAMESTART_DONTEND 0x02
typedef struct {
N2 lnk;
uns16 flags;
uns8 r,g,b,a;
float depth;
} ObjFrameStart;
typedef struct {
N2 lnk;
uns16 sortNum;
uns16 xx1;
uns32 sortBufSize;
uns32 sortBufLow;
uns32 sortBufHigh;
uns8 *sortBufStart;
void *sortBufSave;
} ObjStartSortBuf;
#define M_OBJCAM_OFFSPLINE 0x0001
#define M_OBJCAM_ORTHO 0x0002
#define M_OBJCAM_NOZ 0x0004
#define M_OBJCAM_ADDED 0x0008
#define M_OBJCAM_SIMPLE 0x0010
#define M_OBJCAM_CLEARZ 0x0020
#define M_OBJCAM_GHOSTCAM 0x0040
#define M_OBJCAM_GHOSTSAVED 0x0080
#define M_OBJCAM_USEVM 0x0100
#define M_OBJCAM_DONTFRUST 0x0200
#define M_OBJCAM_FRUSTVALID 0x0400
typedef struct {
N2 lnk;
void *res; // if based on res
char name[PM_SHORTNAME_SIZE];
// set by user
uns16 flags;
uns16 xx2;
float fov;
float orthoWidth;
float orthoHeight;
float clipNear;
float clipFar;
crd rot[3];
crd trans[3];
crd vm[VM_SIZE];
crd shake[3];
crd vertFrust[3*FRUSTVERT_NUM];
crd nrmkFrust[4*CLIP_NUM]; // nrmk
} ObjCam;
#define M_OBJSTR_HASALPHA 0x01
typedef struct {
N2 lnk;
char name[PM_SHORTNAME_SIZE];
uns8 flags;
uns8 xx1;
uns16 xx2;
uns32 texGen;
float user[4];
float xyadj[2];
float wh[2]; // width & height of string in camera coords
float scale[2];
uns16 numc;
uns16 maxc;
// followed by ObjStrChar
} ObjStr;
typedef struct {
uns32 rgb;
float user[2];
float xyadj[2];
float uvbox[BOX_SIZE]; // top left right bottom
float verts[3*2]; // x0,y0,z0 .. x1,y1,z1 (topleft bottomright)
} ObjStrChar;
#define M_OBJLIGHTRES_SHADPOS 0x0001
#define M_OBJLIGHTRES_NOLIGHT 0x0002
#define M_OBJLIGHTRES_SHADDIR 0x0004
typedef struct {
N2 lnk;
void *res; // if based on res
uns flags;
} ObjLightRes;
typedef struct {
N2 lnk;
char name[PM_SHORTNAME_SIZE];
char *str;
int16 box[4];
uns16 flags;
uns16 n;
uns16 size;
} ObjText;
typedef struct {
N2 lnk;
char name[PM_SHORTNAME_SIZE];
void *func; // pointer to function
uns8 ftype; // type of function -- see pm.h ftype
uns8 k;
uns16 n;
void *d;
} ObjFunc;
#define M_OBJDISPRES_MIPMAP 0x00001
#define M_OBJDISPRES_DONTLIGHT 0x00002 // dont light
#define M_OBJDISPRES_DISPCOL 0x00004 // collide against display geometry
#define M_OBJDISPRES_SKELCOL 0x00008 // collide against skelcol geometry
#define M_OBJDISPRES_PROPCOL 0x00010 // collide against propcol geometry
#define M_OBJDISPRES_NOAUTOANI 0x00020 // dont automatically attach anim
#define M_OBJDISPRES_NOAUTOCOL 0x00040 // dont automatically attach col
#define M_OBJDISPRES_LIGHT 0x00080 // light normals & flag set by artist
#define M_OBJDISPRES_FLASHRGB 0x00100 // flash solid color
#define M_OBJDISPRES_FLASHNOLIGHT 0x00200 // flash w/o light
#define M_OBJDISPRES_SAVE 0x00400 // save disp info
#define M_OBJDISPRES_HASTMPLINK 0x00800 // has ObjTmpLink imm following
#define M_OBJDISPRES_AFTERSHADOWS 0x01000 // draw this after the shadows
#define M_OBJDISPRES_FRUSTOUT 0x02000 // outside of camera frustrum
#define M_OBJDISPRES_BLEND 0x04000 // use alpha in rgba
#define M_OBJDISPRES_NOFOG 0x08000 // dont fog
#define M_OBJDISPRES_SORTEDONCE 0x10000 // "sort once" object has been sorted
#define M_OBJDISPRES_HASLOD 0x20000 // has LODs
#define M_OBJDISPRES_ZALWAYS 0x40000 // set Z buffer to always draw (currenty limited to Draw2 attached to Draw3)
typedef struct {
N2 lnk;
void *res;
uns32 flags;
uns8 tag;
uns8 rgba[4];
uns8 curBlend;
uns32 dList; // display list index
} ObjDispRes;
typedef struct {
N2 tmpLnk; // not a permanent link -- changes every frame, not initialized
void *data;
} ObjTmpLink;
#define M_OBJDISPSAVE_SET 0x0001 // stuffed with valid data
#define M_OBJDISPSAVE_BIND 0x0002 // concatenate bind matrix
#define M_OBJDISPSAVE_SINGLE 0x0004 // single mat
typedef struct {
N2 lnk;
// used to save info about draw state
// currently only used for saving skeleton joint matrices
// but can be expanded to save any info about the draw
uns16 flags;
uns16 numJoints;
float *bindMats;
float *jointMats;
} ObjDispSave;
typedef struct {
N2 lnk;
void *res;
} ObjImgRes;
typedef struct {
N2 lnk;
void *res;
} ObjVidRes;
#define M_OBJANIRES_LOOP 0x00000001
#define M_OBJANIRES_DONTLOOP 0x00000002
#define M_OBJANIRES_FREEZENEXT 0x00000004
#define M_OBJANIRES_FROZEN 0x00000008
#define M_OBJANIRES_DONE 0x00000010
#define M_OBJANIRES_ENDKILL 0x00000020
#define M_OBJANIRES_KILLPRIME 0x00000040 // kill prime obj (parent) on exit
#define M_OBJANIRES_ROOT 0x00000080
#define M_OBJANIRES_SKEL 0x00000100
#define M_OBJANIRES_GCOL 0x00000200
#define M_OBJANIRES_NOSCALE 0x00000800
#define M_OBJANIRES_NOPITCH 0x00001000
#define M_OBJANIRES_SNAPONCE 0x00002000
#define M_OBJANIRES_BLENDONCE 0x00004000
#define M_OBJANIRES_SYNC 0x00008000
#define M_OBJANIRES_BRIDGE 0x00010000
#define M_OBJANIRES_MOVED 0x00020000 // not a user flag
#define M_OBJANIRES_BLEND2ADD 0x00040000 // not a user flag
#define M_OBJANIRES_CHANGE 0x00080000 // not a user flag
#define M_OBJANIRES_HITEND 0x00100000 // anim looped, cleared when changing
#define M_OBJANIRES_FROZENTIME 0x00200000
#define M_OBJANIRES_SKIPTO 0x00400000
#define M_OBJANIRES_BLENDING 0x00800000
#define M_OBJANIRES_BLEND2 0x01000000
#define M_OBJANIRES_SLEEPCB 0x02000000
#define M_OBJANIRES_JUMP 0x04000000
enum {
OAR_CH_RX, // assumed 1st for now
OAR_CH_RY,
OAR_CH_RZ,
OAR_CH_TX,
OAR_CH_TY,
OAR_CH_TZ,
OAR_CH_SX,
OAR_CH_SY,
OAR_CH_SZ,
OAR_CH_N
};
#define M_OAR_CH_R ((1<<OAR_CH_RX)|(1<<OAR_CH_RY)|(1<<OAR_CH_RZ))
#define M_OAR_CH_T ((1<<OAR_CH_TX)|(1<<OAR_CH_TY)|(1<<OAR_CH_TZ))
#define M_OAR_CH_S ((1<<OAR_CH_SX)|(1<<OAR_CH_SY)|(1<<OAR_CH_SZ))
typedef struct {
N2 lnk;
void *res; // points to resource
char name[PM_NAME_SIZE];
uns32 flags;
crd cur[9]; // rx,ry,rz,tx,ty,tz,sx,sy,sz
float aniTime0; // time base for start of ani
float speed; // multiplier -- 0==1
float skipAdj;
// primary animation
void *kan;
void *key0; // source 'from'
void *key1; // target 'to'
float fcGameAcc; // accumulated length
float fcGameLen; // speed-adjusted length of current segment
float fcGameInv; // 1/sofarLen
float fcAnimAcc; //
float fcAnimLen; // original segment length
float fcLoopAcc;
float fcLoopCount;
float frameCount; // updated every loop with current/transient value
// blend animation
void *abKan;
void *abKey0;
void *abKey1;
float abTime0;
float abGameAcc;
float abGameLen;
float abGameInv;
float abBlendInv;
float abBlendTime0;
// second blend animation
void *b2Kan;
void *b2Key0;
void *b2Key1;
float b2Time0;
float b2GameAcc;
float b2GameLen;
float b2GameInv;
float b2BlendInv;
float b2BlendTime0;
crd pitch; // shouldn't need extra field
crd rmax; // rot max per millisecond
float aTime; // animation time parameter
float bTime; // animation time parameter
float aRamp; // animation ramp parameter
void *nextKan;
} ObjAniRes;
#define OBJSEQRES_CB_NUM 6
typedef struct {
N2 lnk;
void *res;
char name[PM_NAME_SIZE];
uns32 flags; // use M_OBJANIRES_
void *sigdata;
uns32 time0; // start GameWaveTime
uns32 hold; // hold till
void* key0;
void* signalAbort; // abort adr for signal
void* cleanupSeq; // cleanup adr for the sequence
void* everyLoop; // seq to call every loop
memu cb[OBJSEQRES_CB_NUM]; // callback memory
uns lptSwitchCount[24]; // callback memory for lpt switches
} ObjSeqRes;
#define M_OBJVEL_SCALE 0x0001
#define M_OBJVEL_OFF 0x0002
#define M_OBJVEL_SETMAT 0x0004
#define M_OBJVEL_IGNORE 0x0008
#define M_OBJVEL_JOINTATTACH 0x0010
#define M_OBJVEL_GCOL 0x0020
#define M_OBJVEL_NOPITCH 0x0040
typedef struct {
N2 lnk;
char name[PM_SHORTNAME_SIZE];
crd rot[3];
crd trans[3];
crd scale[3];
uns16 flags;
uns16 attachNum;
uns32 velTime0; // time base
float accTime; // accumulated time
float maxTime;
float t; // time used in calcs
crd rvel[3];
crd tvel[3];
crd racc[3];
crd tacc[3];
float pitch; // used when deer are off splines
float rmax; // rot max per millisecond
} ObjVel;
#define M_OBJEMIT_CAPTURENEXT 0x01 // capture
#define M_OBJEMIT_CAPTUREVALID 0x02 // vm has been (re)captured
#define M_OBJEMIT_CALLIFVALID 0x04 // call the func if capture is valid
#define M_OBJEMIT_CALLINLINE 0x08 // call the func if obj is hit inline
#define M_OBJPART_FIRSTTIME 0x01
typedef struct {
N2 lnk;
N2 l2lnk; // L2 link -- must immediately follow lnk
uns16 flags;
uns16 game; // field is open for use by the game
char name[PM_SHORTNAME_SIZE];
crd vm[VM_SIZE];
void* func;
} ObjEmit;
typedef struct {
N2 lnk;
N2 l2lnk; // L2 link -- must immediately follow lnk
uns16 flags;
uns8 partType; // type of particles -- depends on function
uns8 xx1;
char name[PM_NAME_SIZE];
void* func;
int nFree;
int nDisp;
int nPart;
int nMaxDisp;
int nMaxPart;
void *disps;
void *parts;
} ObjParticles;
typedef struct {
void *disp;
} ObjPartDisp;
#define M_OBJEMITEACHPARTICLE_ACTIVE 0x0001
typedef struct {
uns8 flags;
uns8 partnum;
uns16 xx1;
crd trans[3];
crd tvel[3];
crd tacc[3];
crd scale; // 0 == no scale
uns8 rgba[4];
void *disp;
float tStopTime; // max stop time of this particle
float t; // last t of this particle
} ObjPartEachPart;
typedef struct {
N2 lnk;
void *res; // points to resource
uns16 flags;
uns16 numJoints;
float *jointMats;
float *bindMats;
void *rootDriver; // could be: oar ov
} ObjSkelRes;
typedef struct {
N2 lnk;
uns16 flags;
uns16 xx1;
void *res; // ResDataCol*
} ObjColRes;
enum {
OBJCOLDEFTYPE_NONE,
OBJCOLDEFTYPE_BASE,
OBJCOLDEFTYPE_TEXT,
OBJCOLDEFTYPE_GND,
};
#define M_OBJCOLDEFTYPE 0xff
typedef struct {
uns8 type; // must match
uns8 flags; // must match
uns16 len; // must match
} ObjColDefBase;
typedef struct {
uns8 type; // must match objColDefBase
uns8 flags; // must match objColDefBase
uns16 len; // must match objColDefBase
// this record is good for text/wrapped text
int16 boxBig[BOX_SIZE]; // the whole text box
int16 boxTop[BOX_SIZE]; // the top line
int16 boxBot[BOX_SIZE]; // the bottom line
void *p;
void *d;
} ObjColDefText;
typedef struct {
uns8 type; // must match objColDefBase
uns8 flags; // must match objColDefBase
uns16 len; // must match objColDefBase
void *d; // ptr to resource
} ObjColDefGnd;
// this is the 'head' structure, followed by any number of the above..
#define M_OBJCOLDEF_DONTRESET 0x01
typedef struct {
N2 lnk;
char name[PM_SHORTNAME_SIZE];
uns16 size;
uns16 next;
uns16 flags;
uns16 xx1;
} ObjColDef;
typedef struct {
N2 lnk;
char name[PM_SHORTNAME_SIZE];
uns32 size;
uns32 next;
} ObjBuf;
typedef struct {
N2 lnk;
char name[PM_SHORTNAME_SIZE];
uns flags;
int id;
} ObjMarker;
#define M_OBJCOLACT_HIT 0x0001 // this cola has hit something
#define M_OBJCOLACT_COLFUNC 0x0002 // has col function
#define M_OBJCOLACT_USEVEL 0x0004 // use vel ext, pos, dir&len=tvel
#define M_OBJCOLACT_XYZR 0x0008 // use xyzr
#define M_OBJCOLACT_HITSKELCOL 0x0010 // hit skelcol
#define M_OBJCOLACT_HITPROPCOL 0x0020 // hit propcol
#define M_OBJCOLACT_HITGNDCOL 0x0030 // hit gndcol
#define M_OBJCOLACT_HITCRITCOL 0x0040 // hit critcol -- skeleton objs w/o collision geo
#define M_OBJCOLACT_HITENUM 0x0070
#define M_OBJCOLACT_HITFLAGS (M_OBJCOLACT_HIT|M_OBJCOLACT_HITENUM)
#define M_OBJCOLACTVS_GND 0x01 // versus
#define M_OBJCOLACTVS_ANIMALS 0x02 // versus
#define M_OBJCOLACTVS_PROPS 0x04 // versus
typedef struct {
N2 lnk;
N2 l2lnk; // L2 link -- must immediately follow lnk
// used to run the collision tests
uns16 flags; // all fields are keyed off of these flags & invalid otherwise
uns8 vsflags;
uns8 pnum;
crd pos[3];
crd dir[3];
crd len;
crd xyzr[4]; // in world space
// successful best collision info
crd cpos[3]; // collision point
crd cnrm[3]; // collision normal
crd clen; // length of collision
uns16 cnum; // group number of collision
void *cobj; // object of collision
void *cdata; // polygon of collsion
void *ctype; // type info
ftype4 *colfunc;
int cjointnum;
crd cjointoff[3];
uns32 maxTime; // kill prime after this time
uns32 time0; // jjj -- get rid of -- defunct
crd vpos[3]; // where
ObjVel *ov;
crd xyzo[3]; // in object space
} ObjColAct;
enum {
OBJCOLFUNC_NONE,
OBJCOLFUNC_MCI, // (-,ObjColAct*,MsgColInfo*,NUL)
OBJCOLFUNC_COLA, // (-,ObjColAct*,NUL,NUL)
// return codes
OBJCOLFUNC_STOP=0x1000, // stop processing
};
#define M_OBJCOLFUNC 0xff
#define M_OBJNEW_DONTLINK 0x0000
#define M_OBJNEW_LINKACTIVE 0x0001 // enum
#define M_OBJNEW_LINKAFTER 0x0002 // enum
#define M_OBJNEW_LINKBEFORE 0x0003 // enum
#define M_OBJNEW_LINKCOL 0x0004 // enum
#define M_OBJNEW_LINKLIST 0x000f // enum
#define M_OBJNEW_KIDS 0x0020
#define M_OBJNEW_KIDFIRST 0x0040
#define M_OBJNEW_KIDSFIRST M_OBJNEW_KIDFIRST
#define M_OBJNEW_DONTCLEAR 0x0080
#define NUM_LOD 3 // number of LOD levels supported
#define LOD_DIST0 35.0
#define LOD_DIST1 60.0
#define LOD_DIST2 500000.0
//
// LOD
// level of detail entry
//
typedef struct {
float dist; // max distance from camera to show this LOD (if 0, LOD not active)
void *dispRes; // display resource to use for this LOD
void *skelRes; // skeleton information to use for this LOD (NULL = no skel)
} LOD;
//
// ObjLOD
// LOD information node for object
//
typedef struct {
N2 lnk;
int cur; // current LOD level
void *curDispRes; // current display resource ptr
void *curSkelRes; // current skeleton resource ptr
uns baseNumJoints; // number of joints in the initial object (for sanity check)
LOD lod[NUM_LOD];
} ObjLOD;
extern int ObjInit(void);
extern void ObjFinal(void);
extern int ObjReset(uns reset);
extern int ObjNew(void *objp,uns sub,uns size,uns flags);
#define M_OBJLOOP_DUMMY 0x0001
extern int ObjLoop(uns flags);
extern int ObjOnce(Obj *o);
extern void* ObjActiveFirst(void);
extern int ObjActiveCount(void);
extern void* ObjL2First(uns n);
extern void ObjL2Link(uns n,void *o);
extern void ObjL2Reset(uns n);
extern void* ObjColFirst(void);
extern int ObjColCount(void);
extern int ObjKillDisp(ObjDispRes *odr);
extern int ObjCamResStart(ObjCam *cam,void *r,uns flags);
extern int ObjSkelAddAnims(ObjSkelRes *ani,void *r);
extern ObjCam* ObjCamCur(void);
extern void* ObjFindDispRes(char *name);
void *ObjFindSub(Obj *obj, uns subtype);
#define ObjFindLOD(o) ObjFindSub((Obj*)o,OBJSUB_LOD)
#define ObjFindSkelRes(o) ObjFindSub((Obj*)o,OBJSUB_SKELRES)
extern int ObjAddLOD(ObjDispRes *pObj, void *vLodRes, int lodLevel);
enum {
OBJANICMD_NONE,
OBJANICMD_START,
OBJANICMD_DETACH,
OBJANICMD_HOLD,
OBJANICMD_STEP,
OBJANICMD_RUN,
OBJANICMD_FLAGS,
OBJANICMD_SETNEXT,
OBJANICMD_SETBLENDADD,
OBJANICMD_SKIPTO,
OBJANICMD_SKIP,
};
#define M_OBJANICMD 0x000000ff
#define M_OBJANICMD_LOOP 0x00000100
#define M_OBJANICMD_ZERO 0x00000200
#define M_OBJANICMD_SNAP 0x00000400
#define M_OBJANICMD_BRIDGE 0x00000800
#define M_OBJANICMD_SYNC 0x00001000
#define M_OBJANICMD_ATIME 0x00002000
#define M_OBJANICMD_BTIME 0x00004000
#define M_OBJANICMD_REMOVELOOP 0x00008000
#define M_OBJANICMD_RAMP 0x00010000
#define M_OBJANICMD_CHKDEAD 0x00020000
extern int ObjAniRoot(void *o,void *r,uns cmd,float f1,void *oarp);
extern int ObjAniBody(void *o,void *r,uns cmd,float f1);
extern int ObjAniSeq(ObjSeqRes *osr,void *r,uns cmd);
extern int ObjAniResSwitch(ObjAniRes *ani,void *r);
extern int ObjSeqStart(N2 *nlink,void *r,void *objp);
extern int ObjSeqBranch(ObjSeqRes *osr,void *adr);
extern int ObjAddCol(ObjColDef *col);
extern void* ObjGetCol(uns size,uns flags,void *colp);
extern void* ObjColScanXY(int x,int y);
extern int ObjColScanGnd(ObjColAct *cola);
extern void ObjColLoop(void);
extern int ObjIsSub(void *o,uns8 subtype);
extern int ObjKill(void *o);
extern int ObjLevelKill(int level);
extern int ObjKillBetween(void *v0,void *v1);
extern int ObjHideBetween(void *hideobjp,void *v0,void *v1);
extern int ObjUnhideAfter(void *hideobj,void *unhideafter);
enum {
OBJCULL_NONE,
OBJCULL_SKIPON,
OBJCULL_SKIPOFF,
};
#define M_OBJCULL 0xff
extern int ObjCull(uns op);
extern int ObjTagKill(int tag);
extern int ObjLoopEnd(void);
extern int ObjSetLinkName(char *name);
extern void* ObjFindLinkName(char *name);
extern int ObjSetLinkObj(void *o);
extern void* ObjGetLinkObj(void);
extern int ObjGetRTS(void *o,crd *rot,crd *trans,crd *scale);
extern int ObjGetRTVels(void *o,crd *rvel,crd *tvel);
extern int ObjAniKanProject(ObjAniRes *oar,float wavetime,
crd *rot,crd *trans,crd *scale);
extern int ObjSkelSplineToVel(void *prime,uns flags,ObjVel **ovp);
#define M_OBJSIGNAL 0x0fff
#define M_OBJSIGNAL_IMMEDIATE 0x1000
extern int ObjSignal(void *o,int sig,void *a);
extern int ObjTagSignal(int tag,int sig,void *a);
extern void ObjColaVel(void *cola,void *vel);
extern int ObjAniChange(ObjAniRes *oar,void *kan,float wavetime);
extern int ObjSeqGetVars(ObjSeqRes *osr,memu **varsp);
extern int ObjResolveDisp(ObjDispRes *odr);
extern int ObjResolveTex(ObjDispRes *odr,uns flags);
#define M_OBJJOINTMIRROR_ISLEFT 0x01
typedef struct {
char *jname1;
char *jname2;
crd dir[3];
uns flags;
} ObjJointMirrorRec;
extern int ObjJointMirror(void *odr,ObjJointMirrorRec *ojm,int showonleftside,
int *np,crd *off);
extern int ObjJointLR(void *odr,ObjJointMirrorRec *ojm,int n,crd *off);
extern char *ObjColTypeStr(void *objv,char **s2p);
extern char *ObjNameStr(void *objv,char **s2p);
#define M_OBJANIGET_BODY 0x01
#define M_OBJANIGET_ROOT 0x02
extern int ObjAniGetFrame(void *o,float *f1p,uns flags);
extern char* ObjAniGetName(void *o,uns flags);
#if DEBUG
extern int DbgObjJointNames(void *odr);
#endif // DEBUG
#endif // ndef OBJ_H

920
dond/core/pm.h Executable file
View File

@@ -0,0 +1,920 @@
#ifndef PM_H
#define PM_H
// env overrides -- go writable to change these..
#if 0 // overrides
#undef SAFE
#define SAFE 0
#undef DEBUG
#define DEBUG 0
#endif // overrides
// pm.h
// Play Mechanix - Video Game System
// Copyright 1998-2005 Play Mechanix Inc. All Rights Reserved
//
// GNP 04 May 00
// JFL 26 Aug 04
// JFL 07 Oct 04
///// DOC BLOCK ///////////////////////////////////////////////////////////////
//
// This is the 'root' of the system.
// set the system define in the proprocessor: SYS_JP5500, SYS_PC
//
///////////////////////////////////////////////////////////////////////////////
#if !(SYS_JP5500|SYS_PC|SYS_BB)
#error -- need to define SYS_XX in preprocessor
#endif
#if !SYS_GL
#error -- define SYS_GL in preprocessor
#endif
///////////////////////////////////////////////////////////////////////////////
// BASE TYPES
//-----------------------------------------------------------------------------
// SYS_JP5500
#if SYS_JP5500
// Play Mechanix base types & system
typedef signed char int8;
typedef unsigned char uns8;
typedef signed short int16;
typedef unsigned short uns16;
typedef signed long int32;
typedef unsigned long uns32;
typedef unsigned long long uns64;
typedef signed long long int64;
typedef int8 int2;
typedef uns8* ptr;
typedef float f32;
typedef unsigned int uns;
typedef uns sto; // unsigned, big enough for void*,float,int
typedef uns memu;
#define NUL ((void*)0)
#ifndef NULL
#define NULL ((void*)0)
#endif
#define M_STRUCT_ALIGN 3
#define SYSBREAK() __asm("Break")
// game types for this system
typedef uns32 mtime; // millisecond timer
typedef float crd; // coordinates -- assumed to be float
#endif // SYS_JP5500
// SYS_JP5500
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
// SYS_PC
#if SYS_PC
// Play Mechanix base types & system
typedef signed char int8;
typedef unsigned char uns8;
typedef signed short int16;
typedef unsigned short uns16;
typedef signed long int32;
typedef unsigned long uns32;
typedef __int64 int64;
typedef unsigned __int64 uns64;
typedef int8 int2;
typedef uns8* ptr;
typedef float f32;
typedef unsigned int uns;
typedef uns sto; // unsigned, big enough for void*,float,int
typedef uns memu;
typedef int memi;
#define NUL ((void*)0)
#ifndef NULL
#define NULL ((void*)0)
#endif
#define FLOAT_NAN 0x7FBFFFFF
#define DOUBLE_NAN 0xFFFFFFFF7FF7FFFF
#define SKIRT_NOTHIT FLOAT_NAN
#define M_STRUCT_ALIGN 3
#define SYSBREAK() __asm {int 3}
// game types for this system
typedef uns32 mtime; // millisecond timer
typedef float crd; // coordinates
#define CRD_IS_FLOAT 1
#pragma warning(disable:4244) // conversion from 'double ' to 'float '
#pragma warning(disable:4305) // truncation from 'const double ' to 'float '
#define __STR2__(x) #x
#define __STR1__(x) __STR2__(x)
#define __LOC__ __FILE__ "("__STR1__(__LINE__)") "
#endif // SYS_PC
// SYS_PC SYS_BB
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
// SYS_BB
#if SYS_BB
// Play Mechanix base types & system
typedef signed char int8;
typedef unsigned char uns8;
typedef signed short int16;
typedef unsigned short uns16;
typedef signed long int32;
typedef unsigned long uns32;
typedef long long int64;
typedef unsigned long long uns64;
typedef int8 int2;
typedef uns8* ptr;
typedef float f32;
typedef unsigned int uns;
typedef uns sto; // unsigned, big enough for void*,float,int
typedef uns memu;
typedef int memi;
#define NUL ((void*)0)
#ifndef NULL
#define NULL ((void*)0)
#endif
#define FLOAT_NAN 0x7FBFFFFF
#define DOUBLE_NAN 0xFFFFFFFF7FF7FFFF
#define SKIRT_NOTHIT FLOAT_NAN
#define M_STRUCT_ALIGN 3
#define SYSBREAK() __asm__ ("int $3")
// game types for this system
typedef uns32 mtime; // millisecond timer
typedef float crd; // coordinates
#define CRD_IS_FLOAT 1
#define FALSE 0
#define TRUE 1
#endif // SYS_BB
// SYS_BB
//-----------------------------------------------------------------------------
///////////////////////////////////////////////////////////////////////////////
// TRAP MACROS
extern void* SysAdr(void);
//extern void SysLockup(void);
extern void SysLockup(int);
extern uns8 SysPMBreakpointBehavior;
// notes:
// there are 2 main defines that must be set or clear: DEBUG SAFE
// DEBUG=0 for production
// SAFE set to 0 by this code
// DEBUG=1 for debugging
// SAFE=1 for extra checking
// SAFE=0 for no extra checking
#if DEBUG // --- DEBUG -------------------------------------------
#define SAFE 1
#define LOCKUP(x) SYSBREAK()
#define BP(x) {if(!SysPMBreakpointBehavior) SYSBREAK();}
#define FATAL() SYSBREAK()
#else // --- not DEBUG ----------------------------------------------
#define SAFE 0
#define LOCKUP(x) SysLockup(x)
#define BP(x) SysLockup(x)
#define FATAL() SysLockup(SysAdr())
#endif // --- not DEBUG ---------------------------------------------
///////////////////////////////////////////////////////////////////////////////
// MACROS
#define DONE(x) BAIL:
#define DONEZ(x)
#define err(x) {ec=x;goto BAIL;}
#define berr(x) {BP(x);ec=x;goto BAIL;}
#define VFUNC(x) (void(*)(void))x // void function
#define COUNT(array) (sizeof(array) / sizeof(array[0]))
#define PI 3.1415926535897932384626433832795
#define DEG2RAD(d) (((d)*PI)/180.0)
#define RAD2DEG(r) (((r)*180.0)/PI)
#define RAD_90 1.57080
#define EPS (1e-7)
#define PM_SHORTNAME_SIZE 8
#define PM_NAME_SIZE 32 // across the system (i.e. in DC)
#define PM_FILEPATH_MAX 2048
#define PM_FRAME_TIME 16 // close to 60 frames per second
///////////////////////////////////////////////////////////////////////////////
// ERROR CODES
//
// ERRORS & EXTENDED RETURN CODES
//
// -1.....-8999 user
// -9000..-9099 system
// -9200..-9299 file
// -9300..-9399 memory
// -9400..-9499 network
// -9500..-9599 video
// -9600..-9699 process
//
// 9000..9099
enum // int16
{
// system
ERR_SYS_LAST=-9099,
ERR_USERABORT,
ERR_INTERNAL,
ERR_INTERNAL_ALREADY,
ERR_INTERNAL_NOTREADY,
ERR_OPENGL_EXT_NOTFOUND,
ERR_SYS_FIRST=-9000,
// res
ERR_RES_FIND=-9199,
ERR_RES_LOAD,
ERR_RES_FILESYNTAX,
ERR_RES_CRC,
// file
ERR_FILE_LAST=-9299,
ERR_FILE_EOF,
ERR_FILE_SEEK,
ERR_FILE_SIZE,
ERR_FILE_READ,
ERR_FILE_WRITE,
ERR_FILE_OPEN,
ERR_FILE_EXIST,
ERR_FILE_DELETE,
ERR_FILE_GENERAL,
ERR_FILE_NOTFOUND,
ERR_FILE_INVALID,
ERR_FILE_DISKFULL,
ERR_FILE_RENAME,
ERR_FILE_NOTVALID,
ERR_FILE_NOTWRITABLE,
ERR_FILE_NOFAT,
ERR_FILE_ALIGN,
ERR_FILE_LOCK,
ERR_FILE_SYNTAX,
ERR_FILE_INTERNAL,
ERR_FILE_FIRST=-9200,
// memory
ERR_MEM_LAST=-9399,
ERR_MEM_ALLOC,
ERR_MEM_CORRUPT,
ERR_MEM_INTERNAL,
ERR_MEM_CHECK,
ERR_MEM_AVAIL,
ERR_MEM_AVAIL_LOW,
ERR_MEM_ALREADYFREE,
ERR_MEM_SUBWAVE,
ERR_MEM_NOTACTIVE,
ERR_MEM_POOL_EMPTY,
ERR_MEM_POOL_NOT_INITIALIZED,
ERR_MEM_NOT_DYNAMIC,
ERR_MEM_FIRST=-9300,
// network
ERR_NET_LAST=-9499,
ERR_NET_EMPTY,
ERR_NET_RANGE,
ERR_NET_OVERFLOW,
ERR_NET_CORRUPT,
ERR_NET_TIMEOUT,
ERR_NET_RETRYFAIL,
ERR_NET_PKALLOC,
ERR_NET_BDOVERFLOW,
ERR_NET_INTERNAL,
ERR_NET_PKSEND_ALLOC,
ERR_NET_BUSYWAIT,
ERR_NET_FIRST=-9400,
// video
ERR_VID_LAST=-9599,
ERR_VID_PPC,
ERR_VID_OVERFLOW,
ERR_VID_FIRST=-9560,
// frame buffer
ERR_FB_LAST=-9559,
ERR_FB_FIRST=-9530,
// window
ERR_WND_LAST=-9519,
ERR_WND_SETUP,
ERR_WND_FIRST=-9500,
// process
ERR_PROC_LAST=-9699,
ERR_PROC_FIRST=-9600,
// setup -- protection
ERR_SETUP_LAST=-9799,
ERR_SETUP_USR,
ERR_SETUP_ENV,
ERR_SETUP_MISMATCH,
ERR_SETUP_FIRST=-9700,
// disk raw
ERR_DISKRAW_LAST=-9899,
ERR_DISKRAW_READ,
ERR_DISKRAW_WRITE,
ERR_DISKRAW_COLDSTART,
ERR_DISKRAW_FIRST=-9800,
// host->target
ERR_HOST_LAST=-9999,
ERR_HOST_TIMEOUT,
ERR_HOST_FIRST=-9900,
ERR_PARSE_SYNTAX=-10999,
ERR_PARSE_INCOMPLETE,
ERR_PARSE_SETUP,
ERR_PARSE_RANGE,
ERR_PARSE_FAIL,
ERR_PARSE_STOP,
ERR_PARSE_EOF,
ERR_PROC_STACKOVERFLOW=-11999,
ERR_PROC_NOTHANDLED,
ERR_PROC_SYNTAX,
}; // ERR_
enum {
BP_UNASSIGNED=1000,
BP_FTPBUFGET,
BP_FTPLIST,
BP_FTPRVCTL,
BP_FTPRVCTL2,
BP_FTPNETBUFFUNC1,
BP_FTPNETBUFFUNC2,
BP_FTPNETBUFFUNC3,
BP_FTPNETBUFFUNC4,
BP_FTPLOOP1,
BP_FTPLOOP2,
BP_FTPLOOP3,
BP_MAIN,
BP_MEMDSETUP,
BP_MEMDPOOLFIRSTNODE,
BP_MEMDPOOLFIRSTNODE2,
BP_RESLINK,
BP_FBSETMODE,
BP_FSINIT1,
BP_FSINIT2,
BP_NETRESET1,
BP_NETRESET2,
BP_NETPORTINFO,
BP_IMGLOAD1,
BP_IMGLOAD2,
BP_XRESLOADDISP,
BP_XRESLOADIMG,
BP_VIDINIT,
BP_AUDGAMENUMPL,
BP_GAMEGETPL,
BP_REPORTCALCSCORE, //1030
BP_CABINIT,
BP_CABGETPL,
BP_CABGETGUN,
BP_CABOP,
BP_CABLOOP,
BP_FSOP,
BP_FSOP2,
BP_FTPRVCTL3,
BP_GUNSETXY,
BP_GUNOP1,
BP_GUNOP2,
BP_GUNOP3,
BP_INPJAMMACALLBACK,
BP_MEMSTACKRESTORE,
BP_MEMSTACKSAVE,
BP_OBJNEW,
BP_OBJANIBODY,
BP_OBJANIROOT,
BP_OBJLOOPEND1,
BP_OBJLOOPEND2,
BP_OBJCOLTYPESTR,
BP_ANICHANGE,
BP_SEQCALLBACK,
BP_ADDLIGHT,
BP_ADDLIGHT2,
BP_OBJLOOP,
BP_OBJLOOP2,
BP_PROCLOOP,
BP_RESINIT1,
BP_RESINIT2,
BP_RESINIT3,
BP_RESINIT4,
BP_RESNEW,
BP_RESREAD,
BP_RESREAD2,
BP_RESPTOK,
BP_RESPARSEVARADR,
BP_RESPDEER,
BP_RESPBAN,
BP_RESPBAN2,
BP_RESPBAN3,
BP_RESPRAN,
BP_RESSETCAT,
BP_RESSETCAT2,
BP_RESSETCAT3,
BP_RESSETCAT4,
BP_RESSETCAT5,
BP_RESPKILL,
BP_RESPSEQ,
BP_RESPSEQ2,
BP_RESPBIN,
BP_RESPCREATE,
BP_RESPCREATE2,
BP_RESPCREATE3,
BP_RESPCREATE4,
BP_RESPCREATE5,
BP_RESPCREATE6,
BP_RESPCREATE7,
BP_RESPCREATE8,
BP_RESPCREATE9,
BP_RESPBR,
BP_RESPBR2,
BP_RESPFIND,
BP_RESPFIND2,
BP_RESPFIND3,
BP_RESPFIND4,
BP_RESPFIND5,
BP_RESPFIND6,
BP_RESPFIND7,
BP_RESPFIND8,
BP_RESPFIND9,
BP_RESPFIND10,
BP_RESPFIND11,
BP_RESPFLAG,
BP_RESPOBJ,
BP_RESPOBJ2,
BP_RESPOBJ3,
BP_RESPOBJ4,
BP_RESPOBJ5,
BP_RESPOBJ6,
BP_RESPOBJ7,
BP_RESPOBJ8,
BP_RESPOBJ9,
BP_RESPOBJ10,
BP_RESPMEM,
BP_RESPLIGHT,
BP_RESPLIGHT2,
BP_RESPLIGHT3,
BP_RESPARSEONE,
BP_RESPARSEONE2,
BP_SZTO,
BP_N2LINKAFTER,
BP_N2LINKBEFORE,
BP_N2NAME,
BP_N2SCAN,
BP_INTDEVICEENABLE,
BP_INTDEVICEENABLE2,
BP_INTDEVICEENABLE3,
BP_INTDETACH,
BP_MAIN2, //1130
BP_PROPCOL,
BP_DRAWPOS,
BP_DRAWPOS2,
BP_DRAWPOS3,
BP_DRAWPOS4,
BP_DRAWPOS5,
BP_DISPDRAW2,
BP_COLDISP3,
BP_SKELCOL,
BP_DRAWSKELCOLDISPDBG,
BP_DISPDRAW3,
BP_DISPDRAW4SKELDBG,
BP_DISPDRAW4SKELDBG2,
BP_DISPDRAW4SKELDBG3,
BP_DISPDRAW4SKELDBG4,
BP_DISPDRAW4SKEL,
BP_DISPDRAW4SKEL2,
BP_DISPDRAW4SKEL3,
BP_DISPDRAW4SKEL4,
BP_DRAWINITSORTONCE,
BP_DRAWACCOUNTDISP2SORTONCE,
BP_DRAWALLOCATESORTONCE,
BP_DRAWADDDISP2SORTONCE,
BP_DRAWADDDISP2SORTONCE2,
BP_DRAWADDDISP2SORTONCE3,
BP_OBJANICHANGE,
BP_OBJANIKAN,
BP_SEQCALLBACK2,
BP_SEQFWD,
BP_ADDLIGHT3,
BP_ADDLIGHT4,
BP_ADDLIGHT5,
BP_OBJONCE,
BP_OBJLOOP3,
BP_OBJLOOP4,
BP_OBJLOOP5,
BP_OBJLOOP6,
BP_OBJLOOP7,
BP_OBJLOOP8,
BP_IMGLOAD3,
BP_IMGLOAD4,
BP_IMGLOAD5,
BP_VIDSTART,
BP_JPSAPPHOOKMSG,
BP_ATSETUPDEMO,
BP_ATSETUPDEMO2,
BP_ATSETUPDEMO3,
BP_ATSETUPDEMO4,
BP_ATSETUPDEMO5,
BP_AUDSETCREDITS, //1180
BP_FCCREATEBOAR,
BP_BOARKILLSECONDARIES,
BP_FCINITCRIT,
BP_FCCRITFALLSTART,
BP_FCCRITDIEANIM,
BP_DEERCOLSKEL,
BP_DEERSETFLAG,
BP_DEERCLRFLAG,
BP_DEERFREEZESPLINE,
BP_DEERFREEZESPLINE2,
BP_DEERFREEZESPLINE3,
BP_DEERUNFREEZESPLINE,
BP_DEERUNFREEZESPLINE2,
BP_DEERUNFREEZESPLINE3,
BP_DEERGETRUNSTART,
BP_DEERGETRUNSTART2,
BP_DEERGETRUNSTART3,
BP_DEERKILLSECONDARIES,
BP_DEERFALLSTART,
BP_FCINITDEER,
BP_FCINITREPLAYDEER,
BP_FCDEERDIEANIM,
BP_FCDEERDIEANIM2,
BP_FCDEERDIEANIM3,
BP_FCCREATEDOVE,
BP_FCCREATEDUCK,
BP_FINDDEERPRIMEOBJ,
BP_FINDDEERORCRITPRIMEOBJ,
BP_EDITADDNAME,
BP_EDITADDLIGHT,
BP_EDITRESPARSEONE,
BP_FCSETADV,
BP_FCSETADV2,
BP_FCSETADV3,
BP_FCSETADV4,
BP_FCSETADV5,
BP_FCKILLSECONDARIES,
BP_GAMEPROCCB,
BP_FCCREATEGEAR,
BP_MFREEZESPLINE,
BP_MFREEZESPLINE2,
BP_MFREEZESPLINE3,
BP_MFREEZESPLINEOBJ,
BP_MFREEZESPLINEOBJ2,
BP_MFREEZESPLINEOBJ3,
BP_PARTWEATHER,
BP_PARTWEATHER2,
BP_PARTWEATHER3,
BP_FCCREATEPHEASANT,
BP_PROJSHOTDATA,
BP_PROJSHOTDATA2,
BP_PROJSHOTDATA3,
BP_FCCREATEQUAIL,
BP_SHOTREPORTPROC,
BP_SHOTREPORTPROC2,
BP_SHOTREPORTPROC3,
BP_SHOTREPORT2PPROC,
BP_SHOTREPORT2PPROC2,
BP_SHOTREPORT2PPROC3,
BP_SELTIMERPROC,
BP_FCCREATEMUG,
BP_FCWINDCREATEBLADES,
BP_FCWINDSETCUR,
BP_AUDLOADALLDATA,
};
enum { // int16
ERC_ALREADY_DEAD=9000,
}; // ERC_
///////////////////////////////////////////////////////////////////////////////
// FUNCTION TYPES
enum {
FTYPE_NONE,
FTYPE_1,
FTYPE_2,
FTYPE_3,
FTYPE_4,
FTYPE_5,
FTYPE_6,
FTYPE_7,
};
typedef void (ftype1)(void);
typedef int (ftype2)(void*);
typedef int (ftype3)(void*,void*);
typedef int (ftype4)(int,void*,void*,void*);
typedef int (ftype5)(int);
typedef int (ftype6)(int,void*);
typedef int (ftype7)(void*,int);
///////////////////////////////////////////////////////////////////////////////
// NODES
typedef struct {
void *next;
} N1;
enum {
N2TYPE_NONE,
N2TYPE_UNK, // valid node, but not typed yet
N2TYPE_RES, // resource type
N2TYPE_OBJ, // object type
N2TYPE_PROC, // proc type
N2TYPE_MSG, // msg type
N2TYPE_L2, // l2 link
N2TYPE_MAX
};
#define M_N2TYPE 0x1f // flags will be in the top
enum {
N2SUB_NONE,
N2SUB_KID=0xf2, // can be used to verify that this is a kid (not needed)
};
// keep this whole section up to date in DC
#define M_N2_KIDLIST 0x0001 // has kid list
#define M_N2_KIDFIRST 0x0002 // process kid list first
#define M_N2_SKIP 0x0004 // don't process this node or any kids
#define M_N2_DEAD 0x0008 // node is dead (unlinked, aborted)
#define M_N2_LEVEL0 0x0010 // 0,1,2,3
#define M_N2_LEVEL1 0x0020 // 0,1,2,3
#define M_N2_LEVEL 0x0030 // 0,1,2,3
#define S_N2_LEVEL 4
#define M_N2_STRONG 0x0080 // strong node (don't normally kill)
#define M_N2_TYPE 0x0f00 // type can use 4 bits
#define M_N2_OPEN 0x1000 // node is open (for debugging)
#define M_N2_L2LINKED 0x2000 // linked into L2 list
typedef struct {
// order is assumed by compiled (res_pc.c) and loaded data
void *next;
void *prev;
uns8 type; // type
uns8 sub; // subtype info
uns16 flags; // top 8 bits of flags are reserved for type
} N2;
#define N2KIDLIST(n) (((N2*)n)-1)
#define N2PARENT(n) (((N2*)n)+1)
#define N2L2(n) (((N2*)n)+1) // n2 to l2
#define L2N2(n) (((N2*)n)-1) // l2 to n2
#define N2_DEPTH_MAX 8
#define N2_DEPTH_DEFAULT 8
///////////////////////////////////////////////////////////////////////////////
//
enum {
MATORDER_XYZ,
MATORDER_ZYX
};
#define M_MATORDER_ROTS 0x0f
#define M_MATORDER_SCALEFIRST 0x10
#define M_MATORDER_TRANSLATEFIRST 0x10
// VEC_
enum {
VEC_X,
VEC_Y,
VEC_Z,
VEC_SIZE,
};
enum {
V3_X,
V3_Y,
V3_Z,
V3_SIZE,
};
enum {
XYZ_X,
XYZ_Y,
XYZ_Z,
XYZ_SIZE,
};
// PLANEQ_
enum {
PLANEQ_NX,
PLANEQ_NY,
PLANEQ_NZ,
PLANEQ_D,
PLANEQ_SIZE,
};
// Q_
enum {
Q_X,
Q_Y,
Q_Z,
Q_W,
Q_SIZE,
};
// M3_
enum {
M3_11,
M3_21,
M3_31,
M3_12,
M3_22,
M3_32,
M3_13,
M3_23,
M3_33,
M3_SIZE
};
// VM_
enum {
VM_X,
VM_Y,
VM_Z,
VM_11,
VM_21,
VM_31,
VM_12,
VM_22,
VM_32,
VM_13,
VM_23,
VM_33,
VM_SIZE
};
// VM_
enum {
VM_TX,
VM_TY,
VM_TZ,
VM_RX,
VM_RY,
VM_RZ,
VM_SX,
VM_SY,
VM_SZ,
};
// M4_
enum {
M4_11,
M4_21,
M4_31,
M4_41,
M4_12,
M4_22,
M4_32,
M4_42,
M4_13,
M4_23,
M4_33,
M4_43,
M4_14, // x
M4_24, // y
M4_34, // z
M4_44,
M4_SIZE
};
#define M4_X M4_14
#define M4_Y M4_24
#define M4_Z M4_34
enum {
M4OGL_11,
M4OGL_21,
M4OGL_31,
M4OGL_41,
M4OGL_12,
M4OGL_22,
M4OGL_32,
M4OGL_42,
M4OGL_13,
M4OGL_23,
M4OGL_33,
M4OGL_43,
M4OGL_14, // x
M4OGL_24, // y
M4OGL_34, // z
M4OGL_44,
M4OGL_SIZE
};
#define M4OGL_X 12
#define M4OGL_Y 13
#define M4OGL_Z 14
// notes on boxes
// choose your own box style, but follow conventions
// x,y,w,h
// l,t,r,b
// l=x,t=y,r=l+w-1,b=y+h-1
enum {
BOX_LEFT,
BOX_TOP,
BOX_RIGHT,
BOX_BOTTOM,
BOX_SIZE
};
enum {
BOX_L,
BOX_T,
BOX_R,
BOX_B
};
enum {
BOX_X,
BOX_Y,
BOX_W,
BOX_H
};
enum {
CLIP_LEFT,
CLIP_TOP,
CLIP_RIGHT,
CLIP_BOTTOM,
CLIP_NEAR, // assumed to be after LTRB & before far
CLIP_FAR,
CLIP_NUM
};
#define FRUSTVERT_NUM 8 // numv for near & far plane
#define BOX_WIDTH BOX_W
#define BOX_HEIGHT BOX_H
enum {
BINBUF_SIZE,
BINBUF_NEXT,
BINBUF_FIRST,
};
#define BINBUFSET(f,i,v) {if((f)->binBuf&&((i+BINBUF_FIRST)<(int)(f)->binBuf[BINBUF_SIZE])) \
(f)->binBuf[(i+BINBUF_FIRST)]=(memu)v;}
///////////////////////////////////////////////////////////////////////////////
//
#define M_RESET_ALL 0x0000
#define M_RESET_HARDWARE 0x0001
#define M_RESET_MEMORY 0x0002
#define M_RESET_REBUILD 0x0004
#define M_RESET_LEVEL 0x0008
enum {
LEVEL_PERM,
LEVEL_WAVE,
LEVEL_SUBW,
LEVEL_GAME,
LEVEL_NUM
};
///////////////////////////////////////////////////////////////////////////////
//
extern void errlog(char *msg);
#endif // ndef PM_H

373
dond/core/proc.c Executable file
View File

@@ -0,0 +1,373 @@
// proc.c
// Play Mechanix - Video Game Proctem
// Copyright (c) 2005 Play Mechanix Inc. All Rights Reserved
//
// JFL 19 Jan 05; from JoeCo's lightweight proc system
// JFL 08 Jul 05; callbacks added based on Paul's tapout idea
#include "pm.h"
#include "sys.h"
#include "mem.h"
#include "proc.h"
#include "str.h"
#include <setjmp.h>
typedef struct {
N2 activeList;
N2 deadList;
uns32 *gwt;
uns32 loop;
} procGlobals;
procGlobals procG;
typedef struct {
N2 lnk;
char name[16];
uns state;
uns id;
uns time;
void *func;
void *killFunc;
ftype7 *cbFunc;
uns stackSize;
uns stackBegin;
uns stackUsed;
uns allocSize;
jmp_buf envSys;
jmp_buf envRun;
//char stackSave[<stackSize>];
} procRec;
#if SYS_BB
// see http://www.delorie.com/djgpp/doc/brennan/brennan_att_inline_djgpp.html
// asm ( "statements" : output_registers : input_registers : clobbered_registers);
#define GET_STACK(x) asm("mov %%esp,%0" :"=r"(x))
#define GROW_STACK(x) asm("sub %0,%%esp"::"r"(x))
#else // SYS_PC -- MSVC6.0
#define GET_STACK(x) __asm {mov x,ESP}
#define GROW_STACK(x) __asm {sub ESP,x}
#endif
// JFL 19 Jan 05
int ProcInit(void)
{
MEMZ(procG);
N2Head(&procG.activeList);
N2Head(&procG.deadList);
return 0;
} // ProcInit()
// JFL 19 Jan 05
void procFree(procRec *proc)
{
N2Unlink(proc);
MemDFree(MEMPOOL_OBJ,proc);
} // procFree()
// JFL 19 Jan 05
void procFreeDead(void)
{
procRec *proc;
int (*func)(void *pr);
while((proc=procG.deadList.next) && proc->lnk.type)
{
if((func=proc->killFunc))
(*func)(proc);
procFree(proc);
} // for
} // procFreeDead()
// JFL 19 Jan 05
void ProcFinal(void)
{
procFreeDead();
} // ProcFinal()
// JFL 19 Jan 05
int ProcReset(uns reset)
{
return 0;
} // ProcReset()
// JFL 19 Jan 05
int ProcLoop(void)
{
int ec;
procRec *proc,*pnext;
int (*func)(void *pr);
volatile uns stack;
uns8 dead=0;
for(proc=procG.activeList.next;proc->lnk.type;proc=proc->lnk.next)
{
top:
if(proc->state & M_PROC_STATE_DEAD)
{
dead=1;
continue;
}
if(!(proc->state & M_PROC_STATE_RUN))
continue;
if(!(func=proc->func))
continue;
if(procG.gwt && !(proc->state&M_PROC_STATE_SLOOP))
{
if(*procG.gwt<proc->time)
{
if(proc->cbFunc && (proc->state&M_PROC_STATE_SLEEPCB))
{
if((*proc->cbFunc)(proc,PROCCB_SLEEPING)<0)
goto sleepd;
}
continue;
}
}
else
{
if((int)proc->time>0)
{
proc->time--;
continue;
}
}
sleepd:
GET_STACK(stack);
proc->stackBegin=stack;
// flags
proc->state&=~M_PROC_STATE_SLEEPCB;
ec=setjmp(proc->envSys);
// -- control returns here --
proc->state &= ~M_PROC_STATE_CURRENT;
SysG.curProc=NUL;
if(!ec)
{
// direct call -- either start or continue proc
if(!(proc->state & M_PROC_STATE_RUNNING))
{
// start proc
SysG.curProc=proc->name;
proc->state |= M_PROC_STATE_RUNNING|M_PROC_STATE_CURRENT;
(*func)(proc);
SysG.curProc=NUL;
proc->state &= ~(M_PROC_STATE_RUNNING|M_PROC_STATE_CURRENT);
// kill procs if they return
dead=1;
proc->state|=M_PROC_STATE_DEAD;
}
else
{
// continue proc
stack = proc->stackUsed;
GROW_STACK(stack);
GET_STACK(stack);
MemCopy((char*)stack,&proc[1],proc->stackUsed);
SysG.curProc=proc->name;
proc->state |= M_PROC_STATE_CURRENT;
longjmp(proc->envRun,1); // jump back to routine
BP(BP_PROCLOOP); // never gets here
}
} // setjmp direct
else if(ec==2)
{
// handle a JUMP
proc->state &= ~M_PROC_STATE_RUNNING;
goto top;
}
} // for
// free dead
if(dead)
{
for(proc=procG.activeList.next;proc->lnk.type;proc=pnext)
{
pnext=proc->lnk.next;
if(!(proc->state & M_PROC_STATE_DEAD))
continue;
if((func=proc->killFunc))
{
(*func)(proc);
proc->killFunc=NUL;
}
N2Unlink(proc);
N2LinkBefore(&procG.deadList,proc);
} // for
}
if((proc=procG.deadList.next) && proc->lnk.type)
procFreeDead();
procG.loop++;
return 0;
} // ProcLoop()
// JFL 19 Jan 05
int ProcNew(void *procp,char *name,uns stackSize,uns allocSize,uns id,void *func)
{
int ec;
uns len;
procRec *proc;
len=sizeof(procRec)+stackSize+allocSize;
// create an object node
if((ec=MemDAlloc(MEMPOOL_OBJ,len,&proc))<0)
goto BAIL;
MemZero(proc,sizeof(procRec));
proc->lnk.type=N2TYPE_PROC;
proc->lnk.sub=PROCSUB_LIGHT;
proc->func=func;
proc->id=id;
proc->stackSize=stackSize;
proc->allocSize=allocSize;
proc->state=M_PROC_STATE_RUN;
szncpy(proc->name,name,sizeof(proc->name));
N2LinkBefore(&procG.activeList,proc);
if(procp)
*((void**)procp)=proc;
ec=0;
BAIL:
return ec;
} // ProcNew()
// JFL 29 Jan 04
// JFL 19 Jan 05
int ProcOp(void *vproc,int op,memu p)
{
// keep this frame small, it's saved w/proc
int ec;
volatile memu stack;
procRec *proc=vproc;
memu *memubuf;
// dispatch the op
switch(op)
{
case PROCOP_SLOOP:
// sloop(1) will wakeup next loop
// sloop(0) is not defined yet, but will wakeup next loop too
proc->time=(uns)p;
proc->state|=M_PROC_STATE_SLOOP;
goto sleeptimed;
case PROCOP_SLEEPCB:
// set sleep cb func to run when sleeping
// this will be cleared every time the proc wakes up
proc->state|=M_PROC_STATE_SLEEPCB;
case PROCOP_SLEEP:
if(procG.gwt)
proc->time=*procG.gwt+(uns)p*PROC_FRAME_TIME;
else
proc->time=(uns)p*PROC_FRAME_TIME;
proc->state&=~M_PROC_STATE_SLOOP;
if(proc->cbFunc && (proc->state&M_PROC_STATE_SLEEPCB))
(*proc->cbFunc)(proc,PROCCB_SLEEPINIT);
sleeptimed:
if(!setjmp(proc->envRun))
{
// direct call -- going to sleep
GET_STACK(stack);
proc->stackUsed = proc->stackBegin - stack;
if(proc->stackUsed >= proc->stackSize)
berr(ERR_PROC_STACKOVERFLOW); // increase stack size on create
MemCopy(&proc[1],(char*)stack,proc->stackUsed);
longjmp(proc->envSys,1); // jump back to loop
// should pop this frame off instead of saving it..
} // setjmp direct
break;
case PROCOP_JUMP:
proc->func=(void*)p;
longjmp(proc->envSys,2); // jump back to loop
break;
case PROCOP_KILL:
// kill proc
proc->state &= ~M_PROC_STATE_RUN;
proc->state |= M_PROC_STATE_DEAD;
break;
case PROCOP_SET_KILLFUNC:
proc->killFunc=(void*)p;
break;
case PROCOP_SET_CBFUNC:
proc->cbFunc=(void*)p;
break;
case PROCOP_SET_GAMEWAVETIMEPTR:
procG.gwt=(void*)p;
break;
case PROCOP_GET_ALLOCBUF:
if(proc->allocSize)
*((void**)p)=(((uns8*)&proc[1])+proc->stackSize);
else
*((void**)p)=NUL;
err(proc->allocSize);
case PROCOP_GET_NAMEBUF:
*((void**)p)=proc->name;
err(sizeof(proc->name));
case PROCOP_GET_WAKETIME:
err(proc->time);
case PROCOP_RESET_SLEEPS:
for(proc=procG.activeList.next;proc->lnk.type;proc=proc->lnk.next)
{
if(!(proc->state&M_PROC_STATE_SLOOP))
proc->time=0;
} // for
break;
case PROCOP_KILL_MASK_MATCH:
if(!(memubuf=(memu*)p))
break;
for(proc=procG.activeList.next;proc->lnk.type;proc=proc->lnk.next)
{
if(((proc->id&memubuf[0])==memubuf[1])
&& !(proc->state&M_PROC_STATE_CURRENT))
{
// kill proc
proc->state &= ~M_PROC_STATE_RUN;
proc->state |= M_PROC_STATE_DEAD;
}
} // for
break; // PROCOP_KILL_MASK_MATCH
case PROCOP_GET_ID:
err(proc->id);
case PROCOP_FINDID:
for(proc=procG.activeList.next;proc->lnk.type;proc=proc->lnk.next)
{
if(proc->id==(uns)p)
err(1);
}
break; // PROCOP_FINDID
default:
err(ERR_PROC_NOTHANDLED);
} // switch
ec=0;
BAIL:
return ec;
} // ProcOp()
// JFL 19 Jan 05
void* ProcActiveFirst(void)
{
return procG.activeList.next;
} // ProcActiveFirst()
// EOF

84
dond/core/proc.h Executable file
View File

@@ -0,0 +1,84 @@
#ifndef PROC_H
#define PROC_H
// proc.h
// Copyright (c) 2005 Play Mechanix Inc. All Rights Reserved
//
// JFL 19 Jan 05
///////////////////////////////////////////////////////////////////////////////
// SYSTEM SPECIFIC
//-----------------------------------------------------------------------------
// SYS_JP5500
#if SYS_JP5500
#define PROC_STACK_SIZE 512
#endif // SYS_JP5500
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
// SYS_PC|SYS_BB
#if SYS_PC|SYS_BB
#define PROC_STACK_SIZE 512
#endif // SYS_PC|SYS_BB
//-----------------------------------------------------------------------------
///////////////////////////////////////////////////////////////////////////////
// SYSTEM INDEPENDENT
#define PROC_FRAME_TIME PM_FRAME_TIME // 16 milliseconds per frame == approx 60 frames-per-second
enum {
PROCSUB_NONE,
PROCSUB_LIGHT,
};
#define M_PROC_STATE_RUN 0x00000100 // run
#define M_PROC_STATE_CURRENT 0x00100000 // proc is current proc (running & active)
#define M_PROC_STATE_DEAD 0x00200000 // proc is dead
#define M_PROC_STATE_RUNNING 0x00400000 // proc is running (maybe sliced out)
#define M_PROC_STATE_SLOOP 0x00800000 // proc is sleeping on loops
#define M_PROC_STATE_SLEEPCB 0x01000000 // run cb func when sleeping
#define M_PROCID_DONTKILL 0x00010000 // perm proc
extern int ProcInit(void);
extern void ProcFinal(void);
extern int ProcReset(uns reset);
extern int ProcLoop(void);
extern int ProcNew(void *procp,char *name,uns stackSize,uns allocSize,uns id,void *func);
enum {
PROCOP_NONE,
PROCOP_SLEEP, // (uns)time
PROCOP_SLOOP, // (uns)time
PROCOP_KILL, // kills proc
PROCOP_SLEEPCB, // (uns)time
PROCOP_SET_FUNC, // (void*)func
PROCOP_SET_KILLFUNC, // (void*)func
PROCOP_SET_CBFUNC, // (void*)func -- int func(void*,int)
PROCOP_SET_GAMEWAVETIMEPTR, // (uns32*)&GameWaveTime
PROCOP_JUMP, // return code (for now)
PROCOP_GET_ALLOCBUF, // (void*)&buf -- returns size
PROCOP_GET_NAMEBUF, // (char*)&buf -- returns size
PROCOP_GET_WAKETIME, // returns wake time
PROCOP_RESET_SLEEPS,
PROCOP_KILL_MASK_MATCH, // &memubuf[2]; if((proc->id&mask)==match) kill
PROCOP_GET_ID, // returns id
PROCOP_FINDID, // returns if found
};
extern int ProcOp(void *proc,int op,memu p);
extern void* ProcActiveFirst(void);
enum {
PROCCB_NONE,
PROCCB_SLEEPINIT,
PROCCB_SLEEPING,
};
#define M_PROCCB 0xff
#endif // ndef PROC_H

7879
dond/core/res.c Executable file
View File

File diff suppressed because it is too large Load Diff

762
dond/core/res.h Executable file
View File

@@ -0,0 +1,762 @@
#ifndef RES_H
#define RES_H
// res.h
// Copyright 2004 Play Mechanix Inc. All Rights Reserved
//
// JFL 08 Oct 04
// note: keep DC up-to-date with these defs
#define M_RES_LOADED 0x0001
#define M_RES_COMPILED 0x0002
#define M_RES_DONTFREE 0x0004
#define M_RES_FREEDATA 0x0008
#define M_RES_PARSE1 0x0080
#define M_RES_LOOP 0x0100
#define M_RES_ANIM 0x0200
#define M_RES_SHARED 0xf000 // these flags are shared (OK to use locally)
enum {
// -- see a-doc.h for notes on adding types
// must match DC & resResSubTable[]
RESSUB_NONE,
RESSUB_GROUP,
RESSUB_FUNC1,
RESSUB_DISP1,
RESSUB_DISP2,
RESSUB_IMG1,
RESSUB_CAM,
RESSUB_KAN,
RESSUB_SKEL,
RESSUB_DISP3,
RESSUB_PARSE,
RESSUB_SEQ,
RESSUB_LIGHT,
RESSUB_FTYPE,
RESSUB_COL,
RESSUB_FUNC2,
RESSUB_FUNC3,
RESSUB_FONT,
RESSUB_DISP4,
RESSUB_JUMP,
RESSUB_VID,
RESSUB_MAX
// must match DC & & resResSubTable[]
};
#define M_RESNEW_KID 0x0001
#define M_RESNEW_DONTLINK 0x0002
#define M_RESNEW_DONTCLEAR 0x0004
#define RES_NAME_SIZE 16
typedef struct {
// must match DC
N2 lnk;
uns16 flags;
int16 useCount;
char name[RES_NAME_SIZE];
void *data;
} Res;
#define RES_LIST_DEPTH 4
///////////////////////////////////////////////////////////////////////////////
// SYS_PC|SYS_BB
#if SYS_PC|SYS_BB
extern Res resCompiled[];
//
// Res -- subtype flags
//
enum {
// enumerate the bottom bits
RESDISPMODE_NONE,
RESDISPMODE_WIREFRAME,
RESDISPMODE_TEX,
};
// flags
#define M_RESDISPMODE 0x000f
#define M_RESDISPMODE_VBO 0x0040 // vertex buffer object
#define M_RESDISPMODE_SORTONCE 0x0080
#define M_RESDISPMODE_HASALPHA 0x0100
#define M_RESDISPMODE_GND 0x0200
#define M_RESDISPMODE_MIPMAP 0x0400
#define M_RESDISPMODE_FACESORT 0x0800
#define M_RESDISPMODE_LIGHT 0x1000
#define M_RESDISPMODE_NOCULL 0x2000
#define M_RESDISPMODE_VMAT 0x4000 // vmat field is vmat (not rts)
#define M_RESDISPMODE_DONTFOG 0x8000
#define M_RESDISPFACE_TRI 0x0001
#define M_RESDISPFACE_QUAD 0x0002
#define RESFLOATSPER_VERT 3 // number of floats stored per vertex
#define RESFLOATSPER_COLOR 4 // number of floats stored per vertex color
#define RESFLOATSPER_TEXCOORD 2 // number of floats stored per texture coordinate
#define RESFLOATSPER_NORMAL 3 // number of floats stored per normal
//
// DATA
//
// only used for common fields among all ResDataDisp*
typedef struct {
uns16 mode; // all ResDataDisp* start with uns16 mode
} ResDataDisp0;
typedef struct {
// this is a simple display structure
// used to compile in test objects (res_pc.c)
// must match DC
uns16 mode; // all ResDataDisp* start with uns16 mode
uns16 nTris;
float xyzrCull[4];
void *tVerts;
void *tTexCoords;
void *tVertColors;
uns32 tex;
} ResDataDisp1;
typedef struct {
float xyz[3];
uns32 index;
} ResDataFaceSort;
typedef struct {
// must match DC
uns16 mode;
uns16 atSize;
float vmat[12];
uns16 nTris;
uns16 nQuads;
float xyzrCull[4];
void *tVerts;
void *tVertColors;
void *tTexCoords;
void *tFaceSort;
void *tNormals;
void *qVerts;
void *qVertColors;
void *qTexCoords;
void *qFaceSort;
void *qNormals;
char *atBuf;
uns32 texHash;
uns32 texGen;
uns32 tVertsVBO;
uns32 tVertColorsVBO;
uns32 tTexCoordsVBO;
uns32 tNormalsVBO;
uns32 qVertsVBO;
uns32 qVertColorsVBO;
uns32 qTexCoordsVBO;
uns32 qNormalsVBO;
uns32 texGen2;
} ResDataDisp2;
typedef struct {
// must match DC
uns16 mode; // all ResDataDisp* start with uns16 mode
uns16 atSize;
float vmat[12]; // not used now
uns16 nFaces;
uns16 nVerts;
float xyzrCull[4];
void *verts;
void *normals;
void *faces;
char *atBuf;
uns32 texHash;
uns32 texGen;
} ResDataDisp3;
#define M_RESDATADISP4_WEIGHTS 0x0001
typedef struct {
// must match DC
// this is for displaying shadows
uns16 mode; // all ResDataDisp* start with uns16 mode
uns16 atSize;
uns16 flags;
uns16 nJoints;
uns16 maxFaces;
uns16 nVerts;
float xyzrCull[4];
void *verts;
void *faces;
void *joints;
void *weights;
char *atBuf;
} ResDataDisp4;
typedef struct {
uns16 nFaces;
uns16 jointNum;
uns32 faceoff; // first ResD4Face
} ResD4Joint;
typedef struct {
uns32 vertoff[4];
float nrmk[4];
int16 neighbor[4];
} ResD4Face;
typedef struct {
float w0; // weight for joint j0
float w1; // weight for joint j1
uns16 j0;
uns16 j1;
} ResD4Weight;
enum {
RES_TEX_NONE,
RES_TEX_RGB8,
RES_TEX_RGBA8,
RES_TEX_RGB332,
RES_TEX_RGB555,
};
#define M_RESDATAIMG1_MIPMAP 0x0001
#define M_RESDATAIMG1_HASALPHA 0x0002
typedef struct {
// must match DC
uns16 type;
uns16 flags;
uns16 w;
uns16 h;
uns32 texHash;
uns32 texGen;
void *tex;
} ResDataImg1;
typedef struct {
uns32 fileSize;
void *data;
void *theora;
uns32 texGen;
} ResDataVid;
#define M_RESDATACAM_ORTHO 0x0001
typedef struct {
// must match DC
uns16 mode;
uns16 atSize;
float rot[3];
float trans[3];
float scale[3];
float fov;
float orthoWidth;
float clipNear;
float clipFar;
char *atBuf;
} ResDataCam;
#define M_RESDATAKAN_LOOP 0x0001
#define M_RESDATAKAN_SPLINE 0x0002
#define M_RESDATAKAN_GROUP 0x0004
typedef struct {
uns16 flags;
uns16 numk;
float firstFrame; // as keyed by animator
float length; // total length
// followed by ResDataKanKey
} ResDataKan;
#define M_RESDATAKANKEY_RX 0x0001
#define M_RESDATAKANKEY_RY 0x0002
#define M_RESDATAKANKEY_RZ 0x0004
#define M_RESDATAKANKEY_TX 0x0008
#define M_RESDATAKANKEY_TY 0x0010
#define M_RESDATAKANKEY_TZ 0x0020
#define M_RESDATAKANKEY_SX 0x0040
#define M_RESDATAKANKEY_SY 0x0080
#define M_RESDATAKANKEY_SZ 0x0100
#define M_RESDATAKANKEY_LINEAR 0x0200
#define M_RESDATAKANKEY_ANGULAR 0x0400
#define RESDATAKANKEY_CH_NUM 3
typedef struct {
float time; // duration
uns16 flags;
uns16 keynum;
float rts[3*RESDATAKANKEY_CH_NUM]; // rx,ry,rz,tx,ty,tz,sx,sy,sz
} ResDataKanKey;
typedef struct {
float orient[3];
float vm[12];
float bps[12];
char name[PM_NAME_SIZE];
char parent[PM_NAME_SIZE];
} ResDataJoint;
// every vert has a weight for every joint
// this is how they are stored in the res:
// v0.j0 v0.j1 v0.j2 .. v1.j0 v1.j1 v1.j2 .. v2.j0 v2.j1 v2.j2
#define M_RESDATASKEL_JJJBINDINVERTED 0x0001
typedef struct {
uns16 flags;
uns16 numJoints;
char geoName[PM_NAME_SIZE];
ResDataJoint *joints;
float *weights;
} ResDataSkel;
#define M_RESDATAPARSE_SINGLE 0x0001
typedef struct {
uns16 flags;
uns16 msgSize;
uns16 nLab;
uns16 xx1;
char *cmd;
char *msg;
void *root;
memu *binBuf;
memu *varBuf;
void *lab;
char *nameptr;
ftype4 *callbackFunc;
void *callbackData;
} ResDataParse;
#define M_RESDATASEQ_TEXT 0x0001
typedef struct {
char name[16];
int32 off; // offset from this adr
} ResRDSLab;
typedef struct {
int32 offBefore; // offset from this adr (0=empty)
int32 offCleanup; // offset from this adr (0=empty)
int32 offStart; // offset from this adr (0=empty)
} ResRDSSig;
// rds
// char text[rds->dataSize]
// ResRDSLab labels[rds->nLab]
// ResRDSSig signals[rds->nSig]
typedef struct {
uns16 flags;
uns16 allocSize;
uns16 dataSize;
uns16 beforeOff;
uns16 cleanupOff;
uns16 firstOff;
uns16 nLab;
uns16 nSig;
} ResDataSeq;
enum {
RESDATALIGHT_NONE,
RESDATALIGHT_AMBIENT,
RESDATALIGHT_DIRECTIONAL,
RESDATALIGHT_POSITIONAL,
RESDATALIGHT_SPOT,
};
enum {
RESDATALIGHTP_SPOT_CONE,
};
#define M_RESDATALIGHT_SHADDIR 0x01
#define M_RESDATALIGHT_SHADPOS 0x02
#define M_RESDATALIGHT_NOLIGHT 0x04
typedef struct {
uns8 type;
uns8 flags;
uns16 atSize;
float pos[3];
float dir[3];
float rgb[3]; // intensity 'baked' in
float parameters[4]; // parameters
char *atBuf;
} ResDataLight;
enum {
RESDATACOLTYPE_NONE,
RESDATACOLTYPE_SINGLE,
RESDATACOLTYPE_SKEL,
RESDATACOLTYPE_PROP,
};
#define M_RESDATACOL_RTS 0x01 // has ResDataColRTS imm following
typedef struct {
uns8 flags;
uns8 type;
uns16 atSize;
char *atBuf;
void *blocks;
void *polys;
} ResDataCol;
typedef struct {
float rts[12];
} ResDataColRTS;
enum {
RESDATACOLBLOCK_NONE,
RESDATACOLBLOCK_XZMM,
RESDATACOLBLOCK_XYZR,
};
typedef struct {
uns8 type; // must be in 1st int
uns8 flags;
uns16 xx1;
} ResDataColBlock;
typedef struct {
ResDataColBlock blk;
float minx;
float miny;
float minz;
float maxx;
float maxy;
float maxz;
float xyzr[4];
int32 off; // offset to list of offsets to G_ResDataGBPoly
} ResDataCBXZMM;
typedef struct {
ResDataColBlock blk;
char colName[PM_NAME_SIZE];
uns16 jointNum;
uns16 colNum;
float xyzr[4]; // xyz of center and r*r
int32 off; // offset to list of offsets to G_ResDataGBPoly
} ResDataCBXYZR;
#define RESDATACBPOLY_NUMV_END 0xff
typedef struct {
float vrt[3];
float nrm[3];
} ResDataCBVN;
typedef struct {
uns8 numv;
uns8 xx1;
uns16 xx2;
float nrmk[4]; // normal & plane constant
ResDataCBVN v[3];
// followed by other ResDataCBVN needed
} ResDataCBPoly;
typedef struct {
struct {
float vrt[3];
} v[3];
} ResDataCBTri;
typedef struct {
uns8 ascii;
uns8 xx1;
uns16 xx2;
float uvbox[BOX_SIZE]; // ltrb
float camsize[2]; // xy
float campivot[2]; // xy
} ResDataFChar;
#define M_RESDATAFONT_HASALPHA 0x0001
typedef struct {
uns16 flags;
uns16 xx1;
uns16 asciiFirst;
uns16 numfcs;
uns32 texHash;
uns32 texGen;
void *fcs; // ResDataFChar
} ResDataFont;
#define RES_FRAME_TIME PM_FRAME_TIME // 16 milliseconds per frame == approx 60 frames-per-second
#define RES_CAM2D_W 136.6//64
#define RES_CAM2D_H 76.8//48
#define RES_CAM2D_Z 100
extern int xResInit(void);
extern void xResFinal(void);
extern int xResStart(void);
extern int xResRelease();
extern int xResLoadDisp(Res *res,void *rhdata);
extern int xResLoadVid(Res *res,void *rhdata);
extern int xResLoadImg(Res *res,void *rhdata);
extern int xResLoadCam(Res *res,void *rhdata);
extern int xResLoadLight(Res *res,void *rhdata);
extern int xResLoadSkel(Res *res,void *rhdata);
extern int xResLoadGroup(Res *res,void *rhdata);
extern int xResLoadCol(Res *res,void *rhdata);
extern int xResLoadFont(Res *res,void *rhdata);
#endif // SYS_PC|SYS_BB
///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
// SYSTEM INDEPENDENT
enum {
RESPARSE_NONE,
RESPARSE_GEO,
RESPARSE_GND,
RESPARSE_LOOP,
RESPARSE_DONTLOOP,
RESPARSE_FOG,
RESPARSE_DC,
RESPARSE_HELP,
RESPARSE_BLEND,
RESPARSE_MIN,
RESPARSE_MAG,
RESPARSE_MIP,
RESPARSE_LIGHTS,
RESPARSE_LIGHT,
RESPARSE_ANIS,
RESPARSE_Q,
RESPARSE_DISP,
RESPARSE_CAM,
RESPARSE_GRID,
RESPARSE_JOINTS,
RESPARSE_PAUSE,
RESPARSE_STEP,
RESPARSE_DEER,
RESPARSE_BAN,
RESPARSE_RAN,
RESPARSE_NUL,
RESPARSE_HOLD,
RESPARSE_RUN,
RESPARSE_SET,
RESPARSE_CAT,
RESPARSE_CFG,
RESPARSE_FLAGS,
RESPARSE_KILL,
RESPARSE_SEQ,
RESPARSE_ANI,
RESPARSE_FRAME,
RESPARSE_ALLOC,
RESPARSE_SIZE,
RESPARSE_BIN,
RESPARSE_LOAD,
RESPARSE_ADD,
RESPARSE_WIRE,
RESPARSE_TIME,
RESPARSE_WAVE,
RESPARSE_OFF,
RESPARSE_IF,
RESPARSE_LEVEL,
RESPARSE_VERS,
RESPARSE_INFO,
RESPARSE_LOG,
RESPARSE_BEFORE,
RESPARSE_CLEANUP,
RESPARSE_START,
RESPARSE_PRINT,
RESPARSE_FC,
RESPARSE_BR,
RESPARSE_SLEEP,
RESPARSE_SLOOP,
RESPARSE_FIND,
RESPARSE_SIGNAL,
RESPARSE_SIGNALS,
RESPARSE_RETURN,
RESPARSE_SWATCH,
RESPARSE_FAIL,
RESPARSE_FLAG,
RESPARSE_CREATE,
RESPARSE_TAG,
RESPARSE_SEND,
RESPARSE_OBJ,
RESPARSE_MARK,
RESPARSE_MEM,
RESPARSE_NOP,
RESPARSE_TOOL,
RESPARSE_KEYMACRO,
RESPARSE_DBG,
RESPARSE_GAME,
RESPARSE_SUB,
RESPARSE_ELF,
RESPARSE_COL,
RESPARSE_STR,
RESPARSE_SOUND,
RESPARSE_SHAD,
RESPARSE_SORTBUFSIZE,
RESPARSE_DONTCULL,
RESPARSE_CURS,
RESPARSE_GUNSPEED,
RESPARSE_OP,
RESPARSE_MINTRI,
RESPARSE_MINQUAD,
RESPARSE_FINDNAME,
RESPARSE_BOZORET,
RESPARSE_VSYNC,
RESPARSE_VIDPLAY,
RESPARSE_VIDSTOP,
RESPARSE_VIDREADY,
RESPARSE_VIDDONE,
RESPARSE_VIDALINK,
RESPARSE_PARENOPEN,
RESPARSE_PARENCLOSE,
RESPARSE_QUESTIONMARK,
RESPARSE_DOT,
RESPARSE_DASH,
RESPARSE_X, // -- end of parsable tokens
RESPARSE_STRING,
RESPARSE_LABEL,
RESPARSE_REVERT=-100,
};
typedef struct {
void *root;
char *str;
char *revert;
Res *res;
char *outBuf;
uns outBufSize;
memu *binBuf; // binbuf
memu *varBuf; // binbuf
int depth;
int8 fail;
uns8 brk;
uns16 nLab;
void *lab;
uns16 nSig;
void *sig;
void *rastack[8];
uns16 radepth;
} ResParseH;
typedef struct {
char name[PM_NAME_SIZE];
void* adr;
uns8 ftype;
uns8 flags;
uns16 xx1;
} ResDataFTOne;
typedef struct {
uns16 nFTypes;
uns16 xx1;
void *ftypes;
} ResDataFType;
extern int ResInit(void);
extern void ResFinal(void);
extern int ResReset(uns reset);
extern int ResNew(void *resp,uns sub,uns size,uns flags,char *name);
extern int ResKill(void *r);
extern int ResLevelKill(int level);
extern void ResLoopEnd(void);
extern int ResIsSub(void *r,uns8 subtype);
extern void* ResFindNth(N2 *list,char *name,int *nth,int level);
extern void* ResFindSubNth(N2 *list,char *name,uns subtype,int *nth);
extern int ResLoad(void *resp,char *name);
extern int ResCmp(char *ngame,char *ndata);
extern int ResRDSLabAdr(ResDataSeq *rds,char *s1,char *s2,void *adrp);
extern int ResRDSSigAdr(ResDataSeq *rds,int n,char type,void *adrp);
extern int ResRDSVars(void *osr,ResDataSeq *rds,memu **adrp);
extern int ResRDSCall(void *osr,ResDataSeq *rds,void *adr);
extern int ResParseBlock(ResDataParse *rdp,char **nextp);
extern int ResParseText(void *root,memu *bin,memu *var,char *s1,char *s2);
extern int ResParse(Res *res,char *buf,char **nextp);
extern int ResParseSeq(char *seq);
extern int ResScript(char *script);
extern void* ResLoadedFirst(void);
extern int ResLoadedCount(void);
extern int ResInfoExpand(char *buf,int size,Res *r,uns flags);
extern int ResSelect(Res *r);
extern int ResRunCommandFile(char *name);
extern int ResParseSet(ResParseH *fhb,Res *res,char *str,char *outBuf,uns outBufSize);
extern int ResParseTok(ResParseH *fhb,char **s1p,char **s2p,char *terms);
extern int ResParseRaw(ResParseH *fhb,char **s1p,char **s2p,char *terms);
extern int ResParsePAREN(ResParseH *fhb);
extern memu *ResParseVarAdr(ResParseH *fhb,char *s1,char *s2);
enum {
RESGEN_NONE,
RESGEN_GET_NAMED_RESDATASEQ, // (char *name,ResDataSeq**rdsp)
RESGEN_RESDATASEQ_TO_BUF, // (ResDataSeq *rds,char **bufp)
RESGEN_RESDATAKAN_TO_BUF, // (ResDataKan *rdk,char **bufp)
RESGEN_GET_NAMED_RESANIGROUP, // (char *name,Res **rp)
RESGEN_RESANIGROUP_TO_BUF, // (Res *r,char **bufp)
RESGEN_GET_NAMED_RESDATACOL, // (char *name,ResDataCol**rdcp)
RESGEN_RESDATACOL_TO_BUF, // (ResDataCol *rdc,char **bufp)
RESGEN_GET_NAMED_RESDATALIGHT, // (char *name,ResDataLight**rdlp)
RESGEN_RESDATALIGHT_TO_BUF, // (ResDataLight *rdl,char **bufp)
};
#define M_RESGEN 0xff
#define S_RESGEN_N 8
extern int ResGen(uns cmd,void *src,void *dst);
// -- move into new file
enum {
GAMECALLBACK_NONE,
GAMECALLBACK_ADD_RES, // (char *name)
GAMECALLBACK_SET_WAVE_TIME, // (uns time)
GAMECALLBACK_GET_WAVE_TIME, // (uns*)&time
};
#define M_GAMECALLBACK 0xff
extern int GameCallback(uns cmd,void *src,void *dst);
int ResFCPNext(void *fcp,char type,int n,void *dst);
enum {
RESFCP_NONE,
RESFCP_GETVARS, // (memu**)varptr -- returns number of vars
RESFCP_PARSE_VAR, // (memu*)&var
RESFCP_PARSE_VAD, // (memu*)&vad
RESFCP_GETANDCLEAR_SIGNALDATA, // (memu*)&ptr
RESFCP_GET_SIGNALDATA, // (memu*)&ptr
};
#define M_RESFCP_CMD 0xff
int ResFCPCmd(void *fcp,int cmd,void *a,void *b);
extern char *ResResSubTable[];
extern char *ResObjSubTable[];
enum {
RESKANOP_NONE,
RESKANOP_NUMKEYS,
RESKANOP_FIRSTFRAME, // *(float*)=time
RESKANOP_MOVEDELTA, // *(float*)=time
};
#define M_RESKANOP 0xff
extern int ResKanOp(int op,ResDataKan *kan,void *a);
extern int ResNFSZeroTime(void *nsr,N2 *n);
extern int ResNFSFlag(void *nsr,N2 *n);
extern int ResNFSImg(void *nsr,N2 *n);
enum {
RESSEQCB_NONE,
RESSEQCB_SLEEPINIT,
RESSEQCB_SLEEPING,
};
#define M_RESSEQCB 0xff
extern int ResSeqCB(uns op,void *osr);
#endif // ndef RES_H

268
dond/core/snd.c Executable file
View File

@@ -0,0 +1,268 @@
// snd.c
// Play Mechanix - Video Game System
// Copyright (c) 2005 Play Mechanix Inc. All Rights Reserved
//
// JFL 25 Apr 05
#include "pm.h"
#include "snd.h"
#include "fs.h"
#include "str.h"
#include "mem.h"
#include <jpsdefs.h>
#include <stdarg.h>
typedef struct {
uns8 mute;
int vol;
int minVol;
int maxVol;
uns32 jpsvers[3];
} sndGlobals;
sndGlobals sndG;
// JFL 25 Apr 05
int SndInit(void)
{
MEMZ(sndG);
sndG.minVol=0;
sndG.maxVol=255;
jps_init();
jps_version(&sndG.jpsvers[0],&sndG.jpsvers[1],&sndG.jpsvers[2]);
return 0;
} // SndInit()
// JFL 25 Apr 05
int SndReset(uns reset)
{
MEMZ(sndG);
return 0;
} // SndReset()
// JFL 25 Apr 05
void SndFinal(void)
{
jps_shutdown();
} // SndFinal()
// JFL 26 Apr 05
void* sndBankFindName(char *s1,char *s2)
{
int i;
jps_bank *b;
for(i=0;i<JPS_MAX_BANKS;i++)
{
if(!(b=jps_banks[i]))
continue;
if(!sz2cmpx(s1,s2,b->nameStr,NUL))
return b;
} // for
return NUL;
} // sndBankFindName()
// JFL 26 Apr 05
int SndLoad(char *s1,char *s2)
{
int ec;
char pathbuf[PM_FILEPATH_MAX];
jps_bank *b;
if(sndBankFindName(s1,s2))
err(1); // already
szncpy(pathbuf,SysG.sndpath,sizeof(pathbuf));
if(1
&& ((ec=szlen(pathbuf))>0)
&& (ec<sizeof(pathbuf))
&& (pathbuf[ec-1]!='/')
&& (pathbuf[ec-1]!='\\'))
{
pathbuf[ec++]=FS_DIR_SLASH; // assume this slash works..
pathbuf[ec]=0;
}
sz2ncat2(pathbuf,s1,s2,".txt",NUL,sizeof(pathbuf));
if(!(b=jps_bank_load(pathbuf)))
err(-1);
sz2ncpy(b->nameStr,s1,s2,sizeof(b->nameStr));
ec=0;
BAIL:
return ec;
} // SndLoad()
// JFL 26 Apr 05
int SndUnload(char *s1,char *s2)
{
int ec;
jps_bank *b;
if(!(b=sndBankFindName(s1,s2)))
err(1);
jps_bank_free(b);
ec=0;
BAIL:
return ec;
} // SndUnload()
//MTM
void SndStopAll(void)
{
SndPlay(0);
}
// JFL 26 Apr 05
int SndPlay(uns n)
{
jps_play(NUL,n,255); // play at 100% of master volume
return 0;
} // SndPlay()
// JFL 11 May 05
// JFL 27 Jul 05; vol as percent
int SndPlayVol(uns n,int vol)
{
// this vol is a % of sndG.vol
// eg -- 255=100% 128=50% 64=25%
if(vol<0) vol=0;
if(vol>255) vol=255;
jps_play(NUL,n,vol);
return vol;
} // SndPlayVol()
// JFL 26 Apr 05
// JFL 27 Jul 05
int SndVol(int vol)
{
if(vol<sndG.minVol)
vol=sndG.minVol;
if(vol>sndG.maxVol)
vol=sndG.maxVol;
sndG.vol=vol;
jps_master_volume(vol);
return vol;
} // SndVol()
//ignores minVol - lets you turn off sound
void SndVolOff()
{
sndG.vol=0;
jps_master_volume(0);
} // SndVolOff()
// MTM -- --- 05
int SndGetVol(void)
{
return sndG.vol;
} // SndGetVol()
// JFL 13 May 05
int SndVolMinMax(int *minp,int *maxp,uns flags)
{
if(flags)
{
if(minp)
sndG.minVol=*minp;
if(maxp)
sndG.maxVol=*maxp;
}
else
{
if(minp)
*minp=sndG.minVol;
if(maxp)
*maxp=sndG.maxVol;
}
if(sndG.minVol<0)
sndG.minVol=0;
if(sndG.maxVol>255)
sndG.maxVol=255;
return 0;
} // SndVolMinMax()
// JFL 18 Jul 05
int SndOp(uns op,...)
{
int ec;
va_list args;
char *buf;
int n;
va_start(args,op);
switch(op&M_SNDOP)
{
case SNDOP_GETVERS:
buf=va_arg(args,char*);
n=va_arg(args,int);
szbuild(buf,n,"%d.%d.%d",sndG.jpsvers[0],sndG.jpsvers[1],sndG.jpsvers[2]);
break;
default:
err(-1);
} // switch
ec=0;
BAIL:
va_end(args);
return ec;
} // SndOp()
//
// SndInfo
// print sound system information into output buffer
// used for debug information
//
// in:
// buf = string buffer
// bufSize = size of string buffer
//
// out:
//
// GNP 27 Feb 06; from MemInfo
//
int SndInfo(char *buf,int bufSize)
{
int i;
jps_bank *b;
if(!buf || !bufSize)
return 1;
buf[0]=0;
szbuild(buf,bufSize,"<-cat>sound banks loaded:\n");
// print loaded banks
for(i=0;i<JPS_MAX_BANKS;i++)
{
if(!(b=jps_banks[i]))
continue;
szbuild(buf,bufSize,"<-cat>%s\n",b->nameStr);
} // for
// print memory usage info
szbuild(buf,bufSize,"<-cat>\njps memory usage:\n");
szbuild(buf,bufSize,"<-cat>inuse=%x\n",MemSysInfo.jpsOutstanding);
szbuild(buf,bufSize,"<-cat>allocs=%d\n",MemSysInfo.jpsCount);
szbuild(buf,bufSize,"<-cat>largest=%x\n",MemSysInfo.jpsLargest);
return 0;
} // SndInfo()
// EOF

38
dond/core/snd.h Executable file
View File

@@ -0,0 +1,38 @@
#ifndef SND_H
#define SND_H
// snd.h
// Copyright 2005 Play Mechanix Inc. All Rights Reserved
//
// JFL 25 Apr 05
///////////////////////////////////////////////////////////////////////////////
// JPS
///////////////////////////////////////////////////////////////////////////////
// SYSTEM INDEPENDENT
///////////////////////////////////////////////////////////////////////////////
//
extern int SndInit(void);
extern void SndFinal(void);
extern int SndReset(uns reset);
extern int SndLoad(char *s1,char *s2);
extern int SndUnload(char *s1,char *s2);
extern int SndPlay(uns n);
extern int SndPlayVol(uns n,int vol);
extern void SndStopAll(void);
extern int SndVol(int n);
extern int SndGetVol(void);
extern int SndVolMinMax(int *minp,int *maxp,uns flags);
extern void SndVolOff();
extern int SndInfo(char *buf,int bufSize);
enum {
SNDOP_NONE,
SNDOP_GETVERS, // char *buf,int bufsize
};
#define M_SNDOP 0xff
extern int SndOp(uns op,...);
#endif // ndef SND_H

1194
dond/core/str.c Executable file
View File

File diff suppressed because it is too large Load Diff

51
dond/core/str.h Executable file
View File

@@ -0,0 +1,51 @@
#ifndef STR_H
#define STR_H
// str.h
// Copyright 2004 Play Mechanix Inc. All Rights Reserved
//
// JFL 29 Aug 04
///////////////////////////////////////////////////////////////////////////////
// STRINGS
#define SZ_IS_HEX STR_IS_HEX
#define STR_IS_HEX(_s_) (((_s_)[0]=='0')&&(((_s_)[1]=='x')||((_s_)[1]=='X')))
extern char *str_digit;
extern char *str_equal;
#define C_IS_TOKEN(c) ((c>='0'&&c<='9')||(c>='a'&&c<='z')||(c>='A'&&c<='Z')||(c=='_')||(c=='$')||(c=='.')||(c=='-')||(c=='*')||(c=='?'))
#define C_IS_LABEL(c) ((c>='0'&&c<='9')||(c>='a'&&c<='z')||(c>='A'&&c<='Z')||(c=='_'))
#define C_IS_WHITE(c) (c==' '||c=='\t'||c=='\n'||c=='\r')
#define C_IS_DIGIT(c) (c>='0'&&c<='9')
#define C_IS_NUMBER(c) ((c>='0'&&c<='9')||(c=='-')||(c=='.')
#define C_IS_QUOTE(c) (c=='\"'||c=='\'')
#define C_TO_LOWER(_c_) ((_c_>='A'&&_c_<='Z')?_c_-'A'+'a':_c_)
extern int szlen(char *s1);
extern char* szend(char *s1);
extern int szncpy(char *dst,char *src,int n);
extern int szncpy2(char *dst,char *s1,char *s2,int n);
extern int szncat2(char *dst,char *s1,char *s2,int n);
extern int sz2ncat2(char *dst,char *s1,char *s1x,char *s2,char *s2x,int n);
extern int sz2ncpy(char *dst,char *s1,char *s2,int n);
extern char* szskip(char *src,char *skip);
extern char* szskipto(char *src,char *skipto);
extern char* szskipover(char *src,char *skip);
extern char* szskipwhite(char *src);
extern char* szskiptowhite(char *src);
extern int szcmp(char *s1,char *s2);
extern char* szmid(char *s1,char *s2);
extern char* szchr(char *s1,char *s2,char c);
extern char* szrchr(char *s1,char *s2,char c);
extern int sznicmp(char *s1,char *s2,char *t1,char *t2,int n);
extern int sznfmt(char *dst,int n,char fmt,uns8 *dat);
extern char *szto(char *s1,char *s2,char type,int base,void *dst);
extern int szcmpx(char *s1,char *s2);
extern int sz2cmpx(char *s1,char *s2,char *t1,char *t2);
extern char* szATTok(char *src,char till,char *terms);
extern int sz2map(char *table[],char *str,char *strx);
extern char* szmatok(char *src,char till);
extern int szbuild(char *dst,int n,char *fmt,...);
extern int szbuild_ap(char *dst,int n,char *fmt,void *ap);
#endif // ndef STR_H

1001
dond/core/sys.c Executable file
View File

File diff suppressed because it is too large Load Diff

363
dond/core/sys.h Executable file
View File

@@ -0,0 +1,363 @@
#ifndef SYS_H
#define SYS_H
// sys.h
// Copyright 1998-2004 Play Mechanix Inc. All Rights Reserved
//
// GNP 05 May 00
// JFL 26 Aug 04
// JFL 20 Jul 05; simple protection
#define SYS_HARDWARESN1 0x100901CF // twins - sent to RAW THRILLS
#define SYS_HARDWARESN2 0x7CAF9417 // bears -- Test Cabinet
#define SYS_HARDWARESN3 0x58AAA47F // sox -- RawThrills Cabinet
#define SYS_HARDWARESN4 0x246C9FA4 // JAMMA 1 -- JAPAN
#define SYS_HARDWARESN5 0xA44E612F // JAMMA 2 -- JAPAN
#define SYS_HARDWARESN6 0xC458C6BD // AMOA 1 -- VEGAS BABY
#define SYS_HARDWARESN7 0x78D5224D // AMOA 2 -- VEGAS BABY
#define SYS_HARDWARESN8 0x9086987A // AMOA 3 -- VEGAS BABY
#define SYS_HARDWARESN9 0xE88AD32F // AMOA 4 -- VEGAS BABY
#define SYS_HARDWARESN10 0x303C3C68 // AMOA 5 -- VEGAS BABY --THESE 5 DOWN FOR AMOA
#define SYS_HARDWARESN11 0x80DEA837 // AMOA 6 -- VEGAS BABY
#define SYS_HARDWARESN12 0xF8575B4B // AMOA 7 -- VEGAS BABY
#define SYS_HARDWARESN13 0x708A365E // AMOA 8 -- VEGAS BABY
#define SYS_HARDWARESN14 0x748349A1 // AMOA 9 -- VEGAS BABY
#define SYS_HARDWARESN15 0xFC547341 // PM TEST
#define SYS_HARDWARESN16 0xF476FC22 // PM TEST 2
#define SYS_JAMMAXOR 0xAAAAAAAA // jamma sn is just xor'd
#define SYS_HARDSN(x) (((x)==SYS_HARDWARESN1) \
||(((x)==SYS_HARDWARESN2)) \
||(((x)==SYS_HARDWARESN3)) \
||(((x)==SYS_HARDWARESN4)) \
||(((x)==SYS_HARDWARESN5)) \
||(((x)==SYS_HARDWARESN6)) \
||(((x)==SYS_HARDWARESN7)) \
||(((x)==SYS_HARDWARESN8)) \
||(((x)==SYS_HARDWARESN9)) \
||(((x)==SYS_HARDWARESN10)) \
||(((x)==SYS_HARDWARESN11)) \
||(((x)==SYS_HARDWARESN12)) \
||(((x)==SYS_HARDWARESN13)) \
||(((x)==SYS_HARDWARESN14)) \
||(((x)==SYS_HARDWARESN15)) \
||(((x)==SYS_HARDWARESN16)))
#define SYS_JAMMASN(x) (((x)==(SYS_JAMMAXOR^SYS_HARDWARESN1)) \
||(((x)==(SYS_JAMMAXOR^SYS_HARDWARESN2))) \
||(((x)==(SYS_JAMMAXOR^SYS_HARDWARESN3))) \
||(((x)==(SYS_JAMMAXOR^SYS_HARDWARESN4))) \
||(((x)==(SYS_JAMMAXOR^SYS_HARDWARESN5))) \
||(((x)==(SYS_JAMMAXOR^SYS_HARDWARESN6))) \
||(((x)==(SYS_JAMMAXOR^SYS_HARDWARESN7))) \
||(((x)==(SYS_JAMMAXOR^SYS_HARDWARESN8))) \
||(((x)==(SYS_JAMMAXOR^SYS_HARDWARESN9))) \
||(((x)==(SYS_JAMMAXOR^SYS_HARDWARESN10))) \
||(((x)==(SYS_JAMMAXOR^SYS_HARDWARESN11))) \
||(((x)==(SYS_JAMMAXOR^SYS_HARDWARESN12))) \
||(((x)==(SYS_JAMMAXOR^SYS_HARDWARESN13))) \
||(((x)==(SYS_JAMMAXOR^SYS_HARDWARESN14))) \
||(((x)==(SYS_JAMMAXOR^SYS_HARDWARESN15))) \
||(((x)==(SYS_JAMMAXOR^SYS_HARDWARESN16))))
///////////////////////////////////////////////////////////////////////////////
// SYSTEM SPECIFIC
//-----------------------------------------------------------------------------
// SYS_JP5500
#if SYS_JP5500
//
// GENERAL
//
#define iprintf
#define sprintf
//
// SYSTEM-SPECIFIC
//
extern int xSysInit(void);
extern void xSysFinal(void);
extern int xSysReset(uns reset);
extern uns32 xSysHdwRev(void);
extern uns32 xSysGfxRev(void);
extern void xSysMilliSec(uns n);
extern uns64 xSysMicroSec(void);
extern void xSysNanoSec(uns n);
extern void xSysWatchdogDisable(void);
extern uns xSysIsDebuggerRunning(void);
extern void xSerPort1_init(char baud);
extern int xSerPort1_status(void);
extern char xSerPort1_in(void);
extern void xSerPort1_out(char c);
extern void xSerPort2_init(char baud);
extern int xSerPort2_status(void);
extern char xSerPort2_in(void);
extern void xSerPort2_out(char c);
extern void xSysRTClockStart(void);
extern void xSysRTClockStop(void);
extern uns32 xSysRTClockSec(void);
extern void xSysSetExcVector(void* vec);
extern int xSysSR(void);
extern void xSysSRSet(int x);
extern int xSysCause(void);
extern uns xSysCPUTimer(void);
extern int xSysWait(int *sem);
extern void xSysSignal(int *sem);
extern int xSysSRAndOr(int and,int or);
extern int xSysIntDisable(void);
extern int xSysIntEnable(void);
extern int xSysLock(volatile int *lock,int value);
extern void xSysCacheHWBInvalidate(void *adrlo,void *adrhi);
#define REGSAVE_NUM 40
extern void reg_save(uns64 regs[REGSAVE_NUM]);
extern void reg_restore(uns64 regs[REGSAVE_NUM]);
#endif // SYS_JP5500
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
// SYS_PC|SYS_BB
#if SYS_PC|SYS_BB
extern int xSysInit(void);
extern void xSysFinal(void);
extern int xSysReset(uns reset);
extern uns64 xSysMicroSec(void);
#endif // SYS_PC|SYS_BB
//-----------------------------------------------------------------------------
///////////////////////////////////////////////////////////////////////////////
// SYSTEM INDEPENDENT
#if PRODUCTION
#define M_SYSG_PROFLAGS_JAMMALIVES1 0x01
#define M_SYSG_PROFLAGS_JAMMALIVES2 0x02
#define M_SYSG_PROFLAGS_DONTFLIP 0x04
#define M_SYSG_PROFLAGS_CFFILEERROR 0x08
#endif // PRODUCTION
#define SYSG_VERSTR_SIZE 64
typedef struct {
uns mode;
uns8 restart;
uns8 proflags; // PRODUCTION
uns8 profailrgb[3]; // PRODUCTION
int projammasn; // PRODUCTION
uns8 cfg[32];
uns8 flags[32];
uns8 info[128];
char str[8][16]; // 8 16 character strings
uns16 n2FlagsOr;
uns8 quit;
int gunCalValidated;
int level;
int tag;
char *scriptStartS1;
char *scriptStartS2;
char log[1024];
uns forceFrameTime;
uns loop;
uns64 loopTime;
memu var[32];
char path[1024]; // for all data
char adjpath[256]; // for adjustments
char audpath[256]; // for audits
char cfpath[256]; // for parsed sequences
char plrpath[256]; // for player info
char trnpath[256]; // for tournament info
char lbdpath[256]; // for tournament info
char sndpath[256]; // for sound path
char logpath[256]; // for log path
char keymacros[8][16]; // 8 16 character strings
char *curSeq;
char *curProc;
char versionstr[SYSG_VERSTR_SIZE];
} SysGlobals;
typedef struct {
int sec; // 0..61(?)
int min; // 0..59
int hour; // 0..23
int mday; // 1..31
int mon; // 0..11
int year; // eg 2005
int wday; // 0..6 Sunday==0
int yday; // since jan 1 0..365
int isdst; // is daylight savings time
} SysDate;
enum uTimers {
UTIMER_FRAME,
UTIMER_SYS,
UTIMER_NET,
UTIMER_CAB,
UTIMER_WND,
UTIMER_WNDINP,
UTIMER_INP,
UTIMER_PROC,
UTIMER_OBJ,
UTIMER_DRAWINIT,
UTIMER_DRAWDISP1,
UTIMER_DRAWDISP2,
UTIMER_DRAWDISP2MATRIX,
UTIMER_DRAWDISP2CULL,
UTIMER_DRAWDISP2SORT,
UTIMER_DRAWDISP2SETUP1,
UTIMER_DRAWDISP2SETUP2,
UTIMER_DRAWDISP2COL,
UTIMER_DRAWDISP3,
UTIMER_DRAWDISP3MATRIX,
UTIMER_DRAWDISP3WEIGHT,
UTIMER_DRAWDISP3SETUP1,
UTIMER_DRAWDISP3SETUP2,
UTIMER_DRAWDISP3COL,
UTIMER_DRAWEMITPARTICLES,
UTIMER_DRAWFLIP,
UTIMER_DRAWSORT,
UTIMER_DRAWSHAD,
UTIMER_DRAWCAM,
UTIMER_DRAWTEXT,
UTIMER_OBJFUNC,
UTIMER_OBJANI,
UTIMER_OBJSEQ,
UTIMER_OBJVEL,
UTIMER_OBJCOL,
UTIMER_OBJRESOLVE,
UTIMER_GLUT,
NUM_UTIMERS
};
//
// SysTimer
// use for any type of system timer used in debugging
//
typedef struct _systimer {
uns64 timer; // the actual timer
uns64 timeacc; // time accumulator for starts and stops
char name[64]; // timer name
uns8 count; // number of timing measurements we have taken
} SysTimer;
extern void N1LinkTail(void *headp,void *node);
extern void N1LinkHead(void *headp,void *node);
extern int N1Unlink(void *headp,void *node);
extern void N2Head(void *head);
extern void N2DontLink(void *node);
extern void N2LinkAfter(void *head,void *node);
extern void N2LinkBefore(void *head,void *node);
extern void N2Unlink(void *node);
extern int N2Count(void *node);
extern void* N2Parent(void *node);
extern int N2MoveDead(void *n,void *deadlist);
extern char *N2Name(N2 *n,char **s2p);
enum {
// return codes for the scan func
N2SCANFUNC_MATCH_AND_RETURN,
N2SCANFUNC_CONTINUE
};
typedef struct {
N2 *stack[8];
int stacki;
N2 *wrapper;
ftype3 *func3; // int func(N2ScanRec *nsr,N2 *n) return N2SCANFUNC_
memu fdata; // function data
char *s1; // match string s1
char *s2; // match string s2
} N2ScanRec;
#define M_N2SCAN_VAL 0x0000ffff // used to pass values in
#define M_N2SCAN_SUB 0x00010000 // look for subtype
#define M_N2SCAN_FUNC 0x00020000 // function call
#define M_N2SCAN_NAME 0x00040000 // match the name
#define M_N2SCAN_PRIME 0x00100000 // find prime obj
#define M_N2SCAN_INIT 0x00200000 // this is the first call w/n2sr -- init
#define M_N2SCAN_DONTSCAN 0x00400000 // first and don't search (init only)
#define M_N2SCAN_NODEEPER 0x00800000 // dont scan deeper
#define M_N2SCAN_NOKIDS M_N2SCAN_NODEEPER // -- depricated
#define M_N2SCAN_WRAP 0x01000000 // wrap until start instead of till list end
#define M_N2SCAN_KIDSONLY 0x02000000 // kids only
extern void* N2Scan(N2ScanRec *n2sr,uns find,void *node);
extern int N2LevelSet(N2 *n,int lev);
extern int N2LevelGet(N2 *n);
extern int N2LevelCpy(N2 *dst,N2 *src);
extern int SysInit(void);
extern void SysFinal(void);
extern int SysReset(uns reset);
extern int SysLoop(void);
extern int SysLevelSet(int lev);
extern int SysLevelGet(void);
#define SysMilliSec xSysMilliSec
#define SysMicroSec xSysMicroSec
#define SysNanoSec xSysNanoSec
extern void SysWatchdogEnable(void);
extern void SysWatchdogDisable(void);
extern void SysWatchdogBone(void);
extern uns64 SysClockMilliSec(void);
extern void SysMicroTimerStart(uns32 timerNum);
extern void SysMicroTimerStop(uns32 timerNum);
extern void SysMicroTimerClear(uns32 timerNum);
extern void SysMicroTimerClearAll(void);
extern SysGlobals SysG;
extern SysTimer SysuTimers[];
extern SysLog(char *fmt,...);
extern int SysLogCheck(void);
#define MAIN_RESTART_ARGC_MAX 32
extern int MainRestartArgc;
extern char *MainRestartArgv[MAIN_RESTART_ARGC_MAX];
#define M_SYSTIMEDATE_GMT 0x0001
extern int SysDateTime(SysDate *dt,uns flags);
extern int SysDateTimeStr(SysDate *dt,char *buf,int bufsize,char *fmt);
extern uns32 SysDateTimeInSeconds(void);
#define SHIFT_NUM 5
#define SHIFT_BITS 28
extern uns32 sysEnc1(uns32 *dstp,uns32 a);
extern uns32 sysChk1(uns32 opseed, uns32 actcode);
extern uns32 sysDecode1(uns32 u,uns32 a);
enum {
SYSBUILDINFO_NONE,
SYSBUILDINFO_HARDWARESTRING,
SYSBUILDINFO_SOFTWARESTRING,
SYSBUILDINFO_HARDWARESN,
SYSBUILDINFO_HARDWARECP,
SYSBUILDINFO_GAMESN,
};
#define M_SYSBUILDINFO 0xff
extern int SysBuildInfo(uns op,char *buf,int bufsize,uns *idp);
enum {
SYSGETHARDWAREINFO_NONE,
SYSGETHARDWAREINFO_SN,
};
extern int SysGetHardwareInfo(uns op,char *buf,int bufsize);
extern void SysLoadVersionInfo(void);
extern void SysRestart(void);
#endif // ndef SYS_H

28
dond/core/test.c Executable file
View File

@@ -0,0 +1,28 @@
#include <stdio.h>
#include <stdlib.h>
main()
{
int i;
int n=1024*64;
char *p;
FILE *fh;
if(!(p=malloc(n)))
goto BAIL;
for(i=0;i<n;i++)
p[i]=i;
if(!(fh=fopen("test.bin","wb+")))
goto BAIL;
fwrite(p,n,1,fh);
BAIL:
if(p)
free(p);
if(fh)
close(fh);
return 0;
}

1796
dond/core/theorafunc.c Executable file
View File

File diff suppressed because it is too large Load Diff

190
dond/core/theorafunc.h Executable file
View File

@@ -0,0 +1,190 @@
// -------------------------------------------------------------------
// theorafunc.h - manny najera (11.28.06)
#ifndef _THEORAFUNC_H_
#define _THEORAFUNC_H_
// -------------------------------------------------------------------
#include <stdlib.h>
#include <stdio.h>
#ifndef WIN32
#ifdef SYS_BB
#include <GL/glut.h>
#else
#include <GL/freeglut.h>
#endif
#endif
#ifdef WIN32
#include <gl\glew.h>
#include "gl\glut.h"
#include <gl\gl.h>
#include <gl\glu.h>
#endif
#include <theora/theora.h>
// -------------------------------------------------------------------
#define THEORAFUNC_SYNCTIME 1
#define THEORAFUNC_CATCHUP 1
// -------------------------------------------------------------------
enum {
THEORAFUNC_NOALPHA = 0,
THEORAFUNC_ALPHA,
THEORAFUNC_ALPHA_STACKED,
};
enum {
TF_ENCODE_NOALPHA = 0,
TF_ENCODE_ALPHA,
};
typedef void (td_callback)(void);
// -------------------------------------------------------------------
// - lookup tables for YUV->RGB conversion
static int sAdjCrr[256];
static int sAdjCrg[256];
static int sAdjCbg[256];
static int sAdjCbb[256];
static int sAdjY[256];
static unsigned char sClampBuff[1024];
static unsigned char *sClamp = sClampBuff + 384;
// -------------------------------------------------------------------
// - lookup tables for RGB->YUV conversion
static int tableRy[256];
static int tableGy[256];
static int tableBy[256];
static int tableRu[256];
static int tableGu[256];
static int tableBu[256];
static int tableRv[256];
static int tableGv[256];
static int tableBv[256];
// -------------------------------------------------------------------
// - video data type
typedef struct {
ogg_sync_state oggSyncState;
ogg_page oggPage;
ogg_stream_state oggStreamState;
theora_info theoraInfo;
theora_comment theoraComment;
theora_state theoraState;
int theora_p;
int64 vidStartTicks;
int x, y, w, h;
unsigned int glTex;
int alpha;
int lastFrame;
int pixelSize;
int isPlaying;
int ignoreTime;
td_callback *onDoneCallback;
unsigned char *data;
int dataPos, dataSize;
char *linkedObject[128];
unsigned char *pixelBuff;
} theorafunc_data_t;
// -------------------------------------------------------------------
// - encoding data type
typedef struct {
ogg_stream_state to;
ogg_stream_state vo;
ogg_page og;
ogg_packet op;
theora_state td;
theora_info ti;
theora_comment tc;
FILE *outfile;
unsigned char *yuvFrame;
unsigned char *screen, *bScreen;
int numEncodedFrames;
int numEncodedBytes;
int w, h;
int alphaStack;
} theorafunc_encode_data_t;
// -------------------------------------------------------------------
GLuint textureArray[32];
// -------------------------------------------------------------------
extern void theorafunc_buildTables(void);
extern theorafunc_data_t *theorafunc_allocate(void);
//extern void theorafunc_init(theorafunc_data_t *td, char *filename, int glTex);
extern void theorafunc_init(theorafunc_data_t *td, unsigned char *data, int dataSize, int glTex);
extern void theorafunc_openVideo(theorafunc_data_t *td);
extern int theorafunc_readyVideo(theorafunc_data_t *td);
//extern int theorafunc_bufferData(FILE *in, ogg_sync_state *oy);
extern int theorafunc_bufferData(theorafunc_data_t *td);
extern int theorafunc_queuePage(theorafunc_data_t *td);
extern void theorafunc_videoWrite(theorafunc_data_t *td);
extern void theorafunc_videoWriteRGB(theorafunc_data_t *td);
extern void theorafunc_videoWriteRGBA(theorafunc_data_t *td);
extern void theorafunc_videoWriteStackedRGBA(theorafunc_data_t *td);
extern void theorafunc_restart(theorafunc_data_t *td);
extern void theorafunc_unload(theorafunc_data_t *td);
extern int64 theorafunc_getTime(void);
extern void encode_unload(theorafunc_encode_data_t *td);
extern void encode_init(theorafunc_encode_data_t *td, char *filename
, int w, int h, int bit_rate, int quality, int alphaStack);
extern void encode_buildTables(void);
extern void encode_frame(theorafunc_encode_data_t *td, int bpp, int final);
extern void copyFlippedScreen(unsigned char *src, unsigned char *dst
, int w, int h, int bpp, int alphaStack);
extern void theorafunc_animateG3(void);
extern int theorafunc_getFrame(char *name);
extern int disableMipMapping(char *name);
extern theorafunc_data_t *getVideoFromObject(char *name);
extern void theorafunc_loadVideo(char *name);
extern void theorafunc_unloadVideo(char *name);
extern int theorafunc_getBytesAlloced(void);
extern void theorafunc_vidalink(char *vidname, char *objname);
// -------------------------------------------------------------------
#endif

1435
dond/core/vec.c Executable file
View File

File diff suppressed because it is too large Load Diff

327
dond/core/vec.h Executable file
View File

@@ -0,0 +1,327 @@
#ifndef VEC_H
#define VEC_H
// vec.h
// Copyright 2004 Play Mechanix Inc. All Rights Reserved
//
// JFL 18 Oct 04
#define BOX_REL_W 640
#define BOX_REL_H 480
#define BOX_ABS_W 640
#define BOX_ABS_H 480
///////////////////////////////////////////////////////////////////////////////
//
typedef struct { crd a[Q_SIZE]; } QuatType;
typedef struct { crd a[V3_SIZE]; } V3Type;
typedef struct { crd a[M3_SIZE]; } M3Type;
typedef struct { float a[M3_SIZE]; } M3Typef;
typedef struct { crd a[M4_SIZE]; } M4Type;
typedef struct { crd a[VM_SIZE]; } VMType;
//
// V3
//
#define V3Zero(a) \
(a)[V3_X]=(a)[V3_Y]=(a)[V3_Z]=0
#define V3SetXYZ(a,x,y,z) \
(a)[V3_X]=x,(a)[V3_Y]=y,(a)[V3_Z]=z
#define V3SetVM(a,b) \
(a)[V3_X]=(b)[VM_X],(a)[V3_Y]=(b)[VM_Y],(a)[V3_Z]=(b)[VM_Z]
#define V3SetM4(a,b) \
(a)[V3_X]=(b)[M4_X],(a)[V3_Y]=(b)[M4_Y],(a)[V3_Z]=(b)[M4_Z]
#define V3AddV3(a,b) \
(a)[V3_X]+=(b)[V3_X],(a)[V3_Y]+=(b)[V3_Y],(a)[V3_Z]+=(b)[V3_Z]
#define V3Cpy(a,b) \
*((V3Type*)a)=*((V3Type*)b)
#define V3Add(dst,a,b) \
(dst)[V3_X]=(a)[V3_X]+(b)[V3_X], \
(dst)[V3_Y]=(a)[V3_Y]+(b)[V3_Y], \
(dst)[V3_Z]=(a)[V3_Z]+(b)[V3_Z]
#define V3Sub(dst,a,b) \
(dst)[V3_X]=(a)[V3_X]-(b)[V3_X], \
(dst)[V3_Y]=(a)[V3_Y]-(b)[V3_Y], \
(dst)[V3_Z]=(a)[V3_Z]-(b)[V3_Z]
#define V3MulM3(r,v,mat) \
(r)[0]=(v)[0]*(mat)[M3_11]+(v)[1]*(mat)[M3_12]+(v)[2]*(mat)[M3_13],\
(r)[1]=(v)[0]*(mat)[M3_21]+(v)[1]*(mat)[M3_22]+(v)[2]*(mat)[M3_23],\
(r)[2]=(v)[0]*(mat)[M3_31]+(v)[1]*(mat)[M3_32]+(v)[2]*(mat)[M3_33]
#define V3RotM3 V3MulM3
#define V3MulVM(r,v,vm) \
(r)[0]=(v)[0]*(vm)[VM_11]+(v)[1]*(vm)[VM_12]+(v)[2]*(vm)[VM_13]+(vm)[VM_X],\
(r)[1]=(v)[0]*(vm)[VM_21]+(v)[1]*(vm)[VM_22]+(v)[2]*(vm)[VM_23]+(vm)[VM_Y],\
(r)[2]=(v)[0]*(vm)[VM_31]+(v)[1]*(vm)[VM_32]+(v)[2]*(vm)[VM_33]+(vm)[VM_Z]
#define V3RotVM(r,v,vm) \
(r)[0]=(v)[0]*(vm)[VM_11]+(v)[1]*(vm)[VM_12]+(v)[2]*(vm)[VM_13],\
(r)[1]=(v)[0]*(vm)[VM_21]+(v)[1]*(vm)[VM_22]+(v)[2]*(vm)[VM_23],\
(r)[2]=(v)[0]*(vm)[VM_31]+(v)[1]*(vm)[VM_32]+(v)[2]*(vm)[VM_33]
#define V3MulM4(r,v,mat) \
(r)[0]=(v)[0]*(mat)[M4_11]+(v)[1]*(mat)[M4_12]+(v)[2]*(mat)[M4_13]+(mat)[M4_14],\
(r)[1]=(v)[0]*(mat)[M4_21]+(v)[1]*(mat)[M4_22]+(v)[2]*(mat)[M4_23]+(mat)[M4_24],\
(r)[2]=(v)[0]*(mat)[M4_31]+(v)[1]*(mat)[M4_32]+(v)[2]*(mat)[M4_33]+(mat)[M4_34]
#define V3RotM4(r,v,mat) \
(r)[0]=(v)[0]*(mat)[M4_11]+(v)[1]*(mat)[M4_12]+(v)[2]*(mat)[M4_13],\
(r)[1]=(v)[0]*(mat)[M4_21]+(v)[1]*(mat)[M4_22]+(v)[2]*(mat)[M4_23],\
(r)[2]=(v)[0]*(mat)[M4_31]+(v)[1]*(mat)[M4_32]+(v)[2]*(mat)[M4_33]
#define V3Cross(r,p,q) \
(r)[0] = (p)[1]*(q)[2] - (p)[2]*(q)[1],\
(r)[1] = (p)[2]*(q)[0] - (p)[0]*(q)[2],\
(r)[2] = (p)[0]*(q)[1] - (p)[1]*(q)[0]
#define V3Dot(p,q) \
(((p)[0])*((q)[0])+((p)[1])*((q)[1])+((p)[2])*((q)[2]))
#define V3DotXZ(p,q) \
(((p)[0])*((q)[0])+((p)[2])*((q)[2]))
extern crd V3Normalize(crd* v);
extern crd V3Unitize(crd* v,crd len);
extern crd V3Len(crd* v);
extern int V3NormalCW(crd *normal,crd *v0,crd *v1,crd *v2);
extern crd V3DistFast(crd *v0,crd *v1);
extern crd V3UnitizeFast(crd* v,crd len);
//
// M3
//
#define M3Cpy(a,b) \
*((M3Type*)(a))=*((M3Type*)(b))
#define M3Cpyf(a,b) \
*((M3Typef*)(a))=*((M3Typef*)(b))
#define M3Id(a) \
(a)[M3_11]=(a)[M3_22]=(a)[M3_33]=1, \
(a)[M3_12]=(a)[M3_13]=(a)[M3_21]= \
(a)[M3_23]=(a)[M3_31]=(a)[M3_32]=0
#define M3BuildScaleXYZ(a,x,y,z) \
(a)[M3_11]=(x),(a)[M3_22]=(y),(a)[M3_33]=(z), \
(a)[M3_12]=(a)[M3_13]=(a)[M3_21]= \
(a)[M3_23]=(a)[M3_31]=(a)[M3_32]=0
#define M3SetM4(a,b) \
(a)[M3_11]=(b)[M4_11],(a)[M3_12]=(b)[M4_12],(a)[M3_13]=(b)[M4_13], \
(a)[M3_21]=(b)[M4_21],(a)[M3_22]=(b)[M4_22],(a)[M3_23]=(b)[M4_23], \
(a)[M3_31]=(b)[M4_31],(a)[M3_32]=(b)[M4_32],(a)[M3_33]=(b)[M4_33]
#define M3VecMul(r,mat,v) \
(r)[0]=(v)[0]*(mat)[M3_11]+(v)[1]*(mat)[M3_12]+(v)[2]*(mat)[M3_13],\
(r)[1]=(v)[0]*(mat)[M3_21]+(v)[1]*(mat)[M3_22]+(v)[2]*(mat)[M3_23],\
(r)[2]=(v)[0]*(mat)[M3_31]+(v)[1]*(mat)[M3_32]+(v)[2]*(mat)[M3_33]
#define M3Mpy M3Mul
extern void M3FromQuat(crd *m,crd *q);
extern void M3Mul(crd *dst,crd *a,crd *b);
extern void M3ToQuat(crd* mat, crd* q);
extern int M3Inv(crd *dst,crd *src);
extern void M3BuildRot(crd *a,crd rad,int xyz);
extern void M3BuildObj(crd *dstm,crd *rots);
//
// M4
//
#define M4Cpy(a,b) \
*((M4Type*)a)=*((M4Type*)b)
#define M4Id(a) \
(a)[M4_11]=(a)[M4_22]=(a)[M4_33]=(a)[M4_44]=1,\
(a)[M4_12]=(a)[M4_13]=(a)[M4_14]=(a)[M4_21]=\
(a)[M4_23]=(a)[M4_24]=(a)[M4_31]=(a)[M4_32]=\
(a)[M4_34]=(a)[M4_41]=(a)[M4_42]=(a)[M4_43]=0
#define M4ClrVec(a) \
(a)[M4_44]=1,(a)[M4_X]=(a)[M4_Y]=(a)[M4_Z]=0
#define M4ClrCol(a) \
(a)[M4_41]=(a)[M4_42]=(a)[M4_43]=0
#define M4SetV3(a,b) \
(a)[M4_X]=(b)[V3_X],(a)[M4_Y]=(b)[V3_Y],(a)[M4_Z]=(b)[V3_Z]
#define M4AddV3(a,b) \
(a)[M4_X]+=(b)[V3_X],(a)[M4_Y]+=(b)[V3_Y],(a)[M4_Z]+=(b)[V3_Z]
#define M4SetXYZ(a,x,y,z) \
(a)[M4_X]=x,(a)[M4_Y]=y,(a)[M4_Z]=z
#define M4AddXYZ(a,x,y,z) \
(a)[M4_X]+=x,(a)[M4_Y]+=y,(a)[M4_Z]+=z
#define M4SetM3(a,b) \
(a)[M4_11]=(b)[M3_11],(a)[M4_12]=(b)[M3_12],(a)[M4_13]=(b)[M3_13], \
(a)[M4_21]=(b)[M3_21],(a)[M4_22]=(b)[M3_22],(a)[M4_23]=(b)[M3_23], \
(a)[M4_31]=(b)[M3_31],(a)[M4_32]=(b)[M3_32],(a)[M4_33]=(b)[M3_33]
#define M4Set3x3(a,r1,r2,r3,s1,s2,s3,t1,t2,t3) \
(a)[M4_11]=r1,(a)[M4_12]=r2,(a)[M4_13]=r3, \
(a)[M4_21]=s1,(a)[M4_22]=s2,(a)[M4_23]=s3, \
(a)[M4_31]=t1,(a)[M4_32]=t2,(a)[M4_33]=t3
#define M4SetVM(a,b) \
(a)[M4_11]=(b)[VM_11],(a)[M4_12]=(b)[VM_12],(a)[M4_13]=(b)[VM_13], \
(a)[M4_21]=(b)[VM_21],(a)[M4_22]=(b)[VM_22],(a)[M4_23]=(b)[VM_23], \
(a)[M4_31]=(b)[VM_31],(a)[M4_32]=(b)[VM_32],(a)[M4_33]=(b)[VM_33], \
(a)[M4_X]=(b)[VM_X],(a)[M4_Y]=(b)[VM_Y],(a)[M4_Z]=(b)[VM_Z], \
(a)[M4_41]=(a)[M4_42]=(a)[M4_43]=0,(a)[M4_44]=1
#define M4SetM4(a,b) \
(a)[M4_11]=(b)[M4_11],(a)[M4_12]=(b)[M4_12],(a)[M4_13]=(b)[M4_13], \
(a)[M4_21]=(b)[M4_21],(a)[M4_22]=(b)[M4_22],(a)[M4_23]=(b)[M4_23], \
(a)[M4_31]=(b)[M4_31],(a)[M4_32]=(b)[M4_32],(a)[M4_33]=(b)[M4_33], \
(a)[M4_X]=(b)[M4_X],(a)[M4_Y]=(b)[M4_Y],(a)[M4_Z]=(b)[M4_Z], \
(a)[M4_41]=(a)[M4_42]=(a)[M4_43]=0,(a)[M4_44]=1
#define M4VecMpy(r,v,mat) \
(r)[0]=(v)[0]*(mat)[M4_11]+(v)[1]*(mat)[M4_12]+(v)[2]*(mat)[M4_13]+(mat)[M4_14],\
(r)[1]=(v)[0]*(mat)[M4_21]+(v)[1]*(mat)[M4_22]+(v)[2]*(mat)[M4_23]+(mat)[M4_24],\
(r)[2]=(v)[0]*(mat)[M4_31]+(v)[1]*(mat)[M4_32]+(v)[2]*(mat)[M4_33]+(mat)[M4_34]
#define VMSetM4OGL(a,b) \
(a)[VM_11]=(b)[M4OGL_11],(a)[VM_12]=(b)[M4OGL_12],(a)[VM_13]=(b)[M4OGL_13], \
(a)[VM_21]=(b)[M4OGL_21],(a)[VM_22]=(b)[M4OGL_22],(a)[VM_23]=(b)[M4OGL_23], \
(a)[VM_31]=(b)[M4OGL_31],(a)[VM_32]=(b)[M4OGL_32],(a)[VM_33]=(b)[M4OGL_33], \
(a)[VM_X]=(b)[M4OGL_X],(a)[VM_Y]=(b)[M4OGL_Y],(a)[VM_Z]=(b)[M4OGL_Z]
#define M4OGLSetVM(a,b) \
(a)[M4OGL_11]=(b)[VM_11],(a)[M4OGL_12]=(b)[VM_12],(a)[M4OGL_13]=(b)[VM_13], \
(a)[M4OGL_21]=(b)[VM_21],(a)[M4OGL_22]=(b)[VM_22],(a)[M4OGL_23]=(b)[VM_23], \
(a)[M4OGL_31]=(b)[VM_31],(a)[M4OGL_32]=(b)[VM_32],(a)[M4OGL_33]=(b)[VM_33], \
(a)[M4OGL_X]=(b)[VM_X],(a)[M4OGL_Y]=(b)[VM_Y],(a)[M4OGL_Z]=(b)[VM_Z], \
(a)[M4OGL_41]=(a)[M4OGL_42]=(a)[M4OGL_43]=0,(a)[M4OGL_44]=1
extern void M4Mul(crd *dst,crd *a,crd *b);
extern int M4InvGeneral(crd *inv,crd *mat);
//
// VM
//
#define VMCpy(a,b) \
*((VMType*)a)=*((VMType*)b)
#define VMId(a) \
(a)[VM_11]=(a)[VM_22]=(a)[VM_33]=1, \
(a)[VM_12]=(a)[VM_13]=(a)[VM_21]= \
(a)[VM_23]=(a)[VM_31]=(a)[VM_32]=0, \
(a)[VM_X]=(a)[VM_Y]=(a)[VM_Z]=0
#define VMVecMul(r,v,vm) \
(r)[0]=(v)[0]*(vm)[VM_11]+(v)[1]*(vm)[VM_12]+(v)[2]*(vm)[VM_13]+(vm)[VM_X],\
(r)[1]=(v)[0]*(vm)[VM_21]+(v)[1]*(vm)[VM_22]+(v)[2]*(vm)[VM_23]+(vm)[VM_Y],\
(r)[2]=(v)[0]*(vm)[VM_31]+(v)[1]*(vm)[VM_32]+(v)[2]*(vm)[VM_33]+(vm)[VM_Z]
#define VMVecRot(r,v,vm) \
(r)[0]=(v)[0]*(vm)[VM_11]+(v)[1]*(vm)[VM_12]+(v)[2]*(vm)[VM_13],\
(r)[1]=(v)[0]*(vm)[VM_21]+(v)[1]*(vm)[VM_22]+(v)[2]*(vm)[VM_23],\
(r)[2]=(v)[0]*(vm)[VM_31]+(v)[1]*(vm)[VM_32]+(v)[2]*(vm)[VM_33]
#define VMSetM4(a,b) \
(a)[VM_11]=(b)[M4_11],(a)[VM_12]=(b)[M4_12],(a)[VM_13]=(b)[M4_13], \
(a)[VM_21]=(b)[M4_21],(a)[VM_22]=(b)[M4_22],(a)[VM_23]=(b)[M4_23], \
(a)[VM_31]=(b)[M4_31],(a)[VM_32]=(b)[M4_32],(a)[VM_33]=(b)[M4_33], \
(a)[VM_X]=(b)[M4_X],(a)[VM_Y]=(b)[M4_Y],(a)[VM_Z]=(b)[M4_Z]
#define VMSetXYZ(a,x,y,z) \
(a)[VM_X]=(x),(a)[VM_Y]=(y),(a)[VM_Z]=(z)
#define VMAddXYZ(a,x,y,z) \
(a)[VM_X]+=x,(a)[VM_Y]+=y,(a)[VM_Z]+=z
#define VMSetV3(a,b) \
(a)[VM_X]=(b)[V3_X],(a)[VM_Y]=(b)[V3_Y],(a)[VM_Z]=(b)[V3_Z]
#define VMAddV3(a,b) \
(a)[VM_X]+=(b)[V3_X],(a)[VM_Y]+=(b)[V3_Y],(a)[VM_Z]+=(b)[V3_Z]
#define VMSubV3(a,b) \
(a)[VM_X]-=(b)[V3_X],(a)[VM_Y]-=(b)[V3_Y],(a)[VM_Z]-=(b)[V3_Z]
#define VMBuildRot(a,rad,xyz) \
(a)[VM_X]=(a)[VM_Y]=(a)[VM_Z]=0,M3BuildRot(&((crd*)(a))[3],rad,xyz)
#define VMMul VMMpy
extern void VMInv(crd *dst,crd *a);
extern void VMMpy(crd *dst,crd *a,crd *b);
extern void VMCat(crd *dst,crd *a,crd *b);
extern void VMMlt(crd *dst,crd *cur,crd *add);
extern void VMClean(crd *dst);
extern void VMBuildObj(crd *dst,crd *rots,crd *trans,crd *scale);
//
// QUAT
//
#define QuatId(a) \
(a)[Q_X]=(a)[Q_Y]=(a)[Q_Z]=0,(a)[Q_W]=1
#define QuatCpy(a,b) \
*((QuatType*)a)=*((QuatType*)b)
extern void QuatToM3(crd* q, crd* mat);
extern void QuatNormalize(crd *q);
extern void QuatMul(crd *d,crd *a,crd *b);
extern void QuatAxisToAxis(crd *qdst,crd *a,crd *b);
//
// BOX
//
#define BOXSetXY(a,x,y) \
(a)[BOX_X]=x,(a)[BOX_Y]=y
#define BOXRelXY(a,x,y) \
(a)[BOX_X]=(x*BOX_REL_W/BOX_ABS_W),(a)[BOX_Y]=y*BOX_REL_H/BOX_ABS_H
#define BOXSetWH(a,w,h) \
(a)[BOX_W]=w,(a)[BOX_H]=h
//
// OTHER
//
extern float MathBlendRot(float rot0,float rot1,float blend0,float blend1);
extern float MathSqrt(float a);
extern float MathFastSqrt(float a);
extern double MathCosSind(double a,double *sinp);
extern crd MathCosSin(crd a,crd *sinp);
extern int MathPDUToCamM4(crd *m4,crd *pos,crd *dir,crd *up);
extern int MathCamToPDUM4(crd *m4,crd *pos,crd *dir,crd *up);
extern void MathQSort(void *pbase,int total_elems,int size,
int (*cmp)(void*,void*));
extern void MathNrmToRot(crd *nrm,crd *rot);
extern void MathM3ToRot(crd *m3,crd *rot);
extern void MathM3ToScale(crd *m,crd *scale);
extern void MathM3Unscale(crd *m,crd *scale);
extern crd MathACos(crd a);
extern crd MathASin(crd a);
extern crd MathATan(crd a);
extern crd MathTan(crd a);
extern void RandUSeed(uns seed);
extern uns RandU(uns top);
extern float RandFOne(void);
extern float RandFRange(float low,float high);
#endif // ndef VEC_H

193
dond/core/vid.h Executable file
View File

@@ -0,0 +1,193 @@
#ifndef VID_H
#define VID_H
// vid.h
// Copyright 2004 Play Mechanix Inc. All Rights Reserved
//
// JFL 29 Aug 04
///////////////////////////////////////////////////////////////////////////////
// SYSTEM DEPENDENT
//-----------------------------------------------------------------------------
// SYS_JP5500
#if SYS_JP5500
enum
{
VID_FOG_TABLE_LINEAR,
VID_FOG_TABLE_EXP,
VID_FOG_TABLE_EXP2,
};
typedef struct
{
uns16 screenW;
uns16 screenH;
uns16 centerX;
uns16 centerY;
uns32 flags;
} VidDispInfo;
extern void VidGenerateAndLoadFogTable(int type, float val1, float val2,float min,float max);
extern void VidSysVBLRender(void);
extern void VidSysRenderInterrupt(void);
#define VidIsPlayingMovie() (VidMovieState>1)
extern void VidMovieFrame(void *vid);
extern int VidMovieState;
#endif // SYS_JP5500
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
// SYS_PC|SYS_BB
#if SYS_PC|SYS_BB
#define M_VIDDISP_DBGDISP_NODISP3B 0x01
#define M_VIDDISP_DBGDISP_NODISP3 0x02
#define M_VIDDISP_DBGDISP_FRUST 0x04
#define M_VIDDISP_DBGDISP_FRUST2 0x08
#define M_VIDDISP_DBGDISP_DONTCULL 0x10
#define M_VIDDISP_DBGDISP_NODISP2 0x20
#define M_VIDDISP_DBGDISP_TEX2X2 0x40
#define M_VIDDISP_DBGDISP_LOD 0x80
#define M_VIDDISP_DBGCOL_WIRE 0x01
#define M_VIDDISP_DBGCOL_SKELCOL 0x02
#define M_VIDDISP_DBGCOL_FULL 0x04
#define M_VIDDISP_DBGCOL_GNDBOXES 0x08
#define M_VIDDISP_DBGBENCH_TIMERS 0x01
#define M_VIDDISP_DBGBENCH_DRAWSTATISTICS 0x02
#define M_VIDDISP_DBGBENCH_APIINFO 0x04
#define M_VIDDISP_DBGBENCH_LOGTIMERS 0x08
typedef struct
{
// must be supported by all implementations
uns16 screenW;
uns16 screenH;
uns16 centerX;
uns16 centerY;
uns32 flags;
int fogMode;
float fogDensity;
float fogNear;
float fogFar;
float fogRGBA[4];
float mipMin;
float mipMax;
float anisotropic;
uns8 shadowRGBA[4]; // always used for color
float shadowDist; // always used for dist
float shadowPos[3]; // only if M_VIDDISP_GSHADOW (else use light
int maxLights;
int maxTexWidthHeight;
int texAllocs;
int texMem;
float gridSize;
int gridDim;
uns8 dbgcol;
uns8 dbgshad;
uns8 dbgdisp;
uns8 dbgbench;
int8 dontFlip;
uns8 showCursor;
uns8 bSupportVBO;
uns8 bSoftwareVSync; //limited software VSync support available
uns32 bHardwareVSync; //hardware is handling VSync
int vSyncStart;
uns32 normalFrames;
uns32 droppedFrames;
uns32 vsyncTimeouts;
uns64 VSyncTimerStart; //micro second time stamp since last known vsync
char dbgbb[4][256];
uns64 dbgTime0;
uns64 dbgTime1;
uns64 dbgTime2;
uns dbg2x2;
char *apiVendor;
char *apiVersion;
char *apiRenderer;
char *apiExtensions;
uns32 minTri; //less than, do not draw
uns32 minQuad; //less than, do not draw
char findResName[64]; //use to BP on a given display resource
int32 objDListCount; //count of current object display lists
} VidDispInfo;
#define VID_MAXLIGHTS 8
// OpenGL doesn't seem to have these..
// http://www.opengl.org/documentation/specs/version1.2/1.2specs/texture_lod.txt
#define GL_TEXTURE_MIN_LOD 0x813A
#define GL_TEXTURE_MAX_LOD 0x813B
#define GL_TEXTURE_MAX_ANISOTROPY_EXT 0x84FE
#define GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT 0x84FF
enum {
VIDDRAW_NONE,
VIDDRAW_JOINT,
VIDDRAW_AXIS,
VIDDRAW_GRID,
VIDDRAW_NUB,
VIDDRAW_SPHERE,
VIDDRAW_001,
VIDDRAW_PROJECTILE,
};
extern void xVidDraw(uns shape,float scale); // in res_pc.c
#endif // SYS_PC|SYS_BB
//-----------------------------------------------------------------------------
///////////////////////////////////////////////////////////////////////////////
// SYSTEM INDEPENDENT
extern int VidInit(void);
extern void VidFinal(void);
extern int VidReset(uns reset);
#define M_VIDDISP_MINFILTER 0x00000001
#define M_VIDDISP_MAGFILTER 0x00000002
#define M_VIDDISP_WIREFRAME 0x00000004
#define M_VIDDISP_MIPMAP 0x00000008
#define M_VIDDISP_BACKFACE 0x00000010
#define M_VIDDISP_QUALITY 0x00000020
#define M_VIDDISP_BLEND 0x00000040
#define M_VIDDISP_ONEPASSBLEND 0x00000080
#define M_VIDDISP_FOG 0x00000100
#define M_VIDDISP_FOG_C 0x00000200
#define M_VIDDISP_GRID 0x00000400
#define M_VIDDISP_JOINTS 0x00000800
#define M_VIDDISP_NUBS 0x00001000
#define M_VIDDISP_LIGHTS 0x00002000
#define M_VIDDISP_CPFAILURE 0x00004000
#define M_VIDDISP_DONTFLIP 0x00010000
#define M_VIDDISP_SHADOWS 0x00020000
#define M_VIDDISP_PROCHECK 0x00040000 // PRODUCTION
#define M_VIDDISP_PROFAIL 0x00100000 // PRODUCTION
#define M_VIDDISP_GSHADOW 0x00200000 // use VidDisp.shadow (global shadow)
#define M_VIDDISP_GSHADOW_DIR 0x00400000 // directional shadow (else positional)
#define M_VIDDISP_SYNC_VBLANK 0x00800000 // sync to vblank when set
extern VidDispInfo VidDisp;
extern int VidStart(void);
extern void* VidFrameStart(void);
extern void VidFrameEnd(void *vid);
extern void VidDrawSetRenderDest(void *vid,uns32 flags);
extern void VidGrabViewingMatrices(void);
extern int VidWorldPos(crd *screenxyz,crd *pos);
extern int VidScreenPos(crd *worldxyz,crd *pos);
extern int VidMovieInit(void);
extern void VidMovieFinal(void);
extern int VidMovieReset(void);
#endif // ndef VID_H

65
dond/core/wnd.h Executable file
View File

@@ -0,0 +1,65 @@
#ifndef WND_H
#define WND_H
// wnd.h
// Copyright 2004 Play Mechanix Inc. All Rights Reserved
//
// JFL 11 Oct 04
///////////////////////////////////////////////////////////////////////////////
// SYSTEM DEPENDENT
//-----------------------------------------------------------------------------
// SYS_PC
#if SYS_PC
#ifndef _WINDOWS_
#include <windows.h>
#endif
typedef struct {
HINSTANCE hinst;
HWND hwnd;
HDC hdc;
HGLRC hrc;
uns8 ready;
uns8 quit;
uns8 fullScreen;
int w,h;
} WndRec;
extern int WndOpen(memu hinst,uns w,uns h,uns flags);
extern void WndClose(void);
#endif // SYS_PC
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
// SYS_BB
#if SYS_BB
typedef struct {
void *priv;
uns8 ready;
uns8 quit;
uns8 fullScreen;
int w,h;
} WndRec;
extern int WndOpen(uns w,uns h,uns flags);
extern void WndClose(void);
#endif // SYS_BB
//-----------------------------------------------------------------------------
///////////////////////////////////////////////////////////////////////////////
// SYSTEM INDEPENDENT
extern int WndInit(void);
extern void WndFinal(void);
extern int WndReset(uns reset);
extern int WndLoop(void);
extern int WndInpLoop(void);
extern void* WndCur(void);
extern void WndSwap(WndRec *wnd);
#endif // ndef WND_H

175
dond/corebb/int_bb.c Executable file
View File

@@ -0,0 +1,175 @@
#if SYS_BB
// int_bb.c
// Play Mechanix - Video Game System
// Copyright (c) 1998-2004 Play Mechanix Inc. All Rights Reserved
//
// GNP 01 Sep 00
// JFL 26 Aug 04
// JFL 07 Oct 04
#include "pm.h"
#include "sys.h"
#include "mem.h"
#include "int.h"
enum {
INT_DEVICE_SW0,
INT_DEVICE_SW1,
INT_DEVICE_IP2,
INT_DEVICE_IP3,
INT_DEVICE_IP4,
INT_DEVICE_IP5,
INT_DEVICE_IP6,
INT_DEVICE_TIMER,
INT_DEVICE_RTC,
INT_DEVICE_IDE1, // first FPGA
INT_DEVICE_IDE2,
INT_DEVICE_SERIAL0,
INT_DEVICE_ETHERNET,
INT_DEVICE_RENDER,
INT_DEVICE_SOUNDDMA,
INT_DEVICE_DISPLAY,
INT_DEVICE_SERIAL1,
INT_DEVICE_GUN0,
INT_DEVICE_GUN1,
INT_DEVICE_COUNT
};
typedef struct {
int enabled;
} IntDeviceRec;
IntDeviceRec intDevices[INT_DEVICE_COUNT];
//
// IntInit
// one time initialization at power-up
//
// in:
// out:
// global:
//
// GNP 01 Sep 00
// JFL 07 Oct 04
//
int IntInit(void)
{
//
// RESET VARS
//
MEMZ(intDevices);
return 0;
} // IntInit
//
// IntReset
// called every time system is reset
//
// in:
// out:
// global:
//
// GNP 01 Sep 00
// JFL 07 Oct 04
//
int IntReset(uns reset)
{
return 0;
} // IntReset
//
// IntFinal
// called once upon system shutdown
//
// in:
// out:
// global:
//
// GNP 01 Sep 00
//
void IntFinal(void)
{
} // IntFinal
// JFL 31 Aug 04
int intDeviceEnable(int dev,int enable)
{
int ec;
if(dev>=INT_DEVICE_COUNT)
{
BP(BP_INTDEVICEENABLE);
return -1;
}
intDevices[dev].enabled=enable;
switch(dev)
{
case INT_DEVICE_SW0:
case INT_DEVICE_SW1:
case INT_DEVICE_IP2:
case INT_DEVICE_IP3:
case INT_DEVICE_IP4:
case INT_DEVICE_IP5:
case INT_DEVICE_IP6:
case INT_DEVICE_TIMER:
case INT_DEVICE_IDE1:
case INT_DEVICE_IDE2:
case INT_DEVICE_SERIAL0:
case INT_DEVICE_SERIAL1:
case INT_DEVICE_RTC:
case INT_DEVICE_ETHERNET:
case INT_DEVICE_SOUNDDMA:
case INT_DEVICE_RENDER:
case INT_DEVICE_DISPLAY:
case INT_DEVICE_GUN0:
case INT_DEVICE_GUN1:
BP(BP_INTDEVICEENABLE2);
err(-2);
} // switch
ec=0;
BAIL:
if(ec<0)
BP(BP_INTDEVICEENABLE3);
return ec;
} // intDeviceEnable()
///////////////////////////////////////////////////////////////////////////////
//
// JFL 31 Aug 04
int IntAttach(void)
{
//
// INSTALL LOW LEVEL EXCEPTION HANDLERS
//
return 0;
} // IntAttach()
// JFL 31 Aug 04
void IntDetach(void)
{
BP(BP_INTDETACH); // unlink our node..??
} // IntDetach()
//
// IntEnable
//
// in:
// out:
// global:
//
// GNP 24 Mar 03
// JFL 31 Aug 04
void IntEnable(uns intMask,int enable)
{
} // IntEnable()
#endif // SYS_BB
//EOF

455
dond/corebb/main_bb.c Executable file
View File

@@ -0,0 +1,455 @@
#if SYS_BB
// main_bb.c
// Play Mechanix - Video Game System
// Copyright 1998-2005 Play Mechanix Inc. All Rights Reserved
//
// JFL 26 Aug 04
// JFL 07 Oct 04
// JFL 21 Jan 05; linux black box version started
// #include <windows.h>
// WIN32,_DEBUG,_WINDOWS,_MBCS,SYS_BB
// user32.lib gdi32.lib comdlg32.lib shell32.lib uuid.lib opengl32.lib core.lib
// freeglut demo: _DEBUG,WIN32,_CONSOLE,_MBCS,FREEGLUT_STATIC
#include <GL/glut.h>
#include "pm.h"
#include "sys.h"
#include "int.h"
#include "mem.h"
#include "fb.h"
#include "fs.h"
#include "vid.h"
#include "net.h"
#include "res.h"
#include "obj.h"
#include "font.h"
#include "inp.h"
#include "cab.h"
#include "gun.h"
#include "game.h"
#include "str.h"
#include "proc.h"
#include "wnd.h"
#include "snd.h"
#include <time.h> // also need rt lib
#include <malloc.h>
#include <stdarg.h>
// strings for time and date stamp of build
#define BUILD_TIME __TIME__
#define BUILD_DATE __DATE__
// to create a soft link: ln -s ~/donddata data
#define SCRIPT_START "set(str1 atstart) run(perm)"
#define PATH_START "donddata/hd_pc;donddata/cf;donddata/snd"
#define AUDIT_PATH "/donduser/aud"
#define ADJUST_PATH "/donduser/adj"
#define CF_PATH "donddata/cf"
#define PLR_PATH "/donduser/players"
#define TRN_PATH "/donduser/tourneys"
#define LBD_PATH "/donduser/lboards"
#define SND_PATH "donddata/snd"
#define LOG_PATH "/donduser/log/"
void* jps_memdebug_ptr[2048];
uns jps_memdebug_size[2048];
int MainRestartArgc=0;
char *MainRestartArgv[MAIN_RESTART_ARGC_MAX];
// JFL 26 Aug 04
// JFL 07 Oct 04
// JFL 21 Jan 05
int main(int argc0,char **argv0)
{
int ec;
char *s1,*s2;
uns wndopenflags;
int argc;
char **argv;
SysDate dt;
int swidth, sheight, sresType;
argc=argc0;
argv=argv0;
restart:
wndopenflags=1; // default to full screen
//
// GUARANTEED INITS
//
SysWatchdogDisable();
//
// INIT ALL SYSTEMS
//
for(ec=0;ec<COUNT(jps_memdebug_ptr);ec++)
jps_memdebug_ptr[ec]=NULL;
ec=0;
if(SysInit()<0) ec=1;
if(IntInit()<0) ec=1;
if(MemInit()<0) ec=1;
if(ProcInit()<0) ec=1;
if(FbInit()<0) ec=1;
if(WndInit()<0) ec=1;
if(InpInit()<0) ec=1;
if(GunInit()<0) ec=1;
if(CabInit()<0) ec=1;
if(VidInit()<0) ec=1;
if(DrawInit()<0) ec=1;
if(FsInit()<0) ec=1;
if(NetInit()<0) ec=1;
if(FTPInit()<0) ec=1;
if(SndInit()<0) ec=1;
if(ResInit()<0) ec=1;
if(ObjInit()<0) ec=1;
if(FontInit()<0) ec=1;
if(GameInit()<0) ec=1;
if(ec)
goto BAIL;
argc--;argv++;
while(argc)
{
if((*argv)[0]=='-')
{
switch((*argv)[1])
{
case 'c':
// cursor
VidDisp.showCursor=1; // turn cursor on
break;
case 'n':
if(!szcmp("nobp",&(*argv)[1]))
SysPMBreakpointBehavior=1;
break;
case 's':
s1=s2=&(*argv)[2];
s2+=szlen(s1);
SysG.scriptStartS1=s1;
SysG.scriptStartS2=s2;
break;
case 'w':
if((*argv)[2]=='s')
{
wndopenflags=0;
break;
}
case 'f':
if((*argv)[2]=='s')
{
wndopenflags=1;
break;
}
if(!C_IS_DIGIT((*argv)[2]))
SysG.forceFrameTime=RES_FRAME_TIME;
else
{
szto(&(*argv)[2],NUL,'i',0,&ec);
SysG.forceFrameTime=ec;
}
break;
case 'v':
szto(&(*argv)[2],NUL,'i',0,&ec);
SndVolMinMax(NUL,&ec,1); // set max volume
break;
} // switch
}
argc--;argv++;
} // while
if(!SysG.scriptStartS1)
{
SysG.scriptStartS1=SysG.scriptStartS2=SCRIPT_START;
SysG.scriptStartS2+=sizeof(SCRIPT_START)-1;
}
if(!SysG.path[0])
szncpy(SysG.path,PATH_START,sizeof(SysG.path));
if(!SysG.adjpath[0])
szncpy(SysG.adjpath,ADJUST_PATH,sizeof(SysG.adjpath));
if(!SysG.audpath[0])
szncpy(SysG.audpath,AUDIT_PATH,sizeof(SysG.audpath));
if(!SysG.cfpath[0])
szncpy(SysG.cfpath,CF_PATH,sizeof(SysG.cfpath));
if(!SysG.plrpath[0])
szncpy(SysG.plrpath,PLR_PATH,sizeof(SysG.plrpath));
if(!SysG.trnpath[0])
szncpy(SysG.trnpath,TRN_PATH,sizeof(SysG.trnpath));
if(!SysG.lbdpath[0])
szncpy(SysG.lbdpath,LBD_PATH,sizeof(SysG.lbdpath));
if(!SysG.sndpath[0])
szncpy(SysG.sndpath,SND_PATH,sizeof(SysG.sndpath));
if(!SysG.logpath[0])
szncpy(SysG.logpath,LOG_PATH,sizeof(SysG.logpath));
//
// RESET ALL SYSTEMS TO THEIR NORMAL STATE
//
if(MemReset(0)<0) ec=1;
if(SysReset(0)<0) ec=1;
if(IntReset(0)<0) ec=1;
if(FsReset(0)<0) ec=1;
if(FbReset(0)<0) ec=1;
if(ProcReset(0)<0) ec=1;
if(WndReset(0)<0) ec=1;
if(FontReset(0)<0) ec=1;
if(ResReset(0)<0) ec=1;
if(ObjReset(0)<0) ec=1;
if(InpReset(0)<0) ec=1;
if(VidReset(0)<0) ec=1;
if(DrawReset(0)<0) ec=1;
if(NetReset(0)<0) ec=1;
if(FTPReset(0)<0) ec=1;
SysLoadVersionInfo(); // load the software version information
SysLogCheck();
SysLog("------------------------------\n");
SysLog(" Welcome to Deal or No Deal\n");
SysLog("------------------------------\n");
#if PRODUCTION
szbuild(SysG.log,sizeof(SysG.log),"Version: %02d.%02d.%02d RELEASE",MAJOR_VERSION, MINOR_VERSION, SUB_MINOR_VERSION);
#else
szbuild(SysG.log,sizeof(SysG.log),"Version: %02d.%02d.%02d DEBUG",MAJOR_VERSION, MINOR_VERSION, SUB_MINOR_VERSION);
#endif
SysLog("%s\n",SysG.log);
szbuild(SysG.log,sizeof(SysG.log),"Build: %s %s",__DATE__,__TIME__);
SysLog("%s\n",SysG.log);
SysDateTime(&dt,0);
SysDateTimeStr(&dt,SysG.log,sizeof(SysG.log),"%B %d %Y %H:%M:%S");
SysLog("Current time: %s\n",SysG.log);
//
// CREATE VIDEO WINDOW/SCREEN
//
// setup and open a window or the screen
// this block is system dependent
sresType = FB_RESOLUTION_1366x768;
switch (sresType)
{
case FB_RESOLUTION_1366x768:
swidth = 1366;
sheight = 768;
break;
default:
case FB_RESOLUTION_640x480:
swidth = 640;
sheight = 480;
break;
case FB_RESOLUTION_512x384:
swidth = 512;
sheight = 384;
break;
case FB_RESOLUTION_400x256:
swidth = 400;
sheight = 256;
break;
case FB_RESOLUTION_320x240:
swidth = 320;
sheight = 240;
break;
}
if((ec=FbSetMode(sresType))<0)
goto BAIL;
if((ec=WndOpen(swidth,sheight,wndopenflags))<0)
goto BAIL;
if((ec=VidStart())<0)
goto BAIL;
//
//
//
// GameLoop();
glutDisplayFunc((void(*)(void))GameLoop);
glutMainLoop(); // does not come back
//
//
//
ec=0;
BAIL:
WndClose();
GameFinal();
FontFinal();
ObjFinal();
SndFinal();
ResFinal();
NetFinal();
FsFinal();
VidFinal();
GunFinal();
CabFinal();
InpFinal();
WndFinal();
FbFinal();
ProcFinal();
MemFinal();
IntFinal();
SysFinal();
for(ec=0;ec<COUNT(jps_memdebug_ptr);ec++)
{
if(jps_memdebug_ptr[ec])
BP(BP_UNASSIGNED); // stranded memory! -- jps_memdebug_ptr[ec]
} // for
if(MainRestartArgc)
{
argc=MainRestartArgc;
MainRestartArgc=0;
argv=MainRestartArgv;
goto restart;
}
return ec;
} // main()
//
// SOUND SYSTEM HOOKS
//
void jps_apphook_memadd(void *p,uns size)
{
int i;
for(i=0;i<COUNT(jps_memdebug_ptr);i++)
{
if(!jps_memdebug_ptr[i])
{
jps_memdebug_ptr[i]=p;
jps_memdebug_size[i]=size;
MemSysInfo.jpsOutstanding+=size;
MemSysInfo.jpsCount++;
if(MemSysInfo.jpsLargest<(int)size)
MemSysInfo.jpsLargest=(int)size;
break;
}
} // for
} // jps_apphook_memadd()
void jps_apphook_memdel(void *p)
{
int i;
for(i=0;i<COUNT(jps_memdebug_ptr);i++)
{
if(jps_memdebug_ptr[i]==p)
{
jps_memdebug_ptr[i]=NULL;
MemSysInfo.jpsOutstanding-=jps_memdebug_size[i];
jps_memdebug_size[i]=0;
MemSysInfo.jpsCount--;
break;
}
} // for
} // jps_apphook_memdel()
void* jps_apphook_malloc(unsigned long size)
{
void *p;
p=malloc(size);
jps_apphook_memadd(p,size);
return p;
} // jps_apphook_malloc()
void jps_apphook_free(void* p)
{
jps_apphook_memdel(p);
free(p);
} // jps_apphook_free()
unsigned long jps_apphook_clock_sec(void)
{
static int gotorg=0;
static struct timespec org_time;
struct timespec cur_time;
if(clock_gettime(CLOCK_REALTIME, &cur_time))
return 0;
if(!gotorg)
{
gotorg=1;
org_time.tv_sec=cur_time.tv_sec;
}
return cur_time.tv_sec-org_time.tv_sec;
} // jps_apphook_clock_sec()
void jps_apphook_msg(char *fmt,...)
{
char buf[2048];
va_list args;
va_start(args,fmt);
vsprintf(buf,fmt,args);
SysLog("JPS: %s",buf);
va_end(args);
} // jps_apphook_msg()
void* jamma_apphook_malloc(int size)
{
return malloc(size);
} // jamma_apphook_malloc()
void jamma_apphook_free(void *m)
{
free(m);
} // jamma_apphook_free()
void jamma_apphook_msg(char *fmt,...)
{
char buf[2048];
va_list args;
va_start(args,fmt);
vsprintf(buf,fmt,args);
SysLog("JAMMA: %s",buf);
// BP(); // jamma system message in buf
va_end(args);
} // jamma_apphook_msg()
//
// jamma_apphook_sysmillisec
// return the current system millisecond timer
//
// in:
// out:
// global:
//
// GNP 13 Jan 06
//
unsigned long long jamma_apphook_sysmillisec(void)
{
return(SysMilliSec());
//DONE("jamma_apphook_sysmillisec")
} // jamma_apphook_sysmillisec
#endif // SYS_BB
// EOF

349
dond/corebb/sys_bb.c Executable file
View File

@@ -0,0 +1,349 @@
#if SYS_BB
// sys_pc.c
// Play Mechanix - Video Game System
// Copyright (c) 2004 Play Mechanix Inc. All Rights Reserved
//
// JFL 26 Aug 04
// JFL 07 Oct 04
//#include <GL/freeglut.h>
#include <GL/glut.h>
#include <sys/time.h>
#include <asm/msr.h>
#include <stdio.h>
#include <fcntl.h>
#include <unistd.h>
#include <signal.h>
#include "pm.h"
#include "str.h"
#include "sys.h"
#include "mem.h"
#include "aud.h"
#include "obj.h"
#include "game.h"
uns64 sysTimeBase;
float sysPTimerResolution; // Performance timer millions of ticks per second
char sigBuf[256]; // buffer for building signal log strings
// forward
uns64 xSysMilliSec(void);
float xSysGetPTimerResolution(void);
//
// fSignalHandler
// handle fatal signal trap
//
void fSignalHandler (int sigNo, void *p)
{
struct sigcontext *context = (struct sigcontext *) &p;
char *s1;
AudException();
switch(sigNo)
{
case SIGABRT:
s1 = "SIGABRT";
break;
case SIGSEGV:
s1 = "SIGSEGV";
break;
case SIGBUS:
s1 = "SIGBUS";
break;
case SIGFPE:
s1 = "SIGFPE";
break;
case SIGQUIT:
s1 = "SIGQUIT";
break;
case SIGILL:
s1 = "SIGILL";
break;
case SIGSYS:
s1 = "SIGSYS";
break;
default:
s1 = "<unknown>";
break;
}
SysLog("********************************\n");
SysLog(" Received FATAL signal %s (%d)\n", s1,sigNo);
SysLog("********************************\n");
sprintf(sigBuf,"gs: %04X fs: %04X es: %04X ds: %04X\n",context->gs, context->fs, context->es, context->ds);
SysLog(sigBuf);
sprintf(sigBuf, "edi: %08X esi: %08X ebp: %04X esp: %04X\n",context->edi, context->esi, context->ebp, context->esp);
SysLog(sigBuf);
sprintf(sigBuf, "ebx: %08X edx: %08X ecx: %08X eax: %08X\n", context->ebx, context->edx, context->ecx, context->eax);
SysLog(sigBuf);
sprintf(sigBuf, "trap: %d err: %d eip: %08X cs: %04X\n",context->trapno, context->err, context->eip, context->cs);
SysLog(sigBuf);
sprintf(sigBuf, "flag: %08X SP: %08X ss: %04X cr2: %08X\n",context->eflags, context->esp_at_signal, context->ss, context->cr2);
SysLog(sigBuf);
SysLog("Program exiting...\n");
// fatal, exit hopefully with no core dump
exit(-1);
}
//
// fTrapHandler
// handle debug trap
//
void fTrapHandler (int sigNo, void *p)
{
struct sigcontext *context = (struct sigcontext *) &p;
AudBadTrap();
SysLog("*******************************\n");
SysLog(" Received TRAP signal SIGTRAP (%d) ***\n", sigNo);
SysLog("*******************************\n");
sprintf(sigBuf,"gs: %04X fs: %04X es: %04X ds: %04X\n",context->gs, context->fs, context->es, context->ds);
SysLog(sigBuf);
sprintf(sigBuf, "edi: %08X esi: %08X ebp: %04X esp: %04X\n",context->edi, context->esi, context->ebp, context->esp);
SysLog(sigBuf);
sprintf(sigBuf, "ebx: %08X edx: %08X ecx: %08X eax: %08X\n", context->ebx, context->edx, context->ecx, context->eax);
SysLog(sigBuf);
sprintf(sigBuf, "trap: %d err: %d eip: %08X cs: %04X\n",context->trapno, context->err, context->eip, context->cs);
SysLog(sigBuf);
sprintf(sigBuf, "flag: %08X SP: %08X ss: %04X cr2: %08X\n",context->eflags, context->esp_at_signal, context->ss, context->cr2);
SysLog(sigBuf);
SysLog("Program continuing...\n");
// let's try to return
return;
}
// JFL 07 Oct 04
int xSysInit(void)
{
struct sigaction sSegvHdl;
sysPTimerResolution = xSysGetPTimerResolution();
// sysTimeBase=glutGet(GLUT_ELAPSED_TIME);
sysTimeBase=xSysMilliSec();
// install signal handlers
sSegvHdl.sa_flags = SA_ONESHOT;
sSegvHdl.sa_handler = (void(*)(int))fSignalHandler;
sigemptyset (&sSegvHdl.sa_mask);
// segmentation fault
if (sigaction (SIGSEGV, &sSegvHdl, NULL) != 0)
SysLog("xSysInit(): cannot install SIGSEGV handler\n");
// floating point error
if (sigaction (SIGFPE, &sSegvHdl, NULL) != 0)
SysLog("xSysInit(): cannot install SIGFPE handler\n");
// illegal instruction
if (sigaction (SIGILL, &sSegvHdl, NULL) != 0)
SysLog("xSysInit(): cannot install SIGILL handler\n");
// bus fault
if (sigaction (SIGBUS, &sSegvHdl, NULL) != 0)
SysLog("xSysInit(): cannot install SIGBUS handler\n");
// abort()
if (sigaction (SIGABRT, &sSegvHdl, NULL) != 0)
SysLog("xSysInit(): cannot install SIGABRT handler\n");
// non-existant system call
if (sigaction (SIGSYS, &sSegvHdl, NULL) != 0)
SysLog("xSysInit(): cannot install SIGSYS handler\n");
// quit
if (sigaction (SIGQUIT, &sSegvHdl, NULL) != 0)
SysLog("xSysInit(): cannot install SIGQUIT handler\n");
sSegvHdl.sa_handler = (void(*)(int))fTrapHandler;
// trap
if (sigaction (SIGTRAP, &sSegvHdl, NULL) != 0)
SysLog("xSysInit(): cannot install SIGTRAP handler\n");
return 0;
} // xSysInit()
// JFL 07 Oct 04
void xSysFinal(void)
{
} // xSysFinal()
// JFL 07 Oct 04
int xSysReset(uns reset)
{
return 0;
} // xSysReset()
// GNP 17 Jun 03
void SysWatchdogEnable(void)
{
} // SysWatchdogEnable()
// GNP 17 Jun 03
void SysWatchdogDisable(void)
{
} // SysWatchdogDisable()
// GNP 17 Jun 03
void SysWatchdogBone(void)
{
} // SysWatchdogBone
// JFL 07 Oct 04
void* SysAdr(void)
{
return NUL;
} // SysAdr()
// JFL 07 Oct 04
void SysLockup(int id)
{
// SysLog("LOCKUP: %x\n",adr);
SysLog("LOCKUP: %d\n",(int)id);
GameSysLog(GAMESYSLOG_STATE);
} // SysLockup()
//
// SysClockMilliSec
//
//
// in:
// out:
// global:
//
// JFL 08 Nov 04
// GNP 11 Jan 06; changed to use high resolution proc timer (more accurate)
//
uns64 SysClockMilliSec(void)
{
uns64 newTime;
if(SysG.forceFrameTime)
return SysG.loopTime;
else
{
newTime = xSysMilliSec();
if (newTime < sysTimeBase)
{
newTime = newTime + (uns64)0xffffffffffffffff - sysTimeBase;
}
else
{
newTime = newTime - sysTimeBase;
}
// return glutGet(GLUT_ELAPSED_TIME)-sysTimeBase;
return(newTime);
}
//DONE("SysClockMilliSec")
} // SysClockMilliSec
//
// xSysMilliSec
// return current system timer in milli-seconds
//
// in:
// out:
// global:
//
// GNP 10 Jan 06
//
uns64 xSysMilliSec(void)
{
uns64 retval;
double fTime;
uns32 time_low, time_high;
rdtsc(time_low, time_high);
retval = ((uns64)time_high << 32) + (uns64)time_low;
fTime = (double)retval;
fTime = fTime/(double)(sysPTimerResolution * 1000.0);
retval = (uns64)fTime;
return(retval);
//DONE("xSysMilliSec")
} // xSysMilliSec
//
// xSysMicroSec
// return current system micro-second counter
//
// in:
// out:
// global:
//
// GNP 12 Oct 05
//
uns64 xSysMicroSec(void)
{
uns64 retval;
double fTime;
uns32 time_low, time_high;
rdtsc(time_low, time_high);
retval = ((uns64)time_high << 32) + (uns64)time_low;
fTime = (double)retval;
fTime = fTime/(double)sysPTimerResolution;
retval = (uns64)fTime;
return(retval);
//DONE("xSysMicroSec")
} // xSysMicroSec
//
// xSysGetPTimerResolution
// get system performance timer resolution
// in millions of ticks per second
float xSysGetPTimerResolution(void)
{
char path_to_procfile[32];
char cpuinfo_buffer[256];
int procfile = 0;
int index;
char *ptr = NULL;
float cpuspeed_inMhz = 0.0f;
// read cpu speed from /proc/cpuinfo
sprintf(path_to_procfile, "/proc/cpuinfo");
procfile = open(path_to_procfile, O_RDONLY);
index = read(procfile, cpuinfo_buffer, sizeof(cpuinfo_buffer)-1);
cpuinfo_buffer[index] = '\0';
close(procfile);
ptr = strstr(cpuinfo_buffer, "MHz");
ptr = strstr(ptr, ":");
// search for first non-whitespace character, or just...
ptr += 2;
// got the cpuspeed!
sscanf(ptr, "%f", &cpuspeed_inMhz);
return(cpuspeed_inMhz);
}
// JFL 20 Jul 05
int SysGetHardwareInfo(uns op,char *buf,int bufsize)
{
int ec;
ec=0;
return ec;
} // SysGetHardwareInfo()
///////////////////////////////////////////////////////////////////////////////
//
#endif // SYS_BB
// EOF

882
dond/corebb/wnd_bb.c Executable file
View File

@@ -0,0 +1,882 @@
#if SYS_BB
// wnd_bb.c
// Play Mechanix - Video Game System
// Copyright (c) 2004 Play Mechanix Inc. All Rights Reserved
//
// JFL 29 Aug 04; from ah/fb.c
// JFL 26 Jan 05; Xwindow version
#include <X11/Xlib.h>
#include <X11/keysym.h>
#include <X11/cursorfont.h>
#include <GL/glut.h>
//#define GLX_SGIX_fbconfig 1
#include <GL/glx.h>
#include "pm.h"
#include "mem.h"
#include "obj.h"
#include "vec.h"
#include "vid.h"
#include "inp.h"
#include "sys.h"
#include "wnd.h"
#include "font.h"
extern void GameInputFunction(int numPressed);
WndRec wndlist;
typedef struct {
Display *disp;
int scr;
Window rootWin;
int con;
Atom delWin;
Window h;
GLXContext ctxt;
Cursor curs;
} WndX11Rec;
typedef struct {
int window;
} WndGLRec;
typedef struct {
uns keyFlags;
} WndPrivates;
WndX11Rec syswnd;
WndGLRec syswndGL;
WndPrivates wndG;
// JFL 07 Oct 04
int WndInit(void)
{
MEMZ(wndlist);
MEMZ(syswnd);
MEMZ(syswndGL);
MEMZ(wndG);
return 0;
} // WndInit()
// JFL 07 Oct 04
void WndFinal(void)
{
} // WndFinal()
// JFL 07 Oct 04
int WndReset(uns reset)
{
MEMZ(wndG);
return 0;
} // WndReset()
void* WndCur(void)
{
return &wndlist;
} // WndCur()
// JFL 12 Nov 04
int xInpLowScan(void)
{
if(wndG.keyFlags)
InpLowEvent(INPLOWEVENT_NOP|wndG.keyFlags,NUL);
return 0;
} // xInpLowScan()
//
// WaitForVSync
// wait until vsync count is one greater than just after the last swap
//
// in:
// out:
// global:
//
// GNP 11 Jan 06
//
void WaitForVSync (void)
{
if (!VidDisp.bHardwareVSync
&& VidDisp.bSoftwareVSync && (VidDisp.flags&M_VIDDISP_SYNC_VBLANK))
{
unsigned int count, newCount;
uns64 sanityTime;
glXGetVideoSyncSGI(&count);
// if we have sync'd, just continue, no waiting
// if (count != VidDisp.vSyncStart)
// {
// if(count - VidDisp.vSyncStart < 5)
// VidDisp.droppedFrames += count - VidDisp.vSyncStart;
// VidDisp.vSyncStart=count;
// return;
// }
sanityTime = SysMilliSec() + 6; // max 1/3 frame wait
while(sanityTime > SysMilliSec())
{
// glXGetVideoSyncSGI(&count);
glXGetVideoSyncSGI(&newCount);
// if (count != VidDisp.vSyncStart)
if (count != newCount)
{
VidDisp.VSyncTimerStart = SysMicroSec();
VidDisp.normalFrames++;
VidDisp.vSyncStart=count;
return;
}
}
VidDisp.vsyncTimeouts++;
}
//DONE("WaitForVSync")
} // WaitForVSync
void WndSwap(WndRec *wnd)
{
WaitForVSync();
// swap the buffers
glutSwapBuffers();
// grab starting vsync number
// if (VidDisp.bSoftwareVSync)
// glXGetVideoSyncSGI(&VidDisp.vSyncStart);
}
// JFL 07 Oct 04
void wndCloseGL(WndRec *wnd)
{
} // wndCloseGL
void renderScene(void) {
glClear(GL_COLOR_BUFFER_BIT);
glBegin(GL_TRIANGLES);
glVertex3f(-0.5,-0.5,0.0);
glVertex3f(0.5,0.0,0.0);
glVertex3f(0.0,0.5,0.0);
glEnd();
glFlush();
glutSwapBuffers();
}
void reshape(int w, int h)
{
int err;
int i;
glViewport(0, 0, w, h); /* Establish viewing area to cover entire window. */
}
#if 0 // from Sam
void osmousebtn(int button, int state,int x,int y)
{
int m;
m = glutGetModifiers();
if (m & GLUT_ACTIVE_ALT)
osio.alt = 1;
else
osio.alt = 0;
osio.newdata = 1;
osio.newx = x;
osio.newy = y;
//GLUT_LEFT_BUTTON, GLUT_MIDDLE_BUTTON, or GLUT_RIGHT_BUTTON
//GLUT_UP or GLUT_DOWN
if (button == GLUT_LEFT_BUTTON)
{
if (state == GLUT_DOWN)
{
osio.left = 1;
}
else
osio.left = 0;
}
if (button == GLUT_MIDDLE_BUTTON)
{
if (state == GLUT_DOWN)
{
osio.center = 1;
}
else
osio.center = 0;
}
if (button == GLUT_RIGHT_BUTTON)
{
if (state == GLUT_DOWN)
{
osio.right = 1;
}
else
osio.right = 0;
}
}
void osmouse(int x,int y)
{
int m;
m = glutGetModifiers();
osio.newdata = 1;
osio.newx = x;
osio.newy = y;
}
#endif
//
// wndKeys
// all key processing ultimately comes through here
// this function should only be called by key functions registerd with
// GLUT. this function is not meant to be registered.
// only for keys that map to ASCII characters
//
// in:
// key = key code
// x = mouse x pos
// y = mouse y pos
// down = if true, key is down
// out:
// global:
//
// GNP 29 Dec 05
//
void wndKeys(unsigned char key, int x, int y, int down)
{
int m;
char keys[32];
uns32 flags=0;
m = glutGetModifiers();
// check <Alt> key
if (m & GLUT_ACTIVE_ALT)
{
flags|=M_INPLOWEVENT_ALT;
}
// check <Shift> key
if (m & GLUT_ACTIVE_SHIFT)
{
flags|=M_INPLOWEVENT_SHF;
}
// check <Ctrl> key
if (m & GLUT_ACTIVE_CTRL)
{
flags|=M_INPLOWEVENT_CTL;
}
keys[0]=(char)key;
keys[1]=0;
switch (key)
{
case 27: //ESC
if (down)
InpLowEvent(INPLOWEVENT_SYS_ESC_DOWN,keys);
else
InpLowEvent(INPLOWEVENT_SYS_ESC_UP,keys);
break;
default:
if (down)
InpLowEvent(INPLOWEVENT_SYS_KEYS_DOWN|flags,keys);
else
InpLowEvent(INPLOWEVENT_SYS_KEYS_UP|flags,keys);
break;
}
//DONE("wndKeys")
} // wndKeys
//
// wndSpecialKeys
// all special key processing ultimately comes through here
// this function should only be called by key functions registerd with
// GLUT. this function is not meant to be registered.
// only for keys have special mappings (i.e. F1-F12, up, down, etc)
//
// in:
// key = key code
// x = mouse x pos
// y = mouse y pos
// down = if true, key is down
// out:
// global:
//
// GNP 29 Dec 05
//
void wndSpecialKeys(unsigned char key, int x, int y, int down)
{
int m;
char keys[32];
uns32 flags=0;
m = glutGetModifiers();
// check <Alt> key
if (m & GLUT_ACTIVE_ALT)
{
flags|=M_INPLOWEVENT_ALT;
}
// check <Shift> key
if (m & GLUT_ACTIVE_SHIFT)
{
flags|=M_INPLOWEVENT_SHF;
}
// check <Ctrl> key
if (m & GLUT_ACTIVE_CTRL)
{
flags|=M_INPLOWEVENT_CTL;
}
keys[0]=(char)key;
keys[1]=0;
switch (key)
{
case GLUT_KEY_LEFT:
if (down)
InpLowEvent(INPLOWEVENT_P0_L_DOWN|flags,NUL);
else
InpLowEvent(INPLOWEVENT_P0_L_UP|flags,NUL);
break;
case GLUT_KEY_RIGHT:
if (down)
InpLowEvent(INPLOWEVENT_P0_R_DOWN|flags,NUL);
else
InpLowEvent(INPLOWEVENT_P0_R_UP|flags,NUL);
break;
case GLUT_KEY_UP:
if (down)
InpLowEvent(INPLOWEVENT_P0_U_DOWN|flags,NUL);
else
InpLowEvent(INPLOWEVENT_P0_U_UP|flags,NUL);
break;
case GLUT_KEY_DOWN:
if (down)
InpLowEvent(INPLOWEVENT_P0_D_DOWN|flags,NUL);
else
InpLowEvent(INPLOWEVENT_P0_D_UP|flags,NUL);
break;
case GLUT_KEY_F1:
case GLUT_KEY_F2:
case GLUT_KEY_F3:
case GLUT_KEY_F4:
case GLUT_KEY_F5:
case GLUT_KEY_F6:
case GLUT_KEY_F7:
case GLUT_KEY_F8:
case GLUT_KEY_F9:
case GLUT_KEY_F10:
case GLUT_KEY_F11:
case GLUT_KEY_F12:
keys[0]=(char)(key-GLUT_KEY_F1+INPKEY_F1);
keys[1]=0;
if (down)
InpLowEvent(INPLOWEVENT_SYS_KEYS_DOWN|flags,keys);
else
InpLowEvent(INPLOWEVENT_SYS_KEYS_UP|flags,keys);
break;
default:
;
break;
}
//DONE("wndSpecialKeys")
} // wndSpecialKeys
//
// wndKeysDown
// function to process keyboard presses
// GLUT version
//
// in:
// out:
// global:
//
// GNP 06 Nov 05
//
void wndKeysDown(unsigned char key,int x,int y)
{
switch (key)
{
case 52:
case 53:
case 54:
case 55:
case 56:
case 57:
GameInputFunction(key - 48);
break;
}
wndKeys(key,x,y,1);
} // wndKeysDown
//
// wndKeysUp
// function to process keyboard releases
// GLUT function
//
// in:
// out:
// global:
//
// GNP 29 Dec 05
//
void wndKeysUp(unsigned char key,int x,int y)
{
switch (key)
{
case 52:
case 53:
case 54:
case 55:
case 56:
case 57:
GameInputFunction(-1 * (key - 48));
break;
}
wndKeys(key,x,y,0);
//DONE("wndKeysUp")
} // wndKeysUp
//
// wndSpecialKeysDown
// function to process keyboard special presses
// GLUT version
//
// in:
// out:
// global:
//
// GNP 06 Nov 05
//
void wndSpecialKeysDown(int key,int x,int y)
{
wndSpecialKeys(key,x,y,1);
//DONE("wndSpecialKeysDown")
} // wndSpecialKeysDown
//
// wndSpecialKeysUp
// function to process keyboard special releases
// GLUT version
//
// in:
// out:
// global:
//
// GNP 29 Dec 05
//
void wndSpecialKeysUp(int key,int x,int y)
{
wndSpecialKeys(key,x,y,0);
//DONE("wndSpecialKeysUp")
} // wndSpecialKeysUp
// function to handle mouse clicks
// GTR 10Aug2006
void wndMouseClick(int button, int state, int x, int y)
{
int whichButton; // remembers which mouse button
int downUp; // remembers the mouse button state
switch(button)
{
case GLUT_LEFT_BUTTON:
whichButton = 0; // left
break;
case GLUT_RIGHT_BUTTON:
whichButton = 1; // right
break;
}
switch(state)
{
case GLUT_DOWN:
downUp = 0; // down
break;
case GLUT_UP:
downUp = 10; // up
break;
}
switch(whichButton + downUp)
{
case 0:
InpLowEvent(INPLOWEVENT_MOUSE_LB_DOWN, NUL);
break;
case 1:
InpLowEvent(INPLOWEVENT_MOUSE_RB_DOWN, NUL);
break;
case 10:
InpLowEvent(INPLOWEVENT_MOUSE_LB_UP, NUL);
break;
case 11:
InpLowEvent(INPLOWEVENT_MOUSE_RB_UP, NUL);
break;
}
}
// function to handle mouse motion
// GTR 10Aug2006
void wndMouseMotion(int x, int y)
{
crd buf[4];
buf[0] = x;
buf[1] = y;
InpLowEvent(INPLOWEVENT_MOUSE_MOVE_XY,buf);
}
const char *wtitle="PlayMechanix";
int InitGLWindow(WndRec *wnd,int x,int y,int w,int h)
{
int ret = 0;
int argc=3;
char argv1[64]="dondcontext";
char argv2[64]="-display";
char argv3[64]=":0.0";
char *pargv[] = {argv1, argv2, argv3};
char modestr[64];
//init glut and the OpenGL window
//set the mode to RGBA, with Alpha and depth, double buffered
glutInit(&argc, (char **)&pargv);
glutInitDisplayMode (GLUT_RGBA|GLUT_DOUBLE|GLUT_ALPHA|GLUT_DEPTH|GLUT_STENCIL );
glutInitWindowSize((int)w, (int)h);
glutInitWindowPosition(x,y);
if(wnd->fullScreen)
{
// Sam's way of full screening
sprintf(modestr,"%dx%d:32@60",w,h);
glutGameModeString(modestr);
syswndGL.window = glutEnterGameMode();
// other way
// glutFullScreen();
}
else
syswndGL.window = glutCreateWindow(wtitle);
wnd->w=w;
wnd->h=h;
// not really necessary
glutSetWindow(syswndGL.window);
// need this for both Win and Lin
glutSetCursor(GLUT_CURSOR_NONE);
// no keyboard in production mode
#if !PRODUCTION
// keyboard and mouse input handlers
glutKeyboardFunc(wndKeysDown);
glutKeyboardUpFunc(wndKeysUp);
glutSpecialFunc(wndSpecialKeysDown);
glutSpecialUpFunc(wndSpecialKeysUp);
// Mouse input handlers
if(!VidDisp.showCursor)
{
VidDisp.showCursor=2; // dont-change
glutSetCursor(GLUT_CURSOR_NONE);
}
else if(VidDisp.showCursor==1)
{
VidDisp.showCursor=2; // dont-change
glutSetCursor(GLUT_CURSOR_CROSSHAIR);
glutMouseFunc(wndMouseClick);
glutMotionFunc(wndMouseMotion);
glutPassiveMotionFunc(wndMouseMotion);
}
// make GLUT ingnore key repeats
glutIgnoreKeyRepeat(1);
#endif //!PRODUCTION
glutReshapeFunc(reshape);
return(0);
}
// JFL 07 Oct 04
int WndOpen(uns w,uns h,uns flags)
{
int ec;
WndRec *wnd=&wndlist;
if(flags&1)
wnd->fullScreen=1;
else
wnd->fullScreen=0;
if((ec=InitGLWindow(wnd,0,0,w,h))<0)
goto BAIL;
wnd->ready=1;
ec=0;
BAIL:
return ec;
} // WndOpen()
// JFL 07 Oct 04
void WndClose(void)
{
WndRec *wnd=&wndlist;
if(wnd->ready)
wndCloseGL(wnd);
wnd->ready=0;
} // WndClose
int WndInpLoop(void)
{
return WndLoop();
}
// JFL 07 Oct 04
int WndLoop(void)
{
int ec;
WndRec *wnd=&wndlist;
#if 0
WndX11Rec *wndx;
XEvent event;
int x,y;
KeySym key;
char keys[32];
uns flags;
if(!wnd || !(wndx=wnd->priv) || !wnd->ready)
err(1);
wndx=wnd->priv=&syswnd;
XSync(wndx->disp,0);
while(XEventsQueued(wndx->disp,QueuedAfterFlush))
{
XNextEvent( wndx->disp, &event );
switch(event.type)
{
case Expose:
while (XCheckTypedEvent(wndx->disp, Expose, &event))
;
break;
case ClientMessage:
// Destroy the window when the WM_DELETE_WINDOW message arrives
if( (Atom) event.xclient.data.l[ 0 ] == wndx->delWin )
{
wnd->quit=1;
}
break;
case CreateNotify:
case ConfigureNotify:
x = event.xconfigure.width;
y = event.xconfigure.height;
glXMakeCurrent(wndx->disp,wndx->h,wndx->ctxt);
glViewport(0,0,x,y);
// callback to change aspect
break;
case ButtonPress:
// position: event.xbutton.x,y;
x=INPLOWEVENT_MOUSE_LB_DOWN;
if(event.xbutton.button==Button2)
x=INPLOWEVENT_MOUSE_CB_DOWN;
else if(event.xbutton.button==Button3)
x=INPLOWEVENT_MOUSE_RB_DOWN;
InpLowEvent(x,NUL);
break;
case ButtonRelease:
x=INPLOWEVENT_MOUSE_LB_UP;
if(event.xbutton.button==Button2)
x=INPLOWEVENT_MOUSE_CB_UP;
else if(event.xbutton.button==Button3)
x=INPLOWEVENT_MOUSE_RB_UP;
InpLowEvent(x,NUL);
break;
case MotionNotify:
buf[0] = event.xmotion.x;
buf[1] = event.xmotion.y;
InpLowEvent(INPLOWEVENT_MOUSE_MOVE_XY,buf);
break;
case KeyPress:
flags=0;
keys[0]=0;
//XLookupString((XKeyEvent *)&event, keys,sizeof(keys), &key, NULL);
key=XLookupKeysym((XKeyEvent *)&event,0);
keys[0]=key;
keys[1]=0;
switch (key)
{
case XK_KP_4:
case XK_KP_Left:
case XK_Left:
InpLowEvent(INPLOWEVENT_P0_L_DOWN,NUL);
break;
case XK_KP_6:
case XK_KP_Right:
case XK_Right:
InpLowEvent(INPLOWEVENT_P0_R_DOWN,NUL);
break;
case XK_KP_8:
case XK_KP_Up:
case XK_Up:
InpLowEvent(INPLOWEVENT_P0_U_DOWN,NUL);
break;
case XK_KP_2:
case XK_KP_Down:
case XK_Down:
InpLowEvent(INPLOWEVENT_P0_D_DOWN,NUL);
break;
case XK_Next:
InpLowEvent(INPLOWEVENT_P0_D2_DOWN,NUL);
break;
case XK_Prior:
InpLowEvent(INPLOWEVENT_P0_U2_DOWN,NUL);
break;
case XK_Escape:
InpLowEvent(INPLOWEVENT_SYS_ESC_DOWN,NUL);
break;
case XK_F1:
case XK_F2:
case XK_F3:
case XK_F4:
case XK_F5:
case XK_F6:
case XK_F7:
case XK_F8:
case XK_F9:
case XK_F10:
case XK_F11:
case XK_F12:
keys[0]=key-XK_F1+INPKEY_F1;
keys[1]=0;
InpLowEvent(INPLOWEVENT_SYS_KEYS_DOWN|flags,keys);
break;
case XK_Shift_L:
case XK_Shift_R:
wndG.keyFlags|=M_INPLOWEVENT_SHF;
InpLowEvent(INPLOWEVENT_FLAGS|wndG.keyFlags,NUL);
break;
case XK_Control_L:
case XK_Control_R:
wndG.keyFlags|=M_INPLOWEVENT_CTL;
InpLowEvent(INPLOWEVENT_FLAGS|wndG.keyFlags,NUL);
break;
case XK_Alt_L:
case XK_Alt_R:
wndG.keyFlags|=M_INPLOWEVENT_ALT;
InpLowEvent(INPLOWEVENT_FLAGS|wndG.keyFlags,NUL);
break;
default:
//keys[0]=key&0xff;
//keys[1]=0;
InpLowEvent(INPLOWEVENT_SYS_KEYS_DOWN|flags,keys);
break;
} // switch
break; // KeyPress
case KeyRelease:
flags=0;
keys[0]=0;
XLookupString((XKeyEvent *)&event, keys,sizeof(keys), &key, NULL);
switch (key)
{
case XK_Left:
InpLowEvent(INPLOWEVENT_P0_L_UP,NUL);
break;
case XK_Right:
InpLowEvent(INPLOWEVENT_P0_R_UP,NUL);
break;
case XK_Up:
InpLowEvent(INPLOWEVENT_P0_U_UP,NUL);
break;
case XK_Down:
InpLowEvent(INPLOWEVENT_P0_D_UP,NUL);
break;
case XK_Next:
InpLowEvent(INPLOWEVENT_P0_D2_UP,NUL);
break;
case XK_Prior:
InpLowEvent(INPLOWEVENT_P0_U2_UP,NUL);
break;
case XK_Escape:
InpLowEvent(INPLOWEVENT_SYS_ESC_UP,NUL);
break;
case XK_F1:
case XK_F2:
case XK_F3:
case XK_F4:
case XK_F5:
case XK_F6:
case XK_F7:
case XK_F8:
case XK_F9:
case XK_F10:
case XK_F11:
case XK_F12:
keys[0]=key-XK_F1+INPKEY_F1;
keys[1]=0;
InpLowEvent(INPLOWEVENT_SYS_KEYS_UP|flags,keys);
break;
case XK_Shift_L:
case XK_Shift_R:
wndG.keyFlags&=~M_INPLOWEVENT_SHF;
InpLowEvent(INPLOWEVENT_FLAGS|wndG.keyFlags,NUL);
break;
case XK_Control_L:
case XK_Control_R:
wndG.keyFlags&=~M_INPLOWEVENT_CTL;
InpLowEvent(INPLOWEVENT_FLAGS|wndG.keyFlags,NUL);
break;
case XK_Alt_L:
case XK_Alt_R:
wndG.keyFlags&=~M_INPLOWEVENT_ALT;
InpLowEvent(INPLOWEVENT_FLAGS|wndG.keyFlags,NUL);
break;
default:
//keys[0]=key&0xff;
//keys[1]=0;
InpLowEvent(INPLOWEVENT_SYS_KEYS_UP|flags,keys);
break;
} // switch
break; // KeyRelease
} // switch
} // while
#endif
ec=0;
BAIL:
if(wnd->quit)
ec=-1;
return ec;
} // WndLoop()
// JFL 28 Oct 04
void errlog(char *msg)
{
#if PRODUCTION
SysLog("ERRLOG: %s\n",msg);
#else // !PRODUCTION
WndRec *wnd=&wndlist;
static dontshow=0;
if(!dontshow)
{
}
#endif // !PRODUCTION
} // errlog()
#endif // SYS_BB
// EOF

455
dond/coregl/diag_gl.c Executable file
View File

@@ -0,0 +1,455 @@
#if SYS_GL
// diag_gl.c
// Play Mechanix - Video Game System
// Copyright (c) 2004-2005 Play Mechanix Inc. All Rights Reserved
//
// PRF 20 JUN 05
#include <stdarg.h>
#include "pm.h"
#include "sys.h"
#ifdef SYS_BB
#include <GL/glut.h>
#else
#include <GL/freeglut.h>
#endif
#include "mem.h"
#include "int.h"
#include "diag.h"
#include "str.h"
#include "obj.h"
#include "fb.h"
#include "res.h"
#include <math.h> // sqrt, cos, sin
#define S_X 640
#define S_Y 480
#define XY_MULT 10
crd x[3] = {4.0, 59.0, 32.0};
crd y[3] = {43.0, 4.0, 24.0};
int glDiagDrawDot(void *objv)
{
Extra_Tab_t * Extra_Tab = (void*)&((ObjFunc*)objv)[1];
float xx,yy,d;
switch(Extra_Tab->n)
{
case 0:
case 1:
xx = x[Extra_Tab->n]; //put bullet in cent er of target
yy = y[Extra_Tab->n];
break;
case 2:
xx=Extra_Tab->x/XY_MULT; //convert to font coords
yy=(S_Y - Extra_Tab->y)/XY_MULT;
break;
}
d=.5;
glPolygonMode(GL_FRONT,GL_FILL);
if (Extra_Tab->gnum) glColor3ub(255, 175, 0); //green
else glColor3ub(0, 255, 0); //orange
glBegin(GL_QUADS);
glVertex2f(xx-d,yy-d);
glVertex2f(xx+d,yy-d);
glVertex2f(xx+d,yy+d);
glVertex2f(xx-d,yy+d);
glEnd();
return 0;
}
int glDiagDrawScreen(void *objv)
{
/* int x,y;
glPolygonMode(GL_FRONT,GL_FILL);
glColor3ub(255, 255, 255); //gray big
glBegin(GL_QUADS);
glVertex2f(0,0);
glVertex2f(64,0);
glVertex2f(64,48);
glVertex2f(0,48);
glEnd();
x = 32.0;
y = 24.0;
glLineWidth( 2.0f );
glColor3ub(255, 0, 0); //red
glBegin(GL_LINES);
glVertex2f(x-1.5,y);
glVertex2f(x+1.5,y);
glEnd();
glBegin(GL_LINES);
glVertex2f(x,y-1.5);
glVertex2f(x,y+1.5);
glEnd();
*/
return 0;
}
int glDiagDrawTarget(void *objv)
{
int n = ((ObjFunc*)objv)->n;
glLineWidth( 2.0f );
glColor3ub(255, 0, 0); //red
glBegin(GL_LINES);
glVertex2f(x[n]-1.5,y[n]);
glVertex2f(x[n]+1.5,y[n]);
glEnd();
glBegin(GL_LINES);
glVertex2f(x[n],y[n]-1.5);
glVertex2f(x[n],y[n]+1.5);
glEnd();
return 0;
}
// -------------------------------------------------------------------
int glDiagDrawGrid(void * objv)
{
float x,y,xd,yd,r,c;
glPolygonMode(GL_FRONT,GL_LINE);
glLineWidth( 1.0f );
glColor3ub(255, 255, 255);
x = 0.5;
y = 0.5;
yd = 9.45;//5.85;
xd = 16.925;//7.85;
for (r = 0; r < 8; r++)
{
for (c = 0; c < 8; c++)
{
glBegin(GL_QUADS);
glVertex2f(x,y);
glVertex2f(x+xd,y);
glVertex2f(x+xd,y+yd);
glVertex2f(x,y+yd);
glEnd();
x += xd;
}
y += yd;
x = 0.5;
}
return 0;
}
// -------------------------------------------------------------------
/*
int glDiagDrawGrid(void * objv)
{
float x,y,xd,yd,r,c;
glPolygonMode(GL_FRONT,GL_LINE);
glLineWidth( 10.0f );
glColor3ub(255, 255, 255); //white square
x = 0.5;
y = 0.5;
yd = 18.9;//11.7;
xd = 33.85;//15.7;
for (r=0;r<4;r++)
{
for (c=0;c<4;c++)
{
glBegin(GL_QUADS);
glVertex2f(x,y);
glVertex2f(x+xd,y);
glVertex2f(x+xd,y+yd);
glVertex2f(x,y+yd);
glEnd();
x+=xd;
}
y+=yd;
x=.5;
}
return 0;
}
*/
int glDiagDrawColorScreen(void * objv)
{
Extra_Tab_t * Extra_Tab = (void*)&((ObjFunc*)objv)[1];
float xd = 136.6, y2 = 76.8;
int x=0,y1=0;
int n = ((ObjFunc*)objv)->n;
glPolygonMode(GL_FRONT,GL_FILL);
//tall bars on top
switch(Extra_Tab->n)
{
case 0: glColor3ub(0, 0, 0); break;
case 1: glColor3ub(255, 255, 255); break;
case 2: glColor3ub(255, 0, 0); break;
case 3: glColor3ub(0, 255, 0); break;
case 4: glColor3ub(0, 0, 255); break;
}
glBegin(GL_QUADS);
glVertex2f(x,y1);
glVertex2f(x+xd,y1);
glVertex2f(x+xd,y2);
glVertex2f(x,y2);
glEnd();
return 0;
}
int glDiagDrawColorBar(void * objv)
{
float x,y1,xd,y2;
float xs = 1366.0 / 640.0;
glPolygonMode(GL_FRONT,GL_FILL);
xd = 19.5;//9;
y1 = 27.2;//17;
y2 = 76.8;//48;
x = 0;
//tall bars on top
glColor3ub(204, 204, 204); //gray big
glBegin(GL_QUADS);
glVertex2f(x,y1);
glVertex2f(x+xd,y1);
glVertex2f(x+xd,y2);
glVertex2f(x,y2);
glEnd();
x=19.5;//9;
glColor3ub(255, 255, 0); //yellow big
glBegin(GL_QUADS);
glVertex2f(x,y1);
glVertex2f(x+xd,y1);
glVertex2f(x+xd,y2);
glVertex2f(x,y2);
glEnd();
x=39.0;//18;
glColor3ub(0, 255, 255); //cyan big
glBegin(GL_QUADS);
glVertex2f(x,y1);
glVertex2f(x+xd+1,y1);
glVertex2f(x+xd+1,y2);
glVertex2f(x,y2);
glEnd();
x=58.5;//28;
glColor3ub(0, 255, 0); //green big
glBegin(GL_QUADS);
glVertex2f(x,y1);
glVertex2f(x+xd,y1);
glVertex2f(x+xd,y2);
glVertex2f(x,y2);
glEnd();
x=78.0;//37;
glColor3ub(255, 0, 255); //magenta big
glBegin(GL_QUADS);
glVertex2f(x,y1);
glVertex2f(x+xd,y1);
glVertex2f(x+xd,y2);
glVertex2f(x,y2);
glEnd();
x=97.5;//46;
glColor3ub(255, 0, 0); //red big
glBegin(GL_QUADS);
glVertex2f(x,y1);
glVertex2f(x+xd,y1);
glVertex2f(x+xd,y2);
glVertex2f(x,y2);
glEnd();
x=117;//55;
glColor3ub(0, 0, 255); //blue big
glBegin(GL_QUADS);
glVertex2f(x,y1);
glVertex2f(x+xd,y1);
glVertex2f(x+xd,y2);
glVertex2f(x,y2);
glEnd();
//small middle bars
xd = 19.5;//9;
y1 = 20.8;//13;
y2 = 27.2;//17;
x = 0;
glColor3ub(0, 0, 255); //blue small
glBegin(GL_QUADS);
glVertex2f(x,y1);
glVertex2f(x+xd,y1);
glVertex2f(x+xd,y2);
glVertex2f(x,y2);
glEnd();
x=19.5;//9;
glColor3ub(19, 19, 19); //dk gray small
glBegin(GL_QUADS);
glVertex2f(x,y1);
glVertex2f(x+xd,y1);
glVertex2f(x+xd,y2);
glVertex2f(x,y2);
glEnd();
x=39.0;//18;
glColor3ub(255, 0, 255); //magenta small
glBegin(GL_QUADS);
glVertex2f(x,y1);
glVertex2f(x+xd+1,y1);
glVertex2f(x+xd+1,y2);
glVertex2f(x,y2);
glEnd();
x=58.5;//28;
glColor3ub(19, 19, 19); //dk gray small
glBegin(GL_QUADS);
glVertex2f(x,y1);
glVertex2f(x+xd,y1);
glVertex2f(x+xd,y2);
glVertex2f(x,y2);
glEnd();
x=78.0;//37;
glColor3ub(0, 255, 255); //cyan small
glBegin(GL_QUADS);
glVertex2f(x,y1);
glVertex2f(x+xd,y1);
glVertex2f(x+xd,y2);
glVertex2f(x,y2);
glEnd();
x=97.5;//46;
glColor3ub(19, 19, 19); //dr gray small
glBegin(GL_QUADS);
glVertex2f(x,y1);
glVertex2f(x+xd,y1);
glVertex2f(x+xd,y2);
glVertex2f(x,y2);
glEnd();
x=117.0;//55;
glColor3ub(204, 204, 204); //gray small
glBegin(GL_QUADS);
glVertex2f(x,y1);
glVertex2f(x+xd,y1);
glVertex2f(x+xd,y2);
glVertex2f(x,y2);
glEnd();
//bottom bars
xd = 22.8;//11;
y1 = 0;
y2 = 20.8;//13;
x = 0;
glColor3ub(8, 64, 89); //teal medium
glBegin(GL_QUADS);
glVertex2f(x,y1);
glVertex2f(x+xd,y1);
glVertex2f(x+xd,y2);
glVertex2f(x,y2);
glEnd();
x=22.8;//11;
glColor3ub(255, 255, 255); //white medium
glBegin(GL_QUADS);
glVertex2f(x,y1);
glVertex2f(x+xd,y1);
glVertex2f(x+xd,y2);
glVertex2f(x,y2);
glEnd();
x=45.6;//22;
glColor3ub(58, 0, 126); //purple medium
glBegin(GL_QUADS);
glVertex2f(x,y1);
glVertex2f(x+xd+1,y1);
glVertex2f(x+xd+1,y2);
glVertex2f(x,y2);
glEnd();
x=68.4;//34;
xd++;
glColor3ub(19, 19, 19); //dk gray medium
glBegin(GL_QUADS);
glVertex2f(x,y1);
glVertex2f(x+xd,y1);
glVertex2f(x+xd,y2);
glVertex2f(x,y2);
glEnd();
x=91.2;
xd=7.6;//3;
glColor3ub(0, 0, 0); //black medium
glBegin(GL_QUADS);
glVertex2f(x,y1);
glVertex2f(x+xd,y1);
glVertex2f(x+xd,y2);
glVertex2f(x,y2);
glEnd();
x=98.8;//49;
glColor3ub(19, 19, 19); //dk gray medium
glBegin(GL_QUADS);
glVertex2f(x,y1);
glVertex2f(x+xd,y1);
glVertex2f(x+xd,y2);
glVertex2f(x,y2);
glEnd();
x=106.4;//52;
glColor3ub(38, 38, 38); //lighter gray medium
glBegin(GL_QUADS);
glVertex2f(x,y1);
glVertex2f(x+xd,y1);
glVertex2f(x+xd,y2);
glVertex2f(x,y2);
glEnd();
x=114.0;//55;
xd=22.8;//9;
glColor3ub(19, 19, 19); //dk gray medium
glBegin(GL_QUADS);
glVertex2f(x,y1);
glVertex2f(x+xd,y1);
glVertex2f(x+xd,y2);
glVertex2f(x,y2);
glEnd();
return 0;
}
#endif // SYS_GL
// EOF

6683
dond/coregl/draw_gl.c Executable file
View File

File diff suppressed because it is too large Load Diff

129
dond/coregl/fb_gl.c Executable file
View File

@@ -0,0 +1,129 @@
#if SYS_GL
// fb_gl.c
// Play Mechanix - Video Game System
// Copyright (c) 2004 Play Mechanix Inc. All Rights Reserved
//
// JFL 29 Aug 04; from ah/fb.c
#include "pm.h"
#include "sys.h"
#include "mem.h"
#include "int.h"
#include "fb.h"
#include "wnd.h"
FbResInfo *FbRes; // pointer to current resolution info
FbResInfo resTab[FB_NUM_RESOLUTION] =
{
// 320x240
{
8,
512, // must be next power of 2 from width
320,
240,
1,1, // dispMulX,dispMulY
},
// 400x256
{
8,
512, // must be next power of 2 from width
400,
256,
1,1, // dispMulX,dispMulY
},
// 512x384
{
8, // bytes per pixel
512, // pixel stride -- must be next power of 2 from width
512, // pixel width
384, // pixel height
1,1, // dispMulX,dispMulY
},
// 640X480
{
8,
1024, // must be next power of 2 from width
640,
480,
1,1, // dispMulX,dispMulY
},
// 1366X768
{
8,
2048, // must be next power of 2 from width
1366,
768,
1,1, // dispMulX,dispMulY
},
// DevInVGA -- 512x384 in 640X480 -- development resolution only
{
8,
1024, // must be next power of 2 from width
512,
384,
1,1, // dispMulX,dispMulY
},
};
///////////////////////////////////////////////////////////////////////////////
//
// JFL 29 Aug 04
int FbInit(void)
{
FbRes=NUL;
return 0;
} // FbInit()
// JFL 29 Aug 04
void FbFinal(void)
{
} // FbFinal()
// JFL 29 Aug 04
int FbReset(uns reset)
{
return 0;
} // FbReset()
///////////////////////////////////////////////////////////////////////////////
//
// GNP 24 Mar 03
// JFL 12 Sep 03
// JFL 29 Aug 04
// JFL 07 Oct 04; pc version
int FbSetMode(int res)
{
int ec;
if (res >= FB_NUM_RESOLUTION)
{
// unsupported resolution
LOCKUP(BP_FBSETMODE);
err(-1);
}
FbRes = &resTab[res];
ec=0;
BAIL:
return ec;
} // FbSetMode()
///////////////////////////////////////////////////////////////////////////////
//
// JFL 06 Sep 04
void FbIntHandler(void)
{
} // FbIntHandler()
// JFL 06 Sep 04
void FbWriteDbgInfo(void)
{
} // FbWriteDbgInfo()
#endif // SYS_GL
// EOF

1761
dond/coregl/font_gl.c Executable file
View File

File diff suppressed because it is too large Load Diff

404
dond/coregl/fs_gl.c Executable file
View File

@@ -0,0 +1,404 @@
#if SYS_GL
// fs_gl.c
// Play Mechanix - Video Game System
// Copyright (c) 1998-2005 Play Mechanix Inc. All Rights Reserved
//
// note that is not really a _gl file, but since this code depends on <stdio.h>
// it really isn't generic and has to go into some non-generic core area
//
// JFL 26 Aug 04
// JFL 19 Sep 04; dir
// JFL 08 Oct 04
#include <stdio.h>
#include "pm.h"
#include "sys.h"
#include "mem.h"
#include "str.h"
#include "fs.h"
#define M_FR_VALID 0x0001
#define M_FR_DIRFIRST 0x0002
#define M_FR_DIRNEXT 0x0004
#define M_FR_DIRSAME 0x0008
#define M_FR_DIREMPTY 0x0010
#define M_FR_WRITABLE 0x0020
#define M_FR_LASTSEC 0x0040
#define M_FR_DIRTY 0x0080 // dir needs update
#define M_FR_ERR 0x0100 // dir needs update
typedef struct {
// this must fit into FsH declared in fs.h
uns16 flags;
FILE *fh;
} FileRec;
#define M_FF_VALID 0x01
typedef struct {
// this must fit into FfH declared in fs.h
uns8 flags;
FILE *fh;
} FastFile;
///////////////////////////////////////////////////////////////////////////////
//
// JFL 26 Aug 04
// JFL 08 Oct 04
int FsInit(void)
{
int ec=0;
#if SAFE
if(sizeof(FsH)<sizeof(FileRec))
{
LOCKUP(BP_FSINIT1);
return -1;
}
if(sizeof(FfH)<sizeof(FastFile))
{
LOCKUP(BP_FSINIT2);
return -1;
}
#endif // SAFE
return ec;
} // FsInit
// JFL 26 Aug 04
// JFL 08 Oct 04
int FsReset(uns reset)
{
return 0;
} // FsReset
// JFL 26 Aug 04
// JFL 08 Oct 04
void FsFinal(void)
{
} // FsFinal
///////////////////////////////////////////////////////////////////////////////
// FS
// JFL 29 Sep 04
uns FsInfo(int info)
{
switch(info)
{
case FSINFO_SECTOR_SIZE:
return 512;
case FSINFO_CLUSTER_SIZE:
return 512*8;
} // switch
return 0;
} // FsInfo()
// JFL 27 Aug 04
// JFL 21 Sep 04
int FsOpen(FsH *fh,char *path,uns flags)
{
int ec;
char *mode;
//
// PATH
//
((FileRec*)fh)->flags=0;
if(!(flags&M_FSOPEN_WRITABLE))
{
// take away flags for things you can't do if not writable
flags&=~(M_FSOPEN_CREATEIFNOTFOUND
|M_FSOPEN_DELETEDATA
|M_FSOPEN_APPEND
|M_FSOPEN_ATOMIC);
}
//
// FIND OR CREATE FILE IN DIRECTORY
//
mode="rb";
if(flags&M_FSOPEN_WRITABLE)
{
if(flags&M_FSOPEN_APPEND)
mode="a+b"; // open for read/write, writing at end
else if(flags&M_FSOPEN_DELETEDATA)
mode="w+b"; // create for read/write, discard
}
if(!(((FileRec*)fh)->fh=fopen(path,mode)))
err(ERR_FILE_OPEN);
//
//
//
if(flags&M_FSOPEN_WRITABLE)
((FileRec*)fh)->flags|=M_FR_WRITABLE;
((FileRec*)fh)->flags|=M_FR_VALID;
ec=0;
BAIL:
return ec;
} // FsOpen()
// JFL 15 Feb 05
int FsFindOpen(FsH *fh,char *pathlist,char *name,uns flags,
char *openpath,int openpathsize)
{
int ec;
char buf[PM_FILEPATH_MAX];
char *s2;
if(!pathlist || !name || !fh)
err(ERR_FILE_NOTVALID);
for(;pathlist && pathlist[0];)
{
if(!(s2=szskipto(pathlist,";,")))
{
szncpy(buf,pathlist,sizeof(buf));
pathlist=NUL;
}
else
{
sz2ncpy(buf,pathlist,s2,sizeof(buf));
pathlist=1+s2;
}
if(1
&& ((ec=szlen(buf))>0)
&& (ec<sizeof(buf))
&& (buf[ec-1]!='/')
&& (buf[ec-1]!='\\'))
{
buf[ec++]='/'; // assume this slash works..
buf[ec]=0;
}
szncat2(buf,name,NUL,sizeof(buf));
if((ec=FsOpen(fh,buf,flags))>=0)
{
if(openpath)
szncpy(openpath,buf,openpathsize);
goto BAIL;
}
} // for
ec=ERR_FILE_OPEN;
BAIL:
return ec;
} // FsFindOpen()
// JFL 28 Sep 04
int FsFlush(FsH *fh)
{
int ec;
if(!(((FileRec*)fh)->flags&M_FR_VALID))
err(ERR_FILE_NOTVALID);
if(!(((FileRec*)fh)->flags&M_FR_WRITABLE))
goto done;
fflush(((FileRec*)fh)->fh);
done:
ec=0;
BAIL:
return ec;
} // FsFlush()
// JFL 27 Aug 04
// JFL 28 Sep 04
int FsClose(FsH *fh)
{
int ec;
if(!(((FileRec*)fh)->flags&M_FR_VALID))
err(ERR_FILE_NOTVALID);
if((((FileRec*)fh)->flags&M_FR_WRITABLE))
FsFlush(fh);
((FileRec*)fh)->flags&=~M_FR_VALID;
fclose(((FileRec*)fh)->fh);
ec=0;
BAIL:
return ec;
} // FsClose()
// JFL 21 Sep 04
int FsDelete(char *path)
{
int ec;
if(remove(path))
err(ERR_FILE_DELETE);
ec=0;
BAIL:
return ec;
} // FsDelete()
// JFL 27 Jul 05
int FsRename(char *oldpath,char *newpath)
{
int ec;
if(rename(oldpath,newpath))
err(ERR_FILE_RENAME);
ec=0;
BAIL:
return ec;
} // FsRename()
// JFL 28 Aug 04
int FsRead(FsH *fh,void *buf,uns32 size)
{
int ec;
uns32 n,s;
if(!(((FileRec*)fh)->flags&M_FR_VALID))
err(ERR_FILE_NOTVALID);
s = sizeof(buf);
n=fread(buf,1,size,((FileRec*)fh)->fh);
if(n !=size)
err(ERR_FILE_READ);
ec=0;
BAIL:
return ec;
} // FsRead()
// JFL 20 Sep 04
int FsWrite(FsH *fh,void *buf,uns32 size)
{
int ec;
if(!(((FileRec*)fh)->flags&M_FR_VALID))
err(ERR_FILE_NOTVALID);
if(!(((FileRec*)fh)->flags&M_FR_WRITABLE))
err(ERR_FILE_NOTWRITABLE);
if(fwrite(buf,1,size,((FileRec*)fh)->fh)!=size)
err(ERR_FILE_WRITE);
ec=0;
BAIL:
return ec;
} // FsWrite()
// JFL 21 Sep 04
uns FsSize(FsH *fh)
{
long mark,size;
if(!(((FileRec*)fh)->flags&M_FR_VALID))
return 0;
mark=ftell(((FileRec*)fh)->fh);
if(fseek(((FileRec*)fh)->fh,0,SEEK_END))
return 0;
size=ftell(((FileRec*)fh)->fh);
if(fseek(((FileRec*)fh)->fh,mark,SEEK_SET))
return 0;
return size;
} // FsSize()
// JFL 21 Sep 04
int FsDiskSize(FsH *fh,int set,uns *sizep)
{
int ec;
if(!(((FileRec*)fh)->flags&M_FR_VALID))
err(ERR_FILE_NOTVALID);
if(!set)
{
*sizep=FsSize(fh);
err(0);
}
ec=0;
BAIL:
return ec;
} // FsDiskSize()
// JFL 03 Sep 04
int FsSeek(FsH *fh,uns32 off)
{
if(!(((FileRec*)fh)->flags&M_FR_VALID))
return ERR_FILE_NOTVALID;
if(fseek(((FileRec*)fh)->fh,off,SEEK_SET))
return ERR_FILE_SEEK;
return 0;
} // FsSeek()
// JFL 01 Sep 04
int FfPrep(FfH *ff,FsH *fh)
{
if(!(((FileRec*)fh)->flags&M_FR_VALID))
return ERR_FILE_NOTVALID;
((FastFile*)ff)->flags&=~M_FF_VALID;
((FastFile*)ff)->fh = ((FileRec*)ff)->fh;
((FastFile*)ff)->flags|=M_FF_VALID;
return 0;
} // FfPrep()
// JFL 07 Sep 04
int FfSeek(FfH *ff,uns32 off)
{
return FsSeek((void*)ff,off);
} // FfSeek()
// JFL 01 Sep 04
int FfRead(FfH *ff,void *buf,uns32 size)
{
return FsRead((void*)ff,buf,size);
} // FfRead()
// JFL 02 Sep 04
// JFL 28 Sep 04
int FfWrite(FfH *ff,void *abuf,uns32 size)
{
return FsWrite((void*)ff,abuf,size);
} // FfWrite()
// JFL 02 Sep 04
int FsDefrag(FsH *fh,int set)
{
return 0;
} // FsDefrag()
// JFL 18 Sep 04
int FsDir(FsH *fh,uns dirmask,char *buf,uns bufsize)
{
return ERR_FILE_INTERNAL;
} // FsDir()
// JFL 17 Sep 04
int FsCurDir(int num,int set,char *buf,uns bufsize)
{
return ERR_FILE_INTERNAL;
} // FsCurDir()
#endif // SYS_GL
//EOF

136
dond/coregl/net_gl.c Executable file
View File

@@ -0,0 +1,136 @@
#if SYS_GL
// net_gl.c
// Play Mechanix - Video Game System
// Copyright (c) 1998-2004 Play Mechanix Inc. All Rights Reserved
//
// JFL 08 Sep 04
// JFL 27 Sep 04
#include "pm.h"
#include "sys.h"
#include "mem.h"
#include "fs.h"
#include "str.h"
#include "net.h"
typedef struct {
int dummy;
} netPort;
///////////////////////////////////////////////////////////////////////////////
// SYSTEM INIT
// JFL 08 Sep 04
int NetInit(void)
{
int ec;
NetPH *ph=NUL;
if(sizeof(ph->sys)<sizeof(netPort) || (&ph->sys[0]>0))
err(ERR_NET_INTERNAL);
ec=0;
BAIL:
return ec;
} // NetInit()
// JFL 08 Sep 04
void NetFinal(void)
{
} // NetFinal()
// JFL 22 Sep 04
int NetReset(uns reset)
{
int i;
void *mem;
// reset the pool
MemPoolReset(MEMPOOL_NET,reset); // puts all mem in stack mode
i = MemSAvail(MEMPOOL_NET); // find total size
if(MemSLow(MEMPOOL_NET,i,&mem)<0) // alloc it all from the stack
{
LOCKUP(BP_NETRESET1);
}
else
{
if(MemDSetup(MEMPOOL_NET,mem,i)<0) // put it all into dynamic mode
LOCKUP(BP_NETRESET2);
}
return 0;
} // NetReset()
///////////////////////////////////////////////////////////////////////////////
// FOREGROUND
// JFL 04 Oct 04
int NetPortInfo(NetPH *ph,uns info)
{
switch(info)
{
case NETPORTINFO_OFF_THEIRMAC:
return 0;
case NETPORTINFO_OFF_THEIRIP:
return 0;
} // switch
LOCKUP(BP_NETPORTINFO);
return 0;
} // NetPortInfo()
// JFL 01 Oct 04
int NetPortAddListener(NetPH *ph,uns port,uns flags)
{
return ERR_NET_INTERNAL;
} // NetPortAddListener()
// JFL 04 Oct 04
int NetPortAddSender(NetPH *ph,uns port,uns flags,uns8 *dstmac,uns8 *dstip,uns16 dstport)
{
return ERR_NET_INTERNAL;
} // NetPortAddSender()
// JFL 01 Oct 04
int NetPortRem(NetPH *ph)
{
return ERR_NET_INTERNAL;
} // NetPortRem()
// JFL 01 Oct 04
int NetPortAddRvBuf(NetPH *ph,NetBuf *nb)
{
return ERR_NET_INTERNAL;
} // NetPortAddRvBuf()
// JFL 01 Oct 04
int NetPortAddSdBuf(NetPH *ph,NetBuf *nb,uns flags)
{
return ERR_NET_INTERNAL;
} // NetPortAddSdBuf()
// JFL 01 Oct 04
int NetPortRemBuf(NetPH *ph,NetBuf *nb)
{
return ERR_NET_INTERNAL;
} // NetPortRemBuf()
// JFL 01 Oct 04
// JFL 04 Oct 04
int NetPortPop(NetPH **php,sto *argbuf)
{
return ERR_NET_INTERNAL;
} // NetPortPop()
// JFL 01 Oct 04
int NetBufSignalFIN(NetBuf *nb)
{
return ERR_NET_INTERNAL;
} // NetBufSignalFIN()
// JFL 01 Oct 04
int NetLoop(void)
{
return 0;
} // NetLoop()
#endif // SYS_GL
// EOF

3087
dond/coregl/obj_gl.c Executable file
View File

File diff suppressed because it is too large Load Diff

1635
dond/coregl/res_gl.c Executable file
View File

File diff suppressed because it is too large Load Diff

399
dond/coregl/vid_gl.c Executable file
View File

@@ -0,0 +1,399 @@
#if SYS_GL
// vid_gl.c
//
// video graphics interface - pc
// Play Mechanix Platform Independent Video System
// Copyright 1998-2004 Play Mechanix Inc. All Rights Reserved
//
// JFL 07 Oct 04; from ah
///#include <GL/freeglut.h>
#include "pm.h"
#include "sys.h"
#ifdef SYS_BB
#include <GL/glut.h>
#include <GL/glext.h>
#else
#include <GL/freeglut.h>
#include <GL/glext.h>
#endif
#include "mem.h"
#include "fb.h"
#include "str.h"
#include "vid.h"
VidDispInfo VidDisp; // display info computed
//#define GL_ARRAY_BUFFER_ARB 0x8892
//#define GL_STATIC_DRAW_ARB 0x88E4
//typedef void (APIENTRY * PFNGLBINDBUFFERARBPROC) (GLenum target, GLuint buffer);
//typedef void (APIENTRY * PFNGLDELETEBUFFERSARBPROC) (GLsizei n, const GLuint *buffers);
//typedef void (APIENTRY * PFNGLGENBUFFERSARBPROC) (GLsizei n, GLuint *buffers);
//typedef void (APIENTRY * PFNGLBUFFERDATAARBPROC) (GLenum target, int size, const GLvoid *data, GLenum usage);
#ifndef SYS_BB
// VBO Extension Function Pointers
PFNGLGENBUFFERSARBPROC glGenBuffersARB = NULL; // VBO Name Generation Procedure
PFNGLBINDBUFFERARBPROC glBindBufferARB = NULL; // VBO Bind Procedure
PFNGLBUFFERDATAARBPROC glBufferDataARB = NULL; // VBO Data Loading Procedure
PFNGLDELETEBUFFERSARBPROC glDeleteBuffersARB = NULL; // VBO Deletion Procedure
#endif //!SYS_BB
// frame
typedef struct _vp {
struct _vp *next;
uns32 flags;
} Vid;
void* vidSysMem0=NUL;
///////////////////////////////////////////////////////////////////////////////
// VID
// JFL 03 Sep 04
int VidInit(void)
{
vidSysMem0=NUL;
MEMZ(VidDisp);
VidDisp.fogMode=GL_LINEAR;
VidDisp.fogNear=90.0;
VidDisp.fogFar=1000.0;
VidDisp.fogDensity=0.20f;
VidDisp.fogRGBA[0]=0.0f;
VidDisp.fogRGBA[1]=0.8f;
VidDisp.fogRGBA[2]=0.0f;
VidDisp.fogRGBA[3]=0.0f;
VidDisp.gridSize=10;
VidDisp.gridDim=10;
VidDisp.maxLights=VID_MAXLIGHTS;
if(sizeof(GLfloat)!=sizeof(float))
{
// assumptions are made in the data & program
LOCKUP(BP_VIDINIT);
return -2;
}
return 0;
} // VidInit()
// JFL 03 Sep 04
void VidFinal(void)
{
} // VidFinal()
// JFL 22 Sep 04
int VidReset(uns reset)
{
VidDisp.flags&=~(M_VIDDISP_FOG|M_VIDDISP_GSHADOW|M_VIDDISP_SYNC_VBLANK);
// always reset global shadow parameters
VidDisp.shadowRGBA[0]=0;
VidDisp.shadowRGBA[1]=0;
VidDisp.shadowRGBA[2]=0;
VidDisp.shadowRGBA[3]=100;
VidDisp.shadowDist=30; // should be a certain height above ground
// #if PRODUCTION
#if 0
if(reset) // do this on wipeout
{
int i=SysGetHardwareInfo(SYSGETHARDWAREINFO_SN,NUL,0);
if(!SYS_HARDSN(i))
VidDisp.flags|=M_VIDDISP_PROFAIL;
}
#endif // PRODUCTION
return 0;
} // VidReset()
//
// IsExtensionSupported
// Check to see if OpenGL extension is supported
// from:
// http://nehe.gamedev.net/data/lessons/lesson.asp?lesson=45
//
// in:
// szTargetExtension = ptr to character string name of extension
// out:
// <>0 = supported
// global:
//
// GNP 25 Nov 05
//
uns8 IsExtensionSupported( char* szTargetExtension )
{
const unsigned char *pszExtensions = NULL;
const unsigned char *pszStart;
unsigned char *pszWhere, *pszTerminator;
// Extension names should not have spaces
pszWhere = (unsigned char *) strchr( szTargetExtension, ' ' );
if( pszWhere || *szTargetExtension == '\0' )
return(0);
// Get Extensions String
pszExtensions = glGetString( GL_EXTENSIONS );
// Search The Extensions String For An Exact Copy
pszStart = pszExtensions;
for(;;)
{
pszWhere = (unsigned char *) strstr( (const char *) pszStart, szTargetExtension );
if( !pszWhere )
break;
pszTerminator = pszWhere + strlen( szTargetExtension );
if( pszWhere == pszStart || *( pszWhere - 1 ) == ' ' )
if( *pszTerminator == ' ' || *pszTerminator == '\0' )
return(1);
pszStart = pszTerminator;
}
return(0);
//DONE("IsExtensionSupported")
} // IsExtensionSupported
// JFL 03 Sep 04
// JFL 07 Oct 04
int VidStart(void)
{
int ec;
char *s1,*s2;
GLint i1;
float v[4];
char tS[256];
if(!FbRes)
err(-1);
VidDisp.screenW = FbRes->screenW;
VidDisp.screenH = FbRes->screenH;
VidDisp.centerX = FbRes->screenW>>1;
VidDisp.centerY = FbRes->screenH>>1;
//
// OpenGL settings
//
VidDisp.apiVendor = (void*)glGetString(GL_VENDOR);
VidDisp.apiVersion = (void*)glGetString(GL_VERSION);
VidDisp.apiRenderer = (void*)glGetString(GL_RENDERER);
VidDisp.apiExtensions = (void*)glGetString(GL_EXTENSIONS);
#if DEBUG
SysLog("GL Vendor:\n%s\n",VidDisp.apiVendor);
SysLog("GL Version:\n%s\n",VidDisp.apiVersion);
SysLog("GL Renderer:\n%s\n",VidDisp.apiRenderer);
// prints a list of OpenGL extensions
#if 0
SysLog("GL Extensions:\n");
s1=VidDisp.apiExtensions;
while ((s2 = strchr(s1,0x20)) != NULL)
{
int pos;
pos = s2-s1;
strncpy(tS,s1,pos+1);
tS[pos+1]=0;
SysLog("%s\n",tS);
s1=s2+1;
}
#endif
#endif //DEBUG
s1=VidDisp.apiExtensions;
VidDisp.bSupportVBO = IsExtensionSupported( "GL_ARB_vertex_buffer_object" );
if( VidDisp.bSupportVBO )
{
// Get Pointers To The GL Functions
#ifndef SYS_BB
glGenBuffersARB = (PFNGLGENBUFFERSARBPROC) wglGetProcAddress("glGenBuffersARB");
glBindBufferARB = (PFNGLBINDBUFFERARBPROC) wglGetProcAddress("glBindBufferARB");
glBufferDataARB = (PFNGLBUFFERDATAARBPROC) wglGetProcAddress("glBufferDataARB");
glDeleteBuffersARB = (PFNGLDELETEBUFFERSARBPROC) wglGetProcAddress("glDeleteBuffersARB");
#endif //!SYS_BB
}
else
{
SysLog("VidStart: GL_ARB_vertex_buffer_object not supported\n");
}
#ifdef SYS_BB
{
int vs,ve;
uns64 sanityTime;
char *e;
sanityTime = SysMilliSec() + 4*16;
if (!glXGetVideoSyncSGI(&vs))
{
while (sanityTime > SysMilliSec())
{
glXGetVideoSyncSGI(&ve);
if (ve != vs)
{
VidDisp.VSyncTimerStart = SysMicroSec();
VidDisp.bSoftwareVSync = 1;
break;
}
}
}
if (!VidDisp.bSoftwareVSync)
SysLog("VidStart: glXGetVideoSyncSGI() not working\n");
// check if we are letting the hardware handle vsync
e=(char*)getenv("__GL_SYNC_TO_VBLANK");
if((e!=NULL) & (e[0] != '0'))
{
VidDisp.bHardwareVSync=1;
}
#if DEBUG
if(e==NULL)
SysLog("VidStart: __GL_SYNC_TO_VBLANK not found\n");
else
SysLog("VidStart: __GL_SYNC_TO_VBLANK = %s\n",e);
#endif //DEBUG
}
#endif //SYS_BB
// check for expected extensions
//if(!szmid("GL_ARB_imaging",s1))
// SysLog("GL: imaging extension not available (some blends won't work)\n");
// I don't think this works right...
glGetTexParameterfv(GL_TEXTURE_2D,GL_TEXTURE_MIN_LOD,&VidDisp.mipMin);
glGetTexParameterfv(GL_TEXTURE_2D,GL_TEXTURE_MAX_LOD,&VidDisp.mipMax);
glHint(GL_PERSPECTIVE_CORRECTION_HINT,GL_FASTEST);//GL_FASTEST);//GL_NICEST);
// glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);
// 1=bilinear 2=anisotropic
glGetIntegerv(GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT, &i1);
#if DEBUG
SysLog("GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT = %d\n",i1);
#endif //DEBUG
if(i1>2)
i1=2; // 2 b/c that is the max the NForce2 can do
glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAX_ANISOTROPY_EXT, i1 );
// glEnable(GL_POLYGON_SMOOTH);
//Using GL Hints it's not recommended. Performance of Your program will
//get much lower. If You want to make antialiasing of polygons try enabling
//GL_POLYGON_SMOOTH, but remember that You also have to enable GL_BLEND
//with glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA).
//Else method of antialiasing is multisample, but You can be sure that
//it will eat many of FPS
// http://developer.nvidia.com/object/gdc_ogl_multisample.html
// Will's research:
// http://www.opengl.org/resources/tutorials/sig99/advanced99/course_slides/vissim/sld031.htm
// http://www.nvnews.net/previews/geforce_6600_gt/page_3.shtml
// http://oss.sgi.com/projects/ogl-sample/registry/EXT/texture_filter_anisotropic.txt
// http://www.opengl.org/resources/tutorials/advanced/advanced98/notes/node37.html
// http://www.sulaco.co.za/tut4.htm
// http://www.opengl.org/resources/tutorials/sig99/advanced99/notes/node56.html
// http://www.flipcode.com/articles/article_advgltextures.shtml
// set defaults
// routines must save & restore these settings if changed
glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER,GL_FALSE);
glLightModeli(GL_LIGHT_MODEL_TWO_SIDE,GL_FALSE);
glFrontFace(GL_CCW); // front faces counter clock wise
glDisable(GL_SCISSOR_TEST);
glDisable(GL_STENCIL_TEST);
glDisable(GL_COLOR_LOGIC_OP);
glDisable(GL_INDEX_LOGIC_OP);
glClearDepth(1.0f);
glClearStencil(0);
// default global ambient light
v[0]=v[1]=v[2]=0;v[3]=1;
glLightModelfv(GL_LIGHT_MODEL_AMBIENT,v);
glGetIntegerv(GL_MAX_TEXTURE_SIZE,&i1);
VidDisp.maxTexWidthHeight=i1;
//glewInit();
#if SAFE
if(VidDisp.maxTexWidthHeight<1024)
BP(BP_VIDSTART); // game needs at least 1024x1024 texture size
#endif // SAFE
ec=0;
BAIL:
return ec;
} // VidStart()
//
// frame
//
// JFL 19 Nov 03
void* VidFrameStart()
{
Vid *vp=NUL;
if(!vidSysMem0)
return NUL;
return vp;
} // VidFrameStart()
// JFL 19 Nov 03
void VidFrameEnd(void *vid)
{
} // VidFrameEnd()
// JFL 04 Dec 03
void VidDrawSetRenderDest(void *vid,uns32 flags)
{
} // VidDrawSetRenderDest()
GLint vglViewport[4]; // 0,0,width,height
GLdouble vglProjection[16];
GLdouble vglModelView[16];
// JFL 24 Mar 05
void VidGrabViewingMatrices(void)
{
glGetIntegerv(GL_VIEWPORT,vglViewport);
glGetDoublev(GL_PROJECTION_MATRIX,vglProjection);
glGetDoublev(GL_MODELVIEW_MATRIX,vglModelView);
} // VidGrabViewingMatrices()
// JFL 24 Mar 05
int VidWorldPos(crd *scr,crd *pos)
{
GLdouble x,y,z;
gluUnProject(scr[0],vglViewport[3]-scr[1]-1,scr[2],
vglModelView,vglProjection,vglViewport,
&x,&y,&z);
pos[0]=x;
pos[1]=y;
pos[2]=z;
return 0;
} // VidWorldPos()
// JFL 29 Mar 05
int VidScreenPos(crd *world,crd *pos)
{
GLdouble x,y,z;
gluProject(world[0],world[1],world[2],
vglModelView,vglProjection,vglViewport,
&x,&y,&z);
pos[0]=x;
pos[1]=vglViewport[3]-y-1;
pos[2]=z;
return 0;
} // VidScreenPos()
#endif // SYS_GL
// EOF

175
dond/corepc/int_pc.c Executable file
View File

@@ -0,0 +1,175 @@
#if SYS_PC
// int_pc.c
// Play Mechanix - Video Game System
// Copyright (c) 1998-2004 Play Mechanix Inc. All Rights Reserved
//
// GNP 01 Sep 00
// JFL 26 Aug 04
// JFL 07 Oct 04
#include "pm.h"
#include "sys.h"
#include "mem.h"
#include "int.h"
enum {
INT_DEVICE_SW0,
INT_DEVICE_SW1,
INT_DEVICE_IP2,
INT_DEVICE_IP3,
INT_DEVICE_IP4,
INT_DEVICE_IP5,
INT_DEVICE_IP6,
INT_DEVICE_TIMER,
INT_DEVICE_RTC,
INT_DEVICE_IDE1, // first FPGA
INT_DEVICE_IDE2,
INT_DEVICE_SERIAL0,
INT_DEVICE_ETHERNET,
INT_DEVICE_RENDER,
INT_DEVICE_SOUNDDMA,
INT_DEVICE_DISPLAY,
INT_DEVICE_SERIAL1,
INT_DEVICE_GUN0,
INT_DEVICE_GUN1,
INT_DEVICE_COUNT
};
typedef struct {
int enabled;
} IntDeviceRec;
IntDeviceRec intDevices[INT_DEVICE_COUNT];
//
// IntInit
// one time initialization at power-up
//
// in:
// out:
// global:
//
// GNP 01 Sep 00
// JFL 07 Oct 04
//
int IntInit(void)
{
//
// RESET VARS
//
MEMZ(intDevices);
return 0;
} // IntInit
//
// IntReset
// called every time system is reset
//
// in:
// out:
// global:
//
// GNP 01 Sep 00
// JFL 07 Oct 04
//
int IntReset(uns reset)
{
return 0;
} // IntReset
//
// IntFinal
// called once upon system shutdown
//
// in:
// out:
// global:
//
// GNP 01 Sep 00
//
void IntFinal(void)
{
} // IntFinal
// JFL 31 Aug 04
int intDeviceEnable(int dev,int enable)
{
int ec;
if(dev>=INT_DEVICE_COUNT)
{
BP(BP_INTDEVICEENABLE);
return -1;
}
intDevices[dev].enabled=enable;
switch(dev)
{
case INT_DEVICE_SW0:
case INT_DEVICE_SW1:
case INT_DEVICE_IP2:
case INT_DEVICE_IP3:
case INT_DEVICE_IP4:
case INT_DEVICE_IP5:
case INT_DEVICE_IP6:
case INT_DEVICE_TIMER:
case INT_DEVICE_IDE1:
case INT_DEVICE_IDE2:
case INT_DEVICE_SERIAL0:
case INT_DEVICE_SERIAL1:
case INT_DEVICE_RTC:
case INT_DEVICE_ETHERNET:
case INT_DEVICE_SOUNDDMA:
case INT_DEVICE_RENDER:
case INT_DEVICE_DISPLAY:
case INT_DEVICE_GUN0:
case INT_DEVICE_GUN1:
BP(BP_INTDEVICEENABLE2);
err(-2);
} // switch
ec=0;
BAIL:
if(ec<0)
BP(BP_INTDEVICEENABLE3);
return ec;
} // intDeviceEnable()
///////////////////////////////////////////////////////////////////////////////
//
// JFL 31 Aug 04
int IntAttach(void)
{
//
// INSTALL LOW LEVEL EXCEPTION HANDLERS
//
return 0;
} // IntAttach()
// JFL 31 Aug 04
void IntDetach(void)
{
BP(BP_INTDETACH); // unlink our node..??
} // IntDetach()
//
// IntEnable
//
// in:
// out:
// global:
//
// GNP 24 Mar 03
// JFL 31 Aug 04
void IntEnable(uns intMask,int enable)
{
} // IntEnable()
#endif // SYS_PC
//EOF

446
dond/corepc/main_pc.c Executable file
View File

@@ -0,0 +1,446 @@
#if SYS_PC
// main_pc.c
// Play Mechanix - Video Game System
// Copyright 1998-2004 Play Mechanix Inc. All Rights Reserved
//
// JFL 26 Aug 04
// JFL 07 Oct 04
#include <windows.h>
#include "pm.h"
#include "sys.h"
#include "int.h"
#include "mem.h"
#include "fb.h"
#include "fs.h"
#include "vid.h"
#include "net.h"
#include "res.h"
#include "obj.h"
#include "font.h"
#include "inp.h"
#include "cab.h"
#include "gun.h"
#include "game.h"
#include "str.h"
#include "proc.h"
#include "wnd.h"
#include "snd.h"
#include "ftp.h"
#include "draw.h"
#include <time.h>
#include <stdarg.h>
#include <stdio.h> // vsprintf
#include <setjmp.h>
// strings for time and date stamp of build
#define BUILD_TIME __TIME__
#define BUILD_DATE __DATE__
#define SCRIPT_START "set(str1 atstart) run(perm)"
//#define PATH_START ".;data;/g3/donddata/hd_pc;/g3/donddata/cf"
#define PATH_START "/g3/donddata/hd_pc;/g3/donddata/cf;/g3/donddata/snd"
#define AUDIT_PATH "/g3/donduser/aud"
#define ADJUST_PATH "/g3/donduser/adj"
#define CF_PATH "/g3/donddata/cf"
#define PLR_PATH "/g3/donduser/players"
#define TRN_PATH "/g3/donduser/tourneys"
#define LBD_PATH "/g3/donduser/lboards"
#define SND_PATH "/g3/donddata/snd"
#define LOG_PATH "/g3/donduser/log/"
void* jps_memdebug_ptr[2048];
uns jps_memdebug_size[2048];
int MainRestartArgc=0;
char *MainRestartArgv[MAIN_RESTART_ARGC_MAX];
jmp_buf MainJmpBuf;
// JFL 26 Aug 04
// JFL 07 Oct 04
//int APIENTRY WinMain(HINSTANCE hInstance,HINSTANCE hPrevInstance,
// LPSTR lpCmdLine,int nCmdShow)
int main(int argc0,char *argv0[])
{
int ec;
char *s1,*s2;
memu hInstance;
uns wndopenflags;
int argc;
char **argv;
SysDate dt;
int swidth, sheight, sresType;
argc=argc0;
argv=argv0;
restart:
hInstance=0;
wndopenflags=1; // default to full screen
//
// GUARANTEED INITS
//
SysWatchdogDisable();
//
// INIT ALL SYSTEMS
//
for(ec=0;ec<COUNT(jps_memdebug_ptr);ec++)
jps_memdebug_ptr[ec]=NULL;
ec=0;
if(SysInit()<0) ec=1;
if(IntInit()<0) ec=1;
if(MemInit()<0) ec=1;
if(ProcInit()<0) ec=1;
if(FbInit()<0) ec=1;
if(WndInit()<0) ec=1;
if(InpInit()<0) ec=1;
if(CabInit()<0) ec=1;
if(GunInit()<0) ec=1;
if(VidInit()<0) ec=1;
if(DrawInit()<0) ec=1;
if(FsInit()<0) ec=1;
if(NetInit()<0) ec=1;
if(FTPInit()<0) ec=1;
if(SndInit()<0) ec=1;
if(ResInit()<0) ec=1;
if(ObjInit()<0) ec=1;
if(FontInit()<0) ec=1;
if(GameInit()<0) ec=1;
if(ec)
goto BAIL;
argc--;argv++;
while(argc)
{
if((*argv)[0]=='-')
{
switch((*argv)[1])
{
case 'c':
// cursor
VidDisp.showCursor=1; // turn cursor on
break;
case 'n':
if(!szcmp("nobp",&(*argv)[1]))
SysPMBreakpointBehavior=1;
break;
case 's':
s1=s2=&(*argv)[2];
s2+=szlen(s1);
SysG.scriptStartS1=s1;
SysG.scriptStartS2=s2;
break;
case 'w':
if((*argv)[2]=='s')
{
wndopenflags=0;
break;
}
case 'f':
if((*argv)[2]=='s')
{
wndopenflags=1;
break;
}
if(!C_IS_DIGIT((*argv)[2]))
SysG.forceFrameTime=RES_FRAME_TIME;
else
{
szto(&(*argv)[2],NUL,'i',0,&ec);
SysG.forceFrameTime=ec;
}
break;
case 'v':
szto(&(*argv)[2],NUL,'i',0,&ec);
SndVolMinMax(NUL,&ec,1); // set max volume
break;
} // switch
}
argc--;argv++;
} // while
if(!SysG.scriptStartS1)
{
SysG.scriptStartS1=SysG.scriptStartS2=SCRIPT_START;
SysG.scriptStartS2+=sizeof(SCRIPT_START)-1;
}
if(!SysG.path[0])
szncpy(SysG.path,PATH_START,sizeof(SysG.path));
if(!SysG.adjpath[0])
szncpy(SysG.adjpath,ADJUST_PATH,sizeof(SysG.adjpath));
if(!SysG.audpath[0])
szncpy(SysG.audpath,AUDIT_PATH,sizeof(SysG.audpath));
if(!SysG.cfpath[0])
szncpy(SysG.cfpath,CF_PATH,sizeof(SysG.cfpath));
if(!SysG.plrpath[0])
szncpy(SysG.plrpath,PLR_PATH,sizeof(SysG.plrpath));
if(!SysG.trnpath[0])
szncpy(SysG.trnpath,TRN_PATH,sizeof(SysG.trnpath));
if(!SysG.lbdpath[0])
szncpy(SysG.lbdpath,LBD_PATH,sizeof(SysG.lbdpath));
if(!SysG.sndpath[0])
szncpy(SysG.sndpath,SND_PATH,sizeof(SysG.sndpath));
if(!SysG.logpath[0])
szncpy(SysG.logpath,LOG_PATH,sizeof(SysG.logpath));
//
// RESET ALL SYSTEMS TO THEIR NORMAL STATE
//
if(MemReset(0)<0) ec=1;
if(SysReset(0)<0) ec=1;
if(IntReset(0)<0) ec=1;
if(FsReset(0)<0) ec=1;
if(FbReset(0)<0) ec=1;
if(ProcReset(0)<0) ec=1;
if(WndReset(0)<0) ec=1;
if(FontReset(0)<0) ec=1;
if(ResReset(0)<0) ec=1;
if(ObjReset(0)<0) ec=1;
if(InpReset(0)<0) ec=1;
if(VidReset(0)<0) ec=1;
if(DrawReset(0)<0) ec=1;
if(NetReset(0)<0) ec=1;
if(FTPReset(0)<0) ec=1;
SysLoadVersionInfo(); // load the software version information
SysLogCheck();
SysLog("------------------------------\n");
SysLog("Welcome to Big Buck Hunter Pro\n");
SysLog("------------------------------\n");
#if PRODUCTION
szbuild(SysG.log,sizeof(SysG.log),"Version: %02d.%02d.%02d RELEASE",MAJOR_VERSION, MINOR_VERSION, SUB_MINOR_VERSION);
#else
szbuild(SysG.log,sizeof(SysG.log),"Version: %02d.%02d.%02d DEBUG",MAJOR_VERSION, MINOR_VERSION, SUB_MINOR_VERSION);
#endif
SysLog("%s\n",SysG.log);
szbuild(SysG.log,sizeof(SysG.log),"Build: %s %s",__DATE__,__TIME__);
SysLog("%s\n",SysG.log);
SysDateTime(&dt,0);
SysDateTimeStr(&dt,SysG.log,sizeof(SysG.log),"%B %d %Y %H:%M:%S");
SysLog("Current time: %s\n",SysG.log);
//
// CREATE VIDEO WINDOW/SCREEN
//
// setup and open a window or the screen
// this block is system dependent
sresType = FB_RESOLUTION_1366x768;
switch (sresType)
{
case FB_RESOLUTION_1366x768:
swidth = 1366;
sheight = 768;
break;
default:
case FB_RESOLUTION_640x480:
swidth = 640;
sheight = 480;
break;
case FB_RESOLUTION_512x384:
swidth = 512;
sheight = 384;
break;
case FB_RESOLUTION_400x256:
swidth = 400;
sheight = 256;
break;
case FB_RESOLUTION_320x240:
swidth = 320;
sheight = 240;
break;
}
if ((ec = FbSetMode(sresType)) < 0)
goto BAIL;
if ((ec = WndOpen((memu)hInstance, swidth, sheight, wndopenflags)) < 0)
goto BAIL;
if ((ec = VidStart()) < 0)
goto BAIL;
//
// EXCEPTIONS/FATAL RESTART HERE
//
InpOp(NUL,INPOP_FLUSH,NUL,0);
if(!setjmp(MainJmpBuf))
{
GameLoop();
}
else
{
// jjj setup real argc & argv
MainRestartArgc=1;
}
//
//
//
ec=0;
BAIL:
WndClose();
GameFinal();
FontFinal();
ObjFinal();
ResFinal();
SndFinal();
NetFinal();
FsFinal();
VidFinal();
GunFinal();
CabFinal();
InpFinal();
WndFinal();
FbFinal();
ProcFinal();
MemFinal();
IntFinal();
SysFinal();
for(ec=0;ec<COUNT(jps_memdebug_ptr);ec++)
{
if(jps_memdebug_ptr[ec])
BP(BP_MAIN); // stranded memory! -- jps_memdebug_ptr[ec]
} // for
if(MainRestartArgc)
{
if(VidDisp.showCursor)
MainRestartArgv[MainRestartArgc++]="-c";
if(!wndopenflags)
MainRestartArgv[MainRestartArgc++]="-ws";
argc=MainRestartArgc;
MainRestartArgc=0;
argv=MainRestartArgv;
goto restart;
}
return ec;
} // WinMain()
//
// SOUND SYSTEM HOOKS
//
void jps_apphook_memadd(void *p,uns size)
{
int i;
for(i=0;i<COUNT(jps_memdebug_ptr);i++)
{
if(!jps_memdebug_ptr[i])
{
jps_memdebug_ptr[i]=p;
jps_memdebug_size[i]=size;
MemSysInfo.jpsOutstanding+=size;
MemSysInfo.jpsCount++;
if(MemSysInfo.jpsLargest<(int)size)
MemSysInfo.jpsLargest=(int)size;
break;
}
} // for
} // jps_apphook_memadd()
void jps_apphook_memdel(void *p)
{
int i;
for(i=0;i<COUNT(jps_memdebug_ptr);i++)
{
if(jps_memdebug_ptr[i]==p)
{
jps_memdebug_ptr[i]=NULL;
MemSysInfo.jpsOutstanding-=jps_memdebug_size[i];
jps_memdebug_size[i]=0;
MemSysInfo.jpsCount--;
break;
}
} // for
} // jps_apphook_memdel()
void* jps_apphook_malloc(unsigned long size)
{
void *p;
p=malloc(size);
jps_apphook_memadd(p,size);
return p;
} // jps_apphook_malloc()
void jps_apphook_free(void* p)
{
jps_apphook_memdel(p);
free(p);
} // jps_apphook_free()
unsigned long jps_apphook_clock_sec(void)
{
return clock()/CLOCKS_PER_SEC;
} // jps_apphook_clock_sec()
void* jamma_apphook_malloc(int size)
{
return malloc(size);
} // jamma_apphook_malloc()
void jamma_apphook_free(void *m)
{
free(m);
} // jamma_apphook_free()
void jamma_apphook_msg(char *fmt,...)
{
char buf[2048];
va_list args;
va_start(args,fmt);
vsprintf(buf,fmt,args);
SysLog("JAMMA: %s",buf);
// BP(); // jamma system message in buf
va_end(args);
} // jamma_apphook_msg()
void jps_apphook_msg(char *fmt,...)
{
char buf[2048];
va_list args;
va_start(args,fmt);
vsprintf(buf,fmt,args);
SysLog("JPS: %s",buf);
BP(BP_JPSAPPHOOKMSG); // sound system message in buf
va_end(args);
} // jps_apphook_msg()
#endif // SYS_PC
// EOF

275
dond/corepc/sys_pc.c Executable file
View File

@@ -0,0 +1,275 @@
#if SYS_PC
// sys_bb.c
// Play Mechanix - Video Game System
// Copyright (c) 2004 Play Mechanix Inc. All Rights Reserved
//
// JFL 26 Aug 04
// JFL 07 Oct 04
#include <windows.h>
#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>
#include <GL/freeglut.h>
#include <setjmp.h>
#include "pm.h"
#include "str.h"
#include "sys.h"
#include "mem.h"
#include "aud.h"
#include "obj.h"
#include "game.h"
uns64 sysTimeBase;
// for micro-second timer
LARGE_INTEGER os_us_freq;
double os_us_freq_d;
//LPTOP_LEVEL_EXCEPTION_FILTER sysExcHandler(struct _EXCEPTION_POINTERS *exc);
LONG WINAPI sysExcHandler(struct _EXCEPTION_POINTERS *exc);
typedef struct {
void *excHandler;
} SysPC;
SysPC sysPC;
// JFL 07 Oct 04
int xSysInit(void)
{
MEMZ(sysPC);
sysTimeBase=glutGet(GLUT_ELAPSED_TIME);
sysPC.excHandler=SetUnhandledExceptionFilter(sysExcHandler);
QueryPerformanceFrequency(&os_us_freq);
os_us_freq_d = (double)(os_us_freq.QuadPart);
os_us_freq_d /= 1000000.0f; // change to us
return 0;
} // xSysInit()
// JFL 07 Oct 04
void xSysFinal(void)
{
if(sysPC.excHandler)
{
SetUnhandledExceptionFilter(sysPC.excHandler);
sysPC.excHandler=NUL;
}
} // xSysFinal()
// JFL 07 Oct 04
int xSysReset(uns reset)
{
return 0;
} // xSysReset()
// GNP 17 Jun 03
void SysWatchdogEnable(void)
{
} // SysWatchdogEnable()
// GNP 17 Jun 03
void SysWatchdogDisable(void)
{
} // SysWatchdogDisable()
// GNP 17 Jun 03
void SysWatchdogBone(void)
{
} // SysWatchdogBone
// JFL 07 Oct 04
void* SysAdr(void)
{
return NUL;
} // SysAdr()
// JFL 07 Oct 04
//void SysLockup(void *adr)
void SysLockup(int id)
{
// SysLog("LOCKUP: %x\n",adr);
SysLog("LOCKUP: %d\n",(int)id);
GameSysLog(GAMESYSLOG_STATE);
} // SysLockup()
// JFL 08 Nov 04
uns64 SysClockMilliSec(void)
{
if(SysG.forceFrameTime)
return SysG.loopTime;
else
return glutGet(GLUT_ELAPSED_TIME)-sysTimeBase;
} // SysClockMilliSec()
//
// xSysMicroSec
// return current system micro-second counter
//
// in:
// out:
// global:
//
// GNP 12 Oct 05
//
uns64 xSysMicroSec(void)
{
LARGE_INTEGER li;
double d;
double s;
uns64 retval;
QueryPerformanceCounter(&li);
d = (double)(li.QuadPart);
s = d/os_us_freq_d;
retval = (uns64)s;
return retval;
//DONE("xSysMicroSec")
} // xSysMicroSec
// JFL 20 Jul 05
int SysGetHardwareInfo(uns op,char *buf,int bufsize)
{
int ec;
DWORD dw;
char buff[8];
if(!buf)
buf=buff,bufsize=sizeof(buff),buf[0]='c';
ec=0;
switch(op&0xff)
{
case SYSGETHARDWAREINFO_SN:
// BOOL GetVolumeInformation(
// LPCTSTR lpRootPathName,
// LPTSTR lpVolumeNameBuffer,
// DWORD nVolumeNameSize,
// LPDWORD lpVolumeSerialNumber,
// LPDWORD lpMaximumComponentLength,
// LPDWORD lpFileSystemFlags,
// LPTSTR lpFileSystemNameBuffer,
// DWORD nFileSystemNameSize
// );
buf[1]=':';
buf[2]='\\';
buf[3]=0;
if(!GetVolumeInformation(buf,NUL,0,&dw,NUL,NUL,NUL,0))
dw=0;
ec=dw;
break;
} // switch
return ec;
} // SysGetHardwareInfo()
extern jmp_buf MainJmpBuf;
// JFL 22 Jul 05
void SysRestart(void)
{
longjmp(MainJmpBuf,1);
} // SysRestart()
// JFL 22 Jul 05
LONG WINAPI sysExcHandler(struct _EXCEPTION_POINTERS *exc)
{
char *s1;
switch(exc->ExceptionRecord->ExceptionCode)
{
case EXCEPTION_ACCESS_VIOLATION:
s1="ACCESS_VIOLATION";
break;
case EXCEPTION_DATATYPE_MISALIGNMENT:
s1="DATATYPE_MISALIGNMENT";
break;
case EXCEPTION_BREAKPOINT:
s1="BREAKPOINT";
break;
case EXCEPTION_SINGLE_STEP:
s1="SINGLE_STEP";
break;
case EXCEPTION_ARRAY_BOUNDS_EXCEEDED:
s1="ARRAY_BOUNDS_EXCEEDED";
break;
case EXCEPTION_FLT_DENORMAL_OPERAND:
s1="FLT_DENORMAL_OPERAND";
break;
case EXCEPTION_FLT_DIVIDE_BY_ZERO:
s1="FLT_DIVIDE_BY_ZERO";
break;
case EXCEPTION_FLT_INEXACT_RESULT:
s1="FLT_INEXACT_RESULT";
break;
case EXCEPTION_FLT_INVALID_OPERATION:
s1="FLT_INVALID_OPERATION";
break;
case EXCEPTION_FLT_OVERFLOW:
s1="FLT_OVERFLOW";
break;
case EXCEPTION_FLT_STACK_CHECK:
s1="FLT_STACK_CHECK";
break;
case EXCEPTION_FLT_UNDERFLOW:
s1="FLT_UNDERFLOW";
break;
case EXCEPTION_INT_DIVIDE_BY_ZERO:
s1="INT_DIVIDE_BY_ZERO";
break;
case EXCEPTION_INT_OVERFLOW:
s1="INT_OVERFLOW";
break;
case EXCEPTION_PRIV_INSTRUCTION:
s1="PRIV_INSTRUCTION";
break;
case EXCEPTION_IN_PAGE_ERROR:
s1="IN_PAGE_ERROR";
break;
case EXCEPTION_ILLEGAL_INSTRUCTION:
s1="ILLEGAL_INSTRUCTION";
break;
case EXCEPTION_NONCONTINUABLE_EXCEPTION:
s1="NONCONTINUABLE_EXCEPTION";
break;
case EXCEPTION_STACK_OVERFLOW:
s1="STACK_OVERFLOW";
break;
case EXCEPTION_INVALID_DISPOSITION:
s1="INVALID_DISPOSITION";
break;
case EXCEPTION_GUARD_PAGE:
s1="GUARD_PAGE";
break;
case EXCEPTION_INVALID_HANDLE:
s1="INVALID_HANDLE";
break;
case CONTROL_C_EXIT:
s1="CONTROL_C_EXIT";
break;
default:
s1="<unhandled>";
} // switch
AudException();
SysLog("EXCEPTION: %s %x %x\n",s1,
exc->ExceptionRecord->ExceptionAddress,exc->ExceptionRecord->ExceptionFlags);
GameSysLog(GAMESYSLOG_STATE);
//if(exc->ExceptionRecord->ExceptionFlags&EXCEPTION_NONCONTINUABLE)
//{
SysLog("Restarting the game.\n");
SysRestart(); // doesn't come back..
//}
return EXCEPTION_CONTINUE_SEARCH;
} // sysExcHandler()
///////////////////////////////////////////////////////////////////////////////
//
#endif // SYS_PC
// EOF

584
dond/corepc/wnd_pc.c Executable file
View File

@@ -0,0 +1,584 @@
#if SYS_PC
// wnd_pc.c
// Play Mechanix - Video Game System
// Copyright (c) 2004 Play Mechanix Inc. All Rights Reserved
//
// JFL 29 Aug 04; from ah/fb.c
#include <windows.h>
#include <GL/freeglut.h>
#include <stdarg.h>
#include "pm.h"
#include "mem.h"
#include "wnd.h"
#include "font.h"
#include "obj.h"
#include "vec.h"
#include "vid.h"
#include "inp.h"
WndRec wndlist;
// WndPrivOGL wndogl;
// JFL 07 Oct 04
int WndInit(void)
{
MEMZ(wndlist);
// MEMZ(wndogl);
return 0;
} // WndInit()
// JFL 07 Oct 04
void WndFinal(void)
{
} // WndFinal()
// JFL 07 Oct 04
int WndReset(uns reset)
{
return 0;
} // WndReset()
void* WndCur(void)
{
return &wndlist;
} // WndCur()
// JFL 12 Nov 04
int xInpLowScan(void)
{
uns flags;
flags=0;
if(GetAsyncKeyState(VK_SHIFT)<0)
flags|=M_INPLOWEVENT_SHF;
if(GetAsyncKeyState(VK_CONTROL)<0)
flags|=M_INPLOWEVENT_CTL;
if(GetAsyncKeyState(VK_MENU)<0)
flags|=M_INPLOWEVENT_ALT;
InpLowEvent(INPLOWEVENT_NOP|flags,NUL);
return 0;
} // xInpLowScan()
LRESULT CALLBACK wndProc(HWND hwnd, UINT msg, WPARAM wp, LPARAM lp)
{
crd buf[3];
uns flags=0;
static HWND hwndCapture=NUL;
static int capture=0;
#if !PRODUCTION
char keys[32];
#endif // !PRODUCTION
switch (msg)
{
case WM_CREATE:
break;
case WM_CLOSE:
PostQuitMessage(0);
break;
case WM_DESTROY:
break;
case WM_SYSCOMMAND:
// prevent screensave or powersave mode
if((wp==SC_SCREENSAVE)||(wp==SC_MONITORPOWER))
return 0;
goto return_default;
#if !PRODUCTION
case WM_CHAR:
if(GetKeyState(VK_SHIFT)<0)
flags|=M_INPLOWEVENT_SHF;
if(GetKeyState(VK_CONTROL)<0)
flags|=M_INPLOWEVENT_CTL;
if(GetKeyState(VK_MENU)<0)
flags|=M_INPLOWEVENT_ALT;
if(0)
{
wm_key:
if(flags&M_INPLOWEVENT_SHF)
{
if(wp>='a'&&wp<='z')
wp=wp-'a'+'A';
}
else
{
if(wp>='A'&&wp<='Z')
wp=wp-'A'+'a';
}
}
// this does generate an extra event (higher level must sort out)
// if((wp=='s')||(wp=='S'))
// InpLowEvent(INPLOWEVENT_SYS_KEYS_DOWN|flags,NUL);
keys[0]=wp;
keys[1]=0;
InpLowEvent(INPLOWEVENT_SYS_KEYS_DOWN|flags,keys);
break;
case WM_KEYDOWN:
case WM_SYSKEYDOWN:
if(GetKeyState(VK_SHIFT)<0)
flags|=M_INPLOWEVENT_SHF;
if(GetKeyState(VK_CONTROL)<0)
flags|=M_INPLOWEVENT_CTL;
if(GetKeyState(VK_MENU)<0)
flags|=M_INPLOWEVENT_ALT;
switch (wp)
{
case ' ':
if(flags&M_INPLOWEVENT_ALT)
goto wm_key;
break;
case VK_CANCEL:
PostQuitMessage(0);
break;
case VK_LEFT:
InpLowEvent(INPLOWEVENT_P0_L_DOWN,NUL);
break;
case VK_RIGHT:
InpLowEvent(INPLOWEVENT_P0_R_DOWN,NUL);
break;
case VK_UP:
InpLowEvent(INPLOWEVENT_P0_U_DOWN,NUL);
break;
case VK_DOWN:
InpLowEvent(INPLOWEVENT_P0_D_DOWN,NUL);
break;
case VK_NEXT:
InpLowEvent(INPLOWEVENT_P0_D2_DOWN,NUL);
break;
case VK_PRIOR:
InpLowEvent(INPLOWEVENT_P0_U2_DOWN,NUL);
break;
case VK_ESCAPE:
InpLowEvent(INPLOWEVENT_SYS_ESC_DOWN,NUL);
break;
case VK_F1:
case VK_F2:
case VK_F3:
case VK_F4:
case VK_F5:
case VK_F6:
case VK_F7:
case VK_F8:
case VK_F9:
case VK_F10:
case VK_F11:
case VK_F12:
keys[0]=wp-VK_F1+INPKEY_F1;
keys[1]=0;
InpLowEvent(INPLOWEVENT_SYS_KEYS_DOWN,keys);
break;
case VK_SHIFT:
case VK_CONTROL:
case VK_MENU:
// don't generate an inp event
break;
default:
if(flags&M_INPLOWEVENT_ALT) // otherwise this doesn't generate WM_CHAR
goto wm_key;
break;
} // switch
break;
case WM_KEYUP:
case WM_SYSKEYUP:
switch (wp)
{
case VK_LEFT:
InpLowEvent(INPLOWEVENT_P0_L_UP,NUL);
break;
case VK_RIGHT:
InpLowEvent(INPLOWEVENT_P0_R_UP,NUL);
break;
case VK_UP:
InpLowEvent(INPLOWEVENT_P0_U_UP,NUL);
break;
case VK_DOWN:
InpLowEvent(INPLOWEVENT_P0_D_UP,NUL);
break;
case VK_NEXT:
InpLowEvent(INPLOWEVENT_P0_D2_UP,NUL);
break;
case VK_PRIOR:
InpLowEvent(INPLOWEVENT_P0_U2_UP,NUL);
break;
case VK_ESCAPE:
InpLowEvent(INPLOWEVENT_SYS_ESC_UP,NUL);
break;
case VK_F1:
case VK_F2:
case VK_F3:
case VK_F4:
case VK_F5:
case VK_F6:
case VK_F7:
case VK_F8:
case VK_F9:
case VK_F10:
case VK_F11:
case VK_F12:
keys[0]=wp-VK_F1+INPKEY_F1;
keys[1]=0;
InpLowEvent(INPLOWEVENT_SYS_KEYS_UP,keys);
break;
case VK_SHIFT:
case VK_CONTROL:
case VK_MENU:
// don't generate an inp event
break;
default:
if(GetKeyState(VK_SHIFT)<0)
flags|=M_INPLOWEVENT_SHF;
if(GetKeyState(VK_CONTROL)<0)
flags|=M_INPLOWEVENT_CTL;
if(GetKeyState(VK_MENU)<0)
flags|=M_INPLOWEVENT_ALT;
if(wp>127)
wp-=128;
if(!(flags&M_INPLOWEVENT_SHF))
{
if((wp>='A')&&(wp<='Z'))
wp=wp-'A'+'a';
}
else
{
if((wp>='a')&&(wp<='z'))
wp=wp-'a'+'A';
}
keys[0]=wp;
keys[1]=0;
// this does generate an extra event (higher level must sort out)
//if((wp=='s')||(wp=='S'))
InpLowEvent(INPLOWEVENT_SYS_KEYS_UP|flags,keys);
break;
} // switch
break;
#endif // !PRODUCTION
case WM_CAPTURECHANGED:
hwndCapture=NUL;
break;
case WM_LBUTTONDOWN:
InpLowEvent(INPLOWEVENT_MOUSE_LB_DOWN,NUL);
if(!capture++) SetCapture(hwnd),hwndCapture=hwnd;
break;
case WM_LBUTTONUP:
InpLowEvent(INPLOWEVENT_MOUSE_LB_UP,NUL);
if(!--capture) ReleaseCapture(),hwndCapture=NUL;
break;
case WM_RBUTTONDOWN:
InpLowEvent(INPLOWEVENT_MOUSE_RB_DOWN,NUL);
if(!capture++) SetCapture(hwnd),hwndCapture=hwnd;
break;
case WM_RBUTTONUP:
InpLowEvent(INPLOWEVENT_MOUSE_RB_UP,NUL);
if(!--capture) ReleaseCapture(),hwndCapture=NUL;
break;
case WM_MBUTTONDOWN:
InpLowEvent(INPLOWEVENT_MOUSE_CB_DOWN,NUL);
if(!capture++) SetCapture(hwnd),hwndCapture=hwnd;
break;
case WM_MBUTTONUP:
InpLowEvent(INPLOWEVENT_MOUSE_CB_UP,NUL);
if(!--capture) ReleaseCapture(),hwndCapture=NUL;
break;
case WM_MOUSEMOVE:
buf[0] = LOWORD(lp); // client x
buf[1] = HIWORD(lp); // client y
InpLowEvent(INPLOWEVENT_MOUSE_MOVE_XY,buf);
break;
case 0x020A: // WM_MOUSEWHEEL:
buf[0] = HIWORD(wp); // wheel-delta
InpLowEvent(INPLOWEVENT_MOUSE_DELTA_Z,buf);
break;
default:
return_default:
return DefWindowProc(hwnd,msg,wp,lp);
}
return 0;
} // wndProc()
// JFL 07 Oct 04
int wndOpenGL(WndRec *wnd,int x,int y,int w,int h)
{
int ec;
PIXELFORMATDESCRIPTOR pfd;
int format;
// get the device context (DC)
if(!(wnd->hdc = GetDC(wnd->hwnd)))
err(-1);
// set the pixel format for the DC
MEMZ(pfd);
pfd.nSize = sizeof( pfd );
pfd.nVersion = 1;
pfd.dwFlags = PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL | PFD_DOUBLEBUFFER;
pfd.iPixelType = PFD_TYPE_RGBA;
pfd.cColorBits = 24;
pfd.cAlphaBits = 8;
pfd.cDepthBits = 24;
pfd.cStencilBits = 8;
pfd.iLayerType = PFD_MAIN_PLANE;
format = ChoosePixelFormat(wnd->hdc, &pfd);
SetPixelFormat(wnd->hdc, format, &pfd);
// create render context
if(!(wnd->hrc = wglCreateContext(wnd->hdc)))
{
errlog("Couldn't create OpenGL context");
err(-2);
}
wglMakeCurrent(wnd->hdc,wnd->hrc);
//
//
//
wnd->w = w;
wnd->h = h;
glViewport(x,y,w,h);
//
// DEFAULT STATE VARS
//
ec=0;
BAIL:
return ec;
} // wndOpenGL()
// JFL 07 Oct 04
void wndCloseGL(WndRec *wnd)
{
wglMakeCurrent( NULL, NULL );
if(wnd->hrc)
wglDeleteContext( wnd->hrc );
wnd->hrc=NUL;
if(wnd->hwnd && wnd->hdc)
ReleaseDC(wnd->hwnd,wnd->hdc);
wnd->hdc=NUL;
} // wndCloseGL
// JFL 23 Mar 05
int wndFullScreen(uns w,uns h)
{
DEVMODE dm;
MEMZ(dm);
dm.dmSize=sizeof(dm);
dm.dmPelsWidth= w;
dm.dmPelsHeight= h;
dm.dmBitsPerPel= 32;
dm.dmFields=DM_BITSPERPEL|DM_PELSWIDTH|DM_PELSHEIGHT;
if(ChangeDisplaySettings(&dm,CDS_FULLSCREEN)!=DISP_CHANGE_SUCCESSFUL)
return -1;
return 0;
} // wndFullScreen()
// JFL 23 Mar 05
int wndCloseScreen(void)
{
ChangeDisplaySettings(NUL,0);
return 0;
} // wndCloseScreen()
// JFL 07 Oct 04
int WndOpen(memu hinst,uns w,uns h,uns flags)
{
int ec;
WNDCLASS wc;
WndRec *wnd=&wndlist;
int winl,winr,wint,winb; // windows uses left,right,top,bottom
uns drawStyle;
// extra menubar etc
winl=0; // jjj -- get these from the system metrics
winr=6;
wint=32;
winb=0;
drawStyle=WS_OVERLAPPEDWINDOW;
if(flags&1)
{
if((ec=wndFullScreen(w,h))>=0)
{
wnd->fullScreen=1;
drawStyle=WS_POPUP;
winl=0;
winr=0;
wint=0;
winb=0;
}
}
drawStyle|=WS_CLIPSIBLINGS|WS_CLIPCHILDREN;
if(!wnd->hinst)
{
wnd->hinst=(void*)hinst;
// register
wc.style = CS_OWNDC;
wc.lpfnWndProc = wndProc;
wc.cbClsExtra = 0;
wc.cbWndExtra = 0;
wc.hInstance = (void*)hinst;
wc.hIcon = LoadIcon( NULL, IDI_APPLICATION );
wc.hCursor = LoadCursor( NULL, IDC_ARROW );
wc.hbrBackground = (HBRUSH)GetStockObject( BLACK_BRUSH );
wc.lpszMenuName = NUL;
wc.lpszClassName = "CoreClass";
RegisterClass( &wc );
} // hinst
if(!wnd->hwnd)
{
if(!(wnd->hwnd = CreateWindow("CoreClass", "PlayMechanix",
drawStyle | WS_VISIBLE,
0,0,w+winl+winr,h+wint+winb,
NULL, NULL, wnd->hinst, NULL )))
err(ERR_WND_SETUP);
} // hwnd
// start w/cursor off
ShowCursor(0);
if((ec=wndOpenGL(wnd,winl,winb,w,h))<0)
goto BAIL;
FontReset(M_RESET_REBUILD);
wnd->ready=1;
ec=0;
BAIL:
return ec;
} // WndOpen()
// JFL 07 Oct 04
void WndClose(void)
{
WndRec *wnd=&wndlist;
wndCloseGL(wnd);
if(wnd->hwnd)
DestroyWindow(wnd->hwnd);
wnd->hwnd=NUL;
wnd->ready=0;
if(wnd->fullScreen)
{
wndCloseScreen();
}
} // WndClose
// JFL 07 Oct 04
// JFL 25 Jul 05
int WndInpLoop(void)
{
MSG msg;
WndRec *wnd=&wndlist;
int ec=0;
// check for messages
while(PeekMessage( &msg, NULL, 0, 0, PM_REMOVE ))
{
// handle or dispatch messages
if ( msg.message == WM_QUIT )
{
wnd->quit = 1;
ec=-1;
}
else
{
TranslateMessage( &msg );
DispatchMessage( &msg );
}
} // while
return ec;
} // WndInpLoop()
// JFL 07 Oct 04
int WndLoop(void)
{
int ec=0;
WndRec *wnd=&wndlist;
if(!wnd->ready)
return 1;
if(SysG.quit)
PostQuitMessage(0);
if(!VidDisp.showCursor)
{
VidDisp.showCursor=2; // dont-change
ShowCursor(0);
}
else if(VidDisp.showCursor==1)
{
VidDisp.showCursor=2; // dont-change
ShowCursor(1);
}
return ec;
} // WndLoop()
// JFL 29 Jan 05
void WndSwap(WndRec *wnd)
{
if(!wnd)
wnd=&wndlist;
if(!wnd || !wnd->ready)
return;
#if PRODUCTION
if(SysG.proflags&M_SYSG_PROFLAGS_DONTFLIP)
return;
#endif // PRODUCTION
SwapBuffers(wnd->hdc);
} // WndSwap()
// JFL 28 Oct 04
void errlog(char *msg)
{
#if PRODUCTION
SysLog("ERRLOG: %s\n",msg);
#else // !PRODUCTION
WndRec *wnd=&wndlist;
static dontshow=0;
if(!dontshow)
{
if(IDCANCEL==MessageBox(wnd->hwnd,msg,"ErrLog",MB_OKCANCEL))
dontshow=1;
}
#endif // !PRODUCTION
} // errlog()
#endif // SYS_PC
// EOF

86
dond/linux/makefile Executable file
View File

@@ -0,0 +1,86 @@
# makefile -- gnu make
# JFL 25 Jan 05
# JFL 15 Apr 05
# JFL 31 May 05
# idea is to build from the PC directory structure into D1
H1=.
D1=./linux/tmp
S1=./bbh3/core
OBJ1=$(D1)/cab.o $(D1)/cam.o $(D1)/fc.o $(D1)/fs.o $(D1)/ftp.o $(D1)/gun.o \
$(D1)/inp.o $(D1)/mem.o $(D1)/mem_data.o $(D1)/obj.o $(D1)/proc.o \
$(D1)/res.o \
$(D1)/snd.o $(D1)/str.o $(D1)/sys.o $(D1)/vec.o
S2=./bbh3/corebb
OBJ2=$(D1)/int_bb.o $(D1)/main_bb.o $(D1)/sys_bb.o $(D1)/wnd_bb.o
S3=./bbh3/coregl
OBJ3=$(D1)/diag_gl.o $(D1)/draw_gl.o $(D1)/fb_gl.o $(D1)/font_gl.o $(D1)/fs_gl.o \
$(D1)/net_gl.o $(D1)/obj_gl.o $(D1)/res_gl.o $(D1)/vid_gl.o
S4=./bbh3/game
OBJ4=$(D1)/at.o $(D1)/aud.o $(D1)/bgend.o $(D1)/boars.o $(D1)/bonus.o $(D1)/credits.o \
$(D1)/crit.o $(D1)/currency.o $(D1)/deer.o \
$(D1)/diag.o $(D1)/dove.o $(D1)/duck.o $(D1)/edit.o \
$(D1)/fcfunc.o $(D1)/frog.o $(D1)/game.o $(D1)/gcon.o $(D1)/gears.o $(D1)/gopher.o \
$(D1)/hclub.o $(D1)/hcstat.o \
$(D1)/hisc.o $(D1)/initials.o \
$(D1)/lboard.o $(D1)/logyard.o $(D1)/m.o $(D1)/mars.o $(D1)/moon.o $(D1)/part.o \
$(D1)/pheasant.o $(D1)/piesky.o $(D1)/player.o $(D1)/plgun.o $(D1)/pmnet.o $(D1)/proj.o \
$(D1)/quail.o $(D1)/report.o $(D1)/report2p.o $(D1)/sel.o \
$(D1)/shells.o $(D1)/site.o \
$(D1)/sitesel.o $(D1)/tapper.o $(D1)/text3d.o $(D1)/tip.o $(D1)/trek.o $(D1)/trny.o \
$(D1)/turkey.o $(D1)/weather.o $(D1)/windmill.o $(D1)/winner.o
# OBJ4B is a list of game files that should not be added to the game library
# as they are intended to be built by outside groups
OBJ4B=$(D1)/prts_interface.o $(D1)/prts_msg.o $(D1)/prts_utils.o
buildall=$(D1)/game
CFLAGS=-g -DSYS_BB -DSYS_GL -DDEBUG
#CFLAGS=-DSYS_BB -DSYS_GL -DPRODUCTION
CFLAGS+=-O3
CFLAGS+=-Wno-sign-compare -Wno-conversion -Wno-missing-prototypes
CFLAGS+=-I $(H1)/bbh3/core -I $(H1)/bbh3/game -I $(H1)/lib
CFLAGS+=-I /usr/X11/include -I /usr/local/include
CC=gcc
LD=gcc --mode=link
LFLAGS=-L/usr/X11/lib -lGL -lGLU -lglut -lpthread -lrt
LIBS=$(H1)/lib/libjps.a $(H1)/lib/libjamma.a
# library name for game
TARGETLIB = $(D1)/libgame.a
$(D1)/game: $(OBJ1) $(OBJ2) $(OBJ3) $(OBJ4) $(OBJ4B) $(LIBS)
$(LD) $(LFLAGS) $^ -o $@
cp $(D1)/game .
$(D1)/%.o : $(S1)/%.c
$(CC) $(CFLAGS) -c $< -o $@
$(D1)/%.o : $(S2)/%.c
$(CC) $(CFLAGS) -c $< -o $@
$(D1)/%.o : $(S3)/%.c
$(CC) $(CFLAGS) -c $< -o $@
$(D1)/%.o : $(S4)/%.c
$(CC) $(CFLAGS) -c $< -o $@
.PHONY: all clean
all: $(buildall)
clean:
rm $(D1)/*.o
# lib target makes the game objects an archive
lib: $(TARGETLIB)
$(TARGETLIB) : $(OBJ1) $(OBJ2) $(OBJ3) $(OBJ4)
ar rs $(TARGETLIB) $(OBJ1) $(OBJ2) $(OBJ3) $(OBJ4)
cp $(TARGETLIB) ./lib

BIN
dond/linux/vssver.scc Executable file
View File

Binary file not shown.

282
donddata/cf/at.cf Normal file
View File

@@ -0,0 +1,282 @@
// CF01 - Copyright (C) 2004, PlayMechanix, Inc.
//
seq atcoinp1 (
alloc(8)
start()
// set(level 3)
// load(atcback)
// add(atcback)
// load(cougar)
// load(atcbanim)
// create(cougar .f=d3 .sk=-) bin(mv 0 0 mv 4 4)
// ban($0 atcbacka fl=loop)
//
// cam(courcam)
)
seq atcoinp2 (
alloc(10)
start()
set(level 3)
load(atwback)
add(atwback)
load(wolf)
load(atwbanim)
create(wolf .f=d3 .sk=-) bin(mv 0 0 mv 4 4)
create(wolf .f=d3 .sk=-) bin(mv 5 0 mv 9 4)
ban($0 atwback1 fl=loop)
ban($5 atwback2 fl=loop)
cam(wolfcam)
)
seq atcoinp3 (
alloc(8)
start()
// set(level 3)
load(atbback)
load(bear)
load(atbbanim)
add(atbback)
create(bear .f=d3 .sk=-) bin(mv 0 0 mv 4 4)
ban($0 atbbacka fl=loop)
cam(bearcam)
)
seq atpmlogo (
alloc(4)
start()
set(tag 1) // set tag
load(pmlogo)
mark(cam3)
create(pmlogo.pmlogo .f=d2 .lb)
cam(atcam)
) // atpmlogo
seq ath2haction (
alloc(4)
start()
set(tag 1) // set tag
load(h2haction)
mark(cam2d)
create(h2haction .f=d2 .la)
cam(atcam)
)
seq ath2haction2 (
alloc(4)
start()
set(tag 1) // set tag
load(h2haction2)
mark(cam2d)
create(h2haction2 .f=d2 .la)
cam(atcam)
)
seq atrtlogo (
alloc(4)
start()
set(tag 1) // set tag
load(rawthrills)
mark(cam3)
create(rawthrills.raw .f=d2 .lb)
cam(selcam)
) // rawthrills
seq atTitle (
alloc(4)
start()
set(tag 1) // set tag
load(title)
mark(cam3)
create(title.title .f=d2 .lb)
cam(atcam)
) // atTitle
seq credBG(
alloc(8)
start()
load(deerrack)
add(deerrack)
load(whitetail)
load(whitetailbbuck)
load(whitetaildoe)
load(deeranim)
run(deer)
create(whitetail .f=d3 .sk=- .sh=-)
bin(mv 0 0 mv 4 4)
ban($0 deerrack1 fl=loop)
obj(ob=$4 fl=gcol,loop,primekill rm=0.01)
create(whitetailbuck .f=d3 .sk=- .sh=-)
bin(mv 0 0 mv 4 4)
ban($0 dbuckrack fl=loop)
obj(ob=$4 fl=gcol,loop,primekill rm=0.01)
create(whitetaildoe .f=d3 .sk=- .sh=-)
bin(mv 0 0 mv 4 4)
ban($0 doerack1 fl=loop)
obj(ob=$4 fl=gcol,loop,primekill rm=0.01)
create(whitetaildoe .f=d3 .sk=- .sh=-)
bin(mv 0 0 mv 4 4)
ban($0 doerack2 fl=loop)
obj(ob=$4 fl=gcol,loop,primekill rm=0.01)
cam(deerrack)
) // credBG
seq creditSeq (
alloc(8)
start()
ani(- credBG)
mark(cam3)
ani(- creditRollerSeq)
fc(fcCreditShow 0 32 0 0)
sleep(120)
fc(fcCreditShow 1 32 0 0)
sleep(120)
fc(fcCreditShow 2 32 0 0)
sleep(140)
// ex prod
fc(fcCreditShow 17 32 0 0)
fc(fcCreditShow 18 32 -6 0)
sleep(150)
//programmers
fc(fcCreditShow 3 32 0 0)
fc(fcCreditShow 4 32 -6 0)
sleep(300)
//artists
fc(fcCreditShow 5 32 0 0)
fc(fcCreditShow 6 32 -6 0)
sleep(330)
//big rob
fc(fcCreditShow 7 32 0 0)
fc(fcCreditShow 8 32 -6 0)
sleep(150)
//sound
fc(fcCreditShow 9 32 0 0)
fc(fcCreditShow 10 32 -6 0)
sleep(210)
//prod
fc(fcCreditShow 19 32 0 1)
fc(fcCreditShow 20 32 -6 1)
sleep(180)
//mechanical design
fc(fcCreditShow 21 32 0 1)
fc(fcCreditShow 22 32 -6 1)
sleep(180)
fc(fcCreditKill 0)
//cabinet art
fc(fcCreditShow 23 32 0 1)
fc(fcCreditShow 24 32 -6 1)
sleep(180)
//engineering
fc(fcCreditShow 25 32 0 1)
fc(fcCreditShow 26 32 -6 1)
sleep(260)
//promotional art
fc(fcCreditShow 27 32 0 1)
fc(fcCreditShow 28 32 -6 1)
sleep(160)
//prod/qual
fc(fcCreditShow 29 32 0 1)
fc(fcCreditShow 30 32 -6 1)
sleep(160)
//testers
fc(fcCreditShow 31 32 0 1)
fc(fcCreditShow 32 32 -6 1)
sleep(119)
fc(fcCreditShow 33 32 -6 1)
sleep(230)
//bb girls
fc(fcCreditShow 34 32 0 2)
fc(fcCreditShow 35 32 -6 2)
sleep(210)
//special thanks
fc(fcCreditShow 11 32 0 2)
fc(fcCreditShow 12 32 -6 2)
sleep(80)
// fc(fcCreditShow 13 32 -6 2)
sleep(140)
fc(fcCreditKill 1)
//special thanks RT
fc(fcCreditShow 36 32 0 2)
fc(fcCreditShow 37 16 -6 2)
fc(fcCreditShow 40 48 -6 2)
sleep(82)
fc(fcCreditShow 38 16 -6 2)
fc(fcCreditShow 41 48 -6 2)
sleep(82)
fc(fcCreditShow 39 16 -6 2)
fc(fcCreditShow 42 48 -6 2)
sleep(210)
//families
fc(fcCreditShow 14 32 0 2)
fc(fcCreditShow 15 16 -6 2)
fc(fcCreditShow 16 48 -6 2)
sleep(270)
//made in USA
fc(fcCreditShow 43 32 -6 2)
sleep(80)
fc(fcCreditShow 44 32 -6 2)
sleep(500)
fc(fcCredDone)
)
seq creditRollerSeq (
alloc(8)
start()
credLoop:
sloop(1)
fc(fcCreditRoll)
br(credLoop)
)
// EOF

737
donddata/cf/attract.cf Normal file
View File

@@ -0,0 +1,737 @@
// CF01 - Copyright (C) 2004, PlayMechanix, Inc.
// ---------------------------------------------
// ---------------------------------------------
seq sAtrLEDAnim (
start()
loop:
fc(fcDondSetLampWrite 15 0)
fc(fcDondSetLampWrite 0 1)
sleep(5)
fc(fcDondSetLampWrite 0 0)
fc(fcDondSetLampWrite 1 1)
sleep(5)
fc(fcDondSetLampWrite 1 0)
fc(fcDondSetLampWrite 2 1)
sleep(5)
fc(fcDondSetLampWrite 2 0)
fc(fcDondSetLampWrite 3 1)
sleep(5)
fc(fcDondSetLampWrite 3 0)
fc(fcDondSetLampWrite 4 1)
sleep(5)
fc(fcDondSetLampWrite 4 0)
fc(fcDondSetLampWrite 5 1)
sleep(5)
fc(fcDondSetLampWrite 5 0)
fc(fcDondSetLampWrite 6 1)
sleep(5)
fc(fcDondSetLampWrite 6 0)
fc(fcDondSetLampWrite 7 1)
sleep(5)
fc(fcDondSetLampWrite 7 0)
fc(fcDondSetLampWrite 8 1)
sleep(5)
fc(fcDondSetLampWrite 8 0)
fc(fcDondSetLampWrite 9 1)
sleep(5)
fc(fcDondSetLampWrite 9 0)
fc(fcDondSetLampWrite 10 1)
sleep(5)
fc(fcDondSetLampWrite 10 0)
fc(fcDondSetLampWrite 11 1)
sleep(5)
fc(fcDondSetLampWrite 11 0)
fc(fcDondSetLampWrite 12 1)
sleep(5)
fc(fcDondSetLampWrite 12 0)
fc(fcDondSetLampWrite 13 1)
sleep(5)
fc(fcDondSetLampWrite 13 0)
fc(fcDondSetLampWrite 14 1)
sleep(5)
fc(fcDondSetLampWrite 14 0)
fc(fcDondSetLampWrite 15 1)
sleep(5)
fc(fcDondSetLampWrite 14 1) sleep(5)
fc(fcDondSetLampWrite 13 1) sleep(5)
fc(fcDondSetLampWrite 12 1) sleep(5)
fc(fcDondSetLampWrite 11 1) sleep(5)
fc(fcDondSetLampWrite 10 1) sleep(5)
fc(fcDondSetLampWrite 9 1) sleep(5)
fc(fcDondSetLampWrite 8 1) sleep(5)
fc(fcDondSetLampWrite 7 1) sleep(5)
fc(fcDondSetLampWrite 6 1) sleep(5)
fc(fcDondSetLampWrite 5 1) sleep(5)
fc(fcDondSetLampWrite 4 1) sleep(5)
fc(fcDondSetLampWrite 3 1) sleep(5)
fc(fcDondSetLampWrite 2 1) sleep(5)
fc(fcDondSetLampWrite 1 1) sleep(5)
fc(fcDondSetLampWrite 0 1) sleep(5)
fc(fcDondSetLampWrite 15 0) sleep(5)
fc(fcDondSetLampWrite 14 0) sleep(5)
fc(fcDondSetLampWrite 13 0) sleep(5)
fc(fcDondSetLampWrite 12 0) sleep(5)
fc(fcDondSetLampWrite 11 0) sleep(5)
fc(fcDondSetLampWrite 10 0) sleep(5)
fc(fcDondSetLampWrite 9 0) sleep(5)
fc(fcDondSetLampWrite 8 0) sleep(5)
fc(fcDondSetLampWrite 7 0) sleep(5)
fc(fcDondSetLampWrite 6 0) sleep(5)
fc(fcDondSetLampWrite 5 0) sleep(5)
fc(fcDondSetLampWrite 4 0) sleep(5)
fc(fcDondSetLampWrite 3 0) sleep(5)
fc(fcDondSetLampWrite 2 0) sleep(5)
fc(fcDondSetLampWrite 1 0) sleep(5)
fc(fcDondSetLampWrite 0 0) sleep(5)
br(loop)
)
// ---------------------------------------------
seq sAtrLEDOff (
start()
fc(fcDondSetLamp 15 1) fc(fcDondSetLampWrite 15 0)
fc(fcDondSetLamp 14 1) fc(fcDondSetLampWrite 14 0)
fc(fcDondSetLamp 13 1) fc(fcDondSetLampWrite 13 0)
fc(fcDondSetLamp 12 1) fc(fcDondSetLampWrite 12 0)
fc(fcDondSetLamp 11 1) fc(fcDondSetLampWrite 11 0)
fc(fcDondSetLamp 10 1) fc(fcDondSetLampWrite 10 0)
fc(fcDondSetLamp 9 1) fc(fcDondSetLampWrite 9 0)
fc(fcDondSetLamp 8 1) fc(fcDondSetLampWrite 8 0)
fc(fcDondSetLamp 7 1) fc(fcDondSetLampWrite 7 0)
fc(fcDondSetLamp 6 1) fc(fcDondSetLampWrite 6 0)
fc(fcDondSetLamp 5 1) fc(fcDondSetLampWrite 5 0)
fc(fcDondSetLamp 4 1) fc(fcDondSetLampWrite 4 0)
fc(fcDondSetLamp 3 1) fc(fcDondSetLampWrite 3 0)
fc(fcDondSetLamp 2 1) fc(fcDondSetLampWrite 2 0)
fc(fcDondSetLamp 1 1) fc(fcDondSetLampWrite 1 0)
fc(fcDondSetLamp 0 1) fc(fcDondSetLampWrite 0 0)
)
// ---------------------------------------------
seq sAttractStart (
alloc(8)
start()
fc(fcDondAskAtrMode $7)
mark(fntA)
//fc(fcDondAnimLED 4)
restart:
// - stop any previous music
sound(99)
vidstop(bgVideo)
kill(bgVideo)
br(.t $7 startGirls startVideo startGirls startVideo startGirls startVideo startGirls startVideo)
startGirls:
ani(- sAtrLEDAnim)
create(bgVideo .f=d2 .lb)
vidplay(bgVideo 0) // - 0 = don't ignore clock
// - turn off the "demo mode" text
fc(fcDondAttractText 0)
sloop(1)
fc(fcDondAskAtrSound $6)
br(.z $6 skipSound1)
sound(52)
skipSound1:
mark(fntA)
kill(models_start)
create(models_start .f=d2 .lb .v .s=sPrompt)
bin(mv 4 0) send($4 6)
mark(fntA)
kill(title_page)
create(title_page .f=d2 .lb .v .s=sPrompt)
bin(mv 5 0) send($5 5)
sleep(600)
send($4 2)
send($5 2)
mark(fntA)
kill(ice_logo)
create(ice_logo .f=d2 .lb .v .s=sPrompt)
bin(mv 4 0) send($4 5)
sleep(1)
mark(fntA)
kill(pm_logo1)
create(pm_logo1 .f=d2 .lb .v .s=sPrompt)
bin(mv 5 0) send($5 5)
sleep(300)
send($4 2)
send($5 2)
br(end)
// - play the title video
startVideo:
fc(fcDondAnimLED 4)
vidstop(bgVideo)
vidreset(bgVideo)
create(titleVideo .f=d2 .lb)
vidplay(titleVideo 0)
viddone(titleVideo sAtrVidDone)
// - turn on the "demo mode" text
fc(fcDondAttractText 1)
fc(fcDondAskAtrSound $6)
br(.z $6 skipSound2)
sound(2)
sound(373)
skipSound2:
sleep(290)
br(.t $7 end startReveal end startBanker end startReveal end startBanker)
// - show the wide scene
startReveal:
fc(fcDondAskAtrSound $6)
br(.z $6 skipSound3)
sound(1)
skipSound3:
vidstop(bgVideo)
kill(bgVideo)
ani(- fakeMainScene)
fc(fcDondFadeOut titleVideo)
// - "now choose 5 cases"
sleep(40)
fc(fcDondAskAtrSound $6)
br(.z $6 skipSound4)
sound(302)
skipSound4:
sleep(50)
ani(- startWideAnim)
sleep(210)
// - play a case reveal scene
fc(fcDondAskAtrSound $6)
br(.z $6 skipSound5)
sound(200) // - polite applause
sound(11) // - case open build-up sound
skipSound5:
ani(- stopWideAnim)
fc(fcDondPlayGradedReveal)
fc(fcDondAskGradedReveal $0)
sleep(30)
fc(fcDondAskAtrSound $6)
br(.z $6 skipSound8)
fc(fcDondPlayCaseOpenVocal 0)
skipSound8:
revealLoop:
sleep(1)
fc(fcDondAskVideoFrame * $1 $0) // $1 = video frame of object named "*"
br(.z $1 revealLoop)
fc(fcDondAskAtrSound $6)
br(.z $6 skipSound9)
fc(fcDondPlayGradedAudio)
skipSound9:
bin(si 0 100) // <- $0 = 100
scaleLoop:
sleep(1)
fc(fcDondDrawCaseValue $0 52.0 18.0) // <- shrinkRate, xpos, ypos
bin(ai 0 -10) // <- $0 = $0 - 10;
br(.n $0 scaleLoop) // <- if ($0 != 0) goto scaleLoop
// - create the "ticket" label
fc(fcDondAskForFun $0)
br(.n $0 noLabel)
fc(fcDondAskCoupOrTick $0)
br(.z $0 coupons)
create(c_ticket .f=d2 .lb .v .s=sPrompt) bin(mv 2 0)
br(prizeDone)
coupons:
create(c_coupon .f=d2 .lb .v .s=sPrompt) bin(mv 2 0)
prizeDone:
obj(ob=$2 xq=52.0)
obj(ob=$2 yq=17.0)
noLabel:
sleep(10)
fc(fcDondAskAtrSound $6)
br(.z $6 skipSound10)
fc(fcDondPlayGradedCrowdAudio)
skipSound10:
fc(fcDondRedrawValues)
sleep(40)
fc(fcDondAskAtrSound $6)
br(.z $6 skipSound11)
fc(fcDondPlayCaseOpenVocal 1)
skipSound11:
sleep(240)
fc(fcDondFadeKillReveal)
kill($2)
fc(fcDondCaseRevealDone)
fc(fcDondFadeOut bg_tight)
kill(background)
kill(model_*)
kill(case_*)
kill(shadow_*)
kill(tick*)
kill(coup*)
br(end)
// ...
startBanker:
fc(fcDondAskAtrSound $6)
br(.z $6 skipSound6)
sound(1)
skipSound6:
vidstop(bgVideo)
vidreset(bgVideo)
kill(bgVideo)
fc(fcDondFadeOut titleVideo)
ani(- fakeBankScene)
sleep(700)
vidstop(bank_anim) vidstop(bank2_anim)
fc(fcDondUpdateBankerText 0)
kill(bank*)
kill(tick*)
kill(coup*)
kill(offer*)
kill(banker*)
kill(bg_*)
kill(back*)
kill(bckgrnd*)
kill(bank_tix)
kill(pr*)
kill(deal)
kill(nodeal)
// ....
br(end)
end:
//kill(createInitScene .t=seq)
//ani(- createInitScene)
fc(fcDondSetGameState 99)
fc(fcDondAttractText 0)
)
// ---------------------------------------------
seq sAtrVidDone (
start()
vidstop(titleVideo)
)
// ---------------------------------------------
seq sAtrGirlDone (
start()
vidstop(mr_bad_10)
)
// ---------------------------------------------
seq sAtrCleanup (
start()
fc(fcDondUnloadVideos)
kill(*)
kill(fakeMainScene .t=seq)
kill(fakeBankScene .t=seq)
kill(sATBankerRv .t=seq)
)
// ---------------------------------------------
// fakeMainScene
seq fakeMainScene (
alloc(4)
start()
mark(bgmrk)
kill(model_*)
// - we don't want any object duplicates laying
// around, so we delete everything before creating
kill(background) create(background .f=d2 .lb .v .s=bgAnim)
// - the models are created in reverse order in order
// to get correct layering.
kill(model_016) create(model_016 .f=d2 .lb)
kill(case_016) create(case_016 .f=d2 .lb)
kill(model_015) create(model_015 .f=d2 .lb)
kill(case_015) create(case_015 .f=d2 .lb)
kill(model_014) create(model_014 .f=d2 .lb)
kill(case_014) create(case_014 .f=d2 .lb)
kill(model_013) create(model_013 .f=d2 .lb)
kill(case_013) create(case_013 .f=d2 .lb)
kill(shadow_012) create(shadow_012 .f=d2 .lb)
kill(model_012) create(model_012 .f=d2 .lb)
kill(case_012) create(case_012 .f=d2 .lb)
kill(shadow_011) create(shadow_011 .f=d2 .lb)
kill(model_011) create(model_011 .f=d2 .lb)
kill(case_011) create(case_011 .f=d2 .lb)
kill(shadow_010) create(shadow_010 .f=d2 .lb)
kill(model_010) create(model_010 .f=d2 .lb)
kill(case_010) create(case_010 .f=d2 .lb)
kill(shadow_09) create(shadow_09 .f=d2 .lb)
kill(model_09) create(model_09 .f=d2 .lb)
kill(case_09) create(case_09 .f=d2 .lb)
kill(shadow_08) create(shadow_08 .f=d2 .lb)
kill(model_08) create(model_08 .f=d2 .lb)
kill(case_08) create(case_08 .f=d2 .lb)
kill(shadow_07) create(shadow_07 .f=d2 .lb)
kill(model_07) create(model_07 .f=d2 .lb)
kill(case_07) create(case_07 .f=d2 .lb)
kill(shadow_06) create(shadow_06 .f=d2 .lb)
kill(model_06) create(model_06 .f=d2 .lb)
kill(case_06) create(case_06 .f=d2 .lb)
kill(shadow_05) create(shadow_05 .f=d2 .lb)
kill(model_05) create(model_05 .f=d2 .lb)
kill(case_05) create(case_05 .f=d2 .lb)
kill(shadow_04) create(shadow_04 .f=d2 .lb)
kill(model_04) create(model_04 .f=d2 .lb)
kill(case_04) create(case_04 .f=d2 .lb)
kill(shadow_03) create(shadow_03 .f=d2 .lb)
kill(model_03) create(model_03 .f=d2 .lb)
kill(case_03) create(case_03 .f=d2 .lb)
kill(shadow_02) create(shadow_02 .f=d2 .lb)
kill(model_02) create(model_02 .f=d2 .lb)
kill(case_02) create(case_02 .f=d2 .lb)
kill(shadow_01) create(shadow_01 .f=d2 .lb)
kill(model_01) create(model_01 .f=d2 .lb)
kill(case_01) create(case_01 .f=d2 .lb)
kill(tick_001) create(tick_001 .f=d2 .la .v .s=barAnim)
kill(tick_002) create(tick_002 .f=d2 .la .v .s=barAnim)
kill(tick_003) create(tick_003 .f=d2 .la .v .s=barAnim)
kill(tick_004) create(tick_004 .f=d2 .la .v .s=barAnim)
kill(tick_005) create(tick_005 .f=d2 .la .v .s=barAnim)
kill(tick_006) create(tick_006 .f=d2 .la .v .s=barAnim)
kill(tick_007) create(tick_007 .f=d2 .la .v .s=barAnim)
kill(tick_008) create(tick_008 .f=d2 .la .v .s=barAnim)
kill(tick_009) create(tick_009 .f=d2 .la .v .s=barAnim)
kill(tick_0010) create(tick_0010 .f=d2 .la .v .s=barAnim)
kill(tick_0011) create(tick_0011 .f=d2 .la .v .s=barAnim)
kill(tick_0012) create(tick_0012 .f=d2 .la .v .s=barAnim)
kill(tick_0013) create(tick_0013 .f=d2 .la .v .s=barAnim)
kill(tick_0014) create(tick_0014 .f=d2 .la .v .s=barAnim)
kill(tick_0015) create(tick_0015 .f=d2 .la .v .s=barAnim)
kill(tick_0016) create(tick_0016 .f=d2 .la .v .s=barAnim)
kill(tick_unlit_001) create(tick_unlit_001 .f=d2 .la .v .s=barAnim)
kill(tick_unlit_002) create(tick_unlit_002 .f=d2 .la .v .s=barAnim)
kill(tick_unlit_003) create(tick_unlit_003 .f=d2 .la .v .s=barAnim)
kill(tick_unlit_004) create(tick_unlit_004 .f=d2 .la .v .s=barAnim)
kill(tick_unlit_005) create(tick_unlit_005 .f=d2 .la .v .s=barAnim)
kill(tick_unlit_006) create(tick_unlit_006 .f=d2 .la .v .s=barAnim)
kill(tick_unlit_007) create(tick_unlit_007 .f=d2 .la .v .s=barAnim)
kill(tick_unlit_008) create(tick_unlit_008 .f=d2 .la .v .s=barAnim)
kill(tick_unlit_009) create(tick_unlit_009 .f=d2 .la .v .s=barAnim)
kill(tick_unlit_0010) create(tick_unlit_0010 .f=d2 .la .v .s=barAnim)
kill(tick_unlit_0011) create(tick_unlit_0011 .f=d2 .la .v .s=barAnim)
kill(tick_unlit_0012) create(tick_unlit_0012 .f=d2 .la .v .s=barAnim)
kill(tick_unlit_0013) create(tick_unlit_0013 .f=d2 .la .v .s=barAnim)
kill(tick_unlit_0014) create(tick_unlit_0014 .f=d2 .la .v .s=barAnim)
kill(tick_unlit_0015) create(tick_unlit_0015 .f=d2 .la .v .s=barAnim)
kill(tick_unlit_0016) create(tick_unlit_0016 .f=d2 .la .v .s=barAnim)
fc(fcDondAskForFun $0)
br(.n $0 prizeDone)
fc(fcDondAskCoupOrTick $0)
br(.z $0 coupons)
kill(ticket_sign*)
create(ticket_signL .f=d2 .la .v .s=barAnim)
create(ticket_signR .f=d2 .la .v .s=barAnim)
br(prizeDone)
coupons:
kill(coup_sign*)
create(coup_signL .f=d2 .la .v .s=barAnim)
create(coup_signR .f=d2 .la .v .s=barAnim)
prizeDone:
ani(- startWideAnim)
sleep(1)
ani(- stopWideAnim)
)
// ---------------------------------------------
// fakeBankScene
seq fakeBankScene (
alloc(8)
start()
//set(level 3)
//load(banker)
//set(level 2)
mark(bgmrk)
kill(tick_001) create(tick_001 .f=d2 .la .v .s=barAnim)
kill(tick_002) create(tick_002 .f=d2 .la .v .s=barAnim)
kill(tick_003) create(tick_003 .f=d2 .la .v .s=barAnim)
kill(tick_004) create(tick_004 .f=d2 .la .v .s=barAnim)
kill(tick_005) create(tick_005 .f=d2 .la .v .s=barAnim)
kill(tick_006) create(tick_006 .f=d2 .la .v .s=barAnim)
kill(tick_007) create(tick_007 .f=d2 .la .v .s=barAnim)
kill(tick_008) create(tick_008 .f=d2 .la .v .s=barAnim)
kill(tick_009) create(tick_009 .f=d2 .la .v .s=barAnim)
kill(tick_0010) create(tick_0010 .f=d2 .la .v .s=barAnim)
kill(tick_0011) create(tick_0011 .f=d2 .la .v .s=barAnim)
kill(tick_0012) create(tick_0012 .f=d2 .la .v .s=barAnim)
kill(tick_0013) create(tick_0013 .f=d2 .la .v .s=barAnim)
kill(tick_0014) create(tick_0014 .f=d2 .la .v .s=barAnim)
kill(tick_0015) create(tick_0015 .f=d2 .la .v .s=barAnim)
kill(tick_0016) create(tick_0016 .f=d2 .la .v .s=barAnim)
kill(tick_unlit_001) create(tick_unlit_001 .f=d2 .la .v .s=barAnim)
kill(tick_unlit_002) create(tick_unlit_002 .f=d2 .la .v .s=barAnim)
kill(tick_unlit_003) create(tick_unlit_003 .f=d2 .la .v .s=barAnim)
kill(tick_unlit_004) create(tick_unlit_004 .f=d2 .la .v .s=barAnim)
kill(tick_unlit_005) create(tick_unlit_005 .f=d2 .la .v .s=barAnim)
kill(tick_unlit_006) create(tick_unlit_006 .f=d2 .la .v .s=barAnim)
kill(tick_unlit_007) create(tick_unlit_007 .f=d2 .la .v .s=barAnim)
kill(tick_unlit_008) create(tick_unlit_008 .f=d2 .la .v .s=barAnim)
kill(tick_unlit_009) create(tick_unlit_009 .f=d2 .la .v .s=barAnim)
kill(tick_unlit_0010) create(tick_unlit_0010 .f=d2 .la .v .s=barAnim)
kill(tick_unlit_0011) create(tick_unlit_0011 .f=d2 .la .v .s=barAnim)
kill(tick_unlit_0012) create(tick_unlit_0012 .f=d2 .la .v .s=barAnim)
kill(tick_unlit_0013) create(tick_unlit_0013 .f=d2 .la .v .s=barAnim)
kill(tick_unlit_0014) create(tick_unlit_0014 .f=d2 .la .v .s=barAnim)
kill(tick_unlit_0015) create(tick_unlit_0015 .f=d2 .la .v .s=barAnim)
kill(tick_unlit_0016) create(tick_unlit_0016 .f=d2 .la .v .s=barAnim)
fc(fcDondAskForFun $0)
br(.n $0 prizeDone)
fc(fcDondAskCoupOrTick $0)
br(.z $0 coupons)
kill(ticket_sign*)
create(ticket_signL .f=d2 .la .v .s=barAnim)
create(ticket_signR .f=d2 .la .v .s=barAnim)
br(prizeDone)
coupons:
kill(coup_sign*)
create(coup_signL .f=d2 .la .v .s=barAnim)
create(coup_signR .f=d2 .la .v .s=barAnim)
prizeDone:
mark(bgmrk)
create(bank_anim .f=d2 .la)
create(bank2_anim .f=d2 .la)
create(offer_frame .f=d2 .la)
create(banker_offer1 .f=d2 .la .v .s=bgAnim)
create(bg_banker_w1 .f=d2 .la .v .s=sBankerBg)
bin(mv 2 0) send($2 2)
create(bg_banker_w2 .f=d2 .la .v .s=sBankerBg)
bin(mv 2 0) send($2 2)
create(bg_banker_drk .f=d2 .la .v .s=sBankerBg)
bin(mv 2 0) send($2 2) // <- turn off the dark red background
create(background_blue .f=d2 .la .v .s=sBankerBg)
create(bckgrnd_bnk .f=d2 .la)
vidplay(bank_anim)
viddone(bank_anim onBankVidDone)
// - phone rings
sleep(10)
fc(fcDondAskAtrSound $6)
br(.z $6 skipSound1)
sound(14)
skipSound1:
sleep(50)
fc(fcDondSend background_blue 0)
// - fade the cabinet lights from blue to red
fc(fcDondAnimLED 1) // <- fade blue out
fc(fcDondAnimLED 2) // <- fade red in
// - "that's the banker"
sleep(-tap 60)
fc(fcDondAskAtrSound $6)
br(.z $6 skipSound2)
sound(350)
skipSound2:
// - begin strobing the background
send($2 1)
// - "hello"
sleep(-tap 85)
fc(fcDondAskAtrSound $6)
br(.z $6 skipSound3)
sound(351)
skipSound3:
// - "alright" / "i'll tell them"
sleep(-tap 90)
fc(fcDondAskAtrSound $6)
br(.z $6 skipSound4)
sound(356)
skipSound4:
// - "here's the offer"
sleep(-tap 60)
fc(fcDondAskAtrSound $6)
br(.z $6 skipSound5)
sound(352)
skipSound5:
kill(offer_frame)
create(offer_rotate .f=d2 .lb)
vidplay(offer_rotate 1)
viddone(offer_rotate sATBankerRv)
// - offer rotate sound
fc(fcDondAskAtrSound $6)
br(.z $6 skipSound6)
sound(5)
skipSound6:
)
// ---------------------------------------------
// sBankerRv
//
// - the banker reveals his offer to the player
seq sATBankerRv (
alloc(8)
start()
vidstop(offer_rotate)
fc(fcDondUpdateBankerText 1)
fc(fcDondAskForFun $0)
br(.n $0 prizeDone)
fc(fcDondAskCoupOrTick $0)
br(.z $0 coupons)
create(bank_tix .f=d2 .lb)
br(prizeDone)
coupons:
create(bank_coup .f=d2 .lb)
prizeDone:
create(press_accept .f=d2 .lb)
create(prss_accpt_l .f=d2 .lb .v .s=sSelectButton)
create(press_continue .f=d2 .lb)
create(prss_cntn_ .f=d2 .lb .v .s=sSelectButton)
create(deal .f=d2 .lb)
create(nodeal .f=d2 .lb)
// - "deal, or no deal?"
sleep(50)
fc(fcDondAskAtrSound $6)
br(.z $6 skipSound1)
sound(353)
skipSound1:
)

1092
donddata/cf/banker.cf Normal file
View File

File diff suppressed because it is too large Load Diff

8
donddata/cf/diag.cf Normal file
View File

@@ -0,0 +1,8 @@
// CF01 - Copyright (C) 2004, PlayMechanix, Inc.
// -------------------------------------------------------------------
run(perm)
//load(fntsans16)
//load(fntsans20)
fc(fcDiag 0)

10
donddata/cf/dondinit.cf Normal file
View File

@@ -0,0 +1,10 @@
// CF01 - Copyright (C) 2004, PlayMechanix, Inc.
// copy, make writable, and rename this bbh3init.cf
//set(cfg proctest)
//set(cfg Mark)
//set(cfg Will)
//set(cfg Warp)
cat(flags a)
// EOF

20
donddata/cf/fbo_test.cf Normal file
View File

@@ -0,0 +1,20 @@
// CF01 - Copyright (C) 2004, PlayMechanix, Inc.
load(fbo_test)
seq testfbo (
alloc(4)
start()
create(swipe .f=d2 .lb .v) bin(mv 1 0)
obj(ob=$1 of)
vidplay(swipe)
// create(tempobj .f=d2 .lb)
//vidalink(swipe tempobj)
//vidalink(swipe main_logo1)
//vidalink(swipe main_logo2)
//vidalink(swipe doubledeal)
)
ani(- testfbo)

1474
donddata/cf/models.cf Normal file
View File

File diff suppressed because it is too large Load Diff

1222
donddata/cf/pcase.cf Normal file
View File

File diff suppressed because it is too large Load Diff

2321
donddata/cf/perm.cf Normal file
View File

File diff suppressed because it is too large Load Diff

1239
donddata/cf/shuffle.cf Normal file
View File

File diff suppressed because it is too large Load Diff

459
donddata/cf/text3d.cf Normal file
View File

@@ -0,0 +1,459 @@
// CF01 - Copyright (C) 2004, PlayMechanix, Inc.
//--- seq for all selGame bttns
seq f3DSeq (
alloc(10)
signals(15)
signal(0 - idle - )
signal(1 - spin - )
signal(2 - slideLeft - )
signal(3 - slideRight - )
signal(4 - scale - )
signal(5 - slideLeftT - )
signal(6 - slideRightT - )
signal(7 - circle - )
signal(8 - unroll - )
signal(9 - hiscSpin - )
signal(10 - slam - )
signal(11 - scaleSR - )
signal(12 - scaleHH - )
signal(13 - scrollR - )
signal(14 - wave - )
start()
idle:
sleep(0)
//-------- SPIN ----SIGNAL 1 ---
spin:
sleep($1) //set by create routine
fc(fcCounterSet $0 20)
obj(v0)
obj(xt=0.29)
spinLoop:
sloop(1)
fc(fcCounterDecr $0 1)
br(.n $0 spinLoop)
obj(xr=0.0)
obj(st)
br(x)
//-------- SLIDE LEFT ----SIGNAL 2 ---
slideLeft:
fc(fcCounterSet $0 20)
obj(v0)
obj(xq=-60.0)
slideLLoop:
sleep(1)
obj(xq=3.0)
fc(fcCounterDecr $0 1)
br(.n $0 slideLLoop)
obj(st)
//sound(130)
br(x)
//-------- SLIDE RIGHT ----SIGNAL 3 ---
slideRight:
fc(fcCounterSet $0 20)
obj(v0)
obj(xq=60.0)
slideRLoop:
sleep(1)
obj(xq=-3.0)
fc(fcCounterDecr $0 1)
br(.n $0 slideRLoop)
obj(xr=0.0)
obj(st)
//sound(130)
br(x)
//-------- SCALE DOWN ----SIGNAL 4 ---
scale:
obj(of)
sleep(60)
obj(on)
fc(fcCounterSet $0 15)
obj(v0)
fc(fcScale 7.0 0)
scaleLoop:
sleep(1)
fc(fcScale -0.4 1)
fc(fcCounterDecr $0 1)
br(.n $0 scaleLoop)
sound(130)
scaleLoop2:
sloop(1)
fc(fcScaleAxis 0.2 1 0)
sloop(1)
fc(fcScaleAxis 0.15 1 0)
sloop(1)
fc(fcScaleAxis 0.1 1 0)
sloop(1)
fc(fcScaleAxis 0.05 1 0)
sloop(1)
sloop(1)
fc(fcScaleAxis -0.05 1 0)
sloop(1)
fc(fcScaleAxis -0.1 1 0)
sloop(1)
fc(fcScaleAxis -0.15 1 0)
sloop(1)
fc(fcScaleAxis -0.2 1 0)
fc(fcScale 1.0 0)
obj(st)
br(x)
//-------- SLIDE LEFT TILT ----SIGNAL 5 ---
slideLeftT:
fc(fcCounterSet $0 20)
obj(v0)
obj(xq=-60.0)
slideLTLoop:
sleep(1)
obj(xq=3.0)
fc(fcCounterDecr $0 1)
br(.n $0 slideLTLoop)
obj(st)
//obj(v0)
obj(zr=-0.1)
obj(xq=0.5)
sleep(1)
obj(zr=-0.15)
obj(xq=0.5)
sleep(1)
obj(zr=-0.25)
obj(xq=0.5)
sleep(1)
obj(zr=-0.15)
obj(xq=-0.5)
sleep(1)
obj(zr=-0.1)
obj(xq=-0.5)
sleep(1)
obj(zr=0.0)
obj(xq=-0.5)
obj(st)
br(x)
//-------- SLIDE RIGHT TILT ----SIGNAL 6 ---
slideRightT:
fc(fcCounterSet $0 20)
obj(v0)
obj(xq=60.0)
slideRTLoop:
sleep(1)
obj(xq=-3.0)
fc(fcCounterDecr $0 1)
br(.n $0 slideRTLoop)
obj(st)
//obj(v0)
obj(zr=0.1)
obj(xq=-0.5)
sleep(1)
obj(zr=0.15)
obj(xq=-0.5)
sleep(1)
obj(zr=0.25)
obj(xq=-0.5)
sleep(1)
obj(zr=0.15)
obj(xq=0.5)
sleep(1)
obj(zr=0.1)
obj(xq=0.5)
sleep(1)
obj(zr=0.0)
obj(xq=0.5)
obj(st)
br(x)
//-------- CIRCLE ----SIGNAL 7 ---
circle:
fc(fcText3dCircleInit 7)
fc(fcCounterSet $0 500)
obj(v0)
circleLoop:
sleep(1)
fc(fcText3dCircle)
fc(fcCounterDecr $0 1)
br(.n $0 circleLoop)
obj(st)
br(x)
//-------- UNROLL ----SIGNAL 8 ---
unroll:
obj(of)
sleep($1) //set by create routine
obj(on)
fc(fcText3dCircleInit 8)
fc(fcCounterSet $0 500)
obj(v0)
unrollLoop:
sleep(1)
fc(fcText3dCircle)
br(.n $0 unrollLoop)
fc(fcCounterSet $0 10)
fc(fcText3dResolve "var")
unrollRLoop:
sloop(1)
fc(fcText3dResolve "var")
fc(fcCounterDecr $0 1)
br(.n $0 unrollRLoop)
obj(st)
br(x)
//-------- HISC SPIN ----SIGNAL 9 ---
hiscspin:
obj(v0)
obj(xs=2.5 ys=2.5 zs=2.5 yp=-7.0)
obj(yt=-.1)
hiscspinLoop:
sloop(1)
br(hiscspinLoop)
obj(st)
br(x)
//-------- SLAM ----SIGNAL 10 ---
slam:
fc(fcCounterSet $0 10)
obj(v0)
obj(zq=-200.0)
//fc(fcScale 0.1 0)
slamLoop:
sleep(1)
//fc(fcScale 0.05 1)
obj(zq=20.0)
fc(fcCounterDecr $0 1)
br(.n $0 slamLoop)
fc(fcScale 1.0 0)
sound(136)
obj(of)
sleep(4)
obj(on)
sleep(8)
obj(of)
sleep(4)
obj(on)
sleep(8)
obj(of)
sleep(4)
obj(on)
// sleep(8)
// obj(of)
camshake:
//fc(fcCamShake)
// obj(xq=1.5 yq=0.6)
// sleep(3)
// obj(xq=-0.9 yq=-0.9)
// sleep(3)
// obj(xq=0.6 yq=1.2)
// sleep(3)
// obj(xq=-0.9 yq=-0.9)
// sleep(3)
// obj(xq=0.9 yq=1.5)
// sleep(3)
// obj(xq=-0.9 yq=-0.9)
// sleep(3)
// obj(xq=0.6 yq=0.3)
// sleep(3)
// obj(xq=-0.9 yq=-0.9)
obj(st)
br(x)
//-------- SCALE DOWN SHOTREP----SIGNAL 11 ---
scaleSR:
fc(fcCounterSet $0 10)
obj(v0)
fc(fcScale 7.0 0)
scaleLoopSR:
sleep(1)
fc(fcScale -0.5 1)
fc(fcCounterDecr $0 1)
br(.n $0 scaleLoopSR)
// sound(130)
scaleLoopSR2:
sloop(1)
fc(fcScaleAxis 0.2 1 0)
sloop(1)
fc(fcScaleAxis 0.15 1 0)
sloop(1)
fc(fcScaleAxis 0.1 1 0)
sloop(1)
fc(fcScaleAxis 0.05 1 0)
sloop(1)
sloop(1)
fc(fcScaleAxis -0.05 1 0)
sloop(1)
fc(fcScaleAxis -0.1 1 0)
sloop(1)
fc(fcScaleAxis -0.15 1 0)
sloop(1)
fc(fcScaleAxis -0.2 1 0)
fc(fcScale 1.0 0)
obj(st)
br(x)
//-------- SCALEDOWN HHERO----SIGNAL 12 ---
scaleHH:
fc(fcCounterSet $0 7)
obj(v0)
fc(fcScale 8.0 0)
scaleLoopHH:
sleep(1)
fc(fcScale -1.0 1)
fc(fcCounterDecr $0 1)
br(.n $0 scaleLoopHH)
fc(fcReportScatterHH)
scaleLoopHH2:
sloop(1)
fc(fcScaleAxis 0.2 1 0)
sloop(1)
fc(fcScaleAxis 0.15 1 0)
sloop(1)
fc(fcScaleAxis 0.1 1 0)
sloop(1)
fc(fcScaleAxis 0.05 1 0)
sloop(1)
sloop(1)
fc(fcScaleAxis -0.05 1 0)
sloop(1)
fc(fcScaleAxis -0.1 1 0)
sloop(1)
fc(fcScaleAxis -0.15 1 0)
sloop(1)
fc(fcScaleAxis -0.2 1 0)
fc(fcScale 1.0 0)
obj(st)
br(x)
//-------- SCROLL RIGHT ----SIGNAL 13 ---
scrollR:
fc(fcCounterSet $0 200)
obj(v0)
obj(xq=25.0)
scrollRLoop:
sleep(1)
obj(xq=-0.30)
fc(fcCounterDecr $0 1)
br(.n $0 scrollRLoop)
obj(st)
//sound(130)
br(x)
//-------- WAVE ----SIGNAL 14 ---
wave:
sloop(1)
sleep(15)
sleep($1) //set by create routine
fc(fcCounterSet $0 10)
obj(v0)
waveUpLoop:
sloop(1)
fc(fcScale 0.1 1)
obj(zq=-0.1)
fc(fcCounterDecr $0 1)
br(.n $0 waveUpLoop)
obj(xr=0.0)
fc(fcCounterSet $0 10)
obj(v0)
waveDnLoop:
sloop(1)
fc(fcScale -0.1 1)
obj(zq=0.1)
fc(fcCounterDecr $0 1)
br(.n $0 waveDnLoop)
fc(fcScale 1.0 0)
obj(st)
br(x)
x:
)
seq dblPerf(
start()
// disp(vsync=0)
fc(fc3DText "dbl perf")
)
// EOF

BIN
donddata/cf/vssver.scc Normal file
View File

Binary file not shown.

616
donddata/cf/wreveal.cf Normal file
View File

@@ -0,0 +1,616 @@
// CF01 - Copyright (C) 2004, PlayMechanix, Inc.
// ---------------------------------------------
seq createWRScene (
start()
ani(- sClear)
mark(bgmrk)
kill(background) create(background .f=d2 .lb .v .s=bgAnim)
kill(main_*)
kill(press_*)
kill(doubledeal)
create(revcase_016 .f=d2 .lb) create(Reveal_016 .f=d2 .lb)
create(revcase_015 .f=d2 .lb) create(Reveal_015 .f=d2 .lb)
create(revcase_014 .f=d2 .lb) create(Reveal_014 .f=d2 .lb)
create(revcase_013 .f=d2 .lb) create(Reveal_013 .f=d2 .lb)
create(revshadow_012 .f=d2 .lb) create(revcase_012 .f=d2 .lb) create(Reveal_012 .f=d2 .lb)
create(revshadow_011 .f=d2 .lb) create(revcase_011 .f=d2 .lb) create(Reveal_011 .f=d2 .lb)
create(revshadow_010 .f=d2 .lb) create(revcase_010 .f=d2 .lb) create(Reveal_010 .f=d2 .lb)
create(revshadow_09 .f=d2 .lb) create(revcase_09 .f=d2 .lb) create(Reveal_09 .f=d2 .lb)
create(revshadow_08 .f=d2 .lb) create(revcase_08 .f=d2 .lb) create(Reveal_08 .f=d2 .lb)
create(revshadow_07 .f=d2 .lb) create(revcase_07 .f=d2 .lb) create(Reveal_07 .f=d2 .lb)
create(revshadow_06 .f=d2 .lb) create(revcase_06 .f=d2 .lb) create(Reveal_06 .f=d2 .lb)
create(revshadow_05 .f=d2 .lb) create(revcase_05 .f=d2 .lb) create(Reveal_05 .f=d2 .lb)
create(revshadow_04 .f=d2 .lb) create(revcase_04 .f=d2 .lb) create(Reveal_04 .f=d2 .lb)
create(revshadow_03 .f=d2 .lb) create(revcase_03 .f=d2 .lb) create(Reveal_03 .f=d2 .lb)
create(revshadow_02 .f=d2 .lb) create(revcase_02 .f=d2 .lb) create(Reveal_02 .f=d2 .lb)
create(revshadow_01 .f=d2 .lb) create(revcase_01 .f=d2 .lb) create(Reveal_01 .f=d2 .lb)
// - "play" all of the videos in order to load them into memory
vidplay(Reveal_016)
vidplay(Reveal_015)
vidplay(Reveal_014)
vidplay(Reveal_013)
vidplay(Reveal_012)
vidplay(Reveal_011)
vidplay(Reveal_010)
vidplay(Reveal_09)
vidplay(Reveal_08)
vidplay(Reveal_07)
vidplay(Reveal_06)
vidplay(Reveal_05)
vidplay(Reveal_04)
vidplay(Reveal_03)
vidplay(Reveal_02)
vidplay(Reveal_01)
sleep(1)
playAgain:
vidstop(Reveal_016) vidreset(Reveal_016)
vidstop(Reveal_015) vidreset(Reveal_015)
vidstop(Reveal_014) vidreset(Reveal_014)
vidstop(Reveal_013) vidreset(Reveal_013)
vidstop(Reveal_012) vidreset(Reveal_012)
vidstop(Reveal_011) vidreset(Reveal_011)
vidstop(Reveal_010) vidreset(Reveal_010)
vidstop(Reveal_09) vidreset(Reveal_09)
vidstop(Reveal_08) vidreset(Reveal_08)
vidstop(Reveal_07) vidreset(Reveal_07)
vidstop(Reveal_06) vidreset(Reveal_06)
vidstop(Reveal_05) vidreset(Reveal_05)
vidstop(Reveal_04) vidreset(Reveal_04)
vidstop(Reveal_03) vidreset(Reveal_03)
vidstop(Reveal_02) vidreset(Reveal_02)
vidstop(Reveal_01) vidreset(Reveal_01)
sleep(1)
// vidplay(Reveal_016) vidstop(Reveal_016) vidreset(Reveal_016)
// vidplay(Reveal_015) vidstop(Reveal_015) vidreset(Reveal_015)
// vidplay(Reveal_014) vidstop(Reveal_014) vidreset(Reveal_014)
// vidplay(Reveal_013) vidstop(Reveal_013) vidreset(Reveal_013)
// vidplay(Reveal_012) vidstop(Reveal_012) vidreset(Reveal_012)
// vidplay(Reveal_011) vidstop(Reveal_011) vidreset(Reveal_011)
// vidplay(Reveal_010) vidstop(Reveal_010) vidreset(Reveal_010)
// vidplay(Reveal_09) vidstop(Reveal_09) vidreset(Reveal_09)
// vidplay(Reveal_08) vidstop(Reveal_08) vidreset(Reveal_08)
// vidplay(Reveal_07) vidstop(Reveal_07) vidreset(Reveal_07)
// vidplay(Reveal_06) vidstop(Reveal_06) vidreset(Reveal_06)
// vidplay(Reveal_05) vidstop(Reveal_05) vidreset(Reveal_05)
// vidplay(Reveal_04) vidstop(Reveal_04) vidreset(Reveal_04)
// vidplay(Reveal_03) vidstop(Reveal_03) vidreset(Reveal_03)
// vidplay(Reveal_02) vidstop(Reveal_02) vidreset(Reveal_02)
// vidplay(Reveal_01) vidstop(Reveal_01) vidreset(Reveal_01)
sleep(50)
// ...
vidplay(Reveal_09) viddone(Reveal_09 wrDone_09) // 35
vidplay(Reveal_013) viddone(Reveal_013 wrDone_13) // 21
// ...
sleep(35)
vidplay(Reveal_014) viddone(Reveal_014 wrDone_14) // 44
vidplay(Reveal_010) viddone(Reveal_010 wrDone_10) // 33
// ...
sleep(44)
vidplay(Reveal_015) viddone(Reveal_015 wrDone_15) // 42
vidplay(Reveal_05) viddone(Reveal_05 wrDone_05) // 15
// ...
sleep(42)
vidplay(Reveal_011) viddone(Reveal_011 wrDone_11) // 25
vidplay(Reveal_06) viddone(Reveal_06 wrDone_06) // 24
// ...
sleep(25)
vidplay(Reveal_016) viddone(Reveal_016 wrDone_16) // 28
vidplay(Reveal_01) viddone(Reveal_01 wrDone_01) // 32
// ...
sleep(32)
vidplay(Reveal_012) viddone(Reveal_012 wrDone_12) // 46
// ...
sleep(46)
vidplay(Reveal_07) viddone(Reveal_07 wrDone_07) // 18
vidplay(Reveal_02) viddone(Reveal_02 wrDone_02) // 34
// ...
sleep(34)
vidplay(Reveal_08) viddone(Reveal_08 wrDone_08) // 21
vidplay(Reveal_03) viddone(Reveal_03 wrDone_03) // 31
// ...
sleep(31)
vidplay(Reveal_04) viddone(Reveal_04 wrDone_04) // 24
sleep(100)
br(playAgain)
)
// ---------------------------------------------
seq wrDone_01 ( start() vidstop(Reveal_01) )
seq wrDone_02 ( start() vidstop(Reveal_02) )
seq wrDone_03 ( start() vidstop(Reveal_03) )
seq wrDone_04 ( start() vidstop(Reveal_04) )
seq wrDone_05 ( start() vidstop(Reveal_05) )
seq wrDone_06 ( start() vidstop(Reveal_06) )
seq wrDone_07 ( start() vidstop(Reveal_07) )
seq wrDone_08 ( start() vidstop(Reveal_08) )
seq wrDone_09 ( start() vidstop(Reveal_09) )
seq wrDone_10 ( start() vidstop(Reveal_010) )
seq wrDone_11 ( start() vidstop(Reveal_011) )
seq wrDone_12 ( start() vidstop(Reveal_012) )
seq wrDone_13 ( start() vidstop(Reveal_013) )
seq wrDone_14 ( start() vidstop(Reveal_014) )
seq wrDone_15 ( start() vidstop(Reveal_015) )
seq wrDone_16 ( start() vidstop(Reveal_016) )
// ---------------------------------------------
seq createWRS (
alloc(4)
start()
mark(bgmrk)
kill(model_*)
kill(case_*)
kill(shadow_*)
kill(background)
kill(black_bg)
create(background .f=d2 .lb .v .s=bgAnim)
fc(fcDondAskWRGirl $0 16 0) br(.z $0 skip16)
create(revcase_016 .f=d2 .lb) create(Reveal_016 .f=d2 .lb)
skip16:
fc(fcDondAskWRGirl $0 15 0) br(.z $0 skip15)
create(revcase_015 .f=d2 .lb) create(Reveal_015 .f=d2 .lb)
skip15:
fc(fcDondAskWRGirl $0 14 0) br(.z $0 skip14)
create(revcase_014 .f=d2 .lb) create(Reveal_014 .f=d2 .lb)
skip14:
fc(fcDondAskWRGirl $0 13 0) br(.z $0 skip13)
create(revcase_013 .f=d2 .lb) create(Reveal_013 .f=d2 .lb)
skip13:
fc(fcDondAskWRGirl $0 12 0) br(.z $0 skip12)
create(revshadow_012 .f=d2 .lb) create(revcase_012 .f=d2 .lb) create(Reveal_012 .f=d2 .lb)
skip12:
fc(fcDondAskWRGirl $0 11 0) br(.z $0 skip11)
create(revshadow_011 .f=d2 .lb) create(revcase_011 .f=d2 .lb) create(Reveal_011 .f=d2 .lb)
skip11:
fc(fcDondAskWRGirl $0 10 0) br(.z $0 skip10)
create(revshadow_010 .f=d2 .lb) create(revcase_010 .f=d2 .lb) create(Reveal_010 .f=d2 .lb)
skip10:
fc(fcDondAskWRGirl $0 9 0) br(.z $0 skip9)
create(revshadow_09 .f=d2 .lb) create(revcase_09 .f=d2 .lb) create(Reveal_09 .f=d2 .lb)
skip9:
fc(fcDondAskWRGirl $0 8 0) br(.z $0 skip8)
create(revshadow_08 .f=d2 .lb) create(revcase_08 .f=d2 .lb) create(Reveal_08 .f=d2 .lb)
skip8:
fc(fcDondAskWRGirl $0 7 0) br(.z $0 skip7)
create(revshadow_07 .f=d2 .lb) create(revcase_07 .f=d2 .lb) create(Reveal_07 .f=d2 .lb)
skip7:
fc(fcDondAskWRGirl $0 6 0) br(.z $0 skip6)
create(revshadow_06 .f=d2 .lb) create(revcase_06 .f=d2 .lb) create(Reveal_06 .f=d2 .lb)
skip6:
fc(fcDondAskWRGirl $0 5 0) br(.z $0 skip5)
create(revshadow_05 .f=d2 .lb) create(revcase_05 .f=d2 .lb) create(Reveal_05 .f=d2 .lb)
skip5:
fc(fcDondAskWRGirl $0 4 0) br(.z $0 skip4)
create(revshadow_04 .f=d2 .lb) create(revcase_04 .f=d2 .lb) create(Reveal_04 .f=d2 .lb)
skip4:
fc(fcDondAskWRGirl $0 3 0) br(.z $0 skip3)
create(revshadow_03 .f=d2 .lb) create(revcase_03 .f=d2 .lb) create(Reveal_03 .f=d2 .lb)
skip3:
fc(fcDondAskWRGirl $0 2 0) br(.z $0 skip2)
create(revshadow_02 .f=d2 .lb) create(revcase_02 .f=d2 .lb) create(Reveal_02 .f=d2 .lb)
skip2:
fc(fcDondAskWRGirl $0 1 0) br(.z $0 skip1)
create(revshadow_01 .f=d2 .lb) create(revcase_01 .f=d2 .lb) create(Reveal_01 .f=d2 .lb)
skip1:
create(black_bg .f=d2 .lb .v .s=sBlackBg)
bin(mv 2 0) send($2 0)
// - "play" all of the videos in order to load them into memory
vidplay(Reveal_016)
vidplay(Reveal_015)
vidplay(Reveal_014)
vidplay(Reveal_013)
vidplay(Reveal_012)
vidplay(Reveal_011)
vidplay(Reveal_010)
vidplay(Reveal_09)
vidplay(Reveal_08)
vidplay(Reveal_07)
vidplay(Reveal_06)
vidplay(Reveal_05)
vidplay(Reveal_04)
vidplay(Reveal_03)
vidplay(Reveal_02)
vidplay(Reveal_01)
sleep(1)
vidstop(Reveal_016) vidreset(Reveal_016)
vidstop(Reveal_015) vidreset(Reveal_015)
vidstop(Reveal_014) vidreset(Reveal_014)
vidstop(Reveal_013) vidreset(Reveal_013)
vidstop(Reveal_012) vidreset(Reveal_012)
vidstop(Reveal_011) vidreset(Reveal_011)
vidstop(Reveal_010) vidreset(Reveal_010)
vidstop(Reveal_09) vidreset(Reveal_09)
vidstop(Reveal_08) vidreset(Reveal_08)
vidstop(Reveal_07) vidreset(Reveal_07)
vidstop(Reveal_06) vidreset(Reveal_06)
vidstop(Reveal_05) vidreset(Reveal_05)
vidstop(Reveal_04) vidreset(Reveal_04)
vidstop(Reveal_03) vidreset(Reveal_03)
vidstop(Reveal_02) vidreset(Reveal_02)
vidstop(Reveal_01) vidreset(Reveal_01)
)
// ---------------------------------------------
seq sWRS (
alloc(4)
start()
create(textbar .f=d2 .lb)
create(final_reveal .f=d2 .lb)
// - "ladies, open the cases"
sound(370)
sound(200)
sleep(100)
fc(fcDondAskWRGirl $0 9 13)
br(.z $0 skip1)
// ...
vidplay(Reveal_09 0) viddone(Reveal_09 wrDone_09) // 35
vidplay(Reveal_013 0) viddone(Reveal_013 wrDone_13) // 21
sleep(35)
skip1:
fc(fcDondAskWRGirl $0 14 10)
br(.z $0 skip2)
// ...
vidplay(Reveal_014 0) viddone(Reveal_014 wrDone_14) // 44
vidplay(Reveal_010 0) viddone(Reveal_010 wrDone_10) // 33
sleep(44)
skip2:
fc(fcDondAskWRGirl $0 15 5)
br(.z $0 skip3)
// ...
vidplay(Reveal_015 0) viddone(Reveal_015 wrDone_15) // 42
vidplay(Reveal_05 0) viddone(Reveal_05 wrDone_05) // 15
sleep(42)
skip3:
fc(fcDondAskWRGirl $0 11 6)
br(.z $0 skip4)
// ...
vidplay(Reveal_011 0) viddone(Reveal_011 wrDone_11) // 25
vidplay(Reveal_06 0) viddone(Reveal_06 wrDone_06) // 24
sleep(25)
skip4:
fc(fcDondAskWRGirl $0 16 1)
br(.z $0 skip5)
// ...
vidplay(Reveal_016 0) viddone(Reveal_016 wrDone_16) // 28
vidplay(Reveal_01 0) viddone(Reveal_01 wrDone_01) // 32
sleep(32)
skip5:
fc(fcDondAskWRGirl $0 12 0)
br(.z $0 skip6)
// ...
vidplay(Reveal_012 0) viddone(Reveal_012 wrDone_12) // 46
sleep(46)
skip6:
fc(fcDondAskWRGirl $0 7 2)
br(.z $0 skip7)
// ...
vidplay(Reveal_07 0) viddone(Reveal_07 wrDone_07) // 18
vidplay(Reveal_02 0) viddone(Reveal_02 wrDone_02) // 34
sleep(34)
skip7:
fc(fcDondAskWRGirl $0 8 3)
br(.z $0 skip8)
// ...
vidplay(Reveal_08 0) viddone(Reveal_08 wrDone_08) // 21
vidplay(Reveal_03 0) viddone(Reveal_03 wrDone_03) // 31
sleep(31)
skip8:
fc(fcDondAskWRGirl $0 4 0)
br(.z $0 skip9)
// ...
vidplay(Reveal_04 0) viddone(Reveal_04 wrDone_04) // 24
skip9:
sleep(160)
fc(fcDondUnloadVideos)
// - place the game in DOND_GAMEOVER_REVEAL mode
fc(fcDondSetGameState 10)
fc(fcDondFadeOut textbar)
fc(fcDondFadeOut final_reveal)
ani(- postWRreveal)
)
// ---------------------------------------------
seq postWRreveal (
alloc(4)
start()
mark(bgmrk)
fc(fcDondPlayGradedReveal)
fc(fcDondAskGradedReveal $0) // $0 = number of frames to wait
ani(- sPCaseTitle)
fc(fcDondPlayPCaseRV)
mark(bgmrk)
// - polite applause sound
sound(200)
sleep(20)
// - play the case buildup sound
sound(372)
sound(11)
revealLoop:
sleep(1)
fc(fcDondAskVideoFrame * $1 $0) // $1 = video frame of object named "*"
br(.z $1 revealLoop)
fc(fcDondPlayGradedAudio)
// - start at 100% shrink and loop downwards to
// 0% shrink. this causes the displayed value
// to zoom out of the case
bin(si 0 100) // <- $0 = 100
scaleLoop:
sleep(1)
fc(fcDondDrawCaseValue $0 52.0 18.0) // <- shrinkRate, xpos, ypos
bin(ai 0 -10) // <- $0 = $0 - 10;
br(.n $0 scaleLoop) // <- if ($0 != 0) goto scaleLoop
// - create the "ticket" label
fc(fcDondAskForFun $0)
br(.n $0 noPrizeLabel)
fc(fcDondAskCoupOrTick $0)
br(.z $0 coupons)
create(c_ticket .f=d2 .lb .v .s=sPrompt) bin(mv 2 0)
br(prizeDone)
coupons:
create(c_coupon .f=d2 .lb .v .s=sPrompt) bin(mv 2 0)
prizeDone:
obj(ob=$2 xq=52.0)
obj(ob=$2 yq=17.0)
noPrizeLabel:
sleep(10)
fc(fcDondPlayGradedCrowdAudio)
fc(fcDondRedrawValues)
sleep(180)
fc(fcDondFadeOut personl_title)
sound(201)
ani(- sCollect)
kill(background)
kill(Reveal_*)
kill(revcase_*)
kill(revshadow_*)
fc(fcDondFadeOut bg_tight)
fc(fcDondFadeKillReveal)
//fc(fcDondFadeOut ticket_signL)
//fc(fcDondFadeOut ticket_signR)
kill(tick*)
kill(coup*)
//ani(- slideBarsOut)
// - get rid of the tickets label
kill($2)
fc(fcDondDoGameOver 1)
)
// ---------------------------------------------
// preloadWRS
seq preloadWRS (
alloc(4)
start()
create(Reveal_016 .f=d2 .lb .v) bin(mv 1 0) obj(ob=$1 of)
create(Reveal_015 .f=d2 .lb .v) bin(mv 1 0) obj(ob=$1 of)
create(Reveal_014 .f=d2 .lb .v) bin(mv 1 0) obj(ob=$1 of)
create(Reveal_013 .f=d2 .lb .v) bin(mv 1 0) obj(ob=$1 of)
create(Reveal_012 .f=d2 .lb .v) bin(mv 1 0) obj(ob=$1 of)
create(Reveal_011 .f=d2 .lb .v) bin(mv 1 0) obj(ob=$1 of)
create(Reveal_010 .f=d2 .lb .v) bin(mv 1 0) obj(ob=$1 of)
create(Reveal_09 .f=d2 .lb .v) bin(mv 1 0) obj(ob=$1 of)
create(Reveal_08 .f=d2 .lb .v) bin(mv 1 0) obj(ob=$1 of)
create(Reveal_07 .f=d2 .lb .v) bin(mv 1 0) obj(ob=$1 of)
create(Reveal_06 .f=d2 .lb .v) bin(mv 1 0) obj(ob=$1 of)
create(Reveal_05 .f=d2 .lb .v) bin(mv 1 0) obj(ob=$1 of)
create(Reveal_04 .f=d2 .lb .v) bin(mv 1 0) obj(ob=$1 of)
create(Reveal_03 .f=d2 .lb .v) bin(mv 1 0) obj(ob=$1 of)
create(Reveal_02 .f=d2 .lb .v) bin(mv 1 0) obj(ob=$1 of)
create(Reveal_01 .f=d2 .lb .v) bin(mv 1 0) obj(ob=$1 of)
// - "play" all of the videos in order to load them into memory
vidplay(Reveal_016)
vidplay(Reveal_015)
vidplay(Reveal_014)
vidplay(Reveal_013)
vidplay(Reveal_012)
vidplay(Reveal_011)
vidplay(Reveal_010)
vidplay(Reveal_09)
vidplay(Reveal_08)
vidplay(Reveal_07)
vidplay(Reveal_06)
vidplay(Reveal_05)
vidplay(Reveal_04)
vidplay(Reveal_03)
vidplay(Reveal_02)
vidplay(Reveal_01)
sleep(1)
vidstop(Reveal_016) vidreset(Reveal_016)
vidstop(Reveal_015) vidreset(Reveal_015)
vidstop(Reveal_014) vidreset(Reveal_014)
vidstop(Reveal_013) vidreset(Reveal_013)
vidstop(Reveal_012) vidreset(Reveal_012)
vidstop(Reveal_011) vidreset(Reveal_011)
vidstop(Reveal_010) vidreset(Reveal_010)
vidstop(Reveal_09) vidreset(Reveal_09)
vidstop(Reveal_08) vidreset(Reveal_08)
vidstop(Reveal_07) vidreset(Reveal_07)
vidstop(Reveal_06) vidreset(Reveal_06)
vidstop(Reveal_05) vidreset(Reveal_05)
vidstop(Reveal_04) vidreset(Reveal_04)
vidstop(Reveal_03) vidreset(Reveal_03)
vidstop(Reveal_02) vidreset(Reveal_02)
vidstop(Reveal_01) vidreset(Reveal_01)
sleep(1)
kill(Reveal_*)
sleep(1)
)
// ---------------------------------------------
seq sWRSnodeal (
alloc(4)
start()
kill(offer_rotate)
kill(offer_frame)
create(textbar .f=d2 .lb)
create(final_reveal .f=d2 .lb)
// - polite applause
sound(200)
//sleep(100)
sleep(50)
// - play the remaining girl's wide reveal
fc(fcDondPlayNDWR)
sleep(240)
fc(fcDondUnloadVideos)
// - place the game in DOND_GAMEOVER_REVEAL mode
fc(fcDondSetGameState 10)
fc(fcDondFadeOut textbar)
fc(fcDondFadeOut final_reveal)
// ...
sound(201)
ani(- sCollect)
kill(background)
kill(Reveal_*)
kill(revcase_*)
kill(tick*)
kill(coup*)
fc(fcDondDoGameOver 1)
)

3
donddata/hd_pc/attract.g3 Normal file
View File

@@ -0,0 +1,3 @@
version https://git-lfs.github.com/spec/v1
oid sha256:a17600b6f2a671d3949890c0d9b680747a39dc22e0d6ecbc81579d249379b3d5
size 11055634

3
donddata/hd_pc/banker.g3 Normal file
View File

@@ -0,0 +1,3 @@
version https://git-lfs.github.com/spec/v1
oid sha256:4787d06c63d3d246ea4b128547820bd452163c92dbaf0e4239e66ff0d87b137d
size 19314745

3
donddata/hd_pc/collect.g3 Normal file
View File

@@ -0,0 +1,3 @@
version https://git-lfs.github.com/spec/v1
oid sha256:28a48d68f75a8ba6dcd8be991ae6c9c229abf0a9482964be6cf73d6bcee9bf6b
size 3664048

3
donddata/hd_pc/diag.g3 Normal file
View File

@@ -0,0 +1,3 @@
version https://git-lfs.github.com/spec/v1
oid sha256:c324b580cf41e6ac0a13e626bbc34c6dd1d1aea6b52f1becbf0b24e93999dafd
size 4196180

3
donddata/hd_pc/dondTitle.g3 Normal file
View File

@@ -0,0 +1,3 @@
version https://git-lfs.github.com/spec/v1
oid sha256:f67c776dd1a01cf3d179588e68f8d0f4fa6801aac4a1fafed89c0f0adccebe33
size 3801684

3
donddata/hd_pc/fnt_cont.g3 Normal file
View File

@@ -0,0 +1,3 @@
version https://git-lfs.github.com/spec/v1
oid sha256:48e628601bedaf4aa9d155c3158d58dece159ad676bfee66d9c317a5062e4e6e
size 4197940

3
donddata/hd_pc/fnt_cred.g3 Normal file
View File

@@ -0,0 +1,3 @@
version https://git-lfs.github.com/spec/v1
oid sha256:3b9177c6f4149b69438fe1dc4c50f1288e0fc01dc0dd4f4b18c2739aed83e603
size 66292

3
donddata/hd_pc/fnt_incase.g3 Normal file
View File

@@ -0,0 +1,3 @@
version https://git-lfs.github.com/spec/v1
oid sha256:2a9f83d102be59e4656524f65581922752d38e5a35d78b8574505019f809e7b2
size 262936

3
donddata/hd_pc/fnt_tb_big.g3 Normal file
View File

@@ -0,0 +1,3 @@
version https://git-lfs.github.com/spec/v1
oid sha256:2de267f6cc290a098eb12cb8ffae6c4c405431c6422c52f64209f3728b1baf6a
size 1050232

3
donddata/hd_pc/fnt_tb_small.g3 Normal file
View File

@@ -0,0 +1,3 @@
version https://git-lfs.github.com/spec/v1
oid sha256:54c52d35ad8802c463607abb98ff4e14b7dd25574f469c2a78453ef0beb639cd
size 263800

3
donddata/hd_pc/fnt_tbar_big.g3 Normal file
View File

@@ -0,0 +1,3 @@
version https://git-lfs.github.com/spec/v1
oid sha256:4dce26cd82969f8e133ed4c6c1a1dcfaf21c334809baaad28e84f5843a42f83e
size 262936

3
donddata/hd_pc/fnt_timer.g3 Normal file
View File

@@ -0,0 +1,3 @@
version https://git-lfs.github.com/spec/v1
oid sha256:e286f4d2dd3bff5bccca067cada2cb6888afbb2e06201a11d0b0c2d40bfca2b4
size 262900

3
donddata/hd_pc/fnt_vbar_lit.g3 Normal file
View File

@@ -0,0 +1,3 @@
version https://git-lfs.github.com/spec/v1
oid sha256:beb4b4683f80f266449ae6afb88db446d1892f84aa7d38c747e21750619e9bff
size 262936

3
donddata/hd_pc/fntarb24.g3 Normal file
View File

@@ -0,0 +1,3 @@
version https://git-lfs.github.com/spec/v1
oid sha256:ba9267be305eacc2f94eb34ea0ef43bd6ee7611cae4d6bbf52f6639704eb8084
size 265780

3
donddata/hd_pc/fntarb36.g3 Normal file
View File

@@ -0,0 +1,3 @@
version https://git-lfs.github.com/spec/v1
oid sha256:1feb12eb6db51b24696a2769a8632e8e4f0b54257f8149fdd5cc264e12a49604
size 1052248

3
donddata/hd_pc/fntarb48.g3 Normal file
View File

@@ -0,0 +1,3 @@
version https://git-lfs.github.com/spec/v1
oid sha256:e44632c05a472b0abb9f03b62a353d21b8fd6fe97cb1e498f448500c6695c726
size 1052212

3
donddata/hd_pc/fntarb72.g3 Normal file
View File

@@ -0,0 +1,3 @@
version https://git-lfs.github.com/spec/v1
oid sha256:8cc6961c08064a0eda40a31ba67d822b76c3ccf3876ac61c2f54acb3a560b808
size 4197940

3
donddata/hd_pc/fntprofr.g3 Normal file
View File

@@ -0,0 +1,3 @@
version https://git-lfs.github.com/spec/v1
oid sha256:34143024c62bf419c04235576d2e27b1bbc1bdf478810589333927eb2a402102
size 66328

3
donddata/hd_pc/fntsans16.g3 Normal file
View File

@@ -0,0 +1,3 @@
version https://git-lfs.github.com/spec/v1
oid sha256:0b01967b34124f281f9a2deb034e8be3517c3fe5a9209db352c8537ab83b2615
size 265888

3
donddata/hd_pc/fntsans20.g3 Normal file
View File

@@ -0,0 +1,3 @@
version https://git-lfs.github.com/spec/v1
oid sha256:37ec3d5f13151a762acf5ef3c440335880a4370d47addffbe764d059db0b2ae6
size 265744

3
donddata/hd_pc/fntsans24.g3 Normal file
View File

@@ -0,0 +1,3 @@
version https://git-lfs.github.com/spec/v1
oid sha256:6e6adcf1997ab9ea5ff3dfd9a941fe2e83486cd71688555893d0084a156913c7
size 265780

3
donddata/hd_pc/fntsans36.g3 Normal file
View File

@@ -0,0 +1,3 @@
version https://git-lfs.github.com/spec/v1
oid sha256:c84e3a0774c178db1dc3913c3e5edb80a4e033d3ae8fe2b73e1696f925357092
size 1052212

3
donddata/hd_pc/frame_skips_01.g3 Normal file
View File

@@ -0,0 +1,3 @@
version https://git-lfs.github.com/spec/v1
oid sha256:3dc85028f5081497c80bf583ef521675b395513e1a0fc2f1272fb19ea3ec598e
size 5245084

Some files were not shown because too many files have changed in this diff Show More