LightingSystem.hpp

Go to the documentation of this file.

#ifndef CORE_MAPS_LIGHTINGSYSTEM_HPP
#define CORE_MAPS_LIGHTINGSYSTEM_HPP
 
#include <BLIB/Containers/Grid.hpp>
#include <BLIB/Containers/ObjectPool.hpp>
#include <BLIB/Events.hpp>
#include <BLIB/Render/Lighting/Scene2DLighting.hpp>
#include <BLIB/Serialization/Binary.hpp>
#include <Core/Events/TimeChange.hpp>
#include <Core/Events/Weather.hpp>
#include <Core/Maps/Light.hpp>
#include <SFML/Graphics.hpp>
#include <unordered_map>
#include <vector>
 
namespace core
{
namespace map
{
class LightingSystem
: public bl::event::Listener<event::TimeChange, event::WeatherStarted, event::WeatherStopped,
                             event::Thundered> {
public:
    using Handle = std::uint16_t;
 
    static constexpr Handle None = 0;
 
    LightingSystem();
 
    virtual ~LightingSystem() = default;
 
    void addLight(const Light& light);
 
    void updateLight(Handle handle, const Light& value);
 
    Handle getClosestLight(const sf::Vector2i& position);
 
    const Light& getLight(Handle handle) const;
 
    void removeLight(Handle light);
 
    bool lightsAreOn() const;
 
    void setAmbientLevel(std::uint8_t lowLightLevel, std::uint8_t highLightLevel);
 
    std::uint8_t getMinLightLevel() const;
 
    std::uint8_t getMaxLightLevel() const;
 
    void adjustForSunlight(bool adjust);
 
    bool adjustsForSunlight() const;
 
    void activate(bl::rc::lgt::Scene2DLighting& sceneLighting);
 
    void subscribe();
 
    void unsubscribe();
 
    void clear();
 
    void update(float dt);
 
    void setColorTint(const glm::vec3& tint);
 
    virtual void observe(const event::TimeChange& timeChange) override;
 
    virtual void observe(const event::WeatherStarted& event) override;
 
    virtual void observe(const event::WeatherStopped& event) override;
 
    virtual void observe(const event::Thundered&) override;
 
private:
    std::vector<Light> rawLights;
    std::uint8_t minLevel;
    std::uint8_t maxLevel;
    std::uint8_t sunlight;
    glm::vec3 tint;
 
    bl::rc::lgt::Scene2DLighting* sceneLighting;
    std::vector<bl::rc::lgt::Light2D> activeLights;
    bool lightsActive;
 
    float levelRange;
    float sunlightFactor;
    int weatherModifier;
    int targetWeatherModifier;
    float weatherResidual;
    float thunderTime;
 
    std::uint8_t computeAmbient() const;
    void addLightToScene(const Light& light);
    void updateAmbientLighting();
 
    friend struct bl::serial::SerializableObject<LightingSystem>;
};
 
} // namespace map
} // namespace core
 
namespace bl
{
namespace serial
{
template<>
struct SerializableObject<core::map::LightingSystem> : public SerializableObjectBase {
    using LS = core::map::LightingSystem;
 
    SerializableField<1, LS, std::vector<core::map::Light>> lights;
    SerializableField<2, LS, std::uint8_t> low;
    SerializableField<3, LS, std::uint8_t> high;
    SerializableField<4, LS, std::uint8_t> sun;
 
    SerializableObject()
    : SerializableObjectBase("LightingSystem")
    , lights("lights", *this, &LS::rawLights, SerializableFieldBase::Required{})
    , low("low", *this, &LS::minLevel, SerializableFieldBase::Required{})
    , high("high", *this, &LS::maxLevel, SerializableFieldBase::Required{})
    , sun("sun", *this, &LS::sunlight, SerializableFieldBase::Required{}) {}
};
 
} // namespace serial
} // namespace bl
 
#endif