Gestion de la souris

Version imprimable

04/09/2007, 10h23
kitsune

Gestion de la souris

Bonjour,

Je voudrais pouvoir dessiner un rectangle en utilisant la souris comme dans un editeur graphique : cliquer a un endroit et etirer le rectangle. (genre une selection dans photoshop)

Par contre j'ai un probleme entre les coordonnees de mon rectangle et celles de la position de la souris qui ne sont pas du tout du meme ordre de grandeur.

Par exemple j'ai un carre en (-1,1);(1,1);(1,-1);(-1,-1) place au centre de ma fenetre et le dernier coin (-1,-1) je le remplace par des variables contenant la position de la souris quand elle bouge (j'essaye d'etirer un coin).

J'obtiens alors des positions comme 149.0 ce qui me donne un truc beaucoup trop grand.

Je sais meme pas si c'est dans les fonctions de type OnMouseMove que je dois travailler...

Merci de votre aide.
04/09/2007, 11h22
fearyourself

Bonjour,

OpenGL est une bibliothèque de rendu 3D, tu utilises une autre bibliothèque pour gérer la souris ? Serait-ce Glut ?

Ensuite, il faut savoir que si tu ne travailles pas dans un monde orthogonal, c'est plus difficile de passer du monde 2D de la souris au monde 3D de ton rendu.

Jc
05/09/2007, 02h24
kitsune

Oui effectivement j'utilise Glut et je travaille uniquement en 2D...

Merci
05/09/2007, 05h56
Mat.M

Faire de la 2d avec Open GL ce n'est pas génial à mon avis.
Comme le laisse supposer FearyYourself Open GL est plus axé 3D
Comme il le dit c'est une API de rendu graphique une API qui exploite l'accélération matérielle de la carte graphique pour faire des transformations 3D.
Donc pour faire de la 2D avec OGL les gains de performances sont faibles sauf si tu veux faire un jeu 2D ce qui n'est pas le cas.
Moi je prendrais plutot simplement le GDI et ses fonctions sous Windows par exemple...à bon entendeur...
05/09/2007, 07h51
kitsune

Certes je n'en doute pas.
Toujours est-il que je suis en stage et c'est l'exercice que l'on m'a donne pour me familiariser avec ces outils, apres je vais plonger dans la 3D.
Donc de toute facon je n'ai pas le choix !

Mon probleme etait que les coordonnees pointees par ma souris n'etaient pas les memes que celles dans le plan de ma fenetre openGL.
Par exemple si je cree un rectangle avec un coin en (0,0) je me rend compte que l'origine du plan est au centre de ma fenetre. Mais l'origine de ma fenetre est de coordonnees (327,202). Vous suivez ?

J'essaye juste de comprendre comment tout cela est constitue afin de pouvoir creer un rectangle a l'endroit ou je clique...
Lorsque je faisais partir le coin du rectangle aux coordonnees de ma souris par exemple (176,256) forcement le rectangle se cree mais pas dans la zone visible de mon plan.

J'espere que c'est comprehensible, pas evident a expliquer !

Merci :)
05/09/2007, 07h54
lorannt

Citation:

Faire de la 2d avec Open GL ce n'est pas génial à mon avis.

Alors là je ne suis pas du tout d'accord! :)

D'abord OpenGL est tout à fait adapté à la 2D, pourvu que ce soit du vectoriel (pour le traitement pixel par pixel c'est un peu moins évident). Et le vectoriel et la voie de l'avenir AMHA: étant donné que le pitch des écrans est de plus en plus disparate, travailler sur des pixels va devenir de plus en plus difficile. Toutes les librairies graphiques modernes (au moins dans le monde du libre) travaillent en vectoriel.

Ensuite pourquoi faire faire quelquechose par le CPU alors qu'on a un processeur spécialisé dans cette tâche?

Pour ton problème, kitsune, je sais qu'il existe dans la GLu des fonctions pour faire ce que tu veux (passer des coordonnées écran au coordonnées de tes objets), par exemple gluUnProject. Je ne les ai encore jamais utilisé, donc je peux pas t'aider plus...
05/09/2007, 08h20
kitsune

Merci beaucoup pour l'info.
J'ai trouve un exemple pour ceux que ca interesse.

Je vais tester ca pour voir, merci !
05/09/2007, 09h25
kitsune

Hum ca me donne des valeurs plus qu'etranges... J'ai repris l'exemple mais j'ai l'impression que ca ne marche pas...
Quelqu'un connait-il cette fonction ?

Merci.
05/09/2007, 11h26
Ti-R

Il faut convertir ta vue dans les coordonnées de ta souris, ou convertir les coordonnées de ta souris dans celle de ta vue.

Mon poste dans ce topic Projection 2d

Permet la conversion de ta vue dans les coordonnées de ta souris.

Hmm merci mais j'avoue que je suis un peu perdue la.
Je vais vous donner mon code ce sera ptet plus simple.

oglCreate :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
 
void COpenGLControl::oglCreate(CRect rect, CWnd *parent)
{
	CString className = AfxRegisterWndClass(CS_HREDRAW | CS_VREDRAW | CS_OWNDC, NULL, (HBRUSH)GetStockObject(BLACK_BRUSH), NULL);
 
	CreateEx(0, className, "OpenGL", WS_CHILD | WS_VISIBLE | WS_CLIPSIBLINGS | WS_CLIPCHILDREN, rect, parent, 0);
 
	// Set initial variables' values
	m_oldWindow	   = rect;
	m_originalRect = rect;
 
	hWnd = parent;
}

oglInitialize :

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
 
void COpenGLControl::oglInitialize(void)
{
	// Initial Setup:
	//
	static PIXELFORMATDESCRIPTOR pfd =
	{
		sizeof(PIXELFORMATDESCRIPTOR),
		1,
		PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL | PFD_DOUBLEBUFFER,
		PFD_TYPE_RGBA,
		32, // bit depth
		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
		16, // z-buffer depth
		0, 0, 0, 0, 0, 0, 0,
	};
 
	// Get device context only once.
	hdc = GetDC()->m_hDC;
 
	// Pixel format.
	m_nPixelFormat = ChoosePixelFormat(hdc, &pfd);
	SetPixelFormat(hdc, m_nPixelFormat, &pfd);
 
	// Create the OpenGL Rendering Context.
	hrc = wglCreateContext(hdc);
	wglMakeCurrent(hdc, hrc);
 
	// Basic Setup:
	//
	// Set color to use when clearing the background.
	glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
	glClearDepth(1.0f);
 
	// Turn on backface culling
	glFrontFace(GL_CCW);
	glCullFace(GL_BACK);
 
	// Turn on depth testing
	glEnable(GL_DEPTH_TEST);
	glDepthFunc(GL_LEQUAL);
 
	// Send draw request
	OnDraw(NULL);
}

OnSize :

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
 
void COpenGLControl::OnSize(UINT nType, int cx, int cy)
{
	CWnd::OnSize(nType, cx, cy);
 
	if (0 >= cx || 0 >= cy || nType == SIZE_MINIMIZED) return;
 
	// Map the OpenGL coordinates.
	glViewport(0, 0, cx, cy);
 
	// Projection view
	glMatrixMode(GL_PROJECTION);
 
	glLoadIdentity();
 
	// Set our current view perspective
	gluPerspective(35.0f, (float)cx / (float)cy, 0.01f, 2000.0f);
 
	//glOrtho(-10,10,-10,10,-10,10);
 
	// Model view
	glMatrixMode(GL_MODELVIEW);
 
	glLoadIdentity(); //
 
	switch (nType)
	{
		// If window resize token is "maximize"
		case SIZE_MAXIMIZED:
		{
			// Get the current window rect
			GetWindowRect(m_rect);
 
			// Move the window accordingly
			MoveWindow(6, 6, cx - 14, cy - 14);
 
			// Get the new window rect
			GetWindowRect(m_rect);
 
			// Store our old window as the new rect
			m_oldWindow = m_rect;
 
			break;
		}
 
		// If window resize token is "restore"
		case SIZE_RESTORED:
		{
			// If the window is currently maximized
			if (m_bIsMaximized)
			{
				// Get the current window rect
				GetWindowRect(m_rect);
 
				// Move the window accordingly (to our stored old window)
				MoveWindow(m_oldWindow.left, m_oldWindow.top - 18, m_originalRect.Width() - 4, m_originalRect.Height() - 4);
 
				// Get the new window rect
				GetWindowRect(m_rect);
 
				// Store our old window as the new rect
				m_oldWindow = m_rect;
			}
 
			break;
		}
	}
}

OnDraw :

Code:

1
2
3
4
5
6
7
8
9
10
11
 
void COpenGLControl::OnDraw(CDC *pDC)
{
	// If the current view is perspective...
	glLoadIdentity();
 
	glTranslatef(0.0f, 0.0f, -m_fZoom);
	glTranslatef(m_fPosX, m_fPosY, 0.0f);
	glRotatef(m_fRotX, 1.0f, 0.0f, 0.0f);
	glRotatef(m_fRotY, 0.0f, 1.0f, 0.0f);
}

Click droit :

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
 
void COpenGLControl::OnRButtonDown(UINT nFlags, CPoint point)
{
	object = 1;
 
	GLdouble modelMatrix[16];
        glGetDoublev(GL_MODELVIEW_MATRIX,modelMatrix);
        GLdouble projMatrix[16];
        glGetDoublev(GL_PROJECTION_MATRIX,projMatrix);
	int viewport[4];
	glGetIntegerv(GL_VIEWPORT,viewport);
 
	double winY = viewport[3] - point.y -1;
 
	bool ok = gluUnProject(
	 (GLdouble)point.x,
	 winY,
	 0.0,
	 modelMatrix,
	 projMatrix,
	 viewport,
	 //the next 3 parameters are the pointers to the final object
	 //coordinates. Notice that these MUST be double's
	 &m_firstPosition[0], //-> pointer to your own position (optional)
	 &m_firstPosition[1], // id
	 &m_firstPosition[2] // id
	);
 
         // debug
	 double test = m_firstPosition[0];
	 double test1 = m_firstPosition[1];
	 double test2 = m_firstPosition[2];
 
	CWnd::OnRButtonDown(nFlags, point);
}

Dans la fonction de click, les variables test me rendent des valeurs normalement converties plus qu'etranges comme des 0.0010977432...
Il doit me manquer quelque chose non ?

Sinon je crois que c'est a peu pres tout... Et un timer qui tourne pour rafraichir la scene.

Merci.

06/09/2007, 04h38
kitsune
Bon ben j'ai fini par trouver... C'etait tout bete en plus.

J'ai change mon OnSize :
Code:

1 2 3 //gluPerspective(35.0f, (float)cx / (float)cy, 0.01f, 2000.0f); glOrtho(-10,10,-10,10,-10,10);
Merci ! ;)