/******************************Module*Header*******************************\
* Module Name: fastfill.c
*
* Draws fast solid-coloured, unclipped, non-complex rectangles.
*
* Copyright (c) 1993-1995 Microsoft Corporation
\**************************************************************************/
#include "precomp.h"
#define RIGHT 0
#define LEFT 1
typedef struct _TRAPEZOIDDATA TRAPEZOIDDATA; // Handy forward declaration
typedef VOID (FNTRAPEZOID)(TRAPEZOIDDATA*, LONG, LONG);
// Prototype for trapezoid
// drawing routines
typedef struct _EDGEDATA {
LONG x; // Current x position
LONG dx; // # pixels to advance x on each scan
LONG lError; // Current DDA error
LONG lErrorUp; // DDA error increment on each scan
LONG lErrorDown; // DDA error adjustment
POINTFIX* pptfx; // Points to start of current edge
LONG dptfx; // Delta (in bytes) from pptfx to next point
LONG cy; // Number of scans to go for this edge
} EDGEDATA; /* ed, ped */
typedef struct _TRAPEZOIDDATA {
FNTRAPEZOID* pfnTrap; // Pointer to appropriate trapezoid drawing routine
PDEV* ppdev; // Pointer to PDEV
EDGEDATA aed[2]; // DDA information for both edges
RBRUSH* prb; // Pointer to brush realization
POINTL ptlBrush; // Brush alignment
} TRAPEZOIDDATA; /* td, ptd */
/******************************Public*Routine******************************\
* VOID vIoSolidTrapezoid
*
\**************************************************************************/
VOID vIoSolidTrapezoid(
TRAPEZOIDDATA* ptd,
LONG yTrapezoid,
LONG cyTrapezoid)
{
PDEV* ppdev = ptd->ppdev;
BYTE* pjIoBase = ppdev->pjIoBase;
// If the left and right edges are vertical, simply output as
// a rectangle:
if (((ptd->aed[LEFT].lErrorUp | ptd->aed[RIGHT].lErrorUp) == 0) &&
((ptd->aed[LEFT].dx | ptd->aed[RIGHT].dx) == 0) &&
(cyTrapezoid > 1))
{
LONG lWidth;
/////////////////////////////////////////////////////////////////
// Vertical-edge special case
ContinueVertical:
lWidth = ptd->aed[RIGHT].x - ptd->aed[LEFT].x;
if (lWidth > 0)
{
IO_WAIT_BUFFER_NOT_BUSY(ppdev, pjIoBase);
IO_BITMAP_WIDTH(ppdev, pjIoBase, lWidth);
IO_BITMAP_HEIGHT(ppdev, pjIoBase, cyTrapezoid);
IO_DEST_XY(ppdev, pjIoBase, ptd->aed[LEFT].x, yTrapezoid);
IO_BLT_CMD_0(ppdev, pjIoBase, START_BLT);
IO_WAIT_BUFFER_NOT_BUSY(ppdev, pjIoBase);
IO_BITMAP_HEIGHT(ppdev, pjIoBase, 1);
}
else if (lWidth < 0)
{
LONG lTmp;
POINTFIX* pptfxTmp;
SWAP(ptd->aed[LEFT].x, ptd->aed[RIGHT].x, lTmp);
SWAP(ptd->aed[LEFT].cy, ptd->aed[RIGHT].cy, lTmp);
SWAP(ptd->aed[LEFT].dptfx, ptd->aed[RIGHT].dptfx, lTmp);
SWAP(ptd->aed[LEFT].pptfx, ptd->aed[RIGHT].pptfx, pptfxTmp);
goto ContinueVertical;
}
}
else
{
LONG lLeftError = ptd->aed[LEFT].lError;
LONG dxLeft = ptd->aed[LEFT].dx;
LONG xLeft = ptd->aed[LEFT].x;
LONG lRightError = ptd->aed[RIGHT].lError;
LONG dxRight = ptd->aed[RIGHT].dx;
LONG xRight = ptd->aed[RIGHT].x;
while (TRUE)
{
LONG lWidth;
/////////////////////////////////////////////////////////////////
// Run the DDAs
lWidth = xRight - xLeft;
if (lWidth > 0)
{
IO_WAIT_BUFFER_NOT_BUSY(ppdev, pjIoBase);
IO_BITMAP_WIDTH(ppdev, pjIoBase, lWidth);
IO_DEST_XY(ppdev, pjIoBase, xLeft, yTrapezoid);
IO_BLT_CMD_0(ppdev, pjIoBase, START_BLT);
ContinueAfterZero:
yTrapezoid++;
// Advance the right wall:
xRight += dxRight;
lRightError += ptd->aed[RIGHT].lErrorUp;
if (lRightError >= 0)
{
lRightError -= ptd->aed[RIGHT].lErrorDown;
xRight++;
}
// Advance the left wall:
xLeft += dxLeft;
lLeftError += ptd->aed[LEFT].lErrorUp;
if (lLeftError >= 0)
{
lLeftError -= ptd->aed[LEFT].lErrorDown;
xLeft++;
}
cyTrapezoid--;
if (cyTrapezoid == 0)
break;
}
else if (lWidth == 0)
{
goto ContinueAfterZero;
}
else
{
// We certainly don't want to optimize for this case because we
// should rarely get self-intersecting polygons (if we're slow,
// the app gets what it deserves):
LONG lTmp;
POINTFIX* pptfxTmp;
SWAP(xLeft, xRight, lTmp);
SWAP(dxLeft, dxRight, lTmp);
SWAP(lLeftError, lRightError, lTmp);
SWAP(ptd->aed[LEFT].lErrorUp, ptd->aed[RIGHT].lErrorUp, lTmp);
SWAP(ptd->aed[LEFT].lErrorDown, ptd->aed[RIGHT].lErrorDown, lTmp);
SWAP(ptd->aed[LEFT].cy, ptd->aed[RIGHT].cy, lTmp);
SWAP(ptd->aed[LEFT].dptfx, ptd->aed[RIGHT].dptfx, lTmp);
SWAP(ptd->aed[LEFT].pptfx, ptd->aed[RIGHT].pptfx, pptfxTmp);
}
}
ptd->aed[LEFT].lError = lLeftError;
ptd->aed[LEFT].dx = dxLeft;
ptd->aed[LEFT].x = xLeft;
ptd->aed[RIGHT].lError = lRightError;
ptd->aed[RIGHT].dx = dxRight;
ptd->aed[RIGHT].x = xRight;
}
}
/******************************Public*Routine******************************\
* VOID vIo2ColorTrapezoid
*
\**************************************************************************/
VOID vIo2ColorTrapezoid(
TRAPEZOIDDATA* ptd,
LONG yTrapezoid,
LONG cyTrapezoid)
{
PDEV* ppdev = ptd->ppdev;
BYTE* pjIoBase = ppdev->pjIoBase;
LONG xAlign;
LONG yAlign;
xAlign = ptd->ptlBrush.x;
yAlign = ptd->ptlBrush.y;
// If the left and right edges are vertical, simply output as
// a rectangle:
if (((ptd->aed[LEFT].lErrorUp | ptd->aed[RIGHT].lErrorUp) == 0) &&
((ptd->aed[LEFT].dx | ptd->aed[RIGHT].dx) == 0) &&
(cyTrapezoid > 1))
{
LONG lWidth;
/////////////////////////////////////////////////////////////////
// Vertical-edge special case
ContinueVertical:
lWidth = ptd->aed[RIGHT].x - ptd->aed[LEFT].x;
if (lWidth > 0)
{
IO_WAIT_BUFFER_NOT_BUSY(ppdev, pjIoBase);
IO_BITMAP_WIDTH(ppdev, pjIoBase, lWidth);
IO_BITMAP_HEIGHT(ppdev, pjIoBase, cyTrapezoid);
IO_DEST_XY(ppdev, pjIoBase, ptd->aed[LEFT].x, yTrapezoid);
IO_SRC_ALIGN(ppdev, pjIoBase, ((ptd->aed[LEFT].x - xAlign) & 7) |
((yTrapezoid - yAlign) << 3));
IO_BLT_CMD_0(ppdev, pjIoBase, START_BLT);
IO_WAIT_BUFFER_NOT_BUSY(ppdev, pjIoBase);
IO_BITMAP_HEIGHT(ppdev, pjIoBase, 1);
}
else if (lWidth < 0)
{
LONG lTmp;
POINTFIX* pptfxTmp;
SWAP(ptd->aed[LEFT].x, ptd->aed[RIGHT].x, lTmp);
SWAP(ptd->aed[LEFT].cy, ptd->aed[RIGHT].cy, lTmp);
SWAP(ptd->aed[LEFT].dptfx, ptd->aed[RIGHT].dptfx, lTmp);
SWAP(ptd->aed[LEFT].pptfx, ptd->aed[RIGHT].pptfx, pptfxTmp);
goto ContinueVertical;
}
}
else
{
LONG lLeftError = ptd->aed[LEFT].lError;
LONG dxLeft = ptd->aed[LEFT].dx;
LONG xLeft = ptd->aed[LEFT].x;
LONG lRightError = ptd->aed[RIGHT].lError;
LONG dxRight = ptd->aed[RIGHT].dx;
LONG xRight = ptd->aed[RIGHT].x;
LONG yScaledAlign;
// Scale y alignment up by 8 so that it's easier to compute
// the QVision's alignment on each scan:
yScaledAlign = (yTrapezoid - yAlign) << 3;
while (TRUE)
{
LONG lWidth;
/////////////////////////////////////////////////////////////////
// Run the DDAs
lWidth = xRight - xLeft;
if (lWidth > 0)
{
IO_WAIT_BUFFER_NOT_BUSY(ppdev, pjIoBase);
IO_BITMAP_WIDTH(ppdev, pjIoBase, lWidth);
IO_DEST_XY(ppdev, pjIoBase, xLeft, yTrapezoid);
IO_SRC_ALIGN(ppdev, pjIoBase, (((xLeft - xAlign) & 7)
| yScaledAlign));
IO_BLT_CMD_0(ppdev, pjIoBase, START_BLT);
ContinueAfterZero:
yScaledAlign += 8;
yTrapezoid++;
// Advance the right wall:
xRight += dxRight;
lRightError += ptd->aed[RIGHT].lErrorUp;
if (lRightError >= 0)
{
lRightError -= ptd->aed[RIGHT].lErrorDown;
xRight++;
}
// Advance the left wall:
xLeft += dxLeft;
lLeftError += ptd->aed[LEFT].lErrorUp;
if (lLeftError >= 0)
{
lLeftError -= ptd->aed[LEFT].lErrorDown;
xLeft++;
}
cyTrapezoid--;
if (cyTrapezoid == 0)
break;
}
else if (lWidth == 0)
{
goto ContinueAfterZero;
}
else
{
// We certainly don't want to optimize for this case because we
// should rarely get self-intersecting polygons (if we're slow,
// the app gets what it deserves):
LONG lTmp;
POINTFIX* pptfxTmp;
SWAP(xLeft, xRight, lTmp);
SWAP(dxLeft, dxRight, lTmp);
SWAP(lLeftError, lRightError, lTmp);
SWAP(ptd->aed[LEFT].lErrorUp, ptd->aed[RIGHT].lErrorUp, lTmp);
SWAP(ptd->aed[LEFT].lErrorDown, ptd->aed[RIGHT].lErrorDown, lTmp);
SWAP(ptd->aed[LEFT].cy, ptd->aed[RIGHT].cy, lTmp);
SWAP(ptd->aed[LEFT].dptfx, ptd->aed[RIGHT].dptfx, lTmp);
SWAP(ptd->aed[LEFT].pptfx, ptd->aed[RIGHT].pptfx, pptfxTmp);
}
}
ptd->aed[LEFT].lError = lLeftError;
ptd->aed[LEFT].dx = dxLeft;
ptd->aed[LEFT].x = xLeft;
ptd->aed[RIGHT].lError = lRightError;
ptd->aed[RIGHT].dx = dxRight;
ptd->aed[RIGHT].x = xRight;
}
}
/******************************Public*Routine******************************\
* VOID vIoPatternedTrapezoid
*
\**************************************************************************/
VOID vIoPatternedTrapezoid(
TRAPEZOIDDATA* ptd,
LONG yTrapezoid,
LONG cyTrapezoid)
{
PDEV* ppdev = ptd->ppdev;
BYTE* pjIoBase = ppdev->pjIoBase;
LONG lLeftError = ptd->aed[LEFT].lError;
LONG dxLeft = ptd->aed[LEFT].dx;
LONG xLeft = ptd->aed[LEFT].x;
LONG lRightError = ptd->aed[RIGHT].lError;
LONG dxRight = ptd->aed[RIGHT].dx;
LONG xRight = ptd->aed[RIGHT].x;
BYTE* pjPattern;
LONG iPattern;
LONG xAlign;
xAlign = ptd->ptlBrush.x;
iPattern = 8 * (yTrapezoid - ptd->ptlBrush.y);
pjPattern = (BYTE*) ptd->prb->aulPattern;
while (TRUE)
{
LONG lWidth;
/////////////////////////////////////////////////////////////////
// Run the DDAs
lWidth = xRight - xLeft;
if (lWidth > 0)
{
// Note that we're setting these buffered registers without
// first checking for idle, or even buffer not busy. But
// this is safe because at initialization, we did a wait
// for idle, and here we always loop after waiting for idle
// to set the pattern registers.
IO_BITMAP_WIDTH(ppdev, pjIoBase, lWidth);
IO_DEST_XY(ppdev, pjIoBase, xLeft, yTrapezoid);
IO_SRC_ALIGN(ppdev, pjIoBase, xLeft - xAlign);
IO_WAIT_FOR_IDLE(ppdev, pjIoBase);
IO_PREG_PATTERN(ppdev, pjIoBase, pjPattern + (iPattern & 63));
IO_BLT_CMD_0(ppdev, pjIoBase, START_BLT);
ContinueAfterZero:
iPattern += 8;
yTrapezoid++;
// Advance the right wall:
xRight += dxRight;
lRightError += ptd->aed[RIGHT].lErrorUp;
if (lRightError >= 0)
{
lRightError -= ptd->aed[RIGHT].lErrorDown;
xRight++;
}
// Advance the left wall:
xLeft += dxLeft;
lLeftError += ptd->aed[LEFT].lErrorUp;
if (lLeftError >= 0)
{
lLeftError -= ptd->aed[LEFT].lErrorDown;
xLeft++;
}
cyTrapezoid--;
if (cyTrapezoid == 0)
break;
}
else if (lWidth == 0)
{
goto ContinueAfterZero;
}
else
{
// We certainly don't want to optimize for this case because we
// should rarely get self-intersecting polygons (if we're slow,
// the app gets what it deserves):
LONG lTmp;
POINTFIX* pptfxTmp;
SWAP(xLeft, xRight, lTmp);
SWAP(dxLeft, dxRight, lTmp);
SWAP(lLeftError, lRightError, lTmp);
SWAP(ptd->aed[LEFT].lErrorUp, ptd->aed[RIGHT].lErrorUp, lTmp);
SWAP(ptd->aed[LEFT].lErrorDown, ptd->aed[RIGHT].lErrorDown, lTmp);
SWAP(ptd->aed[LEFT].cy, ptd->aed[RIGHT].cy, lTmp);
SWAP(ptd->aed[LEFT].dptfx, ptd->aed[RIGHT].dptfx, lTmp);
SWAP(ptd->aed[LEFT].pptfx, ptd->aed[RIGHT].pptfx, pptfxTmp);
}
}
ptd->aed[LEFT].lError = lLeftError;
ptd->aed[LEFT].dx = dxLeft;
ptd->aed[LEFT].x = xLeft;
ptd->aed[RIGHT].lError = lRightError;
ptd->aed[RIGHT].dx = dxRight;
ptd->aed[RIGHT].x = xRight;
}
/******************************Public*Routine******************************\
* VOID vIoTrapezoidSetup
*
* Initialize the hardware and some state for doing I/O trapezoids.
*
\**************************************************************************/
VOID vIoTrapezoidSetup(
PDEV* ppdev,
ULONG rop4,
ULONG iSolidColor,
RBRUSH* prb,
POINTL* pptlBrush,
TRAPEZOIDDATA* ptd)
{
BYTE* pjIoBase;
ptd->ppdev = ppdev;
pjIoBase = ppdev->pjIoBase;
IO_WAIT_FOR_IDLE(ppdev, pjIoBase);
IO_BITMAP_HEIGHT(ppdev, pjIoBase, 1);
IO_BLT_CMD_1(ppdev, pjIoBase, XY_SRC_ADDR |
XY_DEST_ADDR);
if (iSolidColor != -1)
{
ptd->pfnTrap = vIoSolidTrapezoid;
/////////////////////////////////////////////////////////////////
// Setup the hardware for solid colours
IO_PREG_COLOR_8(ppdev, pjIoBase, iSolidColor);
IO_CTRL_REG_1(ppdev, pjIoBase, PACKED_PIXEL_VIEW |
BITS_PER_PIX_8 |
ENAB_TRITON_MODE);
if (rop4 == 0xf0f0)
{
IO_DATAPATH_CTRL(ppdev, pjIoBase, ROPSELECT_NO_ROPS |
PIXELMASK_ONLY |
PLANARMASK_NONE_0XFF |
SRC_IS_PATTERN_REGS);
}
else
{
IO_DATAPATH_CTRL(ppdev, pjIoBase, ROPSELECT_ALL |
PIXELMASK_ONLY |
PLANARMASK_NONE_0XFF |
SRC_IS_PATTERN_REGS);
IO_ROP_A(ppdev, pjIoBase, rop4 >> 2);
}
}
else
{
ptd->prb = prb;
ptd->ptlBrush = *pptlBrush;
if (!(prb->fl & RBRUSH_2COLOR))
{
ptd->pfnTrap = vIoPatternedTrapezoid;
/////////////////////////////////////////////////////////////////
// Setup for coloured patterns
IO_CTRL_REG_1(ppdev, pjIoBase, PACKED_PIXEL_VIEW |
BITS_PER_PIX_8 |
ENAB_TRITON_MODE);
if (rop4 == 0xf0f0)
{
IO_DATAPATH_CTRL(ppdev, pjIoBase, ROPSELECT_NO_ROPS |
PIXELMASK_ONLY |
PLANARMASK_NONE_0XFF |
SRC_IS_PATTERN_REGS);
}
else
{
IO_DATAPATH_CTRL(ppdev, pjIoBase, ROPSELECT_ALL |
PIXELMASK_ONLY |
PLANARMASK_NONE_0XFF |
SRC_IS_PATTERN_REGS);
IO_ROP_A(ppdev, pjIoBase, rop4 >> 2);
}
}
else
{
ptd->pfnTrap = vIo2ColorTrapezoid;
/////////////////////////////////////////////////////////////////
// Setup for 2-colour patterns
IO_FG_COLOR(ppdev, pjIoBase, prb->ulForeColor);
IO_BG_COLOR(ppdev, pjIoBase, prb->ulBackColor);
IO_PREG_PATTERN(ppdev, pjIoBase, prb->aulPattern);
IO_CTRL_REG_1(ppdev, pjIoBase, EXPAND_TO_FG |
BITS_PER_PIX_8 |
ENAB_TRITON_MODE);
if (rop4 == 0xf0f0)
{
IO_DATAPATH_CTRL(ppdev, pjIoBase, ROPSELECT_NO_ROPS |
PIXELMASK_ONLY |
PLANARMASK_NONE_0XFF |
SRC_IS_PATTERN_REGS);
}
else if (((rop4 >> 8) & 0xff) == (rop4 & 0xff))
{
IO_ROP_A(ppdev, pjIoBase, rop4 >> 2);
IO_DATAPATH_CTRL(ppdev, pjIoBase, ROPSELECT_ALL |
PIXELMASK_ONLY |
PLANARMASK_NONE_0XFF |
SRC_IS_PATTERN_REGS);
}
else if ((rop4 & 0xff) == 0xcc)
{
IO_DATAPATH_CTRL(ppdev, pjIoBase, ROPSELECT_NO_ROPS |
PIXELMASK_AND_SRC_DATA |
PLANARMASK_NONE_0XFF |
SRC_IS_PATTERN_REGS);
}
else
{
IO_ROP_A(ppdev, pjIoBase, rop4 >> 2);
IO_DATAPATH_CTRL(ppdev, pjIoBase, ROPSELECT_ALL |
PIXELMASK_AND_SRC_DATA |
PLANARMASK_NONE_0XFF |
SRC_IS_PATTERN_REGS);
}
}
}
}
/******************************Public*Routine******************************\
* VOID vMmSolidTrapezoid
*
\**************************************************************************/
VOID vMmSolidTrapezoid(
TRAPEZOIDDATA* ptd,
LONG yTrapezoid,
LONG cyTrapezoid)
{
PDEV* ppdev = ptd->ppdev;
BYTE* pjMmBase = ppdev->pjMmBase;
// If the left and right edges are vertical, simply output as
// a rectangle:
if (((ptd->aed[LEFT].lErrorUp | ptd->aed[RIGHT].lErrorUp) == 0) &&
((ptd->aed[LEFT].dx | ptd->aed[RIGHT].dx) == 0) &&
(cyTrapezoid > 1))
{
LONG lWidth;
/////////////////////////////////////////////////////////////////
// Vertical-edge special case
ContinueVertical:
lWidth = ptd->aed[RIGHT].x - ptd->aed[LEFT].x;
if (lWidth > 0)
{
MM_WAIT_BUFFER_NOT_BUSY(ppdev, pjMmBase);
MM_BITMAP_WIDTH(ppdev, pjMmBase, lWidth);
MM_BITMAP_HEIGHT(ppdev, pjMmBase, cyTrapezoid);
MM_DEST_XY(ppdev, pjMmBase, ptd->aed[LEFT].x, yTrapezoid);
MM_BLT_CMD_0(ppdev, pjMmBase, START_BLT);
MM_WAIT_BUFFER_NOT_BUSY(ppdev, pjMmBase);
MM_BITMAP_HEIGHT(ppdev, pjMmBase, 1);
}
else if (lWidth < 0)
{
LONG lTmp;
POINTFIX* pptfxTmp;
SWAP(ptd->aed[LEFT].x, ptd->aed[RIGHT].x, lTmp);
SWAP(ptd->aed[LEFT].cy, ptd->aed[RIGHT].cy, lTmp);
SWAP(ptd->aed[LEFT].dptfx, ptd->aed[RIGHT].dptfx, lTmp);
SWAP(ptd->aed[LEFT].pptfx, ptd->aed[RIGHT].pptfx, pptfxTmp);
goto ContinueVertical;
}
}
else
{
LONG lLeftError = ptd->aed[LEFT].lError;
LONG dxLeft = ptd->aed[LEFT].dx;
LONG xLeft = ptd->aed[LEFT].x;
LONG lRightError = ptd->aed[RIGHT].lError;
LONG dxRight = ptd->aed[RIGHT].dx;
LONG xRight = ptd->aed[RIGHT].x;
while (TRUE)
{
LONG lWidth;
/////////////////////////////////////////////////////////////////
// Run the DDAs
lWidth = xRight - xLeft;
if (lWidth > 0)
{
MM_WAIT_BUFFER_NOT_BUSY(ppdev, pjMmBase);
MM_BITMAP_WIDTH(ppdev, pjMmBase, lWidth);
MM_DEST_XY(ppdev, pjMmBase, xLeft, yTrapezoid);
MM_BLT_CMD_0(ppdev, pjMmBase, START_BLT);
ContinueAfterZero:
yTrapezoid++;
// Advance the right wall:
xRight += dxRight;
lRightError += ptd->aed[RIGHT].lErrorUp;
if (lRightError >= 0)
{
lRightError -= ptd->aed[RIGHT].lErrorDown;
xRight++;
}
// Advance the left wall:
xLeft += dxLeft;
lLeftError += ptd->aed[LEFT].lErrorUp;
if (lLeftError >= 0)
{
lLeftError -= ptd->aed[LEFT].lErrorDown;
xLeft++;
}
cyTrapezoid--;
if (cyTrapezoid == 0)
break;
}
else if (lWidth == 0)
{
goto ContinueAfterZero;
}
else
{
// We certainly don't want to optimize for this case because we
// should rarely get self-intersecting polygons (if we're slow,
// the app gets what it deserves):
LONG lTmp;
POINTFIX* pptfxTmp;
SWAP(xLeft, xRight, lTmp);
SWAP(dxLeft, dxRight, lTmp);
SWAP(lLeftError, lRightError, lTmp);
SWAP(ptd->aed[LEFT].lErrorUp, ptd->aed[RIGHT].lErrorUp, lTmp);
SWAP(ptd->aed[LEFT].lErrorDown, ptd->aed[RIGHT].lErrorDown, lTmp);
SWAP(ptd->aed[LEFT].cy, ptd->aed[RIGHT].cy, lTmp);
SWAP(ptd->aed[LEFT].dptfx, ptd->aed[RIGHT].dptfx, lTmp);
SWAP(ptd->aed[LEFT].pptfx, ptd->aed[RIGHT].pptfx, pptfxTmp);
}
}
ptd->aed[LEFT].lError = lLeftError;
ptd->aed[LEFT].dx = dxLeft;
ptd->aed[LEFT].x = xLeft;
ptd->aed[RIGHT].lError = lRightError;
ptd->aed[RIGHT].dx = dxRight;
ptd->aed[RIGHT].x = xRight;
}
}
/******************************Public*Routine******************************\
* VOID vMm2ColorTrapezoid
*
\**************************************************************************/
VOID vMm2ColorTrapezoid(
TRAPEZOIDDATA* ptd,
LONG yTrapezoid,
LONG cyTrapezoid)
{
PDEV* ppdev = ptd->ppdev;
BYTE* pjMmBase = ppdev->pjMmBase;
LONG xAlign;
LONG yAlign;
xAlign = ptd->ptlBrush.x;
yAlign = ptd->ptlBrush.y;
// If the left and right edges are vertical, simply output as
// a rectangle:
if (((ptd->aed[LEFT].lErrorUp | ptd->aed[RIGHT].lErrorUp) == 0) &&
((ptd->aed[LEFT].dx | ptd->aed[RIGHT].dx) == 0) &&
(cyTrapezoid > 1))
{
LONG lWidth;
/////////////////////////////////////////////////////////////////
// Vertical-edge special case
ContinueVertical:
lWidth = ptd->aed[RIGHT].x - ptd->aed[LEFT].x;
if (lWidth > 0)
{
MM_WAIT_BUFFER_NOT_BUSY(ppdev, pjMmBase);
MM_BITMAP_WIDTH(ppdev, pjMmBase, lWidth);
MM_BITMAP_HEIGHT(ppdev, pjMmBase, cyTrapezoid);
MM_DEST_XY(ppdev, pjMmBase, ptd->aed[LEFT].x, yTrapezoid);
MM_SRC_ALIGN(ppdev, pjMmBase, ((ptd->aed[LEFT].x - xAlign) & 7) |
((yTrapezoid - yAlign) << 3));
MM_BLT_CMD_0(ppdev, pjMmBase, START_BLT);
MM_WAIT_BUFFER_NOT_BUSY(ppdev, pjMmBase);
MM_BITMAP_HEIGHT(ppdev, pjMmBase, 1);
}
else if (lWidth < 0)
{
LONG lTmp;
POINTFIX* pptfxTmp;
SWAP(ptd->aed[LEFT].x, ptd->aed[RIGHT].x, lTmp);
SWAP(ptd->aed[LEFT].cy, ptd->aed[RIGHT].cy, lTmp);
SWAP(ptd->aed[LEFT].dptfx, ptd->aed[RIGHT].dptfx, lTmp);
SWAP(ptd->aed[LEFT].pptfx, ptd->aed[RIGHT].pptfx, pptfxTmp);
goto ContinueVertical;
}
}
else
{
LONG lLeftError = ptd->aed[LEFT].lError;
LONG dxLeft = ptd->aed[LEFT].dx;
LONG xLeft = ptd->aed[LEFT].x;
LONG lRightError = ptd->aed[RIGHT].lError;
LONG dxRight = ptd->aed[RIGHT].dx;
LONG xRight = ptd->aed[RIGHT].x;
LONG yScaledAlign;
// Scale y alignment up by 8 so that it's easier to compute
// the QVision's alignment on each scan:
yScaledAlign = (yTrapezoid - yAlign) << 3;
while (TRUE)
{
LONG lWidth;
/////////////////////////////////////////////////////////////////
// Run the DDAs
lWidth = xRight - xLeft;
if (lWidth > 0)
{
MM_WAIT_BUFFER_NOT_BUSY(ppdev, pjMmBase);
MM_BITMAP_WIDTH(ppdev, pjMmBase, lWidth);
MM_DEST_XY(ppdev, pjMmBase, xLeft, yTrapezoid);
MM_SRC_ALIGN(ppdev, pjMmBase, (((xLeft - xAlign) & 7)
| yScaledAlign));
MM_BLT_CMD_0(ppdev, pjMmBase, START_BLT);
ContinueAfterZero:
yScaledAlign += 8;
yTrapezoid++;
// Advance the right wall:
xRight += dxRight;
lRightError += ptd->aed[RIGHT].lErrorUp;
if (lRightError >= 0)
{
lRightError -= ptd->aed[RIGHT].lErrorDown;
xRight++;
}
// Advance the left wall:
xLeft += dxLeft;
lLeftError += ptd->aed[LEFT].lErrorUp;
if (lLeftError >= 0)
{
lLeftError -= ptd->aed[LEFT].lErrorDown;
xLeft++;
}
cyTrapezoid--;
if (cyTrapezoid == 0)
break;
}
else if (lWidth == 0)
{
goto ContinueAfterZero;
}
else
{
// We certainly don't want to optimize for this case because we
// should rarely get self-intersecting polygons (if we're slow,
// the app gets what it deserves):
LONG lTmp;
POINTFIX* pptfxTmp;
SWAP(xLeft, xRight, lTmp);
SWAP(dxLeft, dxRight, lTmp);
SWAP(lLeftError, lRightError, lTmp);
SWAP(ptd->aed[LEFT].lErrorUp, ptd->aed[RIGHT].lErrorUp, lTmp);
SWAP(ptd->aed[LEFT].lErrorDown, ptd->aed[RIGHT].lErrorDown, lTmp);
SWAP(ptd->aed[LEFT].cy, ptd->aed[RIGHT].cy, lTmp);
SWAP(ptd->aed[LEFT].dptfx, ptd->aed[RIGHT].dptfx, lTmp);
SWAP(ptd->aed[LEFT].pptfx, ptd->aed[RIGHT].pptfx, pptfxTmp);
}
}
ptd->aed[LEFT].lError = lLeftError;
ptd->aed[LEFT].dx = dxLeft;
ptd->aed[LEFT].x = xLeft;
ptd->aed[RIGHT].lError = lRightError;
ptd->aed[RIGHT].dx = dxRight;
ptd->aed[RIGHT].x = xRight;
}
}
/******************************Public*Routine******************************\
* VOID vMmPatternedTrapezoid
*
\**************************************************************************/
VOID vMmPatternedTrapezoid(
TRAPEZOIDDATA* ptd,
LONG yTrapezoid,
LONG cyTrapezoid)
{
PDEV* ppdev = ptd->ppdev;
BYTE* pjMmBase = ppdev->pjMmBase;
LONG lLeftError = ptd->aed[LEFT].lError;
LONG dxLeft = ptd->aed[LEFT].dx;
LONG xLeft = ptd->aed[LEFT].x;
LONG lRightError = ptd->aed[RIGHT].lError;
LONG dxRight = ptd->aed[RIGHT].dx;
LONG xRight = ptd->aed[RIGHT].x;
BYTE* pjPattern;
LONG iPattern;
LONG xAlign;
xAlign = ptd->ptlBrush.x;
iPattern = 8 * (yTrapezoid - ptd->ptlBrush.y);
pjPattern = (BYTE*) ptd->prb->aulPattern;
while (TRUE)
{
LONG lWidth;
/////////////////////////////////////////////////////////////////
// Run the DDAs
lWidth = xRight - xLeft;
if (lWidth > 0)
{
// Note that we're setting these buffered registers without
// first checking for idle, or even buffer not busy. But
// this is safe because at initialization, we did a wait
// for idle, and here we always loop after waiting for idle
// to set the pattern registers.
MM_BITMAP_WIDTH(ppdev, pjMmBase, lWidth);
MM_DEST_XY(ppdev, pjMmBase, xLeft, yTrapezoid);
MM_SRC_ALIGN(ppdev, pjMmBase, xLeft - xAlign);
MM_WAIT_FOR_IDLE(ppdev, pjMmBase);
MM_PREG_PATTERN(ppdev, pjMmBase, pjPattern + (iPattern & 63));
MM_BLT_CMD_0(ppdev, pjMmBase, START_BLT);
ContinueAfterZero:
iPattern += 8;
yTrapezoid++;
// Advance the right wall:
xRight += dxRight;
lRightError += ptd->aed[RIGHT].lErrorUp;
if (lRightError >= 0)
{
lRightError -= ptd->aed[RIGHT].lErrorDown;
xRight++;
}
// Advance the left wall:
xLeft += dxLeft;
lLeftError += ptd->aed[LEFT].lErrorUp;
if (lLeftError >= 0)
{
lLeftError -= ptd->aed[LEFT].lErrorDown;
xLeft++;
}
cyTrapezoid--;
if (cyTrapezoid == 0)
break;
}
else if (lWidth == 0)
{
goto ContinueAfterZero;
}
else
{
// We certainly don't want to optimize for this case because we
// should rarely get self-intersecting polygons (if we're slow,
// the app gets what it deserves):
LONG lTmp;
POINTFIX* pptfxTmp;
SWAP(xLeft, xRight, lTmp);
SWAP(dxLeft, dxRight, lTmp);
SWAP(lLeftError, lRightError, lTmp);
SWAP(ptd->aed[LEFT].lErrorUp, ptd->aed[RIGHT].lErrorUp, lTmp);
SWAP(ptd->aed[LEFT].lErrorDown, ptd->aed[RIGHT].lErrorDown, lTmp);
SWAP(ptd->aed[LEFT].cy, ptd->aed[RIGHT].cy, lTmp);
SWAP(ptd->aed[LEFT].dptfx, ptd->aed[RIGHT].dptfx, lTmp);
SWAP(ptd->aed[LEFT].pptfx, ptd->aed[RIGHT].pptfx, pptfxTmp);
}
}
ptd->aed[LEFT].lError = lLeftError;
ptd->aed[LEFT].dx = dxLeft;
ptd->aed[LEFT].x = xLeft;
ptd->aed[RIGHT].lError = lRightError;
ptd->aed[RIGHT].dx = dxRight;
ptd->aed[RIGHT].x = xRight;
}
/******************************Public*Routine******************************\
* VOID vMmTrapezoidSetup
*
* Initialize the hardware and some state for doing memory-mapped I/O
* trapezoids.
*
\**************************************************************************/
VOID vMmTrapezoidSetup(
PDEV* ppdev,
ULONG rop4,
ULONG iSolidColor,
RBRUSH* prb,
POINTL* pptlBrush,
TRAPEZOIDDATA* ptd)
{
BYTE* pjMmBase;
ptd->ppdev = ppdev;
pjMmBase = ppdev->pjMmBase;
MM_WAIT_FOR_IDLE(ppdev, pjMmBase);
MM_BITMAP_HEIGHT(ppdev, pjMmBase, 1);
MM_BLT_CMD_1(ppdev, pjMmBase, XY_SRC_ADDR |
XY_DEST_ADDR);
if (iSolidColor != -1)
{
ptd->pfnTrap = vMmSolidTrapezoid;
/////////////////////////////////////////////////////////////////
// Setup the hardware for solid colours
MM_PREG_COLOR_8(ppdev, pjMmBase, iSolidColor);
if (rop4 == 0xf0f0)
{
// Note block write:
MM_CTRL_REG_1(ppdev, pjMmBase, PACKED_PIXEL_VIEW |
BLOCK_WRITE |
BITS_PER_PIX_8 |
ENAB_TRITON_MODE);
MM_DATAPATH_CTRL(ppdev, pjMmBase, ROPSELECT_NO_ROPS |
PIXELMASK_ONLY |
PLANARMASK_NONE_0XFF |
SRC_IS_PATTERN_REGS);
}
else
{
MM_CTRL_REG_1(ppdev, pjMmBase, PACKED_PIXEL_VIEW |
BITS_PER_PIX_8 |
ENAB_TRITON_MODE);
MM_DATAPATH_CTRL(ppdev, pjMmBase, ROPSELECT_ALL |
PIXELMASK_ONLY |
PLANARMASK_NONE_0XFF |
SRC_IS_PATTERN_REGS);
MM_ROP_A(ppdev, pjMmBase, rop4 >> 2);
}
}
else
{
ptd->prb = prb;
ptd->ptlBrush = *pptlBrush;
if (!(prb->fl & RBRUSH_2COLOR))
{
ptd->pfnTrap = vMmPatternedTrapezoid;
/////////////////////////////////////////////////////////////////
// Setup for coloured patterns
MM_CTRL_REG_1(ppdev, pjMmBase, PACKED_PIXEL_VIEW |
BITS_PER_PIX_8 |
ENAB_TRITON_MODE);
if (rop4 == 0xf0f0)
{
MM_DATAPATH_CTRL(ppdev, pjMmBase, ROPSELECT_NO_ROPS |
PIXELMASK_ONLY |
PLANARMASK_NONE_0XFF |
SRC_IS_PATTERN_REGS);
}
else
{
MM_DATAPATH_CTRL(ppdev, pjMmBase, ROPSELECT_ALL |
PIXELMASK_ONLY |
PLANARMASK_NONE_0XFF |
SRC_IS_PATTERN_REGS);
MM_ROP_A(ppdev, pjMmBase, rop4 >> 2);
}
}
else
{
ptd->pfnTrap = vMm2ColorTrapezoid;
/////////////////////////////////////////////////////////////////
// Setup for 2-colour patterns
MM_FG_COLOR(ppdev, pjMmBase, prb->ulForeColor);
MM_BG_COLOR(ppdev, pjMmBase, prb->ulBackColor);
MM_PREG_PATTERN(ppdev, pjMmBase, prb->aulPattern);
MM_CTRL_REG_1(ppdev, pjMmBase, EXPAND_TO_FG |
BITS_PER_PIX_8 |
ENAB_TRITON_MODE);
if (rop4 == 0xf0f0)
{
MM_DATAPATH_CTRL(ppdev, pjMmBase, ROPSELECT_NO_ROPS |
PIXELMASK_ONLY |
PLANARMASK_NONE_0XFF |
SRC_IS_PATTERN_REGS);
}
else if (((rop4 >> 8) & 0xff) == (rop4 & 0xff))
{
MM_ROP_A(ppdev, pjMmBase, rop4 >> 2);
MM_DATAPATH_CTRL(ppdev, pjMmBase, ROPSELECT_ALL |
PIXELMASK_ONLY |
PLANARMASK_NONE_0XFF |
SRC_IS_PATTERN_REGS);
}
else if ((rop4 & 0xff) == 0xcc)
{
MM_DATAPATH_CTRL(ppdev, pjMmBase, ROPSELECT_NO_ROPS |
PIXELMASK_AND_SRC_DATA |
PLANARMASK_NONE_0XFF |
SRC_IS_PATTERN_REGS);
}
else
{
MM_ROP_A(ppdev, pjMmBase, rop4 >> 2);
MM_DATAPATH_CTRL(ppdev, pjMmBase, ROPSELECT_ALL |
PIXELMASK_AND_SRC_DATA |
PLANARMASK_NONE_0XFF |
SRC_IS_PATTERN_REGS);
}
}
}
}
/******************************Public*Routine******************************\
* BOOL bFastFill
*
* Draws a non-complex, unclipped polygon. 'Non-complex' is defined as
* having only two edges that are monotonic increasing in 'y'. That is,
* the polygon cannot have more than one disconnected segment on any given
* scan. Note that the edges of the polygon can self-intersect, so hourglass
* shapes are permissible. This restriction permits this routine to run two
* simultaneous DDAs, and no sorting of the edges is required.
*
* Note that NT's fill convention is different from that of Win 3.1 or 4.0.
* With the additional complication of fractional end-points, our convention
* is the same as in 'X-Windows'. But a DDA is a DDA is a DDA, so once you
* figure out how we compute the DDA terms for NT, you're golden.
*
* Returns TRUE if the polygon was drawn; FALSE if the polygon was complex.
*
\**************************************************************************/
BOOL bFastFill(
PDEV* ppdev,
LONG cEdges, // Includes close figure edge
POINTFIX* pptfxFirst,
ULONG rop4,
ULONG iSolidColor,
RBRUSH* prb,
POINTL* pptlBrush)
{
LONG yTrapezoid; // Top scan for next trapezoid
LONG cyTrapezoid; // Number of scans in current trapezoid
LONG yStart; // y-position of start point in current edge
LONG dM; // Edge delta in FIX units in x direction
LONG dN; // Edge delta in FIX units in y direction
LONG i;
POINTFIX* pptfxLast; // Points to the last point in the polygon array
POINTFIX* pptfxTop; // Points to the top-most point in the polygon
POINTFIX* pptfxOld; // Start point in current edge
POINTFIX* pptfxScan; // Current edge pointer for finding pptfxTop
LONG cScanEdges; // Number of edges scanned to find pptfxTop
// (doesn't include the closefigure edge)
LONG iEdge;
LONG lQuotient;
LONG lRemainder;
TRAPEZOIDDATA td; // Edge data and stuff
EDGEDATA* ped; // Points to current edge being processed
/////////////////////////////////////////////////////////////////
// See if the polygon is 'non-complex'
pptfxScan = pptfxFirst;
pptfxTop = pptfxFirst; // Assume for now that the first
// point in path is the topmost
pptfxLast = pptfxFirst + cEdges - 1;
// 'pptfxScan' will always point to the first point in the current
// edge, and 'cScanEdges' will the number of edges remaining, including
// the current one:
cScanEdges = cEdges - 1; // The number of edges, not counting close figure
if ((pptfxScan + 1)->y > pptfxScan->y)
{
// Collect all downs:
do {
if (--cScanEdges == 0)
goto SetUpForFilling;
pptfxScan++;
} while ((pptfxScan + 1)->y >= pptfxScan->y);
// Collect all ups:
do {
if (--cScanEdges == 0)
goto SetUpForFillingCheck;
pptfxScan++;
} while ((pptfxScan + 1)->y <= pptfxScan->y);
// Collect all downs:
pptfxTop = pptfxScan;
do {
if ((pptfxScan + 1)->y > pptfxFirst->y)
break;
if (--cScanEdges == 0)
goto SetUpForFilling;
pptfxScan++;
} while ((pptfxScan + 1)->y >= pptfxScan->y);
return(FALSE);
}
else
{
// Collect all ups:
do {
pptfxTop++; // We increment this now because we
// want it to point to the very last
// point if we early out in the next
// statement...
if (--cScanEdges == 0)
goto SetUpForFilling;
} while ((pptfxTop + 1)->y <= pptfxTop->y);
// Collect all downs:
pptfxScan = pptfxTop;
do {
if (--cScanEdges == 0)
goto SetUpForFilling;
pptfxScan++;
} while ((pptfxScan + 1)->y >= pptfxScan->y);
// Collect all ups:
do {
if ((pptfxScan + 1)->y < pptfxFirst->y)
break;
if (--cScanEdges == 0)
goto SetUpForFilling;
pptfxScan++;
} while ((pptfxScan + 1)->y <= pptfxScan->y);
return(FALSE);
}
SetUpForFillingCheck:
// We check to see if the end of the current edge is higher
// than the top edge we've found so far:
if ((pptfxScan + 1)->y < pptfxTop->y)
pptfxTop = pptfxScan + 1;
SetUpForFilling:
/////////////////////////////////////////////////////////////////
// Some Initialization
yTrapezoid = (pptfxTop->y + 15) >> 4;
// Make sure we initialize the DDAs appropriately:
td.aed[LEFT].cy = 0;
td.aed[RIGHT].cy = 0;
// For now, guess as to which is the left and which is the right edge:
td.aed[LEFT].dptfx = -(LONG) sizeof(POINTFIX);
td.aed[RIGHT].dptfx = sizeof(POINTFIX);
td.aed[LEFT].pptfx = pptfxTop;
td.aed[RIGHT].pptfx = pptfxTop;
// Do the hardware setup. These are not in-line only because it
// takes too much space to ahve both I/O and memory-mapped I/O
// versions:
if (ppdev->pjMmBase != NULL)
vMmTrapezoidSetup(ppdev, rop4, iSolidColor, prb, pptlBrush, &td);
else
vIoTrapezoidSetup(ppdev, rop4, iSolidColor, prb, pptlBrush, &td);
NewTrapezoid:
/////////////////////////////////////////////////////////////////
// DDA initialization
for (iEdge = 1; iEdge >= 0; iEdge--)
{
ped = &td.aed[iEdge];
if (ped->cy == 0)
{
// Need a new DDA:
do {
cEdges--;
if (cEdges < 0)
return(TRUE);
// Find the next left edge, accounting for wrapping:
pptfxOld = ped->pptfx;
ped->pptfx = (POINTFIX*) ((BYTE*) ped->pptfx + ped->dptfx);
if (ped->pptfx < pptfxFirst)
ped->pptfx = pptfxLast;
else if (ped->pptfx > pptfxLast)
ped->pptfx = pptfxFirst;
// Have to find the edge that spans yTrapezoid:
ped->cy = ((ped->pptfx->y + 15) >> 4) - yTrapezoid;
// With fractional coordinate end points, we may get edges
// that don't cross any scans, in which case we try the
// next one:
} while (ped->cy <= 0);
// 'pptfx' now points to the end point of the edge spanning
// the scan 'yTrapezoid'.
dN = ped->pptfx->y - pptfxOld->y;
dM = ped->pptfx->x - pptfxOld->x;
ASSERTDD(dN > 0, "Should be going down only");
// Compute the DDA increment terms:
if (dM < 0)
{
dM = -dM;
if (dM < dN) // Can't be '<='
{
ped->dx = -1;
ped->lErrorUp = dN - dM;
}
else
{
QUOTIENT_REMAINDER(dM, dN, lQuotient, lRemainder);
ped->dx = -lQuotient; // - dM / dN
ped->lErrorUp = lRemainder; // dM % dN
if (ped->lErrorUp > 0)
{
ped->dx--;
ped->lErrorUp = dN - ped->lErrorUp;
}
}
}
else
{
if (dM < dN) // Can't be '<='
{
ped->dx = 0;
ped->lErrorUp = dM;
}
else
{
QUOTIENT_REMAINDER(dM, dN, lQuotient, lRemainder);
ped->dx = lQuotient; // dM / dN
ped->lErrorUp = lRemainder; // dM % dN
}
}
ped->lErrorDown = dN; // DDA limit
ped->lError = -1; // Error is initially zero (add dN - 1 for
// the ceiling, but subtract off dN so that
// we can check the sign instead of comparing
// to dN)
ped->x = pptfxOld->x;
yStart = pptfxOld->y;
if ((yStart & 15) != 0)
{
// Advance to the next integer y coordinate
for (i = 16 - (yStart & 15); i != 0; i--)
{
ped->x += ped->dx;
ped->lError += ped->lErrorUp;
if (ped->lError >= 0)
{
ped->lError -= ped->lErrorDown;
ped->x++;
}
}
}
if ((ped->x & 15) != 0)
{
ped->lError -= ped->lErrorDown * (16 - (ped->x & 15));
ped->x += 15; // We'll want the ceiling in just a bit...
}
// Chop off those fractional bits:
ped->x >>= 4;
ped->lError >>= 4;
}
}
cyTrapezoid = min(td.aed[LEFT].cy, td.aed[RIGHT].cy); // # of scans in this trap
td.aed[LEFT].cy -= cyTrapezoid;
td.aed[RIGHT].cy -= cyTrapezoid;
td.pfnTrap(&td, yTrapezoid, cyTrapezoid);
yTrapezoid += cyTrapezoid;
goto NewTrapezoid;
}