home *** CD-ROM | disk | FTP | other *** search
/ Otherware / Otherware_1_SB_Development.iso / mac / developm / source / povsrc.sit / SOURCE / OBJECTS.C < prev    next >
Encoding:
C/C++ Source or Header  |  1992-07-03  |  16.6 KB  |  563 lines
  1. /****************************************************************************
  2. *                objects.c
  3. *
  4. *  This module implements the methods for objects and composite objects.
  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.  
  24. #include "frame.h"
  25. #include "vector.h"
  26. #include "povproto.h"
  27.  
  28. extern RAY *VP_Ray;
  29. extern long Bounding_Region_Tests, Bounding_Region_Tests_Succeeded;
  30. extern long Clipping_Region_Tests, Clipping_Region_Tests_Succeeded;
  31. extern unsigned int Options;
  32.  
  33. METHODS Composite_Methods =
  34. { Object_Intersect, All_Composite_Intersections,
  35.    Inside_Composite_Object, NULL,
  36.    Copy_Composite_Object,
  37.    Translate_Composite_Object, Rotate_Composite_Object,
  38.    Scale_Composite_Object, Invert_Composite_Object};
  39.  
  40. METHODS Basic_Object_Methods =
  41. { Object_Intersect, All_Object_Intersections,
  42.    Inside_Basic_Object, NULL,
  43.    Copy_Basic_Object,
  44.    Translate_Basic_Object, Rotate_Basic_Object,
  45.    Scale_Basic_Object, Invert_Basic_Object};
  46.  
  47.  
  48. INTERSECTION *Object_Intersect (Object, Ray)
  49. OBJECT *Object;
  50. RAY *Ray;
  51. {
  52.    INTERSECTION *Local_Intersection, *Queue_Element;
  53.    PRIOQ *Depth_Queue;
  54.  
  55.    Depth_Queue = pq_new (128);
  56.  
  57.    if ((All_Intersections (Object, Ray, Depth_Queue))
  58.       && ((Queue_Element = pq_get_highest (Depth_Queue)) != NULL))
  59.    {
  60.       if ((Local_Intersection = (INTERSECTION *) malloc(sizeof(INTERSECTION)))
  61.          == NULL) {
  62.          printf("Cannot allocate memory for local intersection\n");
  63.          exit(1);
  64.       }
  65.       Local_Intersection->Point = Queue_Element->Point;
  66.       Local_Intersection->Shape = Queue_Element->Shape;
  67.       Local_Intersection->Depth = Queue_Element->Depth;
  68.       Local_Intersection->Object = Queue_Element->Object;
  69.       pq_free (Depth_Queue);
  70.       return (Local_Intersection);
  71.    }
  72.    else
  73.    {
  74.       pq_free (Depth_Queue);
  75.       return (NULL);
  76.    }
  77. }
  78.  
  79.  
  80. int All_Composite_Intersections (Object, Ray, Depth_Queue)
  81. OBJECT *Object;
  82. RAY *Ray;
  83. PRIOQ *Depth_Queue;
  84. {
  85.    register int Intersection_Found, Any_Intersection_Found;
  86.    SHAPE *Bounding_Shape;
  87.    SHAPE *Clipping_Shape;
  88.    INTERSECTION *Local_Intersection;
  89.    OBJECT *Local_Object;
  90.    PRIOQ *Local_Depth_Queue;
  91.  
  92.    for (Bounding_Shape = ((COMPOSITE *) Object) -> Bounding_Shapes ;
  93.               Bounding_Shape != NULL ;
  94.               Bounding_Shape = Bounding_Shape -> Next_Object) {
  95.  
  96.       Bounding_Region_Tests++;
  97.       COOPERATE
  98.       if ((Local_Intersection = Intersection ((OBJECT *) Bounding_Shape, Ray)) != NULL)
  99.          free (Local_Intersection);
  100.       else
  101.          if (!Inside (&Ray -> Initial, (OBJECT *) Bounding_Shape))
  102.             return (FALSE);
  103.       Bounding_Region_Tests_Succeeded++;
  104.    }
  105.  
  106.    Local_Depth_Queue = pq_new (128);
  107.    Any_Intersection_Found = FALSE;
  108.  
  109.    for (Local_Object = ((COMPOSITE *) Object) -> Objects ;
  110.               Local_Object != NULL ;
  111.               Local_Object = Local_Object -> Next_Object)
  112.  
  113.       All_Intersections (Local_Object, Ray, Local_Depth_Queue);
  114.  
  115.    for (Local_Intersection = pq_get_highest (Local_Depth_Queue);
  116.           Local_Intersection != NULL ;
  117.           pq_delete_highest (Local_Depth_Queue),
  118.           Local_Intersection = pq_get_highest (Local_Depth_Queue)) {
  119.  
  120.       Intersection_Found = TRUE;
  121.  
  122.       for (Clipping_Shape = Object -> Clipping_Shapes ;
  123.                      Clipping_Shape != NULL ;
  124.                      Clipping_Shape = Clipping_Shape -> Next_Object) {
  125.          Clipping_Region_Tests++;
  126.          if (!Inside (&Local_Intersection->Point, (OBJECT *) Clipping_Shape)) {
  127.             Intersection_Found = FALSE;
  128.             break;
  129.          }
  130.          Clipping_Region_Tests_Succeeded++;
  131.       }
  132.  
  133.       if (Intersection_Found) {
  134.          pq_add (Depth_Queue, Local_Intersection);
  135.          Any_Intersection_Found = TRUE;
  136.       }
  137.    }
  138.    pq_free (Local_Depth_Queue);
  139.    return (Any_Intersection_Found);
  140. }
  141.  
  142.  
  143. int All_Object_Intersections (Object, Ray, Depth_Queue)
  144. OBJECT *Object;
  145. RAY *Ray;
  146. PRIOQ *Depth_Queue;
  147. {
  148.    int Intersection_Found, Any_Intersection_Found;
  149.    INTERSECTION *Local_Intersection;
  150.    SHAPE *Bounding_Shape;
  151.    SHAPE *Clipping_Shape;
  152.    PRIOQ *Local_Depth_Queue;
  153.  
  154.    for (Bounding_Shape = Object -> Bounding_Shapes ;
  155.               Bounding_Shape != NULL ;
  156.               Bounding_Shape = Bounding_Shape -> Next_Object) {
  157.  
  158.       Bounding_Region_Tests++;
  159.       COOPERATE
  160.       if ((Local_Intersection = Intersection ((OBJECT *) Bounding_Shape, Ray)) != NULL)
  161.          free (Local_Intersection);
  162.       else
  163.          if (!Inside (&Ray -> Initial, (OBJECT *) Bounding_Shape))
  164.             return (FALSE);
  165.       Bounding_Region_Tests_Succeeded++;
  166.    }
  167.  
  168.    Local_Depth_Queue = pq_new (128);
  169.    Any_Intersection_Found = FALSE;
  170.    All_Intersections ((OBJECT *)Object->Shape, Ray, Local_Depth_Queue);
  171.  
  172.    for (Local_Intersection = pq_get_highest (Local_Depth_Queue);
  173.              Local_Intersection != NULL ;
  174.             pq_delete_highest (Local_Depth_Queue),
  175.             Local_Intersection = pq_get_highest (Local_Depth_Queue)) {
  176.  
  177.       Intersection_Found = TRUE;
  178.  
  179.       for (Clipping_Shape = Object -> Clipping_Shapes ;
  180.                 Clipping_Shape != NULL ;
  181.                 Clipping_Shape = Clipping_Shape -> Next_Object) {
  182.  
  183.          Clipping_Region_Tests++;
  184.          if (Options & DEBUGGING) {
  185.             printf("Test (%.4lf, %.4lf, %.4lf)\n",
  186.                Local_Intersection->Point.x,
  187.                Local_Intersection->Point.y,
  188.                Local_Intersection->Point.z);
  189.          }
  190.          if (!Inside (&Local_Intersection->Point, (OBJECT *) Clipping_Shape)) {
  191.             if (Options & DEBUGGING)
  192.                printf("not ok\n");
  193.             Intersection_Found = FALSE;
  194.             break;
  195.          }
  196.          Clipping_Region_Tests_Succeeded++; 
  197.       }
  198.  
  199.       if (Intersection_Found) {
  200.          if (Options & DEBUGGING)
  201.             printf("ok\n");
  202.          pq_add (Depth_Queue, Local_Intersection);
  203.          Any_Intersection_Found = TRUE;
  204.  
  205.       }
  206.    }
  207.    pq_free (Local_Depth_Queue);
  208.    return (Any_Intersection_Found);
  209. }
  210.  
  211.  
  212. int Inside_Basic_Object (Test_Point, Object)
  213. VECTOR *Test_Point;
  214. OBJECT *Object;
  215. {
  216.    SHAPE *Bounding_Shape;
  217.    SHAPE *Clipping_Shape;
  218.  
  219.    for (Bounding_Shape = Object -> Bounding_Shapes ;
  220.               Bounding_Shape != NULL ;
  221.               Bounding_Shape = Bounding_Shape -> Next_Object)
  222.  
  223.       if (!Inside (Test_Point, (OBJECT *) Bounding_Shape))
  224.          return (FALSE);
  225.  
  226.    for (Clipping_Shape = Object -> Clipping_Shapes ;
  227.                Clipping_Shape != NULL ;
  228.                Clipping_Shape = Clipping_Shape -> Next_Object)
  229.  
  230.       if (!Inside (Test_Point, (OBJECT *) Clipping_Shape))
  231.          return (FALSE);
  232.  
  233.    if (Inside (Test_Point, (OBJECT *) Object -> Shape))
  234.       return (TRUE);
  235.    return (FALSE);
  236. }
  237.  
  238. int Inside_Composite_Object (Test_Point, Object)
  239. VECTOR *Test_Point;
  240. OBJECT *Object;
  241. {
  242.    SHAPE *Bounding_Shape;
  243.    SHAPE *Clipping_Shape;
  244.    OBJECT *Local_Object;
  245.  
  246.    for (Bounding_Shape = ((COMPOSITE *) Object) -> Bounding_Shapes ;
  247.               Bounding_Shape != NULL ;
  248.               Bounding_Shape = Bounding_Shape -> Next_Object)
  249.  
  250.       if (!Inside (Test_Point, (OBJECT *) Bounding_Shape))
  251.          return (FALSE);
  252.  
  253.    for (Clipping_Shape = ((COMPOSITE *) Object) -> Clipping_Shapes ;
  254.               Clipping_Shape != NULL ;
  255.               Clipping_Shape = Clipping_Shape -> Next_Object)
  256.  
  257.       if (!Inside (Test_Point, (OBJECT *) Clipping_Shape))
  258.          return (FALSE);
  259.  
  260.    for (Local_Object = ((COMPOSITE *) Object) -> Objects ;
  261.               Local_Object != NULL ;
  262.               Local_Object = Local_Object -> Next_Object)
  263.  
  264.       if (Inside (Test_Point, Local_Object))
  265.          return (TRUE);
  266.  
  267.    return (FALSE);
  268. }
  269.  
  270. void *Copy_Basic_Object (Object)
  271. OBJECT *Object;
  272. {
  273.    SHAPE *Local_Shape, *Copied_Shape;
  274.    OBJECT *New_Object;
  275.  
  276.    New_Object = Get_Object();
  277.    *New_Object = *Object;
  278.    New_Object -> Next_Object = NULL;
  279.    New_Object -> Bounding_Shapes = NULL;
  280.    New_Object -> Clipping_Shapes = NULL;
  281.    for (Local_Shape = Object -> Bounding_Shapes ;
  282.               Local_Shape != NULL ;
  283.               Local_Shape = Local_Shape -> Next_Object) {
  284.  
  285.       Copied_Shape = (SHAPE *) Copy((OBJECT *) Local_Shape);
  286.       Link ((OBJECT *) Copied_Shape,
  287.          (OBJECT **) &(Copied_Shape -> Next_Object),
  288.          (OBJECT **) &(New_Object -> Bounding_Shapes));
  289.  
  290.       if ((Copied_Shape->Type == CSG_UNION_TYPE)
  291.          || (Copied_Shape->Type == CSG_INTERSECTION_TYPE)
  292.          || (Copied_Shape->Type == CSG_DIFFERENCE_TYPE))
  293.          Set_CSG_Parents ((CSG_SHAPE *) Copied_Shape, New_Object);
  294.    }
  295.  
  296.    for (Local_Shape = Object -> Clipping_Shapes ;
  297.               Local_Shape != NULL ;
  298.               Local_Shape = Local_Shape -> Next_Object) {
  299.  
  300.       Copied_Shape = (SHAPE *) Copy((OBJECT *) Local_Shape);
  301.       Link ((OBJECT *) Copied_Shape,
  302.          (OBJECT **) &(Copied_Shape -> Next_Object),
  303.          (OBJECT **) &(New_Object -> Clipping_Shapes));
  304.  
  305.       if ((Copied_Shape->Type == CSG_UNION_TYPE)
  306.          || (Copied_Shape->Type == CSG_INTERSECTION_TYPE)
  307.          || (Copied_Shape->Type == CSG_DIFFERENCE_TYPE))
  308.          Set_CSG_Parents ((CSG_SHAPE *) Copied_Shape, New_Object);
  309.    }
  310.  
  311.    New_Object -> Shape = (SHAPE *) Copy((OBJECT *) Object -> Shape);
  312.    if ((New_Object->Shape->Type == CSG_UNION_TYPE)
  313.       || (New_Object->Shape->Type == CSG_INTERSECTION_TYPE)
  314.       || (New_Object->Shape->Type == CSG_DIFFERENCE_TYPE))
  315.       Set_CSG_Parents ((CSG_SHAPE *) New_Object->Shape, New_Object);
  316.    else
  317.       New_Object->Shape->Parent_Object = New_Object;
  318.  
  319.  
  320.    if (New_Object->Object_Texture != NULL)
  321.       New_Object->Object_Texture = Copy_Texture (New_Object->Object_Texture);
  322.  
  323.    return ((void *)New_Object);
  324. }
  325.  
  326. void *Copy_Composite_Object (Object)
  327. OBJECT *Object;
  328. {
  329.    COMPOSITE *New_Object;
  330.    SHAPE *Local_Shape;
  331.    OBJECT *Local_Object, *Copied_Object;
  332.  
  333.    New_Object = Get_Composite_Object();
  334.    *New_Object = *((COMPOSITE *) Object);
  335.    New_Object -> Next_Object = NULL;
  336.    New_Object -> Objects = NULL;
  337.    for (Local_Object = ((COMPOSITE *) Object) -> Objects;
  338.               Local_Object != NULL ;
  339.               Local_Object = Local_Object -> Next_Object) {
  340.  
  341.       Copied_Object = (OBJECT *) Copy(Local_Object);
  342.       Link (Copied_Object,
  343.          &(Copied_Object -> Next_Object),
  344.          &(New_Object -> Objects));
  345.    }
  346.  
  347.    New_Object -> Bounding_Shapes = NULL;
  348.    for (Local_Shape = ((COMPOSITE *) Object) -> Bounding_Shapes;
  349.               Local_Shape != NULL ;
  350.               Local_Shape = Local_Shape -> Next_Object) {
  351.  
  352.       Copied_Object = (OBJECT *) Copy((OBJECT *) Local_Shape);
  353.       Link (Copied_Object,
  354.          &(Copied_Object -> Next_Object),
  355.          (OBJECT **) &(New_Object -> Bounding_Shapes));
  356.    }
  357.    New_Object -> Clipping_Shapes = NULL;
  358.    for (Local_Shape = ((COMPOSITE *) Object) -> Clipping_Shapes;
  359.               Local_Shape != NULL ;
  360.               Local_Shape = Local_Shape -> Next_Object) {
  361.  
  362.       Copied_Object = (OBJECT *) Copy((OBJECT *) Local_Shape);
  363.       Link (Copied_Object,
  364.          &(Copied_Object -> Next_Object),
  365.          (OBJECT **) &(New_Object -> Clipping_Shapes));
  366.    }
  367.    return ((void *)New_Object);
  368. }
  369.  
  370. void Translate_Basic_Object (Object, Vector)
  371. OBJECT *Object;
  372. VECTOR *Vector;
  373. {
  374.    SHAPE *Local_Shape;
  375.  
  376.    for (Local_Shape = Object -> Bounding_Shapes ;
  377.               Local_Shape != NULL ;
  378.               Local_Shape = Local_Shape -> Next_Object)
  379.  
  380.       Translate ((OBJECT *) Local_Shape, Vector);
  381.  
  382.    for (Local_Shape = Object -> Clipping_Shapes ;
  383.               Local_Shape != NULL ;
  384.               Local_Shape = Local_Shape -> Next_Object)
  385.  
  386.       Translate ((OBJECT *) Local_Shape, Vector);
  387.  
  388.    Translate ((OBJECT *) Object -> Shape, Vector);
  389.  
  390.    Translate_Texture (&Object->Object_Texture, Vector);
  391. }
  392.  
  393. void Rotate_Basic_Object (Object, Vector)
  394. OBJECT *Object;
  395. VECTOR *Vector;
  396. {
  397.    SHAPE *Local_Shape;
  398.    TRANSFORMATION Transformation;
  399.  
  400.    for (Local_Shape = Object -> Bounding_Shapes ;
  401.               Local_Shape != NULL ;
  402.               Local_Shape = Local_Shape -> Next_Object)
  403.  
  404.       Rotate ((OBJECT *) Local_Shape, Vector);
  405.  
  406.    for (Local_Shape = Object -> Clipping_Shapes ;
  407.               Local_Shape != NULL ;
  408.               Local_Shape = Local_Shape -> Next_Object)
  409.  
  410.       Rotate ((OBJECT *) Local_Shape, Vector);
  411.  
  412.    Rotate ((OBJECT *) Object -> Shape, Vector);
  413.    Get_Rotation_Transformation (&Transformation, Vector);
  414.  
  415.    Rotate_Texture (&Object->Object_Texture, Vector);
  416. }
  417.  
  418. void Scale_Basic_Object (Object, Vector)
  419. OBJECT *Object;
  420. VECTOR *Vector;
  421. {
  422.    SHAPE *Local_Shape;
  423.  
  424.    for (Local_Shape = Object -> Bounding_Shapes ;
  425.               Local_Shape != NULL ;
  426.               Local_Shape = Local_Shape -> Next_Object)
  427.  
  428.       Scale ((OBJECT *) Local_Shape, Vector);
  429.  
  430.    for (Local_Shape = Object -> Clipping_Shapes ;
  431.               Local_Shape != NULL ;
  432.               Local_Shape = Local_Shape -> Next_Object)
  433.  
  434.       Scale ((OBJECT *) Local_Shape, Vector);
  435.  
  436.    Scale ((OBJECT *) Object -> Shape, Vector);
  437.  
  438.    Scale_Texture (&Object->Object_Texture, Vector);
  439. }
  440.  
  441. void Translate_Composite_Object (Object, Vector)
  442. OBJECT *Object;
  443. VECTOR *Vector;
  444. {
  445.    OBJECT *Local_Object;
  446.    SHAPE *Local_Shape;
  447.  
  448.    for (Local_Object = ((COMPOSITE *) Object) -> Objects;
  449.               Local_Object != NULL ;
  450.               Local_Object = Local_Object -> Next_Object)
  451.  
  452.       Translate (Local_Object, Vector);   
  453.  
  454.    for (Local_Shape = ((COMPOSITE *) Object) -> Bounding_Shapes ;
  455.               Local_Shape != NULL ;
  456.               Local_Shape = Local_Shape -> Next_Object)
  457.  
  458.       Translate ((OBJECT *) Local_Shape, Vector);
  459.  
  460.    for (Local_Shape = ((COMPOSITE *) Object) -> Clipping_Shapes ;
  461.               Local_Shape != NULL ;
  462.               Local_Shape = Local_Shape -> Next_Object)
  463.  
  464.       Translate ((OBJECT *) Local_Shape, Vector);
  465. }
  466.  
  467. void Rotate_Composite_Object (Object, Vector)
  468. OBJECT *Object;
  469. VECTOR *Vector;
  470. {
  471.    OBJECT *Local_Object;
  472.    SHAPE *Local_Shape;
  473.  
  474.    for (Local_Object = ((COMPOSITE *) Object) -> Objects;
  475.               Local_Object != NULL ;
  476.               Local_Object = Local_Object -> Next_Object)
  477.  
  478.       Rotate (Local_Object, Vector);   
  479.  
  480.    for (Local_Shape = ((COMPOSITE *) Object) -> Bounding_Shapes ;
  481.               Local_Shape != NULL ;
  482.               Local_Shape = Local_Shape -> Next_Object)
  483.  
  484.       Rotate ((OBJECT *) Local_Shape, Vector);
  485.  
  486.    for (Local_Shape = ((COMPOSITE *) Object) -> Clipping_Shapes ;
  487.               Local_Shape != NULL ;
  488.               Local_Shape = Local_Shape -> Next_Object)
  489.  
  490.       Rotate ((OBJECT *) Local_Shape, Vector);
  491. }
  492.  
  493. void Scale_Composite_Object (Object, Vector)
  494. OBJECT *Object;
  495. VECTOR *Vector;
  496. {
  497.    OBJECT *Local_Object;
  498.    SHAPE *Local_Shape;
  499.  
  500.    for (Local_Object = ((COMPOSITE *) Object) -> Objects;
  501.               Local_Object != NULL ;
  502.               Local_Object = Local_Object -> Next_Object)
  503.  
  504.       Scale (Local_Object, Vector);   
  505.  
  506.    for (Local_Shape = ((COMPOSITE *) Object) -> Bounding_Shapes ;
  507.               Local_Shape != NULL ;
  508.               Local_Shape = Local_Shape -> Next_Object)
  509.  
  510.       Scale ((OBJECT *) Local_Shape, Vector);
  511.  
  512.    for (Local_Shape = ((COMPOSITE *) Object) -> Clipping_Shapes ;
  513.               Local_Shape != NULL ;
  514.               Local_Shape = Local_Shape -> Next_Object)
  515.  
  516.       Scale ((OBJECT *) Local_Shape, Vector);
  517. }
  518.  
  519.  
  520. void Invert_Basic_Object (Object)
  521. OBJECT *Object;
  522. {
  523.    SHAPE *Local_Shape;
  524.  
  525.    for (Local_Shape = Object -> Bounding_Shapes ;
  526.               Local_Shape != NULL ;
  527.               Local_Shape = Local_Shape -> Next_Object)
  528.  
  529.       Invert ((OBJECT *) Local_Shape);
  530.  
  531.    for (Local_Shape = Object -> Clipping_Shapes ;
  532.               Local_Shape != NULL ;
  533.               Local_Shape = Local_Shape -> Next_Object)
  534.  
  535.       Invert ((OBJECT *) Local_Shape);
  536.    Invert ((OBJECT *) Object -> Shape);
  537. }
  538.  
  539. void Invert_Composite_Object (Object)
  540. OBJECT *Object;
  541. {
  542.    OBJECT *Local_Object;
  543.    SHAPE *Local_Shape;
  544.  
  545.    for (Local_Object = ((COMPOSITE *)Object) -> Objects;
  546.               Local_Object != NULL ;
  547.               Local_Object = Local_Object -> Next_Object)
  548.  
  549.       Invert (Local_Object);   
  550.  
  551.    for (Local_Shape = ((COMPOSITE *) Object) -> Bounding_Shapes ;
  552.               Local_Shape != NULL ;
  553.               Local_Shape = Local_Shape -> Next_Object)
  554.  
  555.       Invert ((OBJECT *) Local_Shape);
  556.  
  557.    for (Local_Shape = ((COMPOSITE *) Object) -> Clipping_Shapes ;
  558.               Local_Shape != NULL ;
  559.               Local_Shape = Local_Shape -> Next_Object)
  560.  
  561.       Invert ((OBJECT *) Local_Shape);
  562. }
  563.