suzanne.soy/2011-m2s3-city-builder
1
0
Fork 0
Code Issues 1 Pull Requests Actions Packages Projects Releases Wiki Activity

Corrections.

Browse Source
This commit is contained in:
Georges Dupéron 2012-01-13 16:01:03 +01:00
parent e5505e08c8
commit c87e38b4bb
24 changed files with 167 additions and 149 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
all_includes.hh
View File

@ -33,12 +33,14 @@ class Chose;
#include "view.hh" #include "view.hh"
#include "rules/chose.hh" #include "rules/chose.hh"
#include "rules/architecture/couleurs.hh"
#include "rules/architecture/arche.hh" #include "rules/architecture/arche.hh"
#include "rules/architecture/toit.hh" #include "rules/architecture/batiment.hh"
#include "rules/architecture/quartier.hh" #include "rules/architecture/quartier.hh"
#include "rules/architecture/terrain.hh"
#include "rules/architecture/routetrottoir.hh" #include "rules/architecture/routetrottoir.hh"
#include "rules/architecture/terrain.hh"
#include "rules/architecture/toit.hh"
#include "rules/batiment/batimentquad.hh" #include "rules/batiment/batimentquad.hh"
#include "rules/batiment/batimentquadmaison.hh" #include "rules/batiment/batimentquadmaison.hh"

2
main.cpp
View File

@ -10,7 +10,7 @@ int main() {
Vertex se(size, 0, 0); Vertex se(size, 0, 0);
Vertex sw(0, 0, 0); Vertex sw(0, 0, 0);
Vertex nw(0, size, 0); Vertex nw(0, size, 0);
Chose* c = new QuartierQuad_(Quad(ne, se, sw, nw)); Chose* c = new QuartierQuad(Quad(ne, se, sw, nw));
c->triangulation(); c->triangulation();
c->updateAABB(); c->updateAABB();

2
rules/architecture/arche.cpp
View File

@ -17,7 +17,7 @@ bool ArcheQuad::split() {
void ArcheQuad::triangulation() { void ArcheQuad::triangulation() {
Quad che = c.offsetNormal(f(end) * height); Quad che = c.offsetNormal(f(end) * height);
Quad chw = c.offsetNormal(f(start) * height); Quad chw = c.offsetNormal(f(start) * height);
addGPUOcto(c, Quad(che[NE], che[SE], chw[SW], chw[NW]), r, g, b); addGPUOcto(c, Quad(che[NE], che[SE], chw[SW], chw[NW]), Couleurs::mur);
} }
void ArcheQuad::getBoundingBoxPoints() { void ArcheQuad::getBoundingBoxPoints() {

5
rules/architecture/arche.hh
View File

@ -17,11 +17,6 @@ public:
float f(float x); float f(float x);
float ogive(float x); float ogive(float x);
float berceau(float x); float berceau(float x);
private:
// TODO : couleur de l'arche
static const char r = 0xF1; // TODO : factoriser cette couleur (couleur des murs des faux bâtiments).
static const char g = 0xE3;
static const char b = 0xAD;
}; };
#endif #endif

0
rules/architecture/batiment.cpp Normal file
View File

4
rules/architecture/batiment.hh Normal file
View File

@ -0,0 +1,4 @@
#include "all_includes.hh"
//class Batiment_ : public Chose {
//};

16
rules/architecture/couleurs.hh Normal file
View File

@ -0,0 +1,16 @@
#ifndef _RULES_ARCHITECTURE_COLORS_HH_
#define _RULES_ARCHITECTURE_COLORS_HH_
#include "all_includes.hh"
class Couleurs {
public:
static const unsigned int mur = 0xF1E3AD;
static const unsigned int toit = 0xE02000;
static const unsigned int route = 0x363636;
static const unsigned int trottoir = 0x666666;
static const unsigned int bordureTrottoir = 0xAAAAAA;
static const unsigned int herbe = 0x11AA22;
};
#endif

105
rules/architecture/quartier.cpp
View File

@ -1,22 +1,24 @@
#include "all_includes.hh" #include "all_includes.hh"
QuartierQuad_::QuartierQuad_(Quad _c) : Chose(), c(_c) { QuartierQuad::QuartierQuad(Quad _c) : Chose(), c(_c) {
addEntropy(c); addEntropy(c);
} }
void QuartierQuad_::getBoundingBoxPoints() { void QuartierQuad::getBoundingBoxPoints() {
addBBPoints(c, 600); // TODO : factoriser cette longueur (hauteur max des bâtiments). addBBPoints(c, 600); // TODO : factoriser cette longueur (hauteur max des bâtiments).
} }
bool QuartierQuad_::split() { bool QuartierQuad::split() {
bool small = c.minLength() < 3500; bool small = c.minLength() < 3500;
bool isConcave = c.isConcave(); bool isConcave = c.isConcave();
//bool isConcave = c.maxAngle() > Angle::d2r(160); bool nearConcave = c.maxAngle() > Angle::d2r(160);
bool anglesOk = c.minAngle() > Angle::d2r(90-40) && c.maxAngle() < Angle::d2r(90+40); bool anglesOk = c.minAngle() > Angle::d2r(90-40) && c.maxAngle() < Angle::d2r(90+40);
bool tooWideX = c.minLengthEW() * 2 < c.maxLengthNS(); // trop allongé (côté E ou W deux fois plus petit que le côté N ou S). bool tooWideX = c.minLengthEW() * 2 < c.maxLengthNS(); // trop allongé (côté E ou W deux fois plus petit que le côté N ou S).
bool tooWideY = c.minLengthNS() * 2 < c.maxLengthEW(); // trop allongé (côté N ou S deux fois plus petit que le côté E ou W). bool tooWideY = c.minLengthNS() * 2 < c.maxLengthEW(); // trop allongé (côté N ou S deux fois plus petit que le côté E ou W).
if (isConcave) if (isConcave)
concave(); concave();
else if (nearConcave)
angleAngle();
else if (!small && !anglesOk && proba(seed, -2, 1, 2)) else if (!small && !anglesOk && proba(seed, -2, 1, 2))
angleAngle(); angleAngle();
else if (!small && !anglesOk) else if (!small && !anglesOk)
@ -30,55 +32,59 @@ bool QuartierQuad_::split() {
return true; return true;
} }
void QuartierQuad_::triangulation() { void QuartierQuad::triangulation() {
Quad ci = c.insetNESW(250 + 140); // TODO : factoriser cette longueur (largeur route + largeur trottoir). if (c.isConcave()) {
Quad cih = ci.offsetNormal(600); // TODO : factoriser cette longueur (hauteur max des bâtiments). // TODO
addGPUQuad(c, 0x36, 0x36, 0x36); // TODO : factoriser cette couleur (couleur de la route). Quad q = c << c.concaveCorner();
addGPUQuad(cih, 0xF1, 0xE0, 0xE0); // TODO : factoriser cette couleur (couleur des toits). addGPUTriangle(Triangle(q[NE], q[SE], q[SW]), Couleurs::route);
for (int i = 0; i < 4; i++) addGPUTriangle(Triangle(q[SW], q[NW], q[NE]), Couleurs::route);
addGPUQuad(Quad(ci[NE+i], ci[SE+i], cih[SE+i], cih[NE+i]), 0xF1, 0xE3, 0xAD); // TODO : factoriser cette couleur (couleur des murs des faux bâtiments). } else {
Quad ci = c.insetNESW(250 + 140); // TODO : factoriser cette longueur (largeur route + largeur trottoir).
Quad cih = ci.offsetNormal(600); // TODO : factoriser cette longueur (hauteur max des bâtiments).
addGPUQuad(c, Couleurs::route);
addGPUQuad(cih, Couleurs::toit);
for (int i = 0; i < 4; i++)
addGPUQuad(Quad(ci[NE+i], ci[SE+i], cih[SE+i], cih[NE+i]), Couleurs::mur);
}
} }
void QuartierQuad_::concave() { void QuartierQuad::concave() {
// TODO À vérifier. Quad q = c << c.concaveCorner();
Triangle t1(c[c.concaveCorner()], c[c.concaveCorner()+1], c[c.concaveCorner()+2]); addChild(new QuartierTri(Triangle(q[NE], q[SE], q[SW])));
Triangle t2(c[c.concaveCorner()+2], c[c.concaveCorner()+3], c[c.concaveCorner()]); addChild(new QuartierTri(Triangle(q[SW], q[NW], q[NE])));
addChild(new QuartierTri_(t1));
addChild(new QuartierTri_(t2));
} }
void QuartierQuad_::angleCote() { void QuartierQuad::angleCote() {
Quad q = c << c.maxAngleCorner(); Quad q = c << c.maxAngleCorner();
Vertex s = Segment(q[SE], q[SW]).randomPos(seed, 1, 0.4f, 0.6f); Vertex s = Segment(q[SE], q[SW]).randomPos(seed, 1, 0.4f, 0.6f);
Vertex w = Segment(q[SW], q[NW]).randomPos(seed, 0, 0.4f, 0.6f); Vertex w = Segment(q[SW], q[NW]).randomPos(seed, 0, 0.4f, 0.6f);
Triangle ts(q[SE], s, q[NE]); Triangle ts(q[SE], s, q[NE]);
Triangle tw(q[NE], w, q[NW]); Triangle tw(q[NE], w, q[NW]);
if (ts.minAngle() > tw.minAngle()) { if (ts.minAngle() > tw.minAngle()) {
addChild(new QuartierTri_(ts)); addChild(new QuartierTri(ts));
addChild(new QuartierQuad_(Quad(q[NE], s, q[SW], q[NW]))); addChild(new QuartierQuad(Quad(q[NE], s, q[SW], q[NW])));
} else { } else {
addChild(new QuartierTri_(tw)); addChild(new QuartierTri(tw));
addChild(new QuartierQuad_(Quad(q[NE], q[SE], q[SW], w))); addChild(new QuartierQuad(Quad(q[NE], q[SE], q[SW], w)));
} }
} }
void QuartierQuad_::angleAngle() { void QuartierQuad::angleAngle() {
Quad q = c << c.maxAngleCorner(); Quad q = c << c.maxAngleCorner();
addChild(new QuartierTri_(Triangle(q[NE], q[SE], q[SW]))); addChild(new QuartierTri(Triangle(q[NE], q[SE], q[SW])));
addChild(new QuartierTri_(Triangle(q[SW], q[NW], q[NE]))); addChild(new QuartierTri(Triangle(q[SW], q[NW], q[NE])));
} }
void QuartierQuad_::rect() { void QuartierQuad::rect() {
Quad q = c << c.maxLengthSide(); Quad q = c << c.maxLengthSide();
Vertex n = Segment(q[NW], q[NE]).randomPos(seed, 0, 1.f/3.f, 2.f/3.f); Vertex n = Segment(q[NW], q[NE]).randomPos(seed, 0, 1.f/3.f, 2.f/3.f);
Vertex s = Segment(q[SE], q[SW]).randomPos(seed, 1, 1.f/3.f, 2.f/3.f); Vertex s = Segment(q[SE], q[SW]).randomPos(seed, 1, 1.f/3.f, 2.f/3.f);
addChild(new QuartierQuad_(Quad(q[NE], q[SE], s, n))); addChild(new QuartierQuad(Quad(q[NE], q[SE], s, n)));
addChild(new QuartierQuad_(Quad(q[SW], q[NW], n, s))); addChild(new QuartierQuad(Quad(q[SW], q[NW], n, s)));
} }
void QuartierQuad_::carre() { void QuartierQuad::carre() {
// TODO : insetProportionnal(); // TODO : insetProportionnal();
Vertex center = c.insetNESW(c.minLength() / 4.f).randomPoint(seed, 0); Vertex center = c.insetNESW(c.minLength() / 4.f).randomPoint(seed, 0);
Vertex middle[4]; Vertex middle[4];
@ -86,10 +92,10 @@ void QuartierQuad_::carre() {
middle[N+i] = Segment(c[NW+i], c[NE+i]).randomPos(seed, i + 1, 0.25, 0.75); middle[N+i] = Segment(c[NW+i], c[NE+i]).randomPos(seed, i + 1, 0.25, 0.75);
for (int i = 0; i < 4; i++) for (int i = 0; i < 4; i++)
addChild(new QuartierQuad_(Quad(c[NE+i], middle[E+i], center, middle[N+i]))); addChild(new QuartierQuad(Quad(c[NE+i], middle[E+i], center, middle[N+i])));
} }
void QuartierQuad_::batiments() { void QuartierQuad::batiments() {
float hauteurTrottoir = 20; // TODO : factoriser + ajouter ça à la hauteur max d'un bâtiment dans les autres calculs. float hauteurTrottoir = 20; // TODO : factoriser + ajouter ça à la hauteur max d'un bâtiment dans les autres calculs.
Quad qtrottoir = c.insetNESW(250); Quad qtrottoir = c.insetNESW(250);
Quad qinterieur = qtrottoir.insetNESW(140); Quad qinterieur = qtrottoir.insetNESW(140);
@ -111,15 +117,15 @@ void QuartierQuad_::batiments() {
} }
} }
QuartierTri_::QuartierTri_(Triangle _c) : Chose(), c(_c) { QuartierTri::QuartierTri(Triangle _c) : Chose(), c(_c) {
addEntropy(c); addEntropy(c);
} }
void QuartierTri_::getBoundingBoxPoints() { void QuartierTri::getBoundingBoxPoints() {
addBBPoints(c, 600); // TODO : factoriser cette longueur (hauteur max des bâtiments). addBBPoints(c, 600); // TODO : factoriser cette longueur (hauteur max des bâtiments).
} }
bool QuartierTri_::split() { bool QuartierTri::split() {
bool small = c.minLength() < 5000; bool small = c.minLength() < 5000;
bool big = c.maxLength() >= 10000; bool big = c.maxLength() >= 10000;
float minAngle = c.minAngle(); float minAngle = c.minAngle();
@ -149,16 +155,16 @@ bool QuartierTri_::split() {
return true; return true;
} }
void QuartierTri_::triangulation() { void QuartierTri::triangulation() {
Triangle ci = c.insetLTR(250 + 140); // TODO : factoriser cette longueur (largeur route + largeur trottoir). Triangle ci = c.insetLTR(250 + 140); // TODO : factoriser cette longueur (largeur route + largeur trottoir).
Triangle cih = c.offsetNormal(600); // TODO : factoriser cette longueur (hauteur max des bâtiments). Triangle cih = ci.offsetNormal(600); // TODO : factoriser cette longueur (hauteur max des bâtiments).
addGPUTriangle(c, 0x36, 0x36, 0x36); // TODO : factoriser cette couleur (couleur de la route). addGPUTriangle(c, Couleurs::route);
addGPUTriangle(cih, 0xF1, 0xE0, 0xE0); // TODO : factoriser cette couleur (couleur des toits). addGPUTriangle(cih, Couleurs::toit);
for (int i = 0; i < 3; i++) for (int i = 0; i < 3; i++)
addGPUQuad(Quad(ci[LEFT+i], ci[TOP+i], cih[TOP+i], cih[LEFT+i]), 0xF1, 0xE3, 0xAD); // TODO : factoriser cette couleur (couleur des murs des faux bâtiments). addGPUQuad(Quad(ci[LEFT+i], ci[TOP+i], cih[TOP+i], cih[LEFT+i]), Couleurs::mur);
} }
void QuartierTri_::centre() { void QuartierTri::centre() {
// TODO : maxLength / 6 au lieu de 1000 // TODO : maxLength / 6 au lieu de 1000
// TODO : insetProportionnal(); // TODO : insetProportionnal();
Vertex center = c.insetLTR(c.maxLength() / 6).randomPoint(seed, 0); Vertex center = c.insetLTR(c.maxLength() / 6).randomPoint(seed, 0);
@ -167,27 +173,28 @@ void QuartierTri_::centre() {
edge[LEFTSIDE+i] = Segment(c[LEFT+i], c[TOP+i]).randomPos(seed, i+1, 1.f/3.f, 2.f/3.f); edge[LEFTSIDE+i] = Segment(c[LEFT+i], c[TOP+i]).randomPos(seed, i+1, 1.f/3.f, 2.f/3.f);
for (int i = 0; i < 3; i++) for (int i = 0; i < 3; i++)
addChild(new QuartierQuad_(Quad(c[TOP+i], edge[RIGHTSIDE+i], center, edge[LEFTSIDE+i]))); addChild(new QuartierQuad(Quad(c[TOP+i], edge[RIGHTSIDE+i], center, edge[LEFTSIDE+i])));
} }
void QuartierTri_::hauteur() { void QuartierTri::hauteur() {
Triangle t = c << c.maxAngleCorner(); Triangle t = c << c.maxAngleCorner();
Vertex opposite = Segment(t[TOP], t[RIGHT]).randomPos(seed, 0, 1.f/3.f, 2.f/3.f); Vertex opposite = Segment(t[TOP], t[RIGHT]).randomPos(seed, 0, 1.f/3.f, 2.f/3.f);
addChild(new QuartierTri_(Triangle(t[TOP], opposite, t[LEFT]))); addChild(new QuartierTri(Triangle(t[TOP], opposite, t[LEFT])));
addChild(new QuartierTri_(Triangle(t[LEFT], opposite, t[RIGHT]))); addChild(new QuartierTri(Triangle(t[LEFT], opposite, t[RIGHT])));
} }
void QuartierTri_::trapeze() { void QuartierTri::trapeze() {
Triangle t = c << c.minAngleCorner(); Triangle t = c << c.minAngleCorner();
Vertex left = Segment(t[LEFT], t[TOP]).randomPos(seed, 0, 1.f/3.f, 2.f/3.f); Vertex left = Segment(t[LEFT], t[TOP]).randomPos(seed, 0, 1.f/3.f, 2.f/3.f);
Vertex base = Segment(t[RIGHT], t[LEFT]).randomPos(seed, 1, 1.f/3.f, 2.f/3.f); Vertex base = Segment(t[RIGHT], t[LEFT]).randomPos(seed, 1, 1.f/3.f, 2.f/3.f);
addChild(new QuartierTri_(Triangle(base, t[TOP], left))); addChild(new QuartierTri(Triangle(base, t[LEFT], left)));
addChild(new QuartierQuad_(Quad(left, t[TOP], t[RIGHT], base))); addChild(new QuartierQuad(Quad(base, left, t[TOP], t[RIGHT])));
} }
void QuartierTri_::batiments() { void QuartierTri::batiments() {
return;
float hauteurTrottoir = 20; // TODO : factoriser + ajouter ça à la hauteur max d'un bâtiment dans les autres calculs. float hauteurTrottoir = 20; // TODO : factoriser + ajouter ça à la hauteur max d'un bâtiment dans les autres calculs.
Triangle ttrottoir = c.insetLTR(250); Triangle ttrottoir = c.insetLTR(250);
Triangle tinterieur = ttrottoir.insetLTR(140); Triangle tinterieur = ttrottoir.insetLTR(140);

8
rules/architecture/quartier.hh
View File

@ -3,11 +3,11 @@
#include "all_includes.hh" #include "all_includes.hh"
class QuartierQuad_: public Chose { class QuartierQuad: public Chose {
private: private:
Quad c; Quad c;
public: public:
QuartierQuad_(Quad _c); QuartierQuad(Quad _c);
virtual void getBoundingBoxPoints(); virtual void getBoundingBoxPoints();
virtual bool split(); virtual bool split();
virtual void triangulation(); virtual void triangulation();
@ -20,11 +20,11 @@ private:
void batiments(); void batiments();
}; };
class QuartierTri_: public Chose { class QuartierTri: public Chose {
private: private:
Triangle c; Triangle c;
public: public:
QuartierTri_(Triangle _c); QuartierTri(Triangle _c);
virtual void getBoundingBoxPoints(); virtual void getBoundingBoxPoints();
virtual bool split(); virtual bool split();
virtual void triangulation(); virtual void triangulation();

8
rules/architecture/routetrottoir.cpp
View File

@ -13,9 +13,9 @@ void TrottoirQuad::triangulation() {
Quad ch = c.offsetNormal(height); Quad ch = c.offsetNormal(height);
Quad bordureh = ch.inset(E,15); Quad bordureh = ch.inset(E,15);
addGPUQuad(c[NE], c[SE], ch[SE], ch[NE], 0xAA, 0xAA, 0xAA); addGPUQuad(c[NE], c[SE], ch[SE], ch[NE], Couleurs::bordureTrottoir);
addGPUQuad(ch[NE], ch[SE], bordureh[SE], bordureh[NE], 0xAA, 0xAA, 0xAA); addGPUQuad(ch[NE], ch[SE], bordureh[SE], bordureh[NE], Couleurs::bordureTrottoir);
addGPUQuad(bordureh, 0x66, 0x66, 0x66); addGPUQuad(bordureh, Couleurs::trottoir);
} }
RouteQuad::RouteQuad(Quad _c) : Chose(), c(_c) { RouteQuad::RouteQuad(Quad _c) : Chose(), c(_c) {
@ -30,5 +30,5 @@ void RouteQuad::getBoundingBoxPoints() {
} }
void RouteQuad::triangulation() { void RouteQuad::triangulation() {
addGPUQuad(c, 0x36, 0x36, 0x36); addGPUQuad(c, Couleurs::route);
} }

4
rules/architecture/terrain.cpp
View File

@ -12,7 +12,7 @@ void TerrainQuad::getBoundingBoxPoints() {
} }
void TerrainQuad::triangulation() { void TerrainQuad::triangulation() {
addGPUQuad(c, 0x11, 0xaa, 0x22); addGPUQuad(c, Couleurs::herbe);
} }
TerrainTri::TerrainTri(Triangle _c) : Chose(), c(_c) { TerrainTri::TerrainTri(Triangle _c) : Chose(), c(_c) {
@ -27,5 +27,5 @@ void TerrainTri::getBoundingBoxPoints() {
} }
void TerrainTri::triangulation() { void TerrainTri::triangulation() {
addGPUTriangle(c, 0x11, 0xaa, 0x22); addGPUTriangle(c, Couleurs::herbe);
} }

40
rules/architecture/toit.cpp
View File

@ -25,7 +25,7 @@ void ToitQuad::pointCentral() {
Quad qh = c.offsetNormal(height); Quad qh = c.offsetNormal(height);
Vertex center = qh.insetNESW(qh.minLength() / 3.f).randomPoint(seed, 0); Vertex center = qh.insetNESW(qh.minLength() / 3.f).randomPoint(seed, 0);
for (int i = 0; i < 4; i++) for (int i = 0; i < 4; i++)
addGPUTriangle(c[NE+i], center, c[SE+i], r, g, b); addGPUTriangle(c[NE+i], center, c[SE+i], Couleurs::toit);
} }
void ToitQuad::deuxPoints() { void ToitQuad::deuxPoints() {
@ -36,10 +36,10 @@ void ToitQuad::deuxPoints() {
Vertex e = Segment(qh[NE], qh[SE]).randomPos(seed, 1, 1.f/3.f, 2.f/3.f); Vertex e = Segment(qh[NE], qh[SE]).randomPos(seed, 1, 1.f/3.f, 2.f/3.f);
Vertex centerE = Segment(e,w).randomPos(seed, 2, 0.6f, 0.8f); Vertex centerE = Segment(e,w).randomPos(seed, 2, 0.6f, 0.8f);
Vertex centerW = Segment(e,w).randomPos(seed, 2, 0.2f, 0.4f); Vertex centerW = Segment(e,w).randomPos(seed, 2, 0.2f, 0.4f);
addGPUTriangle(q[NE], centerE, q[SE], r, g, b); addGPUTriangle(q[NE], centerE, q[SE], Couleurs::toit);
addGPUTriangle(q[SW], centerW, q[NW], r, g, b); addGPUTriangle(q[SW], centerW, q[NW], Couleurs::toit);
addGPUQuad(q[SE], q[SW], centerW, centerE, r, g, b); addGPUQuad(q[SE], q[SW], centerW, centerE, Couleurs::toit);
addGPUQuad(q[NW], q[NE], centerE, centerW, r, g, b); addGPUQuad(q[NW], q[NE], centerE, centerW, Couleurs::toit);
} }
void ToitQuad::deuxPointsVerticaux() { void ToitQuad::deuxPointsVerticaux() {
@ -48,14 +48,14 @@ void ToitQuad::deuxPointsVerticaux() {
Quad qh = q.offsetNormal(height); Quad qh = q.offsetNormal(height);
Vertex w = Segment(qh[NW], qh[SW]).randomPos(seed, 0, 1.f/3.f, 2.f/3.f); Vertex w = Segment(qh[NW], qh[SW]).randomPos(seed, 0, 1.f/3.f, 2.f/3.f);
Vertex e = Segment(qh[NE], qh[SE]).randomPos(seed, 1, 1.f/3.f, 2.f/3.f); Vertex e = Segment(qh[NE], qh[SE]).randomPos(seed, 1, 1.f/3.f, 2.f/3.f);
addGPUTriangle(q[NE], e, q[SE], r, g, b); // TODO : devrait être couleur mur. addGPUTriangle(q[NE], e, q[SE], Couleurs::toit); // TODO : devrait être couleur mur.
addGPUTriangle(q[SW], w, q[NW], r, g, b); // TODO : devrait être couleur mur. addGPUTriangle(q[SW], w, q[NW], Couleurs::toit); // TODO : devrait être couleur mur.
addGPUQuad(q[SE], q[SW], w, e, r, g, b); addGPUQuad(q[SE], q[SW], w, e, Couleurs::toit);
addGPUQuad(q[NW], q[NE], e, w, r, g, b); addGPUQuad(q[NW], q[NE], e, w, Couleurs::toit);
} }
void ToitQuad::plat() { void ToitQuad::plat() {
addGPUQuad(c, r, g, b); addGPUQuad(c, Couleurs::toit);
} }
ToitTri::ToitTri(Triangle _c, float _height) : Chose(), c(_c), height(_height) { ToitTri::ToitTri(Triangle _c, float _height) : Chose(), c(_c), height(_height) {
@ -82,35 +82,35 @@ void ToitTri::pointCentral() {
Triangle th = c.offsetNormal(height); Triangle th = c.offsetNormal(height);
Vertex center = th.insetLTR(th.minLength() / 3.f).randomPoint(seed, 0); Vertex center = th.insetLTR(th.minLength() / 3.f).randomPoint(seed, 0);
for (int i = 0; i < 3; i++) for (int i = 0; i < 3; i++)
addGPUTriangle(c[LEFT+i], center, c[TOP+i], r, g, b); addGPUTriangle(c[LEFT+i], center, c[TOP+i], Couleurs::toit);
} }
void ToitTri::troisPoints() { void ToitTri::troisPoints() {
Triangle th = c.offsetNormal(height).insetLTR(c.minLength() / 3.f); Triangle th = c.offsetNormal(height).insetLTR(c.minLength() / 3.f);
addGPUTriangle(th, r, g, b); addGPUTriangle(th, Couleurs::toit);
for (int i = 0; i < 3; i++) for (int i = 0; i < 3; i++)
addGPUQuad(c[LEFT], c[TOP], th[TOP], th[LEFT], r, g, b); addGPUQuad(c[LEFT], c[TOP], th[TOP], th[LEFT], Couleurs::toit);
} }
void ToitTri::unPointVertical() { void ToitTri::unPointVertical() {
// Rotation aléatoire du triangle // Rotation aléatoire du triangle
Triangle t = c >> (hash2(seed, 0) % 3); Triangle t = c >> (hash2(seed, 0) % 3);
Triangle th = t.offsetNormal(height); Triangle th = t.offsetNormal(height);
addGPUTriangle(t[LEFT], th[TOP], t[RIGHT], r, g, b); addGPUTriangle(t[LEFT], th[TOP], t[RIGHT], Couleurs::toit);
addGPUTriangle(t[TOP], th[TOP], t[LEFT], r, g, b); addGPUTriangle(t[TOP], th[TOP], t[LEFT], Couleurs::toit);
addGPUTriangle(t[RIGHT], th[TOP], t[TOP], r, g, b); addGPUTriangle(t[RIGHT], th[TOP], t[TOP], Couleurs::toit);
} }
void ToitTri::deuxPointsVerticaux() { void ToitTri::deuxPointsVerticaux() {
// Rotation aléatoire du triangle // Rotation aléatoire du triangle
Triangle t = c >> (hash2(seed, 0) % 3); Triangle t = c >> (hash2(seed, 0) % 3);
Triangle th = t.offsetNormal(height); Triangle th = t.offsetNormal(height);
addGPUTriangle(th[LEFT], t[TOP], th[RIGHT], r, g, b); addGPUTriangle(th[LEFT], t[TOP], th[RIGHT], Couleurs::toit);
addGPUTriangle(t[TOP], th[LEFT], t[LEFT], r, g, b); addGPUTriangle(t[TOP], th[LEFT], t[LEFT], Couleurs::toit);
addGPUTriangle(t[RIGHT], th[RIGHT], t[TOP], r, g, b); addGPUTriangle(t[RIGHT], th[RIGHT], t[TOP], Couleurs::toit);
} }
void ToitTri::plat() { void ToitTri::plat() {
addGPUTriangle(c, r, g, b); addGPUTriangle(c, Couleurs::toit);
} }

3
rules/architecture/toit.hh
View File

@ -35,9 +35,6 @@ private:
void unPointVertical(); void unPointVertical();
void deuxPointsVerticaux(); void deuxPointsVerticaux();
void plat(); void plat();
static const char r = 0xF1;
static const char g = 0xE0;
static const char b = 0xE0;
}; };
#endif #endif

2
rules/batiment/batimentquad.cpp
View File

@ -26,5 +26,5 @@ void BatimentQuad::triangulation() {
float h = floatInRange(seed,1,minHeight,maxHeight); float h = floatInRange(seed,1,minHeight,maxHeight);
float htoit = floatInRange(seed,2,minHeight/2,maxHeight/2); float htoit = floatInRange(seed,2,minHeight/2,maxHeight/2);
addGPUOcto(c, c + Vertex(0,0,h + htoit), 0xFF, 0xFF, 0xFF); addGPUOcto(c, c + Vertex(0,0,h + htoit), 0xFFFFFF);
} }

2
rules/batiment/batimentquadblock.cpp
View File

@ -36,5 +36,5 @@ bool BatimentQuadBlock::split() {
} }
void BatimentQuadBlock::triangulation() { void BatimentQuadBlock::triangulation() {
addGPUOcto(c,ch, 0xF1, 0xE0, 0xE0); addGPUOcto(c,ch, 0xF1E0E0);
} }

2
rules/batiment/batimentquadjardin.cpp
View File

@ -12,5 +12,5 @@ void BatimentQuadJardin::getBoundingBoxPoints() {
void BatimentQuadJardin::triangulation() { void BatimentQuadJardin::triangulation() {
triangles.reserve(2); triangles.reserve(2);
addGPUQuad(c, 0x12, 0x64, 0x12); addGPUQuad(c, 0x126412);
} }

4
rules/batiment/batimentquadmaison.cpp
View File

@ -28,9 +28,9 @@ void BatimentQuadMaison::triangulation() {
Quad ch = c + Vertex(0,0,h); Quad ch = c + Vertex(0,0,h);
Vertex toit = (ch[NE] + ch[SE] + ch[SW] + ch[NW]) / 4 + Vertex(0,0,htoit); Vertex toit = (ch[NE] + ch[SE] + ch[SW] + ch[NW]) / 4 + Vertex(0,0,htoit);
addGPUOcto(c,ch,0xf1,0xe3,0xad); addGPUOcto(c,ch,Couleurs::mur);
for (int i = 0; i < 4; i++) { for (int i = 0; i < 4; i++) {
addGPUTriangle(ch[SE+i],toit,ch[NE+i],0x96,0x16,0x18); addGPUTriangle(ch[SE+i],toit,ch[NE+i],0x961618);
} }
} }

12
rules/batiment/batimentquadmaisonpont.cpp
View File

@ -35,15 +35,15 @@ void BatimentQuadMaisonPont::triangulation() {
Quad q = c.makeParallelogram(); Quad q = c.makeParallelogram();
Quad qh = q + Vertex(0,0,h); Quad qh = q + Vertex(0,0,h);
addGPUQuad(c,0x80,0x80,0x80); addGPUQuad(c,0x808080);
addGPUOcto(q,qh,0xF1,0xE0,0xE0); addGPUOcto(q,qh,Couleurs::mur);
Vertex ce = qh[SE] + (qh[NE] - qh[SE])/2 + Vertex(0,0,0.5f * height / 3.f); Vertex ce = qh[SE] + (qh[NE] - qh[SE])/2 + Vertex(0,0,0.5f * height / 3.f);
Vertex cw = qh[SW] + (qh[NW] - qh[SW])/2 + Vertex(0,0,0.5f * height / 3.f); Vertex cw = qh[SW] + (qh[NW] - qh[SW])/2 + Vertex(0,0,0.5f * height / 3.f);
addGPUTriangle(qh[NW],cw,qh[SW],0xF1,0xE0,0xE0); addGPUTriangle(qh[NW],cw,qh[SW],Couleurs::mur);
addGPUTriangle(qh[SE],ce,qh[NE],0xF1,0xE0,0xE0); addGPUTriangle(qh[SE],ce,qh[NE],Couleurs::mur);
addGPUQuad(qh[NE],qh[NW],cw,ce,0xE0,0x20,0x00); addGPUQuad(qh[NE],qh[NW],cw,ce,Couleurs::toit);
addGPUQuad(qh[SW],qh[SE],ce,cw,0xE0,0x20,0x00); addGPUQuad(qh[SW],qh[SE],ce,cw,Couleurs::toit);
} }

2
rules/batiment/batimentquadmur.cpp
View File

@ -43,7 +43,7 @@ bool BatimentQuadMur::split() {
void BatimentQuadMur::triangulation() { void BatimentQuadMur::triangulation() {
if(!window) if(!window)
addGPUOcto(c, ch, 0xf1,0xe3,0xad); addGPUOcto(c, ch, Couleurs::mur);
//else //else
//addGPUOcto(c, ch, 0xFF,0x10,0x00); //addGPUOcto(c, ch, 0xFF,0x10,0x00);
//addGPUQuad(windowPosh,0xFF,0xFF,0x00); //addGPUQuad(windowPosh,0xFF,0xFF,0x00);

26
rules/batiment/batimentquadpont.cpp
View File

@ -36,35 +36,35 @@ void BatimentQuadPont::triangulation() {
int middle = steps/2; int middle = steps/2;
int n; int n;
addGPUTriangle(c[SW],pb,ch[SW],0xD0,0xD0,0xD0); addGPUTriangle(c[SW],pb,ch[SW],0xD0D0D0);
addGPUTriangle(pa,c[NW],ch[NW],0xD0,0xD0,0xD0); addGPUTriangle(pa,c[NW],ch[NW],0xD0D0D0);
for(var=-1.7f, n=0; var <= 1.7f; var+=pas, n++) { for(var=-1.7f, n=0; var <= 1.7f; var+=pas, n++) {
q = q.inset(W,n2); q = q.inset(W,n2);
a = q[NW] + Vertex(0,0,nt(var,height)); a = q[NW] + Vertex(0,0,nt(var,height));
b = q[SW] + Vertex(0,0,nt(var,height)); b = q[SW] + Vertex(0,0,nt(var,height));
addGPUQuad(a,b,pb,pa,0xD0,0xD0,0xD0); addGPUQuad(a,b,pb,pa,0xD0D0D0);
if( n < middle) { if( n < middle) {
addGPUTriangle(pa,a,ch[NW],0xD0,0xD0,0xD0); addGPUTriangle(pa,a,ch[NW],0xD0D0D0);
addGPUTriangle(b,pb,ch[SW],0xD0,0xD0,0xD0); addGPUTriangle(b,pb,ch[SW],0xD0D0D0);
} }
else if(n == middle) { else if(n == middle) {
addGPUTriangle(pa,a,ch[NW],0xD0,0xD0,0xD0); addGPUTriangle(pa,a,ch[NW],0xD0D0D0);
addGPUTriangle(b,pb,ch[SW],0xD0,0xD0,0xD0); addGPUTriangle(b,pb,ch[SW],0xD0D0D0);
addGPUTriangle(a,ch[NE],ch[NW],0xD0,0xD0,0xD0); addGPUTriangle(a,ch[NE],ch[NW],0xD0D0D0);
addGPUTriangle(b,ch[SW],ch[SE],0xD0,0xD0,0xD0); addGPUTriangle(b,ch[SW],ch[SE],0xD0D0D0);
} }
else { else {
addGPUTriangle(pa,a,ch[NE],0xD0,0xD0,0xD0); addGPUTriangle(pa,a,ch[NE],0xD0D0D0);
addGPUTriangle(b,pb,ch[SE],0xD0,0xD0,0xD0); addGPUTriangle(b,pb,ch[SE],0xD0D0D0);
} }
pa = a; pa = a;
pb = b; pb = b;
} }
addGPUTriangle(c[SE],pb,ch[SE],0xD0,0xD0,0xD0); addGPUTriangle(c[SE],pb,ch[SE],0xD0D0D0);
addGPUTriangle(c[NE],pa,ch[NE],0xD0,0xD0,0xD0); addGPUTriangle(c[NE],pa,ch[NE],0xD0D0D0);
} }

10
rules/batiment/batimentquadtoit.cpp
View File

@ -18,11 +18,11 @@ void BatimentQuadToit::triangulation() {
Vertex ce = c[SE] + (c[NE] - c[SE])/2 + Vertex(0,0,height); Vertex ce = c[SE] + (c[NE] - c[SE])/2 + Vertex(0,0,height);
Vertex cw = c[SW] + (c[NW] - c[SW])/2 + Vertex(0,0,height); Vertex cw = c[SW] + (c[NW] - c[SW])/2 + Vertex(0,0,height);
addGPUTriangle(c[NW],cw,c[SW],0xF1,0xE0,0xE0); addGPUTriangle(c[NW],cw,c[SW],0xF1E0E0);
addGPUTriangle(c[SE],ce,c[NE],0xF1,0xE0,0xE0); addGPUTriangle(c[SE],ce,c[NE],0xF1E0E0);
addGPUQuad(c[NE],c[NW],c[SW],c[SE],0xF1,0xE0,0xE0); //addGPUQuad(c[NE],c[NW],c[SW],c[SE],0xF1E0E0);
addGPUQuad(c[NE],c[NW],cw,ce,0xE0,0x20,0x00); addGPUQuad(c[NE],c[NW],cw,ce,0xE02000);
addGPUQuad(c[SW],c[SE],ce,cw,0xE0,0x20,0x00); addGPUQuad(c[SW],c[SE],ce,cw,0xE02000);
} }
} }

5
rules/batiment/batimenttri.cpp
View File

@ -43,8 +43,7 @@ void BatimentTri::triangulation() {
// float htoit = hashInRange(seed,2,minHeight/2,maxHeight/2); // float htoit = hashInRange(seed,2,minHeight/2,maxHeight/2);
Triangle ch = c + Vertex(0,0,h); Triangle ch = c + Vertex(0,0,h);
addGPUTriangle(c, 0xFF, 0xFF, 0x00); addGPUTriangle(ch, Couleurs::toit);
addGPUTriangle(ch, 0xFF, 0xFF, 0x00);
for (int i = 0; i < 3; i++) for (int i = 0; i < 3; i++)
addGPUQuad(c[LEFT+i], c[TOP+i], ch[TOP+i], ch[LEFT+i], 0xFF, 0xFF, 0x00); addGPUQuad(c[LEFT+i], c[TOP+i], ch[TOP+i], ch[LEFT+i], Couleurs::mur);
} }

36
rules/chose.cpp
View File

@ -20,33 +20,33 @@ bool Chose::merge() {
return true; return true;
} }
void Chose::addGPUTriangle(Vertex left, Vertex top, Vertex right, unsigned char r, unsigned char g, unsigned char b) { void Chose::addGPUTriangle(Vertex left, Vertex top, Vertex right, unsigned int rgb) {
triangles.push_back(new GPUTriangle(left, top, right, r, g, b)); triangles.push_back(new GPUTriangle(left, top, right, (rgb >> 16) & 0xff, (rgb >> 8) & 0xff, rgb & 0xff));
} }
void Chose::addGPUTriangle(Triangle t, unsigned char r, unsigned char g, unsigned char b) { void Chose::addGPUTriangle(Triangle t, unsigned int rgb) {
addGPUTriangle(t[LEFT], t[TOP], t[RIGHT], r, g, b); addGPUTriangle(t[LEFT], t[TOP], t[RIGHT], rgb);
} }
void Chose::addGPUQuad(Vertex ne, Vertex se, Vertex sw, Vertex nw, unsigned char r, unsigned char g, unsigned char b) { void Chose::addGPUQuad(Vertex ne, Vertex se, Vertex sw, Vertex nw, unsigned int rgb) {
this->addGPUTriangle(nw,ne,se,r,g,b); this->addGPUTriangle(nw, ne, se, rgb);
this->addGPUTriangle(se,sw,nw,r,g,b); this->addGPUTriangle(se, sw, nw, rgb);
} }
void Chose::addGPUQuad(Quad q, unsigned char r, unsigned char g, unsigned char b) { void Chose::addGPUQuad(Quad q, unsigned int rgb) {
addGPUQuad(q[NE], q[SE], q[SW], q[NW], r, g, b); addGPUQuad(q[NE], q[SE], q[SW], q[NW], rgb);
} }
void Chose::addGPUOcto(Vertex ne, Vertex se, Vertex sw, Vertex nw, void Chose::addGPUOcto(Vertex ne, Vertex se, Vertex sw, Vertex nw,
Vertex neh, Vertex seh, Vertex swh, Vertex nwh, unsigned char r, unsigned char g, unsigned char b) { Vertex neh, Vertex seh, Vertex swh, Vertex nwh, unsigned int rgb) {
addGPUOcto(Quad(ne,se,sw,nw), Quad(neh,seh,swh,nwh), r, g, b); addGPUOcto(Quad(ne,se,sw,nw), Quad(neh,seh,swh,nwh), rgb);
} }
void Chose::addGPUOcto(Quad q, Quad qh, unsigned char r, unsigned char g, unsigned char b) { void Chose::addGPUOcto(Quad q, Quad qh, unsigned int rgb) {
this->addGPUQuad(q[SE], q[NE], q[NW], q[SW], r, g, b); this->addGPUQuad(q[SE], q[NE], q[NW], q[SW], rgb);
this->addGPUQuad(qh[NE], qh[SE], qh[SW], qh[NW], r, g, b); this->addGPUQuad(qh[NE], qh[SE], qh[SW], qh[NW], rgb);
for (int i = 0; i < 4; i++) for (int i = 0; i < 4; i++)
this->addGPUQuad(q[NE+i], q[SE+i], qh[SE+i], qh[NE+i], r, g, b); this->addGPUQuad(q[NE+i], q[SE+i], qh[SE+i], qh[NE+i], rgb);
} }
void Chose::display() { void Chose::display() {
@ -152,10 +152,8 @@ void Chose::drawAABB() {
Vertex(lod.splitBox[1], lod.splitBox[2], lod.splitBox[5]), Vertex(lod.splitBox[1], lod.splitBox[2], lod.splitBox[5]),
Vertex(lod.splitBox[1], lod.splitBox[3], lod.splitBox[5]), Vertex(lod.splitBox[1], lod.splitBox[3], lod.splitBox[5]),
Vertex(lod.splitBox[0], lod.splitBox[3], lod.splitBox[5]), Vertex(lod.splitBox[0], lod.splitBox[3], lod.splitBox[5]),
hash2(seed, 42) & 255, hash2(seed, 42) & 0xffffff
hash2(seed, 43) & 255,
hash2(seed, 44) & 255
); );
} }
unsigned int Chose::initialSeed = random_seed(); unsigned int Chose::initialSeed = 187001748;//random_seed();

12
rules/chose.hh
View File

@ -62,14 +62,14 @@ class Chose {
} }
void addChild(Chose* c); void addChild(Chose* c);
void addGPUTriangle(Vertex left, Vertex top, Vertex right, unsigned char r, unsigned char g, unsigned char b); void addGPUTriangle(Vertex left, Vertex top, Vertex right, unsigned int rgb);
void addGPUTriangle(Triangle t, unsigned char r, unsigned char g, unsigned char b); void addGPUTriangle(Triangle t, unsigned int rgb);
void addGPUQuad(Vertex ne, Vertex se, Vertex sw, Vertex nw, unsigned char r, unsigned char g, unsigned char b); void addGPUQuad(Vertex ne, Vertex se, Vertex sw, Vertex nw, unsigned int rgb);
void addGPUQuad(Quad q, unsigned char r, unsigned char g, unsigned char b); void addGPUQuad(Quad q, unsigned int rgb);
void addGPUOcto(Vertex ne, Vertex se, Vertex sw, Vertex nw, void addGPUOcto(Vertex ne, Vertex se, Vertex sw, Vertex nw,
Vertex neh, Vertex seh, Vertex swh, Vertex nwh, Vertex neh, Vertex seh, Vertex swh, Vertex nwh,
unsigned char r, unsigned char g, unsigned char b); unsigned int rgb);
void addGPUOcto(Quad q, Quad qh, unsigned char r, unsigned char g, unsigned char b); void addGPUOcto(Quad q, Quad qh, unsigned int rgb);
}; };
#endif #endif