home *** CD-ROM | disk | FTP | other *** search
/ Otherware / Otherware_1_SB_Development.iso / mac / developm / source / povsrc.sit / SOURCE / QUADRICS.C < prev    next >
Encoding:
C/C++ Source or Header  |  1992-07-03  |  10.5 KB  |  336 lines
  1. /****************************************************************************
  2. *                quadrics.c
  3. *
  4. *  This module implements the code for the quadric shape 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.  
  24. #include "frame.h"
  25. #include "vector.h"
  26. #include "povproto.h"
  27.  
  28. METHODS Quadric_Methods =
  29. { Object_Intersect, All_Quadric_Intersections,
  30.    Inside_Quadric, Quadric_Normal,
  31.    Copy_Quadric,
  32.    Translate_Quadric, Rotate_Quadric,
  33.    Scale_Quadric, Invert_Quadric};
  34.  
  35. extern RAY *VP_Ray;
  36. extern long Ray_Quadric_Tests, Ray_Quadric_Tests_Succeeded;
  37.  
  38. int All_Quadric_Intersections (Object, Ray, Depth_Queue)
  39. OBJECT *Object;
  40. RAY *Ray;
  41. PRIOQ *Depth_Queue;
  42. {
  43.    QUADRIC *Shape = (QUADRIC *) Object;
  44.    DBL Depth1, Depth2;
  45.    VECTOR Intersection_Point;
  46.    INTERSECTION Local_Element;
  47.    register int Intersection_Found;
  48.  
  49.    Intersection_Found = FALSE;
  50.    if (Intersect_Quadric (Ray, Shape, &Depth1, &Depth2))
  51.    {
  52.       Local_Element.Depth = Depth1;
  53.       Local_Element.Object = Shape -> Parent_Object;
  54.       VScale (Intersection_Point, Ray -> Direction, Depth1);
  55.       VAdd (Intersection_Point, Intersection_Point, Ray -> Initial);
  56.       Local_Element.Point = Intersection_Point;
  57.       Local_Element.Shape = (SHAPE *)Shape;
  58.       pq_add (Depth_Queue, &Local_Element);
  59.       Intersection_Found = TRUE;
  60.  
  61.       if (Depth2 != Depth1)
  62.       {
  63.          Local_Element.Depth = Depth2;
  64.          Local_Element.Object = Shape -> Parent_Object;
  65.          VScale (Intersection_Point, Ray -> Direction, Depth2);
  66.          VAdd (Intersection_Point, Intersection_Point, Ray -> Initial);
  67.          Local_Element.Point = Intersection_Point;
  68.          Local_Element.Shape = (SHAPE *) Shape;
  69.          pq_add (Depth_Queue, &Local_Element);
  70.          Intersection_Found = TRUE;
  71.       }
  72.    }
  73.    return (Intersection_Found);
  74. }
  75.  
  76. int Intersect_Quadric (Ray, Shape, Depth1, Depth2)
  77. RAY *Ray;
  78. QUADRIC *Shape;
  79. DBL *Depth1, *Depth2;
  80. {
  81.    register DBL Square_Term, Linear_Term, Constant_Term, Temp_Term;
  82.    register DBL Determinant, Determinant_2, A2, BMinus;
  83.  
  84.    Ray_Quadric_Tests++;
  85.    if (!Ray->Quadric_Constants_Cached)
  86.       Make_Ray(Ray);
  87.  
  88.    if (Shape -> Non_Zero_Square_Term)
  89.    {
  90.       VDot (Square_Term, Shape -> Object_2_Terms, Ray -> Direction_2);
  91.       VDot (Temp_Term, Shape -> Object_Mixed_Terms, Ray -> Mixed_Dir_Dir);
  92.       Square_Term += Temp_Term;
  93.    }
  94.    else
  95.       Square_Term = 0.0;
  96.  
  97.    VDot (Linear_Term, Shape -> Object_2_Terms, Ray -> Initial_Direction);
  98.    Linear_Term *= 2.0;
  99.    VDot (Temp_Term, Shape -> Object_Terms, Ray -> Direction);
  100.    Linear_Term += Temp_Term;
  101.    VDot (Temp_Term, Shape -> Object_Mixed_Terms, Ray -> Mixed_Init_Dir);
  102.    Linear_Term += Temp_Term;
  103.  
  104.    if (Ray == VP_Ray)
  105.       if (!Shape -> Constant_Cached)
  106.       {
  107.          VDot (Constant_Term, Shape -> Object_2_Terms, Ray -> Initial_2);
  108.          VDot (Temp_Term, Shape -> Object_Terms, Ray -> Initial);
  109.          Constant_Term +=  Temp_Term + Shape -> Object_Constant;
  110.          Shape -> Object_VP_Constant = Constant_Term;
  111.          Shape -> Constant_Cached = TRUE;
  112.       }
  113.       else
  114.          Constant_Term = Shape -> Object_VP_Constant;
  115.    else
  116.    {
  117.       VDot (Constant_Term, Shape -> Object_2_Terms, Ray -> Initial_2);
  118.       VDot (Temp_Term, Shape -> Object_Terms, Ray -> Initial);
  119.       Constant_Term += Temp_Term + Shape -> Object_Constant;
  120.    }
  121.  
  122.    VDot (Temp_Term, Shape -> Object_Mixed_Terms, 
  123.       Ray -> Mixed_Initial_Initial);
  124.    Constant_Term += Temp_Term;
  125.  
  126.    if (Square_Term != 0.0)
  127.    {
  128.       /* The equation is quadratic - find its roots */
  129.  
  130.       Determinant_2 = Linear_Term * Linear_Term - 4.0 * Square_Term * Constant_Term;
  131.  
  132.       if (Determinant_2 < 0.0)
  133.          return (FALSE);
  134.  
  135.       Determinant = sqrt (Determinant_2);
  136.       A2 = Square_Term * 2.0;
  137.       BMinus = Linear_Term * -1.0;
  138.  
  139.       *Depth1 = (BMinus + Determinant) / A2;
  140.       *Depth2 = (BMinus - Determinant) / A2;
  141.    }
  142.    else
  143.    {
  144.       /* There are no quadratic terms.  Solve the linear equation instead. */
  145.       if (Linear_Term == 0.0)
  146.          return (FALSE);
  147.  
  148.       *Depth1 = Constant_Term * -1.0 / Linear_Term;
  149.       *Depth2 = *Depth1;
  150.    }
  151.  
  152.    if ((*Depth1 < Small_Tolerance) || (*Depth1 > Max_Distance))
  153.       if ((*Depth2 < Small_Tolerance) || (*Depth2 > Max_Distance))
  154.          return (FALSE);
  155.       else
  156.          *Depth1 = *Depth2;
  157.    else
  158.       if ((*Depth2 < Small_Tolerance) || (*Depth2 > Max_Distance))
  159.          *Depth2 = *Depth1;
  160.  
  161.    Ray_Quadric_Tests_Succeeded++;
  162.    return (TRUE);
  163. }
  164.  
  165. int Inside_Quadric (Test_Point, Object)
  166. VECTOR *Test_Point;
  167. OBJECT *Object;
  168. {
  169.    QUADRIC *Shape = (QUADRIC *) Object;
  170.    VECTOR New_Point;
  171.    register DBL Result, Linear_Term, Square_Term;
  172.  
  173.    VDot (Linear_Term, *Test_Point, Shape -> Object_Terms);
  174.    Result = Linear_Term + Shape -> Object_Constant;
  175.    VSquareTerms (New_Point, *Test_Point);
  176.    VDot (Square_Term, New_Point, Shape -> Object_2_Terms);
  177.    Result += Square_Term;
  178.    Result += Shape -> Object_Mixed_Terms.x * (Test_Point -> x) * (Test_Point -> y)
  179.       + Shape -> Object_Mixed_Terms.y * (Test_Point -> x) * (Test_Point -> z)
  180.          + Shape -> Object_Mixed_Terms.z * (Test_Point -> y) * (Test_Point -> z);
  181.  
  182.    if (Result < Small_Tolerance)
  183.       return (TRUE);
  184.  
  185.    return (FALSE);
  186. }
  187.  
  188. void Quadric_Normal (Result, Object, Intersection_Point)
  189. VECTOR *Result, *Intersection_Point;
  190. OBJECT *Object;
  191. {
  192.    QUADRIC *Intersection_Shape = (QUADRIC *) Object;
  193.    VECTOR Derivative_Linear;
  194.    DBL Len;
  195.  
  196.    VScale (Derivative_Linear, Intersection_Shape -> Object_2_Terms, 2.0);
  197.    VEvaluate (*Result, Derivative_Linear, *Intersection_Point);
  198.    VAdd (*Result, *Result, Intersection_Shape -> Object_Terms);
  199.  
  200.    Result -> x += 
  201.    Intersection_Shape->Object_Mixed_Terms.x * Intersection_Point->y +
  202.    Intersection_Shape->Object_Mixed_Terms.y * Intersection_Point->z;
  203.  
  204.  
  205.    Result -> y +=
  206.    Intersection_Shape->Object_Mixed_Terms.x * Intersection_Point->x +
  207.    Intersection_Shape->Object_Mixed_Terms.z * Intersection_Point->z;
  208.  
  209.    Result -> z +=
  210.    Intersection_Shape->Object_Mixed_Terms.y * Intersection_Point->x +
  211.    Intersection_Shape->Object_Mixed_Terms.z * Intersection_Point->y;
  212.  
  213.    Len = Result->x * Result->x + Result->y * Result->y + Result->z * Result->z;
  214.    Len = sqrt(Len);
  215.    if (Len == 0.0) {
  216.       /* The normal is not defined at this point of the surface.  Set it
  217.          to any arbitrary direction. */
  218.       Result->x = 1.0;
  219.       Result->y = 0.0;
  220.       Result->z = 0.0;
  221.    }
  222.    else {
  223.       Result->x /= Len;        /* normalize the normal */
  224.       Result->y /= Len;
  225.       Result->z /= Len;
  226.    }
  227. }
  228.  
  229.    void *Copy_Quadric (Object)
  230.       OBJECT *Object;
  231. {
  232.    QUADRIC *New_Shape;
  233.  
  234.    New_Shape = Get_Quadric_Shape ();
  235.    *New_Shape = *((QUADRIC *) Object);
  236.    New_Shape -> Next_Object = NULL;
  237.  
  238.    if (New_Shape->Shape_Texture != NULL)
  239.       New_Shape->Shape_Texture = Copy_Texture (New_Shape->Shape_Texture);
  240.  
  241.    return (New_Shape);
  242. }
  243.  
  244. void Transform_Quadric (Shape, Transformation)
  245. QUADRIC *Shape;
  246. TRANSFORMATION *Transformation;
  247. {
  248.    MATRIX Quadric_Matrix, Transform_Transposed;
  249.  
  250.    Quadric_To_Matrix (Shape, (MATRIX *) &Quadric_Matrix[0][0]);
  251.    MTimes ((MATRIX *) &Quadric_Matrix[0][0], (MATRIX *) &(Transformation -> inverse[0][0]), (MATRIX *) &Quadric_Matrix[0][0]);
  252.    MTranspose ((MATRIX *) &Transform_Transposed[0][0], (MATRIX *) &(Transformation -> inverse[0][0]));
  253.    MTimes ((MATRIX *) &Quadric_Matrix[0][0], (MATRIX *) &Quadric_Matrix[0][0], (MATRIX *) &Transform_Transposed[0][0]);
  254.    Matrix_To_Quadric ((MATRIX *) &Quadric_Matrix[0][0], Shape);
  255. }
  256.  
  257. void Quadric_To_Matrix (Quadric, Matrix)
  258. QUADRIC *Quadric;
  259. MATRIX *Matrix;
  260. {
  261.    MZero (Matrix);
  262.    (*Matrix)[0][0] = Quadric -> Object_2_Terms.x;
  263.    (*Matrix)[1][1] = Quadric -> Object_2_Terms.y;
  264.    (*Matrix)[2][2] = Quadric -> Object_2_Terms.z;
  265.    (*Matrix)[0][1] = Quadric -> Object_Mixed_Terms.x;
  266.    (*Matrix)[0][2] = Quadric -> Object_Mixed_Terms.y;
  267.    (*Matrix)[0][3] = Quadric -> Object_Terms.x;
  268.    (*Matrix)[1][2] = Quadric -> Object_Mixed_Terms.z;
  269.    (*Matrix)[1][3] = Quadric -> Object_Terms.y;
  270.    (*Matrix)[2][3] = Quadric -> Object_Terms.z;
  271.    (*Matrix)[3][3] = Quadric -> Object_Constant;
  272. }
  273.  
  274. void Matrix_To_Quadric (Matrix, Quadric)
  275. MATRIX *Matrix;
  276. QUADRIC *Quadric;
  277. {
  278.    Quadric -> Object_2_Terms.x = (*Matrix)[0][0];
  279.    Quadric -> Object_2_Terms.y = (*Matrix)[1][1];
  280.    Quadric -> Object_2_Terms.z = (*Matrix)[2][2];
  281.    Quadric -> Object_Mixed_Terms.x = (*Matrix)[0][1] + (*Matrix)[1][0];
  282.    Quadric -> Object_Mixed_Terms.y = (*Matrix)[0][2] + (*Matrix)[2][0];
  283.    Quadric -> Object_Terms.x = (*Matrix)[0][3] + (*Matrix)[3][0];
  284.    Quadric -> Object_Mixed_Terms.z = (*Matrix)[1][2] + (*Matrix)[2][1];
  285.    Quadric -> Object_Terms.y = (*Matrix)[1][3] + (*Matrix)[3][1];
  286.    Quadric -> Object_Terms.z = (*Matrix)[2][3] + (*Matrix)[3][2];
  287.    Quadric -> Object_Constant = (*Matrix)[3][3];
  288. }
  289.  
  290. void Translate_Quadric (Object, Vector)
  291. OBJECT *Object;
  292. VECTOR *Vector;
  293. {
  294.    TRANSFORMATION Transformation;
  295.  
  296.    Get_Translation_Transformation (&Transformation, Vector);
  297.    Transform_Quadric ((QUADRIC *) Object, &Transformation);
  298.  
  299.    Translate_Texture (&((QUADRIC *) Object)->Shape_Texture, Vector);
  300. }
  301.  
  302. void Rotate_Quadric (Object, Vector)
  303. OBJECT *Object;
  304. VECTOR *Vector;
  305. {
  306.    TRANSFORMATION Transformation;
  307.  
  308.    Get_Rotation_Transformation (&Transformation, Vector);
  309.    Transform_Quadric ((QUADRIC *) Object, &Transformation);
  310.  
  311.    Rotate_Texture (&((QUADRIC *) Object)->Shape_Texture, Vector);
  312. }
  313.  
  314. void Scale_Quadric (Object, Vector)
  315. OBJECT *Object;
  316. VECTOR *Vector;
  317. {
  318.    TRANSFORMATION Transformation;
  319.  
  320.    Get_Scaling_Transformation (&Transformation, Vector);
  321.    Transform_Quadric ((QUADRIC *) Object, &Transformation);
  322.  
  323.    Scale_Texture (&((QUADRIC *) Object)->Shape_Texture, Vector);
  324. }
  325.  
  326. void Invert_Quadric (Object)
  327. OBJECT *Object;
  328. {
  329.    QUADRIC *Shape = (QUADRIC *) Object;
  330.  
  331.    VScale (Shape -> Object_2_Terms, Shape -> Object_2_Terms, -1.0);
  332.    VScale (Shape -> Object_Mixed_Terms, Shape -> Object_Mixed_Terms, -1.0);
  333.    VScale (Shape -> Object_Terms, Shape -> Object_Terms, -1.0);
  334.    Shape -> Object_Constant *= -1.0;
  335. }
  336.