Crée un cube avec SDL2 - rendu logiciel

Je pense que pour certain vous vous etes perdu ce sujet ne vise pas le fait de réinventer la 3D, simplement a poser un premier projet d'infographie avec certaine contrainte permettant une mise en condition.

Soit, supposons que nous nous soyons perdu en cours :aie:

Parlons concret si tu veux bien, tu en es ou de tes exos? Tu as du code du coup?

Ou est-ce que tu bloques? @Kannagi as pourtant bien ré-écris la question...

Sachant que je suis toujours bloquer au même endroit j'ai plein de jolie schéma et formule sur mes feuilles mais rien de concret en code

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
#include <SDL2/SDL.h>
#include <stdlib.h>
#include <stdio.h>
 
struct objet_t creer_cube(int x, int y, int z, int a);
int projeter_sommet(int d, int zc, int y, int z);
void afficher_cube(struct objet_t cube, SDL_Window *window);
void copy_tab(int tab1[], int tab2[], int taille);
void pause();
//void afficher_cube(struct objet_t cube, SDL_Surface *ecran);
 
struct polygone_t //Structure pour une face du cube
{
    int som1[3];
    int som2[3];
    int som3[3];
    int som4[3];
};
 
struct objet_t //Strucutre construite a partir d'une autre structure polygone_t
{
    struct polygone_t face1;
    struct polygone_t face2;
    struct polygone_t face3;
    struct polygone_t face4;
    struct polygone_t face5;
    struct polygone_t face6;
};
 
struct camera_t // Structure possedant 3 composantes de coordonnées et une de distance au plan de projection
{
    int position[3]; //Tableau pour les coordonnées de la caméra (Xc, Yc, Zc)
    int d; //Distance entre la caméra et le projeté
};
 
int main(int argc, char *argv[])
{
    //Declare
    int hauteur = 480, largeur = 600;
    int a = 100, x, y, z;   //Taille d'un coté et coordonnées du premier sommet
    int origin_cube_x = (largeur/2) - (a/2) ,origin_cube_y = (hauteur/2) + (a/2),origin_cube_z = 100;
    struct objet_t cube = creer_cube(origin_cube_x, origin_cube_y, origin_cube_z, a);
    struct camera_t camera;
 
    camera.d = 100;    //distance focal
    camera.position[0] = largeur/2;  //xc
    camera.position[1] = hauteur/2;  //yc
    camera.position[2] = -camera.d;  //zc
 
    if (SDL_Init(SDL_INIT_VIDEO) == 0) {
        SDL_Window* window = NULL;
        SDL_Renderer* renderer = NULL;
 
        if (SDL_CreateWindowAndRenderer(largeur, hauteur, 0, &window, &renderer) == 0) {
            SDL_bool done = SDL_FALSE;
 
            while (!done) {
                SDL_Event event;
 
                afficher_cube(cube, window);
 
                SDL_SetRenderDrawColor(renderer, 255, 255, 255, SDL_ALPHA_OPAQUE);
                SDL_RenderDrawLine(renderer, origin_cube_x, origin_cube_y, origin_cube_x, origin_cube_y - a);
                SDL_RenderDrawLine(renderer, origin_cube_x, origin_cube_y - a, origin_cube_x + a, origin_cube_y - a);
                SDL_RenderDrawLine(renderer, origin_cube_x + a, origin_cube_y - a, origin_cube_x + a, origin_cube_y );
                SDL_RenderDrawLine(renderer, origin_cube_x + a, origin_cube_y, origin_cube_x, origin_cube_y);
 
                SDL_RenderPresent(renderer);
 
                while (SDL_PollEvent(&event)) {
                    if (event.type == SDL_QUIT) {
                        done = SDL_TRUE;
                    }
                }
            }
        }
 
        if (renderer) {
            SDL_DestroyRenderer(renderer);
        }
        if (window) {
            SDL_DestroyWindow(window);
        }
    }
 
 
 
 
 
 
    SDL_Quit();
    return EXIT_SUCCESS;
}
 
struct objet_t creer_cube(int x, int y, int z, int a) //Fonction qui crée le cube
{
    struct objet_t cube;
 
    /*
    Mon origine est placer en 1 donc mes 7 autre sommet seront placer en fonction de ce sommet
 
            4#######3
            #       #
            #   5   #
            #       #
            7#######8
            #       #
            #   2   #
            #       #
    7#######6#######5#######8
    #       #       #       #
    #   4   #   6   #   3   #
    #       #       #       #
    4#######1#######2#######3
            #       #
            #   1   #
            #       #
            4#######3
    */
 
    //Definition de la face avant du cube
 
    //Definition du premier sommet (x,y,z)
 
    cube.face1.som1[0] = x;
    cube.face1.som1[1] = y;
    cube.face1.som1[2] = z;
 
    //Definition du second sommet (x+a,y,z)
 
    cube.face1.som2[0] = x + a;
    cube.face1.som2[1] = y;
    cube.face1.som2[2] = z;
 
    //Definition du troisieme sommet (x+a,y+a,z)
 
    cube.face1.som3[0] = x + a;
    cube.face1.som3[1] = y + a;
    cube.face1.som3[2] = z;
 
    //Definition du quatrieme sommet (x,y+a,z)
 
    cube.face1.som4[0] = x;
    cube.face1.som4[1] = y + a;
    cube.face1.som4[2] = z;
 
    //Fin definition face avant
 
    //########################################################
 
    //Definition de la arriere avant du cube
 
    //Definition du cinquieme sommet
 
    cube.face1.som1[0] = x + a;
    cube.face1.som1[1] = y;
    cube.face1.som1[2] = z + a;
 
    //Definition du sixieme sommet
 
    cube.face1.som2[0] = x;
    cube.face1.som2[1] = y;
    cube.face1.som2[2] = z + a;
 
    //Definition du septieme sommet
 
    cube.face1.som3[0] = x;
    cube.face1.som3[1] = y + a;
    cube.face1.som3[2] = z + a;
 
    //Definition du huitieme sommet
 
    cube.face1.som4[0] = x + a;
    cube.face1.som4[1] = y + a;
    cube.face1.som4[2] = z + a;
 
    //Fin definition face arriere
 
    //#######################################################
 
    //definition face 3 (2,5,8,3)
 
    copy_tab(cube.face1.som2, cube.face3.som1, 3); //Copie le sommet 2 de la face 1 dans le sommet 1 de la face 3
    copy_tab(cube.face2.som1, cube.face3.som2, 3); //Copie le sommet 1 de la face 2 dans le sommet 2 de la face 3
    copy_tab(cube.face2.som4, cube.face3.som3, 3); //Copie le sommet 4 de la face 2 dans le sommet 3 de la face 3
    copy_tab(cube.face1.som3, cube.face3.som4, 3); //Copie le sommet 3 de la face 1 dans le sommet 4 de la face 3
 
    //Fin definition face 3
 
    //#######################################################
 
    //definition face 4 (6,1,4,7)
 
    copy_tab(cube.face2.som2, cube.face4.som1, 3); //Copie le sommet 2 de la face 2 dans le sommet 1 de la face 4
    copy_tab(cube.face1.som1, cube.face4.som2, 3); //Copie le sommet 1 de la face 1 dans le sommet 2 de la face 4
    copy_tab(cube.face1.som4, cube.face4.som3, 3); //Copie le sommet 4 de la face 1 dans le sommet 3 de la face 4
    copy_tab(cube.face2.som3, cube.face4.som4, 3); //Copie le sommet 3 de la face 2 dans le sommet 4 de la face 4
 
    //Fin definition face 4
 
    //#######################################################
 
    //definition face 5 (4,3,8,7)
 
    copy_tab(cube.face1.som4, cube.face5.som1, 3); //Copie le sommet 4 de la face 1 dans le sommet 1 de la face 5
    copy_tab(cube.face1.som3, cube.face5.som2, 3); //Copie le sommet 3 de la face 1 dans le sommet 2 de la face 5
    copy_tab(cube.face2.som4, cube.face5.som3, 3); //Copie le sommet 4 de la face 2 dans le sommet 3 de la face 5
    copy_tab(cube.face2.som3, cube.face5.som4, 3); //Copie le sommet 3 de la face 2 dans le sommet 4 de la face 5
 
    //Fin definition face 5
 
    //#######################################################
 
    //definition face 6 (6,5,2,1)
 
    copy_tab(cube.face2.som2, cube.face6.som1, 3); //Copie le sommet 2 de la face 2 dans le sommet 1 de la face 6
    copy_tab(cube.face2.som1, cube.face6.som2, 3); //Copie le sommet 1 de la face 2 dans le sommet 2 de la face 6
    copy_tab(cube.face1.som2, cube.face6.som3, 3); //Copie le sommet 2 de la face 1 dans le sommet 3 de la face 6
    copy_tab(cube.face1.som1, cube.face6.som4, 3); //Copie le sommet 1 de la face 1 dans le sommet 4 de la face 6
 
    //Fin definition face 6
 
    return cube;
}
 
int projeter_sommet(int d, int zc, int y, int z)
{
    int yp = (d*y)/(zc-z);
    return yp;
}
 
void copy_tab(int tab1[], int tab2[], int taille) // Pour 2 tableau de meme taille uniquement
{
    int i;
    for( i=0 ; i<taille ; i++ )
        tab2[i] = tab1[i];
}
 
void pause()
{
    int continuer = 1;
    SDL_Event event;
 
    while (continuer)
    {
        SDL_WaitEvent(&event);
        switch(event.type)
        {
            case SDL_QUIT:
                continuer = 0;
        }
    }
}
 
void afficher_cube(struct objet_t cube, SDL_Window *window)
{
    int xp, yp;
}

Alors règle numéro 1 faudra organiser mieux ton code , tu on aura besoin.

Franchement le prof ne fait pas un truc compliqué (normalement pour la projection 3D/2D on fait une multiplication de matrice) , votre prof a voulu faire plus simple , votre caméra est fixe !
Donc en gros plus un objet est éloigné plus il est petit et inversement (plus il est proche plus il est gros) c'est ce que dit la partie 3 grosso modo.

1 pièce(s) jointe(s)

Je ne comprend pas comment définir les coordonnées de la caméra et et du cube par rapport a l'écran
Pièce jointe 330921

Tes vecteurs sont des triplets d'int ? Tu ne peux pas travailler directement en coordonnées écran (pixels), tu as besoin d'un intervalle bien plus large. Bien que ce soit possible de travailler avec des entiers, c'est bien plus compliqué dans ce cas. Utilise des variables flottants (type double ou float). Travaille en coordonnées normalisées (entre zéro et un, ou entre moins un et un) puis convertis-les au dernier moment, tu t'affranchis ainsi des dimensions de la zone de dessin qui peuvent varier et de tout un tas d'autres contraintes.

Avance progressivement : qu'as-tu réussi à obtenir jusqu'à présent ? Parviens-tu à afficher quelque chose à l'écran ? Qu'est-ce qui te bloque précisément ?

Prends les problèmes un par un et dans l'ordre.

1 pièce(s) jointe(s)

idée

je crois qu'il y a une formule de math pour calculer la position de chaque sommet de ton cube.

tu trace un cube vue de face par rapport au centre de ta fenêtre normalement pour être parfait a l'affichage tu devrai avoir 4 sommet et 4 arrêtes.
le centre de ta fenêtre c xyz { 0,0,0 }

tu peut faire bouger ton cube :

sur x avec les flèches droite et gauche du calcule chaque sommet de ton cube avec une fonction du genre x = x0 + r * cos(a);
sur y avec les flèches haut et bas "" "" y = y0 + r * sin(a);
sur z avec les les touches 1 et 2 par exemple z = z0 + r * tan(a); // a vérifier

Pièce jointe 330957

x0 y0 et z0 sont les coordonnées de ton point central du cube relier au point central de ta fenêtre.
r c'est le rayon du cercle par lequel les sommet de ton cube passe.
a est l'angle que tu peux modifier avec laide des touches.

Pour le moment je n'arrive a obtenir que la face avant le reste par dans tout les sens, j y avait penser a changer mes coordonnées en unitaire je vais faire ça et je reviens vers vous.

En ce qui concerne ce qui me bloque, je ne comprend pas du tout a partir de quel origine me référencer... En gros je vois doit quel direction placer mes axes mais en ce qui concerne le sens et l’origine de mon repère c'est un mystère

1 pièce(s) jointe(s)

j'ai regarder le schema de ton prof et je me suis dit peut etre que je prend le schema dans le mauvais sens en le lisant .

le cadre epais c'est la face avant
dit moi si sa peut t'aider

C'est intéressant comme idée seulement ce genre de fuyante ne correspond pas a ce projet car mon cube doit pouvoir translater et surbir une rotation quelque soit l'axe choisi

ENFIN j y suis arrivé mon cube s'affiche en 3D maintenant la gestion des face cacher
je posterai tout mon programme apres le rendu de mon projet pour que d'autres que ça interesse vois
comment faire... sachant que je n'ai pas suivi toute la methode du projet ça fonctionnai pas

reaction

alors vous avez pu bien terminer votre projet je serai intéréssé de voir comment vous avez fait pour la translation et la rotation