Discussion :

[jcloupgarou]

Bonjour,
je cherche à activer l'antialiasing dans mon appli 3D et je tombe sur les incontournables tutoriaux de NeHe. Je trouve sa description du multiSampling inbitable. Apres un moment de recherche sur google, rien ou pas grand chose de plus que ce tut de NeHe.
L'un d'entre vous aurez-t-il deja coder le multisampling ?
Pas moyen de trouver une explication simple de ce qu'il faut mettre en place pour l'antialiasing avec le multisampling ! Combien de tutoriaux rabacchent a tort le POLYGON_SMOOTH, GL_HINT,.... qui ne marche en fait pas correctement !
Merci de vous pencher sur ce probleme, afin de, pourquoi pas, donner naissance à un tut efficace traitant du multisampling (et en français ;o) )
Bonne journée.
Jc.

[Lung]

Si tu trouves quelque chose, ça m'intéresse aussi.
J'ai le même problème.

Des explications comme celle-là :
http://www.intel.com/design/pca/comp...s/30327202.pdf

C'est pas limpide ...

[gybe]

Si tu veux activer le multi sampling au niveau de l'application

1- Tu te crées un context bidon.

2- Dans ce Context tu vas chercher la fonction
wglChoosePixelFormatARB

3- Tu supprimes ce context.

Voici un exemple:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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

void COGLContext::InitEntryPoints(HWND hwnd)
{
HDC hdc = ::GetDC(hwnd);
PIXELFORMATDESCRIPTOR pfd;
int nPixelFormat;
BOOL bOk = FALSE;
// Clear memory
ZeroMemory( &pfd, sizeof( pfd ) );
// set the pixel format for the DC
pfd.nSize = sizeof( pfd );
pfd.nVersion = 1;
pfd.dwFlags = PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL | PFD_DOUBLEBUFFER;
pfd.iPixelType = PFD_TYPE_RGBA;
pfd.cColorBits = 32;
pfd.cDepthBits = 0;
pfd.cStencilBits = 0;
pfd.cAlphaBits = 8;
pfd.cRedBits = 8;
pfd.cGreenBits = 8;
pfd.cBlueBits = 8; 
nPixelFormat = ChoosePixelFormat(hdc, &pfd);
SetPixelFormat(hdc, nPixelFormat, &pfd);
 
HGLRC hglrc = wglCreateContext(hdc);
wglMakeCurrent(hdc, hglrc);

wglMakeContextCurrentARB = (PFNWGLMAKECONTEXTCURRENTARBPROC)wglGetProcAddress("wglMakeContextCurrentARB");
wglChoosePixelFormatARB = (PFNWGLCHOOSEPIXELFORMATARBPROC)wglGetProcAddress("wglChoosePixelFormatARB");
wglMakeCurrent(NULL, NULL);
wglDeleteContext(hglrc);
ReleaseDC(hwnd, hdc);
}

4- Ensuite tu crées un nouveau context en utilisant wglChoosePixelFormatARB pour choisir le pixel format

5- Tu spécifies les attributs du pixel format un peu comme ça:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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

BOOL COGLContext::InitContext(HDC a_hDC)
{
PIXELFORMATDESCRIPTOR pfd;
int nFormat;
unsignedint nCount;
BOOL bOk = FALSE;
// Clear memory
ZeroMemory( &pfd, sizeof( pfd ) );
// set the pixel format for the DC
pfd.nSize = sizeof( pfd );
pfd.nVersion = 1;
m_hDC = a_hDC;
int nAttr[] =
{
WGL_DRAW_TO_WINDOW_ARB, TRUE,
WGL_SUPPORT_OPENGL_ARB, TRUE,
WGL_SAMPLE_BUFFERS_ARB, (m_nMSAA>1)?TRUE:FALSE,
WGL_SAMPLES_ARB, (m_nMSAA>1)?m_nMSAA:0,
WGL_RED_BITS_ARB, 8,
WGL_GREEN_BITS_ARB, 8,
WGL_BLUE_BITS_ARB, 8,
WGL_ALPHA_BITS_ARB, 8,
WGL_DEPTH_BITS_ARB, 24,
WGL_DOUBLE_BUFFER_ARB, TRUE,
0
};
// choose a pixel format that meets our minimum requirements
wglChoosePixelFormatARB(m_hDC,(constint*)nAttr,NULL,1,&nFormat,&nCount);
// Set this pixelformat
bOk = SetPixelFormat( m_hDC, nFormat, &pfd );
// Create and enable the render context (RC)
m_hRenderDC = wglCreateContext( m_hDC );
bOk = wglMakeCurrent( m_hDC, m_hRenderDC );
// Get All The pixel format extension here
return TRUE;
}

Ce qui t'intéresse pour le multisampling sont les tokens WGL_SAMPLE_BUFFERS_ARB et WGL_SAMPLES_ARB.

[bafman]

principe du multisampling :
en gros, pour effectuer de l'antialiasing, ce qui est fait avec le multisampling, c'est d'utiliser plusieurs buffer. quand on dessin un polygone, le drivers va dessiner dans le back buffer standard, mais il va aussi ecrire des informations sur les bord dans les autres buffer, puis, une fois les calcules d'affichages terminé, il ajoute l'anti aliasing en fonction de ce qui a été ecrit dans les autres buffers (oui je sais, ce n'est pas tres clair, mais moi aussi j'ai pas tout compris )
ce qu'il faut retenir de tout ca, c'est que des qu'on utilise du multisampling, on multiplie les buffer utilisé par la carte graphique (sur une radeon 9800, l'antialiasing max utilise 6 buffers je crois) et donc on bouffer enormement de memoire graphique en plus d'ajouter du temps de calcule.
et c'est d'ailleur de cette utilisation de plusieurs buffer que viens le terme multi sampling car chaque fragment est traité sur plusieurs buffers en réalité...

sinon, pour activer le multi samplinbg en openGL, il existe en gros 2 solution :

• la solution presenté par gybe qui est propre a windows, si tu veut faire du multisampling sous linux il faudra tout refaire en glx.
• utiliser des lib portable comme glut ou SDL qui permettent de l'activer facilement

les dernieres version de glut permettent d'activer l'antialiasing en passant GLUT_MULTISAMPLING lors de l'initalisation je crois (j'ai lu ca rapidement dans le red book 1.4, mais comme je ne l'ai pas sous la mains, je ne suis pas sur de mon coup la ) et apres il suffit de l'activer avec un petit glEnable(GL_MULTISAMPLE_ARB) ou un truc du genre...
sous la SDL, c'est tout aussi facile, lors du passage des parametre de la fenetre openGL, il suffit de faire

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
 
// utilisation de l'antialiasing possible ?
if (SDL_GL_SetAttribute( SDL_GL_MULTISAMPLEBUFFERS, 1 ) == -1)
{
    fprintf(stderr,"impossible d'initialiser SDL_GL_MULTISAMPLEBUFFERS a %d\n", 1);
}
// nombre de tampons utilisé pour l'antialiasing (la valeur utilisé depend de la carte graphique)
if (SDL_GL_SetAttribute( SDL_GL_MULTISAMPLESAMPLES, 6 ) == -1)
{
    fprintf(stderr,"impossible d'initialiser SDL_GL_MULTISAMPLESAMPLES a %d\n", fsaa);
}

avant la creation de la fenetre pour avoir un bel anti aliasing

[shenron666]

Merci Bafman pour tes explications relativement complètes
suite au post de jcloupgarou, je suis allé voir le tutorial de nehe sur le multisampling qui, comme tous les tutoriaux de nehe est en win32 et pas de portage SDL (ni glut je crois)
Je ne demandais justement comment faire bah voilà

encore merci Bafman

[jcloupgarou]

Merci messieurs pour ce bel effort, je vais tester les deux techniques ma foi fort bien détaillées par vous meme. Desole pour la reactivite, je suis en phase d'optimisation et de débug de mon appli, j'ai pas mal de détails de visu à régler ! En tout cas pour l'antialiasing, merci de votre collaboration.
Bonne journée, Jc.

[Lung]

Où trouver les fonctions wglMakeContextCurrentARB et wglChoosePixelFormatARB ?
J'ai essayé le code proposé par gybe, mais ça ne compile pas.

[shenron666]

il s'agit d'extensions OpenGL spécifiques windows, et comme toutes les extensions OpenGL il faut le fichier adéquat (ici ce sera wglext.h)

un peu de recherche dans la FAQ :
http://jeux.developpez.com/faq/openg...ions#EXT_glext

et il ne te reste plus qu'à télécharger wglext.h et à l'inclure

[Lung]

il s'agit d'extensions OpenGL spécifiques windows, et comme toutes les extensions OpenGL il faut le fichier adéquat (ici ce sera wglext.h)

un peu de recherche dans la FAQ :
http://jeux.developpez.com/faq/openg...ions#EXT_glext

et il ne te reste plus qu'à télécharger wglext.h et à l'inclure

L'ennui, c'est que c'est un *.h
Je développe en Delphi (beaucoup plus facile pour moi). Donc, je ne peux rien faire d'une bibliothèque C.
Il n'existe pas autre chose ?
Où, l'utilisation de fonctions OpenGL étendues, nécessite de développer obligatoirement en C ?

[shenron666]

désolé, je n'avais pas fait attention à ce détail important
il y a un site traitant d'OpenGL sous delphi : http://www.delphi3d.net/
je pense que tu le connais
peut-etre y trouveras tu des informations intéressantes au sujet des extensions wgl

[Lung]

il y a un site traitant d'OpenGL sous delphi : http://www.delphi3d.net/
je pense que tu le connais

Non. Il faut dire qu'il est en anglais (ça a tendance à me faire fuir ).
Déjà que lire et comprendre une doc sur OpenGL, c'est pas simple (pour un débutant comme moi); alors, si en plus c'est en anglais ...

peut-etre y trouveras tu des informations intéressantes au sujet des extensions wgl

Merci quand même pour le lien.
Je vais faire un effort, et essayer de réveiller mes notions d'anglais ...

[Laurent Gomila]

Je vais te mâcher un peu le travail.

Apparemment tu peux trouver GLext.pas dans Dot (module OpenGL pour Delphi) :
http://www.delphi3d.net/download/dot.zip

Explications ici :
http://www.delphi3d.net/dot/GLunits.htm

[Lung]

Je regarde ça, dès que possible.

[Lung]

J'ai un problème avec la GLU.
http://www.developpez.net/forums/sho...4&postcount=19

C'est pas sensé être standard ?

[themoye]

Bonjour à tous

Voilà, je cherche moi aussi un petit anti-aliasing à mettre dans mon programme openGL.
Toutes ces explications sont nikel, completes, rien à redire!

Mais serait-il possible de donner les principaux morceaux de code (comme il a été fait en haut par gybe, mais sans la sdl et sans passer par wgl.h?
Car j'utilise deja glext.h (les fonctions sitées plus haut doivent être globalement les mêmes mais avec un nom different?) ainsi que la glew.h, pas envi d'ajouter en plus la sdl ou la wgl ^^

J'ai fais pas mal de recherche sur le net, mais je n'ai pas trouvé grand chose pour faire marcher ce multisampling (avec la glut) et glext.h.

Ou alors en GLSL?
Ca m'interesse aussi

Et pourquoi ne pas faire une FAQ sur le mutlisampling?


Merci d'avaaance, tout type d'aide sera la bienvenue ^^

[shenron666]

sans sdl et sans wgl ? ça va pas être facile
surtout que tu dois faire appel à des fonctions spécifiques à la plateforme

déjà tu utilises quoi comme bibliothèque de fenêtrage ?
sous quel os ?

quand au glsl, c'est autre chose
ça ne sert pas à faire de l'antialiasing
bien que je pense que c'est possible (en passant par un FBO ?) c'est loin d'être la méthode idéale

[themoye]

Salut shenron666 !
Donc pour répondre à tes questions, je créé ma fenêtre avec la glut, sous windows, mais le principe c'est que le code puisse rester portable.

Pour les extensions ARB, pas de soucis je peux utiliser glext.h (j'ai aussi une autre bibliothèque glew, qui semble plus simple que glext).

Ensuite je pense moi aussi qu'il est possible de faire le multisampling grace au GLSL, mais comme je débute et que les sources ne sont pas très importantes, je pense que je vais essayé de le faire directement en openGL (à moins que qqn est quelque chose à proposer en GLSL ^^).

[shenron666]

Salut shenron666 !
Donc pour répondre à tes questions, je créé ma fenêtre avec la glut, sous windows, mais le principe c'est que le code puisse rester portable.

tu n'as pas regardé dans la OpenGL, tu vas te faire dessus
http://jeux.developpez.com/faq/openg..._multisampling

[themoye]

Bien sur que j'ai regardé. ^^

Mon problème n'est pas de l'activer, mais de savoir s'en servire

C'est bien beau de lui signaler que l'on va utiliser le multisampling, mais il y a des paramètres et autres petites choses à initialiser et tt et tt!
C'est là dessus que je bute en fait...

J'imagine que même en passant par la glut, je suis obligé de redefinir le format de pixel?
Et si c'est le cas, je peux toujours créer ma fenetre avec la glut ou faut-il obligatoirement que je la créer en openGL pure?

Et ainsi de même pour le reste de l'initialisation avant de pouvoir utiliser le Multisampling

[shenron666]

Mon problème n'est pas de l'activer, mais de savoir s'en servire

c'est pas compliqué, un glEnable avant le rendu, un glDisable après le rendu
ou un glEnable au début du programme et un glDisable à la fin du programme

C'est bien beau de lui signaler que l'on va utiliser le multisampling, mais il y a des paramètres et autres petites choses à initialiser et tt et tt!
C'est là dessus que je bute en fait...

bah non, tu actives le multisampling et c'est tout

dans la faq tu vois qu'en une seule ligne tu crées une fenêtre en multisampling, il te reste à l'activer avant de rendre ta scène :

glEnable(GL_MULTISAMPLE_ARB);

// Render The Scene

glDisable(GL_MULTISAMPLE_ARB);

bien sûr il faut que tu t'assures que le multisampling est activé en vérifiant l'exetnsion dans le contexte opengl

J'imagine que même en passant par la glut, je suis obligé de redefinir le format de pixel?

non, c'est glut qui s'en occupe, il est là pour ça

Et si c'est le cas, je peux toujours créer ma fenetre avec la glut ou faut-il obligatoirement que je la créer en openGL pure?

opengl ne sait pas créer de fenêtre, c'est pour ça qu'on utilise des bibliothèques de fenêtrage comme glut afin de conserver la portabilité
si opengl (qui est portable) savait créer des fenêtres, on se ferait pas ch...