njin_physics3d.h

#pragma once
#include "njin_3d.h"
 
namespace njin {
struct context;


enum body3d_motion {
  body3d_static,    
  body3d_kinematic, 
  body3d_dynamic,   
};

struct body3d_desc {
  shape3d_kind shape = shape3d_box;  
  vec3 position{0.0f, 0.0f, 0.0f};   
  vec3 rotation{0.0f, 0.0f, 0.0f};   
  vec3 size{1.0f, 1.0f, 1.0f};       
  f32 radius = 0.5f;                 
  f32 height = 1.0f;                 
  body3d_motion motion = body3d_static; 
  f32 mass = 1.0f;                   
  f32 friction = 0.5f;               
  f32 restitution = 0.0f;            
  u64 user = 0;
  model_handle model{};
  vec3 scale{1.0f, 1.0f, 1.0f}; 
  bool sensor = false;
};

body3d_handle body3d_create(context &ctx, const body3d_desc &desc);

void body3d_destroy(context &ctx, body3d_handle handle);

transform3d body3d_transform(const context &ctx, body3d_handle handle);

void body3d_set_position(context &ctx, body3d_handle handle, vec3 position, vec3 rotation = {});

void body3d_move_kinematic(context &ctx, body3d_handle handle, vec3 position, vec3 rotation = {});

vec3 body3d_velocity(const context &ctx, body3d_handle handle);

void body3d_set_velocity(context &ctx, body3d_handle handle, vec3 velocity);

void body3d_add_impulse(context &ctx, body3d_handle handle, vec3 impulse);

void body3d_add_force(context &ctx, body3d_handle handle, vec3 force);

void body3d_add_force(context &ctx, body3d_handle handle, vec3 force, vec3 point);

void body3d_add_torque(context &ctx, body3d_handle handle, vec3 torque);

vec3 body3d_angular_velocity(const context &ctx, body3d_handle handle);

void body3d_carry(context &ctx, body3d_handle handle, f32 mass, vec3 point);

u64 body3d_user(const context &ctx, body3d_handle handle);

struct character3d_desc {
  vec3 position{0.0f, 0.0f, 0.0f}; 
  f32 radius = 0.3f;               
  f32 height = 1.8f;               
  f32 max_slope = 50.0f;           
  f32 step_height = 0.3f;          
  f32 mass = 70.0f;
  bool push = false;
};

character3d_handle character3d_create(context &ctx, const character3d_desc &desc);

void character3d_destroy(context &ctx, character3d_handle handle);

void character3d_set_active(context &ctx, character3d_handle handle, bool active);

bool character3d_active(const context &ctx, character3d_handle handle);

void character3d_set_velocity(context &ctx, character3d_handle handle, vec3 velocity);

vec3 character3d_velocity(const context &ctx, character3d_handle handle);

vec3 character3d_position(const context &ctx, character3d_handle handle);

void character3d_set_position(context &ctx, character3d_handle handle, vec3 position);

bool character3d_grounded(const context &ctx, character3d_handle handle);

vec3 character3d_ground_velocity(const context &ctx, character3d_handle handle);

body3d_handle character3d_ground_body(const context &ctx, character3d_handle handle);

softbody3d_handle character3d_ground_soft(const context &ctx, character3d_handle handle);

vec3 physics3d_capsule_push(const context &ctx, vec3 a, vec3 b, f32 radius, body3d_handle ignore = {});

vec3 physics3d_box_push(const context &ctx, vec3 center, vec3 rotation, vec3 size, body3d_handle ignore = {});

ray3d_hit physics3d_box_cast(const context &ctx, vec3 center, vec3 rotation, vec3 size, vec3 motion,
                             body3d_handle ignore = {}, body3d_handle *body = nullptr);

struct soft3d_hit {
  softbody3d_handle soft{}; 
  i32 face = -1;            
  i32 vertex = -1;          
};

ray3d_hit physics3d_box_cast(const context &ctx, vec3 center, vec3 rotation, vec3 size, vec3 motion,
                             body3d_handle ignore, body3d_handle *body, soft3d_hit *soft);

hull3d_handle physics3d_hull_create(context &ctx, const vec3 *points, i32 count);

void physics3d_hull_destroy(context &ctx, hull3d_handle hull);

vec3 physics3d_hull_push(const context &ctx, hull3d_handle hull, vec3 position, vec3 rotation, body3d_handle ignore = {});

ray3d_hit physics3d_hull_cast(const context &ctx, hull3d_handle hull, vec3 position, vec3 rotation, vec3 motion,
                              body3d_handle ignore = {}, body3d_handle *body = nullptr);

ray3d_hit physics3d_hull_cast(const context &ctx, hull3d_handle hull, vec3 position, vec3 rotation, vec3 motion,
                              body3d_handle ignore, body3d_handle *body, soft3d_hit *soft);

i32 physics3d_hull_lines(const context &ctx, hull3d_handle hull, vec3 *out, i32 count);

ray3d_hit physics3d_raycast(const context &ctx, const ray3d &ray, f32 max_distance,
                            body3d_handle *body = nullptr);

ray3d_hit physics3d_raycast(const context &ctx, const ray3d &ray, f32 max_distance, body3d_handle *body,
                            soft3d_hit *soft);

struct contact3d {
  body3d_handle a{};              
  body3d_handle b{};              
  character3d_handle character{}; 
  bool began = true;              
  bool sensor = false;            
  vec3 point{0.0f, 0.0f, 0.0f};   
  vec3 normal{0.0f, 0.0f, 0.0f};
};

i32 physics3d_contact_count(const context &ctx);

contact3d physics3d_contact(const context &ctx, i32 index);

enum joint3d_kind {
  joint3d_fixed,    
  joint3d_point,    
  joint3d_hinge,    
  joint3d_slider,   
  joint3d_distance, 
  joint3d_gear,
  joint3d_rack,
  joint3d_pulley,
};

struct joint3d_desc {
  joint3d_kind kind = joint3d_hinge; 
  body3d_handle a{};                 
  body3d_handle b{};
  vec3 anchor{0.0f, 0.0f, 0.0f};     
  vec3 anchor_b{0.0f, 0.0f, 0.0f};   
  vec3 axis{0.0f, 1.0f, 0.0f};       
  f32 min = 0.0f;
  f32 max = 0.0f; 
  f32 motor_force = 0.0f;
  f32 spring = 0.0f;
  f32 damping = 0.0f;
  joint3d_handle joint_a{};
  joint3d_handle joint_b{};
  f32 ratio = 1.0f;
  vec3 pulley_a{0.0f, 0.0f, 0.0f}; 
  vec3 pulley_b{0.0f, 0.0f, 0.0f}; 
};

joint3d_handle joint3d_create(context &ctx, const joint3d_desc &desc);

void joint3d_destroy(context &ctx, joint3d_handle handle);

void joint3d_set_motor(context &ctx, joint3d_handle handle, f32 speed);

f32 joint3d_position(const context &ctx, joint3d_handle handle);

void joint3d_set_motor_force(context &ctx, joint3d_handle handle, f32 force);

f32 joint3d_speed(const context &ctx, joint3d_handle handle);

f32 joint3d_force(const context &ctx, joint3d_handle handle);

f32 joint3d_torque(const context &ctx, joint3d_handle handle);

struct ragdoll3d_bone {
  const char *name = nullptr; 
  f32 radius = 0.0f;
  f32 length = 0.0f;
  f32 swing = 30.0f;
  f32 twist = 15.0f; 
  f32 bend_min = 0.0f;
  f32 bend_max = 0.0f; 
};

struct ragdoll3d_desc {
  model_handle model{};     
  transform3d transform{};
  model_pose pose{};        
  const ragdoll3d_bone *bones = nullptr;
  u32 bone_count = 0;       
  f32 mass = 70.0f;         
  f32 friction = 0.6f;      
  vec3 velocity{0.0f, 0.0f, 0.0f}; 
  u64 user = 0;             
};

ragdoll3d_handle ragdoll3d_create(context &ctx, const ragdoll3d_desc &desc);

void ragdoll3d_destroy(context &ctx, ragdoll3d_handle handle);

body3d_handle ragdoll3d_body(const context &ctx, ragdoll3d_handle handle, i32 part);

shape3d ragdoll3d_shape(const context &ctx, ragdoll3d_handle handle, i32 part);

i32 ragdoll3d_bones(const context &ctx, ragdoll3d_handle handle, const transform3d &transform, bone_pose3d *out,
                    i32 count);

enum softbody3d_kind {
  softbody3d_box,
  softbody3d_sphere,
  softbody3d_mesh,
};

struct softbody3d_desc {
  softbody3d_kind kind = softbody3d_sphere; 
  vec3 position{0.0f, 0.0f, 0.0f};  
  vec3 rotation{0.0f, 0.0f, 0.0f};  
  vec3 size{1.0f, 1.0f, 1.0f};      
  f32 radius = 0.5f;                
  i32 detail = 0;
  mesh3d_data mesh{};
  model_handle model{};
  vec3 scale{1.0f, 1.0f, 1.0f};     
  f32 mass = 1.0f;                  
  f32 stiffness = 0.9f;
  f32 bend = 0.5f;
  f32 pressure = 0.0f;
  f32 friction = 0.5f;              
  f32 restitution = 0.0f;           
  f32 damping = 0.1f;               
  f32 drag = 1.0f;
  const u32 *pinned = nullptr;
  u32 pinned_count = 0;             
  u64 user = 0;                     
  bool collide_soft = true;
  bool walkable = true;
};

softbody3d_handle softbody3d_create(context &ctx, const softbody3d_desc &desc);

enum cloth3d_edge : u8 {
  cloth3d_top = 1,    
  cloth3d_bottom = 2, 
  cloth3d_left = 4,   
  cloth3d_right = 8,  
};

struct cloth3d_desc {
  vec3 position{0.0f, 0.0f, 0.0f}; 
  vec3 rotation{0.0f, 0.0f, 0.0f}; 
  vec2 size{2.0f, 2.0f};           
  i32 columns = 20;                
  i32 rows = 20;                   
  f32 mass = 0.5f;                 
  f32 stiffness = 1.0f;            
  f32 bend = 0.05f;                
  f32 damping = 0.1f;              
  f32 friction = 0.5f;             
  f32 drag = 1.0f;                 
  f32 thickness = 0.02f;
  u8 pin_edges = 0;                
  const u32 *pinned = nullptr;     
  u32 pinned_count = 0;            
  u64 user = 0;                    
  bool collide_soft = true;        
  bool walkable = true;            
};

softbody3d_handle cloth3d_create(context &ctx, const cloth3d_desc &desc);

void softbody3d_destroy(context &ctx, softbody3d_handle handle);

i32 softbody3d_vertex_count(const context &ctx, softbody3d_handle handle);

i32 softbody3d_vertices(const context &ctx, softbody3d_handle handle, vec3 *out, i32 count);

i32 softbody3d_normals(const context &ctx, softbody3d_handle handle, vec3 *out, i32 count);

i32 softbody3d_indices(const context &ctx, softbody3d_handle handle, u32 *out, i32 count);

model_handle softbody3d_model(context &ctx, softbody3d_handle handle);

i32 softbody3d_nearest(const context &ctx, softbody3d_handle handle, vec3 point);

void softbody3d_pin(context &ctx, softbody3d_handle handle, i32 vertex, bool pinned);

void softbody3d_move_pinned(context &ctx, softbody3d_handle handle, i32 vertex, vec3 position);

void softbody3d_set_wind(context &ctx, softbody3d_handle handle, vec3 wind);

void softbody3d_add_impulse(context &ctx, softbody3d_handle handle, vec3 impulse);

vec3 softbody3d_position(const context &ctx, softbody3d_handle handle);

u64 softbody3d_user(const context &ctx, softbody3d_handle handle);

void softbody3d_draw_debug(context &ctx, softbody3d_handle handle, rgba color = {0.3f, 0.9f, 1.0f, 1.0f});

struct vehicle3d_wheel {
  vec3 position{0.0f, 0.0f, 0.0f};
  f32 radius = 0.35f;     
  f32 width = 0.25f;      
  bool steer = false;     
  bool drive = true;      
  bool handbrake = false; 
};

struct vehicle3d_desc {
  vec3 position{0.0f, 0.0f, 0.0f};    
  vec3 rotation{0.0f, 0.0f, 0.0f};    
  vec3 size{1.8f, 0.6f, 4.0f};        
  model_handle model{};               
  vec3 scale{1.0f, 1.0f, 1.0f};       
  f32 mass = 1200.0f;                 
  vec3 center_of_mass{0.0f, -0.3f, 0.0f};
  const vehicle3d_wheel *wheels = nullptr;
  u32 wheel_count = 0;                
  f32 wheel_radius = 0.35f;           
  f32 wheel_width = 0.25f;            
  f32 suspension = 0.3f;              
  f32 suspension_frequency = 1.5f;    
  f32 suspension_damping = 0.5f;      
  f32 max_steer = 30.0f;              
  f32 engine_torque = 300.0f;
  f32 max_rpm = 6000.0f;              
  f32 brake_torque = 1500.0f;         
  f32 handbrake_torque = 4000.0f;     
  f32 friction = 0.5f;                
  u64 user = 0;                       
};

vehicle3d_handle vehicle3d_create(context &ctx, const vehicle3d_desc &desc);

void vehicle3d_destroy(context &ctx, vehicle3d_handle handle);

void vehicle3d_set_input(context &ctx, vehicle3d_handle handle, f32 throttle, f32 steer, f32 brake, f32 handbrake);

body3d_handle vehicle3d_body(const context &ctx, vehicle3d_handle handle);

i32 vehicle3d_wheel_count(const context &ctx, vehicle3d_handle handle);

transform3d vehicle3d_wheel_transform(const context &ctx, vehicle3d_handle handle, i32 wheel);

bool vehicle3d_wheel_grounded(const context &ctx, vehicle3d_handle handle, i32 wheel);

f32 vehicle3d_rpm(const context &ctx, vehicle3d_handle handle);

i32 vehicle3d_gear(const context &ctx, vehicle3d_handle handle);

struct motorcycle3d_desc {
  vec3 position{0.0f, 0.0f, 0.0f};    
  vec3 rotation{0.0f, 0.0f, 0.0f};    
  vec3 size{0.4f, 0.6f, 0.8f};        
  model_handle model{};               
  vec3 scale{1.0f, 1.0f, 1.0f};       
  f32 mass = 240.0f;                  
  vec3 center_of_mass{0.0f, -0.3f, 0.0f}; 
  f32 wheelbase = 1.5f;               
  f32 wheel_radius = 0.31f;           
  f32 wheel_width = 0.05f;            
  f32 suspension = 0.2f;              
  f32 caster = 30.0f;                 
  f32 max_steer = 30.0f;              
  f32 max_lean = 45.0f;               
  f32 engine_torque = 150.0f;         
  f32 max_rpm = 10000.0f;             
  f32 brake_torque = 500.0f;          
  f32 friction = 0.5f;                
  u64 user = 0;                       
};

vehicle3d_handle motorcycle3d_create(context &ctx, const motorcycle3d_desc &desc);

struct tracked3d_desc {
  vec3 position{0.0f, 0.0f, 0.0f};    
  vec3 rotation{0.0f, 0.0f, 0.0f};    
  vec3 size{3.4f, 1.0f, 6.4f};        
  model_handle model{};               
  vec3 scale{1.0f, 1.0f, 1.0f};       
  f32 mass = 4000.0f;                 
  vec3 center_of_mass{0.0f, -0.5f, 0.0f}; 
  i32 wheels_per_side = 9;            
  f32 wheel_radius = 0.3f;            
  f32 wheel_width = 0.1f;             
  f32 suspension = 0.2f;              
  f32 engine_torque = 500.0f;         
  f32 max_rpm = 6000.0f;              
  f32 brake_torque = 15000.0f;        
  f32 friction = 0.5f;                
  u64 user = 0;                       
};

vehicle3d_handle tracked3d_create(context &ctx, const tracked3d_desc &desc);

void vehicle3d_set_tracks(context &ctx, vehicle3d_handle handle, f32 left, f32 right, f32 brake);

f32 vehicle3d_track_speed(const context &ctx, vehicle3d_handle handle, i32 side);

void vehicle3d_draw_debug(context &ctx, vehicle3d_handle handle, rgba color = {1.0f, 0.6f, 0.2f, 1.0f});

struct body3d {
  body3d_handle handle{}; 
};

struct character3d {
  character3d_handle handle{}; 
};

void physics3d_set_gravity(context &ctx, vec3 gravity);

vec3 physics3d_gravity(const context &ctx);
} // namespace njin