Discussion :

[martantoine]

Bonsoir

Je suis en train d'apprendre OpenGL,
et j'aimerai créer un objet static Texture pour ne pas à avoir créer des centaines de fois la même texture.
Or depuis ce matin, je bloque sur un problème à propos de ces textures très embêtant.

Dans un premier temps il m'est impossible d'envoyer la texture de type GLuint vers glBindTexture
Voici l'erreur :

Code :

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

1
2
3
 
1>QuadShape.obj : error LNK2001: symbole externe non résolu "public: static class texture::Texture texture::Texture::dirt" (?dirt@Texture@texture@@2V12@A)
1>F:\Documents\Programmation\Visual Studio 2015\Projects\Opengl_1\Debug\Opengl_1.exe : fatal error LNK1120: 1 externes non résolus

Puis dans un second temps j'ai une erreur qui est apparu en même temps que la première :
glGenerateMipmap cré cette erreur :

Code :

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

Exception levée à 0x00000000 dans Opengl_1.exe*: 0xC0000005*: Violation d'accès lors de l'exécution à l'emplacement 0x00000000.

Voici le code réduit au minimum :
Texture.h

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
 
#ifndef TEXTURE
#define TEXTURE
#include <GL\glew.h>
#include <iostream>
using namespace std;
 
namespace texture
{
	class Texture
	{
	public:
		Texture() {}
		Texture(const char* path);
		void Link(const char* path);
		GLuint Get();
 
		static Texture dirt;
 
	private:
		int width, height, nbrChannels;
		GLuint texture;
	};
}
#endif TEXTURE

Texture.cpp

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
 
#ifndef STB_IMAGE_IMPLEMENTATION
#define STB_IMAGE_IMPLEMENTATION
 
#include "stb_image.h"
#include "Texture.h"
 
namespace texture
{
	Texture::Texture(const char* path)
	{
		Link(path);
	}
 
	void Texture::Link(const char* path)
	{
		glGenTextures(1, &texture);
		glBindTexture(GL_TEXTURE_2D, texture);
		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
		unsigned char *data;
		data = stbi_load(path, &width, &height, &nbrChannels, 0);
		glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, width, height, 0, GL_RGB, GL_UNSIGNED_BYTE, data);
		glGenerateMipmap(GL_TEXTURE_2D);
		stbi_image_free(data);
 
	}
 
	GLuint Texture::Get()
	{
		return texture;
	}
	Texture container = Texture("container.jpg");
}
 
#endif STB_IMAGE_IMPLEMENTATION

QuadShape.h

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
 
#ifndef QUAD_SHAPE_H
#define QUAD_SHAPE_H
 
#include <GL\glew.h>
#include "math.h"
#include "Texture.h"
 
using namespace texture;
class QuadShape
{
public:
	QuadShape();
	void Render(bool POLYGON_MODE);
 
private:
	Vertex vertices[4];
	GLuint indices[6];
	GLuint VBO, EBO, VAO;
};
 
#endif QUAD_SHAPE_H

QuadShape.cpp

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
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
 
#include "QuadShape.h"
 
QuadShape::QuadShape()
{
	//Quad
		//Position	
		vertices[0].position = vec3(-1.0f, 1.0f, 0.0f); //Left Top
		vertices[1].position = vec3(-1.0f, -1.0f, 0.0f); //Left Bottom
		vertices[2].position = vec3(1.0f, -1.0f, 0.0f); //Right Bottom
		vertices[3].position = vec3(1.0f, 1.0f, 0.0f); //Right Top
		//Color
		vertices[0].color = vec3(0.0f, 0.0f, 0.0f); //Left Top
		vertices[1].color = vec3(0.0f, 1.0f, 0.0f); //Left Bottom
		vertices[2].color = vec3(1.0f, 0.0f, 1.0f); //Right Bottom
		vertices[3].color = vec3(1.0f, 1.0f, 0.0f); //Right Top
		//Texture Coords	
		vertices[0].textCoords = vec2(0.0f, 1.0f); //Left Top
		vertices[1].textCoords = vec2(0.0f, 0.0f); //Left Bottom
		vertices[2].textCoords = vec2(1.0f, 0.0f); //Right Bottom
		vertices[3].textCoords = vec2(1.0f, 1.0f); //Right Top
 
	//indices
	indices[0] = 0, indices[1] = 1, indices[2] = 3, indices[3] = 1, indices[4] = 2, indices[5] = 3;
 
	//VAO
	glGenVertexArrays(1, &VAO);
	glBindVertexArray(VAO);
 
	//VBO
	glGenBuffers(1, &VBO);
	glBindBuffer(GL_ARRAY_BUFFER, VBO);
	glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);
 
	//EBO
	glGenBuffers(1, &EBO);
	glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, EBO);
	glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(indices), indices, GL_STATIC_DRAW);
 
	//Attribute 0
	glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, sizeof(Vertex), (GLvoid *)(offsetof(Vertex, position)));
	glEnableVertexAttribArray(0);
 
	//Attribute 1
	glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, sizeof(Vertex), (GLvoid *)(offsetof(Vertex, color)));
	glEnableVertexAttribArray(1);
 
	//Attribute 2
	glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, sizeof(Vertex), (GLvoid *)(offsetof(Vertex, textCoords)));
	glEnableVertexAttribArray(2);
}
 
void QuadShape::Render(bool POLYGON_MODE)
{
	if (POLYGON_MODE)
		glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
	glBindTexture(GL_TEXTURE_2D, Texture::dirt.Get());
	glBindVertexArray(VAO);
	glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_INT, 0);
	glBindVertexArray(0);
 
}

Peut être que ce que j'ai mis à disposition est trop insuffisant
Le problème est que ca ferai beaucoup de fichier...

J'espère que j'aurez bien décris mon problème et que vous arriverez à le résoudre

Merci d'avance pour votre aide

Martantoine

[Danny-k]

Bon alors créer une variable static membre de la classe que tu es en train de définir, c'est normal que le compilateur crie a un moment ou un autre.
Ce que tu recherches a faire ressemble a un singleton, et ce n'est pas du tout comme tu l'as écrit que l'on définit un singleton.

Si tu veux continuer dans cette voie (qui au passage est au mieux bancale, au pire un défaut de conception)

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
 
	class Texture
	{
	public:
		Texture() {}
		Texture(const char* path)
		{
			Link(path);
		}
		void Link(const char* path)
		{
			glGenTextures(1, &texture);
			glBindTexture(GL_TEXTURE_2D, texture);
			glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
			glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
			glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
			glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
			unsigned char *data;
			data = stbi_load(path, &width, &height, &nbrChannels, 0);
			glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, width, height, 0, GL_RGB, GL_UNSIGNED_BYTE, data);
			glGenerateMipmap(GL_TEXTURE_2D);
			stbi_image_free(data);
		}
		GLuint Get()
		{
			return texture;
		}
 
		static Texture& instance()
		{
			static Texture tex;
			return tex;
		}
 
	private:
		int width, height, nbrChannels;
		GLuint texture;
	};

Voila comment tu définirais grosso modo ta classe.

Cependant pour ton crash avec glGenerateMipmap, le problème se situe en amont.
Notamment dans texture.cpp avec la variable globale container, il faut savoir que les variables globales sont instanciées avant la fonction main et détruite après cette dernière (idem pour les variables static), hors il se trouve pour que les fonctions OpenGL fonctionne, un contexte OpenGL doit être créé avant, ainsi que le chargements des bonnes fonctions depuis la carte graphique, c'est ce que font les librairies GLFW, SDL, QT, etc. pour créé des fenêtres, elles initialisent et crée un contexte OpenGL, et les librairies glew, glad, etc. après ce contexte crée permettent de charger les fonctions OpenGL.

Hors avec ta globale, l'appel a glGenerateMipmap se fait avant la creation du contexte. Tu aurais pu le voir en debuggant, vu que glGenTextures aurait non seulement initialisé ta variable texture a -1, mais t'aurais renvoyé une erreur après un appel a glGetError.

Sinon pour ton choix de conception, plutôt que de créer une variable globale, je te conseillerais de faire une classe qui gérerait une ou plusieurs textures, stocke soit sous la forme d'un std::unique_ptr si tu es certain que cette classe est la seule a en posséder la propriété, soit un shared_ptr si tu te fiches de savoir qui doit gérer qui (la 1er solution sera cependant plus performante que la 2e, mais demandera un peu plus de rigueur dans le code).