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.