Page MenuHome
Differential D7581 Diff 24263 intern/mantaflow/intern/MANTA_main.cpp

Changeset View

Standalone View

View Options

intern/mantaflow/intern/MANTA_main.cpp

Context not available.
is2D = (mmd->domain->solver_res == 2); is2D = (mmd->domain->solver_res == 2);
if (varName == "USING_SMOKE") // Use the getRealValueHash() function to convert string to a known enum value for switch()
ss << ((mmd->domain->type == FLUID_DOMAIN_TYPE_GAS) ? "True" : "False"); // statement
if (varName == "USING_LIQUID") RealValues hashedVal = getRealValueHash(varName);
ss << ((mmd->domain->type == FLUID_DOMAIN_TYPE_LIQUID) ? "True" : "False");
if (varName == "USING_COLORS") switch (hashedVal) {
ss << (mmd->domain->active_fields & FLUID_DOMAIN_ACTIVE_COLORS ? "True" : "False"); case ID:
if (varName == "USING_HEAT") ss << mCurrentID;
ss << (mmd->domain->active_fields & FLUID_DOMAIN_ACTIVE_HEAT ? "True" : "False"); return ss.str();
if (varName == "USING_FIRE") case USING_SMOKE:
ss << (mmd->domain->active_fields & FLUID_DOMAIN_ACTIVE_FIRE ? "True" : "False"); ss << ((mmd->domain->type == FLUID_DOMAIN_TYPE_GAS) ? "True" : "False");
if (varName == "USING_NOISE") break;
ss << (mmd->domain->flags & FLUID_DOMAIN_USE_NOISE ? "True" : "False"); case USING_LIQUID:
if (varName == "USING_OBSTACLE") ss << ((mmd->domain->type == FLUID_DOMAIN_TYPE_LIQUID) ? "True" : "False");
ss << (mmd->domain->active_fields & FLUID_DOMAIN_ACTIVE_OBSTACLE ? "True" : "False"); break;
if (varName == "USING_GUIDING") case USING_COLORS:
ss << (mmd->domain->flags & FLUID_DOMAIN_USE_GUIDE ? "True" : "False"); ss << (mmd->domain->active_fields & FLUID_DOMAIN_ACTIVE_COLORS ? "True" : "False");
if (varName == "USING_INVEL") break;
ss << (mmd->domain->active_fields & FLUID_DOMAIN_ACTIVE_INVEL ? "True" : "False"); case USING_HEAT:
if (varName == "USING_OUTFLOW") ss << (mmd->domain->active_fields & FLUID_DOMAIN_ACTIVE_HEAT ? "True" : "False");
ss << (mmd->domain->active_fields & FLUID_DOMAIN_ACTIVE_OUTFLOW ? "True" : "False"); break;
if (varName == "USING_LOG_DISSOLVE") case USING_FIRE:
ss << (mmd->domain->flags & FLUID_DOMAIN_USE_DISSOLVE_LOG ? "True" : "False"); ss << (mmd->domain->active_fields & FLUID_DOMAIN_ACTIVE_FIRE ? "True" : "False");
if (varName == "USING_DISSOLVE") break;
ss << (mmd->domain->flags & FLUID_DOMAIN_USE_DISSOLVE ? "True" : "False"); case USING_NOISE:
if (varName == "SOLVER_DIM") ss << (mmd->domain->flags & FLUID_DOMAIN_USE_NOISE ? "True" : "False");
ss << mmd->domain->solver_res; break;
if (varName == "DO_OPEN") { case USING_OBSTACLE:
tmpVar = (FLUID_DOMAIN_BORDER_BACK | FLUID_DOMAIN_BORDER_FRONT | FLUID_DOMAIN_BORDER_LEFT | ss << (mmd->domain->active_fields & FLUID_DOMAIN_ACTIVE_OBSTACLE ? "True" : "False");
FLUID_DOMAIN_BORDER_RIGHT | FLUID_DOMAIN_BORDER_BOTTOM | FLUID_DOMAIN_BORDER_TOP); break;
ss << (((mmd->domain->border_collisions & tmpVar) == tmpVar) ? "False" : "True"); case USING_GUIDING:
} ss << (mmd->domain->flags & FLUID_DOMAIN_USE_GUIDE ? "True" : "False");
if (varName == "BOUND_CONDITIONS") { break;
if (mmd->domain->solver_res == 2) { case USING_INVEL:
if ((mmd->domain->border_collisions & FLUID_DOMAIN_BORDER_LEFT) == 0) ss << (mmd->domain->active_fields & FLUID_DOMAIN_ACTIVE_INVEL ? "True" : "False");
ss << "x"; break;
if ((mmd->domain->border_collisions & FLUID_DOMAIN_BORDER_RIGHT) == 0) case USING_OUTFLOW:
ss << "X"; ss << (mmd->domain->active_fields & FLUID_DOMAIN_ACTIVE_OUTFLOW ? "True" : "False");
if ((mmd->domain->border_collisions & FLUID_DOMAIN_BORDER_FRONT) == 0) break;
ss << "y"; case USING_LOG_DISSOLVE:
if ((mmd->domain->border_collisions & FLUID_DOMAIN_BORDER_BACK) == 0) ss << (mmd->domain->flags & FLUID_DOMAIN_USE_DISSOLVE_LOG ? "True" : "False");
ss << "Y"; break;
} case USING_DISSOLVE:
if (mmd->domain->solver_res == 3) { ss << (mmd->domain->flags & FLUID_DOMAIN_USE_DISSOLVE ? "True" : "False");
if ((mmd->domain->border_collisions & FLUID_DOMAIN_BORDER_LEFT) == 0) break;
ss << "x"; case SOLVER_DIM:
if ((mmd->domain->border_collisions & FLUID_DOMAIN_BORDER_RIGHT) == 0) ss << mmd->domain->solver_res;
ss << "X"; break;
if ((mmd->domain->border_collisions & FLUID_DOMAIN_BORDER_FRONT) == 0) case DO_OPEN:
ss << "y"; tmpVar = (FLUID_DOMAIN_BORDER_BACK | FLUID_DOMAIN_BORDER_FRONT | FLUID_DOMAIN_BORDER_LEFT |
if ((mmd->domain->border_collisions & FLUID_DOMAIN_BORDER_BACK) == 0) FLUID_DOMAIN_BORDER_RIGHT | FLUID_DOMAIN_BORDER_BOTTOM | FLUID_DOMAIN_BORDER_TOP);
ss << "Y"; ss << (((mmd->domain->border_collisions & tmpVar) == tmpVar) ? "False" : "True");
if ((mmd->domain->border_collisions & FLUID_DOMAIN_BORDER_BOTTOM) == 0) break;
ss << "z"; case BOUND_CONDITIONS:
if ((mmd->domain->border_collisions & FLUID_DOMAIN_BORDER_TOP) == 0) if (mmd->domain->solver_res == 2) {
ss << "Z"; if ((mmd->domain->border_collisions & FLUID_DOMAIN_BORDER_LEFT) == 0)
} ss << "x";
} if ((mmd->domain->border_collisions & FLUID_DOMAIN_BORDER_RIGHT) == 0)
if (varName == "BOUNDARY_WIDTH") ss << "X";
ss << mmd->domain->boundary_width; if ((mmd->domain->border_collisions & FLUID_DOMAIN_BORDER_FRONT) == 0)
if (varName == "RES") ss << "y";
ss << mMaxRes; if ((mmd->domain->border_collisions & FLUID_DOMAIN_BORDER_BACK) == 0)
if (varName == "RESX") ss << "Y";
ss << mResX; }
if (varName == "RESY") if (mmd->domain->solver_res == 3) {
if (is2D) { if ((mmd->domain->border_collisions & FLUID_DOMAIN_BORDER_LEFT) == 0)
ss << mResZ; ss << "x";
} if ((mmd->domain->border_collisions & FLUID_DOMAIN_BORDER_RIGHT) == 0)
else { ss << "X";
ss << mResY; if ((mmd->domain->border_collisions & FLUID_DOMAIN_BORDER_FRONT) == 0)
} ss << "y";
else if (varName == "RESZ") { if ((mmd->domain->border_collisions & FLUID_DOMAIN_BORDER_BACK) == 0)
if (is2D) { ss << "Y";
ss << 1; if ((mmd->domain->border_collisions & FLUID_DOMAIN_BORDER_BOTTOM) == 0)
} ss << "z";
else { if ((mmd->domain->border_collisions & FLUID_DOMAIN_BORDER_TOP) == 0)
ss << mResZ; ss << "Z";
} }
} break;
if (varName == "TIME_SCALE") case BOUNDARY_WIDTH:
ss << mmd->domain->time_scale; ss << mmd->domain->boundary_width;
if (varName == "FRAME_LENGTH") break;
ss << mmd->domain->frame_length; case RES:
if (varName == "CFL") ss << mMaxRes;
ss << mmd->domain->cfl_condition; break;
if (varName == "DT") case RESX:
ss << mmd->domain->dt; ss << mResX;
if (varName == "TIMESTEPS_MIN") break;
ss << mmd->domain->timesteps_minimum; case RESY:
if (varName == "TIMESTEPS_MAX") if (is2D) {
ss << mmd->domain->timesteps_maximum; ss << mResZ;
if (varName == "TIME_TOTAL") }
ss << mmd->domain->time_total; else {
if (varName == "TIME_PER_FRAME") ss << mResY;
ss << mmd->domain->time_per_frame; }
if (varName == "VORTICITY") break;
ss << mmd->domain->vorticity / mConstantScaling; case RESZ:
if (varName == "FLAME_VORTICITY") if (is2D) {
ss << mmd->domain->flame_vorticity / mConstantScaling; ss << 1;
if (varName == "NOISE_SCALE") }
ss << mmd->domain->noise_scale; else {
if (varName == "MESH_SCALE") ss << mResZ;
ss << mmd->domain->mesh_scale; }
if (varName == "PARTICLE_SCALE") break;
ss << mmd->domain->particle_scale; case TIME_SCALE:
if (varName == "NOISE_RESX") ss << mmd->domain->time_scale;
ss << mResXNoise; break;
if (varName == "NOISE_RESY") { case FRAME_LENGTH:
if (is2D) { ss << mmd->domain->frame_length;
ss << mResZNoise; break;
} case CFL:
else { ss << mmd->domain->cfl_condition;
ss << mResYNoise; break;
} case DT:
} ss << mmd->domain->dt;
if (varName == "NOISE_RESZ") { break;
if (is2D) { case TIMESTEPS_MIN:
ss << 1; ss << mmd->domain->timesteps_minimum;
} break;
else { case TIMESTEPS_MAX:
ss << mResZNoise; ss << mmd->domain->timesteps_maximum;
} break;
} case TIME_TOTAL:
if (varName == "MESH_RESX") ss << mmd->domain->time_total;
ss << mResXMesh; break;
if (varName == "MESH_RESY") { case TIME_PER_FRAME:
if (is2D) { ss << mmd->domain->time_per_frame;
ss << mResZMesh; break;
} case VORTICITY:
else { ss << mmd->domain->vorticity / mConstantScaling;
ss << mResYMesh; break;
} case FLAME_VORTICITY:
} ss << mmd->domain->flame_vorticity / mConstantScaling;
if (varName == "MESH_RESZ") { break;
if (is2D) { case NOISE_SCALE:
ss << 1; ss << mmd->domain->noise_scale;
} break;
else { case MESH_SCALE:
ss << mResZMesh; ss << mmd->domain->mesh_scale;
} break;
} case PARTICLE_SCALE:
if (varName == "PARTICLE_RESX") ss << mmd->domain->particle_scale;
ss << mResXParticle; break;
if (varName == "PARTICLE_RESY") { case NOISE_RESX:
if (is2D) { ss << mResXNoise;
ss << mResZParticle; break;
} case NOISE_RESY:
else { if (is2D) {
ss << mResYParticle; ss << mResZNoise;
} }
} else {
if (varName == "PARTICLE_RESZ") { ss << mResYNoise;
if (is2D) { }
ss << 1; break;
} case NOISE_RESZ:
else { if (is2D) {
ss << mResZParticle; ss << 1;
} }
} else {
if (varName == "GUIDING_RESX") ss << mResZNoise;
ss << mResGuiding[0]; }
if (varName == "GUIDING_RESY") { break;
if (is2D) { case MESH_RESX:
ss << mResGuiding[2]; ss << mResXMesh;
} case MESH_RESY:
else { if (is2D) {
ss << mResGuiding[1]; ss << mResZMesh;
} }
} else {
if (varName == "GUIDING_RESZ") { ss << mResYMesh;
if (is2D) { }
ss << 1; break;
} case MESH_RESZ:
else { if (is2D) {
ss << mResGuiding[2]; ss << 1;
} }
} else {
if (varName == "MIN_RESX") ss << mResZMesh;
ss << mmd->domain->res_min[0]; }
if (varName == "MIN_RESY") break;
ss << mmd->domain->res_min[1]; case PARTICLE_RESX:
if (varName == "MIN_RESZ") ss << mResXParticle;
ss << mmd->domain->res_min[2]; break;
if (varName == "BASE_RESX") case PARTICLE_RESY:
ss << mmd->domain->base_res[0]; if (is2D) {
if (varName == "BASE_RESY") ss << mResZParticle;
ss << mmd->domain->base_res[1]; }
if (varName == "BASE_RESZ") else {
ss << mmd->domain->base_res[2]; ss << mResYParticle;
if (varName == "WLT_STR") }
ss << mmd->domain->noise_strength; break;
if (varName == "NOISE_POSSCALE") case PARTICLE_RESZ:
ss << mmd->domain->noise_pos_scale; if (is2D) {
if (varName == "NOISE_TIMEANIM") ss << 1;
ss << mmd->domain->noise_time_anim; }
if (varName == "COLOR_R") else {
ss << mmd->domain->active_color[0]; ss << mResZParticle;
if (varName == "COLOR_G") }
ss << mmd->domain->active_color[1]; break;
if (varName == "COLOR_B") case GUIDING_RESX:
ss << mmd->domain->active_color[2]; ss << mResGuiding[0];
if (varName == "BUOYANCY_ALPHA") break;
ss << mmd->domain->alpha; case GUIDING_RESY:
if (varName == "BUOYANCY_BETA") if (is2D) {
ss << mmd->domain->beta; ss << mResGuiding[2];
if (varName == "DISSOLVE_SPEED") }
ss << mmd->domain->diss_speed; else {
if (varName == "BURNING_RATE") ss << mResGuiding[1];
ss << mmd->domain->burning_rate; }
if (varName == "FLAME_SMOKE") break;
ss << mmd->domain->flame_smoke; case GUIDING_RESZ:
if (varName == "IGNITION_TEMP") if (is2D) {
ss << mmd->domain->flame_ignition; ss << 1;
if (varName == "MAX_TEMP") }
ss << mmd->domain->flame_max_temp; else {
if (varName == "FLAME_SMOKE_COLOR_X") ss << mResGuiding[2];
ss << mmd->domain->flame_smoke_color[0]; }
if (varName == "FLAME_SMOKE_COLOR_Y") break;
ss << mmd->domain->flame_smoke_color[1]; case MIN_RESX:
if (varName == "FLAME_SMOKE_COLOR_Z") ss << mmd->domain->res_min[0];
ss << mmd->domain->flame_smoke_color[2]; break;
if (varName == "CURRENT_FRAME") case MIN_RESY:
ss << mmd->time; ss << mmd->domain->res_min[1];
if (varName == "START_FRAME") break;
ss << mmd->domain->cache_frame_start; case MIN_RESZ:
if (varName == "END_FRAME") ss << mmd->domain->res_min[2];
ss << mmd->domain->cache_frame_end; break;
if (varName == "CACHE_DATA_FORMAT") case BASE_RESX:
ss << getCacheFileEnding(mmd->domain->cache_data_format); ss << mmd->domain->base_res[0];
if (varName == "CACHE_MESH_FORMAT") break;
ss << getCacheFileEnding(mmd->domain->cache_mesh_format); case BASE_RESY:
if (varName == "CACHE_NOISE_FORMAT") ss << mmd->domain->base_res[1];
ss << getCacheFileEnding(mmd->domain->cache_noise_format); break;
if (varName == "CACHE_PARTICLE_FORMAT") case BASE_RESZ:
ss << getCacheFileEnding(mmd->domain->cache_particle_format); ss << mmd->domain->base_res[2];
if (varName == "SIMULATION_METHOD") { break;
if (mmd->domain->simulation_method & FLUID_DOMAIN_METHOD_FLIP) { case WLT_STR:
ss << "'FLIP'"; ss << mmd->domain->noise_strength;
} break;
else if (mmd->domain->simulation_method & FLUID_DOMAIN_METHOD_APIC) { case NOISE_POSSCALE:
ss << "'APIC'"; ss << mmd->domain->noise_pos_scale;
} break;
else { case NOISE_TIMEANIM:
ss << "'NONE'"; ss << mmd->domain->noise_time_anim;
} break;
} case COLOR_R:
if (varName == "FLIP_RATIO") ss << mmd->domain->active_color[0];
ss << mmd->domain->flip_ratio; break;
if (varName == "PARTICLE_RANDOMNESS") case COLOR_G:
ss << mmd->domain->particle_randomness; ss << mmd->domain->active_color[1];
if (varName == "PARTICLE_NUMBER") break;
ss << mmd->domain->particle_number; case COLOR_B:
if (varName == "PARTICLE_MINIMUM") ss << mmd->domain->active_color[2];
ss << mmd->domain->particle_minimum; break;
if (varName == "PARTICLE_MAXIMUM") case BUOYANCY_ALPHA:
ss << mmd->domain->particle_maximum; ss << mmd->domain->alpha;
if (varName == "PARTICLE_RADIUS") break;
ss << mmd->domain->particle_radius; case BUOYANCY_BETA:
if (varName == "FRACTIONS_THRESHOLD") ss << mmd->domain->beta;
ss << mmd->domain->fractions_threshold; break;
if (varName == "MESH_CONCAVE_UPPER") case DISSOLVE_SPEED:
ss << mmd->domain->mesh_concave_upper; ss << mmd->domain->diss_speed;
if (varName == "MESH_CONCAVE_LOWER") break;
ss << mmd->domain->mesh_concave_lower; case BURNING_RATE:
if (varName == "MESH_PARTICLE_RADIUS") ss << mmd->domain->burning_rate;
ss << mmd->domain->mesh_particle_radius; break;
if (varName == "MESH_SMOOTHEN_POS") case FLAME_SMOKE:
ss << mmd->domain->mesh_smoothen_pos; ss << mmd->domain->flame_smoke;
if (varName == "MESH_SMOOTHEN_NEG") break;
ss << mmd->domain->mesh_smoothen_neg; case IGNITION_TEMP:
if (varName == "USING_MESH") ss << mmd->domain->flame_ignition;
ss << (mmd->domain->flags & FLUID_DOMAIN_USE_MESH ? "True" : "False"); break;
if (varName == "USING_IMPROVED_MESH") case MAX_TEMP:
ss << (mmd->domain->mesh_generator == FLUID_DOMAIN_MESH_IMPROVED ? "True" : "False"); ss << mmd->domain->flame_max_temp;
if (varName == "PARTICLE_BAND_WIDTH") break;
ss << mmd->domain->particle_band_width; case FLAME_SMOKE_COLOR_X:
if (varName == "SNDPARTICLE_TAU_MIN_WC") ss << mmd->domain->flame_smoke_color[0];
ss << mmd->domain->sndparticle_tau_min_wc; break;
if (varName == "SNDPARTICLE_TAU_MAX_WC") case FLAME_SMOKE_COLOR_Y:
ss << mmd->domain->sndparticle_tau_max_wc; ss << mmd->domain->flame_smoke_color[1];
if (varName == "SNDPARTICLE_TAU_MIN_TA") break;
ss << mmd->domain->sndparticle_tau_min_ta; case FLAME_SMOKE_COLOR_Z:
if (varName == "SNDPARTICLE_TAU_MAX_TA") ss << mmd->domain->flame_smoke_color[2];
ss << mmd->domain->sndparticle_tau_max_ta; break;
if (varName == "SNDPARTICLE_TAU_MIN_K") case CURRENT_FRAME:
ss << mmd->domain->sndparticle_tau_min_k; ss << mmd->time;
if (varName == "SNDPARTICLE_TAU_MAX_K") break;
ss << mmd->domain->sndparticle_tau_max_k; case START_FRAME:
if (varName == "SNDPARTICLE_K_WC") ss << mmd->domain->cache_frame_start;
ss << mmd->domain->sndparticle_k_wc; break;
if (varName == "SNDPARTICLE_K_TA") case END_FRAME:
ss << mmd->domain->sndparticle_k_ta; ss << mmd->domain->cache_frame_end;
if (varName == "SNDPARTICLE_K_B") break;
ss << mmd->domain->sndparticle_k_b; case CACHE_DATA_FORMAT:
if (varName == "SNDPARTICLE_K_D") ss << getCacheFileEnding(mmd->domain->cache_data_format);
ss << mmd->domain->sndparticle_k_d; break;
if (varName == "SNDPARTICLE_L_MIN") case CACHE_MESH_FORMAT:
ss << mmd->domain->sndparticle_l_min; ss << getCacheFileEnding(mmd->domain->cache_mesh_format);
if (varName == "SNDPARTICLE_L_MAX") break;
ss << mmd->domain->sndparticle_l_max; case CACHE_NOISE_FORMAT:
if (varName == "SNDPARTICLE_BOUNDARY_DELETE") ss << getCacheFileEnding(mmd->domain->cache_noise_format);
ss << (mmd->domain->sndparticle_boundary == SNDPARTICLE_BOUNDARY_DELETE); break;
if (varName == "SNDPARTICLE_BOUNDARY_PUSHOUT") case CACHE_PARTICLE_FORMAT:
ss << (mmd->domain->sndparticle_boundary == SNDPARTICLE_BOUNDARY_PUSHOUT); ss << getCacheFileEnding(mmd->domain->cache_particle_format);
if (varName == "SNDPARTICLE_POTENTIAL_RADIUS") break;
ss << mmd->domain->sndparticle_potential_radius; case SIMULATION_METHOD:
if (varName == "SNDPARTICLE_UPDATE_RADIUS") if (mmd->domain->simulation_method & FLUID_DOMAIN_METHOD_FLIP) {
ss << mmd->domain->sndparticle_update_radius; ss << "'FLIP'";
if (varName == "LIQUID_SURFACE_TENSION") }
ss << mmd->domain->surface_tension; else if (mmd->domain->simulation_method & FLUID_DOMAIN_METHOD_APIC) {
if (varName == "FLUID_VISCOSITY") ss << "'APIC'";
ss << mmd->domain->viscosity_base * pow(10.0f, -mmd->domain->viscosity_exponent); }
if (varName == "FLUID_DOMAIN_SIZE") { else {
tmpFloat = MAX3( ss << "'NONE'";
mmd->domain->global_size[0], mmd->domain->global_size[1], mmd->domain->global_size[2]); }
ss << tmpFloat; break;
} case FLIP_RATIO:
if (varName == "SNDPARTICLE_TYPES") { ss << mmd->domain->flip_ratio;
if (mmd->domain->particle_type & FLUID_DOMAIN_PARTICLE_SPRAY) { break;
ss << "PtypeSpray"; case PARTICLE_RANDOMNESS:
} ss << mmd->domain->particle_randomness;
if (mmd->domain->particle_type & FLUID_DOMAIN_PARTICLE_BUBBLE) { break;
if (!ss.str().empty()) case PARTICLE_NUMBER:
ss << "|"; ss << mmd->domain->particle_number;
ss << "PtypeBubble"; break;
} case PARTICLE_MINIMUM:
if (mmd->domain->particle_type & FLUID_DOMAIN_PARTICLE_FOAM) { ss << mmd->domain->particle_minimum;
if (!ss.str().empty()) break;
ss << "|"; case PARTICLE_MAXIMUM:
ss << "PtypeFoam"; ss << mmd->domain->particle_maximum;
} break;
if (mmd->domain->particle_type & FLUID_DOMAIN_PARTICLE_TRACER) { case PARTICLE_RADIUS:
if (!ss.str().empty()) ss << mmd->domain->particle_radius;
ss << "|"; break;
ss << "PtypeTracer"; case FRACTIONS_THRESHOLD:
} ss << mmd->domain->fractions_threshold;
if (ss.str().empty()) break;
ss << "0"; case MESH_CONCAVE_UPPER:
} ss << mmd->domain->mesh_concave_upper;
if (varName == "USING_SNDPARTS") { break;
tmpVar = (FLUID_DOMAIN_PARTICLE_SPRAY | FLUID_DOMAIN_PARTICLE_BUBBLE | case MESH_CONCAVE_LOWER:
FLUID_DOMAIN_PARTICLE_FOAM | FLUID_DOMAIN_PARTICLE_TRACER); ss << mmd->domain->mesh_concave_lower;
ss << (((mmd->domain->particle_type & tmpVar)) ? "True" : "False"); break;
case MESH_PARTICLE_RADIUS:
ss << mmd->domain->mesh_particle_radius;
break;
case MESH_SMOOTHEN_POS:
ss << mmd->domain->mesh_smoothen_pos;
break;
case MESH_SMOOTHEN_NEG:
ss << mmd->domain->mesh_smoothen_neg;
break;
case USING_MESH:
ss << (mmd->domain->flags & FLUID_DOMAIN_USE_MESH ? "True" : "False");
break;
case USING_IMPROVED_MESH:
ss << (mmd->domain->mesh_generator == FLUID_DOMAIN_MESH_IMPROVED ? "True" : "False");
break;
case PARTICLE_BAND_WIDTH:
ss << mmd->domain->particle_band_width;
break;
case SNDPARTICLE_TAU_MIN_WC:
ss << mmd->domain->sndparticle_tau_min_wc;
break;
case SNDPARTICLE_TAU_MAX_WC:
ss << mmd->domain->sndparticle_tau_max_wc;
break;
case SNDPARTICLE_TAU_MIN_TA:
ss << mmd->domain->sndparticle_tau_min_ta;
break;
case SNDPARTICLE_TAU_MAX_TA:
ss << mmd->domain->sndparticle_tau_max_ta;
break;
case SNDPARTICLE_TAU_MIN_K:
ss << mmd->domain->sndparticle_tau_min_k;
break;
case SNDPARTICLE_TAU_MAX_K:
ss << mmd->domain->sndparticle_tau_max_k;
break;
case SNDPARTICLE_K_WC:
ss << mmd->domain->sndparticle_k_wc;
break;
case SNDPARTICLE_K_TA:
ss << mmd->domain->sndparticle_k_ta;
break;
case SNDPARTICLE_K_B:
ss << mmd->domain->sndparticle_k_b;
break;
case SNDPARTICLE_K_D:
ss << mmd->domain->sndparticle_k_d;
break;
case SNDPARTICLE_L_MIN:
ss << mmd->domain->sndparticle_l_min;
break;
case SNDPARTICLE_L_MAX:
ss << mmd->domain->sndparticle_l_max;
break;
case SNDPARTICLE_BOUNDARY_DELETE:
ss << (mmd->domain->sndparticle_boundary == SNDPARTICLE_BOUNDARY_DELETE);
break;
case SNDPARTICLE_BOUNDARY_PUSHOUT:
ss << (mmd->domain->sndparticle_boundary == SNDPARTICLE_BOUNDARY_PUSHOUT);
break;
case SNDPARTICLE_POTENTIAL_RADIUS:
ss << mmd->domain->sndparticle_potential_radius;
break;
case SNDPARTICLE_UPDATE_RADIUS:
ss << mmd->domain->sndparticle_update_radius;
break;
case LIQUID_SURFACE_TENSION:
ss << mmd->domain->surface_tension;
break;
case FLUID_VISCOSITY:
ss << mmd->domain->viscosity_base * pow(10.0f, -mmd->domain->viscosity_exponent);
break;
case FLUID_DOMAIN_SIZE:
tmpFloat = MAX3(
mmd->domain->global_size[0], mmd->domain->global_size[1], mmd->domain->global_size[2]);
ss << tmpFloat;
break;
case SNDPARTICLE_TYPES:
if (mmd->domain->particle_type & FLUID_DOMAIN_PARTICLE_SPRAY) {
ss << "PtypeSpray";
}
if (mmd->domain->particle_type & FLUID_DOMAIN_PARTICLE_BUBBLE) {
if (!ss.str().empty())
ss << "|";
ss << "PtypeBubble";
}
if (mmd->domain->particle_type & FLUID_DOMAIN_PARTICLE_FOAM) {
if (!ss.str().empty())
ss << "|";
ss << "PtypeFoam";
}
if (mmd->domain->particle_type & FLUID_DOMAIN_PARTICLE_TRACER) {
if (!ss.str().empty())
ss << "|";
ss << "PtypeTracer";
}
if (ss.str().empty())
ss << "0";
break;
case USING_SNDPARTS:
tmpVar = (FLUID_DOMAIN_PARTICLE_SPRAY | FLUID_DOMAIN_PARTICLE_BUBBLE |
FLUID_DOMAIN_PARTICLE_FOAM | FLUID_DOMAIN_PARTICLE_TRACER);
ss << (((mmd->domain->particle_type & tmpVar)) ? "True" : "False");
break;
case GUIDING_ALPHA:
ss << mmd->domain->guide_alpha;
break;
case GUIDING_BETA:
ss << mmd->domain->guide_beta;
break;
case GUIDING_FACTOR:
ss << mmd->domain->guide_vel_factor;
break;
case GRAVITY_X:
ss << mmd->domain->gravity[0];
break;
case GRAVITY_Y:
ss << mmd->domain->gravity[1];
break;
case GRAVITY_Z:
ss << mmd->domain->gravity[2];
break;
case CACHE_DIR:
ss << mmd->domain->cache_directory;
break;
case CACHE_RESUMABLE:
ss << (mmd->domain->cache_type == FLUID_DOMAIN_CACHE_FINAL ? "False" : "True");
break;
case USING_ADAPTIVETIME:
ss << (mmd->domain->flags & FLUID_DOMAIN_USE_ADAPTIVE_TIME ? "True" : "False");
break;
case USING_SPEEDVECTORS:
ss << (mmd->domain->flags & FLUID_DOMAIN_USE_SPEED_VECTORS ? "True" : "False");
break;
case USING_FRACTIONS:
ss << (mmd->domain->flags & FLUID_DOMAIN_USE_FRACTIONS ? "True" : "False");
break;
case DELETE_IN_OBSTACLE:
ss << (mmd->domain->flags & FLUID_DOMAIN_DELETE_IN_OBSTACLE ? "True" : "False");
break;
case USING_DIFFUSION:
ss << (mmd->domain->flags & FLUID_DOMAIN_USE_DIFFUSION ? "True" : "False");
break;
default:
std::cerr << "Fluid Error -- Unknown option: " << varName << std::endl;
break;
} }
if (varName == "GUIDING_ALPHA")
ss << mmd->domain->guide_alpha;
if (varName == "GUIDING_BETA")
ss << mmd->domain->guide_beta;
if (varName == "GUIDING_FACTOR")
ss << mmd->domain->guide_vel_factor;
if (varName == "GRAVITY_X")
ss << mmd->domain->gravity[0];
if (varName == "GRAVITY_Y")
ss << mmd->domain->gravity[1];
if (varName == "GRAVITY_Z")
ss << mmd->domain->gravity[2];
if (varName == "CACHE_DIR")
ss << mmd->domain->cache_directory;
if (varName == "CACHE_RESUMABLE")
ss << (mmd->domain->cache_type == FLUID_DOMAIN_CACHE_FINAL ? "False" : "True");
if (varName == "USING_ADAPTIVETIME")
ss << (mmd->domain->flags & FLUID_DOMAIN_USE_ADAPTIVE_TIME ? "True" : "False");
if (varName == "USING_SPEEDVECTORS")
ss << (mmd->domain->flags & FLUID_DOMAIN_USE_SPEED_VECTORS ? "True" : "False");
if (varName == "USING_FRACTIONS")
ss << (mmd->domain->flags & FLUID_DOMAIN_USE_FRACTIONS ? "True" : "False");
if (varName == "DELETE_IN_OBSTACLE")
ss << (mmd->domain->flags & FLUID_DOMAIN_DELETE_IN_OBSTACLE ? "True" : "False");
if (varName == "USING_DIFFUSION")
ss << (mmd->domain->flags & FLUID_DOMAIN_USE_DIFFUSION ? "True" : "False");
if (MANTA::with_debug && ss.str().empty())
std::cerr << "Fluid Error -- Unknown option: " << varName << std::endl;
return ss.str(); return ss.str();
} }
Context not available.
BLI_path_frame(targetFile, framenr, 0); BLI_path_frame(targetFile, framenr, 0);
return targetFile; return targetFile;
} }
MANTA::RealValues MANTA::getRealValueHash(const std::string &varName)
{
// This function returns a member of the MANTA::RealValues enumeration to allow the
// getRealValue function to switch against the enum for higher performance versus
// doing string comparisons repeatedly.
if (varName == "ID")
return RealValues::ID;
if (varName == "USING_SMOKE")
return RealValues::USING_SMOKE;
if (varName == "USING_LIQUID")
return RealValues::USING_LIQUID;
if (varName == "USING_COLORS")
return RealValues::USING_COLORS;
if (varName == "USING_HEAT")
return RealValues::USING_HEAT;
if (varName == "USING_FIRE")
return RealValues::USING_FIRE;
if (varName == "USING_NOISE")
return RealValues::USING_NOISE;
if (varName == "USING_OBSTACLE")
return RealValues::USING_OBSTACLE;
if (varName == "USING_GUIDING")
return RealValues::USING_GUIDING;
if (varName == "USING_INVEL")
return RealValues::USING_INVEL;
if (varName == "USING_OUTFLOW")
return RealValues::USING_OUTFLOW;
if (varName == "USING_LOG_DISSOLVE")
return RealValues::USING_LOG_DISSOLVE;
if (varName == "USING_DISSOLVE")
return RealValues::USING_DISSOLVE;
if (varName == "SOLVER_DIM")
return RealValues::SOLVER_DIM;
if (varName == "DO_OPEN")
return RealValues::DO_OPEN;
if (varName == "BOUND_CONDITIONS")
return RealValues::BOUND_CONDITIONS;
if (varName == "BOUNDARY_WIDTH")
return RealValues::BOUNDARY_WIDTH;
if (varName == "RES")
return RealValues::RES;
if (varName == "RESX")
return RealValues::RESX;
if (varName == "RESY")
return RealValues::RESY;
if (varName == "RESZ")
return RealValues::RESZ;
if (varName == "TIME_SCALE")
return RealValues::TIME_SCALE;
if (varName == "FRAME_LENGTH")
return RealValues::FRAME_LENGTH;
if (varName == "CFL")
return RealValues::CFL;
if (varName == "DT")
return RealValues::DT;
if (varName == "TIMESTEPS_MIN")
return RealValues::TIMESTEPS_MIN;
if (varName == "TIMESTEPS_MAX")
return RealValues::TIMESTEPS_MAX;
if (varName == "TIME_TOTAL")
return RealValues::TIME_TOTAL;
if (varName == "TIME_PER_FRAME")
return RealValues::TIME_PER_FRAME;
if (varName == "VORTICITY")
return RealValues::VORTICITY;
if (varName == "FLAME_VORTICITY")
return RealValues::FLAME_VORTICITY;
if (varName == "NOISE_SCALE")
return RealValues::NOISE_SCALE;
if (varName == "MESH_SCALE")
return RealValues::MESH_SCALE;
if (varName == "PARTICLE_SCALE")
return RealValues::PARTICLE_SCALE;
if (varName == "NOISE_RESX")
return RealValues::NOISE_RESX;
if (varName == "NOISE_RESY")
return RealValues::NOISE_RESY;
if (varName == "NOISE_RESZ")
return RealValues::NOISE_RESZ;
if (varName == "MESH_RESX")
return RealValues::MESH_RESX;
if (varName == "MESH_RESY")
return RealValues::MESH_RESY;
if (varName == "MESH_RESZ")
return RealValues::MESH_RESZ;
if (varName == "PARTICLE_RESX")
return RealValues::PARTICLE_RESX;
if (varName == "PARTICLE_RESY")
return RealValues::PARTICLE_RESY;
if (varName == "PARTICLE_RESZ")
return RealValues::PARTICLE_RESZ;
if (varName == "GUIDING_RESX")
return RealValues::GUIDING_RESX;
if (varName == "GUIDING_RESY")
return RealValues::GUIDING_RESY;
if (varName == "GUIDING_RESZ")
return RealValues::GUIDING_RESZ;
if (varName == "MIN_RESX")
return RealValues::MIN_RESX;
if (varName == "MIN_RESY")
return RealValues::MIN_RESY;
if (varName == "MIN_RESZ")
return RealValues::MIN_RESZ;
if (varName == "BASE_RESX")
return RealValues::BASE_RESX;
if (varName == "BASE_RESY")
return RealValues::BASE_RESY;
if (varName == "BASE_RESZ")
return RealValues::BASE_RESZ;
if (varName == "WLT_STR")
return RealValues::WLT_STR;
if (varName == "NOISE_POSSCALE")
return RealValues::NOISE_POSSCALE;
if (varName == "NOISE_TIMEANIM")
return RealValues::NOISE_TIMEANIM;
if (varName == "COLOR_R")
return RealValues::COLOR_R;
if (varName == "COLOR_G")
return RealValues::COLOR_G;
if (varName == "COLOR_B")
return RealValues::COLOR_B;
if (varName == "BUOYANCY_ALPHA")
return RealValues::BUOYANCY_ALPHA;
if (varName == "BUOYANCY_BETA")
return RealValues::BUOYANCY_BETA;
if (varName == "DISSOLVE_SPEED")
return RealValues::DISSOLVE_SPEED;
if (varName == "BURNING_RATE")
return RealValues::BURNING_RATE;
if (varName == "FLAME_SMOKE")
return RealValues::FLAME_SMOKE;
if (varName == "IGNITION_TEMP")
return RealValues::IGNITION_TEMP;
if (varName == "MAX_TEMP")
return RealValues::MAX_TEMP;
if (varName == "FLAME_SMOKE_COLOR_X")
return RealValues::FLAME_SMOKE_COLOR_X;
if (varName == "FLAME_SMOKE_COLOR_Y")
return RealValues::FLAME_SMOKE_COLOR_Y;
if (varName == "FLAME_SMOKE_COLOR_Z")
return RealValues::FLAME_SMOKE_COLOR_Z;
if (varName == "CURRENT_FRAME")
return RealValues::CURRENT_FRAME;
if (varName == "START_FRAME")
return RealValues::START_FRAME;
if (varName == "END_FRAME")
return RealValues::END_FRAME;
if (varName == "CACHE_DATA_FORMAT")
return RealValues::CACHE_DATA_FORMAT;
if (varName == "CACHE_MESH_FORMAT")
return RealValues::CACHE_MESH_FORMAT;
if (varName == "CACHE_NOISE_FORMAT")
return RealValues::CACHE_NOISE_FORMAT;
if (varName == "CACHE_PARTICLE_FORMAT")
return RealValues::CACHE_PARTICLE_FORMAT;
if (varName == "SIMULATION_METHOD")
return RealValues::SIMULATION_METHOD;
if (varName == "FLIP_RATIO")
return RealValues::FLIP_RATIO;
if (varName == "PARTICLE_RANDOMNESS")
return RealValues::PARTICLE_RANDOMNESS;
if (varName == "PARTICLE_NUMBER")
return RealValues::PARTICLE_NUMBER;
if (varName == "PARTICLE_MINIMUM")
return RealValues::PARTICLE_MINIMUM;
if (varName == "PARTICLE_MAXIMUM")
return RealValues::PARTICLE_MAXIMUM;
if (varName == "PARTICLE_RADIUS")
return RealValues::PARTICLE_RADIUS;
if (varName == "FRACTIONS_THRESHOLD")
return RealValues::FRACTIONS_THRESHOLD;
if (varName == "MESH_CONCAVE_UPPER")
return RealValues::MESH_CONCAVE_UPPER;
if (varName == "MESH_CONCAVE_LOWER")
return RealValues::MESH_CONCAVE_LOWER;
if (varName == "MESH_PARTICLE_RADIUS")
return RealValues::MESH_PARTICLE_RADIUS;
if (varName == "MESH_SMOOTHEN_POS")
return RealValues::MESH_SMOOTHEN_POS;
if (varName == "MESH_SMOOTHEN_NEG")
return RealValues::MESH_SMOOTHEN_NEG;
if (varName == "USING_MESH")
return RealValues::USING_MESH;
if (varName == "USING_IMPROVED_MESH")
return RealValues::USING_IMPROVED_MESH;
if (varName == "PARTICLE_BAND_WIDTH")
return RealValues::PARTICLE_BAND_WIDTH;
if (varName == "SNDPARTICLE_TAU_MIN_WC")
return RealValues::SNDPARTICLE_TAU_MIN_WC;
if (varName == "SNDPARTICLE_TAU_MAX_WC")
return RealValues::SNDPARTICLE_TAU_MAX_WC;
if (varName == "SNDPARTICLE_TAU_MIN_TA")
return RealValues::SNDPARTICLE_TAU_MIN_TA;
if (varName == "SNDPARTICLE_TAU_MAX_TA")
return RealValues::SNDPARTICLE_TAU_MAX_TA;
if (varName == "SNDPARTICLE_TAU_MIN_K")
return RealValues::SNDPARTICLE_TAU_MIN_K;
if (varName == "SNDPARTICLE_TAU_MAX_K")
return RealValues::SNDPARTICLE_TAU_MAX_K;
if (varName == "SNDPARTICLE_K_WC")
return RealValues::SNDPARTICLE_K_WC;
if (varName == "SNDPARTICLE_K_TA")
return RealValues::SNDPARTICLE_K_TA;
if (varName == "SNDPARTICLE_K_B")
return RealValues::SNDPARTICLE_K_B;
if (varName == "SNDPARTICLE_K_D")
return RealValues::SNDPARTICLE_K_D;
if (varName == "SNDPARTICLE_L_MIN")
return RealValues::SNDPARTICLE_L_MIN;
if (varName == "SNDPARTICLE_L_MAX")
return RealValues::SNDPARTICLE_L_MAX;
if (varName == "SNDPARTICLE_BOUNDARY_DELETE")
return RealValues::SNDPARTICLE_BOUNDARY_DELETE;
if (varName == "SNDPARTICLE_BOUNDARY_PUSHOUT")
return RealValues::SNDPARTICLE_BOUNDARY_PUSHOUT;
if (varName == "SNDPARTICLE_POTENTIAL_RADIUS")
return RealValues::SNDPARTICLE_POTENTIAL_RADIUS;
if (varName == "SNDPARTICLE_UPDATE_RADIUS")
return RealValues::SNDPARTICLE_UPDATE_RADIUS;
if (varName == "LIQUID_SURFACE_TENSION")
return RealValues::LIQUID_SURFACE_TENSION;
if (varName == "FLUID_VISCOSITY")
return RealValues::FLUID_VISCOSITY;
if (varName == "FLUID_DOMAIN_SIZE")
return RealValues::FLUID_DOMAIN_SIZE;
if (varName == "SNDPARTICLE_TYPES")
return RealValues::SNDPARTICLE_TYPES;
if (varName == "USING_SNDPARTS")
return RealValues::USING_SNDPARTS;
if (varName == "GUIDING_ALPHA")
return RealValues::GUIDING_ALPHA;
if (varName == "GUIDING_BETA")
return RealValues::GUIDING_BETA;
if (varName == "GUIDING_FACTOR")
return RealValues::GUIDING_FACTOR;
if (varName == "GRAVITY_X")
return RealValues::GRAVITY_X;
if (varName == "GRAVITY_Y")
return RealValues::GRAVITY_Y;
if (varName == "GRAVITY_Z")
return RealValues::GRAVITY_Z;
if (varName == "CACHE_DIR")
return RealValues::CACHE_DIR;
if (varName == "CACHE_RESUMABLE")
return RealValues::CACHE_RESUMABLE;
if (varName == "USING_ADAPTIVETIME")
return RealValues::USING_ADAPTIVETIME;
if (varName == "USING_SPEEDVECTORS")
return RealValues::USING_SPEEDVECTORS;
if (varName == "USING_FRACTIONS")
return RealValues::USING_FRACTIONS;
if (varName == "DELETE_IN_OBSTACLE")
return RealValues::DELETE_IN_OBSTACLE;
if (varName == "USING_DIFFUSION")
return RealValues::USING_DIFFUSION;
// This can be used to test for any unexpected or null values
return RealValues::INVALID_ITEM_ERROR;
}
Context not available.