Nettoyage des subdivisions de bâtiments.
This commit is contained in:
Georges Dupéron
parent
f6167e172d
commit
a9c29c7fc7
|
|
@ -1,108 +1,12 @@
|
|||
#include "all_includes.hh"
|
||||
|
||||
Mur::Mur(Segment _s) : s(_s) {}
|
||||
|
||||
void Mur::addSplitPoint(float position) {
|
||||
(void)position;
|
||||
}
|
||||
|
||||
bool Mur::addDoor(float start, float end) {
|
||||
(void)start; (void)end;
|
||||
return true;
|
||||
}
|
||||
|
||||
bool Mur::addWindow(float start, float end) {
|
||||
(void)start; (void)end;
|
||||
return true;
|
||||
}
|
||||
|
||||
Piece::Piece(Quad _c, Mur* n, Mur* e, Mur* s, Mur* w) : c(_c) {
|
||||
murs[0] = n;
|
||||
murs[1] = e;
|
||||
murs[2] = s;
|
||||
murs[3] = w;
|
||||
}
|
||||
|
||||
BatimentQuad_::BatimentQuad_(Quad _c) : Chose(), c(_c) {
|
||||
addEntropy(c);
|
||||
}
|
||||
|
||||
bool BatimentQuad_::split() {
|
||||
unsigned int trynumber = 0;
|
||||
unsigned int tryseed = hash2(seed, trynumber);
|
||||
std::queue<Piece*> queue;
|
||||
for (int i = 0; i < 4; i++)
|
||||
murs.push_back(new Mur(Segment(c[NE+i], c[SE+i])));
|
||||
queue.push(new Piece(c, murs[0], murs[1], murs[2], murs[3]));
|
||||
|
||||
// TODO : placer la porte d'entrée ?
|
||||
|
||||
Piece* piece;
|
||||
while (!queue.empty()) {
|
||||
piece = queue.front(); queue.pop();
|
||||
pieces.push_back(piece);
|
||||
if (piece->c.surface() < 14 * 100 * 100)
|
||||
continue;
|
||||
switch (hash2(tryseed, 0) % 2) {
|
||||
case 0: { // rectangle
|
||||
if (piece->c.surface() > 100 * 100 * 100 && piece->c.minLength() > 10) {
|
||||
float size = piece->c.minLength() / 3.f;
|
||||
Quad takeN = piece->c.inset(N, size);
|
||||
Quad takeS = takeN.inset(S, size);
|
||||
Quad takeE = takeS.inset(E, size);
|
||||
Quad takeW = takeS.inset(W, size);
|
||||
Quad q[4];
|
||||
q[N] = Quad(piece->c[NE], takeN[NE], takeN[NW], piece->c[NW]);
|
||||
q[E] = Quad(takeS[SE], takeE[SE], takeE[NE], takeS[NE]);
|
||||
q[S] = Quad(piece->c[SW], takeS[SW], takeS[SE], piece->c[SW]);
|
||||
q[W] = Quad(takeS[NW], takeW[NW], takeW[SW], takeS[SW]);
|
||||
Quad qC = takeW;
|
||||
Mur* m[4];
|
||||
m[N] = new Mur(Segment(q[N][SW], q[N][SE]));
|
||||
m[E] = new Mur(Segment(q[E][SW], q[E][SE]));
|
||||
m[S] = new Mur(Segment(q[S][SW], q[S][SE]));
|
||||
m[W] = new Mur(Segment(q[W][SW], q[W][SE]));
|
||||
Piece* p[4];
|
||||
p[N] = new Piece(q[N], piece->murs[N], piece->murs[E], m[N], piece->murs[W]);
|
||||
p[E] = new Piece(q[E], piece->murs[E], m[S], m[E], m[N]);
|
||||
p[S] = new Piece(q[S], piece->murs[S], piece->murs[W], m[S], piece->murs[E]);
|
||||
p[W] = new Piece(q[W], piece->murs[W], m[N], m[W], m[S]);
|
||||
Piece* pC = new Piece(qC, m[N], m[E], m[S], m[W]);
|
||||
for (int i = 0; i < 4; i++) {
|
||||
murs.push_back(m[N+i]);
|
||||
queue.push(p[N+i]);
|
||||
}
|
||||
queue.push(pC);
|
||||
// TODO connecter les pièces avec des addDoor (sur les murs les séparant, et/ou à la pièce centrale) ???
|
||||
break;
|
||||
}
|
||||
}
|
||||
case 1: // donut
|
||||
default: {
|
||||
Cardinal offset = piece->c.maxLengthSide();
|
||||
Vertex n = Segment(piece->c[NW + offset], piece->c[NE + offset]).randomPos(tryseed, 1, 1.f/3.f, 2.f/3.f);
|
||||
Vertex s = Segment(piece->c[SE + offset], piece->c[SW + offset]).randomPos(tryseed, 1, 1.f/3.f, 2.f/3.f);
|
||||
piece->murs[offset]->addSplitPoint(0); // TODO
|
||||
piece->murs[offset+2]->addSplitPoint(0); // TODO
|
||||
Mur* mur = new Mur(Segment(n, s));
|
||||
Piece* p1 = new Piece(Quad(n, piece->c[NE+offset], piece->c[SE+offset], s), piece->murs[offset], piece->murs[offset+1], piece->murs[offset+2], mur);
|
||||
Piece* p2 = new Piece(Quad(s, piece->c[SW+offset], piece->c[NW+offset], n), piece->murs[offset+2], piece->murs[offset+3], piece->murs[offset], mur);
|
||||
murs.push_back(mur);
|
||||
queue.push(p1);
|
||||
queue.push(p2);
|
||||
// TODO : addDoor(start, end); sur le mur les séparant. ?
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
std::vector<Piece*>::iterator it;
|
||||
for (it = pieces.begin(); it != pieces.end(); ++it) {
|
||||
Quad c = (*it)->c.insetNESW(50);
|
||||
addGPUQuad(c, Couleurs::cielHaut);
|
||||
}
|
||||
//Quad ch = c.offsetNormal(Dimensions::hauteurEtage);
|
||||
//addChild(new ToitQuad(ch, Dimensions::hauteurToit));
|
||||
Quad ch = c.offsetNormal(Dimensions::hauteurEtage);
|
||||
addChild(new ToitQuad(ch, Dimensions::hauteurToit));
|
||||
return true;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -3,28 +3,8 @@
|
|||
|
||||
#include "all_includes.hh"
|
||||
|
||||
class Mur {
|
||||
private:
|
||||
std::map<float,Segment> objets;
|
||||
Segment s;
|
||||
public:
|
||||
Mur(Segment _s);
|
||||
void addSplitPoint(float position);
|
||||
bool addDoor(float start, float end);
|
||||
bool addWindow(float start, float end);
|
||||
};
|
||||
|
||||
class Piece {
|
||||
public:
|
||||
Quad c;
|
||||
Mur* murs[4];
|
||||
Piece(Quad _c, Mur* n, Mur* e, Mur* s, Mur* w);
|
||||
};
|
||||
|
||||
class BatimentQuad_ : public Chose {
|
||||
Quad c;
|
||||
std::vector<Piece*> pieces;
|
||||
std::vector<Mur*> murs;
|
||||
public:
|
||||
BatimentQuad_(Quad _c);
|
||||
virtual bool split();
|
||||
|
|
@ -41,120 +21,4 @@ public:
|
|||
virtual void getBoundingBoxPoints();
|
||||
};
|
||||
|
||||
class Wall;
|
||||
class MasterWall;
|
||||
class WallVertex {
|
||||
public:
|
||||
Vertex vertex;
|
||||
MasterWall* onMasterWall;
|
||||
float posOnMasterWall;
|
||||
std::map<WallVertex*, MasterWall*> endWall;
|
||||
public:
|
||||
operator Vertex() { return vertex; };
|
||||
WallVertex(Vertex _v) : vertex(_v), onMasterWall(NULL), posOnMasterWall(0) {};
|
||||
WallVertex(Vertex _v, MasterWall* _onWall, float _posOnWall) : vertex(_v), onMasterWall(_onWall), posOnMasterWall(_posOnWall) {};
|
||||
void addEndWall(WallVertex* v, MasterWall* w) { endWall.insert(std::pair<WallVertex*, MasterWall*>(v, w)); }
|
||||
};
|
||||
|
||||
class MasterWall;
|
||||
class MasterWallIterator : public std::iterator<std::input_iterator_tag, MasterWall> {
|
||||
private:
|
||||
std::map<float, WallVertex*>::iterator it;
|
||||
bool reverse;
|
||||
public:
|
||||
MasterWallIterator() : it(), reverse(false) {};
|
||||
MasterWallIterator(std::map<float, WallVertex*>::iterator mwit) : it(mwit), reverse(false) {};
|
||||
MasterWallIterator(std::map<float, WallVertex*>::iterator mwit, bool _reverse) : it(mwit), reverse(_reverse) {};
|
||||
MasterWallIterator(std::map<float, WallVertex*>::reverse_iterator mwrit) : it(--(mwrit.base())), reverse(false) {};
|
||||
MasterWallIterator(const MasterWallIterator& copy) : it(copy.it), reverse(copy.reverse) {};
|
||||
bool operator==(const MasterWallIterator& mwit) const { return it == mwit.it; };
|
||||
bool operator!=(const MasterWallIterator& mwit) const { return it != mwit.it; };
|
||||
WallVertex* operator*() { return (*it).second; };
|
||||
WallVertex* operator->() { return (*it).second; };
|
||||
virtual MasterWallIterator& operator++() { if (reverse) it--; else it++; return (*this); }
|
||||
};
|
||||
|
||||
class MasterWall {
|
||||
private:
|
||||
std::map<float, WallVertex*> vertices;
|
||||
public:
|
||||
typedef MasterWallIterator iterator;
|
||||
MasterWall(WallVertex* u, WallVertex* v) {
|
||||
insert(0, u);
|
||||
insert(1, v);
|
||||
};
|
||||
void insert(float position, WallVertex* u) {
|
||||
vertices.insert(std::pair<float, WallVertex*>(position,u));
|
||||
};
|
||||
WallVertex* u() { return vertices.begin()->second; };
|
||||
WallVertex* v() { return vertices.rbegin()->second; };
|
||||
iterator begin() { return iterator(vertices.begin()); }
|
||||
iterator end() { return iterator(vertices.end()); }
|
||||
iterator rbegin() { return iterator(vertices.rbegin()); }
|
||||
iterator rend() { return iterator(vertices.rend()); }
|
||||
iterator find(float position) { return iterator(vertices.find(position)); }
|
||||
iterator rfind(float position) { return iterator(vertices.find(position), true); }
|
||||
iterator find(float position, bool reverse) { return iterator(vertices.find(position), reverse); }
|
||||
};
|
||||
|
||||
class Wall {
|
||||
public:
|
||||
WallVertex* u;
|
||||
WallVertex* v;
|
||||
float uPosOnMasterWall;
|
||||
float vPosOnMasterWall;
|
||||
MasterWall* master;
|
||||
public:
|
||||
Wall(WallVertex* _u, WallVertex* _v) {
|
||||
u = _u;
|
||||
v = _v;
|
||||
if (u->onMasterWall != NULL && u->onMasterWall == v->onMasterWall) { // u et v au milieu de master
|
||||
master = u->onMasterWall;
|
||||
uPosOnMasterWall = u->posOnMasterWall;
|
||||
vPosOnMasterWall = v->posOnMasterWall;
|
||||
} else if (u->onMasterWall != NULL && (u->onMasterWall->u() == v || u->onMasterWall->v() == v)) { // u au milieu de master, v au bord
|
||||
master = u->onMasterWall;
|
||||
uPosOnMasterWall = u->posOnMasterWall;
|
||||
vPosOnMasterWall = (master->u() == v) ? 0 : 1;
|
||||
} else if (v->onMasterWall != NULL && (v->onMasterWall->u() == u || v->onMasterWall->v() == u)) { // v au milieu de master, u au bord
|
||||
master = v->onMasterWall;
|
||||
uPosOnMasterWall = (master->u() == u) ? 0 : 1;
|
||||
vPosOnMasterWall = v->posOnMasterWall;
|
||||
} else {
|
||||
std::map<WallVertex*, MasterWall*>::iterator it = u->endWall.find(v);
|
||||
if (it != u->endWall.end()) { // u et v au bord d'un master existant.
|
||||
master = it->second;
|
||||
uPosOnMasterWall = (master->u() == u) ? 0 : 1;
|
||||
vPosOnMasterWall = (master->u() == u) ? 1 : 0;
|
||||
} else { // u et v au bord d'un nouveau master.
|
||||
master = new MasterWall(u, v);
|
||||
uPosOnMasterWall = 0;
|
||||
vPosOnMasterWall = 1;
|
||||
u->addEndWall(v, master);
|
||||
v->addEndWall(u, master);
|
||||
}
|
||||
}
|
||||
};
|
||||
operator Segment () {
|
||||
return Segment(*u, *v);
|
||||
}
|
||||
WallVertex* randomPos(int seed, int n, float a, float b) {
|
||||
float width = vPosOnMasterWall - uPosOnMasterWall;
|
||||
float pos = floatInRange(seed, n, uPosOnMasterWall + a*width, uPosOnMasterWall + b*width);
|
||||
MasterWallIterator mwi = master->find(pos);
|
||||
if (mwi == master->end()) { // Il n'y a pas encore de WallVertex à cette position sur master.
|
||||
Vertex mu = *(master->u());
|
||||
Vertex mv = *(master->v());
|
||||
WallVertex* wv = new WallVertex(mu * pos + mv * (1-pos), master, pos);
|
||||
master->insert(pos, wv);
|
||||
return wv;
|
||||
} else { // Il y a déjà un WallVertex à cette position sur master.
|
||||
return (*mwi);
|
||||
}
|
||||
};
|
||||
typedef MasterWall::iterator iterator;
|
||||
iterator begin() { return master->find(uPosOnMasterWall, (uPosOnMasterWall > vPosOnMasterWall)); };
|
||||
iterator end() { return ++(master->find(vPosOnMasterWall, (uPosOnMasterWall > vPosOnMasterWall))); };
|
||||
};
|
||||
|
||||
#endif
|
||||
|
|
|
|||
Loading…
Reference in New Issue
Block a user