njin_light.h

#pragma once
#include "_tilemap.h"
#include "_types.h"
#include <algorithm>
#include <cmath>
#include <functional>
#include <vector>
 
namespace njin {
// Opaque, see njin_ctx.h.
struct context;


enum light_kind : i32 {
  light_point,       
  light_spot,        
  light_directional, 
};

enum light_falloff : i32 {
  falloff_physical,
  falloff_linear, 
  falloff_smooth, 
  falloff_none,   
};

struct light_2d {
  light_kind kind = light_point; 
  rgba color{1.0f, 1.0f, 1.0f, 1.0f};
  f32 temperature = 0.0f;
  f32 intensity = 6.0f;
  f32 radius = 200.0f; 
  f32 size = 32.0f;
  light_falloff falloff = falloff_physical; 
  f32 angle = 0.0f;
  f32 cone = 60.0f;      
  f32 softness = 0.3f;   
  f32 height = 40.0f;
  f32 elevation = 45.0f; 
  bool cast_shadows = true; 
  bool enabled = true;      
};

struct light_occluder {
  std::vector<vec2> points; 
  bool closed = true;
  bool hole = false;
  f32 reach = 0.0f;
};

inline light_occluder light_occluder_box(vec2 size, vec2 origin = {0.5f, 0.5f}) {
  const f32 x0 = -origin.x * size.x, y0 = -origin.y * size.y;
  const f32 reach = std::sqrt(std::max(x0 * x0, (x0 + size.x) * (x0 + size.x)) + std::max(y0 * y0, (y0 + size.y) * (y0 + size.y)));
  return light_occluder{{{x0, y0}, {x0 + size.x, y0}, {x0 + size.x, y0 + size.y}, {x0, y0 + size.y}}, true, false, reach};
}

inline light_occluder light_occluder_ellipse(vec2 radii, vec2 center = {0.0f, 0.0f}, i32 segments = 16) {
  light_occluder o;
  const i32 n = segments < 3 ? 3 : segments;
  for (i32 i = 0; i < n; i++) {
    const f32 a = 6.28318530718f * (f32)i / (f32)n;
    o.points.push_back({center.x + std::cos(a) * radii.x, center.y + std::sin(a) * radii.y});
  }
  o.reach = std::hypot(center.x, center.y) + std::max(radii.x, radii.y);
  return o;
}

inline light_occluder light_occluder_circle(f32 radius, vec2 center = {0.0f, 0.0f}, i32 segments = 16) {
  return light_occluder_ellipse({radius, radius}, center, segments);
}

inline light_occluder light_occluder_capsule(vec2 a, vec2 b, f32 radius, i32 arc_segments = 6) {
  light_occluder o;
  const f32 dx = b.x - a.x, dy = b.y - a.y;
  const f32 len = std::sqrt(dx * dx + dy * dy);
  const f32 base = len > 1e-6f ? std::atan2(dy, dx) : 0.0f;
  const i32 n = arc_segments < 1 ? 1 : arc_segments;
  // The half circle around `b`, from the left of the axis to the right, then the one around `a`.
  for (i32 i = 0; i <= n; i++) {
    const f32 t = base - 1.57079632679f + 3.14159265359f * (f32)i / (f32)n;
    o.points.push_back({b.x + std::cos(t) * radius, b.y + std::sin(t) * radius});
  }
  for (i32 i = 0; i <= n; i++) {
    const f32 t = base + 1.57079632679f + 3.14159265359f * (f32)i / (f32)n;
    o.points.push_back({a.x + std::cos(t) * radius, a.y + std::sin(t) * radius});
  }
  o.reach = std::max(std::hypot(a.x, a.y), std::hypot(b.x, b.y)) + radius;
  return o;
}

inline light_occluder light_occluder_line(std::vector<vec2> points) {
  light_occluder o{std::move(points), false};
  for (const vec2 &p : o.points)
    o.reach = std::max(o.reach, std::hypot(p.x, p.y));
  return o;
}

struct light_occluder_sprite {
  f32 alpha = 0.5f;
  f32 simplify = 1.0f;
};

struct light_occluder_pixels {
  texture_handle mask{};
};

std::vector<light_occluder> light_occluders_from_tiles(const tilemap &map, const std::function<bool(i32 tile)> &solid,
                                                       f32 simplify = 0.0f);

enum light_tonemap : i32 {
  tonemap_shoulder,
  tonemap_reinhard, 
  tonemap_aces,     
};

struct lighting_desc {
  bool enabled = false;
  rgba ambient{0.12f, 0.14f, 0.24f, 1.0f};
  f32 exposure = 1.0f;
  light_tonemap tonemap = tonemap_shoulder;
  i32 shadow_columns = 0;
  f32 pixel_alpha = 0.5f;
  f32 occluder_margin = 96.0f;
  f32 scale = 1.0f;
  f32 shadow_reach = 600.0f;
  f32 occluder_lod = 1.0f;
};

void lighting_set(context &ctx, const lighting_desc &desc);

lighting_desc lighting_get(const context &ctx);

rgba light_color_kelvin(f32 kelvin);
} // namespace njin