commit e348a945d3fb0b9cbae49eab8562c1c8becd8443
parent c06923105de4be082c7f9d4a2e73bc435811a1fd
Author: Georges Dupéron <jahvascriptmaniac+github@free.fr>
Date: Thu, 12 Jan 2012 17:16:34 +0100
Ajout de architecture/quartier.cpp .
Diffstat:
12 files changed, 352 insertions(+), 71 deletions(-)
diff --git a/all_includes.hh b/all_includes.hh
@@ -36,6 +36,7 @@ class Chose;
#include "rules/architecture/arche.hh"
#include "rules/architecture/toit.hh"
+#include "rules/architecture/quartier.hh"
#include "rules/batiment/batimentquad.hh"
#include "rules/batiment/batimentquadmaison.hh"
diff --git a/geometry/directions.hh b/geometry/directions.hh
@@ -111,22 +111,6 @@ const CoteTriangle LEFTSIDE = CoteTriangle(0);
const CoteTriangle RIGHTSIDE = CoteTriangle(1);
const CoteTriangle BASE = CoteTriangle(2);
-/*
-enum SommetTriangle {
- LEFT = 0,
- TOP = 1,
- RIGHT = 2
-};
-
-inline SommetTriangle operator+(SommetTriangle c, int i) {
- return SommetTriangle((((int(c) + int(i)) % 3 ) + 3) % 3);
-}
-
-inline SommetTriangle operator-(SommetTriangle c, int i) {
- return SommetTriangle((((int(c) - int(i)) % 3 ) + 3) % 3);
-}
-*/
-
// Plus ou moins la même chose que CoteTriangle.
class SommetTriangle {
private:
diff --git a/geometry/quad.cpp b/geometry/quad.cpp
@@ -93,20 +93,46 @@ float Quad::maxLength() const {
return std::max(maxLengthNS(), maxLengthEW());
}
+float Quad::angle(Coin corner) const {
+ return Triangle(c[NW+corner], c[NE+corner], c[SE+corner]).angle();
+}
+
float Quad::minAngle() const {
- float a = 370; // > 360.
- for (int i = 0; i < 4; i++) {
- a = std::min(a, Triangle(c[NE+i], c[SE+i], c[SW+i]).angle());
- }
- return a;
+ float ane = angle(NE);
+ float ase = angle(SE);
+ float asw = angle(SW);
+ float anw = 2*Angle::Pi - (ane + ase + asw);
+ return std::min(std::min(ane, ase), std::min(asw, anw));
}
float Quad::maxAngle() const {
- float a = 0;
- for (int i = 0; i < 4; i++) {
- a = std::max(a, Triangle(c[NE+i], c[SE+i], c[SW+i]).angle());
- }
- return a;
+ float ane = angle(NE);
+ float ase = angle(SE);
+ float asw = angle(SW);
+ float anw = 2*Angle::Pi - (ane + ase + asw);
+ return std::max(std::max(ane, ase), std::max(asw, anw));
+}
+
+Coin Quad::minAngleCorner() const {
+ float ane = angle(NE);
+ float ase = angle(SE);
+ float asw = angle(SW);
+ float anw = 2*Angle::Pi - (ane + ase + asw);
+ if (ane < ase && ane < asw && ane < anw) return NE;
+ else if (ase < asw && ase < anw) return SE;
+ else if (asw < anw) return SW;
+ else return NW;
+}
+
+Coin Quad::maxAngleCorner() const {
+ float ane = angle(NE);
+ float ase = angle(SE);
+ float asw = angle(SW);
+ float anw = 2*Angle::Pi - (ane + ase + asw);
+ if (ane > ase && ane > asw && ane > anw) return NE;
+ else if (ase > asw && ase > anw) return SE;
+ else if (asw > anw) return SW;
+ else return NW;
}
Quad operator+(const Quad& q, const Vertex& v) {
diff --git a/geometry/quad.hh b/geometry/quad.hh
@@ -35,8 +35,11 @@ class Quad {
float maxLengthEW() const;
float minLength() const;
float maxLength() const;
+ float angle(Coin corner) const;
float minAngle() const;
float maxAngle() const;
+ Coin minAngleCorner() const;
+ Coin maxAngleCorner() const;
Vertex randomPoint(int seed, int n) const;
float surface() const;
//void cutCornerCorner(Coin from) const;
diff --git a/geometry/triangle.cpp b/geometry/triangle.cpp
@@ -28,6 +28,24 @@ float Triangle::maxAngle() const {
return std::max(std::max(al, at), ar);
}
+SommetTriangle Triangle::maxAngleCorner() const {
+ float at = angle();
+ float ar = Triangle(c[TOP],c[RIGHT],c[LEFT]).angle();
+ float al = Angle::Pi - at - ar;
+ if (al > at && al > ar) return LEFT;
+ else if (at > ar) return TOP;
+ else return RIGHT;
+}
+
+SommetTriangle Triangle::minAngleCorner() const {
+ float at = angle();
+ float ar = Triangle(c[TOP],c[RIGHT],c[LEFT]).angle();
+ float al = Angle::Pi - at - ar;
+ if (al < at && al < ar) return LEFT;
+ else if (at < ar) return TOP;
+ else return RIGHT;
+}
+
float Triangle::minLength() const {
return std::min(std::min((c[LEFT] - c[TOP]).norm(), (c[TOP] - c[RIGHT]).norm()), (c[RIGHT] - c[LEFT]).norm());
}
diff --git a/geometry/triangle.hh b/geometry/triangle.hh
@@ -24,9 +24,11 @@ public :
}
friend Triangle operator+(const Triangle& t, const Vertex& v);
float cosAngle() const; // cosinus de l'angle en c[1].
- float angle() const; // angle en c[1], en degrés. TODO : le calcul ne donne que des angles entre 0 et 180 !
+ float angle() const; // angle en c[TOP], en degrés.
float minAngle() const; // angle minimum du triangle (en LEFT, TOP ou RIGHT).
float maxAngle() const; // angle maximum du triangle (en LEFT, TOP ou RIGHT).
+ SommetTriangle minAngleCorner() const;
+ SommetTriangle maxAngleCorner() const;
float minLength() const;
float maxLength() const;
float surface() const;
diff --git a/rules/architecture/arche.cpp b/rules/architecture/arche.cpp
@@ -32,12 +32,10 @@ float ArcheQuad::f(float x) {
}
}
-// Fonction fausse
float ArcheQuad::ogive(float x) {
return sin(acos(abs(x / 2.f) + 1.f/2.f));
}
-// Fonction fausse
float ArcheQuad::berceau(float x) {
return sin(acos(x));
}
diff --git a/rules/architecture/arche.hh b/rules/architecture/arche.hh
@@ -19,9 +19,9 @@ public:
float berceau(float x);
private:
// TODO : couleur de l'arche
- static const char r = 0xF1;
- static const char g = 0xE0;
- static const char b = 0xE0;
+ 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
diff --git a/rules/architecture/quartier.cpp b/rules/architecture/quartier.cpp
@@ -0,0 +1,214 @@
+#include "all_includes.hh"
+
+QuartierQuad_::QuartierQuad_(Quad _c) : c(_c) {
+ addEntropy(c);
+}
+
+void QuartierQuad_::getBoundingBoxPoints() {
+ addBBPoints(c, 6000); // TODO : factoriser cette longueur (hauteur max des bâtiments).
+}
+
+bool QuartierQuad_::split() {
+ bool small = c.minLength() < 3500;
+ bool big = c.maxLength() >= 6000;
+ bool isConcave = 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 (!big && proba(seed, -1, 1, 20))
+ batiments();
+ else if (!small && !anglesOk)
+ angleAngle(); // TODO
+ else if (!small && tooWideY)
+ rect(); // TODO : Quad(c[NW], c[NE], c[SE], c[SW])
+ else if (!small && tooWideX)
+ rect(); // TODO : fusion avec ci-dessus
+ else if (!small)
+ carre();
+ else
+ batiments();
+ return true;
+}
+
+void QuartierQuad_::triangulation() {
+ Quad ci = c.insetNESW(250 + 140); // TODO : factoriser cette longueur (largeur route + largeur trottoir).
+ Quad cih = c.offsetNormal(6000); // 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_::concave() {
+ // TODO
+}
+
+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])));
+ } else {
+ addChild(new QuartierTri_(tw));
+ addChild(new QuartierQuad_(Quad(q[NE], q[SE], q[SW], w)));
+ }
+}
+
+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])));
+}
+
+void QuartierQuad_::rect() {
+ Vertex n = Segment(c[NW], c[NE]).randomPos(seed, 0, 1.f/3.f, 2.f/3.f);
+ Vertex s = Segment(c[SE], c[SW]).randomPos(seed, 1, 1.f/3.f, 2.f/3.f);
+
+ addChild(new QuartierQuad_(Quad(c[NE], c[SE], s, n)));
+ addChild(new QuartierQuad_(Quad(c[SW], c[NW], n, s)));
+}
+
+void QuartierQuad_::carre() {
+ // TODO : insetProportionnal();
+ Vertex center = c.insetNESW(c.minLength() / 4.f).randomPoint(seed, 0);
+ Vertex middle[4];
+ for (int i = 0; i < 4; i++)
+ 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])));
+}
+
+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);
+ Quad qbatiments = qinterieur.offsetNormal(hauteurTrottoir);
+
+ for (int i = 0; i < 4; i++) {
+ addChild(new RouteQuadChaussee(Quad(c[NE+i],c[SE+i],qtrottoir[SE+i],qtrottoir[NE+i])));
+ addChild(new TrottoirQuadNormal(Quad(qtrottoir[NE+i],qtrottoir[SE+i],qinterieur[SE+i],qinterieur[NE+i]),hauteurTrottoir));
+ }
+
+ // TODO :
+
+ bool small = c.minLength() < 2500;
+ bool big = c.maxLength() >= 5000;
+ bool anglesAcceptable = c.minAngle() > Angle::d2r(90-60) && c.maxAngle() < Angle::d2r(90+60);
+
+ if (!big && proba(seed, 0, 1, 20)) {
+ addChild(new TerrainQuadHerbe(qbatiments));
+ } else if (small && anglesAcceptable) {
+ addChild(new BatimentQuad(qbatiments));
+ } else {
+ addChild(new TerrainQuadHerbe(qbatiments));
+ }
+}
+
+QuartierTri_::QuartierTri_(Triangle _c) : c(_c) {
+ addEntropy(c);
+}
+
+void QuartierTri_::getBoundingBoxPoints() {
+ addBBPoints(c, 6000); // TODO : factoriser cette longueur (hauteur max des bâtiments).
+}
+
+bool QuartierTri_::split() {
+ bool small = c.minLength() < 5000;
+ bool big = c.maxLength() >= 10000;
+ float minAngle = c.minAngle();
+ float maxAngle = c.maxAngle();
+ bool equilateral = maxAngle < Angle::d2r(60+15) && minAngle > Angle::d2r(60-15);
+ bool angleObtus = maxAngle > Angle::d2r(120);
+ bool angleAigu = minAngle < Angle::d2r(30);
+ bool anglesAcceptable = !angleAigu && !angleObtus;
+ if (!big && proba(seed, -1, 1, 20)) {
+ batiments(); // TODO : RouteTrottoirTri(c);
+ } else if (big && anglesAcceptable) {
+ switch (hash2(seed, -2) % 3) {
+ case 0: centre(); break;
+ case 1: hauteur(); break;
+ case 2:
+ default: trapeze(); break;
+ }
+ } else if (!small && equilateral) {
+ centre();
+ } else if (!small && angleObtus) {
+ hauteur();
+ } else if (!small) {
+ trapeze();
+ } else {
+ batiments();
+ }
+ return true;
+}
+
+void QuartierTri_::triangulation() {
+ Triangle ci = c.insetLTR(250 + 140); // TODO : factoriser cette longueur (largeur route + largeur trottoir).
+ Triangle cih = c.offsetNormal(6000); // 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).
+ 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).
+}
+
+void QuartierTri_::centre() {
+ // TODO : maxLength / 6 au lieu de 1000
+ // TODO : insetProportionnal();
+ Vertex center = c.insetLTR(c.maxLength() / 6).randomPoint(seed, 0);
+ Vertex edge[3];
+ for (int i = 0; i < 3; i++)
+ 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])));
+}
+
+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])));
+}
+
+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)));
+}
+
+void QuartierTri_::batiments() {
+ 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);
+ Triangle tbatiments = tinterieur.offsetNormal(hauteurTrottoir);
+
+ for (int i = 0; i < 3; i++) {
+ addChild(new RouteQuadChaussee(Quad(c[LEFT+i],c[TOP+i],ttrottoir[TOP+i],ttrottoir[LEFT+i])));
+ addChild(new TrottoirQuadNormal(Quad(ttrottoir[LEFT+i],ttrottoir[TOP+i],tinterieur[TOP+i],tinterieur[LEFT+i]),hauteurTrottoir));
+ }
+
+ // TODO :
+
+ bool small = tbatiments.minLength() < 3000;
+ bool big = tbatiments.maxLength() >= 5000;
+ bool anglesAcceptable = tbatiments.minAngle() > Angle::d2r(30) && tbatiments.maxAngle() < Angle::d2r(120);
+
+ if (!big && proba(seed, 0, 1, 20)) {
+ addChild(new TerrainTriHerbe(tbatiments));
+ } else if (small && anglesAcceptable) {
+ addChild(new BatimentTri(tbatiments));
+ } else {
+ addChild(new TerrainTriHerbe(tbatiments));
+ }
+}
diff --git a/rules/architecture/quartier.hh b/rules/architecture/quartier.hh
@@ -0,0 +1,38 @@
+#ifndef _RULES_ARCHITECTURE_QUARTIER_HH_
+#define _RULES_ARCHITECTURE_QUARTIER_HH_
+
+#include "all_includes.hh"
+
+class QuartierQuad_: public Chose {
+private:
+ Quad c;
+public:
+ QuartierQuad_(Quad _c);
+ virtual void getBoundingBoxPoints();
+ virtual bool split();
+ virtual void triangulation();
+private:
+ void concave();
+ void angleAngle();
+ void angleCote();
+ void rect();
+ void carre();
+ void batiments();
+};
+
+class QuartierTri_: public Chose {
+private:
+ Triangle c;
+public:
+ QuartierTri_(Triangle _c);
+ virtual void getBoundingBoxPoints();
+ virtual bool split();
+ virtual void triangulation();
+private:
+ void centre();
+ void hauteur();
+ void trapeze();
+ void batiments();
+};
+
+#endif
diff --git a/rules/architecture/toit.cpp b/rules/architecture/toit.cpp
@@ -1,6 +1,6 @@
#include "all_includes.hh"
-// TODO : les x.insetNESW_LTR(x.minLength() / 3.f) sont faux (on risque d'avoir un triangle plus petit qu'1/3), il faudrait une fonction inset qui prend un float entre 0 et 1.
+// TODO : les x.insetNESW_LTR(x.minLength() / 3.f) sont faux (on risque d'avoir un triangle plus petit qu'⅓), il faudrait une fonction inset qui prend un float entre 0 et 1.
ToitQuad::ToitQuad(Quad _c, float _height) : Chose(), c(_c), height(_height) {
addEntropy(c);
@@ -15,7 +15,7 @@ void ToitQuad::triangulation() {
switch (hash2(seed, -1) % 4) {
case 0: pointCentral(); break;
case 1: deuxPoints(); break;
- case 2: deuxPointsVerticaux();
+ case 2: deuxPointsVerticaux(); break;
case 3:
default: plat(); break;
}
diff --git a/tiles.md b/tiles.md
@@ -1,44 +1,41 @@
-Rules
-=====
+Déjà fait
+=========
+
+* toit
+ * quad : point central, deux points, deux points verticalement au-dessus des murs, plat.
+ * tri : point central, trois points, un points verticalement au-dessus des murs, deux points verticaux, plat.
+* arche
+ * en berceau
+ * d'ogive
+* quartier
+ * quad : concave, angleAngle angleCote, rectangle, carre, (contient route + trottoir)
+ * tri : centre, hauteur, trapeze, batiments (contient route + trottoir)
+
+À faire
+=======
-* chose
* batiment
- * batimentquad (sorte de factory interne, fait un addChild : trottoirs (chosit le bon type), jardin (choisir le bon type, batimentquadmaison ou batimentquadimmeuble ou …)
- * batimentquadmaison
- * batimentquadimmeuble
- * etagequad (factory, représente un étage d'une maison ou d'un immeuble par ex).
- * piecequad (factory, représente une pièce d'un étage)
- * ouverturequad (factory, paramètre décide si porte ou fenêtre, génère 2 ou 3 modèles de portes ou fenêtre)
- * pareil pour les tri et penta
- * ponts, ponts avec maison au-dessus, …
+ * jardin
+ * cour intérieure
+ * 1 étage, 2 étages, immeuble
+ * étages
+ * découpage en pièces
+ * position des portes, fenêtres, escaliers
* mobilier (intérieur et extérieur)
+ * murs
+ * portes
+ * fenêtres
* escalier
* table
- * statue
+ * chaises
* banc
-* quartier
- * quartierquad (factory)
- * quartierquadangle
- * quartierquadcarre
- * quartierquadrect
- * quartiertri (factory)
- * quartiertrihauteur (coupe le triangle selon sa hauteur)
- * quartiertriverscarre (coupe un coin du triangle pour en faire un carré)
- * quartiertriverspenta (coupe un coin du triangle pour en faire un pentagone)
- * quartierpenta (factory)
- * quelques motifs quartierpenta*
- * quelques motifs qui prévoient des ponts
-* route
- * routequad (factory, paramètre indique si l'on veut un carrefour ou une chaussee ou …)
- * routequadcarrefour
- * routequadchaussee
- * routequadparking
- * trottoirquad (factory, paramètre indique s'il faut un bateau, …)
- * trottoirquadnormal
- * trottoirquadbas (la partie basse du bateau)
- * trottoirquadpente (la pente du bateau)
- * trottoirquadbateau (se subdivise en 3 trottoirquad* : pente + bas + pente)
- * un motif pour faire une place
+ * au moins une statue, fontaine ou autre.
+* quartiers spéciaux
+ * longue route bordée de deux enfilades de maisons (prévoir la place pour un / des bâtiment(s) avec arche dans le sens de la rue).
+ * longue enfilade de maisons bordée de deux routes (prévoir la place pour un / des bâtiment(s) avec arche qui fait un raccourci pour ne pas faire tout le tour).
+ * place (polygone de route d'une couleur différente, avec possiblement un petit bâtiment au milieu).
+ * canaux + ponts + bâtiment(s) avec arche au-dessus.
+* route + trottoir
* terrain
- * terrainquadherbe
- * d'autres terrains…
+ * herbe
+ * mettre un peu de relief dans l'herbe
