fart/parser/nodes.h

#ifndef NODES_H
#define NODES_H NODES_H

#include "util/refptr.h"
#include "util/Vector.h"
#include <vector>
#include <string>

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() { return 0; }
        virtual double getNumber() { return 0.0; }
        virtual refptr<Vector> getVector()
        {
            return refptr<Vector>(NULL);
        }
        virtual bool isShape() { return false; }
        virtual bool isMaterial() { return false; }
        virtual std::string getString() { return ""; }

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


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

    protected:
        int m_number;
};

class NumberNode : public Node
{
    public:
        NumberNode(double number) { m_number = number; }
        double getNumber() { return m_number; }

    protected:
        double m_number;
};

class VectorNode : public Node
{
    public:
        VectorNode(refptr<Vector> vector) { m_vector = vector; }
        refptr<Vector> getVector() { return m_vector; }

    protected:
        refptr<Vector> m_vector;
};


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

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

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

class ExposureNode : public NumberNode
{
    public:
        ExposureNode(double d) : NumberNode(d) {}
};

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 IntegerNode
{
    public:
        JitterNode(int i) : IntegerNode(i) {}
};

class LightNode : public Node
{
};

class LookAtNode : public VectorNode
{
    public:
        LookAtNode(refptr<Vector> 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 IntegerNode
{
    public:
        NGonNode(int i) : IntegerNode(i) {}
};

class OffsetNode : public NumberNode
{
    public:
        OffsetNode(double d) : NumberNode(d) {}
};

class OptionsNode : public Node
{
};

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

class PlanePositionNode : public Node
{
    public:
        PlanePositionNode(refptr<Vector> vec, double dist)
        {
            m_vector = vec;
            m_dist = dist;
        }
        refptr<Vector> getVector() { return m_vector; }
        double getNumber() { return m_dist; }

    protected:
        refptr<Vector> m_vector;
        double m_dist;
};

class PolygonNode : public Node
{
};

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

class RadiusNode : public NumberNode
{
    public:
        RadiusNode(double d) : NumberNode(d) {}
};

class ReflectanceNode : public NumberNode
{
    public:
        ReflectanceNode(double d) : NumberNode(d) {}
};

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

    protected:
        double m_angle;
};

class RotateBlockNode : public RotateNode
{
    public:
        RotateBlockNode(double angle, refptr<Vector> vector)
            : RotateNode(angle, vector)
        {
        }
};

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

class ScaleBlockNode : public ScaleNode
{
    public:
        ScaleBlockNode(refptr<Vector> vector) : ScaleNode(vector) {}
};

class SceneNode : public Node
{
};

class ShininessNode : public NumberNode
{
    public:
        ShininessNode(double d) : NumberNode(d) {}
};

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

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

class TranslateBlockNode : public TranslateNode
{
    public:
        TranslateBlockNode(refptr<Vector> vector) : TranslateNode(vector) {}
};

class TransparencyNode : public NumberNode
{
    public:
        TransparencyNode(double d) : NumberNode(d) {}
};

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

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

class VFOVNode : public NumberNode
{
    public:
        VFOVNode(double d) : NumberNode(d) {}
};

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

#endif