HighMap library (C++)
Loading...
Searching...
No Matches
erosion.hpp
Go to the documentation of this file.
1/* Copyright (c) 2023 Otto Link. Distributed under the terms of the GNU General
2 Public License. The full license is in the file LICENSE, distributed with
3 this software. */
4#pragma once
5#include <cmath>
6#include <cstdint>
7#include <vector>
8
9#include "highmap/array.hpp"
10#include "highmap/hydrology/hydrology.hpp"
11#include "highmap/interpolate/interpolate2d.hpp"
12#include "highmap/math/profiles.hpp"
13#include "highmap/terrain_tri_mesh.hpp"
14
15// neighbor pattern search based on Moore pattern and define diagonal
16// weight coefficients ('c' corresponds to a weight coefficient
17// applied to take into account the longer distance for diagonal
18// comparison between cells)
19
20// clang-format off
21// 6 2 8
22// 1 . 4
23// 5 3 7
24#define HMAP_DI {-1, 0, 0, 1, -1, -1, 1, 1}
25#define HMAP_DJ {0, 1, -1, 0, -1, 1, -1, 1}
26#define HMAP_CD {1.f, 1.f, 1.f, 1.f, M_SQRT2, M_SQRT2, M_SQRT2, M_SQRT2}
27#define HMAP_CD_INV {1.f, 1.f, 1.f, 1.f, M_SQRT2, M_SQRT2, M_SQRT2, M_SQRT2}
28// clang-format on
29
30namespace hmap
31{
32
70void coastal_erosion_diffusion(Array &z,
71 Array &water_depth,
72 float additional_depth,
73 int iterations = 10,
74 const Array *p_mask = nullptr,
75 Array *p_water_mask = nullptr);
76
124void coastal_erosion_profile(Array &z,
125 Array &water_depth,
126 float shore_ground_extent, // pixels
127 float shore_water_extent,
128 float slope_shore = 0.5f,
129 float slope_shore_water = 0.5f,
130 float scarp_extent_ratio = 0.5f, // in [0, 1]
131 bool apply_post_filter = true,
132 int post_filter_iterations = 3,
133 bool solid_shore_mask = true,
134 float scarp_mask_transition_ratio = 0.2f,
135 const Array *p_noise = nullptr,
136 Array *p_shore_mask = nullptr,
137 Array *p_scarp_mask = nullptr);
138
139void coastal_erosion_profile(Array &z,
140 const Array *p_mask,
141 Array &water_depth,
142 float shore_ground_extent, // pixels
143 float shore_water_extent,
144 float slope_shore = 0.5f,
145 float slope_shore_water = 0.5f,
146 float scarp_extent_ratio = 0.5f, // in [0, 1]
147 bool apply_post_filter = true,
148 int post_filter_iterations = 3,
149 bool solid_shore_mask = true,
150 float scarp_mask_transition_ratio = 0.2f,
151 const Array *p_noise = nullptr,
152 Array *p_shore_mask = nullptr,
153 Array *p_scarp_mask = nullptr);
154
172void depression_filling(Array &z, int iterations = 1000, float epsilon = 1e-4f);
173
174void depression_filling_priority_flood(Array &z,
175 bool apply_post_filter = false);
176
193void erosion_maps(Array &z_before,
194 Array &z_after,
195 Array &erosion_map,
196 Array &deposition_map,
197 float tolerance = 0.f);
198
222Array generate_bedrock(const Array &z,
223 float elevation_strength,
224 float slope_strength,
225 float slope_limit,
226 float zmin = 0.f,
227 float zmax = -1.f);
228
253void hydraulic_algebric(Array &z,
254 Array *p_mask,
255 float talus_ref,
256 int ir,
257 Array *p_bedrock = nullptr,
258 Array *p_erosion_map = nullptr,
259 Array *p_deposition_map = nullptr,
260 float c_erosion = 0.05f,
261 float c_deposition = 0.05f,
262 int iterations = 1);
263
264void hydraulic_algebric(Array &z,
265 float talus_ref,
266 int ir,
267 Array *p_bedrock = nullptr,
268 Array *p_erosion_map = nullptr,
269 Array *p_deposition_map = nullptr,
270 float c_erosion = 0.05f,
271 float c_deposition = 0.05f,
272 int iterations = 1);
273
304void hydraulic_benes(Array &z,
305 Array *p_mask,
306 int iterations = 50,
307 Array *p_bedrock = nullptr,
308 Array *p_moisture_map = nullptr,
309 Array *p_erosion_map = nullptr,
310 Array *p_deposition_map = nullptr,
311 float c_capacity = 40.f,
312 float c_erosion = 0.2f,
313 float c_deposition = 0.8f,
314 float water_level = 0.005f,
315 float evap_rate = 0.01f,
316 float rain_rate = 0.5f);
317
318void hydraulic_benes(Array &z,
319 int iterations = 50,
320 Array *p_bedrock = nullptr,
321 Array *p_moisture_map = nullptr,
322 Array *p_erosion_map = nullptr,
323 Array *p_deposition_map = nullptr,
324 float c_capacity = 40.f,
325 float c_erosion = 0.2f,
326 float c_deposition = 0.8f,
327 float water_level = 0.005f,
328 float evap_rate = 0.01f,
329 float rain_rate = 0.5f);
330
344void hydraulic_blur(Array &z,
345 float radius,
346 float vmax,
347 float k_smoothing = 0.1f);
348
366void hydraulic_diffusion(Array &z,
367 float c_diffusion,
368 float talus,
369 int iterations);
393void hydraulic_musgrave(Array &z,
394 Array &moisture_map,
395 int iterations = 100,
396 float c_capacity = 1.f,
397 float c_erosion = 0.1f,
398 float c_deposition = 0.1f,
399 float water_level = 0.01f,
400 float evap_rate = 0.01f);
401
402void hydraulic_musgrave(Array &z,
403 int iterations = 100,
404 float c_capacity = 1.f,
405 float c_erosion = 0.1f,
406 float c_deposition = 0.1f,
407 float water_level = 0.01f,
408 float evap_rate = 0.01f);
409
430void hydraulic_saleve(TerrainTriMesh &mesh,
431 const std::vector<float> &erodibility,
432 const std::vector<float> &max_slope,
433 float m_exp = 0.8f,
434 float uplift_rate = 1.f,
435 float tolerance = 1e-3f,
436 int max_iterations = 200,
437 float noise_strength = 0.f,
438 std::uint32_t seed = 0,
439 bool enable_post_slope_limiter = false,
440 float post_slope_limit = 0.f,
441 bool enable_post_smoothing = false);
442
473Array hydraulic_saleve(const Array &z,
474 std::uint32_t seed,
475 size_t control_points_count = 10000,
476 float m_exp = 0.8f,
477 float uplift_rate = 1.f,
478 float tolerance = 1e-3f,
479 int max_iterations = 200,
480 float smin = 0.f,
481 float smax = 6.f,
482 float strength = 0.5f,
483 bool scale_erodibility_with_z = true,
484 float erodibility_distrib_exp = 1.f,
485 float noise_strength = 0.f,
486 bool enable_post_slope_limiter = false,
487 float post_slope_limit = 0.f,
488 bool enable_post_smoothing = false,
489 InterpolationMethod2D interpolation_method =
490 InterpolationMethod2D::ITP2D_DELAUNAY_GRADIENT,
491 const Array *p_noise_x = nullptr,
492 const Array *p_noise_y = nullptr);
493
494Array hydraulic_saleve(const Array &z,
495 const Array *p_mask,
496 std::uint32_t seed,
497 size_t control_points_count = 10000,
498 float m_exp = 0.8f,
499 float uplift_rate = 1.f,
500 float tolerance = 1e-3f,
501 int max_iterations = 200,
502 float smin = 0.f,
503 float smax = 6.f,
504 float strength = 0.5f,
505 bool scale_erodibility_with_z = true,
506 float erodibility_distrib_exp = 1.f,
507 float noise_strength = 0.f,
508 bool enable_post_slope_limiter = false,
509 float post_slope_limit = 0.f,
510 bool enable_post_smoothing = false,
511 InterpolationMethod2D interpolation_method =
512 InterpolationMethod2D::ITP2D_DELAUNAY_GRADIENT,
513 const Array *p_noise_x = nullptr,
514 const Array *p_noise_y = nullptr);
515
543void hydraulic_stream(Array &z,
544 float c_erosion,
545 float talus_ref,
546 Array *p_bedrock = nullptr,
547 Array *p_moisture_map = nullptr,
548 Array *p_erosion_map = nullptr, // -> out
549 int ir = 1,
550 float clipping_ratio = 10.f);
551
552void hydraulic_stream(Array &z,
553 Array *p_mask,
554 float c_erosion,
555 float talus_ref,
556 Array *p_bedrock = nullptr,
557 Array *p_moisture_map = nullptr,
558 Array *p_erosion_map = nullptr, // -> out
559 int ir = 1,
560 float clipping_ratio = 10.f);
561
600void hydraulic_stream_log(Array &z,
601 float c_erosion,
602 float talus_ref,
603 int deposition_ir = 32,
604 float deposition_scale_ratio = 1.f,
605 float gradient_power = 0.8f,
606 float gradient_scaling_ratio = 1.f,
607 int gradient_prefilter_ir = 16,
608 float saturation_ratio = 1.f,
609 Array *p_bedrock = nullptr,
610 Array *p_moisture_map = nullptr,
611 Array *p_erosion_map = nullptr,
612 Array *p_deposition_map = nullptr,
613 Array *p_flow_map = nullptr);
614
615void hydraulic_stream_log(Array &z,
616 float c_erosion,
617 float talus_ref,
618 const Array *p_mask,
619 int deposition_ir = 32,
620 float deposition_scale_ratio = 1.f,
621 float gradient_power = 0.8f,
622 float gradient_scaling_ratio = 1.f,
623 int gradient_prefilter_ir = 16,
624 float saturation_ratio = 1.f,
625 Array *p_bedrock = nullptr,
626 Array *p_moisture_map = nullptr,
627 Array *p_erosion_map = nullptr,
628 Array *p_deposition_map = nullptr,
629 Array *p_flow_map = nullptr);
630
663void hydraulic_stream_upscale_amplification(Array &z,
664 float c_erosion,
665 float talus_ref,
666 int upscaling_levels = 1,
667 float persistence = 1.f,
668 int ir = 1,
669 float clipping_ratio = 10.f);
670
704void hydraulic_stream_upscale_amplification(
705 Array &z,
706 Array *p_mask,
707 float c_erosion,
708 float talus_ref,
709 int upscaling_levels = 1,
710 float persistence = 1.f,
711 int ir = 1,
712 float clipping_ratio = 10.f);
713
714} // namespace hmap
715
716namespace hmap::gpu
717{
718
745void conv_erosion(Array &z,
746 std::uint32_t seed,
747 int iterations = 20,
748 int particle_count = 1000,
749 int ir_min = 8,
750 int ir_max = 64,
751 float size_distrib_exp = 1.f,
752 float erosion_strength = 0.02f,
753 float randomness = 0.01f,
754 float exit_forcing = 0.05f,
755 int gradient_ir = 16,
756 float gradient_exp = 0.5f,
757 float gradient_strength_min = 0.f);
758
770void deposition_fill_holes(Array &z,
771 int deposition_ir,
772 float deposition_strength,
773 int iterations = 1);
774
775void deposition_fill_holes(Array &z,
776 int deposition_ir,
777 float deposition_strength,
778 const Array *p_mask,
779 int iterations = 1);
780
820void hydraulic_particle(Array &z,
821 int nparticles,
822 std::uint32_t seed,
823 const Array *p_bedrock = nullptr,
824 const Array *p_moisture_map = nullptr,
825 const Array *p_elevation_shift = nullptr,
826 Array *p_erosion_map = nullptr,
827 Array *p_deposition_map = nullptr,
828 float c_capacity = 10.f,
829 float c_erosion = 0.05f,
830 float c_deposition = 0.05f,
831 float c_inertia = 0.01f,
832 float c_gravity = 1.f,
833 float drag_rate = 0.001f,
834 float evap_rate = 0.001f,
835 float talus_slope = 2.f,
836 float collapse_rate = 0.1f,
837 int iterations = 1);
838
839void hydraulic_particle(Array &z,
840 const Array *p_mask,
841 int nparticles,
842 std::uint32_t seed,
843 const Array *p_bedrock = nullptr,
844 const Array *p_moisture_map = nullptr,
845 const Array *p_elevation_shift = nullptr,
846 Array *p_erosion_map = nullptr,
847 Array *p_deposition_map = nullptr,
848 float c_capacity = 10.f,
849 float c_erosion = 0.05f,
850 float c_deposition = 0.05f,
851 float c_inertia = 0.01f,
852 float c_gravity = 1.f,
853 float drag_rate = 0.001f,
854 float evap_rate = 0.001f,
855 float talus_slope = 2.f,
856 float collapse_rate = 0.1f,
857 int iterations = 1);
858
892void hydraulic_particle_multiscale(
893 Array &z,
894 std::uint32_t seed,
895 const std::vector<int> &steps_per_level = {4, 2, 1},
896 const Array *p_bedrock = nullptr,
897 const Array *p_moisture_map = nullptr,
898 const Array *p_elevation_shift = nullptr,
899 Array *p_erosion_map = nullptr,
900 Array *p_deposition_map = nullptr,
901 float particles_ratio = 0.5f,
902 float c_capacity = 10.f,
903 float c_erosion = 0.05f,
904 float c_deposition = 0.05f,
905 float c_inertia = 0.01f,
906 float c_gravity = 1.f,
907 float drag_rate = 0.001f,
908 float evap_rate = 0.001f,
909 float talus_slope = 2.f,
910 float collapse_rate = 0.1f,
911 float mix = 1.f);
912
967void hydraulic_mcdonald(Array &z,
968 int steps,
969 std::uint32_t seed,
970 Array *p_sediment_map = nullptr,
971 Array *p_discharge_map = nullptr,
972 float world_extent_km = 40.f,
973 float z_scale_km = 4.f,
974 int samples = 8192,
975 int maxage = 512,
976 float lrate = 0.2f,
977 float time_step = 10.f,
978 float rainfall = 1.f,
979 float evap_rate = 1e-4f,
980 float gravity = 9.81f,
981 float viscosity = 0.025f,
982 float bed_shear = 0.01f,
983 float crit_slope = 0.57f,
984 float settle_rate = 0.1f,
985 float thermal_rate = 2.5e-3f,
986 float deposition_rate = 5e-3f,
987 float suspension_rate = 2.5e-4f,
988 float exit_slope = 0.01f);
989
1004void hydraulic_mcdonald_multiscale(
1005 Array &z,
1006 std::uint32_t seed,
1007 const std::vector<int> &steps_per_level = {512, 256, 128},
1008 Array *p_sediment_map = nullptr,
1009 Array *p_discharge_map = nullptr,
1010 float world_extent_km = 40.f,
1011 float z_scale_km = 4.f,
1012 int samples = 8192,
1013 int maxage = 512,
1014 float lrate = 0.2f,
1015 float time_step = 10.f,
1016 float rainfall = 1.f,
1017 float evap_rate = 1e-4f,
1018 float gravity = 9.81f,
1019 float viscosity = 0.025f,
1020 float bed_shear = 0.01f,
1021 float crit_slope = 0.57f,
1022 float settle_rate = 0.1f,
1023 float thermal_rate = 2.5e-3f,
1024 float deposition_rate = 5e-3f,
1025 float suspension_rate = 2.5e-4f,
1026 float exit_slope = 0.01f);
1027
1076void hydraulic_procedural(
1077 Array &z,
1078 float kp_global,
1079 float c_erosion,
1080 std::uint32_t seed,
1081 ErosionProfile erosion_profile = ErosionProfile::EP_TRIANGLE_GRENIER,
1082 float erosion_profile_parameter = 0.01f,
1083 float angle_shift = 0.f, // degs
1084 float phase_smoothing = 0.1f,
1085 float talus_ref = 0.001f,
1086 float gradient_scaling_ratio = 1.f,
1087 float gradient_power = 0.8f,
1088 bool exclude_ridges = true,
1089 bool apply_deposition = false,
1090 float deposition_strength = 1.f,
1091 bool enable_default_noise = true,
1092 float noise_amp = 0.01f,
1093 const Array *p_kp_multiplier = nullptr,
1094 const Array *p_angle_shift = nullptr,
1095 const Array *p_noise_x = nullptr,
1096 const Array *p_noise_y = nullptr,
1097 Array *p_ridge_mask = nullptr, // ouptput
1098 glm::vec4 bbox = {0.f, 1.f, 0.f, 1.f});
1099
1138void hydraulic_procedural_fbm(
1139 Array &z,
1140 float kp_global,
1141 float c_erosion,
1142 std::uint32_t seed,
1143 ErosionProfile erosion_profile = ErosionProfile::EP_TRIANGLE_GRENIER,
1144 int octaves = 3,
1145 float persistence = 0.5f,
1146 float lacunarity = 2.f,
1147 float erosion_profile_parameter = 0.01f,
1148 float angle_shift = 0.f, // degs
1149 float phase_smoothing = 0.1f,
1150 float talus_ref = 0.001f,
1151 float gradient_scaling_ratio = 1.f,
1152 float gradient_power = 0.8f,
1153 bool exclude_ridges = true,
1154 bool apply_deposition = false,
1155 float deposition_strength = 1.f,
1156 bool enable_default_noise = true,
1157 float noise_amp = 0.01f,
1158 const Array *p_kp_multiplier = nullptr,
1159 const Array *p_angle_shift = nullptr,
1160 const Array *p_noise_x = nullptr,
1161 const Array *p_noise_y = nullptr,
1162 Array *p_ridge_mask = nullptr, // ouptput
1163 glm::vec4 bbox = {0.f, 1.f, 0.f, 1.f});
1164
1165void hydraulic_procedural_fbm(
1166 Array &z,
1167 float kp_global,
1168 float c_erosion,
1169 std::uint32_t seed,
1170 const Array *p_mask,
1171 ErosionProfile erosion_profile = ErosionProfile::EP_TRIANGLE_GRENIER,
1172 int octaves = 3,
1173 float persistence = 0.5f,
1174 float lacunarity = 2.f,
1175 float erosion_profile_parameter = 0.01f,
1176 float angle_shift = 0.f, // degs
1177 float phase_smoothing = 0.1f,
1178 float talus_ref = 0.001f,
1179 float gradient_scaling_ratio = 1.f,
1180 float gradient_power = 0.8f,
1181 bool exclude_ridges = true,
1182 bool apply_deposition = false,
1183 float deposition_strength = 1.f,
1184 bool enable_default_noise = true,
1185 float noise_amp = 0.01f,
1186 const Array *p_kp_multiplier = nullptr,
1187 const Array *p_angle_shift = nullptr,
1188 const Array *p_noise_x = nullptr,
1189 const Array *p_noise_y = nullptr,
1190 Array *p_ridge_mask = nullptr, // ouptput
1191 glm::vec4 bbox = {0.f, 1.f, 0.f, 1.f});
1192
1240void hydraulic_schott(Array &z,
1241 int iterations,
1242 const Array &talus,
1243 float c_erosion = 1.f,
1244 float c_thermal = 0.1f,
1245 float c_deposition = 0.2f,
1246 float flow_acc_exponent = 0.8f,
1247 float flow_acc_exponent_depo = 0.8f,
1248 float flow_routing_exponent = 1.3f,
1249 float thermal_weight = 1.5f,
1250 float deposition_weight = 2.5f,
1251 Array *p_flow = nullptr);
1252
1253void hydraulic_schott(Array &z,
1254 int iterations,
1255 const Array &talus,
1256 Array *p_mask,
1257 float c_erosion = 1.f,
1258 float c_thermal = 0.1f,
1259 float c_deposition = 0.2f,
1260 float flow_acc_exponent = 0.8f,
1261 float flow_acc_exponent_depo = 0.8f,
1262 float flow_routing_exponent = 1.3f,
1263 float thermal_weight = 1.5f,
1264 float deposition_weight = 2.5f,
1265 Array *p_flow = nullptr);
1266
1268void hydraulic_schott_erosion(Array &z,
1269 int iterations,
1270 float c_erosion = 1.f,
1271 float flow_acc_exponent = 0.8f,
1272 float flow_routing_exponent = 1.3f,
1273 const Array *p_moisture_map = nullptr,
1274 Array *p_flow = nullptr);
1275
1277void hydraulic_stream_log(Array &z,
1278 float c_erosion,
1279 float talus_ref,
1280 int deposition_ir = 32,
1281 float deposition_scale_ratio = 1.f,
1282 float gradient_power = 0.8f,
1283 float gradient_scaling_ratio = 1.f,
1284 int gradient_prefilter_ir = 16,
1285 float saturation_ratio = 1.f,
1286 Array *p_bedrock = nullptr,
1287 Array *p_moisture_map = nullptr,
1288 Array *p_erosion_map = nullptr,
1289 Array *p_deposition_map = nullptr,
1290 Array *p_flow_map = nullptr);
1291
1292void hydraulic_stream_log(Array &z,
1293 float c_erosion,
1294 float talus_ref,
1295 const Array *p_mask,
1296 int deposition_ir = 32,
1297 float deposition_scale_ratio = 1.f,
1298 float gradient_power = 0.8f,
1299 float gradient_scaling_ratio = 1.f,
1300 int gradient_prefilter_ir = 16,
1301 float saturation_ratio = 1.f,
1302 Array *p_bedrock = nullptr,
1303 Array *p_moisture_map = nullptr,
1304 Array *p_erosion_map = nullptr,
1305 Array *p_deposition_map = nullptr,
1306 Array *p_flow_map = nullptr);
1307
1309void hydraulic_vpipes(Array &z,
1310 float water_height = 1e-2f,
1311 bool maintain_water_volume = true,
1312 float evap_rate = 0.1f,
1313 int iterations = 50,
1314 float dt = 0.5f,
1315 float k_capacity = 0.5f,
1316 float k_erode = 0.001f,
1317 float k_depose = 0.01f,
1318 float k_discharge_exp = 1.f,
1319 float downcutting_max_depth_ratio = 10.f,
1320 bool flux_diffusion = true,
1321 float flux_diffusion_strength = 0.01f,
1322 Array *p_rain_map = nullptr,
1323 Array *p_water_depth = nullptr,
1324 Array *p_sediment = nullptr,
1325 Array *p_vel_u = nullptr,
1326 Array *p_vel_v = nullptr);
1327
1356void mudslide(Array &z,
1357 const Array &landslide_mask,
1358 float depth,
1359 int iterations,
1360 float depth_map_exponent = 0.5f,
1361 float viscosity_law_power = 1.5f,
1362 Array *p_depth_end = nullptr,
1363 Array *p_depth_init = nullptr);
1364
1366void mudslide(Array &z,
1367 float talus_limit,
1368 float depth,
1369 int iterations,
1370 float depth_map_exponent = 0.5f,
1371 float viscosity_law_power = 1.5f,
1372 Array *p_depth_end = nullptr,
1373 Array *p_depth_init = nullptr);
1374
1426void rifts(Array &z,
1427 const glm::vec2 &kw, // = {4.f, 1.2f},
1428 float angle, // degs
1429 float amplitude,
1430 std::uint32_t seed,
1431 float elevation_noise_shift = 0.f,
1432 float k_smooth_bottom = 0.05f,
1433 float k_smooth_top = 0.05f,
1434 float radial_spread_amp = 0.2f,
1435 float elevation_noise_amp = 0.1f,
1436 float clamp_vmin = 0.f,
1437 float remap_vmin = 0.f,
1438 bool apply_mask = true,
1439 bool reverse_mask = false,
1440 float mask_gamma = 1.f,
1441 const Array *p_noise_x = nullptr,
1442 const Array *p_noise_y = nullptr,
1443 const Array *p_mask = nullptr,
1444 const glm::vec2 &center = {0.5f, 0.5f},
1445 const glm::vec4 &bbox = {0.f, 1.f, 0.f, 1.f});
1446
1469void sediment_deposition(Array &z,
1470 Array *p_mask,
1471 const Array &talus,
1472 Array *p_deposition_map = nullptr,
1473 float max_deposition = 0.01,
1474 int iterations = 5,
1475 int thermal_subiterations = 10);
1476
1477void sediment_deposition(Array &z,
1478 const Array &talus,
1479 Array *p_deposition_map = nullptr,
1480 float max_deposition = 0.01,
1481 int iterations = 5,
1482 int thermal_subiterations = 10);
1483
1505void sediment_layer(Array &z,
1506 const Array &talus_layer,
1507 const Array &talus_upper_limit,
1508 int iterations,
1509 bool apply_post_filter = true,
1510 Array *p_deposition_map = nullptr);
1511
1569void strata(Array &z,
1570 float angle,
1571 float slope,
1572 float gamma, // e.g 0.5f or 1.5f
1573 std::uint32_t seed,
1574 bool linear_gamma = true,
1575 float kz = 1.f,
1576 int octaves = 4,
1577 float lacunarity = 2.f,
1578 float gamma_noise_ratio = 0.5f,
1579 float noise_amp = 0.4f,
1580 const glm::vec2 &noise_kw = {4.f, 4.f},
1581 bool enable_ridge_noise = true,
1582 const glm::vec2 &ridge_noise_kw = {4.f, 1.2f},
1583 float ridge_angle_shift = 45.f,
1584 float ridge_noise_amp = 0.5f,
1585 float ridge_clamp_vmin = 0.f,
1586 float ridge_remap_vmin = 0.f,
1587 bool apply_elevation_mask = true,
1588 bool apply_ridge_mask = true,
1589 float mask_gamma = 0.4f,
1590 const Array *p_mask = nullptr,
1591 const glm::vec4 &bbox = {0.f, 1.f, 0.f, 1.f});
1592
1619void strata_cells(Array &z,
1620 glm::vec2 kw,
1621 float amp,
1622 std::uint32_t seed,
1623 float gamma = 0.5f,
1624 float gamma_lateral = 0.4f,
1625 float angle = 0.f,
1626 float noise_amp = 0.5f,
1627 bool absolute_displacement = true,
1628 float occurence_probability = 0.5f,
1629 const Array *p_noise_x = nullptr,
1630 const Array *p_noise_y = nullptr,
1631 glm::vec4 bbox = {0.f, 1.f, 0.f, 1.f});
1632
1660void strata_cells(Array &z,
1661 glm::vec2 kw,
1662 float amp,
1663 std::uint32_t seed,
1664 const Array *p_mask,
1665 float gamma = 0.5f,
1666 float gamma_lateral = 0.4f,
1667 float angle = 0.f,
1668 float noise_amp = 0.5f,
1669 bool absolute_displacement = true,
1670 float occurence_probability = 0.5f,
1671 const Array *p_noise_x = nullptr,
1672 const Array *p_noise_y = nullptr,
1673 glm::vec4 bbox = {0.f, 1.f, 0.f, 1.f});
1674
1705void strata_cells_fbm(Array &z,
1706 glm::vec2 kw,
1707 float amp,
1708 std::uint32_t seed,
1709 float gamma = 0.5f,
1710 float gamma_lateral = 0.4f,
1711 float angle = 0.f,
1712 bool enable_default_noise = true,
1713 float default_noise_amp = 0.05f,
1714 bool absolute_displacement = true,
1715 float occurence_probability = 0.5f,
1716 int octaves = 8,
1717 float persistence = 0.4f,
1718 float lacunarity = 2.2f,
1719 const Array *p_noise_x = nullptr,
1720 const Array *p_noise_y = nullptr,
1721 glm::vec4 bbox = {0.f, 1.f, 0.f, 1.f});
1722
1754void strata_cells_fbm(Array &z,
1755 glm::vec2 kw,
1756 float amp,
1757 std::uint32_t seed,
1758 const Array *p_mask,
1759 float gamma = 0.5f,
1760 float gamma_lateral = 0.4f,
1761 float angle = 0.f,
1762 bool enable_default_noise = true,
1763 float default_noise_amp = 0.05f,
1764 bool absolute_displacement = true,
1765 float occurence_probability = 0.5f,
1766 int octaves = 8,
1767 float persistence = 0.4f,
1768 float lacunarity = 2.2f,
1769 const Array *p_noise_x = nullptr,
1770 const Array *p_noise_y = nullptr,
1771 glm::vec4 bbox = {0.f, 1.f, 0.f, 1.f});
1772
1796void strata_plates(Array &z,
1797 const Array &talus,
1798 int direction_offset = 0,
1799 int direction_count = 3,
1800 bool random_directions = false,
1801 std::uint32_t seed = 0,
1802 float vmin = -FLT_MAX,
1803 float skew = 0.f,
1804 float mix_ratio = 0.9f,
1805 const Array *p_mask = nullptr,
1806 const Array *p_dx = nullptr,
1807 const Array *p_dy = nullptr);
1808
1834void strata_terrace(Array &z,
1835 float gamma, // e.g 0.5f or 1.5f
1836 std::uint32_t seed,
1837 float kz = 4.f, // 4-layers
1838 bool linear_gamma = true,
1839 float gamma_noise_ratio = 0.5f,
1840 float slope = 0.f,
1841 float angle = 0.f,
1842 const Array *p_noise = nullptr,
1843 glm::vec4 bbox = {0.f, 1.f, 0.f, 1.f});
1844
1870void strata_terrace(Array &z,
1871 float gamma, // e.g 0.5f or 1.5f
1872 std::uint32_t seed,
1873 const Array *p_mask,
1874 float kz = 4.f, // 4-layers
1875 bool linear_gamma = true,
1876 float gamma_noise_ratio = 0.5f,
1877 float slope = 0.f,
1878 float angle = 0.f,
1879 const Array *p_noise = nullptr,
1880 glm::vec4 bbox = {0.f, 1.f, 0.f, 1.f});
1881
1901void thermal(Array &z,
1902 const Array &talus,
1903 int iterations = 10,
1904 Array *p_bedrock = nullptr,
1905 Array *p_deposition_map = nullptr);
1906
1907void thermal(Array &z,
1908 const Array *p_mask,
1909 const Array &talus,
1910 int iterations = 10,
1911 Array *p_bedrock = nullptr,
1912 Array *p_deposition_map = nullptr);
1913
1914void thermal(Array &z,
1915 float talus,
1916 int iterations = 10,
1917 Array *p_bedrock = nullptr,
1918 Array *p_deposition_map = nullptr);
1919
1941void thermal_auto_bedrock(Array &z,
1942 const Array &talus,
1943 int iterations = 10,
1944 Array *p_deposition_map = nullptr);
1945
1946void thermal_auto_bedrock(Array &z,
1947 const Array *p_mask,
1948 const Array &talus,
1949 int iterations = 10,
1950 Array *p_deposition_map = nullptr);
1951
1952void thermal_auto_bedrock(Array &z,
1953 float,
1954 int iterations = 10,
1955 Array *p_deposition_map = nullptr);
1956
1972void thermal_flatten(Array &z,
1973 const Array &talus,
1974 int iterations,
1975 float sigma_inf = 0.5f,
1976 float sigma_sup = 0.f);
1977
1978void thermal_flatten(Array &z,
1979 const Array *p_mask,
1980 const Array &talus,
1981 int iterations,
1982 float sigma_inf = 0.5f,
1983 float sigma_sup = 0.f);
1984
2004void thermal_olsen(Array &z, const Array &talus, int iterations);
2005
2006void thermal_olsen(Array &z,
2007 const Array *p_mask,
2008 const Array &talus,
2009 int iterations);
2010
2028void thermal_inflate(Array &z, const Array &talus, int iterations = 10);
2029
2030void thermal_inflate(Array &z,
2031 const Array *p_mask,
2032 const Array &talus,
2033 int iterations = 10);
2034
2047void thermal_rib(Array &z, int iterations);
2048
2049void thermal_rib(Array &z, const Array *p_mask, int iterations);
2050
2070void thermal_ridge(Array &z,
2071 const Array &talus,
2072 int iterations = 10,
2073 Array *p_deposition_map = nullptr);
2074
2075void thermal_ridge(Array &z,
2076 const Array *p_mask,
2077 const Array &talus,
2078 int iterations = 10,
2079 Array *p_deposition_map = nullptr);
2080
2102void thermal_schott(Array &z,
2103 const Array &talus,
2104 int iterations = 10,
2105 float intensity = 0.2f,
2106 Array *p_deposition_map = nullptr);
2107
2108void thermal_schott(Array &z,
2109 const Array *p_mask,
2110 const Array &talus,
2111 int iterations = 10,
2112 float intensity = 0.2f,
2113 Array *p_deposition_map = nullptr);
2114
2134void thermal_scree(Array &z,
2135 const Array &talus,
2136 const Array &zmax,
2137 int iterations = 10,
2138 Array *p_deposition_map = nullptr);
2139
2140void thermal_scree(Array &z,
2141 const Array *p_mask,
2142 const Array &talus,
2143 const Array &zmax,
2144 int iterations = 10,
2145 Array *p_deposition_map = nullptr);
2146
2167void valley_fill(Array &z,
2168 const Array &talus,
2169 int iterations = 100,
2170 float gamma = 2.f,
2171 float ratio = 0.8f,
2172 float zmin = 0.f,
2173 float zmax = 0.f,
2174 float elevation_max_ratio = 1.f,
2175 bool preserve_elevation_range = true,
2176 const Array *p_noise = nullptr,
2177 Array *p_deposition_map = nullptr);
2178
2179void valley_fill(Array &z,
2180 const Array *p_mask,
2181 const Array &talus,
2182 int iterations = 100,
2183 float gamma = 2.f,
2184 float ratio = 0.8f,
2185 float zmin = 0.f,
2186 float zmax = 0.f,
2187 float elevation_max_ratio = 1.f,
2188 bool preserve_elevation_range = true,
2189 const Array *p_noise = nullptr,
2190 Array *p_deposition_map = nullptr);
2191
2213Array watershed_ridge(
2214 const Array &z,
2215 float amplitude = 0.2f,
2216 float width = 32.f, // pixels
2217 float edt_exponent = 0.5f,
2218 int prefilter_ir = 0,
2219 FlowDirectionMethod fd_method = FlowDirectionMethod::FDM_D8,
2220 const Array *p_noise_x = nullptr,
2221 const Array *p_noise_y = nullptr,
2222 const Array *p_scaling = nullptr);
2223
2224Array watershed_ridge(
2225 const Array &z,
2226 const Array *p_mask,
2227 float amplitude = 0.2f,
2228 float width = 32.f,
2229 float edt_exponent = 0.5f,
2230 int prefilter_ir = 0,
2231 FlowDirectionMethod fd_method = FlowDirectionMethod::FDM_D8,
2232 const Array *p_noise_x = nullptr,
2233 const Array *p_noise_y = nullptr,
2234 const Array *p_scaling = nullptr);
2235
2236} // namespace hmap::gpu
array.hpp
Declaration of the Array class for 2D floating-point arrays with various mathematical operations and ...
hmap::Array
Array class, helper to manipulate 2D float array with "(i, j)" indexing.
Definition array.hpp:32
hydrology.hpp
Header file for hydrological modeling functions and utilities.
interpolate2d.hpp
Header file for 2D interpolation methods.
hmap::gpu
Definition blending.hpp:225
hmap::gpu::thermal_olsen
void thermal_olsen(Array &z, const Array &talus, int iterations)
Apply thermal weathering erosion.
Definition thermal_gpu.cpp:236
hmap::gpu::thermal_ridge
void thermal_ridge(Array &z, const Array &talus, int iterations=10, Array *p_deposition_map=nullptr)
Apply thermal weathering erosion to give a ridge like effect.
Definition thermal_gpu.cpp:293
hmap::gpu::sediment_deposition
void sediment_deposition(Array &z, Array *p_mask, const Array &talus, Array *p_deposition_map=nullptr, float max_deposition=0.01, int iterations=5, int thermal_subiterations=10)
Perform sediment deposition combined with thermal erosion.
Definition deposition.cpp:45
hmap::gpu::thermal
void thermal(Array &z, const Array &talus, int iterations=10, Array *p_bedrock=nullptr, Array *p_deposition_map=nullptr)
Apply thermal weathering erosion.
Definition thermal_gpu.cpp:18
hmap::gpu::hydraulic_mcdonald_multiscale
void hydraulic_mcdonald_multiscale(Array &z, std::uint32_t seed, const std::vector< int > &steps_per_level={512, 256, 128}, Array *p_sediment_map=nullptr, Array *p_discharge_map=nullptr, float world_extent_km=40.f, float z_scale_km=4.f, int samples=8192, int maxage=512, float lrate=0.2f, float time_step=10.f, float rainfall=1.f, float evap_rate=1e-4f, float gravity=9.81f, float viscosity=0.025f, float bed_shear=0.01f, float crit_slope=0.57f, float settle_rate=0.1f, float thermal_rate=2.5e-3f, float deposition_rate=5e-3f, float suspension_rate=2.5e-4f, float exit_slope=0.01f)
Multiscale driver for hydraulic_mcdonald: erodes on a halving resolution ladder derived from z....
Definition hydraulic_mcdonald_gpu.cpp:222
hmap::gpu::thermal_auto_bedrock
void thermal_auto_bedrock(Array &z, const Array &talus, int iterations=10, Array *p_deposition_map=nullptr)
Apply thermal weathering erosion with automatic determination of the bedrock.
Definition thermal_gpu.cpp:105
hmap::gpu::mudslide
void mudslide(Array &z, const Array &landslide_mask, float depth, int iterations, float depth_map_exponent=0.5f, float viscosity_law_power=1.5f, Array *p_depth_end=nullptr, Array *p_depth_init=nullptr)
Simulate a mudslide (landslide-driven material redistribution) on a height field.
Definition mudslide.cpp:19
hmap::gpu::thermal_rib
void thermal_rib(Array &z, int iterations)
Apply thermal erosion using a 'rib' algorithm (taken from Geomorph).
Definition thermal_gpu.cpp:266
hmap::gpu::conv_erosion
void conv_erosion(Array &z, std::uint32_t seed, int iterations=20, int particle_count=1000, int ir_min=8, int ir_max=64, float size_distrib_exp=1.f, float erosion_strength=0.02f, float randomness=0.01f, float exit_forcing=0.05f, int gradient_ir=16, float gradient_exp=0.5f, float gradient_strength_min=0.f)
Performs iterative particle-based convolution erosion on a heightmap.
Definition conv_erosion.cpp:167
hmap::gpu::hydraulic_particle
void hydraulic_particle(Array &z, int nparticles, std::uint32_t seed, const Array *p_bedrock=nullptr, const Array *p_moisture_map=nullptr, const Array *p_elevation_shift=nullptr, Array *p_erosion_map=nullptr, Array *p_deposition_map=nullptr, float c_capacity=10.f, float c_erosion=0.05f, float c_deposition=0.05f, float c_inertia=0.01f, float c_gravity=1.f, float drag_rate=0.001f, float evap_rate=0.001f, float talus_slope=2.f, float collapse_rate=0.1f, int iterations=1)
Simulates hydraulic erosion on a heightmap using particle-based flow.
Definition hydraulic_particle.cpp:21
hmap::gpu::thermal_schott
void thermal_schott(Array &z, const Array &talus, int iterations=10, float intensity=0.2f, Array *p_deposition_map=nullptr)
Applies the thermal erosion process with a uniform slope threshold.
Definition thermal_gpu.cpp:334
hmap::gpu::watershed_ridge
Array watershed_ridge(const Array &z, float amplitude=0.2f, float width=32.f, float edt_exponent=0.5f, int prefilter_ir=0, FlowDirectionMethod fd_method=FlowDirectionMethod::FDM_D8, const Array *p_noise_x=nullptr, const Array *p_noise_y=nullptr, const Array *p_scaling=nullptr)
Carves watershed ridges using basin-wise distance transforms.
Definition watershed_ridge.cpp:22
hmap::gpu::hydraulic_vpipes
void hydraulic_vpipes(Array &z, float water_height=1e-2f, bool maintain_water_volume=true, float evap_rate=0.1f, int iterations=50, float dt=0.5f, float k_capacity=0.5f, float k_erode=0.001f, float k_depose=0.01f, float k_discharge_exp=1.f, float downcutting_max_depth_ratio=10.f, bool flux_diffusion=true, float flux_diffusion_strength=0.01f, Array *p_rain_map=nullptr, Array *p_water_depth=nullptr, Array *p_sediment=nullptr, Array *p_vel_u=nullptr, Array *p_vel_v=nullptr)
See hmap::hydraulic_vpipes.
Definition hydraulic_vpipes_gpu.cpp:16
hmap::gpu::thermal_flatten
void thermal_flatten(Array &z, const Array &talus, int iterations, float sigma_inf=0.5f, float sigma_sup=0.f)
Apply iterative thermal flattening erosion on a heightmap.
Definition thermal_gpu.cpp:165
hmap::gpu::strata_cells_fbm
void strata_cells_fbm(Array &z, glm::vec2 kw, float amp, std::uint32_t seed, float gamma=0.5f, float gamma_lateral=0.4f, float angle=0.f, bool enable_default_noise=true, float default_noise_amp=0.05f, bool absolute_displacement=true, float occurence_probability=0.5f, int octaves=8, float persistence=0.4f, float lacunarity=2.2f, const Array *p_noise_x=nullptr, const Array *p_noise_y=nullptr, glm::vec4 bbox={0.f, 1.f, 0.f, 1.f})
Applies multi-octave (fBm) stratified cell displacement.
Definition strata.cpp:170
hmap::gpu::hydraulic_particle_multiscale
void hydraulic_particle_multiscale(Array &z, std::uint32_t seed, const std::vector< int > &steps_per_level={4, 2, 1}, const Array *p_bedrock=nullptr, const Array *p_moisture_map=nullptr, const Array *p_elevation_shift=nullptr, Array *p_erosion_map=nullptr, Array *p_deposition_map=nullptr, float particles_ratio=0.5f, float c_capacity=10.f, float c_erosion=0.05f, float c_deposition=0.05f, float c_inertia=0.01f, float c_gravity=1.f, float drag_rate=0.001f, float evap_rate=0.001f, float talus_slope=2.f, float collapse_rate=0.1f, float mix=1.f)
Multiscale particle-based hydraulic erosion cascade.
Definition hydraulic_particle.cpp:162
hmap::gpu::hydraulic_stream_log
void hydraulic_stream_log(Array &z, float c_erosion, float talus_ref, int deposition_ir=32, float deposition_scale_ratio=1.f, float gradient_power=0.8f, float gradient_scaling_ratio=1.f, int gradient_prefilter_ir=16, float saturation_ratio=1.f, Array *p_bedrock=nullptr, Array *p_moisture_map=nullptr, Array *p_erosion_map=nullptr, Array *p_deposition_map=nullptr, Array *p_flow_map=nullptr)
See hmap::hydraulic_stream_log.
Definition hydraulic_stream_gpu.cpp:18
hmap::gpu::hydraulic_procedural_fbm
void hydraulic_procedural_fbm(Array &z, float kp_global, float c_erosion, std::uint32_t seed, ErosionProfile erosion_profile=ErosionProfile::EP_TRIANGLE_GRENIER, int octaves=3, float persistence=0.5f, float lacunarity=2.f, float erosion_profile_parameter=0.01f, float angle_shift=0.f, float phase_smoothing=0.1f, float talus_ref=0.001f, float gradient_scaling_ratio=1.f, float gradient_power=0.8f, bool exclude_ridges=true, bool apply_deposition=false, float deposition_strength=1.f, bool enable_default_noise=true, float noise_amp=0.01f, const Array *p_kp_multiplier=nullptr, const Array *p_angle_shift=nullptr, const Array *p_noise_x=nullptr, const Array *p_noise_y=nullptr, Array *p_ridge_mask=nullptr, glm::vec4 bbox={0.f, 1.f, 0.f, 1.f})
Multi-octave (fBm) variant of hydraulic_procedural().
Definition hydraulic_procedural.cpp:201
hmap::gpu::strata_terrace
void strata_terrace(Array &z, float gamma, std::uint32_t seed, float kz=4.f, bool linear_gamma=true, float gamma_noise_ratio=0.5f, float slope=0.f, float angle=0.f, const Array *p_noise=nullptr, glm::vec4 bbox={0.f, 1.f, 0.f, 1.f})
Applies a terrace (stratification) filter to a heightmap.
Definition strata.cpp:299
hmap::gpu::deposition_fill_holes
void deposition_fill_holes(Array &z, int deposition_ir, float deposition_strength, int iterations=1)
Fill holes using Gaussian-based deposition.
Definition deposition_fill_holes.cpp:15
hmap::gpu::strata_cells
void strata_cells(Array &z, glm::vec2 kw, float amp, std::uint32_t seed, float gamma=0.5f, float gamma_lateral=0.4f, float angle=0.f, float noise_amp=0.5f, bool absolute_displacement=true, float occurence_probability=0.5f, const Array *p_noise_x=nullptr, const Array *p_noise_y=nullptr, glm::vec4 bbox={0.f, 1.f, 0.f, 1.f})
Applies procedural stratified cell displacement to a heightmap.
Definition strata.cpp:83
hmap::gpu::hydraulic_mcdonald
void hydraulic_mcdonald(Array &z, int steps, std::uint32_t seed, Array *p_sediment_map=nullptr, Array *p_discharge_map=nullptr, float world_extent_km=40.f, float z_scale_km=4.f, int samples=8192, int maxage=512, float lrate=0.2f, float time_step=10.f, float rainfall=1.f, float evap_rate=1e-4f, float gravity=9.81f, float viscosity=0.025f, float bed_shear=0.01f, float crit_slope=0.57f, float settle_rate=0.1f, float thermal_rate=2.5e-3f, float deposition_rate=5e-3f, float suspension_rate=2.5e-4f, float exit_slope=0.01f)
Particle-based hydraulic erosion with flow-field coupling (McDonald's model): persistent per-cell dis...
Definition hydraulic_mcdonald_gpu.cpp:162
hmap::gpu::hydraulic_schott
void hydraulic_schott(Array &z, int iterations, const Array &talus, float c_erosion=1.f, float c_thermal=0.1f, float c_deposition=0.2f, float flow_acc_exponent=0.8f, float flow_acc_exponent_depo=0.8f, float flow_routing_exponent=1.3f, float thermal_weight=1.5f, float deposition_weight=2.5f, Array *p_flow=nullptr)
Simulates hydraulic erosion and deposition on a heightmap using the Schott method.
Definition hydraulic_schott_gpu.cpp:15
hmap::gpu::hydraulic_procedural
void hydraulic_procedural(Array &z, float kp_global, float c_erosion, std::uint32_t seed, ErosionProfile erosion_profile=ErosionProfile::EP_TRIANGLE_GRENIER, float erosion_profile_parameter=0.01f, float angle_shift=0.f, float phase_smoothing=0.1f, float talus_ref=0.001f, float gradient_scaling_ratio=1.f, float gradient_power=0.8f, bool exclude_ridges=true, bool apply_deposition=false, float deposition_strength=1.f, bool enable_default_noise=true, float noise_amp=0.01f, const Array *p_kp_multiplier=nullptr, const Array *p_angle_shift=nullptr, const Array *p_noise_x=nullptr, const Array *p_noise_y=nullptr, Array *p_ridge_mask=nullptr, glm::vec4 bbox={0.f, 1.f, 0.f, 1.f})
Apply phase-guided hydraulic procedural erosion to a heightmap.
Definition hydraulic_procedural.cpp:26
hmap::gpu::strata_plates
void strata_plates(Array &z, const Array &talus, int direction_offset=0, int direction_count=3, bool random_directions=false, std::uint32_t seed=0, float vmin=-FLT_MAX, float skew=0.f, float mix_ratio=0.9f, const Array *p_mask=nullptr, const Array *p_dx=nullptr, const Array *p_dy=nullptr)
Apply stratified talus projection along multiple directions.
Definition strata_plates.cpp:20
hmap::gpu::hydraulic_schott_erosion
void hydraulic_schott_erosion(Array &z, int iterations, float c_erosion=1.f, float flow_acc_exponent=0.8f, float flow_routing_exponent=1.3f, const Array *p_moisture_map=nullptr, Array *p_flow=nullptr)
See hmap::hydraulic_schott.
Definition hydraulic_schott_gpu.cpp:135
hmap::gpu::thermal_scree
void thermal_scree(Array &z, const Array &talus, const Array &zmax, int iterations=10, Array *p_deposition_map=nullptr)
Performs thermal scree erosion on a heightmap.
Definition thermal_gpu.cpp:378
hmap::gpu::strata
void strata(Array &z, float angle, float slope, float gamma, std::uint32_t seed, bool linear_gamma=true, float kz=1.f, int octaves=4, float lacunarity=2.f, float gamma_noise_ratio=0.5f, float noise_amp=0.4f, const glm::vec2 &noise_kw={4.f, 4.f}, bool enable_ridge_noise=true, const glm::vec2 &ridge_noise_kw={4.f, 1.2f}, float ridge_angle_shift=45.f, float ridge_noise_amp=0.5f, float ridge_clamp_vmin=0.f, float ridge_remap_vmin=0.f, bool apply_elevation_mask=true, bool apply_ridge_mask=true, float mask_gamma=0.4f, const Array *p_mask=nullptr, const glm::vec4 &bbox={0.f, 1.f, 0.f, 1.f})
Applies stratification to a heightfield using directional noise and multiscale gamma transformations.
Definition strata.cpp:20
hmap::gpu::rifts
void rifts(Array &z, const glm::vec2 &kw, float angle, float amplitude, std::uint32_t seed, float elevation_noise_shift=0.f, float k_smooth_bottom=0.05f, float k_smooth_top=0.05f, float radial_spread_amp=0.2f, float elevation_noise_amp=0.1f, float clamp_vmin=0.f, float remap_vmin=0.f, bool apply_mask=true, bool reverse_mask=false, float mask_gamma=1.f, const Array *p_noise_x=nullptr, const Array *p_noise_y=nullptr, const Array *p_mask=nullptr, const glm::vec2 &center={0.5f, 0.5f}, const glm::vec4 &bbox={0.f, 1.f, 0.f, 1.f})
Applies a "rift" deformation effect to a heightmap array.
Definition rifts_gpu.cpp:16
hmap::gpu::thermal_inflate
void thermal_inflate(Array &z, const Array &talus, int iterations=10)
Apply thermal weathering erosion to give a scree like effect.
Definition thermal_gpu.cpp:205
hmap::gpu::valley_fill
void valley_fill(Array &z, const Array &talus, int iterations=100, float gamma=2.f, float ratio=0.8f, float zmin=0.f, float zmax=0.f, float elevation_max_ratio=1.f, bool preserve_elevation_range=true, const Array *p_noise=nullptr, Array *p_deposition_map=nullptr)
Fill valleys using thermal scree deposition and height-based blending.
Definition valley_fill.cpp:14
hmap::gpu::sediment_layer
void sediment_layer(Array &z, const Array &talus_layer, const Array &talus_upper_limit, int iterations, bool apply_post_filter=true, Array *p_deposition_map=nullptr)
Applies a talus-based sediment deposition layer.
Definition deposition.cpp:76
hmap
Definition algebra.hpp:23
hmap::slope
Array slope(glm::ivec2 shape, float angle, float slope, const Array *p_ctrl_param=nullptr, const Array *p_noise_x=nullptr, const Array *p_noise_y=nullptr, glm::vec2 center={0.5f, 0.5f}, glm::vec4 bbox={0.f, 1.f, 0.f, 1.f})
Return an array corresponding to a slope with a given overall.
Definition primitives.cpp:333
hmap::FlowDirectionMethod
FlowDirectionMethod
Enumeration of available algorithms for computing flow directions.
Definition drainage_basin_cell_based.hpp:26
hmap::FDM_D8
@ FDM_D8
Standard D8 flow direction algorithm.
Definition drainage_basin_cell_based.hpp:27
hmap::coastal_erosion_diffusion
void coastal_erosion_diffusion(Array &z, Array &water_depth, float additional_depth, int iterations=10, const Array *p_mask=nullptr, Array *p_water_mask=nullptr)
Simulates terrain diffusion due to coastal erosion.
Definition coastal_erosion.cpp:19
hmap::hydraulic_blur
void hydraulic_blur(Array &z, float radius, float vmax, float k_smoothing=0.1f)
Apply cell-based hydraulic erosion using a nonlinear diffusion model.
Definition hydraulic_blur.cpp:15
hmap::ErosionProfile
ErosionProfile
Procedural erosion angular profile type.
Definition profiles.hpp:20
hmap::EP_TRIANGLE_GRENIER
@ EP_TRIANGLE_GRENIER
Definition profiles.hpp:29
hmap::hydraulic_stream_log
void hydraulic_stream_log(Array &z, float c_erosion, float talus_ref, int deposition_ir=32, float deposition_scale_ratio=1.f, float gradient_power=0.8f, float gradient_scaling_ratio=1.f, int gradient_prefilter_ir=16, float saturation_ratio=1.f, Array *p_bedrock=nullptr, Array *p_moisture_map=nullptr, Array *p_erosion_map=nullptr, Array *p_deposition_map=nullptr, Array *p_flow_map=nullptr)
Apply hydraulic erosion based on a flow accumulation map, alternative formulation.
Definition hydraulic_stream.cpp:111
hmap::coastal_erosion_profile
void coastal_erosion_profile(Array &z, Array &water_depth, float shore_ground_extent, float shore_water_extent, float slope_shore=0.5f, float slope_shore_water=0.5f, float scarp_extent_ratio=0.5f, bool apply_post_filter=true, int post_filter_iterations=3, bool solid_shore_mask=true, float scarp_mask_transition_ratio=0.2f, const Array *p_noise=nullptr, Array *p_shore_mask=nullptr, Array *p_scarp_mask=nullptr)
Applies a coastal erosion profile to a terrain elevation field.
Definition coastal_erosion.cpp:57
hmap::hydraulic_musgrave
void hydraulic_musgrave(Array &z, Array &moisture_map, int iterations=100, float c_capacity=1.f, float c_erosion=0.1f, float c_deposition=0.1f, float water_level=0.01f, float evap_rate=0.01f)
Apply cell-based hydraulic erosion/deposition of Musgrave et al. (1989).
Definition hydraulic_musgrave.cpp:26
hmap::InterpolationMethod2D
InterpolationMethod2D
Enumeration of 2D interpolation methods.
Definition interpolate2d.hpp:47
hmap::ITP2D_DELAUNAY_GRADIENT
@ ITP2D_DELAUNAY_GRADIENT
Delaunay triangulation + linear gradient.
Definition interpolate2d.hpp:53
hmap::hydraulic_stream_upscale_amplification
void hydraulic_stream_upscale_amplification(Array &z, float c_erosion, float talus_ref, int upscaling_levels=1, float persistence=1.f, int ir=1, float clipping_ratio=10.f)
Applies hydraulic erosion with upscaling amplification.
Definition hydraulic_stream_upscale_amplification.cpp:16
hmap::hydraulic_diffusion
void hydraulic_diffusion(Array &z, float c_diffusion, float talus, int iterations)
Apply cell-based hydraulic erosion using a nonlinear diffusion model.
Definition hydraulic_diffusion.cpp:13
hmap::depression_filling
void depression_filling(Array &z, int iterations=1000, float epsilon=1e-4f)
Fill the depressions of the heightmap using the Planchon-Darboux algorithm.
Definition depression_filling.cpp:15
hmap::angle
float angle(const Point &p1, const Point &p2)
Computes the angle between two points relative to the x-axis.
Definition points.cpp:52
hmap::hydraulic_algebric
void hydraulic_algebric(Array &z, Array *p_mask, float talus_ref, int ir, Array *p_bedrock=nullptr, Array *p_erosion_map=nullptr, Array *p_deposition_map=nullptr, float c_erosion=0.05f, float c_deposition=0.05f, int iterations=1)
Apply an algerbic formula based on the local gradient to perform erosion/deposition.
Definition hydraulic_algebric.cpp:74
hmap::hydraulic_stream
void hydraulic_stream(Array &z, float c_erosion, float talus_ref, Array *p_bedrock=nullptr, Array *p_moisture_map=nullptr, Array *p_erosion_map=nullptr, int ir=1, float clipping_ratio=10.f)
Apply hydraulic erosion based on a flow accumulation map.
Definition hydraulic_stream.cpp:22
hmap::mix
Texture mix(const Texture &tex1, const Texture &tex2, MixMethod method=MM_SQRT_AVG)
Mix two textures into an output texture.
Definition colorize.cpp:550
hmap::hydraulic_saleve
void hydraulic_saleve(TerrainTriMesh &mesh, const std::vector< float > &erodibility, const std::vector< float > &max_slope, float m_exp=0.8f, float uplift_rate=1.f, float tolerance=1e-3f, int max_iterations=200, float noise_strength=0.f, std::uint32_t seed=0, bool enable_post_slope_limiter=false, float post_slope_limit=0.f, bool enable_post_smoothing=false)
Perform hydraulic erosion on a triangulated terrain mesh.
Definition hydraulic_saleve.cpp:24
hmap::depression_filling_priority_flood
void depression_filling_priority_flood(Array &z, bool apply_post_filter=false)
Definition depression_filling_priority_flood.cpp:18
hmap::hydraulic_benes
void hydraulic_benes(Array &z, Array *p_mask, int iterations=50, Array *p_bedrock=nullptr, Array *p_moisture_map=nullptr, Array *p_erosion_map=nullptr, Array *p_deposition_map=nullptr, float c_capacity=40.f, float c_erosion=0.2f, float c_deposition=0.8f, float water_level=0.005f, float evap_rate=0.01f, float rain_rate=0.5f)
Apply cell-based hydraulic erosion/deposition based on Benes et al. procedure.
Definition hydraulic_benes.cpp:212
hmap::generate_bedrock
Array generate_bedrock(const Array &z, float elevation_strength, float slope_strength, float slope_limit, float zmin=0.f, float zmax=-1.f)
Generates a modified bedrock heightmap from an input elevation array.
Definition generate_bedrock.cpp:12
hmap::erosion_maps
void erosion_maps(Array &z_before, Array &z_after, Array &erosion_map, Array &deposition_map, float tolerance=0.f)
Definition erosion_maps.cpp:12
terrain_tri_mesh.hpp