E:/Programming/MyProject/K_Game_hg/GameEngine/include/scene/Node.h

Go to the documentation of this file.

// Copyright 2006-2011 by Kat'Oun

#ifndef _NODE_H_
#define _NODE_H_

#include <EngineConfig.h>
#include <core/Types.h>
#include <core/Vector3d.h>
#include <core/Quaternion.h>
#include <core/Matrix4.h>
#include <engine/Object.h>
#include <scene/NodeDefines.h>

#include <map>

namespace scene
{

class ENGINE_PUBLIC_EXPORT Node: public engine::Object
{
        //friend class SceneManager; // Allow full access to scene manager

public:
        
        Node();
        Node(const std::string& name);

        virtual ~Node();

        const NodeType& getNodeType() const;

        virtual void setPosition(f32 x, f32 y, f32 z);
        virtual void setPosition(const core::vector3d& pos);

        const core::vector3d& getPosition();

        virtual void setOrientation(const core::quaternion& q);

        const core::quaternion& getOrientation();

        void setScale(f32 x, f32 y, f32 z);
        void setScale(const core::vector3d& scale);

        const core::vector3d& getScale();

        const core::vector3d getDirection();

        const core::vector3d getUp();

        const core::vector3d getRight();

        void setInheritOrientation(bool inherit);
        bool getInheritOrientation();

        void setInheritScale(bool inherit);
        bool getInheritScale();

        //Transformations on all coordinates
        virtual void scale(const core::vector3d& scale);
        virtual void translate(const core::vector3d& d, TransformSpace relativeTo = TS_LOCAL);
        virtual void rotate(const core::quaternion& q, TransformSpace relativeTo = TS_LOCAL);
        
        virtual void rotate(const f32& degrees, const core::vector3d& axis, TransformSpace relativeTo = TS_LOCAL);
        virtual void rotateX(f32 degrees, TransformSpace relativeTo = TS_LOCAL);
        virtual void rotateY(f32 degrees, TransformSpace relativeTo = TS_LOCAL);
        virtual void rotateZ(f32 degrees, TransformSpace relativeTo = TS_LOCAL);

        void setParent(Node* parent);

        Node* getParent();

        Node* createChild(const core::vector3d& pos = core::vector3d::ORIGIN_3D, const core::quaternion& rot = core::quaternion::IDENTITY, const core::vector3d& scale = core::vector3d::UNIT_SCALE);

        void addChild(Node* child);
        
        Node* getChild(const u32& id) const;

        u16 getNumberOfChildren();

        const std::map<u32, Node*>& getChildren();

        //Drops the specified child from this node. Does not delete the node, just detaches it from
        //this parent, potentially to be reattached elsewhere.
        void removeChild(Node* child);
        Node* removeChild(const u32& id);

        //this parent, potentially to be reattached elsewhere.
        void removeAllChildren();

        const core::vector3d& getAbsolutePosition();

        const core::quaternion& getAbsoluteOrientation();       

        const core::vector3d& getAbsoluteScale();

        const core::vector3d getAbsoluteDirection();

        const core::vector3d getAbsoluteUp();

        const core::vector3d getAbsoluteRight();

protected:

        static u32 msNextGeneratedNodeIndex;

        void initProperties();

        NodeType mNodeType;

        Node* mParent;

        bool mModifiedAbsoluteTransform;

        virtual void updateTransformImpl();

        virtual void updateImpl(f32 elapsedTime);

        core::vector3d mPosition;

        core::quaternion mOrientation;

        core::vector3d mScale;

        core::quaternion mAbsoluteOrientation;

        core::vector3d mAbsolutePosition;

        core::vector3d mAbsoluteScale;

        bool mInheritOrientation;

        bool mInheritScale;

        std::map<u32, Node*> mChildren;
};

class ENGINE_PRIVATE_EXPORT RootNode: public Node
{
public:

        RootNode();
        ~RootNode();
};

class ENGINE_PRIVATE_EXPORT GroupNode: public Node
{
public:

        GroupNode();
        GroupNode(const std::string& name);

        ~GroupNode();

        void addNode(Node* node);

        Node* getNode(const u32& id) const;

        u16 getNumberOfNodes();

        //Drops the specified node from this group.Does not delete the node, just detaches it from
        //this group, potentially to be reattached elsewhere.
        void removeNode(Node* node);
        Node* removeNode(const u32& id);

        void removeAllNodes();

protected:

        static u32 msNextGeneratedGroupNodeIndex;
};

} // end namespace scene

#endif