Page MenuHome
Differential D3857 Diff 12365 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 101 Lines • ▼ Show 20 Lines
#ifdef WITH_MOD_FLUID #ifdef WITH_MOD_FLUID
#include "DNA_object_fluidsim_types.h" #include "DNA_object_fluidsim_types.h"
#include "LBM_fluidsim.h" #include "LBM_fluidsim.h"
#include <zlib.h> #include <zlib.h>
#include <string.h> #include <string.h>
#endif // WITH_MOD_FLUID #endif // WITH_MOD_FLUID
/* manta sim particle import */
#ifdef WITH_MANTA
# include "DNA_smoke_types.h"
# include "manta_fluid_API.h"
#endif // WITH_MANTA
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 409 Lines • ▼ Show 20 Lines if (ctx->roughcurve != NULL) {
curvemapping_free(ctx->roughcurve); curvemapping_free(ctx->roughcurve);
} }
if (ctx->twistcurve != NULL) { if (ctx->twistcurve != NULL) {
curvemapping_free(ctx->twistcurve); curvemapping_free(ctx->twistcurve);
} }
} }
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) {
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;
} }
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…
} }
/* 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,241 Lines • ▼ Show 20 Lines LOOP_PARTICLES {
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;
} }
} }
static void particles_manta_step(
ParticleSimulationData *sim, int UNUSED(cfra), const bool use_render_params)
{
ParticleSystem *psys = sim->psys;
if (psys->particles) {
MEM_freeN(psys->particles);
psys->particles = 0;
psys->totpart = 0;
}
#ifdef WITH_MANTA
{
Object *ob = sim->ob;
SmokeModifierData *smd = (SmokeModifierData *)modifiers_findByType(ob, eModifierType_Smoke);
if (smd && smd->domain && smd->domain->fluid) {
SmokeDomainSettings *sds= smd->domain;
ParticleSettings *part = psys->part;
ParticleData *pa=NULL;
int p, totpart, tottypepart = 0;
int flagActivePart, activeParts = 0;
float posX, posY, posZ, velX, velY, velZ;
float resX, resY, resZ;
int upres = 1;
char debugStrBuffer[256];
/* Helper variables for scaling */
float min[3], max[3], size[3], cell_size_scaled[3], max_size;
/* Sanity check: parts also enabled in fluid domain? */
if ((part->type & PART_MANTA_FLIP && (sds->particle_type & FLUID_DOMAIN_PARTICLE_FLIP)==0) ||
(part->type & PART_MANTA_SPRAY && (sds->particle_type & FLUID_DOMAIN_PARTICLE_SPRAY)==0) ||
(part->type & PART_MANTA_BUBBLE && (sds->particle_type & FLUID_DOMAIN_PARTICLE_BUBBLE)==0) ||
(part->type & PART_MANTA_FOAM && (sds->particle_type & FLUID_DOMAIN_PARTICLE_FOAM)==0) ||
(part->type & PART_MANTA_TRACER && (sds->particle_type & FLUID_DOMAIN_PARTICLE_TRACER)==0) )
{
BLI_snprintf(debugStrBuffer, sizeof(debugStrBuffer), "particles_manta_step::error - found particle system that is not enabled in fluid domain\n");
return;
}
/* Count particle amount. tottypepart only important for snd particles */
if (part->type & PART_MANTA_FLIP) {
tottypepart = totpart = liquid_get_num_flip_particles(sds->fluid);
}
if (part->type & (PART_MANTA_SPRAY | PART_MANTA_BUBBLE | PART_MANTA_FOAM | PART_MANTA_TRACER)) {
totpart = liquid_get_num_snd_particles(sds->fluid);
/* tottypepart is the amount of particles of a snd particle type */
for (p=0; p<totpart; p++) {
flagActivePart = liquid_get_snd_particle_flag_at(sds->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 = tottypepart;
part->sta = part->end = 1.0f;
part->lifetime = sim->scene->r.efra + 1;
/* Allocate particles */
realloc_particles(sim, part->totpart);
/* Randomness when choosing which particles to display */
srand(123456789); // set seed
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;
/* flag, res, upres, pos, vel for FLIP and snd particles have different getterss */
if (part->type & PART_MANTA_FLIP)
{
flagActivePart = liquid_get_flip_particle_flag_at(sds->fluid, p);
resX = (float) fluid_get_res_x(sds->fluid);
resY = (float) fluid_get_res_y(sds->fluid);
resZ = (float) fluid_get_res_z(sds->fluid);
upres = 1;
posX = liquid_get_flip_particle_position_x_at(sds->fluid, p);
posY = liquid_get_flip_particle_position_y_at(sds->fluid, p);
posZ = liquid_get_flip_particle_position_z_at(sds->fluid, p);
velX = liquid_get_flip_particle_velocity_x_at(sds->fluid, p);
velY = liquid_get_flip_particle_velocity_y_at(sds->fluid, p);
velZ = liquid_get_flip_particle_velocity_z_at(sds->fluid, p);
}
else if (part->type & (PART_MANTA_SPRAY | PART_MANTA_BUBBLE | PART_MANTA_FOAM | PART_MANTA_TRACER))
{
flagActivePart = liquid_get_snd_particle_flag_at(sds->fluid, p);
resX = (float) liquid_get_particle_res_x(sds->fluid);
resY = (float) liquid_get_particle_res_y(sds->fluid);
resZ = (float) liquid_get_particle_res_z(sds->fluid);
upres = liquid_get_particle_upres(sds->fluid);
posX = liquid_get_snd_particle_position_x_at(sds->fluid, p);
posY = liquid_get_snd_particle_position_y_at(sds->fluid, p);
posZ = liquid_get_snd_particle_position_z_at(sds->fluid, p);
velX = liquid_get_snd_particle_velocity_x_at(sds->fluid, p);
velY = liquid_get_snd_particle_velocity_y_at(sds->fluid, p);
velZ = liquid_get_snd_particle_velocity_z_at(sds->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);
/* 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, sds->cell_size);
mul_v3_v3(cell_size_scaled, ob->size);
VECMADD(min, sds->p0, cell_size_scaled, sds->res_min);
VECMADD(max, sds->p0, cell_size_scaled, sds->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;
/* 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, sds->dx);
/* Match domain dimension / size */
pa->state.co[0] *= max_size / fabsf(ob->size[0]);
pa->state.co[1] *= max_size / fabsf(ob->size[1]);
pa->state.co[2] *= max_size / fabsf(ob->size[2]);
/* Match domain scale */
mul_m4_v3(ob->obmat, pa->state.co);
// 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, sds->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);
unit_qt(pa->state.rot);
pa->time = 1.f;
pa->dietime = sim->scene->r.efra + 1;
pa->lifetime = sim->scene->r.efra;
pa->alive = PARS_ALIVE;
/* Increasing particle settings pointer only for active particles */
pa++;
}
}
// printf("active parts: %d\n", activeParts);
totpart = psys->totpart = part->totpart = activeParts;
} // manta sim particles done
}
#else
UNUSED_VARS(use_render_params);
#endif // WITH_MANTA
}
static void particles_fluid_step( static void particles_fluid_step(
ParticleSimulationData *sim, int UNUSED(cfra), const bool use_render_params) ParticleSimulationData *sim, int UNUSED(cfra), 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 */ /* fluid sim particle import handling, actual loading of particles from file */
#ifdef WITH_MOD_FLUID #ifdef WITH_MOD_FLUID
{ {
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.
FluidsimModifierData *fluidmd = (FluidsimModifierData *)modifiers_findByType(sim->ob, eModifierType_Fluidsim); FluidsimModifierData *fluidmd = (FluidsimModifierData *)modifiers_findByType(sim->ob, eModifierType_Fluidsim);
if ( fluidmd && fluidmd->fss) { if ( fluidmd && fluidmd->fss) {
FluidsimSettings *fss= fluidmd->fss; FluidsimSettings *fss= fluidmd->fss;
ParticleSettings *part = psys->part; ParticleSettings *part = psys->part;
ParticleData *pa=NULL; ParticleData *pa=NULL;
char filename[256]; char filename[256];
char debugStrBuffer[256]; char debugStrBuffer[256];
int curFrame = sim->scene->r.cfra -1; // warning - sync with derived mesh fsmesh loading int curFrame = sim->scene->r.cfra -1; // warning - sync with derived mesh fsmesh loading
int p, j, totpart; int p, j, totpart;
int readMask, activeParts = 0, fileParts = 0; int readMask, activeParts = 0, fileParts = 0;
gzFile gzf; gzFile gzf;
// XXX if (ob==G.obedit) // off... // XXX if (ob==G.obedit) // off...
// return; // return;
// ok, start loading // ok, start loading
BLI_join_dirfile(filename, sizeof(filename), fss->surfdataPath, OB_FLUIDSIM_SURF_PARTICLES_FNAME); BLI_join_dirfile(filename, sizeof(filename), fss->surfdataPath, OB_FLUIDSIM_SURF_PARTICLES_FNAME);
BLI_path_abs(filename, modifier_path_relbase_from_global(sim->ob)); BLI_path_abs(filename, modifier_path_relbase_from_global(sim->ob));
BLI_path_frame(filename, curFrame, 0); // fixed #frame-no BLI_path_frame(filename, curFrame, 0); // fixed #frame-no
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.
gzf = BLI_gzopen(filename, "rb"); gzf = BLI_gzopen(filename, "rb");
if (!gzf) { if (!gzf) {
BLI_snprintf(debugStrBuffer, sizeof(debugStrBuffer),"readFsPartData::error - Unable to open file for reading '%s'\n", filename); BLI_snprintf(debugStrBuffer, sizeof(debugStrBuffer),"readFsPartData::error - Unable to open file for reading '%s'\n", filename);
// XXX bad level call elbeemDebugOut(debugStrBuffer); // XXX bad level call elbeemDebugOut(debugStrBuffer);
return; return;
} }
gzread(gzf, &totpart, sizeof(totpart)); gzread(gzf, &totpart, sizeof(totpart));
totpart = (use_render_params) ? totpart:(part->disp*totpart) / 100; totpart = (use_render_params) ? totpart:(part->disp*totpart) / 100;
part->totpart= totpart; part->totpart= totpart;
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 // set up reading mask
readMask = fss->typeFlags; readMask = fss->typeFlags;
for (p=0, pa=psys->particles; p<totpart; p++, pa++) { for (p=0, pa=psys->particles; p<totpart; p++, pa++) {
int ptype=0; int ptype=0;
sergeyUnsubmitted
Done
Inline Actions

Dead code is discouraged.

sergey: Dead code is discouraged.
gzread(gzf, &ptype, sizeof( ptype )); gzread(gzf, &ptype, sizeof( ptype ));
if (ptype & readMask) { if (ptype & readMask) {
activeParts++; activeParts++;
gzread(gzf, &(pa->size), sizeof(float)); gzread(gzf, &(pa->size), sizeof(float));
pa->size /= 10.0f; pa->size /= 10.0f;
▲ Show 20 Lines • Show All 372 Lines • ▼ Show 20 Linesvoid particle_system_update(struct Depsgraph *depsgraph, Scene *scene, Object *ob, ParticleSystem *psys, const bool use_render_params)
psys->flag &= ~PSYS_OB_ANIM_RESTORE; psys->flag &= ~PSYS_OB_ANIM_RESTORE;
if (psys->recalc & PSYS_RECALC_RESET) if (psys->recalc & PSYS_RECALC_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;
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(depsgraph, scene, &part->id, part->adt, hcfra, ADT_RECALC_ANIM); BKE_animsys_evaluate_animdata(depsgraph, scene, &part->id, part->adt, hcfra, ADT_RECALC_ANIM);
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);
} }
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_FLUID)
{ {
particles_fluid_step(&sim, (int)cfra, use_render_params); particles_fluid_step(&sim, (int)cfra, use_render_params);
break;
} }
default: else if (part->type & (PART_MANTA_FLIP | PART_MANTA_BUBBLE | PART_MANTA_BUBBLE | PART_MANTA_FOAM | PART_MANTA_TRACER))
{
particles_manta_step(&sim, (int)cfra, use_render_params);
}
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 & PSYS_RECALC_RESET) if (psys->recalc & PSYS_RECALC_RESET)
psys_reset(psys, PSYS_RESET_ALL); psys_reset(psys, PSYS_RESET_ALL);
if (emit_particles(&sim, NULL, cfra) || (psys->recalc & PSYS_RECALC_RESET)) { if (emit_particles(&sim, NULL, cfra) || (psys->recalc & PSYS_RECALC_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 66 Lines • Show Last 20 Lines