home *** CD-ROM | disk | FTP | other *** search
/ Otherware / Otherware_1_SB_Development.iso / mac / developm / source / povsrc.sit / SOURCE / SPHERES.C < prev    next >
Encoding:
C/C++ Source or Header  |  1992-07-03  |  6.5 KB  |  222 lines
  1. /****************************************************************************
  2. *                spheres.c
  3. *
  4. *  This module implements the sphere primitive.
  5. *
  6. *  from Persistence of Vision Raytracer 
  7. *  Copyright 1992 Persistence of Vision Team
  8. *---------------------------------------------------------------------------
  9. *  Copying, distribution and legal info is in the file povlegal.doc which
  10. *  should be distributed with this file. If povlegal.doc is not available
  11. *  or for more info please contact:
  12. *
  13. *       Drew Wells [POV-Team Leader] 
  14. *       CIS: 73767,1244  Internet: 73767.1244@compuserve.com
  15. *       Phone: (213) 254-4041
  16. * 
  17. * This program is based on the popular DKB raytracer version 2.12.
  18. * DKBTrace was originally written by David K. Buck.
  19. * DKBTrace Ver 2.0-2.12 were written by David K. Buck & Aaron A. Collins.
  20. *
  21. *****************************************************************************/
  22.  
  23. #include "frame.h"
  24. #include "vector.h"
  25. #include "povproto.h"
  26.  
  27. METHODS Sphere_Methods =
  28. { Object_Intersect, All_Sphere_Intersections,
  29.    Inside_Sphere, Sphere_Normal,
  30.    Copy_Sphere,
  31.    Translate_Sphere, Rotate_Sphere,
  32.    Scale_Sphere, Invert_Sphere};
  33.  
  34. extern SPHERE *Get_Sphere_Shape();
  35.  
  36. extern RAY *VP_Ray;
  37. extern long Ray_Sphere_Tests, Ray_Sphere_Tests_Succeeded;
  38.  
  39. int All_Sphere_Intersections (Object, Ray, Depth_Queue)
  40. OBJECT *Object;
  41. RAY *Ray;
  42. PRIOQ *Depth_Queue;
  43. {
  44.    DBL Depth1, Depth2;
  45.    VECTOR Intersection_Point;
  46.    INTERSECTION Local_Element;
  47.    register int Intersection_Found;
  48.    SPHERE *Shape = (SPHERE *) Object;
  49.  
  50.    Intersection_Found = FALSE;
  51.    if (Intersect_Sphere (Ray, Shape, &Depth1, &Depth2))
  52.    {
  53.       Local_Element.Depth = Depth1;
  54.       Local_Element.Object = Shape -> Parent_Object;
  55.       VScale (Intersection_Point, Ray -> Direction, Depth1);
  56.       VAdd (Intersection_Point, Intersection_Point, Ray -> Initial);
  57.       Local_Element.Point = Intersection_Point;
  58.       Local_Element.Shape = (SHAPE *)Shape;
  59.       pq_add (Depth_Queue, &Local_Element);
  60.       Intersection_Found = TRUE;
  61.  
  62.       if (Depth2 != Depth1)
  63.       {
  64.          Local_Element.Depth = Depth2;
  65.          Local_Element.Object = Shape -> Parent_Object;
  66.          VScale (Intersection_Point, Ray -> Direction, Depth2);
  67.          VAdd (Intersection_Point, Intersection_Point, Ray -> Initial);
  68.          Local_Element.Point = Intersection_Point;
  69.          Local_Element.Shape = (SHAPE *) Shape;
  70.          pq_add (Depth_Queue, &Local_Element);
  71.          Intersection_Found = TRUE;
  72.       }
  73.    }
  74.    return (Intersection_Found);
  75. }
  76.  
  77. int Intersect_Sphere (Ray, Sphere, Depth1, Depth2)
  78. RAY *Ray;
  79. SPHERE *Sphere;
  80. DBL *Depth1, *Depth2;
  81. {
  82.    VECTOR Origin_To_Center;
  83.    DBL OCSquared, t_Closest_Approach, Half_Chord, t_Half_Chord_Squared;
  84.    short inside;
  85.  
  86.    Ray_Sphere_Tests++;
  87.    if (Ray == VP_Ray) {
  88.       if (!Sphere->VPCached) {
  89.          VSub (Sphere->VPOtoC, Sphere->Center, Ray->Initial);
  90.          VDot (Sphere->VPOCSquared, Sphere->VPOtoC, Sphere->VPOtoC);
  91.          Sphere->VPinside = (Sphere->VPOCSquared < Sphere->Radius_Squared);
  92.          Sphere->VPCached = TRUE;
  93.       }
  94.       VDot (t_Closest_Approach, Sphere->VPOtoC, Ray->Direction);
  95.       if (!Sphere->VPinside && (t_Closest_Approach < Small_Tolerance))
  96.          return (FALSE);      
  97.       t_Half_Chord_Squared = Sphere->Radius_Squared - Sphere->VPOCSquared +
  98.       (t_Closest_Approach * t_Closest_Approach);
  99.    }
  100.    else {
  101.       VSub (Origin_To_Center, Sphere->Center, Ray->Initial);
  102.       VDot (OCSquared, Origin_To_Center, Origin_To_Center);
  103.       inside = (OCSquared < Sphere->Radius_Squared);
  104.       VDot (t_Closest_Approach, Origin_To_Center, Ray->Direction);
  105.       if (!inside && (t_Closest_Approach < Small_Tolerance))
  106.          return (FALSE);
  107.  
  108.       t_Half_Chord_Squared = Sphere->Radius_Squared - OCSquared +
  109.       (t_Closest_Approach * t_Closest_Approach);
  110.    }
  111.  
  112.    if (t_Half_Chord_Squared < Small_Tolerance)
  113.       return (FALSE);
  114.  
  115.    Half_Chord = sqrt (t_Half_Chord_Squared);
  116.    *Depth1 = t_Closest_Approach + Half_Chord;
  117.    *Depth2 = t_Closest_Approach - Half_Chord;
  118.  
  119.    if ((*Depth1 < Small_Tolerance) || (*Depth1 > Max_Distance))
  120.       if ((*Depth2 < Small_Tolerance) || (*Depth2 > Max_Distance))
  121.          return (FALSE);
  122.       else
  123.          *Depth1 = *Depth2;
  124.    else
  125.       if ((*Depth2 < Small_Tolerance) || (*Depth2 > Max_Distance))
  126.          *Depth2 = *Depth1;
  127.  
  128.    Ray_Sphere_Tests_Succeeded++;
  129.    return (TRUE);
  130. }
  131.  
  132. int Inside_Sphere (Test_Point, Object)
  133. VECTOR *Test_Point;
  134. OBJECT *Object;
  135. {
  136.    VECTOR Origin_To_Center;
  137.    DBL OCSquared;
  138.    SPHERE *Sphere = (SPHERE *) Object;
  139.  
  140.    VSub (Origin_To_Center, Sphere->Center, *Test_Point);
  141.    VDot (OCSquared, Origin_To_Center, Origin_To_Center);
  142.  
  143.    if (Sphere->Inverted)
  144.       return (OCSquared - Sphere->Radius_Squared > Small_Tolerance);
  145.    else
  146.       return (OCSquared - Sphere->Radius_Squared < Small_Tolerance);
  147. }
  148.  
  149. void Sphere_Normal (Result, Object, Intersection_Point)
  150. OBJECT *Object;
  151. VECTOR *Result, *Intersection_Point;
  152. {
  153.    SPHERE *Sphere = (SPHERE *) Object;
  154.  
  155.    VSub (*Result, *Intersection_Point, Sphere->Center);
  156.    VScale (*Result, *Result, Sphere->Inverse_Radius);
  157. }
  158.  
  159. void *Copy_Sphere (Object)
  160. OBJECT *Object;
  161. {
  162.    SPHERE *New_Shape;
  163.  
  164.    New_Shape = Get_Sphere_Shape ();
  165.    *New_Shape = *((SPHERE *) Object);
  166.    New_Shape -> Next_Object = NULL;
  167.  
  168.    if (New_Shape->Shape_Texture != NULL)
  169.       New_Shape->Shape_Texture = Copy_Texture (New_Shape->Shape_Texture);
  170.  
  171.    return (New_Shape);
  172. }
  173.  
  174. void Translate_Sphere (Object, Vector)
  175. OBJECT *Object;
  176. VECTOR *Vector;
  177. {
  178.    VAdd (((SPHERE *) Object)->Center, ((SPHERE *) Object)->Center, *Vector);
  179.  
  180.    Translate_Texture (&((SPHERE *) Object)->Shape_Texture, Vector);
  181. }
  182.  
  183. void Rotate_Sphere (Object, Vector)
  184. OBJECT *Object;
  185. VECTOR *Vector;
  186. {
  187.    TRANSFORMATION Transformation;
  188.  
  189.    Get_Rotation_Transformation (&Transformation, Vector);
  190.    MTransformVector (&((SPHERE *) Object)->Center,
  191.       &((SPHERE *) Object)->Center, &Transformation);
  192.  
  193.    Rotate_Texture (&((SPHERE *) Object)->Shape_Texture, Vector);
  194. }
  195.  
  196. void Scale_Sphere (Object, Vector)
  197. OBJECT *Object;
  198. VECTOR *Vector;
  199. {
  200.    SPHERE *Sphere = (SPHERE *) Object;
  201.  
  202.    if ((Vector->x != Vector->y) ||
  203.       (Vector->x != Vector->z)) {
  204.       fprintf (stderr, "Error - you cannot scale a sphere unevenly\n");
  205.       exit (1);
  206.    }
  207.  
  208.    VScale (Sphere->Center, Sphere->Center, Vector->x);
  209.    Sphere->Radius *= Vector->x;
  210.    Sphere->Radius_Squared = Sphere->Radius * Sphere->Radius;
  211.    Sphere->Inverse_Radius = 1.0 / Sphere->Radius;
  212.  
  213.  
  214.    Scale_Texture (&((SPHERE *) Object)->Shape_Texture, Vector);
  215. }
  216.  
  217. void Invert_Sphere (Object)
  218. OBJECT *Object;
  219. {
  220.    ((SPHERE *) Object)->Inverted ^= TRUE;
  221. }
  222.