Discussion :

[martantoine]

Bonjour, je suis le tutoriels sur OpenGL 3.3 http://opengl.developpez.com/tutoriels/opengl-tutorial/ sur ce site, dans le tutoriel "Premier triangle", on utilise une fonction pour charger le Vertex et le Fragment Shader et créer le Programme shader, j'ai voulu réécrire cette fonction mais orienté objet, mais il y a un hic, le programme n'arrive pas à linker le Vertex Shader et le Fragment Shader au ProgramShader
Ducou, le programme m'affiche un triangle blanc sur fond bleu (j'ai un carte graphique amd) mais pas avec mon shader. Ca m'embête énormement

Voici le main.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
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
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
#define GLEW_STATIC
#include <GL\glew.h>
#include <GLFW\glfw3.h>
#include <iostream>
#include "ShaderLoader.h"
 
using namespace std;
 
int main()
{
	//Initialisation GLFW
	if (!glfwInit())
	{
		cout << "Impossible d'initiliaser GLFW !" << endl;
		return -1;
	}
 
	//Initialisation Opengl 3.3
	glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
	glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
 
	//Disable old OpenGL Support
	glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
 
	//Open window
	GLFWwindow* window = glfwCreateWindow(800, 600, "GameEngine", NULL, NULL);
	if (window == NULL)
	{
		cout << "Failed to open GLFW window !" << endl;
		glfwTerminate();
		return -1;
	}
	glfwMakeContextCurrent(window);
 
	//Initialisation GLEW
	glewExperimental = true;
	if (glewInit() != GLEW_OK)
	{
		cout << "Failed to initialise GLEW !" << endl;
		glfwTerminate();
		return -1;
	}
 
	//Coord triangle
	GLfloat g_vertex_buffer_data[] = {
		-0.5f, -0.5f, 0.0f,
		0.0f, 0.5f, 0.0f,
		0.5f, -0.5f, 0.0f
	};
 
	//VAO
	GLuint VertexArrayID;
	glGenVertexArrays(1, &VertexArrayID);
	glBindVertexArray(VertexArrayID);
 
	//VBO
	GLuint vertexBuffer;
	glGenBuffers(1, &vertexBuffer);
	glBindBuffer(GL_ARRAY_BUFFER, vertexBuffer);
	glBufferData(GL_ARRAY_BUFFER, sizeof(g_vertex_buffer_data), g_vertex_buffer_data, GL_STATIC_DRAW);
 
	//Shader
		ShaderLoader VertexShaderLoader, FragmentShaderLoader;
		GLuint VertexShader = glCreateShader(GL_VERTEX_SHADER);
		const char * VertexShaderPointer;
		GLuint FragmentShader = glCreateShader(GL_FRAGMENT_SHADER);
		const char * FragmentShaderPointer;
		//VertexShader
			VertexShaderPointer = VertexShaderLoader.VertexShaderCodeLoader("SimpleVertexShader.vertexshader").c_str();
			glShaderSource(VertexShader, 1, &VertexShaderPointer, NULL);
			glCompileShader(VertexShader);
		//FragmentShader
			FragmentShaderPointer = FragmentShaderLoader.FragmentShaderCodeLoader("SimpleFragmentShader.fragmentshader").c_str();
			glShaderSource(FragmentShader, 1, &FragmentShaderPointer, NULL);
			glCompileShader(FragmentShader);
		//ProgramShader
			GLint success;
			GLchar infoLog[512];
			GLuint ProgramShader = glCreateProgram();
			glAttachShader(ProgramShader, VertexShader);
			glAttachShader(ProgramShader, FragmentShader);
			glLinkProgram(ProgramShader);
			glGetProgramiv(ProgramShader, GL_LINK_STATUS, &success);
			if (!success) {
				glGetProgramInfoLog(ProgramShader, 512, NULL, infoLog);
				std::cout << "ERROR::SHADER::PROGRAM::LINKING_FAILED\n" << infoLog << std::endl;
			}
			glDeleteShader(VertexShader);
			glDeleteShader(FragmentShader);
 
	//Boucle principale
	glfwSetInputMode(window, GLFW_STICKY_KEYS, GL_TRUE);
 
	glClearColor(0.0f, 0.0f, 0.4f, 0.0f);
	while (glfwGetKey(window, GLFW_KEY_ESCAPE) != GLFW_PRESS && glfwWindowShouldClose(window) == 0)
	{
		glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
		glUseProgram(ProgramShader);
		glEnableVertexAttribArray(0);
		glBindBuffer(GL_ARRAY_BUFFER, vertexBuffer);
		glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, (void*)0);
		glDrawArrays(GL_TRIANGLES, 0, 3);
		glDisableVertexAttribArray(0);
		glfwPollEvents();
		glfwSwapBuffers(window);
	}
 
	//Fermeture programme
	glfwTerminate();
	return 0;
}

Le ShaderLoader.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
#pragma once
#define GLEW_STATIC
#include <GL\glew.h>
#include <iostream>
#include <fstream>
#include <string>
 
class ShaderLoader
{
	public:
		ShaderLoader();
		~ShaderLoader();
		std::string VertexShaderCodeLoader(const char * VertexShaderPath);
		std::string FragmentShaderCodeLoader(const char * FragmentShaderPath);
 
	private:
		//Code
		std::string VertexShaderCode;
		std::string FragmentShaderCode;
		std::string Line;
		//File
		std::ifstream VertexShaderFile;
		std::ifstream FragmentShaderFile;
};

Le ShaderLoader.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
#include "ShaderLoader.h"
 
using namespace std;
 
ShaderLoader::ShaderLoader()
{
}
 
ShaderLoader::~ShaderLoader()
{
}
 
string ShaderLoader::VertexShaderCodeLoader(const char * VertexShaderPath)
{
	VertexShaderFile.open(VertexShaderPath, ios::in);
	if (VertexShaderFile.is_open())
	{
		cout << "Load VertexShader" << endl;
		while (getline(VertexShaderFile, Line))
		{
			VertexShaderCode += Line + "\n";
		}
		cout << "VertexShader loading successfull" << endl;
	}
	else
	{
		cout << "Failed to load VertexShader" << endl;
		return "";
	}
	VertexShaderFile.close();
	return VertexShaderCode;
}
 
string ShaderLoader::FragmentShaderCodeLoader(const char * FragmentShaderPath)
{
	FragmentShaderFile.open(FragmentShaderPath, ios::in);
	if (FragmentShaderFile.is_open())
	{
		cout << "Load FragmentShader" << endl;
		while (getline(FragmentShaderFile, Line))
		{
			FragmentShaderCode += Line + "\n";
		}
		cout << "FragmentShader loading successfull" << endl;
	}
	else
	{
		cout << "Failed to load FragmentShader" << endl;
		return "";
	}
	FragmentShaderFile.close();
	return FragmentShaderCode;
}

Merci d'avance pour votre aide

[Bousk]

Salut,

je n'ai plus fait ça depuis des années, mais plusieurs erreurs dans ton code sans même parler des shaders comme le fait que tu retournes une string par copie et espères récupérer un const char* depuis un appel à c_str() sur cette copie : au mieux ça plantera
Quitte à créer une classe pour gérer le shader, pourquoi ne pas vraiment créer une telle classe et se contenter de juste lire le contenu du fichier ?
Toute la logique du shader devrait être dans cette classe, et pour utiliser le shader en question uniquement un appel à Shader::bind() ferait l'affaire
Si tu n'es pas sûr, tu peux regarder les sources de la SFML pour voir comment il gère les shader, il a une telle classe

[martantoine]

Merci Bousk, je test ça
Je pensais que la fonction c_str() pouvais faire d'un string un const char*.

[Matt_Houston]

Tu n'as pas précisé l'erreur de link que tu devrais récupérer depuis l'info log.

[Bousk]

Je pensais que la fonction c_str() pouvais faire d'un string un const char*.

Et c'est exactement ce qu'elle fait, seulement, si tu supprimes l'original, tu as un joli pointeur vers.. du vent qui a toutes les chances d'entraîner un crash ou du moins est un comportement indéterminé.

[martantoine]

Merci mais je ne vois pas trop comment faire

[Bousk]

https://github.com/SFML/SFML/blob/ma...hader.cpp#L826