Fluid: Refactored 'Modifier Data to Python' value transfer function
This function needed a bigger cleanup, especially after the problem from T76276.
This commit is contained in:
parent
57cfa8e2d0
commit
99ee1de094
Notes:
blender-bot
2023-02-21 17:59:30 +01:00
Referenced by commit9db08b77e4, Fluid: Fix for refactor99ee1de094Referenced by commit6ea71cb104, Fluid: Fix for refactor99ee1de094
|
|
@ -184,17 +184,20 @@ MANTA::MANTA(int *res, FluidModifierData *mmd) : mCurrentID(++solverID)
|
|||
// Setup Mantaflow in Python
|
||||
initializeMantaflow();
|
||||
|
||||
// Initializa RNA map with values that Python will need
|
||||
initializeRNAMap(mmd);
|
||||
|
||||
// Initialize Mantaflow variables in Python
|
||||
// Liquid
|
||||
if (mUsingLiquid) {
|
||||
initDomain(mmd);
|
||||
initLiquid(mmd);
|
||||
initDomain();
|
||||
initLiquid();
|
||||
if (mUsingObstacle)
|
||||
initObstacle(mmd);
|
||||
initObstacle();
|
||||
if (mUsingInvel)
|
||||
initInVelocity(mmd);
|
||||
initInVelocity();
|
||||
if (mUsingOutflow)
|
||||
initOutflow(mmd);
|
||||
initOutflow();
|
||||
|
||||
if (mUsingDrops || mUsingBubbles || mUsingFloats || mUsingTracers) {
|
||||
mUpresParticle = mmd->domain->particle_scale;
|
||||
|
|
@ -203,8 +206,8 @@ MANTA::MANTA(int *res, FluidModifierData *mmd) : mCurrentID(++solverID)
|
|||
mResZParticle = mUpresParticle * mResZ;
|
||||
mTotalCellsParticles = mResXParticle * mResYParticle * mResZParticle;
|
||||
|
||||
initSndParts(mmd);
|
||||
initLiquidSndParts(mmd);
|
||||
initSndParts();
|
||||
initLiquidSndParts();
|
||||
}
|
||||
|
||||
if (mUsingMesh) {
|
||||
|
|
@ -215,39 +218,39 @@ MANTA::MANTA(int *res, FluidModifierData *mmd) : mCurrentID(++solverID)
|
|||
mTotalCellsMesh = mResXMesh * mResYMesh * mResZMesh;
|
||||
|
||||
// Initialize Mantaflow variables in Python
|
||||
initMesh(mmd);
|
||||
initLiquidMesh(mmd);
|
||||
initMesh();
|
||||
initLiquidMesh();
|
||||
}
|
||||
|
||||
if (mUsingGuiding) {
|
||||
mResGuiding = (mmd->domain->guide_parent) ? mmd->domain->guide_res : mmd->domain->res;
|
||||
initGuiding(mmd);
|
||||
initGuiding();
|
||||
}
|
||||
if (mUsingFractions) {
|
||||
initFractions(mmd);
|
||||
initFractions();
|
||||
}
|
||||
}
|
||||
|
||||
// Smoke
|
||||
if (mUsingSmoke) {
|
||||
initDomain(mmd);
|
||||
initSmoke(mmd);
|
||||
initDomain();
|
||||
initSmoke();
|
||||
if (mUsingHeat)
|
||||
initHeat(mmd);
|
||||
initHeat();
|
||||
if (mUsingFire)
|
||||
initFire(mmd);
|
||||
initFire();
|
||||
if (mUsingColors)
|
||||
initColors(mmd);
|
||||
initColors();
|
||||
if (mUsingObstacle)
|
||||
initObstacle(mmd);
|
||||
initObstacle();
|
||||
if (mUsingInvel)
|
||||
initInVelocity(mmd);
|
||||
initInVelocity();
|
||||
if (mUsingOutflow)
|
||||
initOutflow(mmd);
|
||||
initOutflow();
|
||||
|
||||
if (mUsingGuiding) {
|
||||
mResGuiding = (mmd->domain->guide_parent) ? mmd->domain->guide_res : mmd->domain->res;
|
||||
initGuiding(mmd);
|
||||
initGuiding();
|
||||
}
|
||||
|
||||
if (mUsingNoise) {
|
||||
|
|
@ -258,12 +261,12 @@ MANTA::MANTA(int *res, FluidModifierData *mmd) : mCurrentID(++solverID)
|
|||
mTotalCellsHigh = mResXNoise * mResYNoise * mResZNoise;
|
||||
|
||||
// Initialize Mantaflow variables in Python
|
||||
initNoise(mmd);
|
||||
initSmokeNoise(mmd);
|
||||
initNoise();
|
||||
initSmokeNoise();
|
||||
if (mUsingFire)
|
||||
initFireHigh(mmd);
|
||||
initFireHigh();
|
||||
if (mUsingColors)
|
||||
initColorsHigh(mmd);
|
||||
initColorsHigh();
|
||||
}
|
||||
}
|
||||
updatePointers();
|
||||
|
|
@ -529,6 +532,9 @@ MANTA::~MANTA()
|
|||
tmpString += manta_import;
|
||||
tmpString += fluid_delete_all;
|
||||
|
||||
// Initializa RNA map with values that Python will need
|
||||
initializeRNAMap();
|
||||
|
||||
// Leave out mmd argument in parseScript since only looking up IDs
|
||||
std::string finalString = parseScript(tmpString);
|
||||
pythonCommands.push_back(finalString);
|
||||
|
|
@ -613,401 +619,232 @@ static std::string getCacheFileEnding(char cache_format)
|
|||
}
|
||||
}
|
||||
|
||||
std::string MANTA::getRealValue(const std::string &varName, FluidModifierData *mmd)
|
||||
void MANTA::initializeRNAMap(FluidModifierData *mmd)
|
||||
{
|
||||
std::ostringstream ss;
|
||||
bool is2D = false;
|
||||
int tmpVar;
|
||||
float tmpFloat;
|
||||
if (with_debug)
|
||||
std::cout << "MANTA::initializeRNAMap()" << std::endl;
|
||||
|
||||
if (varName == "ID") {
|
||||
ss << mCurrentID;
|
||||
return ss.str();
|
||||
}
|
||||
mRNAMap["ID"] = std::to_string(mCurrentID);
|
||||
|
||||
if (!mmd) {
|
||||
std::cerr << "Fluid Error -- Invalid modifier data." << std::endl;
|
||||
ss << "ERROR - INVALID MODIFIER DATA";
|
||||
return ss.str();
|
||||
if (with_debug)
|
||||
std::cout << "No modifier data given in RNA map setup - returning early" << std::endl;
|
||||
return;
|
||||
}
|
||||
|
||||
is2D = (mmd->domain->solver_res == 2);
|
||||
FluidDomainSettings *mds = mmd->domain;
|
||||
bool is2D = (mds->solver_res == 2);
|
||||
|
||||
if (varName == "USING_SMOKE")
|
||||
ss << ((mmd->domain->type == FLUID_DOMAIN_TYPE_GAS) ? "True" : "False");
|
||||
if (varName == "USING_LIQUID")
|
||||
ss << ((mmd->domain->type == FLUID_DOMAIN_TYPE_LIQUID) ? "True" : "False");
|
||||
if (varName == "USING_COLORS")
|
||||
ss << (mmd->domain->active_fields & FLUID_DOMAIN_ACTIVE_COLORS ? "True" : "False");
|
||||
if (varName == "USING_HEAT")
|
||||
ss << (mmd->domain->active_fields & FLUID_DOMAIN_ACTIVE_HEAT ? "True" : "False");
|
||||
if (varName == "USING_FIRE")
|
||||
ss << (mmd->domain->active_fields & FLUID_DOMAIN_ACTIVE_FIRE ? "True" : "False");
|
||||
if (varName == "USING_NOISE")
|
||||
ss << (mmd->domain->flags & FLUID_DOMAIN_USE_NOISE ? "True" : "False");
|
||||
if (varName == "USING_OBSTACLE")
|
||||
ss << (mmd->domain->active_fields & FLUID_DOMAIN_ACTIVE_OBSTACLE ? "True" : "False");
|
||||
if (varName == "USING_GUIDING")
|
||||
ss << (mmd->domain->flags & FLUID_DOMAIN_USE_GUIDE ? "True" : "False");
|
||||
if (varName == "USING_INVEL")
|
||||
ss << (mmd->domain->active_fields & FLUID_DOMAIN_ACTIVE_INVEL ? "True" : "False");
|
||||
if (varName == "USING_OUTFLOW")
|
||||
ss << (mmd->domain->active_fields & FLUID_DOMAIN_ACTIVE_OUTFLOW ? "True" : "False");
|
||||
if (varName == "USING_LOG_DISSOLVE")
|
||||
ss << (mmd->domain->flags & FLUID_DOMAIN_USE_DISSOLVE_LOG ? "True" : "False");
|
||||
if (varName == "USING_DISSOLVE")
|
||||
ss << (mmd->domain->flags & FLUID_DOMAIN_USE_DISSOLVE ? "True" : "False");
|
||||
if (varName == "SOLVER_DIM")
|
||||
ss << mmd->domain->solver_res;
|
||||
if (varName == "DO_OPEN") {
|
||||
tmpVar = (FLUID_DOMAIN_BORDER_BACK | FLUID_DOMAIN_BORDER_FRONT | FLUID_DOMAIN_BORDER_LEFT |
|
||||
FLUID_DOMAIN_BORDER_RIGHT | FLUID_DOMAIN_BORDER_BOTTOM | FLUID_DOMAIN_BORDER_TOP);
|
||||
ss << (((mmd->domain->border_collisions & tmpVar) == tmpVar) ? "False" : "True");
|
||||
int openDomain = (FLUID_DOMAIN_BORDER_BACK | FLUID_DOMAIN_BORDER_FRONT |
|
||||
FLUID_DOMAIN_BORDER_LEFT | FLUID_DOMAIN_BORDER_RIGHT |
|
||||
FLUID_DOMAIN_BORDER_BOTTOM | FLUID_DOMAIN_BORDER_TOP);
|
||||
|
||||
std::string borderCollisions = "";
|
||||
if ((mds->border_collisions & FLUID_DOMAIN_BORDER_LEFT) == 0)
|
||||
borderCollisions += "x";
|
||||
if ((mds->border_collisions & FLUID_DOMAIN_BORDER_RIGHT) == 0)
|
||||
borderCollisions += "X";
|
||||
if ((mds->border_collisions & FLUID_DOMAIN_BORDER_FRONT) == 0)
|
||||
borderCollisions += "y";
|
||||
if ((mds->border_collisions & FLUID_DOMAIN_BORDER_BACK) == 0)
|
||||
borderCollisions += "Y";
|
||||
if ((mds->border_collisions & FLUID_DOMAIN_BORDER_BOTTOM) == 0)
|
||||
borderCollisions += "z";
|
||||
if ((mds->border_collisions & FLUID_DOMAIN_BORDER_TOP) == 0)
|
||||
borderCollisions += "Z";
|
||||
|
||||
std::string simulationMethod = "";
|
||||
if (mds->simulation_method & FLUID_DOMAIN_METHOD_FLIP)
|
||||
simulationMethod += "'FLIP'";
|
||||
else if (mds->simulation_method & FLUID_DOMAIN_METHOD_APIC)
|
||||
simulationMethod += "'APIC'";
|
||||
|
||||
std::string particleTypesStr = "";
|
||||
if (mds->particle_type & FLUID_DOMAIN_PARTICLE_SPRAY)
|
||||
particleTypesStr += "PtypeSpray";
|
||||
if (mds->particle_type & FLUID_DOMAIN_PARTICLE_BUBBLE) {
|
||||
if (!particleTypesStr.empty())
|
||||
particleTypesStr += "|";
|
||||
particleTypesStr += "PtypeBubble";
|
||||
}
|
||||
if (varName == "BOUND_CONDITIONS") {
|
||||
if (mmd->domain->solver_res == 2) {
|
||||
if ((mmd->domain->border_collisions & FLUID_DOMAIN_BORDER_LEFT) == 0)
|
||||
ss << "x";
|
||||
if ((mmd->domain->border_collisions & FLUID_DOMAIN_BORDER_RIGHT) == 0)
|
||||
ss << "X";
|
||||
if ((mmd->domain->border_collisions & FLUID_DOMAIN_BORDER_FRONT) == 0)
|
||||
ss << "y";
|
||||
if ((mmd->domain->border_collisions & FLUID_DOMAIN_BORDER_BACK) == 0)
|
||||
ss << "Y";
|
||||
}
|
||||
if (mmd->domain->solver_res == 3) {
|
||||
if ((mmd->domain->border_collisions & FLUID_DOMAIN_BORDER_LEFT) == 0)
|
||||
ss << "x";
|
||||
if ((mmd->domain->border_collisions & FLUID_DOMAIN_BORDER_RIGHT) == 0)
|
||||
ss << "X";
|
||||
if ((mmd->domain->border_collisions & FLUID_DOMAIN_BORDER_FRONT) == 0)
|
||||
ss << "y";
|
||||
if ((mmd->domain->border_collisions & FLUID_DOMAIN_BORDER_BACK) == 0)
|
||||
ss << "Y";
|
||||
if ((mmd->domain->border_collisions & FLUID_DOMAIN_BORDER_BOTTOM) == 0)
|
||||
ss << "z";
|
||||
if ((mmd->domain->border_collisions & FLUID_DOMAIN_BORDER_TOP) == 0)
|
||||
ss << "Z";
|
||||
}
|
||||
if (mds->particle_type & FLUID_DOMAIN_PARTICLE_FOAM) {
|
||||
if (!particleTypesStr.empty())
|
||||
particleTypesStr += "|";
|
||||
particleTypesStr += "PtypeFoam";
|
||||
}
|
||||
if (varName == "BOUNDARY_WIDTH")
|
||||
ss << mmd->domain->boundary_width;
|
||||
if (varName == "RES")
|
||||
ss << mMaxRes;
|
||||
if (varName == "RESX")
|
||||
ss << mResX;
|
||||
if (varName == "RESY")
|
||||
if (is2D) {
|
||||
ss << mResZ;
|
||||
}
|
||||
else {
|
||||
ss << mResY;
|
||||
}
|
||||
else if (varName == "RESZ") {
|
||||
if (is2D) {
|
||||
ss << 1;
|
||||
}
|
||||
else {
|
||||
ss << mResZ;
|
||||
}
|
||||
if (mds->particle_type & FLUID_DOMAIN_PARTICLE_TRACER) {
|
||||
if (!particleTypesStr.empty())
|
||||
particleTypesStr += "|";
|
||||
particleTypesStr += "PtypeTracer";
|
||||
}
|
||||
if (varName == "TIME_SCALE")
|
||||
ss << mmd->domain->time_scale;
|
||||
if (varName == "FRAME_LENGTH")
|
||||
ss << mmd->domain->frame_length;
|
||||
if (varName == "CFL")
|
||||
ss << mmd->domain->cfl_condition;
|
||||
if (varName == "DT")
|
||||
ss << mmd->domain->dt;
|
||||
if (varName == "TIMESTEPS_MIN")
|
||||
ss << mmd->domain->timesteps_minimum;
|
||||
if (varName == "TIMESTEPS_MAX")
|
||||
ss << mmd->domain->timesteps_maximum;
|
||||
if (varName == "TIME_TOTAL")
|
||||
ss << mmd->domain->time_total;
|
||||
if (varName == "TIME_PER_FRAME")
|
||||
ss << mmd->domain->time_per_frame;
|
||||
if (varName == "VORTICITY")
|
||||
ss << mmd->domain->vorticity / mConstantScaling;
|
||||
if (varName == "FLAME_VORTICITY")
|
||||
ss << mmd->domain->flame_vorticity / mConstantScaling;
|
||||
if (varName == "NOISE_SCALE")
|
||||
ss << mmd->domain->noise_scale;
|
||||
if (varName == "MESH_SCALE")
|
||||
ss << mmd->domain->mesh_scale;
|
||||
if (varName == "PARTICLE_SCALE")
|
||||
ss << mmd->domain->particle_scale;
|
||||
if (varName == "NOISE_RESX")
|
||||
ss << mResXNoise;
|
||||
if (varName == "NOISE_RESY") {
|
||||
if (is2D) {
|
||||
ss << mResZNoise;
|
||||
}
|
||||
else {
|
||||
ss << mResYNoise;
|
||||
}
|
||||
}
|
||||
if (varName == "NOISE_RESZ") {
|
||||
if (is2D) {
|
||||
ss << 1;
|
||||
}
|
||||
else {
|
||||
ss << mResZNoise;
|
||||
}
|
||||
}
|
||||
if (varName == "MESH_RESX")
|
||||
ss << mResXMesh;
|
||||
if (varName == "MESH_RESY") {
|
||||
if (is2D) {
|
||||
ss << mResZMesh;
|
||||
}
|
||||
else {
|
||||
ss << mResYMesh;
|
||||
}
|
||||
}
|
||||
if (varName == "MESH_RESZ") {
|
||||
if (is2D) {
|
||||
ss << 1;
|
||||
}
|
||||
else {
|
||||
ss << mResZMesh;
|
||||
}
|
||||
}
|
||||
if (varName == "PARTICLE_RESX")
|
||||
ss << mResXParticle;
|
||||
if (varName == "PARTICLE_RESY") {
|
||||
if (is2D) {
|
||||
ss << mResZParticle;
|
||||
}
|
||||
else {
|
||||
ss << mResYParticle;
|
||||
}
|
||||
}
|
||||
if (varName == "PARTICLE_RESZ") {
|
||||
if (is2D) {
|
||||
ss << 1;
|
||||
}
|
||||
else {
|
||||
ss << mResZParticle;
|
||||
}
|
||||
}
|
||||
if (varName == "GUIDING_RESX")
|
||||
ss << mResGuiding[0];
|
||||
if (varName == "GUIDING_RESY") {
|
||||
if (is2D) {
|
||||
ss << mResGuiding[2];
|
||||
}
|
||||
else {
|
||||
ss << mResGuiding[1];
|
||||
}
|
||||
}
|
||||
if (varName == "GUIDING_RESZ") {
|
||||
if (is2D) {
|
||||
ss << 1;
|
||||
}
|
||||
else {
|
||||
ss << mResGuiding[2];
|
||||
}
|
||||
}
|
||||
if (varName == "MIN_RESX")
|
||||
ss << mmd->domain->res_min[0];
|
||||
if (varName == "MIN_RESY")
|
||||
ss << mmd->domain->res_min[1];
|
||||
if (varName == "MIN_RESZ")
|
||||
ss << mmd->domain->res_min[2];
|
||||
if (varName == "BASE_RESX")
|
||||
ss << mmd->domain->base_res[0];
|
||||
if (varName == "BASE_RESY")
|
||||
ss << mmd->domain->base_res[1];
|
||||
if (varName == "BASE_RESZ")
|
||||
ss << mmd->domain->base_res[2];
|
||||
if (varName == "WLT_STR")
|
||||
ss << mmd->domain->noise_strength;
|
||||
if (varName == "NOISE_POSSCALE")
|
||||
ss << mmd->domain->noise_pos_scale;
|
||||
if (varName == "NOISE_TIMEANIM")
|
||||
ss << mmd->domain->noise_time_anim;
|
||||
if (varName == "COLOR_R")
|
||||
ss << mmd->domain->active_color[0];
|
||||
if (varName == "COLOR_G")
|
||||
ss << mmd->domain->active_color[1];
|
||||
if (varName == "COLOR_B")
|
||||
ss << mmd->domain->active_color[2];
|
||||
if (varName == "BUOYANCY_ALPHA")
|
||||
ss << mmd->domain->alpha;
|
||||
if (varName == "BUOYANCY_BETA")
|
||||
ss << mmd->domain->beta;
|
||||
if (varName == "DISSOLVE_SPEED")
|
||||
ss << mmd->domain->diss_speed;
|
||||
if (varName == "BURNING_RATE")
|
||||
ss << mmd->domain->burning_rate;
|
||||
if (varName == "FLAME_SMOKE")
|
||||
ss << mmd->domain->flame_smoke;
|
||||
if (varName == "IGNITION_TEMP")
|
||||
ss << mmd->domain->flame_ignition;
|
||||
if (varName == "MAX_TEMP")
|
||||
ss << mmd->domain->flame_max_temp;
|
||||
if (varName == "FLAME_SMOKE_COLOR_X")
|
||||
ss << mmd->domain->flame_smoke_color[0];
|
||||
if (varName == "FLAME_SMOKE_COLOR_Y")
|
||||
ss << mmd->domain->flame_smoke_color[1];
|
||||
if (varName == "FLAME_SMOKE_COLOR_Z")
|
||||
ss << mmd->domain->flame_smoke_color[2];
|
||||
if (varName == "CURRENT_FRAME")
|
||||
ss << mmd->time;
|
||||
if (varName == "START_FRAME")
|
||||
ss << mmd->domain->cache_frame_start;
|
||||
if (varName == "END_FRAME")
|
||||
ss << mmd->domain->cache_frame_end;
|
||||
if (varName == "CACHE_DATA_FORMAT")
|
||||
ss << getCacheFileEnding(mmd->domain->cache_data_format);
|
||||
if (varName == "CACHE_MESH_FORMAT")
|
||||
ss << getCacheFileEnding(mmd->domain->cache_mesh_format);
|
||||
if (varName == "CACHE_NOISE_FORMAT")
|
||||
ss << getCacheFileEnding(mmd->domain->cache_noise_format);
|
||||
if (varName == "CACHE_PARTICLE_FORMAT")
|
||||
ss << getCacheFileEnding(mmd->domain->cache_particle_format);
|
||||
if (varName == "SIMULATION_METHOD") {
|
||||
if (mmd->domain->simulation_method & FLUID_DOMAIN_METHOD_FLIP) {
|
||||
ss << "'FLIP'";
|
||||
}
|
||||
else if (mmd->domain->simulation_method & FLUID_DOMAIN_METHOD_APIC) {
|
||||
ss << "'APIC'";
|
||||
}
|
||||
else {
|
||||
ss << "'NONE'";
|
||||
}
|
||||
}
|
||||
if (varName == "FLIP_RATIO")
|
||||
ss << mmd->domain->flip_ratio;
|
||||
if (varName == "PARTICLE_RANDOMNESS")
|
||||
ss << mmd->domain->particle_randomness;
|
||||
if (varName == "PARTICLE_NUMBER")
|
||||
ss << mmd->domain->particle_number;
|
||||
if (varName == "PARTICLE_MINIMUM")
|
||||
ss << mmd->domain->particle_minimum;
|
||||
if (varName == "PARTICLE_MAXIMUM")
|
||||
ss << mmd->domain->particle_maximum;
|
||||
if (varName == "PARTICLE_RADIUS")
|
||||
ss << mmd->domain->particle_radius;
|
||||
if (varName == "FRACTIONS_THRESHOLD")
|
||||
ss << mmd->domain->fractions_threshold;
|
||||
if (varName == "MESH_CONCAVE_UPPER")
|
||||
ss << mmd->domain->mesh_concave_upper;
|
||||
if (varName == "MESH_CONCAVE_LOWER")
|
||||
ss << mmd->domain->mesh_concave_lower;
|
||||
if (varName == "MESH_PARTICLE_RADIUS")
|
||||
ss << mmd->domain->mesh_particle_radius;
|
||||
if (varName == "MESH_SMOOTHEN_POS")
|
||||
ss << mmd->domain->mesh_smoothen_pos;
|
||||
if (varName == "MESH_SMOOTHEN_NEG")
|
||||
ss << mmd->domain->mesh_smoothen_neg;
|
||||
if (varName == "USING_MESH")
|
||||
ss << (mmd->domain->flags & FLUID_DOMAIN_USE_MESH ? "True" : "False");
|
||||
if (varName == "USING_IMPROVED_MESH")
|
||||
ss << (mmd->domain->mesh_generator == FLUID_DOMAIN_MESH_IMPROVED ? "True" : "False");
|
||||
if (varName == "PARTICLE_BAND_WIDTH")
|
||||
ss << mmd->domain->particle_band_width;
|
||||
if (varName == "SNDPARTICLE_TAU_MIN_WC")
|
||||
ss << mmd->domain->sndparticle_tau_min_wc;
|
||||
if (varName == "SNDPARTICLE_TAU_MAX_WC")
|
||||
ss << mmd->domain->sndparticle_tau_max_wc;
|
||||
if (varName == "SNDPARTICLE_TAU_MIN_TA")
|
||||
ss << mmd->domain->sndparticle_tau_min_ta;
|
||||
if (varName == "SNDPARTICLE_TAU_MAX_TA")
|
||||
ss << mmd->domain->sndparticle_tau_max_ta;
|
||||
if (varName == "SNDPARTICLE_TAU_MIN_K")
|
||||
ss << mmd->domain->sndparticle_tau_min_k;
|
||||
if (varName == "SNDPARTICLE_TAU_MAX_K")
|
||||
ss << mmd->domain->sndparticle_tau_max_k;
|
||||
if (varName == "SNDPARTICLE_K_WC")
|
||||
ss << mmd->domain->sndparticle_k_wc;
|
||||
if (varName == "SNDPARTICLE_K_TA")
|
||||
ss << mmd->domain->sndparticle_k_ta;
|
||||
if (varName == "SNDPARTICLE_K_B")
|
||||
ss << mmd->domain->sndparticle_k_b;
|
||||
if (varName == "SNDPARTICLE_K_D")
|
||||
ss << mmd->domain->sndparticle_k_d;
|
||||
if (varName == "SNDPARTICLE_L_MIN")
|
||||
ss << mmd->domain->sndparticle_l_min;
|
||||
if (varName == "SNDPARTICLE_L_MAX")
|
||||
ss << mmd->domain->sndparticle_l_max;
|
||||
if (varName == "SNDPARTICLE_BOUNDARY_DELETE")
|
||||
ss << (mmd->domain->sndparticle_boundary == SNDPARTICLE_BOUNDARY_DELETE);
|
||||
if (varName == "SNDPARTICLE_BOUNDARY_PUSHOUT")
|
||||
ss << (mmd->domain->sndparticle_boundary == SNDPARTICLE_BOUNDARY_PUSHOUT);
|
||||
if (varName == "SNDPARTICLE_POTENTIAL_RADIUS")
|
||||
ss << mmd->domain->sndparticle_potential_radius;
|
||||
if (varName == "SNDPARTICLE_UPDATE_RADIUS")
|
||||
ss << mmd->domain->sndparticle_update_radius;
|
||||
if (varName == "LIQUID_SURFACE_TENSION")
|
||||
ss << mmd->domain->surface_tension;
|
||||
if (varName == "FLUID_VISCOSITY")
|
||||
ss << mmd->domain->viscosity_base * pow(10.0f, -mmd->domain->viscosity_exponent);
|
||||
if (varName == "FLUID_DOMAIN_SIZE") {
|
||||
tmpFloat = MAX3(
|
||||
mmd->domain->global_size[0], mmd->domain->global_size[1], mmd->domain->global_size[2]);
|
||||
ss << tmpFloat;
|
||||
}
|
||||
if (varName == "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";
|
||||
}
|
||||
if (varName == "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");
|
||||
}
|
||||
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();
|
||||
if (particleTypesStr.empty())
|
||||
particleTypesStr = "0";
|
||||
|
||||
int particleTypes = (FLUID_DOMAIN_PARTICLE_SPRAY | FLUID_DOMAIN_PARTICLE_BUBBLE |
|
||||
FLUID_DOMAIN_PARTICLE_FOAM | FLUID_DOMAIN_PARTICLE_TRACER);
|
||||
|
||||
std::string cacheDirectory(mds->cache_directory);
|
||||
|
||||
mRNAMap["USING_SMOKE"] = std::to_string((mds->type == FLUID_DOMAIN_TYPE_GAS) != 0);
|
||||
mRNAMap["USING_LIQUID"] = std::to_string((mds->type == FLUID_DOMAIN_TYPE_LIQUID) != 0);
|
||||
mRNAMap["USING_COLORS"] = std::to_string((mds->active_fields & FLUID_DOMAIN_ACTIVE_COLORS) != 0);
|
||||
mRNAMap["USING_HEAT"] = std::to_string((mds->active_fields & FLUID_DOMAIN_ACTIVE_HEAT) != 0);
|
||||
mRNAMap["USING_FIRE"] = std::to_string((mds->active_fields & FLUID_DOMAIN_ACTIVE_FIRE) != 0);
|
||||
mRNAMap["USING_NOISE"] = std::to_string((mds->flags & FLUID_DOMAIN_USE_NOISE) != 0);
|
||||
mRNAMap["USING_OBSTACLE"] = std::to_string((mds->active_fields & FLUID_DOMAIN_ACTIVE_OBSTACLE) !=
|
||||
0);
|
||||
mRNAMap["USING_GUIDING"] = std::to_string((mds->flags & FLUID_DOMAIN_USE_GUIDE) != 0);
|
||||
mRNAMap["USING_INVEL"] = std::to_string((mds->active_fields & FLUID_DOMAIN_ACTIVE_INVEL) != 0);
|
||||
mRNAMap["USING_OUTFLOW"] = std::to_string((mds->active_fields & FLUID_DOMAIN_ACTIVE_OUTFLOW) !=
|
||||
0);
|
||||
mRNAMap["USING_LOG_DISSOLVE"] = std::to_string((mds->flags & FLUID_DOMAIN_USE_DISSOLVE_LOG) !=
|
||||
0);
|
||||
mRNAMap["USING_DISSOLVE"] = std::to_string((mds->flags & FLUID_DOMAIN_USE_DISSOLVE) != 0);
|
||||
mRNAMap["SOLVER_DIM"] = std::to_string(mds->solver_res);
|
||||
mRNAMap["DO_OPEN"] = std::to_string(((mds->border_collisions & openDomain) == openDomain) == 0);
|
||||
mRNAMap["BOUND_CONDITIONS"] = borderCollisions;
|
||||
mRNAMap["BOUNDARY_WIDTH"] = std::to_string(mds->boundary_width);
|
||||
mRNAMap["RES"] = std::to_string(mMaxRes);
|
||||
mRNAMap["RESX"] = std::to_string(mResX);
|
||||
mRNAMap["RESY"] = (is2D) ? std::to_string(mResZ) : std::to_string(mResY);
|
||||
mRNAMap["RESZ"] = (is2D) ? std::to_string(1) : std::to_string(mResZ);
|
||||
mRNAMap["TIME_SCALE"] = std::to_string(mds->time_scale);
|
||||
mRNAMap["FRAME_LENGTH"] = std::to_string(mds->frame_length);
|
||||
mRNAMap["CFL"] = std::to_string(mds->cfl_condition);
|
||||
mRNAMap["DT"] = std::to_string(mds->dt);
|
||||
mRNAMap["TIMESTEPS_MIN"] = std::to_string(mds->timesteps_minimum);
|
||||
mRNAMap["TIMESTEPS_MAX"] = std::to_string(mds->timesteps_maximum);
|
||||
mRNAMap["TIME_TOTAL"] = std::to_string(mds->time_total);
|
||||
mRNAMap["TIME_PER_FRAME"] = std::to_string(mds->time_per_frame);
|
||||
mRNAMap["VORTICITY"] = std::to_string(mds->vorticity);
|
||||
mRNAMap["FLAME_VORTICITY"] = std::to_string(mds->flame_vorticity);
|
||||
mRNAMap["NOISE_SCALE"] = std::to_string(mds->noise_scale);
|
||||
mRNAMap["MESH_SCALE"] = std::to_string(mds->mesh_scale);
|
||||
mRNAMap["PARTICLE_SCALE"] = std::to_string(mds->particle_scale);
|
||||
mRNAMap["NOISE_RESX"] = std::to_string(mResXNoise);
|
||||
mRNAMap["NOISE_RESY"] = (is2D) ? std::to_string(mResZNoise) : std::to_string(mResYNoise);
|
||||
mRNAMap["NOISE_RESZ"] = (is2D) ? std::to_string(1) : std::to_string(mResZNoise);
|
||||
mRNAMap["MESH_RESX"] = std::to_string(mResXMesh);
|
||||
mRNAMap["MESH_RESY"] = (is2D) ? std::to_string(mResZMesh) : std::to_string(mResYMesh);
|
||||
mRNAMap["MESH_RESZ"] = (is2D) ? std::to_string(1) : std::to_string(mResZMesh);
|
||||
mRNAMap["PARTICLE_RESX"] = std::to_string(mResXParticle);
|
||||
mRNAMap["PARTICLE_RESY"] = (is2D) ? std::to_string(mResZParticle) :
|
||||
std::to_string(mResYParticle);
|
||||
mRNAMap["PARTICLE_RESZ"] = (is2D) ? std::to_string(1) : std::to_string(mResZParticle);
|
||||
mRNAMap["GUIDING_RESX"] = std::to_string(mResGuiding[0]);
|
||||
mRNAMap["GUIDING_RESY"] = (is2D) ? std::to_string(mResGuiding[2]) :
|
||||
std::to_string(mResGuiding[1]);
|
||||
mRNAMap["GUIDING_RESZ"] = (is2D) ? std::to_string(1) : std::to_string(mResGuiding[2]);
|
||||
mRNAMap["MIN_RESX"] = std::to_string(mds->res_min[0]);
|
||||
mRNAMap["MIN_RESY"] = std::to_string(mds->res_min[1]);
|
||||
mRNAMap["MIN_RESZ"] = std::to_string(mds->res_min[2]);
|
||||
mRNAMap["BASE_RESX"] = std::to_string(mds->base_res[0]);
|
||||
mRNAMap["BASE_RESY"] = std::to_string(mds->base_res[1]);
|
||||
mRNAMap["BASE_RESZ"] = std::to_string(mds->base_res[2]);
|
||||
mRNAMap["WLT_STR"] = std::to_string(mds->noise_strength);
|
||||
mRNAMap["NOISE_POSSCALE"] = std::to_string(mds->noise_pos_scale);
|
||||
mRNAMap["NOISE_TIMEANIM"] = std::to_string(mds->noise_time_anim);
|
||||
mRNAMap["COLOR_R"] = std::to_string(mds->active_color[0]);
|
||||
mRNAMap["COLOR_G"] = std::to_string(mds->active_color[1]);
|
||||
mRNAMap["COLOR_B"] = std::to_string(mds->active_color[2]);
|
||||
mRNAMap["BUOYANCY_ALPHA"] = std::to_string(mds->alpha);
|
||||
mRNAMap["BUOYANCY_BETA"] = std::to_string(mds->beta);
|
||||
mRNAMap["DISSOLVE_SPEED"] = std::to_string(mds->diss_speed);
|
||||
mRNAMap["BURNING_RATE"] = std::to_string(mds->burning_rate);
|
||||
mRNAMap["FLAME_SMOKE"] = std::to_string(mds->flame_smoke);
|
||||
mRNAMap["IGNITION_TEMP"] = std::to_string(mds->flame_ignition);
|
||||
mRNAMap["MAX_TEMP"] = std::to_string(mds->flame_max_temp);
|
||||
mRNAMap["FLAME_SMOKE_COLOR_X"] = std::to_string(mds->flame_smoke_color[0]);
|
||||
mRNAMap["FLAME_SMOKE_COLOR_Y"] = std::to_string(mds->flame_smoke_color[1]);
|
||||
mRNAMap["FLAME_SMOKE_COLOR_Z"] = std::to_string(mds->flame_smoke_color[2]);
|
||||
mRNAMap["CURRENT_FRAME"] = std::to_string(mmd->time);
|
||||
mRNAMap["START_FRAME"] = std::to_string(mds->cache_frame_start);
|
||||
mRNAMap["END_FRAME"] = std::to_string(mds->cache_frame_end);
|
||||
mRNAMap["CACHE_DATA_FORMAT"] = std::to_string(mds->cache_data_format);
|
||||
mRNAMap["CACHE_MESH_FORMAT"] = std::to_string(mds->cache_mesh_format);
|
||||
mRNAMap["CACHE_NOISE_FORMAT"] = std::to_string(mds->cache_noise_format);
|
||||
mRNAMap["CACHE_PARTICLE_FORMAT"] = std::to_string(mds->cache_particle_format);
|
||||
mRNAMap["SIMULATION_METHOD"] = simulationMethod;
|
||||
mRNAMap["FLIP_RATIO"] = std::to_string(mds->flip_ratio);
|
||||
mRNAMap["PARTICLE_RANDOMNESS"] = std::to_string(mds->particle_randomness);
|
||||
mRNAMap["PARTICLE_NUMBER"] = std::to_string(mds->particle_number);
|
||||
mRNAMap["PARTICLE_MINIMUM"] = std::to_string(mds->particle_minimum);
|
||||
mRNAMap["PARTICLE_MAXIMUM"] = std::to_string(mds->particle_maximum);
|
||||
mRNAMap["PARTICLE_RADIUS"] = std::to_string(mds->particle_radius);
|
||||
mRNAMap["FRACTIONS_THRESHOLD"] = std::to_string(mds->fractions_threshold);
|
||||
mRNAMap["MESH_CONCAVE_UPPER"] = std::to_string(mds->mesh_concave_upper);
|
||||
mRNAMap["MESH_CONCAVE_LOWER"] = std::to_string(mds->mesh_concave_lower);
|
||||
mRNAMap["MESH_PARTICLE_RADIUS"] = std::to_string(mds->mesh_particle_radius);
|
||||
mRNAMap["MESH_SMOOTHEN_POS"] = std::to_string(mds->mesh_smoothen_pos);
|
||||
mRNAMap["MESH_SMOOTHEN_NEG"] = std::to_string(mds->mesh_smoothen_neg);
|
||||
mRNAMap["USING_MESH"] = std::to_string((mds->flags & FLUID_DOMAIN_USE_MESH) != 0);
|
||||
mRNAMap["USING_IMPROVED_MESH"] = std::to_string(
|
||||
(mds->mesh_generator == FLUID_DOMAIN_MESH_IMPROVED) != 0);
|
||||
mRNAMap["PARTICLE_BAND_WIDTH"] = std::to_string(mds->particle_band_width);
|
||||
mRNAMap["SNDPARTICLE_TAU_MIN_WC"] = std::to_string(mds->sndparticle_tau_min_wc);
|
||||
mRNAMap["SNDPARTICLE_TAU_MAX_WC"] = std::to_string(mds->sndparticle_tau_max_wc);
|
||||
mRNAMap["SNDPARTICLE_TAU_MIN_TA"] = std::to_string(mds->sndparticle_tau_min_ta);
|
||||
mRNAMap["SNDPARTICLE_TAU_MAX_TA"] = std::to_string(mds->sndparticle_tau_max_ta);
|
||||
mRNAMap["SNDPARTICLE_TAU_MIN_K"] = std::to_string(mds->sndparticle_tau_min_k);
|
||||
mRNAMap["SNDPARTICLE_TAU_MAX_K"] = std::to_string(mds->sndparticle_tau_max_k);
|
||||
mRNAMap["SNDPARTICLE_K_WC"] = std::to_string(mds->sndparticle_k_wc);
|
||||
mRNAMap["SNDPARTICLE_K_TA"] = std::to_string(mds->sndparticle_k_ta);
|
||||
mRNAMap["SNDPARTICLE_K_B"] = std::to_string(mds->sndparticle_k_b);
|
||||
mRNAMap["SNDPARTICLE_K_D"] = std::to_string(mds->sndparticle_k_d);
|
||||
mRNAMap["SNDPARTICLE_L_MIN"] = std::to_string(mds->sndparticle_l_min);
|
||||
mRNAMap["SNDPARTICLE_L_MAX"] = std::to_string(mds->sndparticle_l_max);
|
||||
mRNAMap["SNDPARTICLE_BOUNDARY_DELETE"] = std::to_string(
|
||||
(mds->sndparticle_boundary == SNDPARTICLE_BOUNDARY_DELETE) != 0);
|
||||
mRNAMap["SNDPARTICLE_BOUNDARY_PUSHOUT"] = std::to_string(
|
||||
(mds->sndparticle_boundary == SNDPARTICLE_BOUNDARY_PUSHOUT) != 0);
|
||||
mRNAMap["SNDPARTICLE_POTENTIAL_RADIUS"] = std::to_string(mds->sndparticle_potential_radius);
|
||||
mRNAMap["SNDPARTICLE_UPDATE_RADIUS"] = std::to_string(mds->sndparticle_update_radius);
|
||||
mRNAMap["LIQUID_SURFACE_TENSION"] = std::to_string(mds->surface_tension);
|
||||
mRNAMap["FLUID_VISCOSITY"] = std::to_string(mds->viscosity_base *
|
||||
pow(10.0f, -mds->viscosity_exponent));
|
||||
mRNAMap["FLUID_DOMAIN_SIZE"] = std::to_string(
|
||||
MAX3(mds->global_size[0], mds->global_size[1], mds->global_size[2]));
|
||||
mRNAMap["SNDPARTICLE_TYPES"] = particleTypesStr;
|
||||
mRNAMap["USING_SNDPARTS"] = std::to_string((mds->particle_type & particleTypes) != 0);
|
||||
mRNAMap["GUIDING_ALPHA"] = std::to_string(mds->guide_alpha);
|
||||
mRNAMap["GUIDING_BETA"] = std::to_string(mds->guide_beta);
|
||||
mRNAMap["GUIDING_FACTOR"] = std::to_string(mds->guide_vel_factor);
|
||||
mRNAMap["GRAVITY_X"] = std::to_string(mds->gravity[0]);
|
||||
mRNAMap["GRAVITY_Y"] = std::to_string(mds->gravity[1]);
|
||||
mRNAMap["GRAVITY_Z"] = std::to_string(mds->gravity[2]);
|
||||
mRNAMap["CACHE_DIR"] = cacheDirectory;
|
||||
mRNAMap["CACHE_RESUMABLE"] = std::to_string((mds->cache_type == FLUID_DOMAIN_CACHE_FINAL) == 0);
|
||||
mRNAMap["USING_ADAPTIVETIME"] = std::to_string((mds->flags & FLUID_DOMAIN_USE_ADAPTIVE_TIME) !=
|
||||
0);
|
||||
mRNAMap["USING_SPEEDVECTORS"] = std::to_string((mds->flags & FLUID_DOMAIN_USE_SPEED_VECTORS) !=
|
||||
0);
|
||||
mRNAMap["USING_FRACTIONS"] = std::to_string((mds->flags & FLUID_DOMAIN_USE_FRACTIONS) != 0);
|
||||
mRNAMap["DELETE_IN_OBSTACLE"] = std::to_string((mds->flags & FLUID_DOMAIN_DELETE_IN_OBSTACLE) !=
|
||||
0);
|
||||
mRNAMap["USING_DIFFUSION"] = std::to_string((mds->flags & FLUID_DOMAIN_USE_DIFFUSION) != 0);
|
||||
}
|
||||
|
||||
std::string MANTA::parseLine(const std::string &line, FluidModifierData *mmd)
|
||||
std::string MANTA::getRealValue(const std::string &varName)
|
||||
{
|
||||
if (with_debug)
|
||||
std::cout << "MANTA::getRealValue()" << std::endl;
|
||||
|
||||
std::unordered_map<std::string, std::string>::iterator it;
|
||||
it = mRNAMap.find(varName);
|
||||
|
||||
if (it == mRNAMap.end()) {
|
||||
std::cerr << "Fluid Error -- variable " << varName << " not found in RNA map " << it->second
|
||||
<< std::endl;
|
||||
return "";
|
||||
}
|
||||
if (with_debug) {
|
||||
std::cout << "Found variable " << varName << " with value " << it->second << std::endl;
|
||||
}
|
||||
|
||||
return it->second;
|
||||
}
|
||||
|
||||
std::string MANTA::parseLine(const std::string &line)
|
||||
{
|
||||
if (line.size() == 0)
|
||||
return "";
|
||||
|
|
@ -1024,7 +861,7 @@ std::string MANTA::parseLine(const std::string &line, FluidModifierData *mmd)
|
|||
else if (line[currPos] == delimiter && readingVar) {
|
||||
readingVar = false;
|
||||
end_del = currPos;
|
||||
res += getRealValue(line.substr(start_del, currPos - start_del), mmd);
|
||||
res += getRealValue(line.substr(start_del, currPos - start_del));
|
||||
}
|
||||
currPos++;
|
||||
}
|
||||
|
|
@ -1034,11 +871,19 @@ std::string MANTA::parseLine(const std::string &line, FluidModifierData *mmd)
|
|||
|
||||
std::string MANTA::parseScript(const std::string &setup_string, FluidModifierData *mmd)
|
||||
{
|
||||
if (MANTA::with_debug)
|
||||
std::cout << "MANTA::parseScript()" << std::endl;
|
||||
|
||||
std::istringstream f(setup_string);
|
||||
std::ostringstream res;
|
||||
std::string line = "";
|
||||
|
||||
// Update RNA map if modifier data is handed over
|
||||
if (mmd) {
|
||||
initializeRNAMap(mmd);
|
||||
}
|
||||
while (getline(f, line)) {
|
||||
res << parseLine(line, mmd) << "\n";
|
||||
res << parseLine(line) << "\n";
|
||||
}
|
||||
return res.str();
|
||||
}
|
||||
|
|
|
|||
|
|
@ -27,6 +27,7 @@
|
|||
#include <atomic>
|
||||
#include <cassert>
|
||||
#include <string>
|
||||
#include <unordered_map>
|
||||
#include <vector>
|
||||
|
||||
struct MANTA {
|
||||
|
|
@ -58,20 +59,20 @@ struct MANTA {
|
|||
void step(struct FluidModifierData *mmd, int startFrame);
|
||||
|
||||
// Grid initialization functions
|
||||
void initHeat(struct FluidModifierData *mmd);
|
||||
void initFire(struct FluidModifierData *mmd);
|
||||
void initColors(struct FluidModifierData *mmd);
|
||||
void initFireHigh(struct FluidModifierData *mmd);
|
||||
void initColorsHigh(struct FluidModifierData *mmd);
|
||||
void initLiquid(FluidModifierData *mmd);
|
||||
void initLiquidMesh(FluidModifierData *mmd);
|
||||
void initObstacle(FluidModifierData *mmd);
|
||||
void initGuiding(FluidModifierData *mmd);
|
||||
void initFractions(FluidModifierData *mmd);
|
||||
void initInVelocity(FluidModifierData *mmd);
|
||||
void initOutflow(FluidModifierData *mmd);
|
||||
void initSndParts(FluidModifierData *mmd);
|
||||
void initLiquidSndParts(FluidModifierData *mmd);
|
||||
void initHeat(struct FluidModifierData *mmd = NULL);
|
||||
void initFire(struct FluidModifierData *mmd = NULL);
|
||||
void initColors(struct FluidModifierData *mmd = NULL);
|
||||
void initFireHigh(struct FluidModifierData *mmd = NULL);
|
||||
void initColorsHigh(struct FluidModifierData *mmd = NULL);
|
||||
void initLiquid(FluidModifierData *mmd = NULL);
|
||||
void initLiquidMesh(FluidModifierData *mmd = NULL);
|
||||
void initObstacle(FluidModifierData *mmd = NULL);
|
||||
void initGuiding(FluidModifierData *mmd = NULL);
|
||||
void initFractions(FluidModifierData *mmd = NULL);
|
||||
void initInVelocity(FluidModifierData *mmd = NULL);
|
||||
void initOutflow(FluidModifierData *mmd = NULL);
|
||||
void initSndParts(FluidModifierData *mmd = NULL);
|
||||
void initLiquidSndParts(FluidModifierData *mmd = NULL);
|
||||
|
||||
// Pointer transfer: Mantaflow -> Blender
|
||||
void updatePointers();
|
||||
|
|
@ -741,6 +742,8 @@ struct MANTA {
|
|||
size_t mTotalCellsMesh;
|
||||
size_t mTotalCellsParticles;
|
||||
|
||||
std::unordered_map<std::string, std::string> mRNAMap;
|
||||
|
||||
int mCurrentID;
|
||||
|
||||
bool mUsingHeat;
|
||||
|
|
@ -864,16 +867,17 @@ struct MANTA {
|
|||
std::vector<pVel> *mSndParticleVelocity;
|
||||
std::vector<float> *mSndParticleLife;
|
||||
|
||||
void initDomain(struct FluidModifierData *mmd);
|
||||
void initNoise(struct FluidModifierData *mmd);
|
||||
void initMesh(struct FluidModifierData *mmd);
|
||||
void initSmoke(struct FluidModifierData *mmd);
|
||||
void initSmokeNoise(struct FluidModifierData *mmd);
|
||||
void initializeRNAMap(struct FluidModifierData *mmd = NULL);
|
||||
void initDomain(struct FluidModifierData *mmd = NULL);
|
||||
void initNoise(struct FluidModifierData *mmd = NULL);
|
||||
void initMesh(struct FluidModifierData *mmd = NULL);
|
||||
void initSmoke(struct FluidModifierData *mmd = NULL);
|
||||
void initSmokeNoise(struct FluidModifierData *mmd = NULL);
|
||||
void initializeMantaflow();
|
||||
void terminateMantaflow();
|
||||
bool runPythonString(std::vector<std::string> commands);
|
||||
std::string getRealValue(const std::string &varName, FluidModifierData *mmd);
|
||||
std::string parseLine(const std::string &line, FluidModifierData *mmd);
|
||||
std::string getRealValue(const std::string &varName);
|
||||
std::string parseLine(const std::string &line);
|
||||
std::string parseScript(const std::string &setup_string, FluidModifierData *mmd = NULL);
|
||||
bool updateMeshFromBobj(std::string filename);
|
||||
bool updateMeshFromObj(std::string filename);
|
||||
|
|
|
|||
Loading…
Reference in New Issue