home *** CD-ROM | disk | FTP | other *** search
/ Otherware / Otherware_1_SB_Development.iso / mac / developm / source / povsrc.sit / SOURCE / BOXES.C < prev    next >
Encoding:
C/C++ Source or Header  |  1992-07-03  |  9.3 KB  |  352 lines
  1. /****************************************************************************
  2. *                boxes.c
  3. *
  4. *  This module implements the box primitive.
  5. *
  6. *  This file was written by Alexander Enzmann.    He wrote the code for
  7. *  boxes and generously provided us these enhancements.
  8. *
  9. *  from Persistence of Vision Raytracer 
  10. *  Copyright 1991 Persistence of Vision Team
  11. *---------------------------------------------------------------------------
  12. *  Copying, distribution and legal info is in the file povlegal.doc which
  13. *  should be distributed with this file. If povlegal.doc is not available
  14. *  or for more info please contact:
  15. *
  16. *       Drew Wells [POV-Team Leader] 
  17. *       CIS: 73767,1244  Internet: 73767.1244@compuserve.com
  18. *       Phone: (213) 254-4041
  19. * 
  20. * This program is based on the popular DKB raytracer version 2.12.
  21. * DKBTrace was originally written by David K. Buck.
  22. * DKBTrace Ver 2.0-2.12 were written by David K. Buck & Aaron A. Collins.
  23. *
  24. *****************************************************************************/
  25.  
  26. #include "frame.h"
  27. #include "vector.h"
  28. #include "povproto.h"
  29.  
  30. METHODS Box_Methods =
  31. { Object_Intersect, All_Box_Intersections,
  32.    Inside_Box, Box_Normal,
  33.    Copy_Box,
  34.    Translate_Box, Rotate_Box,
  35.    Scale_Box, Invert_Box};
  36.  
  37. extern BOX *Get_Box_Shape();
  38.  
  39. extern RAY *VP_Ray;
  40. extern long Ray_Box_Tests, Ray_Box_Tests_Succeeded;
  41.  
  42. #define close(x, y) (fabs(x-y) < EPSILON ? 1 : 0)
  43.  
  44. int All_Box_Intersections (Object, Ray, Depth_Queue)
  45. OBJECT *Object;
  46. RAY *Ray;
  47. PRIOQ *Depth_Queue;
  48. {
  49.    DBL Depth1, Depth2;
  50.    VECTOR Intersection_Point;
  51.    INTERSECTION Local_Element;
  52.    register int Intersection_Found;
  53.    BOX *Shape = (BOX *) Object;
  54.  
  55.    Intersection_Found = FALSE;
  56.    if (Intersect_Boxx (Ray, Shape, &Depth1, &Depth2))
  57.    {
  58.       Local_Element.Depth = Depth1;
  59.       Local_Element.Object = Shape -> Parent_Object;
  60.       VScale (Intersection_Point, Ray -> Direction, Depth1);
  61.       VAdd (Intersection_Point, Intersection_Point, Ray -> Initial);
  62.       Local_Element.Point = Intersection_Point;
  63.       Local_Element.Shape = (SHAPE *)Shape;
  64.       pq_add (Depth_Queue, &Local_Element);
  65.       Intersection_Found = TRUE;
  66.  
  67.       if (Depth2 != Depth1)
  68.       {
  69.          Local_Element.Depth = Depth2;
  70.          Local_Element.Object = Shape -> Parent_Object;
  71.          VScale (Intersection_Point, Ray -> Direction, Depth2);
  72.          VAdd (Intersection_Point, Intersection_Point, Ray -> Initial);
  73.          Local_Element.Point = Intersection_Point;
  74.          Local_Element.Shape = (SHAPE *) Shape;
  75.          pq_add (Depth_Queue, &Local_Element);
  76.          Intersection_Found = TRUE;
  77.       }
  78.    }
  79.    return (Intersection_Found);
  80. }
  81.  
  82. int Intersect_Boxx (Ray, box, Depth1, Depth2)
  83. RAY *Ray;
  84. BOX *box;
  85. DBL *Depth1, *Depth2;
  86. {
  87.    DBL t, tmin, tmax;
  88.    VECTOR P, D;
  89.  
  90.    Ray_Box_Tests++;
  91.  
  92.    /* Transform the point into the boxes space */
  93.    if (box->Transform != NULL) {
  94.       MInverseTransformVector(&P, &Ray->Initial, box->Transform);
  95.       MInvTransVector(&D, &Ray->Direction, box->Transform);
  96.    }
  97.    else {
  98.       P.x = Ray->Initial.x;
  99.       P.y = Ray->Initial.y;
  100.       P.z = Ray->Initial.z;
  101.       D.x = Ray->Direction.x;
  102.       D.y = Ray->Direction.y;
  103.       D.z = Ray->Direction.z;
  104.    }
  105.  
  106.       tmin = 0.0;
  107.    tmax = HUGE_VAL;
  108.  
  109.    /* Sides first */
  110.    if (D.x < -EPSILON) {
  111.       t = (box->bounds[0].x - P.x) / D.x;
  112.       if (t < tmin)
  113.          return 0;
  114.       if (t <= tmax)
  115.          tmax = t;
  116.       t = (box->bounds[1].x - P.x) / D.x;
  117.       if (t >= tmin) {
  118.          if (t > tmax)
  119.             return 0;
  120.          tmin = t;
  121.       }
  122.    }
  123.    else if (D.x > EPSILON) {
  124.       t = (box->bounds[1].x - P.x) / D.x;
  125.       if (t < tmin)
  126.          return 0;
  127.       if (t <= tmax)
  128.          tmax = t;
  129.       t = (box->bounds[0].x - P.x) / D.x;
  130.       if (t >= tmin) {
  131.          if (t > tmax)
  132.             return 0;
  133.          tmin = t;
  134.       }
  135.    }
  136.    else if (P.x < box->bounds[0].x || P.x > box->bounds[1].x)
  137.       return 0;
  138.  
  139.    /* Check Top/Bottom */
  140.    if (D.y < -EPSILON) {
  141.       t = (box->bounds[0].y - P.y) / D.y;
  142.       if (t < tmin)
  143.          return 0;
  144.       if (t <= tmax)
  145.          tmax = t;
  146.       t = (box->bounds[1].y - P.y) / D.y;
  147.       if (t >= tmin) {
  148.          if (t > tmax)
  149.             return 0;
  150.          tmin = t;
  151.       }
  152.    }
  153.    else if (D.y > EPSILON) {
  154.       t = (box->bounds[1].y - P.y) / D.y;
  155.       if (t < tmin)
  156.          return 0;
  157.       if (t <= tmax)
  158.          tmax = t;
  159.       t = (box->bounds[0].y - P.y) / D.y;
  160.       if (t >= tmin) {
  161.          if (t > tmax)
  162.             return 0;
  163.          tmin = t;
  164.       }
  165.    }
  166.    else if (P.y < box->bounds[0].y || P.y > box->bounds[1].y)
  167.       return 0;
  168.  
  169.    /* Now front/back */
  170.    if (D.z < -EPSILON) {
  171.       t = (box->bounds[0].z - P.z) / D.z;
  172.       if (t < tmin)
  173.          return 0;
  174.       if (t <= tmax)
  175.          tmax = t;
  176.       t = (box->bounds[1].z - P.z) / D.z;
  177.       if (t >= tmin) {
  178.          if (t > tmax)
  179.             return 0;
  180.          tmin = t;
  181.       }
  182.    }
  183.    else if (D.z > EPSILON) {
  184.       t = (box->bounds[1].z - P.z) / D.z;
  185.       if (t < tmin)
  186.          return 0;
  187.       if (t <= tmax)
  188.          tmax = t;
  189.       t = (box->bounds[0].z - P.z) / D.z;
  190.       if (t >= tmin) {
  191.          if (t > tmax)
  192.             return 0;
  193.          tmin = t;
  194.       }
  195.    }
  196.    else if (P.z < box->bounds[0].z || P.z > box->bounds[1].z)
  197.       return 0;
  198.  
  199.    *Depth1 = tmin;
  200.    *Depth2 = tmax;
  201.  
  202.    /* printf("Box intersects: %g, %g\n", *Depth1, *Depth2); */
  203.    if ((*Depth1 < Small_Tolerance) || (*Depth1 > Max_Distance))
  204.       if ((*Depth2 < Small_Tolerance) || (*Depth2 > Max_Distance))
  205.          return (FALSE);
  206.       else
  207.          *Depth1 = *Depth2;
  208.    else
  209.       if ((*Depth2 < Small_Tolerance) || (*Depth2 > Max_Distance))
  210.          *Depth2 = *Depth1;
  211.  
  212.    Ray_Box_Tests_Succeeded++;
  213.    return (TRUE);
  214. }
  215.  
  216. int Inside_Box (Test_Point, Object)
  217. VECTOR *Test_Point;
  218. OBJECT *Object;
  219. {
  220.    VECTOR New_Point;
  221.    BOX *box = (BOX *) Object;
  222.  
  223.    /* Transform the point into the boxes space */
  224.    if (box->Transform != NULL)
  225.       MInverseTransformVector(&New_Point, Test_Point, box->Transform);
  226.    else
  227.       New_Point = *Test_Point;
  228.  
  229.    /* Test to see if we are inside the box */
  230.    if (New_Point.x < box->bounds[0].x || New_Point.x > box->bounds[1].x)
  231.       return ((int) box->Inverted);
  232.    if (New_Point.y < box->bounds[0].y || New_Point.y > box->bounds[1].y)
  233.       return ((int) box->Inverted);
  234.    if (New_Point.z < box->bounds[0].z || New_Point.z > box->bounds[1].z)
  235.       return ((int)box->Inverted);
  236.    /* Inside the box */
  237.    return 1-box->Inverted;
  238. }
  239.  
  240. void Box_Normal (Result, Object, Intersection_Point)
  241. OBJECT *Object;
  242. VECTOR *Result, *Intersection_Point;
  243. {
  244.    VECTOR New_Point;
  245.    BOX *box = (BOX *) Object;
  246.  
  247.    /* Transform the point into the boxes space */
  248.    if (box->Transform != NULL)
  249.       MInverseTransformVector(&New_Point, Intersection_Point, box->Transform);
  250.    else {
  251.       New_Point.x = Intersection_Point->x;
  252.       New_Point.y = Intersection_Point->y;
  253.       New_Point.z = Intersection_Point->z;
  254.    }
  255.  
  256.       Result->x = 0.0; Result->y = 0.0; Result->z = 0.0;
  257.    if (close(New_Point.x, box->bounds[1].x))
  258.       Result->x = 1.0;
  259.    else if (close(New_Point.x, box->bounds[0].x))
  260.       Result->x = -1.0;
  261.    else if (close(New_Point.y, box->bounds[1].y))
  262.       Result->y = 1.0;
  263.    else if (close(New_Point.y, box->bounds[0].y))
  264.       Result->y = -1.0;
  265.    else if (close(New_Point.z, box->bounds[1].z))
  266.       Result->z = 1.0;
  267.    else if (close(New_Point.z, box->bounds[0].z))
  268.       Result->z = -1.0;
  269.    else {
  270.       /* Bad result, should we do something with it? */
  271.          Result->x = 1.0;
  272.    }
  273.  
  274.    /* Transform the point into the boxes space */
  275.    if (box->Transform != NULL) {
  276.       MTransNormal(Result, Result, box->Transform);
  277.       VNormalize(*Result, *Result);
  278.    }
  279. }
  280.  
  281. void *Copy_Box (Object)
  282. OBJECT *Object;
  283. {
  284.    BOX *New_Shape;
  285.    TRANSFORMATION *Tr;
  286.  
  287.    New_Shape = Get_Box_Shape ();
  288.    *New_Shape = *((BOX *) Object);
  289.    New_Shape -> Next_Object = NULL;
  290.  
  291.    /* Copy any associated transformation */
  292.    if (New_Shape->Transform != NULL) {
  293.       Tr = Get_Transformation();
  294.       memcpy(Tr, New_Shape->Transform, sizeof(TRANSFORMATION));
  295.       New_Shape->Transform = Tr;
  296.    }
  297.  
  298.    if (New_Shape->Shape_Texture != NULL)
  299.       New_Shape->Shape_Texture = Copy_Texture (New_Shape->Shape_Texture);
  300.  
  301.    return (New_Shape);
  302. }
  303.  
  304. void Translate_Box (Object, Vector)
  305. OBJECT *Object;
  306. VECTOR *Vector;
  307. {
  308.    TRANSFORMATION Transform;
  309.    BOX *box = (BOX *)Object;
  310.    if (box->Transform == NULL)
  311.       box->Transform = Get_Transformation();
  312.    Get_Translation_Transformation(&Transform, Vector);
  313.    Compose_Transformations(box->Transform, &Transform);
  314.  
  315.    Translate_Texture (&((BOX *) Object)->Shape_Texture, Vector);
  316. }
  317.  
  318. void Rotate_Box (Object, Vector)
  319. OBJECT *Object;
  320. VECTOR *Vector;
  321. {
  322.    TRANSFORMATION Transform;
  323.    BOX *box = (BOX *)Object;
  324.    if (box->Transform == NULL)
  325.       box->Transform = Get_Transformation();
  326.    Get_Rotation_Transformation(&Transform, Vector);
  327.    Compose_Transformations(box->Transform, &Transform);
  328.  
  329.    Rotate_Texture (&((BOX *) Object)->Shape_Texture, Vector);
  330. }
  331.  
  332. void Scale_Box (Object, Vector)
  333. OBJECT *Object;
  334. VECTOR *Vector;
  335. {
  336.    TRANSFORMATION Transform;
  337.    BOX *box = (BOX *)Object;
  338.    if (box->Transform == NULL)
  339.       box->Transform = Get_Transformation();
  340.    Get_Scaling_Transformation(&Transform, Vector);
  341.    Compose_Transformations(box->Transform, &Transform);
  342.  
  343.    Scale_Texture (&((BOX *) Object)->Shape_Texture, Vector);
  344. }
  345.  
  346.  
  347. void Invert_Box (Object)
  348. OBJECT *Object;
  349. {
  350.    ((BOX *) Object)->Inverted = 1 - ((BOX *)Object)->Inverted;
  351. }
  352.