home *** CD-ROM | disk | FTP | other *** search
/ Stone Design / Stone Design.iso / Stone_Friends / Wave / WavesWorld / Source / IBPalettes / WW3DKit / WWEveParser.m < prev    next >
Encoding:
Text File  |  1995-05-17  |  307.3 KB  |  9,875 lines
  1. // copyright 1993 Michael B. Johnson; some portions copyright 1994, MIT
  2. // see COPYRIGHT for reuse legalities
  3. //
  4.  
  5. #import "WWEveParser.h"
  6. #include <stdlib.h>
  7. #import <ri/ri.h>
  8. #import <ctype.h>
  9. #import <strings.h>
  10.  
  11. #import "WWTCLKit.h"
  12.  
  13. #import "WWSceneClock.h"
  14.  
  15. #import <WW3DShape.h>
  16. #import <WW3DLight.h>
  17. #import <WW3DShader.h>
  18. #import <RIBCommand.h>
  19. #import <RIBAttribute.h>
  20. #import <RIBAttributeBegin.h>
  21. #import <RIBAttributeEnd.h>
  22. #import <RIBArchiveRecord.h>
  23. #import <RIBBasis.h>
  24. #import <RIBCone.h>
  25. #import <RIBColor.h>
  26. #import <RIBConcatTransform.h>
  27. #import <RIBCylinder.h>
  28. #import <RIBDeclare.h>
  29. #import <RIBDisk.h>
  30. #import <RIBGeneralPolygon.h>
  31. #import <RIBHyperboloid.h>
  32. #import <RIBIdentity.h>
  33. #import <RIBIlluminate.h>
  34. #import <RIBMakeTexture.h>
  35. #import <RIBMotionBegin.h>
  36. #import <RIBMotionEnd.h>
  37. #import <RIBNuPatch.h>
  38. #import <RIBObjectInstance.h>
  39. #import <RIBOpacity.h>
  40. #import <RIBOption.h>
  41. #import <RIBParaboloid.h>
  42. #import <RIBPatch.h>
  43. #import <RIBPatchMesh.h>
  44. #import <RIBPerspective.h>
  45. #import <RIBPointsGeneralPolygons.h>
  46. #import <RIBPointsPolygons.h>
  47. #import <RIBPolygon.h>
  48. #import <RIBRotate.h>
  49. #import <RIBScale.h>
  50. #import <RIBShadingRate.h>
  51. #import <RIBSides.h>
  52. #import <RIBSkew.h>
  53. #import <RIBSolidBegin.h>
  54. #import <RIBSolidEnd.h>
  55. #import <RIBSphere.h>
  56. #import <RIBTextureCoordinates.h>
  57. #import <RIBTorus.h>
  58. #import <RIBTransform.h>
  59. #import <RIBTransformBegin.h>
  60. #import <RIBTransformEnd.h>
  61. #import <RIBTranslate.h>
  62. #import <RIBTrimCurve.h>
  63. #import <RIBCommandList.h>
  64. #import <EveCommand.h>
  65. #import <EveProc.h>
  66. #import <WWInterp.h>
  67. #import <WWSet.h>
  68. #import <WW3DText.h>
  69. #import <WW3DSquishySphere.h>
  70. #import "WWSampleGeneratorInfo.h"
  71. #import "WWArticulatedVariableBehavior.h"
  72.  
  73. // for WWSceneClock protocol:
  74. #import <WW3DWell.h>
  75.  
  76. #import <apps/InterfaceBuilder.h>
  77.  
  78. @implementation WWEveParser
  79.  
  80. static char errBuf[1024]; 
  81.  
  82. + initialize {  [WWEveParser setVersion:6]; return self; }
  83.  
  84. int
  85. massageRIB(interp, inName, outName)
  86. Tcl_Interp  *interp; 
  87. char        *inName, *outName;
  88. {
  89.   FILE  *in, *out;
  90.   int   c, c2, quoteCount = 0, commentQuote = 0;
  91.  
  92.   /* at this point, we want to massage the rib file so that it becomes */
  93.   /* interpretable by a rib-extended tcl interp. */
  94.   /* we're assuming that this file has been run through catrib, so it doesn't have */
  95.   /* any leading spaces in front of valid commands, and that it is only ASCII. */
  96.  
  97.   in = fopen(inName, "r");
  98.   if (in == NULL)
  99.   {  sprintf(errBuf, "unable to open RIB file named <%s>\n", inName);
  100.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  101.      return 0;
  102.   }
  103.  
  104.   out = fopen(outName, "w");
  105.   if (out == NULL)
  106.   {  sprintf(errBuf, "unable to open output file %s\n", outName); 
  107.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  108.      return 0;
  109.   }
  110.   
  111.   while ((c = getc(in)) != EOF)
  112.   {  if ((c == '\n') || (c =='
  113. ')) // need to check for ctrl-Ms...
  114.      {  quoteCount = 0;
  115.         c = getc(in);
  116.         /* we want to spin until we get a character.  */
  117.         /* -  If it's a letter, we assume that the next line contains a new command */
  118.         /* -  It's it's anything else, we assume that last line is being continued */
  119.     while ( (c != EOF)  && (isspace(c))) {c = getc(in); }
  120.         if (   (c == '\"') || (c == '[') || (c == ']')  
  121.             || (c == '1')  || (c == '2') || (c == '3') || (c == '4') || (c == '5')
  122.             || (c == '6')  || (c == '7') || (c == '8') || (c == '9') || (c == '0')
  123.             || (c == '-')
  124.            )
  125.         {  if (c == '\"')
  126.            {  quoteCount++;
  127.         }
  128.            if (c != ']')
  129.            {  putc(' ', out);
  130.         }
  131.         }
  132.         else
  133.         {  putc('\n', out);
  134.         }
  135.         if (c == '#')
  136.     {  c2 = getc(in);
  137.            if (c2 == '\n') /* short spacer comment */
  138.            {  fprintf(out, "; ArchiveRecord comment ");
  139.               /* let's pretend this didn't happen and drop through...*/
  140.               c = c2;
  141.        } 
  142.            else
  143.            {  if (c2 == '#') /* it's a structure hint */
  144.           {  /* start with semi-colon in case it's in-line... */
  145.          fprintf(out, "; ArchiveRecord structure ");
  146.           }
  147.               else
  148.           {  fprintf(out, "; ArchiveRecord comment %c", c2);
  149.           }
  150.         }
  151.            /* either way, spin through until we get to EOF or \n */
  152.            commentQuote = 0;
  153.            while ((c != EOF) && (c != '\n'))
  154.            {  c = getc(in);
  155.               if ((c == '{') || (c == '}'))  // need to quote these guys so tcl doesn't flip out
  156.               {  putc('\\', out);
  157.               }
  158.               if (c == '\"')
  159.               {  if (commentQuote)
  160.                  {  putc(' ', out);
  161.                     commentQuote = 0;
  162.                  }  
  163.                  else  
  164.                  {  commentQuote = 1;
  165.                  }  
  166.               }
  167.               putc(c, out);
  168.            }
  169.         }
  170.         else
  171.         {  if (c != EOF)
  172.            {  /* might be a [ or ]... */
  173.               if (c == '[')
  174.               {  fprintf(out, " {");
  175.           }
  176.               else
  177.               {  if (c == ']')
  178.                  {  fprintf(out, "} ");
  179.              }
  180.              else
  181.                  {  putc(c, out);
  182.              }
  183.           }
  184.        }
  185.         }
  186.      }
  187.      else /* we're not at a new-line */
  188.      {  if (c == '[')  /* need to turn things like foo["bar into foo {bar */
  189.         {  putc(' ', out);
  190.            putc('{', out);
  191.            c2 = getc(in); /* if it's a ", eat it, otherwise pass it through */
  192.            if (c2 == ' ') /* one more try - if it's a space, eat it and try again */
  193.            {  putc(' ', out);
  194.               c2 = getc(in);
  195.            }
  196.            if (c2 != '"')
  197.            {  ungetc(c2, in);
  198.            }
  199.            else
  200.            {  quoteCount++;
  201.            } 
  202.         }
  203.         else
  204.         {  if (c == ']')
  205.            {  putc('}', out);
  206.               putc(' ', out);
  207.            }
  208.            else
  209.            {  if (c == '"')
  210.               {  quoteCount++;
  211.                  c2 = getc(in);
  212.                  if (c2 == ' ')  /* one more chance... */
  213.          {  c2 = getc(in);
  214.          }
  215.                  if (c2 != ']')
  216.                  {  ungetc(c2, in);
  217.                     if ((quoteCount % 2)) /* if it's an odd number, just put out <">, if it's even put out <" > */
  218.                     {  putc('\"', out);
  219.             }
  220.                     else
  221.                     {  fprintf(out, "\" ");
  222.             }
  223.                  }
  224.                  else
  225.                  {  putc('}', out);
  226.                     putc(' ', out);
  227.                  }
  228.               }
  229.               else
  230.               {  if (c == '#')
  231.          {  c2 = getc(in);
  232.                     if (c2 == '\n') /* short spacer comment */
  233.                     {  fprintf(out, "; ArchiveRecord comment ");
  234.                        /* let's pretend this didn't happen and drop through...*/
  235.                        c = c2;
  236.             } 
  237.             else
  238.                     {  if (c2 == '#') /* it's just a comment */
  239.                {  /* start with semi-colon in case it's in-line... */
  240.                           fprintf(out, "; ArchiveRecord structure ");
  241.                }
  242.                        else
  243.                {  fprintf(out, "; ArchiveRecord comment %c", c2);
  244.                }
  245.              }
  246.                     /* either way, spin through until we get to EOF or \n */
  247.                     while ((c != EOF) && (c != '\n'))
  248.                     {  c = getc(in);
  249.                        if ((c == '{') || (c == '}'))  // need to quote these guys so tcl doesn't flip out
  250.                {  putc('\\', out);
  251.                        }
  252.                        if (c == '\"')
  253.                        {  if (commentQuote)
  254.                           {  putc(' ', out);
  255.                              commentQuote = 0;
  256.                           }  
  257.                           else  
  258.                           {  commentQuote = 1;
  259.                           }  
  260.                        }
  261.                        putc(c, out);
  262.                     }
  263.          }
  264.                  else
  265.                  {  putc(c, out);
  266.          }
  267.               }
  268.        }
  269.         }
  270.     }
  271.   }
  272.  
  273.   fclose(in);
  274.   fclose(out);
  275.  
  276.   return 1;
  277. }
  278.  
  279.  
  280. RtPointer
  281. encodeFloatRIBVar(me, interp, parm, n)
  282. WWEveParser *me;
  283. Tcl_Interp *interp;
  284. char  *parm;
  285. int   n;   
  286. {
  287.   int      argc = 0, i;
  288.   RtFloat  *retValue, *retPtr;
  289.   char     **argv;
  290.  
  291.  
  292.   if (Tcl_SplitList(interp, parm, &argc, &argv) != TCL_OK)
  293.   {  strcpy(errBuf, "encodeFloatRIBVar : problem splitting list");
  294.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  295.      return RI_NULL;
  296.   }
  297.   if (argc % n)
  298.   {  sprintf(errBuf, "encodeFloatRIBVar : expected parameter to be in groups of %d", n);
  299.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  300.      free(argv);
  301.      return RI_NULL;
  302.   }
  303.   retValue = (RtFloat *)malloc(argc * sizeof(RtFloat));
  304.   if (!retValue)
  305.   {  sprintf(errBuf, "encodeFloatRIBVar : unable to malloc memory to encode float RIB variable");
  306.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  307.      free(argv);
  308.      return RI_NULL;
  309.   }
  310.   retPtr = retValue;
  311.   for (i = 0; i < argc; i ++)
  312.   {  *retPtr++ = (RtFloat)atof(argv[i]);
  313.   }
  314.   free(argv);
  315.  
  316.   list_put(me->rib_parm_list, retValue);
  317.  
  318.   return (RtPointer)retValue;
  319. }
  320.  
  321.  
  322. RtPointer
  323. encodeIntegerRIBVar(me, interp, parm, n)
  324. WWEveParser *me;
  325. Tcl_Interp *interp;
  326. char  *parm;
  327. int   n;   
  328. {
  329.   int    argc, i;
  330.   RtInt  *retValue, *retPtr;
  331.   char   **argv;
  332.  
  333.  
  334.   if (Tcl_SplitList(interp, parm, &argc, &argv) != TCL_OK)
  335.   {  strcpy(errBuf, "encodeIntegerRIBVar : problem splitting list");
  336.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  337.      return RI_NULL;
  338.   }
  339.   if (argc % n)
  340.   {  sprintf(errBuf, "encodeIntegerRIBVar : expected parameter to be in groups of %d", n);
  341.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  342.      free(argv);
  343.      return RI_NULL;
  344.   }
  345.   retValue = (RtInt *)malloc(argc * sizeof(RtInt));
  346.   if (!retValue)
  347.   {  sprintf(errBuf, "encodeIntegerRIBVar : unable to malloc memory to encode int RIB variable");
  348.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  349.      free(argv);
  350.      return RI_NULL;
  351.   }
  352.   retPtr = retValue;
  353.   for (i = 0; i < argc; i ++)
  354.   {  *retPtr++ = (RtInt)atoi(argv[i]);
  355.   }
  356.   free(argv);
  357.  
  358.   list_put(me->rib_parm_list, retValue);
  359.  
  360.   return (RtPointer)retValue;
  361. }
  362.  
  363.  
  364. RtPointer
  365. encodeStringRIBVar(me, interp, parm, n)
  366. WWEveParser *me;
  367. Tcl_Interp *interp;
  368. char  *parm;
  369. int   n;   
  370. {
  371.   char  **retValue;
  372.   int   howMany = 1 + strlen(parm);
  373.  
  374.  
  375.   retValue = (char **)malloc(sizeof(char *));
  376.   if (!retValue)
  377.   {  sprintf(errBuf, "encodeStringRIBVar : unable to malloc memory to encode string RIB variable");
  378.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  379.      return RI_NULL;
  380.   }
  381.   *retValue = (char *)malloc(howMany);
  382.   if (!*retValue)
  383.   {  sprintf(errBuf, "encodeStringRIBVar : unable to malloc memory to encode string RIB variable");
  384.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  385.      return RI_NULL;
  386.   }
  387.   strcpy(*retValue, parm);
  388.  
  389.   list_put(me->rib_parm_list, retValue);
  390.  
  391.   // I used to think this is right, but experience with the RIB client library tells me differently...
  392.   // return (RtPointer)(retValue);
  393.   // No, I was right the first time.  For the client library, the above is correct.
  394.   // for the actual prman/qrman library, passing the address is right... (sigh)
  395.   // 
  396.   return (RtPointer)(retValue);
  397. }
  398.  
  399.  
  400. RtPointer
  401. encodePointRIBVar(me, interp, parm, n)
  402. WWEveParser *me;
  403. Tcl_Interp *interp;
  404. char  *parm;
  405. int   n;   
  406. {
  407.   int      argc, i;
  408.   RtPoint  *retValue, *retPtr;
  409.   char     **argv;
  410.  
  411.  
  412.   if (Tcl_SplitList(interp, parm, &argc, &argv) != TCL_OK)
  413.   {  strcpy(errBuf, "encodePointRIBVar : problem splitting list");
  414.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  415.      return RI_NULL;
  416.   }
  417.   if (argc % (n*3))
  418.   {  sprintf(errBuf, "encodePointRIBVar : expected parameter to be in groups of %d", (n*3));
  419.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  420.      free(argv);
  421.      return RI_NULL;
  422.   }
  423.   retValue = (RtPoint *)malloc((argc/3) * sizeof(RtPoint));
  424.   if (!retValue)
  425.   {  sprintf(errBuf, "encodePointRIBVar : unable to malloc memory to encode point RIB variable");
  426.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  427.      free(argv);
  428.      return RI_NULL;
  429.   }
  430.   retPtr = retValue;
  431.   for (i = 0; i < argc; i += 3)
  432.   {  (*retPtr)[0] = (RtFloat)atof(argv[i+0]);
  433.      (*retPtr)[1] = (RtFloat)atof(argv[i+1]);
  434.      (*retPtr)[2] = (RtFloat)atof(argv[i+2]);
  435.      retPtr++;
  436.   }
  437.   free(argv);
  438.  
  439.   list_put(me->rib_parm_list, retValue);
  440.  
  441.   return (RtPointer)retValue;
  442. }
  443.  
  444.  
  445. RtPointer
  446. encodeColorRIBVar(me, interp, parm, n)
  447. WWEveParser *me;
  448. Tcl_Interp *interp;
  449. char  *parm;
  450. int   n;   
  451. {
  452.   int      argc, i;
  453.   RtColor  *retValue, *retPtr;
  454.   char     **argv;
  455.  
  456.  
  457.   if (Tcl_SplitList(interp, parm, &argc, &argv) != TCL_OK)
  458.   {  strcpy(errBuf, "encodeColorRIBVar : problem splitting list");
  459.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  460.      return RI_NULL;
  461.   }
  462.   if (argc % (n*3))
  463.   {  sprintf(errBuf, "encodeColorRIBVar : expected parameter to be in groups of %d", (n*3));
  464.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  465.      free(argv);
  466.      return RI_NULL;
  467.   }
  468.   retValue = (RtColor *)malloc((argc/3) * sizeof(RtColor));
  469.   if (!retValue)
  470.   {  sprintf(errBuf, "encodeColorRIBVar : unable to malloc memory to encode color RIB variable");
  471.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  472.      free(argv);
  473.      return RI_NULL;
  474.   }
  475.   retPtr = retValue;
  476.   for (i = 0; i < argc; i += 3)
  477.   {  (*retPtr)[0] = (RtFloat)atof(argv[i+0]);
  478.      (*retPtr)[1] = (RtFloat)atof(argv[i+1]);
  479.      (*retPtr)[2] = (RtFloat)atof(argv[i+2]);
  480.      retPtr++;
  481.   }
  482.   free(argv);
  483.  
  484.   list_put(me->rib_parm_list, retValue);
  485.  
  486.   return (RtPointer)retValue;
  487. }
  488.  
  489.  
  490. char
  491. *archiveFloatRIBVar(me, interp, parm, n)
  492. WWEveParser *me;
  493. Tcl_Interp *interp;
  494. char  *parm;
  495. int   n;   
  496. {
  497.   int      argc;
  498.   char     **argv, archiveInfo[256];
  499.  
  500.  
  501.   if (Tcl_SplitList(interp, parm, &argc, &argv) != TCL_OK)
  502.   {  strcpy(errBuf, "archiveFloatRIBVar : problem splitting list");
  503.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  504.      return RI_NULL;
  505.   }
  506.   if (argc % n)
  507.   {  sprintf(errBuf, "archiveFloatRIBVar : expected parameter to be in groups of %d", n);
  508.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  509.      free(argv);
  510.      return RI_NULL;
  511.   }
  512.   free(argv);
  513.   sprintf(archiveInfo, "[%df]", argc);
  514.   return (char *)NXCopyStringBuffer(archiveInfo);
  515. }
  516.  
  517.  
  518. char
  519. *archiveIntegerRIBVar(me, interp, parm, n)
  520. WWEveParser *me;
  521. Tcl_Interp *interp;
  522. char  *parm;
  523. int   n;   
  524. {
  525.   int    argc;
  526.   char   **argv, archiveInfo[256];
  527.  
  528.  
  529.   if (Tcl_SplitList(interp, parm, &argc, &argv) != TCL_OK)
  530.   {  strcpy(errBuf, "archiveIntegerRIBVar : problem splitting list");
  531.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  532.      return RI_NULL;
  533.   }
  534.   if (argc % n)
  535.   {  sprintf(errBuf, "archiveIntegerRIBVar : expected parameter to be in groups of %d", n);
  536.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  537.      free(argv);
  538.      return RI_NULL;
  539.   }
  540.   free(argv);
  541.   sprintf(archiveInfo, "[%di]", argc);
  542.   return (char *)NXCopyStringBuffer(archiveInfo);
  543. }
  544.  
  545.  
  546. char
  547. *archiveStringRIBVar(me, interp, parm, n)
  548. WWEveParser *me;
  549. Tcl_Interp *interp;
  550. char  *parm;
  551. int   n;   
  552. {
  553.   return (char *)NXCopyStringBuffer("*");
  554. }
  555.  
  556.  
  557. char 
  558. *archivePointRIBVar(me, interp, parm, n)
  559. WWEveParser *me;
  560. Tcl_Interp *interp;
  561. char  *parm;
  562. int   n;   
  563. {
  564.   int      argc;
  565.   char     **argv, archiveInfo[256];
  566.  
  567.  
  568.   if (Tcl_SplitList(interp, parm, &argc, &argv) != TCL_OK)
  569.   {  strcpy(errBuf, "archivePointRIBVar : problem splitting list");
  570.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  571.      return RI_NULL;
  572.   }
  573.   if (argc % (n*3))
  574.   {  sprintf(errBuf, "archivePointRIBVar : expected parameter to be in groups of %d", (n*3));
  575.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  576.      free(argv);
  577.      return RI_NULL;
  578.   }
  579.   free(argv);
  580.   sprintf(archiveInfo, "[%df]", argc);
  581.   return (char *)NXCopyStringBuffer(archiveInfo);
  582. }
  583.  
  584.  
  585. char
  586. *archiveColorRIBVar(me, interp, parm, n)
  587. WWEveParser *me;
  588. Tcl_Interp *interp;
  589. char  *parm;
  590. int   n;   
  591. {
  592.   int      argc;
  593.   char     **argv, archiveInfo[256];
  594.  
  595.  
  596.   if (Tcl_SplitList(interp, parm, &argc, &argv) != TCL_OK)
  597.   {  strcpy(errBuf, "archiveColorRIBVar : problem splitting list");
  598.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  599.      return RI_NULL;
  600.   }
  601.   if (argc % (n*3))
  602.   {  sprintf(errBuf, "archiveColorRIBVar : expected parameter to be in groups of %d", (n*3));
  603.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  604.      free(argv);
  605.      return RI_NULL;
  606.   }
  607.   free(argv);
  608.   sprintf(archiveInfo, "[%df]", argc);
  609.   return (char *)NXCopyStringBuffer(archiveInfo);
  610. }
  611.  
  612.  
  613. int
  614. printfFloatRIBVar(me, interp, parm, n, typeInfoPtr)
  615. WWEveParser *me;
  616. Tcl_Interp *interp;
  617. char  *parm;
  618. int   n;   
  619. int   *typeInfoPtr;
  620. {
  621.   int      argc;
  622.   char     **argv;
  623.  
  624.  
  625.   *typeInfoPtr = WW_FLOAT;
  626.   if (Tcl_SplitList(interp, parm, &argc, &argv) != TCL_OK)
  627.   {  strcpy(errBuf, "printfFloatRIBVar : problem splitting list");
  628.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  629.      return 0;
  630.   }
  631.   if (argc % n)
  632.   {  sprintf(errBuf, "printfFloatRIBVar : expected parameter to be in groups of %d", n);
  633.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  634.      free(argv);
  635.      return argc;
  636.   }
  637.   free(argv);
  638.   return argc;
  639. }
  640.  
  641.  
  642. int
  643. printfIntegerRIBVar(me, interp, parm, n, typeInfoPtr)
  644. WWEveParser *me;
  645. Tcl_Interp *interp;
  646. char  *parm;
  647. int   n;   
  648. int   *typeInfoPtr;
  649. {
  650.   int      argc;
  651.   char     **argv;
  652.  
  653.  
  654.   *typeInfoPtr = WW_INT;
  655.   if (Tcl_SplitList(interp, parm, &argc, &argv) != TCL_OK)
  656.   {  strcpy(errBuf, "printfIntegerRIBVar : problem splitting list");
  657.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  658.      return 0;
  659.   }
  660.   if (argc % n)
  661.   {  sprintf(errBuf, "printfIntRIBVar : expected parameter to be in groups of %d", n);
  662.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  663.      free(argv);
  664.      return argc;
  665.   }
  666.   free(argv);
  667.   return argc;
  668. }
  669.  
  670.  
  671. int
  672. printfStringRIBVar(me, interp, parm, n, typeInfoPtr)
  673. WWEveParser *me;
  674. Tcl_Interp *interp;
  675. char  *parm;
  676. int   n;   
  677. int   *typeInfoPtr;
  678. {
  679.   *typeInfoPtr = WW_STRING;
  680.   return 1;
  681. }
  682.  
  683.  
  684. int
  685. printfColorRIBVar(me, interp, parm, n, typeInfoPtr)
  686. WWEveParser *me;
  687. Tcl_Interp *interp;
  688. char  *parm;
  689. int   n;   
  690. int   *typeInfoPtr;
  691. {
  692.   int      argc;
  693.   char     **argv;
  694.  
  695.  
  696.   *typeInfoPtr = WW_COLOR;
  697.   if (Tcl_SplitList(interp, parm, &argc, &argv) != TCL_OK)
  698.   {  strcpy(errBuf, "printfColorRIBVar : problem splitting list");
  699.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  700.      return 0;
  701.   }
  702.   if (argc % (n*3))
  703.   {  sprintf(errBuf, "printfColorRIBVar : expected parameter to be in groups of %d", n);
  704.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  705.      free(argv);
  706.      return argc;
  707.   }
  708.   free(argv);
  709.   return argc;
  710. }
  711.  
  712.  
  713. int
  714. printfPointRIBVar(me, interp, parm, n, typeInfoPtr)
  715. WWEveParser *me;
  716. Tcl_Interp *interp;
  717. char  *parm;
  718. int   n;   
  719. int   *typeInfoPtr;
  720. {
  721.   int      argc;
  722.   char     **argv;
  723.  
  724.  
  725.   *typeInfoPtr = WW_POINT;
  726.   if (Tcl_SplitList(interp, parm, &argc, &argv) != TCL_OK)
  727.   {  strcpy(errBuf, "printfPointRIBVar : problem splitting list");
  728.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  729.      return 0;
  730.   }
  731.   if (argc % (n*3))
  732.   {  sprintf(errBuf, "printfPointRIBVar : expected parameter to be in groups of %d", n);
  733.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  734.      free(argv);
  735.      return argc;
  736.   }
  737.   free(argv);
  738.   return argc;
  739. }
  740.  
  741.  
  742. int
  743. declareBMRTSpecificStuff(me, interp)
  744. WWEveParser    *me;
  745. Tcl_Interp     *interp;
  746. {
  747.   RIB_var_t    *aRIBVar;
  748.  
  749.  
  750.   aRIBVar = (RIB_var_t *)malloc(sizeof(RIB_var_t));
  751.   if (!aRIBVar)
  752.   {  sprintf(errBuf, "declareBMRTSpecificStuff :  unable to malloc memory for RIB var include"); 
  753.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  754.      return 0;
  755.   }
  756.   aRIBVar->name = strcpy((char *)malloc(1 + strlen("include")), "include");
  757.   aRIBVar->n = 1;
  758.   aRIBVar->class = strcpy((char *)malloc(1 + strlen("uniform")), "uniform");
  759.   aRIBVar->type = strcpy((char *)malloc(1 + strlen("string")), "string");
  760.   aRIBVar->encodeFunc = encodeStringRIBVar;
  761.   aRIBVar->archiveFunc = archiveStringRIBVar;
  762.   aRIBVar->printfFunc = printfStringRIBVar;
  763.   aRIBVar->token = RiDeclare("include", "uniform string");
  764.   list_put(me->rib_var_list, aRIBVar);
  765.  
  766.   aRIBVar = (RIB_var_t *)malloc(sizeof(RIB_var_t));
  767.   if (!aRIBVar)
  768.   {  sprintf(errBuf, "declareBMRTSpecificStuff :  unable to malloc memory for RIB var shadows"); 
  769.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  770.      return 0;
  771.   }
  772.   aRIBVar->name = strcpy((char *)malloc(1 + strlen("shadows")), "shadows");
  773.   aRIBVar->n = 1;
  774.   aRIBVar->class = strcpy((char *)malloc(1 + strlen("uniform")), "uniform");
  775.   aRIBVar->type = strcpy((char *)malloc(1 + strlen("string")), "string");
  776.   aRIBVar->encodeFunc = encodeStringRIBVar;
  777.   aRIBVar->archiveFunc = archiveStringRIBVar;
  778.   aRIBVar->printfFunc = printfStringRIBVar;
  779.   aRIBVar->token = RiDeclare("shadows", "uniform string");
  780.   list_put(me->rib_var_list, aRIBVar);
  781.  
  782.   aRIBVar = (RIB_var_t *)malloc(sizeof(RIB_var_t));
  783.   if (!aRIBVar)
  784.   {  sprintf(errBuf, "declareBMRTSpecificStuff :  unable to malloc memory for RIB var verbosity"); 
  785.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  786.      return 0;
  787.   }
  788.   aRIBVar->name = strcpy((char *)malloc(1 + strlen("verbosity")), "verbosity");
  789.   aRIBVar->n = 1;
  790.   aRIBVar->class = strcpy((char *)malloc(1 + strlen("uniform")), "uniform");
  791.   aRIBVar->type = strcpy((char *)malloc(1 + strlen("string")), "string");
  792.   aRIBVar->encodeFunc = encodeStringRIBVar;
  793.   aRIBVar->archiveFunc = archiveStringRIBVar;
  794.   aRIBVar->printfFunc = printfStringRIBVar;
  795.   aRIBVar->token = RiDeclare("verbosity", "uniform string");
  796.   list_put(me->rib_var_list, aRIBVar);
  797.  
  798.   aRIBVar = (RIB_var_t *)malloc(sizeof(RIB_var_t));
  799.   if (!aRIBVar)
  800.   {  sprintf(errBuf, "declareBMRTSpecificStuff :  unable to malloc memory for RIB var casts_shadows"); 
  801.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  802.      return 0;
  803.   }
  804.   aRIBVar->name = strcpy((char *)malloc(1 + strlen("casts_shadows")), "casts_shadows");
  805.   aRIBVar->n = 1;
  806.   aRIBVar->class = strcpy((char *)malloc(1 + strlen("uniform")), "uniform");
  807.   aRIBVar->type = strcpy((char *)malloc(1 + strlen("string")), "string");
  808.   aRIBVar->encodeFunc = encodeStringRIBVar;
  809.   aRIBVar->archiveFunc = archiveStringRIBVar;
  810.   aRIBVar->printfFunc = printfStringRIBVar;
  811.   aRIBVar->token = RiDeclare("casts_shadows", "uniform string");
  812.   list_put(me->rib_var_list, aRIBVar);
  813.  
  814.   aRIBVar = (RIB_var_t *)malloc(sizeof(RIB_var_t));
  815.   if (!aRIBVar)
  816.   {  sprintf(errBuf, "declareBMRTSpecificStuff :  unable to malloc memory for RIB var zonal"); 
  817.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  818.      return 0;
  819.   }
  820.   aRIBVar->name = strcpy((char *)malloc(1 + strlen("zonal")), "zonal");
  821.   aRIBVar->n = 1;
  822.   aRIBVar->class = strcpy((char *)malloc(1 + strlen("uniform")), "uniform");
  823.   aRIBVar->type = strcpy((char *)malloc(1 + strlen("string")), "string");
  824.   aRIBVar->encodeFunc = encodeStringRIBVar;
  825.   aRIBVar->archiveFunc = archiveStringRIBVar;
  826.   aRIBVar->printfFunc = printfStringRIBVar;
  827.   aRIBVar->token = RiDeclare("zonal", "uniform string");
  828.   list_put(me->rib_var_list, aRIBVar);
  829.  
  830.   aRIBVar = (RIB_var_t *)malloc(sizeof(RIB_var_t));
  831.   if (!aRIBVar)
  832.   {  sprintf(errBuf, "declareBMRTSpecificStuff :  unable to malloc memory for RIB var patchsize"); 
  833.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  834.      return 0;
  835.   }
  836.   aRIBVar->name = strcpy((char *)malloc(1 + strlen("patchsize")), "patchsize");
  837.   aRIBVar->n = 1;
  838.   aRIBVar->class = strcpy((char *)malloc(1 + strlen("uniform")), "uniform");
  839.   aRIBVar->type = strcpy((char *)malloc(1 + strlen("float")), "float");
  840.   aRIBVar->encodeFunc = encodeFloatRIBVar;
  841.   aRIBVar->archiveFunc = archiveFloatRIBVar;
  842.   aRIBVar->printfFunc = printfFloatRIBVar;
  843.   aRIBVar->token = RiDeclare("patchsize", "uniform float");
  844.   list_put(me->rib_var_list, aRIBVar);
  845.  
  846.   aRIBVar = (RIB_var_t *)malloc(sizeof(RIB_var_t));
  847.   if (!aRIBVar)
  848.   {  sprintf(errBuf, "declareBMRTSpecificStuff :  unable to malloc memory for RIB var minshadowbias"); 
  849.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  850.      return 0;
  851.   }
  852.   aRIBVar->name = strcpy((char *)malloc(1 + strlen("minshadowbias")), "minshadowbias");
  853.   aRIBVar->n = 1;
  854.   aRIBVar->class = strcpy((char *)malloc(1 + strlen("uniform")), "uniform");
  855.   aRIBVar->type = strcpy((char *)malloc(1 + strlen("float")), "float");
  856.   aRIBVar->encodeFunc = encodeFloatRIBVar;
  857.   aRIBVar->archiveFunc = archiveFloatRIBVar;
  858.   aRIBVar->printfFunc = printfFloatRIBVar;
  859.   aRIBVar->token = RiDeclare("minshadowbias", "uniform float");
  860.   list_put(me->rib_var_list, aRIBVar);
  861.  
  862.   aRIBVar = (RIB_var_t *)malloc(sizeof(RIB_var_t));
  863.   if (!aRIBVar)
  864.   {  sprintf(errBuf, "declareBMRTSpecificStuff :  unable to malloc memory for RIB var minsize"); 
  865.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  866.      return 0;
  867.   }
  868.   aRIBVar->name = strcpy((char *)malloc(1 + strlen("minsize")), "minsize");
  869.   aRIBVar->n = 1;
  870.   aRIBVar->class = strcpy((char *)malloc(1 + strlen("uniform")), "uniform");
  871.   aRIBVar->type = strcpy((char *)malloc(1 + strlen("float")), "float");
  872.   aRIBVar->encodeFunc = encodeFloatRIBVar;
  873.   aRIBVar->archiveFunc = archiveFloatRIBVar;
  874.   aRIBVar->printfFunc = printfFloatRIBVar;
  875.   aRIBVar->token = RiDeclare("minsize", "uniform float");
  876.   list_put(me->rib_var_list, aRIBVar);
  877.  
  878.   aRIBVar = (RIB_var_t *)malloc(sizeof(RIB_var_t));
  879.   if (!aRIBVar)
  880.   {  sprintf(errBuf, "declareBMRTSpecificStuff :  unable to malloc memory for RIB var elemsize"); 
  881.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  882.      return 0;
  883.   }
  884.   aRIBVar->name = strcpy((char *)malloc(1 + strlen("elemsize")), "elemsize");
  885.   aRIBVar->n = 1;
  886.   aRIBVar->class = strcpy((char *)malloc(1 + strlen("uniform")), "uniform");
  887.   aRIBVar->type = strcpy((char *)malloc(1 + strlen("float")), "float");
  888.   aRIBVar->encodeFunc = encodeFloatRIBVar;
  889.   aRIBVar->archiveFunc = archiveFloatRIBVar;
  890.   aRIBVar->printfFunc = printfFloatRIBVar;
  891.   aRIBVar->token = RiDeclare("elemsize", "uniform float");
  892.   list_put(me->rib_var_list, aRIBVar);
  893.  
  894.   aRIBVar = (RIB_var_t *)malloc(sizeof(RIB_var_t));
  895.   if (!aRIBVar)
  896.   {  sprintf(errBuf, "declareBMRTSpecificStuff :  unable to malloc memory for RIB var displacement"); 
  897.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  898.      return 0;
  899.   }
  900.   aRIBVar->name = strcpy((char *)malloc(1 + strlen("displacement")), "displacement");
  901.   aRIBVar->n = 1;
  902.   aRIBVar->class = strcpy((char *)malloc(1 + strlen("uniform")), "uniform");
  903.   aRIBVar->type = strcpy((char *)malloc(1 + strlen("float")), "float");
  904.   aRIBVar->encodeFunc = encodeFloatRIBVar;
  905.   aRIBVar->archiveFunc = archiveFloatRIBVar;
  906.   aRIBVar->printfFunc = printfFloatRIBVar;
  907.   aRIBVar->token = RiDeclare("displacement", "uniform float");
  908.   list_put(me->rib_var_list, aRIBVar);
  909.  
  910.  
  911.  
  912.   aRIBVar = (RIB_var_t *)malloc(sizeof(RIB_var_t));
  913.   if (!aRIBVar)
  914.   {  sprintf(errBuf, "declareBMRTSpecificStuff :  unable to malloc memory for RIB var patch_maxlevel"); 
  915.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  916.      return 0;
  917.   }
  918.   aRIBVar->name = strcpy((char *)malloc(1 + strlen("patch_maxlevel")), "patch_maxlevel");
  919.   aRIBVar->n = 1;
  920.   aRIBVar->class = strcpy((char *)malloc(1 + strlen("uniform")), "uniform");
  921.   aRIBVar->type = strcpy((char *)malloc(1 + strlen("integer")), "integer");
  922.   aRIBVar->encodeFunc = encodeIntegerRIBVar;
  923.   aRIBVar->archiveFunc = archiveIntegerRIBVar;
  924.   aRIBVar->printfFunc = printfIntegerRIBVar;
  925.   aRIBVar->token = RiDeclare("patch_maxlevel", "uniform integer");
  926.   list_put(me->rib_var_list, aRIBVar);
  927.  
  928.   aRIBVar = (RIB_var_t *)malloc(sizeof(RIB_var_t));
  929.   if (!aRIBVar)
  930.   {  sprintf(errBuf, "declareBMRTSpecificStuff :  unable to malloc memory for RIB var max_raylevel"); 
  931.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  932.      return 0;
  933.   }
  934.   aRIBVar->name = strcpy((char *)malloc(1 + strlen("max_raylevel")), "max_raylevel");
  935.   aRIBVar->n = 1;
  936.   aRIBVar->class = strcpy((char *)malloc(1 + strlen("uniform")), "uniform");
  937.   aRIBVar->type = strcpy((char *)malloc(1 + strlen("integer")), "integer");
  938.   aRIBVar->encodeFunc = encodeIntegerRIBVar;
  939.   aRIBVar->archiveFunc = archiveIntegerRIBVar;
  940.   aRIBVar->printfFunc = printfIntegerRIBVar;
  941.   aRIBVar->token = RiDeclare("max_raylevel", "uniform integer");
  942.   list_put(me->rib_var_list, aRIBVar);
  943.  
  944.   aRIBVar = (RIB_var_t *)malloc(sizeof(RIB_var_t));
  945.   if (!aRIBVar)
  946.   {  sprintf(errBuf, "declareBMRTSpecificStuff :  unable to malloc memory for RIB var minsamples"); 
  947.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  948.      return 0;
  949.   }
  950.   aRIBVar->name = strcpy((char *)malloc(1 + strlen("minsamples")), "minsamples");
  951.   aRIBVar->n = 1;
  952.   aRIBVar->class = strcpy((char *)malloc(1 + strlen("uniform")), "uniform");
  953.   aRIBVar->type = strcpy((char *)malloc(1 + strlen("integer")), "integer");
  954.   aRIBVar->encodeFunc = encodeIntegerRIBVar;
  955.   aRIBVar->archiveFunc = archiveIntegerRIBVar;
  956.   aRIBVar->printfFunc = printfIntegerRIBVar;
  957.   aRIBVar->token = RiDeclare("minsamples", "uniform integer");
  958.   list_put(me->rib_var_list, aRIBVar);
  959.  
  960.   aRIBVar = (RIB_var_t *)malloc(sizeof(RIB_var_t));
  961.   if (!aRIBVar)
  962.   {  sprintf(errBuf, "declareBMRTSpecificStuff :  unable to malloc memory for RIB var maxsamples"); 
  963.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  964.      return 0;
  965.   }
  966.   aRIBVar->name = strcpy((char *)malloc(1 + strlen("maxsamples")), "maxsamples");
  967.   aRIBVar->n = 1;
  968.   aRIBVar->class = strcpy((char *)malloc(1 + strlen("uniform")), "uniform");
  969.   aRIBVar->type = strcpy((char *)malloc(1 + strlen("integer")), "integer");
  970.   aRIBVar->encodeFunc = encodeIntegerRIBVar;
  971.   aRIBVar->archiveFunc = archiveIntegerRIBVar;
  972.   aRIBVar->printfFunc = printfIntegerRIBVar;
  973.   aRIBVar->token = RiDeclare("maxsamples", "uniform integer");
  974.   list_put(me->rib_var_list, aRIBVar);
  975.  
  976.   aRIBVar = (RIB_var_t *)malloc(sizeof(RIB_var_t));
  977.   if (!aRIBVar)
  978.   {  sprintf(errBuf, "declareBMRTSpecificStuff :  unable to malloc memory for RIB var branch_ratio"); 
  979.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  980.      return 0;
  981.   }
  982.   aRIBVar->name = strcpy((char *)malloc(1 + strlen("branch_ratio")), "branch_ratio");
  983.   aRIBVar->n = 1;
  984.   aRIBVar->class = strcpy((char *)malloc(1 + strlen("uniform")), "uniform");
  985.   aRIBVar->type = strcpy((char *)malloc(1 + strlen("integer")), "integer");
  986.   aRIBVar->encodeFunc = encodeIntegerRIBVar;
  987.   aRIBVar->archiveFunc = archiveIntegerRIBVar;
  988.   aRIBVar->printfFunc = printfIntegerRIBVar;
  989.   aRIBVar->token = RiDeclare("branch_ratio", "uniform integer");
  990.   list_put(me->rib_var_list, aRIBVar);
  991.  
  992.   aRIBVar = (RIB_var_t *)malloc(sizeof(RIB_var_t));
  993.   if (!aRIBVar)
  994.   {  sprintf(errBuf, "declareBMRTSpecificStuff :  unable to malloc memory for RIB var max_branch_ratio"); 
  995.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  996.      return 0;
  997.   }
  998.   aRIBVar->name = strcpy((char *)malloc(1 + strlen("max_branch_ratio")), "max_branch_ratio");
  999.   aRIBVar->n = 1;
  1000.   aRIBVar->class = strcpy((char *)malloc(1 + strlen("uniform")), "uniform");
  1001.   aRIBVar->type = strcpy((char *)malloc(1 + strlen("integer")), "integer");
  1002.   aRIBVar->encodeFunc = encodeIntegerRIBVar;
  1003.   aRIBVar->archiveFunc = archiveIntegerRIBVar;
  1004.   aRIBVar->printfFunc = printfIntegerRIBVar;
  1005.   aRIBVar->token = RiDeclare("max_branch_ratio", "uniform integer");
  1006.   list_put(me->rib_var_list, aRIBVar);
  1007.  
  1008.   aRIBVar = (RIB_var_t *)malloc(sizeof(RIB_var_t));
  1009.   if (!aRIBVar)
  1010.   {  sprintf(errBuf, "declareBMRTSpecificStuff :  unable to malloc memory for RIB var binary"); 
  1011.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  1012.      return 0;
  1013.   }
  1014.   aRIBVar->name = strcpy((char *)malloc(1 + strlen("binary")), "binary");
  1015.   aRIBVar->n = 1;
  1016.   aRIBVar->class = strcpy((char *)malloc(1 + strlen("uniform")), "uniform");
  1017.   aRIBVar->type = strcpy((char *)malloc(1 + strlen("integer")), "integer");
  1018.   aRIBVar->encodeFunc = encodeIntegerRIBVar;
  1019.   aRIBVar->archiveFunc = archiveIntegerRIBVar;
  1020.   aRIBVar->printfFunc = printfIntegerRIBVar;
  1021.   aRIBVar->token = RiDeclare("binary", "uniform integer");
  1022.   list_put(me->rib_var_list, aRIBVar);
  1023.  
  1024.   aRIBVar = (RIB_var_t *)malloc(sizeof(RIB_var_t));
  1025.   if (!aRIBVar)
  1026.   {  sprintf(errBuf, "declareBMRTSpecificStuff :  unable to malloc memory for RIB var averagecolor"); 
  1027.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  1028.      return 0;
  1029.   }
  1030.   aRIBVar->name = strcpy((char *)malloc(1 + strlen("averagecolor")), "averagecolor");
  1031.   aRIBVar->n = 1;
  1032.   aRIBVar->class = strcpy((char *)malloc(1 + strlen("uniform")), "uniform");
  1033.   aRIBVar->type = strcpy((char *)malloc(1 + strlen("color")), "color");
  1034.   aRIBVar->encodeFunc = encodeColorRIBVar;
  1035.   aRIBVar->archiveFunc = archiveColorRIBVar;
  1036.   aRIBVar->printfFunc = printfColorRIBVar;
  1037.   aRIBVar->token = RiDeclare("averagecolor", "uniform color");
  1038.   list_put(me->rib_var_list, aRIBVar);
  1039.  
  1040.   aRIBVar = (RIB_var_t *)malloc(sizeof(RIB_var_t));
  1041.   if (!aRIBVar)
  1042.   {  sprintf(errBuf, "declareBMRTSpecificStuff :  unable to malloc memory for RIB var emissioncolor"); 
  1043.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  1044.      return 0;
  1045.   }
  1046.   aRIBVar->name = strcpy((char *)malloc(1 + strlen("emissioncolor")), "emissioncolor");
  1047.   aRIBVar->n = 1;
  1048.   aRIBVar->class = strcpy((char *)malloc(1 + strlen("uniform")), "uniform");
  1049.   aRIBVar->type = strcpy((char *)malloc(1 + strlen("color")), "color");
  1050.   aRIBVar->encodeFunc = encodeColorRIBVar;
  1051.   aRIBVar->archiveFunc = archiveColorRIBVar;
  1052.   aRIBVar->printfFunc = printfColorRIBVar;
  1053.   aRIBVar->token = RiDeclare("emissioncolor", "uniform color");
  1054.   list_put(me->rib_var_list, aRIBVar);
  1055.  
  1056.   return 1;
  1057. }
  1058.  
  1059.  
  1060. int
  1061. declareGESTELSpecificStuff(me, interp)
  1062. WWEveParser    *me;
  1063. Tcl_Interp     *interp;
  1064. {
  1065.   RIB_var_t    *aRIBVar;
  1066.  
  1067.  
  1068.   /* add in the few known string ones */
  1069.   aRIBVar = (RIB_var_t *)malloc(sizeof(RIB_var_t));
  1070.   if (!aRIBVar)
  1071.   {  sprintf(errBuf, "declareGESTELSpecificStuff :  unable to malloc memory for RIB var name"); 
  1072.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  1073.      return 0;
  1074.   }
  1075.   aRIBVar->name = strcpy((char *)malloc(1 + strlen("shader")), "shader");
  1076.   aRIBVar->n = 1;
  1077.   aRIBVar->class = strcpy((char *)malloc(1 + strlen("uniform")), "uniform");
  1078.   aRIBVar->type = strcpy((char *)malloc(1 + strlen("string")), "string");
  1079.   aRIBVar->encodeFunc = encodeStringRIBVar;
  1080.   aRIBVar->archiveFunc = archiveStringRIBVar;
  1081.   aRIBVar->printfFunc = printfStringRIBVar;
  1082.   aRIBVar->token = RiDeclare("shader", "uniform string");
  1083.   list_put(me->rib_var_list, aRIBVar);
  1084.  
  1085.   aRIBVar = (RIB_var_t *)malloc(sizeof(RIB_var_t));
  1086.   if (!aRIBVar)
  1087.   {  sprintf(errBuf, "declareGESTELSpecificStuff :  unable to malloc memory for RIB var name"); 
  1088.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  1089.      return 0;
  1090.   }
  1091.   aRIBVar->name = strcpy((char *)malloc(1 + strlen("texture")), "texture");
  1092.   aRIBVar->n = 1;
  1093.   aRIBVar->class = strcpy((char *)malloc(1 + strlen("uniform")), "uniform");
  1094.   aRIBVar->type = strcpy((char *)malloc(1 + strlen("string")), "string");
  1095.   aRIBVar->encodeFunc = encodeStringRIBVar;
  1096.   aRIBVar->archiveFunc = archiveStringRIBVar;
  1097.   aRIBVar->printfFunc = printfStringRIBVar;
  1098.   aRIBVar->token = RiDeclare("texture", "uniform string");
  1099.   list_put(me->rib_var_list, aRIBVar);
  1100.  
  1101.   return 1;
  1102. }
  1103.  
  1104.  
  1105. int
  1106. declarePIXARSpecificStuff(me, interp)
  1107. WWEveParser    *me;
  1108. Tcl_Interp     *interp;
  1109. {
  1110.   RIB_var_t    *aRIBVar;
  1111.  
  1112.  
  1113.   /* add in the few known string ones */
  1114.   aRIBVar = (RIB_var_t *)malloc(sizeof(RIB_var_t));
  1115.   if (!aRIBVar)
  1116.   {  sprintf(errBuf, "declarePIXARSpecificStuff :  unable to malloc memory for RIB var name"); 
  1117.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  1118.      return 0;
  1119.   }
  1120.   aRIBVar->name = strcpy((char *)malloc(1 + strlen("name")), "name");
  1121.   aRIBVar->n = 1;
  1122.   aRIBVar->class = strcpy((char *)malloc(1 + strlen("uniform")), "uniform");
  1123.   aRIBVar->type = strcpy((char *)malloc(1 + strlen("string")), "string");
  1124.   aRIBVar->encodeFunc = encodeStringRIBVar;
  1125.   aRIBVar->archiveFunc = archiveStringRIBVar;
  1126.   aRIBVar->printfFunc = printfStringRIBVar;
  1127.   aRIBVar->token = RiDeclare("name", "uniform string");
  1128.   list_put(me->rib_var_list, aRIBVar);
  1129.  
  1130.   aRIBVar = (RIB_var_t *)malloc(sizeof(RIB_var_t));
  1131.   if (!aRIBVar)
  1132.   {  sprintf(errBuf, "declarePIXARSpecificStuff :  unable to malloc memory for RIB var format"); 
  1133.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  1134.      return 0;
  1135.   }
  1136.   aRIBVar->name = strcpy((char *)malloc(1 + strlen("format")), "format");
  1137.   aRIBVar->n = 1;
  1138.   aRIBVar->class = strcpy((char *)malloc(1 + strlen("uniform")), "uniform");
  1139.   aRIBVar->type = strcpy((char *)malloc(1 + strlen("string")), "string");
  1140.   aRIBVar->encodeFunc = encodeStringRIBVar;
  1141.   aRIBVar->archiveFunc = archiveStringRIBVar;
  1142.   aRIBVar->printfFunc = printfStringRIBVar;
  1143.   aRIBVar->token = RiDeclare("format", "uniform string");
  1144.   list_put(me->rib_var_list, aRIBVar);
  1145.  
  1146.   aRIBVar = (RIB_var_t *)malloc(sizeof(RIB_var_t));
  1147.   if (!aRIBVar)
  1148.   {  sprintf(errBuf, "declarePIXARSpecificStuff :  unable to malloc memory for RIB var shadinggroup"); 
  1149.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  1150.      return 0;
  1151.   }
  1152.   aRIBVar->name = strcpy((char *)malloc(1 + strlen("shadinggroup")), "shadinggroup");
  1153.   aRIBVar->n = 1;
  1154.   aRIBVar->class = strcpy((char *)malloc(1 + strlen("uniform")), "uniform");
  1155.   aRIBVar->type = strcpy((char *)malloc(1 + strlen("string")), "string");
  1156.   aRIBVar->encodeFunc = encodeStringRIBVar;
  1157.   aRIBVar->archiveFunc = archiveStringRIBVar;
  1158.   aRIBVar->printfFunc = printfStringRIBVar;
  1159.   aRIBVar->token = RiDeclare("shadinggroup", "uniform string");
  1160.   list_put(me->rib_var_list, aRIBVar);
  1161.  
  1162.   aRIBVar = (RIB_var_t *)malloc(sizeof(RIB_var_t));
  1163.   if (!aRIBVar)
  1164.   {  sprintf(errBuf, "declarePIXARSpecificStuff :  unable to malloc memory for RIB var texturename"); 
  1165.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  1166.      return 0;
  1167.   }
  1168.   aRIBVar->name = strcpy((char *)malloc(1 + strlen("texturename")), "texturename");
  1169.   aRIBVar->n = 1;
  1170.   aRIBVar->class = strcpy((char *)malloc(1 + strlen("uniform")), "uniform");
  1171.   aRIBVar->type = strcpy((char *)malloc(1 + strlen("string")), "string");
  1172.   aRIBVar->encodeFunc = encodeStringRIBVar;
  1173.   aRIBVar->archiveFunc = archiveStringRIBVar;
  1174.   aRIBVar->printfFunc = printfStringRIBVar;
  1175.   aRIBVar->token = RiDeclare("texturename", "uniform string");
  1176.   list_put(me->rib_var_list, aRIBVar);
  1177.  
  1178.   aRIBVar = (RIB_var_t *)malloc(sizeof(RIB_var_t));
  1179.   if (!aRIBVar)
  1180.   {  sprintf(errBuf, "declarePIXARSpecificStuff :  unable to malloc memory for RIB var lightcolor"); 
  1181.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  1182.      return 0;
  1183.   }
  1184.   aRIBVar->name = strcpy((char *)malloc(1 + strlen("lightcolor")), "lightcolor");
  1185.   aRIBVar->n = 1;
  1186.   aRIBVar->class = strcpy((char *)malloc(1 + strlen("uniform")), "uniform");
  1187.   aRIBVar->type = strcpy((char *)malloc(1 + strlen("color")), "color");
  1188.   aRIBVar->encodeFunc = encodeColorRIBVar;
  1189.   aRIBVar->archiveFunc = archiveColorRIBVar;
  1190.   aRIBVar->printfFunc = printfColorRIBVar;
  1191.   aRIBVar->token = RiDeclare("lightcolor", "uniform color");
  1192.   list_put(me->rib_var_list, aRIBVar);
  1193.  
  1194.   aRIBVar = (RIB_var_t *)malloc(sizeof(RIB_var_t));
  1195.   if (!aRIBVar)
  1196.   {  sprintf(errBuf, "declarePIXARSpecificStuff :  unable to malloc memory for RIB var zthreshold"); 
  1197.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  1198.      return 0;
  1199.   }
  1200.   aRIBVar->name = strcpy((char *)malloc(1 + strlen("zthreshold")), "zthreshold");
  1201.   aRIBVar->n = 1;
  1202.   aRIBVar->class = strcpy((char *)malloc(1 + strlen("uniform")), "uniform");
  1203.   aRIBVar->type = strcpy((char *)malloc(1 + strlen("color")), "color");
  1204.   aRIBVar->encodeFunc = encodeColorRIBVar;
  1205.   aRIBVar->archiveFunc = archiveColorRIBVar;
  1206.   aRIBVar->printfFunc = printfColorRIBVar;
  1207.   aRIBVar->token = RiDeclare("zthreshold", "uniform color");
  1208.   list_put(me->rib_var_list, aRIBVar);
  1209.  
  1210.   aRIBVar = (RIB_var_t *)malloc(sizeof(RIB_var_t));
  1211.   if (!aRIBVar)
  1212.   {  sprintf(errBuf, "declarePIXARSpecificStuff :  unable to malloc memory for RIB var Ng"); 
  1213.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  1214.      return 0;
  1215.   }
  1216.   aRIBVar->name = strcpy((char *)malloc(1 + strlen("Ng")), "Ng");
  1217.   aRIBVar->n = 1;
  1218.   aRIBVar->class = strcpy((char *)malloc(1 + strlen("uniform")), "uniform");
  1219.   aRIBVar->type = strcpy((char *)malloc(1 + strlen("point")), "point");
  1220.   aRIBVar->encodeFunc = encodePointRIBVar;
  1221.   aRIBVar->archiveFunc = archivePointRIBVar;
  1222.   aRIBVar->printfFunc = printfPointRIBVar;
  1223.   aRIBVar->token = RiDeclare("Ng", "uniform point");
  1224.   list_put(me->rib_var_list, aRIBVar);
  1225.  
  1226.   aRIBVar = (RIB_var_t *)malloc(sizeof(RIB_var_t));
  1227.   if (!aRIBVar)
  1228.   {  sprintf(errBuf, "declarePIXARSpecificStuff :  unable to malloc memory for RIB var to"); 
  1229.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  1230.      return 0;
  1231.   }
  1232.   aRIBVar->name = strcpy((char *)malloc(1 + strlen("to")), "to");
  1233.   aRIBVar->n = 1;
  1234.   aRIBVar->class = strcpy((char *)malloc(1 + strlen("uniform")), "uniform");
  1235.   aRIBVar->type = strcpy((char *)malloc(1 + strlen("point")), "point");
  1236.   aRIBVar->encodeFunc = encodePointRIBVar;
  1237.   aRIBVar->archiveFunc = archivePointRIBVar;
  1238.   aRIBVar->printfFunc = printfPointRIBVar;
  1239.   aRIBVar->token = RiDeclare("to", "uniform point");
  1240.   list_put(me->rib_var_list, aRIBVar);
  1241.  
  1242.   aRIBVar = (RIB_var_t *)malloc(sizeof(RIB_var_t));
  1243.   if (!aRIBVar)
  1244.   {  sprintf(errBuf, "declarePIXARSpecificStuff :  unable to malloc memory for RIB var from"); 
  1245.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  1246.      return 0;
  1247.   }
  1248.   aRIBVar->name = strcpy((char *)malloc(1 + strlen("from")), "from");
  1249.   aRIBVar->n = 1;
  1250.   aRIBVar->class = strcpy((char *)malloc(1 + strlen("uniform")), "uniform");
  1251.   aRIBVar->type = strcpy((char *)malloc(1 + strlen("point")), "point");
  1252.   aRIBVar->encodeFunc = encodePointRIBVar;
  1253.   aRIBVar->archiveFunc = archivePointRIBVar;
  1254.   aRIBVar->printfFunc = printfPointRIBVar;
  1255.   aRIBVar->token = RiDeclare("from", "uniform point");
  1256.   list_put(me->rib_var_list, aRIBVar);
  1257.  
  1258.   aRIBVar = (RIB_var_t *)malloc(sizeof(RIB_var_t));
  1259.   if (!aRIBVar)
  1260.   {  sprintf(errBuf, "declarePIXARSpecificStuff :  unable to malloc memory for RIB var binary"); 
  1261.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  1262.      return 0;
  1263.   }
  1264.   aRIBVar->name = strcpy((char *)malloc(1 + strlen("binary")), "binary");
  1265.   aRIBVar->n = 1;
  1266.   aRIBVar->class = strcpy((char *)malloc(1 + strlen("uniform")), "uniform");
  1267.   aRIBVar->type = strcpy((char *)malloc(1 + strlen("integer")), "integer");
  1268.   aRIBVar->encodeFunc = encodeIntegerRIBVar;
  1269.   aRIBVar->archiveFunc = archiveIntegerRIBVar;
  1270.   aRIBVar->printfFunc = printfIntegerRIBVar;
  1271.   aRIBVar->token = RiDeclare("binary", "uniform integer");
  1272.   list_put(me->rib_var_list, aRIBVar);
  1273.  
  1274.   aRIBVar = (RIB_var_t *)malloc(sizeof(RIB_var_t));
  1275.   if (!aRIBVar)
  1276.   {  sprintf(errBuf, "declarePIXARSpecificStuff :  unable to malloc memory for RIB var gridsize"); 
  1277.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  1278.      return 0;
  1279.   }
  1280.   aRIBVar->name = strcpy((char *)malloc(1 + strlen("gridsize")), "gridsize");
  1281.   aRIBVar->n = 1;
  1282.   aRIBVar->class = strcpy((char *)malloc(1 + strlen("uniform")), "uniform");
  1283.   aRIBVar->type = strcpy((char *)malloc(1 + strlen("integer")), "integer");
  1284.   aRIBVar->encodeFunc = encodeIntegerRIBVar;
  1285.   aRIBVar->archiveFunc = archiveIntegerRIBVar;
  1286.   aRIBVar->printfFunc = printfIntegerRIBVar;
  1287.   aRIBVar->token = RiDeclare("gridsize", "uniform integer");
  1288.   list_put(me->rib_var_list, aRIBVar);
  1289.  
  1290.   aRIBVar = (RIB_var_t *)malloc(sizeof(RIB_var_t));
  1291.   if (!aRIBVar)
  1292.   {  sprintf(errBuf, "declarePIXARSpecificStuff :  unable to malloc memory for RIB var eyesplits"); 
  1293.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  1294.      return 0;
  1295.   }
  1296.   aRIBVar->name = strcpy((char *)malloc(1 + strlen("eyesplits")), "eyesplits");
  1297.   aRIBVar->n = 1;
  1298.   aRIBVar->class = strcpy((char *)malloc(1 + strlen("uniform")), "uniform");
  1299.   aRIBVar->type = strcpy((char *)malloc(1 + strlen("integer")), "integer");
  1300.   aRIBVar->encodeFunc = encodeIntegerRIBVar;
  1301.   aRIBVar->archiveFunc = archiveIntegerRIBVar;
  1302.   aRIBVar->printfFunc = printfIntegerRIBVar;
  1303.   aRIBVar->token = RiDeclare("eyesplits", "uniform integer");
  1304.   list_put(me->rib_var_list, aRIBVar);
  1305.  
  1306.   aRIBVar = (RIB_var_t *)malloc(sizeof(RIB_var_t));
  1307.   if (!aRIBVar)
  1308.   {  sprintf(errBuf, "declarePIXARSpecificStuff :  unable to malloc memory for RIB var bucketsize"); 
  1309.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  1310.      return 0;
  1311.   }
  1312.   aRIBVar->name = strcpy((char *)malloc(1 + strlen("bucketsize")), "bucketsize");
  1313.   aRIBVar->n = 2;
  1314.   aRIBVar->class = strcpy((char *)malloc(1 + strlen("uniform")), "uniform");
  1315.   aRIBVar->type = strcpy((char *)malloc(1 + strlen("integer")), "integer");
  1316.   aRIBVar->encodeFunc = encodeIntegerRIBVar;
  1317.   aRIBVar->archiveFunc = archiveIntegerRIBVar;
  1318.   aRIBVar->printfFunc = printfIntegerRIBVar;
  1319.   aRIBVar->token = RiDeclare("bucketsize", "uniform integer[2]");
  1320.   list_put(me->rib_var_list, aRIBVar);
  1321.  
  1322.   aRIBVar = (RIB_var_t *)malloc(sizeof(RIB_var_t));
  1323.   if (!aRIBVar)
  1324.   {  sprintf(errBuf, "declarePIXARSpecificStuff :  unable to malloc memory for RIB var endofframe"); 
  1325.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  1326.      return 0;
  1327.   }
  1328.   aRIBVar->name = strcpy((char *)malloc(1 + strlen("endofframe")), "endofframe");
  1329.   aRIBVar->n = 1;
  1330.   aRIBVar->class = strcpy((char *)malloc(1 + strlen("uniform")), "uniform");
  1331.   aRIBVar->type = strcpy((char *)malloc(1 + strlen("integer")), "integer");
  1332.   aRIBVar->encodeFunc = encodeIntegerRIBVar;
  1333.   aRIBVar->archiveFunc = archiveIntegerRIBVar;
  1334.   aRIBVar->printfFunc = printfIntegerRIBVar;
  1335.   aRIBVar->token = RiDeclare("endofframe", "uniform integer");
  1336.   list_put(me->rib_var_list, aRIBVar);
  1337.  
  1338.   aRIBVar = (RIB_var_t *)malloc(sizeof(RIB_var_t));
  1339.   if (!aRIBVar)
  1340.   {  sprintf(errBuf, "declarePIXARSpecificStuff :  unable to malloc memory for RIB var dynamic"); 
  1341.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  1342.      return 0;
  1343.   }
  1344.   aRIBVar->name = strcpy((char *)malloc(1 + strlen("dynamic")), "dynamic");
  1345.   aRIBVar->n = 1;
  1346.   aRIBVar->class = strcpy((char *)malloc(1 + strlen("uniform")), "uniform");
  1347.   aRIBVar->type = strcpy((char *)malloc(1 + strlen("integer")), "integer");
  1348.   aRIBVar->encodeFunc = encodeIntegerRIBVar;
  1349.   aRIBVar->archiveFunc = archiveIntegerRIBVar;
  1350.   aRIBVar->printfFunc = printfIntegerRIBVar;
  1351.   aRIBVar->token = RiDeclare("dynamic", "uniform integer");
  1352.   list_put(me->rib_var_list, aRIBVar);
  1353.  
  1354.   aRIBVar = (RIB_var_t *)malloc(sizeof(RIB_var_t));
  1355.   if (!aRIBVar)
  1356.   {  sprintf(errBuf, "declarePIXARSpecificStuff :  unable to malloc memory for RIB var texturememory"); 
  1357.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  1358.      return 0;
  1359.   }
  1360.   aRIBVar->name = strcpy((char *)malloc(1 + strlen("texturememory")), "texturememory");
  1361.   aRIBVar->n = 1;
  1362.   aRIBVar->class = strcpy((char *)malloc(1 + strlen("uniform")), "uniform");
  1363.   aRIBVar->type = strcpy((char *)malloc(1 + strlen("integer")), "integer");
  1364.   aRIBVar->encodeFunc = encodeIntegerRIBVar;
  1365.   aRIBVar->archiveFunc = archiveIntegerRIBVar;
  1366.   aRIBVar->printfFunc = printfIntegerRIBVar;
  1367.   aRIBVar->token = RiDeclare("texturememory", "uniform integer");
  1368.   list_put(me->rib_var_list, aRIBVar);
  1369.  
  1370.   aRIBVar = (RIB_var_t *)malloc(sizeof(RIB_var_t));
  1371.   if (!aRIBVar)
  1372.   {  sprintf(errBuf, "declarePIXARSpecificStuff :  unable to malloc memory for RIB var subwindow"); 
  1373.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  1374.      return 0;
  1375.   }
  1376.   aRIBVar->name = strcpy((char *)malloc(1 + strlen("subwindow")), "subwindow");
  1377.   aRIBVar->n = 5;
  1378.   aRIBVar->class = strcpy((char *)malloc(1 + strlen("uniform")), "uniform");
  1379.   aRIBVar->type = strcpy((char *)malloc(1 + strlen("integer")), "integer");
  1380.   aRIBVar->encodeFunc = encodeIntegerRIBVar;
  1381.   aRIBVar->archiveFunc = archiveIntegerRIBVar;
  1382.   aRIBVar->printfFunc = printfIntegerRIBVar;
  1383.   aRIBVar->token = RiDeclare("subwindow", "uniform integer[5]");
  1384.   list_put(me->rib_var_list, aRIBVar);
  1385.  
  1386.   aRIBVar = (RIB_var_t *)malloc(sizeof(RIB_var_t));
  1387.   if (!aRIBVar)
  1388.   {  sprintf(errBuf, "declarePIXARSpecificStuff :  unable to malloc memory for RIB var bucketstride"); 
  1389.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  1390.      return 0;
  1391.   }
  1392.   aRIBVar->name = strcpy((char *)malloc(1 + strlen("bucketstride")), "bucketstride");
  1393.   aRIBVar->n = 2;
  1394.   aRIBVar->class = strcpy((char *)malloc(1 + strlen("uniform")), "uniform");
  1395.   aRIBVar->type = strcpy((char *)malloc(1 + strlen("integer")), "integer");
  1396.   aRIBVar->encodeFunc = encodeIntegerRIBVar;
  1397.   aRIBVar->archiveFunc = archiveIntegerRIBVar;
  1398.   aRIBVar->printfFunc = printfIntegerRIBVar;
  1399.   aRIBVar->token = RiDeclare("bucketstride", "uniform integer[2]");
  1400.   list_put(me->rib_var_list, aRIBVar);
  1401.  
  1402.   aRIBVar = (RIB_var_t *)malloc(sizeof(RIB_var_t));
  1403.   if (!aRIBVar)
  1404.   {  sprintf(errBuf, "declarePIXARSpecificStuff :  unable to malloc memory for RIB var merge"); 
  1405.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  1406.      return 0;
  1407.   }
  1408.   aRIBVar->name = strcpy((char *)malloc(1 + strlen("merge")), "merge");
  1409.   aRIBVar->n = 1;
  1410.   aRIBVar->class = strcpy((char *)malloc(1 + strlen("uniform")), "uniform");
  1411.   aRIBVar->type = strcpy((char *)malloc(1 + strlen("integer")), "integer");
  1412.   aRIBVar->encodeFunc = encodeIntegerRIBVar;
  1413.   aRIBVar->archiveFunc = archiveIntegerRIBVar;
  1414.   aRIBVar->printfFunc = printfIntegerRIBVar;
  1415.   aRIBVar->token = RiDeclare("merge", "uniform integer");
  1416.   list_put(me->rib_var_list, aRIBVar);
  1417.  
  1418.   aRIBVar = (RIB_var_t *)malloc(sizeof(RIB_var_t));
  1419.   if (!aRIBVar)
  1420.   {  sprintf(errBuf, "declarePIXARSpecificStuff :  unable to malloc memory for RIB var jitter"); 
  1421.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  1422.      return 0;
  1423.   }
  1424.   aRIBVar->name = strcpy((char *)malloc(1 + strlen("jitter")), "jitter");
  1425.   aRIBVar->n = 1;
  1426.   aRIBVar->class = strcpy((char *)malloc(1 + strlen("uniform")), "uniform");
  1427.   aRIBVar->type = strcpy((char *)malloc(1 + strlen("integer")), "integer");
  1428.   aRIBVar->encodeFunc = encodeIntegerRIBVar;
  1429.   aRIBVar->archiveFunc = archiveIntegerRIBVar;
  1430.   aRIBVar->printfFunc = printfIntegerRIBVar;
  1431.   aRIBVar->token = RiDeclare("jitter", "uniform integer");
  1432.   list_put(me->rib_var_list, aRIBVar);
  1433.  
  1434.   aRIBVar = (RIB_var_t *)malloc(sizeof(RIB_var_t));
  1435.   if (!aRIBVar)
  1436.   {  sprintf(errBuf, "declarePIXARSpecificStuff :  unable to malloc memory for RIB var intensity"); 
  1437.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  1438.      return 0;
  1439.   }
  1440.   aRIBVar->name = strcpy((char *)malloc(1 + strlen("intensity")), "intensity");
  1441.   aRIBVar->n = 1;
  1442.   aRIBVar->class = strcpy((char *)malloc(1 + strlen("uniform")), "uniform");
  1443.   aRIBVar->type = strcpy((char *)malloc(1 + strlen("float")), "float");
  1444.   aRIBVar->encodeFunc = encodeFloatRIBVar;
  1445.   aRIBVar->archiveFunc = archiveFloatRIBVar;
  1446.   aRIBVar->printfFunc = printfFloatRIBVar;
  1447.   aRIBVar->token = RiDeclare("intensity", "uniform float");
  1448.   list_put(me->rib_var_list, aRIBVar);
  1449.  
  1450.   aRIBVar = (RIB_var_t *)malloc(sizeof(RIB_var_t));
  1451.   if (!aRIBVar)
  1452.   {  sprintf(errBuf, "declarePIXARSpecificStuff :  unable to malloc memory for RIB var displacement"); 
  1453.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  1454.      return 0;
  1455.   }
  1456.   aRIBVar->name = strcpy((char *)malloc(1 + strlen("displacement")), "displacement");
  1457.   aRIBVar->n = 1;
  1458.   aRIBVar->class = strcpy((char *)malloc(1 + strlen("uniform")), "uniform");
  1459.   aRIBVar->type = strcpy((char *)malloc(1 + strlen("float")), "float");
  1460.   aRIBVar->encodeFunc = encodeFloatRIBVar;
  1461.   aRIBVar->archiveFunc = archiveFloatRIBVar;
  1462.   aRIBVar->printfFunc = printfFloatRIBVar;
  1463.   aRIBVar->token = RiDeclare("displacement", "uniform float");
  1464.   list_put(me->rib_var_list, aRIBVar);
  1465.  
  1466.   aRIBVar = (RIB_var_t *)malloc(sizeof(RIB_var_t));
  1467.   if (!aRIBVar)
  1468.   {  sprintf(errBuf, "declarePIXARSpecificStuff :  unable to malloc memory for RIB var extremedisplacement"); 
  1469.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  1470.      return 0;
  1471.   }
  1472.   aRIBVar->name = strcpy((char *)malloc(1 + strlen("extremedisplacement")), "extremedisplacement");
  1473.   aRIBVar->n = 1;
  1474.   aRIBVar->class = strcpy((char *)malloc(1 + strlen("uniform")), "uniform");
  1475.   aRIBVar->type = strcpy((char *)malloc(1 + strlen("float")), "float");
  1476.   aRIBVar->encodeFunc = encodeFloatRIBVar;
  1477.   aRIBVar->archiveFunc = archiveFloatRIBVar;
  1478.   aRIBVar->printfFunc = printfFloatRIBVar;
  1479.   aRIBVar->token = RiDeclare("extremedisplacement", "uniform float");
  1480.   list_put(me->rib_var_list, aRIBVar);
  1481.  
  1482.   aRIBVar = (RIB_var_t *)malloc(sizeof(RIB_var_t));
  1483.   if (!aRIBVar)
  1484.   {  sprintf(errBuf, "declarePIXARSpecificStuff :  unable to malloc memory for RIB var gridarea"); 
  1485.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  1486.      return 0;
  1487.   }
  1488.   aRIBVar->name = strcpy((char *)malloc(1 + strlen("gridarea")), "gridarea");
  1489.   aRIBVar->n = 2;
  1490.   aRIBVar->class = strcpy((char *)malloc(1 + strlen("uniform")), "uniform");
  1491.   aRIBVar->type = strcpy((char *)malloc(1 + strlen("float")), "float");
  1492.   aRIBVar->encodeFunc = encodeFloatRIBVar;
  1493.   aRIBVar->archiveFunc = archiveFloatRIBVar;
  1494.   aRIBVar->printfFunc = printfFloatRIBVar;
  1495.   aRIBVar->token = RiDeclare("gridarea", "uniform float[2]");
  1496.   list_put(me->rib_var_list, aRIBVar);
  1497.  
  1498.   aRIBVar = (RIB_var_t *)malloc(sizeof(RIB_var_t));
  1499.   if (!aRIBVar)
  1500.   {  sprintf(errBuf, "declarePIXARSpecificStuff :  unable to malloc memory for RIB var nearhither"); 
  1501.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  1502.      return 0;
  1503.   }
  1504.   aRIBVar->name = strcpy((char *)malloc(1 + strlen("nearhither")), "nearhither");
  1505.   aRIBVar->n = 1;
  1506.   aRIBVar->class = strcpy((char *)malloc(1 + strlen("uniform")), "uniform");
  1507.   aRIBVar->type = strcpy((char *)malloc(1 + strlen("float")), "float");
  1508.   aRIBVar->encodeFunc = encodeFloatRIBVar;
  1509.   aRIBVar->archiveFunc = archiveFloatRIBVar;
  1510.   aRIBVar->printfFunc = printfFloatRIBVar;
  1511.   aRIBVar->token = RiDeclare("nearhither", "uniform float");
  1512.   list_put(me->rib_var_list, aRIBVar);
  1513.  
  1514.   aRIBVar = (RIB_var_t *)malloc(sizeof(RIB_var_t));
  1515.   if (!aRIBVar)
  1516.   {  sprintf(errBuf, "declarePIXARSpecificStuff :  unable to malloc memory for RIB var epsilon1"); 
  1517.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  1518.      return 0;
  1519.   }
  1520.   aRIBVar->name = strcpy((char *)malloc(1 + strlen("epsilon1")), "epsilon1");
  1521.   aRIBVar->n = 1;
  1522.   aRIBVar->class = strcpy((char *)malloc(1 + strlen("uniform")), "uniform");
  1523.   aRIBVar->type = strcpy((char *)malloc(1 + strlen("float")), "float");
  1524.   aRIBVar->encodeFunc = encodeFloatRIBVar;
  1525.   aRIBVar->archiveFunc = archiveFloatRIBVar;
  1526.   aRIBVar->printfFunc = printfFloatRIBVar;
  1527.   aRIBVar->token = RiDeclare("epsilon1", "uniform float");
  1528.   list_put(me->rib_var_list, aRIBVar);
  1529.  
  1530.   aRIBVar = (RIB_var_t *)malloc(sizeof(RIB_var_t));
  1531.   if (!aRIBVar)
  1532.   {  sprintf(errBuf, "declarePIXARSpecificStuff :  unable to malloc memory for RIB var epsilon2"); 
  1533.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  1534.      return 0;
  1535.   }
  1536.   aRIBVar->name = strcpy((char *)malloc(1 + strlen("epsilon2")), "epsilon2");
  1537.   aRIBVar->n = 1;
  1538.   aRIBVar->class = strcpy((char *)malloc(1 + strlen("uniform")), "uniform");
  1539.   aRIBVar->type = strcpy((char *)malloc(1 + strlen("float")), "float");
  1540.   aRIBVar->encodeFunc = encodeFloatRIBVar;
  1541.   aRIBVar->archiveFunc = archiveFloatRIBVar;
  1542.   aRIBVar->printfFunc = printfFloatRIBVar;
  1543.   aRIBVar->token = RiDeclare("epsilon2", "uniform float");
  1544.   list_put(me->rib_var_list, aRIBVar);
  1545.  
  1546.   aRIBVar = (RIB_var_t *)malloc(sizeof(RIB_var_t));
  1547.   if (!aRIBVar)
  1548.   {  sprintf(errBuf, "declarePIXARSpecificStuff :  unable to malloc memory for RIB var bias0"); 
  1549.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  1550.      return 0;
  1551.   }
  1552.   aRIBVar->name = strcpy((char *)malloc(1 + strlen("bias0")), "bias0");
  1553.   aRIBVar->n = 1;
  1554.   aRIBVar->class = strcpy((char *)malloc(1 + strlen("uniform")), "uniform");
  1555.   aRIBVar->type = strcpy((char *)malloc(1 + strlen("float")), "float");
  1556.   aRIBVar->encodeFunc = encodeFloatRIBVar;
  1557.   aRIBVar->archiveFunc = archiveFloatRIBVar;
  1558.   aRIBVar->printfFunc = printfFloatRIBVar;
  1559.   aRIBVar->token = RiDeclare("bias0", "uniform float");
  1560.   list_put(me->rib_var_list, aRIBVar);
  1561.  
  1562.   aRIBVar = (RIB_var_t *)malloc(sizeof(RIB_var_t));
  1563.   if (!aRIBVar)
  1564.   {  sprintf(errBuf, "declarePIXARSpecificStuff :  unable to malloc memory for RIB var bias1"); 
  1565.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  1566.      return 0;
  1567.   }
  1568.   aRIBVar->name = strcpy((char *)malloc(1 + strlen("bias1")), "bias1");
  1569.   aRIBVar->n = 1;
  1570.   aRIBVar->class = strcpy((char *)malloc(1 + strlen("uniform")), "uniform");
  1571.   aRIBVar->type = strcpy((char *)malloc(1 + strlen("float")), "float");
  1572.   aRIBVar->encodeFunc = encodeFloatRIBVar;
  1573.   aRIBVar->archiveFunc = archiveFloatRIBVar;
  1574.   aRIBVar->printfFunc = printfFloatRIBVar;
  1575.   aRIBVar->token = RiDeclare("bias1", "uniform float");
  1576.   list_put(me->rib_var_list, aRIBVar);
  1577.  
  1578.   aRIBVar = (RIB_var_t *)malloc(sizeof(RIB_var_t));
  1579.   if (!aRIBVar)
  1580.   {  sprintf(errBuf, "declarePIXARSpecificStuff :  unable to malloc memory for RIB var vfxinstance"); 
  1581.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  1582.      return 0;
  1583.   }
  1584.   aRIBVar->name = strcpy((char *)malloc(1 + strlen("vfxinstance")), "vfxinstance");
  1585.   aRIBVar->n = 1;
  1586.   aRIBVar->class = strcpy((char *)malloc(1 + strlen("uniform")), "uniform");
  1587.   aRIBVar->type = strcpy((char *)malloc(1 + strlen("string")), "string");
  1588.   aRIBVar->encodeFunc = encodeStringRIBVar;
  1589.   aRIBVar->archiveFunc = archiveStringRIBVar;
  1590.   aRIBVar->printfFunc = printfStringRIBVar;
  1591.   aRIBVar->token = RiDeclare("texturename", "uniform string");
  1592.   list_put(me->rib_var_list, aRIBVar);
  1593.  
  1594.   return 1;
  1595. }
  1596.  
  1597.  
  1598. RIB_var_t
  1599. *getRIBVarGivenName(me, name)
  1600. WWEveParser  *me;
  1601. char          *name;
  1602. {
  1603.   int        i, howMany = list_size(me->rib_var_list);
  1604.   RIB_var_t  *aRIBVar;
  1605.  
  1606.  
  1607.   /* is it a user defined token? */
  1608.   for (i = 0; i < howMany; i++)
  1609.   {  aRIBVar = (RIB_var_t *)list_get_nth(me->rib_var_list, i);
  1610.      if (!strcmp(aRIBVar->name, name))
  1611.      {  return (aRIBVar);
  1612.      }
  1613.   }
  1614.   return (RIB_var_t *)NULL;
  1615. }
  1616.  
  1617.  
  1618. /* NOTE: need a way to map declares and types to user defined tokens.
  1619.          Shouldn't be too hard...  we should just have some static 
  1620.          pointer to a dynamic table.  The table should get initialized 
  1621.          when RiBegin() is called.  It needs to contain 5 lists: the 
  1622.      names of the tokens which correspond to each of the RenderMan 
  1623.      types that can be declared using 
  1624.      RiDeclare() (point|color|float|integer|string).
  1625.  */
  1626.  
  1627. /* need to make these macros give up immediately if (!x) */
  1628. /* wave! need to add the new tokens I've added in additions to the declareXXXStuff() routines */
  1629.  
  1630. #define isColorToken(x, n) ((n) && (   ((x == RI_CS)) || ((x == RI_OS)) \
  1631.                                     || ((x == RI_LIGHTCOLOR)) || ((x == RI_SPECULARCOLOR)) || ((x == RI_BACKGROUND)) \
  1632.                                     || ((x == RI_RGB)) || ((!strcmp(n, "zthreshold")))))
  1633.  
  1634. #define isPointToken(x, n) ((n) && (   ((x == RI_P)) || ((x == RI_N)) \
  1635.                                     || ((x == RI_NP)) || ((!strcmp(n, "Ng"))) || ((x == RI_FROM)) \
  1636.                                     || ((x == RI_TO))))
  1637.  
  1638. #define isIntegerToken(x, n) ((n) && (   ((!strcmp(n, "binary"))) || ((!strcmp(n, "gridsize"))) || ((!strcmp(n, "eyesplits"))) \
  1639.                                       || ((!strcmp(n, "bucketsize"))) || ((!strcmp(n, "endofframe"))) \
  1640.                                       || ((!strcmp(n, "dynamic"))) || ((!strcmp(n, "texturememory"))) || ((!strcmp(n, "subwindow"))) \
  1641.                                       || ((!strcmp(n, "bucketstride"))) || ((!strcmp(n, "merge"))) || ((x == RI_ORIGIN)) \
  1642.                                       || ((!strcmp(n, "jitter")))))
  1643.  
  1644. // took out trim deviation...
  1645. #define isFloatToken(x, n) ((n) && (   ((x == RI_PZ)) || ((x == RI_PW)) || ((x == RI_S)) \
  1646.                                     || ((x == RI_T)) || ((x == RI_A)) || ((x == RI_AZ)) \
  1647.                                     || ((x == RI_RGBAZ)) || ((x == RI_RGBZ)) || ((x == RI_FLATNESS)) \
  1648.                                     || ((x == RI_FOV)) || ((x == RI_INTENSITY)) \
  1649.                                     || ((x == RI_CONEANGLE)) || ((x == RI_CONEDELTAANGLE)) || ((x == RI_BEAMDISTRIBUTION)) \
  1650.                                     || ((x == RI_KA)) || ((x == RI_KD)) || ((x == RI_KS)) \
  1651.                                     || ((x == RI_ROUGHNESS)) || ((x == RI_KR)) || ((x == RI_MINDISTANCE)) \
  1652.                                     || ((x == RI_MAXDISTANCE)) || ((x == RI_DISTANCE)) || ((x == RI_AMPLITUDE)) \
  1653.                                     || ((x == RI_RGBA)) || ((x == RI_ST)) || ((x == RI_Z)) || ((!strcmp(n, "extremedisplacement"))) \
  1654.                                     || ((!strcmp(n, "displacement"))) || ((!strcmp(n, "gridarea"))) || ((!strcmp(n, "nearhither"))) \
  1655.                                     || ((!strcmp(n, "epsilon1"))) || ((!strcmp(n, "epsilon2"))) || ((!strcmp(n, "bias0"))) \
  1656.                                     || ((!strcmp(n, "bias1")))))
  1657.  
  1658. RtPointer
  1659. parseTokenNameAndParameterIntoParm(me, interp, theToken, tokenName, parmAsString, errPtr)
  1660. WWEveParser  *me;
  1661. Tcl_Interp    *interp;
  1662. RtToken       theToken;
  1663. char          *tokenName, *parmAsString;
  1664. int           *errPtr;
  1665. {
  1666.   int        argc, i;
  1667.   char       **argv;
  1668.   RIB_var_t  *theRIBVar;
  1669.  
  1670.  
  1671.   /* first we see if the parmAsString is NULL.  If so, return success and RI_NULL */
  1672.   if (!parmAsString)
  1673.   {  *errPtr = 0;
  1674.      return RI_NULL;
  1675.   }
  1676.  
  1677.   /* next we see if the token is one of the built-in RenderMan-defined ones */
  1678.   /* if it is, we, deal with it and return. */
  1679.   /* if not, we have to grab the RIB_var_t structure and use that to build up parm appropriately */
  1680.  
  1681.   if (isColorToken(theToken, tokenName))
  1682.   {  RtColor  *colors, *colorPtr;
  1683.  
  1684.      if (Tcl_SplitList(interp, parmAsString, &argc, &argv) != TCL_OK)
  1685.      {  strcpy(errBuf, "parseTokenNameAndParameterIntoParm() : problem splitting list as color token");
  1686.         Tcl_AppendResult(interp, errBuf, (char *)NULL);
  1687.         return RI_NULL;
  1688.      }
  1689.      if (argc % 3)
  1690.      {  sprintf(errBuf, 
  1691.         "parseTokenNameAndParameterIntoParm() : colors specified with %s must be given in 3-vectors : there were %d elements in the list", 
  1692.         tokenName, argc);
  1693.         Tcl_AppendResult(interp, errBuf, (char *)NULL);
  1694.         free(argv);
  1695.         *errPtr = 1;
  1696.         return RI_NULL;
  1697.      }
  1698.      colors = (RtColor *)malloc((argc/3) * sizeof(RtColor));
  1699.      colorPtr = colors;
  1700.      for (i = 0; i < argc; i += 3)
  1701.      {  (*colorPtr)[0] = (RtFloat)atof(argv[i+0]);
  1702.         (*colorPtr)[1] = (RtFloat)atof(argv[i+1]);
  1703.         (*colorPtr)[2] = (RtFloat)atof(argv[i+2]);
  1704.     colorPtr++;
  1705.      }
  1706.      free(argv);
  1707.      *errPtr = 0;
  1708.      return (RtPointer)(colors);
  1709.   }
  1710.  
  1711.   if (isPointToken(theToken, tokenName))
  1712.   {  RtPoint  *points, *pointPtr;
  1713.     
  1714.      if (Tcl_SplitList(interp, parmAsString, &argc, &argv) != TCL_OK)
  1715.      {  strcpy(errBuf, "parseTokenNameAndParameterIntoParm() : problem splitting list as point token");
  1716.         Tcl_AppendResult(interp, errBuf, (char *)NULL);
  1717.         return RI_NULL;
  1718.      }
  1719.      if (argc % 3)
  1720.      {  sprintf(errBuf, 
  1721.         "parseTokenNameAndParameterIntoParm() : points specified with %s must be given in 3-vectors - this list had %d elements", 
  1722.         tokenName, argc);
  1723.         Tcl_AppendResult(interp, errBuf, (char *)NULL);
  1724.         free(argv);
  1725.         *errPtr = 1;
  1726.         return RI_NULL;
  1727.      }
  1728.      points = (RtPoint *)malloc((argc/3) * sizeof(RtPoint));
  1729.      pointPtr = points;
  1730.      for (i = 0; i < argc; i += 3)
  1731.      {  (*pointPtr)[0] = (RtFloat)atof(argv[i+0]);
  1732.         (*pointPtr)[1] = (RtFloat)atof(argv[i+1]);
  1733.         (*pointPtr)[2] = (RtFloat)atof(argv[i+2]);
  1734.     pointPtr++;
  1735.      }
  1736.      free(argv);
  1737.      *errPtr = 0;
  1738.      return (RtPointer)points;
  1739.   }
  1740.  
  1741.   if (isFloatToken(theToken, tokenName))
  1742.   {  RtFloat  *floats, *floatPtr;
  1743.  
  1744.      if (Tcl_SplitList(interp, parmAsString, &argc, &argv) != TCL_OK)
  1745.      {  strcpy(errBuf, "parseTokenNameAndParameterIntoParm() : problem splitting list as float token");
  1746.         Tcl_AppendResult(interp, errBuf, (char *)NULL);
  1747.         return RI_NULL;
  1748.      }
  1749.  
  1750.      /* need to check for various special cases here to do additional argc sanity check */ 
  1751.      if ((theToken == RI_AZ) && (argc % 2))
  1752.      {  sprintf(errBuf, 
  1753.         "parseTokenNameAndParameterIntoParm() : parameters for %s must be given in 2-vectors - this list had %d elements", 
  1754.         tokenName, argc);
  1755.         Tcl_AppendResult(interp, errBuf, (char *)NULL);
  1756.         free(argv);  *errPtr = 1;
  1757.          return (RtPointer)0;
  1758.      }
  1759.      if ((theToken == RI_PW) && (argc % 4))
  1760.      {  sprintf(errBuf,
  1761.         "parseTokenNameAndParameterIntoParm() : parameters for %s must be given in 4-vectors - this list had %d elements", 
  1762.         tokenName, argc);
  1763.         Tcl_AppendResult(interp, errBuf, (char *)NULL);
  1764.         free(argv);  *errPtr = 1;
  1765.          return RI_NULL;
  1766.      }
  1767.      if ((theToken == RI_RGBAZ) && (argc % 5))
  1768.      {  sprintf(errBuf, 
  1769.         "parseTokenNameAndParameterIntoParm() : parameters for %s must be given in 5-vectors - this list had %d elements", 
  1770.         tokenName, argc);
  1771.         Tcl_AppendResult(interp, errBuf, (char *)NULL);
  1772.         free(argv);  *errPtr = 1;
  1773.          return RI_NULL;
  1774.      }
  1775.      if ((theToken == RI_RGBZ) && (argc % 4))
  1776.      {  sprintf(errBuf,
  1777.         "parseTokenNameAndParameterIntoParm() : parameters for %s must be given in 4-vectors - this list had %d elements", 
  1778.         tokenName, argc);
  1779.         Tcl_AppendResult(interp, errBuf, (char *)NULL);
  1780.         free(argv);  *errPtr = 1;
  1781.          return RI_NULL;
  1782.      }
  1783.      if ((theToken == RI_RGBA) && (argc % 4))
  1784.      {  sprintf(errBuf,
  1785.         "parseTokenNameAndParameterIntoParm() : parameters for %s must be given in 4-vectors - this list had %d elements", 
  1786.         tokenName, argc);
  1787.         Tcl_AppendResult(interp, errBuf, (char *)NULL);
  1788.         free(argv);  *errPtr = 1;
  1789.          return RI_NULL;
  1790.      }
  1791.      if ((theToken == RI_ST) && (argc % 2))
  1792.      {  sprintf(errBuf,
  1793.         "parseTokenNameAndParameterIntoParm() : parameters for %s must be given in 2-vectors - this list had %d elements", 
  1794.         tokenName, argc);
  1795.         Tcl_AppendResult(interp, errBuf, (char *)NULL);
  1796.         free(argv);  *errPtr = 1;
  1797.          return RI_NULL;
  1798.      }
  1799.      if ((!strcmp(tokenName, "gridarea")) && (argc % 2))
  1800.      {  sprintf(errBuf,
  1801.         "parseTokenNameAndParameterIntoParm() : parameters for %s must be given in 2-vectors - this list had %d elements", 
  1802.         tokenName, argc);
  1803.         Tcl_AppendResult(interp, errBuf, (char *)NULL);
  1804.         free(argv);  *errPtr = 1;
  1805.          return RI_NULL;
  1806.      }
  1807.      if ((theToken == RI_ST) && (argc % 2))
  1808.      {  sprintf(errBuf,
  1809.         "parseTokenNameAndParameterIntoParm() : parameters for %s must be given in 2-vectors - this list had %d elements", 
  1810.         tokenName, argc);
  1811.         Tcl_AppendResult(interp, errBuf, (char *)NULL);
  1812.         free(argv);  *errPtr = 1;
  1813.          return RI_NULL;
  1814.      }
  1815.  
  1816.      floats = (RtFloat *)malloc((argc * sizeof(RtFloat)));
  1817.      floatPtr = floats;
  1818.      for (i = 0; i < argc; i++)
  1819.      {  *floatPtr++ = (RtFloat)atof(argv[i]);
  1820.      }
  1821.      free(argv);
  1822.      *errPtr = 0;
  1823.      return (RtPointer)floats;
  1824.   }
  1825.  
  1826.   if (isIntegerToken(theToken, tokenName))
  1827.   {  RtInt  *integers, *integerPtr;
  1828.  
  1829.  
  1830.      if (Tcl_SplitList(interp, parmAsString, &argc, &argv) != TCL_OK)
  1831.      {  strcpy(errBuf, "parseTokenNameAndParameterIntoParm() : problem splitting list as integer token");
  1832.         Tcl_AppendResult(interp, errBuf, (char *)NULL);
  1833.         return RI_NULL;
  1834.      }
  1835.  
  1836.      /* need to check for various special cases here to do additional argc sanity check */ 
  1837.      if ((!strcmp(tokenName, "bucketsize")) && (argc % 2))
  1838.      {  sprintf(errBuf,
  1839.         "parseTokenNameAndParameterIntoParm() : parameters for %s must be given in 2-vectors - this list had %d elements", 
  1840.         tokenName, argc);
  1841.         Tcl_AppendResult(interp, errBuf, (char *)NULL);
  1842.         free(argv);  *errPtr = 1;
  1843.          return RI_NULL;
  1844.      }
  1845.      if ((!strcmp(tokenName, "subwindow")) && (argc % 5))
  1846.      {  sprintf(errBuf,
  1847.         "parseTokenNameAndParameterIntoParm() : parameters for %s must be given in 5-vectors - this list had %d elements", 
  1848.         tokenName, argc);
  1849.         Tcl_AppendResult(interp, errBuf, (char *)NULL);
  1850.         free(argv);  *errPtr = 1;
  1851.          return RI_NULL;
  1852.      }
  1853.      if ((!strcmp(tokenName, "bucketstride")) && (argc % 2))
  1854.      {  sprintf(errBuf,
  1855.         "parseTokenNameAndParameterIntoParm() : parameters for %s must be given in 2-vectors - this list had %d elements", 
  1856.         tokenName, argc);
  1857.         Tcl_AppendResult(interp, errBuf, (char *)NULL);
  1858.         free(argv);  *errPtr = 1;
  1859.          return RI_NULL;
  1860.      }
  1861.      if ((theToken == RI_ORIGIN) && (argc % 2))
  1862.      {  sprintf(errBuf,
  1863.         "parseTokenNameAndParameterIntoParm() : parameters for %s must be given in 2-vectors - this list had %d elements", 
  1864.         tokenName, argc);
  1865.         Tcl_AppendResult(interp, errBuf, (char *)NULL);
  1866.         free(argv);  *errPtr = 1;
  1867.          return RI_NULL;
  1868.      }
  1869.  
  1870.      integers = (RtInt *)malloc((argc * sizeof(RtInt)));
  1871.      integerPtr = integers;
  1872.      for (i = 0; i < argc; i++)
  1873.      {  *integerPtr++ = (RtInt)atoi(argv[i]);
  1874.      }
  1875.      free(argv);
  1876.      *errPtr = 0;
  1877.      return (RtPointer)integers;
  1878.   }
  1879.  
  1880.   theRIBVar = getRIBVarGivenName(me, tokenName);
  1881.   if (theRIBVar) /* must be a user defined RIB variable */
  1882.   {  RtPointer  retPtr = RI_NULL;
  1883.  
  1884.      retPtr = (RtPointer)(theRIBVar->encodeFunc(me, interp, parmAsString, theRIBVar->n));
  1885.      *errPtr = 0;
  1886.      if (!retPtr)
  1887.      {  *errPtr = 1;
  1888.      }
  1889.      return retPtr;
  1890.   }
  1891.  
  1892.   *errPtr = 1;
  1893.   sprintf(errBuf, 
  1894.       "parseTokenNameAndParameterIntoParm() : the token <%s> was never formally declared with RiDeclare() - how the hell am I supposed to know what type it is?", 
  1895.       tokenName);
  1896.   Tcl_AppendResult(interp, errBuf, (char *)NULL);
  1897.   return (RtPointer)RI_NULL;
  1898. }
  1899.  
  1900.  
  1901. char 
  1902. *parseTokenNameAndParameterIntoArchiveInfo(me, interp, theToken, tokenName, parmAsString, errPtr)
  1903. WWEveParser  *me;
  1904. Tcl_Interp    *interp;
  1905. RtToken       theToken;
  1906. char          *tokenName, *parmAsString;
  1907. int           *errPtr;
  1908. {
  1909.   int        argc;
  1910.   char       **argv;
  1911.   RIB_var_t  *theRIBVar;
  1912.   char       archiveInfo[256];
  1913.  
  1914.  
  1915.   /* first we see if the parmAsString is NULL.  If so, return success and RI_NULL */
  1916.   if (!parmAsString)
  1917.   {  *errPtr = 0;
  1918.      return NXCopyStringBuffer("");
  1919.   }
  1920.  
  1921.   /* next we see if the token is one of the built-in RenderMan-defined ones */
  1922.   /* if it is, we, deal with it and return. */
  1923.   /* if not, we have to grab the RIB_var_t structure and use that to build up parm appropriately */
  1924.  
  1925.   if (isColorToken(theToken, tokenName))
  1926.   {  
  1927.      if (Tcl_SplitList(interp, parmAsString, &argc, &argv) != TCL_OK)
  1928.      {  strcpy(errBuf, "parseTokenNameAndParameterIntoParm() : problem splitting list as color token");
  1929.         Tcl_AppendResult(interp, errBuf, (char *)NULL);
  1930.         return RI_NULL;
  1931.      }
  1932.      if (argc % 3)
  1933.      {  sprintf(errBuf, 
  1934.         "parseTokenNameAndParameterIntoArchiveInfo() : colors specified with %s must be given in 3-vectors : there were %d elements in the list", 
  1935.         tokenName, argc);
  1936.         Tcl_AppendResult(interp, errBuf, (char *)NULL);
  1937.         free(argv);
  1938.         *errPtr = 1;
  1939.         return RI_NULL;
  1940.      }
  1941.      *errPtr = 0;
  1942.      free(argv);
  1943.      sprintf(archiveInfo, "[%df]", argc);
  1944.      return NXCopyStringBuffer(archiveInfo);
  1945.   }
  1946.  
  1947.   if (isPointToken(theToken, tokenName))
  1948.   {  
  1949.      if (Tcl_SplitList(interp, parmAsString, &argc, &argv) != TCL_OK)
  1950.      {  strcpy(errBuf, "parseTokenNameAndParameterIntoParm() : problem splitting list as point token");
  1951.         Tcl_AppendResult(interp, errBuf, (char *)NULL);
  1952.         return RI_NULL;
  1953.      }
  1954.      if (argc % 3)
  1955.      {  sprintf(errBuf, 
  1956.         "parseTokenNameAndParameterIntoArchiveInfo() : points specified with %s must be given in 3-vectors - this list had %d elements", 
  1957.         tokenName, argc);
  1958.         Tcl_AppendResult(interp, errBuf, (char *)NULL);
  1959.         free(argv);
  1960.         *errPtr = 1;
  1961.         return RI_NULL;
  1962.      }
  1963.      free(argv);
  1964.      *errPtr = 0;
  1965.      sprintf(archiveInfo, "[%df]", argc);
  1966.      return NXCopyStringBuffer(archiveInfo);
  1967.   }
  1968.  
  1969.   if (isFloatToken(theToken, tokenName))
  1970.   {  
  1971.      if (Tcl_SplitList(interp, parmAsString, &argc, &argv) != TCL_OK)
  1972.      {  strcpy(errBuf, "parseTokenNameAndParameterIntoParm() : problem splitting list as float token");
  1973.         Tcl_AppendResult(interp, errBuf, (char *)NULL);
  1974.         return RI_NULL;
  1975.      }
  1976.      /* need to check for various special cases here to do additional argc sanity check */ 
  1977.      if ((theToken == RI_AZ) && (argc % 2))
  1978.      {  sprintf(errBuf, 
  1979.         "parseTokenNameAndParameterIntoArchiveInfo() : parameters for %s must be given in 2-vectors - this list had %d elements", 
  1980.         tokenName, argc);
  1981.         Tcl_AppendResult(interp, errBuf, (char *)NULL);
  1982.         free(argv);  *errPtr = 1;
  1983.          return (RtPointer)0;
  1984.      }
  1985.      if ((theToken == RI_PW) && (argc % 4))
  1986.      {  sprintf(errBuf,
  1987.         "parseTokenNameAndParameterIntoArchiveInfo() : parameters for %s must be given in 4-vectors - this list had %d elements", 
  1988.         tokenName, argc);
  1989.         Tcl_AppendResult(interp, errBuf, (char *)NULL);
  1990.         free(argv);  *errPtr = 1;
  1991.          return RI_NULL;
  1992.      }
  1993.      if ((theToken == RI_RGBAZ) && (argc % 5))
  1994.      {  sprintf(errBuf, 
  1995.         "parseTokenNameAndParameterIntoArchiveInfo() : parameters for %s must be given in 5-vectors - this list had %d elements", 
  1996.         tokenName, argc);
  1997.         Tcl_AppendResult(interp, errBuf, (char *)NULL);
  1998.         free(argv);  *errPtr = 1;
  1999.          return RI_NULL;
  2000.      }
  2001.      if ((theToken == RI_RGBZ) && (argc % 4))
  2002.      {  sprintf(errBuf,
  2003.         "parseTokenNameAndParameterIntoArchiveInfo() : parameters for %s must be given in 4-vectors - this list had %d elements", 
  2004.         tokenName, argc);
  2005.         Tcl_AppendResult(interp, errBuf, (char *)NULL);
  2006.         free(argv);  *errPtr = 1;
  2007.          return RI_NULL;
  2008.      }
  2009.      if ((theToken == RI_RGBA) && (argc % 4))
  2010.      {  sprintf(errBuf,
  2011.         "parseTokenNameAndParameterIntoArchiveInfo() : parameters for %s must be given in 4-vectors - this list had %d elements", 
  2012.         tokenName, argc);
  2013.         Tcl_AppendResult(interp, errBuf, (char *)NULL);
  2014.         free(argv);  *errPtr = 1;
  2015.          return RI_NULL;
  2016.      }
  2017.      if ((theToken == RI_ST) && (argc % 2))
  2018.      {  sprintf(errBuf,
  2019.         "parseTokenNameAndParameterIntoArchiveInfo() : parameters for %s must be given in 2-vectors - this list had %d elements", 
  2020.         tokenName, argc);
  2021.         Tcl_AppendResult(interp, errBuf, (char *)NULL);
  2022.         free(argv);  *errPtr = 1;
  2023.          return RI_NULL;
  2024.      }
  2025.      if ((!strcmp(tokenName, "gridarea")) && (argc % 2))
  2026.      {  sprintf(errBuf,
  2027.         "parseTokenNameAndParameterIntoArchiveInfo() : parameters for %s must be given in 2-vectors - this list had %d elements", 
  2028.         tokenName, argc);
  2029.         Tcl_AppendResult(interp, errBuf, (char *)NULL);
  2030.         free(argv);  *errPtr = 1;
  2031.          return RI_NULL;
  2032.      }
  2033.      if ((theToken == RI_ST) && (argc % 2))
  2034.      {  sprintf(errBuf,
  2035.         "parseTokenNameAndParameterIntoArchiveInfo() : parameters for %s must be given in 2-vectors - this list had %d elements", 
  2036.         tokenName, argc);
  2037.         Tcl_AppendResult(interp, errBuf, (char *)NULL);
  2038.         free(argv);  *errPtr = 1;
  2039.          return RI_NULL;
  2040.      }
  2041.  
  2042.      free(argv);
  2043.      *errPtr = 0;
  2044.      sprintf(archiveInfo, "[%df]", argc);
  2045.      return NXCopyStringBuffer(archiveInfo);
  2046.   }
  2047.  
  2048.   if (isIntegerToken(theToken, tokenName))
  2049.   {  
  2050.      if (Tcl_SplitList(interp, parmAsString, &argc, &argv) != TCL_OK)
  2051.      {  strcpy(errBuf, "parseTokenNameAndParameterIntoParm() : problem splitting list as integer token");
  2052.         Tcl_AppendResult(interp, errBuf, (char *)NULL);
  2053.         return RI_NULL;
  2054.      }
  2055.      /* need to check for various special cases here to do additional argc sanity check */ 
  2056.      if ((!strcmp(tokenName, "bucketsize")) && (argc % 2))
  2057.      {  sprintf(errBuf,
  2058.         "parseTokenNameAndParameterIntoArchiveInfo() : parameters for %s must be given in 2-vectors - this list had %d elements", 
  2059.         tokenName, argc);
  2060.         Tcl_AppendResult(interp, errBuf, (char *)NULL);
  2061.         free(argv);  *errPtr = 1;
  2062.          return RI_NULL;
  2063.      }
  2064.      if ((!strcmp(tokenName, "subwindow")) && (argc % 5))
  2065.      {  sprintf(errBuf,
  2066.         "parseTokenNameAndParameterIntoArchiveInfo() : parameters for %s must be given in 5-vectors - this list had %d elements", 
  2067.         tokenName, argc);
  2068.         Tcl_AppendResult(interp, errBuf, (char *)NULL);
  2069.         free(argv);  *errPtr = 1;
  2070.          return RI_NULL;
  2071.      }
  2072.      if ((!strcmp(tokenName, "bucketstride")) && (argc % 2))
  2073.      {  sprintf(errBuf,
  2074.         "parseTokenNameAndParameterIntoArchiveInfo() : parameters for %s must be given in 2-vectors - this list had %d elements", 
  2075.         tokenName, argc);
  2076.         Tcl_AppendResult(interp, errBuf, (char *)NULL);
  2077.         free(argv);  *errPtr = 1;
  2078.          return RI_NULL;
  2079.      }
  2080.      if ((theToken == RI_ORIGIN) && (argc % 2))
  2081.      {  sprintf(errBuf,
  2082.         "parseTokenNameAndParameterIntoArchiveInfo() : parameters for %s must be given in 2-vectors - this list had %d elements", 
  2083.         tokenName, argc);
  2084.         Tcl_AppendResult(interp, errBuf, (char *)NULL);
  2085.         free(argv);  *errPtr = 1;
  2086.          return RI_NULL;
  2087.      }
  2088.  
  2089.      free(argv);
  2090.      *errPtr = 0;
  2091.      sprintf(archiveInfo, "[%di]", argc);
  2092.      return NXCopyStringBuffer(archiveInfo);
  2093.   }
  2094.  
  2095.   theRIBVar = getRIBVarGivenName(me, tokenName);
  2096.   if (theRIBVar) /* must be a user defined RIB variable */
  2097.   {  char  *retPtr = NULL;
  2098.  
  2099.      retPtr = (char *)(theRIBVar->archiveFunc(me, interp, parmAsString, theRIBVar->n));
  2100.      *errPtr = 0;
  2101.      if (!retPtr)
  2102.      {  *errPtr = 1;
  2103.      }
  2104.      return retPtr;
  2105.   }
  2106.  
  2107.   *errPtr = 1;
  2108.   sprintf(errBuf, 
  2109.       "parseTokenNameAndParameterIntoArchiveInfo() : the token <%s> was never formally declared with RiDeclare() - how the hell am I supposed to know what type it is?", 
  2110.       tokenName);
  2111.   Tcl_AppendResult(interp, errBuf, (char *)NULL);
  2112.   return (RtPointer)RI_NULL;
  2113. }
  2114.  
  2115.  
  2116. int
  2117. parseTokenNameAndParameterIntoPrintfInfo(me, interp, theToken, tokenName, parmAsString, errPtr, typeInfoPtr, howManyPtr)
  2118. WWEveParser  *me;
  2119. Tcl_Interp    *interp;
  2120. RtToken       theToken;
  2121. char          *tokenName, *parmAsString;
  2122. int           *errPtr, *typeInfoPtr, *howManyPtr;
  2123. {
  2124.   int          argc;
  2125.   char         **argv;
  2126.   RIB_var_t    *theRIBVar;
  2127.  
  2128.  
  2129.   /* first we see if the parmAsString is NULL.  If so, return success and RI_NULL */
  2130.   if (!parmAsString)
  2131.   {  *errPtr = 0;
  2132.      *typeInfoPtr = -1;
  2133.      *howManyPtr = 0;
  2134.      return *howManyPtr;
  2135.   }
  2136.  
  2137.  
  2138.   /* next we see if the token is one of the built-in RenderMan-defined ones */
  2139.   /* if it is, we, deal with it and return. */
  2140.   /* if not, we have to grab the RIB_var_t structure and use that to build up parm appropriately */
  2141.  
  2142.   if (isColorToken(theToken, tokenName))
  2143.   {  
  2144.      if (Tcl_SplitList(interp, parmAsString, &argc, &argv) != TCL_OK)
  2145.      {  strcpy(errBuf, "parseTokenNameAndParameterIntoPrintfInfo() : problem splitting list as color token");
  2146.         Tcl_AppendResult(interp, errBuf, (char *)NULL);
  2147.         return 0;
  2148.      }
  2149.      if (argc % 3)
  2150.      {  sprintf(errBuf, 
  2151.         "parseTokenNameAndParameterIntoPrintfInfo() : colors specified with %s must be given in 3-vectors : there were %d elements in the list", 
  2152.         tokenName, argc);
  2153.         Tcl_AppendResult(interp, errBuf, (char *)NULL);
  2154.         free(argv);
  2155.         *errPtr = 1;
  2156.         *typeInfoPtr = -1;
  2157.         *howManyPtr = 0;
  2158.         return *howManyPtr;
  2159.      }
  2160.      *errPtr = 0;
  2161.      free(argv);
  2162.      *typeInfoPtr = WW_COLOR;
  2163.      *howManyPtr = argc;
  2164.      return *howManyPtr;
  2165.   }
  2166.  
  2167.   if (isPointToken(theToken, tokenName))
  2168.   {  
  2169.      if (Tcl_SplitList(interp, parmAsString, &argc, &argv) != TCL_OK)
  2170.      {  strcpy(errBuf, "parseTokenNameAndParameterIntoPrintfInfo() : problem splitting list as point token");
  2171.         Tcl_AppendResult(interp, errBuf, (char *)NULL);
  2172.         return 0;
  2173.      }
  2174.      if (argc % 3)
  2175.      {  sprintf(errBuf, 
  2176.         "parseTokenNameAndParameterIntoPrintfInfo() : points specified with %s must be given in 3-vectors - this list had %d elements", 
  2177.         tokenName, argc);
  2178.         Tcl_AppendResult(interp, errBuf, (char *)NULL);
  2179.         free(argv);
  2180.         *errPtr = 1;
  2181.         *typeInfoPtr = -1;
  2182.         *howManyPtr = 0;
  2183.         return *howManyPtr;
  2184.      }
  2185.      free(argv);
  2186.      *errPtr = 0;
  2187.      *typeInfoPtr = WW_POINT;
  2188.      *howManyPtr = argc;
  2189.      return *howManyPtr;
  2190.   }
  2191.  
  2192.   if (isFloatToken(theToken, tokenName))
  2193.   {  
  2194.      if (Tcl_SplitList(interp, parmAsString, &argc, &argv) != TCL_OK)
  2195.      {  strcpy(errBuf, "parseTokenNameAndParameterIntoPrintfInfo() : problem splitting list as float token");
  2196.         Tcl_AppendResult(interp, errBuf, (char *)NULL);
  2197.         return 0;
  2198.      }
  2199.      /* need to check for various special cases here to do additional argc sanity check */ 
  2200.      if ((theToken == RI_AZ) && (argc % 2))
  2201.      {  sprintf(errBuf, 
  2202.         "parseTokenNameAndParameterIntoPrintfInfo() : parameters for %s must be given in 2-vectors - this list had %d elements", 
  2203.         tokenName, argc);
  2204.         Tcl_AppendResult(interp, errBuf, (char *)NULL);
  2205.         free(argv);  
  2206.         *errPtr = 1;
  2207.         *typeInfoPtr = -1;
  2208.         *howManyPtr = 0;
  2209.         return *howManyPtr;
  2210.      }
  2211.      if ((theToken == RI_PW) && (argc % 4))
  2212.      {  sprintf(errBuf,
  2213.         "parseTokenNameAndParameterIntoPrintfInfo() : parameters for %s must be given in 4-vectors - this list had %d elements", 
  2214.         tokenName, argc);
  2215.         Tcl_AppendResult(interp, errBuf, (char *)NULL);
  2216.         free(argv);  *errPtr = 1;
  2217.         *typeInfoPtr = -1;
  2218.         *howManyPtr = 0;
  2219.         return *howManyPtr;
  2220.      }
  2221.      if ((theToken == RI_RGBAZ) && (argc % 5))
  2222.      {  sprintf(errBuf, 
  2223.         "parseTokenNameAndParameterIntoPrintfInfo() : parameters for %s must be given in 5-vectors - this list had %d elements", 
  2224.         tokenName, argc);
  2225.         Tcl_AppendResult(interp, errBuf, (char *)NULL);
  2226.         free(argv);  *errPtr = 1;
  2227.         *typeInfoPtr = -1;
  2228.         *howManyPtr = 0;
  2229.         return *howManyPtr;
  2230.      }
  2231.      if ((theToken == RI_RGBZ) && (argc % 4))
  2232.      {  sprintf(errBuf,
  2233.         "parseTokenNameAndParameterIntoPrintfInfo() : parameters for %s must be given in 4-vectors - this list had %d elements", 
  2234.         tokenName, argc);
  2235.         Tcl_AppendResult(interp, errBuf, (char *)NULL);
  2236.         free(argv);  *errPtr = 1;
  2237.         *typeInfoPtr = -1;
  2238.         *howManyPtr = 0;
  2239.         return *howManyPtr;
  2240.      }
  2241.      if ((theToken == RI_RGBA) && (argc % 4))
  2242.      {  sprintf(errBuf,
  2243.         "parseTokenNameAndParameterIntoPrintfInfo() : parameters for %s must be given in 4-vectors - this list had %d elements", 
  2244.         tokenName, argc);
  2245.         Tcl_AppendResult(interp, errBuf, (char *)NULL);
  2246.         free(argv);  *errPtr = 1;
  2247.         *typeInfoPtr = -1;
  2248.         *howManyPtr = 0;
  2249.         return *howManyPtr;
  2250.      }
  2251.      if ((theToken == RI_ST) && (argc % 2))
  2252.      {  sprintf(errBuf,
  2253.         "parseTokenNameAndParameterIntoPrintfInfo() : parameters for %s must be given in 2-vectors - this list had %d elements", 
  2254.         tokenName, argc);
  2255.         Tcl_AppendResult(interp, errBuf, (char *)NULL);
  2256.         free(argv);  *errPtr = 1;
  2257.         *typeInfoPtr = -1;
  2258.         *howManyPtr = 0;
  2259.         return *howManyPtr;
  2260.      }
  2261.      if ((!strcmp(tokenName, "gridarea")) && (argc % 2))
  2262.      {  sprintf(errBuf,
  2263.         "parseTokenNameAndParameterIntoPrintfInfo() : parameters for %s must be given in 2-vectors - this list had %d elements", 
  2264.         tokenName, argc);
  2265.         Tcl_AppendResult(interp, errBuf, (char *)NULL);
  2266.         free(argv);  *errPtr = 1;
  2267.         *typeInfoPtr = -1;
  2268.         *howManyPtr = 0;
  2269.         return *howManyPtr;
  2270.      }
  2271.      if ((theToken == RI_ST) && (argc % 2))
  2272.      {  sprintf(errBuf,
  2273.         "parseTokenNameAndParameterIntoPrintfInfo() : parameters for %s must be given in 2-vectors - this list had %d elements", 
  2274.         tokenName, argc);
  2275.         Tcl_AppendResult(interp, errBuf, (char *)NULL);
  2276.         free(argv);  *errPtr = 1;
  2277.         *typeInfoPtr = -1;
  2278.         *howManyPtr = 0;
  2279.         return *howManyPtr;
  2280.      }
  2281.  
  2282.      free(argv);
  2283.      *errPtr = 0;
  2284.      *typeInfoPtr = WW_FLOAT;
  2285.      *howManyPtr = argc;
  2286.      return *howManyPtr;
  2287.   }
  2288.  
  2289.   if (isIntegerToken(theToken, tokenName))
  2290.   {  
  2291.      if (Tcl_SplitList(interp, parmAsString, &argc, &argv) != TCL_OK)
  2292.      {  strcpy(errBuf, "parseTokenNameAndParameterIntoPrintfInfo() : problem splitting list as integer token");
  2293.         Tcl_AppendResult(interp, errBuf, (char *)NULL);
  2294.         return 0;
  2295.      }
  2296.      /* need to check for various special cases here to do additional argc sanity check */ 
  2297.      if ((!strcmp(tokenName, "bucketsize")) && (argc % 2))
  2298.      {  sprintf(errBuf,
  2299.         "parseTokenNameAndParameterIntoPrintfInfo() : parameters for %s must be given in 2-vectors - this list had %d elements", 
  2300.         tokenName, argc);
  2301.         Tcl_AppendResult(interp, errBuf, (char *)NULL);
  2302.         free(argv);  *errPtr = 1;
  2303.         *typeInfoPtr = -1;
  2304.         *howManyPtr = 0;
  2305.         return *howManyPtr;
  2306.      }
  2307.      if ((!strcmp(tokenName, "subwindow")) && (argc % 5))
  2308.      {  sprintf(errBuf,
  2309.         "parseTokenNameAndParameterIntoPrintfInfo() : parameters for %s must be given in 5-vectors - this list had %d elements", 
  2310.         tokenName, argc);
  2311.         Tcl_AppendResult(interp, errBuf, (char *)NULL);
  2312.         free(argv);  *errPtr = 1;
  2313.         *typeInfoPtr = -1;
  2314.         *howManyPtr = 0;
  2315.         return *howManyPtr;
  2316.      }
  2317.      if ((!strcmp(tokenName, "bucketstride")) && (argc % 2))
  2318.      {  sprintf(errBuf,
  2319.         "parseTokenNameAndParameterIntoPrintfInfo() : parameters for %s must be given in 2-vectors - this list had %d elements", 
  2320.         tokenName, argc);
  2321.         Tcl_AppendResult(interp, errBuf, (char *)NULL);
  2322.         free(argv);  *errPtr = 1;
  2323.         *typeInfoPtr = -1;
  2324.         *howManyPtr = 0;
  2325.         return *howManyPtr;
  2326.      }
  2327.      if ((theToken == RI_ORIGIN) && (argc % 2))
  2328.      {  sprintf(errBuf,
  2329.         "parseTokenNameAndParameterIntoPrintfInfo() : parameters for %s must be given in 2-vectors - this list had %d elements", 
  2330.         tokenName, argc);
  2331.         Tcl_AppendResult(interp, errBuf, (char *)NULL);
  2332.         free(argv);  *errPtr = 1;
  2333.         *typeInfoPtr = -1;
  2334.         *howManyPtr = 0;
  2335.         return *howManyPtr;
  2336.      }
  2337.  
  2338.      free(argv);
  2339.      *errPtr = 0;
  2340.      *typeInfoPtr = WW_INT;
  2341.      *howManyPtr = argc;
  2342.      return *howManyPtr;
  2343.   }
  2344.  
  2345.   theRIBVar = getRIBVarGivenName(me, tokenName);
  2346.   if (theRIBVar) /* must be a user defined RIB variable */
  2347.   {  *howManyPtr = (int)(theRIBVar->printfFunc(me, interp, parmAsString, theRIBVar->n, typeInfoPtr));
  2348.      *errPtr = 0;
  2349.      if (!*howManyPtr)
  2350.      {  *errPtr = 1;
  2351.      } 
  2352.      return *howManyPtr;
  2353.   }
  2354.  
  2355.   *errPtr = 1;
  2356.   sprintf(errBuf, 
  2357.       "parseTokenNameAndParameterIntoPrintfInfo() : the token <%s> was never formally declared with RiDeclare() - how the hell am I supposed to know what type it is?", 
  2358.       tokenName);
  2359.   Tcl_AppendResult(interp, errBuf, (char *)NULL);
  2360.   return 0;
  2361. }
  2362.  
  2363.  
  2364. RtToken
  2365. getTokenGivenName(me, name)
  2366. WWEveParser  *me;
  2367. char          *name;
  2368. {
  2369.   int          i, howMany = list_size(me->rib_var_list);
  2370.   RIB_var_t  *aRIBVar;
  2371.  
  2372.  
  2373.   /* is it built-in? */
  2374. #if 0
  2375.   if (!strcmp(name, "bezier")) {  return RI_BEZIER;}
  2376.   if (!strcmp(name, "b-spline")) {  return RI_BSPLINE;}
  2377.   if (!strcmp(name, "catmull-rom")) {  return RI_CATMULLROM;}
  2378.   if (!strcmp(name, "hermite")) {  return RI_HERMITE;}
  2379.   if (!strcmp(name, "power")) {  return RI_POWER;}
  2380. #endif
  2381.   if (!strcmp(name, "framebuffer")) {  return RI_FRAMEBUFFER;}
  2382.   if (!strcmp(name, "file")) {  return RI_FILE;}
  2383.   if (!strcmp(name, "rgb")) {  return RI_RGB;}
  2384.   if (!strcmp(name, "rgba")) {  return RI_RGBA;}
  2385.   if (!strcmp(name, "rgbz")) {  return RI_RGBZ;}
  2386.   if (!strcmp(name, "rgbaz")) {  return RI_RGBAZ;}
  2387.   if (!strcmp(name, "a")) {  return RI_A;}
  2388.   if (!strcmp(name, "z")) {  return RI_Z;}
  2389.   if (!strcmp(name, "az")) {  return RI_AZ;}
  2390.   if (!strcmp(name, "perspective")) {  return RI_PERSPECTIVE;}
  2391.   if (!strcmp(name, "orthographic")) {  return RI_ORTHOGRAPHIC;}
  2392.   if (!strcmp(name, "hidden")) {  return RI_HIDDEN;}
  2393.   if (!strcmp(name, "paint")) {  return RI_PAINT;}
  2394.   if (!strcmp(name, "constant")) {  return RI_CONSTANT;}
  2395.   if (!strcmp(name, "smooth")) {  return RI_SMOOTH;}
  2396.   if (!strcmp(name, "origin")) {  return RI_ORIGIN;}
  2397.   if (!strcmp(name, "flatness")) {  return RI_FLATNESS;}
  2398.   //if (!strcmp(name, "trimdeviation")) {  return RI_TRIMDEVIATION;}
  2399.   if (!strcmp(name, "fov")) {  return RI_FOV;}
  2400.   if (!strcmp(name, "ambientlight")) {  return RI_AMBIENTLIGHT;}
  2401.   if (!strcmp(name, "pointlight")) {  return RI_POINTLIGHT;}
  2402.   if (!strcmp(name, "distantlight")) {  return RI_DISTANTLIGHT;}
  2403.   if (!strcmp(name, "spotlight")) {  return RI_SPOTLIGHT;}
  2404.   if (!strcmp(name, "intensity")) {  return RI_INTENSITY;}
  2405.   if (!strcmp(name, "lightcolor")) {  return RI_LIGHTCOLOR;}
  2406.   if (!strcmp(name, "from")) {  return RI_FROM;}
  2407.   if (!strcmp(name, "to")) {  return RI_TO;}
  2408.   if (!strcmp(name, "coneangle")) {  return RI_CONEANGLE;}
  2409.   if (!strcmp(name, "conedeltaangle")) {  return RI_CONEDELTAANGLE;}
  2410.   if (!strcmp(name, "beamdistribution")) {  return RI_BEAMDISTRIBUTION;}
  2411.   if (!strcmp(name, "matte")) {  return RI_MATTE;}
  2412.   if (!strcmp(name, "metal")) {  return RI_METAL;}
  2413.   if (!strcmp(name, "shinymetal")) {  return RI_SHINYMETAL;}
  2414.   if (!strcmp(name, "plastic")) {  return RI_PLASTIC;}
  2415.   if (!strcmp(name, "paintedplastic")) {  return RI_PAINTEDPLASTIC;}
  2416.   if (!strcmp(name, "Ka")) {  return RI_KA;}
  2417.   if (!strcmp(name, "Kd")) {  return RI_KD;}
  2418.   if (!strcmp(name, "Ks")) {  return RI_KS;}
  2419.   if (!strcmp(name, "roughness")) {  return RI_ROUGHNESS;}
  2420.   if (!strcmp(name, "specularcolor")) {  return RI_SPECULARCOLOR;}
  2421.   if (!strcmp(name, "Kr")) {  return RI_KR;}
  2422.   if (!strcmp(name, "depthcue")) {  return RI_DEPTHCUE;}
  2423.   if (!strcmp(name, "fog")) {  return RI_FOG;}
  2424.   if (!strcmp(name, "bumpy")) {  return RI_BUMPY;}
  2425.   if (!strcmp(name, "mindistance")) {  return RI_MINDISTANCE;}
  2426.   if (!strcmp(name, "maxdistance")) {  return RI_MAXDISTANCE;}
  2427.   if (!strcmp(name, "background")) {  return RI_BACKGROUND;}
  2428.   if (!strcmp(name, "distance")) {  return RI_DISTANCE;}
  2429.   if (!strcmp(name, "amplitude")) {  return RI_AMPLITUDE;}
  2430.   if (!strcmp(name, "raster")) {  return RI_RASTER;}
  2431.   if (!strcmp(name, "screen")) {  return RI_SCREEN;}
  2432.   if (!strcmp(name, "camera")) {  return RI_CAMERA;}
  2433.   if (!strcmp(name, "world")) {  return RI_WORLD;}
  2434.   if (!strcmp(name, "object")) {  return RI_OBJECT;}
  2435.   if (!strcmp(name, "inside")) {  return RI_INSIDE;}
  2436.   if (!strcmp(name, "outside")) {  return RI_OUTSIDE;}
  2437.   if (!strcmp(name, "lh")) {  return RI_LH;}
  2438.   if (!strcmp(name, "rh")) {  return RI_RH;}
  2439.   if (!strcmp(name, "P")) {  return RI_P;}
  2440.   if (!strcmp(name, "Pz")) {  return RI_PZ;}
  2441.   if (!strcmp(name, "Pw")) {  return RI_PW;}
  2442.   if (!strcmp(name, "N")) {  return RI_N;}
  2443.   if (!strcmp(name, "Np")) {  return RI_NP;}
  2444.   if (!strcmp(name, "Cs")) {  return RI_CS;}
  2445.   if (!strcmp(name, "Os")) {  return RI_OS;}
  2446.   if (!strcmp(name, "s")) {  return RI_S;}
  2447.   if (!strcmp(name, "t")) {  return RI_T;}
  2448.   if (!strcmp(name, "st")) {  return RI_ST;}
  2449.   if (!strcmp(name, "bilinear")) {  return RI_BILINEAR;}
  2450.   if (!strcmp(name, "bicubic")) {  return RI_BICUBIC;}
  2451.   if (!strcmp(name, "primitive")) {  return RI_PRIMITIVE;}
  2452.   if (!strcmp(name, "intersection")) {  return RI_INTERSECTION;}
  2453.   if (!strcmp(name, "union")) {  return RI_UNION;}
  2454.   if (!strcmp(name, "difference")) {  return RI_DIFFERENCE;}
  2455.   if (!strcmp(name, "periodic")) {  return RI_PERIODIC;}
  2456.   if (!strcmp(name, "nonperiodic")) {  return RI_NONPERIODIC;}
  2457.   if (!strcmp(name, "clamp")) {  return RI_CLAMP;}
  2458.   if (!strcmp(name, "black")) {  return RI_BLACK;}
  2459.   if (!strcmp(name, "abort")) {  return RI_ABORT;}
  2460.   if (!strcmp(name, "comment")) {  return RI_COMMENT;}
  2461.   if (!strcmp(name, "structure")) {  return RI_STRUCTURE;}
  2462.   if (!strcmp(name, "identifier")) {  return RI_IDENTIFIER;}
  2463.  
  2464.   /* we'll ignore the 4.0 tokens for now */
  2465.  
  2466.   /* is it a user defined token? */
  2467.   for (i = 0; i < howMany; i++)
  2468.   {  aRIBVar = (RIB_var_t *)list_get_nth(me->rib_var_list, i);
  2469.      if (!strcmp(aRIBVar->name, name))
  2470.      {  return (aRIBVar->token);
  2471.      }
  2472.   }
  2473.   return RI_NULL;
  2474. }
  2475.  
  2476. int
  2477. buildParameterList(me, interp, n, tokens, parms, archiveVector, printfNVector, printfTypeVector, startingArgIndex, argv)
  2478. WWEveParser  *me;
  2479. Tcl_Interp    *interp;
  2480. int           n;
  2481. RtToken       **tokens;
  2482. RtPointer     **parms;
  2483. char          ***archiveVector;
  2484. int           **printfNVector;
  2485. int           **printfTypeVector;
  2486. int           startingArgIndex;
  2487. char          **argv;
  2488. {
  2489.   RtToken    *tokenPtr = (RtToken *)RI_NULL;
  2490.   RtPointer  *parmPtr = (RtPointer *)RI_NULL;
  2491.   int        err, i, j, *printfNPtr, *printfTypePtr;
  2492.   char       *tokenName, **archiveVectorPtr = NULL;
  2493.  
  2494.  
  2495.   if (n == 0)
  2496.   {  return 1;
  2497.   }
  2498.   if (n < 0)
  2499.   {  sprintf(errBuf, "buildParameterList() : weird number of arguments");
  2500.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  2501.      return 0;
  2502.   }
  2503.   *tokens = (RtToken *)malloc(n * sizeof(RtToken));
  2504.   *parms = (RtPointer *)malloc(n * sizeof(RtPointer));
  2505.   *archiveVector = (char **)malloc(n * sizeof(char *));
  2506.   *printfNVector = (int *)malloc(n * sizeof(int));
  2507.   *printfTypeVector = (int *)malloc(n * sizeof(int));
  2508.   if ((!(*tokens)) || (!(*parms)) || (!(*archiveVector)) || (!(*printfNVector)) || (!(*printfTypeVector)))
  2509.   {  if (*tokens) { free(*tokens); }
  2510.      if (*parms) { free(*parms); }
  2511.      if (*archiveVector) { free(*archiveVector); }
  2512.      if (*printfNVector) { free(*printfNVector); }
  2513.      if (*printfTypeVector) { free(*printfTypeVector); }
  2514.      sprintf(errBuf, "buildParameterList() : unable to malloc enough memory for parameter list!");
  2515.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  2516.      return 0;
  2517.   }
  2518.   tokenPtr = *tokens; parmPtr = *parms; archiveVectorPtr = *archiveVector; printfNPtr = *printfNVector; printfTypePtr = *printfTypeVector;
  2519.   err = 0;
  2520.  
  2521.   for (i = startingArgIndex; i < ((n*2) + startingArgIndex); i += 2)
  2522.   {  tokenName = (char *)strcpy(malloc(1 + strlen(argv[i])), argv[i]);
  2523.      *tokenPtr = getTokenGivenName(me, tokenName);
  2524.      *parmPtr = parseTokenNameAndParameterIntoParm(me, interp, *tokenPtr, tokenName, argv[i + 1], &err);
  2525.      if (err)
  2526.      {  /* we assume something bad happened in parsing the parameter */
  2527.     /* we also assume that errBuf has been set appropriately */
  2528.     /* clean up and get out - really should go back over both lists... */
  2529.     /* i.e. unwind over i back to 2, freeing both token and parm and their contents */
  2530.         /* actually, it's only if I malloc'ed the tokenPtr, which, in most cases I won't have */
  2531.         /* for now, the bookkeeping is too much of a pain... FIX */
  2532.         j = i;
  2533.     while (j >= startingArgIndex)
  2534.     { if (*parmPtr) 
  2535.           { free(*parmPtr); 
  2536.           }
  2537.       tokenPtr--; 
  2538.           parmPtr--; 
  2539.           j -= 2;
  2540.         }
  2541.         return 0;
  2542.     } 
  2543.     *archiveVectorPtr = parseTokenNameAndParameterIntoArchiveInfo(me, interp, *tokenPtr, tokenName, argv[i + 1], &err);
  2544.      if (err)
  2545.      {  /* we assume something bad happened in parsing the parameter */
  2546.     /* we also assume that errBuf has been set appropriately */
  2547.     /* clean up and get out - really should go back over both lists... */
  2548.     /* i.e. unwind over i back to 2, freeing both token and parm and their contents */
  2549.         /* actually, it's only if I malloc'ed the tokenPtr, which, in most cases I won't have */
  2550.         /* for now, the bookkeeping is too much of a pain... FIX */
  2551.         j = i;
  2552.     while (j >= startingArgIndex)
  2553.     { if (*parmPtr) 
  2554.           { free(*parmPtr); 
  2555.           }
  2556.       tokenPtr--; 
  2557.           parmPtr--; 
  2558.           j -= 2;
  2559.         }
  2560.         return 0;
  2561.     } 
  2562.     *printfNPtr = parseTokenNameAndParameterIntoPrintfInfo(me, interp, *tokenPtr, tokenName, argv[i + 1], &err, printfTypePtr, printfNPtr);
  2563.      if (err)
  2564.      {  /* we assume something bad happened in parsing the parameter */
  2565.     /* we also assume that errBuf has been set appropriately */
  2566.     /* clean up and get out - really should go back over both lists... */
  2567.     /* i.e. unwind over i back to 2, freeing both token and parm and their contents */
  2568.         /* actually, it's only if I malloc'ed the tokenPtr, which, in most cases I won't have */
  2569.         /* for now, the bookkeeping is too much of a pain... FIX */
  2570.         j = i;
  2571.     while (j >= startingArgIndex)
  2572.     { if (*parmPtr) 
  2573.           { free(*parmPtr); 
  2574.           }
  2575.       tokenPtr--; 
  2576.           parmPtr--; 
  2577.           j -= 2;
  2578.         }
  2579.         return 0;
  2580.     } 
  2581.     tokenPtr++; parmPtr++; archiveVectorPtr++; printfNPtr++; printfTypePtr++;
  2582.   }
  2583.   return 1;
  2584. }
  2585.  
  2586.  
  2587. static int
  2588. cmd_massageRIB(me, interp, argc, argv)
  2589. WWEveParser    *me;
  2590. Tcl_Interp     *interp;
  2591. int            argc;
  2592. char           **argv;
  2593. {
  2594.   char         *my_args = "inputRIBFile outputEveFile";
  2595.   int           num_args = 3;
  2596.  
  2597.  
  2598.   sprintf(errBuf, "evaluating %s...", argv[0]);
  2599.   [[me statusText] setStringValue:errBuf]; [[me statusText] display]; NXPing();
  2600.   if (argc < num_args)
  2601.   {  sprintf(errBuf, "USAGE: %s %s", argv[0], my_args);
  2602.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  2603.      return TCL_ERROR;
  2604.   }
  2605.   if (!massageRIB(interp, argv[1], argv[2]))
  2606.   {  return TCL_ERROR;
  2607.   }
  2608.  
  2609.   return TCL_OK;
  2610. }
  2611.  
  2612.  
  2613. static int
  2614. cmd_render(me, interp, argc, argv)
  2615. WWEveParser    *me;
  2616. Tcl_Interp     *interp;
  2617. int            argc;
  2618. char           **argv;
  2619. {
  2620.   char         *my_args = "inputRIBFile tmpFilename", *tmpFilename, *extension, *extension2, *retBuf;
  2621.   int           num_args = 3, ret,  howMany = list_size(me->rib_var_list), i;
  2622.   static char  cmdBuf[2048];
  2623.   //BOOL         oldFlag = [[me tclInterp] showErrors];
  2624.  
  2625.  
  2626.   sprintf(errBuf, "evaluating %s...", argv[0]);
  2627.   [[me statusText] setStringValue:errBuf]; [[me statusText] display]; NXPing();
  2628.   if (argc < num_args)
  2629.   {  sprintf(errBuf, "USAGE: %s %s", argv[0], my_args);
  2630.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  2631.      return TCL_ERROR;
  2632.   }
  2633.  
  2634.   tmpFilename = argv[2];
  2635.  
  2636.   extension = argv[1] + (strlen(argv[1]) - 4);
  2637.   if ((strlen(argv[1]) > 5) && (!strcmp(extension, ".eve")))
  2638.   {  // no need to massage it - it's already in eve format...
  2639.      tmpFilename = argv[1];
  2640.   }
  2641.   else  // check if it's a wwScene file...
  2642.   {  extension2 = argv[1] + (strlen(argv[1]) - 8);
  2643.      if ((strlen(argv[1]) > 9) && (!strcmp(extension2, ".wwScene")))
  2644.      {  // no need to massage it - it's already in eve format...
  2645.         tmpFilename = argv[1];
  2646.      }
  2647.      else
  2648.      {  if (!massageRIB(interp, argv[1], tmpFilename))
  2649.         {  return TCL_ERROR;
  2650.         }
  2651.      }
  2652.   }
  2653.   if ([me riBegun])
  2654.   {  // RiClose();
  2655.   }
  2656.  
  2657.   howMany = list_size(me->rib_parm_list);
  2658.   for (i = 0; i < howMany; i++)
  2659.   {  list_delete_nth(me->rib_parm_list, 0);
  2660.   }
  2661.  
  2662.   howMany = list_size(me->rib_var_list);
  2663.   for (i = 0; i < howMany; i++)
  2664.   {  list_delete_nth(me->rib_var_list, 0);
  2665.   }
  2666.  
  2667.   howMany = list_size(me->rib_object_list);
  2668.   for (i = 0; i < howMany; i++)
  2669.   {  list_delete_nth(me->rib_object_list, 0);
  2670.   }
  2671.  
  2672.   howMany = list_size(me->rib_light_list);
  2673.   for (i = 0; i < howMany; i++)
  2674.   {  list_delete_nth(me->rib_light_list, 0);
  2675.   }
  2676.  
  2677.   // RiBegin(argv[2]);
  2678.   [me setRiBegun:YES];
  2679.  
  2680.   if (!declarePIXARSpecificStuff(me, interp))
  2681.   {  return TCL_ERROR;
  2682.   }
  2683.  
  2684.   if (!declareGESTELSpecificStuff(me, interp))
  2685.   {  return TCL_ERROR;
  2686.   }
  2687.  
  2688.   if (!declareBMRTSpecificStuff(me, interp))
  2689.   {  return TCL_ERROR;
  2690.   }
  2691.  
  2692.   sprintf(cmdBuf, "source {%s}", tmpFilename);
  2693.   //[[me tclInterp] setShowErrors:NO];
  2694.   retBuf = [[me tclInterp] eval:cmdBuf :&ret];
  2695.   if (ret != TCL_OK)
  2696.   {  //[me showError:retBuf];
  2697.   }
  2698.   //[[me tclInterp] setShowErrors:oldFlag];
  2699.  
  2700.   if (retBuf) { free(retBuf); }
  2701.  
  2702.   // RiEnd();
  2703.   [me setRiBegun:NO];
  2704.  
  2705.   return ret;
  2706. }
  2707.  
  2708.  
  2709. static int
  2710. cmd_RiDeclare(me, interp, argc, argv)
  2711. WWEveParser    *me;
  2712. Tcl_Interp     *interp;
  2713. int            argc;
  2714. char           **argv;
  2715. {
  2716.   char  *my_args = "name {[uniform|varying|vertex] point|color|float|integer|int|string [{n}]}";
  2717.   char       declaration[256], **argv2, **argv3;
  2718.   RtToken    returnToken;
  2719.   RIB_var_t  *newRIBVar;
  2720.   int        argc2, argc3;
  2721.   char       *class = NULL, *type = NULL, n = 1;
  2722.   id         newRIBCommand;
  2723.  
  2724.  
  2725.   sprintf(errBuf, "evaluating %s...", argv[0]);
  2726.   [[me statusText] setStringValue:errBuf]; [[me statusText] display]; NXPing();
  2727.   if (![me riBegun])
  2728.   {  sprintf(errBuf, "You must call RiBegin before making any RIB calls");
  2729.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  2730.      return TCL_ERROR;
  2731.   }
  2732.  
  2733.   if (argc != 3)
  2734.   {  sprintf(errBuf, "USAGE: %s %s", argv[0], my_args);
  2735.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  2736.      return TCL_ERROR;
  2737.   }
  2738.  
  2739.   if (Tcl_SplitList(interp, argv[2], &argc2, &argv2) != TCL_OK)
  2740.   {  sprintf(errBuf, "%s :problem splitting 3rd arg as list", argv[0]);
  2741.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  2742.      return TCL_ERROR;
  2743.   }
  2744.  
  2745.   if ((argc > 3) || (argc < 2))
  2746.   {  sprintf(errBuf, "USAGE: %s %s", argv[0], my_args);
  2747.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  2748.      return TCL_ERROR;
  2749.   }
  2750.   if (argc2 == 2) /* uniform|varying|vertex point|color|float|integer|int|string [{n}] */
  2751.   {  if (   strcmp(argv2[0], "uniform") && strcmp(argv2[0], "varying") && strcmp(argv2[0], "vertex")
  2752.          && strcmp(argv2[0], "float") 
  2753.             && strcmp(argv2[0], "integer") 
  2754.             && strcmp(argv2[0], "int") 
  2755.             && strcmp(argv2[0], "string") 
  2756.             && strcmp(argv2[0], "point") 
  2757.             && strcmp(argv2[0], "color"))
  2758.      {  sprintf(errBuf, "USAGE: %s %s", argv[0], my_args);
  2759.         Tcl_AppendResult(interp, errBuf, (char *)NULL);
  2760.         return TCL_ERROR;
  2761.      }
  2762.   }
  2763.   if (argc2 == 3) /* uniform|varying|vertex point|color|float|integer|int|string [{n}] */
  2764.   {  if (strcmp(argv2[0], "uniform") && strcmp(argv2[0], "varying") && strcmp(argv2[0], "vertex"))
  2765.      {  sprintf(errBuf, "USAGE: %s %s", argv[0], my_args);
  2766.         Tcl_AppendResult(interp, errBuf, (char *)NULL);
  2767.         return TCL_ERROR;
  2768.      }
  2769.   }
  2770.   if (argc2 == 1) /* point|color|float|integer|int|string */
  2771.   {  if (strcmp(argv2[0], "float") && strcmp(argv2[0], "integer") && strcmp(argv2[0], "int") && strcmp(argv2[0], "string") && strcmp(argv2[0], "point") && strcmp(argv2[0], "color"))
  2772.      {  sprintf(errBuf, "USAGE: %s %s", argv[0], my_args);
  2773.         Tcl_AppendResult(interp, errBuf, (char *)NULL);
  2774.         return TCL_ERROR;
  2775.      }
  2776.      type = argv2[0];
  2777.      sprintf(declaration, "%s", type); /* Declare foo float */
  2778.   }
  2779.   else  /* uniform|varying|vertex point|color|float|integer|int|string [{n}] */
  2780.   {  if (argc2 == 2)
  2781.      {  if (   strcmp(argv2[0], "uniform") 
  2782.             && strcmp(argv2[0], "varying") 
  2783.             && strcmp(argv2[0], "vertex")) 
  2784.         {  // okay, we're defaulting to "uniform"
  2785.            class = "uniform";
  2786.            if (   strcmp(argv2[0], "float") 
  2787.                && strcmp(argv2[0], "integer") 
  2788.                && strcmp(argv2[0], "int") 
  2789.                && strcmp(argv2[0], "string") 
  2790.                && strcmp(argv2[0], "point") 
  2791.                && strcmp(argv2[0], "color"))
  2792.            {  sprintf(errBuf, "USAGE: %s %s", argv[0], my_args);
  2793.               Tcl_AppendResult(interp, errBuf, (char *)NULL);
  2794.               return TCL_ERROR;
  2795.            }
  2796.            type = argv2[0];
  2797.            if (Tcl_SplitList(interp, argv2[1], &argc3, &argv3) != TCL_OK)
  2798.            {  sprintf(errBuf, "%s : problem splitting <%s> as a list", argv[0], argv2[1]);
  2799.              Tcl_AppendResult(interp, errBuf, (char *)NULL);
  2800.           return TCL_ERROR;
  2801.            }
  2802.            if (argc3 != 1)
  2803.            {  sprintf(errBuf, "USAGE: %s %s", argv[0], my_args);
  2804.              Tcl_AppendResult(interp, errBuf, (char *)NULL);
  2805.           return TCL_ERROR;
  2806.            }
  2807.            n = atoi(argv3[0]);
  2808.            sprintf(declaration, "%s %s[%d]", class, type, n);  /* Declare foo varying float[3] */
  2809.         }
  2810.         else
  2811.         {  if (   strcmp(argv2[1], "float") 
  2812.                && strcmp(argv2[1], "integer") 
  2813.                && strcmp(argv2[1], "int") 
  2814.                && strcmp(argv2[1], "string") 
  2815.                && strcmp(argv2[1], "point") 
  2816.                && strcmp(argv2[1], "color"))
  2817.            {  sprintf(errBuf, "USAGE: %s %s", argv[0], my_args);
  2818.               Tcl_AppendResult(interp, errBuf, (char *)NULL);
  2819.               return TCL_ERROR;
  2820.            }
  2821.            class = argv2[0];
  2822.            type = argv2[1];
  2823.         }
  2824.         sprintf(declaration, "%s %s", class, type);  /* Declare foo varying float */
  2825.      }
  2826.      else /* uniform|varying|vertex point|color|float|integer|int|string {n} */
  2827.      {  if (Tcl_SplitList(interp, argv2[2], &argc3, &argv3) != TCL_OK)
  2828.         {  sprintf(errBuf, "%s : problem splitting <%s> as a list", argv[0], argv2[2]);
  2829.           Tcl_AppendResult(interp, errBuf, (char *)NULL);
  2830.        return TCL_ERROR;
  2831.         }
  2832.  
  2833.         if (argc3 != 1)
  2834.         {  sprintf(errBuf, "USAGE: %s %s", argv[0], my_args);
  2835.           Tcl_AppendResult(interp, errBuf, (char *)NULL);
  2836.        return TCL_ERROR;
  2837.         }
  2838.         class = argv2[0];
  2839.         type = argv2[1];
  2840.         n = atoi(argv3[0]);
  2841.         sprintf(declaration, "%s %s[%d]", class, type, n);  /* Declare foo varying float[3] */
  2842.      }
  2843.   }
  2844.  
  2845.   returnToken = RiDeclare(argv[1], declaration);
  2846.  
  2847.   /* malloc up a RIB_var_t here, stick argv[1] and the token in there.  */
  2848.   /* when they hand you back a token (really, the name) look it up */
  2849.   newRIBVar = (RIB_var_t *)malloc(sizeof(RIB_var_t));
  2850.   if (!newRIBVar)
  2851.   {  sprintf(errBuf, "RiDeclare : unable to malloc memory for new RIB var"); 
  2852.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  2853.      return TCL_ERROR;
  2854.   }
  2855.  
  2856.   newRIBVar->name = strcpy((char *)malloc(1 + strlen(argv[1])), argv[1]);
  2857.   newRIBVar->n = n;
  2858.   if (argc2 == 1)
  2859.   {  newRIBVar->class = strcpy((char *)malloc(1 + strlen("uniform")), "uniform");
  2860.      newRIBVar->type = strcpy((char *)malloc(1 + strlen(type)), type);
  2861.   }
  2862.   else
  2863.   {  newRIBVar->class = strcpy((char *)malloc(1 + strlen(class)), class);
  2864.      newRIBVar->type = strcpy((char *)malloc(1 + strlen(type)), type);
  2865.   }
  2866.   newRIBVar->token = returnToken;
  2867.  
  2868.   if (!strcmp(newRIBVar->type, "float"))
  2869.   {  newRIBVar->encodeFunc = encodeFloatRIBVar;
  2870.      newRIBVar->archiveFunc = archiveFloatRIBVar;
  2871.      newRIBVar->printfFunc = printfFloatRIBVar;
  2872.   }
  2873.   if (!strcmp(newRIBVar->type, "integer"))
  2874.   {  newRIBVar->encodeFunc = encodeIntegerRIBVar;
  2875.      newRIBVar->archiveFunc = archiveIntegerRIBVar;
  2876.      newRIBVar->printfFunc = printfIntegerRIBVar;
  2877.   }
  2878.   if (!strcmp(newRIBVar->type, "string"))
  2879.   {  newRIBVar->encodeFunc = encodeStringRIBVar;
  2880.      newRIBVar->archiveFunc = archiveStringRIBVar;
  2881.      newRIBVar->printfFunc = printfStringRIBVar;
  2882.   }
  2883.   if (!strcmp(newRIBVar->type, "point"))
  2884.   {  newRIBVar->encodeFunc = encodePointRIBVar;
  2885.      newRIBVar->archiveFunc = archivePointRIBVar;
  2886.      newRIBVar->printfFunc = printfPointRIBVar;
  2887.   }
  2888.   if (!strcmp(newRIBVar->type, "color"))
  2889.   {  newRIBVar->encodeFunc = encodeColorRIBVar;
  2890.      newRIBVar->archiveFunc = archiveColorRIBVar;
  2891.      newRIBVar->printfFunc = printfColorRIBVar;
  2892.   }
  2893.  
  2894.   list_put(me->rib_var_list, newRIBVar);
  2895.  
  2896.   newRIBCommand = [[RIBDeclare alloc] init];
  2897.   [newRIBCommand setName:argv[1] declaration:declaration];
  2898.   [newRIBCommand setMyShape:[me currentShape]];
  2899.  
  2900.   if ([me evaluatingEveCommand])
  2901.   {  [me setTmpRIBCommand:newRIBCommand];
  2902.   }
  2903.   else
  2904.   {  [[me currentShape] appendRIBCommand:newRIBCommand];
  2905.   }
  2906.  
  2907.   sprintf(interp->result, "%s", newRIBVar->name);
  2908.   Tcl_AppendResult(interp, errBuf, (char *)NULL);
  2909.  
  2910.   return TCL_OK;
  2911. }
  2912.  
  2913.  
  2914. static int
  2915. cmd_RiBegin(me, interp, argc, argv)
  2916. WWEveParser    *me;
  2917. Tcl_Interp     *interp;
  2918. int            argc;
  2919. char           **argv;
  2920. {
  2921.   char         *my_args = "name";
  2922.   int           num_args = 2, howMany = list_size(me->rib_var_list), i;
  2923.   RtToken      name = RI_NULL;
  2924.   RIB_var_t    *aRIBVar;
  2925.   RIB_light_t  *aRIBLight;
  2926.   RIB_object_t *aRIBObject;
  2927.  
  2928.  
  2929.   sprintf(errBuf, "evaluating %s...", argv[0]);
  2930.   [[me statusText] setStringValue:errBuf]; [[me statusText] display]; NXPing();
  2931.   if (argc > num_args)
  2932.   {  sprintf(errBuf, "USAGE: %s %s", argv[0], my_args);
  2933.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  2934.      return TCL_ERROR;
  2935.   }
  2936.  
  2937.   if ([me riBegun])
  2938.   {  //RiClose();
  2939.   }
  2940.  
  2941.   if (argc > 1)
  2942.   {  name = (RtToken)argv[1];
  2943.   }
  2944.  
  2945.   /* clear out the rib_var list */
  2946.   for (i = 0; i < howMany; i++)
  2947.   {  aRIBVar = (RIB_var_t *)list_get_nth(me->rib_var_list, 0);
  2948.      list_delete_nth(me->rib_var_list, 0);
  2949.      if (aRIBVar)
  2950.      {  free(aRIBVar);
  2951.      }
  2952.   }
  2953.  
  2954.   /* don't free the parm list - each RIBCommand will do that */
  2955.  
  2956.   /* free object list */
  2957.   howMany = list_size(me->rib_object_list);
  2958.   for (i = 0; i < howMany; i++)
  2959.   {  aRIBObject = (RIB_object_t *)(list_get_nth(me->rib_object_list, 0));
  2960.      list_delete_nth(me->rib_object_list, 0);
  2961.      if (aRIBObject)
  2962.      {  free(aRIBObject);
  2963.      }
  2964.   }
  2965.  
  2966.   /* free light list */
  2967.   howMany = list_size(me->rib_light_list);
  2968.   for (i = 0; i < howMany; i++)
  2969.   {  aRIBLight = (RIB_light_t *)(list_get_nth(me->rib_light_list, 0));
  2970.      list_delete_nth(me->rib_light_list, 0);
  2971.      if (aRIBLight)
  2972.      {  free(aRIBLight);
  2973.      }
  2974.   }
  2975.  
  2976.   // RiBegin(name);
  2977.   [me setRiBegun:YES];
  2978.  
  2979.   if (!declarePIXARSpecificStuff(me, interp))
  2980.   {  return TCL_ERROR;
  2981.   }
  2982.  
  2983.   if (!declareGESTELSpecificStuff(me, interp))
  2984.   {  return TCL_ERROR;
  2985.   }
  2986.  
  2987.   return TCL_OK;
  2988. }
  2989.  
  2990.  
  2991. static int
  2992. cmd_RiEnd(me, interp, argc, argv)
  2993. WWEveParser    *me;
  2994. Tcl_Interp     *interp;
  2995. int            argc;
  2996. char           **argv;
  2997. {
  2998.   char       *my_args = "";
  2999.   int         num_args = 1, howMany, i;
  3000.   RtPointer  aPtr;
  3001.  
  3002.  
  3003.   sprintf(errBuf, "evaluating %s...", argv[0]);
  3004.   [[me statusText] setStringValue:errBuf]; [[me statusText] display]; NXPing();
  3005.   if (![me riBegun])
  3006.   {  sprintf(errBuf, "You must call RiBegin before making any RIB calls");
  3007.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  3008.      return TCL_ERROR;
  3009.   }
  3010.  
  3011.   if (argc > num_args)
  3012.   {  sprintf(errBuf, "USAGE: %s %s", argv[0], my_args);
  3013.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  3014.      return TCL_ERROR;
  3015.   }
  3016.  
  3017.   // RiEnd();
  3018.  
  3019.   [me setRiBegun:NO];
  3020.  
  3021.   /* free parm list */
  3022.   howMany = list_size(me->rib_parm_list);
  3023.   for (i = 0; i < howMany; i++)
  3024.   {  aPtr = (RtPointer)list_get_nth(me->rib_parm_list, 0);
  3025.      list_delete_nth(me->rib_parm_list, 0);
  3026.      if (aPtr)
  3027.      {  free(aPtr);
  3028.      }
  3029.   }
  3030.  
  3031.   return TCL_OK;
  3032. }
  3033.  
  3034.  
  3035. static int
  3036. cmd_RiWorldBegin(me, interp, argc, argv)
  3037. WWEveParser    *me;
  3038. Tcl_Interp     *interp;
  3039. int            argc;
  3040. char           **argv;
  3041. {
  3042.   char  *my_args = "";
  3043.   int    num_args = 1;
  3044.   id    newShape;
  3045.  
  3046.  
  3047.   sprintf(errBuf, "evaluating %s...", argv[0]);
  3048.   [[me statusText] setStringValue:errBuf]; [[me statusText] display]; NXPing();
  3049.   if (argc < num_args)
  3050.   {  sprintf(errBuf, "USAGE: %s %s", argv[0], my_args);
  3051.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  3052.      return TCL_ERROR;
  3053.   }
  3054.  
  3055.   [me setRiBegun:YES];
  3056.   newShape = [[WW3DShape alloc] initWithInterp:[me tclInterp] andSceneClock:[me sceneClock]];
  3057.   [newShape setShapeName:"World"];
  3058.   if ([me currentShape])
  3059.   {  [[me currentShape] addChild:newShape];
  3060.   }
  3061.   else
  3062.   {  [me setTmpRootShape:newShape];
  3063.   }
  3064.   [me setCurrentShape:newShape];
  3065.  
  3066.  
  3067.   return TCL_OK;
  3068. }
  3069.  
  3070.  
  3071. static int
  3072. cmd_RiWorldEnd(me, interp, argc, argv)
  3073. WWEveParser    *me;
  3074. Tcl_Interp     *interp;
  3075. int            argc;
  3076. char           **argv;
  3077. {
  3078.   char  *my_args = "";
  3079.   int    num_args = 1;
  3080.  
  3081.  
  3082.   sprintf(errBuf, "evaluating %s...", argv[0]);
  3083.   [[me statusText] setStringValue:errBuf]; [[me statusText] display]; NXPing();
  3084.   if (![me riBegun])
  3085.   {  sprintf(errBuf, "You must call RiBegin before making any RIB calls");
  3086.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  3087.      return TCL_ERROR;
  3088.   }
  3089.  
  3090.   if (argc < num_args)
  3091.   {  sprintf(errBuf, "USAGE: %s %s", argv[0], my_args);
  3092.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  3093.      return TCL_ERROR;
  3094.   }
  3095.  
  3096.   // RiWorldEnd();
  3097.   // at this point, calculate bounding box of current shape
  3098.   //[[me currentShape] logTransformWithMsg:"WorldEnd before boundingBox calc"];
  3099.   [[me currentShape] calculateBoundingBoxStartingAt:[[me sceneClock] timestamp] endingAt:[[me sceneClock] timestamp]]; 
  3100.   //[[me currentShape] logTransformWithMsg:"WorldEnd after boundingBox calc"];
  3101.   [me setRiBegun:NO];
  3102.  
  3103.   return TCL_OK;
  3104. }
  3105.  
  3106.  
  3107. static int
  3108. cmd_RiColorSamples(me, interp, argc, argv)
  3109. WWEveParser    *me;
  3110. Tcl_Interp     *interp;
  3111. int            argc;
  3112. char           **argv;
  3113. {
  3114.   char     *my_args = "{nRGB} ... {RGBn}";
  3115.   int       num_args = 3, vecLen, i, argc2;
  3116.   RtInt    n, n1, n2;
  3117.   char     **argv2;
  3118.   RtFloat  *nRGB, *RGBn;
  3119.  
  3120.  
  3121.   sprintf(errBuf, "evaluating %s...", argv[0]);
  3122.   [[me statusText] setStringValue:errBuf]; [[me statusText] display]; NXPing();
  3123.   if (![me riBegun])
  3124.   {  sprintf(errBuf, "You must call RiBegin before making any RIB calls");
  3125.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  3126.      return TCL_ERROR;
  3127.   }
  3128.  
  3129.   if (argc < num_args)
  3130.   {  sprintf(errBuf, "USAGE: %s %s", argv[0], my_args);
  3131.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  3132.      return TCL_ERROR;
  3133.   }
  3134.  
  3135.   if (Tcl_SplitList(interp, argv[1], &argc2, &argv2) != TCL_OK)
  3136.   {  sprintf(errBuf, "%s: problem splitting <%s> as a list", argv[0], argv[1]);
  3137.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  3138.      return TCL_ERROR;
  3139.   }
  3140.   n1 = argc2; 
  3141.   if (n1 % 3)
  3142.   {  sprintf(errBuf, "%s must be a %d x 3 transform : USAGE: %s %s", argv[1], (int)(n1/3), argv[0], my_args);
  3143.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  3144.      return TCL_ERROR;
  3145.   }
  3146.  
  3147.   n = n1/3;
  3148.   vecLen = n1;
  3149.   nRGB = (RtFloat *)malloc(vecLen * sizeof(RtFloat));
  3150.   for (i = 0; i < vecLen; i++)
  3151.   {  nRGB[i] = (RtFloat)atof(argv2[i]);
  3152.   }
  3153.   free(argv2);
  3154.  
  3155.   if (Tcl_SplitList(interp, argv[2], &argc2, &argv2) != TCL_OK)
  3156.   {  sprintf(errBuf, "%s : problem splitting <%s> as a list", argv[0], argv[2]);
  3157.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  3158.      return TCL_ERROR;
  3159.   }
  3160.  
  3161.   n2 = argc2; 
  3162.   if ((n2 % 3) || (n1 != n2))
  3163.   {  sprintf(errBuf, "%s must be a %d x 3 transform : USAGE: %s %s", argv[2], (int)(n2/3), argv[0], my_args);
  3164.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  3165.      return TCL_ERROR;
  3166.   }
  3167.   RGBn = (RtFloat *)malloc(vecLen * sizeof(RtFloat));
  3168.   for (i = 0; i < vecLen; i++)
  3169.   {  RGBn[i] = (RtFloat)atof(argv2[i]);
  3170.   }
  3171.   free(argv2);
  3172.  
  3173.   // RiColorSamples(n, nRGB, RGBn);
  3174.  
  3175.   return TCL_OK;
  3176. }
  3177.  
  3178.  
  3179. static int
  3180. cmd_RiOption(me, interp, argc, argv)
  3181. WWEveParser    *me;
  3182. Tcl_Interp     *interp;
  3183. int            argc;
  3184. char           **argv;
  3185. {
  3186.   char  *my_args = "name [parameterlist]";
  3187.   int    num_args = 2, n;
  3188.   RtToken    *tokens = (RtToken *)RI_NULL;
  3189.   RtPointer  *parms = (RtPointer *)RI_NULL;
  3190.   int        *nVector = NULL, 
  3191.              *typeVector = NULL;
  3192.   char       **archiveVector = NULL;
  3193.   id         newRIBCommand;
  3194.  
  3195.  
  3196.  
  3197.  
  3198.   sprintf(errBuf, "evaluating %s...", argv[0]);
  3199.   [[me statusText] setStringValue:errBuf]; [[me statusText] display]; NXPing();
  3200.   if (![me riBegun])
  3201.   {  sprintf(errBuf, "You must call RiBegin before making any RIB calls");
  3202.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  3203.      return TCL_ERROR;
  3204.   }
  3205.  
  3206.   if (argc < num_args)
  3207.   {  sprintf(errBuf, "USAGE: %s %s", argv[0], my_args);
  3208.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  3209.      return TCL_ERROR;
  3210.   }
  3211.  
  3212.   if (argc % 2)
  3213.   {  sprintf(errBuf, "RiOption : parameter list must be in groups of two, i.e. the number of args is an even number");
  3214.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  3215.      return TCL_ERROR;
  3216.   }
  3217.  
  3218.   n = 0;
  3219.   if (argc > num_args)
  3220.   {  n = (argc - num_args) / 2;
  3221.      if (!buildParameterList(me, interp, n, &tokens, &parms, &archiveVector, &nVector, &typeVector, num_args, argv))
  3222.      {  return TCL_ERROR;
  3223.      }
  3224.   }
  3225.  
  3226.   // RiOptionV((RtToken)argv[1], n, tokens, parms);
  3227.  
  3228.   newRIBCommand = [[RIBOption alloc] init];
  3229.   [newRIBCommand setName:argv[1]
  3230.                     n:n tokens:tokens parms:parms archiveVector:archiveVector printfTypeVector:typeVector printfNVector:nVector];
  3231.   [newRIBCommand setMyShape:[me currentShape]];
  3232.   if ([me evaluatingEveCommand])
  3233.   {  [me setTmpRIBCommand:newRIBCommand];
  3234.   }
  3235.   else
  3236.   {  [[me currentShape] appendRIBCommand:newRIBCommand];
  3237.   }
  3238.  
  3239.   return TCL_OK;
  3240. }
  3241.  
  3242.  
  3243. static int
  3244. cmd_RiAttributeBegin(me, interp, argc, argv)
  3245. WWEveParser    *me;
  3246. Tcl_Interp     *interp;
  3247. int            argc;
  3248. char           **argv;
  3249. {
  3250.   char  *my_args = "";
  3251.   int    num_args = 1;
  3252.   id    newShape, newRIBCommand;
  3253.   static char  nameBuf[64];
  3254.  
  3255.  
  3256.   sprintf(errBuf, "evaluating %s...", argv[0]);
  3257.   [[me statusText] setStringValue:errBuf]; [[me statusText] display]; NXPing();
  3258.   if (![me riBegun])
  3259.   {  sprintf(errBuf, "You must call RiBegin before making any RIB calls");
  3260.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  3261.      return TCL_ERROR;
  3262.   }
  3263.  
  3264.   if (argc != num_args)
  3265.   {  sprintf(errBuf, "USAGE: %s %s", argv[0], my_args);
  3266.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  3267.      return TCL_ERROR;
  3268.   }
  3269.  
  3270.   if ([me evaluatingEveProc] || ![me treatAttributeBeginLikeStartShape])
  3271.   {  newRIBCommand = [[RIBAttributeBegin alloc] init];
  3272.      [newRIBCommand setMyShape:[me currentShape]];
  3273.      if ([me evaluatingEveCommand])
  3274.      {  [me setTmpRIBCommand:newRIBCommand];
  3275.      }
  3276.      else
  3277.      {  [[me currentShape] appendRIBCommand:newRIBCommand];
  3278.      }
  3279.      return TCL_OK;
  3280.   }
  3281.  
  3282.   newShape = [[WW3DShape alloc] initWithInterp:[me tclInterp] andSceneClock:[me sceneClock]];
  3283.   sprintf(nameBuf, "changeMyNamePlease%d", ([me uniqueTag]));
  3284.   [newShape setShapeName:nameBuf];
  3285.   if ([me currentShape])
  3286.   {  [[me currentShape] addChild:newShape];
  3287.   }
  3288.   else
  3289.   {  [me setTmpRootShape:newShape];
  3290.   }
  3291.   [me setCurrentShape:newShape];
  3292.  
  3293.   return TCL_OK;
  3294. }
  3295.  
  3296.  
  3297. static int
  3298. cmd_StartRootShape(me, interp, argc, argv)
  3299. WWEveParser    *me;
  3300. Tcl_Interp     *interp;
  3301. int            argc;
  3302. char           **argv;
  3303. {
  3304.   char  *my_args = "shapeName";
  3305.   int    num_args = 2;
  3306.   id    newShape;
  3307.  
  3308.  
  3309.   sprintf(errBuf, "evaluating %s...", argv[0]);
  3310.   [[me statusText] setStringValue:errBuf]; [[me statusText] display]; NXPing();
  3311.   if (argc != num_args)
  3312.   {  sprintf(errBuf, "USAGE: %s %s", argv[0], my_args);
  3313.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  3314.      return TCL_ERROR;
  3315.   }
  3316.  
  3317.   [me setRiBegun:YES];
  3318.   newShape = [[WW3DShape alloc] initWithInterp:[me tclInterp] andSceneClock:[me sceneClock]];
  3319.   [newShape setShapeName:argv[1]];
  3320.   [me setTmpRootShape:newShape];
  3321.   [me setCurrentShape:newShape];
  3322.  
  3323.   return TCL_OK;
  3324. }
  3325.  
  3326.  
  3327. static int
  3328. cmd_InstallRootShape(me, interp, argc, argv)
  3329. WWEveParser    *me;
  3330. Tcl_Interp     *interp;
  3331. int            argc;
  3332. char           **argv;
  3333. {
  3334.   sprintf(errBuf, "evaluating %s...", argv[0]);
  3335.   [[me statusText] setStringValue:errBuf]; [[me statusText] display]; NXPing();
  3336.   [me installRootShapeInWell];
  3337.  
  3338.   return TCL_OK;
  3339. }
  3340.  
  3341.  
  3342. static int
  3343. cmd_StartShape(me, interp, argc, argv)
  3344. WWEveParser    *me;
  3345. Tcl_Interp     *interp;
  3346. int            argc;
  3347. char           **argv;
  3348. {
  3349.   char  *my_args = "shapeName [{transformationMatrix}]", **argv2;
  3350.   int    argc2, i, j, cnt = 0;
  3351.   id    newShape, newRIBCommand;
  3352.   RtMatrix  transformMatrix;
  3353.  
  3354.  
  3355.   sprintf(errBuf, "evaluating %s...", argv[0]);
  3356.   [[me statusText] setStringValue:errBuf]; [[me statusText] display]; NXPing();
  3357.   if ((argc != 2) && (argc != 3))
  3358.   {  sprintf(errBuf, "USAGE: %s %s", argv[0], my_args);
  3359.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  3360.      return TCL_ERROR;
  3361.   }
  3362.  
  3363.   if (argc == 3)
  3364.   {  if (Tcl_SplitList(interp, argv[2], &argc2, &argv2) != TCL_OK)
  3365.      {  sprintf(errBuf, 
  3366.         "%s : problem splitting <%s> as a list", 
  3367.         argv[0], argv[2]);
  3368.     Tcl_AppendResult(interp, errBuf, (char *)NULL);
  3369.     return TCL_ERROR;
  3370.      }
  3371.  
  3372.      if (argc2 != 16)
  3373.      {  sprintf(errBuf, 
  3374.         "USAGE: %s %s\n4x4matrix should have 16 elements, not %d", 
  3375.         argv[0], my_args, argc2);
  3376.     Tcl_AppendResult(interp, errBuf, (char *)NULL);
  3377.     return TCL_ERROR;
  3378.      }
  3379.  
  3380.      for (i = 0; i < 4; i++)
  3381.      {  for (j = 0; j < 4; j++)
  3382.     {  transformMatrix[i][j] = (RtFloat)atof(argv2[cnt++]);
  3383.         }
  3384.      }
  3385.      free(argv2);
  3386.   } 
  3387.  
  3388.   if ([me evaluatingEveProc])
  3389.   {  if (argc == 3)
  3390.      {  NXLogError("warning: using a startShape command inside an EveProc: ");
  3391.         NXLogError("should be using a RIBAttributeBegin and RIBConcatTransform objects instead of a WW3DShape,");
  3392.         NXLogError("but right now, I'm ignoring the matrix and merely substituting a RIBAttributeBegin object...");
  3393.         newRIBCommand = [[RIBAttributeBegin alloc] init];
  3394.         [newRIBCommand setMyShape:[me currentShape]];
  3395.         [me setTmpRIBCommand:newRIBCommand];
  3396.      }
  3397.      else
  3398.      {  NXLogError("warning: using a startShape command inside an EveProc: using a RIBAttributeBegin object instead of a WW3DShape...");
  3399.         newRIBCommand = [[RIBAttributeBegin alloc] init];
  3400.         [newRIBCommand setMyShape:[me currentShape]];
  3401.         [me setTmpRIBCommand:newRIBCommand];
  3402.      }
  3403.      return TCL_OK;
  3404.   }
  3405.  
  3406.   if ([me evaluatingEveProc])
  3407.   {  sprintf(errBuf, "you cannot nest a startShape call inside an EveProc call - try an AttributeBegin/End pair instead");
  3408.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  3409.      return TCL_ERROR;
  3410.   }
  3411.  
  3412.   [me setRiBegun:YES];
  3413.   newShape = [[WW3DShape alloc] initWithInterp:[me tclInterp] andSceneClock:[me sceneClock]];
  3414.   [newShape setShapeName:argv[1]];
  3415.   if (argc == 3)
  3416.   {  [newShape setTransformMatrix:transformMatrix];
  3417.   }
  3418.  
  3419.   if ([me currentShape])
  3420.   {  [[me currentShape] addChild:newShape];
  3421.   }
  3422.   else
  3423.   {  [me setTmpRootShape:newShape];
  3424.   }
  3425.   [me setCurrentShape:newShape];
  3426.  
  3427.   return TCL_OK;
  3428. }
  3429.  
  3430.  
  3431. static int
  3432. cmd_StartLight(me, interp, argc, argv)
  3433. WWEveParser    *me;
  3434. Tcl_Interp     *interp;
  3435. int            argc;
  3436. char           **argv;
  3437. {
  3438.   char  *my_args = "lightName isGlobal";
  3439.   int    num_args = 3;
  3440.   id    newShape;
  3441.   int   globalFlag = 0;
  3442.  
  3443.  
  3444.   sprintf(errBuf, "evaluating %s...", argv[0]);
  3445.   [[me statusText] setStringValue:errBuf]; [[me statusText] display]; NXPing();
  3446.   if (argc != num_args)
  3447.   {  sprintf(errBuf, "USAGE: %s %s", argv[0], my_args);
  3448.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  3449.      return TCL_ERROR;
  3450.   }
  3451.   if (Tcl_GetBoolean(interp, argv[1], &globalFlag) != TCL_OK)
  3452.   {  sprintf(errBuf, "%s isn't a valid boolean value", argv[1]);
  3453.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  3454.      return TCL_ERROR;
  3455.   }
  3456.  
  3457.   [me setRiBegun:YES];
  3458.   newShape = [[WW3DLight alloc] init];
  3459.   [newShape setShapeName:argv[1]];
  3460.   [newShape setGlobal:(BOOL)globalFlag];
  3461.   if ([me currentShape])
  3462.   {  [[me currentShape] addChild:newShape];
  3463.   }
  3464.   else
  3465.   {  [me setTmpRootShape:newShape];
  3466.   }
  3467.   [me setCurrentShape:newShape];
  3468.  
  3469.   return TCL_OK;
  3470. }
  3471.  
  3472.  
  3473. static int
  3474. cmd_StartAmbientLight(me, interp, argc, argv)
  3475. WWEveParser    *me;
  3476. Tcl_Interp     *interp;
  3477. int            argc;
  3478. char           **argv;
  3479. {
  3480.   char  *my_args = "lightName intensity isGlobal";
  3481.   int    num_args = 4;
  3482.   id    newShape;
  3483.   int   globalFlag;
  3484.  
  3485.  
  3486.   sprintf(errBuf, "evaluating %s...", argv[0]);
  3487.   [[me statusText] setStringValue:errBuf]; [[me statusText] display]; NXPing();
  3488.   if (argc != num_args)
  3489.   {  sprintf(errBuf, "USAGE: %s %s", argv[0], my_args);
  3490.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  3491.      return TCL_ERROR;
  3492.   }
  3493.   if (Tcl_GetBoolean(interp, argv[3], &globalFlag) != TCL_OK)
  3494.   {  sprintf(errBuf, "%s isn't a valid boolean value", argv[3]);
  3495.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  3496.      return TCL_ERROR;
  3497.   }
  3498.  
  3499.   [me setRiBegun:YES];
  3500.   newShape = [[[WW3DLight alloc] init] makeAmbientWithIntensity:(RtFloat)atof(argv[2])];
  3501.   [newShape setShapeName:argv[1]];
  3502.   [newShape setGlobal:(BOOL)globalFlag];
  3503.  
  3504.   if ([me currentShape])
  3505.   {  [[me currentShape] addChild:newShape];
  3506.   }
  3507.   else
  3508.   {  [me setTmpRootShape:newShape];
  3509.   }
  3510.   [me setCurrentShape:newShape];
  3511.  
  3512.   return TCL_OK;
  3513. }
  3514.  
  3515.  
  3516. static int
  3517. cmd_StartDistantLight(me, interp, argc, argv)
  3518. WWEveParser    *me;
  3519. Tcl_Interp     *interp;
  3520. int            argc;
  3521. char           **argv;
  3522. {
  3523.   char     *my_args = "lightName fromX fromY fromZ toX toY toZ intensity isGlobal";
  3524.   int       num_args = 10;
  3525.   id       newShape;
  3526.   RtPoint  from, to;
  3527.   int      globalFlag = 0;
  3528.  
  3529.  
  3530.   sprintf(errBuf, "evaluating %s...", argv[0]);
  3531.   [[me statusText] setStringValue:errBuf]; [[me statusText] display]; NXPing();
  3532.   if (argc != num_args)
  3533.   {  sprintf(errBuf, "USAGE: %s %s", argv[0], my_args);
  3534.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  3535.      return TCL_ERROR;
  3536.   }
  3537.   if (Tcl_GetBoolean(interp, argv[9], &globalFlag) != TCL_OK)
  3538.   {  sprintf(errBuf, "%s isn't a valid boolean value", argv[9]);
  3539.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  3540.      return TCL_ERROR;
  3541.   }
  3542.  
  3543.   [me setRiBegun:YES];
  3544.   from[0] = (RtFloat)atof(argv[2]);
  3545.   from[1] = (RtFloat)atof(argv[3]);
  3546.   from[2] = (RtFloat)atof(argv[4]);
  3547.   to[0] = (RtFloat)atof(argv[5]);
  3548.   to[1] = (RtFloat)atof(argv[6]);
  3549.   to[2] = (RtFloat)atof(argv[7]);
  3550.   newShape = [[[WW3DLight alloc] init] makeDistantFrom:from to:to intensity:(RtFloat)atof(argv[8])];
  3551.   [newShape setShapeName:argv[1]];
  3552.   [newShape setGlobal:(BOOL)globalFlag];
  3553.  
  3554.   if ([me currentShape])
  3555.   {  [[me currentShape] addChild:newShape];
  3556.   }
  3557.   else
  3558.   {  [me setTmpRootShape:newShape];
  3559.   }
  3560.   [me setCurrentShape:newShape];
  3561.  
  3562.   return TCL_OK;
  3563. }
  3564.  
  3565.  
  3566. static int
  3567. cmd_StartPointLight(me, interp, argc, argv)
  3568. WWEveParser    *me;
  3569. Tcl_Interp     *interp;
  3570. int            argc;
  3571. char           **argv;
  3572. {
  3573.   char     *my_args = "lightName fromX fromY fromZ intensity isGlobal";
  3574.   int       num_args = 7;
  3575.   id       newShape;
  3576.   RtPoint  from;
  3577.   int      globalFlag = 0;
  3578.  
  3579.  
  3580.   sprintf(errBuf, "evaluating %s...", argv[0]);
  3581.   [[me statusText] setStringValue:errBuf]; [[me statusText] display]; NXPing();
  3582.   if (argc != num_args)
  3583.   {  sprintf(errBuf, "USAGE: %s %s", argv[0], my_args);
  3584.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  3585.      return TCL_ERROR;
  3586.   }
  3587.   if (Tcl_GetBoolean(interp, argv[6], &globalFlag) != TCL_OK)
  3588.   {  sprintf(errBuf, "%s isn't a valid boolean value", argv[6]);
  3589.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  3590.      return TCL_ERROR;
  3591.   }
  3592.  
  3593.   [me setRiBegun:YES];
  3594.   from[0] = (RtFloat)atof(argv[2]);
  3595.   from[1] = (RtFloat)atof(argv[3]);
  3596.   from[2] = (RtFloat)atof(argv[4]);
  3597.   newShape = [[[WW3DLight alloc] init] makePointFrom:from intensity:(RtFloat)atof(argv[4])];
  3598.   [newShape setShapeName:argv[1]];
  3599.   [newShape setGlobal:(BOOL)globalFlag];
  3600.  
  3601.   if ([me currentShape])
  3602.   {  [[me currentShape] addChild:newShape];
  3603.   }
  3604.   else
  3605.   {  [me setTmpRootShape:newShape];
  3606.   }
  3607.   [me setCurrentShape:newShape];
  3608.  
  3609.   return TCL_OK;
  3610. }
  3611.  
  3612.  
  3613. static int
  3614. cmd_StartSpotLight(me, interp, argc, argv)
  3615. WWEveParser    *me;
  3616. Tcl_Interp     *interp;
  3617. int            argc;
  3618. char           **argv;
  3619. {
  3620.   char     *my_args = "lightName fromX fromY fromZ toX toY toZ coneAngle coneDelta beamDistribution intensity isGlobal";
  3621.   int       num_args = 13;
  3622.   id       newShape;
  3623.   RtPoint  from, to;
  3624.   int      globalFlag = 0;
  3625.  
  3626.  
  3627.   sprintf(errBuf, "evaluating %s...", argv[0]);
  3628.   [[me statusText] setStringValue:errBuf]; [[me statusText] display]; NXPing();
  3629.   if (argc != num_args)
  3630.   {  sprintf(errBuf, "USAGE: %s %s", argv[0], my_args);
  3631.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  3632.      return TCL_ERROR;
  3633.   }
  3634.   if (Tcl_GetBoolean(interp, argv[12], &globalFlag) != TCL_OK)
  3635.   {  sprintf(errBuf, "%s isn't a valid boolean value", argv[12]);
  3636.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  3637.      return TCL_ERROR;
  3638.   }
  3639.  
  3640.   [me setRiBegun:YES];
  3641.   from[0] = (RtFloat)atof(argv[2]);
  3642.   from[1] = (RtFloat)atof(argv[3]);
  3643.   from[2] = (RtFloat)atof(argv[4]);
  3644.   to[0] = (RtFloat)atof(argv[5]);
  3645.   to[1] = (RtFloat)atof(argv[6]);
  3646.   to[2] = (RtFloat)atof(argv[7]);
  3647.   newShape = [[[WW3DLight alloc] init] makeSpotFrom:from to:to 
  3648.                                        coneAngle:(RtFloat)atof(argv[8]) 
  3649.                                       coneDelta:(RtFloat)atof(argv[9]) 
  3650.                                       beamDistribution:(RtFloat)atof(argv[10]) 
  3651.                                       intensity:(RtFloat)atof(argv[11])];
  3652.   [newShape setShapeName:argv[1]];
  3653.   [newShape setGlobal:(BOOL)globalFlag];
  3654.  
  3655.   if ([me currentShape])
  3656.   {  [[me currentShape] addChild:newShape];
  3657.   }
  3658.   else
  3659.   {  [me setTmpRootShape:newShape];
  3660.   }
  3661.   [me setCurrentShape:newShape];
  3662.  
  3663.   return TCL_OK;
  3664. }
  3665.  
  3666.  
  3667. static int
  3668. cmd_EndShape(me, interp, argc, argv)
  3669. WWEveParser    *me;
  3670. Tcl_Interp     *interp;
  3671. int            argc;
  3672. char           **argv;
  3673. {
  3674.   char  *my_args = "";
  3675.   int    num_args = 1;
  3676.   id    newRIBCommand;
  3677.  
  3678.  
  3679.   sprintf(errBuf, "evaluating %s...", argv[0]);
  3680.   [[me statusText] setStringValue:errBuf]; [[me statusText] display]; NXPing();
  3681.   if (![me riBegun])
  3682.   {  sprintf(errBuf, "You must call RiBegin before making any RIB calls");
  3683.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  3684.      return TCL_ERROR;
  3685.   }
  3686.  
  3687.   if (argc != num_args)
  3688.   {  sprintf(errBuf, "USAGE: %s %s", argv[0], my_args);
  3689.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  3690.      return TCL_ERROR;
  3691.   }
  3692.  
  3693.   if ([me evaluatingEveProc])
  3694.   {  newRIBCommand = [[RIBAttributeEnd alloc] init];
  3695.      [newRIBCommand setMyShape:[me currentShape]];
  3696.      if ([me evaluatingEveCommand])
  3697.      {  [me setTmpRIBCommand:newRIBCommand];
  3698.      }
  3699.      else
  3700.      {  [[me currentShape] appendRIBCommand:newRIBCommand];
  3701.      }
  3702.      return TCL_OK;
  3703.   }
  3704.  
  3705.   // at this point, calculate bounding box of current shape
  3706.   //[[me currentShape] logTransformWithMsg:"AttributeEnd before boundingBox calc"];
  3707.   [[me currentShape]  calculateBoundingBoxStartingAt:[[me sceneClock] timestamp] endingAt:[[me sceneClock] timestamp]]; 
  3708.   //[[me currentShape] logTransformWithMsg:"AttributeEnd after boundingBox calc"];
  3709.   [me setCurrentShape:[[me currentShape] parent]];
  3710.  
  3711.   return TCL_OK;
  3712. }
  3713.  
  3714.  
  3715. static int
  3716. cmd_RiAttributeEnd(me, interp, argc, argv)
  3717. WWEveParser    *me;
  3718. Tcl_Interp     *interp;
  3719. int            argc;
  3720. char           **argv;
  3721. {
  3722.   char  *my_args = "";
  3723.   int    num_args = 1;
  3724.   id    newRIBCommand;
  3725.  
  3726.  
  3727.   sprintf(errBuf, "evaluating %s...", argv[0]);
  3728.   [[me statusText] setStringValue:errBuf]; [[me statusText] display]; NXPing();
  3729.   if (![me riBegun])
  3730.   {  sprintf(errBuf, "You must call RiBegin before making any RIB calls");
  3731.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  3732.      return TCL_ERROR;
  3733.   }
  3734.  
  3735.   if (argc != num_args)
  3736.   {  sprintf(errBuf, "USAGE: %s %s", argv[0], my_args);
  3737.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  3738.      return TCL_ERROR;
  3739.   }
  3740.  
  3741.   if ([me evaluatingEveProc] || ![me treatAttributeBeginLikeStartShape])
  3742.   {  newRIBCommand = [[RIBAttributeEnd alloc] init];
  3743.      [newRIBCommand setMyShape:[me currentShape]];
  3744.      if ([me evaluatingEveCommand])
  3745.      {  [me setTmpRIBCommand:newRIBCommand];
  3746.      }
  3747.      else
  3748.      {  [[me currentShape] appendRIBCommand:newRIBCommand];
  3749.      }
  3750.      return TCL_OK;
  3751.   }
  3752.  
  3753.   // at this point, calculate bounding box of current shape
  3754.   //[[me currentShape] logTransformWithMsg:"AttributeEnd before boundingBox calc"];
  3755.   [[me currentShape]  calculateBoundingBoxStartingAt:[[me sceneClock] timestamp] endingAt:[[me sceneClock] timestamp]]; 
  3756.   //[[me currentShape] logTransformWithMsg:"AttributeEnd after boundingBox calc"];
  3757.   [me setCurrentShape:[[me currentShape] parent]];
  3758.  
  3759.   return TCL_OK;
  3760. }
  3761.  
  3762.  
  3763. static int
  3764. cmd_RiColor(me, interp, argc, argv)
  3765. WWEveParser    *me;
  3766. Tcl_Interp     *interp;
  3767. int            argc;
  3768. char           **argv;
  3769. {
  3770.   char     *my_args = "{red green blue}|red green blue", **argv2;
  3771.   int       argc2;
  3772.   RtColor  aColor;
  3773.   id       newRIBCommand;
  3774.  
  3775.  
  3776.   sprintf(errBuf, "evaluating %s...", argv[0]);
  3777.   [[me statusText] setStringValue:errBuf]; [[me statusText] display]; NXPing();
  3778.   if ([me ignoreColors])
  3779.   {  return TCL_OK;
  3780.   }
  3781.  
  3782.   if (![me riBegun])
  3783.   {  sprintf(errBuf, "You must call RiBegin before making any RIB calls");
  3784.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  3785.      return TCL_ERROR;
  3786.   }
  3787.  
  3788.   if ((argc != 2) && (argc != 4))
  3789.   {  sprintf(errBuf, "USAGE: %s %s", argv[0], my_args);
  3790.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  3791.      return TCL_ERROR;
  3792.   }
  3793.  
  3794.   if (argc == 2)
  3795.   {  if (Tcl_SplitList(interp, argv[1], &argc2, &argv2) != TCL_OK)
  3796.      {  sprintf(errBuf, 
  3797.                "USAGE: %s : problem splitting <%s> as a list", 
  3798.         argv[0], argv[1]);
  3799.     Tcl_AppendResult(interp, errBuf, (char *)NULL);
  3800.     return TCL_ERROR;
  3801.      }
  3802.      if (argc2 != 3)
  3803.      {  sprintf(errBuf, 
  3804.                "USAGE: %s %s\ncolor should have 3 elements, not %d", 
  3805.         argv[0], my_args, argc2);
  3806.     Tcl_AppendResult(interp, errBuf, (char *)NULL);
  3807.     return TCL_ERROR;
  3808.      }
  3809.  
  3810.      aColor[0] = (RtFloat)atof(argv2[0]);
  3811.      aColor[1] = (RtFloat)atof(argv2[1]);
  3812.      aColor[2] = (RtFloat)atof(argv2[2]);
  3813.      free(argv2);
  3814.   }
  3815.   else
  3816.   {  aColor[0] = (RtFloat)atof(argv[1]);
  3817.      aColor[1] = (RtFloat)atof(argv[2]);
  3818.      aColor[2] = (RtFloat)atof(argv[3]);
  3819.   }
  3820.  
  3821.   newRIBCommand = [[RIBColor alloc] init];
  3822.   [newRIBCommand setRtColor:aColor];
  3823.   [newRIBCommand setMyShape:[me currentShape]];
  3824.   if ([me evaluatingEveCommand])
  3825.   {  [me setTmpRIBCommand:newRIBCommand];
  3826.   }
  3827.   else
  3828.   {  [[me currentShape] appendRIBCommand:newRIBCommand];
  3829.   }
  3830.  
  3831.   return TCL_OK;
  3832. }
  3833.  
  3834.  
  3835. static int
  3836. cmd_RiOpacity(me, interp, argc, argv)
  3837. WWEveParser    *me;
  3838. Tcl_Interp     *interp;
  3839. int            argc;
  3840. char           **argv;
  3841. {
  3842.   char     *my_args = "{red green blue}|red green blue", **argv2;
  3843.   int       argc2;
  3844.   RtColor  anOpacity;
  3845.   id       newRIBCommand;
  3846.  
  3847.  
  3848.   sprintf(errBuf, "evaluating %s...", argv[0]);
  3849.   [[me statusText] setStringValue:errBuf]; [[me statusText] display]; NXPing();
  3850.   if ([me ignoreColors])
  3851.   {  return TCL_OK;
  3852.   }
  3853.  
  3854.   if (![me riBegun])
  3855.   {  sprintf(errBuf, "You must call RiBegin before making any RIB calls");
  3856.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  3857.      return TCL_ERROR;
  3858.   }
  3859.  
  3860.   if ((argc != 2) && (argc != 4))
  3861.   {  sprintf(errBuf, "USAGE: %s %s", argv[0], my_args);
  3862.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  3863.      return TCL_ERROR;
  3864.   }
  3865.  
  3866.   if (argc == 2)
  3867.   {  if (Tcl_SplitList(interp, argv[1], &argc2, &argv2) != TCL_OK)
  3868.      {  sprintf(errBuf, 
  3869.                "%s : problem splitting <%s> as a list", 
  3870.         argv[0], argv[1]);
  3871.     Tcl_AppendResult(interp, errBuf, (char *)NULL);
  3872.     return TCL_ERROR;
  3873.      }
  3874.      if (argc2 != 3)
  3875.      {  sprintf(errBuf, 
  3876.                "USAGE: %s %s\nOpacity should have 3 elements, not %d", 
  3877.         argv[0], my_args, argc2);
  3878.     Tcl_AppendResult(interp, errBuf, (char *)NULL);
  3879.     return TCL_ERROR;
  3880.      }
  3881.  
  3882.      anOpacity[0] = (RtFloat)atof(argv2[0]);
  3883.      anOpacity[1] = (RtFloat)atof(argv2[1]);
  3884.      anOpacity[2] = (RtFloat)atof(argv2[2]);
  3885.      free(argv2);
  3886.   }
  3887.   else
  3888.   {  anOpacity[0] = (RtFloat)atof(argv[1]);
  3889.      anOpacity[1] = (RtFloat)atof(argv[2]);
  3890.      anOpacity[2] = (RtFloat)atof(argv[3]);
  3891.   }
  3892.  
  3893.   newRIBCommand = [[RIBOpacity alloc] init];
  3894.   [newRIBCommand setOpacity:anOpacity];
  3895.   [newRIBCommand setMyShape:[me currentShape]];
  3896.   if ([me evaluatingEveCommand])
  3897.   {  [me setTmpRIBCommand:newRIBCommand];
  3898.   }
  3899.   else
  3900.   {  [[me currentShape] appendRIBCommand:newRIBCommand];
  3901.   }
  3902.  
  3903.   return TCL_OK;
  3904. }
  3905.  
  3906.  
  3907. static int
  3908. cmd_RiTextureCoordinates(me, interp, argc, argv)
  3909. WWEveParser    *me;
  3910. Tcl_Interp     *interp;
  3911. int            argc;
  3912. char           **argv;
  3913. {
  3914.   char  *my_args = "s1 t1 s2 t2 s3 t3 s4 t4";
  3915.   int    num_args = 9;
  3916.   id    newRIBCommand;
  3917.  
  3918.  
  3919.   sprintf(errBuf, "evaluating %s...", argv[0]);
  3920.   [[me statusText] setStringValue:errBuf]; [[me statusText] display]; NXPing();
  3921.   if (![me riBegun])
  3922.   {  sprintf(errBuf, "You must call RiBegin before making any RIB calls");
  3923.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  3924.      return TCL_ERROR;
  3925.   }
  3926.  
  3927.   if (argc != num_args)
  3928.   {  sprintf(errBuf, "USAGE: %s %s", argv[0], my_args);
  3929.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  3930.      return TCL_ERROR;
  3931.   }
  3932.  
  3933.   // RiTextureCoordinates((RtFloat)atof(argv[1]), (RtFloat)atof(argv[2]), 
  3934.   //               (RtFloat)atof(argv[3]), (RtFloat)atof(argv[4]), 
  3935.   //               (RtFloat)atof(argv[5]), (RtFloat)atof(argv[6]), 
  3936.   //               (RtFloat)atof(argv[7]), (RtFloat)atof(argv[8]));
  3937.  
  3938.   newRIBCommand = [[RIBTextureCoordinates alloc] init];
  3939.   [newRIBCommand setS1:(RtFloat)atof(argv[1]) t1:(RtFloat)atof(argv[2])
  3940.                     s2:(RtFloat)atof(argv[3]) t2:(RtFloat)atof(argv[4])
  3941.                     s3:(RtFloat)atof(argv[5]) t3:(RtFloat)atof(argv[6])
  3942.                     s4:(RtFloat)atof(argv[7]) t4:(RtFloat)atof(argv[8])];
  3943.   [newRIBCommand setMyShape:[me currentShape]];
  3944.   if ([me evaluatingEveCommand])
  3945.   {  [me setTmpRIBCommand:newRIBCommand];
  3946.   }
  3947.   else
  3948.   {  [[me currentShape] appendRIBCommand:newRIBCommand];
  3949.   }
  3950.  
  3951.   return TCL_OK;
  3952. }
  3953.  
  3954.  
  3955. RIB_light_t
  3956. *getRIBLightGivenToken(me, token)
  3957. WWEveParser  *me;
  3958. RtToken      token;
  3959. {
  3960.   int        i, howMany = list_size(me->rib_light_list);
  3961.   RIB_light_t  *aRIBLight;
  3962.  
  3963.  
  3964.   for (i = 0; i < howMany; i++)
  3965.   {  aRIBLight = (RIB_light_t *)list_get_nth(me->rib_light_list, i);
  3966.      if (aRIBLight->token == token)
  3967.      {  return (aRIBLight);
  3968.      }
  3969.   }
  3970.   for (i = 0; i < howMany; i++)
  3971.   {  aRIBLight = (RIB_light_t *)list_get_nth(me->rib_light_list, i);
  3972.      if (!strcmp(aRIBLight->token, token))
  3973.      {  return (aRIBLight);
  3974.      }
  3975.   }
  3976.   return (RIB_light_t *)NULL;
  3977. }
  3978.  
  3979.  
  3980. static int
  3981. cmd_RiIlluminate(me, interp, argc, argv)
  3982. WWEveParser    *me;
  3983. Tcl_Interp     *interp;
  3984. int            argc;
  3985. char           **argv;
  3986. {
  3987.   char         *my_args = "token [1|0]";
  3988.   int           num_args = 3;
  3989.   RIB_light_t  *aRIBLight;
  3990.   int          flag = 0;
  3991.   id           newRIBCommand;
  3992.  
  3993.  
  3994.   sprintf(errBuf, "evaluating %s...", argv[0]);
  3995.   [[me statusText] setStringValue:errBuf]; [[me statusText] display]; NXPing();
  3996.   if (![me riBegun])
  3997.   {  sprintf(errBuf, "You must call RiBegin before making any RIB calls");
  3998.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  3999.      return TCL_ERROR;
  4000.   }
  4001.  
  4002.   if ((argc != num_args) || (strcmp(argv[2], "0") && strcmp(argv[2], "1")))
  4003.   {  sprintf(errBuf, "USAGE: %s %s", argv[0], my_args);
  4004.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  4005.      return TCL_ERROR;
  4006.   }
  4007.  
  4008.   if (!(aRIBLight = getRIBLightGivenToken(me, argv[1])))
  4009.   {  sprintf(errBuf, "token %s doesn't correspond to a defined light", argv[1]);
  4010.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  4011.      return TCL_ERROR;
  4012.   }
  4013.   
  4014.   //if (!strcmp(argv[2], "1"))
  4015.   //{  RiIlluminate(aRIBLight->handle, RI_TRUE);
  4016.   //}
  4017.   //else
  4018.   //{  RiIlluminate(aRIBLight->handle, RI_FALSE);
  4019.   //}
  4020.  
  4021.   if (Tcl_GetBoolean(interp, argv[2], &flag) != TCL_OK)
  4022.   {  sprintf(errBuf, "%s isn't a valid boolean value", argv[2]);
  4023.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  4024.      return TCL_ERROR;
  4025.   }
  4026.  
  4027.   newRIBCommand = [[RIBIlluminate alloc] init];
  4028.   [newRIBCommand setToken:aRIBLight->token flag:(RtBoolean)flag];
  4029.   [newRIBCommand setMyShape:[me currentShape]];
  4030.   if ([me evaluatingEveCommand])
  4031.   {  [me setTmpRIBCommand:newRIBCommand];
  4032.   }
  4033.   else
  4034.   {  [[me currentShape] appendRIBCommand:newRIBCommand];
  4035.   }
  4036.  
  4037.   return TCL_OK;
  4038. }
  4039.  
  4040.  
  4041. static int
  4042. cmd_RiShadingInterpolation(me, interp, argc, argv)
  4043. WWEveParser    *me;
  4044. Tcl_Interp     *interp;
  4045. int            argc;
  4046. char           **argv;
  4047. {
  4048.   char  *my_args = "constant|smooth";
  4049.   int    num_args = 2;
  4050.  
  4051.  
  4052.   sprintf(errBuf, "evaluating %s...", argv[0]);
  4053.   [[me statusText] setStringValue:errBuf]; [[me statusText] display]; NXPing();
  4054.   if (![me riBegun])
  4055.   {  sprintf(errBuf, "You must call RiBegin before making any RIB calls");
  4056.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  4057.      return TCL_ERROR;
  4058.   }
  4059.  
  4060.   if ((argc != num_args) && strcmp(argv[1], "constant") && strcmp(argv[1], "smooth")) 
  4061.   {  sprintf(errBuf, "USAGE: %s %s", argv[0], my_args);
  4062.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  4063.      return TCL_ERROR;
  4064.   }
  4065.  
  4066.   if (!strcmp(argv[1], "constant"))
  4067.   {  // RiShadingInterpolation(RI_CONSTANT);
  4068.   }
  4069.   if (!strcmp(argv[1], "smooth"))
  4070.   {  // RiShadingInterpolation(RI_SMOOTH);
  4071.   }
  4072.  
  4073.   return TCL_OK;
  4074. }
  4075.  
  4076. static int
  4077. cmd_RiShadingRate(me, interp, argc, argv)
  4078. WWEveParser    *me;
  4079. Tcl_Interp     *interp;
  4080. int            argc;
  4081. char           **argv;
  4082. {
  4083.   char  *my_args = "shadingRate";
  4084.   int    num_args = 2;
  4085.   id    newRIBCommand;
  4086.  
  4087.  
  4088.   sprintf(errBuf, "evaluating %s...", argv[0]);
  4089.   [[me statusText] setStringValue:errBuf]; [[me statusText] display]; NXPing();
  4090.   if (![me riBegun])
  4091.   {  sprintf(errBuf, "You must call RiBegin before making any RIB calls");
  4092.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  4093.      return TCL_ERROR;
  4094.   }
  4095.  
  4096.   if ([me ignoreShadingRate])
  4097.   {  return TCL_OK;
  4098.   }
  4099.  
  4100.   if (argc != num_args)
  4101.   {  sprintf(errBuf, "USAGE: %s %s", argv[0], my_args);
  4102.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  4103.      return TCL_ERROR;
  4104.   }
  4105.  
  4106.   //[[me currentShape] logTransformWithMsg:"Translate before"];
  4107.   if ([me firmTransforms])
  4108.   {  [[me currentShape] preTranslate:(RtFloat)atof(argv[1]) :(RtFloat)atof(argv[2]) :(RtFloat)atof(argv[3])];
  4109.      //[[me currentShape] logTransformWithMsg:"Translate (firmed) after"];
  4110.      return TCL_OK;
  4111.   }
  4112.  
  4113.   newRIBCommand = [[RIBShadingRate alloc] init];
  4114.   [newRIBCommand setShadingRate:(RtFloat)atof(argv[1])];
  4115.   [newRIBCommand setMyShape:[me currentShape]];
  4116.   if ([me evaluatingEveCommand])
  4117.   {  [me setTmpRIBCommand:newRIBCommand];
  4118.   }
  4119.   else
  4120.   {  [[me currentShape] appendRIBCommand:newRIBCommand];
  4121.   }
  4122.   //[[me currentShape] logTransformWithMsg:"Translate after"];
  4123.   return TCL_OK;
  4124. }
  4125.  
  4126.  
  4127.  
  4128. static int
  4129. cmd_RiMatte(me, interp, argc, argv)
  4130. WWEveParser    *me;
  4131. Tcl_Interp     *interp;
  4132. int            argc;
  4133. char           **argv;
  4134. {
  4135.   char  *my_args = "on|off";
  4136.   int    num_args = 2;
  4137.  
  4138.  
  4139.   sprintf(errBuf, "evaluating %s...", argv[0]);
  4140.   [[me statusText] setStringValue:errBuf]; [[me statusText] display]; NXPing();
  4141.   if (![me riBegun])
  4142.   {  sprintf(errBuf, "You must call RiBegin before making any RIB calls");
  4143.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  4144.      return TCL_ERROR;
  4145.   }
  4146.  
  4147.   if ((argc != num_args) && strcmp(argv[1], "on") && strcmp(argv[1], "off")) 
  4148.   {  sprintf(errBuf, "USAGE: %s %s", argv[0], my_args);
  4149.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  4150.      return TCL_ERROR;
  4151.   }
  4152.  
  4153.   if (!strcmp(argv[1], "on"))
  4154.   {  // RiMatte(RI_TRUE);
  4155.   }
  4156.   if (!strcmp(argv[1], "off"))
  4157.   {  // RiMatte(RI_FALSE);
  4158.   }
  4159.  
  4160.   return TCL_OK;
  4161. }
  4162.  
  4163.  
  4164. static int
  4165. cmd_RiBound(me, interp, argc, argv)
  4166. WWEveParser    *me;
  4167. Tcl_Interp     *interp;
  4168. int            argc;
  4169. char           **argv;
  4170. {
  4171.   char     *my_args = "{xmin xmax ymin ymax zmin zmax}", 
  4172.            **argv2;
  4173.   int       num_args = 2,
  4174.            argc2;
  4175.   RtBound  bbox;
  4176.  
  4177.  
  4178.   sprintf(errBuf, "evaluating %s...", argv[0]);
  4179.   [[me statusText] setStringValue:errBuf]; [[me statusText] display]; NXPing();
  4180.   if (![me riBegun])
  4181.   {  sprintf(errBuf, "You must call RiBegin before making any RIB calls");
  4182.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  4183.      return TCL_ERROR;
  4184.   }
  4185.  
  4186.   if (argc != num_args)
  4187.   {  sprintf(errBuf, "USAGE: %s %s", argv[0], my_args);
  4188.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  4189.      return TCL_ERROR;
  4190.   }
  4191.  
  4192.   if (Tcl_SplitList(interp, argv[1], &argc2, &argv2) != TCL_OK)
  4193.   {  sprintf(errBuf, 
  4194.          "%s : problem splitting <%s> as a list", 
  4195.          argv[0], argv[1]);
  4196.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  4197.      return TCL_ERROR;
  4198.   }
  4199.   if (argc2 != 6)
  4200.   {  sprintf(errBuf, 
  4201.          "USAGE: %s %s\nRiBound vector should have 6 elements, not %d", 
  4202.          argv[0], my_args, argc2);
  4203.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  4204.      return TCL_ERROR;
  4205.   }
  4206.  
  4207.   bbox[0] = (RtFloat)atof(argv2[0]);
  4208.   bbox[1] = (RtFloat)atof(argv2[1]);
  4209.   bbox[2] = (RtFloat)atof(argv2[2]);
  4210.   bbox[3] = (RtFloat)atof(argv2[3]);
  4211.   bbox[4] = (RtFloat)atof(argv2[4]);
  4212.   bbox[5] = (RtFloat)atof(argv2[5]);
  4213.  
  4214.   // RiBound(bbox);
  4215.  
  4216.   return TCL_OK;
  4217. }
  4218.  
  4219.  
  4220. static int
  4221. cmd_RiGeometricApproximation(me, interp, argc, argv)
  4222. WWEveParser    *me;
  4223. Tcl_Interp     *interp;
  4224. int            argc;
  4225. char           **argv;
  4226. {
  4227.   char  *my_args = "flatness value";
  4228.   int    num_args = 3;
  4229.  
  4230.  
  4231.   sprintf(errBuf, "evaluating %s...", argv[0]);
  4232.   [[me statusText] setStringValue:errBuf]; [[me statusText] display]; NXPing();
  4233.   if (![me riBegun])
  4234.   {  sprintf(errBuf, "You must call RiBegin before making any RIB calls");
  4235.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  4236.      return TCL_ERROR;
  4237.   }
  4238.  
  4239.   if (argc != num_args)
  4240.   {  sprintf(errBuf, "USAGE: %s %s", argv[0], my_args);
  4241.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  4242.      return TCL_ERROR;
  4243.   }
  4244.  
  4245.   // RiGeometricApproximation(argv[1], (RtFloat)atof(argv[2]));
  4246.  
  4247.   return TCL_OK;
  4248. }
  4249.  
  4250.  
  4251. static int
  4252. cmd_RiOrientation(me, interp, argc, argv)
  4253. WWEveParser    *me;
  4254. Tcl_Interp     *interp;
  4255. int            argc;
  4256. char           **argv;
  4257. {
  4258.   char  *my_args = "inside|outside|lh|rh";
  4259.   int    num_args = 4;
  4260.  
  4261.  
  4262.   sprintf(errBuf, "evaluating %s...", argv[0]);
  4263.   [[me statusText] setStringValue:errBuf]; [[me statusText] display]; NXPing();
  4264.   if (![me riBegun])
  4265.   {  sprintf(errBuf, "You must call RiBegin before making any RIB calls");
  4266.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  4267.      return TCL_ERROR;
  4268.   }
  4269.  
  4270.   if ((argc != num_args) && strcmp(argv[1], "inside") && strcmp(argv[1], "outside") && strcmp(argv[1], "lh") && strcmp(argv[1], "rh")) 
  4271.   {  sprintf(errBuf, "USAGE: %s %s", argv[0], my_args);
  4272.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  4273.      return TCL_ERROR;
  4274.   }
  4275.  
  4276.   // RiOrientation(getTokenGivenName(me, argv[1]));
  4277.  
  4278.   return TCL_OK;
  4279. }
  4280.  
  4281. static int
  4282. cmd_RiReverseOrientation(me, interp, argc, argv)
  4283. WWEveParser    *me;
  4284. Tcl_Interp     *interp;
  4285. int            argc;
  4286. char           **argv;
  4287. {
  4288.   char  *my_args = "";
  4289.   int    num_args = 1;
  4290.  
  4291.  
  4292.   sprintf(errBuf, "evaluating %s...", argv[0]);
  4293.   [[me statusText] setStringValue:errBuf]; [[me statusText] display]; NXPing();
  4294.   if (![me riBegun])
  4295.   {  sprintf(errBuf, "You must call RiBegin before making any RIB calls");
  4296.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  4297.      return TCL_ERROR;
  4298.   }
  4299.  
  4300.   if (argc > num_args)
  4301.   {  sprintf(errBuf, "USAGE: %s %s", argv[0], my_args);
  4302.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  4303.      return TCL_ERROR;
  4304.   }
  4305.  
  4306.   // RiReverseOrientation();
  4307.  
  4308.   return TCL_OK;
  4309. }
  4310.  
  4311.  
  4312. static int
  4313. cmd_RiSides(me, interp, argc, argv)
  4314. WWEveParser    *me;
  4315. Tcl_Interp     *interp;
  4316. int            argc;
  4317. char           **argv;
  4318. {
  4319.   char  *my_args = "1|2";
  4320.   int    num_args = 2;
  4321.   id    newRIBCommand;
  4322.  
  4323.  
  4324.   sprintf(errBuf, "evaluating %s...", argv[0]);
  4325.   [[me statusText] setStringValue:errBuf]; [[me statusText] display]; NXPing();
  4326.   if (![me riBegun])
  4327.   {  sprintf(errBuf, "You must call RiBegin before making any RIB calls");
  4328.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  4329.      return TCL_ERROR;
  4330.   }
  4331.  
  4332.   if ((argc != num_args) && (strcmp(argv[1], "1")) && (strcmp(argv[1], "2")))
  4333.   {  sprintf(errBuf, "USAGE: %s %s", argv[0], my_args);
  4334.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  4335.      return TCL_ERROR;
  4336.   }
  4337.  
  4338.   newRIBCommand = [[RIBSides alloc] init];
  4339.   [newRIBCommand setSides:atoi(argv[1])];
  4340.   [newRIBCommand setMyShape:[me currentShape]];
  4341.   if ([me evaluatingEveCommand])
  4342.   {  [me setTmpRIBCommand:newRIBCommand];
  4343.   }
  4344.   else
  4345.   {  
  4346.      [[me currentShape] appendRIBCommand:newRIBCommand];
  4347.   }
  4348.  
  4349.   return TCL_OK;
  4350. }
  4351.  
  4352.  
  4353. static int
  4354. cmd_RiIdentity(me, interp, argc, argv)
  4355. WWEveParser    *me;
  4356. Tcl_Interp     *interp;
  4357. int            argc;
  4358. char           **argv;
  4359. {
  4360.   char  *my_args = "";
  4361.   int    num_args = 1;
  4362.   id    newRIBCommand;
  4363.  
  4364.  
  4365.   sprintf(errBuf, "evaluating %s...", argv[0]);
  4366.   [[me statusText] setStringValue:errBuf]; [[me statusText] display]; NXPing();
  4367.   if (![me riBegun])
  4368.   {  sprintf(errBuf, "You must call RiBegin before making any RIB calls");
  4369.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  4370.      return TCL_ERROR;
  4371.   }
  4372.  
  4373.   if (argc > num_args)
  4374.   {  sprintf(errBuf, "USAGE: %s %s", argv[0], my_args);
  4375.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  4376.      return TCL_ERROR;
  4377.   }
  4378.  
  4379.   if ([me firmTransforms])
  4380.   {  
  4381.      [[me currentShape] setTransformMatrix:(RtFloat (*)[4])N3DIdentityMatrix];
  4382.      return TCL_OK;
  4383.   }
  4384.  
  4385.   newRIBCommand = [[RIBIdentity alloc] init];
  4386.   [newRIBCommand setMyShape:[me currentShape]];
  4387.   if ([me evaluatingEveCommand])
  4388.   {  [me setTmpRIBCommand:newRIBCommand];
  4389.   }
  4390.   else
  4391.   {  [[me currentShape] appendRIBCommand:newRIBCommand];
  4392.   }
  4393.   return TCL_OK;
  4394. }
  4395.  
  4396.  
  4397. static int
  4398. cmd_RiTransform(me, interp, argc, argv)
  4399. WWEveParser    *me;
  4400. Tcl_Interp     *interp;
  4401. int            argc;
  4402. char           **argv;
  4403. {
  4404.   char      *my_args = "4x4matrix", **argv2;
  4405.   int        num_args = 2, argc2, i, j, cnt = 0;
  4406.   RtMatrix  transformMatrix;
  4407.   id        newRIBCommand;
  4408.  
  4409.  
  4410.   sprintf(errBuf, "evaluating %s...", argv[0]);
  4411.   [[me statusText] setStringValue:errBuf]; [[me statusText] display]; NXPing();
  4412.   if (![me riBegun])
  4413.   {  sprintf(errBuf, "You must call RiBegin before making any RIB calls");
  4414.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  4415.      return TCL_ERROR;
  4416.   }
  4417.  
  4418.   if (argc > num_args)
  4419.   {  sprintf(errBuf, "USAGE: %s %s", argv[0], my_args);
  4420.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  4421.      return TCL_ERROR;
  4422.   }
  4423.  
  4424.   if (Tcl_SplitList(interp, argv[1], &argc2, &argv2) != TCL_OK)
  4425.   {  sprintf(errBuf, 
  4426.          "%s : problem splitting <%s> as a list", 
  4427.          argv[0], argv[1]);
  4428.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  4429.      return TCL_ERROR;
  4430.   }
  4431.   if (argc2 != 16)
  4432.   {  sprintf(errBuf, 
  4433.          "USAGE: %s %s\n4x4matrix should have 16 elements, not %d", 
  4434.          argv[0], my_args, argc2);
  4435.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  4436.      return TCL_ERROR;
  4437.   }
  4438.  
  4439.   for (i = 0; i < 4; i++)
  4440.   {  for (j = 0; j < 4; j++)
  4441.      {  transformMatrix[i][j] = (RtFloat)atof(argv2[cnt++]);
  4442.      }
  4443.   }
  4444.   free(argv2);
  4445.  
  4446.   //[[me currentShape] logTransformWithMsg:"Transform before"];
  4447.   if ([me firmTransforms])
  4448.   {  [[me currentShape] setTransformMatrix:transformMatrix];
  4449.      //[[me currentShape] logTransformWithMsg:"Transform (firmed) after"];
  4450.      return TCL_OK;
  4451.   }
  4452.   newRIBCommand = [[RIBTransform alloc] init];
  4453.   [newRIBCommand setMatrix:transformMatrix];
  4454.   [newRIBCommand setMyShape:[me currentShape]];
  4455.   if ([me evaluatingEveCommand])
  4456.   {  [me setTmpRIBCommand:newRIBCommand];
  4457.   }
  4458.   else
  4459.   {  [[me currentShape] appendRIBCommand:newRIBCommand];
  4460.   }
  4461.   //[[me currentShape] logTransformWithMsg:"Transform after"];
  4462.   return TCL_OK;
  4463. }
  4464.  
  4465.  
  4466. static int
  4467. cmd_RiConcatTransform(me, interp, argc, argv)
  4468. WWEveParser    *me;
  4469. Tcl_Interp     *interp;
  4470. int            argc;
  4471. char           **argv;
  4472. {
  4473.   char      *my_args = "4x4matrix", **argv2;
  4474.   int        num_args = 2, argc2, i, j, cnt = 0;
  4475.   RtMatrix  transformMatrix;
  4476.   id        newRIBCommand;
  4477.  
  4478.  
  4479.   sprintf(errBuf, "evaluating %s...", argv[0]);
  4480.   [[me statusText] setStringValue:errBuf]; [[me statusText] display]; NXPing();
  4481.   if (![me riBegun])
  4482.   {  sprintf(errBuf, "You must call RiBegin before making any RIB calls");
  4483.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  4484.      return TCL_ERROR;
  4485.   }
  4486.  
  4487.   if (argc > num_args)
  4488.   {  sprintf(errBuf, "USAGE: %s %s", argv[0], my_args);
  4489.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  4490.      return TCL_ERROR;
  4491.   }
  4492.  
  4493.   if (Tcl_SplitList(interp, argv[1], &argc2, &argv2) != TCL_OK)
  4494.   {  sprintf(errBuf, 
  4495.          "%s : problem splitting <%s> as a list", 
  4496.          argv[0], argv[1]);
  4497.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  4498.      return TCL_ERROR;
  4499.   }
  4500.  
  4501.   if (argc2 != 16)
  4502.   {  sprintf(errBuf, 
  4503.          "USAGE: %s %s\n4x4matrix should have 16 elements, not %d", 
  4504.          argv[0], my_args, argc2);
  4505.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  4506.      return TCL_ERROR;
  4507.   }
  4508.  
  4509.   for (i = 0; i < 4; i++)
  4510.   {  for (j = 0; j < 4; j++)
  4511.      {  transformMatrix[i][j] = (RtFloat)atof(argv2[cnt++]);
  4512.      }
  4513.   }
  4514.   free(argv2);
  4515.  
  4516.   //[[me currentShape] logTransformWithMsg:"ConcatTransform before"];
  4517.   if ([me firmTransforms])
  4518.   {  [[me currentShape] concatTransformMatrix:transformMatrix premultiply:YES];
  4519.      //[[me currentShape] logTransformWithMsg:"ConcatTransform (firmed) after"];
  4520.      return TCL_OK;
  4521.   }
  4522.  
  4523.   newRIBCommand = [[RIBConcatTransform alloc] init];
  4524.   [newRIBCommand setMatrix:transformMatrix];
  4525.   [newRIBCommand setMyShape:[me currentShape]];
  4526.   if ([me evaluatingEveCommand])
  4527.   {  [me setTmpRIBCommand:newRIBCommand];
  4528.   }
  4529.   else
  4530.   {  [[me currentShape] appendRIBCommand:newRIBCommand];
  4531.   }
  4532.   //[[me currentShape] logTransformWithMsg:"ConcatTransform after"];
  4533.   return TCL_OK;
  4534. }
  4535.  
  4536.  
  4537. static int
  4538. cmd_RiPerspective(me, interp, argc, argv)
  4539. WWEveParser    *me;
  4540. Tcl_Interp     *interp;
  4541. int            argc;
  4542. char           **argv;
  4543. {
  4544.   char  *my_args = "fov";
  4545.   int    num_args = 2;
  4546.  
  4547.  
  4548.   sprintf(errBuf, "evaluating %s...", argv[0]);
  4549.   [[me statusText] setStringValue:errBuf]; [[me statusText] display]; NXPing();
  4550.   if (![me riBegun])
  4551.   {  sprintf(errBuf, "You must call RiBegin before making any RIB calls");
  4552.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  4553.      return TCL_ERROR;
  4554.   }
  4555.  
  4556.   if (argc != num_args)
  4557.   {  sprintf(errBuf, "USAGE: %s %s", argv[0], my_args);
  4558.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  4559.      return TCL_ERROR;
  4560.   }
  4561.  
  4562.   // RiPerspective((RtFloat)atof(argv[1]));
  4563.   //newRIBCommand = [[RIBPerspective alloc] init];
  4564.   //[newRIBCommand setMyShape:[me currentShape]];
  4565.   //[[me currentShape] appendRIBCommand:newRIBCommand];
  4566.  
  4567.   return TCL_OK;
  4568. }
  4569.  
  4570.  
  4571.  
  4572. // should also allow a list as arg[1]
  4573. static int
  4574. cmd_RiTranslate(me, interp, argc, argv)
  4575. WWEveParser    *me;
  4576. Tcl_Interp     *interp;
  4577. int            argc;
  4578. char           **argv;
  4579. {
  4580.   char  *my_args = "dx dy dz";
  4581.   int    num_args = 4;
  4582.   id    newRIBCommand;
  4583.  
  4584.  
  4585.   sprintf(errBuf, "evaluating %s...", argv[0]);
  4586.   [[me statusText] setStringValue:errBuf]; [[me statusText] display]; NXPing();
  4587.   if (![me riBegun])
  4588.   {  sprintf(errBuf, "You must call RiBegin before making any RIB calls");
  4589.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  4590.      return TCL_ERROR;
  4591.   }
  4592.  
  4593.   if (argc != num_args)
  4594.   {  sprintf(errBuf, "USAGE: %s %s", argv[0], my_args);
  4595.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  4596.      return TCL_ERROR;
  4597.   }
  4598.  
  4599.   //[[me currentShape] logTransformWithMsg:"Translate before"];
  4600.   if ([me firmTransforms])
  4601.   {  [[me currentShape] preTranslate:(RtFloat)atof(argv[1]) :(RtFloat)atof(argv[2]) :(RtFloat)atof(argv[3])];
  4602.      //[[me currentShape] logTransformWithMsg:"Translate (firmed) after"];
  4603.      return TCL_OK;
  4604.   }
  4605.  
  4606.   newRIBCommand = [[RIBTranslate alloc] init];
  4607.   [newRIBCommand setDX:(RtFloat)atof(argv[1]) dy:(RtFloat)atof(argv[2]) dz:(RtFloat)atof(argv[3])];
  4608.   [newRIBCommand setMyShape:[me currentShape]];
  4609.   if ([me evaluatingEveCommand])
  4610.   {  [me setTmpRIBCommand:newRIBCommand];
  4611.   }
  4612.   else
  4613.   {  [[me currentShape] appendRIBCommand:newRIBCommand];
  4614.   }
  4615.   //[[me currentShape] logTransformWithMsg:"Translate after"];
  4616.   return TCL_OK;
  4617. }
  4618.  
  4619.  
  4620. static int
  4621. cmd_RiRotate(me, interp, argc, argv)
  4622. WWEveParser    *me;
  4623. Tcl_Interp     *interp;
  4624. int            argc;
  4625. char           **argv;
  4626. {
  4627.   char     *my_args = "angle dx dy dz";
  4628.   int       num_args = 5;
  4629.   id       newRIBCommand;
  4630.  
  4631.  
  4632.   sprintf(errBuf, "evaluating %s...", argv[0]);
  4633.   [[me statusText] setStringValue:errBuf]; [[me statusText] display]; NXPing();
  4634.   if (![me riBegun])
  4635.   {  sprintf(errBuf, "You must call RiBegin before making any RIB calls");
  4636.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  4637.      return TCL_ERROR;
  4638.   }
  4639.  
  4640.   if (argc != num_args)
  4641.   {  sprintf(errBuf, "USAGE: %s %s", argv[0], my_args);
  4642.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  4643.      return TCL_ERROR;
  4644.   }
  4645.  
  4646.   //[[me currentShape] logTransformWithMsg:"Rotate before"];
  4647.   if ([me firmTransforms])
  4648.   {  RtPoint  axis;
  4649.  
  4650.      axis[0] = (RtFloat)atof(argv[2]);
  4651.      axis[1] = (RtFloat)atof(argv[3]);
  4652.      axis[2] = (RtFloat)atof(argv[4]);
  4653.      [[me currentShape] preRotateAngle:(RtFloat)atof(argv[1]) axis:axis];
  4654.      //[[me currentShape] logTransformWithMsg:"Rotate (firmed) after"];
  4655.      return TCL_OK;
  4656.   }
  4657.  
  4658.   newRIBCommand = [[RIBRotate alloc] init];
  4659.   [newRIBCommand setAngle:(RtFloat)atof(argv[1]) dx:(RtFloat)atof(argv[2]) dy:(RtFloat)atof(argv[3]) dz:(RtFloat)atof(argv[4])];
  4660.   [newRIBCommand setMyShape:[me currentShape]];
  4661.   if ([me evaluatingEveCommand])
  4662.   {  [me setTmpRIBCommand:newRIBCommand];
  4663.   }
  4664.   else
  4665.   { [[me currentShape] appendRIBCommand:newRIBCommand];
  4666.   }
  4667.   //[[me currentShape] logTransformWithMsg:"Rotate after"];
  4668.   return TCL_OK;
  4669. }
  4670.  
  4671.  
  4672. static int
  4673. cmd_RiScale(me, interp, argc, argv)
  4674. WWEveParser    *me;
  4675. Tcl_Interp     *interp;
  4676. int            argc;
  4677. char           **argv;
  4678. {
  4679.   char  *my_args = "sx sy sz";
  4680.   int    num_args = 4;
  4681.   id    newRIBCommand;
  4682.  
  4683.  
  4684.   sprintf(errBuf, "evaluating %s...", argv[0]);
  4685.   [[me statusText] setStringValue:errBuf]; [[me statusText] display]; NXPing();
  4686.   if (![me riBegun])
  4687.   {  sprintf(errBuf, "You must call RiBegin before making any RIB calls");
  4688.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  4689.      return TCL_ERROR;
  4690.   }
  4691.  
  4692.   if (argc != num_args)
  4693.   {  sprintf(errBuf, "USAGE: %s %s", argv[0], my_args);
  4694.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  4695.      return TCL_ERROR;
  4696.   }
  4697.  
  4698.   //[[me currentShape] logTransformWithMsg:"Scale before"];
  4699.   if ([me firmTransforms])
  4700.   {  [[me currentShape] preScale:(RtFloat)atof(argv[1]) :(RtFloat)atof(argv[2]) :(RtFloat)atof(argv[3])];
  4701.      //[[me currentShape] logTransformWithMsg:"Scale (firmed) after"];
  4702.      return TCL_OK;
  4703.   }
  4704.  
  4705.   newRIBCommand = [[RIBScale alloc] init];
  4706.   [newRIBCommand setSX:(RtFloat)atof(argv[1]) sy:(RtFloat)atof(argv[2]) sz:(RtFloat)atof(argv[3])];
  4707.   [newRIBCommand setMyShape:[me currentShape]];
  4708.   if ([me evaluatingEveCommand])
  4709.   {  [me setTmpRIBCommand:newRIBCommand];
  4710.   }
  4711.   else
  4712.   {  [[me currentShape] appendRIBCommand:newRIBCommand];
  4713.   }
  4714.   //[[me currentShape] logTransformWithMsg:"Scale after"];
  4715.   return TCL_OK;
  4716. }
  4717.  
  4718.  
  4719. static int
  4720. cmd_RiSkew(me, interp, argc, argv)
  4721. WWEveParser    *me;
  4722. Tcl_Interp     *interp;
  4723. int            argc;
  4724. char           **argv;
  4725. {
  4726.   char  *my_args = "angle x1 y1 z1 x2 y2 z2"; // or "angle {x1 y1 z1} {x2 y2 z2}"
  4727.   id    newRIBCommand;
  4728.  
  4729.  
  4730.   sprintf(errBuf, "evaluating %s...", argv[0]);
  4731.   [[me statusText] setStringValue:errBuf]; [[me statusText] display]; NXPing();
  4732.   if (![me riBegun])
  4733.   {  sprintf(errBuf, "You must call RiBegin before making any RIB calls");
  4734.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  4735.      return TCL_ERROR;
  4736.   }
  4737.  
  4738.   //if ((argc < 8) && (argc != 4))
  4739.   if (argc != 8)
  4740.   {  sprintf(errBuf, "USAGE: %s %s", argv[0], my_args);
  4741.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  4742.      return TCL_ERROR;
  4743.   }
  4744.  
  4745.   newRIBCommand = [[RIBSkew alloc] init];
  4746.   [newRIBCommand setAngle:(RtFloat)atof(argv[1]) 
  4747.                     dx1:(RtFloat)atof(argv[2]) dy1:(RtFloat)atof(argv[3]) dz1:(RtFloat)atof(argv[4])
  4748.                     dx2:(RtFloat)atof(argv[5]) dy2:(RtFloat)atof(argv[6]) dz2:(RtFloat)atof(argv[7])];
  4749.  
  4750.   [newRIBCommand setMyShape:[me currentShape]];
  4751.   if ([me evaluatingEveCommand])
  4752.   {  [me setTmpRIBCommand:newRIBCommand];
  4753.   }
  4754.   else
  4755.   {  [[me currentShape] appendRIBCommand:newRIBCommand];
  4756.   }
  4757.  
  4758.   return TCL_OK;
  4759. }
  4760.  
  4761.  
  4762.  
  4763. static int
  4764. cmd_RiCoordinateSystem(me, interp, argc, argv)
  4765. WWEveParser    *me;
  4766. Tcl_Interp     *interp;
  4767. int            argc;
  4768. char           **argv;
  4769. {
  4770.   char  *my_args = "name";
  4771.   int    num_args = 2;
  4772.  
  4773.  
  4774.   sprintf(errBuf, "evaluating %s...", argv[0]);
  4775.   [[me statusText] setStringValue:errBuf]; [[me statusText] display]; NXPing();
  4776.   if (![me riBegun])
  4777.   {  sprintf(errBuf, "You must call RiBegin before making any RIB calls");
  4778.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  4779.      return TCL_ERROR;
  4780.   }
  4781.  
  4782.   if (argc != num_args)
  4783.   {  sprintf(errBuf, "USAGE: %s %s", argv[0], my_args);
  4784.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  4785.      return TCL_ERROR;
  4786.   }
  4787.  
  4788.   // RiCoordinateSystem((RtToken)argv[1]);
  4789.  
  4790.   return TCL_OK;
  4791. }
  4792.  
  4793.  
  4794.  
  4795. static int
  4796. cmd_RiTransformBegin(me, interp, argc, argv)
  4797. WWEveParser    *me;
  4798. Tcl_Interp     *interp;
  4799. int            argc;
  4800. char           **argv;
  4801. {
  4802.   char  *my_args = "";
  4803.   int    num_args = 1;
  4804.   id    newShape, newRIBCommand;
  4805.   static char  nameBuf[64];
  4806.  
  4807.  
  4808.   sprintf(errBuf, "evaluating %s...", argv[0]);
  4809.   [[me statusText] setStringValue:errBuf]; [[me statusText] display]; NXPing();
  4810.   if (![me riBegun])
  4811.   {  sprintf(errBuf, "You must call RiBegin before making any RIB calls");
  4812.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  4813.      return TCL_ERROR;
  4814.   }
  4815.  
  4816.   if (argc != num_args)
  4817.   {  sprintf(errBuf, "USAGE: %s %s", argv[0], my_args);
  4818.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  4819.      return TCL_ERROR;
  4820.   }
  4821.  
  4822.   if ([me treatTransformBeginLikeAttributeBegin] && [me treatAttributeBeginLikeStartShape])
  4823.   {  newShape = [[WW3DShape alloc] initWithInterp:[me tclInterp] andSceneClock:[me sceneClock]];
  4824.      sprintf(nameBuf, "xformChangeMyNamePlease%d", ([me uniqueTag]));
  4825.      [newShape setShapeName:nameBuf];
  4826.      if ([me currentShape])
  4827.      {  [[me currentShape] addChild:newShape];
  4828.      }
  4829.      else
  4830.      {  [me setTmpRootShape:newShape];
  4831.      }
  4832.      [me setCurrentShape:newShape];
  4833.   }
  4834.   else
  4835.   {  newRIBCommand = [[RIBTransformBegin alloc] init];
  4836.      [newRIBCommand setMyShape:[me currentShape]];
  4837.      if ([me evaluatingEveCommand])
  4838.      {  [me setTmpRIBCommand:newRIBCommand];
  4839.      }
  4840.      else
  4841.      {  [[me currentShape] appendRIBCommand:newRIBCommand];
  4842.      }
  4843.   }
  4844.   return TCL_OK;
  4845. }
  4846.  
  4847.  
  4848. static int
  4849. cmd_RiTransformEnd(me, interp, argc, argv)
  4850. WWEveParser    *me;
  4851. Tcl_Interp     *interp;
  4852. int            argc;
  4853. char           **argv;
  4854. {
  4855.   char  *my_args = "";
  4856.   int    num_args = 1;
  4857.   id    newRIBCommand;
  4858.  
  4859.  
  4860.   sprintf(errBuf, "evaluating %s...", argv[0]);
  4861.   [[me statusText] setStringValue:errBuf]; [[me statusText] display]; NXPing();
  4862.   if (![me riBegun])
  4863.   {  sprintf(errBuf, "You must call RiBegin before making any RIB calls");
  4864.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  4865.      return TCL_ERROR;
  4866.   }
  4867.  
  4868.   if (argc != num_args)
  4869.   {  sprintf(errBuf, "USAGE: %s %s", argv[0], my_args);
  4870.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  4871.      return TCL_ERROR;
  4872.   }
  4873.  
  4874.   if ([me treatTransformBeginLikeAttributeBegin] && [me treatAttributeBeginLikeStartShape])
  4875.   {  //[[me currentShape] logTransformWithMsg:"TransformEnd (like AttributeEnd) before boundingBox calc"];
  4876.      [[me currentShape]  calculateBoundingBoxStartingAt:[[me sceneClock] timestamp] endingAt:[[me sceneClock] timestamp]]; 
  4877.      //[[me currentShape] logTransformWithMsg:"TransformEnd (like AttributeEnd) after boundingBox calc"];
  4878.      [me setCurrentShape:[[me currentShape] parent]];
  4879.   }
  4880.   else
  4881.   {  newRIBCommand = [[RIBTransformEnd alloc] init];
  4882.      [newRIBCommand setMyShape:[me currentShape]];
  4883.      if ([me evaluatingEveCommand])
  4884.      {  [me setTmpRIBCommand:newRIBCommand];
  4885.      }
  4886.      else
  4887.      {  [[me currentShape] appendRIBCommand:newRIBCommand];
  4888.      }
  4889.   }
  4890.   
  4891.   return TCL_OK;
  4892. }
  4893.  
  4894.  
  4895. static int
  4896. cmd_RiAttribute(me, interp, argc, argv)
  4897. WWEveParser    *me;
  4898. Tcl_Interp     *interp;
  4899. int            argc;
  4900. char           **argv;
  4901. {
  4902.   char  *my_args = "name [parameterlist]";
  4903.   int    num_args = 2, n, i;
  4904.   RtToken    *tokens = (RtToken *)RI_NULL;
  4905.   RtPointer  *parms = (RtPointer *)RI_NULL;
  4906.   int        *nVector = NULL, 
  4907.              *typeVector = NULL;
  4908.   char       **archiveVector = NULL;
  4909.   id         newRIBCommand;
  4910.  
  4911.  
  4912.   static char  noQuoteBuf[1024];
  4913.     
  4914.  
  4915.   sprintf(errBuf, "evaluating %s...", argv[0]);
  4916.   [[me statusText] setStringValue:errBuf]; [[me statusText] display]; NXPing();
  4917.   if (![me riBegun])
  4918.   {  sprintf(errBuf, "You must call RiBegin before making any RIB calls");
  4919.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  4920.      return TCL_ERROR;
  4921.   }
  4922.  
  4923.   if (argc < num_args)
  4924.   {  sprintf(errBuf, "USAGE: %s %s", argv[0], my_args);
  4925.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  4926.      return TCL_ERROR;
  4927.   }
  4928.  
  4929.   if (argc % 2)
  4930.   {  sprintf(errBuf, "RiAttribute : parameter list must be in groups of two, i.e. the number of args is an even number");
  4931.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  4932.      return TCL_ERROR;
  4933.   }
  4934.  
  4935.   // need to strip out double quotes, which will probably be in the beginning and end of the string.
  4936.   n = 0;
  4937.   if (argc > num_args)
  4938.   {  n = (argc - num_args) / 2;
  4939.      if (!buildParameterList(me, interp, n, &tokens, &parms, &archiveVector, &nVector, &typeVector, num_args, argv))
  4940.      {  return TCL_ERROR;
  4941.      }
  4942.   }
  4943.  
  4944.   // RiAttributeV(argv[1], n, tokens, parms);
  4945.   i = 1;
  4946.   while (i < argc)
  4947.   {  if (!strcmp(argv[i], "identifier"))
  4948.      {  if (!strcmp(argv[i+1], "name"))
  4949.         {  if (*(argv[i+2]) == '\"')
  4950.            {  int cnt = 1;
  4951.               while ( (*((argv[i+2]) + cnt)) && (*((argv[i+2]) +cnt) != '\"'))  
  4952.               {  noQuoteBuf[cnt - 1] = *((argv[i+2]) + cnt);
  4953.           }
  4954.               [[me currentShape] setShapeName:noQuoteBuf];
  4955.         }
  4956.            else
  4957.            {  [[me currentShape] setShapeName:argv[i+2]];
  4958.            }
  4959.         }
  4960.         if (!strcmp(argv[i+1], "part"))
  4961.         {  if (*(argv[i+2]) == '\"')
  4962.            {  int cnt = 1;
  4963.               while ( (*((argv[i+2]) + cnt)) && (*((argv[i+2]) +cnt) != '\"'))  
  4964.               {  noQuoteBuf[cnt - 1] = *((argv[i+2]) + cnt);
  4965.           }
  4966.               [[me currentShape] setShapeName:noQuoteBuf];
  4967.         }
  4968.            else
  4969.            {  [[me currentShape] setShapeName:argv[i+2]];
  4970.            }
  4971.         }
  4972.         if (!strcmp(argv[i+1], "shadinggroup"))
  4973.         {  if (*(argv[i+2]) == '\"')
  4974.            {  int cnt = 1;
  4975.               while ( (*((argv[i+2]) + cnt)) && (*((argv[i+2]) +cnt) != '\"'))  
  4976.               {  noQuoteBuf[cnt - 1] = *((argv[i+2]) + cnt);
  4977.           }
  4978.               [[me currentShape] setShadingGroup:noQuoteBuf];
  4979.         }
  4980.            else
  4981.            {  [[me currentShape] setShadingGroup:argv[i+2]];
  4982.            }
  4983.         }
  4984.         if (!strcmp(argv[i+1], "geometrygroup"))
  4985.         {  if (*(argv[i+2]) == '\"')
  4986.            {  int cnt = 1;
  4987.               while ( (*((argv[i+2]) + cnt)) && (*((argv[i+2]) +cnt) != '\"'))  
  4988.               {  noQuoteBuf[cnt - 1] = *((argv[i+2]) + cnt);
  4989.           }
  4990.               [[me currentShape] setGeometryGroup:noQuoteBuf];
  4991.         }
  4992.            else
  4993.            {  [[me currentShape] setGeometryGroup:argv[i+2]];
  4994.            }
  4995.         }
  4996.         if (!strcmp(argv[i+1], "materialgroup"))
  4997.         {  if (*(argv[i+2]) == '\"')
  4998.            {  int cnt = 1;
  4999.               while ( (*((argv[i+2]) + cnt)) && (*((argv[i+2]) +cnt) != '\"'))  
  5000.               {  noQuoteBuf[cnt - 1] = *((argv[i+2]) + cnt);
  5001.           }
  5002.               [[me currentShape] setMaterialGroup:noQuoteBuf];
  5003.         }
  5004.            else
  5005.            {  [[me currentShape] setMaterialGroup:argv[i+2]];
  5006.            }
  5007.         }
  5008.      }
  5009.      i += 3;
  5010.   }
  5011.   
  5012.   newRIBCommand = [[RIBAttribute alloc] init];
  5013.   [newRIBCommand setName:argv[1]
  5014.                     n:n tokens:tokens parms:parms archiveVector:archiveVector printfTypeVector:typeVector printfNVector:nVector];
  5015.   [newRIBCommand setMyShape:[me currentShape]];
  5016.   if ([me evaluatingEveCommand])
  5017.   {  [me setTmpRIBCommand:newRIBCommand];
  5018.   }
  5019.   else
  5020.   {  [[me currentShape] appendRIBCommand:newRIBCommand];
  5021.   }
  5022.  
  5023.   return TCL_OK;
  5024. }
  5025.  
  5026.  
  5027. int
  5028. isPredefinedBasis(name)
  5029. char *name;
  5030. {
  5031.   if (!strcmp("bezier", name)) { return 1; }
  5032.   if (!strcmp("b-spline", name)) { return 1; }
  5033.   if (!strcmp("catmull-rom", name)) { return 1; }
  5034.   if (!strcmp("hermite", name)) { return 1; }
  5035.   if (!strcmp("power", name)) { return 1; }
  5036.   return 0;
  5037. }
  5038.  
  5039. RtInt
  5040. stepForPredefinedBasis(name)
  5041. char *name;
  5042. {
  5043.   if (!strcmp("bezier", name)) { return RI_BEZIERSTEP; }
  5044.   if (!strcmp("b-spline", name)) { return RI_BSPLINESTEP; }
  5045.   if (!strcmp("catmull-rom", name)) { return RI_CATMULLROMSTEP; }
  5046.   if (!strcmp("hermite", name)) { return RI_HERMITESTEP; }
  5047.   if (!strcmp("power", name)) { return RI_POWERSTEP; }
  5048.   return 0;
  5049. }
  5050.  
  5051. /* return 1 on successful copy */
  5052. int
  5053. basisCpy(name, basis)
  5054. char *name;
  5055. RtBasis *basis;
  5056. {
  5057.   int i, j;
  5058.  
  5059.  
  5060.   if (!isPredefinedBasis(name)) { return 0; }
  5061.  
  5062.   if (!strcmp("bezier", name))
  5063.   {  for (i = 0; i < 4; i++)
  5064.      {  for (j = 0; j < 4; j++)
  5065.         {  (*basis)[i][j] = RiBezierBasis[i][j];
  5066.         }
  5067.      } 
  5068.      return 1;
  5069.   }
  5070.   if (!strcmp("b-spline", name))
  5071.   {  for (i = 0; i < 4; i++)
  5072.      {  for (j = 0; j < 4; j++)
  5073.         {  (*basis)[i][j] = RiBSplineBasis[i][j];
  5074.         }
  5075.      } 
  5076.      return 1;
  5077.   }
  5078.   if (!strcmp("catmull-rom", name))
  5079.   {  for (i = 0; i < 4; i++)
  5080.      {  for (j = 0; j < 4; j++)
  5081.         {  (*basis)[i][j] = RiCatmullRomBasis[i][j];
  5082.         }
  5083.      } 
  5084.      return 1;
  5085.   }
  5086.   if (!strcmp("hermite", name))
  5087.   {  for (i = 0; i < 4; i++)
  5088.      {  for (j = 0; j < 4; j++)
  5089.         {  (*basis)[i][j] = RiHermiteBasis[i][j];
  5090.         }
  5091.      } 
  5092.      return 1;
  5093.   }
  5094.   if (!strcmp("power", name))
  5095.   {  for (i = 0; i < 4; i++)
  5096.      {  for (j = 0; j < 4; j++)
  5097.         {  (*basis)[i][j] = RiPowerBasis[i][j];
  5098.         }
  5099.      } 
  5100.      return 1;
  5101.   }
  5102.  
  5103.   return 0;  
  5104. }
  5105.  
  5106.  
  5107.  
  5108. static int
  5109. cmd_RiBasis(me, interp, argc, argv)
  5110. WWEveParser    *me;
  5111. Tcl_Interp     *interp;
  5112. int            argc;
  5113. char           **argv;
  5114. {
  5115.   char     *my_args = "ubasis ustep vbasis vstep", **argv2;
  5116.   int       num_args = 5, i, j, cnt, argc2;
  5117.   RtBasis  uBasis, vBasis;
  5118.   RtInt    uStep, vStep;
  5119.   id       newRIBCommand;
  5120.  
  5121.  
  5122.   sprintf(errBuf, "evaluating %s...", argv[0]);
  5123.   [[me statusText] setStringValue:errBuf]; [[me statusText] display]; NXPing();
  5124.   if (![me riBegun])
  5125.   {  sprintf(errBuf, "You must call RiBegin before making any RIB calls");
  5126.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  5127.      return TCL_ERROR;
  5128.   }
  5129.  
  5130.   if (argc != num_args)
  5131.   {  sprintf(errBuf, "USAGE: %s %s", argv[0], my_args);
  5132.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  5133.      return TCL_ERROR;
  5134.   }
  5135.  
  5136.   /* uBasis */
  5137.   if (!isPredefinedBasis(argv[1]))
  5138.   {  if (Tcl_SplitList(interp, argv[1], &argc2, &argv2) != TCL_OK)
  5139.      {  sprintf(errBuf, 
  5140.         "%s : problem splitting <%s> as a list",
  5141.         argv[0], argv[1]);
  5142.        Tcl_AppendResult(interp, errBuf, (char *)NULL);
  5143.     return TCL_ERROR;
  5144.      }
  5145.      if (argc2 != 16)
  5146.      {  sprintf(errBuf, 
  5147.         "USAGE: %s %s\nuBasis should be one of the predefined bases (bezier, b-spline, catmull-rom, hermite, power) or have 16 elements, not %d", 
  5148.         argv[0], my_args, argc2);
  5149.        Tcl_AppendResult(interp, errBuf, (char *)NULL);
  5150.     return TCL_ERROR;
  5151.      }
  5152.  
  5153.      cnt = 0;
  5154.      for (i = 0; i < 4; i++)
  5155.      {  for (j = 0; j < 4; j++)
  5156.         {  uBasis[i][j] = (RtFloat)atof(argv2[cnt++]);
  5157.         }
  5158.      }
  5159.      free(argv2);
  5160.      uStep = (RtInt)atoi(argv[2]);
  5161.   }
  5162.   else
  5163.   {  if (!basisCpy(argv[1], &uBasis))
  5164.      {  sprintf(errBuf, "RiBasis : unable to copy predefined uBasis %s", argv[1]);
  5165.         Tcl_AppendResult(interp, errBuf, (char *)NULL);
  5166.     return TCL_ERROR;
  5167.      }
  5168.      uStep = stepForPredefinedBasis(argv[1]);
  5169.   }
  5170.  
  5171.   /* vBasis */
  5172.   if (!isPredefinedBasis(argv[3]))
  5173.   {  if (Tcl_SplitList(interp, argv[3], &argc2, &argv2) != TCL_OK)
  5174.      {  sprintf(errBuf, 
  5175.         "%s : problem splitting <%s> as a list",
  5176.         argv[0], argv[3]);
  5177.         Tcl_AppendResult(interp, errBuf, (char *)NULL);
  5178.     return TCL_ERROR;
  5179.      }
  5180.      if (argc2 != 16)
  5181.      {  sprintf(errBuf, 
  5182.         "USAGE: %s %s\nvBasis should be one of the predefined bases (bezier, b-spline, catmull-rom, hermite, power) or have 16 elements, not %d", 
  5183.         argv[0], my_args, argc2);
  5184.         Tcl_AppendResult(interp, errBuf, (char *)NULL);
  5185.     return TCL_ERROR;
  5186.      }
  5187.  
  5188.      cnt = 0;
  5189.      for (i = 0; i < 4; i++)
  5190.      {  for (j = 0; j < 4; j++)
  5191.         {  vBasis[i][j] = (RtFloat)atof(argv2[cnt++]);
  5192.         }
  5193.      }
  5194.      free(argv2);
  5195.      vStep = (RtInt)atoi(argv[2]);
  5196.   }
  5197.   else
  5198.   {  if (!basisCpy(argv[3], &vBasis))
  5199.      {  sprintf(errBuf, "RiBasis : unable to copy predefined vBasis %s", argv[3]);
  5200.         Tcl_AppendResult(interp, errBuf, (char *)NULL);
  5201.     return TCL_ERROR;
  5202.      }
  5203.      vStep = stepForPredefinedBasis(argv[3]);
  5204.   }
  5205.  
  5206.   // RiBasis(uBasis, uStep, vBasis, vStep);
  5207.   newRIBCommand = [[RIBBasis alloc] init];
  5208.   [newRIBCommand setUBasis:uBasis uBasisToken:getTokenGivenName(me, argv[1]) uStep:uStep 
  5209.                     vBasis:vBasis vBasisToken:getTokenGivenName(me, argv[3]) vStep:vStep];
  5210.   [newRIBCommand setMyShape:[me currentShape]];
  5211.   if ([me evaluatingEveCommand])
  5212.   {  [me setTmpRIBCommand:newRIBCommand];
  5213.   }
  5214.   else
  5215.   {  
  5216.      [[me currentShape] appendRIBCommand:newRIBCommand];
  5217.   }
  5218.  
  5219.   return TCL_OK;
  5220. }
  5221.  
  5222.  
  5223. static int
  5224. cmd_RiSolidBegin(me, interp, argc, argv)
  5225. WWEveParser    *me;
  5226. Tcl_Interp     *interp;
  5227. int            argc;
  5228. char           **argv;
  5229. {
  5230.   char  *my_args = "primitive|intersection|union|difference";
  5231.   int    num_args = 2;
  5232.   id       newRIBCommand;
  5233.  
  5234.  
  5235.   sprintf(errBuf, "evaluating %s...", argv[0]);
  5236.   [[me statusText] setStringValue:errBuf]; [[me statusText] display]; NXPing();
  5237.   if (![me riBegun])
  5238.   {  sprintf(errBuf, "You must call RiBegin before making any RIB calls");
  5239.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  5240.      return TCL_ERROR;
  5241.   }
  5242.  
  5243.   if ((argc != num_args) || ((strcmp(argv[1], "primitive")) && (strcmp(argv[1], "intersection")) && (strcmp(argv[1], "union")) && (strcmp(argv[1], "difference"))))
  5244.   {  sprintf(errBuf, "USAGE: %s %s", argv[0], my_args);
  5245.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  5246.      return TCL_ERROR;
  5247.   }
  5248.  
  5249.   // RiSolidBegin(getTokenGivenName(me, argv[1]));
  5250.  
  5251.   newRIBCommand = [[RIBSolidBegin alloc] init];
  5252.   [newRIBCommand setOperation:getTokenGivenName(me, argv[1])];
  5253.   [newRIBCommand setMyShape:[me currentShape]];
  5254.   if ([me evaluatingEveCommand])
  5255.   {  [me setTmpRIBCommand:newRIBCommand];
  5256.   }
  5257.   else
  5258.   {  
  5259.      [[me currentShape] appendRIBCommand:newRIBCommand];
  5260.   }
  5261.   return TCL_OK;
  5262. }
  5263.  
  5264.  
  5265. static int
  5266. cmd_RiSolidEnd(me, interp, argc, argv)
  5267. WWEveParser    *me;
  5268. Tcl_Interp     *interp;
  5269. int            argc;
  5270. char           **argv;
  5271. {
  5272.   char  *my_args = "";
  5273.   int    num_args = 1;
  5274.   id    newRIBCommand;
  5275.  
  5276.  
  5277.   sprintf(errBuf, "evaluating %s...", argv[0]);
  5278.   [[me statusText] setStringValue:errBuf]; [[me statusText] display]; NXPing();
  5279.   if (![me riBegun])
  5280.   {  sprintf(errBuf, "You must call RiBegin before making any RIB calls");
  5281.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  5282.      return TCL_ERROR;
  5283.   }
  5284.  
  5285.   if (argc > num_args)
  5286.   {  sprintf(errBuf, "USAGE: %s %s", argv[0], my_args);
  5287.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  5288.      return TCL_ERROR;
  5289.   }
  5290.  
  5291.   // RiSolidEnd();
  5292.  
  5293.   newRIBCommand = [[RIBSolidEnd alloc] init];
  5294.   [newRIBCommand setMyShape:[me currentShape]];
  5295.  
  5296.   if ([me evaluatingEveCommand])
  5297.   {  [me setTmpRIBCommand:newRIBCommand];
  5298.   }
  5299.   else
  5300.   {  
  5301.      [[me currentShape] appendRIBCommand:newRIBCommand];
  5302.   }
  5303.  
  5304.   return TCL_OK;
  5305. }
  5306.  
  5307.  
  5308. static int
  5309. cmd_RiMakeTexture(me, interp, argc, argv)
  5310. WWEveParser    *me;
  5311. Tcl_Interp     *interp;
  5312. int            argc;
  5313. char           **argv;
  5314. {
  5315.   char       *my_args = "pictureName textureName sWrap tWrap filterFuncName sWidth tWidth [parameterList]";
  5316.   int         num_args = 8, n;
  5317.   RtToken    *tokens = (RtToken *)RI_NULL;
  5318.   RtPointer  *parms = (RtPointer *)RI_NULL;
  5319.   int        *nVector = NULL, 
  5320.              *typeVector = NULL;
  5321.   char       **archiveVector = NULL;
  5322.   id         newRIBCommand;
  5323.  
  5324.  
  5325.   sprintf(errBuf, "evaluating %s...", argv[0]);
  5326.   [[me statusText] setStringValue:errBuf]; [[me statusText] display]; NXPing();
  5327.   if (![me riBegun])
  5328.   {  sprintf(errBuf, "You must call RiBegin before making any RIB calls");
  5329.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  5330.      return TCL_ERROR;
  5331.   }
  5332.  
  5333.   if (argc < num_args)
  5334.   {  sprintf(errBuf, "USAGE: %s %s", argv[0], my_args);
  5335.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  5336.      return TCL_ERROR;
  5337.   }
  5338.  
  5339.   if ((argc) % 2)
  5340.   {  sprintf(errBuf, "RiMakeTexture : parameter list must be in groups of two, i.e. the number of args is an even number");
  5341.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  5342.      return TCL_ERROR;
  5343.   }
  5344.  
  5345.   n = 0;
  5346.   if (argc > num_args)
  5347.   {  n = (argc - num_args) / 2;
  5348.      if (!buildParameterList(me, interp, n, &tokens, &parms, &archiveVector, &nVector, &typeVector, num_args, argv))
  5349.      {  return TCL_ERROR;
  5350.      }
  5351.   }
  5352.  
  5353.   newRIBCommand = [[RIBMakeTexture alloc] init];
  5354.   [newRIBCommand setPictureName:(const char *)argv[1] textureName:(const char *)argv[2]
  5355.                  sWrap:(RtToken)argv[3] tWrap:(RtToken)argv[4] filterFuncName:(const char *)argv[5]
  5356.                  sWidth:(RtFloat)atof(argv[6]) tWidth:(RtFloat)atof(argv[7])];
  5357.   [newRIBCommand setMyShape:[me currentShape]];
  5358.   if ([me evaluatingEveCommand])
  5359.   {  [me setTmpRIBCommand:newRIBCommand];
  5360.   }
  5361.   else
  5362.   {  [[me currentShape] appendRIBCommand:newRIBCommand];
  5363.   }
  5364.  
  5365.   return TCL_OK;
  5366. }
  5367.  
  5368.  
  5369. static int
  5370. cmd_RiMotionBegin(me, interp, argc, argv)
  5371. WWEveParser    *me;
  5372. Tcl_Interp     *interp;
  5373. int            argc;
  5374. char           **argv;
  5375. {
  5376.   char   *my_args = "{t0 t1 ... tn}";
  5377.   id     newRIBCommand;
  5378.   char   **argv2 = NULL;
  5379.   int     argc2, i;
  5380.   float  *times;
  5381.  
  5382.  
  5383.   sprintf(errBuf, "evaluating %s...", argv[0]);
  5384.   [[me statusText] setStringValue:errBuf]; [[me statusText] display]; NXPing();
  5385.   if (![me riBegun])
  5386.   {  sprintf(errBuf, "You must call RiBegin before making any RIB calls");
  5387.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  5388.      return TCL_ERROR;
  5389.   }
  5390.  
  5391.   if (argc == 1)
  5392.   {  sprintf(errBuf, "USAGE: %s %s", argv[0], my_args);
  5393.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  5394.      return TCL_ERROR;
  5395.   }
  5396.  
  5397.   if (Tcl_SplitList(interp, argv[1], &argc2, &argv2) != TCL_OK)
  5398.   {  sprintf(errBuf, "%s : problem splitting <%s> as a list", argv[0], argv[1]);
  5399.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  5400.      return TCL_ERROR;
  5401.   }
  5402.  
  5403.   times = (float *)malloc(sizeof(float)*argc2);
  5404.   for (i = 0; i < argc2; i++)
  5405.   {  times[i] = (float)atof(argv2[i]);
  5406.   }
  5407.   newRIBCommand = [[RIBMotionBegin alloc] init];
  5408.   [newRIBCommand setNTimes:argc2 timeVector:times];
  5409.   [newRIBCommand setMyShape:[me currentShape]];
  5410.   if ([me evaluatingEveCommand])
  5411.   {  [me setTmpRIBCommand:newRIBCommand];
  5412.   }
  5413.   else
  5414.   {  
  5415.      [[me currentShape] appendRIBCommand:newRIBCommand];
  5416.   }
  5417.   return TCL_OK;
  5418. }
  5419.  
  5420.  
  5421.  
  5422. static int
  5423. cmd_RiMotionEnd(me, interp, argc, argv)
  5424. WWEveParser    *me;
  5425. Tcl_Interp     *interp;
  5426. int            argc;
  5427. char           **argv;
  5428. {
  5429.   char  *my_args = "";
  5430.   int    num_args = 1;
  5431.   id    newRIBCommand;
  5432.  
  5433.  
  5434.   sprintf(errBuf, "evaluating %s...", argv[0]);
  5435.   [[me statusText] setStringValue:errBuf]; [[me statusText] display]; NXPing();
  5436.   if (![me riBegun])
  5437.   {  sprintf(errBuf, "You must call RiBegin before making any RIB calls");
  5438.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  5439.      return TCL_ERROR;
  5440.   }
  5441.  
  5442.   if (argc > num_args)
  5443.   {  sprintf(errBuf, "USAGE: %s %s", argv[0], my_args);
  5444.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  5445.      return TCL_ERROR;
  5446.   }
  5447.  
  5448.   newRIBCommand = [[RIBMotionEnd alloc] init];
  5449.   [newRIBCommand setMyShape:[me currentShape]];
  5450.   [[me currentShape] appendRIBCommand:newRIBCommand];
  5451.  
  5452.   return TCL_OK;
  5453. }
  5454.  
  5455.  
  5456. RIB_object_t
  5457. *getRIBObjectGivenTag(me, tag)
  5458. WWEveParser  *me;
  5459. int           tag;
  5460. {
  5461.   int        i, howMany = list_size(me->rib_object_list);
  5462.   RIB_object_t  *aRIBObject;
  5463.  
  5464.  
  5465.   for (i = 0; i < howMany; i++)
  5466.   {  aRIBObject = (RIB_object_t *)list_get_nth(me->rib_object_list, i);
  5467.      if (aRIBObject->tag == tag)
  5468.      {  return (aRIBObject);
  5469.      }
  5470.   }
  5471.   return (RIB_object_t *)NULL;
  5472. }
  5473.  
  5474.  
  5475. static int
  5476. cmd_RiObjectBegin(me, interp, argc, argv)
  5477. WWEveParser    *me;
  5478. Tcl_Interp     *interp;
  5479. int            argc;
  5480. char           **argv;
  5481. {
  5482.   char          *my_args = "tag";
  5483.   int            num_args = 2, tag;
  5484.   RIB_object_t  *aRIBObject;
  5485.  
  5486.  
  5487.   sprintf(errBuf, "evaluating %s...", argv[0]);
  5488.   [[me statusText] setStringValue:errBuf]; [[me statusText] display]; NXPing();
  5489.   if (![me riBegun])
  5490.   {  sprintf(errBuf, "You must call RiBegin before making any RIB calls");
  5491.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  5492.      return TCL_ERROR;
  5493.   }
  5494.  
  5495.   if (argc != num_args)
  5496.   {  sprintf(errBuf, "USAGE: %s %s", argv[0], my_args);
  5497.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  5498.      return TCL_ERROR;
  5499.   }
  5500.  
  5501.   tag = atoi(argv[1]);
  5502.   /* need to make sure that an object tagged with this object's tag
  5503.      doesn't already exist */
  5504.   if (getRIBObjectGivenTag(me, tag))
  5505.   {  sprintf(errBuf, "tag %d already in use", tag);
  5506.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  5507.      return TCL_ERROR;
  5508.   }
  5509.  
  5510.   aRIBObject = (RIB_object_t *)malloc(sizeof(RIB_object_t));
  5511.   if (!aRIBObject)
  5512.   {  sprintf(errBuf, "RiObjectBegin : unable to malloc memory for RIB object"); 
  5513.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  5514.      return 0;
  5515.   }
  5516.  
  5517.   aRIBObject->tag = tag;
  5518.   // aRIBObject->handle = RiObjectBegin();
  5519.  
  5520.   list_put(me->rib_object_list, aRIBObject);
  5521.  
  5522.   sprintf(errBuf, "%d", aRIBObject->tag);
  5523.   Tcl_AppendResult(interp, errBuf, (char *)NULL);
  5524.  
  5525.   return TCL_OK;
  5526. }
  5527.  
  5528.  
  5529. static int
  5530. cmd_RiObjectEnd(me, interp, argc, argv)
  5531. WWEveParser    *me;
  5532. Tcl_Interp     *interp;
  5533. int            argc;
  5534. char           **argv;
  5535. {
  5536.   char  *my_args = "";
  5537.   int    num_args = 1;
  5538.  
  5539.  
  5540.   sprintf(errBuf, "evaluating %s...", argv[0]);
  5541.   [[me statusText] setStringValue:errBuf]; [[me statusText] display]; NXPing();
  5542.   if (![me riBegun])
  5543.   {  sprintf(errBuf, "You must call RiBegin before making any RIB calls");
  5544.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  5545.      return TCL_ERROR;
  5546.   }
  5547.  
  5548.   if (argc != num_args)
  5549.   {  sprintf(errBuf, "USAGE: %s %s", argv[0], my_args);
  5550.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  5551.      return TCL_ERROR;
  5552.   }
  5553.  
  5554.   // RiObjectEnd();
  5555.  
  5556.   return TCL_OK;
  5557. }
  5558.  
  5559.  
  5560. static int
  5561. cmd_RiObjectInstance(me, interp, argc, argv)
  5562. WWEveParser    *me;
  5563. Tcl_Interp     *interp;
  5564. int            argc;
  5565. char           **argv;
  5566. {
  5567.   char          *my_args = "tag";
  5568.   int            num_args = 2, tag;
  5569.   RIB_object_t  *aRIBObject;
  5570.  
  5571.  
  5572.   sprintf(errBuf, "evaluating %s...", argv[0]);
  5573.   [[me statusText] setStringValue:errBuf]; [[me statusText] display]; NXPing();
  5574.   if (![me riBegun])
  5575.   {  sprintf(errBuf, "You must call RiBegin before making any RIB calls");
  5576.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  5577.      return TCL_ERROR;
  5578.   }
  5579.  
  5580.   if (argc != num_args)
  5581.   {  sprintf(errBuf, "USAGE: %s %s", argv[0], my_args);
  5582.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  5583.      return TCL_ERROR;
  5584.   }
  5585.  
  5586.   tag = atoi(argv[1]);
  5587.   if (!(aRIBObject = getRIBObjectGivenTag(me, tag)))
  5588.   {  sprintf(errBuf, "tag %d doesn't correspond to a defined object", tag);
  5589.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  5590.      return TCL_ERROR;
  5591.   }
  5592.  
  5593.   // RiObjectInstance(aRIBObject->handle);
  5594.  
  5595.   return TCL_OK;
  5596. }
  5597.  
  5598.  
  5599. /**************************************************************************/
  5600. /**************************************************************************/
  5601. /**************************************************************************/
  5602. /*           "when the going gets weird, the weird turn pro"              */
  5603. /**************************************************************************/
  5604. /**************************************************************************/
  5605. /**************************************************************************/
  5606.  
  5607. /* The following section has all the RenderMan commands  */
  5608. /* with the ubiquitous parameterlist                     */
  5609.  
  5610. static int
  5611. cmd_RiImager(me, interp, argc, argv)
  5612. WWEveParser    *me;
  5613. Tcl_Interp     *interp;
  5614. int            argc;
  5615. char           **argv;
  5616. {
  5617.   char  *my_args = "name [parameterlist]";
  5618.   int    num_args = 2, n;
  5619.   RtToken    *tokens = (RtToken *)RI_NULL;
  5620.   RtPointer  *parms = (RtPointer *)RI_NULL;
  5621.   int        *nVector = NULL, 
  5622.              *typeVector = NULL;
  5623.   char       **archiveVector = NULL;
  5624.  
  5625.  
  5626.  
  5627.  
  5628.  
  5629.   sprintf(errBuf, "evaluating %s...", argv[0]);
  5630.   [[me statusText] setStringValue:errBuf]; [[me statusText] display]; NXPing();
  5631.   if ([me ignoreShaders])
  5632.   {  return TCL_OK;
  5633.   }
  5634.  
  5635.   if (![me riBegun])
  5636.   {  sprintf(errBuf, "You must call RiBegin before making any RIB calls");
  5637.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  5638.      return TCL_ERROR;
  5639.   }
  5640.  
  5641.   if (argc < num_args)
  5642.   {  sprintf(errBuf, "USAGE: %s %s", argv[0], my_args);
  5643.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  5644.      return TCL_ERROR;
  5645.   }
  5646.  
  5647.   if (argc % 2)
  5648.   {  sprintf(errBuf, "RiImager : parameter list must be in groups of two, i.e. the number of args is an even number");
  5649.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  5650.      return TCL_ERROR;
  5651.   }
  5652.  
  5653.   n = 0;
  5654.   if (argc > num_args)
  5655.   {  n = (argc - num_args) / 2;
  5656.      if (!buildParameterList(me, interp, n, &tokens, &parms, &archiveVector, &nVector, &typeVector, num_args, argv))
  5657.      {  return TCL_ERROR;
  5658.      }
  5659.   }
  5660.  
  5661.   // RiImagerV(argv[1], n, tokens, parms);
  5662.  
  5663.   return TCL_OK;
  5664. }
  5665.  
  5666.  
  5667. static int
  5668. cmd_RiHider(me, interp, argc, argv)
  5669. WWEveParser    *me;
  5670. Tcl_Interp     *interp;
  5671. int            argc;
  5672. char           **argv;
  5673. {
  5674.   char  *my_args = "type [parameterlist]";
  5675.   int    num_args = 2, n;
  5676.   RtToken    *tokens = (RtToken *)RI_NULL;
  5677.   RtPointer  *parms = (RtPointer *)RI_NULL;
  5678.   int        *nVector = NULL, 
  5679.              *typeVector = NULL;
  5680.   char       **archiveVector = NULL;
  5681.  
  5682.  
  5683.  
  5684.  
  5685.  
  5686.   sprintf(errBuf, "evaluating %s...", argv[0]);
  5687.   [[me statusText] setStringValue:errBuf]; [[me statusText] display]; NXPing();
  5688.   if (![me riBegun])
  5689.   {  sprintf(errBuf, "You must call RiBegin before making any RIB calls");
  5690.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  5691.      return TCL_ERROR;
  5692.   }
  5693.  
  5694.   if (argc < num_args)
  5695.   {  sprintf(errBuf, "USAGE: %s %s", argv[0], my_args);
  5696.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  5697.      return TCL_ERROR;
  5698.   }
  5699.  
  5700.   if (argc % 2)
  5701.   {  sprintf(errBuf, "RiHider : parameter list must be in groups of two, i.e. the number of args is an even number");
  5702.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  5703.      return TCL_ERROR;
  5704.   }
  5705.  
  5706.   n = 0;
  5707.   if (argc > num_args)
  5708.   {  n = (argc - num_args) / 2;
  5709.      if (!buildParameterList(me, interp, n, &tokens, &parms, &archiveVector, &nVector, &typeVector, num_args, argv))
  5710.      {  return TCL_ERROR;
  5711.      }
  5712.   }
  5713.  
  5714.   // RiHiderV(argv[1], n, tokens, parms);
  5715.  
  5716.   return TCL_OK;
  5717. }
  5718.  
  5719.  
  5720. static int
  5721. cmd_RiLightSource(me, interp, argc, argv)
  5722. WWEveParser    *me;
  5723. Tcl_Interp     *interp;
  5724. int            argc;
  5725. char           **argv;
  5726. {
  5727.   char         *my_args = "shaderName token [parameterlist]", **argv2 = NULL;
  5728.   int           num_args = 3, n, argc2;
  5729.   RtToken      *tokens = (RtToken *)RI_NULL;
  5730.   RtPointer    *parms = (RtPointer *)RI_NULL;
  5731.   int          *nVector = NULL, 
  5732.                *typeVector = NULL;
  5733.   char         **archiveVector = NULL;
  5734.   RIB_light_t  *aRIBLight;
  5735.   id           newShader;
  5736.  
  5737.  
  5738.   sprintf(errBuf, "evaluating %s...", argv[0]);
  5739.   [[me statusText] setStringValue:errBuf]; [[me statusText] display]; NXPing();
  5740.   if ([me ignoreShaders] || [me ignoreLights])
  5741.   {  return TCL_OK;
  5742.   }
  5743.  
  5744.   if (![me riBegun])
  5745.   {  sprintf(errBuf, "You must call RiBegin before making any RIB calls");
  5746.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  5747.      return TCL_ERROR;
  5748.   }
  5749.  
  5750.   if (argc < num_args)
  5751.   {  sprintf(errBuf, "USAGE: %s %s", argv[0], my_args);
  5752.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  5753.      return TCL_ERROR;
  5754.   }
  5755.  
  5756.   if (argc == 4)
  5757.   {  if (Tcl_SplitList(interp, argv[3], &argc2, &argv2) != TCL_OK)
  5758.      {  sprintf(errBuf, "%s : problem splitting <%s> as a list", argv[0], argv[3]);
  5759.         Tcl_AppendResult(interp, errBuf, (char *)NULL);
  5760.         return TCL_ERROR;
  5761.      }
  5762.      if (argc2 % 2)
  5763.      {  if (argv2) 
  5764.         {  free(argv2); 
  5765.         }
  5766.         sprintf(errBuf, 
  5767.         "RiLightSource : parameter list must be in groups of two, i.e. the number of args is an even number");
  5768.         Tcl_AppendResult(interp, errBuf, (char *)NULL);
  5769.         return TCL_ERROR;
  5770.      }
  5771.  
  5772.      n = argc2 / 2;
  5773.      if (!buildParameterList(me, interp, n, &tokens, &parms, &archiveVector, 0, argv2))
  5774.      {  return TCL_ERROR;
  5775.      }
  5776.   }
  5777.   else
  5778.   {  if ((argc+1) % 2)
  5779.      {  sprintf(errBuf, 
  5780.         "RiLightSource : parameter list must be in groups of two, i.e. the number of args is an even number");
  5781.         Tcl_AppendResult(interp, errBuf, (char *)NULL);
  5782.     return TCL_ERROR;
  5783.      }
  5784.  
  5785.      n = 0;
  5786.      if (argc > num_args)
  5787.      {  n = (argc - num_args) / 2;
  5788.         if (!buildParameterList(me, interp, n, &tokens, &parms, &archiveVector, &nVector, &typeVector, num_args, argv))
  5789.         {  return TCL_ERROR;
  5790.         }
  5791.      }
  5792.   }
  5793.  
  5794.  
  5795.   aRIBLight = (RIB_light_t *)malloc(sizeof(RIB_light_t));
  5796.   if (!aRIBLight)
  5797.   {  sprintf(errBuf, "RiLightSource : unable to malloc memory for RIB light"); 
  5798.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  5799.      return 0;
  5800.   }
  5801.  
  5802.   aRIBLight->token = RiCreateHandle(argv[2], RI_LIGHTSOURCE);
  5803.   if (getRIBLightGivenToken(me, aRIBLight->token))
  5804.   {  fprintf(stderr, "WARNING: RiLightSource : token %s already in use - overwriting...\n", aRIBLight->token);
  5805.   }
  5806.  
  5807.   list_put(me->rib_light_list, aRIBLight);
  5808.  
  5809.   newShader = [[WW3DShader alloc] initWithShader:argv[1] n:n tokens:tokens parms:parms 
  5810.                               archiveVector:archiveVector printfTypeVector:typeVector printfNVector:nVector];
  5811.  
  5812.   [newShader setToken:aRIBLight->token];
  5813.   if ([me evaluatingEveCommand])
  5814.   {  [me setTmpRIBCommand:newShader];
  5815.   }
  5816.   else
  5817.   {  if ([me applyShadersDirectlyToCurrentShape])
  5818.      {  //[[me currentShape] setShader_:newShader];
  5819.         // this tickles a nasty bug in NeXT's 3DKit...
  5820.         [[me currentShape] appendRIBCommand:newShader];
  5821.      }
  5822.      else
  5823.      {  [[me currentShape] appendRIBCommand:newShader];
  5824.      }
  5825.   }
  5826.  
  5827.   sprintf(errBuf, "%d", (int)aRIBLight->token);
  5828.   Tcl_AppendResult(interp, errBuf, (char *)NULL);
  5829.  
  5830.   return TCL_OK;
  5831. }
  5832.  
  5833.  
  5834. static int
  5835. cmd_RiAreaLightSource(me, interp, argc, argv)
  5836. WWEveParser    *me;
  5837. Tcl_Interp     *interp;
  5838. int            argc;
  5839. char           **argv;
  5840. {
  5841.   char         *my_args = "shaderName token [parameterlist]", **argv2 = NULL;
  5842.   int           num_args = 3, n, argc2;
  5843.   RtToken      *tokens = (RtToken *)RI_NULL;
  5844.   RtPointer    *parms = (RtPointer *)RI_NULL;
  5845.   int          *nVector = NULL, 
  5846.                *typeVector = NULL;
  5847.   char         **archiveVector = NULL;
  5848.   RIB_light_t  *aRIBLight;
  5849.   id           newShader;
  5850.  
  5851.  
  5852.   sprintf(errBuf, "evaluating %s...", argv[0]);
  5853.   [[me statusText] setStringValue:errBuf]; [[me statusText] display]; NXPing();
  5854.   if ([me ignoreShaders] || [me ignoreLights])
  5855.   {  return TCL_OK;
  5856.   }
  5857.  
  5858.   if (![me riBegun])
  5859.   {  sprintf(errBuf, "You must call RiBegin before making any RIB calls");
  5860.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  5861.      return TCL_ERROR;
  5862.   }
  5863.  
  5864.   if (argc < num_args)
  5865.   {  sprintf(errBuf, "USAGE: %s %s", argv[0], my_args);
  5866.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  5867.      return TCL_ERROR;
  5868.   }
  5869.  
  5870.   if (argc == 4)
  5871.   {  if (Tcl_SplitList(interp, argv[3], &argc2, &argv2) != TCL_OK)
  5872.      {  sprintf(errBuf, "%s : problem splitting <%s> as a list", argv[0], argv[3]);
  5873.         Tcl_AppendResult(interp, errBuf, (char *)NULL);
  5874.         return TCL_ERROR;
  5875.      }
  5876.      if (argc2 % 2)
  5877.      {  if (argv2) 
  5878.         {  free(argv2); 
  5879.         }
  5880.         sprintf(errBuf, 
  5881.         "RiLightSource : parameter list must be in groups of two, i.e. the number of args is an even number");
  5882.         Tcl_AppendResult(interp, errBuf, (char *)NULL);
  5883.         return TCL_ERROR;
  5884.      }
  5885.  
  5886.      n = argc2 / 2;
  5887.      if (!buildParameterList(me, interp, n, &tokens, &parms, &archiveVector, 0, argv2))
  5888.      {  return TCL_ERROR;
  5889.      }
  5890.   }
  5891.   else
  5892.   {  if ((argc+1) % 2)
  5893.      {  sprintf(errBuf, 
  5894.         "RiLightSource : parameter list must be in groups of two, i.e. the number of args is an even number");
  5895.         Tcl_AppendResult(interp, errBuf, (char *)NULL);
  5896.     return TCL_ERROR;
  5897.      }
  5898.  
  5899.      n = 0;
  5900.      if (argc > num_args)
  5901.      {  n = (argc - num_args) / 2;
  5902.         if (!buildParameterList(me, interp, n, &tokens, &parms, &archiveVector, &nVector, &typeVector, num_args, argv))
  5903.         {  return TCL_ERROR;
  5904.         }
  5905.      }
  5906.   }
  5907.  
  5908.  
  5909.   aRIBLight = (RIB_light_t *)malloc(sizeof(RIB_light_t));
  5910.   if (!aRIBLight)
  5911.   {  sprintf(errBuf, "RiLightSource : unable to malloc memory for RIB light"); 
  5912.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  5913.      return 0;
  5914.   }
  5915.  
  5916.   aRIBLight->token = RiCreateHandle(argv[2], RI_LIGHTSOURCE);
  5917.   if (getRIBLightGivenToken(me, aRIBLight->token))
  5918.   {  fprintf(stderr, "WARNING: RiLightSource : token %s already in use - overwriting...\n", aRIBLight->token);
  5919.   }
  5920.  
  5921.   list_put(me->rib_light_list, aRIBLight);
  5922.  
  5923.   newShader = [[WW3DShader alloc] initWithShader:argv[1] n:n tokens:tokens parms:parms 
  5924.                               archiveVector:archiveVector printfTypeVector:typeVector printfNVector:nVector];
  5925.  
  5926.   [newShader setToken:aRIBLight->token];
  5927.   if ([me evaluatingEveCommand])
  5928.   {  [me setTmpRIBCommand:newShader];
  5929.   }
  5930.   else
  5931.   {  if ([me applyShadersDirectlyToCurrentShape])
  5932.      {  //[[me currentShape] setShader_:newShader];
  5933.         // this tickles a nasty bug in NeXT's 3DKit...
  5934.         [[me currentShape] appendRIBCommand:newShader];
  5935.      }
  5936.      else
  5937.      {  [[me currentShape] appendRIBCommand:newShader];
  5938.      }
  5939.   }
  5940.  
  5941.   sprintf(errBuf, "%d", (int)aRIBLight->token);
  5942.   Tcl_AppendResult(interp, errBuf, (char *)NULL);
  5943.  
  5944.   return TCL_OK;
  5945. }
  5946.  
  5947.  
  5948. static int
  5949. cmd_RiSurface(me, interp, argc, argv)
  5950. WWEveParser    *me;
  5951. Tcl_Interp     *interp;
  5952. int            argc;
  5953. char           **argv;
  5954. {
  5955.   char  *my_args = "name [parameterlist]", **argv2 = NULL;
  5956.   int    num_args = 2, n, argc2;
  5957.   RtToken    *tokens = (RtToken *)RI_NULL;
  5958.   RtPointer  *parms = (RtPointer *)RI_NULL;
  5959.   int        *nVector = NULL, 
  5960.              *typeVector = NULL;
  5961.   char       **archiveVector = NULL;
  5962.   id         newShader;
  5963.  
  5964.  
  5965.   sprintf(errBuf, "evaluating %s...", argv[0]);
  5966.   [[me statusText] setStringValue:errBuf]; [[me statusText] display]; NXPing();
  5967.   if ([me ignoreShaders])
  5968.   {  return TCL_OK;
  5969.   }
  5970.  
  5971.   if (![me riBegun])
  5972.   {  sprintf(errBuf, "You must call RiBegin before making any RIB calls");
  5973.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  5974.      return TCL_ERROR;
  5975.   }
  5976.  
  5977.   if (argc < num_args)
  5978.   {  sprintf(errBuf, "USAGE: %s %s", argv[0], my_args);
  5979.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  5980.      return TCL_ERROR;
  5981.   }
  5982.  
  5983.   if (argc == 3)
  5984.   {  if (Tcl_SplitList(interp, argv[2], &argc2, &argv2) != TCL_OK)
  5985.      {  sprintf(errBuf, "%s : problem splitting <%s> as a list", argv[0], argv[2]);
  5986.         Tcl_AppendResult(interp, errBuf, (char *)NULL);
  5987.         return TCL_ERROR;
  5988.      }
  5989.      if (argc2 % 2)
  5990.      {  if (argv2) 
  5991.         {  free(argv2); 
  5992.         }
  5993.         sprintf(errBuf, 
  5994.         "RiSurface : parameter list must be in groups of two, i.e. the number of args is an even number");
  5995.         Tcl_AppendResult(interp, errBuf, (char *)NULL);
  5996.         return TCL_ERROR;
  5997.      }
  5998.  
  5999.      n = argc2 / 2;
  6000.      if (!buildParameterList(me, interp, n, &tokens, &parms, &archiveVector, 0, argv2))
  6001.      {  return TCL_ERROR;
  6002.      }
  6003.   }
  6004.   else
  6005.   {  if (argc % 2)
  6006.      {  sprintf(errBuf, "RiSurface : parameter list must be in groups of two, i.e. the number of args is an even number");
  6007.         Tcl_AppendResult(interp, errBuf, (char *)NULL);
  6008.     return TCL_ERROR;
  6009.      }
  6010.  
  6011.      n = 0;
  6012.      if (argc > num_args)
  6013.      {  n = (argc - num_args) / 2;
  6014.     if (!buildParameterList(me, interp, n, &tokens, &parms, &archiveVector, &nVector, &typeVector, num_args, argv))
  6015.     {  return TCL_ERROR;
  6016.     }
  6017.      }
  6018.   }
  6019.   // RiSurfaceV(argv[1], n, tokens, parms);
  6020.  
  6021.   newShader = [[WW3DShader alloc] initWithShader:argv[1] n:n tokens:tokens parms:parms archiveVector:archiveVector printfTypeVector:typeVector printfNVector:nVector];
  6022.   if ([me evaluatingEveCommand])
  6023.   {  [me setTmpRIBCommand:newShader];
  6024.   }
  6025.   else
  6026.   {  if ([me applyShadersDirectlyToCurrentShape])
  6027.      {  [[me currentShape] setShader_:newShader];
  6028.      }
  6029.      else
  6030.      {  [[me currentShape] appendRIBCommand:newShader];
  6031.      }
  6032.   }
  6033.  
  6034.   if (argv2)
  6035.   {  free(argv2);
  6036.   }
  6037.  
  6038.   return TCL_OK;
  6039. }
  6040.  
  6041.  
  6042. static int
  6043. cmd_RiAtmosphere(me, interp, argc, argv)
  6044. WWEveParser    *me;
  6045. Tcl_Interp     *interp;
  6046. int            argc;
  6047. char           **argv;
  6048. {
  6049.   char  *my_args = "name [parameterlist]", **argv2 = NULL;
  6050.   int    num_args = 2, n, argc2;
  6051.   RtToken    *tokens = (RtToken *)RI_NULL;
  6052.   RtPointer  *parms = (RtPointer *)RI_NULL;
  6053.   int        *nVector = NULL, 
  6054.              *typeVector = NULL;
  6055.   char       **archiveVector = NULL;
  6056.   id         newShader;
  6057.  
  6058.  
  6059.   sprintf(errBuf, "evaluating %s...", argv[0]);
  6060.   [[me statusText] setStringValue:errBuf]; [[me statusText] display]; NXPing();
  6061.   if ([me ignoreShaders])
  6062.   {  return TCL_OK;
  6063.   }
  6064.  
  6065.   if (![me riBegun])
  6066.   {  sprintf(errBuf, "You must call RiBegin before making any RIB calls");
  6067.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  6068.      return TCL_ERROR;
  6069.   }
  6070.  
  6071.   if (argc < num_args)
  6072.   {  sprintf(errBuf, "USAGE: %s %s", argv[0], my_args);
  6073.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  6074.      return TCL_ERROR;
  6075.   }
  6076.  
  6077.   if (argc == 3)
  6078.   {  if (Tcl_SplitList(interp, argv[2], &argc2, &argv2) != TCL_OK)
  6079.      {  sprintf(errBuf, "%s : problem splitting <%s> as a list", argv[0], argv[2]);
  6080.         Tcl_AppendResult(interp, errBuf, (char *)NULL);
  6081.         return TCL_ERROR;
  6082.      }
  6083.      if (argc2 % 2)
  6084.      {  if (argv2) 
  6085.         {  free(argv2); 
  6086.         }
  6087.         sprintf(errBuf, 
  6088.         "RiAtmosphere : parameter list must be in groups of two, i.e. the number of args is an even number");
  6089.         Tcl_AppendResult(interp, errBuf, (char *)NULL);
  6090.         return TCL_ERROR;
  6091.      }
  6092.  
  6093.      n = argc2 / 2;
  6094.      if (!buildParameterList(me, interp, n, &tokens, &parms, &archiveVector, 0, argv2))
  6095.      {  return TCL_ERROR;
  6096.      }
  6097.   }
  6098.   else
  6099.   {  if (argc % 2)
  6100.      {  sprintf(errBuf, "RiAtmosphere : parameter list must be in groups of two, i.e. the number of args is an even number");
  6101.         Tcl_AppendResult(interp, errBuf, (char *)NULL);
  6102.     return TCL_ERROR;
  6103.      }
  6104.  
  6105.      n = 0;
  6106.      if (argc > num_args)
  6107.      {  n = (argc - num_args) / 2;
  6108.     if (!buildParameterList(me, interp, n, &tokens, &parms, &archiveVector, &nVector, &typeVector, num_args, argv))
  6109.     {  return TCL_ERROR;
  6110.     }
  6111.      }
  6112.   }
  6113.   // RiAtmosphereV(argv[1], n, tokens, parms);
  6114.  
  6115.   newShader = [[WW3DShader alloc] initWithShader:argv[1] n:n tokens:tokens parms:parms archiveVector:archiveVector printfTypeVector:typeVector printfNVector:nVector];
  6116.   if ([me evaluatingEveCommand])
  6117.   {  [me setTmpRIBCommand:newShader];
  6118.   }
  6119.   else
  6120.   {  if ([me applyShadersDirectlyToCurrentShape])
  6121.      {  [[me currentShape] setShader_:newShader];
  6122.      }
  6123.      else
  6124.      {  [[me currentShape] appendRIBCommand:newShader];
  6125.      }
  6126.   }
  6127.  
  6128.   return TCL_OK;
  6129. }
  6130.  
  6131.  
  6132. static int
  6133. cmd_RiInterior(me, interp, argc, argv)
  6134. WWEveParser    *me;
  6135. Tcl_Interp     *interp;
  6136. int            argc;
  6137. char           **argv;
  6138. {
  6139.   char  *my_args = "name [parameterlist]", **argv2 = NULL;
  6140.   int    num_args = 2, n, argc2;
  6141.   RtToken    *tokens = (RtToken *)RI_NULL;
  6142.   RtPointer  *parms = (RtPointer *)RI_NULL;
  6143.   int        *nVector = NULL, 
  6144.              *typeVector = NULL;
  6145.   char       **archiveVector = NULL;
  6146.   id         newShader;
  6147.  
  6148.  
  6149.   sprintf(errBuf, "evaluating %s...", argv[0]);
  6150.   [[me statusText] setStringValue:errBuf]; [[me statusText] display]; NXPing();
  6151.   if ([me ignoreShaders])
  6152.   {  return TCL_OK;
  6153.   }
  6154.  
  6155.   if (![me riBegun])
  6156.   {  sprintf(errBuf, "You must call RiBegin before making any RIB calls");
  6157.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  6158.      return TCL_ERROR;
  6159.   }
  6160.  
  6161.   if (argc < num_args)
  6162.   {  sprintf(errBuf, "USAGE: %s %s", argv[0], my_args);
  6163.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  6164.      return TCL_ERROR;
  6165.   }
  6166.  
  6167.   if (argc == 3)
  6168.   {  if (Tcl_SplitList(interp, argv[2], &argc2, &argv2) != TCL_OK)
  6169.      {  sprintf(errBuf, "%s : problem splitting <%s> as a list", argv[0], argv[2]);
  6170.         Tcl_AppendResult(interp, errBuf, (char *)NULL);
  6171.         return TCL_ERROR;
  6172.      }
  6173.      if (argc2 % 2)
  6174.      {  if (argv2) 
  6175.         {  free(argv2); 
  6176.         }
  6177.         sprintf(errBuf, 
  6178.         "RiInterior : parameter list must be in groups of two, i.e. the number of args is an even number");
  6179.         Tcl_AppendResult(interp, errBuf, (char *)NULL);
  6180.         return TCL_ERROR;
  6181.      }
  6182.  
  6183.      n = argc2 / 2;
  6184.      if (!buildParameterList(me, interp, n, &tokens, &parms, &archiveVector, 0, argv2))
  6185.      {  return TCL_ERROR;
  6186.      }
  6187.   }
  6188.   else
  6189.   {  if (argc % 2)
  6190.      {  sprintf(errBuf, "RiInterior : parameter list must be in groups of two, i.e. the number of args is an even number");
  6191.         Tcl_AppendResult(interp, errBuf, (char *)NULL);
  6192.     return TCL_ERROR;
  6193.      }
  6194.  
  6195.      n = 0;
  6196.      if (argc > num_args)
  6197.      {  n = (argc - num_args) / 2;
  6198.     if (!buildParameterList(me, interp, n, &tokens, &parms, &archiveVector, &nVector, &typeVector, num_args, argv))
  6199.     {  return TCL_ERROR;
  6200.     }
  6201.      }
  6202.   }
  6203.   // RiInteriorV(argv[1], n, tokens, parms);
  6204.  
  6205.   newShader = [[WW3DShader alloc] initWithShader:argv[1] n:n tokens:tokens parms:parms archiveVector:archiveVector printfTypeVector:typeVector printfNVector:nVector];
  6206.   if ([me evaluatingEveCommand])
  6207.   {  [me setTmpRIBCommand:newShader];
  6208.   }
  6209.   else
  6210.   {  if ([me applyShadersDirectlyToCurrentShape])
  6211.      {  [[me currentShape] setShader_:newShader];
  6212.      }
  6213.      else
  6214.      {  [[me currentShape] appendRIBCommand:newShader];
  6215.      }
  6216.   }
  6217.  
  6218.   return TCL_OK;
  6219. }
  6220.  
  6221.  
  6222. static int
  6223. cmd_RiExterior(me, interp, argc, argv)
  6224. WWEveParser    *me;
  6225. Tcl_Interp     *interp;
  6226. int            argc;
  6227. char           **argv;
  6228. {
  6229.   char  *my_args = "name [parameterlist]", **argv2 = NULL;
  6230.   int    num_args = 2, n, argc2;
  6231.   RtToken    *tokens = (RtToken *)RI_NULL;
  6232.   RtPointer  *parms = (RtPointer *)RI_NULL;
  6233.   int        *nVector = NULL, 
  6234.              *typeVector = NULL;
  6235.   char       **archiveVector = NULL;
  6236.   id         newShader;
  6237.  
  6238.  
  6239.   sprintf(errBuf, "evaluating %s...", argv[0]);
  6240.   [[me statusText] setStringValue:errBuf]; [[me statusText] display]; NXPing(); 
  6241.   if ([me ignoreShaders])
  6242.   {  return TCL_OK;
  6243.   }
  6244.  
  6245.   if (![me riBegun])
  6246.   {  sprintf(errBuf, "You must call RiBegin before making any RIB calls");
  6247.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  6248.      return TCL_ERROR;
  6249.   }
  6250.  
  6251.   if (argc < num_args)
  6252.   {  sprintf(errBuf, "USAGE: %s %s", argv[0], my_args);
  6253.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  6254.      return TCL_ERROR;
  6255.   }
  6256.  
  6257.   if (argc == 3)
  6258.   {  if (Tcl_SplitList(interp, argv[2], &argc2, &argv2) != TCL_OK)
  6259.      {  sprintf(errBuf, "%s : problem splitting <%s> as a list", argv[0], argv[2]);
  6260.         Tcl_AppendResult(interp, errBuf, (char *)NULL);
  6261.         return TCL_ERROR;
  6262.      }
  6263.      if (argc2 % 2)
  6264.      {  if (argv2) 
  6265.         {  free(argv2); 
  6266.         }
  6267.         sprintf(errBuf, 
  6268.         "RiExterior : parameter list must be in groups of two, i.e. the number of args is an even number");
  6269.         Tcl_AppendResult(interp, errBuf, (char *)NULL);
  6270.         return TCL_ERROR;
  6271.      }
  6272.  
  6273.      n = argc2 / 2;
  6274.      if (!buildParameterList(me, interp, n, &tokens, &parms, &archiveVector, 0, argv2))
  6275.      {  return TCL_ERROR;
  6276.      }
  6277.   }
  6278.   else
  6279.   {  if (argc % 2)
  6280.      {  sprintf(errBuf, "RiExterior : parameter list must be in groups of two, i.e. the number of args is an even number");
  6281.         Tcl_AppendResult(interp, errBuf, (char *)NULL);
  6282.     return TCL_ERROR;
  6283.      }
  6284.  
  6285.      n = 0;
  6286.      if (argc > num_args)
  6287.      {  n = (argc - num_args) / 2;
  6288.     if (!buildParameterList(me, interp, n, &tokens, &parms, &archiveVector, &nVector, &typeVector, num_args, argv))
  6289.     {  return TCL_ERROR;
  6290.     }
  6291.      }
  6292.   }
  6293.   // RiExteriorV(argv[1], n, tokens, parms);
  6294.  
  6295.   newShader = [[WW3DShader alloc] initWithShader:argv[1] n:n tokens:tokens parms:parms archiveVector:archiveVector printfTypeVector:typeVector printfNVector:nVector];
  6296.   if ([me evaluatingEveCommand])
  6297.   {  [me setTmpRIBCommand:newShader];
  6298.   }
  6299.   else
  6300.   {  if ([me applyShadersDirectlyToCurrentShape])
  6301.      {  [[me currentShape] setShader_:newShader];
  6302.      }
  6303.      else
  6304.      {  [[me currentShape] appendRIBCommand:newShader];
  6305.      }
  6306.   }
  6307.  
  6308.   return TCL_OK;
  6309. }
  6310.  
  6311.  
  6312. static int
  6313. cmd_RiDeformation(me, interp, argc, argv)
  6314. WWEveParser    *me;
  6315. Tcl_Interp     *interp;
  6316. int            argc;
  6317. char           **argv;
  6318. {
  6319.   char  *my_args = "name [parameterlist]", **argv2 = NULL;
  6320.   int    num_args = 2, n, argc2;
  6321.   RtToken    *tokens = (RtToken *)RI_NULL;
  6322.   RtPointer  *parms = (RtPointer *)RI_NULL;
  6323.   int        *nVector = NULL, 
  6324.              *typeVector = NULL;
  6325.   char       **archiveVector = NULL;
  6326.   id         newShader;
  6327.  
  6328.  
  6329.   sprintf(errBuf, "evaluating %s...", argv[0]);
  6330.   [[me statusText] setStringValue:errBuf]; [[me statusText] display]; NXPing();
  6331.   if ([me ignoreShaders])
  6332.   {  return TCL_OK;
  6333.   }
  6334.  
  6335.   if (![me riBegun])
  6336.   {  sprintf(errBuf, "You must call RiBegin before making any RIB calls");
  6337.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  6338.      return TCL_ERROR;
  6339.   }
  6340.  
  6341.   if (argc < num_args)
  6342.   {  sprintf(errBuf, "USAGE: %s %s", argv[0], my_args);
  6343.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  6344.      return TCL_ERROR;
  6345.   }
  6346.  
  6347.   if (argc == 3)
  6348.   {  if (Tcl_SplitList(interp, argv[2], &argc2, &argv2) != TCL_OK)
  6349.      {  sprintf(errBuf, "%s : problem splitting <%s> as a list", argv[0], argv[2]);
  6350.         Tcl_AppendResult(interp, errBuf, (char *)NULL);
  6351.         return TCL_ERROR;
  6352.      }
  6353.      if (argc2 % 2)
  6354.      {  if (argv2) 
  6355.         {  free(argv2); 
  6356.         }
  6357.         sprintf(errBuf, 
  6358.         "RiDeformation list must be in groups of two, i.e. the number of args is an even number");
  6359.         Tcl_AppendResult(interp, errBuf, (char *)NULL);
  6360.         return TCL_ERROR;
  6361.      }
  6362.  
  6363.      n = argc2 / 2;
  6364.      if (!buildParameterList(me, interp, n, &tokens, &parms, &archiveVector, 0, argv2))
  6365.      {  return TCL_ERROR;
  6366.      }
  6367.   }
  6368.   else
  6369.   {  if (argc % 2)
  6370.      {  sprintf(errBuf, "RiDeformation : parameter list must be in groups of two, i.e. the number of args is an even number");
  6371.         Tcl_AppendResult(interp, errBuf, (char *)NULL);
  6372.     return TCL_ERROR;
  6373.      }
  6374.  
  6375.      n = 0;
  6376.      if (argc > num_args)
  6377.      {  n = (argc - num_args) / 2;
  6378.     if (!buildParameterList(me, interp, n, &tokens, &parms, &archiveVector, &nVector, &typeVector, num_args, argv))
  6379.     {  return TCL_ERROR;
  6380.     }
  6381.      }
  6382.   }
  6383.   // RiDeformationV(argv[1], n, tokens, parms);
  6384.  
  6385.   newShader = [[WW3DShader alloc] initWithShader:argv[1] n:n tokens:tokens parms:parms archiveVector:archiveVector printfTypeVector:typeVector printfNVector:nVector];
  6386.   if ([me evaluatingEveCommand])
  6387.   {  [me setTmpRIBCommand:newShader];
  6388.   }
  6389.   else
  6390.   {  if ([me applyShadersDirectlyToCurrentShape])
  6391.      {  [[me currentShape] setShader_:newShader];
  6392.      }
  6393.      else
  6394.      {  [[me currentShape] appendRIBCommand:newShader];
  6395.      }
  6396.   }
  6397.  
  6398.   return TCL_OK;
  6399. }
  6400.  
  6401.  
  6402. static int
  6403. cmd_RiDisplacement(me, interp, argc, argv)
  6404. WWEveParser    *me;
  6405. Tcl_Interp     *interp;
  6406. int            argc;
  6407. char           **argv;
  6408. {
  6409.   char  *my_args = "name [parameterlist]", **argv2 = NULL;
  6410.   int    num_args = 2, n, argc2;
  6411.   RtToken    *tokens = (RtToken *)RI_NULL;
  6412.   RtPointer  *parms = (RtPointer *)RI_NULL;
  6413.   int        *nVector = NULL, 
  6414.              *typeVector = NULL;
  6415.   char       **archiveVector = NULL;
  6416.   id         newShader;
  6417.  
  6418.  
  6419.   sprintf(errBuf, "evaluating %s...", argv[0]);
  6420.   [[me statusText] setStringValue:errBuf]; [[me statusText] display]; NXPing();
  6421.   if ([me ignoreShaders])
  6422.   {  return TCL_OK;
  6423.   }
  6424.  
  6425.   if (![me riBegun])
  6426.   {  sprintf(errBuf, "You must call RiBegin before making any RIB calls");
  6427.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  6428.      return TCL_ERROR;
  6429.   }
  6430.  
  6431.   if (argc < num_args)
  6432.   {  sprintf(errBuf, "USAGE: %s %s", argv[0], my_args);
  6433.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  6434.      return TCL_ERROR;
  6435.   }
  6436.  
  6437.   if (argc == 3)
  6438.   {  if (Tcl_SplitList(interp, argv[2], &argc2, &argv2) != TCL_OK)
  6439.      {  sprintf(errBuf, "%s : problem splitting <%s> as a list", argv[0], argv[2]);
  6440.         Tcl_AppendResult(interp, errBuf, (char *)NULL);
  6441.         return TCL_ERROR;
  6442.      }
  6443.      if (argc2 % 2)
  6444.      {  if (argv2) 
  6445.         {  free(argv2); 
  6446.         }
  6447.         sprintf(errBuf, 
  6448.         "RiDisplacement : parameter list must be in groups of two, i.e. the number of args is an even number");
  6449.         Tcl_AppendResult(interp, errBuf, (char *)NULL);
  6450.         return TCL_ERROR;
  6451.      }
  6452.  
  6453.      n = argc2 / 2;
  6454.      if (!buildParameterList(me, interp, n, &tokens, &parms, &archiveVector, 0, argv2))
  6455.      {  return TCL_ERROR;
  6456.      }
  6457.   }
  6458.   else
  6459.   {  if (argc % 2)
  6460.      {  sprintf(errBuf, "RiDisplacement : parameter list must be in groups of two, i.e. the number of args is an even number");
  6461.         Tcl_AppendResult(interp, errBuf, (char *)NULL);
  6462.     return TCL_ERROR;
  6463.      }
  6464.  
  6465.      n = 0;
  6466.      if (argc > num_args)
  6467.      {  n = (argc - num_args) / 2;
  6468.     if (!buildParameterList(me, interp, n, &tokens, &parms, &archiveVector, &nVector, &typeVector, num_args, argv))
  6469.     {  return TCL_ERROR;
  6470.     }
  6471.      }
  6472.   }
  6473.   // RiDisplacementV(argv[1], n, tokens, parms);
  6474.  
  6475.   newShader = [[WW3DShader alloc] initWithShader:argv[1] n:n tokens:tokens parms:parms archiveVector:archiveVector printfTypeVector:typeVector printfNVector:nVector];
  6476.   if ([me evaluatingEveCommand])
  6477.   {  [me setTmpRIBCommand:newShader];
  6478.   }
  6479.   else
  6480.   {  if ([me applyShadersDirectlyToCurrentShape])
  6481.      {  [[me currentShape] setShader_:newShader];
  6482.      }
  6483.      else
  6484.      {  [[me currentShape] appendRIBCommand:newShader];
  6485.      }
  6486.   }
  6487.  
  6488.   return TCL_OK;
  6489. }
  6490.  
  6491.  
  6492. static int
  6493. cmd_RiPolygon(me, interp, argc, argv)
  6494. WWEveParser    *me;
  6495. Tcl_Interp     *interp;
  6496. int            argc;
  6497. char           **argv;
  6498. {
  6499.   char  *my_args = "[parameterlist]", **argv2;
  6500.   int    num_args = 1, n, i, argc2;
  6501.   RtToken    *tokens = (RtToken *)RI_NULL;
  6502.   RtPointer  *parms = (RtPointer *)RI_NULL;
  6503.   int        *nVector = NULL, 
  6504.              *typeVector = NULL;
  6505.   char       **archiveVector = NULL;
  6506.   RtInt      nVertices;
  6507.   id         newRIBCommand;
  6508.  
  6509.  
  6510.   sprintf(errBuf, "evaluating %s...", argv[0]);
  6511.   [[me statusText] setStringValue:errBuf]; [[me statusText] display]; NXPing();
  6512.   if (![me riBegun])
  6513.   {  sprintf(errBuf, "You must call RiBegin before making any RIB calls");
  6514.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  6515.      return TCL_ERROR;
  6516.   }
  6517.  
  6518.   if (argc < num_args)
  6519.   {  sprintf(errBuf, "USAGE: %s %s", argv[0], my_args);
  6520.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  6521.      return TCL_ERROR;
  6522.   }
  6523.  
  6524.   if ((argc+1) % 2)
  6525.   {  sprintf(errBuf, "RiPolygon : parameter list must be in groups of two, i.e. the number of args is an even number");
  6526.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  6527.      return TCL_ERROR;
  6528.   }
  6529.  
  6530.   /* need to grovel over parameter list to find "P" to get number of number of vertices */
  6531.   nVertices = 0;  i = 1;
  6532.   while ((!nVertices) && (i < argc))
  6533.   {  if (!strcmp(argv[i], "P"))
  6534.      {  if (Tcl_SplitList(interp, argv[i+1], &argc2, &argv2) != TCL_OK)
  6535.         {  sprintf(errBuf, "%s : problem splitting <%s> as a list", argv[0], argv[i+1]);
  6536.            Tcl_AppendResult(interp, errBuf, (char *)NULL);
  6537.            return TCL_ERROR;
  6538.         }
  6539.         if (argv2) { free(argv2); }
  6540.     if (argc2 % 3)
  6541.         {  sprintf(errBuf, "RiPolygon : the value of the token P must be in 3-vectors - this one has %d elements", argc2);
  6542.            Tcl_AppendResult(interp, errBuf, (char *)NULL);
  6543.        return TCL_ERROR;
  6544.         }
  6545.         nVertices = argc2 / 3;
  6546.      }
  6547.      i += 2;
  6548.   }
  6549.  
  6550.   n = 0;
  6551.   if (argc > num_args)
  6552.   {  n = (argc - num_args) / 2;
  6553.      if (!buildParameterList(me, interp, n, &tokens, &parms, &archiveVector, &nVector, &typeVector, num_args, argv))
  6554.      {  return TCL_ERROR;
  6555.      }
  6556.   }
  6557.  
  6558.   // RiPolygonV(nVertices, n, tokens, parms);
  6559.  
  6560.   newRIBCommand = [[RIBPolygon alloc] init];
  6561.   [newRIBCommand setNVertices:nVertices n:n tokens:tokens parms:parms archiveVector:archiveVector printfTypeVector:typeVector printfNVector:nVector];
  6562.   [newRIBCommand setMyShape:[me currentShape]];
  6563.   if ([me evaluatingEveCommand])
  6564.   {  [me setTmpRIBCommand:newRIBCommand];
  6565.   }
  6566.   else
  6567.   {  [[me currentShape] appendRIBCommand:newRIBCommand];
  6568.   }
  6569.  
  6570.   return TCL_OK;
  6571. }
  6572.  
  6573.  
  6574. static int
  6575. cmd_RiGeneralPolygon(me, interp, argc, argv)
  6576. WWEveParser    *me;
  6577. Tcl_Interp     *interp;
  6578. int            argc;
  6579. char           **argv;
  6580. {
  6581.   char       *my_args = "nVertices [parameterlist]", 
  6582.              **argv2;
  6583.   int         num_args = 2, n, i, argc2;
  6584.   RtToken    *tokens = (RtToken *)RI_NULL;
  6585.   RtPointer  *parms = (RtPointer *)RI_NULL;
  6586.   int        *nVector = NULL, 
  6587.              *typeVector = NULL;
  6588.   char       **archiveVector = NULL;
  6589.   RtInt      *nVertices;
  6590.   id         newRIBCommand;
  6591.  
  6592.  
  6593.   sprintf(errBuf, "evaluating %s...", argv[0]);
  6594.   [[me statusText] setStringValue:errBuf]; [[me statusText] display]; NXPing();
  6595.   if (![me riBegun])
  6596.   {  sprintf(errBuf, "You must call RiBegin before making any RIB calls");
  6597.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  6598.      return TCL_ERROR;
  6599.   }
  6600.  
  6601.   if (argc < num_args)
  6602.   {  sprintf(errBuf, "USAGE: %s %s", argv[0], my_args);
  6603.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  6604.      return TCL_ERROR;
  6605.   }
  6606.  
  6607.   if (argc % 2)
  6608.   {  sprintf(errBuf, "RiGeneralPolygon : parameter list must be in groups of two : USAGE: %s %s", 
  6609.          argv[0], my_args);
  6610.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  6611.      return TCL_ERROR;
  6612.   }
  6613.  
  6614.   if (Tcl_SplitList(interp, argv[1], &argc2, &argv2) != TCL_OK)
  6615.   {  sprintf(errBuf, "%s : problem splitting <%s> as a list", argv[0], argv[1]);
  6616.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  6617.      return TCL_ERROR;
  6618.   }
  6619.   nVertices = (RtInt *)malloc(sizeof(RtInt) * argc2);
  6620.   if (!nVertices)
  6621.   {  sprintf(errBuf, "RiGeneralPolygon : unable to malloc memory for nVertices");
  6622.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  6623.      return TCL_ERROR;
  6624.   }
  6625.   for (i = 0; i < argc2; i++)
  6626.   {  nVertices[i] = (RtInt)atoi(argv2[i]);
  6627.   }
  6628.   free(argv2);
  6629.  
  6630.   n = 0;
  6631.   if (argc > num_args)
  6632.   {  n = (argc - num_args) / 2;
  6633.      if (!buildParameterList(me, interp, n, &tokens, &parms, &archiveVector, &nVector, &typeVector, num_args, argv))
  6634.      {  return TCL_ERROR;
  6635.      }
  6636.   }
  6637.  
  6638.   // RiGeneralPolygonV((RtInt)argc2, nVertices, n, tokens, parms);
  6639.   // free(nVertices);
  6640.  
  6641.   newRIBCommand = [[RIBGeneralPolygon alloc] init];
  6642.   [newRIBCommand setNLoops:(RtInt)argc2 nVertices:nVertices n:n tokens:tokens parms:parms archiveVector:archiveVector printfTypeVector:typeVector printfNVector:nVector];
  6643.   [newRIBCommand setMyShape:[me currentShape]];
  6644.   if ([me evaluatingEveCommand])
  6645.   {  [me setTmpRIBCommand:newRIBCommand];
  6646.   }
  6647.   else
  6648.   {  [[me currentShape] appendRIBCommand:newRIBCommand];
  6649.   }
  6650.  
  6651.   return TCL_OK;
  6652. }
  6653.  
  6654.  
  6655. static int
  6656. cmd_RiPointsPolygons(me, interp, argc, argv)
  6657. WWEveParser    *me;
  6658. Tcl_Interp     *interp;
  6659. int            argc;
  6660. char           **argv;
  6661. {
  6662.   char       *my_args = "nVertices vertices [parameterlist]", 
  6663.              **argv2;
  6664.   int         num_args = 3, n, i, argc2, sum;
  6665.   RtToken    *tokens = (RtToken *)RI_NULL;
  6666.   RtPointer  *parms = (RtPointer *)RI_NULL;
  6667.     int      *nVector = NULL, 
  6668.              *typeVector = NULL;
  6669.   char       **archiveVector = NULL;
  6670.   RtInt      nPolys, *nVertices, *vertices;
  6671.   id         newRIBCommand;
  6672.  
  6673.  
  6674.   sprintf(errBuf, "evaluating %s...", argv[0]);
  6675.   [[me statusText] setStringValue:errBuf]; [[me statusText] display]; NXPing();
  6676.   if (![me riBegun])
  6677.   {  sprintf(errBuf, "You must call RiBegin before making any RIB calls");
  6678.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  6679.      return TCL_ERROR;
  6680.   }
  6681.  
  6682.   if (argc < num_args)
  6683.   {  sprintf(errBuf, "USAGE: %s %s", argv[0], my_args);
  6684.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  6685.      return TCL_ERROR;
  6686.   }
  6687.  
  6688.   if ((argc+1) % 2)
  6689.   {  sprintf(errBuf, "RiPointsPolygons : parameter list must be in groups of two : USAGE: %s %s", 
  6690.          argv[0], my_args);
  6691.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  6692.      return TCL_ERROR;
  6693.   }
  6694.  
  6695.   /* do nVertices.  should be nPolys long */
  6696.   if (Tcl_SplitList(interp, argv[1], &argc2, &argv2) != TCL_OK)
  6697.   {  sprintf(errBuf, "%s : problem splitting <%s> as a list", argv[0], argv[1]);
  6698.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  6699.      return TCL_ERROR;
  6700.   }
  6701.   nPolys = argc2;
  6702.   nVertices = (RtInt *)malloc(sizeof(RtInt) * nPolys);
  6703.   if (!nVertices)
  6704.   {  sprintf(errBuf, "RiPointsPolygons : unable to malloc memory for nVertices");
  6705.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  6706.      return TCL_ERROR;
  6707.   }
  6708.   sum = 0;
  6709.   for (i = 0; i < nPolys; i++)
  6710.   {  nVertices[i] = (RtInt)atoi(argv2[i]);
  6711.      sum += nVertices[i];
  6712.   }
  6713.   free(argv2);
  6714.  
  6715.   /* do vertices.  should be nPolys long */
  6716.   if (Tcl_SplitList(interp, argv[2], &argc2, &argv2) != TCL_OK)
  6717.   {  sprintf(errBuf, "%s : problem splitting <%s> as a list", argv[0], argv[2]);
  6718.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  6719.      return TCL_ERROR;
  6720.   }
  6721.   if (argc2 != sum)
  6722.   {  sprintf(errBuf, 
  6723.          "RiPointsPolygons : the length of vertices must equal to the sum of all the values in the nVertices array :USAGE: %s %s", 
  6724.          argv[0], my_args);
  6725.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  6726.      return TCL_ERROR;
  6727.   }
  6728.  
  6729.   vertices = (RtInt *)malloc(sizeof(RtInt) * argc2);
  6730.   if (!vertices)
  6731.   {  sprintf(errBuf, "RiPointsPolygons : unable to malloc memory for vertices");
  6732.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  6733.      return TCL_ERROR;
  6734.   }
  6735.   for (i = 0; i < argc2; i++)
  6736.   {  vertices[i] = (RtInt)atoi(argv2[i]);
  6737.   }
  6738.   free(argv2);
  6739.  
  6740.   n = 0;
  6741.   if (argc > num_args)
  6742.   {  n = (argc - num_args) / 2;
  6743.      if (!buildParameterList(me, interp, n, &tokens, &parms, &archiveVector, &nVector, &typeVector, num_args, argv))
  6744.      {  return TCL_ERROR;
  6745.      }
  6746.   }
  6747.  
  6748.   // RiPointsPolygonsV(nPolys, nVertices, vertices, n, tokens, parms);
  6749.   // free(nVertices);
  6750.   // free(vertices);
  6751.  
  6752.   newRIBCommand = [[RIBPointsPolygons alloc] init];
  6753.   [newRIBCommand setNPolys:nPolys nVertices:nVertices vertices:vertices n:n tokens:tokens parms:parms archiveVector:archiveVector printfTypeVector:typeVector printfNVector:nVector];
  6754.   [newRIBCommand setMyShape:[me currentShape]];
  6755.   if ([me evaluatingEveCommand])
  6756.   {  [me setTmpRIBCommand:newRIBCommand];
  6757.   }
  6758.   else
  6759.   {  [[me currentShape] appendRIBCommand:newRIBCommand];
  6760.   }
  6761.  
  6762.   return TCL_OK;
  6763. }
  6764.  
  6765.  
  6766. static int
  6767. cmd_RiPointsGeneralPolygons(me, interp, argc, argv)
  6768. WWEveParser    *me;
  6769. Tcl_Interp     *interp;
  6770. int            argc;
  6771. char           **argv;
  6772. {
  6773.   char       *my_args = "nLoops nVertices vertices [parameterlist]", 
  6774.              **argv2;
  6775.   int         num_args = 4, n, i, argc2, sum, sum2;
  6776.   RtToken    *tokens = (RtToken *)RI_NULL;
  6777.   RtPointer  *parms = (RtPointer *)RI_NULL;
  6778.   int        *nVector = NULL, 
  6779.              *typeVector = NULL;
  6780.   char       **archiveVector = NULL;
  6781.   RtInt      nPolys, *nLoops, *nVertices, *vertices;
  6782.   id         newRIBCommand;
  6783.  
  6784.  
  6785.   sprintf(errBuf, "evaluating %s...", argv[0]);
  6786.   [[me statusText] setStringValue:errBuf]; [[me statusText] display]; NXPing();
  6787.   if (![me riBegun])
  6788.   {  sprintf(errBuf, "You must call RiBegin before making any RIB calls");
  6789.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  6790.      return TCL_ERROR;
  6791.   }
  6792.  
  6793.   if (argc < num_args)
  6794.   {  sprintf(errBuf, "USAGE: %s %s", argv[0], my_args);
  6795.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  6796.      return TCL_ERROR;
  6797.   }
  6798.  
  6799.   if (argc % 2)
  6800.   {  sprintf(errBuf, 
  6801.          "parameter list must be in groups of two : USAGE: %s %s", 
  6802.          argv[0], my_args);
  6803.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  6804.      return TCL_ERROR;
  6805.   }
  6806.  
  6807.   /* do nLoops.  should be nPolys long */
  6808.   if (Tcl_SplitList(interp, argv[1], &argc2, &argv2) != TCL_OK)
  6809.   {  sprintf(errBuf, "%s : problem splitting <%s> as a list", argv[0], argv[1]);
  6810.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  6811.      return TCL_ERROR;
  6812.   }
  6813.   nPolys = argc2;
  6814.   nLoops = (RtInt *)malloc(sizeof(RtInt) * nPolys);
  6815.   if (!nLoops)
  6816.   {  sprintf(errBuf, "RiPointsGeneralPolygons : unable to malloc memory for nLoops");
  6817.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  6818.      return TCL_ERROR;
  6819.   }
  6820.   sum = 0;
  6821.   for (i = 0; i < nPolys; i++)
  6822.   {  nLoops[i] = (RtInt)atoi(argv2[i]);
  6823.      sum += nLoops[i];
  6824.   }
  6825.   free(argv2);
  6826.  
  6827.   /* do nVertices.  should be sum long */
  6828.   if (Tcl_SplitList(interp, argv[2], &argc2, &argv2) != TCL_OK)
  6829.   {  sprintf(errBuf, "%s : problem splitting <%s> as a list", argv[0], argv[2]);
  6830.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  6831.      return TCL_ERROR;
  6832.   }
  6833.   if (argc2 != sum)
  6834.   {  sprintf(errBuf, 
  6835.          "the length of nVertices must equal to the sum of all the values in the nLoops array :USAGE: %s %s", 
  6836.          argv[0], my_args);
  6837.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  6838.      return TCL_ERROR;
  6839.   }
  6840.   nVertices = (RtInt *)malloc(sizeof(RtInt) * sum);
  6841.   if (!nVertices)
  6842.   {  sprintf(errBuf, "RiPointsGeneralPolygons : unable to malloc memory for nVertices");
  6843.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  6844.      return TCL_ERROR;
  6845.   }
  6846.   sum2 = 0;
  6847.   for (i = 0; i < sum; i++)
  6848.   {  nVertices[i] = (RtInt)atoi(argv2[i]);
  6849.      sum2 += nVertices[i];
  6850.   }
  6851.   free(argv2);
  6852.  
  6853.   /* do vertices.  should be sum2 long */
  6854.   if (Tcl_SplitList(interp, argv[3], &argc2, &argv2) != TCL_OK)
  6855.   {  sprintf(errBuf, "%s : problem splitting <%s> as a list", argv[0], argv[3]);
  6856.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  6857.      return TCL_ERROR;
  6858.   }
  6859.   if (argc2 != sum2)
  6860.   {  sprintf(errBuf, 
  6861.          "the length of vertices must equal to the sum of all the values in the nVertices array :USAGE: %s %s", 
  6862.          argv[0], my_args);
  6863.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  6864.      return TCL_ERROR;
  6865.   }
  6866.  
  6867.   vertices = (RtInt *)malloc(sizeof(RtInt) * argc2);
  6868.   if (!vertices)
  6869.   {  sprintf(errBuf, "RiPointsGeneralPolygons : unable to malloc memory for vertices");
  6870.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  6871.      return TCL_ERROR;
  6872.   }
  6873.   for (i = 0; i < argc2; i++)
  6874.   {  vertices[i] = (RtInt)atoi(argv2[i]);
  6875.   }
  6876.   free(argv2);
  6877.  
  6878.   n = 0;
  6879.   if (argc > num_args)
  6880.   {  n = (argc - num_args) / 2;
  6881.      if (!buildParameterList(me, interp, n, &tokens, &parms, &archiveVector, &nVector, &typeVector, num_args, argv))
  6882.      {  return TCL_ERROR;
  6883.      }
  6884.   }
  6885.  
  6886.   // RiPointsGeneralPolygonsV(nPolys, nLoops, nVertices, vertices, n, tokens, parms);
  6887.   // free(nLoops);
  6888.   // free(nVertices);
  6889.   // free(vertices);
  6890.  
  6891.   newRIBCommand = [[RIBPointsGeneralPolygons alloc] init];
  6892.   [newRIBCommand setNPolys:nPolys nLoops:nLoops nVertices:nVertices vertices:vertices n:n tokens:tokens parms:parms archiveVector:archiveVector printfTypeVector:typeVector printfNVector:nVector];
  6893.   [newRIBCommand setMyShape:[me currentShape]];
  6894.   if ([me evaluatingEveCommand])
  6895.   {  [me setTmpRIBCommand:newRIBCommand];
  6896.   }
  6897.   else
  6898.   {  [[me currentShape] appendRIBCommand:newRIBCommand];
  6899.   }
  6900.  
  6901.   return TCL_OK;
  6902. }
  6903.  
  6904.  
  6905. static int
  6906. cmd_RiPatch(me, interp, argc, argv)
  6907. WWEveParser    *me;
  6908. Tcl_Interp     *interp;
  6909. int            argc;
  6910. char           **argv;
  6911. {
  6912.   char  *my_args = "bicubic|bilinear [parameterlist]";
  6913.   int    num_args = 2, n;
  6914.   RtToken    *tokens = (RtToken *)RI_NULL;
  6915.   RtPointer  *parms = (RtPointer *)RI_NULL;
  6916.   int        *nVector = NULL, 
  6917.              *typeVector = NULL;
  6918.   char       **archiveVector = NULL;
  6919.   id         newRIBCommand;
  6920.  
  6921.  
  6922.   sprintf(errBuf, "evaluating %s...", argv[0]);
  6923.   [[me statusText] setStringValue:errBuf]; [[me statusText] display]; NXPing();
  6924.   if (![me riBegun])
  6925.   {  sprintf(errBuf, "You must call RiBegin before making any RIB calls");
  6926.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  6927.      return TCL_ERROR;
  6928.   }
  6929.  
  6930.   if (argc < num_args)
  6931.   {  sprintf(errBuf, "USAGE: %s %s", argv[0], my_args);
  6932.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  6933.      return TCL_ERROR;
  6934.   }
  6935.  
  6936.   if ((strcmp("bicubic", argv[1])) && (strcmp("bilinear", argv[1])))
  6937.   {  sprintf(errBuf, "USAGE: %s %s", argv[0], my_args);
  6938.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  6939.      return TCL_ERROR;
  6940.   }
  6941.  
  6942.   if (argc % 2)
  6943.   {  sprintf(errBuf, "RiPatch : parameter list must be in groups of two, i.e. the number of args is an even number");
  6944.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  6945.      return TCL_ERROR;
  6946.   }
  6947.  
  6948.   n = 0;
  6949.   if (argc > num_args)
  6950.   {  n = (argc - num_args) / 2;
  6951.      if (!buildParameterList(me, interp, n, &tokens, &parms, &archiveVector, &nVector, &typeVector, num_args, argv))
  6952.      {  return TCL_ERROR;
  6953.      }
  6954.   }
  6955.  
  6956.   // RiPatchV(argv[1], n, tokens, parms);
  6957.  
  6958.   newRIBCommand = [[RIBPatch alloc] init];
  6959.   [newRIBCommand setType:argv[1] n:n tokens:tokens parms:parms archiveVector:archiveVector printfTypeVector:typeVector printfNVector:nVector];
  6960.   [newRIBCommand setMyShape:[me currentShape]];
  6961.   if ([me evaluatingEveCommand])
  6962.   {  [me setTmpRIBCommand:newRIBCommand];
  6963.   }
  6964.   else
  6965.   {  [[me currentShape] appendRIBCommand:newRIBCommand];
  6966.   }
  6967.  
  6968.   return TCL_OK;
  6969. }
  6970.  
  6971.  
  6972. static int
  6973. cmd_RiPatchMesh(me, interp, argc, argv)
  6974. WWEveParser    *me;
  6975. Tcl_Interp     *interp;
  6976. int            argc;
  6977. char           **argv;
  6978. {
  6979.   char  *my_args = "type nU uWrap nV vWrap [parameterlist]";
  6980.   int    num_args = 6, n;
  6981.   RtToken    *tokens = (RtToken *)RI_NULL;
  6982.   RtPointer  *parms = (RtPointer *)RI_NULL;
  6983.   int        *nVector = NULL, 
  6984.              *typeVector = NULL;
  6985.   char       **archiveVector = NULL;
  6986.   id         newRIBCommand;
  6987.   RtToken    uWrap, vWrap;
  6988.  
  6989.  
  6990.   sprintf(errBuf, "evaluating %s...", argv[0]);
  6991.   [[me statusText] setStringValue:errBuf]; [[me statusText] display]; NXPing();
  6992.   if (![me riBegun])
  6993.   {  sprintf(errBuf, "You must call RiBegin before making any RIB calls");
  6994.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  6995.      return TCL_ERROR;
  6996.   }
  6997.  
  6998.   if (argc < num_args)
  6999.   {  sprintf(errBuf, "USAGE: %s %s", argv[0], my_args);
  7000.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  7001.      return TCL_ERROR;
  7002.   }
  7003.  
  7004.   if (argc % 2)
  7005.   {  sprintf(errBuf, "RiPatchMesh : parameter list must be in groups of two, i.e. the number of args is an even number");
  7006.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  7007.      return TCL_ERROR;
  7008.   }
  7009.  
  7010.   uWrap = argv[3];
  7011.   if (!strcmp(uWrap, "wrap"))
  7012.   {  NXLogError("warning: <wrap> is an undocumented token; substituting <periodic> for uWrap");
  7013.      uWrap = RI_PERIODIC;
  7014.   }
  7015.   else
  7016.   {  if (!strcmp(uWrap, "nowrap"))
  7017.      {  NXLogError("warning: <nowrap> is an undocumented token; substituting <nonperiodic> for uWrap");
  7018.         uWrap = RI_NONPERIODIC;
  7019.      }
  7020.   }
  7021.   vWrap = argv[5];
  7022.   if (!strcmp(vWrap, "wrap"))
  7023.   {  NXLogError("warning: <wrap> is an undocumented token; substituting <periodic> for vWrap");
  7024.      vWrap = RI_PERIODIC;
  7025.   }
  7026.   else
  7027.   {  if (!strcmp(vWrap, "nowrap"))
  7028.      {  NXLogError("warning: <nowrap> is an undocumented token; substituting <nonperiodic> for vWrap");
  7029.         vWrap = RI_NONPERIODIC;
  7030.      }
  7031.   }
  7032.  
  7033.   if (strcmp(uWrap, "periodic")  && strcmp(uWrap, "nonperiodic"))
  7034.   {  sprintf(errBuf, "RiPatchMesh : uWrap must be either periodic or nonperiodic, not <%s>", uWrap);
  7035.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  7036.      return TCL_ERROR;
  7037.   }
  7038.   if (strcmp(vWrap, "periodic")  && strcmp(vWrap, "nonperiodic"))
  7039.   {  sprintf(errBuf, "RiPatchMesh : vWrap must be either periodic or nonperiodic, not <%s>", vWrap);
  7040.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  7041.      return TCL_ERROR;
  7042.   }
  7043.  
  7044.   n = 0;
  7045.   if (argc > num_args)
  7046.   {  n = (argc - num_args) / 2;
  7047.      if (!buildParameterList(me, interp, n, &tokens, &parms, &archiveVector, &nVector, &typeVector, num_args, argv))
  7048.      {  return TCL_ERROR;
  7049.      }
  7050.   }
  7051.  
  7052.   // RiPatchMeshV((RtToken)argv[1], (RtInt)atoi(argv[2]), (RtToken)argv[3], (RtInt)atoi(argv[4]), (RtToken)argv[5], n, tokens, parms);
  7053.  
  7054.   newRIBCommand = [[RIBPatchMesh alloc] init];
  7055.   [newRIBCommand setType:(RtToken)argv[1] 
  7056.                     nU:(RtInt)atoi(argv[2]) uWrap:uWrap
  7057.                     nV:(RtInt)atoi(argv[4]) vWrap:vWrap n:n tokens:tokens parms:parms archiveVector:archiveVector printfTypeVector:typeVector printfNVector:nVector];
  7058.   [newRIBCommand setMyShape:[me currentShape]];
  7059.   if ([me evaluatingEveCommand])
  7060.   {  [me setTmpRIBCommand:newRIBCommand];
  7061.   }
  7062.   else
  7063.   {  [[me currentShape] appendRIBCommand:newRIBCommand];
  7064.   }
  7065.  
  7066.   return TCL_OK;
  7067. }
  7068.  
  7069.  
  7070. static int
  7071. cmd_RiNuPatch(me, interp, argc, argv)
  7072. WWEveParser    *me;
  7073. Tcl_Interp     *interp;
  7074. int            argc;
  7075. char           **argv;
  7076. {
  7077.   char  *my_args = "nU uOrder uKnot uMin uMax nV vOrder vKnot vMin vMax [parameterlist]", **argv2;
  7078.   int    num_args = 11, n, i, argc2;
  7079.   RtToken    *tokens = (RtToken *)RI_NULL;
  7080.   RtPointer  *parms = (RtPointer *)RI_NULL;
  7081.   int        *nVector = NULL, 
  7082.              *typeVector = NULL;
  7083.   char       **archiveVector = NULL;
  7084.   RtInt      nU, nV, uOrder, vOrder, uKnotLength, vKnotLength;
  7085.   RtFloat    *uKnot, *vKnot, uMin, uMax, vMin, vMax;
  7086.   id         newRIBCommand;
  7087.  
  7088.  
  7089.   sprintf(errBuf, "evaluating %s...", argv[0]);
  7090.   [[me statusText] setStringValue:errBuf]; [[me statusText] display]; NXPing();
  7091.   if (![me riBegun])
  7092.   {  sprintf(errBuf, "You must call RiBegin before making any RIB calls");
  7093.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  7094.      return TCL_ERROR;
  7095.   }
  7096.  
  7097.   if (argc < num_args)
  7098.   {  sprintf(errBuf, "USAGE: %s %s", argv[0], my_args);
  7099.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  7100.      return TCL_ERROR;
  7101.   }
  7102.  
  7103.   if ((argc+1) % 2)
  7104.   {  sprintf(errBuf, "RiNuPatch : parameter list must be in groups of two, i.e. the number of args is an even number");
  7105.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  7106.      return TCL_ERROR;
  7107.   }
  7108.  
  7109.   nU = (RtInt)atoi(argv[1]); 
  7110.   uOrder = (RtInt)atoi(argv[2]); 
  7111.   uMin = (RtFloat)atof(argv[4]); 
  7112.   uMax = (RtFloat)atof(argv[5]); 
  7113.   uKnotLength = nU + uOrder;
  7114.  
  7115.   nV = (RtInt)atoi(argv[6]); 
  7116.   vOrder = (RtInt)atoi(argv[7]); 
  7117.   vMin = (RtFloat)atof(argv[9]); 
  7118.   vMax = (RtFloat)atof(argv[10]); 
  7119.   vKnotLength = nV + vOrder;
  7120.  
  7121.   if (Tcl_SplitList(interp, argv[3], &argc2, &argv2) != TCL_OK)
  7122.   {  sprintf(errBuf, "%s : problem splitting <%s> as a list", argv[0], argv[3]);
  7123.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  7124.      return TCL_ERROR;
  7125.   }
  7126.   if (argc2 != uKnotLength)
  7127.   {  sprintf(errBuf, 
  7128.          "the length of the knots in u must equal to the sum of the order and n :USAGE: %s %s", 
  7129.          argv[0], my_args);
  7130.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  7131.      return TCL_ERROR;
  7132.   }
  7133.   uKnot = (RtFloat *)malloc(sizeof(RtFloat) * uKnotLength);
  7134.   if (!uKnot)
  7135.   {  sprintf(errBuf, "RiNuPatch : unable to malloc memory for uKnot");
  7136.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  7137.      return TCL_ERROR;
  7138.   }
  7139.   for (i = 0; i < uKnotLength; i++)
  7140.   {  uKnot[i] = (RtFloat)atof(argv2[i]);
  7141.   }
  7142.   free(argv2);
  7143.  
  7144.   if (Tcl_SplitList(interp, argv[8], &argc2, &argv2) != TCL_OK)
  7145.   {  sprintf(errBuf, "%s : problem splitting <%s> as a list", argv[0], argv[8]);
  7146.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  7147.      return TCL_ERROR;
  7148.   }
  7149.   if (argc2 != vKnotLength)
  7150.   {  sprintf(errBuf, 
  7151.          "the length of the knots in v must equal to the sum of the order and n :USAGE: %s %s", 
  7152.          argv[0], my_args);
  7153.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  7154.      return TCL_ERROR;
  7155.   }
  7156.   vKnot = (RtFloat *)malloc(sizeof(RtFloat) * vKnotLength);
  7157.   if (!vKnot)
  7158.   {  sprintf(errBuf, "RiNuPatch : unable to malloc memory for vKnot");
  7159.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  7160.      return TCL_ERROR;
  7161.   }
  7162.   for (i = 0; i < vKnotLength; i++)
  7163.   {  vKnot[i] = (RtFloat)atof(argv2[i]);
  7164.   }
  7165.   free(argv2);
  7166.  
  7167.   n = 0;
  7168.   if (argc > num_args)
  7169.   {  n = (argc - num_args) / 2;
  7170.      if (!buildParameterList(me, interp, n, &tokens, &parms, &archiveVector, &nVector, &typeVector, num_args, argv))
  7171.      {  return TCL_ERROR;
  7172.      }
  7173.   }
  7174.  
  7175.   // RiNuPatchV(nU, uOrder, uKnot, uMin, uMax, nV, vOrder, vKnot, vMin, vMax, n, tokens, parms);
  7176.  
  7177.   newRIBCommand = [[RIBNuPatch alloc] init];
  7178.   [newRIBCommand setNU:nU uOrder:uOrder uKnot:uKnot uMin:uMin uMax:uMax 
  7179.                     nV:nV vOrder:vOrder vKnot:vKnot vMin:vMin vMax:vMax n:n tokens:tokens parms:parms archiveVector:archiveVector printfTypeVector:typeVector printfNVector:nVector];
  7180.   [newRIBCommand setMyShape:[me currentShape]];
  7181.   if ([me evaluatingEveCommand])
  7182.   {  [me setTmpRIBCommand:newRIBCommand];
  7183.   }
  7184.   else
  7185.   {  [[me currentShape] appendRIBCommand:newRIBCommand];
  7186.   }
  7187.  
  7188.   return TCL_OK;
  7189. }
  7190.  
  7191.  
  7192. static int
  7193. cmd_RiTrimCurve(me, interp, argc, argv)
  7194. WWEveParser    *me;
  7195. Tcl_Interp     *interp;
  7196. int            argc;
  7197. char           **argv;
  7198. {
  7199.   char  *my_args = "nCurves order knot min max n u v w", **argv2;
  7200.   int    num_args = 10, i,  nLoopsI,
  7201.         orderLength, nLength, knotLength, minLength, maxLength, uLength, vLength, wLength;
  7202.   RtInt      nLoops, *nCurves, *order, *n;
  7203.   RtFloat    *knot, *min, *max, *u, *v, *w;
  7204.   id         newRIBCommand;
  7205.  
  7206.  
  7207.   sprintf(errBuf, "evaluating %s...", argv[0]);
  7208.   [[me statusText] setStringValue:errBuf]; [[me statusText] display]; NXPing();
  7209.   if (![me riBegun])
  7210.   {  sprintf(errBuf, "You must call RiBegin before making any RIB calls");
  7211.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  7212.      return TCL_ERROR;
  7213.   }
  7214.  
  7215.   if (argc < num_args)
  7216.   {  sprintf(errBuf, "USAGE: %s %s", argv[0], my_args);
  7217.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  7218.      return TCL_ERROR;
  7219.   }
  7220.  
  7221.   if (argc % 2)
  7222.   {  sprintf(errBuf, "RiTrimCurve : parameter list must be in groups of two, i.e. the number of args is an even number");
  7223.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  7224.      return TCL_ERROR;
  7225.   }
  7226.  
  7227.   /* get nLoops and nCurves[] */
  7228.   if (Tcl_SplitList(interp, argv[1], &nLoopsI, &argv2) != TCL_OK)
  7229.   {  sprintf(errBuf, "%s : problem splitting <%s> as a list", argv[0], argv[1]);
  7230.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  7231.      return TCL_ERROR;
  7232.   }
  7233.   nLoops = (RtInt)nLoopsI;
  7234.   nCurves = (RtInt *)malloc(sizeof(RtInt) * nLoops);
  7235.   if (!nCurves)
  7236.   {  sprintf(errBuf, "RiTrimCurve : unable to malloc memory for nCurves");
  7237.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  7238.      return TCL_ERROR;
  7239.   }
  7240.   for (i = 0; i < nLoops; i++)
  7241.   {  nCurves[i] = (RtInt)atoi(argv2[i]);
  7242.   }
  7243.   free(argv2);
  7244.  
  7245.   /* get order[]  */
  7246.   if (Tcl_SplitList(interp, argv[2], &orderLength, &argv2) != TCL_OK)
  7247.   {  sprintf(errBuf, "%s : problem splitting <%s> as a list", argv[0], argv[2]);
  7248.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  7249.      return TCL_ERROR;
  7250.   }
  7251.   order = (RtInt *)malloc(sizeof(RtInt) * orderLength);
  7252.   if (!order)
  7253.   {  sprintf(errBuf, "RiTrimCurve : unable to malloc memory for order");
  7254.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  7255.      return TCL_ERROR;
  7256.   }
  7257.   for (i = 0; i < orderLength; i++)
  7258.   {  order[i] = (RtInt)atoi(argv2[i]);
  7259.   }
  7260.   free(argv2);
  7261.  
  7262.   /* get knot[]  */
  7263.   if (Tcl_SplitList(interp, argv[3], &knotLength, &argv2) != TCL_OK)
  7264.   {  sprintf(errBuf, "%s : problem splitting <%s> as a list", argv[0], argv[3]);
  7265.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  7266.      return TCL_ERROR;
  7267.   }
  7268.   knot = (RtFloat *)malloc(sizeof(RtFloat) * knotLength);
  7269.   if (!knot)
  7270.   {  sprintf(errBuf, "RiTrimCurve : unable to malloc memory for knot");
  7271.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  7272.      return TCL_ERROR;
  7273.   }
  7274.   for (i = 0; i < knotLength; i++)
  7275.   {  knot[i] = (RtFloat)atof(argv2[i]);
  7276.   }
  7277.   free(argv2);
  7278.  
  7279.   /* get min[]  */
  7280.   if (Tcl_SplitList(interp, argv[4], &minLength, &argv2) != TCL_OK)
  7281.   {  sprintf(errBuf, "%s : problem splitting <%s> as a list", argv[0], argv[4]);
  7282.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  7283.      return TCL_ERROR;
  7284.   }
  7285.   min = (RtFloat *)malloc(sizeof(RtFloat) * minLength);
  7286.   if (!min)
  7287.   {  sprintf(errBuf, "RiTrimCurve : unable to malloc memory for min");
  7288.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  7289.      return TCL_ERROR;
  7290.   }
  7291.   for (i = 0; i < minLength; i++)
  7292.   {  min[i] = (RtFloat)atof(argv2[i]);
  7293.   }
  7294.   free(argv2);
  7295.  
  7296.   /* get max[]  */
  7297.   if (Tcl_SplitList(interp, argv[5], &maxLength, &argv2) != TCL_OK)
  7298.   {  sprintf(errBuf, "%s : problem splitting <%s> as a list", argv[0], argv[5]);
  7299.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  7300.      return TCL_ERROR;
  7301.   }
  7302.   max = (RtFloat *)malloc(sizeof(RtFloat) * maxLength);
  7303.   if (!max)
  7304.   {  sprintf(errBuf, "RiTrimCurve : unable to malloc memory for max");
  7305.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  7306.      return TCL_ERROR;
  7307.   }
  7308.   for (i = 0; i < maxLength; i++)
  7309.   {  max[i] = (RtFloat)atof(argv2[i]);
  7310.   }
  7311.   free(argv2);
  7312.  
  7313.   /* get n[]  */
  7314.   if (Tcl_SplitList(interp, argv[6], &nLength, &argv2) != TCL_OK)
  7315.   {  sprintf(errBuf, "%s : problem splitting <%s> as a list", argv[0], argv[6]);
  7316.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  7317.      return TCL_ERROR;
  7318.   }
  7319.   n = (RtInt *)malloc(sizeof(RtInt) * nLength);
  7320.   if (!n)
  7321.   {  sprintf(errBuf, "RiTrimCurve : unable to malloc memory for n");
  7322.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  7323.      return TCL_ERROR;
  7324.   }
  7325.   for (i = 0; i < nLength; i++)
  7326.   {  n[i] = (RtInt)atoi(argv2[i]);
  7327.   }
  7328.   free(argv2);
  7329.  
  7330.   /* get u[]  */
  7331.   if (Tcl_SplitList(interp, argv[7], &uLength, &argv2) != TCL_OK)
  7332.   {  sprintf(errBuf, "%s : problem splitting <%s> as a list", argv[0], argv[7]);
  7333.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  7334.      return TCL_ERROR;
  7335.   }
  7336.   u = (RtFloat *)malloc(sizeof(RtFloat) * uLength);
  7337.   if (!u)
  7338.   {  sprintf(errBuf, "RiTrimCurve : unable to malloc memory for u");
  7339.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  7340.      return TCL_ERROR;
  7341.   }
  7342.   for (i = 0; i < uLength; i++)
  7343.   {  u[i] = (RtFloat)atof(argv2[i]);
  7344.   }
  7345.   free(argv2);
  7346.  
  7347.   /* get v[]  */
  7348.   if (Tcl_SplitList(interp, argv[8], &vLength, &argv2) != TCL_OK)
  7349.   {  sprintf(errBuf, "%s : problem splitting <%s> as a list", argv[0], argv[8]);
  7350.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  7351.      return TCL_ERROR;
  7352.   }
  7353.   v = (RtFloat *)malloc(sizeof(RtFloat) * vLength);
  7354.   if (!v)
  7355.   {  sprintf(errBuf, "RiTrimCurve : unable to malloc memory for v");
  7356.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  7357.      return TCL_ERROR;
  7358.   }
  7359.   for (i = 0; i < vLength; i++)
  7360.   {  v[i] = (RtFloat)atof(argv2[i]);
  7361.   }
  7362.   free(argv2);
  7363.  
  7364.   /* get w[]  */
  7365.   if (Tcl_SplitList(interp, argv[9], &wLength, &argv2) != TCL_OK)
  7366.   {  sprintf(errBuf, "%s : problem splitting <%s> as a list", argv[0], argv[9]);
  7367.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  7368.      return TCL_ERROR;
  7369.   }
  7370.   w = (RtFloat *)malloc(sizeof(RtFloat) * wLength);
  7371.   if (!w)
  7372.   {  sprintf(errBuf, "RiTrimCurve : unable to malloc memory for w");
  7373.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  7374.      return TCL_ERROR;
  7375.   }
  7376.   for (i = 0; i < wLength; i++)
  7377.   {  w[i] = (RtFloat)atof(argv2[i]);
  7378.   }
  7379.   free(argv2);
  7380.  
  7381.  
  7382.   // RiTrimCurve(nLoops, nCurves, order, knot, min, max, n, u, v, w);
  7383.   // free(nCurves);
  7384.   // free(order);
  7385.   // free(knot);
  7386.   // free(min);
  7387.   // free(max);
  7388.   // free(n);
  7389.   // free(u);
  7390.   // free(v);
  7391.   // free(w);
  7392.  
  7393.   newRIBCommand = [[RIBTrimCurve alloc] init];
  7394.   [newRIBCommand setNLoops:nLoops nCurves:nCurves 
  7395.                     order:order len:orderLength
  7396.                     knot:knot len:knotLength 
  7397.                     min:min len:minLength 
  7398.                     max:max len:maxLength 
  7399.                     n2:n len:nLength 
  7400.                     u:u len:uLength 
  7401.                     v:v len:vLength 
  7402.                     w:w len:wLength];
  7403.   [newRIBCommand setMyShape:[me currentShape]];
  7404.   if ([me evaluatingEveCommand])
  7405.   {  [me setTmpRIBCommand:newRIBCommand];
  7406.   }
  7407.   else
  7408.   {  [[me currentShape] appendRIBCommand:newRIBCommand];
  7409.   }
  7410.  
  7411.   return TCL_OK;
  7412. }
  7413.  
  7414.  
  7415. static int
  7416. cmd_RiSphere(me, interp, argc, argv)
  7417. WWEveParser    *me;
  7418. Tcl_Interp     *interp;
  7419. int            argc;
  7420. char           **argv;
  7421. {
  7422.   char  *my_args = "radius zMin zMax thetaMax [parameterlist]";
  7423.   int    num_args = 5, n;
  7424.   RtToken    *tokens = (RtToken *)RI_NULL;
  7425.   RtPointer  *parms = (RtPointer *)RI_NULL;
  7426.   int        *nVector = NULL, 
  7427.              *typeVector = NULL;
  7428.   char       **archiveVector = NULL;
  7429.   id         newRIBCommand;
  7430.  
  7431.  
  7432.   sprintf(errBuf, "evaluating %s...", argv[0]);
  7433.   [[me statusText] setStringValue:errBuf]; [[me statusText] display]; NXPing();
  7434.   if (![me riBegun])
  7435.   {  sprintf(errBuf, "You must call RiBegin before making any RIB calls");
  7436.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  7437.      return TCL_ERROR;
  7438.   }
  7439.  
  7440.   if (argc < num_args)
  7441.   {  sprintf(errBuf, "USAGE: %s %s", argv[0], my_args);
  7442.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  7443.      return TCL_ERROR;
  7444.   }
  7445.  
  7446.   if ((argc+1) % 2)
  7447.   {  sprintf(errBuf, "RiSphere : parameter list must be in groups of two, i.e. the number of args is an even number");
  7448.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  7449.      return TCL_ERROR;
  7450.   }
  7451.  
  7452.   n = 0;
  7453.   if (argc > num_args)
  7454.   {  n = (argc - num_args) / 2;
  7455.      if (!buildParameterList(me, interp, n, &tokens, &parms, &archiveVector, &nVector, &typeVector, num_args, argv))
  7456.      {  return TCL_ERROR;
  7457.      }
  7458.   }
  7459.  
  7460.   // RiSphereV((RtFloat)atof(argv[1]), (RtFloat)atof(argv[2]), (RtFloat)atof(argv[3]), (RtFloat)atof(argv[4]), n, tokens, parms);
  7461.  
  7462.   newRIBCommand = [[RIBSphere alloc] init];
  7463.   [newRIBCommand setRadius:(RtFloat)atof(argv[1]) zMin:(RtFloat)atof(argv[2]) zMax:(RtFloat)atof(argv[3]) thetaMax:(RtFloat)atof(argv[4])
  7464.                     n:n tokens:tokens parms:parms archiveVector:archiveVector printfTypeVector:typeVector printfNVector:nVector];
  7465.   [newRIBCommand setMyShape:[me currentShape]];
  7466.   if ([me evaluatingEveCommand])
  7467.   {  [me setTmpRIBCommand:newRIBCommand];
  7468.   }
  7469.   else
  7470.   {  [[me currentShape] appendRIBCommand:newRIBCommand];
  7471.   }
  7472.  
  7473.   return TCL_OK;
  7474. }
  7475.  
  7476.  
  7477.  
  7478. static int
  7479. cmd_RiCone(me, interp, argc, argv)
  7480. WWEveParser    *me;
  7481. Tcl_Interp     *interp;
  7482. int            argc;
  7483. char           **argv;
  7484. {
  7485.   char  *my_args = "height radius thetaMax [parameterlist]";
  7486.   int    num_args = 4, n;
  7487.   RtToken    *tokens = (RtToken *)RI_NULL;
  7488.   RtPointer  *parms = (RtPointer *)RI_NULL;
  7489.   int        *nVector = NULL, 
  7490.              *typeVector = NULL;
  7491.   char       **archiveVector = NULL;
  7492.   id         newRIBCommand;
  7493.  
  7494.  
  7495.   sprintf(errBuf, "evaluating %s...", argv[0]);
  7496.   [[me statusText] setStringValue:errBuf]; [[me statusText] display]; NXPing();
  7497.   if (![me riBegun])
  7498.   {  sprintf(errBuf, "You must call RiBegin before making any RIB calls");
  7499.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  7500.      return TCL_ERROR;
  7501.   }
  7502.  
  7503.   if (argc < num_args)
  7504.   {  sprintf(errBuf, "USAGE: %s %s", argv[0], my_args);
  7505.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  7506.      return TCL_ERROR;
  7507.   }
  7508.  
  7509.   if (argc % 2)
  7510.   {  sprintf(errBuf, "RiCone : parameter list must be in groups of two, i.e. the number of args is an even number");
  7511.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  7512.      return TCL_ERROR;
  7513.   }
  7514.  
  7515.   n = 0;
  7516.   if (argc > num_args)
  7517.   {  n = (argc - num_args) / 2;
  7518.      if (!buildParameterList(me, interp, n, &tokens, &parms, &archiveVector, &nVector, &typeVector, num_args, argv))
  7519.      {  return TCL_ERROR;
  7520.      }
  7521.   }
  7522.  
  7523.   // RiConeV((RtFloat)atof(argv[1]), (RtFloat)atof(argv[2]), (RtFloat)atof(argv[3]), n, tokens, parms);
  7524.  
  7525.   newRIBCommand = [[RIBCone alloc] init];
  7526.   [newRIBCommand setHeight:(RtFloat)atof(argv[1]) radius:(RtFloat)atof(argv[2]) thetaMax:(RtFloat)atof(argv[3])
  7527.                     n:n tokens:tokens parms:parms archiveVector:archiveVector printfTypeVector:typeVector printfNVector:nVector];
  7528.   [newRIBCommand setMyShape:[me currentShape]];
  7529.   if ([me evaluatingEveCommand])
  7530.   {  [me setTmpRIBCommand:newRIBCommand];
  7531.   }
  7532.   else
  7533.   {  [[me currentShape] appendRIBCommand:newRIBCommand];
  7534.   }
  7535.  
  7536.   return TCL_OK;
  7537. }
  7538.  
  7539.  
  7540.  
  7541. static int
  7542. cmd_RiCylinder(me, interp, argc, argv)
  7543. WWEveParser    *me;
  7544. Tcl_Interp     *interp;
  7545. int            argc;
  7546. char           **argv;
  7547. {
  7548.   char  *my_args = "radius zMin zMax thetaMax [parameterlist]";
  7549.   int    num_args = 5, n;
  7550.   RtToken    *tokens = (RtToken *)RI_NULL;
  7551.   RtPointer  *parms = (RtPointer *)RI_NULL;
  7552.   int        *nVector = NULL, 
  7553.              *typeVector = NULL;
  7554.   char       **archiveVector = NULL;
  7555.   id         newRIBCommand;
  7556.  
  7557.  
  7558.   sprintf(errBuf, "evaluating %s...", argv[0]);
  7559.   [[me statusText] setStringValue:errBuf]; [[me statusText] display]; NXPing();
  7560.   if (![me riBegun])
  7561.   {  sprintf(errBuf, "You must call RiBegin before making any RIB calls");
  7562.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  7563.      return TCL_ERROR;
  7564.   }
  7565.  
  7566.   if (argc < num_args)
  7567.   {  sprintf(errBuf, "USAGE: %s %s", argv[0], my_args);
  7568.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  7569.      return TCL_ERROR;
  7570.   }
  7571.  
  7572.   if ((argc+1) % 2)
  7573.   {  sprintf(errBuf, "RiCylinder : parameter list must be in groups of two, i.e. the number of args is an even number");
  7574.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  7575.      return TCL_ERROR;
  7576.   }
  7577.  
  7578.   n = 0;
  7579.   if (argc > num_args)
  7580.   {  n = (argc - num_args) / 2;
  7581.      if (!buildParameterList(me, interp, n, &tokens, &parms, &archiveVector, &nVector, &typeVector, num_args, argv))
  7582.      {  return TCL_ERROR;
  7583.      }
  7584.   }
  7585.  
  7586.   // RiCylinderV((RtFloat)atof(argv[1]), (RtFloat)atof(argv[2]), (RtFloat)atof(argv[3]), (RtFloat)atof(argv[4]), n, tokens, parms);
  7587.  
  7588.   newRIBCommand = [[RIBCylinder alloc] init];
  7589.   [newRIBCommand setRadius:(RtFloat)atof(argv[1]) zMin:(RtFloat)atof(argv[2]) zMax:(RtFloat)atof(argv[3]) thetaMax:(RtFloat)atof(argv[4])
  7590.                     n:n tokens:tokens parms:parms archiveVector:archiveVector printfTypeVector:typeVector printfNVector:nVector];
  7591.   [newRIBCommand setMyShape:[me currentShape]];
  7592.   if ([me evaluatingEveCommand])
  7593.   {  [me setTmpRIBCommand:newRIBCommand];
  7594.   }
  7595.   else
  7596.   {  [[me currentShape] appendRIBCommand:newRIBCommand];
  7597.   }
  7598.  
  7599.   return TCL_OK;
  7600. }
  7601.  
  7602.  
  7603.  
  7604. static int
  7605. cmd_RiHyperboloid(me, interp, argc, argv)
  7606. WWEveParser    *me;
  7607. Tcl_Interp     *interp;
  7608. int            argc;
  7609. char           **argv;
  7610. {
  7611.   char  *my_args = "x1 y1 z1 x2 y2 z2 thetaMax [parameterlist]"; // or "{x1 y1 z1} {x2 y2 z2} thetamax [parameterlist]"
  7612.   int    num_args = 8, n;
  7613.   RtToken    *tokens = (RtToken *)RI_NULL;
  7614.   RtPointer  *parms = (RtPointer *)RI_NULL;
  7615.   int        *nVector = NULL, 
  7616.              *typeVector = NULL;
  7617.   char       **archiveVector = NULL;
  7618.   RtPoint    point1, point2;
  7619.   id         newRIBCommand;
  7620.  
  7621.  
  7622.   sprintf(errBuf, "evaluating %s...", argv[0]);
  7623.   [[me statusText] setStringValue:errBuf]; [[me statusText] display]; NXPing();
  7624.   if (![me riBegun])
  7625.   {  sprintf(errBuf, "You must call RiBegin before making any RIB calls");
  7626.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  7627.      return TCL_ERROR;
  7628.   }
  7629.  
  7630.   if ((argc < 8) && ((argc != 4) || (argc != 6)))
  7631.   {  sprintf(errBuf, "USAGE: %s %s", argv[0], my_args);
  7632.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  7633.      return TCL_ERROR;
  7634.   }
  7635.  
  7636.   if (argc % 2)
  7637.   {  sprintf(errBuf, "RiHyperboloid : parameter list must be in groups of two, i.e. the number of args is an even number");
  7638.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  7639.      return TCL_ERROR;
  7640.   }
  7641.  
  7642.   point1[0] = (RtFloat)atof(argv[1]);
  7643.   point1[1] = (RtFloat)atof(argv[2]);
  7644.   point1[2] = (RtFloat)atof(argv[3]);
  7645.  
  7646.   point2[0] = (RtFloat)atof(argv[4]);
  7647.   point2[1] = (RtFloat)atof(argv[5]);
  7648.   point2[2] = (RtFloat)atof(argv[6]);
  7649.  
  7650.   n = 0;
  7651.   if (argc > num_args)
  7652.   {  n = (argc - num_args) / 2;
  7653.      if (!buildParameterList(me, interp, n, &tokens, &parms, &archiveVector, &nVector, &typeVector, num_args, argv))
  7654.      {  return TCL_ERROR;
  7655.      }
  7656.   }
  7657.  
  7658.   // RiHyperboloidV(point1, point2, (RtFloat)atof(argv[7]), n, tokens, parms);
  7659.  
  7660.   newRIBCommand = [[RIBHyperboloid alloc] init];
  7661.   [newRIBCommand setPoint1:point1 point2:point2 thetaMax:(RtFloat)atof(argv[7])
  7662.                     n:n tokens:tokens parms:parms archiveVector:archiveVector printfTypeVector:typeVector printfNVector:nVector];
  7663.   [newRIBCommand setMyShape:[me currentShape]];
  7664.   if ([me evaluatingEveCommand])
  7665.   {  [me setTmpRIBCommand:newRIBCommand];
  7666.   }
  7667.   else
  7668.   {  [[me currentShape] appendRIBCommand:newRIBCommand];
  7669.   }
  7670.  
  7671.   return TCL_OK;
  7672. }
  7673.  
  7674.  
  7675.  
  7676. static int
  7677. cmd_RiParaboloid(me, interp, argc, argv)
  7678. WWEveParser    *me;
  7679. Tcl_Interp     *interp;
  7680. int            argc;
  7681. char           **argv;
  7682. {
  7683.   char  *my_args = "rMax zMin zMax thetaMax [parameterlist]";
  7684.   int    num_args = 5, n;
  7685.   RtToken    *tokens = (RtToken *)RI_NULL;
  7686.   RtPointer  *parms = (RtPointer *)RI_NULL;
  7687.   int        *nVector = NULL, 
  7688.              *typeVector = NULL;
  7689.   char       **archiveVector = NULL;
  7690.   id         newRIBCommand;
  7691.  
  7692.  
  7693.   sprintf(errBuf, "evaluating %s...", argv[0]);
  7694.   [[me statusText] setStringValue:errBuf]; [[me statusText] display]; NXPing();
  7695.   if (![me riBegun])
  7696.   {  sprintf(errBuf, "You must call RiBegin before making any RIB calls");
  7697.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  7698.      return TCL_ERROR;
  7699.   }
  7700.  
  7701.   if (argc < num_args)
  7702.   {  sprintf(errBuf, "USAGE: %s %s", argv[0], my_args);
  7703.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  7704.      return TCL_ERROR;
  7705.   }
  7706.  
  7707.   if ((argc+1) % 2)
  7708.   {  sprintf(errBuf, "RiParaboloid : parameter list must be in groups of two, i.e. the number of args is an even number");
  7709.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  7710.      return TCL_ERROR;
  7711.   }
  7712.  
  7713.   n = 0;
  7714.   if (argc > num_args)
  7715.   {  n = (argc - num_args) / 2;
  7716.      if (!buildParameterList(me, interp, n, &tokens, &parms, &archiveVector, &nVector, &typeVector, num_args, argv))
  7717.      {  return TCL_ERROR;
  7718.      }
  7719.   }
  7720.  
  7721.   // RiParaboloidV((RtFloat)atof(argv[1]), (RtFloat)atof(argv[2]), (RtFloat)atof(argv[3]), (RtFloat)atof(argv[4]), n, tokens, parms);
  7722.  
  7723.   newRIBCommand = [[RIBParaboloid alloc] init];
  7724.   [newRIBCommand setRMax:(RtFloat)atof(argv[1]) zMin:(RtFloat)atof(argv[2]) zMax:(RtFloat)atof(argv[3]) thetaMax:(RtFloat)atof(argv[4])
  7725.                     n:n tokens:tokens parms:parms archiveVector:archiveVector printfTypeVector:typeVector printfNVector:nVector];
  7726.   [newRIBCommand setMyShape:[me currentShape]];
  7727.   if ([me evaluatingEveCommand])
  7728.   {  [me setTmpRIBCommand:newRIBCommand];
  7729.   }
  7730.   else
  7731.   {  [[me currentShape] appendRIBCommand:newRIBCommand];
  7732.   }
  7733.  
  7734.   return TCL_OK;
  7735. }
  7736.  
  7737.  
  7738.  
  7739. static int
  7740. cmd_RiDisk(me, interp, argc, argv)
  7741. WWEveParser    *me;
  7742. Tcl_Interp     *interp;
  7743. int            argc;
  7744. char           **argv;
  7745. {
  7746.   char  *my_args = "height radius thetaMax [parameterlist]";
  7747.   int    num_args = 4, n;
  7748.   RtToken    *tokens = (RtToken *)RI_NULL;
  7749.   RtPointer  *parms = (RtPointer *)RI_NULL;
  7750.   int        *nVector = NULL, 
  7751.              *typeVector = NULL;
  7752.   char       **archiveVector = NULL;
  7753.   id         newRIBCommand;
  7754.  
  7755.  
  7756.   sprintf(errBuf, "evaluating %s...", argv[0]);
  7757.   [[me statusText] setStringValue:errBuf]; [[me statusText] display]; NXPing();
  7758.   if (![me riBegun])
  7759.   {  sprintf(errBuf, "You must call RiBegin before making any RIB calls");
  7760.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  7761.      return TCL_ERROR;
  7762.   }
  7763.  
  7764.   if (argc < num_args)
  7765.   {  sprintf(errBuf, "USAGE: %s %s", argv[0], my_args);
  7766.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  7767.      return TCL_ERROR;
  7768.   }
  7769.  
  7770.   if (argc % 2)
  7771.   {  sprintf(errBuf, "RiDisk : parameter list must be in groups of two, i.e. the number of args is an even number");
  7772.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  7773.      return TCL_ERROR;
  7774.   }
  7775.  
  7776.   n = 0;
  7777.   if (argc > num_args)
  7778.   {  n = (argc - num_args) / 2;
  7779.      if (!buildParameterList(me, interp, n, &tokens, &parms, &archiveVector, &nVector, &typeVector, num_args, argv))
  7780.      {  return TCL_ERROR;
  7781.      }
  7782.   }
  7783.  
  7784.   // RiDiskV((RtFloat)atof(argv[1]), (RtFloat)atof(argv[2]), (RtFloat)atof(argv[3]), n, tokens, parms);
  7785.  
  7786.   newRIBCommand = [[RIBDisk alloc] init];
  7787.   [newRIBCommand setHeight:(RtFloat)atof(argv[1]) radius:(RtFloat)atof(argv[2]) thetaMax:(RtFloat)atof(argv[3])
  7788.                     n:n tokens:tokens parms:parms archiveVector:archiveVector printfTypeVector:typeVector printfNVector:nVector];
  7789.   [newRIBCommand setMyShape:[me currentShape]];
  7790.   if ([me evaluatingEveCommand])
  7791.   {  [me setTmpRIBCommand:newRIBCommand];
  7792.   }
  7793.   else
  7794.   {  [[me currentShape] appendRIBCommand:newRIBCommand];
  7795.   }
  7796.  
  7797.   return TCL_OK;
  7798. }
  7799.  
  7800.  
  7801.  
  7802. static int
  7803. cmd_RiTorus(me, interp, argc, argv)
  7804. WWEveParser    *me;
  7805. Tcl_Interp     *interp;
  7806. int            argc;
  7807. char           **argv;
  7808. {
  7809.   char  *my_args = "majorRadius minorRadius phiMin phiMax thetaMax [parameterlist]";
  7810.   int    num_args = 6, n;
  7811.   RtToken    *tokens = (RtToken *)RI_NULL;
  7812.   RtPointer  *parms = (RtPointer *)RI_NULL;
  7813.   int        *nVector = NULL, 
  7814.              *typeVector = NULL;
  7815.   char       **archiveVector = NULL;
  7816.   id         newRIBCommand;
  7817.  
  7818.  
  7819.   sprintf(errBuf, "evaluating %s...", argv[0]);
  7820.   [[me statusText] setStringValue:errBuf]; [[me statusText] display]; NXPing();
  7821.   if (![me riBegun])
  7822.   {  sprintf(errBuf, "You must call RiBegin before making any RIB calls");
  7823.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  7824.      return TCL_ERROR;
  7825.   }
  7826.  
  7827.   if (argc < num_args)
  7828.   {  sprintf(errBuf, "USAGE: %s %s", argv[0], my_args);
  7829.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  7830.      return TCL_ERROR;
  7831.   }
  7832.  
  7833.   if (argc % 2)
  7834.   {  sprintf(errBuf, "RiTorus : parameter list must be in groups of two, i.e. the number of args is an even number");
  7835.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  7836.      return TCL_ERROR;
  7837.   }
  7838.  
  7839.   n = 0;
  7840.   if (argc > num_args)
  7841.   {  n = (argc - num_args) / 2;
  7842.      if (!buildParameterList(me, interp, n, &tokens, &parms, &archiveVector, &nVector, &typeVector, num_args, argv))
  7843.      {  return TCL_ERROR;
  7844.      }
  7845.   }
  7846.  
  7847.   // RiTorus((RtFloat)atof(argv[1]), (RtFloat)atof(argv[2]), 
  7848.   //      (RtFloat)atof(argv[3]), (RtFloat)atof(argv[4]), (RtFloat)atof(argv[5]), n, tokens, parms);
  7849.  
  7850.   newRIBCommand = [[RIBTorus alloc] init];
  7851.   [newRIBCommand setMajorRadius:(RtFloat)atof(argv[1]) minorRadius:(RtFloat)atof(argv[2]) 
  7852.                     phiMin:(RtFloat)atof(argv[3]) phiMax:(RtFloat)atof(argv[4]) thetaMax:(RtFloat)atof(argv[5])
  7853.                     n:n tokens:tokens parms:parms archiveVector:archiveVector printfTypeVector:typeVector printfNVector:nVector];
  7854.   [newRIBCommand setMyShape:[me currentShape]];
  7855.   if ([me evaluatingEveCommand])
  7856.   {  [me setTmpRIBCommand:newRIBCommand];
  7857.   }
  7858.   else
  7859.   {  [[me currentShape] appendRIBCommand:newRIBCommand];
  7860.   }
  7861.  
  7862.   return TCL_OK;
  7863. }
  7864.  
  7865.  
  7866.  
  7867. static int
  7868. cmd_RiGeometry(me, interp, argc, argv)
  7869. WWEveParser    *me;
  7870. Tcl_Interp     *interp;
  7871. int            argc;
  7872. char           **argv;
  7873. {
  7874.   char  *my_args = "type [parameterlist]";
  7875.   int    num_args = 2, n;
  7876.   RtToken    *tokens = (RtToken *)RI_NULL;
  7877.   RtPointer  *parms = (RtPointer *)RI_NULL;
  7878.   int        *nVector = NULL, 
  7879.              *typeVector = NULL;
  7880.   char       **archiveVector = NULL;
  7881.  
  7882.  
  7883.   sprintf(errBuf, "evaluating %s...", argv[0]);
  7884.   [[me statusText] setStringValue:errBuf]; [[me statusText] display]; NXPing();
  7885.   if (![me riBegun])
  7886.   {  sprintf(errBuf, "You must call RiBegin before making any RIB calls");
  7887.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  7888.      return TCL_ERROR;
  7889.   }
  7890.  
  7891.   if (argc < num_args)
  7892.   {  sprintf(errBuf, "USAGE: %s %s", argv[0], my_args);
  7893.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  7894.      return TCL_ERROR;
  7895.   }
  7896.  
  7897.   if (argc % 2)
  7898.   {  sprintf(errBuf, "RiGeometry : parameter list must be in groups of two, i.e. the number of args is an even number");
  7899.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  7900.      return TCL_ERROR;
  7901.   }
  7902.  
  7903.   n = 0;
  7904.   if (argc > num_args)
  7905.   {  n = (argc - num_args) / 2;
  7906.      if (!buildParameterList(me, interp, n, &tokens, &parms, &archiveVector, &nVector, &typeVector, num_args, argv))
  7907.      {  return TCL_ERROR;
  7908.      }
  7909.   }
  7910.  
  7911.   // RiGeometryV((RtToken)argv[1], n, tokens, parms);
  7912.  
  7913.   if (n)
  7914.   {  free(tokens); free(parms); free(archiveVector);
  7915.   }
  7916.  
  7917.   return TCL_OK;
  7918. }
  7919.  
  7920.  
  7921. #define MAX_LINE_LENGTH 1024
  7922.  
  7923. static int
  7924. cmd_RiArchiveRecord(me, interp, argc, argv)
  7925. WWEveParser    *me;
  7926. Tcl_Interp     *interp;
  7927. int            argc;
  7928. char           **argv;
  7929. {
  7930.   char  *my_args = " comment|structure stringWithNoNewlines";
  7931.   int    i, bytesLeft;
  7932.   id    newRIBCommand;
  7933.   static  char commentBuf[MAX_LINE_LENGTH + 1];
  7934.  
  7935.  
  7936.   sprintf(errBuf, "evaluating %s...", argv[0]);
  7937.   [[me statusText] setStringValue:errBuf]; [[me statusText] display]; NXPing();
  7938.   if (argc < 2)
  7939.   {  sprintf(errBuf, "USAGE: %s %s", argv[0], my_args);
  7940.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  7941.      return TCL_ERROR;
  7942.   }
  7943.  
  7944.   commentBuf[0] = '\0';
  7945.   bytesLeft = MAX_LINE_LENGTH;
  7946.   for (i = 2; i < argc; i++)
  7947.   {  strncat(commentBuf, argv[i], bytesLeft);
  7948.      bytesLeft -= strlen(argv[i]);
  7949.      strncat(commentBuf, " ", bytesLeft);
  7950.      bytesLeft--;
  7951.   }
  7952.   if (!strcmp(argv[1], "comment"))
  7953.   {  // RiArchiveRecord("comment", "%s", argv[2]);
  7954.      newRIBCommand = [[RIBArchiveRecord alloc] init];
  7955.      [newRIBCommand setType:"comment" format:commentBuf];
  7956.      [newRIBCommand setMyShape:[me currentShape]];
  7957.      if ([me evaluatingEveCommand])
  7958.      {  [me setTmpRIBCommand:newRIBCommand];
  7959.      }
  7960.      else
  7961.      {  [[me currentShape] appendRIBCommand:newRIBCommand];
  7962.      }
  7963.      return TCL_OK;
  7964.   }
  7965.   if (!strcmp(argv[1], "structure"))
  7966.   {  // RiArchiveRecord("structure", "%s", argv[2]);
  7967.      newRIBCommand = [[RIBArchiveRecord alloc] init];
  7968.      [newRIBCommand setType:"structure" format:commentBuf];
  7969.      [newRIBCommand setMyShape:[me currentShape]];
  7970.      if ([me evaluatingEveCommand])
  7971.      {  [me setTmpRIBCommand:newRIBCommand];
  7972.      }
  7973.      else
  7974.      {  [[me currentShape] appendRIBCommand:newRIBCommand];
  7975.      }
  7976.      return TCL_OK;
  7977.   }
  7978.   sprintf(errBuf, 
  7979.       "RiArchiveRecord : first arg must be one of: comment or structure");
  7980.   Tcl_AppendResult(interp, errBuf, (char *)NULL);
  7981.   return TCL_ERROR;
  7982. }
  7983.  
  7984.  
  7985.  
  7986. // EveCmd {wwSet foo $bar}
  7987. static int
  7988. cmd_WWSet(me, interp, argc, argv)
  7989. WWEveParser    *me;
  7990. Tcl_Interp     *interp;
  7991. int            argc;
  7992. char           **argv;
  7993. {
  7994.   char  *my_args = "varName varValue";
  7995.   id    newRIBCommand;
  7996.  
  7997.  
  7998.   sprintf(errBuf, "evaluating %s...", argv[0]);
  7999.   [[me statusText] setStringValue:errBuf]; [[me statusText] display]; NXPing();
  8000.   if (argc != 3)
  8001.   {  sprintf(errBuf, "USAGE: %s %s", argv[0], my_args);
  8002.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  8003.      return TCL_ERROR;
  8004.   }
  8005.  
  8006.   // okay, set this in the current context
  8007.   if (![[me tclInterp] setVar:argv[1] toValue:argv[2]])
  8008.   {  sprintf(errBuf, "%s: unable to set %s to %s", argv[0], argv[1], argv[2]);
  8009.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  8010.      return TCL_ERROR;
  8011.   }
  8012.  
  8013.   //okay, that worked, so now we need to malloc up a new WWSet object to store this state
  8014.   newRIBCommand = [[WWSet alloc] initWithInterp:[me tclInterp]];
  8015.   [newRIBCommand setVar:argv[1] value:argv[2]];
  8016.   if ([me evaluatingEveCommand])
  8017.   {  [me setTmpRIBCommand:newRIBCommand];
  8018.   }
  8019.   else
  8020.   {  [[me currentShape] appendRIBCommand:newRIBCommand];
  8021.   }
  8022.   return TCL_OK;
  8023. }
  8024.  
  8025.  
  8026. static int
  8027. cmd_EveCmd(me, interp, argc, argv)
  8028. WWEveParser    *me;
  8029. Tcl_Interp     *interp;
  8030. int            argc;
  8031. char           **argv;
  8032. {
  8033.   char  *my_args = "eveCommand [{{sampleTime0 { {sampleComponentAGeneratorName weight.a sample0.a} ... {sampleComponentNGeneratorName weight.n sample0.n}}} {sampleTime1  {sampleComponent1AGeneratorName weight.a sample1.a} ... {sampleComponent0NGeneratorName weight.n sample1.n} }}]", *retBuf;
  8034.   int    ret;
  8035.   id    newRIBCommand;
  8036.  
  8037.  
  8038.   sprintf(errBuf, "evaluating %s...", argv[0]);
  8039.   [[me statusText] setStringValue:errBuf]; [[me statusText] display]; NXPing();
  8040.   if ((argc != 2) && (argc != 3))
  8041.   {  sprintf(errBuf, "USAGE: %s %s", argv[0], my_args);
  8042.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  8043.      return TCL_ERROR;
  8044.   }
  8045.  
  8046.   if ([me evaluatingEveProc])
  8047.   {  sprintf(errBuf, "you cannot nest an EveCmd call inside an EveProc call");
  8048.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  8049.      return TCL_ERROR;
  8050.   }
  8051.  
  8052.   newRIBCommand = [[EveCommand alloc] initWithInterp:[me tclInterp] 
  8053.                                       eveParser:(id)me 
  8054.                                       shape:[me currentShape] 
  8055.                                       cmd:argv[1] 
  8056.                                       clock:[me sceneClock] 
  8057.                                       frozen:[me frozen]];
  8058.   if (!newRIBCommand) // evalutation of this rib command failed. we
  8059.   {                   // need to get the error code, though, so we 
  8060.                       // reevaluate the command to get it...
  8061.      retBuf = [[me tclInterp] eval:argv[1] :&ret];
  8062.      sprintf(errBuf, "unable to build new RIBCommand from <%s> inside EveCmd due to <%s>", argv[1], retBuf);
  8063.      NXLogError(errBuf);
  8064.      NXLogError("\n");
  8065.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  8066.      if (retBuf) {  free(retBuf); }
  8067.      return TCL_ERROR;
  8068.   }
  8069.  
  8070.   if (argc == 3)
  8071.   {  if (![newRIBCommand evalAndAddAsSamples:argv[2]])
  8072.      {  sprintf(errBuf, "difficulty parsing %s samples (check console for more errors)", argv[0]);
  8073.         Tcl_AppendResult(interp, errBuf, (char *)NULL);
  8074.         [newRIBCommand free];  
  8075.         return TCL_ERROR;
  8076.      }
  8077.   }
  8078.  
  8079.   // if we don't have a currentShape, that means we're in the limbo of
  8080.   // having blown away our old root shape but not having evaluated the
  8081.   // first AttributeBegin.  To fix this, we'll instantiate a new shape...
  8082.  
  8083.   if (![me currentShape])
  8084.   {  id newShape  = [[WW3DShape alloc] initWithInterp:[me tclInterp] andSceneClock:[me sceneClock]]; 
  8085.      [me setRiBegun:YES];
  8086.      [newShape setShapeName:"dummyShapeToHoldAnimatableCommands"];
  8087.      [me setTmpRootShape:newShape];
  8088.      [me setCurrentShape:newShape];
  8089.   } 
  8090.   [[me currentShape] appendRIBCommand:newRIBCommand];
  8091.  
  8092.   return TCL_OK;
  8093. }
  8094.  
  8095.  
  8096. static int
  8097. cmd_EveProc(me, interp, argc, argv)
  8098. WWEveParser    *me;
  8099. Tcl_Interp     *interp;
  8100. int            argc;
  8101. char           **argv;
  8102. {
  8103.   char  *my_args = "eveProc [{{sampleTime0 {sample0}} {sampleTime1 {sample1}} ... {sampleTimeN {sampleN}}}]", *retBuf;
  8104.   int    ret;
  8105.   id    newRIBCommand;
  8106.  
  8107.   sprintf(errBuf, "evaluating %s...", argv[0]);
  8108.   [[me statusText] setStringValue:errBuf]; [[me statusText] display]; NXPing();
  8109.   if ((argc != 2) && (argc != 3))
  8110.   {  sprintf(errBuf, "USAGE: %s %s", argv[0], my_args);
  8111.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  8112.      return TCL_ERROR;
  8113.   }
  8114.  
  8115.   if ([me evaluatingEveProc])
  8116.   {  sprintf(errBuf, "you cannot nest EveProc calls");
  8117.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  8118.      return TCL_ERROR;
  8119.   }
  8120.  
  8121.   [me setEvaluatingEveProc:YES];
  8122.   newRIBCommand = [[EveProc alloc] initWithInterp:[me tclInterp] 
  8123.                                    eveParser:(id)me 
  8124.                                    shape:[me currentShape] 
  8125.                                    cmd:argv[1] 
  8126.                                    clock:[me sceneClock] frozen:[me frozen]];
  8127.   [me setEvaluatingEveProc:NO];
  8128.  
  8129.   if (!newRIBCommand) // evalutation of this rib command failed. we
  8130.   {                   // need to get the error code, though, so we 
  8131.                       // reevaluate the command to get it...
  8132.      retBuf = [[me tclInterp] eval:argv[1] :&ret];
  8133.      sprintf(errBuf, "unable to build new RIBCommand from <%s> inside EveProc due to <%s>", argv[1], retBuf);
  8134.      NXLogError(errBuf);
  8135.      NXLogError("\n");
  8136.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  8137.      if (retBuf) {  free(retBuf); }
  8138.      return TCL_ERROR;
  8139.   }
  8140.  
  8141.   if (argc == 3)
  8142.   {  if (![newRIBCommand evalAndAddAsSamples:argv[2]])
  8143.      {  sprintf(errBuf, "difficulty parsing %s samples (check console for more errors)", argv[0]);
  8144.         Tcl_AppendResult(interp, errBuf, (char *)NULL);
  8145.         [newRIBCommand free];  
  8146.         return TCL_ERROR;
  8147.      }
  8148.   }
  8149.  
  8150.   // if we don't have a currentShape, that means we're in the limbo of
  8151.   // having blown away our old root shape but not having evaluated the
  8152.   // first AttributeBegin.  To fix this, we'll instantiate a new shape...
  8153.  
  8154.   if (![me currentShape])
  8155.   {  id newShape  = [[WW3DShape alloc] initWithInterp:[me tclInterp] andSceneClock:[me sceneClock]]; 
  8156.      [me setRiBegun:YES];
  8157.      [newShape setShapeName:"dummyShapeToHoldAnimatableCommands"];
  8158.      [me setTmpRootShape:newShape];
  8159.      [me setCurrentShape:newShape];
  8160.   } 
  8161.   [[me currentShape] appendRIBCommand:newRIBCommand];
  8162.  
  8163.   return TCL_OK;
  8164. }
  8165.  
  8166.  
  8167. static int
  8168. cmd_ApplyToCTM(me, interp, argc, argv)
  8169. WWEveParser    *me;
  8170. Tcl_Interp     *interp;
  8171. int            argc;
  8172. char           **argv;
  8173. {
  8174.   char  *my_args = "eveCommand";
  8175.   int    num_args = 2, retVal;
  8176.   BOOL  oldFlag;
  8177.  
  8178.  
  8179.   sprintf(errBuf, "evaluating %s...", argv[0]);
  8180.   [[me statusText] setStringValue:errBuf]; [[me statusText] display]; NXPing();
  8181.   if (argc != num_args)
  8182.   {  sprintf(errBuf, "USAGE: %s %s", argv[0], my_args);
  8183.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  8184.      return TCL_ERROR;
  8185.   }
  8186.  
  8187.   oldFlag = [me firmTransforms];
  8188.   [me setFirmTransforms:YES];
  8189.   retVal = [[me tclInterp] eval:argv[1]];
  8190.   [me setFirmTransforms:oldFlag];
  8191.  
  8192.   return retVal;
  8193. }
  8194.  
  8195.  
  8196. static int
  8197. cmd_updateView(me, interp, argc, argv)
  8198. WWEveParser *me;
  8199. Tcl_Interp *interp;
  8200. int argc;
  8201. char **argv;
  8202. {
  8203.   sprintf(errBuf, "evaluating %s...", argv[0]);
  8204.   [[me statusText] setStringValue:errBuf]; [[me statusText] display]; NXPing();
  8205.   [me updateView];
  8206.   return TCL_OK;
  8207. }
  8208.  
  8209.  
  8210. static int
  8211. cmd_synchWithScene(me, interp, argc, argv)
  8212. WWEveParser *me;
  8213. Tcl_Interp *interp;
  8214. int argc;
  8215. char **argv;
  8216. {
  8217.   int   i, howMany = [me sceneIncr];
  8218.   char  ticksPassed[32];
  8219.   id    sceneClock = [me sceneClock];
  8220.  
  8221.  
  8222.   sprintf(errBuf, "evaluating %s...", argv[0]);
  8223.  
  8224.   // in the real WavesWorld system, this msg would be going from a
  8225.   // skill agent out to the shared state space of the dude.  It would hang
  8226.   // the skill agent until the next tick of the scene clock had passed.  In
  8227.   // a real-time system, this would be some amount of wall time, while in
  8228.   // the non-realtime version, it would be after either all non-amputated
  8229.   // executing skill agents had sent this msg for the given tick.
  8230.   // In this "dude builder" version, since the activity is single-threaded,
  8231.   // this just increments the scene clock and returns immediately.
  8232.  
  8233.   // actually, let's make this a little better.  There will be a global 
  8234.   // variable, scene(
  8235.   for (i = 0; i < howMany; i++)
  8236.   {  [sceneClock increment:nil];
  8237.   }
  8238.   // for now, we should probably also update the view...
  8239.   [me synchViewWithSceneClock];
  8240.   //[me updateView];
  8241.  
  8242.   // in the general case, we return the number of ticks that have
  8243.   // passed in the scene since the scene clock last received a synch msg
  8244.   // from this agent.  In this (somewhat degenerate) case, it will always
  8245.   // be one.  This, in conjunction with the read-only variable "ticksPerSecond",
  8246.   // allows an agent to keep in synch via dead-reckoning...
  8247.  
  8248.   sprintf(ticksPassed, "%d", howMany);
  8249.   Tcl_AppendResult(interp, ticksPassed, (char *)NULL);
  8250.  
  8251.   return TCL_OK;
  8252. }
  8253.  
  8254. static int
  8255. cmd_synchWithSceneInvisibly(me, interp, argc, argv)
  8256. WWEveParser *me;
  8257. Tcl_Interp *interp;
  8258. int argc;
  8259. char **argv;
  8260. {
  8261.   int   i, howMany = [me sceneIncr];
  8262.   char  ticksPassed[32];
  8263.   id    sceneClock = [me sceneClock];
  8264.  
  8265.  
  8266.   sprintf(errBuf, "evaluating %s...", argv[0]);
  8267.  
  8268.   // in the real WavesWorld system, this msg would be going from a
  8269.   // skill agent out to the shared state space of the dude.  It would hang
  8270.   // the skill agent until the next tick of the scene clock had passed.  In
  8271.   // a real-time system, this would be some amount of wall time, while in
  8272.   // the non-realtime version, it would be after either all non-amputated
  8273.   // executing skill agents had sent this msg for the given tick.
  8274.   // In this "dude builder" version, since the activity is single-threaded,
  8275.   // this just increments the scene clock and returns immediately.
  8276.  
  8277.   // actually, let's make this a little better.  There will be a global 
  8278.   // variable, scene(
  8279.   for (i = 0; i < howMany; i++)
  8280.   {  [sceneClock increment:nil];
  8281.   }
  8282.  
  8283.   // in the general case, we return the number of ticks that have
  8284.   // passed in the scene since the scene clock last received a synch msg
  8285.   // from this agent.  In this (somewhat degenerate) case, it will always
  8286.   // be one.  This, in conjunction with the read-only variable "ticksPerSecond",
  8287.   // allows an agent to keep in synch via dead-reckoning...
  8288.  
  8289.   sprintf(ticksPassed, "%d", howMany);
  8290.   Tcl_AppendResult(interp, ticksPassed, (char *)NULL);
  8291.  
  8292.   return TCL_OK;
  8293. }
  8294.  
  8295. static int
  8296. cmd_camera(me, interp, argc, argv)
  8297. WWEveParser *me;
  8298. Tcl_Interp *interp;
  8299. int argc;
  8300. char **argv;
  8301. {
  8302.   char  *my_args = "codeToGiveToCameraInterp";
  8303.   int    num_args = 2;
  8304.   char  *retString = NULL;
  8305.   int   ret;
  8306.  
  8307.  
  8308.   sprintf(errBuf, "evaluating %s...", argv[0]);
  8309.   [[me statusText] setStringValue:errBuf]; [[me statusText] display]; NXPing();
  8310.   if (argc != num_args)
  8311.   {  sprintf(errBuf, "USAGE: %s %s", argv[0], my_args);
  8312.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  8313.      return TCL_ERROR;
  8314.   }
  8315.  
  8316.   retString = [[[me camera] tclInterp] eval:argv[1] :&ret];
  8317.   if (retString)
  8318.   {  Tcl_AppendResult(interp, retString, (char *)NULL);
  8319.      free(retString);
  8320.   }
  8321.   return ret;
  8322. }
  8323.  
  8324.  
  8325. static int
  8326. cmd_TreatAttributeBeginLikeStartShape(me, interp, argc, argv)
  8327. WWEveParser *me;
  8328. Tcl_Interp *interp;
  8329. int argc;
  8330. char **argv;
  8331. {
  8332.   char  *my_args = "[newValue]";
  8333.   int    newValue, num_args = 2;
  8334.  
  8335.  
  8336.   sprintf(errBuf, "evaluating %s...", argv[0]);
  8337.   [[me statusText] setStringValue:errBuf]; [[me statusText] display]; NXPing();
  8338.   if (argc > num_args)
  8339.   {  sprintf(errBuf, "USAGE: %s %s", argv[0], my_args);
  8340.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  8341.      return TCL_ERROR;
  8342.   }
  8343.  
  8344.   if (argc == 1) // just return the current value 
  8345.   {  sprintf(errBuf, "%d", [me treatAttributeBeginLikeStartShape]);
  8346.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  8347.   }
  8348.   else
  8349.   {  if (Tcl_GetBoolean(interp, argv[1], &newValue) != TCL_OK)
  8350.      {  sprintf(errBuf, "%s isn't a valid boolean value", argv[1]);
  8351.         Tcl_AppendResult(interp, errBuf, (char *)NULL);
  8352.         return TCL_ERROR;
  8353.      }
  8354.      [me setTreatAttributeBeginLikeStartShape:(BOOL)newValue];
  8355.      sprintf(errBuf, "%d", [me treatAttributeBeginLikeStartShape]);
  8356.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  8357.   }
  8358.  
  8359.   return TCL_OK;
  8360. }
  8361.  
  8362.  
  8363. static int
  8364. cmd_TreatTransformBeginLikeAttributeBegin(me, interp, argc, argv)
  8365. WWEveParser *me;
  8366. Tcl_Interp *interp;
  8367. int argc;
  8368. char **argv;
  8369. {
  8370.   char  *my_args = "[newValue]";
  8371.   int    newValue, num_args = 2;
  8372.  
  8373.  
  8374.   sprintf(errBuf, "evaluating %s...", argv[0]);
  8375.   [[me statusText] setStringValue:errBuf]; [[me statusText] display]; NXPing();
  8376.   if (argc > num_args)
  8377.   {  sprintf(errBuf, "USAGE: %s %s", argv[0], my_args);
  8378.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  8379.      return TCL_ERROR;
  8380.   }
  8381.  
  8382.   if (argc == 1) // just return the current value 
  8383.   {  sprintf(errBuf, "%d", [me treatTransformBeginLikeAttributeBegin]);
  8384.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  8385.   }
  8386.   else
  8387.   {  if (Tcl_GetBoolean(interp, argv[1], &newValue) != TCL_OK)
  8388.      {  sprintf(errBuf, "%s isn't a valid boolean value", argv[1]);
  8389.         Tcl_AppendResult(interp, errBuf, (char *)NULL);
  8390.         return TCL_ERROR;
  8391.      }
  8392.      [me setTreatTransformBeginLikeAttributeBegin:(BOOL)newValue];
  8393.      sprintf(errBuf, "%d", [me treatTransformBeginLikeAttributeBegin]);
  8394.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  8395.   }
  8396.  
  8397.   return TCL_OK;
  8398. }
  8399.  
  8400.  
  8401. static int
  8402. cmd_ApplyShadersDirectlyToCurrentShape(me, interp, argc, argv)
  8403. WWEveParser *me;
  8404. Tcl_Interp *interp;
  8405. int argc;
  8406. char **argv;
  8407. {
  8408.   char  *my_args = "[newValue]";
  8409.   int    newValue, num_args = 2;
  8410.  
  8411.  
  8412.   sprintf(errBuf, "evaluating %s...", argv[0]);
  8413.   [[me statusText] setStringValue:errBuf]; [[me statusText] display]; NXPing();
  8414.   if (argc > num_args)
  8415.   {  sprintf(errBuf, "USAGE: %s %s", argv[0], my_args);
  8416.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  8417.      return TCL_ERROR;
  8418.   }
  8419.  
  8420.   if (argc == 1) // just return the current value 
  8421.   {  sprintf(errBuf, "%d", [me applyShadersDirectlyToCurrentShape]);
  8422.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  8423.   }
  8424.   else
  8425.   {  if (Tcl_GetBoolean(interp, argv[1], &newValue) != TCL_OK)
  8426.      {  sprintf(errBuf, "%s isn't a valid boolean value", argv[1]);
  8427.         Tcl_AppendResult(interp, errBuf, (char *)NULL);
  8428.         return TCL_ERROR;
  8429.      }
  8430.      [me setApplyShadersDirectlyToCurrentShape:(BOOL)newValue];
  8431.      sprintf(errBuf, "%d", [me applyShadersDirectlyToCurrentShape]);
  8432.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  8433.   }
  8434.  
  8435.   return TCL_OK;
  8436. }
  8437.  
  8438.  
  8439. static int
  8440. cmd_WW3DText(me, interp, argc, argv)
  8441. WWEveParser *me;
  8442. Tcl_Interp *interp;
  8443. int argc;
  8444. char **argv;
  8445. /*
  8446.  * WW3DText fontName fontSize theText
  8447.  */
  8448. {
  8449.   const 
  8450.       char  *cmdUsage = "fontName fontSize theText [left|center|right]";
  8451.   int       expectedCmdArgs = 4;
  8452.   double    fontSize;
  8453.   Font      *theFont;
  8454.   id        newRIBCommand;
  8455.   int       justification = NX_CENTERED;
  8456.  
  8457.  
  8458.   sprintf(errBuf, "evaluating %s...", argv[0]);
  8459.   [[me statusText] setStringValue:errBuf];
  8460.   [[me statusText] display];
  8461.   NXPing();
  8462.   if (![me riBegun]) 
  8463.   {  sprintf(errBuf, "You must call RiBegin before making any RIB calls");
  8464.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  8465.      return TCL_ERROR;
  8466.   }
  8467.   if (argc < expectedCmdArgs)
  8468.   {  sprintf(errBuf, "USAGE: %s %s", argv[0], cmdUsage);
  8469.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  8470.      return TCL_ERROR;
  8471.   }
  8472.   if (Tcl_GetDouble(interp, argv[2], &fontSize) != TCL_OK) 
  8473.   {  sprintf(errBuf, "USAGE: %s %s (second arg must be a floating point number)", argv[0], cmdUsage);
  8474.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  8475.      return TCL_ERROR;
  8476.   }
  8477.   if (argc == (expectedCmdArgs + 1))
  8478.   {  if (strcmp(argv[expectedCmdArgs], "left") && strcmp(argv[expectedCmdArgs], "center") && strcmp(argv[expectedCmdArgs], "right"))
  8479.      {  sprintf(errBuf, "USAGE: %s %s (final arg must be left, center, or right)", argv[0], cmdUsage);
  8480.         Tcl_AppendResult(interp, errBuf, (char *)NULL);
  8481.         return TCL_ERROR;
  8482.      } 
  8483.      if (!strcmp(argv[expectedCmdArgs], "left"))
  8484.      {  justification = NX_LEFTALIGNED;
  8485.      }
  8486.      else
  8487.      {  if (!strcmp(argv[expectedCmdArgs], "center"))
  8488.         {  justification = NX_CENTERED;
  8489.         }
  8490.         else
  8491.         {  justification = NX_RIGHTALIGNED;
  8492.         } 
  8493.      }
  8494.   }
  8495.  
  8496.   theFont = [Font newFont:argv[1] size:(float)fontSize];
  8497.   if (!theFont) 
  8498.   {  sprintf(errBuf, "Unable to instantiate a Font with a font name of %s and size %f", argv[1], (float)fontSize);
  8499.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  8500.      return TCL_ERROR;
  8501.   }
  8502.  
  8503.   newRIBCommand = [[WW3DText alloc] initWithCharPath:argv[3] usingFont:theFont myShape:[me currentShape] justification:justification];
  8504.   if ([me evaluatingEveCommand])
  8505.   {  [me setTmpRIBCommand:newRIBCommand];
  8506.   }
  8507.   else
  8508.   {  [[me currentShape] appendRIBCommand:newRIBCommand];
  8509.   }
  8510.  
  8511.   return TCL_OK;
  8512. }
  8513.  
  8514.  
  8515. static int
  8516. cmd_WW3DSquishySphere(me, interp, argc, argv)
  8517. WWEveParser    *me;
  8518. Tcl_Interp     *interp;
  8519. int            argc;
  8520. char           **argv;
  8521. {
  8522.   char  *my_args = "radius zMin zMax thetaMax yScale [parameterlist]";
  8523.   int    num_args = 6, n;
  8524.   RtToken    *tokens = (RtToken *)RI_NULL;
  8525.   RtPointer  *parms = (RtPointer *)RI_NULL;
  8526.   int        *nVector = NULL, 
  8527.              *typeVector = NULL;
  8528.   char       **archiveVector = NULL;
  8529.   id         newRIBCommand;
  8530.  
  8531.  
  8532.   sprintf(errBuf, "evaluating %s...", argv[0]);
  8533.   [[me statusText] setStringValue:errBuf]; [[me statusText] display]; NXPing();
  8534.   if (![me riBegun])
  8535.   {  sprintf(errBuf, "You must call RiBegin before making any RIB calls");
  8536.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  8537.      return TCL_ERROR;
  8538.   }
  8539.  
  8540.   if (argc < num_args)
  8541.   {  sprintf(errBuf, "USAGE: %s %s", argv[0], my_args);
  8542.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  8543.      return TCL_ERROR;
  8544.   }
  8545.  
  8546.   if (argc % 2)
  8547.   {  sprintf(errBuf, "WW3DSquishySphere : parameter list must be in groups of two, i.e. the number of args is an odd number");
  8548.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  8549.      return TCL_ERROR;
  8550.   }
  8551.  
  8552.   n = 0;
  8553.   if (argc > num_args)
  8554.   {  n = (argc - num_args) / 2;
  8555.      if (!buildParameterList(me, interp, n, &tokens, &parms, &archiveVector, &nVector, &typeVector, num_args, argv))
  8556.      {  return TCL_ERROR;
  8557.      }
  8558.   }
  8559.  
  8560.   newRIBCommand = [[WW3DSquishySphere alloc] init];
  8561.   [newRIBCommand setRadius:(RtFloat)atof(argv[1]) zMin:(RtFloat)atof(argv[2]) zMax:(RtFloat)atof(argv[3]) thetaMax:(RtFloat)atof(argv[4])
  8562.                     yScale:(RtFloat)atof(argv[5])
  8563.                     n:n tokens:tokens parms:parms archiveVector:archiveVector printfTypeVector:typeVector printfNVector:nVector];
  8564.   [newRIBCommand setMyShape:[me currentShape]];
  8565.   if ([me evaluatingEveCommand])
  8566.   {  [me setTmpRIBCommand:newRIBCommand];
  8567.   }
  8568.   else
  8569.   {  [[me currentShape] appendRIBCommand:newRIBCommand];
  8570.   }
  8571.  
  8572.   return TCL_OK;
  8573. }
  8574.  
  8575.  
  8576. static int
  8577. cmd_defineClass(me, interp, argc, argv)
  8578. WWEveParser *me;
  8579. Tcl_Interp *interp;
  8580. int argc;
  8581. char **argv;
  8582. {
  8583.   char  *my_args = "newClassName instanceVariables executableCode";
  8584.   int    num_args = 4;
  8585.   extern  int Tcl_ProcCmd();
  8586.  
  8587.  
  8588.   sprintf(errBuf, "evaluating %s...", argv[0]);
  8589.   [[me statusText] setStringValue:errBuf]; [[me statusText] display]; NXPing();
  8590.  
  8591.   if (argc != num_args)
  8592.   {  sprintf(errBuf, "USAGE: %s %s", argv[0], my_args);
  8593.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  8594.      return TCL_ERROR;
  8595.   }
  8596.  
  8597.   return Tcl_ProcCmd(me, interp, argc, argv);
  8598. }
  8599.  
  8600. static int
  8601. cmd_articulatedVariableChangesAs(me, interp, argc, argv)
  8602. WWEveParser *me;
  8603. Tcl_Interp *interp;
  8604. int argc;
  8605. char **argv;
  8606. {
  8607.   char    *my_args = "variableName startTime endTime uBasedCommand";
  8608.   int      num_args = 5;
  8609.   double  foo;
  8610.   float   startTime, endTime;
  8611.   id      newVarBehavior;
  8612.  
  8613.  
  8614.   sprintf(errBuf, "evaluating %s...", argv[0]);
  8615.   [[me statusText] setStringValue:errBuf]; [[me statusText] display]; NXPing();
  8616.   if (argc != num_args)
  8617.   {  sprintf(errBuf, "USAGE: %s %s", argv[0], my_args);
  8618.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  8619.      return TCL_ERROR;
  8620.   }
  8621.  
  8622.   if (Tcl_GetDouble(interp, argv[2], &foo) != TCL_OK) 
  8623.   {  sprintf(errBuf, "USAGE: %s %s (second arg must be a floating point number)", argv[0], my_args);
  8624.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  8625.      return TCL_ERROR;
  8626.   }
  8627.   startTime = (float)foo;
  8628.  
  8629.   if (Tcl_GetDouble(interp, argv[3], &foo) != TCL_OK) 
  8630.   {  sprintf(errBuf, "USAGE: %s %s (third arg must be a floating point number)", argv[0], my_args);
  8631.      Tcl_AppendResult(interp, errBuf, (char *)NULL);
  8632.      return TCL_ERROR;
  8633.   }
  8634.   endTime = (float)foo;
  8635.  
  8636.   newVarBehavior = [[WWArticulatedVariableBehavior alloc] initWithInterp:[me tclInterp] 
  8637.                                                           startTime:(float)startTime
  8638.                                                           endTime:(float)endTime 
  8639.                                                           var:(const char *)argv[1]
  8640.                                                           expression:(const char *)argv[4]];
  8641.   [me addArticulatedVariableBehavior:newVarBehavior];
  8642.  
  8643.   return TCL_OK;
  8644. }
  8645.  
  8646. static int
  8647. cmd_noop(me, interp, argc, argv)
  8648. WWEveParser *me;
  8649. Tcl_Interp *interp;
  8650. int argc;
  8651. char **argv;
  8652. {
  8653.   sprintf(errBuf, "evaluating %s...", argv[0]);
  8654.   [[me statusText] setStringValue:errBuf]; [[me statusText] display]; NXPing();
  8655.   return TCL_OK;
  8656. }
  8657.  
  8658. ////////////////////////////////////////////////////////////////
  8659. ////////////////////////////////////////////////////////////////
  8660. ////////////////////////// methods /////////////////////////////
  8661. ////////////////////////////////////////////////////////////////
  8662. ////////////////////////////////////////////////////////////////
  8663.  
  8664. - (int)sceneIncr { return sceneIncr; }
  8665.  
  8666. - setSceneIncr:(int)newSceneIncr
  8667. {
  8668.   char   buf[128];
  8669.  
  8670.  
  8671.   sceneIncr = newSceneIncr;
  8672.   sprintf(buf, "%d", sceneIncr);
  8673.   //[tclInterp setVar2:"scene" :"incr" toReadOnlyValue:buf];
  8674.   [tclInterp setVar2:"scene" :"incr" toValue:buf];
  8675.  
  8676.   return self;
  8677. }
  8678.  
  8679.  
  8680. // someone is writing a new value for the scene(incr) parameter, so we need
  8681. // to update the WWEveParser to reflect that new value...
  8682. char *WriteProcForSceneIncr(ClientData clientData, Tcl_Interp *interp, char *name1, char *name2, int flags)
  8683. {
  8684.   char   *varString;
  8685.   int   sceneIncr = 1;
  8686.  
  8687.  
  8688.   varString = [[(WWTCLVarTrace *)clientData tclInterp] getVar2:name1 :name2];
  8689.   sscanf(varString, "%d", &sceneIncr);
  8690.   [[(WWTCLVarTrace *)clientData datum] setSceneIncr:sceneIncr];
  8691.  
  8692.   return NULL;
  8693. }
  8694.  
  8695.  
  8696. // someone is reading a value for the scene(incr) parameter, so we need
  8697. // to " read-through" the WW3DCamera to reflect the current value...
  8698. char *ReadProcForSceneIncr(ClientData clientData, Tcl_Interp *interp, char *name1, char *name2, int flags)
  8699. {
  8700.   char  buf[128];
  8701.   int   sceneIncr;
  8702.  
  8703.  
  8704.   sceneIncr = [[(WWTCLVarTrace *)clientData datum] sceneIncr];
  8705.   sprintf(buf, "%d", sceneIncr);
  8706.   //[[(WWTCLVarTrace *)clientData tclInterp] setVar2:name1 :name2 toReadOnlyValue:buf];
  8707.   [[(WWTCLVarTrace *)clientData tclInterp] setVar2:name1 :name2 toValue:buf];
  8708.  
  8709.   return NULL;
  8710. }
  8711.  
  8712.  
  8713.  
  8714. - initWWEveParser
  8715. {
  8716.   char         *valAsString, *varName;
  8717.  
  8718.  
  8719.   valAsString = (char *)NXZoneCalloc([self zone], 256, sizeof(char));
  8720.   varName = (char *)NXZoneCalloc([self zone], 256, sizeof(char));
  8721.  
  8722.   // you may be asking yourself here: "why is wave, that bozo, copying
  8723.   // the strings that correspond to the variables names into a tmp
  8724.   // variable?  Is he really that wasteful, just because he has bigger
  8725.   // and more expensive equipment than I do?  Is he intentionally wasting
  8726.   // my precious time?"  Well, sports fans, no.  The problem is that
  8727.   // the current (7.3) implementation of tcl still uses a performance
  8728.   // hack that gets bit by compilers being smart.  The short answer is
  8729.   // if you hand tcl a const char* that the compiler has squirreled away
  8730.   // somewhere in read-only space, you will dump core, because tcl,
  8731.   // while doing a comparison on array elements, attempts to stick a '\0'
  8732.   // where the '(' is so it can do a fast hash table lookup.  It's very
  8733.   // good about taking the '\0' out once its done, but unfortunately, 
  8734.   // you'll never get the chance...  This is reasonably well documented
  8735.   // in the tcl doc, and given the efficiency, I can't really complain,
  8736.   // but it *is* a bug (whether in C, the compiler, or tcl, you make the call).
  8737.   // Anyway, to get around it, you either use the setVar2 version, or
  8738.   // you make sure that the string you hand into setVar is writable.
  8739.   // gak...
  8740.  
  8741.   // 
  8742.   strcpy(varName, "scene(incr)");
  8743.   sprintf(valAsString, "%d", [self sceneIncr]); // turn the value into its tcl equivalent
  8744.   //[tclInterp setVar:varName toReadOnlyValue:valAsString]; // don't do this as it sets up a write trace we don't need
  8745.   [tclInterp setVar:varName toValue:valAsString];
  8746.   [tclInterp traceWritesOn:varName andCall:(Tcl_VarTraceProc *)WriteProcForSceneIncr usingData:(ClientData)self];
  8747.   [tclInterp traceReadsOn:varName andCall:(Tcl_VarTraceProc *)ReadProcForSceneIncr usingData:(ClientData)self];
  8748.  
  8749.   // RIB bindings
  8750.   [tclInterp addCommand:"version" :cmd_noop :self];
  8751.   [tclInterp addCommand:"render" :cmd_render :self];
  8752.   [tclInterp addCommand:"massageRIB" :cmd_massageRIB :self];
  8753.  
  8754.   [tclInterp addCommand:"Declare" :cmd_RiDeclare :self];
  8755.   [tclInterp addCommand:"Begin" :cmd_RiBegin :self];
  8756.   [tclInterp addCommand:"End" :cmd_RiEnd :self];
  8757.   [tclInterp addCommand:"FrameBegin" :cmd_noop :self];
  8758.   [tclInterp addCommand:"FrameEnd" :cmd_noop :self];
  8759.   [tclInterp addCommand:"WorldBegin" :cmd_RiWorldBegin :self];
  8760.   [tclInterp addCommand:"WorldEnd" :cmd_RiWorldEnd :self];
  8761.   [tclInterp addCommand:"Format" :cmd_noop :self];
  8762.   [tclInterp addCommand:"FrameAspectRatio" :cmd_noop :self];
  8763.   [tclInterp addCommand:"ScreenWindow" :cmd_noop :self];
  8764.   [tclInterp addCommand:"CropWindow" :cmd_noop :self];
  8765.   [tclInterp addCommand:"Clipping" :cmd_noop :self];
  8766.   [tclInterp addCommand:"DepthOfField" :cmd_noop :self];
  8767.   [tclInterp addCommand:"Shutter" :cmd_noop :self];
  8768.   [tclInterp addCommand:"PixelVariance" :cmd_noop :self];
  8769.   [tclInterp addCommand:"PixelSamples" :cmd_noop :self];
  8770.   [tclInterp addCommand:"PixelFilter" :cmd_noop :self];
  8771.   [tclInterp addCommand:"Exposure" :cmd_noop :self];
  8772.   [tclInterp addCommand:"Quantize" :cmd_noop :self];
  8773.   [tclInterp addCommand:"ColorSamples" :cmd_RiColorSamples :self];
  8774.   [tclInterp addCommand:"RelativeDetail" :cmd_noop :self];
  8775.   [tclInterp addCommand:"AttributeBegin" :cmd_RiAttributeBegin :self];
  8776.   [tclInterp addCommand:"AttributeEnd" :cmd_RiAttributeEnd :self];
  8777.   [tclInterp addCommand:"Color" :cmd_RiColor :self];
  8778.   [tclInterp addCommand:"Opacity" :cmd_RiOpacity :self];
  8779.   [tclInterp addCommand:"TextureCoordinates" :cmd_RiTextureCoordinates :self];
  8780.   [tclInterp addCommand:"Illuminate" :cmd_RiIlluminate :self];
  8781.   [tclInterp addCommand:"ShadingRate" :cmd_RiShadingRate :self];
  8782.   [tclInterp addCommand:"ShadingInterpolation" :cmd_RiShadingInterpolation :self];
  8783.   [tclInterp addCommand:"Matte" :cmd_RiMatte :self];
  8784.   [tclInterp addCommand:"Bound" :cmd_RiBound :self];
  8785.   [tclInterp addCommand:"Detail" :cmd_noop :self];
  8786.   [tclInterp addCommand:"DetailRange" :cmd_noop :self];
  8787.   [tclInterp addCommand:"GeometricApproximation" :cmd_RiGeometricApproximation :self];
  8788.   [tclInterp addCommand:"Orientation" :cmd_RiOrientation :self];
  8789.   [tclInterp addCommand:"ReverseOrientation" :cmd_RiReverseOrientation :self];
  8790.   [tclInterp addCommand:"Sides" :cmd_RiSides :self];
  8791.   [tclInterp addCommand:"Identity" :cmd_RiIdentity :self];
  8792.   [tclInterp addCommand:"Transform" :cmd_RiTransform :self];
  8793.   [tclInterp addCommand:"ConcatTransform" :cmd_RiConcatTransform :self];
  8794.   [tclInterp addCommand:"Perspective" :cmd_RiPerspective :self];
  8795.   [tclInterp addCommand:"Translate" :cmd_RiTranslate :self];
  8796.   [tclInterp addCommand:"Rotate" :cmd_RiRotate :self];
  8797.   [tclInterp addCommand:"Scale" :cmd_RiScale :self];
  8798.   [tclInterp addCommand:"Skew" :cmd_RiSkew :self];
  8799.   [tclInterp addCommand:"CoordinateSystem" :cmd_RiCoordinateSystem :self];
  8800.   [tclInterp addCommand:"TransformPoints" :cmd_noop :self];
  8801.   [tclInterp addCommand:"TransformBegin" :cmd_RiTransformBegin :self];
  8802.   [tclInterp addCommand:"TransformEnd" :cmd_RiTransformEnd :self];
  8803.   [tclInterp addCommand:"Attribute" :cmd_RiAttribute :self];
  8804.   [tclInterp addCommand:"SolidBegin" :cmd_RiSolidBegin :self];
  8805.   [tclInterp addCommand:"SolidEnd" :cmd_RiSolidEnd :self];
  8806.   [tclInterp addCommand:"ObjectBegin" :cmd_RiObjectBegin :self];
  8807.   [tclInterp addCommand:"ObjectEnd" :cmd_RiObjectEnd :self];
  8808.   [tclInterp addCommand:"ObjectInstance" :cmd_RiObjectInstance :self];
  8809.   [tclInterp addCommand:"MotionBegin" :cmd_RiMotionBegin :self];
  8810.   [tclInterp addCommand:"MotionEnd" :cmd_RiMotionEnd :self];
  8811.   [tclInterp addCommand:"Projection" :cmd_noop :self];
  8812.   [tclInterp addCommand:"Imager" :cmd_RiImager :self];
  8813.   [tclInterp addCommand:"Display" :cmd_noop :self];
  8814.   [tclInterp addCommand:"Hider" :cmd_RiHider :self];
  8815.   [tclInterp addCommand:"LightSource" :cmd_RiLightSource :self];
  8816.   [tclInterp addCommand:"AreaLightSource" :cmd_RiAreaLightSource :self];
  8817.   [tclInterp addCommand:"Surface" :cmd_RiSurface :self];
  8818.   [tclInterp addCommand:"Atmosphere" :cmd_RiAtmosphere :self];
  8819.   [tclInterp addCommand:"Interior" :cmd_RiInterior :self];
  8820.   [tclInterp addCommand:"Exterior" :cmd_RiExterior :self];
  8821.   [tclInterp addCommand:"Deformation" :cmd_RiDeformation :self];
  8822.   [tclInterp addCommand:"Displacement" :cmd_RiDisplacement :self];
  8823.   [tclInterp addCommand:"Polygon" :cmd_RiPolygon :self];
  8824.   [tclInterp addCommand:"GeneralPolygon" :cmd_RiGeneralPolygon :self];
  8825.   [tclInterp addCommand:"PointsPolygons" :cmd_RiPointsPolygons :self];
  8826.   [tclInterp addCommand:"PointsGeneralPolygons" :cmd_RiPointsGeneralPolygons :self];
  8827.   [tclInterp addCommand:"Basis" :cmd_RiBasis :self];
  8828.   [tclInterp addCommand:"Patch" :cmd_RiPatch :self];
  8829.   [tclInterp addCommand:"PatchMesh" :cmd_RiPatchMesh :self];
  8830.   [tclInterp addCommand:"NuPatch" :cmd_RiNuPatch :self];
  8831.   [tclInterp addCommand:"Sphere" :cmd_RiSphere :self];
  8832.   [tclInterp addCommand:"Cone" :cmd_RiCone :self];
  8833.   [tclInterp addCommand:"Cylinder" :cmd_RiCylinder :self];
  8834.   [tclInterp addCommand:"Hyperboloid" :cmd_RiHyperboloid :self];
  8835.   [tclInterp addCommand:"Paraboloid" :cmd_RiParaboloid :self];
  8836.   [tclInterp addCommand:"Disk" :cmd_RiDisk :self];
  8837.   [tclInterp addCommand:"Torus" :cmd_RiTorus :self];
  8838.  
  8839.   [tclInterp addCommand:"TrimCurve" :cmd_RiTrimCurve :self];
  8840.   [tclInterp addCommand:"Geometry" :cmd_RiGeometry :self];
  8841.   [tclInterp addCommand:"GeometricRepresentation" :cmd_noop :self];
  8842.   [tclInterp addCommand:"Option" :cmd_RiOption :self];
  8843.  
  8844.   [tclInterp addCommand:"MakeTexture" :cmd_RiMakeTexture :self];
  8845.   [tclInterp addCommand:"MakeBump" :cmd_noop :self];
  8846.   [tclInterp addCommand:"MakeLatLongEnvironment" :cmd_noop :self];
  8847.   [tclInterp addCommand:"MakeCubeFaceEnvironment" :cmd_noop :self];
  8848.   [tclInterp addCommand:"MakeShadow" :cmd_noop :self];
  8849.   [tclInterp addCommand:"ErrorHandler" :cmd_noop :self];
  8850.   [tclInterp addCommand:"ArchiveRecord" :cmd_RiArchiveRecord :self];
  8851.  
  8852.   // Ri bindings, i.e. like the C bindings
  8853.   [tclInterp addCommand:"RiDeclare" :cmd_RiDeclare :self];
  8854.   [tclInterp addCommand:"RiBegin" :cmd_RiBegin :self];
  8855.   [tclInterp addCommand:"RiEnd" :cmd_RiEnd :self];
  8856.   [tclInterp addCommand:"RiFrameBegin" :cmd_noop :self];
  8857.   [tclInterp addCommand:"RiFrameEnd" :cmd_noop :self];
  8858.   [tclInterp addCommand:"RiWorldBegin" :cmd_RiWorldBegin :self];
  8859.   [tclInterp addCommand:"RiWorldEnd" :cmd_RiWorldEnd :self];
  8860.   [tclInterp addCommand:"RiFormat" :cmd_noop :self];
  8861.   [tclInterp addCommand:"RiFrameAspectRatio" :cmd_noop :self];
  8862.   [tclInterp addCommand:"RiScreenWindow" :cmd_noop :self];
  8863.   [tclInterp addCommand:"RiCropWindow" :cmd_noop :self];
  8864.   [tclInterp addCommand:"RiClipping" :cmd_noop :self];
  8865.   [tclInterp addCommand:"RiDepthOfField" :cmd_noop :self];
  8866.   [tclInterp addCommand:"RiShutter" :cmd_noop :self];
  8867.   [tclInterp addCommand:"RiPixelVariance" :cmd_noop :self];
  8868.   [tclInterp addCommand:"RiPixelSamples" :cmd_noop :self];
  8869.   [tclInterp addCommand:"RiPixelFilter" :cmd_noop :self];
  8870.   [tclInterp addCommand:"RiExposure" :cmd_noop :self];
  8871.   [tclInterp addCommand:"RiQuantize" :cmd_noop :self];
  8872.   [tclInterp addCommand:"RiColorSamples" :cmd_RiColorSamples :self];
  8873.   [tclInterp addCommand:"RiRelativeDetail" :cmd_noop :self];
  8874.   [tclInterp addCommand:"RiAttributeBegin" :cmd_RiAttributeBegin :self];
  8875.   [tclInterp addCommand:"RiAttributeEnd" :cmd_RiAttributeEnd :self];
  8876.   [tclInterp addCommand:"RiColor" :cmd_RiColor :self];
  8877.   [tclInterp addCommand:"RiOpacity" :cmd_RiOpacity :self];
  8878.   [tclInterp addCommand:"RiTextureCoordinates" :cmd_RiTextureCoordinates :self];
  8879.   [tclInterp addCommand:"RiIlluminate" :cmd_RiIlluminate :self];
  8880.   [tclInterp addCommand:"RiShadingRate" :cmd_RiShadingRate :self];
  8881.   [tclInterp addCommand:"RiShadingInterpolation" :cmd_RiShadingInterpolation :self];
  8882.   [tclInterp addCommand:"RiMatte" :cmd_RiMatte :self];
  8883.   [tclInterp addCommand:"RiBound" :cmd_RiBound :self];
  8884.   [tclInterp addCommand:"RiDetail" :cmd_noop :self];
  8885.   [tclInterp addCommand:"RiDetailRange" :cmd_noop :self];
  8886.   [tclInterp addCommand:"RiGeometricApproximation" :cmd_RiGeometricApproximation :self];
  8887.   [tclInterp addCommand:"RiOrientation" :cmd_RiOrientation :self];
  8888.   [tclInterp addCommand:"RiReverseOrientation" :cmd_RiReverseOrientation :self];
  8889.   [tclInterp addCommand:"RiSides" :cmd_RiSides :self];
  8890.   [tclInterp addCommand:"RiIdentity" :cmd_RiIdentity :self];
  8891.   [tclInterp addCommand:"RiTransform" :cmd_RiTransform :self];
  8892.   [tclInterp addCommand:"RiConcatTransform" :cmd_RiConcatTransform :self];
  8893.   [tclInterp addCommand:"RiPerspective" :cmd_RiPerspective :self];
  8894.   [tclInterp addCommand:"RiTranslate" :cmd_RiTranslate :self];
  8895.   [tclInterp addCommand:"RiRotate" :cmd_RiRotate :self];
  8896.   [tclInterp addCommand:"RiScale" :cmd_RiScale :self];
  8897.   [tclInterp addCommand:"RiSkew" :cmd_noop :self];
  8898.   [tclInterp addCommand:"RiCoordinateSystem" :cmd_RiCoordinateSystem :self];
  8899.   [tclInterp addCommand:"RiTransformPoints" :cmd_noop :self];
  8900.   [tclInterp addCommand:"RiTransformBegin" :cmd_RiTransformBegin :self];
  8901.   [tclInterp addCommand:"RiTransformEnd" :cmd_RiTransformEnd :self];
  8902.   [tclInterp addCommand:"RiAttribute" :cmd_RiAttribute :self];
  8903.   [tclInterp addCommand:"RiSolidBegin" :cmd_RiSolidBegin :self];
  8904.   [tclInterp addCommand:"RiSolidEnd" :cmd_RiSolidEnd :self];
  8905.   [tclInterp addCommand:"RiObjectBegin" :cmd_RiObjectBegin :self];
  8906.   [tclInterp addCommand:"RiObjectEnd" :cmd_RiObjectEnd :self];
  8907.   [tclInterp addCommand:"RiObjectInstance" :cmd_RiObjectInstance :self];
  8908.   [tclInterp addCommand:"RiMotionBegin" :cmd_noop :self];
  8909.   [tclInterp addCommand:"RiMotionEnd" :cmd_noop :self];
  8910.   [tclInterp addCommand:"RiProjection" :cmd_noop :self];
  8911.   [tclInterp addCommand:"RiImager" :cmd_RiImager :self];
  8912.   [tclInterp addCommand:"RiDisplay" :cmd_noop :self];
  8913.   [tclInterp addCommand:"RiHider" :cmd_RiHider :self];
  8914.   [tclInterp addCommand:"RiLightSource" :cmd_RiLightSource :self];
  8915.   [tclInterp addCommand:"RiAreaLightSource" :cmd_RiAreaLightSource :self];
  8916.   [tclInterp addCommand:"RiSurface" :cmd_RiSurface :self];
  8917.   [tclInterp addCommand:"RiAtmosphere" :cmd_RiAtmosphere :self];
  8918.   [tclInterp addCommand:"RiInterior" :cmd_RiInterior :self];
  8919.   [tclInterp addCommand:"RiExterior" :cmd_RiExterior :self];
  8920.   [tclInterp addCommand:"RiDeformation" :cmd_RiDeformation :self];
  8921.   [tclInterp addCommand:"RiDisplacement" :cmd_RiDisplacement :self];
  8922.   [tclInterp addCommand:"RiPolygon" :cmd_RiPolygon :self];
  8923.   [tclInterp addCommand:"RiGeneralPolygon" :cmd_RiGeneralPolygon :self];
  8924.   [tclInterp addCommand:"RiPointsPolygons" :cmd_RiPointsPolygons :self];
  8925.   [tclInterp addCommand:"RiPointsGeneralPolygons" :cmd_RiPointsGeneralPolygons :self];
  8926.   [tclInterp addCommand:"RiBasis" :cmd_RiBasis :self];
  8927.   [tclInterp addCommand:"RiPatch" :cmd_RiPatch :self];
  8928.   [tclInterp addCommand:"RiPatchMesh" :cmd_RiPatchMesh :self];
  8929.   [tclInterp addCommand:"RiNuPatch" :cmd_RiNuPatch :self];
  8930.   [tclInterp addCommand:"RiSphere" :cmd_RiSphere :self];
  8931.   [tclInterp addCommand:"RiCone" :cmd_RiCone :self];
  8932.   [tclInterp addCommand:"RiCylinder" :cmd_RiCylinder :self];
  8933.   [tclInterp addCommand:"RiHyperboloid" :cmd_RiHyperboloid :self];
  8934.   [tclInterp addCommand:"RiParaboloid" :cmd_RiParaboloid :self];
  8935.   [tclInterp addCommand:"RiDisk" :cmd_RiDisk :self];
  8936.   [tclInterp addCommand:"RiTorus" :cmd_RiTorus :self];
  8937.  
  8938.   [tclInterp addCommand:"RiTrimCurve" :cmd_RiTrimCurve :self];
  8939.   [tclInterp addCommand:"RiGeometry" :cmd_RiGeometry :self];
  8940.   [tclInterp addCommand:"RiGeometricRepresentation" :cmd_noop :self];
  8941.   [tclInterp addCommand:"RiOption" :cmd_RiOption :self];
  8942.  
  8943.   [tclInterp addCommand:"RiMakeTexture" :cmd_RiMakeTexture :self];
  8944.   [tclInterp addCommand:"RiMakeBump" :cmd_noop :self];
  8945.   [tclInterp addCommand:"RiMakeLatLongEnvironment" :cmd_noop :self];
  8946.   [tclInterp addCommand:"RiMakeCubeFaceEnvironment" :cmd_noop :self];
  8947.   [tclInterp addCommand:"RiMakeShadow" :cmd_noop :self];
  8948.   [tclInterp addCommand:"RiErrorHandler" :cmd_noop :self];
  8949.   [tclInterp addCommand:"RiArchiveRecord" :cmd_RiArchiveRecord :self];
  8950.  
  8951.   // because MacroModel is still lame, I have these bindings...
  8952.   [tclInterp addCommand:"surface" :cmd_RiSurface :self];
  8953.   [tclInterp addCommand:"color" :cmd_RiColor :self];
  8954.   [tclInterp addCommand:"opacity" :cmd_RiOpacity :self];
  8955.  
  8956.   //new, weird eve commands...
  8957.   [tclInterp addCommand:"articulatedVariableChangesAs" :cmd_articulatedVariableChangesAs :self];
  8958.   [tclInterp addCommand:"aVariableChangesAs" :cmd_articulatedVariableChangesAs :self];
  8959.  
  8960.   [tclInterp addCommand:"defineClass:" :cmd_defineClass :self];
  8961.  
  8962.   [tclInterp addCommand:"Mutable" :cmd_EveProc :self];
  8963.   [tclInterp addCommand:"Mutable:" :cmd_EveProc :self];
  8964.   [tclInterp addCommand:"mutable" :cmd_EveProc :self];
  8965.   [tclInterp addCommand:"mutable:" :cmd_EveProc :self];
  8966.  
  8967.   [tclInterp addCommand:"Animatable" :cmd_EveProc :self];
  8968.   [tclInterp addCommand:"Animatable:" :cmd_EveProc :self];
  8969.   [tclInterp addCommand:"animatable" :cmd_EveProc :self];
  8970.   [tclInterp addCommand:"animatable:" :cmd_EveProc :self];
  8971.  
  8972.   [tclInterp addCommand:"EveCmd" :cmd_EveCmd :self];
  8973.   [tclInterp addCommand:"eveCmd" :cmd_EveCmd :self];
  8974.   [tclInterp addCommand:"aCmd" :cmd_EveCmd :self];
  8975.   [tclInterp addCommand:"ACmd" :cmd_EveCmd :self];
  8976.   [tclInterp addCommand:"articulatedCmd" :cmd_EveCmd :self];
  8977.   [tclInterp addCommand:"ArticulatedCmd" :cmd_EveCmd :self];
  8978.  
  8979.   [tclInterp addCommand:"EveProc" :cmd_EveProc :self];
  8980.   [tclInterp addCommand:"eveProc" :cmd_EveProc :self];
  8981.   [tclInterp addCommand:"aProc" :cmd_EveProc :self];
  8982.   [tclInterp addCommand:"AProc" :cmd_EveProc :self];
  8983.   [tclInterp addCommand:"articulatedProc" :cmd_EveProc :self];
  8984.   [tclInterp addCommand:"ArticulatedProc" :cmd_EveProc :self];
  8985.  
  8986.   [tclInterp addCommand:"wwSet" :cmd_WWSet :self];
  8987.   [tclInterp addCommand:"eSet" :cmd_WWSet :self];
  8988.   [tclInterp addCommand:"modelSet" :cmd_WWSet :self];
  8989.  
  8990.   [tclInterp addCommand:"ApplyToCTM" :cmd_ApplyToCTM :self];
  8991.   [tclInterp addCommand:"applyToCTM" :cmd_ApplyToCTM :self];
  8992.  
  8993.   [tclInterp addCommand:"startShape" :cmd_StartShape :self];
  8994.   [tclInterp addCommand:"startRootShape" :cmd_StartRootShape :self];
  8995.   [tclInterp addCommand:"endShape" :cmd_RiAttributeEnd :self];
  8996.   [tclInterp addCommand:"endShape" :cmd_EndShape :self];
  8997.   [tclInterp addCommand:"installRootShape" :cmd_InstallRootShape :self];
  8998.   [tclInterp addCommand:"startLight" :cmd_StartLight :self];
  8999.   [tclInterp addCommand:"startAmbientLight" :cmd_StartAmbientLight :self];
  9000.   [tclInterp addCommand:"startDistantLight" :cmd_StartDistantLight :self];
  9001.   [tclInterp addCommand:"startPointLight" :cmd_StartPointLight :self];
  9002.   [tclInterp addCommand:"startSpotLight" :cmd_StartSpotLight :self];
  9003.   [tclInterp addCommand:"endLight" :cmd_RiAttributeEnd :self];
  9004.  
  9005.   [tclInterp addCommand:"updateView" :cmd_updateView :self];
  9006.   [tclInterp addCommand:"display" :cmd_updateView :self];
  9007.   [tclInterp addCommand:"synchWithScene" :cmd_synchWithScene :self];
  9008.   [tclInterp addCommand:"synchWithSceneInvisibly" :cmd_synchWithSceneInvisibly :self];
  9009.   [tclInterp addCommand:"camera" :cmd_camera :self];
  9010.  
  9011.   [tclInterp addCommand:"treatAttributeBeginLikeStartShape" :cmd_TreatAttributeBeginLikeStartShape :self];
  9012.   [tclInterp addCommand:"treatTransformBeginLikeAttributeBegin" :cmd_TreatTransformBeginLikeAttributeBegin :self];
  9013.   [tclInterp addCommand:"applyShadersDirectlyToCurrentShape" :cmd_ApplyShadersDirectlyToCurrentShape :self];
  9014.  
  9015.   // compound commands go here...
  9016.   [tclInterp addCommand:"WW3DText" :cmd_WW3DText :self];
  9017.   [tclInterp addCommand:"WW3DSquishySphere" :cmd_WW3DSquishySphere :self];
  9018.  
  9019.   evaluatingEveCommand = 0;
  9020.   tmpRIBCommand = nil;
  9021.  
  9022.   return self;
  9023. }
  9024.  
  9025. - init
  9026. {
  9027.   [super init];
  9028.  
  9029.   tclInterp = [[WWInterp alloc] init];
  9030.   [tclInterp setRunTime:self];
  9031.  
  9032.   // do this first, pal...
  9033.   sceneIncr = 1;
  9034.  
  9035.   [self initWWEveParser];
  9036.  
  9037.   eveProcList = [[List alloc] init];
  9038.   sampleGeneratorInfoList = [[List alloc] init];
  9039.   currentSampleGeneratorInfo = nil;
  9040.  
  9041.   rib_var_list = list_open(1);
  9042.   rib_parm_list = list_open(1);
  9043.   rib_light_list = list_open(1);
  9044.   rib_object_list = list_open(1);
  9045.   currentShape = rootShape = nil;
  9046.   ignoreColors = ignoreLights = ignoreShaders = NO;
  9047.   ignoreShadingRate = YES;
  9048.   rootShapeInUse = NO;
  9049.   firmTransforms = NO;
  9050.   treatAttributeBeginLikeStartShape = YES;
  9051.   treatTransformBeginLikeAttributeBegin = NO;
  9052.   applyShadersDirectlyToCurrentShape = YES;
  9053.   evaluatingEveProc = NO;
  9054.   riBegun = NO;
  9055.  
  9056.   uniqueTag = 0;
  9057.   cmdBufSize = 4096;
  9058.   cmdBuf = (char *)NXZoneCalloc([self zone], cmdBufSize, sizeof(char));
  9059.   if (!cmdBuf)
  9060.   {  return nil;
  9061.   }
  9062.  
  9063.   statusBufSize = 256;
  9064.   statusBuf = (char *)NXZoneCalloc([self zone], statusBufSize, sizeof(char));
  9065.   if (!statusBuf)
  9066.   {  return nil;
  9067.   }
  9068.  
  9069.   lastTimesLength = 256;
  9070.   lastTimesIndex = 0;
  9071.   lastTimes = (float *)malloc(sizeof(float) * lastTimesLength);
  9072.   if (!lastTimes)
  9073.   {  return nil;
  9074.   }
  9075.  
  9076.   articulatedVariablesBehaviorList = [[List alloc] init];
  9077.  
  9078.   return self;
  9079. }
  9080.  
  9081. - awake
  9082. {
  9083.   [super awake];
  9084.  
  9085.   // tclInterp should have been archived
  9086.   [tclInterp setRunTime:self];
  9087.  
  9088.   // WAVE: this should be archived!
  9089.   sceneIncr = 1;
  9090.   sampleGeneratorInfoList = [[List alloc] init];
  9091.   currentSampleGeneratorInfo = nil;
  9092.  
  9093.   [self initWWEveParser];
  9094.  
  9095.   // eveProcList should have been archived
  9096.   // WAVE!!
  9097.   // really should synch up internal state of the tcl interp with the eveProcList...
  9098.   // this won't be an issue yet, but should be done eventually.
  9099.   // also need to think this through for WW3DCamera
  9100.  
  9101.   rib_var_list = list_open(1);
  9102.   rib_parm_list = list_open(1);
  9103.   rib_light_list = list_open(1);
  9104.   rib_object_list = list_open(1);
  9105.   currentShape = rootShape = nil;
  9106.   rootShapeInUse = NO;
  9107.   firmTransforms = NO;
  9108.   treatTransformBeginLikeAttributeBegin = NO;
  9109.   riBegun = NO;
  9110.  
  9111.   uniqueTag = 0;
  9112.   cmdBufSize = 4096;
  9113.   cmdBuf = (char *)malloc(cmdBufSize);
  9114.   if (!cmdBuf)
  9115.   {  return nil;
  9116.   }
  9117.   statusBufSize = 256;
  9118.   statusBuf = (char *)NXZoneCalloc([self zone], statusBufSize, sizeof(char));
  9119.   if (!statusBuf)
  9120.   {  return nil;
  9121.   }
  9122.  
  9123.   // WAVE!  these should be archived...
  9124.   sceneIncr = 1;
  9125.  
  9126.   lastTimesLength = 256;
  9127.   lastTimesIndex = 0;
  9128.   lastTimes = (float *)malloc(sizeof(float) * lastTimesLength);
  9129.   if (!lastTimes)
  9130.   {  return nil;
  9131.   }
  9132.  
  9133.   articulatedVariablesBehaviorList = [[List alloc] init];
  9134.  
  9135.   return self;
  9136. }
  9137.  
  9138. - free
  9139. {
  9140.  
  9141.   //NXLogError("freeing WWEveParser %p\n", self); 
  9142.   if (!rootShapeInUse)
  9143.   {  [rootShape free];
  9144.   }
  9145.   list_close(rib_var_list);
  9146.   list_close(rib_parm_list);
  9147.   list_close(rib_light_list);
  9148.   list_close(rib_object_list);
  9149.   if (errorWindow)  {  /*NXLogError("freeing errorWindow %p\n", errorWindow);*/ [errorWindow free]; }
  9150.   if (cmdBuf) { /*NXLogError("freeing cmdBuf %p\n", cmdBuf);*/ NXZoneFree([self zone], cmdBuf); }
  9151.   if (statusBuf) { /*NXLogError("freeing statusBuf %p\n", statusBuf);*/ NXZoneFree([self zone], statusBuf); }
  9152.  
  9153.   // make sure you free the tcl interp after the rootShape, because
  9154.   // EveCommands that get free'd will want to untrace their corresponding
  9155.   // tcl variables, and we don't want them sending messages to an already
  9156.   // free'd tclInterp
  9157.   //NXLogError("freeing tclInterp %p\n", tclInterp); 
  9158.   [tclInterp free];
  9159.  
  9160.   if (lastTimesLength)  { free(lastTimes); }
  9161.  
  9162.   return [super free];
  9163. }
  9164.  
  9165.  
  9166. - takeFirmTransforms:sender { firmTransforms = [sender intValue]; return self; }
  9167. - setFirmTransforms:(BOOL)flag { firmTransforms = flag; return self; }
  9168. - (BOOL)firmTransforms { return firmTransforms; }
  9169.  
  9170. - loadErrorWindow
  9171. {
  9172.   id    bundle = [NXBundle bundleForClass: [self class]];
  9173.   char  path[MAXPATHLEN + 1];
  9174.  
  9175.  
  9176.   if (!bundle) 
  9177.   {  NXLogError("No bundle for Class %s - unable to showErrorWindow\n", [self name]);
  9178.      return nil;
  9179.   }
  9180.   if (![bundle getPath:path forResource:"WWEveParserError" ofType:"nib"])
  9181.   {  NXLogError("No path for WWEveParserError.nib.\n");
  9182.      return nil;
  9183.   }
  9184.   [NXApp loadNibFile:path owner:self  withNames:NO fromZone:[self zone]];
  9185.   //NXLogError ("Loaded %s.\n", path);
  9186.  
  9187.   return self;
  9188. }
  9189.  
  9190.  
  9191.  
  9192. - buildNewShapeHierarchyFromRIBFile:(const char *)filename :(BOOL)closeControlsFlag
  9193. {
  9194.   char  tmpBuf[1024], *eveFilename = "/tmp/tmp.eve";
  9195.   //BOOL  oldFlag = [tclInterp showErrors];
  9196.  
  9197.  
  9198.   // blow away anything we loaded from nib files in preparation of new stuff...
  9199.   if (closeControlsFlag)
  9200.   {  [[well camera] setWorldShape:nil];
  9201.      [rootShape free];
  9202.      tmpRootShape = rootShape = currentShape = nil;
  9203.      [tclInterp unloadControlPanels];
  9204.      [[articulatedVariablesBehaviorList makeObjectsPerform:@selector(free)] empty];
  9205.      lastTimesIndex = 0;
  9206.   }
  9207.   else
  9208.   {  tmpRootShape = currentShape = nil;
  9209.   }
  9210.  
  9211.   sprintf(tmpBuf, "render {%s} {%s}", filename, eveFilename);
  9212.  
  9213.   [self setRiBegun:YES];
  9214.   // the "render" command will show any errors...
  9215.   //[tclInterp setShowErrors:NO];
  9216.   if ([tclInterp eval:tmpBuf] != TCL_OK)
  9217.   {  [self setRiBegun:NO];
  9218.      //[tclInterp setShowErrors:oldFlag];
  9219.      return nil;
  9220.   }
  9221.   //[tclInterp setShowErrors:oldFlag];
  9222.   [self setRiBegun:NO];
  9223.  
  9224.   if (!closeControlsFlag)
  9225.   {  return tmpRootShape;
  9226.   }
  9227.  
  9228.   rootShape = tmpRootShape;
  9229.   return rootShape;
  9230. }
  9231.  
  9232. - buildNewShapeHierarchyFromRIBFile:(const char *)filename
  9233. {  return [self buildNewShapeHierarchyFromRIBFile:filename :YES];
  9234. }
  9235.  
  9236.  
  9237. - showError:(char *)error
  9238. {
  9239.   char *errorInfo;
  9240.  
  9241.  
  9242.   if (!errorWindow)
  9243.   {  [self loadErrorWindow];
  9244.   }
  9245.   [errorInfoText setSel:0 :[errorInfoText textLength]];
  9246.   errorInfo = Tcl_GetVar([tclInterp interp], "errorInfo", 0);
  9247.   [errorInfoText replaceSel:errorInfo];
  9248.   [errorWindow center];
  9249.   [errorWindow makeKeyAndOrderFront:self];
  9250.  
  9251.   // should have a button on the window to let them go to the line where the error is...
  9252.   // need to pull out the line number and file from the error
  9253.   // [[Application workspace] openFile:fileName onHost:"" atTrueLine:lineNumber];
  9254.  
  9255.   return self;
  9256. }
  9257.  
  9258. - buildNewShapeHierarchyFromEveFile:(const char *)filename :(BOOL)closeControlsFlag
  9259. {
  9260.   char  tmpBuf[1024];
  9261.   //BOOL  oldFlag = [tclInterp showErrors];
  9262.  
  9263.  
  9264.   if (closeControlsFlag)
  9265.   {  [[well camera] setWorldShape:nil];
  9266.      [rootShape free];
  9267.      tmpRootShape = rootShape = currentShape = nil;
  9268.      [tclInterp unloadControlPanels];
  9269.      [[articulatedVariablesBehaviorList makeObjectsPerform:@selector(free)] empty];
  9270.      lastTimesIndex = 0;
  9271.   }
  9272.   else
  9273.   {  tmpRootShape = currentShape = nil;
  9274.   }
  9275.  
  9276.   sprintf(tmpBuf, "render {%s} {}", filename);
  9277.  
  9278.   [self setRiBegun:YES];
  9279.   // the "render" command will show any errors...
  9280.   //[tclInterp setShowErrors:NO];
  9281.   if ([tclInterp eval:tmpBuf] != TCL_OK)
  9282.   {   [self setRiBegun:NO];
  9283.      //[tclInterp setShowErrors:oldFlag];
  9284.      return nil;
  9285.   }
  9286.   //[tclInterp setShowErrors:oldFlag];
  9287.   [self setRiBegun:NO];
  9288.  
  9289.   if (!closeControlsFlag)
  9290.   {  return tmpRootShape;
  9291.   }
  9292.  
  9293.   rootShape = tmpRootShape;
  9294.   return rootShape;
  9295. }
  9296.  
  9297. - buildNewShapeHierarchyFromEveFile:(const char *)filename
  9298. {  return [self buildNewShapeHierarchyFromEveFile:filename :YES];
  9299. }
  9300.  
  9301.  
  9302. - evaluateEveFile:(const char *)filename
  9303. {
  9304.   char  tmpBuf[MAXPATHLEN + 12], *retBuf;
  9305.   int   ret;
  9306.   //BOOL  oldFlag = [tclInterp showErrors];
  9307.  
  9308.  
  9309.   sprintf(tmpBuf, "source %s", filename);
  9310.   //[tclInterp setShowErrors:NO];
  9311.   retBuf = [tclInterp eval:tmpBuf :&ret];
  9312.   if (ret != TCL_OK)
  9313.   {  [self showError:retBuf];
  9314.      if (retBuf) { free(retBuf); }
  9315.      //[tclInterp setShowErrors:oldFlag];
  9316.      return nil;
  9317.   }
  9318.   //[tclInterp setShowErrors:oldFlag];
  9319.  
  9320.   if (retBuf) { free(retBuf); }
  9321.   return self;
  9322. }
  9323.  
  9324. - closeErrorWindow:sender
  9325. {
  9326.   [errorWindow close];
  9327.  
  9328.   return self;
  9329. }
  9330.  
  9331. - evaluateArticulatedVariablesBehaviorAt:(float)currentTime
  9332. {
  9333.    int   i, howMany = [articulatedVariablesBehaviorList count];
  9334.    char  *originalUValue = NULL;
  9335.  
  9336.  
  9337.    // should check and see if there's a variable "u" in the current context.
  9338.    // if there is, we should save the value, and restore it at the end.
  9339.    originalUValue = [tclInterp getVar:"u"];
  9340.  
  9341.    // okay, now tell all the variables to behave
  9342.    for (i = 0; i < howMany; i++)
  9343.    {  [[articulatedVariablesBehaviorList objectAt:i] evaluateSelfAtTime:currentTime];
  9344.    }
  9345.  
  9346.    // okay, restore old u value if there was one.
  9347.    if (originalUValue)
  9348.    {  [tclInterp setVar:"u" toValue:originalUValue];
  9349.    }
  9350.  
  9351.    return self;
  9352. }
  9353.  
  9354. - addTimeToLastTimes:(float)currentTime
  9355. {
  9356.    lastTimesIndex++; 
  9357.    while (lastTimesLength <= lastTimesIndex)
  9358.    {  lastTimesLength *= 2; 
  9359.       lastTimes = (float *)realloc(lastTimes, (sizeof(float) * lastTimesLength));
  9360.    }
  9361.    lastTimes[lastTimesIndex] = currentTime;
  9362.    return self;
  9363. }
  9364.  
  9365. - setCurrentTime:(float)currentTime
  9366. {
  9367.    int    j;
  9368.    BOOL   alreadyEvaluatedAtTime = NO;
  9369.  
  9370.  
  9371.    // execute all articulated variable behaviors for this point 
  9372.    //NXLogError("current scene time is %f\n", currentTime);
  9373.  
  9374.    if ([[self articulatedVariablesBehaviorList] count])
  9375.    { j = 0;
  9376.      while ((!alreadyEvaluatedAtTime) && (j <= lastTimesIndex))
  9377.      {  if (lastTimes[j] == currentTime)
  9378.     {  alreadyEvaluatedAtTime = YES;  
  9379.     }
  9380.         else
  9381.         {  j++;
  9382.         }
  9383.      }
  9384.      if (!alreadyEvaluatedAtTime)
  9385.      {  [self evaluateArticulatedVariablesBehaviorAt:currentTime];
  9386.         [self addTimeToLastTimes:currentTime];
  9387.      }
  9388.    }
  9389.  
  9390.    return self;
  9391. }
  9392.  
  9393. - currentShape { return currentShape; }
  9394. - setCurrentShape:newShape { currentShape = newShape; return self; }
  9395.  
  9396. - (BOOL)rootShapeInUse { return rootShapeInUse; }
  9397. - setRootShapeInUse:(BOOL)flag { rootShapeInUse = flag; return self; }
  9398.  
  9399. - (BOOL)frozen { return frozen; }
  9400. - setFrozen:(BOOL)flag { frozen = flag; return self; }
  9401.  
  9402. - rootShape { return rootShape; }
  9403. - setRootShape:newShape 
  9404. { 
  9405.   if (!rootShapeInUse)
  9406.   {  [rootShape free];
  9407.   }
  9408.   rootShape = newShape; 
  9409.   return self; 
  9410. }
  9411.  
  9412. - tmpRootShape { return tmpRootShape; }
  9413. - setTmpRootShape:newShape 
  9414. { 
  9415.   tmpRootShape = newShape; 
  9416.   return self; 
  9417. }
  9418.  
  9419. - incrementEveCommandCounter { evaluatingEveCommand++; return self; }
  9420. - decrementEveCommandCounter
  9421. { evaluatingEveCommand--; 
  9422.   if (evaluatingEveCommand < 0)
  9423.   {  NXLogError("warning: evaluatingEveCommand went below zero (%d)\n", evaluatingEveCommand);
  9424.      evaluatingEveCommand = 0;
  9425.      tmpRIBCommand = nil;
  9426.   }
  9427.   return self; 
  9428. }
  9429.  
  9430. - evaluateEveCommand:(char *)cmd
  9431. {
  9432.   BOOL  tmpFlag;
  9433.   id    theRIBCommand;
  9434.   int   ret;
  9435.  
  9436.  
  9437.   // if the first arg of the cmd is an aproc, we need to malloc up a
  9438.   // new RIBCommandList, stick it in tmRIBCommand and then evaluate the
  9439.   // cmd.
  9440.  
  9441.   if (!evaluatingEveCommand)  // first level of evaluation...
  9442.   {  tmpRIBCommand = nil;
  9443.   }
  9444.   [self incrementEveCommandCounter];
  9445.   tmpFlag = [self riBegun];
  9446.   [self setRiBegun:YES];
  9447.  
  9448.   //[tclInterp eval:cmd];
  9449.   // I know, I know - this is gross that I'm doing a global eval...
  9450.   ret = [tclInterp globalEval:cmd];
  9451.  
  9452.   [self decrementEveCommandCounter];
  9453.   [self setRiBegun:tmpFlag];
  9454.  
  9455.   if (ret == TCL_OK) // everything was hunk dory
  9456.   {  theRIBCommand = tmpRIBCommand;
  9457.   }
  9458.   else
  9459.   {  theRIBCommand = nil;
  9460.   }
  9461.  
  9462.   [self setTmpRIBCommand:nil];
  9463.  
  9464.   return theRIBCommand; 
  9465. }
  9466.  
  9467. void eveProcTrace(clientData, interp, level, command, cmdProc, cmdClientData, argc, argv)
  9468. ClientData clientData;
  9469. Tcl_Interp *interp;
  9470. int level;
  9471. char *command;
  9472. Tcl_CmdProc *cmdProc;
  9473. ClientData cmdClientData;
  9474. int argc;
  9475. char *argv[];
  9476. {
  9477.   [(RIBCommandList *)clientData setEveCodeArgc:argc argv:argv];
  9478.     
  9479.   return ;
  9480. }
  9481.  
  9482. - evaluateEveProc:(char *)cmd
  9483. {
  9484.   BOOL       tmpFlag;
  9485.   id         theRIBCommand;
  9486.   int        ret;
  9487.   Tcl_Trace  theTrace;
  9488.  
  9489.  
  9490.   // if the first arg of the cmd is an aproc, we need to malloc up a
  9491.   // new RIBCommandList, stick it in tmRIBCommand and then evaluate the
  9492.   // cmd.
  9493.  
  9494.   if (!cmd)  // first level of evaluation...
  9495.   {  NXLogError("You asked me to evaluate a NULL EveProc!\n");
  9496.      return nil;
  9497.   }
  9498.   if (evaluatingEveCommand && evaluatingEveProc)  // first level of evaluation...
  9499.   {  NXLogError("You cannot nest calls to EveCmd or EveProc inside an EveProc call!\n");
  9500.      return nil;
  9501.   }
  9502.   tmpRIBCommand = [[RIBCommandList alloc] init];
  9503.   evaluatingEveProc = YES;
  9504.   [self incrementEveCommandCounter];
  9505.   tmpFlag = [self riBegun];
  9506.   [self setRiBegun:YES];
  9507.  
  9508.   // okay, so we need to do a few things here.
  9509.   // we need to install a trace to stick the fully closed args of this into the RIBCommandList
  9510.   // we also want to trap any calls to "global" and return an error there...
  9511.   // actually, we can do both in the trace routine...
  9512.   // actually, that's not a great idea...
  9513.  
  9514.   // note: I'm being evil here - *wave* wrote Tcl_Level()...
  9515.  
  9516.   theTrace = Tcl_CreateTrace([tclInterp interp], 
  9517.                              ((int)evil_Tcl_Level_written_by_wave([tclInterp interp]) + 1), 
  9518.                              (Tcl_CmdTraceProc *)eveProcTrace, tmpRIBCommand);
  9519.   ret = [tclInterp globalEval:cmd];
  9520.   Tcl_DeleteTrace([tclInterp interp], theTrace);
  9521.  
  9522.   [self decrementEveCommandCounter];
  9523.   evaluatingEveProc = NO;
  9524.   [self setRiBegun:tmpFlag];
  9525.   
  9526.   if (ret == TCL_OK) // everything was hunk dory
  9527.   {  theRIBCommand = tmpRIBCommand;
  9528.   }
  9529.   else
  9530.   {  theRIBCommand = nil;
  9531.   }
  9532.  
  9533.   [self setTmpRIBCommand:nil];
  9534.  
  9535.   return theRIBCommand; 
  9536. }
  9537.  
  9538. - setRiBegun:(BOOL)flag  {  riBegun = flag; return self; }
  9539. - (BOOL)riBegun { return riBegun; }
  9540.  
  9541. ////////////////////////////////////////////////////////////
  9542. - setIgnoreColors:sender
  9543. {
  9544.   ignoreColors = [sender intValue];
  9545.   return self;
  9546. }
  9547. - (BOOL)ignoreColors { return ignoreColors; }
  9548.  
  9549. - setIgnoreShadingRate:sender
  9550. {
  9551.   ignoreShadingRate = [sender intValue];
  9552.   return self;
  9553. }
  9554. - (BOOL)ignoreShadingRate { return ignoreShadingRate; }
  9555.  
  9556. - setIgnoreShaders:sender
  9557. {
  9558.   ignoreShaders = [sender intValue];
  9559.   return self;
  9560. }
  9561. - (BOOL)ignoreShaders { return ignoreShaders; }
  9562.  
  9563. - setIgnoreLights:sender
  9564. {
  9565.   ignoreLights = [sender intValue];
  9566.   return self;
  9567. }
  9568. - (BOOL)ignoreLights { return ignoreLights; }
  9569.  
  9570. - tclInterp { return tclInterp; }
  9571.  
  9572. - (int)uniqueTag { return uniqueTag++; }
  9573.  
  9574. - setTmpRIBCommand:newRIBCommand 
  9575. {  //NXLogError("tmpRIBCommand is a <%s>\n", [tmpRIBCommand name]);
  9576.    if (!newRIBCommand)
  9577.    {  // if this is nil, we want to reset things and get out
  9578.       tmpRIBCommand = nil;
  9579.    }
  9580.    else
  9581.    {  if (tmpRIBCommand && [tmpRIBCommand respondsTo:@selector(addObject:)])
  9582.       {  // it's a RIBCommandList, don't blow it away, just add to it... 
  9583.          [tmpRIBCommand addObject:newRIBCommand];
  9584.       }
  9585.       else
  9586.       {  tmpRIBCommand = newRIBCommand; 
  9587.       }
  9588.    }
  9589.    //NXLogError("\tnow it is a <%s>\n", [tmpRIBCommand name]);
  9590.    return self; 
  9591. }
  9592. - tmpRIBCommand { return tmpRIBCommand; }
  9593.  
  9594. - (BOOL)evaluatingEveCommand { return (BOOL)evaluatingEveCommand; }
  9595.  
  9596. - (BOOL)evaluatingEveProc { return (BOOL)evaluatingEveProc; }
  9597.  
  9598. - setEvaluatingEveProc:(BOOL)newFlag
  9599. {
  9600.   evaluatingEveProc = newFlag;
  9601.   if (!evaluatingEveProc)
  9602.   {  [self setTmpRIBCommand:nil];  
  9603.   }
  9604.   return self;
  9605. }
  9606.  
  9607.  
  9608. //
  9609. //
  9610. - (BOOL)treatAttributeBeginLikeStartShape { return treatAttributeBeginLikeStartShape; }
  9611.  
  9612. - setTreatAttributeBeginLikeStartShape:(BOOL)flag 
  9613. {  treatAttributeBeginLikeStartShape = flag; 
  9614.    return self; 
  9615. }
  9616.  
  9617. - takeTreatAttributeBeginLikeStartShape:sender 
  9618. {  treatAttributeBeginLikeStartShape = (BOOL)[sender intValue]; 
  9619.    return self; 
  9620. }
  9621.  
  9622.  
  9623. //
  9624. //
  9625. - (BOOL)treatTransformBeginLikeAttributeBegin { return treatTransformBeginLikeAttributeBegin; }
  9626.  
  9627. - setTreatTransformBeginLikeAttributeBegin:(BOOL)flag 
  9628. {  treatTransformBeginLikeAttributeBegin = flag; 
  9629.    return self; 
  9630. }
  9631.  
  9632. - takeTreatTransformBeginLikeAttributeBegin:sender 
  9633. {  treatTransformBeginLikeAttributeBegin = (BOOL)[sender intValue]; 
  9634.    return self; 
  9635. }
  9636.  
  9637.  
  9638. - (BOOL)applyShadersDirectlyToCurrentShape { return applyShadersDirectlyToCurrentShape; }
  9639.  
  9640. - setApplyShadersDirectlyToCurrentShape:(BOOL)flag 
  9641. {  applyShadersDirectlyToCurrentShape = flag; 
  9642.    return self; 
  9643. }
  9644.  
  9645. - takeApplyShadersDirectlyToCurrentShape:sender; 
  9646. {  applyShadersDirectlyToCurrentShape = (BOOL)[sender intValue]; 
  9647.    return self; 
  9648. }
  9649.  
  9650.  
  9651. - setSceneClock:newSceneClock { sceneClock = newSceneClock; return self; }
  9652. - sceneClock { return sceneClock; }
  9653. - setTicksPerSecond:(float)newTicksPerSecond
  9654. {
  9655.    char  buf[128];
  9656.  
  9657.  
  9658.    sprintf(buf, "%f", newTicksPerSecond);
  9659.    // this is probably bad; it's setting a new trace each time...
  9660.    //[[self tclInterp] setVar2:"scene" :"ticksPerSecond" toReadOnlyValue:buf];
  9661.    //[[self tclInterp] setVar:"ticksPerSecond" toReadOnlyValue:buf];
  9662.    [[self tclInterp] setVar2:"scene" :"ticksPerSecond" toValue:buf];
  9663.    [[self tclInterp] setVar:"ticksPerSecond" toValue:buf];
  9664.    return self;
  9665. }
  9666.  
  9667. // boy, this is a hack...
  9668. - setViewToUpdate:aView { viewToUpdate = aView; return self; }
  9669. - updateView { [viewToUpdate display]; return self; }
  9670.  
  9671. - camera { return viewToUpdate; }
  9672.  
  9673. - synchViewWithSceneClock 
  9674. { 
  9675.    [well synchCameraToSceneClock];
  9676.    //[viewToUpdate display]; 
  9677.    return self; 
  9678. }
  9679.  
  9680. - setWell:aWell { well = aWell; return self; }
  9681. - installRootShapeInWell 
  9682. { 
  9683.    if (tmpRootShape) 
  9684.    {  [well setWorldShape:tmpRootShape]; 
  9685.       rootShape = tmpRootShape;
  9686.       [self updateView];
  9687.       return self;
  9688.    } 
  9689.    return nil; 
  9690. }
  9691.  
  9692. - setStatusText:newStatusText { statusText = newStatusText; return self; }
  9693. - statusText { return statusText; }
  9694.  
  9695. - (const char *)currentSampleGeneratorName 
  9696. { 
  9697.   if (currentSampleGeneratorInfo)
  9698.   {  return [currentSampleGeneratorInfo name];
  9699.   }
  9700.   return NULL;
  9701. }
  9702.  
  9703. - (float)currentSampleWeight 
  9704. { 
  9705.   if (currentSampleGeneratorInfo)
  9706.   {  return [currentSampleGeneratorInfo weight];
  9707.   }
  9708.   return 1.0;
  9709. }
  9710.  
  9711. - registerCurrentSampleGeneratorName:(const char *)newCurrentSampleGeneratorName weight:(float)weight
  9712. {
  9713.    // need to make sure we don't already have one named this
  9714.    BOOL  foundIt = NO;
  9715.    id    info = nil;
  9716.    int   i = 0, 
  9717.          howMany = [sampleGeneratorInfoList count];
  9718.  
  9719.  
  9720.    if (!newCurrentSampleGeneratorName) // don't allow NULL-named ones
  9721.    {  return nil;
  9722.    }
  9723.  
  9724.    // need to look in our sampleGeneratorInfoList and see if we
  9725.    // already know about this guy.  If so, change his weight but leave him alone
  9726.    while (!foundIt && (i < howMany))
  9727.    {  info = [sampleGeneratorInfoList objectAt:i];
  9728.       if (!strcmp(newCurrentSampleGeneratorName, [info name]))
  9729.       {  // got it!
  9730.          foundIt = YES;
  9731.          [info setWeight:weight];
  9732.       }
  9733.       i++;
  9734.    }
  9735.    if (!foundIt)
  9736.    {  // okay, cons a new one up.
  9737.       info = [[[WWSampleGeneratorInfo alloc] init] setName:newCurrentSampleGeneratorName weight:weight];
  9738.       [sampleGeneratorInfoList addObject:info];
  9739.    }
  9740.    return self;
  9741. }
  9742.  
  9743.  
  9744. - setCurrentSampleGeneratorName:(const char *)newCurrentSampleGeneratorName
  9745. {  
  9746.    BOOL  foundIt = NO;
  9747.    int   i = 0, 
  9748.          howMany = [sampleGeneratorInfoList count];
  9749.  
  9750.  
  9751.    if (!newCurrentSampleGeneratorName) // if the new one is NULL, that's easy...
  9752.    {  currentSampleGeneratorInfo = nil;
  9753.       return self;
  9754.    }
  9755.  
  9756.    // need to look in our sampleGeneratorInfoList and see if we
  9757.    // already know about this guy.  If so, swap him in, otherwise cons up a
  9758.    // new one, put it in the list with a default weight, and make that current
  9759.    while (!foundIt && (i < howMany))
  9760.    {  currentSampleGeneratorInfo = [sampleGeneratorInfoList objectAt:i];
  9761.       if (!strcmp(newCurrentSampleGeneratorName, [currentSampleGeneratorInfo name]))
  9762.       {  // got it!
  9763.          foundIt = YES;
  9764.       }
  9765.       i++;
  9766.    }
  9767.    if (!foundIt)
  9768.    {  // okay, cons a new one up.
  9769.       currentSampleGeneratorInfo = [[[WWSampleGeneratorInfo alloc] init] setName:newCurrentSampleGeneratorName weight:1.0];
  9770.       [sampleGeneratorInfoList addObject:currentSampleGeneratorInfo];
  9771.    }
  9772.    return self;
  9773. }
  9774.  
  9775. - articulatedVariablesBehaviorList { return articulatedVariablesBehaviorList; }
  9776.  
  9777. - addArticulatedVariableBehavior:newVarBehavior
  9778. {
  9779.    [articulatedVariablesBehaviorList addObject:newVarBehavior];
  9780.  
  9781.    return self;
  9782. }
  9783.  
  9784. - disableStatusText
  9785. {
  9786.    tmpStatusText = statusText;
  9787.    statusText = nil;
  9788.    return self;
  9789. }
  9790.  
  9791. - reenableStatusText
  9792. {
  9793.    statusText = tmpStatusText;
  9794.    return self;
  9795. }
  9796.  
  9797.  
  9798.  
  9799. #define typeVectorVersion1 "@"
  9800. #define typeValuesVersion1 &tclInterp
  9801.  
  9802. #define typeVectorVersion2 "@cccc"
  9803. #define typeValuesVersion2 &tclInterp, &ignoreColors, &ignoreLights, &ignoreShaders, \
  9804.                    &treatTransformBeginLikeAttributeBegin
  9805.  
  9806. #define typeVector "@cccc@"
  9807. #define typeValues &tclInterp, &ignoreColors, &ignoreLights, &ignoreShaders, \
  9808.                    &treatTransformBeginLikeAttributeBegin, &eveProcList
  9809.  
  9810. - read:(NXTypedStream *)stream 
  9811. {
  9812.    int version;
  9813.    [super read:stream];
  9814.  
  9815. NX_DURING
  9816.    version = NXTypedStreamClassVersion(stream, "WWEveParser");
  9817.    if (version == 0) NXReadTypes(stream,"i",&version), version=1;
  9818.    if (version == 1)
  9819.    {  NXReadTypes(stream, typeVectorVersion1, typeValuesVersion1);
  9820.       ignoreShadingRate = YES;
  9821.       treatAttributeBeginLikeStartShape = YES;
  9822.       treatAttributeBeginLikeStartShape = YES;
  9823.    } 
  9824.    if (version == 2)
  9825.    {  NXReadTypes(stream, typeVectorVersion2, typeValuesVersion2);
  9826.       ignoreShadingRate = YES;
  9827.       treatAttributeBeginLikeStartShape = YES;
  9828.       treatAttributeBeginLikeStartShape = YES;
  9829.    } 
  9830.    if (version == 3)
  9831.    {  NXReadTypes(stream, typeVector, typeValues);
  9832.       ignoreShadingRate = YES;
  9833.       treatAttributeBeginLikeStartShape = YES;
  9834.       treatAttributeBeginLikeStartShape = YES;
  9835.    } 
  9836.    if (version == 4)
  9837.    {  NXReadTypes(stream, typeVector, typeValues);
  9838.       NXReadTypes(stream, "c", &ignoreShadingRate);
  9839.       treatAttributeBeginLikeStartShape = YES;
  9840.       treatAttributeBeginLikeStartShape = YES;
  9841.    } 
  9842.    if (version == 5)
  9843.    {  NXReadTypes(stream, typeVector, typeValues);
  9844.       NXReadTypes(stream, "c", &ignoreShadingRate);
  9845.       NXReadTypes(stream, "c", &treatAttributeBeginLikeStartShape);
  9846.       treatAttributeBeginLikeStartShape = YES;
  9847.    } 
  9848.    if (version == 6)
  9849.    {  NXReadTypes(stream, typeVector, typeValues);
  9850.       NXReadTypes(stream, "c", &ignoreShadingRate);
  9851.       NXReadTypes(stream, "c", &treatAttributeBeginLikeStartShape);
  9852.       NXReadTypes(stream, "c", &applyShadersDirectlyToCurrentShape);
  9853.    } 
  9854. NX_HANDLER
  9855.    NXLogError("in read: %s, exception [%d] raised.\n", 
  9856.                  [[self class] name], NXLocalHandler.code);
  9857.    return nil;
  9858. NX_ENDHANDLER
  9859.    return self;
  9860. }
  9861.  
  9862. - write:(NXTypedStream *)stream 
  9863. {
  9864.    [super write:stream];
  9865.  
  9866.    NXWriteTypes(stream, typeVector, typeValues);
  9867.    NXWriteTypes(stream, "c", &ignoreShadingRate);
  9868.    NXWriteTypes(stream, "c", &treatAttributeBeginLikeStartShape);
  9869.    NXWriteTypes(stream, "c", &applyShadersDirectlyToCurrentShape);
  9870.  
  9871.    return self;
  9872. }
  9873.  
  9874.  
  9875. @end
  9876.