home
***
CD-ROM
|
disk
|
FTP
|
other
***
search
/
Frozen Fish 1: Amiga
/
FrozenFish-Apr94.iso
/
bbs
/
alib
/
d1xx
/
d157
/
animballs.lha
/
AnimBalls
/
myblit.c
< prev
next >
Wrap
C/C++ Source or Header
|
1988-10-02
|
5KB
|
222 lines
/* myblit.c - definition of my blitter code */
/* It will blit from a source through a mask to a destination bitmap */
/* The mask must have the word before and after it clear */
#include <exec/types.h>
#ifdef BLTDEBUG
#include <stdio.h>
#endif
#include <hardware/custom.h>
#include <hardware/blit.h>
#include <graphics/gfx.h>
#define BLTADD (0xdff040)
/*
* This structure contains everything we need to know.
* Do not do a structure copy into this! Instead, assign
* each field. The last field assigned must be bltsize; that
* starts up the blitter. Also note that all of these are
* write only, and you can't read them.
*/
struct BltStruct {
WORD con0;
WORD con1;
WORD afwm;
WORD alwm;
WORD *csource, *bsource, *asource, *dsource;
WORD bltsize;
WORD dmy1, dmy2, dmy3;
WORD cmod, bmod, amod, dmod;
};
static struct BltStruct *Blitter = (struct BltStruct *)BLTADD;
static UBYTE boffset[] = {0x80, 0x40, 0x20, 0x10, 0x08, 0x04, 0x02, 0x01};
void
BltBitMask(sbm,sx,sy,dbm,dx,dy,mbm,mx,my,mpno,xsize,ysize)
struct BitMap *sbm, *dbm, *mbm;
int sx,sy,dx,dy,mx,my,mpno,xsize,ysize;
{
WORD *splane, *dplane, *mplane;
WORD *aaddr,*baddr,*daddr;
int ashft, bshft;
UWORD afwm,alwm;
int smodulo, dmodulo, mmodulo;
int i;
smodulo = ((sbm->BytesPerRow) + 1) >> 1;
dmodulo = ((dbm->BytesPerRow) + 1) >> 1;
mmodulo = ((mbm->BytesPerRow) + 1) >> 1;
splane = (WORD *) (sbm->Planes[0]);
dplane = (WORD *) (dbm->Planes[0]);
mplane = (WORD *) (mbm->Planes[mpno]);
daddr = dplane + dmodulo * dy + (dx >> 4);
dx &= 15;
aaddr = mplane + mmodulo * my + (mx >> 4);
mx &= 15;
baddr = splane + smodulo * sy + (sx >> 4);
sx &= 15;
#ifdef BLTDEBUG
printf("new - spl = %x, dpl = %x, mpl = %x\n",splane,dplane,mplane);
printf("smod = %x, dmod = %x, mmod = %x\n",smodulo,dmodulo,mmodulo);
printf("aa=%x, ba=%x, da=%x, (a)mx=%d, (b)sx=%d, dx=%d, xs=%d\n",
(aaddr - mplane - mmodulo * my),
(baddr - splane - smodulo * sy),
(daddr - dplane - dmodulo * dy),mx,sx,dx,xsize);
#endif
ashft = dx - mx;
bshft = dx - sx;
afwm = ((unsigned) 0xffff) >> mx;
alwm = 0xffff << (16 - ((mx + xsize) & 15));
xsize = (xsize + dx + 15) >> 4;
if ((ashft < 0) || (bshft < 0)) {
daddr--;
xsize++;
if (ashft < 0) ashft += 16;
else aaddr--;
if (bshft < 0) bshft += 16;
else baddr--;
}
#ifdef BLTDEBUG
printf("aaddr = %x, baddr = %x, daddr = %x\n",aaddr,baddr,daddr);
printf("aa=%x, ba=%x, da=%x, fw=%x, lw=%x, as=%d, bs=%d, xs=%d\n",
(aaddr - mplane - mmodulo * my),
(baddr - splane - smodulo * sy),
(daddr - dplane - dmodulo * dy),afwm,alwm,ashft,bshft,xsize);
#endif
OwnBlitter();
WaitBlit();
Blitter->asource = aaddr;
Blitter->bsource = baddr;
Blitter->csource = Blitter->dsource = daddr;
Blitter->amod = (mmodulo - xsize) << 1;
Blitter->bmod = (smodulo - xsize) << 1;
Blitter->cmod = Blitter->dmod = (dmodulo - xsize) << 1;
Blitter->afwm = afwm;
Blitter->alwm = alwm;
Blitter->con0 = (ashft << 12) | (0xf << 8) | 0xca;
Blitter->con1 = (bshft << 12);
Blitter->bltsize = (ysize << 6) | xsize;
for (i = 1; i < dbm->Depth; i++) {
WaitBlit();
Blitter->asource = aaddr;
Blitter->bsource = baddr +
(((WORD *)sbm->Planes[i]) - ((WORD *)sbm->Planes[0]));
Blitter->csource = Blitter->dsource = daddr +
(((WORD *)dbm->Planes[i]) - ((WORD *)dbm->Planes[0]));
Blitter->bltsize = (ysize << 6) | xsize;
}
DisownBlitter();
}
void
mywritepixel1(bm,x,y)
struct BitMap *bm;
int x,y;
{
register int offset;
register UBYTE bits;
offset = y * bm->BytesPerRow + (x >> 3);
bits = boffset[x & 7];
bm->Planes[0][offset] |= bits;
}
void
mywritepixel(bm,x,y,color)
struct BitMap *bm;
int x,y;
{
register int offset;
register int i;
UBYTE bits,nbits;
offset = y * bm->BytesPerRow + (x >> 3);
bits = boffset[x & 7];
nbits = ~bits;
for (i=0; i < bm->Depth; i++) {
if (color & 0x01) bm->Planes[i][offset] |= bits;
else bm->Planes[i][offset] &= nbits;
color >>= 1;
}
}
void
myblank(bm,y1,y2)
struct BitMap *bm;
int y1,y2;
{
register int offset, bytes;
register int i;
offset = y1 * bm->BytesPerRow;
bytes = (y2 - y1) * bm->BytesPerRow;
for (i=0; i < bm->Depth; i++)
BltClear(&(bm->Planes[i][offset]),bytes,0);
}
void
mylinecopy(bm,starty,len,delta)
struct BitMap *bm;
int starty, len, delta;
{
UBYTE *loc1, *loc2, *stop;
int i;
for(i=0; i < bm->Depth; i++) {
loc1 = &(bm->Planes[i][starty*bm->BytesPerRow]);
stop = loc1 + len*bm->BytesPerRow;
loc2 = loc1 + delta*bm->BytesPerRow;
while (loc1 < stop) *(loc2++) = *(loc1++);
}
}
void
myblankc(bm,y1,y2,color)
struct BitMap *bm;
int y1,y2,color;
{
register int i;
WORD *daddr;
int dmodulo;
dmodulo = ((bm->BytesPerRow) + 1) >> 1;
daddr = (WORD *) (bm->Planes[0]);
daddr += dmodulo * y1;
OwnBlitter();
WaitBlit();
Blitter->dsource = daddr;
Blitter->dmod = 0;
if (color & 1)
Blitter->con0 = (1 << 8) | (0xff);
else Blitter->con0 = (1 << 8);
Blitter->bltsize = ((y2-y1) << 6) | dmodulo;
color >>= 1;
for (i = 1; i < bm->Depth; i++) {
WaitBlit();
Blitter->dsource = daddr +
(((WORD *)bm->Planes[i]) - ((WORD *)bm->Planes[0]));
if (color & 1)
Blitter->con0 = (1 << 8) | (0xff);
else Blitter->con0 = (1 << 8);
color >>= 1;
Blitter->bltsize = ((y2 - y1) << 6) | dmodulo;
}
DisownBlitter();
}