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

style: 格式化代码及注释

master
ternaryop8479 2026-02-15 15:30:05 +08:00
parent d598b26845
commit c039b83c57
20 changed files with 1560 additions and 1172 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
include/basic/constants.h
View File

@ -3,16 +3,16 @@
namespace are { namespace are {
/// @brief Maximum number of lights in scene // Maximum number of lights in scene
constexpr int MAX_LIGHTS = 16; constexpr int MAX_LIGHTS = 16;
/// @brief Maximum ray tracing depth // Maximum ray tracing depth
constexpr int MAX_RAY_DEPTH = 8; constexpr int MAX_RAY_DEPTH = 8;
/// @brief Default samples per pixel for ray tracing // Default samples per pixel for ray tracing
constexpr int DEFAULT_SPP = 1; constexpr int DEFAULT_SPP = 1;
/// @brief G-Buffer attachment indices // G-Buffer attachment indices
constexpr int GBUFFER_POSITION = 0; constexpr int GBUFFER_POSITION = 0;
constexpr int GBUFFER_NORMAL = 1; constexpr int GBUFFER_NORMAL = 1;
constexpr int GBUFFER_ALBEDO = 2; constexpr int GBUFFER_ALBEDO = 2;
@ -20,11 +20,11 @@ constexpr int GBUFFER_MATERIAL = 3;
constexpr int GBUFFER_MATERIAL_ID = 4; constexpr int GBUFFER_MATERIAL_ID = 4;
constexpr int GBUFFER_COUNT = 5; constexpr int GBUFFER_COUNT = 5;
/// @brief Compute shader work group size // Compute shader work group size
constexpr int COMPUTE_GROUP_SIZE_X = 16; constexpr int COMPUTE_GROUP_SIZE_X = 16;
constexpr int COMPUTE_GROUP_SIZE_Y = 16; constexpr int COMPUTE_GROUP_SIZE_Y = 16;
/// @brief Mathematical constants // Mathematical constants
constexpr float PI = 3.14159265359f; constexpr float PI = 3.14159265359f;
constexpr float INV_PI = 0.31830988618f; constexpr float INV_PI = 0.31830988618f;
constexpr float EPSILON = 1e-4f; constexpr float EPSILON = 1e-4f;

100
include/basic/math.h
View File

@ -7,51 +7,65 @@
namespace are { namespace are {
/// @brief Math utility functions wrapping GLM // Math utility functions wrapping GLM
class MathUtils { class MathUtils {
public: public:
/// @brief Create perspective projection matrix /*
/// @param fov Field of view in radians * @brief Create perspective projection matrix
/// @param aspect Aspect ratio * @param fov Field of view in radians
/// @param near Near plane distance * @param aspect Aspect ratio
/// @param far Far plane distance * @param near Near plane distance
/// @return Projection matrix * @param far Far plane distance
static Mat4 perspective(float fov, float aspect, float near, float far); * @return Projection matrix
*/
/// @brief Create look-at view matrix static Mat4 perspective(float fov, float aspect, float near, float far);
/// @param eye Camera position
/// @param center Look-at target /*
/// @param up Up vector * @brief Create look-at view matrix
/// @return View matrix * @param eye Camera position
static Mat4 look_at(const Vec3& eye, const Vec3& center, const Vec3& up); * @param center Look-at target
* @param up Up vector
/// @brief Normalize a vector * @return View matrix
/// @param v Input vector */
/// @return Normalized vector static Mat4 look_at(const Vec3 &eye, const Vec3 &center, const Vec3 &up);
static Vec3 normalize(const Vec3& v);
/*
/// @brief Calculate dot product * @brief Normalize a vector
/// @param a First vector * @param v Input vector
/// @param b Second vector * @return Normalized vector
/// @return Dot product */
static float dot(const Vec3& a, const Vec3& b); static Vec3 normalize(const Vec3 &v);
/// @brief Calculate cross product /*
/// @param a First vector * @brief Calculate dot product
/// @param b Second vector * @param a First vector
/// @return Cross product * @param b Second vector
static Vec3 cross(const Vec3& a, const Vec3& b); * @return Dot product
*/
/// @brief Reflect vector around normal static float dot(const Vec3 &a, const Vec3 &b);
/// @param incident Incident vector
/// @param normal Surface normal /*
/// @return Reflected vector * @brief Calculate cross product
static Vec3 reflect(const Vec3& incident, const Vec3& normal); * @param a First vector
* @param b Second vector
/// @brief Get pointer to matrix data (for OpenGL) * @return Cross product
/// @param mat Input matrix */
/// @return Pointer to matrix data static Vec3 cross(const Vec3 &a, const Vec3 &b);
static const float* value_ptr(const Mat4& mat);
/*
* @brief Reflect vector around normal
* @param incident Incident vector
* @param normal Surface normal
* @return Reflected vector
*/
static Vec3 reflect(const Vec3 &incident, const Vec3 &normal);
/*
* @brief Get pointer to matrix data (for OpenGL)
* @param mat Input matrix
* @return Pointer to matrix data
*/
static const float *value_ptr(const Mat4 &mat);
}; };
} // namespace are } // namespace are

62
include/basic/types.h
View File

@ -2,68 +2,68 @@
#define ARE_INCLUDE_BASIC_TYPES_H #define ARE_INCLUDE_BASIC_TYPES_H
#include <cstdint> #include <cstdint>
#include <memory>
#include <vector>
#include <string>
#include <glm/glm.hpp> #include <glm/glm.hpp>
#include <memory>
#include <string>
#include <vector>
namespace are { namespace are {
/// @brief Basic vector types using GLM // Basic vector types using GLM
using Vec2 = glm::vec2; using Vec2 = glm::vec2;
using Vec3 = glm::vec3; using Vec3 = glm::vec3;
using Vec4 = glm::vec4; using Vec4 = glm::vec4;
/// @brief Basic matrix types using GLM // Basic matrix types using GLM
using Mat3 = glm::mat3; using Mat3 = glm::mat3;
using Mat4 = glm::mat4; using Mat4 = glm::mat4;
/// @brief Basic integer types // Basic integer types
using uint = uint32_t; using uint = uint32_t;
using uchar = uint8_t; using uchar = uint8_t;
/// @brief Handle types for GPU resources // Handle types for GPU resources
using TextureHandle = uint; using TextureHandle = uint;
using BufferHandle = uint; using BufferHandle = uint;
using ShaderHandle = uint; using ShaderHandle = uint;
using FramebufferHandle = uint; using FramebufferHandle = uint;
/// @brief Invalid handle constant // Invalid handle constant
constexpr uint INVALID_HANDLE = 0; constexpr uint INVALID_HANDLE = 0;
/// @brief Vertex structure for mesh data // Vertex structure for mesh data
struct Vertex { struct Vertex {
Vec3 position_; Vec3 position_;
Vec3 normal_; Vec3 normal_;
Vec2 texcoord_; Vec2 texcoord_;
Vec3 tangent_; Vec3 tangent_;
}; };
/// @brief Ray structure for ray tracing // Ray structure for ray tracing
struct Ray { struct Ray {
Vec3 origin_; Vec3 origin_;
Vec3 direction_; Vec3 direction_;
float t_min_; float t_min_;
float t_max_; float t_max_;
}; };
/// @brief Hit information for ray-surface intersection // Hit information for ray-surface intersection
struct HitInfo { struct HitInfo {
bool hit_; bool hit_;
float t_; float t_;
Vec3 position_; Vec3 position_;
Vec3 normal_; Vec3 normal_;
Vec2 texcoord_; Vec2 texcoord_;
uint material_id_; uint material_id_;
}; };
/// @brief Rendering statistics // Rendering statistics
struct RenderStats { struct RenderStats {
float frame_time_ms_; float frame_time_ms_;
uint triangle_count_; uint triangle_count_;
uint ray_count_; uint ray_count_;
float gbuffer_time_ms_; float gbuffer_time_ms_;
float raytrace_time_ms_; float raytrace_time_ms_;
}; };
} // namespace are } // namespace are

241
include/core/bvh.h
View File

@ -2,139 +2,162 @@
#define ARE_INCLUDE_CORE_BVH_H #define ARE_INCLUDE_CORE_BVH_H
#include "basic/types.h" #include "basic/types.h"
#include "scene/mesh.h"
#include "resource/buffer.h" #include "resource/buffer.h"
#include <vector> #include "scene/mesh.h"
#include <memory> #include <memory>
#include <vector>
namespace are { namespace are {
/// @brief Axis-aligned bounding box // Axis-aligned bounding box
struct AABB { struct AABB {
Vec3 min_; Vec3 min_;
Vec3 max_; Vec3 max_;
/// @brief Construct AABB from min and max points // Construct AABB from min and max points
AABB(const Vec3& min = Vec3(0.0f), const Vec3& max = Vec3(0.0f)) AABB(const Vec3 &min = Vec3(0.0f), const Vec3 &max = Vec3(0.0f))
: min_(min), max_(max) {} : min_(min), max_(max) {
}
/// @brief Expand AABB to include point
void expand(const Vec3& point); // Expand AABB to include point
void expand(const Vec3 &point);
/// @brief Expand AABB to include another AABB
void expand(const AABB& other); // Expand AABB to include another AABB
void expand(const AABB &other);
/// @brief Get center of AABB
Vec3 center() const { return (min_ + max_) * 0.5f; } // Get center of AABB
Vec3 center() const {
/// @brief Get surface area of AABB return (min_ + max_) * 0.5f;
float surface_area() const; }
/// @brief Check if AABB is valid // Get surface area of AABB
bool is_valid() const; float surface_area() const;
// Check if AABB is valid
bool is_valid() const;
}; };
/// @brief Triangle primitive for BVH // Triangle primitive for BVH
struct Triangle { struct Triangle {
Vec3 v0_, v1_, v2_; Vec3 v0_, v1_, v2_;
Vec3 n0_, n1_, n2_; Vec3 n0_, n1_, n2_;
Vec2 uv0_, uv1_, uv2_; Vec2 uv0_, uv1_, uv2_;
uint material_id_; uint material_id_;
/// @brief Get bounding box of triangle // Get bounding box of triangle
AABB get_bounds() const; AABB get_bounds() const;
/// @brief Get centroid of triangle // Get centroid of triangle
Vec3 get_centroid() const; Vec3 get_centroid() const;
}; };
/// @brief BVH node for GPU // BVH node for GPU
struct BVHNode { struct BVHNode {
Vec3 aabb_min_; Vec3 aabb_min_;
uint left_first_; // Left child index or first primitive index uint left_first_; // Left child index or first primitive index
Vec3 aabb_max_; Vec3 aabb_max_;
uint count_; // 0 for interior node, >0 for leaf node uint count_; // 0 for interior node, >0 for leaf node
}; };
/// @brief GPU-friendly BVH node layout (std430 aligned) // GPU-friendly BVH node layout (std430 aligned)
struct BVHNodeGpu { struct BVHNodeGpu {
Vec4 aabb_min_left_first_; ///< xyz = aabb min, w = left_first (uint) Vec4 aabb_min_left_first_; ///< xyz = aabb min, w = left_first (uint)
Vec4 aabb_max_count_; ///< xyz = aabb max, w = count (uint, 0 for interior) Vec4 aabb_max_count_; ///< xyz = aabb max, w = count (uint, 0 for interior)
}; };
/// @brief GPU-friendly triangle layout (std430 aligned) // GPU-friendly triangle layout (std430 aligned)
struct TriangleGpu { struct TriangleGpu {
Vec4 v0_material_; ///< xyz = v0, w = material_id (uint) Vec4 v0_material_; ///< xyz = v0, w = material_id (uint)
Vec4 v1_; ///< xyz = v1, w = reserved Vec4 v1_; ///< xyz = v1, w = reserved
Vec4 v2_; ///< xyz = v2, w = reserved Vec4 v2_; ///< xyz = v2, w = reserved
Vec4 n0_; ///< xyz = n0, w = reserved Vec4 n0_; ///< xyz = n0, w = reserved
Vec4 n1_; ///< xyz = n1, w = reserved Vec4 n1_; ///< xyz = n1, w = reserved
Vec4 n2_; ///< xyz = n2, w = reserved Vec4 n2_; ///< xyz = n2, w = reserved
Vec4 uv0_uv1_; ///< xy = uv0, zw = uv1 Vec4 uv0_uv1_; ///< xy = uv0, zw = uv1
Vec4 uv2_; ///< xy = uv2, zw = reserved Vec4 uv2_; ///< xy = uv2, zw = reserved
}; };
/// @brief Bounding Volume Hierarchy for ray tracing acceleration // Bounding Volume Hierarchy for ray tracing acceleration
class BVH { class BVH {
public: public:
/// @brief Constructor // Constructor
BVH(); BVH();
/// @brief Destructor // Destructor
~BVH(); ~BVH();
/// @brief Build BVH from meshes /*
/// @param meshes Mesh list * @brief Build BVH from meshes
/// @return True if build succeeded * @param meshes Mesh list
bool build(const std::vector<std::shared_ptr<Mesh>>& meshes); * @return True if build succeeded
*/
/// @brief Upload BVH to GPU bool build(const std::vector<std::shared_ptr<Mesh>> &meshes);
/// @param node_buffer Buffer for BVH nodes
/// @param triangle_buffer Buffer for triangles /*
/// @return True if upload succeeded * @brief Upload BVH to GPU
bool upload_to_gpu(Buffer& node_buffer, Buffer& triangle_buffer); * @param node_buffer Buffer for BVH nodes
* @param triangle_buffer Buffer for triangles
/// @brief Get total node count * @return True if upload succeeded
/// @return Node count */
uint get_node_count() const { return static_cast<uint>(nodes_.size()); } bool upload_to_gpu(Buffer &node_buffer, Buffer &triangle_buffer);
/// @brief Get total triangle count /*
/// @return Triangle count * @brief Get total node count
uint get_triangle_count() const { return static_cast<uint>(triangles_.size()); } * @return Node count
*/
/// @brief Clear BVH data uint get_node_count() const {
void clear(); return static_cast<uint>(nodes_.size());
}
/*
* @brief Get total triangle count
* @return Triangle count
*/
uint get_triangle_count() const {
return static_cast<uint>(triangles_.size());
}
// Clear BVH data
void clear();
private: private:
std::vector<BVHNode> nodes_; std::vector<BVHNode> nodes_;
std::vector<Triangle> triangles_; std::vector<Triangle> triangles_;
std::vector<uint> triangle_indices_; std::vector<uint> triangle_indices_;
/// @brief Recursively build BVH /*
/// @param node_idx Current node index * @brief Recursively build BVH
/// @param first_prim First primitive index * @param node_idx Current node index
/// @param prim_count Primitive count * @param first_prim First primitive index
void build_recursive_(uint node_idx, uint first_prim, uint prim_count); * @param prim_count Primitive count
*/
/// @brief Find best split using SAH void build_recursive_(uint node_idx, uint first_prim, uint prim_count);
/// @param first_prim First primitive index
/// @param prim_count Primitive count /*
/// @param axis Split axis (output) * @brief Find best split using SAH
/// @param split_pos Split position (output) * @param first_prim First primitive index
/// @return Split cost * @param prim_count Primitive count
float find_best_split_(uint first_prim, uint prim_count, int& axis, float& split_pos); * @param axis Split axis (output)
* @param split_pos Split position (output)
/// @brief Calculate node bounds * @return Split cost
/// @param first_prim First primitive index */
/// @param prim_count Primitive count float find_best_split_(uint first_prim, uint prim_count, int &axis, float &split_pos);
/// @return Bounding box
AABB calculate_bounds_(uint first_prim, uint prim_count); /*
* @brief Calculate node bounds
/// @brief Calculate centroid bounds * @param first_prim First primitive index
/// @param first_prim First primitive index * @param prim_count Primitive count
/// @param prim_count Primitive count * @return Bounding box
/// @return Centroid bounding box */
AABB calculate_centroid_bounds_(uint first_prim, uint prim_count); AABB calculate_bounds_(uint first_prim, uint prim_count);
/*
* @brief Calculate centroid bounds
* @param first_prim First primitive index
* @param prim_count Primitive count
* @return Centroid bounding box
*/
AABB calculate_centroid_bounds_(uint first_prim, uint prim_count);
}; };
} // namespace are } // namespace are

84
include/core/denoiser.h
View File

@ -7,61 +7,57 @@
namespace are { namespace are {
/** // Mean filter denoiser using compute shader
* @brief Mean filter denoiser using compute shader
*/
class Denoiser { class Denoiser {
public: public:
/** /**
* @brief Construct denoiser * @brief Construct denoiser
* @param width Output width * @param width Output width
* @param height Output height * @param height Output height
*/ */
Denoiser(uint width, uint height); Denoiser(uint width, uint height);
/**
* @brief Destroy denoiser
*/
~Denoiser();
/** /**
* @brief Initialize GPU resources * @brief Destroy denoiser
* @param shader Denoise compute shader (managed by ShaderManager) */
* @return True on success ~Denoiser();
*/
bool initialize(const std::shared_ptr<Shader>& shader);
/** /**
* @brief Release GPU resources * @brief Initialize GPU resources
*/ * @param shader Denoise compute shader (managed by ShaderManager)
void release(); * @return True on success
*/
bool initialize(const std::shared_ptr<Shader> &shader);
/** /**
* @brief Resize internal targets * @brief Release GPU resources
* @param width New width */
* @param height New height void release();
*/
void resize(uint width, uint height);
/** /**
* @brief Apply mean filter * @brief Resize internal targets
* @param input_texture RGBA32F input texture * @param width New width
* @param radius Filter radius (1 => 3x3) * @param height New height
* @return Output texture handle (internal) */
*/ void resize(uint width, uint height);
TextureHandle denoise(TextureHandle input_texture, int radius);
/**
* @brief Apply mean filter
* @param input_texture RGBA32F input texture
* @param radius Filter radius (1 => 3x3)
* @return Output texture handle (internal)
*/
TextureHandle denoise(TextureHandle input_texture, int radius);
private: private:
uint width_; uint width_;
uint height_; uint height_;
std::shared_ptr<Shader> shader_; std::shared_ptr<Shader> shader_;
TextureHandle output_texture_; TextureHandle output_texture_;
bool initialized_; bool initialized_;
/** // Create output texture
* @brief Create output texture void create_output_texture_();
*/
void create_output_texture_();
}; };
} // namespace are } // namespace are

128
include/core/gbuffer.h
View File

@ -1,70 +1,88 @@
#ifndef ARE_INCLUDE_CORE_GBUFFER_H #ifndef ARE_INCLUDE_CORE_GBUFFER_H
#define ARE_INCLUDE_CORE_GBUFFER_H #define ARE_INCLUDE_CORE_GBUFFER_H
#include "basic/types.h"
#include "basic/constants.h" #include "basic/constants.h"
#include "scene/scene.h" #include "basic/types.h"
#include "resource/shader.h" #include "resource/shader.h"
#include "scene/scene.h"
namespace are { namespace are {
/// @brief G-Buffer manager for deferred rendering // G-Buffer manager for deferred rendering
class GBuffer { class GBuffer {
public: public:
/// @brief Constructor /*
/// @param width Buffer width * @brief Constructor
/// @param height Buffer height * @param width Buffer width
GBuffer(uint width, uint height); * @param height Buffer height
*/
/// @brief Destructor GBuffer(uint width, uint height);
~GBuffer();
// Destructor
/// @brief Initialize G-Buffer (create framebuffer and textures) ~GBuffer();
/// @return True if initialization succeeded
bool initialize(); /*
* @brief Initialize G-Buffer (create framebuffer and textures)
/// @brief Release G-Buffer resources * @return True if initialization succeeded
void release(); */
bool initialize();
/// @brief Render scene to G-Buffer
/// @param scene Scene to render // Release G-Buffer resources
/// @param shader Shader program for G-Buffer pass void release();
void render(const Scene& scene, const Shader& shader);
/*
/// @brief Resize G-Buffer * @brief Render scene to G-Buffer
/// @param width New width * @param scene Scene to render
/// @param height New height * @param shader Shader program for G-Buffer pass
void resize(uint width, uint height); */
void render(const Scene &scene, const Shader &shader);
/// @brief Get texture handle for specific buffer
/// @param index Buffer index (GBUFFER_POSITION, GBUFFER_NORMAL, etc.) /*
/// @return Texture handle * @brief Resize G-Buffer
TextureHandle get_texture(int index) const; * @param width New width
* @param height New height
/// @brief Get framebuffer handle */
/// @return Framebuffer handle void resize(uint width, uint height);
FramebufferHandle get_framebuffer() const { return fbo_; }
/*
/// @brief Get buffer dimensions * @brief Get texture handle for specific buffer
/// @param width Output width * @param index Buffer index (GBUFFER_POSITION, GBUFFER_NORMAL, etc.)
/// @param height Output height * @return Texture handle
void get_dimensions(uint& width, uint& height) const; */
TextureHandle get_texture(int index) const;
/*
* @brief Get framebuffer handle
* @return Framebuffer handle
*/
FramebufferHandle get_framebuffer() const {
return fbo_;
}
/*
* @brief Get buffer dimensions
* @param width Output width
* @param height Output height
*/
void get_dimensions(uint &width, uint &height) const;
private: private:
uint width_; uint width_;
uint height_; uint height_;
FramebufferHandle fbo_; FramebufferHandle fbo_;
TextureHandle textures_[GBUFFER_COUNT]; TextureHandle textures_[GBUFFER_COUNT];
TextureHandle depth_texture_; TextureHandle depth_texture_;
bool initialized_; bool initialized_;
/// @brief Create texture for G-Buffer attachment /*
/// @param internal_format OpenGL internal format * @brief Create texture for G-Buffer attachment
/// @param format OpenGL format * @param internal_format OpenGL internal format
/// @param type OpenGL type * @param format OpenGL format
/// @return Texture handle * @param type OpenGL type
TextureHandle create_texture_(uint internal_format, uint format, uint type); * @return Texture handle
*/
TextureHandle create_texture_(uint internal_format, uint format, uint type);
}; };
} // namespace are } // namespace are

88
include/core/raytracer.h
View File

@ -2,7 +2,7 @@
#define ARE_INCLUDE_CORE_RAYTRACER_H #define ARE_INCLUDE_CORE_RAYTRACER_H
#include "basic/types.h" #include "basic/types.h"
#include "core/bvh.h" // 添加 #include "core/bvh.h"
#include "core/gbuffer.h" #include "core/gbuffer.h"
#include "resource/buffer.h" #include "resource/buffer.h"
#include "resource/shader.h" #include "resource/shader.h"
@ -11,62 +11,76 @@
namespace are { namespace are {
/// @brief Ray tracing configuration // Ray tracing configuration
struct RayTracerConfig { struct RayTracerConfig {
uint samples_per_pixel_; uint samples_per_pixel_;
uint max_depth_; uint max_depth_;
bool enable_shadows_; bool enable_shadows_;
bool enable_reflections_; bool enable_reflections_;
bool enable_accumulation_; bool enable_accumulation_;
bool use_bvh_; // 添加BVH开关 bool use_bvh_;
}; };
/// @brief Compute shader based ray tracer // Compute shader based ray tracer
class RayTracer { class RayTracer {
public: public:
/// @brief Constructor /*
/// @param width Output width * @brief Constructor
/// @param height Output height * @param width Output width
/// @param config Ray tracer configuration * @param height Output height
* @param config Ray tracer configuration
*/
RayTracer(uint width, uint height, const RayTracerConfig &config); RayTracer(uint width, uint height, const RayTracerConfig &config);
/// @brief Destructor // Destructor
~RayTracer(); ~RayTracer();
/// @brief Initialize ray tracer /*
/// @return True if initialization succeeded * @brief Initialize ray tracer
* @return True if initialization succeeded
*/
bool initialize(const std::shared_ptr<Shader> &shader); bool initialize(const std::shared_ptr<Shader> &shader);
/// @brief Release resources // Release resources
void release(); void release();
/// @brief Trace rays using G-Buffer as input /*
/// @param scene Scene data * @brief Trace rays using G-Buffer as input
/// @param gbuffer G-Buffer containing geometry information * @param scene Scene data
/// @param output_texture Output texture for ray traced result * @param gbuffer G-Buffer containing geometry information
* @param output_texture Output texture for ray traced result
*/
void trace(const Scene &scene, const GBuffer &gbuffer, TextureHandle output_texture); void trace(const Scene &scene, const GBuffer &gbuffer, TextureHandle output_texture);
/// @brief Resize output /*
/// @param width New width * @brief Resize output
/// @param height New height * @param width New width
* @param height New height
*/
void resize(uint width, uint height); void resize(uint width, uint height);
/// @brief Reset accumulation buffer // Reset accumulation buffer
void reset_accumulation(); void reset_accumulation();
/// @brief Get current configuration /*
/// @return Current configuration * @brief Get current configuration
* @return Current configuration
*/
const RayTracerConfig &get_config() const { const RayTracerConfig &get_config() const {
return config_; return config_;
} }
/// @brief Update configuration /*
/// @param config New configuration * @brief Update configuration
* @param config New configuration
*/
void set_config(const RayTracerConfig &config); void set_config(const RayTracerConfig &config);
/// @brief Rebuild BVH from scene /*
/// @param scene Scene to build BVH from * @brief Rebuild BVH from scene
/// @return True if build succeeded * @param scene Scene to build BVH from
* @return True if build succeeded
*/
bool rebuild_bvh(const Scene &scene); bool rebuild_bvh(const Scene &scene);
private: private:
@ -81,10 +95,10 @@ private:
BufferHandle light_buffer_; BufferHandle light_buffer_;
// BVH related // BVH related
std::unique_ptr<BVH> bvh_; // 添加 std::unique_ptr<BVH> bvh_;
Buffer bvh_node_buffer_; // 添加 Buffer bvh_node_buffer_;
Buffer bvh_triangle_buffer_; // 添加 Buffer bvh_triangle_buffer_;
bool bvh_built_; // 添加 bool bvh_built_;
uint materials_hash_; uint materials_hash_;
uint lights_hash_; uint lights_hash_;
@ -92,12 +106,16 @@ private:
uint frame_count_; uint frame_count_;
bool initialized_; bool initialized_;
/// @brief Upload scene data to GPU buffers /*
/// @param scene Scene to upload * @brief Upload scene data to GPU buffers
* @param scene Scene to upload
*/
void upload_scene_data_(const Scene &scene); void upload_scene_data_(const Scene &scene);
/// @brief Bind G-Buffer textures to compute shader /*
/// @param gbuffer G-Buffer to bind * @brief Bind G-Buffer textures to compute shader
* @param gbuffer G-Buffer to bind
*/
void bind_gbuffer_(const GBuffer &gbuffer); void bind_gbuffer_(const GBuffer &gbuffer);
}; };

114
include/core/renderer.h
View File

@ -2,75 +2,89 @@
#define ARE_INCLUDE_CORE_RENDERER_H #define ARE_INCLUDE_CORE_RENDERER_H
#include "basic/types.h" #include "basic/types.h"
#include "scene/scene.h" #include "core/denoiser.h"
#include "core/gbuffer.h" #include "core/gbuffer.h"
#include "core/raytracer.h" #include "core/raytracer.h"
#include "core/screen_blit.h" #include "core/screen_blit.h"
#include "core/denoiser.h"
#include "core/shader_manager.h" #include "core/shader_manager.h"
#include "scene/scene.h"
#include <memory> #include <memory>
namespace are { namespace are {
/// @brief Main renderer configuration // Main renderer configuration
struct RendererConfig { struct RendererConfig {
uint width_; uint width_;
uint height_; uint height_;
uint samples_per_pixel_; uint samples_per_pixel_;
uint max_ray_depth_; uint max_ray_depth_;
bool enable_denoising_; bool enable_denoising_;
bool enable_accumulation_; bool enable_accumulation_;
}; };
/// @brief Main rendering engine interface // Main rendering engine interface
class Renderer { class Renderer {
public: public:
/// @brief Constructor /*
/// @param config Renderer configuration * @brief Constructor
Renderer(const RendererConfig& config); * @param config Renderer configuration
*/
/// @brief Destructor Renderer(const RendererConfig &config);
~Renderer();
/// @brief Initialize renderer (OpenGL context must be current)
/// @return True if initialization succeeded
bool initialize();
/// @brief Shutdown renderer and release resources
void shutdown();
/// @brief Render a frame
/// @param scene Scene to render
/// @param output_texture Output texture handle (0 for default framebuffer)
/// @return Rendering statistics
RenderStats render(const Scene& scene, TextureHandle output_texture = 0);
/// @brief Resize render targets
/// @param width New width
/// @param height New height
void resize(uint width, uint height);
/// @brief Get current configuration
/// @return Current configuration
const RendererConfig& get_config() const { return config_; }
/// @brief Update configuration
/// @param config New configuration
void set_config(const RendererConfig& config);
/// @brief Notify scene changed to rebuild acceleration // Destructor
~Renderer();
/*
* @brief Initialize renderer (OpenGL context must be current)
* @return True if initialization succeeded
*/
bool initialize();
// Shutdown renderer and release resources
void shutdown();
/*
* @brief Render a frame
* @param scene Scene to render
* @param output_texture Output texture handle (0 for default framebuffer)
* @return Rendering statistics
*/
RenderStats render(const Scene &scene, TextureHandle output_texture = 0);
/*
* @brief Resize render targets
* @param width New width
* @param height New height
*/
void resize(uint width, uint height);
/*
* @brief Get current configuration
* @return Current configuration
*/
const RendererConfig &get_config() const {
return config_;
}
/*
* @brief Update configuration
* @param config New configuration
*/
void set_config(const RendererConfig &config);
// Notify scene changed to rebuild acceleration
void notify_scene_changed(const Scene &scene); void notify_scene_changed(const Scene &scene);
private: private:
RendererConfig config_; RendererConfig config_;
std::unique_ptr<GBuffer> gbuffer_; std::unique_ptr<GBuffer> gbuffer_;
std::unique_ptr<RayTracer> raytracer_; std::unique_ptr<RayTracer> raytracer_;
std::unique_ptr<ShaderManager> shader_manager_; std::unique_ptr<ShaderManager> shader_manager_;
std::unique_ptr<ScreenBlit> screen_blit_; std::unique_ptr<ScreenBlit> screen_blit_;
std::unique_ptr<Denoiser> denoiser_; std::unique_ptr<Denoiser> denoiser_;
bool initialized_; bool initialized_;
uint frame_count_; uint frame_count_;
}; };
} // namespace are } // namespace are

68
include/core/screen_blit.h
View File

@ -7,42 +7,48 @@
namespace are { namespace are {
/// @brief Screen blit utility for rendering texture to screen // Screen blit utility for rendering texture to screen
class ScreenBlit { class ScreenBlit {
public: public:
/// @brief Constructor // Constructor
ScreenBlit(); ScreenBlit();
/// @brief Destructor // Destructor
~ScreenBlit(); ~ScreenBlit();
/// @brief Initialize screen blit /*
/// @return True if initialization succeeded * @brief Initialize screen blit
bool initialize(const std::shared_ptr<Shader> &screen_blit_shader); * @return True if initialization succeeded
*/
/// @brief Release resources bool initialize(const std::shared_ptr<Shader> &screen_blit_shader);
void release();
// Release resources
/// @brief Blit texture to screen void release();
/// @param texture Texture to blit
/// @param x Screen X position /*
/// @param y Screen Y position * @brief Blit texture to screen
/// @param width Blit width * @param texture Texture to blit
/// @param height Blit height * @param x Screen X position
void blit(TextureHandle texture, int x, int y, uint width, uint height); * @param y Screen Y position
* @param width Blit width
/// @brief Blit texture to full screen * @param height Blit height
/// @param texture Texture to blit */
void blit_fullscreen(TextureHandle texture); void blit(TextureHandle texture, int x, int y, uint width, uint height);
/*
* @brief Blit texture to full screen
* @param texture Texture to blit
*/
void blit_fullscreen(TextureHandle texture);
private: private:
std::shared_ptr<Shader> shader_; std::shared_ptr<Shader> shader_;
uint vao_; uint vao_;
uint vbo_; uint vbo_;
bool initialized_; bool initialized_;
/// @brief Create fullscreen quad // Create fullscreen quad
void create_quad_(); void create_quad_();
}; };
} // namespace are } // namespace are

138
include/core/shader_manager.h
View File

@ -3,64 +3,88 @@
#include "basic/types.h" #include "basic/types.h"
#include "resource/shader.h" #include "resource/shader.h"
#include <unordered_map>
#include <string>
#include <memory> #include <memory>
#include <string>
#include <unordered_map>
namespace are { namespace are {
/// @brief Shader manager for loading and caching shaders // Shader manager for loading and caching shaders
class ShaderManager { class ShaderManager {
public: public:
/// @brief Constructor // Constructor
ShaderManager(); ShaderManager();
/// @brief Destructor
~ShaderManager();
/// @brief Initialize shader manager and load built-in shaders
/// @return True if initialization succeeded
bool initialize();
/// @brief Release all shaders
void release();
/// @brief Load shader from files
/// @param name Shader name for caching
/// @param vertex_path Vertex shader file path
/// @param fragment_path Fragment shader file path
/// @return Shader object
std::shared_ptr<Shader> load_shader(const std::string& name,
const std::string& vertex_path,
const std::string& fragment_path);
/// @brief Load compute shader from file
/// @param name Shader name for caching
/// @param compute_path Compute shader file path
/// @return Shader object
std::shared_ptr<Shader> load_compute_shader(const std::string& name,
const std::string& compute_path);
/// @brief Get cached shader by name
/// @param name Shader name
/// @return Shader object (invalid if not found)
std::shared_ptr<Shader> get_shader(const std::string& name) const;
/// @brief Get G-Buffer shader
/// @return G-Buffer shader
const std::shared_ptr<Shader>& get_gbuffer_shader() const { return gbuffer_shader_; }
/// @brief Get ray tracing compute shader
/// @return Ray tracing shader
const std::shared_ptr<Shader>& get_raytracing_shader() const { return raytracing_shader_; }
/// @brief Get mean denoise compute shader // Destructor
/// @return Denoise shader (nullptr if not loaded) ~ShaderManager();
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) * @brief Initialize shader manager and load built-in shaders
const std::shared_ptr<Shader>& get_screen_blit_shader() const { return screen_blit_shader_; } * @return True if initialization succeeded
*/
bool initialize();
// Release all shaders
void release();
/*
* @brief Load shader from files
* @param name Shader name for caching
* @param vertex_path Vertex shader file path
* @param fragment_path Fragment shader file path
* @return Shader object
*/
std::shared_ptr<Shader> load_shader(const std::string &name,
const std::string &vertex_path,
const std::string &fragment_path);
/*
* @brief Load compute shader from file
* @param name Shader name for caching
* @param compute_path Compute shader file path
* @return Shader object
*/
std::shared_ptr<Shader> load_compute_shader(const std::string &name,
const std::string &compute_path);
/*
* @brief Get cached shader by name
* @param name Shader name
* @return Shader object (invalid if not found)
*/
std::shared_ptr<Shader> get_shader(const std::string &name) const;
/*
* @brief Get G-Buffer shader
* @return G-Buffer shader
*/
const std::shared_ptr<Shader> &get_gbuffer_shader() const {
return gbuffer_shader_;
}
/*
* @brief Get ray tracing compute shader
* @return Ray tracing shader
*/
const std::shared_ptr<Shader> &get_raytracing_shader() const {
return raytracing_shader_;
}
/*
* @brief Get mean denoise compute shader
* @return Denoise shader (nullptr if not loaded)
*/
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_;
@ -68,12 +92,14 @@ private:
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_; std::shared_ptr<Shader> screen_blit_shader_;
bool initialized_; bool initialized_;
/// @brief Load built-in shaders /*
/// @return True if loading succeeded * @brief Load built-in shaders
bool load_builtin_shaders_(); * @return True if loading succeeded
*/
bool load_builtin_shaders_();
}; };
} // namespace are } // namespace are

154
include/resource/buffer.h
View File

@ -5,84 +5,106 @@
namespace are { namespace are {
/// @brief Buffer usage hint // Buffer usage hint
enum class BufferUsage { enum class BufferUsage {
STATIC_DRAW, STATIC_DRAW,
DYNAMIC_DRAW, DYNAMIC_DRAW,
STREAM_DRAW STREAM_DRAW
}; };
/// @brief Buffer type // Buffer type
enum class BufferType { enum class BufferType {
VERTEX_BUFFER, VERTEX_BUFFER,
INDEX_BUFFER, INDEX_BUFFER,
UNIFORM_BUFFER, UNIFORM_BUFFER,
SHADER_STORAGE_BUFFER SHADER_STORAGE_BUFFER
}; };
/// @brief GPU buffer resource // GPU buffer resource
class Buffer { class Buffer {
public: public:
/// @brief Constructor // Constructor
Buffer(); Buffer();
Buffer(const Buffer&) = delete; Buffer(const Buffer &) = delete;
Buffer& operator=(const Buffer&) = delete; Buffer &operator=(const Buffer &) = delete;
Buffer(Buffer&& other) noexcept; Buffer(Buffer &&other) noexcept;
Buffer& operator=(Buffer&& other) noexcept; Buffer &operator=(Buffer &&other) noexcept;
/// @brief Destructor // Destructor
~Buffer(); ~Buffer();
/// @brief Create buffer /*
/// @param type Buffer type * @brief Create buffer
/// @param size Buffer size in bytes * @param type Buffer type
/// @param data Initial data (nullptr for empty buffer) * @param size Buffer size in bytes
/// @param usage Usage hint * @param data Initial data (nullptr for empty buffer)
/// @return True if creation succeeded * @param usage Usage hint
bool create(BufferType type, size_t size, const void* data, BufferUsage usage); * @return True if creation succeeded
*/
/// @brief Update buffer data bool create(BufferType type, size_t size, const void *data, BufferUsage usage);
/// @param offset Offset in bytes
/// @param size Size in bytes /*
/// @param data Data to upload * @brief Update buffer data
void update(size_t offset, size_t size, const void* data); * @param offset Offset in bytes
* @param size Size in bytes
/// @brief Bind buffer * @param data Data to upload
void bind() const; */
void update(size_t offset, size_t size, const void *data);
/// @brief Bind buffer to binding point (for UBO/SSBO)
/// @param binding_point Binding point index // Bind buffer
void bind_base(uint binding_point) const; void bind() const;
/// @brief Unbind buffer /*
void unbind() const; * @brief Bind buffer to binding point (for UBO/SSBO)
* @param binding_point Binding point index
/// @brief Release buffer resources */
void release(); void bind_base(uint binding_point) const;
/// @brief Get buffer handle // Unbind buffer
/// @return Buffer handle void unbind() const;
BufferHandle get_handle() const { return handle_; }
// Release buffer resources
/// @brief Get buffer size void release();
/// @return Size in bytes
size_t get_size() const { return size_; } /*
* @brief Get buffer handle
/// @brief Get buffer type * @return Buffer handle
/// @return Buffer type */
BufferType get_type() const { return type_; } BufferHandle get_handle() const {
return handle_;
/// @brief Check if buffer is valid }
/// @return True if valid
bool is_valid() const { return handle_ != INVALID_HANDLE; } /*
* @brief Get buffer size
* @return Size in bytes
*/
size_t get_size() const {
return size_;
}
/*
* @brief Get buffer type
* @return Buffer type
*/
BufferType get_type() const {
return type_;
}
/*
* @brief Check if buffer is valid
* @return True if valid
*/
bool is_valid() const {
return handle_ != INVALID_HANDLE;
}
private: private:
BufferHandle handle_; BufferHandle handle_;
BufferType type_; BufferType type_;
size_t size_; size_t size_;
BufferUsage usage_; BufferUsage usage_;
}; };
} // namespace are } // namespace are

272
include/resource/shader.h
View File

@ -7,127 +7,169 @@
namespace are { namespace are {
/// @brief Shader program resource // Shader program resource
class Shader { class Shader {
public: public:
/// @brief Constructor // Constructor
Shader(); Shader();
Shader(const Shader&) = delete; Shader(const Shader &) = delete;
Shader& operator=(const Shader&) = delete; Shader &operator=(const Shader &) = delete;
Shader(Shader&& other) noexcept; Shader(Shader &&other) noexcept;
Shader& operator=(Shader&& other) noexcept; Shader &operator=(Shader &&other) noexcept;
/// @brief Destructor // Destructor
~Shader(); ~Shader();
/// @brief Load and compile shader from files /*
/// @param vertex_path Vertex shader path * @brief Load and compile shader from files
/// @param fragment_path Fragment shader path * @param vertex_path Vertex shader path
/// @return True if compilation succeeded * @param fragment_path Fragment shader path
bool load(const std::string& vertex_path, const std::string& fragment_path); * @return True if compilation succeeded
*/
/// @brief Load and compile compute shader bool load(const std::string &vertex_path, const std::string &fragment_path);
/// @param compute_path Compute shader path
/// @return True if compilation succeeded /*
bool load_compute(const std::string& compute_path); * @brief Load and compile compute shader
* @param compute_path Compute shader path
/// @brief Compile shader from source strings * @return True if compilation succeeded
/// @param vertex_source Vertex shader source */
/// @param fragment_source Fragment shader source bool load_compute(const std::string &compute_path);
/// @return True if compilation succeeded
bool compile(const std::string& vertex_source, const std::string& fragment_source); /*
* @brief Compile shader from source strings
/// @brief Compile compute shader from source * @param vertex_source Vertex shader source
/// @param compute_source Compute shader source * @param fragment_source Fragment shader source
/// @return True if compilation succeeded * @return True if compilation succeeded
bool compile_compute(const std::string& compute_source); */
bool compile(const std::string &vertex_source, const std::string &fragment_source);
/// @brief Use/activate shader program
void use() const; // 改为const /*
* @brief Compile compute shader from source
/// @brief Release shader resources * @param compute_source Compute shader source
void release(); * @return True if compilation succeeded
*/
/// @brief Set uniform boolean bool compile_compute(const std::string &compute_source);
/// @param name Uniform name
/// @param value Value // Use/activate shader program
void set_bool(const std::string& name, bool value) const; // 新增，const void use() const; // 改为const
/// @brief Set uniform integer // Release shader resources
/// @param name Uniform name void release();
/// @param value Value
void set_int(const std::string& name, int value) const; // 改为const /*
* @brief Set uniform boolean
/// @brief Set uniform unsigned integer * @param name Uniform name
/// @param name Uniform name * @param value Value
/// @param value Value */
void set_uint(const std::string& name, uint value) const; // 改为const void set_bool(const std::string &name, bool value) const; // 新增，const
/// @brief Set uniform float /*
/// @param name Uniform name * @brief Set uniform integer
/// @param value Value * @param name Uniform name
void set_float(const std::string& name, float value) const; // 改为const * @param value Value
*/
/// @brief Set uniform vec2 void set_int(const std::string &name, int value) const; // 改为const
/// @param name Uniform name
/// @param value Value /*
void set_vec2(const std::string& name, const Vec2& value) const; // 改为const * @brief Set uniform unsigned integer
* @param name Uniform name
/// @brief Set uniform vec3 * @param value Value
/// @param name Uniform name */
/// @param value Value void set_uint(const std::string &name, uint value) const; // 改为const
void set_vec3(const std::string& name, const Vec3& value) const; // 改为const
/*
/// @brief Set uniform vec4 * @brief Set uniform float
/// @param name Uniform name * @param name Uniform name
/// @param value Value * @param value Value
void set_vec4(const std::string& name, const Vec4& value) const; // 改为const */
void set_float(const std::string &name, float value) const; // 改为const
/// @brief Set uniform mat3
/// @param name Uniform name /*
/// @param value Value * @brief Set uniform vec2
void set_mat3(const std::string& name, const Mat3& value) const; // 改为const * @param name Uniform name
* @param value Value
/// @brief Set uniform mat4 */
/// @param name Uniform name void set_vec2(const std::string &name, const Vec2 &value) const; // 改为const
/// @param value Value
void set_mat4(const std::string& name, const Mat4& value) const; // 改为const /*
* @brief Set uniform vec3
/// @brief Get shader program handle * @param name Uniform name
/// @return Shader handle * @param value Value
ShaderHandle get_handle() const { return handle_; } */
void set_vec3(const std::string &name, const Vec3 &value) const; // 改为const
/// @brief Check if shader is valid
/// @return True if valid /*
bool is_valid() const { return handle_ != INVALID_HANDLE; } * @brief Set uniform vec4
* @param name Uniform name
* @param value Value
*/
void set_vec4(const std::string &name, const Vec4 &value) const; // 改为const
/*
* @brief Set uniform mat3
* @param name Uniform name
* @param value Value
*/
void set_mat3(const std::string &name, const Mat3 &value) const; // 改为const
/*
* @brief Set uniform mat4
* @param name Uniform name
* @param value Value
*/
void set_mat4(const std::string &name, const Mat4 &value) const; // 改为const
/*
* @brief Get shader program handle
* @return Shader handle
*/
ShaderHandle get_handle() const {
return handle_;
}
/*
* @brief Check if shader is valid
* @return True if valid
*/
bool is_valid() const {
return handle_ != INVALID_HANDLE;
}
private: private:
ShaderHandle handle_; ShaderHandle handle_;
mutable std::unordered_map<std::string, int> uniform_cache_; // 改为mutable mutable std::unordered_map<std::string, int> uniform_cache_; // 改为mutable
/// @brief Get uniform location (with caching) /*
/// @param name Uniform name * @brief Get uniform location (with caching)
/// @return Uniform location * @param name Uniform name
int get_uniform_location_(const std::string& name) const; // 改为const * @return Uniform location
*/
/// @brief Compile shader stage int get_uniform_location_(const std::string &name) const; // 改为const
/// @param source Shader source code
/// @param type Shader type (GL_VERTEX_SHADER, etc.) /*
/// @return Shader object handle (0 on failure) * @brief Compile shader stage
uint compile_shader_(const std::string& source, uint type); * @param source Shader source code
* @param type Shader type (GL_VERTEX_SHADER, etc.)
/// @brief Link shader program * @return Shader object handle (0 on failure)
/// @param shaders Array of shader object handles */
/// @param count Number of shaders uint compile_shader_(const std::string &source, uint type);
/// @return True if linking succeeded
bool link_program_(const uint* shaders, uint count); /*
* @brief Link shader program
/// @brief Read file content * @param shaders Array of shader object handles
/// @param path File path * @param count Number of shaders
/// @return File content * @return True if linking succeeded
std::string read_file_(const std::string& path); */
bool link_program_(const uint *shaders, uint count);
/*
* @brief Read file content
* @param path File path
* @return File content
*/
std::string read_file_(const std::string &path);
}; };
} // namespace are } // namespace are

242
include/resource/texture.h
View File

@ -6,126 +6,158 @@
namespace are { namespace are {
/// @brief Texture format enumeration // Texture format enumeration
enum class TextureFormat { enum class TextureFormat {
R8, R8,
RG8, RG8,
RGB8, RGB8,
RGBA8, RGBA8,
R16F, R16F,
RG16F, RG16F,
RGB16F, RGB16F,
RGBA16F, RGBA16F,
R32F, R32F,
RG32F, RG32F,
RGB32F, RGB32F,
RGBA32F, RGBA32F,
DEPTH24_STENCIL8 DEPTH24_STENCIL8
}; };
/// @brief Texture filter mode // Texture filter mode
enum class TextureFilter { enum class TextureFilter {
NEAREST, NEAREST,
LINEAR, LINEAR,
NEAREST_MIPMAP_NEAREST, NEAREST_MIPMAP_NEAREST,
LINEAR_MIPMAP_NEAREST, LINEAR_MIPMAP_NEAREST,
NEAREST_MIPMAP_LINEAR, NEAREST_MIPMAP_LINEAR,
LINEAR_MIPMAP_LINEAR LINEAR_MIPMAP_LINEAR
}; };
/// @brief Texture wrap mode // Texture wrap mode
enum class TextureWrap { enum class TextureWrap {
REPEAT, REPEAT,
MIRRORED_REPEAT, MIRRORED_REPEAT,
CLAMP_TO_EDGE, CLAMP_TO_EDGE,
CLAMP_TO_BORDER CLAMP_TO_BORDER
}; };
/// @brief Texture resource // Texture resource
class Texture { class Texture {
public: public:
/// @brief Constructor // Constructor
Texture(); Texture();
Texture(const Texture&) = delete; Texture(const Texture &) = delete;
Texture& operator=(const Texture&) = delete; Texture &operator=(const Texture &) = delete;
Texture(Texture&& other) noexcept; Texture(Texture &&other) noexcept;
Texture& operator=(Texture&& other) noexcept; Texture &operator=(Texture &&other) noexcept;
/// @brief Destructor // Destructor
~Texture(); ~Texture();
/// @brief Load texture from file /*
/// @param path File path * @brief Load texture from file
/// @param generate_mipmaps Generate mipmaps * @param path File path
/// @return True if loading succeeded * @param generate_mipmaps Generate mipmaps
bool load_from_file(const std::string& path, bool generate_mipmaps = true); * @return True if loading succeeded
*/
/// @brief Create empty texture bool load_from_file(const std::string &path, bool generate_mipmaps = true);
/// @param width Texture width
/// @param height Texture height /*
/// @param format Texture format * @brief Create empty texture
/// @return True if creation succeeded * @param width Texture width
bool create(uint width, uint height, TextureFormat format); * @param height Texture height
* @param format Texture format
/// @brief Upload data to texture * @return True if creation succeeded
/// @param data Pixel data */
/// @param width Data width bool create(uint width, uint height, TextureFormat format);
/// @param height Data height
/// @param format Data format /*
/// @return True if upload succeeded * @brief Upload data to texture
bool upload(const void* data, uint width, uint height, TextureFormat format); * @param data Pixel data
* @param width Data width
/// @brief Set texture filter mode * @param height Data height
/// @param min_filter Minification filter * @param format Data format
/// @param mag_filter Magnification filter * @return True if upload succeeded
void set_filter(TextureFilter min_filter, TextureFilter mag_filter); */
bool upload(const void *data, uint width, uint height, TextureFormat format);
/// @brief Set texture wrap mode
/// @param wrap_s Wrap mode for S coordinate /*
/// @param wrap_t Wrap mode for T coordinate * @brief Set texture filter mode
void set_wrap(TextureWrap wrap_s, TextureWrap wrap_t); * @param min_filter Minification filter
* @param mag_filter Magnification filter
/// @brief Generate mipmaps */
void generate_mipmaps(); void set_filter(TextureFilter min_filter, TextureFilter mag_filter);
/// @brief Bind texture to texture unit /*
/// @param unit Texture unit * @brief Set texture wrap mode
void bind(uint unit) const; * @param wrap_s Wrap mode for S coordinate
* @param wrap_t Wrap mode for T coordinate
/// @brief Unbind texture */
void unbind() const; void set_wrap(TextureWrap wrap_s, TextureWrap wrap_t);
/// @brief Release texture resources // Generate mipmaps
void release(); void generate_mipmaps();
/// @brief Get texture handle /*
/// @return Texture handle * @brief Bind texture to texture unit
TextureHandle get_handle() const { return handle_; } * @param unit Texture unit
*/
/// @brief Get texture width void bind(uint unit) const;
/// @return Width
uint get_width() const { return width_; } // Unbind texture
void unbind() const;
/// @brief Get texture height
/// @return Height // Release texture resources
uint get_height() const { return height_; } void release();
/// @brief Get texture format /*
/// @return Format * @brief Get texture handle
TextureFormat get_format() const { return format_; } * @return Texture handle
*/
/// @brief Check if texture is valid TextureHandle get_handle() const {
/// @return True if valid return handle_;
bool is_valid() const { return handle_ != INVALID_HANDLE; } }
/*
* @brief Get texture width
* @return Width
*/
uint get_width() const {
return width_;
}
/*
* @brief Get texture height
* @return Height
*/
uint get_height() const {
return height_;
}
/*
* @brief Get texture format
* @return Format
*/
TextureFormat get_format() const {
return format_;
}
/*
* @brief Check if texture is valid
* @return True if valid
*/
bool is_valid() const {
return handle_ != INVALID_HANDLE;
}
private: private:
TextureHandle handle_; TextureHandle handle_;
uint width_; uint width_;
uint height_; uint height_;
TextureFormat format_; TextureFormat format_;
bool has_mipmaps_; bool has_mipmaps_;
}; };
} // namespace are } // namespace are

198
include/scene/camera.h
View File

@ -5,99 +5,125 @@
namespace are { namespace are {
/// @brief Camera projection type // Camera projection type
enum class ProjectionType { enum class ProjectionType {
PERSPECTIVE, PERSPECTIVE,
ORTHOGRAPHIC ORTHOGRAPHIC
}; };
/// @brief Camera for rendering // Camera for rendering
class Camera { class Camera {
public: public:
/// @brief Constructor // Constructor
Camera(); Camera();
/// @brief Destructor // Destructor
~Camera(); ~Camera();
/// @brief Set perspective projection /*
/// @param fov Field of view in degrees * @brief Set perspective projection
/// @param aspect Aspect ratio * @param fov Field of view in degrees
/// @param near Near plane * @param aspect Aspect ratio
/// @param far Far plane * @param near Near plane
void set_perspective(float fov, float aspect, float near, float far); * @param far Far plane
*/
/// @brief Set orthographic projection void set_perspective(float fov, float aspect, float near, float far);
/// @param left Left plane
/// @param right Right plane /*
/// @param bottom Bottom plane * @brief Set orthographic projection
/// @param top Top plane * @param left Left plane
/// @param near Near plane * @param right Right plane
/// @param far Far plane * @param bottom Bottom plane
void set_orthographic(float left, float right, float bottom, float top, float near, float far); * @param top Top plane
* @param near Near plane
/// @brief Set camera position * @param far Far plane
/// @param position Position */
void set_position(const Vec3& position); void set_orthographic(float left, float right, float bottom, float top, float near, float far);
/// @brief Set camera target /*
/// @param target Target position * @brief Set camera position
void set_target(const Vec3& target); * @param position Position
*/
/// @brief Set camera up vector void set_position(const Vec3 &position);
/// @param up Up vector
void set_up(const Vec3& up); /*
* @brief Set camera target
/// @brief Get view matrix * @param target Target position
/// @return View matrix */
Mat4 get_view_matrix() const; void set_target(const Vec3 &target);
/// @brief Get projection matrix /*
/// @return Projection matrix * @brief Set camera up vector
Mat4 get_projection_matrix() const; * @param up Up vector
*/
/// @brief Get view-projection matrix void set_up(const Vec3 &up);
/// @return View-projection matrix
Mat4 get_view_projection_matrix() const; /*
* @brief Get view matrix
/// @brief Get camera position * @return View matrix
/// @return Position */
const Vec3& get_position() const { return position_; } Mat4 get_view_matrix() const;
/// @brief Get camera forward direction /*
/// @return Forward direction * @brief Get projection matrix
Vec3 get_forward() const; * @return Projection matrix
*/
/// @brief Get camera right direction Mat4 get_projection_matrix() const;
/// @return Right direction
Vec3 get_right() const; /*
* @brief Get view-projection matrix
/// @brief Get camera up direction * @return View-projection matrix
/// @return Up direction */
Vec3 get_up() const; Mat4 get_view_projection_matrix() const;
/*
* @brief Get camera position
* @return Position
*/
const Vec3 &get_position() const {
return position_;
}
/*
* @brief Get camera forward direction
* @return Forward direction
*/
Vec3 get_forward() const;
/*
* @brief Get camera right direction
* @return Right direction
*/
Vec3 get_right() const;
/*
* @brief Get camera up direction
* @return Up direction
*/
Vec3 get_up() const;
private: private:
Vec3 position_; Vec3 position_;
Vec3 target_; Vec3 target_;
Vec3 up_; Vec3 up_;
ProjectionType projection_type_; ProjectionType projection_type_;
// Perspective parameters // Perspective parameters
float fov_; float fov_;
float aspect_; float aspect_;
// Orthographic parameters // Orthographic parameters
float left_, right_, bottom_, top_; float left_, right_, bottom_, top_;
// Common parameters // Common parameters
float near_; float near_;
float far_; float far_;
mutable Mat4 view_matrix_; mutable Mat4 view_matrix_;
mutable Mat4 projection_matrix_; mutable Mat4 projection_matrix_;
mutable bool view_dirty_; mutable bool view_dirty_;
mutable bool projection_dirty_; mutable bool projection_dirty_;
}; };
} // namespace are } // namespace are

100
include/scene/light.h
View File

@ -5,95 +5,125 @@
namespace are { namespace are {
/// @brief Light type enumeration // Light type enumeration
enum class LightType { enum class LightType {
DIRECTIONAL = 0, DIRECTIONAL = 0,
POINT = 1, POINT = 1,
SPOT = 2 SPOT = 2
}; };
/// @brief Light source // Light source
class Light { class Light {
public: public:
/// @brief Constructor // Constructor
Light(); Light();
/// @brief Destructor // Destructor
~Light(); ~Light();
/// @brief Set light type /*
/// @param type Light type * @brief Set light type
* @param type Light type
*/
void set_type(LightType type); void set_type(LightType type);
/// @brief Set light position (for point and spot lights) /*
/// @param position Light position * @brief Set light position (for point and spot lights)
* @param position Light position
*/
void set_position(const Vec3 &position); void set_position(const Vec3 &position);
/// @brief Set light direction (for directional and spot lights) /*
/// @param direction Light direction * @brief Set light direction (for directional and spot lights)
* @param direction Light direction
*/
void set_direction(const Vec3 &direction); void set_direction(const Vec3 &direction);
/// @brief Set light color /*
/// @param color Light color * @brief Set light color
* @param color Light color
*/
void set_color(const Vec3 &color); void set_color(const Vec3 &color);
/// @brief Set light intensity /*
/// @param intensity Light intensity * @brief Set light intensity
* @param intensity Light intensity
*/
void set_intensity(float intensity); void set_intensity(float intensity);
/// @brief Set light range (for point and spot lights) /*
/// @param range Light range * @brief Set light range (for point and spot lights)
* @param range Light range
*/
void set_range(float range); void set_range(float range);
/// @brief Set spot light angles /*
/// @param inner_angle Inner cone angle in degrees * @brief Set spot light angles
/// @param outer_angle Outer cone angle in degrees * @param inner_angle Inner cone angle in degrees
* @param outer_angle Outer cone angle in degrees
*/
void set_spot_angles(float inner_angle, float outer_angle); void set_spot_angles(float inner_angle, float outer_angle);
/// @brief Get light type /*
/// @return Light type * @brief Get light type
* @return Light type
*/
LightType get_type() const { LightType get_type() const {
return type_; return type_;
} }
/// @brief Get light position /*
/// @return Light position * @brief Get light position
* @return Light position
*/
const Vec3 &get_position() const { const Vec3 &get_position() const {
return position_; return position_;
} }
/// @brief Get light direction /*
/// @return Light direction * @brief Get light direction
* @return Light direction
*/
const Vec3 &get_direction() const { const Vec3 &get_direction() const {
return direction_; return direction_;
} }
/// @brief Get light color /*
/// @return Light color * @brief Get light color
* @return Light color
*/
const Vec3 &get_color() const { const Vec3 &get_color() const {
return color_; return color_;
} }
/// @brief Get light intensity /*
/// @return Light intensity * @brief Get light intensity
* @return Light intensity
*/
float get_intensity() const { float get_intensity() const {
return intensity_; return intensity_;
} }
/// @brief Get light range /*
/// @return Light range * @brief Get light range
* @return Light range
*/
float get_range() const { float get_range() const {
return range_; return range_;
} }
/// @brief Get spot light inner angle /*
/// @return Inner angle in radians * @brief Get spot light inner angle
* @return Inner angle in radians
*/
float get_inner_angle() const { float get_inner_angle() const {
return inner_angle_; return inner_angle_;
} }
/// @brief Get spot light outer angle /*
/// @return Outer angle in radians * @brief Get spot light outer angle
* @return Outer angle in radians
*/
float get_outer_angle() const { float get_outer_angle() const {
return outer_angle_; return outer_angle_;
} }

216
include/scene/material.h
View File

@ -7,97 +7,145 @@
namespace are { namespace are {
/// @brief Material type enumeration // Material type enumeration
enum class MaterialType { enum class MaterialType {
DIFFUSE = 0, DIFFUSE = 0,
METAL = 1, METAL = 1,
DIELECTRIC = 2, DIELECTRIC = 2,
EMISSIVE = 3 EMISSIVE = 3
}; };
/// @brief Material properties // Material properties
class Material { class Material {
public: public:
/// @brief Constructor // Constructor
Material(); Material();
/// @brief Destructor // Destructor
~Material(); ~Material();
/// @brief Set albedo color /*
/// @param albedo Albedo color * @brief Set albedo color
void set_albedo(const Vec3& albedo); * @param albedo Albedo color
*/
/// @brief Set emission color void set_albedo(const Vec3 &albedo);
/// @param emission Emission color
void set_emission(const Vec3& emission); /*
* @brief Set emission color
/// @brief Set metallic value * @param emission Emission color
/// @param metallic Metallic (0-1) */
void set_metallic(float metallic); void set_emission(const Vec3 &emission);
/// @brief Set roughness value /*
/// @param roughness Roughness (0-1) * @brief Set metallic value
void set_roughness(float roughness); * @param metallic Metallic (0-1)
*/
/// @brief Set index of refraction void set_metallic(float metallic);
/// @param ior Index of refraction
void set_ior(float ior); /*
* @brief Set roughness value
/// @brief Set material type * @param roughness Roughness (0-1)
/// @param type Material type */
void set_type(MaterialType type); void set_roughness(float roughness);
/// @brief Set albedo texture /*
/// @param texture Albedo texture * @brief Set index of refraction
void set_albedo_texture(std::shared_ptr<Texture> texture); * @param ior Index of refraction
*/
/// @brief Set normal map void set_ior(float ior);
/// @param texture Normal map texture
void set_normal_texture(std::shared_ptr<Texture> texture); /*
* @brief Set material type
/// @brief Get albedo color * @param type Material type
/// @return Albedo color */
const Vec3& get_albedo() const { return albedo_; } void set_type(MaterialType type);
/// @brief Get emission color /*
/// @return Emission color * @brief Set albedo texture
const Vec3& get_emission() const { return emission_; } * @param texture Albedo texture
*/
/// @brief Get metallic value void set_albedo_texture(std::shared_ptr<Texture> texture);
/// @return Metallic
float get_metallic() const { return metallic_; } /*
* @brief Set normal map
/// @brief Get roughness value * @param texture Normal map texture
/// @return Roughness */
float get_roughness() const { return roughness_; } void set_normal_texture(std::shared_ptr<Texture> texture);
/// @brief Get index of refraction /*
/// @return IOR * @brief Get albedo color
float get_ior() const { return ior_; } * @return Albedo color
*/
/// @brief Get material type const Vec3 &get_albedo() const {
/// @return Material type return albedo_;
MaterialType get_type() const { return type_; } }
/// @brief Get albedo texture /*
/// @return Albedo texture (nullptr if none) * @brief Get emission color
std::shared_ptr<Texture> get_albedo_texture() const { return albedo_texture_; } * @return Emission color
*/
/// @brief Get normal texture const Vec3 &get_emission() const {
/// @return Normal texture (nullptr if none) return emission_;
std::shared_ptr<Texture> get_normal_texture() const { return normal_texture_; } }
/*
* @brief Get metallic value
* @return Metallic
*/
float get_metallic() const {
return metallic_;
}
/*
* @brief Get roughness value
* @return Roughness
*/
float get_roughness() const {
return roughness_;
}
/*
* @brief Get index of refraction
* @return IOR
*/
float get_ior() const {
return ior_;
}
/*
* @brief Get material type
* @return Material type
*/
MaterialType get_type() const {
return type_;
}
/*
* @brief Get albedo texture
* @return Albedo texture (nullptr if none)
*/
std::shared_ptr<Texture> get_albedo_texture() const {
return albedo_texture_;
}
/*
* @brief Get normal texture
* @return Normal texture (nullptr if none)
*/
std::shared_ptr<Texture> get_normal_texture() const {
return normal_texture_;
}
private: private:
Vec3 albedo_; Vec3 albedo_;
Vec3 emission_; Vec3 emission_;
float metallic_; float metallic_;
float roughness_; float roughness_;
float ior_; float ior_;
MaterialType type_; MaterialType type_;
std::shared_ptr<Texture> albedo_texture_; std::shared_ptr<Texture> albedo_texture_;
std::shared_ptr<Texture> normal_texture_; std::shared_ptr<Texture> normal_texture_;
}; };
} // namespace are } // namespace are

158
include/scene/mesh.h
View File

@ -6,72 +6,106 @@
namespace are { namespace are {
/// @brief Mesh data container // Mesh data container
class Mesh { class Mesh {
public: public:
/// @brief Constructor // Constructor
Mesh(); Mesh();
/// @brief Destructor // Destructor
~Mesh(); ~Mesh();
/// @brief Set vertex data /*
/// @param vertices Vertex array * @brief Set vertex data
void set_vertices(const std::vector<Vertex>& vertices); * @param vertices Vertex array
*/
/// @brief Set index data void set_vertices(const std::vector<Vertex> &vertices);
/// @param indices Index array
void set_indices(const std::vector<uint>& indices); /*
* @brief Set index data
/// @brief Set material index * @param indices Index array
/// @param material_id Material index */
void set_material(uint material_id); void set_indices(const std::vector<uint> &indices);
/// @brief Set transform matrix /*
/// @param transform Transform matrix * @brief Set material index
void set_transform(const Mat4& transform); * @param material_id Material index
*/
/// @brief Get vertices void set_material(uint material_id);
/// @return Vertex array
const std::vector<Vertex>& get_vertices() const { return vertices_; } /*
* @brief Set transform matrix
/// @brief Get indices * @param transform Transform matrix
/// @return Index array */
const std::vector<uint>& get_indices() const { return indices_; } void set_transform(const Mat4 &transform);
/// @brief Get material index /*
/// @return Material index * @brief Get vertices
uint get_material() const { return material_id_; } * @return Vertex array
*/
/// @brief Get transform matrix const std::vector<Vertex> &get_vertices() const {
/// @return Transform matrix return vertices_;
const Mat4& get_transform() const { return transform_; } }
/// @brief Upload mesh data to GPU /*
/// @return True if upload succeeded * @brief Get indices
bool upload_to_gpu(); * @return Index array
*/
/// @brief Release GPU resources const std::vector<uint> &get_indices() const {
void release_gpu_resources(); return indices_;
}
/// @brief Get VAO handle
/// @return VAO handle /*
uint get_vao() const { return vao_; } * @brief Get material index
* @return Material index
/// @brief Check if mesh is uploaded to GPU */
/// @return True if uploaded uint get_material() const {
bool is_uploaded() const { return uploaded_; } return material_id_;
}
/*
* @brief Get transform matrix
* @return Transform matrix
*/
const Mat4 &get_transform() const {
return transform_;
}
/*
* @brief Upload mesh data to GPU
* @return True if upload succeeded
*/
bool upload_to_gpu();
// Release GPU resources
void release_gpu_resources();
/*
* @brief Get VAO handle
* @return VAO handle
*/
uint get_vao() const {
return vao_;
}
/*
* @brief Check if mesh is uploaded to GPU
* @return True if uploaded
*/
bool is_uploaded() const {
return uploaded_;
}
private: private:
std::vector<Vertex> vertices_; std::vector<Vertex> vertices_;
std::vector<uint> indices_; std::vector<uint> indices_;
uint material_id_; uint material_id_;
Mat4 transform_; Mat4 transform_;
uint vao_; uint vao_;
uint vbo_; uint vbo_;
uint ebo_; uint ebo_;
bool uploaded_; bool uploaded_;
}; };
} // namespace are } // namespace are

136
include/scene/scene.h
View File

@ -3,70 +3,96 @@
#include "basic/types.h" #include "basic/types.h"
#include "scene/camera.h" #include "scene/camera.h"
#include "scene/mesh.h"
#include "scene/material.h"
#include "scene/light.h" #include "scene/light.h"
#include <vector> #include "scene/material.h"
#include "scene/mesh.h"
#include <memory> #include <memory>
#include <vector>
namespace are { namespace are {
/// @brief Scene container holding all scene objects // Scene container holding all scene objects
class Scene { class Scene {
public: public:
/// @brief Constructor // Constructor
Scene(); Scene();
/// @brief Destructor // Destructor
~Scene(); ~Scene();
/// @brief Add mesh to scene /*
/// @param mesh Mesh to add * @brief Add mesh to scene
/// @return Mesh index * @param mesh Mesh to add
uint add_mesh(std::shared_ptr<Mesh> mesh); * @return Mesh index
*/
/// @brief Add material to scene uint add_mesh(std::shared_ptr<Mesh> mesh);
/// @param material Material to add
/// @return Material index /*
uint add_material(std::shared_ptr<Material> material); * @brief Add material to scene
* @param material Material to add
/// @brief Add light to scene * @return Material index
/// @param light Light to add */
/// @return Light index uint add_material(std::shared_ptr<Material> material);
uint add_light(std::shared_ptr<Light> light);
/*
/// @brief Set active camera * @brief Add light to scene
/// @param camera Camera to set * @param light Light to add
void set_camera(std::shared_ptr<Camera> camera); * @return Light index
*/
/// @brief Get active camera uint add_light(std::shared_ptr<Light> light);
/// @return Active camera
const Camera& get_camera() const { return *camera_; } /*
* @brief Set active camera
/// @brief Get all meshes * @param camera Camera to set
/// @return Mesh list */
const std::vector<std::shared_ptr<Mesh>>& get_meshes() const { return meshes_; } void set_camera(std::shared_ptr<Camera> camera);
/// @brief Get all materials /*
/// @return Material list * @brief Get active camera
const std::vector<std::shared_ptr<Material>>& get_materials() const { return materials_; } * @return Active camera
*/
/// @brief Get all lights const Camera &get_camera() const {
/// @return Light list return *camera_;
const std::vector<std::shared_ptr<Light>>& get_lights() const { return lights_; } }
/// @brief Clear all scene objects /*
void clear(); * @brief Get all meshes
* @return Mesh list
/// @brief Update scene (animations, transforms, etc.) */
/// @param delta_time Time since last update const std::vector<std::shared_ptr<Mesh>> &get_meshes() const {
void update(float delta_time); return meshes_;
}
/*
* @brief Get all materials
* @return Material list
*/
const std::vector<std::shared_ptr<Material>> &get_materials() const {
return materials_;
}
/*
* @brief Get all lights
* @return Light list
*/
const std::vector<std::shared_ptr<Light>> &get_lights() const {
return lights_;
}
// Clear all scene objects
void clear();
/*
* @brief Update scene (animations, transforms, etc.)
* @param delta_time Time since last update
*/
void update(float delta_time);
private: private:
std::shared_ptr<Camera> camera_; std::shared_ptr<Camera> camera_;
std::vector<std::shared_ptr<Mesh>> meshes_; std::vector<std::shared_ptr<Mesh>> meshes_;
std::vector<std::shared_ptr<Material>> materials_; std::vector<std::shared_ptr<Material>> materials_;
std::vector<std::shared_ptr<Light>> lights_; std::vector<std::shared_ptr<Light>> lights_;
}; };
} // namespace are } // namespace are

132
include/utils/config.h
View File

@ -6,63 +6,85 @@
namespace are { namespace are {
/// @brief Configuration manager for loading engine settings /*
/// @note This module should be implemented by the user * @brief Configuration manager for loading engine settings
* @note This module should be implemented by the user
*/
class Config { class Config {
public: public:
/// @brief Load configuration from file /*
/// @param path Configuration file path * @brief Load configuration from file
/// @return True if loading succeeded * @param path Configuration file path
static bool load(const std::string& path); * @return True if loading succeeded
*/
/// @brief Save configuration to file static bool load(const std::string &path);
/// @param path Configuration file path
/// @return True if saving succeeded /*
static bool save(const std::string& path); * @brief Save configuration to file
* @param path Configuration file path
/// @brief Get string value * @return True if saving succeeded
/// @param key Configuration key */
/// @param default_value Default value if key not found static bool save(const std::string &path);
/// @return Configuration value
static std::string get_string(const std::string& key, const std::string& default_value = ""); /*
* @brief Get string value
/// @brief Get integer value * @param key Configuration key
/// @param key Configuration key * @param default_value Default value if key not found
/// @param default_value Default value if key not found * @return Configuration value
/// @return Configuration value */
static int get_int(const std::string& key, int default_value = 0); static std::string get_string(const std::string &key, const std::string &default_value = "");
/// @brief Get float value /*
/// @param key Configuration key * @brief Get integer value
/// @param default_value Default value if key not found * @param key Configuration key
/// @return Configuration value * @param default_value Default value if key not found
static float get_float(const std::string& key, float default_value = 0.0f); * @return Configuration value
*/
/// @brief Get boolean value static int get_int(const std::string &key, int default_value = 0);
/// @param key Configuration key
/// @param default_value Default value if key not found /*
/// @return Configuration value * @brief Get float value
static bool get_bool(const std::string& key, bool default_value = false); * @param key Configuration key
* @param default_value Default value if key not found
/// @brief Set string value * @return Configuration value
/// @param key Configuration key */
/// @param value Configuration value static float get_float(const std::string &key, float default_value = 0.0f);
static void set_string(const std::string& key, const std::string& value);
/*
/// @brief Set integer value * @brief Get boolean value
/// @param key Configuration key * @param key Configuration key
/// @param value Configuration value * @param default_value Default value if key not found
static void set_int(const std::string& key, int value); * @return Configuration value
*/
/// @brief Set float value static bool get_bool(const std::string &key, bool default_value = false);
/// @param key Configuration key
/// @param value Configuration value /*
static void set_float(const std::string& key, float value); * @brief Set string value
* @param key Configuration key
/// @brief Set boolean value * @param value Configuration value
/// @param key Configuration key */
/// @param value Configuration value static void set_string(const std::string &key, const std::string &value);
static void set_bool(const std::string& key, bool value);
/*
* @brief Set integer value
* @param key Configuration key
* @param value Configuration value
*/
static void set_int(const std::string &key, int value);
/*
* @brief Set float value
* @param key Configuration key
* @param value Configuration value
*/
static void set_float(const std::string &key, float value);
/*
* @brief Set boolean value
* @param key Configuration key
* @param value Configuration value
*/
static void set_bool(const std::string &key, bool value);
}; };
} // namespace are } // namespace are

89
include/utils/logger.h
View File

@ -1,74 +1,65 @@
#ifndef ARE_INCLUDE_CORE_LOGGER_H #ifndef ARE_INCLUDE_CORE_LOGGER_H
#define ARE_INCLUDE_CORE_LOGGER_H #define ARE_INCLUDE_CORE_LOGGER_H
#include <string>
#include <memory> #include <memory>
#include <string>
namespace are { namespace are {
/** // Logging severity levels
* @enum LogLevel
* @brief Logging severity levels
*/
enum class LogLevel { enum class LogLevel {
ARE_LOG_TRACE, ARE_LOG_TRACE,
ARE_LOG_DEBUG, ARE_LOG_DEBUG,
ARE_LOG_INFO, ARE_LOG_INFO,
ARE_LOG_WARN, ARE_LOG_WARN,
ARE_LOG_ERROR, ARE_LOG_ERROR,
ARE_LOG_CRITICAL ARE_LOG_CRITICAL
}; };
/** // Thread-safe logging system
* @class Logger
* @brief Thread-safe logging system
*
* This class provides a simple interface for logging messages with different
* severity levels. It wraps spdlog for actual logging functionality.
*/
class Logger { class Logger {
public: public:
/** /**
* @brief Initialize the logging system * @brief Initialize the logging system
* @param min_level Minimum log level to display * @param min_level Minimum log level to display
*/ */
static void init(LogLevel min_level = LogLevel::ARE_LOG_INFO); static void init(LogLevel min_level = LogLevel::ARE_LOG_INFO);
/** /**
* @brief Shutdown the logging system * @brief Shutdown the logging system
*/ */
static void shutdown(); static void shutdown();
/** /**
* @brief Log a message with file/function/line information * @brief Log a message with file/function/line information
* @param level Log severity level * @param level Log severity level
* @param file Source file name * @param file Source file name
* @param func Function name * @param func Function name
* @param line Line number * @param line Line number
* @param message Log message * @param message Log message
*/ */
static void log(LogLevel level, const char* file, const char* func, static void log(LogLevel level, const char *file, const char *func,
int line, const std::string& message); int line, const std::string &message);
/** /**
* @brief Set minimum log level * @brief Set minimum log level
* @param level Minimum log level to display * @param level Minimum log level to display
*/ */
static void set_level(LogLevel level); static void set_level(LogLevel level);
private: private:
static std::shared_ptr<void> logger_impl_; ///< Internal logger implementation static std::shared_ptr<void> logger_impl_; ///< Internal logger implementation
static bool initialized_; ///< Initialization flag static bool initialized_; ///< Initialization flag
}; };
} // namespace are } // namespace are
// Logging macros // Logging macros
#define ARE_LOG_TRACE(msg) are::Logger::log(are::LogLevel::ARE_LOG_TRACE, __FILE__, __func__, __LINE__, msg) #define ARE_LOG_TRACE(msg) are::Logger::log(are::LogLevel::ARE_LOG_TRACE, __FILE__, __func__, __LINE__, msg)
#define ARE_LOG_DEBUG(msg) are::Logger::log(are::LogLevel::ARE_LOG_DEBUG, __FILE__, __func__, __LINE__, msg) #define ARE_LOG_DEBUG(msg) are::Logger::log(are::LogLevel::ARE_LOG_DEBUG, __FILE__, __func__, __LINE__, msg)
#define ARE_LOG_INFO(msg) are::Logger::log(are::LogLevel::ARE_LOG_INFO, __FILE__, __func__, __LINE__, msg) #define ARE_LOG_INFO(msg) are::Logger::log(are::LogLevel::ARE_LOG_INFO, __FILE__, __func__, __LINE__, msg)
#define ARE_LOG_WARN(msg) are::Logger::log(are::LogLevel::ARE_LOG_WARN, __FILE__, __func__, __LINE__, msg) #define ARE_LOG_WARN(msg) are::Logger::log(are::LogLevel::ARE_LOG_WARN, __FILE__, __func__, __LINE__, msg)
#define ARE_LOG_ERROR(msg) are::Logger::log(are::LogLevel::ARE_LOG_ERROR, __FILE__, __func__, __LINE__, msg) #define ARE_LOG_ERROR(msg) are::Logger::log(are::LogLevel::ARE_LOG_ERROR, __FILE__, __func__, __LINE__, msg)
#define ARE_LOG_CRITICAL(msg) are::Logger::log(are::LogLevel::ARE_LOG_CRITICAL, __FILE__, __func__, __LINE__, msg) #define ARE_LOG_CRITICAL(msg) are::Logger::log(are::LogLevel::ARE_LOG_CRITICAL, __FILE__, __func__, __LINE__, msg)
#endif // ARE_INCLUDE_CORE_LOGGER_H #endif // ARE_INCLUDE_CORE_LOGGER_H