njin_world3d.h

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

 
// ---------------------------------------------------------------------------
// Địa hình
// ---------------------------------------------------------------------------

inline constexpr i32 terrain3d_layer_max = 4;

struct terrain3d_layer {
  texture_handle albedo{}; 
  texture_handle normal{}; 
  rgba color{1.0f, 1.0f, 1.0f, 1.0f}; 
  f32 tile = 4.0f; 
  f32 min_height = -1.0e9f; 
  f32 max_height = 1.0e9f;  
  f32 min_slope = 0.0f;     
  f32 max_slope = 90.0f;    
  f32 blend = 3.0f;         
};

struct terrain3d_desc {
  vec3 origin{0.0f, 0.0f, 0.0f}; 
  f32 size = 256.0f;             
  i32 resolution = 257;
  const f32 *heights = nullptr;
  const char *heightmap = nullptr;
  noise_desc noise{.seed = 1, .frequency = 0.004f, .fractal = fractal_fbm, .octaves = 5};
  f32 height_scale = 40.0f; 
  i32 smooth = 0;           
  terrain3d_layer layers[terrain3d_layer_max]{}; 
  i32 layer_count = 1;      
  bool auto_splat = true;
  const char *splatmap = nullptr;
  i32 chunk_quads = 32;      
  f32 lod_distance = 60.0f;  
  i32 lod_levels = 4;        
  f32 specular = 0.05f;      
  f32 shininess = 16.0f;     
  bool cast_shadows = true;  
  bool collision = true;     
  f32 friction = 0.8f;       
  u64 user = 0;              
};

terrain3d_handle terrain3d_create(context &ctx, const terrain3d_desc &desc);

void terrain3d_destroy(context &ctx, terrain3d_handle handle);

void draw_terrain3d(const context &ctx, terrain3d_handle handle);

f32 terrain3d_height(const context &ctx, terrain3d_handle handle, f32 x, f32 z);

vec3 terrain3d_normal(const context &ctx, terrain3d_handle handle, f32 x, f32 z);

bool terrain3d_contains(const context &ctx, terrain3d_handle handle, f32 x, f32 z);

f32 terrain3d_layer_weight(const context &ctx, terrain3d_handle handle, f32 x, f32 z, i32 layer);

body3d_handle terrain3d_body(const context &ctx, terrain3d_handle handle);

enum terrain3d_brush_kind {
  terrain3d_raise,   
  terrain3d_lower,   
  terrain3d_flatten, 
  terrain3d_smooth,  
};

struct terrain3d_brush {
  terrain3d_brush_kind kind = terrain3d_raise; 
  vec3 center{0.0f, 0.0f, 0.0f}; 
  f32 radius = 4.0f;             
  f32 strength = 0.5f;           
  f32 height = 0.0f;             
  f32 falloff = 0.6f;
};

void terrain3d_edit(context &ctx, terrain3d_handle handle, const terrain3d_brush &brush);

void terrain3d_paint(context &ctx, terrain3d_handle handle, vec3 center, f32 radius, i32 layer, f32 strength);
 
// ---------------------------------------------------------------------------
// Cỏ và vật rải
// ---------------------------------------------------------------------------

struct grass3d_desc {
  terrain3d_handle terrain{}; 
  f32 density = 6.0f;         
  f32 height = 0.45f;         
  f32 height_jitter = 0.4f;   
  f32 width = 0.05f;          
  rgba base_color{0.12f, 0.30f, 0.07f, 1.0f}; 
  rgba tip_color{0.52f, 0.70f, 0.28f, 1.0f};  
  f32 color_jitter = 0.15f;   
  i32 layer = 0;
  f32 max_slope = 35.0f;      
  noise_desc patches{.seed = 3, .frequency = 0.06f, .octaves = 2};
  f32 patchiness = 0.4f;      
  f32 draw_distance = 60.0f;  
  f32 fade = 20.0f;           
  f32 sway = 1.0f;            
  u32 seed = 1;               
  bool cast_shadows = false;  
};

grass3d_handle grass3d_create(context &ctx, const grass3d_desc &desc);

void grass3d_destroy(context &ctx, grass3d_handle handle);

void draw_grass3d(const context &ctx, grass3d_handle handle);

i32 grass3d_drawn(const context &ctx, grass3d_handle handle);

void wind3d_set(context &ctx, vec2 wind);

vec2 wind3d_get(const context &ctx);

struct scatter3d_desc {
  terrain3d_handle terrain{}; 
  model_handle model{};       
  model_handle far_model{};   
  f32 density = 0.02f;        
  f32 spacing = 2.0f;         
  f32 min_height = -1.0e9f;   
  f32 max_height = 1.0e9f;    
  f32 min_slope = 0.0f;       
  f32 max_slope = 30.0f;      
  i32 layer = -1;             
  f32 layer_min = 0.5f;       
  noise_desc patches{.seed = 5, .frequency = 0.02f, .octaves = 2}; 
  f32 patchiness = 0.0f;      
  f32 scale_min = 0.8f;       
  f32 scale_max = 1.2f;       
  f32 align = 0.0f;           
  f32 sink = 0.0f;            
  rgba color{1.0f, 1.0f, 1.0f, 1.0f}; 
  f32 color_jitter = 0.1f;    
  f32 lod_distance = 80.0f;   
  f32 draw_distance = 300.0f; 
  u32 seed = 1;               
};

scatter3d_handle scatter3d_create(context &ctx, const scatter3d_desc &desc);

void scatter3d_destroy(context &ctx, scatter3d_handle handle);

void draw_scatter3d(const context &ctx, scatter3d_handle handle);

i32 scatter3d_count(const context &ctx, scatter3d_handle handle);

i32 scatter3d_transforms(const context &ctx, scatter3d_handle handle, transform3d *out, i32 count);
 
// ---------------------------------------------------------------------------
// Nước
// ---------------------------------------------------------------------------

inline constexpr i32 water3d_wave_max = 8;

struct water3d_wave {
  vec2 direction{1.0f, 0.0f}; 
  f32 wavelength = 12.0f;     
  f32 steepness = 0.2f;
  f32 speed = 1.0f;           
};

struct water3d_desc {
  f32 level = 0.0f;                
  vec2 center{0.0f, 0.0f};         
  vec2 size{0.0f, 0.0f};           
  water3d_wave waves[water3d_wave_max]{{{1.0f, 0.3f}, 9.0f, 0.18f, 1.0f},
                                       {{0.6f, -0.8f}, 5.5f, 0.14f, 1.0f},
                                       {{-0.4f, 1.0f}, 3.1f, 0.10f, 1.0f}};
  i32 wave_count = 3;              
  rgba shallow_color{0.10f, 0.42f, 0.45f, 1.0f}; 
  rgba deep_color{0.02f, 0.09f, 0.16f, 1.0f};    
  f32 depth_fade = 6.0f;           
  f32 clarity = 1.5f;              
  rgba foam_color{0.95f, 0.97f, 1.0f, 1.0f};     
  f32 foam_width = 0.5f;           
  f32 crest_foam = 0.35f;          
  f32 ripples = 0.35f;             
  f32 specular = 1.0f;             
  f32 shininess = 300.0f;          
  terrain3d_handle terrain{};      
  f32 detail = 1.0f;
};

water3d_handle water3d_create(context &ctx, const water3d_desc &desc);

void water3d_destroy(context &ctx, water3d_handle handle);

void water3d_set(context &ctx, water3d_handle handle, const water3d_desc &desc);

water3d_desc water3d_get(const context &ctx, water3d_handle handle);

void draw_water3d(const context &ctx, water3d_handle handle);

f32 water3d_height(const context &ctx, water3d_handle handle, f32 x, f32 z);

vec3 water3d_normal(const context &ctx, water3d_handle handle, f32 x, f32 z);

f32 water3d_time(const context &ctx);

struct buoyancy3d {
  f32 buoyancy = 1.4f;
  f32 linear_drag = 0.6f;  
  f32 angular_drag = 0.15f; 
  vec3 flow{0.0f, 0.0f, 0.0f}; 
};

void water3d_float(context &ctx, water3d_handle water, body3d_handle body, const buoyancy3d &buoyancy = {});

void water3d_unfloat(context &ctx, water3d_handle water, body3d_handle body);
 
// ---------------------------------------------------------------------------
// Bầu trời và thời tiết
// ---------------------------------------------------------------------------

struct weather3d {
  f32 clouds = 0.3f;         
  f32 cloud_darkness = 0.0f; 
  f32 fog = 0.0f;            
  f32 rain = 0.0f;           
  f32 snow = 0.0f;           
  vec2 wind{2.0f, 0.6f};     
  f32 wetness = 0.0f;        
  bool cover_auto = true;
};

struct weather3d_cover {
  vec3 center{0.0f, 0.0f, 0.0f}; 
  vec3 size{1.0f, 1.0f, 1.0f};   
};

void weather3d_cover_set(context &ctx, const weather3d_cover *covers, i32 count);

i32 weather3d_cover_count(const context &ctx);

enum weather3d_kind {
  weather3d_clear,    
  weather3d_overcast, 
  weather3d_rain,     
  weather3d_snow,     
  weather3d_fog,      
};

weather3d weather3d_preset(weather3d_kind kind);

weather3d weather3d_lerp(const weather3d &a, const weather3d &b, f32 t);

struct sky3d {
  f32 hour = 10.0f;         
  f32 latitude = 35.0f;     
  f32 season = 0.0f;
  f32 north = 0.0f;         
  weather3d weather{};      
  f32 cloud_height = 900.0f; 
  f32 cloud_scale = 1.0f;   
  bool stars = true;        
  f32 sun_size = 1.0f;      
  bool drive_light = true;
};

vec3 sky3d_sun_direction(const sky3d &sky);

light3d sky3d_light(const sky3d &sky, const light3d &base = {});

rgba sky3d_color(const sky3d &sky, vec3 direction);

void draw_sky3d(context &ctx, const sky3d &sky);
} // namespace njin