lights.h

Go to the documentation of this file.

#ifndef LIGHTS_H
#define LIGHTS_H
 
#include <functional>
 
#include "utils.h"
#include "configuration.h"
#include "render.h"
#include "colormaps.h"
#include "objects.h"
#include "objects_geometry.h"
 
 
class Simulation;
 

class LightLevelMap {
public:
    LightLevelMap(size_t num_bins_x, size_t num_bins_y, float bin_width, float bin_height);

    ~LightLevelMap();

    float get_light_level_at(float x, float y) const;

    float get_light_level(size_t bin_x, size_t bin_y) const;

    void set_light_level(size_t bin_x, size_t bin_y, int16_t value);

    void add_light_level(size_t bin_x, size_t bin_y, int16_t value);

    void clear();

    size_t get_num_bins_x() const;
    size_t get_num_bins_y() const;
    float get_bin_width() const;
    float get_bin_height() const;

    void render(SDL_Renderer* renderer) const;

    void register_callback(std::function<void(LightLevelMap&)> cb);

    void update();
 
private:
    size_t num_bins_x_;
    size_t num_bins_y_;
    float bin_width_;
    float bin_height_;
    std::vector<std::vector<int16_t>> levels_;
    std::vector<std::function<void(LightLevelMap&)>> callbacks_;
};
 
 

class StaticLightObject : public Object {
public:

    enum class LightMode { STATIC, GRADIENT, PLANE };

    StaticLightObject(float _x, float _y,
                      ObjectGeometry& _geom, LightLevelMap* light_map,
                      int16_t _value,
                      LightMode _mode               = LightMode::STATIC,
                      int16_t _edge_value           = 0,
                      float   _gradient_radius      = -1.0f,
                      float   _plane_angle          = 0.0f,
                      float   _plane_half_span      = 1000.0f,
                      float   _photo_start_at       = -1.0f,
                      float   _photo_start_duration = 1.0f,
                      int16_t _photo_start_value    = 32767,
                      std::string const& _category  = "objects");
 

    StaticLightObject(Simulation* simulation, float _x, float _y,
            LightLevelMap* light_map, Configuration const& config,
            std::string const& _category = "objects");

    virtual void render(SDL_Renderer*, b2WorldId) const override {}

    virtual void update_light_map(LightLevelMap& l);

    virtual void launch_user_step(float t) override;
 
protected:
    virtual void parse_configuration(Configuration const& config, Simulation* simulation) override;
 

    int16_t value = 0;

    int16_t orig_value = 0;

    int16_t edge_value = 0;

    float gradient_radius = -1.0f;
 
    // Direction of the plane’s normal, *in radians* (0 → +x, π/2 → +y)
    float plane_angle = 0.0f;
 
    // Half-width (mm) of the transition zone.  
    // The intensity goes from `value` to `edge_value` over a span of 2·plane_half_span.
    float plane_half_span = 1000.0f;

    LightMode mode = LightMode::STATIC;

    LightLevelMap* light_map = nullptr;
 
    // ---------- Photo-start pulse parameters ---------------------------- //
    float   photo_start_at        = -1.0f;  
    float   photo_start_duration  = 1.0f;   
    int16_t photo_start_value     = 32767;  
    bool    performing_photo_start = false; 
};

class RotatingRayOfLightObject : public Object {
public:
    RotatingRayOfLightObject(float x, float y, ObjectGeometry& geom,
                             LightLevelMap* light_map, int16_t value,
                             float ray_half_width  = 0.1f,
                             float angular_speed   = 3.0f,
                             float photo_start_at  = -1.0f,
                             float photo_start_dur = 1.0f,
                             float _white_frame_dur = 1.0f,
                             int16_t _white_frame_val = 32767,
                             std::string const& category = "objects");
 
    RotatingRayOfLightObject(Simulation* simulation, float x, float y,
                             LightLevelMap* light_map,
                             Configuration const& config,
                             std::string const& category = "objects");
 
    void render(SDL_Renderer*, b2WorldId) const override {}
    void update_light_map(LightLevelMap& l);
    void launch_user_step(float t) override;
 
protected:
    void parse_configuration(Configuration const& config,
                             Simulation* simulation) override;
 
    void start_white_frame(float now_s);
 
private:
    static float normalise_angle(float a);
 
    /* --- parameters --------------------------------------------------- */
    LightLevelMap* light_map = nullptr;
    int16_t value            = 0;
    float ray_half_width     = 0.1f;   
    float angular_speed      = 3.0f;   
    float photo_start_at     = -1.0f;  
    float photo_start_dur    = 1.0f;   
    float white_frame_dur    = 0.03f;  
    int16_t white_frame_val  = 32767;  
 
    /* --- evolving state ----------------------------------------------- */
    float  current_angle         = 0.0f;  
    bool   ray_is_active         = true;  
    float  previous_angle        = 0.f;   
    bool   white_frame_active    = false;
    float  white_frame_end_time  = 0.f;   
    float  sim_prev_t            = 0.f;
    float  ray_current_t         = 0.f;
};
 
 
class AlternatingDualRayOfLightObject : public Object {
public:
    AlternatingDualRayOfLightObject(float x, float y, ObjectGeometry& geom,
                                    LightLevelMap* light_map, int16_t value,
                                    float ray_half_width          = 0.1f,
                                    float angular_speed           = 3.0f,
                                    float long_white_frame_dur    = 1.0f,
                                    float short_white_frame_dur   = 0.03f,
                                    int16_t white_frame_val       = 32767,
                                    std::string const& category   = "objects");
 
    AlternatingDualRayOfLightObject(Simulation* simulation, float x, float y,
                                    LightLevelMap* light_map,
                                    Configuration const& config,
                                    std::string const& category = "objects");
 
    void render(SDL_Renderer*, b2WorldId) const override {}
    void launch_user_step(float t) override;
    void update_light_map(LightLevelMap& l);
 
protected:
    void parse_configuration(Configuration const& config,
                             Simulation* simulation) override;
 
private:
    /* helpers ---------------------------------------------------------- */
    static float normalise_angle(float a);
    void         recompute_geometry();
    void         request_map_refresh() { light_map->update(); }
 
    /* phase machine ---------------------------------------------------- */
    enum class phase_t { LONG_WHITE, LEFT_RAY, SHORT_WHITE, RIGHT_RAY };
 
    void enter_phase(phase_t p, float now_s);
 
    /* parameters ------------------------------------------------------- */
    LightLevelMap* light_map       = nullptr;
    int16_t         value           = 0;
    float           ray_half_width  = 0.1f;     /* rad  */
    float           angular_speed   = 3.0f;     /* rad·s⁻¹ */
    float           long_white_dur  = 1.0f;     /* s    */
    float           short_white_dur = 0.03f;    /* s    */
    int16_t         white_val       = 32767;
 
    /* geometry --------------------------------------------------------- */
    BoundingBox bbox {};
    float       cx = 0.f, cy = 0.f;          /* centre of geometry         */
    float       ax_l = 0.f, ay_l = 0.f;      /* top-left  apex             */
    float       ax_r = 0.f, ay_r = 0.f;      /* top-right apex             */
    float       left_a0  = 0.f, left_a1  = 0.f;
    float       right_a0 = 0.f, right_a1 = 0.f;
 
    /* evolving state --------------------------------------------------- */
    phase_t phase            = phase_t::LONG_WHITE;
    float   phase_start_t    = 0.f;          /* s                           */
    float   prev_t           = 0.f;          /* s                           */
    float   current_angle    = 0.f;          /* rad – of active ray         */
};
 
 
#endif
 
// MODELINE "{{{1
// vim:expandtab:softtabstop=4:shiftwidth=4:fileencoding=utf-8
// vim:foldmethod=marker