4337 lines
111 KiB
Markdown
4337 lines
111 KiB
Markdown
我其实已经实现了所有头文件了，包括所有模块的所有接口以及使用方法都在里面，所以让我直接给你所有头文件的完整源码吧：
|
||
|
||
### 文件：include/are/are.h
|
||
|
||
```cpp
|
||
/**
|
||
* @file are.h
|
||
* @brief Aurora Rendering Engine - Main header file
|
||
*
|
||
* This header includes all public interfaces of the Aurora Rendering Engine.
|
||
* Users only need to include this single header to access all functionality.
|
||
*
|
||
* @author Ternary_Operator
|
||
* @version 1.0
|
||
*/
|
||
|
||
#ifndef ARE_INCLUDE_ARE_H
|
||
#define ARE_INCLUDE_ARE_H
|
||
|
||
// Core modules
|
||
#include <are/core/config.h>
|
||
#include <are/core/logger.h>
|
||
#include <are/core/types.h>
|
||
#include <are/core/profiler.h>
|
||
|
||
// Platform modules
|
||
#include <are/platform/window.h>
|
||
#include <are/platform/gl_context.h>
|
||
|
||
// Geometry modules
|
||
#include <are/geometry/vertex.h>
|
||
#include <are/geometry/triangle.h>
|
||
#include <are/geometry/aabb.h>
|
||
#include <are/geometry/transform.h>
|
||
|
||
// Scene modules
|
||
#include <are/scene/camera.h>
|
||
#include <are/scene/mesh.h>
|
||
#include <are/scene/material.h>
|
||
#include <are/scene/light.h>
|
||
#include <are/scene/directional_light.h>
|
||
#include <are/scene/point_light.h>
|
||
#include <are/scene/spot_light.h>
|
||
#include <are/scene/scene_manager.h>
|
||
|
||
// Acceleration modules
|
||
#include <are/acceleration/bvh.h>
|
||
|
||
// Renderer modules
|
||
#include <are/renderer/renderer.h>
|
||
#include <are/renderer/render_stats.h>
|
||
|
||
// Utility modules
|
||
#include <are/utils/image_io.h>
|
||
#include <are/utils/math_utils.h>
|
||
|
||
/**
|
||
* @namespace are
|
||
* @brief Main namespace for Aurora Rendering Engine
|
||
*/
|
||
namespace are {
|
||
|
||
/**
|
||
* @brief Get the version string of the engine
|
||
* @return Version string in format "major.minor.patch"
|
||
*/
|
||
const char* get_version();
|
||
|
||
/**
|
||
* @brief Initialize the Aurora Rendering Engine
|
||
* @return true if initialization succeeded, false otherwise
|
||
*/
|
||
bool initialize();
|
||
|
||
/**
|
||
* @brief Shutdown the Aurora Rendering Engine
|
||
*/
|
||
void shutdown();
|
||
|
||
} // namespace are
|
||
|
||
#endif // ARE_INCLUDE_ARE_H
|
||
```
|
||
|
||
### 文件：include/are/core/types.h
|
||
|
||
```cpp
|
||
/**
|
||
* @file types.h
|
||
* @brief Basic type definitions and constants
|
||
*/
|
||
|
||
#ifndef ARE_INCLUDE_CORE_TYPES_H
|
||
#define ARE_INCLUDE_CORE_TYPES_H
|
||
|
||
#include <cstdint>
|
||
#include <glm/glm.hpp>
|
||
|
||
namespace are {
|
||
|
||
// Floating point precision
|
||
using Real = float;
|
||
|
||
// Common vector types
|
||
using Vec2 = glm::vec2;
|
||
using Vec3 = glm::vec3;
|
||
using Vec4 = glm::vec4;
|
||
|
||
using Vec2i = glm::ivec2;
|
||
using Vec3i = glm::ivec3;
|
||
using Vec4i = glm::ivec4;
|
||
|
||
// Matrix types
|
||
using Mat3 = glm::mat3;
|
||
using Mat4 = glm::mat4;
|
||
|
||
// Color type (RGBA)
|
||
using Color = Vec4;
|
||
|
||
// Handle types for resource management
|
||
using MeshHandle = uint32_t;
|
||
using MaterialHandle = uint32_t;
|
||
using LightHandle = uint32_t;
|
||
using TextureHandle = uint32_t;
|
||
|
||
// Invalid handle constant
|
||
constexpr uint32_t are_invalid_handle = 0xFFFFFFFF;
|
||
|
||
// Mathematical constants
|
||
constexpr Real are_pi = 3.14159265358979323846f;
|
||
constexpr Real are_two_pi = 6.28318530717958647692f;
|
||
constexpr Real are_inv_pi = 0.31830988618379067154f;
|
||
constexpr Real are_inv_two_pi = 0.15915494309189533577f;
|
||
constexpr Real are_epsilon = 1e-6f;
|
||
|
||
// Ray tracing backend types
|
||
enum class RayTracingBackend {
|
||
ARE_RT_BACKEND_CPU,
|
||
ARE_RT_BACKEND_COMPUTE_SHADER
|
||
};
|
||
|
||
// Tone mapping operators
|
||
enum class ToneMappingOperator {
|
||
ARE_TONEMAP_NONE,
|
||
ARE_TONEMAP_REINHARD,
|
||
ARE_TONEMAP_ACES
|
||
};
|
||
|
||
// G-Buffer visualization modes
|
||
enum class GBufferVisualizationMode {
|
||
ARE_GBUFFER_VIS_NONE,
|
||
ARE_GBUFFER_VIS_POSITION,
|
||
ARE_GBUFFER_VIS_NORMAL,
|
||
ARE_GBUFFER_VIS_ALBEDO,
|
||
ARE_GBUFFER_VIS_METALLIC,
|
||
ARE_GBUFFER_VIS_ROUGHNESS,
|
||
ARE_GBUFFER_VIS_DEPTH
|
||
};
|
||
|
||
} // namespace are
|
||
|
||
#endif // ARE_INCLUDE_CORE_TYPES_H
|
||
```
|
||
|
||
### 文件：include/are/core/config.h
|
||
|
||
```cpp
|
||
/**
|
||
* @file config.h
|
||
* @brief Configuration system for the rendering engine
|
||
*/
|
||
|
||
#ifndef ARE_INCLUDE_CORE_CONFIG_H
|
||
#define ARE_INCLUDE_CORE_CONFIG_H
|
||
|
||
#include <are/core/types.h>
|
||
#include <string>
|
||
|
||
namespace are {
|
||
|
||
/**
|
||
* @struct WindowConfig
|
||
* @brief Configuration for window creation
|
||
*/
|
||
struct WindowConfig {
|
||
int width = 1280; ///< Window width in pixels
|
||
int height = 720; ///< Window height in pixels
|
||
std::string title = "Aurora Rendering Engine"; ///< Window title
|
||
bool resizable = true; ///< Whether window is resizable
|
||
bool vsync = true; ///< Enable vertical synchronization
|
||
int samples = 1; ///< MSAA samples (1 = disabled)
|
||
};
|
||
|
||
/**
|
||
* @struct RayTracingConfig
|
||
* @brief Configuration for ray tracing
|
||
*/
|
||
struct RayTracingConfig {
|
||
RayTracingBackend backend = RayTracingBackend::ARE_RT_BACKEND_COMPUTE_SHADER;
|
||
int spp = 64; ///< Samples per pixel
|
||
int max_depth = 8; ///< Maximum ray bounce depth
|
||
bool enable_gi = true; ///< Enable global illumination
|
||
bool enable_ao = true; ///< Enable ambient occlusion
|
||
bool enable_soft_shadows = false; ///< Enable soft shadows
|
||
int ao_samples = 16; ///< AO sample count
|
||
Real ao_radius = 1.0f; ///< AO sampling radius
|
||
};
|
||
|
||
/**
|
||
* @struct RenderConfig
|
||
* @brief General rendering configuration
|
||
*/
|
||
struct RenderConfig {
|
||
ToneMappingOperator tonemap_op = ToneMappingOperator::ARE_TONEMAP_ACES;
|
||
Real exposure = 1.0f; ///< Exposure value for tone mapping
|
||
bool use_hdr = true; ///< Use HDR rendering pipeline
|
||
GBufferVisualizationMode gbuffer_vis_mode = GBufferVisualizationMode::ARE_GBUFFER_VIS_NONE;
|
||
};
|
||
|
||
/**
|
||
* @struct PerformanceConfig
|
||
* @brief Performance-related configuration
|
||
*/
|
||
struct PerformanceConfig {
|
||
int num_threads = 0; ///< Number of threads (0 = auto-detect)
|
||
bool enable_bvh_multithreading = true; ///< Use multithreading for BVH construction
|
||
bool enable_profiling = false; ///< Enable performance profiling
|
||
};
|
||
|
||
/**
|
||
* @struct PathConfig
|
||
* @brief File path configuration
|
||
*/
|
||
struct PathConfig {
|
||
std::string shader_dir = "shaders/"; ///< Directory containing shader files
|
||
std::string texture_dir = "textures/"; ///< Default texture directory
|
||
std::string output_dir = "output/"; ///< Default output directory
|
||
};
|
||
|
||
/**
|
||
* @class AreConfig
|
||
* @brief Main configuration class for Aurora Rendering Engine
|
||
*/
|
||
class AreConfig {
|
||
public:
|
||
WindowConfig window; ///< Window configuration
|
||
RayTracingConfig ray_tracing; ///< Ray tracing configuration
|
||
RenderConfig render; ///< Rendering configuration
|
||
PerformanceConfig performance; ///< Performance configuration
|
||
PathConfig paths; ///< Path configuration
|
||
|
||
/**
|
||
* @brief Constructor with default values
|
||
*/
|
||
AreConfig() = default;
|
||
|
||
/**
|
||
* @brief Validate configuration values
|
||
* @return true if configuration is valid, false otherwise
|
||
*/
|
||
bool validate() const;
|
||
|
||
/**
|
||
* @brief Print configuration to console
|
||
*/
|
||
void print() const;
|
||
};
|
||
|
||
} // namespace are
|
||
|
||
#endif // ARE_INCLUDE_CORE_CONFIG_H
|
||
```
|
||
|
||
### 文件：include/are/core/logger.h
|
||
|
||
```cpp
|
||
/**
|
||
* @file logger.h
|
||
* @brief Logging system for the rendering engine
|
||
*/
|
||
|
||
#ifndef ARE_INCLUDE_CORE_LOGGER_H
|
||
#define ARE_INCLUDE_CORE_LOGGER_H
|
||
|
||
#include <string>
|
||
#include <memory>
|
||
|
||
namespace are {
|
||
|
||
/**
|
||
* @enum LogLevel
|
||
* @brief Logging severity levels
|
||
*/
|
||
enum class LogLevel {
|
||
ARE_LOG_TRACE,
|
||
ARE_LOG_DEBUG,
|
||
ARE_LOG_INFO,
|
||
ARE_LOG_WARN,
|
||
ARE_LOG_ERROR,
|
||
ARE_LOG_CRITICAL
|
||
};
|
||
|
||
/**
|
||
* @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 {
|
||
public:
|
||
/**
|
||
* @brief Initialize the logging system
|
||
* @param min_level Minimum log level to display
|
||
*/
|
||
static void init(LogLevel min_level = LogLevel::ARE_LOG_INFO);
|
||
|
||
/**
|
||
* @brief Shutdown the logging system
|
||
*/
|
||
static void shutdown();
|
||
|
||
/**
|
||
* @brief Log a message with file/function/line information
|
||
* @param level Log severity level
|
||
* @param file Source file name
|
||
* @param func Function name
|
||
* @param line Line number
|
||
* @param message Log message
|
||
*/
|
||
static void log(LogLevel level, const char* file, const char* func,
|
||
int line, const std::string& message);
|
||
|
||
/**
|
||
* @brief Set minimum log level
|
||
* @param level Minimum log level to display
|
||
*/
|
||
static void set_level(LogLevel level);
|
||
|
||
private:
|
||
static std::shared_ptr<void> logger_impl_; ///< Internal logger implementation
|
||
static bool initialized_; ///< Initialization flag
|
||
};
|
||
|
||
} // namespace are
|
||
|
||
// Logging macros
|
||
#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_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_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)
|
||
|
||
#endif // ARE_INCLUDE_CORE_LOGGER_H
|
||
```
|
||
|
||
### 文件：include/are/core/profiler.h
|
||
|
||
```cpp
|
||
/**
|
||
* @file profiler.h
|
||
* @brief Performance profiling utilities
|
||
*/
|
||
|
||
#ifndef ARE_INCLUDE_CORE_PROFILER_H
|
||
#define ARE_INCLUDE_CORE_PROFILER_H
|
||
|
||
#include <are/core/types.h>
|
||
#include <string>
|
||
#include <chrono>
|
||
#include <unordered_map>
|
||
|
||
namespace are {
|
||
|
||
/**
|
||
* @struct ProfileResult
|
||
* @brief Result of a profiling measurement
|
||
*/
|
||
struct ProfileResult {
|
||
std::string name_; ///< Profile section name
|
||
double duration_ms_; ///< Duration in milliseconds
|
||
uint64_t call_count_; ///< Number of times called
|
||
double avg_duration_ms_; ///< Average duration per call
|
||
};
|
||
|
||
/**
|
||
* @class Profiler
|
||
* @brief Simple performance profiler
|
||
*
|
||
* This class provides basic timing functionality for performance analysis.
|
||
* It is only active when ARE_ENABLE_PROFILING is defined.
|
||
*/
|
||
class Profiler {
|
||
public:
|
||
/**
|
||
* @brief Initialize the profiler
|
||
*/
|
||
static void init();
|
||
|
||
/**
|
||
* @brief Shutdown the profiler and print results
|
||
*/
|
||
static void shutdown();
|
||
|
||
/**
|
||
* @brief Begin a profiling section
|
||
* @param name Section name
|
||
*/
|
||
static void begin(const std::string& name);
|
||
|
||
/**
|
||
* @brief End a profiling section
|
||
* @param name Section name
|
||
*/
|
||
static void end(const std::string& name);
|
||
|
||
/**
|
||
* @brief Get profiling results
|
||
* @return Map of section names to profile results
|
||
*/
|
||
static const std::unordered_map<std::string, ProfileResult>& get_results();
|
||
|
||
/**
|
||
* @brief Reset all profiling data
|
||
*/
|
||
static void reset();
|
||
|
||
/**
|
||
* @brief Print profiling results to console
|
||
*/
|
||
static void print_results();
|
||
|
||
private:
|
||
struct SectionData {
|
||
std::chrono::high_resolution_clock::time_point start_time_;
|
||
double total_duration_ms_ = 0.0;
|
||
uint64_t call_count_ = 0;
|
||
};
|
||
|
||
static std::unordered_map<std::string, SectionData> sections_;
|
||
static std::unordered_map<std::string, ProfileResult> results_;
|
||
static bool enabled_;
|
||
};
|
||
|
||
/**
|
||
* @class ScopedProfiler
|
||
* @brief RAII-style profiler for automatic timing
|
||
*/
|
||
class ScopedProfiler {
|
||
public:
|
||
/**
|
||
* @brief Constructor - begins profiling
|
||
* @param name Section name
|
||
*/
|
||
explicit ScopedProfiler(const std::string& name);
|
||
|
||
/**
|
||
* @brief Destructor - ends profiling
|
||
*/
|
||
~ScopedProfiler();
|
||
|
||
private:
|
||
std::string name_;
|
||
};
|
||
|
||
} // namespace are
|
||
|
||
// Profiling macros
|
||
#ifdef ARE_ENABLE_PROFILING
|
||
#define ARE_PROFILE_BEGIN(name) are::Profiler::begin(name)
|
||
#define ARE_PROFILE_END(name) are::Profiler::end(name)
|
||
#define ARE_PROFILE_SCOPE(name) are::ScopedProfiler are_profiler_##__LINE__(name)
|
||
#define ARE_PROFILE_FUNCTION() ARE_PROFILE_SCOPE(__func__)
|
||
#else
|
||
#define ARE_PROFILE_BEGIN(name) ((void)0)
|
||
#define ARE_PROFILE_END(name) ((void)0)
|
||
#define ARE_PROFILE_SCOPE(name) ((void)0)
|
||
#define ARE_PROFILE_FUNCTION() ((void)0)
|
||
#endif
|
||
|
||
#endif // ARE_INCLUDE_CORE_PROFILER_H
|
||
```
|
||
|
||
### 文件：include/are/geometry/vertex.h
|
||
|
||
```cpp
|
||
/**
|
||
* @file vertex.h
|
||
* @brief Vertex data structure definition
|
||
*/
|
||
|
||
#ifndef ARE_INCLUDE_GEOMETRY_VERTEX_H
|
||
#define ARE_INCLUDE_GEOMETRY_VERTEX_H
|
||
|
||
#include <are/core/types.h>
|
||
|
||
namespace are {
|
||
|
||
/**
|
||
* @struct Vertex
|
||
* @brief Standard vertex structure for mesh data
|
||
*
|
||
* Contains position, normal, texture coordinates, and tangent information
|
||
* for PBR rendering pipeline.
|
||
*/
|
||
struct Vertex {
|
||
Vec3 position_;///< Vertex position in object space
|
||
Vec3 normal_; ///< Vertex normal (normalized)
|
||
Vec2 texcoord_; ///< Texture coordinates (UV)
|
||
Vec3 tangent_; ///< Tangent vector for normal mapping
|
||
|
||
Vertex() = default;
|
||
|
||
/**
|
||
* @brief Construct vertex with position only
|
||
* @param pos Position
|
||
*/
|
||
explicit Vertex(const Vec3& pos);
|
||
|
||
/**
|
||
* @brief Construct vertex with position and normal
|
||
* @param pos Position
|
||
* @param norm Normal
|
||
*/
|
||
Vertex(const Vec3& pos, const Vec3& norm);
|
||
|
||
/**
|
||
* @brief Construct vertex with position, normal, and texcoord
|
||
* @param pos Position
|
||
* @param norm Normal
|
||
* @param uv Texture coordinates
|
||
*/
|
||
Vertex(const Vec3& pos, const Vec3& norm, const Vec2& uv);
|
||
|
||
/**
|
||
* @brief Construct vertex with all attributes
|
||
* @param pos Position
|
||
* @param norm Normal
|
||
* @param uv Texture coordinates
|
||
* @param tan Tangent
|
||
*/
|
||
Vertex(const Vec3& pos, const Vec3& norm, const Vec2& uv, const Vec3& tan);
|
||
|
||
/**
|
||
* @brief Interpolate between two vertices
|
||
* @param a First vertex
|
||
* @param b Second vertex
|
||
* @param t Interpolation factor [0, 1]
|
||
* @return Interpolated vertex
|
||
*/
|
||
static Vertex lerp(const Vertex& a, const Vertex& b, Real t);
|
||
};
|
||
|
||
/**
|
||
* @brief Get vertex attribute stride for OpenGL
|
||
* @return Size of Vertex structure in bytes
|
||
*/
|
||
constexpr size_t get_vertex_stride() {
|
||
return sizeof(Vertex);
|
||
}
|
||
|
||
/**
|
||
* @brief Get offset of position attribute
|
||
* @return Offset in bytes
|
||
*/
|
||
constexpr size_t get_position_offset() {
|
||
return offsetof(Vertex, position_);
|
||
}
|
||
|
||
/**
|
||
* @brief Get offset of normal attribute
|
||
* @return Offset in bytes
|
||
*/
|
||
constexpr size_t get_normal_offset() {
|
||
return offsetof(Vertex, normal_);
|
||
}
|
||
|
||
/**
|
||
* @brief Get offset of texcoord attribute
|
||
* @return Offset in bytes
|
||
*/
|
||
constexpr size_t get_texcoord_offset() {
|
||
return offsetof(Vertex, texcoord_);
|
||
}
|
||
|
||
/**
|
||
* @brief Get offset of tangent attribute
|
||
* @return Offset in bytes
|
||
*/
|
||
constexpr size_t get_tangent_offset() {
|
||
return offsetof(Vertex, tangent_);
|
||
}
|
||
|
||
} // namespace are
|
||
|
||
#endif // ARE_INCLUDE_GEOMETRY_VERTEX_H
|
||
```
|
||
|
||
### 文件：include/are/geometry/aabb.h
|
||
|
||
```cpp
|
||
/**
|
||
* @file aabb.h
|
||
* @brief Axis-Aligned Bounding Box implementation
|
||
*/
|
||
|
||
#ifndef ARE_INCLUDE_GEOMETRY_AABB_H
|
||
#define ARE_INCLUDE_GEOMETRY_AABB_H
|
||
|
||
#include <are/core/types.h>
|
||
|
||
namespace are {
|
||
|
||
// Forward declaration
|
||
struct Ray;
|
||
|
||
/**
|
||
* @class AABB
|
||
* @brief Axis-Aligned Bounding Box for spatial queries
|
||
*
|
||
* Used for BVH construction and ray intersection acceleration.
|
||
*/
|
||
class AABB {
|
||
public:
|
||
Vec3 min_; ///< Minimum corner
|
||
Vec3 max_; ///< Maximum corner
|
||
|
||
/**
|
||
* @brief Default constructor - creates invalid AABB
|
||
*/
|
||
AABB();
|
||
|
||
/**
|
||
* @brief Construct AABB from min and max corners
|
||
* @param min Minimum corner
|
||
* @param max Maximum corner
|
||
*/
|
||
AABB(const Vec3& min, const Vec3& max);
|
||
|
||
/**
|
||
* @brief Construct AABB containing a single point
|
||
* @param point Point to contain
|
||
*/
|
||
explicit AABB(const Vec3& point);
|
||
|
||
/**
|
||
* @brief Check if AABB is valid (min <= max)
|
||
* @return true if valid
|
||
*/
|
||
bool is_valid() const;
|
||
|
||
/**
|
||
* @brief Get center of AABB
|
||
* @return Center point
|
||
*/
|
||
Vec3 center() const;
|
||
|
||
/**
|
||
* @brief Get size (extent) of AABB
|
||
* @return Size vector
|
||
*/
|
||
Vec3 size() const;
|
||
|
||
/**
|
||
* @brief Get surface area of AABB
|
||
* @return Surface area
|
||
*/
|
||
Real surface_area() const;
|
||
|
||
/**
|
||
* @brief Get volume of AABB
|
||
* @return Volume
|
||
*/
|
||
Real volume() const;
|
||
|
||
/**
|
||
* @brief Get longest axis index (0=x, 1=y, 2=z)
|
||
* @return Axis index
|
||
*/
|
||
int longest_axis() const;
|
||
|
||
/**
|
||
* @brief Expand AABB to include a point
|
||
* @param point Point to include
|
||
*/
|
||
void expand(const Vec3& point);
|
||
|
||
/**
|
||
* @brief Expand AABB to include another AABB
|
||
* @param other AABB to include
|
||
*/
|
||
void expand(const AABB& other);
|
||
|
||
/**
|
||
* @brief Check if AABB contains a point
|
||
* @param point Point to check
|
||
* @return true if point is inside AABB
|
||
*/
|
||
bool contains(const Vec3& point) const;
|
||
|
||
/**
|
||
* @brief Check if AABB intersects another AABB
|
||
* @param other AABB to check
|
||
* @return true if AABBs intersect
|
||
*/
|
||
bool intersects(const AABB& other) const;
|
||
|
||
/**
|
||
* @brief Ray-AABB intersection test
|
||
* @param ray Ray to test
|
||
* @param t_min Minimum t value (output)
|
||
* @param t_max Maximum t value (output)
|
||
* @return true if ray intersects AABB
|
||
*/
|
||
bool intersect_ray(const Ray& ray, Real& t_min, Real& t_max) const;
|
||
|
||
/**
|
||
* @brief Merge two AABBs
|
||
* @param a First AABB
|
||
* @param b Second AABB
|
||
* @return Merged AABB containing both
|
||
*/
|
||
static AABB merge(const AABB& a, const AABB& b);
|
||
|
||
/**
|
||
* @brief Create invalid AABB (for initialization)
|
||
* @return Invalid AABB
|
||
*/
|
||
static AABB invalid();
|
||
};
|
||
|
||
} // namespace are
|
||
|
||
#endif // ARE_INCLUDE_GEOMETRY_AABB_H
|
||
```
|
||
|
||
### 文件：include/are/geometry/triangle.h
|
||
|
||
```cpp
|
||
/**
|
||
* @file triangle.h
|
||
* @brief Triangle primitive definition
|
||
*/
|
||
|
||
#ifndef ARE_INCLUDE_GEOMETRY_TRIANGLE_H
|
||
#define ARE_INCLUDE_GEOMETRY_TRIANGLE_H
|
||
|
||
#include <are/core/types.h>
|
||
#include <are/geometry/vertex.h>
|
||
#include <are/geometry/aabb.h>
|
||
|
||
namespace are {
|
||
|
||
// Forward declaration
|
||
struct Ray;
|
||
struct HitRecord;
|
||
|
||
/**
|
||
* @struct Triangle
|
||
* @brief Triangle primitive for ray tracing
|
||
*
|
||
* Stores three vertices and provides intersection testing.
|
||
*/
|
||
struct Triangle {
|
||
Vertex v0_; ///< First vertex
|
||
Vertex v1_; ///< Second vertex
|
||
Vertex v2_; ///< Third vertex
|
||
MaterialHandle material_; ///< Material handle
|
||
|
||
/**
|
||
* @brief Default constructor
|
||
*/
|
||
Triangle();
|
||
|
||
/**
|
||
* @brief Construct triangle from three vertices
|
||
* @param v0 First vertex
|
||
* @param v1 Second vertex
|
||
* @param v2 Third vertex
|
||
* @param material Material handle
|
||
*/
|
||
Triangle(const Vertex& v0, const Vertex& v1, const Vertex& v2,
|
||
MaterialHandle material = are_invalid_handle);
|
||
|
||
/**
|
||
* @brief Get triangle centroid
|
||
* @return Centroid position
|
||
*/
|
||
Vec3 centroid() const;
|
||
|
||
/**
|
||
* @brief Get triangle normal (geometric normal)
|
||
* @return Normal vector (normalized)
|
||
*/
|
||
Vec3 normal() const;
|
||
|
||
/**
|
||
* @brief Get triangle area
|
||
* @return Area
|
||
*/
|
||
Real area() const;
|
||
|
||
/**
|
||
* @brief Compute axis-aligned bounding box
|
||
* @return AABB containing the triangle
|
||
*/
|
||
AABB compute_aabb() const;
|
||
|
||
/**
|
||
* @brief Ray-triangle intersection test (Möller-Trumbore algorithm)
|
||
* @param ray Ray to test
|
||
* @param hit Output hit record
|
||
* @return true if intersection occurred
|
||
*/
|
||
bool intersect(const Ray& ray, HitRecord& hit) const;
|
||
|
||
/**
|
||
* @brief Fast ray-triangle intersection test (no hit record)
|
||
* @param ray Ray to test
|
||
* @param t_max Maximum t value
|
||
* @return true if intersection occurred
|
||
*/
|
||
bool intersect_fast(const Ray& ray, Real t_max) const;
|
||
};
|
||
|
||
} // namespace are
|
||
|
||
#endif // ARE_INCLUDE_GEOMETRY_TRIANGLE_H
|
||
```
|
||
|
||
### 文件：include/are/geometry/transform.h
|
||
|
||
```cpp
|
||
/**
|
||
* @file transform.h
|
||
* @brief Transformation matrix utilities
|
||
*/
|
||
|
||
#ifndef ARE_INCLUDE_GEOMETRY_TRANSFORM_H
|
||
#define ARE_INCLUDE_GEOMETRY_TRANSFORM_H
|
||
|
||
#include <are/core/types.h>
|
||
|
||
namespace are {
|
||
|
||
/**
|
||
* @class Transform
|
||
* @brief 3D transformation (position, rotation, scale)
|
||
*
|
||
* Provides convenient interface for building transformation matrices.
|
||
*/
|
||
class Transform {
|
||
public:
|
||
/**
|
||
* @brief Default constructor (identity transform)
|
||
*/
|
||
Transform();
|
||
|
||
/**
|
||
* @brief Construct from position, rotation, and scale
|
||
* @param position Translation
|
||
* @param rotation Rotation (Euler angles in radians)
|
||
* @param scale Scale factors
|
||
*/
|
||
Transform(const Vec3& position, const Vec3& rotation, const Vec3& scale);
|
||
|
||
// Setters
|
||
void set_position(const Vec3& position);
|
||
void set_rotation(const Vec3& rotation);
|
||
void set_scale(const Vec3& scale);
|
||
void set_scale(Real uniform_scale);
|
||
|
||
// Getters
|
||
const Vec3& get_position() const { return position_; }
|
||
const Vec3& get_rotation() const { return rotation_; }
|
||
const Vec3& get_scale() const { return scale_; }
|
||
|
||
// Matrix operations
|
||
Mat4 get_matrix() const;
|
||
Mat4 get_inverse_matrix() const;
|
||
Mat3 get_normal_matrix() const;
|
||
|
||
/**
|
||
* @brief Transform a point
|
||
* @param point Point to transform
|
||
* @return Transformed point
|
||
*/
|
||
Vec3 transform_point(const Vec3& point) const;
|
||
|
||
/**
|
||
* @brief Transform a direction (ignores translation)
|
||
* @param direction Direction to transform
|
||
* @return Transformed direction
|
||
*/
|
||
Vec3 transform_direction(const Vec3& direction) const;
|
||
|
||
/**
|
||
* @brief Transform a normal (uses inverse transpose)
|
||
* @param normal Normal to transform
|
||
* @return Transformed normal
|
||
*/
|
||
Vec3 transform_normal(const Vec3& normal) const;
|
||
|
||
/**
|
||
* @brief Combine two transforms
|
||
* @param other Other transform
|
||
* @return Combined transform
|
||
*/
|
||
Transform operator*(const Transform& other) const;
|
||
|
||
/**
|
||
* @brief Create identity transform
|
||
* @return Identity transform
|
||
*/
|
||
static Transform identity();
|
||
|
||
/**
|
||
* @brief Create translation transform
|
||
* @param translation Translation vector
|
||
* @return Translation transform
|
||
*/
|
||
static Transform translate(const Vec3& translation);
|
||
|
||
/**
|
||
* @brief Create rotation transform
|
||
* @param rotation Rotation (Euler angles in radians)
|
||
* @return Rotation transform
|
||
*/
|
||
static Transform rotate(const Vec3& rotation);
|
||
|
||
/**
|
||
* @brief Create scale transform
|
||
* @param scale Scale factors
|
||
* @return Scale transform
|
||
*/
|
||
static Transform scale(const Vec3& scale);
|
||
|
||
private:
|
||
void mark_dirty();
|
||
void update_matrix() const;
|
||
|
||
Vec3 position_; ///< Translation
|
||
Vec3 rotation_; ///< Rotation (Euler angles)
|
||
Vec3 scale_; ///< Scale factors
|
||
|
||
mutable Mat4 matrix_; ///< Cached transformation matrix
|
||
mutable Mat4 inverse_matrix_; ///< Cached inverse matrix
|
||
mutable bool dirty_; ///< Matrix needs update
|
||
};
|
||
|
||
} // namespace are
|
||
|
||
#endif // ARE_INCLUDE_GEOMETRY_TRANSFORM_H
|
||
```
|
||
|
||
### 文件：include/are/scene/camera.h
|
||
|
||
```cpp
|
||
/**
|
||
* @file camera.h
|
||
* @brief Camera class for view and projection management
|
||
*/
|
||
|
||
#ifndef ARE_INCLUDE_SCENE_CAMERA_H
|
||
#define ARE_INCLUDE_SCENE_CAMERA_H
|
||
|
||
#include <are/core/types.h>
|
||
|
||
namespace are {
|
||
|
||
/**
|
||
* @class Camera
|
||
* @brief Perspective camera for rendering
|
||
*
|
||
* Manages view and projection matrices, and provides ray generation
|
||
* for ray tracing.
|
||
*/
|
||
class Camera {
|
||
public:
|
||
/**
|
||
* @brief Default constructor
|
||
*/
|
||
Camera();
|
||
|
||
/**
|
||
* @brief Construct camera with position and target
|
||
* @param position Camera position
|
||
* @param target Look-at target
|
||
* @param up Up vector
|
||
*/
|
||
Camera(const Vec3& position, const Vec3& target, const Vec3& up = Vec3(0, 1, 0));
|
||
|
||
// Position and orientation setters
|
||
void set_position(const Vec3& position);
|
||
void set_target(const Vec3& target);
|
||
void set_up(const Vec3& up);
|
||
void look_at(const Vec3& position, const Vec3& target, const Vec3& up = Vec3(0, 1, 0));
|
||
|
||
// Projection setters
|
||
void set_fov(Real fov_degrees);
|
||
void set_aspect_ratio(Real aspect);
|
||
void set_near_plane(Real near);
|
||
void set_far_plane(Real far);
|
||
void set_perspective(Real fov_degrees, Real aspect, Real near, Real far);
|
||
|
||
// Getters
|
||
const Vec3& get_position() const { return position_; }
|
||
const Vec3& get_target() const { return target_; }
|
||
const Vec3& get_up() const { return up_; }
|
||
Real get_fov() const { return fov_; }
|
||
Real get_aspect_ratio() const { return aspect_ratio_; }
|
||
Real get_near_plane() const { return near_plane_; }
|
||
Real get_far_plane() const { return far_plane_; }
|
||
|
||
// Direction vectors
|
||
Vec3 get_forward() const;
|
||
Vec3 get_right() const;
|
||
|
||
// Matrix getters
|
||
const Mat4& get_view_matrix() const;
|
||
const Mat4& get_projection_matrix() const;
|
||
Mat4 get_view_projection_matrix() const;
|
||
|
||
/**
|
||
* @brief Generate ray for given pixel coordinates
|
||
* @param u Normalized x coordinate [0, 1]
|
||
* @param v Normalized y coordinate [0, 1]
|
||
* @param origin Output ray origin
|
||
* @param direction Output ray direction (normalized)
|
||
*/
|
||
void generate_ray(Real u, Real v, Vec3& origin, Vec3& direction) const;
|
||
|
||
/**
|
||
* @brief Check if camera parameters have changed
|
||
* @return true if matrices need recalculation
|
||
*/
|
||
bool is_dirty() const { return dirty_; }
|
||
|
||
/**
|
||
* @brief Mark camera as clean after matrix update
|
||
*/
|
||
void clear_dirty() { dirty_ = false; }
|
||
|
||
private:
|
||
void update_view_matrix() const;
|
||
void update_projection_matrix() const;
|
||
|
||
Vec3 position_; ///< Camera position
|
||
Vec3 target_; ///< Look-at target
|
||
Vec3 up_; ///< Up vector
|
||
|
||
Real fov_; ///< Field of view in degrees
|
||
Real aspect_ratio_; ///< Aspect ratio (width/height)
|
||
Real near_plane_; ///< Near clipping plane
|
||
Real far_plane_; ///< Far clipping plane
|
||
|
||
mutable Mat4 view_matrix_; ///< Cached view matrix
|
||
mutable Mat4 projection_matrix_; ///< Cached projection matrix
|
||
mutable bool view_dirty_; ///< View matrix needs update
|
||
mutable bool projection_dirty_; ///< Projection matrix needs update
|
||
bool dirty_; ///< Any parameter changed
|
||
};
|
||
|
||
} // namespace are
|
||
|
||
#endif // ARE_INCLUDE_SCENE_CAMERA_H
|
||
```
|
||
|
||
### 文件：include/are/scene/material.h
|
||
|
||
```cpp
|
||
/**
|
||
* @file material.h
|
||
* @brief PBR material definition
|
||
*/
|
||
|
||
#ifndef ARE_INCLUDE_SCENE_MATERIAL_H
|
||
#define ARE_INCLUDE_SCENE_MATERIAL_H
|
||
|
||
#include <are/core/types.h>
|
||
#include <string>
|
||
|
||
namespace are {
|
||
|
||
/**
|
||
* @class Material
|
||
* @brief Physically-based rendering material
|
||
*
|
||
* Supports standard PBR workflow with metallic-roughness model.
|
||
*/
|
||
class Material {
|
||
public:
|
||
/**
|
||
* @brief Default constructor - creates default white material
|
||
*/
|
||
Material();
|
||
|
||
// Albedo (base color)
|
||
void set_albedo(const Vec3& albedo);
|
||
void set_albedo_map(const std::string& path);
|
||
const Vec3& get_albedo() const { return albedo_; }
|
||
const std::string& get_albedo_map() const { return albedo_map_; }
|
||
bool has_albedo_map() const { return !albedo_map_.empty(); }
|
||
|
||
// Metallic
|
||
void set_metallic(Real metallic);
|
||
void set_metallic_map(const std::string& path);
|
||
Real get_metallic() const { return metallic_; }
|
||
const std::string& get_metallic_map() const { return metallic_map_; }
|
||
bool has_metallic_map() const { return !metallic_map_.empty(); }
|
||
|
||
// Roughness
|
||
void set_roughness(Real roughness);
|
||
void set_roughness_map(const std::string& path);
|
||
Real get_roughness() const { return roughness_; }
|
||
const std::string& get_roughness_map() const { return roughness_map_; }
|
||
bool has_roughness_map() const { return !roughness_map_.empty(); }
|
||
|
||
// Normal map
|
||
void set_normal_map(const std::string& path);
|
||
const std::string& get_normal_map() const { return normal_map_; }
|
||
bool has_normal_map() const { return !normal_map_.empty(); }
|
||
|
||
// Ambient occlusion
|
||
void set_ao_map(const std::string& path);
|
||
const std::string& get_ao_map() const { return ao_map_; }
|
||
bool has_ao_map() const { return !ao_map_.empty(); }
|
||
|
||
// Emissive
|
||
void set_emissive(const Vec3& emissive);
|
||
void set_emissive_map(const std::string& path);
|
||
const Vec3& get_emissive() const { return emissive_; }
|
||
const std::string& get_emissive_map() const { return emissive_map_; }
|
||
bool has_emissive_map() const { return !emissive_map_.empty(); }
|
||
bool is_emissive() const;
|
||
|
||
// Texture handles (set by TextureManager)
|
||
void set_albedo_texture_handle(TextureHandle handle) { albedo_tex_handle_ = handle; }
|
||
void set_metallic_texture_handle(TextureHandle handle) { metallic_tex_handle_ = handle; }
|
||
void set_roughness_texture_handle(TextureHandle handle) { roughness_tex_handle_ = handle; }
|
||
void set_normal_texture_handle(TextureHandle handle) { normal_tex_handle_ = handle; }
|
||
void set_ao_texture_handle(TextureHandle handle) { ao_tex_handle_ = handle; }
|
||
void set_emissive_texture_handle(TextureHandle handle) { emissive_tex_handle_ = handle; }
|
||
|
||
TextureHandle get_albedo_texture_handle() const { return albedo_tex_handle_; }
|
||
TextureHandle get_metallic_texture_handle() const { return metallic_tex_handle_; }
|
||
TextureHandle get_roughness_texture_handle() const { return roughness_tex_handle_; }
|
||
TextureHandle get_normal_texture_handle() const { return normal_tex_handle_; }
|
||
TextureHandle get_ao_texture_handle() const { return ao_tex_handle_; }
|
||
TextureHandle get_emissive_texture_handle() const { return emissive_tex_handle_; }
|
||
|
||
private:
|
||
// Base values
|
||
Vec3 albedo_;///< Base color (RGB)
|
||
Real metallic_; ///< Metallic factor [0, 1]
|
||
Real roughness_; ///< Roughness factor [0, 1]
|
||
Vec3 emissive_; ///< Emissive color (RGB)
|
||
|
||
// Texture paths
|
||
std::string albedo_map_;
|
||
std::string metallic_map_;
|
||
std::string roughness_map_;
|
||
std::string normal_map_;
|
||
std::string ao_map_;
|
||
std::string emissive_map_;
|
||
|
||
// Texture handles (GPU resources)
|
||
TextureHandle albedo_tex_handle_;
|
||
TextureHandle metallic_tex_handle_;
|
||
TextureHandle roughness_tex_handle_;
|
||
TextureHandle normal_tex_handle_;
|
||
TextureHandle ao_tex_handle_;
|
||
TextureHandle emissive_tex_handle_;
|
||
};
|
||
|
||
} // namespace are
|
||
|
||
#endif // ARE_INCLUDE_SCENE_MATERIAL_H
|
||
```
|
||
|
||
### 文件：include/are/scene/mesh.h
|
||
|
||
```cpp
|
||
/**
|
||
* @file mesh.h
|
||
* @brief Mesh class for geometry storage
|
||
*/
|
||
|
||
#ifndef ARE_INCLUDE_SCENE_MESH_H
|
||
#define ARE_INCLUDE_SCENE_MESH_H
|
||
|
||
#include <are/core/types.h>
|
||
#include <are/geometry/vertex.h>
|
||
#include <are/geometry/aabb.h>
|
||
#include <vector>
|
||
|
||
namespace are {
|
||
|
||
/**
|
||
* @class Mesh
|
||
* @brief Triangle mesh container
|
||
*
|
||
* Stores vertex and index data for a triangle mesh.
|
||
* Supports automatic AABB computation.
|
||
*/
|
||
class Mesh {
|
||
public:
|
||
/**
|
||
* @brief Default constructor - creates empty mesh
|
||
*/
|
||
Mesh();
|
||
|
||
/**
|
||
* @brief Construct mesh from vertex and index data
|
||
* @param vertices Vertex array
|
||
* @param indices Index array (triangles)
|
||
* @param material_id Material handle
|
||
*/
|
||
Mesh(const std::vector<Vertex>& vertices,
|
||
const std::vector<uint32_t>& indices,
|
||
MaterialHandle material_id = are_invalid_handle);
|
||
|
||
/**
|
||
* @brief Construct mesh from raw arrays
|
||
* @param vertices Vertex array pointer
|
||
* @param vertex_count Number of vertices
|
||
* @param indices Index array pointer
|
||
* @param index_count Number of indices
|
||
* @param material_id Material handle
|
||
*/
|
||
Mesh(const Vertex* vertices, size_t vertex_count,
|
||
const uint32_t* indices, size_t index_count,
|
||
MaterialHandle material_id = are_invalid_handle);
|
||
|
||
// Data setters
|
||
void set_vertices(const std::vector<Vertex>& vertices);
|
||
void set_indices(const std::vector<uint32_t>& indices);
|
||
void set_material(MaterialHandle material_id);
|
||
|
||
// Data getters
|
||
const std::vector<Vertex>& get_vertices() const { return vertices_; }
|
||
const std::vector<uint32_t>& get_indices() const { return indices_; }
|
||
MaterialHandle get_material() const { return material_id_; }
|
||
|
||
// Geometry queries
|
||
size_t get_vertex_count() const { return vertices_.size(); }
|
||
size_t get_index_count() const { return indices_.size(); }
|
||
size_t get_triangle_count() const { return indices_.size() / 3; }
|
||
bool is_empty() const { return vertices_.empty() || indices_.empty(); }
|
||
|
||
// AABB
|
||
const AABB& get_aabb() const { return aabb_; }
|
||
void compute_aabb();
|
||
|
||
/**
|
||
* @brief Compute tangent vectors for normal mapping
|
||
*/
|
||
void compute_tangents();/**
|
||
* @brief Get triangle vertices by index
|
||
* @param triangle_index Triangle index
|
||
* @param v0 Output first vertex
|
||
* @param v1 Output second vertex
|
||
* @param v2 Output third vertex
|
||
* @return true if triangle exists
|
||
*/
|
||
bool get_triangle(size_t triangle_index, Vertex& v0, Vertex& v1, Vertex& v2) const;
|
||
|
||
// GPU resource handles (set by Renderer)
|
||
void set_vao(uint32_t vao) { vao_ = vao; }
|
||
void set_vbo(uint32_t vbo) { vbo_ = vbo; }
|
||
void set_ebo(uint32_t ebo) { ebo_ = ebo; }
|
||
uint32_t get_vao() const { return vao_; }
|
||
uint32_t get_vbo() const { return vbo_; }
|
||
uint32_t get_ebo() const { return ebo_; }
|
||
bool has_gpu_resources() const { return vao_ != 0; }
|
||
|
||
private:
|
||
std::vector<Vertex> vertices_; ///< Vertex data
|
||
std::vector<uint32_t> indices_; ///< Index data (triangles)
|
||
MaterialHandle material_id_; ///< Associated material
|
||
AABB aabb_; ///< Bounding box
|
||
|
||
// GPU resources
|
||
uint32_t vao_; ///< Vertex Array Object
|
||
uint32_t vbo_; ///< Vertex Buffer Object
|
||
uint32_t ebo_; ///< Element Buffer Object
|
||
};
|
||
|
||
} // namespace are
|
||
|
||
#endif // ARE_INCLUDE_SCENE_MESH_H
|
||
```
|
||
|
||
### 文件：include/are/scene/light.h
|
||
|
||
```cpp
|
||
/**
|
||
* @file light.h
|
||
* @brief Base light class and common light utilities
|
||
*/
|
||
|
||
#ifndef ARE_INCLUDE_SCENE_LIGHT_H
|
||
#define ARE_INCLUDE_SCENE_LIGHT_H
|
||
|
||
#include <are/core/types.h>
|
||
|
||
namespace are {
|
||
|
||
/**
|
||
* @enum LightType
|
||
* @brief Types of light sources
|
||
*/
|
||
enum class LightType {
|
||
ARE_LIGHT_DIRECTIONAL,
|
||
ARE_LIGHT_POINT,
|
||
ARE_LIGHT_SPOT
|
||
};
|
||
|
||
/**
|
||
* @struct LightData
|
||
* @brief Packed light data for GPU transfer
|
||
*
|
||
* This structure is designed to be efficiently transferred to GPU
|
||
* via SSBO or UBO.
|
||
*/
|
||
struct LightData {
|
||
Vec4 position_type_; ///< xyz: position, w: light type
|
||
Vec4 direction_range_; ///< xyz: direction, w: range
|
||
Vec4 color_intensity_; ///< xyz: color, w: intensity
|
||
Vec4 params_; ///< Light-specific parameters
|
||
};
|
||
|
||
/**
|
||
* @class Light
|
||
* @brief Base class for all light types
|
||
*/
|
||
class Light {
|
||
public:
|
||
/**
|
||
* @brief Constructor
|
||
* @param type Light type
|
||
*/
|
||
explicit Light(LightType type);
|
||
|
||
virtual ~Light() = default;
|
||
|
||
// Common properties
|
||
void set_color(const Vec3& color);
|
||
void set_intensity(Real intensity);
|
||
void set_cast_shadows(bool cast);
|
||
|
||
const Vec3& get_color() const { return color_; }
|
||
Real get_intensity() const { return intensity_; }
|
||
bool get_cast_shadows() const { return cast_shadows_; }
|
||
LightType get_type() const { return type_; }
|
||
|
||
/**
|
||
* @brief Pack light data for GPU transfer
|
||
* @return Packed light data
|
||
*/
|
||
virtual LightData pack() const = 0;
|
||
|
||
/**
|
||
* @brief Check if light affects a point
|
||
* @param point World position
|
||
* @return true if light can affect the point
|
||
*/
|
||
virtual bool affects_point(const Vec3& point) const = 0;
|
||
|
||
protected:
|
||
LightType type_; ///< Light type
|
||
Vec3 color_; ///< Light color (RGB)
|
||
Real intensity_; ///< Light intensity
|
||
bool cast_shadows_; ///< Whether light casts shadows
|
||
};
|
||
|
||
} // namespace are
|
||
|
||
#endif // ARE_INCLUDE_SCENE_LIGHT_H
|
||
```
|
||
|
||
### 文件：include/are/scene/directional_light.h
|
||
|
||
```cpp
|
||
/**
|
||
* @file directional_light.h
|
||
* @brief Directional light implementation
|
||
*/
|
||
|
||
#ifndef ARE_INCLUDE_SCENE_DIRECTIONAL_LIGHT_H
|
||
#define ARE_INCLUDE_SCENE_DIRECTIONAL_LIGHT_H
|
||
|
||
#include <are/scene/light.h>
|
||
|
||
namespace are {
|
||
|
||
/**
|
||
* @class DirectionalLight
|
||
* @brief Directional light source (sun-like)
|
||
*
|
||
* Represents an infinitely distant light source with parallel rays.
|
||
*/
|
||
class DirectionalLight : public Light {
|
||
public:
|
||
/**
|
||
* @brief Default constructor
|
||
*/
|
||
DirectionalLight();
|
||
|
||
/**
|
||
* @brief Construct with direction and color
|
||
* @param direction Light direction (will be normalized)
|
||
* @param color Light color
|
||
* @param intensity Light intensity
|
||
*/
|
||
DirectionalLight(const Vec3& direction, const Vec3& color = Vec3(1.0f),
|
||
Real intensity = 1.0f);
|
||
|
||
// Direction
|
||
void set_direction(const Vec3& direction);
|
||
const Vec3& get_direction() const { return direction_; }
|
||
|
||
// Light interface
|
||
LightData pack() const override;
|
||
bool affects_point(const Vec3& point) const override;
|
||
|
||
private:
|
||
Vec3 direction_; ///< Light direction (normalized)
|
||
};
|
||
|
||
} // namespace are
|
||
|
||
#endif // ARE_INCLUDE_SCENE_DIRECTIONAL_LIGHT_H
|
||
```
|
||
|
||
### 文件：include/are/scene/point_light.h
|
||
|
||
```cpp
|
||
/**
|
||
* @file point_light.h
|
||
* @brief Point light implementation
|
||
*/
|
||
|
||
#ifndef ARE_INCLUDE_SCENE_POINT_LIGHT_H
|
||
#define ARE_INCLUDE_SCENE_POINT_LIGHT_H
|
||
|
||
#include <are/scene/light.h>
|
||
|
||
namespace are {
|
||
|
||
/**
|
||
* @class PointLight
|
||
* @brief Point light source
|
||
*
|
||
* Emits light equally in all directions from a single point.
|
||
*/
|
||
class PointLight : public Light {
|
||
public:
|
||
/**
|
||
* @brief Default constructor
|
||
*/
|
||
PointLight();
|
||
|
||
/**
|
||
* @brief Construct with position and color
|
||
* @param position Light position
|
||
* @param color Light color
|
||
* @param intensity Light intensity
|
||
* @param range Light range (attenuation distance)
|
||
*/
|
||
PointLight(const Vec3& position, const Vec3& color = Vec3(1.0f),
|
||
Real intensity = 1.0f, Real range = 10.0f);
|
||
|
||
// Position
|
||
void set_position(const Vec3& position);
|
||
const Vec3& get_position() const { return position_; }
|
||
|
||
// Range (attenuation)
|
||
void set_range(Real range);
|
||
Real get_range() const { return range_; }
|
||
|
||
// Attenuation parameters
|
||
void set_attenuation(Real constant, Real linear, Real quadratic);
|
||
Real get_constant_attenuation() const { return attenuation_constant_; }
|
||
Real get_linear_attenuation() const { return attenuation_linear_; }
|
||
Real get_quadratic_attenuation() const { return attenuation_quadratic_; }
|
||
|
||
/**
|
||
* @brief Calculate attenuation at given distance
|
||
* @param distance Distance from light
|
||
* @return Attenuation factor [0, 1]
|
||
*/
|
||
Real calculate_attenuation(Real distance) const;
|
||
|
||
// Light interface
|
||
LightData pack() const override;
|
||
bool affects_point(const Vec3& point) const override;
|
||
|
||
private:
|
||
Vec3 position_; ///< Light position
|
||
Real range_; ///< Light range
|
||
Real attenuation_constant_; ///< Constant attenuation factor
|
||
Real attenuation_linear_; ///< Linear attenuation factor
|
||
Real attenuation_quadratic_; ///< Quadratic attenuation factor
|
||
};
|
||
|
||
} // namespace are
|
||
|
||
#endif // ARE_INCLUDE_SCENE_POINT_LIGHT_H
|
||
```
|
||
|
||
### 文件：include/are/scene/spot_light.h
|
||
|
||
```cpp
|
||
/**
|
||
* @file spot_light.h
|
||
* @brief Spot light implementation
|
||
*/
|
||
|
||
#ifndef ARE_INCLUDE_SCENE_SPOT_LIGHT_H
|
||
#define ARE_INCLUDE_SCENE_SPOT_LIGHT_H
|
||
|
||
#include <are/scene/light.h>
|
||
|
||
namespace are {
|
||
|
||
/**
|
||
* @class SpotLight
|
||
* @brief Spot light source
|
||
*
|
||
* Emits light in a cone from a single point.
|
||
*/
|
||
class SpotLight : public Light {
|
||
public:
|
||
/**
|
||
* @brief Default constructor
|
||
*/
|
||
SpotLight();
|
||
|
||
/**
|
||
* @brief Construct with position, direction, and angles
|
||
* @param position Light position
|
||
* @param direction Light direction
|
||
* @param inner_angle Inner cone angle in degrees
|
||
* @param outer_angle Outer cone angle in degrees
|
||
* @param color Light color
|
||
* @param intensity Light intensity
|
||
*/
|
||
SpotLight(const Vec3& position, const Vec3& direction,Real inner_angle, Real outer_angle,
|
||
const Vec3& color = Vec3(1.0f), Real intensity = 1.0f);
|
||
|
||
// Position and direction
|
||
void set_position(const Vec3& position);
|
||
void set_direction(const Vec3& direction);
|
||
const Vec3& get_position() const { return position_; }
|
||
const Vec3& get_direction() const { return direction_; }
|
||
|
||
// Cone angles (in degrees)
|
||
void set_inner_angle(Real angle);
|
||
void set_outer_angle(Real angle);
|
||
Real get_inner_angle() const { return inner_angle_; }
|
||
Real get_outer_angle() const { return outer_angle_; }
|
||
|
||
// Range
|
||
void set_range(Real range);
|
||
Real get_range() const { return range_; }
|
||
|
||
/**
|
||
* @brief Calculate spotlight intensity at given direction
|
||
* @param to_point Direction from light to point (normalized)
|
||
* @return Spotlight factor [0, 1]
|
||
*/
|
||
Real calculate_spot_factor(const Vec3& to_point) const;
|
||
|
||
// Light interface
|
||
LightData pack() const override;
|
||
bool affects_point(const Vec3& point) const override;
|
||
|
||
private:
|
||
Vec3 position_; ///< Light position
|
||
Vec3 direction_; ///< Light direction (normalized)
|
||
Real inner_angle_; ///< Inner cone angle (degrees)
|
||
Real outer_angle_; ///< Outer cone angle (degrees)
|
||
Real range_; ///< Light range
|
||
Real cos_inner_; ///< Cosine of inner angle (cache
|
||
Real cos_outer_; ///< Cosine of outer angle (cached)
|
||
};
|
||
|
||
} // namespace are
|
||
|
||
#endif // ARE_INCLUDE_SCENE_SPOT_LIGHT_H
|
||
```
|
||
|
||
### 文件：include/are/scene/scene_manager.h
|
||
|
||
```cpp
|
||
/**
|
||
* @file scene_manager.h
|
||
* @brief Scene data management
|
||
*/
|
||
|
||
#ifndef ARE_INCLUDE_SCENE_SCENE_MANAGER_H
|
||
#define ARE_INCLUDE_SCENE_SCENE_MANAGER_H
|
||
|
||
#include <are/core/types.h>
|
||
#include <are/scene/mesh.h>
|
||
#include <are/scene/material.h>
|
||
#include <are/scene/light.h>
|
||
#include <vector>
|
||
#include <memory>
|
||
#include <unordered_map>
|
||
|
||
namespace are {
|
||
|
||
/**
|
||
* @class SceneManager
|
||
* @brief Manages all scene objects (meshes, materials, lights)
|
||
*
|
||
* Provides handle-based access to scene resources and tracks
|
||
* scene modifications for BVH rebuilding.
|
||
*/
|
||
class SceneManager {
|
||
public:
|
||
/**
|
||
* @brief Constructor
|
||
*/
|
||
SceneManager();
|
||
|
||
/**
|
||
* @brief Destructor
|
||
*/
|
||
~SceneManager();
|
||
|
||
// Mesh management
|
||
MeshHandle add_mesh(const Mesh& mesh);
|
||
void remove_mesh(MeshHandle handle);
|
||
void update_mesh(MeshHandle handle, const Mesh& mesh);
|
||
Mesh* get_mesh(MeshHandle handle);
|
||
const Mesh* get_mesh(MeshHandle handle) const;
|
||
const std::vector<Mesh>& get_all_meshes() const { return meshes_; }
|
||
|
||
// Material management
|
||
MaterialHandle add_material(const Material& material);
|
||
void remove_material(MaterialHandle handle);
|
||
void update_material(MaterialHandle handle, const Material& material);
|
||
Material* get_material(MaterialHandle handle);
|
||
const Material* get_material(MaterialHandle handle) const;
|
||
const std::vector<Material>& get_all_materials() const { return materials_; }
|
||
|
||
// Light management
|
||
LightHandle add_light(const std::shared_ptr<Light>& light);
|
||
void remove_light(LightHandle handle);
|
||
std::shared_ptr<Light> get_light(LightHandle handle);
|
||
const std::vector<std::shared_ptr<Light>>& get_all_lights() const { return lights_; }
|
||
|
||
// Scene queries
|
||
size_t get_mesh_count() const { return meshes_.size(); }
|
||
size_t get_material_count() const { return materials_.size(); }
|
||
size_t get_light_count() const { return lights_.size(); }
|
||
size_t get_total_triangle_count() const;
|
||
|
||
// Scene state
|
||
bool is_dirty() const { return dirty_; }
|
||
void mark_dirty() { dirty_ = true; }
|
||
void clear_dirty() { dirty_ = false; }
|
||
|
||
/**
|
||
* @brief Clear all scene data
|
||
*/
|
||
void clear();
|
||
|
||
/**
|
||
* @brief Validate all handles and remove invalid entries
|
||
*/
|
||
void compact();
|
||
|
||
private:
|
||
std::vector<Mesh> meshes_; ///< Mesh storage
|
||
std::vector<Material> materials_; ///< Material storage
|
||
std::vector<std::shared_ptr<Light>> lights_; ///< Light storage
|
||
|
||
std::unordered_map<MeshHandle, size_t> mesh_handle_map_;
|
||
std::unordered_map<MaterialHandle, size_t> material_handle_map_;
|
||
std::unordered_map<LightHandle, size_t> light_handle_map_;
|
||
|
||
MeshHandle next_mesh_handle_;
|
||
MaterialHandle next_material_handle_;
|
||
LightHandle next_light_handle_;
|
||
|
||
bool dirty_; ///< Scene modified flag
|
||
};
|
||
|
||
} // namespace are
|
||
|
||
#endif // ARE_INCLUDE_SCENE_SCENE_MANAGER_H
|
||
```
|
||
|
||
### 文件：include/are/renderer/renderer.h
|
||
|
||
```cpp
|
||
/**
|
||
* @file renderer.h
|
||
* @brief Main renderer interface
|
||
*/
|
||
|
||
#ifndef ARE_INCLUDE_RENDERER_RENDERER_H
|
||
#define ARE_INCLUDE_RENDERER_RENDERER_H
|
||
|
||
#include <are/core/config.h>
|
||
#include <are/core/types.h>
|
||
#include <are/scene/camera.h>
|
||
#include <are/scene/mesh.h>
|
||
#include <are/scene/material.h>
|
||
#include <are/scene/light.h>
|
||
#include <are/renderer/render_stats.h>
|
||
#include <memory>
|
||
#include <vector>
|
||
|
||
namespace are {
|
||
|
||
// Forward declarations
|
||
class Window;
|
||
class SceneManager;
|
||
class Rasterizer;
|
||
class RayTracer;
|
||
class TextureManager;
|
||
|
||
/**
|
||
* @class Renderer
|
||
* @brief Main rendering interface for Aurora Rendering Engine
|
||
*
|
||
* This class provides the primary API for rendering scenes using
|
||
* hybrid rasterization and ray tracing techniques.
|
||
*/
|
||
class Renderer {
|
||
public:
|
||
/**
|
||
* @brief Constructor
|
||
* @param config Rendering configuration
|
||
*/
|
||
explicit Renderer(const AreConfig& config);
|
||
|
||
/**
|
||
* @brief Destructor
|
||
*/
|
||
~Renderer();
|
||
|
||
// Configuration
|
||
void set_config(const AreConfig& config);
|
||
const AreConfig& get_config() const;
|
||
|
||
// Camera management
|
||
void set_camera(const Camera& camera);
|
||
Camera& get_camera();
|
||
const Camera& get_camera() const;
|
||
|
||
// Scene management
|
||
MeshHandle add_mesh(const Mesh& mesh);
|
||
MaterialHandle add_material(const Material& material);
|
||
LightHandle add_light(const std::shared_ptr<Light>& light);
|
||
|
||
void remove_mesh(MeshHandle handle);
|
||
void remove_material(MaterialHandle handle);
|
||
void remove_light(LightHandle handle);
|
||
|
||
void update_mesh(MeshHandle handle, const Mesh& mesh);
|
||
void update_material(MaterialHandle handle, const Material& material);
|
||
|
||
void clear_scene();
|
||
|
||
// Ray tracing backend control
|
||
void set_ray_tracing_backend(RayTracingBackend backend);
|
||
RayTracingBackend get_ray_tracing_backend() const;
|
||
|
||
// Rendering
|
||
void begin_frame();
|
||
void render();
|
||
void end_frame();
|
||
void present();
|
||
|
||
// Frame capture
|
||
void capture_frame_ldr(uint8_t** pixels, int* width, int* height);
|
||
void capture_frame_hdr(float** pixels, int* width, int* height);
|
||
void save_frame(const std::string& filename, const uint8_t* pixels,
|
||
int width, int height);
|
||
|
||
// Window control
|
||
bool should_close() const;
|
||
void set_should_close(bool should_close);
|
||
|
||
// Statistics
|
||
const RenderStats& get_stats() const;
|
||
void reset_stats();
|
||
|
||
// Debug visualization
|
||
void set_gbuffer_visualization_mode(GBufferVisualizationMode mode);
|
||
GBufferVisualizationMode get_gbuffer_visualization_mode() const;
|
||
|
||
private:
|
||
void initialize_subsystems();
|
||
void shutdown_subsystems();
|
||
void rebuild_bvh_if_needed();
|
||
void check_scene_dirty();
|
||
|
||
AreConfig config_; ///< Current configuration
|
||
|
||
std::unique_ptr<Window> window_; ///< Window management
|
||
std::unique_ptr<SceneManager> scene_manager_; ///< Scene data management
|
||
std::unique_ptr<Rasterizer> rasterizer_; ///< Rasterization pipeline
|
||
std::unique_ptr<RayTracer> raytracer_; ///< Ray tracing pipeline
|
||
std::unique_ptr<TextureManager> texture_manager_; ///< Texture management
|
||
|
||
Camera camera_; ///< Active camera
|
||
RenderStats stats_; ///< Rendering statistics
|
||
|
||
bool scene_dirty_; ///< Scene needs BVH rebuild
|
||
bool initialized_; ///< Initialization flag
|
||
};
|
||
|
||
} // namespace are
|
||
|
||
#endif // ARE_INCLUDE_RENDERER_RENDERER_H
|
||
```
|
||
|
||
### 文件：include/are/renderer/render_stats.h
|
||
|
||
```cpp
|
||
/**
|
||
* @file render_stats.h
|
||
* @brief Rendering statistics tracking
|
||
*/
|
||
|
||
#ifndef ARE_INCLUDE_RENDERER_RENDER_STATS_H
|
||
#define ARE_INCLUDE_RENDERER_RENDER_STATS_H
|
||
|
||
#include <are/core/types.h>
|
||
#include <cstdint>
|
||
|
||
namespace are {
|
||
|
||
/**
|
||
* @struct RenderStats
|
||
* @brief Statistics for rendering performance analysis
|
||
*/
|
||
struct RenderStats {
|
||
// Frame timing
|
||
double frame_time_ms_; ///< Total frame time in milliseconds
|
||
double rasterization_time_ms_; ///< Rasterization time
|
||
double ray_tracing_time_ms_; ///< Ray tracing time
|
||
double bvh_build_time_ms_; ///< BVH construction time
|
||
double present_time_ms_; ///< Present/swap time
|
||
|
||
// Scene statistics
|
||
uint32_t mesh_count_; ///< Number of meshes
|
||
uint32_t triangle_count_; ///< Total triangle count
|
||
uint32_t light_count_; ///< Number of lights
|
||
uint32_t material_count_; ///< Number of materials
|
||
|
||
// Ray tracing statistics
|
||
uint64_t primary_rays_; ///< Number of primary rays
|
||
uint64_t secondary_rays_; ///< Number of secondary rays
|
||
uint64_t shadow_rays_; ///< Number of shadow rays
|
||
uint64_t bvh_traversals_; ///< BVH traversal count
|
||
uint64_t triangle_tests_; ///< Triangle intersection tests
|
||
|
||
// Memory statistics
|
||
size_t vertex_memory_bytes_; ///< Vertex buffer memory
|
||
size_t index_memory_bytes_; ///< Index buffer memory
|
||
size_t texture_memory_bytes_; ///< Texture memory
|
||
size_t bvh_memory_bytes_; ///< BVH memory
|
||
|
||
// FPS
|
||
double fps_; ///< Frames per second
|
||
|
||
/**
|
||
* @brief Reset all statistics to zero
|
||
*/
|
||
void reset();
|
||
|
||
/**
|
||
* @brief Print statistics to console
|
||
*/
|
||
void print() const;
|
||
|
||
/**
|
||
* @brief Update FPS based on frame time
|
||
*/
|
||
void update_fps();
|
||
};
|
||
|
||
} // namespace are
|
||
|
||
#endif // ARE_INCLUDE_RENDERER_RENDER_STATS_H
|
||
```
|
||
|
||
### 文件：include/are/renderer/render_context.h
|
||
|
||
```cpp
|
||
/**
|
||
* @file render_context.h
|
||
* @brief Rendering context and state management
|
||
*/
|
||
|
||
#ifndef ARE_INCLUDE_RENDERER_RENDER_CONTEXT_H
|
||
#define ARE_INCLUDE_RENDERER_RENDER_CONTEXT_H
|
||
|
||
#include <are/core/types.h>
|
||
#include <are/core/config.h>
|
||
|
||
namespace are {
|
||
|
||
/**
|
||
* @struct RenderContext
|
||
* @brief Rendering context information
|
||
*
|
||
* Contains current rendering state and frame information.
|
||
*/
|
||
struct RenderContext {
|
||
int frame_number_; ///< Current frame number
|
||
double time_; ///< Total elapsed time in seconds
|
||
double delta_time_; ///< Time since last frame
|
||
|
||
int viewport_width_; ///< Viewport width
|
||
int viewport_height_; ///< Viewport height
|
||
|
||
RayTracingBackend current_backend_; ///< Current ray tracing backend
|
||
bool scene_dirty_; ///< Scene needs BVH rebuild
|
||
bool camera_moved_; ///< Camera moved this frame
|
||
|
||
/**
|
||
* @brief Constructor
|
||
*/
|
||
RenderContext();
|
||
|
||
/**
|
||
* @brief Reset context
|
||
*/
|
||
void reset();
|
||
|
||
/**
|
||
* @brief Update frame timing
|
||
* @param current_time Current time in seconds
|
||
*/
|
||
void update_timing(double current_time);
|
||
};
|
||
|
||
} // namespace are
|
||
|
||
#endif // ARE_INCLUDE_RENDERER_RENDER_CONTEXT_H
|
||
```
|
||
|
||
### 文件：include/are/raytracer/ray.h
|
||
|
||
```cpp
|
||
/**
|
||
* @file ray.h
|
||
* @brief Ray structure for ray tracing
|
||
*/
|
||
|
||
#ifndef ARE_INCLUDE_RAYTRACER_RAY_H
|
||
#define ARE_INCLUDE_RAYTRACER_RAY_H
|
||
|
||
#include <are/core/types.h>
|
||
|
||
namespace are {
|
||
|
||
/**
|
||
* @struct Ray
|
||
* @brief Ray representation for ray tracing
|
||
*/
|
||
struct Ray {
|
||
Vec3 origin_; ///< Ray origin
|
||
Vec3 direction_; ///< Ray direction (normalized)
|
||
Real t_min_; ///< Minimum t value
|
||
Real t_max_; ///< Maximum t value
|
||
|
||
/**
|
||
* @brief Default constructor
|
||
*/
|
||
Ray();
|
||
|
||
/**
|
||
* @brief Construct ray with origin and direction
|
||
* @param origin Ray origin
|
||
* @param direction Ray direction (will be normalized)
|
||
* @param t_min Minimum t value
|
||
* @param t_max Maximum t value
|
||
*/
|
||
Ray(const Vec3& origin, const Vec3& direction,
|
||
Real t_min = are_epsilon, Real t_max = 1e30f);
|
||
|
||
/**
|
||
* @brief Evaluate ray at parameter t
|
||
* @param t Parameter value
|
||
* @return Point on ray
|
||
*/
|
||
Vec3 at(Real t) const;
|
||
|
||
/**
|
||
* @brief Check if t is within valid range
|
||
* @param t Parameter value
|
||
* @return true if t is valid
|
||
*/
|
||
bool is_valid_t(Real t) const;
|
||
};
|
||
|
||
} // namespace are
|
||
|
||
#endif // ARE_INCLUDE_RAYTRACER_RAY_H
|
||
```
|
||
|
||
### 文件：include/are/raytracer/hit_record.h
|
||
|
||
```cpp
|
||
/**
|
||
* @file hit_record.h
|
||
* @brief Ray-surface intersection record
|
||
*/
|
||
|
||
#ifndef ARE_INCLUDE_RAYTRACER_HIT_RECORD_H
|
||
#define ARE_INCLUDE_RAYTRACER_HIT_RECORD_H
|
||
|
||
#include <are/core/types.h>
|
||
|
||
namespace are {
|
||
|
||
/**
|
||
* @struct HitRecord
|
||
* @brief Information about ray-surface intersection
|
||
*/
|
||
struct HitRecord {
|
||
Vec3 position_; ///< Hit position in world space
|
||
Vec3 normal_; ///< Surface normal at hit point
|
||
Vec2 texcoord_; ///< Texture coordinates at hit point
|
||
Vec3 tangent_; ///< Tangent vector at hit point
|
||
Real t_; ///< Ray parameter at hit point
|
||
MaterialHandle material_; ///< Material at hit point
|
||
uint32_t triangle_index_; ///< Triangle index that was hit
|
||
bool front_face_; ///< Whether ray hit front face
|
||
|
||
/**
|
||
* @brief Default constructor
|
||
*/
|
||
HitRecord();
|
||
|
||
/**
|
||
* @brief Set face normal based on ray direction
|
||
* @param ray_direction Ray direction
|
||
* @param outward_normal Outward-facing normal
|
||
*/
|
||
void set_face_normal(const Vec3& ray_direction, const Vec3& outward_normal);
|
||
|
||
/**
|
||
* @brief Check if hit record is valid
|
||
* @return true if hit occurred
|
||
*/
|
||
bool is_valid() const;
|
||
};
|
||
|
||
} // namespace are
|
||
|
||
#endif // ARE_INCLUDE_RAYTRACER_HIT_RECORD_H
|
||
```
|
||
|
||
### 文件：include/are/raytracer/raytracer.h
|
||
|
||
```cpp
|
||
/**
|
||
* @file raytracer.h
|
||
* @brief Ray tracing interface
|
||
*/
|
||
|
||
#ifndef ARE_INCLUDE_RAYTRACER_RAYTRACER_H
|
||
#define ARE_INCLUDE_RAYTRACER_RAYTRACER_H
|
||
|
||
#include <are/core/types.h>
|
||
#include <are/core/config.h>
|
||
|
||
namespace are {
|
||
|
||
// Forward declarations
|
||
class SceneManager;
|
||
class Camera;
|
||
class GBuffer;
|
||
class BVH;
|
||
|
||
/**
|
||
* @class RayTracer
|
||
* @brief Abstract ray tracing interface
|
||
*
|
||
* Base class for CPU and GPU ray tracing implementations.
|
||
*/
|
||
class RayTracer {
|
||
public:
|
||
/**
|
||
* @brief Constructor
|
||
* @param config Ray tracing configuration
|
||
*/
|
||
explicit RayTracer(const RayTracingConfig& config);
|
||
|
||
/**
|
||
* @brief Virtual destructor
|
||
*/
|
||
virtual ~RayTracer() = default;
|
||
|
||
/**
|
||
* @brief Render scene using ray tracing
|
||
* @param scene Scene manager
|
||
* @param camera Camera
|
||
* @param gbuffer G-Buffer (optional, for hybrid rendering)
|
||
* @param output Output texture ID
|
||
*/
|
||
virtual void render(const SceneManager& scene,
|
||
const Camera& camera,
|
||
const GBuffer* gbuffer,
|
||
uint32_t output_texture) = 0;
|
||
|
||
/**
|
||
* @brief Update BVH
|
||
* @param bvh BVH reference
|
||
*/
|
||
virtual void update_bvh(const BVH& bvh) = 0;
|
||
|
||
/**
|
||
* @brief Set configuration
|
||
* @param config New configuration
|
||
*/
|
||
virtual void set_config(const RayTracingConfig& config);
|
||
|
||
/**
|
||
* @brief Get configuration
|
||
* @return Current configuration
|
||
*/
|
||
const RayTracingConfig& get_config() const { return config_; }
|
||
|
||
protected:
|
||
RayTracingConfig config_; ///< Ray tracing configuration
|
||
};
|
||
|
||
} // namespace are
|
||
|
||
#endif // ARE_INCLUDE_RAYTRACER_RAYTRACER_H
|
||
```
|
||
|
||
### 文件：include/are/raytracer/cpu_raytracer.h
|
||
|
||
```cpp
|
||
/**
|
||
* @file cpu_raytracer.h
|
||
* @brief CPU-based ray tracing implementation
|
||
*/
|
||
|
||
#ifndef ARE_INCLUDE_RAYTRACER_CPU_RAYTRACER_H
|
||
#define ARE_INCLUDE_RAYTRACER_CPU_RAYTRACER_H
|
||
|
||
#include <are/raytracer/raytracer.h>
|
||
#include <are/raytracer/ray.h>
|
||
#include <are/raytracer/hit_record.h>
|
||
#include <vector>
|
||
|
||
namespace are {
|
||
|
||
/**
|
||
* @class CPURayTracer
|
||
* @brief CPU-based ray tracing implementation
|
||
*
|
||
* Uses multithreading for parallel ray tracing on CPU.
|
||
*/
|
||
class CPURayTracer : public RayTracer {
|
||
public:
|
||
/**
|
||
* @brief Constructor
|
||
* @param config Ray tracing configuration
|
||
*/
|
||
explicit CPURayTracer(const RayTracingConfig& config);
|
||
|
||
/**
|
||
* @brief Destructor
|
||
*/
|
||
~CPURayTracer() override;
|
||
|
||
/**
|
||
* @brief Render scene using CPU ray tracing
|
||
* @param scene Scene manager
|
||
* @param camera Camera
|
||
* @param gbuffer G-Buffer (optional)
|
||
* @param output Output texture ID
|
||
*/
|
||
void render(const SceneManager& scene,
|
||
const Camera& camera,
|
||
const GBuffer* gbuffer,
|
||
uint32_t output_texture) override;
|
||
|
||
/**
|
||
* @brief Update BVH
|
||
* @param bvh BVH reference
|
||
*/
|
||
void update_bvh(const BVH& bvh) override;
|
||
|
||
private:
|
||
/**
|
||
* @brief Trace a single ray
|
||
* @param ray Ray to trace
|
||
* @param depth Current recursion depth
|
||
* @return Ray color
|
||
*/
|
||
Vec3 trace_ray(const Ray& ray, int depth);
|
||
|
||
/**
|
||
* @brief Shade hit point
|
||
* @param hit Hit record
|
||
* @param ray Incident ray
|
||
* @param depth Current recursion depth
|
||
* @return Shaded color
|
||
*/
|
||
Vec3 shade(const HitRecord& hit, const Ray& ray, int depth);
|
||
|
||
/**
|
||
* @brief Compute direct lighting
|
||
* @param hit Hit record
|
||
* @return Direct lighting contribution
|
||
*/
|
||
Vec3 compute_direct_lighting(const HitRecord& hit);
|
||
|
||
/**
|
||
* @brief Compute ambient occlusion
|
||
* @param hit Hit record
|
||
* @return AO factor [0, 1]
|
||
*/
|
||
Real compute_ambient_occlusion(const HitRecord& hit);
|
||
|
||
/**
|
||
* @brief Check shadow ray
|
||
* @param origin Shadow ray origin
|
||
* @param direction Shadow ray direction
|
||
* @param max_distance Maximum distance
|
||
* @return true if in shadow
|
||
*/
|
||
bool is_in_shadow(const Vec3& origin, const Vec3& direction, Real max_distance);
|
||
|
||
const BVH* bvh_; ///< BVH reference
|
||
const SceneManager* scene_; ///< Scene reference
|
||
std::vector<Vec3> framebuffer_; ///< CPU framebuffer (HDR)
|
||
int width_; ///< Framebuffer width
|
||
int height_; ///< Framebuffer height
|
||
};
|
||
|
||
} // namespace are
|
||
|
||
#endif // ARE_INCLUDE_RAYTRACER_CPU_RAYTRACER_H
|
||
```
|
||
|
||
### 文件：include/are/raytracer/compute_raytracer.h
|
||
|
||
```cpp
|
||
/**
|
||
* @file compute_raytracer.h
|
||
* @brief GPU compute shader ray tracing implementation
|
||
*/
|
||
|
||
#ifndef ARE_INCLUDE_RAYTRACER_COMPUTE_RAYTRACER_H
|
||
#define ARE_INCLUDE_RAYTRACER_COMPUTE_RAYTRACER_H
|
||
|
||
#include <are/raytracer/raytracer.h>
|
||
#include <memory>
|
||
|
||
namespace are {
|
||
|
||
// Forward declarations
|
||
class ShaderProgram;
|
||
|
||
/**
|
||
* @class ComputeRayTracer
|
||
* @brief GPU-based ray tracing using compute shaders
|
||
*/
|
||
class ComputeRayTracer : public RayTracer {
|
||
public:
|
||
/**
|
||
* @brief Constructor
|
||
* @param config Ray tracing configuration
|
||
*/
|
||
explicit ComputeRayTracer(const RayTracingConfig& config);
|
||
|
||
/**
|
||
* @brief Destructor
|
||
*/
|
||
~ComputeRayTracer() override;
|
||
|
||
/**
|
||
* @brief Render scene using compute shader ray tracing
|
||
* @param scene Scene manager
|
||
* @param camera Camera
|
||
* @param gbuffer G-Buffer (optional)
|
||
* @param output Output texture ID
|
||
*/
|
||
void render(const SceneManager& scene,
|
||
const Camera& camera,
|
||
const GBuffer* gbuffer,
|
||
uint32_t output_texture) override;
|
||
|
||
/**
|
||
* @brief Update BVH
|
||
* @param bvh BVH reference
|
||
*/
|
||
void update_bvh(const BVH& bvh) override;
|
||
|
||
private:
|
||
void initialize_compute_shader(const std::string& shader_dir);
|
||
void upload_scene_data(const SceneManager& scene);
|
||
void upload_bvh_data(const BVH& bvh);
|
||
void upload_camera_data(const Camera& camera);
|
||
|
||
std::unique_ptr<ShaderProgram> compute_shader_; ///< Ray tracing compute shader
|
||
|
||
// GPU buffers (SSBOs)
|
||
uint32_t bvh_buffer_; ///< BVH nodes buffer
|
||
uint32_t triangle_buffer_; ///< Triangle data buffer
|
||
uint32_t material_buffer_; ///< Material data buffer
|
||
uint32_t light_buffer_; ///< Light data buffer
|
||
|
||
bool buffers_initialized_; ///< Buffer initialization flag
|
||
};
|
||
|
||
} // namespace are
|
||
|
||
#endif // ARE_INCLUDE_RAYTRACER_COMPUTE_RAYTRACER_H
|
||
```
|
||
|
||
### 文件：include/are/utils/image_io.h
|
||
|
||
```cpp
|
||
/**
|
||
* @file image_io.h
|
||
* @brief Image loading and saving utilities
|
||
*/
|
||
|
||
#ifndef ARE_INCLUDE_UTILS_IMAGE_IO_H
|
||
#define ARE_INCLUDE_UTILS_IMAGE_IO_H
|
||
|
||
#include <are/core/types.h>
|
||
#include <string>
|
||
#include <vector>
|
||
|
||
namespace are {
|
||
|
||
/**
|
||
* @enum ImageFormat
|
||
* @brief Supported image formats
|
||
*/
|
||
enum class ImageFormat {
|
||
ARE_IMAGE_FORMAT_PPM,
|
||
ARE_IMAGE_FORMAT_BMP,
|
||
ARE_IMAGE_FORMAT_PNG,
|
||
ARE_IMAGE_FORMAT_JPG
|
||
};
|
||
|
||
/**
|
||
* @struct ImageData
|
||
* @brief Container for image data
|
||
*/
|
||
struct ImageData {
|
||
int width_; ///< Image width
|
||
int height_; ///< Image height
|
||
int channels_; ///< Number of channels (3=RGB, 4=RGBA)
|
||
std::vector<uint8_t> data_; ///< Pixel data (row-major)
|
||
|
||
/**
|
||
* @brief Check if image data is valid
|
||
* @return true if valid
|
||
*/
|
||
bool is_valid() const;
|
||
|
||
/**
|
||
* @brief Get pixel at (x, y)
|
||
* @param x X coordinate
|
||
* @param y Y coordinate
|
||
* @return Pointer to pixel data (RGB or RGBA)
|
||
*/
|
||
const uint8_t* get_pixel(int x, int y) const;
|
||
|
||
/**
|
||
* @brief Set pixel at (x, y)
|
||
* @param x X coordinate
|
||
* @param y Y coordinate
|
||
* @param r Red channel
|
||
* @param g Green channel
|
||
* @param b Blue channel
|
||
* @param a Alpha channel (optional)
|
||
*/
|
||
void set_pixel(int x, int y, uint8_t r, uint8_t g, uint8_t b, uint8_t a = 255);
|
||
};
|
||
|
||
/**
|
||
* @brief Load image from file
|
||
* @param filename Image file path
|
||
* @param flip_vertically Whether to flip image vertically
|
||
* @return Image data (empty if failed)
|
||
*/
|
||
ImageData load_image(const std::string& filename, bool flip_vertically = false);
|
||
|
||
/**
|
||
* @brief Save image to file
|
||
* @param filename Output file path
|
||
* @param data Image data
|
||
* @param format Output format (auto-detected from extension if not specified)
|
||
* @return true if save succeeded
|
||
*/
|
||
bool save_image(const std::string& filename, const ImageData& data,
|
||
ImageFormat format = ImageFormat::ARE_IMAGE_FORMAT_PNG);
|
||
|
||
/**
|
||
* @brief Save raw pixel data to file
|
||
* @param filename Output file path
|
||
* @param pixels Pixel data pointer
|
||
* @param width Image width
|
||
* @param height Image height
|
||
* @param channels Number of channels
|
||
* @param format Output format
|
||
* @return true if save succeeded
|
||
*/
|
||
bool save_image(const std::string& filename, const uint8_t* pixels,
|
||
int width, int height, int channels,
|
||
ImageFormat format = ImageFormat::ARE_IMAGE_FORMAT_PNG);
|
||
|
||
/**
|
||
* @brief Detect image format from file extension
|
||
* @param filename File path
|
||
* @return Detected format
|
||
*/
|
||
ImageFormat detect_format(const std::string& filename);
|
||
|
||
} // namespace are
|
||
|
||
#endif // ARE_INCLUDE_UTILS_IMAGE_IO_H
|
||
```
|
||
|
||
### 文件：include/are/utils/math_utils.h
|
||
|
||
```cpp
|
||
/**
|
||
* @file math_utils.h
|
||
* @brief Mathematical utility functions
|
||
*/
|
||
|
||
#ifndef ARE_INCLUDE_UTILS_MATH_UTILS_H
|
||
#define ARE_INCLUDE_UTILS_MATH_UTILS_H
|
||
|
||
#include <are/core/types.h>
|
||
#include <algorithm>
|
||
|
||
namespace are {
|
||
|
||
/**
|
||
* @brief Clamp value to range [min, max]
|
||
* @param value Value to clamp
|
||
* @param min Minimum value
|
||
* @param max Maximum value
|
||
* @return Clamped value
|
||
*/
|
||
template<typename T>
|
||
inline T clamp(T value, T min, T max) {
|
||
return std::max(min, std::min(value, max));
|
||
}
|
||
|
||
/**
|
||
* @brief Linear interpolation
|
||
* @param a Start value
|
||
* @param b End value
|
||
* @param t Interpolation factor [0, 1]
|
||
* @return Interpolated value
|
||
*/
|
||
template<typename T>
|
||
inline T lerp(T a, T b, Real t) {
|
||
return a + (b - a) * t;
|
||
}
|
||
|
||
/**
|
||
* @brief Convert degrees to radians
|
||
* @param degrees Angle in degrees
|
||
* @return Angle in radians
|
||
*/
|
||
inline Real degrees_to_radians(Real degrees) {
|
||
return degrees * are_pi / 180.0f;
|
||
}
|
||
|
||
/**
|
||
* @brief Convert radians to degrees
|
||
* @param radians Angle in radians
|
||
* @return Angle in degrees
|
||
*/
|
||
inline Real radians_to_degrees(Real radians) {
|
||
return radians * 180.0f / are_pi;
|
||
}
|
||
|
||
/**
|
||
* @brief Check if two floating point values are approximately equal
|
||
* @param a First value
|
||
* @param b Second value
|
||
* @param epsilon Tolerance
|
||
* @return true if approximately equal
|
||
*/
|
||
inline bool approx_equal(Real a, Real b, Real epsilon = are_epsilon) {
|
||
return std::abs(a - b) < epsilon;
|
||
}
|
||
|
||
/**
|
||
* @brief Compute barycentric coordinates
|
||
* @param p Point
|
||
* @param a Triangle vertex A
|
||
* @param b Triangle vertex B
|
||
* @param c Triangle vertex C
|
||
* @param u Output barycentric coordinate u
|
||
* @param v Output barycentric coordinate v
|
||
* @param w Output barycentric coordinate w
|
||
*/
|
||
void compute_barycentric(const Vec3& p, const Vec3& a, const Vec3& b, const Vec3& c,
|
||
Real& u, Real& v, Real& w);
|
||
|
||
/**
|
||
* @brief Reflect vector around normal
|
||
* @param incident Incident vector
|
||
* @param normal Surface normal (normalized)
|
||
* @return Reflected vector
|
||
*/
|
||
Vec3 reflect(const Vec3& incident, const Vec3& normal);
|
||
|
||
/**
|
||
* @brief Refract vector through surface
|
||
* @param incident Incident vector (normalized)
|
||
* @param normal Surface normal (normalized)
|
||
* @param eta Ratio of refractive indices
|
||
* @param refracted Output refracted vector
|
||
* @return true if refraction occurred (false for total internal reflection)
|
||
*/
|
||
bool refract(const Vec3& incident, const Vec3& normal, Real eta, Vec3& refracted);
|
||
|
||
/**
|
||
* @brief Compute Fresnel reflectance (Schlick approximation)
|
||
* @param cos_theta Cosine of angle between view and normal
|
||
* @param f0 Reflectance at normal incidence
|
||
* @return Fresnel reflectance
|
||
*/
|
||
Real fresnel_schlick(Real cos_theta, Real f0);
|
||
|
||
/**
|
||
* @brief Create orthonormal basis from normal
|
||
* @param normal Normal vector (normalized)
|
||
* @param tangent Output tangent vector
|
||
* @param bitangent Output bitangent vector
|
||
*/
|
||
void create_orthonormal_basis(const Vec3& normal, Vec3& tangent, Vec3& bitangent);
|
||
|
||
/**
|
||
* @brief Transform direction from tangent space to world space
|
||
* @param tangent_dir Direction in tangent space
|
||
* @param normal Surface normal
|
||
* @param tangent Surface tangent
|
||
* @param bitangent Surface bitangent
|
||
* @return Direction in world space
|
||
*/
|
||
Vec3 tangent_to_world(const Vec3& tangent_dir, const Vec3& normal,
|
||
const Vec3& tangent, const Vec3& bitangent);
|
||
|
||
} // namespace are
|
||
|
||
#endif // ARE_INCLUDE_UTILS_MATH_UTILS_H
|
||
```
|
||
|
||
### 文件：include/are/utils/random.h
|
||
|
||
```cpp
|
||
/**
|
||
* @file random.h
|
||
* @brief Random number generation utilities
|
||
*/
|
||
|
||
#ifndef ARE_INCLUDE_UTILS_RANDOM_H
|
||
#define ARE_INCLUDE_UTILS_RANDOM_H
|
||
|
||
#include <are/core/types.h>
|
||
#include <random>
|
||
|
||
namespace are {
|
||
|
||
/**
|
||
* @class RandomGenerator
|
||
* @brief Thread-safe random number generator
|
||
*
|
||
* Uses PCG (Permuted Congruential Generator) for high-quality random numbers.
|
||
*/
|
||
class RandomGenerator {
|
||
public:
|
||
/**
|
||
* @brief Constructor with optional seed
|
||
* @param seed Random seed (0 = use random device)
|
||
*/
|
||
explicit RandomGenerator(uint64_t seed = 0);
|
||
|
||
/**
|
||
* @brief Generate random float in [0, 1)
|
||
* @return Random float
|
||
*/
|
||
Real random_float();
|
||
|
||
/**
|
||
* @brief Generate random float in [min, max)
|
||
* @param min Minimum value
|
||
* @param max Maximum value
|
||
* @return Random float
|
||
*/
|
||
Real random_float(Real min, Real max);
|
||
|
||
/**
|
||
* @brief Generate random integer in [min, max]
|
||
* @param min Minimum value
|
||
* @param max Maximum value
|
||
* @return Random integer
|
||
*/
|
||
int random_int(int min, int max);
|
||
|
||
/**
|
||
* @brief Generate random point in unit disk
|
||
* @return Random point (z = 0)
|
||
*/
|
||
Vec3 random_in_unit_disk();
|
||
|
||
/**
|
||
* @brief Generate random point in unit sphere
|
||
* @return Random point
|
||
*/
|
||
Vec3 random_in_unit_sphere();
|
||
|
||
/**
|
||
* @brief Generate random unit vector
|
||
* @return Random unit vector
|
||
*/
|
||
Vec3 random_unit_vector();
|
||
|
||
/**
|
||
* @brief Generate random vector in hemisphere
|
||
* @param normal Hemisphere normal
|
||
* @return Random vector in hemisphere
|
||
*/
|
||
Vec3 random_in_hemisphere(const Vec3 &normal);
|
||
|
||
/**
|
||
* @brief Generate random cosine-weighted direction
|
||
* @param normal Surface normal
|
||
* @return Random direction (cosine-weighted)
|
||
*/
|
||
Vec3 random_cosine_direction(const Vec3 &normal);
|
||
|
||
/**
|
||
* @brief Set seed for reproducible results
|
||
* @param seed Random seed
|
||
*/
|
||
void set_seed(uint64_t seed);
|
||
|
||
private:
|
||
std::mt19937_64 rng_; ///< Random number generator
|
||
std::uniform_real_distribution<Real> dist_; ///< Uniform distribution [0, 1)
|
||
};
|
||
|
||
/**
|
||
* @brief Get thread-local random generator
|
||
* @return Reference to thread-local generator
|
||
*/
|
||
RandomGenerator &get_thread_random();
|
||
|
||
/**
|
||
* @brief Generate random float in [0, 1) using thread-local generator
|
||
* @return Random float
|
||
*/
|
||
inline Real random_float() {
|
||
return get_thread_random().random_float();
|
||
}
|
||
|
||
/**
|
||
* @brief Generate random float in [min, max) using thread-local generator
|
||
* @param min Minimum value
|
||
* @param max Maximum value
|
||
* @return Random float
|
||
*/
|
||
inline Real random_float(Real min, Real max) {
|
||
return get_thread_random().random_float(min, max);
|
||
}
|
||
|
||
} // namespace are
|
||
|
||
#endif // ARE_INCLUDE_UTILS_RANDOM_H
|
||
```
|
||
|
||
### 文件：include/are/utils/file_utils.h
|
||
|
||
```cpp
|
||
/**
|
||
* @file file_utils.h
|
||
* @brief File system utilities
|
||
*/
|
||
|
||
#ifndef ARE_INCLUDE_UTILS_FILE_UTILS_H
|
||
#define ARE_INCLUDE_UTILS_FILE_UTILS_H
|
||
|
||
#include <string>
|
||
#include <vector>
|
||
#include <cstdint>
|
||
|
||
namespace are {
|
||
|
||
/**
|
||
* @brief Read entire file into string
|
||
* @param filepath File path
|
||
* @return File contents (empty if failed)
|
||
*/
|
||
std::string read_file_to_string(const std::string& filepath);
|
||
|
||
/**
|
||
* @brief Read entire file into byte array
|
||
* @param filepath File path
|
||
* @return File contents (empty if failed)
|
||
*/
|
||
std::vector<uint8_t> read_file_to_bytes(const std::string& filepath);
|
||
|
||
/**
|
||
* @brief Write string to file
|
||
* @param filepath File path
|
||
* @param content Content to write
|
||
* @return true if write succeeded
|
||
*/
|
||
bool write_string_to_file(const std::string& filepath, const std::string& content);
|
||
|
||
/**
|
||
* @brief Write bytes to file
|
||
* @param filepath File path
|
||
* @param data Data pointer
|
||
* @param size Data size in bytes
|
||
* @return true if write succeeded
|
||
*/
|
||
bool write_bytes_to_file(const std::string& filepath, const void* data, size_t size);
|
||
|
||
/**
|
||
* @brief Check if file exists
|
||
* @param filepath File path
|
||
* @return true if file exists
|
||
*/
|
||
bool file_exists(const std::string& filepath);
|
||
|
||
/**
|
||
* @brief Check if path is directory
|
||
* @param path Directory path
|
||
* @return true if directory exists
|
||
*/
|
||
bool is_directory(const std::string& path);
|
||
|
||
/**
|
||
* @brief Create directory (including parent directories)
|
||
* @param path Directory path
|
||
* @return true if creation succeeded
|
||
*/
|
||
bool create_directory(const std::string& path);
|
||
|
||
/**
|
||
* @brief Get file extension
|
||
* @param filepath File path
|
||
* @return Extension (lowercase, without dot)
|
||
*/
|
||
std::string get_file_extension(const std::string& filepath);
|
||
|
||
/**
|
||
* @brief Get filename from path
|
||
* @param filepath File path
|
||
* @return Filename (without directory)
|
||
*/
|
||
std::string get_filename(const std::string& filepath);
|
||
|
||
/**
|
||
* @brief Get directory from path
|
||
* @param filepath File path
|
||
* @return Directory path
|
||
*/
|
||
std::string get_directory(const std::string& filepath);
|
||
|
||
/**
|
||
* @brief Join path components
|
||
* @param parts Path components
|
||
* @return Joined path
|
||
*/
|
||
std::string join_path(const std::vector<std::string>& parts);
|
||
|
||
/**
|
||
* @brief Normalize path (resolve .. and .)
|
||
* @param path Path to normalize
|
||
* @return Normalized path
|
||
*/
|
||
std::string normalize_path(const std::string& path);
|
||
|
||
} // namespace are
|
||
|
||
#endif // ARE_INCLUDE_UTILS_FILE_UTILS_H
|
||
```
|
||
|
||
### 文件：include/are/platform/window.h
|
||
|
||
```cpp
|
||
/**
|
||
* @file window.h
|
||
* @brief Window management using GLFW
|
||
*/
|
||
|
||
#ifndef ARE_INCLUDE_PLATFORM_WINDOW_H
|
||
#define ARE_INCLUDE_PLATFORM_WINDOW_H
|
||
|
||
#include <are/core/config.h>
|
||
#include <are/core/types.h>
|
||
#include <string>
|
||
|
||
// Forward declare GLFW types to avoid including GLFW in header
|
||
struct GLFWwindow;
|
||
|
||
namespace are {
|
||
|
||
/**
|
||
* @class Window
|
||
* @brief GLFW window wrapper
|
||
*
|
||
* Manages window creation, input handling, and OpenGL context.
|
||
*/
|
||
class Window {
|
||
public:
|
||
/**
|
||
* @brief Constructor
|
||
* @param config Window configuration
|
||
*/
|
||
explicit Window(const WindowConfig& config);
|
||
|
||
/**
|
||
* @brief Destructor
|
||
*/
|
||
~Window();
|
||
|
||
// Window control
|
||
bool should_close() const;
|
||
void set_should_close(bool should_close);
|
||
void swap_buffers();
|
||
void poll_events();
|
||
|
||
// Window properties
|
||
int get_width() const;
|
||
int get_height() const;
|
||
Real get_aspect_ratio() const;
|
||
const std::string& get_title() const;
|
||
|
||
void set_title(const std::string& title);
|
||
void set_size(int width, int height);
|
||
|
||
// Framebuffer size (may differ from window size on high-DPI displays)
|
||
void get_framebuffer_size(int& width, int& height) const;
|
||
|
||
// VSync control
|
||
void set_vsync(bool enabled);
|
||
bool get_vsync() const;
|
||
|
||
// Input queries (basic support)
|
||
bool is_key_pressed(int key) const;
|
||
bool is_mouse_button_pressed(int button) const;
|
||
void get_cursor_pos(double& x, double& y) const;
|
||
|
||
// Internal
|
||
GLFWwindow* get_native_window() const { return window_; }
|
||
|
||
private:
|
||
void initialize_glfw();
|
||
void create_window();
|
||
void setup_callbacks();
|
||
|
||
static void framebuffer_size_callback(GLFWwindow* window, int width, int height);
|
||
static void error_callback(int error, const char* description);
|
||
|
||
GLFWwindow* window_; ///< GLFW window handle
|
||
WindowConfig config_; ///< Window configuration
|
||
bool vsync_enabled_; ///< VSync state
|
||
|
||
static int instance_count_; ///< Number of Window instances
|
||
};
|
||
|
||
} // namespace are
|
||
|
||
#endif // ARE_INCLUDE_PLATFORM_WINDOW_H
|
||
```
|
||
|
||
### 文件：include/are/platform/gl_context.h
|
||
|
||
```cpp
|
||
/**
|
||
* @file gl_context.h
|
||
* @brief OpenGL context management
|
||
*/
|
||
|
||
#ifndef ARE_INCLUDE_PLATFORM_GL_CONTEXT_H
|
||
#define ARE_INCLUDE_PLATFORM_GL_CONTEXT_H
|
||
|
||
#include <are/core/types.h>
|
||
#include <string>
|
||
|
||
namespace are {
|
||
|
||
/**
|
||
* @class GLContext
|
||
* @brief OpenGL context initialization and management
|
||
*
|
||
* Handles GLAD initialization and provides OpenGL utility functions.
|
||
*/
|
||
class GLContext {
|
||
public:
|
||
/**
|
||
* @brief Initialize OpenGL context (load function pointers)
|
||
* @return true if initialization succeeded
|
||
*/
|
||
static bool initialize();
|
||
|
||
/**
|
||
* @brief Check if context is initialized
|
||
* @return true if initialized
|
||
*/
|
||
static bool is_initialized();
|
||
|
||
/**
|
||
* @brief Get OpenGL version string
|
||
* @return Version string
|
||
*/
|
||
static std::string get_version();
|
||
|
||
/**
|
||
* @brief Get OpenGL renderer string
|
||
* @return Renderer string
|
||
*/
|
||
static std::string get_renderer();
|
||
|
||
/**
|
||
* @brief Get OpenGL vendor string
|
||
* @return Vendor string
|
||
*/
|
||
static std::string get_vendor();
|
||
|
||
/**
|
||
* @brief Check if OpenGL extension is supported
|
||
* @param extension Extension name
|
||
* @return true if supported
|
||
*/
|
||
static bool is_extension_supported(const std::string& extension);
|
||
|
||
/**
|
||
* @brief Print OpenGL information to console
|
||
*/
|
||
static void print_info();
|
||
|
||
/**
|
||
* @brief Check for OpenGL errors
|
||
* @param file Source file
|
||
* @param line Line number
|
||
* @return true if error occurred
|
||
*/
|
||
static bool check_error(const char* file, int line);
|
||
|
||
/**
|
||
* @brief Clear all OpenGL errors
|
||
*/
|
||
static void clear_errors();
|
||
|
||
private:
|
||
static bool initialized_; ///< Initialization flag
|
||
};
|
||
|
||
} // namespace are
|
||
|
||
// OpenGL error checking macro
|
||
#ifdef ARE_ENABLE_DEBUG_VIS
|
||
#define ARE_GL_CHECK() are::GLContext::check_error(__FILE__, __LINE__)
|
||
#else
|
||
#define ARE_GL_CHECK() ((void)0)
|
||
#endif
|
||
|
||
#endif // ARE_INCLUDE_PLATFORM_GL_CONTEXT_H
|
||
```
|
||
|
||
### 文件：include/are/acceleration/bvh_node.h
|
||
|
||
```cpp
|
||
/**
|
||
* @file bvh_node.h
|
||
* @brief BVH node structure
|
||
*/
|
||
|
||
#ifndef ARE_INCLUDE_ACCELERATION_BVH_NODE_H
|
||
#define ARE_INCLUDE_ACCELERATION_BVH_NODE_H
|
||
|
||
#include <are/core/types.h>
|
||
#include <are/geometry/aabb.h>
|
||
|
||
namespace are {
|
||
|
||
/**
|
||
* @struct BVHNode
|
||
* @brief Node in Bounding Volume Hierarchy
|
||
*
|
||
* Uses a compact representation for efficient GPU transfer.
|
||
*/
|
||
struct BVHNode {
|
||
AABB bounds_; ///< Node bounding box
|
||
|
||
union {
|
||
uint32_t left_child_; ///< Left child index (internal node)
|
||
uint32_t first_primitive_; ///< First primitive index (leaf node)
|
||
};
|
||
|
||
union {
|
||
uint32_t right_child_; ///< Right child index (internal node)
|
||
uint32_t primitive_count_; ///< Number of primitives (leaf node)
|
||
};
|
||
|
||
/**
|
||
* @brief Check if node is a leaf
|
||
* @return true if leaf node
|
||
*/
|
||
bool is_leaf() const {
|
||
return primitive_count_ > 0;
|
||
}
|
||
|
||
/**
|
||
* @brief Get node surface area (for SAH)
|
||
* @return Surface area
|
||
*/
|
||
Real surface_area() const {
|
||
return bounds_.surface_area();
|
||
}
|
||
};
|
||
|
||
} // namespace are
|
||
|
||
#endif // ARE_INCLUDE_ACCELERATION_BVH_NODE_H
|
||
```
|
||
|
||
### 文件：include/are/acceleration/bvh_builder.h
|
||
|
||
```cpp
|
||
/**
|
||
* @file bvh_builder.h
|
||
* @brief BVH construction algorithms
|
||
*/
|
||
|
||
#ifndef ARE_INCLUDE_ACCELERATION_BVH_BUILDER_H
|
||
#define ARE_INCLUDE_ACCELERATION_BVH_BUILDER_H
|
||
|
||
#include <are/core/types.h>
|
||
#include <are/acceleration/bvh_node.h>
|
||
#include <are/geometry/triangle.h>
|
||
#include <vector>
|
||
|
||
namespace are {
|
||
|
||
/**
|
||
* @enum BVHSplitMethod
|
||
* @brief BVH splitting strategies
|
||
*/
|
||
enum class BVHSplitMethod {
|
||
ARE_BVH_SPLIT_MIDDLE, ///< Split at midpoint
|
||
ARE_BVH_SPLIT_SAH ///< Surface Area Heuristic
|
||
};
|
||
|
||
/**
|
||
* @struct BVHBuildConfig
|
||
* @brief Configuration for BVH construction
|
||
*/
|
||
struct BVHBuildConfig {
|
||
BVHSplitMethod split_method_ = BVHSplitMethod::ARE_BVH_SPLIT_SAH;
|
||
int max_leaf_size_ = 4; ///< Maximum triangles per leaf
|
||
int max_depth_ = 64; ///< Maximum tree depth
|
||
bool use_multithreading_ = true; ///< Use parallel construction
|
||
};
|
||
|
||
/**
|
||
* @class BVHBuilder
|
||
* @brief Constructs BVH from triangle list
|
||
*/
|
||
class BVHBuilder {
|
||
public:
|
||
/**
|
||
* @brief Constructor
|
||
* @param config Build configuration
|
||
*/
|
||
explicit BVHBuilder(const BVHBuildConfig& config = BVHBuildConfig());
|
||
|
||
/**
|
||
* @brief Build BVH from triangles
|
||
* @param triangles Triangle list
|
||
* @param nodes Output node list
|
||
* @param primitive_indices Output primitive index list
|
||
* @return Root node index
|
||
*/
|
||
uint32_t build(const std::vector<Triangle>& triangles,
|
||
std::vector<BVHNode>& nodes,
|
||
std::vector<uint32_t>& primitive_indices);
|
||
|
||
/**
|
||
* @brief Get build statistics
|
||
* @param node_count Output node count
|
||
* @param leaf_count Output leaf count
|
||
* @param max_depth Output maximum depth reached
|
||
*/
|
||
void get_stats(size_t& node_count, size_t& leaf_count, int& max_depth) const;
|
||
|
||
private:
|
||
struct BuildEntry {
|
||
uint32_t parent_;
|
||
uint32_t start_;
|
||
uint32_t end_;
|
||
int depth_;
|
||
};
|
||
|
||
uint32_t build_recursive(const std::vector<Triangle>& triangles,
|
||
std::vector<BVHNode>& nodes,
|
||
std::vector<uint32_t>& primitive_indices,
|
||
uint32_t start, uint32_t end, int depth);
|
||
|
||
int find_best_split_axis(const std::vector<Triangle>& triangles,
|
||
const std::vector<uint32_t>& indices,
|
||
uint32_t start, uint32_t end);
|
||
|
||
Real compute_sah_cost(const AABB& bounds, uint32_t count);
|
||
|
||
BVHBuildConfig config_;
|
||
size_t node_count_;
|
||
size_t leaf_count_;
|
||
int max_depth_reached_;
|
||
};
|
||
|
||
} // namespace are
|
||
|
||
#endif // ARE_INCLUDE_ACCELERATION_BVH_BUILDER_H
|
||
```
|
||
|
||
### 文件：include/are/acceleration/bvh.h
|
||
|
||
```cpp
|
||
/**
|
||
* @file bvh.h
|
||
* @brief BVH interface and traversal
|
||
*/
|
||
|
||
#ifndef ARE_INCLUDE_ACCELERATION_BVH_H
|
||
#define ARE_INCLUDE_ACCELERATION_BVH_H
|
||
|
||
#include <are/core/types.h>
|
||
#include <are/acceleration/bvh_node.h>
|
||
#include <are/acceleration/bvh_builder.h>
|
||
#include <are/geometry/triangle.h>
|
||
#include <are/raytracer/ray.h>
|
||
#include <are/raytracer/hit_record.h>
|
||
#include <vector>
|
||
|
||
namespace are {
|
||
|
||
/**
|
||
* @class BVH
|
||
* @brief Bounding Volume Hierarchy for ray tracing acceleration
|
||
*/
|
||
class BVH {
|
||
public:
|
||
/**
|
||
* @brief Constructor
|
||
*/
|
||
BVH();
|
||
|
||
/**
|
||
* @brief Destructor
|
||
*/
|
||
~BVH();
|
||
|
||
/**
|
||
* @brief Build BVH from triangle list
|
||
* @param triangles Triangle list
|
||
* @param config Build configuration
|
||
* @return true if build succeeded
|
||
*/
|
||
bool build(const std::vector<Triangle>& triangles,
|
||
const BVHBuildConfig& config = BVHBuildConfig());
|
||
|
||
/**
|
||
* @brief Traverse BVH and find closest intersection
|
||
* @param ray Ray to trace
|
||
* @param hit Output hit record
|
||
* @return true if intersection found
|
||
*/
|
||
bool intersect(const Ray& ray, HitRecord& hit) const;
|
||
|
||
/**
|
||
* @brief Fast occlusion test (any hit)
|
||
* @param ray Ray to trace
|
||
* @param t_max Maximum t value
|
||
* @return true if any intersection found
|
||
*/
|
||
bool intersect_any(const Ray& ray, Real t_max) const;
|
||
|
||
/**
|
||
* @brief Check if BVH is built
|
||
* @return true if built
|
||
*/
|
||
bool is_built() const { return !nodes_.empty(); }
|
||
|
||
/**
|
||
* @brief Get BVH nodes (for GPU upload)
|
||
* @return Node array
|
||
*/
|
||
const std::vector<BVHNode>& get_nodes() const { return nodes_; }
|
||
|
||
/**
|
||
* @brief Get primitive indices
|
||
* @return Index array
|
||
*/
|
||
const std::vector<uint32_t>& get_primitive_indices() const {
|
||
return primitive_indices_;
|
||
}
|
||
|
||
/**
|
||
* @brief Get triangles
|
||
* @return Triangle array
|
||
*/
|
||
const std::vector<Triangle>& get_triangles() const { return triangles_; }
|
||
|
||
/**
|
||
* @brief Get memory usage in bytes
|
||
* @return Memory usage
|
||
*/
|
||
size_t get_memory_usage() const;
|
||
|
||
/**
|
||
* @brief Clear BVH data
|
||
*/
|
||
void clear();
|
||
|
||
private:
|
||
// Recursive traversal (kept for reference)
|
||
bool intersect_recursive(uint32_t node_index, const Ray& ray, HitRecord& hit) const;
|
||
bool intersect_any_recursive(uint32_t node_index, const Ray& ray, Real t_max) const;
|
||
|
||
// Optimized iterative traversal
|
||
bool intersect_iterative(const Ray& ray, HitRecord& hit) const;
|
||
bool intersect_any_iterative(const Ray& ray, Real t_max) const;
|
||
|
||
// Fast intersection helpers
|
||
inline bool intersect_aabb_fast(const AABB& bounds, const Ray& ray,
|
||
const Vec3& inv_dir, Real t_max,
|
||
Real& t_min_out, Real& t_max_out) const;
|
||
inline bool intersect_triangle_fast(const Triangle& triangle, const Ray& ray,
|
||
Real t_max, HitRecord& hit) const;
|
||
|
||
std::vector<BVHNode> nodes_; ///< BVH nodes
|
||
std::vector<uint32_t> primitive_indices_; ///< Primitive index array
|
||
std::vector<Triangle> triangles_; ///< Triangle data
|
||
uint32_t root_index_; ///< Root node index
|
||
};
|
||
|
||
} // namespace are
|
||
|
||
#endif // ARE_INCLUDE_ACCELERATION_BVH_H
|
||
```
|
||
|
||
### 文件：include/are/rasterizer/rasterizer.h
|
||
|
||
```cpp
|
||
/**
|
||
* @file rasterizer.h
|
||
* @brief Rasterization pipeline for G-Buffer generation
|
||
*/
|
||
|
||
#ifndef ARE_INCLUDE_RASTERIZER_RASTERIZER_H
|
||
#define ARE_INCLUDE_RASTERIZER_RASTERIZER_H
|
||
|
||
#include <are/core/types.h>
|
||
#include <are/core/config.h>
|
||
#include <memory>
|
||
|
||
namespace are {
|
||
|
||
// Forward declarations
|
||
class GBuffer;
|
||
class ShaderProgram;
|
||
class SceneManager;
|
||
class Camera;
|
||
class Mesh;
|
||
|
||
/**
|
||
* @class Rasterizer
|
||
* @brief OpenGL rasterization pipeline
|
||
*
|
||
* Renders scene geometry to G-Buffer using traditional rasterization.
|
||
*/
|
||
class Rasterizer {
|
||
public:
|
||
/**
|
||
* @brief Constructor
|
||
* @param width Framebuffer width
|
||
* @param height Framebuffer height
|
||
*/
|
||
Rasterizer(int width, int height);
|
||
|
||
/**
|
||
* @brief Destructor
|
||
*/
|
||
~Rasterizer();
|
||
|
||
/**
|
||
* @brief Resize framebuffer
|
||
* @param width New width
|
||
* @param height New height
|
||
*/
|
||
void resize(int width, int height);
|
||
|
||
/**
|
||
* @brief Render scene to G-Buffer
|
||
* @param scene Scene manager
|
||
* @param camera Camera
|
||
*/
|
||
void render_gbuffer(const SceneManager& scene, const Camera& camera);
|
||
|
||
/**
|
||
* @brief Get G-Buffer
|
||
* @return G-Buffer reference
|
||
*/
|
||
GBuffer& get_gbuffer();
|
||
const GBuffer& get_gbuffer() const;
|
||
|
||
/**
|
||
* @brief Upload mesh data to GPU
|
||
* @param mesh Mesh to upload
|
||
*/
|
||
void upload_mesh(Mesh& mesh);
|
||
|
||
/**
|
||
* @brief Delete mesh GPU resources
|
||
* @param mesh Mesh to delete
|
||
*/
|
||
void delete_mesh(Mesh& mesh);
|
||
|
||
private:
|
||
void initialize_shaders(const std::string& shader_dir);
|
||
void setup_mesh_buffers(Mesh& mesh);
|
||
|
||
std::unique_ptr<GBuffer> gbuffer_; ///< G-Buffer
|
||
std::unique_ptr<ShaderProgram> gbuffer_shader_; ///< G-Buffer shader
|
||
|
||
int width_; ///< Framebuffer width
|
||
int height_; ///< Framebuffer height
|
||
};
|
||
|
||
} // namespace are
|
||
|
||
#endif // ARE_INCLUDE_RASTERIZER_RASTERIZER_H
|
||
```
|
||
|
||
### 文件：include/are/rasterizer/shader_program.h
|
||
|
||
```cpp
|
||
/**
|
||
* @file shader_program.h
|
||
* @brief OpenGL shader program wrapper
|
||
*/
|
||
|
||
#ifndef ARE_INCLUDE_RASTERIZER_SHADER_PROGRAM_H
|
||
#define ARE_INCLUDE_RASTERIZER_SHADER_PROGRAM_H
|
||
|
||
#include <are/core/types.h>
|
||
#include <string>
|
||
#include <unordered_map>
|
||
|
||
namespace are {
|
||
|
||
/**
|
||
* @enum ShaderType
|
||
* @brief Shader stage types
|
||
*/
|
||
enum class ShaderType {
|
||
ARE_SHADER_VERTEX,
|
||
ARE_SHADER_FRAGMENT,
|
||
ARE_SHADER_COMPUTE
|
||
};
|
||
|
||
/**
|
||
* @class ShaderProgram
|
||
* @brief OpenGL shader program management
|
||
*/
|
||
class ShaderProgram {
|
||
public:
|
||
/**
|
||
* @brief Constructor
|
||
*/
|
||
ShaderProgram();
|
||
|
||
/**
|
||
* @brief Destructor
|
||
*/
|
||
~ShaderProgram();
|
||
|
||
/**
|
||
* @brief Load and compile shader from file
|
||
* @param type Shader type
|
||
* @param filepath Shader file path
|
||
* @return true if compilation succeeded
|
||
*/
|
||
bool load_shader(ShaderType type, const std::string& filepath);
|
||
|
||
/**
|
||
* @brief Compile shader from source string
|
||
* @param type Shader type
|
||
* @param source Shader source code
|
||
* @return true if compilation succeeded
|
||
*/
|
||
bool compile_shader(ShaderType type, const std::string& source);
|
||
|
||
/**
|
||
* @brief Link shader program
|
||
* @return true if linking succeeded
|
||
*/
|
||
bool link();
|
||
|
||
/**
|
||
* @brief Use this shader program
|
||
*/
|
||
void use() const;
|
||
|
||
/**
|
||
* @brief Check if program is valid
|
||
* @return true if valid
|
||
*/
|
||
bool is_valid() const { return program_ != 0 && linked_; }
|
||
|
||
/**
|
||
* @brief Get OpenGL program ID
|
||
* @return Program ID
|
||
*/
|
||
uint32_t get_program() const { return program_; }
|
||
|
||
// Uniform setters
|
||
void set_uniform(const std::string& name, int value);
|
||
void set_uniform(const std::string& name, float value);
|
||
void set_uniform(const std::string& name, const Vec2& value);
|
||
void set_uniform(const std::string& name, const Vec3& value);
|
||
void set_uniform(const std::string& name, const Vec4& value);
|
||
void set_uniform(const std::string& name, const Mat3& value);
|
||
void set_uniform(const std::string& name, const Mat4& value);
|
||
|
||
/**
|
||
* @brief Get uniform location (cached)
|
||
* @param name Uniform name
|
||
* @return Uniform location (-1 if not found)
|
||
*/
|
||
int get_uniform_location(const std::string& name);
|
||
|
||
private:
|
||
bool check_compile_errors(uint32_t shader, ShaderType type);
|
||
bool check_link_errors();
|
||
|
||
uint32_t program_; ///< OpenGL program ID
|
||
uint32_t vertex_shader_; ///< Vertex shader ID
|
||
uint32_t fragment_shader_; ///< Fragment shader ID
|
||
uint32_t compute_shader_; ///< Compute shader ID
|
||
|
||
bool linked_; ///< Link status
|
||
std::unordered_map<std::string, int> uniform_cache_; ///< Uniform location cache
|
||
};
|
||
|
||
} // namespace are
|
||
|
||
#endif // ARE_INCLUDE_RASTERIZER_SHADER_PROGRAM_H
|
||
```
|
||
|
||
### 文件：include/are/rasterizer/gbuffer.h
|
||
|
||
```cpp
|
||
/**
|
||
* @file gbuffer.h
|
||
* @brief G-Buffer management for deferred rendering
|
||
*/
|
||
|
||
#ifndef ARE_INCLUDE_RASTERIZER_GBUFFER_H
|
||
#define ARE_INCLUDE_RASTERIZER_GBUFFER_H
|
||
|
||
#include <are/core/types.h>
|
||
#include <cstdint>
|
||
|
||
namespace are {
|
||
|
||
/**
|
||
* @class GBuffer
|
||
* @brief G-Buffer for deferred rendering
|
||
*
|
||
* Contains multiple render targets for position, normal, albedo, etc.
|
||
*/
|
||
class GBuffer {
|
||
public:
|
||
/**
|
||
* @brief Constructor
|
||
* @param width Buffer width
|
||
* @param height Buffer height
|
||
*/
|
||
GBuffer(int width, int height);
|
||
|
||
/**
|
||
* @brief Destructor
|
||
*/
|
||
~GBuffer();
|
||
|
||
/**
|
||
* @brief Resize G-Buffer
|
||
* @param width New width
|
||
* @param height New height
|
||
*/
|
||
void resize(int width, int height);
|
||
|
||
/**
|
||
* @brief Bind G-Buffer for rendering
|
||
*/
|
||
void bind();
|
||
|
||
/**
|
||
* @brief Unbind G-Buffer
|
||
*/
|
||
void unbind();
|
||
|
||
/**
|
||
* @brief Clear all buffers
|
||
*/
|
||
void clear();
|
||
|
||
/**
|
||
* @brief Bind texture for reading
|
||
* @param index Texture index (0=position, 1=normal, 2=albedo, etc.)
|
||
* @param texture_unit Texture unit to bind to
|
||
*/
|
||
void bind_texture(int index, int texture_unit);
|
||
|
||
// Texture getters
|
||
uint32_t get_position_texture() const { return position_texture_; }
|
||
uint32_t get_normal_texture() const { return normal_texture_; }
|
||
uint32_t get_albedo_texture() const { return albedo_texture_; }
|
||
uint32_t get_material_texture() const { return material_texture_; }
|
||
uint32_t get_depth_texture() const { return depth_texture_; }
|
||
|
||
// Dimensions
|
||
int get_width() const { return width_; }
|
||
int get_height() const { return height_; }
|
||
|
||
/**
|
||
* @brief Read pixel data from G-Buffer
|
||
* @param index Buffer index
|
||
* @param data Output data pointer
|
||
*/
|
||
void read_pixels(int index, void* data);
|
||
|
||
private:
|
||
void create_textures();
|
||
void delete_textures();
|
||
void create_framebuffer();
|
||
|
||
uint32_t fbo_; ///< Framebuffer object
|
||
uint32_t rbo_depth_; ///< Depth renderbuffer
|
||
|
||
// G-Buffer textures
|
||
uint32_t position_texture_; ///< World position (RGB16F)
|
||
uint32_t normal_texture_; ///< World normal (RGB16F)
|
||
uint32_t albedo_texture_; ///< Albedo + Metallic (RGBA8)
|
||
uint32_t material_texture_; ///< Roughness + AO (RG8)
|
||
uint32_t depth_texture_; ///< Depth (R32F)
|
||
|
||
int width_; ///< Buffer width
|
||
int height_; ///< Buffer height
|
||
};
|
||
|
||
} // namespace are
|
||
|
||
#endif // ARE_INCLUDE_RASTERIZER_GBUFFER_H
|
||
```
|
||
|
||
### 文件：include/are/texture/texture.h
|
||
|
||
```cpp
|
||
/**
|
||
* @file texture.h
|
||
* @brief Texture resource management
|
||
*/
|
||
|
||
#ifndef ARE_INCLUDE_TEXTURE_TEXTURE_H
|
||
#define ARE_INCLUDE_TEXTURE_TEXTURE_H
|
||
|
||
#include <are/core/types.h>
|
||
#include <string>
|
||
|
||
namespace are {
|
||
|
||
/**
|
||
* @enum TextureFormat
|
||
* @brief Texture internal formats
|
||
*/
|
||
enum class TextureFormat {
|
||
ARE_TEXTURE_R8,
|
||
ARE_TEXTURE_RG8,
|
||
ARE_TEXTURE_RGB8,
|
||
ARE_TEXTURE_RGBA8,
|
||
ARE_TEXTURE_R16F,
|
||
ARE_TEXTURE_RG16F,
|
||
ARE_TEXTURE_RGB16F,
|
||
ARE_TEXTURE_RGBA16F,
|
||
ARE_TEXTURE_R32F,
|
||
ARE_TEXTURE_RG32F,
|
||
ARE_TEXTURE_RGB32F,
|
||
ARE_TEXTURE_RGBA32F
|
||
};
|
||
|
||
/**
|
||
* @enum TextureFilter
|
||
* @brief Texture filtering modes
|
||
*/
|
||
enum class TextureFilter {
|
||
ARE_TEXTURE_FILTER_NEAREST,
|
||
ARE_TEXTURE_FILTER_LINEAR,
|
||
ARE_TEXTURE_FILTER_NEAREST_MIPMAP_NEAREST,
|
||
ARE_TEXTURE_FILTER_LINEAR_MIPMAP_NEAREST,
|
||
ARE_TEXTURE_FILTER_NEAREST_MIPMAP_LINEAR,
|
||
ARE_TEXTURE_FILTER_LINEAR_MIPMAP_LINEAR
|
||
};
|
||
|
||
/**
|
||
* @enum TextureWrap
|
||
* @brief Texture wrapping modes
|
||
*/
|
||
enum class TextureWrap {
|
||
ARE_TEXTURE_WRAP_REPEAT,
|
||
ARE_TEXTURE_WRAP_CLAMP_TO_EDGE,
|
||
ARE_TEXTURE_WRAP_CLAMP_TO_BORDER,
|
||
ARE_TEXTURE_WRAP_MIRRORED_REPEAT
|
||
};
|
||
|
||
/**
|
||
* @class Texture
|
||
* @brief OpenGL texture wrapper
|
||
*/
|
||
class Texture {
|
||
public:
|
||
/**
|
||
* @brief Constructor
|
||
*/
|
||
Texture();
|
||
|
||
/**
|
||
* @brief Destructor
|
||
*/
|
||
~Texture();
|
||
|
||
/**
|
||
* @brief Load texture from file
|
||
* @param filepath Image file path
|
||
* @param format Desired texture format
|
||
* @param generate_mipmaps Generate mipmaps
|
||
* @return true if load succeeded
|
||
*/
|
||
bool load_from_file(const std::string& filepath,
|
||
TextureFormat format = TextureFormat::ARE_TEXTURE_RGBA8,
|
||
bool generate_mipmaps = true);
|
||
|
||
/**
|
||
* @brief Create texture from raw data
|
||
* @param width Texture width
|
||
* @param height Texture height
|
||
* @param format Texture format
|
||
* @param data Pixel data
|
||
* @param generate_mipmaps Generate mipmaps
|
||
* @return true if creation succeeded
|
||
*/
|
||
bool create_from_data(int width, int height,
|
||
TextureFormat format,
|
||
const void* data,
|
||
bool generate_mipmaps = true);
|
||
|
||
/**
|
||
* @brief Bind texture to texture unit
|
||
* @param unit Texture unit (0-31)
|
||
*/
|
||
void bind(int unit = 0) const;
|
||
|
||
/**
|
||
* @brief Unbind texture
|
||
*/
|
||
void unbind() const;
|
||
|
||
/**
|
||
* @brief Set texture filtering
|
||
* @param min_filter Minification filter
|
||
* @param mag_filter Magnification filter
|
||
*/
|
||
void set_filter(TextureFilter min_filter, TextureFilter mag_filter);
|
||
|
||
/**
|
||
* @brief Set texture wrapping
|
||
* @param wrap_s S-axis wrapping
|
||
* @param wrap_t T-axis wrapping
|
||
*/
|
||
void set_wrap(TextureWrap wrap_s, TextureWrap wrap_t);
|
||
|
||
/**
|
||
* @brief Generate mipmaps
|
||
*/
|
||
void generate_mipmaps();
|
||
|
||
// Getters
|
||
uint32_t get_id() const { return texture_id_; }
|
||
int get_width() const { return width_; }
|
||
int get_height() const { return height_; }
|
||
TextureFormat get_format() const { return format_; }
|
||
bool is_valid() const { return texture_id_ != 0; }
|
||
|
||
/**
|
||
* @brief Delete texture
|
||
*/
|
||
void destroy();
|
||
|
||
private:
|
||
uint32_t texture_id_; ///< OpenGL texture ID
|
||
int width_; ///< Texture width
|
||
int height_; ///< Texture height
|
||
TextureFormat format_; ///< Texture format
|
||
};
|
||
|
||
} // namespace are
|
||
|
||
#endif // ARE_INCLUDE_TEXTURE_TEXTURE_H
|
||
```
|
||
|
||
### 文件：include/are/texture/texture_manager.h
|
||
|
||
```cpp
|
||
/**
|
||
* @file texture_manager.h
|
||
* @brief Texture resource management and caching
|
||
*/
|
||
|
||
#ifndef ARE_INCLUDE_TEXTURE_TEXTURE_MANAGER_H
|
||
#define ARE_INCLUDE_TEXTURE_TEXTURE_MANAGER_H
|
||
|
||
#include <are/core/types.h>
|
||
#include <are/texture/texture.h>
|
||
#include <string>
|
||
#include <unordered_map>
|
||
#include <memory>
|
||
|
||
namespace are {
|
||
|
||
/**
|
||
* @class TextureManager
|
||
* @brief Manages texture loading and caching
|
||
*
|
||
* Automatically handles texture deduplication and lifetime management.
|
||
*/
|
||
class TextureManager {
|
||
public:
|
||
/**
|
||
* @brief Constructor
|
||
*/
|
||
TextureManager();
|
||
|
||
/**
|
||
* @brief Destructor
|
||
*/
|
||
~TextureManager();
|
||
|
||
/**
|
||
* @brief Load texture from file (with caching)
|
||
* @param filepath Texture file path
|
||
* @param format Desired texture format
|
||
* @param generate_mipmaps Generate mipmaps
|
||
* @return Texture handle (are_invalid_handle if failed)
|
||
*/
|
||
TextureHandle load_texture(const std::string& filepath,
|
||
TextureFormat format = TextureFormat::ARE_TEXTURE_RGBA8,
|
||
bool generate_mipmaps = true);
|
||
|
||
/**
|
||
* @brief Create texture from raw data
|
||
* @param name Texture name (for caching)
|
||
* @param width Texture width
|
||
* @param height Texture height
|
||
* @param format Texture format
|
||
* @param data Pixel data
|
||
* @param generate_mipmaps Generate mipmaps
|
||
* @return Texture handle
|
||
*/
|
||
TextureHandle create_texture(const std::string& name,
|
||
int width, int height,
|
||
TextureFormat format,
|
||
const void* data,
|
||
bool generate_mipmaps = true);
|
||
|
||
/**
|
||
* @brief Get texture by handle
|
||
* @param handle Texture handle
|
||
* @return Texture pointer (nullptr if not found)
|
||
*/
|
||
Texture* get_texture(TextureHandle handle);
|
||
const Texture* get_texture(TextureHandle handle) const;
|
||
|
||
/**
|
||
* @brief Unload texture
|
||
* @param handle Texture handle
|
||
*/
|
||
void unload_texture(TextureHandle handle);
|
||
|
||
/**
|
||
* @brief Clear all textures
|
||
*/
|
||
void clear();
|
||
|
||
/**
|
||
* @brief Get total texture memory usage
|
||
* @return Memory usage in bytes
|
||
*/
|
||
size_t get_memory_usage() const;
|
||
|
||
/**
|
||
* @brief Get number of loaded textures
|
||
* @return Texture count
|
||
*/
|
||
size_t get_texture_count() const { return textures_.size(); }
|
||
|
||
private:
|
||
std::unordered_map<std::string, TextureHandle> path_to_handle_;
|
||
std::unordered_map<TextureHandle, std::unique_ptr<Texture>> textures_;
|
||
TextureHandle next_handle_;
|
||
};
|
||
|
||
} // namespace are
|
||
|
||
#endif // ARE_INCLUDE_TEXTURE_TEXTURE_MANAGER_H
|
||
```
|
||
|
||
### 文件：include/are/texture/sampler.h
|
||
|
||
```cpp
|
||
/**
|
||
* @file sampler.h
|
||
* @brief Texture sampling utilities
|
||
*/
|
||
|
||
#ifndef ARE_INCLUDE_TEXTURE_SAMPLER_H
|
||
#define ARE_INCLUDE_TEXTURE_SAMPLER_H
|
||
|
||
#include <are/core/types.h>
|
||
|
||
namespace are {
|
||
|
||
// Forward declaration
|
||
class Texture;
|
||
class TextureWrap;
|
||
|
||
/**
|
||
* @class Sampler
|
||
* @brief Texture sampling utilities for CPU ray tracing
|
||
*
|
||
* Provides bilinear filtering and wrapping modes for CPU-side texture access.
|
||
*/
|
||
class Sampler {
|
||
public:
|
||
/**
|
||
* @brief Sample texture at UV coordinates
|
||
* @param texture Texture to sample
|
||
* @param uv UV coordinates
|
||
* @return Sampled color (RGBA)
|
||
*/
|
||
static Vec4 sample(const Texture& texture, const Vec2& uv);
|
||
|
||
/**
|
||
* @brief Sample texture with bilinear filtering
|
||
* @param texture Texture to sample
|
||
* @param uv UV coordinates
|
||
* @return Sampled color (RGBA)
|
||
*/
|
||
static Vec4 sample_bilinear(const Texture& texture, const Vec2& uv);
|
||
|
||
/**
|
||
* @brief Sample texture at nearest pixel
|
||
* @param texture Texture to sample
|
||
* @param uv UV coordinates
|
||
* @return Sampled color (RGBA)
|
||
*/
|
||
static Vec4 sample_nearest(const Texture& texture, const Vec2& uv);
|
||
|
||
private:
|
||
static Vec2 apply_wrap(const Vec2& uv, TextureWrap wrap);
|
||
};
|
||
|
||
} // namespace are
|
||
|
||
#endif // ARE_INCLUDE_TEXTURE_SAMPLER_H
|
||
```
|
||
|
||
接下来我再给你一个项目中的.cpp文件，让你熟悉错误处理和日志输出等信息：
|
||
### 文件：src/utils/image_io.cpp
|
||
```cpp
|
||
/**
|
||
* @file image_io.cpp
|
||
* @brief Implementation of image I/O utilities
|
||
*/
|
||
|
||
#include <are/utils/image_io.h>
|
||
#include <are/core/logger.h>
|
||
#include <cstring>
|
||
#include <algorithm>
|
||
#include <string>
|
||
#include <fstream>
|
||
|
||
#define STB_IMAGE_IMPLEMENTATION
|
||
#include <stb_image.h>
|
||
|
||
#define STB_IMAGE_WRITE_IMPLEMENTATION
|
||
#include <stb_image_write.h>
|
||
|
||
namespace are {
|
||
|
||
bool ImageData::is_valid() const {
|
||
return width_ > 0 && height_ > 0 && channels_ > 0 && !data_.empty();
|
||
}
|
||
|
||
const uint8_t* ImageData::get_pixel(int x, int y) const {
|
||
if (x < 0 || x >= width_ || y < 0 || y >= height_) {
|
||
return nullptr;
|
||
}
|
||
|
||
size_t index = (y * width_ + x) * channels_;
|
||
return &data_[index];
|
||
}
|
||
|
||
void ImageData::set_pixel(int x, int y, uint8_t r, uint8_t g, uint8_t b, uint8_t a) {
|
||
if (x < 0 || x >= width_ || y < 0 || y >= height_) {
|
||
return;
|
||
}
|
||
|
||
size_t index = (y * width_ + x) * channels_;
|
||
|
||
data_[index + 0] = r;
|
||
data_[index + 1] = g;
|
||
data_[index + 2] = b;
|
||
|
||
if (channels_ == 4) {
|
||
data_[index + 3] = a;
|
||
}
|
||
}
|
||
|
||
ImageData load_image(const std::string& filename, bool flip_vertically) {
|
||
ImageData image;
|
||
|
||
// Set flip flag
|
||
stbi_set_flip_vertically_on_load(flip_vertically ? 1 : 0);
|
||
|
||
// Load image
|
||
int width, height, channels;
|
||
unsigned char* data = stbi_load(filename.c_str(), &width, &height, &channels, 0);
|
||
|
||
if (!data) {
|
||
ARE_LOG_ERROR("Failed to load image: " + filename + " - " + stbi_failure_reason());
|
||
return image;
|
||
}
|
||
|
||
// Copy data to ImageData
|
||
image.width_ = width;
|
||
image.height_ = height;
|
||
image.channels_ = channels;
|
||
|
||
size_t data_size = width * height * channels;
|
||
image.data_.resize(data_size);
|
||
std::memcpy(image.data_.data(), data, data_size);
|
||
|
||
// Free stb_image data
|
||
stbi_image_free(data);
|
||
|
||
ARE_LOG_INFO("Loaded image: " + filename + " (" +
|
||
std::to_string(width) + "x" + std::to_string(height) +
|
||
", " + std::to_string(channels) + " channels)");
|
||
|
||
return image;
|
||
}
|
||
|
||
ImageFormat detect_format(const std::string& filename) {
|
||
std::string ext;
|
||
size_t dot_pos = filename.find_last_of('.');
|
||
|
||
if (dot_pos != std::string::npos) {
|
||
ext = filename.substr(dot_pos + 1);
|
||
|
||
// Convert to lowercase
|
||
std::transform(ext.begin(), ext.end(), ext.begin(),
|
||
[](unsigned char c) { return std::tolower(c); });
|
||
}
|
||
|
||
if (ext == "ppm") return ImageFormat::ARE_IMAGE_FORMAT_PPM;
|
||
if (ext == "bmp") return ImageFormat::ARE_IMAGE_FORMAT_BMP;
|
||
if (ext == "png") return ImageFormat::ARE_IMAGE_FORMAT_PNG;
|
||
if (ext == "jpg" || ext == "jpeg") return ImageFormat::ARE_IMAGE_FORMAT_JPG;
|
||
|
||
// Default to PNG
|
||
return ImageFormat::ARE_IMAGE_FORMAT_PNG;
|
||
}
|
||
|
||
bool save_image(const std::string& filename, const ImageData& data, ImageFormat format) {
|
||
if (!data.is_valid()) {
|
||
ARE_LOG_ERROR("Cannot save invalid image data");
|
||
return false;
|
||
}
|
||
|
||
// Auto-detect format if not specified
|
||
if (format == ImageFormat::ARE_IMAGE_FORMAT_PNG) {
|
||
format = detect_format(filename);
|
||
}
|
||
|
||
int result = 0;
|
||
|
||
switch (format) {
|
||
case ImageFormat::ARE_IMAGE_FORMAT_PPM: {
|
||
// Write PPM manually (stb doesn't support it)
|
||
std::ofstream file(filename, std::ios::binary);
|
||
if (!file.is_open()) {
|
||
ARE_LOG_ERROR("Failed to open file for writing: " + filename);
|
||
return false;
|
||
}
|
||
|
||
file << "P6\n" << data.width_ << " " << data.height_ << "\n255\n";
|
||
|
||
for (int i = 0; i < data.width_ * data.height_; ++i) {
|
||
int idx = i * data.channels_;
|
||
file.put(data.data_[idx + 0]); // R
|
||
file.put(data.data_[idx + 1]); // G
|
||
file.put(data.data_[idx + 2]); // B
|
||
}
|
||
|
||
file.close();
|
||
result = 1;
|
||
break;
|
||
}
|
||
|
||
case ImageFormat::ARE_IMAGE_FORMAT_BMP:
|
||
result = stbi_write_bmp(filename.c_str(), data.width_, data.height_,
|
||
data.channels_, data.data_.data());
|
||
break;
|
||
|
||
case ImageFormat::ARE_IMAGE_FORMAT_PNG:
|
||
result = stbi_write_png(filename.c_str(), data.width_, data.height_,
|
||
data.channels_, data.data_.data(),
|
||
data.width_ * data.channels_);
|
||
break;
|
||
|
||
case ImageFormat::ARE_IMAGE_FORMAT_JPG:
|
||
result = stbi_write_jpg(filename.c_str(), data.width_, data.height_,
|
||
data.channels_, data.data_.data(), 90);
|
||
break;
|
||
}
|
||
|
||
if (result == 0) {
|
||
ARE_LOG_ERROR("Failed to save image: " + filename);
|
||
return false;
|
||
}
|
||
|
||
ARE_LOG_INFO("Saved image: " + filename);
|
||
return true;
|
||
}
|
||
|
||
bool save_image(const std::string& filename, const uint8_t* pixels,
|
||
int width, int height, int channels, ImageFormat format) {
|
||
ImageData data;
|
||
data.width_ = width;
|
||
data.height_ = height;
|
||
data.channels_ = channels;
|
||
|
||
size_t data_size = width * height * channels;
|
||
data.data_.resize(data_size);
|
||
std::memcpy(data.data_.data(), pixels, data_size);
|
||
|
||
return save_image(filename, data, format);
|
||
}
|
||
|
||
} // namespace are
|
||
```
|
||
哦对了，这是我们现在的CMakeLists.txt，你可以在编写完这个模块之后编写cornell_box的测试代码和独属于Phase 5的测试代码（在CPU光追效率太低的时候使用）：
|
||
```CMakeLists.txt
|
||
cmake_minimum_required(VERSION 3.15)
|
||
project(AuroraRenderingEngine VERSION 0.1.0 LANGUAGES CXX C)
|
||
|
||
# Set C++ standard
|
||
set(CMAKE_CXX_STANDARD 17)
|
||
set(CMAKE_CXX_STANDARD_REQUIRED ON)
|
||
set(CMAKE_CXX_EXTENSIONS OFF)
|
||
|
||
# Set C standard for GLAD
|
||
set(CMAKE_C_STANDARD 99)
|
||
set(CMAKE_C_STANDARD_REQUIRED ON)
|
||
|
||
# Build options
|
||
option(ARE_BUILD_SHARED "Build shared library" OFF)
|
||
option(ARE_BUILD_EXAMPLES "Build example programs" ON)
|
||
option(ARE_ENABLE_PROFILING "Enable performance profiling" ON)
|
||
option(ARE_ENABLE_DEBUG_VIS "Enable debug visualization" ON)
|
||
|
||
# Set output directories
|
||
set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/lib)
|
||
set(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/lib)
|
||
set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin)
|
||
|
||
# Compiler flags
|
||
if(MSVC)
|
||
add_compile_options(/W4)
|
||
add_compile_definitions(_CRT_SECURE_NO_WARNINGS)
|
||
# Disable specific warnings that are too strict
|
||
add_compile_options(/wd4100) # unreferenced formal parameter
|
||
else()
|
||
add_compile_options(-Wall -Wextra -pedantic)
|
||
# Disable specific warnings
|
||
add_compile_options(-Wno-unused-parameter)
|
||
endif()
|
||
|
||
# Find required packages
|
||
find_package(OpenGL REQUIRED)
|
||
find_package(glfw3 REQUIRED)
|
||
find_package(glm REQUIRED)
|
||
|
||
# Try to find spdlog (system installation)
|
||
find_package(spdlog QUIET)
|
||
|
||
if(NOT spdlog_FOUND)
|
||
message(STATUS "spdlog not found in system, using local version")
|
||
# Use local spdlog
|
||
set(SPDLOG_INCLUDE_DIR "${CMAKE_SOURCE_DIR}/lib/spdlog/include")
|
||
if(NOT EXISTS ${SPDLOG_INCLUDE_DIR})
|
||
message(FATAL_ERROR "spdlog not found. Please install spdlog or place it in lib/spdlog/")
|
||
endif()
|
||
add_library(spdlog INTERFACE)
|
||
target_include_directories(spdlog INTERFACE ${SPDLOG_INCLUDE_DIR})
|
||
# spdlog compile definitions
|
||
target_compile_definitions(spdlog INTERFACE SPDLOG_COMPILED_LIB)
|
||
endif()
|
||
|
||
# Find OpenMP (optional)
|
||
find_package(OpenMP)
|
||
if(OpenMP_CXX_FOUND)
|
||
set(ARE_USE_OPENMP ON)
|
||
add_compile_definitions(ARE_USE_OPENMP)
|
||
message(STATUS "OpenMP found and enabled")
|
||
else()
|
||
message(STATUS "OpenMP not found, multithreading will use std::thread")
|
||
endif()
|
||
|
||
# GLAD library path
|
||
set(GLAD_INCLUDE_DIR "${CMAKE_SOURCE_DIR}/lib/glad")
|
||
set(GLAD_SOURCE_DIR "${CMAKE_SOURCE_DIR}/lib/glad")
|
||
|
||
if(NOT EXISTS ${GLAD_INCLUDE_DIR})
|
||
message(FATAL_ERROR "GLAD include directory not found: ${GLAD_INCLUDE_DIR}")
|
||
endif()
|
||
|
||
if(NOT EXISTS ${GLAD_SOURCE_DIR})
|
||
message(FATAL_ERROR "GLAD source directory not found: ${GLAD_SOURCE_DIR}")
|
||
endif()
|
||
|
||
# STB library path
|
||
set(STB_INCLUDE_DIR "${CMAKE_SOURCE_DIR}/lib/stb")
|
||
|
||
if(NOT EXISTS ${STB_INCLUDE_DIR})
|
||
message(FATAL_ERROR "STB include directory not found: ${STB_INCLUDE_DIR}")
|
||
endif()
|
||
|
||
# Collect all source files from src/
|
||
file(GLOB_RECURSE ARE_SOURCES
|
||
"${CMAKE_SOURCE_DIR}/src/*.cpp"
|
||
"${CMAKE_SOURCE_DIR}/src/*.c"
|
||
)
|
||
|
||
# Collect all GLAD source files
|
||
file(GLOB GLAD_SOURCES
|
||
"${GLAD_SOURCE_DIR}/*.c"
|
||
)
|
||
|
||
# Add GLAD sources to ARE sources
|
||
list(APPEND ARE_SOURCES ${GLAD_SOURCES})
|
||
|
||
# Collect all header files
|
||
file(GLOB_RECURSE ARE_HEADERS
|
||
"${CMAKE_SOURCE_DIR}/include/*.h"
|
||
"${CMAKE_SOURCE_DIR}/include/*.hpp"
|
||
)
|
||
|
||
# Create library
|
||
if(ARE_BUILD_SHARED)
|
||
add_library(are SHARED ${ARE_SOURCES} ${ARE_HEADERS})
|
||
target_compile_definitions(are PRIVATE ARE_BUILD_SHARED)
|
||
message(STATUS "Building shared library")
|
||
else()
|
||
add_library(are STATIC ${ARE_SOURCES} ${ARE_HEADERS})
|
||
message(STATUS "Building static library")
|
||
endif()
|
||
|
||
# Set target properties
|
||
set_target_properties(are PROPERTIES
|
||
VERSION ${PROJECT_VERSION}
|
||
SOVERSION ${PROJECT_VERSION_MAJOR}
|
||
PUBLIC_HEADER "${ARE_HEADERS}"
|
||
)
|
||
|
||
# Include directories
|
||
target_include_directories(are
|
||
PUBLIC
|
||
$<BUILD_INTERFACE:${CMAKE_SOURCE_DIR}/include>
|
||
$<INSTALL_INTERFACE:include>
|
||
PRIVATE
|
||
${CMAKE_SOURCE_DIR}/src
|
||
${GLAD_INCLUDE_DIR}
|
||
${STB_INCLUDE_DIR}
|
||
)
|
||
|
||
# Link libraries
|
||
target_link_libraries(are
|
||
PUBLIC
|
||
OpenGL::GL
|
||
glfw
|
||
glm::glm
|
||
)
|
||
|
||
# Link spdlog
|
||
if(spdlog_FOUND)
|
||
target_link_libraries(are PUBLIC spdlog::spdlog)
|
||
else()
|
||
target_link_libraries(are PUBLIC spdlog)
|
||
target_include_directories(are PRIVATE ${SPDLOG_INCLUDE_DIR})
|
||
endif()
|
||
|
||
# Link OpenMP if available
|
||
if(OpenMP_CXX_FOUND)
|
||
target_link_libraries(are PUBLIC OpenMP::OpenMP_CXX)
|
||
endif()
|
||
|
||
# Platform-specific libraries
|
||
if(UNIX AND NOT APPLE)
|
||
target_link_libraries(are PUBLIC dl pthread)
|
||
endif()
|
||
|
||
# Compile definitions
|
||
if(ARE_ENABLE_PROFILING)
|
||
target_compile_definitions(are PUBLIC ARE_ENABLE_PROFILING)
|
||
message(STATUS "Profiling enabled")
|
||
endif()
|
||
|
||
if(ARE_ENABLE_DEBUG_VIS)
|
||
target_compile_definitions(are PUBLIC ARE_ENABLE_DEBUG_VIS)
|
||
message(STATUS "Debug visualization enabled")
|
||
endif()
|
||
|
||
# Build examples
|
||
if(ARE_BUILD_EXAMPLES)
|
||
# Define helper function for creating examples
|
||
function(add_are_example EXAMPLE_NAME)
|
||
add_executable(${EXAMPLE_NAME} ${ARGN})
|
||
target_link_libraries(${EXAMPLE_NAME} PRIVATE are)
|
||
set_target_properties(${EXAMPLE_NAME} PROPERTIES
|
||
RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin
|
||
)
|
||
endfunction()
|
||
|
||
# Add example subdirectories
|
||
add_subdirectory(examples/00_phase1_test)
|
||
add_subdirectory(examples/01_phase2_test)
|
||
add_subdirectory(examples/02_visual_test)
|
||
add_subdirectory(examples/02_phase3_test)
|
||
add_subdirectory(examples/03_phase4_test)
|
||
|
||
message(STATUS "Examples will be built")
|
||
endif()
|
||
|
||
# Installation rules
|
||
install(TARGETS are
|
||
ARCHIVE DESTINATION lib
|
||
LIBRARY DESTINATION lib
|
||
RUNTIME DESTINATION bin
|
||
PUBLIC_HEADER DESTINATION include/are
|
||
)
|
||
|
||
install(DIRECTORY ${CMAKE_SOURCE_DIR}/include/are
|
||
DESTINATION include
|
||
FILES_MATCHING PATTERN "*.h" PATTERN "*.hpp"
|
||
)
|
||
|
||
install(DIRECTORY ${CMAKE_SOURCE_DIR}/shaders
|
||
DESTINATION share/are/shaders
|
||
)
|
||
|
||
# Print configuration summary
|
||
message(STATUS "")
|
||
message(STATUS "========================================")
|
||
message(STATUS "Aurora Rendering Engine Configuration")
|
||
message(STATUS "========================================")
|
||
message(STATUS " Version: ${PROJECT_VERSION}")
|
||
message(STATUS " Build type: ${CMAKE_BUILD_TYPE}")
|
||
message(STATUS " Library type: ${ARE_BUILD_SHARED}")
|
||
message(STATUS " C++ standard: ${CMAKE_CXX_STANDARD}")
|
||
message(STATUS " Compiler: ${CMAKE_CXX_COMPILER_ID} ${CMAKE_CXX_COMPILER_VERSION}")
|
||
message(STATUS "")
|
||
message(STATUS "Features:")
|
||
message(STATUS " OpenMP support: ${ARE_USE_OPENMP}")
|
||
message(STATUS " Build examples: ${ARE_BUILD_EXAMPLES}")
|
||
message(STATUS " Enable profiling: ${ARE_ENABLE_PROFILING}")
|
||
message(STATUS " Enable debug vis: ${ARE_ENABLE_DEBUG_VIS}")
|
||
message(STATUS "")
|
||
message(STATUS "Dependencies:")
|
||
message(STATUS " OpenGL: ${OPENGL_LIBRARIES}")
|
||
message(STATUS " GLFW: Found")
|
||
message(STATUS " GLM: Found")
|
||
if(spdlog_FOUND)
|
||
message(STATUS " spdlog: Found (system)")
|
||
else()
|
||
message(STATUS " spdlog: Found (local)")
|
||
endif()
|
||
message(STATUS " GLAD: ${GLAD_INCLUDE_DIR}")
|
||
message(STATUS " STB: ${STB_INCLUDE_DIR}")
|
||
message(STATUS "")
|
||
message(STATUS "Output directories:")
|
||
message(STATUS " Executables: ${CMAKE_BINARY_DIR}/bin")
|
||
message(STATUS " Libraries: ${CMAKE_BINARY_DIR}/lib")
|
||
message(STATUS "========================================")
|
||
message(STATUS "")
|
||
```
|
||
|
||
目前你只需要实现Phase 5所要求的文件即可，其他大部分模块已经实现。
|