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 "rules/chose.hh"
#include "rules/architecture/couleurs.hh"
#include "rules/architecture/arche.hh"
#include "rules/architecture/toit.hh"
#include "rules/architecture/batiment.hh"
#include "rules/architecture/quartier.hh"
#include "rules/architecture/terrain.hh"
#include "rules/architecture/routetrottoir.hh"
#include "rules/architecture/terrain.hh"
#include "rules/architecture/toit.hh"
#include "rules/batiment/batimentquad.hh"
#include "rules/batiment/batimentquadmaison.hh"

2
main.cpp
View File

@ -10,7 +10,7 @@ int main() {
Vertex se(size, 0, 0);
Vertex sw(0, 0, 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->updateAABB();

2
rules/architecture/arche.cpp
View File

@ -17,7 +17,7 @@ bool ArcheQuad::split() {
void ArcheQuad::triangulation() {
Quad che = c.offsetNormal(f(end) * 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() {

5
rules/architecture/arche.hh
View File

@ -17,11 +17,6 @@ public:
float f(float x);
float ogive(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

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"
QuartierQuad_::QuartierQuad_(Quad _c) : Chose(), c(_c) {
QuartierQuad::QuartierQuad(Quad _c) : Chose(), c(_c) {
addEntropy(c);
}
void QuartierQuad_::getBoundingBoxPoints() {
void QuartierQuad::getBoundingBoxPoints() {
addBBPoints(c, 600); // TODO : factoriser cette longueur (hauteur max des bâtiments).
}
bool QuartierQuad_::split() {
bool QuartierQuad::split() {
bool small = c.minLength() < 3500;
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 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).
if (isConcave)
concave();
else if (nearConcave)
angleAngle();
else if (!small && !anglesOk && proba(seed, -2, 1, 2))
angleAngle();
else if (!small && !anglesOk)
@ -30,55 +32,59 @@ bool QuartierQuad_::split() {
return true;
}
void QuartierQuad_::triangulation() {
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, 0x36, 0x36, 0x36); // TODO : factoriser cette couleur (couleur de la route).
addGPUQuad(cih, 0xF1, 0xE0, 0xE0); // TODO : factoriser cette couleur (couleur des toits).
for (int i = 0; i < 4; i++)
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).
void QuartierQuad::triangulation() {
if (c.isConcave()) {
// TODO
Quad q = c << c.concaveCorner();
addGPUTriangle(Triangle(q[NE], q[SE], q[SW]), Couleurs::route);
addGPUTriangle(Triangle(q[SW], q[NW], q[NE]), Couleurs::route);
} 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() {
// TODO À vérifier.
Triangle t1(c[c.concaveCorner()], c[c.concaveCorner()+1], c[c.concaveCorner()+2]);
Triangle t2(c[c.concaveCorner()+2], c[c.concaveCorner()+3], c[c.concaveCorner()]);
addChild(new QuartierTri_(t1));
addChild(new QuartierTri_(t2));
void QuartierQuad::concave() {
Quad q = c << c.concaveCorner();
addChild(new QuartierTri(Triangle(q[NE], q[SE], q[SW])));
addChild(new QuartierTri(Triangle(q[SW], q[NW], q[NE])));
}
void QuartierQuad_::angleCote() {
void QuartierQuad::angleCote() {
Quad q = c << c.maxAngleCorner();
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);
Triangle ts(q[SE], s, q[NE]);
Triangle tw(q[NE], w, q[NW]);
if (ts.minAngle() > tw.minAngle()) {
addChild(new QuartierTri_(ts));
addChild(new QuartierQuad_(Quad(q[NE], s, q[SW], q[NW])));
addChild(new QuartierTri(ts));
addChild(new QuartierQuad(Quad(q[NE], s, q[SW], q[NW])));
} else {
addChild(new QuartierTri_(tw));
addChild(new QuartierQuad_(Quad(q[NE], q[SE], q[SW], w)));
addChild(new QuartierTri(tw));
addChild(new QuartierQuad(Quad(q[NE], q[SE], q[SW], w)));
}
}
void QuartierQuad_::angleAngle() {
void QuartierQuad::angleAngle() {
Quad q = c << c.maxAngleCorner();
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[NE], q[SE], q[SW])));
addChild(new QuartierTri(Triangle(q[SW], q[NW], q[NE])));
}
void QuartierQuad_::rect() {
void QuartierQuad::rect() {
Quad q = c << c.maxLengthSide();
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);
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[NE], q[SE], s, n)));
addChild(new QuartierQuad(Quad(q[SW], q[NW], n, s)));
}
void QuartierQuad_::carre() {
void QuartierQuad::carre() {
// TODO : insetProportionnal();
Vertex center = c.insetNESW(c.minLength() / 4.f).randomPoint(seed, 0);
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);
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.
Quad qtrottoir = c.insetNESW(250);
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);
}
void QuartierTri_::getBoundingBoxPoints() {
void QuartierTri::getBoundingBoxPoints() {
addBBPoints(c, 600); // TODO : factoriser cette longueur (hauteur max des bâtiments).
}
bool QuartierTri_::split() {
bool QuartierTri::split() {
bool small = c.minLength() < 5000;
bool big = c.maxLength() >= 10000;
float minAngle = c.minAngle();
@ -149,16 +155,16 @@ bool QuartierTri_::split() {
return true;
}
void QuartierTri_::triangulation() {
void QuartierTri::triangulation() {
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).
addGPUTriangle(c, 0x36, 0x36, 0x36); // TODO : factoriser cette couleur (couleur de la route).
addGPUTriangle(cih, 0xF1, 0xE0, 0xE0); // TODO : factoriser cette couleur (couleur des toits).
Triangle cih = ci.offsetNormal(600); // TODO : factoriser cette longueur (hauteur max des bâtiments).
addGPUTriangle(c, Couleurs::route);
addGPUTriangle(cih, Couleurs::toit);
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 : insetProportionnal();
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);
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();
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[LEFT], opposite, t[RIGHT])));
addChild(new QuartierTri(Triangle(t[TOP], opposite, t[LEFT])));
addChild(new QuartierTri(Triangle(t[LEFT], opposite, t[RIGHT])));
}
void QuartierTri_::trapeze() {
void QuartierTri::trapeze() {
Triangle t = c << c.minAngleCorner();
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);
addChild(new QuartierTri_(Triangle(base, t[TOP], left)));
addChild(new QuartierQuad_(Quad(left, t[TOP], t[RIGHT], base)));
addChild(new QuartierTri(Triangle(base, t[LEFT], left)));
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.
Triangle ttrottoir = c.insetLTR(250);
Triangle tinterieur = ttrottoir.insetLTR(140);

8
rules/architecture/quartier.hh
View File

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

8
rules/architecture/routetrottoir.cpp
View File

@ -13,9 +13,9 @@ void TrottoirQuad::triangulation() {
Quad ch = c.offsetNormal(height);
Quad bordureh = ch.inset(E,15);
addGPUQuad(c[NE], c[SE], ch[SE], ch[NE], 0xAA, 0xAA, 0xAA);
addGPUQuad(ch[NE], ch[SE], bordureh[SE], bordureh[NE], 0xAA, 0xAA, 0xAA);
addGPUQuad(bordureh, 0x66, 0x66, 0x66);
addGPUQuad(c[NE], c[SE], ch[SE], ch[NE], Couleurs::bordureTrottoir);
addGPUQuad(ch[NE], ch[SE], bordureh[SE], bordureh[NE], Couleurs::bordureTrottoir);
addGPUQuad(bordureh, Couleurs::trottoir);
}
RouteQuad::RouteQuad(Quad _c) : Chose(), c(_c) {
@ -30,5 +30,5 @@ void RouteQuad::getBoundingBoxPoints() {
}
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() {
addGPUQuad(c, 0x11, 0xaa, 0x22);
addGPUQuad(c, Couleurs::herbe);
}
TerrainTri::TerrainTri(Triangle _c) : Chose(), c(_c) {
@ -27,5 +27,5 @@ void TerrainTri::getBoundingBoxPoints() {
}
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);
Vertex center = qh.insetNESW(qh.minLength() / 3.f).randomPoint(seed, 0);
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() {
@ -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 centerE = Segment(e,w).randomPos(seed, 2, 0.6f, 0.8f);
Vertex centerW = Segment(e,w).randomPos(seed, 2, 0.2f, 0.4f);
addGPUTriangle(q[NE], centerE, q[SE], r, g, b);
addGPUTriangle(q[SW], centerW, q[NW], r, g, b);
addGPUQuad(q[SE], q[SW], centerW, centerE, r, g, b);
addGPUQuad(q[NW], q[NE], centerE, centerW, r, g, b);
addGPUTriangle(q[NE], centerE, q[SE], Couleurs::toit);
addGPUTriangle(q[SW], centerW, q[NW], Couleurs::toit);
addGPUQuad(q[SE], q[SW], centerW, centerE, Couleurs::toit);
addGPUQuad(q[NW], q[NE], centerE, centerW, Couleurs::toit);
}
void ToitQuad::deuxPointsVerticaux() {
@ -48,14 +48,14 @@ void ToitQuad::deuxPointsVerticaux() {
Quad qh = q.offsetNormal(height);
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);
addGPUTriangle(q[NE], e, q[SE], r, g, b); // TODO : devrait être couleur mur.
addGPUTriangle(q[SW], w, q[NW], r, g, b); // TODO : devrait être couleur mur.
addGPUQuad(q[SE], q[SW], w, e, r, g, b);
addGPUQuad(q[NW], q[NE], e, w, r, g, b);
addGPUTriangle(q[NE], e, q[SE], Couleurs::toit); // 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, Couleurs::toit);
addGPUQuad(q[NW], q[NE], e, w, Couleurs::toit);
}
void ToitQuad::plat() {
addGPUQuad(c, r, g, b);
addGPUQuad(c, Couleurs::toit);
}
ToitTri::ToitTri(Triangle _c, float _height) : Chose(), c(_c), height(_height) {
@ -82,35 +82,35 @@ void ToitTri::pointCentral() {
Triangle th = c.offsetNormal(height);
Vertex center = th.insetLTR(th.minLength() / 3.f).randomPoint(seed, 0);
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() {
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++)
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() {
// Rotation aléatoire du triangle
Triangle t = c >> (hash2(seed, 0) % 3);
Triangle th = t.offsetNormal(height);
addGPUTriangle(t[LEFT], th[TOP], t[RIGHT], r, g, b);
addGPUTriangle(t[TOP], th[TOP], t[LEFT], r, g, b);
addGPUTriangle(t[RIGHT], th[TOP], t[TOP], r, g, b);
addGPUTriangle(t[LEFT], th[TOP], t[RIGHT], Couleurs::toit);
addGPUTriangle(t[TOP], th[TOP], t[LEFT], Couleurs::toit);
addGPUTriangle(t[RIGHT], th[TOP], t[TOP], Couleurs::toit);
}
void ToitTri::deuxPointsVerticaux() {
// Rotation aléatoire du triangle
Triangle t = c >> (hash2(seed, 0) % 3);
Triangle th = t.offsetNormal(height);
addGPUTriangle(th[LEFT], t[TOP], th[RIGHT], r, g, b);
addGPUTriangle(t[TOP], th[LEFT], t[LEFT], r, g, b);
addGPUTriangle(t[RIGHT], th[RIGHT], t[TOP], r, g, b);
addGPUTriangle(th[LEFT], t[TOP], th[RIGHT], Couleurs::toit);
addGPUTriangle(t[TOP], th[LEFT], t[LEFT], Couleurs::toit);
addGPUTriangle(t[RIGHT], th[RIGHT], t[TOP], Couleurs::toit);
}
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 deuxPointsVerticaux();
void plat();
static const char r = 0xF1;
static const char g = 0xE0;
static const char b = 0xE0;
};
#endif

2
rules/batiment/batimentquad.cpp
View File

@ -26,5 +26,5 @@ void BatimentQuad::triangulation() {
float h = floatInRange(seed,1,minHeight,maxHeight);
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() {
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() {
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);
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++) {
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 qh = q + Vertex(0,0,h);
addGPUQuad(c,0x80,0x80,0x80);
addGPUOcto(q,qh,0xF1,0xE0,0xE0);
addGPUQuad(c,0x808080);
addGPUOcto(q,qh,Couleurs::mur);
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);
addGPUTriangle(qh[NW],cw,qh[SW],0xF1,0xE0,0xE0);
addGPUTriangle(qh[SE],ce,qh[NE],0xF1,0xE0,0xE0);
addGPUTriangle(qh[NW],cw,qh[SW],Couleurs::mur);
addGPUTriangle(qh[SE],ce,qh[NE],Couleurs::mur);
addGPUQuad(qh[NE],qh[NW],cw,ce,0xE0,0x20,0x00);
addGPUQuad(qh[SW],qh[SE],ce,cw,0xE0,0x20,0x00);
addGPUQuad(qh[NE],qh[NW],cw,ce,Couleurs::toit);
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() {
if(!window)
addGPUOcto(c, ch, 0xf1,0xe3,0xad);
addGPUOcto(c, ch, Couleurs::mur);
//else
//addGPUOcto(c, ch, 0xFF,0x10,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 n;
addGPUTriangle(c[SW],pb,ch[SW],0xD0,0xD0,0xD0);
addGPUTriangle(pa,c[NW],ch[NW],0xD0,0xD0,0xD0);
addGPUTriangle(c[SW],pb,ch[SW],0xD0D0D0);
addGPUTriangle(pa,c[NW],ch[NW],0xD0D0D0);
for(var=-1.7f, n=0; var <= 1.7f; var+=pas, n++) {
q = q.inset(W,n2);
a = q[NW] + 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) {
addGPUTriangle(pa,a,ch[NW],0xD0,0xD0,0xD0);
addGPUTriangle(b,pb,ch[SW],0xD0,0xD0,0xD0);
addGPUTriangle(pa,a,ch[NW],0xD0D0D0);
addGPUTriangle(b,pb,ch[SW],0xD0D0D0);
}
else if(n == middle) {
addGPUTriangle(pa,a,ch[NW],0xD0,0xD0,0xD0);
addGPUTriangle(b,pb,ch[SW],0xD0,0xD0,0xD0);
addGPUTriangle(a,ch[NE],ch[NW],0xD0,0xD0,0xD0);
addGPUTriangle(b,ch[SW],ch[SE],0xD0,0xD0,0xD0);
addGPUTriangle(pa,a,ch[NW],0xD0D0D0);
addGPUTriangle(b,pb,ch[SW],0xD0D0D0);
addGPUTriangle(a,ch[NE],ch[NW],0xD0D0D0);
addGPUTriangle(b,ch[SW],ch[SE],0xD0D0D0);
}
else {
addGPUTriangle(pa,a,ch[NE],0xD0,0xD0,0xD0);
addGPUTriangle(b,pb,ch[SE],0xD0,0xD0,0xD0);
addGPUTriangle(pa,a,ch[NE],0xD0D0D0);
addGPUTriangle(b,pb,ch[SE],0xD0D0D0);
}
pa = a;
pb = b;
}
addGPUTriangle(c[SE],pb,ch[SE],0xD0,0xD0,0xD0);
addGPUTriangle(c[NE],pa,ch[NE],0xD0,0xD0,0xD0);
addGPUTriangle(c[SE],pb,ch[SE],0xD0D0D0);
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 cw = c[SW] + (c[NW] - c[SW])/2 + Vertex(0,0,height);
addGPUTriangle(c[NW],cw,c[SW],0xF1,0xE0,0xE0);
addGPUTriangle(c[SE],ce,c[NE],0xF1,0xE0,0xE0);
addGPUTriangle(c[NW],cw,c[SW],0xF1E0E0);
addGPUTriangle(c[SE],ce,c[NE],0xF1E0E0);
addGPUQuad(c[NE],c[NW],c[SW],c[SE],0xF1,0xE0,0xE0);
addGPUQuad(c[NE],c[NW],cw,ce,0xE0,0x20,0x00);
addGPUQuad(c[SW],c[SE],ce,cw,0xE0,0x20,0x00);
//addGPUQuad(c[NE],c[NW],c[SW],c[SE],0xF1E0E0);
addGPUQuad(c[NE],c[NW],cw,ce,0xE02000);
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);
Triangle ch = c + Vertex(0,0,h);
addGPUTriangle(c, 0xFF, 0xFF, 0x00);
addGPUTriangle(ch, 0xFF, 0xFF, 0x00);
addGPUTriangle(ch, Couleurs::toit);
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;
}
void Chose::addGPUTriangle(Vertex left, Vertex top, Vertex right, unsigned char r, unsigned char g, unsigned char b) {
triangles.push_back(new GPUTriangle(left, top, right, r, g, b));
void Chose::addGPUTriangle(Vertex left, Vertex top, Vertex right, unsigned int rgb) {
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) {
addGPUTriangle(t[LEFT], t[TOP], t[RIGHT], r, g, b);
void Chose::addGPUTriangle(Triangle t, unsigned int rgb) {
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) {
this->addGPUTriangle(nw,ne,se,r,g,b);
this->addGPUTriangle(se,sw,nw,r,g,b);
void Chose::addGPUQuad(Vertex ne, Vertex se, Vertex sw, Vertex nw, unsigned int rgb) {
this->addGPUTriangle(nw, ne, se, rgb);
this->addGPUTriangle(se, sw, nw, rgb);
}
void Chose::addGPUQuad(Quad q, unsigned char r, unsigned char g, unsigned char b) {
addGPUQuad(q[NE], q[SE], q[SW], q[NW], r, g, b);
void Chose::addGPUQuad(Quad q, unsigned int rgb) {
addGPUQuad(q[NE], q[SE], q[SW], q[NW], rgb);
}
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) {
addGPUOcto(Quad(ne,se,sw,nw), Quad(neh,seh,swh,nwh), r, g, b);
Vertex neh, Vertex seh, Vertex swh, Vertex nwh, unsigned int rgb) {
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) {
this->addGPUQuad(q[SE], q[NE], q[NW], q[SW], r, g, b);
this->addGPUQuad(qh[NE], qh[SE], qh[SW], qh[NW], r, g, b);
void Chose::addGPUOcto(Quad q, Quad qh, unsigned int rgb) {
this->addGPUQuad(q[SE], q[NE], q[NW], q[SW], rgb);
this->addGPUQuad(qh[NE], qh[SE], qh[SW], qh[NW], rgb);
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() {
@ -152,10 +152,8 @@ void Chose::drawAABB() {
Vertex(lod.splitBox[1], lod.splitBox[2], lod.splitBox[5]),
Vertex(lod.splitBox[1], lod.splitBox[3], lod.splitBox[5]),
Vertex(lod.splitBox[0], lod.splitBox[3], lod.splitBox[5]),
hash2(seed, 42) & 255,
hash2(seed, 43) & 255,
hash2(seed, 44) & 255
hash2(seed, 42) & 0xffffff
);
}
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 addGPUTriangle(Vertex left, Vertex top, Vertex right, unsigned char r, unsigned char g, unsigned char b);
void addGPUTriangle(Triangle t, unsigned char r, unsigned char g, unsigned char b);
void addGPUQuad(Vertex ne, Vertex se, Vertex sw, Vertex nw, unsigned char r, unsigned char g, unsigned char b);
void addGPUQuad(Quad q, 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 int rgb);
void addGPUQuad(Vertex ne, Vertex se, Vertex sw, Vertex nw, unsigned int rgb);
void addGPUQuad(Quad q, unsigned int rgb);
void 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);
void addGPUOcto(Quad q, Quad qh, unsigned char r, unsigned char g, unsigned char b);
unsigned int rgb);
void addGPUOcto(Quad q, Quad qh, unsigned int rgb);
};
#endif