fart/parser/nodes.h

#ifndef NODES_H
#define NODES_H NODES_H

#include <stdlib.h>                 /* exit() */

#include <vector>
#include <string>
#include <iostream>

#include "util/refptr.h"
#include "util/Vector.h"
#include "util/Scope.h"

extern refptr<Scope> parser_scope;

class Node
{
    public:
        virtual ~Node();
        void addChild(refptr<Node> child) { m_children.push_back(child); }
        void addChildren(refptr<Node> other);
        std::vector< refptr<Node> > & getChildren() { return m_children; }

        virtual int getInteger()
        {
            std::cerr << "Warning: Node::getInteger() called!" << std::endl;
            return 0;
        }
        virtual double getNumber()
        {
            std::cerr << "Warning: Node::getNumber() called!" << std::endl;
            return 0.0;
        }
        virtual refptr<Vector> getVector()
        {
            std::cerr << "Warning: Node::getVector() called!" << std::endl;
            return refptr<Vector>(NULL);
        }
        virtual std::string getString()
        {
            std::cerr << "Warning: Node::getString() called!" << std::endl;
            return "";
        }
        virtual refptr<Node> getNode(int idx)
        {
            std::cerr << "Warning: Node::getNode() called!" << std::endl;
            return NULL;
        }
        virtual void evaluate(refptr<Node> parent)
        {
            std::cerr << "Warning: Node::evaluate() called!" << std::endl;
        }
        virtual void evaluateChildren(refptr<Node> parent)
        {
            for (std::vector< refptr<Node> >::iterator it = m_children.begin();
                 it != m_children.end();
                 it++)
            {
                (*it)->evaluate(parent);
            }
        }

        virtual bool isShape() { return false; }
        virtual bool isMaterial() { return false; }
        virtual bool isTransformBlock() { return false; }
        virtual bool isExpression() { return false; }

    protected:
        std::vector< refptr<Node> > m_children;
};

typedef refptr<Node> NodeRef;


class IntegerNode : public Node
{
    public:
        IntegerNode(int number) { m_number = number; }
        virtual int getInteger() { return m_number; }
        virtual double getNumber() { return m_number; }

    protected:
        int m_number;
};

class NumberNode : public Node
{
    public:
        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();
        }

    protected:
        double m_number;
        NodeRef m_expr;
        bool m_direct;
};

class VectorNode : public Node
{
    public:
        VectorNode(NodeRef a, NodeRef b, NodeRef c)
            : m_a(a), m_b(b), m_c(c), m_direct(true)
        {
        }
        VectorNode(NodeRef node)
            : m_a(node), m_direct(false)
        {
        }
        refptr<Vector> getVector()
        {
            return m_direct
                ? new Vector(m_a->getNumber(),
                        m_b->getNumber(),
                        m_c->getNumber())
                : m_a->getVector();
        }
    protected:
        NodeRef m_a, m_b, m_c;
        bool m_direct;
};


class AmbientNode : public VectorNode
{
    public:
        AmbientNode(NodeRef vector) : VectorNode(vector) {}
};

class AmbientOcclusionNode : public IntegerNode
{
    public:
        AmbientOcclusionNode(int i) : IntegerNode(i) {}
};

class BoxNode : public Node
{
    public:
        bool isShape() { return true; }
};

class CameraNode : public Node
{
};

class ColorNode : public VectorNode
{
    public:
        ColorNode(NodeRef vector) : VectorNode(vector) {}
};

class CylNode : public Node
{
    public:
        bool isShape() { return true; }
};

class DiffuseNode : public VectorNode
{
    public:
        DiffuseNode(NodeRef vector) : VectorNode(vector) {}
};

class ExposureNode : public NumberNode
{
    public:
        ExposureNode(NodeRef e) : NumberNode(e) {}
};

class ExtrudeNode : public Node
{
    public:
        bool isShape() { return true; }
};

class HeightNode : public IntegerNode
{
    public:
        HeightNode(int i) : IntegerNode(i) {}
};

class IdentifierNode : public Node
{
    public:
        IdentifierNode(const std::string & str) { m_string = str; }
        std::string getString() { return m_string; }
    protected:
        std::string m_string;
};

class IntersectNode : public Node
{
    public:
        bool isShape() { return true; }
};

class ItemsNode : public Node
{
};

class JitterNode : public NumberNode
{
    public:
        JitterNode(NodeRef e) : NumberNode(e) {}
        int getInteger() { return getNumber(); }
};

class LightNode : public Node
{
};

class LookAtNode : public VectorNode
{
    public:
        LookAtNode(NodeRef vector) : VectorNode(vector) {}
};

class MaterialNode : public Node
{
    public:
        bool isMaterial() { return true; }
};

class MaterialDefinitionNode : public IdentifierNode
{
    public:
        MaterialDefinitionNode(const std::string & str) : IdentifierNode(str) {}
};

class MaterialRefNode : public IdentifierNode
{
    public:
        MaterialRefNode(const std::string & str) : IdentifierNode(str) {}
        bool isMaterial() { return true; }
};

class MaxDepthNode : public IntegerNode
{
    public:
        MaxDepthNode(int i) : IntegerNode(i) {}
};

class MultisampleNode : public IntegerNode
{
    public:
        MultisampleNode(int i) : IntegerNode(i) {}
};

class NGonNode : public NumberNode
{
    public:
        NGonNode(NodeRef e) : NumberNode(e) {}
        int getInteger() { return getNumber(); }
};

class OffsetNode : public NumberNode
{
    public:
        OffsetNode(NodeRef e) : NumberNode(e) {}
};

class OptionsNode : public Node
{
};

class PlaneNode : public Node
{
    public:
        bool isShape() { return true; }
};

class PlanePositionNode : public VectorNode
{
    public:
        PlanePositionNode(NodeRef vec_node, NodeRef dist)
            : VectorNode(vec_node)
        {
            m_dist = dist;
        }
        double getNumber() { return m_dist->getNumber(); }

    protected:
        NodeRef m_dist;
};

class PolygonNode : public Node
{
};

class PositionNode : public VectorNode
{
    public:
        PositionNode(NodeRef vector) : VectorNode(vector) {}
};

class RadiusNode : public NumberNode
{
    public:
        RadiusNode(NodeRef e) : NumberNode(e) {}
};

class ReflectanceNode : public NumberNode
{
    public:
        ReflectanceNode(NodeRef e) : NumberNode(e) {}
};

class RotateNode : public VectorNode
{
    public:
        RotateNode(NodeRef angle, NodeRef vec_node)
            : VectorNode(vec_node)
        {
            m_angle = angle;
        }
        double getNumber() { return m_angle->getNumber(); }

    protected:
        NodeRef m_angle;
};

class RotateBlockNode : public RotateNode
{
    public:
        RotateBlockNode(NodeRef angle, NodeRef vec_node)
            : RotateNode(angle, vec_node) {}
        bool isTransformBlock() { return true; }
};

class ScaleNode : public VectorNode
{
    public:
        ScaleNode(NodeRef vector) : VectorNode(vector) {}
};

class ScaleBlockNode : public ScaleNode
{
    public:
        ScaleBlockNode(NodeRef vector) : ScaleNode(vector) {}
        bool isTransformBlock() { return true; }
};

class ScaleScalarNode : public Node
{
    public:
        ScaleScalarNode(NodeRef expr)
            : m_expr(expr)
        {
        }
        refptr<Vector> getVector()
        {
            double x = m_expr->getNumber();
            return new Vector(x, x, x);
        }
    protected:
        NodeRef m_expr;
};

class SceneNode : public Node
{
};

class ShapeDefinitionNode : public IdentifierNode
{
    public:
        ShapeDefinitionNode(const std::string & str) : IdentifierNode(str) {}
};

class ShapeRefNode : public IdentifierNode
{
    public:
        ShapeRefNode(const std::string & str) : IdentifierNode(str) {}
        bool isShape() { return true; }
};

class ShininessNode : public NumberNode
{
    public:
        ShininessNode(NodeRef e) : NumberNode(e) {}
};

class SizeNode : public VectorNode
{
    public:
        SizeNode(NodeRef vector) : VectorNode(vector) {}
};

class SpecularNode : public VectorNode
{
    public:
        SpecularNode(NodeRef vector) : VectorNode(vector) {}
};

class SphereNode : public Node
{
    public:
        bool isShape() { return true; }
};

class SubtractNode : public Node
{
    public:
        bool isShape() { return true; }
};

class TranslateNode : public VectorNode
{
    public:
        TranslateNode(NodeRef vector) : VectorNode(vector) {}
};

class TranslateBlockNode : public TranslateNode
{
    public:
        TranslateBlockNode(NodeRef vector) : TranslateNode(vector) {}
        bool isTransformBlock() { return true; }
};

class TransparencyNode : public NumberNode
{
    public:
        TransparencyNode(NodeRef e) : NumberNode(e) {}
};

class UnionNode : public Node
{
    public:
        bool isShape() { return true; }
};

class UpNode : public VectorNode
{
    public:
        UpNode(NodeRef vector) : VectorNode(vector) {}
};

class VFOVNode : public NumberNode
{
    public:
        VFOVNode(NodeRef e) : NumberNode(e) {}
};

class WidthNode : public IntegerNode
{
    public:
        WidthNode(int i) : IntegerNode(i) {}
};

/******** scripting nodes ********/

class ExpressionNode : public Node
{
    public:
        bool isExpression() { return true; }
        virtual double getNumber() = 0;
        virtual int getInteger() { return getNumber(); }
};

class AssignmentNode : public ExpressionNode
{
    public:
        AssignmentNode(NodeRef varref, NodeRef expr)
            : m_varref(varref), m_expr(expr)
        {
        }
        std::string getString() { return m_varref->getString(); }
        double getNumber()
        {
            double n = m_expr->getNumber();
            parser_scope->putGlobal(getString(), n);
            return n;
        }
    protected:
        NodeRef m_varref;
        NodeRef m_expr;
};

class LocalAssignmentNode : public ExpressionNode
{
    public:
        LocalAssignmentNode(NodeRef varref, NodeRef expr)
            : m_varref(varref), m_expr(expr)
        {
        }
        std::string getString() { return m_varref->getString(); }
        double getNumber()
        {
            double n = m_expr->getNumber();
            parser_scope->putLocal(getString(), n);
            return n;
        }
    protected:
        NodeRef m_varref;
        NodeRef m_expr;
};

class LocalDeclNode : public ExpressionNode
{
    public:
        LocalDeclNode(NodeRef varref) : m_varref(varref) { }
        double getNumber()
        {
            parser_scope->putLocal(m_varref->getString(), 0.0);
            return 0.0;
        }
    protected:
        NodeRef m_varref;
};

class BinOpNode : public ExpressionNode
{
    public:
        BinOpNode(char op, NodeRef one, NodeRef two)
            : m_op(op), one(one), two(two)
        {
        }
        virtual double getNumber();
    protected:
        char m_op;
        NodeRef one;
        NodeRef two;
};

class BoolExpressionNode : public Node
{
    public:
        BoolExpressionNode(char op, NodeRef one, NodeRef two)
            : m_op(op), one(one), two(two)
        {
        }
        int getInteger();
    protected:
        char m_op;
        NodeRef one;
        NodeRef two;
};

class VarRefNode : public Node
{
    public:
        VarRefNode(const std::string & str) { m_string = str; }
        std::string getString() { return m_string; }
        double getNumber()
        {
            if (parser_scope->contains(m_string))
            {
                return parser_scope->get(m_string);
            }
            std::cerr << "Error: No identifier '" << m_string << "' in scope"
                << std::endl;
            exit(4);
        }
    protected:
        std::string m_string;
};

class ForNode : public Node
{
    public:
        ForNode(NodeRef e1, NodeRef e2, NodeRef e3)
        {
            m_nodes[0] = e1;
            m_nodes[1] = e2;
            m_nodes[2] = e3;
        }
        NodeRef getNode(int idx)
        {
            if (0 <= idx && idx <= 2)
            {
                return m_nodes[idx];
            }
            return NULL;
        }
    protected:
        NodeRef m_nodes[3];
};

#endif