njin_3d.h

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


struct camera3d {
  vec3 position{0.0f, 0.0f, 0.0f};  
  vec3 target{0.0f, 0.0f, -1.0f};   
  vec3 up{0.0f, 1.0f, 0.0f};        
  f32 fovy = 60.0f;                 
  f32 near_plane = 0.05f;           
  f32 far_plane = 1000.0f;          
  bool entities = true;
};

void begin_3d(context &ctx, const camera3d &camera);

void begin_3d(context &ctx, const camera3d &camera, render_texture_handle target, rgba clear);

void end_3d(context &ctx);

struct light3d {
  vec3 direction{-0.4f, -1.0f, -0.3f};  
  rgba color{1.0f, 1.0f, 1.0f, 1.0f};   
  rgba ambient{0.35f, 0.35f, 0.4f, 1.0f}; 
  bool shadows = false;
  f32 shadow_range = 30.0f;
  i32 shadow_size = 2048;       
  f32 shadow_softness = 1.0f;   
  i32 source_shadow_size = 512;
  rgba fog_color{0.6f, 0.65f, 0.75f, 1.0f}; 
  f32 fog_density = 0.0f;
};

void light3d_set(context &ctx, const light3d &light);

light3d light3d_get(const context &ctx);

enum light3d_kind {
  light3d_point, 
  light3d_spot,  
};

struct light3d_source {
  light3d_kind kind = light3d_point; 
  vec3 position{0.0f, 0.0f, 0.0f};   
  vec3 direction{0.0f, -1.0f, 0.0f}; 
  rgba color{1.0f, 1.0f, 1.0f, 1.0f}; 
  f32 intensity = 1.0f;              
  f32 radius = 10.0f;                
  f32 cone = 60.0f;                  
  f32 softness = 0.25f;              
  bool shadows = false;
};

inline constexpr i32 light3d_max = 16;

inline constexpr i32 light3d_shadow_max = 4;

void light3d_add(context &ctx, const light3d_source &light);

struct material3d {
  f32 specular = 0.25f;  
  f32 shininess = 32.0f; 
  rgba emission{0.0f, 0.0f, 0.0f, 0.0f};
  rgba rim{0.0f, 0.0f, 0.0f, 0.0f};
  bool unlit = false;        
  texture_handle texture{};
  bool cast_shadows = true;  
  f32 clay = 0.0f;
  f32 clay_detail = 9.0f; 
  texture_handle normal{};
  f32 world_uv = 0.0f;
  texture_handle under{};
  texture_handle under_normal{}; 
  f32 under_amount = 0.0f;
  f32 reflect = 0.0f;
};

void material3d_set(context &ctx, const material3d &material);

void draw_cube3d(const context &ctx, vec3 center, vec3 size, rgba color);

void draw_sphere3d(const context &ctx, vec3 center, f32 radius, rgba color);

void draw_plane3d(const context &ctx, vec3 center, vec2 size, rgba color);

void draw_cylinder3d(const context &ctx, vec3 from, vec3 to, f32 radius, rgba color);

void draw_capsule3d(const context &ctx, vec3 from, vec3 to, f32 radius, rgba color);

enum shape3d_kind {
  shape3d_sphere,   
  shape3d_box,      
  shape3d_capsule,  
  shape3d_cylinder, 
  shape3d_torus,    
};

struct shape3d {
  shape3d_kind kind = shape3d_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;                  
  f32 height = 1.0f;                  
  f32 thickness = 0.15f;              
  f32 rounding = 0.0f;                
};

void draw_shape3d(const context &ctx, const shape3d &shape, rgba color);

struct sdf_part {
  vec3 a{0.0f, 0.0f, 0.0f}; 
  vec3 b{0.0f, 0.0f, 0.0f}; 
  f32 ra = 0.1f;            
  f32 rb = 0.1f;            
  f32 blend = -1.0f;
};

inline constexpr u32 sdf_blend_max = 32;

void draw_sdf_blend(const context &ctx, const sdf_part *parts, u32 count, f32 blend, rgba color);

model_handle model_load(context &ctx, const char *path);

struct model_load_desc {
  const char *path = nullptr;               
  const char *const *skip_nodes = nullptr;  
  u32 skip_count = 0;                       
  const char *const *only_nodes = nullptr;  
  u32 only_count = 0;                       
  bool merge = false;
};

model_handle model_load(context &ctx, const model_load_desc &desc);

void model_unload(context &ctx, model_handle handle);

struct mesh3d_data {
  const vec3 *positions = nullptr; 
  const vec3 *normals = nullptr;
  const rgba *colors = nullptr; 
  const vec2 *texcoords = nullptr;
  u32 vertex_count = 0;         
  const u32 *indices = nullptr;
  u32 index_count = 0; 
};

model_handle model_create(context &ctx, const mesh3d_data &mesh);

struct skinned_mesh3d_data {
  const vec3 *positions = nullptr; 
  const vec3 *normals = nullptr;
  const vec2 *texcoords = nullptr;
  u32 vertex_count = 0; 
  const u8 *joints = nullptr;
  const f32 *weights = nullptr; 
  const u32 *indices = nullptr;
  u32 index_count = 0; 
  const u32 *part_ends = nullptr;
  u32 part_count = 0; 
  model_handle skeleton{};
};

model_handle model_create_skinned(context &ctx, const skinned_mesh3d_data &mesh);

struct model_lod_desc {
  i32 levels = 3;        
  f32 ratio = 0.5f;      
  f32 max_error = 0.05f;
  f32 screen = 0.25f;
};

i32 model_lod_build(context &ctx, model_handle handle, const model_lod_desc &desc = {});

struct transform3d {
  vec3 position{0.0f, 0.0f, 0.0f}; 
  vec3 rotation{0.0f, 0.0f, 0.0f}; 
  vec3 scale{1.0f, 1.0f, 1.0f};    
};

struct model_material {
  rgba color{1.0f, 1.0f, 1.0f, 1.0f}; 
  texture_handle albedo{};   
  texture_handle normal{};   
  texture_handle emission{}; 
  rgba emission_color{1.0f, 1.0f, 1.0f, 1.0f}; 
  shader_handle shader{};
  material3d surface{};
  bool double_sided = false;
};

i32 model_material_count(const context &ctx, model_handle handle);

i32 model_material_find(const context &ctx, model_handle handle, const char *name);

model_material model_material_get(const context &ctx, model_handle handle, i32 index);

void model_material_set(context &ctx, model_handle handle, i32 index, const model_material &material);

void draw_model(const context &ctx, model_handle handle, const transform3d &transform,
                rgba tint = colors::white);

i32 model_anim_count(const context &ctx, model_handle handle);

i32 model_anim_find(const context &ctx, model_handle handle, const char *name);

const char *model_anim_name(const context &ctx, model_handle handle, i32 index);

f32 model_anim_duration(const context &ctx, model_handle handle, i32 index);
 
struct bone_pose3d;

struct model_pose {
  i32 anim = -1;           
  f32 time = 0.0f;         
  bool loop = true;        
  i32 blend_anim = -1;     
  f32 blend_time = 0.0f;   
  bool blend_loop = true;  
  f32 blend = 0.0f;        
  const bone_pose3d *bones = nullptr;
  const f32 *morph_weights = nullptr;
  i32 morph_count = 0; 
};

void draw_model_anim(const context &ctx, model_handle handle, const transform3d &transform, const model_pose &pose,
                     rgba tint = colors::white);

struct model_recolor {
  i32 material = -1;                 
  rgba color{1.0f, 1.0f, 1.0f, 1.0f}; 
};

void draw_model_anim(const context &ctx, model_handle handle, const transform3d &transform, const model_pose &pose,
                     rgba tint, const model_recolor &recolor);

void draw_model_anim(const context &ctx, model_handle handle, const transform3d &transform, const model_pose &pose,
                     rgba tint, const model_recolor *recolors, u32 count);

i32 model_bone_count(const context &ctx, model_handle handle);

const char *model_bone_name(const context &ctx, model_handle handle, i32 bone);

i32 model_bone_find(const context &ctx, model_handle handle, const char *name);

i32 model_bone_parent(const context &ctx, model_handle handle, i32 bone);

bool model_bone_bounds(const context &ctx, model_handle handle, i32 bone, bool children, vec3 *min, vec3 *max);

i32 model_bone_points(const context &ctx, model_handle handle, i32 bone, bool children, vec3 *out, i32 count);

struct bone_pose3d {
  vec3 position{0.0f, 0.0f, 0.0f}; 
  vec3 x_axis{1.0f, 0.0f, 0.0f};   
  vec3 y_axis{0.0f, 1.0f, 0.0f};   
  vec3 z_axis{0.0f, 0.0f, 1.0f};   
};

i32 model_morph_count(const context &ctx, model_handle handle);

const char *model_morph_name(const context &ctx, model_handle handle, i32 morph);

i32 model_morph_find(const context &ctx, model_handle handle, const char *name);

i32 model_morph_weights(const context &ctx, model_handle handle, const model_pose &pose, f32 *out, i32 count);

bone_pose3d model_bone_pose(const context &ctx, model_handle handle, const model_pose &pose, i32 bone);

struct ray3d {
  vec3 origin{0.0f, 0.0f, 0.0f};     
  vec3 direction{0.0f, 0.0f, -1.0f}; 
};

struct ray3d_hit {
  bool hit = false;                
  f32 distance = 0.0f;             
  vec3 point{0.0f, 0.0f, 0.0f};    
  vec3 normal{0.0f, 0.0f, 0.0f};   
};

ray3d camera3d_ray(const context &ctx, const camera3d &camera, vec2 screen);

vec2 camera3d_to_screen(const context &ctx, const camera3d &camera, vec3 point, bool *visible = nullptr);

ray3d_hit ray3d_box(const ray3d &ray, vec3 center, vec3 size);

ray3d_hit ray3d_sphere(const ray3d &ray, vec3 center, f32 radius);

ray3d_hit ray3d_plane(const ray3d &ray, vec3 point, vec3 normal);

ray3d_hit ray3d_shape(const ray3d &ray, const shape3d &shape);

ray3d_hit ray3d_model(const context &ctx, const ray3d &ray, model_handle model, const transform3d &transform);

ray3d_hit ray3d_model(const context &ctx, const ray3d &ray, model_handle model, const transform3d &transform,
                      const model_pose &pose);

enum mesh3d_kind {
  mesh3d_cube,     
  mesh3d_sphere,   
  mesh3d_plane,    
  mesh3d_cylinder, 
  mesh3d_sphere_low,
  mesh3d_cylinder_low,
};

void draw_instanced3d(const context &ctx, mesh3d_kind mesh, instance_buffer_handle buffer, u32 first, u32 count,
                      shader_handle shader = {});

void draw_instanced3d(const context &ctx, model_handle model, instance_buffer_handle buffer, u32 first, u32 count,
                      shader_handle shader = {});

void draw_instanced3d(const context &ctx, model_handle model, instance_buffer_handle buffer, u32 first, u32 count,
                      const model_pose &pose, shader_handle shader = {});

struct fx3d {
  rgba flash{1.0f, 1.0f, 1.0f, 0.0f};
  f32 dissolve = 0.0f;
  rgba edge_color{1.0f, 0.55f, 0.1f, 1.0f}; 
  f32 edge_width = 0.08f; 
  f32 grain = 0.1f;       
  f32 seed = 0.0f;        
  vec3 mask_center{0.0f, 0.0f, 0.0f};
  f32 mask_radius = 0.0f; 
};

void fx3d_set(context &ctx, const fx3d &fx);

struct particles3d_desc {
  vec3 direction{0.0f, 1.0f, 0.0f};
  f32 scale = 0.02f;
};

void particles3d_spawn(context &ctx, const particle_emitter &emitter, vec3 pos, i32 count,
                       const particles3d_desc &desc = {});

void particles3d_clear(context &ctx);

i32 particles3d_count(const context &ctx);

struct model3d {
  model_handle model{};          
  rgba tint{1.0f, 1.0f, 1.0f, 1.0f}; 
  model_pose pose{};             
  f32 speed = 1.0f;              
  fx3d fx{};                     
  bool visible = true;           
};

struct shape3d_render {
  shape3d shape{};                    
  rgba color{1.0f, 1.0f, 1.0f, 1.0f}; 
  material3d material{};              
  fx3d fx{};                          
  bool visible = true;                
};

} // namespace njin