/******************************Module*Header*******************************\ * Module Name: trimesh.cxx * * Gradient fill inplementation * * Created: 21-Jun-1996 * Author: Mark Enstrom [marke] * * Copyright (c) 1996-1999 Microsoft Corporation \**************************************************************************/ #include "precomp.hxx" #include "solline.hxx" /**************************************************************************\ * pfnDetermineTriangleFillRoutine * * determine scan line drawing routine for gradient fill * * Arguments: * * pSurfDst - dest surface * *ppal - dest palette * *pnfTriangleFill - return triangle fill routine * *pnfRectangleFill - return gradient fill routine * * Return Value: * * status * * History: * * 2/17/1997 Mark Enstrom [marke] * \**************************************************************************/ BOOL bDetermineTriangleFillRoutine( PSURFACE pSurfDst, XEPALOBJ *ppal, PFN_GRADIENT *pnfTriangleFill, PFN_GRADRECT *pnfRectangleFill ) { switch (pSurfDst->iFormat()) { case BMF_1BPP: *pnfTriangleFill = vGradientFill1; *pnfRectangleFill = vFillGRectDIB1; break; case BMF_4BPP: *pnfTriangleFill = vGradientFill4; *pnfRectangleFill = vFillGRectDIB4; break; case BMF_8BPP: *pnfTriangleFill = vGradientFill8; *pnfRectangleFill = vFillGRectDIB8; break; case BMF_16BPP: { ULONG flR = ppal->flRed(); ULONG flG = ppal->flGre(); ULONG flB = ppal->flBlu(); if ( (flR == 0xf800) && (flG == 0x07e0) && (flB == 0x001f) ) { *pnfTriangleFill = vGradientFill16_565; *pnfRectangleFill = vFillGRectDIB16_565; } else if ( (flR == 0x7c00) && (flG == 0x03e0) && (flB == 0x001f) ) { *pnfTriangleFill = vGradientFill16_555; *pnfRectangleFill = vFillGRectDIB16_555; } else { *pnfTriangleFill = vGradientFill16Bitfields; *pnfRectangleFill = vFillGRectDIB16Bitfields; } } break; case BMF_24BPP: if(ppal->bIsRGB()) { *pnfTriangleFill = vGradientFill24RGB; *pnfRectangleFill = vFillGRectDIB24RGB; } else if(ppal->bIsBGR()) { *pnfTriangleFill = vGradientFill24BGR; *pnfRectangleFill = vFillGRectDIB24BGR; } else { *pnfTriangleFill = vGradientFill24Bitfields; *pnfRectangleFill = vFillGRectDIB24Bitfields; } break; case BMF_32BPP: if (ppal->bIsRGB()) { *pnfTriangleFill = vGradientFill32RGB; *pnfRectangleFill = vFillGRectDIB32RGB; } else if (ppal->bIsBGR()) { *pnfTriangleFill = vGradientFill32BGRA; *pnfRectangleFill = vFillGRectDIB32BGRA; } else { *pnfTriangleFill = vGradientFill32Bitfields; *pnfRectangleFill = vFillGRectDIB32Bitfields; } break; } return(TRUE); } /******************************Public*Routine******************************\ * vHorizontalLine * * Record information for horizontal line. * Colors are recorded as fixed point 8.56 * * Arguments: * * pv1 - vertex 1 * pv2 - vertex 2 * ptData - triangle data * ptridda - dda data * * Return Value: * * none * * History: * * 11/20/1996 Mark Enstrom [marke] * \**************************************************************************/ VOID vHorizontalLine( PTRIVERTEX pv1, PTRIVERTEX pv2, PTRIANGLEDATA ptData, PTRIDDA ptridda ) { LONG yPosition = ptridda->N0; LONG yIndex = yPosition - ptData->y0; // // check if this line is whithin clipping in y // if ( (yPosition >= ptData->rcl.top) && (yPosition < ptData->rcl.bottom) ) { // // find left edge // if (pv1->x <= pv2->x) { // // left edge // ptData->TriEdge[yIndex].xLeft = pv1->x; ptData->TriEdge[yIndex].llRed = ((LONGLONG)pv1->Red) << 48; ptData->TriEdge[yIndex].llGreen = ((LONGLONG)pv1->Green) << 48; ptData->TriEdge[yIndex].llBlue = ((LONGLONG)pv1->Blue) << 48; ptData->TriEdge[yIndex].llAlpha = ((LONGLONG)pv1->Alpha) << 48; // // right edge // ptData->TriEdge[yIndex].xRight = pv2->x; } else { // // left edge // ptData->TriEdge[yIndex].xLeft = pv2->x; ptData->TriEdge[yIndex].llRed = pv2->Red << 48; ptData->TriEdge[yIndex].llGreen = pv2->Green << 48; ptData->TriEdge[yIndex].llBlue = pv2->Blue << 48; ptData->TriEdge[yIndex].llAlpha = pv2->Alpha << 48; // // right edge // ptData->TriEdge[yIndex].xRight = pv1->x; } } } /******************************Public*Routine******************************\ * vEdgeDDA * * Run line DDA down an edge of the triangle recording edge * position and color * * Arguments: * * ptData - triangle data * ptridda - line dda information * * Return Value: * * None * * History: * * 11/20/1996 Mark Enstrom [marke] * \**************************************************************************/ VOID vEdgeDDA( PTRIANGLEDATA ptData, PTRIDDA ptridda ) { LONG NumScanLines = ptridda->NumScanLines; LONG yIndex = ptridda->yIndex; LONGLONG llRed = ptridda->llRed; LONGLONG llGreen = ptridda->llGreen; LONGLONG llBlue = ptridda->llBlue; LONGLONG llAlpha = ptridda->llAlpha; LONG L = ptridda->L; LONG Rb = ptridda->Rb; // // Scan all lines, only record lines contained by // the clipping in ptData->rcl (y) // while (NumScanLines--) { // // check for and record left edge // if (yIndex >= 0) { if (L < ptData->TriEdge[yIndex].xLeft) { ptData->TriEdge[yIndex].xLeft = L; ptData->TriEdge[yIndex].llRed = llRed; ptData->TriEdge[yIndex].llGreen = llGreen; ptData->TriEdge[yIndex].llBlue = llBlue; ptData->TriEdge[yIndex].llAlpha = llAlpha; } if (L > ptData->TriEdge[yIndex].xRight) { ptData->TriEdge[yIndex].xRight = L; } } // // inc y by one scan line, inc x(L) by integer step // and inc error term by dR // yIndex++; L += ptridda->dL; Rb -= ptridda->dR; // // inc color components by y and integer x components // llRed += (ptridda->lldxyRed); llGreen += (ptridda->lldxyGreen); llBlue += (ptridda->lldxyBlue); llAlpha += (ptridda->lldxyAlpha); // // check for DDA error term overflow, add one // more step in x and color if true, // and correct error term // if (Rb < 0) { // // fraction step in x // L += ptridda->Linc; // // fraction step in color components // llRed += ptData->lldRdX; llGreen += ptData->lldGdX; llBlue += ptData->lldBdX; llAlpha += ptData->lldAdX; // // adjust error term // Rb += ptridda->dN; } } } /******************************Public*Routine******************************\ * vCalulateLine * * calculate bounding line * * Arguments: * * pv1 - vertex 1 * pv2 - vertex 2 * ptData - triangle data * * Return Value: * * none * * History: * * 11/20/1996 Mark Enstrom [marke] * \**************************************************************************/ VOID vCalculateLine( PTRIVERTEX pv1, PTRIVERTEX pv2, PTRIANGLEDATA ptData ) { TRIDDA tridda; // // initial y component // tridda.lldxyRed = ptData->lldRdY; tridda.lldxyGreen = ptData->lldGdY; tridda.lldxyBlue = ptData->lldBdY; tridda.lldxyAlpha = ptData->lldAdY; // // N0 = integer y starting location // M0 = integer x starting location // dN = integer delta y // dM = integer delta x // // Arrange lines, must run DDA in positive delta y. // if (pv2->y >= pv1->y) { tridda.dN = pv2->y - pv1->y; tridda.dM = pv2->x - pv1->x; tridda.N0 = pv1->y; tridda.M0 = pv1->x; } else { tridda.dN = pv1->y - pv2->y; tridda.dM = pv1->x - pv2->x; tridda.N0 = pv2->y; tridda.M0 = pv2->x; } // // caclulate initial color value at stating vertex // tridda.llRed = ptData->lldRdY * (tridda.N0 - ptData->ptColorCalcOrg.y) + ptData->lldRdX * (tridda.M0 - ptData->ptColorCalcOrg.x) + ptData->llRA; tridda.llGreen = ptData->lldGdY * (tridda.N0 - ptData->ptColorCalcOrg.y) + ptData->lldGdX * (tridda.M0 - ptData->ptColorCalcOrg.x) + ptData->llGA; tridda.llBlue = ptData->lldBdY * (tridda.N0 - ptData->ptColorCalcOrg.y) + ptData->lldBdX * (tridda.M0 - ptData->ptColorCalcOrg.x) + ptData->llBA; tridda.llAlpha = ptData->lldAdY * (tridda.N0 - ptData->ptColorCalcOrg.y) + ptData->lldAdX * (tridda.M0 - ptData->ptColorCalcOrg.x) + ptData->llAA; // // Check for horizontal line, dN == 0 is a horizontal line. // In this case just record the end points. // if (tridda.dN == 0) { vHorizontalLine(pv1,pv2,ptData,&tridda); } else { LONGLONG l0,Frac; tridda.Linc = 1; // // yIndex is the offset into the edge array for // the current line. Calc number of scan lines // and maximum y position // tridda.yIndex = tridda.N0 - ptData->y0; tridda.NumScanLines = tridda.dN; LONG NMax = tridda.N0 + tridda.NumScanLines; // // make sure scan lines do not overrun buffer due to // clipping // if ( (tridda.N0 > ptData->rcl.bottom) || (NMax < ptData->rcl.top) ) { // // nothing to draw // return; } else if (NMax > ptData->rcl.bottom) { tridda.NumScanLines = tridda.NumScanLines - (NMax - ptData->rcl.bottom); } tridda.j = tridda.N0; tridda.C = ((LONGLONG)tridda.M0 * (LONGLONG)tridda.dN) - ((LONGLONG)tridda.N0 * (LONGLONG)tridda.dM) -1; tridda.C = tridda.C + tridda.dN; LONGLONG LongL; if (tridda.dM > 0) { tridda.dL = tridda.dM / tridda.dN; tridda.dR = tridda.dM - tridda.dL * tridda.dN; } else if (tridda.dM < 0) { // // negative divide // LONG dLQ,dLR; tridda.dM = -tridda.dM; dLQ = (tridda.dM - 1) / tridda.dN; dLR = tridda.dM - 1 - (dLQ * tridda.dN); tridda.dL = -(dLQ + 1); tridda.dR = tridda.dN - dLR - 1; } else { // // dM = 0 // tridda.dL = 0; tridda.dR = 0; } l0 = tridda.j * tridda.dL; LongL = tridda.j * tridda.dR + tridda.C; if (LongL > 0) { Frac = (LONG)(LongL/tridda.dN); } else if (LongL < 0) { LONGLONG Q = ((-LongL - 1)/tridda.dN); Frac = -(Q + 1); } else { Frac = 0; } tridda.R = (LONG)(LongL - (Frac * tridda.dN)); tridda.L = (LONG)(l0 + Frac); tridda.Rb = tridda.dN - tridda.R - 1; // // Calculate color steps for dx // tridda.lldxyRed = tridda.lldxyRed + (ptData->lldRdX * tridda.dL); tridda.lldxyGreen = tridda.lldxyGreen + (ptData->lldGdX * tridda.dL); tridda.lldxyBlue = tridda.lldxyBlue + (ptData->lldBdX * tridda.dL); tridda.lldxyAlpha = tridda.lldxyAlpha + (ptData->lldAdX * tridda.dL); // // run edge dda // vEdgeDDA(ptData,&tridda); } } /**************************************************************************\ * bCalulateColorGradient * * Calculate all color gradients * * Arguments: * * pv0,pv1,pv2 - triangle verticies * ptData - triangel data * * Return Value: * * status * * History: * * 5/22/1997 Kirk Olnyk [kirko] * \**************************************************************************/ BOOL bCalulateColorGradient( PTRIVERTEX pv0, PTRIVERTEX pv1, PTRIVERTEX pv2, PTRIANGLEDATA ptData ) { GRADSTRUCT g; LONGLONG d; LONG z; g.x1 = pv1->x; g.y1 = pv1->y; g.x2 = pv2->x; g.y2 = pv2->y; z = pv0->x; g.x1 -= z; g.x2 -= z; z = pv0->y; g.y1 -= z; g.y2 -= z; g.d = g.x1 * g.y2 - g.x2 * g.y1; LONG tx = MIN(g.x1,0); LONG ty = MIN(g.y1,0); g.m = MIN(tx,g.x2) + MIN(ty,g.y2); d = (LONGLONG) ABS(g.d); g.Q = (LONGLONG)TWO_TO_THE_48TH / d; g.R = (LONGLONG)TWO_TO_THE_48TH % d; ptData->ptColorCalcOrg.x = pv0->x; ptData->ptColorCalcOrg.y = pv0->y; bDoGradient( &ptData->lldRdX // &A , &ptData->lldRdY // &B , &ptData->llRA // &C , pv0->Red // R0 , pv1->Red // R1 , pv2->Red // R2 , &g ); bDoGradient( &ptData->lldGdX , &ptData->lldGdY , &ptData->llGA , pv0->Green , pv1->Green , pv2->Green , &g ); bDoGradient( &ptData->lldBdX , &ptData->lldBdY , &ptData->llBA , pv0->Blue , pv1->Blue , pv2->Blue , &g ); bDoGradient( &ptData->lldAdX , &ptData->lldAdY , &ptData->llAA , pv0->Alpha , pv1->Alpha , pv2->Alpha , &g ); return(TRUE); } /**************************************************************************\ * MDiv64 * 64 bit mul-div * * Arguments: * * return = (a * b) / c * * Return Value: * * * * History: * * 5/22/1997 Kirk Olnyk [kirko] * \**************************************************************************/ LONGLONG MDiv64( LONGLONG a, LONGLONG b, LONGLONG c) { LONGLONG Result; int isNegative=0; Result = 0; if (a != 0 && b != 0) { if (a < 0) { a = -a; isNegative = 1; } else if (b < 0) { b = -b; isNegative = 1; } a = a * b - (LONGLONG) isNegative; Result = a / c; if (isNegative) { Result = - Result - 1; } } return(Result); } /**************************************************************************\ * bDoGradient * * calc color gradient for one color * * Arguments: * * pA * pB * pC * g0 * g1 * g2 * pg * * Return Value: * * status * * History: * * 5/22/1997 Kirk Olnyk [kirko] * \**************************************************************************/ BOOL bDoGradient( LONGLONG *pA, LONGLONG *pB, LONGLONG *pC, LONG g0, LONG g1, LONG g2, GRADSTRUCT *pg ) { BOOL bDiv(LONGLONG*, LONGLONG, LONG); LONGLONG a,b,c,d; g1 = g1 - g0; g2 = g2 - g0; a = g1 * pg->y2 - g2 * pg->y1; b = g2 * pg->x1 - g1 * pg->x2; d = pg->d; if (d < 0) { a = -a; b = -b; d = -d; } *pA = pg->Q * a + MDiv64(a, pg->R, d); *pB = pg->Q * b + MDiv64(b, pg->R, d); c = (d >> 1) + 1; a = c * pg->R - pg->m - 1; a /= d; a += c * pg->Q; a += pg->m; *pC = a + (((LONGLONG) g0) << 48); return(TRUE); } /**************************************************************************\ * lCalculateTriangleArea * * Arguments: * * pv0 - vertex * pv1 - vertex * pv2 - vertex * ptData - triangle data * * Return Value: * * < 0 = negative area * 0 = 0 area * > 0 = positive area * * History: * * 2/26/1997 Mark Enstrom [marke] * \**************************************************************************/ LONG lCalculateTriangleArea( PTRIVERTEX pv0, PTRIVERTEX pv1, PTRIVERTEX pv2, PTRIANGLEDATA ptData ) { LONG lRet; // // calc area, color gradients in x,y // // area = (v2-v0) X (v1 - v2) // LONGLONG v12x = pv1->x - pv2->x; LONGLONG v12y = pv1->y - pv2->y; LONGLONG v02x = pv0->x - pv2->x; LONGLONG v02y = pv0->y - pv2->y; LONGLONG Area = (v12y * v02x) - (v12x * v02y); if (Area == 0) { lRet = 0; } else if (Area > 0) { lRet = 1; if (ptData != NULL) { ptData->Area = Area; } } else { lRet = -1; } return(lRet); } /**************************************************************************\ * LIMIT_COLOR * * Actual input colors are limited to 0x0000 - 0xff00 * 256 * (0x00 - 0xff) * * Arguments: * * pv - vertex * * History: * * 2/26/1997 Mark Enstrom [marke] * \**************************************************************************/ #define LIMIT_COLOR(pv) \ \ if (pv->Red > 0xff00) \ { \ pv->Red = 0xff00; \ } \ \ if (pv->Green > 0xff00) \ { \ pv->Green = 0xff00; \ } \ \ if (pv->Blue > 0xff00) \ { \ pv->Blue = 0xff00; \ } /******************************Public*Routine******************************\ * bCalculateTriangle * * if triangle is too largre, break it in into 2 triangles and call this * routine on each (max recursion ~= 16) * * Calculate color gradients, then scan the three lines that make up the * triangle. Fill out a structure that can later be used to fill in the * interior of the triangle. * * Arguments: * * pSurfDst - destination surface * pInV0 - vertex * pInV1 - vertex * pInV2 - vertex * ptData - triangle data * pfnG - surface gradient draw routine * * Return Value: * * status * * History: * * 17-Jul-1996 -by- Mark Enstrom [marke] * \**************************************************************************/ BOOL bCalculateAndDrawTriangle( PSURFACE pSurfDst, PTRIVERTEX pInV0, PTRIVERTEX pInV1, PTRIVERTEX pInV2, PTRIANGLEDATA ptData, PFN_GRADIENT pfnG ) { BOOL bStatus = TRUE; LONG index; LONG lStatus; PTRIVERTEX pv0 = pInV0; PTRIVERTEX pv1 = pInV1; PTRIVERTEX pv2 = pInV2; { PTRIVERTEX pvt; // // sort in y for line processing // if (pv0->y > pv1->y) { SWAP_VERTEX(pv0,pv1,pvt); } if (pv1->y > pv2->y) { SWAP_VERTEX(pv1,pv2,pvt); } if (pv0->y > pv1->y) { SWAP_VERTEX(pv0,pv1,pvt); } lStatus = lCalculateTriangleArea(pv0,pv1,pv2,ptData); // // if area is zero then this is a degenerate triangle // if (lStatus == 0) { return(FALSE); } else if (lStatus <0) { // // negative area, swap pv1 and pv2 and recalcualte // SWAP_VERTEX(pv1,pv2,pvt); lStatus = lCalculateTriangleArea(pv0,pv1,pv2,ptData); if (lStatus == 0) { return(FALSE); } else if (lStatus <0) { WARNING1("Triangle Area still negative after vertex swap\n"); return(FALSE); } } // // calc min and max drawing y // ptData->y0 = MAX(pv0->y,ptData->rcl.top); LONG MaxY = MAX(pv1->y,pv2->y); ptData->y1 = MIN(MaxY,ptData->rcl.bottom); { // // init ptdata // LONG lIndex; for (lIndex=0;lIndex<(ptData->y1-ptData->y0);lIndex++) { ptData->TriEdge[lIndex].xLeft = LONG_MAX; ptData->TriEdge[lIndex].xRight = LONG_MIN; } } // // calculate color gradients for each color. There is a little redundant // work here with calculation of deltas. Should make this one call or // do it in place. // LIMIT_COLOR(pv0); LIMIT_COLOR(pv1); LIMIT_COLOR(pv2); bCalulateColorGradient(pv0,pv1,pv2,ptData); // // draw lines into data array // vCalculateLine(pv0,pv1,ptData); vCalculateLine(pv1,pv2,ptData); vCalculateLine(pv2,pv0,ptData); pfnG(pSurfDst,ptData); } return(bStatus); } /**************************************************************************\ * bIsTriangleInBounds * * Is triangle inside bounding rect * * Arguments: * * pInV0 - vertex 0 * pInV1 - vertex 1 * pInV2 - vertex 2 * ptData - triangle data * * Return Value: * * TRUE in any of the triangle is contained in bounding rect * * History: * * 5/8/1997 Mark Enstrom [marke] * \**************************************************************************/ BOOL bIsTriangleInBounds( PTRIVERTEX pInV0, PTRIVERTEX pInV1, PTRIVERTEX pInV2, PTRIANGLEDATA ptData ) { PRECTL prclClip = &ptData->rcl; RECTL rclTri; rclTri.left = MIN(pInV0->x,pInV1->x); rclTri.right = MAX(pInV0->x,pInV1->x); rclTri.top = MIN(pInV0->y,pInV1->y); rclTri.bottom = MAX(pInV0->y,pInV1->y); rclTri.left = MIN(rclTri.left,pInV2->x); rclTri.right = MAX(rclTri.right,pInV2->x); rclTri.top = MIN(rclTri.top,pInV2->y); rclTri.bottom = MAX(rclTri.bottom,pInV2->y); if ((rclTri.left >= prclClip->right) || (rclTri.right <= prclClip->left) || (rclTri.top >= prclClip->bottom) || (rclTri.bottom <= prclClip->top)) { return(FALSE); } return(TRUE); } /**************************************************************************\ * bTriangleNeedSplit * determine whether triangle needs split * * Arguments: * * pv0,pv1,pv2 - triangle vertex * * Return Value: * * TRUE if triangle needs to be split * * History: * * 5/8/1997 Mark Enstrom [marke] * \**************************************************************************/ BOOL bTriangleNeedsSplit( PTRIVERTEX pv0, PTRIVERTEX pv1, PTRIVERTEX pv2 ) { // // calc dx,dy for each leg // LONG dx01 = ABS(pv0->x - pv1->x); LONG dy01 = ABS(pv0->y - pv1->y); LONG dx02 = ABS(pv0->x - pv2->x); LONG dy02 = ABS(pv0->y - pv2->y); LONG dx12 = ABS(pv1->x - pv2->x); LONG dy12 = ABS(pv1->y - pv2->y); // // if any length is longer than max, break triangle into two pieces // and call this routine for each // if ( ( (dx01 > MAX_EDGE_LENGTH) || (dy01 > MAX_EDGE_LENGTH) || (dx02 > MAX_EDGE_LENGTH) || (dy02 > MAX_EDGE_LENGTH) || (dx12 > MAX_EDGE_LENGTH) || (dy12 > MAX_EDGE_LENGTH) ) ) { return(TRUE); } return(FALSE); } /**************************************************************************\ * bSplitTriangle * Determine is triangle must be split. * Split triangle along longest edge * * Arguments: * * pv0,pv1,pv2 - triangle * pvNew - new vertex * pGrad - mesh * * Return Value: * * TRUE if split, FALSE otherwise * * History: * * 5/8/1997 Mark Enstrom [marke] * \**************************************************************************/ BOOL bSplitTriangle( PTRIVERTEX pVert, PULONG pFreeVert, PGRADIENT_TRIANGLE pMesh, PULONG pFreeMesh, PULONG pRecurseLevel ) { BOOL bStatus = FALSE; ULONG CurrentMesh = (*pFreeMesh) - 1; ULONG ulTM0 = pMesh[CurrentMesh].Vertex1; ULONG ulTM1 = pMesh[CurrentMesh].Vertex2; ULONG ulTM2 = pMesh[CurrentMesh].Vertex3; PTRIVERTEX pv0 = &pVert[ulTM0]; PTRIVERTEX pv1 = &pVert[ulTM1]; PTRIVERTEX pv2 = &pVert[ulTM2]; PTRIVERTEX pvT0 = pv0; PTRIVERTEX pvT1 = pv1; PTRIVERTEX pvT2 = pv2; TRIVERTEX triNew; // // find longest edge // LONGLONG dx01 = ABS(pv0->x - pv1->x); LONGLONG dy01 = ABS(pv0->y - pv1->y); LONGLONG dx02 = ABS(pv0->x - pv2->x); LONGLONG dy02 = ABS(pv0->y - pv2->y); LONGLONG dx12 = ABS(pv1->x - pv2->x); LONGLONG dy12 = ABS(pv1->y - pv2->y); // // determine if triangle needs to be split // if ( ( (dx01 > MAX_EDGE_LENGTH) || (dy01 > MAX_EDGE_LENGTH) || (dx02 > MAX_EDGE_LENGTH) || (dy02 > MAX_EDGE_LENGTH) || (dx12 > MAX_EDGE_LENGTH) || (dy12 > MAX_EDGE_LENGTH) ) ) { // // make sure this is a triangle // if (lCalculateTriangleArea(pv0,pv1,pv2,NULL) != 0) { // // Find longest edge, swap verticies so edge 0-1 is // longest. // LONGLONG d01Max = dx01 * dx01 + dy01 * dy01; LONGLONG d02Max = dx02 * dx02 + dy02 * dy02; LONGLONG d12Max = dx12 * dx12 + dy12 * dy12; if (d01Max > d02Max) { if (d01Max > d12Max) { // // d01 largest, default // } else { // // d12 largest, swap 0 and 2 // pvT0 = pv2; pvT2 = pv0; ulTM0 = pMesh[CurrentMesh].Vertex3; ulTM2 = pMesh[CurrentMesh].Vertex1; } } else { if (d02Max > d12Max) { // // d02 largest, swap 1,2 // pvT1 = pv2; pvT2 = pv1; ulTM1 = pMesh[CurrentMesh].Vertex3; ulTM2 = pMesh[CurrentMesh].Vertex2; } else { // // d12 largest, swap 0,2 // pvT0 = pv2; pvT2 = pv0; ulTM0 = pMesh[CurrentMesh].Vertex3; ulTM2 = pMesh[CurrentMesh].Vertex1; } } // // 2 new triangles 0,2,N and 1,2,N (float) // { EFLOAT fpA,fpB; EFLOAT fTwo; LONG lTemp; fTwo = (LONG)2; fpA = pvT0->x; fpB = pvT1->x; fpB-=(fpA); fpB/=(fTwo); fpA+=(fpB); fpA.bEfToL(triNew.x); fpA = pvT0->y; fpB = pvT1->y; fpB-=(fpA); fpB/=(fTwo); fpA+=(fpB); fpA.bEfToL(triNew.y); fpA = (LONG)pvT0->Red; fpB = (LONG)pvT1->Red; fpB-=(fpA); fpB/=(fTwo); fpA+=(fpB); fpA.bEfToL(lTemp); triNew.Red = (USHORT)lTemp; fpA = (LONG)pvT0->Green; fpB = (LONG)pvT1->Green; fpB-=(fpA); fpB/=(fTwo); fpA+=(fpB); fpA.bEfToL(lTemp); triNew.Green = (USHORT)lTemp; fpA = (LONG)pvT0->Blue; fpB = (LONG)pvT1->Blue; fpB-=(fpA); fpB/=(fTwo); fpA+=(fpB); fpA.bEfToL(lTemp); triNew.Blue = (USHORT)lTemp; fpA = (LONG)pvT0->Alpha; fpB = (LONG)pvT1->Alpha; fpB-=(fpA); fpB/=(fTwo); fpA+=(fpB); fpA.bEfToL(lTemp); triNew.Alpha = (USHORT)lTemp; } // // add new entry to vertex array and two new entries to mesh array // // 0,2,New and 1,2,New // ULONG FreeVert = *pFreeVert; ULONG FreeMesh = *pFreeMesh; pVert[FreeVert] = triNew; pMesh[FreeMesh].Vertex1 = ulTM0; pMesh[FreeMesh].Vertex2 = ulTM2; pMesh[FreeMesh].Vertex3 = FreeVert; pMesh[FreeMesh+1].Vertex1 = ulTM1; pMesh[FreeMesh+1].Vertex2 = ulTM2; pMesh[FreeMesh+1].Vertex3 = FreeVert; pRecurseLevel[FreeMesh] = 1; pRecurseLevel[FreeMesh+1] = 0; *pFreeMesh += 2; *pFreeVert += 1; bStatus = TRUE; } else { WARNING("bSplitTriangle:Error: triangle area = 0\n\n"); } } return(bStatus); } /**************************************************************************\ * bTriangleMesh * * Draw each triangle. If triangle is too big, then split. * * Arguments: * * pSurfDst - destination surface * pxlo - xlate * pVertex - pointer to vertex array * nVertex - elements in vertex array * pMesh - pointer to mesh array * nMesh - elements in mesh array * ulMode - draw mode * prclClip - clip rect * prclMeshExtents - triangle extents rect * pptlDitherOrg - dither org * * Return Value: * * Status * * History: * * 5/22/1997 Mark Enstrom [marke] * \**************************************************************************/ BOOL bTriangleMesh( PSURFACE pSurfDst, XLATEOBJ *pxlo, PTRIVERTEX pVertex, ULONG nVertex, PGRADIENT_TRIANGLE pMesh, ULONG nMesh, ULONG ulMode, PRECTL prclClip, PRECTL prclMeshExtents, PPOINTL pptlDitherOrg ) { PFN_GRADIENT pfnG; PFN_GRADRECT pfnTemp; BOOL bStatus = TRUE; LONG dyTri = prclClip->bottom - prclClip->top; PTRIANGLEDATA ptData; // // allocate structure to hold scan line data for all triangles // drawn during this call // ptData = (PTRIANGLEDATA)PALLOCMEM(sizeof(TRIANGLEDATA) + (dyTri-1) * sizeof(TRIEDGE),'gdEg'); if (ptData) { // // find a palette for the output surface // XEPALOBJ epal(pSurfDst->ppal()); if (!epal.bValid()) { PDEVOBJ pdo(pSurfDst->hdev()); epal.ppalSet(pdo.ppalSurf()); } if (epal.bValid()) { // // find out scan line routine to use to draw pixels // bDetermineTriangleFillRoutine(pSurfDst,&epal,&pfnG,&pfnTemp); // // Init global data // ptData->rcl = *prclClip; ptData->DrawMode = ulMode; ptData->pxlo = pxlo; ptData->ppalDstSurf = &epal; ptData->ptDitherOrg = *pptlDitherOrg; // // if triangle does not need to be split, draw each one. // Triangles need to be split if any edge exceeds a length // that will cause math problems. // if ( ((prclMeshExtents->right - prclMeshExtents->left) < MAX_EDGE_LENGTH) && ((prclMeshExtents->bottom - prclMeshExtents->top) < MAX_EDGE_LENGTH) ) { // // no split needed // ULONG ulIndex; for (ulIndex = 0;ulIndex 0, "bTriangleMesh: bad nMesh\n"); ULONG FreeVertex = nVertex; ULONG FreeMesh = nMesh; do { BOOL bSplit = FALSE; // // always operate on the last triangle in array // ULONG CurrentMesh = FreeMesh - 1; // // validate mesh pointers // if ( (pTempMesh[CurrentMesh].Vertex1 >= ulMaxVertex) || (pTempMesh[CurrentMesh].Vertex2 >= ulMaxVertex) || (pTempMesh[CurrentMesh].Vertex3 >= ulMaxVertex) ) { RIP("Error in triangle split routine:Vertex out of range\n"); break; } PTRIVERTEX pv0 = &pTempVertex[pTempMesh[CurrentMesh].Vertex1]; PTRIVERTEX pv1 = &pTempVertex[pTempMesh[CurrentMesh].Vertex2]; PTRIVERTEX pv2 = &pTempVertex[pTempMesh[CurrentMesh].Vertex3]; // // check if triangle boundary is inside clip rect // if (bIsTriangleInBounds(pv0,pv1,pv2,ptData)) { bSplit = bSplitTriangle(pTempVertex,&FreeVertex,pTempMesh,&FreeMesh,pRecurse); if (!bSplit) { // // draw triangle // bStatus = bCalculateAndDrawTriangle(pSurfDst,pv0,pv1,pv2,ptData,pfnG); } else { // // validate array indcies // if ((FreeVertex > ulMaxVertex) || (FreeMesh > ulMaxMesh)) { RIP("Error in triangle split routine: indicies out of range\n"); break; } } } // // if triangle was not split, then remove from list. // if (!bSplit) { // // remove triangle just drawn. If this is the second triangle of a // split, then remove the added vertex and the original triangle as // well // do { FreeMesh--; if (pRecurse[FreeMesh]) { FreeVertex--; } } while ((FreeMesh != 0) && (pRecurse[FreeMesh] == 1)); } } while (FreeMesh != 0); VFREEMEM(pAlloc); } else { WARNING1("Memory allocation failed for temp triangle buffers\n"); bStatus = FALSE; } } } else { RIP("EngGradientFill:Error reading palette from surface\n"); bStatus = FALSE; } // // free triangle data buffer // VFREEMEM(ptData); } else { bStatus = FALSE; } return(bStatus); } /**************************************************************************\ * vCalcRectOffsets * * calc params for gradient rect * * Arguments: * * pGradRect - gradietn rect data * * Return Value: * * status * * History: * * 2/14/1997 Mark Enstrom [marke] * \**************************************************************************/ BOOL bCalcGradientRectOffsets( PGRADIENTRECTDATA pGradRect ) { LONG yScanTop = MAX(pGradRect->rclClip.top,pGradRect->rclGradient.top); LONG yScanBottom = MIN(pGradRect->rclClip.bottom,pGradRect->rclGradient.bottom); LONG yScanLeft = MAX(pGradRect->rclClip.left,pGradRect->rclGradient.left); LONG yScanRight = MIN(pGradRect->rclClip.right,pGradRect->rclGradient.right); // // calc actual widht, check for early out // pGradRect->ptDraw.x = yScanLeft; pGradRect->ptDraw.y = yScanTop; pGradRect->szDraw.cx = yScanRight - yScanLeft; pGradRect->szDraw.cy = yScanBottom - yScanTop; LONG ltemp = pGradRect->rclClip.left - pGradRect->rclGradient.left; if (ltemp <= 0) { ltemp = 0; } pGradRect->xScanAdjust = ltemp; ltemp = pGradRect->rclClip.top - pGradRect->rclGradient.top; if (ltemp <= 0) { ltemp = 0; } pGradRect->yScanAdjust = ltemp; return((pGradRect->szDraw.cx > 0) && (pGradRect->szDraw.cy > 0)); } /**************************************************************************\ * bRectangleMesh * * Draw rectangle mesh * * Arguments: * * pSurfDst - destination surface * pxlo - clip obj * pVertex - vertex list * nVertex - # in vertex list * pMesh - mesh list * nMesh - # in mesh list * ulMode - draw mode and attributes * prclClip - bounding rect * pptlDitherOrg - dither org * * Return Value: * * status * * History: * * 2/17/1997 Mark Enstrom [marke] * \**************************************************************************/ BOOL bRectangleMesh( PSURFACE pSurfDst, XLATEOBJ *pxlo, PTRIVERTEX pVertex, ULONG nVertex, PGRADIENT_RECT pMesh, ULONG nMesh, ULONG ulMode, PRECTL prclClip, PPOINTL pptlDitherOrg ) { PFN_GRADIENT pfnTemp; PFN_GRADRECT pfnG; BOOL bStatus = TRUE; LONG dyTri = prclClip->bottom - prclClip->top; GRADIENTRECTDATA grData; XEPALOBJ epal(pSurfDst->ppal()); if (!epal.bValid()) { PDEVOBJ pdo(pSurfDst->hdev()); epal.ppalSet(pdo.ppalSurf()); } if (epal.bValid()) { // // find out scan line routine to use to draw pixels // bDetermineTriangleFillRoutine(pSurfDst,&epal,&pfnTemp,&pfnG); grData.pxlo = pxlo; grData.ppalDstSurf = &epal; grData.ptDitherOrg = *pptlDitherOrg; // // draw each rectangle // grData.rclClip = *prclClip; ULONG ulIndex; for (ulIndex=0;ulIndex (nVertex-1)) || (ulRect1 > (nVertex-1)) ) { bStatus = FALSE; break; } TRIVERTEX tvert0 = pVertex[ulRect0]; TRIVERTEX tvert1 = pVertex[ulRect1]; PTRIVERTEX pv0 = &tvert0; PTRIVERTEX pv1 = &tvert1; PTRIVERTEX pvt; // // make sure rectangle endpoints are properly ordered // if (ulMode == GRADIENT_FILL_RECT_H) { if (pv0->x > pv1->x) { SWAP_VERTEX(pv0,pv1,pvt); } if (pv0->y > pv1->y) { // // must swap y // LONG ltemp = pv1->y; pv1->y = pv0->y; pv0->y = ltemp; } } else { if (pv0->y > pv1->y) { SWAP_VERTEX(pv0,pv1,pvt); } if (pv0->x > pv1->x) { // // must swap x // LONG ltemp = pv1->x; pv1->x = pv0->x; pv0->x = ltemp; } } // // gradient definition rectangle // grData.rclGradient.left = pv0->x; grData.rclGradient.top = pv0->y; grData.rclGradient.right = pv1->x; grData.rclGradient.bottom = pv1->y; grData.ulMode = ulMode; LONG dxGrad = grData.rclGradient.right - grData.rclGradient.left; LONG dyGrad = grData.rclGradient.bottom - grData.rclGradient.top; // // make sure rect not empty // if ((dxGrad > 0) && (dyGrad > 0)) { // // calculate color gradients for x and y // grData.llRed = ((LONGLONG)pv0->Red) << 40; grData.llGreen = ((LONGLONG)pv0->Green) << 40; grData.llBlue = ((LONGLONG)pv0->Blue) << 40; grData.llAlpha = ((LONGLONG)pv0->Alpha) << 40; if (ulMode == GRADIENT_FILL_RECT_H) { grData.lldRdY = 0; grData.lldGdY = 0; grData.lldBdY = 0; grData.lldAdY = 0; LONGLONG lldRed = (LONGLONG)(pv1->Red) << 40; LONGLONG lldGreen = (LONGLONG)(pv1->Green) << 40; LONGLONG lldBlue = (LONGLONG)(pv1->Blue) << 40; LONGLONG lldAlpha = (LONGLONG)(pv1->Alpha) << 40; lldRed -= (LONGLONG)(pv0->Red) << 40; lldGreen -= (LONGLONG)(pv0->Green) << 40; lldBlue -= (LONGLONG)(pv0->Blue) << 40; lldAlpha -= (LONGLONG)(pv0->Alpha) << 40; grData.lldRdX = MDiv64(lldRed ,(LONGLONG)1,(LONGLONG)dxGrad); grData.lldGdX = MDiv64(lldGreen,(LONGLONG)1,(LONGLONG)dxGrad); grData.lldBdX = MDiv64(lldBlue ,(LONGLONG)1,(LONGLONG)dxGrad); grData.lldAdX = MDiv64(lldAlpha,(LONGLONG)1,(LONGLONG)dxGrad); } else { grData.lldRdX = 0; grData.lldGdX = 0; grData.lldBdX = 0; grData.lldAdX = 0; LONGLONG lldRed = (LONGLONG)(pv1->Red) << 40; LONGLONG lldGreen = (LONGLONG)(pv1->Green) << 40; LONGLONG lldBlue = (LONGLONG)(pv1->Blue) << 40; LONGLONG lldAlpha = (LONGLONG)(pv1->Alpha) << 40; lldRed -= (LONGLONG)(pv0->Red) << 40; lldGreen -= (LONGLONG)(pv0->Green) << 40; lldBlue -= (LONGLONG)(pv0->Blue) << 40; lldAlpha -= (LONGLONG)(pv0->Alpha) << 40; grData.lldRdY = MDiv64(lldRed ,(LONGLONG)1,(LONGLONG)dyGrad); grData.lldGdY = MDiv64(lldGreen,(LONGLONG)1,(LONGLONG)dyGrad); grData.lldBdY = MDiv64(lldBlue ,(LONGLONG)1,(LONGLONG)dyGrad); grData.lldAdY = MDiv64(lldAlpha,(LONGLONG)1,(LONGLONG)dyGrad); } // // calculate common offsets // if (bCalcGradientRectOffsets(&grData)) { // // call specific drawing routine if output // not totally clipped // (*pfnG)(pSurfDst,&grData); } } } } else { WARNING("bRectangleMesh: can't get surface palette\n"); } return(bStatus); } /******************************Public*Routine******************************\ * EngGradientFill * * Draw gradient fill to memory surface. If complex clipping is used, then * draw to a temp dib and blt to destination through clip. * * Arguments: * * psoDst - destination surface * pco - clip obj * pVertex - vertex list * nVertex - # in vertex list * pMesh - mesh list * nMesh - # in mesh list * ulMode - draw mode and attributes * * Return Value: * * Status * * History: * * 11/20/1996 Mark Enstrom [marke] * \**************************************************************************/ BOOL APIENTRY EngGradientFill( SURFOBJ *psoDst, CLIPOBJ *pco, XLATEOBJ *pxlo, TRIVERTEX *pVertex, ULONG nVertex, PVOID pMesh, ULONG nMesh, RECTL *prclExtents, POINTL *ptlDitherOrg, ULONG ulMode ) { ASSERTGDI(psoDst != NULL, "ERROR EngGradientFill: No destination surface\n"); BOOL bStatus = TRUE; PSURFACE pSurfDst = SURFOBJ_TO_SURFACE(psoDst); PSURFACE pSurfDstTmp = NULL; ULONG ulTri; BOOL bForceDstAlloc = FALSE; BOOL bAllocDstSurf = FALSE; RECTL rclDstTrim; RECTL rclDstWk; CLIPOBJ *pcoDstWk = pco; SURFMEM surfTmpDst; ULONG ulIndex; PDEVOBJ pdo(pSurfDst->hdev()); BOOL bCopyFromDst = TRUE; ASSERTGDI(pdo.bValid(), "Invalid HDEV"); ASSERTGDI((ulMode == GRADIENT_FILL_TRIANGLE) || (ulMode == GRADIENT_FILL_RECT_H) || (ulMode == GRADIENT_FILL_RECT_V), "Invalid gradient mode"); // // sync with driver // { pdo.vSync(psoDst,NULL,0); } // // trim rclDst to clip bounding box // rclDstTrim = *prclExtents; // // clip extents to destination clip rect // if ((pco != NULL) && (pco->iDComplexity > DC_TRIVIAL)) { if (rclDstTrim.left < pco->rclBounds.left) { rclDstTrim.left = pco->rclBounds.left; } if (rclDstTrim.right > pco->rclBounds.right) { rclDstTrim.right = pco->rclBounds.right; } if (rclDstTrim.top < pco->rclBounds.top) { rclDstTrim.top = pco->rclBounds.top; } if (rclDstTrim.bottom > pco->rclBounds.bottom) { rclDstTrim.bottom = pco->rclBounds.bottom; } } // // rclDstWk specifies size of temp surface needed (if temp surface is created) // coordinates in this temp surface are referenced to prclExtents, even though the // surface may be clipped to a smaller extent // rclDstWk = rclDstTrim; // // Force Complex clipping to go through temp surface // if ((pco != NULL) && (pco->iDComplexity != DC_TRIVIAL) && (pco->iDComplexity != DC_RECT)) { bForceDstAlloc = TRUE; } // // get a dst surface that can be written to, remember since it will have to // be written back. // // // If the gradient fill shape is a rectangle, we don't need // to copy bits from the destination since they'll all // be overwritten // if ((ulMode == GRADIENT_FILL_RECT_H) || (ulMode == GRADIENT_FILL_RECT_V)) { bCopyFromDst = FALSE; } pSurfDstTmp = psSetupDstSurface( pSurfDst, &rclDstWk, surfTmpDst, bForceDstAlloc, bCopyFromDst); if (pSurfDstTmp != NULL) { if (pSurfDstTmp != pSurfDst) { bAllocDstSurf = TRUE; } if (bAllocDstSurf) { // // drawing lies completely in temp rectangle, src surface is read // into tmp DIB before drawing, so no clipping is needed when this // is copied to destination surface // pcoDstWk = NULL; // // subtract rect origin // for (ulIndex=0;ulIndexx += rclDstTrim.left; ptlDitherOrg->y += rclDstTrim.top; } // // limit recorded triangle to clipped output // ERECTL *prclClip; LONG dyTri = rclDstWk.bottom - rclDstWk.top; if ((pcoDstWk == NULL) || (pcoDstWk->iDComplexity == DC_TRIVIAL)) { prclClip = NULL; } else { prclClip = (ERECTL *)&pcoDstWk->rclBounds; } // // draw gradients // if (ulMode == GRADIENT_FILL_TRIANGLE) { bStatus = bTriangleMesh(pSurfDstTmp, pxlo, pVertex, nVertex, (PGRADIENT_TRIANGLE)pMesh, nMesh, ulMode, &rclDstWk, prclExtents, ptlDitherOrg ); } else { ASSERTGDI((ulMode == GRADIENT_FILL_RECT_H) || (ulMode == GRADIENT_FILL_RECT_V), "Unhandle 'ulMode'"); bStatus = bRectangleMesh( pSurfDstTmp, pxlo, pVertex, nVertex, (PGRADIENT_RECT)pMesh, nMesh, ulMode, &rclDstWk, ptlDitherOrg ); } // // write temp destination surface to real dst // if (bAllocDstSurf) { PDEVOBJ pdoDst(pSurfDst->hdev()); ASSERTGDI(pdoDst.bValid(), "Invalid HDEV"); POINTL ptlCopy = {0,0}; (*PPFNGET(pdoDst,CopyBits,pSurfDst->flags()))( pSurfDst->pSurfobj(), pSurfDstTmp->pSurfobj(), pco, &xloIdent, &rclDstTrim, &ptlCopy); // // undo temporary offseting // for (ulIndex=0;ulIndexx -= rclDstTrim.left; ptlDitherOrg->y -= rclDstTrim.top; } } else { EngSetLastError(ERROR_NOT_ENOUGH_MEMORY); bStatus = FALSE; } return(bStatus); } /******************************Public*Routine******************************\ * vCalcMeshExtent * * Verify mesh, calculate bounding rect of drawing. * * Arguments: * * pVertex - vertex array * nVertex - number of vertex in array * pMesh - array of rect or tri * nMesh - number in mesh array * ulMode - triangle or rectangle * prclExt - return extent rect * * Return Value: * * TRUE if mesh is valid * * History: * * 12/3/1996 Mark Enstrom [marke] * \**************************************************************************/ BOOL bCalcMeshExtent( PTRIVERTEX pVertex, ULONG nVertex, PVOID pMesh, ULONG nMesh, ULONG ulMode, RECTL *prclExt ) { LONG xmin = LONG_MAX; LONG xmax = LONG_MIN; LONG ymin = LONG_MAX; LONG ymax = LONG_MIN; BOOL bRet = TRUE; ULONG ulIndex; // // triangle or rectangle case // if ( (ulMode ==GRADIENT_FILL_RECT_H) || (ulMode == GRADIENT_FILL_RECT_V) ) { // // verify rectangle mesh, remember extents // PGRADIENT_RECT pGradRect = (PGRADIENT_RECT)pMesh; for (ulIndex=0;ulIndexUpperLeft; ULONG vlr = pGradRect->LowerRight; if ((vul <= nVertex) && (vlr <= nVertex)) { LONG VertLeftX = pVertex[vul].x; LONG VertLeftY = pVertex[vul].y; LONG VertRightX = pVertex[vlr].x; LONG VertRightY = pVertex[vlr].y; if (VertLeftX < xmin) { xmin = VertLeftX; } if (VertLeftX > xmax) { xmax = VertLeftX; } if (VertLeftY < ymin) { ymin = VertLeftY; } if (VertLeftY > ymax) { ymax = VertLeftY; } if (VertRightX < xmin) { xmin = VertRightX; } if (VertRightX > xmax) { xmax = VertRightX; } if (VertRightY < ymin) { ymin = VertRightY; } if (VertRightY > ymax) { ymax = VertRightY; } } else { // // error in mesh/vertex array, return null // bounding rect // prclExt->left = 0; prclExt->right = 0; prclExt->top = 0; prclExt->bottom = 0; return(FALSE); } pGradRect++; } } else if (ulMode == GRADIENT_FILL_TRIANGLE) { // // verify triangle mesh, remember extents // PGRADIENT_TRIANGLE pGradTri = (PGRADIENT_TRIANGLE)pMesh; for (ulIndex=0;ulIndexVertex1; lVertex[1] = pGradTri->Vertex2; lVertex[2] = pGradTri->Vertex3; for (vIndex=0;vIndex<3;vIndex++) { ULONG TriVertex = lVertex[vIndex]; if (TriVertex < nVertex) { LONG VertX = pVertex[TriVertex].x; LONG VertY = pVertex[TriVertex].y; if (VertX < xmin) { xmin = VertX; } if (VertX > xmax) { xmax = VertX; } if (VertY < ymin) { ymin = VertY; } if (VertY > ymax) { ymax = VertY; } } else { // // error in mesh/vertex array, return null // bounding rect // prclExt->left = 0; prclExt->right = 0; prclExt->top = 0; prclExt->bottom = 0; return(FALSE); } } pGradTri++; } } else { bRet = FALSE; } // // are any parameter out of coordinate space bounds 2^28 // LONG lIntMax = 0x08000000; LONG lIntMin = -lIntMax; if ( (xmin < lIntMin) || (xmin > lIntMax) || (xmax < lIntMin) || (xmax > lIntMax) || (ymin < lIntMin) || (ymin > lIntMax) || (ymax < lIntMin) || (ymax > lIntMax) ) { prclExt->left = 0; prclExt->right = 0; prclExt->top = 0; prclExt->bottom = 0; return(FALSE); } prclExt->left = xmin; prclExt->right = xmax; prclExt->top = ymin; prclExt->bottom = ymax; return(bRet); } /******************************Public*Routine******************************\ * GreGradientFill * * Arguments: * * hdc - dc * pLocalVertex - Position and color * nVertex - number of vertex * pLocalMesh - each three USHORTs define 1 triangle * nMesh - Number of triangles * ulMode - drawing mode (rect/tri) and options * * Return Value: * * Status * * History: * * 23-Jun-1997 Added rotation support for rectangles -by- Ori Gershony [orig] * * 16-Jul-1996 -by- Mark Enstrom [marke] * \**************************************************************************/ BOOL GreGradientFill( HDC hdc, PTRIVERTEX pLocalVertex, ULONG nVertex, PVOID pLocalMesh, ULONG nMesh, ULONG ulMode ) { GDITraceHandle(GreGradientFill, "(%X, %p, %u, %p, %u, %u)\n", (va_list)&hdc, hdc); BOOL bStatus = FALSE; PTRIVERTEX pLocalVertexTmp=NULL; PVOID pLocalMeshTmp=NULL; // // limit ulMode (direct from user) // ulMode &= GRADIENT_FILL_OP_FLAG; // // validate DST DC // DCOBJ dcoDst(hdc); if (dcoDst.bValid()) { // // lock device // DEVLOCKBLTOBJ dlo; if (dlo.bLock(dcoDst)) { EXFORMOBJ xoDst(dcoDst, WORLD_TO_DEVICE); // // Break each rotated rectangle into two triangles. This will double // the number of vertices used (4 per two triangles). // if (xoDst.bRotation() && ((ulMode == GRADIENT_FILL_RECT_H) || (ulMode == GRADIENT_FILL_RECT_V))) { // // Allocate two triangles for each rectangle // ULONG ulSizeM = nMesh * 2 * sizeof(GRADIENT_TRIANGLE); ULONG ulSizeV = nVertex * 2 * sizeof(TRIVERTEX); // // Let's make sure nMesh and nVertex are not so high as to cause overflow--this // can cause us to allocate too small a buffer and then commit an access // violation. Also make sure we have enough memory. // if ((nVertex > MAXULONG/2) || (nMesh > MAXULONG/2) || ((nVertex * 2) > (MAXIMUM_POOL_ALLOC / sizeof(TRIVERTEX))) || ((nMesh * 2) > ((MAXIMUM_POOL_ALLOC - ulSizeV) / (sizeof(GRADIENT_TRIANGLE))))) { WARNING("GreGradientFill: can't allocate input buffer\n"); EngSetLastError(ERROR_NOT_ENOUGH_MEMORY); return(FALSE); } // // Allocate memory and assign to the pointers // pLocalVertexTmp = (PTRIVERTEX)PALLOCNOZ(ulSizeV + ulSizeM,'pmtG'); if (!pLocalVertexTmp) { EngSetLastError(ERROR_NOT_ENOUGH_MEMORY); return FALSE; } pLocalMeshTmp = (PVOID)((PBYTE)pLocalVertexTmp + ulSizeV); // // First copy the old Vertices // ULONG vertexNum; for (vertexNum=0; vertexNum < nVertex; vertexNum++) { ((PTRIVERTEX)pLocalVertexTmp)[vertexNum] = ((PTRIVERTEX) pLocalVertex)[vertexNum]; } // // Now walk the rectangle list and generate triangles/vertices as needed: // // v1 vertexNum // *------------------* // | | // | | // *------------------* // vertexNum+1 v2 // for (ULONG rectNum=0; rectNum < nMesh; rectNum++) { ULONG v1,v2; v1 = ((PGRADIENT_RECT)pLocalMesh)[rectNum].UpperLeft; v2 = ((PGRADIENT_RECT)pLocalMesh)[rectNum].LowerRight; if ((v1 >= nVertex) || (v2 >= nVertex)) { WARNING("GreGradientFill: vertex is out of range\n"); EngSetLastError(ERROR_INVALID_PARAMETER); VFREEMEM(pLocalVertexTmp); return(FALSE); } pLocalVertexTmp[vertexNum].x = pLocalVertex[v2].x; pLocalVertexTmp[vertexNum].y = pLocalVertex[v1].y; pLocalVertexTmp[vertexNum+1].x = pLocalVertex[v1].x; pLocalVertexTmp[vertexNum+1].y = pLocalVertex[v2].y; if (ulMode == GRADIENT_FILL_RECT_V) { // // vertexNum has same color as v1, vertexNum+1 has same color as v2 // pLocalVertexTmp[vertexNum].Red = pLocalVertex[v1].Red; pLocalVertexTmp[vertexNum].Green = pLocalVertex[v1].Green; pLocalVertexTmp[vertexNum].Blue = pLocalVertex[v1].Blue; pLocalVertexTmp[vertexNum].Alpha = pLocalVertex[v1].Alpha; pLocalVertexTmp[vertexNum+1].Red = pLocalVertex[v2].Red; pLocalVertexTmp[vertexNum+1].Green = pLocalVertex[v2].Green; pLocalVertexTmp[vertexNum+1].Blue = pLocalVertex[v2].Blue; pLocalVertexTmp[vertexNum+1].Alpha = pLocalVertex[v2].Alpha; } else { // // vertexNum has same color as v2, vertexNum+1 has same color as v1 // pLocalVertexTmp[vertexNum].Red = pLocalVertex[v2].Red; pLocalVertexTmp[vertexNum].Green = pLocalVertex[v2].Green; pLocalVertexTmp[vertexNum].Blue = pLocalVertex[v2].Blue; pLocalVertexTmp[vertexNum].Alpha = pLocalVertex[v2].Alpha; pLocalVertexTmp[vertexNum+1].Red = pLocalVertex[v1].Red; pLocalVertexTmp[vertexNum+1].Green = pLocalVertex[v1].Green; pLocalVertexTmp[vertexNum+1].Blue = pLocalVertex[v1].Blue; pLocalVertexTmp[vertexNum+1].Alpha = pLocalVertex[v1].Alpha; } // // Now add vertices for the two triangles // ((PGRADIENT_TRIANGLE)pLocalMeshTmp)[rectNum*2].Vertex1 = v1; ((PGRADIENT_TRIANGLE)pLocalMeshTmp)[rectNum*2].Vertex2 = vertexNum; ((PGRADIENT_TRIANGLE)pLocalMeshTmp)[rectNum*2].Vertex3 = vertexNum+1; ((PGRADIENT_TRIANGLE)pLocalMeshTmp)[rectNum*2+1].Vertex1 = v2; ((PGRADIENT_TRIANGLE)pLocalMeshTmp)[rectNum*2+1].Vertex2 = vertexNum; ((PGRADIENT_TRIANGLE)pLocalMeshTmp)[rectNum*2+1].Vertex3 = vertexNum+1; vertexNum += 2; } // // Now modify the arguments so that this change is transparent to the rest of the code // pLocalMesh = pLocalMeshTmp; pLocalVertex = pLocalVertexTmp; ulMode = GRADIENT_FILL_TRIANGLE; nVertex = vertexNum; nMesh *= 2; } // // should be able to rotate triangle with no problem. Rotated // rectangles should have already been converted to triangles. // ULONG ulIndex; ERECTL erclDst(POS_INFINITY,POS_INFINITY,NEG_INFINITY,NEG_INFINITY); // // Translate to device space. Use integer points, not fixed point // for (ulIndex=0;ulIndexhdev()); DEVEXCLUDEOBJ dxo(dcoDst,&erclDst,&eco); EXLATEOBJ xlo; XLATEOBJ *pxlo; // // Inc the target surface uniqueness // INC_SURF_UNIQ(pSurfDst); if ((pdo.bPrinter()) || (pSurfDst->iFormat() <= BMF_8BPP)) { // // 16bpp or greater does not require a translation object. // // color translate is from RGB (PAL_BGR) 32 to device // XEPALOBJ palDst(pSurfDst->ppal()); XEPALOBJ palDstDC(dcoDst.ppal()); XEPALOBJ palSrc(gppalRGB); bStatus = xlo.bInitXlateObj( dcoDst.pdc->hcmXform(), dcoDst.pdc->GetICMMode(), palSrc, palDst, palDstDC, palDstDC, dcoDst.pdc->crTextClr(), dcoDst.pdc->crBackClr(), 0 ); pxlo = xlo.pxlo(); } else { pxlo = NULL; } // // must have window offset for dither org // POINTL ptlDitherOrg = dcoDst.pdc->eptlOrigin(); ptlDitherOrg.x = -ptlDitherOrg.x; ptlDitherOrg.y = -ptlDitherOrg.y; // // call driver/engine drawing // PFN_DrvGradientFill pfnGradientFill; if (pSurfDst->iFormat() == BMF_8BPP) { // Drivers can't really support GradientFill at // 8BPP. Instead of calling them and running // the risk of having them mess up, let's call // the engine instead. pfnGradientFill = EngGradientFill; } else { pfnGradientFill = PPFNGET(pdo,GradientFill, pSurfDst->flags()); } bStatus = bStatus && (*pfnGradientFill)( pSurfDst->pSurfobj(), &eco, pxlo, pLocalVertex, nVertex, pLocalMesh, nMesh, &erclDst, &ptlDitherOrg, ulMode ); } else { bStatus = TRUE; } } else { bStatus = TRUE; } } else { WARNING1("GreGradientFill: Invalid mesh or vertex\n"); } } else { bStatus = dcoDst.bFullScreen(); } } else { bStatus = FALSE; } // // If allocated memory to convert rectangles to triangles, free it before // leaving this function. // if (pLocalVertexTmp) { VFREEMEM(pLocalVertexTmp); } return(bStatus); } /******************************Public*Routine******************************\ * NtGdiTriangleMesh * * Kernel mode stub for GradientFill * * Arguments: * * hdc - dc * pLocalVertex - Position and color * nVertex - number of vertex * pLocalMesh - triangle or rectangle mesh * nMesh - Number of triangles * ulMode - drawing mode (rect/tri) and options * * Return Value: * * Status * * History: * * 17-Jul-1996 -by- Mark Enstrom [marke] * \**************************************************************************/ BOOL NtGdiGradientFill( HDC hdc, PTRIVERTEX pVertex, ULONG nVertex, PVOID pMesh, ULONG nMesh, ULONG ulMode ) { PTRIVERTEX pLocalVertex; PVOID pLocalMesh; // // make sure ulMode is not being mis-used // if ((ulMode & ~GRADIENT_FILL_OP_FLAG) != 0) { WARNING("NtGdiGradientFill: illegal parameter\n"); EngSetLastError(ERROR_INVALID_PARAMETER); return(FALSE); } ulMode &= GRADIENT_FILL_OP_FLAG; // // validate parameters, make sure one of the mode // flags is set, but no invalid mode is set // if ( (pVertex == NULL) || (pMesh == NULL) || (nVertex == 0) || (nMesh == 0) || (nVertex >= 0x80000000) || (nMesh >= 0x80000000) || ( (ulMode != GRADIENT_FILL_RECT_H) && (ulMode != GRADIENT_FILL_RECT_V) && (ulMode != GRADIENT_FILL_TRIANGLE) ) ) { WARNING("NtGdiGradientFill: illegal parameter\n"); EngSetLastError(ERROR_INVALID_PARAMETER); return(FALSE); } // // attempt to allocate a buffer to copy entire vertex and mesh array // if (nVertex > (MAXIMUM_POOL_ALLOC / sizeof(TRIVERTEX))) { WARNING("NtGdiGradientFill: nVertex is too large\n"); EngSetLastError(ERROR_INVALID_PARAMETER); return(FALSE); } ULONG ulSizeV = nVertex * sizeof(TRIVERTEX); ULONG ulSizeM; BOOL bRet = TRUE; if (ulMode == GRADIENT_FILL_TRIANGLE) { if (nMesh > ((MAXIMUM_POOL_ALLOC - ulSizeV) / (sizeof(GRADIENT_TRIANGLE)))) { WARNING("NtGdiGradientFill: nMesh is too large\n"); EngSetLastError(ERROR_INVALID_PARAMETER); return(FALSE); } ulSizeM = nMesh * sizeof(GRADIENT_TRIANGLE); } else { if (nMesh > ((MAXIMUM_POOL_ALLOC - ulSizeV) / (sizeof(GRADIENT_RECT)))) { WARNING("NtGdiGradientFill: nMesh is too large\n"); EngSetLastError(ERROR_INVALID_PARAMETER); return(FALSE); } ulSizeM = nMesh * sizeof(GRADIENT_RECT); } // // alloc memory for data buffers // if ((ulSizeM + ulSizeV) >= MAXIMUM_POOL_ALLOC) { WARNING("NtGdiGradientFill: can't allocate input buffer\n"); EngSetLastError(ERROR_NOT_ENOUGH_MEMORY); return(FALSE); } pLocalVertex = (PTRIVERTEX)PALLOCNOZ(ulSizeV + ulSizeM,'pmtG'); if (pLocalVertex) { pLocalMesh = (PVOID)((PBYTE)pLocalVertex + ulSizeV); // // probe then copy buffers // __try { ProbeForRead(pVertex,ulSizeV,sizeof(BYTE)); RtlCopyMemory(pLocalVertex,pVertex,ulSizeV); ProbeForRead(pMesh,ulSizeM,sizeof(BYTE)); RtlCopyMemory(pLocalMesh,pMesh,ulSizeM); } __except(EXCEPTION_EXECUTE_HANDLER) { WARNINGX(2); bRet = FALSE; } if (bRet) { bRet = GreGradientFill( hdc, pLocalVertex, nVertex, pLocalMesh, nMesh, ulMode ); } VFREEMEM(pLocalVertex); } else { EngSetLastError(ERROR_NOT_ENOUGH_MEMORY); bRet = FALSE; } return(bRet); }