### 文件：src/basic/math.cpp

```cpp
#include "basic/math.h"

namespace are {

Mat4 MathUtils::perspective(float fov, float aspect, float near, float far) {
    return glm::perspective(fov, aspect, near, far);
}

Mat4 MathUtils::look_at(const Vec3& eye, const Vec3& center, const Vec3& up) {
    return glm::lookAt(eye, center, up);
}

Vec3 MathUtils::normalize(const Vec3& v) {
    return glm::normalize(v);
}

float MathUtils::dot(const Vec3& a, const Vec3& b) {
    return glm::dot(a, b);
}

Vec3 MathUtils::cross(const Vec3& a, const Vec3& b) {
    return glm::cross(a, b);
}

Vec3 MathUtils::reflect(const Vec3& incident, const Vec3& normal) {
    return glm::reflect(incident, normal);
}

const float* MathUtils::value_ptr(const Mat4& mat) {
    return glm::value_ptr(mat);
}

} // namespace are
```

### 文件：src/core/bvh.cpp

```cpp
#include "core/bvh.h"
#include "utils/logger.h"
#include "basic/constants.h"
#include <algorithm>
#include <limits>

namespace are {

// AABB implementation
void AABB::expand(const Vec3& point) {
    min_ = glm::min(min_, point);
    max_ = glm::max(max_, point);
}

void AABB::expand(const AABB& other) {
    min_ = glm::min(min_, other.min_);
    max_ = glm::max(max_, other.max_);
}

float AABB::surface_area() const {
    Vec3 extent = max_ - min_;
    return 2.0f * (extent.x * extent.y + extent.y * extent.z + extent.z * extent.x);
}

bool AABB::is_valid() const {
    return min_.x <= max_.x && min_.y <= max_.y && min_.z <= max_.z;
}

// Triangle implementation
AABB Triangle::get_bounds() const {
    AABB bounds(v0_, v0_);
    bounds.expand(v1_);
    bounds.expand(v2_);
    return bounds;
}

Vec3 Triangle::get_centroid() const {
    return (v0_ + v1_ + v2_) / 3.0f;
}

// BVH implementation
BVH::BVH() {
}

BVH::~BVH() {
    clear();
}

bool BVH::build(const std::vector<std::shared_ptr<Mesh>>& meshes) {
    clear();
    
    Logger::info("Building BVH...");
    
    // Extract all triangles from meshes
    for (const auto& mesh : meshes) {
        const auto& vertices = mesh->get_vertices();
        const auto& indices = mesh->get_indices();
        uint material_id = mesh->get_material();
        Mat4 transform = mesh->get_transform();
        
        for (size_t i = 0; i < indices.size(); i += 3) {
            Triangle tri;
            
            // Transform vertices
            Vec4 v0 = transform * Vec4(vertices[indices[i]].position_, 1.0f);
            Vec4 v1 = transform * Vec4(vertices[indices[i + 1]].position_, 1.0f);
            Vec4 v2 = transform * Vec4(vertices[indices[i + 2]].position_, 1.0f);
            
            tri.v0_ = Vec3(v0) / v0.w;
            tri.v1_ = Vec3(v1) / v1.w;
            tri.v2_ = Vec3(v2) / v2.w;
            
            // Transform normals
            Mat3 normal_matrix = glm::transpose(glm::inverse(Mat3(transform)));
            tri.n0_ = glm::normalize(normal_matrix * vertices[indices[i]].normal_);
            tri.n1_ = glm::normalize(normal_matrix * vertices[indices[i + 1]].normal_);
            tri.n2_ = glm::normalize(normal_matrix * vertices[indices[i + 2]].normal_);
            
            // Copy UVs
            tri.uv0_ = vertices[indices[i]].texcoord_;
            tri.uv1_ = vertices[indices[i + 1]].texcoord_;
            tri.uv2_ = vertices[indices[i + 2]].texcoord_;
            
            tri.material_id_ = material_id;
            
            triangles_.push_back(tri);
        }
    }
    
    if (triangles_.empty()) {
        Logger::warning("No triangles to build BVH");
        return false;
    }
    
    // Initialize triangle indices
    triangle_indices_.resize(triangles_.size());
    for (size_t i = 0; i < triangles_.size(); ++i) {
        triangle_indices_[i] = static_cast<uint>(i);
    }
    
    // Reserve space for nodes (estimate)
    nodes_.reserve(triangles_.size() * 2);
    
    // Create root node
    nodes_.emplace_back();
    
    // Build BVH recursively
    build_recursive_(0, 0, static_cast<uint>(triangles_.size()));
    
    Logger::info("BVH built: " + std::to_string(nodes_.size()) + " nodes, " +
                std::to_string(triangles_.size()) + " triangles");
    
    return true;
}

void BVH::build_recursive_(uint node_idx, uint first_prim, uint prim_count) {
    BVHNode& node = nodes_[node_idx];
    
    // Calculate bounds
    AABB bounds = calculate_bounds_(first_prim, prim_count);
    node.aabb_min_ = bounds.min_;
    node.aabb_max_ = bounds.max_;
    
    // Leaf node threshold
    const uint LEAF_SIZE = 4;
    
    if (prim_count <= LEAF_SIZE) {
        // Create leaf node
        node.left_first_ = first_prim;
        node.count_ = prim_count;
        return;
    }
    
    // Find best split
    int axis;
    float split_pos;
    float split_cost = find_best_split_(first_prim, prim_count, axis, split_pos);
    
    // Check if split is beneficial
    float no_split_cost = prim_count * bounds.surface_area();
    if (split_cost >= no_split_cost) {
        // Create leaf node
        node.left_first_ = first_prim;
        node.count_ = prim_count;
        return;
    }
    
    // Partition primitives
    uint mid = first_prim;
    for (uint i = first_prim; i < first_prim + prim_count; ++i) {
        Triangle& tri = triangles_[triangle_indices_[i]];
        float centroid = tri.get_centroid()[axis];
        
        if (centroid < split_pos) {
            std::swap(triangle_indices_[i], triangle_indices_[mid]);
            mid++;
        }
    }
    
    // Ensure we have primitives on both sides
    if (mid == first_prim || mid == first_prim + prim_count) {
        mid = first_prim + prim_count / 2;
    }
    
    // Create interior node
    uint left_count = mid - first_prim;
    uint right_count = prim_count - left_count;
    
    node.left_first_ = static_cast<uint>(nodes_.size());
    node.count_ = 0;
    
    // Create child nodes
    nodes_.emplace_back();
    nodes_.emplace_back();
    
    // Recursively build children
    build_recursive_(node.left_first_, first_prim, left_count);
    build_recursive_(node.left_first_ + 1, mid, right_count);
}

float BVH::find_best_split_(uint first_prim, uint prim_count, int& axis, float& split_pos) {
    float best_cost = std::numeric_limits<float>::max();
    
    AABB centroid_bounds = calculate_centroid_bounds_(first_prim, prim_count);
    
    // Try each axis
    for (int a = 0; a < 3; ++a) {
        float extent = centroid_bounds.max_[a] - centroid_bounds.min_[a];
        if (extent < EPSILON) continue;
        
        // Try multiple split positions
        const int NUM_BINS = 16;
        for (int i = 1; i < NUM_BINS; ++i) {
            float t = static_cast<float>(i) / NUM_BINS;
            float pos = centroid_bounds.min_[a] + t * extent;
            
            // Count primitives and calculate bounds for each side
            AABB left_bounds, right_bounds;
            uint left_count = 0, right_count = 0;
            
            for (uint j = first_prim; j < first_prim + prim_count; ++j) {
                Triangle& tri = triangles_[triangle_indices_[j]];
                float centroid = tri.get_centroid()[a];
                
                if (centroid < pos) {
                    left_bounds.expand(tri.get_bounds());
                    left_count++;
                } else {
                    right_bounds.expand(tri.get_bounds());
                    right_count++;
                }
            }
            
            // Calculate SAH cost
            if (left_count == 0 || right_count == 0) continue;
            
            float cost = left_count * left_bounds.surface_area() +
                        right_count * right_bounds.surface_area();
            
            if (cost < best_cost) {
                best_cost = cost;
                axis = a;
                split_pos = pos;
            }
        }
    }
    
    return best_cost;
}

AABB BVH::calculate_bounds_(uint first_prim, uint prim_count) {
    AABB bounds{Vec3(std::numeric_limits<float>::max()),
               Vec3(std::numeric_limits<float>::lowest())};
    
    for (uint i = first_prim; i < first_prim + prim_count; ++i) {
        Triangle& tri = triangles_[triangle_indices_[i]];
        bounds.expand(tri.get_bounds());
    }
    
    return bounds;
}

AABB BVH::calculate_centroid_bounds_(uint first_prim, uint prim_count) {
    AABB bounds{Vec3(std::numeric_limits<float>::max()),
               Vec3(std::numeric_limits<float>::lowest())};
    
    for (uint i = first_prim; i < first_prim + prim_count; ++i) {
        Triangle& tri = triangles_[triangle_indices_[i]];
        bounds.expand(tri.get_centroid());
    }
    
    return bounds;
}

bool BVH::upload_to_gpu(Buffer& node_buffer, Buffer& triangle_buffer) {
    if (nodes_.empty() || triangles_.empty()) {
        Logger::error("Cannot upload empty BVH to GPU");
        return false;
    }
    
    // Reorder triangles according to BVH layout
    std::vector<Triangle> ordered_triangles;
    ordered_triangles.reserve(triangles_.size());
    
    for (uint idx : triangle_indices_) {
        ordered_triangles.push_back(triangles_[idx]);
    }
    
    // Upload nodes
    if (!node_buffer.create(BufferType::SHADER_STORAGE_BUFFER,
                           nodes_.size() * sizeof(BVHNode),
                           nodes_.data(),
                           BufferUsage::STATIC_DRAW)) {
        Logger::error("Failed to upload BVH nodes to GPU");
        return false;
    }
    
    // Upload triangles
    if (!triangle_buffer.create(BufferType::SHADER_STORAGE_BUFFER,
                               ordered_triangles.size() * sizeof(Triangle),
                               ordered_triangles.data(),
                               BufferUsage::STATIC_DRAW)) {
        Logger::error("Failed to upload BVH triangles to GPU");
        return false;
    }
    
    Logger::info("BVH uploaded to GPU successfully");
    return true;
}

void BVH::clear() {
    nodes_.clear();
    triangles_.clear();
    triangle_indices_.clear();
}

} // namespace are
```

### 文件：src/core/gbuffer.cpp

```cpp
#include "core/gbuffer.h"
#include "utils/logger.h"
#include <glad/glad.h>

namespace are {

GBuffer::GBuffer(uint width, uint height)
    : width_(width)
    , height_(height)
    , fbo_(INVALID_HANDLE)
    , depth_texture_(INVALID_HANDLE)
    , initialized_(false) {
    for (int i = 0; i < GBUFFER_COUNT; ++i) {
        textures_[i] = INVALID_HANDLE;
    }
}

GBuffer::~GBuffer() {
    release();
}

bool GBuffer::initialize() {
    if (initialized_) {
        Logger::warning("GBuffer already initialized");
        return true;
    }
    
    // Create framebuffer
    glGenFramebuffers(1, &fbo_);
    glBindFramebuffer(GL_FRAMEBUFFER, fbo_);
    
    // Create G-Buffer textures
    textures_[GBUFFER_POSITION] = create_texture_(GL_RGBA32F, GL_RGBA, GL_FLOAT);
    textures_[GBUFFER_NORMAL] = create_texture_(GL_RGBA32F, GL_RGBA, GL_FLOAT);
    textures_[GBUFFER_ALBEDO] = create_texture_(GL_RGBA8, GL_RGBA, GL_UNSIGNED_BYTE);
    
    // Attach textures to framebuffer
    glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0 + GBUFFER_POSITION,
                          GL_TEXTURE_2D, textures_[GBUFFER_POSITION], 0);
    glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0 + GBUFFER_NORMAL,
                          GL_TEXTURE_2D, textures_[GBUFFER_NORMAL], 0);
    glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0 + GBUFFER_ALBEDO,
                          GL_TEXTURE_2D, textures_[GBUFFER_ALBEDO], 0);
    
    // Create depth texture
    glGenTextures(1, &depth_texture_);
    glBindTexture(GL_TEXTURE_2D, depth_texture_);
    glTexImage2D(GL_TEXTURE_2D, 0, GL_DEPTH24_STENCIL8, width_, height_, 0,
                GL_DEPTH_STENCIL, GL_UNSIGNED_INT_24_8, nullptr);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
    glFramebufferTexture2D(GL_FRAMEBUFFER, GL_DEPTH_STENCIL_ATTACHMENT,
                          GL_TEXTURE_2D, depth_texture_, 0);
    
    // Set draw buffers
    GLenum draw_buffers[GBUFFER_COUNT] = {
        GL_COLOR_ATTACHMENT0 + GBUFFER_POSITION,
        GL_COLOR_ATTACHMENT0 + GBUFFER_NORMAL,
        GL_COLOR_ATTACHMENT0 + GBUFFER_ALBEDO
    };
    glDrawBuffers(GBUFFER_COUNT, draw_buffers);
    
    // Check framebuffer completeness
    if (glCheckFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE) {
        Logger::error("GBuffer framebuffer is not complete");
        glBindFramebuffer(GL_FRAMEBUFFER, 0);
        return false;
    }
    
    glBindFramebuffer(GL_FRAMEBUFFER, 0);
    
    initialized_ = true;
    Logger::info("GBuffer initialized successfully");
    return true;
}

void GBuffer::release() {
    if (!initialized_) return;
    
    if (fbo_ != INVALID_HANDLE) {
        glDeleteFramebuffers(1, &fbo_);
        fbo_ = INVALID_HANDLE;
    }
    
    for (int i = 0; i < GBUFFER_COUNT; ++i) {
        if (textures_[i] != INVALID_HANDLE) {
            glDeleteTextures(1, &textures_[i]);
            textures_[i] = INVALID_HANDLE;
        }
    }
    
    if (depth_texture_ != INVALID_HANDLE) {
        glDeleteTextures(1, &depth_texture_);
        depth_texture_ = INVALID_HANDLE;
    }
    
    initialized_ = false;
    Logger::info("GBuffer released");
}

void GBuffer::render(const Scene& scene, const Shader& shader) {
    if (!initialized_) {
        Logger::error("GBuffer not initialized");
        return;
    }
    
    // Bind framebuffer
    glBindFramebuffer(GL_FRAMEBUFFER, fbo_);
    glViewport(0, 0, width_, height_);
    
    // Clear buffers
    glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
    
    // Enable depth test
    glEnable(GL_DEPTH_TEST);
    glDepthFunc(GL_LESS);
    
    // Use shader
    shader.use();
    
    // Set camera matrices
    const Camera& camera = scene.get_camera();
    Mat4 view = camera.get_view_matrix();
    Mat4 projection = camera.get_projection_matrix();
    
    shader.set_mat4("u_view", view);
    shader.set_mat4("u_projection", projection);
    
    // Render all meshes
    const auto& meshes = scene.get_meshes();
    const auto& materials = scene.get_materials();
    
    for (const auto& mesh : meshes) {
        if (!mesh->is_uploaded()) {
            Logger::warning("Mesh not uploaded to GPU, skipping");
            continue;
        }
        
        // Set model matrix
        Mat4 model = mesh->get_transform();
        shader.set_mat4("u_model", model);
        
        // Set material properties
        uint material_id = mesh->get_material();
        if (material_id < materials.size()) {
            const auto& material = materials[material_id];
            
            shader.set_vec3("u_albedo", material->get_albedo());
            shader.set_float("u_metallic", material->get_metallic());
            shader.set_float("u_roughness", material->get_roughness());
            shader.set_uint("u_material_id", material_id);
            
            // Bind textures
            auto albedo_tex = material->get_albedo_texture();
            if (albedo_tex && albedo_tex->is_valid()) {
                albedo_tex->bind(0);
                shader.set_int("u_albedo_map", 0);
                shader.set_int("u_has_albedo_map", 1);
            } else {
                shader.set_int("u_has_albedo_map", 0);
            }
            
            auto normal_tex = material->get_normal_texture();
            if (normal_tex && normal_tex->is_valid()) {
                normal_tex->bind(1);
                shader.set_int("u_normal_map", 1);
                shader.set_int("u_has_normal_map", 1);
            } else {
                shader.set_int("u_has_normal_map", 0);
            }
        }
        
        // Draw mesh
        glBindVertexArray(mesh->get_vao());
        glDrawElements(GL_TRIANGLES, mesh->get_indices().size(), GL_UNSIGNED_INT, 0);
        glBindVertexArray(0);
    }
    
    // Unbind framebuffer
    glBindFramebuffer(GL_FRAMEBUFFER, 0);
}

void GBuffer::resize(uint width, uint height) {
    if (width == width_ && height == height_) return;
    
    width_ = width;
    height_ = height;
    
    if (initialized_) {
        release();
        initialize();
    }
}

TextureHandle GBuffer::get_texture(int index) const {
    if (index < 0 || index >= GBUFFER_COUNT) {
        Logger::error("Invalid G-Buffer texture index");
        return INVALID_HANDLE;
    }
    return textures_[index];
}

void GBuffer::get_dimensions(uint& width, uint& height) const {
    width = width_;
    height = height_;
}

TextureHandle GBuffer::create_texture_(uint internal_format, uint format, uint type) {
    TextureHandle texture;
    glGenTextures(1, &texture);
    glBindTexture(GL_TEXTURE_2D, texture);
    glTexImage2D(GL_TEXTURE_2D, 0, internal_format, width_, height_, 0, format, type, nullptr);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
    return texture;
}

} // namespace are
```

### 文件：src/core/raytracer.cpp

```cpp
#include "core/raytracer.h"
#include "utils/logger.h"
#include "basic/constants.h"
#include <glad/glad.h>

namespace are {

RayTracer::RayTracer(uint width, uint height, const RayTracerConfig& config)
    : width_(width)
    , height_(height)
    , config_(config)
    , accumulation_texture_(INVALID_HANDLE)
    , scene_buffer_(INVALID_HANDLE)
    , material_buffer_(INVALID_HANDLE)
    , light_buffer_(INVALID_HANDLE)
    , bvh_(nullptr)
    , bvh_built_(false)
    , frame_count_(0)
    , initialized_(false) {
}

RayTracer::~RayTracer() {
    release();
}

bool RayTracer::initialize() {
    if (initialized_) {
        Logger::warning("RayTracer already initialized");
        return true;
    }
    
    // Create accumulation texture
    glGenTextures(1, &accumulation_texture_);
    glBindTexture(GL_TEXTURE_2D, accumulation_texture_);
    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA32F, width_, height_, 0, GL_RGBA, GL_FLOAT, nullptr);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
    
    // Create shader storage buffers
    glGenBuffers(1, &material_buffer_);
    glGenBuffers(1, &light_buffer_);
    
    // Load compute shader
    Logger::info("Loading ray tracing compute shader in RayTracer...");
    if (!compute_shader_.load_compute("shaders/raytracing.comp")) {
        Logger::error("Failed to load ray tracing compute shader in RayTracer");
        return false;
    }
    Logger::info("Ray tracing compute shader loaded in RayTracer");
    
    // Initialize BVH if enabled
    if (config_.use_bvh_) {
        bvh_ = std::make_unique<BVH>();
    }
    
    initialized_ = true;
    Logger::info("RayTracer initialized successfully");
    return true;
}

void RayTracer::release() {
    if (!initialized_) return;
    
    if (accumulation_texture_ != INVALID_HANDLE) {
        glDeleteTextures(1, &accumulation_texture_);
        accumulation_texture_ = INVALID_HANDLE;
    }
    
    if (material_buffer_ != INVALID_HANDLE) {
        glDeleteBuffers(1, &material_buffer_);
        material_buffer_ = INVALID_HANDLE;
    }
    
    if (light_buffer_ != INVALID_HANDLE) {
        glDeleteBuffers(1, &light_buffer_);
        light_buffer_ = INVALID_HANDLE;
    }
    
    bvh_node_buffer_.release();
    bvh_triangle_buffer_.release();
    
    compute_shader_.release();
    
    bvh_.reset();
    bvh_built_ = false;
    
    initialized_ = false;
    Logger::info("RayTracer released");
}

bool RayTracer::rebuild_bvh(const Scene& scene) {
    if (!config_.use_bvh_) {
        Logger::warning("BVH is disabled in configuration");
        return false;
    }
    
    if (!bvh_) {
        bvh_ = std::make_unique<BVH>();
    }
    
    Logger::info("Building BVH for ray tracing...");
    
    if (!bvh_->build(scene.get_meshes())) {
        Logger::error("Failed to build BVH");
        return false;
    }
    
    if (!bvh_->upload_to_gpu(bvh_node_buffer_, bvh_triangle_buffer_)) {
        Logger::error("Failed to upload BVH to GPU");
        return false;
    }
    
    bvh_built_ = true;
    Logger::info("BVH built and uploaded successfully");
    return true;
}

void RayTracer::trace(const Scene& scene, const GBuffer& gbuffer, TextureHandle output_texture) {
    if (!initialized_) {
        Logger::error("RayTracer not initialized");
        return;
    }
    
    if (!compute_shader_.is_valid()) {
        Logger::error("Ray tracing compute shader not loaded");
        return;
    }
    
    // Build BVH if enabled and not built yet
    if (config_.use_bvh_ && !bvh_built_) {
        rebuild_bvh(scene);
    }
    
    // Upload scene data
    upload_scene_data_(scene);
    
    // Use compute shader
    compute_shader_.use();
    
    // Bind G-Buffer textures
    bind_gbuffer_(gbuffer);
    
    // Bind output and accumulation textures
    glBindImageTexture(3, output_texture, 0, GL_FALSE, 0, GL_WRITE_ONLY, GL_RGBA32F);
    glBindImageTexture(4, accumulation_texture_, 0, GL_FALSE, 0, GL_READ_WRITE, GL_RGBA32F);
    
    // Bind BVH buffers if enabled
    if (config_.use_bvh_ && bvh_built_) {
        bvh_node_buffer_.bind_base(2);
        bvh_triangle_buffer_.bind_base(3);
        compute_shader_.set_bool("u_use_bvh", true);
        compute_shader_.set_uint("u_bvh_node_count", bvh_->get_node_count());
    } else {
        compute_shader_.set_bool("u_use_bvh", false);
    }
    
    // Set uniforms
    compute_shader_.set_uint("u_frame_count", frame_count_);
    compute_shader_.set_uint("u_samples_per_pixel", config_.samples_per_pixel_);
    compute_shader_.set_uint("u_max_depth", config_.max_depth_);
    compute_shader_.set_uint("u_light_count", static_cast<uint>(scene.get_lights().size()));
    compute_shader_.set_bool("u_enable_accumulation", config_.enable_accumulation_);
    
    // Set camera data
    const Camera& camera = scene.get_camera();
    compute_shader_.set_vec3("u_camera_position", camera.get_position());
    
    Mat4 inv_vp = glm::inverse(camera.get_view_projection_matrix());
    compute_shader_.set_mat4("u_inv_view_projection", inv_vp);
    
    // Dispatch compute shader
    uint num_groups_x = (width_ + COMPUTE_GROUP_SIZE_X - 1) / COMPUTE_GROUP_SIZE_X;
    uint num_groups_y = (height_ + COMPUTE_GROUP_SIZE_Y - 1) / COMPUTE_GROUP_SIZE_Y;
    
    glDispatchCompute(num_groups_x, num_groups_y, 1);
    
    // Memory barrier
    glMemoryBarrier(GL_SHADER_IMAGE_ACCESS_BARRIER_BIT);
    
    // Increment frame count for accumulation
    if (config_.enable_accumulation_) {
        frame_count_++;
    }
}

void RayTracer::resize(uint width, uint height) {
    if (width == width_ && height == height_) return;
    
    width_ = width;
    height_ = height;
    
    if (initialized_) {
        // Recreate accumulation texture
        if (accumulation_texture_ != INVALID_HANDLE) {
            glDeleteTextures(1, &accumulation_texture_);
        }
        
        glGenTextures(1, &accumulation_texture_);
        glBindTexture(GL_TEXTURE_2D, accumulation_texture_);
        glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA32F, width_, height_, 0, GL_RGBA, GL_FLOAT, nullptr);
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
        
        reset_accumulation();
    }
}

void RayTracer::reset_accumulation() {
    frame_count_ = 0;
}

void RayTracer::set_config(const RayTracerConfig& config) {
    bool bvh_changed = (config.use_bvh_ != config_.use_bvh_);
    
    config_ = config;
    reset_accumulation();
    
    if (bvh_changed) {
        if (config_.use_bvh_ && !bvh_) {
            bvh_ = std::make_unique<BVH>();
            bvh_built_ = false;
        } else if (!config_.use_bvh_) {
            bvh_.reset();
            bvh_built_ = false;
        }
    }
}

void RayTracer::upload_scene_data_(const Scene& scene) {
    // Upload materials
    const auto& materials = scene.get_materials();
    if (!materials.empty()) {
        struct MaterialData {
            Vec3 albedo;
            float metallic;
            Vec3 emission;
            float roughness;
            int type;
            float ior;
            Vec2 padding;
        };
        
        std::vector<MaterialData> material_data;
        material_data.reserve(materials.size());
        
        for (const auto& mat : materials) {
            MaterialData data;
            data.albedo = mat->get_albedo();
            data.metallic = mat->get_metallic();
            data.emission = mat->get_emission();
            data.roughness = mat->get_roughness();
            data.type = static_cast<int>(mat->get_type());
            data.ior = mat->get_ior();
            material_data.push_back(data);
        }
        
        glBindBuffer(GL_SHADER_STORAGE_BUFFER, material_buffer_);
        glBufferData(GL_SHADER_STORAGE_BUFFER, 
                    material_data.size() * sizeof(MaterialData),
                    material_data.data(), GL_DYNAMIC_DRAW);
        glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 0, material_buffer_);
    }
    
    // Upload lights
    const auto& lights = scene.get_lights();
    if (!lights.empty()) {
        struct LightData {
            Vec3 position;
            int type;
            Vec3 direction;
            float intensity;
            Vec3 color;
            float range;
            Vec2 spot_angles;
            Vec2 padding;
        };
        
        std::vector<LightData> light_data;
        light_data.reserve(lights.size());
        
        for (const auto& light : lights) {
            LightData data;
            data.position = light->get_position();
            data.type = static_cast<int>(light->get_type());
            data.direction = light->get_direction();
            data.intensity = light->get_intensity();
            data.color = light->get_color();
            data.range = light->get_range();
            data.spot_angles = Vec2(light->get_inner_angle(), light->get_outer_angle());
            light_data.push_back(data);
        }
        
        glBindBuffer(GL_SHADER_STORAGE_BUFFER, light_buffer_);
        glBufferData(GL_SHADER_STORAGE_BUFFER,
                    light_data.size() * sizeof(LightData),
                    light_data.data(), GL_DYNAMIC_DRAW);
        glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 1, light_buffer_);
    }
}

void RayTracer::bind_gbuffer_(const GBuffer& gbuffer) {
    glBindImageTexture(0, gbuffer.get_texture(GBUFFER_POSITION), 0, GL_FALSE, 0, GL_READ_ONLY, GL_RGBA32F);
    glBindImageTexture(1, gbuffer.get_texture(GBUFFER_NORMAL), 0, GL_FALSE, 0, GL_READ_ONLY, GL_RGBA32F);
    glBindImageTexture(2, gbuffer.get_texture(GBUFFER_ALBEDO), 0, GL_FALSE, 0, GL_READ_ONLY, GL_RGBA8);
}

void RayTracer::set_compute_shader(const Shader& shader) {
    compute_shader_ = shader;
    Logger::info("Compute shader set for RayTracer");
}

} // namespace are
```

### 文件：src/core/renderer.cpp

```cpp
#include "core/renderer.h"
#include "utils/logger.h"
#include <chrono>
#include <glad/glad.h>

namespace are {

Renderer::Renderer(const RendererConfig &config)
	: config_(config)
	, initialized_(false)
	, frame_count_(0) {
}

Renderer::~Renderer() {
	shutdown();
}

bool Renderer::initialize() {
    if (initialized_) {
        Logger::warning("Renderer already initialized");
        return true;
    }
    
    Logger::info("Initializing Aurora Rendering Engine...");
    
    // Initialize shader manager
    shader_manager_ = std::make_unique<ShaderManager>();
    if (!shader_manager_->initialize()) {
        Logger::error("Failed to initialize shader manager");
        return false;
    }
    
    // Initialize G-Buffer
    gbuffer_ = std::make_unique<GBuffer>(config_.width_, config_.height_);
    if (!gbuffer_->initialize()) {
        Logger::error("Failed to initialize G-Buffer");
        return false;
    }
    
    // Initialize ray tracer
    RayTracerConfig rt_config;
    rt_config.samples_per_pixel_ = config_.samples_per_pixel_;
    rt_config.max_depth_ = config_.max_ray_depth_;
    rt_config.enable_shadows_ = true;
    rt_config.enable_reflections_ = true;
    rt_config.enable_accumulation_ = config_.enable_accumulation_;
    rt_config.use_bvh_ = true;
    
    raytracer_ = std::make_unique<RayTracer>(config_.width_, config_.height_, rt_config);
    if (!raytracer_->initialize()) {
        Logger::error("Failed to initialize ray tracer");
        return false;
    }
    
    // Pass compute shader to ray tracer
    const Shader& rt_shader = shader_manager_->get_raytracing_shader();
    if (!rt_shader.is_valid()) {
        Logger::error("Ray tracing shader is invalid");
        return false;
    }
    raytracer_->set_compute_shader(rt_shader);
    
    // Initialize screen blit
    screen_blit_ = std::make_unique<ScreenBlit>();
    if (!screen_blit_->initialize()) {
        Logger::error("Failed to initialize screen blit");
        return false;
    }
    
    initialized_ = true;
    Logger::info("Aurora Rendering Engine initialized successfully");
    return true;
}

void Renderer::shutdown() {
	if (!initialized_)
		return;

	Logger::info("Shutting down Aurora Rendering Engine...");

	if (screen_blit_) {
        screen_blit_->release();
        screen_blit_.reset();
    }

	if (raytracer_) {
		raytracer_->release();
		raytracer_.reset();
	}

	if (gbuffer_) {
		gbuffer_->release();
		gbuffer_.reset();
	}

	if (shader_manager_) {
		shader_manager_->release();
		shader_manager_.reset();
	}

	initialized_ = false;
	Logger::info("Aurora Rendering Engine shut down");
}

RenderStats Renderer::render(const Scene& scene, TextureHandle output_texture) {
    RenderStats stats = {};
    
    if (!initialized_) {
        Logger::error("Renderer not initialized");
        return stats;
    }
    
    // Start timing
    auto start_time = std::chrono::high_resolution_clock::now();
    
    // Phase 1: G-Buffer pass
    auto gbuffer_start = std::chrono::high_resolution_clock::now();
    
    const Shader& gbuffer_shader = shader_manager_->get_gbuffer_shader();
    gbuffer_->render(scene, gbuffer_shader);
    
    auto gbuffer_end = std::chrono::high_resolution_clock::now();
    stats.gbuffer_time_ms_ = std::chrono::duration<float, std::milli>(gbuffer_end - gbuffer_start).count();
    
    // Phase 2: Ray tracing pass
    auto raytrace_start = std::chrono::high_resolution_clock::now();
    
    // Create output texture if not provided
    TextureHandle rt_output = output_texture;
    bool created_temp_texture = false;
    
    if (rt_output == 0) {
        glGenTextures(1, &rt_output);
        glBindTexture(GL_TEXTURE_2D, rt_output);
        glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA32F, config_.width_, config_.height_, 
                    0, GL_RGBA, GL_FLOAT, nullptr);
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
        created_temp_texture = true;
    }
    
    raytracer_->trace(scene, *gbuffer_, rt_output);
    
    auto raytrace_end = std::chrono::high_resolution_clock::now();
    stats.raytrace_time_ms_ = std::chrono::duration<float, std::milli>(raytrace_end - raytrace_start).count();
    
    // Phase 3: Blit to screen if output is default framebuffer
    if (created_temp_texture && output_texture == 0) {
        screen_blit_->blit_fullscreen(rt_output);
        glDeleteTextures(1, &rt_output);
    }
    
    // Calculate total frame time
    auto end_time = std::chrono::high_resolution_clock::now();
    stats.frame_time_ms_ = std::chrono::duration<float, std::milli>(end_time - start_time).count();
    
    // Count triangles
    const auto& meshes = scene.get_meshes();
    for (const auto& mesh : meshes) {
        stats.triangle_count_ += mesh->get_indices().size() / 3;
    }
    
    // Estimate ray count (very rough)
    stats.ray_count_ = config_.width_ * config_.height_ * config_.samples_per_pixel_ * config_.max_ray_depth_;
    
    frame_count_++;
    
    return stats;
}

void Renderer::resize(uint width, uint height) {
	if (width == config_.width_ && height == config_.height_)
		return;

	config_.width_ = width;
	config_.height_ = height;

	if (initialized_) {
		gbuffer_->resize(width, height);
		raytracer_->resize(width, height);

		Logger::info("Renderer resized to " + std::to_string(width) + "x" + std::to_string(height));
	}
}

void Renderer::set_config(const RendererConfig &config) {
	bool size_changed = (config.width_ != config_.width_ || config.height_ != config_.height_);

	config_ = config;

	if (initialized_) {
		if (size_changed) {
			resize(config_.width_, config_.height_);
		}

		// Update ray tracer config
		RayTracerConfig rt_config = raytracer_->get_config();
		rt_config.samples_per_pixel_ = config_.samples_per_pixel_;
		rt_config.max_depth_ = config_.max_ray_depth_;
		rt_config.enable_accumulation_ = config_.enable_accumulation_;
		raytracer_->set_config(rt_config);
	}
}

} // namespace are
```

### 文件：src/core/screen_blit.cpp

```cpp
#include "core/screen_blit.h"
#include "utils/logger.h"
#include <glad/glad.h>

namespace are {

namespace {
    const char* VERTEX_SHADER_SOURCE = R"(
        #version 430 core
        layout(location = 0) in vec2 a_position;
        layout(location = 1) in vec2 a_texcoord;
        
        out vec2 v_texcoord;
        
        void main() {
            v_texcoord = a_texcoord;
            gl_Position = vec4(a_position, 0.0, 1.0);
        }
    )";
    
    const char* FRAGMENT_SHADER_SOURCE = R"(
        #version 430 core
        in vec2 v_texcoord;
        out vec4 frag_color;
        
        uniform sampler2D u_texture;
        
        void main() {
            frag_color = texture(u_texture, v_texcoord);
        }
    )";
}

ScreenBlit::ScreenBlit()
    : vao_(0)
    , vbo_(0)
    , initialized_(false) {
}

ScreenBlit::~ScreenBlit() {
    release();
}

bool ScreenBlit::initialize() {
    if (initialized_) {
        Logger::warning("ScreenBlit already initialized");
        return true;
    }
    
    // Compile shader
    if (!shader_.compile(VERTEX_SHADER_SOURCE, FRAGMENT_SHADER_SOURCE)) {
        Logger::error("Failed to compile screen blit shader");
        return false;
    }
    
    // Create fullscreen quad
    create_quad_();
    
    initialized_ = true;
    Logger::info("ScreenBlit initialized successfully");
    return true;
}

void ScreenBlit::release() {
    if (!initialized_) return;
    
    shader_.release();
    
    if (vao_ != 0) {
        glDeleteVertexArrays(1, &vao_);
        vao_ = 0;
    }
    
    if (vbo_ != 0) {
        glDeleteBuffers(1, &vbo_);
        vbo_ = 0;
    }
    
    initialized_ = false;
}

void ScreenBlit::blit(TextureHandle texture, int x, int y, uint width, uint height) {
    if (!initialized_) {
        Logger::error("ScreenBlit not initialized");
        return;
    }
    
    // Set viewport
    glViewport(x, y, width, height);
    
    // Disable depth test
    glDisable(GL_DEPTH_TEST);
    
    // Use shader
    shader_.use();
    shader_.set_int("u_texture", 0);
    
    // Bind texture
    glActiveTexture(GL_TEXTURE0);
    glBindTexture(GL_TEXTURE_2D, texture);
    
    // Draw quad
    glBindVertexArray(vao_);
    glDrawArrays(GL_TRIANGLES, 0, 6);
    glBindVertexArray(0);
    
    // Re-enable depth test
    glEnable(GL_DEPTH_TEST);
}

void ScreenBlit::blit_fullscreen(TextureHandle texture) {
    GLint viewport[4];
    glGetIntegerv(GL_VIEWPORT, viewport);
    blit(texture, viewport[0], viewport[1], viewport[2], viewport[3]);
}

void ScreenBlit::create_quad_() {
    // Fullscreen quad vertices (position + texcoord)
    float vertices[] = {
        // Position    // TexCoord
        -1.0f, -1.0f,  0.0f, 0.0f,
         1.0f, -1.0f,  1.0f, 0.0f,
         1.0f,  1.0f,  1.0f, 1.0f,
        
        -1.0f, -1.0f,  0.0f, 0.0f,
         1.0f,  1.0f,  1.0f, 1.0f,
        -1.0f,  1.0f,  0.0f, 1.0f
    };
    
    glGenVertexArrays(1, &vao_);
    glGenBuffers(1, &vbo_);
    
    glBindVertexArray(vao_);
    glBindBuffer(GL_ARRAY_BUFFER, vbo_);
    glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);
    
    // Position attribute
    glEnableVertexAttribArray(0);
    glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 4 * sizeof(float), (void*)0);
    
    // TexCoord attribute
    glEnableVertexAttribArray(1);
    glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 4 * sizeof(float), (void*)(2 * sizeof(float)));
    
    glBindVertexArray(0);
}

} // namespace are
```

### 文件：src/core/shader_manager.cpp

```cpp
#include "core/shader_manager.h"
#include "utils/logger.h"

namespace are {

ShaderManager::ShaderManager()
    : initialized_(false) {
}

ShaderManager::~ShaderManager() {
    release();
}

bool ShaderManager::initialize() {
    if (initialized_) {
        Logger::warning("ShaderManager already initialized");
        return true;
    }
    
    Logger::info("Loading built-in shaders...");
    
    if (!load_builtin_shaders_()) {
        Logger::error("Failed to load built-in shaders");
        return false;
    }
    
    initialized_ = true;
    Logger::info("ShaderManager initialized successfully");
    return true;
}

void ShaderManager::release() {
    if (!initialized_) return;
    
    gbuffer_shader_.release();
    raytracing_shader_.release();
    
    for (auto& pair : shader_cache_) {
        pair.second.release();
    }
    shader_cache_.clear();
    
    initialized_ = false;
    Logger::info("ShaderManager released");
}

Shader ShaderManager::load_shader(const std::string& name,
                                  const std::string& vertex_path,
                                  const std::string& fragment_path) {
    // Check cache
    auto it = shader_cache_.find(name);
    if (it != shader_cache_.end()) {
        Logger::info("Shader '" + name + "' loaded from cache");
        return it->second;
    }
    
    // Load shader
    Shader shader;
    if (!shader.load(vertex_path, fragment_path)) {
        Logger::error("Failed to load shader '" + name + "'");
        return Shader();
    }
    
    shader_cache_[name] = shader;
    Logger::info("Shader '" + name + "' loaded successfully");
    return shader;
}

Shader ShaderManager::load_compute_shader(const std::string& name,
                                         const std::string& compute_path) {
    // Check cache
    auto it = shader_cache_.find(name);
    if (it != shader_cache_.end()) {
        Logger::info("Compute shader '" + name + "' loaded from cache");
        return it->second;
    }
    
    // Load shader
    Shader shader;
    if (!shader.load_compute(compute_path)) {
        Logger::error("Failed to load compute shader '" + name + "'");
        return Shader();
    }
    
    shader_cache_[name] = shader;
    Logger::info("Compute shader '" + name + "' loaded successfully");
    return shader;
}

Shader ShaderManager::get_shader(const std::string& name) const {
    auto it = shader_cache_.find(name);
    if (it != shader_cache_.end()) {
        return it->second;
    }
    
    Logger::warning("Shader '" + name + "' not found in cache");
    return Shader();
}

bool ShaderManager::load_builtin_shaders_() {
    // Load G-Buffer shader
    if (!gbuffer_shader_.load("shaders/gbuffer.vert", "shaders/gbuffer.frag")) {
        Logger::error("Failed to load G-Buffer shader");
        return false;
    }
    shader_cache_["gbuffer"] = gbuffer_shader_;
    
    // Load ray tracing compute shader
    if (!raytracing_shader_.load_compute("shaders/raytracing.comp")) {
        Logger::error("Failed to load ray tracing shader");
        return false;
    }
    shader_cache_["raytracing"] = raytracing_shader_;

	// Load ray tracing compute shader
    Logger::info("Loading ray tracing compute shader...");
    if (!raytracing_shader_.load_compute("shaders/raytracing.comp")) {
        Logger::error("Failed to load ray tracing shader");
        return false;
    }
    shader_cache_["raytracing"] = raytracing_shader_;
    Logger::info("Ray tracing shader loaded successfully");
    
    return true;
}

} // namespace are
```

### 文件：src/scene/camera.cpp

```cpp
#include "scene/camera.h"
#include "basic/math.h"
#include <glm/gtc/matrix_transform.hpp>

namespace are {

Camera::Camera()
    : position_(0.0f, 0.0f, 5.0f)
    , target_(0.0f, 0.0f, 0.0f)
    , up_(0.0f, 1.0f, 0.0f)
    , projection_type_(ProjectionType::PERSPECTIVE)
    , fov_(glm::radians(45.0f))
    , aspect_(16.0f / 9.0f)
    , left_(-1.0f)
    , right_(1.0f)
    , bottom_(-1.0f)
    , top_(1.0f)
    , near_(0.1f)
    , far_(100.0f)
    , view_dirty_(true)
    , projection_dirty_(true) {
}

Camera::~Camera() {
}

void Camera::set_perspective(float fov, float aspect, float near, float far) {
    projection_type_ = ProjectionType::PERSPECTIVE;
    fov_ = glm::radians(fov);
    aspect_ = aspect;
    near_ = near;
    far_ = far;
    projection_dirty_ = true;
}

void Camera::set_orthographic(float left, float right, float bottom, float top, float near, float far) {
    projection_type_ = ProjectionType::ORTHOGRAPHIC;
    left_ = left;
    right_ = right;
    bottom_ = bottom;
    top_ = top;
    near_ = near;
    far_ = far;
    projection_dirty_ = true;
}

void Camera::set_position(const Vec3& position) {
    position_ = position;
    view_dirty_ = true;
}

void Camera::set_target(const Vec3& target) {
    target_ = target;
    view_dirty_ = true;
}

void Camera::set_up(const Vec3& up) {
    up_ = up;
    view_dirty_ = true;
}

Mat4 Camera::get_view_matrix() const {
    if (view_dirty_) {
        view_matrix_ = MathUtils::look_at(position_, target_, up_);
        view_dirty_ = false;
    }
    return view_matrix_;
}

Mat4 Camera::get_projection_matrix() const {
    if (projection_dirty_) {
        if (projection_type_ == ProjectionType::PERSPECTIVE) {
            projection_matrix_ = MathUtils::perspective(fov_, aspect_, near_, far_);
        } else {
            projection_matrix_ = glm::ortho(left_, right_, bottom_, top_, near_, far_);
        }
        projection_dirty_ = false;
    }
    return projection_matrix_;
}

Mat4 Camera::get_view_projection_matrix() const {
    return get_projection_matrix() * get_view_matrix();
}

Vec3 Camera::get_forward() const {
    return MathUtils::normalize(target_ - position_);
}

Vec3 Camera::get_right() const {
    Vec3 forward = get_forward();
    return MathUtils::normalize(MathUtils::cross(forward, up_));
}

Vec3 Camera::get_up() const {
    Vec3 forward = get_forward();
    Vec3 right = get_right();
    return MathUtils::cross(right, forward);
}

} // namespace are
```

### 文件：src/scene/material.cpp

```cpp
#include "scene/material.h"

namespace are {

Material::Material()
    : albedo_(1.0f, 1.0f, 1.0f)
    , emission_(0.0f, 0.0f, 0.0f)
    , metallic_(0.0f)
    , roughness_(0.5f)
    , ior_(1.5f)
    , type_(MaterialType::DIFFUSE)
    , albedo_texture_(nullptr)
    , normal_texture_(nullptr) {
}

Material::~Material() {
}

void Material::set_albedo(const Vec3& albedo) {
    albedo_ = albedo;
}

void Material::set_emission(const Vec3& emission) {
    emission_ = emission;
}

void Material::set_metallic(float metallic) {
    metallic_ = glm::clamp(metallic, 0.0f, 1.0f);
}

void Material::set_roughness(float roughness) {
    roughness_ = glm::clamp(roughness, 0.0f, 1.0f);
}

void Material::set_ior(float ior) {
    ior_ = ior;
}

void Material::set_type(MaterialType type) {
    type_ = type;
}

void Material::set_albedo_texture(std::shared_ptr<Texture> texture) {
    albedo_texture_ = texture;
}

void Material::set_normal_texture(std::shared_ptr<Texture> texture) {
    normal_texture_ = texture;
}

} // namespace are
```

### 文件：src/scene/light.cpp

```cpp
#include "scene/light.h"
#include <glm/gtc/constants.hpp>

namespace are {

Light::Light()
    : type_(LightType::POINT)
    , position_(0.0f, 5.0f, 0.0f)
    , direction_(0.0f, -1.0f, 0.0f)
    , color_(1.0f, 1.0f, 1.0f)
    , intensity_(1.0f)
    , range_(10.0f)
    , inner_angle_(glm::radians(30.0f))
    , outer_angle_(glm::radians(45.0f)) {
}

Light::~Light() {
}

void Light::set_type(LightType type) {
    type_ = type;
}

void Light::set_position(const Vec3& position) {
    position_ = position;
}

void Light::set_direction(const Vec3& direction) {
    direction_ = glm::normalize(direction);
}

void Light::set_color(const Vec3& color) {
    color_ = color;
}

void Light::set_intensity(float intensity) {
    intensity_ = intensity;
}

void Light::set_range(float range) {
    range_ = range;
}

void Light::set_spot_angles(float inner_angle, float outer_angle) {
    inner_angle_ = glm::radians(inner_angle);
    outer_angle_ = glm::radians(outer_angle);
}

} // namespace are
```

### 文件：src/scene/scene.cpp

```cpp
#include "scene/scene.h"

namespace are {

Scene::Scene() {
    // Create default camera
    camera_ = std::make_shared<Camera>();
}

Scene::~Scene() {
    clear();
}

uint Scene::add_mesh(std::shared_ptr<Mesh> mesh) {
    meshes_.push_back(mesh);
    return static_cast<uint>(meshes_.size() - 1);
}

uint Scene::add_material(std::shared_ptr<Material> material) {
    materials_.push_back(material);
    return static_cast<uint>(materials_.size() - 1);
}

uint Scene::add_light(std::shared_ptr<Light> light) {
    lights_.push_back(light);
    return static_cast<uint>(lights_.size() - 1);
}

void Scene::set_camera(std::shared_ptr<Camera> camera) {
    camera_ = camera;
}

void Scene::clear() {
    meshes_.clear();
    materials_.clear();
    lights_.clear();
}

void Scene::update(float delta_time) {
    // Reserved for future animation/physics updates
    (void)delta_time; // Suppress unused parameter warning
}

} // namespace are
```

### 文件：src/scene/mesh.cpp

```cpp
#include "scene/mesh.h"
#include "utils/logger.h"
#include <glad/glad.h>

namespace are {

Mesh::Mesh()
    : material_id_(0)
    , transform_(1.0f)
    , vao_(0)
    , vbo_(0)
    , ebo_(0)
    , uploaded_(false) {
}

Mesh::~Mesh() {
    release_gpu_resources();
}

void Mesh::set_vertices(const std::vector<Vertex>& vertices) {
    vertices_ = vertices;
    uploaded_ = false;
}

void Mesh::set_indices(const std::vector<uint>& indices) {
    indices_ = indices;
    uploaded_ = false;
}

void Mesh::set_material(uint material_id) {
    material_id_ = material_id;
}

void Mesh::set_transform(const Mat4& transform) {
    transform_ = transform;
}

bool Mesh::upload_to_gpu() {
    if (uploaded_) {
        Logger::warning("Mesh already uploaded to GPU");
        return true;
    }
    
    if (vertices_.empty()) {
        Logger::error("Cannot upload mesh: no vertices");
        return false;
    }
    
    if (indices_.empty()) {
        Logger::error("Cannot upload mesh: no indices");
        return false;
    }
    
    // Generate VAO
    glGenVertexArrays(1, &vao_);
    glBindVertexArray(vao_);
    
    // Generate and upload VBO
    glGenBuffers(1, &vbo_);
    glBindBuffer(GL_ARRAY_BUFFER, vbo_);
    glBufferData(GL_ARRAY_BUFFER, vertices_.size() * sizeof(Vertex), 
                vertices_.data(), GL_STATIC_DRAW);
    
    // Generate and upload EBO
    glGenBuffers(1, &ebo_);
    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ebo_);
    glBufferData(GL_ELEMENT_ARRAY_BUFFER, indices_.size() * sizeof(uint),
                indices_.data(), GL_STATIC_DRAW);
    
    // Set vertex attributes
    // Location 0: Position
    glEnableVertexAttribArray(0);
    glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, sizeof(Vertex),
                         (void*)offsetof(Vertex, position_));
    
    // Location 1: Normal
    glEnableVertexAttribArray(1);
    glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, sizeof(Vertex),
                         (void*)offsetof(Vertex, normal_));
    
    // Location 2: TexCoord
    glEnableVertexAttribArray(2);
    glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, sizeof(Vertex),
                         (void*)offsetof(Vertex, texcoord_));
    
    // Location 3: Tangent
    glEnableVertexAttribArray(3);
    glVertexAttribPointer(3, 3, GL_FLOAT, GL_FALSE, sizeof(Vertex),
                         (void*)offsetof(Vertex, tangent_));
    
    glBindVertexArray(0);
    
    uploaded_ = true;
    Logger::info("Mesh uploaded to GPU successfully");
    return true;
}

void Mesh::release_gpu_resources() {
    if (!uploaded_) return;
    
    if (vao_ != 0) {
        glDeleteVertexArrays(1, &vao_);
        vao_ = 0;
    }
    
    if (vbo_ != 0) {
        glDeleteBuffers(1, &vbo_);
        vbo_ = 0;
    }
    
    if (ebo_ != 0) {
        glDeleteBuffers(1, &ebo_);
        ebo_ = 0;
    }
    
    uploaded_ = false;
}

} // namespace are
```

### 文件：src/resource/buffer.cpp

```cpp
#include "resource/buffer.h"
#include "utils/logger.h"
#include <glad/glad.h>

namespace are {

namespace {
    GLenum get_gl_buffer_type(BufferType type) {
        switch (type) {
            case BufferType::VERTEX_BUFFER: return GL_ARRAY_BUFFER;
            case BufferType::INDEX_BUFFER: return GL_ELEMENT_ARRAY_BUFFER;
            case BufferType::UNIFORM_BUFFER: return GL_UNIFORM_BUFFER;
            case BufferType::SHADER_STORAGE_BUFFER: return GL_SHADER_STORAGE_BUFFER;
            default: return GL_ARRAY_BUFFER;
        }
    }
    
    GLenum get_gl_usage(BufferUsage usage) {
        switch (usage) {
            case BufferUsage::STATIC_DRAW: return GL_STATIC_DRAW;
            case BufferUsage::DYNAMIC_DRAW: return GL_DYNAMIC_DRAW;
            case BufferUsage::STREAM_DRAW: return GL_STREAM_DRAW;
            default: return GL_STATIC_DRAW;
        }
    }
}

Buffer::Buffer()
    : handle_(INVALID_HANDLE)
    , type_(BufferType::VERTEX_BUFFER)
    , size_(0)
    , usage_(BufferUsage::STATIC_DRAW) {
}

Buffer::~Buffer() {
    // Don't auto-release, let user control lifetime
}

bool Buffer::create(BufferType type, size_t size, const void* data, BufferUsage usage) {
    if (handle_ != INVALID_HANDLE) {
        Logger::warning("Buffer already created, releasing old buffer");
        release();
    }
    
    type_ = type;
    size_ = size;
    usage_ = usage;
    
    glGenBuffers(1, &handle_);
    
    GLenum gl_type = get_gl_buffer_type(type);
    GLenum gl_usage = get_gl_usage(usage);
    
    glBindBuffer(gl_type, handle_);
    glBufferData(gl_type, size, data, gl_usage);
    glBindBuffer(gl_type, 0);
    
    Logger::info("Buffer created successfully");
    return true;
}

void Buffer::update(size_t offset, size_t size, const void* data) {
    if (handle_ == INVALID_HANDLE) {
        Logger::error("Cannot update invalid buffer");
        return;
    }
    
    if (offset + size > size_) {
        Logger::error("Buffer update out of bounds");
        return;
    }
    
    GLenum gl_type = get_gl_buffer_type(type_);
    
    glBindBuffer(gl_type, handle_);
    glBufferSubData(gl_type, offset, size, data);
    glBindBuffer(gl_type, 0);
}

void Buffer::bind() const {
    if (handle_ == INVALID_HANDLE) {
        Logger::warning("Attempting to bind invalid buffer");
        return;
    }
    
    GLenum gl_type = get_gl_buffer_type(type_);
    glBindBuffer(gl_type, handle_);
}

void Buffer::bind_base(uint binding_point) const {
    if (handle_ == INVALID_HANDLE) {
        Logger::warning("Attempting to bind invalid buffer");
        return;
    }
    
    GLenum gl_type = get_gl_buffer_type(type_);
    glBindBufferBase(gl_type, binding_point, handle_);
}

void Buffer::unbind() const {
    GLenum gl_type = get_gl_buffer_type(type_);
    glBindBuffer(gl_type, 0);
}

void Buffer::release() {
    if (handle_ != INVALID_HANDLE) {
        glDeleteBuffers(1, &handle_);
        handle_ = INVALID_HANDLE;
    }
    
    size_ = 0;
}

} // namespace are
```

### 文件：src/resource/model_loader.cpp

```cpp
#include "resource/model_loader.h"
#include "utils/logger.h"
#include "resource/texture.h"

// Note: This is a simplified implementation without Assimp
// For full implementation, include Assimp and implement properly

namespace are {

bool ModelLoader::load(const std::string& path,
                      std::vector<std::shared_ptr<Mesh>>& meshes,
                      std::vector<std::shared_ptr<Material>>& materials,
                      bool flip_uvs) {
    Logger::error("ModelLoader requires Assimp library (not implemented in this version)");
    Logger::info("To implement: include <assimp/Importer.hpp>, <assimp/scene.h>, <assimp/postprocess.h>");
    
    // Placeholder implementation
    // TODO: Implement with Assimp
    /*
    Assimp::Importer importer;
    const aiScene* scene = importer.ReadFile(path, 
        aiProcess_Triangulate | 
        aiProcess_GenNormals |
        aiProcess_CalcTangentSpace |
        (flip_uvs ? aiProcess_FlipUVs : 0));
    
    if (!scene || scene->mFlags & AI_SCENE_FLAGS_INCOMPLETE || !scene->mRootNode) {
        Logger::error("Failed to load model: " + std::string(importer.GetErrorString()));
        return false;
    }
    
    std::string directory = path.substr(0, path.find_last_of('/'));
    process_node_(scene->mRootNode, scene, meshes, materials, directory);
    
    Logger::info("Model loaded: " + path);
    return true;
    */
    
    return false;
}

bool ModelLoader::load_and_upload(const std::string& path,
                                 std::vector<std::shared_ptr<Mesh>>& meshes,
                                 std::vector<std::shared_ptr<Material>>& materials,
                                 bool flip_uvs) {
    if (!load(path, meshes, materials, flip_uvs)) {
        return false;
    }
    
    // Upload all meshes to GPU
    for (auto& mesh : meshes) {
        if (!mesh->upload_to_gpu()) {
            Logger::error("Failed to upload mesh to GPU");
            return false;
        }
    }
    
    return true;
}

void ModelLoader::process_node_(void* node, void* scene,
                               std::vector<std::shared_ptr<Mesh>>& meshes,
                               std::vector<std::shared_ptr<Material>>& materials,
                               const std::string& directory) {
    // TODO: Implement with Assimp
    /*
    aiNode* ai_node = static_cast<aiNode*>(node);
    const aiScene* ai_scene = static_cast<const aiScene*>(scene);
    
    // Process all meshes in this node
    for (uint i = 0; i < ai_node->mNumMeshes; ++i) {
        aiMesh* ai_mesh = ai_scene->mMeshes[ai_node->mMeshes[i]];
        meshes.push_back(process_mesh_(ai_mesh, ai_scene, materials, directory));
    }
    
    // Process children recursively
    for (uint i = 0; i < ai_node->mNumChildren; ++i) {
        process_node_(ai_node->mChildren[i], ai_scene, meshes, materials, directory);
    }
    */
}

std::shared_ptr<Mesh> ModelLoader::process_mesh_(void* mesh, void* scene,
                                                std::vector<std::shared_ptr<Material>>& materials,
                                                const std::string& directory) {
    // TODO: Implement with Assimp
    /*
    aiMesh* ai_mesh = static_cast<aiMesh*>(mesh);
    const aiScene* ai_scene = static_cast<const aiScene*>(scene);
    
    std::vector<Vertex> vertices;
    std::vector<uint> indices;
    
    // Process vertices
    for (uint i = 0; i < ai_mesh->mNumVertices; ++i) {
        Vertex vertex;
        
        vertex.position_ = Vec3(ai_mesh->mVertices[i].x,
                               ai_mesh->mVertices[i].y,
                               ai_mesh->mVertices[i].z);
        
        if (ai_mesh->HasNormals()) {
            vertex.normal_ = Vec3(ai_mesh->mNormals[i].x,
                                 ai_mesh->mNormals[i].y,
                                 ai_mesh->mNormals[i].z);
        }
        
        if (ai_mesh->mTextureCoords[0]) {
            vertex.texcoord_ = Vec2(ai_mesh->mTextureCoords[0][i].x,
                                   ai_mesh->mTextureCoords[0][i].y);
        }
        
        if (ai_mesh->HasTangentsAndBitangents()) {
            vertex.tangent_ = Vec3(ai_mesh->mTangents[i].x,
                                  ai_mesh->mTangents[i].y,
                                  ai_mesh->mTangents[i].z);
        }
        
        vertices.push_back(vertex);
    }
    
    // Process indices
    for (uint i = 0; i < ai_mesh->mNumFaces; ++i) {
        aiFace face = ai_mesh->mFaces[i];
        for (uint j = 0; j < face.mNumIndices; ++j) {
            indices.push_back(face.mIndices[j]);
        }
    }
    
    // Process material
    uint material_id = materials.size();
    if (ai_mesh->mMaterialIndex >= 0) {
        aiMaterial* ai_material = ai_scene->mMaterials[ai_mesh->mMaterialIndex];
        
        auto material = std::make_shared<Material>();
        
        // Load diffuse color
        aiColor3D color;
        if (ai_material->Get(AI_MATKEY_COLOR_DIFFUSE, color) == AI_SUCCESS) {
            material->set_albedo(Vec3(color.r, color.g, color.b));
        }
        
        // Load textures
        load_material_textures_(ai_material, aiTextureType_DIFFUSE, material, directory);
        load_material_textures_(ai_material, aiTextureType_NORMALS, material, directory);
        
        materials.push_back(material);
    }
    
    auto mesh_obj = std::make_shared<Mesh>();
    mesh_obj->set_vertices(vertices);
    mesh_obj->set_indices(indices);
    mesh_obj->set_material(material_id);
    
    return mesh_obj;
    */
    
    return nullptr;
}

void ModelLoader::load_material_textures_(void* material, int type,
                                         std::shared_ptr<Material>& mat,
                                         const std::string& directory) {
    // TODO: Implement with Assimp
    /*
    aiMaterial* ai_material = static_cast<aiMaterial*>(material);
    aiTextureType ai_type = static_cast<aiTextureType>(type);
    
    for (uint i = 0; i < ai_material->GetTextureCount(ai_type); ++i) {
        aiString str;
        ai_material->GetTexture(ai_type, i, &str);
        
        std::string filename = directory + "/" + std::string(str.C_Str());
        
        auto texture = std::make_shared<Texture>();
        if (texture->load_from_file(filename)) {
            if (ai_type == aiTextureType_DIFFUSE) {
                mat->set_albedo_texture(texture);
            } else if (ai_type == aiTextureType_NORMALS) {
                mat->set_normal_texture(texture);
            }
        }
    }
    */
}

} // namespace are
```

### 文件：src/resource/shader.cpp

```cpp
#include "resource/shader.h"
#include "utils/logger.h"
#include "basic/math.h"  // 修改为math.h
#include <glad/glad.h>
#include <fstream>
#include <sstream>

namespace are {

Shader::Shader()
    : handle_(INVALID_HANDLE) {
}

Shader::~Shader() {
    // Don't auto-release, let user control lifetime
}

bool Shader::load(const std::string& vertex_path, const std::string& fragment_path) {
    std::string vertex_source = read_file_(vertex_path);
    std::string fragment_source = read_file_(fragment_path);
    
    if (vertex_source.empty() || fragment_source.empty()) {
        Logger::error("Failed to read shader files");
        return false;
    }
    
    return compile(vertex_source, fragment_source);
}

bool Shader::load_compute(const std::string& compute_path) {
    std::string compute_source = read_file_(compute_path);
    
    if (compute_source.empty()) {
        Logger::error("Failed to read compute shader file");
        return false;
    }
    
    return compile_compute(compute_source);
}

bool Shader::compile(const std::string& vertex_source, const std::string& fragment_source) {
    uint vertex_shader = compile_shader_(vertex_source, GL_VERTEX_SHADER);
    if (vertex_shader == 0) return false;
    
    uint fragment_shader = compile_shader_(fragment_source, GL_FRAGMENT_SHADER);
    if (fragment_shader == 0) {
        glDeleteShader(vertex_shader);
        return false;
    }
    
    uint shaders[] = { vertex_shader, fragment_shader };
    bool success = link_program_(shaders, 2);
    
    glDeleteShader(vertex_shader);
    glDeleteShader(fragment_shader);
    
    return success;
}

bool Shader::compile_compute(const std::string& compute_source) {
    uint compute_shader = compile_shader_(compute_source, GL_COMPUTE_SHADER);
    if (compute_shader == 0) return false;
    
    uint shaders[] = { compute_shader };
    bool success = link_program_(shaders, 1);
    
    glDeleteShader(compute_shader);
    
    return success;
}

void Shader::use() const {  // 改为const
    if (handle_ != INVALID_HANDLE) {
        glUseProgram(handle_);
    }
}

void Shader::release() {
    if (handle_ != INVALID_HANDLE) {
        glDeleteProgram(handle_);
        handle_ = INVALID_HANDLE;
    }
    uniform_cache_.clear();
}

void Shader::set_bool(const std::string& name, bool value) const {  // 新增
    glUniform1i(get_uniform_location_(name), static_cast<int>(value));
}

void Shader::set_int(const std::string& name, int value) const {  // 改为const
    glUniform1i(get_uniform_location_(name), value);
}

void Shader::set_uint(const std::string& name, uint value) const {  // 改为const
    glUniform1ui(get_uniform_location_(name), value);
}

void Shader::set_float(const std::string& name, float value) const {  // 改为const
    glUniform1f(get_uniform_location_(name), value);
}

void Shader::set_vec2(const std::string& name, const Vec2& value) const {  // 改为const
    glUniform2fv(get_uniform_location_(name), 1, &value[0]);
}

void Shader::set_vec3(const std::string& name, const Vec3& value) const {  // 改为const
    glUniform3fv(get_uniform_location_(name), 1, &value[0]);
}

void Shader::set_vec4(const std::string& name, const Vec4& value) const {  // 改为const
    glUniform4fv(get_uniform_location_(name), 1, &value[0]);
}

void Shader::set_mat3(const std::string& name, const Mat3& value) const {  // 改为const
    glUniformMatrix3fv(get_uniform_location_(name), 1, GL_FALSE, &value[0][0]);
}

void Shader::set_mat4(const std::string& name, const Mat4& value) const {  // 改为const
    glUniformMatrix4fv(get_uniform_location_(name), 1, GL_FALSE, MathUtils::value_ptr(value));
}

int Shader::get_uniform_location_(const std::string& name) const {  // 改为const
    auto it = uniform_cache_.find(name);
    if (it != uniform_cache_.end()) {
        return it->second;
    }
    
    int location = glGetUniformLocation(handle_, name.c_str());
    uniform_cache_[name] = location;  // mutable允许修改
    
    if (location == -1) {
        Logger::warning("Uniform '" + name + "' not found in shader");
    }
    
    return location;
}

uint Shader::compile_shader_(const std::string& source, uint type) {
    uint shader = glCreateShader(type);
    const char* source_cstr = source.c_str();
    glShaderSource(shader, 1, &source_cstr, nullptr);
    glCompileShader(shader);
    
    int success;
    glGetShaderiv(shader, GL_COMPILE_STATUS, &success);
    if (!success) {
        char info_log[512];
        glGetShaderInfoLog(shader, 512, nullptr, info_log);
        
        std::string type_str = (type == GL_VERTEX_SHADER) ? "VERTEX" :
                              (type == GL_FRAGMENT_SHADER) ? "FRAGMENT" : "COMPUTE";
        Logger::error("Shader compilation failed (" + type_str + "): " + std::string(info_log));
        
        glDeleteShader(shader);
        return 0;
    }
    
    return shader;
}

bool Shader::link_program_(const uint* shaders, uint count) {
    handle_ = glCreateProgram();
    
    for (uint i = 0; i < count; ++i) {
        glAttachShader(handle_, shaders[i]);
    }
    
    glLinkProgram(handle_);
    
    int success;
    glGetProgramiv(handle_, GL_LINK_STATUS, &success);
    if (!success) {
        char info_log[512];
        glGetProgramInfoLog(handle_, 512, nullptr, info_log);
        Logger::error("Shader linking failed: " + std::string(info_log));
        
        glDeleteProgram(handle_);
        handle_ = INVALID_HANDLE;
        return false;
    }
    
    return true;
}

std::string Shader::read_file_(const std::string& path) {
    std::ifstream file(path);
    if (!file.is_open()) {
        Logger::error("Failed to open file: " + path);
        return "";
    }
    
    std::stringstream buffer;
    buffer << file.rdbuf();
    return buffer.str();
}

} // namespace are
```

### 文件：src/resource/texture.cpp

```cpp
#include "resource/texture.h"
#include "utils/logger.h"
#include <glad/glad.h>
#include <stb_image.h>

namespace are {

namespace {
    GLenum get_gl_internal_format(TextureFormat format) {
        switch (format) {
            case TextureFormat::R8: return GL_R8;
            case TextureFormat::RG8: return GL_RG8;
            case TextureFormat::RGB8: return GL_RGB8;
            case TextureFormat::RGBA8: return GL_RGBA8;
            case TextureFormat::R16F: return GL_R16F;
            case TextureFormat::RG16F: return GL_RG16F;
            case TextureFormat::RGB16F: return GL_RGB16F;
            case TextureFormat::RGBA16F: return GL_RGBA16F;
            case TextureFormat::R32F: return GL_R32F;
            case TextureFormat::RG32F: return GL_RG32F;
            case TextureFormat::RGB32F: return GL_RGB32F;
            case TextureFormat::RGBA32F: return GL_RGBA32F;
            case TextureFormat::DEPTH24_STENCIL8: return GL_DEPTH24_STENCIL8;
            default: return GL_RGBA8;
        }
    }
    
    GLenum get_gl_format(TextureFormat format) {
        switch (format) {
            case TextureFormat::R8:
            case TextureFormat::R16F:
            case TextureFormat::R32F:
                return GL_RED;
            case TextureFormat::RG8:
            case TextureFormat::RG16F:
            case TextureFormat::RG32F:
                return GL_RG;
            case TextureFormat::RGB8:
            case TextureFormat::RGB16F:
            case TextureFormat::RGB32F:
                return GL_RGB;
            case TextureFormat::RGBA8:
            case TextureFormat::RGBA16F:
            case TextureFormat::RGBA32F:
                return GL_RGBA;
            case TextureFormat::DEPTH24_STENCIL8:
                return GL_DEPTH_STENCIL;
            default:
                return GL_RGBA;
        }
    }
    
    GLenum get_gl_type(TextureFormat format) {
        switch (format) {
            case TextureFormat::R8:
            case TextureFormat::RG8:
            case TextureFormat::RGB8:
            case TextureFormat::RGBA8:
                return GL_UNSIGNED_BYTE;
            case TextureFormat::R16F:
            case TextureFormat::RG16F:
            case TextureFormat::RGB16F:
            case TextureFormat::RGBA16F:
            case TextureFormat::R32F:
            case TextureFormat::RG32F:
            case TextureFormat::RGB32F:
            case TextureFormat::RGBA32F:
                return GL_FLOAT;
            case TextureFormat::DEPTH24_STENCIL8:
                return GL_UNSIGNED_INT_24_8;
            default:
                return GL_UNSIGNED_BYTE;
        }
    }
    
    GLenum get_gl_filter(TextureFilter filter) {
        switch (filter) {
            case TextureFilter::NEAREST: return GL_NEAREST;
            case TextureFilter::LINEAR: return GL_LINEAR;
            case TextureFilter::NEAREST_MIPMAP_NEAREST: return GL_NEAREST_MIPMAP_NEAREST;
            case TextureFilter::LINEAR_MIPMAP_NEAREST: return GL_LINEAR_MIPMAP_NEAREST;
            case TextureFilter::NEAREST_MIPMAP_LINEAR: return GL_NEAREST_MIPMAP_LINEAR;
            case TextureFilter::LINEAR_MIPMAP_LINEAR: return GL_LINEAR_MIPMAP_LINEAR;
            default: return GL_LINEAR;
        }
    }
    
    GLenum get_gl_wrap(TextureWrap wrap) {
        switch (wrap) {
            case TextureWrap::REPEAT: return GL_REPEAT;
            case TextureWrap::MIRRORED_REPEAT: return GL_MIRRORED_REPEAT;
            case TextureWrap::CLAMP_TO_EDGE: return GL_CLAMP_TO_EDGE;
            case TextureWrap::CLAMP_TO_BORDER: return GL_CLAMP_TO_BORDER;
            default: return GL_REPEAT;
        }
    }
}

Texture::Texture()
    : handle_(INVALID_HANDLE)
    , width_(0)
    , height_(0)
    , format_(TextureFormat::RGBA8)
    , has_mipmaps_(false) {
}

Texture::~Texture() {
    // Don't auto-release, let user control lifetime
}

bool Texture::load_from_file(const std::string& path, bool generate_mipmaps) {
    // Load image using stb_image
    int width, height, channels;
    stbi_set_flip_vertically_on_load(true);
    unsigned char* data = stbi_load(path.c_str(), &width, &height, &channels, 0);
    
    if (!data) {
        Logger::error("Failed to load texture: " + path);
        return false;
    }
    
    // Determine format based on channels
    TextureFormat format;
    switch (channels) {
        case 1: format = TextureFormat::R8; break;
        case 2: format = TextureFormat::RG8; break;
        case 3: format = TextureFormat::RGB8; break;
        case 4: format = TextureFormat::RGBA8; break;
        default:
            Logger::error("Unsupported channel count: " + std::to_string(channels));
            stbi_image_free(data);
            return false;
    }
    
    // Create texture
    bool success = create(width, height, format);
    if (!success) {
        stbi_image_free(data);
        return false;
    }
    
    // Upload data
    success = upload(data, width, height, format);
    stbi_image_free(data);
    
    if (!success) {
        return false;
    }
    
    // Generate mipmaps if requested
    if (generate_mipmaps) {
        this->generate_mipmaps();
    }
    
    Logger::info("Texture loaded successfully: " + path);
    return true;
}

bool Texture::create(uint width, uint height, TextureFormat format) {
    if (handle_ != INVALID_HANDLE) {
        Logger::warning("Texture already created, releasing old texture");
        release();
    }
    
    width_ = width;
    height_ = height;
    format_ = format;
    
    glGenTextures(1, &handle_);
    glBindTexture(GL_TEXTURE_2D, handle_);
    
    GLenum internal_format = get_gl_internal_format(format);
    GLenum gl_format = get_gl_format(format);
    GLenum type = get_gl_type(format);
    
    glTexImage2D(GL_TEXTURE_2D, 0, internal_format, width, height, 0, gl_format, type, nullptr);
    
    // Set default parameters
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
    
    glBindTexture(GL_TEXTURE_2D, 0);
    
    return true;
}

bool Texture::upload(const void* data, uint width, uint height, TextureFormat format) {
    if (handle_ == INVALID_HANDLE) {
        Logger::error("Cannot upload to invalid texture");
        return false;
    }
    
    if (width != width_ || height != height_ || format != format_) {
        Logger::warning("Upload parameters differ from texture creation, recreating texture");
        create(width, height, format);
    }
    
    glBindTexture(GL_TEXTURE_2D, handle_);
    
    GLenum gl_format = get_gl_format(format);
    GLenum type = get_gl_type(format);
    
    glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, width, height, gl_format, type, data);
    
    glBindTexture(GL_TEXTURE_2D, 0);
    
    return true;
}

void Texture::set_filter(TextureFilter min_filter, TextureFilter mag_filter) {
    if (handle_ == INVALID_HANDLE) {
        Logger::error("Cannot set filter on invalid texture");
        return;
    }
    
    glBindTexture(GL_TEXTURE_2D, handle_);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, get_gl_filter(min_filter));
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, get_gl_filter(mag_filter));
    glBindTexture(GL_TEXTURE_2D, 0);
}

void Texture::set_wrap(TextureWrap wrap_s, TextureWrap wrap_t) {
    if (handle_ == INVALID_HANDLE) {
        Logger::error("Cannot set wrap mode on invalid texture");
        return;
    }
    
    glBindTexture(GL_TEXTURE_2D, handle_);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, get_gl_wrap(wrap_s));
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, get_gl_wrap(wrap_t));
    glBindTexture(GL_TEXTURE_2D, 0);
}

void Texture::generate_mipmaps() {
    if (handle_ == INVALID_HANDLE) {
        Logger::error("Cannot generate mipmaps for invalid texture");
        return;
    }
    
    glBindTexture(GL_TEXTURE_2D, handle_);
    glGenerateMipmap(GL_TEXTURE_2D);
    glBindTexture(GL_TEXTURE_2D, 0);
    
    has_mipmaps_ = true;
}

void Texture::bind(uint unit) const {
    if (handle_ == INVALID_HANDLE) {
        Logger::warning("Attempting to bind invalid texture");
        return;
    }
    
    glActiveTexture(GL_TEXTURE0 + unit);
    glBindTexture(GL_TEXTURE_2D, handle_);
}

void Texture::unbind() const {
    glBindTexture(GL_TEXTURE_2D, 0);
}

void Texture::release() {
    if (handle_ != INVALID_HANDLE) {
        glDeleteTextures(1, &handle_);
        handle_ = INVALID_HANDLE;
    }
    
    width_ = 0;
    height_ = 0;
    has_mipmaps_ = false;
}

} // namespace are
```

### 文件：src/utils/config.cpp

```cpp
#include "utils/config.h"
#include "utils/logger.h"
#include <fstream>
#include <sstream>
#include <algorithm>

namespace are {

// Static storage
static std::unordered_map<std::string, std::string> g_config_map;

// Helper function to trim whitespace
static std::string trim(const std::string& str) {
    size_t first = str.find_first_not_of(" \t\r\n");
    if (first == std::string::npos) return "";
    size_t last = str.find_last_not_of(" \t\r\n");
    return str.substr(first, last - first + 1);
}

bool Config::load(const std::string& path) {
    std::ifstream file(path);
    if (!file.is_open()) {
        Logger::error("Failed to open config file: " + path);
        return false;
    }
    
    g_config_map.clear();
    
    std::string line;
    std::string current_section;
    
    while (std::getline(file, line)) {
        line = trim(line);
        
        // Skip empty lines and comments
        if (line.empty() || line[0] == '#' || line[0] == ';') {
            continue;
        }
        
        // Section header
        if (line[0] == '[' && line.back() == ']') {
            current_section = line.substr(1, line.length() - 2);
            continue;
        }
        
        // Key-value pair
        size_t pos = line.find('=');
        if (pos != std::string::npos) {
            std::string key = trim(line.substr(0, pos));
            std::string value = trim(line.substr(pos + 1));
            
            // Add section prefix if in a section
            if (!current_section.empty()) {
                key = current_section + "." + key;
            }
            
            g_config_map[key] = value;
        }
    }
    
    Logger::info("Config loaded: " + path + " (" + std::to_string(g_config_map.size()) + " entries)");
    return true;
}

bool Config::save(const std::string& path) {
    std::ofstream file(path);
    if (!file.is_open()) {
        Logger::error("Failed to open config file for writing: " + path);
        return false;
    }
    
    for (const auto& pair : g_config_map) {
        file << pair.first << "=" << pair.second << std::endl;
    }
    
    Logger::info("Config saved: " + path);
    return true;
}

std::string Config::get_string(const std::string& key, const std::string& default_value) {
    auto it = g_config_map.find(key);
    if (it != g_config_map.end()) {
        return it->second;
    }
    return default_value;
}

int Config::get_int(const std::string& key, int default_value) {
    auto it = g_config_map.find(key);
    if (it != g_config_map.end()) {
        try {
            return std::stoi(it->second);
        } catch (...) {
            Logger::warning("Failed to parse int for key: " + key);
        }
    }
    return default_value;
}

float Config::get_float(const std::string& key, float default_value) {
    auto it = g_config_map.find(key);
    if (it != g_config_map.end()) {
        try {
            return std::stof(it->second);
        } catch (...) {
            Logger::warning("Failed to parse float for key: " + key);
        }
    }
    return default_value;
}

bool Config::get_bool(const std::string& key, bool default_value) {
    auto it = g_config_map.find(key);
    if (it != g_config_map.end()) {
        std::string value = it->second;
        std::transform(value.begin(), value.end(), value.begin(), ::tolower);
        
        if (value == "true" || value == "1" || value == "yes" || value == "on") {
            return true;
        }
        if (value == "false" || value == "0" || value == "no" || value == "off") {
            return false;
        }
    }
    return default_value;
}

void Config::set_string(const std::string& key, const std::string& value) {
    g_config_map[key] = value;
}

void Config::set_int(const std::string& key, int value) {
    g_config_map[key] = std::to_string(value);
}

void Config::set_float(const std::string& key, float value) {
    g_config_map[key] = std::to_string(value);
}

void Config::set_bool(const std::string& key, bool value) {
    g_config_map[key] = value ? "true" : "false";
}

} // namespace are
```

### 文件：src/utils/logger.cpp

```cpp
#include "utils/logger.h"
#include <iostream>
#include <fstream>
#include <ctime>
#include <iomanip>
#include <sstream>

namespace are {

// Static members
static LogLevel g_min_level = LogLevel::DEBUG;
static std::ofstream g_log_file;
static bool g_initialized = false;

bool Logger::initialize(const std::string& log_file) {
    if (g_initialized) {
        return true;
    }
    
    if (!log_file.empty()) {
        g_log_file.open(log_file, std::ios::out | std::ios::app);
        if (!g_log_file.is_open()) {
            std::cerr << "Failed to open log file: " << log_file << std::endl;
            return false;
        }
    }
    
    g_initialized = true;
    return true;
}

void Logger::shutdown() {
    if (g_log_file.is_open()) {
        g_log_file.close();
    }
    g_initialized = false;
}

static std::string get_current_time() {
    auto now = std::time(nullptr);
    auto tm = *std::localtime(&now);
    std::ostringstream oss;
    oss << std::put_time(&tm, "%H:%M:%S");
    return oss.str();
}

static std::string level_to_string(LogLevel level) {
    switch (level) {
        case LogLevel::DEBUG: return "DEBUG";
        case LogLevel::INFO: return "INFO";
        case LogLevel::WARNING: return "WARN";
        case LogLevel::ERROR: return "ERROR";
        case LogLevel::FATAL: return "FATAL";
        default: return "UNKNOWN";
    }
}

void Logger::log(LogLevel level, const std::string& message) {
    if (level < g_min_level) return;
    
    std::string time_str = get_current_time();
    std::string level_str = level_to_string(level);
    std::string formatted = "[" + time_str + "] [" + level_str + "] " + message;
    
    // Console output
    if (level >= LogLevel::ERROR) {
        std::cerr << formatted << std::endl;
    } else {
        std::cout << formatted << std::endl;
    }
    
    // File output
    if (g_log_file.is_open()) {
        g_log_file << formatted << std::endl;
        g_log_file.flush();
    }
}

void Logger::debug(const std::string& message) {
    log(LogLevel::DEBUG, message);
}

void Logger::info(const std::string& message) {
    log(LogLevel::INFO, message);
}

void Logger::warning(const std::string& message) {
    log(LogLevel::WARNING, message);
}

void Logger::error(const std::string& message) {
    log(LogLevel::ERROR, message);
}

void Logger::fatal(const std::string& message) {
    log(LogLevel::FATAL, message);
}

void Logger::set_level(LogLevel level) {
    g_min_level = level;
}

} // namespace are
```