blender
/
blender
129
397
Fork 571
Code Issues 6.2k Pull Requests 752 Projects 19 Wiki Activity

Cleanup: Fluid renaming from old 'manta' naming to new 'fluid' naming 

Changed variable names from mmd, mds, mfs, and mes to fmd, fds, ffs, and fes. The author of this commits lights a candle for all the merge conflicts this will cause.
This commit is contained in:
Sebastián Barschkis 2020-07-03 11:51:15 +02:00
parent 868d6ba1a7
commit b1d3850333
28 changed files with 2615 additions and 2615 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

64
intern/mantaflow/extern/manta_fluid_API.h vendored
View File

@ -31,52 +31,52 @@ extern "C" {
struct MANTA;
/* Fluid functions */
struct MANTA *manta_init(int *res, struct FluidModifierData *mmd);
struct MANTA *manta_init(int *res, struct FluidModifierData *fmd);
void manta_free(struct MANTA *fluid);
void manta_ensure_obstacle(struct MANTA *fluid, struct FluidModifierData *mmd);
void manta_ensure_guiding(struct MANTA *fluid, struct FluidModifierData *mmd);
void manta_ensure_invelocity(struct MANTA *fluid, struct FluidModifierData *mmd);
void manta_ensure_outflow(struct MANTA *fluid, struct FluidModifierData *mmd);
int manta_write_config(struct MANTA *fluid, struct FluidModifierData *mmd, int framenr);
int manta_write_data(struct MANTA *fluid, struct FluidModifierData *mmd, int framenr);
int manta_write_noise(struct MANTA *fluid, struct FluidModifierData *mmd, int framenr);
int manta_read_config(struct MANTA *fluid, struct FluidModifierData *mmd, int framenr);
void manta_ensure_obstacle(struct MANTA *fluid, struct FluidModifierData *fmd);
void manta_ensure_guiding(struct MANTA *fluid, struct FluidModifierData *fmd);
void manta_ensure_invelocity(struct MANTA *fluid, struct FluidModifierData *fmd);
void manta_ensure_outflow(struct MANTA *fluid, struct FluidModifierData *fmd);
int manta_write_config(struct MANTA *fluid, struct FluidModifierData *fmd, int framenr);
int manta_write_data(struct MANTA *fluid, struct FluidModifierData *fmd, int framenr);
int manta_write_noise(struct MANTA *fluid, struct FluidModifierData *fmd, int framenr);
int manta_read_config(struct MANTA *fluid, struct FluidModifierData *fmd, int framenr);
int manta_read_data(struct MANTA *fluid,
struct FluidModifierData *mmd,
struct FluidModifierData *fmd,
int framenr,
bool resumable);
int manta_read_noise(struct MANTA *fluid,
struct FluidModifierData *mmd,
struct FluidModifierData *fmd,
int framenr,
bool resumable);
int manta_read_mesh(struct MANTA *fluid, struct FluidModifierData *mmd, int framenr);
int manta_read_mesh(struct MANTA *fluid, struct FluidModifierData *fmd, int framenr);
int manta_read_particles(struct MANTA *fluid,
struct FluidModifierData *mmd,
struct FluidModifierData *fmd,
int framenr,
bool resumable);
int manta_read_guiding(struct MANTA *fluid,
struct FluidModifierData *mmd,
struct FluidModifierData *fmd,
int framenr,
bool sourceDomain);
int manta_bake_data(struct MANTA *fluid, struct FluidModifierData *mmd, int framenr);
int manta_bake_noise(struct MANTA *fluid, struct FluidModifierData *mmd, int framenr);
int manta_bake_mesh(struct MANTA *fluid, struct FluidModifierData *mmd, int framenr);
int manta_bake_particles(struct MANTA *fluid, struct FluidModifierData *mmd, int framenr);
int manta_bake_guiding(struct MANTA *fluid, struct FluidModifierData *mmd, int framenr);
int manta_has_data(struct MANTA *fluid, struct FluidModifierData *mmd, int framenr);
int manta_has_noise(struct MANTA *fluid, struct FluidModifierData *mmd, int framenr);
int manta_has_mesh(struct MANTA *fluid, struct FluidModifierData *mmd, int framenr);
int manta_has_particles(struct MANTA *fluid, struct FluidModifierData *mmd, int framenr);
int manta_bake_data(struct MANTA *fluid, struct FluidModifierData *fmd, int framenr);
int manta_bake_noise(struct MANTA *fluid, struct FluidModifierData *fmd, int framenr);
int manta_bake_mesh(struct MANTA *fluid, struct FluidModifierData *fmd, int framenr);
int manta_bake_particles(struct MANTA *fluid, struct FluidModifierData *fmd, int framenr);
int manta_bake_guiding(struct MANTA *fluid, struct FluidModifierData *fmd, int framenr);
int manta_has_data(struct MANTA *fluid, struct FluidModifierData *fmd, int framenr);
int manta_has_noise(struct MANTA *fluid, struct FluidModifierData *fmd, int framenr);
int manta_has_mesh(struct MANTA *fluid, struct FluidModifierData *fmd, int framenr);
int manta_has_particles(struct MANTA *fluid, struct FluidModifierData *fmd, int framenr);
int manta_has_guiding(struct MANTA *fluid,
struct FluidModifierData *mmd,
struct FluidModifierData *fmd,
int framenr,
bool domain);
void manta_update_variables(struct MANTA *fluid, struct FluidModifierData *mmd);
void manta_update_variables(struct MANTA *fluid, struct FluidModifierData *fmd);
int manta_get_frame(struct MANTA *fluid);
float manta_get_timestep(struct MANTA *fluid);
void manta_adapt_timestep(struct MANTA *fluid);
bool manta_needs_realloc(struct MANTA *fluid, struct FluidModifierData *mmd);
bool manta_needs_realloc(struct MANTA *fluid, struct FluidModifierData *fmd);
/* Fluid accessors */
size_t manta_get_index(int x, int max_x, int y, int max_y, int z /*, int max_z */);
@ -110,7 +110,7 @@ float *manta_get_phiout_in(struct MANTA *fluid);
float *manta_get_phioutstatic_in(struct MANTA *fluid);
/* Smoke functions */
void manta_smoke_export_script(struct MANTA *smoke, struct FluidModifierData *mmd);
void manta_smoke_export_script(struct MANTA *smoke, struct FluidModifierData *fmd);
void manta_smoke_export(struct MANTA *smoke,
float *dt,
float *dx,
@ -151,9 +151,9 @@ void manta_smoke_turbulence_get_rgba_fixed_color(struct MANTA *smoke,
float color[3],
float *data,
int sequential);
void manta_smoke_ensure_heat(struct MANTA *smoke, struct FluidModifierData *mmd);
void manta_smoke_ensure_fire(struct MANTA *smoke, struct FluidModifierData *mmd);
void manta_smoke_ensure_colors(struct MANTA *smoke, struct FluidModifierData *mmd);
void manta_smoke_ensure_heat(struct MANTA *smoke, struct FluidModifierData *fmd);
void manta_smoke_ensure_fire(struct MANTA *smoke, struct FluidModifierData *fmd);
void manta_smoke_ensure_colors(struct MANTA *smoke, struct FluidModifierData *fmd);
/* Smoke accessors */
float *manta_smoke_get_density(struct MANTA *smoke);
@ -190,8 +190,8 @@ void manta_smoke_turbulence_get_res(struct MANTA *smoke, int *res);
int manta_smoke_turbulence_get_cells(struct MANTA *smoke);
/* Liquid functions */
void manta_liquid_export_script(struct MANTA *smoke, struct FluidModifierData *mmd);
void manta_liquid_ensure_sndparts(struct MANTA *fluid, struct FluidModifierData *mmd);
void manta_liquid_export_script(struct MANTA *smoke, struct FluidModifierData *fmd);
void manta_liquid_ensure_sndparts(struct MANTA *fluid, struct FluidModifierData *fmd);
/* Liquid accessors */
int manta_liquid_get_particle_res_x(struct MANTA *liquid);

730
intern/mantaflow/intern/MANTA_main.cpp
View File

File diff suppressed because it is too large Load Diff

110
intern/mantaflow/intern/MANTA_main.h
View File

@ -37,7 +37,7 @@ using std::vector;
struct MANTA {
public:
MANTA(int *res, struct FluidModifierData *mmd);
MANTA(int *res, struct FluidModifierData *fmd);
MANTA(){};
virtual ~MANTA();
@ -61,68 +61,68 @@ struct MANTA {
} Triangle;
// Manta step, handling everything
void step(struct FluidModifierData *mmd, int startFrame);
void step(struct FluidModifierData *fmd, int startFrame);
// Grid initialization functions
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 initCurvature(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);
void initHeat(struct FluidModifierData *fmd = NULL);
void initFire(struct FluidModifierData *fmd = NULL);
void initColors(struct FluidModifierData *fmd = NULL);
void initFireHigh(struct FluidModifierData *fmd = NULL);
void initColorsHigh(struct FluidModifierData *fmd = NULL);
void initLiquid(FluidModifierData *fmd = NULL);
void initLiquidMesh(FluidModifierData *fmd = NULL);
void initObstacle(FluidModifierData *fmd = NULL);
void initCurvature(FluidModifierData *fmd = NULL);
void initGuiding(FluidModifierData *fmd = NULL);
void initFractions(FluidModifierData *fmd = NULL);
void initInVelocity(FluidModifierData *fmd = NULL);
void initOutflow(FluidModifierData *fmd = NULL);
void initSndParts(FluidModifierData *fmd = NULL);
void initLiquidSndParts(FluidModifierData *fmd = NULL);
// Pointer transfer: Mantaflow -> Blender
void updatePointers();
// Write cache
bool writeConfiguration(FluidModifierData *mmd, int framenr);
bool writeData(FluidModifierData *mmd, int framenr);
bool writeNoise(FluidModifierData *mmd, int framenr);
bool writeConfiguration(FluidModifierData *fmd, int framenr);
bool writeData(FluidModifierData *fmd, int framenr);
bool writeNoise(FluidModifierData *fmd, int framenr);
// write calls for mesh and particles were left in bake calls for now
// Read cache (via Manta save/load)
bool readConfiguration(FluidModifierData *mmd, int framenr);
bool readData(FluidModifierData *mmd, int framenr, bool resumable);
bool readNoise(FluidModifierData *mmd, int framenr, bool resumable);
bool readMesh(FluidModifierData *mmd, int framenr);
bool readParticles(FluidModifierData *mmd, int framenr, bool resumable);
bool readGuiding(FluidModifierData *mmd, int framenr, bool sourceDomain);
bool readConfiguration(FluidModifierData *fmd, int framenr);
bool readData(FluidModifierData *fmd, int framenr, bool resumable);
bool readNoise(FluidModifierData *fmd, int framenr, bool resumable);
bool readMesh(FluidModifierData *fmd, int framenr);
bool readParticles(FluidModifierData *fmd, int framenr, bool resumable);
bool readGuiding(FluidModifierData *fmd, int framenr, bool sourceDomain);
// Read cache (via file read functions in MANTA - e.g. read .bobj.gz meshes, .uni particles)
bool updateMeshStructures(FluidModifierData *mmd, int framenr);
bool updateFlipStructures(FluidModifierData *mmd, int framenr);
bool updateParticleStructures(FluidModifierData *mmd, int framenr);
bool updateSmokeStructures(FluidModifierData *mmd, int framenr);
bool updateNoiseStructures(FluidModifierData *mmd, int framenr);
bool updateVariables(FluidModifierData *mmd);
bool updateMeshStructures(FluidModifierData *fmd, int framenr);
bool updateFlipStructures(FluidModifierData *fmd, int framenr);
bool updateParticleStructures(FluidModifierData *fmd, int framenr);
bool updateSmokeStructures(FluidModifierData *fmd, int framenr);
bool updateNoiseStructures(FluidModifierData *fmd, int framenr);
bool updateVariables(FluidModifierData *fmd);
// Bake cache
bool bakeData(FluidModifierData *mmd, int framenr);
bool bakeNoise(FluidModifierData *mmd, int framenr);
bool bakeMesh(FluidModifierData *mmd, int framenr);
bool bakeParticles(FluidModifierData *mmd, int framenr);
bool bakeGuiding(FluidModifierData *mmd, int framenr);
bool bakeData(FluidModifierData *fmd, int framenr);
bool bakeNoise(FluidModifierData *fmd, int framenr);
bool bakeMesh(FluidModifierData *fmd, int framenr);
bool bakeParticles(FluidModifierData *fmd, int framenr);
bool bakeGuiding(FluidModifierData *fmd, int framenr);
// IO for Mantaflow scene script
void exportSmokeScript(struct FluidModifierData *mmd);
void exportLiquidScript(struct FluidModifierData *mmd);
void exportSmokeScript(struct FluidModifierData *fmd);
void exportLiquidScript(struct FluidModifierData *fmd);
// Check cache status by frame
bool hasConfig(FluidModifierData *mmd, int framenr);
bool hasData(FluidModifierData *mmd, int framenr);
bool hasNoise(FluidModifierData *mmd, int framenr);
bool hasMesh(FluidModifierData *mmd, int framenr);
bool hasParticles(FluidModifierData *mmd, int framenr);
bool hasGuiding(FluidModifierData *mmd, int framenr, bool sourceDomain);
bool hasConfig(FluidModifierData *fmd, int framenr);
bool hasData(FluidModifierData *fmd, int framenr);
bool hasNoise(FluidModifierData *fmd, int framenr);
bool hasMesh(FluidModifierData *fmd, int framenr);
bool hasParticles(FluidModifierData *fmd, int framenr);
bool hasGuiding(FluidModifierData *fmd, int framenr, bool sourceDomain);
inline size_t getTotalCells()
{
@ -739,7 +739,7 @@ struct MANTA {
float getTimestep();
void adaptTimestep();
bool needsRealloc(FluidModifierData *mmd);
bool needsRealloc(FluidModifierData *fmd);
private:
// simulation constants
@ -874,20 +874,20 @@ struct MANTA {
vector<pVel> *mSndParticleVelocity;
vector<float> *mSndParticleLife;
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 initializeRNAMap(struct FluidModifierData *fmd = NULL);
void initDomain(struct FluidModifierData *fmd = NULL);
void initNoise(struct FluidModifierData *fmd = NULL);
void initMesh(struct FluidModifierData *fmd = NULL);
void initSmoke(struct FluidModifierData *fmd = NULL);
void initSmokeNoise(struct FluidModifierData *fmd = NULL);
void initializeMantaflow();
void terminateMantaflow();
bool runPythonString(vector<string> commands);
string getRealValue(const string &varName);
string parseLine(const string &line);
string parseScript(const string &setup_string, FluidModifierData *mmd = NULL);
string getDirectory(struct FluidModifierData *mmd, string subdirectory);
string getFile(struct FluidModifierData *mmd,
string parseScript(const string &setup_string, FluidModifierData *fmd = NULL);
string getDirectory(struct FluidModifierData *fmd, string subdirectory);
string getFile(struct FluidModifierData *fmd,
string subdirectory,
string fname,
string extension,

174
intern/mantaflow/intern/manta_fluid_API.cpp
View File

@ -27,9 +27,9 @@
#include "manta_fluid_API.h"
/* Fluid functions */
MANTA *manta_init(int *res, struct FluidModifierData *mmd)
MANTA *manta_init(int *res, struct FluidModifierData *fmd)
{
return new MANTA(res, mmd);
return new MANTA(res, fmd);
}
void manta_free(MANTA *fluid)
{
@ -37,173 +37,173 @@ void manta_free(MANTA *fluid)
fluid = nullptr;
}
void manta_ensure_obstacle(MANTA *fluid, struct FluidModifierData *mmd)
void manta_ensure_obstacle(MANTA *fluid, struct FluidModifierData *fmd)
{
if (!fluid)
return;
fluid->initObstacle(mmd);
fluid->initObstacle(fmd);
fluid->updatePointers();
}
void manta_ensure_guiding(MANTA *fluid, struct FluidModifierData *mmd)
void manta_ensure_guiding(MANTA *fluid, struct FluidModifierData *fmd)
{
if (!fluid)
return;
fluid->initGuiding(mmd);
fluid->initGuiding(fmd);
fluid->updatePointers();
}
void manta_ensure_invelocity(MANTA *fluid, struct FluidModifierData *mmd)
void manta_ensure_invelocity(MANTA *fluid, struct FluidModifierData *fmd)
{
if (!fluid)
return;
fluid->initInVelocity(mmd);
fluid->initInVelocity(fmd);
fluid->updatePointers();
}
void manta_ensure_outflow(MANTA *fluid, struct FluidModifierData *mmd)
void manta_ensure_outflow(MANTA *fluid, struct FluidModifierData *fmd)
{
if (!fluid)
return;
fluid->initOutflow(mmd);
fluid->initOutflow(fmd);
fluid->updatePointers();
}
int manta_write_config(MANTA *fluid, FluidModifierData *mmd, int framenr)
int manta_write_config(MANTA *fluid, FluidModifierData *fmd, int framenr)
{
if (!fluid || !mmd)
if (!fluid || !fmd)
return 0;
return fluid->writeConfiguration(mmd, framenr);
return fluid->writeConfiguration(fmd, framenr);
}
int manta_write_data(MANTA *fluid, FluidModifierData *mmd, int framenr)
int manta_write_data(MANTA *fluid, FluidModifierData *fmd, int framenr)
{
if (!fluid || !mmd)
if (!fluid || !fmd)
return 0;
return fluid->writeData(mmd, framenr);
return fluid->writeData(fmd, framenr);
}
int manta_write_noise(MANTA *fluid, FluidModifierData *mmd, int framenr)
int manta_write_noise(MANTA *fluid, FluidModifierData *fmd, int framenr)
{
if (!fluid || !mmd)
if (!fluid || !fmd)
return 0;
return fluid->writeNoise(mmd, framenr);
return fluid->writeNoise(fmd, framenr);
}
int manta_read_config(MANTA *fluid, FluidModifierData *mmd, int framenr)
int manta_read_config(MANTA *fluid, FluidModifierData *fmd, int framenr)
{
if (!fluid || !mmd)
if (!fluid || !fmd)
return 0;
return fluid->readConfiguration(mmd, framenr);
return fluid->readConfiguration(fmd, framenr);
}
int manta_read_data(MANTA *fluid, FluidModifierData *mmd, int framenr, bool resumable)
int manta_read_data(MANTA *fluid, FluidModifierData *fmd, int framenr, bool resumable)
{
if (!fluid || !mmd)
if (!fluid || !fmd)
return 0;
return fluid->readData(mmd, framenr, resumable);
return fluid->readData(fmd, framenr, resumable);
}
int manta_read_noise(MANTA *fluid, FluidModifierData *mmd, int framenr, bool resumable)
int manta_read_noise(MANTA *fluid, FluidModifierData *fmd, int framenr, bool resumable)
{
if (!fluid || !mmd)
if (!fluid || !fmd)
return 0;
return fluid->readNoise(mmd, framenr, resumable);
return fluid->readNoise(fmd, framenr, resumable);
}
int manta_read_mesh(MANTA *fluid, FluidModifierData *mmd, int framenr)
int manta_read_mesh(MANTA *fluid, FluidModifierData *fmd, int framenr)
{
if (!fluid || !mmd)
if (!fluid || !fmd)
return 0;
return fluid->readMesh(mmd, framenr);
return fluid->readMesh(fmd, framenr);
}
int manta_read_particles(MANTA *fluid, FluidModifierData *mmd, int framenr, bool resumable)
int manta_read_particles(MANTA *fluid, FluidModifierData *fmd, int framenr, bool resumable)
{
if (!fluid || !mmd)
if (!fluid || !fmd)
return 0;
return fluid->readParticles(mmd, framenr, resumable);
return fluid->readParticles(fmd, framenr, resumable);
}
int manta_read_guiding(MANTA *fluid, FluidModifierData *mmd, int framenr, bool sourceDomain)
int manta_read_guiding(MANTA *fluid, FluidModifierData *fmd, int framenr, bool sourceDomain)
{
if (!fluid || !mmd)
if (!fluid || !fmd)
return 0;
return fluid->readGuiding(mmd, framenr, sourceDomain);
return fluid->readGuiding(fmd, framenr, sourceDomain);
}
int manta_bake_data(MANTA *fluid, FluidModifierData *mmd, int framenr)
int manta_bake_data(MANTA *fluid, FluidModifierData *fmd, int framenr)
{
if (!fluid || !mmd)
if (!fluid || !fmd)
return 0;
return fluid->bakeData(mmd, framenr);
return fluid->bakeData(fmd, framenr);
}
int manta_bake_noise(MANTA *fluid, FluidModifierData *mmd, int framenr)
int manta_bake_noise(MANTA *fluid, FluidModifierData *fmd, int framenr)
{
if (!fluid || !mmd)
if (!fluid || !fmd)
return 0;
return fluid->bakeNoise(mmd, framenr);
return fluid->bakeNoise(fmd, framenr);
}
int manta_bake_mesh(MANTA *fluid, FluidModifierData *mmd, int framenr)
int manta_bake_mesh(MANTA *fluid, FluidModifierData *fmd, int framenr)
{
if (!fluid || !mmd)
if (!fluid || !fmd)
return 0;
return fluid->bakeMesh(mmd, framenr);
return fluid->bakeMesh(fmd, framenr);
}
int manta_bake_particles(MANTA *fluid, FluidModifierData *mmd, int framenr)
int manta_bake_particles(MANTA *fluid, FluidModifierData *fmd, int framenr)
{
if (!fluid || !mmd)
if (!fluid || !fmd)
return 0;
return fluid->bakeParticles(mmd, framenr);
return fluid->bakeParticles(fmd, framenr);
}
int manta_bake_guiding(MANTA *fluid, FluidModifierData *mmd, int framenr)
int manta_bake_guiding(MANTA *fluid, FluidModifierData *fmd, int framenr)
{
if (!fluid || !mmd)
if (!fluid || !fmd)
return 0;
return fluid->bakeGuiding(mmd, framenr);
return fluid->bakeGuiding(fmd, framenr);
}
int manta_has_data(MANTA *fluid, FluidModifierData *mmd, int framenr)
int manta_has_data(MANTA *fluid, FluidModifierData *fmd, int framenr)
{
if (!fluid || !mmd)
if (!fluid || !fmd)
return 0;
return fluid->hasData(mmd, framenr);
return fluid->hasData(fmd, framenr);
}
int manta_has_noise(MANTA *fluid, FluidModifierData *mmd, int framenr)
int manta_has_noise(MANTA *fluid, FluidModifierData *fmd, int framenr)
{
if (!fluid || !mmd)
if (!fluid || !fmd)
return 0;
return fluid->hasNoise(mmd, framenr);
return fluid->hasNoise(fmd, framenr);
}
int manta_has_mesh(MANTA *fluid, FluidModifierData *mmd, int framenr)
int manta_has_mesh(MANTA *fluid, FluidModifierData *fmd, int framenr)
{
if (!fluid || !mmd)
if (!fluid || !fmd)
return 0;
return fluid->hasMesh(mmd, framenr);
return fluid->hasMesh(fmd, framenr);
}
int manta_has_particles(MANTA *fluid, FluidModifierData *mmd, int framenr)
int manta_has_particles(MANTA *fluid, FluidModifierData *fmd, int framenr)
{
if (!fluid || !mmd)
if (!fluid || !fmd)
return 0;
return fluid->hasParticles(mmd, framenr);
return fluid->hasParticles(fmd, framenr);
}
int manta_has_guiding(MANTA *fluid, FluidModifierData *mmd, int framenr, bool domain)
int manta_has_guiding(MANTA *fluid, FluidModifierData *fmd, int framenr, bool domain)
{
if (!fluid || !mmd)
if (!fluid || !fmd)
return 0;
return fluid->hasGuiding(mmd, framenr, domain);
return fluid->hasGuiding(fmd, framenr, domain);
}
void manta_update_variables(MANTA *fluid, FluidModifierData *mmd)
void manta_update_variables(MANTA *fluid, FluidModifierData *fmd)
{
if (!fluid)
return;
fluid->updateVariables(mmd);
fluid->updateVariables(fmd);
}
int manta_get_frame(MANTA *fluid)
@ -227,11 +227,11 @@ void manta_adapt_timestep(MANTA *fluid)
fluid->adaptTimestep();
}
bool manta_needs_realloc(MANTA *fluid, FluidModifierData *mmd)
bool manta_needs_realloc(MANTA *fluid, FluidModifierData *fmd)
{
if (!fluid)
return false;
return fluid->needsRealloc(mmd);
return fluid->needsRealloc(fmd);
}
/* Fluid accessors */
@ -361,11 +361,11 @@ float *manta_get_phioutstatic_in(MANTA *fluid)
}
/* Smoke functions */
void manta_smoke_export_script(MANTA *smoke, FluidModifierData *mmd)
void manta_smoke_export_script(MANTA *smoke, FluidModifierData *fmd)
{
if (!smoke || !mmd)
if (!smoke || !fmd)
return;
smoke->exportSmokeScript(mmd);
smoke->exportSmokeScript(fmd);
}
void manta_smoke_export(MANTA *smoke,
@ -527,31 +527,31 @@ void manta_smoke_turbulence_get_rgba_fixed_color(MANTA *smoke,
get_rgba_fixed_color(color, smoke->getTotalCellsHigh(), data, sequential);
}
void manta_smoke_ensure_heat(MANTA *smoke, struct FluidModifierData *mmd)
void manta_smoke_ensure_heat(MANTA *smoke, struct FluidModifierData *fmd)
{
if (smoke) {
smoke->initHeat(mmd);
smoke->initHeat(fmd);
smoke->updatePointers();
}
}
void manta_smoke_ensure_fire(MANTA *smoke, struct FluidModifierData *mmd)
void manta_smoke_ensure_fire(MANTA *smoke, struct FluidModifierData *fmd)
{
if (smoke) {
smoke->initFire(mmd);
smoke->initFire(fmd);
if (smoke->usingNoise()) {
smoke->initFireHigh(mmd);
smoke->initFireHigh(fmd);
}
smoke->updatePointers();
}
}
void manta_smoke_ensure_colors(MANTA *smoke, struct FluidModifierData *mmd)
void manta_smoke_ensure_colors(MANTA *smoke, struct FluidModifierData *fmd)
{
if (smoke) {
smoke->initColors(mmd);
smoke->initColors(fmd);
if (smoke->usingNoise()) {
smoke->initColorsHigh(mmd);
smoke->initColorsHigh(fmd);
}
smoke->updatePointers();
}
@ -700,17 +700,17 @@ int manta_smoke_turbulence_get_cells(MANTA *smoke)
}
/* Liquid functions */
void manta_liquid_export_script(MANTA *liquid, FluidModifierData *mmd)
void manta_liquid_export_script(MANTA *liquid, FluidModifierData *fmd)
{
if (!liquid || !mmd)
if (!liquid || !fmd)
return;
liquid->exportLiquidScript(mmd);
liquid->exportLiquidScript(fmd);
}
void manta_liquid_ensure_sndparts(MANTA *liquid, struct FluidModifierData *mmd)
void manta_liquid_ensure_sndparts(MANTA *liquid, struct FluidModifierData *fmd)
{
if (liquid) {
liquid->initLiquidSndParts(mmd);
liquid->initLiquidSndParts(fmd);
liquid->updatePointers();
}
}

22
source/blender/blenkernel/BKE_fluid.h
View File

@ -39,21 +39,21 @@ struct Scene;
typedef float (*BKE_Fluid_BresenhamFn)(
float *result, float *input, int res[3], int *pixel, float *tRay, float correct);
struct Mesh *BKE_fluid_modifier_do(struct FluidModifierData *mmd,
struct Mesh *BKE_fluid_modifier_do(struct FluidModifierData *fmd,
struct Depsgraph *depsgraph,
struct Scene *scene,
struct Object *ob,
struct Mesh *me);
void BKE_fluid_modifier_free(struct FluidModifierData *mmd);
void BKE_fluid_modifier_reset(struct FluidModifierData *mmd);
void BKE_fluid_modifier_create_type_data(struct FluidModifierData *mmd);
void BKE_fluid_modifier_copy(const struct FluidModifierData *mmd,
struct FluidModifierData *tmmd,
void BKE_fluid_modifier_free(struct FluidModifierData *fmd);
void BKE_fluid_modifier_reset(struct FluidModifierData *fmd);
void BKE_fluid_modifier_create_type_data(struct FluidModifierData *fmd);
void BKE_fluid_modifier_copy(const struct FluidModifierData *fmd,
struct FluidModifierData *tfmd,
const int flag);
bool BKE_fluid_reallocate_fluid(struct FluidDomainSettings *mds, int res[3], int free_old);
void BKE_fluid_reallocate_copy_fluid(struct FluidDomainSettings *mds,
bool BKE_fluid_reallocate_fluid(struct FluidDomainSettings *fds, int res[3], int free_old);
void BKE_fluid_reallocate_copy_fluid(struct FluidDomainSettings *fds,
int o_res[3],
int n_res[3],
int o_min[3],
@ -61,12 +61,12 @@ void BKE_fluid_reallocate_copy_fluid(struct FluidDomainSettings *mds,
int o_max[3],
int o_shift[3],
int n_shift[3]);
void BKE_fluid_cache_free_all(struct FluidDomainSettings *mds, struct Object *ob);
void BKE_fluid_cache_free(struct FluidDomainSettings *mds, struct Object *ob, int cache_map);
void BKE_fluid_cache_free_all(struct FluidDomainSettings *fds, struct Object *ob);
void BKE_fluid_cache_free(struct FluidDomainSettings *fds, struct Object *ob, int cache_map);
void BKE_fluid_cache_new_name_for_current_session(int maxlen, char *r_name);
float BKE_fluid_get_velocity_at(struct Object *ob, float position[3], float velocity[3]);
int BKE_fluid_get_data_flags(struct FluidDomainSettings *mds);
int BKE_fluid_get_data_flags(struct FluidDomainSettings *fds);
void BKE_fluid_particle_system_create(struct Main *bmain,
struct Object *ob,

2
source/blender/blenkernel/BKE_pointcache.h
View File

@ -291,7 +291,7 @@ void BKE_ptcache_make_particle_key(struct ParticleKey *key, int index, void **da
void BKE_ptcache_id_from_softbody(PTCacheID *pid, struct Object *ob, struct SoftBody *sb);
void BKE_ptcache_id_from_particles(PTCacheID *pid, struct Object *ob, struct ParticleSystem *psys);
void BKE_ptcache_id_from_cloth(PTCacheID *pid, struct Object *ob, struct ClothModifierData *clmd);
void BKE_ptcache_id_from_smoke(PTCacheID *pid, struct Object *ob, struct FluidModifierData *mmd);
void BKE_ptcache_id_from_smoke(PTCacheID *pid, struct Object *ob, struct FluidModifierData *fmd);
void BKE_ptcache_id_from_dynamicpaint(PTCacheID *pid,
struct Object *ob,
struct DynamicPaintSurface *surface);

6
source/blender/blenkernel/intern/bpath.c
View File

@ -609,9 +609,9 @@ void BKE_bpath_traverse_id(
}
}
else if (md->type == eModifierType_Fluid) {
FluidModifierData *mmd = (FluidModifierData *)md;
if (mmd->type & MOD_FLUID_TYPE_DOMAIN && mmd->domain) {
rewrite_path_fixed(mmd->domain->cache_directory, visit_cb, absbase, bpath_user_data);
FluidModifierData *fmd = (FluidModifierData *)md;
if (fmd->type & MOD_FLUID_TYPE_DOMAIN && fmd->domain) {
rewrite_path_fixed(fmd->domain->cache_directory, visit_cb, absbase, bpath_user_data);
}
}
else if (md->type == eModifierType_Cloth) {

2430
source/blender/blenkernel/intern/fluid.c
View File

File diff suppressed because it is too large Load Diff

14
source/blender/blenkernel/intern/object.c
View File

@ -1532,12 +1532,12 @@ void BKE_object_copy_particlesystems(Object *ob_dst, const Object *ob_src, const
}
}
else if (md->type == eModifierType_Fluid) {
FluidModifierData *mmd = (FluidModifierData *)md;
FluidModifierData *fmd = (FluidModifierData *)md;
if (mmd->type == MOD_FLUID_TYPE_FLOW) {
if (mmd->flow) {
if (mmd->flow->psys == psys) {
mmd->flow->psys = npsys;
if (fmd->type == MOD_FLUID_TYPE_FLOW) {
if (fmd->flow) {
if (fmd->flow->psys == psys) {
fmd->flow->psys = npsys;
}
}
}
@ -4592,9 +4592,9 @@ bool BKE_object_modifier_update_subframe(Depsgraph *depsgraph,
}
}
else if (type == eModifierType_Fluid) {
FluidModifierData *mmd = (FluidModifierData *)md;
FluidModifierData *fmd = (FluidModifierData *)md;
if (mmd && (mmd->type & MOD_FLUID_TYPE_DOMAIN) != 0) {
if (fmd && (fmd->type & MOD_FLUID_TYPE_DOMAIN) != 0) {
return true;
}
}

22
source/blender/blenkernel/intern/particle.c
View File

@ -3668,43 +3668,43 @@ void object_remove_particle_system(Main *bmain, Scene *UNUSED(scene), Object *ob
/* Clear particle system in fluid modifier. */
if ((md = BKE_modifiers_findby_type(ob, eModifierType_Fluid))) {
FluidModifierData *mmd = (FluidModifierData *)md;
FluidModifierData *fmd = (FluidModifierData *)md;
/* Clear particle system pointer in flow settings. */
if ((mmd->type == MOD_FLUID_TYPE_FLOW) && mmd->flow && mmd->flow->psys) {
if (mmd->flow->psys == psys) {
mmd->flow->psys = NULL;
if ((fmd->type == MOD_FLUID_TYPE_FLOW) && fmd->flow && fmd->flow->psys) {
if (fmd->flow->psys == psys) {
fmd->flow->psys = NULL;
}
}
/* Clear particle flag in domain settings when removing particle system manually. */
if (mmd->type == MOD_FLUID_TYPE_DOMAIN) {
if (fmd->type == MOD_FLUID_TYPE_DOMAIN) {
if (psys->part->type == PART_FLUID_FLIP) {
mmd->domain->particle_type &= ~FLUID_DOMAIN_PARTICLE_FLIP;
fmd->domain->particle_type &= ~FLUID_DOMAIN_PARTICLE_FLIP;
}
if (psys->part->type == PART_FLUID_SPRAY || psys->part->type == PART_FLUID_SPRAYFOAM ||
psys->part->type == PART_FLUID_SPRAYBUBBLE ||
psys->part->type == PART_FLUID_SPRAYFOAMBUBBLE) {
mmd->domain->particle_type &= ~FLUID_DOMAIN_PARTICLE_SPRAY;
fmd->domain->particle_type &= ~FLUID_DOMAIN_PARTICLE_SPRAY;
}
if (psys->part->type == PART_FLUID_FOAM || psys->part->type == PART_FLUID_SPRAYFOAM ||
psys->part->type == PART_FLUID_FOAMBUBBLE ||
psys->part->type == PART_FLUID_SPRAYFOAMBUBBLE) {
mmd->domain->particle_type &= ~FLUID_DOMAIN_PARTICLE_FOAM;
fmd->domain->particle_type &= ~FLUID_DOMAIN_PARTICLE_FOAM;
}
if (psys->part->type == PART_FLUID_BUBBLE || psys->part->type == PART_FLUID_FOAMBUBBLE ||
psys->part->type == PART_FLUID_SPRAYBUBBLE ||
psys->part->type == PART_FLUID_SPRAYFOAMBUBBLE) {
mmd->domain->particle_type &= ~FLUID_DOMAIN_PARTICLE_BUBBLE;
fmd->domain->particle_type &= ~FLUID_DOMAIN_PARTICLE_BUBBLE;
}
if (psys->part->type == PART_FLUID_TRACER) {
mmd->domain->particle_type &= ~FLUID_DOMAIN_PARTICLE_TRACER;
fmd->domain->particle_type &= ~FLUID_DOMAIN_PARTICLE_TRACER;
}
/* Disable combined export if combined particle system was deleted. */
if (psys->part->type == PART_FLUID_SPRAYFOAM || psys->part->type == PART_FLUID_SPRAYBUBBLE ||
psys->part->type == PART_FLUID_FOAMBUBBLE ||
psys->part->type == PART_FLUID_SPRAYFOAMBUBBLE) {
mmd->domain->sndparticle_combined_export = SNDPARTICLE_COMBINED_EXPORT_OFF;
fmd->domain->sndparticle_combined_export = SNDPARTICLE_COMBINED_EXPORT_OFF;
}
}
}

78
source/blender/blenkernel/intern/particle_system.c
View File

@ -4188,11 +4188,11 @@ static void particles_fluid_step(ParticleSimulationData *sim,
#else
{
Object *ob = sim->ob;
FluidModifierData *mmd = (FluidModifierData *)BKE_modifiers_findby_type(ob,
FluidModifierData *fmd = (FluidModifierData *)BKE_modifiers_findby_type(ob,
eModifierType_Fluid);
if (mmd && mmd->domain && mmd->domain->fluid) {
FluidDomainSettings *mds = mmd->domain;
if (fmd && fmd->domain && fmd->domain->fluid) {
FluidDomainSettings *fds = fmd->domain;
ParticleSettings *part = psys->part;
ParticleData *pa = NULL;
@ -4210,15 +4210,15 @@ static void particles_fluid_step(ParticleSimulationData *sim,
/* Sanity check: parts also enabled in fluid domain? */
if ((particles_has_flip(part->type) &&
(mds->particle_type & FLUID_DOMAIN_PARTICLE_FLIP) == 0) ||
(fds->particle_type & FLUID_DOMAIN_PARTICLE_FLIP) == 0) ||
(particles_has_spray(part->type) &&
(mds->particle_type & FLUID_DOMAIN_PARTICLE_SPRAY) == 0) ||
(fds->particle_type & FLUID_DOMAIN_PARTICLE_SPRAY) == 0) ||
(particles_has_bubble(part->type) &&
(mds->particle_type & FLUID_DOMAIN_PARTICLE_BUBBLE) == 0) ||
(fds->particle_type & FLUID_DOMAIN_PARTICLE_BUBBLE) == 0) ||
(particles_has_foam(part->type) &&
(mds->particle_type & FLUID_DOMAIN_PARTICLE_FOAM) == 0) ||
(fds->particle_type & FLUID_DOMAIN_PARTICLE_FOAM) == 0) ||
(particles_has_tracer(part->type) &&
(mds->particle_type & FLUID_DOMAIN_PARTICLE_TRACER) == 0)) {
(fds->particle_type & FLUID_DOMAIN_PARTICLE_TRACER) == 0)) {
BLI_snprintf(debugStrBuffer,
sizeof(debugStrBuffer),
"particles_fluid_step::error - found particle system that is not enabled in "
@ -4228,15 +4228,15 @@ static void particles_fluid_step(ParticleSimulationData *sim,
/* Count particle amount. tottypepart is only important for snd particles. */
if (part->type == PART_FLUID_FLIP) {
tottypepart = totpart = manta_liquid_get_num_flip_particles(mds->fluid);
tottypepart = totpart = manta_liquid_get_num_flip_particles(fds->fluid);
}
if (particles_has_spray(part->type) || particles_has_bubble(part->type) ||
particles_has_foam(part->type) || particles_has_tracer(part->type)) {
totpart = manta_liquid_get_num_snd_particles(mds->fluid);
totpart = manta_liquid_get_num_snd_particles(fds->fluid);
/* tottypepart is the amount of particles of a snd particle type. */
for (p = 0; p < totpart; p++) {
flagActivePart = manta_liquid_get_snd_particle_flag_at(mds->fluid, p);
flagActivePart = manta_liquid_get_snd_particle_flag_at(fds->fluid, p);
if (particles_has_spray(part->type) && (flagActivePart & PARTICLE_TYPE_SPRAY)) {
tottypepart++;
}
@ -4281,39 +4281,39 @@ static void particles_fluid_step(ParticleSimulationData *sim,
/* flag, res, upres, pos, vel for FLIP and snd particles have different getters. */
if (part->type == PART_FLUID_FLIP) {
flagActivePart = manta_liquid_get_flip_particle_flag_at(mds->fluid, p);
flagActivePart = manta_liquid_get_flip_particle_flag_at(fds->fluid, p);
resX = (float)manta_get_res_x(mds->fluid);
resY = (float)manta_get_res_y(mds->fluid);
resZ = (float)manta_get_res_z(mds->fluid);
resX = (float)manta_get_res_x(fds->fluid);
resY = (float)manta_get_res_y(fds->fluid);
resZ = (float)manta_get_res_z(fds->fluid);
upres = 1;
posX = manta_liquid_get_flip_particle_position_x_at(mds->fluid, p);
posY = manta_liquid_get_flip_particle_position_y_at(mds->fluid, p);
posZ = manta_liquid_get_flip_particle_position_z_at(mds->fluid, p);
posX = manta_liquid_get_flip_particle_position_x_at(fds->fluid, p);
posY = manta_liquid_get_flip_particle_position_y_at(fds->fluid, p);
posZ = manta_liquid_get_flip_particle_position_z_at(fds->fluid, p);
velX = manta_liquid_get_flip_particle_velocity_x_at(mds->fluid, p);
velY = manta_liquid_get_flip_particle_velocity_y_at(mds->fluid, p);
velZ = manta_liquid_get_flip_particle_velocity_z_at(mds->fluid, p);
velX = manta_liquid_get_flip_particle_velocity_x_at(fds->fluid, p);
velY = manta_liquid_get_flip_particle_velocity_y_at(fds->fluid, p);
velZ = manta_liquid_get_flip_particle_velocity_z_at(fds->fluid, p);
}
else if (particles_has_spray(part->type) || particles_has_bubble(part->type) ||
particles_has_foam(part->type) || particles_has_tracer(part->type)) {
flagActivePart = manta_liquid_get_snd_particle_flag_at(mds->fluid, p);
flagActivePart = manta_liquid_get_snd_particle_flag_at(fds->fluid, p);
resX = (float)manta_liquid_get_particle_res_x(mds->fluid);
resY = (float)manta_liquid_get_particle_res_y(mds->fluid);
resZ = (float)manta_liquid_get_particle_res_z(mds->fluid);
resX = (float)manta_liquid_get_particle_res_x(fds->fluid);
resY = (float)manta_liquid_get_particle_res_y(fds->fluid);
resZ = (float)manta_liquid_get_particle_res_z(fds->fluid);
upres = manta_liquid_get_particle_upres(mds->fluid);
upres = manta_liquid_get_particle_upres(fds->fluid);
posX = manta_liquid_get_snd_particle_position_x_at(mds->fluid, p);
posY = manta_liquid_get_snd_particle_position_y_at(mds->fluid, p);
posZ = manta_liquid_get_snd_particle_position_z_at(mds->fluid, p);
posX = manta_liquid_get_snd_particle_position_x_at(fds->fluid, p);
posY = manta_liquid_get_snd_particle_position_y_at(fds->fluid, p);
posZ = manta_liquid_get_snd_particle_position_z_at(fds->fluid, p);
velX = manta_liquid_get_snd_particle_velocity_x_at(mds->fluid, p);
velY = manta_liquid_get_snd_particle_velocity_y_at(mds->fluid, p);
velZ = manta_liquid_get_snd_particle_velocity_z_at(mds->fluid, p);
velX = manta_liquid_get_snd_particle_velocity_x_at(fds->fluid, p);
velY = manta_liquid_get_snd_particle_velocity_y_at(fds->fluid, p);
velZ = manta_liquid_get_snd_particle_velocity_z_at(fds->fluid, p);
}
else {
BLI_snprintf(debugStrBuffer,
@ -4362,10 +4362,10 @@ static void particles_fluid_step(ParticleSimulationData *sim,
}
/* Get size (dimension) but considering scaling */
copy_v3_v3(cell_size_scaled, mds->cell_size);
copy_v3_v3(cell_size_scaled, fds->cell_size);
mul_v3_v3(cell_size_scaled, ob->scale);
madd_v3fl_v3fl_v3fl_v3i(min, mds->p0, cell_size_scaled, mds->res_min);
madd_v3fl_v3fl_v3fl_v3i(max, mds->p0, cell_size_scaled, mds->res_max);
madd_v3fl_v3fl_v3fl_v3i(min, fds->p0, cell_size_scaled, fds->res_min);
madd_v3fl_v3fl_v3fl_v3i(max, fds->p0, cell_size_scaled, fds->res_max);
sub_v3_v3v3(size, max, min);
/* Biggest dimension will be used for up-scaling. */
@ -4379,7 +4379,7 @@ static void particles_fluid_step(ParticleSimulationData *sim,
float resDomain[3] = {resX, resY, resZ};
mul_v3_fl(resDomain, 0.5f);
sub_v3_v3(pa->state.co, resDomain);
mul_v3_fl(pa->state.co, mds->dx);
mul_v3_fl(pa->state.co, fds->dx);
/* Match domain dimension / size. */
float scaleAbs[3] = {
@ -4393,9 +4393,9 @@ static void particles_fluid_step(ParticleSimulationData *sim,
/* Add origin offset to particle position. */
zero_v3(tmp);
zero_v3(tmp2);
sub_v3_v3v3(tmp2, mds->p1, mds->p0);
sub_v3_v3v3(tmp2, fds->p1, fds->p0);
mul_v3_fl(tmp2, 0.5f);
add_v3_v3v3(tmp, tmp, mds->p1);
add_v3_v3v3(tmp, tmp, fds->p1);
sub_v3_v3(tmp, tmp2);
mul_v3_v3(tmp, ob->scale);
add_v3_v3(pa->state.co, tmp);
@ -4407,7 +4407,7 @@ static void particles_fluid_step(ParticleSimulationData *sim,
/* Set particle velocity. */
float velParticle[3] = {velX, velY, velZ};
copy_v3_v3(pa->state.vel, velParticle);
mul_v3_fl(pa->state.vel, mds->dx);
mul_v3_fl(pa->state.vel, fds->dx);
# if 0
/* Debugging: Print particle velocity. */
printf("pa->state.vel[0]: %f, pa->state.vel[1]: %f, pa->state.vel[2]: %f\n",

406
source/blender/blenkernel/intern/pointcache.c
View File

@ -627,11 +627,11 @@ static void ptcache_cloth_error(void *cloth_v, const char *message)
/* Smoke functions */
static int ptcache_smoke_totpoint(void *smoke_v, int UNUSED(cfra))
{
FluidModifierData *mmd = (FluidModifierData *)smoke_v;
FluidDomainSettings *mds = mmd->domain;
FluidModifierData *fmd = (FluidModifierData *)smoke_v;
FluidDomainSettings *fds = fmd->domain;
if (mds->fluid) {
return mds->base_res[0] * mds->base_res[1] * mds->base_res[2];
if (fds->fluid) {
return fds->base_res[0] * fds->base_res[1] * fds->base_res[2];
}
else {
return 0;
@ -640,28 +640,28 @@ static int ptcache_smoke_totpoint(void *smoke_v, int UNUSED(cfra))
static void ptcache_smoke_error(void *smoke_v, const char *message)
{
FluidModifierData *mmd = (FluidModifierData *)smoke_v;
BKE_modifier_set_error(&mmd->modifier, "%s", message);
FluidModifierData *fmd = (FluidModifierData *)smoke_v;
BKE_modifier_set_error(&fmd->modifier, "%s", message);
}
# define SMOKE_CACHE_VERSION "1.04"
static int ptcache_smoke_write(PTCacheFile *pf, void *smoke_v)
{
FluidModifierData *mmd = (FluidModifierData *)smoke_v;
FluidDomainSettings *mds = mmd->domain;
FluidModifierData *fmd = (FluidModifierData *)smoke_v;
FluidDomainSettings *fds = fmd->domain;
int ret = 0;
int fluid_fields = BKE_fluid_get_data_flags(mds);
int fluid_fields = BKE_fluid_get_data_flags(fds);
/* version header */
ptcache_file_write(pf, SMOKE_CACHE_VERSION, 4, sizeof(char));
ptcache_file_write(pf, &fluid_fields, 1, sizeof(int));
ptcache_file_write(pf, &mds->active_fields, 1, sizeof(int));
ptcache_file_write(pf, &mds->res, 3, sizeof(int));
ptcache_file_write(pf, &mds->dx, 1, sizeof(float));
ptcache_file_write(pf, &fds->active_fields, 1, sizeof(int));
ptcache_file_write(pf, &fds->res, 3, sizeof(int));
ptcache_file_write(pf, &fds->dx, 1, sizeof(float));
if (mds->fluid) {
size_t res = mds->res[0] * mds->res[1] * mds->res[2];
if (fds->fluid) {
size_t res = fds->res[0] * fds->res[1] * fds->res[2];
float dt, dx, *dens, *react, *fuel, *flame, *heat, *heatold, *vx, *vy, *vz, *r, *g, *b;
unsigned char *obstacles;
unsigned int in_len = sizeof(float) * (unsigned int)res;
@ -669,11 +669,11 @@ static int ptcache_smoke_write(PTCacheFile *pf, void *smoke_v)
"pointcache_lzo_buffer");
// int mode = res >= 1000000 ? 2 : 1;
int mode = 1; // light
if (mds->cache_comp == SM_CACHE_HEAVY) {
if (fds->cache_comp == SM_CACHE_HEAVY) {
mode = 2; // heavy
}
smoke_export(mds->fluid,
smoke_export(fds->fluid,
&dt,
&dx,
&dens,
@ -691,7 +691,7 @@ static int ptcache_smoke_write(PTCacheFile *pf, void *smoke_v)
&obstacles,
NULL);
ptcache_file_compressed_write(pf, (unsigned char *)mds->shadow, in_len, out, mode);
ptcache_file_compressed_write(pf, (unsigned char *)fds->shadow, in_len, out, mode);
ptcache_file_compressed_write(pf, (unsigned char *)dens, in_len, out, mode);
if (fluid_fields & FLUID_DOMAIN_ACTIVE_HEAT) {
ptcache_file_compressed_write(pf, (unsigned char *)heat, in_len, out, mode);
@ -713,43 +713,43 @@ static int ptcache_smoke_write(PTCacheFile *pf, void *smoke_v)
ptcache_file_compressed_write(pf, (unsigned char *)obstacles, (unsigned int)res, out, mode);
ptcache_file_write(pf, &dt, 1, sizeof(float));
ptcache_file_write(pf, &dx, 1, sizeof(float));
ptcache_file_write(pf, &mds->p0, 3, sizeof(float));
ptcache_file_write(pf, &mds->p1, 3, sizeof(float));
ptcache_file_write(pf, &mds->dp0, 3, sizeof(float));
ptcache_file_write(pf, &mds->shift, 3, sizeof(int));
ptcache_file_write(pf, &mds->obj_shift_f, 3, sizeof(float));
ptcache_file_write(pf, &mds->obmat, 16, sizeof(float));
ptcache_file_write(pf, &mds->base_res, 3, sizeof(int));
ptcache_file_write(pf, &mds->res_min, 3, sizeof(int));
ptcache_file_write(pf, &mds->res_max, 3, sizeof(int));
ptcache_file_write(pf, &mds->active_color, 3, sizeof(float));
ptcache_file_write(pf, &fds->p0, 3, sizeof(float));
ptcache_file_write(pf, &fds->p1, 3, sizeof(float));
ptcache_file_write(pf, &fds->dp0, 3, sizeof(float));
ptcache_file_write(pf, &fds->shift, 3, sizeof(int));
ptcache_file_write(pf, &fds->obj_shift_f, 3, sizeof(float));
ptcache_file_write(pf, &fds->obmat, 16, sizeof(float));
ptcache_file_write(pf, &fds->base_res, 3, sizeof(int));
ptcache_file_write(pf, &fds->res_min, 3, sizeof(int));
ptcache_file_write(pf, &fds->res_max, 3, sizeof(int));
ptcache_file_write(pf, &fds->active_color, 3, sizeof(float));
MEM_freeN(out);
ret = 1;
}
if (mds->wt) {
if (fds->wt) {
int res_big_array[3];
int res_big;
int res = mds->res[0] * mds->res[1] * mds->res[2];
int res = fds->res[0] * fds->res[1] * fds->res[2];
float *dens, *react, *fuel, *flame, *tcu, *tcv, *tcw, *r, *g, *b;
unsigned int in_len = sizeof(float) * (unsigned int)res;
unsigned int in_len_big;
unsigned char *out;
int mode;
smoke_turbulence_get_res(mds->wt, res_big_array);
smoke_turbulence_get_res(fds->wt, res_big_array);
res_big = res_big_array[0] * res_big_array[1] * res_big_array[2];
// mode = res_big >= 1000000 ? 2 : 1;
mode = 1; // light
if (mds->cache_high_comp == SM_CACHE_HEAVY) {
if (fds->cache_high_comp == SM_CACHE_HEAVY) {
mode = 2; // heavy
}
in_len_big = sizeof(float) * (unsigned int)res_big;
smoke_turbulence_export(mds->wt, &dens, &react, &flame, &fuel, &r, &g, &b, &tcu, &tcv, &tcw);
smoke_turbulence_export(fds->wt, &dens, &react, &flame, &fuel, &r, &g, &b, &tcu, &tcv, &tcw);
out = (unsigned char *)MEM_callocN(LZO_OUT_LEN(in_len_big), "pointcache_lzo_buffer");
ptcache_file_compressed_write(pf, (unsigned char *)dens, in_len_big, out, mode);
@ -780,24 +780,24 @@ static int ptcache_smoke_write(PTCacheFile *pf, void *smoke_v)
/* read old smoke cache from 2.64 */
static int ptcache_smoke_read_old(PTCacheFile *pf, void *smoke_v)
{
FluidModifierData *mmd = (FluidModifierData *)smoke_v;
FluidDomainSettings *mds = mmd->domain;
FluidModifierData *fmd = (FluidModifierData *)smoke_v;
FluidDomainSettings *fds = fmd->domain;
if (mds->fluid) {
const size_t res = mds->res[0] * mds->res[1] * mds->res[2];
if (fds->fluid) {
const size_t res = fds->res[0] * fds->res[1] * fds->res[2];
const unsigned int out_len = (unsigned int)res * sizeof(float);
float dt, dx, *dens, *heat, *heatold, *vx, *vy, *vz;
unsigned char *obstacles;
float *tmp_array = MEM_callocN(out_len, "Smoke old cache tmp");
int fluid_fields = BKE_fluid_get_data_flags(mds);
int fluid_fields = BKE_fluid_get_data_flags(fds);
/* Part part of the new cache header */
mds->active_color[0] = 0.7f;
mds->active_color[1] = 0.7f;
mds->active_color[2] = 0.7f;
fds->active_color[0] = 0.7f;
fds->active_color[1] = 0.7f;
fds->active_color[2] = 0.7f;
smoke_export(mds->fluid,
smoke_export(fds->fluid,
&dt,
&dx,
&dens,
@ -815,7 +815,7 @@ static int ptcache_smoke_read_old(PTCacheFile *pf, void *smoke_v)
&obstacles,
NULL);
ptcache_file_compressed_read(pf, (unsigned char *)mds->shadow, out_len);
ptcache_file_compressed_read(pf, (unsigned char *)fds->shadow, out_len);
ptcache_file_compressed_read(pf, (unsigned char *)dens, out_len);
ptcache_file_compressed_read(pf, (unsigned char *)tmp_array, out_len);
@ -839,19 +839,19 @@ static int ptcache_smoke_read_old(PTCacheFile *pf, void *smoke_v)
MEM_freeN(tmp_array);
if (pf->data_types & (1 << BPHYS_DATA_SMOKE_HIGH) && mds->wt) {
if (pf->data_types & (1 << BPHYS_DATA_SMOKE_HIGH) && fds->wt) {
int res_big, res_big_array[3];
float *tcu, *tcv, *tcw;
unsigned int out_len_big;
unsigned char *tmp_array_big;
smoke_turbulence_get_res(mds->wt, res_big_array);
smoke_turbulence_get_res(fds->wt, res_big_array);
res_big = res_big_array[0] * res_big_array[1] * res_big_array[2];
out_len_big = sizeof(float) * (unsigned int)res_big;
tmp_array_big = MEM_callocN(out_len_big, "Smoke old cache tmp");
smoke_turbulence_export(
mds->wt, &dens, NULL, NULL, NULL, NULL, NULL, NULL, &tcu, &tcv, &tcw);
fds->wt, &dens, NULL, NULL, NULL, NULL, NULL, NULL, &tcu, &tcv, &tcw);
ptcache_file_compressed_read(pf, (unsigned char *)dens, out_len_big);
ptcache_file_compressed_read(pf, (unsigned char *)tmp_array_big, out_len_big);
@ -869,12 +869,12 @@ static int ptcache_smoke_read_old(PTCacheFile *pf, void *smoke_v)
static int ptcache_smoke_read(PTCacheFile *pf, void *smoke_v)
{
FluidModifierData *mmd = (FluidModifierData *)smoke_v;
FluidDomainSettings *mds = mmd->domain;
FluidModifierData *fmd = (FluidModifierData *)smoke_v;
FluidDomainSettings *fds = fmd->domain;
char version[4];
int ch_res[3];
float ch_dx;
int fluid_fields = BKE_fluid_get_data_flags(mds);
int fluid_fields = BKE_fluid_get_data_flags(fds);
int cache_fields = 0;
int active_fields = 0;
int reallocate = 0;
@ -894,8 +894,8 @@ static int ptcache_smoke_read(PTCacheFile *pf, void *smoke_v)
ptcache_file_read(pf, &ch_dx, 1, sizeof(float));
/* check if resolution has changed */
if (mds->res[0] != ch_res[0] || mds->res[1] != ch_res[1] || mds->res[2] != ch_res[2]) {
if (mds->flags & FLUID_DOMAIN_USE_ADAPTIVE_DOMAIN) {
if (fds->res[0] != ch_res[0] || fds->res[1] != ch_res[1] || fds->res[2] != ch_res[2]) {
if (fds->flags & FLUID_DOMAIN_USE_ADAPTIVE_DOMAIN) {
reallocate = 1;
}
else {
@ -903,26 +903,26 @@ static int ptcache_smoke_read(PTCacheFile *pf, void *smoke_v)
}
}
/* check if active fields have changed */
if (fluid_fields != cache_fields || active_fields != mds->active_fields) {
if (fluid_fields != cache_fields || active_fields != fds->active_fields) {
reallocate = 1;
}
/* reallocate fluid if needed*/
if (reallocate) {
mds->active_fields = active_fields | cache_fields;
BKE_fluid_reallocate_fluid(mds, ch_res, 1);
mds->dx = ch_dx;
copy_v3_v3_int(mds->res, ch_res);
mds->total_cells = ch_res[0] * ch_res[1] * ch_res[2];
fds->active_fields = active_fields | cache_fields;
BKE_fluid_reallocate_fluid(fds, ch_res, 1);
fds->dx = ch_dx;
copy_v3_v3_int(fds->res, ch_res);
fds->total_cells = ch_res[0] * ch_res[1] * ch_res[2];
}
if (mds->fluid) {
size_t res = mds->res[0] * mds->res[1] * mds->res[2];
if (fds->fluid) {
size_t res = fds->res[0] * fds->res[1] * fds->res[2];
float dt, dx, *dens, *react, *fuel, *flame, *heat, *heatold, *vx, *vy, *vz, *r, *g, *b;
unsigned char *obstacles;
unsigned int out_len = (unsigned int)res * sizeof(float);
smoke_export(mds->fluid,
smoke_export(fds->fluid,
&dt,
&dx,
&dens,
@ -940,7 +940,7 @@ static int ptcache_smoke_read(PTCacheFile *pf, void *smoke_v)
&obstacles,
NULL);
ptcache_file_compressed_read(pf, (unsigned char *)mds->shadow, out_len);
ptcache_file_compressed_read(pf, (unsigned char *)fds->shadow, out_len);
ptcache_file_compressed_read(pf, (unsigned char *)dens, out_len);
if (cache_fields & FLUID_DOMAIN_ACTIVE_HEAT) {
ptcache_file_compressed_read(pf, (unsigned char *)heat, out_len);
@ -962,30 +962,30 @@ static int ptcache_smoke_read(PTCacheFile *pf, void *smoke_v)
ptcache_file_compressed_read(pf, (unsigned char *)obstacles, (unsigned int)res);
ptcache_file_read(pf, &dt, 1, sizeof(float));
ptcache_file_read(pf, &dx, 1, sizeof(float));
ptcache_file_read(pf, &mds->p0, 3, sizeof(float));
ptcache_file_read(pf, &mds->p1, 3, sizeof(float));
ptcache_file_read(pf, &mds->dp0, 3, sizeof(float));
ptcache_file_read(pf, &mds->shift, 3, sizeof(int));
ptcache_file_read(pf, &mds->obj_shift_f, 3, sizeof(float));
ptcache_file_read(pf, &mds->obmat, 16, sizeof(float));
ptcache_file_read(pf, &mds->base_res, 3, sizeof(int));
ptcache_file_read(pf, &mds->res_min, 3, sizeof(int));
ptcache_file_read(pf, &mds->res_max, 3, sizeof(int));
ptcache_file_read(pf, &mds->active_color, 3, sizeof(float));
ptcache_file_read(pf, &fds->p0, 3, sizeof(float));
ptcache_file_read(pf, &fds->p1, 3, sizeof(float));
ptcache_file_read(pf, &fds->dp0, 3, sizeof(float));
ptcache_file_read(pf, &fds->shift, 3, sizeof(int));
ptcache_file_read(pf, &fds->obj_shift_f, 3, sizeof(float));
ptcache_file_read(pf, &fds->obmat, 16, sizeof(float));
ptcache_file_read(pf, &fds->base_res, 3, sizeof(int));
ptcache_file_read(pf, &fds->res_min, 3, sizeof(int));
ptcache_file_read(pf, &fds->res_max, 3, sizeof(int));
ptcache_file_read(pf, &fds->active_color, 3, sizeof(float));
}
if (pf->data_types & (1 << BPHYS_DATA_SMOKE_HIGH) && mds->wt) {
int res = mds->res[0] * mds->res[1] * mds->res[2];
if (pf->data_types & (1 << BPHYS_DATA_SMOKE_HIGH) && fds->wt) {
int res = fds->res[0] * fds->res[1] * fds->res[2];
int res_big, res_big_array[3];
float *dens, *react, *fuel, *flame, *tcu, *tcv, *tcw, *r, *g, *b;
unsigned int out_len = sizeof(float) * (unsigned int)res;
unsigned int out_len_big;
smoke_turbulence_get_res(mds->wt, res_big_array);
smoke_turbulence_get_res(fds->wt, res_big_array);
res_big = res_big_array[0] * res_big_array[1] * res_big_array[2];
out_len_big = sizeof(float) * (unsigned int)res_big;
smoke_turbulence_export(mds->wt, &dens, &react, &flame, &fuel, &r, &g, &b, &tcu, &tcv, &tcw);
smoke_turbulence_export(fds->wt, &dens, &react, &flame, &fuel, &r, &g, &b, &tcu, &tcv, &tcw);
ptcache_file_compressed_read(pf, (unsigned char *)dens, out_len_big);
if (cache_fields & FLUID_DOMAIN_ACTIVE_FIRE) {
@ -1020,88 +1020,88 @@ static int ptcache_smoke_read(PTCacheFile *pf, void *smoke_v)
* with `vs` = voxel size, and `px, py, pz`,
* the min position of the domain's bounding box.
*/
static void compute_fluid_matrices(FluidDomainSettings *mds)
static void compute_fluid_matrices(FluidDomainSettings *fds)
{
float bbox_min[3];
copy_v3_v3(bbox_min, mds->p0);
copy_v3_v3(bbox_min, fds->p0);
if (mds->flags & FLUID_DOMAIN_USE_ADAPTIVE_DOMAIN) {
bbox_min[0] += (mds->cell_size[0] * (float)mds->res_min[0]);
bbox_min[1] += (mds->cell_size[1] * (float)mds->res_min[1]);
bbox_min[2] += (mds->cell_size[2] * (float)mds->res_min[2]);
add_v3_v3(bbox_min, mds->obj_shift_f);
if (fds->flags & FLUID_DOMAIN_USE_ADAPTIVE_DOMAIN) {
bbox_min[0] += (fds->cell_size[0] * (float)fds->res_min[0]);
bbox_min[1] += (fds->cell_size[1] * (float)fds->res_min[1]);
bbox_min[2] += (fds->cell_size[2] * (float)fds->res_min[2]);
add_v3_v3(bbox_min, fds->obj_shift_f);
}
/* construct low res matrix */
size_to_mat4(mds->fluidmat, mds->cell_size);
copy_v3_v3(mds->fluidmat[3], bbox_min);
size_to_mat4(fds->fluidmat, fds->cell_size);
copy_v3_v3(fds->fluidmat[3], bbox_min);
/* The smoke simulator stores voxels cell-centered, whilst VDB is node
* centered, so we offset the matrix by half a voxel to compensate. */
madd_v3_v3fl(mds->fluidmat[3], mds->cell_size, 0.5f);
madd_v3_v3fl(fds->fluidmat[3], fds->cell_size, 0.5f);
mul_m4_m4m4(mds->fluidmat, mds->obmat, mds->fluidmat);
mul_m4_m4m4(fds->fluidmat, fds->obmat, fds->fluidmat);
if (mds->wt) {
if (fds->wt) {
float voxel_size_high[3];
/* construct high res matrix */
mul_v3_v3fl(voxel_size_high, mds->cell_size, 1.0f / (float)(mds->amplify + 1));
size_to_mat4(mds->fluidmat_wt, voxel_size_high);
copy_v3_v3(mds->fluidmat_wt[3], bbox_min);
mul_v3_v3fl(voxel_size_high, fds->cell_size, 1.0f / (float)(fds->amplify + 1));
size_to_mat4(fds->fluidmat_wt, voxel_size_high);
copy_v3_v3(fds->fluidmat_wt[3], bbox_min);
/* Same here, add half a voxel to adjust the position of the fluid. */
madd_v3_v3fl(mds->fluidmat_wt[3], voxel_size_high, 0.5f);
madd_v3_v3fl(fds->fluidmat_wt[3], voxel_size_high, 0.5f);
mul_m4_m4m4(mds->fluidmat_wt, mds->obmat, mds->fluidmat_wt);
mul_m4_m4m4(fds->fluidmat_wt, fds->obmat, fds->fluidmat_wt);
}
}
static int ptcache_smoke_openvdb_write(struct OpenVDBWriter *writer, void *smoke_v)
{
FluidModifierData *mmd = (FluidModifierData *)smoke_v;
FluidDomainSettings *mds = mmd->domain;
FluidModifierData *fmd = (FluidModifierData *)smoke_v;
FluidDomainSettings *fds = fmd->domain;
OpenVDBWriter_set_flags(writer, mds->openvdb_compression, (mds->openvdb_data_depth == 16));
OpenVDBWriter_set_flags(writer, fds->openvdb_compression, (fds->openvdb_data_depth == 16));
OpenVDBWriter_add_meta_int(writer, "blender/smoke/active_fields", mds->active_fields);
OpenVDBWriter_add_meta_v3_int(writer, "blender/smoke/resolution", mds->res);
OpenVDBWriter_add_meta_v3_int(writer, "blender/smoke/min_resolution", mds->res_min);
OpenVDBWriter_add_meta_v3_int(writer, "blender/smoke/max_resolution", mds->res_max);
OpenVDBWriter_add_meta_v3_int(writer, "blender/smoke/base_resolution", mds->base_res);
OpenVDBWriter_add_meta_v3(writer, "blender/smoke/min_bbox", mds->p0);
OpenVDBWriter_add_meta_v3(writer, "blender/smoke/max_bbox", mds->p1);
OpenVDBWriter_add_meta_v3(writer, "blender/smoke/dp0", mds->dp0);
OpenVDBWriter_add_meta_v3_int(writer, "blender/smoke/shift", mds->shift);
OpenVDBWriter_add_meta_v3(writer, "blender/smoke/obj_shift_f", mds->obj_shift_f);
OpenVDBWriter_add_meta_v3(writer, "blender/smoke/active_color", mds->active_color);
OpenVDBWriter_add_meta_mat4(writer, "blender/smoke/obmat", mds->obmat);
OpenVDBWriter_add_meta_int(writer, "blender/smoke/active_fields", fds->active_fields);
OpenVDBWriter_add_meta_v3_int(writer, "blender/smoke/resolution", fds->res);
OpenVDBWriter_add_meta_v3_int(writer, "blender/smoke/min_resolution", fds->res_min);
OpenVDBWriter_add_meta_v3_int(writer, "blender/smoke/max_resolution", fds->res_max);
OpenVDBWriter_add_meta_v3_int(writer, "blender/smoke/base_resolution", fds->base_res);
OpenVDBWriter_add_meta_v3(writer, "blender/smoke/min_bbox", fds->p0);
OpenVDBWriter_add_meta_v3(writer, "blender/smoke/max_bbox", fds->p1);
OpenVDBWriter_add_meta_v3(writer, "blender/smoke/dp0", fds->dp0);
OpenVDBWriter_add_meta_v3_int(writer, "blender/smoke/shift", fds->shift);
OpenVDBWriter_add_meta_v3(writer, "blender/smoke/obj_shift_f", fds->obj_shift_f);
OpenVDBWriter_add_meta_v3(writer, "blender/smoke/active_color", fds->active_color);
OpenVDBWriter_add_meta_mat4(writer, "blender/smoke/obmat", fds->obmat);
int fluid_fields = BKE_fluid_get_data_flags(mds);
int fluid_fields = BKE_fluid_get_data_flags(fds);
struct OpenVDBFloatGrid *clip_grid = NULL;
compute_fluid_matrices(mds);
compute_fluid_matrices(fds);
OpenVDBWriter_add_meta_int(writer, "blender/smoke/fluid_fields", fluid_fields);
if (mds->wt) {
if (fds->wt) {
struct OpenVDBFloatGrid *wt_density_grid;
float *dens, *react, *fuel, *flame, *tcu, *tcv, *tcw, *r, *g, *b;
smoke_turbulence_export(mds->wt, &dens, &react, &flame, &fuel, &r, &g, &b, &tcu, &tcv, &tcw);
smoke_turbulence_export(fds->wt, &dens, &react, &flame, &fuel, &r, &g, &b, &tcu, &tcv, &tcw);
wt_density_grid = OpenVDB_export_grid_fl(
writer, "density", dens, mds->res_wt, mds->fluidmat_wt, mds->clipping, NULL);
writer, "density", dens, fds->res_wt, fds->fluidmat_wt, fds->clipping, NULL);
clip_grid = wt_density_grid;
if (fluid_fields & FLUID_DOMAIN_ACTIVE_FIRE) {
OpenVDB_export_grid_fl(
writer, "flame", flame, mds->res_wt, mds->fluidmat_wt, mds->clipping, wt_density_grid);
writer, "flame", flame, fds->res_wt, fds->fluidmat_wt, fds->clipping, wt_density_grid);
OpenVDB_export_grid_fl(
writer, "fuel", fuel, mds->res_wt, mds->fluidmat_wt, mds->clipping, wt_density_grid);
writer, "fuel", fuel, fds->res_wt, fds->fluidmat_wt, fds->clipping, wt_density_grid);
OpenVDB_export_grid_fl(
writer, "react", react, mds->res_wt, mds->fluidmat_wt, mds->clipping, wt_density_grid);
writer, "react", react, fds->res_wt, fds->fluidmat_wt, fds->clipping, wt_density_grid);
}
if (fluid_fields & FLUID_DOMAIN_ACTIVE_COLORS) {
@ -1110,11 +1110,11 @@ static int ptcache_smoke_openvdb_write(struct OpenVDBWriter *writer, void *smoke
r,
g,
b,
mds->res_wt,
mds->fluidmat_wt,
fds->res_wt,
fds->fluidmat_wt,
VEC_INVARIANT,
true,
mds->clipping,
fds->clipping,
wt_density_grid);
}
@ -1123,20 +1123,20 @@ static int ptcache_smoke_openvdb_write(struct OpenVDBWriter *writer, void *smoke
tcu,
tcv,
tcw,
mds->res,
mds->fluidmat,
fds->res,
fds->fluidmat,
VEC_INVARIANT,
false,
mds->clipping,
fds->clipping,
wt_density_grid);
}
if (mds->fluid) {
if (fds->fluid) {
struct OpenVDBFloatGrid *density_grid;
float dt, dx, *dens, *react, *fuel, *flame, *heat, *heatold, *vx, *vy, *vz, *r, *g, *b;
unsigned char *obstacles;
smoke_export(mds->fluid,
smoke_export(fds->fluid,
&dt,
&dx,
&dens,
@ -1157,45 +1157,45 @@ static int ptcache_smoke_openvdb_write(struct OpenVDBWriter *writer, void *smoke
OpenVDBWriter_add_meta_fl(writer, "blender/smoke/dx", dx);
OpenVDBWriter_add_meta_fl(writer, "blender/smoke/dt", dt);
const char *name = (!mds->wt) ? "density" : "density_low";
const char *name = (!fds->wt) ? "density" : "density_low";
density_grid = OpenVDB_export_grid_fl(
writer, name, dens, mds->res, mds->fluidmat, mds->clipping, NULL);
clip_grid = mds->wt ? clip_grid : density_grid;
writer, name, dens, fds->res, fds->fluidmat, fds->clipping, NULL);
clip_grid = fds->wt ? clip_grid : density_grid;
OpenVDB_export_grid_fl(
writer, "shadow", mds->shadow, mds->res, mds->fluidmat, mds->clipping, NULL);
writer, "shadow", fds->shadow, fds->res, fds->fluidmat, fds->clipping, NULL);
if (fluid_fields & FLUID_DOMAIN_ACTIVE_HEAT) {
OpenVDB_export_grid_fl(
writer, "heat", heat, mds->res, mds->fluidmat, mds->clipping, clip_grid);
writer, "heat", heat, fds->res, fds->fluidmat, fds->clipping, clip_grid);
OpenVDB_export_grid_fl(
writer, "heat_old", heatold, mds->res, mds->fluidmat, mds->clipping, clip_grid);
writer, "heat_old", heatold, fds->res, fds->fluidmat, fds->clipping, clip_grid);
}
if (fluid_fields & FLUID_DOMAIN_ACTIVE_FIRE) {
name = (!mds->wt) ? "flame" : "flame_low";
name = (!fds->wt) ? "flame" : "flame_low";
OpenVDB_export_grid_fl(
writer, name, flame, mds->res, mds->fluidmat, mds->clipping, density_grid);
name = (!mds->wt) ? "fuel" : "fuel_low";
writer, name, flame, fds->res, fds->fluidmat, fds->clipping, density_grid);
name = (!fds->wt) ? "fuel" : "fuel_low";
OpenVDB_export_grid_fl(
writer, name, fuel, mds->res, mds->fluidmat, mds->clipping, density_grid);
name = (!mds->wt) ? "react" : "react_low";
writer, name, fuel, fds->res, fds->fluidmat, fds->clipping, density_grid);
name = (!fds->wt) ? "react" : "react_low";
OpenVDB_export_grid_fl(
writer, name, react, mds->res, mds->fluidmat, mds->clipping, density_grid);
writer, name, react, fds->res, fds->fluidmat, fds->clipping, density_grid);
}
if (fluid_fields & FLUID_DOMAIN_ACTIVE_COLORS) {
name = (!mds->wt) ? "color" : "color_low";
name = (!fds->wt) ? "color" : "color_low";
OpenVDB_export_grid_vec(writer,
name,
r,
g,
b,
mds->res,
mds->fluidmat,
fds->res,
fds->fluidmat,
VEC_INVARIANT,
true,
mds->clipping,
fds->clipping,
density_grid);
}
@ -1204,14 +1204,14 @@ static int ptcache_smoke_openvdb_write(struct OpenVDBWriter *writer, void *smoke
vx,
vy,
vz,
mds->res,
mds->fluidmat,
fds->res,
fds->fluidmat,
VEC_CONTRAVARIANT_RELATIVE,
false,
mds->clipping,
fds->clipping,
clip_grid);
OpenVDB_export_grid_ch(
writer, "obstacles", obstacles, mds->res, mds->fluidmat, mds->clipping, NULL);
writer, "obstacles", obstacles, fds->res, fds->fluidmat, fds->clipping, NULL);
}
return 1;
@ -1219,38 +1219,38 @@ static int ptcache_smoke_openvdb_write(struct OpenVDBWriter *writer, void *smoke
static int ptcache_smoke_openvdb_read(struct OpenVDBReader *reader, void *smoke_v)
{
FluidModifierData *mmd = (FluidModifierData *)smoke_v;
FluidModifierData *fmd = (FluidModifierData *)smoke_v;
if (!mmd) {
if (!fmd) {
return 0;
}
FluidDomainSettings *mds = mmd->domain;
FluidDomainSettings *fds = fmd->domain;
int fluid_fields = BKE_fluid_get_data_flags(mds);
int fluid_fields = BKE_fluid_get_data_flags(fds);
int active_fields, cache_fields = 0;
int cache_res[3];
float cache_dx;
bool reallocate = false;
OpenVDBReader_get_meta_v3_int(reader, "blender/smoke/min_resolution", mds->res_min);
OpenVDBReader_get_meta_v3_int(reader, "blender/smoke/max_resolution", mds->res_max);
OpenVDBReader_get_meta_v3_int(reader, "blender/smoke/base_resolution", mds->base_res);
OpenVDBReader_get_meta_v3(reader, "blender/smoke/min_bbox", mds->p0);
OpenVDBReader_get_meta_v3(reader, "blender/smoke/max_bbox", mds->p1);
OpenVDBReader_get_meta_v3(reader, "blender/smoke/dp0", mds->dp0);
OpenVDBReader_get_meta_v3_int(reader, "blender/smoke/shift", mds->shift);
OpenVDBReader_get_meta_v3(reader, "blender/smoke/obj_shift_f", mds->obj_shift_f);
OpenVDBReader_get_meta_v3(reader, "blender/smoke/active_color", mds->active_color);
OpenVDBReader_get_meta_mat4(reader, "blender/smoke/obmat", mds->obmat);
OpenVDBReader_get_meta_v3_int(reader, "blender/smoke/min_resolution", fds->res_min);
OpenVDBReader_get_meta_v3_int(reader, "blender/smoke/max_resolution", fds->res_max);
OpenVDBReader_get_meta_v3_int(reader, "blender/smoke/base_resolution", fds->base_res);
OpenVDBReader_get_meta_v3(reader, "blender/smoke/min_bbox", fds->p0);
OpenVDBReader_get_meta_v3(reader, "blender/smoke/max_bbox", fds->p1);
OpenVDBReader_get_meta_v3(reader, "blender/smoke/dp0", fds->dp0);
OpenVDBReader_get_meta_v3_int(reader, "blender/smoke/shift", fds->shift);
OpenVDBReader_get_meta_v3(reader, "blender/smoke/obj_shift_f", fds->obj_shift_f);
OpenVDBReader_get_meta_v3(reader, "blender/smoke/active_color", fds->active_color);
OpenVDBReader_get_meta_mat4(reader, "blender/smoke/obmat", fds->obmat);
OpenVDBReader_get_meta_int(reader, "blender/smoke/fluid_fields", &cache_fields);
OpenVDBReader_get_meta_int(reader, "blender/smoke/active_fields", &active_fields);
OpenVDBReader_get_meta_fl(reader, "blender/smoke/dx", &cache_dx);
OpenVDBReader_get_meta_v3_int(reader, "blender/smoke/resolution", cache_res);
/* check if resolution has changed */
if (mds->res[0] != cache_res[0] || mds->res[1] != cache_res[1] || mds->res[2] != cache_res[2]) {
if (mds->flags & FLUID_DOMAIN_USE_ADAPTIVE_DOMAIN) {
if (fds->res[0] != cache_res[0] || fds->res[1] != cache_res[1] || fds->res[2] != cache_res[2]) {
if (fds->flags & FLUID_DOMAIN_USE_ADAPTIVE_DOMAIN) {
reallocate = true;
}
else {
@ -1259,24 +1259,24 @@ static int ptcache_smoke_openvdb_read(struct OpenVDBReader *reader, void *smoke_
}
/* check if active fields have changed */
if ((fluid_fields != cache_fields) || (active_fields != mds->active_fields)) {
if ((fluid_fields != cache_fields) || (active_fields != fds->active_fields)) {
reallocate = true;
}
/* reallocate fluid if needed*/
if (reallocate) {
mds->active_fields = active_fields | cache_fields;
BKE_fluid_reallocate_fluid(mds, cache_dx, cache_res, 1);
mds->dx = cache_dx;
copy_v3_v3_int(mds->res, cache_res);
mds->total_cells = cache_res[0] * cache_res[1] * cache_res[2];
fds->active_fields = active_fields | cache_fields;
BKE_fluid_reallocate_fluid(fds, cache_dx, cache_res, 1);
fds->dx = cache_dx;
copy_v3_v3_int(fds->res, cache_res);
fds->total_cells = cache_res[0] * cache_res[1] * cache_res[2];
}
if (mds->fluid) {
if (fds->fluid) {
float dt, dx, *dens, *react, *fuel, *flame, *heat, *heatold, *vx, *vy, *vz, *r, *g, *b;
unsigned char *obstacles;
smoke_export(mds->fluid,
smoke_export(fds->fluid,
&dt,
&dx,
&dens,
@ -1296,52 +1296,52 @@ static int ptcache_smoke_openvdb_read(struct OpenVDBReader *reader, void *smoke_
OpenVDBReader_get_meta_fl(reader, "blender/smoke/dt", &dt);
OpenVDB_import_grid_fl(reader, "shadow", &mds->shadow, mds->res);
OpenVDB_import_grid_fl(reader, "shadow", &fds->shadow, fds->res);
const char *name = (!mds->wt) ? "density" : "density_low";
OpenVDB_import_grid_fl(reader, name, &dens, mds->res);
const char *name = (!fds->wt) ? "density" : "density_low";
OpenVDB_import_grid_fl(reader, name, &dens, fds->res);
if (cache_fields & FLUID_DOMAIN_ACTIVE_HEAT) {
OpenVDB_import_grid_fl(reader, "heat", &heat, mds->res);
OpenVDB_import_grid_fl(reader, "heat_old", &heatold, mds->res);
OpenVDB_import_grid_fl(reader, "heat", &heat, fds->res);
OpenVDB_import_grid_fl(reader, "heat_old", &heatold, fds->res);
}
if (cache_fields & FLUID_DOMAIN_ACTIVE_FIRE) {
name = (!mds->wt) ? "flame" : "flame_low";
OpenVDB_import_grid_fl(reader, name, &flame, mds->res);
name = (!mds->wt) ? "fuel" : "fuel_low";
OpenVDB_import_grid_fl(reader, name, &fuel, mds->res);
name = (!mds->wt) ? "react" : "react_low";
OpenVDB_import_grid_fl(reader, name, &react, mds->res);
name = (!fds->wt) ? "flame" : "flame_low";
OpenVDB_import_grid_fl(reader, name, &flame, fds->res);
name = (!fds->wt) ? "fuel" : "fuel_low";
OpenVDB_import_grid_fl(reader, name, &fuel, fds->res);
name = (!fds->wt) ? "react" : "react_low";
OpenVDB_import_grid_fl(reader, name, &react, fds->res);
}
if (cache_fields & FLUID_DOMAIN_ACTIVE_COLORS) {
name = (!mds->wt) ? "color" : "color_low";
OpenVDB_import_grid_vec(reader, name, &r, &g, &b, mds->res);
name = (!fds->wt) ? "color" : "color_low";
OpenVDB_import_grid_vec(reader, name, &r, &g, &b, fds->res);
}
OpenVDB_import_grid_vec(reader, "velocity", &vx, &vy, &vz, mds->res);
OpenVDB_import_grid_ch(reader, "obstacles", &obstacles, mds->res);
OpenVDB_import_grid_vec(reader, "velocity", &vx, &vy, &vz, fds->res);
OpenVDB_import_grid_ch(reader, "obstacles", &obstacles, fds->res);
}
if (mds->wt) {
if (fds->wt) {
float *dens, *react, *fuel, *flame, *tcu, *tcv, *tcw, *r, *g, *b;
smoke_turbulence_export(mds->wt, &dens, &react, &flame, &fuel, &r, &g, &b, &tcu, &tcv, &tcw);
smoke_turbulence_export(fds->wt, &dens, &react, &flame, &fuel, &r, &g, &b, &tcu, &tcv, &tcw);
OpenVDB_import_grid_fl(reader, "density", &dens, mds->res_wt);
OpenVDB_import_grid_fl(reader, "density", &dens, fds->res_wt);
if (cache_fields & FLUID_DOMAIN_ACTIVE_FIRE) {
OpenVDB_import_grid_fl(reader, "flame", &flame, mds->res_wt);
OpenVDB_import_grid_fl(reader, "fuel", &fuel, mds->res_wt);
OpenVDB_import_grid_fl(reader, "react", &react, mds->res_wt);
OpenVDB_import_grid_fl(reader, "flame", &flame, fds->res_wt);
OpenVDB_import_grid_fl(reader, "fuel", &fuel, fds->res_wt);
OpenVDB_import_grid_fl(reader, "react", &react, fds->res_wt);
}
if (cache_fields & FLUID_DOMAIN_ACTIVE_COLORS) {
OpenVDB_import_grid_vec(reader, "color", &r, &g, &b, mds->res_wt);
OpenVDB_import_grid_vec(reader, "color", &r, &g, &b, fds->res_wt);
}
OpenVDB_import_grid_vec(reader, "texture coordinates", &tcu, &tcv, &tcw, mds->res);
OpenVDB_import_grid_vec(reader, "texture coordinates", &tcu, &tcv, &tcw, fds->res);
}
OpenVDBReader_free(reader);
@ -1732,21 +1732,21 @@ void BKE_ptcache_id_from_cloth(PTCacheID *pid, Object *ob, ClothModifierData *cl
pid->max_step = 1;
pid->file_type = PTCACHE_FILE_PTCACHE;
}
void BKE_ptcache_id_from_smoke(PTCacheID *pid, struct Object *ob, struct FluidModifierData *mmd)
void BKE_ptcache_id_from_smoke(PTCacheID *pid, struct Object *ob, struct FluidModifierData *fmd)
{
FluidDomainSettings *mds = mmd->domain;
FluidDomainSettings *fds = fmd->domain;
memset(pid, 0, sizeof(PTCacheID));
pid->owner_id = &ob->id;
pid->calldata = mmd;
pid->calldata = fmd;
pid->type = PTCACHE_TYPE_SMOKE_DOMAIN;
pid->stack_index = mds->point_cache[0]->index;
pid->stack_index = fds->point_cache[0]->index;
pid->cache = mds->point_cache[0];
pid->cache_ptr = &(mds->point_cache[0]);
pid->ptcaches = &(mds->ptcaches[0]);
pid->cache = fds->point_cache[0];
pid->cache_ptr = &(fds->point_cache[0]);
pid->ptcaches = &(fds->ptcaches[0]);
pid->totpoint = pid->totwrite = ptcache_smoke_totpoint;
pid->error = ptcache_smoke_error;
@ -1771,16 +1771,16 @@ void BKE_ptcache_id_from_smoke(PTCacheID *pid, struct Object *ob, struct FluidMo
pid->data_types = 0;
pid->info_types = 0;
if (mds->fluid) {
if (fds->fluid) {
pid->data_types |= (1 << BPHYS_DATA_SMOKE_LOW);
if (mds->flags & FLUID_DOMAIN_USE_NOISE) {
if (fds->flags & FLUID_DOMAIN_USE_NOISE) {
pid->data_types |= (1 << BPHYS_DATA_SMOKE_HIGH);
}
}
pid->default_step = 1;
pid->max_step = 1;
pid->file_type = mmd->domain->cache_file_format;
pid->file_type = fmd->domain->cache_file_format;
}
void BKE_ptcache_id_from_dynamicpaint(PTCacheID *pid, Object *ob, DynamicPaintSurface *surface)
@ -2024,8 +2024,8 @@ static bool foreach_object_modifier_ptcache(Object *object,
}
}
else if (md->type == eModifierType_Fluid) {
FluidModifierData *mmd = (FluidModifierData *)md;
if (mmd->type & MOD_FLUID_TYPE_DOMAIN) {
FluidModifierData *fmd = (FluidModifierData *)md;
if (fmd->type & MOD_FLUID_TYPE_DOMAIN) {
BKE_ptcache_id_from_smoke(&pid, object, (FluidModifierData *)md);
if (!callback(&pid, callback_user_data)) {
return false;
@ -3873,8 +3873,8 @@ int BKE_ptcache_object_reset(Scene *scene, Object *ob, int mode)
reset |= BKE_ptcache_id_reset(scene, &pid, mode);
}
if (md->type == eModifierType_Fluid) {
FluidModifierData *mmd = (FluidModifierData *)md;
if (mmd->type & MOD_FLUID_TYPE_DOMAIN) {
FluidModifierData *fmd = (FluidModifierData *)md;
if (fmd->type & MOD_FLUID_TYPE_DOMAIN) {
BKE_ptcache_id_from_smoke(&pid, ob, (FluidModifierData *)md);
reset |= BKE_ptcache_id_reset(scene, &pid, mode);
}

118
source/blender/blenloader/intern/readfile.c
View File

@ -5285,18 +5285,18 @@ static void lib_link_object(BlendLibReader *reader, Object *ob)
}
{
FluidModifierData *mmd = (FluidModifierData *)BKE_modifiers_findby_type(ob,
FluidModifierData *fmd = (FluidModifierData *)BKE_modifiers_findby_type(ob,
eModifierType_Fluid);
if (mmd && (mmd->type == MOD_FLUID_TYPE_DOMAIN) && mmd->domain) {
if (fmd && (fmd->type == MOD_FLUID_TYPE_DOMAIN) && fmd->domain) {
/* Flag for refreshing the simulation after loading */
mmd->domain->flags |= FLUID_DOMAIN_FILE_LOAD;
fmd->domain->flags |= FLUID_DOMAIN_FILE_LOAD;
}
else if (mmd && (mmd->type == MOD_FLUID_TYPE_FLOW) && mmd->flow) {
mmd->flow->flags &= ~FLUID_FLOW_NEEDS_UPDATE;
else if (fmd && (fmd->type == MOD_FLUID_TYPE_FLOW) && fmd->flow) {
fmd->flow->flags &= ~FLUID_FLOW_NEEDS_UPDATE;
}
else if (mmd && (mmd->type == MOD_FLUID_TYPE_EFFEC) && mmd->effector) {
mmd->effector->flags &= ~FLUID_EFFECTOR_NEEDS_UPDATE;
else if (fmd && (fmd->type == MOD_FLUID_TYPE_EFFEC) && fmd->effector) {
fmd->effector->flags &= ~FLUID_EFFECTOR_NEEDS_UPDATE;
}
}
@ -5589,42 +5589,42 @@ static void direct_link_modifiers(BlendDataReader *reader, ListBase *lb, Object
}
else if (md->type == eModifierType_Fluid) {
FluidModifierData *mmd = (FluidModifierData *)md;
FluidModifierData *fmd = (FluidModifierData *)md;
if (mmd->type == MOD_FLUID_TYPE_DOMAIN) {
mmd->flow = NULL;
mmd->effector = NULL;
BLO_read_data_address(reader, &mmd->domain);
mmd->domain->mmd = mmd;
if (fmd->type == MOD_FLUID_TYPE_DOMAIN) {
fmd->flow = NULL;
fmd->effector = NULL;
BLO_read_data_address(reader, &fmd->domain);
fmd->domain->fmd = fmd;
mmd->domain->fluid = NULL;
mmd->domain->fluid_mutex = BLI_rw_mutex_alloc();
mmd->domain->tex_density = NULL;
mmd->domain->tex_color = NULL;
mmd->domain->tex_shadow = NULL;
mmd->domain->tex_flame = NULL;
mmd->domain->tex_flame_coba = NULL;
mmd->domain->tex_coba = NULL;
mmd->domain->tex_field = NULL;
mmd->domain->tex_velocity_x = NULL;
mmd->domain->tex_velocity_y = NULL;
mmd->domain->tex_velocity_z = NULL;
mmd->domain->tex_wt = NULL;
mmd->domain->mesh_velocities = NULL;
BLO_read_data_address(reader, &mmd->domain->coba);
fmd->domain->fluid = NULL;
fmd->domain->fluid_mutex = BLI_rw_mutex_alloc();
fmd->domain->tex_density = NULL;
fmd->domain->tex_color = NULL;
fmd->domain->tex_shadow = NULL;
fmd->domain->tex_flame = NULL;
fmd->domain->tex_flame_coba = NULL;
fmd->domain->tex_coba = NULL;
fmd->domain->tex_field = NULL;
fmd->domain->tex_velocity_x = NULL;
fmd->domain->tex_velocity_y = NULL;
fmd->domain->tex_velocity_z = NULL;
fmd->domain->tex_wt = NULL;
fmd->domain->mesh_velocities = NULL;
BLO_read_data_address(reader, &fmd->domain->coba);
BLO_read_data_address(reader, &mmd->domain->effector_weights);
if (!mmd->domain->effector_weights) {
mmd->domain->effector_weights = BKE_effector_add_weights(NULL);
BLO_read_data_address(reader, &fmd->domain->effector_weights);
if (!fmd->domain->effector_weights) {
fmd->domain->effector_weights = BKE_effector_add_weights(NULL);
}
direct_link_pointcache_list(
reader, &(mmd->domain->ptcaches[0]), &(mmd->domain->point_cache[0]), 1);
reader, &(fmd->domain->ptcaches[0]), &(fmd->domain->point_cache[0]), 1);
/* Manta sim uses only one cache from now on, so store pointer convert */
if (mmd->domain->ptcaches[1].first || mmd->domain->point_cache[1]) {
if (mmd->domain->point_cache[1]) {
PointCache *cache = BLO_read_get_new_data_address(reader, mmd->domain->point_cache[1]);
if (fmd->domain->ptcaches[1].first || fmd->domain->point_cache[1]) {
if (fmd->domain->point_cache[1]) {
PointCache *cache = BLO_read_get_new_data_address(reader, fmd->domain->point_cache[1]);
if (cache->flag & PTCACHE_FAKE_SMOKE) {
/* Manta-sim/smoke was already saved in "new format" and this cache is a fake one. */
}
@ -5635,35 +5635,35 @@ static void direct_link_modifiers(BlendDataReader *reader, ListBase *lb, Object
}
BKE_ptcache_free(cache);
}
BLI_listbase_clear(&mmd->domain->ptcaches[1]);
mmd->domain->point_cache[1] = NULL;
BLI_listbase_clear(&fmd->domain->ptcaches[1]);
fmd->domain->point_cache[1] = NULL;
}
}
else if (mmd->type == MOD_FLUID_TYPE_FLOW) {
mmd->domain = NULL;
mmd->effector = NULL;
BLO_read_data_address(reader, &mmd->flow);
mmd->flow->mmd = mmd;
mmd->flow->mesh = NULL;
mmd->flow->verts_old = NULL;
mmd->flow->numverts = 0;
BLO_read_data_address(reader, &mmd->flow->psys);
else if (fmd->type == MOD_FLUID_TYPE_FLOW) {
fmd->domain = NULL;
fmd->effector = NULL;
BLO_read_data_address(reader, &fmd->flow);
fmd->flow->fmd = fmd;
fmd->flow->mesh = NULL;
fmd->flow->verts_old = NULL;
fmd->flow->numverts = 0;
BLO_read_data_address(reader, &fmd->flow->psys);
}
else if (mmd->type == MOD_FLUID_TYPE_EFFEC) {
mmd->flow = NULL;
mmd->domain = NULL;
BLO_read_data_address(reader, &mmd->effector);
if (mmd->effector) {
mmd->effector->mmd = mmd;
mmd->effector->verts_old = NULL;
mmd->effector->numverts = 0;
mmd->effector->mesh = NULL;
else if (fmd->type == MOD_FLUID_TYPE_EFFEC) {
fmd->flow = NULL;
fmd->domain = NULL;
BLO_read_data_address(reader, &fmd->effector);
if (fmd->effector) {
fmd->effector->fmd = fmd;
fmd->effector->verts_old = NULL;
fmd->effector->numverts = 0;
fmd->effector->mesh = NULL;
}
else {
mmd->type = 0;
mmd->flow = NULL;
mmd->domain = NULL;
mmd->effector = NULL;
fmd->type = 0;
fmd->flow = NULL;
fmd->domain = NULL;
fmd->effector = NULL;
}
}
}

22
source/blender/blenloader/intern/versioning_250.c
View File

@ -1793,18 +1793,18 @@ void blo_do_versions_250(FileData *fd, Library *lib, Main *bmain)
for (md = ob->modifiers.first; md; md = md->next) {
if (md->type == eModifierType_Fluid) {
FluidModifierData *mmd = (FluidModifierData *)md;
FluidModifierData *fmd = (FluidModifierData *)md;
if ((mmd->type & MOD_FLUID_TYPE_DOMAIN) && mmd->domain) {
mmd->domain->vorticity = 2.0f;
mmd->domain->time_scale = 1.0f;
if ((fmd->type & MOD_FLUID_TYPE_DOMAIN) && fmd->domain) {
fmd->domain->vorticity = 2.0f;
fmd->domain->time_scale = 1.0f;
if (!(mmd->domain->flags & (1 << 4))) {
if (!(fmd->domain->flags & (1 << 4))) {
continue;
}
/* delete old MOD_SMOKE_INITVELOCITY flag */
mmd->domain->flags &= ~(1 << 4);
fmd->domain->flags &= ~(1 << 4);
/* for now just add it to all flow objects in the scene */
{
@ -1813,18 +1813,18 @@ void blo_do_versions_250(FileData *fd, Library *lib, Main *bmain)
ModifierData *md2;
for (md2 = ob2->modifiers.first; md2; md2 = md2->next) {
if (md2->type == eModifierType_Fluid) {
FluidModifierData *mmd2 = (FluidModifierData *)md2;
FluidModifierData *fmd2 = (FluidModifierData *)md2;
if ((mmd2->type & MOD_FLUID_TYPE_FLOW) && mmd2->flow) {
mmd2->flow->flags |= FLUID_FLOW_INITVELOCITY;
if ((fmd2->type & MOD_FLUID_TYPE_FLOW) && fmd2->flow) {
fmd2->flow->flags |= FLUID_FLOW_INITVELOCITY;
}
}
}
}
}
}
else if ((mmd->type & MOD_FLUID_TYPE_FLOW) && mmd->flow) {
mmd->flow->vel_multi = 1.0f;
else if ((fmd->type & MOD_FLUID_TYPE_FLOW) && fmd->flow) {
fmd->flow->vel_multi = 1.0f;
}
}
}

70
source/blender/blenloader/intern/versioning_260.c
View File

@ -1310,11 +1310,11 @@ void blo_do_versions_260(FileData *fd, Library *UNUSED(lib), Main *bmain)
ModifierData *md;
for (md = ob->modifiers.first; md; md = md->next) {
if (md->type == eModifierType_Fluid) {
FluidModifierData *mmd = (FluidModifierData *)md;
if ((mmd->type & MOD_FLUID_TYPE_DOMAIN) && mmd->domain) {
int maxres = max_iii(mmd->domain->res[0], mmd->domain->res[1], mmd->domain->res[2]);
mmd->domain->scale = mmd->domain->dx * maxres;
mmd->domain->dx = 1.0f / mmd->domain->scale;
FluidModifierData *fmd = (FluidModifierData *)md;
if ((fmd->type & MOD_FLUID_TYPE_DOMAIN) && fmd->domain) {
int maxres = max_iii(fmd->domain->res[0], fmd->domain->res[1], fmd->domain->res[2]);
fmd->domain->scale = fmd->domain->dx * maxres;
fmd->domain->dx = 1.0f / fmd->domain->scale;
}
}
}
@ -1628,30 +1628,30 @@ void blo_do_versions_260(FileData *fd, Library *UNUSED(lib), Main *bmain)
ModifierData *md;
for (md = ob->modifiers.first; md; md = md->next) {
if (md->type == eModifierType_Fluid) {
FluidModifierData *mmd = (FluidModifierData *)md;
if ((mmd->type & MOD_FLUID_TYPE_DOMAIN) && mmd->domain) {
FluidModifierData *fmd = (FluidModifierData *)md;
if ((fmd->type & MOD_FLUID_TYPE_DOMAIN) && fmd->domain) {
/* keep branch saves if possible */
if (!mmd->domain->flame_max_temp) {
mmd->domain->burning_rate = 0.75f;
mmd->domain->flame_smoke = 1.0f;
mmd->domain->flame_vorticity = 0.5f;
mmd->domain->flame_ignition = 1.25f;
mmd->domain->flame_max_temp = 1.75f;
mmd->domain->adapt_threshold = 0.02f;
mmd->domain->adapt_margin = 4;
mmd->domain->flame_smoke_color[0] = 0.7f;
mmd->domain->flame_smoke_color[1] = 0.7f;
mmd->domain->flame_smoke_color[2] = 0.7f;
if (!fmd->domain->flame_max_temp) {
fmd->domain->burning_rate = 0.75f;
fmd->domain->flame_smoke = 1.0f;
fmd->domain->flame_vorticity = 0.5f;
fmd->domain->flame_ignition = 1.25f;
fmd->domain->flame_max_temp = 1.75f;
fmd->domain->adapt_threshold = 0.02f;
fmd->domain->adapt_margin = 4;
fmd->domain->flame_smoke_color[0] = 0.7f;
fmd->domain->flame_smoke_color[1] = 0.7f;
fmd->domain->flame_smoke_color[2] = 0.7f;
}
}
else if ((mmd->type & MOD_FLUID_TYPE_FLOW) && mmd->flow) {
if (!mmd->flow->texture_size) {
mmd->flow->fuel_amount = 1.0;
mmd->flow->surface_distance = 1.5;
mmd->flow->color[0] = 0.7f;
mmd->flow->color[1] = 0.7f;
mmd->flow->color[2] = 0.7f;
mmd->flow->texture_size = 1.0f;
else if ((fmd->type & MOD_FLUID_TYPE_FLOW) && fmd->flow) {
if (!fmd->flow->texture_size) {
fmd->flow->fuel_amount = 1.0;
fmd->flow->surface_distance = 1.5;
fmd->flow->color[0] = 0.7f;
fmd->flow->color[1] = 0.7f;
fmd->flow->color[2] = 0.7f;
fmd->flow->texture_size = 1.0f;
}
}
}
@ -2158,13 +2158,13 @@ void blo_do_versions_260(FileData *fd, Library *UNUSED(lib), Main *bmain)
ModifierData *md;
for (md = ob->modifiers.first; md; md = md->next) {
if (md->type == eModifierType_Fluid) {
FluidModifierData *mmd = (FluidModifierData *)md;
if ((mmd->type & MOD_FLUID_TYPE_DOMAIN) && mmd->domain) {
if (mmd->domain->flags & FLUID_DOMAIN_USE_HIGH_SMOOTH) {
mmd->domain->highres_sampling = SM_HRES_LINEAR;
FluidModifierData *fmd = (FluidModifierData *)md;
if ((fmd->type & MOD_FLUID_TYPE_DOMAIN) && fmd->domain) {
if (fmd->domain->flags & FLUID_DOMAIN_USE_HIGH_SMOOTH) {
fmd->domain->highres_sampling = SM_HRES_LINEAR;
}
else {
mmd->domain->highres_sampling = SM_HRES_NEAREST;
fmd->domain->highres_sampling = SM_HRES_NEAREST;
}
}
}
@ -2225,10 +2225,10 @@ void blo_do_versions_260(FileData *fd, Library *UNUSED(lib), Main *bmain)
ModifierData *md;
for (md = ob->modifiers.first; md; md = md->next) {
if (md->type == eModifierType_Fluid) {
FluidModifierData *mmd = (FluidModifierData *)md;
if ((mmd->type & MOD_FLUID_TYPE_FLOW) && mmd->flow) {
if (!mmd->flow->particle_size) {
mmd->flow->particle_size = 1.0f;
FluidModifierData *fmd = (FluidModifierData *)md;
if ((fmd->type & MOD_FLUID_TYPE_FLOW) && fmd->flow) {
if (!fmd->flow->particle_size) {
fmd->flow->particle_size = 1.0f;
}
}
}

16
source/blender/blenloader/intern/versioning_270.c
View File

@ -1470,11 +1470,11 @@ void blo_do_versions_270(FileData *fd, Library *UNUSED(lib), Main *bmain)
for (ob = bmain->objects.first; ob; ob = ob->id.next) {
for (md = ob->modifiers.first; md; md = md->next) {
if (md->type == eModifierType_Fluid) {
FluidModifierData *mmd = (FluidModifierData *)md;
if (mmd->domain) {
mmd->domain->slice_per_voxel = 5.0f;
mmd->domain->slice_depth = 0.5f;
mmd->domain->display_thickness = 1.0f;
FluidModifierData *fmd = (FluidModifierData *)md;
if (fmd->domain) {
fmd->domain->slice_per_voxel = 5.0f;
fmd->domain->slice_depth = 0.5f;
fmd->domain->display_thickness = 1.0f;
}
}
}
@ -1640,9 +1640,9 @@ void blo_do_versions_270(FileData *fd, Library *UNUSED(lib), Main *bmain)
for (ob = bmain->objects.first; ob; ob = ob->id.next) {
for (md = ob->modifiers.first; md; md = md->next) {
if (md->type == eModifierType_Fluid) {
FluidModifierData *mmd = (FluidModifierData *)md;
if (mmd->domain) {
mmd->domain->clipping = 1e-3f;
FluidModifierData *fmd = (FluidModifierData *)md;
if (fmd->domain) {
fmd->domain->clipping = 1e-3f;
}
}
}

36
source/blender/blenloader/intern/writefile.c
View File

@ -1670,37 +1670,37 @@ static void write_modifiers(BlendWriter *writer, ListBase *modbase)
write_pointcaches(writer, &clmd->ptcaches);
}
else if (md->type == eModifierType_Fluid) {
FluidModifierData *mmd = (FluidModifierData *)md;
FluidModifierData *fmd = (FluidModifierData *)md;
if (mmd->type & MOD_FLUID_TYPE_DOMAIN) {
BLO_write_struct(writer, FluidDomainSettings, mmd->domain);
if (fmd->type & MOD_FLUID_TYPE_DOMAIN) {
BLO_write_struct(writer, FluidDomainSettings, fmd->domain);
if (mmd->domain) {
write_pointcaches(writer, &(mmd->domain->ptcaches[0]));
if (fmd->domain) {
write_pointcaches(writer, &(fmd->domain->ptcaches[0]));
/* create fake pointcache so that old blender versions can read it */
mmd->domain->point_cache[1] = BKE_ptcache_add(&mmd->domain->ptcaches[1]);
mmd->domain->point_cache[1]->flag |= PTCACHE_DISK_CACHE | PTCACHE_FAKE_SMOKE;
mmd->domain->point_cache[1]->step = 1;
fmd->domain->point_cache[1] = BKE_ptcache_add(&fmd->domain->ptcaches[1]);
fmd->domain->point_cache[1]->flag |= PTCACHE_DISK_CACHE | PTCACHE_FAKE_SMOKE;
fmd->domain->point_cache[1]->step = 1;
write_pointcaches(writer, &(mmd->domain->ptcaches[1]));
write_pointcaches(writer, &(fmd->domain->ptcaches[1]));
if (mmd->domain->coba) {
BLO_write_struct(writer, ColorBand, mmd->domain->coba);
if (fmd->domain->coba) {
BLO_write_struct(writer, ColorBand, fmd->domain->coba);
}
/* cleanup the fake pointcache */
BKE_ptcache_free_list(&mmd->domain->ptcaches[1]);
mmd->domain->point_cache[1] = NULL;
BKE_ptcache_free_list(&fmd->domain->ptcaches[1]);
fmd->domain->point_cache[1] = NULL;
BLO_write_struct(writer, EffectorWeights, mmd->domain->effector_weights);
BLO_write_struct(writer, EffectorWeights, fmd->domain->effector_weights);
}
}
else if (mmd->type & MOD_FLUID_TYPE_FLOW) {
BLO_write_struct(writer, FluidFlowSettings, mmd->flow);
else if (fmd->type & MOD_FLUID_TYPE_FLOW) {
BLO_write_struct(writer, FluidFlowSettings, fmd->flow);
}
else if (mmd->type & MOD_FLUID_TYPE_EFFEC) {
BLO_write_struct(writer, FluidEffectorSettings, mmd->effector);
else if (fmd->type & MOD_FLUID_TYPE_EFFEC) {
BLO_write_struct(writer, FluidEffectorSettings, fmd->effector);
}
}
else if (md->type == eModifierType_Fluidsim) {

38
source/blender/draw/engines/eevee/eevee_volumes.c
View File

@ -487,11 +487,11 @@ static bool eevee_volume_object_mesh_init(Scene *scene,
if ((md = BKE_modifiers_findby_type(ob, eModifierType_Fluid)) &&
(BKE_modifier_is_enabled(scene, md, eModifierMode_Realtime)) &&
((FluidModifierData *)md)->domain != NULL) {
FluidModifierData *mmd = (FluidModifierData *)md;
FluidDomainSettings *mds = mmd->domain;
FluidModifierData *fmd = (FluidModifierData *)md;
FluidDomainSettings *fds = fmd->domain;
/* Don't try to show liquid domains here. */
if (!mds->fluid || !(mds->type == FLUID_DOMAIN_TYPE_GAS)) {
if (!fds->fluid || !(fds->type == FLUID_DOMAIN_TYPE_GAS)) {
return false;
}
@ -500,33 +500,33 @@ static bool eevee_volume_object_mesh_init(Scene *scene,
#if 0
const DRWContextState *draw_ctx = DRW_context_state_get();
const bool show_smoke = ((int)DEG_get_ctime(draw_ctx->depsgraph) >=
*mds->point_cache[0]->startframe);
*fds->point_cache[0]->startframe);
#endif
if (mds->fluid && (mds->type == FLUID_DOMAIN_TYPE_GAS) /* && show_smoke */) {
if (!(mds->flags & FLUID_DOMAIN_USE_NOISE)) {
GPU_create_smoke(mmd, 0);
if (fds->fluid && (fds->type == FLUID_DOMAIN_TYPE_GAS) /* && show_smoke */) {
if (!(fds->flags & FLUID_DOMAIN_USE_NOISE)) {
GPU_create_smoke(fmd, 0);
}
else if (mds->flags & FLUID_DOMAIN_USE_NOISE) {
GPU_create_smoke(mmd, 1);
else if (fds->flags & FLUID_DOMAIN_USE_NOISE) {
GPU_create_smoke(fmd, 1);
}
BLI_addtail(&e_data.smoke_domains, BLI_genericNodeN(mmd));
BLI_addtail(&e_data.smoke_domains, BLI_genericNodeN(fmd));
}
LISTBASE_FOREACH (GPUMaterialVolumeGrid *, gpu_grid, gpu_grids) {
if (STREQ(gpu_grid->name, "density")) {
DRW_shgroup_uniform_texture_ref(grp,
gpu_grid->sampler_name,
mds->tex_density ? &mds->tex_density :
fds->tex_density ? &fds->tex_density :
&e_data.dummy_density);
}
else if (STREQ(gpu_grid->name, "color")) {
DRW_shgroup_uniform_texture_ref(
grp, gpu_grid->sampler_name, mds->tex_color ? &mds->tex_color : &e_data.dummy_density);
grp, gpu_grid->sampler_name, fds->tex_color ? &fds->tex_color : &e_data.dummy_density);
}
else if (STREQ(gpu_grid->name, "flame") || STREQ(gpu_grid->name, "temperature")) {
DRW_shgroup_uniform_texture_ref(
grp, gpu_grid->sampler_name, mds->tex_flame ? &mds->tex_flame : &e_data.dummy_flame);
grp, gpu_grid->sampler_name, fds->tex_flame ? &fds->tex_flame : &e_data.dummy_flame);
}
else {
DRW_shgroup_uniform_texture_ref(grp, gpu_grid->sampler_name, &e_data.dummy_density);
@ -534,14 +534,14 @@ static bool eevee_volume_object_mesh_init(Scene *scene,
}
/* Constant Volume color. */
bool use_constant_color = ((mds->active_fields & FLUID_DOMAIN_ACTIVE_COLORS) == 0 &&
(mds->active_fields & FLUID_DOMAIN_ACTIVE_COLOR_SET) != 0);
bool use_constant_color = ((fds->active_fields & FLUID_DOMAIN_ACTIVE_COLORS) == 0 &&
(fds->active_fields & FLUID_DOMAIN_ACTIVE_COLOR_SET) != 0);
DRW_shgroup_uniform_vec3(
grp, "volumeColor", (use_constant_color) ? mds->active_color : white, 1);
grp, "volumeColor", (use_constant_color) ? fds->active_color : white, 1);
/* Output is such that 0..1 maps to 0..1000K */
DRW_shgroup_uniform_vec2(grp, "volumeTemperature", &mds->flame_ignition, 1);
DRW_shgroup_uniform_vec2(grp, "volumeTemperature", &fds->flame_ignition, 1);
}
else {
LISTBASE_FOREACH (GPUMaterialVolumeGrid *, gpu_grid, gpu_grids) {
@ -840,8 +840,8 @@ void EEVEE_volumes_free_smoke_textures(void)
{
/* Free Smoke Textures after rendering */
LISTBASE_FOREACH (LinkData *, link, &e_data.smoke_domains) {
FluidModifierData *mmd = (FluidModifierData *)link->data;
GPU_free_smoke(mmd);
FluidModifierData *fmd = (FluidModifierData *)link->data;
GPU_free_smoke(fmd);
}
BLI_freelistN(&e_data.smoke_domains);
}

54
source/blender/draw/engines/overlay/overlay_extra.c
View File

@ -1358,22 +1358,22 @@ static void OVERLAY_volume_extra(OVERLAY_ExtraCallBuffers *cb,
Scene *scene,
float *color)
{
FluidModifierData *mmd = (FluidModifierData *)md;
FluidDomainSettings *mds = mmd->domain;
FluidModifierData *fmd = (FluidModifierData *)md;
FluidDomainSettings *fds = fmd->domain;
/* Don't show smoke before simulation starts, this could be made an option in the future. */
const bool draw_velocity = (mds->draw_velocity && mds->fluid &&
CFRA >= mds->point_cache[0]->startframe);
const bool draw_velocity = (fds->draw_velocity && fds->fluid &&
CFRA >= fds->point_cache[0]->startframe);
/* Small cube showing voxel size. */
{
float min[3];
madd_v3fl_v3fl_v3fl_v3i(min, mds->p0, mds->cell_size, mds->res_min);
madd_v3fl_v3fl_v3fl_v3i(min, fds->p0, fds->cell_size, fds->res_min);
float voxel_cubemat[4][4] = {{0.0f}};
/* scale small cube to voxel size */
voxel_cubemat[0][0] = mds->cell_size[0] / 2.0f;
voxel_cubemat[1][1] = mds->cell_size[1] / 2.0f;
voxel_cubemat[2][2] = mds->cell_size[2] / 2.0f;
voxel_cubemat[0][0] = fds->cell_size[0] / 2.0f;
voxel_cubemat[1][1] = fds->cell_size[1] / 2.0f;
voxel_cubemat[2][2] = fds->cell_size[2] / 2.0f;
voxel_cubemat[3][3] = 1.0f;
/* translate small cube to corner */
copy_v3_v3(voxel_cubemat[3], min);
@ -1385,38 +1385,38 @@ static void OVERLAY_volume_extra(OVERLAY_ExtraCallBuffers *cb,
}
if (draw_velocity) {
const bool use_needle = (mds->vector_draw_type == VECTOR_DRAW_NEEDLE);
const bool use_needle = (fds->vector_draw_type == VECTOR_DRAW_NEEDLE);
int line_count = (use_needle) ? 6 : 1;
int slice_axis = -1;
line_count *= mds->res[0] * mds->res[1] * mds->res[2];
line_count *= fds->res[0] * fds->res[1] * fds->res[2];
if (mds->slice_method == FLUID_DOMAIN_SLICE_AXIS_ALIGNED &&
mds->axis_slice_method == AXIS_SLICE_SINGLE) {
if (fds->slice_method == FLUID_DOMAIN_SLICE_AXIS_ALIGNED &&
fds->axis_slice_method == AXIS_SLICE_SINGLE) {
float viewinv[4][4];
DRW_view_viewmat_get(NULL, viewinv, true);
const int axis = (mds->slice_axis == SLICE_AXIS_AUTO) ? axis_dominant_v3_single(viewinv[2]) :
mds->slice_axis - 1;
const int axis = (fds->slice_axis == SLICE_AXIS_AUTO) ? axis_dominant_v3_single(viewinv[2]) :
fds->slice_axis - 1;
slice_axis = axis;
line_count /= mds->res[axis];
line_count /= fds->res[axis];
}
GPU_create_smoke_velocity(mmd);
GPU_create_smoke_velocity(fmd);
GPUShader *sh = OVERLAY_shader_volume_velocity(use_needle);
DRWShadingGroup *grp = DRW_shgroup_create(sh, data->psl->extra_ps[0]);
DRW_shgroup_uniform_texture(grp, "velocityX", mds->tex_velocity_x);
DRW_shgroup_uniform_texture(grp, "velocityY", mds->tex_velocity_y);
DRW_shgroup_uniform_texture(grp, "velocityZ", mds->tex_velocity_z);
DRW_shgroup_uniform_float_copy(grp, "displaySize", mds->vector_scale);
DRW_shgroup_uniform_float_copy(grp, "slicePosition", mds->slice_depth);
DRW_shgroup_uniform_vec3_copy(grp, "cellSize", mds->cell_size);
DRW_shgroup_uniform_vec3_copy(grp, "domainOriginOffset", mds->p0);
DRW_shgroup_uniform_ivec3_copy(grp, "adaptiveCellOffset", mds->res_min);
DRW_shgroup_uniform_texture(grp, "velocityX", fds->tex_velocity_x);
DRW_shgroup_uniform_texture(grp, "velocityY", fds->tex_velocity_y);
DRW_shgroup_uniform_texture(grp, "velocityZ", fds->tex_velocity_z);
DRW_shgroup_uniform_float_copy(grp, "displaySize", fds->vector_scale);
DRW_shgroup_uniform_float_copy(grp, "slicePosition", fds->slice_depth);
DRW_shgroup_uniform_vec3_copy(grp, "cellSize", fds->cell_size);
DRW_shgroup_uniform_vec3_copy(grp, "domainOriginOffset", fds->p0);
DRW_shgroup_uniform_ivec3_copy(grp, "adaptiveCellOffset", fds->res_min);
DRW_shgroup_uniform_int_copy(grp, "sliceAxis", slice_axis);
DRW_shgroup_call_procedural_lines(grp, ob, line_count);
BLI_addtail(&data->stl->pd->smoke_domains, BLI_genericNodeN(mmd));
BLI_addtail(&data->stl->pd->smoke_domains, BLI_genericNodeN(fmd));
}
}
@ -1430,8 +1430,8 @@ static void OVERLAY_volume_free_smoke_textures(OVERLAY_Data *data)
* all viewport in a redraw at least. */
LinkData *link;
while ((link = BLI_pophead(&data->stl->pd->smoke_domains))) {
FluidModifierData *mmd = (FluidModifierData *)link->data;
GPU_free_smoke_velocity(mmd);
FluidModifierData *fmd = (FluidModifierData *)link->data;
GPU_free_smoke_velocity(fmd);
MEM_freeN(link);
}
}

68
source/blender/draw/engines/workbench/workbench_volume.c
View File

@ -65,53 +65,53 @@ static void workbench_volume_modifier_cache_populate(WORKBENCH_Data *vedata,
Object *ob,
ModifierData *md)
{
FluidModifierData *mmd = (FluidModifierData *)md;
FluidDomainSettings *mds = mmd->domain;
FluidModifierData *fmd = (FluidModifierData *)md;
FluidDomainSettings *fds = fmd->domain;
WORKBENCH_PrivateData *wpd = vedata->stl->wpd;
WORKBENCH_TextureList *txl = vedata->txl;
DefaultTextureList *dtxl = DRW_viewport_texture_list_get();
DRWShadingGroup *grp = NULL;
/* Don't try to show liquid domains here */
if (!mds->fluid || !(mds->type == FLUID_DOMAIN_TYPE_GAS)) {
if (!fds->fluid || !(fds->type == FLUID_DOMAIN_TYPE_GAS)) {
return;
}
wpd->volumes_do = true;
if (mds->use_coba) {
GPU_create_smoke_coba_field(mmd);
if (fds->use_coba) {
GPU_create_smoke_coba_field(fmd);
}
else if (!(mds->flags & FLUID_DOMAIN_USE_NOISE)) {
GPU_create_smoke(mmd, 0);
else if (!(fds->flags & FLUID_DOMAIN_USE_NOISE)) {
GPU_create_smoke(fmd, 0);
}
else if (mds->flags & FLUID_DOMAIN_USE_NOISE) {
GPU_create_smoke(mmd, 1);
else if (fds->flags & FLUID_DOMAIN_USE_NOISE) {
GPU_create_smoke(fmd, 1);
}
if ((!mds->use_coba && (mds->tex_density == NULL && mds->tex_color == NULL)) ||
(mds->use_coba && mds->tex_field == NULL)) {
if ((!fds->use_coba && (fds->tex_density == NULL && fds->tex_color == NULL)) ||
(fds->use_coba && fds->tex_field == NULL)) {
return;
}
const bool use_slice = (mds->slice_method == FLUID_DOMAIN_SLICE_AXIS_ALIGNED &&
mds->axis_slice_method == AXIS_SLICE_SINGLE);
const bool cubic_interp = (mds->interp_method == VOLUME_INTERP_CUBIC);
GPUShader *sh = workbench_shader_volume_get(use_slice, mds->use_coba, cubic_interp, true);
const bool use_slice = (fds->slice_method == FLUID_DOMAIN_SLICE_AXIS_ALIGNED &&
fds->axis_slice_method == AXIS_SLICE_SINGLE);
const bool cubic_interp = (fds->interp_method == VOLUME_INTERP_CUBIC);
GPUShader *sh = workbench_shader_volume_get(use_slice, fds->use_coba, cubic_interp, true);
if (use_slice) {
float invviewmat[4][4];
DRW_view_viewmat_get(NULL, invviewmat, true);
const int axis = (mds->slice_axis == SLICE_AXIS_AUTO) ?
const int axis = (fds->slice_axis == SLICE_AXIS_AUTO) ?
axis_dominant_v3_single(invviewmat[2]) :
mds->slice_axis - 1;
fds->slice_axis - 1;
float dim[3];
BKE_object_dimensions_get(ob, dim);
/* 0.05f to achieve somewhat the same opacity as the full view. */
float step_length = max_ff(1e-16f, dim[axis] * 0.05f);
grp = DRW_shgroup_create(sh, vedata->psl->volume_ps);
DRW_shgroup_uniform_float_copy(grp, "slicePosition", mds->slice_depth);
DRW_shgroup_uniform_float_copy(grp, "slicePosition", fds->slice_depth);
DRW_shgroup_uniform_int_copy(grp, "sliceAxis", axis);
DRW_shgroup_uniform_float_copy(grp, "stepLength", step_length);
DRW_shgroup_state_disable(grp, DRW_STATE_CULL_FRONT);
@ -120,8 +120,8 @@ static void workbench_volume_modifier_cache_populate(WORKBENCH_Data *vedata,
double noise_ofs;
BLI_halton_1d(3, 0.0, wpd->taa_sample, &noise_ofs);
float dim[3], step_length, max_slice;
float slice_ct[3] = {mds->res[0], mds->res[1], mds->res[2]};
mul_v3_fl(slice_ct, max_ff(0.001f, mds->slice_per_voxel));
float slice_ct[3] = {fds->res[0], fds->res[1], fds->res[2]};
mul_v3_fl(slice_ct, max_ff(0.001f, fds->slice_per_voxel));
max_slice = max_fff(slice_ct[0], slice_ct[1], slice_ct[2]);
BKE_object_dimensions_get(ob, dim);
invert_v3(slice_ct);
@ -136,26 +136,26 @@ static void workbench_volume_modifier_cache_populate(WORKBENCH_Data *vedata,
DRW_shgroup_state_enable(grp, DRW_STATE_CULL_FRONT);
}
if (mds->use_coba) {
DRW_shgroup_uniform_texture(grp, "densityTexture", mds->tex_field);
DRW_shgroup_uniform_texture(grp, "transferTexture", mds->tex_coba);
if (fds->use_coba) {
DRW_shgroup_uniform_texture(grp, "densityTexture", fds->tex_field);
DRW_shgroup_uniform_texture(grp, "transferTexture", fds->tex_coba);
}
else {
static float white[3] = {1.0f, 1.0f, 1.0f};
bool use_constant_color = ((mds->active_fields & FLUID_DOMAIN_ACTIVE_COLORS) == 0 &&
(mds->active_fields & FLUID_DOMAIN_ACTIVE_COLOR_SET) != 0);
bool use_constant_color = ((fds->active_fields & FLUID_DOMAIN_ACTIVE_COLORS) == 0 &&
(fds->active_fields & FLUID_DOMAIN_ACTIVE_COLOR_SET) != 0);
DRW_shgroup_uniform_texture(
grp, "densityTexture", (mds->tex_color) ? mds->tex_color : mds->tex_density);
DRW_shgroup_uniform_texture(grp, "shadowTexture", mds->tex_shadow);
grp, "densityTexture", (fds->tex_color) ? fds->tex_color : fds->tex_density);
DRW_shgroup_uniform_texture(grp, "shadowTexture", fds->tex_shadow);
DRW_shgroup_uniform_texture(
grp, "flameTexture", (mds->tex_flame) ? mds->tex_flame : txl->dummy_volume_tx);
grp, "flameTexture", (fds->tex_flame) ? fds->tex_flame : txl->dummy_volume_tx);
DRW_shgroup_uniform_texture(
grp, "flameColorTexture", (mds->tex_flame) ? mds->tex_flame_coba : txl->dummy_coba_tx);
grp, "flameColorTexture", (fds->tex_flame) ? fds->tex_flame_coba : txl->dummy_coba_tx);
DRW_shgroup_uniform_vec3(
grp, "activeColor", (use_constant_color) ? mds->active_color : white, 1);
grp, "activeColor", (use_constant_color) ? fds->active_color : white, 1);
}
DRW_shgroup_uniform_texture_ref(grp, "depthBuffer", &dtxl->depth);
DRW_shgroup_uniform_float_copy(grp, "densityScale", 10.0f * mds->display_thickness);
DRW_shgroup_uniform_float_copy(grp, "densityScale", 10.0f * fds->display_thickness);
if (use_slice) {
DRW_shgroup_call(grp, DRW_cache_quad_get(), ob);
@ -164,7 +164,7 @@ static void workbench_volume_modifier_cache_populate(WORKBENCH_Data *vedata,
DRW_shgroup_call(grp, DRW_cache_cube_get(), ob);
}
BLI_addtail(&wpd->smoke_domains, BLI_genericNodeN(mmd));
BLI_addtail(&wpd->smoke_domains, BLI_genericNodeN(fmd));
}
static void workbench_volume_material_color(WORKBENCH_PrivateData *wpd,
@ -292,8 +292,8 @@ void workbench_volume_draw_finish(WORKBENCH_Data *vedata)
* modifier is not used for display. We should share them for
* all viewport in a redraw at least. */
LISTBASE_FOREACH (LinkData *, link, &wpd->smoke_domains) {
FluidModifierData *mmd = (FluidModifierData *)link->data;
GPU_free_smoke(mmd);
FluidModifierData *fmd = (FluidModifierData *)link->data;
GPU_free_smoke(fmd);
}
BLI_freelistN(&wpd->smoke_domains);
}

170
source/blender/editors/physics/physics_fluid.c
View File

@ -93,7 +93,7 @@ typedef struct FluidJob {
Depsgraph *depsgraph;
Object *ob;
FluidModifierData *mmd;
FluidModifierData *fmd;
int success;
double start;
@ -153,17 +153,17 @@ static inline bool fluid_is_free_guiding(FluidJob *job)
static bool fluid_initjob(
bContext *C, FluidJob *job, wmOperator *op, char *error_msg, int error_size)
{
FluidModifierData *mmd = NULL;
FluidDomainSettings *mds;
FluidModifierData *fmd = NULL;
FluidDomainSettings *fds;
Object *ob = ED_object_active_context(C);
mmd = (FluidModifierData *)BKE_modifiers_findby_type(ob, eModifierType_Fluid);
if (!mmd) {
fmd = (FluidModifierData *)BKE_modifiers_findby_type(ob, eModifierType_Fluid);
if (!fmd) {
BLI_strncpy(error_msg, N_("Bake failed: no Fluid modifier found"), error_size);
return false;
}
mds = mmd->domain;
if (!mds) {
fds = fmd->domain;
if (!fds) {
BLI_strncpy(error_msg, N_("Bake failed: invalid domain"), error_size);
return false;
}
@ -172,7 +172,7 @@ static bool fluid_initjob(
job->scene = CTX_data_scene(C);
job->depsgraph = CTX_data_depsgraph_pointer(C);
job->ob = ob;
job->mmd = mmd;
job->fmd = fmd;
job->type = op->type->idname;
job->name = op->type->name;
@ -181,7 +181,7 @@ static bool fluid_initjob(
static bool fluid_validatepaths(FluidJob *job, ReportList *reports)
{
FluidDomainSettings *mds = job->mmd->domain;
FluidDomainSettings *fds = job->fmd->domain;
char temp_dir[FILE_MAX];
temp_dir[0] = '\0';
bool is_relative = false;
@ -189,17 +189,17 @@ static bool fluid_validatepaths(FluidJob *job, ReportList *reports)
const char *relbase = BKE_modifier_path_relbase(job->bmain, job->ob);
/* We do not accept empty paths, they can end in random places silently, see T51176. */
if (mds->cache_directory[0] == '\0') {
if (fds->cache_directory[0] == '\0') {
char cache_name[64];
BKE_fluid_cache_new_name_for_current_session(sizeof(cache_name), cache_name);
BKE_modifier_path_init(mds->cache_directory, sizeof(mds->cache_directory), cache_name);
BKE_modifier_path_init(fds->cache_directory, sizeof(fds->cache_directory), cache_name);
BKE_reportf(reports,
RPT_WARNING,
"Fluid: Empty cache path, reset to default '%s'",
mds->cache_directory);
fds->cache_directory);
}
BLI_strncpy(temp_dir, mds->cache_directory, FILE_MAXDIR);
BLI_strncpy(temp_dir, fds->cache_directory, FILE_MAXDIR);
is_relative = BLI_path_abs(temp_dir, relbase);
/* Ensure whole path exists */
@ -210,13 +210,13 @@ static bool fluid_validatepaths(FluidJob *job, ReportList *reports)
if (!dir_exists) {
char cache_name[64];
BKE_fluid_cache_new_name_for_current_session(sizeof(cache_name), cache_name);
BKE_modifier_path_init(mds->cache_directory, sizeof(mds->cache_directory), cache_name);
BKE_modifier_path_init(fds->cache_directory, sizeof(fds->cache_directory), cache_name);
BKE_reportf(reports,
RPT_ERROR,
"Fluid: Could not create cache directory '%s', reset to default '%s'",
temp_dir,
mds->cache_directory);
fds->cache_directory);
/* Ensure whole path exists and is writable. */
if (!BLI_dir_create_recursive(temp_dir)) {
@ -228,7 +228,7 @@ static bool fluid_validatepaths(FluidJob *job, ReportList *reports)
return false;
}
/* Copy final dir back into domain settings */
BLI_strncpy(mds->cache_directory, temp_dir, FILE_MAXDIR);
BLI_strncpy(fds->cache_directory, temp_dir, FILE_MAXDIR);
return false;
}
@ -239,7 +239,7 @@ static bool fluid_validatepaths(FluidJob *job, ReportList *reports)
}
/* Copy final dir back into domain settings */
BLI_strncpy(mds->cache_directory, temp_dir, FILE_MAXDIR);
BLI_strncpy(fds->cache_directory, temp_dir, FILE_MAXDIR);
return true;
}
@ -251,17 +251,17 @@ static void fluid_bake_free(void *customdata)
static void fluid_bake_sequence(FluidJob *job)
{
FluidDomainSettings *mds = job->mmd->domain;
FluidDomainSettings *fds = job->fmd->domain;
Scene *scene = job->scene;
int frame = 1, orig_frame;
int frames;
int *pause_frame = NULL;
bool is_first_frame;
frames = mds->cache_frame_end - mds->cache_frame_start + 1;
frames = fds->cache_frame_end - fds->cache_frame_start + 1;
if (frames <= 0) {
BLI_strncpy(mds->error, N_("No frames to bake"), sizeof(mds->error));
BLI_strncpy(fds->error, N_("No frames to bake"), sizeof(fds->error));
return;
}
@ -275,15 +275,15 @@ static void fluid_bake_sequence(FluidJob *job)
/* Set frame to start point (depending on current pause frame value). */
is_first_frame = ((*pause_frame) == 0);
frame = is_first_frame ? mds->cache_frame_start : (*pause_frame);
frame = is_first_frame ? fds->cache_frame_start : (*pause_frame);
/* Save orig frame and update scene frame. */
orig_frame = CFRA;
CFRA = frame;
/* Loop through selected frames. */
for (; frame <= mds->cache_frame_end; frame++) {
const float progress = (frame - mds->cache_frame_start) / (float)frames;
for (; frame <= fds->cache_frame_end; frame++) {
const float progress = (frame - fds->cache_frame_start) / (float)frames;
/* Keep track of pause frame - needed to init future loop. */
(*pause_frame) = frame;
@ -321,32 +321,32 @@ static void fluid_bake_sequence(FluidJob *job)
static void fluid_bake_endjob(void *customdata)
{
FluidJob *job = customdata;
FluidDomainSettings *mds = job->mmd->domain;
FluidDomainSettings *fds = job->fmd->domain;
if (fluid_is_bake_noise(job) || fluid_is_bake_all(job)) {
mds->cache_flag &= ~FLUID_DOMAIN_BAKING_NOISE;
mds->cache_flag |= FLUID_DOMAIN_BAKED_NOISE;
mds->cache_flag &= ~FLUID_DOMAIN_OUTDATED_NOISE;
fds->cache_flag &= ~FLUID_DOMAIN_BAKING_NOISE;
fds->cache_flag |= FLUID_DOMAIN_BAKED_NOISE;
fds->cache_flag &= ~FLUID_DOMAIN_OUTDATED_NOISE;
}
if (fluid_is_bake_mesh(job) || fluid_is_bake_all(job)) {
mds->cache_flag &= ~FLUID_DOMAIN_BAKING_MESH;
mds->cache_flag |= FLUID_DOMAIN_BAKED_MESH;
mds->cache_flag &= ~FLUID_DOMAIN_OUTDATED_MESH;
fds->cache_flag &= ~FLUID_DOMAIN_BAKING_MESH;
fds->cache_flag |= FLUID_DOMAIN_BAKED_MESH;
fds->cache_flag &= ~FLUID_DOMAIN_OUTDATED_MESH;
}
if (fluid_is_bake_particle(job) || fluid_is_bake_all(job)) {
mds->cache_flag &= ~FLUID_DOMAIN_BAKING_PARTICLES;
mds->cache_flag |= FLUID_DOMAIN_BAKED_PARTICLES;
mds->cache_flag &= ~FLUID_DOMAIN_OUTDATED_PARTICLES;
fds->cache_flag &= ~FLUID_DOMAIN_BAKING_PARTICLES;
fds->cache_flag |= FLUID_DOMAIN_BAKED_PARTICLES;
fds->cache_flag &= ~FLUID_DOMAIN_OUTDATED_PARTICLES;
}
if (fluid_is_bake_guiding(job) || fluid_is_bake_all(job)) {
mds->cache_flag &= ~FLUID_DOMAIN_BAKING_GUIDE;
mds->cache_flag |= FLUID_DOMAIN_BAKED_GUIDE;
mds->cache_flag &= ~FLUID_DOMAIN_OUTDATED_GUIDE;
fds->cache_flag &= ~FLUID_DOMAIN_BAKING_GUIDE;
fds->cache_flag |= FLUID_DOMAIN_BAKED_GUIDE;
fds->cache_flag &= ~FLUID_DOMAIN_OUTDATED_GUIDE;
}
if (fluid_is_bake_data(job) || fluid_is_bake_all(job)) {
mds->cache_flag &= ~FLUID_DOMAIN_BAKING_DATA;
mds->cache_flag |= FLUID_DOMAIN_BAKED_DATA;
mds->cache_flag &= ~FLUID_DOMAIN_OUTDATED_DATA;
fds->cache_flag &= ~FLUID_DOMAIN_BAKING_DATA;
fds->cache_flag |= FLUID_DOMAIN_BAKED_DATA;
fds->cache_flag &= ~FLUID_DOMAIN_OUTDATED_DATA;
}
DEG_id_tag_update(&job->ob->id, ID_RECALC_GEOMETRY);
@ -362,8 +362,8 @@ static void fluid_bake_endjob(void *customdata)
RPT_INFO, "Fluid: %s complete! (%.2f)", job->name, PIL_check_seconds_timer() - job->start);
}
else {
if (mds->error[0] != '\0') {
WM_reportf(RPT_ERROR, "Fluid: %s failed: %s", job->name, mds->error);
if (fds->error[0] != '\0') {
WM_reportf(RPT_ERROR, "Fluid: %s failed: %s", job->name, fds->error);
}
else { /* User canceled the bake. */
WM_reportf(RPT_WARNING, "Fluid: %s canceled!", job->name);
@ -374,7 +374,7 @@ static void fluid_bake_endjob(void *customdata)
static void fluid_bake_startjob(void *customdata, short *stop, short *do_update, float *progress)
{
FluidJob *job = customdata;
FluidDomainSettings *mds = job->mmd->domain;
FluidDomainSettings *fds = job->fmd->domain;
char temp_dir[FILE_MAX];
const char *relbase = BKE_modifier_path_relbase_from_global(job->ob);
@ -390,54 +390,54 @@ static void fluid_bake_startjob(void *customdata, short *stop, short *do_update,
BKE_spacedata_draw_locks(true);
if (fluid_is_bake_noise(job) || fluid_is_bake_all(job)) {
BLI_path_join(temp_dir, sizeof(temp_dir), mds->cache_directory, FLUID_DOMAIN_DIR_NOISE, NULL);
BLI_path_join(temp_dir, sizeof(temp_dir), fds->cache_directory, FLUID_DOMAIN_DIR_NOISE, NULL);
BLI_path_abs(temp_dir, relbase);
BLI_dir_create_recursive(temp_dir); /* Create 'noise' subdir if it does not exist already */
mds->cache_flag &= ~(FLUID_DOMAIN_BAKED_NOISE | FLUID_DOMAIN_OUTDATED_NOISE);
mds->cache_flag |= FLUID_DOMAIN_BAKING_NOISE;
job->pause_frame = &mds->cache_frame_pause_noise;
fds->cache_flag &= ~(FLUID_DOMAIN_BAKED_NOISE | FLUID_DOMAIN_OUTDATED_NOISE);
fds->cache_flag |= FLUID_DOMAIN_BAKING_NOISE;
job->pause_frame = &fds->cache_frame_pause_noise;
}
if (fluid_is_bake_mesh(job) || fluid_is_bake_all(job)) {
BLI_path_join(temp_dir, sizeof(temp_dir), mds->cache_directory, FLUID_DOMAIN_DIR_MESH, NULL);
BLI_path_join(temp_dir, sizeof(temp_dir), fds->cache_directory, FLUID_DOMAIN_DIR_MESH, NULL);
BLI_path_abs(temp_dir, relbase);
BLI_dir_create_recursive(temp_dir); /* Create 'mesh' subdir if it does not exist already */
mds->cache_flag &= ~(FLUID_DOMAIN_BAKED_MESH | FLUID_DOMAIN_OUTDATED_MESH);
mds->cache_flag |= FLUID_DOMAIN_BAKING_MESH;
job->pause_frame = &mds->cache_frame_pause_mesh;
fds->cache_flag &= ~(FLUID_DOMAIN_BAKED_MESH | FLUID_DOMAIN_OUTDATED_MESH);
fds->cache_flag |= FLUID_DOMAIN_BAKING_MESH;
job->pause_frame = &fds->cache_frame_pause_mesh;
}
if (fluid_is_bake_particle(job) || fluid_is_bake_all(job)) {
BLI_path_join(
temp_dir, sizeof(temp_dir), mds->cache_directory, FLUID_DOMAIN_DIR_PARTICLES, NULL);
temp_dir, sizeof(temp_dir), fds->cache_directory, FLUID_DOMAIN_DIR_PARTICLES, NULL);
BLI_path_abs(temp_dir, relbase);
BLI_dir_create_recursive(
temp_dir); /* Create 'particles' subdir if it does not exist already */
mds->cache_flag &= ~(FLUID_DOMAIN_BAKED_PARTICLES | FLUID_DOMAIN_OUTDATED_PARTICLES);
mds->cache_flag |= FLUID_DOMAIN_BAKING_PARTICLES;
job->pause_frame = &mds->cache_frame_pause_particles;
fds->cache_flag &= ~(FLUID_DOMAIN_BAKED_PARTICLES | FLUID_DOMAIN_OUTDATED_PARTICLES);
fds->cache_flag |= FLUID_DOMAIN_BAKING_PARTICLES;
job->pause_frame = &fds->cache_frame_pause_particles;
}
if (fluid_is_bake_guiding(job) || fluid_is_bake_all(job)) {
BLI_path_join(temp_dir, sizeof(temp_dir), mds->cache_directory, FLUID_DOMAIN_DIR_GUIDE, NULL);
BLI_path_join(temp_dir, sizeof(temp_dir), fds->cache_directory, FLUID_DOMAIN_DIR_GUIDE, NULL);
BLI_path_abs(temp_dir, relbase);
BLI_dir_create_recursive(temp_dir); /* Create 'guiding' subdir if it does not exist already */
mds->cache_flag &= ~(FLUID_DOMAIN_BAKED_GUIDE | FLUID_DOMAIN_OUTDATED_GUIDE);
mds->cache_flag |= FLUID_DOMAIN_BAKING_GUIDE;
job->pause_frame = &mds->cache_frame_pause_guide;
fds->cache_flag &= ~(FLUID_DOMAIN_BAKED_GUIDE | FLUID_DOMAIN_OUTDATED_GUIDE);
fds->cache_flag |= FLUID_DOMAIN_BAKING_GUIDE;
job->pause_frame = &fds->cache_frame_pause_guide;
}
if (fluid_is_bake_data(job) || fluid_is_bake_all(job)) {
BLI_path_join(temp_dir, sizeof(temp_dir), mds->cache_directory, FLUID_DOMAIN_DIR_CONFIG, NULL);
BLI_path_join(temp_dir, sizeof(temp_dir), fds->cache_directory, FLUID_DOMAIN_DIR_CONFIG, NULL);
BLI_path_abs(temp_dir, relbase);
BLI_dir_create_recursive(temp_dir); /* Create 'config' subdir if it does not exist already */
BLI_path_join(temp_dir, sizeof(temp_dir), mds->cache_directory, FLUID_DOMAIN_DIR_DATA, NULL);
BLI_path_join(temp_dir, sizeof(temp_dir), fds->cache_directory, FLUID_DOMAIN_DIR_DATA, NULL);
BLI_path_abs(temp_dir, relbase);
BLI_dir_create_recursive(temp_dir); /* Create 'data' subdir if it does not exist already */
mds->cache_flag &= ~(FLUID_DOMAIN_BAKED_DATA | FLUID_DOMAIN_OUTDATED_DATA);
mds->cache_flag |= FLUID_DOMAIN_BAKING_DATA;
job->pause_frame = &mds->cache_frame_pause_data;
fds->cache_flag &= ~(FLUID_DOMAIN_BAKED_DATA | FLUID_DOMAIN_OUTDATED_DATA);
fds->cache_flag |= FLUID_DOMAIN_BAKING_DATA;
job->pause_frame = &fds->cache_frame_pause_data;
if (mds->flags & FLUID_DOMAIN_EXPORT_MANTA_SCRIPT) {
if (fds->flags & FLUID_DOMAIN_EXPORT_MANTA_SCRIPT) {
BLI_path_join(
temp_dir, sizeof(temp_dir), mds->cache_directory, FLUID_DOMAIN_DIR_SCRIPT, NULL);
temp_dir, sizeof(temp_dir), fds->cache_directory, FLUID_DOMAIN_DIR_SCRIPT, NULL);
BLI_path_abs(temp_dir, relbase);
BLI_dir_create_recursive(temp_dir); /* Create 'script' subdir if it does not exist already */
}
@ -457,7 +457,7 @@ static void fluid_bake_startjob(void *customdata, short *stop, short *do_update,
static void fluid_free_endjob(void *customdata)
{
FluidJob *job = customdata;
FluidDomainSettings *mds = job->mmd->domain;
FluidDomainSettings *fds = job->fmd->domain;
G.is_rendering = false;
BKE_spacedata_draw_locks(false);
@ -474,8 +474,8 @@ static void fluid_free_endjob(void *customdata)
RPT_INFO, "Fluid: %s complete! (%.2f)", job->name, PIL_check_seconds_timer() - job->start);
}
else {
if (mds->error[0] != '\0') {
WM_reportf(RPT_ERROR, "Fluid: %s failed: %s", job->name, mds->error);
if (fds->error[0] != '\0') {
WM_reportf(RPT_ERROR, "Fluid: %s failed: %s", job->name, fds->error);
}
else { /* User canceled the free job */
WM_reportf(RPT_WARNING, "Fluid: %s canceled!", job->name);
@ -486,7 +486,7 @@ static void fluid_free_endjob(void *customdata)
static void fluid_free_startjob(void *customdata, short *stop, short *do_update, float *progress)
{
FluidJob *job = customdata;
FluidDomainSettings *mds = job->mmd->domain;
FluidDomainSettings *fds = job->fmd->domain;
job->stop = stop;
job->do_update = do_update;
@ -519,9 +519,9 @@ static void fluid_free_startjob(void *customdata, short *stop, short *do_update,
FLUID_DOMAIN_OUTDATED_GUIDE);
}
#ifdef WITH_FLUID
BKE_fluid_cache_free(mds, job->ob, cache_map);
BKE_fluid_cache_free(fds, job->ob, cache_map);
#else
UNUSED_VARS(mds);
UNUSED_VARS(fds);
#endif
*do_update = true;
@ -615,27 +615,27 @@ static int fluid_bake_modal(bContext *C, wmOperator *UNUSED(op), const wmEvent *
static int fluid_free_exec(struct bContext *C, struct wmOperator *op)
{
FluidModifierData *mmd = NULL;
FluidDomainSettings *mds;
FluidModifierData *fmd = NULL;
FluidDomainSettings *fds;
Object *ob = ED_object_active_context(C);
Scene *scene = CTX_data_scene(C);
/*
* Get modifier data
*/
mmd = (FluidModifierData *)BKE_modifiers_findby_type(ob, eModifierType_Fluid);
if (!mmd) {
fmd = (FluidModifierData *)BKE_modifiers_findby_type(ob, eModifierType_Fluid);
if (!fmd) {
BKE_report(op->reports, RPT_ERROR, "Bake free failed: no Fluid modifier found");
return OPERATOR_CANCELLED;
}
mds = mmd->domain;
if (!mds) {
fds = fmd->domain;
if (!fds) {
BKE_report(op->reports, RPT_ERROR, "Bake free failed: invalid domain");
return OPERATOR_CANCELLED;
}
/* Cannot free data if other bakes currently working */
if (mmd->domain->cache_flag & (FLUID_DOMAIN_BAKING_DATA | FLUID_DOMAIN_BAKING_NOISE |
if (fmd->domain->cache_flag & (FLUID_DOMAIN_BAKING_DATA | FLUID_DOMAIN_BAKING_NOISE |
FLUID_DOMAIN_BAKING_MESH | FLUID_DOMAIN_BAKING_PARTICLES)) {
BKE_report(op->reports, RPT_ERROR, "Bake free failed: pending bake jobs found");
return OPERATOR_CANCELLED;
@ -646,7 +646,7 @@ static int fluid_free_exec(struct bContext *C, struct wmOperator *op)
job->scene = scene;
job->depsgraph = CTX_data_depsgraph_pointer(C);
job->ob = ob;
job->mmd = mmd;
job->fmd = fmd;
job->type = op->type->idname;
job->name = op->type->name;
@ -678,20 +678,20 @@ static int fluid_free_exec(struct bContext *C, struct wmOperator *op)
static int fluid_pause_exec(struct bContext *C, struct wmOperator *op)
{
FluidModifierData *mmd = NULL;
FluidDomainSettings *mds;
FluidModifierData *fmd = NULL;
FluidDomainSettings *fds;
Object *ob = ED_object_active_context(C);
/*
* Get modifier data
*/
mmd = (FluidModifierData *)BKE_modifiers_findby_type(ob, eModifierType_Fluid);
if (!mmd) {
fmd = (FluidModifierData *)BKE_modifiers_findby_type(ob, eModifierType_Fluid);
if (!fmd) {
BKE_report(op->reports, RPT_ERROR, "Bake free failed: no Fluid modifier found");
return OPERATOR_CANCELLED;
}
mds = mmd->domain;
if (!mds) {
fds = fmd->domain;
if (!fds) {
BKE_report(op->reports, RPT_ERROR, "Bake free failed: invalid domain");
return OPERATOR_CANCELLED;
}

10
source/blender/gpu/GPU_draw.h
View File

@ -79,11 +79,11 @@ void GPU_free_images_anim(struct Main *bmain);
void GPU_free_images_old(struct Main *bmain);
/* gpu_draw_smoke.c */
void GPU_free_smoke(struct FluidModifierData *mmd);
void GPU_free_smoke_velocity(struct FluidModifierData *mmd);
void GPU_create_smoke(struct FluidModifierData *mmd, int highres);
void GPU_create_smoke_coba_field(struct FluidModifierData *mmd);
void GPU_create_smoke_velocity(struct FluidModifierData *mmd);
void GPU_free_smoke(struct FluidModifierData *fmd);
void GPU_free_smoke_velocity(struct FluidModifierData *fmd);
void GPU_create_smoke(struct FluidModifierData *fmd, int highres);
void GPU_create_smoke_coba_field(struct FluidModifierData *fmd);
void GPU_create_smoke_velocity(struct FluidModifierData *fmd);
/* Delayed free of OpenGL buffers by main thread */
void GPU_free_unused_buffers(void);

214
source/blender/gpu/intern/gpu_draw_smoke.c
View File

@ -132,74 +132,74 @@ static void swizzle_texture_channel_single(GPUTexture *tex)
GPU_texture_unbind(tex);
}
static GPUTexture *create_field_texture(FluidDomainSettings *mds)
static GPUTexture *create_field_texture(FluidDomainSettings *fds)
{
float *field = NULL;
switch (mds->coba_field) {
switch (fds->coba_field) {
case FLUID_DOMAIN_FIELD_DENSITY:
field = manta_smoke_get_density(mds->fluid);
field = manta_smoke_get_density(fds->fluid);
break;
case FLUID_DOMAIN_FIELD_HEAT:
field = manta_smoke_get_heat(mds->fluid);
field = manta_smoke_get_heat(fds->fluid);
break;
case FLUID_DOMAIN_FIELD_FUEL:
field = manta_smoke_get_fuel(mds->fluid);
field = manta_smoke_get_fuel(fds->fluid);
break;
case FLUID_DOMAIN_FIELD_REACT:
field = manta_smoke_get_react(mds->fluid);
field = manta_smoke_get_react(fds->fluid);
break;
case FLUID_DOMAIN_FIELD_FLAME:
field = manta_smoke_get_flame(mds->fluid);
field = manta_smoke_get_flame(fds->fluid);
break;
case FLUID_DOMAIN_FIELD_VELOCITY_X:
field = manta_get_velocity_x(mds->fluid);
field = manta_get_velocity_x(fds->fluid);
break;
case FLUID_DOMAIN_FIELD_VELOCITY_Y:
field = manta_get_velocity_y(mds->fluid);
field = manta_get_velocity_y(fds->fluid);
break;
case FLUID_DOMAIN_FIELD_VELOCITY_Z:
field = manta_get_velocity_z(mds->fluid);
field = manta_get_velocity_z(fds->fluid);
break;
case FLUID_DOMAIN_FIELD_COLOR_R:
field = manta_smoke_get_color_r(mds->fluid);
field = manta_smoke_get_color_r(fds->fluid);
break;
case FLUID_DOMAIN_FIELD_COLOR_G:
field = manta_smoke_get_color_g(mds->fluid);
field = manta_smoke_get_color_g(fds->fluid);
break;
case FLUID_DOMAIN_FIELD_COLOR_B:
field = manta_smoke_get_color_b(mds->fluid);
field = manta_smoke_get_color_b(fds->fluid);
break;
case FLUID_DOMAIN_FIELD_FORCE_X:
field = manta_get_force_x(mds->fluid);
field = manta_get_force_x(fds->fluid);
break;
case FLUID_DOMAIN_FIELD_FORCE_Y:
field = manta_get_force_y(mds->fluid);
field = manta_get_force_y(fds->fluid);
break;
case FLUID_DOMAIN_FIELD_FORCE_Z:
field = manta_get_force_z(mds->fluid);
field = manta_get_force_z(fds->fluid);
break;
default:
return NULL;
}
GPUTexture *tex = GPU_texture_create_nD(
mds->res[0], mds->res[1], mds->res[2], 3, field, GPU_R8, GPU_DATA_FLOAT, 0, true, NULL);
fds->res[0], fds->res[1], fds->res[2], 3, field, GPU_R8, GPU_DATA_FLOAT, 0, true, NULL);
swizzle_texture_channel_single(tex);
return tex;
}
static GPUTexture *create_density_texture(FluidDomainSettings *mds, int highres)
static GPUTexture *create_density_texture(FluidDomainSettings *fds, int highres)
{
int *dim = (highres) ? mds->res_noise : mds->res;
int *dim = (highres) ? fds->res_noise : fds->res;
float *data;
if (highres) {
data = manta_smoke_turbulence_get_density(mds->fluid);
data = manta_smoke_turbulence_get_density(fds->fluid);
}
else {
data = manta_smoke_get_density(mds->fluid);
data = manta_smoke_get_density(fds->fluid);
}
GPUTexture *tex = GPU_texture_create_nD(
@ -210,17 +210,17 @@ static GPUTexture *create_density_texture(FluidDomainSettings *mds, int highres)
return tex;
}
static GPUTexture *create_color_texture(FluidDomainSettings *mds, int highres)
static GPUTexture *create_color_texture(FluidDomainSettings *fds, int highres)
{
const bool has_color = (highres) ? manta_smoke_turbulence_has_colors(mds->fluid) :
manta_smoke_has_colors(mds->fluid);
const bool has_color = (highres) ? manta_smoke_turbulence_has_colors(fds->fluid) :
manta_smoke_has_colors(fds->fluid);
if (!has_color) {
return NULL;
}
int cell_count = (highres) ? manta_smoke_turbulence_get_cells(mds->fluid) : mds->total_cells;
int *dim = (highres) ? mds->res_noise : mds->res;
int cell_count = (highres) ? manta_smoke_turbulence_get_cells(fds->fluid) : fds->total_cells;
int *dim = (highres) ? fds->res_noise : fds->res;
float *data = MEM_callocN(sizeof(float) * cell_count * 4, "smokeColorTexture");
if (data == NULL) {
@ -228,10 +228,10 @@ static GPUTexture *create_color_texture(FluidDomainSettings *mds, int highres)
}
if (highres) {
manta_smoke_turbulence_get_rgba(mds->fluid, data, 0);
manta_smoke_turbulence_get_rgba(fds->fluid, data, 0);
}
else {
manta_smoke_get_rgba(mds->fluid, data, 0);
manta_smoke_get_rgba(fds->fluid, data, 0);
}
GPUTexture *tex = GPU_texture_create_nD(
@ -242,22 +242,22 @@ static GPUTexture *create_color_texture(FluidDomainSettings *mds, int highres)
return tex;
}
static GPUTexture *create_flame_texture(FluidDomainSettings *mds, int highres)
static GPUTexture *create_flame_texture(FluidDomainSettings *fds, int highres)
{
float *source = NULL;
const bool has_fuel = (highres) ? manta_smoke_turbulence_has_fuel(mds->fluid) :
manta_smoke_has_fuel(mds->fluid);
int *dim = (highres) ? mds->res_noise : mds->res;
const bool has_fuel = (highres) ? manta_smoke_turbulence_has_fuel(fds->fluid) :
manta_smoke_has_fuel(fds->fluid);
int *dim = (highres) ? fds->res_noise : fds->res;
if (!has_fuel) {
return NULL;
}
if (highres) {
source = manta_smoke_turbulence_get_flame(mds->fluid);
source = manta_smoke_turbulence_get_flame(fds->fluid);
}
else {
source = manta_smoke_get_flame(mds->fluid);
source = manta_smoke_get_flame(fds->fluid);
}
GPUTexture *tex = GPU_texture_create_nD(
@ -276,90 +276,90 @@ static GPUTexture *create_flame_texture(FluidDomainSettings *mds, int highres)
/** \name Public API
* \{ */
void GPU_free_smoke(FluidModifierData *mmd)
void GPU_free_smoke(FluidModifierData *fmd)
{
if (mmd->type & MOD_FLUID_TYPE_DOMAIN && mmd->domain) {
if (mmd->domain->tex_density) {
GPU_texture_free(mmd->domain->tex_density);
mmd->domain->tex_density = NULL;
if (fmd->type & MOD_FLUID_TYPE_DOMAIN && fmd->domain) {
if (fmd->domain->tex_density) {
GPU_texture_free(fmd->domain->tex_density);
fmd->domain->tex_density = NULL;
}
if (mmd->domain->tex_color) {
GPU_texture_free(mmd->domain->tex_color);
mmd->domain->tex_color = NULL;
if (fmd->domain->tex_color) {
GPU_texture_free(fmd->domain->tex_color);
fmd->domain->tex_color = NULL;
}
if (mmd->domain->tex_shadow) {
GPU_texture_free(mmd->domain->tex_shadow);
mmd->domain->tex_shadow = NULL;
if (fmd->domain->tex_shadow) {
GPU_texture_free(fmd->domain->tex_shadow);
fmd->domain->tex_shadow = NULL;
}
if (mmd->domain->tex_flame) {
GPU_texture_free(mmd->domain->tex_flame);
mmd->domain->tex_flame = NULL;
if (fmd->domain->tex_flame) {
GPU_texture_free(fmd->domain->tex_flame);
fmd->domain->tex_flame = NULL;
}
if (mmd->domain->tex_flame_coba) {
GPU_texture_free(mmd->domain->tex_flame_coba);
mmd->domain->tex_flame_coba = NULL;
if (fmd->domain->tex_flame_coba) {
GPU_texture_free(fmd->domain->tex_flame_coba);
fmd->domain->tex_flame_coba = NULL;
}
if (mmd->domain->tex_coba) {
GPU_texture_free(mmd->domain->tex_coba);
mmd->domain->tex_coba = NULL;
if (fmd->domain->tex_coba) {
GPU_texture_free(fmd->domain->tex_coba);
fmd->domain->tex_coba = NULL;
}
if (mmd->domain->tex_field) {
GPU_texture_free(mmd->domain->tex_field);
mmd->domain->tex_field = NULL;
if (fmd->domain->tex_field) {
GPU_texture_free(fmd->domain->tex_field);
fmd->domain->tex_field = NULL;
}
}
}
void GPU_create_smoke_coba_field(FluidModifierData *mmd)
void GPU_create_smoke_coba_field(FluidModifierData *fmd)
{
#ifndef WITH_FLUID
UNUSED_VARS(mmd);
UNUSED_VARS(fmd);
#else
if (mmd->type & MOD_FLUID_TYPE_DOMAIN) {
FluidDomainSettings *mds = mmd->domain;
if (fmd->type & MOD_FLUID_TYPE_DOMAIN) {
FluidDomainSettings *fds = fmd->domain;
if (!mds->tex_field) {
mds->tex_field = create_field_texture(mds);
if (!fds->tex_field) {
fds->tex_field = create_field_texture(fds);
}
if (!mds->tex_coba) {
mds->tex_coba = create_transfer_function(TFUNC_COLOR_RAMP, mds->coba);
if (!fds->tex_coba) {
fds->tex_coba = create_transfer_function(TFUNC_COLOR_RAMP, fds->coba);
}
}
#endif
}
void GPU_create_smoke(FluidModifierData *mmd, int highres)
void GPU_create_smoke(FluidModifierData *fmd, int highres)
{
#ifndef WITH_FLUID
UNUSED_VARS(mmd, highres);
UNUSED_VARS(fmd, highres);
#else
if (mmd->type & MOD_FLUID_TYPE_DOMAIN) {
FluidDomainSettings *mds = mmd->domain;
if (fmd->type & MOD_FLUID_TYPE_DOMAIN) {
FluidDomainSettings *fds = fmd->domain;
if (!mds->tex_density) {
mds->tex_density = create_density_texture(mds, highres);
if (!fds->tex_density) {
fds->tex_density = create_density_texture(fds, highres);
}
if (!mds->tex_color) {
mds->tex_color = create_color_texture(mds, highres);
if (!fds->tex_color) {
fds->tex_color = create_color_texture(fds, highres);
}
if (!mds->tex_flame) {
mds->tex_flame = create_flame_texture(mds, highres);
if (!fds->tex_flame) {
fds->tex_flame = create_flame_texture(fds, highres);
}
if (!mds->tex_flame_coba && mds->tex_flame) {
mds->tex_flame_coba = create_transfer_function(TFUNC_FLAME_SPECTRUM, NULL);
if (!fds->tex_flame_coba && fds->tex_flame) {
fds->tex_flame_coba = create_transfer_function(TFUNC_FLAME_SPECTRUM, NULL);
}
if (!mds->tex_shadow) {
mds->tex_shadow = GPU_texture_create_nD(mds->res[0],
mds->res[1],
mds->res[2],
if (!fds->tex_shadow) {
fds->tex_shadow = GPU_texture_create_nD(fds->res[0],
fds->res[1],
fds->res[2],
3,
manta_smoke_get_shadow(mds->fluid),
manta_smoke_get_shadow(fds->fluid),
GPU_R8,
GPU_DATA_FLOAT,
0,
@ -370,53 +370,53 @@ void GPU_create_smoke(FluidModifierData *mmd, int highres)
#endif /* WITH_FLUID */
}
void GPU_create_smoke_velocity(FluidModifierData *mmd)
void GPU_create_smoke_velocity(FluidModifierData *fmd)
{
#ifndef WITH_FLUID
UNUSED_VARS(mmd);
UNUSED_VARS(fmd);
#else
if (mmd->type & MOD_FLUID_TYPE_DOMAIN) {
FluidDomainSettings *mds = mmd->domain;
if (fmd->type & MOD_FLUID_TYPE_DOMAIN) {
FluidDomainSettings *fds = fmd->domain;
const float *vel_x = manta_get_velocity_x(mds->fluid);
const float *vel_y = manta_get_velocity_y(mds->fluid);
const float *vel_z = manta_get_velocity_z(mds->fluid);
const float *vel_x = manta_get_velocity_x(fds->fluid);
const float *vel_y = manta_get_velocity_y(fds->fluid);
const float *vel_z = manta_get_velocity_z(fds->fluid);
if (ELEM(NULL, vel_x, vel_y, vel_z)) {
return;
}
if (!mds->tex_velocity_x) {
mds->tex_velocity_x = GPU_texture_create_3d(
mds->res[0], mds->res[1], mds->res[2], GPU_R16F, vel_x, NULL);
mds->tex_velocity_y = GPU_texture_create_3d(
mds->res[0], mds->res[1], mds->res[2], GPU_R16F, vel_y, NULL);
mds->tex_velocity_z = GPU_texture_create_3d(
mds->res[0], mds->res[1], mds->res[2], GPU_R16F, vel_z, NULL);
if (!fds->tex_velocity_x) {
fds->tex_velocity_x = GPU_texture_create_3d(
fds->res[0], fds->res[1], fds->res[2], GPU_R16F, vel_x, NULL);
fds->tex_velocity_y = GPU_texture_create_3d(
fds->res[0], fds->res[1], fds->res[2], GPU_R16F, vel_y, NULL);
fds->tex_velocity_z = GPU_texture_create_3d(
fds->res[0], fds->res[1], fds->res[2], GPU_R16F, vel_z, NULL);
}
}
#endif /* WITH_FLUID */
}
/* TODO Unify with the other GPU_free_smoke. */
void GPU_free_smoke_velocity(FluidModifierData *mmd)
void GPU_free_smoke_velocity(FluidModifierData *fmd)
{
if (mmd->type & MOD_FLUID_TYPE_DOMAIN && mmd->domain) {
if (mmd->domain->tex_velocity_x) {
GPU_texture_free(mmd->domain->tex_velocity_x);
if (fmd->type & MOD_FLUID_TYPE_DOMAIN && fmd->domain) {
if (fmd->domain->tex_velocity_x) {
GPU_texture_free(fmd->domain->tex_velocity_x);
}
if (mmd->domain->tex_velocity_y) {
GPU_texture_free(mmd->domain->tex_velocity_y);
if (fmd->domain->tex_velocity_y) {
GPU_texture_free(fmd->domain->tex_velocity_y);
}
if (mmd->domain->tex_velocity_z) {
GPU_texture_free(mmd->domain->tex_velocity_z);
if (fmd->domain->tex_velocity_z) {
GPU_texture_free(fmd->domain->tex_velocity_z);
}
mmd->domain->tex_velocity_x = NULL;
mmd->domain->tex_velocity_y = NULL;
mmd->domain->tex_velocity_z = NULL;
fmd->domain->tex_velocity_x = NULL;
fmd->domain->tex_velocity_y = NULL;
fmd->domain->tex_velocity_z = NULL;
}
}

6
source/blender/makesdna/DNA_fluid_types.h
View File

@ -427,7 +427,7 @@ typedef struct FluidDomainSettings {
/* -- Runtime-only fields (from here on). -- */
struct FluidModifierData *mmd; /* For fast RNA access. */
struct FluidModifierData *fmd; /* For fast RNA access. */
struct MANTA *fluid;
struct MANTA *fluid_old; /* Adaptive domain needs access to old fluid state. */
void *fluid_mutex;
@ -689,7 +689,7 @@ typedef struct FluidFlowSettings {
/* -- Runtime-only fields (from here on). -- */
/* For fast RNA access. */
struct FluidModifierData *mmd;
struct FluidModifierData *fmd;
struct Mesh *mesh;
struct ParticleSystem *psys;
struct Tex *noise_texture;
@ -765,7 +765,7 @@ typedef struct FluidEffectorSettings {
/* -- Runtime-only fields (from here on). -- */
/* For fast RNA access. */
struct FluidModifierData *mmd;
struct FluidModifierData *fmd;
struct Mesh *mesh;
float *verts_old;
int numverts;

252
source/blender/makesrna/intern/rna_fluid.c
View File

@ -77,7 +77,7 @@ static void rna_Fluid_datacache_reset(Main *UNUSED(bmain), Scene *UNUSED(scene),
{
# ifdef WITH_FLUID
FluidDomainSettings *settings = (FluidDomainSettings *)ptr->data;
if (settings->mmd && settings->mmd->domain) {
if (settings->fmd && settings->fmd->domain) {
Object *ob = (Object *)ptr->owner_id;
int cache_map = (FLUID_DOMAIN_OUTDATED_DATA | FLUID_DOMAIN_OUTDATED_NOISE |
FLUID_DOMAIN_OUTDATED_MESH | FLUID_DOMAIN_OUTDATED_PARTICLES);
@ -90,7 +90,7 @@ static void rna_Fluid_noisecache_reset(Main *UNUSED(bmain), Scene *UNUSED(scene)
{
# ifdef WITH_FLUID
FluidDomainSettings *settings = (FluidDomainSettings *)ptr->data;
if (settings->mmd && settings->mmd->domain) {
if (settings->fmd && settings->fmd->domain) {
Object *ob = (Object *)ptr->owner_id;
int cache_map = FLUID_DOMAIN_OUTDATED_NOISE;
BKE_fluid_cache_free(settings, ob, cache_map);
@ -102,7 +102,7 @@ static void rna_Fluid_meshcache_reset(Main *UNUSED(bmain), Scene *UNUSED(scene),
{
# ifdef WITH_FLUID
FluidDomainSettings *settings = (FluidDomainSettings *)ptr->data;
if (settings->mmd && settings->mmd->domain) {
if (settings->fmd && settings->fmd->domain) {
Object *ob = (Object *)ptr->owner_id;
int cache_map = FLUID_DOMAIN_OUTDATED_MESH;
BKE_fluid_cache_free(settings, ob, cache_map);
@ -116,7 +116,7 @@ static void rna_Fluid_particlescache_reset(Main *UNUSED(bmain),
{
# ifdef WITH_FLUID
FluidDomainSettings *settings = (FluidDomainSettings *)ptr->data;
if (settings->mmd && settings->mmd->domain) {
if (settings->fmd && settings->fmd->domain) {
Object *ob = (Object *)ptr->owner_id;
int cache_map = FLUID_DOMAIN_OUTDATED_PARTICLES;
BKE_fluid_cache_free(settings, ob, cache_map);
@ -130,7 +130,7 @@ static void rna_Fluid_guidingcache_reset(Main *UNUSED(bmain),
{
# ifdef WITH_FLUID
FluidDomainSettings *settings = (FluidDomainSettings *)ptr->data;
if (settings->mmd && settings->mmd->domain) {
if (settings->fmd && settings->fmd->domain) {
Object *ob = (Object *)ptr->owner_id;
int cache_map = (FLUID_DOMAIN_OUTDATED_DATA | FLUID_DOMAIN_OUTDATED_NOISE |
FLUID_DOMAIN_OUTDATED_MESH | FLUID_DOMAIN_OUTDATED_PARTICLES |
@ -165,7 +165,7 @@ static void rna_Fluid_domain_reset(Main *bmain, Scene *scene, PointerRNA *ptr)
{
# ifdef WITH_FLUID
FluidDomainSettings *settings = (FluidDomainSettings *)ptr->data;
BKE_fluid_modifier_reset(settings->mmd);
BKE_fluid_modifier_reset(settings->fmd);
# endif
rna_Fluid_datacache_reset(bmain, scene, ptr);
@ -176,7 +176,7 @@ static void rna_Fluid_reset_dependency(Main *bmain, Scene *scene, PointerRNA *pt
{
# ifdef WITH_FLUID
FluidDomainSettings *settings = (FluidDomainSettings *)ptr->data;
BKE_fluid_modifier_reset(settings->mmd);
BKE_fluid_modifier_reset(settings->fmd);
# endif
rna_Fluid_dependency_update(bmain, scene, ptr);
@ -223,15 +223,15 @@ static bool rna_Fluid_parts_exists(PointerRNA *ptr, int ptype)
static void rna_Fluid_flip_parts_update(Main *bmain, Scene *scene, PointerRNA *ptr)
{
Object *ob = (Object *)ptr->owner_id;
FluidModifierData *mmd;
mmd = (FluidModifierData *)BKE_modifiers_findby_type(ob, eModifierType_Fluid);
FluidModifierData *fmd;
fmd = (FluidModifierData *)BKE_modifiers_findby_type(ob, eModifierType_Fluid);
bool exists = rna_Fluid_parts_exists(ptr, PART_FLUID_FLIP);
/* Only create a particle system in liquid domain mode.
* Remove any remaining data from a liquid sim when switching to gas. */
if (mmd->domain->type != FLUID_DOMAIN_TYPE_LIQUID) {
if (fmd->domain->type != FLUID_DOMAIN_TYPE_LIQUID) {
rna_Fluid_parts_delete(ptr, PART_FLUID_FLIP);
mmd->domain->particle_type &= ~FLUID_DOMAIN_PARTICLE_FLIP;
fmd->domain->particle_type &= ~FLUID_DOMAIN_PARTICLE_FLIP;
rna_Fluid_domain_reset(bmain, scene, ptr);
return;
}
@ -239,11 +239,11 @@ static void rna_Fluid_flip_parts_update(Main *bmain, Scene *scene, PointerRNA *p
if (ob->type == OB_MESH && !exists) {
rna_Fluid_parts_create(
bmain, ptr, "LiquidParticleSettings", "Liquid", "Liquid Particle System", PART_FLUID_FLIP);
mmd->domain->particle_type |= FLUID_DOMAIN_PARTICLE_FLIP;
fmd->domain->particle_type |= FLUID_DOMAIN_PARTICLE_FLIP;
}
else {
rna_Fluid_parts_delete(ptr, PART_FLUID_FLIP);
mmd->domain->particle_type &= ~FLUID_DOMAIN_PARTICLE_FLIP;
fmd->domain->particle_type &= ~FLUID_DOMAIN_PARTICLE_FLIP;
}
rna_Fluid_update(bmain, scene, ptr);
}
@ -251,26 +251,26 @@ static void rna_Fluid_flip_parts_update(Main *bmain, Scene *scene, PointerRNA *p
static void rna_Fluid_spray_parts_update(Main *bmain, Scene *UNUSED(scene), PointerRNA *ptr)
{
Object *ob = (Object *)ptr->owner_id;
FluidModifierData *mmd;
mmd = (FluidModifierData *)BKE_modifiers_findby_type(ob, eModifierType_Fluid);
FluidModifierData *fmd;
fmd = (FluidModifierData *)BKE_modifiers_findby_type(ob, eModifierType_Fluid);
bool exists = rna_Fluid_parts_exists(ptr, PART_FLUID_SPRAY);
if (ob->type == OB_MESH && !exists) {
rna_Fluid_parts_create(
bmain, ptr, "SprayParticleSettings", "Spray", "Spray Particle System", PART_FLUID_SPRAY);
mmd->domain->particle_type |= FLUID_DOMAIN_PARTICLE_SPRAY;
fmd->domain->particle_type |= FLUID_DOMAIN_PARTICLE_SPRAY;
}
else {
rna_Fluid_parts_delete(ptr, PART_FLUID_SPRAY);
mmd->domain->particle_type &= ~FLUID_DOMAIN_PARTICLE_SPRAY;
fmd->domain->particle_type &= ~FLUID_DOMAIN_PARTICLE_SPRAY;
}
}
static void rna_Fluid_bubble_parts_update(Main *bmain, Scene *UNUSED(scene), PointerRNA *ptr)
{
Object *ob = (Object *)ptr->owner_id;
FluidModifierData *mmd;
mmd = (FluidModifierData *)BKE_modifiers_findby_type(ob, eModifierType_Fluid);
FluidModifierData *fmd;
fmd = (FluidModifierData *)BKE_modifiers_findby_type(ob, eModifierType_Fluid);
bool exists = rna_Fluid_parts_exists(ptr, PART_FLUID_BUBBLE);
if (ob->type == OB_MESH && !exists) {
@ -280,37 +280,37 @@ static void rna_Fluid_bubble_parts_update(Main *bmain, Scene *UNUSED(scene), Poi
"Bubbles",
"Bubble Particle System",
PART_FLUID_BUBBLE);
mmd->domain->particle_type |= FLUID_DOMAIN_PARTICLE_BUBBLE;
fmd->domain->particle_type |= FLUID_DOMAIN_PARTICLE_BUBBLE;
}
else {
rna_Fluid_parts_delete(ptr, PART_FLUID_BUBBLE);
mmd->domain->particle_type &= ~FLUID_DOMAIN_PARTICLE_BUBBLE;
fmd->domain->particle_type &= ~FLUID_DOMAIN_PARTICLE_BUBBLE;
}
}
static void rna_Fluid_foam_parts_update(Main *bmain, Scene *UNUSED(scene), PointerRNA *ptr)
{
Object *ob = (Object *)ptr->owner_id;
FluidModifierData *mmd;
mmd = (FluidModifierData *)BKE_modifiers_findby_type(ob, eModifierType_Fluid);
FluidModifierData *fmd;
fmd = (FluidModifierData *)BKE_modifiers_findby_type(ob, eModifierType_Fluid);
bool exists = rna_Fluid_parts_exists(ptr, PART_FLUID_FOAM);
if (ob->type == OB_MESH && !exists) {
rna_Fluid_parts_create(
bmain, ptr, "FoamParticleSettings", "Foam", "Foam Particle System", PART_FLUID_FOAM);
mmd->domain->particle_type |= FLUID_DOMAIN_PARTICLE_FOAM;
fmd->domain->particle_type |= FLUID_DOMAIN_PARTICLE_FOAM;
}
else {
rna_Fluid_parts_delete(ptr, PART_FLUID_FOAM);
mmd->domain->particle_type &= ~FLUID_DOMAIN_PARTICLE_FOAM;
fmd->domain->particle_type &= ~FLUID_DOMAIN_PARTICLE_FOAM;
}
}
static void rna_Fluid_tracer_parts_update(Main *bmain, Scene *UNUSED(scene), PointerRNA *ptr)
{
Object *ob = (Object *)ptr->owner_id;
FluidModifierData *mmd;
mmd = (FluidModifierData *)BKE_modifiers_findby_type(ob, eModifierType_Fluid);
FluidModifierData *fmd;
fmd = (FluidModifierData *)BKE_modifiers_findby_type(ob, eModifierType_Fluid);
bool exists = rna_Fluid_parts_exists(ptr, PART_FLUID_TRACER);
if (ob->type == OB_MESH && !exists) {
@ -320,21 +320,21 @@ static void rna_Fluid_tracer_parts_update(Main *bmain, Scene *UNUSED(scene), Poi
"Tracers",
"Tracer Particle System",
PART_FLUID_TRACER);
mmd->domain->particle_type |= FLUID_DOMAIN_PARTICLE_TRACER;
fmd->domain->particle_type |= FLUID_DOMAIN_PARTICLE_TRACER;
}
else {
rna_Fluid_parts_delete(ptr, PART_FLUID_TRACER);
mmd->domain->particle_type &= ~FLUID_DOMAIN_PARTICLE_TRACER;
fmd->domain->particle_type &= ~FLUID_DOMAIN_PARTICLE_TRACER;
}
}
static void rna_Fluid_combined_export_update(Main *bmain, Scene *scene, PointerRNA *ptr)
{
Object *ob = (Object *)ptr->owner_id;
FluidModifierData *mmd;
mmd = (FluidModifierData *)BKE_modifiers_findby_type(ob, eModifierType_Fluid);
FluidModifierData *fmd;
fmd = (FluidModifierData *)BKE_modifiers_findby_type(ob, eModifierType_Fluid);
if (mmd->domain->sndparticle_combined_export == SNDPARTICLE_COMBINED_EXPORT_OFF) {
if (fmd->domain->sndparticle_combined_export == SNDPARTICLE_COMBINED_EXPORT_OFF) {
rna_Fluid_parts_delete(ptr, PART_FLUID_SPRAYFOAM);
rna_Fluid_parts_delete(ptr, PART_FLUID_SPRAYBUBBLE);
rna_Fluid_parts_delete(ptr, PART_FLUID_FOAMBUBBLE);
@ -345,17 +345,17 @@ static void rna_Fluid_combined_export_update(Main *bmain, Scene *scene, PointerR
bool exists_bubble = rna_Fluid_parts_exists(ptr, PART_FLUID_BUBBLE);
/* Re-add each particle type if enabled and no particle system exists for them anymore. */
if ((mmd->domain->particle_type & FLUID_DOMAIN_PARTICLE_SPRAY) && !exists_spray) {
if ((fmd->domain->particle_type & FLUID_DOMAIN_PARTICLE_SPRAY) && !exists_spray) {
rna_Fluid_spray_parts_update(bmain, scene, ptr);
}
if ((mmd->domain->particle_type & FLUID_DOMAIN_PARTICLE_FOAM) && !exists_foam) {
if ((fmd->domain->particle_type & FLUID_DOMAIN_PARTICLE_FOAM) && !exists_foam) {
rna_Fluid_foam_parts_update(bmain, scene, ptr);
}
if ((mmd->domain->particle_type & FLUID_DOMAIN_PARTICLE_BUBBLE) && !exists_bubble) {
if ((fmd->domain->particle_type & FLUID_DOMAIN_PARTICLE_BUBBLE) && !exists_bubble) {
rna_Fluid_bubble_parts_update(bmain, scene, ptr);
}
}
else if (mmd->domain->sndparticle_combined_export == SNDPARTICLE_COMBINED_EXPORT_SPRAY_FOAM) {
else if (fmd->domain->sndparticle_combined_export == SNDPARTICLE_COMBINED_EXPORT_SPRAY_FOAM) {
if (ob->type == OB_MESH && !rna_Fluid_parts_exists(ptr, PART_FLUID_SPRAYFOAM)) {
rna_Fluid_parts_create(bmain,
@ -365,8 +365,8 @@ static void rna_Fluid_combined_export_update(Main *bmain, Scene *scene, PointerR
"Spray + Foam Particle System",
PART_FLUID_SPRAYFOAM);
mmd->domain->particle_type |= FLUID_DOMAIN_PARTICLE_SPRAY;
mmd->domain->particle_type |= FLUID_DOMAIN_PARTICLE_FOAM;
fmd->domain->particle_type |= FLUID_DOMAIN_PARTICLE_SPRAY;
fmd->domain->particle_type |= FLUID_DOMAIN_PARTICLE_FOAM;
rna_Fluid_parts_delete(ptr, PART_FLUID_SPRAY);
rna_Fluid_parts_delete(ptr, PART_FLUID_FOAM);
@ -376,12 +376,12 @@ static void rna_Fluid_combined_export_update(Main *bmain, Scene *scene, PointerR
/* Re-add spray if enabled and no particle system exists for it anymore. */
bool exists_bubble = rna_Fluid_parts_exists(ptr, PART_FLUID_BUBBLE);
if ((mmd->domain->particle_type & FLUID_DOMAIN_PARTICLE_BUBBLE) && !exists_bubble) {
if ((fmd->domain->particle_type & FLUID_DOMAIN_PARTICLE_BUBBLE) && !exists_bubble) {
rna_Fluid_bubble_parts_update(bmain, scene, ptr);
}
}
}
else if (mmd->domain->sndparticle_combined_export == SNDPARTICLE_COMBINED_EXPORT_SPRAY_BUBBLE) {
else if (fmd->domain->sndparticle_combined_export == SNDPARTICLE_COMBINED_EXPORT_SPRAY_BUBBLE) {
if (ob->type == OB_MESH && !rna_Fluid_parts_exists(ptr, PART_FLUID_SPRAYBUBBLE)) {
rna_Fluid_parts_create(bmain,
@ -391,8 +391,8 @@ static void rna_Fluid_combined_export_update(Main *bmain, Scene *scene, PointerR
"Spray + Bubble Particle System",
PART_FLUID_SPRAYBUBBLE);
mmd->domain->particle_type |= FLUID_DOMAIN_PARTICLE_SPRAY;
mmd->domain->particle_type |= FLUID_DOMAIN_PARTICLE_BUBBLE;
fmd->domain->particle_type |= FLUID_DOMAIN_PARTICLE_SPRAY;
fmd->domain->particle_type |= FLUID_DOMAIN_PARTICLE_BUBBLE;
rna_Fluid_parts_delete(ptr, PART_FLUID_SPRAY);
rna_Fluid_parts_delete(ptr, PART_FLUID_BUBBLE);
@ -402,12 +402,12 @@ static void rna_Fluid_combined_export_update(Main *bmain, Scene *scene, PointerR
/* Re-add foam if enabled and no particle system exists for it anymore. */
bool exists_foam = rna_Fluid_parts_exists(ptr, PART_FLUID_FOAM);
if ((mmd->domain->particle_type & FLUID_DOMAIN_PARTICLE_FOAM) && !exists_foam) {
if ((fmd->domain->particle_type & FLUID_DOMAIN_PARTICLE_FOAM) && !exists_foam) {
rna_Fluid_foam_parts_update(bmain, scene, ptr);
}
}
}
else if (mmd->domain->sndparticle_combined_export == SNDPARTICLE_COMBINED_EXPORT_FOAM_BUBBLE) {
else if (fmd->domain->sndparticle_combined_export == SNDPARTICLE_COMBINED_EXPORT_FOAM_BUBBLE) {
if (ob->type == OB_MESH && !rna_Fluid_parts_exists(ptr, PART_FLUID_FOAMBUBBLE)) {
rna_Fluid_parts_create(bmain,
@ -417,8 +417,8 @@ static void rna_Fluid_combined_export_update(Main *bmain, Scene *scene, PointerR
"Foam + Bubble Particle System",
PART_FLUID_FOAMBUBBLE);
mmd->domain->particle_type |= FLUID_DOMAIN_PARTICLE_FOAM;
mmd->domain->particle_type |= FLUID_DOMAIN_PARTICLE_BUBBLE;
fmd->domain->particle_type |= FLUID_DOMAIN_PARTICLE_FOAM;
fmd->domain->particle_type |= FLUID_DOMAIN_PARTICLE_BUBBLE;
rna_Fluid_parts_delete(ptr, PART_FLUID_FOAM);
rna_Fluid_parts_delete(ptr, PART_FLUID_BUBBLE);
@ -428,12 +428,12 @@ static void rna_Fluid_combined_export_update(Main *bmain, Scene *scene, PointerR
/* Re-add foam if enabled and no particle system exists for it anymore. */
bool exists_spray = rna_Fluid_parts_exists(ptr, PART_FLUID_SPRAY);
if ((mmd->domain->particle_type & FLUID_DOMAIN_PARTICLE_SPRAY) && !exists_spray) {
if ((fmd->domain->particle_type & FLUID_DOMAIN_PARTICLE_SPRAY) && !exists_spray) {
rna_Fluid_spray_parts_update(bmain, scene, ptr);
}
}
}
else if (mmd->domain->sndparticle_combined_export ==
else if (fmd->domain->sndparticle_combined_export ==
SNDPARTICLE_COMBINED_EXPORT_SPRAY_FOAM_BUBBLE) {
if (ob->type == OB_MESH && !rna_Fluid_parts_exists(ptr, PART_FLUID_SPRAYFOAMBUBBLE)) {
@ -444,9 +444,9 @@ static void rna_Fluid_combined_export_update(Main *bmain, Scene *scene, PointerR
"Spray + Foam + Bubble Particle System",
PART_FLUID_SPRAYFOAMBUBBLE);
mmd->domain->particle_type |= FLUID_DOMAIN_PARTICLE_SPRAY;
mmd->domain->particle_type |= FLUID_DOMAIN_PARTICLE_FOAM;
mmd->domain->particle_type |= FLUID_DOMAIN_PARTICLE_BUBBLE;
fmd->domain->particle_type |= FLUID_DOMAIN_PARTICLE_SPRAY;
fmd->domain->particle_type |= FLUID_DOMAIN_PARTICLE_FOAM;
fmd->domain->particle_type |= FLUID_DOMAIN_PARTICLE_BUBBLE;
rna_Fluid_parts_delete(ptr, PART_FLUID_SPRAY);
rna_Fluid_parts_delete(ptr, PART_FLUID_FOAM);
@ -512,20 +512,20 @@ static void rna_Fluid_guide_parent_set(struct PointerRNA *ptr,
struct PointerRNA value,
struct ReportList *UNUSED(reports))
{
FluidDomainSettings *mds = (FluidDomainSettings *)ptr->data;
FluidDomainSettings *fds = (FluidDomainSettings *)ptr->data;
Object *par = (Object *)value.data;
FluidModifierData *mmd_par = NULL;
FluidModifierData *fmd_par = NULL;
if (par != NULL) {
mmd_par = (FluidModifierData *)BKE_modifiers_findby_type(par, eModifierType_Fluid);
if (mmd_par && mmd_par->domain) {
mds->guide_parent = value.data;
copy_v3_v3_int(mds->guide_res, mmd_par->domain->res);
fmd_par = (FluidModifierData *)BKE_modifiers_findby_type(par, eModifierType_Fluid);
if (fmd_par && fmd_par->domain) {
fds->guide_parent = value.data;
copy_v3_v3_int(fds->guide_res, fmd_par->domain->res);
}
}
else {
mds->guide_parent = NULL;
fds->guide_parent = NULL;
}
}
@ -580,9 +580,9 @@ static const EnumPropertyItem *rna_Fluid_cachetype_volume_itemf(bContext *UNUSED
# endif
/* Support for deprecated .raw format. */
FluidDomainSettings *mds = (FluidDomainSettings *)ptr->data;
if (mds->cache_data_format == FLUID_DOMAIN_FILE_RAW ||
mds->cache_noise_format == FLUID_DOMAIN_FILE_RAW) {
FluidDomainSettings *fds = (FluidDomainSettings *)ptr->data;
if (fds->cache_data_format == FLUID_DOMAIN_FILE_RAW ||
fds->cache_noise_format == FLUID_DOMAIN_FILE_RAW) {
tmp.value = FLUID_DOMAIN_FILE_RAW;
tmp.identifier = "RAW";
tmp.name = "Raw Cache";
@ -642,7 +642,7 @@ static void rna_Fluid_domaintype_set(struct PointerRNA *ptr, int value)
static char *rna_FluidDomainSettings_path(PointerRNA *ptr)
{
FluidDomainSettings *settings = (FluidDomainSettings *)ptr->data;
ModifierData *md = (ModifierData *)settings->mmd;
ModifierData *md = (ModifierData *)settings->fmd;
char name_esc[sizeof(md->name) * 2];
BLI_strescape(name_esc, md->name, sizeof(name_esc));
@ -652,7 +652,7 @@ static char *rna_FluidDomainSettings_path(PointerRNA *ptr)
static char *rna_FluidFlowSettings_path(PointerRNA *ptr)
{
FluidFlowSettings *settings = (FluidFlowSettings *)ptr->data;
ModifierData *md = (ModifierData *)settings->mmd;
ModifierData *md = (ModifierData *)settings->fmd;
char name_esc[sizeof(md->name) * 2];
BLI_strescape(name_esc, md->name, sizeof(name_esc));
@ -662,7 +662,7 @@ static char *rna_FluidFlowSettings_path(PointerRNA *ptr)
static char *rna_FluidEffectorSettings_path(PointerRNA *ptr)
{
FluidEffectorSettings *settings = (FluidEffectorSettings *)ptr->data;
ModifierData *md = (ModifierData *)settings->mmd;
ModifierData *md = (ModifierData *)settings->fmd;
char name_esc[sizeof(md->name) * 2];
BLI_strescape(name_esc, md->name, sizeof(name_esc));
@ -677,23 +677,23 @@ static char *rna_FluidEffectorSettings_path(PointerRNA *ptr)
static int rna_FluidModifier_grid_get_length(PointerRNA *ptr, int length[RNA_MAX_ARRAY_DIMENSION])
{
FluidDomainSettings *mds = (FluidDomainSettings *)ptr->data;
FluidDomainSettings *fds = (FluidDomainSettings *)ptr->data;
float *density = NULL;
int size = 0;
if (mds->flags & FLUID_DOMAIN_USE_NOISE && mds->fluid) {
if (fds->flags & FLUID_DOMAIN_USE_NOISE && fds->fluid) {
/* high resolution smoke */
int res[3];
manta_smoke_turbulence_get_res(mds->fluid, res);
manta_smoke_turbulence_get_res(fds->fluid, res);
size = res[0] * res[1] * res[2];
density = manta_smoke_turbulence_get_density(mds->fluid);
density = manta_smoke_turbulence_get_density(fds->fluid);
}
else if (mds->fluid) {
else if (fds->fluid) {
/* regular resolution */
size = mds->res[0] * mds->res[1] * mds->res[2];
density = manta_smoke_get_density(mds->fluid);
size = fds->res[0] * fds->res[1] * fds->res[2];
density = manta_smoke_get_density(fds->fluid);
}
length[0] = (density) ? size : 0;
@ -712,18 +712,18 @@ static int rna_FluidModifier_color_grid_get_length(PointerRNA *ptr,
static int rna_FluidModifier_velocity_grid_get_length(PointerRNA *ptr,
int length[RNA_MAX_ARRAY_DIMENSION])
{
FluidDomainSettings *mds = (FluidDomainSettings *)ptr->data;
FluidDomainSettings *fds = (FluidDomainSettings *)ptr->data;
float *vx = NULL;
float *vy = NULL;
float *vz = NULL;
int size = 0;
/* Velocity data is always low-resolution. */
if (mds->fluid) {
size = 3 * mds->res[0] * mds->res[1] * mds->res[2];
vx = manta_get_velocity_x(mds->fluid);
vy = manta_get_velocity_y(mds->fluid);
vz = manta_get_velocity_z(mds->fluid);
if (fds->fluid) {
size = 3 * fds->res[0] * fds->res[1] * fds->res[2];
vx = manta_get_velocity_x(fds->fluid);
vy = manta_get_velocity_y(fds->fluid);
vz = manta_get_velocity_z(fds->fluid);
}
length[0] = (vx && vy && vz) ? size : 0;
@ -733,14 +733,14 @@ static int rna_FluidModifier_velocity_grid_get_length(PointerRNA *ptr,
static int rna_FluidModifier_heat_grid_get_length(PointerRNA *ptr,
int length[RNA_MAX_ARRAY_DIMENSION])
{
FluidDomainSettings *mds = (FluidDomainSettings *)ptr->data;
FluidDomainSettings *fds = (FluidDomainSettings *)ptr->data;
float *heat = NULL;
int size = 0;
/* Heat data is always low-resolution. */
if (mds->fluid) {
size = mds->res[0] * mds->res[1] * mds->res[2];
heat = manta_smoke_get_heat(mds->fluid);
if (fds->fluid) {
size = fds->res[0] * fds->res[1] * fds->res[2];
heat = manta_smoke_get_heat(fds->fluid);
}
length[0] = (heat) ? size : 0;
@ -749,38 +749,38 @@ static int rna_FluidModifier_heat_grid_get_length(PointerRNA *ptr,
static void rna_FluidModifier_density_grid_get(PointerRNA *ptr, float *values)
{
FluidDomainSettings *mds = (FluidDomainSettings *)ptr->data;
FluidDomainSettings *fds = (FluidDomainSettings *)ptr->data;
int length[RNA_MAX_ARRAY_DIMENSION];
int size = rna_FluidModifier_grid_get_length(ptr, length);
float *density;
BLI_rw_mutex_lock(mds->fluid_mutex, THREAD_LOCK_READ);
BLI_rw_mutex_lock(fds->fluid_mutex, THREAD_LOCK_READ);
if (mds->flags & FLUID_DOMAIN_USE_NOISE && mds->fluid) {
density = manta_smoke_turbulence_get_density(mds->fluid);
if (fds->flags & FLUID_DOMAIN_USE_NOISE && fds->fluid) {
density = manta_smoke_turbulence_get_density(fds->fluid);
}
else {
density = manta_smoke_get_density(mds->fluid);
density = manta_smoke_get_density(fds->fluid);
}
memcpy(values, density, size * sizeof(float));
BLI_rw_mutex_unlock(mds->fluid_mutex);
BLI_rw_mutex_unlock(fds->fluid_mutex);
}
static void rna_FluidModifier_velocity_grid_get(PointerRNA *ptr, float *values)
{
FluidDomainSettings *mds = (FluidDomainSettings *)ptr->data;
FluidDomainSettings *fds = (FluidDomainSettings *)ptr->data;
int length[RNA_MAX_ARRAY_DIMENSION];
int size = rna_FluidModifier_velocity_grid_get_length(ptr, length);
float *vx, *vy, *vz;
int i;
BLI_rw_mutex_lock(mds->fluid_mutex, THREAD_LOCK_READ);
BLI_rw_mutex_lock(fds->fluid_mutex, THREAD_LOCK_READ);
vx = manta_get_velocity_x(mds->fluid);
vy = manta_get_velocity_y(mds->fluid);
vz = manta_get_velocity_z(mds->fluid);
vx = manta_get_velocity_x(fds->fluid);
vy = manta_get_velocity_y(fds->fluid);
vz = manta_get_velocity_z(fds->fluid);
for (i = 0; i < size; i += 3) {
*(values++) = *(vx++);
@ -788,56 +788,56 @@ static void rna_FluidModifier_velocity_grid_get(PointerRNA *ptr, float *values)
*(values++) = *(vz++);
}
BLI_rw_mutex_unlock(mds->fluid_mutex);
BLI_rw_mutex_unlock(fds->fluid_mutex);
}
static void rna_FluidModifier_color_grid_get(PointerRNA *ptr, float *values)
{
FluidDomainSettings *mds = (FluidDomainSettings *)ptr->data;
FluidDomainSettings *fds = (FluidDomainSettings *)ptr->data;
int length[RNA_MAX_ARRAY_DIMENSION];
int size = rna_FluidModifier_grid_get_length(ptr, length);
BLI_rw_mutex_lock(mds->fluid_mutex, THREAD_LOCK_READ);
BLI_rw_mutex_lock(fds->fluid_mutex, THREAD_LOCK_READ);
if (!mds->fluid) {
if (!fds->fluid) {
memset(values, 0, size * sizeof(float));
}
else {
if (mds->flags & FLUID_DOMAIN_USE_NOISE) {
if (manta_smoke_turbulence_has_colors(mds->fluid)) {
manta_smoke_turbulence_get_rgba(mds->fluid, values, 0);
if (fds->flags & FLUID_DOMAIN_USE_NOISE) {
if (manta_smoke_turbulence_has_colors(fds->fluid)) {
manta_smoke_turbulence_get_rgba(fds->fluid, values, 0);
}
else {
manta_smoke_turbulence_get_rgba_fixed_color(mds->fluid, mds->active_color, values, 0);
manta_smoke_turbulence_get_rgba_fixed_color(fds->fluid, fds->active_color, values, 0);
}
}
else {
if (manta_smoke_has_colors(mds->fluid)) {
manta_smoke_get_rgba(mds->fluid, values, 0);
if (manta_smoke_has_colors(fds->fluid)) {
manta_smoke_get_rgba(fds->fluid, values, 0);
}
else {
manta_smoke_get_rgba_fixed_color(mds->fluid, mds->active_color, values, 0);
manta_smoke_get_rgba_fixed_color(fds->fluid, fds->active_color, values, 0);
}
}
}
BLI_rw_mutex_unlock(mds->fluid_mutex);
BLI_rw_mutex_unlock(fds->fluid_mutex);
}
static void rna_FluidModifier_flame_grid_get(PointerRNA *ptr, float *values)
{
FluidDomainSettings *mds = (FluidDomainSettings *)ptr->data;
FluidDomainSettings *fds = (FluidDomainSettings *)ptr->data;
int length[RNA_MAX_ARRAY_DIMENSION];
int size = rna_FluidModifier_grid_get_length(ptr, length);
float *flame;
BLI_rw_mutex_lock(mds->fluid_mutex, THREAD_LOCK_READ);
BLI_rw_mutex_lock(fds->fluid_mutex, THREAD_LOCK_READ);
if (mds->flags & FLUID_DOMAIN_USE_NOISE && mds->fluid) {
flame = manta_smoke_turbulence_get_flame(mds->fluid);
if (fds->flags & FLUID_DOMAIN_USE_NOISE && fds->fluid) {
flame = manta_smoke_turbulence_get_flame(fds->fluid);
}
else {
flame = manta_smoke_get_flame(mds->fluid);
flame = manta_smoke_get_flame(fds->fluid);
}
if (flame) {
@ -847,19 +847,19 @@ static void rna_FluidModifier_flame_grid_get(PointerRNA *ptr, float *values)
memset(values, 0, size * sizeof(float));
}
BLI_rw_mutex_unlock(mds->fluid_mutex);
BLI_rw_mutex_unlock(fds->fluid_mutex);
}
static void rna_FluidModifier_heat_grid_get(PointerRNA *ptr, float *values)
{
FluidDomainSettings *mds = (FluidDomainSettings *)ptr->data;
FluidDomainSettings *fds = (FluidDomainSettings *)ptr->data;
int length[RNA_MAX_ARRAY_DIMENSION];
int size = rna_FluidModifier_heat_grid_get_length(ptr, length);
float *heat;
BLI_rw_mutex_lock(mds->fluid_mutex, THREAD_LOCK_READ);
BLI_rw_mutex_lock(fds->fluid_mutex, THREAD_LOCK_READ);
heat = manta_smoke_get_heat(mds->fluid);
heat = manta_smoke_get_heat(fds->fluid);
if (heat != NULL) {
/* scale heat values from -2.0-2.0 to -1.0-1.0. */
@ -871,29 +871,29 @@ static void rna_FluidModifier_heat_grid_get(PointerRNA *ptr, float *values)
memset(values, 0, size * sizeof(float));
}
BLI_rw_mutex_unlock(mds->fluid_mutex);
BLI_rw_mutex_unlock(fds->fluid_mutex);
}
static void rna_FluidModifier_temperature_grid_get(PointerRNA *ptr, float *values)
{
FluidDomainSettings *mds = (FluidDomainSettings *)ptr->data;
FluidDomainSettings *fds = (FluidDomainSettings *)ptr->data;
int length[RNA_MAX_ARRAY_DIMENSION];
int size = rna_FluidModifier_grid_get_length(ptr, length);
float *flame;
BLI_rw_mutex_lock(mds->fluid_mutex, THREAD_LOCK_READ);
BLI_rw_mutex_lock(fds->fluid_mutex, THREAD_LOCK_READ);
if (mds->flags & FLUID_DOMAIN_USE_NOISE && mds->fluid) {
flame = manta_smoke_turbulence_get_flame(mds->fluid);
if (fds->flags & FLUID_DOMAIN_USE_NOISE && fds->fluid) {
flame = manta_smoke_turbulence_get_flame(fds->fluid);
}
else {
flame = manta_smoke_get_flame(mds->fluid);
flame = manta_smoke_get_flame(fds->fluid);
}
if (flame) {
/* Output is such that 0..1 maps to 0..1000K */
float offset = mds->flame_ignition;
float scale = mds->flame_max_temp - mds->flame_ignition;
float offset = fds->flame_ignition;
float scale = fds->flame_max_temp - fds->flame_ignition;
for (int i = 0; i < size; i++) {
values[i] = (flame[i] > 0.01f) ? offset + flame[i] * scale : 0.0f;
@ -903,7 +903,7 @@ static void rna_FluidModifier_temperature_grid_get(PointerRNA *ptr, float *value
memset(values, 0, size * sizeof(float));
}
BLI_rw_mutex_unlock(mds->fluid_mutex);
BLI_rw_mutex_unlock(fds->fluid_mutex);
}
# endif /* WITH_FLUID */
@ -935,12 +935,12 @@ static void rna_FluidFlow_uvlayer_set(struct PointerRNA *ptr, const char *value)
static void rna_Fluid_use_color_ramp_set(struct PointerRNA *ptr, bool value)
{
FluidDomainSettings *mds = (FluidDomainSettings *)ptr->data;
FluidDomainSettings *fds = (FluidDomainSettings *)ptr->data;
mds->use_coba = value;
fds->use_coba = value;
if (value && mds->coba == NULL) {
mds->coba = BKE_colorband_add(false);
if (value && fds->coba == NULL) {
fds->coba = BKE_colorband_add(false);
}
}

10
source/blender/makesrna/intern/rna_modifier.c
View File

@ -1040,20 +1040,20 @@ static void rna_UVProjector_object_set(PointerRNA *ptr,
static void rna_fluid_set_type(Main *bmain, Scene *scene, PointerRNA *ptr)
{
FluidModifierData *mmd = (FluidModifierData *)ptr->data;
FluidModifierData *fmd = (FluidModifierData *)ptr->data;
Object *ob = (Object *)ptr->owner_id;
/* nothing changed */
if ((mmd->type & MOD_FLUID_TYPE_DOMAIN) && mmd->domain) {
if ((fmd->type & MOD_FLUID_TYPE_DOMAIN) && fmd->domain) {
return;
}
# ifdef WITH_FLUID
BKE_fluid_modifier_free(mmd); /* XXX TODO: completely free all 3 pointers */
BKE_fluid_modifier_create_type_data(mmd); /* create regarding of selected type */
BKE_fluid_modifier_free(fmd); /* XXX TODO: completely free all 3 pointers */
BKE_fluid_modifier_create_type_data(fmd); /* create regarding of selected type */
# endif
switch (mmd->type) {
switch (fmd->type) {
case MOD_FLUID_TYPE_DOMAIN:
ob->dt = OB_WIRE;
break;

4
source/blender/makesrna/intern/rna_object_force.c
View File

@ -805,8 +805,8 @@ static char *rna_EffectorWeight_path(PointerRNA *ptr)
/* check smoke modifier */
md = (ModifierData *)BKE_modifiers_findby_type(ob, eModifierType_Fluid);
if (md) {
FluidModifierData *mmd = (FluidModifierData *)md;
if (mmd->domain->effector_weights == ew) {
FluidModifierData *fmd = (FluidModifierData *)md;
if (fmd->domain->effector_weights == ew) {
char name_esc[sizeof(md->name) * 2];
BLI_strescape(name_esc, md->name, sizeof(name_esc));
return BLI_sprintfN("modifiers[\"%s\"].settings.effector_weights", name_esc);

84
source/blender/modifiers/intern/MOD_fluid.c
View File

@ -59,13 +59,13 @@
static void initData(ModifierData *md)
{
FluidModifierData *mmd = (FluidModifierData *)md;
FluidModifierData *fmd = (FluidModifierData *)md;
mmd->domain = NULL;
mmd->flow = NULL;
mmd->effector = NULL;
mmd->type = 0;
mmd->time = -1;
fmd->domain = NULL;
fmd->flow = NULL;
fmd->effector = NULL;
fmd->type = 0;
fmd->time = -1;
}
static void copyData(const ModifierData *md, ModifierData *target, const int flag)
@ -73,11 +73,11 @@ static void copyData(const ModifierData *md, ModifierData *target, const int fla
#ifndef WITH_FLUID
UNUSED_VARS(md, target, flag);
#else
const FluidModifierData *mmd = (const FluidModifierData *)md;
FluidModifierData *tmmd = (FluidModifierData *)target;
const FluidModifierData *fmd = (const FluidModifierData *)md;
FluidModifierData *tfmd = (FluidModifierData *)target;
BKE_fluid_modifier_free(tmmd);
BKE_fluid_modifier_copy(mmd, tmmd, flag);
BKE_fluid_modifier_free(tfmd);
BKE_fluid_modifier_copy(fmd, tfmd, flag);
#endif /* WITH_FLUID */
}
@ -86,9 +86,9 @@ static void freeData(ModifierData *md)
#ifndef WITH_FLUID
UNUSED_VARS(md);
#else
FluidModifierData *mmd = (FluidModifierData *)md;
FluidModifierData *fmd = (FluidModifierData *)md;
BKE_fluid_modifier_free(mmd);
BKE_fluid_modifier_free(fmd);
#endif /* WITH_FLUID */
}
@ -96,16 +96,16 @@ static void requiredDataMask(Object *UNUSED(ob),
ModifierData *md,
CustomData_MeshMasks *r_cddata_masks)
{
FluidModifierData *mmd = (FluidModifierData *)md;
FluidModifierData *fmd = (FluidModifierData *)md;
if (mmd && (mmd->type & MOD_FLUID_TYPE_FLOW) && mmd->flow) {
if (mmd->flow->source == FLUID_FLOW_SOURCE_MESH) {
if (fmd && (fmd->type & MOD_FLUID_TYPE_FLOW) && fmd->flow) {
if (fmd->flow->source == FLUID_FLOW_SOURCE_MESH) {
/* vertex groups */
if (mmd->flow->vgroup_density) {
if (fmd->flow->vgroup_density) {
r_cddata_masks->vmask |= CD_MASK_MDEFORMVERT;
}
/* uv layer */
if (mmd->flow->texture_type == FLUID_FLOW_TEXTURE_MAP_UV) {
if (fmd->flow->texture_type == FLUID_FLOW_TEXTURE_MAP_UV) {
r_cddata_masks->fmask |= CD_MASK_MTFACE;
}
}
@ -118,7 +118,7 @@ static Mesh *modifyMesh(ModifierData *md, const ModifierEvalContext *ctx, Mesh *
UNUSED_VARS(md, ctx);
return me;
#else
FluidModifierData *mmd = (FluidModifierData *)md;
FluidModifierData *fmd = (FluidModifierData *)md;
Mesh *result = NULL;
if (ctx->flag & MOD_APPLY_ORCO) {
@ -127,7 +127,7 @@ static Mesh *modifyMesh(ModifierData *md, const ModifierEvalContext *ctx, Mesh *
Scene *scene = DEG_get_evaluated_scene(ctx->depsgraph);
result = BKE_fluid_modifier_do(mmd, ctx->depsgraph, scene, ctx->object, me);
result = BKE_fluid_modifier_do(fmd, ctx->depsgraph, scene, ctx->object, me);
return result ? result : me;
#endif /* WITH_FLUID */
}
@ -139,69 +139,69 @@ static bool dependsOnTime(ModifierData *UNUSED(md))
static bool is_flow_cb(Object *UNUSED(ob), ModifierData *md)
{
FluidModifierData *mmd = (FluidModifierData *)md;
return (mmd->type & MOD_FLUID_TYPE_FLOW) && mmd->flow;
FluidModifierData *fmd = (FluidModifierData *)md;
return (fmd->type & MOD_FLUID_TYPE_FLOW) && fmd->flow;
}
static bool is_coll_cb(Object *UNUSED(ob), ModifierData *md)
{
FluidModifierData *mmd = (FluidModifierData *)md;
return (mmd->type & MOD_FLUID_TYPE_EFFEC) && mmd->effector;
FluidModifierData *fmd = (FluidModifierData *)md;
return (fmd->type & MOD_FLUID_TYPE_EFFEC) && fmd->effector;
}
static void updateDepsgraph(ModifierData *md, const ModifierUpdateDepsgraphContext *ctx)
{
FluidModifierData *mmd = (FluidModifierData *)md;
FluidModifierData *fmd = (FluidModifierData *)md;
if (mmd && (mmd->type & MOD_FLUID_TYPE_DOMAIN) && mmd->domain) {
if (fmd && (fmd->type & MOD_FLUID_TYPE_DOMAIN) && fmd->domain) {
DEG_add_collision_relations(ctx->node,
ctx->object,
mmd->domain->fluid_group,
fmd->domain->fluid_group,
eModifierType_Fluid,
is_flow_cb,
"Fluid Flow");
DEG_add_collision_relations(ctx->node,
ctx->object,
mmd->domain->effector_group,
fmd->domain->effector_group,
eModifierType_Fluid,
is_coll_cb,
"Fluid Effector");
DEG_add_forcefield_relations(ctx->node,
ctx->object,
mmd->domain->effector_weights,
fmd->domain->effector_weights,
true,
PFIELD_FLUIDFLOW,
"Fluid Force Field");
if (mmd->domain->guide_parent != NULL) {
if (fmd->domain->guide_parent != NULL) {
DEG_add_object_relation(
ctx->node, mmd->domain->guide_parent, DEG_OB_COMP_TRANSFORM, "Fluid Guiding Object");
ctx->node, fmd->domain->guide_parent, DEG_OB_COMP_TRANSFORM, "Fluid Guiding Object");
DEG_add_object_relation(
ctx->node, mmd->domain->guide_parent, DEG_OB_COMP_GEOMETRY, "Fluid Guiding Object");
ctx->node, fmd->domain->guide_parent, DEG_OB_COMP_GEOMETRY, "Fluid Guiding Object");
}
}
}
static void foreachIDLink(ModifierData *md, Object *ob, IDWalkFunc walk, void *userData)
{
FluidModifierData *mmd = (FluidModifierData *)md;
FluidModifierData *fmd = (FluidModifierData *)md;
if (mmd->type == MOD_FLUID_TYPE_DOMAIN && mmd->domain) {
walk(userData, ob, (ID **)&mmd->domain->effector_group, IDWALK_CB_NOP);
walk(userData, ob, (ID **)&mmd->domain->fluid_group, IDWALK_CB_NOP);
walk(userData, ob, (ID **)&mmd->domain->force_group, IDWALK_CB_NOP);
if (fmd->type == MOD_FLUID_TYPE_DOMAIN && fmd->domain) {
walk(userData, ob, (ID **)&fmd->domain->effector_group, IDWALK_CB_NOP);
walk(userData, ob, (ID **)&fmd->domain->fluid_group, IDWALK_CB_NOP);
walk(userData, ob, (ID **)&fmd->domain->force_group, IDWALK_CB_NOP);
if (mmd->domain->guide_parent) {
walk(userData, ob, (ID **)&mmd->domain->guide_parent, IDWALK_CB_NOP);
if (fmd->domain->guide_parent) {
walk(userData, ob, (ID **)&fmd->domain->guide_parent, IDWALK_CB_NOP);
}
if (mmd->domain->effector_weights) {
walk(userData, ob, (ID **)&mmd->domain->effector_weights->group, IDWALK_CB_NOP);
if (fmd->domain->effector_weights) {
walk(userData, ob, (ID **)&fmd->domain->effector_weights->group, IDWALK_CB_NOP);
}
}
if (mmd->type == MOD_FLUID_TYPE_FLOW && mmd->flow) {
walk(userData, ob, (ID **)&mmd->flow->noise_texture, IDWALK_CB_USER);
if (fmd->type == MOD_FLUID_TYPE_FLOW && fmd->flow) {
walk(userData, ob, (ID **)&fmd->flow->noise_texture, IDWALK_CB_USER);
}
}