eng_node.hh

Go to the documentation of this file.

/*
 * LEGAL:   COPYRIGHT (C) 2007 JIM E. BROOKS
 *          THIS SOURCE CODE IS RELEASED UNDER THE TERMS
 *          OF THE GNU GENERAL PUBLIC LICENSE VERSION 2 (GPL 2).
 *****************************************************************************/

#ifndef ENG_NODE_HH
#define ENG_NODE_HH 1

namespace eng {

// File-wide way to make everything in a .cc file a friend of Node.
// Node's implementation is distributed across several .cc files.
#ifndef NODE_PRIVATE
#define NODE_PRIVATE private
#endif
#ifndef NODE_PROTECTED
#define NODE_PROTECTED protected
#endif

// NODE_FRIENDS is expanded into Node and derivative classes.
#ifndef MORE_NODE_FRIENDS
#define MORE_NODE_FRIENDS
#endif
#define NODE_FRIENDS \
    friend class Value; friend class NodeClones; \
    friend class Graph; friend class GraphMaker; friend class GraphImporter; \
    MORE_NODE_FRIENDS

class Node;
class Visitor;
class Graph;
class NodeClones;

#if DEBUG
void CheckNode( const Node* node, bool nullOk );
void CHECK_PATERNITY( const Node& parent, const Node& child );
template<typename NODE> void CHECK_NODE(         SharedPtrNull<NODE> node ) { CheckNode( node.CONST_PTR(), false ); }
template<typename NODE> void CHECK_NODE_NULL_OK( SharedPtrNull<NODE> node ) { CheckNode( node.CONST_PTR(), true ); }
INLINE void                  CHECK_NODE( const Node* node ) { CheckNode( node, false ); }
#else
#define CHECK_NODE(NODE)
#define CHECK_NODE_NULL_OK(NODE)
#define CHECK_PATERNITY(parent,child)
#endif

class Node : public Shared
{
//..............................................................................
// Macros:
#define NULL_NODE     (NULL)
#define IF_NODE(NODE) ((NODE) != (NULL))

//..............................................................................
// Types:
public:    typedef SharedPtrNull<Node>  Ptr;
protected: typedef uint                 Idx;                       
protected: CLASS_CONST Idx              INVALID_IDX = 0xb00bb00b;  

//..............................................................................
// Type ID (LIMITED-USE):
// Intended for debug assertions only.

NODE_PROTECTED:
    enum TypeId
    {
        ID_LOD_NODE,
        ID_PARTITION_NODE,
        ID_TRANSFORM_NODE,
        ID_VERTEXS_NODE,
        ID_NORMALS_NODE,
        ID_MODES_NODE,
        ID_MATERIAL_NODE,
        ID_TEXTURE_NODE,
        ID_COLORS_NODE,
        ID_POLYGON_NODE,
        ID_SPECIAL_NODE
    };

NODE_PROTECTED: virtual TypeId  GetTypeId( void ) const = 0;

//..............................................................................
// Node (value, key, priority):
// To compare net priority, use the operator<(Node&,Node&).

public:
    class Value
    {
    
    friend bool operator<( const Node& node1, const Node& node2 );
    NODE_PROTECTED:
        // ePriority1 is occasionally misused as a type ID in assertions.
        enum ePriority1
        {
            ePriority1_LodNode        = 10,  // Graph ctor allocates LodNode as the root
            ePriority1_PartitionNode  = 9,
            ePriority1_TransformNode  = 8,
            ePriority1_VertexsNode    = 7,
            ePriority1_NormalsNode    = 6,
            ePriority1_ModesNode      = 5,
            ePriority1_MaterialNode   = 4,
            ePriority1_TextureNode    = 3,
            ePriority1_ColorsNode     = 2,
            ePriority1_PolygonNode    = 1,
            ePriority1_SpecialNode    = 0
        };
    public:
                            Value( void ) { }
        virtual             ~Value() { }
    NODE_PROTECTED:
        virtual ePriority1  GetPriority1( void ) const = 0;
        virtual bool        LessThan( const Value& otherValue ) const
        {
            // 2nd-order homogeneous priority is dynamically computed by derivative's LessThan().
            // Default only compares priority1 and assumes priority2 are equal (homogeneuous are equal).
            return GetPriority1() < otherValue.GetPriority1();
        }
    };

public:
    friend inline bool
    operator<( const Node& node1, const Node& node2 )
    {
    CHECK_TYPESIG(&node1,TYPESIG_NODE);
    CHECK_TYPESIG(&node2,TYPESIG_NODE);
        // Compare polymorphic Node::Value.
        return node1.GetValue().LessThan( node2.GetValue() );  // value1 < value2
    }

    friend inline bool
    operator==( const Node& node1, const Node& node2 )
    {
        return (not (node1 < node2))
            && (not (node2 < node1));
    }

    friend inline bool
    operator!=( const Node& node1, const Node& node2 )
    {
        return not (node1 == node2);
    }

NODE_PROTECTED:
    class SortableNode  // isn't a Node derivative
    {
    
    public:
                    SortableNode( void ) : mNode(NULL_NODE) { }
                    SortableNode( Node::Ptr node ) : mNode(node) { CHECK_TYPESIG(node,TYPESIG_NODE); }
        Node::Ptr   GetNode( void ) const { CHECK_TYPESIG_NULL_OK(mNode,TYPESIG_NODE); return mNode; }
        operator Node::Ptr() const { return GetNode(); }
        // Compare priorities using operator(Node&,Node&)
        friend inline bool operator==( const SortableNode& node1, const SortableNode& node2 )
        { return *node1.mNode == *node2.mNode; }
        friend inline bool operator<( const SortableNode& node1, const SortableNode& node2 )
        { return *node1.mNode < *node2.mNode; }

    private:
        Node::Ptr mNode;
    };

NODE_PROTECTED:
    class SortedNodes
    {
    
    public:
                        SortedNodes( void );
                        SortedNodes( const SortedNodes& src );
        SortedNodes&    operator=( const SortedNodes& src );
                        ~SortedNodes();
        // Return const to guard sorted order.
        const SortableNode& operator[]( uint i ) const { return (*mSortedNodes)[i]; }
        const SortableNode& front( void ) const;
        const SortableNode& back( void ) const;
        uint            size( void ) const { return (mSortedNodes != NULL) ? mSortedNodes->size() : 0; }
        bool            empty( void ) const { return size() == 0; }
        void            clear( void );
        pair<bool,uint> find_last( const SortableNode& sortableNode ) const;
        uint            insert( const SortableNode& sortableNode );
        bool            remove_first( const SortableNode& sortableNode );
        void            remove_idx( const uint idx );
    private:
        SortedArray<SortableNode>*  mSortedNodes;
    };

//..............................................................................
// Methods (ctor, dtor):
public:                         Node( void );
public:                         Node( const Node& src );
public:    virtual              ~Node();
protected: virtual Node::Ptr    Clone( void ) const = 0;

//..............................................................................
// Methods (query):
protected: bool             IfDetached( void ) const;
protected: bool             IfChildren( void ) const;

//..............................................................................
// Methods (priority/key):
// Despite its name, Node::Value is also used as a key for sorting child nodes.
// GetValue() returns const Value as a feeble effort to prevent modifying a key,
// though, technically, the values of some types of Node will change but their net priority won't.

public:    virtual const Node::Value& GetValue( void ) const = 0;  // for use as a key, despite name

//..............................................................................
// Methods (links):
// Disabling or enabling nodes can be done by calling DetachChild(), AttachChild().
// which doesn't burden Traverse() as Node::mEnable flag would.

public:
    Node::Ptr       GetParent( void ) const;
NODE_PROTECTED:
    SortedNodes&    GetChildren( void );
    Node::Ptr       GetFirstChild( void ) const  // freq
                    {
                    CHECK_TYPESIG(this,TYPESIG_NODE);
                        if ( not mChildren.empty() )
                        {
                        CHECK_TYPESIG(mChildren.front().GetNode(),TYPESIG_NODE);
                        CHECK_PATERNITY(*this,*mChildren.front().GetNode());
                            return mChildren.front();
                        }
                        else
                            return NULL_NODE;
                    }
    Node::Ptr       GetLastChild( void ) const;
    Node::Ptr       GetPrevSibling( void ) const;
    Node::Ptr       GetNextSibling( void ) const  // freq
                    {
                    CHECK_TYPESIG(this,TYPESIG_NODE);
                        if ( (mParent != NULL_NODE) && (mSiblingIdx+1 < mParent->mChildren.size()) )
                        {
                            CHECK_TYPESIG(mParent->mChildren[mSiblingIdx+1].GetNode(),TYPESIG_NODE);
                            return mParent->mChildren[mSiblingIdx+1];
                        }
                        else
                            return NULL_NODE;
                    }

//..............................................................................
// Methods (attach, detach):

NODE_PROTECTED: void         SetParent( Node::Ptr parent );         // LIMITED-USE
public:         void         AttachSibling( Node::Ptr sibling );
public: virtual void         AttachChild( Node::Ptr child );
public:         void         Detach( const bool keepChildren = false );
public: virtual void         DetachChild( Node::Ptr child );

//..............................................................................
// Methods (Visitor):
protected: virtual void      Accept( Visitor& visitor ) = 0;

//..............................................................................
// Methods (departure action):
protected: virtual void      Departure( void ) { }  
protected: virtual bool      IfDeparture( void ) const { return false; }  

//..............................................................................
// Data:
NODE_PROTECTED: CLASS_CONST uint    VCNT = 4;       
NODE_PROTECTED: Node::Ptr           mParent;        
NODE_PROTECTED: SortedNodes         mChildren;      
NODE_PROTECTED: Node::Idx           mSiblingIdx;    
NODE_PRIVATE:   Node::Idx           mCloneIdx;      

//..............................................................................
// Friends:
NODE_FRIENDS // expand macro

//..............................................................................
// Debug:
#if DEBUG
NODE_PRIVATE: CLASS_VAR long msInstanceCnt;
friend void CheckNode( const Node* node, bool nullOk );
#endif
      // final member
};

//==============================================================================
} // namespace eng
#include "eng_node_visitor.hh"
namespace eng {
//==============================================================================

class LodNode : public Node
{
NODE_FRIENDS
public:
    typedef SharedPtrNull<LodNode> Ptr;

public:
    class Value : public Node::Value
    {
    
    friend class LodNode;
    public:
                        Value( void ) { }
        ePriority1      GetPriority1( void ) const { return ePriority1_LodNode; }
      //bool            LessThan()  // a Graph has only one LodNode
    private:
        struct ChildNode
        {
            ChildNode( Node::Ptr node, ObjectLod objectLod )
            : mNode(node), mObjectLod(objectLod) { CHECK_NODE(node); }
            const Node::Ptr     mNode;
            const ObjectLod     mObjectLod;
        };

    private:
        ObjectLod       mObjectLod;  // the LOD of this Graph (ObjectLod defaults to any LOD)
        list<ChildNode> mAllChildren;
    };

public:     LodNode( const Value& value );
public:     LodNode( const LodNode& src );
public:     void                    Accept( Visitor& visitor ) { visitor.Visit( *this ); }
public:     const LodNode::Value&   GetValue( void ) const { return mValue; }
protected:  Node::Ptr               Clone( void ) const;
NODE_PROTECTED: TypeId              GetTypeId( void ) const;

// Specific methods:
public:
    // LodNod is THE root node and appears uniquely in a Graph.
    void    SetLod( const ObjectLod objectLod );
    void    AttachChild( Node::Ptr child );
    void    AttachChild( Node::Ptr child, const ObjectLod objectLod );
    void     DetachChild( Node::Ptr child );

private:
    Value   mValue;
};

class PartitionNode : public Node
{
NODE_FRIENDS
public:
    typedef SharedPtrNull<PartitionNode> Ptr;

    class Value : public Node::Value
    {
    
    friend class PartitionNode;
    public:
                    Value( const string& name );
        ePriority1  GetPriority1( void ) const { return ePriority1_PartitionNode; }
        bool        LessThan( const Node::Value& otherValue ) const;
    private:
        string      mName;
        bool        mPivotValid;  // if mPivotVertex is valid
        LocalVertex mPivotVertex;
    };

public:     PartitionNode( const Value& value );
public:     PartitionNode( const PartitionNode& src );
public:     void                        Accept( Visitor& visitor ) { visitor.Visit( *this ); }
public:     const PartitionNode::Value& GetValue( void ) const { return mValue; }
protected:  Node::Ptr                   Clone( void ) const;
NODE_PROTECTED: TypeId                  GetTypeId( void ) const;

// Specific methods:
public:
    void            Enable( const bool enable = true );
    const string    GetName( void ) const { return mValue.mName; }
    void            SetPivotVertex( const LocalVertex& pivotVertex );

private:
    Value           mValue;
    bool            mEnabled;           
    SortedNodes     mChildrenSwapped;   
};

class TransformNode : public Node
{
NODE_FRIENDS
public:
    typedef SharedPtrNull<TransformNode> Ptr;

    class Value : public Node::Value
    {
    
    friend class TransformNode;
    public:
                    Value( SharedPtr<Matrix> matrix ) : mMatrix(matrix) { }
        ePriority1  GetPriority1( void ) const { return ePriority1_TransformNode; }
        bool        LessThan( const Node::Value& otherValue ) const;
    private:
        SharedPtr<Matrix>   mMatrix;
    };

public:     TransformNode( const Value& value );
public:     TransformNode( const TransformNode& src );
public:     void                        Accept( Visitor& visitor ) { visitor.Visit( *this ); }
public:     const TransformNode::Value& GetValue( void ) const { return mValue; }
protected:  Node::Ptr                   Clone( void ) const;
NODE_PROTECTED: TypeId                  GetTypeId( void ) const;

// Specific methods:
// The reason GetMatrix() returns a const Matrix is to force calling SetMatrix()
// to change a matrix which gives TransformNode to update itself in case
// it is implemented with a quaternion.
public:
  //shptr<const Quaternion> GetQuaternion( void );              // possible extension
  //void                    SetQuaternion( shptr<Quaternion> );
    SharedPtr<const Matrix>     GetMatrix( void ) { return mValue.mMatrix.CONST_PTR(); }
    void                    SetMatrix( const Matrix& matrix ) { *mValue.mMatrix = matrix; }
    void                    SetPosition( const WorldVertex& position ) { mValue.mMatrix->SetOrigin( position ); }
    WorldVertex             GetPosition( void ) { return WorldVertex(mValue.mMatrix->GetOrigin()); }

private:
    Value   mValue;
};

class VertexsNode : public Node
{
NODE_FRIENDS
public:
    typedef SharedPtrNull<VertexsNode> Ptr;

    class Value : public Node::Value
    {
    
    friend class VertexsNode;
    public:
                    Value( SharedPtr<LocalVertexs> localVertexs ) : mLocalVertexs(localVertexs) { }
        ePriority1  GetPriority1( void ) const { return ePriority1_VertexsNode; }
      //bool        LessThan()  // VertexsNode is unique within a partition
    private:
        SharedPtr<LocalVertexs> mLocalVertexs;
    };

public:     VertexsNode( const Value& value );
public:     VertexsNode( const VertexsNode& src );
public:     void                        Accept( Visitor& visitor ) { visitor.Visit( *this ); }
public:     const VertexsNode::Value&   GetValue( void ) const { return mValue; }
protected:  Node::Ptr                   Clone( void ) const;
NODE_PROTECTED: TypeId                  GetTypeId( void ) const;

// Specific methods:
public:
    SharedPtr<LocalVertexs> GetLocalVertexs( void ) const { return mValue.mLocalVertexs; }
    void                SetLocalVertexs( SharedPtr<LocalVertexs> localVertexs ) { mValue.mLocalVertexs = localVertexs; }
    uint                GetVertexCnt( void ) const { return mValue.mLocalVertexs->size(); }

private:
    Value   mValue;
};

class NormalsNode : public Node
{
NODE_FRIENDS
public:
    typedef SharedPtrNull<NormalsNode> Ptr;

    class Value : public Node::Value
    {
    
    friend class NormalsNode; friend class GraphMaker;
    public:
        Value( SharedPtr<NormalVertexs> polygonNormals, SharedPtr<NormalVertexs> vertexNormals, bool normalsAreConstant = false );
        ePriority1  GetPriority1( void ) const { return ePriority1_NormalsNode; }
      //bool        LessThan()  // NormalsNode is unique within a partition
    private:
        SharedPtr<NormalVertexs>    mPolygonNormals;
        SharedPtr<NormalVertexs>    mVertexNormals;
        bool                    mRecomputeNormals;
        bool                    mRetransformNormals;
        bool                    mNormalsAreConstant;  
    };

public:     NormalsNode( const Value& value );
public:     NormalsNode( const NormalsNode& src );
public:     void                        Accept( Visitor& visitor ) { visitor.Visit( *this ); }
public:     const NormalsNode::Value&   GetValue( void ) const { return mValue; }
protected:  Node::Ptr                   Clone( void ) const;
NODE_PROTECTED: TypeId                  GetTypeId( void ) const;

// Specific methods:
public:
    SharedPtr<NormalVertexs>    GetPolygonNormals( void ) const { return mValue.mPolygonNormals; }
    SharedPtr<NormalVertexs>    GetVertexNormals( void ) const { return mValue.mVertexNormals; }
    void                    SetRecomputeNormals( bool f = true ) { mValue.mRecomputeNormals = f; }
    void                    SetRetransformNormals( bool f = true ) { mValue.mRetransformNormals = f; }
    bool                    IfRecomputeNormals( void ) const { return mValue.mRecomputeNormals; }
    bool                    IfRetransformNormals( void ) const { return mValue.mRetransformNormals; }
    bool                    IfNormalsAreConstant( void ) const { return mValue.mNormalsAreConstant; }

private:
    Value   mValue;
};

class ModesNode : public Node
{
NODE_FRIENDS
public:
    typedef SharedPtrNull<ModesNode> Ptr;

public:
    class Modes
    {
    
    public:
        // Note: Modes with higher priorities occupy most-signficant bits.
        // This affects ModesNode's 2nd-order priority, that is,
        // the priority of ModesNodes relative to each other.
        //
        // uint64() cast or "ull" suffix is critical to compile 64-bit shifts correctly.
        CLASS_CONST uint64 MODE_NONE        = 0;
        CLASS_CONST uint64 MODE_DEFAULT     = MODE_NONE;  // alias
        CLASS_CONST uint64 MODE_NO_CULL     = (uint64(1) << uint64(0));   // -- lowest-priority --
        CLASS_CONST uint64 MODE_TRANSLUCENT = (uint64(1) << uint64(63));  // -- highest-priority --

        Modes( void ) : mModes(MODE_DEFAULT) { }

        // This method combines modes, instead of client, in case Modes is ever extended/redefined.
        Modes& operator|=( const uint64 mode ) { mModes |= mode; return *this; }
        Modes& operator=( const uint64 modes ) { mModes = modes; return *this; }

        friend inline bool operator<( Modes a, Modes b ) { return a.mModes < b.mModes; }
        friend inline bool operator==( Modes a, Modes b ) { return a.mModes == b.mModes; }
        friend inline bool operator!=( Modes a, Modes b ) { return a.mModes != b.mModes; }

        bool IfMode( const uint64 mode ) const { return mModes & mode; }

    private:
        uint64  mModes;
    };

public:
    class Value : public Node::Value
    {
    
    friend class ModesNode;
    public:
                    Value( void ) : mModes() { }
                    Value( const ModesNode::Modes modes ) : mModes(modes) { }
        ePriority1  GetPriority1( void ) const { return ePriority1_ModesNode; }
        bool        LessThan( const Node::Value& otherValue ) const;
    private:
        ModesNode::Modes     mModes;
    };

public:     ModesNode( const Value& value );
public:     ModesNode( const ModesNode& src );
public:     void                    Accept( Visitor& visitor ) { visitor.Visit( *this ); }
public:     const ModesNode::Value& GetValue( void ) const { return mValue; }
protected:  Node::Ptr               Clone( void ) const;
NODE_PROTECTED: TypeId              GetTypeId( void ) const;

// Specific methods:
public:     const Modes         GetModes( void ) const { return mValue.mModes; }
public:     void                SetModes( const Modes modes );

private:
    Value       mValue;
};

class MaterialNode : public Node
{
NODE_FRIENDS
public:
    typedef SharedPtrNull<MaterialNode> Ptr;

    class Value : public Node::Value
    {
    
    friend class MaterialNode;
    public:
                    Value( void );  // no material
                    Value( const GFX::Material& material );
        ePriority1  GetPriority1( void ) const { return ePriority1_MaterialNode; }
        bool        LessThan( const Node::Value& otherValue ) const;
    private:
        GFX::Material   mMaterial;
        bool            mEnabled;
    };

public:     MaterialNode( const Value& value );
public:     MaterialNode( const MaterialNode& src );
public:     void                        Accept( Visitor& visitor ) { visitor.Visit( *this ); }
public:     const MaterialNode::Value&  GetValue( void ) const { return mValue; }
protected:  Node::Ptr                   Clone( void ) const;
NODE_PROTECTED: TypeId                  GetTypeId( void ) const;

// Specific methods:
public:
// UNIMPLEMENTED
    bool            IfEnabled( void ) const { return mValue.mEnabled; }

private:
    Value   mValue;
};

class TextureNode : public Node
{
NODE_FRIENDS
public:
    typedef SharedPtrNull<TextureNode> Ptr;

    class Value : public Node::Value
    {
    
    friend class TextureNode;
    public:
                    Value( void );
                    Value( SharedPtr<Texture> texture );
        ePriority1  GetPriority1( void ) const { return ePriority1_TextureNode; }
        bool        LessThan( const Node::Value& otherValue ) const;
    public:
        SharedPtr<Texture>  mTexture;
    private:
        bool            mIdentityTextureMatrix;  // true if mTextureMatrix remains identity
        SharedPtr<Matrix>   mTextureMatrix;
    };

public:     TextureNode( const Value& value );
public:     TextureNode( const TextureNode& src );
public:     void                        Accept( Visitor& visitor ) { visitor.Visit( *this ); }
public:     const TextureNode::Value&   GetValue( void ) const { return mValue; }
protected:  Node::Ptr                   Clone( void ) const;
NODE_PROTECTED: TypeId                  GetTypeId( void ) const;

// Specific methods:
public:
    bool                IfEnabled( void ) const { return GetTexture()->IfValid(); }
    SharedPtr<Texture>      GetTexture( void ) const { return mValue.mTexture; }
    bool                IfIdentityTextureMatrix( void ) const { return mValue.mIdentityTextureMatrix; }
    SharedPtr<const Matrix> GetTextureMatrix( void ) const { return mValue.mTextureMatrix; }
    void                SetTextureMatrix( const Matrix& textureMatrix );

private:
    Value   mValue;
};

class ColorsNode : public Node
{
NODE_FRIENDS
public:
    typedef SharedPtrNull<ColorsNode> Ptr;
    typedef SmallArray<Node::VCNT,RGBA> Colors;

    class Value : public Node::Value
    {
    
    friend class ColorsNode; friend class GraphMaker;
    public:
                    Value( const ColorsNode::Colors& colors );  // multi-color
                    Value( const RGBA color );   // same color
        ePriority1  GetPriority1( void ) const { return ePriority1_ColorsNode; }
        bool        LessThan( const Node::Value& otherValue ) const;
    private:
        ColorsNode::Colors  mColors;    // plural
    };

public:     ColorsNode( const Value& value );
public:     ColorsNode( const ColorsNode& src );
public:     void                        Accept( Visitor& visitor ) { visitor.Visit( *this ); }
public:     const ColorsNode::Value&    GetValue( void ) const { return mValue; }
protected:  Node::Ptr                   Clone( void ) const;
NODE_PROTECTED: TypeId                  GetTypeId( void ) const;

// Specific methods:
public:     const Colors&       GetColors( void ) const { return mValue.mColors; }
public:     void                SetColors( const Colors& colors );
public:     void                SetColors( const RGBA color );

private:
    Value   mValue;
};

class PolygonNode : public Node
{
NODE_FRIENDS
public:
    typedef SharedPtrNull<PolygonNode> Ptr;
    typedef SmallArray<Node::VCNT,Vix> Vixs;  // differs from gfx::Vixs

    class Value : public Node::Value
    {
    
    friend class PolygonNode; friend class GraphMaker;
    public:
        // To compile vector<Vix> or Vixs arg.
        template<typename VIXS>
        Value( const VIXS& vixs, const Nix nix )
        {
        ASSERT( vixs.size() == 3 || vixs.size() == 4 );  // limited to triangles or quads
            for ( uint i = 0; i < vixs.size(); ++i )
                mVixs.push_back( vixs[i] );             // mVixs
            mNix = nix;                                 // mNix
        }
        ePriority1  GetPriority1( void ) const { return ePriority1_PolygonNode; }
        // Fast insertion/reindexing of PolygonNode children depends on them
        // having equal homogeneous priority.  See eng_node.cc and ReindexSiblings().
      //bool        LessThan( const Node::Value& otherValue ) const;  // priority2 equal
    private:
        PolygonNode::Vixs   mVixs;  
        Nix                 mNix;   
    };

public:     PolygonNode( const Value& value );
public:     PolygonNode( const PolygonNode& src );
public:     void                        Accept( Visitor& visitor ) { visitor.Visit( *this ); }
public:     const PolygonNode::Value&   GetValue( void ) const { return mValue; }
protected:  Node::Ptr                   Clone( void ) const;
NODE_PROTECTED: TypeId                  GetTypeId( void ) const;

// Specific:
public:
    void                        SetVixs( const PolygonNode::Vixs& vixs ) { mValue.mVixs = vixs; }
    const PolygonNode::Vixs&    GetVixs( void ) const { return mValue.mVixs; }
    void                        SetNix( const Nix nix ) { mValue.mNix = nix; }
    Nix                         GetNix( void ) const { return mValue.mNix; }

public:
    Value   mValue;
};

class PolygonNode_TriColor1: public PolygonNode
{
NODE_FRIENDS
public:     PolygonNode_TriColor1( const Value& value );
public:     PolygonNode_TriColor1( const PolygonNode_TriColor1& src );
public:     void        Accept( Visitor& visitor ) { visitor.Visit( *this ); }
protected:  Node::Ptr   Clone( void ) const;
};

class PolygonNode_TriColor3: public PolygonNode
{
NODE_FRIENDS
public:     PolygonNode_TriColor3( const Value& value );
public:     PolygonNode_TriColor3( const PolygonNode_TriColor3& src );
public:     void        Accept( Visitor& visitor ) { visitor.Visit( *this ); }
protected:  Node::Ptr   Clone( void ) const;
};

class PolygonNode_QuadColor1: public PolygonNode
{
NODE_FRIENDS
public:     PolygonNode_QuadColor1( const Value& value );
public:     PolygonNode_QuadColor1( const PolygonNode_QuadColor1& src );
public:     void        Accept( Visitor& visitor ) { visitor.Visit( *this ); }
protected:  Node::Ptr   Clone( void ) const;
};

class PolygonNode_QuadColor4: public PolygonNode
{
NODE_FRIENDS
public:     PolygonNode_QuadColor4( const Value& value );
public:     PolygonNode_QuadColor4( const PolygonNode_QuadColor4& src );
public:     void        Accept( Visitor& visitor ) { visitor.Visit( *this ); }
protected:  Node::Ptr   Clone( void ) const;
};

class PolygonNode_Tex : public PolygonNode
{
NODE_FRIENDS
public:
    typedef SmallArray<Node::VCNT,TexCoord> TexCoords;  // differs from gfx::TexCoords

    class Value : public PolygonNode::Value
    {
    
    friend class PolygonNode_Tex;
    public:
        // To compile vector<Vix/TexCoords> or Vixs/TexCoords args.
        template<typename VIXS,typename TEXCOORDS>
        Value( const VIXS& vixs, const Nix nix, const TEXCOORDS& texCoords )
        :   PolygonNode::Value(vixs,nix)
        {
        ASSERT( vixs.size() == texCoords.size() );
            for ( uint i = 0; i < texCoords.size(); ++i )
                mTexCoords.push_back( texCoords[i] );
        }
    private:
        PolygonNode_Tex::TexCoords   mTexCoords;
    };

public:     PolygonNode_Tex( const Value& value );
public:     PolygonNode_Tex( const PolygonNode_Tex& src );
public:     void                            Accept( Visitor& visitor ) { visitor.Visit( *this ); }
public:     const PolygonNode_Tex::Value&   GetValue( void ) const { return mValue; }
protected:  Node::Ptr                       Clone( void ) const;

// Specific methods:
public:
    const PolygonNode_Tex::TexCoords&   GetTexCoords( void ) const { return mValue.mTexCoords; }

public:
    Value   mValue;
};

class PolygonNode_TexTriColor1: public PolygonNode_Tex
{
NODE_FRIENDS
public:     PolygonNode_TexTriColor1( const Value& value );
public:     PolygonNode_TexTriColor1( const PolygonNode_TexTriColor1& src );
public:     void        Accept( Visitor& visitor ) { visitor.Visit( *this ); }
protected:  Node::Ptr   Clone( void ) const;
};

class PolygonNode_TexTriColor3: public PolygonNode_Tex
{
NODE_FRIENDS
public:     PolygonNode_TexTriColor3( const Value& value );
public:     PolygonNode_TexTriColor3( const PolygonNode_TexTriColor3& src );
public:     void        Accept( Visitor& visitor ) { visitor.Visit( *this ); }
protected:  Node::Ptr   Clone( void ) const;
};

class PolygonNode_TexQuadColor1: public PolygonNode_Tex
{
NODE_FRIENDS
public:     PolygonNode_TexQuadColor1( const Value& value );
public:     PolygonNode_TexQuadColor1( const PolygonNode_TexQuadColor1& src );
public:     void        Accept( Visitor& visitor ) { visitor.Visit( *this ); }
protected:  Node::Ptr   Clone( void ) const;
};

class PolygonNode_TexQuadColor4: public PolygonNode_Tex
{
NODE_FRIENDS
public:     PolygonNode_TexQuadColor4( const Value& value );
public:     PolygonNode_TexQuadColor4( const PolygonNode_TexQuadColor4& src );
public:     void        Accept( Visitor& visitor ) { visitor.Visit( *this ); }
protected:  Node::Ptr   Clone( void ) const;
};

class SpecialNode : public Node
{
public:
    typedef SharedPtrNull<SpecialNode> Ptr;

    class Value : public Node::Value
    {
    
    friend class SpecialNode;
    public:
                    Value( void ) { }
        ePriority1  GetPriority1( void ) const { return ePriority1_SpecialNode; }
      //bool        LessThan()  // SpecialNodes are equal
    };

                SpecialNode( void ) : Node(), mValue() { }
                SpecialNode( const SpecialNode& src ) : Node(src), mValue(src.mValue) { }
    virtual     ~SpecialNode() { }

public:     virtual void                Accept( Visitor& visitor ) { visitor.Visit( *this ); }
public:     const SpecialNode::Value&   GetValue( void ) const { return mValue; }
protected:  virtual Node::Ptr           Clone( void ) const = 0;
// Derivatives of SpecialNode should keep ID_SPECIAL_NODE.
NODE_PROTECTED: TypeId                  GetTypeId( void ) const { return ID_SPECIAL_NODE; }

private:
    Value   mValue;
};

} // namespace eng

#endif // ENG_NODE_HH

Palomino 3D Engine documents generated by doxygen 1.5.3 on Fri Nov 23 11:26:09 2007