D:/SoftwareEntwicklung/C++/HLC/Tools/SoftPixelEngine/repository/sources/SceneGraph/spSceneNode.hpp

Go to the documentation of this file.

/*
 * Scene node header
 * 
 * This file is part of the "SoftPixel Engine" (Copyright (c) 2008 by Lukas Hermanns)
 * See "SoftPixelEngine.hpp" for license information.
 */

#ifndef __SP_SCENE_SCENENODE_H__
#define __SP_SCENE_SCENENODE_H__


#include "Base/spStandard.hpp"
#include "Base/spDimension.hpp"
#include "Base/spInputOutputLog.hpp"
#include "Base/spMaterialStates.hpp"
#include "Base/spGeometryStructures.hpp"
#include "Base/spNode.hpp"
#include "Base/spMath.hpp"
#include "Base/spTransformation3D.hpp"
#include "SceneGraph/spBoundingVolume.hpp"
#include "RenderSystem/spShaderProgram.hpp"

#include <list>


namespace sp
{
namespace scene
{


class Animation;

/*
 * Global members
 */

extern dim::matrix4f spProjectionMatrix;
extern dim::matrix4f spViewMatrix;
extern dim::matrix4f spViewInvMatrix;
extern dim::matrix4f spWorldMatrix;
extern dim::matrix4f spTextureMatrix[MAX_COUNT_OF_TEXTURES];
extern dim::matrix4f spColorMatrix;


/*
 * Enumerations
 */

enum ENodeTypes
{
    NODE_BASICNODE,     
    NODE_CUSTOM,        
    NODE_SCENEGRAPH,    
    NODE_CAMERA,        
    NODE_LIGHT,         
    NODE_MESH,          
    NODE_BILLBOARD,     
    NODE_TERRAIN,       
};


class SP_EXPORT SceneNode : public Node
{
    
    public:
        
        /* === Header === */
        
        SceneNode(const ENodeTypes Type = NODE_BASICNODE);
        virtual ~SceneNode();
        
        /* === Functions === */
        
        SceneNode* copy() const;
        
        void setPositionMatrix(const dim::matrix4f &Position, bool isGlobal);
        dim::matrix4f getPositionMatrix(bool isGlobal) const;
        
        void setRotationMatrix(const dim::matrix4f &Rotation, bool isGlobal);
        dim::matrix4f getRotationMatrix(bool isGlobal) const;
        
        void setScaleMatrix(const dim::matrix4f &Scale, bool isGlobal);
        dim::matrix4f getScaleMatrix(bool isGlobal) const;
        
        void setPosition(const dim::vector3df &Position, bool isGlobal = false);
        dim::vector3df getPosition(bool isGlobal = false) const;
        
        void setRotation(const dim::vector3df &Rotation, bool isGlobal = false);
        dim::vector3df getRotation(bool isGlobal = false) const;
        
        void setScale(const dim::vector3df &Scale, bool isGlobal = false);
        dim::vector3df getScale(bool isGlobal = false) const;
        
        virtual void lookAt(const dim::vector3df &Position, bool isGlobal = false);
        
        virtual void addAnimation(Animation* Anim);
        
        virtual void removeAnimation(Animation* Anim);
        
        virtual void clearAnimations();
        
        virtual Animation* getFirstAnimation() const;
        
        virtual Animation* getAnimation(u32 Index = 0) const;
        
        virtual Animation* findAnimation(const io::stringc &Name) const;
        
        /* === Parents === */
        
        virtual bool getVisible(bool isGlobal = false) const;
        
        void setParent(SceneNode* Parent, bool isGlobal);
        
        /* === Children === */
        
        virtual void addChild(SceneNode* Child);
        
        virtual void addChildren(const std::list<SceneNode*> &Children);
        
        virtual bool removeChild(SceneNode* Child);
        
        virtual bool removeChild();
        
        virtual u32 removeChildren(const std::list<SceneNode*> &Children);
        
        virtual void removeChildren();
        
        /* === Parent system === */
        
        virtual void updateTransformation();
        virtual void updateTransformationBase(const dim::matrix4f &BaseMatrix);
        
        Transformation getTransformation(bool isGlobal) const;
        
        virtual void loadTransformation();
        
        /* === Inline functions === */
        
        inline ENodeTypes getType() const
        {
            return Type_;
        }
        
        inline void setBoundingVolume(const BoundingVolume &BoundVolume)
        {
            BoundVolume_ = BoundVolume;
        }
        
        inline BoundingVolume& getBoundingVolume()
        {
            return BoundVolume_;
        }
        inline const BoundingVolume& getBoundingVolume() const
        {
            return BoundVolume_;
        }
        
        inline void setPositionMatrix(const dim::matrix4f &Position)
        {
            Transform_.setPosition(Position.getPosition());
        }
        inline dim::matrix4f getPositionMatrix() const
        {
            return dim::getPositionMatrix(Transform_.getPosition());
        }
        
        inline void setRotationMatrix(const dim::matrix4f &Rotation)
        {
            Transform_.setRotation(Rotation);
        }
        inline dim::matrix4f getRotationMatrix() const
        {
            return Transform_.getRotationMatrix();
        }
        
        inline void setScaleMatrix(const dim::matrix4f &Scale)
        {
            Transform_.setScale(Scale.getScale());
        }
        inline dim::matrix4f getScaleMatrix() const
        {
            return dim::getScaleMatrix(Transform_.getScale());
        }
        
        inline void setupTransformation(bool isGlobal)
        {
            FinalWorldMatrix_ = getTransformation(isGlobal).getMatrix();
        }
        inline void setupWorldMatrix(const dim::matrix4f &WorldMatrix)
        {
            FinalWorldMatrix_ = WorldMatrix;
        }
        
        inline const Transformation& getTransformation() const
        {
            return Transform_;
        }
        inline Transformation& getTransformation()
        {
            return Transform_;
        }
        
        inline dim::matrix4f getTransformMatrix(bool isGlobal = false) const
        {
            return getTransformation(isGlobal).getMatrix();
        }
        
        inline void setTransformation(const Transformation &Transform)
        {
            Transform_ = Transform;
        }
        
        inline const std::vector<SceneNode*> &getSceneChildren() const
        {
            return SceneChildren_;
        }
        inline std::vector<SceneNode*> &getSceneChildren()
        {
            return SceneChildren_;
        }
        
        inline void setParent(SceneNode* Parent)
        {
            SceneParent_ = Parent;
        }
        inline SceneNode* getParent() const
        {
            return SceneParent_;
        }
        
        inline const std::vector<Animation*>& getAnimationList() const
        {
            return AnimationList_;
        }
        
        inline u32 getAnimationCount() const
        {
            return AnimationList_.size();
        }
        
        inline void move(const dim::vector3df &Direction)
        {
            Transform_.move(Direction);
        }
        inline void turn(const dim::vector3df &Rotation)
        {
            Transform_.turn(Rotation);
        }
        inline void translate(const dim::vector3df &Direction)
        {
            Transform_.translate(Direction);
        }
        inline void transform(const dim::vector3df &Size)
        {
            Transform_.transform(Size);
        }
        
    protected:
        
        friend class Animation;
        
        /* === Functions === */
        
        void copyRoot(SceneNode* NewNode) const;
        
        /* === Members === */
        
        BoundingVolume BoundVolume_;
        Transformation Transform_;
        
        dim::matrix4f FinalWorldMatrix_;
        
        SceneNode* SceneParent_;
        
        std::vector<SceneNode*> SceneChildren_;
        
        std::vector<Animation*> AnimationList_;
        
    private:
        
        /* === Members === */
        
        ENodeTypes Type_;
        
};


} // /namespace scene

} // /namespace sp


#endif



// ================================================================================