/*
** Macros and externs used by genline.c
*/
extern ULONG FASTCALL __fastLineComputeColorRGB4(__GLcontext *gc, __GLcolor *color);
extern ULONG FASTCALL __fastLineComputeColorRGB8(__GLcontext *gc, __GLcolor *color);
extern ULONG FASTCALL __fastLineComputeColorRGB(__GLcontext *gc, __GLcolor *color);
extern ULONG FASTCALL __fastLineComputeColorCI4and8(__GLcontext *gc, __GLcolor *color);
extern ULONG FASTCALL __fastLineComputeColorCI(__GLcontext *gc, __GLcolor *color);
extern void FASTCALL __fastGenLineBegin(__GLcontext *gc);
extern void FASTCALL __fastGenLineEnd(__GLcontext *gc);
extern void FASTCALL __fastGenLine(__GLcontext *gc, __GLvertex *v0,
__GLvertex *v1, GLuint flags);
extern void FASTCALL __fastGenLineWide(__GLcontext *gc, __GLvertex *v0,
__GLvertex *v1, GLuint flags);
BOOL FASTCALL __fastGenLineSetupDisplay(__GLcontext *gc);
void FASTCALL __glQueryLineAcceleration(__GLcontext *gc);
BOOL FASTCALL __glGenSetupEitherLines(__GLcontext *gc);
/*
** float-to-fix macro converts floats to 28.4
*/
#define __FAST_LINE_FLTTOFIX(x) ((long)((x) * 16.0f))
// Converts a floating-point coordinate to an appropriate device coordinate
#ifdef _CLIENTSIDE_
#define __FAST_LINE_FLTTODEV(x) ((long)(x))
#define __FAST_LINE_UNIT_VALUE 1
#else
#define __FAST_LINE_FLTTODEV(x) __FAST_LINE_FLTTOFIX(x)
#define __FAST_LINE_UNIT_VALUE 16
#endif
/*
** line-stroking macros for DIB surfaces
*/
#ifdef NT_NO_BUFFER_INVARIANCE
BOOL FASTCALL __fastGenLineSetupDIB(__GLcontext *gc);
/*
** __FAST_LINE_STROKE_DIB
**
** Strokes a thin solid line into a DIB surface. Performs scissoring.
** Works for 8, 16, and 32 BPP
**
*/
#define __FAST_LINE_STROKE_DIB \
{ \
len = gc->line.options.numPixels; \
fraction = gc->line.options.fraction; \
dfraction = gc->line.options.dfraction; \
\
if (!gc->transform.reasonableViewport) { \
GLint clipX0, clipX1, clipY0, clipY1; \
GLint xStart, yStart, xEnd, yEnd; \
GLint xLittle, yLittle, xBig, yBig; \
GLint highWord, lowWord, bigs, littles; \
\
clipX0 = gc->transform.clipX0; \
clipX1 = gc->transform.clipX1; \
clipY0 = gc->transform.clipY0; \
clipY1 = gc->transform.clipY1; \
\
xBig = gc->line.options.xBig; \
yBig = gc->line.options.yBig; \
\
xStart = gc->line.options.xStart; \
yStart = gc->line.options.yStart; \
\
/* If the start point is in the scissor region, we attempt to \
** trivially accept the line. \
*/ \
if (xStart >= clipX0 && xStart < clipX1 && \
yStart >= clipY0 && yStart < clipY1) { \
\
len--; /* Makes our math simpler */ \
/* Trivial accept attempt */ \
xEnd = xStart + xBig * len; \
yEnd = yStart + yBig * len; \
if (xEnd >= clipX0 && xEnd < clipX1 && \
yEnd >= clipY0 && yEnd < clipY1) { \
len++; \
goto no_scissor; \
} \
\
xLittle = gc->line.options.xLittle; \
yLittle = gc->line.options.yLittle; \
\
/* \
** Invert negative minor slopes so we can assume \
** dfraction > 0 \
*/ \
if (dfraction < 0) { \
dfraction = -dfraction; \
fraction = 0x7fffffff - fraction; \
} \
\
/* Now we compute number of littles and bigs in this line */\
\
/* We perform a 16 by 32 bit multiply. Ugh. */ \
highWord = (((GLuint) dfraction) >> 16) * len + \
(((GLuint) fraction) >> 16); \
lowWord = (dfraction & 0xffff) * len + (fraction & 0xffff); \
highWord += (((GLuint) lowWord) >> 16); \
bigs = ((GLuint) highWord) >> 15; \
littles = len - bigs; \
\
/* Second trivial accept attempt */ \
xEnd = xStart + xBig*bigs + xLittle*littles; \
yEnd = yStart + yBig*bigs + yLittle*littles; \
if (xEnd >= clipX0 && xEnd < clipX1 && \
yEnd >= clipY0 && yEnd < clipY1) { \
len++; \
goto no_scissor; \
} \
len++; /* Restore len */ \
} else { \
xLittle = gc->line.options.xLittle; \
yLittle = gc->line.options.yLittle; \
} \
\
/* \
** The line needs to be scissored. \
** Well, it should only happen rarely, so we can afford \
** to make it slow. We achieve this by tediously stippling the \
** line. (rather than clipping it, of course, which would be \
** faster but harder). \
*/ \
\
if (!((GLuint)cfb->buf.other & NO_CLIP)) { \
RECTL rcl; \
\
xEnd = x + xBig * (len - 1); \
yEnd = y + yBig * (len - 1); \
\
if (x < xEnd) { \
rcl.left = x; \
rcl.right = xEnd + 1; \
} else { \
rcl.left = xEnd; \
rcl.right = x + 1; \
} \
if (y < yEnd) { \
rcl.top = y; \
rcl.bottom = yEnd + 1; \
} else { \
rcl.top = yEnd; \
rcl.bottom = y + 1; \
} \
switch (wglRectVisible(&rcl)) { \
case WGL_RECT_ALL: \
goto scissor_no_complex; \
break; \
case WGL_RECT_NONE: \
goto no_draw; \
break; \
} \
\
/* Line is partially visible, check each pixel */ \
\
while (--len >= 0) { \
if (wglPixelVisible(x, y) && \
xStart >= clipX0 && xStart < clipX1 && \
yStart >= clipY0 && yStart < clipY1) { \
*addr = pixel; \
} \
fraction += dfraction; \
if (fraction < 0) { \
fraction &= ~0x80000000; \
x += xBig; \
y += yBig; \
xStart += xBig; \
yStart += yBig; \
addr += addrBig; \
} else { \
x += xLittle; \
y += yLittle; \
xStart += xLittle; \
yStart += yLittle; \
addr += addrLittle; \
} \
} \
} else { \
scissor_no_complex: \
while (--len >= 0) { \
if (xStart >= clipX0 && xStart < clipX1 && \
yStart >= clipY0 && yStart < clipY1) { \
*addr = pixel; \
} \
fraction += dfraction; \
if (fraction < 0) { \
fraction &= ~0x80000000; \
xStart += xBig; \
yStart += yBig; \
addr += addrBig; \
} else { \
xStart += xLittle; \
yStart += yLittle; \
addr += addrLittle; \
} \
} \
} \
} else { \
no_scissor: \
if (!((GLuint)cfb->buf.other & NO_CLIP)) { \
RECTL rcl; \
GLint xEnd, yEnd, xBig, yBig, xLittle, yLittle; \
\
xBig = gc->line.options.xBig; \
yBig = gc->line.options.yBig; \
xLittle = gc->line.options.xLittle; \
yLittle = gc->line.options.yLittle; \
\
xEnd = x + xBig * (len - 1); \
yEnd = y + yBig * (len - 1); \
\
if (x < xEnd) { \
rcl.left = x; \
rcl.right = xEnd + 1; \
} else { \
rcl.left = xEnd; \
rcl.right = x + 1; \
} \
if (y < yEnd) { \
rcl.top = y; \
rcl.bottom = yEnd + 1; \
} else { \
rcl.top = yEnd; \
rcl.bottom = y + 1; \
} \
switch (wglRectVisible(&rcl)) { \
case WGL_RECT_ALL: \
goto no_complex; \
break; \
case WGL_RECT_NONE: \
goto no_draw; \
break; \
} \
\
/* Line is partially visible, check each pixel */ \
\
while (--len >= 0) { \
if (wglPixelVisible(x, y)) \
*addr = pixel; \
\
fraction += dfraction; \
if (fraction < 0) { \
fraction &= ~0x80000000; \
x += xBig; \
y += yBig; \
addr += addrBig; \
} else { \
x += xLittle; \
y += yLittle; \
addr += addrLittle; \
} \
} \
} else { \
no_complex: \
while (--len >= 0) { \
*addr = pixel; \
\
fraction += dfraction; \
if (fraction < 0) { \
fraction &= ~0x80000000; \
addr += addrBig; \
} else { \
addr += addrLittle; \
} \
} \
} \
} \
no_draw:; \
}
/*
** __FAST_LINE_STROKE_DIB24
**
** Strokes a thin solid line into a DIB surface. Performs scissoring.
** Works for 24 BPP
**
*/
#define __FAST_LINE_STROKE_DIB24 \
{ \
len = gc->line.options.numPixels; \
fraction = gc->line.options.fraction; \
dfraction = gc->line.options.dfraction; \
\
if (!gc->transform.reasonableViewport) { \
GLint clipX0, clipX1, clipY0, clipY1; \
GLint xStart, yStart, xEnd, yEnd; \
GLint xLittle, yLittle, xBig, yBig; \
GLint highWord, lowWord, bigs, littles; \
\
clipX0 = gc->transform.clipX0; \
clipX1 = gc->transform.clipX1; \
clipY0 = gc->transform.clipY0; \
clipY1 = gc->transform.clipY1; \
\
xBig = gc->line.options.xBig; \
yBig = gc->line.options.yBig; \
\
xStart = gc->line.options.xStart; \
yStart = gc->line.options.yStart; \
\
/* If the start point is in the scissor region, we attempt to \
** trivially accept the line. \
*/ \
if (xStart >= clipX0 && xStart < clipX1 && \
yStart >= clipY0 && yStart < clipY1) { \
\
len--; /* Makes our math simpler */ \
/* Trivial accept attempt */ \
xEnd = xStart + xBig * len; \
yEnd = yStart + yBig * len; \
if (xEnd >= clipX0 && xEnd < clipX1 && \
yEnd >= clipY0 && yEnd < clipY1) { \
len++; \
goto no_scissor; \
} \
\
xLittle = gc->line.options.xLittle; \
yLittle = gc->line.options.yLittle; \
\
/* \
** Invert negative minor slopes so we can assume \
** dfraction > 0 \
*/ \
if (dfraction < 0) { \
dfraction = -dfraction; \
fraction = 0x7fffffff - fraction; \
} \
\
/* Now we compute number of littles and bigs in this line */\
\
/* We perform a 16 by 32 bit multiply. Ugh. */ \
highWord = (((GLuint) dfraction) >> 16) * len + \
(((GLuint) fraction) >> 16); \
lowWord = (dfraction & 0xffff) * len + (fraction & 0xffff); \
highWord += (((GLuint) lowWord) >> 16); \
bigs = ((GLuint) highWord) >> 15; \
littles = len - bigs; \
\
/* Second trivial accept attempt */ \
xEnd = xStart + xBig*bigs + xLittle*littles; \
yEnd = yStart + yBig*bigs + yLittle*littles; \
if (xEnd >= clipX0 && xEnd < clipX1 && \
yEnd >= clipY0 && yEnd < clipY1) { \
len++; \
goto no_scissor; \
} \
len++; /* Restore len */ \
} else { \
xLittle = gc->line.options.xLittle; \
yLittle = gc->line.options.yLittle; \
} \
\
/* \
** The line needs to be scissored. \
** Well, it should only happen rarely, so we can afford \
** to make it slow. We achieve this by tediously stippling the \
** line. (rather than clipping it, of course, which would be \
** faster but harder). \
*/ \
\
if (!((GLuint)cfb->buf.other & NO_CLIP)) { \
RECTL rcl; \
\
xEnd = x + xBig * (len - 1); \
yEnd = y + yBig * (len - 1); \
\
if (x < xEnd) { \
rcl.left = x; \
rcl.right = xEnd + 1; \
} else { \
rcl.left = xEnd; \
rcl.right = x + 1; \
} \
if (y < yEnd) { \
rcl.top = y; \
rcl.bottom = yEnd + 1; \
} else { \
rcl.top = yEnd; \
rcl.bottom = y + 1; \
} \
switch (wglRectVisible(&rcl)) { \
case WGL_RECT_ALL: \
goto scissor_no_complex; \
break; \
case WGL_RECT_NONE: \
goto no_draw; \
break; \
} \
\
/* Line is partially visible, check each pixel */ \
\
while (--len >= 0) { \
if (wglPixelVisible(x, y) && \
xStart >= clipX0 && xStart < clipX1 && \
yStart >= clipY0 && yStart < clipY1) { \
addr[0] = ir; \
addr[1] = ig; \
addr[2] = ib; \
} \
fraction += dfraction; \
if (fraction < 0) { \
fraction &= ~0x80000000; \
x += xBig; \
y += yBig; \
xStart += xBig; \
yStart += yBig; \
addr += addrBig; \
} else { \
x += xLittle; \
y += yLittle; \
xStart += xLittle; \
yStart += yLittle; \
addr += addrLittle; \
} \
} \
} else { \
scissor_no_complex: \
while (--len >= 0) { \
if (xStart >= clipX0 && xStart < clipX1 && \
yStart >= clipY0 && yStart < clipY1) { \
addr[0] = ir; \
addr[1] = ig; \
addr[2] = ib; \
} \
fraction += dfraction; \
if (fraction < 0) { \
fraction &= ~0x80000000; \
xStart += xBig; \
yStart += yBig; \
addr += addrBig; \
} else { \
xStart += xLittle; \
yStart += yLittle; \
addr += addrLittle; \
} \
} \
} \
} else { \
no_scissor: \
if (!((GLuint)cfb->buf.other & NO_CLIP)) { \
RECTL rcl; \
GLint xEnd, yEnd, xBig, yBig, xLittle, yLittle; \
\
xBig = gc->line.options.xBig; \
yBig = gc->line.options.yBig; \
xLittle = gc->line.options.xLittle; \
yLittle = gc->line.options.yLittle; \
\
xEnd = x + xBig * (len - 1); \
yEnd = y + yBig * (len - 1); \
\
if (x < xEnd) { \
rcl.left = x; \
rcl.right = xEnd + 1; \
} else { \
rcl.left = xEnd; \
rcl.right = x + 1; \
} \
if (y < yEnd) { \
rcl.top = y; \
rcl.bottom = yEnd + 1; \
} else { \
rcl.top = yEnd; \
rcl.bottom = y + 1; \
} \
switch (wglRectVisible(&rcl)) { \
case WGL_RECT_ALL: \
goto no_complex; \
break; \
case WGL_RECT_NONE: \
goto no_draw; \
break; \
} \
\
/* Line is partially visible, check each pixel */ \
\
while (--len >= 0) { \
if (wglPixelVisible(x, y)) { \
addr[0] = ir; \
addr[1] = ig; \
addr[2] = ib; \
} \
fraction += dfraction; \
if (fraction < 0) { \
fraction &= ~0x80000000; \
addr += addrBig; \
} else { \
addr += addrLittle; \
} \
} \
} else { \
no_complex: \
while (--len >= 0) { \
addr[0] = ir; \
addr[1] = ig; \
addr[2] = ib; \
fraction += dfraction; \
if (fraction < 0) { \
fraction &= ~0x80000000; \
addr += addrBig; \
} else { \
addr += addrLittle; \
} \
} \
} \
} \
no_draw:; \
}
/*
** __FAST_LINE_STROKE_DIB_WIDE
**
** Strokes a wide solid line into a DIB surface. Performs scissoring.
** Works for 8, 16, and 32 BPP
**
*/
#define __FAST_LINE_STROKE_DIB_WIDE \
{ \
len = gc->line.options.numPixels; \
fraction = gc->line.options.fraction; \
dfraction = gc->line.options.dfraction; \
\
/* \
** Since one or more of the strokes of a wide line may lie outside \
** the viewport, wide lines always go through the scissoring checks \
*/ \
{ \
GLint clipX0, clipX1, clipY0, clipY1; \
GLint xStart, yStart, xEnd, yEnd; \
GLint xLittle, yLittle, xBig, yBig; \
GLint highWord, lowWord, bigs, littles; \
\
clipX0 = gc->transform.clipX0; \
clipX1 = gc->transform.clipX1; \
clipY0 = gc->transform.clipY0; \
clipY1 = gc->transform.clipY1; \
\
xBig = gc->line.options.xBig; \
yBig = gc->line.options.yBig; \
\
xStart = gc->line.options.xStart; \
yStart = gc->line.options.yStart; \
\
/* If the start point is in the scissor region, we attempt to \
** trivially accept the line. \
*/ \
if (xStart >= clipX0 && xStart < clipX1 && \
yStart >= clipY0 && yStart < clipY1) { \
\
len--; /* Makes our math simpler */ \
width--; \
/* Trivial accept attempt */ \
xEnd = xStart + xBig * len; \
yEnd = yStart + yBig * len; \
if (xEnd >= clipX0 && xEnd < clipX1 && \
yEnd >= clipY0 && yEnd < clipY1) { \
\
if (gc->line.options.axis == __GL_X_MAJOR) { \
if (((yStart + width) >= clipY0) && \
((yStart + width) < clipY1) && \
((yEnd + width) >= clipY0) && \
((yEnd + width) < clipY1)) { \
\
len++; \
width++; \
goto no_scissor; \
} \
} else { \
if (((xStart + width) >= clipX0) && \
((xStart + width) < clipX1) && \
((xEnd + width) >= clipX0) && \
((xEnd + width) < clipX1)) { \
\
len++; \
width++; \
goto no_scissor; \
} \
} \
} \
\
xLittle = gc->line.options.xLittle; \
yLittle = gc->line.options.yLittle; \
\
/* \
** Invert negative minor slopes so we can assume \
** dfraction > 0 \
*/ \
if (dfraction < 0) { \
dfraction = -dfraction; \
fraction = 0x7fffffff - fraction; \
} \
\
/* Now we compute number of littles and bigs in this line */\
\
/* We perform a 16 by 32 bit multiply. Ugh. */ \
highWord = (((GLuint) dfraction) >> 16) * len + \
(((GLuint) fraction) >> 16); \
lowWord = (dfraction & 0xffff) * len + (fraction & 0xffff); \
highWord += (((GLuint) lowWord) >> 16); \
bigs = ((GLuint) highWord) >> 15; \
littles = len - bigs; \
\
/* Second trivial accept attempt */ \
xEnd = xStart + xBig*bigs + xLittle*littles; \
yEnd = yStart + yBig*bigs + yLittle*littles; \
if (xEnd >= clipX0 && xEnd < clipX1 && \
yEnd >= clipY0 && yEnd < clipY1) { \
\
if (gc->line.options.axis == __GL_X_MAJOR) { \
if (((yStart + width) >= clipY0) && \
((yStart + width) < clipY1) && \
((yEnd + width) >= clipY0) && \
((yEnd + width) < clipY1)) { \
\
len++; \
width++; \
goto no_scissor; \
} \
} else { \
if (((xStart + width) >= clipX0) && \
((xStart + width) < clipX1) && \
((xEnd + width) >= clipX0) && \
((xEnd + width) < clipX1)) { \
\
len++; \
width++; \
goto no_scissor; \
} \
} \
} \
len++; /* Restore len and width */ \
width++; \
} else { \
xLittle = gc->line.options.xLittle; \
yLittle = gc->line.options.yLittle; \
} \
\
/* \
** The line needs to be scissored. \
** Well, it should only happen rarely, so we can afford \
** to make it slow. We achieve this by tediously stippling the \
** line. (rather than clipping it, of course, which would be \
** faster but harder). \
*/ \
\
if (gc->line.options.axis == __GL_X_MAJOR) { \
GLint yTmp0; \
\
if (!((GLuint)cfb->buf.other & NO_CLIP)) { \
RECTL rcl; \
GLint yTmp1; \
\
xEnd = x + xBig * (len - 1); \
yEnd = y + yBig * (len - 1); \
\
if (x < xEnd) { \
rcl.left = x; \
rcl.right = xEnd + 1; \
} else { \
rcl.left = xEnd; \
rcl.right = x + 1; \
} \
if (y < yEnd) { \
rcl.top = y; \
rcl.bottom = yEnd + width; \
} else { \
rcl.top = yEnd; \
rcl.bottom = y + width; \
} \
switch (wglRectVisible(&rcl)) { \
case WGL_RECT_ALL: \
goto scissor_x_no_complex; \
break; \
case WGL_RECT_NONE: \
goto no_draw; \
break; \
} \
\
/* Line is partially visible, check each pixel */ \
\
while (--len >= 0) { \
if (xStart >= clipX0 && xStart < clipX1) { \
yTmp0 = yStart; \
yTmp1 = y; \
w = width; \
while (--w >= 0) { \
if (wglPixelVisible(x, yTmp1) && \
yTmp0 >= clipY0 && yTmp0 < clipY1) { \
*addr = pixel; \
} \
addr += addrMinor; \
yTmp0++; \
yTmp1++; \
} \
} else { \
addr += addrMinor * width; \
} \
fraction += dfraction; \
if (fraction < 0) { \
fraction &= ~0x80000000; \
x += xBig; \
y += yBig; \
xStart += xBig; \
yStart += yBig; \
addr += addrBig; \
} else { \
x += xLittle; \
y += yLittle; \
xStart += xLittle; \
yStart += yLittle; \
addr += addrLittle; \
} \
} \
} else { \
scissor_x_no_complex: \
while (--len >= 0) { \
if (xStart >= clipX0 && xStart < clipX1) { \
yTmp0 = yStart; \
w = width; \
while (--w >= 0) { \
if (yTmp0 >= clipY0 && yTmp0 < clipY1) { \
*addr = pixel; \
} \
addr += addrMinor; \
yTmp0++; \
} \
} else { \
addr += addrMinor * width; \
} \
fraction += dfraction; \
if (fraction < 0) { \
fraction &= ~0x80000000; \
xStart += xBig; \
yStart += yBig; \
addr += addrBig; \
} else { \
xStart += xLittle; \
yStart += yLittle; \
addr += addrLittle; \
} \
} \
} \
} else { \
GLint xTmp0; \
\
if (!((GLuint)cfb->buf.other & NO_CLIP)) { \
RECTL rcl; \
GLint xTmp1; \
\
xEnd = x + xBig * (len - 1); \
yEnd = y + yBig * (len - 1); \
\
if (x < xEnd) { \
rcl.left = x; \
rcl.right = xEnd + width; \
} else { \
rcl.left = xEnd; \
rcl.right = x + width; \
} \
if (y < yEnd) { \
rcl.top = y; \
rcl.bottom = yEnd + 1; \
} else { \
rcl.top = yEnd; \
rcl.bottom = y + 1; \
} \
switch (wglRectVisible(&rcl)) { \
case WGL_RECT_ALL: \
goto scissor_y_no_complex; \
break; \
case WGL_RECT_NONE: \
goto no_draw; \
break; \
} \
\
/* Line is partially visible, check each pixel */ \
\
while (--len >= 0) { \
if (yStart >= clipY0 && yStart < clipY1) { \
xTmp0 = xStart; \
xTmp1 = x; \
w = width; \
while (--w >= 0) { \
if (wglPixelVisible(xTmp1, y) && \
xTmp0 >= clipX0 && xTmp0 < clipX1) { \
*addr = pixel; \
} \
addr += addrMinor; \
xTmp0++; \
xTmp1++; \
} \
} else { \
addr += addrMinor * width; \
} \
fraction += dfraction; \
if (fraction < 0) { \
fraction &= ~0x80000000; \
x += xBig; \
y += yBig; \
xStart += xBig; \
yStart += yBig; \
addr += addrBig; \
} else { \
x += xLittle; \
y += yLittle; \
xStart += xLittle; \
yStart += yLittle; \
addr += addrLittle; \
} \
} \
} else { \
scissor_y_no_complex: \
while (--len >= 0) { \
if (yStart >= clipY0 && yStart < clipY1) { \
xTmp0 = xStart; \
w = width; \
while (--w >= 0) { \
if (xTmp0 >= clipX0 && xTmp0 < clipX1) { \
*addr = pixel; \
} \
addr += addrMinor; \
xTmp0++; \
} \
} else { \
addr += addrMinor * width; \
} \
fraction += dfraction; \
if (fraction < 0) { \
fraction &= ~0x80000000; \
xStart += xBig; \
yStart += yBig; \
addr += addrBig; \
} else { \
xStart += xLittle; \
yStart += yLittle; \
addr += addrLittle; \
} \
} \
} \
} \
goto no_draw; \
no_scissor: \
if (!((GLuint)cfb->buf.other & NO_CLIP)) { \
RECTL rcl; \
\
xEnd = x + xBig * (len - 1); \
yEnd = y + yBig * (len - 1); \
\
xLittle = gc->line.options.xLittle; \
yLittle = gc->line.options.yLittle; \
\
if (gc->line.options.axis == __GL_X_MAJOR) { \
GLint yTmp; \
\
if (x < xEnd) { \
rcl.left = x; \
rcl.right = xEnd + 1; \
} else { \
rcl.left = xEnd; \
rcl.right = x + 1; \
} \
if (y < yEnd) { \
rcl.top = y; \
rcl.bottom = yEnd + width; \
} else { \
rcl.top = yEnd; \
rcl.bottom = y + width; \
} \
switch (wglRectVisible(&rcl)) { \
case WGL_RECT_ALL: \
goto no_scissor_no_complex; \
break; \
case WGL_RECT_NONE: \
goto no_draw; \
break; \
} \
\
/* Line is partially visible, check each pixel */ \
\
while (--len >= 0) { \
yTmp = y; \
w = width; \
while (--w >= 0) { \
if (wglPixelVisible(x, yTmp)) { \
*addr = pixel; \
} \
addr += addrMinor; \
yTmp++; \
} \
fraction += dfraction; \
if (fraction < 0) { \
fraction &= ~0x80000000; \
x += xBig; \
y += yBig; \
addr += addrBig; \
} else { \
x += xLittle; \
y += yLittle; \
addr += addrLittle; \
} \
} \
} else { \
GLint xTmp; \
\
if (x < xEnd) { \
rcl.left = x; \
rcl.right = xEnd + width; \
} else { \
rcl.left = xEnd; \
rcl.right = x + width; \
} \
if (y < yEnd) { \
rcl.top = y; \
rcl.bottom = yEnd + 1; \
} else { \
rcl.top = yEnd; \
rcl.bottom = y + 1; \
} \
switch (wglRectVisible(&rcl)) { \
case WGL_RECT_ALL: \
goto no_scissor_no_complex; \
break; \
case WGL_RECT_NONE: \
goto no_draw; \
break; \
} \
\
/* Line is partially visible, check each pixel */ \
\
while (--len >= 0) { \
xTmp = x; \
w = width; \
while (--w >= 0) { \
if (wglPixelVisible(xTmp, y)) { \
*addr = pixel; \
} \
addr += addrMinor; \
xTmp++; \
} \
fraction += dfraction; \
if (fraction < 0) { \
fraction &= ~0x80000000; \
x += xBig; \
y += yBig; \
addr += addrBig; \
} else { \
x += xLittle; \
y += yLittle; \
addr += addrLittle; \
} \
} \
} \
} else { \
no_scissor_no_complex: \
while (--len >= 0) { \
w = width; \
while (--w >= 0) { \
*addr = pixel; \
addr += addrMinor; \
} \
fraction += dfraction; \
if (fraction < 0) { \
fraction &= ~0x80000000; \
addr += addrBig; \
} else { \
addr += addrLittle; \
} \
} \
} \
} \
no_draw:; \
}
/*
** __FAST_LINE_STROKE_DIB24_WIDE
**
** Strokes a wide solid line into a DIB surface. Performs scissoring.
** Works for 24 BPP
**
*/
#define __FAST_LINE_STROKE_DIB24_WIDE \
{ \
len = gc->line.options.numPixels; \
fraction = gc->line.options.fraction; \
dfraction = gc->line.options.dfraction; \
\
/* \
** Since one or more of the strokes of a wide line may lie outside \
** the viewport, wide lines always go through the scissoring checks \
*/ \
{ \
GLint clipX0, clipX1, clipY0, clipY1; \
GLint xStart, yStart, xEnd, yEnd; \
GLint xLittle, yLittle, xBig, yBig; \
GLint highWord, lowWord, bigs, littles; \
\
clipX0 = gc->transform.clipX0; \
clipX1 = gc->transform.clipX1; \
clipY0 = gc->transform.clipY0; \
clipY1 = gc->transform.clipY1; \
\
xBig = gc->line.options.xBig; \
yBig = gc->line.options.yBig; \
\
xStart = gc->line.options.xStart; \
yStart = gc->line.options.yStart; \
\
/* If the start point is in the scissor region, we attempt to \
** trivially accept the line. \
*/ \
if (xStart >= clipX0 && xStart < clipX1 && \
yStart >= clipY0 && yStart < clipY1) { \
\
len--; /* Makes our math simpler */ \
width--; \
/* Trivial accept attempt */ \
xEnd = xStart + xBig * len; \
yEnd = yStart + yBig * len; \
if (xEnd >= clipX0 && xEnd < clipX1 && \
yEnd >= clipY0 && yEnd < clipY1) { \
\
if (gc->line.options.axis == __GL_X_MAJOR) { \
if (((yStart + width) >= clipY0) && \
((yStart + width) < clipY1) && \
((yEnd + width) >= clipY0) && \
((yEnd + width) < clipY1)) { \
\
len++; \
width++; \
goto no_scissor; \
} \
} else { \
if (((xStart + width) >= clipX0) && \
((xStart + width) < clipX1) && \
((xEnd + width) >= clipX0) && \
((xEnd + width) < clipX1)) { \
\
len++; \
width++; \
goto no_scissor; \
} \
} \
} \
\
xLittle = gc->line.options.xLittle; \
yLittle = gc->line.options.yLittle; \
\
/* \
** Invert negative minor slopes so we can assume \
** dfraction > 0 \
*/ \
if (dfraction < 0) { \
dfraction = -dfraction; \
fraction = 0x7fffffff - fraction; \
} \
\
/* Now we compute number of littles and bigs in this line */\
\
/* We perform a 16 by 32 bit multiply. Ugh. */ \
highWord = (((GLuint) dfraction) >> 16) * len + \
(((GLuint) fraction) >> 16); \
lowWord = (dfraction & 0xffff) * len + (fraction & 0xffff); \
highWord += (((GLuint) lowWord) >> 16); \
bigs = ((GLuint) highWord) >> 15; \
littles = len - bigs; \
\
/* Second trivial accept attempt */ \
xEnd = xStart + xBig*bigs + xLittle*littles; \
yEnd = yStart + yBig*bigs + yLittle*littles; \
if (xEnd >= clipX0 && xEnd < clipX1 && \
yEnd >= clipY0 && yEnd < clipY1) { \
\
if (gc->line.options.axis == __GL_X_MAJOR) { \
if (((yStart + width) >= clipY0) && \
((yStart + width) < clipY1) && \
((yEnd + width) >= clipY0) && \
((yEnd + width) < clipY1)) { \
\
len++; \
width++; \
goto no_scissor; \
} \
} else { \
if (((xStart + width) >= clipX0) && \
((xStart + width) < clipX1) && \
((xEnd + width) >= clipX0) && \
((xEnd + width) < clipX1)) { \
\
len++; \
width++; \
goto no_scissor; \
} \
} \
} \
len++; /* Restore len and width */ \
width++; \
} else { \
xLittle = gc->line.options.xLittle; \
yLittle = gc->line.options.yLittle; \
} \
\
/* \
** The line needs to be scissored. \
** Well, it should only happen rarely, so we can afford \
** to make it slow. We achieve this by tediously stippling the \
** line. (rather than clipping it, of course, which would be \
** faster but harder). \
*/ \
\
if (gc->line.options.axis == __GL_X_MAJOR) { \
GLint yTmp0; \
\
if (!((GLuint)cfb->buf.other & NO_CLIP)) { \
RECTL rcl; \
GLint yTmp1; \
\
xEnd = x + xBig * (len - 1); \
yEnd = y + yBig * (len - 1); \
\
if (x < xEnd) { \
rcl.left = x; \
rcl.right = xEnd + 1; \
} else { \
rcl.left = xEnd; \
rcl.right = x + 1; \
} \
if (y < yEnd) { \
rcl.top = y; \
rcl.bottom = yEnd + width; \
} else { \
rcl.top = yEnd; \
rcl.bottom = y + width; \
} \
switch (wglRectVisible(&rcl)) { \
case WGL_RECT_ALL: \
goto scissor_x_no_complex; \
break; \
case WGL_RECT_NONE: \
goto no_draw; \
break; \
} \
\
/* Line is partially visible, check each pixel */ \
\
while (--len >= 0) { \
if (xStart >= clipX0 && xStart < clipX1) { \
yTmp0 = yStart; \
yTmp1 = y; \
w = width; \
while (--w >= 0) { \
if (wglPixelVisible(x, yTmp1) && \
yTmp0 >= clipY0 && yTmp0 < clipY1) { \
addr[0] = ir; \
addr[1] = ig; \
addr[2] = ib; \
} \
addr += addrMinor; \
yTmp0++; \
yTmp1++; \
} \
} else { \
addr += addrMinor * width; \
} \
fraction += dfraction; \
if (fraction < 0) { \
fraction &= ~0x80000000; \
x += xBig; \
y += yBig; \
xStart += xBig; \
yStart += yBig; \
addr += addrBig; \
} else { \
x += xLittle; \
y += yLittle; \
xStart += xLittle; \
yStart += yLittle; \
addr += addrLittle; \
} \
} \
} else { \
scissor_x_no_complex: \
while (--len >= 0) { \
if (xStart >= clipX0 && xStart < clipX1) { \
yTmp0 = yStart; \
w = width; \
while (--w >= 0) { \
if (yTmp0 >= clipY0 && yTmp0 < clipY1) { \
addr[0] = ir; \
addr[1] = ig; \
addr[2] = ib; \
} \
addr += addrMinor; \
yTmp0++; \
} \
} else { \
addr += addrMinor * width; \
} \
fraction += dfraction; \
if (fraction < 0) { \
fraction &= ~0x80000000; \
xStart += xBig; \
yStart += yBig; \
addr += addrBig; \
} else { \
xStart += xLittle; \
yStart += yLittle; \
addr += addrLittle; \
} \
} \
} \
} else { \
GLint xTmp0; \
\
if (!((GLuint)cfb->buf.other & NO_CLIP)) { \
RECTL rcl; \
GLint xTmp1; \
\
xEnd = x + xBig * (len - 1); \
yEnd = y + yBig * (len - 1); \
\
if (x < xEnd) { \
rcl.left = x; \
rcl.right = xEnd + width; \
} else { \
rcl.left = xEnd; \
rcl.right = x + width; \
} \
if (y < yEnd) { \
rcl.top = y; \
rcl.bottom = yEnd + 1; \
} else { \
rcl.top = yEnd; \
rcl.bottom = y + 1; \
} \
switch (wglRectVisible(&rcl)) { \
case WGL_RECT_ALL: \
goto scissor_y_no_complex; \
break; \
case WGL_RECT_NONE: \
goto no_draw; \
break; \
} \
\
/* Line is partially visible, check each pixel */ \
\
while (--len >= 0) { \
if (yStart >= clipY0 && yStart < clipY1) { \
xTmp0 = xStart; \
xTmp1 = x; \
w = width; \
while (--w >= 0) { \
if (wglPixelVisible(xTmp1, y) && \
xTmp0 >= clipX0 && xTmp0 < clipX1) { \
addr[0] = ir; \
addr[1] = ig; \
addr[2] = ib; \
} \
addr += addrMinor; \
xTmp0++; \
xTmp1++; \
} \
} else { \
addr += addrMinor * width; \
} \
fraction += dfraction; \
if (fraction < 0) { \
fraction &= ~0x80000000; \
x += xBig; \
y += yBig; \
xStart += xBig; \
yStart += yBig; \
addr += addrBig; \
} else { \
x += xLittle; \
y += yLittle; \
xStart += xLittle; \
yStart += yLittle; \
addr += addrLittle; \
} \
} \
} else { \
scissor_y_no_complex: \
while (--len >= 0) { \
if (yStart >= clipY0 && yStart < clipY1) { \
xTmp0 = xStart; \
w = width; \
while (--w >= 0) { \
if (xTmp0 >= clipX0 && xTmp0 < clipX1) { \
addr[0] = ir; \
addr[1] = ig; \
addr[2] = ib; \
} \
addr += addrMinor; \
xTmp0++; \
} \
} else { \
addr += addrMinor * width; \
} \
fraction += dfraction; \
if (fraction < 0) { \
fraction &= ~0x80000000; \
xStart += xBig; \
yStart += yBig; \
addr += addrBig; \
} else { \
xStart += xLittle; \
yStart += yLittle; \
addr += addrLittle; \
} \
} \
} \
} \
goto no_draw; \
no_scissor: \
if (!((GLuint)cfb->buf.other & NO_CLIP)) { \
RECTL rcl; \
\
xLittle = gc->line.options.xLittle; \
yLittle = gc->line.options.yLittle; \
\
if (gc->line.options.axis == __GL_X_MAJOR) { \
GLint yTmp; \
\
if (x < xEnd) { \
rcl.left = x; \
rcl.right = xEnd + 1; \
} else { \
rcl.left = xEnd; \
rcl.right = x + 1; \
} \
if (y < yEnd) { \
rcl.top = y; \
rcl.bottom = yEnd + width; \
} else { \
rcl.top = yEnd; \
rcl.bottom = y + width; \
} \
switch (wglRectVisible(&rcl)) { \
case WGL_RECT_ALL: \
goto no_scissor_no_complex; \
break; \
case WGL_RECT_NONE: \
goto no_draw; \
break; \
} \
\
/* Line is partially visible, check each pixel */ \
\
while (--len >= 0) { \
yTmp = y; \
w = width; \
while (--w >= 0) { \
if (wglPixelVisible(x, yTmp)) { \
addr[0] = ir; \
addr[1] = ig; \
addr[2] = ib; \
} \
addr += addrMinor; \
yTmp++; \
} \
fraction += dfraction; \
if (fraction < 0) { \
fraction &= ~0x80000000; \
x += xBig; \
y += yBig; \
addr += addrBig; \
} else { \
x += xLittle; \
y += yLittle; \
addr += addrLittle; \
} \
} \
} else { \
GLint xTmp; \
\
if (x < xEnd) { \
rcl.left = x; \
rcl.right = xEnd + width; \
} else { \
rcl.left = xEnd; \
rcl.right = x + width; \
} \
if (y < yEnd) { \
rcl.top = y; \
rcl.bottom = yEnd + 1; \
} else { \
rcl.top = yEnd; \
rcl.bottom = y + 1; \
} \
switch (wglRectVisible(&rcl)) { \
case WGL_RECT_ALL: \
goto no_scissor_no_complex; \
break; \
case WGL_RECT_NONE: \
goto no_draw; \
break; \
} \
\
/* Line is partially visible, check each pixel */ \
\
while (--len >= 0) { \
xTmp = x; \
w = width; \
while (--w >= 0) { \
if (wglPixelVisible(xTmp, y)) { \
addr[0] = ir; \
addr[1] = ig; \
addr[2] = ib; \
} \
addr += addrMinor; \
xTmp++; \
} \
fraction += dfraction; \
if (fraction < 0) { \
fraction &= ~0x80000000; \
x += xBig; \
y += yBig; \
addr += addrBig; \
} else { \
x += xLittle; \
y += yLittle; \
addr += addrLittle; \
} \
} \
} \
} else { \
no_scissor_no_complex: \
while (--len >= 0) { \
w = width; \
while (--w >= 0) { \
addr[0] = ir; \
addr[1] = ig; \
addr[2] = ib; \
addr += addrMinor; \
} \
fraction += dfraction; \
if (fraction < 0) { \
fraction &= ~0x80000000; \
addr += addrBig; \
} else { \
addr += addrLittle; \
} \
} \
} \
} \
no_draw:; \
}
#endif // NT_NO_BUFFER_INVARIANCE