blender
/
blender
136
404
Fork 586
Code Issues 6.2k Pull Requests 753 Projects 19 Wiki Activity

Particles: improve mesh emitter 

Particles are now emitted from vertices of the mesh.
This commit is contained in:
Jacques Lucke 2020-07-23 17:57:11 +02:00
parent 67857b5d9f
commit 766edbdf1f
11 changed files with 505 additions and 345 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
source/blender/blenlib/BLI_vector.hh
View File

@ -561,7 +561,7 @@ class Vector {
/**
* Return a reference to the last element in the vector.
* This will assert when the vector is empty.
* This invokes undefined behavior when the vector is empty.
*/
const T &last() const
{

46
source/blender/functions/FN_multi_function_params.hh
View File

@ -50,52 +50,56 @@ class MFParamsBuilder {
MFParamsBuilder(const class MultiFunction &fn, int64_t min_array_size);
template<typename T> void add_readonly_single_input(const T *value)
template<typename T> void add_readonly_single_input(const T *value, StringRef expected_name = "")
{
this->add_readonly_single_input(GVSpan::FromSingle(CPPType::get<T>(), value, min_array_size_));
this->add_readonly_single_input(GVSpan::FromSingle(CPPType::get<T>(), value, min_array_size_),
expected_name);
}
void add_readonly_single_input(GVSpan ref)
void add_readonly_single_input(GVSpan ref, StringRef expected_name = "")
{
this->assert_current_param_type(MFParamType::ForSingleInput(ref.type()));
this->assert_current_param_type(MFParamType::ForSingleInput(ref.type()), expected_name);
BLI_assert(ref.size() >= min_array_size_);
virtual_spans_.append(ref);
}
void add_readonly_vector_input(GVArraySpan ref)
void add_readonly_vector_input(GVArraySpan ref, StringRef expected_name = "")
{
this->assert_current_param_type(MFParamType::ForVectorInput(ref.type()));
this->assert_current_param_type(MFParamType::ForVectorInput(ref.type()), expected_name);
BLI_assert(ref.size() >= min_array_size_);
virtual_array_spans_.append(ref);
}
template<typename T> void add_uninitialized_single_output(T *value)
template<typename T> void add_uninitialized_single_output(T *value, StringRef expected_name = "")
{
this->add_uninitialized_single_output(GMutableSpan(CPPType::get<T>(), value, 1));
this->add_uninitialized_single_output(GMutableSpan(CPPType::get<T>(), value, 1),
expected_name);
}
void add_uninitialized_single_output(GMutableSpan ref)
void add_uninitialized_single_output(GMutableSpan ref, StringRef expected_name = "")
{
this->assert_current_param_type(MFParamType::ForSingleOutput(ref.type()));
this->assert_current_param_type(MFParamType::ForSingleOutput(ref.type()), expected_name);
BLI_assert(ref.size() >= min_array_size_);
mutable_spans_.append(ref);
}
void add_vector_output(GVectorArray &vector_array)
void add_vector_output(GVectorArray &vector_array, StringRef expected_name = "")
{
this->assert_current_param_type(MFParamType::ForVectorOutput(vector_array.type()));
this->assert_current_param_type(MFParamType::ForVectorOutput(vector_array.type()),
expected_name);
BLI_assert(vector_array.size() >= min_array_size_);
vector_arrays_.append(&vector_array);
}
void add_single_mutable(GMutableSpan ref)
void add_single_mutable(GMutableSpan ref, StringRef expected_name = "")
{
this->assert_current_param_type(MFParamType::ForMutableSingle(ref.type()));
this->assert_current_param_type(MFParamType::ForMutableSingle(ref.type()), expected_name);
BLI_assert(ref.size() >= min_array_size_);
mutable_spans_.append(ref);
}
void add_vector_mutable(GVectorArray &vector_array)
void add_vector_mutable(GVectorArray &vector_array, StringRef expected_name = "")
{
this->assert_current_param_type(MFParamType::ForMutableVector(vector_array.type()));
this->assert_current_param_type(MFParamType::ForMutableVector(vector_array.type()),
expected_name);
BLI_assert(vector_array.size() >= min_array_size_);
vector_arrays_.append(&vector_array);
}
@ -119,11 +123,17 @@ class MFParamsBuilder {
}
private:
void assert_current_param_type(MFParamType param_type)
void assert_current_param_type(MFParamType param_type, StringRef expected_name = "")
{
UNUSED_VARS_NDEBUG(param_type);
UNUSED_VARS_NDEBUG(param_type, expected_name);
#ifdef DEBUG
int param_index = this->current_param_index();
if (expected_name != "") {
StringRef actual_name = signature_->param_names[param_index];
BLI_assert(actual_name == expected_name);
}
MFParamType expected_type = signature_->param_types[param_index];
BLI_assert(expected_type == param_type);
#endif

3
source/blender/simulation/CMakeLists.txt
View File

@ -43,6 +43,7 @@ set(SRC
intern/implicit_eigen.cpp
intern/particle_allocator.cc
intern/particle_function.cc
intern/particle_mesh_emitter.cc
intern/simulation_collect_influences.cc
intern/simulation_solver.cc
intern/simulation_update.cc
@ -52,7 +53,9 @@ set(SRC
intern/implicit.h
intern/particle_allocator.hh
intern/particle_function.hh
intern/particle_mesh_emitter.hh
intern/simulation_collect_influences.hh
intern/simulation_solver_influences.hh
intern/simulation_solver.hh
intern/time_interval.hh

147
source/blender/simulation/intern/particle_mesh_emitter.cc Normal file
View File

@ -0,0 +1,147 @@
/*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software Foundation,
* Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*/
#include "particle_mesh_emitter.hh"
#include "BLI_float4x4.hh"
#include "BLI_rand.hh"
#include "DNA_mesh_types.h"
#include "DNA_meshdata_types.h"
#include "DNA_object_types.h"
namespace blender::sim {
struct EmitterSettings {
const Object *object;
float rate;
};
static void compute_birth_times(float rate,
TimeInterval emit_interval,
ParticleMeshEmitterSimulationState &state,
Vector<float> &r_birth_times)
{
const float time_between_particles = 1.0f / rate;
int counter = 0;
while (true) {
counter++;
const float time_offset = counter * time_between_particles;
const float birth_time = state.last_birth_time + time_offset;
if (birth_time > emit_interval.end()) {
break;
}
if (birth_time <= emit_interval.start()) {
continue;
}
r_birth_times.append(birth_time);
}
}
static void compute_new_particle_attributes(EmitterSettings &settings,
TimeInterval emit_interval,
ParticleMeshEmitterSimulationState &state,
Vector<float3> &r_positions,
Vector<float3> &r_velocities,
Vector<float> &r_birth_times)
{
if (settings.object == nullptr) {
return;
}
if (settings.rate <= 0.000001f) {
return;
}
if (settings.object->type != OB_MESH) {
return;
}
const Mesh &mesh = *(Mesh *)settings.object->data;
if (mesh.totvert == 0) {
return;
}
float4x4 local_to_world = settings.object->obmat;
const float start_time = emit_interval.start();
const uint32_t seed = DefaultHash<StringRef>{}(state.head.name);
RandomNumberGenerator rng{(*(uint32_t *)&start_time) ^ seed};
compute_birth_times(settings.rate, emit_interval, state, r_birth_times);
if (r_birth_times.is_empty()) {
return;
}
state.last_birth_time = r_birth_times.last();
for (int i : r_birth_times.index_range()) {
UNUSED_VARS(i);
const int vertex_index = rng.get_int32() % mesh.totvert;
float3 vertex_position = mesh.mvert[vertex_index].co;
r_positions.append(local_to_world * vertex_position);
r_velocities.append(rng.get_unit_float3());
}
}
static EmitterSettings compute_settings(const fn::MultiFunction &inputs_fn,
ParticleEmitterContext &context)
{
EmitterSettings parameters;
fn::MFContextBuilder mf_context;
mf_context.add_global_context("PersistentDataHandleMap", &context.solve_context().handle_map());
fn::MFParamsBuilder mf_params{inputs_fn, 1};
bke::PersistentObjectHandle object_handle;
mf_params.add_uninitialized_single_output(&object_handle, "Object");
mf_params.add_uninitialized_single_output(&parameters.rate, "Rate");
inputs_fn.call(IndexRange(1), mf_params, mf_context);
parameters.object = context.solve_context().handle_map().lookup(object_handle);
return parameters;
}
void ParticleMeshEmitter::emit(ParticleEmitterContext &context) const
{
auto *state = context.lookup_state<ParticleMeshEmitterSimulationState>(own_state_name_);
if (state == nullptr) {
return;
}
EmitterSettings settings = compute_settings(inputs_fn_, context);
Vector<float3> new_positions;
Vector<float3> new_velocities;
Vector<float> new_birth_times;
compute_new_particle_attributes(
settings, context.emit_interval(), *state, new_positions, new_velocities, new_birth_times);
for (StringRef name : particle_names_) {
ParticleAllocator *allocator = context.try_get_particle_allocator(name);
if (allocator == nullptr) {
continue;
}
int amount = new_positions.size();
fn::MutableAttributesRef attributes = allocator->allocate(amount);
attributes.get<float3>("Position").copy_from(new_positions);
attributes.get<float3>("Velocity").copy_from(new_velocities);
attributes.get<float>("Birth Time").copy_from(new_birth_times);
}
}
} // namespace blender::sim

47
source/blender/simulation/intern/particle_mesh_emitter.hh Normal file
View File

@ -0,0 +1,47 @@
/*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software Foundation,
* Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*/
#ifndef __SIM_PARTICLE_MESH_EMITTER_HH__
#define __SIM_PARTICLE_MESH_EMITTER_HH__
#include "simulation_solver_influences.hh"
#include "FN_multi_function.hh"
namespace blender::sim {
class ParticleMeshEmitter final : public ParticleEmitter {
private:
std::string own_state_name_;
Array<std::string> particle_names_;
const fn::MultiFunction &inputs_fn_;
public:
ParticleMeshEmitter(std::string own_state_name,
Array<std::string> particle_names,
const fn::MultiFunction &inputs_fn)
: own_state_name_(std::move(own_state_name)),
particle_names_(particle_names),
inputs_fn_(inputs_fn)
{
}
void emit(ParticleEmitterContext &context) const override;
};
} // namespace blender::sim
#endif /* __SIM_PARTICLE_MESH_EMITTER_HH__ */

87
source/blender/simulation/intern/simulation_collect_influences.cc
View File

@ -16,6 +16,7 @@
#include "simulation_collect_influences.hh"
#include "particle_function.hh"
#include "particle_mesh_emitter.hh"
#include "FN_attributes_ref.hh"
#include "FN_multi_function_network_evaluation.hh"
@ -279,83 +280,6 @@ static void collect_forces(nodes::MFNetworkTreeMap &network_map,
}
}
class MyBasicEmitter : public ParticleEmitter {
private:
Array<std::string> names_;
std::string my_state_;
const fn::MultiFunction &inputs_fn_;
uint32_t seed_;
public:
MyBasicEmitter(Array<std::string> names,
std::string my_state,
const fn::MultiFunction &inputs_fn,
uint32_t seed)
: names_(std::move(names)),
my_state_(std::move(my_state)),
inputs_fn_(inputs_fn),
seed_(seed)
{
}
void emit(ParticleEmitterContext &context) const override
{
auto *state = context.solve_context().state_map().lookup<ParticleMeshEmitterSimulationState>(
my_state_);
if (state == nullptr) {
return;
}
fn::MFContextBuilder mf_context;
mf_context.add_global_context("PersistentDataHandleMap",
&context.solve_context().handle_map());
fn::MFParamsBuilder mf_params{inputs_fn_, 1};
bke::PersistentObjectHandle object_handle;
float rate;
mf_params.add_uninitialized_single_output(&object_handle);
mf_params.add_uninitialized_single_output(&rate);
inputs_fn_.call(IndexRange(1), mf_params, mf_context);
const Object *object = context.solve_context().handle_map().lookup(object_handle);
if (object == nullptr) {
return;
}
Vector<float3> new_positions;
Vector<float3> new_velocities;
Vector<float> new_birth_times;
TimeInterval time_interval = context.simulation_time_interval();
float start_time = time_interval.start();
RandomNumberGenerator rng{(*(uint32_t *)&start_time) ^ seed_};
const float time_between_particles = 1.0f / rate;
while (state->last_birth_time + time_between_particles < time_interval.end()) {
new_positions.append(rng.get_unit_float3() * 0.3 + float3(object->loc));
new_velocities.append(rng.get_unit_float3());
const float birth_time = state->last_birth_time + time_between_particles;
new_birth_times.append(birth_time);
state->last_birth_time = birth_time;
}
for (StringRef name : names_) {
ParticleAllocator *allocator = context.try_get_particle_allocator(name);
if (allocator == nullptr) {
return;
}
int amount = new_positions.size();
fn::MutableAttributesRef attributes = allocator->allocate(amount);
initialized_copy_n(new_positions.data(), amount, attributes.get<float3>("Position").data());
initialized_copy_n(new_velocities.data(), amount, attributes.get<float3>("Velocity").data());
initialized_copy_n(
new_birth_times.data(), amount, attributes.get<float>("Birth Time").data());
}
}
};
static Vector<const nodes::DNode *> find_linked_particle_simulations(
const nodes::DOutputSocket &output_socket)
{
@ -396,11 +320,10 @@ static ParticleEmitter *create_particle_emitter(const nodes::DNode &dnode,
fn::MultiFunction &inputs_fn = resources.construct<fn::MFNetworkEvaluator>(
AT, Span<const fn::MFOutputSocket *>(), input_sockets.as_span());
std::string my_state_name = dnode_to_path(dnode);
r_required_states.add(my_state_name, SIM_TYPE_NAME_PARTICLE_MESH_EMITTER);
uint32_t seed = DefaultHash<std::string>{}(my_state_name);
ParticleEmitter &emitter = resources.construct<MyBasicEmitter>(
AT, std::move(names), std::move(my_state_name), inputs_fn, seed);
std::string own_state_name = dnode_to_path(dnode);
r_required_states.add(own_state_name, SIM_TYPE_NAME_PARTICLE_MESH_EMITTER);
ParticleEmitter &emitter = resources.construct<ParticleMeshEmitter>(
AT, std::move(own_state_name), std::move(names), inputs_fn);
return &emitter;
}

2
source/blender/simulation/intern/simulation_collect_influences.hh
View File

@ -21,7 +21,7 @@
#include "BLI_resource_collector.hh"
#include "simulation_solver.hh"
#include "simulation_solver_influences.hh"
namespace blender::sim {

3
source/blender/simulation/intern/simulation_solver.cc
View File

@ -272,7 +272,6 @@ void solve_simulation_time_step(Simulation &simulation,
TimeInterval(simulation.current_simulation_time, time_step),
state_map,
handle_map};
TimeInterval simulation_time_interval{simulation.current_simulation_time, time_step};
Span<ParticleSimulationState *> particle_simulation_states =
state_map.lookup<ParticleSimulationState>();
@ -305,7 +304,7 @@ void solve_simulation_time_step(Simulation &simulation,
remove_dead_and_add_new_particles(*state, allocator);
}
simulation.current_simulation_time = simulation_time_interval.end();
simulation.current_simulation_time = solve_context.solve_interval().end();
}
} // namespace blender::sim

241
source/blender/simulation/intern/simulation_solver.hh
View File

@ -17,251 +17,12 @@
#ifndef __SIM_SIMULATION_SOLVER_HH__
#define __SIM_SIMULATION_SOLVER_HH__
#include "BLI_float3.hh"
#include "BLI_span.hh"
#include "DNA_simulation_types.h"
#include "FN_attributes_ref.hh"
#include "BKE_persistent_data_handle.hh"
#include "BKE_simulation.h"
#include "particle_allocator.hh"
#include "time_interval.hh"
#include "simulation_collect_influences.hh"
struct Depsgraph;
namespace blender::sim {
class ParticleEmitterContext;
class ParticleForceContext;
class ParticleEmitter {
public:
virtual ~ParticleEmitter();
virtual void emit(ParticleEmitterContext &context) const = 0;
};
class ParticleForce {
public:
virtual ~ParticleForce();
virtual void add_force(ParticleForceContext &context) const = 0;
};
struct SimulationInfluences {
Map<std::string, Vector<const ParticleForce *>> particle_forces;
Map<std::string, fn::AttributesInfoBuilder *> particle_attributes_builder;
Vector<const ParticleEmitter *> particle_emitters;
};
class SimulationStateMap {
private:
Map<StringRefNull, SimulationState *> states_by_name_;
Map<StringRefNull, Vector<SimulationState *>> states_by_type_;
public:
void add(SimulationState *state)
{
states_by_name_.add_new(state->name, state);
states_by_type_.lookup_or_add_default(state->type).append(state);
}
template<typename StateType> StateType *lookup(StringRef name) const
{
const char *type = BKE_simulation_get_state_type_name<StateType>();
return (StateType *)this->lookup_name_type(name, type);
}
template<typename StateType> Span<StateType *> lookup() const
{
const char *type = BKE_simulation_get_state_type_name<StateType>();
return this->lookup_type(type).cast<StateType *>();
}
SimulationState *lookup_name_type(StringRef name, StringRef type) const
{
SimulationState *state = states_by_name_.lookup_default_as(name, nullptr);
if (state == nullptr) {
return nullptr;
}
if (state->type == type) {
return state;
}
return nullptr;
}
Span<SimulationState *> lookup_type(StringRef type) const
{
const Vector<SimulationState *> *states = states_by_type_.lookup_ptr_as(type);
if (states == nullptr) {
return {};
}
else {
return states->as_span();
}
}
};
class SimulationSolveContext {
private:
Simulation &simulation_;
Depsgraph &depsgraph_;
const SimulationInfluences &influences_;
TimeInterval solve_interval_;
const SimulationStateMap &state_map_;
const bke::PersistentDataHandleMap &id_handle_map_;
public:
SimulationSolveContext(Simulation &simulation,
Depsgraph &depsgraph,
const SimulationInfluences &influences,
TimeInterval solve_interval,
const SimulationStateMap &state_map,
const bke::PersistentDataHandleMap &handle_map)
: simulation_(simulation),
depsgraph_(depsgraph),
influences_(influences),
solve_interval_(solve_interval),
state_map_(state_map),
id_handle_map_(handle_map)
{
}
TimeInterval solve_interval() const
{
return solve_interval_;
}
const SimulationInfluences &influences() const
{
return influences_;
}
const bke::PersistentDataHandleMap &handle_map() const
{
return id_handle_map_;
}
const SimulationStateMap &state_map() const
{
return state_map_;
}
};
class ParticleAllocators {
private:
Map<std::string, std::unique_ptr<ParticleAllocator>> &allocators_;
public:
ParticleAllocators(Map<std::string, std::unique_ptr<ParticleAllocator>> &allocators)
: allocators_(allocators)
{
}
ParticleAllocator *try_get_allocator(StringRef particle_simulation_name)
{
auto *ptr = allocators_.lookup_ptr_as(particle_simulation_name);
if (ptr != nullptr) {
return ptr->get();
}
else {
return nullptr;
}
}
};
class ParticleChunkContext {
private:
IndexMask index_mask_;
fn::MutableAttributesRef attributes_;
public:
ParticleChunkContext(IndexMask index_mask, fn::MutableAttributesRef attributes)
: index_mask_(index_mask), attributes_(attributes)
{
}
IndexMask index_mask() const
{
return index_mask_;
}
fn::MutableAttributesRef attributes()
{
return attributes_;
}
fn::AttributesRef attributes() const
{
return attributes_;
}
};
class ParticleEmitterContext {
private:
SimulationSolveContext &solve_context_;
ParticleAllocators &particle_allocators_;
TimeInterval simulation_time_interval_;
public:
ParticleEmitterContext(SimulationSolveContext &solve_context,
ParticleAllocators &particle_allocators,
TimeInterval simulation_time_interval)
: solve_context_(solve_context),
particle_allocators_(particle_allocators),
simulation_time_interval_(simulation_time_interval)
{
}
SimulationSolveContext &solve_context()
{
return solve_context_;
}
ParticleAllocator *try_get_particle_allocator(StringRef particle_simulation_name)
{
return particle_allocators_.try_get_allocator(particle_simulation_name);
}
TimeInterval simulation_time_interval() const
{
return simulation_time_interval_;
}
};
class ParticleForceContext {
private:
SimulationSolveContext &solve_context_;
const ParticleChunkContext &particle_chunk_context_;
MutableSpan<float3> force_dst_;
public:
ParticleForceContext(SimulationSolveContext &solve_context,
const ParticleChunkContext &particle_chunk_context,
MutableSpan<float3> force_dst)
: solve_context_(solve_context),
particle_chunk_context_(particle_chunk_context),
force_dst_(force_dst)
{
}
SimulationSolveContext &solve_context()
{
return solve_context_;
}
const ParticleChunkContext &particle_chunk() const
{
return particle_chunk_context_;
}
MutableSpan<float3> force_dst()
{
return force_dst_;
}
};
void initialize_simulation_states(Simulation &simulation,
Depsgraph &depsgraph,
const SimulationInfluences &influences,

270
source/blender/simulation/intern/simulation_solver_influences.hh Normal file
View File

@ -0,0 +1,270 @@
/*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software Foundation,
* Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*/
#ifndef __SIM_SIMULATION_SOLVER_INFLUENCES_HH__
#define __SIM_SIMULATION_SOLVER_INFLUENCES_HH__
#include "BLI_float3.hh"
#include "BLI_span.hh"
#include "DNA_simulation_types.h"
#include "FN_attributes_ref.hh"
#include "BKE_persistent_data_handle.hh"
#include "BKE_simulation.h"
#include "particle_allocator.hh"
#include "time_interval.hh"
namespace blender::sim {
class ParticleEmitterContext;
class ParticleForceContext;
class ParticleEmitter {
public:
virtual ~ParticleEmitter();
virtual void emit(ParticleEmitterContext &context) const = 0;
};
class ParticleForce {
public:
virtual ~ParticleForce();
virtual void add_force(ParticleForceContext &context) const = 0;
};
struct SimulationInfluences {
Map<std::string, Vector<const ParticleForce *>> particle_forces;
Map<std::string, fn::AttributesInfoBuilder *> particle_attributes_builder;
Vector<const ParticleEmitter *> particle_emitters;
};
class SimulationStateMap {
private:
Map<StringRefNull, SimulationState *> states_by_name_;
Map<StringRefNull, Vector<SimulationState *>> states_by_type_;
public:
void add(SimulationState *state)
{
states_by_name_.add_new(state->name, state);
states_by_type_.lookup_or_add_default(state->type).append(state);
}
template<typename StateType> StateType *lookup(StringRef name) const
{
const char *type = BKE_simulation_get_state_type_name<StateType>();
return (StateType *)this->lookup_name_type(name, type);
}
template<typename StateType> Span<StateType *> lookup() const
{
const char *type = BKE_simulation_get_state_type_name<StateType>();
return this->lookup_type(type).cast<StateType *>();
}
SimulationState *lookup_name_type(StringRef name, StringRef type) const
{
SimulationState *state = states_by_name_.lookup_default_as(name, nullptr);
if (state == nullptr) {
return nullptr;
}
if (state->type == type) {
return state;
}
return nullptr;
}
Span<SimulationState *> lookup_type(StringRef type) const
{
const Vector<SimulationState *> *states = states_by_type_.lookup_ptr_as(type);
if (states == nullptr) {
return {};
}
else {
return states->as_span();
}
}
};
class SimulationSolveContext {
private:
Simulation &simulation_;
Depsgraph &depsgraph_;
const SimulationInfluences &influences_;
TimeInterval solve_interval_;
const SimulationStateMap &state_map_;
const bke::PersistentDataHandleMap &id_handle_map_;
public:
SimulationSolveContext(Simulation &simulation,
Depsgraph &depsgraph,
const SimulationInfluences &influences,
TimeInterval solve_interval,
const SimulationStateMap &state_map,
const bke::PersistentDataHandleMap &handle_map)
: simulation_(simulation),
depsgraph_(depsgraph),
influences_(influences),
solve_interval_(solve_interval),
state_map_(state_map),
id_handle_map_(handle_map)
{
}
TimeInterval solve_interval() const
{
return solve_interval_;
}
const SimulationInfluences &influences() const
{
return influences_;
}
const bke::PersistentDataHandleMap &handle_map() const
{
return id_handle_map_;
}
const SimulationStateMap &state_map() const
{
return state_map_;
}
};
class ParticleAllocators {
private:
Map<std::string, std::unique_ptr<ParticleAllocator>> &allocators_;
public:
ParticleAllocators(Map<std::string, std::unique_ptr<ParticleAllocator>> &allocators)
: allocators_(allocators)
{
}
ParticleAllocator *try_get_allocator(StringRef particle_simulation_name)
{
auto *ptr = allocators_.lookup_ptr_as(particle_simulation_name);
if (ptr != nullptr) {
return ptr->get();
}
else {
return nullptr;
}
}
};
class ParticleChunkContext {
private:
IndexMask index_mask_;
fn::MutableAttributesRef attributes_;
public:
ParticleChunkContext(IndexMask index_mask, fn::MutableAttributesRef attributes)
: index_mask_(index_mask), attributes_(attributes)
{
}
IndexMask index_mask() const
{
return index_mask_;
}
fn::MutableAttributesRef attributes()
{
return attributes_;
}
fn::AttributesRef attributes() const
{
return attributes_;
}
};
class ParticleEmitterContext {
private:
SimulationSolveContext &solve_context_;
ParticleAllocators &particle_allocators_;
TimeInterval emit_interval_;
public:
ParticleEmitterContext(SimulationSolveContext &solve_context,
ParticleAllocators &particle_allocators,
TimeInterval emit_interval)
: solve_context_(solve_context),
particle_allocators_(particle_allocators),
emit_interval_(emit_interval)
{
}
template<typename StateType> StateType *lookup_state(StringRef name)
{
return solve_context_.state_map().lookup<StateType>(name);
}
SimulationSolveContext &solve_context()
{
return solve_context_;
}
ParticleAllocator *try_get_particle_allocator(StringRef particle_simulation_name)
{
return particle_allocators_.try_get_allocator(particle_simulation_name);
}
TimeInterval emit_interval() const
{
return emit_interval_;
}
};
class ParticleForceContext {
private:
SimulationSolveContext &solve_context_;
const ParticleChunkContext &particle_chunk_context_;
MutableSpan<float3> force_dst_;
public:
ParticleForceContext(SimulationSolveContext &solve_context,
const ParticleChunkContext &particle_chunk_context,
MutableSpan<float3> force_dst)
: solve_context_(solve_context),
particle_chunk_context_(particle_chunk_context),
force_dst_(force_dst)
{
}
SimulationSolveContext &solve_context()
{
return solve_context_;
}
const ParticleChunkContext &particle_chunk() const
{
return particle_chunk_context_;
}
MutableSpan<float3> force_dst()
{
return force_dst_;
}
};
} // namespace blender::sim
#endif /* __SIM_SIMULATION_SOLVER_INFLUENCES_HH__ */

2
source/blender/simulation/intern/time_interval.hh
View File

@ -22,7 +22,7 @@
namespace blender::sim {
/**
* The start time is inclusive and the end time is exclusive. The duration is zero, the interval
* The start time is exclusive and the end time is inclusive. If the duration is zero, the interval
* describes a single point in time.
*/
class TimeInterval {