[ OPENGL ] avis au stars !!

Recherche :

Dernière réponse
Sujet : [ OPENGL ] avis au stars !!
oO_Oo	un site avec des tutoriaux bien sympo : http://nehe.gamedev.net ya pleins de lecons et la difficulté augmente ptit a ptit et c ultra commenté :D si jmeuh souvient bien ya un tutorial pour se balader ds un ptit nivo donc tu devrais trouver ce qu'il te faut dedans

Votre réponse

Nom d'utilisateur

Pour poster, vous devez être inscrit sur ce forum .... si ce n'est pas le cas, cliquez ici !

Le ton de votre message

Votre réponse

Smilies

Liste des smilies perso
Wiki smilies
Chercher un smiley

Options

Activer votre signature
Désactiver les smilies
Activer la notification par email du sujet

Aperçu

Vous avez perdu votre mot de passe ?

Vue Rapide de la discussion

oO_Oo

un site avec des tutoriaux bien sympo :

http://nehe.gamedev.net

ya pleins de lecons et la difficulté augmente ptit a ptit et c ultra commenté :D
si jmeuh souvient bien ya un tutorial pour se balader ds un ptit nivo donc tu devrais trouver ce qu'il te faut dedans

Arlo13

Salut!
J'ai pas mal dévelloper en OpenGL et je comprends tout a fait ton problème:

Premièrement, lorsque l'on dit que la caméra se déplace c'est en réalité tous les objets composants ta scène qui vont subir des transformations (rotation, translation, etc..). Cela donnera l'impression d'avancer mais ce sont en réalité les objets qui reculent.

En OpenGL, le repère est fixe, c'est à dire que les objets de ta scène quand tu les importent ont des coordonées qui ne changeront pas.

En gros, ca veut dire que si tu fais une rotation sur ta scène avec GLRotate() le centre de ta rotation sera le centre de ta scène. Donc forcement si tu fais une translation sur tes objets, le centre va rester le même donc ca te fera un truc tout bizarre puisque le centre de ta rotation ne sera pas ton point de vue mais celui du centre... :crazy:

Pour cela, il suffit juste que tu prennes un ptit papier et un crayon, pour t'apercevoir qu'il faudra d'une part gérer les rotations autrement qu'avec un angle fixe genre angle = angle + 1 et d'autre part qu'il faudra que tes rotations et tes translations soient en relations selon une formule propre a chaque axe (x,y,z).

D'où la bonne idée des matrices !
Mais la je te laisse chercher dans le forum le post: 'Pour les bons en Maths' qui expliquent très bien comment ca marche et ou trouver des liens !

Finalement, utilise des matrices et ton problème sera résolu! Et après tu pourras gérer ta caméra comme un pro ;)

@+

Zeross

Je n'ai pas beaucoup de temps je vais te donner quelques pistes aujourd'hui et si ça ne suffit pas je rentre Dimanche je pourrais mieux t'expliquer.

Tout d'abord il faut que tu t'imagines qu'en OpenGL le repère n'est pas fixe : quand tu fais ton glRotate tout le repère a subit une rotation, maintenant si tu veux avancer par rapport à ce nouveau repère il faut que tu exprimes ta translation dans ce repère modifié. En l'occurence si tu fais un petit schéma (essentiel pour la programmation 3D), tu t'aperçois que ta translation qui auparavant dans le repère précédent s'exprimait uniquement en Z s'exprime désormais en x et en z.

Fais un petit schéma avec le repère qui a subi une rotation puis projette ta translation sur les nouveaux axes tu vas voir ça va te sauter aux yeux.

pymousses

Zeross a écrit a écrit :

Je crois avoir compris ce que tu souhaites faire mais je suis pas sûr. J'avais fait un truc dans le genre il y a quelques temps c'était mon premier programme OpenGL donc c'est un peu dégueu mais c'est pas le sujet :D voilà le source :

#include <windows.h>
#include <stdlib.h>
#include <math.h>
#include <gl/gl.h>
#include <gl/glu.h>
#include <gl/glut.h>

#define BITS_PAR_PIXEL 16
#define Z_BUFFER 16

#define PI 3.14159265

HDC hdc=NULL;
HGLRC hrc=NULL;
HWND window_handle=NULL;

int distance=5;
int angleX=0,angleY=0;
float transX=0, transZ=5;

void SetupPixelFormat(HDC hdc)
{
int pixel_format;
PIXELFORMATDESCRIPTOR pfd=
{
sizeof(PIXELFORMATDESCRIPTOR),
1,
PFD_DRAW_TO_WINDOW|
PFD_SUPPORT_OPENGL|
PFD_DOUBLEBUFFER,
PFD_TYPE_RGBA,
BITS_PAR_PIXEL,
0, 0, 0, 0, 0, 0,
0,
0,
0,
0, 0, 0, 0,
Z_BUFFER,
0,
0,
0,
0,
0, 0, 0
};

pixel_format=ChoosePixelFormat(hdc, &pfd);
if(!pixel_format)
{
MessageBox
(
NULL,
"Problème lors du choix du format d'affichage.",
"ERREUR !",
MB_OK|MB_ICONERROR
);
exit(1);
}

if(!SetPixelFormat(hdc, pixel_format, &pfd))
{
MessageBox
(
NULL,
"Problème lors de l'initialisation du format d'affichage.",
"ERREUR !",
MB_OK|MB_ICONERROR
);
exit(1);
}
}

void Resize(int width, int height)
{
glViewport(0, 0, width, height);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluPerspective(45.0f, (float)width/(float)height, 0.1f, 100.0f);

glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
}

void InitGL()
{
GLfloat mat_specular[]={1.0, 1.0, 1.0, 1.0};
GLfloat mat_diffuse[]={1.0, 1.0, 1.0, 1.0};

GLfloat light_specular[]={1.0, 1.0, 1.0, 1.0};

glLightfv(GL_LIGHT0, GL_SPECULAR, light_specular);
glMaterialfv(GL_FRONT, GL_DIFFUSE, mat_diffuse);
glMaterialfv(GL_FRONT, GL_SPECULAR, mat_specular);
glMaterialf(GL_FRONT, GL_SHININESS, 128.0);
glEnable(GL_LIGHTING);
glEnable(GL_LIGHT0);
glEnable(GL_DEPTH_TEST);
}

void Draw()
{
GLfloat light_position[]={0.0, 1.0, 1.0, 0.0};
glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);

glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glRotatef(-(float)angleY, 0, 1, 0);
glTranslatef(-1.5f-transX, -1.5f, -transZ);

glLightfv(GL_LIGHT0, GL_POSITION, light_position);
glutSolidSphere(1.0, 50.0, 50.0);
SwapBuffers(hdc);
}

LRESULT CALLBACK
WindowProc(HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam)
{
int virtual_key_code=(int)wparam;

switch(msg)
{
case WM_CREATE:
hdc=GetDC(hwnd);
SetupPixelFormat(hdc);
hrc=wglCreateContext(hdc);
if(!hrc)
SendMessage(hwnd, WM_CLOSE, 0, 0);
wglMakeCurrent(hdc, hrc);
InitGL();
break;

case WM_PAINT:
Draw();
break;

case WM_SIZE:
Resize(LOWORD(lparam), HIWORD(lparam));
break;

case WM_CLOSE:
wglMakeCurrent(NULL, NULL);
if(hrc)
wglDeleteContext(hrc);
ReleaseDC(hwnd, hdc);
PostQuitMessage(0);
break;

case WM_KEYDOWN:

switch(virtual_key_code)
{
case VK_UP:
transX-=(float)sin(angleY*PI/180);
transZ-=(float)cos(angleY*PI/180);
break;

case VK_DOWN:
transX+=(float)sin(angleY*PI/180);
transZ+=(float)cos(angleY*PI/180);
break;

case VK_RIGHT:
angleY=(angleY-5)%360;
break;

case VK_LEFT:
angleY=(angleY+5)%360;
break;

default:
SendMessage(hwnd, WM_PAINT, 0, 0);
break;
}
break;

default:
return DefWindowProc(hwnd, msg, wparam, lparam);
}

return 0;
}

int WINAPI
WinMain(HINSTANCE hinstance,
HINSTANCE hprevinstance,
LPSTR lpcmdline,
int ncmdshow)
{
WNDCLASS winclass;
HWND hwnd;
MSG msg;

winclass.style=CS_DBLCLKS|CS_OWNDC|CS_HREDRAW|CS_

VREDRAW;
winclass.lpfnWndProc=WindowProc;
winclass.cbWndExtra=0;
winclass.hInstance=hinstance;
winclass.hIcon=0;
winclass.hCursor=LoadCursor(NULL, IDC_ARROW);
winclass.hbrBackground=GetStockObject(BLACK_BRUSH

);
winclass.lpszMenuName=NULL;
winclass.lpszClassName="MACLASSE";

if(!RegisterClass(&winclass))
exit(1);

hwnd=CreateWindow("MACLASSE",
"OpenGL",
WS_OVERLAPPEDWINDOW|WS_VISIBLE,
0,0,
320,240,
NULL,
NULL,
hinstance,
NULL);

if(!hwnd)
exit(1);

window_handle=hwnd;

while(1)
{
if(PeekMessage(&msg, window_handle, 0, 0, PM_REMOVE))
{
if(msg.message==WM_QUIT)
exit(0);
TranslateMessage(&msg);
DispatchMessage(&msg);
}
}

return EXIT_SUCCESS;
}

Fais le tourner, si c'est ce mouvemement de caméra que tu souhaites je te l'explique sinon je vois pas trop....

C'est tout à fait cet effet que je recherchais. Je veux bien que tu me donne kke explications.

Zeross

Je crois avoir compris ce que tu souhaites faire mais je suis pas sûr. J'avais fait un truc dans le genre il y a quelques temps c'était mon premier programme OpenGL donc c'est un peu dégueu mais c'est pas le sujet :D voilà le source :

#include <windows.h>
#include <stdlib.h>
#include <math.h>
#include <gl/gl.h>
#include <gl/glu.h>
#include <gl/glut.h>

#define BITS_PAR_PIXEL 16
#define Z_BUFFER 16

#define PI 3.14159265

HDC hdc=NULL;
HGLRC hrc=NULL;
HWND window_handle=NULL;

int distance=5;
int angleX=0,angleY=0;
float transX=0, transZ=5;

void SetupPixelFormat(HDC hdc)
{
int pixel_format;
PIXELFORMATDESCRIPTOR pfd=
{
sizeof(PIXELFORMATDESCRIPTOR),
1,
PFD_DRAW_TO_WINDOW|
PFD_SUPPORT_OPENGL|
PFD_DOUBLEBUFFER,
PFD_TYPE_RGBA,
BITS_PAR_PIXEL,
0, 0, 0, 0, 0, 0,
0,
0,
0,
0, 0, 0, 0,
Z_BUFFER,
0,
0,
0,
0,
0, 0, 0
};

pixel_format=ChoosePixelFormat(hdc, &pfd);
if(!pixel_format)
{
MessageBox
(
NULL,
"Problème lors du choix du format d'affichage.",
"ERREUR !",
MB_OK|MB_ICONERROR
);
exit(1);
}

if(!SetPixelFormat(hdc, pixel_format, &pfd))
{
MessageBox
(
NULL,
"Problème lors de l'initialisation du format d'affichage.",
"ERREUR !",
MB_OK|MB_ICONERROR
);
exit(1);
}
}

void Resize(int width, int height)
{
glViewport(0, 0, width, height);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluPerspective(45.0f, (float)width/(float)height, 0.1f, 100.0f);

glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
}

void InitGL()
{
GLfloat mat_specular[]={1.0, 1.0, 1.0, 1.0};
GLfloat mat_diffuse[]={1.0, 1.0, 1.0, 1.0};

GLfloat light_specular[]={1.0, 1.0, 1.0, 1.0};

glLightfv(GL_LIGHT0, GL_SPECULAR, light_specular);
glMaterialfv(GL_FRONT, GL_DIFFUSE, mat_diffuse);
glMaterialfv(GL_FRONT, GL_SPECULAR, mat_specular);
glMaterialf(GL_FRONT, GL_SHININESS, 128.0);
glEnable(GL_LIGHTING);
glEnable(GL_LIGHT0);
glEnable(GL_DEPTH_TEST);
}

void Draw()
{
GLfloat light_position[]={0.0, 1.0, 1.0, 0.0};
glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);

glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glRotatef(-(float)angleY, 0, 1, 0);
glTranslatef(-1.5f-transX, -1.5f, -transZ);

glLightfv(GL_LIGHT0, GL_POSITION, light_position);
glutSolidSphere(1.0, 50.0, 50.0);
SwapBuffers(hdc);
}

LRESULT CALLBACK
WindowProc(HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam)
{
int virtual_key_code=(int)wparam;

switch(msg)
{
case WM_CREATE:
hdc=GetDC(hwnd);
SetupPixelFormat(hdc);
hrc=wglCreateContext(hdc);
if(!hrc)
SendMessage(hwnd, WM_CLOSE, 0, 0);
wglMakeCurrent(hdc, hrc);
InitGL();
break;

case WM_PAINT:
Draw();
break;

case WM_SIZE:
Resize(LOWORD(lparam), HIWORD(lparam));
break;

case WM_CLOSE:
wglMakeCurrent(NULL, NULL);
if(hrc)
wglDeleteContext(hrc);
ReleaseDC(hwnd, hdc);
PostQuitMessage(0);
break;

case WM_KEYDOWN:

switch(virtual_key_code)
{
case VK_UP:
transX-=(float)sin(angleY*PI/180);
transZ-=(float)cos(angleY*PI/180);
break;

case VK_DOWN:
transX+=(float)sin(angleY*PI/180);
transZ+=(float)cos(angleY*PI/180);
break;

case VK_RIGHT:
angleY=(angleY-5)%360;
break;

case VK_LEFT:
angleY=(angleY+5)%360;
break;

default:
SendMessage(hwnd, WM_PAINT, 0, 0);
break;
}
break;

default:
return DefWindowProc(hwnd, msg, wparam, lparam);
}

return 0;
}

int WINAPI
WinMain(HINSTANCE hinstance,
HINSTANCE hprevinstance,
LPSTR lpcmdline,
int ncmdshow)
{
WNDCLASS winclass;
HWND hwnd;
MSG msg;

winclass.style=CS_DBLCLKS|CS_OWNDC|CS_HREDRAW|CS_
VREDRAW;
winclass.lpfnWndProc=WindowProc;
winclass.cbWndExtra=0;
winclass.hInstance=hinstance;
winclass.hIcon=0;
winclass.hCursor=LoadCursor(NULL, IDC_ARROW);
winclass.hbrBackground=GetStockObject(BLACK_BRUSH
);
winclass.lpszMenuName=NULL;
winclass.lpszClassName="MACLASSE";

if(!RegisterClass(&winclass))
exit(1);

hwnd=CreateWindow("MACLASSE",
"OpenGL",
WS_OVERLAPPEDWINDOW|WS_VISIBLE,
0,0,
320,240,
NULL,
NULL,
hinstance,
NULL);

if(!hwnd)
exit(1);

window_handle=hwnd;

while(1)
{
if(PeekMessage(&msg, window_handle, 0, 0, PM_REMOVE))
{
if(msg.message==WM_QUIT)
exit(0);
TranslateMessage(&msg);
DispatchMessage(&msg);
}
}

return EXIT_SUCCESS;
}

Fais le tourner, si c'est ce mouvemement de caméra que tu souhaites je te l'explique sinon je vois pas trop....

pymousses

darkoli a écrit a écrit :

c'est pas clair cette histoire !!!
qu'est ce que tu appelle un truc 'pas reel' ?
Tu veux que le mouvement soit fait douement en plusieurs etapes ?

Pour être plus explicite, je donne mon code source, vous vous renderez mieux compte de mon problème :

Je veux donc que le personnage tourne suivant la sourie, et avance suivant les touches directionnelles. C'est un programme de base, mais j'essaye de gerer une camera d'un jeu du type Quake, donc je fais des essais.
Voilà mon code source : J'attend vos réponses...

code source :
--------------

/*
From pymousses
*/
#include <glut.h>
#include <math.h>
#include <glu.h>
#include <stdio.h>
#include <gl.h>

void InitGL();
void Reshape(int width, int height);
void Draw();
void GestionClavier(unsigned char, int, int);
void GESTIONSOURIE(int,int);

int Win1;
double a=0; //Angles
int etatsourie[2]={0,0}; /* enregistre les coordonnées précedentes de la sourie */
double dte=0,distance=25,distancee=25.0;
int R;

////////////////////////////////////////////////////////////////////////////

int main( int argc, char *argv[ ], char *envp[ ] )
{
glutInit(&argc,argv);
glutInitWindowSize(640,480);
glutInitDisplayMode(GLUT_RGBA | GLUT_DOUBLE | GLUT_DEPTH);

Win1 = glutCreateWindow("Maison virtuelle !" );

InitGL();
glutReshapeFunc(Reshape);
glutDisplayFunc(Draw);
glutSpecialFunc(GestionClavier);
glutPassiveMotionFunc(GESTIONSOURIE);
glutFullScreen();

glutMainLoop();

return 0;
}

////////////////////////////////////////////////////////////////////////////
void GestionClavier(unsigned char key, int x, int y)
{

R=0;
switch (key) {

case GLUT_KEY_LEFT :
dte+=0.2;
break;
case GLUT_KEY_UP :
distance-=0.5;
break;
case GLUT_KEY_RIGHT :
dte-=0.2;
break;
case GLUT_KEY_DOWN :
distance+=0.5;
break;
case GLUT_KEY_END :
exit(0);
break;

}

}

//////////////////////////////////////////////////
//////////////////////////

void GESTIONSOURIE (int x,int y) {
int resx,resy;
R=1;

resx=etatsourie[0] - x;
resy=etatsourie[1] - y;

if (resx <0) {
a+=5;
etatsourie[0]=x;
}
else if (resx >0) {
a-=5;
etatsourie[0]=x;
}

else if (resy <0) {
/*etatsourie[1]=y;
b+=1; */
}

else {
/* etatsourie[1]=y;
b-=1; */
}

if (x==0) {
a-=5;
etatsourie[0]=x;
}

if (x==1023) {
a+=5;
etatsourie[0]=x;
}

}

//////////////////////////////////////////////////////////////////////////////

void Reshape(int width, int height)
{
glViewport(0,0,width,height);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluPerspective(45,width/height,1,100);
glMatrixMode(GL_MODELVIEW);
}

////////////////////////////////////////////////////////////////////////////

void Draw()
{

glClear(GL_COLOR_BUFFER_BIT);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
gluLookAt(0,1,3,0,0,0,0,5,0);

/* -------------- Action suivant touches tapées ou souris deplacée ------------------- */

glRotated(a,0,1,0); /* rotation autour axe y | */
glTranslatef(0,0,-distance); /* key up or down */
glTranslatef(dte,0,0); /* key right or left */

/* -------------- Fin de l'Action suivant touche tapées ou souris deplacée ------------------- */

glBegin(GL_QUADS);

glColor3d(1,0,0);
glVertex3i(0,0,0-10);glVertex3i(1,0,0-10);glVertex3i(1,1,0-
10);glVertex3i(0,1,0-10);

glVertex3i(0,0,0-10);glVertex3i(0,0,1-10);glVerte
x3i(0,1,1-10);glVertex3i(0,1,0-10);
glVertex3i(0,0,1-10);glVertex3i(1,0,1-10);glVerte
x3i(1,1,1-10);glVertex3i(0,1,1-10);
glVertex3i(1,0,1-10);glVertex3i(1,0,0-10);glVerte
x3i(1,1,0-10);glVertex3i(1,1,1-10);

/* sol */
glVertex3i(0,0,0-10);glVertex3i(0,0,1-10);glVerte
x3i(1,0,1-10);glVertex3i(1,0,0-10);

glColor3d(1,1,0);
glVertex3i(0,1,1-10);glVertex3i(1,1,1-10);glVertex3f(1,1.5,0.5-
10);glVertex3f(0,1.5,0.5-10);
glVertex3i(0,1,0-10);glVertex3i(1,1,0-10);glVerte
x3f(1,1.5,0.5-10);glVertex3f(0,1.5,0.5-10);

glEnd();

glBegin(GL_TRIANGLES);

/* toit */

glColor3d(0,1,0);
glVertex3f(0,1,0-10);glVertex3f(0,1.5,0.5-10);glVe
rtex3i(0,1,1-10);

glColor3d(0,1,0);
glVertex3f(1,1,0-10);glVertex3f(1,1.5,0.5-10);glVe
rtex3i(1,1,1-10);

glEnd();

glutSwapBuffers();
glutPostRedisplay();

}

////////////////////////////////////////////////////////////////////////////

void InitGL()
{

glEnable(GL_DEPTH_TEST);
glEnable(GL_LIGHTING); // Active l'éclairage
glEnable(GL_LIGHT0);
glEnable(GL_COLOR_MATERIAL);

}

//Fin///////////////////////////////////////////////

darkoli

c'est pas clair cette histoire !!!
qu'est ce que tu appelle un truc 'pas reel' ?
Tu veux que le mouvement soit fait douement en plusieurs etapes ?

pymousses

oliv5 a écrit a écrit :

Darkoli a raison, je pense qu'il est plus simple que tu fasse tourner tous les objets. C'est relativement simple : juste un glRotate au début de l'affichage de ta scene.
Cela dit, question rapidité, vaut-il mieux faire comme ca ou bouger la caméra ???

J'y ai bien pensé mais quand je fait un glRotate puis un glTranslate, forcement puisque les transformations affectent aussi le repère le glTranslate d'effectue sur le nouveau repère modifié par le glRotate. Ce qui fait, un effet qui ne parrait pas reel. Il faut que le repere soit fixe.

darkoli

ben dans tout les cas si tu fais un gluLookAt() pour bouger la camera ou faire bouger tes objet avec glRotate et glTranslate reviens au meme parce que à la fin faire bouger ta camera c'est faire bouger tes objets parce que lors qu calcul de la position des objets c'est eux qui sont placé devant la camera (qui est virtuel de toute facon car elle n'existe pas mais elle represente simplement le point de vue).

Donc l'avantage du gluLookAt c'est que tu donne la positonde la camera (point de vue), la direction du "regard" et aussi tu lui dis aussi ou se trouve le haut de la camera. Donc pour l'utilisateur c'est tres facile et du point de vue calcul ce n'est pas beaucoup plus complexe (y'a quelques matrices quoi et ptet meme un ptit peu de quaternions car c'est bien cool dans ce cas là !!!)

[edtdd]--Message édité par darkoli--[/edtdd]

oliv5

Darkoli a raison, je pense qu'il est plus simple que tu fasse tourner tous les objets. C'est relativement simple : juste un glRotate au début de l'affichage de ta scene.
Cela dit, question rapidité, vaut-il mieux faire comme ca ou bouger la caméra ???

darkoli

ben dans ton cas par exemple tu veux par exemple tourner un peu a gauche et avancer d'un metre. Donc en fait tout les objets ne bouges pas mais c'est la camera qui bouge.

y'a deux solution tu as soit l'instrcution gluLookAt(xa,ya,za,xb,yb,zb,xc,yc,zc) qui te permet de 'poser' la camera ou tu le souhaites.

sinon tu fais bouger les objets vers toi (tous).

Donc si tu tourne à gauche de 30°, les objets tourne à droite de 30° et si tu avance, ben les objets y reculent !!!

youdontcare

regarde les matrices et comment exprimer des vecteurs dans différents repères.

pymousses

Je cherche comment on pourrait faire pour faire une rotation d'un certain angle, puis un translation (Z) par rapport à un repère fixe.
Dans la réalité ca ferrait un truc du genre je me tourne un peu puis j'avance de qqe pas. (gestion de camera pour jeu en 3D).
HELP à ceux qui maitrise !!!!