Discussion :

[jobard344]

Bonsoir,

Je voudrais dessiner un cube en langage C à partir de coordonnées 3D.
Pour cela j'ai creer une fonction qui convertir les points 3D en points 2D.
Ma fonction prend en parametre une structure des points 3D et une structure de points 2D dans laquelle elle mettra les valeurs de conversions qu elle aura calculée.

J'ai aussi creer une autre fonction qui prend en paramétre 2 points en coordonnees 2D et qui trace une ligne entre ces deux points.

Ma question est : Comment faire pour tracer le cube en ayant ces coordonnees 3D des 8 points du cube qui sont :
(0,0,0)
(0,0,50)
(0,50,0)
(0;50;50)
(50;0;0)
(50;0;50)
(50;50;0)
(50;50;50)

Je met ma fonction qui convertit:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
int     main(int argc, char *argv[])
{
  Coordonnees_3D        point_3D;
  Coordonnees_2D        point_2D;
  double        constante;
 
  point_3D.x = 120;
  point_3D.y = 75;
  point_3D.z = 500;
  constante = 0.8;
  proj_paral(&point_3D, &point_2D, constante);
  return (0);
}

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
 
void    proj_paral(Coordonnees_3D *point_3D, Coordonnees_2D *point_2D, double constante)
{
  point_2D -> X = (point_3D -> x) + constante * (point_3D -> z);
  point_2D -> Y = (point_3D -> y) + (constante / 2) * (point_3D -> z);
}

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
 
typedef struct Coordonnees_3D Coordonnees_3D;
struct Coordonnees_3D
{
  double        x;
  double        y;
  double        z;
};

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
 
typedef struct Coordonnees_2D Coordonnees_2D;
struct Coordonnees_2D
{
  double        X;
  double        Y;
};

Merci de votre aide.

[c1702]

Bonjour,

Peux-tu nous donner plus de précisions ?
Quelle librairie graphique utilises-tu ?
As-tu déjà fait la fonction de rotation ?

Au final, tu veux juste faire tourner un cube à la demomaker ou tu veux mettre en place un système de caméra ?

Pour la projection 3D > 2D, pour un truc très simple type démo, normalement la formule ressemble en gros à un truc du style :
x2D = ((x3D + constante) / z3D) + (largeur écran / 2);
y2D = ((y3D + constante) / z3D) + (hauteur écran / 2);

Un article parle de ça ici :
http://www.flipcode.com/archives/The..._Systems.shtml

Ensuite, tu veux faire un cube en fil de fer ? En faces pleines ? Texturé ?

Clément.

[jobard344]

en fait c'est un exercice de TP que j essaye de faire, et c est la libraire "minilibX",
d'apres l'enoncé de mon TP il faut seulement la fonction qui convertit les coordonnées 3D en 2D et une autre fonction qui relie les 8 points du cube.

Oui c est un genre de cube en fil de fer.

Je met en piece jointe mon TP.

Merci

[c1702]

Bonsoir,

Ah d'accord, c'est beaucoup plus simple que je ne l'imaginais !

Dans ton cas, il va te falloir un tableau de 8 points 3D. Par exemple :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
 
#define PTS_3D (8)
Coordonnees_3D        pPts3D[PTS_3D] =
{
   { 0,0,0 },
   { 0,0,50 },
   { 0,50,0 },
etc...
};

Note, il va falloir faire attention à l'ordre des points pour la suite !

Tu vas aussi avoir un tableau qui va te dire quels points relier. Par exemple :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
 
#define LINES_NB (12)
struct SLine
{
   u32 nPtA, nPtB;
};
struct SLine        pLines[LINES_NB] =
{
   { 0,1 },   // On va relier le sommet 0 au sommet 1.
   { 1,2 },   // On va relier le sommet 1 au sommet 2.
   { 2,3 },
etc...
};

A partir de là, tu fais un for pour parcourir pLines, tu fais proj_paral sur les deux sommets de la ligne en cours, et le draw_line. Par exemple :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
 
u32   i;
u32   nPtA, nPtB;
Coordonnees_2D        point_2DA, point_2DB;
for (i = 0; i < LINES_NB; i++)
{
   // On récupère les deux sommets de la ligne en cours.
   nPtA = pLines[i].nPtA;
   nPtB = pLines[i].nPtB;
 
   // Projection.
   proj_paral(&pPts3D[nPtA], &point_2DA, constante);
   proj_paral(&pPts3D[nPtB], &point_2DB, constante);
 
   // Ligne.
   draw_line(point_2DA.x, point_2DA.y, point_2DB.x, point_2DB.y);
}

Et pour le draw_line, tu n'as plus qu'à encoder l'algo de Bresenham. Ca se trouve un peu partout, par exemple ici : http://fr.wikipedia.org/wiki/Algorit...t_de_Bresenham
(Ceci dit, essaye d'abord de tracer juste les sommets, tu verras déjà si ça donne ce que tu veux).

Note : Ton TP dit de faire la conversion 3D > 2D pour chacun des 2 sommets des 12 lignes, ce qui n'est pas génial, parce que tu vas calculer plusieurs fois les mêmes positions. Dans l'idéal, il faudrait projeter tous tes points une fois et se référer directement à ces points 2D.

Clément.

[jobard344]

@c1702: Merci de ta reponse j ai modifier un peu mon code, et j ai essayer de faire un tableau de structure pour stocker les coordonnees du cube, comme tu m as dit.

Le probleme est que quand je veux remplir mon tableau comme ca :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
 
ptr_3D[0] = {0, 0, 0}; 
ptr_3D[1] = {0, 0, 50};
ptr_3D[2] = {0, 50, 0};   etc...

Le compilo se met en erreur !
Sais tu pourquoi?

Sinon je post mon code modifier.

Merci.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
 
int     main()
{
  Coordonnees_3D        points_3D[8];
  Coordonnees_3D        *ptr_3D;
  Coordonnees_2D        points_2D[8];
  Coordonnees_2D        *ptr_2D;
  double        constante;
 
  constante = 0.8;
  ptr_3D = &points_3D[0];
  ptr_2D = &points_2D[0];
 
  ptr_3D[0] = {0, 0, 0};
  ptr_3D[1] = {0, 0, 50};
  ptr_3D[2] = {0, 50, 0};
 
  conversion(ptr_3D, ptr_2D, constante);
  read(ptr_2D);
}

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
 
void    conversion(Coordonnees_3D *ptr_3D,  Coordonnees_2D *ptr_2D, double constante)
{
  int   i;
 
  i = 1;
  while (i < 2)
    {
      ptr_2D[i].X = ptr_3D[i].x + constante * ptr_3D[i].z;
      ptr_2D[i].Y = ptr_3D[i].y + (constante / 2) * ptr_3D[i].z;
      i = i + 1;
    }
}

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
 
void    read(Coordonnees_2D *ptr_2D)
{
  int   i;
 
  i = 0;
  while (i != 2)
    {
      printf("[%d].X = %f\n", i, ptr_2D[i].X);
      printf("[%d].Y = %f\n", i, ptr_2D[i].Y);
      i++;
    }
}

[c1702]

Bonjour,

Le probleme est que quand je veux remplir mon tableau comme ca :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
 
ptr_3D[0] = {0, 0, 0}; 
ptr_3D[1] = {0, 0, 50};
ptr_3D[2] = {0, 50, 0};   etc...

Le compilo se met en erreur !
Sais tu pourquoi?

On peut retirer l'erreur avec un cast, mais ce n'est pas vraiment le souci. Le souci, c'est pourquoi veux tu initialiser ton tableau comme ça alors que tu peux mettre des valeurs statiques directement dans la table ? Ce n'est pas une bonne idée. Non seulement ça fait des immédiats, ce n'est pas pratique à modifier, et en plus ça génère du code alors que tu pourrais ne rien faire du tout.

Ton code modifié ne ressemble pas du tout à ce que je t'ai expliqué. Où est passé le tableau de lignes ? Où sont les define ? Dans ce que je t'ai donné, il ne reste qu'à coder une routine de ligne (ce qui est de loin la partie la plus compliquée du TP). Si c'est le "u32" qui te pose un problème, tu peux le remplacer par un "unsigned int" (ou un "int").

Au passage, ta routine "conversion" est buggée. La ligne 6, ça devrait être "i = 0;". Le problème, c'est aussi que fait de cette façon, tu ne pourras pas convertir tes coordonnées point par point. Si tu convertis 2 points, ce sera forcément 2 points qui se suivent dans le tableau 3D, ce qui va te poser un problème. (A moins que tu ne veuilles projeter tous les points d'un coup ? C'est mieux, mais pas ce qui est demandé dans ton énnoncé). A adapter en fonction : la ligne 6 du main (tableau 2D de 8 cases, alors que tu n'en utilises que 2 (pour l'instant)).

Clément.