home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: Graphics / Graphics.zip / pov22f.zip / source / parse.c < prev    next >
C/C++ Source or Header  |  1993-11-09  |  89KB  |  3,294 lines
  1. /****************************************************************************
  2. *                parse.c
  3. *
  4. *  This module implements a parser for the scene description files.
  5. *
  6. *  from Persistence of Vision Raytracer
  7. *  Copyright 1993 Persistence of Vision Team
  8. *---------------------------------------------------------------------------
  9. *  NOTICE: This source code file is provided so that users may experiment
  10. *  with enhancements to POV-Ray and to port the software to platforms other 
  11. *  than those supported by the POV-Ray Team.  There are strict rules under
  12. *  which you are permitted to use this file.  The rules are in the file
  13. *  named POVLEGAL.DOC which should be distributed with this file. If 
  14. *  POVLEGAL.DOC is not available or for more info please contact the POV-Ray
  15. *  Team Coordinator by leaving a message in CompuServe's Graphics Developer's
  16. *  Forum.  The latest version of POV-Ray may be found there as well.
  17. *
  18. * This program is based on the popular DKB raytracer version 2.12.
  19. * DKBTrace was originally written by David K. Buck.
  20. * DKBTrace Ver 2.0-2.12 were written by David K. Buck & Aaron A. Collins.
  21. *
  22. *****************************************************************************/
  23.  
  24. #include "frame.h"
  25. #include "vector.h"
  26. #include "povproto.h"
  27. #include "parse.h"
  28.  
  29. /* This file implements a simple recursive-descent parser for reading the
  30. input file.  */
  31.  
  32. extern DBL Max_Trace_Level;
  33. extern char VerboseFormat;
  34. extern unsigned int Options;
  35. extern int Use_Slabs;
  36. extern char Stat_File_Name[FILE_NAME_LENGTH];
  37.  
  38. extern struct Reserved_Word_Struct Reserved_Words [];
  39. extern DBL Antialias_Threshold;
  40.  
  41. extern struct Token_Struct Token;
  42. extern char String[MAX_STRING_INDEX];
  43.  
  44. extern COLOUR_MAP_ENTRY *Build_Entries;
  45. extern FRAME Frame;
  46. extern DBL Clock_Value;
  47. extern char **Symbol_Table;
  48. extern int Max_Intersections;
  49. extern DBL Language_Version;
  50. extern METHODS Csg_Height_Field_Methods;
  51. extern METHODS CSG_Union_Methods;
  52.  
  53. static void Parse_Image_Map PARAMS((PIGMENT *Pigment));
  54. static void Parse_Bump_Map PARAMS((TNORMAL *Tnormal));
  55. static void Parse_Pigment PARAMS((PIGMENT **Pigment_Ptr));
  56. static void Parse_Tnormal PARAMS((TNORMAL **Tnormal_Ptr));
  57. static void Parse_Finish PARAMS((FINISH **Finish_Ptr));
  58. static TEXTURE *Parse_Texture PARAMS((void));
  59. static void Token_Init PARAMS((void));
  60. static void Frame_Init PARAMS((void));
  61. static void Parse_Coeffs PARAMS((int order, DBL *Coeffs));
  62. static IMAGE *Parse_Image PARAMS((int Legal));
  63. static TRANSFORM *Parse_Transform PARAMS((void));
  64. static void Parse_Object_Mods PARAMS((OBJECT *Object));
  65. static OBJECT *Parse_Bicubic_Patch PARAMS((void));
  66. static OBJECT *Parse_Blob PARAMS((void));
  67. static OBJECT *Parse_Box PARAMS((void));
  68. static OBJECT *Parse_Cone PARAMS((void));
  69. static OBJECT *Parse_Cylinder PARAMS((void));
  70. static OBJECT *Parse_Disc PARAMS((void));
  71. static OBJECT *Parse_Height_Field PARAMS((void));
  72. static OBJECT *Parse_Plane PARAMS((void));
  73. static OBJECT *Parse_Poly PARAMS((int order));
  74. static OBJECT *Parse_Quadric PARAMS((void));
  75. static OBJECT *Parse_Smooth_Triangle PARAMS((void));
  76. static OBJECT *Parse_Sphere PARAMS((void));
  77. static OBJECT *Parse_Torus PARAMS((void));
  78. static OBJECT *Parse_Triangle PARAMS((void));
  79. static OBJECT *Parse_CSG PARAMS((int CSG_Type));
  80. static OBJECT *Parse_Light_Source PARAMS((void));
  81. static OBJECT *Parse_Object PARAMS((void));
  82. static void Parse_Fog PARAMS((void));
  83. static void Parse_Frame PARAMS((void));
  84. static void Parse_Camera PARAMS((CAMERA **Camera_Ptr));
  85. static void Parse_Declare PARAMS((void));
  86. static void Link PARAMS((OBJECT *New_Object,OBJECT **Field,OBJECT **Old_Object_List));
  87. static void Link_Textures PARAMS((TEXTURE **Old_Texture, TEXTURE *New_Texture));
  88. static char *Get_Token_String PARAMS((TOKEN Token_Id));
  89. static void Where_Error PARAMS((void));
  90. static int Test_Redefine PARAMS((int a));
  91. static OBJECT *Parse_Bound_Clip PARAMS((void));
  92. static void Found_Instead PARAMS((void));
  93. /*static void Parse_Warn PARAMS((TOKEN Token_Id));*/
  94. static void Warn_State PARAMS((TOKEN Token_Id, TOKEN Type));
  95. static void Post_Process PARAMS((OBJECT *Object, OBJECT *Parent));
  96. static void Destroy_Constants PARAMS((void));
  97. static OBJECT *Parse_Object_Id PARAMS((void));
  98. static void Link_To_Frame PARAMS((OBJECT *Object));
  99.  
  100. extern struct Constant_Struct Constants[MAX_CONSTANTS];
  101.  
  102. int Number_Of_Constants;
  103. int Previous;
  104. short Have_Vector;
  105. short Not_In_Default;
  106.  
  107. TOKEN *Brace_Stack;
  108. int Brace_Index;
  109.  
  110. TEXTURE *Default_Texture;
  111. CAMERA *Default_Camera;
  112.  
  113. /* Parse the file. */
  114. void Parse ()
  115.   {
  116.    Build_Entries  = NULL;
  117.    if ((Brace_Stack = (TOKEN *) malloc(MAX_BRACES*sizeof (TOKEN))) == NULL)
  118.      MAError ("brace stack");
  119.    Brace_Index = 0;
  120.    Token_Init ();
  121.    Default_Camera = Create_Camera();
  122.    Default_Texture = Create_PNF_Texture();
  123.    Default_Texture->Pigment = Create_Pigment();
  124.    Default_Texture->Tnormal = NULL;
  125.    Default_Texture->Finish  = Create_Finish();
  126.    Not_In_Default = TRUE;
  127.    Frame_Init ();
  128.    Parse_Frame ();
  129.    if (Frame.Objects==NULL)
  130.      Error("No objects in scene");
  131.    Destroy_Constants ();
  132.    Destroy_Textures(Default_Texture);
  133.    Destroy_Camera(Default_Camera);
  134.    if (Build_Entries != NULL)
  135.      free (Build_Entries);
  136.    free (Brace_Stack);
  137.   }
  138.  
  139. static void Token_Init ()
  140.   {
  141.    Number_Of_Constants = 0;
  142.   }
  143.  
  144. /* Set up the fields in the frame to default values. */
  145. static
  146. void Frame_Init ()
  147.   {
  148.    Frame.Camera = Copy_Camera(Default_Camera);
  149.    Frame.Light_Sources = NULL;
  150.    Frame.Objects = NULL;
  151.    Frame.Atmosphere_IOR = 1.0;
  152.    Frame.Antialias_Threshold = Antialias_Threshold;
  153.    Frame.Fog_Distance = 0.0;
  154.    Make_Colour (&(Frame.Fog_Colour), 0.0, 0.0, 0.0);
  155.   }
  156.  
  157. void Parse_Begin ()
  158.   {
  159.    char *front;
  160.  
  161.    Brace_Stack[++Brace_Index]=Token.Token_Id;
  162.    Get_Token ();
  163.  
  164.    if (Token.Token_Id == LEFT_CURLY_TOKEN)
  165.      return;
  166.  
  167.    Where_Error ();
  168.  
  169.    front = Get_Token_String (Brace_Stack[Brace_Index]);
  170.    fprintf (stderr, "Missing { after %s, ", front);
  171.    Found_Instead ();
  172.    exit (1);
  173.   }
  174.  
  175. void Parse_End ()
  176.   {
  177.    char *front;
  178.  
  179.    Get_Token ();
  180.  
  181.    if (Token.Token_Id == RIGHT_CURLY_TOKEN)
  182.      {
  183.       Brace_Index--;
  184.       return;
  185.      }
  186.  
  187.    Where_Error ();
  188.  
  189.    front = Get_Token_String (Brace_Stack[Brace_Index]);
  190.    fprintf (stderr, "No matching } in %s,", front);
  191.    Found_Instead ();
  192.    exit (1);
  193.   }
  194.  
  195. static OBJECT *Parse_Object_Id ()
  196.   {
  197.    OBJECT *Object;
  198.    
  199.    EXPECT
  200.      CASE (OBJECT_ID_TOKEN)
  201.        Warn_State(OBJECT_ID_TOKEN, OBJECT_TOKEN);
  202.        Object = Copy_Object((OBJECT *) Token.Constant_Data);
  203.        Parse_Object_Mods (Object);
  204.        EXIT
  205.      END_CASE
  206.  
  207.      OTHERWISE
  208.        Object = NULL;
  209.        UNGET
  210.        EXIT
  211.      END_CASE
  212.    END_EXPECT
  213.  
  214.    return (Object);
  215.   }
  216.  
  217. void Parse_Comma ()
  218.   {
  219.    Get_Token();
  220.    if (Token.Token_Id != COMMA_TOKEN)
  221.      {
  222.       UNGET;
  223.      }
  224.   }
  225.  
  226. static void Parse_Coeffs(order, Coeffs)
  227.   int order;
  228.   DBL *Coeffs;
  229.   {
  230.    int i;
  231.  
  232.    EXPECT
  233.      CASE (LEFT_ANGLE_TOKEN)
  234.        Coeffs[0] = Parse_Float();
  235.        for (i = 1; i < term_counts(order); i++)
  236.          {
  237.           Parse_Comma();
  238.           Coeffs[i] = Parse_Float();
  239.          }
  240.        GET (RIGHT_ANGLE_TOKEN);
  241.        EXIT
  242.      END_CASE
  243.  
  244.      OTHERWISE
  245.        Parse_Error (LEFT_ANGLE_TOKEN);
  246.      END_CASE
  247.    END_EXPECT
  248.   }
  249.  
  250. static
  251. IMAGE *Parse_Image (Legal)
  252.   int Legal;
  253.   {
  254.    IMAGE *Image;
  255.    VECTOR Local_Vector;
  256.  
  257.    Image = Create_Image ();
  258.  
  259.    if (Legal & GRAD_FILE)
  260.      {
  261.       EXPECT
  262.         CASE_VECTOR
  263.           Warn("Should use map_type keyword and/or eliminate orientation.",1.5);
  264.           Have_Vector = FALSE;
  265.           Parse_Vector_Float (&Local_Vector);
  266.           if (Have_Vector)
  267.             Image->Gradient = Local_Vector;
  268.           else
  269.             Image->Map_Type = (int)Local_Vector.x;
  270.         END_CASE
  271.  
  272.         OTHERWISE
  273.           UNGET
  274.           EXIT
  275.         END_CASE
  276.       END_EXPECT
  277.      }
  278.  
  279.    EXPECT
  280.      CASE (IFF_TOKEN)
  281.        Image->File_Type = IFF_FILE;
  282.        GET (STRING_TOKEN);
  283.        Read_Iff_Image (Image, Token.Token_String);
  284.        EXIT
  285.      END_CASE
  286.  
  287.      CASE (GIF_TOKEN)
  288.        Image->File_Type = GIF_FILE;
  289.        GET (STRING_TOKEN);
  290.        Read_Gif_Image(Image, Token.Token_String);
  291.        EXIT
  292.      END_CASE
  293.  
  294.      CASE (POT_TOKEN)
  295.        Image->File_Type = POT_FILE;
  296.        GET (STRING_TOKEN);
  297.        Read_Gif_Image(Image, Token.Token_String);
  298.        EXIT
  299.      END_CASE
  300.  
  301.      CASE (DUMP_TOKEN)
  302.        Image->File_Type = DUMP_FILE;
  303.        GET (STRING_TOKEN);
  304.        Read_Dump_Image(Image, Token.Token_String);
  305.        EXIT
  306.      END_CASE
  307.  
  308.      CASE (TGA_TOKEN)
  309.        Image->File_Type = TGA_FILE;
  310.        GET (STRING_TOKEN);
  311.        Read_Targa_Image(Image, Token.Token_String);
  312.        EXIT
  313.      END_CASE
  314.  
  315.      OTHERWISE
  316.        Parse_Error_Str ("map file spec");
  317.      END_CASE
  318.    END_EXPECT
  319.  
  320.    if (!(Image->File_Type & Legal))
  321.      Error ("File type not supported here");
  322.    return (Image);
  323.   }
  324.  
  325. static void Parse_Image_Map (Pigment)
  326.   PIGMENT *Pigment;
  327.   {
  328.    int reg;
  329.  
  330.    Pigment->Type = IMAGE_MAP_PIGMENT;
  331.  
  332.    Parse_Begin ();
  333.  
  334.    Pigment->Image = Parse_Image (IMAGE_FILE);
  335.    Pigment->Image->Use_Colour_Flag = TRUE;
  336.  
  337.    EXPECT                   /* Look for image_attribs */
  338.      CASE (ONCE_TOKEN)
  339.        Pigment->Image->Once_Flag=TRUE;
  340.      END_CASE
  341.  
  342.      CASE (INTERPOLATE_TOKEN)
  343.        Pigment->Image->Interpolation_Type = (int)Parse_Float();
  344.      END_CASE
  345.  
  346.      CASE (MAP_TYPE_TOKEN)
  347.        Pigment->Image->Map_Type = (int) Parse_Float ();
  348.      END_CASE
  349.  
  350.      CASE (USE_COLOUR_TOKEN)
  351.        Pigment->Image->Use_Colour_Flag = TRUE;
  352.      END_CASE
  353.  
  354.      CASE (USE_INDEX_TOKEN)
  355.        Pigment->Image->Use_Colour_Flag = FALSE;
  356.      END_CASE
  357.  
  358.      CASE (ALPHA_TOKEN)
  359.        Warn("Keyword ALPHA discontinued.  Use FILTER instead.",1.55);
  360.          
  361.      CASE (FILTER_TOKEN)
  362.        EXPECT
  363.          CASE (ALL_TOKEN)
  364.            {
  365.             DBL filter;
  366.             filter = Parse_Float();
  367.             for (reg = 0 ; reg < Pigment->Image->Colour_Map_Size ; reg++)
  368.               Pigment->Image->Colour_Map[reg].Filter
  369.                   = (unsigned short) (filter *255.0);
  370.            }
  371.            EXIT
  372.          END_CASE
  373.  
  374.          OTHERWISE
  375.            UNGET
  376.            reg = (int)(Parse_Float() + 0.01);
  377.            if (Pigment->Image->Colour_Map == NULL)
  378.              Error ("Can't apply FILTER to a non colour-mapped image\n");
  379.            if ((reg < 0) || (reg >= Pigment->Image->Colour_Map_Size))
  380.              Error ("FILTER colour register value out of range.\n");
  381.  
  382.            Parse_Comma();
  383.            Pigment->Image->Colour_Map[reg].Filter
  384.                   = (unsigned short) (255.0 * Parse_Float());
  385.            EXIT
  386.          END_CASE
  387.  
  388.        END_EXPECT
  389.      END_CASE
  390.  
  391.      OTHERWISE
  392.        UNGET
  393.        EXIT
  394.      END_CASE
  395.    END_EXPECT
  396.  
  397.    Parse_End ();
  398. }
  399.  
  400. static void Parse_Bump_Map (Tnormal)
  401.   TNORMAL *Tnormal;
  402.   {
  403.    Tnormal->Type = BUMP_MAP;
  404.  
  405.    Parse_Begin ();
  406.  
  407.    Tnormal->Image = Parse_Image (NORMAL_FILE);
  408.  
  409.    Tnormal->Image->Use_Colour_Flag = TRUE;
  410.  
  411.    EXPECT
  412.      CASE (ONCE_TOKEN)
  413.        Tnormal->Image->Once_Flag=TRUE;
  414.      END_CASE
  415.  
  416.      CASE (MAP_TYPE_TOKEN)
  417.        Tnormal->Image->Map_Type = (int) Parse_Float ();
  418.      END_CASE
  419.  
  420.      CASE (INTERPOLATE_TOKEN)
  421.        Tnormal->Image->Interpolation_Type = (int)Parse_Float();
  422.      END_CASE
  423.  
  424.      CASE (BUMP_SIZE_TOKEN)
  425.        Tnormal->Amount = Parse_Float ();
  426.      END_CASE
  427.  
  428.      CASE (USE_COLOUR_TOKEN)
  429.        Tnormal->Image->Use_Colour_Flag = TRUE;
  430.      END_CASE
  431.  
  432.      CASE (USE_INDEX_TOKEN)
  433.        Tnormal->Image->Use_Colour_Flag = FALSE;
  434.      END_CASE
  435.  
  436.      OTHERWISE
  437.        UNGET
  438.        EXIT
  439.      END_CASE
  440.    END_EXPECT
  441.    Parse_End ();
  442. }
  443.  
  444. static void Parse_Pigment (Pigment_Ptr)
  445.   PIGMENT **Pigment_Ptr;
  446.   {
  447.    PIGMENT *New;
  448.    VECTOR Local_Vector;
  449.  
  450.    Parse_Begin ();
  451.  
  452.    EXPECT            /* Look for [pigment_id] */
  453.      CASE (PIGMENT_ID_TOKEN)
  454.        Destroy_Pigment(*Pigment_Ptr);
  455.        *Pigment_Ptr = Copy_Pigment ((PIGMENT *) Token.Constant_Data);
  456.        EXIT
  457.      END_CASE
  458.  
  459.      OTHERWISE
  460.        UNGET
  461.        EXIT
  462.      END_CASE
  463.    END_EXPECT    /* End pigment_id */
  464.  
  465.    New = *Pigment_Ptr;
  466.  
  467.    EXPECT
  468.      CASE (AGATE_TOKEN)
  469.        New->Type = AGATE_PIGMENT;
  470.        EXIT
  471.      END_CASE
  472.  
  473.      CASE (BOZO_TOKEN)
  474.        New->Type = BOZO_PIGMENT;
  475.        EXIT
  476.      END_CASE
  477.  
  478.      CASE (GRANITE_TOKEN)
  479.        New->Type = GRANITE_PIGMENT;
  480.        EXIT
  481.      END_CASE
  482.  
  483.      CASE (LEOPARD_TOKEN)
  484.        New->Type = LEOPARD_PIGMENT;
  485.        EXIT
  486.      END_CASE
  487.  
  488.      CASE (MARBLE_TOKEN)
  489.        New->Type = MARBLE_PIGMENT;
  490.        EXIT
  491.      END_CASE
  492.  
  493.      CASE (MANDEL_TOKEN)
  494.        New->Type = MANDEL_PIGMENT;
  495.        New->Iterations = (int)Parse_Float();
  496.        EXIT
  497.      END_CASE
  498.  
  499.      CASE (ONION_TOKEN)
  500.        New->Type = ONION_PIGMENT;
  501.        EXIT
  502.      END_CASE
  503.  
  504.      CASE (PAINTED1_TOKEN)
  505.        New->Type = PAINTED1_PIGMENT;
  506.        EXIT
  507.      END_CASE
  508.  
  509.      CASE (PAINTED2_TOKEN)
  510.        New->Type = PAINTED2_PIGMENT;
  511.        EXIT
  512.      END_CASE
  513.  
  514.      CASE (PAINTED3_TOKEN)
  515.        New->Type = PAINTED2_PIGMENT;
  516.        EXIT
  517.      END_CASE
  518.  
  519.      CASE (SPOTTED_TOKEN)
  520.        New->Type = SPOTTED_PIGMENT;
  521.        EXIT
  522.      END_CASE
  523.  
  524.      CASE (WOOD_TOKEN)
  525.        New->Type = WOOD_PIGMENT;
  526.        EXIT
  527.      END_CASE
  528.  
  529.      CASE (GRADIENT_TOKEN)
  530.        New->Type = GRADIENT_PIGMENT;
  531.        Parse_Vector (&(New->Colour_Gradient));
  532.        EXIT
  533.      END_CASE
  534.  
  535.      CASE (RADIAL_TOKEN)
  536.        New->Type = RADIAL_PIGMENT;
  537.      END_CASE
  538.  
  539.      CASE (COLOUR_TOKEN)
  540.        New->Type = COLOUR_PIGMENT;
  541.        New->Colour1 = Create_Colour ();
  542.        Parse_Colour (New->Colour1);
  543.        New->Quick_Colour = *New->Colour1;
  544.        EXIT
  545.      END_CASE
  546.  
  547.      CASE5 (COLOUR_ID_TOKEN, RGB_TOKEN, RGBF_TOKEN, RED_TOKEN, BLUE_TOKEN)
  548.      CASE3 (GREEN_TOKEN, ALPHA_TOKEN, FILTER_TOKEN)
  549.        UNGET
  550.        New->Type = COLOUR_PIGMENT;
  551.        New->Colour1 = Create_Colour ();
  552.        Parse_Colour (New->Colour1);
  553.        New->Quick_Colour = *New->Colour1;
  554.        EXIT
  555.      END_CASE
  556.  
  557.      CASE (CHECKER_TOKEN)
  558.        New->Type = CHECKER_PIGMENT;
  559.        New->Colour_Map = Parse_Colour_List(2);
  560.        EXIT
  561.      END_CASE
  562.  
  563.      CASE (HEXAGON_TOKEN)
  564.        New->Type = HEXAGON_PIGMENT;
  565.        New->Colour_Map = Parse_Colour_List(3);
  566.        EXIT
  567.      END_CASE
  568.  
  569.      CASE (IMAGE_MAP_TOKEN)
  570.        Parse_Image_Map (New);
  571.        EXIT
  572.      END_CASE
  573.  
  574.      OTHERWISE
  575.        UNGET
  576.        EXIT
  577.      END_CASE
  578.    END_EXPECT     /* Concludes pigment_body */
  579.  
  580.    EXPECT         /* Look for pigment_modifier */
  581.      CASE (TURBULENCE_TOKEN)
  582.        Parse_Vector_Float(&(New->Turbulence));
  583.        if ((New->Turbulence.x !=0.0) || (New->Turbulence.y !=0.0) ||
  584.            (New->Turbulence.z !=0.0))
  585.           New->Flags |= HAS_TURB;
  586.      END_CASE
  587.  
  588.      CASE (COLOUR_MAP_TOKEN)
  589.        if (New->Type == CHECKER_PIGMENT ||
  590.            New->Type == HEXAGON_PIGMENT ||
  591.            New->Type == COLOUR_PIGMENT ||
  592.            New->Type == IMAGE_MAP_PIGMENT)
  593.          Warn ("Cannot use color map with this pigment type",1.5);
  594.        New->Colour_Map = Parse_Colour_Map ();
  595.      END_CASE
  596.  
  597.      CASE (QUICK_COLOUR_TOKEN)
  598.        Parse_Colour (&New->Quick_Colour);
  599.      END_CASE
  600.  
  601.      CASE (OCTAVES_TOKEN)
  602.        New->Octaves = (int)Parse_Float();
  603.          if(New->Octaves < 1)
  604.             New->Octaves = 1;
  605.          if(New->Octaves > 10)  /* Avoid DOMAIN errors */
  606.             New->Octaves = 10;
  607.      END_CASE
  608.  
  609.      CASE (OMEGA_TOKEN)
  610.        New->omega = Parse_Float();
  611.      END_CASE
  612.  
  613.      CASE (LAMBDA_TOKEN)
  614.        New->lambda = Parse_Float();
  615.      END_CASE
  616.  
  617.      CASE (FREQUENCY_TOKEN)
  618.        New->Frequency = Parse_Float();
  619.      END_CASE
  620.  
  621.      CASE (PHASE_TOKEN)
  622.        New->Phase = Parse_Float();
  623.      END_CASE
  624.  
  625.      CASE (AGATE_TURB_TOKEN)
  626.        if (Not_In_Default && (New->Type != AGATE_PIGMENT))
  627.           Warn("Attempt to use agate_turb on non-agate",1.9);
  628.        New->Agate_Turb_Scale = Parse_Float();
  629.      END_CASE
  630.  
  631.      CASE (TRANSLATE_TOKEN)
  632.        Parse_Vector (&Local_Vector);
  633.        Translate_Pigment (New, &Local_Vector);
  634.      END_CASE
  635.  
  636.      CASE (ROTATE_TOKEN)
  637.        Parse_Vector (&Local_Vector);
  638.        Rotate_Pigment (New, &Local_Vector);
  639.      END_CASE
  640.  
  641.      CASE (SCALE_TOKEN)
  642.        Parse_Scale_Vector (&Local_Vector);
  643.        Scale_Pigment (New, &Local_Vector);
  644.      END_CASE
  645.  
  646.      CASE (TRANSFORM_TOKEN)
  647.        GET(TRANSFORM_ID_TOKEN)
  648.        Transform_Pigment (New, (TRANSFORM *)Token.Constant_Data);
  649.      END_CASE
  650.  
  651.      OTHERWISE
  652.        UNGET
  653.        EXIT
  654.      END_CASE
  655.    END_EXPECT
  656.  
  657.    if (Not_In_Default && (New->Type == NO_PIGMENT))
  658.      Warn("Pigment type unspecified or not 1st item",1.7);
  659.  
  660.    Parse_End ();
  661.   }
  662.  
  663. static void Parse_Tnormal (Tnormal_Ptr)
  664.   TNORMAL **Tnormal_Ptr;
  665.   {
  666.    TNORMAL *New;
  667.    VECTOR Local_Vector;
  668.  
  669.    Parse_Begin ();
  670.  
  671.    EXPECT            /* Look for [tnormal_id] */
  672.      CASE (TNORMAL_ID_TOKEN)
  673.        Destroy_Tnormal(*Tnormal_Ptr);
  674.        *Tnormal_Ptr = Copy_Tnormal ((TNORMAL *) Token.Constant_Data);
  675.        EXIT
  676.      END_CASE
  677.  
  678.      OTHERWISE
  679.        UNGET
  680.        EXIT
  681.      END_CASE
  682.    END_EXPECT    /* End [tnormal_id] */
  683.  
  684.    if (*Tnormal_Ptr == NULL)
  685.      if ((Default_Texture->Tnormal) != NULL)
  686.        *Tnormal_Ptr = Copy_Tnormal ((Default_Texture->Tnormal));
  687.      else
  688.        *Tnormal_Ptr = Create_Tnormal ();
  689.  
  690.    New = *Tnormal_Ptr;
  691.  
  692.    EXPECT  /* [tnormal_body] */
  693.      CASE (BUMPS_TOKEN)
  694.        New->Type = BUMPS;
  695.        New->Amount = Parse_Float ();
  696.        EXIT
  697.      END_CASE
  698.  
  699.      CASE (BUMPY1_TOKEN)
  700.        New->Type = BUMPY1;
  701.        New->Amount = Parse_Float ();
  702.        EXIT
  703.      END_CASE
  704.  
  705.      CASE (BUMPY2_TOKEN)
  706.        New->Type = BUMPY2;
  707.        New->Amount = Parse_Float ();
  708.        EXIT
  709.      END_CASE
  710.  
  711.      CASE (BUMPY3_TOKEN)
  712.        New->Type = BUMPY3;
  713.        New->Amount = Parse_Float ();
  714.        EXIT
  715.      END_CASE
  716.  
  717.      CASE (DENTS_TOKEN)
  718.        New->Type = DENTS;
  719.        New->Amount = Parse_Float ();
  720.        EXIT
  721.      END_CASE
  722.  
  723.      CASE (RIPPLES_TOKEN)
  724.        New->Type = RIPPLES;
  725.        New->Amount = Parse_Float ();
  726.        EXIT
  727.      END_CASE
  728.  
  729.      CASE (WAVES_TOKEN)
  730.        New->Type = WAVES;
  731.        New->Amount = Parse_Float ();
  732.        EXIT
  733.      END_CASE
  734.  
  735.      CASE (WRINKLES_TOKEN)
  736.        New->Type = WRINKLES;
  737.        New->Amount = Parse_Float ();
  738.        EXIT
  739.      END_CASE
  740.  
  741.      CASE (BUMP_MAP_TOKEN)
  742.        Parse_Bump_Map (New);
  743.        EXIT
  744.      END_CASE
  745.  
  746.      OTHERWISE
  747.        if (Not_In_Default && (New->Type == NO_NORMAL))
  748.          Parse_Error_Str("normal body");
  749.        UNGET
  750.        EXIT
  751.      END_CASE
  752.    END_EXPECT    /* End of tnormal_body */
  753.  
  754.    EXPECT        /* Look for tnormal_mods */
  755.  
  756.      CASE (TURBULENCE_TOKEN)
  757.        Parse_Vector_Float(&(New->Turbulence));
  758.        if ((New->Turbulence.x !=0.0) || (New->Turbulence.y !=0.0) ||
  759.            (New->Turbulence.z !=0.0))
  760.           New->Flags |= HAS_TURB;
  761.      END_CASE
  762.  
  763.      CASE (OCTAVES_TOKEN)
  764.        New->Octaves = (int)Parse_Float();
  765.      END_CASE
  766.  
  767.      CASE (OMEGA_TOKEN)
  768.        New->omega = Parse_Float();
  769.      END_CASE
  770.  
  771.      CASE (LAMBDA_TOKEN)
  772.        New->lambda = Parse_Float();
  773.      END_CASE
  774.  
  775.      CASE (FREQUENCY_TOKEN)
  776.        if (!(New->Type == RIPPLES || New->Type == WAVES))
  777.          if (Language_Version >= 1.5)
  778.            Warn ("Cannot use frequency with this normal",1.5);
  779.        New->Frequency = Parse_Float();
  780.      END_CASE
  781.  
  782.      CASE (PHASE_TOKEN)
  783.        if (!(New->Type == RIPPLES || New->Type == WAVES))
  784.          if (Language_Version >= 1.5)
  785.             Warn ("Cannot use phase with this normal",1.5);
  786.        New->Phase = Parse_Float();
  787.      END_CASE
  788.  
  789.      CASE (TRANSLATE_TOKEN)
  790.        Parse_Vector (&Local_Vector);
  791.        Translate_Tnormal (New, &Local_Vector);
  792.      END_CASE
  793.  
  794.      CASE (ROTATE_TOKEN)
  795.        Parse_Vector (&Local_Vector);
  796.        Rotate_Tnormal (New, &Local_Vector);
  797.      END_CASE
  798.  
  799.      CASE (SCALE_TOKEN)
  800.        Parse_Scale_Vector (&Local_Vector);
  801.        Scale_Tnormal (New, &Local_Vector);
  802.      END_CASE
  803.  
  804.      CASE (TRANSFORM_TOKEN)
  805.        GET(TRANSFORM_ID_TOKEN)
  806.        Transform_Tnormal (New, (TRANSFORM *)Token.Constant_Data);
  807.      END_CASE
  808.  
  809.      OTHERWISE
  810.        UNGET
  811.        EXIT
  812.      END_CASE
  813.    END_EXPECT    /* End of tnormal_mods */
  814.  
  815.    Parse_End ();
  816.   }
  817.  
  818. static void Parse_Finish (Finish_Ptr)
  819.   FINISH **Finish_Ptr;
  820.   {
  821.    FINISH *New;
  822.  
  823.    Parse_Begin ();
  824.  
  825.    EXPECT        /* Look for zero or one finish_id */
  826.      CASE (FINISH_ID_TOKEN)
  827.        Destroy_Finish(*Finish_Ptr);
  828.        *Finish_Ptr = Copy_Finish ((FINISH *) Token.Constant_Data);
  829.        EXIT
  830.      END_CASE
  831.  
  832.      OTHERWISE
  833.        UNGET
  834.        EXIT
  835.      END_CASE
  836.    END_EXPECT    /* End finish_id */
  837.  
  838.    New = *Finish_Ptr;
  839.  
  840.    EXPECT        /* Look for zero or more finish_body */
  841.      CASE (AMBIENT_TOKEN)
  842.        New->Ambient = Parse_Float ();
  843.      END_CASE
  844.  
  845.      CASE (BRILLIANCE_TOKEN)
  846.        New->Brilliance = Parse_Float ();
  847.      END_CASE
  848.  
  849.      CASE (DIFFUSE_TOKEN)
  850.        New->Diffuse = Parse_Float ();
  851.      END_CASE
  852.  
  853.      CASE (REFLECTION_TOKEN)
  854.        New->Reflection = Parse_Float ();
  855.      END_CASE
  856.  
  857.      CASE (REFRACTION_TOKEN)
  858.        New->Refraction = Parse_Float ();
  859.      END_CASE
  860.  
  861.      CASE (IOR_TOKEN)
  862.        New->Index_Of_Refraction = Parse_Float ();
  863.      END_CASE
  864.  
  865.      CASE (PHONG_TOKEN)
  866.        New->Phong = Parse_Float ();
  867.      END_CASE
  868.  
  869.      CASE (PHONG_SIZE_TOKEN)
  870.        New->Phong_Size = Parse_Float ();
  871. /*     if (New->Phong_Size < 1.0)
  872.            New->Phong_Size = 1.0;
  873.        if (New->Phong_Size > 100)
  874.            New->Phong_Size = 100; */
  875.      END_CASE
  876.  
  877.      CASE (SPECULAR_TOKEN)
  878.        New->Specular = Parse_Float ();
  879.      END_CASE
  880.  
  881.      CASE (ROUGHNESS_TOKEN)
  882.        New->Roughness = Parse_Float ();
  883. /*     if (New->Roughness > 1.0)
  884.            New->Roughness = 1.0;
  885.        if (New->Roughness < 0.001)
  886.            New->Roughness = 0.001;  */
  887.        New->Roughness = 1.0/New->Roughness; /* CEY 12/92 */
  888.      END_CASE
  889.  
  890.      CASE (METALLIC_TOKEN)
  891.        New->Metallic_Flag = TRUE;
  892.      END_CASE
  893.  
  894.      CASE (CRAND_TOKEN)
  895.        New->Crand = Parse_Float();
  896.      END_CASE
  897.  
  898.      OTHERWISE
  899.        UNGET
  900.        EXIT
  901.      END_CASE
  902.    END_EXPECT    /* End of finish_body */
  903.  
  904.    EXPECT        /* Look for finish_mods */
  905.  
  906. /*   CASE none implemented
  907.      END_CASE     */
  908.  
  909.      OTHERWISE
  910.        UNGET
  911.        EXIT
  912.      END_CASE
  913.    END_EXPECT    /* End of finish_mods */
  914.  
  915.    Parse_End ();
  916.   }
  917.  
  918. #define ADD_TNORMAL if (Tnormal == NULL) {if ((Default_Texture->Tnormal) != NULL) \
  919.  Tnormal = Copy_Tnormal ((Default_Texture->Tnormal)); else Tnormal = Create_Tnormal ();\
  920.  Texture->Tnormal=Tnormal;};
  921.  
  922. static
  923. TEXTURE *Parse_Texture ()
  924.   {
  925.    VECTOR Local_Vector;
  926.    TEXTURE *Texture, *Local_Texture;
  927.    PIGMENT *Pigment;
  928.    TNORMAL *Tnormal;
  929.    FINISH *Finish;
  930.  
  931.    Parse_Begin ();
  932.  
  933.    EXPECT                      /* Look for texture_body */
  934.      CASE (TILES_TOKEN)
  935.        Parse_Begin ();
  936.  
  937.        Texture = (TEXTURE *)Create_Tiles_Texture ();
  938.  
  939.        EXPECT
  940.          CASE (TEXTURE_TOKEN)
  941.            Local_Texture = Parse_Texture ();
  942.            Link_Textures(&(((TILES *)Texture)->Tile1),Local_Texture);
  943.          END_CASE
  944.  
  945.          OTHERWISE
  946.            UNGET
  947.            EXIT
  948.          END_CASE
  949.        END_EXPECT
  950.  
  951.        GET (TILE2_TOKEN);
  952.  
  953.        EXPECT
  954.          CASE (TEXTURE_TOKEN)
  955.            Local_Texture = Parse_Texture ();
  956.            Link_Textures(&(((TILES *)Texture)->Tile2),Local_Texture);
  957.          END_CASE
  958.  
  959.          OTHERWISE
  960.            UNGET
  961.            EXIT
  962.          END_CASE
  963.        END_EXPECT
  964.        Parse_End ();
  965.        EXIT
  966.      END_CASE
  967.  
  968.      CASE (MATERIAL_MAP_TOKEN)
  969.        Parse_Begin ();
  970.  
  971.        Texture = (TEXTURE *)Create_Material_Texture ();
  972.  
  973.        ((MATERIAL *)Texture)->Image = Parse_Image(MATERIAL_FILE);
  974.        ((MATERIAL *)Texture)->Image->Use_Colour_Flag = FALSE;
  975.  
  976.        EXPECT
  977.          CASE (ONCE_TOKEN)
  978.            ((MATERIAL *)Texture)->Image->Once_Flag=TRUE;
  979.          END_CASE
  980.  
  981.          CASE (INTERPOLATE_TOKEN)
  982.            ((MATERIAL *)Texture)->Image->Interpolation_Type=(int)Parse_Float();
  983.          END_CASE
  984.  
  985.          CASE (MAP_TYPE_TOKEN)
  986.            ((MATERIAL *)Texture)->Image->Map_Type = (int) Parse_Float ();
  987.          END_CASE
  988.  
  989.          OTHERWISE
  990.            UNGET
  991.            EXIT
  992.          END_CASE
  993.        END_EXPECT
  994.  
  995.        GET (TEXTURE_TOKEN)                /* First material */
  996.        ((MATERIAL *)Texture)->Materials = Local_Texture = Parse_Texture ();
  997.        ((MATERIAL *)Texture)->Num_Of_Mats++;
  998.  
  999.        EXPECT                             /* Subsequent materials */
  1000.          CASE (TEXTURE_TOKEN)
  1001.            Local_Texture->Next_Material = Parse_Texture ();
  1002.            Local_Texture = Local_Texture->Next_Material;
  1003.            ((MATERIAL *)Texture)->Num_Of_Mats++;
  1004.          END_CASE
  1005.  
  1006.          OTHERWISE
  1007.            UNGET
  1008.            EXIT
  1009.          END_CASE
  1010.        END_EXPECT
  1011.        Parse_End ();
  1012.        EXIT
  1013.      END_CASE
  1014.      
  1015.      CASE (TEXTURE_ID_TOKEN)
  1016.        Texture = Copy_Textures((TEXTURE *) Token.Constant_Data);
  1017.        EXIT
  1018.      END_CASE
  1019.  
  1020.      OTHERWISE
  1021.        UNGET
  1022.        Texture = Copy_Textures (Default_Texture);
  1023.        EXIT
  1024.      END_CASE
  1025.    END_EXPECT
  1026.    
  1027.    /* Look for [pnf_texture] */
  1028.    if (Texture->Type == PNF_TEXTURE)
  1029.      {
  1030.        EXPECT   /* Look for [pnf_ids] */
  1031.          CASE (PIGMENT_ID_TOKEN)
  1032.            Destroy_Pigment(Texture->Pigment);
  1033.            Texture->Pigment = Copy_Pigment ((PIGMENT *) Token.Constant_Data);
  1034.          END_CASE
  1035.  
  1036.          CASE (TNORMAL_ID_TOKEN)
  1037.            Destroy_Tnormal(Texture->Tnormal);
  1038.            Texture->Tnormal = Copy_Tnormal ((TNORMAL *) Token.Constant_Data);
  1039.          END_CASE
  1040.  
  1041.          CASE (FINISH_ID_TOKEN)
  1042.            Destroy_Finish(Texture->Finish);
  1043.            Texture->Finish = Copy_Finish ((FINISH *) Token.Constant_Data);
  1044.          END_CASE
  1045.  
  1046.          OTHERWISE
  1047.            UNGET
  1048.            EXIT
  1049.          END_CASE
  1050.        END_EXPECT
  1051.  
  1052.        Pigment = Texture->Pigment;
  1053.        Tnormal = Texture->Tnormal;
  1054.        Finish  = Texture->Finish;
  1055.  
  1056.        EXPECT
  1057.          CASE (PIGMENT_TOKEN)
  1058.            Parse_Pigment ( &(Texture->Pigment) );
  1059.          END_CASE
  1060.  
  1061.          CASE (TNORMAL_TOKEN)
  1062.            Parse_Tnormal ( &(Texture->Tnormal) );
  1063.          END_CASE
  1064.  
  1065.          CASE (FINISH_TOKEN)
  1066.            Parse_Finish ( &(Texture->Finish) );
  1067.          END_CASE
  1068.  
  1069. /***********************************************************************
  1070.  PIGMENT STUFF OUTSIDE PIGMENT{}
  1071. ***********************************************************************/
  1072.          CASE (AGATE_TOKEN)
  1073.            Warn_State(Token.Token_Id, PIGMENT_TOKEN);           
  1074.            Pigment->Type = AGATE_PIGMENT;
  1075.          END_CASE
  1076.  
  1077.          CASE (BOZO_TOKEN)
  1078.            Warn_State(Token.Token_Id, PIGMENT_TOKEN);           
  1079.            Pigment->Type = BOZO_PIGMENT;
  1080.          END_CASE
  1081.  
  1082.          CASE (GRANITE_TOKEN)
  1083.            Warn_State(Token.Token_Id, PIGMENT_TOKEN);           
  1084.            Pigment->Type = GRANITE_PIGMENT;
  1085.          END_CASE
  1086.  
  1087.          CASE (LEOPARD_TOKEN)
  1088.            Warn_State(Token.Token_Id, PIGMENT_TOKEN);           
  1089.            Pigment->Type = LEOPARD_PIGMENT;
  1090.          END_CASE
  1091.  
  1092.          CASE (MARBLE_TOKEN)
  1093.            Warn_State(Token.Token_Id, PIGMENT_TOKEN);           
  1094.            Pigment->Type = MARBLE_PIGMENT;
  1095.          END_CASE
  1096.  
  1097.          CASE (MANDEL_TOKEN)
  1098.            Warn_State(Token.Token_Id, PIGMENT_TOKEN);           
  1099.            Pigment->Type = MANDEL_PIGMENT;
  1100.            Pigment->Iterations = (int)Parse_Float();
  1101.          END_CASE
  1102.  
  1103.          CASE (ONION_TOKEN)
  1104.            Warn_State(Token.Token_Id, PIGMENT_TOKEN);           
  1105.            Pigment->Type = ONION_PIGMENT;
  1106.          END_CASE
  1107.  
  1108.          CASE (PAINTED1_TOKEN)
  1109.            Warn_State(Token.Token_Id, PIGMENT_TOKEN);           
  1110.            Pigment->Type = PAINTED1_PIGMENT;
  1111.          END_CASE
  1112.  
  1113.          CASE (PAINTED2_TOKEN)
  1114.            Warn_State(Token.Token_Id, PIGMENT_TOKEN);           
  1115.            Pigment->Type = PAINTED2_PIGMENT;
  1116.          END_CASE
  1117.  
  1118.          CASE (PAINTED3_TOKEN)
  1119.            Warn_State(Token.Token_Id, PIGMENT_TOKEN);           
  1120.            Pigment->Type = PAINTED2_PIGMENT;
  1121.          END_CASE
  1122.  
  1123.          CASE (SPOTTED_TOKEN)
  1124.            Warn_State(Token.Token_Id, PIGMENT_TOKEN);           
  1125.            Pigment->Type = SPOTTED_PIGMENT;
  1126.          END_CASE
  1127.  
  1128.          CASE (WOOD_TOKEN)
  1129.            Warn_State(Token.Token_Id, PIGMENT_TOKEN);           
  1130.            Pigment->Type = WOOD_PIGMENT;
  1131.          END_CASE
  1132.  
  1133.          CASE (GRADIENT_TOKEN)
  1134.            Warn_State(Token.Token_Id, PIGMENT_TOKEN);           
  1135.            Pigment->Type = GRADIENT_PIGMENT;
  1136.            Parse_Vector (&(Pigment->Colour_Gradient));
  1137.          END_CASE
  1138.  
  1139.          CASE (COLOUR_TOKEN)
  1140.            Warn_State(Token.Token_Id, PIGMENT_TOKEN);           
  1141.            Pigment->Type = COLOUR_PIGMENT;
  1142.            Pigment->Colour1 = Create_Colour ();
  1143.            Parse_Colour (Pigment->Colour1);
  1144.            Pigment->Quick_Colour = *Pigment->Colour1;
  1145.          END_CASE
  1146.  
  1147.          CASE5 (COLOUR_ID_TOKEN, RGB_TOKEN, RGBF_TOKEN, RED_TOKEN, BLUE_TOKEN)
  1148.          CASE3 (GREEN_TOKEN, ALPHA_TOKEN, FILTER_TOKEN)
  1149.            Warn_State(Token.Token_Id, PIGMENT_TOKEN);           
  1150.            UNGET
  1151.            Pigment->Type = COLOUR_PIGMENT;
  1152.            Pigment->Colour1 = Create_Colour ();
  1153.            Parse_Colour (Pigment->Colour1);
  1154.            Pigment->Quick_Colour = *Pigment->Colour1;
  1155.          END_CASE
  1156.  
  1157.          CASE (CHECKER_TOKEN)
  1158.            Warn_State(Token.Token_Id, PIGMENT_TOKEN);           
  1159.            Pigment->Type = CHECKER_PIGMENT;
  1160.            Pigment->Colour_Map = Parse_Colour_List(2);
  1161.          END_CASE
  1162.  
  1163.          CASE (HEXAGON_TOKEN)
  1164.            Warn_State(Token.Token_Id, PIGMENT_TOKEN);           
  1165.            Pigment->Type = HEXAGON_PIGMENT;
  1166.            Pigment->Colour_Map = Parse_Colour_List(3);
  1167.          END_CASE
  1168.  
  1169.          CASE (IMAGE_MAP_TOKEN)
  1170.            Warn_State(Token.Token_Id, PIGMENT_TOKEN);           
  1171.            Parse_Image_Map (Pigment);
  1172.          END_CASE
  1173.  
  1174.          CASE (TURBULENCE_TOKEN)
  1175.            Parse_Vector_Float(&(Pigment->Turbulence));
  1176.            if ((Pigment->Turbulence.x !=0.0) ||
  1177.                (Pigment->Turbulence.y !=0.0) ||
  1178.                (Pigment->Turbulence.z !=0.0))
  1179.              Pigment->Flags |= HAS_TURB;
  1180.          END_CASE
  1181.  
  1182.          CASE (COLOUR_MAP_TOKEN)
  1183.            Warn_State(Token.Token_Id, PIGMENT_TOKEN);
  1184.            if (Pigment->Type == CHECKER_PIGMENT ||
  1185.                Pigment->Type == HEXAGON_PIGMENT ||
  1186.                Pigment->Type == COLOUR_PIGMENT ||
  1187.                Pigment->Type == IMAGE_MAP_PIGMENT)
  1188.              Warn ("Cannot use color map with this pigment type",1.5);
  1189.            Pigment->Colour_Map = Parse_Colour_Map ();
  1190.          END_CASE
  1191.  
  1192.          CASE (QUICK_COLOUR_TOKEN)
  1193.            Warn_State(Token.Token_Id, PIGMENT_TOKEN);           
  1194.            Parse_Colour (&Pigment->Quick_Colour);
  1195.          END_CASE
  1196.  
  1197.          CASE (OCTAVES_TOKEN)
  1198.            Pigment->Octaves = (int)Parse_Float();
  1199.              if(Pigment->Octaves < 1)
  1200.                 Pigment->Octaves = 1;
  1201.              if(Pigment->Octaves > 10)  /* Avoid DOMAIN errors */
  1202.                 Pigment->Octaves = 10;
  1203.          END_CASE
  1204.  
  1205.          CASE (OMEGA_TOKEN)
  1206.            Pigment->omega = Parse_Float();
  1207.          END_CASE
  1208.  
  1209.          CASE (LAMBDA_TOKEN)
  1210.            Pigment->lambda = Parse_Float();
  1211.          END_CASE
  1212.  
  1213. /***********************************************************************
  1214. TNORMAL STUFF OUTSIDE NORMAL{}
  1215. ***********************************************************************/
  1216.          CASE (BUMPS_TOKEN)
  1217.            Warn_State(Token.Token_Id, TNORMAL_TOKEN);           
  1218.            ADD_TNORMAL
  1219.            Tnormal->Type = BUMPS;
  1220.            Tnormal->Amount = Parse_Float ();
  1221.          END_CASE
  1222.  
  1223.          CASE (BUMPY1_TOKEN)
  1224.            Warn_State(Token.Token_Id, TNORMAL_TOKEN);           
  1225.            ADD_TNORMAL
  1226.            Tnormal->Type = BUMPY1;
  1227.            Tnormal->Amount = Parse_Float ();
  1228.          END_CASE
  1229.  
  1230.          CASE (BUMPY2_TOKEN)
  1231.            Warn_State(Token.Token_Id, TNORMAL_TOKEN);           
  1232.            ADD_TNORMAL
  1233.            Tnormal->Type = BUMPY2;
  1234.            Tnormal->Amount = Parse_Float ();
  1235.          END_CASE
  1236.  
  1237.          CASE (BUMPY3_TOKEN)
  1238.            Warn_State(Token.Token_Id, TNORMAL_TOKEN);           
  1239.            ADD_TNORMAL
  1240.            Tnormal->Type = BUMPY3;
  1241.            Tnormal->Amount = Parse_Float ();
  1242.          END_CASE
  1243.  
  1244.          CASE (DENTS_TOKEN)
  1245.            Warn_State(Token.Token_Id, TNORMAL_TOKEN);           
  1246.            ADD_TNORMAL
  1247.            Tnormal->Type = DENTS;
  1248.            Tnormal->Amount = Parse_Float ();
  1249.          END_CASE
  1250.  
  1251.          CASE (RIPPLES_TOKEN)
  1252.            Warn_State(Token.Token_Id, TNORMAL_TOKEN);           
  1253.            ADD_TNORMAL
  1254.            Tnormal->Type = RIPPLES;
  1255.            Tnormal->Amount = Parse_Float ();
  1256.          END_CASE
  1257.  
  1258.          CASE (WAVES_TOKEN)
  1259.            Warn_State(Token.Token_Id, TNORMAL_TOKEN);           
  1260.            ADD_TNORMAL
  1261.            Tnormal->Type = WAVES;
  1262.            Tnormal->Amount = Parse_Float ();
  1263.          END_CASE
  1264.  
  1265.          CASE (WRINKLES_TOKEN)
  1266.            Warn_State(Token.Token_Id, TNORMAL_TOKEN);           
  1267.            ADD_TNORMAL
  1268.            Tnormal->Type = WRINKLES;
  1269.            Tnormal->Amount = Parse_Float ();
  1270.          END_CASE
  1271.  
  1272.          CASE (BUMP_MAP_TOKEN)
  1273.            Warn_State(Token.Token_Id, TNORMAL_TOKEN);           
  1274.            ADD_TNORMAL
  1275.            Parse_Bump_Map (Tnormal);
  1276.          END_CASE
  1277.  
  1278.          CASE (FREQUENCY_TOKEN)
  1279.            Warn_State(Token.Token_Id, TNORMAL_TOKEN);           
  1280.            ADD_TNORMAL
  1281.            if (!(Tnormal->Type == RIPPLES || Tnormal->Type == WAVES))
  1282.              if (Language_Version >= 1.5)
  1283.                Warn ("Cannot use frequency with this normal",1.5);
  1284.            Tnormal->Frequency = Parse_Float();
  1285.          END_CASE
  1286.  
  1287.          CASE (PHASE_TOKEN)
  1288.            Warn_State(Token.Token_Id, TNORMAL_TOKEN);           
  1289.            ADD_TNORMAL
  1290.            if (!(Tnormal->Type == RIPPLES || Tnormal->Type == WAVES))
  1291.              if (Language_Version >= 1.5)
  1292.                Warn ("Cannot use phase with this normal",1.5);
  1293.            Tnormal->Phase = Parse_Float();
  1294.          END_CASE
  1295.  
  1296.  
  1297. /***********************************************************************
  1298. FINISH STUFF OUTSIDE FINISH{}
  1299. ***********************************************************************/
  1300.          CASE (AMBIENT_TOKEN)
  1301.            Warn_State(Token.Token_Id, FINISH_TOKEN);           
  1302.            Finish->Ambient = Parse_Float ();
  1303.          END_CASE
  1304.  
  1305.          CASE (BRILLIANCE_TOKEN)
  1306.            Warn_State(Token.Token_Id, FINISH_TOKEN);           
  1307.            Finish->Brilliance = Parse_Float ();
  1308.          END_CASE
  1309.  
  1310.          CASE (DIFFUSE_TOKEN)
  1311.            Warn_State(Token.Token_Id, FINISH_TOKEN);           
  1312.            Finish->Diffuse = Parse_Float ();
  1313.          END_CASE
  1314.  
  1315.          CASE (REFLECTION_TOKEN)
  1316.            Warn_State(Token.Token_Id, FINISH_TOKEN);           
  1317.            Finish->Reflection = Parse_Float ();
  1318.          END_CASE
  1319.  
  1320.          CASE (REFRACTION_TOKEN)
  1321.            Warn_State(Token.Token_Id, FINISH_TOKEN);           
  1322.            Finish->Refraction = Parse_Float ();
  1323.          END_CASE
  1324.  
  1325.          CASE (IOR_TOKEN)
  1326.            Warn_State(Token.Token_Id, FINISH_TOKEN);           
  1327.            Finish->Index_Of_Refraction = Parse_Float ();
  1328.          END_CASE
  1329.  
  1330.          CASE (PHONG_TOKEN)
  1331.            Warn_State(Token.Token_Id, FINISH_TOKEN);           
  1332.            Finish->Phong = Parse_Float ();
  1333.          END_CASE
  1334.  
  1335.          CASE (PHONG_SIZE_TOKEN)
  1336.            Warn_State(Token.Token_Id, FINISH_TOKEN);           
  1337.            Finish->Phong_Size = Parse_Float ();
  1338.     /*     if (Finish->Phong_Size < 1.0)
  1339.                Finish->Phong_Size = 1.0;
  1340.            if (Finish->Phong_Size > 100)
  1341.                Finish->Phong_Size = 100; */
  1342.          END_CASE
  1343.  
  1344.          CASE (SPECULAR_TOKEN)
  1345.            Warn_State(Token.Token_Id, FINISH_TOKEN);           
  1346.            Finish->Specular = Parse_Float ();
  1347.          END_CASE
  1348.  
  1349.          CASE (ROUGHNESS_TOKEN)
  1350.            Warn_State(Token.Token_Id, FINISH_TOKEN);           
  1351.            Finish->Roughness = Parse_Float ();
  1352.     /*     if (Finish->Roughness > 1.0)
  1353.                Finish->Roughness = 1.0;
  1354.            if (Finish->Roughness < 0.001)
  1355.                Finish->Roughness = 0.001;  */
  1356.            Finish->Roughness = 1.0/Finish->Roughness; /* CEY 12/92 */
  1357.          END_CASE
  1358.  
  1359.          CASE (METALLIC_TOKEN)
  1360.            Warn_State(Token.Token_Id, FINISH_TOKEN);           
  1361.            Finish->Metallic_Flag = TRUE;
  1362.          END_CASE
  1363.  
  1364.          CASE (CRAND_TOKEN)
  1365.            Warn_State(Token.Token_Id, FINISH_TOKEN);           
  1366.            Finish->Crand = Parse_Float();
  1367.          END_CASE
  1368.  
  1369.          CASE_FLOAT
  1370.            Finish->Crand = Parse_Float();
  1371.            Warn("Should use crand keyword in finish statement.",1.5);           
  1372.          END_CASE
  1373.  
  1374.          CASE (TRANSLATE_TOKEN)
  1375.            Parse_Vector (&Local_Vector);
  1376.            Translate_Textures (Texture, &Local_Vector);
  1377.          END_CASE
  1378.  
  1379.          CASE (ROTATE_TOKEN)
  1380.            Parse_Vector (&Local_Vector);
  1381.            Rotate_Textures (Texture, &Local_Vector);
  1382.          END_CASE
  1383.  
  1384.          CASE (SCALE_TOKEN)
  1385.            Parse_Scale_Vector (&Local_Vector);
  1386.            Scale_Textures (Texture, &Local_Vector);
  1387.          END_CASE
  1388.  
  1389.          CASE (TRANSFORM_TOKEN)
  1390.            GET(TRANSFORM_ID_TOKEN)
  1391.            Transform_Textures (Texture, (TRANSFORM *)Token.Constant_Data);
  1392.          END_CASE
  1393.  
  1394.          CASE (TEXTURE_ID_TOKEN)
  1395.            Warn("Texture identifier overwriting previous values.",0);
  1396.            Destroy_Textures(Texture);
  1397.            Texture = Copy_Textures((TEXTURE *) Token.Constant_Data);
  1398.            Pigment = Texture->Pigment;
  1399.            Tnormal = Texture->Tnormal;
  1400.            Finish  = Texture->Finish;
  1401.          END_CASE
  1402.  
  1403.          OTHERWISE
  1404.            UNGET
  1405.            EXIT
  1406.          END_CASE
  1407. /***********************************************************************/
  1408.  
  1409.        END_EXPECT
  1410.  
  1411.        if (Not_In_Default && (Texture->Pigment->Type == NO_PIGMENT) &&
  1412.            !(Language_Version < 1.5))
  1413.          Parse_Error(PIGMENT_ID_TOKEN);
  1414.  
  1415.      }
  1416.  
  1417.    EXPECT            /* Look for texture_mods */
  1418.      CASE (TRANSLATE_TOKEN)
  1419.        Parse_Vector (&Local_Vector);
  1420.        Translate_Textures (Texture, &Local_Vector);
  1421.      END_CASE
  1422.  
  1423.      CASE (ROTATE_TOKEN)
  1424.        Parse_Vector (&Local_Vector);
  1425.        Rotate_Textures (Texture, &Local_Vector);
  1426.      END_CASE
  1427.  
  1428.      CASE (SCALE_TOKEN)
  1429.        Parse_Scale_Vector (&Local_Vector);
  1430.        Scale_Textures (Texture, &Local_Vector);
  1431.      END_CASE
  1432.  
  1433.      CASE (TRANSFORM_TOKEN)
  1434.        GET(TRANSFORM_ID_TOKEN)
  1435.        Transform_Textures (Texture, (TRANSFORM *)Token.Constant_Data);
  1436.      END_CASE
  1437.  
  1438.      OTHERWISE
  1439.        UNGET
  1440.        EXIT
  1441.      END_CASE
  1442.    END_EXPECT        /* End of texture */
  1443.  
  1444.    Parse_End ();
  1445.    return (Texture);
  1446.   }
  1447.  
  1448. static
  1449. OBJECT *Parse_Bound_Clip ()
  1450.   {
  1451.    VECTOR Local_Vector;
  1452.    OBJECT *First, *Current, *Prev;
  1453.  
  1454.    First = Prev = NULL;
  1455.  
  1456.    while ((Current = Parse_Object ()) != NULL)
  1457.      {
  1458.       if (Current->Type & (TEXTURED_OBJECT+PATCH_OBJECT))
  1459.         Error ("Illegal texture or patch in clip or bound");
  1460.       if (First == NULL)
  1461.         First = Current;
  1462.       if (Prev != NULL)
  1463.         Prev->Sibling = Current;
  1464.       Prev = Current;
  1465.      }
  1466.  
  1467.    EXPECT
  1468.      CASE (TRANSLATE_TOKEN)
  1469.        Parse_Vector (&Local_Vector);
  1470.        for (Current = First;
  1471.             Current != NULL;
  1472.             Current = Current->Sibling)
  1473.          Translate_Object (Current, &Local_Vector);
  1474.      END_CASE
  1475.  
  1476.      CASE (ROTATE_TOKEN)
  1477.        Parse_Vector (&Local_Vector);
  1478.        for (Current = First;
  1479.             Current != NULL;
  1480.             Current = Current->Sibling)
  1481.          Rotate_Object (Current, &Local_Vector);
  1482.      END_CASE
  1483.  
  1484.      CASE (SCALE_TOKEN)
  1485.        Parse_Scale_Vector (&Local_Vector);
  1486.        for (Current = First;
  1487.             Current != NULL;
  1488.             Current = Current->Sibling)
  1489.          Scale_Object (Current, &Local_Vector);
  1490.      END_CASE
  1491.  
  1492.      CASE (TRANSFORM_TOKEN)
  1493.        GET(TRANSFORM_ID_TOKEN)
  1494.        for (Current = First;
  1495.             Current != NULL;
  1496.             Current = Current->Sibling)
  1497.        Transform_Object (Current, (TRANSFORM *)Token.Constant_Data);
  1498.      END_CASE
  1499.  
  1500.      OTHERWISE
  1501.        UNGET
  1502.        EXIT
  1503.      END_CASE
  1504.    END_EXPECT
  1505.  
  1506.    return (First);
  1507.   }
  1508.  
  1509. static void Parse_Object_Mods (Object)
  1510.   OBJECT *Object;
  1511.   {
  1512.    VECTOR Local_Vector;
  1513.    TEXTURE *Local_Texture;
  1514.    OBJECT *Temp1_Object;
  1515.    OBJECT *Temp2_Object;
  1516.    COLOUR Local_Colour;
  1517.    DBL Temp_Water_Level;
  1518.  
  1519.    EXPECT
  1520.      CASE (COLOUR_TOKEN)
  1521.        Parse_Colour (&Local_Colour);
  1522.        if (Language_Version < 1.5)
  1523.          if (Object->Texture != NULL) 
  1524.            if (Object->Texture->Type == PNF_TEXTURE)
  1525.              {
  1526.               Object->Texture->Pigment->Quick_Colour = Local_Colour;
  1527.               break;  /* acts like END_CASE */
  1528.              }
  1529.        Warn("Quick color belongs in texture.  Color ignored.",0.0);
  1530.      END_CASE
  1531.  
  1532.      CASE (TRANSLATE_TOKEN)
  1533.        Parse_Vector (&Local_Vector);
  1534.        Translate_Object (Object, &Local_Vector);
  1535.      END_CASE
  1536.  
  1537.      CASE (ROTATE_TOKEN)
  1538.        Parse_Vector (&Local_Vector);
  1539.        Rotate_Object (Object, &Local_Vector);
  1540.      END_CASE
  1541.  
  1542.      CASE (SCALE_TOKEN)
  1543.        Parse_Scale_Vector (&Local_Vector);
  1544.        Scale_Object (Object, &Local_Vector);
  1545.      END_CASE
  1546.  
  1547.      CASE (TRANSFORM_TOKEN)
  1548.        GET(TRANSFORM_ID_TOKEN)
  1549.        Transform_Object (Object, (TRANSFORM *)Token.Constant_Data);
  1550.      END_CASE
  1551.  
  1552.      CASE (BOUNDED_BY_TOKEN)
  1553.        Parse_Begin ();
  1554.        if (Object->Bound != NULL)
  1555.          if (Object->Clip == Object->Bound)
  1556.            Error ("Cannot add bounds after linking bounds and clips");
  1557.  
  1558.        EXPECT
  1559.          CASE (CLIPPED_BY_TOKEN)
  1560.            if (Object->Bound != NULL)
  1561.              Error ("Cannot link clips with previous bounds");
  1562.            Object->Bound = Object->Clip;
  1563.            EXIT
  1564.          END_CASE
  1565.  
  1566.          OTHERWISE
  1567.            UNGET
  1568.            Temp1_Object = Temp2_Object = Parse_Bound_Clip ();
  1569.            while (Temp2_Object->Sibling != NULL)
  1570.              Temp2_Object = Temp2_Object->Sibling;
  1571.            Temp2_Object->Sibling = Object->Bound;
  1572.            Object->Bound = Temp1_Object;
  1573.            EXIT
  1574.          END_CASE
  1575.        END_EXPECT
  1576.        
  1577.        Parse_End ();
  1578.      END_CASE
  1579.  
  1580.      CASE (CLIPPED_BY_TOKEN)
  1581.        Parse_Begin ();
  1582.        if (Object->Clip != NULL)
  1583.          if (Object->Clip == Object->Bound)
  1584.            Error ("Cannot add clips after linking bounds and clips");
  1585.  
  1586.        EXPECT
  1587.          CASE (BOUNDED_BY_TOKEN)
  1588.            if (Object->Clip != NULL)
  1589.              Error ("Cannot link bounds with previous clips");
  1590.            Object->Clip = Object->Bound;
  1591.            EXIT
  1592.          END_CASE
  1593.  
  1594.          OTHERWISE
  1595.            UNGET
  1596.            Temp1_Object = Temp2_Object = Parse_Bound_Clip ();
  1597.            while (Temp2_Object->Sibling != NULL)
  1598.              Temp2_Object = Temp2_Object->Sibling;
  1599.            Temp2_Object->Sibling = Object->Clip;
  1600.            Object->Clip = Temp1_Object;
  1601.            EXIT
  1602.          END_CASE
  1603.        END_EXPECT
  1604.  
  1605.        Parse_End ();
  1606.      END_CASE
  1607.  
  1608.      CASE (TEXTURE_TOKEN)
  1609.        Object->Type |= TEXTURED_OBJECT;
  1610.        Local_Texture = Parse_Texture ();
  1611.        Link_Textures(&(Object->Texture), Local_Texture);
  1612.      END_CASE
  1613.  
  1614.      CASE3 (PIGMENT_TOKEN, TNORMAL_TOKEN, FINISH_TOKEN)
  1615.        Object->Type |= TEXTURED_OBJECT;
  1616.        if (Object->Texture == NULL)
  1617.          Object->Texture = Copy_Textures(Default_Texture);
  1618.        else
  1619.          if (Object->Texture->Type != PNF_TEXTURE)
  1620.            Link_Textures(&(Object->Texture), Copy_Textures(Default_Texture));
  1621.        UNGET
  1622.        EXPECT
  1623.          CASE (PIGMENT_TOKEN)
  1624.            Parse_Pigment ( &(Object->Texture->Pigment) );
  1625.          END_CASE
  1626.  
  1627.          CASE (TNORMAL_TOKEN)
  1628.            Parse_Tnormal ( &(Object->Texture->Tnormal) );
  1629.          END_CASE
  1630.  
  1631.          CASE (FINISH_TOKEN)
  1632.            Parse_Finish ( &(Object->Texture->Finish) );
  1633.          END_CASE
  1634.  
  1635.          OTHERWISE
  1636.            UNGET
  1637.            EXIT
  1638.          END_CASE
  1639.        END_EXPECT
  1640.      END_CASE
  1641.  
  1642.      CASE (INVERSE_TOKEN)
  1643.        if (Object->Type & PATCH_OBJECT)
  1644.          Warn ("Cannot invert a patch object",0.0);
  1645.        Invert_Object (Object);
  1646.      END_CASE
  1647.  
  1648.      CASE (STURM_TOKEN)
  1649.        if (!(Object->Type & STURM_OK_OBJECT))
  1650.          Error ("Cannot use STRUM here");
  1651.        ((POLY *) Object)->Sturm_Flag = TRUE;
  1652.      END_CASE
  1653.  
  1654.      CASE (WATER_LEVEL_TOKEN)
  1655.        if (!(Object->Type & WATER_LEVEL_OK_OBJECT))
  1656.          Error ("Cannot use WATER_LEVEL here");
  1657.        Temp_Water_Level = Parse_Float();
  1658.        if (Language_Version < 2.0)
  1659.          Temp_Water_Level /=256.0;
  1660.        ((HEIGHT_FIELD *) Object)->bounding_box->bounds[0].y = 65536.0 * Temp_Water_Level;
  1661.      END_CASE
  1662.  
  1663.      CASE (SMOOTH_TOKEN)
  1664.        if (!(Object->Type & SMOOTH_OK_OBJECT))
  1665.          Error ("Cannot use SMOOTH here");
  1666.        ((HEIGHT_FIELD *) Object)->Smoothed = TRUE;
  1667.        Object->Type |= DOUBLE_ILLUMINATE;
  1668.      END_CASE
  1669.  
  1670.      CASE (NO_SHADOW_TOKEN)
  1671.        Object->No_Shadow_Flag = TRUE;
  1672.      END_CASE
  1673.  
  1674.      CASE (LIGHT_SOURCE_TOKEN)
  1675.        Error("Light source must be defined using new syntax");
  1676.      END_CASE
  1677.  
  1678.      OTHERWISE
  1679.        UNGET
  1680.        EXIT
  1681.      END_CASE
  1682.    END_EXPECT
  1683.  
  1684.    if (Object->Bound != NULL)
  1685.      {
  1686.       Object->Bounds.Lower_Left = Object->Bound->Bounds.Lower_Left;
  1687.       Object->Bounds.Lengths    = Object->Bound->Bounds.Lengths;
  1688.      }
  1689.    Parse_End ();
  1690.   }
  1691.  
  1692. static
  1693. OBJECT *Parse_Sphere ()
  1694.   {
  1695.    SPHERE *Object;
  1696.  
  1697.    Parse_Begin ();
  1698.  
  1699.    if ( (Object = (SPHERE *)Parse_Object_Id()) != NULL)
  1700.       return ((OBJECT *) Object);
  1701.       
  1702.    Object = Create_Sphere();
  1703.  
  1704.    Parse_Vector(&(Object -> Center));   Parse_Comma();
  1705.    Object -> Radius = Parse_Float();
  1706.    Object -> Radius_Squared = Object -> Radius * Object -> Radius;
  1707.    Object -> Inverse_Radius = 1.0 / Object -> Radius;
  1708.  
  1709.    Make_Vector(&Object->Bounds.Lower_Left,
  1710.            Object->Center.x - Object->Radius,
  1711.            Object->Center.y - Object->Radius,
  1712.            Object->Center.z - Object->Radius);
  1713.    Make_Vector(&Object->Bounds.Lengths,
  1714.            2.0 * Object->Radius,
  1715.            2.0 * Object->Radius,
  1716.            2.0 * Object->Radius);
  1717.  
  1718.    Parse_Object_Mods ((OBJECT *) Object);
  1719.  
  1720.    return ((OBJECT *) Object);
  1721.   }
  1722.  
  1723. static
  1724. OBJECT *Parse_Plane ()
  1725.   {
  1726.    PLANE *Object;
  1727.  
  1728.    Parse_Begin ();
  1729.  
  1730.    if ( (Object = (PLANE *)Parse_Object_Id()) != NULL)
  1731.       return ((OBJECT *) Object);
  1732.       
  1733.    Object = Create_Plane();
  1734.  
  1735.    Parse_Vector(&(Object -> Normal_Vector));   Parse_Comma();
  1736.    VNormalize(Object->Normal_Vector, Object->Normal_Vector);
  1737.    Object->Distance = -Parse_Float();
  1738.  
  1739.    Parse_Object_Mods ((OBJECT *)Object);
  1740.  
  1741.    return ((OBJECT *) Object);
  1742.   }
  1743.  
  1744. static
  1745. OBJECT *Parse_Height_Field ()
  1746.   {
  1747.    HEIGHT_FIELD *Object;
  1748.    VECTOR Local_Vector;
  1749.    IMAGE *Image;
  1750.  
  1751.    Parse_Begin ();
  1752.  
  1753.    if ( (Object = (HEIGHT_FIELD *)Parse_Object_Id()) != NULL)
  1754.       return ((OBJECT *) Object);
  1755.       
  1756.    Object = Create_Height_Field();
  1757.  
  1758.    Image = Parse_Image (HF_FILE);
  1759.    Image->Use_Colour_Flag = FALSE;
  1760.  
  1761.    Object->bounding_box->bounds[0].x = 1.0;
  1762.    Object->bounding_box->bounds[0].y = 0.0;
  1763.    Object->bounding_box->bounds[0].z = 1.0;
  1764.    if (Image->File_Type == POT_FILE)
  1765.      {
  1766.       Object->bounding_box->bounds[1].x = Image -> width/2.0 - 2.0;
  1767.       Make_Vector(&Local_Vector,2.0/Image->width,1.0/65536.0,1.0/Image->height);
  1768.      }
  1769.    else
  1770.      {
  1771.       Object->bounding_box->bounds[1].x = Image -> width - 2.0;
  1772.       Make_Vector(&Local_Vector,1.0/(Image->width),1.0/65536.0,1.0/(Image->height));
  1773.      }
  1774.    Object->bounding_box->bounds[1].y = 65536.0;
  1775.    Object->bounding_box->bounds[1].z = Image -> height - 2.0;
  1776.    Compute_Scaling_Transform(Object->Trans,&Local_Vector);
  1777.  
  1778.    Parse_Object_Mods ((OBJECT *)Object);
  1779.  
  1780.    Find_Hf_Min_Max(Object, Image);
  1781.  
  1782.    return ((OBJECT *) Object);
  1783.   }
  1784.  
  1785. static
  1786. OBJECT *Parse_Triangle ()
  1787.   {
  1788.    TRIANGLE *Object;
  1789.  
  1790.    Parse_Begin ();
  1791.  
  1792.    if ( (Object = (TRIANGLE *)Parse_Object_Id()) != NULL)
  1793.       return ((OBJECT *) Object);
  1794.       
  1795.    Object = Create_Triangle();
  1796.  
  1797.    Parse_Vector (&Object->P1);    Parse_Comma();
  1798.    Parse_Vector (&Object->P2);    Parse_Comma();
  1799.    Parse_Vector (&Object->P3);
  1800.    if (!Compute_Triangle (Object,FALSE))
  1801.      fprintf (stdout, "Degenerate triangle on line %d.  Please remove.\n",
  1802.               Token.Token_Line_No+1);
  1803.  
  1804.    Parse_Object_Mods ((OBJECT *)Object);
  1805.  
  1806.    return ((OBJECT *) Object);
  1807.   }
  1808.  
  1809. static
  1810. OBJECT *Parse_Smooth_Triangle ()
  1811.   {
  1812.    SMOOTH_TRIANGLE *Object;
  1813.    short degen;                                                   /* LSK */
  1814.    DBL vlen;                                                      /* LSK */
  1815.  
  1816.    degen=FALSE;
  1817.  
  1818.    Parse_Begin ();
  1819.  
  1820.    if ( (Object = (SMOOTH_TRIANGLE *)Parse_Object_Id()) != NULL)
  1821.       return ((OBJECT *) Object);
  1822.  
  1823.    Object = Create_Smooth_Triangle();
  1824.  
  1825.    Parse_Vector (&Object->P1);    Parse_Comma();
  1826.    Parse_Vector (&Object->N1);    Parse_Comma();
  1827.  
  1828.    VLength(vlen,Object->N1);                                     /* LSK */
  1829.    if (vlen<1E-09)                                               /* LSK */
  1830.      degen=TRUE;                                                 /* LSK */
  1831.    else                                                          /* LSK */
  1832.      VNormalize (Object->N1, Object->N1);
  1833.  
  1834.    Parse_Vector (&Object->P2);    Parse_Comma();
  1835.    Parse_Vector (&Object->N2);    Parse_Comma();
  1836.  
  1837.    VLength(vlen,Object->N2);                                     /* LSK */
  1838.    if (vlen<1E-09)                                               /* LSK */
  1839.      degen=TRUE;                                                 /* LSK */
  1840.    else                                                          /* LSK */
  1841.      VNormalize (Object->N2, Object->N2);
  1842.  
  1843.    Parse_Vector (&Object->P3);    Parse_Comma();
  1844.    Parse_Vector (&Object->N3);
  1845.  
  1846.    VLength(vlen,Object->N3);                                     /* LSK */
  1847.    if (vlen<1E-09)                                               /* LSK */
  1848.      degen=TRUE;                                                 /* LSK */
  1849.    else                                                          /* LSK */
  1850.      VNormalize (Object->N3, Object->N3);
  1851.  
  1852.    if (!degen) {                                                 /* LSK */
  1853.      degen=!Compute_Triangle ((TRIANGLE *) Object,TRUE);         /* LSK */
  1854.    }
  1855.  
  1856.    if (degen)                                                    /* LSK */
  1857.      fprintf (stdout, "Degenerate triangle on line %d.  Please remove.\n",
  1858.               Token.Token_Line_No+1);
  1859.  
  1860.    Parse_Object_Mods ((OBJECT *)Object);
  1861.  
  1862.    return ((OBJECT *) Object);
  1863.  }
  1864.  
  1865. static
  1866. OBJECT *Parse_Quadric ()
  1867.   {
  1868.    QUADRIC *Object;
  1869.  
  1870.    Parse_Begin ();
  1871.  
  1872.    if ( (Object = (QUADRIC *)Parse_Object_Id()) != NULL)
  1873.       return ((OBJECT *) Object);
  1874.       
  1875.    Object = Create_Quadric();
  1876.  
  1877.    Parse_Vector(&(Object -> Square_Terms));     Parse_Comma();
  1878.    Parse_Vector(&(Object -> Mixed_Terms));      Parse_Comma();
  1879.    Parse_Vector(&(Object -> Terms));            Parse_Comma();
  1880.    Object -> Constant = Parse_Float();
  1881.    Object -> Non_Zero_Square_Term =
  1882.      !( (Object -> Square_Terms.x == 0.0)
  1883.      && (Object -> Square_Terms.y == 0.0)
  1884.      && (Object -> Square_Terms.z == 0.0)
  1885.      && (Object -> Mixed_Terms.x == 0.0)
  1886.      && (Object -> Mixed_Terms.y == 0.0)
  1887.      && (Object -> Mixed_Terms.z == 0.0));
  1888.  
  1889.    Parse_Object_Mods ((OBJECT *)Object);
  1890.  
  1891.    return ((OBJECT *) Object);
  1892.   }
  1893.  
  1894. static
  1895. OBJECT *Parse_Box ()
  1896.   {
  1897.    BOX *Object;
  1898.    DBL temp;
  1899.  
  1900.    Parse_Begin ();
  1901.  
  1902.    if ( (Object = (BOX *)Parse_Object_Id()) != NULL)
  1903.       return ((OBJECT *) Object);
  1904.       
  1905.    Object = Create_Box();
  1906.  
  1907.    Parse_Vector(&(Object->bounds[0]));     Parse_Comma();
  1908.    Parse_Vector(&(Object->bounds[1]));
  1909.  
  1910.     if (Object->bounds[0].x > Object->bounds[1].x) {
  1911.        temp = Object->bounds[0].x;
  1912.        Object->bounds[0].x = Object->bounds[1].x;
  1913.        Object->bounds[1].x = temp;
  1914.        }
  1915.     if (Object->bounds[0].y > Object->bounds[1].y) {
  1916.        temp = Object->bounds[0].y;
  1917.        Object->bounds[0].y = Object->bounds[1].y;
  1918.        Object->bounds[1].y = temp;
  1919.        }
  1920.     if (Object->bounds[0].z > Object->bounds[1].z) {
  1921.        temp = Object->bounds[0].z;
  1922.        Object->bounds[0].z = Object->bounds[1].z;
  1923.        Object->bounds[1].z = temp;
  1924.        }
  1925.  
  1926.    Object->Bounds.Lower_Left = Object->bounds[0];
  1927.    VSub(Object->Bounds.Lengths, Object->bounds[1],Object->bounds[0]);
  1928.  
  1929.    Parse_Object_Mods ((OBJECT *)Object);
  1930.  
  1931.    return ((OBJECT *) Object);
  1932.   }
  1933.  
  1934.  
  1935.  
  1936. static
  1937. OBJECT *Parse_Disc ()
  1938.   {
  1939.    DISC *Object;
  1940.    DBL tmpf;
  1941.    VECTOR lengths;
  1942.  
  1943.    Parse_Begin ();
  1944.  
  1945.    if ( (Object = (DISC *)Parse_Object_Id()) != NULL)
  1946.       return ((OBJECT *) Object);
  1947.       
  1948.    Object = Create_Disc();
  1949.  
  1950.    Parse_Vector(&(Object->center)); Parse_Comma ();
  1951.    Parse_Vector(&(Object->normal)); Parse_Comma ();
  1952.    VNormalize(Object->normal, Object->normal);
  1953.  
  1954.    tmpf = Parse_Float(); Parse_Comma ();
  1955.    Object->oradius2 = tmpf * tmpf;
  1956.  
  1957.    EXPECT
  1958.      CASE_FLOAT
  1959.        tmpf = Parse_Float();
  1960.        Object->iradius2 = tmpf * tmpf;
  1961.      END_CASE
  1962.  
  1963.      OTHERWISE
  1964.        UNGET
  1965.        EXIT
  1966.      END_CASE
  1967.    END_EXPECT
  1968.  
  1969.    /* Calculate info needed for ray-disc intersections */
  1970.    VDot(tmpf, Object->center, Object->normal);
  1971.    Object->d = -tmpf;
  1972.  
  1973.    /* Calculate the bounds */
  1974.    tmpf = sqrt(Object->oradius2);
  1975.    Make_Vector(&lengths, tmpf, tmpf, tmpf);
  1976.    VSub(Object->Bounds.Lower_Left, Object->center, lengths);
  1977.    VScale(Object->Bounds.Lengths, lengths, 2.0);
  1978.  
  1979.    Parse_Object_Mods ((OBJECT *)Object);
  1980.  
  1981.    return ((OBJECT *) Object);
  1982.   }
  1983.  
  1984. static
  1985. OBJECT *Parse_Cylinder ()
  1986.   {
  1987.    CONE *Object;
  1988.  
  1989.    Parse_Begin ();
  1990.  
  1991.    if ( (Object = (CONE *)Parse_Object_Id()) != NULL)
  1992.       return ((OBJECT *) Object);
  1993.       
  1994.    Object = Create_Cylinder();
  1995.  
  1996.    Parse_Vector(&(Object->apex));  Parse_Comma ();
  1997.    Parse_Vector(&(Object->base));  Parse_Comma ();
  1998.    Object->apex_radius = Parse_Float();
  1999.    Object->base_radius = Object->apex_radius;
  2000.  
  2001.    EXPECT
  2002.      CASE(OPEN_TOKEN)
  2003.        Object->closed = 0;
  2004.        EXIT
  2005.      END_CASE
  2006.      
  2007.      OTHERWISE
  2008.        UNGET
  2009.        EXIT
  2010.      END_CASE
  2011.    END_EXPECT
  2012.  
  2013.    Compute_Cylinder_Data((OBJECT *)Object);
  2014.  
  2015.    Parse_Object_Mods ((OBJECT *)Object);
  2016.  
  2017.    return ((OBJECT *) Object);
  2018.   }
  2019.  
  2020. static
  2021. OBJECT *Parse_Cone ()
  2022.   {
  2023.    CONE *Object;
  2024.  
  2025.    Parse_Begin ();
  2026.  
  2027.    if ( (Object = (CONE *)Parse_Object_Id()) != NULL)
  2028.       return ((OBJECT *) Object);
  2029.       
  2030.    Object = Create_Cone();
  2031.  
  2032.    Parse_Vector(&(Object->apex));  Parse_Comma ();
  2033.    Object->apex_radius = Parse_Float();  Parse_Comma ();
  2034.  
  2035.    Parse_Vector(&(Object->base));  Parse_Comma ();
  2036.    Object->base_radius = Parse_Float();
  2037.    
  2038.    EXPECT
  2039.      CASE(OPEN_TOKEN)
  2040.        Object->closed = 0;
  2041.        EXIT
  2042.      END_CASE
  2043.      
  2044.      OTHERWISE
  2045.        UNGET
  2046.        EXIT
  2047.      END_CASE
  2048.    END_EXPECT
  2049.  
  2050.    /* Compute run-time values for the cone */
  2051.    Compute_Cone_Data((OBJECT *)Object);
  2052.  
  2053.    Parse_Object_Mods ((OBJECT *)Object);
  2054.  
  2055.    return ((OBJECT *) Object);
  2056.   }
  2057.  
  2058. static
  2059. OBJECT *Parse_Blob ()
  2060.   {
  2061.    BLOB *Object;
  2062.    DBL threshold;
  2063.    int npoints;
  2064.    blobstackptr blob_components, blob_component;
  2065.  
  2066.    Parse_Begin ();
  2067.  
  2068.    if ( (Object = (BLOB *)Parse_Object_Id()) != NULL)
  2069.       return ((OBJECT *) Object);
  2070.       
  2071.    Object = Create_Blob();
  2072.  
  2073.    blob_components = NULL;
  2074.    npoints = 0;
  2075.    threshold = 1.0;
  2076.  
  2077.    EXPECT
  2078.      CASE (THRESHOLD_TOKEN)
  2079.        threshold = Parse_Float();
  2080.      END_CASE
  2081.  
  2082.      CASE (COMPONENT_TOKEN)
  2083.        blob_component = (blobstackptr) malloc(sizeof(struct blob_list_struct));
  2084.        if (blob_component == NULL)
  2085.           MAError("blob component");
  2086.        blob_component->elem.coeffs[2] = Parse_Float(); Parse_Comma();
  2087.        blob_component->elem.radius2   = Parse_Float(); Parse_Comma();
  2088.        Parse_Vector(&blob_component->elem.pos);
  2089.        blob_component->next = blob_components;
  2090.        blob_components = blob_component;
  2091.        npoints++;
  2092.      END_CASE
  2093.  
  2094.      OTHERWISE
  2095.        UNGET
  2096.        EXIT
  2097.      END_CASE
  2098.    END_EXPECT
  2099.  
  2100.    /* Finally, process the information */
  2101.    MakeBlob(Object, threshold, blob_components, npoints, 0);
  2102.  
  2103.    Parse_Object_Mods ((OBJECT *)Object);
  2104.  
  2105.    return ((OBJECT *) Object);
  2106.   }
  2107.  
  2108. static
  2109. OBJECT *Parse_Torus ()
  2110.   {
  2111.    POLY *Object;
  2112.    DBL iradius, oradius, *Coeffs;
  2113.  
  2114.    Parse_Begin ();
  2115.  
  2116.    if ( (Object = (POLY *)Parse_Object_Id()) != NULL)
  2117.       return ((OBJECT *) Object);
  2118.       
  2119.    Object = Create_Poly(4);
  2120.  
  2121.    /* Read in the two radii */
  2122.    iradius = Parse_Float(); /* Big radius */
  2123.    Parse_Comma();
  2124.    oradius = Parse_Float(); /* Little radius */
  2125.  
  2126.    /* Build the coefficients of a torus lying in the x-z plane */
  2127.    Coeffs = Object->Coeffs;
  2128.    Coeffs[ 0] =  1.0;
  2129.    Coeffs[ 4] =  2.0;
  2130.    Coeffs[ 7] =  2.0;
  2131.    Coeffs[ 9] = -2.0 * (iradius * iradius + oradius * oradius);
  2132.    Coeffs[20] =  1.0;
  2133.    Coeffs[23] =  2.0;
  2134.    Coeffs[25] =  2.0 * (iradius * iradius - oradius * oradius);
  2135.    Coeffs[30] =  1.0;
  2136.    Coeffs[32] = -2.0 * (iradius * iradius + oradius * oradius);
  2137.    Coeffs[34] = (iradius * iradius - oradius * oradius) *
  2138.             (iradius * iradius - oradius * oradius);
  2139.  
  2140.    Make_Vector(&Object->Bounds.Lower_Left, -(iradius + oradius),
  2141.            -iradius, -(iradius + oradius))
  2142.    Make_Vector(&Object->Bounds.Lengths, 2.0 * (iradius + oradius),
  2143.            2.0 * iradius, 2.0 * (iradius + oradius));
  2144.  
  2145.    Parse_Object_Mods ((OBJECT *)Object);
  2146.  
  2147.    return ((OBJECT *) Object);
  2148.   }
  2149.  
  2150. static
  2151. OBJECT *Parse_Poly (order)
  2152.   int order;
  2153.   {
  2154.    POLY *Object;
  2155.  
  2156.    Parse_Begin ();
  2157.  
  2158.    if ( (Object = (POLY *)Parse_Object_Id()) != NULL)
  2159.       return ((OBJECT *) Object);
  2160.       
  2161.    if (order == 0)
  2162.      {
  2163.       order = (int)Parse_Float();      Parse_Comma();
  2164.       if (order < 2 || order > MAX_ORDER)
  2165.         Error("Order of poly is out of range");
  2166.      }
  2167.  
  2168.    Object = Create_Poly(order);
  2169.  
  2170.    Parse_Coeffs(Object->Order, &(Object->Coeffs[0]));
  2171.  
  2172.    Parse_Object_Mods ((OBJECT *)Object);
  2173.  
  2174.    return ((OBJECT *) Object);
  2175.   }
  2176.  
  2177. static
  2178. OBJECT *Parse_Bicubic_Patch ()
  2179.   {
  2180.    BICUBIC_PATCH *Object;
  2181.    int i, j;
  2182.  
  2183.    Parse_Begin ();
  2184.  
  2185.    if ( (Object = (BICUBIC_PATCH *)Parse_Object_Id()) != NULL)
  2186.       return ((OBJECT *) Object);
  2187.       
  2188.    Object = Create_Bicubic_Patch();
  2189.  
  2190.    EXPECT
  2191.      CASE_FLOAT
  2192.        Warn("Should use keywords for bicubic parameters.",1.5);
  2193.        Object->Patch_Type = (int)Parse_Float();
  2194.        if (Object->Patch_Type == 2 ||
  2195.            Object->Patch_Type == 3)
  2196.            Object->Flatness_Value = Parse_Float();
  2197.          else
  2198.            Object->Flatness_Value = 0.1;
  2199.        Object->U_Steps = (int)Parse_Float();
  2200.        Object->V_Steps = (int)Parse_Float();
  2201.        EXIT
  2202.      END_CASE       
  2203.        
  2204.      CASE (TYPE_TOKEN)
  2205.        Object->Patch_Type = (int)Parse_Float();
  2206.      END_CASE
  2207.  
  2208.      CASE (FLATNESS_TOKEN)
  2209.        Object->Flatness_Value = Parse_Float();
  2210.      END_CASE
  2211.  
  2212.      CASE (V_STEPS_TOKEN)
  2213.        Object->V_Steps = (int)Parse_Float();
  2214.      END_CASE
  2215.  
  2216.      CASE (U_STEPS_TOKEN)
  2217.        Object->U_Steps = (int)Parse_Float();
  2218.      END_CASE
  2219.  
  2220.      OTHERWISE
  2221.        UNGET
  2222.        EXIT
  2223.      END_CASE
  2224.    END_EXPECT
  2225.  
  2226.    if (Object->Patch_Type > 1)
  2227.      {
  2228.       Object->Patch_Type = 1;
  2229.       Warn("Patch type no longer supported. Using type 1.",0.0);
  2230.      }
  2231.  
  2232.    if ((Object->Patch_Type < 0) || (Object->Patch_Type > MAX_PATCH_TYPE))
  2233.      Error("Undefined bicubic patch type");
  2234.  
  2235.    Parse_Comma();
  2236.    for (i=0;i<4;i++)
  2237.      for (j=0;j<4;j++)
  2238.        {
  2239.         Parse_Vector(&(Object -> Control_Points[i][j]));
  2240.         if (!((i==3)&&(j==3)))
  2241.           Parse_Comma();
  2242.        };
  2243.    Precompute_Patch_Values(Object); /* interpolated mesh coords */
  2244.  
  2245.    Parse_Object_Mods ((OBJECT *)Object);
  2246.  
  2247.    return ((OBJECT *) Object);
  2248.   }
  2249.  
  2250. static
  2251. OBJECT *Parse_CSG (CSG_Type)
  2252.   int CSG_Type;
  2253.   {
  2254.    CSG *Object;
  2255.    OBJECT *Local;
  2256.    int Object_Count = 0;
  2257.  
  2258.    Parse_Begin ();
  2259.  
  2260.    if ( (Object = (CSG *)Parse_Object_Id()) != NULL)
  2261.       return ((OBJECT *) Object);
  2262.       
  2263.    if (CSG_Type & CSG_UNION_TYPE)
  2264.      Object = Create_CSG_Union ();
  2265.    else
  2266.      if (CSG_Type & CSG_MERGE_TYPE)
  2267.        Object = Create_CSG_Merge ();
  2268.      else
  2269.        Object = Create_CSG_Intersection ();
  2270.  
  2271.    Object->Children = NULL;
  2272.  
  2273.    while ((Local = Parse_Object ()) != NULL)
  2274.      {
  2275.       if ((CSG_Type & CSG_INTERSECTION_TYPE) && (Local->Type & PATCH_OBJECT))
  2276.         Warn ("Patch objects not allowed in intersection",0.0);
  2277.       Object_Count++;
  2278.       if ((CSG_Type & CSG_DIFFERENCE_TYPE) && (Object_Count > 1))
  2279.         Invert_Object (Local);
  2280.       Object->Type |=  (Local->Type & CHILDREN_FLAGS);
  2281.       Local->Type |= IS_CHILD_OBJECT;
  2282.       Link(Local, &Local->Sibling, &Object->Children);
  2283.      };
  2284.  
  2285.    if ((Object_Count < 2) && (Language_Version >= 1.5))
  2286.      Warn ("Should have at least 2 objects in csg",1.5);
  2287.    Compute_CSG_Bounds((OBJECT *)Object);
  2288.  
  2289.    Parse_Object_Mods ((OBJECT *)Object);
  2290.  
  2291.    return ((OBJECT *) Object);
  2292.   }
  2293.  
  2294. static
  2295. OBJECT *Parse_Light_Source ()
  2296.   {
  2297.    VECTOR Local_Vector;
  2298.    LIGHT_SOURCE *Object;
  2299.  
  2300.    Parse_Begin ();
  2301.  
  2302.    if ( (Object = (LIGHT_SOURCE *)Parse_Object_Id()) != NULL)
  2303.       return ((OBJECT *) Object);
  2304.       
  2305.    Object = Create_Light_Source ();
  2306.  
  2307.    Parse_Vector(&Object->Center);
  2308.  
  2309.    GET (COLOUR_TOKEN)
  2310.  
  2311.    Parse_Colour (&Object->Colour);
  2312.  
  2313.    EXPECT
  2314.      CASE (LOOKS_LIKE_TOKEN)
  2315.        if (Object->Children != NULL)
  2316.          Error("Only one looks_like allowed per light_source");
  2317.        Parse_Begin ();
  2318.        Object->Type &= ~(int)PATCH_OBJECT;
  2319.        if ((Object->Children = Parse_Object ()) == NULL)
  2320.          Parse_Error_Str ("object");
  2321.        Translate_Object (Object->Children, &Object->Center);
  2322.        Parse_Object_Mods (Object->Children);
  2323.        Object->Children->No_Shadow_Flag = TRUE;
  2324.        Object->No_Shadow_Flag = TRUE;
  2325.        Object->Type |= (Object->Children->Type & CHILDREN_FLAGS);
  2326.      END_CASE
  2327.  
  2328.      CASE (SPOTLIGHT_TOKEN)
  2329.        Object->Light_Type = SPOT_SOURCE;
  2330.      END_CASE
  2331.  
  2332.      CASE (POINT_AT_TOKEN)
  2333.        if (Object->Light_Type == SPOT_SOURCE)
  2334.          Parse_Vector(&Object->Points_At);
  2335.        else
  2336.          Error("Spotlight param illegal in standard light source");
  2337.      END_CASE
  2338.  
  2339.      CASE (TIGHTNESS_TOKEN)
  2340.        if (Object->Light_Type == SPOT_SOURCE)
  2341.          Object->Coeff = Parse_Float();
  2342.        else
  2343.          Error("Spotlight param illegal in standard light source");
  2344.      END_CASE
  2345.  
  2346.      CASE (RADIUS_TOKEN)
  2347.        if (Object->Light_Type == SPOT_SOURCE)
  2348.          Object->Radius = cos(Parse_Float() * M_PI / 180.0);
  2349.        else
  2350.          Error("Spotlight param illegal in standard light source");
  2351.      END_CASE
  2352.  
  2353.      CASE (FALLOFF_TOKEN)
  2354.        if (Object->Light_Type == SPOT_SOURCE)
  2355.          Object->Falloff = cos(Parse_Float() * M_PI / 180.0);
  2356.        else
  2357.          Error("Spotlight param illegal in standard light source");
  2358.      END_CASE
  2359.  
  2360.      CASE (AREA_LIGHT_TOKEN)
  2361.        Object -> Area_Light = TRUE;
  2362.        Parse_Vector (&(Object -> Axis1)); Parse_Comma ();
  2363.        Parse_Vector (&(Object -> Axis2)); Parse_Comma ();
  2364.        Object -> Area_Size1 = (int)Parse_Float(); Parse_Comma ();
  2365.        Object -> Area_Size2 = (int)Parse_Float();
  2366.        Object -> Light_Grid = Create_Light_Grid (Object -> Area_Size1,
  2367.             Object -> Area_Size2);
  2368.      END_CASE
  2369.  
  2370.      CASE (JITTER_TOKEN)
  2371.        Object -> Jitter = TRUE;
  2372.      END_CASE
  2373.  
  2374.      CASE (TRACK_TOKEN)
  2375.        Object -> Track = TRUE;
  2376.      END_CASE
  2377.  
  2378.      CASE (ADAPTIVE_TOKEN)
  2379.        Object -> Adaptive_Level = (int)Parse_Float();
  2380.      END_CASE
  2381.  
  2382.      CASE (TRANSLATE_TOKEN)
  2383.        Parse_Vector (&Local_Vector);
  2384.        Translate_Object ((OBJECT *)Object, &Local_Vector);
  2385.      END_CASE
  2386.  
  2387.      CASE (ROTATE_TOKEN)
  2388.        Parse_Vector (&Local_Vector);
  2389.        Rotate_Object ((OBJECT *)Object, &Local_Vector);
  2390.      END_CASE
  2391.  
  2392.      CASE (SCALE_TOKEN)
  2393.        Parse_Scale_Vector (&Local_Vector);
  2394.        Scale_Object ((OBJECT *)Object, &Local_Vector);
  2395.      END_CASE
  2396.  
  2397.      CASE (TRANSFORM_TOKEN)
  2398.        GET(TRANSFORM_ID_TOKEN)
  2399.        Transform_Object ((OBJECT *)Object, (TRANSFORM *)Token.Constant_Data);
  2400.      END_CASE
  2401.  
  2402.      OTHERWISE
  2403.        UNGET
  2404.        EXIT
  2405.      END_CASE
  2406.    END_EXPECT
  2407.  
  2408.    Parse_End ();
  2409.  
  2410.    return ((OBJECT *)Object);
  2411.   }
  2412.  
  2413.  
  2414. static
  2415. OBJECT *Parse_Object ()
  2416.   {
  2417.    OBJECT *Object = NULL;
  2418.  
  2419.    EXPECT
  2420.      CASE (SPHERE_TOKEN)
  2421.        Object = Parse_Sphere ();
  2422.        EXIT
  2423.      END_CASE
  2424.  
  2425.      CASE (PLANE_TOKEN)
  2426.        Object = Parse_Plane ();
  2427.        EXIT
  2428.      END_CASE
  2429.  
  2430.      CASE (CONE_TOKEN)
  2431.        Object = Parse_Cone ();
  2432.        EXIT
  2433.      END_CASE
  2434.  
  2435.      CASE (CYLINDER_TOKEN)
  2436.        Object = Parse_Cylinder ();
  2437.        EXIT
  2438.      END_CASE
  2439.  
  2440.      CASE (DISC_TOKEN)
  2441.        Object = Parse_Disc ();
  2442.        EXIT
  2443.      END_CASE
  2444.  
  2445.      CASE (QUADRIC_TOKEN)
  2446.        Object = Parse_Quadric ();
  2447.        EXIT
  2448.      END_CASE
  2449.  
  2450.      CASE (CUBIC_TOKEN)
  2451.        Object = Parse_Poly (3);
  2452.        EXIT
  2453.      END_CASE
  2454.  
  2455.      CASE (QUARTIC_TOKEN)
  2456.        Object = Parse_Poly (4);
  2457.        EXIT
  2458.      END_CASE
  2459.  
  2460.      CASE (POLY_TOKEN)
  2461.        Object = Parse_Poly (0);
  2462.        EXIT
  2463.      END_CASE
  2464.  
  2465.      CASE (TORUS_TOKEN)
  2466.        Object = Parse_Torus ();
  2467.        EXIT
  2468.      END_CASE
  2469.  
  2470.      CASE (OBJECT_ID_TOKEN)
  2471.        Object = Copy_Object((OBJECT *) Token.Constant_Data);
  2472.        EXIT
  2473.      END_CASE
  2474.  
  2475.      CASE (UNION_TOKEN)
  2476.        Object = Parse_CSG (CSG_UNION_TYPE);
  2477.        EXIT
  2478.      END_CASE
  2479.  
  2480.      CASE (COMPOSITE_TOKEN)
  2481.        Warn("Use union instead of composite",1.5);
  2482.        Object = Parse_CSG (CSG_UNION_TYPE);
  2483.        EXIT
  2484.      END_CASE
  2485.  
  2486.      CASE (MERGE_TOKEN)
  2487.        Object = Parse_CSG (CSG_MERGE_TYPE);
  2488.        EXIT
  2489.      END_CASE
  2490.  
  2491.      CASE (INTERSECTION_TOKEN)
  2492.        Object = Parse_CSG (CSG_INTERSECTION_TYPE);
  2493.        EXIT
  2494.      END_CASE
  2495.  
  2496.      CASE (DIFFERENCE_TOKEN)
  2497.        Object = Parse_CSG (CSG_DIFFERENCE_TYPE+CSG_INTERSECTION_TYPE);
  2498.        EXIT
  2499.      END_CASE
  2500.  
  2501.      CASE (BICUBIC_PATCH_TOKEN)
  2502.        Object = Parse_Bicubic_Patch ();
  2503.        EXIT
  2504.      END_CASE
  2505.  
  2506.      CASE (TRIANGLE_TOKEN)
  2507.        Object = Parse_Triangle ();
  2508.        EXIT
  2509.      END_CASE
  2510.  
  2511.      CASE (SMOOTH_TRIANGLE_TOKEN)
  2512.        Object = Parse_Smooth_Triangle ();
  2513.        EXIT
  2514.      END_CASE
  2515.  
  2516.      CASE (HEIGHT_FIELD_TOKEN)
  2517.        Object = Parse_Height_Field ();
  2518.        EXIT
  2519.      END_CASE
  2520.  
  2521.      CASE (BOX_TOKEN)
  2522.        Object = Parse_Box ();
  2523.        EXIT
  2524.      END_CASE
  2525.  
  2526.      CASE (BLOB_TOKEN)
  2527.        Object = Parse_Blob ();
  2528.        EXIT
  2529.      END_CASE
  2530.  
  2531.      CASE (LIGHT_SOURCE_TOKEN)
  2532.        Object = Parse_Light_Source ();
  2533.        EXIT
  2534.      END_CASE
  2535.  
  2536.      CASE (OBJECT_TOKEN)
  2537.        Parse_Begin ();
  2538.        Object = Parse_Object ();
  2539.        if (!Object)
  2540.          Parse_Error_Str ("object");
  2541.        Parse_Object_Mods ((OBJECT *)Object);
  2542.        EXIT
  2543.      END_CASE
  2544.  
  2545.      OTHERWISE
  2546.        UNGET
  2547.        EXIT
  2548.      END_CASE
  2549.    END_EXPECT
  2550.  
  2551.    return ((OBJECT *) Object);
  2552.   }
  2553.  
  2554. static void Parse_Fog ()
  2555.   {
  2556.    Parse_Begin ();
  2557.  
  2558.    EXPECT
  2559.      CASE (COLOUR_TOKEN)
  2560.        Parse_Colour (&Frame.Fog_Colour);
  2561.      END_CASE
  2562.  
  2563.      CASE (DISTANCE_TOKEN)
  2564.        Frame.Fog_Distance = Parse_Float ();
  2565.      END_CASE
  2566.  
  2567.      CASE_FLOAT
  2568.        Warn("Should use distance keyword.",1.5);
  2569.        Frame.Fog_Distance = Parse_Float ();
  2570.      END_CASE
  2571.  
  2572.      OTHERWISE
  2573.        UNGET
  2574.        EXIT
  2575.      END_CASE
  2576.    END_EXPECT
  2577.    Parse_End ();
  2578.   }
  2579.  
  2580. static void Parse_Frame ()
  2581.   {
  2582.    OBJECT *Object;
  2583.    TEXTURE *Local_Texture;
  2584.    PIGMENT *Local_Pigment;
  2585.    TNORMAL *Local_Tnormal;
  2586.    FINISH  *Local_Finish;
  2587.  
  2588.    EXPECT
  2589.      CASE (FOG_TOKEN)
  2590.        Parse_Fog();
  2591.      END_CASE
  2592.  
  2593.      CASE (BACKGROUND_TOKEN)
  2594.        Parse_Begin();
  2595.        GET (COLOUR_TOKEN)
  2596.        Parse_Colour (&Frame.Background_Colour);
  2597.        Parse_End();
  2598.      END_CASE
  2599.  
  2600.      CASE (CAMERA_TOKEN)
  2601.        Parse_Camera (&Frame.Camera);
  2602.      END_CASE
  2603.  
  2604.      CASE (DECLARE_TOKEN)
  2605.        Parse_Declare ();
  2606.      END_CASE
  2607.  
  2608.      CASE (MAX_TRACE_LEVEL_TOKEN)
  2609.        Max_Trace_Level = Parse_Float ();
  2610.      END_CASE
  2611.  
  2612.      CASE (VERSION_TOKEN)
  2613.        Language_Version = Parse_Float ();
  2614.      END_CASE
  2615.  
  2616.      CASE (MAX_INTERSECTIONS)
  2617.        Max_Intersections = (int)Parse_Float ();
  2618.      END_CASE
  2619.  
  2620.      CASE (DEFAULT_TOKEN)
  2621.        Not_In_Default = FALSE;
  2622.        Parse_Begin();
  2623.        EXPECT
  2624.          CASE (TEXTURE_TOKEN)
  2625.            Local_Texture = Default_Texture;
  2626.            Default_Texture = Parse_Texture();
  2627.            if (Default_Texture->Type != PNF_TEXTURE)
  2628.              Error("Default texture cannot be material map or tiles");
  2629.            if (Default_Texture->Next_Layer != NULL)
  2630.              Error("Default texture cannot be layered");
  2631.            Destroy_Textures(Local_Texture);
  2632.          END_CASE
  2633.  
  2634.          CASE (PIGMENT_TOKEN)
  2635.            Local_Pigment = Copy_Pigment((Default_Texture->Pigment));
  2636.            Parse_Pigment (&Local_Pigment);
  2637.            Destroy_Pigment(Default_Texture->Pigment);
  2638.            Default_Texture->Pigment = Local_Pigment;
  2639.          END_CASE
  2640.  
  2641.          CASE (TNORMAL_TOKEN)
  2642.            Local_Tnormal = Copy_Tnormal((Default_Texture->Tnormal));
  2643.            Parse_Tnormal (&Local_Tnormal);
  2644.            Destroy_Tnormal(Default_Texture->Tnormal);
  2645.            Default_Texture->Tnormal = Local_Tnormal;
  2646.          END_CASE
  2647.  
  2648.          CASE (FINISH_TOKEN)
  2649.            Local_Finish = Copy_Finish((Default_Texture->Finish));
  2650.            Parse_Finish (&Local_Finish);
  2651.            Destroy_Finish(Default_Texture->Finish);
  2652.            Default_Texture->Finish = Local_Finish;
  2653.          END_CASE
  2654.  
  2655.          CASE (CAMERA_TOKEN)
  2656.            Parse_Camera (&Default_Camera);
  2657.          END_CASE
  2658.  
  2659.          OTHERWISE
  2660.            UNGET
  2661.            EXIT
  2662.          END_CASE
  2663.        END_EXPECT
  2664.        Parse_End();
  2665.        Not_In_Default = TRUE;
  2666.      END_CASE
  2667.  
  2668.      CASE (END_OF_FILE_TOKEN)
  2669.        EXIT
  2670.      END_CASE
  2671.  
  2672.      OTHERWISE
  2673.        UNGET
  2674.        Object = Parse_Object();
  2675.        if (Object == NULL)
  2676.          Parse_Error_Str ("object or directive");
  2677.        Post_Process (Object, NULL);
  2678.        Link_To_Frame (Object);
  2679.      END_CASE
  2680.    END_EXPECT
  2681.   }
  2682.  
  2683. static void Parse_Camera (Camera_Ptr)
  2684.   CAMERA **Camera_Ptr;
  2685.   {
  2686.    VECTOR Local_Vector, Temp_Vector;
  2687.    DBL Direction_Length, Up_Length, Right_Length, Handedness;
  2688.    CAMERA *New;
  2689.  
  2690.    Parse_Begin ();
  2691.  
  2692.    EXPECT
  2693.      CASE (CAMERA_ID_TOKEN)
  2694.        Destroy_Camera(*Camera_Ptr);
  2695.        *Camera_Ptr = Copy_Camera ((CAMERA *) Token.Constant_Data);
  2696.        EXIT
  2697.      END_CASE
  2698.  
  2699.      OTHERWISE
  2700.        UNGET
  2701.        EXIT
  2702.      END_CASE
  2703.    END_EXPECT
  2704.  
  2705.    New = *Camera_Ptr;
  2706.  
  2707.    EXPECT
  2708.      CASE (LOCATION_TOKEN)
  2709.        Parse_Vector(&(New->Location));
  2710.      END_CASE
  2711.  
  2712.      CASE (DIRECTION_TOKEN)
  2713.        Parse_Vector(&(New->Direction));
  2714.      END_CASE
  2715.  
  2716.      CASE (UP_TOKEN)
  2717.        Parse_Vector(&(New->Up));
  2718.      END_CASE
  2719.  
  2720.      CASE (RIGHT_TOKEN)
  2721.        Parse_Vector(&(New->Right));
  2722.      END_CASE
  2723.  
  2724.      CASE (SKY_TOKEN)
  2725.        Parse_Vector(&(New->Sky));
  2726.      END_CASE
  2727.  
  2728.      CASE (LOOK_AT_TOKEN)
  2729.        VLength (Direction_Length, New->Direction);
  2730.        VLength (Up_Length,        New->Up);
  2731.        VLength (Right_Length,     New->Right);
  2732.        VCross  (Temp_Vector,      New->Direction, New->Up);
  2733.        VDot    (Handedness,       Temp_Vector,   New->Right);
  2734.  
  2735.        Parse_Vector (&New->Direction);
  2736.  
  2737.        VSub       (New->Direction, New->Direction, New->Location);
  2738.        VNormalize (New->Direction, New->Direction);
  2739.        VCross     (New->Right,     New->Direction, New->Sky);
  2740.        VNormalize (New->Right,     New->Right);
  2741.        VCross     (New->Up,        New->Right,     New->Direction);
  2742.        VScale     (New->Direction, New->Direction, Direction_Length);
  2743.  
  2744.        if (Handedness >= 0.0)
  2745.          VScale (New->Right, New->Right, Right_Length)
  2746.        else
  2747.          VScale (New->Right, New->Right, -Right_Length);
  2748.  
  2749.        VScale (New->Up, New->Up, Up_Length);
  2750.      END_CASE
  2751.  
  2752.      CASE (TRANSLATE_TOKEN)
  2753.        Parse_Vector (&Local_Vector);
  2754.        Translate_Camera (New, &Local_Vector);
  2755.      END_CASE
  2756.  
  2757.      CASE (ROTATE_TOKEN)
  2758.        Parse_Vector (&Local_Vector);
  2759.        Rotate_Camera (New, &Local_Vector);
  2760.      END_CASE
  2761.  
  2762.      CASE (SCALE_TOKEN)
  2763.        Parse_Scale_Vector (&Local_Vector);
  2764.        Scale_Camera (New, &Local_Vector);
  2765.      END_CASE
  2766.  
  2767.      CASE (TRANSFORM_TOKEN)
  2768.        GET(TRANSFORM_ID_TOKEN)
  2769.        Transform_Camera (New, (TRANSFORM *)Token.Constant_Data);
  2770.      END_CASE
  2771.  
  2772.      OTHERWISE
  2773.        UNGET
  2774.        EXIT
  2775.      END_CASE
  2776.    END_EXPECT
  2777.    Parse_End ();
  2778.   }
  2779.  
  2780. static
  2781. TRANSFORM *Parse_Transform ()
  2782.   {
  2783.    TRANSFORM *New, Local_Trans;
  2784.    VECTOR Local_Vector;
  2785.  
  2786.    Parse_Begin ();
  2787.    New = Create_Transform ();
  2788.  
  2789.    EXPECT
  2790.      CASE(TRANSFORM_ID_TOKEN)
  2791.        Compose_Transforms (New, (TRANSFORM *)Token.Constant_Data);
  2792.        EXIT
  2793.      END_CASE
  2794.  
  2795.      CASE (TRANSLATE_TOKEN)
  2796.        Parse_Vector (&Local_Vector);
  2797.        Compute_Translation_Transform(&Local_Trans, &Local_Vector);
  2798.        Compose_Transforms (New, &Local_Trans);
  2799.      END_CASE
  2800.  
  2801.      CASE (ROTATE_TOKEN)
  2802.        Parse_Vector (&Local_Vector);
  2803.        Compute_Rotation_Transform(&Local_Trans, &Local_Vector);
  2804.        Compose_Transforms (New, &Local_Trans);
  2805.      END_CASE
  2806.  
  2807.      CASE (SCALE_TOKEN)
  2808.        Parse_Scale_Vector (&Local_Vector);
  2809.        Compute_Scaling_Transform(&Local_Trans, &Local_Vector);
  2810.        Compose_Transforms (New, &Local_Trans);
  2811.      END_CASE
  2812.  
  2813.      OTHERWISE
  2814.        UNGET
  2815.        EXIT
  2816.      END_CASE
  2817.    END_EXPECT
  2818.  
  2819.    Parse_End ();
  2820.    return (New);
  2821.   }
  2822.  
  2823. static void Parse_Declare ()
  2824.   {
  2825.   VECTOR Local_Vector;
  2826.   COLOUR *Local_Colour;
  2827.   PIGMENT *Local_Pigment;
  2828.   TNORMAL *Local_Tnormal;
  2829.   FINISH *Local_Finish;
  2830.   TEXTURE *Local_Texture;
  2831.   COLOUR_MAP *Local_Colour_Map;
  2832.   TRANSFORM *Local_Trans;
  2833.   OBJECT *Local_Object;
  2834.   CAMERA *Local_Camera;
  2835.  
  2836.   struct Constant_Struct *Constant_Ptr;
  2837.  
  2838.   EXPECT
  2839.     CASE (IDENTIFIER_TOKEN)
  2840.       if (++Number_Of_Constants >= MAX_CONSTANTS)
  2841.         Error ("Too many constants \"DECLARED\"");
  2842.       else
  2843.         Constant_Ptr = &(Constants[Number_Of_Constants]);
  2844.       EXIT
  2845.     END_CASE
  2846.  
  2847.     CASE4 (COLOUR_ID_TOKEN, VECTOR_ID_TOKEN, FLOAT_ID_TOKEN, PIGMENT_ID_TOKEN)
  2848.     CASE4 (TNORMAL_ID_TOKEN, FINISH_ID_TOKEN, TEXTURE_ID_TOKEN, OBJECT_ID_TOKEN)
  2849.     CASE3 (COLOUR_MAP_ID_TOKEN, TRANSFORM_ID_TOKEN, CAMERA_ID_TOKEN)
  2850.       Constant_Ptr = &(Constants[Token.Constant_Index]);
  2851.       EXIT
  2852.     END_CASE
  2853.  
  2854.     OTHERWISE
  2855.       Parse_Error(IDENTIFIER_TOKEN);
  2856.     END_CASE
  2857.   END_EXPECT
  2858.  
  2859.   Previous = Token.Token_Id;
  2860.  
  2861.   GET (EQUALS_TOKEN);
  2862.  
  2863.   EXPECT
  2864.     CASE (COLOUR_TOKEN)
  2865.       if (Test_Redefine(COLOUR_ID_TOKEN))
  2866.         Destroy_Colour((COLOUR *)Constant_Ptr->Constant_Data);
  2867.       Local_Colour = Create_Colour();
  2868.       Parse_Colour (Local_Colour);
  2869.       Constant_Ptr -> Constant_Data = (char *) Local_Colour;
  2870.       Constant_Ptr -> Constant_Type = COLOUR_CONSTANT;
  2871.       EXIT
  2872.     END_CASE
  2873.  
  2874.     CASE_VECTOR
  2875.       Have_Vector = FALSE;
  2876.       Parse_Vector_Float (&Local_Vector);
  2877.       if (Have_Vector)
  2878.         {
  2879.          if (Test_Redefine(VECTOR_ID_TOKEN))
  2880.            Destroy_Vector((VECTOR *)Constant_Ptr->Constant_Data);
  2881.          Constant_Ptr -> Constant_Type = VECTOR_CONSTANT;
  2882.          Constant_Ptr -> Constant_Data = (char *) Create_Vector();
  2883.          *((VECTOR *)Constant_Ptr -> Constant_Data) = Local_Vector;
  2884.         }
  2885.       else
  2886.         {
  2887.          if (Test_Redefine(FLOAT_ID_TOKEN))
  2888.            Destroy_Float((DBL *)Constant_Ptr->Constant_Data);
  2889.          Constant_Ptr -> Constant_Type = FLOAT_CONSTANT;
  2890.          Constant_Ptr -> Constant_Data = (char *) Create_Float();
  2891.          *((DBL *) Constant_Ptr -> Constant_Data) = Local_Vector.x;
  2892.         }
  2893.       EXIT
  2894.     END_CASE
  2895.  
  2896.     CASE (PIGMENT_TOKEN)
  2897.       if (Test_Redefine(PIGMENT_ID_TOKEN))
  2898.         Destroy_Pigment((PIGMENT *)Constant_Ptr->Constant_Data);
  2899.       Local_Pigment = Copy_Pigment((Default_Texture->Pigment));
  2900.       Parse_Pigment (&Local_Pigment);
  2901.       Constant_Ptr -> Constant_Type = PIGMENT_CONSTANT;
  2902.       Constant_Ptr -> Constant_Data = (char *)Local_Pigment;
  2903.       EXIT
  2904.     END_CASE
  2905.  
  2906.     CASE (TNORMAL_TOKEN)
  2907.       if (Test_Redefine(TNORMAL_ID_TOKEN))
  2908.         Destroy_Tnormal((TNORMAL *)Constant_Ptr->Constant_Data);
  2909.       Local_Tnormal = Copy_Tnormal((Default_Texture->Tnormal));
  2910.       Parse_Tnormal (&Local_Tnormal);
  2911.       Constant_Ptr -> Constant_Type = TNORMAL_CONSTANT;
  2912.       Constant_Ptr -> Constant_Data = (char *) Local_Tnormal;
  2913.       EXIT
  2914.     END_CASE
  2915.  
  2916.     CASE (FINISH_TOKEN)
  2917.       if (Test_Redefine(FINISH_ID_TOKEN))
  2918.         Destroy_Finish((FINISH *)Constant_Ptr->Constant_Data);
  2919.       Local_Finish = Copy_Finish((Default_Texture->Finish));
  2920.       Parse_Finish (&Local_Finish);
  2921.       Constant_Ptr -> Constant_Type = FINISH_CONSTANT;
  2922.       Constant_Ptr -> Constant_Data = (char *) Local_Finish;
  2923.       EXIT
  2924.     END_CASE
  2925.  
  2926.     CASE (CAMERA_TOKEN)
  2927.       if (Test_Redefine(CAMERA_ID_TOKEN))
  2928.         Destroy_Camera((CAMERA *)Constant_Ptr->Constant_Data);
  2929.       Local_Camera = Copy_Camera(Default_Camera);
  2930.       Parse_Camera (&Local_Camera);
  2931.       Constant_Ptr -> Constant_Type = CAMERA_CONSTANT;
  2932.       Constant_Ptr -> Constant_Data = (char *) Local_Camera;
  2933.       EXIT
  2934.     END_CASE
  2935.  
  2936.     CASE (TEXTURE_TOKEN)
  2937.       if (Test_Redefine(TEXTURE_ID_TOKEN))
  2938.         Destroy_Textures((TEXTURE *)Constant_Ptr->Constant_Data);
  2939.       Local_Texture = Parse_Texture ();
  2940.       Constant_Ptr -> Constant_Type = TEXTURE_CONSTANT;
  2941.       Constant_Ptr -> Constant_Data = NULL;
  2942.       Link_Textures((TEXTURE **) &Constant_Ptr->Constant_Data, Local_Texture);
  2943.       EXPECT
  2944.         CASE (TEXTURE_TOKEN)
  2945.           Local_Texture = Parse_Texture ();
  2946.           Link_Textures((TEXTURE **) &Constant_Ptr->Constant_Data, Local_Texture);
  2947.         END_CASE
  2948.  
  2949.         OTHERWISE
  2950.           UNGET
  2951.           EXIT
  2952.         END_CASE
  2953.       END_EXPECT
  2954.       EXIT
  2955.     END_CASE
  2956.  
  2957.     CASE (COLOUR_MAP_TOKEN)
  2958.       if (Test_Redefine(COLOUR_MAP_ID_TOKEN))
  2959.         Destroy_Colour_Map((COLOUR_MAP *)Constant_Ptr->Constant_Data);
  2960.       Local_Colour_Map = Parse_Colour_Map ();
  2961.       Constant_Ptr -> Constant_Type = COLOUR_MAP_CONSTANT;
  2962.       Constant_Ptr -> Constant_Data = (char *) Local_Colour_Map;
  2963.       EXIT
  2964.     END_CASE
  2965.  
  2966.     CASE (TRANSFORM_TOKEN)
  2967.       if (Test_Redefine(TRANSFORM_ID_TOKEN))
  2968.         Destroy_Transform((TRANSFORM *)Constant_Ptr->Constant_Data);
  2969.       Local_Trans = Parse_Transform ();
  2970.       Constant_Ptr -> Constant_Type = TRANSFORM_CONSTANT;
  2971.       Constant_Ptr -> Constant_Data = (char *) Local_Trans;
  2972.       EXIT
  2973.     END_CASE
  2974.  
  2975.     OTHERWISE
  2976.       UNGET
  2977.       if (Test_Redefine(OBJECT_ID_TOKEN))
  2978.         Destroy_Object((OBJECT *)Constant_Ptr->Constant_Data);
  2979.       Local_Object = Parse_Object ();
  2980.       Constant_Ptr -> Constant_Type = OBJECT_CONSTANT;
  2981.       Constant_Ptr -> Constant_Data = (char *) Local_Object;
  2982.       EXIT
  2983.     END_CASE
  2984.  
  2985.   END_EXPECT
  2986.   }
  2987.  
  2988. static void Link (New_Object, Field, Old_Object_List)
  2989.   OBJECT *New_Object, **Field, **Old_Object_List;
  2990.   {
  2991.   *Field = *Old_Object_List;
  2992.   *Old_Object_List = New_Object;
  2993.   }
  2994.  
  2995. static void Link_Textures (Old_Textures, New_Textures)
  2996.   TEXTURE **Old_Textures;
  2997.   TEXTURE  *New_Textures;
  2998.   {
  2999.    TEXTURE *Layer;
  3000.  
  3001.    for (Layer = New_Textures ;
  3002.         Layer->Next_Layer != NULL ;
  3003.         Layer = Layer->Next_Layer)
  3004.      {}
  3005.         Layer->Next_Layer = *Old_Textures;
  3006.         *Old_Textures = New_Textures;
  3007.   }
  3008.  
  3009. static
  3010. char *Get_Token_String (Token_Id)
  3011.   TOKEN Token_Id;
  3012.   {
  3013.   register int i;
  3014.  
  3015.   for (i = 0 ; i < LAST_TOKEN ; i++)
  3016.      if (Reserved_Words[i].Token_Number == Token_Id)
  3017.         return (Reserved_Words[i].Token_Name);
  3018.   return ("");
  3019.   }
  3020.  
  3021. static
  3022. void Where_Error ()
  3023.   {
  3024.   fprintf (stderr, "\nError in file %s line %d\n", Token.Filename,
  3025.                                                  Token.Token_Line_No+1);
  3026.   }
  3027.  
  3028. static int Test_Redefine(a)
  3029.   int a;
  3030.   {
  3031.   char *old, *new;
  3032.  
  3033.   if (Previous == IDENTIFIER_TOKEN)
  3034.     return (FALSE);
  3035.   if (Previous != a)
  3036.     {old = Get_Token_String (Previous);
  3037.      new = Get_Token_String (a);
  3038.      Where_Error ();
  3039.      fprintf (stderr, "Attempted to redefine %s as %s", old, new);
  3040.      exit (1);
  3041.     }
  3042.   return (TRUE);
  3043.   }
  3044.  
  3045. void Parse_Error (Token_Id)
  3046.   TOKEN Token_Id;
  3047.   {
  3048.   char *expected;
  3049.  
  3050.   expected = Get_Token_String (Token_Id);
  3051.   Parse_Error_Str(expected);
  3052.   }
  3053.  
  3054. void Parse_Error_Str (str)
  3055.   char *str;
  3056.   {
  3057.    Where_Error ();
  3058.    fprintf (stderr, "%s expected but", str);
  3059.    Found_Instead ();
  3060.    exit (1);
  3061.   }
  3062.  
  3063. static void Found_Instead ()
  3064.   {
  3065.   char *found;
  3066.  
  3067.   if (Token.Token_Id == IDENTIFIER_TOKEN)
  3068.     fprintf (stderr,
  3069.       " undeclared identifier '%s' found instead.\n", Token.Token_String);
  3070.   else
  3071.    {
  3072.     found = Get_Token_String (Token.Token_Id);
  3073.     fprintf (stderr, " %s found instead.\n", found);
  3074.    }
  3075.   }
  3076. /*
  3077. static void Parse_Warn (Token_Id)
  3078.   TOKEN Token_Id;
  3079.   {
  3080.   char *expected;
  3081.  
  3082.   fprintf (stderr, "\nWarning in file %s line %d\n", Token.Filename,
  3083.                                                    Token.Token_Line_No+1);
  3084.   expected = Get_Token_String (Token_Id);
  3085.   fprintf (stderr, "%s expected but", expected);
  3086.   Found_Instead ();
  3087.   }
  3088. */
  3089. static void Warn_State (Token_Id,Type)
  3090.   TOKEN Token_Id, Type;
  3091.   {
  3092.   char *found;
  3093.   char *should;
  3094.  
  3095.   if (Language_Version < 1.5)
  3096.      return;
  3097.  
  3098.   fprintf (stderr, "\nWarning in file %s line %d\n", Token.Filename,
  3099.                                                    Token.Token_Line_No+1);
  3100.   found = Get_Token_String (Token_Id);
  3101.   should = Get_Token_String (Type);
  3102.   fprintf (stderr, "Found %s that should be in %s statement", found, should);
  3103.   }
  3104.  
  3105. void Warn (str,Level)
  3106.   char *str;
  3107.   DBL Level;
  3108.   {
  3109.   if (Language_Version < Level)
  3110.     return;
  3111.     
  3112.   fprintf (stdout, "\nWarning in file %s line %d\n", Token.Filename,
  3113.                                                    Token.Token_Line_No+1);
  3114.   fputs (str, stdout);
  3115.   }
  3116.  
  3117. void Error (str)
  3118.   char *str;
  3119.   {
  3120.   Where_Error ();
  3121.   fputs (str, stderr);
  3122.   exit (1);
  3123.   }
  3124.  
  3125. void MAError (str)
  3126.   char *str;
  3127.   {
  3128.   Where_Error ();
  3129.   fprintf (stderr, "Out of memory.  Cannot allocate %s.\n",str);
  3130.   exit (1);
  3131.   }
  3132.  
  3133. /* Write a token out to the token file */
  3134.  
  3135. void Write_Token (Token_Id, Data_File)
  3136.   TOKEN Token_Id;
  3137.   DATA_FILE *Data_File;
  3138.  
  3139.   {
  3140.    Token.Token_Id = Token_Id;
  3141.    Token.Token_Line_No = Data_File->Line_Number;
  3142.    Token.Filename = Data_File->Filename;
  3143.    Token.Token_String = String;
  3144.    Token.Constant_Data = NULL;
  3145.    Token.Constant_Index = (int) Token.Token_Id - (int) LAST_TOKEN;
  3146.  
  3147.    if (Token.Constant_Index >= 0)
  3148.      {if (Token.Constant_Index <= Number_Of_Constants)
  3149.         {Token.Constant_Data = Constants[Token.Constant_Index].Constant_Data;
  3150.          switch (Constants[Token.Constant_Index].Constant_Type)
  3151.            {CASEID(COLOUR_CONSTANT,     COLOUR_ID_TOKEN)
  3152.             CASEID(VECTOR_CONSTANT,     VECTOR_ID_TOKEN)
  3153.             CASEID(FLOAT_CONSTANT,      FLOAT_ID_TOKEN)
  3154.             CASEID(PIGMENT_CONSTANT,    PIGMENT_ID_TOKEN)
  3155.             CASEID(TNORMAL_CONSTANT,    TNORMAL_ID_TOKEN)
  3156.             CASEID(FINISH_CONSTANT,     FINISH_ID_TOKEN)
  3157.             CASEID(TEXTURE_CONSTANT,    TEXTURE_ID_TOKEN)
  3158.             CASEID(OBJECT_CONSTANT,     OBJECT_ID_TOKEN)
  3159.             CASEID(COLOUR_MAP_CONSTANT, COLOUR_MAP_ID_TOKEN)
  3160.             CASEID(TRANSFORM_CONSTANT,  TRANSFORM_ID_TOKEN)
  3161.             CASEID(CAMERA_CONSTANT,     CAMERA_ID_TOKEN)
  3162.            }
  3163.         }
  3164.       else Token.Token_Id = IDENTIFIER_TOKEN;
  3165.      }
  3166.   }
  3167.  
  3168. static void Post_Process (Object,Parent)
  3169.   OBJECT *Object, *Parent;
  3170.   {
  3171.    OBJECT *Sib;
  3172.  
  3173.    if (Object == NULL)
  3174.      return;
  3175.  
  3176.    if (Parent != NULL)
  3177.      {
  3178.       if (Object->Texture == NULL)
  3179.         Object->Texture = Parent->Texture;
  3180. /*
  3181.       else
  3182.         if (Parent->Texture != NULL)
  3183.           {Local_Texture = Copy_Textures (Parent->Texture);
  3184.            Link_Textures (&(Object->Texture), Local_Texture);
  3185.           }
  3186. */ /* Removed for backward compat with 1.0.  May put back in. CEY 12/92 */
  3187.       Object->No_Shadow_Flag |= Parent->No_Shadow_Flag;
  3188.      }
  3189.      
  3190.    if (     (Object->Texture == NULL) 
  3191.         && !(Object->Type & TEXTURED_OBJECT) 
  3192.         && !(Object->Type & LIGHT_SOURCE_OBJECT))
  3193.      Object->Texture = Copy_Textures(Default_Texture);
  3194.  
  3195.    if (Object->Type & COMPOUND_OBJECT)
  3196.      {
  3197.       if (Object->Type & LIGHT_SOURCE_OBJECT)
  3198.         {
  3199.          ((LIGHT_SOURCE *)Object)->Next_Light_Source = Frame.Light_Sources;
  3200.          Frame.Light_Sources = (LIGHT_SOURCE *)Object;
  3201.         }
  3202.       for (Sib = ((CSG *)Object)->Children;
  3203.            Sib != NULL;
  3204.            Sib = Sib->Sibling)
  3205.         Post_Process(Sib, Object);
  3206.      }
  3207.    else
  3208.      {
  3209.       if (Object->Texture == NULL)
  3210.         Object->Texture = Copy_Textures(Default_Texture);
  3211.       if (Object->Texture->Type == PNF_TEXTURE) 
  3212.         if (Object->Texture->Tnormal != NULL)
  3213.           Object->Type |= DOUBLE_ILLUMINATE;
  3214.      }
  3215.    Post_Textures (Object->Texture);
  3216.    if ((Object->Type & WATER_LEVEL_OK_OBJECT) &&
  3217.        (Object->Type & IS_CHILD_OBJECT))
  3218.      Object->Methods = &Csg_Height_Field_Methods;
  3219.   }
  3220.  
  3221. static void Destroy_Constants ()
  3222.   {
  3223.    int i;
  3224.    char *Ptr;
  3225.  
  3226.    for (i=1; i <= Number_Of_Constants; i++)
  3227.      {
  3228.       Ptr = Constants[i].Constant_Data;
  3229.       switch (Constants[i].Constant_Type)
  3230.         {
  3231.          case COLOUR_CONSTANT:
  3232.            Destroy_Colour((COLOUR *)Ptr);
  3233.            break;
  3234.          case VECTOR_CONSTANT:
  3235.            Destroy_Vector((VECTOR *)Ptr);
  3236.            break;
  3237.          case FLOAT_CONSTANT:
  3238.            Destroy_Float((DBL *)Ptr);
  3239.            break;
  3240.          case PIGMENT_CONSTANT:
  3241.            Destroy_Pigment((PIGMENT *)Ptr);
  3242.            break;
  3243.          case TNORMAL_CONSTANT:
  3244.            Destroy_Tnormal((TNORMAL *)Ptr);
  3245.            break;
  3246.          case FINISH_CONSTANT:
  3247.            Destroy_Finish((FINISH *)Ptr);
  3248.            break;
  3249.          case TEXTURE_CONSTANT:
  3250.            Destroy_Textures((TEXTURE *)Ptr);
  3251.            break;
  3252.          case OBJECT_CONSTANT:
  3253.            Destroy_Object((OBJECT *)Ptr);
  3254.            break;
  3255.          case COLOUR_MAP_CONSTANT:
  3256.            Destroy_Colour_Map((COLOUR_MAP *)Ptr);
  3257.            break;
  3258.          case TRANSFORM_CONSTANT:
  3259.            Destroy_Transform((TRANSFORM *)Ptr);
  3260.            break;
  3261.          case CAMERA_CONSTANT:
  3262.            Destroy_Camera((CAMERA *)Ptr);
  3263.            break;
  3264.         }
  3265.      }
  3266.   }
  3267.  
  3268. static void Link_To_Frame (Object)
  3269.  OBJECT *Object;
  3270.  {
  3271.   OBJECT *This_Sib, *Next_Sib;
  3272.   
  3273.   if ((Object->Methods != &CSG_Union_Methods) ||
  3274.       (Object->Bound != NULL) ||
  3275.       (Object->Clip != NULL) ||
  3276.       (!Use_Slabs))
  3277.     {
  3278.      Link(Object, &(Object -> Sibling), &(Frame.Objects));
  3279.      return;
  3280.     }
  3281.   
  3282.   for (This_Sib = ((CSG *)Object)->Children;
  3283.        This_Sib != NULL;
  3284.        This_Sib = Next_Sib)
  3285.        {
  3286.         Next_Sib = This_Sib->Sibling; /*L2F changes Sibling so save it */
  3287.         Link_To_Frame (This_Sib);
  3288.        }
  3289.   Object->Texture = NULL;
  3290.   Object->Sibling = NULL;
  3291.   ((CSG *)Object)->Children = NULL;
  3292.   Destroy_Object (Object);
  3293.  }
  3294.