CUpdater.h

Go to the documentation of this file.

//    Copyright (C) 2004-2013 Dylan Blair
//
//    email: dblair@alumni.cs.utexas.edu
//
//    This library is free software; you can redistribute it and/or
//    modify it under the terms of the GNU Lesser General Public
//    License as published by the Free Software Foundation; either
//    version 2.1 of the License, or (at your option) any later version.
//
//    This library is distributed in the hope that it will be useful,
//    but WITHOUT ANY WARRANTY; without even the implied warranty of
//    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
//    Lesser General Public License for more details.
//
//    You should have received a copy of the GNU Lesser General Public
//    License along with this library; if not, write to the Free Software
//    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

#ifndef CUPDATER_H
#define CUPDATER_H

#include "IObject.h"

#include <list>
#include <map>

namespace OpenSkyNet {
    namespace Core {
        class UpdateManager;

        class CORE_DLL Updater {
        public:
            enum UPDATER_TYPE { BASE, AI, CAMERA, PATH_FINDER, PATH, TRANSFORM_INTERPOLATOR, PHYSICS, ANIMATION, COLLISION_DETECTOR, PHYS_VIS, TRANSFORM_CHANGE_DETECTOR, CORE_MAX, MAX=32 };

            enum UPDATER_PRIORITY { UPD_DISABLED, UPD_1, UPD_2, UPD_3, UPD_4, UPD_5, UPD_6, UPD_7, UPD_8, UPD_NUM_PRIORITIES };

            enum OBJECT_PRIORITY { OBJ_DISABLED, OBJ_1, OBJ_2, OBJ_3, OBJ_NUM_PRIORITIES };

            struct UpdateInfo {
                OBJECT_PRIORITY _prio, _prevPrio;
                float _prevUpdateTimeAfterReset;
                bool _isOneShot;
                UpdateInfo(OBJECT_PRIORITY prio_=OBJ_DISABLED, bool isOneShot_=false) : _prio(prio_), 
                    _prevPrio(prio_), _prevUpdateTimeAfterReset(0), _isOneShot(isOneShot_) {}
                virtual ~UpdateInfo() {}
            };

            typedef std::map<Object*, UpdateInfo*> ObjMap;

            friend class Core::UpdateManager;
        protected:
            std::list<Object*> _objLists[OBJ_NUM_PRIORITIES];
            ObjMap _objMap;

            UPDATER_TYPE _type;
            std::string _typeName;
            UPDATER_PRIORITY _prio;
            float _interval;
            float _dtSinceAllWereUpdated;
            float _prevTotalTimeForAllUpdates;
            float _partialUpdate;

            int _currPrio;
            std::list<Object*>::iterator _currObj;

            virtual bool addObject(Object* obj_, OBJECT_PRIORITY prio_=OBJ_1, bool isOneShot_=false);

            virtual bool removeObject(Object* obj_);

            virtual void removeAllObjects();

            int getNumToUpdate(float dt_);
            void allObjectsUpdated();
            inline void setPriority(UPDATER_PRIORITY prio_) { _prio = prio_; }
        public:
            Updater() : _type(BASE), _typeName("BASE"), _prio(UPD_1), _interval(0), 
                _dtSinceAllWereUpdated(0), _prevTotalTimeForAllUpdates(0), _partialUpdate(0), 
                _currPrio(OBJ_NUM_PRIORITIES-1), _currObj(_objLists[OBJ_NUM_PRIORITIES-1].begin()) {}
            Updater(UPDATER_TYPE type_, const char* typeName_, UPDATER_PRIORITY prio_, float interval_) : _type(type_), 
                _typeName(typeName_), _prio(prio_), _interval(interval_), 
                _dtSinceAllWereUpdated(0), _prevTotalTimeForAllUpdates(0), _partialUpdate(0), 
                _currPrio(OBJ_NUM_PRIORITIES-1), _currObj(_objLists[OBJ_NUM_PRIORITIES-1].begin()) {}
            virtual ~Updater() {}

            inline UPDATER_TYPE getType() const { return _type; }
            inline const std::string& getTypeName() const { return _typeName; }

            virtual bool update(float dt_);

            inline float getInterval() const { return _interval; }

            inline void setInterval(float interval_) { _interval = interval_; }

            inline Utils::uint getNumObjects() const { return static_cast<Utils::uint>(_objMap.size()); }

            inline Utils::uint getNumObjectsThatCanUpdate() const {
                Utils::uint numObjectsThatCanUpdate = 0;
                for (ObjMap::const_iterator i = _objMap.begin(); i != _objMap.end(); i++)
                    if (i->second->_prio > OBJ_DISABLED)
                        ++numObjectsThatCanUpdate;
                return numObjectsThatCanUpdate;
            }

            inline bool find(Object* obj_) const {
                if (_objMap.find(obj_) != _objMap.end())
                    return true;
                return false;
            }

            inline UPDATER_PRIORITY getPriority() const { return _prio; }

            OBJECT_PRIORITY getPriority(Object* obj_) const;

            virtual bool setPriority(Object* obj_, OBJECT_PRIORITY prio_);
        };
    }
}

#define UPDATE_METHOD_COMMON_VARS \
    _dtSinceAllWereUpdated += dt_; \
    float objDt = 0; \
    int numToUpdate = getNumToUpdate(dt_); \
    int numUpdated = 0; \
    std::list<Object*>::iterator initObj = _currObj; \
    std::list<Object*>::iterator j(initObj); \
    std::list<Object*>::iterator k(j);

#endif //CUPDATER_H