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

+ | Define system + denoising back

Browse Source
This commit is contained in:
TheRedShip
2025-02-13 23:18:04 +01:00
parent 9b8da6ebd8
commit 4ddacdaadd
14 changed files with 376 additions and 319 deletions
Download Patch File Download Diff File Expand all files Collapse all files

56
srcs/RT.cpp
View File

@ -18,6 +18,32 @@ 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)
{
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);
}
int main(int argc, char **argv)
{
Arguments args(argc, argv);
@ -33,20 +59,21 @@ int main(int argc, char **argv)
GLuint VAO;
setupScreenTriangle(&VAO);
std::vector<GLuint> textures = generateTextures(2);
GLuint output_texture = textures[0];
std::vector<GLuint> textures = generateTextures(5);
ShaderProgram raytracing_program;
Shader compute = Shader(GL_COMPUTE_SHADER, "shaders/compute.glsl");
Shader debug = Shader(GL_COMPUTE_SHADER, "shaders/debug.glsl");
raytracing_program.attachShader(&compute);
raytracing_program.link();
ShaderProgram denoising_program;
Shader denoise = Shader(GL_COMPUTE_SHADER, "shaders/denoising.glsl");
denoising_program.attachShader(&denoise);
denoising_program.link();
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();
@ -62,15 +89,6 @@ int main(int argc, char **argv)
glClear(GL_COLOR_BUFFER_BIT);
updateDataOnGPU(scene, buffers);
if (scene.getDebug().enabled)
{
raytracing_program.clearShaders();
raytracing_program.attachShader(&debug);
raytracing_program.link();
scene.getDebug().enabled = 0;
}
raytracing_program.use();
raytracing_program.set_int("u_frameCount", window.getFrameCount());
@ -88,15 +106,21 @@ int main(int argc, char **argv)
raytracing_program.dispathCompute((WIDTH + 15) / 16, (HEIGHT + 15) / 16, 1);
if (scene.getDenoise().enabled)
shaderDenoise(denoising_program, scene.getDenoise(), textures);
window.imGuiNewFrame();
render_program.use();
drawScreenTriangle(VAO, output_texture, render_program.getProgram());
drawScreenTriangle(VAO, textures[0], render_program.getProgram());
window.imGuiRender();
window.imGuiRender(raytracing_program);
window.display();
window.pollEvents();
glClearTexImage(textures[3], 0, GL_RGBA, GL_FLOAT, nullptr);
glClearTexImage(textures[4], 0, GL_RGBA, GL_FLOAT, nullptr);
}
ImGui_ImplOpenGL3_Shutdown();

25
srcs/class/Shader.cpp
View File

@ -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::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,7 @@ 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);
std::string includedContent = loadFileWithIncludes(includePath).str();
fileContent << includedContent << "\n";
}
}
@ -44,7 +44,7 @@ const char *loadFileWithIncludes(const std::string& path)
fileContent << line << "\n";
}
return strdup(fileContent.str().c_str());
return fileContent;
}
@ -78,10 +78,16 @@ void Shader::compile()
{
_shader_id = glCreateShader(_type);
const char *shader_code = loadFileWithIncludes(_file_path);
// printWithLineNumbers(shader_code);
std::string shader_code = loadFileWithIncludes(_file_path).str();
glShaderSource(_shader_id, 1, &shader_code, NULL);
for (auto &define : _defines)
shader_code = "#define SHADER_" + define.first + " " + define.second + "\n" + shader_code;
shader_code = "#version 430\n" + shader_code;
const char *shader_code_cstr = shader_code.c_str();
// printWithLineNumbers(shader_code_cstr);
glShaderSource(_shader_id, 1, &shader_code_cstr, NULL);
glCompileShader(_shader_id);
this->checkCompileErrors();
@ -106,6 +112,11 @@ void Shader::checkCompileErrors()
}
}
void Shader::setDefine(const std::string &name, const std::string &value)
{
_defines[name] = value;
}
GLuint Shader::getShader(void) const
{
return (_shader_id);

6
srcs/class/ShaderProgram.cpp
View File

@ -115,6 +115,12 @@ void ShaderProgram::set_textures(std::map<std::string, std::vector<GLuint>> text
}
}
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);

16
srcs/class/Window.cpp
View File

@ -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", (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))
@ -292,7 +297,12 @@ void Window::imGuiRender()
{
ImGui::PushID(0);
has_changed |= ImGui::Checkbox("Enable", (bool *)(&_scene->getDebug().enabled));
if (ImGui::Checkbox("Enable", (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);