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

Merge branch 'ShaderReload'

Browse Source
This commit is contained in:
tomoron
2025-02-14 18:47:03 +01:00
parent cb87646621 a704a1fd76
commit 0544bc3a0f
23 changed files with 906 additions and 752 deletions
Download Patch File Download Diff File Expand all files Collapse all files

193
srcs/RT.cpp
View File

@ -6,178 +6,101 @@
/* By: ycontre <ycontre@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/09/27 14:51:49 by TheRed #+# #+# */
/* Updated: 2025/02/13 14:26:18 by tomoron ### ########.fr */
/* Updated: 2025/02/14 18:26:34 by tomoron ### ########.fr */
/* */
/* ************************************************************************** */
#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);
void shaderDenoise(ShaderProgram &denoising_program, GPUDenoise &denoise, std::vector<GLuint> textures);
int main(int argc, char **argv)
{
Arguments args(argc, argv);
if (args.error())
return (1);
Scene scene(args.getSceneName());
if (scene.fail())
return (1);
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);
GLint max_gpu_size;
glGetIntegerv(GL_MAX_SHADER_STORAGE_BLOCK_SIZE, &max_gpu_size);
std::vector<GLuint> textures = generateTextures(5);
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();
ShaderProgram raytracing_program;
Shader compute = Shader(GL_COMPUTE_SHADER, "shaders/compute.glsl");
raytracing_program.attachShader(&compute);
raytracing_program.link();
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;
ShaderProgram denoising_program;
Shader denoise = Shader(GL_COMPUTE_SHADER, "shaders/denoising.glsl");
denoising_program.attachShader(&denoise);
denoising_program.link();
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);
ShaderProgram render_program;
Shader vertex = Shader(GL_VERTEX_SHADER, "shaders/vertex.vert");
Shader frag = Shader(GL_FRAGMENT_SHADER, "shaders/frag.frag");
render_program.attachShader(&vertex);
render_program.attachShader(&frag);
render_program.link();
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);
std::vector<Buffer *> buffers = createDataOnGPU(scene);
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();
return (-1);
while (!window.shouldClose())
{
window.updateDeltaTime();
glUseProgram(shader.getProgramCompute());
updateDataOnGPU(scene, buffers);
window.rendererUpdate(textures[0]);
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);
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));
std::map<std::string, std::vector<GLuint>> object_textures;
object_textures["textures"] = scene.getTextureIDs();
object_textures["emissive_textures"] = scene.getEmissionTextureIDs();
raytracing_program.set_textures(object_textures);
raytracing_program.dispathCompute((WIDTH + 15) / 16, (HEIGHT + 15) / 16, 1);
if (scene.getDenoise().enabled)
shaderDenoise(denoising_program, scene.getDenoise(), textures);
window.imGuiNewFrame();
glUseProgram(shader.getProgram());
shader.drawTriangles();
render_program.use();
drawScreenTriangle(VAO, textures[0], render_program.getProgram());
window.imGuiRender();
window.imGuiRender(raytracing_program);
window.display();
window.pollEvents();
glClearTexImage(shader.getNormalTexture(), 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
glClearTexImage(shader.getPositionTexture(), 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
glClearTexImage(textures[3], 0, GL_RGBA, GL_FLOAT, nullptr);
glClearTexImage(textures[4], 0, GL_RGBA, GL_FLOAT, nullptr);
}
ImGui_ImplOpenGL3_Shutdown();

144
srcs/RT_utils.cpp Normal file
View File

@ -0,0 +1,144 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* 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));
}
void shaderDenoise(ShaderProgram &denoising_program, GPUDenoise &denoise, std::vector<GLuint> textures)
{
denoising_program.use();
denoising_program.set_vec2("u_resolution", glm::vec2(WIDTH, HEIGHT));
denoising_program.set_float("u_c_phi", denoise.c_phi);
denoising_program.set_float("u_p_phi", denoise.p_phi);
denoising_program.set_float("u_n_phi", denoise.n_phi);
int output_texture = 0;
int denoising_texture = 2;
for (int pass = 0; pass < denoise.pass ; ++pass)
{
glBindImageTexture(0, textures[output_texture], 0, GL_FALSE, 0, GL_READ_WRITE, GL_RGBA32F);
glBindImageTexture(2, textures[denoising_texture], 0, GL_FALSE, 0, GL_READ_WRITE, GL_RGBA32F);
denoising_program.set_int("u_pass", pass);
denoising_program.dispathCompute((WIDTH + 15) / 16, (HEIGHT + 15) / 16, 1);
std::swap(output_texture, denoising_texture);
}
glBindImageTexture(0, textures[output_texture], 0, GL_FALSE, 0, GL_READ_WRITE, GL_RGBA32F);
}

19
srcs/class/Renderer.cpp
View File

@ -3,10 +3,10 @@
/* ::: :::::::: */
/* Renderer.cpp :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: tomoron <tomoron@student.42angouleme.fr> +#+ +:+ +#+ */
/* By: ycontre <ycontre@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2025/01/22 16:34:53 by tomoron #+# #+# */
/* Updated: 2025/02/07 23:24:53 by tomoron ### ########.fr */
/* Updated: 2025/02/13 19:03:34 by ycontre ### ########.fr */
/* */
/* ************************************************************************** */
@ -300,14 +300,17 @@ void Renderer::initRender(void)
SWS_BILINEAR, nullptr, nullptr, nullptr);
}
void Renderer::addImageToRender(Shader &shader)
void Renderer::addImageToRender(GLuint &texture)
{
std::vector<float> image;
std::vector<float> image(WIDTH * HEIGHT * 4);
AVPacket *pkt;
long int videoFrameOffset;
long int outputImageOffset;
image = shader.getOutputImage();
glBindTexture(GL_TEXTURE_2D, texture);
glGetTexImage(GL_TEXTURE_2D, 0, GL_RGBA, GL_FLOAT, image.data());
glBindTexture(GL_TEXTURE_2D, 0);
for (int x = 0; x < WIDTH; x++)
{
@ -400,7 +403,7 @@ void Renderer::addPoint(float time)
_path.insert(pos, newPoint);
}
void Renderer::update(Shader &shader)
void Renderer::update(GLuint &texture)
{
double curTime;
@ -421,7 +424,7 @@ void Renderer::update(Shader &shader)
if(!_testMode)
{
addImageToRender(shader);
addImageToRender(texture);
_frameCount++;
}
makeMovement(curTime - _curSplitStart, curTime);

2
srcs/class/Scene.cpp
View File

@ -6,7 +6,7 @@
/* By: ycontre <ycontre@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/12/23 18:29:41 by ycontre #+# #+# */
/* Updated: 2025/02/04 16:43:33 by tomoron ### ########.fr */
/* Updated: 2025/02/13 18:13:58 by ycontre ### ########.fr */
/* */
/* ************************************************************************** */

291
srcs/class/Shader.cpp
View File

@ -6,7 +6,7 @@
/* By: ycontre <ycontre@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/10/13 20:21:13 by ycontre #+# #+# */
/* Updated: 2025/02/06 19:48:22 by ycontre ### ########.fr */
/* Updated: 2025/02/13 18:59:18 by ycontre ### ########.fr */
/* */
/* ************************************************************************** */
@ -16,12 +16,12 @@
#include <stdlib.h>
#include <string.h>
const char *loadFileWithIncludes(const std::string& path)
std::stringstream loadFileWithIncludes(const std::string& path, std::vector<std::string> &included_files)
{
std::ifstream file(path);
if (!file.is_open()) {
std::cerr << "Failed to open file: " << path << std::endl;
return "";
return std::stringstream();
}
std::stringstream fileContent;
@ -36,7 +36,9 @@ const char *loadFileWithIncludes(const std::string& path)
if (start != std::string::npos && end != std::string::npos && end > start)
{
std::string includePath = line.substr(start + 1, end - start - 1);
std::string includedContent = loadFileWithIncludes(includePath);
included_files.push_back(includePath);
std::string includedContent = loadFileWithIncludes(includePath, included_files).str();
fileContent << includedContent << "\n";
}
}
@ -44,7 +46,7 @@ const char *loadFileWithIncludes(const std::string& path)
fileContent << line << "\n";
}
return strdup(fileContent.str().c_str());
return (fileContent);
}
@ -61,263 +63,86 @@ void printWithLineNumbers(const char *str)
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);
const char *fragmentCode = loadFileWithIncludes(fragmentPath);
const char *computeCode = loadFileWithIncludes(computePath);
const char *denoisingCode = loadFileWithIncludes(denoisingPath);
_type = type;
_file_path = file_path;
_shader_id = 0;
// printWithLineNumbers(computeCode);
_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);
this->compile();
}
Shader::~Shader(void)
{
glDeleteShader(_vertex);
glDeleteShader(_fragment);
glDeleteShader(_compute);
glDeleteProgram(_program);
glDeleteProgram(_program_compute);
glDeleteProgram(_denoising);
}
void Shader::attach(void)
void Shader::compile()
{
_program = glCreateProgram();
_program_compute = glCreateProgram();
_program_denoising = glCreateProgram();
_shader_id = glCreateShader(_type);
std::vector<std::string> files;
files.push_back(_file_path);
glEnable(GL_DEBUG_OUTPUT);
glEnable(GL_DEBUG_OUTPUT_SYNCHRONOUS);
glDebugMessageControl(GL_DONT_CARE, GL_DONT_CARE, GL_DONT_CARE, 0, nullptr, GL_TRUE);
std::string shader_code = loadFileWithIncludes(_file_path, files).str();
for (auto &file : files)
_files_timestamps[file] = std::filesystem::last_write_time(file);
glAttachShader(_program, _vertex);
glAttachShader(_program, _fragment);
for (auto &define : _defines)
shader_code = "#define SHADER_" + define.first + " " + define.second + "\n" + shader_code;
shader_code = "#version 430\n" + shader_code;
glAttachShader(_program_compute, _compute);
const char *shader_code_cstr = shader_code.c_str();
// printWithLineNumbers(shader_code_cstr);
glShaderSource(_shader_id, 1, &shader_code_cstr, NULL);
glCompileShader(_shader_id);
glAttachShader(_program_denoising, _denoising);
glLinkProgram(_program);
glLinkProgram(_program_compute);
glLinkProgram(_program_denoising);
glGenTextures(1, &_output_texture);
glBindTexture(GL_TEXTURE_2D, _output_texture);
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, _output_texture, 0, GL_FALSE, 0, GL_READ_WRITE, GL_RGBA32F);
glGenTextures(1, &_accumulation_texture);
glBindTexture(GL_TEXTURE_2D, _accumulation_texture);
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(1, _accumulation_texture, 0, GL_FALSE, 0, GL_READ_WRITE, GL_RGBA32F);
glGenTextures(1, &_denoising_texture);
glBindTexture(GL_TEXTURE_2D, _denoising_texture);
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(2, _denoising_texture, 0, GL_FALSE, 0, GL_READ_WRITE, GL_RGBA32F);
glGenTextures(1, &_normal_texture);
glBindTexture(GL_TEXTURE_2D, _normal_texture);
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(3, _normal_texture, 0, GL_FALSE, 0, GL_READ_WRITE, GL_RGBA32F);
glGenTextures(1, &_position_texture);
glBindTexture(GL_TEXTURE_2D, _position_texture);
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(4, _position_texture, 0, GL_FALSE, 0, GL_READ_WRITE, GL_RGBA32F);
this->checkCompileErrors();
}
void Shader::checkCompileErrors(GLuint shader)
bool Shader::hasChanged()
{
for (auto &file : _files_timestamps)
{
if (std::filesystem::last_write_time(file.first) != file.second)
{
_files_timestamps[file.first] = std::filesystem::last_write_time(file.first);
return (true);
}
}
return (false);
}
void Shader::reload()
{
glDeleteShader(_shader_id);
this->compile();
}
void Shader::checkCompileErrors()
{
GLint success;
GLchar infoLog[512];
glGetShaderiv(shader, GL_COMPILE_STATUS, &success);
glGetShaderiv(_shader_id, GL_COMPILE_STATUS, &success);
if (!success)
{
glGetShaderInfoLog(shader, 512, NULL, infoLog);
glGetShaderInfoLog(_shader_id, 512, NULL, infoLog);
std::cout << "ERROR::SHADER::COMPILATION_FAILED\n" << infoLog << std::endl;
}
}
void Shader::setupVertexBuffer()
void Shader::setDefine(const std::string &name, const std::string &value)
{
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 = sizeof(vertices) / sizeof(Vertex) / 3;
glGenVertexArrays(1, &_screen_VAO);
glGenBuffers(1, &_screen_VBO);
glBindVertexArray(_screen_VAO);
glBindBuffer(GL_ARRAY_BUFFER, _screen_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);
_defines[name] = value;
}
void Shader::drawTriangles()
GLuint Shader::getShader(void) const
{
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, _output_texture);
glUniform1i(glGetUniformLocation(_program, "screenTexture"), 0);
glBindVertexArray(_screen_VAO);
glDrawArrays(GL_TRIANGLES, 0, _size * 3);
return (_shader_id);
}
void Shader::flipOutputDenoising(bool pass)
const std::string &Shader::getFilePath(void) const
{
if (pass)
{
glBindImageTexture(0, _output_texture, 0, GL_FALSE, 0, GL_READ_ONLY, GL_RGBA32F);
glBindImageTexture(2, _denoising_texture, 0, GL_FALSE, 0, GL_WRITE_ONLY, GL_RGBA32F);
}
else
{
glBindImageTexture(0, _denoising_texture, 0, GL_FALSE, 0, GL_READ_ONLY, GL_RGBA32F);
glBindImageTexture(2, _output_texture, 0, GL_FALSE, 0, GL_WRITE_ONLY, GL_RGBA32F);
}
}
void Shader::set_int(const std::string &name, int value) const
{
glUniform1i(glGetUniformLocation(_program_compute, name.c_str()), value);
}
void Shader::set_float(const std::string &name, float value) const
{
glUniform1f(glGetUniformLocation(_program_compute, name.c_str()), value);
}
void Shader::set_vec2(const std::string &name, const glm::vec2 &value) const
{
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_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_compute, name.c_str()), 1, GL_FALSE, glm::value_ptr(value));
}
void Shader::set_textures(std::vector<GLuint> texture_ids, std::vector<GLuint> emissive_texture_ids)
{
for (size_t i = 0; i < texture_ids.size(); i++)
{
glActiveTexture(GL_TEXTURE0 + i);
glBindTexture(GL_TEXTURE_2D, texture_ids[i]);
std::string uniform_name = "textures[" + std::to_string(i) + "]";
// std::cout << "Loading texture " << uniform_name << " at unit " << i << std::endl;
glUniform1i(glGetUniformLocation(_program_compute, uniform_name.c_str()), i);
}
size_t start_texture = texture_ids.size();
for (size_t i = 0; i < emissive_texture_ids.size(); i++)
{
GLuint currentUnit = start_texture + i;
glActiveTexture(GL_TEXTURE0 + currentUnit);
glBindTexture(GL_TEXTURE_2D, emissive_texture_ids[i]);
std::string uniform_name = "emissive_textures[" + std::to_string(i) + "]";
// std::cout << "Loading emissive texture " << uniform_name << " (" << emissive_texture_ids[i] << ") at unit " << currentUnit << std::endl;
glUniform1i(glGetUniformLocation(_program_compute, uniform_name.c_str()), currentUnit);
}
}
GLuint Shader::getProgram(void) const
{
return (_program);
}
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> res(WIDTH * HEIGHT * 4);
glBindTexture(GL_TEXTURE_2D, _output_texture);
glGetTexImage(GL_TEXTURE_2D, 0, GL_RGBA, GL_FLOAT, res.data());
glBindTexture(GL_TEXTURE_2D, 0);
return (res);
}
return (_file_path);
}

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

@ -0,0 +1,141 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ShaderProgram.cpp :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: ycontre <ycontre@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2025/02/12 22:21:46 by TheRed #+# #+# */
/* Updated: 2025/02/13 19:16:44 by ycontre ### ########.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::clearShaders()
{
for (Shader *shader : _shaders)
glDetachShader(_program, shader->getShader());
_shaders.clear();
}
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()
{
glUseProgram(_program);
this->watchForChanges();
}
void ShaderProgram::dispathCompute(GLuint x, GLuint y, GLuint z)
{
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::watchForChanges(void)
{
for (Shader *shader : _shaders)
{
if (shader->hasChanged())
{
std::cout << "Shader " << shader->getFilePath() << " has changed" << std::endl;
this->reloadShaders();
break;
}
}
}
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));
}
void ShaderProgram::set_textures(std::map<std::string, std::vector<GLuint>> texture_ids)
{
size_t start_texture = 0;
for (auto it = texture_ids.begin(); it != texture_ids.end(); it++)
{
for (unsigned int i = 0; i < it->second.size(); i++)
{
GLuint current_unit = start_texture + i;
glActiveTexture(GL_TEXTURE0 + current_unit);
glBindTexture(GL_TEXTURE_2D, it->second[i]);
std::string uniform_name = it->first + "[" + std::to_string(i) + "]";
// std::cout << "Loading texture " << uniform_name << " at unit " << i << std::endl;
glUniform1i(glGetUniformLocation(_program, uniform_name.c_str()), current_unit);
}
start_texture = it->second.size();
}
}
void ShaderProgram::set_define(const std::string &name, const std::string &value)
{
for (Shader *shader : _shaders)
shader->setDefine(name, value);
}
GLuint ShaderProgram::getProgram(void) const
{
return (_program);
}

34
srcs/class/Window.cpp
View File

@ -172,9 +172,9 @@ bool Window::shouldClose()
return glfwWindowShouldClose(_window) || _renderer->shouldClose();
}
void Window::rendererUpdate(Shader &shader)
void Window::rendererUpdate(GLuint &texture)
{
_renderer->update(shader);
_renderer->update(texture);
}
void Window::imGuiNewFrame()
@ -184,7 +184,7 @@ void Window::imGuiNewFrame()
ImGui::NewFrame();
}
void Window::imGuiRender()
void Window::imGuiRender(ShaderProgram &raytracing_program)
{
bool has_changed = false;
@ -253,7 +253,12 @@ void Window::imGuiRender()
if (ImGui::CollapsingHeader("Fog"))
{
has_changed |= ImGui::Checkbox("Enable", (bool *)(&_scene->getVolume().enabled));
if (ImGui::Checkbox("Enable##0", (bool *)(&_scene->getVolume().enabled)))
{
raytracing_program.set_define("FOG", std::to_string(_scene->getVolume().enabled));
raytracing_program.reloadShaders();
has_changed = true;
}
ImGui::Separator();
if (ImGui::SliderFloat("Absorption", &_scene->getVolume().sigma_a.x, 0., 0.1))
@ -274,9 +279,7 @@ void Window::imGuiRender()
if (ImGui::CollapsingHeader("Denoiser"))
{
ImGui::PushID(0);
ImGui::Checkbox("Enable", (bool *)(&_scene->getDenoise().enabled));
ImGui::Checkbox("Enable##1", (bool *)(&_scene->getDenoise().enabled));
ImGui::Separator();
if (ImGui::SliderInt("Pass", &_scene->getDenoise().pass, 0, 8))
_scene->getDenoise().pass = (_scene->getDenoise().pass / 2) * 2; // make sure it's even
@ -284,21 +287,20 @@ void Window::imGuiRender()
ImGui::SliderFloat("Color diff", &_scene->getDenoise().c_phi, 0.0f, 1.0f);
ImGui::SliderFloat("Position diff", &_scene->getDenoise().p_phi, 0.0f, 1.0f);
ImGui::SliderFloat("Normal diff", &_scene->getDenoise().n_phi, 0.0f, 1.0f);
ImGui::PopID();
}
if (ImGui::CollapsingHeader("Debug"))
{
ImGui::PushID(0);
has_changed |= ImGui::Checkbox("Enable", (bool *)(&_scene->getDebug().enabled));
if (ImGui::Checkbox("Enable##2", (bool *)(&_scene->getDebug().enabled)))
{
raytracing_program.set_define("DEBUG", std::to_string(_scene->getDebug().enabled));
raytracing_program.reloadShaders();
has_changed = true;
}
ImGui::Separator();
has_changed |= ImGui::SliderInt("Debug mode", &_scene->getDebug().mode, 0, 2);
has_changed |= ImGui::SliderInt("Box treshold", &_scene->getDebug().box_treshold, 1, 2000);
has_changed |= ImGui::SliderInt("Triangle treshold", &_scene->getDebug().triangle_treshold, 1, 2000);
ImGui::PopID();
}
@ -346,9 +348,9 @@ int Window::getPixelisation(void)
if (mouse || movement)
{
if(_fps < 60 && _pixelisation < 16)
if(_fps < 30 && _pixelisation < 16)
_pixelisation++;
if(_fps > 120 && _pixelisation > 0)
if(_fps > 60 && _pixelisation > 0)
_pixelisation--;
}
else if(_pixelisation)