---

id_table.h

Go to the documentation of this file.

#ifndef _ID_TABLE_H_
#define _ID_TABLE_H_
#include "key_mutable_set.h"
#include "ext_stl.h"
#include "collidable.h"

const int fudgeFactor = 1;

template<class T>
class IdTable {
private:
    class CollideKeyLess {
    public:
        bool operator() (const KeyMutableShell<T> &a, const KeyMutableShell<T> &b) const {
            return (a->getCollideKey()<b->getCollideKey());
        }
    };
    class MeshIdLess {
    public:
        bool operator() (const MutableShell<T> &a, const MutableShell<T> &b) const {
            if (a->model==b->model) {
                return (a->getId()<b->getId());
            } else {
                return (a->model<b->model);
            }
        }
    };
    typedef MutableSet <T, MeshIdLess> MeshMapClass;
    typedef KeyMutableSet <typename T::CollideKey, T, CollideKeyLess> CollideMapClass;
    typedef Hashtable <int, T *, 65535 > IdMap;
    std::vector<int> deleteQueue;
private:
    MeshMapClass meshMap;
    IdMap idMap;
    CollideMapClass collideMap;

    inline void incrementAndCheck (typename CollideMapClass::iterator &iter) {
        iter=collideMap.changeKey(iter,(*iter)->recalculateCollideKey());
    }
protected:
    bool del (int id) {
        using std::vector;
        T *spec=idMap.Get(id);
        if (!spec) {
            return false;
        }
        idMap.Delete(id);
        {
            typename CollideMapClass::iterator iter=collidemap.find(spec->getCollideKey());
            while (iter!=collidemap.end()) {
                if (spec==(*iter).second) {
                    collidemap.erase(iter);
                }
                iter++;
            }
        }
        typename MeshMapClass::iterator iter=meshmap.find(spec);
        if (&(*iter)==spec) {
            meshmap.erase(iter);
            break;
        }
        return true;
    }   
public:
    void eraseAll () {
        meshMap.clear();
//      idMap=IdMap(); //Does not work :-(
        collideMap.clear();
        deleteQueue.clear();
    }
    int add (const T &s) {
        static int numgen=0;
        typename MeshMapClass::iterator iter= meshMap.insert(s);
        T *collidableToInsert=&(*iter).get();
        collideMap.insert(collidableToInsert);
        collidableToInsert->setId(numgen++);
        idMap.Put(collidableToInsert->getId(),collidableToInsert);
        return collidableToInsert->getId();
    }
    void kill(int id) {
        deleteQueue.push_back (id);
    }
    T * getById (int id) {
        typename IdMap::iterator iter = idMap.find(id);
        if (iter!=iter.end()) {
            return (*iter).second;
        } else {
            return NULL;
        }
    }
    
    // Returns an iterator to the CollideKeyMap perhaps? FIXME
    //iterator radius (const CollideKey &, T */*updates said T*/);

    void updateDeleteList() {
        while (!deleteQueue.empty()){
            Del (deleteQueue.back());
            deleteQueue.pop_back();
        }
    }
    void draw ();
    void update ();
    template <class Coll> void collideWithOther(Coll *coll, int surface, double minRadius, double maxRadius) {
        typename CollideMapClass::iterator othiter;
        typename T::CollideKey collideKey (surface,minRadius);
        othiter=this->collideMap.lower_bound(collideKey);
        while (othiter!=this->collideMap.end()&&(*othiter)->getCollideKey().radius<=maxRadius) {
            (*othiter)->collide(coll);
            ++othiter;
        }
    }
    void collideWithBolts() {
        //lower_bound!!!
        IdTable<Bolt> *btable=&world->surfaces[0]->boltField;//Just in case.
        typename CollideMapClass::iterator thisiter=collideMap.begin();
        for (;
                thisiter!=collideMap.end();
                ++thisiter) {
            const typename T::CollideKey &collideKey = ((*thisiter)->getCollideKey());
            int surface=collideKey.surface;
            btable=&world->surfaces[surface]->boltField;
            T * c = (*thisiter);
            float cRadius=c->getRadius();
            btable->collideWithOther(c,surface,collideKey.radius-fudgeFactor-cRadius,collideKey.radius+fudgeFactor+cRadius);
        }
    }
    void fixCollideOrder() {
        for (typename CollideMapClass::iterator thisiter=collideMap.begin();
                thisiter!=collideMap.end();
                incrementAndCheck(thisiter)) {}
    }
    void collideWithSame() {
        for (typename CollideMapClass::iterator thisiter=collideMap.begin();
                thisiter!=collideMap.end();
                ++thisiter) {
            const typename T::CollideKey &collideKey = ((*thisiter)->getCollideKey());
            for (typename CollideMapClass::iterator backward=thisiter;;) {
                if (backward==collideMap.begin())
                    break;
                --backward;
                const typename T::CollideKey &backCollideKey = ((*backward)->getCollideKey());
                if ((backCollideKey.radius<(collideKey.radius-fudgeFactor-(2 * (*thisiter)->getRadius())))||(backCollideKey.surface!=collideKey.surface)) {
                    break;
                }
                (*thisiter)->collide(*backward);
            }
            bool reachedthisiter=false;
            typename CollideMapClass::iterator otheriter=thisiter;
            ++otheriter;
            for (;otheriter!=collideMap.end();++otheriter) {
                const typename T::CollideKey &forwardCollideKey = ((*otheriter)->getCollideKey());
                if (forwardCollideKey.radius>(collideKey.radius+fudgeFactor+(2 * (*thisiter )->getRadius()))||forwardCollideKey.surface!=collideKey.surface) {
                    break;
                }
                (*thisiter)->collide(*otheriter);
            }
        }
    }
};
#endif

---