From f36c1fa60f271d35666b99a60faf84195f2b380e Mon Sep 17 00:00:00 2001
From: Josh Holtrop <jholtrop+git@gmail.com>
Date: Wed, 6 Oct 2010 16:32:27 +0000
Subject: [PATCH] added evaluate() method for all non-scripting nodes, made
 evaluateChildren() recursive

git-svn-id: svn://anubis/fart/branches/scene-file-scripting@338 7f9b0f55-74a9-4bce-be96-3c2cd072584d
---
 main/Scene-load.cc |   6 +-
 parser/nodes.h     | 208 ++++++++++++++++++++++++++++++++++++++++++---
 2 files changed, 197 insertions(+), 17 deletions(-)

diff --git a/main/Scene-load.cc b/main/Scene-load.cc
index 53e2584..cbb8103 100644
--- a/main/Scene-load.cc
+++ b/main/Scene-load.cc
@@ -21,12 +21,12 @@ void Scene::load(const char * filename)
     refptr<Node> node = parse(filename, scope);
     if ( ! node.isNull() )
     {
-        refptr<Node> dummy = new Node();
         /* evaluate any scripting nodes in the node tree */
-        node->evaluate(dummy);
+        refptr<Node> processed_scene = node->evaluate();
+        node->evaluateChildren(processed_scene);
 
         /* now we have a new node tree under 'dummy' with no scripting nodes */
-        processScene(dummy->getChildren()[0]);
+        processScene(processed_scene);
     }
 }
 
diff --git a/parser/nodes.h b/parser/nodes.h
index 68254e1..c417e0e 100644
--- a/parser/nodes.h
+++ b/parser/nodes.h
@@ -44,17 +44,24 @@ class Node
             std::cerr << "Warning: Node::getNode() called!" << std::endl;
             return NULL;
         }
-        virtual void evaluate(refptr<Node> parent)
+        virtual refptr<Node> evaluate()
         {
             std::cerr << "Warning: Node::evaluate() called!" << std::endl;
+            return NULL;
         }
         virtual void evaluateChildren(refptr<Node> parent)
         {
+            /* recursively evaluate all children nodes */
             for (std::vector< refptr<Node> >::iterator it = m_children.begin();
                  it != m_children.end();
                  it++)
             {
-                (*it)->evaluate(parent);
+                refptr<Node> evaluated = (*it)->evaluate();
+                if ( ! evaluated.isNull() )
+                {
+                    (*it)->evaluateChildren(evaluated);
+                    parent->addChild(evaluated);
+                }
             }
         }
 
@@ -76,22 +83,23 @@ class NumberNode : public Node
         NumberNode(double number)
         {
             m_number = number;
-            m_direct = true;
         }
         NumberNode(NodeRef expr)
         {
             m_expr = expr;
-            m_direct = false;
         }
         virtual double getNumber()
         {
-            return m_direct ? m_number : m_expr->getNumber();
+            return m_number;
+        }
+        virtual refptr<Node> evaluate()
+        {
+            return new NumberNode(m_number);
         }
 
     protected:
         double m_number;
         NodeRef m_expr;
-        bool m_direct;
 };
 
 class VectorNode : public Node
@@ -102,7 +110,7 @@ class VectorNode : public Node
         {
         }
         VectorNode(NodeRef node)
-            : m_a(node), m_direct(false)
+            : m_vector(node), m_direct(false)
         {
         }
         refptr<Vector> getVector()
@@ -113,8 +121,16 @@ class VectorNode : public Node
                         m_c->getNumber())
                 : m_a->getVector();
         }
+        virtual NodeRef evaluate()
+        {
+            return m_direct
+                ? new VectorNode(m_a->evaluate(),
+                        m_b->evaluate(),
+                        m_c->evaluate())
+                : m_a->evaluate();
+        }
     protected:
-        NodeRef m_a, m_b, m_c;
+        NodeRef m_a, m_b, m_c, m_vector;
         bool m_direct;
 };
 
@@ -123,58 +139,99 @@ class AmbientNode : public VectorNode
 {
     public:
         AmbientNode(NodeRef vector) : VectorNode(vector) {}
+        virtual NodeRef evaluate()
+        {
+            return new AmbientNode(m_vector->evaluate());
+        }
 };
 
 class AmbientOcclusionNode : public NumberNode
 {
     public:
         AmbientOcclusionNode(NodeRef e) : NumberNode(e) {}
+        virtual NodeRef evaluate()
+        {
+            return new AmbientOcclusionNode(m_expr->evaluate());
+        }
 };
 
 class BoxNode : public Node
 {
     public:
         bool isShape() { return true; }
+        virtual NodeRef evaluate()
+        {
+            return new BoxNode();
+        }
 };
 
 class CameraNode : public Node
 {
+    public:
+        virtual NodeRef evaluate()
+        {
+            return new CameraNode();
+        }
 };
 
 class ColorNode : public VectorNode
 {
     public:
         ColorNode(NodeRef vector) : VectorNode(vector) {}
+        virtual NodeRef evaluate()
+        {
+            return new ColorNode(m_vector->evaluate());
+        }
 };
 
 class CylNode : public Node
 {
     public:
         bool isShape() { return true; }
+        virtual NodeRef evaluate()
+        {
+            return new CylNode();
+        }
 };
 
 class DiffuseNode : public VectorNode
 {
     public:
         DiffuseNode(NodeRef vector) : VectorNode(vector) {}
+        virtual NodeRef evaluate()
+        {
+            return new DiffuseNode(m_vector->evaluate());
+        }
 };
 
 class ExposureNode : public NumberNode
 {
     public:
         ExposureNode(NodeRef e) : NumberNode(e) {}
+        virtual NodeRef evaluate()
+        {
+            return new ExposureNode(m_expr->evaluate());
+        }
 };
 
 class ExtrudeNode : public Node
 {
     public:
         bool isShape() { return true; }
+        virtual NodeRef evaluate()
+        {
+            return new ExtrudeNode();
+        }
 };
 
 class HeightNode : public NumberNode
 {
     public:
         HeightNode(NodeRef e) : NumberNode(e) {}
+        virtual NodeRef evaluate()
+        {
+            return new HeightNode(m_expr->evaluate());
+        }
 };
 
 class IdentifierNode : public Node
@@ -182,6 +239,10 @@ class IdentifierNode : public Node
     public:
         IdentifierNode(const std::string & str) { m_string = str; }
         std::string getString() { return m_string; }
+        virtual NodeRef evaluate()
+        {
+            return new IdentifierNode(m_string);
+        }
     protected:
         std::string m_string;
 };
@@ -190,39 +251,62 @@ class IntersectNode : public Node
 {
     public:
         bool isShape() { return true; }
+        virtual NodeRef evaluate()
+        {
+            return new IntersectNode();
+        }
 };
 
 class ItemsNode : public Node
 {
+    public:
+        virtual NodeRef evaluate()
+        {
+            return new ItemsNode();
+        }
 };
 
 class JitterNode : public NumberNode
 {
     public:
         JitterNode(NodeRef e) : NumberNode(e) {}
-        int getInteger() { return getNumber(); }
+        virtual NodeRef evaluate()
+        {
+            return new JitterNode(m_expr->evaluate());
+        }
 };
 
 class LightNode : public Node
 {
+    public:
+        virtual NodeRef evaluate() { return new LightNode(); }
 };
 
 class LookAtNode : public VectorNode
 {
     public:
         LookAtNode(NodeRef vector) : VectorNode(vector) {}
+        virtual NodeRef evaluate()
+        {
+            return new LookAtNode(m_vector->evaluate());
+        }
 };
 
 class MaterialNode : public Node
 {
     public:
         bool isMaterial() { return true; }
+        virtual NodeRef evaluate() { return new MaterialNode(); }
 };
 
 class MaterialDefinitionNode : public IdentifierNode
 {
     public:
         MaterialDefinitionNode(const std::string & str) : IdentifierNode(str) {}
+        virtual NodeRef evaluate()
+        {
+            return new MaterialDefinitionNode(m_string);
+        }
 };
 
 class MaterialRefNode : public IdentifierNode
@@ -230,41 +314,60 @@ class MaterialRefNode : public IdentifierNode
     public:
         MaterialRefNode(const std::string & str) : IdentifierNode(str) {}
         bool isMaterial() { return true; }
+        virtual NodeRef evaluate() { return new MaterialRefNode(m_string); }
 };
 
 class MaxDepthNode : public NumberNode
 {
     public:
         MaxDepthNode(NodeRef e) : NumberNode(e) {}
+        virtual NodeRef evaluate()
+        {
+            return new MaxDepthNode(m_expr->evaluate());
+        }
 };
 
 class MultisampleNode : public NumberNode
 {
     public:
         MultisampleNode(NodeRef e) : NumberNode(e) {}
+        virtual NodeRef evaluate()
+        {
+            return new MultisampleNode(m_expr->evaluate());
+        }
 };
 
 class NGonNode : public NumberNode
 {
     public:
         NGonNode(NodeRef e) : NumberNode(e) {}
-        int getInteger() { return getNumber(); }
+        virtual NodeRef evaluate()
+        {
+            return new NGonNode(m_expr->evaluate());
+        }
 };
 
 class OffsetNode : public NumberNode
 {
     public:
         OffsetNode(NodeRef e) : NumberNode(e) {}
+        virtual NodeRef evaluate()
+        {
+            return new OffsetNode(m_expr->evaluate());
+        }
 };
 
 class OptionsNode : public Node
 {
+    public:
+        virtual NodeRef evaluate() { return new OptionsNode(); }
 };
 
 class PlaneNode : public Node
 {
     public:
         bool isShape() { return true; }
+        virtual NodeRef evaluate() { return new PlaneNode(); }
 };
 
 class PlanePositionNode : public VectorNode
@@ -276,6 +379,11 @@ class PlanePositionNode : public VectorNode
             m_dist = dist;
         }
         double getNumber() { return m_dist->getNumber(); }
+        virtual NodeRef evaluate()
+        {
+            return new PlanePositionNode(m_vector->evaluate(),
+                    m_dist->evaluate());
+        }
 
     protected:
         NodeRef m_dist;
@@ -283,24 +391,38 @@ class PlanePositionNode : public VectorNode
 
 class PolygonNode : public Node
 {
+    public:
+        virtual NodeRef evaluate() { return new PolygonNode(); }
 };
 
 class PositionNode : public VectorNode
 {
     public:
         PositionNode(NodeRef vector) : VectorNode(vector) {}
+        virtual NodeRef evaluate()
+        {
+            return new PositionNode(m_vector->evaluate());
+        }
 };
 
 class RadiusNode : public NumberNode
 {
     public:
         RadiusNode(NodeRef e) : NumberNode(e) {}
+        virtual NodeRef evaluate()
+        {
+            return new RadiusNode(m_expr->evaluate());
+        }
 };
 
 class ReflectanceNode : public NumberNode
 {
     public:
         ReflectanceNode(NodeRef e) : NumberNode(e) {}
+        virtual NodeRef evaluate()
+        {
+            return new ReflectanceNode(m_expr->evaluate());
+        }
 };
 
 class RotateNode : public VectorNode
@@ -312,6 +434,10 @@ class RotateNode : public VectorNode
             m_angle = angle;
         }
         double getNumber() { return m_angle->getNumber(); }
+        virtual NodeRef evaluate()
+        {
+            return new RotateNode(m_angle->evaluate(), m_vector->evaluate());
+        }
 
     protected:
         NodeRef m_angle;
@@ -323,12 +449,20 @@ class RotateBlockNode : public RotateNode
         RotateBlockNode(NodeRef angle, NodeRef vec_node)
             : RotateNode(angle, vec_node) {}
         bool isTransformBlock() { return true; }
+        virtual NodeRef evaluate()
+        {
+            return new RotateBlockNode(m_angle->evaluate(), m_vector->evaluate());
+        }
 };
 
 class ScaleNode : public VectorNode
 {
     public:
         ScaleNode(NodeRef vector) : VectorNode(vector) {}
+        virtual NodeRef evaluate()
+        {
+            return new ScaleNode(m_vector->evaluate());
+        }
 };
 
 class ScaleBlockNode : public ScaleNode
@@ -336,6 +470,10 @@ class ScaleBlockNode : public ScaleNode
     public:
         ScaleBlockNode(NodeRef vector) : ScaleNode(vector) {}
         bool isTransformBlock() { return true; }
+        virtual NodeRef evaluate()
+        {
+            return new ScaleBlockNode(m_vector->evaluate());
+        }
 };
 
 class ScaleScalarNode : public Node
@@ -345,10 +483,10 @@ class ScaleScalarNode : public Node
             : m_expr(expr)
         {
         }
-        refptr<Vector> getVector()
+        virtual NodeRef evaluate()
         {
-            double x = m_expr->getNumber();
-            return new Vector(x, x, x);
+            NodeRef n = m_expr->evaluate();
+            return new VectorNode(n, n, n);
         }
     protected:
         NodeRef m_expr;
@@ -356,12 +494,15 @@ class ScaleScalarNode : public Node
 
 class SceneNode : public Node
 {
+    public:
+        virtual NodeRef evaluate() { return new SceneNode(); }
 };
 
 class ShapeDefinitionNode : public IdentifierNode
 {
     public:
         ShapeDefinitionNode(const std::string & str) : IdentifierNode(str) {}
+        virtual NodeRef evaluate() { return new ShapeDefinitionNode(m_string); }
 };
 
 class ShapeRefNode : public IdentifierNode
@@ -369,42 +510,61 @@ class ShapeRefNode : public IdentifierNode
     public:
         ShapeRefNode(const std::string & str) : IdentifierNode(str) {}
         bool isShape() { return true; }
+        virtual NodeRef evaluate() { return new ShapeRefNode(m_string); }
 };
 
 class ShininessNode : public NumberNode
 {
     public:
         ShininessNode(NodeRef e) : NumberNode(e) {}
+        virtual NodeRef evaluate()
+        {
+            return new ShininessNode(m_expr->evaluate());
+        }
 };
 
 class SizeNode : public VectorNode
 {
     public:
         SizeNode(NodeRef vector) : VectorNode(vector) {}
+        virtual NodeRef evaluate()
+        {
+            return new SizeNode(m_vector->evaluate());
+        }
 };
 
 class SpecularNode : public VectorNode
 {
     public:
         SpecularNode(NodeRef vector) : VectorNode(vector) {}
+        virtual NodeRef evaluate()
+        {
+            return new SpecularNode(m_vector->evaluate());
+        }
 };
 
 class SphereNode : public Node
 {
     public:
         bool isShape() { return true; }
+        virtual NodeRef evaluate() { return new SphereNode(); }
 };
 
 class SubtractNode : public Node
 {
     public:
         bool isShape() { return true; }
+        virtual NodeRef evaluate() { return new SubtractNode(); }
 };
 
 class TranslateNode : public VectorNode
 {
     public:
         TranslateNode(NodeRef vector) : VectorNode(vector) {}
+        virtual NodeRef evaluate()
+        {
+            return new TranslateNode(m_vector->evaluate());
+        }
 };
 
 class TranslateBlockNode : public TranslateNode
@@ -412,36 +572,57 @@ class TranslateBlockNode : public TranslateNode
     public:
         TranslateBlockNode(NodeRef vector) : TranslateNode(vector) {}
         bool isTransformBlock() { return true; }
+        virtual NodeRef evaluate()
+        {
+            return new TranslateBlockNode(m_vector->evaluate());
+        }
 };
 
 class TransparencyNode : public NumberNode
 {
     public:
         TransparencyNode(NodeRef e) : NumberNode(e) {}
+        virtual NodeRef evaluate()
+        {
+            return new TransparencyNode(m_expr->evaluate());
+        }
 };
 
 class UnionNode : public Node
 {
     public:
         bool isShape() { return true; }
+        virtual NodeRef evaluate() { return new UnionNode(); }
 };
 
 class UpNode : public VectorNode
 {
     public:
         UpNode(NodeRef vector) : VectorNode(vector) {}
+        virtual NodeRef evaluate()
+        {
+            return new UpNode(m_vector->evaluate());
+        }
 };
 
 class VFOVNode : public NumberNode
 {
     public:
         VFOVNode(NodeRef e) : NumberNode(e) {}
+        virtual NodeRef evaluate()
+        {
+            return new VFOVNode(m_expr->evaluate());
+        }
 };
 
 class WidthNode : public NumberNode
 {
     public:
         WidthNode(NodeRef e) : NumberNode(e) {}
+        virtual NodeRef evaluate()
+        {
+            return new WidthNode(m_expr->evaluate());
+        }
 };
 
 /******** scripting nodes ********/
@@ -451,7 +632,6 @@ class ExpressionNode : public Node
     public:
         bool isExpression() { return true; }
         virtual double getNumber() = 0;
-        virtual int getInteger() { return getNumber(); }
 };
 
 class AssignmentNode : public ExpressionNode