1763 lines
45 KiB
Markdown
1763 lines
45 KiB
Markdown
### 文件：include/basic/types.h
|
||
|
||
```cpp
|
||
#ifndef ARE_INCLUDE_BASIC_TYPES_H
|
||
#define ARE_INCLUDE_BASIC_TYPES_H
|
||
|
||
#include <cstdint>
|
||
#include <memory>
|
||
#include <vector>
|
||
#include <string>
|
||
#include <glm/glm.hpp>
|
||
|
||
namespace are {
|
||
|
||
/// @brief Basic vector types using GLM
|
||
using Vec2 = glm::vec2;
|
||
using Vec3 = glm::vec3;
|
||
using Vec4 = glm::vec4;
|
||
|
||
/// @brief Basic matrix types using GLM
|
||
using Mat3 = glm::mat3;
|
||
using Mat4 = glm::mat4;
|
||
|
||
/// @brief Basic integer types
|
||
using uint = uint32_t;
|
||
using uchar = uint8_t;
|
||
|
||
/// @brief Handle types for GPU resources
|
||
using TextureHandle = uint;
|
||
using BufferHandle = uint;
|
||
using ShaderHandle = uint;
|
||
using FramebufferHandle = uint;
|
||
|
||
/// @brief Invalid handle constant
|
||
constexpr uint INVALID_HANDLE = 0;
|
||
|
||
/// @brief Vertex structure for mesh data
|
||
struct Vertex {
|
||
Vec3 position_;
|
||
Vec3 normal_;
|
||
Vec2 texcoord_;
|
||
Vec3 tangent_;
|
||
};
|
||
|
||
/// @brief Ray structure for ray tracing
|
||
struct Ray {
|
||
Vec3 origin_;
|
||
Vec3 direction_;
|
||
float t_min_;
|
||
float t_max_;
|
||
};
|
||
|
||
/// @brief Hit information for ray-surface intersection
|
||
struct HitInfo {
|
||
bool hit_;
|
||
float t_;
|
||
Vec3 position_;
|
||
Vec3 normal_;
|
||
Vec2 texcoord_;
|
||
uint material_id_;
|
||
};
|
||
|
||
/// @brief Rendering statistics
|
||
struct RenderStats {
|
||
float frame_time_ms_;
|
||
uint triangle_count_;
|
||
uint ray_count_;
|
||
float gbuffer_time_ms_;
|
||
float raytrace_time_ms_;
|
||
};
|
||
|
||
} // namespace are
|
||
|
||
#endif // ARE_INCLUDE_BASIC_TYPES_H
|
||
```
|
||
|
||
### 文件：include/basic/constants.h
|
||
|
||
```cpp
|
||
#ifndef ARE_INCLUDE_BASIC_CONSTANTS_H
|
||
#define ARE_INCLUDE_BASIC_CONSTANTS_H
|
||
|
||
namespace are {
|
||
|
||
/// @brief Maximum number of lights in scene
|
||
constexpr int MAX_LIGHTS = 16;
|
||
|
||
/// @brief Maximum ray tracing depth
|
||
constexpr int MAX_RAY_DEPTH = 8;
|
||
|
||
/// @brief Default samples per pixel for ray tracing
|
||
constexpr int DEFAULT_SPP = 1;
|
||
|
||
/// @brief G-Buffer attachment indices
|
||
constexpr int GBUFFER_POSITION = 0;
|
||
constexpr int GBUFFER_NORMAL = 1;
|
||
constexpr int GBUFFER_ALBEDO = 2;
|
||
constexpr int GBUFFER_COUNT = 3;
|
||
|
||
/// @brief Compute shader work group size
|
||
constexpr int COMPUTE_GROUP_SIZE_X = 16;
|
||
constexpr int COMPUTE_GROUP_SIZE_Y = 16;
|
||
|
||
/// @brief Mathematical constants
|
||
constexpr float PI = 3.14159265359f;
|
||
constexpr float INV_PI = 0.31830988618f;
|
||
constexpr float EPSILON = 1e-4f;
|
||
|
||
} // namespace are
|
||
|
||
#endif // ARE_INCLUDE_BASIC_CONSTANTS_H
|
||
```
|
||
|
||
### 文件：include/basic/math.h
|
||
|
||
```cpp
|
||
#ifndef ARE_INCLUDE_BASIC_MATH_UTILS_H
|
||
#define ARE_INCLUDE_BASIC_MATH_UTILS_H
|
||
|
||
#include "types.h"
|
||
#include <glm/gtc/matrix_transform.hpp>
|
||
#include <glm/gtc/type_ptr.hpp>
|
||
|
||
namespace are {
|
||
|
||
/// @brief Math utility functions wrapping GLM
|
||
class MathUtils {
|
||
public:
|
||
/// @brief Create perspective projection matrix
|
||
/// @param fov Field of view in radians
|
||
/// @param aspect Aspect ratio
|
||
/// @param near Near plane distance
|
||
/// @param far Far plane distance
|
||
/// @return Projection matrix
|
||
static Mat4 perspective(float fov, float aspect, float near, float far);
|
||
|
||
/// @brief Create look-at view matrix
|
||
/// @param eye Camera position
|
||
/// @param center Look-at target
|
||
/// @param up Up vector
|
||
/// @return View matrix
|
||
static Mat4 look_at(const Vec3& eye, const Vec3& center, const Vec3& up);
|
||
|
||
/// @brief Normalize a vector
|
||
/// @param v Input vector
|
||
/// @return Normalized vector
|
||
static Vec3 normalize(const Vec3& v);
|
||
|
||
/// @brief Calculate dot product
|
||
/// @param a First vector
|
||
/// @param b Second vector
|
||
/// @return Dot product
|
||
static float dot(const Vec3& a, const Vec3& b);
|
||
|
||
/// @brief Calculate cross product
|
||
/// @param a First vector
|
||
/// @param b Second vector
|
||
/// @return Cross product
|
||
static Vec3 cross(const Vec3& a, const Vec3& b);
|
||
|
||
/// @brief Reflect vector around normal
|
||
/// @param incident Incident vector
|
||
/// @param normal Surface normal
|
||
/// @return Reflected vector
|
||
static Vec3 reflect(const Vec3& incident, const Vec3& normal);
|
||
|
||
/// @brief Get pointer to matrix data (for OpenGL)
|
||
/// @param mat Input matrix
|
||
/// @return Pointer to matrix data
|
||
static const float* value_ptr(const Mat4& mat);
|
||
};
|
||
|
||
} // namespace are
|
||
|
||
#endif // ARE_INCLUDE_BASIC_MATH_UTILS_H
|
||
```
|
||
|
||
### 文件：include/core/bvh.h
|
||
|
||
```cpp
|
||
#ifndef ARE_INCLUDE_CORE_BVH_H
|
||
#define ARE_INCLUDE_CORE_BVH_H
|
||
|
||
#include "basic/types.h"
|
||
#include "scene/mesh.h"
|
||
#include "resource/buffer.h"
|
||
#include <vector>
|
||
#include <memory>
|
||
|
||
namespace are {
|
||
|
||
/// @brief Axis-aligned bounding box
|
||
struct AABB {
|
||
Vec3 min_;
|
||
Vec3 max_;
|
||
|
||
/// @brief Construct AABB from min and max points
|
||
AABB(const Vec3& min = Vec3(0.0f), const Vec3& max = Vec3(0.0f))
|
||
: min_(min), max_(max) {}
|
||
|
||
/// @brief Expand AABB to include point
|
||
void expand(const Vec3& point);
|
||
|
||
/// @brief Expand AABB to include another AABB
|
||
void expand(const AABB& other);
|
||
|
||
/// @brief Get center of AABB
|
||
Vec3 center() const { return (min_ + max_) * 0.5f; }
|
||
|
||
/// @brief Get surface area of AABB
|
||
float surface_area() const;
|
||
|
||
/// @brief Check if AABB is valid
|
||
bool is_valid() const;
|
||
};
|
||
|
||
/// @brief Triangle primitive for BVH
|
||
struct Triangle {
|
||
Vec3 v0_, v1_, v2_;
|
||
Vec3 n0_, n1_, n2_;
|
||
Vec2 uv0_, uv1_, uv2_;
|
||
uint material_id_;
|
||
|
||
/// @brief Get bounding box of triangle
|
||
AABB get_bounds() const;
|
||
|
||
/// @brief Get centroid of triangle
|
||
Vec3 get_centroid() const;
|
||
};
|
||
|
||
/// @brief BVH node for GPU
|
||
struct BVHNode {
|
||
Vec3 aabb_min_;
|
||
uint left_first_; // Left child index or first primitive index
|
||
Vec3 aabb_max_;
|
||
uint count_; // 0 for interior node, >0 for leaf node
|
||
};
|
||
|
||
/// @brief Bounding Volume Hierarchy for ray tracing acceleration
|
||
class BVH {
|
||
public:
|
||
/// @brief Constructor
|
||
BVH();
|
||
|
||
/// @brief Destructor
|
||
~BVH();
|
||
|
||
/// @brief Build BVH from meshes
|
||
/// @param meshes Mesh list
|
||
/// @return True if build succeeded
|
||
bool build(const std::vector<std::shared_ptr<Mesh>>& meshes);
|
||
|
||
/// @brief Upload BVH to GPU
|
||
/// @param node_buffer Buffer for BVH nodes
|
||
/// @param triangle_buffer Buffer for triangles
|
||
/// @return True if upload succeeded
|
||
bool upload_to_gpu(Buffer& node_buffer, Buffer& triangle_buffer);
|
||
|
||
/// @brief Get total node count
|
||
/// @return Node count
|
||
uint get_node_count() const { return static_cast<uint>(nodes_.size()); }
|
||
|
||
/// @brief Get total triangle count
|
||
/// @return Triangle count
|
||
uint get_triangle_count() const { return static_cast<uint>(triangles_.size()); }
|
||
|
||
/// @brief Clear BVH data
|
||
void clear();
|
||
|
||
private:
|
||
std::vector<BVHNode> nodes_;
|
||
std::vector<Triangle> triangles_;
|
||
std::vector<uint> triangle_indices_;
|
||
|
||
/// @brief Recursively build BVH
|
||
/// @param node_idx Current node index
|
||
/// @param first_prim First primitive index
|
||
/// @param prim_count Primitive count
|
||
void build_recursive_(uint node_idx, uint first_prim, uint prim_count);
|
||
|
||
/// @brief Find best split using SAH
|
||
/// @param first_prim First primitive index
|
||
/// @param prim_count Primitive count
|
||
/// @param axis Split axis (output)
|
||
/// @param split_pos Split position (output)
|
||
/// @return Split cost
|
||
float find_best_split_(uint first_prim, uint prim_count, int& axis, float& split_pos);
|
||
|
||
/// @brief Calculate node bounds
|
||
/// @param first_prim First primitive index
|
||
/// @param prim_count Primitive count
|
||
/// @return Bounding box
|
||
AABB calculate_bounds_(uint first_prim, uint prim_count);
|
||
|
||
/// @brief Calculate centroid bounds
|
||
/// @param first_prim First primitive index
|
||
/// @param prim_count Primitive count
|
||
/// @return Centroid bounding box
|
||
AABB calculate_centroid_bounds_(uint first_prim, uint prim_count);
|
||
};
|
||
|
||
} // namespace are
|
||
|
||
#endif // ARE_INCLUDE_CORE_BVH_H
|
||
```
|
||
|
||
### 文件：include/core/gbuffer.h
|
||
|
||
```cpp
|
||
#ifndef ARE_INCLUDE_CORE_GBUFFER_H
|
||
#define ARE_INCLUDE_CORE_GBUFFER_H
|
||
|
||
#include "basic/types.h"
|
||
#include "basic/constants.h"
|
||
#include "scene/scene.h"
|
||
#include "resource/shader.h"
|
||
|
||
namespace are {
|
||
|
||
/// @brief G-Buffer manager for deferred rendering
|
||
class GBuffer {
|
||
public:
|
||
/// @brief Constructor
|
||
/// @param width Buffer width
|
||
/// @param height Buffer height
|
||
GBuffer(uint width, uint height);
|
||
|
||
/// @brief Destructor
|
||
~GBuffer();
|
||
|
||
/// @brief Initialize G-Buffer (create framebuffer and textures)
|
||
/// @return True if initialization succeeded
|
||
bool initialize();
|
||
|
||
/// @brief Release G-Buffer resources
|
||
void release();
|
||
|
||
/// @brief Render scene to G-Buffer
|
||
/// @param scene Scene to render
|
||
/// @param shader Shader program for G-Buffer pass
|
||
void render(const Scene& scene, const Shader& shader);
|
||
|
||
/// @brief Resize G-Buffer
|
||
/// @param width New width
|
||
/// @param height New height
|
||
void resize(uint width, uint height);
|
||
|
||
/// @brief Get texture handle for specific buffer
|
||
/// @param index Buffer index (GBUFFER_POSITION, GBUFFER_NORMAL, etc.)
|
||
/// @return Texture handle
|
||
TextureHandle get_texture(int index) const;
|
||
|
||
/// @brief Get framebuffer handle
|
||
/// @return Framebuffer handle
|
||
FramebufferHandle get_framebuffer() const { return fbo_; }
|
||
|
||
/// @brief Get buffer dimensions
|
||
/// @param width Output width
|
||
/// @param height Output height
|
||
void get_dimensions(uint& width, uint& height) const;
|
||
|
||
private:
|
||
uint width_;
|
||
uint height_;
|
||
FramebufferHandle fbo_;
|
||
TextureHandle textures_[GBUFFER_COUNT];
|
||
TextureHandle depth_texture_;
|
||
|
||
bool initialized_;
|
||
|
||
/// @brief Create texture for G-Buffer attachment
|
||
/// @param internal_format OpenGL internal format
|
||
/// @param format OpenGL format
|
||
/// @param type OpenGL type
|
||
/// @return Texture handle
|
||
TextureHandle create_texture_(uint internal_format, uint format, uint type);
|
||
};
|
||
|
||
} // namespace are
|
||
|
||
#endif // ARE_INCLUDE_CORE_GBUFFER_H
|
||
```
|
||
|
||
### 文件：include/core/raytracer.h
|
||
|
||
```cpp
|
||
#ifndef ARE_INCLUDE_CORE_RAYTRACER_H
|
||
#define ARE_INCLUDE_CORE_RAYTRACER_H
|
||
|
||
#include "basic/types.h"
|
||
#include "core/bvh.h" // 添加
|
||
#include "core/gbuffer.h"
|
||
#include "resource/buffer.h"
|
||
#include "resource/shader.h"
|
||
#include "scene/scene.h"
|
||
|
||
namespace are {
|
||
|
||
/// @brief Ray tracing configuration
|
||
struct RayTracerConfig {
|
||
uint samples_per_pixel_;
|
||
uint max_depth_;
|
||
bool enable_shadows_;
|
||
bool enable_reflections_;
|
||
bool enable_accumulation_;
|
||
bool use_bvh_; // 添加BVH开关
|
||
};
|
||
|
||
/// @brief Compute shader based ray tracer
|
||
class RayTracer {
|
||
public:
|
||
/// @brief Constructor
|
||
/// @param width Output width
|
||
/// @param height Output height
|
||
/// @param config Ray tracer configuration
|
||
RayTracer(uint width, uint height, const RayTracerConfig &config);
|
||
|
||
/// @brief Destructor
|
||
~RayTracer();
|
||
|
||
/// @brief Initialize ray tracer
|
||
/// @return True if initialization succeeded
|
||
bool initialize();
|
||
|
||
/// @brief Release resources
|
||
void release();
|
||
|
||
/// @brief Trace rays using G-Buffer as input
|
||
/// @param scene Scene data
|
||
/// @param gbuffer G-Buffer containing geometry information
|
||
/// @param output_texture Output texture for ray traced result
|
||
void trace(const Scene &scene, const GBuffer &gbuffer, TextureHandle output_texture);
|
||
|
||
/// @brief Resize output
|
||
/// @param width New width
|
||
/// @param height New height
|
||
void resize(uint width, uint height);
|
||
|
||
/// @brief Reset accumulation buffer
|
||
void reset_accumulation();
|
||
|
||
/// @brief Get current configuration
|
||
/// @return Current configuration
|
||
const RayTracerConfig &get_config() const {
|
||
return config_;
|
||
}
|
||
|
||
/// @brief Update configuration
|
||
/// @param config New configuration
|
||
void set_config(const RayTracerConfig &config);
|
||
|
||
/// @brief Rebuild BVH from scene
|
||
/// @param scene Scene to build BVH from
|
||
/// @return True if build succeeded
|
||
bool rebuild_bvh(const Scene &scene);
|
||
|
||
/// @brief Set compute shader (called by renderer)
|
||
/// @param shader Compute shader
|
||
void set_compute_shader(const Shader &shader);
|
||
|
||
private:
|
||
uint width_;
|
||
uint height_;
|
||
RayTracerConfig config_;
|
||
|
||
Shader compute_shader_;
|
||
TextureHandle accumulation_texture_;
|
||
BufferHandle scene_buffer_;
|
||
BufferHandle material_buffer_;
|
||
BufferHandle light_buffer_;
|
||
|
||
// BVH related
|
||
std::unique_ptr<BVH> bvh_; // 添加
|
||
Buffer bvh_node_buffer_; // 添加
|
||
Buffer bvh_triangle_buffer_; // 添加
|
||
bool bvh_built_; // 添加
|
||
|
||
uint frame_count_;
|
||
bool initialized_;
|
||
|
||
/// @brief Upload scene data to GPU buffers
|
||
/// @param scene Scene to upload
|
||
void upload_scene_data_(const Scene &scene);
|
||
|
||
/// @brief Bind G-Buffer textures to compute shader
|
||
/// @param gbuffer G-Buffer to bind
|
||
void bind_gbuffer_(const GBuffer &gbuffer);
|
||
};
|
||
|
||
} // namespace are
|
||
|
||
#endif // ARE_INCLUDE_CORE_RAYTRACER_H
|
||
```
|
||
|
||
### 文件：include/core/renderer.h
|
||
|
||
```cpp
|
||
#ifndef ARE_INCLUDE_CORE_RENDERER_H
|
||
#define ARE_INCLUDE_CORE_RENDERER_H
|
||
|
||
#include "basic/types.h"
|
||
#include "scene/scene.h"
|
||
#include "core/gbuffer.h"
|
||
#include "core/raytracer.h"
|
||
#include "core/screen_blit.h"
|
||
#include "core/shader_manager.h"
|
||
#include <memory>
|
||
|
||
namespace are {
|
||
|
||
/// @brief Main renderer configuration
|
||
struct RendererConfig {
|
||
uint width_;
|
||
uint height_;
|
||
uint samples_per_pixel_;
|
||
uint max_ray_depth_;
|
||
bool enable_denoising_;
|
||
bool enable_accumulation_;
|
||
};
|
||
|
||
/// @brief Main rendering engine interface
|
||
class Renderer {
|
||
public:
|
||
/// @brief Constructor
|
||
/// @param config Renderer configuration
|
||
Renderer(const RendererConfig& config);
|
||
|
||
/// @brief Destructor
|
||
~Renderer();
|
||
|
||
/// @brief Initialize renderer (OpenGL context must be current)
|
||
/// @return True if initialization succeeded
|
||
bool initialize();
|
||
|
||
/// @brief Shutdown renderer and release resources
|
||
void shutdown();
|
||
|
||
/// @brief Render a frame
|
||
/// @param scene Scene to render
|
||
/// @param output_texture Output texture handle (0 for default framebuffer)
|
||
/// @return Rendering statistics
|
||
RenderStats render(const Scene& scene, TextureHandle output_texture = 0);
|
||
|
||
/// @brief Resize render targets
|
||
/// @param width New width
|
||
/// @param height New height
|
||
void resize(uint width, uint height);
|
||
|
||
/// @brief Get current configuration
|
||
/// @return Current configuration
|
||
const RendererConfig& get_config() const { return config_; }
|
||
|
||
/// @brief Update configuration
|
||
/// @param config New configuration
|
||
void set_config(const RendererConfig& config);
|
||
|
||
private:
|
||
RendererConfig config_;
|
||
std::unique_ptr<GBuffer> gbuffer_;
|
||
std::unique_ptr<RayTracer> raytracer_;
|
||
std::unique_ptr<ShaderManager> shader_manager_;
|
||
std::unique_ptr<ScreenBlit> screen_blit_;
|
||
|
||
bool initialized_;
|
||
uint frame_count_;
|
||
};
|
||
|
||
} // namespace are
|
||
|
||
#endif // ARE_INCLUDE_CORE_RENDERER_H
|
||
```
|
||
|
||
### 文件：include/core/screen_blit.h
|
||
|
||
```cpp
|
||
#ifndef ARE_INCLUDE_CORE_SCREEN_BLIT_H
|
||
#define ARE_INCLUDE_CORE_SCREEN_BLIT_H
|
||
|
||
#include "basic/types.h"
|
||
#include "resource/shader.h"
|
||
|
||
namespace are {
|
||
|
||
/// @brief Screen blit utility for rendering texture to screen
|
||
class ScreenBlit {
|
||
public:
|
||
/// @brief Constructor
|
||
ScreenBlit();
|
||
|
||
/// @brief Destructor
|
||
~ScreenBlit();
|
||
|
||
/// @brief Initialize screen blit
|
||
/// @return True if initialization succeeded
|
||
bool initialize();
|
||
|
||
/// @brief Release resources
|
||
void release();
|
||
|
||
/// @brief Blit texture to screen
|
||
/// @param texture Texture to blit
|
||
/// @param x Screen X position
|
||
/// @param y Screen Y position
|
||
/// @param width Blit width
|
||
/// @param height Blit height
|
||
void blit(TextureHandle texture, int x, int y, uint width, uint height);
|
||
|
||
/// @brief Blit texture to full screen
|
||
/// @param texture Texture to blit
|
||
void blit_fullscreen(TextureHandle texture);
|
||
|
||
private:
|
||
Shader shader_;
|
||
uint vao_;
|
||
uint vbo_;
|
||
bool initialized_;
|
||
|
||
/// @brief Create fullscreen quad
|
||
void create_quad_();
|
||
};
|
||
|
||
} // namespace are
|
||
|
||
#endif // ARE_INCLUDE_CORE_SCREEN_BLIT_H
|
||
```
|
||
|
||
### 文件：include/core/shader_manager.h
|
||
|
||
```cpp
|
||
#ifndef ARE_INCLUDE_CORE_SHADER_MANAGER_H
|
||
#define ARE_INCLUDE_CORE_SHADER_MANAGER_H
|
||
|
||
#include "basic/types.h"
|
||
#include "resource/shader.h"
|
||
#include <unordered_map>
|
||
#include <string>
|
||
|
||
namespace are {
|
||
|
||
/// @brief Shader manager for loading and caching shaders
|
||
class ShaderManager {
|
||
public:
|
||
/// @brief Constructor
|
||
ShaderManager();
|
||
|
||
/// @brief Destructor
|
||
~ShaderManager();
|
||
|
||
/// @brief Initialize shader manager and load built-in shaders
|
||
/// @return True if initialization succeeded
|
||
bool initialize();
|
||
|
||
/// @brief Release all shaders
|
||
void release();
|
||
|
||
/// @brief Load shader from files
|
||
/// @param name Shader name for caching
|
||
/// @param vertex_path Vertex shader file path
|
||
/// @param fragment_path Fragment shader file path
|
||
/// @return Shader object
|
||
Shader load_shader(const std::string& name,
|
||
const std::string& vertex_path,
|
||
const std::string& fragment_path);
|
||
|
||
/// @brief Load compute shader from file
|
||
/// @param name Shader name for caching
|
||
/// @param compute_path Compute shader file path
|
||
/// @return Shader object
|
||
Shader load_compute_shader(const std::string& name,
|
||
const std::string& compute_path);
|
||
|
||
/// @brief Get cached shader by name
|
||
/// @param name Shader name
|
||
/// @return Shader object (invalid if not found)
|
||
Shader get_shader(const std::string& name) const;
|
||
|
||
/// @brief Get G-Buffer shader
|
||
/// @return G-Buffer shader
|
||
const Shader& get_gbuffer_shader() const { return gbuffer_shader_; }
|
||
|
||
/// @brief Get ray tracing compute shader
|
||
/// @return Ray tracing shader
|
||
const Shader& get_raytracing_shader() const { return raytracing_shader_; }
|
||
|
||
private:
|
||
std::unordered_map<std::string, Shader> shader_cache_;
|
||
Shader gbuffer_shader_;
|
||
Shader raytracing_shader_;
|
||
|
||
bool initialized_;
|
||
|
||
/// @brief Load built-in shaders
|
||
/// @return True if loading succeeded
|
||
bool load_builtin_shaders_();
|
||
};
|
||
|
||
} // namespace are
|
||
|
||
#endif // ARE_INCLUDE_CORE_SHADER_MANAGER_H
|
||
```
|
||
|
||
### 文件：include/scene/camera.h
|
||
|
||
```cpp
|
||
#ifndef ARE_INCLUDE_SCENE_CAMERA_H
|
||
#define ARE_INCLUDE_SCENE_CAMERA_H
|
||
|
||
#include "basic/types.h"
|
||
|
||
namespace are {
|
||
|
||
/// @brief Camera projection type
|
||
enum class ProjectionType {
|
||
PERSPECTIVE,
|
||
ORTHOGRAPHIC
|
||
};
|
||
|
||
/// @brief Camera for rendering
|
||
class Camera {
|
||
public:
|
||
/// @brief Constructor
|
||
Camera();
|
||
|
||
/// @brief Destructor
|
||
~Camera();
|
||
|
||
/// @brief Set perspective projection
|
||
/// @param fov Field of view in degrees
|
||
/// @param aspect Aspect ratio
|
||
/// @param near Near plane
|
||
/// @param far Far plane
|
||
void set_perspective(float fov, float aspect, float near, float far);
|
||
|
||
/// @brief Set orthographic projection
|
||
/// @param left Left plane
|
||
/// @param right Right plane
|
||
/// @param bottom Bottom plane
|
||
/// @param top Top plane
|
||
/// @param near Near plane
|
||
/// @param far Far plane
|
||
void set_orthographic(float left, float right, float bottom, float top, float near, float far);
|
||
|
||
/// @brief Set camera position
|
||
/// @param position Position
|
||
void set_position(const Vec3& position);
|
||
|
||
/// @brief Set camera target
|
||
/// @param target Target position
|
||
void set_target(const Vec3& target);
|
||
|
||
/// @brief Set camera up vector
|
||
/// @param up Up vector
|
||
void set_up(const Vec3& up);
|
||
|
||
/// @brief Get view matrix
|
||
/// @return View matrix
|
||
Mat4 get_view_matrix() const;
|
||
|
||
/// @brief Get projection matrix
|
||
/// @return Projection matrix
|
||
Mat4 get_projection_matrix() const;
|
||
|
||
/// @brief Get view-projection matrix
|
||
/// @return View-projection matrix
|
||
Mat4 get_view_projection_matrix() const;
|
||
|
||
/// @brief Get camera position
|
||
/// @return Position
|
||
const Vec3& get_position() const { return position_; }
|
||
|
||
/// @brief Get camera forward direction
|
||
/// @return Forward direction
|
||
Vec3 get_forward() const;
|
||
|
||
/// @brief Get camera right direction
|
||
/// @return Right direction
|
||
Vec3 get_right() const;
|
||
|
||
/// @brief Get camera up direction
|
||
/// @return Up direction
|
||
Vec3 get_up() const;
|
||
|
||
private:
|
||
Vec3 position_;
|
||
Vec3 target_;
|
||
Vec3 up_;
|
||
|
||
ProjectionType projection_type_;
|
||
|
||
// Perspective parameters
|
||
float fov_;
|
||
float aspect_;
|
||
|
||
// Orthographic parameters
|
||
float left_, right_, bottom_, top_;
|
||
|
||
// Common parameters
|
||
float near_;
|
||
float far_;
|
||
|
||
mutable Mat4 view_matrix_;
|
||
mutable Mat4 projection_matrix_;
|
||
mutable bool view_dirty_;
|
||
mutable bool projection_dirty_;
|
||
};
|
||
|
||
} // namespace are
|
||
|
||
#endif // ARE_INCLUDE_SCENE_CAMERA_H
|
||
```
|
||
|
||
### 文件：include/scene/material.h
|
||
|
||
```cpp
|
||
#ifndef ARE_INCLUDE_SCENE_MATERIAL_H
|
||
#define ARE_INCLUDE_SCENE_MATERIAL_H
|
||
|
||
#include "basic/types.h"
|
||
#include "resource/texture.h"
|
||
#include <memory>
|
||
|
||
namespace are {
|
||
|
||
/// @brief Material type enumeration
|
||
enum class MaterialType {
|
||
DIFFUSE = 0,
|
||
METAL = 1,
|
||
DIELECTRIC = 2,
|
||
EMISSIVE = 3
|
||
};
|
||
|
||
/// @brief Material properties
|
||
class Material {
|
||
public:
|
||
/// @brief Constructor
|
||
Material();
|
||
|
||
/// @brief Destructor
|
||
~Material();
|
||
|
||
/// @brief Set albedo color
|
||
/// @param albedo Albedo color
|
||
void set_albedo(const Vec3& albedo);
|
||
|
||
/// @brief Set emission color
|
||
/// @param emission Emission color
|
||
void set_emission(const Vec3& emission);
|
||
|
||
/// @brief Set metallic value
|
||
/// @param metallic Metallic (0-1)
|
||
void set_metallic(float metallic);
|
||
|
||
/// @brief Set roughness value
|
||
/// @param roughness Roughness (0-1)
|
||
void set_roughness(float roughness);
|
||
|
||
/// @brief Set index of refraction
|
||
/// @param ior Index of refraction
|
||
void set_ior(float ior);
|
||
|
||
/// @brief Set material type
|
||
/// @param type Material type
|
||
void set_type(MaterialType type);
|
||
|
||
/// @brief Set albedo texture
|
||
/// @param texture Albedo texture
|
||
void set_albedo_texture(std::shared_ptr<Texture> texture);
|
||
|
||
/// @brief Set normal map
|
||
/// @param texture Normal map texture
|
||
void set_normal_texture(std::shared_ptr<Texture> texture);
|
||
|
||
/// @brief Get albedo color
|
||
/// @return Albedo color
|
||
const Vec3& get_albedo() const { return albedo_; }
|
||
|
||
/// @brief Get emission color
|
||
/// @return Emission color
|
||
const Vec3& get_emission() const { return emission_; }
|
||
|
||
/// @brief Get metallic value
|
||
/// @return Metallic
|
||
float get_metallic() const { return metallic_; }
|
||
|
||
/// @brief Get roughness value
|
||
/// @return Roughness
|
||
float get_roughness() const { return roughness_; }
|
||
|
||
/// @brief Get index of refraction
|
||
/// @return IOR
|
||
float get_ior() const { return ior_; }
|
||
|
||
/// @brief Get material type
|
||
/// @return Material type
|
||
MaterialType get_type() const { return type_; }
|
||
|
||
/// @brief Get albedo texture
|
||
/// @return Albedo texture (nullptr if none)
|
||
std::shared_ptr<Texture> get_albedo_texture() const { return albedo_texture_; }
|
||
|
||
/// @brief Get normal texture
|
||
/// @return Normal texture (nullptr if none)
|
||
std::shared_ptr<Texture> get_normal_texture() const { return normal_texture_; }
|
||
|
||
private:
|
||
Vec3 albedo_;
|
||
Vec3 emission_;
|
||
float metallic_;
|
||
float roughness_;
|
||
float ior_;
|
||
MaterialType type_;
|
||
|
||
std::shared_ptr<Texture> albedo_texture_;
|
||
std::shared_ptr<Texture> normal_texture_;
|
||
};
|
||
|
||
} // namespace are
|
||
|
||
#endif // ARE_INCLUDE_SCENE_MATERIAL_H
|
||
```
|
||
|
||
### 文件：include/scene/light.h
|
||
|
||
```cpp
|
||
#ifndef ARE_INCLUDE_SCENE_LIGHT_H
|
||
#define ARE_INCLUDE_SCENE_LIGHT_H
|
||
|
||
#include "basic/types.h"
|
||
|
||
namespace are {
|
||
|
||
/// @brief Light type enumeration
|
||
enum class LightType {
|
||
DIRECTIONAL = 0,
|
||
POINT = 1,
|
||
SPOT = 2
|
||
};
|
||
|
||
/// @brief Light source
|
||
class Light {
|
||
public:
|
||
/// @brief Constructor
|
||
Light();
|
||
|
||
/// @brief Destructor
|
||
~Light();
|
||
|
||
/// @brief Set light type
|
||
/// @param type Light type
|
||
void set_type(LightType type);
|
||
|
||
/// @brief Set light position (for point and spot lights)
|
||
/// @param position Light position
|
||
void set_position(const Vec3 &position);
|
||
|
||
/// @brief Set light direction (for directional and spot lights)
|
||
/// @param direction Light direction
|
||
void set_direction(const Vec3 &direction);
|
||
|
||
/// @brief Set light color
|
||
/// @param color Light color
|
||
void set_color(const Vec3 &color);
|
||
|
||
/// @brief Set light intensity
|
||
/// @param intensity Light intensity
|
||
void set_intensity(float intensity);
|
||
|
||
/// @brief Set light range (for point and spot lights)
|
||
/// @param range Light range
|
||
void set_range(float range);
|
||
|
||
/// @brief Set spot light angles
|
||
/// @param inner_angle Inner cone angle in degrees
|
||
/// @param outer_angle Outer cone angle in degrees
|
||
void set_spot_angles(float inner_angle, float outer_angle);
|
||
|
||
/// @brief Get light type
|
||
/// @return Light type
|
||
LightType get_type() const {
|
||
return type_;
|
||
}
|
||
|
||
/// @brief Get light position
|
||
/// @return Light position
|
||
const Vec3 &get_position() const {
|
||
return position_;
|
||
}
|
||
|
||
/// @brief Get light direction
|
||
/// @return Light direction
|
||
const Vec3 &get_direction() const {
|
||
return direction_;
|
||
}
|
||
|
||
/// @brief Get light color
|
||
/// @return Light color
|
||
const Vec3 &get_color() const {
|
||
return color_;
|
||
}
|
||
|
||
/// @brief Get light intensity
|
||
/// @return Light intensity
|
||
float get_intensity() const {
|
||
return intensity_;
|
||
}
|
||
|
||
/// @brief Get light range
|
||
/// @return Light range
|
||
float get_range() const {
|
||
return range_;
|
||
}
|
||
|
||
/// @brief Get spot light inner angle
|
||
/// @return Inner angle in radians
|
||
float get_inner_angle() const {
|
||
return inner_angle_;
|
||
}
|
||
|
||
/// @brief Get spot light outer angle
|
||
/// @return Outer angle in radians
|
||
float get_outer_angle() const {
|
||
return outer_angle_;
|
||
}
|
||
|
||
private:
|
||
LightType type_;
|
||
Vec3 position_;
|
||
Vec3 direction_;
|
||
Vec3 color_;
|
||
float intensity_;
|
||
float range_;
|
||
float inner_angle_;
|
||
float outer_angle_;
|
||
};
|
||
|
||
} // namespace are
|
||
|
||
#endif // ARE_INCLUDE_SCENE_LIGHT_H
|
||
```
|
||
|
||
### 文件：include/scene/scene.h
|
||
|
||
```cpp
|
||
#ifndef ARE_INCLUDE_SCENE_SCENE_H
|
||
#define ARE_INCLUDE_SCENE_SCENE_H
|
||
|
||
#include "basic/types.h"
|
||
#include "scene/camera.h"
|
||
#include "scene/mesh.h"
|
||
#include "scene/material.h"
|
||
#include "scene/light.h"
|
||
#include <vector>
|
||
#include <memory>
|
||
|
||
namespace are {
|
||
|
||
/// @brief Scene container holding all scene objects
|
||
class Scene {
|
||
public:
|
||
/// @brief Constructor
|
||
Scene();
|
||
|
||
/// @brief Destructor
|
||
~Scene();
|
||
|
||
/// @brief Add mesh to scene
|
||
/// @param mesh Mesh to add
|
||
/// @return Mesh index
|
||
uint add_mesh(std::shared_ptr<Mesh> mesh);
|
||
|
||
/// @brief Add material to scene
|
||
/// @param material Material to add
|
||
/// @return Material index
|
||
uint add_material(std::shared_ptr<Material> material);
|
||
|
||
/// @brief Add light to scene
|
||
/// @param light Light to add
|
||
/// @return Light index
|
||
uint add_light(std::shared_ptr<Light> light);
|
||
|
||
/// @brief Set active camera
|
||
/// @param camera Camera to set
|
||
void set_camera(std::shared_ptr<Camera> camera);
|
||
|
||
/// @brief Get active camera
|
||
/// @return Active camera
|
||
const Camera& get_camera() const { return *camera_; }
|
||
|
||
/// @brief Get all meshes
|
||
/// @return Mesh list
|
||
const std::vector<std::shared_ptr<Mesh>>& get_meshes() const { return meshes_; }
|
||
|
||
/// @brief Get all materials
|
||
/// @return Material list
|
||
const std::vector<std::shared_ptr<Material>>& get_materials() const { return materials_; }
|
||
|
||
/// @brief Get all lights
|
||
/// @return Light list
|
||
const std::vector<std::shared_ptr<Light>>& get_lights() const { return lights_; }
|
||
|
||
/// @brief Clear all scene objects
|
||
void clear();
|
||
|
||
/// @brief Update scene (animations, transforms, etc.)
|
||
/// @param delta_time Time since last update
|
||
void update(float delta_time);
|
||
|
||
private:
|
||
std::shared_ptr<Camera> camera_;
|
||
std::vector<std::shared_ptr<Mesh>> meshes_;
|
||
std::vector<std::shared_ptr<Material>> materials_;
|
||
std::vector<std::shared_ptr<Light>> lights_;
|
||
};
|
||
|
||
} // namespace are
|
||
|
||
#endif // ARE_INCLUDE_SCENE_SCENE_H
|
||
```
|
||
|
||
### 文件：include/scene/mesh.h
|
||
|
||
```cpp
|
||
#ifndef ARE_INCLUDE_SCENE_MESH_H
|
||
#define ARE_INCLUDE_SCENE_MESH_H
|
||
|
||
#include "basic/types.h"
|
||
#include <vector>
|
||
|
||
namespace are {
|
||
|
||
/// @brief Mesh data container
|
||
class Mesh {
|
||
public:
|
||
/// @brief Constructor
|
||
Mesh();
|
||
|
||
/// @brief Destructor
|
||
~Mesh();
|
||
|
||
/// @brief Set vertex data
|
||
/// @param vertices Vertex array
|
||
void set_vertices(const std::vector<Vertex>& vertices);
|
||
|
||
/// @brief Set index data
|
||
/// @param indices Index array
|
||
void set_indices(const std::vector<uint>& indices);
|
||
|
||
/// @brief Set material index
|
||
/// @param material_id Material index
|
||
void set_material(uint material_id);
|
||
|
||
/// @brief Set transform matrix
|
||
/// @param transform Transform matrix
|
||
void set_transform(const Mat4& transform);
|
||
|
||
/// @brief Get vertices
|
||
/// @return Vertex array
|
||
const std::vector<Vertex>& get_vertices() const { return vertices_; }
|
||
|
||
/// @brief Get indices
|
||
/// @return Index array
|
||
const std::vector<uint>& get_indices() const { return indices_; }
|
||
|
||
/// @brief Get material index
|
||
/// @return Material index
|
||
uint get_material() const { return material_id_; }
|
||
|
||
/// @brief Get transform matrix
|
||
/// @return Transform matrix
|
||
const Mat4& get_transform() const { return transform_; }
|
||
|
||
/// @brief Upload mesh data to GPU
|
||
/// @return True if upload succeeded
|
||
bool upload_to_gpu();
|
||
|
||
/// @brief Release GPU resources
|
||
void release_gpu_resources();
|
||
|
||
/// @brief Get VAO handle
|
||
/// @return VAO handle
|
||
uint get_vao() const { return vao_; }
|
||
|
||
/// @brief Check if mesh is uploaded to GPU
|
||
/// @return True if uploaded
|
||
bool is_uploaded() const { return uploaded_; }
|
||
|
||
private:
|
||
std::vector<Vertex> vertices_;
|
||
std::vector<uint> indices_;
|
||
uint material_id_;
|
||
Mat4 transform_;
|
||
|
||
uint vao_;
|
||
uint vbo_;
|
||
uint ebo_;
|
||
bool uploaded_;
|
||
};
|
||
|
||
} // namespace are
|
||
|
||
#endif // ARE_INCLUDE_SCENE_MESH_H
|
||
```
|
||
|
||
### 文件：include/resource/buffer.h
|
||
|
||
```cpp
|
||
#ifndef ARE_INCLUDE_RESOURCE_BUFFER_H
|
||
#define ARE_INCLUDE_RESOURCE_BUFFER_H
|
||
|
||
#include "basic/types.h"
|
||
|
||
namespace are {
|
||
|
||
/// @brief Buffer usage hint
|
||
enum class BufferUsage {
|
||
STATIC_DRAW,
|
||
DYNAMIC_DRAW,
|
||
STREAM_DRAW
|
||
};
|
||
|
||
/// @brief Buffer type
|
||
enum class BufferType {
|
||
VERTEX_BUFFER,
|
||
INDEX_BUFFER,
|
||
UNIFORM_BUFFER,
|
||
SHADER_STORAGE_BUFFER
|
||
};
|
||
|
||
/// @brief GPU buffer resource
|
||
class Buffer {
|
||
public:
|
||
/// @brief Constructor
|
||
Buffer();
|
||
|
||
/// @brief Destructor
|
||
~Buffer();
|
||
|
||
/// @brief Create buffer
|
||
/// @param type Buffer type
|
||
/// @param size Buffer size in bytes
|
||
/// @param data Initial data (nullptr for empty buffer)
|
||
/// @param usage Usage hint
|
||
/// @return True if creation succeeded
|
||
bool create(BufferType type, size_t size, const void* data, BufferUsage usage);
|
||
|
||
/// @brief Update buffer data
|
||
/// @param offset Offset in bytes
|
||
/// @param size Size in bytes
|
||
/// @param data Data to upload
|
||
void update(size_t offset, size_t size, const void* data);
|
||
|
||
/// @brief Bind buffer
|
||
void bind() const;
|
||
|
||
/// @brief Bind buffer to binding point (for UBO/SSBO)
|
||
/// @param binding_point Binding point index
|
||
void bind_base(uint binding_point) const;
|
||
|
||
/// @brief Unbind buffer
|
||
void unbind() const;
|
||
|
||
/// @brief Release buffer resources
|
||
void release();
|
||
|
||
/// @brief Get buffer handle
|
||
/// @return Buffer handle
|
||
BufferHandle get_handle() const { return handle_; }
|
||
|
||
/// @brief Get buffer size
|
||
/// @return Size in bytes
|
||
size_t get_size() const { return size_; }
|
||
|
||
/// @brief Get buffer type
|
||
/// @return Buffer type
|
||
BufferType get_type() const { return type_; }
|
||
|
||
/// @brief Check if buffer is valid
|
||
/// @return True if valid
|
||
bool is_valid() const { return handle_ != INVALID_HANDLE; }
|
||
|
||
private:
|
||
BufferHandle handle_;
|
||
BufferType type_;
|
||
size_t size_;
|
||
BufferUsage usage_;
|
||
};
|
||
|
||
} // namespace are
|
||
|
||
#endif // ARE_INCLUDE_RESOURCE_BUFFER_H
|
||
```
|
||
|
||
### 文件：include/resource/model_loader.h
|
||
|
||
```cpp
|
||
#ifndef ARE_INCLUDE_RESOURCE_MODEL_LOADER_H
|
||
#define ARE_INCLUDE_RESOURCE_MODEL_LOADER_H
|
||
|
||
#include "basic/types.h"
|
||
#include "scene/mesh.h"
|
||
#include "scene/material.h"
|
||
#include <string>
|
||
#include <vector>
|
||
#include <memory>
|
||
|
||
namespace are {
|
||
|
||
/// @brief Model loader using Assimp
|
||
class ModelLoader {
|
||
public:
|
||
/// @brief Load model from file
|
||
/// @param path Model file path
|
||
/// @param meshes Output mesh list
|
||
/// @param materials Output material list
|
||
/// @param flip_uvs Flip UV coordinates vertically
|
||
/// @return True if loading succeeded
|
||
static bool load(const std::string& path,
|
||
std::vector<std::shared_ptr<Mesh>>& meshes,
|
||
std::vector<std::shared_ptr<Material>>& materials,
|
||
bool flip_uvs = true);
|
||
|
||
/// @brief Load model and automatically upload to GPU
|
||
/// @param path Model file path
|
||
/// @param meshes Output mesh list
|
||
/// @param materials Output material list
|
||
/// @param flip_uvs Flip UV coordinates vertically
|
||
/// @return True if loading succeeded
|
||
static bool load_and_upload(const std::string& path,
|
||
std::vector<std::shared_ptr<Mesh>>& meshes,
|
||
std::vector<std::shared_ptr<Material>>& materials,
|
||
bool flip_uvs = true);
|
||
|
||
private:
|
||
/// @brief Process Assimp node recursively
|
||
static void process_node_(void* node, void* scene,
|
||
std::vector<std::shared_ptr<Mesh>>& meshes,
|
||
std::vector<std::shared_ptr<Material>>& materials,
|
||
const std::string& directory);
|
||
|
||
/// @brief Process Assimp mesh
|
||
static std::shared_ptr<Mesh> process_mesh_(void* mesh, void* scene,
|
||
std::vector<std::shared_ptr<Material>>& materials,
|
||
const std::string& directory);
|
||
|
||
/// @brief Load material textures
|
||
static void load_material_textures_(void* material, int type,
|
||
std::shared_ptr<Material>& mat,
|
||
const std::string& directory);
|
||
};
|
||
|
||
} // namespace are
|
||
|
||
#endif // ARE_INCLUDE_RESOURCE_MODEL_LOADER_H
|
||
```
|
||
|
||
### 文件：include/resource/shader.h
|
||
|
||
```cpp
|
||
#ifndef ARE_INCLUDE_RESOURCE_SHADER_H
|
||
#define ARE_INCLUDE_RESOURCE_SHADER_H
|
||
|
||
#include "basic/types.h"
|
||
#include <string>
|
||
#include <unordered_map>
|
||
|
||
namespace are {
|
||
|
||
/// @brief Shader program resource
|
||
class Shader {
|
||
public:
|
||
/// @brief Constructor
|
||
Shader();
|
||
|
||
/// @brief Destructor
|
||
~Shader();
|
||
|
||
/// @brief Load and compile shader from files
|
||
/// @param vertex_path Vertex shader path
|
||
/// @param fragment_path Fragment shader path
|
||
/// @return True if compilation succeeded
|
||
bool load(const std::string& vertex_path, const std::string& fragment_path);
|
||
|
||
/// @brief Load and compile compute shader
|
||
/// @param compute_path Compute shader path
|
||
/// @return True if compilation succeeded
|
||
bool load_compute(const std::string& compute_path);
|
||
|
||
/// @brief Compile shader from source strings
|
||
/// @param vertex_source Vertex shader source
|
||
/// @param fragment_source Fragment shader source
|
||
/// @return True if compilation succeeded
|
||
bool compile(const std::string& vertex_source, const std::string& fragment_source);
|
||
|
||
/// @brief Compile compute shader from source
|
||
/// @param compute_source Compute shader source
|
||
/// @return True if compilation succeeded
|
||
bool compile_compute(const std::string& compute_source);
|
||
|
||
/// @brief Use/activate shader program
|
||
void use() const; // 改为const
|
||
|
||
/// @brief Release shader resources
|
||
void release();
|
||
|
||
/// @brief Set uniform boolean
|
||
/// @param name Uniform name
|
||
/// @param value Value
|
||
void set_bool(const std::string& name, bool value) const; // 新增，const
|
||
|
||
/// @brief Set uniform integer
|
||
/// @param name Uniform name
|
||
/// @param value Value
|
||
void set_int(const std::string& name, int value) const; // 改为const
|
||
|
||
/// @brief Set uniform unsigned integer
|
||
/// @param name Uniform name
|
||
/// @param value Value
|
||
void set_uint(const std::string& name, uint value) const; // 改为const
|
||
|
||
/// @brief Set uniform float
|
||
/// @param name Uniform name
|
||
/// @param value Value
|
||
void set_float(const std::string& name, float value) const; // 改为const
|
||
|
||
/// @brief Set uniform vec2
|
||
/// @param name Uniform name
|
||
/// @param value Value
|
||
void set_vec2(const std::string& name, const Vec2& value) const; // 改为const
|
||
|
||
/// @brief Set uniform vec3
|
||
/// @param name Uniform name
|
||
/// @param value Value
|
||
void set_vec3(const std::string& name, const Vec3& value) const; // 改为const
|
||
|
||
/// @brief Set uniform vec4
|
||
/// @param name Uniform name
|
||
/// @param value Value
|
||
void set_vec4(const std::string& name, const Vec4& value) const; // 改为const
|
||
|
||
/// @brief Set uniform mat3
|
||
/// @param name Uniform name
|
||
/// @param value Value
|
||
void set_mat3(const std::string& name, const Mat3& value) const; // 改为const
|
||
|
||
/// @brief Set uniform mat4
|
||
/// @param name Uniform name
|
||
/// @param value Value
|
||
void set_mat4(const std::string& name, const Mat4& value) const; // 改为const
|
||
|
||
/// @brief Get shader program handle
|
||
/// @return Shader handle
|
||
ShaderHandle get_handle() const { return handle_; }
|
||
|
||
/// @brief Check if shader is valid
|
||
/// @return True if valid
|
||
bool is_valid() const { return handle_ != INVALID_HANDLE; }
|
||
|
||
private:
|
||
ShaderHandle handle_;
|
||
mutable std::unordered_map<std::string, int> uniform_cache_; // 改为mutable
|
||
|
||
/// @brief Get uniform location (with caching)
|
||
/// @param name Uniform name
|
||
/// @return Uniform location
|
||
int get_uniform_location_(const std::string& name) const; // 改为const
|
||
|
||
/// @brief Compile shader stage
|
||
/// @param source Shader source code
|
||
/// @param type Shader type (GL_VERTEX_SHADER, etc.)
|
||
/// @return Shader object handle (0 on failure)
|
||
uint compile_shader_(const std::string& source, uint type);
|
||
|
||
/// @brief Link shader program
|
||
/// @param shaders Array of shader object handles
|
||
/// @param count Number of shaders
|
||
/// @return True if linking succeeded
|
||
bool link_program_(const uint* shaders, uint count);
|
||
|
||
/// @brief Read file content
|
||
/// @param path File path
|
||
/// @return File content
|
||
std::string read_file_(const std::string& path);
|
||
};
|
||
|
||
} // namespace are
|
||
|
||
#endif // ARE_INCLUDE_RESOURCE_SHADER_H
|
||
```
|
||
|
||
### 文件：include/resource/texture.h
|
||
|
||
```cpp
|
||
#ifndef ARE_INCLUDE_RESOURCE_TEXTURE_H
|
||
#define ARE_INCLUDE_RESOURCE_TEXTURE_H
|
||
|
||
#include "basic/types.h"
|
||
#include <string>
|
||
|
||
namespace are {
|
||
|
||
/// @brief Texture format enumeration
|
||
enum class TextureFormat {
|
||
R8,
|
||
RG8,
|
||
RGB8,
|
||
RGBA8,
|
||
R16F,
|
||
RG16F,
|
||
RGB16F,
|
||
RGBA16F,
|
||
R32F,
|
||
RG32F,
|
||
RGB32F,
|
||
RGBA32F,
|
||
DEPTH24_STENCIL8
|
||
};
|
||
|
||
/// @brief Texture filter mode
|
||
enum class TextureFilter {
|
||
NEAREST,
|
||
LINEAR,
|
||
NEAREST_MIPMAP_NEAREST,
|
||
LINEAR_MIPMAP_NEAREST,
|
||
NEAREST_MIPMAP_LINEAR,
|
||
LINEAR_MIPMAP_LINEAR
|
||
};
|
||
|
||
/// @brief Texture wrap mode
|
||
enum class TextureWrap {
|
||
REPEAT,
|
||
MIRRORED_REPEAT,
|
||
CLAMP_TO_EDGE,
|
||
CLAMP_TO_BORDER
|
||
};
|
||
|
||
/// @brief Texture resource
|
||
class Texture {
|
||
public:
|
||
/// @brief Constructor
|
||
Texture();
|
||
|
||
/// @brief Destructor
|
||
~Texture();
|
||
|
||
/// @brief Load texture from file
|
||
/// @param path File path
|
||
/// @param generate_mipmaps Generate mipmaps
|
||
/// @return True if loading succeeded
|
||
bool load_from_file(const std::string& path, bool generate_mipmaps = true);
|
||
|
||
/// @brief Create empty texture
|
||
/// @param width Texture width
|
||
/// @param height Texture height
|
||
/// @param format Texture format
|
||
/// @return True if creation succeeded
|
||
bool create(uint width, uint height, TextureFormat format);
|
||
|
||
/// @brief Upload data to texture
|
||
/// @param data Pixel data
|
||
/// @param width Data width
|
||
/// @param height Data height
|
||
/// @param format Data format
|
||
/// @return True if upload succeeded
|
||
bool upload(const void* data, uint width, uint height, TextureFormat format);
|
||
|
||
/// @brief Set texture filter mode
|
||
/// @param min_filter Minification filter
|
||
/// @param mag_filter Magnification filter
|
||
void set_filter(TextureFilter min_filter, TextureFilter mag_filter);
|
||
|
||
/// @brief Set texture wrap mode
|
||
/// @param wrap_s Wrap mode for S coordinate
|
||
/// @param wrap_t Wrap mode for T coordinate
|
||
void set_wrap(TextureWrap wrap_s, TextureWrap wrap_t);
|
||
|
||
/// @brief Generate mipmaps
|
||
void generate_mipmaps();
|
||
|
||
/// @brief Bind texture to texture unit
|
||
/// @param unit Texture unit
|
||
void bind(uint unit) const;
|
||
|
||
/// @brief Unbind texture
|
||
void unbind() const;
|
||
|
||
/// @brief Release texture resources
|
||
void release();
|
||
|
||
/// @brief Get texture handle
|
||
/// @return Texture handle
|
||
TextureHandle get_handle() const { return handle_; }
|
||
|
||
/// @brief Get texture width
|
||
/// @return Width
|
||
uint get_width() const { return width_; }
|
||
|
||
/// @brief Get texture height
|
||
/// @return Height
|
||
uint get_height() const { return height_; }
|
||
|
||
/// @brief Get texture format
|
||
/// @return Format
|
||
TextureFormat get_format() const { return format_; }
|
||
|
||
/// @brief Check if texture is valid
|
||
/// @return True if valid
|
||
bool is_valid() const { return handle_ != INVALID_HANDLE; }
|
||
|
||
private:
|
||
TextureHandle handle_;
|
||
uint width_;
|
||
uint height_;
|
||
TextureFormat format_;
|
||
bool has_mipmaps_;
|
||
};
|
||
|
||
} // namespace are
|
||
|
||
#endif // ARE_INCLUDE_RESOURCE_TEXTURE_H
|
||
```
|
||
|
||
### 文件：include/utils/config.h
|
||
|
||
```cpp
|
||
#ifndef ARE_INCLUDE_UTILS_CONFIG_H
|
||
#define ARE_INCLUDE_UTILS_CONFIG_H
|
||
|
||
#include <string>
|
||
#include <unordered_map>
|
||
|
||
namespace are {
|
||
|
||
/// @brief Configuration manager for loading engine settings
|
||
/// @note This module should be implemented by the user
|
||
class Config {
|
||
public:
|
||
/// @brief Load configuration from file
|
||
/// @param path Configuration file path
|
||
/// @return True if loading succeeded
|
||
static bool load(const std::string& path);
|
||
|
||
/// @brief Save configuration to file
|
||
/// @param path Configuration file path
|
||
/// @return True if saving succeeded
|
||
static bool save(const std::string& path);
|
||
|
||
/// @brief Get string value
|
||
/// @param key Configuration key
|
||
/// @param default_value Default value if key not found
|
||
/// @return Configuration value
|
||
static std::string get_string(const std::string& key, const std::string& default_value = "");
|
||
|
||
/// @brief Get integer value
|
||
/// @param key Configuration key
|
||
/// @param default_value Default value if key not found
|
||
/// @return Configuration value
|
||
static int get_int(const std::string& key, int default_value = 0);
|
||
|
||
/// @brief Get float value
|
||
/// @param key Configuration key
|
||
/// @param default_value Default value if key not found
|
||
/// @return Configuration value
|
||
static float get_float(const std::string& key, float default_value = 0.0f);
|
||
|
||
/// @brief Get boolean value
|
||
/// @param key Configuration key
|
||
/// @param default_value Default value if key not found
|
||
/// @return Configuration value
|
||
static bool get_bool(const std::string& key, bool default_value = false);
|
||
|
||
/// @brief Set string value
|
||
/// @param key Configuration key
|
||
/// @param value Configuration value
|
||
static void set_string(const std::string& key, const std::string& value);
|
||
|
||
/// @brief Set integer value
|
||
/// @param key Configuration key
|
||
/// @param value Configuration value
|
||
static void set_int(const std::string& key, int value);
|
||
|
||
/// @brief Set float value
|
||
/// @param key Configuration key
|
||
/// @param value Configuration value
|
||
static void set_float(const std::string& key, float value);
|
||
|
||
/// @brief Set boolean value
|
||
/// @param key Configuration key
|
||
/// @param value Configuration value
|
||
static void set_bool(const std::string& key, bool value);
|
||
};
|
||
|
||
} // namespace are
|
||
|
||
#endif // ARE_INCLUDE_UTILS_CONFIG_H
|
||
```
|
||
|
||
### 文件：include/utils/logger.h
|
||
|
||
```cpp
|
||
#ifndef ARE_INCLUDE_UTILS_LOGGER_H
|
||
#define ARE_INCLUDE_UTILS_LOGGER_H
|
||
|
||
#include <string>
|
||
|
||
namespace are {
|
||
|
||
/// @brief Log level enumeration
|
||
enum class LogLevel {
|
||
DEBUG,
|
||
INFO,
|
||
WARNING,
|
||
ERROR,
|
||
FATAL
|
||
};
|
||
|
||
/// @brief Logger interface for engine logging
|
||
/// @note This module should be implemented by the user
|
||
class Logger {
|
||
public:
|
||
/// @brief Initialize logger
|
||
/// @param log_file Log file path (empty for console only)
|
||
/// @return True if initialization succeeded
|
||
static bool initialize(const std::string& log_file = "");
|
||
|
||
/// @brief Shutdown logger
|
||
static void shutdown();
|
||
|
||
/// @brief Log message
|
||
/// @param level Log level
|
||
/// @param message Message content
|
||
static void log(LogLevel level, const std::string& message);
|
||
|
||
/// @brief Log debug message
|
||
/// @param message Message content
|
||
static void debug(const std::string& message);
|
||
|
||
/// @brief Log info message
|
||
/// @param message Message content
|
||
static void info(const std::string& message);
|
||
|
||
/// @brief Log warning message
|
||
/// @param message Message content
|
||
static void warning(const std::string& message);
|
||
|
||
/// @brief Log error message
|
||
/// @param message Message content
|
||
static void error(const std::string& message);
|
||
|
||
/// @brief Log fatal message
|
||
/// @param message Message content
|
||
static void fatal(const std::string& message);
|
||
|
||
/// @brief Set minimum log level
|
||
/// @param level Minimum level to log
|
||
static void set_level(LogLevel level);
|
||
};
|
||
|
||
} // namespace are
|
||
|
||
#endif // ARE_INCLUDE_UTILS_LOGGER_H
|
||
```
|
||
|