CPPGPGPU Library - Reference (Doxygen)

---

Main Page | General Use | Reference | Examples Info | Get/Download CPPGPGPU | SF.net Page

---

Node.h

Go to the documentation of this file.

//Generic scene graph node for use in -- anything.

//Note that this is the following:
// An object that can have multiple parents, and multiple children.
// Each object knows who its parents are, and who its children are.
// Each object is actually a shadow of the real object.
// This is because a refcounter, or safe pointer of sorts is used.
// Additionally, All nodes have RTTI of sorts.

#ifndef _NODE_H
#define _NODE_H

#include <stdio.h>
#include <string>
#include <vector>
#include <map>

using namespace std;

class NodeObject;


class Node
{
public:
    Node();
    Node( NodeObject * nToInit );
    Node( const Node & nToCopy );
    ~Node();

    Node & operator = ( const Node & rhs );
    Node & operator = ( NodeObject * rhs );

    inline bool IsNull() { return This!=0; }
    inline operator NodeObject * () { return This; }
    inline NodeObject & operator * () { return *This; }
    inline NodeObject * Get() { return This; }
    inline const NodeObject * Get() const { return This; }
    inline NodeObject * operator -> () { return This; }
    inline const NodeObject * operator -> () const { return This; }

    inline bool operator == ( const Node & rhs ) const { return This==rhs.This; }


    inline bool operator < ( const Node & rhs ) const { return ((long long)This)<((long long)rhs.This); }
private:
    void Hook( NodeObject * n );

    void Unhook( NodeObject * n );

    NodeObject * This;
};



class NodeObject
{
public:
    NodeObject( const string & sName );
    virtual ~NodeObject();

    virtual string GetType() { return "NodeBase"; }

    virtual bool IsTypeOf( const string & sType ) { return sType.compare( "NodeBase" )==0; }

    void SetName( const string & sName );

    string GetName() { return m_sName; }

    Node AttachChild( Node n );

    void DetachChild( Node n );

    inline int GetCount() { return m_iCount; }

    void DestroySelfOnUpdate() { m_bDestroyOnUpdate = true; }

    virtual void Init();

    virtual void Render();

    virtual void Update( const float fDtime );

    virtual void Message( int iMessageID, const string & sMessageName, const string & sMessagePayload );

    virtual void Disestablish();

    virtual void Reload() { Disestablish(); Init(); }

    void Lock();

    void Unlock();
private:
#ifndef NOSYNCHRONIZATION
    void * m_vMutex;
#endif

    inline void DecCount() { m_iCount--; }

    inline void IncCount() { m_iCount++; }

    friend class Node;

    void AttachParent( NodeObject * n );

    void DetachParent( NodeObject * n );

    string m_sName;

    vector< NodeObject * > m_vnParents;

    vector< Node > m_vnChildren;

    int m_iCount;

    bool m_bDestroyOnUpdate;
};

#define CLASS_RTTI( NAME, PARENT ) \
    virtual string GetType() { return #NAME; } \
    virtual bool IsTypeOf( const string & sType ) { return (sType.compare( #NAME ) == 0)?true:PARENT::IsTypeOf( sType ); }

#define REGISTER_CLASS( CLASSNAME ) \
    NodeObject * Produce##CLASSNAME( const string & sObjectName ) \
    { return new CLASSNAME( sObjectName ); } \
    class RegClass##CLASSNAME { public: \
        RegClass##CLASSNAME() { \
        NodeManager::Instance()->RegisterType( #CLASSNAME, Produce##CLASSNAME ); \
        } \
    }; \
    RegClass##CLASSNAME AUTOREG##CLASSNAME;

typedef NodeObject * (*ProducerFunct)( const string & sObjectName );

class NodeManager
{
public:
    static NodeManager * Instance();

    void RegisterType( const string & sClass, ProducerFunct t );

    Node Spawn( const string & sClass, const string & sName );

    Node SpawnExplicit( const string & sClass, const string & sName );

    void Drop( NodeObject * nObject );

    void Add( NodeObject * nObject );

    inline Node GetInstance( const string & sName ) { return Node( GetInstanceExp( sName ) ); }

    inline NodeObject * GetInstanceExp( const string & sName ) {
        map< string, NodeObject * >::iterator i( m_mInstances.find( sName ) );
        if( i != m_mInstances.end() )
            return i->second;
        else
            return NULL;
    }

    void RegisterForMessage( const string & sMessage, int iMessageID, Node nToRegister );

    void UnregisterForMessage( const string & sMessage, int iMessageID, Node nToRegister );

    void BroadcastMessage( const string & sMessage, const string & sPayload, Node nTarget );

    void PostMessage( const string & sMessage, const string & sPayload, Node nTarget, const float fTimeInFuture = 0 );

    void Update( const float fDtime );

    inline NodeObject * DerefGet( const string & sType, const string & sName ) { return Spawn( sType, sName ).Get(); }

    map< string, NodeObject* > * GetObjectInstanceMap() { return &m_mInstances; }

private:
    bool m_bInit;

    map< string, ProducerFunct > m_mToMake;

    map< string, NodeObject * > m_mInstances;

    map< string, map< Node, int > > m_mMessageMatches;

    struct StringPair
    {
        StringPair( const string & P1, const string & P2, NodeObject * NT ) 
          : sP1( P1 ), sP2( P2 ), nTarget(NT) { }
        string sP1, sP2;
        NodeObject * nTarget;
    };
    vector< StringPair >  m_dImmediateMessages;

    struct StringPairFloat
    {
        StringPairFloat( const string & P1, const string & P2, Node NT, float ft )
          : sP1( P1 ), sP2( P2 ), nTarget(NT), fFuture( ft ) { }
        StringPairFloat() : fFuture( 0 ) { }
        string sP1, sP2;
        Node nTarget;
        double fFuture;
    };

    vector< StringPairFloat > m_vFutureMessages;    //Lower values = farther in future

    double m_fCurrentTime;
};

extern NodeManager * NODEMAN;

#define NODE_CAST( Node, Type ) \
    (Node.Get()?((Type*) (Node->IsTypeOf(#Type)?Node.Get():NULL)):NULL)

#define GET_NODE_CAST( NodeName, Type ) \
    ((Type*)NODEMAN->DerefGet( #Type, NodeName ))

#define CODERENDERNODE( NODENAME, CODEIN, CODEOUT ) \
class NODENAME : public NodeObject \
{ \
public: \
    NODENAME( const string & sName ) : NodeObject( sName ) { } \
    CLASS_RTTI( NODENAME, NodeObject ); \
 \
    virtual void Render() { CODEIN; NodeObject::Render(); CODEOUT; } \
};

#endif

/*
Copyright (c) 2007 Charles Lohr

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
*/

---

© 2005-2007 Charles Lohr, Joshua Allen, David Chapman, Andrew Lohr. All material including documentation under the MIT/X11 license.