home *** CD-ROM | disk | FTP | other *** search
/ Otherware / Otherware_1_SB_Development.iso / mac / developm / source / povsrc.sit / SOURCE / LIGHTING.C < prev    next >
Encoding:
C/C++ Source or Header  |  1992-07-03  |  29.7 KB  |  927 lines
  1. /****************************************************************************
  2. *                   lighting.c
  3. *
  4. *  This module calculates lighting properties like ambient, diffuse, specular,
  5. *  reflection, refraction, etc.
  6. *
  7. *  from Persistence of Vision Raytracer 
  8. *  Copyright 1992 Persistence of Vision Team
  9. *---------------------------------------------------------------------------
  10. *  Copying, distribution and legal info is in the file povlegal.doc which
  11. *  should be distributed with this file. If povlegal.doc is not available
  12. *  or for more info please contact:
  13. *
  14. *       Drew Wells [POV-Team Leader] 
  15. *       CIS: 73767,1244  Internet: 73767.1244@compuserve.com
  16. *       Phone: (213) 254-4041
  17. * 
  18. * This program is based on the popular DKB raytracer version 2.12.
  19. * DKBTrace was originally written by David K. Buck.
  20. * DKBTrace Ver 2.0-2.12 were written by David K. Buck & Aaron A. Collins.
  21. *
  22. *****************************************************************************/
  23. #include "frame.h"
  24. #include "vector.h"
  25. #include "povproto.h"
  26.  
  27. extern int Trace_Level;
  28. extern FRAME Frame;
  29. extern unsigned int Options;
  30. extern int Quality;
  31. extern int Shadow_Test_Flag;
  32. extern long Shadow_Ray_Tests, Shadow_Rays_Succeeded;
  33. extern long Reflected_Rays_Traced, Refracted_Rays_Traced;
  34. extern long Transmitted_Rays_Traced;
  35.  
  36.  
  37.  
  38. #define COORDINATE_LIMIT 1.0e17
  39.  
  40. /* "Small_Tolerance" is just too tight for higher order polynomial equations.
  41.    this value should probably be a variable of some sort, but for now just
  42.    use a reasonably small value.  If people render real small objects real 
  43.    close to each other then there may be some shading problems.  Otherwise
  44.    having SHADOW_TOLERANCE as large as this won't affect images. */
  45. #define SHADOW_TOLERANCE 0.05
  46.  
  47. static void do_light PARAMS((LIGHT_SHAPE *Light_Source, DBL *Light_Source_Depth,
  48. RAY *Light_Source_Ray, VECTOR *Intersection_Point, COLOUR *Light_Colour));
  49. static int do_blocking PARAMS((INTERSECTION *Local_Intersection, 
  50. COLOUR *Light_Colour, PRIOQ *Local_Queue));
  51. static void do_phong PARAMS((TEXTURE *Texture, RAY *Light_Source_Ray,
  52. VECTOR Eye, VECTOR *Surface_Normal, COLOUR *Colour, COLOUR *Light_Colour,
  53. COLOUR *Surface_Colour));
  54. static void do_specular PARAMS((TEXTURE *Texture, RAY *Light_Source_Ray,
  55. VECTOR REye, VECTOR *Surface_Normal, COLOUR *Colour, COLOUR *Light_Colour,
  56. COLOUR *Surface_Colour));
  57. static void do_diffuse PARAMS((TEXTURE *Texture, RAY *Light_Source_Ray,
  58. VECTOR *Surface_Normal, COLOUR *Colour, COLOUR *Light_Colour,
  59. COLOUR *Surface_Colour, DBL Attenuation));
  60.  
  61.  
  62.  
  63.  
  64. void Colour_At (Colour, Texture, Intersection_Point)
  65. COLOUR *Colour;
  66. TEXTURE *Texture;
  67. VECTOR *Intersection_Point;
  68. {
  69.    register DBL x, y, z;
  70.    VECTOR Transformed_Point;
  71.  
  72.  
  73.    if ((Intersection_Point->x > COORDINATE_LIMIT) ||
  74.       (Intersection_Point->y > COORDINATE_LIMIT) ||
  75.       (Intersection_Point->z > COORDINATE_LIMIT) ||
  76.       (Intersection_Point->x < -COORDINATE_LIMIT) ||
  77.       (Intersection_Point->y < -COORDINATE_LIMIT) ||
  78.       (Intersection_Point->z < -COORDINATE_LIMIT))
  79.    {
  80.       Make_Vector (&Transformed_Point, 0.0, 0.0, 0.0);
  81.    }
  82.    else
  83.       if (Texture->Texture_Transformation) {
  84.          MInverseTransformVector (&Transformed_Point,
  85.             Intersection_Point,
  86.             Texture->Texture_Transformation);
  87.       }
  88.       else {
  89.          Transformed_Point = *Intersection_Point;
  90.       }
  91.  
  92.       x = Transformed_Point.x;
  93.    y = Transformed_Point.y;
  94.    z = Transformed_Point.z;
  95.  
  96.    switch (Texture->Texture_Number) {
  97.    case NO_TEXTURE:
  98.       /* No colouring texture has been specified - make it black. */
  99.       Make_Colour (Colour, 0.0, 0.0, 0.0);
  100.       Colour -> Alpha  = 0.0;
  101.       break;
  102.  
  103.    case COLOUR_TEXTURE:
  104.       Colour -> Red += Texture->Colour1->Red;
  105.       Colour -> Green += Texture->Colour1->Green;
  106.       Colour -> Blue += Texture->Colour1->Blue;
  107.       Colour -> Alpha += Texture->Colour1->Alpha;
  108.       break;
  109.  
  110.    case BOZO_TEXTURE: 
  111.       bozo (x, y, z, Texture, Colour);
  112.       break;
  113.  
  114.    case MARBLE_TEXTURE:
  115.       marble (x, y, z, Texture, Colour);
  116.       break;
  117.  
  118.    case WOOD_TEXTURE:
  119.       wood (x, y, z, Texture, Colour);
  120.       break;
  121.  
  122.    case BRICK_TEXTURE:
  123.       brick (x, y, z, Texture, Colour);
  124.       break;
  125.  
  126.    case CHECKER_TEXTURE:
  127.       checker (x, y, z, Texture, Colour);
  128.       break;
  129.  
  130.    case CHECKER_TEXTURE_TEXTURE:
  131.       checker_texture (x, y, z, Texture, Colour);
  132.       break;
  133.  
  134.    case SPOTTED_TEXTURE:
  135.       spotted (x, y, z, Texture, Colour);
  136.       break;
  137.  
  138.    case AGATE_TEXTURE:
  139.       agate (x, y, z, Texture, Colour);
  140.       break;
  141.  
  142.    case GRANITE_TEXTURE:
  143.       granite (x, y, z, Texture, Colour);
  144.       break;
  145.  
  146.    case GRADIENT_TEXTURE:
  147.       gradient (x, y, z, Texture, Colour);
  148.       break;
  149.  
  150.    case IMAGEMAP_TEXTURE:
  151.       image_map (x, y, z, Texture, Colour);
  152.       break;
  153.  
  154.    case ONION_TEXTURE:
  155.       onion (x, y, z, Texture, Colour);
  156.       break;
  157.  
  158.    case LEOPARD_TEXTURE:
  159.       leopard (x, y, z, Texture, Colour);
  160.       break;
  161.  
  162.    case PAINTED1_TEXTURE:
  163.       painted1 (x, y, z, Texture, Colour);
  164.       break;
  165.  
  166.    case PAINTED2_TEXTURE:
  167.       painted2 (x, y, z, Texture, Colour);
  168.       break;
  169.  
  170.    case PAINTED3_TEXTURE:
  171.       painted3 (x, y, z, Texture, Colour);
  172.       break;
  173.    }
  174. }
  175.  
  176.  
  177. void Perturb_Normal(New_Normal, Texture, Intersection_Point, Surface_Normal)
  178. VECTOR *New_Normal, *Intersection_Point, *Surface_Normal;
  179. TEXTURE *Texture;
  180. {
  181.    VECTOR Transformed_Point;
  182.    register DBL x, y, z;
  183.  
  184.    if (Texture->Bump_Number == NO_BUMPS) {
  185.       *New_Normal = *Surface_Normal;
  186.       return;
  187.    }
  188.  
  189.    if (Texture->Texture_Transformation)
  190.       MInverseTransformVector (&Transformed_Point,
  191.          Intersection_Point,
  192.          Texture->Texture_Transformation);
  193.    else
  194.       Transformed_Point = *Intersection_Point;
  195.  
  196.    x = Transformed_Point.x;
  197.    y = Transformed_Point.y;
  198.    z = Transformed_Point.z;
  199.  
  200.    switch (Texture->Bump_Number) {
  201.  
  202.    case WAVES: 
  203.       waves (x, y, z, Texture, New_Normal);
  204.       break;
  205.  
  206.    case RIPPLES: 
  207.       ripples (x, y, z, Texture, New_Normal);
  208.       break;
  209.  
  210.    case WRINKLES: 
  211.       wrinkles (x, y, z, Texture, New_Normal);
  212.       break;
  213.  
  214.    case BUMPS: 
  215.       bumps (x, y, z, Texture, New_Normal);
  216.       break;
  217.  
  218.    case DENTS: 
  219.       dents (x, y, z, Texture, New_Normal);
  220.       break; 
  221.  
  222.    case BUMPY1: 
  223.       bumpy1 (x, y, z, Texture, New_Normal);
  224.       break;
  225.  
  226.    case BUMPY2: 
  227.       bumpy2 (x, y, z, Texture, New_Normal);
  228.       break;
  229.  
  230.    case BUMPY3: 
  231.       bumpy3 (x, y, z, Texture, New_Normal);
  232.       break;
  233.  
  234.    case BUMPMAP: 
  235.       bump_map (x, y, z, Texture, New_Normal);
  236.       break;
  237.  
  238.    }
  239.    return;
  240. }
  241.  
  242. void Ambient (Texture, Surface_Colour, Colour, Attenuation)
  243. TEXTURE *Texture;
  244. COLOUR *Surface_Colour;
  245. COLOUR *Colour;
  246. DBL    Attenuation;
  247. {
  248.    if (Texture -> Object_Ambient == 0.0)
  249.       return;
  250.  
  251.    Colour->Red += Surface_Colour->Red * Texture->Object_Ambient * Attenuation;
  252.    Colour->Green += Surface_Colour->Green * Texture->Object_Ambient * Attenuation;
  253.    Colour->Blue += Surface_Colour->Blue * Texture->Object_Ambient * Attenuation;
  254.    return;
  255. }
  256.  
  257.  
  258. void Diffuse (Texture, Intersection_Point, Eye, Surface_Normal, Surface_Colour, Colour, Attenuation)
  259. TEXTURE *Texture;
  260. VECTOR *Intersection_Point, *Surface_Normal;
  261. COLOUR *Surface_Colour;
  262. COLOUR *Colour;
  263. RAY    *Eye;
  264. DBL    Attenuation;
  265. {
  266.    DBL Light_Source_Depth;
  267.    RAY Light_Source_Ray;
  268.    LIGHT_SHAPE *Light_Source;
  269.    OBJECT *Blocking_Object;
  270.    int Intersection_Found;
  271.    INTERSECTION *Local_Intersection;
  272.    VECTOR REye;
  273.    COLOUR Light_Colour;
  274.    PRIOQ *Local_Queue;
  275.  
  276.    if ((Texture -> Object_Diffuse == 0.0) &&
  277.       (Texture -> Object_Specular == 0.0) &&
  278.       (Texture -> Object_Phong == 0.0))
  279.       return;
  280.  
  281.    if (Texture -> Object_Specular != 0.0)
  282.    {
  283.       REye.x = -Eye->Direction.x;
  284.       REye.y = -Eye->Direction.y;
  285.       REye.z = -Eye->Direction.z;
  286.    }
  287.  
  288.    Local_Queue = pq_new (128);
  289.  
  290.    for (Light_Source = Frame.Light_Sources ; 
  291.           Light_Source != NULL;
  292.           Light_Source = Light_Source -> Next_Light_Source)
  293.    {
  294.       Intersection_Found = FALSE;
  295.  
  296.       do_light(Light_Source, &Light_Source_Depth, &Light_Source_Ray, Intersection_Point, &Light_Colour);
  297.  
  298.       /* What objects does this ray intersect? */
  299.       if (Quality > 3) {
  300.          Shadow_Test_Flag = TRUE;
  301.          for (Blocking_Object = Frame.Objects ; 
  302.                       Blocking_Object != NULL ;
  303.                       Blocking_Object = Blocking_Object -> Next_Object) {
  304.  
  305.             Shadow_Ray_Tests++;
  306.             for (All_Intersections (Blocking_Object, &Light_Source_Ray, Local_Queue) ;
  307.                         (Local_Intersection = pq_get_highest(Local_Queue)) != NULL ;
  308.                         pq_delete_highest(Local_Queue)) {
  309.  
  310.                if ((Local_Intersection -> Depth < Light_Source_Depth-Small_Tolerance)
  311.                   && (Local_Intersection -> Depth > SHADOW_TOLERANCE))
  312.  
  313.                   /* Does the object not cast a shadow? */
  314.                   if (!Local_Intersection -> Object -> No_Shadow_Flag)
  315.                      if (do_blocking(Local_Intersection, &Light_Colour, Local_Queue)) {
  316.                         Intersection_Found = TRUE;
  317.                         break;
  318.                      }
  319.             }
  320.             if (Intersection_Found)
  321.                break;
  322.          }
  323.          Shadow_Test_Flag = FALSE;
  324.       }
  325.  
  326.       /* If light source was not blocked by any intervening object, then
  327.        calculate it's contribution to the object's overall illumination */
  328.  
  329.       if (!Intersection_Found) {
  330.          if (Texture->Object_Phong >0.0) /* Phong Hilite */
  331.             do_phong(Texture,&Light_Source_Ray,Eye->Direction,Surface_Normal,Colour,&Light_Colour, Surface_Colour);
  332.  
  333.          if (Texture->Object_Specular >0.0) /* Specular Hilite */
  334.             do_specular(Texture,&Light_Source_Ray,REye,Surface_Normal,Colour,&Light_Colour, Surface_Colour);
  335.  
  336.          if (Texture->Object_Diffuse > 0.0) /* Normal Diffuse Illum. */
  337.             do_diffuse(Texture,&Light_Source_Ray,Surface_Normal,Colour,&Light_Colour,Surface_Colour, Attenuation);
  338.       }
  339.    }
  340.    pq_free (Local_Queue);
  341.    return;
  342. }
  343.  
  344.  
  345. static void do_light(Light_Source, Light_Source_Depth, Light_Source_Ray, Intersection_Point, Light_Colour)
  346. LIGHT_SHAPE *Light_Source;
  347. DBL *Light_Source_Depth;
  348. RAY *Light_Source_Ray;
  349. VECTOR *Intersection_Point;
  350. COLOUR *Light_Colour;
  351. {
  352.    DBL Attenuation = 1.0;
  353.  
  354.    /* Get the light source colour. */
  355.    if (Light_Source->Shape_Colour == NULL) {
  356.       Make_Colour (Light_Colour, 1.0, 1.0, 1.0);
  357.    }
  358.    else
  359.       *Light_Colour = *Light_Source->Shape_Colour;
  360.  
  361.    Light_Source_Ray->Initial = *Intersection_Point;
  362.    Light_Source_Ray->Quadric_Constants_Cached = FALSE;
  363.  
  364.    VSub (Light_Source_Ray->Direction,
  365.       Light_Source->Center,
  366.       *Intersection_Point);
  367.  
  368.    VLength (*Light_Source_Depth, Light_Source_Ray->Direction);
  369.  
  370.    VScale (Light_Source_Ray->Direction, Light_Source_Ray->Direction,
  371.       1.0/(*Light_Source_Depth));
  372.  
  373.    Attenuation = Attenuate_Light(Light_Source, Light_Source_Ray);
  374.  
  375.    /* Now scale the color by the attenuation */
  376.    Light_Colour->Red   *= Attenuation;
  377.    Light_Colour->Green *= Attenuation;
  378.    Light_Colour->Blue  *= Attenuation;
  379.  
  380.  
  381.    return;
  382. }
  383.  
  384. static int do_blocking(Local_Intersection, Light_Colour, Local_Queue)
  385. INTERSECTION *Local_Intersection;
  386. COLOUR *Light_Colour;
  387. PRIOQ *Local_Queue;
  388. {
  389.    Shadow_Rays_Succeeded++;
  390.  
  391.    Determine_Surface_Colour (Local_Intersection, Light_Colour, NULL, TRUE);
  392.  
  393.    if ((Light_Colour->Red < 0.01) && (Light_Colour->Green < 0.01)
  394.       && (Light_Colour->Blue < 0.01)) {
  395.  
  396.       while (pq_get_highest(Local_Queue))
  397.          pq_delete_highest(Local_Queue);
  398.       return(TRUE);
  399.    }
  400.    return(FALSE);
  401. }
  402.  
  403. static void do_phong(Texture, Light_Source_Ray, Eye, Surface_Normal, Colour, Light_Colour, Surface_Colour)
  404. TEXTURE *Texture;
  405. RAY *Light_Source_Ray;
  406. VECTOR *Surface_Normal, Eye;
  407. COLOUR *Colour, *Light_Colour, *Surface_Colour;
  408. {
  409.    DBL Cos_Angle_Of_Incidence, Normal_Length, Intensity;
  410.    VECTOR Local_Normal, Normal_Projection, Reflect_Direction;
  411.  
  412.    VDot(Cos_Angle_Of_Incidence, Eye, *Surface_Normal);
  413.  
  414.    if (Cos_Angle_Of_Incidence < 0.0)
  415.    {
  416.       Local_Normal = *Surface_Normal;
  417.       Cos_Angle_Of_Incidence = -Cos_Angle_Of_Incidence;
  418.    }
  419.    else
  420.    {
  421.       VScale (Local_Normal, *Surface_Normal, -1.0);
  422.    }
  423.  
  424.    VScale (Normal_Projection, Local_Normal, Cos_Angle_Of_Incidence);
  425.    VScale (Normal_Projection, Normal_Projection, 2.0);
  426.    VAdd (Reflect_Direction, Eye, Normal_Projection);
  427.  
  428.    VDot (Cos_Angle_Of_Incidence, Reflect_Direction, Light_Source_Ray->Direction);
  429.    VLength (Normal_Length, Light_Source_Ray->Direction);
  430.  
  431.    if (Normal_Length == 0.0)
  432.       Cos_Angle_Of_Incidence = 0.0;
  433.    else Cos_Angle_Of_Incidence /= Normal_Length;
  434.  
  435.       if (Cos_Angle_Of_Incidence < 0.0)
  436.          Cos_Angle_Of_Incidence = 0;
  437.  
  438.    if (Texture -> Object_PhongSize != 1.0)
  439.       Intensity = pow(Cos_Angle_Of_Incidence, Texture->Object_PhongSize);
  440.    else
  441.       Intensity = Cos_Angle_Of_Incidence;
  442.  
  443.    Intensity *= Texture -> Object_Phong;
  444.  
  445.    if (Texture->Metallic_Flag) {
  446.       Colour->Red+=Intensity*(Surface_Colour->Red);
  447.       Colour->Green+=Intensity*(Surface_Colour->Green);
  448.       Colour->Blue+=Intensity*(Surface_Colour->Blue);
  449.    }
  450.    else {
  451.       Colour->Red+=Intensity*(Light_Colour->Red);
  452.       Colour->Green+=Intensity*(Light_Colour->Green);
  453.       Colour->Blue+=Intensity*(Light_Colour->Blue);
  454.    }
  455.    return;
  456. }
  457.  
  458.    static void do_specular(Texture, Light_Source_Ray, REye, Surface_Normal, Colour, Light_Colour, Surface_Colour)
  459.       TEXTURE *Texture;
  460. RAY *Light_Source_Ray;
  461. VECTOR *Surface_Normal, REye;
  462. COLOUR *Colour, *Light_Colour, *Surface_Colour;
  463. {
  464.    DBL Cos_Angle_Of_Incidence, Normal_Length, Intensity, Halfway_Length, Roughness;
  465.    VECTOR Halfway;
  466.  
  467.    VHalf (Halfway, REye, Light_Source_Ray->Direction);
  468.    VLength (Normal_Length, *Surface_Normal);
  469.    VLength (Halfway_Length, Halfway);
  470.    VDot (Cos_Angle_Of_Incidence, Halfway, *Surface_Normal);
  471.  
  472.    if (Normal_Length == 0.0 || Halfway_Length == 0.0)
  473.       Cos_Angle_Of_Incidence = 0.0;
  474.    else Cos_Angle_Of_Incidence /= (Normal_Length * Halfway_Length);
  475.  
  476.       if (Cos_Angle_Of_Incidence < 0.0)
  477.          Cos_Angle_Of_Incidence = 0.0;
  478.  
  479.    Roughness = 1.0 / Texture->Object_Roughness;
  480.  
  481.    if (Roughness != 1.0)
  482.       Intensity = pow(Cos_Angle_Of_Incidence, Roughness);
  483.    else
  484.       Intensity = Cos_Angle_Of_Incidence;
  485.    Intensity *= Texture->Object_Specular;
  486.    if (Texture->Metallic_Flag) {
  487.       Colour->Red+=Intensity*(Surface_Colour->Red);
  488.       Colour->Green+=Intensity*(Surface_Colour->Green);
  489.       Colour->Blue+=Intensity*(Surface_Colour->Blue);
  490.    }
  491.    else {
  492.       Colour->Red+=Intensity*(Light_Colour->Red);
  493.       Colour->Green+=Intensity*(Light_Colour->Green);
  494.       Colour->Blue+=Intensity*(Light_Colour->Blue);
  495.    }
  496.    return;
  497. }
  498.  
  499.    static void do_diffuse(Texture, Light_Source_Ray, Surface_Normal, Colour, Light_Colour, Surface_Colour, Attenuation)
  500.       TEXTURE *Texture;
  501. RAY *Light_Source_Ray;
  502. VECTOR *Surface_Normal;
  503. COLOUR *Colour, *Light_Colour, *Surface_Colour;
  504. DBL Attenuation;
  505. {
  506.    DBL Cos_Angle_Of_Incidence, Intensity, RandomNumber;
  507.  
  508.    VDot (Cos_Angle_Of_Incidence, *Surface_Normal, Light_Source_Ray->Direction);
  509.    if (Cos_Angle_Of_Incidence < 0.0)
  510.       Cos_Angle_Of_Incidence = -Cos_Angle_Of_Incidence;
  511.  
  512.    if (Texture -> Object_Brilliance != 1.0)
  513.       Intensity = pow(Cos_Angle_Of_Incidence, Texture->Object_Brilliance);
  514.    else
  515.       Intensity = Cos_Angle_Of_Incidence;
  516.  
  517.    Intensity *= Texture -> Object_Diffuse * Attenuation;
  518.  
  519.    RandomNumber = (rand()&0x7FFF)/(DBL) 0x7FFF;
  520.  
  521.    Intensity -= RandomNumber * Texture->Texture_Randomness;
  522.  
  523.    Colour->Red += Intensity * (Surface_Colour->Red) * (Light_Colour->Red);
  524.    Colour->Green += Intensity * (Surface_Colour->Green) * (Light_Colour->Green);
  525.    Colour->Blue += Intensity * (Surface_Colour->Blue) * (Light_Colour->Blue);
  526.    return;
  527. }
  528.  
  529. void Reflect (Texture, Intersection_Point, Ray, Surface_Normal, Colour)
  530. TEXTURE *Texture;
  531. VECTOR *Intersection_Point;
  532. RAY *Ray;
  533. VECTOR *Surface_Normal;
  534. COLOUR *Colour;
  535. {
  536.    RAY New_Ray;
  537.    COLOUR Temp_Colour;
  538.    VECTOR Local_Normal;
  539.    VECTOR Normal_Projection;
  540.    VECTOR Surface_Offset;
  541.    register DBL Normal_Component;
  542.  
  543.    if (Texture -> Object_Reflection != 0.0)
  544.       {
  545.       Reflected_Rays_Traced++;
  546.       VDot (Normal_Component, Ray -> Direction, *Surface_Normal);
  547.       if (Normal_Component < 0.0) {
  548.          Local_Normal = *Surface_Normal;
  549.          Normal_Component *= -1.0;
  550.       }
  551.       else
  552.          VScale (Local_Normal, *Surface_Normal, -1.0);
  553.  
  554.       VScale (Normal_Projection, Local_Normal, Normal_Component);
  555.       VScale (Normal_Projection, Normal_Projection, 2.0);
  556.       VAdd (New_Ray.Direction, Ray -> Direction, Normal_Projection);
  557.       New_Ray.Initial = *Intersection_Point;
  558.  
  559.       /* ARE 08/25/91 */
  560.  
  561.       VScale(Surface_Offset, New_Ray.Direction, 2.0 * Small_Tolerance); 
  562.       VAdd(New_Ray.Initial, New_Ray.Initial, Surface_Offset);           
  563.  
  564.       Copy_Ray_Containers (&New_Ray, Ray);
  565.       Trace_Level++;
  566.       Make_Colour (&Temp_Colour, 0.0, 0.0, 0.0);
  567.       New_Ray.Quadric_Constants_Cached = FALSE;
  568.       Trace (&New_Ray, &Temp_Colour);
  569.       Trace_Level--;
  570.  
  571.       Colour -> Red += Temp_Colour.Red 
  572.       * Texture -> Object_Reflection;
  573.       Colour -> Green += Temp_Colour.Green
  574.       * Texture -> Object_Reflection;
  575.       Colour -> Blue += Temp_Colour.Blue
  576.       * Texture -> Object_Reflection;
  577.  
  578.    }
  579. }
  580.  
  581. void Refract (Texture, Intersection_Point, Ray, Surface_Normal, Colour)
  582. TEXTURE *Texture;
  583. VECTOR *Intersection_Point;
  584. RAY *Ray;
  585. VECTOR *Surface_Normal;
  586. COLOUR *Colour;
  587. {
  588.    RAY New_Ray;
  589.    COLOUR Temp_Colour;
  590.    VECTOR Local_Normal;
  591.    VECTOR Ray_Direction;
  592.    register DBL Normal_Component, Temp_IOR;
  593.    DBL temp, ior;
  594.    int inside;
  595.  
  596.    if (Surface_Normal == NULL) {
  597.       New_Ray.Initial = *Intersection_Point;
  598.       New_Ray.Direction = Ray->Direction;
  599.  
  600.       Copy_Ray_Containers (&New_Ray, Ray);
  601.       Trace_Level++;
  602.       Transmitted_Rays_Traced++;
  603.       Make_Colour (&Temp_Colour, 0.0, 0.0, 0.0);
  604.       New_Ray.Quadric_Constants_Cached = FALSE;
  605.       Trace (&New_Ray, &Temp_Colour);
  606.       Trace_Level--;
  607.       (Colour -> Red) += Temp_Colour.Red;
  608.       (Colour -> Green) += Temp_Colour.Green;
  609.       (Colour -> Blue) += Temp_Colour.Blue;
  610.    }
  611.       else {
  612.          Refracted_Rays_Traced++;
  613.          VDot (Normal_Component, Ray -> Direction, *Surface_Normal);
  614.          if (Normal_Component <= 0.0)
  615.             {
  616.             Local_Normal.x = Surface_Normal -> x;
  617.             Local_Normal.y = Surface_Normal -> y;
  618.             Local_Normal.z = Surface_Normal -> z;
  619.             Normal_Component *= -1.0;
  620.             inside = FALSE;
  621.          }
  622.          else
  623.          {
  624.             VScale (Local_Normal, *Surface_Normal, -1.0);
  625.             inside = TRUE;
  626.          }
  627.  
  628.  
  629.          Copy_Ray_Containers (&New_Ray, Ray);
  630.  
  631.          if (Ray -> Containing_Index == -1)
  632.             {
  633.             /* The ray is entering from the atmosphere */
  634.             Ray_Enter (&New_Ray, Texture);
  635.             ior = (Frame.Atmosphere_IOR)/(Texture -> Object_Index_Of_Refraction);
  636.          }
  637.          else
  638.          {
  639.             /* The ray is currently inside an object */
  640.             if (New_Ray.Containing_Textures [New_Ray.Containing_Index] == Texture) 
  641.                /*         if (inside) */
  642.             {
  643.                /* The ray is leaving the current object */
  644.                Ray_Exit (&New_Ray);
  645.                if (New_Ray.Containing_Index == -1)
  646.                   /* The ray is leaving into the atmosphere */
  647.                Temp_IOR = Frame.Atmosphere_IOR;
  648.                else
  649.                   /* The ray is leaving into another object */
  650.                   Temp_IOR = New_Ray.Containing_IORs [New_Ray.Containing_Index];
  651.  
  652.                ior =  (Texture -> Object_Index_Of_Refraction)/Temp_IOR;
  653.             }
  654.                else
  655.                {
  656.                   /* The ray is entering a new object */
  657.                   Temp_IOR = New_Ray.Containing_IORs [New_Ray.Containing_Index];
  658.                   Ray_Enter (&New_Ray, Texture);
  659.  
  660.                   ior =  Temp_IOR / (Texture -> Object_Index_Of_Refraction);
  661.                }
  662.             }
  663.  
  664.             temp = 1.0 + ior * ior * (Normal_Component * Normal_Component - 1.0);
  665.             if (temp < 0.0) {
  666.                /* Total internal reflection - not yet implemented.
  667.      Reflect (Texture, Intersection_Point, Ray, Surface_Normal, Color);
  668.      */
  669.                return;
  670.             }
  671.  
  672.             temp = ior*Normal_Component - sqrt(temp);
  673.             VScale (Local_Normal, Local_Normal, temp);
  674.             VScale (Ray_Direction, Ray->Direction, ior);
  675.             VAdd (New_Ray.Direction, Local_Normal, Ray_Direction);
  676.             VNormalize (New_Ray.Direction, New_Ray.Direction);
  677.  
  678.             New_Ray.Initial = *Intersection_Point;
  679.             Trace_Level++;
  680.             Make_Colour (&Temp_Colour, 0.0, 0.0, 0.0);
  681.             New_Ray.Quadric_Constants_Cached = FALSE;
  682.  
  683.             Trace (&New_Ray, &Temp_Colour);
  684.             Trace_Level--;
  685.  
  686.             (Colour -> Red) += (Temp_Colour.Red)
  687.                * (Texture -> Object_Refraction);
  688.             (Colour -> Green) += (Temp_Colour.Green)
  689.                * (Texture -> Object_Refraction);
  690.             (Colour -> Blue) += (Temp_Colour.Blue)
  691.                * (Texture -> Object_Refraction);
  692.          }
  693.       }
  694.  
  695.       void Fog (Distance, Fog_Colour, Fog_Distance, Colour)
  696.          DBL Distance, Fog_Distance;
  697.       COLOUR *Fog_Colour, *Colour;
  698.       {
  699.          DBL Fog_Factor, Fog_Factor_Inverse;
  700.  
  701.          Fog_Factor = exp(-1.0 * Distance/Fog_Distance);
  702.          Fog_Factor_Inverse = 1.0 - Fog_Factor;
  703.          Colour->Red = Colour->Red*Fog_Factor + Fog_Colour->Red*Fog_Factor_Inverse;
  704.          Colour->Green = Colour->Green*Fog_Factor + Fog_Colour->Green*Fog_Factor_Inverse;
  705.          Colour->Blue = Colour->Blue*Fog_Factor + Fog_Colour->Blue*Fog_Factor_Inverse;
  706.       }
  707.  
  708.  
  709.  
  710.       void Compute_Reflected_Colour (Ray, Texture, Ray_Intersection, Surface_Colour, Filter_Colour, Colour)
  711.          RAY *Ray;
  712.       TEXTURE *Texture;
  713.       INTERSECTION *Ray_Intersection;
  714.       COLOUR *Surface_Colour;
  715.       COLOUR *Filter_Colour;
  716.       COLOUR *Colour;
  717.       {
  718.          VECTOR Surface_Normal;
  719.          DBL Normal_Direction, Attenuation;
  720.          COLOUR Emitted_Colour;
  721.  
  722.          /* This variable keeps track of how much colour comes from the surface
  723.       of the object and how much is transmited through. */
  724.  
  725.          Make_Colour (&Emitted_Colour, 0.0, 0.0, 0.0);
  726.  
  727.          if (Texture == NULL)
  728.             Texture = Ray_Intersection->Object->Object_Texture;
  729.  
  730.          if (Quality <= 1) {
  731.             Surface_Colour->Alpha = 0.0;
  732.  
  733.             Colour->Red   += Surface_Colour->Red * Filter_Colour->Alpha;
  734.             Colour->Green += Surface_Colour->Green * Filter_Colour->Alpha;
  735.             Colour->Blue  += Surface_Colour->Blue * Filter_Colour->Alpha;
  736.             return;
  737.          }
  738.  
  739.          Normal (&Surface_Normal, (OBJECT *) Ray_Intersection -> Shape,
  740.          &Ray_Intersection -> Point);
  741.  
  742.          if (Quality >= 8) {
  743.             Perturb_Normal (&Surface_Normal, Texture,
  744.             &Ray_Intersection->Point, &Surface_Normal);
  745.          }
  746.  
  747.          /* If the surface normal points away, flip its direction. */
  748.          VDot (Normal_Direction, Surface_Normal, Ray->Direction);
  749.          if (Normal_Direction > 0.0) {
  750.             VScale (Surface_Normal, Surface_Normal, -1.0);
  751.          }
  752.  
  753.          Attenuation = Filter_Colour->Alpha * (1.0 - Surface_Colour->Alpha);
  754.  
  755.  
  756.          Ambient (Texture, Surface_Colour, &Emitted_Colour, Attenuation);
  757.          Diffuse (Texture, &Ray_Intersection -> Point, Ray,
  758.          &Surface_Normal, Surface_Colour, &Emitted_Colour, Attenuation);
  759.          Colour->Red   += Emitted_Colour.Red;
  760.          Colour->Green += Emitted_Colour.Green;
  761.          Colour->Blue  += Emitted_Colour.Blue;
  762.          if (Quality >= 8)
  763.             Reflect (Texture, &Ray_Intersection -> Point, Ray,
  764.          &Surface_Normal, Colour); 
  765.       }
  766.  
  767.       void Determine_Surface_Colour (Ray_Intersection, Colour, Ray, Shadow_Ray)
  768.          INTERSECTION *Ray_Intersection;
  769.       COLOUR *Colour;
  770.       RAY *Ray;
  771.       int Shadow_Ray;
  772.       {
  773.          COLOUR Surface_Colour, Refracted_Colour, Filter_Colour;
  774.          TEXTURE *Temp_Texture, *Texture;
  775.          VECTOR Surface_Normal;
  776.          DBL Normal_Direction;
  777.          int surface;
  778.  
  779.          if (!Shadow_Ray)
  780.             Make_Colour (Colour, 0.0, 0.0, 0.0);
  781.  
  782.          if (Options & DEBUGGING)
  783.             if (Ray_Intersection->Shape->Shape_Colour)
  784.             printf ("Depth: %f Object %d Colour %f %f %f ", Ray_Intersection->Depth,
  785.          Ray_Intersection->Shape->Type,
  786.          Ray_Intersection->Shape->Shape_Colour->Red,
  787.          Ray_Intersection->Shape->Shape_Colour->Green,
  788.          Ray_Intersection->Shape->Shape_Colour->Blue);
  789.          else
  790.             printf ("Depth: %f Object %d Colour NIL ", Ray_Intersection->Depth,
  791.             Ray_Intersection->Shape->Type);
  792.  
  793.  
  794.          Make_Colour (&Surface_Colour, 0.0, 0.0, 0.0);
  795.  
  796.          /* Is there a texture in the shape?  If not, use the one in the object. */
  797.          if ((Texture = Ray_Intersection->Shape->Shape_Texture) == NULL) {
  798.             Texture = Ray_Intersection->Object->Object_Texture;      
  799.          }
  800.          /* Check to see if this object/shape has a material_map texture, if so */
  801.          /* then change the texture pointer to point to the mapped texture - CdW 7/91 */
  802.          if(Texture->Texture_Number == MATERIAL_MAP_TEXTURE)  
  803.             Texture = material_map(&Ray_Intersection->Point, Texture);
  804.  
  805.  
  806.  
  807.          /* If this is just a shadow ray and we're rendering low quality, then return */
  808.  
  809.          if (Shadow_Ray && (Quality <= 5))
  810.             return;
  811.  
  812.          Make_Colour (&Filter_Colour, 1.0, 1.0, 1.0);
  813.          Filter_Colour.Alpha = 1.0;
  814.  
  815.          /* Now, we perform the lighting calculations. */
  816.          for ( surface = 1 , Temp_Texture = Texture;
  817.                 (Temp_Texture != NULL) && (Filter_Colour.Alpha > 0.01) ;
  818.                 surface++, Temp_Texture = Temp_Texture->Next_Texture) {
  819.  
  820.             Make_Colour (&Surface_Colour, 0.0, 0.0, 0.0);
  821.             if (Quality <= 5) {
  822.                if (Ray_Intersection->Shape->Shape_Colour != NULL)
  823.                   Surface_Colour = *Ray_Intersection->Shape->Shape_Colour;
  824.             else if (Ray_Intersection->Object->Object_Colour != NULL)
  825.                Surface_Colour = *Ray_Intersection->Object->Object_Colour;
  826.             else {
  827.                Make_Colour (&Surface_Colour, 0.5, 0.5, 0.5);
  828.             }
  829.          }
  830.          else
  831.             Colour_At (&Surface_Colour,
  832.             Temp_Texture,
  833.             &Ray_Intersection -> Point);
  834.          /* We don't need to compute the lighting characteristics for shadow rays. */
  835.          if (!Shadow_Ray) {
  836.             Compute_Reflected_Colour (Ray,
  837.             Temp_Texture,
  838.             Ray_Intersection,
  839.             &Surface_Colour,
  840.             &Filter_Colour,
  841.             Colour);
  842.  
  843.          }
  844.  
  845.          if (Options & DEBUGGING) {
  846.             printf ("Surface %d\n", surface);
  847.             printf ("   Surf: %6.4f %6.4f %6.4f %6.4f\n",
  848.             Surface_Colour.Red, Surface_Colour.Green, Surface_Colour.Blue, Surface_Colour.Alpha);
  849.             printf ("   Filter_Colour:   %6.4f %6.4f %6.4f %6.4f  Final Colour: %6.4f %6.4f %6.4f %6.4f  \n",
  850.             Filter_Colour.Red, Filter_Colour.Green, Filter_Colour.Blue, Filter_Colour.Alpha,
  851.             Colour->Red, Colour->Green, Colour->Blue, Colour->Alpha);
  852.          }
  853.  
  854.          Filter_Colour.Red   *= Surface_Colour.Red;
  855.          Filter_Colour.Green *= Surface_Colour.Green;
  856.          Filter_Colour.Blue  *= Surface_Colour.Blue;
  857.  
  858.          Filter_Colour.Alpha *= Surface_Colour.Alpha;
  859.       }
  860.  
  861.       /* For shadow rays, we have the filter colour now - time to return */
  862.       if (Shadow_Ray) {
  863.  
  864.          if (Filter_Colour.Alpha < 0.01) {
  865.             Make_Colour (Colour, 0.0, 0.0, 0.0);
  866.             return;
  867.          }
  868.  
  869.          if (Texture->Object_Refraction > 0.0) {
  870.             Colour->Red *= Filter_Colour.Red * Texture->Object_Refraction * Filter_Colour.Alpha;
  871.             Colour->Green *= Filter_Colour.Green * Texture->Object_Refraction * Filter_Colour.Alpha;
  872.             Colour->Blue *= Filter_Colour.Blue * Texture->Object_Refraction * Filter_Colour.Alpha;
  873.          }
  874.          else {
  875.             Colour->Red *= Filter_Colour.Red * Filter_Colour.Alpha;
  876.             Colour->Green *= Filter_Colour.Green * Filter_Colour.Alpha;
  877.             Colour->Blue *= Filter_Colour.Blue * Filter_Colour.Alpha;
  878.          }
  879.          return;
  880.       }
  881.  
  882.          if ((Filter_Colour.Alpha > 0.01) && (Quality > 5)) {
  883.             Make_Colour (&Refracted_Colour, 0.0, 0.0, 0.0);
  884.  
  885.             if (Texture->Object_Refraction > 0.0) {
  886.                Normal (&Surface_Normal, (OBJECT *) Ray_Intersection -> Shape,
  887.                &Ray_Intersection -> Point);
  888.  
  889.                if (Quality > 7) {
  890.                   Perturb_Normal (&Surface_Normal, Texture,
  891.                   &Ray_Intersection->Point, &Surface_Normal);
  892.                }
  893.  
  894.             /* If the surface normal points away, flip its direction. */
  895.             VDot (Normal_Direction, Surface_Normal, Ray->Direction);
  896.             if (Normal_Direction > 0.0) {
  897.                VScale (Surface_Normal, Surface_Normal, -1.0);
  898.             }
  899.  
  900.             Refract (Texture, &Ray_Intersection -> Point, Ray,
  901.             &Surface_Normal, &Refracted_Colour);
  902.          }
  903.             else
  904.                Refract (Texture, &Ray_Intersection->Point, Ray,
  905.                NULL, &Refracted_Colour);
  906.  
  907.             Colour->Red += Filter_Colour.Red * Refracted_Colour.Red * Filter_Colour.Alpha;
  908.             Colour->Green += Filter_Colour.Green * Refracted_Colour.Green * Filter_Colour.Alpha;
  909.             Colour->Blue += Filter_Colour.Blue * Refracted_Colour.Blue * Filter_Colour.Alpha;
  910.  
  911.             if (Texture->Object_Refraction > 0.0 &&
  912.             Texture->Object_Transmit > 0.0) {
  913.                Make_Colour (&Refracted_Colour, 0.0, 0.0, 0.0);
  914.                Refract (Texture, &Ray_Intersection->Point, Ray,
  915.                NULL, &Refracted_Colour);
  916.                Colour->Red += Filter_Colour.Red * Refracted_Colour.Red * Filter_Colour.Alpha;
  917.                Colour->Green += Filter_Colour.Green * Refracted_Colour.Green * Filter_Colour.Alpha;
  918.                Colour->Blue += Filter_Colour.Blue * Refracted_Colour.Blue * Filter_Colour.Alpha;
  919.             }
  920.          }
  921.  
  922.          if (Frame.Fog_Distance != 0.0)  {
  923.             Fog (Ray_Intersection->Depth, &Frame.Fog_Colour, Frame.Fog_Distance,
  924.             Colour);
  925.          }
  926.       }
  927.