tom/RT_GPU
1
0
Fork 0
mirror of https://github.com/TheRedShip/RT_GPU.git synced 2025-09-27 18:48:36 +02:00
Code Issues Packages Projects Releases Wiki Activity

+ | Shader class system better working

Browse Source
This commit is contained in:
TheRedShip
2025-02-13 00:28:20 +01:00
parent a71529312b
commit 6e3b0c44eb
11 changed files with 402 additions and 213 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
includes/RT.hpp
View File

@ -58,10 +58,12 @@ struct Vertex {
# include "objects/Portal.hpp" # include "objects/Portal.hpp"
# include "objects/Cylinder.hpp" # include "objects/Cylinder.hpp"
# include "Buffer.hpp"
# include "Arguments.hpp" # include "Arguments.hpp"
# include "Camera.hpp" # include "Camera.hpp"
# include "Renderer.hpp" # include "Renderer.hpp"
# include "Window.hpp" # include "Window.hpp"
# include "ShaderProgram.hpp"
# include "Shader.hpp" # include "Shader.hpp"
# include "Scene.hpp" # include "Scene.hpp"
# include "SceneParser.hpp" # include "SceneParser.hpp"

54
includes/RT/Buffer.hpp Normal file
View File

@ -0,0 +1,54 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* Buffer.hpp :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: TheRed <TheRed@students.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2025/02/12 23:45:57 by TheRed #+# #+# */
/* Updated: 2025/02/12 23:45:57 by TheRed ### ########.fr */
/* */
/* ************************************************************************** */
#ifndef BUFFER_HPP
# define BUFFER_HPP
# include "RT.hpp"
class Buffer
{
public:
enum Type
{
SSBO,
UBO
};
Buffer(Type type, GLuint binding_point, GLuint size, const void *data)
: _type(type), _binding_point(binding_point)
{
glGenBuffers(1, &_buffer_id);
glBindBuffer(_type == SSBO ? GL_SHADER_STORAGE_BUFFER : GL_UNIFORM_BUFFER, _buffer_id);
glBufferData(_type == SSBO ? GL_SHADER_STORAGE_BUFFER : GL_UNIFORM_BUFFER, size, data, GL_DYNAMIC_DRAW);
glBindBufferBase(_type == SSBO ? GL_SHADER_STORAGE_BUFFER : GL_UNIFORM_BUFFER, _binding_point, _buffer_id);
glBindBuffer(_type == SSBO ? GL_SHADER_STORAGE_BUFFER : GL_UNIFORM_BUFFER, 0);
}
~Buffer() { glDeleteBuffers(1, &_buffer_id); }
void update(const void *data, GLuint size)
{
glBindBuffer(_type == SSBO ? GL_SHADER_STORAGE_BUFFER : GL_UNIFORM_BUFFER, _buffer_id);
glBufferSubData(_type == SSBO ? GL_SHADER_STORAGE_BUFFER : GL_UNIFORM_BUFFER, 0, size, data);
glBindBuffer(_type == SSBO ? GL_SHADER_STORAGE_BUFFER : GL_UNIFORM_BUFFER, 0);
}
GLuint getID() const { return _buffer_id; }
private:
Type _type;
GLuint _buffer_id;
GLuint _binding_point;
};
#endif

15
includes/RT/Shader.hpp
View File

@ -18,9 +18,14 @@
class Shader class Shader
{ {
public: public:
Shader(std::string vertexPath, std::string fragmentPath, std::string computePath, std::string denoisingPath); Shader(GLenum type, const std::string &file_path);
~Shader(void); ~Shader(void);
void compile(void);
void reload();
GLuint getShader(void) const;
void attach(void); void attach(void);
void setupVertexBuffer(); void setupVertexBuffer();
void drawTriangles(); void drawTriangles();
@ -37,7 +42,6 @@ class Shader
void set_textures(std::vector<GLuint> texture_ids, std::vector<GLuint> emissive_texture_ids); void set_textures(std::vector<GLuint> texture_ids, std::vector<GLuint> emissive_texture_ids);
GLuint getProgram(void) const;
GLuint getProgramCompute(void) const; GLuint getProgramCompute(void) const;
GLuint getProgramComputeDenoising(void) const; GLuint getProgramComputeDenoising(void) const;
@ -67,7 +71,12 @@ class Shader
size_t _size; size_t _size;
void checkCompileErrors(unsigned int shader); void checkCompileErrors();
//
GLenum _type;
GLuint _shader_id;
std::string _file_path;
}; };
#endif #endif

46
includes/RT/ShaderProgram.hpp Normal file
View File

@ -0,0 +1,46 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ShaderProgram.hpp :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: TheRed <TheRed@students.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2025/02/12 22:22:17 by TheRed #+# #+# */
/* Updated: 2025/02/12 22:22:17 by TheRed ### ########.fr */
/* */
/* ************************************************************************** */
#ifndef SHADERPROGRAM_HPP
# define SHADERPROGRAM_HPP
# include "RT.hpp"
class ShaderProgram
{
public:
ShaderProgram();
~ShaderProgram(void);
void attachShader(Shader *shader);
void link(void);
void use(void) const;
void dispathCompute(GLuint x, GLuint y, GLuint z) const;
void bindImageTexture(GLuint texture_id, GLuint unit, GLenum access, GLenum format) const;
void reloadShaders(void);
void set_int(const std::string &name, int value) const;
void set_float(const std::string &name, float value) const;
void set_vec2(const std::string &name, const glm::vec2 &value) const;
GLuint getProgram(void) const;
private:
std::vector<Shader *> _shaders;
GLuint _program;
};
#endif

1
includes/RT/objects/Portal.hpp
View File

@ -52,7 +52,6 @@ class Portal : public Object
_rotation = glm::mat3(right, up, forward); _rotation = glm::mat3(right, up, forward);
_normal = forward * (_invert_normal ? -1.0f : 1.0f); _normal = forward * (_invert_normal ? -1.0f : 1.0f);
std::cout << glm::to_string(_normal) << std::endl;
_linked_portal = -1; _linked_portal = -1;
_mat_index = mat_index; _mat_index = mat_index;

5
shaders/frag.frag
View File

@ -2,8 +2,9 @@
in vec2 TexCoords; in vec2 TexCoords;
out vec4 FragColor; out vec4 FragColor;
uniform sampler2D screenTexture; layout (binding = 0, rgba32f) uniform image2D screenTexture;
void main() { void main() {
FragColor = texture(screenTexture, TexCoords); FragColor = imageLoad(screenTexture, ivec2(gl_FragCoord.xy));
// FragColor = vec4(1.0, 0.0, 0.0, 1.0);
} }

2
shaders/light.glsl
View File

@ -2,7 +2,7 @@ hitInfo traceRay(inout Ray ray);
vec3 GetEnvironmentLight(Ray ray) vec3 GetEnvironmentLight(Ray ray)
{ {
return vec3(0.); // return vec3(0.);
vec3 sun_pos = vec3(-0.5, 0.5, 0.5); vec3 sun_pos = vec3(-0.5, 0.5, 0.5);
float SunFocus = 1.5; float SunFocus = 1.5;
float SunIntensity = 1.; float SunIntensity = 1.;

185
srcs/RT.cpp
View File

@ -12,172 +12,77 @@
#include "RT.hpp" #include "RT.hpp"
void setupScreenTriangle(GLuint *VAO);
void drawScreenTriangle(GLuint VAO, GLuint output_texture, GLuint program);
std::vector<GLuint> generateTextures(unsigned int textures_count);
std::vector<Buffer *> createDataOnGPU(Scene &scene);
void updateDataOnGPU(Scene &scene, std::vector<Buffer *> buffers);
int main(int argc, char **argv) int main(int argc, char **argv)
{ {
Arguments args(argc, argv); Arguments args(argc, argv);
if (args.error()) if (args.error())
return (1); return (1);
Scene scene(args.getSceneName()); Scene scene(args.getSceneName());
if (scene.fail()) if (scene.fail())
return (1); return (1);
Window window(&scene, WIDTH, HEIGHT, "RT_GPU", 0, args); Window window(&scene, WIDTH, HEIGHT, "RT_GPU", 0, args);
Shader shader("shaders/vertex.vert", "shaders/frag.frag", "shaders/compute.glsl", "shaders/denoising.glsl");
// Shader shader("shaders/vertex.vert", "shaders/frag.frag", "shaders/debug.glsl"); GLuint VAO;
setupScreenTriangle(&VAO);
std::vector<GLuint> textures = generateTextures(2);
GLuint output_texture = textures[0];
ShaderProgram raytracing_program;
Shader compute = Shader(GL_COMPUTE_SHADER, "shaders/compute.glsl");
raytracing_program.attachShader(&compute);
raytracing_program.link();
raytracing_program.use();
// raytracing_program.bindImageTexture(output_texture, 0, GL_READ_WRITE, GL_RGBA32F);
// raytracing_program.bindImageTexture(textures[1], 1, GL_READ_WRITE, GL_RGBA32F);
GLint max_gpu_size; ShaderProgram render_program;
glGetIntegerv(GL_MAX_SHADER_STORAGE_BLOCK_SIZE, &max_gpu_size); Shader vertex = Shader(GL_VERTEX_SHADER, "shaders/vertex.vert");
Shader frag = Shader(GL_FRAGMENT_SHADER, "shaders/frag.frag");
const std::vector<GPUObject> &object_data = scene.getObjectData(); render_program.attachShader(&vertex);
const std::vector<GPUTriangle> &triangle_data = scene.getTriangleData(); render_program.attachShader(&frag);
const std::vector<GPUBvh> &bvh_nodes = scene.getBvh(); render_program.link();
const std::vector<GPUBvhData> &bvh_data = scene.getBvhData();
const std::vector<GPUMaterial> &material_data = scene.getMaterialData();
std::cout << "Sending " << object_data.size() << " objects for " << \ std::vector<Buffer *> buffers = createDataOnGPU(scene);
object_data.size() * sizeof(GPUObject) + \
triangle_data.size() * sizeof(GPUTriangle) + \
bvh_nodes.size() * sizeof(GPUBvh) + \
material_data.size() * sizeof(GPUMaterial) \
<< " / " << max_gpu_size << " bytes" << std::endl;
GLuint objectSSBO;
glGenBuffers(1, &objectSSBO);
glBindBuffer(GL_SHADER_STORAGE_BUFFER, objectSSBO);
glBufferData(GL_SHADER_STORAGE_BUFFER, sizeof(GPUObject) * object_data.size(), object_data.data(), GL_STATIC_DRAW);
glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 1, objectSSBO);
GLuint trianglesSSBO;
glGenBuffers(1, &trianglesSSBO);
glBindBuffer(GL_SHADER_STORAGE_BUFFER, trianglesSSBO);
glBufferData(GL_SHADER_STORAGE_BUFFER, sizeof(GPUTriangle) * triangle_data.size(), triangle_data.data(), GL_STATIC_DRAW);
glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 2, trianglesSSBO);
GLuint bvh_nodesSSBO;
glGenBuffers(1, &bvh_nodesSSBO);
glBindBuffer(GL_SHADER_STORAGE_BUFFER, bvh_nodesSSBO);
glBufferData(GL_SHADER_STORAGE_BUFFER, sizeof(GPUBvhData) * bvh_data.size(), bvh_data.data(), GL_STATIC_DRAW);
glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 3, bvh_nodesSSBO);
GLuint bvhSSBO;
glGenBuffers(1, &bvhSSBO);
glBindBuffer(GL_SHADER_STORAGE_BUFFER, bvhSSBO);
glBufferData(GL_SHADER_STORAGE_BUFFER, sizeof(GPUBvh) * bvh_nodes.size(), bvh_nodes.data(), GL_STATIC_DRAW);
glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 4, bvhSSBO);
GLuint materialSSBO;
glGenBuffers(1, &materialSSBO);
glBindBuffer(GL_SHADER_STORAGE_BUFFER, materialSSBO);
glBufferData(GL_SHADER_STORAGE_BUFFER, sizeof(GPUMaterial) * material_data.size(), nullptr, GL_STATIC_DRAW);
glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 5, materialSSBO);
GLuint lightSSBO;
glGenBuffers(1, &lightSSBO);
glBindBuffer(GL_SHADER_STORAGE_BUFFER, lightSSBO);
glBufferData(GL_SHADER_STORAGE_BUFFER, scene.getGPULights().size() * sizeof(int), nullptr, GL_STATIC_DRAW);
glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 6, lightSSBO);
GLuint cameraUBO;
glGenBuffers(1, &cameraUBO);
glBindBuffer(GL_UNIFORM_BUFFER, cameraUBO);
glBufferData(GL_UNIFORM_BUFFER, sizeof(GPUCamera), nullptr, GL_DYNAMIC_DRAW);
glBindBufferBase(GL_UNIFORM_BUFFER, 0, cameraUBO);
GLuint volumeUBO;
glGenBuffers(1, &volumeUBO);
glBindBuffer(GL_UNIFORM_BUFFER, volumeUBO);
glBufferData(GL_UNIFORM_BUFFER, sizeof(GPUVolume), nullptr, GL_STATIC_DRAW);
glBindBufferBase(GL_UNIFORM_BUFFER, 1, volumeUBO);
GLuint debugUBO;
glGenBuffers(1, &debugUBO);
glBindBuffer(GL_UNIFORM_BUFFER, debugUBO);
glBufferData(GL_UNIFORM_BUFFER, sizeof(GPUDebug), nullptr, GL_STATIC_DRAW);
glBindBufferBase(GL_UNIFORM_BUFFER, 2, debugUBO);
if (!scene.loadTextures())
return (1);
shader.attach();
shader.setupVertexBuffer();
while (!window.shouldClose()) while (!window.shouldClose())
{ {
window.updateDeltaTime(); window.updateDeltaTime();
glUseProgram(shader.getProgramCompute());
glBindBuffer(GL_SHADER_STORAGE_BUFFER, materialSSBO);
glBufferSubData(GL_SHADER_STORAGE_BUFFER, 0, material_data.size() * sizeof(GPUMaterial), material_data.data());
std::set<int> gpu_lights = scene.getGPULights();
std::vector<int> gpu_lights_array(gpu_lights.begin(), gpu_lights.end());
glBindBuffer(GL_SHADER_STORAGE_BUFFER, lightSSBO);
glBufferSubData(GL_SHADER_STORAGE_BUFFER, 0, gpu_lights_array.size() * sizeof(int), gpu_lights_array.data());
window.rendererUpdate(shader);
GPUCamera camera_data = scene.getCamera()->getGPUData();
glBindBuffer(GL_UNIFORM_BUFFER, cameraUBO);
glBufferSubData(GL_UNIFORM_BUFFER, 0, sizeof(GPUCamera), &camera_data);
glBindBuffer(GL_UNIFORM_BUFFER, volumeUBO);
glBufferSubData(GL_UNIFORM_BUFFER, 0, sizeof(GPUVolume), &scene.getVolume());
glBindBuffer(GL_UNIFORM_BUFFER, debugUBO);
glBufferSubData(GL_UNIFORM_BUFFER, 0, sizeof(GPUDebug), &scene.getDebug());
shader.set_int("u_frameCount", window.getFrameCount());
shader.set_int("u_objectsNum", object_data.size());
shader.set_int("u_bvhNum", bvh_data.size());
shader.set_int("u_lightsNum", gpu_lights.size());
shader.set_int("u_pixelisation", window.getPixelisation());
shader.set_float("u_time", (float)(glfwGetTime()));
shader.set_vec2("u_resolution", glm::vec2(WIDTH, HEIGHT));
shader.set_textures(scene.getTextureIDs(), scene.getEmissionTextureIDs());
glDispatchCompute((WIDTH + 15) / 16, (HEIGHT + 15) / 16, 1);
glMemoryBarrier(GL_SHADER_IMAGE_ACCESS_BARRIER_BIT);
GPUDenoise denoise = scene.getDenoise();
if (denoise.enabled)
{
glUseProgram(shader.getProgramComputeDenoising());
glUniform2fv(glGetUniformLocation(shader.getProgramComputeDenoising(), "u_resolution"), 1, glm::value_ptr(glm::vec2(WIDTH, HEIGHT)));
glUniform1f(glGetUniformLocation(shader.getProgramComputeDenoising(), "u_c_phi"), denoise.c_phi);
glUniform1f(glGetUniformLocation(shader.getProgramComputeDenoising(), "u_p_phi"), denoise.p_phi);
glUniform1f(glGetUniformLocation(shader.getProgramComputeDenoising(), "u_n_phi"), denoise.n_phi);
for (int pass = 0; pass < denoise.pass ; ++pass)
{
shader.flipOutputDenoising(pass % 2 == 0);
glUniform1i(glGetUniformLocation(shader.getProgramComputeDenoising(), "u_pass"), pass);
glDispatchCompute((WIDTH + 15) / 16, (HEIGHT + 15) / 16, 1);
glMemoryBarrier(GL_SHADER_IMAGE_ACCESS_BARRIER_BIT);
}
shader.flipOutputDenoising(true);
}
glClear(GL_COLOR_BUFFER_BIT); glClear(GL_COLOR_BUFFER_BIT);
updateDataOnGPU(scene, buffers);
raytracing_program.use();
raytracing_program.set_int("u_frameCount", window.getFrameCount());
raytracing_program.set_int("u_objectsNum", scene.getObjectData().size());
raytracing_program.set_int("u_bvhNum", scene.getBvhData().size());
raytracing_program.set_int("u_lightsNum", scene.getGPULights().size());
raytracing_program.set_int("u_pixelisation", window.getPixelisation());
raytracing_program.set_float("u_time", (float)(glfwGetTime()));
raytracing_program.set_vec2("u_resolution", glm::vec2(WIDTH, HEIGHT));
raytracing_program.dispathCompute((WIDTH + 15) / 16, (HEIGHT + 15) / 16, 1);
window.imGuiNewFrame(); window.imGuiNewFrame();
glUseProgram(shader.getProgram()); render_program.use();
shader.drawTriangles(); drawScreenTriangle(VAO, output_texture, render_program.getProgram());
window.imGuiRender(); window.imGuiRender();
window.display(); window.display();
window.pollEvents(); window.pollEvents();
glClearTexImage(shader.getNormalTexture(), 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
glClearTexImage(shader.getPositionTexture(), 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
} }
ImGui_ImplOpenGL3_Shutdown(); ImGui_ImplOpenGL3_Shutdown();

117
srcs/RT_utils.cpp Normal file
View File

@ -0,0 +1,117 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* RT_utils.cpp :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: TheRed <TheRed@students.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2025/02/12 23:21:09 by TheRed #+# #+# */
/* Updated: 2025/02/12 23:21:09 by TheRed ### ########.fr */
/* */
/* ************************************************************************** */
#include "RT.hpp"
void setupScreenTriangle(GLuint *VAO)
{
GLuint VBO;
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}}};
size_t size = sizeof(vertices) / sizeof(Vertex) / 3; // size 1
glGenVertexArrays(1, VAO);
glBindVertexArray(*VAO);
glGenBuffers(1, &VBO);
glBindBuffer(GL_ARRAY_BUFFER, VBO);
glBufferData(GL_ARRAY_BUFFER, size * 3 * sizeof(Vertex), vertices, GL_STATIC_DRAW);
// 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 drawScreenTriangle(GLuint VAO, GLuint output_texture, GLuint program)
{
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, output_texture);
glUniform1i(glGetUniformLocation(program, "screenTexture"), 0);
glBindVertexArray(VAO);
glDrawArrays(GL_TRIANGLES, 0, 1 * 3); // size 1
}
std::vector<GLuint> generateTextures(unsigned int textures_count)
{
std::vector<GLuint> textures(textures_count);
glGenTextures(textures_count, textures.data());
for (unsigned int i = 0; i < textures_count; ++i)
{
glBindTexture(GL_TEXTURE_2D, textures[i]);
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(i, textures[i], 0, GL_FALSE, 0, GL_READ_WRITE, GL_RGBA32F);
}
return (textures);
}
std::vector<Buffer *> createDataOnGPU(Scene &scene)
{
GLint max_gpu_size;
glGetIntegerv(GL_MAX_SHADER_STORAGE_BLOCK_SIZE, &max_gpu_size);
const std::vector<GPUObject> &object_data = scene.getObjectData();
const std::vector<GPUTriangle> &triangle_data = scene.getTriangleData();
const std::vector<GPUBvh> &bvh_nodes = scene.getBvh();
const std::vector<GPUBvhData> &bvh_data = scene.getBvhData();
const std::vector<GPUMaterial> &material_data = scene.getMaterialData();
std::cout << "Sending " << object_data.size() << " objects for " << \
object_data.size() * sizeof(GPUObject) + \
triangle_data.size() * sizeof(GPUTriangle) + \
bvh_nodes.size() * sizeof(GPUBvh) + \
material_data.size() * sizeof(GPUMaterial) \
<< " / " << max_gpu_size << " bytes" << std::endl;
std::vector<Buffer *> buffers;
buffers.push_back(new Buffer(Buffer::Type::SSBO, 1, sizeof(GPUObject) * object_data.size(), object_data.data()));
buffers.push_back(new Buffer(Buffer::Type::SSBO, 2, sizeof(GPUTriangle) * triangle_data.size(), triangle_data.data()));
buffers.push_back(new Buffer(Buffer::Type::SSBO, 3, sizeof(GPUBvhData) * bvh_data.size(), bvh_data.data()));
buffers.push_back(new Buffer(Buffer::Type::SSBO, 4, sizeof(GPUBvh) * bvh_nodes.size(), bvh_nodes.data()));
buffers.push_back(new Buffer(Buffer::Type::SSBO, 5, sizeof(GPUMaterial) * material_data.size(), nullptr));
buffers.push_back(new Buffer(Buffer::Type::SSBO, 6, scene.getGPULights().size() * sizeof(int), nullptr));
buffers.push_back(new Buffer(Buffer::Type::UBO, 0, sizeof(GPUCamera), nullptr));
buffers.push_back(new Buffer(Buffer::Type::UBO, 1, sizeof(GPUVolume), nullptr));
buffers.push_back(new Buffer(Buffer::Type::UBO, 2, sizeof(GPUDebug), nullptr));
return (buffers);
}
void updateDataOnGPU(Scene &scene, std::vector<Buffer *> buffers)
{
const std::vector<GPUMaterial> &material_data = scene.getMaterialData();
const std::set<int> &gpu_lights = scene.getGPULights();
std::vector<int> gpu_lights_array(gpu_lights.begin(), gpu_lights.end());
buffers[4]->update(material_data.data(), sizeof(GPUMaterial) * material_data.size());
buffers[5]->update(gpu_lights_array.data(), gpu_lights.size() * sizeof(int));
GPUCamera camera_data = scene.getCamera()->getGPUData();
buffers[6]->update(&camera_data, sizeof(GPUCamera));
buffers[7]->update(&scene.getVolume(), sizeof(GPUVolume));
buffers[8]->update(&scene.getDebug(), sizeof(GPUDebug));
}

94
srcs/class/Shader.cpp
View File

@ -61,52 +61,36 @@ void printWithLineNumbers(const char *str)
std::cout << lineNumber++ << ": " << line << std::endl; std::cout << lineNumber++ << ": " << line << std::endl;
} }
Shader::Shader(std::string vertexPath, std::string fragmentPath, std::string computePath, std::string denoisingPath) Shader::Shader(GLenum type, const std::string &file_path)
{ {
const char *vertexCode = loadFileWithIncludes(vertexPath); _type = type;
const char *fragmentCode = loadFileWithIncludes(fragmentPath); _file_path = file_path;
const char *computeCode = loadFileWithIncludes(computePath); _shader_id = 0;
const char *denoisingCode = loadFileWithIncludes(denoisingPath);
// printWithLineNumbers(computeCode); this->compile();
_vertex = glCreateShader(GL_VERTEX_SHADER);
glShaderSource(_vertex, 1, &vertexCode, NULL);
glCompileShader(_vertex);
checkCompileErrors(_vertex);
_fragment = glCreateShader(GL_FRAGMENT_SHADER);
glShaderSource(_fragment, 1, &fragmentCode, NULL);
glCompileShader(_fragment);
checkCompileErrors(_fragment);
_compute = glCreateShader(GL_COMPUTE_SHADER);
glShaderSource(_compute, 1, &computeCode, NULL);
glCompileShader(_compute);
checkCompileErrors(_compute);
_denoising = glCreateShader(GL_COMPUTE_SHADER);
glShaderSource(_denoising, 1, &denoisingCode, NULL);
glCompileShader(_denoising);
checkCompileErrors(_denoising);
} }
Shader::~Shader(void) Shader::~Shader(void)
{ {
glDeleteShader(_vertex); }
glDeleteShader(_fragment);
glDeleteShader(_compute); void Shader::compile()
glDeleteProgram(_program); {
glDeleteProgram(_program_compute); _shader_id = glCreateShader(_type);
glDeleteProgram(_denoising);
const char *shader_code = loadFileWithIncludes(_file_path);
// printWithLineNumbers(shader_code);
glShaderSource(_shader_id, 1, &shader_code, NULL);
glCompileShader(_shader_id);
this->checkCompileErrors();
}
void Shader::reload()
{
glDeleteShader(_shader_id);
this->compile();
} }
void Shader::attach(void) void Shader::attach(void)
@ -176,15 +160,15 @@ void Shader::attach(void)
glBindImageTexture(4, _position_texture, 0, GL_FALSE, 0, GL_READ_WRITE, GL_RGBA32F); glBindImageTexture(4, _position_texture, 0, GL_FALSE, 0, GL_READ_WRITE, GL_RGBA32F);
} }
void Shader::checkCompileErrors(GLuint shader) void Shader::checkCompileErrors()
{ {
GLint success; GLint success;
GLchar infoLog[512]; GLchar infoLog[512];
glGetShaderiv(shader, GL_COMPILE_STATUS, &success); glGetShaderiv(_shader_id, GL_COMPILE_STATUS, &success);
if (!success) if (!success)
{ {
glGetShaderInfoLog(shader, 512, NULL, infoLog); glGetShaderInfoLog(_shader_id, 512, NULL, infoLog);
std::cout << "ERROR::SHADER::COMPILATION_FAILED\n" << infoLog << std::endl; std::cout << "ERROR::SHADER::COMPILATION_FAILED\n" << infoLog << std::endl;
} }
} }
@ -287,29 +271,9 @@ void Shader::set_textures(std::vector<GLuint> texture_ids, std::vector<GLuint> e
} }
GLuint Shader::getProgram(void) const GLuint Shader::getShader(void) const
{ {
return (_program); return (_shader_id);
}
GLuint Shader::getProgramCompute(void) const
{
return (_program_compute);
}
GLuint Shader::getProgramComputeDenoising(void) const
{
return (_program_denoising);
}
GLuint Shader::getNormalTexture(void) const
{
return (_normal_texture);
}
GLuint Shader::getPositionTexture(void) const
{
return (_position_texture);
} }
std::vector<float> Shader::getOutputImage(void) std::vector<float> Shader::getOutputImage(void)

92
srcs/class/ShaderProgram.cpp Normal file
View File

@ -0,0 +1,92 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ShaderProgram.cpp :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: TheRed <TheRed@students.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2025/02/12 22:21:46 by TheRed #+# #+# */
/* Updated: 2025/02/12 22:21:46 by TheRed ### ########.fr */
/* */
/* ************************************************************************** */
#include "ShaderProgram.hpp"
ShaderProgram::ShaderProgram()
{
_program = glCreateProgram();
}
ShaderProgram::~ShaderProgram(void)
{
glDeleteProgram(_program);
}
void ShaderProgram::attachShader(Shader *shader)
{
_shaders.push_back(shader);
glAttachShader(_program, shader->getShader());
}
void ShaderProgram::link()
{
glLinkProgram(_program);
GLint success;
glGetProgramiv(_program, GL_LINK_STATUS, &success);
if (!success)
{
GLchar infoLog[512];
glGetProgramInfoLog(_program, 512, NULL, infoLog);
std::cerr << "ERROR::SHADER::PROGRAM::LINKING_FAILED\n" << infoLog << std::endl;
}
}
void ShaderProgram::use() const
{
glUseProgram(_program);
}
void ShaderProgram::dispathCompute(GLuint x, GLuint y, GLuint z) const
{
this->use();
glDispatchCompute(x, y, z);
glMemoryBarrier(GL_SHADER_IMAGE_ACCESS_BARRIER_BIT);
}
void ShaderProgram::bindImageTexture(GLuint texture_id, GLuint unit, GLenum access, GLenum format) const
{
glBindImageTexture(unit, texture_id, 0, GL_FALSE, 0, access, format);
}
void ShaderProgram::reloadShaders(void)
{
std::cout << "Reloading shaders" << std::endl;
for (Shader *shader : _shaders)
{
glDetachShader(_program, shader->getShader());
shader->reload();
glAttachShader(_program, shader->getShader());
}
this->link();
}
void ShaderProgram::set_int(const std::string &name, int value) const
{
glUniform1i(glGetUniformLocation(_program, name.c_str()), value);
}
void ShaderProgram::set_float(const std::string &name, float value) const
{
glUniform1f(glGetUniformLocation(_program, name.c_str()), value);
}
void ShaderProgram::set_vec2(const std::string &name, const glm::vec2 &value) const
{
glUniform2fv(glGetUniformLocation(_program, name.c_str()), 1, glm::value_ptr(value));
}
GLuint ShaderProgram::getProgram(void) const
{
return (_program);
}