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 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;
};


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(refptr<Node> expr)
        {
            m_expr = expr;
            m_direct = false;
        }
        virtual double getNumber()
        {
            return m_direct ? m_number : m_expr->getNumber();
        }

    protected:
        double m_number;
        refptr<Node> m_expr;
        bool m_direct;
};

class VectorNode : public Node
{
    public:
        VectorNode(refptr<Node> a, refptr<Node> b, refptr<Node> c)
            : m_a(a), m_b(b), m_c(c), m_direct(true)
        {
        }
        VectorNode(refptr<Node> 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:
        refptr<Node> m_a, m_b, m_c;
        bool m_direct;
};


class AmbientNode : public VectorNode
{
    public:
        AmbientNode(refptr<Node> 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(refptr<Node> vector) : VectorNode(vector) {}
};

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

class DiffuseNode : public VectorNode
{
    public:
        DiffuseNode(refptr<Node> vector) : VectorNode(vector) {}
};

class ExposureNode : public NumberNode
{
    public:
        ExposureNode(refptr<Node> 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(refptr<Node> e) : NumberNode(e) {}
        int getInteger() { return getNumber(); }
};

class LightNode : public Node
{
};

class LookAtNode : public VectorNode
{
    public:
        LookAtNode(refptr<Node> 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(refptr<Node> e) : NumberNode(e) {}
        int getInteger() { return getNumber(); }
};

class OffsetNode : public NumberNode
{
    public:
        OffsetNode(refptr<Node> e) : NumberNode(e) {}
};

class OptionsNode : public Node
{
};

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

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

    protected:
        refptr<Node> m_dist;
};

class PolygonNode : public Node
{
};

class PositionNode : public VectorNode
{
    public:
        PositionNode(refptr<Node> vector) : VectorNode(vector) {}
};

class RadiusNode : public NumberNode
{
    public:
        RadiusNode(refptr<Node> e) : NumberNode(e) {}
};

class ReflectanceNode : public NumberNode
{
    public:
        ReflectanceNode(refptr<Node> e) : NumberNode(e) {}
};

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

    protected:
        refptr<Node> m_angle;
};

class RotateBlockNode : public RotateNode
{
    public:
        RotateBlockNode(refptr<Node> angle, refptr<Node> vec_node)
            : RotateNode(angle, vec_node) {}
        bool isTransformBlock() { return true; }
};

class ScaleNode : public VectorNode
{
    public:
        ScaleNode(refptr<Node> vector) : VectorNode(vector) {}
};

class ScaleBlockNode : public ScaleNode
{
    public:
        ScaleBlockNode(refptr<Node> vector) : ScaleNode(vector) {}
        bool isTransformBlock() { return true; }
};

class ScaleScalarNode : public Node
{
    public:
        ScaleScalarNode(refptr<Node> expr)
            : m_expr(expr)
        {
        }
        refptr<Vector> getVector()
        {
            double x = m_expr->getNumber();
            return new Vector(x, x, x);
        }
    protected:
        refptr<Node> 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(refptr<Node> e) : NumberNode(e) {}
};

class SizeNode : public VectorNode
{
    public:
        SizeNode(refptr<Node> vector) : VectorNode(vector) {}
};

class SpecularNode : public VectorNode
{
    public:
        SpecularNode(refptr<Node> 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(refptr<Node> vector) : VectorNode(vector) {}
};

class TranslateBlockNode : public TranslateNode
{
    public:
        TranslateBlockNode(refptr<Node> vector) : TranslateNode(vector) {}
        bool isTransformBlock() { return true; }
};

class TransparencyNode : public NumberNode
{
    public:
        TransparencyNode(refptr<Node> e) : NumberNode(e) {}
};

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

class UpNode : public VectorNode
{
    public:
        UpNode(refptr<Node> vector) : VectorNode(vector) {}
};

class VFOVNode : public NumberNode
{
    public:
        VFOVNode(refptr<Node> 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(refptr<Node> varref, refptr<Node> 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:
        refptr<Node> m_varref;
        refptr<Node> m_expr;
};

class LocalAssignmentNode : public ExpressionNode
{
    public:
        LocalAssignmentNode(refptr<Node> varref, refptr<Node> 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:
        refptr<Node> m_varref;
        refptr<Node> m_expr;
};

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

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

class BoolExpressionNode : public Node
{
    public:
        BoolExpressionNode(char op, refptr<Node> one, refptr<Node> two)
            : m_op(op), one(one), two(two)
        {
        }
        int getInteger();
    protected:
        char m_op;
        refptr<Node> one;
        refptr<Node> 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(refptr<Node> e1, refptr<Node> e2, refptr<Node> e3)
            : m_e1(e1), m_e2(e2), m_e3(e3)
        {
        }
    protected:
        refptr<Node> m_e1, m_e2, m_e3;
};

#endif