archive
/
windows-server-2003
mirror of https://github.com/selfrender/Windows-Server-2003
2
0
Fork 0
Code Issues Projects Releases Wiki Activity
Leaked source code of windows server 2003
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
4 Commits
1 Branch
0 Tags
1.5 GiB
 
 
 
 
 
 
Branch: master
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from 'master'
${ noResults }
windows-server-2003/multimedia/opengl/server/generic/genaline.c

2341 lines
72 KiB
Raw Permalink Blame History

/******************************Module*Header*******************************\
* Module Name: genaline.c *
* *
* This module provides accelerated interpolated line support. *
* *
* Created: 8-Dec-1995 *
* Author: Otto Berkes [ottob] *
* *
* 23-Jan-1996 Drew Bliss [drewb] *
* Cut down antialiasing code to provide aliased versions *
* Optimized line setup *
* *
* Copyright (c) 1995-1996 Microsoft Corporation *
\**************************************************************************/
#include "precomp.h"
#pragma hdrstop
// #define DO_CHECK_PIXELS
#ifdef _X86_
#include <gli386.h>
#endif
#include "genline.h"
#ifndef NO_COMPILER_BUG
#undef __GL_FLOAT_SIMPLE_BEGIN_DIVIDE
#undef __GL_FLOAT_SIMPLE_END_DIVIDE
#define __GL_FLOAT_SIMPLE_BEGIN_DIVIDE(a, b, c) \
__GL_FLOAT_BEGIN_DIVIDE(a, b, &(c))
#define __GL_FLOAT_SIMPLE_END_DIVIDE(r) \
__GL_FLOAT_END_DIVIDE(&(r))
#endif
// Also used by soft line code
BOOL FASTCALL __glInitLineData(__GLcontext *gc, __GLvertex *v0, __GLvertex *v1)
{
GLint start, end;
__GLfloat x0,y0,x1,y1;
__GLfloat minorStart;
__GLfloat fdx, fdy;
__GLfloat offset;
__GLfloat slope;
__GLlineState *ls = &gc->state.line;
__GLfloat halfWidth;
GLint x0frac, x1frac, y0frac, y1frac, totDist;
GLint ix0, ix1, iy0, iy1, idx, idy;
__GLcolorBuffer *cfb = gc->drawBuffer;
ASSERT_CHOP_ROUND();
gc->line.options.v0 = v0;
gc->line.options.v1 = v1;
gc->line.options.width = ls->aliasedWidth;
x0 = v0->window.x;
y0 = v0->window.y;
x1 = v1->window.x;
y1 = v1->window.y;
#ifdef DO_CHECK_PIXELS
if (x0 < gc->transform.fminx || x0 >= gc->transform.fmaxx ||
y0 < gc->transform.fminy || y0 >= gc->transform.fmaxy ||
x1 < gc->transform.fminx || x1 >= gc->transform.fmaxx ||
y1 < gc->transform.fminy || y1 >= gc->transform.fmaxy)
{
DbgPrint("Line coordinates out %.3lf,%.3lf - %.3lf,%.3lf%s\n",
x0, y0, x1, y1,
!gc->transform.reasonableViewport ? " (unreasonable)" : "");
}
#endif
fdx = x1-x0;
fdy = y1-y0;
halfWidth = (ls->aliasedWidth - 1) * __glHalf;
ix0 = __GL_VERTEX_FLOAT_TO_INT(x0);
x0frac = __GL_VERTEX_FLOAT_FRACTION(x0);
iy0 = __GL_VERTEX_FLOAT_TO_INT(y0);
y0frac = __GL_VERTEX_FLOAT_FRACTION(y0);
ix1 = __GL_VERTEX_FLOAT_TO_INT(x1);
x1frac = __GL_VERTEX_FLOAT_FRACTION(x1);
iy1 = __GL_VERTEX_FLOAT_TO_INT(y1);
y1frac = __GL_VERTEX_FLOAT_FRACTION(y1);
#if 0
DbgPrint("Line %.3lf,%.3lf - %.3lf,%.3lf\n", x0, y0, x1, y1);
DbgPrint("Line %d.%03d,%d.%03d - %d.%03d,%d.%03d\n",
ix0, x0frac, iy0, y0frac, ix1, x1frac, iy1, y1frac);
#endif
// An interesting property of window coordinates is that subtracting
// two of them cancels the exponent so the result is the fixed-point
// difference
idx = CASTINT(x1)-CASTINT(x0);
idy = CASTINT(y1)-CASTINT(y0);
if (idx > 0) {
if (idy > 0) {
if (idx > idy) { /* dx > dy > 0 */
gc->line.options.yBig = 1;
gc->polygon.shader.sbufBig =
cfb->buf.outerWidth+GENACCEL(gc).xMultiplier;
gc->polygon.shader.zbufBig = gc->depthBuffer.buf.outerWidth+1;
posxmajor: /* dx > |dy| >= 0 */
gc->line.options.yLittle = 0;
gc->line.options.xBig = 1;
gc->line.options.xLittle = 1;
gc->polygon.shader.sbufLittle = GENACCEL(gc).xMultiplier;
gc->polygon.shader.zbufLittle = 1;
__GL_FLOAT_SIMPLE_BEGIN_DIVIDE(__glOne, fdx, slope);
start = ix0;
end = ix1;
y0frac -= __GL_VERTEX_FRAC_HALF;
if (y0frac < 0) y0frac = -y0frac;
totDist = y0frac + x0frac - __GL_VERTEX_FRAC_ONE;
if (totDist > 0) start++;
y1frac -= __GL_VERTEX_FRAC_HALF;
if (y1frac < 0) y1frac = -y1frac;
totDist = y1frac + x1frac - __GL_VERTEX_FRAC_ONE;
if (totDist > 0) end++;
offset = start + __glHalf - x0;
gc->line.options.length = fdx;
gc->line.options.numPixels = end - start;
xmajorfinish:
gc->line.options.axis = __GL_X_MAJOR;
gc->line.options.xStart = start;
gc->line.options.offset = offset;
__GL_FLOAT_SIMPLE_END_DIVIDE(slope);
gc->line.options.oneOverLength = slope;
slope *= fdy;
minorStart = y0 + offset*slope - halfWidth;
gc->line.options.yStart = __GL_VERTEX_FLOAT_TO_INT(minorStart);
if (gc->line.options.yStart < gc->transform.miny)
{
gc->line.options.yStart = gc->transform.miny;
gc->line.options.fraction = 0;
}
else if (gc->line.options.yStart >= gc->transform.maxy)
{
gc->line.options.yStart = gc->transform.maxy-1;
gc->line.options.fraction =
__GL_VERTEX_PROMOTE_FRACTION(
(1 << __GL_VERTEX_FRAC_BITS)-1);
}
else
{
gc->line.options.fraction =
__GL_VERTEX_PROMOTED_FRACTION(minorStart);
}
gc->line.options.dfraction = FLT_FRACTION(slope);
} else { /* dy >= dx > 0 */
gc->line.options.xBig = 1;
gc->polygon.shader.sbufBig =
cfb->buf.outerWidth+GENACCEL(gc).xMultiplier;
gc->polygon.shader.zbufBig = gc->depthBuffer.buf.outerWidth+1;
posymajor: /* dy >= |dx| >= 0, dy != 0 */
gc->line.options.xLittle = 0;
gc->line.options.yBig = 1;
gc->line.options.yLittle = 1;
gc->polygon.shader.sbufLittle = cfb->buf.outerWidth;
gc->polygon.shader.zbufLittle = gc->depthBuffer.buf.outerWidth;
__GL_FLOAT_SIMPLE_BEGIN_DIVIDE(__glOne, fdy, slope);
start = iy0;
end = iy1;
x0frac -= __GL_VERTEX_FRAC_HALF;
if (x0frac < 0) x0frac = -x0frac;
totDist = y0frac + x0frac - __GL_VERTEX_FRAC_ONE;
if (totDist > 0) start++;
x1frac -= __GL_VERTEX_FRAC_HALF;
if (x1frac < 0) x1frac = -x1frac;
totDist = y1frac + x1frac - __GL_VERTEX_FRAC_ONE;
if (totDist > 0) end++;
offset = start + __glHalf - y0;
gc->line.options.length = fdy;
gc->line.options.numPixels = end - start;
ymajorfinish:
gc->line.options.axis = __GL_Y_MAJOR;
gc->line.options.yStart = start;
gc->line.options.offset = offset;
__GL_FLOAT_SIMPLE_END_DIVIDE(slope);
gc->line.options.oneOverLength = slope;
slope *= fdx;
minorStart = x0 + offset*slope - halfWidth;
gc->line.options.xStart = __GL_VERTEX_FLOAT_TO_INT(minorStart);
if (gc->line.options.xStart < gc->transform.minx)
{
gc->line.options.xStart = gc->transform.minx;
gc->line.options.fraction = 0;
}
else if (gc->line.options.xStart >= gc->transform.maxx)
{
gc->line.options.xStart = gc->transform.maxx-1;
gc->line.options.fraction =
__GL_VERTEX_PROMOTE_FRACTION(
(1 << __GL_VERTEX_FRAC_BITS)-1);
}
else
{
gc->line.options.fraction =
__GL_VERTEX_PROMOTED_FRACTION(minorStart);
}
gc->line.options.dfraction = FLT_FRACTION(slope);
}
} else {
if (idx > -idy) { /* dx > -dy >= 0 */
gc->line.options.yBig = -1;
gc->polygon.shader.sbufBig =
GENACCEL(gc).xMultiplier-cfb->buf.outerWidth;
gc->polygon.shader.zbufBig = 1-gc->depthBuffer.buf.outerWidth;
goto posxmajor;
} else { /* -dy >= dx >= 0, dy != 0 */
gc->line.options.xBig = 1;
gc->polygon.shader.sbufBig =
GENACCEL(gc).xMultiplier-cfb->buf.outerWidth;
gc->polygon.shader.zbufBig = 1-gc->depthBuffer.buf.outerWidth;
negymajor: /* -dy >= |dx| >= 0, dy != 0 */
gc->line.options.xLittle = 0;
gc->line.options.yBig = -1;
gc->line.options.yLittle = -1;
gc->polygon.shader.sbufLittle = -cfb->buf.outerWidth;
gc->polygon.shader.zbufLittle = -gc->depthBuffer.buf.outerWidth;
__GL_FLOAT_BEGIN_DIVIDE(__glOne, -fdy, &slope);
start = iy0;
end = iy1;
x0frac -= __GL_VERTEX_FRAC_HALF;
if (x0frac < 0) x0frac = -x0frac;
totDist = x0frac - y0frac;
if (totDist > 0) start--;
x1frac -= __GL_VERTEX_FRAC_HALF;
if (x1frac < 0) x1frac = -x1frac;
totDist = x1frac - y1frac;
if (totDist > 0) end--;
offset = y0 - (start + __glHalf);
gc->line.options.length = -fdy;
gc->line.options.numPixels = start - end;
goto ymajorfinish;
}
}
} else {
if (idy > 0) {
if (-idx > idy) { /* -dx > dy > 0 */
gc->line.options.yBig = 1;
gc->polygon.shader.sbufBig =
cfb->buf.outerWidth-GENACCEL(gc).xMultiplier;
gc->polygon.shader.zbufBig = gc->depthBuffer.buf.outerWidth-1;
negxmajor: /* -dx > |dy| >= 0 */
gc->line.options.yLittle = 0;
gc->line.options.xBig = -1;
gc->line.options.xLittle = -1;
gc->polygon.shader.sbufLittle = -GENACCEL(gc).xMultiplier;
gc->polygon.shader.zbufLittle = -1;
__GL_FLOAT_BEGIN_DIVIDE(__glOne, -fdx, &slope);
start = ix0;
end = ix1;
y0frac -= __GL_VERTEX_FRAC_HALF;
if (y0frac < 0) y0frac = -y0frac;
totDist = y0frac - x0frac;
if (totDist > 0) start--;
y1frac -= __GL_VERTEX_FRAC_HALF;
if (y1frac < 0) y1frac = -y1frac;
totDist = y1frac - x1frac;
if (totDist > 0) end--;
offset = x0 - (start + __glHalf);
gc->line.options.length = -fdx;
gc->line.options.numPixels = start - end;
goto xmajorfinish;
} else { /* dy >= -dx >= 0, dy != 0 */
gc->line.options.xBig = -1;
gc->polygon.shader.sbufBig =
cfb->buf.outerWidth-GENACCEL(gc).xMultiplier;
gc->polygon.shader.zbufBig = gc->depthBuffer.buf.outerWidth-1;
goto posymajor;
}
} else {
if (idx < idy) { /* -dx > -dy >= 0 */
gc->line.options.yBig = -1;
gc->polygon.shader.sbufBig =
-GENACCEL(gc).xMultiplier-cfb->buf.outerWidth;
gc->polygon.shader.zbufBig = -1-gc->depthBuffer.buf.outerWidth;
goto negxmajor;
} else { /* -dy >= -dx >= 0 */
if ((idx | idy) == 0) {
gc->line.options.numPixels = 0;
return FALSE;
}
gc->line.options.xBig = -1;
gc->polygon.shader.sbufBig =
-GENACCEL(gc).xMultiplier-cfb->buf.outerWidth;
gc->polygon.shader.zbufBig = -1-gc->depthBuffer.buf.outerWidth;
goto negymajor;
}
}
}
#ifdef DO_CHECK_PIXELS
if (gc->line.options.numPixels > 0)
{
ix0 = gc->line.options.xStart;
iy0 = gc->line.options.yStart;
if (ix0 < gc->transform.minx || ix0 >= gc->transform.maxx ||
iy0 < gc->transform.miny || iy0 >= gc->transform.maxy)
{
DbgPrint("Start out of bounds %d,%d (%d,%d - %d,%d) for %d,%d\n",
ix0, iy0,
gc->transform.minx, gc->transform.miny,
gc->transform.maxx, gc->transform.maxy,
idx, idy);
DbgPrint(" Line %.3lf,%.3lf - %.3lf,%.3lf\n", x0, y0, x1, y1);
DbgPrint(" Viewport %.3lf,%.3lf - %.3lf,%.3lf%s\n",
gc->state.viewport.xCenter, gc->state.viewport.yCenter,
gc->state.viewport.xScale, gc->state.viewport.yScale,
!gc->transform.reasonableViewport ?
" (unreasonable)" : "");
}
}
#endif
return gc->line.options.numPixels > 0;
}
// Only used by fast single-pixel line code
// It differs from glInitLineData only in the removal of halfWidth
BOOL FASTCALL __glInitThinLineData(__GLcontext *gc, __GLvertex *v0, __GLvertex *v1)
{
GLint start, end;
__GLfloat x0,y0,x1,y1;
__GLfloat minorStart;
__GLfloat fdx, fdy;
__GLfloat offset;
__GLfloat slope;
GLint x0frac, x1frac, y0frac, y1frac, totDist;
GLint ix0, ix1, iy0, iy1, idx, idy;
__GLcolorBuffer *cfb = gc->drawBuffer;
ASSERT_CHOP_ROUND();
ASSERTOPENGL(gc->state.line.aliasedWidth == __glOne,
"ThinAlias setup for wrong line state\n");
x0 = v0->window.x;
y0 = v0->window.y;
x1 = v1->window.x;
y1 = v1->window.y;
#ifdef DO_CHECK_PIXELS
gc->line.options.v0 = v0;
gc->line.options.v1 = v1;
if (x0 < gc->transform.fminx || x0 >= gc->transform.fmaxx ||
y0 < gc->transform.fminy || y0 >= gc->transform.fmaxy ||
x1 < gc->transform.fminx || x1 >= gc->transform.fmaxx ||
y1 < gc->transform.fminy || y1 >= gc->transform.fmaxy)
{
DbgPrint("Line coordinates out %.3lf,%.3lf - %.3lf,%.3lf%s\n",
x0, y0, x1, y1,
!gc->transform.reasonableViewport ? " (unreasonable)" : "");
}
#endif
fdx = x1-x0;
fdy = y1-y0;
ix0 = __GL_VERTEX_FLOAT_TO_INT(x0);
x0frac = __GL_VERTEX_FLOAT_FRACTION(x0);
iy0 = __GL_VERTEX_FLOAT_TO_INT(y0);
y0frac = __GL_VERTEX_FLOAT_FRACTION(y0);
ix1 = __GL_VERTEX_FLOAT_TO_INT(x1);
x1frac = __GL_VERTEX_FLOAT_FRACTION(x1);
iy1 = __GL_VERTEX_FLOAT_TO_INT(y1);
y1frac = __GL_VERTEX_FLOAT_FRACTION(y1);
#if 0
DbgPrint("Line %.3lf,%.3lf - %.3lf,%.3lf\n", x0, y0, x1, y1);
DbgPrint("Line %d.%03d,%d.%03d - %d.%03d,%d.%03d\n",
ix0, x0frac, iy0, y0frac, ix1, x1frac, iy1, y1frac);
#endif
// An interesting property of window coordinates is that subtracting
// two of them cancels the exponent so the result is the fixed-point
// difference
idx = CASTINT(x1)-CASTINT(x0);
idy = CASTINT(y1)-CASTINT(y0);
if (idx > 0) {
if (idy > 0) {
if (idx > idy) { /* dx > dy > 0 */
gc->line.options.yBig = 1;
gc->polygon.shader.sbufBig =
cfb->buf.outerWidth+GENACCEL(gc).xMultiplier;
gc->polygon.shader.zbufBig = gc->depthBuffer.buf.outerWidth+1;
posxmajor: /* dx > |dy| >= 0 */
gc->line.options.yLittle = 0;
gc->line.options.xBig = 1;
gc->line.options.xLittle = 1;
gc->polygon.shader.sbufLittle = GENACCEL(gc).xMultiplier;
gc->polygon.shader.zbufLittle = 1;
__GL_FLOAT_SIMPLE_BEGIN_DIVIDE(__glOne, fdx, slope);
start = ix0;
end = ix1;
y0frac -= __GL_VERTEX_FRAC_HALF;
if (y0frac < 0) y0frac = -y0frac;
totDist = y0frac + x0frac - __GL_VERTEX_FRAC_ONE;
if (totDist > 0) start++;
y1frac -= __GL_VERTEX_FRAC_HALF;
if (y1frac < 0) y1frac = -y1frac;
totDist = y1frac + x1frac - __GL_VERTEX_FRAC_ONE;
if (totDist > 0) end++;
offset = start + __glHalf - x0;
gc->line.options.length = fdx;
gc->line.options.numPixels = end - start;
xmajorfinish:
gc->line.options.axis = __GL_X_MAJOR;
gc->line.options.xStart = start;
gc->line.options.offset = offset;
__GL_FLOAT_SIMPLE_END_DIVIDE(slope);
gc->line.options.oneOverLength = slope;
slope *= fdy;
minorStart = y0 + offset*slope;
gc->line.options.yStart = __GL_VERTEX_FLOAT_TO_INT(minorStart);
if (gc->line.options.yStart < gc->transform.miny)
{
gc->line.options.yStart = gc->transform.miny;
gc->line.options.fraction = 0;
}
else if (gc->line.options.yStart >= gc->transform.maxy)
{
gc->line.options.yStart = gc->transform.maxy-1;
gc->line.options.fraction =
__GL_VERTEX_PROMOTE_FRACTION(
(1 << __GL_VERTEX_FRAC_BITS)-1);
}
else
{
gc->line.options.fraction =
__GL_VERTEX_PROMOTED_FRACTION(minorStart);
}
gc->line.options.dfraction = FLT_FRACTION(slope);
} else { /* dy >= dx > 0 */
gc->line.options.xBig = 1;
gc->polygon.shader.sbufBig =
cfb->buf.outerWidth+GENACCEL(gc).xMultiplier;
gc->polygon.shader.zbufBig = gc->depthBuffer.buf.outerWidth+1;
posymajor: /* dy >= |dx| >= 0, dy != 0 */
gc->line.options.xLittle = 0;
gc->line.options.yBig = 1;
gc->line.options.yLittle = 1;
gc->polygon.shader.sbufLittle = cfb->buf.outerWidth;
gc->polygon.shader.zbufLittle = gc->depthBuffer.buf.outerWidth;
__GL_FLOAT_SIMPLE_BEGIN_DIVIDE(__glOne, fdy, slope);
start = iy0;
end = iy1;
x0frac -= __GL_VERTEX_FRAC_HALF;
if (x0frac < 0) x0frac = -x0frac;
totDist = y0frac + x0frac - __GL_VERTEX_FRAC_ONE;
if (totDist > 0) start++;
x1frac -= __GL_VERTEX_FRAC_HALF;
if (x1frac < 0) x1frac = -x1frac;
totDist = y1frac + x1frac - __GL_VERTEX_FRAC_ONE;
if (totDist > 0) end++;
offset = start + __glHalf - y0;
gc->line.options.length = fdy;
gc->line.options.numPixels = end - start;
ymajorfinish:
gc->line.options.axis = __GL_Y_MAJOR;
gc->line.options.yStart = start;
gc->line.options.offset = offset;
__GL_FLOAT_SIMPLE_END_DIVIDE(slope);
gc->line.options.oneOverLength = slope;
slope *= fdx;
minorStart = x0 + offset*slope;
gc->line.options.xStart = __GL_VERTEX_FLOAT_TO_INT(minorStart);
if (gc->line.options.xStart < gc->transform.minx)
{
gc->line.options.xStart = gc->transform.minx;
gc->line.options.fraction = 0;
}
else if (gc->line.options.xStart >= gc->transform.maxx)
{
gc->line.options.xStart = gc->transform.maxx-1;
gc->line.options.fraction =
__GL_VERTEX_PROMOTE_FRACTION(
(1 << __GL_VERTEX_FRAC_BITS)-1);
}
else
{
gc->line.options.fraction =
__GL_VERTEX_PROMOTED_FRACTION(minorStart);
}
gc->line.options.dfraction = FLT_FRACTION(slope);
}
} else {
if (idx > -idy) { /* dx > -dy >= 0 */
gc->line.options.yBig = -1;
gc->polygon.shader.sbufBig =
GENACCEL(gc).xMultiplier-cfb->buf.outerWidth;
gc->polygon.shader.zbufBig = 1-gc->depthBuffer.buf.outerWidth;
goto posxmajor;
} else { /* -dy >= dx >= 0, dy != 0 */
gc->line.options.xBig = 1;
gc->polygon.shader.sbufBig =
GENACCEL(gc).xMultiplier-cfb->buf.outerWidth;
gc->polygon.shader.zbufBig = 1-gc->depthBuffer.buf.outerWidth;
negymajor: /* -dy >= |dx| >= 0, dy != 0 */
gc->line.options.xLittle = 0;
gc->line.options.yBig = -1;
gc->line.options.yLittle = -1;
gc->polygon.shader.sbufLittle = -cfb->buf.outerWidth;
gc->polygon.shader.zbufLittle = -gc->depthBuffer.buf.outerWidth;
__GL_FLOAT_BEGIN_DIVIDE(__glOne, -fdy, &slope);
start = iy0;
end = iy1;
x0frac -= __GL_VERTEX_FRAC_HALF;
if (x0frac < 0) x0frac = -x0frac;
totDist = x0frac - y0frac;
if (totDist > 0) start--;
x1frac -= __GL_VERTEX_FRAC_HALF;
if (x1frac < 0) x1frac = -x1frac;
totDist = x1frac - y1frac;
if (totDist > 0) end--;
offset = y0 - (start + __glHalf);
gc->line.options.length = -fdy;
gc->line.options.numPixels = start - end;
goto ymajorfinish;
}
}
} else {
if (idy > 0) {
if (-idx > idy) { /* -dx > dy > 0 */
gc->line.options.yBig = 1;
gc->polygon.shader.sbufBig =
cfb->buf.outerWidth-GENACCEL(gc).xMultiplier;
gc->polygon.shader.zbufBig = gc->depthBuffer.buf.outerWidth-1;
negxmajor: /* -dx > |dy| >= 0 */
gc->line.options.yLittle = 0;
gc->line.options.xBig = -1;
gc->line.options.xLittle = -1;
gc->polygon.shader.sbufLittle = -GENACCEL(gc).xMultiplier;
gc->polygon.shader.zbufLittle = -1;
__GL_FLOAT_BEGIN_DIVIDE(__glOne, -fdx, &slope);
start = ix0;
end = ix1;
y0frac -= __GL_VERTEX_FRAC_HALF;
if (y0frac < 0) y0frac = -y0frac;
totDist = y0frac - x0frac;
if (totDist > 0) start--;
y1frac -= __GL_VERTEX_FRAC_HALF;
if (y1frac < 0) y1frac = -y1frac;
totDist = y1frac - x1frac;
if (totDist > 0) end--;
offset = x0 - (start + __glHalf);
gc->line.options.length = -fdx;
gc->line.options.numPixels = start - end;
goto xmajorfinish;
} else { /* dy >= -dx >= 0, dy != 0 */
gc->line.options.xBig = -1;
gc->polygon.shader.sbufBig =
cfb->buf.outerWidth-GENACCEL(gc).xMultiplier;
gc->polygon.shader.zbufBig = gc->depthBuffer.buf.outerWidth-1;
goto posymajor;
}
} else {
if (idx < idy) { /* -dx > -dy >= 0 */
gc->line.options.yBig = -1;
gc->polygon.shader.sbufBig =
-GENACCEL(gc).xMultiplier-cfb->buf.outerWidth;
gc->polygon.shader.zbufBig = -1-gc->depthBuffer.buf.outerWidth;
goto negxmajor;
} else { /* -dy >= -dx >= 0 */
if ((idx | idy) == 0) {
gc->line.options.numPixels = 0;
return FALSE;
}
gc->line.options.xBig = -1;
gc->polygon.shader.sbufBig =
-GENACCEL(gc).xMultiplier-cfb->buf.outerWidth;
gc->polygon.shader.zbufBig = -1-gc->depthBuffer.buf.outerWidth;
goto negymajor;
}
}
}
#ifdef DO_CHECK_PIXELS
if (gc->line.options.numPixels > 0)
{
ix0 = gc->line.options.xStart;
iy0 = gc->line.options.yStart;
if (ix0 < gc->transform.minx || ix0 >= gc->transform.maxx ||
iy0 < gc->transform.miny || iy0 >= gc->transform.maxy)
{
DbgPrint("Start out of bounds %d,%d (%d,%d - %d,%d) for %d,%d\n",
ix0, iy0,
gc->transform.minx, gc->transform.miny,
gc->transform.maxx, gc->transform.maxy,
idx, idy);
DbgPrint(" Line %.3lf,%.3lf - %.3lf,%.3lf\n", x0, y0, x1, y1);
DbgPrint(" Viewport %.3lf,%.3lf - %.3lf,%.3lf%s\n",
gc->state.viewport.xCenter, gc->state.viewport.yCenter,
gc->state.viewport.xScale, gc->state.viewport.yScale,
!gc->transform.reasonableViewport ?
" (unreasonable)" : "");
}
}
#endif
return gc->line.options.numPixels > 0;
}
// Called to render both anti-aliased and aliased lines
void FASTCALL __glGenRenderEitherLine(__GLcontext *gc, __GLvertex *v0,
__GLvertex *v1, GLuint flags)
{
__GLfloat invDelta;
GLuint modeFlags = gc->polygon.shader.modeFlags;
CHOP_ROUND_ON();
if (!(*GENACCEL(gc).__fastGenInitLineData)(gc, v0, v1))
{
CHOP_ROUND_OFF();
return;
}
ASSERTOPENGL(GENACCEL(gc).rAccelScale == FIX_SCALEFACT,
"rAccelScale != FIX_SCALEFACT\n");
ASSERTOPENGL(GENACCEL(gc).gAccelScale == FIX_SCALEFACT,
"gAccelScale != FIX_SCALEFACT\n");
ASSERTOPENGL(GENACCEL(gc).bAccelScale == FIX_SCALEFACT,
"bAccelScale != FIX_SCALEFACT\n");
// Alpha is always scaled between 0 and 255
invDelta = gc->line.options.oneOverLength;
/*
** Set up increments for any enabled line options.
*/
if ((gc->drawBuffer->buf.flags & DIB_FORMAT) == 0)
{
// For non-DIBs we pick up the bytes from ColorsBits so
// the pixel pointer doesn't move
gc->polygon.shader.sbufLittle = 0;
gc->polygon.shader.sbufBig = 0;
}
if (modeFlags & __GL_SHADE_SMOOTH)
{
__GLcolor *c0 = v0->color;
__GLcolor *c1 = v1->color;
/*
** Calculate red, green, blue and alpha value increments.
*/
if (gc->modes.rgbMode)
{
__GLfloat dr, dg, db;
#ifdef _X86_
__asm
{
; Compute dr, dg and db
mov eax, c0
mov edx, c1
fld DWORD PTR [eax+COLOR_r]
fld DWORD PTR [eax+COLOR_g]
fld DWORD PTR [eax+COLOR_b]
fld DWORD PTR [edx+COLOR_r]
fsub st(0), st(3)
fld DWORD PTR [edx+COLOR_g]
fsub st(0), st(3)
fld DWORD PTR [edx+COLOR_b]
fsub st(0), st(3)
mov edx, gc
fstp db
fstp dg
fstp dr
FLT_STACK_RGB_TO_GC_FIXED(GC_SHADER_R,
GC_SHADER_G,
GC_SHADER_B)
}
#else
dr = c1->r - c0->r;
CASTFIX(gc->polygon.shader.frag.color.r) =
UNSAFE_FLT_TO_FIX(c0->r);
dg = c1->g - c0->g;
CASTFIX(gc->polygon.shader.frag.color.g) =
UNSAFE_FLT_TO_FIX(c0->g);
db = c1->b - c0->b;
CASTFIX(gc->polygon.shader.frag.color.b) =
UNSAFE_FLT_TO_FIX(c0->b);
#endif
if ((CASTINT(dr) | CASTINT(dg) | CASTINT(db)) == 0)
{
CASTINT(gc->polygon.shader.drdx) = 0;
CASTINT(gc->polygon.shader.dgdx) = 0;
CASTINT(gc->polygon.shader.dbdx) = 0;
}
else
{
#ifdef _X86_
__asm
{
fld dr
fld dg
fld db
fld invDelta
fmul __glVal65536
mov edx, gc
fmul st(3), st(0)
fmul st(2), st(0)
fmulp st(1), st(0)
fistp DWORD PTR [edx+GC_SHADE_dbdx]
fistp DWORD PTR [edx+GC_SHADE_dgdx]
fistp DWORD PTR [edx+GC_SHADE_drdx]
}
#else
CASTFIX(gc->polygon.shader.drdx) =
UNSAFE_FLT_TO_FIX(dr * invDelta);
CASTFIX(gc->polygon.shader.dgdx) =
UNSAFE_FLT_TO_FIX(dg * invDelta);
CASTFIX(gc->polygon.shader.dbdx) =
UNSAFE_FLT_TO_FIX(db * invDelta);
#endif
}
if (gc->state.enables.general & __GL_BLEND_ENABLE)
{
__GLfloat da;
da = c1->a - c0->a;
CASTFIX(gc->polygon.shader.frag.color.a) =
UNSAFE_FTOL(c0->a * GENACCEL(gc).aAccelScale);
if (__GL_FLOAT_EQZ(da))
{
CASTINT(gc->polygon.shader.dadx) = 0;
}
else
{
CASTFIX(gc->polygon.shader.dadx) =
UNSAFE_FTOL(da * invDelta * GENACCEL(gc).aAccelScale);
}
}
}
else
{
__GLfloat dr;
dr = c1->r - c0->r;
CASTFIX(gc->polygon.shader.frag.color.r) =
UNSAFE_FLT_TO_FIX(c0->r);
if (__GL_FLOAT_EQZ(dr))
{
CASTINT(gc->polygon.shader.drdx) = 0;
}
else
{
CASTFIX(gc->polygon.shader.drdx) =
UNSAFE_FLT_TO_FIX(dr * invDelta);
}
}
}
else
{
__GLcolor *c1 = v0->color;
if (gc->modes.rgbMode)
{
#ifdef _X86_
__asm
{
mov eax, c1
fld DWORD PTR [eax+COLOR_r]
fld DWORD PTR [eax+COLOR_g]
fld DWORD PTR [eax+COLOR_b]
mov edx, gc
FLT_STACK_RGB_TO_GC_FIXED(GC_SHADER_R,
GC_SHADER_G,
GC_SHADER_B)
}
#else
CASTFIX(gc->polygon.shader.frag.color.r) =
UNSAFE_FLT_TO_FIX(c1->r);
CASTFIX(gc->polygon.shader.frag.color.g) =
UNSAFE_FLT_TO_FIX(c1->g);
CASTFIX(gc->polygon.shader.frag.color.b) =
UNSAFE_FLT_TO_FIX(c1->b);
#endif
if (gc->state.enables.general & __GL_BLEND_ENABLE)
{
CASTFIX(gc->polygon.shader.frag.color.a) =
UNSAFE_FTOL(c1->a * GENACCEL(gc).aAccelScale);
}
}
else
{
CASTFIX(gc->polygon.shader.frag.color.r) =
UNSAFE_FLT_TO_FIX(c1->r);
}
}
if (modeFlags & __GL_SHADE_DEPTH_ITER)
{
// The increment is in USHORT units so it only needs to be
// scaled in the 32-bit Z buffer case
if (gc->depthBuffer.buf.elementSize == 4)
{
gc->polygon.shader.zbufLittle <<= 1;
gc->polygon.shader.zbufBig <<= 1;
}
/*
** Calculate window z coordinate increment and starting position.
*/
if(( gc->modes.depthBits == 16 ) &&
( gc->depthBuffer.scale <= (GLuint)0xffff ))
{
ASSERTOPENGL(Z16_SCALE == FIX_SCALEFACT,
"Z16 scaling different from fixed\n");
gc->polygon.shader.dzdx =
FLT_TO_Z16_SCALE((v1->window.z - v0->window.z) * invDelta);
gc->polygon.shader.frag.z =
FTOL(v0->window.z*Z16_SCALE + gc->polygon.shader.dzdx *
gc->line.options.offset);
}
else
{
gc->polygon.shader.dzdx =
FTOL((v1->window.z - v0->window.z) * invDelta);
gc->polygon.shader.frag.z =
FTOL(v0->window.z + gc->polygon.shader.dzdx *
gc->line.options.offset);
}
}
(*GENACCEL(gc).__fastGenLineProc)(gc);
CHOP_ROUND_OFF();
}
#define DITHER_PIXEL(pPix, x, y)\
{\
ULONG r, g, b;\
DWORD ditherVal;\
\
ditherVal = ditherShade[((x) & 0x3) + \
(((y) & 0x3) << 3)];\
\
r = ((rAccum + ditherVal) >> (16-RSHIFT)) & RMASK;\
g = ((gAccum + ditherVal) >> (16-GSHIFT)) & GMASK;\
b = ((bAccum + ditherVal) >> (16-BSHIFT)) & BMASK;\
\
WRITE_PIX(pPix);\
}
#define BLEND_PIXEL(pPix, alpha, x, y)\
{\
ULONG pix;\
ULONG rDisplay, gDisplay, bDisplay, aDisplay;\
ULONG r, g, b;\
ULONG invAlpha;\
DWORD ditherVal;\
\
ditherVal = ditherShade[((x) & 0x3) + \
(((y) & 0x3) << 3)];\
\
aDisplay = (gbMulTable[((aAccum >> 16) & 0xff) | (alpha)]) << 8;\
\
pix = READ_PIX(pPix);\
\
rDisplay = ((pix & RMASK) >> RSHIFT) << (8 - RBITS);\
gDisplay = ((pix & GMASK) >> GSHIFT) << (8 - GBITS);\
bDisplay = ((pix & BMASK) >> BSHIFT) << (8 - BBITS);\
\
if (gc->state.raster.blendDst == GL_ONE) { \
\
r = (gbMulTable[((rAccum >> (RBITS+8)) & 0xff) | aDisplay] + rDisplay)\
+ (ditherVal >> (RBITS + 8));\
g = (gbMulTable[((gAccum >> (GBITS+8)) & 0xff) | aDisplay] + gDisplay)\
+ (ditherVal >> (GBITS + 8));\
b = (gbMulTable[((bAccum >> (BBITS+8)) & 0xff) | aDisplay] + bDisplay)\
+ (ditherVal >> (BBITS + 8));\
r = ((gbSatTable[r] << (RBITS+8)) \
>> (16 - RSHIFT)) & RMASK;\
g = ((gbSatTable[g] << (GBITS+8)) \
>> (16 - GSHIFT)) & GMASK;\
b = ((gbSatTable[b] << (BBITS+8)) \
>> (16 - BSHIFT)) & BMASK;\
\
} else { \
\
invAlpha = 0xff00 - (ULONG)aDisplay;\
\
rDisplay = gbMulTable[rDisplay | invAlpha];\
gDisplay = gbMulTable[gDisplay | invAlpha];\
bDisplay = gbMulTable[bDisplay | invAlpha];\
\
r = ((((gbMulTable[((rAccum >> (RBITS+8)) & 0xff) | aDisplay] + rDisplay)\
<< (RBITS+8)) + ditherVal) >> (16 - RSHIFT)) & RMASK;\
\
g = ((((gbMulTable[((gAccum >> (GBITS+8)) & 0xff) | aDisplay] + gDisplay)\
<< (GBITS+8)) + ditherVal) >> (16 - GSHIFT)) & GMASK;\
\
b = ((((gbMulTable[((bAccum >> (BBITS+8)) & 0xff) | aDisplay] + bDisplay)\
<< (BBITS+8)) + ditherVal) >> (16 - BSHIFT)) & BMASK;\
} \
\
WRITE_PIX(pPix);\
}
#define WRITE_PIXEL_GEN(pPix, alpha, x, y)\
if (gc->state.enables.general & __GL_BLEND_ENABLE) {\
ULONG pix;\
ULONG rDisplay, gDisplay, bDisplay, aDisplay;\
ULONG r, g, b;\
ULONG invAlpha;\
DWORD ditherVal;\
\
if (modeFlags & __GL_SHADE_DITHER) {\
ditherVal = ditherShade[((x) & 0x3) + \
(((y) & 0x3) << 3)];\
} else\
ditherVal = 0;\
\
aDisplay = (gbMulTable[((aAccum >> 16) & 0xff) | (alpha)]) << 8;\
\
switch (bytesPerPixel) {\
case 1:\
pix = ((__GLGENcontext *)gc)->pajInvTranslateVector[*((BYTE *)(pPix))];\
rDisplay = ((pix & rMask) >> rShift) << (8 - rBits);\
gDisplay = ((pix & gMask) >> gShift) << (8 - gBits);\
bDisplay = ((pix & bMask) >> bShift) << (8 - bBits);\
break;\
case 2:\
pix = *((USHORT *)(pPix));\
rDisplay = ((pix & rMask) >> rShift) << (8 - rBits);\
gDisplay = ((pix & gMask) >> gShift) << (8 - gBits);\
bDisplay = ((pix & bMask) >> bShift) << (8 - bBits);\
break;\
case 3:\
default:\
if (rShift > bShift) {\
rDisplay = pPix[2];\
gDisplay = pPix[1];\
bDisplay = pPix[0];\
} else {\
rDisplay = pPix[0];\
gDisplay = pPix[1];\
bDisplay = pPix[2];\
}\
break;\
}\
\
if (gc->state.raster.blendDst == GL_ONE) { \
\
r = (gbMulTable[((rAccum >> (rBits+8)) & 0xff) | aDisplay] + rDisplay)\
+ (ditherVal >> (rBits + 8));\
g = (gbMulTable[((gAccum >> (gBits+8)) & 0xff) | aDisplay] + gDisplay)\
+ (ditherVal >> (gBits + 8));\
b = (gbMulTable[((bAccum >> (bBits+8)) & 0xff) | aDisplay] + bDisplay)\
+ (ditherVal >> (bBits + 8));\
r = ((gbSatTable[r] << (rBits+8)) \
>> (16 - rShift)) & rMask;\
g = ((gbSatTable[g] << (gBits+8)) \
>> (16 - gShift)) & gMask;\
b = ((gbSatTable[b] << (bBits+8)) \
>> (16 - bShift)) & bMask;\
\
} else { \
\
invAlpha = 0xff00 - (ULONG)aDisplay;\
\
rDisplay = gbMulTable[rDisplay | invAlpha];\
gDisplay = gbMulTable[gDisplay | invAlpha];\
bDisplay = gbMulTable[bDisplay | invAlpha];\
\
r = ((((gbMulTable[((rAccum >> (rBits+8)) & 0xff) | aDisplay] + rDisplay)\
<< (rBits+8)) + ditherVal) >> (16 - rShift)) & rMask;\
\
g = ((((gbMulTable[((gAccum >> (gBits+8)) & 0xff) | aDisplay] + gDisplay)\
<< (gBits+8)) + ditherVal) >> (16 - gShift)) & gMask;\
\
b = ((((gbMulTable[((bAccum >> (bBits+8)) & 0xff) | aDisplay] + bDisplay)\
<< (bBits+8)) + ditherVal) >> (16 - bShift)) & bMask;\
} \
\
switch (bytesPerPixel) {\
case 1:\
pPix[0] = ((__GLGENcontext *)gc)->xlatPalette[r | g | b];\
break;\
case 2:\
*((USHORT *)pPix) = (USHORT)(r | g | b);\
break;\
case 3:\
pix = r | g | b;\
*((USHORT UNALIGNED *)pPix) = (USHORT)pix;\
pPix[2] = (BYTE)(pix >> 16);\
break;\
default:\
*((DWORD *)pPix) = (DWORD)(r | g | b);\
break;\
}\
} else {\
ULONG r, g, b;\
DWORD ditherVal;\
ULONG pix;\
\
if (modeFlags & __GL_SHADE_DITHER) {\
ditherVal = ditherShade[((x) & 0x3) + (((y) & 0x3) << 3)];\
} else\
ditherVal = 0;\
\
r = ((rAccum + ditherVal) >> (16-rShift)) & rMask;\
g = ((gAccum + ditherVal) >> (16-gShift)) & gMask;\
b = ((bAccum + ditherVal) >> (16-bShift)) & bMask;\
\
switch (bytesPerPixel) {\
case 1:\
pPix[0] = ((__GLGENcontext *)gc)->xlatPalette[r | g | b];\
break;\
case 2:\
*((USHORT *)pPix) = (USHORT)(r | g | b);\
break;\
case 3:\
pix = r | g | b;\
*((USHORT UNALIGNED *)pPix) = (USHORT)pix;\
pPix[2] = (BYTE)(pix >> 16);\
break;\
default:\
*((DWORD *)pPix) = (DWORD)(r | g | b);\
break;\
}\
}
#ifdef DO_CHECK_PIXELS
#define CHECK_PIXEL(gc, cfb, count, bx, by) \
{\
GLint fbX, fbY;\
\
fbX = __GL_UNBIAS_X(gc, bx);\
fbY = __GL_UNBIAS_Y(gc, by);\
if (!(fbX >= 0 && fbX < (cfb)->buf.width &&\
fbY >= 0 && fbY < (cfb)->buf.height))\
{\
DbgPrint("Pixel out of bounds at %c %d of %d: %d,%d (%d,%d)\n",\
(gc)->line.options.axis == __GL_Y_MAJOR ? 'Y' : 'X',\
(gc)->line.options.numPixels-(count),\
(gc)->line.options.numPixels,\
fbX, fbY, (cfb)->buf.width, (cfb)->buf.height);\
DbgPrint(" Line %.3lf,%.3lf - %.3lf,%.3lf\n",\
(gc)->line.options.v0->window.x,\
(gc)->line.options.v0->window.y,\
(gc)->line.options.v1->window.x,\
(gc)->line.options.v1->window.y);\
}\
}
#else
#define CHECK_PIXEL(gc, cfb, w, x, y)
#endif
#define FAST_AA_LINE \
{\
GLint xLittle, xBig, yLittle, yBig;\
GLint fragX2, fragY2;\
BYTE *pPix;\
BYTE *pPix2;\
USHORT *pZ;\
USHORT *pZ2;\
__GLfragment frag;\
__GLcolorBuffer *cfb = gc->drawBuffer;\
LONG rAccum, gAccum, bAccum, aAccum;\
LONG pixAdjStep;\
ULONG zAdjStep;\
ULONG coverage, invCoverage;\
LONG fragXinc;\
LONG fragYinc;\
LONG bytesPerPixel;\
__GLzValue zAccum;\
GLint clipX1 = gc->transform.clipX1;\
GLint clipY1 = gc->transform.clipY1;\
\
GLint fraction, dfraction;\
GLint w;\
GLuint modeFlags = gc->polygon.shader.modeFlags;\
\
ASSERTOPENGL((cfb->buf.flags &\
(DIB_FORMAT | NO_CLIP)) == (DIB_FORMAT | NO_CLIP),\
"FAST_AA_LINE on clipping surface\n");\
\
fraction = gc->line.options.fraction;\
dfraction = gc->line.options.dfraction;\
\
xBig = gc->line.options.xBig;\
yBig = gc->line.options.yBig;\
xLittle = gc->line.options.xLittle;\
yLittle = gc->line.options.yLittle;\
\
frag.x = gc->line.options.xStart;\
frag.y = gc->line.options.yStart;\
\
bytesPerPixel = GENACCEL(gc).xMultiplier;\
\
if (gc->line.options.axis == __GL_Y_MAJOR) {\
pixAdjStep = bytesPerPixel;\
zAdjStep = 1;\
fragXinc = 1;\
fragYinc = 0;\
} else {\
pixAdjStep = cfb->buf.outerWidth;\
zAdjStep = gc->depthBuffer.buf.outerWidth;\
fragXinc = 0;\
fragYinc = 1;\
}\
\
pPix = (BYTE *)((ULONG_PTR)cfb->buf.base +\
(__GL_UNBIAS_Y(gc, frag.y) + cfb->buf.yOrigin) * cfb->buf.outerWidth +\
(__GL_UNBIAS_X(gc, frag.x) + cfb->buf.xOrigin) * bytesPerPixel);\
\
if (modeFlags & __GL_SHADE_DEPTH_TEST) {\
zAccum = gc->polygon.shader.frag.z;\
\
if( gc->modes.depthBits == 32 ) {\
pZ = (USHORT *)__GL_DEPTH_ADDR(&gc->depthBuffer, (__GLzValue*),\
frag.x, frag.y);\
\
zAdjStep *= 2;\
} else {\
pZ = (USHORT *)__GL_DEPTH_ADDR(&gc->depthBuffer,\
(__GLz16Value*),\
frag.x, frag.y);\
}\
\
}\
\
rAccum = CASTFIX(gc->polygon.shader.frag.color.r);\
gAccum = CASTFIX(gc->polygon.shader.frag.color.g);\
bAccum = CASTFIX(gc->polygon.shader.frag.color.b);\
aAccum = CASTFIX(gc->polygon.shader.frag.color.a);\
\
w = gc->line.options.numPixels;\
for (;;)\
{\
CHECK_PIXEL(gc, cfb, w, frag.x, frag.y);\
\
invCoverage = ((fraction << 1) & 0xff000000) >> 16;\
coverage = 0xff00 - invCoverage;\
\
if (modeFlags & __GL_SHADE_DEPTH_TEST) {\
if (!(*GENACCEL(gc).__fastGenZStore)(zAccum, (__GLzValue *)pZ ))\
goto noWrite1;\
}\
\
BLEND_PIXEL(pPix, coverage, frag.x, frag.y);\
noWrite1:\
\
fragX2 = frag.x + fragXinc;\
fragY2 = frag.y + fragYinc;\
if ((fragX2 >= clipX1) || (fragY2 >= clipY1)) {\
goto noWrite2;\
}\
\
pZ2 = pZ+zAdjStep;\
if (modeFlags & __GL_SHADE_DEPTH_TEST) {\
if (!(*GENACCEL(gc).__fastGenZStore)(zAccum, (__GLzValue *)pZ2 ))\
goto noWrite2;\
}\
\
pPix2 = pPix + pixAdjStep;\
BLEND_PIXEL(pPix2, invCoverage, fragX2, fragY2);\
noWrite2:\
\
if (--w <= 0)\
return GL_TRUE;\
\
fraction += dfraction;\
if (fraction < 0) {\
fraction &= ~0x80000000;\
frag.x += xBig;\
frag.y += yBig;\
pPix += gc->polygon.shader.sbufBig;\
pZ += gc->polygon.shader.zbufBig;\
} else {\
frag.x += xLittle;\
frag.y += yLittle;\
pPix += gc->polygon.shader.sbufLittle;\
pZ += gc->polygon.shader.zbufLittle;\
}\
\
if (modeFlags & __GL_SHADE_SMOOTH) {\
rAccum += CASTFIX(gc->polygon.shader.drdx);\
gAccum += CASTFIX(gc->polygon.shader.dgdx);\
bAccum += CASTFIX(gc->polygon.shader.dbdx);\
aAccum += CASTFIX(gc->polygon.shader.dadx);\
}\
\
if (modeFlags & __GL_SHADE_DEPTH_ITER) {\
zAccum += gc->polygon.shader.dzdx;\
}\
}\
\
return GL_TRUE;\
}
/************************************************************************/
#undef BPP
#undef RSHIFT
#undef GSHIFT
#undef BSHIFT
#undef RBITS
#undef GBITS
#undef BBITS
#undef RMASK
#undef GMASK
#undef BMASK
#undef READ_PIX
#undef WRITE_PIX
#define RSHIFT 0
#define GSHIFT 3
#define BSHIFT 6
#define RBITS 3
#define GBITS 3
#define BBITS 2
#define RMASK (((1 << RBITS) - 1) << RSHIFT)
#define GMASK (((1 << GBITS) - 1) << GSHIFT)
#define BMASK (((1 << BBITS) - 1) << BSHIFT)
#define BPP 8
#define READ_PIX(pPix) \
((__GLGENcontext *)gc)->pajInvTranslateVector[*((BYTE *)(pPix))]
#define WRITE_PIX(pPix) \
pPix[0] = ((__GLGENcontext *)gc)->xlatPalette[r | g | b]
GLboolean FASTCALL __fastGenAntiAliasLine332(__GLcontext *gc)
FAST_AA_LINE
#undef BPP
#undef RSHIFT
#undef GSHIFT
#undef BSHIFT
#undef RBITS
#undef GBITS
#undef BBITS
#undef RMASK
#undef GMASK
#undef BMASK
#undef READ_PIX
#undef WRITE_PIX
#define RSHIFT 10
#define GSHIFT 5
#define BSHIFT 0
#define RBITS 5
#define GBITS 5
#define BBITS 5
#define RMASK (((1 << RBITS) - 1) << RSHIFT)
#define GMASK (((1 << GBITS) - 1) << GSHIFT)
#define BMASK (((1 << BBITS) - 1) << BSHIFT)
#define BPP 16
#define READ_PIX(pPix) \
*((USHORT *)(pPix))
#define WRITE_PIX(pPix) \
*((USHORT *)pPix) = (USHORT)(r | g | b)
GLboolean FASTCALL __fastGenAntiAliasLine555(__GLcontext *gc)
FAST_AA_LINE
#undef BPP
#undef RSHIFT
#undef GSHIFT
#undef BSHIFT
#undef RBITS
#undef GBITS
#undef BBITS
#undef RMASK
#undef GMASK
#undef BMASK
#undef READ_PIX
#undef WRITE_PIX
#define RSHIFT 11
#define GSHIFT 5
#define BSHIFT 0
#define RBITS 5
#define GBITS 6
#define BBITS 5
#define RMASK (((1 << RBITS) - 1) << RSHIFT)
#define GMASK (((1 << GBITS) - 1) << GSHIFT)
#define BMASK (((1 << BBITS) - 1) << BSHIFT)
#define BPP 16
#define READ_PIX(pPix) \
*((USHORT *)(pPix))
#define WRITE_PIX(pPix) \
*((USHORT *)pPix) = (USHORT)(r | g | b)
GLboolean FASTCALL __fastGenAntiAliasLine565(__GLcontext *gc)
FAST_AA_LINE
GLboolean FASTCALL __fastGenAntiAliasLine(__GLcontext *gc)
{
GLint xLittle, xBig, yLittle, yBig;
GLint fragX2, fragY2;
BYTE *pPix;
BYTE *pPix2;
USHORT *pZ;
USHORT *pZ2;
__GLfragment frag;
__GLcolorBuffer *cfb = gc->drawBuffer;
LONG rAccum, gAccum, bAccum, aAccum;
ULONG rMask, gMask, bMask;
ULONG rShift, gShift, bShift;
ULONG rBits, gBits, bBits;
LONG bytesPerPixel;
LONG pixAdjStep;
ULONG zAdjStep;
ULONG coverage, invCoverage;
LONG fragXinc;
LONG fragYinc;
GLint cfbX, cfbY;
int copyPix;
__GLGENcontext *gengc = (__GLGENcontext *)gc;
__GLzValue zAccum;
GLint clipX1 = gc->transform.clipX1;
GLint clipY1 = gc->transform.clipY1;
GLint fraction, dfraction;
GLint w;
GLuint modeFlags = gc->polygon.shader.modeFlags;
w = gc->line.options.numPixels;
fraction = gc->line.options.fraction;
dfraction = gc->line.options.dfraction;
xBig = gc->line.options.xBig;
yBig = gc->line.options.yBig;
xLittle = gc->line.options.xLittle;
yLittle = gc->line.options.yLittle;
frag.x = gc->line.options.xStart;
frag.y = gc->line.options.yStart;
bytesPerPixel = GENACCEL(gc).xMultiplier;
if (gc->line.options.axis == __GL_Y_MAJOR) {
pixAdjStep = bytesPerPixel;
zAdjStep = 1;
fragXinc = 1;
fragYinc = 0;
// For Y-major non-DIB lines we can copy both affected pixels
// at once since they are adjacent in memory
copyPix = 2;
} else {
if ((cfb->buf.flags & DIB_FORMAT) != 0)
{
pixAdjStep = cfb->buf.outerWidth;
}
else
{
pixAdjStep = 0;
}
zAdjStep = gc->depthBuffer.buf.outerWidth;
fragXinc = 0;
fragYinc = 1;
copyPix = 1;
}
if ((cfb->buf.flags & DIB_FORMAT) != 0)
{
pPix = (BYTE *)((ULONG_PTR)cfb->buf.base +
(__GL_UNBIAS_Y(gc, frag.y) + cfb->buf.yOrigin) * cfb->buf.outerWidth +
(__GL_UNBIAS_X(gc, frag.x) + cfb->buf.xOrigin) * bytesPerPixel);
}
else
{
pPix = gengc->ColorsBits;
}
if (modeFlags & __GL_SHADE_DEPTH_TEST) {
zAccum = gc->polygon.shader.frag.z;
if( gc->modes.depthBits == 32 ) {
pZ = (USHORT *)__GL_DEPTH_ADDR(&gc->depthBuffer, (__GLzValue*),
frag.x, frag.y);
// Adjust for pZ being a USHORT * but traversing a 32-bit
// depth buffer
zAdjStep *= 2;
} else {
pZ = (USHORT *)__GL_DEPTH_ADDR(&gc->depthBuffer,
(__GLz16Value*),
frag.x, frag.y);
}
}
rShift = cfb->redShift;
gShift = cfb->greenShift;
bShift = cfb->blueShift;
rMask = gc->modes.redMask;
gMask = gc->modes.greenMask;
bMask = gc->modes.blueMask;
rBits = gc->modes.redBits;
gBits = gc->modes.greenBits;
bBits = gc->modes.blueBits;
rAccum = CASTFIX(gc->polygon.shader.frag.color.r);
gAccum = CASTFIX(gc->polygon.shader.frag.color.g);
bAccum = CASTFIX(gc->polygon.shader.frag.color.b);
aAccum = CASTFIX(gc->polygon.shader.frag.color.a);
for (;;)
{
CHECK_PIXEL(gc, cfb, w, frag.x, frag.y);
invCoverage = ((fraction << 1) & 0xff000000) >> 16;
coverage = 0xff00 - invCoverage;
if ((cfb->buf.flags & DIB_FORMAT) == 0)
{
cfbX = __GL_UNBIAS_X(gc, frag.x)+cfb->buf.xOrigin;
cfbY = __GL_UNBIAS_Y(gc, frag.y)+cfb->buf.yOrigin;
gengc->pfnCopyPixels(gengc, cfb, cfbX, cfbY, copyPix, FALSE);
}
if (modeFlags & __GL_SHADE_DEPTH_TEST) {
if (!(*GENACCEL(gc).__fastGenZStore)(zAccum, (__GLzValue *)pZ ))
goto noWrite1;
}
if ((cfb->buf.flags & (NO_CLIP | DIB_FORMAT)) == DIB_FORMAT)
{
cfbX = __GL_UNBIAS_X(gc, frag.x)+cfb->buf.xOrigin;
cfbY = __GL_UNBIAS_Y(gc, frag.y)+cfb->buf.yOrigin;
if (!wglPixelVisible(cfbX, cfbY))
{
goto noWrite1;
}
}
WRITE_PIXEL_GEN(pPix, coverage, frag.x, frag.y);
if ((cfb->buf.flags & DIB_FORMAT) == 0 && copyPix == 1)
{
gengc->pfnCopyPixels(gengc, cfb, cfbX, cfbY, copyPix, TRUE);
}
noWrite1:
fragX2 = frag.x + fragXinc;
fragY2 = frag.y + fragYinc;
if ((fragX2 >= clipX1) || (fragY2 >= clipY1)) {
goto noWrite2;
}
pZ2 = pZ+zAdjStep;
if (modeFlags & __GL_SHADE_DEPTH_TEST) {
if (!(*GENACCEL(gc).__fastGenZStore)(zAccum, (__GLzValue *)pZ2 ))
goto noWrite2;
}
if ((cfb->buf.flags & (NO_CLIP | DIB_FORMAT)) == DIB_FORMAT)
{
cfbX = __GL_UNBIAS_X(gc, fragX2)+cfb->buf.xOrigin;
cfbY = __GL_UNBIAS_Y(gc, fragY2)+cfb->buf.yOrigin;
if (!wglPixelVisible(cfbX, cfbY))
{
goto noWrite2;
}
}
pPix2 = pPix + pixAdjStep;
if ((cfb->buf.flags & DIB_FORMAT) == 0 && copyPix == 1)
{
cfbX += fragXinc;
cfbY += fragYinc;
gengc->pfnCopyPixels(gengc, cfb, cfbX, cfbY, copyPix, FALSE);
}
WRITE_PIXEL_GEN(pPix2, invCoverage, fragX2, fragY2);
noWrite2:
if ((cfb->buf.flags & DIB_FORMAT) == 0)
{
gengc->pfnCopyPixels(gengc, cfb, cfbX, cfbY, copyPix, TRUE);
}
if (--w <= 0)
return GL_TRUE;
fraction += dfraction;
if (fraction < 0) {
fraction &= ~0x80000000;
frag.x += xBig;
frag.y += yBig;
pPix += gc->polygon.shader.sbufBig;
pZ += gc->polygon.shader.zbufBig;
} else {
frag.x += xLittle;
frag.y += yLittle;
pPix += gc->polygon.shader.sbufLittle;
pZ += gc->polygon.shader.zbufLittle;
}
if (modeFlags & __GL_SHADE_SMOOTH) {
rAccum += CASTFIX(gc->polygon.shader.drdx);
gAccum += CASTFIX(gc->polygon.shader.dgdx);
bAccum += CASTFIX(gc->polygon.shader.dbdx);
aAccum += CASTFIX(gc->polygon.shader.dadx);
}
if (modeFlags & __GL_SHADE_DEPTH_ITER) {
zAccum += gc->polygon.shader.dzdx;
}
}
return GL_TRUE;
}
/************************************************************************/
#define FAST_A_LINE_BLEND \
{\
GLint xLittle, xBig, yLittle, yBig;\
BYTE *pPix;\
USHORT *pZ;\
__GLfragment frag;\
__GLcolorBuffer *cfb = gc->drawBuffer;\
LONG rAccum, gAccum, bAccum, aAccum;\
LONG bytesPerPixel;\
__GLzValue zAccum;\
GLint fraction, dfraction;\
GLint w;\
GLuint modeFlags = gc->polygon.shader.modeFlags;\
ULONG coverage = 0xff00;\
\
ASSERTOPENGL((cfb->buf.flags &\
(DIB_FORMAT | NO_CLIP)) == (DIB_FORMAT | NO_CLIP),\
"FAST_A_LINE_BLEND on clipping surface\n");\
\
fraction = gc->line.options.fraction;\
dfraction = gc->line.options.dfraction;\
\
xBig = gc->line.options.xBig;\
yBig = gc->line.options.yBig;\
xLittle = gc->line.options.xLittle;\
yLittle = gc->line.options.yLittle;\
\
frag.x = gc->line.options.xStart;\
frag.y = gc->line.options.yStart;\
\
bytesPerPixel = GENACCEL(gc).xMultiplier;\
\
pPix = (BYTE *)((ULONG_PTR)cfb->buf.base +\
(__GL_UNBIAS_Y(gc, frag.y) + cfb->buf.yOrigin) * cfb->buf.outerWidth +\
(__GL_UNBIAS_X(gc, frag.x) + cfb->buf.xOrigin) * bytesPerPixel);\
\
if (modeFlags & __GL_SHADE_DEPTH_TEST) {\
zAccum = gc->polygon.shader.frag.z;\
\
if( gc->modes.depthBits == 32 ) {\
pZ = (USHORT *)__GL_DEPTH_ADDR(&gc->depthBuffer, (__GLzValue*),\
frag.x, frag.y);\
\
} else {\
pZ = (USHORT *)__GL_DEPTH_ADDR(&gc->depthBuffer,\
(__GLz16Value*),\
frag.x, frag.y);\
}\
\
}\
\
rAccum = CASTFIX(gc->polygon.shader.frag.color.r);\
gAccum = CASTFIX(gc->polygon.shader.frag.color.g);\
bAccum = CASTFIX(gc->polygon.shader.frag.color.b);\
aAccum = CASTFIX(gc->polygon.shader.frag.color.a);\
\
w = gc->line.options.numPixels;\
for (;;)\
{\
CHECK_PIXEL(gc, cfb, w, frag.x, frag.y);\
\
if (modeFlags & __GL_SHADE_DEPTH_TEST) {\
if (!(*GENACCEL(gc).__fastGenZStore)(zAccum, (__GLzValue *)pZ))\
goto NoWrite;\
}\
\
BLEND_PIXEL(pPix, coverage, frag.x, frag.y);\
NoWrite:\
\
if (--w <= 0)\
return GL_TRUE;\
\
fraction += dfraction;\
if (fraction < 0) {\
fraction &= ~0x80000000;\
frag.x += xBig;\
frag.y += yBig;\
pPix += gc->polygon.shader.sbufBig;\
pZ += gc->polygon.shader.zbufBig;\
} else {\
frag.x += xLittle;\
frag.y += yLittle;\
pPix += gc->polygon.shader.sbufLittle;\
pZ += gc->polygon.shader.zbufLittle;\
}\
\
if (modeFlags & __GL_SHADE_SMOOTH) {\
rAccum += CASTFIX(gc->polygon.shader.drdx);\
gAccum += CASTFIX(gc->polygon.shader.dgdx);\
bAccum += CASTFIX(gc->polygon.shader.dbdx);\
aAccum += CASTFIX(gc->polygon.shader.dadx);\
}\
\
if (modeFlags & __GL_SHADE_DEPTH_ITER) {\
zAccum += gc->polygon.shader.dzdx;\
}\
}\
\
return GL_TRUE;\
}
#undef BPP
#undef RSHIFT
#undef GSHIFT
#undef BSHIFT
#undef RBITS
#undef GBITS
#undef BBITS
#undef RMASK
#undef GMASK
#undef BMASK
#undef READ_PIX
#undef WRITE_PIX
#define RSHIFT 0
#define GSHIFT 3
#define BSHIFT 6
#define RBITS 3
#define GBITS 3
#define BBITS 2
#define RMASK (((1 << RBITS) - 1) << RSHIFT)
#define GMASK (((1 << GBITS) - 1) << GSHIFT)
#define BMASK (((1 << BBITS) - 1) << BSHIFT)
#define BPP 8
#define READ_PIX(pPix) \
((__GLGENcontext *)gc)->pajInvTranslateVector[*((BYTE *)(pPix))]
#define WRITE_PIX(pPix) \
pPix[0] = ((__GLGENcontext *)gc)->xlatPalette[r | g | b]
GLboolean FASTCALL __fastGenBlendAliasLine332(__GLcontext *gc)
FAST_A_LINE_BLEND
#undef BPP
#undef RSHIFT
#undef GSHIFT
#undef BSHIFT
#undef RBITS
#undef GBITS
#undef BBITS
#undef RMASK
#undef GMASK
#undef BMASK
#undef READ_PIX
#undef WRITE_PIX
#define RSHIFT 10
#define GSHIFT 5
#define BSHIFT 0
#define RBITS 5
#define GBITS 5
#define BBITS 5
#define RMASK (((1 << RBITS) - 1) << RSHIFT)
#define GMASK (((1 << GBITS) - 1) << GSHIFT)
#define BMASK (((1 << BBITS) - 1) << BSHIFT)
#define BPP 16
#define READ_PIX(pPix) \
*((USHORT *)(pPix))
#define WRITE_PIX(pPix) \
*((USHORT *)pPix) = (USHORT)(r | g | b)
GLboolean FASTCALL __fastGenBlendAliasLine555(__GLcontext *gc)
FAST_A_LINE_BLEND
#undef BPP
#undef RSHIFT
#undef GSHIFT
#undef BSHIFT
#undef RBITS
#undef GBITS
#undef BBITS
#undef RMASK
#undef GMASK
#undef BMASK
#undef READ_PIX
#undef WRITE_PIX
#define RSHIFT 11
#define GSHIFT 5
#define BSHIFT 0
#define RBITS 5
#define GBITS 6
#define BBITS 5
#define RMASK (((1 << RBITS) - 1) << RSHIFT)
#define GMASK (((1 << GBITS) - 1) << GSHIFT)
#define BMASK (((1 << BBITS) - 1) << BSHIFT)
#define BPP 16
#define READ_PIX(pPix) \
*((USHORT *)(pPix))
#define WRITE_PIX(pPix) \
*((USHORT *)pPix) = (USHORT)(r | g | b)
GLboolean FASTCALL __fastGenBlendAliasLine565(__GLcontext *gc)
FAST_A_LINE_BLEND
/************************************************************************/
#define FAST_A_LINE_NO_BLEND \
{\
GLint xLittle, xBig, yLittle, yBig;\
BYTE *pPix;\
USHORT *pZ;\
__GLfragment frag;\
__GLcolorBuffer *cfb = gc->drawBuffer;\
LONG rAccum, gAccum, bAccum;\
LONG bytesPerPixel;\
__GLzValue zAccum;\
GLint fraction, dfraction;\
GLint w;\
GLuint modeFlags = gc->polygon.shader.modeFlags;\
\
ASSERTOPENGL((cfb->buf.flags &\
(DIB_FORMAT | NO_CLIP)) == (DIB_FORMAT | NO_CLIP),\
"FAST_A_LINE_NO_BLEND on clipping surface\n");\
\
fraction = gc->line.options.fraction;\
dfraction = gc->line.options.dfraction;\
\
xBig = gc->line.options.xBig;\
yBig = gc->line.options.yBig;\
xLittle = gc->line.options.xLittle;\
yLittle = gc->line.options.yLittle;\
\
frag.x = gc->line.options.xStart;\
frag.y = gc->line.options.yStart;\
\
bytesPerPixel = GENACCEL(gc).xMultiplier;\
\
pPix = (BYTE *)((ULONG_PTR)cfb->buf.base +\
(__GL_UNBIAS_Y(gc, frag.y) + cfb->buf.yOrigin) * cfb->buf.outerWidth +\
(__GL_UNBIAS_X(gc, frag.x) + cfb->buf.xOrigin) * bytesPerPixel);\
\
if (modeFlags & __GL_SHADE_DEPTH_TEST) {\
zAccum = gc->polygon.shader.frag.z;\
\
if( gc->modes.depthBits == 32 ) {\
pZ = (USHORT *)__GL_DEPTH_ADDR(&gc->depthBuffer, (__GLzValue*),\
frag.x, frag.y);\
\
} else {\
pZ = (USHORT *)__GL_DEPTH_ADDR(&gc->depthBuffer,\
(__GLz16Value*),\
frag.x, frag.y);\
}\
\
}\
\
rAccum = CASTFIX(gc->polygon.shader.frag.color.r);\
gAccum = CASTFIX(gc->polygon.shader.frag.color.g);\
bAccum = CASTFIX(gc->polygon.shader.frag.color.b);\
\
w = gc->line.options.numPixels;\
for (;;)\
{\
CHECK_PIXEL(gc, cfb, w, frag.x, frag.y);\
\
if (modeFlags & __GL_SHADE_DEPTH_TEST) {\
if (!(*GENACCEL(gc).__fastGenZStore)(zAccum, (__GLzValue *)pZ))\
goto NoWrite;\
}\
\
DITHER_PIXEL(pPix, frag.x, frag.y);\
NoWrite:\
\
if (--w <= 0)\
return GL_TRUE;\
\
fraction += dfraction;\
if (fraction < 0) {\
fraction &= ~0x80000000;\
frag.x += xBig;\
frag.y += yBig;\
pPix += gc->polygon.shader.sbufBig;\
pZ += gc->polygon.shader.zbufBig;\
} else {\
frag.x += xLittle;\
frag.y += yLittle;\
pPix += gc->polygon.shader.sbufLittle;\
pZ += gc->polygon.shader.zbufLittle;\
}\
\
if (modeFlags & __GL_SHADE_SMOOTH) {\
rAccum += CASTFIX(gc->polygon.shader.drdx);\
gAccum += CASTFIX(gc->polygon.shader.dgdx);\
bAccum += CASTFIX(gc->polygon.shader.dbdx);\
}\
\
if (modeFlags & __GL_SHADE_DEPTH_ITER) {\
zAccum += gc->polygon.shader.dzdx;\
}\
}\
\
return GL_TRUE;\
}
#undef BPP
#undef RSHIFT
#undef GSHIFT
#undef BSHIFT
#undef RBITS
#undef GBITS
#undef BBITS
#undef RMASK
#undef GMASK
#undef BMASK
#undef READ_PIX
#undef WRITE_PIX
#define RSHIFT 0
#define GSHIFT 3
#define BSHIFT 6
#define RBITS 3
#define GBITS 3
#define BBITS 2
#define RMASK (((1 << RBITS) - 1) << RSHIFT)
#define GMASK (((1 << GBITS) - 1) << GSHIFT)
#define BMASK (((1 << BBITS) - 1) << BSHIFT)
#define BPP 8
#define WRITE_PIX(pPix) \
pPix[0] = ((__GLGENcontext *)gc)->xlatPalette[r | g | b]
GLboolean FASTCALL __fastGenNoBlendAliasLine332(__GLcontext *gc)
FAST_A_LINE_NO_BLEND
#undef BPP
#undef RSHIFT
#undef GSHIFT
#undef BSHIFT
#undef RBITS
#undef GBITS
#undef BBITS
#undef RMASK
#undef GMASK
#undef BMASK
#undef READ_PIX
#undef WRITE_PIX
#define RSHIFT 10
#define GSHIFT 5
#define BSHIFT 0
#define RBITS 5
#define GBITS 5
#define BBITS 5
#define RMASK (((1 << RBITS) - 1) << RSHIFT)
#define GMASK (((1 << GBITS) - 1) << GSHIFT)
#define BMASK (((1 << BBITS) - 1) << BSHIFT)
#define BPP 16
#define WRITE_PIX(pPix) \
*((USHORT *)pPix) = (USHORT)(r | g | b)
GLboolean FASTCALL __fastGenNoBlendAliasLine555(__GLcontext *gc)
FAST_A_LINE_NO_BLEND
#undef BPP
#undef RSHIFT
#undef GSHIFT
#undef BSHIFT
#undef RBITS
#undef GBITS
#undef BBITS
#undef RMASK
#undef GMASK
#undef BMASK
#undef READ_PIX
#undef WRITE_PIX
#define RSHIFT 11
#define GSHIFT 5
#define BSHIFT 0
#define RBITS 5
#define GBITS 6
#define BBITS 5
#define RMASK (((1 << RBITS) - 1) << RSHIFT)
#define GMASK (((1 << GBITS) - 1) << GSHIFT)
#define BMASK (((1 << BBITS) - 1) << BSHIFT)
#define BPP 16
#define WRITE_PIX(pPix) \
*((USHORT *)pPix) = (USHORT)(r | g | b)
GLboolean FASTCALL __fastGenNoBlendAliasLine565(__GLcontext *gc)
FAST_A_LINE_NO_BLEND
// WRITE_PIXEL_GEN handles both blending and no blending so this
// generic routine works for both of those cases
GLboolean FASTCALL __fastGenAliasLine(__GLcontext *gc)
{
GLint xLittle, xBig, yLittle, yBig;
BYTE *pPix;
USHORT *pZ;
__GLfragment frag;
__GLcolorBuffer *cfb = gc->drawBuffer;
LONG rAccum, gAccum, bAccum, aAccum;
ULONG rMask, gMask, bMask;
ULONG rShift, gShift, bShift;
ULONG rBits, gBits, bBits;
LONG bytesPerPixel;
GLint cfbX, cfbY;
__GLGENcontext *gengc = (__GLGENcontext *)gc;
__GLzValue zAccum;
GLint fraction, dfraction;
GLint w;
GLuint modeFlags = gc->polygon.shader.modeFlags;
// Only present for placeholder in WRITE_PIXEL_GEN macro
ULONG coverage = 0xff00;
w = gc->line.options.numPixels;
fraction = gc->line.options.fraction;
dfraction = gc->line.options.dfraction;
xBig = gc->line.options.xBig;
yBig = gc->line.options.yBig;
xLittle = gc->line.options.xLittle;
yLittle = gc->line.options.yLittle;
frag.x = gc->line.options.xStart;
frag.y = gc->line.options.yStart;
bytesPerPixel = GENACCEL(gc).xMultiplier;
if ((cfb->buf.flags & DIB_FORMAT) != 0)
{
pPix = (BYTE *)((ULONG_PTR)cfb->buf.base +
(__GL_UNBIAS_Y(gc, frag.y) + cfb->buf.yOrigin) * cfb->buf.outerWidth +
(__GL_UNBIAS_X(gc, frag.x) + cfb->buf.xOrigin) * bytesPerPixel);
}
else
{
pPix = gengc->ColorsBits;
}
if (modeFlags & __GL_SHADE_DEPTH_TEST) {
zAccum = gc->polygon.shader.frag.z;
if( gc->modes.depthBits == 32 ) {
pZ = (USHORT *)__GL_DEPTH_ADDR(&gc->depthBuffer, (__GLzValue*),
frag.x, frag.y);
} else {
pZ = (USHORT *)__GL_DEPTH_ADDR(&gc->depthBuffer,
(__GLz16Value*),
frag.x, frag.y);
}
}
rShift = cfb->redShift;
gShift = cfb->greenShift;
bShift = cfb->blueShift;
rMask = gc->modes.redMask;
gMask = gc->modes.greenMask;
bMask = gc->modes.blueMask;
rBits = gc->modes.redBits;
gBits = gc->modes.greenBits;
bBits = gc->modes.blueBits;
rAccum = CASTFIX(gc->polygon.shader.frag.color.r);
gAccum = CASTFIX(gc->polygon.shader.frag.color.g);
bAccum = CASTFIX(gc->polygon.shader.frag.color.b);
aAccum = CASTFIX(gc->polygon.shader.frag.color.a);
for (;;)
{
CHECK_PIXEL(gc, cfb, w, frag.x, frag.y);
if (modeFlags & __GL_SHADE_DEPTH_TEST) {
if (!(*GENACCEL(gc).__fastGenZStore)(zAccum, (__GLzValue *)pZ))
goto NoWrite;
}
if ((cfb->buf.flags & (NO_CLIP | DIB_FORMAT)) == DIB_FORMAT)
{
cfbX = __GL_UNBIAS_X(gc, frag.x)+cfb->buf.xOrigin;
cfbY = __GL_UNBIAS_Y(gc, frag.y)+cfb->buf.yOrigin;
if (!wglPixelVisible(cfbX, cfbY))
{
goto NoWrite;
}
}
if ((cfb->buf.flags & DIB_FORMAT) == 0)
{
cfbX = __GL_UNBIAS_X(gc, frag.x)+cfb->buf.xOrigin;
cfbY = __GL_UNBIAS_Y(gc, frag.y)+cfb->buf.yOrigin;
gengc->pfnCopyPixels(gengc, cfb, cfbX, cfbY, 1, FALSE);
}
WRITE_PIXEL_GEN(pPix, coverage, frag.x, frag.y);
if ((cfb->buf.flags & DIB_FORMAT) == 0)
{
gengc->pfnCopyPixels(gengc, cfb, cfbX, cfbY, 1, TRUE);
}
NoWrite:
if (--w <= 0)
return GL_TRUE;
fraction += dfraction;
if (fraction < 0) {
fraction &= ~0x80000000;
frag.x += xBig;
frag.y += yBig;
pPix += gc->polygon.shader.sbufBig;
pZ += gc->polygon.shader.zbufBig;
} else {
frag.x += xLittle;
frag.y += yLittle;
pPix += gc->polygon.shader.sbufLittle;
pZ += gc->polygon.shader.zbufLittle;
}
if (modeFlags & __GL_SHADE_SMOOTH) {
rAccum += CASTFIX(gc->polygon.shader.drdx);
gAccum += CASTFIX(gc->polygon.shader.dgdx);
bAccum += CASTFIX(gc->polygon.shader.dbdx);
aAccum += CASTFIX(gc->polygon.shader.dadx);
}
if (modeFlags & __GL_SHADE_DEPTH_ITER) {
zAccum += gc->polygon.shader.dzdx;
}
}
return GL_TRUE;
}
/************************************************************************/
// Bits 0-1 are for pixel format
// Bit 2 is for GL_BLEND enable
// Bit 3 is for GL_LINE_SMOOTH_ENABLE
fastGenLineProc pfnFastGenLineProcs[] =
{
__fastGenAliasLine,
__fastGenNoBlendAliasLine332,
__fastGenNoBlendAliasLine555,
__fastGenNoBlendAliasLine565,
__fastGenAliasLine,
__fastGenBlendAliasLine332,
__fastGenBlendAliasLine555,
__fastGenBlendAliasLine565,
__fastGenAntiAliasLine,
__fastGenAntiAliasLine,
__fastGenAntiAliasLine,
__fastGenAntiAliasLine,
__fastGenAntiAliasLine,
__fastGenAntiAliasLine332,
__fastGenAntiAliasLine555,
__fastGenAntiAliasLine565
};
//
// Assumptions for accelerated lines:
//
// no blending, or (SRC, 1-SRC), or (SRC, 1)
// not both buffers
// not stippled
// not stenciled
// not textured
// not alpha-tested
// not masked, zmasked
// no logicOp
// not slow fog
// not color-indexed
// not wide
#define __SLOW_LINE_MODE_FLAGS \
(__GL_SHADE_TEXTURE | __GL_SHADE_LINE_STIPPLE | \
__GL_SHADE_STENCIL_TEST | __GL_SHADE_LOGICOP | \
__GL_SHADE_ALPHA_TEST | __GL_SHADE_MASK | \
__GL_SHADE_SLOW_FOG)
BOOL FASTCALL __glGenSetupEitherLines(__GLcontext *gc)
{
#ifdef _MCD_
GENMCDSTATE *pMcdState = ((__GLGENcontext *) gc)->pMcdState;
#endif
GLuint modeFlags = gc->polygon.shader.modeFlags;
LONG bytesPerPixel;
int fmt;
BOOL bAccelerate =
(((__GLGENcontext *)gc)->gsurf.pfd.cColorBits >= 8) &&
(gc->state.raster.drawBuffer != GL_FRONT_AND_BACK) &&
(gc->state.raster.drawBuffer != GL_NONE) &&
( ! ALPHA_WRITE_ENABLED( gc->drawBuffer ) ) &&
(
((gc->polygon.shader.modeFlags & __GL_SHADE_DEPTH_TEST) &&
(gc->polygon.shader.modeFlags & __GL_SHADE_DEPTH_ITER) &&
(gc->state.depth.writeEnable)) ||
(!(gc->polygon.shader.modeFlags & __GL_SHADE_DEPTH_TEST) &&
!(gc->polygon.shader.modeFlags & __GL_SHADE_DEPTH_ITER))
) &&
(gc->transform.reasonableViewport) &&
(gc->state.line.aliasedWidth == 1) &&
(modeFlags & __GL_SHADE_RGB) &&
#ifdef GL_WIN_phong_shading
!(modeFlags & __GL_SHADE_PHONG) &&
#endif //GL_WIN_phong_shading
#ifdef GL_WIN_specular_fog
!(modeFlags & __GL_SHADE_SPEC_FOG) &&
#endif //GL_WIN_specular_fog
(!(modeFlags & __SLOW_LINE_MODE_FLAGS)) &&
(!(gc->state.enables.general & __GL_BLEND_ENABLE) ||
((gc->state.raster.blendSrc == GL_SRC_ALPHA) &&
((gc->state.raster.blendDst == GL_ONE_MINUS_SRC_ALPHA) ||
(gc->state.raster.blendDst == GL_ONE)))
);
#ifdef _MCD_
bAccelerate &= (!pMcdState || (pMcdState->McdBuffers.mcdDepthBuf.bufFlags & MCDBUF_ENABLED));
#endif
// Resort to soft code if we can't handle the line:
if (!bAccelerate)
{
return FALSE;
}
else if (gc->state.enables.general & __GL_LINE_SMOOTH_ENABLE)
{
if (gc->state.hints.lineSmooth == GL_NICEST)
{
return FALSE;
}
}
else if ((modeFlags & __GL_SHADE_CHEAP_FOG) &&
(modeFlags & __GL_SHADE_SMOOTH_LIGHT) == 0)
{
// We only support cheap fog done by the front end, not
// flat cheap fog done by the render procs
return FALSE;
}
GENACCEL(gc).xMultiplier = bytesPerPixel =
(((__GLGENcontext *)gc)->gsurf.pfd.cColorBits + 7) >> 3;
// Set up our local z-buffer procs:
if (modeFlags & __GL_SHADE_DEPTH_ITER)
__fastGenPickZStoreProc(gc);
gc->procs.renderLine = __glGenRenderEitherLine;
// Assume generic format
fmt = 0;
// For deep-color modes, we don't support most-significant-byte
// formats...
// For non-MSB deep-color modes, we only support generic rendering
if (bytesPerPixel > 2)
{
if (((gc->drawBuffer->redShift > 16) ||
(gc->drawBuffer->greenShift > 16) ||
(gc->drawBuffer->blueShift > 16)))
{
return FALSE;
}
else
{
goto PickProc;
}
}
// Just use generic acceleration if we're not
// dithering, since these are hardwired into the fastest routines...
// We also only support unclipped surfaces in the fastest routines
if (!(modeFlags & __GL_SHADE_DITHER) ||
(gc->drawBuffer->buf.flags & (DIB_FORMAT | NO_CLIP)) !=
(DIB_FORMAT | NO_CLIP))
{
goto PickProc;
}
// Now, check for supported color formats for fastest modes:
if ((bytesPerPixel == 1) &&
(gc->drawBuffer->redShift == 0) &&
(gc->drawBuffer->greenShift == 3) &&
(gc->drawBuffer->blueShift == 6))
{
fmt = 1;
}
else if (bytesPerPixel == 2)
{
if ((gc->drawBuffer->greenShift == 5) &&
(gc->drawBuffer->blueShift == 0))
{
if (gc->drawBuffer->redShift == 10)
{
fmt = 2;
}
else if (gc->drawBuffer->redShift == 11)
{
fmt = 3;
}
}
}
PickProc:
if (gc->state.enables.general & __GL_BLEND_ENABLE)
{
fmt += 4;
}
if (gc->state.enables.general & __GL_LINE_SMOOTH_ENABLE)
{
fmt += 8;
}
GENACCEL(gc).__fastGenLineProc = pfnFastGenLineProcs[fmt];
if (gc->state.line.aliasedWidth != 1)
{
GENACCEL(gc).__fastGenInitLineData = __glInitLineData;
}
else
{
GENACCEL(gc).__fastGenInitLineData = __glInitThinLineData;
}
return TRUE;
}