diff --git a/TP_Geom3D_2018/Projet_modeling/main.cpp b/TP_Geom3D_2018/Projet_modeling/main.cpp
index 7946993cb0508dcd95d3caa604ff288469d5768d..401b12ae874c5210fe1b6ce1d3215b1b8817126e 100644
--- a/TP_Geom3D_2018/Projet_modeling/main.cpp
+++ b/TP_Geom3D_2018/Projet_modeling/main.cpp
@@ -1,4 +1,4 @@
-
+
#include <QApplication>
#include <QGLViewer/simple_viewer.h>
#include <matrices.h>
@@ -19,9 +19,20 @@ const Vec3 NOIR = {0,0,0};
void draw_repere(const Primitives& prim, const Mat4& tr)
{
prim.draw_sphere(tr, BLANC);
+<<<<<<< HEAD
prim.draw_cylinder(tr*translate(1,0,0)* scale(2,0.5,0.5) * rotateY(90) , ROUGE); // X
prim.draw_cylinder(tr*translate(0,1,0)* scale(0.5,2,0.5) * rotateX(90) , VERT); // Y
prim.draw_cylinder(tr*translate(0,0,1) * scale(0.5,0.5,2) , BLEU); // Z
+=======
+ prim.draw_cylinder(tr*translate(1,0,0)* scale(1,0.25,0.25) * rotateY(90) , ROUGE); // X
+ prim.draw_cylinder(tr*translate(0,1,0)* scale(0.25,1,0.25) * rotateX(90) , VERT); //Y
+ prim.draw_cylinder(tr*translate(0,0,1) * scale(0.25,0.25,1) , BLEU); //Z
+
+ prim.draw_cone(tr*translate(0,1,0)* rotateX(-90), VERT);
+ prim.draw_cone(tr*translate(1,0,0)* rotateY(90), ROUGE);
+ prim.draw_cone(tr*translate(0,0,1), BLEU);
+}
+>>>>>>> 3eaf77e4b27a9ed06e64dda2d31ce444b5e0010f
prim.draw_cone(tr*translate(2,0,0)* rotateY(90), ROUGE);
prim.draw_cone(tr*translate(0,2,0)* rotateX(-90), VERT);
@@ -44,9 +55,16 @@ void star(MeshQuad& m)
}
}
+<<<<<<< HEAD
void spirale(MeshQuad& m)
{
m.create_cube();
+=======
+
+void spirale(MeshQuad& m)
+{
+ m.create_cube();
+>>>>>>> 3eaf77e4b27a9ed06e64dda2d31ce444b5e0010f
#pragma omp parallel for
for(int i = 0 ; i < 250 ; i++)
{
@@ -54,6 +72,7 @@ void spirale(MeshQuad& m)
m.extrude_quad(12) ;
}
+<<<<<<< HEAD
}
void inside_shape1(MeshQuad& m,int q, int count)
@@ -73,10 +92,107 @@ void inside_shape1(MeshQuad& m,int q, int count)
index = m.nb_quads()*4;
inside_shape1(m,q, count-1);
+=======
+}
+
+void inside_shape(MeshQuad& m,int q, int count)
+{
+ int index;
+ if(count > 0)
+ {
+ m.extrude_quad(q);
+ m.extrude_quad(q);
+ m.shrink_quad(q,0.9f);
+ m.tourne_quad(q,5) ;
+ m.extrude_quad(q);
+ m.shrink_quad(q,0.5f);
+ m.extrude_quad(q);
+ m.decale_quad(q,1.2f);
+
+ index = m.nb_quads()*4;
+
+ inside_shape(m,q, count-1);
+
+ inside_shape(m,index-4, count-1);
+ inside_shape(m,index-8, count-1);
+
+ inside_shape(m,index-12, count-1);
+ inside_shape(m,index-16, count-1);
+
+ }
+}
+
+void inside_shape2(MeshQuad& m,int q, int count)
+{
+ int index;
+ if(count > 0)
+ {
+ m.extrude_quad(q) ;
+ m.extrude_quad(q) ;
+ m.shrink_quad(q,0.5f) ;
+ m.extrude_quad(q) ;
+ m.decale_quad(q,5);
+
+ index = m.nb_quads()*4;
+
+ inside_shape2(m,q, count-1);
+
+ inside_shape2(m,index-4, count-1);
+ inside_shape2(m,index-8, count-1);
+
+ inside_shape2(m,index-12, count-1);
+ inside_shape2(m,index-16, count-1);
+ }
+}
+
+void inside_shape3(MeshQuad& m,int q, int count)
+{
+ if(count > 1){
+
+ #pragma omp parallel for
+ for(int i = 0 ; i < 17 ; i++)
+ {
+ m.extrude_quad(q) ;
+ m.transfo_quad(q,rotateX(20)) ;
+
+ }
+ int index = count * 16 ;
+ inside_shape3(m,index,count -1) ;
+
+ }
+
+}
+
+void shape1(MeshQuad& m )
+{
+ m.create_cube() ;
+ #pragma omp parallel for
+ for(int i = 0 ; i < 6 ; i++)
+ inside_shape(m,4*i,3) ;
+
+}
+
+void shape2(MeshQuad& m )
+{
+ m.create_cube() ;
+
+ for(int i = 0 ; i < 8; i++)
+ {
+ m.extrude_quad(12) ;
+ m.transfo_quad(12,rotateY(18)) ;
+ m.extrude_quad(16) ;
+ m.transfo_quad(16,rotateY(-18)) ;
+ }
+
+
+ inside_shape2(m,12,3) ;
+ inside_shape2(m,16,3) ;
+>>>>>>> 3eaf77e4b27a9ed06e64dda2d31ce444b5e0010f
inside_shape1(m,index-4, count-1);
inside_shape1(m,index-8, count-1);
+<<<<<<< HEAD
inside_shape1(m,index-12, count-1);
inside_shape1(m,index-16, count-1);
@@ -95,6 +211,16 @@ void inside_shape2(MeshQuad& m,int q, int count)
m.decale_quad(q,5);
index = m.nb_quads()*4;
+=======
+}
+
+void shape3(MeshQuad& m )
+{
+ m.create_cube() ;
+ inside_shape3(m,12,18) ;
+
+}
+>>>>>>> 3eaf77e4b27a9ed06e64dda2d31ce444b5e0010f
inside_shape2(m,q, count-1);
@@ -184,7 +310,11 @@ int main(int argc, char *argv[])
mesh.set_matrices(viewer.getCurrentModelViewMatrix(),viewer.getCurrentProjectionMatrix());
prim.set_matrices(viewer.getCurrentModelViewMatrix(),viewer.getCurrentProjectionMatrix());
+<<<<<<< HEAD
mesh.draw(JAUNE);
+=======
+ mesh.draw(BLANC);
+>>>>>>> 3eaf77e4b27a9ed06e64dda2d31ce444b5e0010f
if (selected_quad>=0)
{
@@ -241,8 +371,13 @@ int main(int argc, char *argv[])
break;
case Qt::Key_1:
+<<<<<<< HEAD
shape1(mesh) ;
break ;
+=======
+ shape1(mesh) ;
+ break ;
+>>>>>>> 3eaf77e4b27a9ed06e64dda2d31ce444b5e0010f
case Qt::Key_2:
shape2(mesh) ;
@@ -251,8 +386,11 @@ int main(int argc, char *argv[])
case Qt::Key_3:
shape3(mesh) ;
break ;
+<<<<<<< HEAD
+=======
+>>>>>>> 3eaf77e4b27a9ed06e64dda2d31ce444b5e0010f
// ....
// Attention au cas m_selected_quad == -1
diff --git a/TP_Geom3D_2018/Projet_modeling/meshquad.cpp b/TP_Geom3D_2018/Projet_modeling/meshquad.cpp
index 9140825c9bbad248acd7c8f5fb8def350e311d55..be5a4a4baebb01b0cc7b7978527e125e946e9f6a 100644
--- a/TP_Geom3D_2018/Projet_modeling/meshquad.cpp
+++ b/TP_Geom3D_2018/Projet_modeling/meshquad.cpp
@@ -1,4 +1,4 @@
-#include "meshquad.h"
+ #include "meshquad.h"
#include "matrices.h"
#include <iostream>
#include <vector>
@@ -7,6 +7,11 @@
using namespace std;
+<<<<<<< HEAD
+=======
+#define MAX 1000000000
+using namespace std ;
+>>>>>>> 3eaf77e4b27a9ed06e64dda2d31ce444b5e0010f
void MeshQuad::clear()
{
m_points.clear();
@@ -39,6 +44,7 @@ void MeshQuad::convert_quads_to_tris(const std::vector<int>& quads, std::vector<
// Pour chaque quad on genere 2 triangles
// Attention a repecter l'orientation des triangles
+<<<<<<< HEAD
#pragma omp parallel for
for (size_t i=0; i< quads.size(); i+=4) {
int v1 = quads.at(i);
@@ -52,6 +58,21 @@ void MeshQuad::convert_quads_to_tris(const std::vector<int>& quads, std::vector<
tris.push_back(v3);
tris.push_back(v4);
tris.push_back(v1);
+=======
+ int index = 0 ;
+
+ for(size_t i = 0 ; i < quads.size()/4 ; i++)
+ {
+ tris.push_back(quads[index]) ;
+ tris.push_back(quads[index+1]) ;
+ tris.push_back(quads[index+2]) ;
+
+ tris.push_back(quads[index]) ;
+ tris.push_back(quads[index+2]) ;
+ tris.push_back(quads[index+3]) ;
+
+ index += 4 ;
+>>>>>>> 3eaf77e4b27a9ed06e64dda2d31ce444b5e0010f
}
}
@@ -60,11 +81,15 @@ void MeshQuad::convert_quads_to_edges(const std::vector<int>& quads, std::vector
{
edges.clear();
edges.reserve(quads.size()); // ( *2 /2 !)
+<<<<<<< HEAD
+=======
+>>>>>>> 3eaf77e4b27a9ed06e64dda2d31ce444b5e0010f
// Pour chaque quad on genere 4 aretes, 1 arete = 2 indices.
// Mais chaque arete est commune a 2 quads voisins !
// Comment n'avoir qu'une seule fois chaque arete ?
+<<<<<<< HEAD
size_t i, nb_quads = quads.size();
#pragma omp parallel for
@@ -91,11 +116,43 @@ void MeshQuad::convert_quads_to_edges(const std::vector<int>& quads, std::vector
edges.push_back(i1);
}
}
+=======
+ int i ,i1,i2,i3,i4;
+ for(i = 0 ; i < quads.size()/4 ; i+=4)
+ {
+ i1 = quads.at(i) ;
+ i2 = quads.at(i+1) ;
+ i2 = quads.at(i+2) ;
+ i2 = quads.at(i+3) ;
+
+ if(i1 < i2)
+ {
+ edges.push_back(i1);
+ edges.push_back(i2);
+ }
+ if(i2 < i3)
+ {
+ edges.push_back(i2);
+ edges.push_back(i3);
+ }
+ if(i3 < i4)
+ {
+ edges.push_back(i3);
+ edges.push_back(i4);
+ }
+ if(i4 < i1)
+ {
+ edges.push_back(i4);
+ edges.push_back(i1);
+ }
+ }
+>>>>>>> 3eaf77e4b27a9ed06e64dda2d31ce444b5e0010f
}
void MeshQuad::bounding_sphere(Vec3& C, float& R)
{
+<<<<<<< HEAD
size_t i , nb_points = m_points.size();
#pragma omp parallel for reduction(+:C)
@@ -113,12 +170,28 @@ void MeshQuad::bounding_sphere(Vec3& C, float& R)
}
}
R = max;
+=======
+
+ for (size_t i = 0; i < this->m_points.size(); i++) {
+ C += this->m_points.at(i);
+ }
+ C /= m_points.size();
+ float max = glm::length(C - this->m_points.at(0));
+ for (size_t i = 1; i < this->m_points.size(); i++) {
+ float tmp = glm::length(C - this->m_points.at(i));
+ if (tmp > max) {
+ max = tmp;
+ }
+ }
+ R = max;
+>>>>>>> 3eaf77e4b27a9ed06e64dda2d31ce444b5e0010f
}
void MeshQuad::create_cube()
{
clear();
+<<<<<<< HEAD
float s = 0.5 ;
// ajouter 8 sommets (-1 +1)
@@ -140,12 +213,34 @@ void MeshQuad::create_cube()
add_quad(i8,i7,i6,i5);
gl_update();
+=======
+ // ajouter 8 sommets (-1 +1)
+ int i1 = add_vertex(Vec3(-1,1,1));
+ int i2 = add_vertex(Vec3(-1,-1,1));
+ int i3 = add_vertex(Vec3(1,-1,1));
+ int i4 = add_vertex(Vec3(1,1,1));
+ int i5 = add_vertex(Vec3(-1,1,-1));
+ int i6 = add_vertex(Vec3(-1,-1,-1));
+ int i7 = add_vertex(Vec3(1,-1,-1));
+ int i8 = add_vertex(Vec3(1,1,-1));
+
+ // ajouter 6 faces (sens trigo)
+ add_quad(i1,i2,i3,i4);
+ add_quad(i4,i3,i7,i8);
+ add_quad(i8,i7,i6,i5);
+ add_quad(i5,i6,i2,i1);
+ add_quad(i2,i6,i7,i3);
+ add_quad(i1,i4,i8,i5);
+
+ gl_update();
+>>>>>>> 3eaf77e4b27a9ed06e64dda2d31ce444b5e0010f
}
Vec3 MeshQuad::normal_of(const Vec3& A, const Vec3& B, const Vec3& C)
{
// Attention a l'ordre des points !
// le produit vectoriel n'est pas commutatif U ^ V = - V ^ U
+<<<<<<< HEAD
// ne pas oublier de normaliser le resultat.
Vec3 normal = glm::cross(B - A, C - A);
@@ -159,6 +254,18 @@ float MeshQuad::quad_aire(int q)
v2 = m_quad_indices.at(q+1);
v3 = m_quad_indices.at(q+2);
v4 = m_quad_indices.at(q+3);
+=======
+ // ne pas oublier de normcaliser le resultat.
+
+ Vec3 n, nA, nB, nC;
+ nA = glm::cross(B-A, C-A);
+ nB = glm::cross(A-B, C-B);
+ nC = glm::cross(B-C, A-C);
+ n = (nA + nB + nC);
+ n /= 3;
+ return glm::normalize(n);
+}
+>>>>>>> 3eaf77e4b27a9ed06e64dda2d31ce444b5e0010f
Vec3 A, B, C, D;
A = m_points.at(v1);
@@ -181,6 +288,7 @@ float MeshQuad::quad_aire(int q)
bool MeshQuad::is_points_in_quad(const Vec3& P, const Vec3& A, const Vec3& B, const Vec3& C, const Vec3& D)
{
// On sait que P est dans le plan du quad.
+<<<<<<< HEAD
// P est-il au dessus des 4 plans contenant chacun la normale au quad et une arete AB/BC/CD/DA ?
// si oui il est dans le quad
@@ -210,13 +318,30 @@ bool MeshQuad::is_points_in_quad(const Vec3& P, const Vec3& A, const Vec3& B, co
n4 = glm::cross(n, DA);
if (glm::dot(n4, P) - glm::dot(n4, D)< 0)
return false;
+=======
+
+ // P est-il au dessus des 4 plans contenant chacun la normale au quad et une arete AB/BC/CD/DA ?
+ // si oui il est dans le quad
+
+ Vec3 n1 = glm::cross(B-A,C-B) ;
+ Vec3 n2 = glm::cross(C-B,D-C) ;
+ Vec3 n3 = glm::cross(D-C,A-D) ;
+ Vec3 n4 = glm::cross(A-D,B-A) ;
+
+ float som1 = P.x*n1.x + P.y*n1.y + P.z*n1.z ; //dot
+ float som2 = P.x*n2.x + P.y*n2.y + P.z*n2.z ;
+ float som3 = P.x*n3.x + P.y*n3.y + P.z*n3.z ;
+ float som4 = P.x*n4.x + P.y*n4.y + P.z*n4.z ;
+
+ return som1 > 0 && som2 >0 && som3 > 0 && som4 > 0 ;
+>>>>>>> 3eaf77e4b27a9ed06e64dda2d31ce444b5e0010f
- return true;
}
bool MeshQuad::intersect_ray_quad(const Vec3& P, const Vec3& Dir, int q, Vec3& inter)
{
// recuperation des indices de points
+<<<<<<< HEAD
int i1, i2, i3, i4;
i1 = m_quad_indices.at(q);
i2 = m_quad_indices.at(q+1);
@@ -244,6 +369,38 @@ bool MeshQuad::intersect_ray_quad(const Vec3& P, const Vec3& Dir, int q, Vec3& i
// I dans le quad ?
return is_points_in_quad(inter, A, B, C, D);
}
+=======
+ // recuperation des points
+ int i1,i2,i3,i4 ;
+ Vec3 p1,p2,p3,p4 ;
+
+ i1 = m_quad_indices.at(q) ;
+ i2 = m_quad_indices.at(q+1) ;
+ i3 = m_quad_indices.at(q+2) ;
+ i4 = m_quad_indices.at(q+3) ;
+
+ p1 = m_points.at(i1) ;
+ p2 = m_points.at(i2) ;
+ p3 = m_points.at(i3) ;
+ p4 = m_points.at(i4) ;
+
+
+ // calcul de l'equation du plan (N+d)
+
+ Vec3 N = glm::cross(p2-p1,p3-p1) ;
+ float d = -N.x*p4.x - N.y*p4.y - N.z*p4.z ;
+ Vec3 D ;
+ // calcul de l'intersection rayon plan
+ // I = P + alpha*Dir est dans le plan => calcul de alpha
+
+ float alpha = (d - glm::dot(N, P)) / glm::dot(P,Dir);
+ // alpha => calcul de I
+
+ inter = P + alpha * Dir ;
+ // I dans le quad ?
+ return is_points_in_quad(inter,p1,p2,p3,p4) ;
+ }
+>>>>>>> 3eaf77e4b27a9ed06e64dda2d31ce444b5e0010f
int MeshQuad::intersected_closest(const Vec3& P, const Vec3& Dir)
@@ -251,6 +408,7 @@ int MeshQuad::intersected_closest(const Vec3& P, const Vec3& Dir)
// on parcours tous les quads
// on teste si il y a intersection avec le rayon
// on garde le plus proche (de P)
+<<<<<<< HEAD
int i,inter = -1 ;
@@ -274,6 +432,26 @@ int MeshQuad::intersected_closest(const Vec3& P, const Vec3& Dir)
return inter;
+=======
+
+ int i,inter = -1 ;
+ float min = MAX ;
+ Vec3 inters = Vec3() ;
+
+ for (i = 0 ; i < m_quad_indices.size()/4 ; i+=4)
+ {
+ if(intersect_ray_quad(P,Dir,i,inters))
+ {
+ if(glm::length(P-inters) < min)
+ {
+ inter = i ;
+ min = glm::length(P-inters) ;
+ }
+ }
+ }
+
+ return inter;
+>>>>>>> 3eaf77e4b27a9ed06e64dda2d31ce444b5e0010f
}
@@ -282,6 +460,7 @@ Mat4 MeshQuad::local_frame(int q)
// Repere locale = Matrice de transfo avec
// les trois premieres colones: X,Y,Z locaux
// la derniere colonne l'origine du repere
+<<<<<<< HEAD
// ici Z = N et X = AB
// Origine le centre de la face
@@ -375,6 +554,61 @@ void MeshQuad::extrude_quad(int q)
add_quad(i4, i1, v1, v4);
add_quad(i2, i3, v3, v2);
+=======
+
+ // ici Z = N et X = AB
+ // Origine le centre de la face
+ // longueur des axes : [AB]/2
+
+ // recuperation des indices de points
+ // recuperation des points
+
+ int i1,i2,i3,i4 ;
+ Vec3 A,B,C,D ;
+
+ i1 = m_quad_indices.at(q) ;
+ i2 = m_quad_indices.at(q+1) ;
+ i3 = m_quad_indices.at(q+2) ;
+ i4 = m_quad_indices.at(q+3) ;
+
+ A = m_points.at(i1) ;
+ B = m_points.at(i2) ;
+ C = m_points.at(i3) ;
+ D = m_points.at(i4) ;
+
+ // calcul de Z:N / X:AB -> Y
+
+ Vec3 Z = glm::cross(B-A,C-A) ;
+ Vec3 X = B - A ;
+ Vec3 Y = Z / X ;
+
+ // calcul du centre
+ C = normal_of(X,Y,Z) ;
+ // calcul de la taille
+
+ float t = glm::length(B-A) ;
+ // calcul de la matrice
+
+ Mat4 transfo = Mat4(Vec4(X,t),Vec4(Y,t),Vec4(Z,t),Vec4(C,t)) ;
+ return transfo;
+}
+
+void MeshQuad::extrude_quad(int q)
+{
+ // recuperation des indices de points
+
+ // recuperation des points
+
+ // calcul de la normale
+
+ // calcul de la hauteur
+
+ // calcul et ajout des 4 nouveaux points
+
+ // on remplace le quad initial par le quad du dessu
+
+ // on ajoute les 4 quads des cotes
+>>>>>>> 3eaf77e4b27a9ed06e64dda2d31ce444b5e0010f
gl_update();
}
@@ -382,6 +616,7 @@ void MeshQuad::extrude_quad(int q)
void MeshQuad::transfo_quad(int q, const glm::mat4& tr)
{
// recuperation des indices de points
+<<<<<<< HEAD
int i1, i2, i3, i4;
i1 = m_quad_indices.at(q);
i2 = m_quad_indices.at(q+1);
@@ -413,6 +648,14 @@ void MeshQuad::transfo_quad(int q, const glm::mat4& tr)
D = Vec3(transfo * Vec4(D, 1));
gl_update();
+=======
+ // recuperation des (references de) points
+
+ // generation de la matrice de transfo globale:
+ // indice utilisation de glm::inverse() et de local_frame
+
+ // Application au 4 points du quad
+>>>>>>> 3eaf77e4b27a9ed06e64dda2d31ce444b5e0010f
}
void MeshQuad::decale_quad(int q, float d)
diff --git a/TP_Geom3D_2018/Projet_modeling/meshquad.h b/TP_Geom3D_2018/Projet_modeling/meshquad.h
index c1494dad0c4df7d1d282f6d9ec15faf9af8c1f4c..b49fcdd78671a0c0b50f22bfc291b667b70c6c81 100644
--- a/TP_Geom3D_2018/Projet_modeling/meshquad.h
+++ b/TP_Geom3D_2018/Projet_modeling/meshquad.h
@@ -1,4 +1,4 @@
-#ifndef MESHTRI_H
+ #ifndef MESHTRI_H
#define MESHTRI_H
#include <vector>