ISceneNodeAnimator.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_ANIMATOR_H_INCLUDED__
#define __I_SCENE_NODE_ANIMATOR_H_INCLUDED__

#include "IReferenceCounted.h"
#include "vector3d.h"
#include "ESceneNodeAnimatorTypes.h"
#include "IAttributeExchangingObject.h"
#include "IAttributes.h"
#include "IEventReceiver.h"

namespace irr
{
namespace io
{
        class IAttributes;
} // end namespace io
namespace scene
{
        class ISceneNode;
        class ISceneManager;


        class ISceneNodeAnimator : public io::IAttributeExchangingObject, public IEventReceiver
        {
        public:
                ISceneNodeAnimator() : IsEnabled(true), PauseTimeSum(0), PauseTimeStart(0), StartTime(0)
                {
                }


                virtual void animateNode(ISceneNode* node, u32 timeMs) =0;


                virtual ISceneNodeAnimator* createClone(ISceneNode* node,
                                ISceneManager* newManager=0) =0;


                virtual bool isEventReceiverEnabled() const
                {
                        return false;
                }

                virtual bool OnEvent(const SEvent& event) _IRR_OVERRIDE_
                {
                        return false;
                }

                virtual ESCENE_NODE_ANIMATOR_TYPE getType() const
                {
                        return ESNAT_UNKNOWN;
                }


                virtual bool hasFinished(void) const
                {
                        return false;
                }


                virtual void setStartTime(u32 time, bool resetPauseTime=true)
                {
                        StartTime = time;
                        if ( resetPauseTime )
                        {
                                PauseTimeStart = 0;
                                PauseTimeSum = 0;
                        }
                }


                virtual irr::u32 getStartTime() const
                {
                        return StartTime;
                }


                virtual void setEnabled(bool enabled, u32 timeNow=0)
                {
                        if ( enabled == IsEnabled )
                                return;
                        IsEnabled = enabled;
                        if ( enabled )
                        {
                                if ( timeNow > 0 && PauseTimeStart > 0 )
                                        PauseTimeSum += timeNow-PauseTimeStart;
                        }
                        else
                        {
                                PauseTimeStart = timeNow;
                        }
                }

                virtual bool isEnabled() const
                {
                        return IsEnabled;
                }

                virtual void serializeAttributes(io::IAttributes* out, io::SAttributeReadWriteOptions* options=0) const _IRR_OVERRIDE_
                {
                        out->addBool("IsEnabled", IsEnabled);
                        // timers not serialized as they usually depend on system-time which is different on each application start.
                }

                virtual void deserializeAttributes(io::IAttributes* in, io::SAttributeReadWriteOptions* options=0) _IRR_OVERRIDE_
                {
                        IsEnabled = in->getAttributeAsBool("IsEnabled", IsEnabled);
                        PauseTimeSum = 0;
                        PauseTimeStart = 0;
                }

        protected:

                void cloneMembers(const ISceneNodeAnimator* toCopyFrom)
                {
                        IsEnabled = toCopyFrom->IsEnabled;
                        PauseTimeSum = toCopyFrom->IsEnabled;
                        PauseTimeStart = toCopyFrom->PauseTimeStart;
                        StartTime = toCopyFrom->StartTime;
                }

                bool IsEnabled;         
                u32 PauseTimeSum;       
                u32 PauseTimeStart;     
                u32 StartTime;          
        };


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

#endif