Return to intline.c CVS log

Up to [WindowsNT SDKs] / ntddk / src / video / displays / s3

Annotation of ntddk/src/video/displays/s3/intline.c, revision 1.1

1.1     ! root        1: /*************************************************************************\
        !             2: * Module Name: Lines.cxx
        !             3: *
        !             4: * C template for the ASM version of the line DDA calculator.
        !             5: * contains the C code associated with the c++ code (c++ does not handle
        !             6: * READ/WRITE_REGISTER to well
        !             7: *
        !             8: * Copyright (c) 1993 Microsoft Corporation
        !             9: * Copyright (c) 1992 Digital Equipment Corporation
        !            10: \**************************************************************************/
        !            11: 
        !            12: #include "driver.h"
        !            13: #include "lines.h"
        !            14: 
        !            15: #define S3_MAX_INT_LINE        0x800
        !            16: #define DEFAULT_DRAW_CMD       DRAW_LINE | \
        !            17:                                 DRAW | \
        !            18:                                 DIR_TYPE_XY | \
        !            19:                                 MULTIPLE_PIXELS | \
        !            20:                                 WRITE | \
        !            21:                                 LAST_PIXEL_OFF
        !            22: 
        !            23: 
        !            24: /******************************************************************************
        !            25:  * bIntegerLine
        !            26:  *
        !            27:  *
        !            28:  * This routine attempts to draw a line segment between two points. It
        !            29:  * will only draw if both end points are whole integers: it does not support
        !            30:  * fractional endpoints.
        !            31:  *
        !            32:  * Returns:
        !            33:  *   TRUE     if the line segment is drawn
        !            34:  *   FALSE    otherwise
        !            35:  *****************************************************************************/
        !            36: 
        !            37: BOOL
        !            38: bIntegerLine (
        !            39:              PPDEV     ppdev,
        !            40:              ULONG     X1,
        !            41:              ULONG     Y1,
        !            42:              ULONG     X2,
        !            43:              ULONG     Y2
        !            44: )
        !            45:     {
        !            46:        LONG            Cmd;
        !            47:        LONG            DeltaX, DeltaY;
        !            48:        LONG            ErrorTerm;
        !            49:        LONG            Major, Minor;
        !            50:        
        !            51:        
        !            52:        
        !            53:        X1 >>= 4;
        !            54:        Y1 >>= 4;
        !            55:        X2 >>= 4;
        !            56:        Y2 >>= 4;
        !            57:        
        !            58:        Cmd = DEFAULT_DRAW_CMD | PLUS_Y | PLUS_X | MAJOR_Y;
        !            59:        
        !            60:        DeltaX = X2 - X1;
        !            61:        if (DeltaX < 0) {
        !            62:            DeltaX = -DeltaX;
        !            63:            Cmd &= ~PLUS_X;
        !            64:        }
        !            65:        DeltaY = Y2 - Y1;
        !            66:        if (DeltaY < 0) {
        !            67:            DeltaY = -DeltaY;
        !            68:            Cmd &= ~PLUS_Y;
        !            69:        }
        !            70:        
        !            71:        // Compute the major drawing axis
        !            72:        
        !            73:        if (DeltaX > DeltaY) {
        !            74:            Cmd &= ~MAJOR_Y;
        !            75:            Major = DeltaX;
        !            76:            Minor = DeltaY;
        !            77:        } else {
        !            78:            Major = DeltaY;
        !            79:            Minor = DeltaX;
        !            80:        }
        !            81:        
        !            82:        
        !            83:        // Tell the S3 to draw the line
        !            84:        
        !            85:        FIFOWAIT (FIFO_7_EMPTY);
        !            86:        OUTPW (CUR_X, X1);
        !            87:        OUTPW (CUR_Y, Y1);
        !            88:        OUTPW (LINE_MAX, Major);
        !            89:        OUTPW (AXSTP, Minor * 2);
        !            90:        OUTPW (DIASTP, 2 * Minor - 2 * Major);
        !            91:        
        !            92:        
        !            93:        // Adjust the error term so that 1/2 always rounds down, to
        !            94:        // conform with GIQ.
        !            95:        
        !            96:        ErrorTerm = 2 * Minor - Major;
        !            97:        if (Cmd & MAJOR_Y) {
        !            98:            if (Cmd & PLUS_X) {
        !            99:                ErrorTerm--;
        !           100:            }
        !           101:        } else {
        !           102:            if (Cmd & PLUS_Y) {
        !           103:                ErrorTerm--;
        !           104:            }
        !           105:        }
        !           106:        
        !           107:        OUTPW (ERR_TERM, ErrorTerm);
        !           108:        OUTPW (CMD, Cmd);
        !           109:        
        !           110:        
        !           111:        // Wait until the S3 has finished drawing, and return success
        !           112:        // to the caller
        !           113:        
        !           114:        GPWAIT();
        !           115:        return TRUE;
        !           116:        
        !           117:     }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.