### 文件：include/are/core/types.h
```cpp
/**
 * @file types.h
 * @brief Basic type definitions and constants
 */

#ifndef ARE_INCLUDE_CORE_TYPES_H
#define ARE_INCLUDE_CORE_TYPES_H

#include <cstdint>
#include <glm/glm.hpp>

namespace are {

// Floating point precision
using Real = float;

// Common vector types
using Vec2 = glm::vec2;
using Vec3 = glm::vec3;
using Vec4 = glm::vec4;

using Vec2i = glm::ivec2;
using Vec3i = glm::ivec3;
using Vec4i = glm::ivec4;

// Matrix types
using Mat3 = glm::mat3;
using Mat4 = glm::mat4;

// Color type (RGBA)
using Color = Vec4;

// Handle types for resource management
using MeshHandle = uint32_t;
using MaterialHandle = uint32_t;
using LightHandle = uint32_t;
using TextureHandle = uint32_t;

// Invalid handle constant
constexpr uint32_t are_invalid_handle = 0xFFFFFFFF;

// Mathematical constants
constexpr Real are_pi = 3.14159265358979323846f;
constexpr Real are_two_pi = 6.28318530717958647692f;
constexpr Real are_inv_pi = 0.31830988618379067154f;
constexpr Real are_inv_two_pi = 0.15915494309189533577f;
constexpr Real are_epsilon = 1e-6f;

// Ray tracing backend types
enum class RayTracingBackend {
    ARE_RT_BACKEND_CPU,
    ARE_RT_BACKEND_COMPUTE_SHADER
};

// Tone mapping operators
enum class ToneMappingOperator {
    ARE_TONEMAP_NONE,
    ARE_TONEMAP_REINHARD,
    ARE_TONEMAP_ACES
};

// G-Buffer visualization modes
enum class GBufferVisualizationMode {
    ARE_GBUFFER_VIS_NONE,
    ARE_GBUFFER_VIS_POSITION,
    ARE_GBUFFER_VIS_NORMAL,
    ARE_GBUFFER_VIS_ALBEDO,
    ARE_GBUFFER_VIS_METALLIC,
    ARE_GBUFFER_VIS_ROUGHNESS,
    ARE_GBUFFER_VIS_DEPTH
};

} // namespace are

#endif // ARE_INCLUDE_CORE_TYPES_H
```

### 文件：include/are/core/logger.h
```cpp
/**
 * @file logger.h
 * @brief Logging system for the rendering engine
 */

#ifndef ARE_INCLUDE_CORE_LOGGER_H
#define ARE_INCLUDE_CORE_LOGGER_H

#include <string>
#include <memory>

namespace are {

/**
 * @enum LogLevel
 * @brief Logging severity levels
 */
enum class LogLevel {
    ARE_LOG_TRACE,
    ARE_LOG_DEBUG,
    ARE_LOG_INFO,
    ARE_LOG_WARN,
    ARE_LOG_ERROR,
    ARE_LOG_CRITICAL
};

/**
 * @class Logger
 * @brief Thread-safe logging system
 * 
 * This class provides a simple interface for logging messages with different
 * severity levels. It wraps spdlog for actual logging functionality.
 */
class Logger {
public:
    /**
     * @brief Initialize the logging system
     * @param min_level Minimum log level to display
     */
    static void init(LogLevel min_level = LogLevel::ARE_LOG_INFO);

    /**
     * @brief Shutdown the logging system
     */
    static void shutdown();

    /**
     * @brief Log a message with file/function/line information
     * @param level Log severity level
     * @param file Source file name
     * @param func Function name
     * @param line Line number
     * @param message Log message
     */
    static void log(LogLevel level, const char* file, const char* func, 
                   int line, const std::string& message);

    /**
     * @brief Set minimum log level
     * @param level Minimum log level to display
     */
    static void set_level(LogLevel level);

private:
    static std::shared_ptr<void> logger_impl_; ///< Internal logger implementation
    static bool initialized_;                   ///< Initialization flag
};

} // namespace are

// Logging macros
#define ARE_LOG_TRACE(msg)    are::Logger::log(are::LogLevel::ARE_LOG_TRACE, __FILE__, __func__, __LINE__, msg)
#define ARE_LOG_DEBUG(msg)    are::Logger::log(are::LogLevel::ARE_LOG_DEBUG, __FILE__, __func__, __LINE__, msg)
#define ARE_LOG_INFO(msg)     are::Logger::log(are::LogLevel::ARE_LOG_INFO, __FILE__, __func__, __LINE__, msg)
#define ARE_LOG_WARN(msg)     are::Logger::log(are::LogLevel::ARE_LOG_WARN, __FILE__, __func__, __LINE__, msg)
#define ARE_LOG_ERROR(msg)    are::Logger::log(are::LogLevel::ARE_LOG_ERROR, __FILE__, __func__, __LINE__, msg)
#define ARE_LOG_CRITICAL(msg) are::Logger::log(are::LogLevel::ARE_LOG_CRITICAL, __FILE__, __func__, __LINE__, msg)

#endif // ARE_INCLUDE_CORE_LOGGER_H
```

### 文件：include/are/core/config.h
```cpp
/**
 * @file config.h
 * @brief Configuration system for the rendering engine
 */

#ifndef ARE_INCLUDE_CORE_CONFIG_H
#define ARE_INCLUDE_CORE_CONFIG_H

#include <are/core/types.h>
#include <string>

namespace are {

/**
 * @struct WindowConfig
 * @brief Configuration for window creation
 */
struct WindowConfig {
	int width = 1280; ///< Window width in pixels
	int height = 720; ///< Window height in pixels
	std::string title = "Aurora Rendering Engine"; ///< Window title
	bool resizable = true; ///< Whether window is resizable
	bool vsync = true; ///< Enable vertical synchronization
	int samples = 1; ///< MSAA samples (1 = disabled)
};

/**
 * @struct RayTracingConfig
 * @brief Configuration for ray tracing
 */
struct RayTracingConfig {
	RayTracingBackend backend = RayTracingBackend::ARE_RT_BACKEND_COMPUTE_SHADER;
	int spp = 64; ///< Samples per pixel
	int max_depth = 8; ///< Maximum ray bounce depth
	bool enable_gi = true; ///< Enable global illumination
	bool enable_ao = true; ///< Enable ambient occlusion
	bool enable_soft_shadows = false; ///< Enable soft shadows
	int ao_samples = 16; ///< AO sample count
	Real ao_radius = 1.0f; ///< AO sampling radius
};

/**
 * @struct RenderConfig
 * @brief General rendering configuration
 */
struct RenderConfig {
	ToneMappingOperator tonemap_op = ToneMappingOperator::ARE_TONEMAP_ACES;
	Real exposure = 1.0f; ///< Exposure value for tone mapping
	bool use_hdr = true; ///< Use HDR rendering pipeline
	GBufferVisualizationMode gbuffer_vis_mode = GBufferVisualizationMode::ARE_GBUFFER_VIS_NONE;
};

/**
 * @struct PerformanceConfig
 * @brief Performance-related configuration
 */
struct PerformanceConfig {
	int num_threads = 0; ///< Number of threads (0 = auto-detect)
	bool enable_bvh_multithreading = true; ///< Use multithreading for BVH construction
	bool enable_profiling = false; ///< Enable performance profiling
};

/**
 * @struct PathConfig
 * @brief File path configuration
 */
struct PathConfig {
	std::string shader_dir = "shaders/"; ///< Directory containing shader files
	std::string texture_dir = "textures/"; ///< Default texture directory
	std::string output_dir = "output/"; ///< Default output directory
};

/**
 * @class AreConfig
 * @brief Main configuration class for Aurora Rendering Engine
 */
class AreConfig {
public:
	WindowConfig window; ///< Window configuration
	RayTracingConfig ray_tracing; ///< Ray tracing configuration
	RenderConfig render; ///< Rendering configuration
	PerformanceConfig performance; ///< Performance configuration
	PathConfig paths; ///< Path configuration

	/**
	 * @brief Constructor with default values
	 */
	AreConfig() = default;

	/**
	 * @brief Validate configuration values
	 * @return true if configuration is valid, false otherwise
	 */
	bool validate() const;

	/**
	 * @brief Print configuration to console
	 */
	void print() const;
};

} // namespace are

#endif // ARE_INCLUDE_CORE_CONFIG_H
```

### 文件：include/are/utils/math_utils.h
```cpp
/**
 * @file math_utils.h
 * @brief Mathematical utility functions
 */

#ifndef ARE_INCLUDE_UTILS_MATH_UTILS_H
#define ARE_INCLUDE_UTILS_MATH_UTILS_H

#include <are/core/types.h>
#include <algorithm>

namespace are {

/**
 * @brief Clamp value to range [min, max]
 * @param value Value to clamp
 * @param min Minimum value
 * @param max Maximum value
 * @return Clamped value
 */
template<typename T>
inline T clamp(T value, T min, T max) {
    return std::max(min, std::min(value, max));
}

/**
 * @brief Linear interpolation
 * @param a Start value
 * @param b End value
 * @param t Interpolation factor [0, 1]
 * @return Interpolated value
 */
template<typename T>
inline T lerp(T a, T b, Real t) {
    return a + (b - a) * t;
}

/**
 * @brief Convert degrees to radians
 * @param degrees Angle in degrees
 * @return Angle in radians
 */
inline Real degrees_to_radians(Real degrees) {
    return degrees * are_pi / 180.0f;
}

/**
 * @brief Convert radians to degrees
 * @param radians Angle in radians
 * @return Angle in degrees
 */
inline Real radians_to_degrees(Real radians) {
    return radians * 180.0f / are_pi;
}

/**
 * @brief Check if two floating point values are approximately equal
 * @param a First value
 * @param b Second value
 * @param epsilon Tolerance
 * @return true if approximately equal
 */
inline bool approx_equal(Real a, Real b, Real epsilon = are_epsilon) {
    return std::abs(a - b) < epsilon;
}

/**
 * @brief Compute barycentric coordinates
 * @param p Point
 * @param a Triangle vertex A
 * @param b Triangle vertex B
 * @param c Triangle vertex C
 * @param u Output barycentric coordinate u
 * @param v Output barycentric coordinate v
 * @param w Output barycentric coordinate w
 */
void compute_barycentric(const Vec3& p, const Vec3& a, const Vec3& b, const Vec3& c,
                        Real& u, Real& v, Real& w);

/**
 * @brief Reflect vector around normal
 * @param incident Incident vector
 * @param normal Surface normal (normalized)
 * @return Reflected vector
 */
Vec3 reflect(const Vec3& incident, const Vec3& normal);

/**
 * @brief Refract vector through surface
 * @param incident Incident vector (normalized)
 * @param normal Surface normal (normalized)
 * @param eta Ratio of refractive indices
 * @param refracted Output refracted vector
 * @return true if refraction occurred (false for total internal reflection)
 */
bool refract(const Vec3& incident, const Vec3& normal, Real eta, Vec3& refracted);

/**
 * @brief Compute Fresnel reflectance (Schlick approximation)
 * @param cos_theta Cosine of angle between view and normal
 * @param f0 Reflectance at normal incidence
 * @return Fresnel reflectance
 */
Real fresnel_schlick(Real cos_theta, Real f0);

/**
 * @brief Create orthonormal basis from normal
 * @param normal Normal vector (normalized)
 * @param tangent Output tangent vector
 * @param bitangent Output bitangent vector
 */
void create_orthonormal_basis(const Vec3& normal, Vec3& tangent, Vec3& bitangent);

/**
 * @brief Transform direction from tangent space to world space
 * @param tangent_dir Direction in tangent space
 * @param normal Surface normal
 * @param tangent Surface tangent
 * @param bitangent Surface bitangent
 * @return Direction in world space
 */
Vec3 tangent_to_world(const Vec3& tangent_dir, const Vec3& normal, 
                     const Vec3& tangent, const Vec3& bitangent);

} // namespace are

#endif // ARE_INCLUDE_UTILS_MATH_UTILS_H
```

### 文件：include/are/core/profiler.h
```cpp
/**
 * @file profiler.h
 * @brief Performance profiling utilities
 */

#ifndef ARE_INCLUDE_CORE_PROFILER_H
#define ARE_INCLUDE_CORE_PROFILER_H

#include <are/core/types.h>
#include <string>
#include <chrono>
#include <unordered_map>

namespace are {

/**
 * @struct ProfileResult
 * @brief Result of a profiling measurement
 */
struct ProfileResult {
    std::string name_;                    ///< Profile section name
    double duration_ms_;                  ///< Duration in milliseconds
    uint64_t call_count_;                 ///< Number of times called
    double avg_duration_ms_;              ///< Average duration per call
};

/**
 * @class Profiler
 * @brief Simple performance profiler
 * 
 * This class provides basic timing functionality for performance analysis.
 * It is only active when ARE_ENABLE_PROFILING is defined.
 */
class Profiler {
public:
    /**
     * @brief Initialize the profiler
     */
    static void init();

    /**
     * @brief Shutdown the profiler and print results
     */
    static void shutdown();

    /**
     * @brief Begin a profiling section
     * @param name Section name
     */
    static void begin(const std::string& name);

	/**
     * @brief End a profiling section
     * @param name Section name
     */
    static void end(const std::string& name);

    /**
     * @brief Get profiling results
     * @return Map of section names to profile results
     */
    static const std::unordered_map<std::string, ProfileResult>& get_results();

    /**
     * @brief Reset all profiling data
     */
    static void reset();

    /**
     * @brief Print profiling results to console
     */
    static void print_results();

private:
    struct SectionData {
        std::chrono::high_resolution_clock::time_point start_time_;
        double total_duration_ms_ = 0.0;
        uint64_t call_count_ = 0;
    };

    static std::unordered_map<std::string, SectionData> sections_;
    static std::unordered_map<std::string, ProfileResult> results_;
    static bool enabled_;
};

/**
 * @class ScopedProfiler
 * @brief RAII-style profiler for automatic timing
 */
class ScopedProfiler {
public:
    /**
     * @brief Constructor - begins profiling
     * @param name Section name
     */
    explicit ScopedProfiler(const std::string& name);

    /**
     * @brief Destructor - ends profiling
     */
    ~ScopedProfiler();

private:
    std::string name_;
};

} // namespace are

// Profiling macros
#ifdef ARE_ENABLE_PROFILING
	#define ARE_PROFILE_BEGIN(name) are::Profiler::begin(name)
    #define ARE_PROFILE_END(name)   are::Profiler::end(name)
    #define ARE_PROFILE_SCOPE(name) are::ScopedProfiler are_profiler_##__LINE__(name)
    #define ARE_PROFILE_FUNCTION()  ARE_PROFILE_SCOPE(__func__)
#else
    #define ARE_PROFILE_BEGIN(name) ((void)0)
    #define ARE_PROFILE_END(name)   ((void)0)
    #define ARE_PROFILE_SCOPE(name) ((void)0)
    #define ARE_PROFILE_FUNCTION()  ((void)0)
#endif

#endif // ARE_INCLUDE_CORE_PROFILER_H
```

### 文件：src/core/logger.cpp
```cpp
/**
 * @file logger.cpp
 * @brief Implementation of logging system
 */

#include <are/core/logger.h>
#include <spdlog/spdlog.h>
#include <spdlog/sinks/stdout_color_sinks.h>
#include <spdlog/sinks/basic_file_sink.h>
#include <mutex>
#include <cstring>

namespace are {

std::shared_ptr<void> Logger::logger_impl_ = nullptr;
bool Logger::initialized_ = false;

void Logger::init(LogLevel min_level) {
    if (initialized_) {
        return;
    }

    try {
        // Create console sink with color support
        auto console_sink = std::make_shared<spdlog::sinks::stdout_color_sink_mt>();
        console_sink->set_pattern("[%H:%M:%S.%e] [%^%l%$] %v");

        // Create logger with console sink
        auto logger = std::make_shared<spdlog::logger>("are", console_sink);
        
        // Set log level
        switch (min_level) {
            case LogLevel::ARE_LOG_TRACE:    
                logger->set_level(spdlog::level::trace); 
                break;
            case LogLevel::ARE_LOG_DEBUG:    
                logger->set_level(spdlog::level::debug); 
                break;
            case LogLevel::ARE_LOG_INFO:     
                logger->set_level(spdlog::level::info); 
                break;
            case LogLevel::ARE_LOG_WARN:     
                logger->set_level(spdlog::level::warn); 
                break;
            case LogLevel::ARE_LOG_ERROR:    
                logger->set_level(spdlog::level::err); 
                break;
            case LogLevel::ARE_LOG_CRITICAL: 
                logger->set_level(spdlog::level::critical); 
                break;
        }

        // Flush on error or higher
        logger->flush_on(spdlog::level::err);

        // Set as default logger
        spdlog::set_default_logger(logger);
        logger_impl_ = logger;
        initialized_ = true;

    } catch (const std::exception& e) {
        fprintf(stderr, "[ARE] Failed to initialize logger: %s\n", e.what());
    }
}

void Logger::shutdown() {
    if (!initialized_) {
        return;
    }

    try {
        spdlog::shutdown();
        logger_impl_.reset();
        initialized_ = false;
    } catch (const std::exception& e) {
        fprintf(stderr, "[ARE] Error during logger shutdown: %s\n", e.what());
    }
}

void Logger::log(LogLevel level, const char* file, const char* func, 
                int line, const std::string& message) {
    if (!initialized_) {
        init();
    }

    // Extract filename from full path
    const char* filename = file;
    const char* last_slash = nullptr;
    
    for (const char* p = file; *p; ++p) {
        if (*p == '/' || *p == '\\') {
            last_slash = p;
        }
    }
    
    if (last_slash) {
        filename = last_slash + 1;
    }

    // Format message with location information
    std::string formatted = message + " (" + filename + ":" + std::to_string(line) + ")";

    try {
        auto logger = std::static_pointer_cast<spdlog::logger>(logger_impl_);
        
        switch (level) {
            case LogLevel::ARE_LOG_TRACE:
                logger->trace(formatted);
                break;
            case LogLevel::ARE_LOG_DEBUG:
                logger->debug(formatted);
                break;
            case LogLevel::ARE_LOG_INFO:
                logger->info(formatted);
                break;
            case LogLevel::ARE_LOG_WARN:
                logger->warn(formatted);
                break;
            case LogLevel::ARE_LOG_ERROR:
                logger->error(formatted);
                break;
            case LogLevel::ARE_LOG_CRITICAL:
                logger->critical(formatted);
                break;
        }
    } catch (const std::exception& e) {
        fprintf(stderr, "[ARE] Logging error: %s\n", e.what());
    }
}

void Logger::set_level(LogLevel level) {
    if (!initialized_) {
        return;
    }

    try {
        auto logger = std::static_pointer_cast<spdlog::logger>(logger_impl_);
        
        switch (level) {
            case LogLevel::ARE_LOG_TRACE:    
                logger->set_level(spdlog::level::trace); 
                break;
            case LogLevel::ARE_LOG_DEBUG:    
                logger->set_level(spdlog::level::debug); 
                break;
            case LogLevel::ARE_LOG_INFO:     
                logger->set_level(spdlog::level::info); 
                break;
            case LogLevel::ARE_LOG_WARN:     
                logger->set_level(spdlog::level::warn); 
                break;
            case LogLevel::ARE_LOG_ERROR:    
                logger->set_level(spdlog::level::err); 
                break;
            case LogLevel::ARE_LOG_CRITICAL: 
                logger->set_level(spdlog::level::critical); 
                break;
        }
    } catch (const std::exception& e) {
        fprintf(stderr, "[ARE] Error setting log level: %s\n", e.what());
    }
}

} // namespace are
```

### 文件：CMakeLists.txt
```CMakeLists.txt
cmake_minimum_required(VERSION 3.15)
project(AuroraRenderingEngine VERSION 0.1.0 LANGUAGES CXX C)

# Set C++ standard
set(CMAKE_CXX_STANDARD 17)
set(CMAKE_CXX_STANDARD_REQUIRED ON)
set(CMAKE_CXX_EXTENSIONS OFF)

# Set C standard for GLAD
set(CMAKE_C_STANDARD 99)
set(CMAKE_C_STANDARD_REQUIRED ON)

# Build options
option(ARE_BUILD_SHARED "Build shared library" OFF)
option(ARE_BUILD_EXAMPLES "Build example programs" ON)
option(ARE_ENABLE_PROFILING "Enable performance profiling" ON)
option(ARE_ENABLE_DEBUG_VIS "Enable debug visualization" ON)

# Set output directories
set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/lib)
set(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/lib)
set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin)

# Compiler flags
if(MSVC)
    add_compile_options(/W4)
    add_compile_definitions(_CRT_SECURE_NO_WARNINGS)
    # Disable specific warnings that are too strict
    add_compile_options(/wd4100)  # unreferenced formal parameter
else()
    add_compile_options(-Wall -Wextra -pedantic)
    # Disable specific warnings
    add_compile_options(-Wno-unused-parameter)
endif()

# Find required packages
find_package(OpenGL REQUIRED)
find_package(glfw3 REQUIRED)
find_package(glm REQUIRED)

# Try to find spdlog (system installation)
find_package(spdlog QUIET)

if(NOT spdlog_FOUND)
    message(STATUS "spdlog not found in system, using local version")
    # Use local spdlog
    set(SPDLOG_INCLUDE_DIR "${CMAKE_SOURCE_DIR}/lib/spdlog/include")
    if(NOT EXISTS ${SPDLOG_INCLUDE_DIR})
        message(FATAL_ERROR "spdlog not found. Please install spdlog or place it in lib/spdlog/")
    endif()
    add_library(spdlog INTERFACE)
    target_include_directories(spdlog INTERFACE ${SPDLOG_INCLUDE_DIR})
    # spdlog compile definitions
    target_compile_definitions(spdlog INTERFACE SPDLOG_COMPILED_LIB)
endif()

# Find OpenMP (optional)
find_package(OpenMP)
if(OpenMP_CXX_FOUND)
    set(ARE_USE_OPENMP ON)
    add_compile_definitions(ARE_USE_OPENMP)
    message(STATUS "OpenMP found and enabled")
else()
    message(STATUS "OpenMP not found, multithreading will use std::thread")
endif()

# GLAD library path
set(GLAD_INCLUDE_DIR "${CMAKE_SOURCE_DIR}/lib/glad")
set(GLAD_SOURCE_DIR "${CMAKE_SOURCE_DIR}/lib/glad")

if(NOT EXISTS ${GLAD_INCLUDE_DIR})
    message(FATAL_ERROR "GLAD include directory not found: ${GLAD_INCLUDE_DIR}")
endif()

if(NOT EXISTS ${GLAD_SOURCE_DIR})
    message(FATAL_ERROR "GLAD source directory not found: ${GLAD_SOURCE_DIR}")
endif()

# STB library path
set(STB_INCLUDE_DIR "${CMAKE_SOURCE_DIR}/lib/stb")

if(NOT EXISTS ${STB_INCLUDE_DIR})
    message(FATAL_ERROR "STB include directory not found: ${STB_INCLUDE_DIR}")
endif()

# Collect all source files from src/
file(GLOB_RECURSE ARE_SOURCES 
    "${CMAKE_SOURCE_DIR}/src/*.cpp"
    "${CMAKE_SOURCE_DIR}/src/*.c"
)

# Collect all GLAD source files
file(GLOB GLAD_SOURCES 
    "${GLAD_SOURCE_DIR}/*.c"
)

# Add GLAD sources to ARE sources
list(APPEND ARE_SOURCES ${GLAD_SOURCES})

# Collect all header files
file(GLOB_RECURSE ARE_HEADERS 
    "${CMAKE_SOURCE_DIR}/include/*.h"
    "${CMAKE_SOURCE_DIR}/include/*.hpp"
)

# Create library
if(ARE_BUILD_SHARED)
    add_library(are SHARED ${ARE_SOURCES} ${ARE_HEADERS})
    target_compile_definitions(are PRIVATE ARE_BUILD_SHARED)
    message(STATUS "Building shared library")
else()
    add_library(are STATIC ${ARE_SOURCES} ${ARE_HEADERS})
    message(STATUS "Building static library")
endif()

# Set target properties
set_target_properties(are PROPERTIES
    VERSION ${PROJECT_VERSION}
    SOVERSION ${PROJECT_VERSION_MAJOR}
    PUBLIC_HEADER "${ARE_HEADERS}"
)

# Include directories
target_include_directories(are
    PUBLIC
        $<BUILD_INTERFACE:${CMAKE_SOURCE_DIR}/include>
        $<INSTALL_INTERFACE:include>
    PRIVATE
        ${CMAKE_SOURCE_DIR}/src
        ${GLAD_INCLUDE_DIR}
        ${STB_INCLUDE_DIR}
)

# Link libraries
target_link_libraries(are
    PUBLIC
        OpenGL::GL
        glfw
        glm::glm
)

# Link spdlog
if(spdlog_FOUND)
    target_link_libraries(are PUBLIC spdlog::spdlog)
else()
    target_link_libraries(are PUBLIC spdlog)
    target_include_directories(are PRIVATE ${SPDLOG_INCLUDE_DIR})
endif()

# Link OpenMP if available
if(OpenMP_CXX_FOUND)
    target_link_libraries(are PUBLIC OpenMP::OpenMP_CXX)
endif()

# Platform-specific libraries
if(UNIX AND NOT APPLE)
    target_link_libraries(are PUBLIC dl pthread)
endif()

# Compile definitions
if(ARE_ENABLE_PROFILING)
    target_compile_definitions(are PUBLIC ARE_ENABLE_PROFILING)
    message(STATUS "Profiling enabled")
endif()

if(ARE_ENABLE_DEBUG_VIS)
    target_compile_definitions(are PUBLIC ARE_ENABLE_DEBUG_VIS)
    message(STATUS "Debug visualization enabled")
endif()

# Build examples
if(ARE_BUILD_EXAMPLES)
    # Define helper function for creating examples
    function(add_are_example EXAMPLE_NAME)
        add_executable(${EXAMPLE_NAME} ${ARGN})
        target_link_libraries(${EXAMPLE_NAME} PRIVATE are)
        set_target_properties(${EXAMPLE_NAME} PROPERTIES
            RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin
        )
    endfunction()
    
    # Add example subdirectories
    add_subdirectory(examples/00_phase1_test)
    
    message(STATUS "Examples will be built")
endif()

# Installation rules
install(TARGETS are
    ARCHIVE DESTINATION lib
    LIBRARY DESTINATION lib
    RUNTIME DESTINATION bin
    PUBLIC_HEADER DESTINATION include/are
)

install(DIRECTORY ${CMAKE_SOURCE_DIR}/include/are
    DESTINATION include
    FILES_MATCHING PATTERN "*.h" PATTERN "*.hpp"
)

install(DIRECTORY ${CMAKE_SOURCE_DIR}/shaders
    DESTINATION share/are/shaders
)

# Print configuration summary
message(STATUS "")
message(STATUS "========================================")
message(STATUS "Aurora Rendering Engine Configuration")
message(STATUS "========================================")
message(STATUS "  Version:              ${PROJECT_VERSION}")
message(STATUS "  Build type:           ${CMAKE_BUILD_TYPE}")
message(STATUS "  Library type:         ${ARE_BUILD_SHARED}")
message(STATUS "  C++ standard:         ${CMAKE_CXX_STANDARD}")
message(STATUS "  Compiler:             ${CMAKE_CXX_COMPILER_ID} ${CMAKE_CXX_COMPILER_VERSION}")
message(STATUS "")
message(STATUS "Features:")
message(STATUS "  OpenMP support:       ${ARE_USE_OPENMP}")
message(STATUS "  Build examples:       ${ARE_BUILD_EXAMPLES}")
message(STATUS "  Enable profiling:     ${ARE_ENABLE_PROFILING}")
message(STATUS "  Enable debug vis:     ${ARE_ENABLE_DEBUG_VIS}")
message(STATUS "")
message(STATUS "Dependencies:")
message(STATUS "  OpenGL:               ${OPENGL_LIBRARIES}")
message(STATUS "  GLFW:                 Found")
message(STATUS "  GLM:                  Found")
if(spdlog_FOUND)
    message(STATUS "  spdlog:               Found (system)")
else()
    message(STATUS "  spdlog:               Found (local)")
endif()
message(STATUS "  GLAD:                 ${GLAD_INCLUDE_DIR}")
message(STATUS "  STB:                  ${STB_INCLUDE_DIR}")
message(STATUS "")
message(STATUS "Output directories:")
message(STATUS "  Executables:          ${CMAKE_BINARY_DIR}/bin")
message(STATUS "  Libraries:            ${CMAKE_BINARY_DIR}/lib")
message(STATUS "========================================")
message(STATUS "")
```

接下来，其实我已经实现了所有头文件，下面是Phase 2的头文件：
### 文件：vertex.h
```cpp
/**
 * @file vertex.h
 * @brief Vertex data structure definition
 */

#ifndef ARE_INCLUDE_GEOMETRY_VERTEX_H
#define ARE_INCLUDE_GEOMETRY_VERTEX_H

#include <are/core/types.h>

namespace are {

/**
 * @struct Vertex
 * @brief Standard vertex structure for mesh data
 * 
 * Contains position, normal, texture coordinates, and tangent information
 * for PBR rendering pipeline.
 */
struct Vertex {
    Vec3 position_;///< Vertex position in object space
    Vec3 normal_;                         ///< Vertex normal (normalized)
    Vec2 texcoord_;                       ///< Texture coordinates (UV)
    Vec3 tangent_;                        ///< Tangent vector for normal mapping

    Vertex() = default;

    /**
     * @brief Construct vertex with position only
     * @param pos Position
     */
    explicit Vertex(const Vec3& pos);

    /**
     * @brief Construct vertex with position and normal
     * @param pos Position
     * @param norm Normal
     */
    Vertex(const Vec3& pos, const Vec3& norm);

    /**
     * @brief Construct vertex with position, normal, and texcoord
     * @param pos Position
     * @param norm Normal
     * @param uv Texture coordinates
     */
    Vertex(const Vec3& pos, const Vec3& norm, const Vec2& uv);

    /**
     * @brief Construct vertex with all attributes
     * @param pos Position
     * @param norm Normal
     * @param uv Texture coordinates
     * @param tan Tangent
     */
    Vertex(const Vec3& pos, const Vec3& norm, const Vec2& uv, const Vec3& tan);

    /**
     * @brief Interpolate between two vertices
     * @param a First vertex
     * @param b Second vertex
     * @param t Interpolation factor [0, 1]
     * @return Interpolated vertex
     */
    static Vertex lerp(const Vertex& a, const Vertex& b, Real t);
};

/**
 * @brief Get vertex attribute stride for OpenGL
 * @return Size of Vertex structure in bytes
 */
constexpr size_t get_vertex_stride() {
    return sizeof(Vertex);
}

/**
 * @brief Get offset of position attribute
 * @return Offset in bytes
 */
constexpr size_t get_position_offset() {
    return offsetof(Vertex, position_);
}

/**
 * @brief Get offset of normal attribute
 * @return Offset in bytes
 */
constexpr size_t get_normal_offset() {
    return offsetof(Vertex, normal_);
}

/**
 * @brief Get offset of texcoord attribute
 * @return Offset in bytes
 */
constexpr size_t get_texcoord_offset() {
    return offsetof(Vertex, texcoord_);
}

/**
 * @brief Get offset of tangent attribute
 * @return Offset in bytes
 */
constexpr size_t get_tangent_offset() {
    return offsetof(Vertex, tangent_);
}

} // namespace are

#endif // ARE_INCLUDE_GEOMETRY_VERTEX_H
```

### 文件：triangle.h
```cpp
/**
 * @file triangle.h
 * @brief Triangle primitive definition
 */

#ifndef ARE_INCLUDE_GEOMETRY_TRIANGLE_H
#define ARE_INCLUDE_GEOMETRY_TRIANGLE_H

#include <are/core/types.h>
#include <are/geometry/vertex.h>
#include <are/geometry/aabb.h>

namespace are {

// Forward declaration
struct Ray;
struct HitRecord;

/**
 * @struct Triangle
 * @brief Triangle primitive for ray tracing
 * 
 * Stores three vertices and provides intersection testing.
 */
struct Triangle {
    Vertex v0_;                           ///< First vertex
    Vertex v1_;                           ///< Second vertex
    Vertex v2_;                           ///< Third vertex
    MaterialHandle material_;             ///< Material handle

    /**
     * @brief Default constructor
     */
    Triangle();

    /**
     * @brief Construct triangle from three vertices
     * @param v0 First vertex
     * @param v1 Second vertex
     * @param v2 Third vertex
     * @param material Material handle
     */
    Triangle(const Vertex& v0, const Vertex& v1, const Vertex& v2,
            MaterialHandle material = are_invalid_handle);

    /**
     * @brief Get triangle centroid
     * @return Centroid position
     */
    Vec3 centroid() const;

    /**
     * @brief Get triangle normal (geometric normal)
     * @return Normal vector (normalized)
     */
    Vec3 normal() const;

    /**
     * @brief Get triangle area
     * @return Area
     */
    Real area() const;

    /**
     * @brief Compute axis-aligned bounding box
     * @return AABB containing the triangle
     */
    AABB compute_aabb() const;

    /**
     * @brief Ray-triangle intersection test (Möller-Trumbore algorithm)
     * @param ray Ray to test
     * @param hit Output hit record
     * @return true if intersection occurred
     */
    bool intersect(const Ray& ray, HitRecord& hit) const;

    /**
     * @brief Fast ray-triangle intersection test (no hit record)
     * @param ray Ray to test
     * @param t_max Maximum t value
     * @return true if intersection occurred
     */
    bool intersect_fast(const Ray& ray, Real t_max) const;
};

} // namespace are

#endif // ARE_INCLUDE_GEOMETRY_TRIANGLE_H
```

### 文件：aabb.h
```cpp
/**
 * @file aabb.h
 * @brief Axis-Aligned Bounding Box implementation
 */

#ifndef ARE_INCLUDE_GEOMETRY_AABB_H
#define ARE_INCLUDE_GEOMETRY_AABB_H

#include <are/core/types.h>

namespace are {

// Forward declaration
struct Ray;

/**
 * @class AABB
 * @brief Axis-Aligned Bounding Box for spatial queries
 * 
 * Used for BVH construction and ray intersection acceleration.
 */
class AABB {
public:
    Vec3 min_;                            ///< Minimum corner
    Vec3 max_;                            ///< Maximum corner

    /**
     * @brief Default constructor - creates invalid AABB
     */
    AABB();

    /**
     * @brief Construct AABB from min and max corners
     * @param min Minimum corner
     * @param max Maximum corner
     */
    AABB(const Vec3& min, const Vec3& max);

    /**
     * @brief Construct AABB containing a single point
     * @param point Point to contain
     */
    explicit AABB(const Vec3& point);

    /**
     * @brief Check if AABB is valid (min <= max)
     * @return true if valid
     */
    bool is_valid() const;

    /**
     * @brief Get center of AABB
     * @return Center point
     */
    Vec3 center() const;

    /**
     * @brief Get size (extent) of AABB
     * @return Size vector
     */
    Vec3 size() const;

    /**
     * @brief Get surface area of AABB
     * @return Surface area
     */
    Real surface_area() const;

    /**
     * @brief Get volume of AABB
     * @return Volume
     */
    Real volume() const;

    /**
     * @brief Get longest axis index (0=x, 1=y, 2=z)
     * @return Axis index
     */
    int longest_axis() const;

    /**
     * @brief Expand AABB to include a point
     * @param point Point to include
     */
    void expand(const Vec3& point);

    /**
     * @brief Expand AABB to include another AABB
     * @param other AABB to include
     */
    void expand(const AABB& other);

    /**
     * @brief Check if AABB contains a point
     * @param point Point to check
     * @return true if point is inside AABB
     */
    bool contains(const Vec3& point) const;

    /**
     * @brief Check if AABB intersects another AABB
     * @param other AABB to check
     * @return true if AABBs intersect
     */
    bool intersects(const AABB& other) const;

    /**
     * @brief Ray-AABB intersection test
     * @param ray Ray to test
     * @param t_min Minimum t value (output)
     * @param t_max Maximum t value (output)
     * @return true if ray intersects AABB
     */
    bool intersect_ray(const Ray& ray, Real& t_min, Real& t_max) const;

    /**
     * @brief Merge two AABBs
     * @param a First AABB
     * @param b Second AABB
     * @return Merged AABB containing both
     */
    static AABB merge(const AABB& a, const AABB& b);

    /**
     * @brief Create invalid AABB (for initialization)
     * @return Invalid AABB
     */
    static AABB invalid();
};

} // namespace are

#endif // ARE_INCLUDE_GEOMETRY_AABB_H
```

### 文件：transform.h
```cpp
/**
 * @file transform.h
 * @brief Transformation matrix utilities
 */

#ifndef ARE_INCLUDE_GEOMETRY_TRANSFORM_H
#define ARE_INCLUDE_GEOMETRY_TRANSFORM_H

#include <are/core/types.h>

namespace are {

/**
 * @class Transform
 * @brief 3D transformation (position, rotation, scale)
 * 
 * Provides convenient interface for building transformation matrices.
 */
class Transform {
public:
    /**
     * @brief Default constructor (identity transform)
     */
    Transform();

    /**
     * @brief Construct from position, rotation, and scale
     * @param position Translation
     * @param rotation Rotation (Euler angles in radians)
     * @param scale Scale factors
     */
    Transform(const Vec3& position, const Vec3& rotation, const Vec3& scale);

    // Setters
    void set_position(const Vec3& position);
    void set_rotation(const Vec3& rotation);
    void set_scale(const Vec3& scale);
    void set_scale(Real uniform_scale);

    // Getters
    const Vec3& get_position() const { return position_; }
    const Vec3& get_rotation() const { return rotation_; }
    const Vec3& get_scale() const { return scale_; }

    // Matrix operations
    Mat4 get_matrix() const;
    Mat4 get_inverse_matrix() const;
    Mat3 get_normal_matrix() const;

    /**
     * @brief Transform a point
     * @param point Point to transform
     * @return Transformed point
     */
    Vec3 transform_point(const Vec3& point) const;

    /**
     * @brief Transform a direction (ignores translation)
     * @param direction Direction to transform
     * @return Transformed direction
     */
    Vec3 transform_direction(const Vec3& direction) const;

    /**
     * @brief Transform a normal (uses inverse transpose)
     * @param normal Normal to transform
     * @return Transformed normal
     */
    Vec3 transform_normal(const Vec3& normal) const;

    /**
     * @brief Combine two transforms
     * @param other Other transform
     * @return Combined transform
     */
    Transform operator*(const Transform& other) const;

    /**
     * @brief Create identity transform
     * @return Identity transform
     */
    static Transform identity();

    /**
     * @brief Create translation transform
     * @param translation Translation vector
     * @return Translation transform
     */
    static Transform translate(const Vec3& translation);

    /**
     * @brief Create rotation transform
     * @param rotation Rotation (Euler angles in radians)
     * @return Rotation transform
     */
    static Transform rotate(const Vec3& rotation);

    /**
     * @brief Create scale transform
     * @param scale Scale factors
     * @return Scale transform
     */
    static Transform scale(const Vec3& scale);

private:
    void mark_dirty();
    void update_matrix() const;

    Vec3 position_;                       ///< Translation
    Vec3 rotation_;                       ///< Rotation (Euler angles)
    Vec3 scale_;                          ///< Scale factors

    mutable Mat4 matrix_;                 ///< Cached transformation matrix
    mutable Mat4 inverse_matrix_;         ///< Cached inverse matrix
    mutable bool dirty_;                  ///< Matrix needs update
};

} // namespace are

#endif // ARE_INCLUDE_GEOMETRY_TRANSFORM_H
```

### 文件：camera.h
```cpp
/**
 * @file camera.h
 * @brief Camera class for view and projection management
 */

#ifndef ARE_INCLUDE_SCENE_CAMERA_H
#define ARE_INCLUDE_SCENE_CAMERA_H

#include <are/core/types.h>

namespace are {

/**
 * @class Camera
 * @brief Perspective camera for rendering
 * 
 * Manages view and projection matrices, and provides ray generation
 * for ray tracing.
 */
class Camera {
public:
    /**
     * @brief Default constructor
     */
    Camera();

    /**
     * @brief Construct camera with position and target
     * @param position Camera position
     * @param target Look-at target
     * @param up Up vector
     */
    Camera(const Vec3& position, const Vec3& target, const Vec3& up = Vec3(0, 1, 0));

    // Position and orientation setters
    void set_position(const Vec3& position);
    void set_target(const Vec3& target);
    void set_up(const Vec3& up);
    void look_at(const Vec3& position, const Vec3& target, const Vec3& up = Vec3(0, 1, 0));

    // Projection setters
    void set_fov(Real fov_degrees);
    void set_aspect_ratio(Real aspect);
    void set_near_plane(Real near);
    void set_far_plane(Real far);
    void set_perspective(Real fov_degrees, Real aspect, Real near, Real far);

    // Getters
    const Vec3& get_position() const { return position_; }
    const Vec3& get_target() const { return target_; }
    const Vec3& get_up() const { return up_; }
    Real get_fov() const { return fov_; }
    Real get_aspect_ratio() const { return aspect_ratio_; }
    Real get_near_plane() const { return near_plane_; }
    Real get_far_plane() const { return far_plane_; }

    // Direction vectors
    Vec3 get_forward() const;
    Vec3 get_right() const;

    // Matrix getters
    const Mat4& get_view_matrix() const;
    const Mat4& get_projection_matrix() const;
    Mat4 get_view_projection_matrix() const;

    /**
     * @brief Generate ray for given pixel coordinates
     * @param u Normalized x coordinate [0, 1]
     * @param v Normalized y coordinate [0, 1]
     * @param origin Output ray origin
     * @param direction Output ray direction (normalized)
     */
    void generate_ray(Real u, Real v, Vec3& origin, Vec3& direction) const;

    /**
     * @brief Check if camera parameters have changed
     * @return true if matrices need recalculation
     */
    bool is_dirty() const { return dirty_; }

    /**
     * @brief Mark camera as clean after matrix update
     */
    void clear_dirty() { dirty_ = false; }

private:
    void update_view_matrix() const;
    void update_projection_matrix() const;

    Vec3 position_;                       ///< Camera position
    Vec3 target_;                         ///< Look-at target
    Vec3 up_;                             ///< Up vector

    Real fov_;                            ///< Field of view in degrees
    Real aspect_ratio_;                   ///< Aspect ratio (width/height)
    Real near_plane_;                     ///< Near clipping plane
    Real far_plane_;                      ///< Far clipping plane

    mutable Mat4 view_matrix_;            ///< Cached view matrix
    mutable Mat4 projection_matrix_;      ///< Cached projection matrix
    mutable bool view_dirty_;             ///< View matrix needs update
    mutable bool projection_dirty_;       ///< Projection matrix needs update
    bool dirty_;                          ///< Any parameter changed
};

} // namespace are

#endif // ARE_INCLUDE_SCENE_CAMERA_H
```

### 文件：mesh.h
```cpp
/**
 * @file mesh.h
 * @brief Mesh class for geometry storage
 */

#ifndef ARE_INCLUDE_SCENE_MESH_H
#define ARE_INCLUDE_SCENE_MESH_H

#include <are/core/types.h>
#include <are/geometry/vertex.h>
#include <are/geometry/aabb.h>
#include <vector>

namespace are {

/**
 * @class Mesh
 * @brief Triangle mesh container
 * 
 * Stores vertex and index data for a triangle mesh.
 * Supports automatic AABB computation.
 */
class Mesh {
public:
    /**
     * @brief Default constructor - creates empty mesh
     */
    Mesh();

    /**
     * @brief Construct mesh from vertex and index data
     * @param vertices Vertex array
     * @param indices Index array (triangles)
     * @param material_id Material handle
     */
    Mesh(const std::vector<Vertex>& vertices, 
         const std::vector<uint32_t>& indices,
         MaterialHandle material_id = are_invalid_handle);

    /**
     * @brief Construct mesh from raw arrays
     * @param vertices Vertex array pointer
     * @param vertex_count Number of vertices
     * @param indices Index array pointer
     * @param index_count Number of indices
     * @param material_id Material handle
     */
    Mesh(const Vertex* vertices, size_t vertex_count,
         const uint32_t* indices, size_t index_count,
         MaterialHandle material_id = are_invalid_handle);

    // Data setters
    void set_vertices(const std::vector<Vertex>& vertices);
    void set_indices(const std::vector<uint32_t>& indices);
    void set_material(MaterialHandle material_id);

    // Data getters
    const std::vector<Vertex>& get_vertices() const { return vertices_; }
    const std::vector<uint32_t>& get_indices() const { return indices_; }
    MaterialHandle get_material() const { return material_id_; }

    // Geometry queries
    size_t get_vertex_count() const { return vertices_.size(); }
    size_t get_index_count() const { return indices_.size(); }
    size_t get_triangle_count() const { return indices_.size() / 3; }
    bool is_empty() const { return vertices_.empty() || indices_.empty(); }

    // AABB
    const AABB& get_aabb() const { return aabb_; }
    void compute_aabb();

    /**
     * @brief Compute tangent vectors for normal mapping
     */
    void compute_tangents();/**
     * @brief Get triangle vertices by index
     * @param triangle_index Triangle index
     * @param v0 Output first vertex
     * @param v1 Output second vertex
     * @param v2 Output third vertex
     * @return true if triangle exists
     */
    bool get_triangle(size_t triangle_index, Vertex& v0, Vertex& v1, Vertex& v2) const;

    // GPU resource handles (set by Renderer)
    void set_vao(uint32_t vao) { vao_ = vao; }
    void set_vbo(uint32_t vbo) { vbo_ = vbo; }
    void set_ebo(uint32_t ebo) { ebo_ = ebo; }
    uint32_t get_vao() const { return vao_; }
    uint32_t get_vbo() const { return vbo_; }
    uint32_t get_ebo() const { return ebo_; }
    bool has_gpu_resources() const { return vao_ != 0; }

private:
    std::vector<Vertex> vertices_;        ///< Vertex data
    std::vector<uint32_t> indices_;       ///< Index data (triangles)
    MaterialHandle material_id_;          ///< Associated material
    AABB aabb_;                           ///< Bounding box

    // GPU resources
    uint32_t vao_;                         ///< Vertex Array Object
    uint32_t vbo_;                         ///< Vertex Buffer Object
    uint32_t ebo_;                         ///< Element Buffer Object
};

} // namespace are

#endif // ARE_INCLUDE_SCENE_MESH_H
```

### 文件：material.h
```cpp
/**
 * @file material.h
 * @brief PBR material definition
 */

#ifndef ARE_INCLUDE_SCENE_MATERIAL_H
#define ARE_INCLUDE_SCENE_MATERIAL_H

#include <are/core/types.h>
#include <string>

namespace are {

/**
 * @class Material
 * @brief Physically-based rendering material
 * 
 * Supports standard PBR workflow with metallic-roughness model.
 */
class Material {
public:
    /**
     * @brief Default constructor - creates default white material
     */
    Material();

    // Albedo (base color)
    void set_albedo(const Vec3& albedo);
    void set_albedo_map(const std::string& path);
    const Vec3& get_albedo() const { return albedo_; }
    const std::string& get_albedo_map() const { return albedo_map_; }
    bool has_albedo_map() const { return !albedo_map_.empty(); }

    // Metallic
    void set_metallic(Real metallic);
    void set_metallic_map(const std::string& path);
    Real get_metallic() const { return metallic_; }
    const std::string& get_metallic_map() const { return metallic_map_; }
    bool has_metallic_map() const { return !metallic_map_.empty(); }

    // Roughness
    void set_roughness(Real roughness);
    void set_roughness_map(const std::string& path);
    Real get_roughness() const { return roughness_; }
    const std::string& get_roughness_map() const { return roughness_map_; }
    bool has_roughness_map() const { return !roughness_map_.empty(); }

    // Normal map
    void set_normal_map(const std::string& path);
    const std::string& get_normal_map() const { return normal_map_; }
    bool has_normal_map() const { return !normal_map_.empty(); }

    // Ambient occlusion
    void set_ao_map(const std::string& path);
    const std::string& get_ao_map() const { return ao_map_; }
    bool has_ao_map() const { return !ao_map_.empty(); }

    // Emissive
    void set_emissive(const Vec3& emissive);
    void set_emissive_map(const std::string& path);
    const Vec3& get_emissive() const { return emissive_; }
    const std::string& get_emissive_map() const { return emissive_map_; }
    bool has_emissive_map() const { return !emissive_map_.empty(); }
    bool is_emissive() const;

    // Texture handles (set by TextureManager)
    void set_albedo_texture_handle(TextureHandle handle) { albedo_tex_handle_ = handle; }
    void set_metallic_texture_handle(TextureHandle handle) { metallic_tex_handle_ = handle; }
    void set_roughness_texture_handle(TextureHandle handle) { roughness_tex_handle_ = handle; }
    void set_normal_texture_handle(TextureHandle handle) { normal_tex_handle_ = handle; }
    void set_ao_texture_handle(TextureHandle handle) { ao_tex_handle_ = handle; }
    void set_emissive_texture_handle(TextureHandle handle) { emissive_tex_handle_ = handle; }

    TextureHandle get_albedo_texture_handle() const { return albedo_tex_handle_; }
    TextureHandle get_metallic_texture_handle() const { return metallic_tex_handle_; }
    TextureHandle get_roughness_texture_handle() const { return roughness_tex_handle_; }
    TextureHandle get_normal_texture_handle() const { return normal_tex_handle_; }
    TextureHandle get_ao_texture_handle() const { return ao_tex_handle_; }
    TextureHandle get_emissive_texture_handle() const { return emissive_tex_handle_; }

private:
    // Base values
    Vec3 albedo_;///< Base color (RGB)
    Real metallic_;                       ///< Metallic factor [0, 1]
    Real roughness_;                      ///< Roughness factor [0, 1]
    Vec3 emissive_;                       ///< Emissive color (RGB)

    // Texture paths
    std::string albedo_map_;
    std::string metallic_map_;
    std::string roughness_map_;
    std::string normal_map_;
    std::string ao_map_;
    std::string emissive_map_;

    // Texture handles (GPU resources)
    TextureHandle albedo_tex_handle_;
    TextureHandle metallic_tex_handle_;
    TextureHandle roughness_tex_handle_;
    TextureHandle normal_tex_handle_;
    TextureHandle ao_tex_handle_;
    TextureHandle emissive_tex_handle_;
};

} // namespace are

#endif // ARE_INCLUDE_SCENE_MATERIAL_H
```

### 文件：light.h
```cpp
/**
 * @file light.h
 * @brief Base light class and common light utilities
 */

#ifndef ARE_INCLUDE_SCENE_LIGHT_H
#define ARE_INCLUDE_SCENE_LIGHT_H

#include <are/core/types.h>

namespace are {

/**
 * @enum LightType
 * @brief Types of light sources
 */
enum class LightType {
    ARE_LIGHT_DIRECTIONAL,
    ARE_LIGHT_POINT,
    ARE_LIGHT_SPOT
};

/**
 * @struct LightData
 * @brief Packed light data for GPU transfer
 * 
 * This structure is designed to be efficiently transferred to GPU
 * via SSBO or UBO.
 */
struct LightData {
    Vec4 position_type_;                  ///< xyz: position, w: light type
    Vec4 direction_range_;                ///< xyz: direction, w: range
    Vec4 color_intensity_;                ///< xyz: color, w: intensity
    Vec4 params_;                         ///< Light-specific parameters
};

/**
 * @class Light
 * @brief Base class for all light types
 */
class Light {
public:
    /**
     * @brief Constructor
     * @param type Light type
     */
    explicit Light(LightType type);

    virtual ~Light() = default;

    // Common properties
    void set_color(const Vec3& color);
    void set_intensity(Real intensity);
    void set_cast_shadows(bool cast);

    const Vec3& get_color() const { return color_; }
    Real get_intensity() const { return intensity_; }
    bool get_cast_shadows() const { return cast_shadows_; }
    LightType get_type() const { return type_; }

    /**
     * @brief Pack light data for GPU transfer
     * @return Packed light data
     */
    virtual LightData pack() const = 0;

    /**
     * @brief Check if light affects a point
     * @param point World position
     * @return true if light can affect the point
     */
    virtual bool affects_point(const Vec3& point) const = 0;

protected:
    LightType type_;                      ///< Light type
    Vec3 color_;                          ///< Light color (RGB)
    Real intensity_;                      ///< Light intensity
    bool cast_shadows_;                   ///< Whether light casts shadows
};

} // namespace are

#endif // ARE_INCLUDE_SCENE_LIGHT_H
```

### 文件：scene_manager.h
```cpp
/**
 * @file scene_manager.h
 * @brief Scene data management
 */

#ifndef ARE_INCLUDE_SCENE_SCENE_MANAGER_H
#define ARE_INCLUDE_SCENE_SCENE_MANAGER_H

#include <are/core/types.h>
#include <are/scene/mesh.h>
#include <are/scene/material.h>
#include <are/scene/light.h>
#include <vector>
#include <memory>
#include <unordered_map>

namespace are {

/**
 * @class SceneManager
 * @brief Manages all scene objects (meshes, materials, lights)
 * 
 * Provides handle-based access to scene resources and tracks
 * scene modifications for BVH rebuilding.
 */
class SceneManager {
public:
    /**
     * @brief Constructor
     */
    SceneManager();

    /**
     * @brief Destructor
     */
    ~SceneManager();

    // Mesh management
    MeshHandle add_mesh(const Mesh& mesh);
    void remove_mesh(MeshHandle handle);
    void update_mesh(MeshHandle handle, const Mesh& mesh);
    Mesh* get_mesh(MeshHandle handle);
    const Mesh* get_mesh(MeshHandle handle) const;
    const std::vector<Mesh>& get_all_meshes() const { return meshes_; }

    // Material management
    MaterialHandle add_material(const Material& material);
    void remove_material(MaterialHandle handle);
    void update_material(MaterialHandle handle, const Material& material);
    Material* get_material(MaterialHandle handle);
    const Material* get_material(MaterialHandle handle) const;
    const std::vector<Material>& get_all_materials() const { return materials_; }

    // Light management
    LightHandle add_light(const std::shared_ptr<Light>& light);
    void remove_light(LightHandle handle);
    std::shared_ptr<Light> get_light(LightHandle handle);
    const std::vector<std::shared_ptr<Light>>& get_all_lights() const { return lights_; }

    // Scene queries
    size_t get_mesh_count() const { return meshes_.size(); }
    size_t get_material_count() const { return materials_.size(); }
    size_t get_light_count() const { return lights_.size(); }
    size_t get_total_triangle_count() const;

    // Scene state
    bool is_dirty() const { return dirty_; }
    void mark_dirty() { dirty_ = true; }
    void clear_dirty() { dirty_ = false; }

    /**
     * @brief Clear all scene data
     */
    void clear();

    /**
     * @brief Validate all handles and remove invalid entries
     */
    void compact();

private:
    std::vector<Mesh> meshes_;            ///< Mesh storage
    std::vector<Material> materials_;     ///< Material storage
    std::vector<std::shared_ptr<Light>> lights_; ///< Light storage

    std::unordered_map<MeshHandle, size_t> mesh_handle_map_;
    std::unordered_map<MaterialHandle, size_t> material_handle_map_;
    std::unordered_map<LightHandle, size_t> light_handle_map_;

    MeshHandle next_mesh_handle_;
    MaterialHandle next_material_handle_;
    LightHandle next_light_handle_;

    bool dirty_;                          ///< Scene modified flag
};

} // namespace are

#endif // ARE_INCLUDE_SCENE_SCENE_MANAGER_H
```
关于异常部分，你直接ARE_LOG_CRITICAL然后返回或者throw std::runtime_error即可；GLM已经有了自定义别名，且已经启用GLM扩展。
关于命名空间的话，就像你刚才看到的一样，代码包裹在are命名空间中。
还有需要我提供的东西吗？没有的话，你可以开始分步骤实现Phase 2。