86#define DT_DEFAULT 0.1f
89#define PHI_MAX 9999.0f
102static Mutex object_update_lock;
104# define ADD_IF_LOWER_POS(a, b) min_ff((a) + (b), max_ff((a), (b)))
105# define ADD_IF_LOWER_NEG(a, b) max_ff((a) + (b), min_ff((a), (b)))
106# define ADD_IF_LOWER(a, b) (((b) > 0) ? ADD_IF_LOWER_POS((a), (b)) : ADD_IF_LOWER_NEG((a), (b)))
110 if (free_old && fds->fluid) {
113 if (!std::min({res[0], res[1], res[2]})) {
114 fds->fluid =
nullptr;
119 fds->res_noise[0] = res[0] * fds->noise_scale;
120 fds->res_noise[1] = res[1] * fds->noise_scale;
121 fds->res_noise[2] = res[2] * fds->noise_scale;
124 return (fds->fluid !=
nullptr);
136 MANTA *fluid_old = fds->fluid;
137 const int block_size = fds->noise_scale;
138 int new_shift[3] = {0};
144 int o_total_cells = o_res[0] * o_res[1] * o_res[2];
145 int n_total_cells = n_res[0] * n_res[1] * n_res[2];
148 if (o_total_cells > 1 && n_total_cells > 1) {
205 for (
int z = o_min[2];
z < o_max[2];
z++) {
206 for (
int y = o_min[1];
y < o_max[1];
y++) {
207 for (
int x = o_min[0];
x < o_max[0];
x++) {
209 int xo =
x - o_min[0];
210 int yo =
y - o_min[1];
211 int zo =
z - o_min[2];
214 int xn =
x - n_min[0] - new_shift[0];
215 int yn =
y - n_min[1] - new_shift[1];
216 int zn =
z - n_min[2] - new_shift[2];
220 if (xn < 0 || xn >= n_res[0] || yn < 0 || yn >= n_res[1] || zn < 0 || zn >= n_res[2]) {
231 int bwidth = fds->boundary_width;
234 if (xo < bwidth || yo < bwidth || zo < bwidth || xo >= o_res[0] - bwidth ||
235 yo >= o_res[1] - bwidth || zo >= o_res[2] - bwidth)
240 if (xn < bwidth || yn < bwidth || zn < bwidth || xn >= n_res[0] - bwidth ||
241 yn >= n_res[1] - bwidth || zn >= n_res[2] - bwidth)
251 int xx_o = xo * block_size;
252 int yy_o = yo * block_size;
253 int zz_o = zo * block_size;
255 int xx_n = xn * block_size;
256 int yy_n = yn * block_size;
257 int zz_n = zn * block_size;
260 n_wt_tcu[index_new] = o_wt_tcu[index_old];
261 n_wt_tcv[index_new] = o_wt_tcv[index_old];
262 n_wt_tcw[index_new] = o_wt_tcw[index_old];
264 n_wt_tcu2[index_new] = o_wt_tcu2[index_old];
265 n_wt_tcv2[index_new] = o_wt_tcv2[index_old];
266 n_wt_tcw2[index_new] = o_wt_tcw2[index_old];
268 for (i = 0; i < block_size; i++) {
269 for (j = 0; j < block_size; j++) {
270 for (k = 0; k < block_size; k++) {
272 xx_o + i, wt_res_old[0], yy_o + j, wt_res_old[1], zz_o + k);
274 xx_n + i, fds->res_noise[0], yy_n + j, fds->res_noise[1], zz_n + k);
276 n_wt_dens[big_index_new] = o_wt_dens[big_index_old];
277 if (n_wt_flame && o_wt_flame) {
278 n_wt_flame[big_index_new] = o_wt_flame[big_index_old];
279 n_wt_fuel[big_index_new] = o_wt_fuel[big_index_old];
280 n_wt_react[big_index_new] = o_wt_react[big_index_old];
282 if (n_wt_r && o_wt_r) {
283 n_wt_r[big_index_new] = o_wt_r[big_index_old];
284 n_wt_g[big_index_new] = o_wt_g[big_index_old];
285 n_wt_b[big_index_new] = o_wt_b[big_index_old];
292 n_dens[index_new] = o_dens[index_old];
294 if (n_heat && o_heat) {
295 n_heat[index_new] = o_heat[index_old];
298 if (n_fuel && o_fuel) {
299 n_flame[index_new] = o_flame[index_old];
300 n_fuel[index_new] = o_fuel[index_old];
301 n_react[index_new] = o_react[index_old];
305 n_r[index_new] = o_r[index_old];
306 n_g[index_new] = o_g[index_old];
307 n_b[index_new] = o_b[index_old];
309 n_vx[index_new] = o_vx[index_old];
310 n_vy[index_new] = o_vy[index_old];
311 n_vz[index_new] = o_vz[index_old];
350 fds->cache_frame_pause_data = 0;
359 fds->cache_frame_pause_noise = 0;
368 fds->cache_frame_pause_mesh = 0;
378 fds->cache_frame_pause_particles = 0;
387 fds->cache_frame_pause_guide = 0;
389 fds->cache_flag = flags;
397 pos[0] *= 1.0f / fds->cell_size[0];
398 pos[1] *= 1.0f / fds->cell_size[1];
399 pos[2] *= 1.0f / fds->cell_size[2];
406 bool init_resolution)
419 for (i = 0; i <
mesh->verts_num; i++) {
426 fds->dx = 1.0f / res;
430 if (init_resolution) {
435 for (i = 0; i < 3; i++) {
436 const float scale = ob->scale[i];
438 if (!isfinite(size[i])) {
455 if (size[0] >= std::max(size[1], size[2])) {
457 fds->scale =
size[0] /
fabsf(ob->scale[0]);
458 fds->base_res[0] = res;
459 fds->base_res[1] =
max_ii(
int(size[1] *
scale + 0.5f), 4);
460 fds->base_res[2] =
max_ii(
int(size[2] *
scale + 0.5f), 4);
462 else if (size[1] >= std::max(size[0], size[2])) {
464 fds->scale =
size[1] /
fabsf(ob->scale[1]);
465 fds->base_res[0] =
max_ii(
int(size[0] *
scale + 0.5f), 4);
466 fds->base_res[1] = res;
467 fds->base_res[2] =
max_ii(
int(size[2] *
scale + 0.5f), 4);
471 fds->scale =
size[2] /
fabsf(ob->scale[2]);
472 fds->base_res[0] =
max_ii(
int(size[0] *
scale + 0.5f), 4);
473 fds->base_res[1] =
max_ii(
int(size[1] *
scale + 0.5f), 4);
474 fds->base_res[2] = res;
478 fds->cell_size[0] /=
float(fds->base_res[0]);
479 fds->cell_size[1] /=
float(fds->base_res[1]);
480 fds->cell_size[2] /=
float(fds->base_res[2]);
486 copy_v3_v3(fds->gravity_final, scene->physics_settings.gravity);
491 mul_v3_fl(fds->gravity_final, fds->effector_weights->global_gravity);
494static bool fluid_modifier_init(
503 manta_set_domain_from_mesh(fds, ob,
mesh,
true);
505 update_final_gravity(fds, scene);
511 mul_m4_v3(ob->object_to_world().ptr(), fds->prev_loc);
512 copy_m4_m4(fds->obmat, ob->object_to_world().ptr());
518 res[0] = res[1] = res[2] = 1;
524 fds->total_cells = fds->res[0] * fds->res[1] * fds->res[2];
525 fds->res_min[0] = fds->res_min[1] = fds->res_min[2] = 0;
529 fds->frame_length =
DT_DEFAULT * (25.0f / scene->frames_per_second()) * fds->time_scale;
531 fds->dt = fds->frame_length;
532 fds->time_per_frame = 0;
534 fmd->time = scene_framenr;
543 fmd->time = scene_framenr;
547 if (!fmd->effector) {
550 fmd->time = scene_framenr;
557static void manta_smoke_calc_transparency(
const Main &bmain,
561static float calc_voxel_transp(
562 float *
result,
const float *input,
int res[3],
int *pixel,
float *t_ray,
float correct);
563static void update_distances(
int index,
566 const float ray_start[3],
567 float surface_thickness,
568 bool use_plane_init);
570static int get_light(
const Main &bmain,
Scene *scene,
ViewLayer *view_layer,
float *light)
577 if (base_tmp.object->type ==
OB_LAMP) {
578 Light *la = id_cast<Light *>(base_tmp.object->data);
581 copy_v3_v3(light, base_tmp.object->object_to_world().location());
585 copy_v3_v3(light, base_tmp.object->object_to_world().location());
597 const float *min_vel,
598 const float *max_vel,
602 for (
int i = 0; i < 3; i++) {
609 if (min_vel && min_vel[i] < 0.0f) {
610 min[i] += int(
floor(min_vel[i] * dt));
612 if (max_vel && max_vel[i] > 0.0f) {
613 max[i] += int(
ceil(max_vel[i] * dt));
617 CLAMP(
min[i], -adapt, fds->base_res[i] + adapt);
618 CLAMP(
max[i], -adapt, fds->base_res[i] + adapt);
622static bool is_static_object(
Object *ob)
627 for (; md; md = md->next) {
656struct FluidObjectBB {
661 int min[3],
max[3], res[3];
662 int hmin[3], hmax[3], hres[3];
663 int total_cells, valid;
666static void bb_boundInsert(FluidObjectBB *bb,
const float point[3])
671 bb->min[i] = int(
floor(point[i]));
672 bb->max[i] = int(
ceil(point[i]));
678 if (point[i] < bb->min[i]) {
679 bb->min[i] = int(
floor(point[i]));
681 if (point[i] > bb->max[i]) {
682 bb->max[i] = int(
ceil(point[i]));
688static void bb_allocateData(FluidObjectBB *bb,
bool use_velocity,
bool use_influence)
692 for (i = 0; i < 3; i++) {
693 res[i] = bb->max[i] - bb->min[i];
698 bb->total_cells = res[0] * res[1] * res[2];
710 "fluid_bb_distances");
711 std::fill_n(bb->distances, bb->total_cells,
FLT_MAX);
716static void bb_freeData(FluidObjectBB *bb)
719 MEM_delete(bb->numobjs);
722 MEM_delete(bb->influence);
725 MEM_delete(bb->velocity);
728 MEM_delete(bb->distances);
732static void bb_combineMaps(FluidObjectBB *
output,
741 memcpy(&bb1,
output,
sizeof(FluidObjectBB));
742 memset(
output, 0,
sizeof(FluidObjectBB));
744 for (i = 0; i < 3; i++) {
746 output->min[i] = std::min(bb1.min[i], bb2->min[i]);
747 output->max[i] = std::max(bb1.max[i], bb2->max[i]);
750 output->min[i] = bb2->min[i];
751 output->max[i] = bb2->max[i];
755 bb_allocateData(
output, (bb1.velocity || bb2->velocity), (bb1.influence || bb2->influence));
768 if (
x >= bb1.min[0] &&
x < bb1.max[0] &&
y >= bb1.min[1] &&
y < bb1.max[1] &&
769 z >= bb1.min[2] &&
z < bb1.max[2])
772 x - bb1.min[0], bb1.res[0],
y - bb1.min[1], bb1.res[1],
z - bb1.min[2]);
775 output->numobjs[index_out] = bb1.numobjs[index_in];
776 if (
output->influence && bb1.influence) {
777 output->influence[index_out] = bb1.influence[index_in];
779 output->distances[index_out] = bb1.distances[index_in];
780 if (
output->velocity && bb1.velocity) {
790 x - bb2->min[0], bb2->res[0],
y - bb2->min[1], bb2->res[1],
z - bb2->min[2]);
793 output->numobjs[index_out] = std::max(bb2->numobjs[index_in],
794 output->numobjs[index_out]);
795 if (
output->influence && bb2->influence) {
797 output->influence[index_out] += bb2->influence[index_in] * sample_size;
800 output->influence[index_out] = std::max(bb2->influence[index_in],
801 output->influence[index_out]);
804 output->distances[index_out] = std::min(bb2->distances[index_in],
805 output->distances[index_out]);
806 if (
output->velocity && bb2->velocity) {
808 output->velocity[index_out * 3] = ADD_IF_LOWER(
output->velocity[index_out * 3],
809 bb2->velocity[index_in * 3]);
810 output->velocity[index_out * 3 + 1] = ADD_IF_LOWER(
output->velocity[index_out * 3 + 1],
811 bb2->velocity[index_in * 3 + 1]);
812 output->velocity[index_out * 3 + 2] = ADD_IF_LOWER(
output->velocity[index_out * 3 + 2],
813 bb2->velocity[index_in * 3 + 2]);
832 float src_distance_value,
834 float src_numobjs_value,
836 float const src_vel_value[3],
843 dest_phi_in[
index] = std::min(src_distance_value, dest_phi_in[
index]);
847 if (dest_numobjs && src_numobjs_value > 0) {
848 dest_numobjs[
index] += 1;
852 if (dest_vel_x && src_numobjs_value > 0) {
853 dest_vel_x[
index] += src_vel_value[0];
854 dest_vel_y[
index] += src_vel_value[1];
855 dest_vel_z[
index] += src_vel_value[2];
861 const int *corner_verts,
862 const int3 *corner_tris,
866 const float ray_start[3],
867 const float *vert_vel,
873 const float surface_distance = 1.732;
876 const std::optional<bke::bvh::ClosestPointResult> nearest = tree.closest_point(ray_start,
878 if (has_velocity && nearest) {
880 int v1,
v2, v3, tri_i = nearest->index;
883 v1 = corner_verts[corner_tris[tri_i][0]];
884 v2 = corner_verts[corner_tris[tri_i][1]];
885 v3 = corner_verts[corner_tris[tri_i][2]];
887 weights, vert_positions[v1], vert_positions[
v2], vert_positions[v3], nearest->position);
891 interp_v3_v3v3v3(hit_vel, &vert_vel[v1 * 3], &vert_vel[
v2 * 3], &vert_vel[v3 * 3], weights);
903 switch (fes->guide_mode) {
905 velocity_map[
index * 3] = (velocity_map[
index * 3] + hit_vel[0]) * 0.5f;
906 velocity_map[
index * 3 + 1] = (velocity_map[
index * 3 + 1] + hit_vel[1]) * 0.5f;
907 velocity_map[
index * 3 + 2] = (velocity_map[
index * 3 + 2] + hit_vel[2]) * 0.5f;
910 velocity_map[
index * 3] = hit_vel[0];
911 velocity_map[
index * 3 + 1] = hit_vel[1];
912 velocity_map[
index * 3 + 2] = hit_vel[2];
915 velocity_map[
index * 3] = std::min(abs_hit_vel[0], abs_vel[0]);
916 velocity_map[
index * 3 + 1] = std::min(abs_hit_vel[1], abs_vel[1]);
917 velocity_map[
index * 3 + 2] = std::min(abs_hit_vel[2], abs_vel[2]);
921 velocity_map[
index * 3] = std::max(abs_hit_vel[0], abs_vel[0]);
922 velocity_map[
index * 3 + 1] = std::max(abs_hit_vel[1], abs_vel[1]);
923 velocity_map[
index * 3 + 2] = std::max(abs_hit_vel[2], abs_vel[2]);
928 velocity_map[
index * 3] = hit_vel[0];
929 velocity_map[
index * 3 + 1] = hit_vel[1];
930 velocity_map[
index * 3 + 2] = hit_vel[2];
933 printf(
"setting effector object vel: [%f, %f, %f]\n", hit_vel[0], hit_vel[1], hit_vel[2]);
947struct ObstaclesFromDMData {
948 FluidEffectorSettings *fes;
950 Span<float3> vert_positions;
951 Span<int> corner_verts;
952 Span<int3> corner_tris;
954 const bke::bvh::Tree *tree;
962static void obstacles_from_mesh_task_cb(
void *__restrict userdata,
966 ObstaclesFromDMData *
data =
static_cast<ObstaclesFromDMData *
>(userdata);
967 FluidObjectBB *bb =
data->bb;
972 x - bb->min[0], bb->res[0],
y - bb->min[1], bb->res[1],
z - bb->min[2]);
976 update_distances(
index,
980 data->fes->surface_distance,
984 update_velocities(
data->fes,
985 data->vert_positions,
986 data->corner_verts.data(),
987 data->corner_tris.data(),
996 if (bb->distances[
index] < 0) {
997 bb->numobjs[
index]++;
1003static void obstacles_from_mesh(
Object *coll_ob,
1012 float *vert_vel =
nullptr;
1013 bool has_velocity =
false;
1018 int min[3],
max[3], res[3];
1022 numverts =
mesh->verts_num;
1028 if (fes->numverts != numverts || !fes->verts_old) {
1029 if (fes->verts_old) {
1030 MEM_delete(fes->verts_old);
1034 fes->numverts = numverts;
1037 has_velocity =
true;
1043 for (i = 0; i < numverts; i++) {
1047 mul_m4_v3(coll_ob->object_to_world().ptr(), positions[i]);
1048 manta_pos_to_cell(fds, positions[i]);
1053 sub_v3_v3v3(&vert_vel[i * 3], co, &fes->verts_old[i * 3]);
1059 bb_boundInsert(bb, positions[i]);
1062 mesh->tag_positions_changed();
1066 int bounds_margin = int(
ceil(5.196));
1067 clamp_bounds_in_domain(fds, bb->min, bb->max,
nullptr,
nullptr, bounds_margin, dt);
1068 bb_allocateData(bb,
true,
false);
1071 for (i = 0; i < 3; i++) {
1072 min[i] = bb->min[i];
1073 max[i] = bb->max[i];
1074 res[i] = bb->res[i];
1079 if (use_effector &&
mesh->faces_num > 0) {
1081 ObstaclesFromDMData
data{};
1083 data.vert_positions = positions;
1084 data.corner_verts = corner_verts;
1085 data.corner_tris = corner_tris;
1086 data.tree = &tree_data;
1088 data.has_velocity = has_velocity;
1089 data.vert_vel = vert_vel;
1096 settings.min_iter_per_thread = 2;
1101 MEM_delete(vert_vel);
1120 int coll_ob_array_len)
1128 active_fields &= ~prev_flags;
1131 for (coll_index = 0; coll_index < coll_ob_array_len; coll_index++) {
1132 Object *coll_ob = coll_ob_array[coll_index];
1158 fds->active_fields = active_fields;
1161static bool escape_effectorobject(
Object *flowobj,
1166 bool is_static = is_static_object(flowobj);
1168 bool is_resume = (fds->cache_frame_pause_data == frame);
1170 bool is_first_frame = (frame == fds->cache_frame_start);
1178 if (is_static && !is_first_frame && !is_resume) {
1184static void compute_obstaclesemission(
Scene *scene,
1185 FluidObjectBB *bb_maps,
1186 Depsgraph *depsgraph,
1193 float time_per_frame)
1195 bool is_first_frame = (frame == fds->cache_frame_start);
1198 for (
int effec_index = 0; effec_index < numeffecobjs; effec_index++) {
1199 Object *effecobj = effecobjs[effec_index];
1212 FluidObjectBB *bb = &bb_maps[effec_index];
1215 if (escape_effectorobject(effecobj, fds, fes, frame)) {
1221 if (is_first_frame) {
1226 float sample_size = 1.0f /
float(subframes + 1);
1227 float subframe_dt = dt * sample_size;
1230 for (
int subframe = 0; subframe <= subframes; subframe++) {
1233 FluidObjectBB bb_temp = {
nullptr};
1237 if ((subframe < subframes || time_per_frame + dt +
FLT_EPSILON < frame_length) &&
1240 scene->r.subframe = (time_per_frame + (subframe + 1.0f) * subframe_dt) / frame_length;
1241 scene->r.cfra = frame - 1;
1244 scene->r.subframe = 0.0f;
1245 scene->r.cfra = frame;
1248 CLAMP(scene->r.subframe, 0.0f, 1.0f);
1252 "effector: frame (is first: %d): %d // scene current frame: %d // scene current "
1273 obstacles_from_mesh(effecobj, fds, fes, &bb_temp, subframe_dt);
1276 obstacles_from_mesh(effecobj, fds, fes, bb, subframe_dt);
1283 bb_combineMaps(bb, &bb_temp, 0, 0.0f);
1284 bb_freeData(&bb_temp);
1291static void update_obstacles(Depsgraph *depsgraph,
1295 float time_per_frame,
1300 FluidObjectBB *bb_maps =
nullptr;
1301 Object **effecobjs =
nullptr;
1302 uint numeffecobjs = 0;
1303 bool is_resume = (fds->cache_frame_pause_data == frame);
1304 bool is_first_frame = (frame == fds->cache_frame_start);
1310 update_obstacleflags(fds, effecobjs, numeffecobjs);
1311 ensure_obstaclefields(fds);
1317 compute_obstaclesemission(scene,
1344 for (
z = 0;
z < fds->res[0] * fds->res[1] * fds->res[2];
z++) {
1352 if (phi_obsstatic_in && (is_first_frame || use_adaptivedomain)) {
1358 if (num_obstacles) {
1359 num_obstacles[
z] = 0;
1364 if (vel_x && vel_y && vel_z) {
1369 if (vel_x_guide && vel_y_guide && vel_z_guide) {
1370 vel_x_guide[
z] = 0.0f;
1371 vel_y_guide[
z] = 0.0f;
1372 vel_z_guide[
z] = 0.0f;
1377 for (
int effec_index = 0; effec_index < numeffecobjs; effec_index++) {
1378 Object *effecobj = effecobjs[effec_index];
1390 bool is_static = is_static_object(effecobj) && !use_adaptivedomain;
1401 FluidObjectBB *bb = &bb_maps[effec_index];
1402 float *velocity_map = bb->velocity;
1403 float *numobjs_map = bb->numobjs;
1404 float *distance_map = bb->distances;
1406 int gx, gy, gz, ex, ey, ez, dx, dy, dz;
1407 size_t e_index, d_index;
1410 for (gx = bb->min[0]; gx < bb->
max[0]; gx++) {
1411 for (gy = bb->min[1]; gy < bb->
max[1]; gy++) {
1412 for (gz = bb->min[2]; gz < bb->
max[2]; gz++) {
1414 ex = gx - bb->min[0];
1415 ey = gy - bb->min[1];
1416 ez = gz - bb->min[2];
1420 dx = gx - fds->res_min[0];
1421 dy = gy - fds->res_min[1];
1422 dz = gz - fds->res_min[2];
1425 if (dx < 0 || dy < 0 || dz < 0 || dx >= fds->res[0] || dy >= fds->res[1] ||
1432 float *levelset = ((is_first_frame || is_resume) && is_static) ? phi_obsstatic_in :
1434 apply_effector_fields(fes,
1436 distance_map[e_index],
1438 numobjs_map[e_index],
1440 &velocity_map[e_index * 3],
1446 apply_effector_fields(fes,
1448 distance_map[e_index],
1450 numobjs_map[e_index],
1452 &velocity_map[e_index * 3],
1466 MEM_delete(bb_maps);
1476struct EmitFromParticlesData {
1477 FluidFlowSettings *ffs;
1478 KDTree<float3> *tree;
1481 float *particle_vel;
1488static void emit_from_particles_task_cb(
void *__restrict userdata,
1492 EmitFromParticlesData *
data =
static_cast<EmitFromParticlesData *
>(userdata);
1494 FluidObjectBB *bb =
data->bb;
1499 x - bb->min[0], bb->res[0],
y - bb->min[1], bb->res[1],
z - bb->min[2]);
1504 const float range =
data->solid +
data->smooth;
1507 if (nearest.dist < range) {
1508 bb->influence[
index] = (nearest.dist <
data->solid) ?
1514 &bb->velocity[index * 3], &data->particle_vel[nearest.index * 3], ffs->vel_multi);
1521static void emit_from_particles(
Object *flow_ob,
1525 Depsgraph *depsgraph,
1534 float *particle_pos;
1535 float *particle_vel;
1536 int totpart = psys->totpart, totchild;
1538 int valid_particles = 0;
1539 int bounds_margin = 1;
1542 const float solid = ffs->particle_size * 0.5f;
1543 const float smooth = 0.5f;
1546 sim.depsgraph = depsgraph;
1559 totchild = psys->totchild * psys->part->disp / 100;
1563 "manta_flow_particles_pos");
1565 "manta_flow_particles_vel");
1574 for (p = 0; p < totpart + totchild; p++) {
1598 pos = &particle_pos[valid_particles * 3];
1600 manta_pos_to_cell(fds, pos);
1603 vel = &particle_vel[valid_particles * 3];
1612 bb_boundInsert(bb, pos);
1617 clamp_bounds_in_domain(fds, bb->min, bb->max,
nullptr,
nullptr, bounds_margin, dt);
1621 for (p = 0; p < valid_particles; p++) {
1628 cell[0] =
floor(particle_pos[p * 3]) - bb->min[0];
1629 cell[1] =
floor(particle_pos[p * 3 + 1]) - bb->min[1];
1630 cell[2] =
floor(particle_pos[p * 3 + 2]) - bb->min[2];
1632 for (i = 0; i < 3; i++) {
1633 if ((cell[i] > bb->res[i] - 1) || (cell[i] < 0)) {
1644 bb->influence[
index] = 1.0f;
1651 else if (valid_particles > 0) {
1652 int min[3],
max[3], res[3];
1655 for (
int i = 0; i < 3; i++) {
1656 min[i] = bb->min[i];
1657 max[i] = bb->max[i];
1658 res[i] = bb->res[i];
1663 EmitFromParticlesData
data{};
1667 data.particle_vel = particle_vel;
1676 settings.min_iter_per_thread = 2;
1686 MEM_delete(particle_pos);
1689 MEM_delete(particle_vel);
1698static void update_distances(
int index,
1699 float *distance_map,
1701 const float ray_start[3],
1702 float surface_thickness,
1703 bool use_plane_init)
1708 if (use_plane_init) {
1712 float surface_distance = 1.732;
1716 if (surface_thickness) {
1717 surface_distance = std::sqrt(surface_distance * surface_distance + surface_thickness);
1719 if (
const std::optional<bke::bvh::ClosestPointResult> nearest = tree.closest_point(
1720 ray_start, surface_distance))
1725 min_dist = (-1.0f) *
fabsf(min_dist);
1732 float ray_dirs[26][3] = {
1733 {1.0f, 0.0f, 0.0f}, {0.0f, 1.0f, 0.0f}, {0.0f, 0.0f, 1.0f}, {-1.0f, 0.0f, 0.0f},
1734 {0.0f, -1.0f, 0.0f}, {0.0f, 0.0f, -1.0f}, {1.0f, 1.0f, 0.0f}, {1.0f, -1.0f, 0.0f},
1735 {-1.0f, 1.0f, 0.0f}, {-1.0f, -1.0f, 0.0f}, {1.0f, 0.0f, 1.0f}, {1.0f, 0.0f, -1.0f},
1736 {-1.0f, 0.0f, 1.0f}, {-1.0f, 0.0f, -1.0f}, {0.0f, 1.0f, 1.0f}, {0.0f, 1.0f, -1.0f},
1737 {0.0f, -1.0f, 1.0f}, {0.0f, -1.0f, -1.0f}, {1.0f, 1.0f, 1.0f}, {1.0f, -1.0f, 1.0f},
1738 {-1.0f, 1.0f, 1.0f}, {-1.0f, -1.0f, 1.0f}, {1.0f, 1.0f, -1.0f}, {1.0f, -1.0f, -1.0f},
1739 {-1.0f, 1.0f, -1.0f}, {-1.0f, -1.0f, -1.0f}};
1744 int miss_count = 0, dir_count = 0;
1746 for (
int i = 0; i <
ARRAY_SIZE(ray_dirs); i++) {
1749 const std::optional<bke::bvh::RayHit> hit_tree = tree.ray_intersect(ray);
1763 min_dist = std::min(hit_tree->distance, min_dist);
1768 if (!(miss_count > 0 || dir_count ==
ARRAY_SIZE(ray_dirs))) {
1769 min_dist = (-1.0f) *
fabsf(min_dist);
1773 if (surface_thickness) {
1774 min_dist -= surface_thickness;
1779 distance_map[
index] = std::min(distance_map[
index], min_dist);
1788 const int *corner_verts,
1789 const int3 *corner_tris,
1791 float *influence_map,
1792 float *velocity_map,
1794 const int base_res[3],
1795 const float global_size[3],
1796 const float flow_center[3],
1798 const float ray_start[3],
1799 const float *vert_vel,
1807 float ray_dir[3] = {1.0f, 0.0f, 0.0f};
1809 float volume_factor = 0.0f;
1814 const float surface_distance = 1.732;
1816 bool is_gas_flow =
ELEM(
1822 float emission_strength = (is_gas_flow) ? 0.0f : 1.0f;
1825 if (is_gas_flow && ffs->volume_density) {
1827 if (
const std::optional<bke::bvh::RayHit> hit = tree.ray_intersect(ray)) {
1835 const std::optional<bke::bvh::RayHit> hit_opposite = tree.ray_intersect(opposite_ray);
1837 volume_factor = ffs->volume_density;
1844 if (
const std::optional<bke::bvh::ClosestPointResult> nearest = tree.closest_point(
1845 ray_start, surface_distance))
1848 int v1,
v2, v3, tri_i = nearest->index;
1849 float hit_normal[3];
1852 v1 = corner_verts[corner_tris[tri_i][0]];
1853 v2 = corner_verts[corner_tris[tri_i][1]];
1854 v3 = corner_verts[corner_tris[tri_i][2]];
1856 weights, vert_positions[v1], vert_positions[
v2], vert_positions[v3], nearest->position);
1861 if (ffs->surface_distance) {
1863 ffs->surface_distance;
1864 CLAMP(emission_strength, 0.0f, 1.0f);
1865 emission_strength =
pow(1.0f - emission_strength, 0.5f);
1868 emission_strength = 0.0f;
1872 if (defgrp_index != -1 && dvert) {
1876 emission_strength *= weight_mask;
1881 float tex_co[3] = {0};
1885 tex_co[0] = ((
x - flow_center[0]) / base_res[0]) / ffs->texture_size;
1886 tex_co[1] = ((
y - flow_center[1]) / base_res[1]) / ffs->texture_size;
1887 tex_co[2] = ((
z - flow_center[2]) / base_res[2] - ffs->texture_offset) /
1892 uv[0] = uv_map[corner_tris[tri_i][0]];
1893 uv[1] = uv_map[corner_tris[tri_i][1]];
1894 uv[2] = uv_map[corner_tris[tri_i][2]];
1899 tex_co[0] = tex_co[0] * 2.0f - 1.0f;
1900 tex_co[1] = tex_co[1] * 2.0f - 1.0f;
1901 tex_co[2] = ffs->texture_offset;
1904 emission_strength *= texres.tin;
1911 if (ffs->vel_normal) {
1914 hit_normal, vert_normals[v1], vert_normals[
v2], vert_normals[v3], weights);
1918 velocity_map[
index * 3] += hit_normal[0] * ffs->vel_normal;
1919 velocity_map[
index * 3 + 1] += hit_normal[1] * ffs->vel_normal;
1920 velocity_map[
index * 3 + 2] += hit_normal[2] * ffs->vel_normal;
1923 if (has_velocity && ffs->vel_multi) {
1926 hit_vel, &vert_vel[v1 * 3], &vert_vel[
v2 * 3], &vert_vel[v3 * 3], weights);
1927 velocity_map[
index * 3] += hit_vel[0] * ffs->vel_multi;
1928 velocity_map[
index * 3 + 1] += hit_vel[1] * ffs->vel_multi;
1929 velocity_map[
index * 3 + 2] += hit_vel[2] * ffs->vel_multi;
1932 printf(
"adding flow object vel: [%f, %f, %f]\n", hit_vel[0], hit_vel[1], hit_vel[2]);
1936 float convert_vel[3];
1938 float time_mult = 1.0 / (25.0f *
DT_DEFAULT);
1939 float size_mult = std::max({base_res[0], base_res[1], base_res[2]}) /
1940 std::max({global_size[0], global_size[1], global_size[2]});
1941 mul_v3_v3fl(convert_vel, ffs->vel_coord, size_mult * time_mult);
1943 velocity_map[
index * 3] += convert_vel[0];
1944 velocity_map[
index * 3 + 1] += convert_vel[1];
1945 velocity_map[
index * 3 + 2] += convert_vel[2];
1947 printf(
"initial vel: [%f, %f, %f]\n",
1948 velocity_map[
index * 3],
1949 velocity_map[
index * 3 + 1],
1950 velocity_map[
index * 3 + 2]);
1956 influence_map[
index] = std::max(volume_factor, emission_strength);
1959struct EmitFromDMData {
1960 FluidDomainSettings *fds;
1961 FluidFlowSettings *ffs;
1963 Span<float3> vert_positions;
1964 Span<float3> vert_normals;
1965 Span<int> corner_verts;
1966 Span<int3> corner_tris;
1967 Span<float2> uv_map;
1968 const MDeformVert *dvert;
1971 const bke::bvh::Tree *tree;
1980static void emit_from_mesh_task_cb(
void *__restrict userdata,
1984 EmitFromDMData *
data =
static_cast<EmitFromDMData *
>(userdata);
1985 FluidObjectBB *bb =
data->bb;
1990 x - bb->min[0], bb->res[0],
y - bb->min[1], bb->res[1],
z - bb->min[2]);
1996 sample_mesh(
data->ffs,
1997 data->vert_positions,
1999 data->corner_verts.data(),
2000 data->corner_tris.data(),
2005 data->fds->base_res,
2006 data->fds->global_size,
2020 update_distances(
index,
2024 data->ffs->surface_distance,
2030static void emit_from_mesh(
2036 float *vert_vel =
nullptr;
2037 bool has_velocity =
false;
2039 int defgrp_index = ffs->vgroup_density - 1;
2040 float flow_center[3] = {0};
2041 int min[3],
max[3], res[3];
2050 const int numverts =
mesh->verts_num;
2059 if (ffs->numverts != numverts || !ffs->verts_old) {
2060 if (ffs->verts_old) {
2061 MEM_delete(ffs->verts_old);
2064 ffs->numverts = numverts;
2067 has_velocity =
true;
2073 for (i = 0; i < numverts; i++) {
2075 mul_m4_v3(flow_ob->object_to_world().ptr(), positions[i]);
2076 manta_pos_to_cell(fds, positions[i]);
2083 sub_v3_v3v3(&vert_vel[i * 3], co, &ffs->verts_old[i * 3]);
2090 bb_boundInsert(bb, positions[i]);
2092 mesh->tag_positions_changed();
2093 mul_m4_v3(flow_ob->object_to_world().ptr(), flow_center);
2094 manta_pos_to_cell(fds, flow_center);
2098 int bounds_margin = int(
ceil(5.196));
2099 clamp_bounds_in_domain(fds, bb->min, bb->max,
nullptr,
nullptr, bounds_margin, dt);
2103 for (i = 0; i < 3; i++) {
2104 min[i] = bb->min[i];
2105 max[i] = bb->max[i];
2106 res[i] = bb->res[i];
2111 if (use_flow &&
mesh->faces_num > 0) {
2114 EmitFromDMData
data{};
2117 data.vert_positions = positions;
2118 data.vert_normals =
mesh->vert_normals();
2119 data.corner_verts = corner_verts;
2120 data.corner_tris = corner_tris;
2121 data.uv_map = uv_map;
2123 data.defgrp_index = defgrp_index;
2124 data.tree = &tree_data;
2126 data.has_velocity = has_velocity;
2127 data.vert_vel = vert_vel;
2128 data.flow_center = flow_center;
2135 settings.min_iter_per_thread = 2;
2140 MEM_delete(vert_vel);
2152static void adaptive_domain_adjust(
2156 int new_shift[3] = {0};
2158 float frame_shift_f[3];
2159 float ob_loc[3] = {0};
2161 mul_m4_v3(ob->object_to_world().ptr(), ob_loc);
2163 sub_v3_v3v3(frame_shift_f, ob_loc, fds->prev_loc);
2167 frame_shift_f[0] = frame_shift_f[0] / fds->cell_size[0];
2168 frame_shift_f[1] = frame_shift_f[1] / fds->cell_size[1];
2169 frame_shift_f[2] = frame_shift_f[2] / fds->cell_size[2];
2173 total_shift[0] = int(
floorf(fds->shift_f[0]));
2174 total_shift[1] = int(
floorf(fds->shift_f[1]));
2175 total_shift[2] = int(
floorf(fds->shift_f[2]));
2182 fds->p0[0] = fds->dp0[0] - fds->cell_size[0] * (fds->shift_f[0] - total_shift[0] - 0.5f);
2183 fds->p0[1] = fds->dp0[1] - fds->cell_size[1] * (fds->shift_f[1] - total_shift[1] - 0.5f);
2184 fds->p0[2] = fds->dp0[2] - fds->cell_size[2] * (fds->shift_f[2] - total_shift[2] - 0.5f);
2185 fds->p1[0] = fds->p0[0] + fds->cell_size[0] * fds->base_res[0];
2186 fds->p1[1] = fds->p0[1] + fds->cell_size[1] * fds->base_res[1];
2187 fds->p1[2] = fds->p0[2] + fds->cell_size[2] * fds->base_res[2];
2190 const int block_size = fds->noise_scale;
2191 int min[3] = {32767, 32767, 32767},
max[3] = {-32767, -32767, -32767}, res[3];
2192 int total_cells = 1, res_changed = 0, shift_changed = 0;
2193 float min_vel[3], max_vel[3];
2212 for (
x = fds->res_min[0];
x < fds->res_max[0];
x++) {
2213 for (
y = fds->res_min[1];
y < fds->res_max[1];
y++) {
2214 for (
z = fds->res_min[2];
z < fds->res_max[2];
z++) {
2215 int xn =
x - new_shift[0];
2216 int yn =
y - new_shift[1];
2217 int zn =
z - new_shift[2];
2222 if (xn >=
min[0] && xn <=
max[0] && yn >=
min[1] && yn <=
max[1] && zn >=
min[2] &&
2230 y - fds->res_min[1],
2232 z - fds->res_min[2]);
2233 max_den = (fuel) ? std::max(density[
index], fuel[
index]) : density[
index];
2234 max_den = (heat) ? std::max(max_den, heat[
index]) : max_den;
2240 int xx = (
x - fds->res_min[0]) * block_size;
2241 int yy = (
y - fds->res_min[1]) * block_size;
2242 int zz = (
z - fds->res_min[2]) * block_size;
2244 for (i = 0; i < block_size; i++) {
2245 for (j = 0; j < block_size; j++) {
2246 for (k = 0; k < block_size; k++) {
2247 int big_index =
manta_get_index(xx + i, wt_res[0], yy + j, wt_res[1], zz + k);
2248 float den = (bigfuel) ? std::max(bigdensity[big_index], bigfuel[big_index]) :
2249 bigdensity[big_index];
2250 max_den = std::max(den, max_den);
2257 if (max_den >= fds->adapt_threshold) {
2258 min[0] = std::min(
min[0], xn);
2259 min[1] = std::min(
min[1], yn);
2260 min[2] = std::min(
min[2], zn);
2261 max[0] = std::max(
max[0], xn);
2262 max[1] = std::max(
max[1], yn);
2263 max[2] = std::max(
max[2], zn);
2267 min_vel[0] = std::min(min_vel[0], vx[
index]);
2268 min_vel[1] = std::min(min_vel[1], vy[
index]);
2269 min_vel[2] = std::min(min_vel[2], vz[
index]);
2270 max_vel[0] = std::max(max_vel[0], vx[
index]);
2271 max_vel[1] = std::max(max_vel[1], vy[
index]);
2272 max_vel[2] = std::max(max_vel[2], vz[
index]);
2278 for (
int i = 0; i < numflowobj; i++) {
2279 FluidObjectBB *bb = &bb_maps[i];
2285 x - bb->min[0], bb->res[0],
y - bb->min[1], bb->res[1],
z - bb->min[2]);
2286 float max_den = bb->influence[
index];
2289 if (max_den >= fds->adapt_threshold) {
2303 clamp_bounds_in_domain(fds,
min,
max, min_vel, max_vel, fds->adapt_margin + 1, dt);
2305 for (
int i = 0; i < 3; i++) {
2307 res[i] =
max[i] -
min[i];
2308 total_cells *= res[i];
2317 for (j = 0; j < 3; j++) {
2326 if (
min[i] != fds->res_min[i] ||
max[i] != fds->res_max[i]) {
2331 if (res_changed || shift_changed) {
2338 fds, o_res, res, fds->res_min,
min, fds->res_max, temp_shift, total_shift);
2343 fds->total_cells = total_cells;
2351 float distance_value,
2364 phiout[
index] = std::min(distance_value, phiout[
index]);
2369 density[
index] = 0.0f;
2376 react[
index] = 0.0f;
2379 color_r[
index] = 0.0f;
2380 color_g[
index] = 0.0f;
2381 color_b[
index] = 0.0f;
2386 float emission_value,
2387 float distance_value,
2390 const float *density,
2398 const float *color_r,
2400 const float *color_g,
2402 const float *color_b,
2409 phi_in[
index] = std::min(distance_value, phi_in[
index]);
2415 emission_in[
index] = std::max(emission_value, emission_in[
index]);
2420 float dens_old = (density) ? density[
index] : 0.0;
2423 float fuel_flow = (fuel) ? emission_value * ffs->fuel_amount : 0.0f;
2425 if (heat && heat_in) {
2426 if (emission_value > 0.0f) {
2427 heat_in[
index] = ADD_IF_LOWER(heat[
index], ffs->temperature);
2432 if (absolute_flow) {
2433 if (density && density_in) {
2436 density_in[
index] = std::max(dens_flow, density_in[
index]);
2439 if (fuel && fuel_in) {
2442 fuel_in[
index] = std::max(fuel_flow, fuel_in[
index]);
2448 if (density && density_in) {
2450 density_in[
index] += dens_flow;
2454 if (fuel && fuel_in) {
2456 fuel_in[
index] += fuel_flow;
2463 if (color_r && color_r_in) {
2465 float total_dens = density[
index] / (dens_old + dens_flow);
2466 color_r_in[
index] = (color_r[
index] + ffs->color[0] * dens_flow) * total_dens;
2467 color_g_in[
index] = (color_g[
index] + ffs->color[1] * dens_flow) * total_dens;
2468 color_b_in[
index] = (color_b[
index] + ffs->color[2] * dens_flow) * total_dens;
2473 if (fuel && fuel_in) {
2475 float value = 1.0f -
pow2f(1.0f - emission_value);
2478 float f = fuel_flow / fuel_in[
index];
2479 react_in[
index] = value * f + (1.0f - f) * react[
index];
2522 active_fields &= ~prev_flags;
2525 for (flow_index = 0; flow_index < numflowobj; flow_index++) {
2526 Object *flow_ob = flowobjs[flow_index];
2557 if (ffs->temperature != 0.0) {
2573 else if (!
equals_v3v3(fds->active_color, ffs->color)) {
2586 copy_v3_v3(fds->active_color, fds->flame_smoke_color);
2589 else if (!
equals_v3v3(fds->active_color, fds->flame_smoke_color)) {
2590 copy_v3_v3(fds->active_color, fds->flame_smoke_color);
2594 fds->active_fields = active_fields;
2597static bool escape_flowsobject(
Object *flowobj,
2603 bool is_static = is_static_object(flowobj);
2606 bool gas_flow =
ELEM(
2613 bool is_resume = (fds->cache_frame_pause_data == frame);
2614 bool is_first_frame = (fds->cache_frame_start == frame);
2622 if (liquid_flow && is_geometry && !is_first_frame) {
2626 if ((liquid_flow && gas_domain) || (gas_flow && liquid_domain)) {
2631 if (liquid_flow && is_static && !is_first_frame && !is_resume && !use_velocity) {
2637static void compute_flowsemission(
Scene *scene,
2638 FluidObjectBB *bb_maps,
2639 Depsgraph *depsgraph,
2646 float time_per_frame)
2648 bool is_first_frame = (frame == fds->cache_frame_start);
2651 for (
int flow_index = 0; flow_index < numflowobjs; flow_index++) {
2652 Object *flowobj = flowobjs[flow_index];
2665 FluidObjectBB *bb = &bb_maps[flow_index];
2668 if (escape_flowsobject(flowobj, fds, ffs, frame)) {
2674 if (is_first_frame) {
2679 float sample_size = 1.0f /
float(subframes + 1);
2680 float subframe_dt = dt * sample_size;
2683 for (
int subframe = 0; subframe <= subframes; subframe++) {
2685 FluidObjectBB bb_temp = {
nullptr};
2688 if ((subframe < subframes || time_per_frame + dt +
FLT_EPSILON < frame_length) &&
2691 scene->r.subframe = (time_per_frame + (subframe + 1.0f) * subframe_dt) / frame_length;
2692 scene->r.cfra = frame - 1;
2695 scene->r.subframe = 0.0f;
2696 scene->r.cfra = frame;
2700 CLAMP(scene->r.subframe, 0.0f, 1.0f);
2704 "flow: frame (is first: %d): %d // scene current frame: %d // scene current subframe: "
2726 emit_from_particles(flowobj, fds, ffs, &bb_temp, depsgraph, scene, subframe_dt);
2729 emit_from_particles(flowobj, fds, ffs, bb, depsgraph, scene, subframe_dt);
2735 emit_from_mesh(flowobj, fds, ffs, &bb_temp, subframe_dt);
2738 emit_from_mesh(flowobj, fds, ffs, bb, subframe_dt);
2742 printf(
"Error: unknown flow emission source\n");
2750 bb_freeData(&bb_temp);
2757 printf(
"flow: frame: %d // time per frame: %f // frame length: %f // dt: %f\n",
2765static void update_flowsfluids(Depsgraph *depsgraph,
2769 float time_per_frame,
2774 FluidObjectBB *bb_maps =
nullptr;
2775 Object **flowobjs =
nullptr;
2776 uint numflowobjs = 0;
2777 bool is_resume = (fds->cache_frame_pause_data == frame);
2778 bool is_first_frame = (fds->cache_frame_start == frame);
2784 update_flowsflags(fds, flowobjs, numflowobjs);
2785 ensure_flowsfields(fds);
2791 compute_flowsemission(scene,
2804 adaptive_domain_adjust(fds, ob, bb_maps, numflowobjs, dt);
2840 BLI_assert((color_r && color_g && color_b) || (!color_r && !color_g && !color_b));
2841 BLI_assert((color_r_in && color_g_in && color_b_in) ||
2842 (!color_r_in && !color_g_in && !color_b_in));
2843 BLI_assert((velx_initial && vely_initial && velz_initial) ||
2844 (!velx_initial && !vely_initial && !velz_initial));
2848 for (
z = 0;
z < fds->res[0] * fds->res[1] * fds->res[2];
z++) {
2850 if (phistatic_in && is_first_frame) {
2857 if (phioutstatic_in && is_first_frame) {
2865 density_in[
z] = density[
z];
2868 heat_in[
z] = heat[
z];
2870 if (color_r_in && color_g_in && color_b_in) {
2871 color_r_in[
z] = color_r[
z];
2872 color_g_in[
z] = color_b[
z];
2873 color_b_in[
z] = color_g[
z];
2876 fuel_in[
z] = fuel[
z];
2877 react_in[
z] = react[
z];
2880 emission_in[
z] = 0.0f;
2882 if (velx_initial && vely_initial && velz_initial) {
2883 velx_initial[
z] = 0.0f;
2884 vely_initial[
z] = 0.0f;
2885 velz_initial[
z] = 0.0f;
2894 for (
int flow_index = 0; flow_index < numflowobjs; flow_index++) {
2895 Object *flowobj = flowobjs[flow_index];
2911 bool is_static = is_static_object(flowobj) &&
2914 FluidObjectBB *bb = &bb_maps[flow_index];
2915 float *velocity_map = bb->velocity;
2916 float *emission_map = bb->influence;
2917 float *distance_map = bb->distances;
2919 int gx, gy, gz, ex, ey, ez, dx, dy, dz;
2920 size_t e_index, d_index;
2923 for (gx = bb->min[0]; gx < bb->
max[0]; gx++) {
2924 for (gy = bb->min[1]; gy < bb->
max[1]; gy++) {
2925 for (gz = bb->min[2]; gz < bb->
max[2]; gz++) {
2927 ex = gx - bb->min[0];
2928 ey = gy - bb->min[1];
2929 ez = gz - bb->min[2];
2933 dx = gx - fds->res_min[0];
2934 dy = gy - fds->res_min[1];
2935 dz = gz - fds->res_min[2];
2938 if (dx < 0 || dy < 0 || dz < 0 || dx >= fds->res[0] || dy >= fds->res[1] ||
2946 float *levelset = ((is_first_frame || is_resume) && is_static) ? phioutstatic_in :
2948 apply_outflow_fields(d_index,
2949 distance_map[e_index],
2960 else if (is_geometry && !is_first_frame) {
2961 apply_inflow_fields(ffs,
2983 else if (is_geometry || is_inflow) {
2984 float *levelset = ((is_first_frame || is_resume) && is_static && !is_geometry) ?
2987 apply_inflow_fields(ffs,
2988 emission_map[e_index],
2989 distance_map[e_index],
3010 float vel_initial[3];
3011 vel_initial[0] = velx_initial[d_index];
3012 vel_initial[1] = vely_initial[d_index];
3013 vel_initial[2] = velz_initial[d_index];
3015 float vel_map_strength =
len_squared_v3(velocity_map + 3 * e_index);
3016 if (vel_map_strength > vel_initial_strength) {
3017 velx_initial[d_index] = velocity_map[e_index * 3];
3018 vely_initial[d_index] = velocity_map[e_index * 3 + 1];
3019 velz_initial[d_index] = velocity_map[e_index * 3 + 2];
3032 MEM_delete(bb_maps);
3036struct UpdateEffectorsData {
3038 FluidDomainSettings *fds;
3039 ListBaseT<EffectorCache> *effectors;
3053static void update_effectors_task_cb(
void *__restrict userdata,
3057 UpdateEffectorsData *
data =
static_cast<UpdateEffectorsData *
>(userdata);
3060 for (
int y = 0;
y < fds->res[1];
y++) {
3061 for (
int z = 0;
z < fds->res[2];
z++) {
3064 float voxel_center[3] = {0, 0, 0}, vel[3] = {0, 0, 0}, retvel[3] = {0, 0, 0};
3088 voxel_center[0] = fds->p0[0] + fds->cell_size[0] * (
float(
x + fds->res_min[0]) + 0.5f);
3089 voxel_center[1] = fds->p0[1] + fds->cell_size[1] * (
float(
y + fds->res_min[1]) + 0.5f);
3090 voxel_center[2] = fds->p0[2] + fds->cell_size[2] * (
float(
z + fds->res_min[2]) + 0.5f);
3096 data->effectors,
nullptr, fds->effector_weights, &epoint, retvel,
nullptr,
nullptr);
3113 printf(
"setting force: [%f, %f, %f]\n",
3122static void update_effectors(
3125 ListBaseT<EffectorCache> *effectors;
3132 UpdateEffectorsData
data;
3135 data.effectors = effectors;
3149 settings.min_iter_per_thread = 2;
3161 using namespace blender::bke;
3166 float cell_size_scaled[3];
3169 const VArraySpan orig_material_indices = *orig_attributes.
lookup<
int>(
"material_index",
3171 const short mp_mat_nr = orig_material_indices.
is_empty() ? 0 : orig_material_indices[0];
3174 int num_verts, num_faces;
3185 printf(
"num_verts: %d, num_faces: %d\n", num_verts, num_faces);
3188 if (!num_verts || !num_faces) {
3200 if (orgmesh->
attributes().domain_size(AttrDomain::Face) > 0) {
3202 .lookup_or_default<
bool>(
"sharp_face", AttrDomain::Face,
false)
3208 copy_v3_v3(cell_size_scaled, fds->cell_size);
3215 float max_size = std::max({
size[0],
size[1],
size[2]});
3218 co_scale[0] = max_size / ob->scale[0];
3219 co_scale[1] = max_size / ob->scale[1];
3220 co_scale[2] = max_size / ob->scale[2];
3223 co_offset[0] = (fds->p0[0] + fds->p1[0]) / 2.0f;
3224 co_offset[1] = (fds->p0[1] + fds->p1[1]) / 2.0f;
3225 co_offset[2] = (fds->p0[2] + fds->p1[2]) / 2.0f;
3232 float time_mult = fds->dx / (
DT_DEFAULT * (25.0f / scene->frames_per_second()));
3234 if (use_speedvectors) {
3240 for (i = 0; i < num_verts; i++) {
3248 float tmp[3] = {
float(fds->res[0]),
float(fds->res[1]),
float(fds->res[2])};
3253 mul_v3_fl(positions[i], fds->dx / fds->mesh_scale);
3260 printf(
"positions[i][0]: %f, positions[i][1]: %f, positions[i][2]: %f\n",
3268 printf(
"no_s[0]: %d, no_s[1]: %d, no_s[2]: %d\n", no_s[0], no_s[1], no_s[2]);
3271 if (use_speedvectors) {
3277 printf(
"velocities[%d].x: %f, velocities[%d].y: %f, velocities[%d].z: %f\n",
3279 velocities.
span[i].x,
3281 velocities.
span[i].y,
3283 velocities.
span[i].z);
3289 "material_index", AttrDomain::Face);
3294 material_indices.
span[i] = mp_mat_nr;
3296 face_offsets[i] = i * 3;
3303 printf(
"mloops[0].v: %d, mloops[1].v: %d, mloops[2].v: %d\n",
3311 material_indices.
finish();
3320 using namespace blender::bke;
3329 float ob_loc[3] = {0};
3330 float ob_cache_loc[3] = {0};
3383 face_offsets.
fill(4);
3388 corner_vert = &corner_verts[0 * 4];
3394 corner_vert = &corner_verts[1 * 4];
3400 corner_vert = &corner_verts[2 * 4];
3406 corner_vert = &corner_verts[3 * 4];
3412 corner_vert = &corner_verts[4 * 4];
3418 corner_vert = &corner_verts[5 * 4];
3426 invert_m4_m4(ob->runtime->world_to_object.ptr(), ob->object_to_world().ptr());
3427 mul_m4_v3(ob->object_to_world().ptr(), ob_loc);
3433 for (
int i = 0; i < num_verts; i++) {
3442static int manta_step(
3446 float dt, frame_length, time_total, time_total_old;
3447 float time_per_frame;
3448 bool init_resolution =
true;
3463 manta_set_domain_from_mesh(fds, ob,
mesh, init_resolution);
3473 std::scoped_lock
lock(object_update_lock);
3476 while (time_per_frame +
FLT_EPSILON < frame_length) {
3485 update_flowsfluids(depsgraph, scene, ob, fds, time_per_frame, frame_length, frame, dt);
3488 if (
G.is_break && !mode_replay) {
3496 update_obstacles(depsgraph, scene, ob, fds, time_per_frame, frame_length, frame, dt);
3499 if (
G.is_break && !mode_replay) {
3506 update_effectors(depsgraph, scene, ob, fds, dt);
3511 time_per_frame += dt;
3532static void manta_guiding(
3538 std::scoped_lock
lock(object_update_lock);
3540 update_obstacles(depsgraph, scene, ob, fds, dt, dt, frame, dt);
3545 Depsgraph *depsgraph,
3549 const int scene_framenr)
3551 if (scene_framenr >= fmd->
time) {
3552 fluid_modifier_init(fmd, depsgraph, ob, scene,
mesh);
3562 if (scene_framenr > fmd->
time) {
3563 fmd->
time = scene_framenr;
3565 else if (scene_framenr < fmd->time) {
3566 fmd->
time = scene_framenr;
3572 Depsgraph *depsgraph,
3576 const int scene_framenr)
3578 if (scene_framenr >= fmd->
time) {
3579 fluid_modifier_init(fmd, depsgraph, ob, scene,
mesh);
3589 if (scene_framenr > fmd->
time) {
3590 fmd->
time = scene_framenr;
3592 else if (scene_framenr < fmd->time) {
3593 fmd->
time = scene_framenr;
3599 Depsgraph *depsgraph,
3603 const int scene_framenr)
3606 Object *guide_parent =
nullptr;
3611 bool is_startframe, has_advanced;
3613 has_advanced = (scene_framenr == fmd->
time + 1);
3617 bool escape =
false;
3622 if (scene_framenr < fds->cache_frame_start ||
3638 if (scene_framenr < fds->cache_frame_start || scene_framenr > fds->
cache_frame_end) {
3644 if (escape && fds->
fluid) {
3672 update_flowsflags(fds, objs, numobj);
3678 update_obstacleflags(fds, objs, numobj);
3684 if (!fds->
fluid && !fluid_modifier_init(fmd, depsgraph, ob, scene,
mesh)) {
3685 CLOG_ERROR(&
LOG,
"Fluid initialization failed. Should not happen!");
3694 if (fmd_parent && fmd_parent->
domain) {
3700 int o_res[3], o_min[3], o_max[3], o_shift[3];
3712 update_final_gravity(fds, scene);
3714 int next_frame = scene_framenr + 1;
3715 int prev_frame = scene_framenr - 1;
3719 int data_frame = scene_framenr, noise_frame = scene_framenr;
3720 int mesh_frame = scene_framenr, particles_frame = scene_framenr, guide_frame = scene_framenr;
3722 bool with_smoke, with_liquid;
3726 bool drops, bubble, floater;
3732 bool with_script, with_noise, with_mesh, with_particles, with_guide;
3737 with_particles = drops || bubble || floater;
3739 bool has_data, has_noise, has_mesh, has_particles, has_guide, has_config;
3751 ensure_flowsfields(fds);
3752 ensure_obstaclefields(fds);
3755 bool baking_data, baking_noise, baking_mesh, baking_particles, baking_guide;
3762 bool resume_data, resume_noise, resume_mesh, resume_particles, resume_guide;
3769 bool read_cache, bake_cache;
3771 bake_cache = baking_data || baking_noise || baking_mesh || baking_particles || baking_guide;
3773 bool next_data, next_noise, next_mesh, next_particles, next_guide;
3780 bool prev_data, prev_noise, prev_mesh, prev_particles, prev_guide;
3798 if (!baking_data && !baking_noise && !baking_mesh && !baking_particles && !baking_guide) {
3812 if (baking_data && resume_data) {
3813 data_frame = prev_frame;
3815 if (baking_noise && resume_noise) {
3816 noise_frame = prev_frame;
3818 if (baking_mesh && resume_mesh) {
3819 mesh_frame = prev_frame;
3821 if (baking_particles && resume_particles) {
3822 particles_frame = prev_frame;
3824 if (baking_guide && resume_guide) {
3825 guide_frame = prev_frame;
3839 baking_data = !has_data && (is_startframe || prev_data);
3840 if (with_smoke && with_noise) {
3841 baking_noise = !has_noise && (is_startframe || prev_noise);
3843 if (with_liquid && with_mesh) {
3844 baking_mesh = !has_mesh && (is_startframe || prev_mesh);
3846 if (with_liquid && with_particles) {
3847 baking_particles = !has_particles && (is_startframe || prev_particles);
3856 bool read_partial =
false, read_all =
false;
3862 if (with_liquid && with_mesh) {
3863 if (mesh_frame != scene_framenr) {
3881 if (with_liquid && with_particles) {
3882 if (particles_frame != scene_framenr) {
3891 read_partial = !baking_data && !baking_particles && next_particles;
3892 read_all = !read_partial && with_resumable_cache;
3903 if (with_smoke && with_noise) {
3904 if (noise_frame != scene_framenr) {
3911 fds, o_res, fds->
res, o_min, fds->
res_min, o_max, o_shift, fds->
shift);
3914 read_partial = !baking_data && !baking_noise && next_noise;
3915 read_all = !read_partial && with_resumable_cache;
3918 read_partial = !baking_data && !baking_noise && next_data && next_noise;
3919 read_all = !read_partial && with_resumable_cache;
3924 if (data_frame != scene_framenr) {
3928 if (with_smoke || with_liquid) {
3935 read_partial = !baking_data && !baking_particles && !baking_mesh && next_data &&
3937 read_all = !read_partial && with_resumable_cache;
3946 if (!baking_data && !baking_noise && !baking_mesh && !baking_particles && !baking_guide) {
3953 baking_guide = !has_guide && (is_startframe || prev_guide);
3955 baking_data = !has_data && (is_startframe || prev_data);
3956 if (with_smoke && with_noise) {
3957 baking_noise = !has_noise && (is_startframe || prev_noise);
3959 if (with_liquid && with_mesh) {
3960 baking_mesh = !has_mesh && (is_startframe || prev_mesh);
3962 if (with_liquid && with_particles) {
3963 baking_particles = !has_particles && (is_startframe || prev_particles);
3967 if (is_startframe || has_advanced) {
3968 bake_cache = baking_data || baking_noise || baking_mesh || baking_particles;
3979 if (with_script && is_startframe) {
3988 if (baking_guide && with_guide) {
3989 manta_guiding(depsgraph, scene, ob, fmd, scene_framenr);
3993 if (manta_step(depsgraph, scene, ob,
mesh, fmd, scene_framenr)) {
3998 if (has_data || baking_data) {
3999 if (baking_noise && with_smoke && with_noise) {
4006 if (baking_mesh && with_liquid && with_mesh) {
4009 if (baking_particles && with_liquid && with_particles) {
4019 fmd->
time = scene_framenr;
4022static void fluid_modifier_process(
4028 fluid_modifier_processFlow(fmd, depsgraph, scene, ob,
mesh, scene_framenr);
4031 fluid_modifier_processEffector(fmd, depsgraph, scene, ob,
mesh, scene_framenr);
4034 fluid_modifier_processDomain(fmd, depsgraph, scene, ob,
mesh, scene_framenr);
4043 bool needs_viewport_update =
false;
4052 fluid_modifier_process(fmd, depsgraph, scene, ob,
mesh);
4065 needs_viewport_update =
true;
4071 bool baking_data, baking_noise, baking_mesh, baking_particles, baking_guide;
4078 if (with_mesh && !baking_data && !baking_noise && !baking_mesh && !baking_particles &&
4081 needs_viewport_update =
true;
4089 if (needs_viewport_update) {
4124static float calc_voxel_transp(
4125 float *
result,
const float *input,
int res[3],
int *pixel,
float *t_ray,
float correct)
4139static void bresenham_linie_3D(
int x1,
4152 int dx, dy, dz, i,
l, m, n, x_inc, y_inc, z_inc, err_1, err_2, dx2, dy2, dz2;
4163 x_inc = (dx < 0) ? -1 : 1;
4165 y_inc = (dy < 0) ? -1 : 1;
4167 z_inc = (dz < 0) ? -1 : 1;
4173 if ((
l >= m) && (
l >= n)) {
4176 for (i = 0; i <
l; i++) {
4193 else if ((m >=
l) && (m >= n)) {
4196 for (i = 0; i < m; i++) {
4216 for (i = 0; i < n; i++) {
4233 cb(
result, input, res, pixel, t_ray, correct);
4236static void manta_smoke_calc_transparency(
const Main &bmain,
4243 int slabsize = fds->
res[0] * fds->
res[1];
4246 float correct = -7.0f * fds->
dx;
4248 if (!get_light(bmain, scene, view_layer, light)) {
4254 light[0] = (light[0] - fds->
p0[0]) / fds->
cell_size[0] - 0.5f -
float(fds->
res_min[0]);
4255 light[1] = (light[1] - fds->
p0[1]) / fds->
cell_size[1] - 0.5f -
float(fds->
res_min[1]);
4256 light[2] = (light[2] - fds->
p0[2]) / fds->
cell_size[2] - 0.5f -
float(fds->
res_min[2]);
4264 for (
int z = 0;
z < fds->
res[2];
z++) {
4265 size_t index =
z * slabsize;
4267 for (
int y = 0;
y < fds->
res[1];
y++) {
4269 float voxel_center[3];
4275 shadow[
index] = -1.0f;
4277 voxel_center[0] =
float(
x);
4278 voxel_center[1] =
float(
y);
4279 voxel_center[2] =
float(
z);
4284 cell[0] = int(
floor(pos[0]));
4285 cell[1] = int(
floor(pos[1]));
4286 cell[2] = int(
floor(pos[2]));
4290 cell[0] = int(
floor(light[0]));
4291 cell[1] = int(
floor(light[1]));
4292 cell[2] = int(
floor(light[2]));
4295 CLAMP(cell[0], 0, fds->
res[0] - 1);
4296 CLAMP(cell[1], 0, fds->
res[1] - 1);
4297 CLAMP(cell[2], 0, fds->
res[2] - 1);
4299 bresenham_linie_3D(cell[0],
4313 shadow[
index] = t_ray;
4330 float density = 0.0f, fuel = 0.0f;
4333 manta_pos_to_cell(fds, pos);
4344 pos[0] = (pos[0] - fds->
res_min[0]) /
float(fds->
res[0]);
4345 pos[1] = (pos[1] - fds->
res_min[1]) /
float(fds->
res[1]);
4346 pos[2] = (pos[2] - fds->
res_min[2]) /
float(fds->
res[2]);
4350 if (pos[0] < 0.0f || pos[1] < 0.0f || pos[2] < 0.0f) {
4353 if (pos[0] > 1.0f || pos[1] > 1.0f || pos[2] > 1.0f) {
4368 vel_mag =
len_v3(velocity);
4378 return std::max(density, fuel);
4404 const char *pset_name,
4405 const char *parts_name,
4406 const char *psys_name,
4415 psys = MEM_new<ParticleSystem>(__func__);
4417 part->
type = psys_type;
4450 for (psys = ob->particlesystem.first(); psys; psys = next_psys) {
4451 next_psys = psys->next;
4452 if (psys->part->
type == particle_type) {
4577 settings->
type = type;
4599 settings->
type = type;
4606 settings->
type = type;
4613 const char coba_field = settings->
coba_field;
4617 if (
ELEM(coba_field,
4633 if (
ELEM(coba_field,
4697 MEM_delete(fmd->
flow);
4698 fmd->
flow =
nullptr;
4746 else if (fmd->
flow) {
4785 fmd->
domain = MEM_new<FluidDomainSettings>(__func__);
4794#ifndef WITH_OPENVDB_BLOSC
4801 char cache_name[64];
4817 fmd->
flow = MEM_new<FluidFlowSettings>(__func__);
4825 fmd->
effector = MEM_new<FluidEffectorSettings>(__func__);
4979 tfds->
coba = MEM_dupalloc(fds->
coba);
5018 else if (tfmd->
flow) {
5075 static int counter = 1;
CustomData interface, see also DNA_customdata_types.h.
General operations, lookup, etc. for blender objects.
#define OBJECT_MODIFIER_UPDATE_SUBFRAME_RECURSION_DEFAULT
#define PTCACHE_RESET_OUTDATED
File and directory operations.
A KD-tree for nearest neighbor search.
#define BLI_path_join(...)
#define THREAD_LOCK_WRITE
#define CLOG_ERROR(clg_ref,...)
#define FLUID_DOMAIN_DIR_DATA
#define FLUID_DOMAIN_DIR_PARTICLES
#define FLUID_DOMAIN_DIR_DEFAULT
#define FLUID_DOMAIN_DIR_MESH
#define FLUID_DOMAIN_DIR_GUIDE
#define FLUID_DOMAIN_DIR_SCRIPT
#define FLUID_DOMAIN_DIR_CONFIG
#define FLUID_DOMAIN_DIR_NOISE
Object is a sort of wrapper for general info.
Types and defines for representing Rigid Body entities.
Read Blender memory allocation and freeing.
#define INIT_MINMAX(min, max)
#define BLI_assert_unreachable()
SIMD_FORCE_INLINE const btScalar & z() const
Return the z value.
array< Particle > particles
constexpr bool is_empty() const
constexpr void fill(const T &value) const
constexpr IndexRange index_range() const
GAttributeReader lookup(const StringRef name) const
GSpanAttributeWriter lookup_or_add_for_write_span(StringRef name, AttrDomain domain, AttrType data_type, const AttributeInit &initializer=AttributeInitDefaultValue())
GSpanAttributeWriter lookup_or_add_for_write_only_span(StringRef name, AttrDomain domain, AttrType data_type)
constexpr IndexRange drop_back(int64_t n) const
constexpr bool is_empty() const
float dot(VecOp< float, D >, VecOp< float, D >) RET
float3x3 scale(float3x3 mat, float2 scale)
void mesh_smooth_set(Mesh &mesh, bool use_smooth, bool keep_sharp_edges=false)
void mesh_calc_edges(Mesh &mesh, bool keep_existing_edges, bool select_new_edges)
int size(const AssetLibraryReference *library_reference)
T distance(const T &a, const T &b)
T dot(const QuaternionBase< T > &a, const QuaternionBase< T > &b)
MatBase< T, NumCol, NumRow > normalize(const MatBase< T, NumCol, NumRow > &a)
constexpr StringRefNull velocity
OffsetIndices< int > accumulate_counts_to_offsets(MutableSpan< int > counts_to_offsets, int start_offset=0)
bool is_adaptive(const CpuPatchTable *patch_table)
@ FLUID_DOMAIN_FIELD_COLOR_G
@ FLUID_DOMAIN_FIELD_FUEL
@ FLUID_DOMAIN_FIELD_PHI_OBSTACLE
@ FLUID_DOMAIN_FIELD_PHI_IN
@ FLUID_DOMAIN_FIELD_FLAME
@ FLUID_DOMAIN_FIELD_COLOR_B
@ FLUID_DOMAIN_FIELD_DENSITY
@ FLUID_DOMAIN_FIELD_COLOR_R
@ FLUID_DOMAIN_FIELD_PHI_OUT
@ FLUID_DOMAIN_FIELD_HEAT
void BKE_fluid_cachetype_data_set(struct FluidDomainSettings *settings, eFluidDomain_FileFormat cache_data_format)
static void fluid_modifier_freeEffector(FluidModifierData *fmd)
MINLINE void add_v3fl_v3fl_v3i(float r[3], const float a[3], const int b[3])
BLI_assert(slot->slot_subtype.map==BMO_OP_SLOT_SUBTYPE_MAP_FLT)
void BKE_fluid_cache_new_name_for_current_session(int maxlen, char *r_name)
void BKE_fluid_modifier_reset(struct FluidModifierData *fmd)
void kdtree_balance(KDTree< CoordT > *tree)
bool manta_read_noise(struct MANTA *fluid, struct FluidModifierData *fmd, int framenr, bool resumable)
bool manta_bake_mesh(struct MANTA *fluid, struct FluidModifierData *fmd, int framenr)
@ VDB_PRECISION_HALF_FLOAT
@ VDB_PRECISION_MINI_FLOAT
size_t BLI_snprintf(char *__restrict dst, size_t dst_maxncpy, const char *__restrict format,...) ATTR_NONNULL(1
float * manta_get_ob_velocity_z(struct MANTA *fluid)
float * manta_get_guide_velocity_x(struct MANTA *fluid)
char * STRNCPY(char(&dst)[N], const char *src)
int manta_liquid_get_triangle_y_at(struct MANTA *liquid, int i)
float manta_liquid_get_vertex_x_at(struct MANTA *liquid, int i)
bool manta_has_mesh(struct MANTA *fluid, struct FluidModifierData *fmd, int framenr)
static void fluid_modifier_reset_ex(FluidModifierData *fmd, bool need_lock)
float * manta_noise_get_texture_u2(struct MANTA *smoke)
BLI_INLINE void BLI_parallel_range_settings_defaults(TaskParallelSettings *settings)
MINLINE void copy_v3_v3(float r[3], const float a[3])
void * MEM_new_array_uninitialized(size_t len, size_t size, const char *str) ATTR_WARN_UNUSED_RESULT ATTR_ALLOC_SIZE(1
void BKE_fluid_cachetype_noise_set(struct FluidDomainSettings *settings, eFluidDomain_FileFormat cache_noise_format)
float * manta_noise_get_color_b(struct MANTA *smoke)
bool BLI_path_abs(char path[FILE_MAX], const char *basepath) ATTR_NONNULL(1
float(*) BKE_Fluid_BresenhamFn(float *result, const float *input, int res[3], int *pixel, float *tRay, float correct)
@ FLUID_FLOW_BEHAVIOR_GEOMETRY
@ FLUID_FLOW_BEHAVIOR_OUTFLOW
@ FLUID_FLOW_BEHAVIOR_INFLOW
float * manta_smoke_get_react(struct MANTA *smoke)
void BKE_fluid_cache_endframe_set(struct FluidDomainSettings *settings, int value)
void minmax_v3v3_v3(float min[3], float max[3], const float vec[3])
float * manta_get_in_velocity_x(struct MANTA *fluid)
@ FLUID_DOMAIN_BORDER_BACK
@ FLUID_DOMAIN_BORDER_LEFT
@ FLUID_DOMAIN_BORDER_TOP
@ FLUID_DOMAIN_BORDER_RIGHT
@ FLUID_DOMAIN_BORDER_FRONT
@ FLUID_DOMAIN_BORDER_BOTTOM
float * manta_smoke_get_shadow(struct MANTA *smoke)
void psys_sim_data_init(struct ParticleSimulationData *sim)
ATTR_WARN_UNUSED_RESULT const BMLoop * l
void manta_free(struct MANTA *fluid)
ThreadRWMutex * BLI_rw_mutex_alloc()
MINLINE void sub_v3_v3v3_int(int r[3], const int a[3], const int b[3])
float * manta_noise_get_texture_w2(struct MANTA *smoke)
bool BKE_object_moves_in_time(const Object *object, bool recurse_parent)
@ FLUID_EFFECTOR_GUIDE_MIN
@ FLUID_EFFECTOR_GUIDE_AVERAGED
@ FLUID_EFFECTOR_GUIDE_MAX
@ FLUID_EFFECTOR_GUIDE_OVERRIDE
Mesh * BKE_mesh_copy_for_eval(const Mesh &source)
void interp_v2_v2v2v2(float r[2], const float a[2], const float b[2], const float c[2], const float t[3])
float * manta_get_force_x(struct MANTA *fluid)
void BKE_fluid_effector_type_set(struct Object *object, struct FluidEffectorSettings *settings, eFluidEffector_Type type)
int BKE_ptcache_id_reset(struct Scene *scene, PTCacheID *pid, int mode)
bool BLI_exists(const char *path) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL()
MINLINE void copy_v3_v3_int(int r[3], const int a[3])
float * manta_smoke_get_color_r_in(struct MANTA *smoke)
void BLI_rw_mutex_free(ThreadRWMutex *mutex)
bool invert_m4_m4(float inverse[4][4], const float mat[4][4])
float * manta_get_phiout_in(struct MANTA *fluid)
@ eModifierType_ParticleSystem
@ eModifierType_DynamicPaint
float * manta_get_phi_in(struct MANTA *fluid)
bool manta_has_particles(struct MANTA *fluid, struct FluidModifierData *fmd, int framenr)
float * manta_get_ob_velocity_x(struct MANTA *fluid)
float * manta_smoke_get_heat(struct MANTA *smoke)
MINLINE void add_v3_fl(float r[3], float f)
void BKE_effectors_apply(ListBaseT< EffectorCache > *effectors, ListBaseT< ColliderCache > *colliders, struct EffectorWeights *weights, struct EffectedPoint *point, float *force, float *wind_force, float *impulse)
bool manta_has_noise(struct MANTA *fluid, struct FluidModifierData *fmd, int framenr)
void BKE_ptcache_id_from_smoke(PTCacheID *pid, struct Object *ob, struct FluidModifierData *fmd)
MINLINE int max_ii(int a, int b)
void BLI_task_parallel_range(int start, int stop, void *userdata, TaskParallelRangeFunc func, const TaskParallelSettings *settings)
MINLINE void madd_v3fl_v3fl_v3fl_v3i(float r[3], const float a[3], const float b[3], const int c[3])
ATTR_WARN_UNUSED_RESULT const BMVert * v
void BKE_fluid_fields_sanitize(struct FluidDomainSettings *settings)
struct ParticleSystemModifierData * psys_get_modifier(struct Object *ob, struct ParticleSystem *psys)
bool manta_smoke_ensure_heat(struct MANTA *smoke, struct FluidModifierData *fmd)
void BKE_fluid_domain_type_set(struct Object *object, struct FluidDomainSettings *settings, eFluidDomain_Type type)
struct ParticleSettings * BKE_particlesettings_add(struct Main *bmain, const char *name)
void BLI_rw_mutex_lock(ThreadRWMutex *mutex, int mode)
void BKE_fluid_collisionextents_set(struct FluidDomainSettings *settings, eFluidDomain_BorderFlags value, bool clear)
void BKE_modifiers_persistent_uid_init(const Object &object, ModifierData &md)
int manta_liquid_get_num_triangles(struct MANTA *liquid)
@ FLUID_DOMAIN_USE_RESUMABLE_CACHE
@ FLUID_DOMAIN_USE_SPEED_VECTORS
@ FLUID_DOMAIN_EXPORT_MANTA_SCRIPT
@ FLUID_DOMAIN_USE_ADAPTIVE_DOMAIN
float * manta_noise_get_density(struct MANTA *smoke)
@ LIB_ID_COPY_SET_COPIED_ON_WRITE
float * manta_get_guide_velocity_y(struct MANTA *fluid)
bool manta_smoke_has_colors(struct MANTA *smoke)
MINLINE void mul_v3_fl(float r[3], float f)
MINLINE float pow2f(float x)
bool manta_bake_data(struct MANTA *fluid, struct FluidModifierData *fmd, int framenr)
float * manta_smoke_get_color_g_in(struct MANTA *smoke)
bool manta_ensure_obstacle(struct MANTA *fluid, struct FluidModifierData *fmd)
float * manta_get_phiobsstatic_in(struct MANTA *fluid)
@ FLUID_DOMAIN_CACHE_MODULAR
@ FLUID_DOMAIN_CACHE_REPLAY
float * manta_smoke_get_react_in(struct MANTA *smoke)
bool manta_read_config(struct MANTA *fluid, struct FluidModifierData *fmd, int framenr)
eFluidDomain_ActiveFields
@ FLUID_DOMAIN_ACTIVE_OUTFLOW
@ FLUID_DOMAIN_ACTIVE_COLORS
@ FLUID_DOMAIN_ACTIVE_FIRE
@ FLUID_DOMAIN_ACTIVE_COLOR_SET
@ FLUID_DOMAIN_ACTIVE_HEAT
@ FLUID_DOMAIN_ACTIVE_INVEL
@ FLUID_DOMAIN_ACTIVE_GUIDE
@ FLUID_DOMAIN_ACTIVE_OBSTACLE
float * manta_noise_get_color_r(struct MANTA *smoke)
MINLINE void sub_v3_v3(float r[3], const float a[3])
void BKE_modifier_unique_name(ListBaseT< ModifierData > *modifiers, ModifierData *md)
float * manta_get_phioutstatic_in(struct MANTA *fluid)
float manta_liquid_get_vertvel_z_at(struct MANTA *liquid, int i)
float BKE_fluid_get_velocity_at(struct Object *ob, float position[3], float velocity[3])
struct MANTA * manta_init(int *res, struct FluidModifierData *fmd)
KDTree< CoordT > * kdtree_new(uint nodes_len_capacity)
bool manta_ensure_invelocity(struct MANTA *fluid, struct FluidModifierData *fmd)
void mul_m4_v3(const float M[4][4], float r[3])
void BKE_fluid_modifier_free(struct FluidModifierData *fmd)
int manta_liquid_get_num_verts(struct MANTA *liquid)
MINLINE void madd_v3_v3fl(float r[3], const float a[3], float f)
MINLINE bool equals_v3v3(const float v1[3], const float v2[3]) ATTR_WARN_UNUSED_RESULT
bool manta_ensure_outflow(struct MANTA *fluid, struct FluidModifierData *fmd)
float BKE_defvert_find_weight(const MDeformVert *dvert, int defgroup)
void BKE_mesh_copy_parameters_for_eval(Mesh *me_dst, const Mesh *me_src)
float * manta_get_num_guide(struct MANTA *fluid)
float * manta_get_velocity_z(struct MANTA *fluid)
int manta_liquid_get_triangle_z_at(struct MANTA *liquid, int i)
VecBase< float, 2 > float2
void manta_update_variables(struct MANTA *fluid, struct FluidModifierData *fmd)
bool psys_get_particle_state(struct ParticleSimulationData *sim, int p, struct ParticleKey *state, bool always)
VecBase< int32_t, 3 > int3
struct Mesh * BKE_fluid_modifier_do(struct FluidModifierData *fmd, struct Depsgraph *depsgraph, struct Scene *scene, struct Object *ob, struct Mesh *mesh)
void BKE_fluid_cache_free_all(struct FluidDomainSettings *fds, struct Object *ob)
MINLINE void mul_v3_v3(float r[3], const float a[3])
BLI_INLINE unsigned int BLI_hash_int(unsigned int k)
@ FLUID_EFFECTOR_USE_PLANE_INIT
@ FLUID_EFFECTOR_USE_EFFEC
@ FLUID_EFFECTOR_NEEDS_UPDATE
float * manta_get_force_z(struct MANTA *fluid)
float * manta_get_in_velocity_y(struct MANTA *fluid)
void BLI_rw_mutex_unlock(ThreadRWMutex *mutex)
void BLI_remlink(ListBase *listbase, void *vlink) ATTR_NONNULL(1)
Main * DEG_get_bmain(const Depsgraph *graph)
float BLI_voxel_sample_trilinear(const float *data, const int res[3], const float co[3])
BMesh const char void * data
void BKE_fluid_particles_set(struct FluidDomainSettings *settings, eFluidDomain_ParticleTypes value, bool clear)
float manta_liquid_get_vertvel_x_at(struct MANTA *liquid, int i)
ModifierData * BKE_modifier_new(int type)
int BLI_delete(const char *path, bool dir, bool recursive) ATTR_NONNULL()
void manta_adapt_timestep(struct MANTA *fluid)
float * manta_noise_get_color_g(struct MANTA *smoke)
void psys_free(struct Object *ob, struct ParticleSystem *psys)
bool manta_bake_guiding(struct MANTA *fluid, struct FluidModifierData *fmd, int framenr)
float * manta_smoke_get_color_r(struct MANTA *smoke)
void interp_weights_tri_v3(float w[3], const float v1[3], const float v2[3], const float v3[3], const float co[3])
void kdtree_insert(KDTree< CoordT > *tree, int index, const CoordT &co)
bool manta_read_particles(struct MANTA *fluid, struct FluidModifierData *fmd, int framenr, bool resumable)
void BKE_fluid_cachetype_particle_set(struct FluidDomainSettings *settings, eFluidDomain_FileFormat cache_particle_format)
float * manta_get_phistatic_in(struct MANTA *fluid)
Mesh * BKE_mesh_new_nomain(int verts_num, int edges_num, int faces_num, int corners_num)
ModifierData * BKE_modifiers_get_virtual_modifierlist(const Object *ob, VirtualModifierData *data)
bool manta_liquid_ensure_sndparts(struct MANTA *liquid, struct FluidModifierData *fmd)
void BKE_modifier_free(ModifierData *md)
void manta_noise_get_res(struct MANTA *smoke, int *res)
int kdtree_find_nearest(const KDTree< CoordT > *tree, const CoordT &co, KDTreeNearest< CoordT > *r_nearest)
void BKE_fluid_cache_startframe_set(struct FluidDomainSettings *settings, int value)
constexpr size_t ARRAY_SIZE(const T(&arg)[N]) noexcept
bool BKE_view_layer_synced_ensure(const Main &bmain, const Scene *scene, ViewLayer *view_layer)
MINLINE void negate_v3(float r[3])
float manta_liquid_get_vertex_y_at(struct MANTA *liquid, int i)
bool manta_has_data(struct MANTA *fluid, struct FluidModifierData *fmd, int framenr)
ViewLayer * DEG_get_evaluated_view_layer(const Depsgraph *graph)
float BLI_bvhtree_bb_raycast(const float bv[6], const float light_start[3], const float light_end[3], float pos[3])
float * manta_get_force_y(struct MANTA *fluid)
float manta_get_timestep(struct MANTA *fluid)
void BKE_modifier_remove_from_list(Object *ob, ModifierData *md)
float * manta_noise_get_fuel(struct MANTA *smoke)
MINLINE float len_v3(const float a[3]) ATTR_WARN_UNUSED_RESULT
void BKE_fluid_cachetype_mesh_set(struct FluidDomainSettings *settings, eFluidDomain_FileFormat cache_mesh_format)
int manta_liquid_get_triangle_x_at(struct MANTA *liquid, int i)
void BKE_object_modifier_update_subframe(Depsgraph *depsgraph, Scene *scene, Object *ob, bool update_mesh, int parent_recursion_limit, float frame, int modifier_type)
MINLINE void zero_v3(float r[3])
float manta_liquid_get_vertvel_y_at(struct MANTA *liquid, int i)
void BKE_id_free(Main *bmain, void *idv)
bool manta_ensure_guiding(struct MANTA *fluid, struct FluidModifierData *fmd)
bool manta_smoke_has_fuel(struct MANTA *smoke)
float * manta_smoke_get_fuel(struct MANTA *smoke)
void BKE_fluid_flow_behavior_set(struct Object *object, struct FluidFlowSettings *settings, eFluidFlow_Behavior behavior)
void mul_mat3_m4_v3(const float mat[4][4], float r[3])
void BKE_texture_get_value(struct Tex *texture, const float *tex_co, struct TexResult *texres, bool use_color_management)
float * manta_smoke_get_density(struct MANTA *smoke)
bool BKE_fluid_reallocate_fluid(struct FluidDomainSettings *fds, int res[3], int free_old)
size_t manta_get_index(int x, int max_x, int y, int max_y, int z)
float * manta_smoke_get_heat_in(struct MANTA *smoke)
void BKE_fluid_cache_free(struct FluidDomainSettings *fds, struct Object *ob, int cache_map)
int * manta_smoke_get_flags(struct MANTA *smoke)
MINLINE void mul_v3_v3fl(float r[3], const float a[3], float f)
void BKE_fluid_modifier_copy(const struct FluidModifierData *fmd, struct FluidModifierData *tfmd, int flag)
MINLINE float normalize_v3(float n[3])
@ FLUID_DOMAIN_BAKED_PARTICLES
@ FLUID_DOMAIN_BAKED_GUIDE
@ FLUID_DOMAIN_BAKED_NOISE
@ FLUID_DOMAIN_OUTDATED_MESH
@ FLUID_DOMAIN_BAKED_DATA
@ FLUID_DOMAIN_OUTDATED_NOISE
@ FLUID_DOMAIN_BAKING_NOISE
@ FLUID_DOMAIN_BAKING_MESH
@ FLUID_DOMAIN_OUTDATED_GUIDE
@ FLUID_DOMAIN_BAKED_MESH
@ FLUID_DOMAIN_OUTDATED_PARTICLES
@ FLUID_DOMAIN_BAKING_PARTICLES
@ FLUID_DOMAIN_BAKING_DATA
@ FLUID_DOMAIN_OUTDATED_DATA
@ FLUID_DOMAIN_BAKING_GUIDE
float manta_liquid_get_vertex_z_at(struct MANTA *liquid, int i)
ModifierData * BKE_modifiers_findby_type(const Object *ob, ModifierType type)
MINLINE void add_v3_v3(float r[3], const float a[3])
void kdtree_free(KDTree< CoordT > *tree)
float * manta_get_guide_velocity_z(struct MANTA *fluid)
float * manta_noise_get_flame(struct MANTA *smoke)
float * manta_get_ob_velocity_y(struct MANTA *fluid)
MINLINE void sub_v3_v3v3(float r[3], const float a[3], const float b[3])
void pd_point_from_loc(struct Scene *scene, float *loc, float *vel, int index, struct EffectedPoint *point)
void manta_update_pointers(struct MANTA *fluid, struct FluidModifierData *fmd, bool flush)
void BKE_ptcache_free_list(ListBaseT< PointCache > *ptcaches)
void BKE_fluid_particle_system_destroy(struct Object *ob, int particle_type)
void BLI_addtail(ListBase *listbase, void *vlink) ATTR_NONNULL(1)
bool manta_smoke_ensure_colors(struct MANTA *smoke, struct FluidModifierData *fmd)
ATTR_WARN_UNUSED_RESULT const BMVert * v2
float BKE_scene_ctime_get(const Scene *scene)
MINLINE void copy_v3_fl(float r[3], float f)
bool manta_write_config(struct MANTA *fluid, struct FluidModifierData *fmd, int framenr)
struct Object ** BKE_collision_objects_create(struct Depsgraph *depsgraph, struct Object *self, struct Collection *collection, unsigned int *numcollobj, unsigned int modifier_type)
float * manta_get_num_obstacle(struct MANTA *fluid)
float * manta_smoke_get_flame(struct MANTA *smoke)
bool manta_bake_particles(struct MANTA *fluid, struct FluidModifierData *fmd, int framenr)
float * manta_smoke_get_color_b_in(struct MANTA *smoke)
@ FLUID_FLOW_TYPE_SMOKEFIRE
void BKE_fluid_flow_type_set(struct Object *object, struct FluidFlowSettings *settings, eFluidFlow_Type type)
static void fluid_modifier_freeDomain(FluidModifierData *fmd)
ListBaseT< EffectorCache > * BKE_effectors_create(struct Depsgraph *depsgraph, struct Object *ob_src, struct ParticleSystem *psys_src, struct EffectorWeights *weights, bool use_rotation)
bool manta_needs_realloc(struct MANTA *fluid, struct FluidModifierData *fmd)
@ FLUID_DOMAIN_GUIDE_SRC_DOMAIN
MINLINE float len_squared_v3(const float v[3]) ATTR_WARN_UNUSED_RESULT
float * manta_smoke_get_density_in(struct MANTA *smoke)
float * manta_get_phiguide_in(struct MANTA *fluid)
float * manta_get_phiobs_in(struct MANTA *fluid)
MINLINE void clamp_v3(float vec[3], float min, float max)
float * manta_smoke_get_emission_in(struct MANTA *smoke)
@ eModifierFlag_SharedCaches
struct PointCache * BKE_ptcache_add(ListBaseT< PointCache > *ptcaches)
bool manta_smoke_ensure_fire(struct MANTA *smoke, struct FluidModifierData *fmd)
void BKE_fluid_reallocate_copy_fluid(struct FluidDomainSettings *fds, int o_res[3], int n_res[3], const int o_min[3], const int n_min[3], const int o_max[3], int o_shift[3], int n_shift[3])
struct PointCache * BKE_ptcache_copy_list(ListBaseT< PointCache > *ptcaches_new, const ListBaseT< PointCache > *ptcaches_old, int flag)
float * manta_get_velocity_x(struct MANTA *fluid)
float * manta_noise_get_react(struct MANTA *smoke)
bool manta_has_guiding(struct MANTA *fluid, struct FluidModifierData *fmd, int framenr, bool domain)
MINLINE void copy_v4_v4(float r[4], const float a[4])
bool manta_read_mesh(struct MANTA *fluid, struct FluidModifierData *fmd, int framenr)
@ FLUID_FLOW_SOURCE_PARTICLES
float * manta_noise_get_texture_v(struct MANTA *smoke)
void BKE_mesh_texspace_calc(Mesh *mesh)
float * manta_noise_get_texture_w(struct MANTA *smoke)
void copy_m4_m4(float m1[4][4], const float m2[4][4])
float * manta_smoke_get_fuel_in(struct MANTA *smoke)
VecBase< float, 3 > float3
void interp_v3_v3v3v3(float p[3], const float v1[3], const float v2[3], const float v3[3], const float w[3])
float * manta_get_velocity_y(struct MANTA *fluid)
@ FLUID_FLOW_USE_PLANE_INIT
@ FLUID_FLOW_INITVELOCITY
@ FLUID_FLOW_NEEDS_UPDATE
@ FLUID_FLOW_USE_PART_SIZE
bool manta_liquid_export_script(struct MANTA *liquid, struct FluidModifierData *fmd)
Scene * DEG_get_evaluated_scene(const Depsgraph *graph)
float * manta_get_in_velocity_z(struct MANTA *fluid)
float * manta_smoke_get_color_b(struct MANTA *smoke)
static void fluid_modifier_freeFlow(FluidModifierData *fmd)
const char * BKE_modifier_path_relbase_from_global(Object *ob)
pthread_rwlock_t ThreadRWMutex
struct EffectorWeights * BKE_effector_add_weights(struct Collection *collection)
MINLINE float dot_v3v3(const float a[3], const float b[3]) ATTR_WARN_UNUSED_RESULT
void BKE_fluid_particle_system_create(struct Main *bmain, struct Object *ob, const char *pset_name, const char *parts_name, const char *psys_name, eParticleType psys_type)
bool manta_read_guiding(struct MANTA *fluid, struct FluidModifierData *fmd, int framenr, bool sourceDomain)
float DEG_get_ctime(const Depsgraph *graph)
void BKE_modifier_path_init(char *path, int path_maxncpy, const char *name)
MINLINE void zero_v3_int(int r[3])
bool manta_bake_noise(struct MANTA *fluid, struct FluidModifierData *fmd, int framenr)
bool manta_write_noise(struct MANTA *fluid, struct FluidModifierData *fmd, int framenr)
void BKE_fluid_modifier_create_type_data(struct FluidModifierData *fmd)
ListBaseT< Base > * BKE_view_layer_object_bases_get(ViewLayer *view_layer)
void BKE_collision_objects_free(struct Object **objects)
bool manta_smoke_has_heat(struct MANTA *smoke)
int BKE_fluid_get_data_flags(struct FluidDomainSettings *fds)
@ FLUID_EFFECTOR_TYPE_COLLISION
@ FLUID_EFFECTOR_TYPE_GUIDE
bool manta_smoke_export_script(struct MANTA *smoke, struct FluidModifierData *fmd)
void psys_sim_data_free(struct ParticleSimulationData *sim)
float * manta_smoke_get_color_g(struct MANTA *smoke)
void BKE_effectors_free(ListBaseT< EffectorCache > *lb)
float * manta_noise_get_texture_u(struct MANTA *smoke)
@ FLUID_DOMAIN_TYPE_LIQUID
bool manta_read_data(struct MANTA *fluid, struct FluidModifierData *fmd, int framenr, bool resumable)
void * MEM_new_array_zeroed(size_t len, size_t size, const char *str) ATTR_WARN_UNUSED_RESULT ATTR_ALLOC_SIZE(1
@ FLUID_FLOW_TEXTURE_MAP_AUTO
float * manta_noise_get_texture_v2(struct MANTA *smoke)
bool manta_write_data(struct MANTA *fluid, struct FluidModifierData *fmd, int framenr)
eFluidDomain_ParticleTypes
@ FLUID_DOMAIN_PARTICLE_TRACER
@ FLUID_DOMAIN_PARTICLE_FOAM
@ FLUID_DOMAIN_PARTICLE_SPRAY
@ FLUID_DOMAIN_PARTICLE_BUBBLE
KERNEL_FEATURE_LIGHT_PASSES KERNEL_FEATURE_PATH_GUIDING float
eFluidDomain_FileFormat cache_noise_format
eFluidDomain_FileFormat cache_mesh_format
eFluidDomain_CacheFlag cache_flag
eFluidDomain_BorderFlags border_collisions
int cache_frame_pause_guide
struct ListBaseT< PointCache > ptcaches[2]
float sndparticle_tau_min_k
float gridlines_upper_bound
struct EffectorWeights * effector_weights
int sndparticle_update_radius
FLUID_DisplayInterpolationMethod interp_method
eFluidDomain_AxisSliceMethod axis_slice_method
float mesh_particle_radius
eFluidDomain_VectorDrawType vector_draw_type
struct Collection * effector_group
float sndparticle_tau_min_ta
eFluidDomain_OpenVDBCompression openvdb_compression
float gridlines_range_color[4]
eFluidDomain_CobaField coba_field
struct Object * guide_parent
eFluidDomain_SimMethod simulation_method
struct PointCache * point_cache[2]
float fractions_threshold
int cache_frame_pause_data
int sndparticle_potential_radius
eFluidDomain_OpenVDBDepth openvdb_data_depth
struct Collection * fluid_group
float gridlines_lower_bound
eFluidDomain_FileFormat cache_data_format
eFluidDomain_FileFormat cache_particle_format
eFluidDomain_HighresSampling highres_sampling
FLUID_DisplayVectorField vector_field
float particle_randomness
eFluidDomain_ParticleTypes particle_type
float flame_smoke_color[3]
eFluidDomain_GridlineColorField gridlines_color_field
int cache_frame_pause_mesh
eFluidDomain_ActiveFields active_fields
eFluidDomain_SliceAxis slice_axis
float particle_band_width
eFluidDomain_CacheType cache_type
int cache_frame_pause_noise
eFluidDomain_VectorDrawMAC vector_draw_mac_components
eFluidDomain_SndParticleBoundary sndparticle_boundary
eFluidDomain_GridlineCellFilter gridlines_cell_filter
float sndparticle_tau_max_ta
eFluidDomain_GuideSource guide_source
struct Collection * force_group
char vector_scale_with_magnitude
float sndparticle_tau_max_k
float sndparticle_tau_max_wc
int cache_frame_pause_particles
struct FluidModifierData * fmd
float sndparticle_tau_min_wc
char cache_directory[1024]
eFluidDomain_SndParticleCombinedExport sndparticle_combined_export
eFluidDomain_MeshGenerator mesh_generator
struct FluidModifierData * fmd
eFluidEffector_Flags flags
eFluidEffector_GuideMode guide_mode
struct ParticleSystem * psys
eFluidFlow_TextureType texture_type
eFluidFlow_Behavior behavior
struct Tex * noise_texture
struct FluidModifierData * fmd
struct FluidEffectorSettings * effector
struct FluidFlowSettings * flow
struct FluidDomainSettings * domain
struct PointCache * cache
eParticleDrawCol draw_col
eParticlePhysicsType phystype
struct ParticleSystem * psys
MutableVArraySpan< T > span