ISceneNode.h

// 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), IsStaticObject(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(), end = Children.end();
                for (; it != end; ++it)
                {
                    ISceneNode* node = (*it);
                    if (node->IsVisible == true)
                        node->OnRegisterSceneNode();
                }
            }
        }
 
        virtual void CheckCount(int &count)
        {
            count++;
 
            ISceneNodeList::Iterator it = Children.begin(), end = Children.end();
            for (; it != end; ++it)
            {
                (*it)->CheckCount(count);
            }
        }


        virtual void OnAnimate(u32 timeMs)
        {
            if (IsVisible && IsStaticObject == false)
            {
                // animate this node with all animators
 
                ISceneNodeAnimatorList::Iterator ait = Animators.begin(), atEnd = Animators.end();
                while (ait != atEnd)
                    {
                    // 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;
                    anim->animateNode(this, timeMs);
                }
 
                // update absolute position
                updateAbsolutePosition();
 
                // perform the post render process on all children
 
                ISceneNodeList::Iterator it = Children.begin(), itEnd = Children.end();
                for (; it != itEnd; ++it)
                {
                    ISceneNode *node = (*it);
                    if (node->IsVisible == true && node->IsStaticObject == false)
                        node->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 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
        {
            _IRR_IMPLEMENT_MANAGED_MARSHALLING_BUGFIX;
            return IsVisible;
        }


        virtual bool isTrulyVisible() const
        {
            _IRR_IMPLEMENT_MANAGED_MARSHALLING_BUGFIX;
            if(!IsVisible)
                return false;
 
            if(!Parent)
                return true;
 
            return Parent->isTrulyVisible();
        }


        virtual void setVisible(bool isVisible)
        {
            IsVisible = isVisible;
        }
 
        // Skylicht engine
        // Add to skip OnAnimation
        virtual void setStaticNode(bool s)
        {
            IsStaticObject = s;
        }
 
        virtual bool isStaticNode()
        {
            return IsStaticObject;
        }


        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;
                }
 
            _IRR_IMPLEMENT_MANAGED_MARSHALLING_BUGFIX;
            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(s32 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
        {
            _IRR_IMPLEMENT_MANAGED_MARSHALLING_BUGFIX;
            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
        {
            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)
        {
            if (!in)
                return;
            Name = in->getAttributeAsString("Name");
            ID = in->getAttributeAsInt("Id");
 
            setPosition(in->getAttributeAsVector3d("Position"));
            setRotation(in->getAttributeAsVector3d("Rotation"));
            setScale(in->getAttributeAsVector3d("Scale"));
 
            IsVisible = in->getAttributeAsBool("Visible");
            s32 tmpState = in->getAttributeAsEnumeration("AutomaticCulling",
                    scene::AutomaticCullingNames);
            if (tmpState != -1)
                AutomaticCullingState = (u32)tmpState;
            else
                AutomaticCullingState = in->getAttributeAsInt("AutomaticCulling");
 
            DebugDataVisible = in->getAttributeAsInt("DebugDataVisible");
            IsDebugObject = in->getAttributeAsBool("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;
 
        // Skylicht engine add
        bool IsStaticObject;

        bool IsDebugObject;
    };
 
 
} // end namespace scene
} // end namespace irr
 
#endif