10b49cd6c6
This showed: argument 1 range [18446744071562067968, 18446744073709551615] exceeds maximum object size 9223372036854775807. It seems to think signed integers might lead to this kind of overflow, but it's unclear why these two cases are causing warnings specifically. Refactor the code to sidestep it.
5460 lines
162 KiB
C++
5460 lines
162 KiB
C++
/* SPDX-FileCopyrightText: 2007 by Janne Karhu. All rights reserved.
|
|
*
|
|
* SPDX-License-Identifier: GPL-2.0-or-later */
|
|
|
|
/** \file
|
|
* \ingroup bke
|
|
*/
|
|
|
|
/* Allow using deprecated functionality for .blend file I/O. */
|
|
#define DNA_DEPRECATED_ALLOW
|
|
|
|
#include <algorithm>
|
|
#include <cmath>
|
|
#include <cstdlib>
|
|
#include <cstring>
|
|
#include <optional>
|
|
|
|
#include "MEM_guardedalloc.h"
|
|
|
|
#include "DNA_defaults.h"
|
|
|
|
#include "DNA_cloth_types.h"
|
|
#include "DNA_collection_types.h"
|
|
#include "DNA_curve_types.h"
|
|
#include "DNA_dynamicpaint_types.h"
|
|
#include "DNA_fluid_types.h"
|
|
#include "DNA_key_types.h"
|
|
#include "DNA_material_types.h"
|
|
#include "DNA_mesh_types.h"
|
|
#include "DNA_meshdata_types.h"
|
|
#include "DNA_object_force_types.h"
|
|
#include "DNA_particle_types.h"
|
|
#include "DNA_scene_types.h"
|
|
#include "DNA_texture_types.h"
|
|
|
|
#include "BLI_kdopbvh.hh"
|
|
#include "BLI_kdtree.h"
|
|
#include "BLI_linklist.h"
|
|
#include "BLI_listbase.h"
|
|
#include "BLI_math_base_safe.h"
|
|
#include "BLI_math_geom.h"
|
|
#include "BLI_math_matrix.h"
|
|
#include "BLI_math_rotation.h"
|
|
#include "BLI_math_vector.h"
|
|
#include "BLI_rand.h"
|
|
#include "BLI_string.h"
|
|
#include "BLI_task.h"
|
|
#include "BLI_threads.h"
|
|
#include "BLI_utildefines.h"
|
|
|
|
#include "BLT_translation.hh"
|
|
|
|
#include "BKE_anim_path.h"
|
|
#include "BKE_boids.h"
|
|
#include "BKE_cloth.hh"
|
|
#include "BKE_collection.hh"
|
|
#include "BKE_colortools.hh"
|
|
#include "BKE_customdata.hh"
|
|
#include "BKE_deform.hh"
|
|
#include "BKE_displist.h"
|
|
#include "BKE_effect.h"
|
|
#include "BKE_idtype.hh"
|
|
#include "BKE_key.hh"
|
|
#include "BKE_lattice.hh"
|
|
#include "BKE_layer.hh"
|
|
#include "BKE_lib_id.hh"
|
|
#include "BKE_lib_query.hh"
|
|
#include "BKE_material.hh"
|
|
#include "BKE_mesh.hh"
|
|
#include "BKE_mesh_legacy_convert.hh"
|
|
#include "BKE_modifier.hh"
|
|
#include "BKE_object.hh"
|
|
#include "BKE_particle.h"
|
|
#include "BKE_pointcache.h"
|
|
#include "BKE_scene.hh"
|
|
#include "BKE_texture.h"
|
|
|
|
#include "DEG_depsgraph.hh"
|
|
#include "DEG_depsgraph_build.hh"
|
|
#include "DEG_depsgraph_query.hh"
|
|
|
|
#include "RE_texture.h"
|
|
|
|
#include "BLO_read_write.hh"
|
|
|
|
#include "particle_private.h"
|
|
|
|
using blender::float3;
|
|
|
|
static void fluid_free_settings(SPHFluidSettings *fluid);
|
|
|
|
static void particle_settings_init(ID *id)
|
|
{
|
|
ParticleSettings *particle_settings = (ParticleSettings *)id;
|
|
BLI_assert(MEMCMP_STRUCT_AFTER_IS_ZERO(particle_settings, id));
|
|
|
|
MEMCPY_STRUCT_AFTER(particle_settings, DNA_struct_default_get(ParticleSettings), id);
|
|
|
|
particle_settings->effector_weights = BKE_effector_add_weights(nullptr);
|
|
particle_settings->pd = BKE_partdeflect_new(PFIELD_NULL);
|
|
particle_settings->pd2 = BKE_partdeflect_new(PFIELD_NULL);
|
|
}
|
|
|
|
static void particle_settings_copy_data(Main * /*bmain*/,
|
|
std::optional<Library *> /*owner_library*/,
|
|
ID *id_dst,
|
|
const ID *id_src,
|
|
const int /*flag*/)
|
|
{
|
|
ParticleSettings *particle_settings_dst = (ParticleSettings *)id_dst;
|
|
const ParticleSettings *partticle_settings_src = (const ParticleSettings *)id_src;
|
|
|
|
particle_settings_dst->pd = BKE_partdeflect_copy(partticle_settings_src->pd);
|
|
particle_settings_dst->pd2 = BKE_partdeflect_copy(partticle_settings_src->pd2);
|
|
particle_settings_dst->effector_weights = static_cast<EffectorWeights *>(
|
|
MEM_dupallocN(partticle_settings_src->effector_weights));
|
|
particle_settings_dst->fluid = static_cast<SPHFluidSettings *>(
|
|
MEM_dupallocN(partticle_settings_src->fluid));
|
|
|
|
if (partticle_settings_src->clumpcurve) {
|
|
particle_settings_dst->clumpcurve = BKE_curvemapping_copy(partticle_settings_src->clumpcurve);
|
|
}
|
|
if (partticle_settings_src->roughcurve) {
|
|
particle_settings_dst->roughcurve = BKE_curvemapping_copy(partticle_settings_src->roughcurve);
|
|
}
|
|
if (partticle_settings_src->twistcurve) {
|
|
particle_settings_dst->twistcurve = BKE_curvemapping_copy(partticle_settings_src->twistcurve);
|
|
}
|
|
|
|
particle_settings_dst->boids = boid_copy_settings(partticle_settings_src->boids);
|
|
|
|
for (int a = 0; a < MAX_MTEX; a++) {
|
|
if (partticle_settings_src->mtex[a]) {
|
|
particle_settings_dst->mtex[a] = static_cast<MTex *>(
|
|
MEM_dupallocN(partticle_settings_src->mtex[a]));
|
|
}
|
|
}
|
|
|
|
BLI_duplicatelist(&particle_settings_dst->instance_weights,
|
|
&partticle_settings_src->instance_weights);
|
|
}
|
|
|
|
static void particle_settings_free_data(ID *id)
|
|
{
|
|
ParticleSettings *particle_settings = (ParticleSettings *)id;
|
|
|
|
for (int a = 0; a < MAX_MTEX; a++) {
|
|
MEM_SAFE_FREE(particle_settings->mtex[a]);
|
|
}
|
|
|
|
if (particle_settings->clumpcurve) {
|
|
BKE_curvemapping_free(particle_settings->clumpcurve);
|
|
}
|
|
if (particle_settings->roughcurve) {
|
|
BKE_curvemapping_free(particle_settings->roughcurve);
|
|
}
|
|
if (particle_settings->twistcurve) {
|
|
BKE_curvemapping_free(particle_settings->twistcurve);
|
|
}
|
|
|
|
BKE_partdeflect_free(particle_settings->pd);
|
|
BKE_partdeflect_free(particle_settings->pd2);
|
|
|
|
MEM_SAFE_FREE(particle_settings->effector_weights);
|
|
|
|
BLI_freelistN(&particle_settings->instance_weights);
|
|
|
|
boid_free_settings(particle_settings->boids);
|
|
fluid_free_settings(particle_settings->fluid);
|
|
}
|
|
|
|
static void particle_settings_foreach_id(ID *id, LibraryForeachIDData *data)
|
|
{
|
|
ParticleSettings *psett = reinterpret_cast<ParticleSettings *>(id);
|
|
const int flag = BKE_lib_query_foreachid_process_flags_get(data);
|
|
|
|
BKE_LIB_FOREACHID_PROCESS_IDSUPER(data, psett->instance_collection, IDWALK_CB_USER);
|
|
BKE_LIB_FOREACHID_PROCESS_IDSUPER(data, psett->instance_object, IDWALK_CB_NOP);
|
|
BKE_LIB_FOREACHID_PROCESS_IDSUPER(data, psett->bb_ob, IDWALK_CB_NOP);
|
|
BKE_LIB_FOREACHID_PROCESS_IDSUPER(data, psett->collision_group, IDWALK_CB_NOP);
|
|
|
|
for (int i = 0; i < MAX_MTEX; i++) {
|
|
if (psett->mtex[i]) {
|
|
BKE_LIB_FOREACHID_PROCESS_FUNCTION_CALL(data,
|
|
BKE_texture_mtex_foreach_id(data, psett->mtex[i]));
|
|
}
|
|
}
|
|
|
|
if (psett->effector_weights) {
|
|
BKE_LIB_FOREACHID_PROCESS_IDSUPER(data, psett->effector_weights->group, IDWALK_CB_USER);
|
|
}
|
|
|
|
if (psett->pd) {
|
|
BKE_LIB_FOREACHID_PROCESS_IDSUPER(data, psett->pd->tex, IDWALK_CB_USER);
|
|
BKE_LIB_FOREACHID_PROCESS_IDSUPER(data, psett->pd->f_source, IDWALK_CB_NOP);
|
|
}
|
|
if (psett->pd2) {
|
|
BKE_LIB_FOREACHID_PROCESS_IDSUPER(data, psett->pd2->tex, IDWALK_CB_USER);
|
|
BKE_LIB_FOREACHID_PROCESS_IDSUPER(data, psett->pd2->f_source, IDWALK_CB_NOP);
|
|
}
|
|
|
|
if (psett->boids) {
|
|
LISTBASE_FOREACH (BoidState *, state, &psett->boids->states) {
|
|
LISTBASE_FOREACH (BoidRule *, rule, &state->rules) {
|
|
if (ELEM(rule->type, eBoidRuleType_Avoid, eBoidRuleType_Goal)) {
|
|
BoidRuleGoalAvoid *gabr = (BoidRuleGoalAvoid *)rule;
|
|
BKE_LIB_FOREACHID_PROCESS_IDSUPER(data, gabr->ob, IDWALK_CB_NOP);
|
|
}
|
|
else if (rule->type == eBoidRuleType_FollowLeader) {
|
|
BoidRuleFollowLeader *flbr = (BoidRuleFollowLeader *)rule;
|
|
BKE_LIB_FOREACHID_PROCESS_IDSUPER(data, flbr->ob, IDWALK_CB_NOP);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
LISTBASE_FOREACH (ParticleDupliWeight *, dw, &psett->instance_weights) {
|
|
BKE_LIB_FOREACHID_PROCESS_IDSUPER(data, dw->ob, IDWALK_CB_NOP);
|
|
}
|
|
|
|
if (flag & IDWALK_DO_DEPRECATED_POINTERS) {
|
|
BKE_LIB_FOREACHID_PROCESS_IDSUPER(data, psett->force_group, IDWALK_CB_NOP);
|
|
}
|
|
}
|
|
|
|
static void write_boid_state(BlendWriter *writer, BoidState *state)
|
|
{
|
|
BLO_write_struct(writer, BoidState, state);
|
|
|
|
LISTBASE_FOREACH (BoidRule *, rule, &state->rules) {
|
|
switch (rule->type) {
|
|
case eBoidRuleType_Goal:
|
|
case eBoidRuleType_Avoid:
|
|
BLO_write_struct(writer, BoidRuleGoalAvoid, rule);
|
|
break;
|
|
case eBoidRuleType_AvoidCollision:
|
|
BLO_write_struct(writer, BoidRuleAvoidCollision, rule);
|
|
break;
|
|
case eBoidRuleType_FollowLeader:
|
|
BLO_write_struct(writer, BoidRuleFollowLeader, rule);
|
|
break;
|
|
case eBoidRuleType_AverageSpeed:
|
|
BLO_write_struct(writer, BoidRuleAverageSpeed, rule);
|
|
break;
|
|
case eBoidRuleType_Fight:
|
|
BLO_write_struct(writer, BoidRuleFight, rule);
|
|
break;
|
|
default:
|
|
BLO_write_struct(writer, BoidRule, rule);
|
|
break;
|
|
}
|
|
}
|
|
#if 0
|
|
BoidCondition *cond = state->conditions.first;
|
|
for (; cond; cond = cond->next) {
|
|
BLO_write_struct(writer, BoidCondition, cond);
|
|
}
|
|
#endif
|
|
}
|
|
|
|
static void particle_settings_blend_write(BlendWriter *writer, ID *id, const void *id_address)
|
|
{
|
|
ParticleSettings *part = (ParticleSettings *)id;
|
|
|
|
/* write LibData */
|
|
BLO_write_id_struct(writer, ParticleSettings, id_address, &part->id);
|
|
BKE_id_blend_write(writer, &part->id);
|
|
|
|
BLO_write_struct(writer, PartDeflect, part->pd);
|
|
BLO_write_struct(writer, PartDeflect, part->pd2);
|
|
BLO_write_struct(writer, EffectorWeights, part->effector_weights);
|
|
|
|
if (part->clumpcurve) {
|
|
BKE_curvemapping_blend_write(writer, part->clumpcurve);
|
|
}
|
|
if (part->roughcurve) {
|
|
BKE_curvemapping_blend_write(writer, part->roughcurve);
|
|
}
|
|
if (part->twistcurve) {
|
|
BKE_curvemapping_blend_write(writer, part->twistcurve);
|
|
}
|
|
|
|
LISTBASE_FOREACH (ParticleDupliWeight *, dw, &part->instance_weights) {
|
|
/* update indices, but only if dw->ob is set (can be nullptr after loading e.g.) */
|
|
if (dw->ob != nullptr) {
|
|
dw->index = 0;
|
|
if (part->instance_collection) { /* can be nullptr if lining fails or set to None */
|
|
FOREACH_COLLECTION_OBJECT_RECURSIVE_BEGIN (part->instance_collection, object) {
|
|
if (object == dw->ob) {
|
|
break;
|
|
}
|
|
dw->index++;
|
|
}
|
|
FOREACH_COLLECTION_OBJECT_RECURSIVE_END;
|
|
}
|
|
}
|
|
BLO_write_struct(writer, ParticleDupliWeight, dw);
|
|
}
|
|
|
|
if (part->boids && part->phystype == PART_PHYS_BOIDS) {
|
|
BLO_write_struct(writer, BoidSettings, part->boids);
|
|
|
|
LISTBASE_FOREACH (BoidState *, state, &part->boids->states) {
|
|
write_boid_state(writer, state);
|
|
}
|
|
}
|
|
if (part->fluid && part->phystype == PART_PHYS_FLUID) {
|
|
BLO_write_struct(writer, SPHFluidSettings, part->fluid);
|
|
}
|
|
|
|
for (int a = 0; a < MAX_MTEX; a++) {
|
|
if (part->mtex[a]) {
|
|
BLO_write_struct(writer, MTex, part->mtex[a]);
|
|
}
|
|
}
|
|
}
|
|
|
|
void BKE_particle_partdeflect_blend_read_data(BlendDataReader * /*reader*/, PartDeflect * /*pd*/)
|
|
{
|
|
}
|
|
|
|
static void particle_settings_blend_read_data(BlendDataReader *reader, ID *id)
|
|
{
|
|
ParticleSettings *part = (ParticleSettings *)id;
|
|
|
|
BLO_read_struct(reader, PartDeflect, &part->pd);
|
|
BLO_read_struct(reader, PartDeflect, &part->pd2);
|
|
BKE_particle_partdeflect_blend_read_data(reader, part->pd);
|
|
BKE_particle_partdeflect_blend_read_data(reader, part->pd2);
|
|
|
|
BLO_read_struct(reader, CurveMapping, &part->clumpcurve);
|
|
if (part->clumpcurve) {
|
|
BKE_curvemapping_blend_read(reader, part->clumpcurve);
|
|
}
|
|
BLO_read_struct(reader, CurveMapping, &part->roughcurve);
|
|
if (part->roughcurve) {
|
|
BKE_curvemapping_blend_read(reader, part->roughcurve);
|
|
}
|
|
BLO_read_struct(reader, CurveMapping, &part->twistcurve);
|
|
if (part->twistcurve) {
|
|
BKE_curvemapping_blend_read(reader, part->twistcurve);
|
|
}
|
|
|
|
BLO_read_struct(reader, EffectorWeights, &part->effector_weights);
|
|
if (!part->effector_weights) {
|
|
part->effector_weights = BKE_effector_add_weights(part->force_group);
|
|
}
|
|
|
|
BLO_read_struct_list(reader, ParticleDupliWeight, &part->instance_weights);
|
|
|
|
BLO_read_struct(reader, BoidSettings, &part->boids);
|
|
BLO_read_struct(reader, SPHFluidSettings, &part->fluid);
|
|
|
|
if (part->boids) {
|
|
BLO_read_struct_list(reader, BoidState, &part->boids->states);
|
|
|
|
LISTBASE_FOREACH (BoidState *, state, &part->boids->states) {
|
|
BLO_read_struct_list(reader, BoidRule, &state->rules);
|
|
#if 0
|
|
/* Not implemented yet. */
|
|
BLO_read_struct_list(reader, BoidCondition, &state->conditions);
|
|
BLO_read_struct_list(reader, BoidAction, &state->actions);
|
|
#endif
|
|
}
|
|
}
|
|
for (int a = 0; a < MAX_MTEX; a++) {
|
|
BLO_read_struct(reader, MTex, &part->mtex[a]);
|
|
}
|
|
|
|
/* Protect against integer overflow vulnerability. */
|
|
CLAMP(part->trail_count, 1, 100000);
|
|
}
|
|
|
|
static void particle_settings_blend_read_after_liblink(BlendLibReader * /*reader*/, ID *id)
|
|
{
|
|
ParticleSettings *part = reinterpret_cast<ParticleSettings *>(id);
|
|
|
|
if (part->instance_weights.first && !part->instance_collection) {
|
|
BLI_freelistN(&part->instance_weights);
|
|
}
|
|
}
|
|
|
|
IDTypeInfo IDType_ID_PA = {
|
|
/*id_code*/ ID_PA,
|
|
/*id_filter*/ FILTER_ID_PA,
|
|
/*dependencies_id_types*/ FILTER_ID_OB | FILTER_ID_GR | FILTER_ID_TE,
|
|
/*main_listbase_index*/ INDEX_ID_PA,
|
|
/*struct_size*/ sizeof(ParticleSettings),
|
|
/*name*/ "ParticleSettings",
|
|
/*name_plural*/ N_("particles"),
|
|
/*translation_context*/ BLT_I18NCONTEXT_ID_PARTICLESETTINGS,
|
|
/*flags*/ 0,
|
|
/*asset_type_info*/ nullptr,
|
|
|
|
/*init_data*/ particle_settings_init,
|
|
/*copy_data*/ particle_settings_copy_data,
|
|
/*free_data*/ particle_settings_free_data,
|
|
/*make_local*/ nullptr,
|
|
/*foreach_id*/ particle_settings_foreach_id,
|
|
/*foreach_cache*/ nullptr,
|
|
/*foreach_path*/ nullptr,
|
|
/*owner_pointer_get*/ nullptr,
|
|
|
|
/*blend_write*/ particle_settings_blend_write,
|
|
/*blend_read_data*/ particle_settings_blend_read_data,
|
|
/*blend_read_after_liblink*/ particle_settings_blend_read_after_liblink,
|
|
|
|
/*blend_read_undo_preserve*/ nullptr,
|
|
|
|
/*lib_override_apply_post*/ nullptr,
|
|
};
|
|
|
|
uint PSYS_FRAND_SEED_OFFSET[PSYS_FRAND_COUNT];
|
|
uint PSYS_FRAND_SEED_MULTIPLIER[PSYS_FRAND_COUNT];
|
|
float PSYS_FRAND_BASE[PSYS_FRAND_COUNT];
|
|
|
|
void BKE_particle_init_rng()
|
|
{
|
|
RNG *rng = BLI_rng_new_srandom(5831); /* arbitrary */
|
|
for (int i = 0; i < PSYS_FRAND_COUNT; i++) {
|
|
PSYS_FRAND_BASE[i] = BLI_rng_get_float(rng);
|
|
PSYS_FRAND_SEED_OFFSET[i] = uint(BLI_rng_get_int(rng));
|
|
PSYS_FRAND_SEED_MULTIPLIER[i] = uint(BLI_rng_get_int(rng));
|
|
}
|
|
BLI_rng_free(rng);
|
|
}
|
|
|
|
static void get_child_modifier_parameters(ParticleSettings *part,
|
|
ParticleThreadContext *ctx,
|
|
ChildParticle *cpa,
|
|
short cpa_from,
|
|
int cpa_num,
|
|
float *cpa_fuv,
|
|
float *orco,
|
|
ParticleTexture *ptex);
|
|
static void get_cpa_texture(Mesh *mesh,
|
|
ParticleSystem *psys,
|
|
ParticleSettings *part,
|
|
ParticleData *par,
|
|
int child_index,
|
|
int face_index,
|
|
const float fw[4],
|
|
float *orco,
|
|
ParticleTexture *ptex,
|
|
int event,
|
|
float cfra);
|
|
|
|
int count_particles(ParticleSystem *psys)
|
|
{
|
|
ParticleSettings *part = psys->part;
|
|
PARTICLE_P;
|
|
int tot = 0;
|
|
|
|
LOOP_SHOWN_PARTICLES
|
|
{
|
|
if (pa->alive == PARS_UNBORN && (part->flag & PART_UNBORN) == 0) {
|
|
}
|
|
else if (pa->alive == PARS_DEAD && (part->flag & PART_DIED) == 0) {
|
|
}
|
|
else {
|
|
tot++;
|
|
}
|
|
}
|
|
return tot;
|
|
}
|
|
int count_particles_mod(ParticleSystem *psys, int totgr, int cur)
|
|
{
|
|
ParticleSettings *part = psys->part;
|
|
PARTICLE_P;
|
|
int tot = 0;
|
|
|
|
LOOP_SHOWN_PARTICLES
|
|
{
|
|
if (pa->alive == PARS_UNBORN && (part->flag & PART_UNBORN) == 0) {
|
|
}
|
|
else if (pa->alive == PARS_DEAD && (part->flag & PART_DIED) == 0) {
|
|
}
|
|
else if (p % totgr == cur) {
|
|
tot++;
|
|
}
|
|
}
|
|
return tot;
|
|
}
|
|
/* We allocate path cache memory in chunks instead of a big contiguous
|
|
* chunk, windows' memory allocator fails to find big blocks of memory often. */
|
|
|
|
#define PATH_CACHE_BUF_SIZE 1024
|
|
|
|
static ParticleCacheKey *pcache_key_segment_endpoint_safe(ParticleCacheKey *key)
|
|
{
|
|
return (key->segments > 0) ? (key + (key->segments - 1)) : key;
|
|
}
|
|
|
|
static ParticleCacheKey **psys_alloc_path_cache_buffers(ListBase *bufs, int tot, int totkeys)
|
|
{
|
|
LinkData *buf;
|
|
ParticleCacheKey **cache;
|
|
int i, totkey, totbufkey;
|
|
|
|
tot = std::max(tot, 1);
|
|
totkey = 0;
|
|
cache = MEM_calloc_arrayN<ParticleCacheKey *>(size_t(tot), "PathCacheArray");
|
|
|
|
while (totkey < tot) {
|
|
totbufkey = std::min(tot - totkey, PATH_CACHE_BUF_SIZE);
|
|
buf = MEM_callocN<LinkData>("PathCacheLinkData");
|
|
buf->data = MEM_calloc_arrayN<ParticleCacheKey>(size_t(totbufkey) * size_t(totkeys),
|
|
"ParticleCacheKey");
|
|
|
|
for (i = 0; i < totbufkey; i++) {
|
|
cache[totkey + i] = ((ParticleCacheKey *)buf->data) + i * totkeys;
|
|
}
|
|
|
|
totkey += totbufkey;
|
|
BLI_addtail(bufs, buf);
|
|
}
|
|
|
|
return cache;
|
|
}
|
|
|
|
static void psys_free_path_cache_buffers(ParticleCacheKey **cache, ListBase *bufs)
|
|
{
|
|
if (cache) {
|
|
MEM_freeN(cache);
|
|
}
|
|
|
|
LISTBASE_FOREACH (LinkData *, buf, bufs) {
|
|
MEM_freeN(buf->data);
|
|
}
|
|
BLI_freelistN(bufs);
|
|
}
|
|
|
|
/************************************************/
|
|
/* Getting stuff */
|
|
/************************************************/
|
|
|
|
ParticleSystem *psys_get_current(Object *ob)
|
|
{
|
|
if (ob == nullptr) {
|
|
return nullptr;
|
|
}
|
|
|
|
LISTBASE_FOREACH (ParticleSystem *, psys, &ob->particlesystem) {
|
|
if (psys->flag & PSYS_CURRENT) {
|
|
return psys;
|
|
}
|
|
}
|
|
|
|
return nullptr;
|
|
}
|
|
short psys_get_current_num(Object *ob)
|
|
{
|
|
ParticleSystem *psys;
|
|
short i;
|
|
|
|
if (ob == nullptr) {
|
|
return 0;
|
|
}
|
|
|
|
for (psys = static_cast<ParticleSystem *>(ob->particlesystem.first), i = 0; psys;
|
|
psys = psys->next, i++)
|
|
{
|
|
if (psys->flag & PSYS_CURRENT) {
|
|
return i;
|
|
}
|
|
}
|
|
|
|
return i;
|
|
}
|
|
void psys_set_current_num(Object *ob, int index)
|
|
{
|
|
ParticleSystem *psys;
|
|
short i;
|
|
|
|
if (ob == nullptr) {
|
|
return;
|
|
}
|
|
|
|
for (psys = static_cast<ParticleSystem *>(ob->particlesystem.first), i = 0; psys;
|
|
psys = psys->next, i++)
|
|
{
|
|
if (i == index) {
|
|
psys->flag |= PSYS_CURRENT;
|
|
}
|
|
else {
|
|
psys->flag &= ~PSYS_CURRENT;
|
|
}
|
|
}
|
|
}
|
|
|
|
void psys_sim_data_init(ParticleSimulationData *sim)
|
|
{
|
|
ParticleSystem *psys = sim->psys;
|
|
ParticleSettings *part = psys->part;
|
|
|
|
/* Prepare lattice deform. */
|
|
psys->lattice_deform_data = nullptr;
|
|
if (psys_in_edit_mode(sim->depsgraph, sim->psys) == 0) {
|
|
Object *lattice = nullptr;
|
|
ModifierData *md = (ModifierData *)psys_get_modifier(sim->ob, sim->psys);
|
|
bool for_render = DEG_get_mode(sim->depsgraph) == DAG_EVAL_RENDER;
|
|
int mode = for_render ? eModifierMode_Render : eModifierMode_Realtime;
|
|
|
|
for (; md; md = md->next) {
|
|
if (md->type == eModifierType_Lattice) {
|
|
if (md->mode & mode) {
|
|
LatticeModifierData *lmd = (LatticeModifierData *)md;
|
|
lattice = lmd->object;
|
|
psys->lattice_strength = lmd->strength;
|
|
}
|
|
|
|
break;
|
|
}
|
|
}
|
|
if (lattice) {
|
|
psys->lattice_deform_data = BKE_lattice_deform_data_create(lattice, nullptr);
|
|
}
|
|
}
|
|
|
|
/* Prepare curvemapping tables. */
|
|
if ((part->child_flag & PART_CHILD_USE_CLUMP_CURVE) && part->clumpcurve) {
|
|
BKE_curvemapping_init(part->clumpcurve);
|
|
}
|
|
if ((part->child_flag & PART_CHILD_USE_ROUGH_CURVE) && part->roughcurve) {
|
|
BKE_curvemapping_init(part->roughcurve);
|
|
}
|
|
if ((part->child_flag & PART_CHILD_USE_TWIST_CURVE) && part->twistcurve) {
|
|
BKE_curvemapping_init(part->twistcurve);
|
|
}
|
|
}
|
|
|
|
void psys_sim_data_free(ParticleSimulationData *sim)
|
|
{
|
|
ParticleSystem *psys = sim->psys;
|
|
|
|
if (psys->lattice_deform_data) {
|
|
BKE_lattice_deform_data_destroy(psys->lattice_deform_data);
|
|
psys->lattice_deform_data = nullptr;
|
|
}
|
|
}
|
|
|
|
void psys_disable_all(Object *ob)
|
|
{
|
|
ParticleSystem *psys = static_cast<ParticleSystem *>(ob->particlesystem.first);
|
|
|
|
for (; psys; psys = psys->next) {
|
|
psys->flag |= PSYS_DISABLED;
|
|
}
|
|
}
|
|
void psys_enable_all(Object *ob)
|
|
{
|
|
ParticleSystem *psys = static_cast<ParticleSystem *>(ob->particlesystem.first);
|
|
|
|
for (; psys; psys = psys->next) {
|
|
psys->flag &= ~PSYS_DISABLED;
|
|
}
|
|
}
|
|
|
|
ParticleSystem *psys_orig_get(ParticleSystem *psys)
|
|
{
|
|
if (psys->orig_psys == nullptr) {
|
|
return psys;
|
|
}
|
|
return psys->orig_psys;
|
|
}
|
|
|
|
ParticleSystem *psys_eval_get(Depsgraph *depsgraph, Object *object, ParticleSystem *psys)
|
|
{
|
|
Object *object_eval = DEG_get_evaluated_object(depsgraph, object);
|
|
if (object_eval == object) {
|
|
return psys;
|
|
}
|
|
ParticleSystem *psys_eval = static_cast<ParticleSystem *>(object_eval->particlesystem.first);
|
|
while (psys_eval != nullptr) {
|
|
if (psys_eval->orig_psys == psys) {
|
|
return psys_eval;
|
|
}
|
|
psys_eval = psys_eval->next;
|
|
}
|
|
return psys_eval;
|
|
}
|
|
|
|
static PTCacheEdit *psys_orig_edit_get(ParticleSystem *psys)
|
|
{
|
|
if (psys->orig_psys == nullptr) {
|
|
return psys->edit;
|
|
}
|
|
return psys->orig_psys->edit;
|
|
}
|
|
|
|
bool psys_in_edit_mode(Depsgraph *depsgraph, const ParticleSystem *psys)
|
|
{
|
|
const Scene *scene = DEG_get_input_scene(depsgraph);
|
|
ViewLayer *view_layer = DEG_get_input_view_layer(depsgraph);
|
|
BKE_view_layer_synced_ensure(scene, view_layer);
|
|
const Object *object = BKE_view_layer_active_object_get(view_layer);
|
|
if (object == nullptr) {
|
|
/* TODO(sergey): Needs double-check with multi-object edit. */
|
|
return false;
|
|
}
|
|
const bool use_render_params = (DEG_get_mode(depsgraph) == DAG_EVAL_RENDER);
|
|
if (object->mode != OB_MODE_PARTICLE_EDIT) {
|
|
return false;
|
|
}
|
|
const ParticleSystem *psys_orig = psys_orig_get((ParticleSystem *)psys);
|
|
return (psys_orig->edit || psys->pointcache->edit) && (use_render_params == false);
|
|
}
|
|
|
|
bool psys_check_enabled(Object *ob, ParticleSystem *psys, const bool use_render_params)
|
|
{
|
|
ParticleSystemModifierData *psmd;
|
|
|
|
if (psys->flag & PSYS_DISABLED || psys->flag & PSYS_DELETE || !psys->part) {
|
|
return false;
|
|
}
|
|
|
|
psmd = psys_get_modifier(ob, psys);
|
|
|
|
if (!psmd) {
|
|
return false;
|
|
}
|
|
|
|
if (use_render_params) {
|
|
if (!(psmd->modifier.mode & eModifierMode_Render)) {
|
|
return false;
|
|
}
|
|
}
|
|
else if (!(psmd->modifier.mode & eModifierMode_Realtime)) {
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool psys_check_edited(ParticleSystem *psys)
|
|
{
|
|
if (psys->part && psys->part->type == PART_HAIR) {
|
|
return (psys->flag & PSYS_EDITED || (psys->edit && psys->edit->edited));
|
|
}
|
|
|
|
return (psys->pointcache->edit && psys->pointcache->edit->edited);
|
|
}
|
|
|
|
void psys_find_group_weights(ParticleSettings *part)
|
|
{
|
|
/* Find object pointers based on index. If the collection is linked from
|
|
* another library linking may not have the object pointers available on
|
|
* file load, so we have to retrieve them later. See #49273. */
|
|
ListBase instance_collection_objects = {nullptr, nullptr};
|
|
|
|
if (part->instance_collection) {
|
|
instance_collection_objects = BKE_collection_object_cache_get(part->instance_collection);
|
|
}
|
|
|
|
LISTBASE_FOREACH (ParticleDupliWeight *, dw, &part->instance_weights) {
|
|
if (dw->ob == nullptr) {
|
|
Base *base = static_cast<Base *>(BLI_findlink(&instance_collection_objects, dw->index));
|
|
if (base != nullptr) {
|
|
dw->ob = base->object;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void psys_check_group_weights(ParticleSettings *part)
|
|
{
|
|
ParticleDupliWeight *dw, *tdw;
|
|
|
|
if (part->ren_as != PART_DRAW_GR || !part->instance_collection) {
|
|
BLI_freelistN(&part->instance_weights);
|
|
return;
|
|
}
|
|
|
|
/* Find object pointers. */
|
|
psys_find_group_weights(part);
|
|
|
|
/* Remove nullptr objects, that were removed from the collection. */
|
|
dw = static_cast<ParticleDupliWeight *>(part->instance_weights.first);
|
|
while (dw) {
|
|
if (dw->ob == nullptr ||
|
|
!BKE_collection_has_object_recursive(part->instance_collection, dw->ob))
|
|
{
|
|
tdw = dw->next;
|
|
BLI_freelinkN(&part->instance_weights, dw);
|
|
dw = tdw;
|
|
}
|
|
else {
|
|
dw = dw->next;
|
|
}
|
|
}
|
|
|
|
/* Add new objects in the collection. */
|
|
int index = 0;
|
|
FOREACH_COLLECTION_OBJECT_RECURSIVE_BEGIN (part->instance_collection, object) {
|
|
dw = static_cast<ParticleDupliWeight *>(part->instance_weights.first);
|
|
while (dw && dw->ob != object) {
|
|
dw = dw->next;
|
|
}
|
|
|
|
if (!dw) {
|
|
dw = MEM_callocN<ParticleDupliWeight>("ParticleDupliWeight");
|
|
dw->ob = object;
|
|
dw->count = 1;
|
|
BLI_addtail(&part->instance_weights, dw);
|
|
}
|
|
|
|
dw->index = index++;
|
|
}
|
|
FOREACH_COLLECTION_OBJECT_RECURSIVE_END;
|
|
|
|
/* Ensure there is an element marked as current. */
|
|
int current = 0;
|
|
LISTBASE_FOREACH (ParticleDupliWeight *, dw, &part->instance_weights) {
|
|
if (dw->flag & PART_DUPLIW_CURRENT) {
|
|
current = 1;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (!current) {
|
|
dw = static_cast<ParticleDupliWeight *>(part->instance_weights.first);
|
|
if (dw) {
|
|
dw->flag |= PART_DUPLIW_CURRENT;
|
|
}
|
|
}
|
|
}
|
|
|
|
int psys_uses_gravity(ParticleSimulationData *sim)
|
|
{
|
|
return sim->scene->physics_settings.flag & PHYS_GLOBAL_GRAVITY && sim->psys->part &&
|
|
sim->psys->part->effector_weights->global_gravity != 0.0f;
|
|
}
|
|
|
|
/************************************************/
|
|
/* Freeing stuff */
|
|
/************************************************/
|
|
|
|
static void fluid_free_settings(SPHFluidSettings *fluid)
|
|
{
|
|
if (fluid) {
|
|
MEM_freeN(fluid);
|
|
}
|
|
}
|
|
|
|
void free_hair(Object *object, ParticleSystem *psys, int dynamics)
|
|
{
|
|
PARTICLE_P;
|
|
|
|
LOOP_PARTICLES
|
|
{
|
|
MEM_SAFE_FREE(pa->hair);
|
|
pa->totkey = 0;
|
|
}
|
|
|
|
psys->flag &= ~PSYS_HAIR_DONE;
|
|
|
|
if (psys->clmd) {
|
|
if (dynamics) {
|
|
BKE_modifier_free((ModifierData *)psys->clmd);
|
|
psys->clmd = nullptr;
|
|
PTCacheID pid;
|
|
BKE_ptcache_id_from_particles(&pid, object, psys);
|
|
BKE_ptcache_id_clear(&pid, PTCACHE_CLEAR_ALL, 0);
|
|
}
|
|
else {
|
|
cloth_free_modifier(psys->clmd);
|
|
}
|
|
}
|
|
|
|
if (psys->hair_in_mesh) {
|
|
BKE_id_free(nullptr, psys->hair_in_mesh);
|
|
}
|
|
psys->hair_in_mesh = nullptr;
|
|
|
|
if (psys->hair_out_mesh) {
|
|
BKE_id_free(nullptr, psys->hair_out_mesh);
|
|
}
|
|
psys->hair_out_mesh = nullptr;
|
|
}
|
|
void free_keyed_keys(ParticleSystem *psys)
|
|
{
|
|
PARTICLE_P;
|
|
|
|
if (psys->part->type == PART_HAIR) {
|
|
return;
|
|
}
|
|
|
|
if (psys->particles && psys->particles->keys) {
|
|
MEM_freeN(psys->particles->keys);
|
|
|
|
LOOP_PARTICLES
|
|
{
|
|
if (pa->keys) {
|
|
pa->keys = nullptr;
|
|
pa->totkey = 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
static void free_child_path_cache(ParticleSystem *psys)
|
|
{
|
|
psys_free_path_cache_buffers(psys->childcache, &psys->childcachebufs);
|
|
psys->childcache = nullptr;
|
|
psys->totchildcache = 0;
|
|
}
|
|
void psys_free_path_cache(ParticleSystem *psys, PTCacheEdit *edit)
|
|
{
|
|
if (edit) {
|
|
psys_free_path_cache_buffers(edit->pathcache, &edit->pathcachebufs);
|
|
edit->pathcache = nullptr;
|
|
edit->totcached = 0;
|
|
}
|
|
if (psys) {
|
|
psys_free_path_cache_buffers(psys->pathcache, &psys->pathcachebufs);
|
|
psys->pathcache = nullptr;
|
|
psys->totcached = 0;
|
|
|
|
free_child_path_cache(psys);
|
|
}
|
|
}
|
|
void psys_free_children(ParticleSystem *psys)
|
|
{
|
|
if (psys->child) {
|
|
MEM_freeN(psys->child);
|
|
psys->child = nullptr;
|
|
psys->totchild = 0;
|
|
}
|
|
|
|
free_child_path_cache(psys);
|
|
}
|
|
void psys_free_particles(ParticleSystem *psys)
|
|
{
|
|
PARTICLE_P;
|
|
|
|
if (psys->particles) {
|
|
/* Even though psys->part should never be nullptr,
|
|
* this can happen as an exception during deletion.
|
|
* See ID_REMAP_SKIP/FORCE/FLAG_NEVER_NULL_USAGE in BKE_library_remap. */
|
|
if (psys->part && psys->part->type == PART_HAIR) {
|
|
LOOP_PARTICLES
|
|
{
|
|
if (pa->hair) {
|
|
MEM_freeN(pa->hair);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (psys->particles->keys) {
|
|
MEM_freeN(psys->particles->keys);
|
|
}
|
|
|
|
if (psys->particles->boid) {
|
|
MEM_freeN(psys->particles->boid);
|
|
}
|
|
|
|
MEM_freeN(psys->particles);
|
|
psys->particles = nullptr;
|
|
psys->totpart = 0;
|
|
}
|
|
}
|
|
void psys_free_pdd(ParticleSystem *psys)
|
|
{
|
|
if (psys->pdd) {
|
|
MEM_SAFE_FREE(psys->pdd->cdata);
|
|
|
|
MEM_SAFE_FREE(psys->pdd->vdata);
|
|
|
|
MEM_SAFE_FREE(psys->pdd->ndata);
|
|
|
|
MEM_SAFE_FREE(psys->pdd->vedata);
|
|
|
|
psys->pdd->totpoint = 0;
|
|
psys->pdd->totpart = 0;
|
|
psys->pdd->partsize = 0;
|
|
}
|
|
}
|
|
void psys_free(Object *ob, ParticleSystem *psys)
|
|
{
|
|
if (psys) {
|
|
int nr = 0;
|
|
|
|
psys_free_path_cache(psys, nullptr);
|
|
|
|
/* NOTE: We pass dynamics=0 to free_hair() to prevent it from doing an
|
|
* unneeded clear of the cache. But for historical reason that code path
|
|
* was only clearing cloth part of modifier data.
|
|
*
|
|
* Part of the story there is that particle evaluation is trying to not
|
|
* re-allocate thew ModifierData itself, and limits all allocations to
|
|
* the cloth part of it.
|
|
*
|
|
* Why evaluation is relying on hair_free() and in some specific code
|
|
* paths there is beyond me.
|
|
*/
|
|
free_hair(ob, psys, 0);
|
|
if (psys->clmd != nullptr) {
|
|
BKE_modifier_free((ModifierData *)psys->clmd);
|
|
}
|
|
|
|
psys_free_particles(psys);
|
|
|
|
if (psys->edit && psys->free_edit) {
|
|
psys->free_edit(psys->edit);
|
|
}
|
|
|
|
if (psys->child) {
|
|
MEM_freeN(psys->child);
|
|
psys->child = nullptr;
|
|
psys->totchild = 0;
|
|
}
|
|
|
|
/* check if we are last non-visible particle system */
|
|
LISTBASE_FOREACH (ParticleSystem *, tpsys, &ob->particlesystem) {
|
|
if (tpsys->part) {
|
|
if (ELEM(tpsys->part->ren_as, PART_DRAW_OB, PART_DRAW_GR)) {
|
|
nr++;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
/* clear do-not-draw-flag */
|
|
if (!nr) {
|
|
ob->transflag &= ~OB_DUPLIPARTS;
|
|
}
|
|
|
|
psys->part = nullptr;
|
|
|
|
if ((psys->flag & PSYS_SHARED_CACHES) == 0) {
|
|
BKE_ptcache_free_list(&psys->ptcaches);
|
|
}
|
|
psys->pointcache = nullptr;
|
|
|
|
BLI_freelistN(&psys->targets);
|
|
|
|
BLI_bvhtree_free(psys->bvhtree);
|
|
BLI_kdtree_3d_free(psys->tree);
|
|
|
|
if (psys->fluid_springs) {
|
|
MEM_freeN(psys->fluid_springs);
|
|
}
|
|
|
|
BKE_effectors_free(psys->effectors);
|
|
|
|
if (psys->pdd) {
|
|
psys_free_pdd(psys);
|
|
MEM_freeN(psys->pdd);
|
|
}
|
|
|
|
BKE_particle_batch_cache_free(psys);
|
|
|
|
MEM_freeN(psys);
|
|
}
|
|
}
|
|
|
|
void psys_copy_particles(ParticleSystem *psys_dst, ParticleSystem *psys_src)
|
|
{
|
|
/* Free existing particles. */
|
|
if (psys_dst->particles != psys_src->particles) {
|
|
psys_free_particles(psys_dst);
|
|
}
|
|
if (psys_dst->child != psys_src->child) {
|
|
psys_free_children(psys_dst);
|
|
}
|
|
/* Restore counters. */
|
|
psys_dst->totpart = psys_src->totpart;
|
|
psys_dst->totchild = psys_src->totchild;
|
|
/* Copy particles and children. */
|
|
psys_dst->particles = static_cast<ParticleData *>(MEM_dupallocN(psys_src->particles));
|
|
psys_dst->child = static_cast<ChildParticle *>(MEM_dupallocN(psys_src->child));
|
|
|
|
/* Ideally this should only be performed if `(psys_dst->part->type == PART_HAIR)`.
|
|
*
|
|
* But #ParticleData (`psys_dst`) is some sub-data of the #Object ID, while #ParticleSettings
|
|
* (`psys_dst->part`) is another ID. In case the particle settings is a linked ID that gets
|
|
* missing, it will be replaced (in readfile code) by a place-holder, which defaults to a
|
|
* `PART_EMITTER` type of particle settings.
|
|
*
|
|
* This leads to a situation where each particle of `psys_dst` still has a valid allocated `hair`
|
|
* data, which should still be preserved in case the missing particle settings ID becomes valid
|
|
* again.
|
|
*
|
|
* Furthermore, #free_hair() always frees `pa->hair` if it's not nullptr, regardless of the
|
|
* particle type. So *not* copying here would cause a double free (or more), e.g. freeing the
|
|
* copy-on-evaluation copy and the original data will crash Blender.
|
|
* In any case, sharing pointers between `psys_src` and `psys_dst` should be forbidden.
|
|
*
|
|
* So while we could in theory 'sanitize' the situation by setting `pa->hair` to nullptr in the
|
|
* new copy (in case of non-`PART_HAIR` type), it is probably safer for now to systematically
|
|
* duplicate the `hair` data if available. */
|
|
{
|
|
ParticleData *pa;
|
|
int p;
|
|
for (p = 0, pa = psys_dst->particles; p < psys_dst->totpart; p++, pa++) {
|
|
pa->hair = static_cast<HairKey *>(MEM_dupallocN(pa->hair));
|
|
}
|
|
}
|
|
if (psys_dst->particles && (psys_dst->particles->keys || psys_dst->particles->boid)) {
|
|
ParticleKey *key = psys_dst->particles->keys;
|
|
BoidParticle *boid = psys_dst->particles->boid;
|
|
ParticleData *pa;
|
|
int p;
|
|
if (key != nullptr) {
|
|
key = static_cast<ParticleKey *>(MEM_dupallocN(key));
|
|
}
|
|
if (boid != nullptr) {
|
|
boid = static_cast<BoidParticle *>(MEM_dupallocN(boid));
|
|
}
|
|
for (p = 0, pa = psys_dst->particles; p < psys_dst->totpart; p++, pa++) {
|
|
if (boid != nullptr) {
|
|
pa->boid = boid++;
|
|
}
|
|
if (key != nullptr) {
|
|
pa->keys = key;
|
|
key += pa->totkey;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/************************************************/
|
|
/* Interpolation */
|
|
/************************************************/
|
|
|
|
static float interpolate_particle_value(
|
|
float v1, float v2, float v3, float v4, const float w[4], int four)
|
|
{
|
|
float value;
|
|
|
|
value = w[0] * v1 + w[1] * v2 + w[2] * v3;
|
|
if (four) {
|
|
value += w[3] * v4;
|
|
}
|
|
|
|
CLAMP(value, 0.0f, 1.0f);
|
|
|
|
return value;
|
|
}
|
|
|
|
void psys_interpolate_particle(
|
|
short type, ParticleKey keys[4], float dt, ParticleKey *result, bool velocity)
|
|
{
|
|
float t[4];
|
|
|
|
if (type < 0) {
|
|
interp_cubic_v3(result->co, result->vel, keys[1].co, keys[1].vel, keys[2].co, keys[2].vel, dt);
|
|
}
|
|
else {
|
|
key_curve_position_weights(dt, t, type);
|
|
|
|
interp_v3_v3v3v3v3(result->co, keys[0].co, keys[1].co, keys[2].co, keys[3].co, t);
|
|
|
|
if (velocity) {
|
|
float temp[3];
|
|
|
|
if (dt > 0.999f) {
|
|
key_curve_position_weights(dt - 0.001f, t, type);
|
|
interp_v3_v3v3v3v3(temp, keys[0].co, keys[1].co, keys[2].co, keys[3].co, t);
|
|
sub_v3_v3v3(result->vel, result->co, temp);
|
|
}
|
|
else {
|
|
key_curve_position_weights(dt + 0.001f, t, type);
|
|
interp_v3_v3v3v3v3(temp, keys[0].co, keys[1].co, keys[2].co, keys[3].co, t);
|
|
sub_v3_v3v3(result->vel, temp, result->co);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
struct ParticleInterpolationData {
|
|
HairKey *hkey[2];
|
|
|
|
Mesh *mesh;
|
|
float3 *vert_positions[2];
|
|
|
|
int keyed;
|
|
ParticleKey *kkey[2];
|
|
|
|
PointCache *cache;
|
|
PTCacheMem *pm;
|
|
|
|
PTCacheEditPoint *epoint;
|
|
PTCacheEditKey *ekey[2];
|
|
|
|
float birthtime;
|
|
/** Die on this frame, see #ParticleData.dietime for details. */
|
|
float dietime;
|
|
int bspline;
|
|
};
|
|
/**
|
|
* Assumes pointcache->mem_cache exists, so for disk cached particles
|
|
* call #psys_make_temp_pointcache() before use.
|
|
* It uses #ParticleInterpolationData.pm to store the current memory cache frame
|
|
* so it's thread safe.
|
|
*/
|
|
static void get_pointcache_keys_for_time(Object * /*ob*/,
|
|
PointCache *cache,
|
|
PTCacheMem **cur,
|
|
int index,
|
|
float t,
|
|
ParticleKey *key1,
|
|
ParticleKey *key2)
|
|
{
|
|
static PTCacheMem *pm = nullptr;
|
|
int index1, index2;
|
|
|
|
if (index < 0) { /* initialize */
|
|
*cur = static_cast<PTCacheMem *>(cache->mem_cache.first);
|
|
|
|
if (*cur) {
|
|
*cur = (*cur)->next;
|
|
}
|
|
}
|
|
else {
|
|
if (*cur) {
|
|
while (*cur && (*cur)->next && float((*cur)->frame) < t) {
|
|
*cur = (*cur)->next;
|
|
}
|
|
|
|
pm = *cur;
|
|
|
|
index2 = BKE_ptcache_mem_index_find(pm, index);
|
|
index1 = BKE_ptcache_mem_index_find(pm->prev, index);
|
|
if (index2 < 0) {
|
|
return;
|
|
}
|
|
|
|
BKE_ptcache_make_particle_key(key2, index2, pm->data, float(pm->frame));
|
|
if (index1 < 0) {
|
|
copy_particle_key(key1, key2, 1);
|
|
}
|
|
else {
|
|
BKE_ptcache_make_particle_key(key1, index1, pm->prev->data, float(pm->prev->frame));
|
|
}
|
|
}
|
|
else if (cache->mem_cache.first) {
|
|
pm = static_cast<PTCacheMem *>(cache->mem_cache.first);
|
|
index2 = BKE_ptcache_mem_index_find(pm, index);
|
|
if (index2 < 0) {
|
|
return;
|
|
}
|
|
BKE_ptcache_make_particle_key(key2, index2, pm->data, float(pm->frame));
|
|
copy_particle_key(key1, key2, 1);
|
|
}
|
|
}
|
|
}
|
|
static int get_pointcache_times_for_particle(PointCache *cache,
|
|
int index,
|
|
float *r_start,
|
|
float *r_dietime)
|
|
{
|
|
int ret = 0;
|
|
|
|
LISTBASE_FOREACH (PTCacheMem *, pm, &cache->mem_cache) {
|
|
if (BKE_ptcache_mem_index_find(pm, index) >= 0) {
|
|
*r_start = pm->frame;
|
|
ret++;
|
|
break;
|
|
}
|
|
}
|
|
|
|
LISTBASE_FOREACH_BACKWARD (PTCacheMem *, pm, &cache->mem_cache) {
|
|
if (BKE_ptcache_mem_index_find(pm, index) >= 0) {
|
|
/* Die *after* the last available frame. */
|
|
*r_dietime = pm->frame + 1;
|
|
ret++;
|
|
break;
|
|
}
|
|
}
|
|
|
|
return ret == 2;
|
|
}
|
|
|
|
float psys_get_dietime_from_cache(PointCache *cache, int index)
|
|
{
|
|
int dietime = 10000000; /* some max value so that we can default to pa->time+lifetime */
|
|
|
|
LISTBASE_FOREACH_BACKWARD (PTCacheMem *, pm, &cache->mem_cache) {
|
|
if (BKE_ptcache_mem_index_find(pm, index) >= 0) {
|
|
/* Die *after* the last available frame. */
|
|
dietime = pm->frame + 1;
|
|
break;
|
|
}
|
|
}
|
|
|
|
return float(dietime);
|
|
}
|
|
|
|
static void init_particle_interpolation(Object *ob,
|
|
ParticleSystem *psys,
|
|
ParticleData *pa,
|
|
ParticleInterpolationData *pind)
|
|
{
|
|
|
|
if (pind->epoint) {
|
|
PTCacheEditPoint *point = pind->epoint;
|
|
|
|
pind->ekey[0] = point->keys;
|
|
pind->ekey[1] = point->totkey > 1 ? point->keys + 1 : nullptr;
|
|
|
|
pind->birthtime = *(point->keys->time);
|
|
pind->dietime = *((point->keys + point->totkey - 1)->time);
|
|
}
|
|
else if (pind->keyed) {
|
|
ParticleKey *key = pa->keys;
|
|
pind->kkey[0] = key;
|
|
pind->kkey[1] = pa->totkey > 1 ? key + 1 : nullptr;
|
|
|
|
pind->birthtime = key->time;
|
|
pind->dietime = (key + pa->totkey - 1)->time;
|
|
}
|
|
else if (pind->cache) {
|
|
float start = 0.0f, dietime = 0.0f;
|
|
get_pointcache_keys_for_time(ob, pind->cache, &pind->pm, -1, 0.0f, nullptr, nullptr);
|
|
pind->birthtime = pa ? pa->time : pind->cache->startframe;
|
|
pind->dietime = pa ? pa->dietime : (pind->cache->endframe + 1);
|
|
|
|
if (get_pointcache_times_for_particle(pind->cache, pa - psys->particles, &start, &dietime)) {
|
|
pind->birthtime = std::max(pind->birthtime, start);
|
|
pind->dietime = std::min(pind->dietime, dietime);
|
|
}
|
|
}
|
|
else {
|
|
HairKey *key = pa->hair;
|
|
pind->hkey[0] = key;
|
|
pind->hkey[1] = key + 1;
|
|
|
|
pind->birthtime = key->time;
|
|
pind->dietime = (key + pa->totkey - 1)->time;
|
|
|
|
if (pind->mesh) {
|
|
float3 *positions = pind->mesh->vert_positions_for_write().data();
|
|
pind->vert_positions[0] = &positions[pa->hair_index];
|
|
pind->vert_positions[1] = pind->vert_positions[0] + 1;
|
|
}
|
|
}
|
|
}
|
|
static void edit_to_particle(ParticleKey *key, PTCacheEditKey *ekey)
|
|
{
|
|
copy_v3_v3(key->co, ekey->co);
|
|
if (ekey->vel) {
|
|
copy_v3_v3(key->vel, ekey->vel);
|
|
}
|
|
key->time = *(ekey->time);
|
|
}
|
|
static void hair_to_particle(ParticleKey *key, HairKey *hkey)
|
|
{
|
|
copy_v3_v3(key->co, hkey->co);
|
|
key->time = hkey->time;
|
|
}
|
|
|
|
static void mvert_to_particle(ParticleKey *key, float3 *position, HairKey *hkey)
|
|
{
|
|
copy_v3_v3(key->co, *position);
|
|
key->time = hkey->time;
|
|
}
|
|
|
|
static void do_particle_interpolation(ParticleSystem *psys,
|
|
int p,
|
|
ParticleData *pa,
|
|
float t,
|
|
ParticleInterpolationData *pind,
|
|
ParticleKey *result)
|
|
{
|
|
PTCacheEditPoint *point = pind->epoint;
|
|
ParticleKey keys[4];
|
|
int point_vel = (point && point->keys->vel);
|
|
float real_t, dfra, keytime, invdt = 1.0f;
|
|
|
|
/* billboards won't fill in all of these, so start cleared */
|
|
memset(keys, 0, sizeof(keys));
|
|
|
|
/* interpret timing and find keys */
|
|
if (point) {
|
|
if (result->time < 0.0f) {
|
|
real_t = -result->time;
|
|
}
|
|
else {
|
|
real_t = *(pind->ekey[0]->time) +
|
|
t * (*(pind->ekey[0][point->totkey - 1].time) - *(pind->ekey[0]->time));
|
|
}
|
|
|
|
while (*(pind->ekey[1]->time) < real_t) {
|
|
pind->ekey[1]++;
|
|
}
|
|
|
|
pind->ekey[0] = pind->ekey[1] - 1;
|
|
}
|
|
else if (pind->keyed) {
|
|
/* we have only one key, so let's use that */
|
|
if (pind->kkey[1] == nullptr) {
|
|
copy_particle_key(result, pind->kkey[0], 1);
|
|
return;
|
|
}
|
|
|
|
if (result->time < 0.0f) {
|
|
real_t = -result->time;
|
|
}
|
|
else {
|
|
real_t = pind->kkey[0]->time +
|
|
t * (pind->kkey[0][pa->totkey - 1].time - pind->kkey[0]->time);
|
|
}
|
|
|
|
if (psys->part->phystype == PART_PHYS_KEYED && psys->flag & PSYS_KEYED_TIMING) {
|
|
ParticleTarget *pt = static_cast<ParticleTarget *>(psys->targets.first);
|
|
|
|
pt = pt->next;
|
|
|
|
while (pt && pa->time + pt->time < real_t) {
|
|
pt = pt->next;
|
|
}
|
|
|
|
if (pt) {
|
|
pt = pt->prev;
|
|
|
|
if (pa->time + pt->time + pt->duration > real_t) {
|
|
real_t = pa->time + pt->time;
|
|
}
|
|
}
|
|
else {
|
|
real_t = pa->time + ((ParticleTarget *)psys->targets.last)->time;
|
|
}
|
|
}
|
|
|
|
CLAMP(real_t, pa->time, pa->dietime);
|
|
|
|
while (pind->kkey[1]->time < real_t) {
|
|
pind->kkey[1]++;
|
|
}
|
|
|
|
pind->kkey[0] = pind->kkey[1] - 1;
|
|
}
|
|
else if (pind->cache) {
|
|
if (result->time < 0.0f) { /* flag for time in frames */
|
|
real_t = -result->time;
|
|
}
|
|
else {
|
|
real_t = pa->time + t * (pa->dietime - pa->time);
|
|
}
|
|
}
|
|
else {
|
|
if (result->time < 0.0f) {
|
|
real_t = -result->time;
|
|
}
|
|
else {
|
|
real_t = pind->hkey[0]->time +
|
|
t * (pind->hkey[0][pa->totkey - 1].time - pind->hkey[0]->time);
|
|
}
|
|
|
|
while (pind->hkey[1]->time < real_t) {
|
|
pind->hkey[1]++;
|
|
if (pind->mesh) {
|
|
pind->vert_positions[1]++;
|
|
}
|
|
}
|
|
|
|
pind->hkey[0] = pind->hkey[1] - 1;
|
|
}
|
|
|
|
/* set actual interpolation keys */
|
|
if (point) {
|
|
edit_to_particle(keys + 1, pind->ekey[0]);
|
|
edit_to_particle(keys + 2, pind->ekey[1]);
|
|
}
|
|
else if (pind->mesh) {
|
|
pind->vert_positions[0] = pind->vert_positions[1] - 1;
|
|
mvert_to_particle(keys + 1, pind->vert_positions[0], pind->hkey[0]);
|
|
mvert_to_particle(keys + 2, pind->vert_positions[1], pind->hkey[1]);
|
|
}
|
|
else if (pind->keyed) {
|
|
memcpy(keys + 1, pind->kkey[0], sizeof(ParticleKey));
|
|
memcpy(keys + 2, pind->kkey[1], sizeof(ParticleKey));
|
|
}
|
|
else if (pind->cache) {
|
|
get_pointcache_keys_for_time(nullptr, pind->cache, &pind->pm, p, real_t, keys + 1, keys + 2);
|
|
}
|
|
else {
|
|
hair_to_particle(keys + 1, pind->hkey[0]);
|
|
hair_to_particle(keys + 2, pind->hkey[1]);
|
|
}
|
|
|
|
/* set secondary interpolation keys for hair */
|
|
if (!pind->keyed && !pind->cache && !point_vel) {
|
|
if (point) {
|
|
if (pind->ekey[0] != point->keys) {
|
|
edit_to_particle(keys, pind->ekey[0] - 1);
|
|
}
|
|
else {
|
|
edit_to_particle(keys, pind->ekey[0]);
|
|
}
|
|
}
|
|
else if (pind->mesh) {
|
|
if (pind->hkey[0] != pa->hair) {
|
|
mvert_to_particle(keys, pind->vert_positions[0] - 1, pind->hkey[0] - 1);
|
|
}
|
|
else {
|
|
mvert_to_particle(keys, pind->vert_positions[0], pind->hkey[0]);
|
|
}
|
|
}
|
|
else {
|
|
if (pind->hkey[0] != pa->hair) {
|
|
hair_to_particle(keys, pind->hkey[0] - 1);
|
|
}
|
|
else {
|
|
hair_to_particle(keys, pind->hkey[0]);
|
|
}
|
|
}
|
|
|
|
if (point) {
|
|
if (pind->ekey[1] != point->keys + point->totkey - 1) {
|
|
edit_to_particle(keys + 3, pind->ekey[1] + 1);
|
|
}
|
|
else {
|
|
edit_to_particle(keys + 3, pind->ekey[1]);
|
|
}
|
|
}
|
|
else if (pind->mesh) {
|
|
if (pind->hkey[1] != pa->hair + pa->totkey - 1) {
|
|
mvert_to_particle(keys + 3, pind->vert_positions[1] + 1, pind->hkey[1] + 1);
|
|
}
|
|
else {
|
|
mvert_to_particle(keys + 3, pind->vert_positions[1], pind->hkey[1]);
|
|
}
|
|
}
|
|
else {
|
|
if (pind->hkey[1] != pa->hair + pa->totkey - 1) {
|
|
hair_to_particle(keys + 3, pind->hkey[1] + 1);
|
|
}
|
|
else {
|
|
hair_to_particle(keys + 3, pind->hkey[1]);
|
|
}
|
|
}
|
|
}
|
|
|
|
dfra = keys[2].time - keys[1].time;
|
|
keytime = (real_t - keys[1].time) / dfra;
|
|
|
|
/* Convert velocity to time-step size. */
|
|
if (pind->keyed || pind->cache || point_vel) {
|
|
invdt = dfra * 0.04f * (psys ? psys->part->timetweak : 1.0f);
|
|
mul_v3_fl(keys[1].vel, invdt);
|
|
mul_v3_fl(keys[2].vel, invdt);
|
|
interp_qt_qtqt(result->rot, keys[1].rot, keys[2].rot, keytime);
|
|
}
|
|
|
|
/* Now we should have in chronological order k1<=k2<=t<=k3<=k4 with key-time between
|
|
* [0, 1]->[k2, k3] (k1 & k4 used for cardinal & b-spline interpolation). */
|
|
psys_interpolate_particle((pind->keyed || pind->cache || point_vel) ?
|
|
-1 /* signal for cubic interpolation */
|
|
:
|
|
(pind->bspline ? KEY_BSPLINE : KEY_CARDINAL),
|
|
keys,
|
|
keytime,
|
|
result,
|
|
true);
|
|
|
|
/* the velocity needs to be converted back from cubic interpolation */
|
|
if (pind->keyed || pind->cache || point_vel) {
|
|
mul_v3_fl(result->vel, 1.0f / invdt);
|
|
}
|
|
}
|
|
|
|
static void interpolate_pathcache(ParticleCacheKey *first, float t, ParticleCacheKey *result)
|
|
{
|
|
int i = 0;
|
|
ParticleCacheKey *cur = first;
|
|
|
|
/* scale the requested time to fit the entire path even if the path is cut early */
|
|
t *= (first + first->segments)->time;
|
|
|
|
while (i < first->segments && cur->time < t) {
|
|
cur++;
|
|
}
|
|
|
|
if (cur->time == t) {
|
|
*result = *cur;
|
|
}
|
|
else {
|
|
float dt = (t - (cur - 1)->time) / (cur->time - (cur - 1)->time);
|
|
interp_v3_v3v3(result->co, (cur - 1)->co, cur->co, dt);
|
|
interp_v3_v3v3(result->vel, (cur - 1)->vel, cur->vel, dt);
|
|
interp_qt_qtqt(result->rot, (cur - 1)->rot, cur->rot, dt);
|
|
result->time = t;
|
|
}
|
|
|
|
/* first is actual base rotation, others are incremental from first */
|
|
if (cur == first || cur - 1 == first) {
|
|
copy_qt_qt(result->rot, first->rot);
|
|
}
|
|
else {
|
|
mul_qt_qtqt(result->rot, first->rot, result->rot);
|
|
}
|
|
}
|
|
|
|
/************************************************/
|
|
/* Particles on a dm */
|
|
/************************************************/
|
|
|
|
void psys_interpolate_face(Mesh *mesh,
|
|
const float (*vert_positions)[3],
|
|
const float (*vert_normals)[3],
|
|
const MFace *mface,
|
|
MTFace *tface,
|
|
const float (*orcodata)[3],
|
|
float w[4],
|
|
float vec[3],
|
|
float nor[3],
|
|
float utan[3],
|
|
float vtan[3],
|
|
float orco[3])
|
|
{
|
|
const float *v1 = nullptr, *v2 = nullptr, *v3 = nullptr, *v4 = nullptr;
|
|
float e1[3], e2[3], s1, s2, t1, t2;
|
|
float *uv1, *uv2, *uv3, *uv4;
|
|
float n1[3], n2[3], n3[3], n4[3];
|
|
float tuv[4][2];
|
|
const float *o1, *o2, *o3, *o4;
|
|
|
|
v1 = vert_positions[mface->v1];
|
|
v2 = vert_positions[mface->v2];
|
|
v3 = vert_positions[mface->v3];
|
|
|
|
copy_v3_v3(n1, vert_normals[mface->v1]);
|
|
copy_v3_v3(n2, vert_normals[mface->v2]);
|
|
copy_v3_v3(n3, vert_normals[mface->v3]);
|
|
|
|
if (mface->v4) {
|
|
v4 = vert_positions[mface->v4];
|
|
copy_v3_v3(n4, vert_normals[mface->v4]);
|
|
|
|
interp_v3_v3v3v3v3(vec, v1, v2, v3, v4, w);
|
|
|
|
if (nor) {
|
|
if (mface->flag & ME_SMOOTH) {
|
|
interp_v3_v3v3v3v3(nor, n1, n2, n3, n4, w);
|
|
}
|
|
else {
|
|
normal_quad_v3(nor, v1, v2, v3, v4);
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
interp_v3_v3v3v3(vec, v1, v2, v3, w);
|
|
|
|
if (nor) {
|
|
if (mface->flag & ME_SMOOTH) {
|
|
interp_v3_v3v3v3(nor, n1, n2, n3, w);
|
|
}
|
|
else {
|
|
normal_tri_v3(nor, v1, v2, v3);
|
|
}
|
|
}
|
|
}
|
|
|
|
/* calculate tangent vectors */
|
|
if (utan && vtan) {
|
|
if (tface) {
|
|
uv1 = tface->uv[0];
|
|
uv2 = tface->uv[1];
|
|
uv3 = tface->uv[2];
|
|
uv4 = tface->uv[3];
|
|
}
|
|
else {
|
|
uv1 = tuv[0];
|
|
uv2 = tuv[1];
|
|
uv3 = tuv[2];
|
|
uv4 = tuv[3];
|
|
map_to_sphere(uv1, uv1 + 1, v1[0], v1[1], v1[2]);
|
|
map_to_sphere(uv2, uv2 + 1, v2[0], v2[1], v2[2]);
|
|
map_to_sphere(uv3, uv3 + 1, v3[0], v3[1], v3[2]);
|
|
if (v4) {
|
|
map_to_sphere(uv4, uv4 + 1, v4[0], v4[1], v4[2]);
|
|
}
|
|
}
|
|
|
|
if (v4) {
|
|
s1 = uv3[0] - uv1[0];
|
|
s2 = uv4[0] - uv1[0];
|
|
|
|
t1 = uv3[1] - uv1[1];
|
|
t2 = uv4[1] - uv1[1];
|
|
|
|
sub_v3_v3v3(e1, v3, v1);
|
|
sub_v3_v3v3(e2, v4, v1);
|
|
}
|
|
else {
|
|
s1 = uv2[0] - uv1[0];
|
|
s2 = uv3[0] - uv1[0];
|
|
|
|
t1 = uv2[1] - uv1[1];
|
|
t2 = uv3[1] - uv1[1];
|
|
|
|
sub_v3_v3v3(e1, v2, v1);
|
|
sub_v3_v3v3(e2, v3, v1);
|
|
}
|
|
|
|
vtan[0] = (s1 * e2[0] - s2 * e1[0]);
|
|
vtan[1] = (s1 * e2[1] - s2 * e1[1]);
|
|
vtan[2] = (s1 * e2[2] - s2 * e1[2]);
|
|
|
|
utan[0] = (t1 * e2[0] - t2 * e1[0]);
|
|
utan[1] = (t1 * e2[1] - t2 * e1[1]);
|
|
utan[2] = (t1 * e2[2] - t2 * e1[2]);
|
|
}
|
|
|
|
if (orco) {
|
|
if (orcodata) {
|
|
o1 = orcodata[mface->v1];
|
|
o2 = orcodata[mface->v2];
|
|
o3 = orcodata[mface->v3];
|
|
|
|
if (mface->v4) {
|
|
o4 = orcodata[mface->v4];
|
|
|
|
interp_v3_v3v3v3v3(orco, o1, o2, o3, o4, w);
|
|
}
|
|
else {
|
|
interp_v3_v3v3v3(orco, o1, o2, o3, w);
|
|
}
|
|
BKE_mesh_orco_verts_transform(mesh, (float(*)[3])orco, 1, true);
|
|
}
|
|
else {
|
|
copy_v3_v3(orco, vec);
|
|
}
|
|
}
|
|
}
|
|
void psys_interpolate_uvs(const MTFace *tface, int quad, const float w[4], float uvco[2])
|
|
{
|
|
float v10 = tface->uv[0][0];
|
|
float v11 = tface->uv[0][1];
|
|
float v20 = tface->uv[1][0];
|
|
float v21 = tface->uv[1][1];
|
|
float v30 = tface->uv[2][0];
|
|
float v31 = tface->uv[2][1];
|
|
float v40, v41;
|
|
|
|
if (quad) {
|
|
v40 = tface->uv[3][0];
|
|
v41 = tface->uv[3][1];
|
|
|
|
uvco[0] = w[0] * v10 + w[1] * v20 + w[2] * v30 + w[3] * v40;
|
|
uvco[1] = w[0] * v11 + w[1] * v21 + w[2] * v31 + w[3] * v41;
|
|
}
|
|
else {
|
|
uvco[0] = w[0] * v10 + w[1] * v20 + w[2] * v30;
|
|
uvco[1] = w[0] * v11 + w[1] * v21 + w[2] * v31;
|
|
}
|
|
}
|
|
|
|
void psys_interpolate_mcol(const MCol *mcol, int quad, const float w[4], MCol *mc)
|
|
{
|
|
const char *cp1, *cp2, *cp3, *cp4;
|
|
char *cp;
|
|
|
|
cp = (char *)mc;
|
|
cp1 = (const char *)&mcol[0];
|
|
cp2 = (const char *)&mcol[1];
|
|
cp3 = (const char *)&mcol[2];
|
|
|
|
if (quad) {
|
|
cp4 = (char *)&mcol[3];
|
|
|
|
cp[0] = int(w[0] * cp1[0] + w[1] * cp2[0] + w[2] * cp3[0] + w[3] * cp4[0]);
|
|
cp[1] = int(w[0] * cp1[1] + w[1] * cp2[1] + w[2] * cp3[1] + w[3] * cp4[1]);
|
|
cp[2] = int(w[0] * cp1[2] + w[1] * cp2[2] + w[2] * cp3[2] + w[3] * cp4[2]);
|
|
cp[3] = int(w[0] * cp1[3] + w[1] * cp2[3] + w[2] * cp3[3] + w[3] * cp4[3]);
|
|
}
|
|
else {
|
|
cp[0] = int(w[0] * cp1[0] + w[1] * cp2[0] + w[2] * cp3[0]);
|
|
cp[1] = int(w[0] * cp1[1] + w[1] * cp2[1] + w[2] * cp3[1]);
|
|
cp[2] = int(w[0] * cp1[2] + w[1] * cp2[2] + w[2] * cp3[2]);
|
|
cp[3] = int(w[0] * cp1[3] + w[1] * cp2[3] + w[2] * cp3[3]);
|
|
}
|
|
}
|
|
|
|
static float psys_interpolate_value_from_verts(
|
|
Mesh *mesh, short from, int index, const float fw[4], const float *values)
|
|
{
|
|
if (values == nullptr || index == -1) {
|
|
return 0.0;
|
|
}
|
|
|
|
switch (from) {
|
|
case PART_FROM_VERT:
|
|
return values[index];
|
|
case PART_FROM_FACE:
|
|
case PART_FROM_VOLUME: {
|
|
MFace *mfaces = static_cast<MFace *>(
|
|
CustomData_get_layer_for_write(&mesh->fdata_legacy, CD_MFACE, mesh->totface_legacy));
|
|
MFace *mf = &mfaces[index];
|
|
return interpolate_particle_value(
|
|
values[mf->v1], values[mf->v2], values[mf->v3], values[mf->v4], fw, mf->v4);
|
|
}
|
|
}
|
|
return 0.0f;
|
|
}
|
|
|
|
/* conversion of pa->fw to origspace layer coordinates */
|
|
static void psys_w_to_origspace(const float w[4], float uv[2])
|
|
{
|
|
uv[0] = w[1] + w[2];
|
|
uv[1] = w[2] + w[3];
|
|
}
|
|
|
|
/* conversion of pa->fw to weights in face from origspace */
|
|
static void psys_origspace_to_w(OrigSpaceFace *osface, int quad, const float w[4], float neww[4])
|
|
{
|
|
float v[4][3], co[3];
|
|
|
|
v[0][0] = osface->uv[0][0];
|
|
v[0][1] = osface->uv[0][1];
|
|
v[0][2] = 0.0f;
|
|
v[1][0] = osface->uv[1][0];
|
|
v[1][1] = osface->uv[1][1];
|
|
v[1][2] = 0.0f;
|
|
v[2][0] = osface->uv[2][0];
|
|
v[2][1] = osface->uv[2][1];
|
|
v[2][2] = 0.0f;
|
|
|
|
psys_w_to_origspace(w, co);
|
|
co[2] = 0.0f;
|
|
|
|
if (quad) {
|
|
v[3][0] = osface->uv[3][0];
|
|
v[3][1] = osface->uv[3][1];
|
|
v[3][2] = 0.0f;
|
|
interp_weights_poly_v3(neww, v, 4, co);
|
|
}
|
|
else {
|
|
interp_weights_poly_v3(neww, v, 3, co);
|
|
neww[3] = 0.0f;
|
|
}
|
|
}
|
|
|
|
int psys_particle_dm_face_lookup(Mesh *mesh_final,
|
|
Mesh *mesh_original,
|
|
int findex_orig,
|
|
const float fw[4],
|
|
LinkNode **poly_nodes)
|
|
{
|
|
MFace *mtessface_final;
|
|
const OrigSpaceFace *osface_final;
|
|
int pindex_orig;
|
|
float uv[2];
|
|
const float(*faceuv)[2];
|
|
|
|
const int *index_mf_to_mpoly_deformed = nullptr;
|
|
const int *index_mf_to_mpoly = nullptr;
|
|
const int *index_mp_to_orig = nullptr;
|
|
|
|
const int totface_final = mesh_final->totface_legacy;
|
|
const int totface_deformed = mesh_original ? mesh_original->totface_legacy : totface_final;
|
|
|
|
if (ELEM(0, totface_final, totface_deformed)) {
|
|
return DMCACHE_NOTFOUND;
|
|
}
|
|
|
|
index_mf_to_mpoly = static_cast<const int *>(
|
|
CustomData_get_layer(&mesh_final->fdata_legacy, CD_ORIGINDEX));
|
|
index_mp_to_orig = static_cast<const int *>(
|
|
CustomData_get_layer(&mesh_final->face_data, CD_ORIGINDEX));
|
|
BLI_assert(index_mf_to_mpoly);
|
|
|
|
if (mesh_original) {
|
|
index_mf_to_mpoly_deformed = static_cast<const int *>(
|
|
CustomData_get_layer(&mesh_original->fdata_legacy, CD_ORIGINDEX));
|
|
}
|
|
else {
|
|
BLI_assert(mesh_final->runtime->deformed_only);
|
|
index_mf_to_mpoly_deformed = index_mf_to_mpoly;
|
|
}
|
|
BLI_assert(index_mf_to_mpoly_deformed);
|
|
|
|
pindex_orig = index_mf_to_mpoly_deformed[findex_orig];
|
|
|
|
if (mesh_original == nullptr) {
|
|
mesh_original = mesh_final;
|
|
}
|
|
|
|
index_mf_to_mpoly_deformed = nullptr;
|
|
|
|
mtessface_final = static_cast<MFace *>(CustomData_get_layer_for_write(
|
|
&mesh_final->fdata_legacy, CD_MFACE, mesh_final->totface_legacy));
|
|
osface_final = static_cast<OrigSpaceFace *>(CustomData_get_layer_for_write(
|
|
&mesh_final->fdata_legacy, CD_ORIGSPACE, mesh_final->totface_legacy));
|
|
|
|
if (osface_final == nullptr) {
|
|
/* Assume we don't need osface_final data, and we get a direct 1-1 mapping... */
|
|
if (findex_orig < totface_final) {
|
|
// printf("\tNO CD_ORIGSPACE, assuming not needed\n");
|
|
return findex_orig;
|
|
}
|
|
|
|
printf("\tNO CD_ORIGSPACE, error out of range\n");
|
|
return DMCACHE_NOTFOUND;
|
|
}
|
|
if (findex_orig >= mesh_original->totface_legacy) {
|
|
return DMCACHE_NOTFOUND; /* index not in the original mesh */
|
|
}
|
|
|
|
psys_w_to_origspace(fw, uv);
|
|
|
|
if (poly_nodes) {
|
|
/* we can have a restricted linked list of faces to check, faster! */
|
|
LinkNode *tessface_node = poly_nodes[pindex_orig];
|
|
|
|
for (; tessface_node; tessface_node = tessface_node->next) {
|
|
int findex_dst = POINTER_AS_INT(tessface_node->link);
|
|
faceuv = osface_final[findex_dst].uv;
|
|
|
|
/* check that this intersects - Its possible this misses :/ -
|
|
* could also check its not between */
|
|
if (mtessface_final[findex_dst].v4) {
|
|
if (isect_point_quad_v2(uv, faceuv[0], faceuv[1], faceuv[2], faceuv[3])) {
|
|
return findex_dst;
|
|
}
|
|
}
|
|
else if (isect_point_tri_v2(uv, faceuv[0], faceuv[1], faceuv[2])) {
|
|
return findex_dst;
|
|
}
|
|
}
|
|
}
|
|
else { /* if we have no node, try every face */
|
|
for (int findex_dst = 0; findex_dst < totface_final; findex_dst++) {
|
|
/* If current tessface from 'final' DM and orig tessface (given by index)
|
|
* map to the same orig poly. */
|
|
if (BKE_mesh_origindex_mface_mpoly(index_mf_to_mpoly, index_mp_to_orig, findex_dst) ==
|
|
pindex_orig)
|
|
{
|
|
faceuv = osface_final[findex_dst].uv;
|
|
|
|
/* check that this intersects - Its possible this misses :/ -
|
|
* could also check its not between */
|
|
if (mtessface_final[findex_dst].v4) {
|
|
if (isect_point_quad_v2(uv, faceuv[0], faceuv[1], faceuv[2], faceuv[3])) {
|
|
return findex_dst;
|
|
}
|
|
}
|
|
else if (isect_point_tri_v2(uv, faceuv[0], faceuv[1], faceuv[2])) {
|
|
return findex_dst;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return DMCACHE_NOTFOUND;
|
|
}
|
|
|
|
static int psys_map_index_on_dm(Mesh *mesh,
|
|
int from,
|
|
int index,
|
|
int index_dmcache,
|
|
const float fw[4],
|
|
float /*foffset*/,
|
|
int *mapindex,
|
|
float mapfw[4])
|
|
{
|
|
if (index < 0) {
|
|
return 0;
|
|
}
|
|
|
|
if (mesh->runtime->deformed_only || index_dmcache == DMCACHE_ISCHILD) {
|
|
/* for meshes that are either only deformed or for child particles, the
|
|
* index and fw do not require any mapping, so we can directly use it */
|
|
if (from == PART_FROM_VERT) {
|
|
if (index >= mesh->verts_num) {
|
|
return 0;
|
|
}
|
|
|
|
*mapindex = index;
|
|
}
|
|
else { /* FROM_FACE/FROM_VOLUME */
|
|
if (index >= mesh->totface_legacy) {
|
|
return 0;
|
|
}
|
|
|
|
*mapindex = index;
|
|
copy_v4_v4(mapfw, fw);
|
|
}
|
|
}
|
|
else {
|
|
/* for other meshes that have been modified, we try to map the particle
|
|
* to their new location, which means a different index, and for faces
|
|
* also a new face interpolation weights */
|
|
if (from == PART_FROM_VERT) {
|
|
if (index_dmcache == DMCACHE_NOTFOUND || index_dmcache >= mesh->verts_num) {
|
|
return 0;
|
|
}
|
|
|
|
*mapindex = index_dmcache;
|
|
}
|
|
else { /* FROM_FACE/FROM_VOLUME */
|
|
/* find a face on the derived mesh that uses this face */
|
|
int i = index_dmcache;
|
|
|
|
if (i == DMCACHE_NOTFOUND || i >= mesh->totface_legacy) {
|
|
return 0;
|
|
}
|
|
|
|
*mapindex = i;
|
|
|
|
/* modify the original weights to become
|
|
* weights for the derived mesh face */
|
|
OrigSpaceFace *osface = static_cast<OrigSpaceFace *>(
|
|
CustomData_get_layer_for_write(&mesh->fdata_legacy, CD_ORIGSPACE, mesh->totface_legacy));
|
|
const MFace *mfaces = static_cast<const MFace *>(
|
|
CustomData_get_layer(&mesh->fdata_legacy, CD_MFACE));
|
|
const MFace *mface = &mfaces[i];
|
|
|
|
if (osface == nullptr) {
|
|
mapfw[0] = mapfw[1] = mapfw[2] = mapfw[3] = 0.0f;
|
|
}
|
|
else {
|
|
psys_origspace_to_w(&osface[i], mface->v4, fw, mapfw);
|
|
}
|
|
}
|
|
}
|
|
|
|
return 1;
|
|
}
|
|
|
|
void psys_particle_on_dm(Mesh *mesh_final,
|
|
int from,
|
|
int index,
|
|
int index_dmcache,
|
|
const float fw[4],
|
|
float foffset,
|
|
float vec[3],
|
|
float nor[3],
|
|
float utan[3],
|
|
float vtan[3],
|
|
float orco[3])
|
|
{
|
|
float tmpnor[3], mapfw[4];
|
|
const float(*orcodata)[3];
|
|
int mapindex;
|
|
|
|
if (!psys_map_index_on_dm(mesh_final, from, index, index_dmcache, fw, foffset, &mapindex, mapfw))
|
|
{
|
|
if (vec) {
|
|
vec[0] = vec[1] = vec[2] = 0.0;
|
|
}
|
|
if (nor) {
|
|
nor[0] = nor[1] = 0.0;
|
|
nor[2] = 1.0;
|
|
}
|
|
if (orco) {
|
|
orco[0] = orco[1] = orco[2] = 0.0;
|
|
}
|
|
if (utan) {
|
|
utan[0] = utan[1] = utan[2] = 0.0;
|
|
}
|
|
if (vtan) {
|
|
vtan[0] = vtan[1] = vtan[2] = 0.0;
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
orcodata = static_cast<const float(*)[3]>(CustomData_get_layer(&mesh_final->vert_data, CD_ORCO));
|
|
const blender::Span<blender::float3> vert_normals = mesh_final->vert_normals();
|
|
|
|
if (from == PART_FROM_VERT) {
|
|
const blender::Span<blender::float3> vert_positions = mesh_final->vert_positions();
|
|
copy_v3_v3(vec, vert_positions[mapindex]);
|
|
|
|
if (nor) {
|
|
copy_v3_v3(nor, vert_normals[mapindex]);
|
|
}
|
|
|
|
if (orco) {
|
|
if (orcodata) {
|
|
copy_v3_v3(orco, orcodata[mapindex]);
|
|
BKE_mesh_orco_verts_transform(mesh_final, (float(*)[3])orco, 1, true);
|
|
}
|
|
else {
|
|
copy_v3_v3(orco, vec);
|
|
}
|
|
}
|
|
|
|
if (utan && vtan) {
|
|
utan[0] = utan[1] = utan[2] = 0.0f;
|
|
vtan[0] = vtan[1] = vtan[2] = 0.0f;
|
|
}
|
|
}
|
|
else { /* PART_FROM_FACE / PART_FROM_VOLUME */
|
|
MFace *mface;
|
|
MTFace *mtface;
|
|
|
|
MFace *mfaces = static_cast<MFace *>(CustomData_get_layer_for_write(
|
|
&mesh_final->fdata_legacy, CD_MFACE, mesh_final->totface_legacy));
|
|
mface = &mfaces[mapindex];
|
|
const blender::Span<blender::float3> vert_positions = mesh_final->vert_positions();
|
|
mtface = static_cast<MTFace *>(CustomData_get_layer_for_write(
|
|
&mesh_final->fdata_legacy, CD_MTFACE, mesh_final->totface_legacy));
|
|
|
|
if (mtface) {
|
|
mtface += mapindex;
|
|
}
|
|
|
|
if (from == PART_FROM_VOLUME) {
|
|
psys_interpolate_face(mesh_final,
|
|
reinterpret_cast<const float(*)[3]>(vert_positions.data()),
|
|
reinterpret_cast<const float(*)[3]>(vert_normals.data()),
|
|
mface,
|
|
mtface,
|
|
orcodata,
|
|
mapfw,
|
|
vec,
|
|
tmpnor,
|
|
utan,
|
|
vtan,
|
|
orco);
|
|
if (nor) {
|
|
copy_v3_v3(nor, tmpnor);
|
|
}
|
|
|
|
/* XXX Why not normalize tmpnor before copying it into nor??? -- mont29 */
|
|
normalize_v3(tmpnor);
|
|
|
|
mul_v3_fl(tmpnor, -foffset);
|
|
add_v3_v3(vec, tmpnor);
|
|
}
|
|
else {
|
|
psys_interpolate_face(mesh_final,
|
|
reinterpret_cast<const float(*)[3]>(vert_positions.data()),
|
|
reinterpret_cast<const float(*)[3]>(vert_normals.data()),
|
|
mface,
|
|
mtface,
|
|
orcodata,
|
|
mapfw,
|
|
vec,
|
|
nor,
|
|
utan,
|
|
vtan,
|
|
orco);
|
|
}
|
|
}
|
|
}
|
|
|
|
float psys_particle_value_from_verts(Mesh *mesh, short from, ParticleData *pa, float *values)
|
|
{
|
|
float mapfw[4];
|
|
int mapindex;
|
|
|
|
if (!psys_map_index_on_dm(
|
|
mesh, from, pa->num, pa->num_dmcache, pa->fuv, pa->foffset, &mapindex, mapfw))
|
|
{
|
|
return 0.0f;
|
|
}
|
|
|
|
return psys_interpolate_value_from_verts(mesh, from, mapindex, mapfw, values);
|
|
}
|
|
|
|
ParticleSystemModifierData *psys_get_modifier(Object *ob, ParticleSystem *psys)
|
|
{
|
|
ParticleSystemModifierData *psmd;
|
|
|
|
LISTBASE_FOREACH (ModifierData *, md, &ob->modifiers) {
|
|
if (md->type == eModifierType_ParticleSystem) {
|
|
psmd = (ParticleSystemModifierData *)md;
|
|
if (psmd->psys == psys) {
|
|
return psmd;
|
|
}
|
|
}
|
|
}
|
|
return nullptr;
|
|
}
|
|
|
|
/************************************************/
|
|
/* Particles on a shape */
|
|
/************************************************/
|
|
|
|
/* ready for future use */
|
|
static void psys_particle_on_shape(int /*distr*/,
|
|
int /*index*/,
|
|
float * /*fuv*/,
|
|
float vec[3],
|
|
float nor[3],
|
|
float utan[3],
|
|
float vtan[3],
|
|
float orco[3])
|
|
{
|
|
/* TODO */
|
|
const float zerovec[3] = {0.0f, 0.0f, 0.0f};
|
|
if (vec) {
|
|
copy_v3_v3(vec, zerovec);
|
|
}
|
|
if (nor) {
|
|
copy_v3_v3(nor, zerovec);
|
|
}
|
|
if (utan) {
|
|
copy_v3_v3(utan, zerovec);
|
|
}
|
|
if (vtan) {
|
|
copy_v3_v3(vtan, zerovec);
|
|
}
|
|
if (orco) {
|
|
copy_v3_v3(orco, zerovec);
|
|
}
|
|
}
|
|
|
|
/************************************************/
|
|
/* Particles on emitter */
|
|
/************************************************/
|
|
|
|
void psys_emitter_customdata_mask(ParticleSystem *psys, CustomData_MeshMasks *r_cddata_masks)
|
|
{
|
|
MTex *mtex;
|
|
int i;
|
|
|
|
if (!psys->part) {
|
|
return;
|
|
}
|
|
|
|
for (i = 0; i < MAX_MTEX; i++) {
|
|
mtex = psys->part->mtex[i];
|
|
if (mtex && mtex->mapto && (mtex->texco & TEXCO_UV)) {
|
|
r_cddata_masks->fmask |= CD_MASK_MTFACE;
|
|
}
|
|
}
|
|
|
|
if (psys->part->tanfac != 0.0f) {
|
|
r_cddata_masks->fmask |= CD_MASK_MTFACE;
|
|
}
|
|
|
|
/* Ask for vertex-groups if we need them. */
|
|
for (i = 0; i < PSYS_TOT_VG; i++) {
|
|
if (psys->vgroup[i]) {
|
|
r_cddata_masks->vmask |= CD_MASK_MDEFORMVERT;
|
|
break;
|
|
}
|
|
}
|
|
|
|
/* particles only need this if they are after a non deform modifier, and
|
|
* the modifier stack will only create them in that case. */
|
|
r_cddata_masks->lmask |= CD_MASK_ORIGSPACE_MLOOP;
|
|
/* XXX Check we do need all those? */
|
|
r_cddata_masks->vmask |= CD_MASK_ORIGINDEX;
|
|
r_cddata_masks->emask |= CD_MASK_ORIGINDEX;
|
|
r_cddata_masks->pmask |= CD_MASK_ORIGINDEX;
|
|
|
|
r_cddata_masks->vmask |= CD_MASK_ORCO;
|
|
}
|
|
|
|
void psys_particle_on_emitter(ParticleSystemModifierData *psmd,
|
|
int from,
|
|
int index,
|
|
int index_dmcache,
|
|
float fuv[4],
|
|
float foffset,
|
|
float vec[3],
|
|
float nor[3],
|
|
float utan[3],
|
|
float vtan[3],
|
|
float orco[3])
|
|
{
|
|
if (psmd && psmd->mesh_final) {
|
|
if (psmd->psys->part->distr == PART_DISTR_GRID && psmd->psys->part->from != PART_FROM_VERT) {
|
|
if (vec) {
|
|
copy_v3_v3(vec, fuv);
|
|
}
|
|
|
|
if (orco) {
|
|
copy_v3_v3(orco, fuv);
|
|
}
|
|
return;
|
|
}
|
|
/* we can't use the num_dmcache */
|
|
psys_particle_on_dm(
|
|
psmd->mesh_final, from, index, index_dmcache, fuv, foffset, vec, nor, utan, vtan, orco);
|
|
}
|
|
else {
|
|
psys_particle_on_shape(from, index, fuv, vec, nor, utan, vtan, orco);
|
|
}
|
|
}
|
|
|
|
/************************************************/
|
|
/* Path Cache */
|
|
/************************************************/
|
|
|
|
void precalc_guides(ParticleSimulationData *sim, ListBase *effectors)
|
|
{
|
|
EffectedPoint point;
|
|
ParticleKey state;
|
|
EffectorData efd;
|
|
ParticleSystem *psys = sim->psys;
|
|
EffectorWeights *weights = sim->psys->part->effector_weights;
|
|
GuideEffectorData *data;
|
|
PARTICLE_P;
|
|
|
|
if (!effectors) {
|
|
return;
|
|
}
|
|
|
|
LOOP_PARTICLES
|
|
{
|
|
psys_particle_on_emitter(sim->psmd,
|
|
sim->psys->part->from,
|
|
pa->num,
|
|
pa->num_dmcache,
|
|
pa->fuv,
|
|
pa->foffset,
|
|
state.co,
|
|
nullptr,
|
|
nullptr,
|
|
nullptr,
|
|
nullptr);
|
|
|
|
mul_m4_v3(sim->ob->object_to_world().ptr(), state.co);
|
|
mul_mat3_m4_v3(sim->ob->object_to_world().ptr(), state.vel);
|
|
|
|
pd_point_from_particle(sim, pa, &state, &point);
|
|
|
|
LISTBASE_FOREACH (EffectorCache *, eff, effectors) {
|
|
if (eff->pd->forcefield != PFIELD_GUIDE) {
|
|
continue;
|
|
}
|
|
|
|
if (!eff->guide_data) {
|
|
eff->guide_data = MEM_calloc_arrayN<GuideEffectorData>(size_t(psys->totpart),
|
|
"GuideEffectorData");
|
|
}
|
|
|
|
data = eff->guide_data + p;
|
|
|
|
sub_v3_v3v3(efd.vec_to_point, state.co, eff->guide_loc);
|
|
copy_v3_v3(efd.nor, eff->guide_dir);
|
|
efd.distance = len_v3(efd.vec_to_point);
|
|
|
|
copy_v3_v3(data->vec_to_point, efd.vec_to_point);
|
|
data->strength = effector_falloff(eff, &efd, &point, weights);
|
|
}
|
|
}
|
|
}
|
|
|
|
bool do_guides(Depsgraph *depsgraph,
|
|
ParticleSettings *part,
|
|
ListBase *effectors,
|
|
ParticleKey *state,
|
|
int index,
|
|
float time)
|
|
{
|
|
CurveMapping *clumpcurve = (part->child_flag & PART_CHILD_USE_CLUMP_CURVE) ? part->clumpcurve :
|
|
nullptr;
|
|
CurveMapping *roughcurve = (part->child_flag & PART_CHILD_USE_ROUGH_CURVE) ? part->roughcurve :
|
|
nullptr;
|
|
PartDeflect *pd;
|
|
Curve *cu;
|
|
GuideEffectorData *data;
|
|
|
|
float effect[3] = {0.0f, 0.0f, 0.0f}, veffect[3] = {0.0f, 0.0f, 0.0f};
|
|
float guidevec[4], guidedir[3], rot2[4], temp[3];
|
|
float guidetime, radius, weight, angle, totstrength = 0.0f;
|
|
float vec_to_point[3];
|
|
|
|
if (effectors) {
|
|
LISTBASE_FOREACH (EffectorCache *, eff, effectors) {
|
|
pd = eff->pd;
|
|
|
|
if (pd->forcefield != PFIELD_GUIDE) {
|
|
continue;
|
|
}
|
|
|
|
data = eff->guide_data + index;
|
|
|
|
if (data->strength <= 0.0f) {
|
|
continue;
|
|
}
|
|
|
|
guidetime = time / (1.0f - pd->free_end);
|
|
|
|
if (guidetime > 1.0f) {
|
|
continue;
|
|
}
|
|
|
|
cu = (Curve *)eff->ob->data;
|
|
|
|
if (pd->flag & PFIELD_GUIDE_PATH_ADD) {
|
|
if (BKE_where_on_path(eff->ob,
|
|
data->strength * guidetime,
|
|
guidevec,
|
|
guidedir,
|
|
nullptr,
|
|
&radius,
|
|
&weight) == 0)
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
else {
|
|
if (BKE_where_on_path(eff->ob, guidetime, guidevec, guidedir, nullptr, &radius, &weight) ==
|
|
0)
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
|
|
mul_m4_v3(eff->ob->object_to_world().ptr(), guidevec);
|
|
mul_mat3_m4_v3(eff->ob->object_to_world().ptr(), guidedir);
|
|
|
|
normalize_v3(guidedir);
|
|
|
|
copy_v3_v3(vec_to_point, data->vec_to_point);
|
|
|
|
if (guidetime != 0.0f) {
|
|
/* curve direction */
|
|
cross_v3_v3v3(temp, eff->guide_dir, guidedir);
|
|
angle = dot_v3v3(eff->guide_dir, guidedir) / len_v3(eff->guide_dir);
|
|
angle = safe_acosf(angle);
|
|
axis_angle_to_quat(rot2, temp, angle);
|
|
mul_qt_v3(rot2, vec_to_point);
|
|
|
|
/* curve tilt */
|
|
axis_angle_to_quat(rot2, guidedir, guidevec[3] - eff->guide_loc[3]);
|
|
mul_qt_v3(rot2, vec_to_point);
|
|
}
|
|
|
|
/* curve taper */
|
|
if (cu->taperobj) {
|
|
mul_v3_fl(vec_to_point,
|
|
BKE_displist_calc_taper(depsgraph,
|
|
eff->scene,
|
|
cu->taperobj,
|
|
int(data->strength * guidetime * 100.0f),
|
|
100));
|
|
}
|
|
else { /* Curve size. */
|
|
if (cu->flag & CU_PATH_RADIUS) {
|
|
mul_v3_fl(vec_to_point, radius);
|
|
}
|
|
}
|
|
|
|
if (clumpcurve) {
|
|
BKE_curvemapping_changed_all(clumpcurve);
|
|
}
|
|
if (roughcurve) {
|
|
BKE_curvemapping_changed_all(roughcurve);
|
|
}
|
|
|
|
{
|
|
ParticleKey key;
|
|
const float par_co[3] = {0.0f, 0.0f, 0.0f};
|
|
const float par_vel[3] = {0.0f, 0.0f, 0.0f};
|
|
const float par_rot[4] = {1.0f, 0.0f, 0.0f, 0.0f};
|
|
const float orco_offset[3] = {0.0f, 0.0f, 0.0f};
|
|
|
|
copy_v3_v3(key.co, vec_to_point);
|
|
do_kink(&key,
|
|
par_co,
|
|
par_vel,
|
|
par_rot,
|
|
guidetime,
|
|
pd->kink_freq,
|
|
pd->kink_shape,
|
|
pd->kink_amp,
|
|
0.0f,
|
|
pd->kink,
|
|
pd->kink_axis,
|
|
nullptr,
|
|
0);
|
|
do_clump(&key,
|
|
par_co,
|
|
guidetime,
|
|
orco_offset,
|
|
pd->clump_fac,
|
|
pd->clump_pow,
|
|
1.0f,
|
|
part->child_flag & PART_CHILD_USE_CLUMP_NOISE,
|
|
part->clump_noise_size,
|
|
clumpcurve);
|
|
copy_v3_v3(vec_to_point, key.co);
|
|
}
|
|
|
|
add_v3_v3(vec_to_point, guidevec);
|
|
|
|
// sub_v3_v3v3(pa_loc, pa_loc, pa_zero);
|
|
madd_v3_v3fl(effect, vec_to_point, data->strength);
|
|
madd_v3_v3fl(veffect, guidedir, data->strength);
|
|
totstrength += data->strength;
|
|
|
|
if (pd->flag & PFIELD_GUIDE_PATH_WEIGHT) {
|
|
totstrength *= weight;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (totstrength != 0.0f) {
|
|
if (totstrength > 1.0f) {
|
|
mul_v3_fl(effect, 1.0f / totstrength);
|
|
}
|
|
CLAMP(totstrength, 0.0f, 1.0f);
|
|
// add_v3_v3(effect, pa_zero);
|
|
interp_v3_v3v3(state->co, state->co, effect, totstrength);
|
|
|
|
normalize_v3(veffect);
|
|
mul_v3_fl(veffect, len_v3(state->vel));
|
|
copy_v3_v3(state->vel, veffect);
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
static void do_path_effectors(ParticleSimulationData *sim,
|
|
int i,
|
|
ParticleCacheKey *ca,
|
|
int k,
|
|
int steps,
|
|
float * /*rootco*/,
|
|
float effector,
|
|
float /*dfra*/,
|
|
float /*cfra*/,
|
|
float *length,
|
|
float *vec)
|
|
{
|
|
float force[3] = {0.0f, 0.0f, 0.0f};
|
|
ParticleKey eff_key;
|
|
EffectedPoint epoint;
|
|
|
|
/* Don't apply effectors for dynamic hair, otherwise the effectors don't get applied twice. */
|
|
if (sim->psys->flag & PSYS_HAIR_DYNAMICS) {
|
|
return;
|
|
}
|
|
|
|
copy_v3_v3(eff_key.co, (ca - 1)->co);
|
|
copy_v3_v3(eff_key.vel, (ca - 1)->vel);
|
|
copy_qt_qt(eff_key.rot, (ca - 1)->rot);
|
|
|
|
pd_point_from_particle(sim, sim->psys->particles + i, &eff_key, &epoint);
|
|
BKE_effectors_apply(sim->psys->effectors,
|
|
sim->colliders,
|
|
sim->psys->part->effector_weights,
|
|
&epoint,
|
|
force,
|
|
nullptr,
|
|
nullptr);
|
|
|
|
mul_v3_fl(force,
|
|
effector * powf(float(k) / float(steps), 100.0f * sim->psys->part->eff_hair) /
|
|
float(steps));
|
|
|
|
add_v3_v3(force, vec);
|
|
|
|
normalize_v3(force);
|
|
|
|
if (k < steps) {
|
|
sub_v3_v3v3(vec, (ca + 1)->co, ca->co);
|
|
}
|
|
|
|
madd_v3_v3v3fl(ca->co, (ca - 1)->co, force, *length);
|
|
|
|
if (k < steps) {
|
|
*length = len_v3(vec);
|
|
}
|
|
}
|
|
static void offset_child(ChildParticle *cpa,
|
|
ParticleKey *par,
|
|
float *par_rot,
|
|
ParticleKey *child,
|
|
float flat,
|
|
float radius)
|
|
{
|
|
copy_v3_v3(child->co, cpa->fuv);
|
|
mul_v3_fl(child->co, radius);
|
|
|
|
child->co[0] *= flat;
|
|
|
|
copy_v3_v3(child->vel, par->vel);
|
|
|
|
if (par_rot) {
|
|
mul_qt_v3(par_rot, child->co);
|
|
copy_qt_qt(child->rot, par_rot);
|
|
}
|
|
else {
|
|
unit_qt(child->rot);
|
|
}
|
|
|
|
add_v3_v3(child->co, par->co);
|
|
}
|
|
float *psys_cache_vgroup(Mesh *mesh, ParticleSystem *psys, int vgroup)
|
|
{
|
|
float *vg = nullptr;
|
|
|
|
if (vgroup < 0) {
|
|
/* hair dynamics pinning vgroup */
|
|
}
|
|
else if (psys->vgroup[vgroup]) {
|
|
const MDeformVert *dvert = mesh->deform_verts().data();
|
|
if (dvert) {
|
|
int totvert = mesh->verts_num, i;
|
|
vg = MEM_calloc_arrayN<float>(size_t(totvert), "vg_cache");
|
|
if (psys->vg_neg & (1 << vgroup)) {
|
|
for (i = 0; i < totvert; i++) {
|
|
vg[i] = 1.0f - BKE_defvert_find_weight(&dvert[i], psys->vgroup[vgroup] - 1);
|
|
}
|
|
}
|
|
else {
|
|
for (i = 0; i < totvert; i++) {
|
|
vg[i] = BKE_defvert_find_weight(&dvert[i], psys->vgroup[vgroup] - 1);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return vg;
|
|
}
|
|
void psys_find_parents(ParticleSimulationData *sim, const bool use_render_params)
|
|
{
|
|
ParticleSystem *psys = sim->psys;
|
|
ParticleSettings *part = sim->psys->part;
|
|
KDTree_3d *tree;
|
|
ChildParticle *cpa;
|
|
ParticleTexture ptex;
|
|
int p, totparent, totchild = sim->psys->totchild;
|
|
float co[3], orco[3];
|
|
int from = PART_FROM_FACE;
|
|
totparent = int(totchild * part->parents * 0.3f);
|
|
|
|
if (use_render_params && part->child_percent && part->child_render_percent) {
|
|
totparent *= float(part->child_percent) / float(part->child_render_percent);
|
|
}
|
|
|
|
/* hard limit, workaround for it being ignored above */
|
|
totparent = std::min(sim->psys->totpart, totparent);
|
|
|
|
tree = BLI_kdtree_3d_new(totparent);
|
|
|
|
for (p = 0, cpa = sim->psys->child; p < totparent; p++, cpa++) {
|
|
psys_particle_on_emitter(sim->psmd,
|
|
from,
|
|
cpa->num,
|
|
DMCACHE_ISCHILD,
|
|
cpa->fuv,
|
|
cpa->foffset,
|
|
co,
|
|
nullptr,
|
|
nullptr,
|
|
nullptr,
|
|
orco);
|
|
|
|
/* Check if particle doesn't exist because of texture influence.
|
|
* Insert only existing particles into kdtree. */
|
|
get_cpa_texture(sim->psmd->mesh_final,
|
|
psys,
|
|
part,
|
|
psys->particles + cpa->pa[0],
|
|
p,
|
|
cpa->num,
|
|
cpa->fuv,
|
|
orco,
|
|
&ptex,
|
|
PAMAP_DENS | PAMAP_CHILD,
|
|
psys->cfra);
|
|
|
|
if (ptex.exist >= psys_frand(psys, p + 24)) {
|
|
BLI_kdtree_3d_insert(tree, p, orco);
|
|
}
|
|
}
|
|
|
|
BLI_kdtree_3d_balance(tree);
|
|
|
|
for (; p < totchild; p++, cpa++) {
|
|
psys_particle_on_emitter(sim->psmd,
|
|
from,
|
|
cpa->num,
|
|
DMCACHE_ISCHILD,
|
|
cpa->fuv,
|
|
cpa->foffset,
|
|
co,
|
|
nullptr,
|
|
nullptr,
|
|
nullptr,
|
|
orco);
|
|
cpa->parent = BLI_kdtree_3d_find_nearest(tree, orco, nullptr);
|
|
}
|
|
|
|
BLI_kdtree_3d_free(tree);
|
|
}
|
|
|
|
static bool psys_thread_context_init_path(ParticleThreadContext *ctx,
|
|
ParticleSimulationData *sim,
|
|
Scene *scene,
|
|
float cfra,
|
|
const bool editupdate,
|
|
const bool use_render_params)
|
|
{
|
|
ParticleSystem *psys = sim->psys;
|
|
ParticleSettings *part = psys->part;
|
|
int totparent = 0, between = 0;
|
|
int segments = 1 << part->draw_step;
|
|
int totchild = psys->totchild;
|
|
|
|
psys_thread_context_init(ctx, sim);
|
|
|
|
/*---start figuring out what is actually wanted---*/
|
|
if (psys_in_edit_mode(sim->depsgraph, psys)) {
|
|
ParticleEditSettings *pset = &scene->toolsettings->particle;
|
|
|
|
if ((use_render_params == 0) &&
|
|
(psys_orig_edit_get(psys) == nullptr || pset->flag & PE_DRAW_PART) == 0)
|
|
{
|
|
totchild = 0;
|
|
}
|
|
|
|
segments = 1 << pset->draw_step;
|
|
}
|
|
|
|
if (totchild && part->childtype == PART_CHILD_FACES) {
|
|
totparent = int(totchild * part->parents * 0.3f);
|
|
|
|
if (use_render_params && part->child_percent && part->child_render_percent) {
|
|
totparent *= float(part->child_percent) / float(part->child_render_percent);
|
|
}
|
|
|
|
/* part->parents could still be 0 so we can't test with totparent */
|
|
between = 1;
|
|
}
|
|
|
|
if (use_render_params) {
|
|
segments = 1 << part->ren_step;
|
|
}
|
|
else {
|
|
totchild = int(float(totchild) * float(part->disp) / 100.0f);
|
|
}
|
|
|
|
totparent = std::min(totparent, totchild);
|
|
|
|
if (totchild == 0) {
|
|
return false;
|
|
}
|
|
|
|
/* fill context values */
|
|
ctx->between = between;
|
|
ctx->segments = segments;
|
|
if (ELEM(part->kink, PART_KINK_SPIRAL)) {
|
|
ctx->extra_segments = max_ii(part->kink_extra_steps, 1);
|
|
}
|
|
else {
|
|
ctx->extra_segments = 0;
|
|
}
|
|
ctx->totchild = totchild;
|
|
ctx->totparent = totparent;
|
|
ctx->parent_pass = 0;
|
|
ctx->cfra = cfra;
|
|
ctx->editupdate = editupdate;
|
|
|
|
psys_sim_data_init(&ctx->sim);
|
|
|
|
/* cache all relevant vertex groups if they exist */
|
|
ctx->vg_length = psys_cache_vgroup(ctx->mesh, psys, PSYS_VG_LENGTH);
|
|
ctx->vg_clump = psys_cache_vgroup(ctx->mesh, psys, PSYS_VG_CLUMP);
|
|
ctx->vg_kink = psys_cache_vgroup(ctx->mesh, psys, PSYS_VG_KINK);
|
|
ctx->vg_rough1 = psys_cache_vgroup(ctx->mesh, psys, PSYS_VG_ROUGH1);
|
|
ctx->vg_rough2 = psys_cache_vgroup(ctx->mesh, psys, PSYS_VG_ROUGH2);
|
|
ctx->vg_roughe = psys_cache_vgroup(ctx->mesh, psys, PSYS_VG_ROUGHE);
|
|
ctx->vg_twist = psys_cache_vgroup(ctx->mesh, psys, PSYS_VG_TWIST);
|
|
if (psys->part->flag & PART_CHILD_EFFECT) {
|
|
ctx->vg_effector = psys_cache_vgroup(ctx->mesh, psys, PSYS_VG_EFFECTOR);
|
|
}
|
|
|
|
/* prepare curvemapping tables */
|
|
if ((part->child_flag & PART_CHILD_USE_CLUMP_CURVE) && part->clumpcurve) {
|
|
ctx->clumpcurve = BKE_curvemapping_copy(part->clumpcurve);
|
|
BKE_curvemapping_changed_all(ctx->clumpcurve);
|
|
}
|
|
else {
|
|
ctx->clumpcurve = nullptr;
|
|
}
|
|
if ((part->child_flag & PART_CHILD_USE_ROUGH_CURVE) && part->roughcurve) {
|
|
ctx->roughcurve = BKE_curvemapping_copy(part->roughcurve);
|
|
BKE_curvemapping_changed_all(ctx->roughcurve);
|
|
}
|
|
else {
|
|
ctx->roughcurve = nullptr;
|
|
}
|
|
if ((part->child_flag & PART_CHILD_USE_TWIST_CURVE) && part->twistcurve) {
|
|
ctx->twistcurve = BKE_curvemapping_copy(part->twistcurve);
|
|
BKE_curvemapping_changed_all(ctx->twistcurve);
|
|
}
|
|
else {
|
|
ctx->twistcurve = nullptr;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
static void psys_task_init_path(ParticleTask *task, ParticleSimulationData *sim)
|
|
{
|
|
/* init random number generator */
|
|
int seed = 31415926 + sim->psys->seed;
|
|
|
|
task->rng_path = BLI_rng_new(seed);
|
|
}
|
|
|
|
/* NOTE: this function must be thread safe, except for branching! */
|
|
static void psys_thread_create_path(ParticleTask *task,
|
|
ChildParticle *cpa,
|
|
ParticleCacheKey *child_keys,
|
|
int i)
|
|
{
|
|
ParticleThreadContext *ctx = task->ctx;
|
|
Object *ob = ctx->sim.ob;
|
|
ParticleSystem *psys = ctx->sim.psys;
|
|
ParticleSettings *part = psys->part;
|
|
ParticleCacheKey **cache = psys->childcache;
|
|
PTCacheEdit *edit = psys_orig_edit_get(psys);
|
|
ParticleCacheKey **pcache = psys_in_edit_mode(ctx->sim.depsgraph, psys) && edit ?
|
|
edit->pathcache :
|
|
psys->pathcache;
|
|
ParticleCacheKey *child, *key[4];
|
|
ParticleTexture ptex;
|
|
float *cpa_fuv = nullptr, *par_rot = nullptr, rot[4];
|
|
float orco[3], hairmat[4][4], dvec[3], off1[4][3], off2[4][3];
|
|
float eff_length, eff_vec[3], weight[4];
|
|
int k, cpa_num;
|
|
short cpa_from;
|
|
|
|
if (!pcache) {
|
|
return;
|
|
}
|
|
|
|
if (ctx->between) {
|
|
ParticleData *pa = psys->particles + cpa->pa[0];
|
|
int w, needupdate;
|
|
float foffset, wsum = 0.0f;
|
|
float co[3];
|
|
float p_min = part->parting_min;
|
|
float p_max = part->parting_max;
|
|
/* Virtual parents don't work nicely with parting. */
|
|
float p_fac = part->parents > 0.0f ? 0.0f : part->parting_fac;
|
|
|
|
if (ctx->editupdate) {
|
|
needupdate = 0;
|
|
w = 0;
|
|
while (w < 4 && cpa->pa[w] >= 0) {
|
|
if (edit->points[cpa->pa[w]].flag & PEP_EDIT_RECALC) {
|
|
needupdate = 1;
|
|
break;
|
|
}
|
|
w++;
|
|
}
|
|
|
|
if (!needupdate) {
|
|
return;
|
|
}
|
|
|
|
memset(child_keys, 0, sizeof(*child_keys) * (ctx->segments + 1));
|
|
}
|
|
|
|
/* get parent paths */
|
|
for (w = 0; w < 4; w++) {
|
|
if (cpa->pa[w] >= 0) {
|
|
key[w] = pcache[cpa->pa[w]];
|
|
weight[w] = cpa->w[w];
|
|
}
|
|
else {
|
|
key[w] = pcache[0];
|
|
weight[w] = 0.0f;
|
|
}
|
|
}
|
|
|
|
/* modify weights to create parting */
|
|
if (p_fac > 0.0f) {
|
|
const ParticleCacheKey *key_0_last = pcache_key_segment_endpoint_safe(key[0]);
|
|
for (w = 0; w < 4; w++) {
|
|
if (w && (weight[w] > 0.0f)) {
|
|
const ParticleCacheKey *key_w_last = pcache_key_segment_endpoint_safe(key[w]);
|
|
float d;
|
|
if (part->flag & PART_CHILD_LONG_HAIR) {
|
|
/* For long hair use tip distance/root distance as parting
|
|
* factor instead of root to tip angle. */
|
|
float d1 = len_v3v3(key[0]->co, key[w]->co);
|
|
float d2 = len_v3v3(key_0_last->co, key_w_last->co);
|
|
|
|
d = d1 > 0.0f ? d2 / d1 - 1.0f : 10000.0f;
|
|
}
|
|
else {
|
|
float v1[3], v2[3];
|
|
sub_v3_v3v3(v1, key_0_last->co, key[0]->co);
|
|
sub_v3_v3v3(v2, key_w_last->co, key[w]->co);
|
|
normalize_v3(v1);
|
|
normalize_v3(v2);
|
|
|
|
d = RAD2DEGF(safe_acosf(dot_v3v3(v1, v2)));
|
|
}
|
|
|
|
if (p_max > p_min) {
|
|
d = (d - p_min) / (p_max - p_min);
|
|
}
|
|
else {
|
|
d = (d - p_min) <= 0.0f ? 0.0f : 1.0f;
|
|
}
|
|
|
|
CLAMP(d, 0.0f, 1.0f);
|
|
|
|
if (d > 0.0f) {
|
|
weight[w] *= (1.0f - d);
|
|
}
|
|
}
|
|
wsum += weight[w];
|
|
}
|
|
for (w = 0; w < 4; w++) {
|
|
weight[w] /= wsum;
|
|
}
|
|
|
|
interp_v4_v4v4(weight, cpa->w, weight, p_fac);
|
|
}
|
|
|
|
/* get the original coordinates (orco) for texture usage */
|
|
cpa_num = cpa->num;
|
|
|
|
foffset = cpa->foffset;
|
|
cpa_fuv = cpa->fuv;
|
|
cpa_from = PART_FROM_FACE;
|
|
|
|
psys_particle_on_emitter(ctx->sim.psmd,
|
|
cpa_from,
|
|
cpa_num,
|
|
DMCACHE_ISCHILD,
|
|
cpa->fuv,
|
|
foffset,
|
|
co,
|
|
nullptr,
|
|
nullptr,
|
|
nullptr,
|
|
orco);
|
|
|
|
mul_m4_v3(ob->object_to_world().ptr(), co);
|
|
|
|
for (w = 0; w < 4; w++) {
|
|
sub_v3_v3v3(off1[w], co, key[w]->co);
|
|
}
|
|
|
|
psys_mat_hair_to_global(ob, ctx->sim.psmd->mesh_final, psys->part->from, pa, hairmat);
|
|
}
|
|
else {
|
|
ParticleData *pa = psys->particles + cpa->parent;
|
|
float co[3];
|
|
if (ctx->editupdate) {
|
|
if (!(edit->points[cpa->parent].flag & PEP_EDIT_RECALC)) {
|
|
return;
|
|
}
|
|
|
|
memset(child_keys, 0, sizeof(*child_keys) * (ctx->segments + 1));
|
|
}
|
|
|
|
/* get the parent path */
|
|
key[0] = pcache[cpa->parent];
|
|
|
|
/* get the original coordinates (orco) for texture usage */
|
|
cpa_from = part->from;
|
|
|
|
/*
|
|
* NOTE: Should in theory be the same as:
|
|
* cpa_num = psys_particle_dm_face_lookup(
|
|
* ctx->sim.psmd->dm_final,
|
|
* ctx->sim.psmd->dm_deformed,
|
|
* pa->num, pa->fuv,
|
|
* nullptr);
|
|
*/
|
|
cpa_num = ELEM(pa->num_dmcache, DMCACHE_ISCHILD, DMCACHE_NOTFOUND) ? pa->num : pa->num_dmcache;
|
|
|
|
/* XXX hack to avoid messed up particle num and subsequent crash (#40733) */
|
|
if (cpa_num > ctx->sim.psmd->mesh_final->totface_legacy) {
|
|
cpa_num = 0;
|
|
}
|
|
cpa_fuv = pa->fuv;
|
|
|
|
psys_particle_on_emitter(ctx->sim.psmd,
|
|
cpa_from,
|
|
cpa_num,
|
|
DMCACHE_ISCHILD,
|
|
cpa_fuv,
|
|
pa->foffset,
|
|
co,
|
|
nullptr,
|
|
nullptr,
|
|
nullptr,
|
|
orco);
|
|
|
|
psys_mat_hair_to_global(ob, ctx->sim.psmd->mesh_final, psys->part->from, pa, hairmat);
|
|
}
|
|
|
|
child_keys->segments = ctx->segments;
|
|
|
|
/* get different child parameters from textures & vgroups */
|
|
get_child_modifier_parameters(part, ctx, cpa, cpa_from, cpa_num, cpa_fuv, orco, &ptex);
|
|
|
|
if (ptex.exist < psys_frand(psys, i + 24)) {
|
|
child_keys->segments = -1;
|
|
return;
|
|
}
|
|
|
|
/* create the child path */
|
|
for (k = 0, child = child_keys; k <= ctx->segments; k++, child++) {
|
|
if (ctx->between) {
|
|
int w = 0;
|
|
|
|
zero_v3(child->co);
|
|
zero_v3(child->vel);
|
|
unit_qt(child->rot);
|
|
|
|
for (w = 0; w < 4; w++) {
|
|
copy_v3_v3(off2[w], off1[w]);
|
|
|
|
if (part->flag & PART_CHILD_LONG_HAIR) {
|
|
/* Use parent rotation (in addition to emission location) to determine child offset. */
|
|
if (k) {
|
|
mul_qt_v3((key[w] + k)->rot, off2[w]);
|
|
}
|
|
|
|
/* Fade the effect of rotation for even lengths in the end */
|
|
project_v3_v3v3(dvec, off2[w], (key[w] + k)->vel);
|
|
madd_v3_v3fl(off2[w], dvec, -float(k) / float(ctx->segments));
|
|
}
|
|
|
|
add_v3_v3(off2[w], (key[w] + k)->co);
|
|
}
|
|
|
|
/* child position is the weighted sum of parent positions */
|
|
interp_v3_v3v3v3v3(child->co, off2[0], off2[1], off2[2], off2[3], weight);
|
|
interp_v3_v3v3v3v3(child->vel,
|
|
(key[0] + k)->vel,
|
|
(key[1] + k)->vel,
|
|
(key[2] + k)->vel,
|
|
(key[3] + k)->vel,
|
|
weight);
|
|
|
|
copy_qt_qt(child->rot, (key[0] + k)->rot);
|
|
}
|
|
else {
|
|
if (k) {
|
|
mul_qt_qtqt(rot, (key[0] + k)->rot, key[0]->rot);
|
|
par_rot = rot;
|
|
}
|
|
else {
|
|
par_rot = key[0]->rot;
|
|
}
|
|
/* offset the child from the parent position */
|
|
offset_child(cpa,
|
|
(ParticleKey *)(key[0] + k),
|
|
par_rot,
|
|
(ParticleKey *)child,
|
|
part->childflat,
|
|
part->childrad);
|
|
}
|
|
|
|
child->time = float(k) / float(ctx->segments);
|
|
}
|
|
|
|
/* apply effectors */
|
|
if (part->flag & PART_CHILD_EFFECT) {
|
|
for (k = 0, child = child_keys; k <= ctx->segments; k++, child++) {
|
|
if (k) {
|
|
do_path_effectors(&ctx->sim,
|
|
cpa->pa[0],
|
|
child,
|
|
k,
|
|
ctx->segments,
|
|
child_keys->co,
|
|
ptex.effector,
|
|
0.0f,
|
|
ctx->cfra,
|
|
&eff_length,
|
|
eff_vec);
|
|
}
|
|
else {
|
|
sub_v3_v3v3(eff_vec, (child + 1)->co, child->co);
|
|
eff_length = len_v3(eff_vec);
|
|
}
|
|
}
|
|
}
|
|
|
|
{
|
|
ParticleData *pa = nullptr;
|
|
ParticleCacheKey *par = nullptr;
|
|
float par_co[3];
|
|
float par_orco[3];
|
|
|
|
if (ctx->totparent) {
|
|
if (i >= ctx->totparent) {
|
|
pa = &psys->particles[cpa->parent];
|
|
/* this is now threadsafe, virtual parents are calculated before rest of children */
|
|
BLI_assert(cpa->parent < psys->totchildcache);
|
|
par = cache[cpa->parent];
|
|
}
|
|
}
|
|
else if (cpa->parent >= 0) {
|
|
pa = &psys->particles[cpa->parent];
|
|
par = pcache[cpa->parent];
|
|
|
|
/* If particle is non-existing, try to pick a viable parent from particles
|
|
* used for interpolation. */
|
|
for (k = 0; k < 4 && pa && (pa->flag & PARS_UNEXIST); k++) {
|
|
if (cpa->pa[k] >= 0) {
|
|
pa = &psys->particles[cpa->pa[k]];
|
|
par = pcache[cpa->pa[k]];
|
|
}
|
|
}
|
|
|
|
if (pa->flag & PARS_UNEXIST) {
|
|
pa = nullptr;
|
|
}
|
|
}
|
|
|
|
if (pa) {
|
|
ListBase modifiers;
|
|
BLI_listbase_clear(&modifiers);
|
|
|
|
psys_particle_on_emitter(ctx->sim.psmd,
|
|
part->from,
|
|
pa->num,
|
|
pa->num_dmcache,
|
|
pa->fuv,
|
|
pa->foffset,
|
|
par_co,
|
|
nullptr,
|
|
nullptr,
|
|
nullptr,
|
|
par_orco);
|
|
|
|
psys_apply_child_modifiers(
|
|
ctx, &modifiers, cpa, &ptex, orco, hairmat, child_keys, par, par_orco);
|
|
}
|
|
else {
|
|
zero_v3(par_orco);
|
|
}
|
|
}
|
|
|
|
/* Hide virtual parents */
|
|
if (i < ctx->totparent) {
|
|
child_keys->segments = -1;
|
|
}
|
|
}
|
|
|
|
static void exec_child_path_cache(TaskPool *__restrict /*pool*/, void *taskdata)
|
|
{
|
|
ParticleTask *task = static_cast<ParticleTask *>(taskdata);
|
|
ParticleThreadContext *ctx = task->ctx;
|
|
ParticleSystem *psys = ctx->sim.psys;
|
|
ParticleCacheKey **cache = psys->childcache;
|
|
ChildParticle *cpa;
|
|
int i;
|
|
|
|
cpa = psys->child + task->begin;
|
|
for (i = task->begin; i < task->end; i++, cpa++) {
|
|
BLI_assert(i < psys->totchildcache);
|
|
psys_thread_create_path(task, cpa, cache[i], i);
|
|
}
|
|
}
|
|
|
|
void psys_cache_child_paths(ParticleSimulationData *sim,
|
|
float cfra,
|
|
const bool editupdate,
|
|
const bool use_render_params)
|
|
{
|
|
if (sim->psys->flag & PSYS_GLOBAL_HAIR) {
|
|
return;
|
|
}
|
|
|
|
/* create a task pool for child path tasks */
|
|
ParticleThreadContext ctx;
|
|
if (!psys_thread_context_init_path(&ctx, sim, sim->scene, cfra, editupdate, use_render_params)) {
|
|
return;
|
|
}
|
|
|
|
TaskPool *task_pool = BLI_task_pool_create(&ctx, TASK_PRIORITY_HIGH);
|
|
const int totchild = ctx.totchild;
|
|
const int totparent = ctx.totparent;
|
|
|
|
if (editupdate && sim->psys->childcache && totchild == sim->psys->totchildcache) {
|
|
/* just overwrite the existing cache */
|
|
}
|
|
else {
|
|
/* clear out old and create new empty path cache */
|
|
free_child_path_cache(sim->psys);
|
|
|
|
sim->psys->childcache = psys_alloc_path_cache_buffers(
|
|
&sim->psys->childcachebufs, totchild, ctx.segments + ctx.extra_segments + 1);
|
|
sim->psys->totchildcache = totchild;
|
|
}
|
|
|
|
/* cache parent paths */
|
|
ctx.parent_pass = 1;
|
|
blender::Vector<ParticleTask> tasks_parent = psys_tasks_create(&ctx, 0, totparent);
|
|
for (ParticleTask &task : tasks_parent) {
|
|
psys_task_init_path(&task, sim);
|
|
BLI_task_pool_push(task_pool, exec_child_path_cache, &task, false, nullptr);
|
|
}
|
|
BLI_task_pool_work_and_wait(task_pool);
|
|
|
|
/* cache child paths */
|
|
ctx.parent_pass = 0;
|
|
blender::Vector<ParticleTask> tasks_child = psys_tasks_create(&ctx, totparent, totchild);
|
|
for (ParticleTask &task : tasks_child) {
|
|
psys_task_init_path(&task, sim);
|
|
BLI_task_pool_push(task_pool, exec_child_path_cache, &task, false, nullptr);
|
|
}
|
|
BLI_task_pool_work_and_wait(task_pool);
|
|
|
|
BLI_task_pool_free(task_pool);
|
|
|
|
psys_tasks_free(tasks_parent);
|
|
psys_tasks_free(tasks_child);
|
|
|
|
psys_thread_context_free(&ctx);
|
|
}
|
|
|
|
/* figure out incremental rotations along path starting from unit quat */
|
|
static void cache_key_incremental_rotation(ParticleCacheKey *key0,
|
|
ParticleCacheKey *key1,
|
|
ParticleCacheKey *key2,
|
|
float *prev_tangent,
|
|
int i)
|
|
{
|
|
float cosangle, angle, tangent[3], normal[3], q[4];
|
|
|
|
switch (i) {
|
|
case 0:
|
|
/* start from second key */
|
|
break;
|
|
case 1:
|
|
/* calculate initial tangent for incremental rotations */
|
|
sub_v3_v3v3(prev_tangent, key0->co, key1->co);
|
|
normalize_v3(prev_tangent);
|
|
unit_qt(key1->rot);
|
|
break;
|
|
default:
|
|
sub_v3_v3v3(tangent, key0->co, key1->co);
|
|
normalize_v3(tangent);
|
|
|
|
cosangle = dot_v3v3(tangent, prev_tangent);
|
|
|
|
/* note we do the comparison on cosangle instead of
|
|
* angle, since floating point accuracy makes it give
|
|
* different results across platforms */
|
|
if (cosangle > 0.999999f) {
|
|
copy_v4_v4(key1->rot, key2->rot);
|
|
}
|
|
else {
|
|
angle = safe_acosf(cosangle);
|
|
cross_v3_v3v3(normal, prev_tangent, tangent);
|
|
axis_angle_to_quat(q, normal, angle);
|
|
mul_qt_qtqt(key1->rot, q, key2->rot);
|
|
}
|
|
|
|
copy_v3_v3(prev_tangent, tangent);
|
|
}
|
|
}
|
|
|
|
void psys_cache_paths(ParticleSimulationData *sim, float cfra, const bool use_render_params)
|
|
{
|
|
PARTICLE_PSMD;
|
|
ParticleEditSettings *pset = &sim->scene->toolsettings->particle;
|
|
ParticleSystem *psys = sim->psys;
|
|
ParticleSettings *part = psys->part;
|
|
ParticleCacheKey *ca, **cache;
|
|
|
|
Mesh *hair_mesh = (psys->part->type == PART_HAIR && psys->flag & PSYS_HAIR_DYNAMICS) ?
|
|
psys->hair_out_mesh :
|
|
nullptr;
|
|
|
|
ParticleKey result;
|
|
|
|
Material *ma;
|
|
ParticleInterpolationData pind;
|
|
ParticleTexture ptex;
|
|
|
|
PARTICLE_P;
|
|
|
|
float birthtime = 0.0, dietime = 0.0;
|
|
float t, time = 0.0, dfra = 1.0;
|
|
float col[4] = {0.5f, 0.5f, 0.5f, 1.0f};
|
|
float prev_tangent[3] = {0.0f, 0.0f, 0.0f}, hairmat[4][4];
|
|
float rotmat[3][3];
|
|
int k;
|
|
int segments = int(pow(2.0, double((use_render_params) ? part->ren_step : part->draw_step)));
|
|
int totpart = psys->totpart;
|
|
float length, vec[3];
|
|
float *vg_effector = nullptr;
|
|
float *vg_length = nullptr, pa_length = 1.0f;
|
|
int keyed, baked;
|
|
|
|
/* we don't have anything valid to create paths from so let's quit here */
|
|
if ((psys->flag & PSYS_HAIR_DONE || psys->flag & PSYS_KEYED || psys->pointcache) == 0) {
|
|
return;
|
|
}
|
|
|
|
if (psys_in_edit_mode(sim->depsgraph, psys)) {
|
|
if ((psys->edit == nullptr || pset->flag & PE_DRAW_PART) == 0) {
|
|
return;
|
|
}
|
|
}
|
|
|
|
keyed = psys->flag & PSYS_KEYED;
|
|
baked = psys->pointcache->mem_cache.first && psys->part->type != PART_HAIR;
|
|
|
|
/* clear out old and create new empty path cache */
|
|
psys_free_path_cache(psys, psys->edit);
|
|
cache = psys->pathcache = psys_alloc_path_cache_buffers(
|
|
&psys->pathcachebufs, totpart, segments + 1);
|
|
|
|
psys_sim_data_init(sim);
|
|
ma = BKE_object_material_get(sim->ob, psys->part->omat);
|
|
if (ma && (psys->part->draw_col == PART_DRAW_COL_MAT)) {
|
|
copy_v3_v3(col, &ma->r);
|
|
}
|
|
|
|
if ((psys->flag & PSYS_GLOBAL_HAIR) == 0) {
|
|
if ((psys->part->flag & PART_CHILD_EFFECT) == 0) {
|
|
vg_effector = psys_cache_vgroup(psmd->mesh_final, psys, PSYS_VG_EFFECTOR);
|
|
}
|
|
|
|
if (!psys->totchild) {
|
|
vg_length = psys_cache_vgroup(psmd->mesh_final, psys, PSYS_VG_LENGTH);
|
|
}
|
|
}
|
|
|
|
/* ensure we have tessfaces to be used for mapping */
|
|
if (part->from != PART_FROM_VERT) {
|
|
BKE_mesh_tessface_ensure(psmd->mesh_final);
|
|
}
|
|
|
|
/*---first main loop: create all actual particles' paths---*/
|
|
LOOP_PARTICLES
|
|
{
|
|
if (!psys->totchild) {
|
|
psys_get_texture(sim, pa, &ptex, PAMAP_LENGTH, 0.0f);
|
|
pa_length = ptex.length * (1.0f - part->randlength * psys_frand(psys, psys->seed + p));
|
|
if (vg_length) {
|
|
pa_length *= psys_particle_value_from_verts(psmd->mesh_final, part->from, pa, vg_length);
|
|
}
|
|
}
|
|
|
|
pind.keyed = keyed;
|
|
pind.cache = baked ? psys->pointcache : nullptr;
|
|
pind.epoint = nullptr;
|
|
pind.bspline = (psys->part->flag & PART_HAIR_BSPLINE);
|
|
pind.mesh = hair_mesh;
|
|
|
|
memset(cache[p], 0, sizeof(*cache[p]) * (segments + 1));
|
|
|
|
cache[p]->segments = segments;
|
|
|
|
/*--get the first data points--*/
|
|
init_particle_interpolation(sim->ob, sim->psys, pa, &pind);
|
|
|
|
/* 'hairmat' is needed for non-hair particle too so we get proper rotations. */
|
|
psys_mat_hair_to_global(sim->ob, psmd->mesh_final, psys->part->from, pa, hairmat);
|
|
copy_v3_v3(rotmat[0], hairmat[2]);
|
|
copy_v3_v3(rotmat[1], hairmat[1]);
|
|
copy_v3_v3(rotmat[2], hairmat[0]);
|
|
|
|
if (part->draw & PART_ABS_PATH_TIME) {
|
|
birthtime = std::max(pind.birthtime, part->path_start);
|
|
dietime = std::min(pind.dietime, part->path_end);
|
|
}
|
|
else {
|
|
float tb = pind.birthtime;
|
|
birthtime = tb + part->path_start * (pind.dietime - tb);
|
|
dietime = tb + part->path_end * (pind.dietime - tb);
|
|
}
|
|
|
|
if (birthtime >= dietime) {
|
|
cache[p]->segments = -1;
|
|
continue;
|
|
}
|
|
|
|
dietime = birthtime + pa_length * (dietime - birthtime);
|
|
|
|
/*--interpolate actual path from data points--*/
|
|
for (k = 0, ca = cache[p]; k <= segments; k++, ca++) {
|
|
time = float(k) / float(segments);
|
|
t = birthtime + time * (dietime - birthtime);
|
|
result.time = -t;
|
|
do_particle_interpolation(psys, p, pa, t, &pind, &result);
|
|
copy_v3_v3(ca->co, result.co);
|
|
|
|
/* dynamic hair is in object space */
|
|
/* keyed and baked are already in global space */
|
|
if (hair_mesh) {
|
|
mul_m4_v3(sim->ob->object_to_world().ptr(), ca->co);
|
|
}
|
|
else if (!keyed && !baked && !(psys->flag & PSYS_GLOBAL_HAIR)) {
|
|
mul_m4_v3(hairmat, ca->co);
|
|
}
|
|
|
|
copy_v3_v3(ca->col, col);
|
|
}
|
|
|
|
if (part->type == PART_HAIR) {
|
|
HairKey *hkey;
|
|
|
|
for (k = 0, hkey = pa->hair; k < pa->totkey; k++, hkey++) {
|
|
mul_v3_m4v3(hkey->world_co, hairmat, hkey->co);
|
|
}
|
|
}
|
|
|
|
/*--modify paths and calculate rotation & velocity--*/
|
|
|
|
if (!(psys->flag & PSYS_GLOBAL_HAIR)) {
|
|
/* apply effectors */
|
|
if ((psys->part->flag & PART_CHILD_EFFECT) == 0) {
|
|
float effector = 1.0f;
|
|
if (vg_effector) {
|
|
effector *= psys_particle_value_from_verts(
|
|
psmd->mesh_final, psys->part->from, pa, vg_effector);
|
|
}
|
|
|
|
sub_v3_v3v3(vec, (cache[p] + 1)->co, cache[p]->co);
|
|
length = len_v3(vec);
|
|
|
|
for (k = 1, ca = cache[p] + 1; k <= segments; k++, ca++) {
|
|
do_path_effectors(
|
|
sim, p, ca, k, segments, cache[p]->co, effector, dfra, cfra, &length, vec);
|
|
}
|
|
}
|
|
|
|
/* apply guide curves to path data */
|
|
if (sim->psys->effectors && (psys->part->flag & PART_CHILD_EFFECT) == 0) {
|
|
for (k = 0, ca = cache[p]; k <= segments; k++, ca++) {
|
|
/* ca is safe to cast, since only co and vel are used */
|
|
do_guides(sim->depsgraph,
|
|
sim->psys->part,
|
|
sim->psys->effectors,
|
|
(ParticleKey *)ca,
|
|
p,
|
|
float(k) / float(segments));
|
|
}
|
|
}
|
|
|
|
/* Lattices have to be calculated separately to avoid mix-ups between effector calculations.
|
|
*/
|
|
if (psys->lattice_deform_data) {
|
|
for (k = 0, ca = cache[p]; k <= segments; k++, ca++) {
|
|
BKE_lattice_deform_data_eval_co(
|
|
psys->lattice_deform_data, ca->co, psys->lattice_strength);
|
|
}
|
|
}
|
|
}
|
|
|
|
/* finally do rotation & velocity */
|
|
for (k = 1, ca = cache[p] + 1; k <= segments; k++, ca++) {
|
|
cache_key_incremental_rotation(ca, ca - 1, ca - 2, prev_tangent, k);
|
|
|
|
if (k == segments) {
|
|
copy_qt_qt(ca->rot, (ca - 1)->rot);
|
|
}
|
|
|
|
/* set velocity */
|
|
sub_v3_v3v3(ca->vel, ca->co, (ca - 1)->co);
|
|
|
|
if (k == 1) {
|
|
copy_v3_v3((ca - 1)->vel, ca->vel);
|
|
}
|
|
|
|
ca->time = float(k) / float(segments);
|
|
}
|
|
/* First rotation is based on emitting face orientation.
|
|
* This is way better than having flipping rotations resulting
|
|
* from using a global axis as a rotation pole (vec_to_quat()).
|
|
* It's not an ideal solution though since it disregards the
|
|
* initial tangent, but taking that in to account will allow
|
|
* the possibility of flipping again. -jahka
|
|
*/
|
|
mat3_to_quat_legacy(cache[p]->rot, rotmat);
|
|
}
|
|
|
|
psys->totcached = totpart;
|
|
|
|
psys_sim_data_free(sim);
|
|
|
|
if (vg_effector) {
|
|
MEM_freeN(vg_effector);
|
|
}
|
|
|
|
if (vg_length) {
|
|
MEM_freeN(vg_length);
|
|
}
|
|
}
|
|
|
|
struct CacheEditrPathsIterData {
|
|
Object *object;
|
|
PTCacheEdit *edit;
|
|
ParticleSystemModifierData *psmd;
|
|
ParticleData *pa;
|
|
int segments;
|
|
bool use_weight;
|
|
};
|
|
|
|
static void psys_cache_edit_paths_iter(void *__restrict iter_data_v,
|
|
const int iter,
|
|
const TaskParallelTLS *__restrict /*tls*/)
|
|
{
|
|
CacheEditrPathsIterData *iter_data = (CacheEditrPathsIterData *)iter_data_v;
|
|
PTCacheEdit *edit = iter_data->edit;
|
|
PTCacheEditPoint *point = &edit->points[iter];
|
|
if (edit->totcached && !(point->flag & PEP_EDIT_RECALC)) {
|
|
return;
|
|
}
|
|
if (point->totkey == 0) {
|
|
return;
|
|
}
|
|
Object *ob = iter_data->object;
|
|
ParticleSystem *psys = edit->psys;
|
|
ParticleCacheKey **cache = edit->pathcache;
|
|
ParticleSystemModifierData *psmd = iter_data->psmd;
|
|
ParticleData *pa = iter_data->pa ? iter_data->pa + iter : nullptr;
|
|
PTCacheEditKey *ekey = point->keys;
|
|
const int segments = iter_data->segments;
|
|
const bool use_weight = iter_data->use_weight;
|
|
|
|
float birthtime = 0.0f, dietime = 0.0f;
|
|
float hairmat[4][4], rotmat[3][3], prev_tangent[3] = {0.0f, 0.0f, 0.0f};
|
|
|
|
ParticleInterpolationData pind;
|
|
pind.keyed = 0;
|
|
pind.cache = nullptr;
|
|
pind.epoint = point;
|
|
pind.bspline = psys ? (psys->part->flag & PART_HAIR_BSPLINE) : 0;
|
|
pind.mesh = nullptr;
|
|
|
|
/* should init_particle_interpolation set this ? */
|
|
if (use_weight) {
|
|
pind.hkey[0] = nullptr;
|
|
/* pa != nullptr since the weight brush is only available for hair */
|
|
pind.hkey[0] = pa->hair;
|
|
pind.hkey[1] = pa->hair + 1;
|
|
}
|
|
|
|
memset(cache[iter], 0, sizeof(*cache[iter]) * (segments + 1));
|
|
|
|
cache[iter]->segments = segments;
|
|
|
|
/*--get the first data points--*/
|
|
init_particle_interpolation(ob, psys, pa, &pind);
|
|
|
|
if (psys) {
|
|
psys_mat_hair_to_global(ob, psmd->mesh_final, psys->part->from, pa, hairmat);
|
|
copy_v3_v3(rotmat[0], hairmat[2]);
|
|
copy_v3_v3(rotmat[1], hairmat[1]);
|
|
copy_v3_v3(rotmat[2], hairmat[0]);
|
|
}
|
|
|
|
birthtime = pind.birthtime;
|
|
dietime = pind.dietime;
|
|
|
|
if (birthtime >= dietime) {
|
|
cache[iter]->segments = -1;
|
|
return;
|
|
}
|
|
|
|
/*--interpolate actual path from data points--*/
|
|
ParticleCacheKey *ca;
|
|
int k;
|
|
float t, time = 0.0f, keytime = 0.0f;
|
|
for (k = 0, ca = cache[iter]; k <= segments; k++, ca++) {
|
|
time = float(k) / float(segments);
|
|
t = birthtime + time * (dietime - birthtime);
|
|
ParticleKey result;
|
|
result.time = -t;
|
|
do_particle_interpolation(psys, iter, pa, t, &pind, &result);
|
|
copy_v3_v3(ca->co, result.co);
|
|
|
|
/* non-hair points are already in global space */
|
|
if (psys && !(psys->flag & PSYS_GLOBAL_HAIR)) {
|
|
mul_m4_v3(hairmat, ca->co);
|
|
|
|
if (k) {
|
|
cache_key_incremental_rotation(ca, ca - 1, ca - 2, prev_tangent, k);
|
|
|
|
if (k == segments) {
|
|
copy_qt_qt(ca->rot, (ca - 1)->rot);
|
|
}
|
|
|
|
/* set velocity */
|
|
sub_v3_v3v3(ca->vel, ca->co, (ca - 1)->co);
|
|
|
|
if (k == 1) {
|
|
copy_v3_v3((ca - 1)->vel, ca->vel);
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
ca->vel[0] = ca->vel[1] = 0.0f;
|
|
ca->vel[2] = 1.0f;
|
|
}
|
|
|
|
/* selection coloring in edit mode */
|
|
if (use_weight) {
|
|
if (k == 0) {
|
|
BKE_defvert_weight_to_rgb(ca->col, pind.hkey[1]->weight);
|
|
}
|
|
else {
|
|
/* WARNING: copied from 'do_particle_interpolation' (without 'vertex' array stepping) */
|
|
float real_t;
|
|
if (result.time < 0.0f) {
|
|
real_t = -result.time;
|
|
}
|
|
else {
|
|
real_t = pind.hkey[0]->time +
|
|
t * (pind.hkey[0][pa->totkey - 1].time - pind.hkey[0]->time);
|
|
}
|
|
|
|
while (pind.hkey[1]->time < real_t) {
|
|
pind.hkey[1]++;
|
|
}
|
|
pind.hkey[0] = pind.hkey[1] - 1;
|
|
/* end copy */
|
|
|
|
float w1[3], w2[3];
|
|
keytime = (t - (*pind.ekey[0]->time)) / ((*pind.ekey[1]->time) - (*pind.ekey[0]->time));
|
|
|
|
BKE_defvert_weight_to_rgb(w1, pind.hkey[0]->weight);
|
|
BKE_defvert_weight_to_rgb(w2, pind.hkey[1]->weight);
|
|
|
|
interp_v3_v3v3(ca->col, w1, w2, keytime);
|
|
}
|
|
}
|
|
else {
|
|
/* HACK(fclem): Instead of setting the color we pass the select state in the red channel.
|
|
* This is then picked up in DRW and the gpu shader will do the color interpolation. */
|
|
if ((ekey + (pind.ekey[0] - point->keys))->flag & PEK_SELECT) {
|
|
if ((ekey + (pind.ekey[1] - point->keys))->flag & PEK_SELECT) {
|
|
ca->col[0] = 1.0f;
|
|
}
|
|
else {
|
|
keytime = (t - (*pind.ekey[0]->time)) / ((*pind.ekey[1]->time) - (*pind.ekey[0]->time));
|
|
ca->col[0] = 1.0f - keytime;
|
|
}
|
|
}
|
|
else {
|
|
if ((ekey + (pind.ekey[1] - point->keys))->flag & PEK_SELECT) {
|
|
keytime = (t - (*pind.ekey[0]->time)) / ((*pind.ekey[1]->time) - (*pind.ekey[0]->time));
|
|
ca->col[0] = keytime;
|
|
}
|
|
else {
|
|
ca->col[0] = 0.0f;
|
|
}
|
|
}
|
|
}
|
|
|
|
ca->time = t;
|
|
}
|
|
if (psys && !(psys->flag & PSYS_GLOBAL_HAIR)) {
|
|
/* First rotation is based on emitting face orientation.
|
|
* This is way better than having flipping rotations resulting
|
|
* from using a global axis as a rotation pole (vec_to_quat()).
|
|
* It's not an ideal solution though since it disregards the
|
|
* initial tangent, but taking that in to account will allow
|
|
* the possibility of flipping again. -jahka
|
|
*/
|
|
mat3_to_quat_legacy(cache[iter]->rot, rotmat);
|
|
}
|
|
}
|
|
|
|
void psys_cache_edit_paths(Depsgraph *depsgraph,
|
|
Scene *scene,
|
|
Object *ob,
|
|
PTCacheEdit *edit,
|
|
float cfra,
|
|
const bool use_render_params)
|
|
{
|
|
ParticleCacheKey **cache = edit->pathcache;
|
|
ParticleEditSettings *pset = &scene->toolsettings->particle;
|
|
|
|
ParticleSystem *psys = edit->psys;
|
|
|
|
ParticleData *pa = psys ? psys->particles : nullptr;
|
|
|
|
int segments = 1 << pset->draw_step;
|
|
int totpart = edit->totpoint, recalc_set = 0;
|
|
|
|
if (edit->psmd_eval == nullptr) {
|
|
return;
|
|
}
|
|
|
|
segments = std::max(segments, 4);
|
|
|
|
if (!cache || edit->totpoint != edit->totcached) {
|
|
/* Clear out old and create new empty path cache. */
|
|
psys_free_path_cache(edit->psys, edit);
|
|
cache = edit->pathcache = psys_alloc_path_cache_buffers(
|
|
&edit->pathcachebufs, totpart, segments + 1);
|
|
/* Set flag for update (child particles check this too). */
|
|
int i;
|
|
PTCacheEditPoint *point;
|
|
for (i = 0, point = edit->points; i < totpart; i++, point++) {
|
|
point->flag |= PEP_EDIT_RECALC;
|
|
}
|
|
recalc_set = 1;
|
|
}
|
|
|
|
const bool use_weight = (pset->brushtype == PE_BRUSH_WEIGHT) && (psys != nullptr) &&
|
|
(psys->particles != nullptr);
|
|
|
|
CacheEditrPathsIterData iter_data;
|
|
iter_data.object = ob;
|
|
iter_data.edit = edit;
|
|
iter_data.psmd = edit->psmd_eval;
|
|
iter_data.pa = pa;
|
|
iter_data.segments = segments;
|
|
iter_data.use_weight = use_weight;
|
|
|
|
TaskParallelSettings settings;
|
|
BLI_parallel_range_settings_defaults(&settings);
|
|
BLI_task_parallel_range(0, edit->totpoint, &iter_data, psys_cache_edit_paths_iter, &settings);
|
|
|
|
edit->totcached = totpart;
|
|
|
|
if (psys) {
|
|
ParticleSimulationData sim = {nullptr};
|
|
sim.depsgraph = depsgraph;
|
|
sim.scene = scene;
|
|
sim.ob = ob;
|
|
sim.psys = psys;
|
|
sim.psmd = edit->psmd_eval;
|
|
|
|
psys_cache_child_paths(&sim, cfra, true, use_render_params);
|
|
}
|
|
|
|
/* clear recalc flag if set here */
|
|
if (recalc_set) {
|
|
PTCacheEditPoint *point;
|
|
int i;
|
|
for (i = 0, point = edit->points; i < totpart; i++, point++) {
|
|
point->flag &= ~PEP_EDIT_RECALC;
|
|
}
|
|
}
|
|
}
|
|
|
|
/************************************************/
|
|
/* Particle Key handling */
|
|
/************************************************/
|
|
|
|
void copy_particle_key(ParticleKey *to, ParticleKey *from, int time)
|
|
{
|
|
if (time) {
|
|
memcpy(to, from, sizeof(ParticleKey));
|
|
}
|
|
else {
|
|
float to_time = to->time;
|
|
memcpy(to, from, sizeof(ParticleKey));
|
|
to->time = to_time;
|
|
}
|
|
}
|
|
void psys_get_from_key(ParticleKey *key, float loc[3], float vel[3], float rot[4], float *time)
|
|
{
|
|
if (loc) {
|
|
copy_v3_v3(loc, key->co);
|
|
}
|
|
if (vel) {
|
|
copy_v3_v3(vel, key->vel);
|
|
}
|
|
if (rot) {
|
|
copy_qt_qt(rot, key->rot);
|
|
}
|
|
if (time) {
|
|
*time = key->time;
|
|
}
|
|
}
|
|
|
|
static void triatomat(float *v1, float *v2, float *v3, const float (*uv)[2], float mat[4][4])
|
|
{
|
|
float det, w1, w2, d1[2], d2[2];
|
|
|
|
memset(mat, 0, sizeof(float[4][4]));
|
|
mat[3][3] = 1.0f;
|
|
|
|
/* first axis is the normal */
|
|
normal_tri_v3(mat[2], v1, v2, v3);
|
|
|
|
/* second axis along (1, 0) in uv space */
|
|
if (uv) {
|
|
d1[0] = uv[1][0] - uv[0][0];
|
|
d1[1] = uv[1][1] - uv[0][1];
|
|
d2[0] = uv[2][0] - uv[0][0];
|
|
d2[1] = uv[2][1] - uv[0][1];
|
|
|
|
det = d2[0] * d1[1] - d2[1] * d1[0];
|
|
|
|
if (det != 0.0f) {
|
|
det = 1.0f / det;
|
|
w1 = -d2[1] * det;
|
|
w2 = d1[1] * det;
|
|
|
|
mat[1][0] = w1 * (v2[0] - v1[0]) + w2 * (v3[0] - v1[0]);
|
|
mat[1][1] = w1 * (v2[1] - v1[1]) + w2 * (v3[1] - v1[1]);
|
|
mat[1][2] = w1 * (v2[2] - v1[2]) + w2 * (v3[2] - v1[2]);
|
|
normalize_v3(mat[1]);
|
|
}
|
|
else {
|
|
mat[1][0] = mat[1][1] = mat[1][2] = 0.0f;
|
|
}
|
|
}
|
|
else {
|
|
sub_v3_v3v3(mat[1], v2, v1);
|
|
normalize_v3(mat[1]);
|
|
}
|
|
|
|
/* third as a cross product */
|
|
cross_v3_v3v3(mat[0], mat[1], mat[2]);
|
|
}
|
|
|
|
static void psys_face_mat(Object *ob, Mesh *mesh, ParticleData *pa, float mat[4][4], int orco)
|
|
{
|
|
float v[3][3];
|
|
MFace *mface;
|
|
const float(*orcodata)[3];
|
|
|
|
int i = ELEM(pa->num_dmcache, DMCACHE_ISCHILD, DMCACHE_NOTFOUND) ? pa->num : pa->num_dmcache;
|
|
if (i == -1 || i >= mesh->totface_legacy) {
|
|
unit_m4(mat);
|
|
return;
|
|
}
|
|
|
|
MFace *mfaces = static_cast<MFace *>(
|
|
CustomData_get_layer_for_write(&mesh->fdata_legacy, CD_MFACE, mesh->totface_legacy));
|
|
mface = &mfaces[i];
|
|
const OrigSpaceFace *osface = static_cast<const OrigSpaceFace *>(
|
|
CustomData_get_for_write(&mesh->fdata_legacy, i, CD_ORIGSPACE, mesh->totface_legacy));
|
|
|
|
if (orco &&
|
|
(orcodata = static_cast<const float(*)[3]>(CustomData_get_layer(&mesh->vert_data, CD_ORCO))))
|
|
{
|
|
copy_v3_v3(v[0], orcodata[mface->v1]);
|
|
copy_v3_v3(v[1], orcodata[mface->v2]);
|
|
copy_v3_v3(v[2], orcodata[mface->v3]);
|
|
|
|
/* ugly hack to use non-transformed orcos, since only those
|
|
* give symmetric results for mirroring in particle mode */
|
|
if (CustomData_get_layer(&mesh->vert_data, CD_ORIGINDEX)) {
|
|
BKE_mesh_orco_verts_transform(static_cast<Mesh *>(ob->data), v, 3, true);
|
|
}
|
|
}
|
|
else {
|
|
const blender::Span<blender::float3> vert_positions = mesh->vert_positions();
|
|
copy_v3_v3(v[0], vert_positions[mface->v1]);
|
|
copy_v3_v3(v[1], vert_positions[mface->v2]);
|
|
copy_v3_v3(v[2], vert_positions[mface->v3]);
|
|
}
|
|
|
|
triatomat(v[0], v[1], v[2], (osface) ? osface->uv : nullptr, mat);
|
|
}
|
|
|
|
void psys_mat_hair_to_object(
|
|
Object * /*ob*/, Mesh *mesh, short from, ParticleData *pa, float hairmat[4][4])
|
|
{
|
|
float vec[3];
|
|
|
|
/* can happen when called from a different object's modifier */
|
|
if (!mesh) {
|
|
unit_m4(hairmat);
|
|
return;
|
|
}
|
|
|
|
psys_face_mat(nullptr, mesh, pa, hairmat, 0);
|
|
psys_particle_on_dm(mesh,
|
|
from,
|
|
pa->num,
|
|
pa->num_dmcache,
|
|
pa->fuv,
|
|
pa->foffset,
|
|
vec,
|
|
nullptr,
|
|
nullptr,
|
|
nullptr,
|
|
nullptr);
|
|
copy_v3_v3(hairmat[3], vec);
|
|
}
|
|
|
|
void psys_mat_hair_to_orco(
|
|
Object *ob, Mesh *mesh, short from, ParticleData *pa, float hairmat[4][4])
|
|
{
|
|
float vec[3], orco[3];
|
|
|
|
psys_face_mat(ob, mesh, pa, hairmat, 1);
|
|
psys_particle_on_dm(mesh,
|
|
from,
|
|
pa->num,
|
|
pa->num_dmcache,
|
|
pa->fuv,
|
|
pa->foffset,
|
|
vec,
|
|
nullptr,
|
|
nullptr,
|
|
nullptr,
|
|
orco);
|
|
|
|
copy_v3_v3(hairmat[3], orco);
|
|
}
|
|
|
|
void psys_vec_rot_to_face(Mesh *mesh, ParticleData *pa, float vec[3])
|
|
{
|
|
float mat[4][4];
|
|
|
|
psys_face_mat(nullptr, mesh, pa, mat, 0);
|
|
transpose_m4(mat); /* cheap inverse for rotation matrix */
|
|
mul_mat3_m4_v3(mat, vec);
|
|
}
|
|
|
|
void psys_mat_hair_to_global(
|
|
Object *ob, Mesh *mesh, short from, ParticleData *pa, float hairmat[4][4])
|
|
{
|
|
float facemat[4][4];
|
|
|
|
psys_mat_hair_to_object(ob, mesh, from, pa, facemat);
|
|
|
|
mul_m4_m4m4(hairmat, ob->object_to_world().ptr(), facemat);
|
|
}
|
|
|
|
/************************************************/
|
|
/* ParticleSettings handling */
|
|
/************************************************/
|
|
|
|
static ModifierData *object_add_or_copy_particle_system(
|
|
Main *bmain, const Scene *scene, Object *ob, const char *name, const ParticleSystem *psys_orig)
|
|
{
|
|
ParticleSystem *psys;
|
|
ModifierData *md;
|
|
ParticleSystemModifierData *psmd;
|
|
|
|
if (!ob || ob->type != OB_MESH) {
|
|
return nullptr;
|
|
}
|
|
|
|
if (name == nullptr) {
|
|
name = (psys_orig != nullptr) ? psys_orig->name : DATA_("ParticleSystem");
|
|
}
|
|
|
|
psys = static_cast<ParticleSystem *>(ob->particlesystem.first);
|
|
for (; psys; psys = psys->next) {
|
|
psys->flag &= ~PSYS_CURRENT;
|
|
}
|
|
|
|
psys = MEM_callocN<ParticleSystem>("particle_system");
|
|
psys->pointcache = BKE_ptcache_add(&psys->ptcaches);
|
|
BLI_addtail(&ob->particlesystem, psys);
|
|
psys_unique_name(ob, psys, name);
|
|
|
|
if (psys_orig != nullptr) {
|
|
psys->part = psys_orig->part;
|
|
id_us_plus(&psys->part->id);
|
|
}
|
|
else {
|
|
psys->part = BKE_particlesettings_add(bmain, DATA_("ParticleSettings"));
|
|
}
|
|
md = BKE_modifier_new(eModifierType_ParticleSystem);
|
|
STRNCPY(md->name, psys->name);
|
|
BKE_modifier_unique_name(&ob->modifiers, md);
|
|
|
|
psmd = (ParticleSystemModifierData *)md;
|
|
psmd->psys = psys;
|
|
BLI_addtail(&ob->modifiers, md);
|
|
BKE_object_modifier_set_active(ob, md);
|
|
BKE_modifiers_persistent_uid_init(*ob, *md);
|
|
|
|
psys->totpart = 0;
|
|
psys->flag = PSYS_CURRENT;
|
|
if (scene != nullptr) {
|
|
psys->cfra = BKE_scene_frame_to_ctime(scene, scene->r.cfra + 1);
|
|
}
|
|
|
|
DEG_relations_tag_update(bmain);
|
|
DEG_id_tag_update(&ob->id, ID_RECALC_GEOMETRY);
|
|
|
|
return md;
|
|
}
|
|
|
|
ModifierData *object_add_particle_system(Main *bmain,
|
|
const Scene *scene,
|
|
Object *ob,
|
|
const char *name)
|
|
{
|
|
return object_add_or_copy_particle_system(bmain, scene, ob, name, nullptr);
|
|
}
|
|
|
|
ModifierData *object_copy_particle_system(Main *bmain,
|
|
const Scene *scene,
|
|
Object *ob,
|
|
const ParticleSystem *psys_orig)
|
|
{
|
|
return object_add_or_copy_particle_system(bmain, scene, ob, nullptr, psys_orig);
|
|
}
|
|
|
|
void object_remove_particle_system(Main *bmain,
|
|
Scene * /*scene*/,
|
|
Object *ob,
|
|
ParticleSystem *psys)
|
|
{
|
|
if (!ob || !psys) {
|
|
return;
|
|
}
|
|
|
|
ParticleSystemModifierData *psmd;
|
|
ModifierData *md = BKE_modifiers_findby_type(ob, eModifierType_Fluid);
|
|
|
|
/* Clear particle system in fluid modifier. */
|
|
if (md) {
|
|
FluidModifierData *fmd = (FluidModifierData *)md;
|
|
|
|
/* Clear particle system pointer in flow settings. */
|
|
if ((fmd->type == MOD_FLUID_TYPE_FLOW) && fmd->flow && fmd->flow->psys) {
|
|
if (fmd->flow->psys == psys) {
|
|
fmd->flow->psys = nullptr;
|
|
}
|
|
}
|
|
/* Clear particle flag in domain settings when removing particle system manually. */
|
|
if (fmd->type == MOD_FLUID_TYPE_DOMAIN) {
|
|
if (psys->part->type == PART_FLUID_FLIP) {
|
|
fmd->domain->particle_type &= ~FLUID_DOMAIN_PARTICLE_FLIP;
|
|
}
|
|
if (ELEM(psys->part->type,
|
|
PART_FLUID_SPRAY,
|
|
PART_FLUID_SPRAYFOAM,
|
|
PART_FLUID_SPRAYBUBBLE,
|
|
PART_FLUID_SPRAYFOAMBUBBLE))
|
|
{
|
|
fmd->domain->particle_type &= ~FLUID_DOMAIN_PARTICLE_SPRAY;
|
|
}
|
|
if (ELEM(psys->part->type,
|
|
PART_FLUID_FOAM,
|
|
PART_FLUID_SPRAYFOAM,
|
|
PART_FLUID_FOAMBUBBLE,
|
|
PART_FLUID_SPRAYFOAMBUBBLE))
|
|
{
|
|
fmd->domain->particle_type &= ~FLUID_DOMAIN_PARTICLE_FOAM;
|
|
}
|
|
if (ELEM(psys->part->type,
|
|
PART_FLUID_BUBBLE,
|
|
PART_FLUID_FOAMBUBBLE,
|
|
PART_FLUID_SPRAYBUBBLE,
|
|
PART_FLUID_SPRAYFOAMBUBBLE))
|
|
{
|
|
fmd->domain->particle_type &= ~FLUID_DOMAIN_PARTICLE_BUBBLE;
|
|
}
|
|
if (psys->part->type == PART_FLUID_TRACER) {
|
|
fmd->domain->particle_type &= ~FLUID_DOMAIN_PARTICLE_TRACER;
|
|
}
|
|
|
|
/* Disable combined export if combined particle system was deleted. */
|
|
if (ELEM(psys->part->type,
|
|
PART_FLUID_SPRAYFOAM,
|
|
PART_FLUID_SPRAYBUBBLE,
|
|
PART_FLUID_FOAMBUBBLE,
|
|
PART_FLUID_SPRAYFOAMBUBBLE))
|
|
{
|
|
fmd->domain->sndparticle_combined_export = SNDPARTICLE_COMBINED_EXPORT_OFF;
|
|
}
|
|
}
|
|
}
|
|
|
|
if ((md = BKE_modifiers_findby_type(ob, eModifierType_DynamicPaint))) {
|
|
DynamicPaintModifierData *pmd = (DynamicPaintModifierData *)md;
|
|
if (pmd->brush && pmd->brush->psys) {
|
|
if (pmd->brush->psys == psys) {
|
|
pmd->brush->psys = nullptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
/* Clear modifier, skip empty ones. */
|
|
psmd = psys_get_modifier(ob, psys);
|
|
if (psmd) {
|
|
BKE_modifier_remove_from_list(ob, (ModifierData *)psmd);
|
|
BKE_modifier_free((ModifierData *)psmd);
|
|
}
|
|
|
|
/* Clear particle system. */
|
|
BLI_remlink(&ob->particlesystem, psys);
|
|
if (psys->part) {
|
|
id_us_min(&psys->part->id);
|
|
}
|
|
psys_free(ob, psys);
|
|
|
|
if (ob->particlesystem.first) {
|
|
((ParticleSystem *)ob->particlesystem.first)->flag |= PSYS_CURRENT;
|
|
}
|
|
else {
|
|
ob->mode &= ~OB_MODE_PARTICLE_EDIT;
|
|
}
|
|
|
|
DEG_relations_tag_update(bmain);
|
|
DEG_id_tag_update(&ob->id, ID_RECALC_GEOMETRY);
|
|
|
|
/* Flush object mode. */
|
|
DEG_id_tag_update(&ob->id, ID_RECALC_SYNC_TO_EVAL);
|
|
}
|
|
|
|
ParticleSettings *BKE_particlesettings_add(Main *bmain, const char *name)
|
|
{
|
|
ParticleSettings *part;
|
|
|
|
part = static_cast<ParticleSettings *>(BKE_id_new(bmain, ID_PA, name));
|
|
|
|
return part;
|
|
}
|
|
|
|
void BKE_particlesettings_clump_curve_init(ParticleSettings *part)
|
|
{
|
|
CurveMapping *cumap = BKE_curvemapping_add(1, 0.0f, 0.0f, 1.0f, 1.0f);
|
|
|
|
cumap->cm[0].curve[0].x = 0.0f;
|
|
cumap->cm[0].curve[0].y = 1.0f;
|
|
cumap->cm[0].curve[1].x = 1.0f;
|
|
cumap->cm[0].curve[1].y = 1.0f;
|
|
|
|
BKE_curvemapping_init(cumap);
|
|
|
|
part->clumpcurve = cumap;
|
|
}
|
|
|
|
void BKE_particlesettings_rough_curve_init(ParticleSettings *part)
|
|
{
|
|
CurveMapping *cumap = BKE_curvemapping_add(1, 0.0f, 0.0f, 1.0f, 1.0f);
|
|
|
|
cumap->cm[0].curve[0].x = 0.0f;
|
|
cumap->cm[0].curve[0].y = 1.0f;
|
|
cumap->cm[0].curve[1].x = 1.0f;
|
|
cumap->cm[0].curve[1].y = 1.0f;
|
|
|
|
BKE_curvemapping_init(cumap);
|
|
|
|
part->roughcurve = cumap;
|
|
}
|
|
|
|
void BKE_particlesettings_twist_curve_init(ParticleSettings *part)
|
|
{
|
|
CurveMapping *cumap = BKE_curvemapping_add(1, 0.0f, 0.0f, 1.0f, 1.0f);
|
|
|
|
cumap->cm[0].curve[0].x = 0.0f;
|
|
cumap->cm[0].curve[0].y = 1.0f;
|
|
cumap->cm[0].curve[1].x = 1.0f;
|
|
cumap->cm[0].curve[1].y = 1.0f;
|
|
|
|
BKE_curvemapping_init(cumap);
|
|
|
|
part->twistcurve = cumap;
|
|
}
|
|
|
|
/************************************************/
|
|
/* Textures */
|
|
/************************************************/
|
|
|
|
static int get_particle_uv(Mesh *mesh,
|
|
ParticleData *pa,
|
|
int index,
|
|
const float fuv[4],
|
|
const char *name,
|
|
float *texco,
|
|
bool from_vert)
|
|
{
|
|
MFace *mfaces = (MFace *)CustomData_get_layer_for_write(
|
|
&mesh->fdata_legacy, CD_MFACE, mesh->totface_legacy);
|
|
MFace *mf;
|
|
const MTFace *tf;
|
|
int i;
|
|
|
|
tf = static_cast<const MTFace *>(
|
|
CustomData_get_layer_named(&mesh->fdata_legacy, CD_MTFACE, name));
|
|
if (tf == nullptr) {
|
|
tf = static_cast<const MTFace *>(CustomData_get_layer(&mesh->fdata_legacy, CD_MTFACE));
|
|
}
|
|
if (tf == nullptr) {
|
|
return 0;
|
|
}
|
|
|
|
if (pa) {
|
|
i = ELEM(pa->num_dmcache, DMCACHE_NOTFOUND, DMCACHE_ISCHILD) ? pa->num : pa->num_dmcache;
|
|
if ((!from_vert && i >= mesh->totface_legacy) || (from_vert && i >= mesh->verts_num)) {
|
|
i = -1;
|
|
}
|
|
}
|
|
else {
|
|
i = index;
|
|
}
|
|
|
|
if (i == -1) {
|
|
texco[0] = 0.0f;
|
|
texco[1] = 0.0f;
|
|
texco[2] = 0.0f;
|
|
}
|
|
else {
|
|
if (from_vert) {
|
|
mf = mfaces;
|
|
|
|
/* This finds the first face to contain the emitting vertex,
|
|
* this is not ideal, but is mostly fine as UV seams generally
|
|
* map to equal-colored parts of a texture */
|
|
for (int j = 0; j < mesh->totface_legacy; j++, mf++) {
|
|
if (ELEM(i, mf->v1, mf->v2, mf->v3, mf->v4)) {
|
|
i = j;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
mf = &mfaces[i];
|
|
}
|
|
|
|
psys_interpolate_uvs(&tf[i], mf->v4, fuv, texco);
|
|
|
|
texco[0] = texco[0] * 2.0f - 1.0f;
|
|
texco[1] = texco[1] * 2.0f - 1.0f;
|
|
texco[2] = 0.0f;
|
|
}
|
|
|
|
return 1;
|
|
}
|
|
|
|
#define SET_PARTICLE_TEXTURE(type, pvalue, texfac) \
|
|
if ((event & mtex->mapto) & type) { \
|
|
pvalue = texture_value_blend(def, pvalue, value, texfac, blend); \
|
|
} \
|
|
(void)0
|
|
|
|
#define CLAMP_PARTICLE_TEXTURE_POS(type, pvalue) \
|
|
if (event & type) { \
|
|
CLAMP(pvalue, 0.0f, 1.0f); \
|
|
} \
|
|
(void)0
|
|
|
|
#define CLAMP_WARP_PARTICLE_TEXTURE_POS(type, pvalue) \
|
|
if (event & type) { \
|
|
if (pvalue < 0.0f) { \
|
|
pvalue = 1.0f + pvalue; \
|
|
} \
|
|
CLAMP(pvalue, 0.0f, 1.0f); \
|
|
} \
|
|
(void)0
|
|
|
|
#define CLAMP_PARTICLE_TEXTURE_POSNEG(type, pvalue) \
|
|
if (event & type) { \
|
|
CLAMP(pvalue, -1.0f, 1.0f); \
|
|
} \
|
|
(void)0
|
|
|
|
static void get_cpa_texture(Mesh *mesh,
|
|
ParticleSystem *psys,
|
|
ParticleSettings *part,
|
|
ParticleData *par,
|
|
int child_index,
|
|
int face_index,
|
|
const float fw[4],
|
|
float *orco,
|
|
ParticleTexture *ptex,
|
|
int event,
|
|
float cfra)
|
|
{
|
|
MTex *mtex, **mtexp = part->mtex;
|
|
int m;
|
|
float value, rgba[4], texvec[3];
|
|
|
|
ptex->ivel = ptex->life = ptex->exist = ptex->size = ptex->damp = ptex->gravity = ptex->field =
|
|
ptex->time = ptex->clump = ptex->kink_freq = ptex->kink_amp = ptex->effector = ptex->rough1 =
|
|
ptex->rough2 = ptex->roughe = 1.0f;
|
|
ptex->twist = 1.0f;
|
|
|
|
ptex->length = 1.0f - part->randlength * psys_frand(psys, child_index + 26);
|
|
ptex->length *= part->clength_thres < psys_frand(psys, child_index + 27) ? part->clength : 1.0f;
|
|
|
|
for (m = 0; m < MAX_MTEX; m++, mtexp++) {
|
|
mtex = *mtexp;
|
|
if (mtex && mtex->tex && mtex->mapto) {
|
|
float def = mtex->def_var;
|
|
short blend = mtex->blendtype;
|
|
short texco = mtex->texco;
|
|
|
|
if (ELEM(texco, TEXCO_UV, TEXCO_ORCO) &&
|
|
(ELEM(part->from, PART_FROM_FACE, PART_FROM_VOLUME) == 0 ||
|
|
part->distr == PART_DISTR_GRID))
|
|
{
|
|
texco = TEXCO_GLOB;
|
|
}
|
|
|
|
switch (texco) {
|
|
case TEXCO_GLOB:
|
|
copy_v3_v3(texvec, par->state.co);
|
|
break;
|
|
case TEXCO_OBJECT:
|
|
copy_v3_v3(texvec, par->state.co);
|
|
if (mtex->object) {
|
|
mul_m4_v3(mtex->object->world_to_object().ptr(), texvec);
|
|
}
|
|
break;
|
|
case TEXCO_UV:
|
|
if (fw && get_particle_uv(mesh,
|
|
nullptr,
|
|
face_index,
|
|
fw,
|
|
mtex->uvname,
|
|
texvec,
|
|
(part->from == PART_FROM_VERT)))
|
|
{
|
|
break;
|
|
}
|
|
/* no break, failed to get uv's, so let's try orco's */
|
|
ATTR_FALLTHROUGH;
|
|
case TEXCO_ORCO:
|
|
copy_v3_v3(texvec, orco);
|
|
break;
|
|
case TEXCO_PARTICLE:
|
|
/* texture coordinates in range [-1, 1] */
|
|
texvec[0] = 2.0f * (cfra - par->time) / (par->dietime - par->time) - 1.0f;
|
|
texvec[1] = 0.0f;
|
|
texvec[2] = 0.0f;
|
|
break;
|
|
}
|
|
|
|
RE_texture_evaluate(mtex, texvec, 0, nullptr, false, false, &value, rgba);
|
|
|
|
if ((event & mtex->mapto) & PAMAP_ROUGH) {
|
|
ptex->rough1 = ptex->rough2 = ptex->roughe = texture_value_blend(
|
|
def, ptex->rough1, value, mtex->roughfac, blend);
|
|
}
|
|
|
|
SET_PARTICLE_TEXTURE(PAMAP_LENGTH, ptex->length, mtex->lengthfac);
|
|
SET_PARTICLE_TEXTURE(PAMAP_CLUMP, ptex->clump, mtex->clumpfac);
|
|
SET_PARTICLE_TEXTURE(PAMAP_KINK_AMP, ptex->kink_amp, mtex->kinkampfac);
|
|
SET_PARTICLE_TEXTURE(PAMAP_KINK_FREQ, ptex->kink_freq, mtex->kinkfac);
|
|
SET_PARTICLE_TEXTURE(PAMAP_DENS, ptex->exist, mtex->padensfac);
|
|
SET_PARTICLE_TEXTURE(PAMAP_TWIST, ptex->twist, mtex->twistfac);
|
|
}
|
|
}
|
|
|
|
CLAMP_PARTICLE_TEXTURE_POS(PAMAP_LENGTH, ptex->length);
|
|
CLAMP_WARP_PARTICLE_TEXTURE_POS(PAMAP_CLUMP, ptex->clump);
|
|
CLAMP_WARP_PARTICLE_TEXTURE_POS(PAMAP_KINK_AMP, ptex->kink_amp);
|
|
CLAMP_WARP_PARTICLE_TEXTURE_POS(PAMAP_KINK_FREQ, ptex->kink_freq);
|
|
CLAMP_WARP_PARTICLE_TEXTURE_POS(PAMAP_ROUGH, ptex->rough1);
|
|
CLAMP_WARP_PARTICLE_TEXTURE_POS(PAMAP_DENS, ptex->exist);
|
|
}
|
|
void psys_get_texture(
|
|
ParticleSimulationData *sim, ParticleData *pa, ParticleTexture *ptex, int event, float cfra)
|
|
{
|
|
Object *ob = sim->ob;
|
|
Mesh *mesh = (Mesh *)ob->data;
|
|
ParticleSettings *part = sim->psys->part;
|
|
MTex **mtexp = part->mtex;
|
|
MTex *mtex;
|
|
int m;
|
|
float value, rgba[4], co[3], texvec[3];
|
|
int setvars = 0;
|
|
|
|
/* initialize ptex */
|
|
ptex->ivel = ptex->life = ptex->exist = ptex->size = ptex->damp = ptex->gravity = ptex->field =
|
|
ptex->length = ptex->clump = ptex->kink_freq = ptex->kink_amp = ptex->effector =
|
|
ptex->rough1 = ptex->rough2 = ptex->roughe = 1.0f;
|
|
ptex->twist = 1.0f;
|
|
|
|
ptex->time = float(pa - sim->psys->particles) / float(sim->psys->totpart);
|
|
|
|
for (m = 0; m < MAX_MTEX; m++, mtexp++) {
|
|
mtex = *mtexp;
|
|
if (mtex && mtex->tex && mtex->mapto) {
|
|
float def = mtex->def_var;
|
|
short blend = mtex->blendtype;
|
|
short texco = mtex->texco;
|
|
|
|
if (texco == TEXCO_UV && (ELEM(part->from, PART_FROM_FACE, PART_FROM_VOLUME) == 0 ||
|
|
part->distr == PART_DISTR_GRID))
|
|
{
|
|
texco = TEXCO_GLOB;
|
|
}
|
|
|
|
switch (texco) {
|
|
case TEXCO_GLOB:
|
|
copy_v3_v3(texvec, pa->state.co);
|
|
break;
|
|
case TEXCO_OBJECT:
|
|
copy_v3_v3(texvec, pa->state.co);
|
|
if (mtex->object) {
|
|
mul_m4_v3(mtex->object->world_to_object().ptr(), texvec);
|
|
}
|
|
break;
|
|
case TEXCO_UV:
|
|
if (get_particle_uv(sim->psmd->mesh_final,
|
|
pa,
|
|
0,
|
|
pa->fuv,
|
|
mtex->uvname,
|
|
texvec,
|
|
(part->from == PART_FROM_VERT)))
|
|
{
|
|
break;
|
|
}
|
|
/* no break, failed to get uv's, so let's try orco's */
|
|
ATTR_FALLTHROUGH;
|
|
case TEXCO_ORCO:
|
|
psys_particle_on_emitter(sim->psmd,
|
|
sim->psys->part->from,
|
|
pa->num,
|
|
pa->num_dmcache,
|
|
pa->fuv,
|
|
pa->foffset,
|
|
co,
|
|
nullptr,
|
|
nullptr,
|
|
nullptr,
|
|
texvec);
|
|
|
|
BKE_mesh_texspace_ensure(mesh);
|
|
sub_v3_v3(texvec, mesh->texspace_location);
|
|
if (mesh->texspace_size[0] != 0.0f) {
|
|
texvec[0] /= mesh->texspace_size[0];
|
|
}
|
|
if (mesh->texspace_size[1] != 0.0f) {
|
|
texvec[1] /= mesh->texspace_size[1];
|
|
}
|
|
if (mesh->texspace_size[2] != 0.0f) {
|
|
texvec[2] /= mesh->texspace_size[2];
|
|
}
|
|
break;
|
|
case TEXCO_PARTICLE:
|
|
/* texture coordinates in range [-1, 1] */
|
|
texvec[0] = 2.0f * (cfra - pa->time) / (pa->dietime - pa->time) - 1.0f;
|
|
if (sim->psys->totpart > 0) {
|
|
texvec[1] = 2.0f * float(pa - sim->psys->particles) / float(sim->psys->totpart) - 1.0f;
|
|
}
|
|
else {
|
|
texvec[1] = 0.0f;
|
|
}
|
|
texvec[2] = 0.0f;
|
|
break;
|
|
}
|
|
|
|
RE_texture_evaluate(mtex, texvec, 0, nullptr, false, false, &value, rgba);
|
|
|
|
if ((event & mtex->mapto) & PAMAP_TIME) {
|
|
/* the first time has to set the base value for time regardless of blend mode */
|
|
if ((setvars & PAMAP_TIME) == 0) {
|
|
int flip = (mtex->timefac < 0.0f);
|
|
float timefac = fabsf(mtex->timefac);
|
|
ptex->time *= 1.0f - timefac;
|
|
ptex->time += timefac * ((flip) ? 1.0f - value : value);
|
|
setvars |= PAMAP_TIME;
|
|
}
|
|
else {
|
|
ptex->time = texture_value_blend(def, ptex->time, value, mtex->timefac, blend);
|
|
}
|
|
}
|
|
SET_PARTICLE_TEXTURE(PAMAP_LIFE, ptex->life, mtex->lifefac);
|
|
SET_PARTICLE_TEXTURE(PAMAP_DENS, ptex->exist, mtex->padensfac);
|
|
SET_PARTICLE_TEXTURE(PAMAP_SIZE, ptex->size, mtex->sizefac);
|
|
SET_PARTICLE_TEXTURE(PAMAP_IVEL, ptex->ivel, mtex->ivelfac);
|
|
SET_PARTICLE_TEXTURE(PAMAP_FIELD, ptex->field, mtex->fieldfac);
|
|
SET_PARTICLE_TEXTURE(PAMAP_GRAVITY, ptex->gravity, mtex->gravityfac);
|
|
SET_PARTICLE_TEXTURE(PAMAP_DAMP, ptex->damp, mtex->dampfac);
|
|
SET_PARTICLE_TEXTURE(PAMAP_LENGTH, ptex->length, mtex->lengthfac);
|
|
SET_PARTICLE_TEXTURE(PAMAP_TWIST, ptex->twist, mtex->twistfac);
|
|
}
|
|
}
|
|
|
|
CLAMP_WARP_PARTICLE_TEXTURE_POS(PAMAP_TIME, ptex->time);
|
|
CLAMP_WARP_PARTICLE_TEXTURE_POS(PAMAP_LIFE, ptex->life);
|
|
CLAMP_WARP_PARTICLE_TEXTURE_POS(PAMAP_DENS, ptex->exist);
|
|
CLAMP_PARTICLE_TEXTURE_POS(PAMAP_SIZE, ptex->size);
|
|
CLAMP_PARTICLE_TEXTURE_POSNEG(PAMAP_IVEL, ptex->ivel);
|
|
CLAMP_PARTICLE_TEXTURE_POSNEG(PAMAP_FIELD, ptex->field);
|
|
CLAMP_PARTICLE_TEXTURE_POSNEG(PAMAP_GRAVITY, ptex->gravity);
|
|
CLAMP_WARP_PARTICLE_TEXTURE_POS(PAMAP_DAMP, ptex->damp);
|
|
CLAMP_PARTICLE_TEXTURE_POS(PAMAP_LENGTH, ptex->length);
|
|
}
|
|
|
|
/************************************************/
|
|
/* Particle State */
|
|
/************************************************/
|
|
|
|
float psys_get_timestep(ParticleSimulationData *sim)
|
|
{
|
|
return 0.04f * sim->psys->part->timetweak;
|
|
}
|
|
float psys_get_child_time(
|
|
ParticleSystem *psys, ChildParticle *cpa, float cfra, float *birthtime, float *dietime)
|
|
{
|
|
ParticleSettings *part = psys->part;
|
|
float time, life;
|
|
|
|
if (part->childtype == PART_CHILD_FACES) {
|
|
int w = 0;
|
|
time = 0.0;
|
|
while (w < 4 && cpa->pa[w] >= 0) {
|
|
time += cpa->w[w] * (psys->particles + cpa->pa[w])->time;
|
|
w++;
|
|
}
|
|
|
|
life = part->lifetime * (1.0f - part->randlife * psys_frand(psys, cpa - psys->child + 25));
|
|
}
|
|
else {
|
|
ParticleData *pa = psys->particles + cpa->parent;
|
|
|
|
time = pa->time;
|
|
life = pa->lifetime;
|
|
}
|
|
|
|
if (birthtime) {
|
|
*birthtime = time;
|
|
}
|
|
if (dietime) {
|
|
*dietime = time + life;
|
|
}
|
|
|
|
return (cfra - time) / life;
|
|
}
|
|
float psys_get_child_size(ParticleSystem *psys,
|
|
ChildParticle *cpa,
|
|
float /*cfra*/,
|
|
float * /*pa_time*/)
|
|
{
|
|
ParticleSettings *part = psys->part;
|
|
float size; /* time XXX */
|
|
|
|
if (part->childtype == PART_CHILD_FACES) {
|
|
int w = 0;
|
|
size = 0.0;
|
|
while (w < 4 && cpa->pa[w] >= 0) {
|
|
size += cpa->w[w] * (psys->particles + cpa->pa[w])->size;
|
|
w++;
|
|
}
|
|
}
|
|
else {
|
|
size = psys->particles[cpa->parent].size;
|
|
}
|
|
|
|
size *= part->childsize;
|
|
|
|
if (part->childrandsize != 0.0f) {
|
|
size *= 1.0f - part->childrandsize * psys_frand(psys, cpa - psys->child + 26);
|
|
}
|
|
|
|
return size;
|
|
}
|
|
static void get_child_modifier_parameters(ParticleSettings *part,
|
|
ParticleThreadContext *ctx,
|
|
ChildParticle *cpa,
|
|
short cpa_from,
|
|
int cpa_num,
|
|
float *cpa_fuv,
|
|
float *orco,
|
|
ParticleTexture *ptex)
|
|
{
|
|
ParticleSystem *psys = ctx->sim.psys;
|
|
int i = cpa - psys->child;
|
|
|
|
get_cpa_texture(ctx->mesh,
|
|
psys,
|
|
part,
|
|
psys->particles + cpa->pa[0],
|
|
i,
|
|
cpa_num,
|
|
cpa_fuv,
|
|
orco,
|
|
ptex,
|
|
PAMAP_DENS | PAMAP_CHILD,
|
|
psys->cfra);
|
|
|
|
if (ptex->exist < psys_frand(psys, i + 24)) {
|
|
return;
|
|
}
|
|
|
|
if (ctx->vg_length) {
|
|
ptex->length *= psys_interpolate_value_from_verts(
|
|
ctx->mesh, cpa_from, cpa_num, cpa_fuv, ctx->vg_length);
|
|
}
|
|
if (ctx->vg_clump) {
|
|
ptex->clump *= psys_interpolate_value_from_verts(
|
|
ctx->mesh, cpa_from, cpa_num, cpa_fuv, ctx->vg_clump);
|
|
}
|
|
if (ctx->vg_kink) {
|
|
ptex->kink_freq *= psys_interpolate_value_from_verts(
|
|
ctx->mesh, cpa_from, cpa_num, cpa_fuv, ctx->vg_kink);
|
|
}
|
|
if (ctx->vg_rough1) {
|
|
ptex->rough1 *= psys_interpolate_value_from_verts(
|
|
ctx->mesh, cpa_from, cpa_num, cpa_fuv, ctx->vg_rough1);
|
|
}
|
|
if (ctx->vg_rough2) {
|
|
ptex->rough2 *= psys_interpolate_value_from_verts(
|
|
ctx->mesh, cpa_from, cpa_num, cpa_fuv, ctx->vg_rough2);
|
|
}
|
|
if (ctx->vg_roughe) {
|
|
ptex->roughe *= psys_interpolate_value_from_verts(
|
|
ctx->mesh, cpa_from, cpa_num, cpa_fuv, ctx->vg_roughe);
|
|
}
|
|
if (ctx->vg_effector) {
|
|
ptex->effector *= psys_interpolate_value_from_verts(
|
|
ctx->mesh, cpa_from, cpa_num, cpa_fuv, ctx->vg_effector);
|
|
}
|
|
if (ctx->vg_twist) {
|
|
ptex->twist *= psys_interpolate_value_from_verts(
|
|
ctx->mesh, cpa_from, cpa_num, cpa_fuv, ctx->vg_twist);
|
|
}
|
|
}
|
|
void psys_get_particle_on_path(ParticleSimulationData *sim,
|
|
int p,
|
|
ParticleKey *state,
|
|
const bool vel)
|
|
{
|
|
PARTICLE_PSMD;
|
|
ParticleSystem *psys = sim->psys;
|
|
ParticleSettings *part = sim->psys->part;
|
|
Material *ma = BKE_object_material_get(sim->ob, part->omat);
|
|
ParticleData *pa;
|
|
ChildParticle *cpa;
|
|
ParticleTexture ptex;
|
|
ParticleKey *par = nullptr, keys[4], tstate;
|
|
ParticleThreadContext ctx; /* fake thread context for child modifiers */
|
|
ParticleInterpolationData pind;
|
|
|
|
float t;
|
|
float co[3], orco[3];
|
|
float hairmat[4][4];
|
|
int totpart = psys->totpart;
|
|
int totchild = psys->totchild;
|
|
short between = 0, edit = 0;
|
|
|
|
int keyed = part->phystype & PART_PHYS_KEYED && psys->flag & PSYS_KEYED;
|
|
int cached = !keyed && part->type != PART_HAIR;
|
|
|
|
float *cpa_fuv;
|
|
int cpa_num;
|
|
short cpa_from;
|
|
|
|
/* initialize keys to zero */
|
|
memset(keys, 0, sizeof(ParticleKey[4]));
|
|
|
|
t = state->time;
|
|
CLAMP(t, 0.0f, 1.0f);
|
|
|
|
if (p < totpart) {
|
|
/* interpolate pathcache directly if it exist */
|
|
if (psys->pathcache) {
|
|
ParticleCacheKey result;
|
|
interpolate_pathcache(psys->pathcache[p], t, &result);
|
|
copy_v3_v3(state->co, result.co);
|
|
copy_v3_v3(state->vel, result.vel);
|
|
copy_qt_qt(state->rot, result.rot);
|
|
}
|
|
/* otherwise interpolate with other means */
|
|
else {
|
|
pa = psys->particles + p;
|
|
|
|
pind.keyed = keyed;
|
|
pind.cache = cached ? psys->pointcache : nullptr;
|
|
pind.epoint = nullptr;
|
|
pind.bspline = (psys->part->flag & PART_HAIR_BSPLINE);
|
|
/* `pind.dm` disabled in edit-mode means we don't get effectors taken into
|
|
* account when subdividing for instance. */
|
|
pind.mesh = psys_in_edit_mode(sim->depsgraph, psys) ?
|
|
nullptr :
|
|
psys->hair_out_mesh; /* XXX(@sybren): EEK. */
|
|
init_particle_interpolation(sim->ob, psys, pa, &pind);
|
|
do_particle_interpolation(psys, p, pa, t, &pind, state);
|
|
|
|
if (pind.mesh) {
|
|
mul_m4_v3(sim->ob->object_to_world().ptr(), state->co);
|
|
mul_mat3_m4_v3(sim->ob->object_to_world().ptr(), state->vel);
|
|
}
|
|
else if (!keyed && !cached && !(psys->flag & PSYS_GLOBAL_HAIR)) {
|
|
if ((pa->flag & PARS_REKEY) == 0) {
|
|
psys_mat_hair_to_global(sim->ob, sim->psmd->mesh_final, part->from, pa, hairmat);
|
|
mul_m4_v3(hairmat, state->co);
|
|
mul_mat3_m4_v3(hairmat, state->vel);
|
|
|
|
if (sim->psys->effectors && (part->flag & PART_CHILD_GUIDE) == 0) {
|
|
do_guides(
|
|
sim->depsgraph, sim->psys->part, sim->psys->effectors, state, p, state->time);
|
|
/* TODO: proper velocity handling */
|
|
}
|
|
|
|
if (psys->lattice_deform_data && edit == 0) {
|
|
BKE_lattice_deform_data_eval_co(
|
|
psys->lattice_deform_data, state->co, psys->lattice_strength);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else if (totchild) {
|
|
// invert_m4_m4(imat, ob->object_to_world().ptr());
|
|
|
|
/* interpolate childcache directly if it exists */
|
|
if (psys->childcache) {
|
|
ParticleCacheKey result;
|
|
interpolate_pathcache(psys->childcache[p - totpart], t, &result);
|
|
copy_v3_v3(state->co, result.co);
|
|
copy_v3_v3(state->vel, result.vel);
|
|
copy_qt_qt(state->rot, result.rot);
|
|
}
|
|
else {
|
|
float par_co[3], par_orco[3];
|
|
|
|
cpa = psys->child + p - totpart;
|
|
|
|
if (state->time < 0.0f) {
|
|
t = psys_get_child_time(psys, cpa, -state->time, nullptr, nullptr);
|
|
}
|
|
|
|
if (part->childtype == PART_CHILD_FACES) {
|
|
/* part->parents could still be 0 so we can't test with totparent */
|
|
between = 1;
|
|
}
|
|
if (between) {
|
|
int w = 0;
|
|
float foffset;
|
|
|
|
/* get parent states */
|
|
while (w < 4 && cpa->pa[w] >= 0) {
|
|
keys[w].time = state->time;
|
|
psys_get_particle_on_path(sim, cpa->pa[w], keys + w, true);
|
|
w++;
|
|
}
|
|
|
|
/* get the original coordinates (orco) for texture usage */
|
|
cpa_num = cpa->num;
|
|
|
|
foffset = cpa->foffset;
|
|
cpa_fuv = cpa->fuv;
|
|
cpa_from = PART_FROM_FACE;
|
|
|
|
psys_particle_on_emitter(psmd,
|
|
cpa_from,
|
|
cpa_num,
|
|
DMCACHE_ISCHILD,
|
|
cpa->fuv,
|
|
foffset,
|
|
co,
|
|
nullptr,
|
|
nullptr,
|
|
nullptr,
|
|
orco);
|
|
|
|
/* We need to save the actual root position of the child for
|
|
* positioning it accurately to the surface of the emitter. */
|
|
// copy_v3_v3(cpa_1st, co);
|
|
|
|
// mul_m4_v3(ob->object_to_world().ptr(), cpa_1st);
|
|
|
|
pa = psys->particles + cpa->parent;
|
|
|
|
psys_particle_on_emitter(psmd,
|
|
part->from,
|
|
pa->num,
|
|
pa->num_dmcache,
|
|
pa->fuv,
|
|
pa->foffset,
|
|
par_co,
|
|
nullptr,
|
|
nullptr,
|
|
nullptr,
|
|
par_orco);
|
|
if (part->type == PART_HAIR) {
|
|
psys_mat_hair_to_global(sim->ob, sim->psmd->mesh_final, psys->part->from, pa, hairmat);
|
|
}
|
|
else {
|
|
unit_m4(hairmat);
|
|
}
|
|
|
|
pa = nullptr;
|
|
}
|
|
else {
|
|
/* get the parent state */
|
|
keys->time = state->time;
|
|
psys_get_particle_on_path(sim, cpa->parent, keys, true);
|
|
|
|
/* get the original coordinates (orco) for texture usage */
|
|
pa = psys->particles + cpa->parent;
|
|
|
|
cpa_from = part->from;
|
|
cpa_num = pa->num;
|
|
cpa_fuv = pa->fuv;
|
|
|
|
psys_particle_on_emitter(psmd,
|
|
part->from,
|
|
pa->num,
|
|
pa->num_dmcache,
|
|
pa->fuv,
|
|
pa->foffset,
|
|
par_co,
|
|
nullptr,
|
|
nullptr,
|
|
nullptr,
|
|
par_orco);
|
|
if (part->type == PART_HAIR) {
|
|
psys_particle_on_emitter(psmd,
|
|
cpa_from,
|
|
cpa_num,
|
|
DMCACHE_ISCHILD,
|
|
cpa_fuv,
|
|
pa->foffset,
|
|
co,
|
|
nullptr,
|
|
nullptr,
|
|
nullptr,
|
|
orco);
|
|
psys_mat_hair_to_global(sim->ob, sim->psmd->mesh_final, psys->part->from, pa, hairmat);
|
|
}
|
|
else {
|
|
copy_v3_v3(orco, cpa->fuv);
|
|
unit_m4(hairmat);
|
|
}
|
|
}
|
|
|
|
/* get different child parameters from textures & vgroups */
|
|
memset(&ctx, 0, sizeof(ParticleThreadContext));
|
|
ctx.sim = *sim;
|
|
ctx.mesh = psmd->mesh_final;
|
|
ctx.ma = ma;
|
|
/* TODO: assign vertex groups */
|
|
get_child_modifier_parameters(part, &ctx, cpa, cpa_from, cpa_num, cpa_fuv, orco, &ptex);
|
|
|
|
if (between) {
|
|
int w = 0;
|
|
|
|
state->co[0] = state->co[1] = state->co[2] = 0.0f;
|
|
state->vel[0] = state->vel[1] = state->vel[2] = 0.0f;
|
|
|
|
/* child position is the weighted sum of parent positions */
|
|
while (w < 4 && cpa->pa[w] >= 0) {
|
|
state->co[0] += cpa->w[w] * keys[w].co[0];
|
|
state->co[1] += cpa->w[w] * keys[w].co[1];
|
|
state->co[2] += cpa->w[w] * keys[w].co[2];
|
|
|
|
state->vel[0] += cpa->w[w] * keys[w].vel[0];
|
|
state->vel[1] += cpa->w[w] * keys[w].vel[1];
|
|
state->vel[2] += cpa->w[w] * keys[w].vel[2];
|
|
w++;
|
|
}
|
|
/* apply offset for correct positioning */
|
|
// add_v3_v3(state->co, cpa_1st);
|
|
}
|
|
else {
|
|
/* offset the child from the parent position */
|
|
offset_child(cpa, keys, keys->rot, state, part->childflat, part->childrad);
|
|
}
|
|
|
|
par = keys;
|
|
|
|
if (vel) {
|
|
copy_particle_key(&tstate, state, 1);
|
|
}
|
|
|
|
/* apply different deformations to the child path */
|
|
ParticleChildModifierContext modifier_ctx = {nullptr};
|
|
modifier_ctx.thread_ctx = nullptr;
|
|
modifier_ctx.sim = sim;
|
|
modifier_ctx.ptex = &ptex;
|
|
modifier_ctx.cpa = cpa;
|
|
modifier_ctx.orco = orco;
|
|
modifier_ctx.par_co = par->co;
|
|
modifier_ctx.par_vel = par->vel;
|
|
modifier_ctx.par_rot = par->rot;
|
|
modifier_ctx.par_orco = par_orco;
|
|
modifier_ctx.parent_keys = psys->childcache ? psys->childcache[p - totpart] : nullptr;
|
|
do_child_modifiers(&modifier_ctx, hairmat, state, t);
|
|
|
|
/* try to estimate correct velocity */
|
|
if (vel) {
|
|
ParticleKey tstate_tmp;
|
|
float length = len_v3(state->vel);
|
|
|
|
if (t >= 0.001f) {
|
|
tstate_tmp.time = t - 0.001f;
|
|
psys_get_particle_on_path(sim, p, &tstate_tmp, false);
|
|
sub_v3_v3v3(state->vel, state->co, tstate_tmp.co);
|
|
normalize_v3(state->vel);
|
|
}
|
|
else {
|
|
tstate_tmp.time = t + 0.001f;
|
|
psys_get_particle_on_path(sim, p, &tstate_tmp, false);
|
|
sub_v3_v3v3(state->vel, tstate_tmp.co, state->co);
|
|
normalize_v3(state->vel);
|
|
}
|
|
|
|
mul_v3_fl(state->vel, length);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
bool psys_get_particle_state(ParticleSimulationData *sim,
|
|
int p,
|
|
ParticleKey *state,
|
|
const bool always)
|
|
{
|
|
ParticleSystem *psys = sim->psys;
|
|
ParticleSettings *part = psys->part;
|
|
ParticleData *pa = nullptr;
|
|
ChildParticle *cpa = nullptr;
|
|
float cfra;
|
|
int totpart = psys->totpart;
|
|
float timestep = psys_get_timestep(sim);
|
|
|
|
/* negative time means "use current time" */
|
|
cfra = state->time > 0 ? state->time : DEG_get_ctime(sim->depsgraph);
|
|
|
|
if (p >= totpart) {
|
|
if (!psys->totchild) {
|
|
return false;
|
|
}
|
|
|
|
if (part->childtype == PART_CHILD_FACES) {
|
|
if (!(psys->flag & PSYS_KEYED)) {
|
|
return false;
|
|
}
|
|
|
|
cpa = psys->child + p - totpart;
|
|
|
|
state->time = psys_get_child_time(psys, cpa, cfra, nullptr, nullptr);
|
|
|
|
if (!always) {
|
|
if ((state->time < 0.0f && !(part->flag & PART_UNBORN)) ||
|
|
(state->time > 1.0f && !(part->flag & PART_DIED)))
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
|
|
state->time = (cfra - (part->sta + (part->end - part->sta) * psys_frand(psys, p + 23))) /
|
|
(part->lifetime * psys_frand(psys, p + 24));
|
|
|
|
psys_get_particle_on_path(sim, p, state, true);
|
|
return true;
|
|
}
|
|
|
|
cpa = sim->psys->child + p - totpart;
|
|
pa = sim->psys->particles + cpa->parent;
|
|
}
|
|
else {
|
|
pa = sim->psys->particles + p;
|
|
}
|
|
|
|
if (pa) {
|
|
if (!always) {
|
|
if ((cfra < pa->time && (part->flag & PART_UNBORN) == 0) ||
|
|
(cfra >= pa->dietime && (part->flag & PART_DIED) == 0))
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
|
|
cfra = std::min(cfra, pa->dietime);
|
|
}
|
|
|
|
if (sim->psys->flag & PSYS_KEYED) {
|
|
state->time = -cfra;
|
|
psys_get_particle_on_path(sim, p, state, true);
|
|
return true;
|
|
}
|
|
|
|
if (cpa) {
|
|
float mat[4][4];
|
|
ParticleKey *key1;
|
|
float t = (cfra - pa->time) / pa->lifetime;
|
|
const float par_orco[3] = {0.0f, 0.0f, 0.0f};
|
|
|
|
key1 = &pa->state;
|
|
offset_child(cpa, key1, key1->rot, state, part->childflat, part->childrad);
|
|
|
|
CLAMP(t, 0.0f, 1.0f);
|
|
|
|
unit_m4(mat);
|
|
ParticleChildModifierContext modifier_ctx = {nullptr};
|
|
modifier_ctx.thread_ctx = nullptr;
|
|
modifier_ctx.sim = sim;
|
|
modifier_ctx.ptex = nullptr;
|
|
modifier_ctx.cpa = cpa;
|
|
modifier_ctx.orco = cpa->fuv;
|
|
modifier_ctx.par_co = key1->co;
|
|
modifier_ctx.par_vel = key1->vel;
|
|
modifier_ctx.par_rot = key1->rot;
|
|
modifier_ctx.par_orco = par_orco;
|
|
modifier_ctx.parent_keys = psys->childcache ? psys->childcache[p - totpart] : nullptr;
|
|
|
|
do_child_modifiers(&modifier_ctx, mat, state, t);
|
|
|
|
if (psys->lattice_deform_data) {
|
|
BKE_lattice_deform_data_eval_co(
|
|
psys->lattice_deform_data, state->co, psys->lattice_strength);
|
|
}
|
|
}
|
|
else {
|
|
if (pa->state.time == cfra || ELEM(part->phystype, PART_PHYS_NO, PART_PHYS_KEYED)) {
|
|
copy_particle_key(state, &pa->state, 1);
|
|
}
|
|
else if (pa->prev_state.time == cfra) {
|
|
copy_particle_key(state, &pa->prev_state, 1);
|
|
}
|
|
else {
|
|
float dfra, frs_sec = sim->scene->r.frs_sec;
|
|
/* let's interpolate to try to be as accurate as possible */
|
|
if (pa->state.time + 2.0f >= state->time && pa->prev_state.time - 2.0f <= state->time) {
|
|
if (pa->prev_state.time >= pa->state.time || pa->prev_state.time < 0.0f) {
|
|
/* prev_state is wrong so let's not use it,
|
|
* this can happen at frames 1, 0 or particle birth. */
|
|
dfra = state->time - pa->state.time;
|
|
|
|
copy_particle_key(state, &pa->state, 1);
|
|
|
|
madd_v3_v3v3fl(state->co, state->co, state->vel, dfra / frs_sec);
|
|
}
|
|
else {
|
|
ParticleKey keys[4];
|
|
float keytime;
|
|
|
|
copy_particle_key(keys + 1, &pa->prev_state, 1);
|
|
copy_particle_key(keys + 2, &pa->state, 1);
|
|
|
|
dfra = keys[2].time - keys[1].time;
|
|
|
|
keytime = (state->time - keys[1].time) / dfra;
|
|
|
|
/* convert velocity to timestep size */
|
|
mul_v3_fl(keys[1].vel, dfra * timestep);
|
|
mul_v3_fl(keys[2].vel, dfra * timestep);
|
|
|
|
psys_interpolate_particle(-1, keys, keytime, state, true);
|
|
|
|
/* convert back to real velocity */
|
|
mul_v3_fl(state->vel, 1.0f / (dfra * timestep));
|
|
|
|
interp_v3_v3v3(state->ave, keys[1].ave, keys[2].ave, keytime);
|
|
interp_qt_qtqt(state->rot, keys[1].rot, keys[2].rot, keytime);
|
|
}
|
|
}
|
|
else if (pa->state.time + 1.0f >= state->time && pa->state.time - 1.0f <= state->time) {
|
|
/* linear interpolation using only pa->state */
|
|
|
|
dfra = state->time - pa->state.time;
|
|
|
|
copy_particle_key(state, &pa->state, 1);
|
|
|
|
madd_v3_v3v3fl(state->co, state->co, state->vel, dfra / frs_sec);
|
|
}
|
|
else {
|
|
/* Extrapolating over big ranges is not accurate
|
|
* so let's just give something close to reasonable back. */
|
|
copy_particle_key(state, &pa->state, 0);
|
|
}
|
|
}
|
|
|
|
if (sim->psys->lattice_deform_data) {
|
|
BKE_lattice_deform_data_eval_co(
|
|
sim->psys->lattice_deform_data, state->co, psys->lattice_strength);
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
void psys_get_dupli_texture(ParticleSystem *psys,
|
|
ParticleSettings *part,
|
|
ParticleSystemModifierData *psmd,
|
|
ParticleData *pa,
|
|
ChildParticle *cpa,
|
|
float uv[2],
|
|
float orco[3])
|
|
{
|
|
float loc[3];
|
|
int num;
|
|
|
|
/* XXX: on checking '(psmd->dm != nullptr)'
|
|
* This is incorrect but needed for meta-ball evaluation.
|
|
* Ideally this would be calculated via the depsgraph, however with meta-balls,
|
|
* the entire scenes dupli's are scanned, which also looks into uncalculated data.
|
|
*
|
|
* For now just include this workaround as an alternative to crashing,
|
|
* but longer term meta-balls should behave in a more manageable way, see: #46622. */
|
|
|
|
uv[0] = uv[1] = 0.0f;
|
|
|
|
/* Grid distribution doesn't support UV or emit from vertex mode */
|
|
bool is_grid = (part->distr == PART_DISTR_GRID && part->from != PART_FROM_VERT);
|
|
|
|
if (cpa) {
|
|
if ((part->childtype == PART_CHILD_FACES) && (psmd->mesh_final != nullptr)) {
|
|
if (!is_grid) {
|
|
CustomData *mtf_data = &psmd->mesh_final->fdata_legacy;
|
|
const int uv_idx = CustomData_get_render_layer(mtf_data, CD_MTFACE);
|
|
|
|
if (uv_idx >= 0) {
|
|
const MTFace *mtface = static_cast<const MTFace *>(
|
|
CustomData_get_layer_n(mtf_data, CD_MTFACE, uv_idx));
|
|
if (mtface != nullptr) {
|
|
const MFace *mface = static_cast<const MFace *>(
|
|
CustomData_get_for_write(&psmd->mesh_final->fdata_legacy,
|
|
cpa->num,
|
|
CD_MFACE,
|
|
psmd->mesh_final->totface_legacy));
|
|
mtface += cpa->num;
|
|
psys_interpolate_uvs(mtface, mface->v4, cpa->fuv, uv);
|
|
}
|
|
}
|
|
}
|
|
|
|
psys_particle_on_emitter(psmd,
|
|
PART_FROM_FACE,
|
|
cpa->num,
|
|
DMCACHE_ISCHILD,
|
|
cpa->fuv,
|
|
cpa->foffset,
|
|
loc,
|
|
nullptr,
|
|
nullptr,
|
|
nullptr,
|
|
orco);
|
|
return;
|
|
}
|
|
|
|
pa = psys->particles + cpa->pa[0];
|
|
}
|
|
|
|
if ((part->from == PART_FROM_FACE) && (psmd->mesh_final != nullptr) && !is_grid) {
|
|
num = pa->num_dmcache;
|
|
|
|
if (num == DMCACHE_NOTFOUND) {
|
|
num = pa->num;
|
|
}
|
|
|
|
if (num >= psmd->mesh_final->totface_legacy) {
|
|
/* happens when simplify is enabled
|
|
* gives invalid coords but would crash otherwise */
|
|
num = DMCACHE_NOTFOUND;
|
|
}
|
|
|
|
if (!ELEM(num, DMCACHE_NOTFOUND, DMCACHE_ISCHILD)) {
|
|
CustomData *mtf_data = &psmd->mesh_final->fdata_legacy;
|
|
const int uv_idx = CustomData_get_render_layer(mtf_data, CD_MTFACE);
|
|
|
|
if (uv_idx >= 0) {
|
|
const MTFace *mtface = static_cast<const MTFace *>(
|
|
CustomData_get_layer_n(mtf_data, CD_MTFACE, uv_idx));
|
|
const MFace *mface = static_cast<const MFace *>(CustomData_get_for_write(
|
|
&psmd->mesh_final->fdata_legacy, num, CD_MFACE, psmd->mesh_final->totface_legacy));
|
|
mtface += num;
|
|
psys_interpolate_uvs(mtface, mface->v4, pa->fuv, uv);
|
|
}
|
|
}
|
|
}
|
|
|
|
psys_particle_on_emitter(psmd,
|
|
part->from,
|
|
pa->num,
|
|
pa->num_dmcache,
|
|
pa->fuv,
|
|
pa->foffset,
|
|
loc,
|
|
nullptr,
|
|
nullptr,
|
|
nullptr,
|
|
orco);
|
|
}
|
|
|
|
void psys_get_dupli_path_transform(ParticleSimulationData *sim,
|
|
ParticleData *pa,
|
|
ChildParticle *cpa,
|
|
ParticleCacheKey *cache,
|
|
float mat[4][4],
|
|
float *scale)
|
|
{
|
|
Object *ob = sim->ob;
|
|
ParticleSystem *psys = sim->psys;
|
|
ParticleSystemModifierData *psmd = sim->psmd;
|
|
float loc[3], nor[3], vec[3], side[3], len;
|
|
float xvec[3] = {-1.0, 0.0, 0.0}, nmat[3][3];
|
|
|
|
sub_v3_v3v3(vec, (cache + cache->segments)->co, cache->co);
|
|
len = normalize_v3(vec);
|
|
|
|
if (pa == nullptr && psys->part->childflat != PART_CHILD_FACES) {
|
|
pa = psys->particles + cpa->pa[0];
|
|
}
|
|
|
|
if (pa) {
|
|
psys_particle_on_emitter(psmd,
|
|
sim->psys->part->from,
|
|
pa->num,
|
|
pa->num_dmcache,
|
|
pa->fuv,
|
|
pa->foffset,
|
|
loc,
|
|
nor,
|
|
nullptr,
|
|
nullptr,
|
|
nullptr);
|
|
}
|
|
else {
|
|
psys_particle_on_emitter(psmd,
|
|
PART_FROM_FACE,
|
|
cpa->num,
|
|
DMCACHE_ISCHILD,
|
|
cpa->fuv,
|
|
cpa->foffset,
|
|
loc,
|
|
nor,
|
|
nullptr,
|
|
nullptr,
|
|
nullptr);
|
|
}
|
|
|
|
if (psys->part->rotmode == PART_ROT_VEL) {
|
|
transpose_m3_m4(nmat, ob->world_to_object().ptr());
|
|
mul_m3_v3(nmat, nor);
|
|
normalize_v3(nor);
|
|
|
|
/* make sure that we get a proper side vector */
|
|
if (fabsf(dot_v3v3(nor, vec)) > 0.999999f) {
|
|
if (fabsf(dot_v3v3(nor, xvec)) > 0.999999f) {
|
|
nor[0] = 0.0f;
|
|
nor[1] = 1.0f;
|
|
nor[2] = 0.0f;
|
|
}
|
|
else {
|
|
nor[0] = 1.0f;
|
|
nor[1] = 0.0f;
|
|
nor[2] = 0.0f;
|
|
}
|
|
}
|
|
cross_v3_v3v3(side, nor, vec);
|
|
normalize_v3(side);
|
|
|
|
/* rotate side vector around vec */
|
|
if (psys->part->phasefac != 0) {
|
|
float q_phase[4];
|
|
float phasefac = psys->part->phasefac;
|
|
if (psys->part->randphasefac != 0.0f) {
|
|
phasefac += psys->part->randphasefac * psys_frand(psys, (pa - psys->particles) + 20);
|
|
}
|
|
axis_angle_to_quat(q_phase, vec, phasefac * float(M_PI));
|
|
|
|
mul_qt_v3(q_phase, side);
|
|
}
|
|
|
|
cross_v3_v3v3(nor, vec, side);
|
|
|
|
unit_m4(mat);
|
|
copy_v3_v3(mat[0], vec);
|
|
copy_v3_v3(mat[1], side);
|
|
copy_v3_v3(mat[2], nor);
|
|
}
|
|
else {
|
|
quat_to_mat4(mat, pa->state.rot);
|
|
}
|
|
|
|
*scale = len;
|
|
}
|
|
|
|
void psys_apply_hair_lattice(Depsgraph *depsgraph, Scene *scene, Object *ob, ParticleSystem *psys)
|
|
{
|
|
ParticleSimulationData sim = {nullptr};
|
|
sim.depsgraph = depsgraph;
|
|
sim.scene = scene;
|
|
sim.ob = ob;
|
|
sim.psys = psys;
|
|
sim.psmd = psys_get_modifier(ob, psys);
|
|
|
|
psys_sim_data_init(&sim);
|
|
|
|
if (psys->lattice_deform_data) {
|
|
ParticleData *pa = psys->particles;
|
|
HairKey *hkey;
|
|
int p, h;
|
|
float hairmat[4][4], imat[4][4];
|
|
|
|
for (p = 0; p < psys->totpart; p++, pa++) {
|
|
psys_mat_hair_to_global(sim.ob, sim.psmd->mesh_final, psys->part->from, pa, hairmat);
|
|
invert_m4_m4(imat, hairmat);
|
|
|
|
hkey = pa->hair;
|
|
for (h = 0; h < pa->totkey; h++, hkey++) {
|
|
mul_m4_v3(hairmat, hkey->co);
|
|
BKE_lattice_deform_data_eval_co(
|
|
psys->lattice_deform_data, hkey->co, psys->lattice_strength);
|
|
mul_m4_v3(imat, hkey->co);
|
|
}
|
|
}
|
|
|
|
/* protect the applied shape */
|
|
psys->flag |= PSYS_EDITED;
|
|
}
|
|
|
|
psys_sim_data_free(&sim);
|
|
}
|
|
|
|
/* Draw Engine */
|
|
|
|
void (*BKE_particle_batch_cache_dirty_tag_cb)(ParticleSystem *psys, int mode) = nullptr;
|
|
void (*BKE_particle_batch_cache_free_cb)(ParticleSystem *psys) = nullptr;
|
|
|
|
void BKE_particle_batch_cache_dirty_tag(ParticleSystem *psys, int mode)
|
|
{
|
|
if (psys->batch_cache) {
|
|
BKE_particle_batch_cache_dirty_tag_cb(psys, mode);
|
|
}
|
|
}
|
|
void BKE_particle_batch_cache_free(ParticleSystem *psys)
|
|
{
|
|
if (psys->batch_cache) {
|
|
BKE_particle_batch_cache_free_cb(psys);
|
|
}
|
|
}
|
|
|
|
void BKE_particle_system_blend_write(BlendWriter *writer, ListBase *particles)
|
|
{
|
|
LISTBASE_FOREACH (ParticleSystem *, psys, particles) {
|
|
BLO_write_struct(writer, ParticleSystem, psys);
|
|
|
|
if (psys->particles) {
|
|
BLO_write_struct_array(writer, ParticleData, psys->totpart, psys->particles);
|
|
|
|
if (psys->particles->hair) {
|
|
ParticleData *pa = psys->particles;
|
|
|
|
for (int a = 0; a < psys->totpart; a++, pa++) {
|
|
BLO_write_struct_array(writer, HairKey, pa->totkey, pa->hair);
|
|
}
|
|
}
|
|
|
|
if (psys->particles->boid && (psys->part->phystype == PART_PHYS_BOIDS)) {
|
|
BLO_write_struct_array(writer, BoidParticle, psys->totpart, psys->particles->boid);
|
|
}
|
|
|
|
if (psys->part->fluid && (psys->part->phystype == PART_PHYS_FLUID) &&
|
|
(psys->part->fluid->flag & SPH_VISCOELASTIC_SPRINGS))
|
|
{
|
|
BLO_write_struct_array(
|
|
writer, ParticleSpring, psys->tot_fluidsprings, psys->fluid_springs);
|
|
}
|
|
}
|
|
LISTBASE_FOREACH (ParticleTarget *, pt, &psys->targets) {
|
|
BLO_write_struct(writer, ParticleTarget, pt);
|
|
}
|
|
|
|
if (psys->child) {
|
|
BLO_write_struct_array(writer, ChildParticle, psys->totchild, psys->child);
|
|
}
|
|
|
|
if (psys->clmd) {
|
|
BLO_write_struct(writer, ClothModifierData, psys->clmd);
|
|
BLO_write_struct(writer, ClothSimSettings, psys->clmd->sim_parms);
|
|
BLO_write_struct(writer, ClothCollSettings, psys->clmd->coll_parms);
|
|
}
|
|
|
|
BKE_ptcache_blend_write(writer, &psys->ptcaches);
|
|
}
|
|
}
|
|
|
|
void BKE_particle_system_blend_read_data(BlendDataReader *reader, ListBase *particles)
|
|
{
|
|
ParticleData *pa;
|
|
int a;
|
|
|
|
LISTBASE_FOREACH (ParticleSystem *, psys, particles) {
|
|
BLO_read_struct_array(reader, ParticleData, psys->totpart, &psys->particles);
|
|
|
|
if (psys->particles && psys->particles->hair) {
|
|
for (a = 0, pa = psys->particles; a < psys->totpart; a++, pa++) {
|
|
BLO_read_struct_array(reader, HairKey, pa->totkey, &pa->hair);
|
|
}
|
|
}
|
|
|
|
if (psys->particles && psys->particles->keys) {
|
|
for (a = 0, pa = psys->particles; a < psys->totpart; a++, pa++) {
|
|
pa->keys = nullptr;
|
|
pa->totkey = 0;
|
|
}
|
|
|
|
psys->flag &= ~PSYS_KEYED;
|
|
}
|
|
|
|
if (psys->particles && psys->particles->boid) {
|
|
pa = psys->particles;
|
|
BLO_read_struct_array(reader, BoidParticle, psys->totpart, &pa->boid);
|
|
|
|
/* This is purely runtime data, but still can be an issue if left dangling. */
|
|
pa->boid->ground = nullptr;
|
|
|
|
for (a = 1, pa++; a < psys->totpart; a++, pa++) {
|
|
pa->boid = (pa - 1)->boid + 1;
|
|
pa->boid->ground = nullptr;
|
|
}
|
|
}
|
|
else if (psys->particles) {
|
|
for (a = 0, pa = psys->particles; a < psys->totpart; a++, pa++) {
|
|
pa->boid = nullptr;
|
|
}
|
|
}
|
|
|
|
BLO_read_struct_array(reader, ParticleSpring, psys->tot_fluidsprings, &psys->fluid_springs);
|
|
|
|
BLO_read_struct_array(reader, ChildParticle, psys->totchild, &psys->child);
|
|
psys->effectors = nullptr;
|
|
|
|
BLO_read_struct_list(reader, ParticleTarget, &psys->targets);
|
|
|
|
psys->edit = nullptr;
|
|
psys->free_edit = nullptr;
|
|
psys->pathcache = nullptr;
|
|
psys->childcache = nullptr;
|
|
BLI_listbase_clear(&psys->pathcachebufs);
|
|
BLI_listbase_clear(&psys->childcachebufs);
|
|
psys->pdd = nullptr;
|
|
|
|
if (psys->clmd) {
|
|
BLO_read_struct(reader, ClothModifierData, &psys->clmd);
|
|
psys->clmd->clothObject = nullptr;
|
|
psys->clmd->hairdata = nullptr;
|
|
|
|
BLO_read_struct(reader, ClothSimSettings, &psys->clmd->sim_parms);
|
|
BLO_read_struct(reader, ClothCollSettings, &psys->clmd->coll_parms);
|
|
|
|
if (psys->clmd->sim_parms) {
|
|
psys->clmd->sim_parms->effector_weights = nullptr;
|
|
if (psys->clmd->sim_parms->presets > 10) {
|
|
psys->clmd->sim_parms->presets = 0;
|
|
}
|
|
}
|
|
|
|
psys->hair_in_mesh = psys->hair_out_mesh = nullptr;
|
|
psys->clmd->solver_result = nullptr;
|
|
}
|
|
|
|
BKE_ptcache_blend_read_data(reader, &psys->ptcaches, &psys->pointcache, 0);
|
|
if (psys->clmd) {
|
|
psys->clmd->point_cache = psys->pointcache;
|
|
}
|
|
|
|
psys->tree = nullptr;
|
|
psys->bvhtree = nullptr;
|
|
|
|
psys->orig_psys = nullptr;
|
|
psys->batch_cache = nullptr;
|
|
}
|
|
}
|
|
|
|
void BKE_particle_system_blend_read_after_liblink(BlendLibReader * /*reader*/,
|
|
Object *ob,
|
|
ID * /*id*/,
|
|
ListBase *particles)
|
|
{
|
|
LISTBASE_FOREACH_MUTABLE (ParticleSystem *, psys, particles) {
|
|
if (psys->part) {
|
|
if (psys->clmd) {
|
|
/* XXX(@ideasman42): from reading existing code this seems correct but intended usage
|
|
* of point-cache with cloth should be added in #ParticleSystem. */
|
|
psys->clmd->point_cache = psys->pointcache;
|
|
psys->clmd->ptcaches.first = psys->clmd->ptcaches.last = nullptr;
|
|
psys->clmd->modifier.error = nullptr;
|
|
}
|
|
}
|
|
else {
|
|
/* Particle modifier must be removed before particle system. */
|
|
ParticleSystemModifierData *psmd = psys_get_modifier(ob, psys);
|
|
BKE_modifier_remove_from_list(ob, (ModifierData *)psmd);
|
|
BKE_modifier_free((ModifierData *)psmd);
|
|
|
|
BLI_remlink(particles, psys);
|
|
MEM_freeN(psys);
|
|
}
|
|
}
|
|
}
|