njin_collision.h

#pragma once
#include "_comps.h"
#include "_math.h"
#include "_types.h"
#include <entt/entity/entity.hpp>
#include <vector>
 
namespace njin {
struct context;


inline constexpr u32 layer_all = 0xFFFFFFFFu;

constexpr u32 layer_bit(i32 n) { return 1u << (u32)n; }

enum collider_shape {
  collider_box,    
  collider_circle, 
  collider_tiles,
};

struct collider {
  collider_shape shape = collider_box; 
  vec2 size{16.0f, 16.0f}; 
  f32 radius = 8.0f;       
  vec2 offset{};           
  u32 layer = layer_bit(0); 
  u32 mask = layer_all;     
  bool trigger = false;
  bool enabled = true; 
  bool one_way = false;
};

struct platform_rider {};

struct collision_enter {
  entt::entity self = entt::null;  
  entt::entity other = entt::null; 
  bool trigger = false; 
};

struct collision_stay {
  entt::entity self = entt::null;  
  entt::entity other = entt::null; 
  bool trigger = false; 
};

struct collision_exit {
  entt::entity self = entt::null;  
  entt::entity other = entt::null; 
  bool trigger = false; 
};

inline rect collider_bounds(const transform &tr, const collider &col) {
  const f32 s = tr.scale < 0.0f ? -tr.scale : tr.scale;
  const vec2 center = tr.pos + rotate(col.offset * s, tr.rot);
  if (col.shape == collider_circle)
    return rect_from_center(center, vec2{col.radius, col.radius} * (2.0f * s));
  if (col.shape == collider_box)
    return rect_from_center(center, col.size * s);
  return rect{tr.pos, {}};
}

struct collision_move_result {
  vec2 moved{};  
  bool hit_x = false; 
  bool hit_y = false; 
  entt::entity other_x = entt::null; 
  entt::entity other_y = entt::null; 
  bool grounded = false;
  entt::entity ground = entt::null; 
  bool on_slope = false;       
  bool ground_one_way = false; 
};

struct collision_move_opts {
  bool drop_through = false;
  f32 snap_down = 0.0f;
  bool test_only = false;
};

collision_move_result collision_move(context &ctx, entt::entity entity, vec2 delta);

collision_move_result collision_move(context &ctx, entt::entity entity, vec2 delta,
                                     const collision_move_opts &opts);

void collision_move_platform(context &ctx, entt::entity platform, vec2 delta);

i32 collision_overlap_rect(const context &ctx, rect area,
                           std::vector<entt::entity> *out = nullptr,
                           u32 mask = layer_all, bool include_triggers = true);

i32 collision_overlap_circle(const context &ctx, circle area,
                             std::vector<entt::entity> *out = nullptr,
                             u32 mask = layer_all, bool include_triggers = true);

i32 collision_overlap_point(const context &ctx, vec2 point,
                            std::vector<entt::entity> *out = nullptr,
                            u32 mask = layer_all, bool include_triggers = true);

struct raycast_hit {
  bool hit = false;   
  entt::entity entity = entt::null; 
  vec2 point{};       
  vec2 normal{};      
  f32 distance = 0.0f; 
};

raycast_hit collision_raycast(const context &ctx, vec2 from, vec2 to,
                              u32 mask = layer_all, bool include_triggers = false,
                              entt::entity ignore = entt::null);

inline bool collision_line_of_sight(const context &ctx, vec2 from, vec2 to,
                                    u32 mask = layer_all, entt::entity ignore = entt::null) {
  return !collision_raycast(ctx, from, to, mask, false, ignore).hit;
}

void collision_set_debug(context &ctx, bool on);

void collision_set_cell_size(context &ctx, f32 size);
} // namespace njin