你对代码的观察非常敏锐！我对你的实现计划表示认同，下面是你要求到的和可能用到的头文件：
### 文件：include/are/raytracer/ray.h
```cpp
/**
 * @file ray.h
 * @brief Ray structure for ray tracing
 */

#ifndef ARE_INCLUDE_RAYTRACER_RAY_H
#define ARE_INCLUDE_RAYTRACER_RAY_H

#include <are/core/types.h>

namespace are {

/**
 * @struct Ray
 * @brief Ray representation for ray tracing
 */
struct Ray {
    Vec3 origin_;                         ///< Ray origin
    Vec3 direction_;                      ///< Ray direction (normalized)
    Real t_min_;                          ///< Minimum t value
    Real t_max_;                          ///< Maximum t value

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

    /**
     * @brief Construct ray with origin and direction
     * @param origin Ray origin
     * @param direction Ray direction (will be normalized)
     * @param t_min Minimum t value
     * @param t_max Maximum t value
     */
    Ray(const Vec3& origin, const Vec3& direction, 
        Real t_min = are_epsilon, Real t_max = 1e30f);

    /**
     * @brief Evaluate ray at parameter t
     * @param t Parameter value
     * @return Point on ray
     */
    Vec3 at(Real t) const;

    /**
     * @brief Check if t is within valid range
     * @param t Parameter value
     * @return true if t is valid
     */
    bool is_valid_t(Real t) const;
};

} // namespace are

#endif // ARE_INCLUDE_RAYTRACER_RAY_H
```

### 文件：include/are/raytracer/hit_record.h
```cpp
/**
 * @file hit_record.h
 * @brief Ray-surface intersection record
 */

#ifndef ARE_INCLUDE_RAYTRACER_HIT_RECORD_H
#define ARE_INCLUDE_RAYTRACER_HIT_RECORD_H

#include <are/core/types.h>

namespace are {

/**
 * @struct HitRecord
 * @brief Information about ray-surface intersection
 */
struct HitRecord {
    Vec3 position_;                       ///< Hit position in world space
    Vec3 normal_;                         ///< Surface normal at hit point
    Vec2 texcoord_;                       ///< Texture coordinates at hit point
    Vec3 tangent_;                        ///< Tangent vector at hit point
    Real t_;                              ///< Ray parameter at hit point
    MaterialHandle material_;             ///< Material at hit point
    uint32_t triangle_index_;             ///< Triangle index that was hit
    bool front_face_;                     ///< Whether ray hit front face

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

    /**
     * @brief Set face normal based on ray direction
     * @param ray_direction Ray direction
     * @param outward_normal Outward-facing normal
     */
    void set_face_normal(const Vec3& ray_direction, const Vec3& outward_normal);

    /**
     * @brief Check if hit record is valid
     * @return true if hit occurred
     */
    bool is_valid() const;
};

} // namespace are

#endif // ARE_INCLUDE_RAYTRACER_HIT_RECORD_H
```

### 文件：include/are/scene/directional_light.h
```cpp
/**
 * @file directional_light.h
 * @brief Directional light implementation
 */

#ifndef ARE_INCLUDE_SCENE_DIRECTIONAL_LIGHT_H
#define ARE_INCLUDE_SCENE_DIRECTIONAL_LIGHT_H

#include <are/scene/light.h>

namespace are {

/**
 * @class DirectionalLight
 * @brief Directional light source (sun-like)
 * 
 * Represents an infinitely distant light source with parallel rays.
 */
class DirectionalLight : public Light {
public:
    /**
     * @brief Default constructor
     */
    DirectionalLight();

    /**
     * @brief Construct with direction and color
     * @param direction Light direction (will be normalized)
     * @param color Light color
     * @param intensity Light intensity
     */
    DirectionalLight(const Vec3& direction, const Vec3& color = Vec3(1.0f), 
                    Real intensity = 1.0f);

    // Direction
    void set_direction(const Vec3& direction);
    const Vec3& get_direction() const { return direction_; }

    // Light interface
    LightData pack() const override;
    bool affects_point(const Vec3& point) const override;

private:
    Vec3 direction_;                      ///< Light direction (normalized)
};

} // namespace are

#endif // ARE_INCLUDE_SCENE_DIRECTIONAL_LIGHT_H
```

### 文件：include/are/scene/point_light.h
```cpp
/**
 * @file point_light.h
 * @brief Point light implementation
 */

#ifndef ARE_INCLUDE_SCENE_POINT_LIGHT_H
#define ARE_INCLUDE_SCENE_POINT_LIGHT_H

#include <are/scene/light.h>

namespace are {

/**
 * @class PointLight
 * @brief Point light source
 * 
 * Emits light equally in all directions from a single point.
 */
class PointLight : public Light {
public:
    /**
     * @brief Default constructor
     */
    PointLight();

    /**
     * @brief Construct with position and color
     * @param position Light position
     * @param color Light color
     * @param intensity Light intensity
     * @param range Light range (attenuation distance)
     */
    PointLight(const Vec3& position, const Vec3& color = Vec3(1.0f),
              Real intensity = 1.0f, Real range = 10.0f);

    // Position
    void set_position(const Vec3& position);
    const Vec3& get_position() const { return position_; }

    // Range (attenuation)
    void set_range(Real range);
    Real get_range() const { return range_; }

    // Attenuation parameters
    void set_attenuation(Real constant, Real linear, Real quadratic);
    Real get_constant_attenuation() const { return attenuation_constant_; }
    Real get_linear_attenuation() const { return attenuation_linear_; }
    Real get_quadratic_attenuation() const { return attenuation_quadratic_; }

    /**
     * @brief Calculate attenuation at given distance
     * @param distance Distance from light
     * @return Attenuation factor [0, 1]
     */
    Real calculate_attenuation(Real distance) const;

    // Light interface
    LightData pack() const override;
    bool affects_point(const Vec3& point) const override;

private:
    Vec3 position_;                       ///< Light position
    Real range_;                          ///< Light range
    Real attenuation_constant_;           ///< Constant attenuation factor
    Real attenuation_linear_;             ///< Linear attenuation factor
    Real attenuation_quadratic_;          ///< Quadratic attenuation factor
};

} // namespace are

#endif // ARE_INCLUDE_SCENE_POINT_LIGHT_H
```

### 文件：include/are/scene/spot_light.h
```cpp
/**
 * @file spot_light.h
 * @brief Spot light implementation
 */

#ifndef ARE_INCLUDE_SCENE_SPOT_LIGHT_H
#define ARE_INCLUDE_SCENE_SPOT_LIGHT_H

#include <are/scene/light.h>

namespace are {

/**
 * @class SpotLight
 * @brief Spot light source
 * 
 * Emits light in a cone from a single point.
 */
class SpotLight : public Light {
public:
    /**
     * @brief Default constructor
     */
    SpotLight();

    /**
     * @brief Construct with position, direction, and angles
     * @param position Light position
     * @param direction Light direction
     * @param inner_angle Inner cone angle in degrees
     * @param outer_angle Outer cone angle in degrees
     * @param color Light color
     * @param intensity Light intensity
     */
    SpotLight(const Vec3& position, const Vec3& direction,Real inner_angle, Real outer_angle,
             const Vec3& color = Vec3(1.0f), Real intensity = 1.0f);

    // Position and direction
    void set_position(const Vec3& position);
    void set_direction(const Vec3& direction);
    const Vec3& get_position() const { return position_; }
    const Vec3& get_direction() const { return direction_; }

    // Cone angles (in degrees)
    void set_inner_angle(Real angle);
    void set_outer_angle(Real angle);
    Real get_inner_angle() const { return inner_angle_; }
    Real get_outer_angle() const { return outer_angle_; }

    // Range
    void set_range(Real range);
    Real get_range() const { return range_; }

    /**
     * @brief Calculate spotlight intensity at given direction
     * @param to_point Direction from light to point (normalized)
     * @return Spotlight factor [0, 1]
     */
    Real calculate_spot_factor(const Vec3& to_point) const;

    // Light interface
    LightData pack() const override;
    bool affects_point(const Vec3& point) const override;

private:
    Vec3 position_;                       ///< Light position
    Vec3 direction_;                      ///< Light direction (normalized)
    Real inner_angle_;                    ///< Inner cone angle (degrees)
    Real outer_angle_;                    ///< Outer cone angle (degrees)
    Real range_;                          ///< Light range
    Real cos_inner_;                      ///< Cosine of inner angle (cache
	Real cos_outer_;                      ///< Cosine of outer angle (cached)
};

} // namespace are

#endif // ARE_INCLUDE_SCENE_SPOT_LIGHT_H
```

还有缺失的头文件需要补充吗？如果没有的话，我们就可以开始实现Phase 2了。