ternaryop
/
aurora-rendering-engine
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

chore: 将screen_blit shader的加载方式从硬编码修改为由shader_manager加载

master
ternaryop8479 2026-02-14 23:55:41 +08:00
parent 2284124628
commit 00243a090f
6 changed files with 72 additions and 85 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

BIN
examples/cornell_box
View File

Binary file not shown.

95
examples/cornell_box.cpp
View File

@ -23,7 +23,7 @@ std::unique_ptr<Scene> g_scene = nullptr;
// GLFW error callback // GLFW error callback
void glfw_error_callback(int error, const char* description) { void glfw_error_callback(int error, const char* description) {
Logger::error("GLFW Error " + std::to_string(error) + ": " + std::string(description)); ARE_LOG_ERROR("GLFW Error " + std::to_string(error) + ": " + std::string(description));
} }
/// @brief Create a quad mesh /// @brief Create a quad mesh
@ -246,7 +246,7 @@ void setup_cornell_box() {
light->set_range(10.0f); light->set_range(10.0f);
g_scene->add_light(light); g_scene->add_light(light);
Logger::info("Cornell Box scene created"); ARE_LOG_INFO("Cornell Box scene created");
} }
/// @brief Initialize GLFW and create window /// @brief Initialize GLFW and create window
@ -255,11 +255,11 @@ bool init_window() {
glfwSetErrorCallback(glfw_error_callback); glfwSetErrorCallback(glfw_error_callback);
if (!glfwInit()) { if (!glfwInit()) {
Logger::error("Failed to initialize GLFW"); ARE_LOG_ERROR("Failed to initialize GLFW");
return false; return false;
} }
Logger::info("GLFW initialized successfully"); ARE_LOG_INFO("GLFW initialized successfully");
// Request OpenGL 4.5 Core Profile // Request OpenGL 4.5 Core Profile
glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 4); glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 4);
@ -271,35 +271,35 @@ bool init_window() {
glfwWindowHint(GLFW_RESIZABLE, GL_FALSE); glfwWindowHint(GLFW_RESIZABLE, GL_FALSE);
glfwWindowHint(GLFW_SAMPLES, 0); glfwWindowHint(GLFW_SAMPLES, 0);
Logger::info("Creating window..."); ARE_LOG_INFO("Creating window...");
g_window = glfwCreateWindow(WINDOW_WIDTH, WINDOW_HEIGHT, "Aurora - Cornell Box", nullptr, nullptr); g_window = glfwCreateWindow(WINDOW_WIDTH, WINDOW_HEIGHT, "Aurora - Cornell Box", nullptr, nullptr);
if (!g_window) { if (!g_window) {
Logger::error("Failed to create GLFW window"); ARE_LOG_ERROR("Failed to create GLFW window");
Logger::error("Possible reasons:"); ARE_LOG_ERROR("Possible reasons:");
Logger::error(" 1. OpenGL 4.5 not supported by your GPU/driver"); ARE_LOG_ERROR(" 1. OpenGL 4.5 not supported by your GPU/driver");
Logger::error(" 2. No display server running (X11/Wayland)"); ARE_LOG_ERROR(" 2. No display server running (X11/Wayland)");
Logger::error(" 3. Insufficient GPU resources"); ARE_LOG_ERROR(" 3. Insufficient GPU resources");
// Try to get more info // Try to get more info
int major, minor, rev; int major, minor, rev;
glfwGetVersion(&major, &minor, &rev); glfwGetVersion(&major, &minor, &rev);
Logger::info("GLFW version: " + std::to_string(major) + "." + ARE_LOG_INFO("GLFW version: " + std::to_string(major) + "." +
std::to_string(minor) + "." + std::to_string(rev)); std::to_string(minor) + "." + std::to_string(rev));
glfwTerminate(); glfwTerminate();
return false; return false;
} }
Logger::info("Window created successfully"); ARE_LOG_INFO("Window created successfully");
glfwMakeContextCurrent(g_window); glfwMakeContextCurrent(g_window);
glfwSwapInterval(1); // Enable vsync glfwSwapInterval(1); // Enable vsync
// Load OpenGL functions // Load OpenGL functions
Logger::info("Loading OpenGL functions..."); ARE_LOG_INFO("Loading OpenGL functions...");
if (!gladLoadGLLoader((GLADloadproc)glfwGetProcAddress)) { if (!gladLoadGLLoader((GLADloadproc)glfwGetProcAddress)) {
Logger::error("Failed to initialize GLAD"); ARE_LOG_ERROR("Failed to initialize GLAD");
return false; return false;
} }
@ -309,35 +309,35 @@ bool init_window() {
const char* version = (const char*)glGetString(GL_VERSION); const char* version = (const char*)glGetString(GL_VERSION);
const char* glsl_version = (const char*)glGetString(GL_SHADING_LANGUAGE_VERSION); const char* glsl_version = (const char*)glGetString(GL_SHADING_LANGUAGE_VERSION);
Logger::info("OpenGL Vendor: " + std::string(vendor ? vendor : "Unknown")); ARE_LOG_INFO("OpenGL Vendor: " + std::string(vendor ? vendor : "Unknown"));
Logger::info("OpenGL Renderer: " + std::string(renderer ? renderer : "Unknown")); ARE_LOG_INFO("OpenGL Renderer: " + std::string(renderer ? renderer : "Unknown"));
Logger::info("OpenGL Version: " + std::string(version ? version : "Unknown")); ARE_LOG_INFO("OpenGL Version: " + std::string(version ? version : "Unknown"));
Logger::info("GLSL Version: " + std::string(glsl_version ? glsl_version : "Unknown")); ARE_LOG_INFO("GLSL Version: " + std::string(glsl_version ? glsl_version : "Unknown"));
// Check OpenGL version // Check OpenGL version
GLint major_ver, minor_ver; GLint major_ver, minor_ver;
glGetIntegerv(GL_MAJOR_VERSION, &major_ver); glGetIntegerv(GL_MAJOR_VERSION, &major_ver);
glGetIntegerv(GL_MINOR_VERSION, &minor_ver); glGetIntegerv(GL_MINOR_VERSION, &minor_ver);
Logger::info("OpenGL Context: " + std::to_string(major_ver) + "." + std::to_string(minor_ver)); ARE_LOG_INFO("OpenGL Context: " + std::to_string(major_ver) + "." + std::to_string(minor_ver));
// if (major_ver < 4 || (major_ver == 4 && minor_ver < 5)) { // if (major_ver < 4 || (major_ver == 4 && minor_ver < 5)) {
// Logger::error("OpenGL 4.5 or higher is required!"); // ARE_LOG_ERROR("OpenGL 4.5 or higher is required!");
// Logger::error("Your system supports: OpenGL " + std::to_string(major_ver) + "." + std::to_string(minor_ver)); // ARE_LOG_ERROR("Your system supports: OpenGL " + std::to_string(major_ver) + "." + std::to_string(minor_ver));
// return false; // return false;
// } // }
// Check compute shader support // Check compute shader support
GLint max_compute_work_group_invocations; GLint max_compute_work_group_invocations;
glGetIntegerv(GL_MAX_COMPUTE_WORK_GROUP_INVOCATIONS, &max_compute_work_group_invocations); glGetIntegerv(GL_MAX_COMPUTE_WORK_GROUP_INVOCATIONS, &max_compute_work_group_invocations);
Logger::info("Max compute work group invocations: " + std::to_string(max_compute_work_group_invocations)); ARE_LOG_INFO("Max compute work group invocations: " + std::to_string(max_compute_work_group_invocations));
return true; return true;
} }
/// @brief Main render loop /// @brief Main render loop
void render_loop() { void render_loop() {
Logger::info("Entering render loop..."); ARE_LOG_INFO("Entering render loop...");
int frame_count = 0; int frame_count = 0;
double last_time = glfwGetTime(); double last_time = glfwGetTime();
@ -369,11 +369,11 @@ void render_loop() {
// Print detailed stats every 60 frames // Print detailed stats every 60 frames
static int stat_frame_count = 0; static int stat_frame_count = 0;
if (++stat_frame_count % 60 == 0) { if (++stat_frame_count % 60 == 0) {
Logger::info("Frame time: " + std::to_string(stats.frame_time_ms_) + " ms (" + ARE_LOG_INFO("Frame time: " + std::to_string(stats.frame_time_ms_) + " ms (" +
std::to_string(1000.0f / stats.frame_time_ms_) + " FPS)"); std::to_string(1000.0f / stats.frame_time_ms_) + " FPS)");
Logger::info(" G-Buffer: " + std::to_string(stats.gbuffer_time_ms_) + " ms"); ARE_LOG_INFO(" G-Buffer: " + std::to_string(stats.gbuffer_time_ms_) + " ms");
Logger::info(" Ray trace: " + std::to_string(stats.raytrace_time_ms_) + " ms"); ARE_LOG_INFO(" Ray trace: " + std::to_string(stats.raytrace_time_ms_) + " ms");
Logger::info(" Triangles: " + std::to_string(stats.triangle_count_)); ARE_LOG_INFO(" Triangles: " + std::to_string(stats.triangle_count_));
} }
// ESC to exit // ESC to exit
@ -382,12 +382,12 @@ void render_loop() {
} }
} }
Logger::info("Exiting render loop"); ARE_LOG_INFO("Exiting render loop");
} }
/// @brief Cleanup /// @brief Cleanup
void cleanup() { void cleanup() {
Logger::info("Cleaning up..."); ARE_LOG_INFO("Cleaning up...");
if (g_renderer) { if (g_renderer) {
g_renderer->shutdown(); g_renderer->shutdown();
@ -401,44 +401,43 @@ void cleanup() {
glfwTerminate(); glfwTerminate();
} }
Logger::info("Cleanup complete"); ARE_LOG_INFO("Cleanup complete");
} }
int main() { int main() {
// Initialize logger // Initialize logger
Logger::initialize(); ARE_LOG_INFO("===========================================");
Logger::info("==========================================="); ARE_LOG_INFO("Aurora Rendering Engine - Cornell Box Demo");
Logger::info("Aurora Rendering Engine - Cornell Box Demo"); ARE_LOG_INFO("===========================================");
Logger::info("===========================================");
// Check environment // Check environment
const char* display = getenv("DISPLAY"); const char* display = getenv("DISPLAY");
const char* wayland_display = getenv("WAYLAND_DISPLAY"); const char* wayland_display = getenv("WAYLAND_DISPLAY");
if (!display && !wayland_display) { if (!display && !wayland_display) {
Logger::error("No display server detected!"); ARE_LOG_ERROR("No display server detected!");
Logger::error("Make sure you're running in a graphical environment (X11 or Wayland)"); ARE_LOG_ERROR("Make sure you're running in a graphical environment (X11 or Wayland)");
Logger::error("DISPLAY=" + std::string(display ? display : "not set")); ARE_LOG_ERROR("DISPLAY=" + std::string(display ? display : "not set"));
Logger::error("WAYLAND_DISPLAY=" + std::string(wayland_display ? wayland_display : "not set")); ARE_LOG_ERROR("WAYLAND_DISPLAY=" + std::string(wayland_display ? wayland_display : "not set"));
return -1; return -1;
} }
Logger::info("Display server: " + std::string(display ? display : wayland_display)); ARE_LOG_INFO("Display server: " + std::string(display ? display : wayland_display));
// Initialize window // Initialize window
if (!init_window()) { if (!init_window()) {
cleanup(); cleanup();
Logger::error("Failed to initialize window"); ARE_LOG_ERROR("Failed to initialize window");
Logger::shutdown(); Logger::shutdown();
return -1; return -1;
} }
// Setup scene // Setup scene
Logger::info("Setting up Cornell Box scene..."); ARE_LOG_INFO("Setting up Cornell Box scene...");
setup_cornell_box(); setup_cornell_box();
// Initialize renderer // Initialize renderer
Logger::info("Initializing renderer..."); ARE_LOG_INFO("Initializing renderer...");
RendererConfig config; RendererConfig config;
config.width_ = WINDOW_WIDTH; config.width_ = WINDOW_WIDTH;
config.height_ = WINDOW_HEIGHT; config.height_ = WINDOW_HEIGHT;
@ -449,16 +448,16 @@ int main() {
g_renderer = std::make_unique<Renderer>(config); g_renderer = std::make_unique<Renderer>(config);
if (!g_renderer->initialize()) { if (!g_renderer->initialize()) {
Logger::error("Failed to initialize renderer"); ARE_LOG_ERROR("Failed to initialize renderer");
cleanup(); cleanup();
Logger::shutdown(); Logger::shutdown();
return -1; return -1;
} }
Logger::info("==========================================="); ARE_LOG_INFO("===========================================");
Logger::info("Renderer initialized successfully!"); ARE_LOG_INFO("Renderer initialized successfully!");
Logger::info("Press ESC to exit"); ARE_LOG_INFO("Press ESC to exit");
Logger::info("==========================================="); ARE_LOG_INFO("===========================================");
// Main loop // Main loop
render_loop(); render_loop();
@ -466,7 +465,7 @@ int main() {
// Cleanup // Cleanup
cleanup(); cleanup();
Logger::info("Cornell Box demo finished"); ARE_LOG_INFO("Cornell Box demo finished");
Logger::shutdown(); Logger::shutdown();
return 0; return 0;

3
include/core/screen_blit.h
View File

@ -3,6 +3,7 @@
#include "basic/types.h" #include "basic/types.h"
#include "resource/shader.h" #include "resource/shader.h"
#include <memory>
namespace are { namespace are {
@ -35,7 +36,7 @@ public:
void blit_fullscreen(TextureHandle texture); void blit_fullscreen(TextureHandle texture);
private: private:
Shader shader_; std::shared_ptr<Shader> shader_;
uint vao_; uint vao_;
uint vbo_; uint vbo_;
bool initialized_; bool initialized_;

5
include/core/shader_manager.h
View File

@ -58,11 +58,16 @@ public:
/// @return Denoise shader (nullptr if not loaded) /// @return Denoise shader (nullptr if not loaded)
const std::shared_ptr<Shader>& get_denoise_shader() const { return denoise_shader_; } const std::shared_ptr<Shader>& get_denoise_shader() const { return denoise_shader_; }
/// @brief Get screen bliting shader
/// @return Screen bliting shader (nullptr if not loaded)
const std::shared_ptr<Shader>& get_screen_blit_shader() const { return screen_blit_shader_; }
private: private:
std::unordered_map<std::string, std::shared_ptr<Shader>> shader_cache_; std::unordered_map<std::string, std::shared_ptr<Shader>> shader_cache_;
std::shared_ptr<Shader> gbuffer_shader_; std::shared_ptr<Shader> gbuffer_shader_;
std::shared_ptr<Shader> raytracing_shader_; std::shared_ptr<Shader> raytracing_shader_;
std::shared_ptr<Shader> denoise_shader_; std::shared_ptr<Shader> denoise_shader_;
std::shared_ptr<Shader> screen_blit_shader_;
bool initialized_; bool initialized_;

39
src/core/screen_blit.cpp
View File

@ -4,33 +4,6 @@
namespace are { namespace are {
namespace {
const char* VERTEX_SHADER_SOURCE = R"(
#version 430 core
layout(location = 0) in vec2 a_position;
layout(location = 1) in vec2 a_texcoord;
out vec2 v_texcoord;
void main() {
v_texcoord = a_texcoord;
gl_Position = vec4(a_position, 0.0, 1.0);
}
)";
const char* FRAGMENT_SHADER_SOURCE = R"(
#version 430 core
in vec2 v_texcoord;
out vec4 frag_color;
uniform sampler2D u_texture;
void main() {
frag_color = texture(u_texture, v_texcoord);
}
)";
}
ScreenBlit::ScreenBlit() ScreenBlit::ScreenBlit()
: vao_(0) : vao_(0)
, vbo_(0) , vbo_(0)
@ -47,12 +20,6 @@ bool ScreenBlit::initialize() {
return true; return true;
} }
// Compile shader
if (!shader_.compile(VERTEX_SHADER_SOURCE, FRAGMENT_SHADER_SOURCE)) {
ARE_LOG_ERROR("Failed to compile screen blit shader");
return false;
}
// Create fullscreen quad // Create fullscreen quad
create_quad_(); create_quad_();
@ -64,7 +31,7 @@ bool ScreenBlit::initialize() {
void ScreenBlit::release() { void ScreenBlit::release() {
if (!initialized_) return; if (!initialized_) return;
shader_.release(); shader_.reset();
if (vao_ != 0) { if (vao_ != 0) {
glDeleteVertexArrays(1, &vao_); glDeleteVertexArrays(1, &vao_);
@ -92,8 +59,8 @@ void ScreenBlit::blit(TextureHandle texture, int x, int y, uint width, uint heig
glDisable(GL_DEPTH_TEST); glDisable(GL_DEPTH_TEST);
// Use shader // Use shader
shader_.use(); shader_->use();
shader_.set_int("u_texture", 0); shader_->set_int("u_texture", 0);
// Bind texture // Bind texture
glActiveTexture(GL_TEXTURE0); glActiveTexture(GL_TEXTURE0);

15
src/core/shader_manager.cpp
View File

@ -38,6 +38,7 @@ void ShaderManager::release() {
shader_cache_.clear(); shader_cache_.clear();
gbuffer_shader_.reset(); gbuffer_shader_.reset();
screen_blit_shader_.reset();
raytracing_shader_.reset(); raytracing_shader_.reset();
denoise_shader_.reset(); denoise_shader_.reset();
@ -93,6 +94,8 @@ std::shared_ptr<Shader> ShaderManager::get_shader(const std::string& name) const
} }
bool ShaderManager::load_builtin_shaders_() { bool ShaderManager::load_builtin_shaders_() {
// Load G-buffer shader
ARE_LOG_INFO("Loading G-buffer shaders..");
gbuffer_shader_ = std::make_shared<Shader>(); gbuffer_shader_ = std::make_shared<Shader>();
if (!gbuffer_shader_->load("shaders/gbuffer.vert", "shaders/gbuffer.frag")) { if (!gbuffer_shader_->load("shaders/gbuffer.vert", "shaders/gbuffer.frag")) {
ARE_LOG_ERROR("Failed to load G-Buffer shader"); ARE_LOG_ERROR("Failed to load G-Buffer shader");
@ -100,6 +103,17 @@ bool ShaderManager::load_builtin_shaders_() {
} }
shader_cache_["gbuffer"] = gbuffer_shader_; shader_cache_["gbuffer"] = gbuffer_shader_;
// Load screen bliting shader
ARE_LOG_INFO("Loading screen blit shaders...");
screen_blit_shader_ = std::make_shared<Shader>();
if (!screen_blit_shader_->load("shaders/screen_blit.vert", "shaders/screen_blit.frag")) {
ARE_LOG_ERROR("Failed to load screen blit shader");
return false;
}
shader_cache_["screen_blit"] = denoise_shader_;
ARE_LOG_INFO("Screen blit shader loaded successfully");
// Load ray tracing shader
ARE_LOG_INFO("Loading ray tracing compute shader..."); ARE_LOG_INFO("Loading ray tracing compute shader...");
raytracing_shader_ = std::make_shared<Shader>(); raytracing_shader_ = std::make_shared<Shader>();
if (!raytracing_shader_->load_compute("shaders/raytracing.comp")) { if (!raytracing_shader_->load_compute("shaders/raytracing.comp")) {
@ -109,6 +123,7 @@ bool ShaderManager::load_builtin_shaders_() {
shader_cache_["raytracing"] = raytracing_shader_; shader_cache_["raytracing"] = raytracing_shader_;
ARE_LOG_INFO("Ray tracing shader loaded successfully"); ARE_LOG_INFO("Ray tracing shader loaded successfully");
// Load denoising shader
ARE_LOG_INFO("Loading denoise compute shader..."); ARE_LOG_INFO("Loading denoise compute shader...");
denoise_shader_ = std::make_shared<Shader>(); denoise_shader_ = std::make_shared<Shader>();
if (!denoise_shader_->load_compute("shaders/denoiser.comp")) { if (!denoise_shader_->load_compute("shaders/denoiser.comp")) {