home *** CD-ROM | disk | FTP | other *** search
/ Club Amiga de Montreal - CAM / CAM_CD_1.iso / files / 015.lha / tracer_source / find.c < prev    next >
C/C++ Source or Header  |  1986-11-10  |  2KB  |  164 lines
  1. #include <math.h>
  2. #include "MyMath.h"
  3. #include "rtd.h"
  4. #include "extern.h"
  5. #include "macros.h"
  6.  
  7. /* finds where a ray inside the ball exits. */
  8. FFP    findo (m, s)
  9. struct    mat    *m;
  10. register    struct    sphere    *s;
  11. {
  12.     /* foops id the rotated position vector. */
  13.     struct    vector    foops;
  14.     register    FFP    t;
  15.  
  16.     MTV (foops, (*m), s -> cent);
  17.  
  18.     /* see if it hits the ball (it better) */
  19.     t = SPSub(
  20.         SPMul(
  21.             foops.z,
  22.             foops.z
  23.         ),
  24.         SPSub(
  25.             SPMul(
  26.                 foops.y,
  27.                 foops.y
  28.             ),
  29.             SPMul(
  30.                 s -> rad,
  31.                 s -> rad
  32.             )
  33.         )
  34.     );
  35.  
  36.     if( SPTst(t) > 0 )
  37.         t = SPAdd(foops.x, SPSqrt(t));
  38.     else
  39.         t = SPFlt(0);
  40.  
  41.     /* return how far along the ray you were when you hit */
  42.     return (t);
  43. }
  44.  
  45. /* finds whether a ray hits a ball*/
  46. FFP    find(m, s)
  47. struct    mat    *m;
  48. register    struct    sphere    *s;
  49. {
  50.     struct    vector    foops;
  51.     register    FFP    t;
  52.  
  53.     MTV (foops, (*m), s -> cent);
  54.  
  55.     t = SPSub(
  56.         SPMul(
  57.             foops.z,
  58.             foops.z
  59.         ),
  60.         SPSub(
  61.             SPMul(
  62.                 foops.y,
  63.                 foops.y
  64.             ),
  65.             SPMul(
  66.                 s -> rad,
  67.                 s -> rad
  68.             )
  69.         )
  70.     );
  71.  
  72.     if( SPTst(t) > 0 )
  73.         t = SPSub(SPSqrt(t), foops.x);
  74.     else
  75.         t = SPFlt(0);
  76.  
  77.     return (t);
  78. }
  79.  
  80.  
  81. /*
  82.     finds if a ball is between a point and a 
  83.     lightsource. Returns how obscuring the ball is.
  84. */
  85. FFP    finds (m, s)
  86. struct    mat    *m;
  87. register    struct    sphere    *s;
  88. {
  89.     struct    vector    foops;
  90.     register    FFP    t;
  91.  
  92.     MTV (foops, (*m), s -> cent);
  93.  
  94.     t = SPSub(
  95.         SPSqrt (
  96.             SPAdd(
  97.                 SPMul(foops.y, foops.y),
  98.                 SPMul(foops.z, foops.z)
  99.             )
  100.         ),
  101.         s -> rad
  102.     );
  103.  
  104.     if (SPTst(t) > 0)
  105.         t = SPDiv(foops.x, t);
  106.     else
  107.         t = SPFlt(0);
  108.  
  109.     return (t);
  110. }
  111.  
  112. FFP    shadow (p)/* finds if a point is in a shadow, or if it is on edge */
  113. register    struct    vector    *p;
  114. {
  115.     struct    mat    trans;
  116.     struct    sphere    ss;
  117.     struct    vector    d;
  118.     int    c,
  119.         i;
  120.     register    FFP    l,
  121.                 k;
  122.     FFP    finds ();
  123.  
  124.     l = SPFlt(0);
  125.     c = -1;
  126.  
  127.     SV (d, ls.cent, (*p));
  128.     d.l = LEN (d);
  129.     d.xzl = XZL (d);
  130.     mt (&(d), &trans);
  131.  
  132.     for (i = 0; i < nob; i++) {
  133.         ss.rad = bl[i] -> s.rad;
  134.         SV (ss.cent, bl[i] -> s.cent, (*p));
  135.         if ( SPCmp( (k = finds (&trans, &ss)), l ) > 0 ) { /* ### */
  136.             c = i;
  137.             l = k;
  138.         }
  139.     }
  140.     if (c == -1)
  141.         k = SPFlt(200);
  142.     else {
  143.  
  144.         k = SPSub(
  145.             SPDiv(
  146.                 SPDiv( 
  147.                     (d.l),
  148.                     (ls.rad)
  149.                 ),
  150.                 l
  151.             ),
  152.             SPFlt(1)
  153.         );
  154. /*
  155.         k = 1.0 - l / ((ls.rad) / (d.l));
  156. */
  157.         if ( SPTst(k) < 0)
  158.             k = SPFlt(0);
  159.         k = SPMul(k, SPFlt(200));
  160.     }
  161.  
  162.     return (k);
  163. }
  164.