home *** CD-ROM | disk | FTP | other *** search
/ Photo CD Demo 1 / Demo.bin / graphtal / interprt.c < prev    next >
C/C++ Source or Header  |  1992-11-02  |  20KB  |  891 lines
  1. /* Interpreter.C - methods for turtle interpreter.
  2.  *
  3.  * Copyright (C) 1991, Christoph Streit
  4.  *
  5.  * This software may be freely copied, modified, and redistributed,
  6.  * provided that this copyright notice is preserved on all copies.
  7.  *
  8.  * There is no warranty or other guarantee of fitness for this software,
  9.  * it is provided solely "as is". Bug reports or fixes may be sent
  10.  * to the author, who may or may not act on them as he desires.
  11.  *
  12.  * You may not include this software in a program or other software product
  13.  * without supplying the source, or without informing the end-user that the
  14.  * source is available for no extra charge.
  15.  *
  16.  * If you modify this software, you should include a notice giving the
  17.  * name of the person performing the modification, the date of modification,
  18.  * and the reason for such modification.
  19.  *
  20.  */
  21.  
  22. #include "Interpreter.h"
  23. #include "Options.h"
  24. #include "Polygon.h"
  25. #include "Turtle.h"
  26. #include "DeviceDriver.h"
  27. #include "Module.h"
  28. #include "Hull.h"
  29. #include "boolean.h"
  30.  
  31. #define startBranchSymbol "["
  32. #define endBranchSymbol   "]"
  33.  
  34. #ifdef OLD_STYLE_CPP
  35.  InterpreterFunctions Interpreter::FuncTable[] = {
  36. #else
  37.  Interpreter::InterpreterFunctions Interpreter::FuncTable[] = {
  38. #endif
  39.  
  40.   {"F",               &Interpreter::forward},
  41.   {"wi",              &Interpreter::width},
  42.   {"G",               &Interpreter::go},
  43.   {"f",               &Interpreter::go},
  44.   {"pt",              &Interpreter::pitch},
  45.   {"&",               &Interpreter::pitch_negativ},
  46.   {"^",               &Interpreter::pitch},
  47.   {"ro",              &Interpreter::roll},
  48.   {"\\",              &Interpreter::roll_negativ},
  49.   {"/",               &Interpreter::roll},
  50.   {"tu",              &Interpreter::turn},
  51.   {"+",               &Interpreter::turn_negativ},
  52.   {"-",               &Interpreter::turn},
  53.   {"rv",              &Interpreter::rotate_vertical},
  54.   {"$",               &Interpreter::rotate_vertical},
  55.   {"|",               &Interpreter::reverse},
  56.   {startBranchSymbol, &Interpreter::push},
  57.   {endBranchSymbol,   &Interpreter::pop},
  58.   {"{",               &Interpreter::startPolygon},
  59.   {"sv",              &Interpreter::saveVertex},
  60.   {".",               &Interpreter::saveVertex},
  61.   {"}",               &Interpreter::endPolygon},
  62.   {"t",               &Interpreter::tropism},
  63.   {"we",              &Interpreter::weight},
  64.   {"co",              &Interpreter::color},
  65.   {"sm",              &Interpreter::beginMacro},
  66.   {"em",              &Interpreter::endMacro},
  67.   {"xm",              &Interpreter::executeMacro},
  68.   {"lib",             &Interpreter::libraryObject},
  69.   {"s",               &Interpreter::sphere},
  70.   {"tri",             &Interpreter::triangle},
  71.   {"poly",            &Interpreter::polygon},
  72.   {"ah",              &Interpreter::activateHull},
  73.   {"dh",              &Interpreter::deactivateHull},
  74.   {"cb",              &Interpreter::cutBranchWhenHit},
  75.   {"%",               &Interpreter::cutBranch},
  76.   {"texture",         &Interpreter::texture},
  77.   {"LastFunc",        NULL}
  78. };
  79.  
  80. FP* Interpreter::functable = NULL;
  81. Value Interpreter::turtleX;
  82. Value Interpreter::turtleY;
  83. Value Interpreter::turtleZ;
  84.  
  85. typedef Turtle* TurtlePtr;
  86. declareList(TurtleStack, TurtlePtr)
  87. implementList(TurtleStack, TurtlePtr)
  88.  
  89. //___________________________________________________________ Interpreter
  90.  
  91. Interpreter::Interpreter(DeviceDriver* device, Options* theOptions)
  92. : d(device), options(theOptions),
  93.   t(NULL), m(NULL), ml(NULL), currentModule(-1), saveTurtle(NULL), 
  94.   polyStack(new PolygonList(100)), turtleStack(new TurtleStack(100)),
  95.   definingMacro(FALSE), reflected(FALSE), deleteBranchWhenHit(FALSE)
  96. {
  97.  
  98.   /*
  99.    * Set up function table if not already done.
  100.    */
  101.   if (functable == NULL) {
  102.  
  103.     /*
  104.      * Add all the function names to global name space.
  105.      */
  106.     for (register int i=0; FuncTable[i].function != NULL; i++) 
  107.       FuncTable[i].index = Name::addname(FuncTable[i].name);
  108.  
  109.     functable = new FP[Name::namesCount()];
  110.  
  111.     /*
  112.      * Generate and initialize hash table for function pointers.
  113.      */
  114.     for (i=0; i<Name::namesCount(); i++)
  115.       functable[i] = NULL;
  116.     for (i=0; FuncTable[i].function != NULL; i++)
  117.       functable[FuncTable[i].index] = FuncTable[i].function;
  118.   }
  119.  
  120.   /*
  121.    * Set up analytic tropism functions and hulls.
  122.    */
  123.   tropismX = options->tropismX; 
  124.   tropismY = options->tropismY; 
  125.   tropismZ = options->tropismZ; 
  126.   tropismFunction = 
  127.     (tropismX != NULL) || (tropismY != NULL) || (tropismZ != NULL);
  128.   tropismWeight = options->weight;
  129.   weightFunction = (tropismWeight != NULL);
  130.   h = options->hulls;
  131. }
  132.  
  133. Interpreter::~Interpreter()
  134. {
  135.   delete polyStack;
  136.   delete turtleStack;
  137. }
  138.  
  139. /*
  140.  * Interpret the module string modules using the given dive driver.
  141.  */
  142.  
  143. void Interpreter::interpret(ModuleList* modules)
  144. {
  145.   t = new Turtle; 
  146.   ml = modules;
  147.  
  148.   /*
  149.    * Start interpretation of module string ml.
  150.    */
  151.   if (!options->quiet)
  152.     cerr << "Start of Interpretation ...\n\n";
  153.  
  154.   d->begin();
  155.  
  156.   /*
  157.    * For each module lookup corresponding interpreter function, call it
  158.    * if not NULL.
  159.    */
  160.   for (currentModule = 0; currentModule < ml->count(); currentModule++) {
  161.     m = ml->item(currentModule);
  162.     if (functable[ml->item(currentModule)->name().index()] != NULL) {
  163.       FP currentFunc = functable[ml->item(currentModule)->name().index()];
  164.       (this->*currentFunc)();
  165.     }
  166.       
  167.     if (options->deleteModules)
  168.       delete ml->item(currentModule);
  169.  
  170.     /*
  171.      * If we hit any hull primitive and deleteBranchWhenHit option is
  172.      * set, ignore all modules up to the next end branch command ("]").
  173.      * Note that we have to skip all the subbranches also.
  174.      */
  175.     if (deleteBranchWhenHit && reflected) {
  176.       reflected = FALSE; // reset
  177.       cutBranch();
  178.     }
  179.   }
  180.  
  181.   flush();
  182.  
  183.   /*
  184.    * Visualize the definied hulls.
  185.    */
  186.   if (options->showHulls) {
  187.     PolygonList* polys;
  188.  
  189.     d->color(Color("HullColor"));
  190.     for (HullSymtab_Iterator hullItr(*h); hullItr.more(); hullItr.next()) {
  191.       polys = hullItr.cur_value()->convertToPolygonList(t->bbox());
  192.       for (register long i=0; i<polys->count(); i++)
  193.     d->polygon(polys->item(i));
  194.       delete polys;
  195.     } 
  196.   }
  197.  
  198.   if (options->verbose) {
  199.     cerr << "BoundingBox: " << t->bbox() << "\n\n";
  200.     cerr << "intersection tests: " 
  201.      << GeoObject::getIntersectionTests() <<"\n"
  202.          << "intersection hits:  " 
  203.      << GeoObject::getIntersections() << "\n\n";
  204.   }
  205.  
  206.   d->end(t->bbox());
  207.  
  208.   delete t;
  209. }
  210.  
  211. //___________________________________________________________ interpreter functions
  212.  
  213. /*
  214.  * Flush checks if there is a segment in the pipe which has't been draw yet
  215.  * (lastWidth > 0) and draws it in that case.
  216.  */
  217.  
  218. void Interpreter::flush()
  219. {
  220.   /*
  221.    * A segment left in the pipe?
  222.    */
  223.   if (t->getLastWidth() > 0) {
  224.     if (tropismFunction || weightFunction)
  225.       computeTropism();
  226.  
  227.     d->color(t->getLastColor());
  228.     d->texture(t->getLastTexture());
  229.  
  230.     if (equal(t->getLastWidth(), t->getWidth()))
  231.       d->cylinder(t->lastPos(), t->pos(), t->getWidth());
  232.     else if (!options->coneSpheres)
  233.       d->cone(t->lastPos(), t->getLastWidth(), t->pos(), t->getWidth());
  234.     else
  235.       createConeBetweenSpheres(t->lastPos(), t->getLastWidth(), 
  236.                    t->pos(), t->getWidth());      
  237.     if (options->coneSpheres)
  238.       d->sphere(t->pos(), t->getWidth());
  239.   }
  240.   t->setLastWidth(-1); // no segments left in the pipe
  241. }
  242.  
  243. /*
  244.  * Go forward and draw a line.
  245.  * lastWidth < 0: no move has been previously done
  246.  */
  247.  
  248. void Interpreter::forward()
  249. { 
  250.   real step;
  251.  
  252.   /*
  253.    * Is there an argument for the move?
  254.    */
  255.   if (m->argCount() <= 0 || !m->arg(0)->toReal(step)) 
  256.     step = options->defaultForward;
  257.  
  258.   /*
  259.    * Do we really have to move?
  260.    */
  261.   if (equal(step, 0)) {
  262.     Error(ERR_ADVISE, "Interpreter::forward with argument 0");
  263.     return;
  264.   }
  265.  
  266.   /*
  267.    * Recompute tropism and weight functions if any present.
  268.    */
  269.   if (tropismFunction || weightFunction)
  270.     computeTropism();
  271.  
  272.   if (t->getLastWidth() > 0) {
  273.     d->color(t->getLastColor());
  274.     d->texture(t->getLastTexture());
  275.   }
  276.  
  277.   real lastWidth    = t->getLastWidth();
  278.   real currentWidth = t->getWidth();
  279.   Vector lastPos    = t->lastPos();
  280.   Vector currentPos = t->pos();
  281.   reflected = t->forward(step);
  282.   Vector newPos     = t->pos();
  283.  
  284.   /*
  285.    * Regular line segment or cone spheres?
  286.    */
  287.   if (lastWidth > 0) {
  288.     if (equal(lastWidth, currentWidth))
  289.       d->cylinder(lastPos, currentPos, lastWidth);
  290.     else if (!options->coneSpheres)
  291.       d->cone(lastPos, lastWidth, currentPos, currentWidth);    
  292.     else 
  293.       createConeBetweenSpheres(lastPos, lastWidth, currentPos, currentWidth);
  294.     
  295.    /*
  296.     * Add sphere when there's an angle between the segments.
  297.     */
  298.     if (options->coneSpheres && !((lastPos-currentPos)*(currentPos-newPos)).zero())
  299.       d->sphere(currentPos, currentWidth);
  300.   }
  301. }
  302.  
  303. /*
  304.  * Go forward without drawing a line.
  305.  */
  306.  
  307. void Interpreter::go()
  308. { 
  309.   real step;
  310.  
  311.   flush();
  312.   if (tropismFunction || weightFunction)
  313.     computeTropism();
  314.  
  315.   if (m->argCount()>0 && m->arg(0)->toReal(step))
  316.     reflected = t->forward(step);
  317.   else
  318.     reflected = t->forward(options->defaultForward);
  319.  
  320.   /*
  321.    * There's no segment in the pipe left.
  322.    */
  323.   t->setLastWidth(-1);
  324. }
  325.  
  326. /*
  327.  * Set line width.
  328.  */
  329.  
  330. void Interpreter::width()
  331. {
  332.   real width;
  333.   if (m->argCount()>0 && m->arg(0)->toReal(width) && width>0) 
  334.     t->setWidth(width);
  335. }
  336.  
  337. /*
  338.  * Pitch turtle in positive direction.
  339.  */
  340.  
  341. void Interpreter::pitch()
  342. { 
  343.   real a;
  344.   if (m->argCount()>0 && m->arg(0)->toReal(a)) 
  345.     t->pitch(dtor(a));
  346.   else
  347.     t->pitch(options->defaultPitch);
  348. }
  349.  
  350. /*
  351.  * Pitch turtle in negative direction.
  352.  */
  353.  
  354. void Interpreter::pitch_negativ()
  355. { 
  356.   real a;
  357.   if (m->argCount()>0 && m->arg(0)->toReal(a)) 
  358.     t->pitch(-dtor(a));
  359.   else
  360.     t->pitch(-options->defaultPitch);
  361. }
  362.  
  363. /*
  364.  * Turn turtle in positive direction.
  365.  */
  366.  
  367. void Interpreter::turn()
  368. { 
  369.   real a;
  370.   if (m->argCount()>0 && m->arg(0)->toReal(a)) 
  371.     t->turn(dtor(a));
  372.   else
  373.     t->turn(options->defaultTurn);
  374. }
  375.  
  376. /*
  377.  * Turn turtle in negative direction.
  378.  */
  379.  
  380. void Interpreter::turn_negativ()
  381. { 
  382.   real a;
  383.   if (m->argCount()>0 && m->arg(0)->toReal(a)) 
  384.     t->turn(-dtor(a));
  385.   else
  386.     t->turn(-options->defaultTurn);
  387. }
  388.  
  389. /*
  390.  * Roll turtle in positive direction.
  391.  */
  392.  
  393. void Interpreter::roll()
  394. { 
  395.   real a;
  396.   if (m->argCount()>0 && m->arg(0)->toReal(a)) 
  397.     t->roll(dtor(a));
  398.   else
  399.     t->roll(options->defaultRoll);
  400. }
  401.  
  402. /*
  403.  * Roll turtle in negative direction.
  404.  */
  405.  
  406. void Interpreter::roll_negativ()
  407. { 
  408.   real a;
  409.   if (m->argCount()>0 && m->arg(0)->toReal(a)) 
  410.     t->roll(-dtor(a));
  411.   else
  412.     t->roll(-options->defaultRoll);
  413. }
  414.  
  415. /*
  416.  * Align turtle vertical.
  417.  */
  418.  
  419. void Interpreter::rotate_vertical()
  420. {
  421.   t->rotate_vertical();
  422. }
  423.  
  424. /*
  425.  * Reverse heading of the turtle.
  426.  */
  427.  
  428. void Interpreter::reverse()
  429. {
  430.   t->reverse();
  431. }
  432.  
  433. /*
  434.  * Save current turtle state on the stack.
  435.  */
  436.  
  437. void Interpreter::push()
  438. {
  439.   turtleStack->prepend(t);
  440.   t = new Turtle(*t);
  441.   t->setLastWidth(-1);
  442. }
  443.  
  444. /*
  445.  * Restore turtle state from stack.
  446.  */
  447.  
  448. void Interpreter::pop()
  449. {
  450.   flush();
  451.  
  452.   if (turtleStack->count() > 0) {
  453.     turtleStack->item(0)->expandBBoxBy(t->bbox());
  454.     delete t;
  455.     t = turtleStack->item(0);
  456.     turtleStack->remove(0);
  457.   }
  458.   else 
  459.     Error(ERR_WARN, "Interpreter::pop stack is empty");
  460. }
  461.  
  462. /*
  463.  * Start a new polygon.
  464.  */
  465.  
  466. void Interpreter::startPolygon()
  467. {
  468.   polyStack->prepend(new Polygon);
  469. }
  470.  
  471. /*
  472.  * Add vertex to current polygon.
  473.  */
  474.  
  475. void Interpreter::saveVertex()
  476. {
  477.   if (polyStack->count() > 0)
  478.     polyStack->item(0)->addVertex(t->pos());
  479.   else
  480.     Error(ERR_WARN, "Interpreter::saveVertex polygon stack is empty");
  481. }
  482.  
  483. /*
  484.  * End of polygon definition.
  485.  */
  486.  
  487. void Interpreter::endPolygon()
  488. {
  489.   if (polyStack->count() <= 0) {
  490.     Error(ERR_WARN, "Interpreter::endPolygon polygon stack is empty");
  491.     return;
  492.   }
  493.  
  494.   Polygon* p = polyStack->item(0);
  495.  
  496.   if (p->numVertices() <= 0) {
  497.     Error(ERR_WARN, "Interpreter::endPolygon no vertex in polygon");
  498.     delete p;
  499.     polyStack->remove(0);
  500.     return;
  501.   }
  502.   
  503.   /*
  504.    * Start and endpoint should not be the same.
  505.    */
  506.   if (p->numVertices()>1 && p->vertex(0) == p->vertex(p->numVertices()-1))
  507.     p->removeVertex(p->numVertices()-1);
  508.  
  509.   /* 
  510.    * Set color and texture.
  511.    */
  512.   d->color(t->getColor());
  513.   d->texture(t->getTexture());
  514.  
  515.   d->polygon(p);
  516.  
  517.   polyStack->remove(0);
  518. }
  519.  
  520. /*
  521.  * Set tropism vector.
  522.  */
  523.  
  524. void Interpreter::tropism()
  525. {
  526.   real x, y, z, w;
  527.   if (m->argCount() >= 3  &&  
  528.       m->arg(0)->toReal(x) && m->arg(1)->toReal(y) && m->arg(2)->toReal(z)) {
  529.     t->setTropism(x,y,z);
  530.  
  531.     if (m->argCount() >= 4 && m->arg(3)->toReal(w))
  532.       t->setWeight(w);
  533.   }
  534. }
  535.  
  536. /*
  537.  * Set weight for tropism calculations.
  538.  */
  539.  
  540. void Interpreter::weight()
  541. {
  542.   real w;
  543.   if (m->argCount()>0 && m->arg(0)->toReal(w)) 
  544.     t->setWeight(w);
  545. }
  546.  
  547. /*
  548.  * Set color.
  549.  */
  550.  
  551. void Interpreter::color()
  552. {
  553.   if (m->argCount()>0) {
  554.     Color c(m->arg(0)->toString());
  555.     t->setColor(c);
  556.   }
  557. }
  558.  
  559. /* 
  560.  * Start macro definition.
  561.  */
  562.  
  563. void Interpreter::beginMacro()
  564. {
  565.   if (definingMacro) 
  566.     Error(ERR_PANIC, "Interpreter::beginMacro nested macro definition");
  567.   
  568.   if (m->argCount() <= 0) 
  569.     Error(ERR_PANIC, "Interpreter::beginMacro macro definition without a name");
  570.  
  571.   rcString macroName(m->arg(0)->toString());
  572.  
  573.   if (!d->addMacroName(macroName))
  574.     Error(ERR_PANIC, "Interpreter::beginMacro macro \"" 
  575.                      + macroName + "\" already defined");
  576.   
  577.   saveTurtle = t; 
  578.   t = new Turtle; 
  579.   definingMacro = TRUE;
  580.   d->beginMacro(macroName);
  581. }
  582.  
  583. /*
  584.  * End of macro definition.
  585.  */
  586.  
  587. void Interpreter::endMacro()
  588. {
  589.   flush();
  590.   d->endMacro();
  591.   delete t;
  592.   t = saveTurtle; saveTurtle = NULL;
  593.   definingMacro = FALSE;
  594. }
  595.  
  596. /*
  597.  * Execute a already defined macro.
  598.  */
  599.  
  600. void Interpreter::executeMacro()
  601. {
  602.   if (m->argCount() <= 0) {
  603.     Error(ERR_WARN, "Interpreter::executeMacro macro without a name");
  604.     return;
  605.   }
  606.  
  607.   TransMatrix tmat;
  608.   real scale;
  609.  
  610.   tmat(0,0) = t->vecU()[0]; tmat(0,1) = t->vecU()[1]; tmat(0,2) = t->vecU()[2]; 
  611.   tmat(1,0) = t->vecL()[0]; tmat(1,1) = t->vecL()[1]; tmat(1,2) = t->vecL()[2]; 
  612.   tmat(2,0) = t->vecH()[0]; tmat(2,1) = t->vecH()[1]; tmat(2,2) = t->vecH()[2]; 
  613.  
  614.   if (m->argCount()>1 && m->arg(1)->toReal(scale) && !equal(scale, 1))
  615.     tmat.scale(scale, scale, scale);
  616.   tmat.translate(t->pos());
  617.  
  618.   d->executeMacro(m->arg(0)->toString(), tmat);
  619. }
  620.  
  621. /*
  622.  * Include a predefined object.
  623.  */
  624.  
  625. void Interpreter::libraryObject()
  626. {
  627.   if (m->argCount() <= 0) {
  628.     Error(ERR_WARN, "Interpreter::libraryObject object without a name");
  629.     return;
  630.   }
  631.  
  632.   TransMatrix tmat;
  633.   real scale;
  634.  
  635.   rcString libName(m->arg(0)->toString());
  636.  
  637.   d->addLibraryObjectName(libName);
  638.  
  639.   tmat(0,0) = t->vecU()[0]; tmat(0,1) = t->vecU()[1]; tmat(0,2) = t->vecU()[2]; 
  640.   tmat(1,0) = t->vecL()[0]; tmat(1,1) = t->vecL()[1]; tmat(1,2) = t->vecL()[2]; 
  641.   tmat(2,0) = t->vecH()[0]; tmat(2,1) = t->vecH()[1]; tmat(2,2) = t->vecH()[2]; 
  642.  
  643.   if (m->argCount()>1 && m->arg(1)->toReal(scale) && !equal(scale, 1))
  644.     tmat.scale(scale, scale, scale);
  645.   tmat.translate(t->pos());
  646.  
  647.   d->libraryObject(libName, tmat);
  648. }
  649.  
  650. /*
  651.  * Generate sphere at turtle position with given radius.
  652.  */
  653.  
  654. void Interpreter::sphere()
  655. {
  656.   real r;
  657.  
  658.   /* 
  659.    * Set color and texture.
  660.    */
  661.   d->color(t->getColor());
  662.   d->texture(t->getTexture());
  663.  
  664.   if (m->argCount()>0 && m->arg(0)->toReal(r)) 
  665.     d->sphere(t->pos(), r);
  666.   else
  667.     d->sphere(t->pos(), 1);
  668. }
  669.  
  670. /*
  671.  * Generate triangle with given vertices.
  672.  */
  673.  
  674. void Interpreter::triangle()
  675. {
  676.   if (m->argCount() < 9)
  677.     return;
  678.  
  679.   real coords[9];
  680.   for (register int i=0; i<9; i++)
  681.     if (!m->arg(i)->toReal(coords[i]))
  682.       return;
  683.  
  684.   Vector p1(coords[0], coords[1], coords[2]); 
  685.   Vector p2(coords[3], coords[4], coords[5]); 
  686.   Vector p3(coords[6], coords[7], coords[8]); 
  687.  
  688.   BoundingBox tmpBBox;
  689.   tmpBBox.expand(p1);
  690.   tmpBBox.expand(p2);
  691.   tmpBBox.expand(p3);
  692.   t->expandBBoxBy(tmpBBox);
  693.  
  694.   /* 
  695.    * Set color and texture.
  696.    */
  697.   d->color(t->getColor());
  698.   d->texture(t->getTexture());
  699.  
  700.   d->polygon(new Polygon(p1, p2, p3));
  701. }
  702.  
  703. /*
  704.  * Generate polygon with given vertices.
  705.  */
  706.  
  707. void Interpreter::polygon()
  708. {
  709.   if (m->argCount() < 9)
  710.     return;
  711.  
  712.   real x, y, z;
  713.   Polygon* p = new Polygon(3);
  714.   BoundingBox tmpBBox;
  715.  
  716.   for (register int i=0; i<m->argCount()-2; i+=3) {
  717.     if (m->arg(i)->toReal(x)   && 
  718.     m->arg(i+1)->toReal(y) && 
  719.     m->arg(i+2)->toReal(z)) 
  720.       {
  721.     p->addVertex(Vector(x,y,z));
  722.     tmpBBox.expand(Vector(x,y,z));
  723.       }
  724.   }
  725.  
  726.   if (p->numVertices() > 2) {
  727.  
  728.     /* 
  729.      * Set color and texture.
  730.      */
  731.     d->color(t->getColor());
  732.     d->texture(t->getTexture());
  733.  
  734.     d->polygon(p);
  735.     t->expandBBoxBy(tmpBBox);
  736.   }
  737.   else
  738.     delete p;
  739. }
  740.  
  741. /*
  742.  * Activate a hull. Turtle will move with respect to the primitives
  743.  * of the hull.
  744.  */
  745.  
  746. void Interpreter::activateHull()
  747. {
  748.   if (m->argCount()<=0) {
  749.     Error(ERR_WARN, "Interpreter::activateHull no hull name");
  750.     return;
  751.   }
  752.  
  753.   rcString hullName(m->arg(0)->toString());
  754.  
  755.   Hull* hull;
  756.   if (!h->lookup(hullName, hull)) {
  757.     Error(ERR_WARN, "Interpreter::activateHull unknown hull " + hullName);
  758.     return;
  759.   }
  760.   real reflectanceFactor = 1;
  761.   if (m->argCount()>1)
  762.     m->arg(1)->toReal(reflectanceFactor);
  763.   
  764.   t->setHull(hull, reflectanceFactor);
  765. }
  766.  
  767. void Interpreter::deactivateHull()
  768. {
  769.   t->unsetHull();
  770. }
  771.  
  772. /*
  773.  * Set/Unset of delete branch when conflict with current hull.
  774.  */
  775.  
  776. void Interpreter::cutBranchWhenHit()
  777. {
  778.   real flag = TRUE;
  779.   if (m->argCount() > 0)
  780.     m->arg(0)->toReal(flag);
  781.     
  782.   if ((int)flag) {
  783.     deleteBranchWhenHit = TRUE;
  784.     t->setStopOnHit();
  785.   }
  786.   else {
  787.     deleteBranchWhenHit = FALSE;
  788.     t->unsetStopOnHit();
  789.   }
  790. }
  791.  
  792. /*
  793.  * Ignore all the modules until we find a end branch symbol (ignore
  794.  * subbranches also).
  795.  */
  796.  
  797. void Interpreter::cutBranch()
  798. {
  799.   static Name startBranch(startBranchSymbol);
  800.   static Name endBranch(endBranchSymbol);
  801.   int nested = 0;
  802.  
  803.   /*
  804.    * Ignore all modules up to the next end branch command ("]").
  805.    * Note that we have to skip all the subbranches also.
  806.    */
  807.   while (++currentModule < ml->count()) {
  808.     if (ml->item(currentModule)->name() == startBranch)
  809.       nested++;
  810.     else if (ml->item(currentModule)->name() == endBranch) {
  811.       if (nested-- == 0) {
  812.     currentModule--; 
  813.     break;
  814.       }
  815.     }
  816.     if (options->deleteModules)
  817.       delete ml->item(currentModule);
  818.   }
  819. }
  820.  
  821. /*
  822.  * Define texture for the following primitives.
  823.  */
  824. void Interpreter::texture()
  825. {
  826.   if (m->argCount()>0) {
  827.     rcString theTexture(m->arg(0)->toString());
  828.     t->setTexture(theTexture);
  829.   }
  830.   else
  831.     t->setTexture(""); // disable textures
  832. }
  833.  
  834. /*
  835.  * Generate a cone between two given spheres. 
  836.  */
  837.  
  838. void Interpreter::createConeBetweenSpheres(const Vector& p1, real r1, 
  839.                             const Vector& p2, real r2)
  840. {
  841.   real a = r1-r2;
  842.   real r = r1;
  843.   real c = p1.distance(p2);
  844.   int secondIsLarger = FALSE;
  845.  
  846.   if (c<r1 || c<r2) {
  847.     Error(ERR_ADVISE, rcString("Interpreter::createConeBetweenSpheres\n") + 
  848.                       "\tdistance between spheres is too small -> can't create cone\n");
  849.     return;
  850.   }
  851.     
  852.   if (a < 0) {
  853.     r = r2;
  854.     a = -a;
  855.     secondIsLarger = TRUE;
  856.   }
  857.   
  858.   real p  = a*a/c;
  859.   real ps = p*r/a;
  860.  
  861.   real h  = sqrt(p*(c-p));
  862.   real hs = h*r/a;
  863.  
  864.   Vector dir = p2 - p1;
  865.  
  866.   if (secondIsLarger)
  867.     d->cone(p1-dir*((ps-p)/c), hs-h, p2-dir*(ps/c), hs);
  868.   else
  869.     d->cone(p1+dir*(ps/c), hs, p2+dir*((ps-p)/c), hs-h);
  870. }
  871.  
  872. /*
  873.  * If tropism vector depends on turtle position, we recompute the
  874.  * tropism vector after each move.
  875.  */
  876.  
  877. void Interpreter::computeTropism()
  878. {
  879.   turtleX = t->pos()[0];
  880.   turtleY = t->pos()[1];
  881.   turtleZ = t->pos()[2];
  882.  
  883.   if (tropismFunction)
  884.     t->setTropism(tropismX->evaluate(),
  885.           tropismY->evaluate(),
  886.           tropismZ->evaluate());  
  887.  
  888.   if (weightFunction)
  889.     t->setWeight(tropismWeight->evaluate());
  890. }
  891.