CCollisionDetector.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 CCOLLISION_DETECTOR_H
#define CCOLLISION_DETECTOR_H

#include "CUpdater.h"
#include "CPhysicalObject.h"
#include "ICollisionListener.h"

#include "../CD_LIB/CDGrid.h"

namespace OpenSkyNet {
    namespace Core {
        class CORE_DLL CollisionDetector : public Updater {
        public:
            struct ColInfo : public Updater::UpdateInfo {
                bool _doCalculate, _isInGrid, _doSweepTests, _doAllowPostUpdateCollisions;
                float _secsLeftToCalc;
                Utils::uint _numCollisions;
                std::set<Object*> _colliders, _prevColliders;

                ColInfo(Updater::OBJECT_PRIORITY prio_=Updater::OBJ_DISABLED, bool isOneShot_=false) : Updater::UpdateInfo(prio_,isOneShot_), 
                    _doCalculate(false), _isInGrid(false), _doSweepTests(false), _doAllowPostUpdateCollisions(false), 
                    _secsLeftToCalc(0.f), _numCollisions(0) {}
            };
        protected:
            CD::Grid _grid;
            std::list<CollisionListener*> _registeredListeners;
            Utils::uint _maxCollisionsPerVolume;

            CD::Grid::BinOccupiersMap _nonCollidingOccupiers;
            CD::Grid::OccupiedBinsMap _nonCollidingOccupiedBins;

            inline bool doCollide(Object* collidee_, Object* collider_);
            inline bool doCollideWhenSwept(Object* collidee_, Object* collider_, float dt_, CD::HitInfo& hitInfo_);

            virtual bool addObject(Object* obj_, Updater::OBJECT_PRIORITY prio_, bool isOneShot_);
            virtual bool removeObject(Object* obj_);
        public:
            CollisionDetector() : Updater(Updater::COLLISION_DETECTOR, "COLLISION_DETECTOR", Updater::UPD_3, 0.0f), 
                _grid(32,32,32,0), _maxCollisionsPerVolume(3) {
                if (!CD::g_initialGrid) CD::Grid::init(32,32,32,0);
            }

            virtual ~CollisionDetector() { CD::Grid::shutDown(); }

            virtual bool update(float dt_);

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


            virtual bool enableSweepTests(Object* obj_);
            virtual bool disableSweepTests(Object* obj_);

            virtual bool allowPostUpdateCollisions(Object* obj_);
            virtual bool disallowPostUpdateCollisions(Object* obj_);

            virtual void setCDGrid(const Math::Point<>* corners_, std::set<CD::Volume*>& obstacles_);

            inline const CD::Grid* getGrid() const { return &_grid; }

            inline void registerCollisionListener(CollisionListener* listener_) { _registeredListeners.push_back(listener_); }
            inline void unregisterCollisionListener(CollisionListener* listener_) { _registeredListeners.remove(listener_); }

            virtual bool getClosestRayIntersection(const Math::Point<>& rayOrigin_, const Math::Point<>& rayDir_, 
                Utils::uint colGroup_, CD::HitInfo& hitInfo_) const;
        };
    }
}

#endif //CCOLLISION_DETECTOR_H