Bonjour bonjour, je suis de retour !

Je me suis remis à la programmation aujourd´hui ( c´est un hobby v´voyez... j´aimerais en faire un emploi mais j´en ai encore pour 4 ans à étudier avant, avec l´université... mais c´est complètement hors sujet) et j´ai une petite question théorique qui concerne DirectX ( et, je suppose, tous les autres APIs/lib mais comme je travaille avec DX présentement...), C++ et la souris.

Prenons n´importe quel jeu qui contient des boutons avec lesquels il est possible d´intéragir à la souris ( donc pas mal tous les jeux récent et relativement complexe - tetris ou pacman n´ont pas de boutons de ce genre -). J´aimerais savoir, est-ce qu´il existe une façon précise de savoir si la souris vient de cliquer sur une surface/un polygone ? Ou est-ce qu´un éventuel bouton implique que l´on compare la position de la souris au moment du clique avec la position du bouton et, évidemment, sa taille, question de savoir si le clique a lieu ?

Plus ou moins sur le sujet, vous avez essayé les intéractions avec les ordinateurs dans Doom 3 ( je parle de ceux dans le monde, pas du PDA) ? C´est pas mal la seule chose qui m´a sérieusement impressioné de tout le jeu ( et le mal de tête que j´ai à essayer d´imaginer comment ça a été codé) !

vi, a mon avis, ça a été monstrueux a coder Doom3, lol !

Pour ce qui est de DirectX, je vais essayer de répondre, meme si je connais bien mieux OpenGL :
tu as des fonctions de bas niveau que tu peux mettre dans ta fonction callback d´appel windows qui gerent la souris :

c´est a dire que tu peux juste détecter si tu as un clic, et la position x,y a tout moment.

De la, soit DirectX gere la selection de polygones, soit c´est a toi d´y calculer en passant par les matrices de rasterisation.

Est-ce qu´on parle bien des messages
WM_MOUSEMOVE
et
WM_MOUSEWHEEL
j´ai un peu de mal avec le terme CALLBACK, j´ai fais des recherches pour en trouvé l´utilisation/signification et la seule conclusion que j´ai pu tirer c´est que c´était utilisé pour le management d´event ?

bonne conclusion
et cela est meme dans la couche windows.h : donc AVANT la couche DirectX
pour te le prouver, le lien que je t´envoie est un lien de tutorial OpenGL, mais qui utilise windows.h

va sur :
http://nehe.gamedev.net
frame de gauche, " OpenGL Tutorials", tu vas sur le tutorial de la " lesson 32".
Une fois sur la page de cette leçon, tu vas tout en bas, tu as un lien :
" DOWNLOAD Visual C++ Code For This Lesson"
tu le charges, dedans tu as le fichier :
nehegl.cpp que tu ouvres

la fonction callback commence ligne 226.
a la ligne 297 et jusqu´a la fin de la fonction callback, y´a la gestion ( simple) d´évenements, qui met a jour des variables globales ( ligne 20)

ainsi, A TOUT MOMENT, quand tu interroges ces variables globales, tu as la bonne valeur de la souris

PS : meme si tu n´utilises ni visual, ni opengl, ouvre quand meme ce fichier et regardes la partie dont je te parle est indépendante, et de visual, et de DirectX/OpenGL, donc no problemo

Haaa Nehe, c´est un trademark de réussite . C´est en effet une bonne méthode, propre et efficace. Reste à savoir si DX a une forme de sélection des polygones .

Si ce n´était pas de ID3DXSprite qui gère la 2D facilement sous DirectGraphics ( du moins je pense que c´est ça le nom de la portion de DX concernée), je travaillerais probablement sous OGL en suivant religieusement les dires de ce site . Je suppose que ça pourrait être intéressant d´essayer de wrapper une approche de type " surface" avec des primitifs sous OGL ( et plus rapide que DGraphics) mais c´est un effort relativement important. Juste au niveau du AlphaBlending, tout est déjà fait en DX, il ne suffit que d´entrer un nombre pour indiquer le niveau d´alpha et ma surface devient transparente. Sous OGL, un long tutorial au sujet du blending . Je suis paresseux je suppose .

Je me question encore quand même sur le mot CALLBACK. Il est bien dans le message handler du code de Nehe... mais à chaque fois que j´écris un message handler, j´omets le CALLBACK et tout va bien. Le message manager de mon app sous DX est...

LRESULT WINAPI MsgProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
. ..
}

Quoiqu´il en soit, je suppose que c´est légèrement hors du sujet du post.

Merci beaucoup de ton aide !

Wew, désolé pour les fautes ( il est tard ici ) .

po grave pour les fautes

pour les WINAPI, les PASCAL, ou les CALLBACK
c´est juste des #define ( qui sont souvent identiques) pour clarifier le programmeur, mais en C++, ça ne signifie pas grand chose

pour l´approche DirectX, tu utilises une abstraction intermediaire via des tables d´action mapping ; tu enumeres tout les peripheriques d´entree ( souris, clavier, gamepad, voire des trucs plus originaux comme tablette graphique) de maniere generique ( revoila nos callbacks), au passage, l´utilisateur a la possibilite d´assigner les actions du jeu a chaque bouton d´un des periph reconnus ( via la table de mapping ^^^^) et ensuite, tu traites generiquement les entrees.
Tu ne diras pas " if ( souris.leftButton)" mais plutot " if ( input.fire)" ( sur le principe) ; donc tu n´as pas de concept de peripherique specifique, ce qui se revele TRES pratique et puissant.
les mousewheeldown etc. dont tu parles plus haut ^^^ sont lies a la couche de boucle de message win32, directx permet de couper au travers.

pis ensuite, pour le coup des polygones sur lequel on clique, c´est du picking... y´a 40000 techniques pour faire ca, du raycasting a l´accum buffer

Merci pour vos réponses !

LGV, est-ce qu´il s´agit là de DirectInput ?

vi, c´est du DirectInput