/*************************************************************************\ * Module Name: Lines.c * * Contains most of the required GDI line support. Supports drawing * lines in short 'strips' when clipping is complex or coordinates * are too large to be drawn by the line hardware. * * Copyright (c) 1990-1995 Microsoft Corporation \**************************************************************************/ #include "precomp.h" /////////////////////////////////////////////////////////////////////// // We have to be careful of arithmetic overflow in a number of places. // Fortunately, the compiler is guaranteed to natively support 64-bit // signed LONGLONGs and 64-bit unsigned DWORDLONGs. // // UUInt32x32To64(a, b) is a macro defined in 'winnt.h' that multiplies // two 32-bit ULONGs to produce a 64-bit DWORDLONG result. // // UInt64By32To32 is our own macro to divide a 64-bit DWORDLONG by // a 32-bit ULONG to produce a 32-bit ULONG result. // // UInt64Mod32To32 is our own macro to modulus a 64-bit DWORDLONG by // a 32-bit ULONG to produce a 32-bit ULONG result. // // 64 bit divides are usually very expensive. Since it's very rare // that we'll get lines where the upper 32 bits of the 64 bit result // are used, we can almost always use 32-bit ULONG divides. We still // must correctly handle the larger cases: #define UInt64Div32To32(a, b) \ ((((DWORDLONG)(a)) > ULONG_MAX) ? \ (ULONG)((DWORDLONG)(a) / (ULONG)(b)) : \ (ULONG)((ULONG)(a) / (ULONG)(b))) #define UInt64Mod32To32(a, b) \ ((((DWORDLONG)(a)) > ULONG_MAX) ? \ (ULONG)((DWORDLONG)(a) % (ULONG)(b)) : \ (ULONG)((ULONG)(a) % (ULONG)(b))) #define SWAPL(x,y,t) {t = x; x = y; y = t;} FLONG gaflRound[] = { FL_H_ROUND_DOWN | FL_V_ROUND_DOWN, // no flips FL_H_ROUND_DOWN | FL_V_ROUND_DOWN, // FL_FLIP_D FL_H_ROUND_DOWN, // FL_FLIP_V FL_V_ROUND_DOWN, // FL_FLIP_V | FL_FLIP_D FL_V_ROUND_DOWN, // FL_FLIP_SLOPE_ONE 0xbaadf00d, // FL_FLIP_SLOPE_ONE | FL_FLIP_D FL_H_ROUND_DOWN, // FL_FLIP_SLOPE_ONE | FL_FLIP_V 0xbaadf00d // FL_FLIP_SLOPE_ONE | FL_FLIP_V | FL_FLIP_D }; ////////////////////////////////////////////////////////////////////////// // General defines for bHardwareLine BOOL bHardwareLine(PDEV*, POINTFIX*, POINTFIX*); #define HW_FLIP_D 0x0001L // Diagonal flip #define HW_FLIP_V 0x0002L // Vertical flip #define HW_FLIP_H 0x0004L // Horizontal flip #define HW_FLIP_SLOPE_ONE 0x0008L // Normalized line has exactly slope one #define HW_FLIP_MASK (HW_FLIP_D | HW_FLIP_V | HW_FLIP_H) #define HW_X_ROUND_DOWN 0x0100L // x = 1/2 rounds down in value #define HW_Y_ROUND_DOWN 0x0200L // y = 1/2 rounds down in value LONG gaiDir[] = { 0, 1, 7, 6, 3, 2, 4, 5 }; FLONG gaflHardwareRound[] = { HW_X_ROUND_DOWN | HW_Y_ROUND_DOWN, // | | | HW_X_ROUND_DOWN | HW_Y_ROUND_DOWN, // | | | FLIP_D HW_X_ROUND_DOWN, // | | FLIP_V | HW_Y_ROUND_DOWN, // | | FLIP_V | FLIP_D HW_Y_ROUND_DOWN, // | FLIP_H | | HW_X_ROUND_DOWN, // | FLIP_H | | FLIP_D 0, // | FLIP_H | FLIP_V | 0, // | FLIP_H | FLIP_V | FLIP_D HW_Y_ROUND_DOWN, // SLOPE_ONE | | | 0xffffffff, // SLOPE_ONE | | | FLIP_D HW_X_ROUND_DOWN, // SLOPE_ONE | | FLIP_V | 0xffffffff, // SLOPE_ONE | | FLIP_V | FLIP_D HW_Y_ROUND_DOWN, // SLOPE_ONE | FLIP_H | | 0xffffffff, // SLOPE_ONE | FLIP_H | | FLIP_D HW_X_ROUND_DOWN, // SLOPE_ONE | FLIP_H | FLIP_V | 0xffffffff // SLOPE_ONE | FLIP_H | FLIP_V | FLIP_D }; ////////////////////////////////////////////////////////////////////////// // QVision specific defines // The QVision's hardware can have 12 bits of significance for the error and // step terms: #define NUM_DDA_BITS 12 // This table is used to compute the appropriate QVision drawing command // so that tie-breaker pixels are done correctly in each direction. The // index is a flag composed of HW_FLIP_D, HW_FLIP_V and HW_FLIP_H, which // indicates in which octant the line lies: LONG gaiIntegerLineCmd[] = { DEFAULT_LINE_CMD | LAST_PIXEL_NULL | AXIAL_ROUND_DOWN, DEFAULT_LINE_CMD | LAST_PIXEL_NULL | AXIAL_ROUND_DOWN, DEFAULT_LINE_CMD | LAST_PIXEL_NULL | AXIAL_ROUND_UP, DEFAULT_LINE_CMD | LAST_PIXEL_NULL | AXIAL_ROUND_DOWN, DEFAULT_LINE_CMD | LAST_PIXEL_NULL | AXIAL_ROUND_DOWN, DEFAULT_LINE_CMD | LAST_PIXEL_NULL | AXIAL_ROUND_UP, DEFAULT_LINE_CMD | LAST_PIXEL_NULL | AXIAL_ROUND_UP, DEFAULT_LINE_CMD | LAST_PIXEL_NULL | AXIAL_ROUND_UP, }; /******************************Public*Routine******************************\ * BOOL bLines(ppdev, pptfxFirst, pptfxBuf, cptfx, pls, * prclClip, apfn[], flStart) * * Computes the DDA for the line and gets ready to draw it. Puts the * pixel data into an array of strips, and calls a strip routine to * do the actual drawing. * * Doing NT Lines Right * -------------------- * * In NT, all lines are given to the device driver in fractional * coordinates, in a 28.4 fixed point format. The lower 4 bits are * fractional for sub-pixel positioning. * * Note that you CANNOT! just round the coordinates to integers * and pass the results to your favorite integer Bresenham routine!! * (Unless, of course, you have such a high resolution device that * nobody will notice -- not likely for a display device.) The * fractions give a more accurate rendering of the line -- this is * important for things like our Bezier curves, which would have 'kinks' * if the points in its polyline approximation were rounded to integers. * * Unfortunately, for fractional lines there is more setup work to do * a DDA than for integer lines. However, the main loop is exactly * the same (and can be done entirely with 32 bit math). * * If You've Got Hardware That Does Bresenham * ------------------------------------------ * * A lot of hardware limits DDA error terms to 'n' bits. With fractional * coordinates, 4 bits are given to the fractional part, letting * you draw in hardware only those lines that lie entirely in a 2^(n-4) * by 2^(n-4) pixel space. * * And you still have to correctly draw those lines with coordinates * outside that space! Remember that the screen is only a viewport * onto a 28.4 by 28.4 space -- if any part of the line is visible * you MUST render it precisely, regardless of where the end points lie. * So even if you do it in software, somewhere you'll have to have a * 32 bit DDA routine. * * Our Implementation * ------------------ * * We employ a run length slice algorithm: our DDA calculates the * number of pixels that are in each row (or 'strip') of pixels. * * We've separated the running of the DDA and the drawing of pixels: * we run the DDA for several iterations and store the results in * a 'strip' buffer (which are the lengths of consecutive pixel rows of * the line), then we crank up a 'strip drawer' that will draw all the * strips in the buffer. * * We also employ a 'half-flip' to reduce the number of strip * iterations we need to do in the DDA and strip drawing loops: when a * (normalized) line's slope is more than 1/2, we do a final flip * about the line y = (1/2)x. So now, instead of each strip being * consecutive horizontal or vertical pixel rows, each strip is composed * of those pixels aligned in 45 degree rows. So a line like (0, 0) to * (128, 128) would generate only one strip. * * We also always draw only left-to-right. * * Styled lines may have arbitrary style patterns. We specially * optimize the default patterns (and call them 'masked' styles). * * The DDA Derivation * ------------------ * * Here is how I like to think of the DDA calculation. * * We employ Knuth's "diamond rule": rendering a one-pixel-wide line * can be thought of as dragging a one-pixel-wide by one-pixel-high * diamond along the true line. Pixel centers lie on the integer * coordinates, and so we light any pixel whose center gets covered * by the "drag" region (John D. Hobby, Journal of the Association * for Computing Machinery, Vol. 36, No. 2, April 1989, pp. 209-229). * * We must define which pixel gets lit when the true line falls * exactly half-way between two pixels. In this case, we follow * the rule: when two pels are equidistant, the upper or left pel * is illuminated, unless the slope is exactly one, in which case * the upper or right pel is illuminated. (So we make the edges * of the diamond exclusive, except for the top and left vertices, * which are inclusive, unless we have slope one.) * * This metric decides what pixels should be on any line BEFORE it is * flipped around for our calculation. Having a consistent metric * this way will let our lines blend nicely with our curves. The * metric also dictates that we will never have one pixel turned on * directly above another that's turned on. We will also never have * a gap; i.e., there will be exactly one pixel turned on for each * column between the start and end points. All that remains to be * done is to decide how many pixels should be turned on for each row. * * So lines we draw will consist of varying numbers of pixels on * successive rows, for example: * * ****** * ***** * ****** * ***** * * We'll call each set of pixels on a row a "strip". * * (Please remember that our coordinate space has the origin as the * upper left pixel on the screen; postive y is down and positive x * is right.) * * Device coordinates are specified as fixed point 28.4 numbers, * where the first 28 bits are the integer coordinate, and the last * 4 bits are the fraction. So coordinates may be thought of as * having the form (x, y) = (M/F, N/F) where F is the constant scaling * factor F = 2^4 = 16, and M and N are 32 bit integers. * * Consider the line from (M0/F, N0/F) to (M1/F, N1/F) which runs * left-to-right and whose slope is in the first octant, and let * dM = M1 - M0 and dN = N1 - N0. Then dM >= 0, dN >= 0 and dM >= dN. * * Since the slope of the line is less than 1, the edges of the * drag region are created by the top and bottom vertices of the * diamond. At any given pixel row y of the line, we light those * pixels whose centers are between the left and right edges. * * Let mL(n) denote the line representing the left edge of the drag * region. On pixel row j, the column of the first pixel to be * lit is * * iL(j) = ceiling( mL(j * F) / F) * * Since the line's slope is less than one: * * iL(j) = ceiling( mL([j + 1/2] F) / F ) * * Recall the formula for our line: * * n(m) = (dN / dM) (m - M0) + N0 * * m(n) = (dM / dN) (n - N0) + M0 * * Since the line's slope is less than one, the line representing * the left edge of the drag region is the original line offset * by 1/2 pixel in the y direction: * * mL(n) = (dM / dN) (n - F/2 - N0) + M0 * * From this we can figure out the column of the first pixel that * will be lit on row j, being careful of rounding (if the left * edge lands exactly on an integer point, the pixel at that * point is not lit because of our rounding convention): * * iL(j) = floor( mL(j F) / F ) + 1 * * = floor( ((dM / dN) (j F - F/2 - N0) + M0) / F ) + 1 * * = floor( F dM j - F/2 dM - N0 dM + dN M0) / F dN ) + 1 * * F dM j - [ dM (N0 + F/2) - dN M0 ] * = floor( ---------------------------------- ) + 1 * F dN * * dM j - [ dM (N0 + F/2) - dN M0 ] / F * = floor( ------------------------------------ ) + 1 (1) * dN * * = floor( (dM j + alpha) / dN ) + 1 * * where * * alpha = - [ dM (N0 + F/2) - dN M0 ] / F * * We use equation (1) to calculate the DDA: there are iL(j+1) - iL(j) * pixels in row j. Because we are always calculating iL(j) for * integer quantities of j, we note that the only fractional term * is constant, and so we can 'throw away' the fractional bits of * alpha: * * beta = floor( - [ dM (N0 + F/2) - dN M0 ] / F ) (2) * * so * * iL(j) = floor( (dM j + beta) / dN ) + 1 (3) * * for integers j. * * Note if iR(j) is the line's rightmost pixel on row j, that * iR(j) = iL(j + 1) - 1. * * Similarly, rewriting equation (1) as a function of column i, * we can determine, given column i, on which pixel row j is the line * lit: * * dN i + [ dM (N0 + F/2) - dN M0 ] / F * j(i) = ceiling( ------------------------------------ ) - 1 * dM * * Floors are easier to compute, so we can rewrite this: * * dN i + [ dM (N0 + F/2) - dN M0 ] / F + dM - 1/F * j(i) = floor( ----------------------------------------------- ) - 1 * dM * * dN i + [ dM (N0 + F/2) - dN M0 ] / F + dM - 1/F - dM * = floor( ---------------------------------------------------- ) * dM * * dN i + [ dM (N0 + F/2) - dN M0 - 1 ] / F * = floor( ---------------------------------------- ) * dM * * We can once again wave our hands and throw away the fractional bits * of the remainder term: * * j(i) = floor( (dN i + gamma) / dM ) (4) * * where * * gamma = floor( [ dM (N0 + F/2) - dN M0 - 1 ] / F ) (5) * * We now note that * * beta = -gamma - 1 = ~gamma (6) * * To draw the pixels of the line, we could evaluate (3) on every scan * line to determine where the strip starts. Of course, we don't want * to do that because that would involve a multiply and divide for every * scan. So we do everything incrementally. * * We would like to easily compute c , the number of pixels on scan j: * j * * c = iL(j + 1) - iL(j) * j * * = floor((dM (j + 1) + beta) / dN) - floor((dM j + beta) / dN) (7) * * This may be rewritten as * * c = floor(i + r / dN) - floor(i + r / dN) (8) * j j+1 j+1 j j * * where i , i are integers and r < dN, r < dN. * j j+1 j j+1 * * Rewriting (7) again: * * c = floor(i + r / dN + dM / dN) - floor(i + r / dN) * j j j j j * * * = floor((r + dM) / dN) - floor(r / dN) * j j * * This may be rewritten as * * c = dI + floor((r + dR) / dN) - floor(r / dN) * j j j * * where dI + dR / dN = dM / dN, dI is an integer and dR < dN. * * r is the remainder (or "error") term in the DDA loop: r / dN * j j * is the exact fraction of a pixel at which the strip ends. To go * on to the next scan and compute c we need to know r . * j+1 j+1 * * So in the main loop of the DDA: * * c = dI + floor((r + dR) / dN) and r = (r + dR) % dN * j j j+1 j * * and we know r < dN, r < dN, and dR < dN. * j j+1 * * We have derived the DDA only for lines in the first octant; to * handle other octants we do the common trick of flipping the line * to the first octant by first making the line left-to-right by * exchanging the end-points, then flipping about the lines y = 0 and * y = x, as necessary. We must record the transformation so we can * undo them later. * * We must also be careful of how the flips affect our rounding. If * to get the line to the first octant we flipped about x = 0, we now * have to be careful to round a y value of 1/2 up instead of down as * we would for a line originally in the first octant (recall that * "In the case where two pels are equidistant, the upper or left * pel is illuminated..."). * * To account for this rounding when running the DDA, we shift the line * (or not) in the y direction by the smallest amount possible. That * takes care of rounding for the DDA, but we still have to be careful * about the rounding when determining the first and last pixels to be * lit in the line. * * Determining The First And Last Pixels In The Line * ------------------------------------------------- * * Fractional coordinates also make it harder to determine which pixels * will be the first and last ones in the line. We've already taken * the fractional coordinates into account in calculating the DDA, but * the DDA cannot tell us which are the end pixels because it is quite * happy to calculate pixels on the line from minus infinity to positive * infinity. * * The diamond rule determines the start and end pixels. (Recall that * the sides are exclusive except for the left and top vertices.) * This convention can be thought of in another way: there are diamonds * around the pixels, and wherever the true line crosses a diamond, * that pel is illuminated. * * Consider a line where we've done the flips to the first octant, and the * floor of the start coordinates is the origin: * * +-----------------------> +x * | * | 0 1 * | 0123456789abcdef * | * | 0 00000000?1111111 * | 1 00000000 1111111 * | 2 0000000 111111 * | 3 000000 11111 * | 4 00000 ** 1111 * | 5 0000 ****1 * | 6 000 1*** * | 7 00 1 **** * | 8 ? *** * | 9 22 3 **** * | a 222 33 *** * | b 2222 333 **** * | c 22222 3333 ** * | d 222222 33333 * | e 2222222 333333 * | f 22222222 3333333 * | * | 2 3 * v * +y * * If the start of the line lands on the diamond around pixel 0 (shown by * the '0' region here), pixel 0 is the first pel in the line. The same * is true for the other pels. * * A little more work has to be done if the line starts in the * 'nether-land' between the diamonds (as illustrated by the '*' line): * the first pel lit is the first diamond crossed by the line (pixel 1 in * our example). This calculation is determined by the DDA or slope of * the line. * * If the line starts exactly half way between two adjacent pixels * (denoted here by the '?' spots), the first pixel is determined by our * round-down convention (and is dependent on the flips done to * normalize the line). * * Last Pel Exclusive * ------------------ * * To eliminate repeatedly lit pels between continuous connected lines, * we employ a last-pel exclusive convention: if the line ends exactly on * the diamond around a pel, that pel is not lit. (This eliminates the * checks we had in the old code to see if we were re-lighting pels.) * * The Half Flip * ------------- * * To make our run length algorithm more efficient, we employ a "half * flip". If after normalizing to the first octant, the slope is more * than 1/2, we subtract the y coordinate from the x coordinate. This * has the effect of reflecting the coordinates through the line of slope * 1/2. Note that the diagonal gets mapped into the x-axis after a half * flip. * * How Many Bits Do We Need, Anyway? * --------------------------------- * * Note that if the line is visible on your screen, you must light up * exactly the correct pixels, no matter where in the 28.4 x 28.4 device * space the end points of the line lie (meaning you must handle 32 bit * DDAs, you can certainly have optimized cases for lesser DDAs). * * We move the origin to (floor(M0 / F), floor(N0 / F)), so when we * calculate gamma from (5), we know that 0 <= M0, N0 < F. And we * are in the first octant, so dM >= dN. Then we know that gamma can * be in the range [(-1/2)dM, (3/2)dM]. The DDI guarantees us that * valid lines will have dM and dN values at most 31 bits (unsigned) * of significance. So gamma requires 33 bits of significance (we store * this as a 64 bit number for convenience). * * When running through the DDA loop, r + dR can have a value in the * j * range 0 <= r < 2 dN; thus the result must be a 32 bit unsigned value. * j * * Testing Lines * ------------- * * To be NT compliant, a display driver must exactly adhere to GIQ, * which means that for any given line, the driver must light exactly * the same pels as does GDI. This can be tested using the Guiman tool * provided elsewhere in the DDK, and 'ZTest', which draws random lines * on the screen and to a bitmap, and compares the results. * * If You've Got Line Hardware * --------------------------- * * If your hardware already adheres to GIQ, you're all set. Otherwise * you'll want to look at the S3 sample code and read the following: * * 1) You'll want to special case integer-only lines, since they require * less processing time and are more common (CAD programs will probably * only ever give integer lines). GDI does not provide a flag saying * that all lines in a path are integer lines; consequently, you will * have to explicitly check every line. * * 2) You are required to correctly draw any line in the 28.4 device * space that intersects the viewport. If you have less than 32 bits * of significance in the hardware for the Bresenham terms, extremely * long lines would overflow the hardware. For such (rare) cases, you * can fall back to strip-drawing code (or if your display is a frame * buffer, fall back to the engine). * * 3) If you can explicitly set the Bresenham terms in your hardware, you * can draw non-integer lines using the hardware. If your hardware has * 'n' bits of precision, you can draw GIQ lines that are up to 2^(n-5) * pels long (4 bits are required for the fractional part, and one bit is * used as a sign bit). Note that integer lines don't require the 4 * fractional bits, so if you special case them as in 1), you can do * integer lines that are up to 2^(n - 1) pels long. See the * 'bHardwareLine' routine for an example. * \**************************************************************************/ BOOL bLines( PDEV* ppdev, POINTFIX* pptfxFirst, // Start of first line POINTFIX* pptfxBuf, // Pointer to buffer of all remaining lines RUN* prun, // Pointer to runs if doing complex clipping ULONG cptfx, // Number of points in pptfxBuf or number of runs // in prun LINESTATE* pls, // Colour and style info RECTL* prclClip, // Pointer to clip rectangle if doing simple clipping PFNSTRIP apfn[], // Array of strip functions FLONG flStart) // Flags for each line, which is a combination of: // FL_SIMPLE_CLIP // FL_COMPLEX_CLIP // FL_STYLED // FL_LAST_PEL_INCLUSIVE // - Should be set only for all integer lines, // and can't be used with FL_COMPLEX_CLIP { ULONG M0; ULONG dM; ULONG N0; ULONG dN; ULONG dN_Original; FLONG fl; LONG x; LONG y; LONGLONG llBeta; LONGLONG llGamma; LONGLONG dl; LONGLONG ll; ULONG ulDelta; ULONG x0; ULONG y0; ULONG x1; ULONG cStylePels; // Major length of line in pixels for styling ULONG xStart; POINTL ptlStart; STRIP strip; PFNSTRIP pfn; LONG cPels; LONG* plStrip; LONG* plStripEnd; LONG cStripsInNextRun; POINTFIX* pptfxBufEnd = pptfxBuf + cptfx; // Last point in path record STYLEPOS spThis; // Style pos for this line BYTE* pjIoBase; BYTE* pjMmBase; pjIoBase = ppdev->pjIoBase; pjMmBase = ppdev->pjMmBase; do { /***********************************************************************\ * Start the DDA calculations. * \***********************************************************************/ M0 = (LONG) pptfxFirst->x; dM = (LONG) pptfxBuf->x; N0 = (LONG) pptfxFirst->y; dN = (LONG) pptfxBuf->y; fl = flStart; // Check for non-clipped, non-styled integer endpoint lines if ((fl & (FL_CLIP | FL_STYLED)) == 0) { // Special-case integer end-point lines: if (((M0 | dM | N0 | dN) & (F - 1)) == 0) { LONG x0; LONG y0; LONG x1; LONG y1; FLONG flQuadrant; ULONG ulCmd; x0 = M0 >> FLOG2; y0 = N0 >> FLOG2; x1 = dM >> FLOG2; y1 = dN >> FLOG2; flQuadrant = 0; dM -= M0; if ((LONG) dM < 0) { dM = - (LONG) dM; flQuadrant = HW_FLIP_H; } dN -= N0; if ((LONG) dN < 0) { dN = - (LONG) dN; flQuadrant |= HW_FLIP_V; } if (dN > dM) { flQuadrant |= HW_FLIP_D; } // When the start and end point are coincident, NT's // last-pel exclusion rule dictates that no pixel is // lit. Unfortunately, the QVision will light a // pixel even when LAST_PIXEL_NULL is specified, so // we have to special case zero-length lines: if (dN | dM) { ulCmd = gaiIntegerLineCmd[flQuadrant]; // Unfortunately, the line command register itself isn't // buffered, so we can't take advantage of the buffered // registers here: if (pjMmBase != NULL) { MM_WAIT_FOR_IDLE(ppdev, pjMmBase); MM_X0_Y0(ppdev, pjMmBase, x0, y0); MM_X1_Y1(ppdev, pjMmBase, x1, y1); MM_LINE_CMD(ppdev, pjMmBase, ulCmd); } else { IO_WAIT_FOR_IDLE(ppdev, pjIoBase); IO_X0_Y0(ppdev, pjIoBase, x0, y0); IO_X1_Y1(ppdev, pjIoBase, x1, y1); IO_LINE_CMD(ppdev, pjIoBase, ulCmd); } } goto Next_Line; } // Check for fractional endpoint lines that are small enough // to use the hardware DDA: if (bHardwareLine(ppdev, pptfxFirst, pptfxBuf)) { // v-normmi... NT bugid 227596 // bHardwareLine sets the LINE_CMD bits differently so set them // back to the default values so that the next 'strip' works right if (pjMmBase != NULL) { MM_WAIT_FOR_IDLE(ppdev, pjMmBase); MM_LINE_CMD(ppdev, pjMmBase, DEFAULT_LINE_CMD & ~START_LINE); } else { IO_WAIT_FOR_IDLE(ppdev, pjIoBase); IO_LINE_CMD(ppdev, pjIoBase, DEFAULT_LINE_CMD & ~START_LINE); } goto Next_Line; } } if ((LONG) M0 > (LONG) dM) { // Ensure that we run left-to-right: register ULONG ulTmp; SWAPL(M0, dM, ulTmp); SWAPL(N0, dN, ulTmp); fl |= FL_FLIP_H; } // Compute the delta dx. The DDI says we can never have a valid delta // with a magnitued more than 2^31 - 1, but GDI never actually checks // its transforms. So we have to check for this case to avoid overflow: dM -= M0; if ((LONG) dM < 0) { goto Next_Line; } if ((LONG) dN < (LONG) N0) { // Line runs from bottom to top, so flip across y = 0: N0 = -(LONG) N0; dN = -(LONG) dN; fl |= FL_FLIP_V; } dN -= N0; if ((LONG) dN < 0) { goto Next_Line; } // We now have a line running left-to-right, top-to-bottom from (M0, N0) // to (M0 + dM, N0 + dN): if (dN >= dM) { if (dN == dM) { // Have to special case slopes of one: fl |= FL_FLIP_SLOPE_ONE; } else { // Since line has slope greater than 1, flip across x = y: register ULONG ulTmp; SWAPL(dM, dN, ulTmp); SWAPL(M0, N0, ulTmp); fl |= FL_FLIP_D; } } fl |= gaflRound[(fl & FL_ROUND_MASK) >> FL_ROUND_SHIFT]; x = LFLOOR((LONG) M0); y = LFLOOR((LONG) N0); M0 = FXFRAC(M0); N0 = FXFRAC(N0); // Calculate the remainder term [ dM * (N0 + F/2) - M0 * dN ]: llGamma = UInt32x32To64(dM, N0 + F/2) - UInt32x32To64(M0, dN); if (fl & FL_V_ROUND_DOWN) // Adjust so y = 1/2 rounds down { llGamma--; } llGamma >>= FLOG2; llBeta = ~llGamma; /***********************************************************************\ * Figure out which pixels are at the ends of the line. * \***********************************************************************/ // The toughest part of GIQ is determining the start and end pels. // // Our approach here is to calculate x0 and x1 (the inclusive start // and end columns of the line respectively, relative to our normalized // origin). Then x1 - x0 + 1 is the number of pels in the line. The // start point is easily calculated by plugging x0 into our line equation // (which takes care of whether y = 1/2 rounds up or down in value) // getting y0, and then undoing the normalizing flips to get back // into device space. // // We look at the fractional parts of the coordinates of the start and // end points, and call them (M0, N0) and (M1, N1) respectively, where // 0 <= M0, N0, M1, N1 < 16. We plot (M0, N0) on the following grid // to determine x0: // // +-----------------------> +x // | // | 0 1 // | 0123456789abcdef // | // | 0 ........?xxxxxxx // | 1 ..........xxxxxx // | 2 ...........xxxxx // | 3 ............xxxx // | 4 .............xxx // | 5 ..............xx // | 6 ...............x // | 7 ................ // | 8 ................ // | 9 ......**........ // | a ........****...x // | b ............**** // | c .............xxx**** // | d ............xxxx **** // | e ...........xxxxx **** // | f ..........xxxxxx // | // | 2 3 // v // // +y // // This grid accounts for the appropriate rounding of GIQ and last-pel // exclusion. If (M0, N0) lands on an 'x', x0 = 2. If (M0, N0) lands // on a '.', x0 = 1. If (M0, N0) lands on a '?', x0 rounds up or down, // depending on what flips have been done to normalize the line. // // For the end point, if (M1, N1) lands on an 'x', x1 = // floor((M0 + dM) / 16) + 1. If (M1, N1) lands on a '.', x1 = // floor((M0 + dM)). If (M1, N1) lands on a '?', x1 rounds up or down, // depending on what flips have been done to normalize the line. // // Lines of exactly slope one require a special case for both the start // and end. For example, if the line ends such that (M1, N1) is (9, 1), // the line has gone exactly through (8, 0) -- which may be considered // to be part of 'x' because of rounding! So slopes of exactly slope // one going through (8, 0) must also be considered as belonging in 'x'. // // For lines that go left-to-right, we have the following grid: // // +-----------------------> +x // | // | 0 1 // | 0123456789abcdef // | // | 0 xxxxxxxx?....... // | 1 xxxxxxx......... // | 2 xxxxxx.......... // | 3 xxxxx........... // | 4 xxxx............ // | 5 xxx............. // | 6 xx.............. // | 7 x............... // | 8 x............... // | 9 x.....**........ // | a xx......****.... // | b xxx.........**** // | c xxxx............**** // | d xxxxx........... **** // | e xxxxxx.......... **** // | f xxxxxxx......... // | // | 2 3 // v // // +y // // This grid accounts for the appropriate rounding of GIQ and last-pel // exclusion. If (M0, N0) lands on an 'x', x0 = 0. If (M0, N0) lands // on a '.', x0 = 1. If (M0, N0) lands on a '?', x0 rounds up or down, // depending on what flips have been done to normalize the line. // // For the end point, if (M1, N1) lands on an 'x', x1 = // floor((M0 + dM) / 16) - 1. If (M1, N1) lands on a '.', x1 = // floor((M0 + dM)). If (M1, N1) lands on a '?', x1 rounds up or down, // depending on what flips have been done to normalize the line. // // Lines of exactly slope one must be handled similarly to the right-to- // left case. { // Calculate x0, x1 ULONG N1 = FXFRAC(N0 + dN); ULONG M1 = FXFRAC(M0 + dM); x1 = LFLOOR(M0 + dM); if (fl & FL_LAST_PEL_INCLUSIVE) { // It sure is easy to compute the first pel when lines have only // integer coordinates and are last-pel inclusive: x0 = 0; y0 = 0; // Last-pel inclusive lines that are exactly one pixel long // have a 'delta-x' and 'delta-y' equal to zero. The problem is // that our clip code assumes that 'delta-x' is always non-zero // (since it never happens with last-pel exclusive lines). As // an inelegant solution, we simply modify 'delta-x' in this // case -- because the line is exactly one pixel long, changing // the slope will obviously have no effect on rasterization. if (x1 == 0) { dM = 1; llGamma = 0; llBeta = ~llGamma; } } else { if (fl & FL_FLIP_H) { // --------------------------------------------------------------- // Line runs right-to-left: <---- // Compute x1: if (N1 == 0) { if (LROUND(M1, fl & FL_H_ROUND_DOWN)) { x1++; } } else if (abs((LONG) (N1 - F/2)) + M1 > F) { x1++; } if ((fl & (FL_FLIP_SLOPE_ONE | FL_H_ROUND_DOWN)) == (FL_FLIP_SLOPE_ONE)) { // Have to special-case diagonal lines going through our // the point exactly equidistant between two horizontal // pixels, if we're supposed to round x=1/2 down: if ((N1 > 0) && (M1 == N1 + 8)) x1++; // Don't you love special cases? Is this a rhetorical question? if ((N0 > 0) && (M0 == N0 + 8)) { x0 = 2; ulDelta = dN; goto right_to_left_compute_y0; } } // Compute x0: x0 = 1; ulDelta = 0; if (N0 == 0) { if (LROUND(M0, fl & FL_H_ROUND_DOWN)) { x0 = 2; ulDelta = dN; } } else if (abs((LONG) (N0 - F/2)) + M0 > F) { x0 = 2; ulDelta = dN; } // Compute y0: right_to_left_compute_y0: y0 = 0; ll = llGamma + (LONGLONG) ulDelta; if (ll >= (LONGLONG) (2 * dM - dN)) y0 = 2; else if (ll >= (LONGLONG) (dM - dN)) y0 = 1; } else { // --------------------------------------------------------------- // Line runs left-to-right: ----> // Compute x1: if (!(fl & FL_LAST_PEL_INCLUSIVE)) x1--; if (M1 > 0) { if (N1 == 0) { if (LROUND(M1, fl & FL_H_ROUND_DOWN)) x1++; } else if (abs((LONG) (N1 - F/2)) <= (LONG) M1) { x1++; } } if ((fl & (FL_FLIP_SLOPE_ONE | FL_H_ROUND_DOWN)) == (FL_FLIP_SLOPE_ONE | FL_H_ROUND_DOWN)) { // Have to special-case diagonal lines going through our // the point exactly equidistant between two horizontal // pixels, if we're supposed to round x=1/2 down: if ((M1 > 0) && (N1 == M1 + 8)) x1--; if ((M0 > 0) && (N0 == M0 + 8)) { x0 = 0; goto left_to_right_compute_y0; } } // Compute x0: x0 = 0; if (M0 > 0) { if (N0 == 0) { if (LROUND(M0, fl & FL_H_ROUND_DOWN)) x0 = 1; } else if (abs((LONG) (N0 - F/2)) <= (LONG) M0) { x0 = 1; } } // Compute y0: left_to_right_compute_y0: y0 = 0; if (llGamma >= (LONGLONG) (dM - (dN & (-(LONG) x0)))) { y0 = 1; } } } } cStylePels = x1 - x0 + 1; if ((LONG) cStylePels <= 0) goto Next_Line; xStart = x0; /***********************************************************************\ * Complex clipping. * \***********************************************************************/ if (fl & FL_COMPLEX_CLIP) { dN_Original = dN; Continue_Complex_Clipping: if (fl & FL_FLIP_H) { // Line runs right-to-left <----- x0 = xStart + cStylePels - prun->iStop - 1; x1 = xStart + cStylePels - prun->iStart - 1; } else { // Line runs left-to-right -----> x0 = xStart + prun->iStart; x1 = xStart + prun->iStop; } prun++; // Reset some variables we'll nuke a little later: dN = dN_Original; pls->spNext = pls->spComplex; // No overflow since large integer math is used. Both values // will be positive: dl = UInt32x32To64(x0, dN) + llGamma; // y0 = dl / dM: y0 = UInt64Div32To32(dl, dM); ASSERTDD((LONG) y0 >= 0, "y0 weird: Goofed up end pel calc?"); } /***********************************************************************\ * Simple rectangular clipping. * \***********************************************************************/ if (fl & FL_SIMPLE_CLIP) { ULONG y1; LONG xRight; LONG xLeft; LONG yBottom; LONG yTop; // Note that y0 and y1 are actually the lower and upper bounds, // respectively, of the y coordinates of the line (the line may // have actually shrunk due to first/last pel clipping). // // Also note that x0, y0 are not necessarily zero. RECTL* prcl = &prclClip[(fl & FL_RECTLCLIP_MASK) >> FL_RECTLCLIP_SHIFT]; // Normalize to the same point we've normalized for the DDA // calculations: xRight = prcl->right - x; xLeft = prcl->left - x; yBottom = prcl->bottom - y; yTop = prcl->top - y; if (yBottom <= (LONG) y0 || xRight <= (LONG) x0 || xLeft > (LONG) x1) { Totally_Clipped: if (fl & FL_STYLED) { pls->spNext += cStylePels; if (pls->spNext >= pls->spTotal2) pls->spNext %= pls->spTotal2; } goto Next_Line; } if ((LONG) x1 >= xRight) x1 = xRight - 1; // We have to know the correct y1, which we haven't bothered to // calculate up until now. This multiply and divide is quite // expensive; we could replace it with code similar to that which // we used for computing y0. // // The reason why we need the actual value, and not an upper // bounds guess like y1 = LFLOOR(dM) + 2 is that we have to be // careful when calculating x(y) that y0 <= y <= y1, otherwise // we can overflow on the divide (which, needless to say, is very // bad). dl = UInt32x32To64(x1, dN) + llGamma; // y1 = dl / dM: y1 = UInt64Div32To32(dl, dM); if (yTop > (LONG) y1) goto Totally_Clipped; if (yBottom <= (LONG) y1) { y1 = yBottom; dl = UInt32x32To64(y1, dM) + llBeta; // x1 = dl / dN: x1 = UInt64Div32To32(dl, dN); } // At this point, we've taken care of calculating the intercepts // with the right and bottom edges. Now we work on the left and // top edges: if (xLeft > (LONG) x0) { x0 = xLeft; dl = UInt32x32To64(x0, dN) + llGamma; // y0 = dl / dM; y0 = UInt64Div32To32(dl, dM); if (yBottom <= (LONG) y0) goto Totally_Clipped; } if (yTop > (LONG) y0) { y0 = yTop; dl = UInt32x32To64(y0, dM) + llBeta; // x0 = dl / dN + 1; x0 = UInt64Div32To32(dl, dN) + 1; if (xRight <= (LONG) x0) goto Totally_Clipped; } ASSERTDD(x0 <= x1, "Improper rectangle clip"); } /***********************************************************************\ * Done clipping. Unflip if necessary. * \***********************************************************************/ ptlStart.x = x + x0; ptlStart.y = y + y0; if (fl & FL_FLIP_D) { register LONG lTmp; SWAPL(ptlStart.x, ptlStart.y, lTmp); } if (fl & FL_FLIP_V) { ptlStart.y = -ptlStart.y; } cPels = x1 - x0 + 1; /***********************************************************************\ * Style calculations. * \***********************************************************************/ if (fl & FL_STYLED) { STYLEPOS sp; spThis = pls->spNext; pls->spNext += cStylePels; { if (pls->spNext >= pls->spTotal2) pls->spNext %= pls->spTotal2; if (fl & FL_FLIP_H) sp = pls->spNext - x0 + xStart; else sp = spThis + x0 - xStart; ASSERTDD(fl & FL_STYLED, "Oops"); // Normalize our target style position: if ((sp < 0) || (sp >= pls->spTotal2)) { sp %= pls->spTotal2; // The modulus of a negative number is not well-defined // in C -- if it's negative we'll adjust it so that it's // back in the range [0, spTotal2): if (sp < 0) sp += pls->spTotal2; } // Since we always draw the line left-to-right, but styling is // always done in the direction of the original line, we have // to figure out where we are in the style array for the left // edge of this line. if (fl & FL_FLIP_H) { // Line originally ran right-to-left: sp = -sp; if (sp < 0) sp += pls->spTotal2; pls->ulStyleMask = ~pls->ulStartMask; pls->pspStart = &pls->aspRtoL[0]; pls->pspEnd = &pls->aspRtoL[pls->cStyle - 1]; } else { // Line originally ran left-to-right: pls->ulStyleMask = pls->ulStartMask; pls->pspStart = &pls->aspLtoR[0]; pls->pspEnd = &pls->aspLtoR[pls->cStyle - 1]; } if (sp >= pls->spTotal) { sp -= pls->spTotal; if (pls->cStyle & 1) pls->ulStyleMask = ~pls->ulStyleMask; } pls->psp = pls->pspStart; while (sp >= *pls->psp) sp -= *pls->psp++; ASSERTDD(pls->psp <= pls->pspEnd, "Flew off into NeverNeverLand"); pls->spRemaining = *pls->psp - sp; if ((pls->psp - pls->pspStart) & 1) pls->ulStyleMask = ~pls->ulStyleMask; } } plStrip = &strip.alStrips[0]; plStripEnd = &strip.alStrips[STRIP_MAX]; // Is exclusive cStripsInNextRun = 0x7fffffff; strip.ptlStart = ptlStart; if (2 * dN > dM && !(fl & FL_STYLED)) { // Do a half flip! Remember that we may doing this on the // same line multiple times for complex clipping (meaning the // affected variables should be reset for every clip run): fl |= FL_FLIP_HALF; llBeta = llGamma - (LONGLONG) ((LONG) dM); dN = dM - dN; y0 = x0 - y0; // Note this may overflow, but that's okay } // Now, run the DDA starting at (ptlStart.x, ptlStart.y)! strip.flFlips = fl; pfn = apfn[(fl & FL_STRIP_MASK) >> FL_STRIP_SHIFT]; // Now calculate the DDA variables needed to figure out how many pixels // go in the very first strip: { register LONG i; register ULONG dI; register ULONG dR; ULONG r; if (dN == 0) i = 0x7fffffff; else { dl = UInt32x32To64(y0 + 1, dM) + llBeta; ASSERTDD(dl >= 0, "Oops!"); // i = (dl / dN) - x0 + 1; // r = (dl % dN); i = UInt64Div32To32(dl, dN); r = UInt64Mod32To32(dl, dN); i = i - x0 + 1; dI = dM / dN; dR = dM % dN; // 0 <= dR < dN ASSERTDD(dI > 0, "Weird dI"); } ASSERTDD(i > 0 && i <= 0x7fffffff, "Weird initial strip length"); ASSERTDD(cPels > 0, "Zero pel line"); /***********************************************************************\ * Run the DDA! * \***********************************************************************/ while(TRUE) { cPels -= i; if (cPels <= 0) break; *plStrip++ = i; if (plStrip == plStripEnd) { strip.cStrips = (LONG)(plStrip - &strip.alStrips[0]); (*pfn)(ppdev, &strip, pls); plStrip = &strip.alStrips[0]; } i = dI; r += dR; if (r >= dN) { r -= dN; i++; } } *plStrip++ = cPels + i; strip.cStrips = (LONG)(plStrip - &strip.alStrips[0]); (*pfn)(ppdev, &strip, pls); } Next_Line: if (fl & FL_COMPLEX_CLIP) { cptfx--; if (cptfx != 0) goto Continue_Complex_Clipping; break; } else { pptfxFirst = pptfxBuf; pptfxBuf++; } } while (pptfxBuf < pptfxBufEnd); return(TRUE); } /******************************Public*Routine******************************\ * BOOL bHardwareLine(ppdev, pptfxStart, pptfxEnd) * * This routine is useful for folks who have line drawing hardware where * they can explicitly set the Bresenham terms -- they can use this routine * to draw fractional coordinate GIQ lines with the hardware. * * Fractional coordinate lines require an extra 4 bits of precision in the * Bresenham terms. For example, if your hardware has 13 bits of precision * for the terms, you can only draw GIQ lines up to 255 pels long using this * routine. * * Input: * pptfxStart - Points to GIQ coordinate of start of line * pptfxEnd - Points to GIQ coordinate of end of line * NUM_DDA_BITS- The number of bits of precision your hardware can support. * * Output: * returns - TRUE if the line was drawn. * FALSE if the line is too long, and the strips code must be * used. * * DDALINE: * iDir - Direction of the line, as an octant numbered as follows: * * \ 5 | 6 / * \ | / * 4 \ | / 7 * \ / * -----+----- * /|\ * 3 / | \ 0 * / | \ * / 2 | 1 \ * * ptlStart - Start pixel of line. * cPels - # of pels in line. *NOTE* You must check if this is <= 0! * dMajor - Major axis delta. * dMinor - Minor axis delta. * lErrorTerm - Error term. * * What you do with the last 3 terms may be a little tricky. They are * actually the terms for the formula of the normalized line * * dMinor * x + (lErrorTerm + dMajor) * y(x) = floor( ---------------------------------- ) * dMajor * * where y(x) is the y coordinate of the pixel to be lit as a function of * the x-coordinate. * * Every time the line advances one in the major direction 'x', dMinor * gets added to the current error term. If the resulting value is >= 0, * we know we have to move one pixel in the minor direction 'y', and * dMajor must be subtracted from the current error term. * * If you're trying to figure out what this means for your hardware, you can * think of the DDALINE terms as having been computed equivalently as * follows: * * dMinor = 2 * (minor axis delta) * dMajor = 2 * (major axis delta) * lErrorTerm = - (major axis delta) - fixup * * That is, if your documentation tells you that for integer lines, a * register is supposed to be initialized with the value * '2 * (minor axis delta)', you'll actually use dMinor. * * Example: Setting up the 8514 * * AXSTPSIGN is supposed to be the axial step constant register, defined * as 2 * (minor axis delta). You set: * * AXSTPSIGN = dMinor * * DGSTPSIGN is supposed to be the diagonal step constant register, * defined as 2 * (minor axis delta) - 2 * (major axis delta). You set: * * DGSTPSIGN = dMinor - dMajor * * ERR_TERM is supposed to be the adjusted error term, defined as * 2 * (minor axis delta) - (major axis delta) - fixup. You set: * * ERR_TERM = lErrorTerm + dMinor * * Implementation: * * You'll want to special case integer lines before calling this routine * (since they're very common, take less time to the computation of line * terms, and can handle longer lines than this routine because 4 bits * aren't being given to the fraction). * * If a GIQ line is too long to be handled by this routine, you can just * use the slower strip routines for that line. Note that you cannot * just fail the call -- you must be able to accurately draw any line * in the 28.4 device space when it intersects the viewport. * * Testing: * * Use Guiman, or some other test that draws random fractional coordinate * lines and compares them to what GDI itself draws to a bitmap. * \**************************************************************************/ BOOL bHardwareLine( PDEV* ppdev, POINTFIX* pptfxStart, // Start of line POINTFIX* pptfxEnd) // End of line { FLONG fl; // Various flags ULONG M0; // Normalized fractional unit x start coordinate (0 <= M0 < F) ULONG N0; // Normalized fractional unit y start coordinate (0 <= N0 < F) ULONG M1; // Normalized fractional unit x end coordinate (0 <= M1 < F) ULONG N1; // Normalized fractional unit x end coordinate (0 <= N1 < F) ULONG dM; // Normalized fractional unit x-delta (0 <= dM) ULONG dN; // Normalized fractional unit y-delta (0 <= dN <= dM) LONG x; // Normalized x coordinate of origin LONG y; // Normalized y coordinate of origin LONG x0; // Normalized x offset from origin to start pixel (inclusive) LONG y0; // Normalized y offset from origin to start pixel (inclusive) LONG x1; // Normalized x offset from origin to end pixel (inclusive) LONG lGamma;// Bresenham error term at origin LONG cPels; // Number of pixels in line BYTE* pjMmBase; BYTE* pjIoBase; /***********************************************************************\ * Normalize line to the first octant. \***********************************************************************/ fl = 0; M0 = pptfxStart->x; dM = pptfxEnd->x; if ((LONG) dM < (LONG) M0) { // Line runs from right to left, so flip across x = 0: M0 = -(LONG) M0; dM = -(LONG) dM; fl |= HW_FLIP_H; } // Compute the delta. The DDI says we can never have a valid delta // with a magnitude more than 2^31 - 1, but the engine never actually // checks its transforms. To ensure that we'll never puke on our shoes, // we check for that case and simply refuse to draw the line: dM -= M0; if ((LONG) dM < 0) return(FALSE); N0 = pptfxStart->y; dN = pptfxEnd->y; if ((LONG) dN < (LONG) N0) { // Line runs from bottom to top, so flip across y = 0: N0 = -(LONG) N0; dN = -(LONG) dN; fl |= HW_FLIP_V; } // Compute another delta: dN -= N0; if ((LONG) dN < 0) return(FALSE); if (dN >= dM) { if (dN == dM) { // Have to special case slopes of one: fl |= HW_FLIP_SLOPE_ONE; } else { // Since line has slope greater than 1, flip across x = y: register ULONG ulTmp; ulTmp = dM; dM = dN; dN = ulTmp; ulTmp = M0; M0 = N0; N0 = ulTmp; fl |= HW_FLIP_D; } } // Figure out if we can do the line in hardware, given that we have a // limited number of bits of precision for the Bresenham terms. // // Remember that one bit has to be kept as a sign bit: if ((LONG) dM >= (1L << (NUM_DDA_BITS - 1))) return(FALSE); fl |= gaflHardwareRound[fl]; /***********************************************************************\ * Calculate the error term at pixel 0. \***********************************************************************/ x = LFLOOR((LONG) M0); y = LFLOOR((LONG) N0); M0 = FXFRAC(M0); N0 = FXFRAC(N0); // NOTE NOTE NOTE: If this routine were to handle any line in the 28.4 // space, it will overflow its math (the following part requires 36 bits // of precision)! But we get here for lines that the hardware can handle // (see the expression (dM >= (1L << (NUM_DDA_BITS - 1))) above?), so if // cBits is less than 28, we're safe. // // If you're going to use this routine to handle all lines in the 28.4 // device space, you will HAVE to make sure the math doesn't overflow, // otherwise you won't be NT compliant! (See 'bHardwareLine' for an example // how to do that. You don't have to worry about this if you simply // default to the strips code for long lines, because those routines // already do the math correctly.) // Calculate the remainder term [ dM * (N0 + F/2) - M0 * dN ]. Note // that M0 and N0 have at most 4 bits of significance (and if the // arguments are properly ordered, on a 486 each multiply would be no // more than 13 cycles): lGamma = (N0 + F/2) * dM - M0 * dN; if (fl & HW_Y_ROUND_DOWN) lGamma--; lGamma >>= FLOG2; /***********************************************************************\ * Figure out which pixels are at the ends of the line. \***********************************************************************/ // The toughest part of GIQ is determining the start and end pels. // // Our approach here is to calculate x0 and x1 (the inclusive start // and end columns of the line respectively, relative to our normalized // origin). Then x1 - x0 + 1 is the number of pels in the line. The // start point is easily calculated by plugging x0 into our line equation // (which takes care of whether y = 1/2 rounds up or down in value) // getting y0, and then undoing the normalizing flips to get back // into device space. // // We look at the fractional parts of the coordinates of the start and // end points, and call them (M0, N0) and (M1, N1) respectively, where // 0 <= M0, N0, M1, N1 < 16. We plot (M0, N0) on the following grid // to determine x0: // // +-----------------------> +x // | // | 0 1 // | 0123456789abcdef // | // | 0 ........?xxxxxxx // | 1 ..........xxxxxx // | 2 ...........xxxxx // | 3 ............xxxx // | 4 .............xxx // | 5 ..............xx // | 6 ...............x // | 7 ................ // | 8 ................ // | 9 ......**........ // | a ........****...x // | b ............**** // | c .............xxx**** // | d ............xxxx **** // | e ...........xxxxx **** // | f ..........xxxxxx // | // | 2 3 // v // // +y // // This grid accounts for the appropriate rounding of GIQ and last-pel // exclusion. If (M0, N0) lands on an 'x', x0 = 2. If (M0, N0) lands // on a '.', x0 = 1. If (M0, N0) lands on a '?', x0 rounds up or down, // depending on what flips have been done to normalize the line. // // For the end point, if (M1, N1) lands on an 'x', x1 = // floor((M0 + dM) / 16) + 1. If (M1, N1) lands on a '.', x1 = // floor((M0 + dM)). If (M1, N1) lands on a '?', x1 rounds up or down, // depending on what flips have been done to normalize the line. // // Lines of exactly slope one require a special case for both the start // and end. For example, if the line ends such that (M1, N1) is (9, 1), // the line has gone exactly through (8, 0) -- which may be considered // to be part of 'x' because of rounding! So slopes of exactly slope // one going through (8, 0) must also be considered as belonging in 'x' // when an x value of 1/2 is supposed to round up in value. // Calculate x0, x1: N1 = FXFRAC(N0 + dN); M1 = FXFRAC(M0 + dM); x1 = LFLOOR(M0 + dM); // Line runs left-to-right: // Compute x1: x1--; if (M1 > 0) { if (N1 == 0) { if (LROUND(M1, fl & HW_X_ROUND_DOWN)) x1++; } else if (abs((LONG) (N1 - F/2)) <= (LONG) M1) { x1++; } } if ((fl & (HW_FLIP_SLOPE_ONE | HW_X_ROUND_DOWN)) == (HW_FLIP_SLOPE_ONE | HW_X_ROUND_DOWN)) { // Have to special-case diagonal lines going through our // the point exactly equidistant between two horizontal // pixels, if we're supposed to round x=1/2 down: if ((M1 > 0) && (N1 == M1 + 8)) x1--; if ((M0 > 0) && (N0 == M0 + 8)) { x0 = 0; goto left_to_right_compute_y0; } } // Compute x0: x0 = 0; if (M0 > 0) { if (N0 == 0) { if (LROUND(M0, fl & HW_X_ROUND_DOWN)) x0 = 1; } else if (abs((LONG) (N0 - F/2)) <= (LONG) M0) { x0 = 1; } } left_to_right_compute_y0: /***********************************************************************\ * Calculate the start pixel. \***********************************************************************/ // We now compute y0 and adjust the error term. We know x0, and we know // the current formula for the pixels to be lit on the line: // // dN * x + lGamma // y(x) = floor( --------------- ) // dM // // The remainder of this expression is the new error term at (x0, y0). // Since x0 is going to be either 0 or 1, we don't actually have to do a // multiply or divide to compute y0. Finally, we subtract dM from the // new error term so that it is in the range [-dM, 0). y0 = 0; lGamma += (dN & (-x0)); lGamma -= dM; if (lGamma >= 0) { y0 = 1; lGamma -= dM; } // Undo our flips to get the start coordinate: x += x0; y += y0; if (fl & HW_FLIP_D) { register LONG lTmp; lTmp = x; x = y; y = lTmp; } if (fl & HW_FLIP_V) { y = -y; } if (fl & HW_FLIP_H) { x = -x; } /***********************************************************************\ * Return the Bresenham terms: \***********************************************************************/ // iDir = gaiDir[fl & HW_FLIP_MASK]; // ptlStart.x = x; // ptlStart.y = y; // cPels = x1 - x0 + 1; // NOTE: You'll have to check if cPels <= 0! // dMajor = dM; // dMinor = dN; // lErrorTerm = lGamma; /***********************************************************************\ * Draw the line. S3 specific code follows: \***********************************************************************/ cPels = x1 - x0 + 1; if (cPels > 0) { pjMmBase = ppdev->pjMmBase; if (pjMmBase != NULL) { MM_WAIT_FOR_IDLE(ppdev, pjMmBase); MM_LINE_PIX_CNT(ppdev, pjMmBase, cPels); MM_LINE_ERR_TERM(ppdev, pjMmBase, lGamma + dN); MM_K1_CONST(ppdev, pjMmBase, dN); MM_K2_CONST(ppdev, pjMmBase, dN - dM); MM_SIGN_CODES(ppdev, pjMmBase, (fl & HW_FLIP_MASK)); MM_X0_Y0(ppdev, pjMmBase, x, y); MM_LINE_CMD(ppdev, pjMmBase, DEFAULT_LINE_CMD | LAST_PIXEL_NULL); } else { pjIoBase = ppdev->pjIoBase; IO_WAIT_FOR_IDLE(ppdev, pjIoBase); IO_LINE_PIX_CNT(ppdev, pjIoBase, cPels); IO_LINE_ERR_TERM(ppdev, pjIoBase, lGamma + dN); IO_K1_CONST(ppdev, pjIoBase, dN); IO_K2_CONST(ppdev, pjIoBase, dN - dM); IO_SIGN_CODES(ppdev, pjIoBase, (fl & HW_FLIP_MASK)); IO_X0_Y0(ppdev, pjIoBase, x, y); IO_LINE_CMD(ppdev, pjIoBase, DEFAULT_LINE_CMD | LAST_PIXEL_NULL); } } return(TRUE); } /*******************************Public*Table*******************************\ * gapfnStrip * * Look-up table for DrvStrokePath to find which strip routines to call. * \**************************************************************************/ VOID (*gapfnIoStrip[])(PDEV*, STRIP*, LINESTATE*) = { vIoStripSolidHorizontal, vIoStripSolidVertical, vIoStripSolidDiagonalHorizontal, vIoStripSolidDiagonalVertical, vIoStripStyledHorizontal, vIoStripStyledVertical, vIoStripStyledVertical, // Diagonal goes here vIoStripStyledVertical, // Diagonal goes here }; VOID (*gapfnMmStrip[])(PDEV*, STRIP*, LINESTATE*) = { vMmStripSolidHorizontal, vMmStripSolidVertical, vMmStripSolidDiagonalHorizontal, vMmStripSolidDiagonalVertical, vMmStripStyledHorizontal, vMmStripStyledVertical, vMmStripStyledVertical, // Diagonal goes here vMmStripStyledVertical, // Diagonal goes here }; // Style array for alternate style (alternates one pixel on, one pixel off): STYLEPOS gaspAlternateStyle[] = { 1 }; /******************************Public*Routine******************************\ * BOOL DrvStrokePath(pso, ppo, pco, pxo, pbo, pptlBrush, pla, mix) * * Strokes the path. * \**************************************************************************/ BOOL DrvStrokePath( SURFOBJ* pso, PATHOBJ* ppo, CLIPOBJ* pco, XFORMOBJ* pxo, BRUSHOBJ* pbo, POINTL* pptlBrush, LINEATTRS* pla, MIX mix) { STYLEPOS aspLtoR[STYLE_MAX_COUNT]; STYLEPOS aspRtoL[STYLE_MAX_COUNT]; LINESTATE ls; PFNSTRIP* apfn; FLONG fl; PDEV* ppdev; DSURF* pdsurf; OH* poh; RECTL arclClip[4]; // For rectangular clipping BYTE* pjIoBase; BYTE* pjMmBase; RECTL* prclClip; ULONG ulLinePattern; ASSERTDD(((mix >> 8) & 0xff) == (mix & 0xff), "GDI gave us an improper mix"); // Pass the surface off to GDI if it's a device bitmap that we've // converted to a DIB: pdsurf = (DSURF*) pso->dhsurf; if (pdsurf->dt == DT_DIB) { return(EngStrokePath(pdsurf->pso, ppo, pco, pxo, pbo, pptlBrush, pla, mix)); } // We'll be drawing to the screen or an off-screen DFB; copy the surface's // offset now so that we won't need to refer to the DSURF again: poh = pdsurf->poh; ppdev = (PDEV*) pso->dhpdev; ppdev->xOffset = poh->x; ppdev->yOffset = poh->y; pjIoBase = ppdev->pjIoBase; pjMmBase = ppdev->pjMmBase; prclClip = NULL; fl = 0; ulLinePattern = (ULONG) -1; // Look after styling initialization: if (pla->fl & LA_ALTERNATE) { ls.cStyle = 1; ls.spTotal = 1; ls.spTotal2 = 2; ls.spRemaining = 1; ls.aspRtoL = &gaspAlternateStyle[0]; ls.aspLtoR = &gaspAlternateStyle[0]; ls.spNext = HIWORD(pla->elStyleState.l); ls.xyDensity = 1; fl |= FL_STYLED; ls.ulStartMask = 0L; } else if (pla->pstyle != (FLOAT_LONG*) NULL) { PFLOAT_LONG pstyle; STYLEPOS* pspDown; STYLEPOS* pspUp; pstyle = &pla->pstyle[pla->cstyle]; ls.xyDensity = STYLE_DENSITY; ls.spTotal = 0; while (pstyle-- > pla->pstyle) { ls.spTotal += pstyle->l; } ls.spTotal *= STYLE_DENSITY; ls.spTotal2 = 2 * ls.spTotal; // Compute starting style position (this is guaranteed not to overflow): ls.spNext = HIWORD(pla->elStyleState.l) * STYLE_DENSITY + LOWORD(pla->elStyleState.l); fl |= FL_STYLED; ls.cStyle = pla->cstyle; ls.aspRtoL = aspRtoL; ls.aspLtoR = aspLtoR; if (pla->fl & LA_STARTGAP) ls.ulStartMask = 0xffffffffL; else ls.ulStartMask = 0L; pstyle = pla->pstyle; pspDown = &ls.aspRtoL[ls.cStyle - 1]; pspUp = &ls.aspLtoR[0]; while (pspDown >= &ls.aspRtoL[0]) { *pspDown = pstyle->l * STYLE_DENSITY; *pspUp = *pspDown; pspUp++; pspDown--; pstyle++; } } if (pco->iDComplexity == DC_RECT) { fl |= FL_SIMPLE_CLIP; arclClip[0] = pco->rclBounds; // FL_FLIP_D: arclClip[1].top = pco->rclBounds.left; arclClip[1].left = pco->rclBounds.top; arclClip[1].bottom = pco->rclBounds.right; arclClip[1].right = pco->rclBounds.bottom; // FL_FLIP_V: arclClip[2].top = -pco->rclBounds.bottom + 1; arclClip[2].left = pco->rclBounds.left; arclClip[2].bottom = -pco->rclBounds.top + 1; arclClip[2].right = pco->rclBounds.right; // FL_FLIP_V | FL_FLIP_D: arclClip[3].top = pco->rclBounds.left; arclClip[3].left = -pco->rclBounds.bottom + 1; arclClip[3].bottom = pco->rclBounds.right; arclClip[3].right = -pco->rclBounds.top + 1; prclClip = arclClip; } if (ppdev->pjMmBase != NULL) apfn = &gapfnMmStrip[4 * ((fl & FL_STYLE_MASK) >> FL_STYLE_SHIFT)]; else apfn = &gapfnIoStrip[4 * ((fl & FL_STYLE_MASK) >> FL_STYLE_SHIFT)]; // Get the device ready: if (pjMmBase != NULL) { MM_WAIT_FOR_IDLE(ppdev, pjMmBase); MM_FG_COLOR(ppdev, pjMmBase, pbo->iSolidColor); MM_CTRL_REG_1(ppdev, pjMmBase, EXPAND_TO_FG | BITS_PER_PIX_8 | ENAB_TRITON_MODE); MM_LINE_PATTERN(ppdev, pjMmBase, ulLinePattern); MM_LINE_CMD(ppdev, pjMmBase, DEFAULT_LINE_CMD & ~START_LINE); if (mix == ((R2_COPYPEN << 8) | R2_COPYPEN)) { MM_DATAPATH_CTRL(ppdev, pjMmBase, ROPSELECT_NO_ROPS | PIXELMASK_AND_SRC_DATA | PLANARMASK_NONE_0XFF | SRC_IS_LINE_PATTERN); } else { MM_ROP_A(ppdev, pjMmBase, (mix - 1)); MM_DATAPATH_CTRL(ppdev, pjMmBase, ROPSELECT_ALL | PIXELMASK_AND_SRC_DATA | PLANARMASK_NONE_0XFF | SRC_IS_LINE_PATTERN); } } else { IO_WAIT_FOR_IDLE(ppdev, pjIoBase); IO_FG_COLOR(ppdev, pjIoBase, pbo->iSolidColor); IO_CTRL_REG_1(ppdev, pjIoBase, EXPAND_TO_FG | BITS_PER_PIX_8 | ENAB_TRITON_MODE); IO_LINE_PATTERN(ppdev, pjIoBase, ulLinePattern); IO_LINE_CMD(ppdev, pjIoBase, DEFAULT_LINE_CMD & ~START_LINE); if (mix == ((R2_COPYPEN << 8) | R2_COPYPEN)) { IO_DATAPATH_CTRL(ppdev, pjIoBase, ROPSELECT_NO_ROPS | PIXELMASK_AND_SRC_DATA | PLANARMASK_NONE_0XFF | SRC_IS_LINE_PATTERN); } else { IO_ROP_A(ppdev, pjIoBase, (mix - 1)); IO_DATAPATH_CTRL(ppdev, pjIoBase, ROPSELECT_ALL | PIXELMASK_AND_SRC_DATA | PLANARMASK_NONE_0XFF | SRC_IS_LINE_PATTERN); } } // Set up to enumerate the path: if (pco->iDComplexity != DC_COMPLEX) { PATHDATA pd; BOOL bMore; ULONG cptfx; POINTFIX ptfxStartFigure; POINTFIX ptfxLast; POINTFIX* pptfxFirst; POINTFIX* pptfxBuf; pd.flags = 0; do { bMore = PATHOBJ_bEnum(ppo, &pd); cptfx = pd.count; if (cptfx == 0) break; if (pd.flags & PD_BEGINSUBPATH) { ptfxStartFigure = *pd.pptfx; pptfxFirst = pd.pptfx; pptfxBuf = pd.pptfx + 1; cptfx--; } else { pptfxFirst = &ptfxLast; pptfxBuf = pd.pptfx; } if (pd.flags & PD_RESETSTYLE) ls.spNext = 0; if (cptfx > 0) { if (!bLines(ppdev, pptfxFirst, pptfxBuf, (RUN*) NULL, cptfx, &ls, prclClip, apfn, fl)) return(FALSE); } ptfxLast = pd.pptfx[pd.count - 1]; if (pd.flags & PD_CLOSEFIGURE) { if (!bLines(ppdev, &ptfxLast, &ptfxStartFigure, (RUN*) NULL, 1, &ls, prclClip, apfn, fl)) return(FALSE); } } while (bMore); if (fl & FL_STYLED) { // Save the style state: ULONG ulHigh; ULONG ulLow; // Masked styles don't normalize the style state. It's a good // thing to do, so let's do it now: if ((ULONG) ls.spNext >= (ULONG) ls.spTotal2) ls.spNext = (ULONG) ls.spNext % (ULONG) ls.spTotal2; ulHigh = ls.spNext / ls.xyDensity; ulLow = ls.spNext % ls.xyDensity; pla->elStyleState.l = MAKELONG(ulLow, ulHigh); } } else { // Local state for path enumeration: BOOL bMore; union { BYTE aj[offsetof(CLIPLINE, arun) + RUN_MAX * sizeof(RUN)]; CLIPLINE cl; } cl; fl |= FL_COMPLEX_CLIP; // We use the clip object when non-simple clipping is involved: PATHOBJ_vEnumStartClipLines(ppo, pco, pso, pla); do { bMore = PATHOBJ_bEnumClipLines(ppo, sizeof(cl), &cl.cl); if (cl.cl.c != 0) { if (fl & FL_STYLED) { ls.spComplex = HIWORD(cl.cl.lStyleState) * ls.xyDensity + LOWORD(cl.cl.lStyleState); } if (!bLines(ppdev, &cl.cl.ptfxA, &cl.cl.ptfxB, &cl.cl.arun[0], cl.cl.c, &ls, (RECTL*) NULL, apfn, fl)) return(FALSE); } } while (bMore); } return(TRUE); }