Sphere en mouvement openGl

Version imprimable

19/04/2017, 18h55
wallace27

Sphere en mouvement openGl

Bonjour,

Existe-t-il un moyen de déterminer en temps réel les coordonnées x, y, z d'une sphère pendant qu'elle est en mouvement ?

Je précise donc que je veux les coordonnées d'où elle se situe et non de l'endroit vers lequel elle se dirige.

Merci pour votre aide.
19/04/2017, 19h05
Kannagi

Je ne comprend pas , si tu affiche une sphère , tu sais ou elle se trouve en x,y,z (en mouvement ou pas) vu que c'est toi qui l'a fait bouger...
19/04/2017, 19h12
wallace27
Non, cette sphere par exemple, je connais ses coordonnées lorsqu'elle est posée sur la brique du bas et au moment où elle touche la première brique du haut, mais je ne connais pas ses coordonnées lorsqu'elle est à mi chemin, lorsqu'elle est aux 4/5 du chemin, etc.

https://www.youtube.com/watch?v=ZdkJpWhvKC8

Le but c'est que je puisse faire en sorte qu'il y ait un événement au moment où les coordonnées x, y, z de la sphere atteignent une certaine valeur. J'ai besoin de pouvoir dire :
Code:

1 2 3 4 if (sphere.x == 10 && sphere.y == 12 && sphere.z == 8) { then monAction };
19/04/2017, 19h18
Kannagi

Ta sphère tu l'affiche non donc tu lui donne une position X,Y,Z...

Ou alors tu parle de connaître sa position sur l'écran (mais la on parle de X,Y du coup)
19/04/2017, 19h27
wallace27

Je lui donne une position de départ, mais je ne lui donne pas toutes les coordonnées qu'elle adoptera durant sa trajectoire. Si par exemple je veux faire disparaître une brique au moment où ma sphere se situe à mi chemin entre la position de départ et sa position de retour je fais comment ? Je suis obligé de créer une fonction qui va dire qu'au moment où ma sphère adopte telles coordonnées tel événement se produira. Tu vois ce que je veux dire ?
19/04/2017, 19h32
Kannagi
Pas du tout , sur ton code que t'as posté sur ton topic précédent tu as mis ceci :
Code:

1 2 3 glTranslatef(0, sphereDeplacement, 0); afficherSphere();
Donc tu connaît la position de ta sphère x)

Par logique il faudrait plus faire ceci :
Code:

1 2 3 glTranslatef(sphere.x, sphere.y, sphere.z); afficherSphere();
et tu aura la position de ta sphère en tout instant (sur X,Y,Z) :roll:

Le souci n'est meme plus OpenGL la , mais le B.A.BA de la prog :p
19/04/2017, 20h00
wallace27

sphere.y reste toujours à -11, même lorsque la boule bouge, je le vois avec un simple printf. Comment tu expliques ça ?
19/04/2017, 20h03
wallace27

et si j'affiche l'équivalent du sphere.y qui est dans le gltranslate du display() j'ai la coordonnée vers laquelle la sphere se dirige même avant qu'elle n'y soit arrivée.
19/04/2017, 20h12
Kannagi

Citation:

Envoyé par wallace27

sphere.y reste toujours à -11, même lorsque la boule bouge, je le vois avec un simple printf. Comment tu expliques ça ?

Ma boule de cristal ne me dit rien désolé ;)

sphere.y dépend de ce que tu lui donne , si tu l'initialise pas la valeur sera un peu en "random".
Si tu l'initialise a -11 elle restera a -11.
Et donc faudra modifier cette valeur comme tu le sens.

Je comprend que en soit un débutant en prog , mais peut être un peu de réflexion ne fera pas de mal ^^'
19/04/2017, 22h07
wallace27

J'ai initialisé moi-même la valeur à -11, mais quel est le rapport avec la question que je pose ? Ma question se réfère au fait que pendant que la boule se déplace, la valeur de y ne reste pas à -11, elle passe à -10, -9, etc.

voici comment je fais pour le moment :

Fonction collision :

Code:

1
2
3
4
5
6
void collision(){
	if ((vingtDeux.position.y - sphereDeplacement) < 1){  // vingDeux = 22ème brique, sphereDeplacement = coordonnée y
		visibilite[22] = 0;
	}
 
}

Déplacement de la boule :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
void idle()
{
	if (animation == 1)
	{
		if (sphereDeplacement > 11 || sphereDeplacement < -0.6)
		{
                        sphereDirection = sphereDirection * -1;
			collision();
		}
 
		sphereDeplacement += 0.1 * sphereDirection;
 
		display();
		//Sleep(1000 / 60);
	}
}

19/04/2017, 23h38
Kannagi
Je ne comprend plus ton souci en faite , le gros souci c'est que tu programme de manière trop brouillant.
Le C est un langage 'simple' dans le sens sa syntaxe est souvent apprécier mais c'est un langage réputé difficile parce qu'il faut atteindre une certaine rigueur pour faire des choses assez simple.
Rigueur que tu ne possède absolument pas.

Si je dis cela c'est que on va aller de probleme en probleme avant que tu peux esperer faire ton casse brique.

Deja un avant de codé (et faire un peu n'importe quoi) il faut avoir son algo en tête , et tu me semble pas du tout l'avoir quand tu aura réfléchir mis sur papier la plupart des obstacles tu commencera a écrire du code pas avant.
L'autre point qui tue toute façon de faire un programme un peu plus complexe , c'est de faire des variables globales , c'est complètement déconseillé (et quasiment impossible de faire un programme modulaire avec ça).
Code:

1 2 3 4 5 6 7 void collision(){ if ((vingtDeux.position.y - sphereDeplacement) < 1){ // vingDeux = 22ème brique, sphereDeplacement = coordonnée y visibilite[22] = 0; } }
C'est complètement absurde de faire vingtDeux.position.y (il existe des tableau...), ta fonction n'est pas modulaire donc elle ne sert a rien.

Et si tu pense que je ne répond pas a ta question c'est que tu n'as rien compris sur l’intérêt de je que je t'ai dit ;)
La question que tu pose initialement n'a aucun sens vraiment , c'est toi qui décide ou est la position de ta sphere donc tu connais sa valeur :roll: , si tu n'arrive pas a récupère une valeur aussi basique c'est que y'a un gros souci dans le code (et rien n'a voir avec OpenGL d'ailleurs ).

Un Gameloop peut être vu de cette façon :
Code:

1 2 3 4 5 6 7 8 9 while(1) { Event(); Gameplay_control(); deplacement des vitesse(); collision(); affichage(); }
(possible de faire ce genre de gameloop avec freeglut).
C'est une vision simplifié bien sur mais le principe reste le même .
Plus savoir faire des fonctions modulaires (grâce aux structures et aux pointeurs) et tu pourra espérer finir ton casse-brique...
19/04/2017, 23h58
wallace27

Je panique un peu là... C'est à ce point grave d'avoir utilisé des variables globales ?
20/04/2017, 14h12
ohnomorejmmings

afficherSphere ?

J'ai rapidement lu et Kannagi a fait plein de bonnes remarques même si je le trouve trop dur avec un pauvre débutant. Ce que j'aimerai bien savoir c'est ce qui se passe dans ta fonction afficherSphere. Comment peux-tu afficher un objet sans connaitre sa position ? Ça sent le code copié-collé, l'utilisation d'une bibliothèque non comprise…
20/04/2017, 14h19
ohnomorejmmings

Variables globales

Pas forcément quand on sait ce qu'on fait mais dans ton cas ça relève d'un manque d'organisation et ça favorise les erreurs ou ce qu'on nomme le code spaghetti. Des variables comme vingtDeux n'existeraient pas dans ta fonction collision si tu avais proprement passé un tableau de briques en paramètre. De même tu ne te serais pas posé une question un peu tordue si ta fonction afficherSphere prenait un paramètre comme positionSphere. Au lieu de ça t'es perdu car tes fonctions sont déconnectées des variables qu'elles utilisent.

Pour se consoler on compte les briques : Un, deux… vingtUn, vingDeux… :P
20/04/2017, 14h33
el_slapper

Citation:

Envoyé par wallace27

Je panique un peu là... C'est à ce point grave d'avoir utilisé des variables globales ?

Juste là-dessus : oui c'est grave...quand on peut éviter. Quand on a pas le choix, eh bien on a pas le choix. Mais, dans ton cas précis, tu as le choix. Dans la plupart des cas, on a le choix. Et dans la plupart des cas, c'est la chose à faire.

Le principal souci des variables globales, c'est qu'elles sont accessibles de partout, et on finit assez vite par les changer de partout, ce qui rend le programmer indébuggable. Or le debugging est une activité clef en programmation. En réduisant au maximum la portée des variables, on les isole du reste, et si on a un debugging à faire(ça arrive tout le temps), on se limite au petit morceau qui va bien. Et ça devient possible. C'est ce que Kannagi appelle la programmation modulaire. Les langages objets ont d'ailleurs été conçus pour forcer cette encapsulation(le code qui manipule les données est embarqué dans la structure de données). C n'est pas objet, mais il faut quand même être propre et structuré.

Une organisation structurée, ça serait de définir toutes les variables liées à une brique(numéro, position, état, couleur), et de faire un tableau les contenant(ou une collection, mais je ne connais pas assez C pour savoir si ça existe). A chaque tour de jeu, tu fais une boucle qui teste si la boule a tapé une brique, en testant chaque brique de ton tableau contre la sphere. Ce genre de choses.