📄 m2b4_drv.c
字号:
dstPxBit = (dstPxBit >> shfCnt);
if (dstPxBit == 0)
{ /* advance to next byte */
dstPtr++;
/* now check for high speed middle blit */
if (srcShf == 0)
{ /* yes */
while (lclByteCnt >= lclShift)
{ /* for each byte in the row */
srcPtr++;
*dstPtr = pnColr ^ *srcPtr;
dstPtr++;
lclByteCnt -= lclShift;
}
}
/* do rest of data */
if (shfCnt == 2)
{
dstPxBit = 0xc0;
}
else
{
dstPxBit = 0xf0;
}
}
srcPxBit = (srcPxBit >> shfCnt);
if (srcPxBit == 0)
{ /* advance to next byte */
srcPtr++;
if (shfCnt == 2)
{
srcPxBit = 0xc0;
}
else
{
srcPxBit = 0xf0;
}
}
}
dRect.Ymin++; /* advance to next row */
sRect.Ymin++;
}
}
return;
}
/* Function OXADestM2_4B sets the destination pixel data based on
the logical function "OR", "XOR" or "AND". */
void OXADestM2_4B(void)
{
int lclByteCnt, lclShift;
int dstPxShift, srcPxShift, srcShf;
byte dstPxBit, srcPxBit, srcColr;
int logFnc;
if ((dstBmap == srcBmap) && ((sRect.Ymin < dRect.Ymin) ||
((sRect.Ymin == dRect.Ymin) && (sRect.Xmin < dRect.Xmin))))
{ /* blit bottom to top, right to left */
dstPxShift = (dRect.Xmax & firstOffset) * shfCnt;
srcPxShift = (sRect.Xmax & firstOffset) * shfCnt;
srcShf = srcPxShift - dstPxShift;
/* BobB 1/15/99 - corrected image shifting */
if (srcShf < 0) srcShf = -srcShf;
lclShift = (flipMask << 1);
logFnc = (dstClass & 3); /* only two lower bits needed */
while (lineCntM1-- >= 0)
{ /* for each row */
dstPtr = (byte *) (*(dstBmap->mapTable[0] + dRect.Ymax))
+ (dRect.Xmax >> flipMask);
srcPtr = (byte *) (*(srcBmap->mapTable[0] + sRect.Ymax))
+ (sRect.Xmax >> flipMask);
lclByteCnt = byteCntM1;
dstPxBit = (byte) (shiftMask >> dstPxShift);
srcPxBit = (byte) (shiftMask >> srcPxShift);
while (lclByteCnt-- >= 0)
{ /* for each byte in the row */
srcColr = (*srcPtr ^ pnColr) & srcPxBit;
/* BobB 1/15/99 - corrected image shifting
if (srcShf < 0) srcColr = (srcColr >> -srcShf);
if (srcShf > 0) srcColr = (srcColr << srcShf); */
if (dstPxBit < srcPxBit) srcColr = (srcColr >> srcShf);
if (dstPxBit > srcPxBit) srcColr = (srcColr << srcShf);
switch (logFnc)
{
case 0: /* can't happen */
case 1: /* "OR" */
*dstPtr = *dstPtr | srcColr;
break;
case 2: /* "XOR" */
*dstPtr = *dstPtr ^ srcColr;
break;
case 3: /* "AND" */
*dstPtr = *dstPtr & (~dstPxBit | (dstPxBit & srcColr));
break;
}
dstPxBit = (dstPxBit << shfCnt);
if (dstPxBit == 0)
{ /* advance to next byte */
dstPtr--;
/* now check for high speed middle blit */
if (srcShf == 0)
{ /* yes */
while (lclByteCnt >= lclShift)
{ /* for each byte in the row */
srcPtr--;
srcColr = pnColr ^ *srcPtr;
switch (logFnc)
{
case 0: /* can't happen */
case 1: /* "OR" */
*dstPtr = *dstPtr | srcColr;
break;
case 2: /* "XOR" */
*dstPtr = *dstPtr ^ srcColr;
break;
case 3: /* "AND" */
*dstPtr = *dstPtr & (~dstPxBit | (dstPxBit & srcColr));
break;
}
dstPtr--;
lclByteCnt -= lclShift;
}
}
/* do rest of data */
if (shfCnt == 2)
{
dstPxBit = 0x03;
}
else
{
dstPxBit = 0x0f;
}
}
srcPxBit = (srcPxBit << shfCnt);
if (srcPxBit == 0)
{ /* advance to next byte */
srcPtr--;
if (shfCnt == 2)
{
srcPxBit = 0x03;
}
else
{
srcPxBit = 0x0f;
}
}
}
dRect.Ymax--; /* advance to next row */
sRect.Ymax--;
}
}
else
{ /* blit top to bottom, left to right */
dstPxShift = (dRect.Xmin & firstOffset) * shfCnt;
srcPxShift = (sRect.Xmin & firstOffset) * shfCnt;
srcShf = srcPxShift - dstPxShift;
/* BobB 1/15/99 - corrected image shifting */
if (srcShf < 0) srcShf = -srcShf;
lclShift = (flipMask << 1);
logFnc = (dstClass & 3); /* only two lower bits needed */
while (lineCntM1-- >= 0)
{ /* for each row */
dstPtr = (byte *) (*(dstBmap->mapTable[0] + dRect.Ymin))
+ dstBgnByte;
srcPtr = (byte *) (*(srcBmap->mapTable[0] + sRect.Ymin))
+ srcBgnByte;
lclByteCnt = byteCntM1;
dstPxBit = (byte) (shiftMask >> dstPxShift);
srcPxBit = (byte) (shiftMask >> srcPxShift);
while (lclByteCnt-- >= 0)
{ /* for each byte in the row */
srcColr = (*srcPtr ^ pnColr) & srcPxBit;
/* BobB 1/15/99 - corrected image shifting
if (srcShf < 0) srcColr = (srcColr >> -srcShf);
if (srcShf > 0) srcColr = (srcColr << srcShf); */
if (dstPxBit < srcPxBit) srcColr = (srcColr >> srcShf);
if (dstPxBit > srcPxBit) srcColr = (srcColr << srcShf);
switch (logFnc)
{
case 0: /* can't happen */
case 1: /* "OR" */
*dstPtr = *dstPtr | srcColr;
break;
case 2: /* "XOR" */
*dstPtr = *dstPtr ^ srcColr;
break;
case 3: /* "AND" */
*dstPtr = *dstPtr & (~dstPxBit | (dstPxBit & srcColr));
break;
}
dstPxBit = (dstPxBit >> shfCnt);
if (dstPxBit == 0)
{ /* advance to next byte */
dstPtr++;
/* now check for high speed middle blit */
if (srcShf == 0)
{ /* yes */
while (lclByteCnt >= lclShift)
{ /* for each byte in the row */
srcPtr++;
srcColr = pnColr ^ *srcPtr;
switch (logFnc)
{
case 0: /* can't happen */
case 1: /* "OR" */
*dstPtr = *dstPtr | srcColr;
break;
case 2: /* "XOR" */
*dstPtr = *dstPtr ^ srcColr;
break;
case 3: /* "AND" */
*dstPtr = *dstPtr & (~dstPxBit | (dstPxBit & srcColr));
break;
}
dstPtr++;
lclByteCnt -= lclShift;
}
}
/* do rest of data */
if (shfCnt == 2)
{
dstPxBit = 0xc0;
}
else
{
dstPxBit = 0xf0;
}
}
srcPxBit = (srcPxBit >> shfCnt);
if (srcPxBit == 0)
{ /* advance to next byte */
srcPtr++;
if (shfCnt == 2)
{
srcPxBit = 0xc0;
}
else
{
srcPxBit = 0xf0;
}
}
}
dRect.Ymin++; /* advance to next row */
sRect.Ymin++;
}
}
return;
}
/* Function mwGP2_4B is a special case optimization for GetPixel,
2/4-bit per pixel memory source. */
int mwGP2_4B(int gblX, int gblY, grafMap *getpBmap)
{
void nuResume(grafMap *argGRAFMAP);
byte *pixelPtr;
int pixelValue;
/* check if off bitmap */
if ((gblX < 0) || (gblY < 0) || (gblX >= getpBmap->pixWidth) ||
(gblY >= getpBmap->pixHeight)) return(0);
M_PAUSE(getpBmap); /* lock grafMap */
shfCnt = getpBmap->pixBits; /* determine number of bits per pixel */
if (shfCnt == 2)
{ /* 2 bpp */
pixelPtr = (byte *) (*(getpBmap->mapTable[0] + gblY)) +
(gblX >> 2);
switch (gblX & 0x03)
{
case 0:
pixelValue = (*pixelPtr >> 6) & 0x03;
break;
case 1:
pixelValue = (*pixelPtr >> 4) & 0x03;
break;
case 2:
pixelValue = (*pixelPtr >> 2) & 0x03;
break;
case 3:
pixelValue = *pixelPtr & 0x03;
break;
}
}
else
{ /* 4 bpp */
pixelPtr = (byte *) (*(getpBmap->mapTable[0] + gblY)) +
(gblX >> 1);
if (gblX & 0x01)
{
pixelValue = *pixelPtr & 0x0f;
}
else
{
pixelValue = (*pixelPtr >> 4) & 0x0f;
}
}
nuResume(getpBmap);
return(pixelValue);
}
/* Function mwSP2_4B is a special case optimization for SetPixel,
2/4-bit-per-pixel memory destination, rectangular and/or region
clipping with color translation.
*******************************************
* Only patterns 0 and 1 are handled here, *
* and only raster ops 0 and 16!!!! *
*******************************************
blitCnt is ignored; it's assumed to be 1. */
void mwSP2_4B(blitRcd *setpRec )
{
void DrawRectEntry_setp2_4B(blitRcd *drwPRec);
int Set_Up_Clip(blitRcd *clipBlit, rect *cRect, int blitMayOverlap,
int isLine);
int Fill_Clip_Region(blitRcd *fcRec, rect *dRectect);
void nuResume(grafMap *argGRAFMAP);
point *drawPt; /* Pointer to point to draw */
int blitMayOverlap = 0; /* Set false */
int isLine = 0; /* Set false */
/* set up the rectangular/region clip info */
if (Set_Up_Clip(setpRec, &cRect, blitMayOverlap, isLine)) return;
drawPt = (point *) setpRec->blitList; /* set up pointer */
dRect.Xmin = drawPt->X;
dRect.Ymin = drawPt->Y;
M_PAUSE(setpRec->blitDmap); /* lock grafMap */
/* do we need to worry about clipping at all*/
if (clipToRectFlag == 0)
{ /* no--valid coordinates are guaranteed at a higher level */
DrawRectEntry_setp2_4B(setpRec); /* draw the point */
}
else
{ /* yes first check trivial reject */
if ((dRect.Xmin >= cRect.Xmin) && (dRect.Ymin >= cRect.Ymin) &&
(dRect.Xmin < cRect.Xmax) && (dRect.Ymin < cRect.Ymax))
{ /* it passes so far - do we need to worry about region clipping? */
if (clipToRegionFlag == 0)
{ /* no, draw the point */
DrawRectEntry_setp2_4B(setpRec);
}
else
{ /* yes, clip to the region and draw */
dRect.Xmax = dRect.Xmin + 1;
dRect.Ymax = dRect.Ymin + 1;
FillDrawer = &DrawRectEntry_setp2_4B;
Fill_Clip_Region(setpRec, &dRect);
}
}
}
nuResume(setpRec->blitDmap);
return;
}
void DrawRectEntry_setp2_4B(blitRcd *drwPRec)
{
grafMap *drwGmap;
long *rowTable;
byte *bytePtr;
short pColor;
drwGmap = drwPRec->blitDmap; /* get grafMap */
/* look up the starting row */
rowTable = (long *) drwGmap->mapTable[0] + dRect.Ymin;
if (drwPRec->blitPat == 0) /* pattern 0? */
{ /* yes, use background color */
if (drwPRec->blitRop & 0x10) return; /* done if transparent */
pColor = (short) drwPRec->blitBack;
}
else
{ /* no, use foreground color */
pColor = (short) drwPRec->blitFore;
}
/* point to pixel */
shfCnt = drwGmap->pixBits; /* determine number of bits per pixel */
if (shfCnt == 2)
{ /* 2 bpp */
/* BobB 12/29/98 - Corrected the following line for set pixel
pColor = ((pColor & sMapMask) & 0x03); */
pColor = (pColor & 0x03);
bytePtr = (byte *) ((*rowTable) + (dRect.Xmin >> 2));
switch (dRect.Xmin & 0x03)
{
case 0:
*bytePtr = (*bytePtr & 0x3f) | (pColor << 6);
break;
case 1:
*bytePtr = (*bytePtr & 0xcf) | (pColor << 4);
break;
case 2:
*bytePtr = (*bytePtr & 0xf3) | (pColor << 2);
break;
case 3:
*bytePtr = (*bytePtr & 0xfc) | pColor;
break;
}
}
else
{ /* 4 bpp */
/* BobB 12/29/98 - Corrected the following line for set pixel
pColor = ((pColor & sMapMask) & 0x0f); */
pColor = (pColor & 0x0f);
bytePtr = (byte *) ((*rowTable) + (dRect.Xmin >> 1));
if (dRect.Xmin & 0x01)
{
*bytePtr = (*bytePtr & 0xf0) | pColor;
}
else
{
*bytePtr = (*bytePtr & 0x0f) | (pColor << 4);
}
}
return;
}
⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -