void LandQuad::creationQuartier()
{
Vector::setCol(COL_ROUTE1,COL_ROUTE2,COL_ROUTE3);
PrismQuad(Quadrangle(p[0],p[1],p[2],p[3]),0.10*UNITE).Render();
Vector::setColDefaut();
double tShrink = 7.5*UNITE; // largeur de 15m (au total, donc 7.5m de chaque côté depuis le milieu de la route)
Quadrangle q=Quadrangle(p[0],p[1],p[2],p[3]).Shrink(tShrink,tShrink,tShrink,tShrink);
BlockQuad(q.getVectors(0), q.getVectors(1), q.getVectors(2), q.getVectors(3),centres);
}
/*!
\brief Create a quadrangular block.
\param a,b,c,d End vertices of the parcel.
*/
BlockQuad::BlockQuad(const Vector& _a,const Vector& _b,const Vector& _c,const Vector& _d,const std::vector<Centre>&_centres): Quadrangle(_a,_b,_c,_d)
{
// hauteur de 10 mètres pour le lampadaire (5 unités)
Mobilier(7*UNITE,50*UNITE,0.3*UNITE).creerLampadaires(Quadrangle(_a,_b,_c,_d)); // d a 10 pour le moment mais il faudra le mettre à 25 (cad tous les 50m) une fois les vrais quartiers définis
// création du trottoir
Vector::setCol(COL_TROTT1,COL_TROTT2,COL_TROTT3);
PrismQuad(Quadrangle(_a,_b,_c,_d),0.30*UNITE).Render(); // hauteur de 20 cm
Vector::setColDefaut();
double tShrink = 4* UNITE; // 4 m
Quadrangle q=Quadrangle(_a,_b,_c,_d).Shrink(tShrink,tShrink,tShrink,tShrink);
Quartier::choixQuartier(q,_centres);
}
RDC::RDC(const Vec3<float>& a, const Vec3<float>& b, const Vec3<float>& c, const Vec3<float>& d, const float& _h,const float& _dif,const int& _type)
{
q = Quadrangle(a, b, c, d);
h = _h;
dif = _dif;
type = _type;
}
void Batiment::creerBordureToit(const bool& toitParDefaut)
{
double largeurBord = (double) UNITE*0.2;
double hauteurBord = (double) UNITE;
hauteurBord *= toitParDefaut?0.5:0.2;
double air = Quadrangle(listePoints[0],listePoints[1],listePoints[2],listePoints[3]).Area();
bool airMini = air > 8*(largeurBord*largeurBord); //2*le minimum
if(airMini)
{
for(unsigned int i = 0; i < 4 && airMin; i++)
{
Vector a(listePoints[i%4]);
Vector b(listePoints[(i+1)%4]);
Vector pt1, pt2, pt3, pt4;
Vector ab = Vector(b-a);
double angle = ( atan2(ab[1],ab[0]) + (M_PI/2) )* (180/M_PI);
double plusX = largeurBord*cos(angle*M_PI/180);
double plusY = largeurBord*sin(angle*M_PI/180);
pt1 = Vector(a[0], a[1], a[2]);
pt2 = Vector(b[0], b[1], b[2]);
pt3 = Vector(b[0] + plusX, b[1] + plusY, b[2]);
pt4 = Vector(a[0] + plusX, a[1] + plusY, a[2]);
Vector::setCol(125,125,125);
PrismQuad(pt1, pt2, pt3, pt4, hauteurBord).Render();
Vector::setColDefaut();
}
}
}
/*!
\brief Shrinks the quadrangle by a given orthogonal offset for every edge.
*/
Quadrangle Quadrangle::Shrink(const double& ab,const double& bc, const double& cd, const double& da)
{
Vector sa = p[0]-Normalized((p[1]-p[0])/Vector(0,0,1))*ab;
Vector sb = p[1]-Normalized((p[2]-p[1])/Vector(0,0,1))*bc;
Vector sc = p[2]-Normalized((p[3]-p[2])/Vector(0,0,1))*cd;
Vector sd = p[3]-Normalized((p[0]-p[3])/Vector(0,0,1))*da;
return Quadrangle(
Intersection(sa,sa+(p[1]-p[0]),sb,sb+(p[2]-p[1])),
Intersection(sb,sb+(p[2]-p[1]),sc,sc+(p[3]-p[2])),
Intersection(sc,sc+(p[3]-p[2]),sd,sd+(p[0]-p[3])),
Intersection(sd,sd+(p[0]-p[3]),sa,sa+(p[1]-p[0])));
}
Quadrangle Quadrangle::GenerateRectangle(Vec3<float> p0, Vec3<float> p1, float width, float height)
{
if (Vec3<float>::dotProduct(p1, p1) > Vec3<float>::dotProduct(p0, p0))
{
Vec3<float> tmp(p0);
p0 = p1;
p1 = p0;
}
//Vec3<float> min = p0.min(p1);
//Vec3<float> max = p0.max(p1);
//return Quadrangle(p0, Vec3<float>(min.x, max.y, 0.f), p1, Vec3<float>(max.x, min.y, 0.f));//, p1 + dirP4 * width, p0 + dirP4 * width);
Vec3<float> p0p1 = p1 - p0;
p1 = p0 + p0p1.normalized() * height;
p0p1 = p1 - p0;
/*Vec3<float> tmp2 = tmp;*/
Vec3<float> tmp3 = Vec3<float>(p0p1.y, -p0p1.x, 0.f).normalized() * width;
return Quadrangle(p0, p1, tmp3 + p0p1 + p0, tmp3 + p0);
}
/*
\brief Subdivide a quadrangular land parcel.
*/
void LandQuad::Subdivide()
{
// Area
double area=Area();
// Compute index of smallest edge
double ab=Norm(p[1]-p[0]);
double bc=Norm(p[2]-p[1]);
double cd=Norm(p[3]-p[2]);
double da=Norm(p[0]-p[3]);
double random = ((double)(rand()%3 + 3) / 10); // rapport de division du côté
//std::cout << "ab = " << ab << std::endl;
//std::cout << "bc = " << bc << std::endl << std::endl;
int partage = rand()%2;
// première subdivision large
if( ab > 150*UNITE && da > 150*UNITE)
{
if(partage)
{
Vector v1(0,0,0); v1.setDiffxy(p[0],p[1],random * ab);
Vector v2(0,0,0); v2.setDiffxy(p[3],p[2],random * cd);
LandQuad(p[0],v1,v2,p[3],centres).Subdivide();
LandQuad(v1,p[1],p[2],v2,centres).Subdivide();
}
else
{
Vector v1(0,0,0); v1.setDiffxy(p[0],p[3],random * da);
Vector v2(0,0,0); v2.setDiffxy(p[1],p[2],random * bc);
LandQuad(v1,v2,p[2],p[3],centres).Subdivide();
LandQuad(p[0],p[1],v2,v1,centres).Subdivide();
}
}
else if(ab > 150*UNITE )//&& partage
{
Vector v1(0,0,0); v1.setDiffxy(p[0],p[1],random * ab);
Vector v2(0,0,0); v2.setDiffxy(p[3],p[2],random * cd);
LandQuad(p[0],v1,v2,p[3],centres).Subdivide();
LandQuad(v1,p[1],p[2],v2,centres).Subdivide();
}
else if( da > 150*UNITE )//&& !partage
{
Vector v1(0,0,0); v1.setDiffxy(p[0],p[3],random * da);
Vector v2(0,0,0); v2.setDiffxy(p[1],p[2],random * bc);
LandQuad(v1,v2,p[2],p[3],centres).Subdivide();
LandQuad(p[0],p[1],v2,v1,centres).Subdivide();
}
else if( (ab > 90*UNITE && ab < 160*UNITE && bc > 2*ab && bc < 320*UNITE && bc > 180*UNITE )|| (bc > 90*UNITE && bc < 160*UNITE && ab > 2*bc && ab < 320*UNITE && ab > 180*UNITE) || // très grands quartiers rectangulaires
(ab > 150*UNITE && ab < 200*UNITE && bc > 1.5*ab && bc < 300*UNITE && bc >225*UNITE )|| (bc > 150*UNITE && bc < 200*UNITE && ab > 1.5*bc && ab < 300*UNITE && ab > 225*UNITE) || // très grands quartiers semi rectangulaires
(ab > 80*UNITE && ab < 100*UNITE && bc < 100*UNITE && bc > 80*UNITE)) // grands quartiers carrés
{
creationQuartier();
}
else if( ab > 90*UNITE && da > 90*UNITE)
{
if(partage){
Vector v1(0,0,0); v1.setDiffxy(p[0],p[1],random * ab);
Vector v2(0,0,0); v2.setDiffxy(p[3],p[2],random * cd);
LandQuad(p[0],v1,v2,p[3],centres).Subdivide();
LandQuad(v1,p[1],p[2],v2,centres).Subdivide();
}
else{
Vector v1(0,0,0); v1.setDiffxy(p[0],p[3],random * da);
Vector v2(0,0,0); v2.setDiffxy(p[1],p[2],random * bc);
LandQuad(v1,v2,p[2],p[3],centres).Subdivide();
LandQuad(p[0],p[1],v2,v1,centres).Subdivide();
}
}
// deuxième subdivision moyenne
else if(ab > 90*UNITE ) // && partage
{
Vector v1(0,0,0); v1.setDiffxy(p[0],p[1],random * ab);
Vector v2(0,0,0); v2.setDiffxy(p[3],p[2],random * cd);
LandQuad(p[0],v1,v2,p[3],centres).Subdivide();
LandQuad(v1,p[1],p[2],v2,centres).Subdivide();
}
else if( da > 90*UNITE ) // && !partage
{
Vector v1(0,0,0); v1.setDiffxy(p[0],p[3],random * da);
Vector v2(0,0,0); v2.setDiffxy(p[1],p[2],random * bc);
LandQuad(v1,v2,p[2],p[3],centres).Subdivide();
LandQuad(p[0],p[1],v2,v1,centres).Subdivide();
}
else if( (ab > 80*UNITE && ab < 100*UNITE && bc > 2*ab && bc < 200*UNITE && bc > 180*UNITE )|| (bc > 80*UNITE && bc < 100*UNITE && ab > 2*bc && ab < 200*UNITE && ab >160*UNITE )|| // quartiers rectangulaires moyens
(ab > 50*UNITE && ab < 70*UNITE && bc < 70*UNITE && bc > 50*UNITE) || // quartiers carrés moyens
(ab > 50*UNITE && ab < 70*UNITE && bc > 3*ab && bc < 210*UNITE && bc >150*UNITE )|| (bc> 50*UNITE && bc < 70*UNITE && ab > 3*bc && ab < 210*UNITE && ab >150*UNITE ) || // quartiers rectangulaires étalés moyens
(ab > 50*UNITE && ab < 80*UNITE && bc > 1.5*ab && bc < 120*UNITE && bc > 75*UNITE )|| (bc > 50*UNITE && bc < 80*UNITE && ab > 1.5*bc && ab < 120*UNITE && ab > 75*UNITE )) // quartiers semi rectangulaires moyens
{
creationQuartier();
}
// dernière subdivision
else if(ab > 120*UNITE && ab > 2 *bc)
{
Vector v1(0,0,0); v1.setDiffxy(p[0],p[1],random * ab);
Vector v2(0,0,0); v2.setDiffxy(p[3],p[2],random * cd);
LandQuad(p[0],v1,v2,p[3],centres).Subdivide();
LandQuad(v1,p[1],p[2],v2,centres).Subdivide();
}
else if( da > 120*UNITE && da > 2 *ab)
{
Vector v1(0,0,0); v1.setDiffxy(p[0],p[3],random * da);
Vector v2(0,0,0); v2.setDiffxy(p[1],p[2],random * bc);
LandQuad(v1,v2,p[2],p[3],centres).Subdivide();
LandQuad(p[0],p[1],v2,v1,centres).Subdivide();
}
else if(da > 30*UNITE && ab > 30*UNITE)
{
creationQuartier();
}
else
{
Vector::setCol(COL_ROUTE1,COL_ROUTE2,COL_ROUTE3);
PrismQuad(Quadrangle(p[0],p[1],p[2],p[3]),0.10*UNITE).Render();
double tShrink = 7.5*UNITE; // largeur de 15m (au total, donc 7.5m de chaque côté depuis le milieu de la route)
Quadrangle q=Quadrangle(p[0],p[1],p[2],p[3]).Shrink(tShrink,tShrink,tShrink,tShrink);
Mobilier(10*UNITE,50*UNITE,0.3*UNITE).creerLampadaires(Quadrangle(q[0],q[1],q[2],q[3])); // d a 10 pour le moment mais il faudra le mettre à 25 (cad tous les 50m) une fois les vrais quartiers définis
//création du trottoir
Vector::setCol(COL_TROTT1,COL_TROTT2,COL_TROTT3);
PrismQuad(Quadrangle(q[0],q[1],q[2],q[3]),0.30*UNITE).Render(); // hauteur de 20 cm
Vector::setColDefaut();
tShrink = 4* UNITE; // 4 m
Quadrangle q2=Quadrangle(q[0],q[1],q[2],q[3]).Shrink(tShrink,tShrink,tShrink,tShrink);
Vector::setCol(COL_HERBE1,COL_HERBE2,COL_HERBE3);
PrismQuad(Quadrangle(q2[0],q2[1],q2[2],q2[3]),0.40*UNITE).Render();
//PrismQuad(Quadrangle(p[0],p[1],p[2],p[3]),0.40*UNITE).Render();
Vector::setColDefaut();
}
}
Toit::Toit(const Vec3<float>& a, const Vec3<float>& b, const Vec3<float>& c, const Vec3<float>& d, const float& _h,const float& _rotate,int _etage){
q = Quadrangle(a, b, c, d);
h = _h;
rotate = _rotate;
etages = _etage;
}
void BaseBuilding::creerToitPyramideCoupe()
{
double largeurBord = (double) UNIT*0.2;
double hauteurBord = (double) UNIT*0.2;
double air = Quadrangle(listPoints[0],listPoints[1],listPoints[2],listPoints[3]).Area();
bool airMini = air > 8*(largeurBord*largeurBord);
if(airMini)
{
float zTriangle = listPoints[0][2] + (float) windowHeight*2;
Vector centre(0,0,0);
for(unsigned int i = 0; i < listPoints.size(); i++) centre += listPoints[i];
centre /= listPoints.size();
double& z = centre[2];
z = zTriangle; // mise à jour de Z
//-------------------------Quadrangle supérieur --------------------------------------------------->
std::vector<Vector> quadrangleIn; //la liste des points du quadrangle supérieur
double onConserve = (double)(rand()%15)/100;
for(unsigned int i = 0; i < listPoints.size(); i++)
{
Vector in = listPoints[i] + (centre - listPoints[i])*(onConserve + 0.5);
double& z = in[2];
z = zTriangle;
quadrangleIn.push_back(in);
}
glBegin(GL_QUADS);
glNormal3d(0,0,1.0f);
glColor3ub(Vector::col1,Vector::col2,Vector::col3);
glVertex3f(quadrangleIn[0][0], quadrangleIn[0][1], quadrangleIn[0][2]);
glVertex3f(quadrangleIn[1][0], quadrangleIn[1][1], quadrangleIn[1][2]);
glVertex3f(quadrangleIn[2][0], quadrangleIn[2][1], quadrangleIn[2][2]);
glVertex3f(quadrangleIn[3][0], quadrangleIn[3][1], quadrangleIn[3][2]);
for(int i=0; i<4;i++)
{
for(int j =0;j<3;j++)
{
ToitPyramideCoupe.push_back(quadrangleIn[i][j]);
}
}
glEnd();
//--------------------------------------------------------------------------------------------------<
//----------------------------Faces de la "pyramide coupée"-----------------------------------------<
glBegin(GL_QUADS);
glColor3ub(Vector::col1,Vector::col2,Vector::col3);
for(unsigned int i = 0; i < 4; i++)
{
glVertex3f(quadrangleIn[i%4][0], quadrangleIn[i%4][1], quadrangleIn[i%4][2]); // point Haut-Gauche
glVertex3f(listPoints[i%4][0], listPoints[i%4][1], listPoints[i%4][2]); // point Bas-Gauche
glVertex3f(listPoints[(i+1)%4][0], listPoints[(i+1)%4][1], listPoints[(i+1)%4][2]); //point Bas-Droite
glVertex3f(quadrangleIn[(i+1)%4][0], quadrangleIn[(i+1)%4][1], quadrangleIn[(i+1)%4][2]); //point Haut-Droite
}
int j;
for (int i=0; i<=3 ;i++)
{
for(j=0;j<=2;j++)
ToitPyramideCoupe.push_back(quadrangleIn[i%4][j]);
for(j=0;j<=2;j++)
ToitPyramideCoupe.push_back(listPoints[i%4][j]);
for(j=0;j<=2;j++)
ToitPyramideCoupe.push_back(listPoints[(i+1)%4][j]);
for(j=0;j<=2;j++)
ToitPyramideCoupe.push_back(quadrangleIn[(i+1)%4][j]);
}
glEnd();
//--------------------------------------------------------------------------------------------------<
listPoints.clear();
for(unsigned int i = 0; i < quadrangleIn.size(); i++) listPoints.push_back(quadrangleIn[i]);
PrismQuad(quadrangleIn[0],quadrangleIn[1],quadrangleIn[2],quadrangleIn[3], ((double) UNIT)*0.2).Render();
}
}
void BaseBuilding::creerToitPrisme(bool addChimney)
{
/*
d_________________c
| |
e|________g________|f --> arrête supérieure du prisme
| |
|________h________|
a b
*/
double air = Quadrangle(listPoints[0],listPoints[1],listPoints[2],listPoints[3]).Area();
if(air > airMin)
{
double hauteurPrisme = (double) UNIT * 3;
Vector monterEnZ(0,0,hauteurPrisme);
int j;
Vector e = ( (listPoints[3] + listPoints[0]) /2 ) + monterEnZ;
Vector f = ( (listPoints[2] + listPoints[1]) /2 ) + monterEnZ;
glBegin(GL_TRIANGLES); // Face ade
Vector n= (listPoints[3]-listPoints[0])/(e-listPoints[0]);
n/=Norm(n);
glNormal3f(n[0],n[1],n[2]);
glColor3ub(Vector::col1,Vector::col2,Vector::col3);
glVertex3f(listPoints[0][0], listPoints[0][1], listPoints[0][2]);
glVertex3f(listPoints[3][0], listPoints[3][1], listPoints[3][2]);
glVertex3f(e[0], e[1], e[2]);
for(j=0;j<=2;j++)
PrismRoof.push_back(listPoints[0][j]);
for(j=0;j<=2;j++)
PrismRoof.push_back(listPoints[3][j]);
for(j=0;j<=2;j++)
PrismRoof.push_back(e[j]);
glEnd();
glBegin(GL_QUADS); // Face abfe
n= (listPoints[1]-listPoints[0])/(e-listPoints[0]);
n/=Norm(n);
glNormal3f(n[0],n[1],n[2]);
glColor3ub(Vector::col1,Vector::col2,Vector::col3);
glVertex3f(listPoints[0][0], listPoints[0][1], listPoints[0][2]);
glVertex3f(listPoints[1][0], listPoints[1][1], listPoints[1][2]);
glVertex3f(f[0], f[1], f[2]);
glVertex3f(e[0], e[1], e[2]);
for(j=0;j<=2;j++)
PrismRoof.push_back(listPoints[0][j]);
for(j=0;j<=2;j++)
PrismRoof.push_back(listPoints[1][j]);
for(j=0;j<=2;j++)
PrismRoof.push_back(f[j]);
for(j=0;j<=2;j++)
PrismRoof.push_back(e[j]);
glEnd();
glBegin(GL_QUADS); // Face cdef
n= (listPoints[3]-listPoints[2])/(f-listPoints[2]);
n/=Norm(n);
glNormal3f(n[0],n[1],n[2]);
glColor3ub(Vector::col1,Vector::col2,Vector::col3);
glVertex3f(listPoints[2][0], listPoints[2][1], listPoints[2][2]);
glVertex3f(listPoints[3][0], listPoints[3][1], listPoints[3][2]);
glVertex3f(e[0], e[1], e[2]);
glVertex3f(f[0], f[1], f[2]);
for(j=0;j<=2;j++)
PrismRoof.push_back(listPoints[2][j]);
for(j=0;j<=2;j++)
PrismRoof.push_back(listPoints[3][j]);
for(j=0;j<=2;j++)
PrismRoof.push_back(e[j]);
for(j=0;j<=2;j++)
PrismRoof.push_back(f[j]);
glEnd();
glBegin(GL_TRIANGLES); // Face bcf
n= (listPoints[2]-listPoints[1])/(f-listPoints[1]);
n/=Norm(n);
glNormal3f(n[0],n[1],n[2]);
glColor3ub(Vector::col1,Vector::col2,Vector::col3);
glVertex3f(listPoints[1][0], listPoints[1][1], listPoints[1][2]);
glVertex3f(listPoints[2][0], listPoints[2][1], listPoints[2][2]);
glVertex3f(f[0], f[1], f[2]);
for(j=0;j<=2;j++)
PrismRoof.push_back(listPoints[1][j]);
for(j=0;j<=2;j++)
PrismRoof.push_back(listPoints[2][j]);
for(j=0;j<=2;j++)
PrismRoof.push_back(f[j]);
glEnd();
//-------------------Cheminée----------------------------->
if(addChimney)
{
Vector g = (e + f)/2;
Vector h = (listPoints[0] + listPoints[1])/2;
double chimneyWidth = (double) UNIT;
std::vector<Vector> newPoints;
newPoints.push_back(listPoints[0] + monterEnZ/3);
newPoints.push_back(h + monterEnZ/3); //e - monterEnZ + (monterEnZ/3)
newPoints.push_back(e - (monterEnZ*2/3)); //g - monterEnZ + (monterEnZ/3)
newPoints.push_back(g - (monterEnZ*2/3));
Vector tmp = (listPoints[0] + e + g + h)/4;
Vector centerAEGH = Vector(tmp[0],tmp[1], newPoints[0][2]); //le centre de la cheminée
double tailleAd = Norm(newPoints[3] - newPoints[0]);
double tailleAb = Norm(newPoints[1] - newPoints[0]);
double ratioAbEtDc,ratioAdEtBc;
if(tailleAd > tailleAb)
{
ratioAbEtDc = tailleAd/tailleAb;
ratioAdEtBc = 1;
}
else
{
ratioAbEtDc = 1;
ratioAdEtBc = tailleAb/tailleAd;
}
for(unsigned int i = 0; i < newPoints.size(); i++)
{
double pas = Norm(newPoints[i] - centerAEGH)/chimneyWidth;
newPoints[i] = centerAEGH + ( (newPoints[i] - centerAEGH)/pas );
}
//Les sommets de la cheminée
Vector a,b,c,d;
a = newPoints[0];
b = newPoints[1];
c = newPoints[3];
d = newPoints[2];
//comme on veut que tous les côtés soient égaux, on applique un ratio
PrismQuad(
a,
a + (b - a)*ratioAbEtDc,
d + (c - d)*ratioAbEtDc,
a + (d - a)*ratioAdEtBc,
((double)UNIT)*3).Render();
}
}
}
void Batiment::creerToitPyramide()
{
double largeurBord = (double) UNITE*0.2;
double hauteurBord = (double) UNITE*0.2;
double air = Quadrangle(listePoints[0],listePoints[1],listePoints[2],listePoints[3]).Area();
bool airMini = air > 8*(largeurBord*largeurBord);
int j;
if(airMini)
{
double hauteurPyramide = hauteurEtage*2;
Vector monterEnZ(0,0,hauteurPyramide);
Vector centre(0,0,0);
for(unsigned int i = 0; i < listePoints.size(); i++) centre += listePoints[i];
centre /= listePoints.size();
centre += monterEnZ;// mise à jour de Z
glBegin(GL_TRIANGLES); // Debut du dessin de la pyramide
glColor3ub(Vector::col1,Vector::col2,Vector::col3);
for(unsigned int i = 0; i < 4; i++)
{
glNormal3d(0,0,1.0f);
glVertex3f(centre[0], centre[1], centre[2]); // Haut du triangle de face
glVertex3f(listePoints[i%4][0], listePoints[i%4][1], listePoints[i%4][3]); // Bas gauche du triangle de face
glVertex3f(listePoints[(i+1)%4][0], listePoints[(i+1)%4][1], listePoints[(i+1)%4][3]); // Bas droit du triangle de face
for(j=0;j<=2;j++)
ToitPyramide.push_back(centre[j]);
for(j=0;j<=1;j++)
ToitPyramide.push_back(listePoints[i%4][j]);
if(j==2)
ToitPyramide.push_back(listePoints[i%4][j+1]);
for(j=0;j<=1;j++)
ToitPyramide.push_back(listePoints[(i+1)%4][j]);
if(j==2)
ToitPyramide.push_back(listePoints[(i+1)%4][j+1]);
}
glEnd(); // Fin du dessin de la pyramide
//ajout d'une antenne
if(rand()%100 > 30)
{
//"0.9*" pour enterrer l'antenne dans la pyramide
Vector enterrer(0,0, -0.15*hauteurPyramide);
std::vector<Vector> quadrangleIn;
// la base de l'antenne
for(unsigned int i = 0; i < listePoints.size(); i++)
{
Vector in = (listePoints[i] + monterEnZ) + (centre - (listePoints[i] + monterEnZ))*0.97 + enterrer;
quadrangleIn.push_back(in);
}
PrismQuad(quadrangleIn[0], quadrangleIn[1], quadrangleIn[2], quadrangleIn[3], hauteurEtage).Render();
// l'antenne
for(unsigned int i = 0; i < listePoints.size(); i++)
quadrangleIn[i] = quadrangleIn[i] + (centre - quadrangleIn[i])*0.5;
PrismQuad(quadrangleIn[0], quadrangleIn[1], quadrangleIn[2], quadrangleIn[3], hauteurPyramide*1.5).Render();
}
}
}
