From 99ee1de094a1744391a1bcddec56e53e3d180c4e Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Sebasti=C3=A1n=20Barschkis?= Date: Sun, 3 May 2020 18:33:34 +0200 Subject: Fluid: Refactored 'Modifier Data to Python' value transfer function This function needed a bigger cleanup, especially after the problem from T76276. --- intern/mantaflow/intern/MANTA_main.cpp | 673 +++++++++++++-------------------- intern/mantaflow/intern/MANTA_main.h | 46 ++- 2 files changed, 284 insertions(+), 435 deletions(-) (limited to 'intern/mantaflow') diff --git a/intern/mantaflow/intern/MANTA_main.cpp b/intern/mantaflow/intern/MANTA_main.cpp index c1ac3d3a22d..1e32548bee2 100644 --- a/intern/mantaflow/intern/MANTA_main.cpp +++ b/intern/mantaflow/intern/MANTA_main.cpp @@ -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(); - } - - is2D = (mmd->domain->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"); - } - 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 (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 (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 (with_debug) + std::cout << "No modifier data given in RNA map setup - returning early" << std::endl; + return; } - if (varName == "GUIDING_RESZ") { - if (is2D) { - ss << 1; - } - else { - ss << mResGuiding[2]; - } + + FluidDomainSettings *mds = mmd->domain; + bool is2D = (mds->solver_res == 2); + + 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 (mds->particle_type & FLUID_DOMAIN_PARTICLE_FOAM) { + if (!particleTypesStr.empty()) + particleTypesStr += "|"; + particleTypesStr += "PtypeFoam"; + } + if (mds->particle_type & FLUID_DOMAIN_PARTICLE_TRACER) { + if (!particleTypesStr.empty()) + particleTypesStr += "|"; + particleTypesStr += "PtypeTracer"; + } + 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::getRealValue(const std::string &varName) +{ + if (with_debug) + std::cout << "MANTA::getRealValue()" << std::endl; + + std::unordered_map::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 (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 (with_debug) { + std::cout << "Found variable " << varName << " with value " << it->second << std::endl; } - 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(); -} - -std::string MANTA::parseLine(const std::string &line, FluidModifierData *mmd) + + 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(); } diff --git a/intern/mantaflow/intern/MANTA_main.h b/intern/mantaflow/intern/MANTA_main.h index 21946431f28..5760e31d28d 100644 --- a/intern/mantaflow/intern/MANTA_main.h +++ b/intern/mantaflow/intern/MANTA_main.h @@ -27,6 +27,7 @@ #include #include #include +#include #include 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 mRNAMap; + int mCurrentID; bool mUsingHeat; @@ -864,16 +867,17 @@ struct MANTA { std::vector *mSndParticleVelocity; std::vector *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 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); -- cgit v1.2.3