/cygdrive/d/src/svn/vrut/trunk/core/src/scenenode.h

Go to the documentation of this file.

/*
 * $Id: scenenode.h 713 2009-02-20 13:51:13Z misek $
 *
 * Description  : One line description of file.
 * Author       : Vaclav Kyba <mail/Jabber: vaseo1@gmail.com>  <ICQ: 98576293>
 *
 * Purpose      :
 *     Long description of what the file is for.
 */


#ifndef __SCENENODE__H__
#define __SCENENODE__H__

#include <list>
#include <wx/string.h>
#include "rwlock.h"
#include "flexilog.h"
#include "common.h"
#include "moddefs.h"


namespace VRUT
{
       class SceneNode : public ReadWriteMutex
       {
       public:
              typedef std::list<NODE_ID> NodeIDList;

              enum SCENENODE_TYPE
              {
                     ASSEMBLY = 0,  
                     ROOT     = 1,  
                     CAMERA   = 2,  
                     GEOMETRY = 4,  
                     LIGHT    = 8   
              };

       private:
              wxString uid;
              wxString name;
              NODE_ID id;
              SCENENODE_TYPE type;

              MATRIX localTransMatrix;
              MATRIX worldTransMatrix;
              bool valid;

              bool active;

              NodeIDList children;
              NODE_ID parent;

       public:
              SceneNode(const wxString & _uid, const wxString & _name, SCENENODE_TYPE _type)
              : uid(CloneWxString(_uid)), name(CloneWxString(_name)), type(_type)
              {
                     wxASSERT_MSG(IsOk(), wxT("<SceneNode>Failed to create mutex"));
                     active = true;
                     valid = false;
                     id = parent = NODE_ID_NONE;
              }

              SceneNode(const SceneNode & n)
                     : ReadWriteMutex(), uid(CloneWxString(n.uid)), name(CloneWxString(n.name)), id(n.id), type(n.type),
                     localTransMatrix(n.localTransMatrix), worldTransMatrix(n.worldTransMatrix),
                     valid(n.valid), active(n.active), parent(n.parent)
              {
                     children.assign(n.children.begin(), n.children.end());
              }

              virtual ~SceneNode()
              {
              }

              const wxString & GetUid() const
              {
                     return uid;
              }

              const wxString & GetName() const
              {
                     return name;
              }

              NODE_ID GetID() const
              {
                     return id;
              }

              const MATRIX * GetLocalTransMatrix() const
              {
                     return &localTransMatrix;
              }

              const MATRIX * GetWorldTransMatrix() const
              {
                     if (!valid)
                            LOGWARNING(wxT("<SceneNode>Getting invalid world transformation matrix - update first"));
                     return &worldTransMatrix;
              }

              const NodeIDList * GetChildren() const
              {
                     return &children;
              }

              NODE_ID GetParent() const
              {
                     return parent;
              }

              bool IsValid() const
              {
                     return valid;
              }

              bool IsActive() const
              {
                     return active;
              }

              void SetActive(const bool _active)
              {
                     active=_active;
              }

              SCENENODE_TYPE GetType() const
              {
                     return type;
              }

              bool IsOfType(SCENENODE_TYPE _type) const
              {
                     return ( type == _type );
              }

              virtual wxString ToString() const
              {
                     return wxString::Format(wxT("ID: %i\nName: %s\nType: %i\nLocal:\n%sWorld:\n%s"),
                            unsigned(GetID()),
                            GetName().c_str(),
                            type,
                            GetLocalTransMatrix()->ToString().c_str(),
                            ( IsValid() ? GetWorldTransMatrix()->ToString().c_str() : wxT("invalid\n") ));
              }
              virtual SceneNode * Clone() const
              {
                     return new SceneNode(*this);
              }

              friend class Scene;
       };
};

#endif

---