m1b_drv.c

与Nucleus Plus配套的图形库

				if (dstPxBit > srcPxBit) srcColr = (srcColr << srcShf);

				*dstPtr = (*dstPtr & ~dstPxBit) | srcColr;

				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 */
						dstPxBit = 0x80;
				}

				srcPxBit = (srcPxBit >> shfCnt);
				if (srcPxBit == 0)
				{	/* advance to next byte */
					srcPtr++;
					srcPxBit = 0x80;
				}

			}

			dRect.Ymin++;	/* advance to next row */
			sRect.Ymin++;
		}
	}

	return;
}


/* Function OXADestM1Bit sets the destination pixel data based on
the logical function "OR", "XOR" or "AND". */
void OXADestM1Bit(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 = 8;
		logFnc = (dstClass & 3);	/* only two lower bits needed */

		while (lineCntM1-- >= 0)
		{	/* for each row */
			dstPtr = (byte *) (*(dstBmap->mapTable[0] + dRect.Ymax))
				+ (dRect.Xmax >> 3);
			srcPtr = (byte *) (*(srcBmap->mapTable[0] + sRect.Ymax))
				+ (sRect.Xmax >> 3);
			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 */
					dstPxBit = 0x01;
				}

				srcPxBit = (srcPxBit << shfCnt);
				if (srcPxBit == 0)
				{	/* advance to next byte */
					srcPtr--;
					srcPxBit = 0x01;
				}
			}

			dRect.Ymax--;	/* advance to next row */
			sRect.Ymax--;
		}
	}
	else
	{	/* blit top to bottom, left to right */
		dstPxShift = (dRect.Xmin & firstOffset);
		srcPxShift = (sRect.Xmin & firstOffset);
		srcShf = srcPxShift - dstPxShift;

/* BobB 1/15/99 - corrected image shifting */
	if (srcShf < 0) srcShf = -srcShf;

		lclShift = 8;
		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 */
					dstPxBit = 0x80;
				}

				srcPxBit = (srcPxBit >> shfCnt);
				if (srcPxBit == 0)
				{	/* advance to next byte */
					srcPtr++;
					srcPxBit = 0x80;
				}
			}

			dRect.Ymin++;	/* advance to next row */
			sRect.Ymin++;
		}
	}

	return;
}


/* Function mwGP1Bit is a special case optimization for GetPixel,
1-bit per pixel memory source.  */
int mwGP1Bit(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 = (gblX & 0x07);
	pixelPtr = (byte *) (*(getpBmap->mapTable[0] + gblY)) +
		(gblX >> 3);
	pixelValue = (*pixelPtr >> shfCnt) & 0x01;

	nuResume(getpBmap);
	return(pixelValue);
}


/* Function mwSP1Bit is a special case optimization for SetPixel,
1-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 mwSP1Bit(blitRcd *setpRec )
{
	void DrawRectEntry_setp1Bit(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_setp1Bit(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_setp1Bit(setpRec);
			}
			else
			{	/* yes, clip to the region and draw */
				dRect.Xmax = dRect.Xmin + 1;
				dRect.Ymax = dRect.Ymin + 1;
				FillDrawer = &DrawRectEntry_setp1Bit;
				Fill_Clip_Region(setpRec, &dRect);
			}
		}
	}

	nuResume(setpRec->blitDmap);
	return;
}

void DrawRectEntry_setp1Bit(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 = (dRect.Xmin & 0x07);
	flipMask = ~(0x80 >> shfCnt);

/* BobB 12/29/98 - Corrected the following line for set pixel
	pColor = ((pColor & sMapMask) << (7 - shfCnt)); */
	pColor = (pColor << (7 - shfCnt));
	bytePtr = (byte *) ((*rowTable) + (dRect.Xmin >> 3));
	*bytePtr = (*bytePtr & flipMask) | pColor;

	return;
}


/* Function SetSrcLCD sets the destination pixel data. */
void SetSrcLCD(void)
{
	byte *lclDstPtr;
	int lclLineCnt, lclByteCnt;
	byte * dstPtrSave;

	lclDstPtr = dstPtr;	/* set up local pointers */
	lclLineCnt = lineCntM1;

	while (lclLineCnt-- >= 0)
	{	/* for each row */

		dstPtrSave = lclDstPtr;

		lclByteCnt = byteCntM1;
		while (lclByteCnt-- >= 0)
		{	/* for each byte in the row */
			*lclDstPtr++ = pnColr;
		}

		lclDstPtr = dstPtrSave + dstNextRow;
	}

	return;
}


/* Function InvertSrcLCD inverts the destination pixel data. */
void InvertSrcLCD(void)
{
	byte *lclDstPtr;
	int lclLineCnt, lclByteCnt;
	byte * dstPtrSave;

	lclDstPtr = dstPtr;	/* set up local pointers */
	lclLineCnt = lineCntM1;

	while (lclLineCnt-- >= 0)
	{	/* for each row */

		dstPtrSave = lclDstPtr;

		lclByteCnt = byteCntM1;
		while (lclByteCnt-- >= 0)
		{	/* for each byte in the row */
			*lclDstPtr = ~(*lclDstPtr);
			lclDstPtr++;
		}

		lclDstPtr = dstPtrSave + dstNextRow;
	}

	return;
}


/* Function QuickEnd is just a NOP */
void QuickEnd(void)
{
	return;
}