ISceneNode.h

Go to the documentation of this file.

// Copyright (C) 2002-2012 Nikolaus Gebhardt
// This file is part of the "Irrlicht Engine".
// For conditions of distribution and use, see copyright notice in irrlicht.h

#ifndef __I_SCENE_NODE_H_INCLUDED__
#define __I_SCENE_NODE_H_INCLUDED__

#include "IAttributeExchangingObject.h"
#include "ESceneNodeTypes.h"
#include "ECullingTypes.h"
#include "EDebugSceneTypes.h"
#include "ISceneNodeAnimator.h"
#include "ITriangleSelector.h"
#include "SMaterial.h"
#include "irrString.h"
#include "aabbox3d.h"
#include "matrix4.h"
#include "irrList.h"
#include "IAttributes.h"

namespace irr
{
namespace scene
{
        class ISceneManager;

        typedef core::list<ISceneNode*> ISceneNodeList;
        typedef core::list<ISceneNodeAnimator*> ISceneNodeAnimatorList;


        class ISceneNode : virtual public io::IAttributeExchangingObject
        {
        public:

                ISceneNode(ISceneNode* parent, ISceneManager* mgr, s32 id=-1,
                                const core::vector3df& position = core::vector3df(0,0,0),
                                const core::vector3df& rotation = core::vector3df(0,0,0),
                                const core::vector3df& scale = core::vector3df(1.0f, 1.0f, 1.0f))
                        : RelativeTranslation(position), RelativeRotation(rotation), RelativeScale(scale),
                                Parent(0), SceneManager(mgr), TriangleSelector(0), ID(id),
                                AutomaticCullingState(EAC_BOX), DebugDataVisible(EDS_OFF),
                                IsVisible(true), IsDebugObject(false)
                {
                        if (parent)
                                parent->addChild(this);

                        updateAbsolutePosition();
                }


                virtual ~ISceneNode()
                {
                        // delete all children
                        removeAll();

                        // delete all animators
                        ISceneNodeAnimatorList::Iterator ait = Animators.begin();
                        for (; ait != Animators.end(); ++ait)
                                (*ait)->drop();

                        if (TriangleSelector)
                                TriangleSelector->drop();
                }



                virtual void OnRegisterSceneNode()
                {
                        if (IsVisible)
                        {
                                ISceneNodeList::Iterator it = Children.begin();
                                for (; it != Children.end(); ++it)
                                        (*it)->OnRegisterSceneNode();
                        }
                }



                virtual void OnAnimate(u32 timeMs)
                {
                        if (IsVisible)
                        {
                                // animate this node with all animators

                                ISceneNodeAnimatorList::Iterator ait = Animators.begin();
                                while (ait != Animators.end())
                                        {
                                        // continue to the next node before calling animateNode()
                                        // so that the animator may remove itself from the scene
                                        // node without the iterator becoming invalid
                                        ISceneNodeAnimator* anim = *ait;
                                        ++ait;
                                        if ( anim->isEnabled() )
                                        {
                                                anim->animateNode(this, timeMs);
                                        }
                                }

                                // update absolute position
                                updateAbsolutePosition();

                                // perform the post render process on all children

                                ISceneNodeList::Iterator it = Children.begin();
                                for (; it != Children.end(); ++it)
                                        (*it)->OnAnimate(timeMs);
                        }
                }


                virtual void render() = 0;



                virtual const c8* getName() const
                {
                        return Name.c_str();
                }



                virtual void setName(const c8* name)
                {
                        Name = name;
                }



                virtual void setName(const core::stringc& name)
                {
                        Name = name;
                }



                virtual const core::aabbox3d<f32>& getBoundingBox() const = 0;



                virtual const core::aabbox3d<f32> getTransformedBoundingBox() const
                {
                        core::aabbox3d<f32> box = getBoundingBox();
                        AbsoluteTransformation.transformBoxEx(box);
                        return box;
                }


                virtual void getTransformedBoundingBoxEdges(core::array< core::vector3d<f32> >& edges) const
                {
                        edges.set_used(8);
                        getBoundingBox().getEdges( edges.pointer() );
                        for ( u32 i=0; i<8; ++i )
                                AbsoluteTransformation.transformVect( edges[i] );
                }


                virtual const core::matrix4& getAbsoluteTransformation() const
                {
                        return AbsoluteTransformation;
                }



                virtual core::matrix4 getRelativeTransformation() const
                {
                        core::matrix4 mat;
                        mat.setRotationDegrees(RelativeRotation);
                        mat.setTranslation(RelativeTranslation);

                        if (RelativeScale != core::vector3df(1.f,1.f,1.f))
                        {
                                core::matrix4 smat;
                                smat.setScale(RelativeScale);
                                mat *= smat;
                        }

                        return mat;
                }



                virtual bool isVisible() const
                {
                        return IsVisible;
                }


                virtual bool isTrulyVisible() const
                {
                        if(!IsVisible)
                                return false;

                        if(!Parent)
                                return true;

                        return Parent->isTrulyVisible();
                }


                virtual void setVisible(bool isVisible)
                {
                        IsVisible = isVisible;
                }



                virtual s32 getID() const
                {
                        return ID;
                }



                virtual void setID(s32 id)
                {
                        ID = id;
                }



                virtual void addChild(ISceneNode* child)
                {
                        if (child && (child != this))
                        {
                                // Change scene manager?
                                if (SceneManager != child->SceneManager)
                                        child->setSceneManager(SceneManager);

                                child->grab();
                                child->remove(); // remove from old parent
                                Children.push_back(child);
                                child->Parent = this;
                        }
                }



                virtual bool removeChild(ISceneNode* child)
                {
                        ISceneNodeList::Iterator it = Children.begin();
                        for (; it != Children.end(); ++it)
                                if ((*it) == child)
                                {
                                        (*it)->Parent = 0;
                                        (*it)->drop();
                                        Children.erase(it);
                                        return true;
                                }

                        return false;
                }



                virtual void removeAll()
                {
                        ISceneNodeList::Iterator it = Children.begin();
                        for (; it != Children.end(); ++it)
                        {
                                (*it)->Parent = 0;
                                (*it)->drop();
                        }

                        Children.clear();
                }



                virtual void remove()
                {
                        if (Parent)
                                Parent->removeChild(this);
                }



                virtual void addAnimator(ISceneNodeAnimator* animator)
                {
                        if (animator)
                        {
                                Animators.push_back(animator);
                                animator->grab();
                        }
                }



                const core::list<ISceneNodeAnimator*>& getAnimators() const
                {
                        return Animators;
                }



                virtual void removeAnimator(ISceneNodeAnimator* animator)
                {
                        ISceneNodeAnimatorList::Iterator it = Animators.begin();
                        for (; it != Animators.end(); ++it)
                        {
                                if ((*it) == animator)
                                {
                                        (*it)->drop();
                                        Animators.erase(it);
                                        return;
                                }
                        }
                }



                virtual void removeAnimators()
                {
                        ISceneNodeAnimatorList::Iterator it = Animators.begin();
                        for (; it != Animators.end(); ++it)
                                (*it)->drop();

                        Animators.clear();
                }



                virtual video::SMaterial& getMaterial(u32 num)
                {
                        return video::IdentityMaterial;
                }



                virtual u32 getMaterialCount() const
                {
                        return 0;
                }



                void setMaterialFlag(video::E_MATERIAL_FLAG flag, bool newvalue)
                {
                        for (u32 i=0; i<getMaterialCount(); ++i)
                                getMaterial(i).setFlag(flag, newvalue);
                }



                void setMaterialTexture(u32 textureLayer, video::ITexture* texture)
                {
                        if (textureLayer >= video::MATERIAL_MAX_TEXTURES)
                                return;

                        for (u32 i=0; i<getMaterialCount(); ++i)
                                getMaterial(i).setTexture(textureLayer, texture);
                }



                void setMaterialType(video::E_MATERIAL_TYPE newType)
                {
                        for (u32 i=0; i<getMaterialCount(); ++i)
                                getMaterial(i).MaterialType = newType;
                }



                virtual const core::vector3df& getScale() const
                {
                        return RelativeScale;
                }



                virtual void setScale(const core::vector3df& scale)
                {
                        RelativeScale = scale;
                }



                virtual const core::vector3df& getRotation() const
                {
                        return RelativeRotation;
                }



                virtual void setRotation(const core::vector3df& rotation)
                {
                        RelativeRotation = rotation;
                }



                virtual const core::vector3df& getPosition() const
                {
                        return RelativeTranslation;
                }



                virtual void setPosition(const core::vector3df& newpos)
                {
                        RelativeTranslation = newpos;
                }



                virtual core::vector3df getAbsolutePosition() const
                {
                        return AbsoluteTransformation.getTranslation();
                }



                void setAutomaticCulling( u32 state)
                {
                        AutomaticCullingState = state;
                }



                u32 getAutomaticCulling() const
                {
                        return AutomaticCullingState;
                }



                virtual void setDebugDataVisible(u32 state)
                {
                        DebugDataVisible = state;
                }


                u32 isDebugDataVisible() const
                {
                        return DebugDataVisible;
                }



                void setIsDebugObject(bool debugObject)
                {
                        IsDebugObject = debugObject;
                }



                bool isDebugObject() const
                {
                        return IsDebugObject;
                }



                const core::list<ISceneNode*>& getChildren() const
                {
                        return Children;
                }



                virtual void setParent(ISceneNode* newParent)
                {
                        grab();
                        remove();

                        Parent = newParent;

                        if (Parent)
                                Parent->addChild(this);

                        drop();
                }



                virtual ITriangleSelector* getTriangleSelector() const
                {
                        return TriangleSelector;
                }



                virtual void setTriangleSelector(ITriangleSelector* selector)
                {
                        if (TriangleSelector != selector)
                        {
                                if (TriangleSelector)
                                        TriangleSelector->drop();

                                TriangleSelector = selector;
                                if (TriangleSelector)
                                        TriangleSelector->grab();
                        }
                }



                virtual void updateAbsolutePosition()
                {
                        if (Parent)
                        {
                                AbsoluteTransformation =
                                        Parent->getAbsoluteTransformation() * getRelativeTransformation();
                        }
                        else
                                AbsoluteTransformation = getRelativeTransformation();
                }



                scene::ISceneNode* getParent() const
                {
                        return Parent;
                }



                virtual ESCENE_NODE_TYPE getType() const
                {
                        return ESNT_UNKNOWN;
                }



                virtual void serializeAttributes(io::IAttributes* out, io::SAttributeReadWriteOptions* options=0) const _IRR_OVERRIDE_
                {
                        if (!out)
                                return;
                        out->addString("Name", Name.c_str());
                        out->addInt("Id", ID );

                        out->addVector3d("Position", getPosition() );
                        out->addVector3d("Rotation", getRotation() );
                        out->addVector3d("Scale", getScale() );

                        out->addBool("Visible", IsVisible );
                        out->addInt("AutomaticCulling", AutomaticCullingState);
                        out->addInt("DebugDataVisible", DebugDataVisible );
                        out->addBool("IsDebugObject", IsDebugObject );
                }



                virtual void deserializeAttributes(io::IAttributes* in, io::SAttributeReadWriteOptions* options=0) _IRR_OVERRIDE_
                {
                        if (!in)
                                return;
                        Name = in->getAttributeAsString("Name", Name);
                        ID = in->getAttributeAsInt("Id", ID);

                        setPosition(in->getAttributeAsVector3d("Position", RelativeTranslation));
                        setRotation(in->getAttributeAsVector3d("Rotation", RelativeRotation));
                        setScale(in->getAttributeAsVector3d("Scale", RelativeScale));

                        IsVisible = in->getAttributeAsBool("Visible", IsVisible);
                        if (in->existsAttribute("AutomaticCulling"))
                        {
                                s32 tmpState = in->getAttributeAsEnumeration("AutomaticCulling",
                                                scene::AutomaticCullingNames);
                                if (tmpState != -1)
                                        AutomaticCullingState = (u32)tmpState;
                                else
                                        AutomaticCullingState = in->getAttributeAsInt("AutomaticCulling");
                        }

                        DebugDataVisible = in->getAttributeAsInt("DebugDataVisible", DebugDataVisible);
                        IsDebugObject = in->getAttributeAsBool("IsDebugObject", IsDebugObject);

                        updateAbsolutePosition();
                }


                virtual ISceneNode* clone(ISceneNode* newParent=0, ISceneManager* newManager=0)
                {
                        return 0; // to be implemented by derived classes
                }


                virtual ISceneManager* getSceneManager(void) const { return SceneManager; }

        protected:


                void cloneMembers(ISceneNode* toCopyFrom, ISceneManager* newManager)
                {
                        Name = toCopyFrom->Name;
                        AbsoluteTransformation = toCopyFrom->AbsoluteTransformation;
                        RelativeTranslation = toCopyFrom->RelativeTranslation;
                        RelativeRotation = toCopyFrom->RelativeRotation;
                        RelativeScale = toCopyFrom->RelativeScale;
                        ID = toCopyFrom->ID;
                        setTriangleSelector(toCopyFrom->TriangleSelector);
                        AutomaticCullingState = toCopyFrom->AutomaticCullingState;
                        DebugDataVisible = toCopyFrom->DebugDataVisible;
                        IsVisible = toCopyFrom->IsVisible;
                        IsDebugObject = toCopyFrom->IsDebugObject;

                        if (newManager)
                                SceneManager = newManager;
                        else
                                SceneManager = toCopyFrom->SceneManager;

                        // clone children

                        ISceneNodeList::Iterator it = toCopyFrom->Children.begin();
                        for (; it != toCopyFrom->Children.end(); ++it)
                                (*it)->clone(this, newManager);

                        // clone animators

                        ISceneNodeAnimatorList::Iterator ait = toCopyFrom->Animators.begin();
                        for (; ait != toCopyFrom->Animators.end(); ++ait)
                        {
                                ISceneNodeAnimator* anim = (*ait)->createClone(this, SceneManager);
                                if (anim)
                                {
                                        addAnimator(anim);
                                        anim->drop();
                                }
                        }
                }

                void setSceneManager(ISceneManager* newManager)
                {
                        SceneManager = newManager;

                        ISceneNodeList::Iterator it = Children.begin();
                        for (; it != Children.end(); ++it)
                                (*it)->setSceneManager(newManager);
                }

                core::stringc Name;

                core::matrix4 AbsoluteTransformation;

                core::vector3df RelativeTranslation;

                core::vector3df RelativeRotation;

                core::vector3df RelativeScale;

                ISceneNode* Parent;

                core::list<ISceneNode*> Children;

                core::list<ISceneNodeAnimator*> Animators;

                ISceneManager* SceneManager;

                ITriangleSelector* TriangleSelector;

                s32 ID;

                u32 AutomaticCullingState;

                u32 DebugDataVisible;

                bool IsVisible;

                bool IsDebugObject;
        };


} // end namespace scene
} // end namespace irr

#endif