📄 m8b_lin.c

📁 nucleus 文件系统,内核和彩色图形系统,在小系统上非常好用
💻 C
📖 第 1 页 / 共 3 页
字号:
上一页 1 23
/* Y major top->bottom, vertical masked, XOR. */
void M8BMXV(void)
{
	int i;
	byte lclMask;

	lclMask = lclPortMask & lclPenColor;	/* we'll leave all
											masked-off bits unchanged */
	for (i = 0; i <= majorAxisLengthM1; i++)
	{
		dstPtr = (byte *) *rowTablePtr[0] + dRect.Xmin;
		*dstPtr = (*dstPtr ^ lclMask);
		rowTablePtr[0]++;
		errTermL += errTermAdjUpL;
		if (errTermL >= 0)
		{	/* minor axis advance */
			errTermL -= errTermAdjDownL;
			dRect.Xmin++;
		}
	}

	return;
}


/* Y major top->bottom, right->left masked, XOR. */
void M8BMXYMRL(void)
{
	int i;
	byte lclMask;

	lclMask = lclPortMask & lclPenColor;	/* we'll leave all
											masked-off bits unchanged */
	for (i = 0; i <= majorAxisLengthM1; i++)
	{
		dstPtr = (byte *) *rowTablePtr[0] + dRect.Xmin;
		*dstPtr = (*dstPtr ^ lclMask);
		rowTablePtr[0]++;
		errTermL += errTermAdjUpL;
		if (errTermL >= 0)
		{	/* minor axis advance */
			errTermL -= errTermAdjDownL;
			dRect.Xmin--;
		}
	}

	return;
}


/* X major top->bottom, left->right masked, XOR. */
/* #define M8BMXXMLR M8BMXH */
/* Diagonal top->bottom, left->right masked, XOR. */
/* #define M8BMXDLR M8BMXH */
/* Horizontal left->right masked, XOR. */
void M8BMXH(void)
{
	int i;
	byte lclMask;

	lclMask = lclPortMask & lclPenColor;	/* we'll leave all
											masked-off bits unchanged */
	for (i = 0; i <= majorAxisLengthM1; i++)
	{
		dstPtr = (byte *) *rowTablePtr[0] + dRect.Xmin;
		*dstPtr = (*dstPtr ^ lclMask);
		dRect.Xmin++;
		errTermL += errTermAdjUpL;
		if (errTermL >= 0)
		{	/* minor axis advance */
			errTermL -= errTermAdjDownL;
			rowTablePtr[0]++;
		}
	}

	return;
}


/* X major top->bottom, right->left masked, XOR. */
/* #define M8BMXXMRL M8BMXDRL */
/* Diagonal top->bottom, right->left masked, XOR. */
void M8BMXDRL(void)
{
	int i;
	byte lclMask;

	lclMask = lclPortMask & lclPenColor;	/* we'll leave all
											masked-off bits unchanged */
	for (i = 0; i <= majorAxisLengthM1; i++)
	{
		dstPtr = (byte *) *rowTablePtr[0] + dRect.Xmin;
		*dstPtr = (*dstPtr ^ lclMask);
		dRect.Xmin--;
		errTermL += errTermAdjUpL;
		if (errTermL >= 0)
		{	/* minor axis advance */
			errTermL -= errTermAdjDownL;
			rowTablePtr[0]++;
		}
	}

	return;
}


/* Y major top->bottom, left->right masked, OR. */
/* #define M8BMOYMLR M8BMOV */
/* Y major top->bottom, vertical masked, OR. */
void M8BMOV(void)
{
	int i;
	byte lclMask;

	lclMask = lclPortMask & lclPenColor;	/* we'll leave all
											masked-off bits unchanged */
	for (i = 0; i <= majorAxisLengthM1; i++)
	{
		dstPtr = (byte *) *rowTablePtr[0] + dRect.Xmin;
		*dstPtr = (*dstPtr | lclMask);
		rowTablePtr[0]++;
		errTermL += errTermAdjUpL;
		if (errTermL >= 0)
		{	/* minor axis advance */
			errTermL -= errTermAdjDownL;
			dRect.Xmin++;
		}
	}

	return;
}


/* Y major top->bottom, right->left masked, OR. */
void M8BMOYMRL(void)
{
	int i;
	byte lclMask;

	lclMask = lclPortMask & lclPenColor;	/* we'll leave all
											masked-off bits unchanged */
	for (i = 0; i <= majorAxisLengthM1; i++)
	{
		dstPtr = (byte *) *rowTablePtr[0] + dRect.Xmin;
		*dstPtr = (*dstPtr | lclMask);
		rowTablePtr[0]++;
		errTermL += errTermAdjUpL;
		if (errTermL >= 0)
		{	/* minor axis advance */
			errTermL -= errTermAdjDownL;
			dRect.Xmin--;
		}
	}

	return;
}


/* X major top->bottom, left->right masked, OR. */
/* #define M8BMOXMLR M8BMOH */
/* Diagonal top->bottom, left->right masked, OR. */
/* #define M8BMODLR M8BMOH */
/* Horizontal left->right masked, OR. */
void M8BMOH(void)
{
	int i;
	byte lclMask;

	lclMask = lclPortMask & lclPenColor;	/* we'll leave all
											masked-off bits unchanged */
	for (i = 0; i <= majorAxisLengthM1; i++)
	{
		dstPtr = (byte *) *rowTablePtr[0] + dRect.Xmin;
		*dstPtr = (*dstPtr | lclMask);
		dRect.Xmin++;
		errTermL += errTermAdjUpL;
		if (errTermL >= 0)
		{	/* minor axis advance */
			errTermL -= errTermAdjDownL;
			rowTablePtr[0]++;
		}
	}

	return;
}


/* X major top->bottom, right->left masked, OR. */
/* #define M8BMOXMRL M8BMODRL */
/* Diagonal top->bottom, right->left masked, OR. */
void M8BMODRL(void)
{
	int i;
	byte lclMask;

	lclMask = lclPortMask & lclPenColor;	/* we'll leave all
											masked-off bits unchanged */
	for (i = 0; i <= majorAxisLengthM1; i++)
	{
		dstPtr = (byte *) *rowTablePtr[0] + dRect.Xmin;
		*dstPtr = (*dstPtr | lclMask);
		dRect.Xmin--;
		errTermL += errTermAdjUpL;
		if (errTermL >= 0)
		{	/* minor axis advance */
			errTermL -= errTermAdjDownL;
			rowTablePtr[0]++;
		}
	}

	return;
}


/* Y major top->bottom, left->right masked, OR NOT dest. */
/* #define M8BMOYMLR_ND M8BMOV_ND */
/* Y major top->bottom, vertical masked, OR NOT dest. */
void M8BMOV_ND(void)
{
	int i;
	byte lclMask;

	lclMask = lclPortMask & lclPenColor;	/* we'll leave all
											masked-off bits unchanged */
	for (i = 0; i <= majorAxisLengthM1; i++)
	{
		dstPtr = (byte *) *rowTablePtr[0] + dRect.Xmin;
		*dstPtr = (*dstPtr ^ lclPortMask) | lclMask;
		rowTablePtr[0]++;
		errTermL += errTermAdjUpL;
		if (errTermL >= 0)
		{	/* minor axis advance */
			errTermL -= errTermAdjDownL;
			dRect.Xmin++;
		}
	}

	return;
}


/* Y major top->bottom, right->left masked, OR NOT dest. */
void M8BMOYMRL_ND(void)
{
	int i;
	byte lclMask;

	lclMask = lclPortMask & lclPenColor;	/* we'll leave all
											masked-off bits unchanged */
	for (i = 0; i <= majorAxisLengthM1; i++)
	{
		dstPtr = (byte *) *rowTablePtr[0] + dRect.Xmin;
		*dstPtr = (*dstPtr ^ lclPortMask) | lclMask;
		rowTablePtr[0]++;
		errTermL += errTermAdjUpL;
		if (errTermL >= 0)
		{	/* minor axis advance */
			errTermL -= errTermAdjDownL;
			dRect.Xmin--;
		}
	}

	return;
}


/* X major top->bottom, left->right masked, OR NOT dest. */
/* #define M8BMOXMLR_ND M8BMOH_ND */
/* Diagonal top->bottom, left->right masked, OR NOT dest. */
/* #define M8BMODLR_ND M8BMOH_ND */
/* Horizontal left->right masked, OR NOT dest. */
void M8BMOH_ND(void)
{
	int i;
	byte lclMask;

	lclMask = lclPortMask & lclPenColor;	/* we'll leave all
											masked-off bits unchanged */
	for (i = 0; i <= majorAxisLengthM1; i++)
	{
		dstPtr = (byte *) *rowTablePtr[0] + dRect.Xmin;
		*dstPtr = (*dstPtr ^ lclPortMask) | lclMask;
		dRect.Xmin++;
		errTermL += errTermAdjUpL;
		if (errTermL >= 0)
		{	/* minor axis advance */
			errTermL -= errTermAdjDownL;
			rowTablePtr[0]++;
		}
	}

	return;
}


/* X major top->bottom, right->left masked, OR NOT dest. */
/* #define M8BMOXMRL_ND M8BMODRL_ND */
/* Diagonal top->bottom, right->left masked, OR NOT dest. */
void M8BMODRL_ND(void)
{
	int i;
	byte lclMask;

	lclMask = lclPortMask & lclPenColor;	/* we'll leave all
											masked-off bits unchanged */
	for (i = 0; i <= majorAxisLengthM1; i++)
	{
		dstPtr = (byte *) *rowTablePtr[0] + dRect.Xmin;
		*dstPtr = (*dstPtr ^ lclPortMask) | lclMask;
		dRect.Xmin--;
		errTermL += errTermAdjUpL;
		if (errTermL >= 0)
		{	/* minor axis advance */
			errTermL -= errTermAdjDownL;
			rowTablePtr[0]++;
		}
	}

	return;
}


/* Y major top->bottom, left->right masked, AND. */
/* #define M8BMAYMLR M8BMAV */
/* Y major top->bottom, vertical masked, AND. */
void M8BMAV(void)
{
	int i;
	byte lclMask;

	lclMask = (~lclPortMask) | lclPenColor;	/* we'll leave all
											masked-off bits unchanged */
	for (i = 0; i <= majorAxisLengthM1; i++)
	{
		dstPtr = (byte *) *rowTablePtr[0] + dRect.Xmin;
		*dstPtr = (*dstPtr & lclMask);
		rowTablePtr[0]++;
		errTermL += errTermAdjUpL;
		if (errTermL >= 0)
		{	/* minor axis advance */
			errTermL -= errTermAdjDownL;
			dRect.Xmin++;
		}
	}

	return;
}


/* Y major top->bottom, right->left masked, AND. */
void M8BMAYMRL(void)
{
	int i;
	byte lclMask;

	lclMask = (~lclPortMask) | lclPenColor;	/* we'll leave all
											masked-off bits unchanged */
	for (i = 0; i <= majorAxisLengthM1; i++)
	{
		dstPtr = (byte *) *rowTablePtr[0] + dRect.Xmin;
		*dstPtr = (*dstPtr & lclMask);
		rowTablePtr[0]++;
		errTermL += errTermAdjUpL;
		if (errTermL >= 0)
		{	/* minor axis advance */
			errTermL -= errTermAdjDownL;
			dRect.Xmin--;
		}
	}

	return;
}


/* X major top->bottom, left->right masked, AND. */
/* #define M8BMAXMLR M8BMAH */
/* Diagonal top->bottom, left->right masked, AND. */
/* #define M8BMADLR M8BMAH */
/* Horizontal left->right masked, AND. */
void M8BMAH(void)
{
	int i;
	byte lclMask;

	lclMask = (~lclPortMask) | lclPenColor;	/* we'll leave all
											masked-off bits unchanged */
	for (i = 0; i <= majorAxisLengthM1; i++)
	{
		dstPtr = (byte *) *rowTablePtr[0] + dRect.Xmin;
		*dstPtr = (*dstPtr & lclMask);
		dRect.Xmin++;
		errTermL += errTermAdjUpL;
		if (errTermL >= 0)
		{	/* minor axis advance */
			errTermL -= errTermAdjDownL;
			rowTablePtr[0]++;
		}
	}

	return;
}


/* X major top->bottom, right->left masked, AND. */
/* #define M8BMAXMRL M8BMADRL */
/* Diagonal top->bottom, right->left masked, AND. */
void M8BMADRL(void)
{
	int i;
	byte lclMask;

	lclMask = (~lclPortMask) | lclPenColor;	/* we'll leave all
											masked-off bits unchanged */
	for (i = 0; i <= majorAxisLengthM1; i++)
	{
		dstPtr = (byte *) *rowTablePtr[0] + dRect.Xmin;
		*dstPtr = (*dstPtr & lclMask);
		dRect.Xmin--;
		errTermL += errTermAdjUpL;
		if (errTermL >= 0)
		{	/* minor axis advance */
			errTermL -= errTermAdjDownL;
			rowTablePtr[0]++;
		}
	}

	return;
}


/* Y major top->bottom, left->right masked, AND NOT dest. */
/* #define M8BMAYMLR_ND M8BMAV_ND */
/* Y major top->bottom, vertical masked, AND NOT dest. */
void M8BMAV_ND(void)
{
	int i;
	byte lclMask;

	lclMask = (~lclPortMask) | lclPenColor;	/* we'll leave all
											masked-off bits unchanged */
	for (i = 0; i <= majorAxisLengthM1; i++)
	{
		dstPtr = (byte *) *rowTablePtr[0] + dRect.Xmin;
		*dstPtr = (*dstPtr ^ lclPortMask) & lclMask;
		rowTablePtr[0]++;
		errTermL += errTermAdjUpL;
		if (errTermL >= 0)
		{	/* minor axis advance */
			errTermL -= errTermAdjDownL;
			dRect.Xmin++;
		}
	}

	return;
}


/* Y major top->bottom, right->left masked, AND NOT dest. */
void M8BMAYMRL_ND(void)
{
	int i;
	byte lclMask;

	lclMask = (~lclPortMask) | lclPenColor;	/* we'll leave all
											masked-off bits unchanged */
	for (i = 0; i <= majorAxisLengthM1; i++)
	{
		dstPtr = (byte *) *rowTablePtr[0] + dRect.Xmin;
		*dstPtr = (*dstPtr ^ lclPortMask) & lclMask;
		rowTablePtr[0]++;
		errTermL += errTermAdjUpL;
		if (errTermL >= 0)
		{	/* minor axis advance */
			errTermL -= errTermAdjDownL;
			dRect.Xmin--;
		}
	}

	return;
}


/* X major top->bottom, left->right masked, AND NOT dest. */
/* #define M8BMAXMLR_ND M8BMAH_ND */
/* Diagonal top->bottom, left->right masked, AND NOT dest. */
/* #define M8BMADLR_ND M8BMAH_ND */
/* Horizontal left->right masked, AND NOT dest. */
void M8BMAH_ND(void)
{
	int i;
	byte lclMask;

	lclMask = (~lclPortMask) | lclPenColor;	/* we'll leave all
											masked-off bits unchanged */
	for (i = 0; i <= majorAxisLengthM1; i++)
	{
		dstPtr = (byte *) *rowTablePtr[0] + dRect.Xmin;
		*dstPtr = (*dstPtr ^ lclPortMask) & lclMask;
		dRect.Xmin++;
		errTermL += errTermAdjUpL;
		if (errTermL >= 0)
		{	/* minor axis advance */
			errTermL -= errTermAdjDownL;
			rowTablePtr[0]++;
		}
	}

	return;
}


/* X major top->bottom, right->left masked, AND NOT dest. */
/* #define M8BMAXMRL_ND M8BMADRL_ND */
/* Diagonal top->bottom, right->left masked, AND NOT dest. */
void M8BMADRL_ND(void)
{
	int i;
	byte lclMask;

	lclMask = (~lclPortMask) | lclPenColor;	/* we'll leave all
											masked-off bits unchanged */
	for (i = 0; i <= majorAxisLengthM1; i++)
	{
		dstPtr = (byte *) *rowTablePtr[0] + dRect.Xmin;
		*dstPtr = (*dstPtr ^ lclPortMask) & lclMask;
		dRect.Xmin--;
		errTermL += errTermAdjUpL;
		if (errTermL >= 0)
		{	/* minor axis advance */
			errTermL -= errTermAdjDownL;
			rowTablePtr[0]++;
		}
	}

	return;
}
上一页 1 23
⌨️ 快捷键说明

复制代码 Ctrl + C
搜索代码 Ctrl + F
全屏模式 F11
切换主题 Ctrl + Shift + D
显示快捷键 ?
增大字号 Ctrl + =
减小字号 Ctrl + -