home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Professional / OS2PRO194.ISO / os2 / graphic / dkb / source / parse.c < prev    next >
Encoding:
C/C++ Source or Header  |  1992-07-28  |  74.1 KB  |  2,623 lines
  1. /*****************************************************************************
  2. *
  3. *                                    parse.c
  4. *
  5. *   from DKBTrace (c) 1990  David Buck
  6. *
  7. *  This module implements a parser for the scene description files.
  8. *
  9. * This software is freely distributable. The source and/or object code may be
  10. * copied or uploaded to communications services so long as this notice remains
  11. * at the top of each file.  If any changes are made to the program, you must
  12. * clearly indicate in the documentation and in the programs startup message
  13. * who it was who made the changes. The documentation should also describe what
  14. * those changes were. This software may not be included in whole or in
  15. * part into any commercial package without the express written consent of the
  16. * author.  It may, however, be included in other public domain or freely
  17. * distributed software so long as the proper credit for the software is given.
  18. *
  19. * This software is provided as is without any guarantees or warranty. Although
  20. * the author has attempted to find and correct any bugs in the software, he
  21. * is not responsible for any damage caused by the use of the software.  The
  22. * author is under no obligation to provide service, corrections, or upgrades
  23. * to this package.
  24. *
  25. * Despite all the legal stuff above, if you do find bugs, I would like to hear
  26. * about them.  Also, if you have any comments or questions, you may contact me
  27. * at the following address:
  28. *
  29. *     David Buck
  30. *     22C Sonnet Cres.
  31. *     Nepean Ontario
  32. *     Canada, K2H 8W7
  33. *
  34. *  I can also be reached on the following bulletin boards:
  35. *
  36. *     OMX              (613) 731-3419
  37. *     Mystic           (613) 596-4249  or  (613) 596-4772
  38. *
  39. *  Fidonet:   1:163/109.9
  40. *  Internet:  dbuck@ccs.carleton.ca
  41. *  The "You Can Call Me RAY" BBS    (708) 358-5611
  42. *
  43. *  IBM Port by Aaron A. Collins. Aaron may be reached on the following BBS'es:
  44. *
  45. *     The "You Can Call Me RAY" BBS (708) 358-5611
  46. *     The Information Exchange BBS  (708) 945-5575
  47. *
  48. *****************************************************************************/
  49.  
  50. #include "frame.h"
  51. #include "vector.h"
  52. #include "dkbproto.h"
  53.  
  54. /* This file implements a simple recursive-descent parser for reading the
  55. input file.  */
  56.  
  57. FRAME *Parsing_Frame_Ptr;
  58.  
  59. extern METHODS Composite_Methods;
  60. extern METHODS Basic_Object_Methods;
  61. extern METHODS Sphere_Methods;
  62. extern METHODS Quadric_Methods;
  63. extern METHODS Quartic_Methods;
  64. extern METHODS Viewpoint_Methods;
  65. extern METHODS Plane_Methods;
  66. extern METHODS Triangle_Methods;
  67. extern METHODS Smooth_Triangle_Methods;
  68. extern METHODS CSG_Union_Methods;
  69. extern METHODS CSG_Intersection_Methods;
  70.  
  71. extern struct Reserved_Word_Struct Reserved_Words [];
  72. extern DBL Antialias_Threshold;
  73.  
  74. extern struct Token_Struct Token;
  75.  
  76. #define MAX_CONSTANTS 250
  77. struct Constant_Struct Constants[MAX_CONSTANTS];
  78. int Number_Of_Constants;
  79. TEXTURE *Default_Texture;
  80. int Degenerate_Triangles;
  81.  
  82. /* Here we create out own little language for doing the parsing.  It
  83. makes the code easier to read. */
  84.  
  85. #define EXPECT { int Exit_Flag; Exit_Flag = FALSE; \
  86.  while (!Exit_Flag) {Get_Token();  switch (Token.Token_Id) {
  87. #define CASE(x) case x:
  88. #define CASE2(x, y) case x: case y:
  89. #define CASE3(x, y, z) case x: case y: case z:
  90. #define CASE4(w, x, y, z) case w: case x: case y: case z:
  91. #define CASE5(v, w, x, y, z) case v: case w: case x: case y: case z:
  92. #define CASE6(u, v, w, x, y, z) case u: case v: case w: case x: case y: case z:
  93. #define END_CASE break;
  94. #define EXIT Exit_Flag = TRUE;
  95. #define OTHERWISE default:
  96. #define END_EXPECT } } }
  97. #define GET(x) Get_Token(); if (Token.Token_Id != x) Parse_Error (x)
  98. #define UNGET Unget_Token();
  99.  
  100. /*
  101.  
  102. char *Coeff_terms[35] = {
  103.    "x^4", "x^3*y", "x^3*z", "x^3", "x^2*y^2", "x^2*y*z", "x^2*y", "x^2*z^2",
  104.    "x^2*z", "x^2", "x*y^3", "x*y^2*z", "x*y^2", "x*y*z^2", "x*y*z", "x*y",
  105.    "x*z^3", "x*z^2", "x*z", "x", "y^4", "y^3*z", "y^3", "y^2*z^2", "y^2*z",
  106.    "y^2", "y*z^3", "y*z^2", "y*z", "y", "z^4", "z^3", "z^2", "z", ""
  107.    };
  108.  
  109. void show_quartic(Coeffs)
  110. DBL *Coeffs;
  111. {
  112.    int i,j;
  113.    for (i=0,j=0;i<35;i++)
  114.       if (Coeffs[i] != 0.0) {
  115.      if (j) PRINT(" + ");
  116.      PRINT("%.5Lg %s", Coeffs[i], Coeff_terms[i]);
  117.      j = 1;
  118.      }
  119. }
  120.  
  121. */
  122.  
  123. /* Parse the file into the given frame. */
  124. void Parse (Frame_Ptr)
  125.   FRAME *Frame_Ptr;
  126.   {
  127.   Parsing_Frame_Ptr = Frame_Ptr;
  128.  
  129.   Degenerate_Triangles = FALSE;
  130.   Token_Init ();
  131.   Frame_Init ();
  132.   Parse_Frame ();
  133.   if (Degenerate_Triangles) {
  134.      PRINT ("Cannot continue due to degenerate triangles.\n");
  135.      return;
  136.      }
  137.   }
  138.  
  139. void Token_Init ()
  140.   {
  141.   Number_Of_Constants = 0;
  142.   }
  143.  
  144.  
  145. /* Set up the fields in the frame to default values. */
  146. void Frame_Init ()
  147.   {
  148.   Default_Texture = Get_Texture();
  149.   Init_Viewpoint(&(Parsing_Frame_Ptr -> View_Point));
  150.   Parsing_Frame_Ptr -> Light_Sources = NULL;
  151.   Parsing_Frame_Ptr -> Objects = NULL;
  152.   Parsing_Frame_Ptr -> Atmosphere_IOR = 1.0;
  153.   Parsing_Frame_Ptr -> Antialias_Threshold = Antialias_Threshold;
  154.   Parsing_Frame_Ptr -> Fog_Distance = 0.0;
  155.   Make_Colour (&(Parsing_Frame_Ptr->Fog_Colour), 0.0, 0.0, 0.0);
  156.   }
  157.  
  158. /* Allocate and initialize a composite object. */
  159. COMPOSITE *Get_Composite_Object()
  160.   {
  161.   COMPOSITE *New_Composite;
  162.  
  163.   if ((New_Composite = (COMPOSITE *) malloc (sizeof (COMPOSITE)))
  164.         == NULL)
  165.     Error ("Cannot allocate object");
  166.  
  167.   New_Composite -> Objects = NULL;
  168.   New_Composite -> Next_Object = NULL;
  169.   New_Composite -> Next_Light_Source = NULL;
  170.   New_Composite -> Bounding_Shapes = NULL;
  171.   New_Composite -> Type = COMPOSITE_TYPE;
  172.   New_Composite -> Methods = &Composite_Methods;
  173.   return (New_Composite);
  174.   }
  175.  
  176. /* Allocate and initialize a sphere. */
  177. SPHERE *Get_Sphere_Shape()
  178.   {
  179.   SPHERE *New_Shape;
  180.  
  181.   if ((New_Shape = (SPHERE *) malloc (sizeof (SPHERE))) == NULL)
  182.     Error ("Cannot allocate shape");
  183.  
  184.   Make_Vector (&(New_Shape -> Center), 0.0, 0.0, 0.0);
  185.   New_Shape->Radius = 1.0;
  186.   New_Shape->Radius_Squared = 1.0;
  187.   New_Shape->Inverse_Radius = 1.0;
  188.   New_Shape -> Type = SPHERE_TYPE;
  189.   New_Shape -> Next_Object = NULL;
  190.   New_Shape -> Methods = &Sphere_Methods;
  191.   New_Shape -> VPCached = FALSE;
  192.   New_Shape -> Inverted = FALSE;
  193.   New_Shape -> Shape_Texture = NULL;
  194.   New_Shape -> Shape_Colour = NULL;
  195.   return (New_Shape);
  196.   }
  197.  
  198. /* Allocate and initialize a quadric surface. */
  199. QUADRIC *Get_Quadric_Shape()
  200.   {
  201.   QUADRIC *New_Shape;
  202.  
  203.   if ((New_Shape = (QUADRIC *) malloc (sizeof (QUADRIC))) == NULL)
  204.     Error ("Cannot allocate shape");
  205.  
  206.   Make_Vector (&(New_Shape -> Object_2_Terms), 1.0, 1.0, 1.0);
  207.   Make_Vector (&(New_Shape -> Object_Mixed_Terms), 0.0, 0.0, 0.0);
  208.   Make_Vector (&(New_Shape -> Object_Terms), 0.0, 0.0, 0.0);
  209.   New_Shape -> Object_Constant = 1.0;
  210.   New_Shape -> Object_VP_Constant = HUGE_VAL;
  211.   New_Shape -> Constant_Cached = FALSE;
  212.   New_Shape -> Non_Zero_Square_Term = FALSE;
  213.   New_Shape -> Type = QUADRIC_TYPE;
  214.   New_Shape -> Next_Object = NULL;
  215.   New_Shape -> Methods = &Quadric_Methods;
  216.   New_Shape -> Shape_Texture = NULL;
  217.   New_Shape -> Shape_Colour = NULL;
  218.   return (New_Shape);
  219.   }
  220.  
  221. /* Allocate and initialize a quartic surface. */
  222. QUARTIC *Get_Quartic_Shape()
  223. {
  224.    QUARTIC *New_Shape;
  225.    int i;
  226.  
  227.    if ((New_Shape = (QUARTIC *) malloc (sizeof (QUARTIC))) == NULL)
  228.       Error ("Cannot allocate shape");
  229.  
  230.    for (i=0;i<35;i++)
  231.       New_Shape->Coeffs[i] = 0.0;
  232.    New_Shape -> Type = QUARTIC_TYPE;
  233.    New_Shape -> Next_Object = NULL;
  234.    New_Shape -> Methods = &Quartic_Methods;
  235.    New_Shape -> Shape_Texture = NULL;
  236.    New_Shape -> Shape_Colour = NULL;
  237.    return (New_Shape);
  238. }
  239.  
  240. /* Allocate and initialize a plane. */
  241. PLANE *Get_Plane_Shape()
  242.   {
  243.   PLANE *New_Shape;
  244.  
  245.   if ((New_Shape = (PLANE *) malloc (sizeof (PLANE))) == NULL)
  246.     Error ("Cannot allocate shape");
  247.  
  248.   Make_Vector (&(New_Shape -> Normal_Vector), 0.0, 1.0, 0.0);
  249.   New_Shape->Distance = 0.0;
  250.   New_Shape -> Type = PLANE_TYPE;
  251.   New_Shape -> Next_Object = NULL;
  252.   New_Shape -> Methods = &Plane_Methods;
  253.   New_Shape -> VPCached = 0;
  254.   New_Shape -> Shape_Texture = NULL;
  255.   New_Shape -> Shape_Colour = NULL;
  256.   return (New_Shape);
  257.   }
  258.  
  259. /* Allocate and initialize a triangle. */
  260. TRIANGLE *Get_Triangle_Shape()
  261.   {
  262.   TRIANGLE *New_Shape;
  263.  
  264.   if ((New_Shape = (TRIANGLE *) malloc (sizeof (TRIANGLE))) == NULL)
  265.     Error ("Cannot allocate shape");
  266.  
  267.   Make_Vector (&(New_Shape -> Normal_Vector), 0.0, 1.0, 0.0);
  268.   Make_Vector (&(New_Shape -> P1), 0.0, 0.0, 0.0);
  269.   Make_Vector (&(New_Shape -> P2), 1.0, 0.0, 0.0);
  270.   Make_Vector (&(New_Shape -> P3), 0.0, 1.0, 0.0);
  271.   New_Shape->Distance = 0.0;
  272.   New_Shape->Inverted = FALSE;
  273.   New_Shape -> Type = TRIANGLE_TYPE;
  274.   New_Shape -> Next_Object = NULL;
  275.   New_Shape -> Methods = &Triangle_Methods;
  276.   New_Shape -> VPCached = FALSE;
  277.   New_Shape -> Shape_Texture = NULL;
  278.   New_Shape -> Shape_Colour = NULL;
  279.   return (New_Shape);
  280.   }
  281.  
  282. /* Allocate and initialize a smooth triangle. */
  283. SMOOTH_TRIANGLE *Get_Smooth_Triangle_Shape()
  284.   {
  285.   SMOOTH_TRIANGLE *New_Shape;
  286.  
  287.   if ((New_Shape = (SMOOTH_TRIANGLE *) malloc (sizeof (SMOOTH_TRIANGLE))) == NULL)
  288.     Error ("Cannot allocate shape");
  289.  
  290.   Make_Vector (&(New_Shape -> Normal_Vector), 0.0, 1.0, 0.0);
  291.   Make_Vector (&(New_Shape -> P1), 0.0, 0.0, 0.0);
  292.   Make_Vector (&(New_Shape -> P2), 1.0, 0.0, 0.0);
  293.   Make_Vector (&(New_Shape -> P3), 0.0, 1.0, 0.0);
  294.   Make_Vector (&(New_Shape -> N1), 0.0, 1.0, 0.0);
  295.   Make_Vector (&(New_Shape -> N2), 0.0, 1.0, 0.0);
  296.   Make_Vector (&(New_Shape -> N3), 0.0, 1.0, 0.0);
  297.   New_Shape->Distance = 0.0;
  298.   New_Shape -> Type = SMOOTH_TRIANGLE_TYPE;
  299.   New_Shape->Inverted = FALSE;
  300.   New_Shape -> Next_Object = NULL;
  301.   New_Shape -> Methods = &Smooth_Triangle_Methods;
  302.   New_Shape -> VPCached = 0;
  303.   New_Shape -> Shape_Texture = NULL;
  304.   New_Shape -> Shape_Colour = NULL;
  305.   return (New_Shape);
  306.   }
  307.  
  308. CSG_SHAPE *Get_CSG_Shape()
  309.   {
  310.   CSG_SHAPE *New_Shape;
  311.  
  312.   if ((New_Shape = (CSG_SHAPE *) malloc (sizeof (CSG_SHAPE))) == NULL)
  313.     Error ("Cannot allocate shape");
  314.  
  315.   New_Shape -> Parent_Object = NULL;
  316.   New_Shape -> Next_Object = NULL;
  317.   New_Shape -> Shapes = NULL;
  318.   return (New_Shape);
  319.   }
  320.  
  321. CSG_SHAPE *Get_CSG_Union()
  322.   {
  323.   CSG_SHAPE *New_Shape;
  324.  
  325.   New_Shape = Get_CSG_Shape();
  326.   New_Shape -> Methods = &CSG_Union_Methods;
  327.   New_Shape -> Type = CSG_UNION_TYPE;
  328.   return (New_Shape);
  329.   }
  330.  
  331. CSG_SHAPE *Get_CSG_Intersection()
  332.   {
  333.   CSG_SHAPE *New_Shape;
  334.  
  335.   New_Shape = Get_CSG_Shape();
  336.   New_Shape -> Methods = &CSG_Intersection_Methods;
  337.   New_Shape -> Type = CSG_INTERSECTION_TYPE;
  338.   return (New_Shape);
  339.   }
  340.  
  341. OBJECT *Get_Object ()
  342.   {
  343.   OBJECT *New_Object;
  344.  
  345.   if ((New_Object = (OBJECT *) malloc (sizeof (OBJECT))) == NULL)
  346.     Error ("Cannot allocate object");
  347.  
  348.   Make_Vector (&(New_Object -> Object_Center), 0.0, 0.0, 0.0);
  349.  
  350.   New_Object -> Next_Object = NULL;
  351.   New_Object -> Next_Light_Source = NULL;
  352.   New_Object -> Shape = NULL;
  353.   New_Object -> Bounding_Shapes = NULL;
  354.   New_Object -> Object_Texture = Default_Texture;
  355.  
  356.   New_Object->Object_Colour = NULL;
  357.  
  358.   New_Object -> Light_Source_Flag = FALSE;
  359.   New_Object -> Type = OBJECT_TYPE;
  360.   New_Object -> Methods = &Basic_Object_Methods;
  361.   return (New_Object);
  362.   }
  363.  
  364. TEXTURE *Get_Texture ()
  365.    {
  366.    TEXTURE *New_Texture;
  367.  
  368.    if ((New_Texture = (TEXTURE *) malloc (sizeof (TEXTURE))) == NULL)
  369.      Error ("Cannot allocate object");
  370.  
  371.    New_Texture -> Next_Texture = NULL;
  372.    New_Texture -> Object_Reflection = 0.0;
  373.    New_Texture -> Object_Ambient = 0.3;
  374.    New_Texture -> Object_Diffuse = 0.7;
  375.    New_Texture -> Object_Brilliance = 1.0;
  376.    New_Texture -> Object_Specular = 0.0;
  377.    New_Texture -> Object_Roughness = 0.05;
  378.    New_Texture -> Object_Phong = 0.0;
  379.    New_Texture -> Object_PhongSize = 40;
  380.  
  381.    New_Texture -> Texture_Randomness= 0.0;
  382.    New_Texture -> Bump_Amount = 0.0;
  383.    New_Texture -> Phase = 0.0;
  384.    New_Texture -> Frequency = 1.0;
  385.    New_Texture -> Texture_Number = NO_TEXTURE;
  386.    New_Texture -> Texture_Transformation = NULL;
  387.    New_Texture -> Bump_Number = NO_BUMPS;
  388.    New_Texture -> Turbulence = 0.0;
  389.    New_Texture -> Colour_Map = NULL;
  390.    New_Texture -> Once_Flag = FALSE;
  391.    New_Texture -> Metallic_Flag = FALSE;
  392.  
  393.    New_Texture -> Constant_Flag = TRUE;
  394.    New_Texture -> Colour1 = NULL;
  395.    New_Texture -> Colour2 = NULL;
  396.    Make_Vector (&New_Texture->Texture_Gradient, 0.0, 0.0, 0.0);
  397.  
  398.    New_Texture -> Object_Index_Of_Refraction = 1.0;
  399.    New_Texture -> Object_Refraction = 0.0;
  400.  
  401.    return (New_Texture);
  402.    }
  403.  
  404. VIEWPOINT *Get_Viewpoint ()
  405.   {
  406.   VIEWPOINT *New_Viewpoint;
  407.  
  408.   if ((New_Viewpoint = (VIEWPOINT *)malloc (sizeof (VIEWPOINT)))
  409.         == NULL)
  410.     Error ("Cannot allocate viewpoint");
  411.  
  412.   Init_Viewpoint (New_Viewpoint);
  413.   return (New_Viewpoint);
  414.   }
  415.  
  416. COLOUR *Get_Colour ()
  417.   {
  418.   COLOUR *New_Colour;
  419.  
  420.   if ((New_Colour = (COLOUR *) malloc (sizeof (COLOUR))) == NULL)
  421.     Error ("Cannot allocate colour");
  422.  
  423.   Make_Colour (New_Colour, 0.0, 0.0, 0.0);
  424.   return (New_Colour);
  425.   }
  426.  
  427. VECTOR *Get_Vector ()
  428.   {
  429.   VECTOR *New_Vector;
  430.  
  431.   if ((New_Vector = (VECTOR *) malloc (sizeof (VECTOR))) == NULL)
  432.     Error ("Cannot allocate vector");
  433.  
  434.   New_Vector -> x = 0.0;
  435.   New_Vector -> y = 0.0;
  436.   New_Vector -> z = 0.0;
  437.   return (New_Vector);
  438.   }
  439.  
  440. DBL *Get_Float ()
  441.   {
  442.   DBL *New_Float;
  443.  
  444.   if ((New_Float = (DBL *) malloc (sizeof (DBL))) == NULL)
  445.     Error ("Cannot allocate float");
  446.  
  447.   *New_Float = 0.0;
  448.   return (New_Float);
  449.   }
  450.  
  451. TRANSFORMATION *Get_Transformation()
  452.   {
  453.   TRANSFORMATION *New_Transformation;
  454.  
  455.   if ((New_Transformation =
  456.         (TRANSFORMATION *) malloc (sizeof (TRANSFORMATION))) == NULL)
  457.     Error ("Cannot allocate transformation");
  458.  
  459.   MIdentity ((MATRIX *) &(New_Transformation -> matrix[0][0]));
  460.   MIdentity ((MATRIX *) &(New_Transformation -> inverse[0][0]));
  461.   return (New_Transformation);
  462.   }
  463.  
  464. /* Parse a float.  Doesn't handle exponentiation. */
  465. DBL Parse_Float ()
  466.   {
  467.   DBL Local_Float = 0.0;
  468.   CONSTANT Constant_Id;
  469.   register int Negative, Sign_Parsed;
  470.  
  471.   Negative = FALSE;
  472.   Sign_Parsed = FALSE;
  473.  
  474.   EXPECT
  475.     CASE (IDENTIFIER_TOKEN)
  476.       if ((Constant_Id = Find_Constant()) != -1)
  477.         if (Constants[(int)Constant_Id].Constant_Type == FLOAT_CONSTANT)
  478.           {
  479.           Local_Float = *((DBL *) Constants[(int)Constant_Id].Constant_Data);
  480.           if (Negative)
  481.             Local_Float *= -1.0;
  482.           }
  483.         else
  484.           Type_Error ();
  485.       else
  486.         Undeclared ();
  487.       EXIT
  488.     END_CASE
  489.  
  490.     CASE (PLUS_TOKEN)
  491.       if (Sign_Parsed)
  492.         Parse_Error (FLOAT_TOKEN);
  493.       Sign_Parsed = TRUE;
  494.     END_CASE
  495.  
  496.     CASE (DASH_TOKEN)
  497.       if (Sign_Parsed)
  498.         Parse_Error (FLOAT_TOKEN);
  499.       Negative = TRUE;
  500.       Sign_Parsed = TRUE;
  501.     END_CASE
  502.  
  503.     CASE (FLOAT_TOKEN)
  504.       Local_Float = Token.Token_Float;
  505.       if (Negative)
  506.         Local_Float *= -1.0;
  507.       EXIT
  508.     END_CASE
  509.  
  510.     OTHERWISE
  511.       Parse_Error (FLOAT_TOKEN);
  512.     END_CASE
  513.   END_EXPECT
  514.  
  515.   return (Local_Float);
  516.   }
  517.  
  518. void Parse_Vector (Given_Vector)
  519.   VECTOR *Given_Vector;
  520.   {
  521.   CONSTANT Constant_Id;
  522.  
  523.   EXPECT
  524.     CASE (IDENTIFIER_TOKEN)
  525.       if ((Constant_Id = Find_Constant()) != -1)
  526.         if (Constants[(int)Constant_Id].Constant_Type == VECTOR_CONSTANT)
  527.           *Given_Vector = *((VECTOR *) Constants[(int)Constant_Id].Constant_Data);
  528.         else
  529.           Type_Error ();
  530.       else
  531.         Undeclared ();
  532.       EXIT
  533.     END_CASE
  534.  
  535.     CASE (LEFT_ANGLE_TOKEN)
  536.       (Given_Vector -> x) = Parse_Float();
  537.       (Given_Vector -> y) = Parse_Float();
  538.       (Given_Vector -> z) = Parse_Float();
  539.       GET (RIGHT_ANGLE_TOKEN);
  540.       EXIT
  541.     END_CASE
  542.  
  543.     OTHERWISE 
  544.       Parse_Error (LEFT_ANGLE_TOKEN);
  545.     END_CASE
  546.   END_EXPECT
  547.   }
  548.  
  549. void Parse_Coeffs(Given_Coeffs)
  550.   DBL *Given_Coeffs;
  551.   {
  552.   int i;
  553.  
  554.   EXPECT
  555.     CASE (LEFT_ANGLE_TOKEN)
  556.        for (i=0;i<35;i++)
  557.      Given_Coeffs[i] = Parse_Float();
  558.       GET (RIGHT_ANGLE_TOKEN);
  559.       EXIT
  560.     END_CASE
  561.  
  562.     OTHERWISE 
  563.       Parse_Error (LEFT_ANGLE_TOKEN);
  564.     END_CASE
  565.   END_EXPECT
  566. }
  567.  
  568. void Parse_Colour (Given_Colour)
  569.   COLOUR *Given_Colour;
  570.   {
  571.   CONSTANT Constant_Id;
  572.  
  573.   Make_Colour (Given_Colour, 0.0, 0.0, 0.0);
  574.   EXPECT
  575.     CASE (IDENTIFIER_TOKEN)
  576.       if ((Constant_Id = Find_Constant()) != -1)
  577.         if (Constants[(int)Constant_Id].Constant_Type == COLOUR_CONSTANT)
  578.           *Given_Colour = *((COLOUR *) Constants[(int)Constant_Id].Constant_Data);
  579.         else
  580.           Type_Error ();
  581.       else
  582.         Undeclared ();
  583.     END_CASE
  584.  
  585.     CASE (RED_TOKEN)
  586.       (Given_Colour -> Red) = Parse_Float();
  587.     END_CASE
  588.  
  589.     CASE (GREEN_TOKEN)
  590.       (Given_Colour -> Green) = Parse_Float();
  591.     END_CASE
  592.  
  593.     CASE (BLUE_TOKEN)
  594.       (Given_Colour -> Blue) = Parse_Float();
  595.     END_CASE
  596.  
  597.     CASE (ALPHA_TOKEN)
  598.       (Given_Colour -> Alpha) = Parse_Float();
  599.     END_CASE
  600.  
  601.     OTHERWISE
  602.       UNGET
  603.       EXIT
  604.     END_CASE
  605.   END_EXPECT
  606.   }
  607.  
  608. COLOUR_MAP *Parse_Colour_Map ()
  609.    {
  610. #define MAX_ENTRIES 20
  611.    COLOUR_MAP *New_Colour_Map;
  612. static COLOUR_MAP_ENTRY *Construction_Map = NULL;
  613.  
  614.    register int i, j;
  615.  
  616.    if ((New_Colour_Map = (COLOUR_MAP *) malloc (sizeof (COLOUR_MAP))) == NULL)
  617.       Error ("Not enough memory for colour map");
  618.  
  619.  
  620.    if (Construction_Map == NULL)
  621.       if ((Construction_Map = (COLOUR_MAP_ENTRY *)
  622.                      malloc(MAX_ENTRIES * sizeof (COLOUR_MAP_ENTRY))) == NULL)
  623.          Error ("Not enough memory for colour map");
  624.  
  625.    i = 0;
  626.    New_Colour_Map->Transparency_Flag = FALSE;
  627.  
  628.    EXPECT
  629.       CASE (LEFT_SQUARE_TOKEN)
  630.          Construction_Map [i].start = Parse_Float();
  631.          Construction_Map [i].end = Parse_Float();
  632.  
  633.          GET (COLOUR_TOKEN);
  634.          Parse_Colour (&(Construction_Map[i].Start_Colour));
  635.          if (Construction_Map[i].Start_Colour.Alpha != 0.0)
  636.             New_Colour_Map->Transparency_Flag = TRUE;
  637.  
  638.          GET (COLOUR_TOKEN);
  639.          Parse_Colour (&(Construction_Map[i].End_Colour));
  640.          if (Construction_Map[i].End_Colour.Alpha != 0.0)
  641.             New_Colour_Map->Transparency_Flag = TRUE;
  642.  
  643.          i++;
  644.          if (i > MAX_ENTRIES)
  645.             Error ("Colour_Map too long");
  646.          GET (RIGHT_SQUARE_TOKEN);
  647.       END_CASE
  648.  
  649.       CASE (END_COLOUR_MAP_TOKEN)
  650.           New_Colour_Map -> Number_Of_Entries = i;
  651.  
  652.           if ((New_Colour_Map -> Colour_Map_Entries = (COLOUR_MAP_ENTRY *)
  653.                malloc(sizeof(COLOUR_MAP_ENTRY) * i)) == NULL)
  654.              Error ("Not enough memory for colour map");
  655.  
  656.           for (j = 0 ; j < i ; j++)
  657.              New_Colour_Map->Colour_Map_Entries[j] = Construction_Map[j];
  658.  
  659.           EXIT
  660.       END_CASE
  661.  
  662.       OTHERWISE
  663.          Parse_Error (END_COLOUR_MAP_TOKEN);
  664.       END_CASE
  665.    END_EXPECT
  666.  
  667.    return (New_Colour_Map);
  668.    }
  669.  
  670. TEXTURE *Copy_Texture (Texture)
  671.    TEXTURE *Texture;
  672.    {
  673.    TEXTURE *New_Texture, *Local_Texture, *First_Texture, *Previous_Texture;
  674.  
  675.    Previous_Texture = First_Texture = NULL;
  676.  
  677.    for (Local_Texture = Texture ; Local_Texture != NULL ; Local_Texture = Local_Texture->Next_Texture)  {
  678.       New_Texture = Get_Texture();
  679.       *New_Texture = *Local_Texture;
  680.  
  681.       if (First_Texture == NULL)
  682.          First_Texture = New_Texture;
  683.  
  684.       if (Previous_Texture != NULL)
  685.          Previous_Texture->Next_Texture = New_Texture;
  686.  
  687.       if (New_Texture->Texture_Transformation) {
  688.          if ((New_Texture->Texture_Transformation = (TRANSFORMATION *) malloc (sizeof (TRANSFORMATION))) == NULL)
  689.         Error("Cannot allocate texture transformation");
  690.          *New_Texture->Texture_Transformation = *Local_Texture->Texture_Transformation;
  691.          }
  692.       New_Texture->Constant_Flag = FALSE;
  693.       Previous_Texture = New_Texture;
  694.       }   
  695.    return (First_Texture);
  696.    }
  697.  
  698. TEXTURE *Parse_Texture ()
  699.    {
  700.    VECTOR Local_Vector;
  701.    TRANSFORMATION Local_Transformation;
  702.    CONSTANT Constant_Id;
  703.    TEXTURE *Texture, *Local_Texture;
  704.    int reg;
  705.  
  706.    Texture = Default_Texture;
  707.  
  708.    EXPECT
  709.       CASE (IDENTIFIER_TOKEN)
  710.          if ((Constant_Id = Find_Constant()) != -1)
  711.             if (Constants[(int)Constant_Id].Constant_Type == TEXTURE_CONSTANT) {
  712.                Texture = ((TEXTURE *) Constants[(int)Constant_Id].Constant_Data);
  713.                }
  714.             else
  715.                Type_Error ();
  716.          else
  717.             Undeclared ();
  718.       END_CASE
  719.  
  720.       CASE (FLOAT_TOKEN)
  721.          UNGET
  722.          if (Texture->Constant_Flag) {
  723.             Texture = Copy_Texture(Texture);
  724.             Texture->Constant_Flag = FALSE;
  725.             }
  726.          Texture -> Texture_Randomness = Parse_Float();
  727.       END_CASE
  728.  
  729.       CASE (ONCE_TOKEN)
  730.          if (Texture->Constant_Flag) {
  731.             Texture = Copy_Texture(Texture);
  732.             Texture->Constant_Flag = FALSE;
  733.             }
  734.          Texture->Once_Flag = TRUE;
  735.       END_CASE
  736.  
  737.       CASE (TURBULENCE_TOKEN)
  738.          if (Texture->Constant_Flag) {
  739.             Texture = Copy_Texture(Texture);
  740.             Texture->Constant_Flag = FALSE;
  741.             }
  742.           Texture -> Turbulence = Parse_Float();
  743.       END_CASE
  744.  
  745.       CASE (BOZO_TOKEN)
  746.          if (Texture->Constant_Flag) {
  747.             Texture = Copy_Texture (Texture);
  748.             Texture->Constant_Flag = FALSE;
  749.             }
  750.          Texture -> Texture_Number = BOZO_TEXTURE;
  751.       END_CASE
  752.  
  753.       CASE (CHECKER_TOKEN)
  754.          if (Texture->Constant_Flag) {
  755.             Texture = Copy_Texture (Texture);
  756.             Texture->Constant_Flag = FALSE;
  757.             }
  758.          Texture -> Texture_Number = CHECKER_TEXTURE;
  759.          EXPECT
  760.             CASE (COLOUR_TOKEN)
  761.                Texture->Colour1 = Get_Colour();
  762.                Texture->Colour2 = Get_Colour();
  763.                Parse_Colour (Texture -> Colour1);
  764.                GET (COLOUR_TOKEN);
  765.                Parse_Colour (Texture -> Colour2);
  766.             END_CASE
  767.  
  768.             OTHERWISE
  769.                UNGET
  770.                EXIT
  771.             END_CASE
  772.          END_EXPECT
  773.       END_CASE
  774.  
  775.       CASE (CHECKER_TEXTURE_TOKEN)
  776.          if (Texture->Constant_Flag) {
  777.             Texture = Copy_Texture (Texture);
  778.             Texture->Constant_Flag = FALSE;
  779.             }
  780.          Texture -> Texture_Number = CHECKER_TEXTURE_TEXTURE;
  781.          EXPECT
  782.             CASE (TEXTURE_TOKEN)
  783.                Local_Texture = Parse_Texture ();
  784.                if (Local_Texture->Constant_Flag)
  785.                   Local_Texture = Copy_Texture(Local_Texture);
  786.  
  787.                {
  788.                TEXTURE *temp_texture;
  789.  
  790.                for (temp_texture = Local_Texture ;
  791.                     temp_texture->Next_Texture != NULL ;
  792.                     temp_texture = temp_texture->Next_Texture)
  793.                    {}
  794.  
  795.                temp_texture->Next_Texture = (TEXTURE *) Texture->Colour1;
  796.                Texture->Colour1 = (COLOUR *) Local_Texture;
  797.                }
  798.              END_CASE
  799.              OTHERWISE
  800.                 UNGET
  801.                 EXIT
  802.              END_CASE
  803.          END_EXPECT
  804.  
  805.          GET (TILE2_TOKEN);
  806.          EXPECT
  807.             CASE (TEXTURE_TOKEN)
  808.                Local_Texture = Parse_Texture ();
  809.                if (Local_Texture->Constant_Flag)
  810.                   Local_Texture = Copy_Texture(Local_Texture);
  811.  
  812.                {
  813.                TEXTURE *temp_texture;
  814.  
  815.                for (temp_texture = Local_Texture ;
  816.                     temp_texture->Next_Texture != NULL ;
  817.                     temp_texture = temp_texture->Next_Texture)
  818.                    {}
  819.  
  820.                temp_texture->Next_Texture = (TEXTURE *) Texture->Colour2;
  821.                Texture->Colour2 = (COLOUR *) Local_Texture;
  822.                }
  823.              END_CASE
  824.              OTHERWISE
  825.                 UNGET
  826.                 EXIT
  827.              END_CASE
  828.          END_EXPECT
  829.          GET (END_CHECKER_TEXTURE_TOKEN);
  830.       END_CASE
  831.  
  832.       CASE (MARBLE_TOKEN)
  833.          if (Texture->Constant_Flag) {
  834.             Texture = Copy_Texture (Texture);
  835.             Texture->Constant_Flag = FALSE;
  836.             }
  837.          Texture -> Texture_Number = MARBLE_TEXTURE;
  838.       END_CASE
  839.  
  840.       CASE (WOOD_TOKEN)
  841.          if (Texture->Constant_Flag) {
  842.             Texture = Copy_Texture (Texture);
  843.             Texture->Constant_Flag = FALSE;
  844.             }
  845.          Texture -> Texture_Number = WOOD_TEXTURE;
  846.       END_CASE
  847.  
  848.       CASE (SPOTTED_TOKEN)
  849.          if (Texture->Constant_Flag) {
  850.             Texture = Copy_Texture (Texture);
  851.             Texture->Constant_Flag = FALSE;
  852.             }
  853.          Texture -> Texture_Number = SPOTTED_TEXTURE;
  854.       END_CASE
  855.  
  856.       CASE (AGATE_TOKEN)
  857.          if (Texture->Constant_Flag) {
  858.             Texture = Copy_Texture (Texture);
  859.             Texture->Constant_Flag = FALSE;
  860.             }
  861.          Texture -> Texture_Number = AGATE_TEXTURE;
  862.       END_CASE
  863.  
  864.       CASE (GRANITE_TOKEN)
  865.          if (Texture->Constant_Flag) {
  866.             Texture = Copy_Texture (Texture);
  867.             Texture->Constant_Flag = FALSE;
  868.             }
  869.          Texture -> Texture_Number = GRANITE_TEXTURE;
  870.       END_CASE
  871.  
  872.        CASE (GRADIENT_TOKEN)
  873.          if (Texture->Constant_Flag) {
  874.             Texture = Copy_Texture (Texture);
  875.             Texture->Constant_Flag = FALSE;
  876.             }
  877.      Texture -> Texture_Number = GRADIENT_TEXTURE;
  878.      Parse_Vector (&(Texture -> Texture_Gradient));
  879.        END_CASE
  880.  
  881.       CASE (AMBIENT_TOKEN)
  882.          if (Texture->Constant_Flag) {
  883.             Texture = Copy_Texture (Texture);
  884.             Texture->Constant_Flag = FALSE;
  885.             }
  886.          (Texture -> Object_Ambient) = Parse_Float ();
  887.       END_CASE
  888.  
  889.       CASE (BRILLIANCE_TOKEN)
  890.          if (Texture->Constant_Flag) {
  891.             Texture = Copy_Texture (Texture);
  892.             Texture->Constant_Flag = FALSE;
  893.             }
  894.          (Texture -> Object_Brilliance) = Parse_Float ();
  895.       END_CASE
  896.  
  897.       CASE (ROUGHNESS_TOKEN)
  898.          if (Texture->Constant_Flag) {
  899.             Texture = Copy_Texture (Texture);
  900.             Texture->Constant_Flag = FALSE;
  901.             }
  902.          (Texture -> Object_Roughness) = Parse_Float ();
  903.          if (Texture -> Object_Roughness > 1.0)
  904.             Texture -> Object_Roughness = 1.0;
  905.          if (Texture -> Object_Roughness < 0.001)
  906.             Texture -> Object_Roughness = 0.001;
  907.       END_CASE
  908.  
  909.       CASE (PHONGSIZE_TOKEN)
  910.          if (Texture->Constant_Flag) {
  911.             Texture = Copy_Texture (Texture);
  912.             Texture->Constant_Flag = FALSE;
  913.             }
  914.          (Texture -> Object_PhongSize) = Parse_Float ();
  915.          if (Texture -> Object_PhongSize < 1.0)
  916.             Texture -> Object_PhongSize = 1.0;
  917.          if (Texture -> Object_PhongSize > 100)
  918.             Texture -> Object_PhongSize = 100;
  919.       END_CASE
  920.  
  921.       CASE (DIFFUSE_TOKEN)
  922.          if (Texture->Constant_Flag) {
  923.             Texture = Copy_Texture (Texture);
  924.             Texture->Constant_Flag = FALSE;
  925.             }
  926.          (Texture -> Object_Diffuse) = Parse_Float ();
  927.       END_CASE
  928.  
  929.       CASE (SPECULAR_TOKEN)
  930.          if (Texture->Constant_Flag) {
  931.             Texture = Copy_Texture (Texture);
  932.             Texture->Constant_Flag = FALSE;
  933.             }
  934.          (Texture -> Object_Specular) = Parse_Float ();
  935.       END_CASE
  936.  
  937.       CASE (PHONG_TOKEN)
  938.          if (Texture->Constant_Flag) {
  939.             Texture = Copy_Texture (Texture);
  940.             Texture->Constant_Flag = FALSE;
  941.             }
  942.          (Texture -> Object_Phong) = Parse_Float ();
  943.       END_CASE
  944.  
  945.       CASE (METALLIC_TOKEN)
  946.          if (Texture->Constant_Flag) {
  947.             Texture = Copy_Texture (Texture);
  948.             Texture->Constant_Flag = FALSE;
  949.             }
  950.          Texture -> Metallic_Flag = TRUE;
  951.       END_CASE
  952.  
  953.       CASE (IOR_TOKEN)
  954.          if (Texture->Constant_Flag) {
  955.             Texture = Copy_Texture (Texture);
  956.             Texture->Constant_Flag = FALSE;
  957.             }
  958.          (Texture -> Object_Index_Of_Refraction) = Parse_Float ();
  959.       END_CASE
  960.  
  961.       CASE (REFRACTION_TOKEN)
  962.          if (Texture->Constant_Flag) {
  963.             Texture = Copy_Texture (Texture);
  964.             Texture->Constant_Flag = FALSE;
  965.             }
  966.          (Texture -> Object_Refraction) = Parse_Float ();
  967.       END_CASE
  968.  
  969.       CASE (REFLECTION_TOKEN)
  970.          if (Texture->Constant_Flag) {
  971.             Texture = Copy_Texture (Texture);
  972.             Texture->Constant_Flag = FALSE;
  973.             }
  974.          (Texture -> Object_Reflection) = Parse_Float ();
  975.       END_CASE
  976.  
  977.       CASE (IMAGEMAP_TOKEN)
  978.          if (Texture->Constant_Flag) {
  979.             Texture = Copy_Texture (Texture);
  980.             Texture->Constant_Flag = FALSE;
  981.             }
  982.          Texture -> Texture_Number = IMAGEMAP_TEXTURE;
  983.          if ((Texture->Image = (IMAGE *)malloc(sizeof(IMAGE))) == NULL)
  984.          Error("Cannot allocate imagemap texture");
  985.          Make_Vector (&Texture->Texture_Gradient, 1.0, -1.0, 0.0);
  986.          EXPECT
  987.             CASE (LEFT_ANGLE_TOKEN)
  988.                  UNGET
  989.                  Parse_Vector (&(Texture -> Texture_Gradient));
  990.             END_CASE
  991.  
  992.             CASE (IFF_TOKEN)
  993.                GET (STRING_TOKEN);
  994.                Read_Iff_Image(Texture->Image, Token.Token_String);
  995.                EXIT
  996.             END_CASE
  997.  
  998.             CASE (GIF_TOKEN)
  999.                GET (STRING_TOKEN);
  1000.                Read_Gif_Image(Texture->Image, Token.Token_String);
  1001.                EXIT
  1002.             END_CASE
  1003.  
  1004.             CASE (DUMP_TOKEN)
  1005.                GET (STRING_TOKEN);
  1006.                Read_Dump_Image(Texture->Image, Token.Token_String);
  1007.                EXIT
  1008.             END_CASE
  1009.  
  1010.             OTHERWISE
  1011.                Parse_Error (DUMP_TOKEN);
  1012.             END_CASE
  1013.          END_EXPECT
  1014.  
  1015.          EXPECT
  1016.             CASE (ALPHA_TOKEN)
  1017.                EXPECT
  1018.                   CASE (FLOAT_TOKEN)
  1019.                      reg = (int)(Token.Token_Float + 0.01);
  1020.                      if (Texture->Image->Colour_Map == NULL)
  1021.                         Error ("Can't apply ALPHA to a non colour-mapped image\n");
  1022.  
  1023.                      if ((reg < 0) || (reg >= Texture->Image->Colour_Map_Size))
  1024.                         Error ("ALPHA colour register value out of range.\n");
  1025.  
  1026.                      Texture->Image->Colour_Map[reg].Alpha = (unsigned short) (255.0 * Parse_Float());
  1027.                      EXIT
  1028.                   END_CASE
  1029.  
  1030.                   CASE (ALL_TOKEN)
  1031.                      {
  1032.                      DBL alpha;
  1033.                      alpha = Parse_Float();
  1034.  
  1035.                      for (reg = 0 ; reg < Texture->Image->Colour_Map_Size ; reg++)
  1036.                         Texture->Image->Colour_Map[reg].Alpha = (unsigned short) alpha;
  1037.                      }
  1038.                      EXIT
  1039.                   END_CASE
  1040.                END_EXPECT
  1041.             END_CASE
  1042.  
  1043.             OTHERWISE
  1044.                UNGET
  1045.                EXIT
  1046.             END_CASE
  1047.          END_EXPECT
  1048.       END_CASE
  1049.  
  1050.       CASE (WAVES_TOKEN)
  1051.          if (Texture->Constant_Flag) {
  1052.             Texture = Copy_Texture (Texture);
  1053.             Texture->Constant_Flag = FALSE;
  1054.             }
  1055.          Texture -> Bump_Number = WAVES;
  1056.          Texture -> Bump_Amount = Parse_Float ();
  1057.          EXPECT
  1058.             CASE (PHASE_TOKEN)
  1059.                Texture -> Phase = Parse_Float();
  1060.                EXIT
  1061.             END_CASE
  1062.  
  1063.             OTHERWISE
  1064.                UNGET
  1065.                EXIT
  1066.             END_CASE
  1067.          END_EXPECT
  1068.       END_CASE
  1069.  
  1070.       CASE (FREQUENCY_TOKEN)
  1071.          if (Texture->Constant_Flag) {
  1072.             Texture = Copy_Texture (Texture);
  1073.             Texture->Constant_Flag = FALSE;
  1074.             }
  1075.          Texture -> Frequency = Parse_Float();
  1076.       END_CASE
  1077.  
  1078.       CASE (PHASE_TOKEN)
  1079.          if (Texture->Constant_Flag) {
  1080.             Texture = Copy_Texture (Texture);
  1081.             Texture->Constant_Flag = FALSE;
  1082.             }
  1083.          Texture -> Phase = Parse_Float();
  1084.       END_CASE
  1085.  
  1086.       CASE (RIPPLES_TOKEN)
  1087.          if (Texture->Constant_Flag) {
  1088.             Texture = Copy_Texture (Texture);
  1089.             Texture->Constant_Flag = FALSE;
  1090.             }
  1091.          Texture -> Bump_Number = RIPPLES;
  1092.          Texture -> Bump_Amount = Parse_Float ();
  1093.       END_CASE
  1094.  
  1095.       CASE (WRINKLES_TOKEN)
  1096.          if (Texture->Constant_Flag) {
  1097.             Texture = Copy_Texture (Texture);
  1098.             Texture->Constant_Flag = FALSE;
  1099.             }
  1100.          Texture -> Bump_Number = WRINKLES;
  1101.          Texture -> Bump_Amount = Parse_Float ();
  1102.       END_CASE
  1103.  
  1104.       CASE (BUMPS_TOKEN)
  1105.          if (Texture->Constant_Flag) {
  1106.             Texture = Copy_Texture (Texture);
  1107.             Texture->Constant_Flag = FALSE;
  1108.             }
  1109.          Texture -> Bump_Number = BUMPS;
  1110.          Texture -> Bump_Amount = Parse_Float ();
  1111.       END_CASE
  1112.  
  1113.       CASE (DENTS_TOKEN)
  1114.          if (Texture->Constant_Flag) {
  1115.             Texture = Copy_Texture (Texture);
  1116.             Texture->Constant_Flag = FALSE;
  1117.             }
  1118.          Texture -> Bump_Number = DENTS;
  1119.          Texture -> Bump_Amount = Parse_Float ();
  1120.       END_CASE
  1121.  
  1122.       CASE (TRANSLATE_TOKEN)
  1123.          if (Texture->Constant_Flag) {
  1124.             Texture = Copy_Texture (Texture);
  1125.             Texture->Constant_Flag = FALSE;
  1126.             }
  1127.          Parse_Vector (&Local_Vector);
  1128.          if (!Texture -> Texture_Transformation)
  1129.             Texture -> Texture_Transformation = Get_Transformation ();
  1130.          Get_Translation_Transformation (&Local_Transformation,
  1131.                                          &Local_Vector);
  1132.          Compose_Transformations (Texture -> Texture_Transformation,
  1133.                                   &Local_Transformation);
  1134.       END_CASE
  1135.  
  1136.       CASE (ROTATE_TOKEN)
  1137.          if (Texture->Constant_Flag) {
  1138.             Texture = Copy_Texture (Texture);
  1139.             Texture->Constant_Flag = FALSE;
  1140.             }
  1141.          Parse_Vector (&Local_Vector);
  1142.          if (!Texture -> Texture_Transformation)
  1143.             Texture -> Texture_Transformation = Get_Transformation ();
  1144.          Get_Rotation_Transformation (&Local_Transformation,
  1145.                                       &Local_Vector);
  1146.          Compose_Transformations (Texture -> Texture_Transformation,
  1147.                                   &Local_Transformation);
  1148.       END_CASE
  1149.  
  1150.       CASE (SCALE_TOKEN)
  1151.          if (Texture->Constant_Flag) {
  1152.             Texture = Copy_Texture (Texture);
  1153.             Texture->Constant_Flag = FALSE;
  1154.             }
  1155.          Parse_Vector (&Local_Vector);
  1156.          if (!Texture -> Texture_Transformation)
  1157.              Texture -> Texture_Transformation = Get_Transformation ();
  1158.          Get_Scaling_Transformation (&Local_Transformation,
  1159.                                      &Local_Vector);
  1160.          Compose_Transformations (Texture -> Texture_Transformation,
  1161.                                   &Local_Transformation);
  1162.       END_CASE
  1163.  
  1164.       CASE (COLOUR_TOKEN)
  1165.          if (Texture->Constant_Flag) {
  1166.             Texture = Copy_Texture (Texture);
  1167.             Texture->Constant_Flag = FALSE;
  1168.             }
  1169.          Texture->Colour1 = Get_Colour();
  1170.          Parse_Colour (Texture -> Colour1);
  1171.          Texture -> Texture_Number = COLOUR_TEXTURE;
  1172.       END_CASE
  1173.  
  1174.       CASE (COLOUR_MAP_TOKEN)
  1175.          if (Texture->Constant_Flag) {
  1176.             Texture = Copy_Texture (Texture);
  1177.             Texture->Constant_Flag = FALSE;
  1178.             }
  1179.          Texture -> Colour_Map = Parse_Colour_Map();
  1180.       END_CASE
  1181.  
  1182.       CASE (END_TEXTURE_TOKEN)
  1183.          EXIT
  1184.       END_CASE
  1185.  
  1186.       OTHERWISE
  1187.          Parse_Error (END_TEXTURE_TOKEN);
  1188.       END_CASE
  1189.    END_EXPECT
  1190.    return (Texture);
  1191.    }
  1192.  
  1193. SHAPE *Parse_Sphere ()
  1194.   {
  1195.   SPHERE *Local_Shape;
  1196.   CONSTANT Constant_Id;
  1197.   VECTOR Local_Vector;
  1198.   TEXTURE *Local_Texture;
  1199.  
  1200.   Local_Shape = NULL;
  1201.  
  1202.   EXPECT
  1203.      CASE (LEFT_ANGLE_TOKEN)
  1204.        UNGET
  1205.        Local_Shape = Get_Sphere_Shape();
  1206.        Parse_Vector(&(Local_Shape -> Center));
  1207.        Local_Shape -> Radius = Parse_Float();
  1208.        Local_Shape -> Radius_Squared = Local_Shape -> Radius * Local_Shape -> Radius;
  1209.        Local_Shape -> Inverse_Radius = 1.0 / Local_Shape -> Radius;
  1210.        EXIT
  1211.      END_CASE
  1212.  
  1213.      CASE (IDENTIFIER_TOKEN)
  1214.        if ((Constant_Id = Find_Constant()) != -1)
  1215.          if (Constants[(int)Constant_Id].Constant_Type == SPHERE_CONSTANT)
  1216.            Local_Shape = (SPHERE *)Copy((OBJECT *) Constants[(int)Constant_Id].Constant_Data);
  1217.          else
  1218.            Type_Error ();
  1219.        else
  1220.          Undeclared ();
  1221.        EXIT
  1222.      END_CASE
  1223.  
  1224.      OTHERWISE
  1225.         Parse_Error (LEFT_ANGLE_TOKEN);
  1226.      END_CASE
  1227.   END_EXPECT
  1228.  
  1229.   EXPECT
  1230.      CASE (END_SPHERE_TOKEN)
  1231.         EXIT
  1232.      END_CASE
  1233.  
  1234.      CASE (TRANSLATE_TOKEN)
  1235.         Parse_Vector (&Local_Vector);
  1236.         Translate ((OBJECT *) Local_Shape, &Local_Vector);
  1237.      END_CASE
  1238.  
  1239.      CASE (ROTATE_TOKEN)
  1240.         Parse_Vector (&Local_Vector);
  1241.         Rotate ((OBJECT *) Local_Shape, &Local_Vector);
  1242.      END_CASE
  1243.  
  1244.      CASE (SCALE_TOKEN)
  1245.         Parse_Vector (&Local_Vector);
  1246.         Scale ((OBJECT *) Local_Shape, &Local_Vector);
  1247.      END_CASE
  1248.  
  1249.      CASE (INVERSE_TOKEN)
  1250.         Invert ((OBJECT *) Local_Shape);
  1251.      END_CASE
  1252.  
  1253.      CASE (TEXTURE_TOKEN)
  1254.         Local_Texture = Parse_Texture ();
  1255.         if (Local_Texture->Constant_Flag)
  1256.            Local_Texture = Copy_Texture(Local_Texture);
  1257.  
  1258.         {
  1259.         TEXTURE *temp_texture;
  1260.  
  1261.         for (temp_texture = Local_Texture ;
  1262.              temp_texture->Next_Texture != NULL ;
  1263.              temp_texture = temp_texture->Next_Texture)
  1264.            {}
  1265.  
  1266.         temp_texture->Next_Texture = Local_Shape->Shape_Texture;
  1267.         Local_Shape->Shape_Texture = Local_Texture;
  1268.         }
  1269.      END_CASE
  1270.  
  1271.      CASE (COLOUR_TOKEN)
  1272.         Local_Shape->Shape_Colour = Get_Colour();
  1273.         Parse_Colour (Local_Shape->Shape_Colour);
  1274.      END_CASE
  1275.  
  1276.      OTHERWISE
  1277.         Parse_Error (END_SPHERE_TOKEN);
  1278.      END_CASE
  1279.   END_EXPECT
  1280.  
  1281.   return ((SHAPE *) Local_Shape);
  1282.   }
  1283.  
  1284. SHAPE *Parse_Plane ()
  1285.   {
  1286.   PLANE *Local_Shape;
  1287.   CONSTANT Constant_Id;
  1288.   VECTOR Local_Vector;
  1289.   TEXTURE *Local_Texture;
  1290.  
  1291.   Local_Shape = NULL;
  1292.  
  1293.   EXPECT
  1294.      CASE (LEFT_ANGLE_TOKEN)
  1295.        UNGET
  1296.        Local_Shape = Get_Plane_Shape();
  1297.        Parse_Vector(&(Local_Shape -> Normal_Vector));
  1298.        Local_Shape->Distance = Parse_Float();
  1299.        Local_Shape->Distance *= -1.0;
  1300.        EXIT
  1301.      END_CASE
  1302.  
  1303.      CASE (IDENTIFIER_TOKEN)
  1304.        if ((Constant_Id = Find_Constant()) != -1)
  1305.          if (Constants[(int)Constant_Id].Constant_Type == PLANE_CONSTANT)
  1306.            Local_Shape = (PLANE *)Copy((OBJECT *) Constants[(int)Constant_Id].Constant_Data);
  1307.          else
  1308.            Type_Error ();
  1309.        else
  1310.          Undeclared ();
  1311.        EXIT
  1312.      END_CASE
  1313.  
  1314.      OTHERWISE
  1315.         Parse_Error (LEFT_ANGLE_TOKEN);
  1316.      END_CASE
  1317.   END_EXPECT
  1318.  
  1319.   EXPECT
  1320.      CASE (END_PLANE_TOKEN)
  1321.         EXIT
  1322.      END_CASE
  1323.  
  1324.      CASE (TRANSLATE_TOKEN)
  1325.         Parse_Vector (&Local_Vector);
  1326.         Translate ((OBJECT *) Local_Shape, &Local_Vector);
  1327.      END_CASE
  1328.  
  1329.      CASE (ROTATE_TOKEN)
  1330.         Parse_Vector (&Local_Vector);
  1331.         Rotate ((OBJECT *) Local_Shape, &Local_Vector);
  1332.      END_CASE
  1333.  
  1334.      CASE (SCALE_TOKEN)
  1335.         Parse_Vector (&Local_Vector);
  1336.         Scale ((OBJECT *) Local_Shape, &Local_Vector);
  1337.      END_CASE
  1338.  
  1339.      CASE (INVERSE_TOKEN)
  1340.         Invert ((OBJECT *) Local_Shape);
  1341.      END_CASE
  1342.  
  1343.      CASE (TEXTURE_TOKEN)
  1344.         Local_Texture = Parse_Texture ();
  1345.         if (Local_Texture->Constant_Flag)
  1346.            Local_Texture = Copy_Texture(Local_Texture);
  1347.  
  1348.         {
  1349.         TEXTURE *temp_texture;
  1350.  
  1351.         for (temp_texture = Local_Texture ;
  1352.              temp_texture->Next_Texture != NULL ;
  1353.              temp_texture = temp_texture->Next_Texture)
  1354.            {}
  1355.  
  1356.         temp_texture->Next_Texture = Local_Shape->Shape_Texture;
  1357.         Local_Shape->Shape_Texture = Local_Texture;
  1358.         }
  1359.      END_CASE
  1360.  
  1361.      CASE (COLOUR_TOKEN)
  1362.         Local_Shape->Shape_Colour = Get_Colour();
  1363.         Parse_Colour (Local_Shape->Shape_Colour);
  1364.      END_CASE
  1365.  
  1366.      OTHERWISE
  1367.         Parse_Error (END_PLANE_TOKEN);
  1368.      END_CASE
  1369.   END_EXPECT
  1370.  
  1371.   return ((SHAPE *) Local_Shape);
  1372.   }
  1373.  
  1374. SHAPE *Parse_Triangle ()
  1375.   {
  1376.   TRIANGLE *Local_Shape;
  1377.   CONSTANT Constant_Id;
  1378.   VECTOR Local_Vector;
  1379.   TEXTURE *Local_Texture;
  1380.  
  1381.   Local_Shape = NULL;
  1382.  
  1383.   EXPECT
  1384.      CASE (LEFT_ANGLE_TOKEN)
  1385.        UNGET
  1386.        Local_Shape = Get_Triangle_Shape();
  1387.        Parse_Vector (&Local_Shape->P1);
  1388.        Parse_Vector (&Local_Shape->P2);
  1389.        Parse_Vector (&Local_Shape->P3);
  1390.        if (!Compute_Triangle (Local_Shape)) {
  1391.           PRINT ("Degenerate triangle on line %d.  Please remove.\n", Token.Token_Line_No);
  1392.           Degenerate_Triangles = TRUE;
  1393.           }
  1394.        EXIT
  1395.      END_CASE
  1396.  
  1397.      CASE (IDENTIFIER_TOKEN)
  1398.        if ((Constant_Id = Find_Constant()) != -1)
  1399.          if (Constants[(int)Constant_Id].Constant_Type == TRIANGLE_CONSTANT)
  1400.            Local_Shape = (TRIANGLE *)Copy((OBJECT *) Constants[(int)Constant_Id].Constant_Data);
  1401.          else
  1402.            Type_Error ();
  1403.        else
  1404.          Undeclared ();
  1405.        EXIT
  1406.      END_CASE
  1407.  
  1408.      OTHERWISE
  1409.         Parse_Error (LEFT_ANGLE_TOKEN);
  1410.      END_CASE
  1411.   END_EXPECT
  1412.  
  1413.   EXPECT
  1414.      CASE (END_TRIANGLE_TOKEN)
  1415.         EXIT
  1416.      END_CASE
  1417.  
  1418.      CASE (TRANSLATE_TOKEN)
  1419.         Parse_Vector (&Local_Vector);
  1420.         Translate ((OBJECT *) Local_Shape, &Local_Vector);
  1421.      END_CASE
  1422.  
  1423.      CASE (ROTATE_TOKEN)
  1424.         Parse_Vector (&Local_Vector);
  1425.         Rotate ((OBJECT *) Local_Shape, &Local_Vector);
  1426.      END_CASE
  1427.  
  1428.      CASE (SCALE_TOKEN)
  1429.         Parse_Vector (&Local_Vector);
  1430.         Scale ((OBJECT *) Local_Shape, &Local_Vector);
  1431.      END_CASE
  1432.  
  1433.      CASE (INVERSE_TOKEN)
  1434.         Invert ((OBJECT *) Local_Shape);
  1435.      END_CASE
  1436.  
  1437.      CASE (TEXTURE_TOKEN)
  1438.         Local_Texture = Parse_Texture ();
  1439.         if (Local_Texture->Constant_Flag)
  1440.            Local_Texture = Copy_Texture(Local_Texture);
  1441.  
  1442.         {
  1443.         TEXTURE *temp_texture;
  1444.  
  1445.         for (temp_texture = Local_Texture ;
  1446.              temp_texture->Next_Texture != NULL ;
  1447.              temp_texture = temp_texture->Next_Texture)
  1448.            {}
  1449.  
  1450.         temp_texture->Next_Texture = Local_Shape->Shape_Texture;
  1451.         Local_Shape->Shape_Texture = Local_Texture;
  1452.         }
  1453.      END_CASE
  1454.  
  1455.      CASE (COLOUR_TOKEN)
  1456.         Local_Shape->Shape_Colour = Get_Colour();
  1457.         Parse_Colour (Local_Shape->Shape_Colour);
  1458.      END_CASE
  1459.  
  1460.      OTHERWISE
  1461.         Parse_Error (END_TRIANGLE_TOKEN);
  1462.      END_CASE
  1463.   END_EXPECT
  1464.  
  1465.   return ((SHAPE *) Local_Shape);
  1466.   }
  1467.  
  1468. SHAPE *Parse_Smooth_Triangle ()
  1469.   {
  1470.   SMOOTH_TRIANGLE *Local_Shape;
  1471.   CONSTANT Constant_Id;
  1472.   VECTOR Local_Vector;
  1473.   TEXTURE *Local_Texture;
  1474.  
  1475.   Local_Shape = NULL;
  1476.  
  1477.   EXPECT
  1478.      CASE (LEFT_ANGLE_TOKEN)
  1479.        UNGET
  1480.        Local_Shape = (SMOOTH_TRIANGLE *) Get_Smooth_Triangle_Shape();
  1481.        Parse_Vector (&Local_Shape->P1);
  1482.        Parse_Vector (&Local_Shape->N1);
  1483.        VNormalize (Local_Shape->N1, Local_Shape->N1)
  1484.        Parse_Vector (&Local_Shape->P2);
  1485.        Parse_Vector (&Local_Shape->N2);
  1486.        VNormalize (Local_Shape->N2, Local_Shape->N2)
  1487.        Parse_Vector (&Local_Shape->P3);
  1488.        Parse_Vector (&Local_Shape->N3);
  1489.        VNormalize (Local_Shape->N3, Local_Shape->N3)
  1490.        if (!Compute_Triangle ((TRIANGLE *) Local_Shape)) {
  1491.           PRINT ("Degenerate triangle on line %d.  Please remove.\n", Token.Token_Line_No);
  1492.           Degenerate_Triangles = TRUE;
  1493.           }
  1494.        EXIT
  1495.      END_CASE
  1496.  
  1497.      CASE (IDENTIFIER_TOKEN)
  1498.        if ((Constant_Id = Find_Constant()) != -1)
  1499.          if (Constants[(int)Constant_Id].Constant_Type == SMOOTH_TRIANGLE_CONSTANT)
  1500.            Local_Shape = (SMOOTH_TRIANGLE *)Copy((OBJECT *) Constants[(int)Constant_Id].Constant_Data);
  1501.          else
  1502.            Type_Error ();
  1503.        else
  1504.          Undeclared ();
  1505.        EXIT
  1506.      END_CASE
  1507.  
  1508.      OTHERWISE
  1509.         Parse_Error (LEFT_ANGLE_TOKEN);
  1510.      END_CASE
  1511.   END_EXPECT
  1512.  
  1513.   EXPECT
  1514.      CASE2 (END_TRIANGLE_TOKEN, END_SMOOTH_TRIANGLE_TOKEN)
  1515.         EXIT
  1516.      END_CASE
  1517.  
  1518.      CASE (TRANSLATE_TOKEN)
  1519.         Parse_Vector (&Local_Vector);
  1520.         Translate ((OBJECT *) Local_Shape, &Local_Vector);
  1521.      END_CASE
  1522.  
  1523.      CASE (ROTATE_TOKEN)
  1524.         Parse_Vector (&Local_Vector);
  1525.         Rotate ((OBJECT *) Local_Shape, &Local_Vector);
  1526.      END_CASE
  1527.  
  1528.      CASE (SCALE_TOKEN)
  1529.         Parse_Vector (&Local_Vector);
  1530.         Scale ((OBJECT *) Local_Shape, &Local_Vector);
  1531.      END_CASE
  1532.  
  1533.      CASE (INVERSE_TOKEN)
  1534.         Invert ((OBJECT *) Local_Shape);
  1535.      END_CASE
  1536.  
  1537.      CASE (TEXTURE_TOKEN)
  1538.         Local_Texture = Parse_Texture ();
  1539.         if (Local_Texture->Constant_Flag)
  1540.            Local_Texture = Copy_Texture(Local_Texture);
  1541.  
  1542.         {
  1543.         TEXTURE *temp_texture;
  1544.  
  1545.         for (temp_texture = Local_Texture ;
  1546.              temp_texture->Next_Texture != NULL ;
  1547.              temp_texture = temp_texture->Next_Texture)
  1548.            {}
  1549.  
  1550.         temp_texture->Next_Texture = Local_Shape->Shape_Texture;
  1551.         Local_Shape->Shape_Texture = Local_Texture;
  1552.         }
  1553.      END_CASE
  1554.  
  1555.      CASE (COLOUR_TOKEN)
  1556.         Local_Shape->Shape_Colour = Get_Colour();
  1557.         Parse_Colour (Local_Shape->Shape_Colour);
  1558.      END_CASE
  1559.  
  1560.      OTHERWISE
  1561.         Parse_Error (END_SMOOTH_TRIANGLE_TOKEN);
  1562.      END_CASE
  1563.   END_EXPECT
  1564.  
  1565.   return ((SHAPE *) Local_Shape);
  1566.   }
  1567.  
  1568. SHAPE *Parse_Quadric ()
  1569.   {
  1570.   QUADRIC *Local_Shape;
  1571.   VECTOR Local_Vector;
  1572.   CONSTANT Constant_Id;
  1573.   TEXTURE *Local_Texture;
  1574.  
  1575.   Local_Shape = NULL;
  1576.  
  1577.   EXPECT
  1578.      CASE (LEFT_ANGLE_TOKEN)
  1579.        UNGET
  1580.        Local_Shape = Get_Quadric_Shape();
  1581.        Parse_Vector(&(Local_Shape -> Object_2_Terms));
  1582.        Parse_Vector(&(Local_Shape -> Object_Mixed_Terms));
  1583.        Parse_Vector(&(Local_Shape -> Object_Terms));
  1584.        (Local_Shape -> Object_Constant) = Parse_Float();
  1585.        Local_Shape -> Non_Zero_Square_Term = 
  1586.          !((Local_Shape -> Object_2_Terms.x == 0.0)
  1587.           && (Local_Shape -> Object_2_Terms.y == 0.0)
  1588.           && (Local_Shape -> Object_2_Terms.z == 0.0)
  1589.           && (Local_Shape -> Object_Mixed_Terms.x == 0.0)
  1590.           && (Local_Shape -> Object_Mixed_Terms.y == 0.0)
  1591.           && (Local_Shape -> Object_Mixed_Terms.z == 0.0));
  1592.        EXIT
  1593.      END_CASE
  1594.  
  1595.      CASE (IDENTIFIER_TOKEN)
  1596.        if ((Constant_Id = Find_Constant()) != -1)
  1597.          if (Constants[(int)Constant_Id].Constant_Type == QUADRIC_CONSTANT)
  1598.            Local_Shape = (QUADRIC *)Copy((OBJECT *) Constants[(int)Constant_Id].Constant_Data);
  1599.          else
  1600.            Type_Error ();
  1601.        else
  1602.          Undeclared ();
  1603.        EXIT
  1604.      END_CASE
  1605.  
  1606.      OTHERWISE
  1607.         Parse_Error (LEFT_ANGLE_TOKEN);
  1608.      END_CASE
  1609.   END_EXPECT
  1610.  
  1611.   EXPECT
  1612.      CASE (END_QUADRIC_TOKEN)
  1613.         EXIT
  1614.      END_CASE
  1615.  
  1616.      CASE (TRANSLATE_TOKEN)
  1617.         Parse_Vector (&Local_Vector);
  1618.         Translate ((OBJECT *) Local_Shape, &Local_Vector);
  1619.      END_CASE
  1620.  
  1621.      CASE (ROTATE_TOKEN)
  1622.         Parse_Vector (&Local_Vector);
  1623.         Rotate ((OBJECT *) Local_Shape, &Local_Vector);
  1624.      END_CASE
  1625.  
  1626.      CASE (SCALE_TOKEN)
  1627.         Parse_Vector (&Local_Vector);
  1628.         Scale ((OBJECT *) Local_Shape, &Local_Vector);
  1629.      END_CASE
  1630.  
  1631.      CASE (INVERSE_TOKEN)
  1632.         Invert ((OBJECT *) Local_Shape);
  1633.      END_CASE
  1634.  
  1635.      CASE (TEXTURE_TOKEN)
  1636.         Local_Texture = Parse_Texture ();
  1637.         if (Local_Texture->Constant_Flag)
  1638.            Local_Texture = Copy_Texture(Local_Texture);
  1639.  
  1640.         {
  1641.         TEXTURE *temp_texture;
  1642.  
  1643.         for (temp_texture = Local_Texture ;
  1644.              temp_texture->Next_Texture != NULL ;
  1645.              temp_texture = temp_texture->Next_Texture)
  1646.            {}
  1647.  
  1648.         temp_texture->Next_Texture = Local_Shape->Shape_Texture;
  1649.         Local_Shape->Shape_Texture = Local_Texture;
  1650.         }
  1651.      END_CASE
  1652.  
  1653.      CASE (COLOUR_TOKEN)
  1654.         Local_Shape->Shape_Colour = Get_Colour();
  1655.         Parse_Colour (Local_Shape->Shape_Colour);
  1656.      END_CASE
  1657.  
  1658.      OTHERWISE
  1659.         Parse_Error (END_QUADRIC_TOKEN);
  1660.      END_CASE
  1661.   END_EXPECT
  1662.  
  1663.   return ((SHAPE *) Local_Shape);
  1664.   }
  1665.  
  1666. SHAPE *Parse_Quartic ()
  1667. {
  1668.   QUARTIC *Local_Shape;
  1669.   VECTOR Local_Vector;
  1670.   CONSTANT Constant_Id;
  1671.   TEXTURE *Local_Texture;
  1672.  
  1673.   Local_Shape = NULL;
  1674.  
  1675.   EXPECT
  1676.      CASE (LEFT_ANGLE_TOKEN)
  1677.        UNGET
  1678.        Local_Shape = Get_Quartic_Shape();
  1679.        Parse_Coeffs(&(Local_Shape->Coeffs[0]));
  1680.        EXIT
  1681.      END_CASE
  1682.  
  1683.      CASE (IDENTIFIER_TOKEN)
  1684.        if ((Constant_Id = Find_Constant()) != -1)
  1685.          if (Constants[(int)Constant_Id].Constant_Type == QUARTIC_CONSTANT)
  1686.            Local_Shape = (QUARTIC *)Copy((OBJECT *)
  1687.                         Constants[(int)Constant_Id].Constant_Data);
  1688.          else
  1689.            Type_Error ();
  1690.        else
  1691.          Undeclared ();
  1692.        EXIT
  1693.      END_CASE
  1694.  
  1695.      OTHERWISE
  1696.         Parse_Error (LEFT_ANGLE_TOKEN);
  1697.      END_CASE
  1698.   END_EXPECT
  1699.  
  1700.   EXPECT
  1701.      CASE (END_QUARTIC_TOKEN)
  1702.         EXIT
  1703.      END_CASE
  1704.  
  1705.      CASE (TRANSLATE_TOKEN)
  1706.         Parse_Vector (&Local_Vector);
  1707.         Translate ((OBJECT *) Local_Shape, &Local_Vector);
  1708.      END_CASE
  1709.  
  1710.      CASE (ROTATE_TOKEN)
  1711.         Parse_Vector (&Local_Vector);
  1712.         Rotate ((OBJECT *) Local_Shape, &Local_Vector);
  1713.      END_CASE
  1714.  
  1715.      CASE (SCALE_TOKEN)
  1716.         Parse_Vector (&Local_Vector);
  1717.         Scale ((OBJECT *) Local_Shape, &Local_Vector);
  1718.      END_CASE
  1719.  
  1720.      CASE (INVERSE_TOKEN)
  1721.         Invert ((OBJECT *) Local_Shape);
  1722.      END_CASE
  1723.  
  1724.      CASE (TEXTURE_TOKEN)
  1725.         Local_Texture = Parse_Texture ();
  1726.         if (Local_Texture->Constant_Flag)
  1727.            Local_Texture = Copy_Texture(Local_Texture);
  1728.  
  1729.         {
  1730.         TEXTURE *temp_texture;
  1731.  
  1732.         for (temp_texture = Local_Texture ;
  1733.              temp_texture->Next_Texture != NULL ;
  1734.              temp_texture = temp_texture->Next_Texture)
  1735.            {}
  1736.  
  1737.         temp_texture->Next_Texture = Local_Shape->Shape_Texture;
  1738.         Local_Shape->Shape_Texture = Local_Texture;
  1739.         }
  1740.      END_CASE
  1741.  
  1742.      CASE (COLOUR_TOKEN)
  1743.         Local_Shape->Shape_Colour = Get_Colour();
  1744.         Parse_Colour (Local_Shape->Shape_Colour);
  1745.      END_CASE
  1746.  
  1747.      OTHERWISE
  1748.         Parse_Error (END_QUARTIC_TOKEN);
  1749.      END_CASE
  1750.   END_EXPECT
  1751.   return ((SHAPE *) Local_Shape);
  1752. }
  1753.  
  1754. CSG_SHAPE *Parse_CSG (type, Parent_Object)
  1755.   int type;
  1756.   OBJECT *Parent_Object;
  1757.   {
  1758.   CSG_SHAPE *Container = NULL;
  1759.   SHAPE *Local_Shape;
  1760.   VECTOR Local_Vector;
  1761.   CONSTANT Constant_Id;
  1762.   int First_Shape_Parsed = FALSE;
  1763.  
  1764.   if (type == CSG_UNION_TYPE)
  1765.     Container = Get_CSG_Union ();
  1766.  
  1767.   else if ((type == CSG_INTERSECTION_TYPE) || (type == CSG_DIFFERENCE_TYPE))
  1768.     Container = Get_CSG_Intersection ();
  1769.  
  1770.   Container -> Parent_Object = Parent_Object;
  1771.  
  1772.   EXPECT
  1773.      CASE (IDENTIFIER_TOKEN)
  1774.        if ((Constant_Id = Find_Constant()) != -1)
  1775.          if ((Constants[(int)Constant_Id].Constant_Type == CSG_INTERSECTION_CONSTANT)
  1776.              || (Constants[(int)Constant_Id].Constant_Type == CSG_UNION_CONSTANT)
  1777.              || (Constants[(int)Constant_Id].Constant_Type == CSG_DIFFERENCE_CONSTANT)) {
  1778.            free (Container);
  1779.            Container = (CSG_SHAPE *) Copy ((OBJECT *) Constants[(int)Constant_Id].Constant_Data);
  1780.            Set_CSG_Parents(Container, Parent_Object);
  1781.            }
  1782.          else
  1783.            Type_Error ();
  1784.        else
  1785.          Undeclared ();
  1786.      END_CASE
  1787.  
  1788.      CASE (SPHERE_TOKEN)
  1789.        Local_Shape = Parse_Sphere ();
  1790.        Local_Shape -> Parent_Object = Parent_Object;
  1791.        if ((type == CSG_DIFFERENCE_TYPE) && First_Shape_Parsed)
  1792.           Invert ((OBJECT *) Local_Shape);
  1793.        First_Shape_Parsed = TRUE;
  1794.        Link((OBJECT *) Local_Shape, (OBJECT **) &(Local_Shape -> Next_Object),
  1795.                (OBJECT **) &(Container -> Shapes));
  1796.      END_CASE
  1797.  
  1798.      CASE (PLANE_TOKEN)
  1799.        Local_Shape = Parse_Plane ();
  1800.        Local_Shape -> Parent_Object = Parent_Object;
  1801.        if ((type == CSG_DIFFERENCE_TYPE) && First_Shape_Parsed)
  1802.           Invert ((OBJECT *) Local_Shape);
  1803.        First_Shape_Parsed = TRUE;
  1804.        Link((OBJECT *) Local_Shape, (OBJECT **) &(Local_Shape -> Next_Object),
  1805.                (OBJECT **) &(Container -> Shapes));
  1806.      END_CASE
  1807.  
  1808.      CASE (TRIANGLE_TOKEN)
  1809.        Local_Shape = Parse_Triangle ();
  1810.        Local_Shape -> Parent_Object = Parent_Object;
  1811.        if ((type == CSG_DIFFERENCE_TYPE) && First_Shape_Parsed)
  1812.           Invert ((OBJECT *) Local_Shape);
  1813.        First_Shape_Parsed = TRUE;
  1814.        Link((OBJECT *) Local_Shape, (OBJECT **) &(Local_Shape -> Next_Object),
  1815.                (OBJECT **) &(Container -> Shapes));
  1816.      END_CASE
  1817.  
  1818.      CASE (SMOOTH_TRIANGLE_TOKEN)
  1819.        Local_Shape = Parse_Smooth_Triangle ();
  1820.        Local_Shape -> Parent_Object = Parent_Object;
  1821.        if ((type == CSG_DIFFERENCE_TYPE) && First_Shape_Parsed)
  1822.           Invert ((OBJECT *) Local_Shape);
  1823.        First_Shape_Parsed = TRUE;
  1824.        Link((OBJECT *) Local_Shape, (OBJECT **) &(Local_Shape -> Next_Object),
  1825.                (OBJECT **) &(Container -> Shapes));
  1826.      END_CASE
  1827.  
  1828.      CASE (QUADRIC_TOKEN)
  1829.        Local_Shape = Parse_Quadric ();
  1830.        Local_Shape -> Parent_Object = Parent_Object;
  1831.        if ((type == CSG_DIFFERENCE_TYPE) && First_Shape_Parsed)
  1832.           Invert ((OBJECT *) Local_Shape);
  1833.        First_Shape_Parsed = TRUE;
  1834.        Link((OBJECT *) Local_Shape, (OBJECT **) &(Local_Shape -> Next_Object),
  1835.                (OBJECT **) &(Container -> Shapes));
  1836.      END_CASE
  1837.  
  1838.      CASE (QUARTIC_TOKEN)
  1839.        Local_Shape = Parse_Quartic ();
  1840.        Local_Shape -> Parent_Object = Parent_Object;
  1841.        if ((type == CSG_DIFFERENCE_TYPE) && First_Shape_Parsed)
  1842.           Invert ((OBJECT *) Local_Shape);
  1843.        First_Shape_Parsed = TRUE;
  1844.        Link((OBJECT *) Local_Shape, (OBJECT **) &(Local_Shape -> Next_Object),
  1845.                (OBJECT **) &(Container -> Shapes));
  1846.      END_CASE
  1847.  
  1848.      CASE (UNION_TOKEN)
  1849.        Local_Shape = (SHAPE *) Parse_CSG (CSG_UNION_TYPE, Parent_Object);
  1850.        if ((type == CSG_DIFFERENCE_TYPE) && First_Shape_Parsed)
  1851.           Invert ((OBJECT *) Local_Shape);
  1852.        First_Shape_Parsed = TRUE;
  1853.        Link((OBJECT *) Local_Shape, (OBJECT **) &(Local_Shape -> Next_Object),
  1854.                (OBJECT **) &(Container -> Shapes));
  1855.      END_CASE
  1856.  
  1857.      CASE (INTERSECTION_TOKEN)
  1858.        Local_Shape = (SHAPE *) Parse_CSG (CSG_INTERSECTION_TYPE, Parent_Object);
  1859.        if ((type == CSG_DIFFERENCE_TYPE) && First_Shape_Parsed)
  1860.           Invert ((OBJECT *) Local_Shape);
  1861.        First_Shape_Parsed = TRUE;
  1862.        Link((OBJECT *) Local_Shape, (OBJECT **) &(Local_Shape -> Next_Object),
  1863.                (OBJECT **) &(Container -> Shapes));
  1864.      END_CASE
  1865.  
  1866.      CASE (DIFFERENCE_TOKEN)
  1867.        Local_Shape = (SHAPE *) Parse_CSG (CSG_DIFFERENCE_TYPE, Parent_Object);
  1868.        if ((type == CSG_DIFFERENCE_TYPE) && First_Shape_Parsed)
  1869.           Invert ((OBJECT *) Local_Shape);
  1870.        First_Shape_Parsed = TRUE;
  1871.        Link((OBJECT *) Local_Shape, (OBJECT **) &(Local_Shape -> Next_Object),
  1872.                (OBJECT **) &(Container -> Shapes));
  1873.      END_CASE
  1874.  
  1875.      OTHERWISE
  1876.         UNGET
  1877.         EXIT
  1878.      END_CASE
  1879.   END_EXPECT
  1880.  
  1881.   EXPECT
  1882.      CASE3 (END_UNION_TOKEN, END_INTERSECTION_TOKEN, END_DIFFERENCE_TOKEN)
  1883.         EXIT
  1884.      END_CASE
  1885.  
  1886.      CASE (TRANSLATE_TOKEN)
  1887.         Parse_Vector (&Local_Vector);
  1888.         Translate((OBJECT *) Container, &Local_Vector);
  1889.      END_CASE
  1890.  
  1891.      CASE (ROTATE_TOKEN)
  1892.         Parse_Vector (&Local_Vector);
  1893.         Rotate ((OBJECT *) Container, &Local_Vector);
  1894.      END_CASE
  1895.  
  1896.      CASE (SCALE_TOKEN)
  1897.         Parse_Vector (&Local_Vector);
  1898.         Scale ((OBJECT *) Container, &Local_Vector);
  1899.      END_CASE
  1900.  
  1901.      CASE (INVERSE_TOKEN)
  1902.         Invert ((OBJECT *) Container);
  1903.      END_CASE
  1904.  
  1905.      OTHERWISE
  1906.         if (type == CSG_UNION_TYPE)
  1907.            Parse_Error (END_UNION_TOKEN);
  1908.         else if (type == CSG_INTERSECTION_TYPE)
  1909.            Parse_Error (END_INTERSECTION_TOKEN);
  1910.         else
  1911.            Parse_Error (END_DIFFERENCE_TOKEN);
  1912.      END_CASE
  1913.   END_EXPECT
  1914.  
  1915.   return ((CSG_SHAPE *) Container);
  1916.   }
  1917.  
  1918. SHAPE *Parse_Shape (Object)
  1919.   OBJECT *Object;
  1920.   {
  1921.   SHAPE *Local_Shape = NULL;
  1922.  
  1923.   EXPECT
  1924.     CASE (SPHERE_TOKEN)
  1925.       Local_Shape = Parse_Sphere ();
  1926.       Local_Shape -> Parent_Object = Object;
  1927.       EXIT
  1928.     END_CASE
  1929.  
  1930.     CASE (PLANE_TOKEN)
  1931.       Local_Shape = Parse_Plane ();
  1932.       Local_Shape -> Parent_Object = Object;
  1933.       EXIT
  1934.     END_CASE
  1935.  
  1936.     CASE (TRIANGLE_TOKEN)
  1937.       Local_Shape = Parse_Triangle ();
  1938.       Local_Shape -> Parent_Object = Object;
  1939.       EXIT
  1940.     END_CASE
  1941.  
  1942.     CASE (SMOOTH_TRIANGLE_TOKEN)
  1943.       Local_Shape = Parse_Smooth_Triangle ();
  1944.       Local_Shape -> Parent_Object = Object;
  1945.       EXIT
  1946.     END_CASE
  1947.  
  1948.     CASE (QUADRIC_TOKEN)
  1949.       Local_Shape = Parse_Quadric ();
  1950.       Local_Shape -> Parent_Object = Object;
  1951.       EXIT
  1952.     END_CASE
  1953.  
  1954.     CASE (QUARTIC_TOKEN)
  1955.       Local_Shape = Parse_Quartic ();
  1956.       Local_Shape -> Parent_Object = Object;
  1957.       EXIT
  1958.     END_CASE
  1959.  
  1960.     CASE (UNION_TOKEN)
  1961.       Local_Shape = (SHAPE *) Parse_CSG (CSG_UNION_TYPE, Object);
  1962.       EXIT
  1963.     END_CASE
  1964.  
  1965.     CASE (INTERSECTION_TOKEN)
  1966.       Local_Shape = (SHAPE *) Parse_CSG (CSG_INTERSECTION_TYPE, Object);
  1967.       EXIT
  1968.     END_CASE
  1969.  
  1970.     CASE (DIFFERENCE_TOKEN)
  1971.       Local_Shape = (SHAPE *) Parse_CSG (CSG_DIFFERENCE_TYPE, Object);
  1972.       EXIT
  1973.     END_CASE
  1974.  
  1975.     OTHERWISE
  1976.        Parse_Error (QUADRIC_TOKEN);
  1977.     END_CASE
  1978.   END_EXPECT
  1979.   return (Local_Shape);
  1980.   }
  1981.  
  1982. OBJECT *Parse_Object ()
  1983.   {
  1984.   OBJECT *Object;
  1985.   SHAPE *Local_Shape;
  1986.   VECTOR Local_Vector;
  1987.   CONSTANT Constant_Id;
  1988.   TEXTURE *Local_Texture;
  1989.  
  1990.   Object = NULL;
  1991.  
  1992.   EXPECT
  1993.     CASE (IDENTIFIER_TOKEN)
  1994.       if ((Constant_Id = Find_Constant()) != -1)
  1995.         if (Constants[(int)Constant_Id].Constant_Type == OBJECT_CONSTANT)
  1996.           Object = (OBJECT *) Copy((OBJECT *) Constants[(int)Constant_Id].Constant_Data);
  1997.         else
  1998.           Type_Error ();
  1999.       else
  2000.         Undeclared ();
  2001.       EXIT
  2002.     END_CASE
  2003.  
  2004.     CASE6 (SPHERE_TOKEN, QUADRIC_TOKEN, QUARTIC_TOKEN, UNION_TOKEN,
  2005.            INTERSECTION_TOKEN, DIFFERENCE_TOKEN)
  2006.     CASE3 (TRIANGLE_TOKEN, SMOOTH_TRIANGLE_TOKEN, PLANE_TOKEN)
  2007.         UNGET
  2008.         if (Object == NULL)
  2009.            Object = Get_Object();
  2010.  
  2011.         Local_Shape = Parse_Shape(Object);
  2012.         Link((OBJECT *)Local_Shape, (OBJECT **) &(Local_Shape -> Next_Object),
  2013.                 (OBJECT **) &(Object -> Shape));
  2014.         EXIT
  2015.     END_CASE
  2016.  
  2017.     OTHERWISE
  2018.         Parse_Error (QUADRIC_TOKEN);
  2019.         EXIT
  2020.     END_CASE
  2021.   END_EXPECT
  2022.  
  2023.   EXPECT
  2024.     CASE (BOUNDED_TOKEN)
  2025.        EXPECT
  2026.           CASE (END_BOUNDED_TOKEN)
  2027.              EXIT
  2028.           END_CASE
  2029.  
  2030.           OTHERWISE
  2031.              UNGET
  2032.              Local_Shape = Parse_Shape(Object);
  2033.              Link((OBJECT *) Local_Shape,
  2034.                   (OBJECT **) &(Local_Shape -> Next_Object),
  2035.                   (OBJECT **) &(Object -> Bounding_Shapes));
  2036.           END_CASE
  2037.        END_EXPECT       
  2038.     END_CASE
  2039.  
  2040.     CASE (COLOUR_TOKEN)
  2041.        Object->Object_Colour = Get_Colour();
  2042.        Parse_Colour (Object -> Object_Colour);
  2043.     END_CASE
  2044.  
  2045.     CASE (TEXTURE_TOKEN)
  2046.         Local_Texture = Parse_Texture ();
  2047.         if (Local_Texture->Constant_Flag)
  2048.            Local_Texture = Copy_Texture(Local_Texture);
  2049.  
  2050.         if (Object->Object_Texture == Default_Texture)
  2051.            Object->Object_Texture = Local_Texture;
  2052.         else
  2053.         {
  2054.         TEXTURE *temp_texture;
  2055.  
  2056.         for (temp_texture = Local_Texture ;
  2057.              temp_texture->Next_Texture != NULL ;
  2058.              temp_texture = temp_texture->Next_Texture)
  2059.            {}
  2060.  
  2061.         temp_texture->Next_Texture = Object->Object_Texture;
  2062.         Object->Object_Texture = Local_Texture;
  2063.         }
  2064.     END_CASE
  2065.  
  2066.     CASE (LIGHT_SOURCE_TOKEN)
  2067.       Object -> Light_Source_Flag = TRUE;
  2068.     END_CASE
  2069.  
  2070.     CASE (TRANSLATE_TOKEN)
  2071.        Parse_Vector (&Local_Vector);
  2072.        Translate (Object, &Local_Vector);
  2073.     END_CASE
  2074.  
  2075.     CASE (ROTATE_TOKEN)
  2076.        Parse_Vector (&Local_Vector);
  2077.        Rotate (Object, &Local_Vector);
  2078.     END_CASE
  2079.  
  2080.     CASE (SCALE_TOKEN)
  2081.        Parse_Vector (&Local_Vector);
  2082.        Scale (Object, &Local_Vector);
  2083.     END_CASE
  2084.  
  2085.     CASE (INVERSE_TOKEN)
  2086.        Invert (Object);
  2087.     END_CASE
  2088.  
  2089.     CASE (END_OBJECT_TOKEN)
  2090.       EXIT
  2091.     END_CASE
  2092.  
  2093.     OTHERWISE
  2094.       Parse_Error (END_OBJECT_TOKEN);
  2095.     END_CASE
  2096.  
  2097.   END_EXPECT
  2098.  
  2099.   return (Object);
  2100.   }
  2101.  
  2102. OBJECT *Parse_Composite ()
  2103.   {
  2104.   COMPOSITE *Local_Composite;
  2105.   OBJECT *Local_Object;
  2106.   SHAPE *Local_Shape;
  2107.   CONSTANT Constant_Id;
  2108.   VECTOR Local_Vector;
  2109.  
  2110.   Local_Composite = NULL;
  2111.  
  2112.   EXPECT
  2113.     CASE (IDENTIFIER_TOKEN)
  2114.       if ((Constant_Id = Find_Constant()) != -1)
  2115.         if (Constants[(int)Constant_Id].Constant_Type == COMPOSITE_CONSTANT)
  2116.           Local_Composite = (COMPOSITE *)Copy((OBJECT *) Constants[(int)Constant_Id].Constant_Data);
  2117.         else          
  2118.           Type_Error ();
  2119.       else
  2120.         Undeclared ();
  2121.     END_CASE
  2122.  
  2123.     CASE (COMPOSITE_TOKEN)
  2124.       if (Local_Composite == NULL)       
  2125.            Local_Composite = Get_Composite_Object();
  2126.  
  2127.       Local_Object = Parse_Composite();
  2128.       Link((OBJECT *) Local_Object,(OBJECT **) &(Local_Object -> Next_Object),
  2129.               (OBJECT **) &(Local_Composite -> Objects));
  2130.     END_CASE
  2131.  
  2132.     CASE (OBJECT_TOKEN)
  2133.       if (Local_Composite == NULL)       
  2134.            Local_Composite = Get_Composite_Object();
  2135.  
  2136.       Local_Object = Parse_Object();
  2137.       Link(Local_Object, &(Local_Object -> Next_Object),
  2138.                &(Local_Composite -> Objects));
  2139.     END_CASE
  2140.  
  2141.     CASE (END_COMPOSITE_TOKEN)
  2142.       UNGET
  2143.       if (Local_Composite == NULL)       
  2144.         Local_Composite = Get_Composite_Object();
  2145.  
  2146.       EXIT
  2147.     END_CASE
  2148.  
  2149.     OTHERWISE
  2150.        UNGET
  2151.        EXIT
  2152.     END_CASE
  2153.   END_EXPECT
  2154.  
  2155.   EXPECT
  2156.     CASE (END_COMPOSITE_TOKEN)
  2157.        EXIT
  2158.     END_CASE
  2159.  
  2160.     CASE (BOUNDED_TOKEN)
  2161.        EXPECT
  2162.           CASE (END_BOUNDED_TOKEN)
  2163.              EXIT
  2164.           END_CASE
  2165.  
  2166.           OTHERWISE
  2167.              UNGET
  2168.              Local_Shape = Parse_Shape((OBJECT *) Local_Composite);
  2169.              Link((OBJECT *) Local_Shape,
  2170.                   (OBJECT **) &(Local_Shape -> Next_Object),
  2171.                   (OBJECT **) &(Local_Composite -> Bounding_Shapes));
  2172.           END_CASE
  2173.        END_EXPECT       
  2174.     END_CASE
  2175.  
  2176.     CASE (TRANSLATE_TOKEN)
  2177.        Parse_Vector (&Local_Vector);
  2178.        Translate ((OBJECT *) Local_Composite, &Local_Vector);
  2179.     END_CASE
  2180.  
  2181.     CASE (ROTATE_TOKEN)
  2182.        Parse_Vector (&Local_Vector);
  2183.        Rotate ((OBJECT *) Local_Composite, &Local_Vector);
  2184.     END_CASE
  2185.  
  2186.     CASE (SCALE_TOKEN)
  2187.        Parse_Vector (&Local_Vector);
  2188.        Scale ((OBJECT *) Local_Composite, &Local_Vector);
  2189.     END_CASE
  2190.  
  2191.      CASE (INVERSE_TOKEN)
  2192.         Invert ((OBJECT *) Local_Composite);
  2193.      END_CASE
  2194.  
  2195.     OTHERWISE
  2196.        Parse_Error (END_COMPOSITE_TOKEN);
  2197.     END_CASE
  2198.   END_EXPECT
  2199.  
  2200.   return ((OBJECT *) Local_Composite);
  2201.   }
  2202.  
  2203. void Parse_Fog ()
  2204.    {
  2205.    EXPECT
  2206.       CASE (COLOUR_TOKEN)
  2207.          Parse_Colour (&Parsing_Frame_Ptr->Fog_Colour);
  2208.       END_CASE
  2209.  
  2210.       CASE (FLOAT_TOKEN)
  2211.          Parsing_Frame_Ptr->Fog_Distance = Token.Token_Float;
  2212.       END_CASE
  2213.  
  2214.       CASE (END_FOG_TOKEN)
  2215.          EXIT
  2216.       END_CASE
  2217.  
  2218.       OTHERWISE
  2219.          Parse_Error (END_FOG_TOKEN);
  2220.       END_CASE
  2221.    END_EXPECT
  2222.    }
  2223.  
  2224. void Add_Composite_Light_Source (Object)
  2225.    COMPOSITE *Object;
  2226.    {
  2227.    OBJECT *Temp_Object;
  2228.  
  2229.    for (Temp_Object = Object -> Objects;
  2230.         Temp_Object != NULL ; 
  2231.         Temp_Object = Temp_Object->Next_Object) {
  2232.  
  2233.       if (Temp_Object->Type == OBJECT_TYPE) {
  2234.          if (Temp_Object->Light_Source_Flag) {
  2235.             Link(Temp_Object, &(Temp_Object -> Next_Light_Source),
  2236.                   &(Parsing_Frame_Ptr -> Light_Sources));
  2237.             }
  2238.          }
  2239.       else if (Temp_Object->Type == COMPOSITE_TYPE)
  2240.          Add_Composite_Light_Source ((COMPOSITE *)Temp_Object);
  2241.       }
  2242.    }
  2243.  
  2244. void Parse_Frame ()
  2245.   {
  2246.   OBJECT *Local_Object;
  2247.  
  2248.   EXPECT
  2249.     CASE (FOG_TOKEN)
  2250.        Parse_Fog();
  2251.     END_CASE
  2252.  
  2253.     CASE (OBJECT_TOKEN)
  2254.       Local_Object = Parse_Object();
  2255.       Link(Local_Object, &(Local_Object -> Next_Object),
  2256.              &(Parsing_Frame_Ptr -> Objects));
  2257.  
  2258.       if (Local_Object -> Light_Source_Flag)
  2259.          Link(Local_Object, &(Local_Object -> Next_Light_Source),
  2260.                &(Parsing_Frame_Ptr -> Light_Sources));
  2261.     END_CASE
  2262.  
  2263.     CASE (COMPOSITE_TOKEN)
  2264.       Local_Object = Parse_Composite();
  2265.       Link(Local_Object, &(Local_Object -> Next_Object),
  2266.             &(Parsing_Frame_Ptr -> Objects));
  2267.  
  2268.       Add_Composite_Light_Source ((COMPOSITE *)Local_Object);
  2269.     END_CASE
  2270.  
  2271.     CASE (VIEW_POINT_TOKEN)
  2272.       Parse_Viewpoint(&(Parsing_Frame_Ptr -> View_Point));
  2273.     END_CASE
  2274.  
  2275.     CASE (DECLARE_TOKEN)
  2276.       Parse_Declare ();
  2277.     END_CASE
  2278.  
  2279.     CASE (END_OF_FILE_TOKEN)
  2280.       EXIT
  2281.     END_CASE
  2282.  
  2283.     OTHERWISE 
  2284.       Parse_Error (OBJECT_TOKEN);
  2285.     END_CASE
  2286.   END_EXPECT
  2287.   }
  2288.  
  2289. void Parse_Viewpoint (Given_Vp)
  2290.   VIEWPOINT *Given_Vp;
  2291.   {
  2292.   CONSTANT Constant_Id;
  2293.   VECTOR Local_Vector, Temp_Vector;
  2294.   DBL Direction_Length, Up_Length, Right_Length, Handedness;
  2295.  
  2296.   Init_Viewpoint (Given_Vp);
  2297.  
  2298.   EXPECT
  2299.     CASE (IDENTIFIER_TOKEN)
  2300.       if ((Constant_Id = Find_Constant()) != -1)
  2301.         if (Constants[(int)Constant_Id].Constant_Type == VIEW_POINT_CONSTANT)
  2302.           *Given_Vp = 
  2303.              *((VIEWPOINT*) Constants[(int)Constant_Id].Constant_Data);
  2304.         else
  2305.           Type_Error ();
  2306.       else
  2307.         Undeclared ();
  2308.     END_CASE
  2309.  
  2310.     CASE (LOCATION_TOKEN)
  2311.       Parse_Vector(&(Given_Vp -> Location));
  2312.     END_CASE
  2313.  
  2314.     CASE (DIRECTION_TOKEN)
  2315.       Parse_Vector(&(Given_Vp -> Direction));
  2316.     END_CASE
  2317.  
  2318.     CASE (UP_TOKEN)
  2319.       Parse_Vector(&(Given_Vp -> Up));
  2320.     END_CASE
  2321.  
  2322.     CASE (RIGHT_TOKEN)
  2323.       Parse_Vector(&(Given_Vp -> Right));
  2324.     END_CASE
  2325.  
  2326.     CASE (SKY_TOKEN)
  2327.       Parse_Vector(&(Given_Vp -> Sky));
  2328.     END_CASE
  2329.  
  2330.     CASE (LOOK_AT_TOKEN)
  2331.        VLength (Direction_Length, Given_Vp->Direction);
  2332.        VLength (Up_Length, Given_Vp->Up);
  2333.        VLength (Right_Length, Given_Vp->Right);
  2334.        VCross (Temp_Vector, Given_Vp->Direction, Given_Vp->Up);
  2335.        VDot (Handedness, Temp_Vector, Given_Vp->Right);
  2336.        Parse_Vector(&Given_Vp->Direction);
  2337.  
  2338.        VSub (Given_Vp->Direction, Given_Vp->Direction, Given_Vp->Location);
  2339.        VNormalize (Given_Vp->Direction, Given_Vp->Direction);
  2340.        VCross(Given_Vp->Right, Given_Vp->Direction, Given_Vp->Sky);
  2341.        VNormalize (Given_Vp->Right, Given_Vp->Right);
  2342.        VCross (Given_Vp->Up, Given_Vp->Right, Given_Vp->Direction);
  2343.        VScale (Given_Vp->Direction, Given_Vp->Direction, Direction_Length);
  2344.        if (Handedness >= 0.0) {
  2345.           VScale (Given_Vp->Right, Given_Vp->Right, Right_Length);
  2346.           }
  2347.        else {
  2348.           VScale (Given_Vp->Right, Given_Vp->Right, -Right_Length);
  2349.           }
  2350.  
  2351.        VScale (Given_Vp->Up, Given_Vp->Up, Up_Length);       
  2352.     END_CASE
  2353.  
  2354.     CASE (TRANSLATE_TOKEN)
  2355.        Parse_Vector (&Local_Vector);
  2356.        Translate ((OBJECT *) Given_Vp, &Local_Vector);
  2357.     END_CASE
  2358.  
  2359.     CASE (ROTATE_TOKEN)
  2360.        Parse_Vector (&Local_Vector);
  2361.        Rotate ((OBJECT *) Given_Vp, &Local_Vector);
  2362.     END_CASE
  2363.  
  2364.     CASE (SCALE_TOKEN)
  2365.        Parse_Vector (&Local_Vector);
  2366.        Scale ((OBJECT *) Given_Vp, &Local_Vector);
  2367.     END_CASE
  2368.  
  2369.     CASE (END_VIEW_POINT_TOKEN)
  2370.       EXIT
  2371.     END_CASE
  2372.  
  2373.     OTHERWISE
  2374.       Parse_Error (END_VIEW_POINT_TOKEN);
  2375.     END_CASE
  2376.   END_EXPECT
  2377.   }
  2378.  
  2379. void Parse_Declare ()
  2380.   {
  2381.   CONSTANT Constant_Id;
  2382.   TEXTURE *Local_Texture;
  2383.   struct Constant_Struct *Constant_Ptr;
  2384.  
  2385.   GET (IDENTIFIER_TOKEN);
  2386.   if ((Constant_Id = Find_Constant()) == -1)
  2387.     if (++Number_Of_Constants >= MAX_CONSTANTS)
  2388.       Error ("Too many constants \"DECLARED\"");
  2389.     else
  2390.       Constant_Id = Number_Of_Constants;
  2391.  
  2392.   Constant_Ptr = &(Constants[(int)Constant_Id]);
  2393.   GET (EQUALS_TOKEN);
  2394.  
  2395.   EXPECT
  2396.     CASE (OBJECT_TOKEN)
  2397.       Constant_Ptr -> Identifier_Number = Token.Identifier_Number;
  2398.       Constant_Ptr -> Constant_Data = (char *) Parse_Object();
  2399.       Constant_Ptr -> Constant_Type = OBJECT_CONSTANT;
  2400.       EXIT
  2401.     END_CASE
  2402.  
  2403.     CASE (SPHERE_TOKEN)
  2404.       Constant_Ptr -> Identifier_Number = Token.Identifier_Number;
  2405.       Constant_Ptr -> Constant_Data = (char *) Parse_Sphere ();
  2406.       Constant_Ptr -> Constant_Type = SPHERE_CONSTANT;
  2407.       EXIT
  2408.     END_CASE
  2409.  
  2410.     CASE (PLANE_TOKEN)
  2411.       Constant_Ptr -> Identifier_Number = Token.Identifier_Number;
  2412.       Constant_Ptr -> Constant_Data = (char *) Parse_Plane ();
  2413.       Constant_Ptr -> Constant_Type = PLANE_CONSTANT;
  2414.       EXIT
  2415.     END_CASE
  2416.  
  2417.     CASE (TRIANGLE_TOKEN)
  2418.       Constant_Ptr -> Identifier_Number = Token.Identifier_Number;
  2419.       Constant_Ptr -> Constant_Data = (char *) Parse_Triangle ();
  2420.       Constant_Ptr -> Constant_Type = TRIANGLE_CONSTANT;
  2421.       EXIT
  2422.     END_CASE
  2423.  
  2424.     CASE (SMOOTH_TRIANGLE_TOKEN)
  2425.       Constant_Ptr -> Identifier_Number = Token.Identifier_Number;
  2426.       Constant_Ptr -> Constant_Data = (char *) Parse_Smooth_Triangle ();
  2427.       Constant_Ptr -> Constant_Type = SMOOTH_TRIANGLE_CONSTANT;
  2428.       EXIT
  2429.     END_CASE
  2430.  
  2431.     CASE (QUADRIC_TOKEN)
  2432.       Constant_Ptr -> Identifier_Number = Token.Identifier_Number;
  2433.       Constant_Ptr -> Constant_Data = (char *) Parse_Quadric ();
  2434.       Constant_Ptr -> Constant_Type = QUADRIC_CONSTANT;
  2435.       EXIT
  2436.     END_CASE
  2437.  
  2438.     CASE (QUARTIC_TOKEN)
  2439.       Constant_Ptr -> Identifier_Number = Token.Identifier_Number;
  2440.       Constant_Ptr -> Constant_Data = (char *) Parse_Quartic ();
  2441.       Constant_Ptr -> Constant_Type = QUARTIC_CONSTANT;
  2442.       EXIT
  2443.     END_CASE
  2444.  
  2445.     CASE (INTERSECTION_TOKEN)
  2446.       Constant_Ptr -> Identifier_Number = Token.Identifier_Number;
  2447.       Constant_Ptr -> Constant_Data = (char *) Parse_CSG(CSG_INTERSECTION_TYPE, NULL);
  2448.       Constant_Ptr -> Constant_Type = CSG_INTERSECTION_CONSTANT;
  2449.       EXIT
  2450.     END_CASE
  2451.  
  2452.     CASE (UNION_TOKEN)
  2453.       Constant_Ptr -> Identifier_Number = Token.Identifier_Number;
  2454.       Constant_Ptr -> Constant_Data = (char *) Parse_CSG(CSG_UNION_TYPE, NULL);
  2455.       Constant_Ptr -> Constant_Type = CSG_UNION_CONSTANT;
  2456.       EXIT
  2457.     END_CASE
  2458.  
  2459.     CASE (DIFFERENCE_TOKEN)
  2460.       Constant_Ptr -> Identifier_Number = Token.Identifier_Number;
  2461.       Constant_Ptr -> Constant_Data = (char *) Parse_CSG(CSG_DIFFERENCE_TYPE, NULL);
  2462.       Constant_Ptr -> Constant_Type = CSG_DIFFERENCE_CONSTANT;
  2463.       EXIT
  2464.     END_CASE
  2465.  
  2466.     CASE (COMPOSITE_TOKEN)
  2467.       Constant_Ptr -> Identifier_Number = Token.Identifier_Number;
  2468.       Constant_Ptr -> Constant_Data = (char *) Parse_Composite();
  2469.       Constant_Ptr -> Constant_Type = COMPOSITE_CONSTANT;
  2470.       EXIT
  2471.     END_CASE
  2472.  
  2473.     CASE (TEXTURE_TOKEN)
  2474.       Constant_Ptr -> Identifier_Number = Token.Identifier_Number;
  2475.       Local_Texture = NULL;
  2476.       Constant_Ptr -> Constant_Data = (char *) Local_Texture;
  2477.       Constant_Ptr -> Constant_Type = TEXTURE_CONSTANT;
  2478.       UNGET
  2479.       EXPECT
  2480.          CASE (TEXTURE_TOKEN)
  2481.             Local_Texture = Parse_Texture ();
  2482.             if (Local_Texture->Constant_Flag)
  2483.                Local_Texture = Copy_Texture(Local_Texture);
  2484.  
  2485.             Local_Texture -> Constant_Flag = TRUE;
  2486.  
  2487.             {
  2488.             TEXTURE *temp_texture;
  2489.             for (temp_texture = Local_Texture ;
  2490.                  temp_texture->Next_Texture != NULL ;
  2491.                  temp_texture = temp_texture->Next_Texture)
  2492.                {}
  2493.  
  2494.             temp_texture->Next_Texture = (TEXTURE *) Constant_Ptr->Constant_Data;
  2495.             Constant_Ptr->Constant_Data = (char *) Local_Texture;
  2496.             }
  2497.          END_CASE
  2498.  
  2499.          OTHERWISE
  2500.             UNGET
  2501.             EXIT
  2502.          END_CASE
  2503.       END_EXPECT
  2504.       EXIT
  2505.     END_CASE
  2506.  
  2507.     CASE (VIEW_POINT_TOKEN)
  2508.       Constant_Ptr -> Identifier_Number = Token.Identifier_Number;
  2509.       Constant_Ptr -> Constant_Data = (char *) Get_Viewpoint();
  2510.       Constant_Ptr -> Constant_Type = VIEW_POINT_CONSTANT;
  2511.       Parse_Viewpoint((VIEWPOINT *) Constant_Ptr -> Constant_Data);
  2512.       EXIT
  2513.     END_CASE
  2514.  
  2515.     CASE (COLOUR_TOKEN)
  2516.       Constant_Ptr -> Identifier_Number = Token.Identifier_Number;
  2517.       Constant_Ptr -> Constant_Data = (char *) Get_Colour();
  2518.       Constant_Ptr -> Constant_Type = COLOUR_CONSTANT;
  2519.       Parse_Colour ((COLOUR *) Constant_Ptr -> Constant_Data);
  2520.       EXIT
  2521.     END_CASE
  2522.  
  2523.     CASE (LEFT_ANGLE_TOKEN)
  2524.       UNGET
  2525.       Constant_Ptr -> Identifier_Number = Token.Identifier_Number;
  2526.       Constant_Ptr -> Constant_Data = (char *) Get_Vector();
  2527.       Constant_Ptr -> Constant_Type = VECTOR_CONSTANT;
  2528.       Parse_Vector((VECTOR *) Constant_Ptr -> Constant_Data);
  2529.       EXIT
  2530.     END_CASE
  2531.  
  2532.     CASE3 (DASH_TOKEN, PLUS_TOKEN, FLOAT_TOKEN)
  2533.       UNGET
  2534.       Constant_Ptr -> Identifier_Number = Token.Identifier_Number;
  2535.       Constant_Ptr -> Constant_Data = (char *) Get_Float();
  2536.       Constant_Ptr -> Constant_Type = FLOAT_CONSTANT;
  2537.       *((DBL *) Constant_Ptr -> Constant_Data) = Parse_Float();
  2538.       EXIT
  2539.     END_CASE
  2540.  
  2541.     OTHERWISE
  2542.       Parse_Error (OBJECT_TOKEN);
  2543.     END_CASE
  2544.   END_EXPECT
  2545.   }
  2546.  
  2547. void Init_Viewpoint (vp)
  2548.   VIEWPOINT *vp;
  2549.   {
  2550.   vp -> Methods = (void *) &Viewpoint_Methods;
  2551.   vp -> Type = VIEWPOINT_TYPE;
  2552.   Make_Vector (&vp->Location, 0.0, 0.0, 0.0);
  2553.   Make_Vector (&vp->Direction, 0.0, 0.0, 1.0);
  2554.   Make_Vector (&vp->Up, 0.0, 1.0, 0.0);
  2555.   Make_Vector (&vp->Right, 1.0, 0.0, 0.0);
  2556.   Make_Vector (&vp->Sky, 0.0, 1.0, 0.0);
  2557.   }
  2558.  
  2559. void Link (New_Object, Field, Old_Object_List)
  2560.   OBJECT *New_Object, **Field, **Old_Object_List;
  2561.   {
  2562.   *Field = *Old_Object_List;
  2563.   *Old_Object_List = New_Object;
  2564.   }
  2565.  
  2566. CONSTANT Find_Constant()
  2567.   {
  2568.   register int i;
  2569.  
  2570.   for (i = 1 ; i <= Number_Of_Constants ; i++)
  2571.     if (Constants [i].Identifier_Number == Token.Identifier_Number)
  2572.       return (i);
  2573.  
  2574.   return (-1);
  2575.   }
  2576.  
  2577.  
  2578. char *Get_Token_String (Token_Id)
  2579.   TOKEN Token_Id;
  2580.   {
  2581.   register int i;
  2582.  
  2583.   for (i = 0 ; i < LAST_TOKEN ; i++)
  2584.      if (Reserved_Words[i].Token_Number == Token_Id)
  2585.         return (Reserved_Words[i].Token_Name);
  2586.   return ("");
  2587.   }
  2588.  
  2589. void Parse_Error (Token_Id)
  2590.   TOKEN Token_Id;
  2591.   {
  2592.   char *expected, *found;
  2593.  
  2594.   PRINT ("Error in file %s line %d\n", Token.Filename, Token.Token_Line_No);
  2595.   expected = Get_Token_String (Token_Id);
  2596.   found = Get_Token_String (Token.Token_Id);
  2597.   PRINT ("%s expected but %s found instead\n", expected, found);
  2598.   return;
  2599.   }
  2600.  
  2601. void Type_Error ()
  2602.   {
  2603.   PRINT ("Error in file %s line %d\n", Token.Filename, Token.Token_Line_No);
  2604.   PRINT ("Identifier %s is the wrong type\n", Token.Token_String);
  2605.   return;
  2606.   }
  2607.  
  2608. void Undeclared ()
  2609.   {
  2610.   PRINT ("Error in file %s line %d\n", Token.Filename, Token.Token_Line_No);
  2611.   PRINT ("Undeclared identifier %s\n", Token.Token_String);
  2612.   return;
  2613.   }
  2614.  
  2615. void Error (str)
  2616.   char *str;
  2617.   {
  2618.   PRINT ("Error in file %s line %d\n", Token.Filename, Token.Token_Line_No);
  2619.   PRINT ("%s\n", str);
  2620.   return;
  2621.   }
  2622.  
  2623.