include/line.h

   1 /*
   2  * $Logfile: /Freespace2/code/Graphics/Line.h $
   3  * $Revision$
   4  * $Date$
   5  * $Author$
   6  *
   7  * Header file for line.cpp
   8  *
   9  * $Log$
  10  * Revision 1.1  2002/05/03 03:28:12  root
  11  * Initial revision
  12  *
  13  *
  14  * 2     10/07/98 10:53a Dave
  15  * Initial checkin.
  16  *
  17  * 1     10/07/98 10:49a Dave
  18  *
  19  * 10    5/06/98 5:30p John
  20  * Removed unused cfilearchiver.  Removed/replaced some unused/little used
  21  * graphics functions, namely gradient_h and _v and pixel_sp.   Put in new
  22  * DirectX header files and libs that fixed the Direct3D alpha blending
  23  * problems.
  24  *
  25  * 9     3/10/98 4:18p John
  26  * Cleaned up graphics lib.  Took out most unused gr functions.   Made D3D
  27  * & Glide have popups and print screen.  Took out all >8bpp software
  28  * support.  Made Fred zbuffer.  Made zbuffer allocate dynamically to
  29  * support Fred.  Made zbuffering key off of functions rather than one
  30  * global variable.
  31  *
  32  * 8     10/03/97 9:10a John
  33  * added better antialiased line drawer
  34  *
  35  * 7     6/13/97 5:35p John
  36  * added some antialiased bitmaps and lines
  37  *
  38  * 6     11/26/96 6:50p John
  39  * Added some more hicolor primitives.  Made windowed mode run as current
  40  * bpp, if bpp is 8,16,or 32.
  41  *
  42  * 5     10/26/96 2:56p John
  43  * Got gradient code working.
  44  *
  45  * 4     10/26/96 1:40p John
  46  * Added some now primitives to the 2d library and
  47  * cleaned up some old ones.
  48  *
  49  * $NoKeywords: $
  50  */
  51
  52 #ifndef _LINE_H
  53 #define _LINE_H
  54
  55 void gr8_line(int x1,int y1,int x2,int y2);
  56 void gr8_aaline(vertex *v1, vertex *v2);
  57
  58
  59 #define INT_EXCHG(a,b) do {                                              \
  60     int __temp__ = (a);                                                 \
  61     (a) = (b);                                                          \
  62     (b) = __temp__;                                                     \
  63 } while(0)
  64
  65 //#define INT_SCALE(var,arg,num,den) ((var) = ((arg) * (num)) / (den))
  66 #define INT_SCALE(var,arg,num,den) ((var) = MulDiv(arg, num, den))
  67
  68 #define INT_CLIPLINE(x1,y1,x2,y2,XMIN,YMIN,XMAX,YMAX,WHEN_OUTSIDE,WHEN_CLIPPED,WHEN_SWAPPED) do {                                    \
  69     int temp;                                                  \
  70                                                                         \
  71     if(y1 > y2)                                                         \
  72         { INT_EXCHG(y1,y2); INT_EXCHG(x1,x2); WHEN_SWAPPED; }                                 \
  73     if((y2 < YMIN) || (y1 > YMAX))                    \
  74         { WHEN_OUTSIDE; }                                               \
  75     if(x1 < x2) {                                                       \
  76         if((x2 < XMIN) || (x1 > XMAX)) {              \
  77             WHEN_OUTSIDE;                                               \
  78         }                                                               \
  79         if(x1 < XMIN) {                                        \
  80                         INT_SCALE(temp,(y2 - y1),(XMIN - x1),(x2 - x1));      \
  81             if((y1 += temp) > YMAX) { WHEN_OUTSIDE; }          \
  82             x1 = XMIN;                                         \
  83             WHEN_CLIPPED;                                               \
  84         }                                                               \
  85         if(x2 > XMAX) {                                        \
  86                         INT_SCALE(temp,(y2 - y1),(x2 - XMAX),(x2 - x1));      \
  87             if((y2 -= temp) < YMIN) { WHEN_OUTSIDE; }          \
  88             x2 = XMAX;                                         \
  89             WHEN_CLIPPED;                                               \
  90         }                                                               \
  91         if(y1 < YMIN) {                                        \
  92                         INT_SCALE(temp,(x2 - x1),(YMIN - y1),(y2 - y1));      \
  93             x1 += temp;                                                 \
  94             y1 = YMIN;                                         \
  95             WHEN_CLIPPED;                                               \
  96         }                                                               \
  97         if(y2 > YMAX) {                                        \
  98                         INT_SCALE(temp,(x2 - x1),(y2 - YMAX),(y2 - y1));      \
  99             x2 -= temp;                                                 \
 100             y2 = YMAX;                                         \
 101             WHEN_CLIPPED;                                               \
 102         }                                                               \
 103     }                                                                   \
 104     else {                                                              \
 105         if((x1 < XMIN) || (x2 > XMAX)) {              \
 106             WHEN_OUTSIDE;                                               \
 107         }                                                               \
 108         if(x1 > XMAX) {                                        \
 109                         INT_SCALE(temp,(y2 - y1),(x1 - XMAX),(x1 - x2));      \
 110             if((y1 += temp) > YMAX) { WHEN_OUTSIDE; }          \
 111             x1 = XMAX;                                         \
 112             WHEN_CLIPPED;                                               \
 113         }                                                               \
 114         if(x2 < XMIN) {                                        \
 115                         INT_SCALE(temp,(y2 - y1),(XMIN - x2),(x1 - x2));      \
 116             if((y2 -= temp) < YMIN) { WHEN_OUTSIDE; }          \
 117             x2 = XMIN;                                         \
 118             WHEN_CLIPPED;                                               \
 119         }                                                               \
 120         if(y1 < YMIN) {                                        \
 121                         INT_SCALE(temp,(x1 - x2),(YMIN - y1),(y2 - y1));      \
 122             x1 -= temp;                                                 \
 123             y1 = YMIN;                                         \
 124             WHEN_CLIPPED;                                               \
 125         }                                                               \
 126         if(y2 > YMAX) {                                        \
 127                         INT_SCALE(temp,(x1 - x2),(y2 - YMAX),(y2 - y1));      \
 128             x2 += temp;                                                 \
 129             y2 = YMAX;                                         \
 130             WHEN_CLIPPED;                                               \
 131         }                                                               \
 132     }                                                                   \
 133 } while(0)
 134
 135 #define FL_EXCHG(a,b) do {                                                 \
 136     float __temp__ = (a);                                                 \
 137     (a) = (b);                                                          \
 138     (b) = __temp__;                                                     \
 139 } while(0)
 140
 141 #define FL_SCALE(var,arg,num,den) ((var) = ((arg) * (num)) / (den))
 142
 143 #define FL_CLIPLINE(x1,y1,x2,y2,XMIN,YMIN,XMAX,YMAX,WHEN_OUTSIDE,WHEN_CLIPPED,WHEN_SWAPPED) do {                                    \
 144     float temp;                                                  \
 145                                                                         \
 146     if(y1 > y2)                                                         \
 147         { FL_EXCHG(y1,y2); FL_EXCHG(x1,x2); WHEN_SWAPPED; }                                 \
 148     if((y2 < YMIN) || (y1 > YMAX))                    \
 149         { WHEN_OUTSIDE; }                                               \
 150     if(x1 < x2) {                                                       \
 151         if((x2 < XMIN) || (x1 > XMAX)) {              \
 152             WHEN_OUTSIDE;                                               \
 153         }                                                               \
 154         if(x1 < XMIN) {                                        \
 155                         FL_SCALE(temp,(y2 - y1),(XMIN - x1),(x2 - x1));      \
 156             if((y1 += temp) > YMAX) { WHEN_OUTSIDE; }          \
 157             x1 = XMIN;                                         \
 158             WHEN_CLIPPED;                                               \
 159         }                                                               \
 160         if(x2 > XMAX) {                                        \
 161                         FL_SCALE(temp,(y2 - y1),(x2 - XMAX),(x2 - x1));      \
 162             if((y2 -= temp) < YMIN) { WHEN_OUTSIDE; }          \
 163             x2 = XMAX;                                         \
 164             WHEN_CLIPPED;                                               \
 165         }                                                               \
 166         if(y1 < YMIN) {                                        \
 167                         FL_SCALE(temp,(x2 - x1),(YMIN - y1),(y2 - y1));      \
 168             x1 += temp;                                                 \
 169             y1 = YMIN;                                         \
 170             WHEN_CLIPPED;                                               \
 171         }                                                               \
 172         if(y2 > YMAX) {                                        \
 173                         FL_SCALE(temp,(x2 - x1),(y2 - YMAX),(y2 - y1));      \
 174             x2 -= temp;                                                 \
 175             y2 = YMAX;                                         \
 176             WHEN_CLIPPED;                                               \
 177         }                                                               \
 178     }                                                                   \
 179     else {                                                              \
 180         if((x1 < XMIN) || (x2 > XMAX)) {              \
 181             WHEN_OUTSIDE;                                               \
 182         }                                                               \
 183         if(x1 > XMAX) {                                        \
 184                         FL_SCALE(temp,(y2 - y1),(x1 - XMAX),(x1 - x2));      \
 185             if((y1 += temp) > YMAX) { WHEN_OUTSIDE; }          \
 186             x1 = XMAX;                                         \
 187             WHEN_CLIPPED;                                               \
 188         }                                                               \
 189         if(x2 < XMIN) {                                        \
 190                         FL_SCALE(temp,(y2 - y1),(XMIN - x2),(x1 - x2));      \
 191             if((y2 -= temp) < YMIN) { WHEN_OUTSIDE; }          \
 192             x2 = XMIN;                                         \
 193             WHEN_CLIPPED;                                               \
 194         }                                                               \
 195         if(y1 < YMIN) {                                        \
 196                         FL_SCALE(temp,(x1 - x2),(YMIN - y1),(y2 - y1));      \
 197             x1 -= temp;                                                 \
 198             y1 = YMIN;                                         \
 199             WHEN_CLIPPED;                                               \
 200         }                                                               \
 201         if(y2 > YMAX) {                                        \
 202                         FL_SCALE(temp,(x1 - x2),(y2 - YMAX),(y2 - y1));      \
 203             x2 += temp;                                                 \
 204             y2 = YMAX;                                         \
 205             WHEN_CLIPPED;                                               \
 206         }                                                               \
 207     }                                                                   \
 208 } while(0)
 209
 210 #endif
 211