subdivision des murs. (bug)

rules/architecture/etage.cpp

@@ -0,0 +1,39 @@
+#include "all_includes.hh"
+
+EtageQuad::EtageQuad(Quad _c, Quad _ch, bool _we, bool _ws, bool _ww, bool _wn)
+        : Chose(), c(_c), ch(_ch), we(_we), ws(_ws), ww(_ww), wn(_wn) {
+	addEntropy(c);
+	addEntropy(ch);
+}
+
+void EtageQuad::getBoundingBoxPoints() {
+	addBBPoints(c);
+	addBBPoints(ch);
+}
+
+bool EtageQuad::split() {
+    Quad me = c.insetOpp(E,28);
+    Quad ms = c.inset(E,28).inset(W,28).insetOpp(S,28);
+    Quad mw = c.insetOpp(W,28);
+    Quad mn = c.inset(E,28).inset(W,28).insetOpp(N,28);
+    Quad meh = ch.insetOpp(E,28);
+    Quad msh = ch.inset(E,28).inset(W,28).insetOpp(S,28);
+    Quad mwh = ch.insetOpp(W,28);
+    Quad mnh = ch.inset(E,28).inset(W,28).insetOpp(N,28);
+
+    MurQuad *mme = new MurQuad(me << 1,meh << 1,we);
+    MurQuad *mmn = new MurQuad(mn,mnh,wn);
+    MurQuad *mmw = new MurQuad(mw >> 1,mwh >> 1,ww);
+    MurQuad *mms = new MurQuad(ms >> 2,msh >> 2,ws);
+mmw=mmw;
+mms=mms;
+    addChild(mme);
+    //addChild(mmw);
+    addChild(mmn);
+    //addChild(mms);
+    return true;
+}
+
+void EtageQuad::triangulation() {
+    addGPUOcto(c,ch, 0xF1E0E0);
+}

rules/architecture/etage.hh

@@ -0,0 +1,20 @@
+#ifndef _RULES_BATIMENT_EtageQuad_HH_
+#define _RULES_BATIMENT_EtageQuad_HH_
+
+#include "all_includes.hh"
+
+
+class EtageQuad : public Chose {
+    private :
+	Quad c;
+	Quad ch;
+	bool we, ws, ww, wn;
+
+    public :
+	EtageQuad(Quad c, Quad ch, bool we=true, bool ws=true, bool ww=true, bool wn=true);
+	virtual bool split();
+	virtual void triangulation();
+	virtual void getBoundingBoxPoints();
+};
+
+#endif

rules/architecture/mur.cpp

@@ -0,0 +1,75 @@
+#include "all_includes.hh"
+
+MurQuad::MurQuad(Quad _c, Quad _ch, bool _window) : Chose(), c(_c), ch(_ch), window(_window) {
+	addEntropy(c);
+	addEntropy(ch);
+	if(_window)
+        setWindow();
+}
+
+void MurQuad::getBoundingBoxPoints() {
+	addBBPoints(c);
+	addBBPoints(ch);
+}
+
+void MurQuad::setWindow() {
+    Quad q = Quad(ch[NE],c[NE],c[NW],ch[NW]);
+    int lr = (q.length(S) - 120)/2;
+
+    Quad wFront = q.insetNESW(40,lr,120,lr);
+    Quad wBack = wFront.offsetNormal(28);
+    windowPos = Quad(wFront[SE],wBack[SE],wBack[SW],wFront[SW]);
+    windowPosh = Quad(wFront[NE],wBack[NE],wBack[NW],wFront[NW]);
+
+//addGPUQuad(q,0xFFFF00);
+//addGPUQuad(ch,0xFFFF00);
+//addGPUQuad(windowPos,0xFFFF00);
+}
+
+bool MurQuad::split() {
+    if(!window)
+        return false;
+
+    /*if(c.maxLengthNS() < c.maxLengthEW()) {
+        c = c >> 1;
+        ch = ch >> 1;
+    }*/
+    float length = c.maxLengthNS();
+
+    if(length > 500) {
+//addGPUTriangle(c[NW],c[NE],c[SE],0xFF0000);
+        Quad qa = c.insetOpp(W,length/2);
+        Quad qb = c.insetOpp(E,length-(length/2));
+        Quad qah = ch.insetOpp(W,length/2);
+        Quad qbh = ch.insetOpp(E,length-(length/2));
+
+addGPUQuad(qa,0x0000FF);
+addGPUQuad(qb,0x00FF00);
+addGPUQuad(qah,0x0000FF);
+addGPUQuad(qbh,0x00FF00);
+//addGPUQuad(qa,0xFFFF00);
+        //addChild(new MurQuad(qa,qah,window));
+        //addChild(new MurQuad(qb,qbh,window));
+    } else {
+        Quad right = Quad(windowPos[NW],windowPos[SW],c[SW],c[NW]);
+        Quad righth = Quad(windowPosh[NW],windowPosh[SW],ch[SW],ch[NW]);
+        Quad left = Quad(c[NE],c[SE],windowPos[SE],windowPos[NE]);
+        Quad lefth = Quad(ch[NE],ch[SE],windowPosh[SE],windowPosh[NE]);
+        Quad top = Quad(windowPosh[NE],windowPosh[NW],windowPosh[SW],windowPosh[SE]);
+
+        addChild(new MurQuad(c,windowPos));
+        addChild(new MurQuad(windowPosh,ch));
+        addChild(new MurQuad(left,lefth));
+        addChild(new MurQuad(right,righth));
+    }
+
+    return true;
+}
+
+void MurQuad::triangulation() {
+    if(!window)
+        addGPUOcto(c, ch, Couleurs::mur);
+    //else
+        //addGPUOcto(c, ch, 0xFF,0x10,0x00);
+        //addGPUQuad(windowPosh,0xFF,0xFF,0x00);
+}

rules/architecture/mur.hh

@@ -0,0 +1,24 @@
+#ifndef _RULES_BATIMENT_Mur_HH_
+#define _RULES_BATIMENT_Mur_HH_
+
+#include "all_includes.hh"
+
+class MurQuad: public Chose {
+    private :
+	Quad c;
+	Quad ch;
+	bool window;        // Contient une fenêtre ou non.
+	Quad windowPos;
+	Quad windowPosh;
+
+    public :
+
+	MurQuad(Quad c, Quad ch, bool _windows=false);
+	virtual void triangulation();
+	virtual bool split();
+	virtual void getBoundingBoxPoints();
+	void setWindow();
+};
+
+#endif
+