+ | Switched to compute shader

srcs/RT.cpp

@@ -12,29 +12,40 @@
 
 #include "RT.hpp"
 
+
+
 int main(void)
 {
 	Window		window(WIDTH, HEIGHT, "RT_GPU", 0);
-	Shader		shader("shaders/vertex.vert", "shaders/frag.frag");
+	Shader		shader("shaders/vertex.vert", "shaders/frag.frag", "shaders/compute.glsl");
 	
+	Vertex vertices[3] = {
+		{{-1.0f, -1.0f}, {0.0f, 0.0f}},
+		{{3.0f, -1.0f}, {2.0f, 0.0f}},
+		{{-1.0f, 3.0f}, {0.0f, 2.0f}}
+	};
+
 	shader.attach();
 
-	glm::vec2 vertices[3] = {
-		{-1.0f, -1.0f}, {3.0f, -1.0f}, {-1.0f,  3.0f}
-	};
-	size_t size = sizeof(vertices) / sizeof(glm::vec2) / 3;
+	size_t size = sizeof(vertices) / sizeof(Vertex) / 3;
 
 	shader.setupVertexBuffer(vertices, size);
 	
 	while (!window.shouldClose())
 	{
-		glClear(GL_COLOR_BUFFER_BIT);
-
+		glUseProgram(shader.getProgramCompute());
+		
 		shader.set_vec2("u_resolution", glm::vec2(WIDTH, HEIGHT));
 		shader.set_vec3("u_cameraPosition", window.getScene()->getCamera()->get_position());
 		shader.set_mat4("u_viewMatrix", window.getScene()->getCamera()->get_view_matrix());
+		
+		glDispatchCompute((WIDTH + 15) / 16, (HEIGHT + 15) / 16, 1);
+		glMemoryBarrier(GL_SHADER_IMAGE_ACCESS_BARRIER_BIT);
+		
+		glClear(GL_COLOR_BUFFER_BIT);
 
 		glUseProgram(shader.getProgram());
+		
 		shader.drawTriangles(size);
 
 		std::cout << "\rFPS: " << int(window.getFps()) << "        " << std::flush;

srcs/class/Shader.cpp

@@ -37,10 +37,11 @@ char* load_file(char const* path)
 	return buffer;
 }
 
-Shader::Shader(std::string vertexPath, std::string fragmentPath)
+Shader::Shader(std::string vertexPath, std::string fragmentPath, std::string computePath)
 {
 	const char *vertexCode = load_file(vertexPath.c_str());
 	const char *fragmentCode = load_file(fragmentPath.c_str());
+	const char *computeCode = load_file(computePath.c_str());
 	
 	_vertex = glCreateShader(GL_VERTEX_SHADER);
 	
@@ -55,38 +56,45 @@ Shader::Shader(std::string vertexPath, std::string fragmentPath)
 	glCompileShader(_fragment);
 
 	checkCompileErrors(_fragment);
-}
 
-Shader::Shader(Shader const &src)
-{
-	*this = src;
-}
+	_compute = glCreateShader(GL_COMPUTE_SHADER);
 
-Shader	&Shader::operator=(Shader const &rhs)
-{
-	if (this != &rhs)
-	{
-		_program = rhs._program;
-		_vertex = rhs._vertex;
-		_fragment = rhs._fragment;
-	}
-	return (*this);
+	glShaderSource(_compute, 1, &computeCode, NULL);
+	glCompileShader(_compute);
+
+	checkCompileErrors(_compute);
 }
 
 Shader::~Shader(void)
 {
 	glDeleteShader(_vertex);
 	glDeleteShader(_fragment);
+	glDeleteShader(_compute);
 	glDeleteProgram(_program);
+	glDeleteProgram(_program_compute);
 }
 
 void Shader::attach(void)
 {
 	_program = glCreateProgram();
+	_program_compute = glCreateProgram();
+
 	
 	glAttachShader(_program, _vertex);
 	glAttachShader(_program, _fragment);
+	glAttachShader(_program_compute, _compute);
+
 	glLinkProgram(_program);
+	glLinkProgram(_program_compute);
+
+	glGenTextures(1, &_outputTexture);
+	glBindTexture(GL_TEXTURE_2D, _outputTexture);
+	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
+	glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA32F, WIDTH, HEIGHT, 0, GL_RGBA, GL_FLOAT, NULL);
+	glBindImageTexture(0, _outputTexture, 0, GL_FALSE, 0, GL_WRITE_ONLY, GL_RGBA32F);
 }
 
 void Shader::checkCompileErrors(GLuint shader)
@@ -102,25 +110,34 @@ void Shader::checkCompileErrors(GLuint shader)
 	}
 }
 
-void Shader::setupVertexBuffer(const glm::vec2* vertices, size_t size)
+void Shader::setupVertexBuffer(const Vertex* vertices, size_t size)
 {
-	glGenVertexArrays(1, &_screen_VAO);
+    glGenVertexArrays(1, &_screen_VAO);
     glGenBuffers(1, &_screen_VBO);
-	
+    
     glBindVertexArray(_screen_VAO);
 
     glBindBuffer(GL_ARRAY_BUFFER, _screen_VBO);
-    glBufferData(GL_ARRAY_BUFFER, size * 3 * sizeof(glm::vec2), vertices, GL_STATIC_DRAW);
+    glBufferData(GL_ARRAY_BUFFER, size * 3 * sizeof(Vertex), vertices, GL_STATIC_DRAW);
 
-    glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 2 * sizeof(float), (void*)0);
+    // Position attribute
+    glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, sizeof(Vertex), (void*)0);
     glEnableVertexAttribArray(0);
 
+    // Texture coordinate attribute
+    glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, sizeof(Vertex), (void*)offsetof(Vertex, texCoord));
+    glEnableVertexAttribArray(1);
+
     glBindBuffer(GL_ARRAY_BUFFER, 0);
     glBindVertexArray(0);
 }
 
 void	Shader::drawTriangles(size_t size)
 {
+	glActiveTexture(GL_TEXTURE0);
+	glBindTexture(GL_TEXTURE_2D, _outputTexture);
+	glUniform1i(glGetUniformLocation(_program, "screenTexture"), 0);
+	
 	glBindVertexArray(_screen_VAO);
 	glDrawArrays(GL_TRIANGLES, 0, size * 3);
 }
@@ -128,20 +145,25 @@ void	Shader::drawTriangles(size_t size)
 
 void	Shader::set_vec2(const std::string &name, const glm::vec2 &value) const
 {
-	glUniform2fv(glGetUniformLocation(_program, name.c_str()), 1, glm::value_ptr(value));
+	glUniform2fv(glGetUniformLocation(_program_compute, name.c_str()), 1, glm::value_ptr(value));
 }
 
 void	Shader::set_vec3(const std::string &name, const glm::vec3 &value) const
 {
-	glUniform3fv(glGetUniformLocation(_program, name.c_str()), 1, glm::value_ptr(value));
+	glUniform3fv(glGetUniformLocation(_program_compute, name.c_str()), 1, glm::value_ptr(value));
 }
 
 void	Shader::set_mat4(const std::string &name, const glm::mat4 &value) const
 {
-	glUniformMatrix4fv(glGetUniformLocation(_program, name.c_str()), 1, GL_FALSE, glm::value_ptr(value));
+	glUniformMatrix4fv(glGetUniformLocation(_program_compute, name.c_str()), 1, GL_FALSE, glm::value_ptr(value));
 }
 
 GLuint	Shader::getProgram(void) const
 {
 	return (_program);
+}
+
+GLuint	Shader::getProgramCompute(void) const
+{
+	return (_program_compute);
 }