home
***
CD-ROM
|
disk
|
FTP
|
other
***
search
/
Amiga ACS 1998 #6
/
amigaacscoverdisc1998-061998.iso
/
games
/
shareware
/
crystalppc
/
amiga.cpp
next >
Wrap
C/C++ Source or Header
|
1998-06-08
|
16KB
|
596 lines
#ifdef DO_AMIGAOS
#include <rtgmaster/rtgmaster.h>
#include <rtgmaster/rtgsublibs.h>
#include <clib/rtgmaster_protos.h>
#include <powerpc/memoryPPC.h>
#include <clib/powerpc_protos.h>
#include <graphics/gfx.h>
#include <graphics/rastport.h>
#include <intuition/intuition.h>
#include <exec/types.h>
// Next three structures are internal rtgmaster structures used
// by a hack, that is needed as rtgmaster currently only supports
// LoadRGB32-style color loading, not SetRGB32-style color loading
// Will add this to the next rtgmaster-version. Currently this
// program does not run on EGS.
#define byte UBYTE
struct MyPort
{
struct MsgPort *port;
ULONG signal;
WORD *MouseX;
WORD *MouseY;
};
int Workbench=0;
struct RtgScreenAMI
{
struct RtgScreen Header;
UWORD Locks;
struct Screen *ScreenHandle;
ULONG PlaneSize;
ULONG DispBuf;
ULONG ChipMem1;
ULONG ChipMem2;
ULONG ChipMem3;
struct BitMap Bitmap1;
struct BitMap Bitmap2;
struct BitMap Bitmap3;
ULONG Flags;
struct Rectangle MyRect;
BYTE Place[52];
struct RastPort RastPort1;
struct RastPort RastPort2;
struct RastPort RastPort3;
struct Window *MyWindow;
APTR Pointer;
struct MyPort PortData;
struct DBufInfo *dbufinfo;
ULONG DispBuf1;
ULONG DispBuf2;
ULONG DispBuf3;
ULONG SafeToWrite;
ULONG SafeToDisp;
ULONG SrcMode;
APTR tempras;
APTR tempbm;
APTR wbcolors;
ULONG Width;
ULONG Height;
ULONG colchanged;
};
struct RtgScreenCGX
{
struct RtgScreen Header;
struct Screen *MyScreen;
ULONG ActiveMap;
APTR MapA;
APTR MapB;
APTR MapC;
APTR FrontMap;
ULONG Bytes;
ULONG Width;
UWORD Height;
ULONG NumBuf;
UWORD Locks;
ULONG ModeID;
struct BitMap *RealMapA;
ULONG Tags[5];
ULONG OffA;
ULONG OffB;
ULONG OffC;
struct Window *MyWindow;
struct MyPort PortData;
ULONG BPR;
struct DBufInfo *dbi;
ULONG SafeToWrite;
ULONG SafeToDisp;
ULONG Special;
ULONG SrcMode;
APTR tempras;
APTR tempbm;
APTR wbcolors;
ULONG colchanged;
ULONG ccol;
};
#include "system.h"
extern "C" {
#include <exec/types.h>
#include <exec/memory.h>
#include <exec/execbase.h>
#include <intuition/intuition.h>
#include <devices/inputevent.h>
#include <clib/exec_protos.h>
#include "cryst_rev.h"
extern void ConvertFrame(byte *,byte *,unsigned long);
}
#include <clib/rtgmaster_protos.h>
#include <clib/graphics_protos.h>
extern struct ExecBase *SysBase;
struct RTGMasterBase *RTGMasterBase;
static char *version = VERSTAG;
static struct Screen *scr;
static struct Window *wnd;
static unsigned short *empty_pointer;
static struct RastPort temprp;
struct GfxBase *GfxBase;
struct Library *PowerPCBase;
struct Library *WarpBase;
static BOOL aga;
struct ScreenReq *sr;
struct RtgScreen *MyScreen;
struct ViewPort *vp;
extern int mmu;
// Keyboard fonctions
Graphics::Graphics(int argc, char *argv[])
{
signal(SIGINT, SIG_IGN); // FIXME: make a proper handler
if (mmu) Memory=(char *)AllocVecPPC(FRAME_WIDTH*FRAME_HEIGHT,MEMF_CLEAR|MEMF_FAST|MEMF_CACHEOFF,8);
else Memory = (char *)AllocVecPPC(FRAME_WIDTH*FRAME_HEIGHT, MEMF_CLEAR|MEMF_FAST,8);
// don't touch, please !
graphicsData = Memory;
}
Graphics::~Graphics(void)
{
if(Memory) { FreeVecPPC(Memory); Memory = NULL; }
}
static unsigned long WBColorTable[3*256+2],ColorTable[3*256+2];
static int pen_obtained=FALSE;
static struct ColorMap *ColorMap;
static byte transtable[256];
struct Window *Window;
void SetPalette_WIN (unsigned char *palette)
{
struct TagItem EmptyTags[] =
{
TAG_DONE,0
};
int i,r,g,b;
unsigned char *p;
struct ViewPort *VPort;
p = palette;
if (!aga) Window=((struct RtgScreenCGX *)MyScreen)->MyWindow;
else Window=((struct RtgScreenAMI *)MyScreen)->MyWindow;
ColorMap = Window->WScreen->ViewPort.ColorMap;
VPort = &Window->WScreen->ViewPort;
if (!(pen_obtained))
{
WBColorTable[0] = 0x01000000;
WBColorTable[3*256+1] = 0;
GetRGB32(ColorMap,0,256,WBColorTable+1);
for (i=0;i<(3*256+2);i++)
ColorTable[i] = WBColorTable[i];
for (i=0; i<256; i++)
{
r = ((ULONG)*p++)<<24;
g = ((ULONG)*p++)<<24;
b = ((ULONG)*p++)<<24;
transtable[i] = ObtainBestPenA(ColorMap,r,g,b,EmptyTags);
}
}
p = palette;
for (i=0; i<256; i++)
{
ColorTable[3*i+1/*3*transtable[i]+1*/] = ((ULONG)*p++)<<24;
ColorTable[3*i+2/*3*transtable[i]+2*/] = ((ULONG)*p++)<<24;
ColorTable[3*i+3/*3*transtable[i]+3*/] = ((ULONG)*p++)<<24;
}
LoadRGB32(VPort,ColorTable);
pen_obtained = TRUE;
}
int Graphics::Open(void)
{
int display_id, width, height;
#ifdef CHIRES
struct TagItem rtag[] = {
smr_MinWidth, 640,
smr_MinHeight, 400,
smr_MaxWidth, 640,
smr_MaxHeight, 512,
smr_ChunkySupport, 512,
smr_PlanarSupport, -1,
smr_ProgramUsesC2P, 0,
smr_Buffers,2,
TAG_DONE, NULL
};
#else
#ifdef TINY
struct TagItem rtag[] = {
smr_MinWidth, 160,
smr_MinHeight, 100,
smr_MaxWidth, 320,
smr_MaxHeight, 256,
smr_ChunkySupport, 512,
smr_PlanarSupport, -1,
smr_ProgramUsesC2P, 0,
smr_Buffers,2,
TAG_DONE, NULL
};
#else
struct TagItem rtag[] = {
smr_MinWidth, 320,
smr_MinHeight, 200,
smr_MaxWidth, 320,
smr_MaxHeight, 256,
smr_ChunkySupport, 512,
smr_PlanarSupport, -1,
smr_ProgramUsesC2P, 0,
smr_Buffers,2,
TAG_DONE, NULL
};
#endif
#endif
struct TagItem gtag[] = {
grd_BytesPerRow, 0,
grd_Width, 0,
grd_Height, 0,
grd_Depth, 0,
grd_PixelLayout, 0,
grd_ColorSpace, 0,
grd_PlaneSize, 0,
TAG_DONE, 0
};
struct TagItem tacks[] = {
rtg_Buffers,2,
rtg_Workbench,0,
rtg_ChangeColors,1,
TAG_DONE,0
};
RTGMasterBase = (struct RTGMasterBase *)OpenLibrary((STRPTR)"rtgmaster.library", 34);
if (!RTGMasterBase)
{
printf("Could not open rtgmaster.library V34!\n");
exit(0);
}
GfxBase=(struct GfxBase *)OpenLibrary("graphics.library",36);
PowerPCBase=OpenLibrary("powerpc.library",7);
if (PowerPCBase) CloseLibrary(PowerPCBase);
else
{
printf("This program requires at least powerpc.library V7/warp.library V2.0\n");
exit(0);
}
WarpBase=OpenLibrary("warp.library",2);
if (WarpBase) CloseLibrary(WarpBase);
else
{
printf("This program requires at least powerpc.library V7/warp.library V2.0\n");
exit(0);
}
sr = PPCRtgScreenModeReq(rtag);
if (sr->Flags&sq_WORKBENCH) {tacks[1].ti_Data=LUT8;Workbench=1;}
if (sr==NULL) exit(0);
MyScreen = PPCOpenRtgScreen(sr, tacks);
if (!MyScreen) {PPCFreeRtgScreenModeReq(sr);exit(0);CloseLibrary((struct Library *)GfxBase);CloseLibrary((struct Library *)RTGMasterBase);}
PPCGetRtgScreenData(MyScreen, gtag);
width = FRAME_WIDTH;
height = FRAME_HEIGHT;
empty_pointer = (unsigned short *)AllocVec(8, MEMF_CHIP|MEMF_CLEAR);
PPCRtgSetPointer(MyScreen, empty_pointer, 0, 0, 0, 0);
if (gtag[4].ti_Data==grd_PLANAR)
{
struct Screen *scr;
aga=TRUE;
// Hack, as rtgmaster currently only supports LoadRGB32-type color
// Loading, not SetRGB32-type color loading, i will probably
// include this in the next version
scr=((struct RtgScreenAMI *)MyScreen)->ScreenHandle;
vp=&(scr->ViewPort);
}
else
{
struct Screen *scr;
aga=FALSE;
// Hack, as rtgmaster currently only supports LoadRGB32-type color
// Loading, not SetRGB32-type color loading, i will probably
// include this in the next version
scr=((struct RtgScreenCGX *)MyScreen)->MyScreen;
vp=&(scr->ViewPort);
}
return 1;
}
void Graphics::Close(void)
{
if (pen_obtained)
{
int i;
//for (i=0; i<256; i++)
//ReleasePen(ColorMap,transtable[i]);
//LoadRGB32(&(Window->WScreen->ViewPort),WBColorTable);
}
if (MyScreen) {PPCCloseRtgScreen(MyScreen);MyScreen=0;}
if(empty_pointer) { FreeVec(empty_pointer); empty_pointer = NULL; }
if(Memory) { FreeVec(Memory); Memory = NULL; }
if (sr) {PPCFreeRtgScreenModeReq(sr);sr=NULL;}
if (RTGMasterBase) {CloseLibrary((struct Library *)RTGMasterBase);RTGMasterBase=NULL;}
if (GfxBase) {CloseLibrary((struct Library *)GfxBase);}
}
void Graphics::Print(void)
{
if ((!aga)&&Workbench)
{
int xstop,ystop;
Window=((struct RtgScreenCGX *)MyScreen)->MyWindow;
//ConvertFrame(Memory,transtable,FRAME_WIDTH*FRAME_HEIGHT);
xstop = FRAME_WIDTH-1;
ystop = FRAME_HEIGHT-1;
/*WritePixelArray8(Window->RPort,0,0,xstop,ystop,
(UBYTE *)Memory,
(struct RastPort *)((struct RtgScreenCGX *)MyScreen)->tempras);*/
PPCCopyRtgBlit(MyScreen,PPCGetBufAdr(MyScreen,0),Memory,0,0,0,FRAME_WIDTH,FRAME_HEIGHT,FRAME_WIDTH,FRAME_HEIGHT,0,0);
}
else if (Workbench)
{
int xstop,ystop;
Window=((struct RtgScreenAMI *)MyScreen)->MyWindow;
//ConvertFrame(Memory,transtable,FRAME_WIDTH*FRAME_HEIGHT);
xstop = FRAME_WIDTH-1;
ystop = FRAME_HEIGHT-1;
WritePixelArray8(Window->RPort,0,0,xstop,ystop,
(UBYTE *)Memory,
(struct RastPort *)((struct RtgScreenAMI *)MyScreen)->tempras);
}
else PPCCopyRtgBlit(MyScreen,PPCGetBufAdr(MyScreen,0),Memory,0,0,0,FRAME_WIDTH,FRAME_HEIGHT,FRAME_WIDTH,FRAME_HEIGHT,0,0);
}
void Graphics::Clear (int color)
{
// Clear your graphic interface
// this is the standard one
if (Memory) memset (Memory, color, FRAME_WIDTH*FRAME_HEIGHT);
}
void Graphics::SetPixel (int x, int y, int color)
{
// print a pixel on your graphic interface
// this is the standard one
if (Memory)
{
if (x < 0 || x >= FRAME_WIDTH) return;
if (y < 0 || y >= FRAME_HEIGHT) return;
y = FRAME_HEIGHT-y;
*(Memory+y*FRAME_WIDTH+x) = color;
}
}
void Graphics::SetLine (int x1, int y1, int x2, int y2, int color)
{
// print a line on your graphic interface
// this is the standard one
if (Memory)
{
if (x1 < 0 || x1 > FRAME_WIDTH) { printf ("*"); return ;}
if (x2 < 0 || x2 > FRAME_WIDTH) { printf ("*"); return ;}
if (y1 < 0 || y1 > FRAME_HEIGHT) { printf ("*"); return ;}
if (y2 < 0 || y2 > FRAME_HEIGHT) { printf ("*"); return ;}
y2 = FRAME_HEIGHT-y2;
y1 = FRAME_HEIGHT-y1;
int i, x, y;
for (i = 0 ; i < 200 ; i++)
{
x = (x2-x1)*i/200+x1;
y = (y2-y1)*i/200+y1;
*(Memory+y*FRAME_WIDTH+x) = color;
}
}
}
void Graphics::SetHorLine (int x1, int x2, int y, int color)
{
// print a line with overflow on your graphic interface
// this is the standard one
/*if(Memory)
{
y = FRAME_HEIGHT-y;
char* d = Memory+y*FRAME_WIDTH+x1;
if (y < 0 || y >= FRAME_HEIGHT) { printf ("OVERFLOW draw_hor_line(y=%d)!\n", y); return; }
if (x1 < 0 || x1 >= FRAME_WIDTH) { printf ("OVERFLOW draw_hor_line(x1=%d,x2=%d,y=%d)!\n", x1, x2, y); return; }
if (x2 < 0 || x2 >= FRAME_WIDTH) { printf ("OVERFLOW draw_hor_line(x1=%d,x2=%d,y=%d)!\n", x1, x2, y); return; }
if (x2 >= x1) memset (d, color, x2-x1+1);
//for (x = x1 ; x < x2 ; x++) *d++ = color;
} */
}
ULONG rtgpal[770];
char winpal[768];
void Graphics::SetRGB(int i, int r, int g, int b)
{
// set a rgb color in the palette of your graphic interface
// Hack, as rtgmaster currently only supports LoadRGB32-style Color loading,
// will add this to the next version
//SetRGB32(vp, i, r*0x01010101, g*0x01010101, b*0x01010101);
// dont't touch, please !
//graphicsPalette[i].red = r;
//graphicsPalette[i].green = g;
//graphicsPalette[i].blue = b;
//graphicsPalette_alloc[i] = TRUE;
//if (!Planar) Window=((struct RtgScreenCGX *)MyScreen)->MyWindow;
//else Window=((struct RtgScreenAMI *)MyScreen)->MyWindow;
//vp = &Window->WScreen->ViewPort;
//if (Workbench) LoadRGB32(vp,rtgpal);
/*if (Workbench)
{
int f;
for (f=0;f<256;f++)
{
winpal[3*f]=graphicsPalette[f].red;
winpal[3*f+1]=graphicsPalette[f].green;
winpal[3*f+2]=graphicsPalette[f].blue;
}
SetPalette_WIN(winpal);
}
else */PPCLoadRGBRtg(MyScreen,rtgpal);
}
// Keyboard fonctions
Keyboard::Keyboard(int argc, char *argv[])
{
// Create your keyboard interface
}
Keyboard::~Keyboard(void)
{
// Destroy your keyboard interface
Close();
}
int Keyboard::Open(void)
{
// Open your keyboard interface
return (1);
}
void Keyboard::Close(void)
{
// Close your keyboard interface
}
// don't touch, please !
void do_buttonpress (int x, int y, int shift, int alt, int ctrl);
void do_buttonrelease (int x, int y);
void do_mousemotion (int x, int y);
void do_stuff ();
void do_expose ();
void do_keypress (int key, int shift, int alt, int ctrl);
// System loop !
void System::Loop(void)
{
struct Message *msg;
struct IntuiMessage copy;
int key = 0, shift = 0, alt = 0, ctrl = 0;
int key_up = 0, key_down = 0, key_left = 0, key_right = 0;
// don't touch, please !
Graph->Clear(0);
Shutdown=0;
while(!Shutdown)
{
if (key) do_keypress(key, shift, alt, ctrl);
if (key_up) do_keypress(key_up, shift, alt, ctrl);
if (key_down) do_keypress(key_down, shift, alt, ctrl);
if (key_left) do_keypress(key_left, shift, alt, ctrl);
if (key_right) do_keypress(key_right, shift, alt, ctrl);
do_stuff (); // don't remove, please !
while((msg = (struct Message *)PPCRtgGetMsg(MyScreen)))
{
CopyMemPPC(msg, ©, sizeof(struct IntuiMessage));
PPCRtgReplyMsg(MyScreen,msg);
if(copy.Class == IDCMP_RAWKEY)
{
if(copy.Code & IECODE_UP_PREFIX)
{
copy.Code &= ~IECODE_UP_PREFIX;
switch(copy.Code)
{
case 0x4c: key_up = 0; break;
case 0x4d: key_down = 0; break;
case 0x4f: key_left = 0; break;
case 0x4e: key_right = 0; break;
}
key = 0;
}
else
{
switch(copy.Code)
{
case 0x4c: key_up = KEY_UP; key = 0; break;
case 0x4d: key_down = KEY_DOWN; key = 0; break;
case 0x4f: key_left = KEY_LEFT; key = 0; break;
case 0x4e: key_right = KEY_RIGHT; key = 0; break;
case 0x41: key = KEY_BS; break;
case 0x3f: key = KEY_PGUP; break;
case 0x1f: key = KEY_PGDN; break;
case 0x1d: key = KEY_END; break;
case 0x45: key = KEY_ESC; break;
case 0x35: key = 'b'; break;
case 0x40: key = ' '; break;
case 0x28: key = 'l'; break;
case 0x12: key = 'e'; break;
case 0x33: key = 'c'; break;
case 0x21: key = 's'; break;
case 0x10: key = 'q'; break;
case 0x14: key = 't'; break;
case 0x17: key = 'i'; break;
case 0x13: key = 'r'; break;
case 0x19: key = 'p'; break;
default: key = 0; break;
}
}
shift = copy.Qualifier & (IEQUALIFIER_LSHIFT|IEQUALIFIER_RSHIFT);
alt = copy.Qualifier & (IEQUALIFIER_LALT|IEQUALIFIER_RALT);
ctrl = copy.Qualifier & IEQUALIFIER_CONTROL;
}
}
} // while (!Shutdown)
}
#endif // DO_AMIGAOS