void DrawLine2D(float x1, float y1, float x2, float y2) { int xi1, yi1, xi2, yi2; //x1 = x_current; //y1 = y_current; //TO DO <MATRIZ>.DoTransformation(&x1, &y1); //TO DO Faça Transformacao x2 y2 if (Clip2D(&x1, &y1, &x2, &y2)) { ViewingTransformation(&x1, &y1); ViewingTransformation(&x2, &y2); NormalizedToDevice(x1, y1, &xi1, &yi1); NormalizedToDevice(x2, y2, &xi2, &yi2); DrawLine(xi1, yi1, xi2, yi2); } }
void LineDraw( BOOL fClip, int XStart, int YStart, int XEnd, int YEnd, short Color, UINT8 *ScreenPtr) { int Temp, AdjUp, AdjDown, ErrorTerm, XAdvance, XDelta, YDelta; int WholeStep, InitialPixelCount, FinalPixelCount, i, RunLength; int ScreenWidth=giImageWidth/2; char col2 = Color>>8; char col1 = Color & 0x00FF; if ( fClip ) { if ( !Clip2D( &XStart, &YStart, &XEnd, &YEnd ) ) return; } /* We'll always draw top to bottom, to reduce the number of cases we have to handle, and to make lines between the same endpoints draw the same pixels */ if (YStart > YEnd) { Temp = YStart; YStart = YEnd; YEnd = Temp; Temp = XStart; XStart = XEnd; XEnd = Temp; } // point to the bitmap address first pixel to draw ScreenPtr = ScreenPtr + YStart*giImageWidth + XStart*2; /* Figure out whether we're going left or right, and how far we're going horizontally */ if ((XDelta = XEnd - XStart) < 0) { XAdvance = -1; XDelta = -XDelta; } else { XAdvance = 1; } /* Figure out how far we're going vertically */ YDelta = YEnd - YStart; /* Special-case horizontal, vertical, and diagonal lines, for speed and to avoid nasty boundary conditions and division by 0 */ if (XDelta == 0) { /* Vertical line */ for (i=0; i<=YDelta; i++) { ScreenPtr[0] = col1; ScreenPtr[1] = col2; ScreenPtr += giImageWidth; } return; } if (YDelta == 0) { /* Horizontal line */ for (i=0; i<=XDelta; i++) { ScreenPtr[0] = col1; ScreenPtr[1] = col2; ScreenPtr += XAdvance*2; } return; } if (XDelta == YDelta) { /* Diagonal line */ for (i=0; i<=XDelta; i++) { ScreenPtr[0] = col1; ScreenPtr[1] = col2; ScreenPtr += (XAdvance*2) + giImageWidth; } return; } /* Determine whether the line is X or Y major, and handle accordingly */ if (XDelta >= YDelta) { /* X major line */ /* Minimum # of pixels in a run in this line */ WholeStep = XDelta / YDelta; /* Error term adjust each time Y steps by 1; used to tell when one extra pixel should be drawn as part of a run, to account for fractional steps along the X axis per 1-pixel steps along Y */ AdjUp = (XDelta % YDelta) * 2; /* Error term adjust when the error term turns over, used to factor out the X step made at that time */ AdjDown = YDelta * 2; /* Initial error term; reflects an initial step of 0.5 along the Y axis */ ErrorTerm = (XDelta % YDelta) - (YDelta * 2); /* The initial and last runs are partial, because Y advances only 0.5 for these runs, rather than 1. Divide one full run, plus the initial pixel, between the initial and last runs */ InitialPixelCount = (WholeStep / 2) + 1; FinalPixelCount = InitialPixelCount; /* If the basic run length is even and there's no fractional advance, we have one pixel that could go to either the initial or last partial run, which we'll arbitrarily allocate to the last run */ if ((AdjUp == 0) && ((WholeStep & 0x01) == 0)) { InitialPixelCount--; } /* If there're an odd number of pixels per run, we have 1 pixel that can't be allocated to either the initial or last partial run, so we'll add 0.5 to error term so this pixel will be handled by the normal full-run loop */ if ((WholeStep & 0x01) != 0) { ErrorTerm += YDelta; } /* Draw the first, partial run of pixels */ DrawHorizontalRun(&ScreenPtr, XAdvance, InitialPixelCount, Color, ScreenWidth); /* Draw all full runs */ for (i=0; i<(YDelta-1); i++) { RunLength = WholeStep; /* run is at least this long */ /* Advance the error term and add an extra pixel if the error term so indicates */ if ((ErrorTerm += AdjUp) > 0) { RunLength++; ErrorTerm -= AdjDown; /* reset the error term */ } /* Draw this scan line's run */ DrawHorizontalRun(&ScreenPtr, XAdvance, RunLength, Color, ScreenWidth); } /* Draw the final run of pixels */ DrawHorizontalRun(&ScreenPtr, XAdvance, FinalPixelCount, Color, ScreenWidth); return; } else { /* Y major line */ /* Minimum # of pixels in a run in this line */ WholeStep = YDelta / XDelta; /* Error term adjust each time X steps by 1; used to tell when 1 extra pixel should be drawn as part of a run, to account for fractional steps along the Y axis per 1-pixel steps along X */ AdjUp = (YDelta % XDelta) * 2; /* Error term adjust when the error term turns over, used to factor out the Y step made at that time */ AdjDown = XDelta * 2; /* Initial error term; reflects initial step of 0.5 along the X axis */ ErrorTerm = (YDelta % XDelta) - (XDelta * 2); /* The initial and last runs are partial, because X advances only 0.5 for these runs, rather than 1. Divide one full run, plus the initial pixel, between the initial and last runs */ InitialPixelCount = (WholeStep / 2) + 1; FinalPixelCount = InitialPixelCount; /* If the basic run length is even and there's no fractional advance, we have 1 pixel that could go to either the initial or last partial run, which we'll arbitrarily allocate to the last run */ if ((AdjUp == 0) && ((WholeStep & 0x01) == 0)) { InitialPixelCount--; } /* If there are an odd number of pixels per run, we have one pixel that can't be allocated to either the initial or last partial run, so we'll add 0.5 to the error term so this pixel will be handled by the normal full-run loop */ if ((WholeStep & 0x01) != 0) { ErrorTerm += XDelta; } /* Draw the first, partial run of pixels */ DrawVerticalRun(&ScreenPtr, XAdvance, InitialPixelCount, Color, ScreenWidth); /* Draw all full runs */ for (i=0; i<(XDelta-1); i++) { RunLength = WholeStep; /* run is at least this long */ /* Advance the error term and add an extra pixel if the error term so indicates */ if ((ErrorTerm += AdjUp) > 0) { RunLength++; ErrorTerm -= AdjDown; /* reset the error term */ } /* Draw this scan line's run */ DrawVerticalRun(&ScreenPtr, XAdvance, RunLength, Color, ScreenWidth); } /* Draw the final run of pixels */ DrawVerticalRun(&ScreenPtr, XAdvance, FinalPixelCount, Color, ScreenWidth); return; } }