home *** CD-ROM | disk | FTP | other *** search
/ Otherware / Otherware_1_SB_Development.iso / mac / developm / source / povsrc.sit / SOURCE / TRIANGLE.C < prev    next >
Encoding:
C/C++ Source or Header  |  1992-07-03  |  18.6 KB  |  638 lines
  1. /****************************************************************************
  2. *                triangle.c
  3. *
  4. *  This module implements primitives for triangles and smooth triangles.
  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 Triangle_Methods = {
  28.    Object_Intersect, All_Triangle_Intersections,
  29.    Inside_Triangle, Triangle_Normal,
  30.    Copy_Triangle,
  31.    Translate_Triangle, Rotate_Triangle,
  32.    Scale_Triangle, Invert_Triangle};
  33.  
  34. METHODS Smooth_Triangle_Methods = {
  35.    Object_Intersect, All_Triangle_Intersections,
  36.    Inside_Triangle, Smooth_Triangle_Normal,
  37.    Copy_Smooth_Triangle,
  38.    Translate_Smooth_Triangle, Rotate_Smooth_Triangle,
  39.    Scale_Smooth_Triangle, Invert_Smooth_Triangle};
  40.  
  41. extern TRIANGLE *Get_Triangle_Shape();
  42.  
  43. extern RAY *VP_Ray;
  44. extern long Ray_Triangle_Tests, Ray_Triangle_Tests_Succeeded;
  45.  
  46. #define max3(x,y,z) ((x>y)?((x>z)?1:3):((y>z)?2:3))
  47.  
  48. void Find_Triangle_Dominant_Axis(Triangle)
  49. TRIANGLE *Triangle;
  50. {
  51.    DBL x, y, z;
  52.  
  53.    x = fabs(Triangle->Normal_Vector.x);
  54.    y = fabs (Triangle->Normal_Vector.y);
  55.    z = fabs (Triangle->Normal_Vector.z);
  56.    switch (max3(x, y, z)) {
  57.    case 1: 
  58.       Triangle->Dominant_Axis = X_AXIS;
  59.       break;
  60.    case 2: 
  61.       Triangle->Dominant_Axis = Y_AXIS;
  62.       break;
  63.    case 3: 
  64.       Triangle->Dominant_Axis = Z_AXIS;
  65.       break;
  66.    }
  67. }
  68.  
  69. void Compute_Smooth_Triangle (Triangle)
  70. SMOOTH_TRIANGLE *Triangle;
  71. {
  72.    VECTOR P3MinusP2, VTemp1, VTemp2;
  73.    DBL x, y, z, uDenominator, Proj;
  74.  
  75.    VSub (P3MinusP2, Triangle->P3, Triangle->P2);
  76.    x = fabs (P3MinusP2.x);
  77.    y = fabs (P3MinusP2.y);
  78.    z = fabs (P3MinusP2.z);
  79.  
  80.    switch (max3 (x, y, z)) {
  81.    case 1:  
  82.       Triangle->vAxis = X_AXIS;
  83.       Triangle->BaseDelta = P3MinusP2.x;
  84.       break;
  85.  
  86.    case 2:  
  87.       Triangle->vAxis = Y_AXIS;
  88.       Triangle->BaseDelta = P3MinusP2.y;
  89.       break;
  90.  
  91.    case 3:  
  92.       Triangle->vAxis = Z_AXIS;
  93.       Triangle->BaseDelta = P3MinusP2.z;
  94.       break;
  95.    }      
  96.  
  97.    VSub (VTemp1, Triangle->P2, Triangle->P3);
  98.    VNormalize (VTemp1, VTemp1);
  99.    VSub (VTemp2, Triangle->P1, Triangle->P3);
  100.    VDot (Proj, VTemp2, VTemp1);
  101.    VScale (VTemp1, VTemp1, Proj);
  102.    VSub (Triangle->Perp, VTemp1, VTemp2);
  103.    VNormalize (Triangle->Perp, Triangle->Perp);
  104.    VDot (uDenominator, VTemp2, Triangle->Perp);
  105.    uDenominator = -1.0 / uDenominator;
  106.    VScale (Triangle->Perp, Triangle->Perp, uDenominator);
  107. }
  108.  
  109. int Compute_Triangle (Triangle)
  110. TRIANGLE *Triangle;
  111. {
  112.    VECTOR V1, V2, Temp;
  113.    DBL Length;
  114.  
  115.    VSub (V1, Triangle->P1, Triangle->P2);
  116.    VSub (V2, Triangle->P3, Triangle->P2);
  117.    VCross (Triangle->Normal_Vector, V1, V2);
  118.    VLength (Length, Triangle->Normal_Vector);
  119.    /* Set up a flag so we can ignore degenerate triangles */
  120.    if (Length < 1.0e-9){
  121.       Triangle->Degenerate_Flag = TRUE;
  122.       return (0);
  123.    }
  124.  
  125.    /* Normalize the normal vector. */
  126.    VScale (Triangle->Normal_Vector, Triangle->Normal_Vector, 1.0/Length);
  127.  
  128.    VDot (Triangle->Distance, Triangle->Normal_Vector, Triangle->P1);
  129.    Triangle->Distance *= -1.0;
  130.    Find_Triangle_Dominant_Axis(Triangle);
  131.  
  132.    switch (Triangle->Dominant_Axis) {
  133.    case X_AXIS:
  134.       if ((Triangle->P2.y - Triangle->P3.y)*(Triangle->P2.z - Triangle->P1.z) <
  135.          (Triangle->P2.z - Triangle->P3.z)*(Triangle->P2.y - Triangle->P1.y)) {
  136.  
  137.          Temp = Triangle->P2;
  138.          Triangle->P2 = Triangle->P1;
  139.          Triangle->P1 = Temp;
  140.          if (Triangle->Type == SMOOTH_TRIANGLE_TYPE) {
  141.             Temp = ((SMOOTH_TRIANGLE *) Triangle)->N2;
  142.             ((SMOOTH_TRIANGLE *) Triangle)->N2 = ((SMOOTH_TRIANGLE *) Triangle)->N1;
  143.             ((SMOOTH_TRIANGLE *) Triangle)->N1 = Temp;
  144.          }
  145.       }
  146.       break;
  147.  
  148.    case Y_AXIS:
  149.       if ((Triangle->P2.x - Triangle->P3.x)*(Triangle->P2.z - Triangle->P1.z) <
  150.          (Triangle->P2.z - Triangle->P3.z)*(Triangle->P2.x - Triangle->P1.x)) {
  151.  
  152.          Temp = Triangle->P2;
  153.          Triangle->P2 = Triangle->P1;
  154.          Triangle->P1 = Temp;
  155.          if (Triangle->Type == SMOOTH_TRIANGLE_TYPE) {
  156.             Temp = ((SMOOTH_TRIANGLE *) Triangle)->N2;
  157.             ((SMOOTH_TRIANGLE *) Triangle)->N2 = ((SMOOTH_TRIANGLE *) Triangle)->N1;
  158.             ((SMOOTH_TRIANGLE *) Triangle)->N1 = Temp;
  159.          }
  160.       }
  161.       break;
  162.  
  163.    case Z_AXIS:
  164.       if ((Triangle->P2.x - Triangle->P3.x)*(Triangle->P2.y - Triangle->P1.y) <
  165.          (Triangle->P2.y - Triangle->P3.y)*(Triangle->P2.x - Triangle->P1.x)) {
  166.  
  167.          Temp = Triangle->P2;
  168.          Triangle->P2 = Triangle->P1;
  169.          Triangle->P1 = Temp;
  170.          if (Triangle->Type == SMOOTH_TRIANGLE_TYPE) {
  171.             Temp = ((SMOOTH_TRIANGLE *) Triangle)->N2;
  172.             ((SMOOTH_TRIANGLE *) Triangle)->N2 = ((SMOOTH_TRIANGLE *) Triangle)->N1;
  173.             ((SMOOTH_TRIANGLE *) Triangle)->N1 = Temp;
  174.          }
  175.       }
  176.       break;
  177.    }
  178.  
  179.    if (Triangle->Type == SMOOTH_TRIANGLE_TYPE)
  180.       Compute_Smooth_Triangle((SMOOTH_TRIANGLE *) Triangle);
  181.    return (1);
  182. }
  183.  
  184. int All_Triangle_Intersections (Object, Ray, Depth_Queue)
  185. OBJECT *Object;
  186. RAY *Ray;
  187. PRIOQ *Depth_Queue;
  188. {
  189.    TRIANGLE *Shape = (TRIANGLE *) Object;
  190.    DBL Depth;
  191.    VECTOR Intersection_Point;
  192.    INTERSECTION Local_Element;
  193.  
  194.    if(Shape->Degenerate_Flag)
  195.       return(FALSE);
  196.  
  197.    if (Intersect_Triangle (Ray, Shape, &Depth))
  198.    {
  199.       Local_Element.Depth = Depth;
  200.       Local_Element.Object = Shape -> Parent_Object;
  201.       VScale (Intersection_Point, Ray -> Direction, Depth);
  202.       VAdd (Intersection_Point, Intersection_Point, Ray -> Initial);
  203.       Local_Element.Point = Intersection_Point;
  204.       Local_Element.Shape = (SHAPE *)Shape;
  205.       pq_add (Depth_Queue, &Local_Element);
  206.       return (TRUE);
  207.    }
  208.    return (FALSE);
  209. }
  210.  
  211. int Intersect_Triangle (Ray, Triangle, Depth)
  212. RAY *Ray;
  213. TRIANGLE *Triangle;
  214. DBL *Depth;
  215. {
  216.    DBL NormalDotOrigin, NormalDotDirection;
  217.    DBL s, t;
  218.  
  219.    Ray_Triangle_Tests++;
  220.    if(Triangle->Degenerate_Flag)
  221.       return(FALSE);
  222.  
  223.    if (Ray == VP_Ray) {
  224.       if (!Triangle->VPCached) {
  225.          VDot (Triangle->VPNormDotOrigin, Triangle->Normal_Vector, Ray->Initial);
  226.          Triangle->VPNormDotOrigin += Triangle->Distance;
  227.          Triangle->VPNormDotOrigin *= -1.0;
  228.          Triangle->VPCached = TRUE;
  229.       }
  230.  
  231.       VDot (NormalDotDirection, Triangle->Normal_Vector, Ray->Direction);
  232.       if ((NormalDotDirection < Small_Tolerance) &&
  233.          (NormalDotDirection > -Small_Tolerance))
  234.          return (FALSE);
  235.  
  236.       *Depth = Triangle->VPNormDotOrigin / NormalDotDirection;
  237.    }
  238.    else {
  239.       VDot (NormalDotOrigin, Triangle->Normal_Vector, Ray->Initial);
  240.       NormalDotOrigin += Triangle->Distance;
  241.       NormalDotOrigin *= -1.0;
  242.  
  243.          VDot (NormalDotDirection, Triangle->Normal_Vector, Ray->Direction);
  244.       if ((NormalDotDirection < Small_Tolerance) &&
  245.          (NormalDotDirection > -Small_Tolerance))
  246.          return (FALSE);
  247.  
  248.       *Depth = NormalDotOrigin / NormalDotDirection;
  249.    }
  250.  
  251.    if ((*Depth < Small_Tolerance) || (*Depth > Max_Distance))
  252.       return (FALSE);
  253.  
  254.    switch (Triangle->Dominant_Axis) {
  255.    case X_AXIS:
  256.       s = Ray->Initial.y + *Depth * Ray->Direction.y;
  257.       t = Ray->Initial.z + *Depth * Ray->Direction.z;
  258.  
  259.       if ((Triangle->P2.y - s)*(Triangle->P2.z - Triangle->P1.z) <
  260.          (Triangle->P2.z - t)*(Triangle->P2.y - Triangle->P1.y))
  261.          if ((int) Triangle->Inverted) {
  262.             Ray_Triangle_Tests_Succeeded++;
  263.             return (TRUE);
  264.          }
  265.          else
  266.             return (FALSE);
  267.  
  268.       if ((Triangle->P3.y - s)*(Triangle->P3.z - Triangle->P2.z) <
  269.          (Triangle->P3.z - t)*(Triangle->P3.y - Triangle->P2.y))
  270.          if ((int) Triangle->Inverted) {
  271.             Ray_Triangle_Tests_Succeeded++;
  272.             return (TRUE);
  273.          }
  274.          else
  275.             return (FALSE);
  276.  
  277.       if ((Triangle->P1.y - s)*(Triangle->P1.z - Triangle->P3.z) <
  278.          (Triangle->P1.z - t)*(Triangle->P1.y - Triangle->P3.y))
  279.          if ((int) Triangle->Inverted) {
  280.             Ray_Triangle_Tests_Succeeded++;
  281.             return (TRUE);
  282.          }
  283.          else
  284.             return (FALSE);
  285.  
  286.       if (!(int) Triangle->Inverted) {
  287.          Ray_Triangle_Tests_Succeeded++;
  288.          return (TRUE);
  289.       }
  290.       else
  291.          return (FALSE);
  292.  
  293.    case Y_AXIS:
  294.       s = Ray->Initial.x + *Depth * Ray->Direction.x;
  295.       t = Ray->Initial.z + *Depth * Ray->Direction.z;
  296.  
  297.       if ((Triangle->P2.x - s)*(Triangle->P2.z - Triangle->P1.z) <
  298.          (Triangle->P2.z - t)*(Triangle->P2.x - Triangle->P1.x))
  299.          if ((int) Triangle->Inverted) {
  300.             Ray_Triangle_Tests_Succeeded++;
  301.             return (TRUE);
  302.          }
  303.          else
  304.             return (FALSE);
  305.  
  306.       if ((Triangle->P3.x - s)*(Triangle->P3.z - Triangle->P2.z) <
  307.          (Triangle->P3.z - t)*(Triangle->P3.x - Triangle->P2.x))
  308.          if ((int) Triangle->Inverted) {
  309.             Ray_Triangle_Tests_Succeeded++;
  310.             return (TRUE);
  311.          }
  312.          else
  313.             return (FALSE);
  314.  
  315.       if ((Triangle->P1.x - s)*(Triangle->P1.z - Triangle->P3.z) <
  316.          (Triangle->P1.z - t)*(Triangle->P1.x - Triangle->P3.x))
  317.          if ((int) Triangle->Inverted) {
  318.             Ray_Triangle_Tests_Succeeded++;
  319.             return (TRUE);
  320.          }
  321.          else
  322.             return (FALSE);
  323.  
  324.       if (!(int) Triangle->Inverted) {
  325.          Ray_Triangle_Tests_Succeeded++;
  326.          return (TRUE);
  327.       }
  328.       else
  329.          return (FALSE);
  330.  
  331.    case Z_AXIS:
  332.       s = Ray->Initial.x + *Depth * Ray->Direction.x;
  333.       t = Ray->Initial.y + *Depth * Ray->Direction.y;
  334.  
  335.       if ((Triangle->P2.x - s)*(Triangle->P2.y - Triangle->P1.y) <
  336.          (Triangle->P2.y - t)*(Triangle->P2.x - Triangle->P1.x))
  337.          if ((int) Triangle->Inverted) {
  338.             Ray_Triangle_Tests_Succeeded++;
  339.             return (TRUE);
  340.          }
  341.          else
  342.             return (FALSE);
  343.  
  344.       if ((Triangle->P3.x - s)*(Triangle->P3.y - Triangle->P2.y) <
  345.          (Triangle->P3.y - t)*(Triangle->P3.x - Triangle->P2.x))
  346.          if ((int) Triangle->Inverted) {
  347.             Ray_Triangle_Tests_Succeeded++;
  348.             return (TRUE);
  349.          }
  350.          else
  351.             return (FALSE);
  352.  
  353.       if ((Triangle->P1.x - s)*(Triangle->P1.y - Triangle->P3.y) <
  354.          (Triangle->P1.y - t)*(Triangle->P1.x - Triangle->P3.x))
  355.          if ((int) Triangle->Inverted) {
  356.             Ray_Triangle_Tests_Succeeded++;
  357.             return (TRUE);
  358.          }
  359.          else
  360.             return (FALSE);
  361.  
  362.       if (!(int) Triangle->Inverted) {
  363.          Ray_Triangle_Tests_Succeeded++;
  364.          return (TRUE);
  365.       }
  366.       else
  367.          return (FALSE);
  368.  
  369.    }
  370.    return (FALSE);
  371. }
  372.  
  373. int Inside_Triangle (Test_Point, Object)
  374. VECTOR *Test_Point;
  375. OBJECT *Object;
  376. {
  377.    return (FALSE);
  378. }
  379.  
  380. void Triangle_Normal (Result, Object, Intersection_Point)
  381. OBJECT *Object;
  382. VECTOR *Result, *Intersection_Point;
  383. {
  384.    TRIANGLE *Triangle = (TRIANGLE *) Object;
  385.  
  386.    *Result = Triangle->Normal_Vector;
  387. }
  388.  
  389. void *Copy_Triangle (Object)
  390. OBJECT *Object;
  391. {
  392.    TRIANGLE *New_Shape;
  393.  
  394.    New_Shape = Get_Triangle_Shape ();
  395.    *New_Shape = * ((TRIANGLE *)Object);
  396.    New_Shape -> Next_Object = NULL;
  397.  
  398.    if (New_Shape->Shape_Texture != NULL)
  399.       New_Shape->Shape_Texture = Copy_Texture (New_Shape->Shape_Texture);
  400.  
  401.    return (New_Shape);
  402. }
  403.  
  404. void Translate_Triangle (Object, Vector)
  405. OBJECT *Object;
  406. VECTOR *Vector;
  407. {
  408.    TRIANGLE *Triangle = (TRIANGLE *) Object;
  409.    VECTOR Translation;
  410.  
  411.    VEvaluate (Translation, Triangle->Normal_Vector, *Vector);
  412.    Triangle->Distance -= Translation.x + Translation.y + Translation.z;
  413.    VAdd (Triangle->P1, Triangle->P1, *Vector)
  414.       VAdd (Triangle->P2, Triangle->P2, *Vector)
  415.          VAdd (Triangle->P3, Triangle->P3, *Vector)
  416.  
  417.             Translate_Texture (&((TRIANGLE *) Object)->Shape_Texture, Vector);
  418. }
  419.  
  420. void Rotate_Triangle (Object, Vector)
  421. OBJECT *Object;
  422. VECTOR *Vector;
  423. {
  424.    TRANSFORMATION Transformation;
  425.    TRIANGLE *Triangle = (TRIANGLE *) Object;
  426.  
  427.    Get_Rotation_Transformation (&Transformation, Vector);
  428.    MTransformVector (&Triangle->Normal_Vector,
  429.       &Triangle->Normal_Vector, &Transformation);
  430.    MTransformVector (&Triangle->P1, &Triangle->P1, &Transformation);
  431.    MTransformVector (&Triangle->P2, &Triangle->P2, &Transformation);
  432.    MTransformVector (&Triangle->P3, &Triangle->P3, &Transformation);
  433.    Compute_Triangle (Triangle);
  434.  
  435.    Rotate_Texture (&((TRIANGLE *) Object)->Shape_Texture, Vector);
  436. }
  437.  
  438. void Scale_Triangle (Object, Vector)
  439. OBJECT *Object;
  440. VECTOR *Vector;
  441. {
  442.    TRIANGLE *Triangle = (TRIANGLE *) Object;
  443.    DBL Length;
  444.  
  445.    Triangle->Normal_Vector.x = Triangle->Normal_Vector.x / Vector->x;
  446.    Triangle->Normal_Vector.y = Triangle->Normal_Vector.y / Vector->y;
  447.    Triangle->Normal_Vector.z = Triangle->Normal_Vector.z / Vector->z;
  448.  
  449.    VLength(Length, Triangle->Normal_Vector);
  450.    VScale (Triangle->Normal_Vector, Triangle->Normal_Vector, 1.0 / Length);
  451.    Triangle->Distance /= Length;
  452.  
  453.    VEvaluate (Triangle->P1, Triangle->P1, *Vector);
  454.    VEvaluate (Triangle->P2, Triangle->P2, *Vector);
  455.    VEvaluate (Triangle->P3, Triangle->P3, *Vector);
  456.  
  457.    Scale_Texture (&((TRIANGLE *) Object)->Shape_Texture, Vector);
  458. }
  459.  
  460.  
  461. void Invert_Triangle (Object)
  462. OBJECT *Object;
  463. {
  464.    TRIANGLE *Triangle = (TRIANGLE  *) Object;
  465.  
  466.    Triangle->Inverted ^= TRUE;
  467. }
  468.  
  469. /* Calculate the Phong-interpolated vector within the triangle
  470.    at the given intersection point. The math for this is a bit
  471.    bizarre:
  472.  
  473.     -         P1
  474.     |        /|\ \
  475.     |       / |Perp\
  476.     |      /  V  \   \
  477.     |     /   |    \   \
  478.   u |    /____|_____PI___\
  479.     |   /     |       \    \
  480.     -  P2-----|--------|----P3
  481.               Pbase    PIntersect
  482.         |-------------------|
  483.                        v
  484.  
  485.    Triangle->Perp is a unit vector from P1 to Pbase. We calculate
  486.  
  487.    u = (PI - P1) DOT Perp / ((P3 - P1) DOT Perp).
  488.  
  489.    We then calculate where the line from P1 to PI intersects the line P2 to P3:
  490.    PIntersect = (PI - P1)/u.
  491.  
  492.    We really only need one coordinate of PIntersect.  We then calculate v as:
  493.  
  494.       v = PIntersect.x / (P3.x - P2.x)
  495.  or   v = PIntersect.y / (P3.y - P2.y)
  496.  or   v = PIntersect.z / (P3.z - P2.z)
  497.  
  498.    depending on which calculation will give us the best answers.
  499.  
  500.    Once we have u and v, we can perform the normal interpolation as:
  501.  
  502.      NTemp1 = N1 + u(N2 - N1);
  503.      NTemp2 = N1 + u(N3 - N1);
  504.      Result = normalize (NTemp1 + v(NTemp2 - NTemp1))
  505.  
  506.    As always, any values which are constant for the triangle are cached
  507.    in the triangle.
  508. */
  509.  
  510. void Smooth_Triangle_Normal (Result, Object, Intersection_Point)
  511. OBJECT *Object;
  512. VECTOR *Result, *Intersection_Point;
  513. {
  514.    SMOOTH_TRIANGLE *Triangle = (SMOOTH_TRIANGLE *) Object;
  515.    VECTOR PIMinusP1, NTemp1, NTemp2;
  516.    DBL u = 0.0, v = 0.0;
  517.  
  518.    VSub (PIMinusP1, *Intersection_Point, Triangle->P1);
  519.    VDot (u, PIMinusP1, Triangle->Perp);
  520.    if (u < 1.0e-9) {
  521.       *Result = Triangle->N1;
  522.       return;
  523.    }
  524.  
  525.    /* BaseDelta contains P3.x-P2.x,  P3.y-P2.y, or P3.z-P2.z depending on the
  526.       value of vAxis. */
  527.  
  528.    switch (Triangle->vAxis) {
  529.    case X_AXIS:  
  530.       v = (PIMinusP1.x/u + Triangle->P1.x - Triangle->P2.x) / Triangle->BaseDelta;
  531.       break;
  532.  
  533.    case Y_AXIS:  
  534.       v = (PIMinusP1.y/u + Triangle->P1.y - Triangle->P2.y) / Triangle->BaseDelta;
  535.       break;
  536.  
  537.    case Z_AXIS:  
  538.       v = (PIMinusP1.z/u + Triangle->P1.z - Triangle->P2.z)/ Triangle->BaseDelta;
  539.       break;
  540.    }
  541.  
  542.    VSub (NTemp1, Triangle->N2, Triangle->N1);
  543.    VScale (NTemp1, NTemp1, u);
  544.    VAdd (NTemp1, NTemp1, Triangle->N1);
  545.    VSub (NTemp2, Triangle->N3, Triangle->N1);
  546.    VScale (NTemp2, NTemp2, u);
  547.    VAdd (NTemp2, NTemp2, Triangle->N1);
  548.    VSub (*Result, NTemp2, NTemp1);
  549.    VScale (*Result, *Result, v);
  550.    VAdd (*Result, *Result, NTemp1); 
  551.    VNormalize (*Result, *Result);
  552. }
  553.  
  554. void *Copy_Smooth_Triangle (Object)
  555. OBJECT *Object;
  556. {
  557.    SMOOTH_TRIANGLE *New_Shape;
  558.  
  559.    New_Shape = Get_Smooth_Triangle_Shape ();
  560.    *New_Shape = * ((SMOOTH_TRIANGLE *)Object);
  561.    New_Shape -> Next_Object = NULL;
  562.  
  563.    if (New_Shape->Shape_Texture != NULL)
  564.       New_Shape->Shape_Texture = Copy_Texture (New_Shape->Shape_Texture);
  565.  
  566.    return (New_Shape);
  567. }
  568.  
  569. void Rotate_Smooth_Triangle (Object, Vector)
  570. OBJECT *Object;
  571. VECTOR *Vector;
  572. {
  573.    TRANSFORMATION Transformation;
  574.    SMOOTH_TRIANGLE *Triangle = (SMOOTH_TRIANGLE *) Object;
  575.  
  576.    Get_Rotation_Transformation (&Transformation, Vector);
  577.    MTransformVector (&Triangle->Normal_Vector,
  578.       &Triangle->Normal_Vector, &Transformation);
  579.    MTransformVector (&Triangle->P1, &Triangle->P1, &Transformation);
  580.    MTransformVector (&Triangle->P2, &Triangle->P2, &Transformation);
  581.    MTransformVector (&Triangle->P3, &Triangle->P3, &Transformation);
  582.    MTransformVector (&Triangle->N1, &Triangle->N1, &Transformation);
  583.    MTransformVector (&Triangle->N2, &Triangle->N2, &Transformation);
  584.    MTransformVector (&Triangle->N3, &Triangle->N3, &Transformation);
  585.    Compute_Triangle ((TRIANGLE *) Triangle);
  586.  
  587.    Rotate_Texture (&((TRIANGLE *) Object)->Shape_Texture, Vector);
  588. }
  589.  
  590. void Translate_Smooth_Triangle (Object, Vector)
  591. OBJECT *Object;
  592. VECTOR *Vector;
  593. {
  594.    SMOOTH_TRIANGLE *Triangle = (SMOOTH_TRIANGLE *) Object;
  595.    VECTOR Translation;
  596.  
  597.    VEvaluate (Translation, Triangle->Normal_Vector, *Vector);
  598.    Triangle->Distance -= Translation.x + Translation.y + Translation.z;
  599.    VAdd (Triangle->P1, Triangle->P1, *Vector)
  600.       VAdd (Triangle->P2, Triangle->P2, *Vector)
  601.          VAdd (Triangle->P3, Triangle->P3, *Vector)
  602.             Compute_Triangle ((TRIANGLE *) Triangle);
  603.  
  604.    Translate_Texture (&((TRIANGLE *) Object)->Shape_Texture, Vector);
  605. }
  606.  
  607. void Scale_Smooth_Triangle (Object, Vector)
  608. OBJECT *Object;
  609. VECTOR *Vector;
  610. {
  611.    SMOOTH_TRIANGLE *Triangle = (SMOOTH_TRIANGLE *) Object;
  612.    DBL Length;
  613.  
  614.    Triangle->Normal_Vector.x = Triangle->Normal_Vector.x / Vector->x;
  615.    Triangle->Normal_Vector.y = Triangle->Normal_Vector.y / Vector->y;
  616.    Triangle->Normal_Vector.z = Triangle->Normal_Vector.z / Vector->z;
  617.  
  618.    VLength(Length, Triangle->Normal_Vector);
  619.    VScale (Triangle->Normal_Vector, Triangle->Normal_Vector, 1.0 / Length);
  620.    Triangle->Distance /= Length;
  621.  
  622.    VEvaluate (Triangle->P1, Triangle->P1, *Vector);
  623.    VEvaluate (Triangle->P2, Triangle->P2, *Vector);
  624.    VEvaluate (Triangle->P3, Triangle->P3, *Vector);
  625.    Compute_Triangle ((TRIANGLE *) Triangle);
  626.  
  627.    Scale_Texture (&((SMOOTH_TRIANGLE *) Object)->Shape_Texture, Vector);
  628. }
  629.  
  630.  
  631. void Invert_Smooth_Triangle (Object)
  632. OBJECT *Object;
  633. {
  634.    SMOOTH_TRIANGLE *Triangle = (SMOOTH_TRIANGLE  *) Object;
  635.  
  636.    Triangle->Inverted ^= TRUE;
  637. }
  638.