lighting.h

Go to the documentation of this file.

 
 
#ifndef ASW_LIGHTING_H
#define ASW_LIGHTING_H
 
#include <SDL3/SDL.h>
#include <cstddef>
#include <cstdint>
#include <utility>
#include <vector>
 
#include "./camera.h"
#include "./color.h"
#include "./geometry.h"
#include "./types.h"
 
namespace asw::lighting {
 
enum class ShadowMode {
    None,
 
    Cast,
 
    Visibility,
};
 
struct Light {
    asw::Vec2<float> position;
 
    float radius { 128.0F };
 
    asw::Color color { 255, 255, 255 };
 
    float intensity { 1.0F };
 
    asw::Falloff falloff { asw::Falloff::Smooth };
 
    float direction { 0.0F };
 
    float cone { 0.0F };
 
    bool shadows { true };
 
    float flicker { 0.0F };
 
    float pulse { 0.0F };
 
    float pulse_speed { 1.0F };
 
    int seed { 0 };
};
 
class AmbientCycle {
public:
    explicit AmbientCycle(float length = 1.0F);
 
    void add(float time, const asw::Color& color);
 
    asw::Color at(float time) const;
 
    float get_length() const;
 
private:
    float length;
    std::vector<std::pair<float, asw::Color>> keys;
};
 
class TileLight {
public:
    TileLight(int width, int height, float tile_size);
 
    void set_solid(int x, int y, bool solid);
 
    bool is_solid(int x, int y) const;
 
    void set_falloff(float amount);
 
    void clear_lights();
 
    void add_light(int x, int y, const asw::Color& color);
 
    void compute();
 
    asw::Color get(int x, int y) const;
 
    const asw::Texture& get_texture() const;
 
    asw::Vec2<float> get_size() const;
 
private:
    struct Source {
        int x;
        int y;
        asw::Color color;
    };
 
    bool in_grid(int x, int y) const;
    void upload();
 
    int width;
    int height;
    float tile_size;
    float falloff { 0.1F };
    std::vector<uint8_t> solid;
    std::vector<Source> sources;
    std::vector<float> light;
    asw::Texture texture;
 
    // Kept between compute() calls so they do not allocate each time
    std::vector<float> level;
    std::vector<std::size_t> open;
    std::vector<uint8_t> pixels;
};
 
class LightMap {
public:
    void set_ambient(const asw::Color& color);
 
    asw::Color get_ambient() const;
 
    void set_camera(const asw::Camera* camera);
 
    void set_shadow_mode(ShadowMode mode);
 
    ShadowMode get_shadow_mode() const;
 
    void update(float dt);
 
    void clear();
 
    void add(const Light& light);
 
    void add_glow(const asw::Texture& texture, const asw::Quad<float>& dest,
        const asw::Color& tint = asw::Color(255, 255, 255));
 
    void add_tiles(const TileLight& tile_light, const asw::Vec2<float>& position = { });
 
    void add_occluder(const asw::Polygonf& polygon);
 
    void add_occluder(const asw::Quad<float>& rect);
 
    void clear_occluders();
 
    const std::vector<asw::Polygonf>& get_occluders() const;
 
    void draw();
 
    const asw::Texture& render();
 
private:
    struct Glow {
        asw::Texture texture;
        asw::Quad<float> dest;
        asw::Color tint;
    };
 
    struct Tiles {
        const TileLight* grid;
        asw::Vec2<float> position;
    };
 
    asw::Vec2<float> to_screen(const asw::Vec2<float>& point) const;
    asw::Quad<float> to_screen(const asw::Quad<float>& rect) const;
    const asw::Texture& gradient(asw::Falloff falloff);
    void prepare_occluders();
    bool has_blockers(const asw::Quad<float>& reach) const;
    void draw_light(const Light& light);
    void draw_shadows(const asw::Vec2<float>& center, const asw::Quad<float>& reach);
 
    asw::Color ambient { 0, 0, 0 };
    const asw::Camera* camera { nullptr };
    ShadowMode shadow_mode { ShadowMode::None };
 
    // Double, so flicker and pulse stay smooth in long sessions
    double time { 0.0 };
 
    std::vector<Light> lights;
    std::vector<Glow> glows;
    std::vector<Tiles> tiles;
    std::vector<asw::Polygonf> occluders;
 
    // Occluders in screen space for this frame, with their bounds and which
    // way round their corners go. Kept between frames to reuse the memory
    std::vector<asw::Polygonf> screen_occluders;
    std::vector<asw::Quad<float>> screen_bounds;
    std::vector<float> screen_winding;
 
    // Reused each light
    asw::Polygonf seen;
    std::vector<SDL_Vertex> shadow_vertices;
    std::vector<int> shadow_indices;
 
    asw::Texture map;
    asw::Texture scratch;
    asw::Vec2<int> map_size;
    std::vector<std::pair<asw::Falloff, asw::Texture>> gradients;
};
 
} // namespace asw::lighting
 
#endif // ASW_LIGHTING_H