fish/surf/poly.c

   1 #include <proto/mathtrans.h>
   2 #include "mytypes.h"
   3 #include "scrnio.h"
   4 #include "bezpt.h"
   5 #include "revolve.h"
   6 #include "control.h"
   7 #include "poly.h"
   8 #include "readilbm.h"
   9 #include "menuexp.h"
  10
  11 bool  SpecOn = false; /* specular lighting enable - default off */
  12
  13 float Ambience = DefAmbience;
  14 float PtIntensity = (float)DefIntensity;
  15 float Kd = DefKd,
  16       Ks = DefKs;
  17
  18 Pt3 LightSrc = {
  19         DefLightSrcX,
  20         DefLightSrcY,
  21         DefLightSrcZ
  22         };
  23
  24 extern struct Library * MathTransBase;
  25
  26 static
  27 Rhomboid *polylist = null,
  28          *nextpoly;
  29
  30 MapRhomboid *mpolylist = null,
  31         *mnextpoly;
  32
  33
  34 void OutErr(char *);
  35 void ClrWindow(bool);
  36 void DrawRhomShade(Rhomboid *);
  37 void DrawRhomFrame(ScrnPair *);
  38 void DrawRhomMap(MapRhomboid *);
  39 bool InitMapping();
  40
  41 static bool shadeflag;
  42
  43 long CalcMaxPolyNum() {
  44     return( GetNumSegs() * BezMesh * RevMesh );
  45 }
  46
  47 static
  48 bool PrepPoly()
  49 {
  50         if( polylist ) free( (char *)polylist );
  51         polylist = (Rhomboid *)malloc( CalcMaxPolyNum() * sizeof(Rhomboid));
  52         if( !polylist ) {
  53             OutErr("PrepPoly: not enough memory");
  54             return( true );
  55         }
  56         nextpoly = polylist;
  57         return(false); /* success = 0 */
  58 }
  59
  60
  61 static bool
  62 PrepMPoly()
  63 {
  64         if( mpolylist ) free( (char *)mpolylist );
  65         mpolylist = (MapRhomboid *)
  66                     malloc( CalcMaxPolyNum() * sizeof(MapRhomboid));
  67         if( !mpolylist ) {
  68             OutErr("PrepPoly: not enough memory");
  69             return( true );
  70         }
  71         mnextpoly = mpolylist;
  72         return(false); /* success = 0 */
  73 }
  74
  75
  76 /*
  77  * Multiply a vector by scalar quantity
  78  */
  79 void ScaleVec( fact, src, dst )
  80         float fact;
  81         Pt3 *src, *dst;
  82 {
  83         dst->x = src->x * fact;
  84         dst->y = src->y * fact;
  85         dst->z = src->z * fact;
  86 }
  87 /*
  88  * convert a vector to a unitized vector
  89  * if possible
  90  */
  91 void Unitize( vec )
  92         Pt3 *vec;
  93 {
  94         float len;
  95
  96         len = vec->x*vec->x + vec->y*vec->y + vec->z*vec->z;
  97         len = sqrt( len );
  98         if( len != 0.0 ) {
  99                 vec->x /= len;
 100                 vec->y /= len;
 101                 vec->z /= len;
 102         }
 103 }
 104
 105 /*
 106  * calculate a vector from two points
 107  */
 108 void CalcVector( src1, src2, dest )
 109 Pt3 *src1, *src2, *dest ;
 110 {
 111         dest->x = src1->x - src2->x;
 112         dest->y = src1->y - src2->y;
 113         dest->z = src1->z - src2->z;
 114 }
 115
 116
 117
 118
 119 /*
 120  * calculate a normal from a list of polygons. This routine does the
 121  * logical trick of trying to exclude each point in turn if the
 122  * normal can not be calculated, or something of the sort.
 123  * a value of true is returned if a normal with a nonzero z component
 124  * could not be calculated
 125  */
 126
 127 bool CalcNormal( vxlist, normal)
 128         PtGen *vxlist[];
 129         register Pt3 *normal;
 130 {
 131         int i, k, m;
 132         Pt3 *j[3];
 133         Pt3 v1, v2;
 134
 135         for( i = 0; i < RhomVxNum; i++ ) {
 136                 for( k = 0, m = 3; m--; k++ ) {
 137                         if( k == i ) {
 138                                 k++;
 139                         }
 140                         j[m] = &vxlist[k]->d3;
 141                 }
 142                 CalcVector( j[1], j[0], &v1 );
 143                 CalcVector( j[2], j[1], &v2 );
 144
 145                 normal->z = v1.x*v2.y - v1.y*v2.x;
 146                 if( normal->z == 0 ) {
 147                         continue;
 148                 }
 149                 normal->x = v1.y*v2.z - v1.z*v2.y;
 150                 normal->y = v1.z*v2.x - v1.x*v2.z;
 151                 if( normal->z < 0 ) {
 152                         normal->x = -normal->x;
 153                         normal->y = -normal->y;
 154                         normal->z = -normal->z;
 155                 }
 156                 Unitize(normal);
 157                 return( false );
 158         }
 159         return(true);
 160 }
 161
 162
 163 /*
 164  * Euclidean dot product.
 165  * I wonder what the minkowski dot product would look like
 166  */
 167 float DotProd( v1, v2 )
 168         Pt3 *v1, *v2;
 169 {
 170         return( v1->x*v2->x + v1->y*v2->y + v1->z*v2->z );
 171 }
 172
 173
 174
 175
 176
 177 /*
 178  * define a polygon as a set of four points
 179  * returns true if polygon created
 180  */
 181 static bool CreatePoly(curpoly, p0, p1, p2, p3)
 182     register Rhomboid *curpoly;
 183     PtGen *p0, *p1, *p2, *p3;
 184 {
 185
 186     Pt3 normal;
 187     PtGen *list[RhomVxNum];
 188
 189     list[0] = p0; list[1] = p1; list[2] = p2; list[3] = p3;
 190     /*
 191      * compute stuff needed only if producing shaded image
 192      */
 193     if( shadeflag ) {
 194             Pt3 lvec;
 195             Pt3 center;
 196             float ptintens;
 197             float ldotn; /* light vector dot normal */
 198             /*
 199             * if cant compute normal, then junk polygon
 200             */
 201             if( CalcNormal( list, &normal )) {
 202                 return(false);
 203             }
 204
 205             curpoly->intensity = Ambience;
 206             center.x = ( list[0]->d3.x
 207                     + list[1]->d3.x
 208                     + list[2]->d3.x
 209                     + list[3]->d3.x)/4.0;
 210             center.y = ( list[0]->d3.y
 211                     + list[1]->d3.y
 212                     + list[2]->d3.y
 213                     + list[3]->d3.y)/4.0;
 214             center.z = ( list[0]->d3.z
 215                     + list[1]->d3.z
 216                     + list[2]->d3.z
 217                     + list[3]->d3.z)/4.0;
 218
 219             curpoly->depth = center.z;
 220
 221             CalcVector( &center, &LightSrc, &lvec );
 222             Unitize( &lvec );
 223             ldotn = DotProd( &lvec, &normal );
 224             if( ldotn < 0 ) {
 225                 ptintens = PtIntensity * Kd * -ldotn;
 226                 curpoly->intensity += ptintens;
 227             }
 228             /*
 229              * calculate specular component
 230              */
 231             if( SpecOn && ldotn < 0 ) {
 232                 float Kspec, Is;
 233                 Pt3 rvec; /* lvec reflected through poly */
 234
 235                 ScaleVec( 2*ldotn, &normal, &rvec );
 236                 CalcVector(&lvec, &rvec, &rvec );
 237                 Unitize( &center );
 238                 Kspec = DotProd( &rvec, &center);
 239
 240                 if( Kspec <= 0.0 ) {
 241                     Is = Ks * Kspec * Kspec* PtIntensity;
 242                     curpoly->intensity += Is;
 243                 }
 244             }
 245
 246             if( curpoly->intensity > 1.0 ) {
 247                 curpoly->intensity = 1.0;
 248             }
 249     }
 250     else {
 251         /*
 252          * calculate depth of polygon
 253          * for now, try an average of the vertex depths
 254          */
 255         curpoly->depth =( list[0]->d3.z
 256                 + list[1]->d3.z
 257                 + list[2]->d3.z
 258                 + list[3]->d3.z)/4.0;
 259     }
 260     /*
 261      * store index to screen coordinates
 262      */
 263     curpoly->pt[0] = p0->d2;
 264     curpoly->pt[1] = p1->d2;
 265     curpoly->pt[2] = p2->d2;
 266     curpoly->pt[3] = p3->d2;
 267
 268     return(true);
 269 }
 270 /*
 271  * passable procedure for creating polygons without mapping
 272  */
 273 static
 274 void AcceptPoly(p0, p1, p2, p3)
 275     PtGen *p0, *p1, *p2, *p3;
 276 {
 277     if( CreatePoly(nextpoly, p0, p1, p2,p3)) {
 278         nextpoly++;
 279     }
 280 }
 281
 282 static
 283 void AcceptMPoly( p0, p1, p2, p3)
 284     PtGen *p0, *p1, *p2, *p3;
 285 {
 286     if( CreatePoly(&mnextpoly->rhom, p0, p1, p2,p3)) {
 287         mnextpoly->bezindex = RevImageB;
 288         mnextpoly->revindex = RevImageR;
 289         mnextpoly++;
 290     }
 291 }
 292
 293
 294
 295
 296
 297 /*
 298  * compare the depth of two polygons for SortPoly
 299  */
 300 static int CmpDepth( a, b )
 301         Rhomboid *a, *b;
 302 {
 303         if( a->depth < b->depth ) return(-1);
 304         else if( a->depth > b->depth ) return(1);
 305         else return(0);
 306 }
 307
 308 static int CmpMDepth( a, b )
 309         MapRhomboid *a, *b;
 310 {
 311         if( a->rhom.depth < b->rhom.depth ) return(-1);
 312         else if( a->rhom.depth > b->rhom.depth ) return(1);
 313         else return(0);
 314 }
 315
 316
 317
 318
 319
 320 void RevNoShade() {
 321         Rhomboid *i;
 322         if( GetNumSegs() < 1 ) {
 323                 return;
 324         }
 325
 326         ClrAbort();
 327         shadeflag = false;
 328         if( PrepPoly() ) return;
 329         if( Revolve(AcceptPoly) ) return;
 330         CurMode = NOTACTIVE;
 331
 332         qsort( (char *)polylist, nextpoly - polylist,
 333                 sizeof(Rhomboid), CmpDepth);
 334
 335         ClrWindow(false);
 336
 337         for( i = polylist; i< nextpoly; i++ ) {
 338             if( AbortDraw ) return;
 339                 DrawRhomFrame( i->pt );
 340         }
 341 }
 342
 343
 344
 345
 346 void RevShade() {
 347         register Rhomboid *i;
 348
 349         if( !AllocDither()) return; /* not enough memory */
 350         if( GetNumSegs() < 1 ) {
 351                 return;
 352         }
 353         CurMode = NOTACTIVE;
 354         ClrAbort();
 355         shadeflag = true;
 356         if( PrepPoly() || Revolve(AcceptPoly) ) {
 357             return;
 358         }
 359         qsort( (char *)polylist, nextpoly-polylist,
 360                 sizeof(Rhomboid), CmpDepth);
 361
 362         ClrWindow(false);
 363
 364         for( i = polylist; i< nextpoly; i++ ) {
 365                 if( AbortDraw ) return;
 366                 DrawRhomShade( i );
 367         }
 368 }
 369
 370
 371
 372 void RevMap() {
 373     register MapRhomboid *i;
 374
 375     ClrAbort();
 376     if( GetNumSegs() < 1 ) {
 377             return;
 378     }
 379     if( InitMapping() ) {
 380         return;
 381     }
 382     CurMode = NOTACTIVE;
 383     shadeflag = true;
 384
 385
 386     if( PrepMPoly() || Revolve(AcceptMPoly) ) {
 387         return;
 388     }
 389     qsort( (char *)mpolylist, mnextpoly-mpolylist,
 390         sizeof(MapRhomboid), CmpMDepth);
 391     ClrWindow(false);
 392
 393     for( i = mpolylist; i< mnextpoly; i++ ) {
 394             if( AbortDraw ) return;
 395             DrawRhomMap(i);
 396     }
 397 }