---

obstacle_grid.h

Go to the documentation of this file.

#ifndef __OBSTACLE_GRID_H__
#define __OBSTACLE_GRID_H__
#include "obstacle.h"
#include "hashtable.h"


class VectorHash {
    static float frem (float a, float b) {
        float ne=fmod(a,b);
        if (ne<0) {
            return b+ne;
        } else {
            return ne;
        }
    }
public:
    unsigned int hashval;
    static const float shortWidth() {return 65536-129;} 

    inline operator unsigned int () const {
        return hashval;
    }
    VectorHash () {
        hashval=0;
    }
    void operator= (const VectorHash &oth) {
        hashval=oth.hashval;
    }
    VectorHash (const VectorHash &oth) : hashval(oth.hashval) {}
    VectorHash (const Vector &coord) {
        Vector crd (coord.Scale(ScaleAmt));
        hashval =((unsigned int)((frem(floor(crd.i),shortWidth()))+(shortWidth()*floor(crd.j))));
    }
    bool operator== (const VectorHash &oth)const {
        return hashval==oth.hashval;
    }
    bool operator< (const VectorHash &oth)const {
        return hashval<oth.hashval;
    }
    static const float ScaleAmt;
};



#include <stdio.h>
class ObstacleGrid {
public:
    typedef Hashtable <class VectorHash, Obstacle *, 65535> ObstMap;
    typedef std::multimap <Obstacle::ModelRef, Obstacle> MeshSortedObstMap;
private:
    ObstMap collObst;

    MeshSortedObstMap drawObst;
public:
    ObstMap::iterator getByColl (const Vector& coord) {
        VectorHash hash (coord);
        return collObst.find (hash);
    }
    MeshSortedObstMap::iterator getByDraw (const Obstacle::ModelRef& model) {
        return drawObst.find (model);
    }
    class MyFuncBase {
    protected:
        ObstacleGrid *parent; 
        Obstacle *obst;
    public:
        MyFuncBase (ObstacleGrid *myparent, Obstacle *obstacle)
                : parent (myparent), obst (obstacle) {
        }
    };
    class PutFunc : public MyFuncBase {
    public:
        PutFunc(ObstacleGrid * myparent, Obstacle * obstacle) : MyFuncBase(myparent,obstacle){}
        inline void operator() (Vector pos){
            ObstMap::iterator iter=parent->collObst.insert (ObstMap::value_type(VectorHash (pos), obst));
            printf ("Adding %X (%f,%f)\n",&(*iter),pos.i,pos.j);
        }
    };
    class EraseFunc : public MyFuncBase {
    public:
        EraseFunc(ObstacleGrid * myparent, Obstacle * obstacle) : MyFuncBase(myparent,obstacle){}
        inline void operator() (Vector pos){
            ObstMap::iterator iter=parent->getByColl(pos);
            while (iter!=iter.end()) {
                if (&(*iter->second)==obst) {
                    printf ("Erasing %X (%f,%f)\n",obst,pos.i,pos.j);
                    parent->collObst.erase(iter);
                    break;
                }
                ++iter;
            }
        }
    };
    friend class MyFuncBase;
    friend class PutFunc;
    friend class EraseFunc;
    MeshSortedObstMap::iterator put (const Obstacle &o) {
        MeshSortedObstMap::value_type v(o.model,o);
        MeshSortedObstMap::iterator i = drawObst.insert (v);
        Obstacle * obst = &(*i).second;
        const Vector fudgeFactor (0,0,0);//.01/VectorHash::ScaleAmt,.01/VectorHash::ScaleAmt,.01/VectorHash::ScaleAmt);
        Vector firstcoord (obst->getPosition()+obst->getMin()-fudgeFactor);
        Vector lastcoord (obst->getPosition()+obst->getMax()+fudgeFactor);
        printf("ADD %X (%f,%f),(%f,%f)\n",obst,firstcoord.i,firstcoord.j,lastcoord.i,lastcoord.j);
        forEach2dVector (firstcoord, lastcoord, PutFunc(this, obst),Vector(1/VectorHash::ScaleAmt,1/VectorHash::ScaleAmt,1/VectorHash::ScaleAmt));
        return i;
    }
    void erase (Obstacle &obst) {
        {
            const Vector fudgeFactor (.05/VectorHash::ScaleAmt,.05/VectorHash::ScaleAmt,.05/VectorHash::ScaleAmt);
            Vector firstcoord (obst.getPosition()+obst.getMin()-fudgeFactor);
            Vector lastcoord (obst.getPosition()+obst.getMax()+fudgeFactor);
            printf("ERASE %X (%f,%f),(%f,%f)\n",&obst,firstcoord.i,firstcoord.j,lastcoord.i,lastcoord.j);
            forEach2dVector (firstcoord, lastcoord, EraseFunc(this, &obst),Vector(1/VectorHash::ScaleAmt,1/VectorHash::ScaleAmt,1/VectorHash::ScaleAmt));
        }{
            for (MeshSortedObstMap::iterator miter=drawObst.find(obst.model);miter!=drawObst.end()&&(*miter).first==obst.model;++miter) {
                if (&(*miter).second==(&obst)) {
                    drawObst.erase(miter);
                    break;
                }
            }
        }
        
    }

    ObstMap::vector_type &getCollObstacleList (const Vector &coord) {
        return collObst.GetAll(VectorHash (coord));
    }

    std::vector <Obstacle> getDrawObstacleList (Collidable::ModelRef ref) {
        using std::vector;
        MeshSortedObstMap::iterator iter=getByDraw (ref);
        Collidable::ModelRef hash ((*iter).first);
        vector <Obstacle> obstvec;
        while (iter!=endByDraw()&&(*iter).first==hash) {
            obstvec.push_back ((*iter).second);
            iter++;
        }
        return obstvec;
    }
    
    void collideWithSpectres () {
//      for (iterator iter=
        //FIXME PATRICK
    }
    

    ObstMap::iterator::it_type endByColl (ObstMap::iterator tablenum) {
        return tablenum.end();
    }
    
    const MeshSortedObstMap::iterator endByDraw () {return drawObst.end();} 
};

const float VectorHash::ScaleAmt=(float)(2.);

#endif

---