[Yes::Engine] Scintillement avec DrawIndexedPrimitives mais pas avec DrawPrimitives

Version imprimable

Bonjour,

Je viens encor une nouvelle fois vers vous car je me trouve confronter à un problème avec le tuto sur le moteur 3D Yes::Engine.

Je suis entrain d'implémenter une classe C_Model mais j'ai rencontrer un problème de scintillement.
J'ai donc voulu faire un test pour voir ou se situe le problème.

Si j'essaye de faire l'exemple suivant comme dans le tuto tous se passe bien (affichage du rectangle) :

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
 
        // Création du vertex buffer - rectangle centré en (0, 0)
	TVertex Vertices[] =
	{
		{ -200, -100, 0, Renderer.ConvertColor(0xFF008080) },
		{ 200, -100, 0, Renderer.ConvertColor(0xFF303050) },
		{ -200, 100, 0, Renderer.ConvertColor(0xFF505000) },
		{ 200, 100, 0, Renderer.ConvertColor(0xFF1090F0) },
	};
	m_VertexBuffer = Renderer.CreateVertexBuffer(4, 0, Vertices);
 
	// Création de la déclaration de vertex
	TDeclarationElement Decl[] =
	{
		{ 0, ELT_USAGE_POSITION, ELT_TYPE_FLOAT3 },
		{ 0, ELT_USAGE_DIFFUSE, ELT_TYPE_COLOR }
	};
	m_Declaration = Renderer.CreateVertexDeclaration(Decl);
 
 
     ///////////////////////////////////////////////
     // Dans la fonction Render
     //////////////////////////////////////////////////
Renderer.BeginScene(); // glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
        // Affichage du rectangle
	Renderer.SetDeclaration(m_Declaration);
	Renderer.SetVertexBuffer(0, m_VertexBuffer);
	Renderer.DrawPrimitives(PT_TRIANGLESTRIP, 0, 2);
Renderer.EndScene(); // SwapBuffers(m_Handle);

Mais lorsque j'essaye d'afficher un Cube avec les index la j'ai un scintillement qui apparait.
Voici le code tester pour le Cube :

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
 
        // Création du vertex buffer - Cube
	T_Vertex Vertices[] =
	{
		{ -1.0f, 1.0f, -1.0f, Renderer.ConvertColor(0xFF008080) },
		{ -1.0f, -1.0f, -1.0f, Renderer.ConvertColor(0xFF303050) },
		{ -1.0f, 1.0f, 1.0f, Renderer.ConvertColor(0xFF505000) },
		{ -1.0f, -1.0f, 1.0f, Renderer.ConvertColor(0xFF1090F0) },
 
		{ 1.0f, 1.0f, 1.0f, Renderer.ConvertColor(0xFF1090F0) },
		{ 1.0f, -1.0f, 1.0f, Renderer.ConvertColor(0xFF1090F0) },
		{ 1.0f, 1.0f, -1.0f, Renderer.ConvertColor(0xFF1090F0) },
		{ 1.0f, -1.0f, -1.0f, Renderer.ConvertColor(0xFF1090F0) },
	};
	m_VertexBuffer = Renderer.CreateVertexBuffer(8, 0, Vertices);
 
	// Création de l'index buffer - Cube
	T_Index Indices[] = { 0, 1, 2, 2, 1, 3,
		4, 5, 6, 6, 5, 7,
		3, 1, 5, 5, 1, 7,
		0, 2, 6, 6, 2, 4,
		6, 7, 0, 0, 7, 1,
		2, 3, 4, 4, 3, 5 };
	m_indexBuffer = Renderer.CreateIndexBuffer(36, 0, Indices);
 
	// Création de la déclaration de vertex
	TDeclarationElement Decl[] =
	{
		{ 0, ELT_USAGE_POSITION, ELT_TYPE_FLOAT3 },
		{ 0, ELT_USAGE_DIFFUSE, ELT_TYPE_COLOR }
	};
	m_Declaration = Renderer.CreateVertexDeclaration(Decl);
 
 
     ///////////////////////////////////////////////
     // Dans la fonction Render
     //////////////////////////////////////////////////
 
        // Affichage du Cube
Renderer.BeginScene(); // glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
	Renderer.SetDeclaration(m_Declaration);
	Renderer.SetVertexBuffer(0, m_VertexBuffer);
	Renderer.SetIndexBuffer(m_indexBuffer);
	Renderer.DrawPrimitives(PT_TRIANGLELIST, 0, m_indexBuffer.GetCount() / 3);
Renderer.EndScene(); // SwapBuffers(m_Handle);

J'aurais aimer savoir si quelqu'un était tomber sur ce problème ou si quelqu'un avait une proposition du à se problème?

Je précise également j'utilise les même configuration que le tuto l'initialisation de Opengl :

Code:

1
2
3
4
5
6
7
 
// States par défaut
    glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
    glClearDepth(1.0f);
    glClearStencil(0x00);
    glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);
    glEnable(GL_DEPTH_TEST);

J'ai également essayer de rajouter le code ci-dessous pour désactiver après le rendu les buffer mais aucun résultat :

Code:

1
2
3
4
5
6
7
8
 
        glColor4f(1, 1, 1, 1);
	glDisableClientState(GL_VERTEX_ARRAY);
	glDisableClientState(GL_NORMAL_ARRAY);
	glDisableClientState(GL_COLOR_ARRAY);
 
	glBindBufferARB(GL_ARRAY_BUFFER_ARB, 0);
	glBindBufferARB(GL_ELEMENT_ARRAY_BUFFER_ARB, 0);

21/10/2015, 05h22
ksta.k
Bon après de longue recherche je n'arrive toujours pas à savoir les raison mais j'ai réussie ce que je voulais faire (faire fonction la fonction avec les index) en utilisant pas les Extensions opengl mais "Glew"

voici donc ce que j'ai modifier dans le renderer OpenGL :
Code:

1 2 3 4 5 // avant glGenBuffersARB(1, &VertexBuffer); // après glGenBuffers(1, &VertexBuffer);
Il faut enlever tous les ARB et initialiser glew dans la fonction Initialize du renderer OpenGL :
Code:

1 2 3 4 5 /* initialisation de GLEW */ GLenum resultInitGlew = glewInit(); if (resultInitGlew != GLEW_OK) throw ("Initialize Glew");
Par contre je n'arrive pas à comprendre pourquoi cela ne fonction pas avec les extensions des que j'utilise les index :(

Si quelqu'un peut m'expliquer la raison sa serait cool car j'aimerais bien la connaître car je suis dans le flou totale.
21/10/2015, 11h12
dragonjoker59

Euh... tu dis que tu essaies d'utiliser les extensions, mais tu les initialisais avec GLEW? Ou tu les initialisais toi-même? Ou tu ne les initialisais pas?
Pour ton moteur, afin de tracker les erreurs OpenGL, prend l'habitude d'appeler très régulièrement glGetError, pour te dire, je le fais à chaque appel de fonction OpenGL.
De plus tu as les extensions de debogage, en OpenGL, qui pourront t'aider: http://jeux.developpez.com/telecharg...via-extensions

En effet je les charges moi même comme dans le tutos :
Code:

1 2 3 4 5 6 7 8 9 10 11 //////////////////////////////////////////////////////////// // Fonction et macros facilitant le chargement des extensions //////////////////////////////////////////////////////////// template <class T> inline void LoadExtension(T& Proc, const char* Name) { if (!(Proc = reinterpret_cast<T>(wglGetProcAddress(Name)))) throw C_OGLException("wglGetProcAddress", "LoadExtension"); } #define LOAD_EXTENSION(Ext) LoadExtension(Ext, #Ext) #define CHECK_EXTENSION(Ext) if (!CheckExtension(Ext)) throw C_OGLException(#Ext, "CheckExtensions");
Mais en modifiant les fonction et en utilisant glew cela fonctionne.

J'ai remarquer également que j'ai changer aussi les buffer d'index lors de l'utiliation (est-ce que cela pourrai venir de la?) :
Code:

1 2 3 4 5 6 7 8 // Avant glBindBufferARB(GL_ARRAY_BUFFER_ARB, IndexBuffer); glBufferDataARB(GL_ARRAY_BUFFER_ARB, Size * Stride, NULL, C_OGLEnum::BufferFlags(Flags)); // Après glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, IndexBuffer); glBufferData(GL_ELEMENT_ARRAY_BUFFER, Size * Stride, NULL, C_OGLEnum::BufferFlags(Flags));
Par contre c'est vrai que j'ai pas pris l'habitude de toujours tester les erreurs openGl qui est une bonne erreur de ma part. Je vais le faire a partir de maintenant :)

Par contre est-ce possible de trouver une erreur openGL lorsque cela scintille? car justement visual studio me disait rien et scintillais juste.

Je te remercie pour le lien je ne connaissais pas du tous.
Merci également pour ton aide

21/10/2015, 20h09
dragonjoker59

Ah ben effectivement, ta première initialisation d'un IBO était fausse, tu le bindais en tant que VBO
21/10/2015, 21h37
ksta.k

8O alors la je suis désoler sérieux même moi en plus qui le revoie en le mettant dans le post du forum j'ai pas remarquer cette erreur.

Comme quoi des fois faut arrêter de chercher c'est juste sous notre nez :(

effectivement sa marche mieux en le changeant :) .

Par contre du coup je me pose une question si je peut me permettre, est-il mieux de passer par les extension ou directement avec glew? car du coup j'ai une lib de plus dépendante dans le moteur.

Je me demande également si tu connaissais un site qui décrit bien la différence entre les version d'openGL? pour pouvoir faire une renderer par version. Cela me permettra de rentrer plus en profondeur dans openGL pour mieux apprendre.

Encore merci pour ton aide et désoler encore pour cette erreur futile.
25/10/2015, 22h26
dragonjoker59

Citation:

est-il mieux de passer par les extension ou directement avec glew?

Il n'y a pas de réponse définitive à cette question.
Personnellement j'utilisais GLEW jusqu'à ce que j'aie envie de supprimer cette dépendance (je ne dépends que de quelques libs que je ne me sens pas de remplacer : FreeType, FreeImage, ZLib et libzip)
GLEW est une très bonne lib, que je conseille même si je m'en passe.

Citation:

un site qui décrit bien la différence entre les version d'openGL

Est-ce vraiment utile? Tiens-tu réellement à écrire du code OpenGL 1.x "juste pour voir"?
25/10/2015, 23h43
ksta.k

ha ok donc je vais garder GLEW pour le moment et un jour si je le souhaite je l'enlèverais la le bute c'est surtout de l'apprentissage de base sur un moteur 3d et openGL.

Non je souhaite pas raiment faire de openGL 1.x mais je souhaiterais entrer dans une société de jeux et je sais par expérience dans le web que certaine société on déjà des bases de leur programme et donc si je rentre dans une société qui utilise par exemple openGL 3 mais que j'ai appris sur du openGL 4 j'aimerais facilement trouver les différences pour m'adapter plus rapidement. C'est juste une question de trouver rapidement une information sur openGL :)
26/10/2015, 09h10
ternel

Alors, peut-être suffirait-il de chercher des tutos sur comment migrer une application de 3 vers 4
26/10/2015, 10h04
dragonjoker59

La migration de 3.x vers 4.x ne me semble pas douloureuse.
Le plus douloureux a été de passer de 2.x avec pipeline fixe à 3.x sans pipeline fixe. J'ai eu à la faire, j'ai eu mal...