diff options
6 files changed, 77 insertions, 78 deletions
diff --git a/source/blender/simulations/bparticles/actions.cpp b/source/blender/simulations/bparticles/actions.cpp index 9aa282baa6b..7f5ac3a3e58 100644 --- a/source/blender/simulations/bparticles/actions.cpp +++ b/source/blender/simulations/bparticles/actions.cpp @@ -43,8 +43,8 @@ static void update_position_and_velocity_offsets(ParticleActionContext &context) void ConditionAction::execute(ParticleActionContext &context) { - auto inputs = ParticleFunctionResult::Compute( - *m_inputs_fn, context.pindex_mask(), context.attributes()); + ParticleFunctionEvaluator inputs{*m_inputs_fn, context.pindex_mask(), context.attributes()}; + inputs.compute(); Vector<uint> true_pindices, false_pindices; for (uint pindex : context.pindex_mask().indices()) { @@ -71,8 +71,8 @@ void SetAttributeAction::execute(ParticleActionContext &context) GenericMutableArrayRef attribute = *attribute_opt; - auto inputs = ParticleFunctionResult::Compute( - m_inputs_fn, context.pindex_mask(), context.attributes()); + ParticleFunctionEvaluator inputs{m_inputs_fn, context.pindex_mask(), context.attributes()}; + inputs.compute(); for (uint pindex : context.pindex_mask().indices()) { const void *value = inputs.get_single("Value", 0, pindex); @@ -102,8 +102,8 @@ void SpawnParticlesAction::execute(ParticleActionContext &context) uint array_size = context.pindex_mask().min_array_size(); - auto inputs = ParticleFunctionResult::Compute( - m_spawn_function, context.pindex_mask(), context.attributes()); + ParticleFunctionEvaluator inputs{m_spawn_function, context.pindex_mask(), context.attributes()}; + inputs.compute(); LargeScopedArray<int> particle_counts(array_size, -1); diff --git a/source/blender/simulations/bparticles/events.cpp b/source/blender/simulations/bparticles/events.cpp index b98b6ad1e85..451b0e76af1 100644 --- a/source/blender/simulations/bparticles/events.cpp +++ b/source/blender/simulations/bparticles/events.cpp @@ -14,8 +14,8 @@ void AgeReachedEvent::filter(EventFilterInterface &interface) { AttributesRef attributes = interface.attributes(); - auto inputs = ParticleFunctionResult::Compute( - *m_inputs_fn, interface.index_mask(), interface.attributes()); + ParticleFunctionEvaluator inputs{*m_inputs_fn, interface.index_mask(), interface.attributes()}; + inputs.compute(); float end_time = interface.step_end_time(); auto birth_times = attributes.get<float>("Birth Time"); @@ -63,12 +63,9 @@ void CustomEvent::filter(EventFilterInterface &interface) { FN::EventFilterEndTimeContext end_time_context = {interface.step_end_time()}; - auto inputs = ParticleFunctionResult::Compute( - m_inputs_fn, - interface.index_mask(), - interface.attributes(), - {BLI::get_class_id<FN::EventFilterEndTimeContext>()}, - {(const void *)&end_time_context}); + ParticleFunctionEvaluator inputs{m_inputs_fn, interface.index_mask(), interface.attributes()}; + inputs.context_builder().add_global_context(end_time_context); + inputs.compute(); for (uint pindex : interface.index_mask().indices()) { bool condition = inputs.get_single<bool>("Condition", 0, pindex); diff --git a/source/blender/simulations/bparticles/forces.cpp b/source/blender/simulations/bparticles/forces.cpp index 015fa62bcde..f340bce8245 100644 --- a/source/blender/simulations/bparticles/forces.cpp +++ b/source/blender/simulations/bparticles/forces.cpp @@ -12,8 +12,8 @@ void CustomForce::add_force(ForceInterface &interface) { MutableArrayRef<float3> dst = interface.combined_destination(); - auto inputs = ParticleFunctionResult::Compute( - *m_inputs_fn, interface.pindices(), interface.attributes()); + ParticleFunctionEvaluator inputs{*m_inputs_fn, interface.pindices(), interface.attributes()}; + inputs.compute(); for (uint pindex : interface.pindices()) { dst[pindex] += inputs.get_single<float3>("Force", 0, pindex); diff --git a/source/blender/simulations/bparticles/offset_handlers.cpp b/source/blender/simulations/bparticles/offset_handlers.cpp index d9e3ebaf9b7..77af449ca04 100644 --- a/source/blender/simulations/bparticles/offset_handlers.cpp +++ b/source/blender/simulations/bparticles/offset_handlers.cpp @@ -10,8 +10,8 @@ void CreateTrailHandler::execute(OffsetHandlerInterface &interface) auto position_offsets = interface.attribute_offsets().get<float3>("Position"); auto colors = interface.attributes().get<rgba_f>("Color"); - auto inputs = ParticleFunctionResult::Compute( - *m_inputs_fn, interface.pindices(), interface.attributes()); + ParticleFunctionEvaluator inputs{*m_inputs_fn, interface.pindices(), interface.attributes()}; + inputs.compute(); Vector<float3> new_positions; Vector<rgba_f> new_colors; @@ -53,8 +53,8 @@ void SizeOverTimeHandler::execute(OffsetHandlerInterface &interface) auto birth_times = interface.attributes().get<float>("Birth Time"); auto sizes = interface.attributes().get<float>("Size"); - auto inputs = ParticleFunctionResult::Compute( - *m_inputs_fn, interface.pindices(), interface.attributes()); + ParticleFunctionEvaluator inputs{*m_inputs_fn, interface.pindices(), interface.attributes()}; + inputs.compute(); for (uint pindex : interface.pindices()) { float final_size = inputs.get_single<float>("Final Size", 0, pindex); diff --git a/source/blender/simulations/bparticles/particle_function.cpp b/source/blender/simulations/bparticles/particle_function.cpp index 7654e1dd562..a0b7772a46d 100644 --- a/source/blender/simulations/bparticles/particle_function.cpp +++ b/source/blender/simulations/bparticles/particle_function.cpp @@ -41,32 +41,30 @@ ParticleFunction::ParticleFunction(const MultiFunction &fn, } } -ParticleFunctionResult::~ParticleFunctionResult() +ParticleFunctionEvaluator::~ParticleFunctionEvaluator() { - for (GenericVectorArray *vector_array : m_vector_arrays) { + BLI_assert(m_is_computed); + for (GenericVectorArray *vector_array : m_computed_vector_arrays) { delete vector_array; } - for (GenericMutableArrayRef array : m_arrays) { + for (GenericMutableArrayRef array : m_computed_arrays) { array.destruct_indices(m_mask.indices()); MEM_freeN(array.buffer()); } } -ParticleFunctionResult ParticleFunctionResult::Compute(const ParticleFunction &particle_fn, - IndexMask mask, - AttributesRef attributes, - ArrayRef<BLI::class_id_t> context_ids, - ArrayRef<const void *> contexts) +void ParticleFunctionEvaluator::compute() { - uint array_size = mask.min_array_size(); + BLI_assert(!m_is_computed); - const MultiFunction &fn = particle_fn.m_fn; + uint array_size = m_mask.min_array_size(); - ParticleFunctionResult result; - result.m_mask = mask; - result.m_index_mapping = particle_fn.m_index_mapping; - result.m_computed_names = particle_fn.m_computed_names; + FN::ParticleAttributesContext attributes_context(m_particle_attributes); + m_context_builder.add_element_context(attributes_context, IndexRange(array_size)); + m_context_builder.add_global_context(m_particle_fn.m_id_data_cache); + m_context_builder.add_global_context(m_particle_fn.m_id_handle_lookup); + const MultiFunction &fn = m_particle_fn.fn(); MFParamsBuilder params_builder(fn, array_size); for (uint param_index : fn.param_indices()) { MFParamType param_type = fn.param_type(param_index); @@ -78,33 +76,21 @@ ParticleFunctionResult ParticleFunctionResult::Compute(const ParticleFunction &p void *buffer = MEM_mallocN_aligned(array_size * type.size(), type.alignment(), __func__); GenericMutableArrayRef array{type, buffer, array_size}; params_builder.add_single_output(array); - result.m_arrays.append(array); + m_computed_arrays.append(array); break; } case MFDataType::Vector: { const CPPType &base_type = data_type.vector__cpp_base_type(); GenericVectorArray *vector_array = new GenericVectorArray(base_type, array_size); params_builder.add_vector_output(*vector_array); - result.m_vector_arrays.append(vector_array); + m_computed_vector_arrays.append(vector_array); break; } } } - FN::ParticleAttributesContext attributes_context(attributes); - - MFContextBuilder context_builder; - context_builder.add_element_context(attributes_context, IndexRange(array_size)); - context_builder.add_global_context(particle_fn.m_id_data_cache); - context_builder.add_global_context(particle_fn.m_id_handle_lookup); - - for (uint i : context_ids.index_iterator()) { - context_builder.add_global_context(context_ids[i], contexts[i]); - } - - fn.call(mask, params_builder, context_builder); - - return result; + fn.call(m_mask, params_builder, m_context_builder); + m_is_computed = true; } } // namespace BParticles diff --git a/source/blender/simulations/bparticles/particle_function.hpp b/source/blender/simulations/bparticles/particle_function.hpp index 1611df2e5dc..c16a4e4a5c0 100644 --- a/source/blender/simulations/bparticles/particle_function.hpp +++ b/source/blender/simulations/bparticles/particle_function.hpp @@ -30,7 +30,7 @@ class ParticleFunction { const BKE::IDDataCache &m_id_data_cache; const BKE::IDHandleLookup &m_id_handle_lookup; - friend class ParticleFunctionResult; + friend class ParticleFunctionEvaluator; public: ParticleFunction(const MultiFunction &fn, @@ -44,73 +44,89 @@ class ParticleFunction { } }; -class ParticleFunctionResult : BLI::NonCopyable { +class ParticleFunctionEvaluator { private: - Vector<GenericVectorArray *> m_vector_arrays; - Vector<GenericMutableArrayRef> m_arrays; - - ArrayRef<uint> m_index_mapping; + const ParticleFunction &m_particle_fn; IndexMask m_mask; - ArrayRef<std::string> m_computed_names; + AttributesRef m_particle_attributes; + bool m_is_computed = false; + + FN::MFContextBuilder m_context_builder; - ParticleFunctionResult() = default; + Vector<GenericVectorArray *> m_computed_vector_arrays; + Vector<GenericMutableArrayRef> m_computed_arrays; public: - ~ParticleFunctionResult(); - ParticleFunctionResult(ParticleFunctionResult &&other) = default; + ParticleFunctionEvaluator(const ParticleFunction &particle_fn, + IndexMask mask, + AttributesRef particle_attributes) + : m_particle_fn(particle_fn), m_mask(mask), m_particle_attributes(particle_attributes) + { + } + + ~ParticleFunctionEvaluator(); + + FN::MFContextBuilder &context_builder() + { + return m_context_builder; + } + + void compute(); - static ParticleFunctionResult Compute(const ParticleFunction &particle_fn, - IndexMask mask, - AttributesRef attributes, - ArrayRef<BLI::class_id_t> context_ids = {}, - ArrayRef<const void *> contexts = {}); + /* Access computed values + *********************************************/ const void *get_single(StringRef expected_name, uint param_index, uint pindex) { + BLI_assert(m_is_computed); UNUSED_VARS_NDEBUG(expected_name); #ifdef DEBUG - StringRef actual_name = m_computed_names[param_index]; + StringRef actual_name = m_particle_fn.m_computed_names[param_index]; BLI_assert(expected_name == actual_name); #endif - uint corrected_index = m_index_mapping[param_index]; - return m_arrays[corrected_index][pindex]; + uint corrected_index = m_particle_fn.m_index_mapping[param_index]; + return m_computed_arrays[corrected_index][pindex]; } template<typename T> const T &get_single(StringRef expected_name, uint param_index, uint pindex) { + BLI_assert(m_is_computed); UNUSED_VARS_NDEBUG(expected_name); #ifdef DEBUG - StringRef actual_name = m_computed_names[param_index]; + StringRef actual_name = m_particle_fn.m_computed_names[param_index]; BLI_assert(expected_name == actual_name); #endif - uint corrected_index = m_index_mapping[param_index]; - ArrayRef<T> array = m_arrays[corrected_index].as_typed_ref<T>(); + uint corrected_index = m_particle_fn.m_index_mapping[param_index]; + ArrayRef<T> array = m_computed_arrays[corrected_index].as_typed_ref<T>(); return array[pindex]; } template<typename T> ArrayRef<T> get_vector(StringRef expected_name, uint param_index, uint pindex) { + BLI_assert(m_is_computed); UNUSED_VARS_NDEBUG(expected_name); #ifdef DEBUG - StringRef actual_name = m_computed_names[param_index]; + StringRef actual_name = m_particle_fn.m_computed_names[param_index]; BLI_assert(expected_name == actual_name); #endif - uint corrected_index = m_index_mapping[param_index]; - GenericVectorArray &vector_array = *m_vector_arrays[corrected_index]; + uint corrected_index = m_particle_fn.m_index_mapping[param_index]; + GenericVectorArray &vector_array = *m_computed_vector_arrays[corrected_index]; return vector_array[pindex].as_typed_ref<T>(); } GenericVectorArray &computed_vector_array(uint param_index) { - uint corrected_index = m_index_mapping[param_index]; - return *m_vector_arrays[corrected_index]; + BLI_assert(m_is_computed); + uint corrected_index = m_particle_fn.m_index_mapping[param_index]; + return *m_computed_vector_arrays[corrected_index]; } GenericArrayRef computed_array(uint param_index) { - uint corrected_index = m_index_mapping[param_index]; - return m_arrays[corrected_index]; + BLI_assert(m_is_computed); + uint corrected_index = m_particle_fn.m_index_mapping[param_index]; + return m_computed_arrays[corrected_index]; } }; |