[Bf-blender-cvs] [904966b3efb] functions: particle function contains two functions: with/without dependencies
Jacques Lucke
noreply at git.blender.org
Mon Jul 29 17:57:09 CEST 2019
Commit: 904966b3efbf4db0daf41d4f6ae5f5ab7e6eccd0
Author: Jacques Lucke
Date: Mon Jul 29 11:14:38 2019 +0200
Branches: functions
https://developer.blender.org/rB904966b3efbf4db0daf41d4f6ae5f5ab7e6eccd0
particle function contains two functions: with/without dependencies
===================================================================
M source/blender/simulations/bparticles/inserters.cpp
M source/blender/simulations/bparticles/particle_function.cpp
M source/blender/simulations/bparticles/particle_function.hpp
===================================================================
diff --git a/source/blender/simulations/bparticles/inserters.cpp b/source/blender/simulations/bparticles/inserters.cpp
index 74c667e3ffe..00d4f2198ee 100644
--- a/source/blender/simulations/bparticles/inserters.cpp
+++ b/source/blender/simulations/bparticles/inserters.cpp
@@ -87,7 +87,12 @@ ValueOrError<ParticleFunction> create_particle_function(VirtualNode *main_vnode,
FunctionGraph fgraph(data_graph.graph(), dependencies.sockets, sockets_to_compute);
FN::fgraph_add_TupleCallBody(fn, fgraph);
- ParticleFunction particle_function(fn);
+ FunctionBuilder empty_fn_builder;
+ SharedFunction empty_fn = empty_fn_builder.build("Empty");
+
+ Vector<bool> depends_on_particle(fn->output_amount(), true);
+
+ ParticleFunction particle_function(empty_fn, fn, depends_on_particle);
return particle_function;
}
@@ -241,13 +246,13 @@ static std::unique_ptr<Event> BUILD_EVENT_close_by_points(BuildContext &ctx,
VirtualNode *vnode,
ParticleFunction compute_inputs)
{
- if (compute_inputs.depends_on_particle()) {
+ if (compute_inputs.parameter_depends_on_particle("Points", 0)) {
return {};
}
auto action = build_action_for_trigger(ctx, vnode->output(0));
- SharedFunction &fn = compute_inputs.function();
+ SharedFunction &fn = compute_inputs.function_no_deps();
BLI_assert(fn->input_amount() == 0);
TupleCallBody &body = fn->body<TupleCallBody>();
FN_TUPLE_CALL_ALLOC_TUPLES(body, fn_in, fn_out);
diff --git a/source/blender/simulations/bparticles/particle_function.cpp b/source/blender/simulations/bparticles/particle_function.cpp
index ca31936ba04..b002d36217f 100644
--- a/source/blender/simulations/bparticles/particle_function.cpp
+++ b/source/blender/simulations/bparticles/particle_function.cpp
@@ -41,37 +41,46 @@ std::unique_ptr<ParticleFunctionResult> ParticleFunction::compute(ArrayAllocator
AttributeArrays attributes,
ActionContext *action_context)
{
- if (m_fn->input_amount() == 0) {
- BLI_assert(array_allocator.array_size() >= 1);
+ uint parameter_amount = m_parameter_depends_on_particle.size();
- ParticleFunctionResult *result = new ParticleFunctionResult();
- result->m_fn = m_fn.ptr();
- result->m_array_allocator = &array_allocator;
+ ParticleFunctionResult *result = new ParticleFunctionResult();
+ result->m_array_allocator = &array_allocator;
+ result->m_buffers.append_n_times(nullptr, parameter_amount);
+ result->m_only_first.append_n_times(false, parameter_amount);
+ result->m_strides.append_n_times(0, parameter_amount);
- FN_TUPLE_CALL_ALLOC_TUPLES(*m_body, fn_in, fn_out);
- m_body->call__setup_execution_context(fn_in, fn_out);
+ if (m_fn_no_deps->output_amount() > 0) {
+ TupleCallBody &body = m_fn_no_deps->body<TupleCallBody>();
- for (uint i = 0; i < m_fn->output_amount(); i++) {
- CPPTypeInfo &type_info = m_fn->output_type(i)->extension<CPPTypeInfo>();
+ FN_TUPLE_CALL_ALLOC_TUPLES(body, fn_in, fn_out);
+ body.call__setup_execution_context(fn_in, fn_out);
+
+ for (uint parameter_index = 0; parameter_index < parameter_amount; parameter_index++) {
+ if (m_parameter_depends_on_particle[parameter_index]) {
+ continue;
+ }
+ uint output_index = m_output_indices[parameter_index];
+ CPPTypeInfo &type_info = m_fn_no_deps->output_type(output_index)->extension<CPPTypeInfo>();
uint output_stride = type_info.size_of_type();
void *output_buffer = array_allocator.allocate(output_stride);
- result->m_buffers.append(output_buffer);
- result->m_strides.append(output_stride);
- result->m_only_first.append(true);
+ result->m_buffers[parameter_index] = output_buffer;
+ result->m_strides[parameter_index] = output_stride;
+ result->m_only_first[parameter_index] = true;
- fn_out.relocate_out__dynamic(i, output_buffer);
+ fn_out.relocate_out__dynamic(output_index, output_buffer);
}
-
- return std::unique_ptr<ParticleFunctionResult>(result);
}
- else {
+
+ if (m_fn_with_deps->output_amount() > 0) {
+ TupleCallBody &body = m_fn_with_deps->body<TupleCallBody>();
+
Vector<void *> input_buffers;
Vector<uint> input_strides;
- for (uint i = 0; i < m_fn->input_amount(); i++) {
- StringRef input_name = m_fn->input_name(i);
+ for (uint i = 0; i < m_fn_with_deps->input_amount(); i++) {
+ StringRef input_name = m_fn_with_deps->input_name(i);
void *input_buffer = nullptr;
uint input_stride = 0;
if (input_name.startswith("Attribute")) {
@@ -95,25 +104,32 @@ std::unique_ptr<ParticleFunctionResult> ParticleFunction::compute(ArrayAllocator
input_strides.append(input_stride);
}
- ParticleFunctionResult *result = new ParticleFunctionResult();
- result->m_fn = m_fn.ptr();
- result->m_array_allocator = &array_allocator;
+ Vector<void *> output_buffers;
+ Vector<uint> output_strides;
- for (uint i = 0; i < m_fn->output_amount(); i++) {
- CPPTypeInfo &type_info = m_fn->output_type(i)->extension<CPPTypeInfo>();
+ for (uint parameter_index = 0; parameter_index < parameter_amount; parameter_index++) {
+ if (!m_parameter_depends_on_particle[parameter_index]) {
+ continue;
+ }
+
+ uint output_index = m_output_indices[parameter_index];
+ CPPTypeInfo &type_info = m_fn_with_deps->output_type(output_index)->extension<CPPTypeInfo>();
uint output_stride = type_info.size_of_type();
void *output_buffer = array_allocator.allocate(output_stride);
- result->m_buffers.append(output_buffer);
- result->m_strides.append(output_stride);
- result->m_only_first.append(false);
+ result->m_buffers[parameter_index] = output_buffer;
+ result->m_strides[parameter_index] = output_stride;
+ result->m_only_first[parameter_index] = false;
+
+ output_buffers.append(output_buffer);
+ output_strides.append(output_stride);
}
ExecutionStack stack;
ExecutionContext execution_context(stack);
- FN_TUPLE_CALL_ALLOC_TUPLES(*m_body, fn_in, fn_out);
+ FN_TUPLE_CALL_ALLOC_TUPLES(body, fn_in, fn_out);
for (uint pindex : pindices) {
for (uint i = 0; i < input_buffers.size(); i++) {
@@ -121,16 +137,16 @@ std::unique_ptr<ParticleFunctionResult> ParticleFunction::compute(ArrayAllocator
fn_in.copy_in__dynamic(i, ptr);
}
- m_body->call(fn_in, fn_out, execution_context);
+ body.call(fn_in, fn_out, execution_context);
- for (uint i = 0; i < result->m_buffers.size(); i++) {
- void *ptr = POINTER_OFFSET(result->m_buffers[i], pindex * result->m_strides[i]);
+ for (uint i = 0; i < output_buffers.size(); i++) {
+ void *ptr = POINTER_OFFSET(output_buffers[i], pindex * output_strides[i]);
fn_out.relocate_out__dynamic(i, ptr);
}
}
-
- return std::unique_ptr<ParticleFunctionResult>(result);
}
+
+ return std::unique_ptr<ParticleFunctionResult>(result);
}
} // namespace BParticles
diff --git a/source/blender/simulations/bparticles/particle_function.hpp b/source/blender/simulations/bparticles/particle_function.hpp
index 203e1dce93e..4eb2c867cc3 100644
--- a/source/blender/simulations/bparticles/particle_function.hpp
+++ b/source/blender/simulations/bparticles/particle_function.hpp
@@ -24,7 +24,6 @@ class ParticleFunctionResult {
Vector<uint> m_strides;
Vector<bool> m_only_first;
ArrayAllocator *m_array_allocator;
- FN::Function *m_fn;
friend ParticleFunction;
@@ -42,11 +41,11 @@ class ParticleFunctionResult {
template<typename T> T get(StringRef expected_name, uint parameter_index, uint pindex)
{
-#ifdef DEBUG
- BLI_assert(sizeof(T) == m_strides[parameter_index]);
- StringRefNull real_name = m_fn->output_name(parameter_index);
- BLI_assert(real_name == expected_name);
-#endif
+ // #ifdef DEBUG
+ // BLI_assert(sizeof(T) == m_strides[parameter_index]);
+ // StringRefNull real_name = m_fn->output_name(parameter_index);
+ // BLI_assert(real_name == expected_name);
+ // #endif
UNUSED_VARS_NDEBUG(expected_name);
T *buffer = (T *)m_buffers[parameter_index];
@@ -61,23 +60,57 @@ class ParticleFunctionResult {
class ParticleFunction {
private:
- SharedFunction m_fn;
- TupleCallBody *m_body;
+ SharedFunction m_fn_no_deps;
+ SharedFunction m_fn_with_deps;
+ Vector<bool> m_parameter_depends_on_particle;
+ Vector<uint> m_output_indices;
public:
- ParticleFunction(SharedFunction fn) : m_fn(std::move(fn)), m_body(&m_fn->body<TupleCallBody>())
+ ParticleFunction(SharedFunction fn_no_deps,
+ SharedFunction fn_with_deps,
+ Vector<bool> parameter_depends_on_particle)
+ : m_fn_no_deps(std::move(fn_no_deps)),
+ m_fn_with_deps(std::move(fn_with_deps)),
+ m_parameter_depends_on_particle(std::move(parameter_depends_on_particle))
{
- BLI_assert(m_body != nullptr);
+ BLI_assert(m_fn_no_deps->output_amount() + m_fn_with_deps->output_amount() ==
+ m_parameter_depends_on_particle.size());
+
+ uint no_deps_index = 0;
+ uint with_deps_index = 0;
+ for (uint i = 0; i < m_parameter_depends_on_particle.size(); i++) {
+ if (m_parameter_depends_on_particle[i]) {
+ m_output_indices.append(with_deps_index);
+ with_deps_index++;
+ }
+ else {
+ m_output_indices.append(no_deps_index);
+ no_deps_index++;
+ }
+ }
}
- bool depends_on_particle()
+ SharedFunction &function_no_deps()
{
- return m_fn->input_amount() > 0;
+ return m_fn_no_deps;
}
- SharedFunction &function()
+ bool parameter_depends_on_particle(StringRef expected_name, uint parameter_index)
{
- return m_fn;
+ bool depends_on_particle = m_parameter_depends_on_particle[parameter_index];
+#ifdef DEBUG
+ uint output_index = m_output_indices[parameter_index];
+ if (depends_on_particle) {
+ StringRefNull real_name = m_fn_with_deps->output_name(outp
@@ Diff output truncated at 10240 characters. @@
More information about the Bf-blender-cvs
mailing list