diff options
author | Jacques Lucke <jacques@blender.org> | 2020-07-17 22:19:48 +0300 |
---|---|---|
committer | Jacques Lucke <jacques@blender.org> | 2020-07-17 22:20:51 +0300 |
commit | aa8279648e22c8fc5ffc943036b77c47d1f8a764 (patch) | |
tree | 076bd188af901b2de560620c72b640c85eb30b79 /source/blender/simulation/intern | |
parent | 25582aef61ce6fdf8e6e9b8f86e5bff294370f3d (diff) |
Simulation: extract node tree parsing code to separate file
Diffstat (limited to 'source/blender/simulation/intern')
5 files changed, 290 insertions, 227 deletions
diff --git a/source/blender/simulation/intern/simulation_collect_influences.cc b/source/blender/simulation/intern/simulation_collect_influences.cc new file mode 100644 index 00000000000..3feb0ccce5b --- /dev/null +++ b/source/blender/simulation/intern/simulation_collect_influences.cc @@ -0,0 +1,236 @@ +/* + * 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 "simulation_collect_influences.hh" +#include "SIM_particle_function.hh" + +#include "FN_attributes_ref.hh" +#include "FN_multi_function_network_evaluation.hh" +#include "FN_multi_function_network_optimization.hh" + +#include "NOD_node_tree_multi_function.hh" + +namespace blender::sim { + +extern "C" { +void WM_clipboard_text_set(const char *buf, bool selection); +} + +static Map<const fn::MFOutputSocket *, std::string> deduplicate_attribute_nodes( + fn::MFNetwork &network, + nodes::MFNetworkTreeMap &network_map, + const nodes::DerivedNodeTree &tree) +{ + Span<const nodes::DNode *> attribute_dnodes = tree.nodes_by_type( + "SimulationNodeParticleAttribute"); + uint amount = attribute_dnodes.size(); + if (amount == 0) { + return {}; + } + + Vector<fn::MFInputSocket *> name_sockets; + for (const nodes::DNode *dnode : attribute_dnodes) { + fn::MFInputSocket &name_socket = network_map.lookup_dummy(dnode->input(0)); + name_sockets.append(&name_socket); + } + + fn::MFNetworkEvaluator network_fn{{}, name_sockets.as_span()}; + + fn::MFParamsBuilder params{network_fn, 1}; + + Array<std::string> attribute_names{amount, NoInitialization()}; + for (uint i : IndexRange(amount)) { + params.add_uninitialized_single_output( + fn::GMutableSpan(fn::CPPType::get<std::string>(), attribute_names.data() + i, 1)); + } + + fn::MFContextBuilder context; + /* Todo: Check that the names don't depend on dummy nodes. */ + network_fn.call({0}, params, context); + + Map<std::pair<std::string, fn::MFDataType>, Vector<fn::MFNode *>> + attribute_nodes_by_name_and_type; + for (uint i : IndexRange(amount)) { + attribute_nodes_by_name_and_type + .lookup_or_add_default({attribute_names[i], name_sockets[i]->node().output(0).data_type()}) + .append(&name_sockets[i]->node()); + } + + Map<const fn::MFOutputSocket *, std::string> attribute_inputs; + for (auto item : attribute_nodes_by_name_and_type.items()) { + StringRef attribute_name = item.key.first; + fn::MFDataType data_type = item.key.second; + Span<fn::MFNode *> nodes = item.value; + + fn::MFOutputSocket &new_attribute_socket = network.add_input( + "Attribute '" + attribute_name + "'", data_type); + for (fn::MFNode *node : nodes) { + network.relink(node->output(0), new_attribute_socket); + } + network.remove(nodes); + + attribute_inputs.add_new(&new_attribute_socket, attribute_name); + } + + return attribute_inputs; +} + +class ParticleAttributeInput : public ParticleFunctionInput { + private: + std::string attribute_name_; + const fn::CPPType &attribute_type_; + + public: + ParticleAttributeInput(std::string attribute_name, const fn::CPPType &attribute_type) + : attribute_name_(std::move(attribute_name)), attribute_type_(attribute_type) + { + } + + void add_input(fn::AttributesRef attributes, + fn::MFParamsBuilder ¶ms, + ResourceCollector &UNUSED(resources)) const override + { + std::optional<fn::GSpan> span = attributes.try_get(attribute_name_, attribute_type_); + if (span.has_value()) { + params.add_readonly_single_input(*span); + } + else { + params.add_readonly_single_input(fn::GVSpan::FromDefault(attribute_type_)); + } + } +}; + +static const ParticleFunction *create_particle_function_for_inputs( + Span<const fn::MFInputSocket *> sockets_to_compute, + ResourceCollector &resources, + const Map<const fn::MFOutputSocket *, std::string> &attribute_inputs) +{ + BLI_assert(sockets_to_compute.size() >= 1); + const fn::MFNetwork &network = sockets_to_compute[0]->node().network(); + + VectorSet<const fn::MFOutputSocket *> dummy_deps; + VectorSet<const fn::MFInputSocket *> unlinked_input_deps; + network.find_dependencies(sockets_to_compute, dummy_deps, unlinked_input_deps); + BLI_assert(unlinked_input_deps.size() == 0); + + Vector<const ParticleFunctionInput *> per_particle_inputs; + for (const fn::MFOutputSocket *socket : dummy_deps) { + const std::string *attribute_name = attribute_inputs.lookup_ptr(socket); + if (attribute_name == nullptr) { + return nullptr; + } + per_particle_inputs.append(&resources.construct<ParticleAttributeInput>( + AT, *attribute_name, socket->data_type().single_type())); + } + + const fn::MultiFunction &per_particle_fn = resources.construct<fn::MFNetworkEvaluator>( + AT, dummy_deps.as_span(), sockets_to_compute); + + Array<bool> output_is_global(sockets_to_compute.size(), false); + + const ParticleFunction &particle_fn = resources.construct<ParticleFunction>( + AT, + nullptr, + &per_particle_fn, + Span<const ParticleFunctionInput *>(), + per_particle_inputs.as_span(), + output_is_global.as_span()); + + return &particle_fn; +} + +class ParticleFunctionForce : public ParticleForce { + private: + const ParticleFunction &particle_fn_; + + public: + ParticleFunctionForce(const ParticleFunction &particle_fn) : particle_fn_(particle_fn) + { + } + + void add_force(fn::AttributesRef attributes, MutableSpan<float3> r_combined_force) const override + { + IndexMask mask = IndexRange(attributes.size()); + ParticleFunctionEvaluator evaluator{particle_fn_, mask, attributes}; + evaluator.compute(); + fn::VSpan<float3> forces = evaluator.get<float3>(0, "Force"); + for (uint i : mask) { + r_combined_force[i] += forces[i]; + } + } +}; + +static Vector<const ParticleForce *> create_forces_for_particle_simulation( + const nodes::DNode &simulation_node, + nodes::MFNetworkTreeMap &network_map, + ResourceCollector &resources, + const Map<const fn::MFOutputSocket *, std::string> &attribute_inputs) +{ + Vector<const ParticleForce *> forces; + for (const nodes::DOutputSocket *origin_socket : + simulation_node.input(2, "Forces").linked_sockets()) { + const nodes::DNode &origin_node = origin_socket->node(); + if (origin_node.idname() != "SimulationNodeForce") { + continue; + } + + const fn::MFInputSocket &force_socket = network_map.lookup_dummy( + origin_node.input(0, "Force")); + + const ParticleFunction *particle_fn = create_particle_function_for_inputs( + {&force_socket}, resources, attribute_inputs); + + if (particle_fn == nullptr) { + continue; + } + + const ParticleForce &force = resources.construct<ParticleFunctionForce>(AT, *particle_fn); + forces.append(&force); + } + return forces; +} + +static void collect_forces(nodes::MFNetworkTreeMap &network_map, + ResourceCollector &resources, + const Map<const fn::MFOutputSocket *, std::string> &attribute_inputs, + SimulationInfluences &r_influences) +{ + for (const nodes::DNode *dnode : + network_map.tree().nodes_by_type("SimulationNodeParticleSimulation")) { + std::string name = dnode_to_path(*dnode); + Vector<const ParticleForce *> forces = create_forces_for_particle_simulation( + *dnode, network_map, resources, attribute_inputs); + r_influences.particle_forces.add_new(std::move(name), std::move(forces)); + } +} + +void collect_simulation_influences(const nodes::DerivedNodeTree &tree, + ResourceCollector &resources, + SimulationInfluences &r_influences) +{ + fn::MFNetwork &network = resources.construct<fn::MFNetwork>(AT); + nodes::MFNetworkTreeMap network_map = insert_node_tree_into_mf_network(network, tree, resources); + Map<const fn::MFOutputSocket *, std::string> attribute_inputs = deduplicate_attribute_nodes( + network, network_map, tree); + fn::mf_network_optimization::constant_folding(network, resources); + fn::mf_network_optimization::common_subnetwork_elimination(network); + fn::mf_network_optimization::dead_node_removal(network); + // WM_clipboard_text_set(network.to_dot().c_str(), false); + + collect_forces(network_map, resources, attribute_inputs, r_influences); +} + +} // namespace blender::sim diff --git a/source/blender/simulation/intern/simulation_collect_influences.hh b/source/blender/simulation/intern/simulation_collect_influences.hh new file mode 100644 index 00000000000..a02a6320419 --- /dev/null +++ b/source/blender/simulation/intern/simulation_collect_influences.hh @@ -0,0 +1,45 @@ +/* + * 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_COLLECT_INFLUENCES_HH__ +#define __SIM_SIMULATION_COLLECT_INFLUENCES_HH__ + +#include "NOD_derived_node_tree.hh" + +#include "BLI_resource_collector.hh" + +#include "simulation_solver.hh" + +namespace blender::sim { + +void collect_simulation_influences(const nodes::DerivedNodeTree &tree, + ResourceCollector &resources, + SimulationInfluences &r_influences); + +/* TODO: Move this to a better place. */ +inline std::string dnode_to_path(const nodes::DNode &dnode) +{ + std::string path; + for (const nodes::DParentNode *parent = dnode.parent(); parent; parent = parent->parent()) { + path = parent->node_ref().name() + "/" + path; + } + path = path + dnode.name(); + return path; +} + +} // namespace blender::sim + +#endif /* __SIM_SIMULATION_COLLECT_INFLUENCES_HH__ */ diff --git a/source/blender/simulation/intern/simulation_solver.cc b/source/blender/simulation/intern/simulation_solver.cc index 289e586682e..c51e8e1a37f 100644 --- a/source/blender/simulation/intern/simulation_solver.cc +++ b/source/blender/simulation/intern/simulation_solver.cc @@ -121,7 +121,8 @@ void solve_simulation_time_step(Simulation &simulation, MutableSpan<float3> velocities = attributes.get<float3>("Velocity"); Array<float3> force_vectors{(uint)state->tot_particles, {0, 0, 0}}; - const Vector<const ParticleForce *> *forces = influences.particle_forces.lookup_ptr(state); + const Vector<const ParticleForce *> *forces = influences.particle_forces.lookup_ptr( + state->head.name); if (forces != nullptr) { for (const ParticleForce *force : *forces) { force->add_force(attributes, force_vectors); diff --git a/source/blender/simulation/intern/simulation_solver.hh b/source/blender/simulation/intern/simulation_solver.hh index c96cfee52da..818bcf067a3 100644 --- a/source/blender/simulation/intern/simulation_solver.hh +++ b/source/blender/simulation/intern/simulation_solver.hh @@ -36,7 +36,7 @@ class ParticleForce { }; struct SimulationInfluences { - Map<const ParticleSimulationState *, Vector<const ParticleForce *>> particle_forces; + Map<std::string, Vector<const ParticleForce *>> particle_forces; }; void initialize_simulation_states(Simulation &simulation, diff --git a/source/blender/simulation/intern/simulation_update.cc b/source/blender/simulation/intern/simulation_update.cc index 18d9ea8b853..a3fddbbe18f 100644 --- a/source/blender/simulation/intern/simulation_update.cc +++ b/source/blender/simulation/intern/simulation_update.cc @@ -32,18 +32,9 @@ #include "BLI_rand.h" #include "BLI_vector.hh" -#include "NOD_node_tree_multi_function.hh" - -#include "FN_attributes_ref.hh" -#include "FN_multi_function_network_evaluation.hh" -#include "FN_multi_function_network_optimization.hh" - +#include "simulation_collect_influences.hh" #include "simulation_solver.hh" -extern "C" { -void WM_clipboard_text_set(const char *buf, bool selection); -} - namespace blender::sim { static void copy_states_to_cow(Simulation *simulation_orig, Simulation *simulation_cow) @@ -69,75 +60,6 @@ static void copy_states_to_cow(Simulation *simulation_orig, Simulation *simulati } } -static Map<const fn::MFOutputSocket *, std::string> deduplicate_attribute_nodes( - fn::MFNetwork &network, - nodes::MFNetworkTreeMap &network_map, - const nodes::DerivedNodeTree &tree) -{ - Span<const nodes::DNode *> attribute_dnodes = tree.nodes_by_type( - "SimulationNodeParticleAttribute"); - uint amount = attribute_dnodes.size(); - if (amount == 0) { - return {}; - } - - Vector<fn::MFInputSocket *> name_sockets; - for (const nodes::DNode *dnode : attribute_dnodes) { - fn::MFInputSocket &name_socket = network_map.lookup_dummy(dnode->input(0)); - name_sockets.append(&name_socket); - } - - fn::MFNetworkEvaluator network_fn{{}, name_sockets.as_span()}; - - fn::MFParamsBuilder params{network_fn, 1}; - - Array<std::string> attribute_names{amount, NoInitialization()}; - for (uint i : IndexRange(amount)) { - params.add_uninitialized_single_output( - fn::GMutableSpan(fn::CPPType::get<std::string>(), attribute_names.data() + i, 1)); - } - - fn::MFContextBuilder context; - /* Todo: Check that the names don't depend on dummy nodes. */ - network_fn.call({0}, params, context); - - Map<std::pair<std::string, fn::MFDataType>, Vector<fn::MFNode *>> - attribute_nodes_by_name_and_type; - for (uint i : IndexRange(amount)) { - attribute_nodes_by_name_and_type - .lookup_or_add_default({attribute_names[i], name_sockets[i]->node().output(0).data_type()}) - .append(&name_sockets[i]->node()); - } - - Map<const fn::MFOutputSocket *, std::string> attribute_inputs; - for (auto item : attribute_nodes_by_name_and_type.items()) { - StringRef attribute_name = item.key.first; - fn::MFDataType data_type = item.key.second; - Span<fn::MFNode *> nodes = item.value; - - fn::MFOutputSocket &new_attribute_socket = network.add_input( - "Attribute '" + attribute_name + "'", data_type); - for (fn::MFNode *node : nodes) { - network.relink(node->output(0), new_attribute_socket); - } - network.remove(nodes); - - attribute_inputs.add_new(&new_attribute_socket, attribute_name); - } - - return attribute_inputs; -} - -static std::string dnode_to_path(const nodes::DNode &dnode) -{ - std::string path; - for (const nodes::DParentNode *parent = dnode.parent(); parent; parent = parent->parent()) { - path = parent->node_ref().name() + "/" + path; - } - path = path + dnode.name(); - return path; -} - static void remove_unused_states(Simulation *simulation, const VectorSet<std::string> &state_names) { LISTBASE_FOREACH_MUTABLE (SimulationState *, state, &simulation->states) { @@ -209,138 +131,6 @@ static void update_simulation_state_list(Simulation *simulation, add_missing_particle_states(simulation, state_names); } -class ParticleAttributeInput : public ParticleFunctionInput { - private: - std::string attribute_name_; - const fn::CPPType &attribute_type_; - - public: - ParticleAttributeInput(std::string attribute_name, const fn::CPPType &attribute_type) - : attribute_name_(std::move(attribute_name)), attribute_type_(attribute_type) - { - } - - void add_input(fn::AttributesRef attributes, - fn::MFParamsBuilder ¶ms, - ResourceCollector &UNUSED(resources)) const override - { - std::optional<fn::GSpan> span = attributes.try_get(attribute_name_, attribute_type_); - if (span.has_value()) { - params.add_readonly_single_input(*span); - } - else { - params.add_readonly_single_input(fn::GVSpan::FromDefault(attribute_type_)); - } - } -}; - -static const ParticleFunction *create_particle_function_for_inputs( - Span<const fn::MFInputSocket *> sockets_to_compute, - ResourceCollector &resources, - const Map<const fn::MFOutputSocket *, std::string> &attribute_inputs) -{ - BLI_assert(sockets_to_compute.size() >= 1); - const fn::MFNetwork &network = sockets_to_compute[0]->node().network(); - - VectorSet<const fn::MFOutputSocket *> dummy_deps; - VectorSet<const fn::MFInputSocket *> unlinked_input_deps; - network.find_dependencies(sockets_to_compute, dummy_deps, unlinked_input_deps); - BLI_assert(unlinked_input_deps.size() == 0); - - Vector<const ParticleFunctionInput *> per_particle_inputs; - for (const fn::MFOutputSocket *socket : dummy_deps) { - const std::string *attribute_name = attribute_inputs.lookup_ptr(socket); - if (attribute_name == nullptr) { - return nullptr; - } - per_particle_inputs.append(&resources.construct<ParticleAttributeInput>( - AT, *attribute_name, socket->data_type().single_type())); - } - - const fn::MultiFunction &per_particle_fn = resources.construct<fn::MFNetworkEvaluator>( - AT, dummy_deps.as_span(), sockets_to_compute); - - Array<bool> output_is_global(sockets_to_compute.size(), false); - - const ParticleFunction &particle_fn = resources.construct<ParticleFunction>( - AT, - nullptr, - &per_particle_fn, - Span<const ParticleFunctionInput *>(), - per_particle_inputs.as_span(), - output_is_global.as_span()); - - return &particle_fn; -} - -class ParticleFunctionForce : public ParticleForce { - private: - const ParticleFunction &particle_fn_; - - public: - ParticleFunctionForce(const ParticleFunction &particle_fn) : particle_fn_(particle_fn) - { - } - - void add_force(fn::AttributesRef attributes, MutableSpan<float3> r_combined_force) const override - { - IndexMask mask = IndexRange(attributes.size()); - ParticleFunctionEvaluator evaluator{particle_fn_, mask, attributes}; - evaluator.compute(); - fn::VSpan<float3> forces = evaluator.get<float3>(0, "Force"); - for (uint i : mask) { - r_combined_force[i] += forces[i]; - } - } -}; - -static Vector<const ParticleForce *> create_forces_for_particle_simulation( - const nodes::DNode &simulation_node, - nodes::MFNetworkTreeMap &network_map, - ResourceCollector &resources, - const Map<const fn::MFOutputSocket *, std::string> &attribute_inputs) -{ - Vector<const ParticleForce *> forces; - for (const nodes::DOutputSocket *origin_socket : - simulation_node.input(2, "Forces").linked_sockets()) { - const nodes::DNode &origin_node = origin_socket->node(); - if (origin_node.idname() != "SimulationNodeForce") { - continue; - } - - const fn::MFInputSocket &force_socket = network_map.lookup_dummy( - origin_node.input(0, "Force")); - - const ParticleFunction *particle_fn = create_particle_function_for_inputs( - {&force_socket}, resources, attribute_inputs); - - if (particle_fn == nullptr) { - continue; - } - - const ParticleForce &force = resources.construct<ParticleFunctionForce>(AT, *particle_fn); - forces.append(&force); - } - return forces; -} - -static void collect_forces(Simulation &simulation, - nodes::MFNetworkTreeMap &network_map, - ResourceCollector &resources, - const Map<const fn::MFOutputSocket *, std::string> &attribute_inputs, - SimulationInfluences &r_influences) -{ - for (const nodes::DNode *dnode : - network_map.tree().nodes_by_type("SimulationNodeParticleSimulation")) { - std::string name = dnode_to_path(*dnode); - Vector<const ParticleForce *> forces = create_forces_for_particle_simulation( - *dnode, network_map, resources, attribute_inputs); - ParticleSimulationState *state = (ParticleSimulationState *)try_find_state_by_name(&simulation, - name); - r_influences.particle_forces.add_new(state, std::move(forces)); - } -} - void update_simulation_in_depsgraph(Depsgraph *depsgraph, Scene *scene_cow, Simulation *simulation_cow) @@ -360,24 +150,15 @@ void update_simulation_in_depsgraph(Depsgraph *depsgraph, nodes::NodeTreeRefMap tree_refs; /* TODO: Use simulation_cow, but need to add depsgraph relations before that. */ const nodes::DerivedNodeTree tree{simulation_orig->nodetree, tree_refs}; - fn::MFNetwork network; - ResourceCollector resources; - nodes::MFNetworkTreeMap network_map = insert_node_tree_into_mf_network(network, tree, resources); - Map<const fn::MFOutputSocket *, std::string> attribute_inputs = deduplicate_attribute_nodes( - network, network_map, tree); - fn::mf_network_optimization::constant_folding(network, resources); - fn::mf_network_optimization::common_subnetwork_elimination(network); - fn::mf_network_optimization::dead_node_removal(network); - // WM_clipboard_text_set(network.to_dot().c_str(), false); - SimulationInfluences simulation_influences; - collect_forces( - *simulation_orig, network_map, resources, attribute_inputs, simulation_influences); + ResourceCollector resources; + SimulationInfluences influences; + collect_simulation_influences(tree, resources, influences); if (current_frame == 1) { reinitialize_empty_simulation_states(simulation_orig, tree); - initialize_simulation_states(*simulation_orig, *depsgraph, simulation_influences); + initialize_simulation_states(*simulation_orig, *depsgraph, influences); simulation_orig->current_frame = 1; copy_states_to_cow(simulation_orig, simulation_cow); @@ -386,7 +167,7 @@ void update_simulation_in_depsgraph(Depsgraph *depsgraph, update_simulation_state_list(simulation_orig, tree); float time_step = 1.0f / 24.0f; - solve_simulation_time_step(*simulation_orig, *depsgraph, simulation_influences, time_step); + solve_simulation_time_step(*simulation_orig, *depsgraph, influences, time_step); simulation_orig->current_frame = current_frame; copy_states_to_cow(simulation_orig, simulation_cow); |