Page MenuHome
Differential D3857 Diff 19947 source/blender/blenkernel/intern/particle_system.c

Changeset View

Standalone View

View Options

source/blender/blenkernel/intern/particle_system.c

Show First 20 Lines • Show All 79 Lines • ▼ Show 20 Lines
#include "DEG_depsgraph.h" #include "DEG_depsgraph.h"
#include "DEG_depsgraph_physics.h" #include "DEG_depsgraph_physics.h"
#include "DEG_depsgraph_query.h" #include "DEG_depsgraph_query.h"
#include "PIL_time.h" #include "PIL_time.h"
#include "RE_shader_ext.h" #include "RE_shader_ext.h"
/* fluid sim particle import */ /* manta sim particle import */
#ifdef WITH_MOD_FLUID #ifdef WITH_MANTA
# include "DNA_object_fluidsim_types.h" # include "DNA_manta_types.h"
# include "LBM_fluidsim.h" # include "manta_fluid_API.h"
# include <zlib.h> #endif // WITH_MANTA
# include <string.h>
#endif // WITH_MOD_FLUID
static ThreadRWMutex psys_bvhtree_rwlock = BLI_RWLOCK_INITIALIZER; static ThreadRWMutex psys_bvhtree_rwlock = BLI_RWLOCK_INITIALIZER;
/************************************************/ /************************************************/
/* Reacting to system events */ /* Reacting to system events */
/************************************************/ /************************************************/
static int particles_are_dynamic(ParticleSystem *psys) static int particles_are_dynamic(ParticleSystem *psys)
▲ Show 20 Lines • Show All 472 Lines • ▼ Show 20 Lines
static void initialize_particle_texture(ParticleSimulationData *sim, ParticleData *pa, int p) static void initialize_particle_texture(ParticleSimulationData *sim, ParticleData *pa, int p)
{ {
ParticleSystem *psys = sim->psys; ParticleSystem *psys = sim->psys;
ParticleSettings *part = psys->part; ParticleSettings *part = psys->part;
ParticleTexture ptex; ParticleTexture ptex;
psys_get_texture(sim, pa, &ptex, PAMAP_INIT, 0.f); psys_get_texture(sim, pa, &ptex, PAMAP_INIT, 0.f);
switch (part->type) { if (part->type & PART_EMITTER) {
case PART_EMITTER:
if (ptex.exist < psys_frand(psys, p + 125)) { if (ptex.exist < psys_frand(psys, p + 125)) {
pa->flag |= PARS_UNEXIST; pa->flag |= PARS_UNEXIST;
} }
pa->time = part->sta + (part->end - part->sta) * ptex.time; pa->time = part->sta + (part->end - part->sta) * ptex.time;
break; }
case PART_HAIR: if (part->type & PART_HAIR) {
sergeyUnsubmitted
Done
Inline Actions

I don't understand it. Particle system can not be emitter and hair at the same time and type can not be a bitfield.

sergey: I don't understand it. Particle system can not be emitter and hair at the same time and type…
sebbasAuthorUnsubmitted
Done
Inline Actions

I agree. This doesn't make any sense. Changed it.

sebbas: I agree. This doesn't make any sense. Changed it.
sergeyUnsubmitted
Done
Inline Actions

Why not to keep it as a switch statement?

sergey: Why not to keep it as a switch statement?
sebbasAuthorUnsubmitted
Done
Inline Actions

Yes, let's do that. I don't really have an opinion on this. The whole change probably just came from me not liking case statement so much.

sebbas: Yes, let's do that. I don't really have an opinion on this. The whole change probably just came…
if (ptex.exist < psys_frand(psys, p + 125)) { if (ptex.exist < psys_frand(psys, p + 125)) {
pa->flag |= PARS_UNEXIST; pa->flag |= PARS_UNEXIST;
} }
pa->time = 0.f; pa->time = 0.f;
break;
case PART_FLUID:
break;
} }
} }
/* set particle parameters that don't change during particle's life */ /* set particle parameters that don't change during particle's life */
void initialize_particle(ParticleSimulationData *sim, ParticleData *pa) void initialize_particle(ParticleSimulationData *sim, ParticleData *pa)
{ {
ParticleSettings *part = sim->psys->part; ParticleSettings *part = sim->psys->part;
float birth_time = (float)(pa - sim->psys->particles) / (float)sim->psys->totpart; float birth_time = (float)(pa - sim->psys->particles) / (float)sim->psys->totpart;
▲ Show 20 Lines • Show All 3,530 Lines • ▼ Show 20 Lines if (psys_frand(psys, p) > disp) {
pa->flag |= PARS_NO_DISP; pa->flag |= PARS_NO_DISP;
} }
else { else {
pa->flag &= ~PARS_NO_DISP; pa->flag &= ~PARS_NO_DISP;
} }
} }
} }
static void particles_fluid_step(ParticleSimulationData *sim, static void particles_manta_step(ParticleSimulationData *sim,
int UNUSED(cfra), int UNUSED(cfra),
const bool use_render_params) const bool use_render_params)
{ {
ParticleSystem *psys = sim->psys; ParticleSystem *psys = sim->psys;
if (psys->particles) { if (psys->particles) {
MEM_freeN(psys->particles); MEM_freeN(psys->particles);
psys->particles = 0; psys->particles = 0;
psys->totpart = 0; psys->totpart = 0;
} }
/* fluid sim particle import handling, actual loading of particles from file */ #ifdef WITH_MANTA
#ifdef WITH_MOD_FLUID
{ {
FluidsimModifierData *fluidmd = (FluidsimModifierData *)modifiers_findByType( Object *ob = sim->ob;
sim->ob, eModifierType_Fluidsim); MantaModifierData *mmd = (MantaModifierData *)modifiers_findByType(ob, eModifierType_Manta);
if (mmd && mmd->domain && mmd->domain->fluid) {
MantaDomainSettings *mds = mmd->domain;
if (fluidmd && fluidmd->fss) {
FluidsimSettings *fss = fluidmd->fss;
ParticleSettings *part = psys->part; ParticleSettings *part = psys->part;
ParticleData *pa = NULL; ParticleData *pa = NULL;
char filename[256];
char debugStrBuffer[256];
int curFrame = sim->scene->r.cfra - 1; // warning - sync with derived mesh fsmesh loading
int p, j, totpart;
int readMask, activeParts = 0, fileParts = 0;
gzFile gzf;
// XXX if (ob==G.obedit) // off...
// return;
// ok, start loading int p, totpart, tottypepart = 0;
BLI_join_dirfile( int flagActivePart, activeParts = 0;
filename, sizeof(filename), fss->surfdataPath, OB_FLUIDSIM_SURF_PARTICLES_FNAME); float posX, posY, posZ, velX, velY, velZ;
float resX, resY, resZ;
BLI_path_abs(filename, modifier_path_relbase_from_global(sim->ob)); int upres = 1;
char debugStrBuffer[256];
float tmp[3] = {0}, tmp2[3] = {0};
BLI_path_frame(filename, curFrame, 0); // fixed #frame-no /* Helper variables for scaling */
float min[3], max[3], size[3], cell_size_scaled[3], max_size;
gzf = BLI_gzopen(filename, "rb"); /* Sanity check: parts also enabled in fluid domain? */
if (!gzf) { if ((part->type & PART_MANTA_FLIP &&
(mds->particle_type & FLUID_DOMAIN_PARTICLE_FLIP) == 0) ||
(part->type & PART_MANTA_SPRAY &&
(mds->particle_type & FLUID_DOMAIN_PARTICLE_SPRAY) == 0) ||
(part->type & PART_MANTA_BUBBLE &&
(mds->particle_type & FLUID_DOMAIN_PARTICLE_BUBBLE) == 0) ||
(part->type & PART_MANTA_FOAM &&
(mds->particle_type & FLUID_DOMAIN_PARTICLE_FOAM) == 0) ||
(part->type & PART_MANTA_TRACER &&
(mds->particle_type & FLUID_DOMAIN_PARTICLE_TRACER) == 0)) {
BLI_snprintf(debugStrBuffer, BLI_snprintf(debugStrBuffer,
sizeof(debugStrBuffer), sizeof(debugStrBuffer),
"readFsPartData::error - Unable to open file for reading '%s'\n", "particles_manta_step::error - found particle system that is not enabled in "
filename); "fluid domain\n");
// XXX bad level call elbeemDebugOut(debugStrBuffer);
return; return;
} }
gzread(gzf, &totpart, sizeof(totpart)); /* Count particle amount. tottypepart only important for snd particles */
totpart = (use_render_params) ? totpart : (part->disp * totpart) / 100; if (part->type & PART_MANTA_FLIP) {
tottypepart = totpart = manta_liquid_get_num_flip_particles(mds->fluid);
}
if (part->type &
(PART_MANTA_SPRAY | PART_MANTA_BUBBLE | PART_MANTA_FOAM | PART_MANTA_TRACER)) {
totpart = manta_liquid_get_num_snd_particles(mds->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);
if ((part->type & PART_MANTA_SPRAY) && (flagActivePart & PSPRAY))
tottypepart++;
if ((part->type & PART_MANTA_BUBBLE) && (flagActivePart & PBUBBLE))
tottypepart++;
if ((part->type & PART_MANTA_FOAM) && (flagActivePart & PFOAM))
tottypepart++;
if ((part->type & PART_MANTA_TRACER) && (flagActivePart & PTRACER))
tottypepart++;
}
}
/* Sanity check: no particles present */
if (!totpart || !tottypepart)
return;
/* How many particles to display? */
tottypepart = (use_render_params) ? tottypepart : (part->disp * tottypepart) / 100;
part->totpart = totpart; part->totpart = tottypepart;
part->sta = part->end = 1.0f; part->sta = part->end = 1.0f;
part->lifetime = sim->scene->r.efra + 1; part->lifetime = sim->scene->r.efra + 1;
/* allocate particles */ /* Allocate particles */
realloc_particles(sim, part->totpart); realloc_particles(sim, part->totpart);
// set up reading mask /* Randomness when choosing which particles to display */
readMask = fss->typeFlags; srand(123456789); // set seed
sergeyUnsubmitted
Not Done
Inline Actions

Shouldn't this be using seed from settings?

But it also seems you've got way bigger design violation here. srand()modifies global state, so you can not use it from a function which runs in threads. You should be using reentrant variant of rand() instead.

sergey: Shouldn't this be using seed from settings? But it also seems you've got way bigger design…
sebbasAuthorUnsubmitted
Done
Inline Actions

I see. I figured that this is how other particle steps set the seed: c54fd66c0a17

Would this work?

sebbas: I see. I figured that this is how other particle steps set the seed: c54fd66c0a17 Would this…
sergeyUnsubmitted
Done
Inline Actions

I figured that this is how other particle steps set the seed

That would only mean that the other step functions are wrong.
We've already had issues with this during Spring (re-rendering same frame would distribute particles differently).

As for c54fd66c0a17: sim->rng the idea is correct. Just watch out for where rng is being allocated. Code is a bit hairy, so not sure if particles_manta_step ever called from dynamics_step.

Also keep in mind that to access random numbers you are to use BLI_rng_get() (and not rand()). So depending on where the random values are accessed from you might need to go deeper.

sergey: > I figured that this is how other particle steps set the seed That would only mean that the…
sebbasAuthorUnsubmitted
Done
Inline Actions

Okay, good to know. I am using now BLI_rng_get_double() to get the random value.

sebbas: Okay, good to know. I am using now `BLI_rng_get_double()` to get the random value.
double r, dispProb = (double)part->disp / 100.0;
/* Loop over *all* particles. Will break out of loop before tottypepart amount exceeded */
for (p = 0, pa = psys->particles; p < totpart; p++) {
/* Apply some randomness and determine which particles to skip */
r = (double)rand() / (double)RAND_MAX;
if (r > dispProb)
continue;
for (p = 0, pa = psys->particles; p < totpart; p++, pa++) { /* flag, res, upres, pos, vel for FLIP and snd particles have different getterss */
int ptype = 0; if (part->type & PART_MANTA_FLIP) {
flagActivePart = manta_liquid_get_flip_particle_flag_at(mds->fluid, p);
gzread(gzf, &ptype, sizeof(ptype)); resX = (float)manta_get_res_x(mds->fluid);
if (ptype & readMask) { resY = (float)manta_get_res_y(mds->fluid);
activeParts++; resZ = (float)manta_get_res_z(mds->fluid);
gzread(gzf, &(pa->size), sizeof(float)); upres = 1;
pa->size /= 10.0f; 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);
for (j = 0; j < 3; j++) { velX = manta_liquid_get_flip_particle_velocity_x_at(mds->fluid, p);
float wrf; velY = manta_liquid_get_flip_particle_velocity_y_at(mds->fluid, p);
gzread(gzf, &wrf, sizeof(wrf)); velZ = manta_liquid_get_flip_particle_velocity_z_at(mds->fluid, p);
pa->state.co[j] = wrf;
// fprintf(stderr,"Rj%d ",j);
}
for (j = 0; j < 3; j++) {
float wrf;
gzread(gzf, &wrf, sizeof(wrf));
pa->state.vel[j] = wrf;
} }
else if (part->type &
(PART_MANTA_SPRAY | PART_MANTA_BUBBLE | PART_MANTA_FOAM | PART_MANTA_TRACER)) {
flagActivePart = manta_liquid_get_snd_particle_flag_at(mds->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);
upres = manta_liquid_get_particle_upres(mds->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);
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);
}
else {
BLI_snprintf(debugStrBuffer,
sizeof(debugStrBuffer),
"particles_manta_step::error - unknown particle system type\n");
return;
}
// printf("part->type: %d, flagActivePart: %d\n", part->type, flagActivePart);
/* Type of particle must matche current particle system type (only important for snd
* particles) */
if ((flagActivePart & PSPRAY) && (part->type & PART_MANTA_SPRAY) == 0)
continue;
if ((flagActivePart & PBUBBLE) && (part->type & PART_MANTA_BUBBLE) == 0)
continue;
if ((flagActivePart & PFOAM) && (part->type & PART_MANTA_FOAM) == 0)
continue;
if ((flagActivePart & PTRACER) && (part->type & PART_MANTA_TRACER) == 0)
continue;
// printf("system type is %d and particle type is %d\n", part->type, flagActivePart);
sergeyUnsubmitted
Done
Inline Actions

Dead code is discouraged.

sergey: Dead code is discouraged.
/* Particle system has allocated tottypeparts particles - so break early before exceeded */
if (activeParts >= tottypepart)
break;
/* Only show active particles, i.e. filter out dead particles that just Mantaflow needs
* Mantaflow convention: PDELETE == inactive particle */
if ((flagActivePart & PDELETE) == 0) {
activeParts++;
/* Use particle system settings for particle size */
pa->size = part->size;
if (part->randsize > 0.0f)
pa->size *= 1.0f - part->randsize * psys_frand(psys, p + 1);
/* Get size (dimension) but considering scaling */
copy_v3_v3(cell_size_scaled, mds->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);
sub_v3_v3v3(size, max, min);
/* Biggest dimension will be used for upscaling */
max_size = MAX3(size[0] / (float)upres, size[1] / (float)upres, size[2] / (float)upres);
/* Set particle position */
pa->state.co[0] = posX;
pa->state.co[1] = posY;
pa->state.co[2] = posZ;
sergeyUnsubmitted
Done
Inline Actions

Merge pos{X,Y,Z} into a float[3] and use vector math.

Sane for velocity.

sergey: Merge `pos{X,Y,Z}` into a `float[3]` and use vector math. Sane for velocity.
/* Normalize to unit cube around 0 */
pa->state.co[0] -= resX * 0.5f;
pa->state.co[1] -= resY * 0.5f;
pa->state.co[2] -= resZ * 0.5f;
mul_v3_fl(pa->state.co, mds->dx);
/* Match domain dimension / size */
pa->state.co[0] *= max_size / fabsf(ob->scale[0]);
pa->state.co[1] *= max_size / fabsf(ob->scale[1]);
pa->state.co[2] *= max_size / fabsf(ob->scale[2]);
/* Match domain scale */
mul_m4_v3(ob->obmat, pa->state.co);
/* Add origin offset to particle position */
zero_v3(tmp);
zero_v3(tmp2);
sub_v3_v3v3(tmp2, mds->p1, mds->p0);
mul_v3_fl(tmp2, 0.5f);
add_v3_v3v3(tmp, tmp, mds->p1);
sub_v3_v3(tmp, tmp2);
mul_v3_v3(tmp, ob->scale);
add_v3_v3(pa->state.co, tmp);
// printf("pa->state.co[0]: %f, pa->state.co[1]: %f, pa->state.co[2]: %f\n",
// pa->state.co[0], pa->state.co[1], pa->state.co[2]);
/* Set particle velocity */
pa->state.vel[0] = velX;
pa->state.vel[1] = velY;
pa->state.vel[2] = velZ;
mul_v3_fl(pa->state.vel, mds->dx);
// printf("pa->state.vel[0]: %f, pa->state.vel[1]: %f, pa->state.vel[2]: %f\n",
// pa->state.vel[0], pa->state.vel[1], pa->state.vel[2]);
/* Set default angular velocity and particle rotation */
zero_v3(pa->state.ave); zero_v3(pa->state.ave);
unit_qt(pa->state.rot); unit_qt(pa->state.rot);
pa->time = 1.f; pa->time = 1.f;
pa->dietime = sim->scene->r.efra + 1; pa->dietime = sim->scene->r.efra + 1;
pa->lifetime = sim->scene->r.efra; pa->lifetime = sim->scene->r.efra;
pa->alive = PARS_ALIVE; pa->alive = PARS_ALIVE;
# if 0
if (a < 25) { /* Increasing particle settings pointer only for active particles */
fprintf(stderr, pa++;
"FSPARTICLE debug set %s, a%d = %f,%f,%f, life=%f\n",
filename,
a,
pa->co[0],
pa->co[1],
pa->co[2],
pa->lifetime);
}
# endif
}
else {
// skip...
for (j = 0; j < 2 * 3 + 1; j++) {
float wrf;
gzread(gzf, &wrf, sizeof(wrf));
}
} }
fileParts++;
} }
gzclose(gzf); // printf("active parts: %d\n", activeParts);
totpart = psys->totpart = part->totpart = activeParts;
totpart = psys->totpart = activeParts; } // manta sim particles done
BLI_snprintf(debugStrBuffer,
sizeof(debugStrBuffer),
"readFsPartData::done - particles:%d, active:%d, file:%d, mask:%d\n",
psys->totpart,
activeParts,
fileParts,
readMask);
// bad level call
// XXX elbeemDebugOut(debugStrBuffer);
} // fluid sim particles done
} }
#else #else
UNUSED_VARS(use_render_params); UNUSED_VARS(use_render_params);
#endif // WITH_MOD_FLUID #endif // WITH_MANTA
} }
static int emit_particles(ParticleSimulationData *sim, PTCacheID *pid, float UNUSED(cfra)) static int emit_particles(ParticleSimulationData *sim, PTCacheID *pid, float UNUSED(cfra))
{ {
ParticleSystem *psys = sim->psys; ParticleSystem *psys = sim->psys;
int oldtotpart = psys->totpart; int oldtotpart = psys->totpart;
int totpart = tot_particles(psys, pid); int totpart = tot_particles(psys, pid);
▲ Show 20 Lines • Show All 364 Lines • ▼ Show 20 Linesvoid particle_system_update(struct Depsgraph *depsgraph,
if (psys->recalc & ID_RECALC_PSYS_RESET) { if (psys->recalc & ID_RECALC_PSYS_RESET) {
psys->totunexist = 0; psys->totunexist = 0;
} }
/* setup necessary physics type dependent additional data if it doesn't yet exist */ /* setup necessary physics type dependent additional data if it doesn't yet exist */
psys_prepare_physics(&sim); psys_prepare_physics(&sim);
switch (part->type) { if (part->type & PART_HAIR) {
case PART_HAIR: {
/* nothing to do so bail out early */ /* nothing to do so bail out early */
if (psys->totpart == 0 && part->totpart == 0) { if (psys->totpart == 0 && part->totpart == 0) {
psys_free_path_cache(psys, NULL); psys_free_path_cache(psys, NULL);
free_hair(ob, psys, 0); free_hair(ob, psys, 0);
psys->flag |= PSYS_HAIR_DONE; psys->flag |= PSYS_HAIR_DONE;
} }
/* (re-)create hair */ /* (re-)create hair */
else if (hair_needs_recalc(psys)) { else if (hair_needs_recalc(psys)) {
float hcfra = 0.0f; float hcfra = 0.0f;
int i, recalc = psys->recalc; int i, recalc = psys->recalc;
free_hair(ob, psys, 0); free_hair(ob, psys, 0);
if (psys_orig->edit && psys_orig->free_edit) { if (psys_orig->edit && psys_orig->free_edit) {
psys_orig->free_edit(psys_orig->edit); psys_orig->free_edit(psys_orig->edit);
psys_orig->edit = NULL; psys_orig->edit = NULL;
psys_orig->free_edit = NULL; psys_orig->free_edit = NULL;
} }
/* first step is negative so particles get killed and reset */ /* first step is negative so particles get killed and reset */
psys->cfra = 1.0f; psys->cfra = 1.0f;
ParticleSettings *part_local = part; ParticleSettings *part_local = part;
if ((part->flag & PART_HAIR_REGROW) == 0) { if ((part->flag & PART_HAIR_REGROW) == 0) {
part_local = particle_settings_localize(part); part_local = particle_settings_localize(part);
psys->part = part_local; psys->part = part_local;
} }
for (i = 0; i <= part->hair_step; i++) { for (i = 0; i <= part->hair_step; i++) {
hcfra = 100.0f * (float)i / (float)psys->part->hair_step; hcfra = 100.0f * (float)i / (float)psys->part->hair_step;
if ((part->flag & PART_HAIR_REGROW) == 0) { if ((part->flag & PART_HAIR_REGROW) == 0) {
BKE_animsys_evaluate_animdata( BKE_animsys_evaluate_animdata(
scene, &part_local->id, part_local->adt, hcfra, ADT_RECALC_ANIM, false); scene, &part_local->id, part_local->adt, hcfra, ADT_RECALC_ANIM, false);
} }
system_step(&sim, hcfra, use_render_params); system_step(&sim, hcfra, use_render_params);
psys->cfra = hcfra; psys->cfra = hcfra;
psys->recalc = 0; psys->recalc = 0;
save_hair(&sim, hcfra); save_hair(&sim, hcfra);
} }
if (part_local != part) { if (part_local != part) {
particle_settings_free_local(part_local); particle_settings_free_local(part_local);
psys->part = part; psys->part = part;
} }
psys->flag |= PSYS_HAIR_DONE; psys->flag |= PSYS_HAIR_DONE;
psys->recalc = recalc; psys->recalc = recalc;
} }
else if (psys->flag & PSYS_EDITED) { else if (psys->flag & PSYS_EDITED) {
psys->flag |= PSYS_HAIR_DONE; psys->flag |= PSYS_HAIR_DONE;
} }
if (psys->flag & PSYS_HAIR_DONE) { if (psys->flag & PSYS_HAIR_DONE) {
hair_step(&sim, cfra, use_render_params); hair_step(&sim, cfra, use_render_params);
} }
break;
} }
case PART_FLUID: { else if (part->type & (PART_MANTA_FLIP | PART_MANTA_BUBBLE | PART_MANTA_BUBBLE |
particles_fluid_step(&sim, (int)cfra, use_render_params); PART_MANTA_FOAM | PART_MANTA_TRACER)) {
break; particles_manta_step(&sim, (int)cfra, use_render_params);
} }
default: { else {
switch (part->phystype) { switch (part->phystype) {
case PART_PHYS_NO: case PART_PHYS_NO:
case PART_PHYS_KEYED: { case PART_PHYS_KEYED: {
PARTICLE_P; PARTICLE_P;
float disp = psys_get_current_display_percentage(psys, use_render_params); float disp = psys_get_current_display_percentage(psys, use_render_params);
bool free_unexisting = false; bool free_unexisting = false;
/* Particles without dynamics haven't been reset yet because they don't use pointcache */ /* Particles without dynamics haven't been reset yet because they don't use pointcache */
if (psys->recalc & ID_RECALC_PSYS_RESET) { if (psys->recalc & ID_RECALC_PSYS_RESET) {
psys_reset(psys, PSYS_RESET_ALL); psys_reset(psys, PSYS_RESET_ALL);
} }
if (emit_particles(&sim, NULL, cfra) || (psys->recalc & ID_RECALC_PSYS_RESET)) { if (emit_particles(&sim, NULL, cfra) || (psys->recalc & ID_RECALC_PSYS_RESET)) {
free_keyed_keys(psys); free_keyed_keys(psys);
distribute_particles(&sim, part->from); distribute_particles(&sim, part->from);
initialize_all_particles(&sim); initialize_all_particles(&sim);
free_unexisting = true; free_unexisting = true;
/* flag for possible explode modifiers after this system */ /* flag for possible explode modifiers after this system */
sim.psmd->flag |= eParticleSystemFlag_Pars; sim.psmd->flag |= eParticleSystemFlag_Pars;
} }
LOOP_EXISTING_PARTICLES LOOP_EXISTING_PARTICLES
{ {
pa->size = part->size; pa->size = part->size;
if (part->randsize > 0.0f) { if (part->randsize > 0.0f) {
pa->size *= 1.0f - part->randsize * psys_frand(psys, p + 1); pa->size *= 1.0f - part->randsize * psys_frand(psys, p + 1);
} }
reset_particle(&sim, pa, 0.0, cfra); reset_particle(&sim, pa, 0.0, cfra);
if (psys_frand(psys, p) > disp) { if (psys_frand(psys, p) > disp) {
pa->flag |= PARS_NO_DISP; pa->flag |= PARS_NO_DISP;
} }
else { else {
pa->flag &= ~PARS_NO_DISP; pa->flag &= ~PARS_NO_DISP;
} }
} }
/* free unexisting after resetting particles */ /* free unexisting after resetting particles */
if (free_unexisting) { if (free_unexisting) {
free_unexisting_particles(&sim); free_unexisting_particles(&sim);
} }
if (part->phystype == PART_PHYS_KEYED) { if (part->phystype == PART_PHYS_KEYED) {
psys_count_keyed_targets(&sim); psys_count_keyed_targets(&sim);
set_keyed_keys(&sim); set_keyed_keys(&sim);
psys_update_path_cache(&sim, (int)cfra, use_render_params); psys_update_path_cache(&sim, (int)cfra, use_render_params);
} }
break; break;
} }
default: { default: {
/* the main dynamic particle system step */ /* the main dynamic particle system step */
system_step(&sim, cfra, use_render_params); system_step(&sim, cfra, use_render_params);
break; break;
} }
} }
break;
}
} }
/* make sure emitter is left at correct time (particle emission can change this) */ /* make sure emitter is left at correct time (particle emission can change this) */
if (psys->flag & PSYS_OB_ANIM_RESTORE) { if (psys->flag & PSYS_OB_ANIM_RESTORE) {
evaluate_emitter_anim(depsgraph, scene, ob, cfra); evaluate_emitter_anim(depsgraph, scene, ob, cfra);
psys->flag &= ~PSYS_OB_ANIM_RESTORE; psys->flag &= ~PSYS_OB_ANIM_RESTORE;
} }
▲ Show 20 Lines • Show All 80 Lines • Show Last 20 Lines