SceneGraphNode.hpp

#ifndef SCENEGRAPHNODE_H
#define SCENEGRAPHNODE_H
 
#ifndef INCLUDE_LIST_H
#    include <list>
#    define INCLUDE_LIST_H
#endif
#ifndef INCLUDE_STRING_H
#    include <string>
#    define INCLUDE_STRING_H
#endif
#ifndef MATRIX_H
#    include "Matrix.hpp"
#endif
#ifndef VEC3_H
#    include "Vec3.hpp"
#endif
#ifndef QUATERNION_H
#    include "Quaternion.hpp"
#endif
 
class Scene;
 
#ifdef SIMD_SSE3
class BEGIN_ALIGNED( SceneGraphNode, 16 )
#else
class SceneGraphNode
#endif
{
  public:
    enum class Type { None, Model, Camera, Light };
 
    static void RegisterScene( Scene* scene );
    
    static void UnregisterScene();
    
    SceneGraphNode();
    
    virtual ~SceneGraphNode();
    
    virtual bool AddChild( SceneGraphNode* child );
 
    virtual bool ContainsChild( const SceneGraphNode* node ) const;
 
    virtual void FindFirstChildWithName( const char* name, SceneGraphNode** outNode );
    
    virtual void SetLayerMask( unsigned mask ) { layerMask = mask; }
    
    virtual void SetName( const std::string& newName ) { name = newName; }
    
    virtual void SetPosition( const Vec3& aPosition ) { position = aPosition; dirtyTransform = true; }
    
    virtual void SetRotation( const Quaternion& aRotation ) { rotation = aRotation; dirtyTransform = true; }
 
    virtual Quaternion GetRotation() const { return rotation; }
    
    virtual void SetScale( float aScale ) { scale = aScale; dirtyTransform = true; }
 
    virtual float GetScale() const { return scale; }
    
    virtual void SolveMatrices();
    
    virtual SceneGraphNode* Parent() { return parent; }
    
    virtual std::string GetName() const { return name; }
    
    virtual Type GetType() const { return type; }
    
    virtual unsigned GetLayerMask() const { return layerMask; }
    
    virtual std::list< SceneGraphNode* >& Children() { return children; }
    
    virtual Vec3 GetPosition() const { return position; }
 
    virtual SceneGraphNode* Root();
 
    std::list< SceneGraphNode* > children;
 
    void CleanDirties();
 
    bool IsDirty() const
    {
        bool outDirty = dirtyTransform;
        
        if (outDirty)
        {
            return true;
        }
        
        SceneGraphNode* testParent = parent;
        
        while (testParent)
        {
            if (testParent->dirtyTransform)
            {
                return true;
            }
            else
            {
                testParent = testParent->parent;
            }
        }
        
        return false;
    }
 
    Matrix44 modelMatrix;
 
protected:
    Type type;
    float scale;
    Vec3 position;
    SceneGraphNode* parent;
    Quaternion rotation;
    std::string name;
    bool dirtyTransform = true;
    unsigned layerMask = 0xFFFFFFFF;
 
  private:
    void FindChild( const SceneGraphNode* node, bool& outFound ) const;
 
    static Scene* sScene;
}
#ifdef SIMD_SSE3
END_ALIGNED( SceneGraphNode, 16 )
#endif
;
#endif