Particles: improve mesh emitter
Particles are now emitted from vertices of the mesh.
This commit is contained in:
parent
67857b5d9f
commit
766edbdf1f
|
@ -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
|
||||
{
|
||||
|
|
|
@ -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
|
||||
|
|
|
@ -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
|
||||
|
||||
|
|
|
@ -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(¶meters.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
|
|
@ -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__ */
|
|
@ -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;
|
||||
}
|
||||
|
||||
|
|
|
@ -21,7 +21,7 @@
|
|||
|
||||
#include "BLI_resource_collector.hh"
|
||||
|
||||
#include "simulation_solver.hh"
|
||||
#include "simulation_solver_influences.hh"
|
||||
|
||||
namespace blender::sim {
|
||||
|
||||
|
|
|
@ -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
|
||||
|
|
|
@ -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,
|
||||
|
|
|
@ -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__ */
|
|
@ -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 {
|
||||
|
|
Loading…
Reference in New Issue