openGL3.3: probleme de texture

Version imprimable

bonjour,

je suis entrain de développez un application C++ avec openGL3.3, SFML2(pour la fenêtrage) et openCTM pour charger les model3D.

je n'arrive pas a faire marcher les texture: lors du rendu le model est tout noir.

je suis sous ubuntu 64bit. vous pourrez trouvez le code entier ici.

voici le code qui charge les model:

VBO.h:

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
#ifndef VBO_H
#define VBO_H
 
#include "tools.h"
#include "texture.h"
 
class VBO
{
	public:
		VBO(string file);
		~VBO();
 
		void draw();
 
	private:
		unsigned int m_vaoID;		// one vertex array objects, one for each drawn object
		unsigned int m_vboID[2];
		unsigned int m_vboColorID;
		unsigned int m_vbotexCoordID;
		Texture* tex;
		bool Color;
		unsigned int numTriangles;
 
};
 
#endif

VBO.cpp:

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
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
#include "vbo.h"
 
#define GL3_PROTOTYPES 1
#include <GL3/gl3.h>
#include <openctm.h>
#include <iostream>
 
VBO::VBO(string file):
tex(NULL),
Color(true)
{
	CTMimporter ctm;
 
	try
	{	
		ctm.Load(file.c_str());
    }
    catch (const ctm_error& error)
    {
		string msg=string("impposible de charger le fichier: ")+file;
		throw msg;
	}
 
	if(ctm.GetNamedAttribMap("Color") == CTM_NONE)
		Color=false;
 
 
	// one VAOs allocation
	glGenVertexArrays(1, &m_vaoID);
 
	// VAO setup
	glBindVertexArray(m_vaoID);
 
	glGenBuffers(2, m_vboID);
 
	glEnableVertexAttribArray(0);
	glBindBuffer(GL_ARRAY_BUFFER, m_vboID[0]);
	glBufferData(GL_ARRAY_BUFFER, ctm.GetInteger(CTM_VERTEX_COUNT)*3*sizeof(GLfloat), ctm.GetFloatArray(CTM_VERTICES), GL_STATIC_DRAW);
	glVertexAttribPointer((GLuint)0, 3, GL_FLOAT, GL_FALSE, 0, 0); 
 
	if(Color)
	{
		glEnableVertexAttribArray(1);
		glGenBuffers(1, &m_vboColorID);
		glBindBuffer(GL_ARRAY_BUFFER, m_vboID[2]);
		glBufferData(GL_ARRAY_BUFFER, ctm.GetInteger(CTM_VERTEX_COUNT)*4*sizeof(GLfloat), ctm.GetFloatArray(ctm.GetNamedAttribMap("Color")), GL_STATIC_DRAW);
		glVertexAttribPointer((GLuint)1, 4, GL_FLOAT, GL_FALSE, 0, 0);
	}
 
	//texture
	if(ctm.GetInteger(CTM_UV_MAP_COUNT) > 0)
	{
		tex = new Texture((string)ctm.GetUVMapString(CTM_UV_MAP_1, CTM_FILE_NAME));
		glGenBuffers(1, &m_vbotexCoordID);
 
		glEnableVertexAttribArray(2);
 
		glBindBuffer(GL_ARRAY_BUFFER, m_vbotexCoordID);
		glBufferData(GL_ARRAY_BUFFER, ctm.GetInteger(CTM_VERTEX_COUNT)*2*sizeof(GLfloat),ctm.GetFloatArray(CTM_UV_MAP_1), GL_STATIC_DRAW);
		glVertexAttribPointer((GLuint)2, 2, GL_FLOAT, GL_FALSE, 0, 0);
	}
 
	numTriangles=ctm.GetInteger(CTM_TRIANGLE_COUNT);
	glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_vboID[1]);
	glBufferData(GL_ELEMENT_ARRAY_BUFFER, ctm.GetInteger(CTM_TRIANGLE_COUNT)*3*sizeof(uint), ctm.GetIntegerArray(CTM_INDICES), GL_STATIC_DRAW);
	glVertexAttribPointer((GLuint)3, 1, GL_UNSIGNED_INT, GL_FALSE, 0, 0);
 
	glBindVertexArray(0);
}
 
 
VBO::~VBO()
{
	glBindBuffer(GL_ARRAY_BUFFER, 0);
	glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
	glDeleteBuffers(2, m_vboID);
	glDeleteBuffers(1, &m_vboColorID);
	glBindVertexArray(0);
	glDeleteVertexArrays(1, &m_vaoID);
	if(tex)
		delete tex;
}
 
void VBO::draw()
{
	if(!Color)
		glVertexAttrib3f((GLuint)1, 1.0, 1.0, 1.0);
	glBindVertexArray(m_vaoID);
	if(tex)
		tex->bind();
	glDrawElements(GL_TRIANGLES, numTriangles*3, GL_UNSIGNED_INT, 0); 
	glBindVertexArray(0);
}

je suis désoler de mettre autant de code mais je n'est aucune idée d'où je me suis trompez

merci d'avance

27/02/2011, 02h19
LittleWhite

Bonjour,

J'ai l'impression (bon d'accord, j'ai fait juste un rapide parcourt du code) que vous n'activez pas le tableau de coordonées de texture ... ou que vous n'activez pas le texturing.
Sinon cela peut être aussi dans le shader ...
27/02/2011, 09h33
dragonjoker59

Tu dis utiliser OpenGL 3.3, avec un contexte compatible 2.X ou pas ?
Si tu utilises un contexte compatible, il faut activer ta texture, sinon, il faut la passer au shader via une variable uniform. Tu peux nous montrer le code correspondant ?
27/02/2011, 11h51
daedra

merci pour vaut réponse.

pour répondre a vaut question, il y a bien un tableau de coordonné de texture. et dans openGL 3.3 "glEnable(GL_TEXTURE_2D);" ne sert a rien, car tout marche avec les shader. vous pouvez toujours regarder si vous avez envi ici:
http://fardokin.alwaysdata.net/SMFL2-OGL33.zip

je vait modifier mon code pour utiliser freeGLUT j'ai trouver un tutorial qui explique openGL3.3 avec freeglut et qui explique les texture car j'ai mal comprendre un truc.

merci pour vaut réponse mais je vais recommencez de zéro car je n'est aucun idée d'où le problème vient.
27/02/2011, 16h09
dragonjoker59

Et donc, tu passes ta texture au shader ou pas ? On peut voir le code, ainsi que le code de traitement de la texture (et de l'UV) dans le shader ?

voici le code du shader:
frag:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
#version 330
 
 
in vec4 color;
in  vec2 texCoord;
out vec4 gl_FragColor;
 
 
uniform sampler2D gSampler;
 
 
void main()
{
    gl_FragColor = texture2D(gSampler, texCoord.xy);
}

vert:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
#version 330
 
out vec4 color;
out vec2 texCoord;
 
uniform mat4 modelview;
uniform mat4 projection;
 
#define ATTR_POSITION  0
#define ATTR_COLOR 1
#define ATTR_TEXCOORD0 2
 
layout(location = ATTR_TEXCOORD0) in vec2 texCoordI;
layout(location = ATTR_COLOR)  in vec4 colorI;
layout(location = ATTR_POSITION)  in vec4 positionI;
 
void main()
{
    gl_Position = projection * modelview * positionI;
    color = colorI;
    texCoord=texCoordI;
}

28/02/2011, 12h16
dragonjoker59

Tu la passes comment, au shader, ta texture ?
28/02/2011, 13h17
daedra

j'ai enfin trouver le problème j'avais mal implémenter ma class "texture". j'avais inverser le contenu des mes fonction par une erreur d'inattention. merci de votre aide surtout sur erreur aussi stupide et le temp que j'ai mis a la resoudre.