home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 January / usenetsourcesnewsgroupsinfomagicjanuary1994.iso / sources / misc / volume5 / tracer / refract.c < prev    next >
Encoding:
C/C++ Source or Header  |  1989-02-03  |  2.9 KB  |  132 lines
  1. #include <math.h>
  2. #include "rtd.h"
  3. #include "macros.h"
  4. #include "extern.h"
  5.  
  6. int    rlev;
  7. int     refract (r, bll)
  8. struct ray *r;
  9. struct ball *bll;
  10. {
  11.     struct vector   new,
  12.                     norm;
  13.     struct mat  trans;
  14.     struct ray  ir;
  15.     double  l,
  16.             refk (), getcapt (), capt, inside ();
  17.     double  stupid;
  18.     struct sphere   ss;
  19.  
  20.     SV (norm, r -> org, bll -> s.cent);
  21.     norm.l = bll-> s.rad;
  22.  
  23.     capt = getcapt (&norm, &(r -> dir), bll -> ior);
  24.  
  25.  
  26. /* get the addition factor for the normal for refraction*/
  27.     stupid = refk (&(norm), &(r -> dir), bll -> ior);
  28.     SCMLT (stupid, norm);
  29.  
  30.     AV (ir.dir, r -> dir, norm);
  31.     MV (r -> org.x, r -> org.y, r -> org.z, ir.org);
  32.  
  33. /* now get it for reflection */
  34.     SV (norm, r -> org, bll -> s.cent);
  35.     norm.l = bll -> s.rad;
  36.     SCMLT (1.0 / norm.l, norm);
  37.     stupid = 2.0 * DOT (norm, r -> dir);
  38.     SCMLT (stupid, norm);
  39.     SV (r -> dir, r -> dir, norm);
  40.  
  41.     return ((int) ((1.0 - capt) * (double) shade (r) + ((capt) * inside (&ir, bll))));
  42. }
  43.  
  44. double  inside (r, bll)
  45. struct ray *r;
  46. struct ball *bll;
  47. {
  48.     struct vector   new,
  49.                     norm;
  50.     struct mat  trans;
  51.     struct ray  er;
  52.     double  findo (), lght, l, refk (), getcapt (), capt;
  53.     double  stupid;
  54.     struct sphere   ss;
  55.  
  56.  
  57.     if (++rlev < RLEV) {
  58.     r -> dir.l = LEN (r -> dir);
  59.     r -> dir.xzl = XZL (r -> dir);
  60.     mt (&(r -> dir), &trans);
  61.     ss.rad = bll -> s.rad;
  62.     SV (ss.cent, bll -> s.cent, r -> org);
  63.  
  64.     l = findo (&trans, &ss);
  65.     MV (l * trans.x.x, l * trans.x.y, l * trans.x.z, new);
  66.     AV (er.org, r -> org, new);
  67.     AV (r -> org, r -> org, new);
  68.     SV (norm, er.org, bll -> s.cent);
  69.  
  70.     norm.l = bll -> s.rad;
  71.     capt = getcapt (&norm, &(r -> dir), 1.0 / bll -> ior);
  72.  
  73.     stupid = refk (&norm, &(r -> dir), 1.0 / bll -> ior);
  74.     SCMLT (stupid, norm);
  75.     AV (er.dir, norm, r -> dir);
  76.  
  77.     SCMLT (1.0 / norm.l, norm);
  78.     stupid = 2.0 * DOT (norm, r -> dir);
  79.     SCMLT (stupid, norm);
  80.     SV (r -> dir, r -> dir, norm);
  81.     lght = (1.0 - capt) * inside (r, bll) + (capt * (double) shade (&er));
  82.     }
  83.     else
  84.     lght = 0.0;
  85.     rlev--;
  86.      if (lght<0.0) lght=0.0;
  87.      if (lght>255.0) lght=255.0;
  88.     return (lght);
  89. }
  90.  
  91.  
  92.  
  93. double  refk (nrm, in, ior)
  94. struct vector  *nrm,
  95.                *in;
  96. double  ior;
  97. {
  98.     double  dt,
  99.             ln,
  100.             li,
  101.             ret;
  102.  
  103.     ior = ior * ior;
  104.     dt = DOT ((*nrm), (*in));
  105.     ln = LN2 ((*nrm));
  106.     li = LN2 ((*in));
  107.     if (dt < 0)
  108.     ret = (-dt - sqrt (dt * dt - ln * li * (1 - ior))) / ln;
  109.     else
  110.     ret = (-dt + sqrt (dt * dt - ln * li * (1 - ior))) / ln;
  111.     return (ret);
  112. }
  113.  
  114. double  getcapt (nrm, dr, ior)
  115. struct vector  *nrm,
  116.                *dr;
  117. double  ior;
  118. {
  119.     double  dt,
  120.             cs1,
  121.             cs2,
  122.             p,
  123.             s;
  124.     dt = DOT ((*nrm), (*dr));
  125.     dt = dt * dt / LN2 ((*nrm)) / LN2 ((*dr));
  126.     cs1 = sqrt (dt);
  127.     cs2 = sqrt (1.0 - (1.0 - dt) / ior);
  128.     p = cs1 / (cs1 + ior * cs2);
  129.     s = cs1 / (ior * cs1 + cs2);
  130.     return (2.0 * (p * p + s * s));
  131. }
  132.