ISceneNode.hpp

// Copyright (C) 2002-2012 Nikolaus Gebhardt
// This file is part of the "Irrlicht Engine".
// For conditions of distribution and use, see copyright notice in jimcpp/jimcpp.hpp
 
#ifndef JPP_I_SCENE_NODE_HPP_INCLUDED
#define JPP_I_SCENE_NODE_HPP_INCLUDED
 
#include <jimcpp/core/engine/IAttributeExchangingObject.hpp>
#include <jimcpp/core/engine/ESceneNodeTypes.hpp>
#include <jimcpp/core/engine/ESceneNodeUpdateAbs.hpp>
#include <jimcpp/core/engine/ECullingTypes.hpp>
#include <jimcpp/core/engine/EDebugSceneTypes.hpp>
#include <jimcpp/core/engine/ISceneNodeAnimator.hpp>
#include <jimcpp/core/engine/ITriangleSelector.hpp>
#include <jimcpp/core/engine/SMaterial.hpp>
#include <jimcpp/core/engine/irrString.hpp>
#include <jimcpp/core/engine/aabbox3d.hpp>
#include <jimcpp/core/engine/matrix4.hpp>
#include <jimcpp/core/engine/irrList.hpp>
#include <jimcpp/core/engine/IAttributes.hpp>
 
namespace jpp
{
namespace scene
{
    class ISceneManager;
 
    using ISceneNodeList = core::list<ISceneNode*>;
    using ISceneNodeAnimatorList = core::list<ISceneNodeAnimator*>;
 
 
 
    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),
                UpdateAbsolutePosBehavior(ESNUA_TRANSFORM_MATRIX), 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.data();
        }
 
 
 
        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;
        }
 
        void setUpdateAbsolutePosBehavior(ESCENE_NODE_UPDATE_ABS behavior)
        {
            UpdateAbsolutePosBehavior = behavior;
        }
 
        ESCENE_NODE_UPDATE_ABS getUpdateAbsolutePosBehavior() const
        {
            return UpdateAbsolutePosBehavior;
        }
 
 
 
        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)
            {
                if ( UpdateAbsolutePosBehavior == ESNUA_TRANSFORM_MATRIX )
                {
                    AbsoluteTransformation =
                        Parent->getAbsoluteTransformation() * getRelativeTransformation();
                }
                else if ( UpdateAbsolutePosBehavior == ESNUA_TRANSFORM_POSITION )
                {
                    AbsoluteTransformation = getRelativeTransformation();
                    Parent->getAbsoluteTransformation().transformVect(reinterpret_cast<jpp::core::vector3df&>(AbsoluteTransformation[12]));
                }
            }
            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 override
        {
            if (!out)
                return;
            out->addString("Name", Name.data());
            out->addInt("Id", ID );
 
            out->addVector3d("Position", getPosition() );
            out->addVector3d("Rotation", getRotation() );
            out->addVector3d("Scale", getScale() );
 
            out->addBool("Visible", IsVisible );
            out->addEnum("AbsPosUpdate", (s32)UpdateAbsolutePosBehavior, SceneNodeUpdateAbsNames);
            out->addInt("AutomaticCulling", AutomaticCullingState);
            out->addInt("DebugDataVisible", DebugDataVisible );
            out->addBool("IsDebugObject", IsDebugObject );
        }
 
 
 
        virtual void deserializeAttributes(io::IAttributes* in, io::SAttributeReadWriteOptions* options=0) 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);
 
            UpdateAbsolutePosBehavior = (ESCENE_NODE_UPDATE_ABS)in->getAttributeAsEnumeration("AbsPosUpdate", SceneNodeUpdateAbsNames, (s32)UpdateAbsolutePosBehavior);
 
            if (in->existsAttribute("AutomaticCulling"))
            {
                // compatibility for older version, new one uses int's
                const 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);
            UpdateAbsolutePosBehavior = toCopyFrom->UpdateAbsolutePosBehavior;
            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;
 
        ESCENE_NODE_UPDATE_ABS UpdateAbsolutePosBehavior;
 
        u32 AutomaticCullingState;
 
        u32 DebugDataVisible;
 
        bool IsVisible;
 
        bool IsDebugObject;
    };
 
 
} // end namespace scene
} // end namespace jpp
 
#endif