diff options
75 files changed, 550 insertions, 558 deletions
diff --git a/source/blender/functions/backends/dependencies/fgraph_dependencies.cpp b/source/blender/functions/backends/dependencies/fgraph_dependencies.cpp index 55bcae3f0d4..dbc98521c75 100644 --- a/source/blender/functions/backends/dependencies/fgraph_dependencies.cpp +++ b/source/blender/functions/backends/dependencies/fgraph_dependencies.cpp @@ -32,11 +32,11 @@ class FGraphDependencies : public DepsBody { } else { uint node_id = m_graph.node_id_of_output(socket); - SharedFunction &fn = m_graph.function_of_node(node_id); - if (fn->has_body<DepsBody>()) { + Function &fn = m_graph.function_of_node(node_id); + if (fn.has_body<DepsBody>()) { MultiMap<uint, ID *> input_ids; - for (uint i = 0; i < fn->input_amount(); i++) { + for (uint i = 0; i < fn.input_amount(); i++) { input_ids.add_multiple_new( i, this->find_deps_and_outputs(m_graph.socket_of_node_input(node_id, i), @@ -45,7 +45,7 @@ class FGraphDependencies : public DepsBody { MultiMap<uint, ID *> output_ids; FunctionDepsBuilder builder(input_ids, output_ids, parent_builder.dependency_components()); - DepsBody &body = fn->body<DepsBody>(); + DepsBody &body = fn.body<DepsBody>(); body.build_deps(builder); return output_ids.lookup_default(m_graph.index_of_output(socket)); } @@ -59,9 +59,9 @@ class FGraphDependencies : public DepsBody { } }; -void fgraph_add_DependenciesBody(SharedFunction &fn, FunctionGraph &fgraph) +void fgraph_add_DependenciesBody(Function &fn, FunctionGraph &fgraph) { - fn->add_body<FGraphDependencies>(fgraph); + fn.add_body<FGraphDependencies>(fgraph); } } // namespace FN diff --git a/source/blender/functions/backends/dependencies/fgraph_dependencies.hpp b/source/blender/functions/backends/dependencies/fgraph_dependencies.hpp index 50f2dfb373f..f2d373c4c7c 100644 --- a/source/blender/functions/backends/dependencies/fgraph_dependencies.hpp +++ b/source/blender/functions/backends/dependencies/fgraph_dependencies.hpp @@ -5,6 +5,6 @@ namespace FN { -void fgraph_add_DependenciesBody(SharedFunction &fn, FunctionGraph &fgraph); +void fgraph_add_DependenciesBody(Function &fn, FunctionGraph &fgraph); } /* namespace FN */ diff --git a/source/blender/functions/backends/llvm/build_ir_body.cpp b/source/blender/functions/backends/llvm/build_ir_body.cpp index 64a40c30962..5a30ac82944 100644 --- a/source/blender/functions/backends/llvm/build_ir_body.cpp +++ b/source/blender/functions/backends/llvm/build_ir_body.cpp @@ -7,11 +7,11 @@ llvm::Function *LLVMBuildIRBody::build_function(llvm::Module *module, BuildIRSettings &settings, FunctionIRCache &function_cache) { - Function *owner_fn = this->owner(); + Function &owner_fn = this->owner(); llvm::LLVMContext &context = module->getContext(); - uint input_amount = owner_fn->input_amount(); - uint output_amount = owner_fn->output_amount(); + uint input_amount = owner_fn.input_amount(); + uint output_amount = owner_fn.output_amount(); Vector<LLVMTypeInfo *> input_type_infos(input_amount); Vector<LLVMTypeInfo *> output_type_infos(output_amount); @@ -19,13 +19,13 @@ llvm::Function *LLVMBuildIRBody::build_function(llvm::Module *module, Vector<llvm::Type *> output_types(output_amount); for (uint i = 0; i < input_amount; i++) { - LLVMTypeInfo &type_info = owner_fn->input_type(i)->extension<LLVMTypeInfo>(); + LLVMTypeInfo &type_info = owner_fn.input_type(i)->extension<LLVMTypeInfo>(); input_type_infos[i] = &type_info; input_types[i] = type_info.get_type(context); } for (uint i = 0; i < output_amount; i++) { - LLVMTypeInfo &type_info = owner_fn->output_type(i)->extension<LLVMTypeInfo>(); + LLVMTypeInfo &type_info = owner_fn.output_type(i)->extension<LLVMTypeInfo>(); output_type_infos[i] = &type_info; output_types[i] = type_info.get_type(context); } @@ -42,7 +42,7 @@ llvm::Function *LLVMBuildIRBody::build_function(llvm::Module *module, Vector<llvm::Value *> input_values(input_amount); for (uint i = 0; i < input_amount; i++) { - input_values[i] = builder.take_function_input(i, owner_fn->input_name(i)); + input_values[i] = builder.take_function_input(i, owner_fn.input_name(i)); } llvm::Value *context_ptr = builder.take_function_input(input_amount, "context_ptr"); Vector<llvm::Value *> output_values(output_amount); diff --git a/source/blender/functions/backends/llvm/fgraph_ir_generation.cpp b/source/blender/functions/backends/llvm/fgraph_ir_generation.cpp index 03958aa00e6..cd51310574b 100644 --- a/source/blender/functions/backends/llvm/fgraph_ir_generation.cpp +++ b/source/blender/functions/backends/llvm/fgraph_ir_generation.cpp @@ -14,15 +14,15 @@ class BuildGraphIR : public LLVMBuildIRBody { BuildGraphIR(FunctionGraph &fgraph) : m_fgraph(fgraph), m_graph(fgraph.graph()) { for (uint node_id : m_graph.node_ids()) { - SharedFunction &fn = m_graph.function_of_node(node_id); - if (fn->has_body<LLVMBuildIRBody>()) { + Function &fn = m_graph.function_of_node(node_id); + if (fn.has_body<LLVMBuildIRBody>()) { continue; } - if (fn->has_body<TupleCallBody>()) { + if (fn.has_body<TupleCallBody>()) { derive_LLVMBuildIRBody_from_TupleCallBody(fn); continue; } - if (fn->has_body<LazyInTupleCallBody>()) { + if (fn.has_body<LazyInTupleCallBody>()) { derive_TupleCallBody_from_LazyInTupleCallBody(fn); derive_LLVMBuildIRBody_from_TupleCallBody(fn); continue; @@ -139,8 +139,8 @@ class BuildGraphIR : public LLVMBuildIRBody { uint node_id, Vector<llvm::Value *> &input_values) const { - SharedFunction &fn = m_graph.function_of_node(node_id); - auto &body = fn->body<LLVMBuildIRBody>(); + Function &fn = m_graph.function_of_node(node_id); + auto &body = fn.body<LLVMBuildIRBody>(); bool setup_stack = settings.maintain_stack() && body.prepare_execution_context(); if (setup_stack) { @@ -210,9 +210,9 @@ class BuildGraphIR : public LLVMBuildIRBody { } }; -void fgraph_add_LLVMBuildIRBody(SharedFunction &fn, FunctionGraph &fgraph) +void fgraph_add_LLVMBuildIRBody(Function &fn, FunctionGraph &fgraph) { - fn->add_body<BuildGraphIR>(fgraph); + fn.add_body<BuildGraphIR>(fgraph); } } /* namespace FN */ diff --git a/source/blender/functions/backends/llvm/fgraph_ir_generation.hpp b/source/blender/functions/backends/llvm/fgraph_ir_generation.hpp index 7ddb7232fd7..a00dd62a397 100644 --- a/source/blender/functions/backends/llvm/fgraph_ir_generation.hpp +++ b/source/blender/functions/backends/llvm/fgraph_ir_generation.hpp @@ -4,6 +4,6 @@ namespace FN { -void fgraph_add_LLVMBuildIRBody(SharedFunction &fn, FunctionGraph &fgraph); +void fgraph_add_LLVMBuildIRBody(Function &fn, FunctionGraph &fgraph); } /* namespace FN */ diff --git a/source/blender/functions/backends/llvm/ir_for_tuple_call.cpp b/source/blender/functions/backends/llvm/ir_for_tuple_call.cpp index b6cb2fcac31..b783077de93 100644 --- a/source/blender/functions/backends/llvm/ir_for_tuple_call.cpp +++ b/source/blender/functions/backends/llvm/ir_for_tuple_call.cpp @@ -60,11 +60,11 @@ class TupleCallLLVM : public LLVMBuildIRBody { CodeInterface &interface, const BuildIRSettings &settings) const override { - Function *fn = m_tuple_call.owner(); + Function &fn = m_tuple_call.owner(); /* Find relevant type information. */ - auto input_type_infos = fn->input_extensions<LLVMTypeInfo>(); - auto output_type_infos = fn->output_extensions<LLVMTypeInfo>(); + auto input_type_infos = fn.input_extensions<LLVMTypeInfo>(); + auto output_type_infos = fn.output_extensions<LLVMTypeInfo>(); /* Build wrapper function. */ llvm::Function *wrapper_function = this->get_wrapper_function( @@ -91,7 +91,7 @@ class TupleCallLLVM : public LLVMBuildIRBody { ArrayRef<LLVMTypeInfo *> input_type_infos, ArrayRef<LLVMTypeInfo *> output_type_infos) const { - Function *fn = m_tuple_call.owner(); + Function &fn = m_tuple_call.owner(); Vector<llvm::Type *> input_types = builder.types_of_values(interface.inputs()); if (settings.maintain_stack()) { @@ -116,7 +116,7 @@ class TupleCallLLVM : public LLVMBuildIRBody { wrapper_function = llvm::Function::Create(wrapper_function_type, llvm::GlobalValue::LinkageTypes::InternalLinkage, - fn->name() + " Wrapper", + fn.name() + " Wrapper", builder.getModule()); this->build_wrapper_function( @@ -182,12 +182,12 @@ class TupleCallLLVM : public LLVMBuildIRBody { } }; -void derive_LLVMBuildIRBody_from_TupleCallBody(SharedFunction &fn) +void derive_LLVMBuildIRBody_from_TupleCallBody(Function &fn) { - BLI_assert(fn->has_body<TupleCallBody>()); - BLI_assert(!fn->has_body<LLVMBuildIRBody>()); + BLI_assert(fn.has_body<TupleCallBody>()); + BLI_assert(!fn.has_body<LLVMBuildIRBody>()); - fn->add_body<TupleCallLLVM>(fn->body<TupleCallBody>()); + fn.add_body<TupleCallLLVM>(fn.body<TupleCallBody>()); } } /* namespace FN */ diff --git a/source/blender/functions/backends/llvm/ir_for_tuple_call.hpp b/source/blender/functions/backends/llvm/ir_for_tuple_call.hpp index ad72ffc94e4..dd0f8985532 100644 --- a/source/blender/functions/backends/llvm/ir_for_tuple_call.hpp +++ b/source/blender/functions/backends/llvm/ir_for_tuple_call.hpp @@ -8,6 +8,6 @@ class LLVMContext; namespace FN { -void derive_LLVMBuildIRBody_from_TupleCallBody(SharedFunction &fn); +void derive_LLVMBuildIRBody_from_TupleCallBody(Function &fn); } /* namespace FN */ diff --git a/source/blender/functions/backends/llvm/ir_to_tuple_call.cpp b/source/blender/functions/backends/llvm/ir_to_tuple_call.cpp index 34fa65457e1..021bab7e6d5 100644 --- a/source/blender/functions/backends/llvm/ir_to_tuple_call.cpp +++ b/source/blender/functions/backends/llvm/ir_to_tuple_call.cpp @@ -25,14 +25,14 @@ typedef void(TupleCallFunction)(uint8_t *data_in, uint32_t *offsets_out, uint8_t *execution_context); -static llvm::Function *insert_tuple_call_function(SharedFunction &fn, llvm::Module *module) +static llvm::Function *insert_tuple_call_function(Function &fn, llvm::Module *module) { llvm::LLVMContext &context = module->getContext(); - LLVMBuildIRBody &body = fn->body<LLVMBuildIRBody>(); + LLVMBuildIRBody &body = fn.body<LLVMBuildIRBody>(); llvm::FunctionType *function_type = llvm::TypeBuilder<TupleCallFunction, false>::get(context); llvm::Function *function = llvm::Function::Create( - function_type, llvm::GlobalValue::LinkageTypes::ExternalLinkage, fn->name().data(), module); + function_type, llvm::GlobalValue::LinkageTypes::ExternalLinkage, fn.name().data(), module); llvm::BasicBlock *bb = llvm::BasicBlock::Create(context, "entry", function); CodeBuilder builder(bb); @@ -49,16 +49,16 @@ static llvm::Function *insert_tuple_call_function(SharedFunction &fn, llvm::Modu context_ptr->setName("context"); Vector<llvm::Value *> input_values; - for (uint i = 0; i < fn->input_amount(); i++) { + for (uint i = 0; i < fn.input_amount(); i++) { llvm::Value *value_byte_addr = lookup_tuple_address(builder, fn_in_data, fn_in_offsets, i); - LLVMTypeInfo &type_info = fn->input_type(i)->extension<LLVMTypeInfo>(); + LLVMTypeInfo &type_info = fn.input_type(i)->extension<LLVMTypeInfo>(); llvm::Value *value = type_info.build_load_ir__relocate(builder, value_byte_addr); input_values.append(value); } - Vector<llvm::Value *> output_values(fn->output_amount()); + Vector<llvm::Value *> output_values(fn.output_amount()); BuildIRSettings settings; FunctionIRCache function_cache; CodeInterface interface(input_values, output_values, context_ptr, function_cache); @@ -67,7 +67,7 @@ static llvm::Function *insert_tuple_call_function(SharedFunction &fn, llvm::Modu for (uint i = 0; i < output_values.size(); i++) { llvm::Value *value_byte_addr = lookup_tuple_address(builder, fn_out_data, fn_out_offsets, i); - LLVMTypeInfo &type_info = fn->output_type(i)->extension<LLVMTypeInfo>(); + LLVMTypeInfo &type_info = fn.output_type(i)->extension<LLVMTypeInfo>(); type_info.build_store_ir__relocate(builder, output_values[i], value_byte_addr); } @@ -106,23 +106,23 @@ class LLVMTupleCall : public TupleCallBody { } }; -static std::unique_ptr<CompiledLLVM> compile_ir_to_tuple_call(SharedFunction &fn, +static std::unique_ptr<CompiledLLVM> compile_ir_to_tuple_call(Function &fn, llvm::LLVMContext &context) { - llvm::Module *module = new llvm::Module(fn->name().data(), context); + llvm::Module *module = new llvm::Module(fn.name().data(), context); llvm::Function *function = insert_tuple_call_function(fn, module); auto compiled = CompiledLLVM::FromIR(module, function); return compiled; } -void derive_TupleCallBody_from_LLVMBuildIRBody(SharedFunction &fn) +void derive_TupleCallBody_from_LLVMBuildIRBody(Function &fn) { - BLI_assert(fn->has_body<LLVMBuildIRBody>()); - BLI_assert(!fn->has_body<TupleCallBody>()); + BLI_assert(fn.has_body<LLVMBuildIRBody>()); + BLI_assert(!fn.has_body<TupleCallBody>()); auto *context = aquire_llvm_context(); - fn->add_body<LLVMTupleCall>(compile_ir_to_tuple_call(fn, *context)); + fn.add_body<LLVMTupleCall>(compile_ir_to_tuple_call(fn, *context)); release_llvm_context(context); } diff --git a/source/blender/functions/backends/llvm/ir_to_tuple_call.hpp b/source/blender/functions/backends/llvm/ir_to_tuple_call.hpp index 0a8924d7949..b03b316c9a7 100644 --- a/source/blender/functions/backends/llvm/ir_to_tuple_call.hpp +++ b/source/blender/functions/backends/llvm/ir_to_tuple_call.hpp @@ -4,6 +4,6 @@ namespace FN { -void derive_TupleCallBody_from_LLVMBuildIRBody(SharedFunction &fn); +void derive_TupleCallBody_from_LLVMBuildIRBody(Function &fn); } /* namespace FN */ diff --git a/source/blender/functions/backends/tuple_call/fgraph_tuple_call.cpp b/source/blender/functions/backends/tuple_call/fgraph_tuple_call.cpp index 2f0e71bdbe8..46315f20487 100644 --- a/source/blender/functions/backends/tuple_call/fgraph_tuple_call.cpp +++ b/source/blender/functions/backends/tuple_call/fgraph_tuple_call.cpp @@ -10,16 +10,16 @@ using BLI::VectorAdaptor; static void try_ensure_tuple_call_bodies(DataGraph &graph) { for (uint node_id : graph.node_ids()) { - SharedFunction &fn = graph.function_of_node(node_id); - if (fn->has_body<TupleCallBody>()) { + Function &fn = graph.function_of_node(node_id); + if (fn.has_body<TupleCallBody>()) { continue; } - if (fn->has_body<LazyInTupleCallBody>()) { + if (fn.has_body<LazyInTupleCallBody>()) { derive_TupleCallBody_from_LazyInTupleCallBody(fn); } - if (fn->has_body<LLVMBuildIRBody>()) { + if (fn.has_body<LLVMBuildIRBody>()) { derive_TupleCallBody_from_LLVMBuildIRBody(fn); } } @@ -67,34 +67,34 @@ class ExecuteFGraph : public TupleCallBody { ExecuteFGraph(FunctionGraph &fgraph) : m_fgraph(fgraph), m_graph(fgraph.graph()) { for (uint node_id : m_graph.node_ids()) { - SharedFunction &fn = m_graph.function_of_node(node_id); + Function &fn = m_graph.function_of_node(node_id); TupleCallBodyBase *body = nullptr; bool is_lazy_body = false; - if (fn->has_body<LazyInTupleCallBody>()) { - body = &fn->body<LazyInTupleCallBody>(); + if (fn.has_body<LazyInTupleCallBody>()) { + body = &fn.body<LazyInTupleCallBody>(); is_lazy_body = true; } - else if (fn->has_body<TupleCallBody>()) { - body = &fn->body<TupleCallBody>(); + else if (fn.has_body<TupleCallBody>()) { + body = &fn.body<TupleCallBody>(); is_lazy_body = false; } m_node_info.append( NodeInfo(body, is_lazy_body, m_inputs_buffer_size, m_outputs_buffer_size)); - m_inputs_init_buffer_size += fn->input_amount(); - m_outputs_init_buffer_size += fn->output_amount(); + m_inputs_init_buffer_size += fn.input_amount(); + m_outputs_init_buffer_size += fn.output_amount(); if (body == nullptr) { - for (auto type : fn->input_types()) { + for (auto type : fn.input_types()) { CPPTypeInfo &type_info = type->extension<CPPTypeInfo>(); uint type_size = type_info.size(); m_input_info.append(SocketInfo(type_info, m_inputs_buffer_size, false)); m_inputs_buffer_size += type_size; } - for (auto type : fn->output_types()) { + for (auto type : fn.output_types()) { CPPTypeInfo &type_info = type->extension<CPPTypeInfo>(); uint type_size = type_info.size(); m_output_info.append(SocketInfo(type_info, m_outputs_buffer_size, false)); @@ -103,14 +103,14 @@ class ExecuteFGraph : public TupleCallBody { } else { TupleMeta &meta_in = body->meta_in(); - for (uint i = 0; i < fn->input_amount(); i++) { + for (uint i = 0; i < fn.input_amount(); i++) { m_input_info.append(SocketInfo( *meta_in.type_infos()[i], m_inputs_buffer_size + meta_in.offsets()[i], false)); } m_inputs_buffer_size += meta_in.size_of_data(); TupleMeta &meta_out = body->meta_out(); - for (uint i = 0; i < fn->output_amount(); i++) { + for (uint i = 0; i < fn.output_amount(); i++) { m_output_info.append(SocketInfo( *meta_out.type_infos()[i], m_outputs_buffer_size + meta_out.offsets()[i], false)); } @@ -584,8 +584,8 @@ class ExecuteFGraph_Simple : public TupleCallBody { } else { uint node_id = m_graph.node_id_of_output(socket); - SharedFunction &fn = m_graph.function_of_node(node_id); - TupleCallBody &body = fn->body<TupleCallBody>(); + Function &fn = m_graph.function_of_node(node_id); + TupleCallBody &body = fn.body<TupleCallBody>(); FN_TUPLE_CALL_ALLOC_TUPLES(body, tmp_in, tmp_out); @@ -603,10 +603,10 @@ class ExecuteFGraph_Simple : public TupleCallBody { } }; -void fgraph_add_TupleCallBody(SharedFunction &fn, FunctionGraph &fgraph) +void fgraph_add_TupleCallBody(Function &fn, FunctionGraph &fgraph) { try_ensure_tuple_call_bodies(fgraph.graph()); - fn->add_body<ExecuteFGraph>(fgraph); + fn.add_body<ExecuteFGraph>(fgraph); } } /* namespace FN */ diff --git a/source/blender/functions/backends/tuple_call/fgraph_tuple_call.hpp b/source/blender/functions/backends/tuple_call/fgraph_tuple_call.hpp index 701d0b51462..4e7b7690373 100644 --- a/source/blender/functions/backends/tuple_call/fgraph_tuple_call.hpp +++ b/source/blender/functions/backends/tuple_call/fgraph_tuple_call.hpp @@ -4,6 +4,6 @@ namespace FN { -void fgraph_add_TupleCallBody(SharedFunction &fn, FunctionGraph &fgraph); +void fgraph_add_TupleCallBody(Function &fn, FunctionGraph &fgraph); } /* namespace FN */ diff --git a/source/blender/functions/backends/tuple_call/lazy_to_normal.cpp b/source/blender/functions/backends/tuple_call/lazy_to_normal.cpp index 6ad05d7b1c0..83929fca80a 100644 --- a/source/blender/functions/backends/tuple_call/lazy_to_normal.cpp +++ b/source/blender/functions/backends/tuple_call/lazy_to_normal.cpp @@ -29,12 +29,12 @@ class MakeEagerBody : public TupleCallBody { } }; -void derive_TupleCallBody_from_LazyInTupleCallBody(SharedFunction &fn) +void derive_TupleCallBody_from_LazyInTupleCallBody(Function &fn) { - BLI_assert(fn->has_body<LazyInTupleCallBody>()); - BLI_assert(!fn->has_body<TupleCallBody>()); + BLI_assert(fn.has_body<LazyInTupleCallBody>()); + BLI_assert(!fn.has_body<TupleCallBody>()); - fn->add_body<MakeEagerBody>(fn->body<LazyInTupleCallBody>()); + fn.add_body<MakeEagerBody>(fn.body<LazyInTupleCallBody>()); } } /* namespace FN */ diff --git a/source/blender/functions/backends/tuple_call/lazy_to_normal.hpp b/source/blender/functions/backends/tuple_call/lazy_to_normal.hpp index 813d199b20a..503d59fc674 100644 --- a/source/blender/functions/backends/tuple_call/lazy_to_normal.hpp +++ b/source/blender/functions/backends/tuple_call/lazy_to_normal.hpp @@ -4,6 +4,6 @@ namespace FN { -void derive_TupleCallBody_from_LazyInTupleCallBody(SharedFunction &fn); +void derive_TupleCallBody_from_LazyInTupleCallBody(Function &fn); } /* namespace FN */ diff --git a/source/blender/functions/backends/tuple_call/tuple_call.cpp b/source/blender/functions/backends/tuple_call/tuple_call.cpp index 82013ccc7d4..68bfa86c7f1 100644 --- a/source/blender/functions/backends/tuple_call/tuple_call.cpp +++ b/source/blender/functions/backends/tuple_call/tuple_call.cpp @@ -9,8 +9,8 @@ void TupleCallBodyBase::init_defaults(Tuple &fn_in) const void TupleCallBodyBase::owner_init_post() { - m_meta_in = TupleMeta(this->owner()->input_types()); - m_meta_out = TupleMeta(this->owner()->output_types()); + m_meta_in = TupleMeta(this->owner().input_types()); + m_meta_out = TupleMeta(this->owner().output_types()); } uint LazyInTupleCallBody::user_data_size() const diff --git a/source/blender/functions/backends/tuple_call/tuple_call.hpp b/source/blender/functions/backends/tuple_call/tuple_call.hpp index 196626e0ef2..1517ae2810b 100644 --- a/source/blender/functions/backends/tuple_call/tuple_call.hpp +++ b/source/blender/functions/backends/tuple_call/tuple_call.hpp @@ -51,7 +51,7 @@ class TupleCallBody : public TupleCallBodyBase { */ inline void call__setup_stack(Tuple &fn_in, Tuple &fn_out, ExecutionContext &ctx) const { - TextStackFrame frame(this->owner()->name().data()); + TextStackFrame frame(this->owner().name().data()); ctx.stack().push(&frame); this->call(fn_in, fn_out, ctx); ctx.stack().pop(); @@ -187,7 +187,7 @@ class LazyInTupleCallBody : public TupleCallBodyBase { ExecutionContext &ctx, LazyState &state) const { - TextStackFrame frame(this->owner()->name().data()); + TextStackFrame frame(this->owner().name().data()); ctx.stack().push(&frame); this->call(fn_in, fn_out, ctx, state); ctx.stack().pop(); @@ -217,31 +217,31 @@ class LazyInTupleCallBody : public TupleCallBodyBase { class FunctionInputNamesProvider final : public TupleElementNameProvider { private: - Function *m_function; + Function &m_function; public: - FunctionInputNamesProvider(Function *function) : m_function(function) + FunctionInputNamesProvider(Function &function) : m_function(function) { } StringRefNull get_element_name(uint index) const override { - return m_function->input_name(index); + return m_function.input_name(index); } }; class FunctionOutputNamesProvider final : public TupleElementNameProvider { private: - Function *m_function; + Function &m_function; public: - FunctionOutputNamesProvider(Function *function) : m_function(function) + FunctionOutputNamesProvider(Function &function) : m_function(function) { } StringRefNull get_element_name(uint index) const override { - return m_function->output_name(index); + return m_function.output_name(index); } }; diff --git a/source/blender/functions/core/core-c.cpp b/source/blender/functions/core/core-c.cpp index 3b529f4b6d5..1945c902542 100644 --- a/source/blender/functions/core/core-c.cpp +++ b/source/blender/functions/core/core-c.cpp @@ -4,7 +4,7 @@ using namespace FN; void FN_function_free(FnFunction fn_c) { - unwrap(fn_c)->decref(); + delete unwrap(fn_c); } bool FN_function_has_signature(FnFunction fn_c, FnType *inputs_c, FnType *outputs_c) diff --git a/source/blender/functions/core/data_graph.cpp b/source/blender/functions/core/data_graph.cpp index c0621dd396a..c4781a5705a 100644 --- a/source/blender/functions/core/data_graph.cpp +++ b/source/blender/functions/core/data_graph.cpp @@ -30,7 +30,7 @@ void DataGraph::print_socket(DataSocket socket) const { uint node_id = this->node_id_of_socket(socket); auto &node = m_nodes[node_id]; - std::cout << "<" << node.function->name() << " - "; + std::cout << "<" << node.function.name() << " - "; if (socket.is_input()) { std::cout << "Input"; } diff --git a/source/blender/functions/core/data_graph.hpp b/source/blender/functions/core/data_graph.hpp index d5aea1390d7..8dbaec61fca 100644 --- a/source/blender/functions/core/data_graph.hpp +++ b/source/blender/functions/core/data_graph.hpp @@ -157,15 +157,15 @@ template<typename SequenceT> class DataSocketSequence { class DataGraph { public: struct Node { - SharedFunction function; + Function &function; SourceInfo *source_info; /* Index into m_origins. */ uint inputs_start; /* Index into m_targets_info. */ uint outputs_start; - Node(SharedFunction fn, SourceInfo *source_info, uint inputs_start, uint outputs_start) - : function(std::move(fn)), + Node(Function &fn, SourceInfo *source_info, uint inputs_start, uint outputs_start) + : function(fn), source_info(source_info), inputs_start(inputs_start), outputs_start(outputs_start) @@ -221,19 +221,19 @@ class DataGraph { return IndexRange(m_nodes.size()); } - SharedFunction &function_of_node(uint node_id) const + Function &function_of_node(uint node_id) const { /* A function is mostly immutable anyway. */ - const SharedFunction &fn = m_nodes[node_id].function; - return const_cast<SharedFunction &>(fn); + const Function &fn = m_nodes[node_id].function; + return const_cast<Function &>(fn); } - SharedFunction &function_of_input(uint input_id) const + Function &function_of_input(uint input_id) const { return this->function_of_node(m_inputs[input_id].node); } - SharedFunction &function_of_output(uint output_id) const + Function &function_of_output(uint output_id) const { return this->function_of_node(m_outputs[output_id].node); } @@ -263,7 +263,7 @@ class DataGraph { IndexRange input_ids_of_node(uint node_id) const { const Node &node = m_nodes[node_id]; - return IndexRange(node.inputs_start, node.function->input_amount()); + return IndexRange(node.inputs_start, node.function.input_amount()); } DataSocketSequence<IndexRange> inputs_of_node(uint node_id) const @@ -274,7 +274,7 @@ class DataGraph { IndexRange output_ids_of_node(uint node_id) const { const Node &node = m_nodes[node_id]; - return IndexRange(node.outputs_start, node.function->output_amount()); + return IndexRange(node.outputs_start, node.function.output_amount()); } DataSocketSequence<IndexRange> outputs_of_node(uint node_id) const @@ -299,7 +299,7 @@ class DataGraph { const char *name_ptr_of_node(uint node_id) const { - return m_nodes[node_id].function->name().data(); + return m_nodes[node_id].function.name().data(); } uint origin_of_input(uint input_id) const @@ -411,22 +411,22 @@ class DataGraph { StringRefNull name_of_input(uint input_id) const { - return this->function_of_input(input_id)->input_name(this->index_of_input(input_id)); + return this->function_of_input(input_id).input_name(this->index_of_input(input_id)); } StringRefNull name_of_output(uint output_id) const { - return this->function_of_output(output_id)->output_name(this->index_of_output(output_id)); + return this->function_of_output(output_id).output_name(this->index_of_output(output_id)); } Type *type_of_input(uint input_id) const { - return this->function_of_input(input_id)->input_type(this->index_of_input(input_id)); + return this->function_of_input(input_id).input_type(this->index_of_input(input_id)); } Type *type_of_output(uint output_id) const { - return this->function_of_output(output_id)->output_type(this->index_of_output(output_id)); + return this->function_of_output(output_id).output_type(this->index_of_output(output_id)); } Type *type_of_input(DataSocket input_socket) const diff --git a/source/blender/functions/core/data_graph_builder.cpp b/source/blender/functions/core/data_graph_builder.cpp index 8b46c810dcf..c410e52f0c1 100644 --- a/source/blender/functions/core/data_graph_builder.cpp +++ b/source/blender/functions/core/data_graph_builder.cpp @@ -21,20 +21,20 @@ DataGraphBuilder::~DataGraphBuilder() } } -BuilderNode *DataGraphBuilder::insert_function(SharedFunction function, SourceInfo *source_info) +BuilderNode *DataGraphBuilder::insert_function(Function &function, SourceInfo *source_info) { /* Allocate memory for node, input sockets and output sockets. */ BuilderNode *node = m_allocator.allocate<BuilderNode>(); MutableArrayRef<BuilderInputSocket> input_sockets = - m_allocator.allocate_array<BuilderInputSocket>(function->input_amount()); + m_allocator.allocate_array<BuilderInputSocket>(function.input_amount()); MutableArrayRef<BuilderInputSocket *> input_socket_pointers = - m_allocator.allocate_array<BuilderInputSocket *>(function->input_amount()); + m_allocator.allocate_array<BuilderInputSocket *>(function.input_amount()); MutableArrayRef<BuilderOutputSocket> output_sockets = - m_allocator.allocate_array<BuilderOutputSocket>(function->output_amount()); + m_allocator.allocate_array<BuilderOutputSocket>(function.output_amount()); MutableArrayRef<BuilderOutputSocket *> output_socket_pointers = - m_allocator.allocate_array<BuilderOutputSocket *>(function->output_amount()); + m_allocator.allocate_array<BuilderOutputSocket *>(function.output_amount()); /* Initialize input sockets. */ for (uint i = 0; i < input_sockets.size(); i++) { @@ -61,7 +61,7 @@ BuilderNode *DataGraphBuilder::insert_function(SharedFunction function, SourceIn /* Initialize node. */ new (node) BuilderNode(); node->m_id = m_nodes.size(); - node->m_function = std::move(function); + node->m_function = &function; node->m_builder = this; node->m_source_info = source_info; node->m_inputs = input_socket_pointers; @@ -104,10 +104,8 @@ std::unique_ptr<DataGraph> DataGraphBuilder::build() for (BuilderNode *builder_node : m_nodes) { uint node_id = builder_node->id(); - r_nodes.append(DataGraph::Node(std::move(builder_node->function()), - builder_node->source_info(), - r_inputs.size(), - r_outputs.size())); + r_nodes.append(DataGraph::Node( + builder_node->function(), builder_node->source_info(), r_inputs.size(), r_outputs.size())); for (BuilderInputSocket *builder_socket : builder_node->inputs()) { BLI_assert(builder_socket->origin() != nullptr); diff --git a/source/blender/functions/core/data_graph_builder.hpp b/source/blender/functions/core/data_graph_builder.hpp index 4aae9ed48fe..eda47a55595 100644 --- a/source/blender/functions/core/data_graph_builder.hpp +++ b/source/blender/functions/core/data_graph_builder.hpp @@ -66,7 +66,7 @@ class BuilderOutputSocket : public BuilderSocket { class BuilderNode { private: DataGraphBuilder *m_builder; - SharedFunction m_function; + Function *m_function; SourceInfo *m_source_info; uint m_id; @@ -82,9 +82,9 @@ class BuilderNode { return *m_builder; } - SharedFunction &function() + Function &function() { - return m_function; + return *m_function; } uint id() @@ -155,7 +155,7 @@ class DataGraphBuilder { std::unique_ptr<DataGraph> build(); - BuilderNode *insert_function(SharedFunction function, SourceInfo *source_info = nullptr); + BuilderNode *insert_function(Function &function, SourceInfo *source_info = nullptr); void insert_link(BuilderOutputSocket *from, BuilderInputSocket *to); template<typename T> void add_resource(std::unique_ptr<T> resource, const char *name) @@ -213,12 +213,12 @@ inline BuilderOutputSocket *BuilderInputSocket::origin() inline StringRef BuilderInputSocket::name() { - return m_node->function()->input_name(this->index()); + return m_node->function().input_name(this->index()); } inline Type *BuilderInputSocket::type() { - return m_node->function()->input_type(this->index()); + return m_node->function().input_type(this->index()); } inline uint BuilderOutputSocket::output_id() @@ -233,12 +233,12 @@ inline ArrayRef<BuilderInputSocket *> BuilderOutputSocket::targets() inline StringRef BuilderOutputSocket::name() { - return m_node->function()->output_name(this->index()); + return m_node->function().output_name(this->index()); } inline Type *BuilderOutputSocket::type() { - return m_node->function()->output_type(this->index()); + return m_node->function().output_type(this->index()); } } // namespace FN diff --git a/source/blender/functions/core/dot_export.cpp b/source/blender/functions/core/dot_export.cpp index e68fe34c5e4..3d29d4bb8ff 100644 --- a/source/blender/functions/core/dot_export.cpp +++ b/source/blender/functions/core/dot_export.cpp @@ -33,7 +33,7 @@ static void insert_node_table(std::stringstream &ss, BuilderNode *node) /* Header */ ss << "<tr><td colspan=\"3\" align=\"center\"><b>"; - ss << node->function()->name(); + ss << node->function().name(); ss << "</b></td></tr>"; /* Sockets */ diff --git a/source/blender/functions/core/function.hpp b/source/blender/functions/core/function.hpp index 8eceb8dde9d..045be14ad2d 100644 --- a/source/blender/functions/core/function.hpp +++ b/source/blender/functions/core/function.hpp @@ -47,12 +47,12 @@ class FunctionBody : BLI::NonCopyable, BLI::NonMovable { virtual ~FunctionBody(); - Function *owner() const; + Function &owner() const; static const uint BODY_TYPE_AMOUNT = 5; }; -class Function final : public RefCounter { +class Function final { public: Function(Function &fn) = delete; @@ -173,8 +173,6 @@ class Function final : public RefCounter { const char *m_strings; }; -using SharedFunction = AutoRefCount<Function>; - /* Function inline functions ***********************************************/ @@ -308,9 +306,9 @@ inline void FunctionBody::set_owner(Function *fn) this->owner_init_post(); } -inline Function *FunctionBody::owner() const +inline Function &FunctionBody::owner() const { - return m_owner; + return *m_owner; } } /* namespace FN */ diff --git a/source/blender/functions/core/function_builder.cpp b/source/blender/functions/core/function_builder.cpp index 20f812e01c0..4a614cd6141 100644 --- a/source/blender/functions/core/function_builder.cpp +++ b/source/blender/functions/core/function_builder.cpp @@ -40,7 +40,7 @@ void FunctionBuilder::add_outputs(const DataGraph &data_graph, ArrayRef<DataSock } } -SharedFunction FunctionBuilder::build(StringRef function_name) +std::unique_ptr<Function> FunctionBuilder::build(StringRef function_name) { auto name_ref = m_strings_builder.add(function_name); char *strings = m_strings_builder.build(); @@ -57,12 +57,12 @@ SharedFunction FunctionBuilder::build(StringRef function_name) output_names.append(name.to_string_ref(strings)); } - return SharedFunction::New(name_ref.to_string_ref(strings), - input_names, - m_input_types, - output_names, - m_output_types, - strings); + return make_unique<Function>(name_ref.to_string_ref(strings), + input_names, + m_input_types, + output_names, + m_output_types, + strings); } } // namespace FN diff --git a/source/blender/functions/core/function_builder.hpp b/source/blender/functions/core/function_builder.hpp index 23c94a87290..9965039f5d8 100644 --- a/source/blender/functions/core/function_builder.hpp +++ b/source/blender/functions/core/function_builder.hpp @@ -39,7 +39,7 @@ class FunctionBuilder { /** * Create a new function with the given name and all the inputs and outputs previously added. */ - SharedFunction build(StringRef function_name); + std::unique_ptr<Function> build(StringRef function_name); }; } // namespace FN diff --git a/source/blender/functions/core/function_graph.cpp b/source/blender/functions/core/function_graph.cpp index f122535b584..09ccb0bd4a8 100644 --- a/source/blender/functions/core/function_graph.cpp +++ b/source/blender/functions/core/function_graph.cpp @@ -2,7 +2,7 @@ namespace FN { -SharedFunction FunctionGraph::new_function(StringRef name) const +std::unique_ptr<Function> FunctionGraph::new_function(StringRef name) const { FunctionBuilder builder; builder.add_inputs(*m_graph, m_inputs); diff --git a/source/blender/functions/core/function_graph.hpp b/source/blender/functions/core/function_graph.hpp index 78f0074113b..f390a8bdae5 100644 --- a/source/blender/functions/core/function_graph.hpp +++ b/source/blender/functions/core/function_graph.hpp @@ -51,7 +51,7 @@ class FunctionGraph { * Create a new function with the given name. The inputs and outputs correspond to the sockets in * the graph. The returned function does not contain any bodies. */ - SharedFunction new_function(StringRef name) const; + std::unique_ptr<Function> new_function(StringRef name) const; /** * Get a subset of all sockets in the graph that can influence the function execution (under the diff --git a/source/blender/functions/frontends/data_flow_nodes/data_flow_nodes-c.cpp b/source/blender/functions/frontends/data_flow_nodes/data_flow_nodes-c.cpp index 34d8965e554..cf548696537 100644 --- a/source/blender/functions/frontends/data_flow_nodes/data_flow_nodes-c.cpp +++ b/source/blender/functions/frontends/data_flow_nodes/data_flow_nodes-c.cpp @@ -7,15 +7,13 @@ FnFunction FN_tree_to_function(bNodeTree *btree) { SCOPED_TIMER("Tree to function"); BLI_assert(btree); - Optional<SharedFunction> optional_fn = DataFlowNodes::generate_function(btree); + Optional<std::unique_ptr<Function>> optional_fn = DataFlowNodes::generate_function(btree); if (!optional_fn.has_value()) { return nullptr; } - SharedFunction fn = optional_fn.extract(); - Function *fn_ptr = fn.ptr(); - fn_ptr->incref(); - return wrap(fn_ptr); + std::unique_ptr<Function> fn = optional_fn.extract(); + return wrap(fn.release()); } FnFunction FN_function_get_with_signature(bNodeTree *btree, FnType *inputs_c, FnType *outputs_c) diff --git a/source/blender/functions/frontends/data_flow_nodes/function_generation.cpp b/source/blender/functions/frontends/data_flow_nodes/function_generation.cpp index 462a6f7ef32..6aa3b4caa67 100644 --- a/source/blender/functions/frontends/data_flow_nodes/function_generation.cpp +++ b/source/blender/functions/frontends/data_flow_nodes/function_generation.cpp @@ -32,7 +32,7 @@ static void find_interface_sockets(VirtualNodeTree &vtree, } } -Optional<SharedFunction> generate_function(bNodeTree *btree) +Optional<std::unique_ptr<Function>> generate_function(bNodeTree *btree) { auto vtree = make_unique<VirtualNodeTree>(); vtree->add_all_of_tree(btree); @@ -53,11 +53,11 @@ Optional<SharedFunction> generate_function(bNodeTree *btree) // fgraph.graph().to_dot__clipboard(); - auto fn = fgraph.new_function(btree->id.name); - fgraph_add_DependenciesBody(fn, fgraph); - fgraph_add_LLVMBuildIRBody(fn, fgraph); + std::unique_ptr<Function> fn = fgraph.new_function(btree->id.name); + fgraph_add_DependenciesBody(*fn, fgraph); + fgraph_add_LLVMBuildIRBody(*fn, fgraph); - fgraph_add_TupleCallBody(fn, fgraph); + fgraph_add_TupleCallBody(*fn, fgraph); // derive_TupleCallBody_from_LLVMBuildIRBody(fn); fn->add_resource(std::move(vtree), "Virtual Node Tree"); diff --git a/source/blender/functions/frontends/data_flow_nodes/function_generation.hpp b/source/blender/functions/frontends/data_flow_nodes/function_generation.hpp index 2771559c8bd..54fdadbaa6a 100644 --- a/source/blender/functions/frontends/data_flow_nodes/function_generation.hpp +++ b/source/blender/functions/frontends/data_flow_nodes/function_generation.hpp @@ -10,7 +10,7 @@ namespace DataFlowNodes { using BLI::Optional; -Optional<SharedFunction> generate_function(struct bNodeTree *btree); +Optional<std::unique_ptr<Function>> generate_function(struct bNodeTree *btree); } // namespace DataFlowNodes } // namespace FN diff --git a/source/blender/functions/frontends/data_flow_nodes/mappings.cpp b/source/blender/functions/frontends/data_flow_nodes/mappings.cpp index dced74ecc7c..50e74e4cd0d 100644 --- a/source/blender/functions/frontends/data_flow_nodes/mappings.cpp +++ b/source/blender/functions/frontends/data_flow_nodes/mappings.cpp @@ -50,7 +50,7 @@ void NodeInserters::register_inserter(StringRef idname, NodeInserter inserter) void NodeInserters::register_function(StringRef idname, FunctionGetter getter) { auto inserter = [getter](VTreeDataGraphBuilder &builder, VirtualNode *vnode) { - SharedFunction fn = getter(); + Function &fn = getter(); BuilderNode *node = builder.insert_function(fn, vnode); builder.map_sockets(node, vnode); }; @@ -103,7 +103,7 @@ void LinkInserters::register_conversion_function(StringRef from_type, { auto inserter = [getter](VTreeDataGraphBuilder &builder, BuilderOutputSocket *from, BuilderInputSocket *to) { - auto fn = getter(); + Function &fn = getter(); BuilderNode *node = builder.insert_function(fn); builder.insert_link(from, node->input(0)); builder.insert_link(node->output(0), to); diff --git a/source/blender/functions/frontends/data_flow_nodes/mappings.hpp b/source/blender/functions/frontends/data_flow_nodes/mappings.hpp index e1eefba6e2a..6ee4eaeb261 100644 --- a/source/blender/functions/frontends/data_flow_nodes/mappings.hpp +++ b/source/blender/functions/frontends/data_flow_nodes/mappings.hpp @@ -23,7 +23,7 @@ typedef std::function<void( VTreeDataGraphBuilder &builder, BuilderOutputSocket *from, BuilderInputSocket *to)> ConversionInserter; -typedef std::function<SharedFunction()> FunctionGetter; +typedef std::function<Function &()> FunctionGetter; class TypeMappings { private: diff --git a/source/blender/functions/frontends/data_flow_nodes/mappings/conversion_inserters.cpp b/source/blender/functions/frontends/data_flow_nodes/mappings/conversion_inserters.cpp index 69a440404b5..4340f410703 100644 --- a/source/blender/functions/frontends/data_flow_nodes/mappings/conversion_inserters.cpp +++ b/source/blender/functions/frontends/data_flow_nodes/mappings/conversion_inserters.cpp @@ -10,7 +10,7 @@ static void INSERT_base_to_list(VTreeDataGraphBuilder &builder, BuilderInputSocket *to) { Type *base_type = from->type(); - auto fn = Functions::GET_FN_list_from_element(base_type); + Function &fn = Functions::GET_FN_list_from_element(base_type); BuilderNode *node = builder.insert_function(fn); builder.insert_link(from, node->input(0)); builder.insert_link(node->output(0), to); diff --git a/source/blender/functions/frontends/data_flow_nodes/mappings/node_inserters.cpp b/source/blender/functions/frontends/data_flow_nodes/mappings/node_inserters.cpp index 79f5a9fd2c1..cdb7a67f2ea 100644 --- a/source/blender/functions/frontends/data_flow_nodes/mappings/node_inserters.cpp +++ b/source/blender/functions/frontends/data_flow_nodes/mappings/node_inserters.cpp @@ -15,24 +15,23 @@ using namespace Types; struct AutoVectorizedInput { const char *prop_name; - SharedFunction &default_value_builder; + Function &default_value_builder; }; -static SharedFunction get_vectorized_function(SharedFunction &original_fn, - PointerRNA &node_rna, - ArrayRef<AutoVectorizedInput> auto_vectorized_inputs, - bool use_cache = true) +static Function &get_vectorized_function(Function &original_fn, + PointerRNA &node_rna, + ArrayRef<AutoVectorizedInput> auto_vectorized_inputs) { #ifdef DEBUG - BLI_assert(original_fn->input_amount() == auto_vectorized_inputs.size()); - for (uint i = 0; i < original_fn->input_amount(); i++) { - BLI_assert(original_fn->input_type(i) == - auto_vectorized_inputs[i].default_value_builder->output_type(0)); + BLI_assert(original_fn.input_amount() == auto_vectorized_inputs.size()); + for (uint i = 0; i < original_fn.input_amount(); i++) { + BLI_assert(original_fn.input_type(i) == + auto_vectorized_inputs[i].default_value_builder.output_type(0)); } #endif Vector<bool> vectorized_inputs; - Vector<SharedFunction> used_default_value_builders; + Vector<Function *> used_default_value_builders; for (auto &input : auto_vectorized_inputs) { char state[5]; BLI_assert(RNA_string_length(&node_rna, input.prop_name) == strlen("BASE")); @@ -42,19 +41,13 @@ static SharedFunction get_vectorized_function(SharedFunction &original_fn, bool is_vectorized = STREQ(state, "LIST"); vectorized_inputs.append(is_vectorized); if (is_vectorized) { - used_default_value_builders.append(input.default_value_builder); + used_default_value_builders.append(&input.default_value_builder); } } if (vectorized_inputs.contains(true)) { - if (use_cache) { - return Functions::to_vectorized_function__with_cache( - original_fn, vectorized_inputs, used_default_value_builders); - } - else { - return Functions::to_vectorized_function( - original_fn, vectorized_inputs, used_default_value_builders); - } + return Functions::to_vectorized_function__with_cache( + original_fn, vectorized_inputs, used_default_value_builders); } else { return original_fn; @@ -63,11 +56,11 @@ static SharedFunction get_vectorized_function(SharedFunction &original_fn, static void INSERT_object_transforms(VTreeDataGraphBuilder &builder, VirtualNode *vnode) { - auto fn = Functions::GET_FN_object_location(); + Function &fn = Functions::GET_FN_object_location(); builder.insert_matching_function(fn, vnode); } -static SharedFunction &get_float_math_function(int operation) +static Function &get_float_math_function(int operation) { switch (operation) { case 1: @@ -127,26 +120,25 @@ static void INSERT_float_math(VTreeDataGraphBuilder &builder, VirtualNode *vnode PointerRNA rna = vnode->rna(); int operation = RNA_enum_get(&rna, "operation"); - SharedFunction &original_fn = get_float_math_function(operation); - uint input_amount = original_fn->input_amount(); + Function &original_fn = get_float_math_function(operation); + uint input_amount = original_fn.input_amount(); if (input_amount == 1) { - SharedFunction fn = get_vectorized_function( + Function &fn = get_vectorized_function( original_fn, rna, {{"use_list__a", Functions::GET_FN_output_float_0()}}); builder.insert_matching_function(fn, vnode); } else { BLI_assert(input_amount == 2); - SharedFunction fn = get_vectorized_function( - original_fn, - rna, - {{"use_list__a", Functions::GET_FN_output_float_0()}, - {"use_list__b", Functions::GET_FN_output_float_0()}}); + Function &fn = get_vectorized_function(original_fn, + rna, + {{"use_list__a", Functions::GET_FN_output_float_0()}, + {"use_list__b", Functions::GET_FN_output_float_0()}}); builder.insert_matching_function(fn, vnode); } } -static SharedFunction &get_vector_math_function(int operation) +static Function &get_vector_math_function(int operation) { switch (operation) { case 1: @@ -176,18 +168,17 @@ static void INSERT_vector_math(VTreeDataGraphBuilder &builder, VirtualNode *vnod PointerRNA rna = vnode->rna(); int operation = RNA_enum_get(&rna, "operation"); - SharedFunction fn = get_vectorized_function( - get_vector_math_function(operation), - rna, - {{"use_list__a", Functions::GET_FN_output_float3_0()}, - {"use_list__b", Functions::GET_FN_output_float3_0()}}); + Function &fn = get_vectorized_function(get_vector_math_function(operation), + rna, + {{"use_list__a", Functions::GET_FN_output_float3_0()}, + {"use_list__b", Functions::GET_FN_output_float3_0()}}); builder.insert_matching_function(fn, vnode); } static void INSERT_clamp(VTreeDataGraphBuilder &builder, VirtualNode *vnode) { - SharedFunction &max_fn = Functions::GET_FN_max_floats(); - SharedFunction &min_fn = Functions::GET_FN_min_floats(); + Function &max_fn = Functions::GET_FN_max_floats(); + Function &min_fn = Functions::GET_FN_min_floats(); BuilderNode *max_node = builder.insert_function(max_fn, vnode); BuilderNode *min_node = builder.insert_function(min_fn, vnode); @@ -202,14 +193,14 @@ static void INSERT_clamp(VTreeDataGraphBuilder &builder, VirtualNode *vnode) static void INSERT_get_list_element(VTreeDataGraphBuilder &builder, VirtualNode *vnode) { Type *base_type = builder.query_type_property(vnode, "active_type"); - SharedFunction &fn = Functions::GET_FN_get_list_element(base_type); + Function &fn = Functions::GET_FN_get_list_element(base_type); builder.insert_matching_function(fn, vnode); } static void INSERT_list_length(VTreeDataGraphBuilder &builder, VirtualNode *vnode) { Type *base_type = builder.query_type_property(vnode, "active_type"); - SharedFunction &fn = Functions::GET_FN_list_length(base_type); + Function &fn = Functions::GET_FN_list_length(base_type); builder.insert_matching_function(fn, vnode); } @@ -275,35 +266,35 @@ static void INSERT_call(VTreeDataGraphBuilder &builder, VirtualNode *vnode) return; } - Optional<SharedFunction> optional_fn = generate_function(btree); + Optional<std::unique_ptr<Function>> optional_fn = generate_function(btree); BLI_assert(optional_fn.has_value()); - SharedFunction fn = optional_fn.extract(); - builder.insert_matching_function(fn, vnode); + auto fn = optional_fn.extract(); + builder.insert_matching_function(*fn, vnode); + builder.add_resource(std::move(fn), "Generated function in for Call node"); } static void INSERT_switch(VTreeDataGraphBuilder &builder, VirtualNode *vnode) { Type *data_type = builder.query_type_property(vnode, "data_type"); - auto fn = Functions::GET_FN_bool_switch(data_type); + Function &fn = Functions::GET_FN_bool_switch(data_type); builder.insert_matching_function(fn, vnode); } static void INSERT_combine_vector(VTreeDataGraphBuilder &builder, VirtualNode *vnode) { PointerRNA rna = vnode->rna(); - SharedFunction fn = get_vectorized_function( - Functions::GET_FN_combine_vector(), - rna, - {{"use_list__x", Functions::GET_FN_output_float_0()}, - {"use_list__y", Functions::GET_FN_output_float_0()}, - {"use_list__z", Functions::GET_FN_output_float_0()}}); + Function &fn = get_vectorized_function(Functions::GET_FN_combine_vector(), + rna, + {{"use_list__x", Functions::GET_FN_output_float_0()}, + {"use_list__y", Functions::GET_FN_output_float_0()}, + {"use_list__z", Functions::GET_FN_output_float_0()}}); builder.insert_matching_function(fn, vnode); } static void INSERT_separate_vector(VTreeDataGraphBuilder &builder, VirtualNode *vnode) { PointerRNA rna = vnode->rna(); - SharedFunction fn = get_vectorized_function( + Function &fn = get_vectorized_function( Functions::GET_FN_separate_vector(), rna, {{"use_list__vector", Functions::GET_FN_output_float3_0()}}); @@ -313,7 +304,7 @@ static void INSERT_separate_vector(VTreeDataGraphBuilder &builder, VirtualNode * static void INSERT_separate_color(VTreeDataGraphBuilder &builder, VirtualNode *vnode) { PointerRNA rna = vnode->rna(); - SharedFunction fn = get_vectorized_function( + Function &fn = get_vectorized_function( Functions::GET_FN_separate_color(), rna, {{"use_list__color", Functions::GET_FN_output_magenta()}}); @@ -323,7 +314,7 @@ static void INSERT_separate_color(VTreeDataGraphBuilder &builder, VirtualNode *v static void INSERT_combine_color(VTreeDataGraphBuilder &builder, VirtualNode *vnode) { PointerRNA rna = vnode->rna(); - SharedFunction fn = get_vectorized_function( + Function &fn = get_vectorized_function( Functions::GET_FN_combine_color(), rna, {{"use_list__red", Functions::GET_FN_output_float_0()}, @@ -333,7 +324,7 @@ static void INSERT_combine_color(VTreeDataGraphBuilder &builder, VirtualNode *vn builder.insert_matching_function(fn, vnode); } -static SharedFunction &get_compare_function(int operation) +static Function &get_compare_function(int operation) { switch (operation) { case 1: @@ -348,15 +339,14 @@ static void INSERT_compare(VTreeDataGraphBuilder &builder, VirtualNode *vnode) { PointerRNA rna = vnode->rna(); int operation = RNA_enum_get(&rna, "operation"); - SharedFunction fn = get_vectorized_function( - get_compare_function(operation), - rna, - {{"use_list__a", Functions::GET_FN_output_float_0()}, - {"use_list__b", Functions::GET_FN_output_float_0()}}); + Function &fn = get_vectorized_function(get_compare_function(operation), + rna, + {{"use_list__a", Functions::GET_FN_output_float_0()}, + {"use_list__b", Functions::GET_FN_output_float_0()}}); builder.insert_matching_function(fn, vnode); } -static SharedFunction &get_boolean_math_function(int operation) +static Function &get_boolean_math_function(int operation) { switch (operation) { case 1: @@ -375,20 +365,19 @@ static void INSERT_boolean_math(VTreeDataGraphBuilder &builder, VirtualNode *vno { PointerRNA rna = vnode->rna(); int operation = RNA_enum_get(&rna, "operation"); - SharedFunction &original_fn = get_boolean_math_function(operation); - uint input_amount = original_fn->input_amount(); + Function &original_fn = get_boolean_math_function(operation); + uint input_amount = original_fn.input_amount(); if (input_amount == 1) { - SharedFunction fn = get_vectorized_function( + Function &fn = get_vectorized_function( original_fn, rna, {{"use_list__a", Functions::GET_FN_output_false()}}); builder.insert_matching_function(fn, vnode); } else { BLI_assert(input_amount == 2); - SharedFunction fn = get_vectorized_function( - original_fn, - rna, - {{"use_list__a", Functions::GET_FN_output_false()}, - {"use_list__b", Functions::GET_FN_output_true()}}); + Function &fn = get_vectorized_function(original_fn, + rna, + {{"use_list__a", Functions::GET_FN_output_false()}, + {"use_list__b", Functions::GET_FN_output_true()}}); builder.insert_matching_function(fn, vnode); } } diff --git a/source/blender/functions/frontends/data_flow_nodes/unlinked_input_groupers.cpp b/source/blender/functions/frontends/data_flow_nodes/unlinked_input_groupers.cpp index 3fe53ffd6af..ecb5c4b164f 100644 --- a/source/blender/functions/frontends/data_flow_nodes/unlinked_input_groupers.cpp +++ b/source/blender/functions/frontends/data_flow_nodes/unlinked_input_groupers.cpp @@ -111,7 +111,7 @@ void GroupByNodeUsage::group(VTreeDataGraphBuilder &builder, Vector<uint> updated_vsockets; for (BuilderNode *node : builder.placeholder_nodes()) { - VNodePlaceholderBody &placeholder_info = node->function()->body<VNodePlaceholderBody>(); + VNodePlaceholderBody &placeholder_info = node->function().body<VNodePlaceholderBody>(); uint random = rand(); for (VirtualSocket *vsocket : placeholder_info.inputs()) { update_hash_of_used_vsockets( @@ -134,7 +134,7 @@ void GroupBySocketUsage::group(VTreeDataGraphBuilder &builder, Vector<uint> updated_vsockets; for (BuilderNode *node : builder.placeholder_nodes()) { - VNodePlaceholderBody &placeholder_info = node->function()->body<VNodePlaceholderBody>(); + VNodePlaceholderBody &placeholder_info = node->function().body<VNodePlaceholderBody>(); for (VirtualSocket *vsocket : placeholder_info.inputs()) { update_hash_of_used_vsockets( builder, vsocket, rand(), hash_per_vsocket, was_updated_per_vsocket, updated_vsockets); diff --git a/source/blender/functions/frontends/data_flow_nodes/unlinked_input_inserters.cpp b/source/blender/functions/frontends/data_flow_nodes/unlinked_input_inserters.cpp index c603a8bbbe5..36b51cb892b 100644 --- a/source/blender/functions/frontends/data_flow_nodes/unlinked_input_inserters.cpp +++ b/source/blender/functions/frontends/data_flow_nodes/unlinked_input_inserters.cpp @@ -86,11 +86,12 @@ void DynamicSocketLoader::insert(VTreeDataGraphBuilder &builder, btrees.append(vsocket->btree()); } - auto fn = fn_builder.build("Input Sockets"); + std::unique_ptr<Function> fn = fn_builder.build("Input Sockets"); fn->add_body<SocketLoaderBody>(btrees, bsockets, loaders); fn->add_body<SocketLoaderDependencies>(btrees, bsockets); - BuilderNode *node = builder.insert_function(fn); + BuilderNode *node = builder.insert_function(*fn); + builder.add_resource(std::move(fn), "Owned dynamic socket loader function"); r_new_origins.copy_from(node->outputs()); } @@ -165,7 +166,7 @@ void ConstantInputsHandler::insert(VTreeDataGraphBuilder &builder, fn_builder.add_output(vsocket->name(), type); } - SharedFunction fn = fn_builder.build("Unlinked Inputs"); + std::unique_ptr<Function> fn = fn_builder.build("Unlinked Inputs"); std::unique_ptr<TupleMeta> inputs_meta = make_unique<TupleMeta>(fn->output_types()); @@ -184,11 +185,13 @@ void ConstantInputsHandler::insert(VTreeDataGraphBuilder &builder, tuple_call_body.set_tuple(inputs_tuple.get()); build_ir_body.set_tuple(inputs_tuple.get()); + BuilderNode *node = builder.insert_function(*fn); + builder.add_resource(std::move(inputs_meta), "Meta information for tuple"); builder.add_resource(std::move(inputs_tuple_data_init), "Buffer for tuple"); builder.add_resource(std::move(inputs_tuple), "Tuple containing function inputs"); + builder.add_resource(std::move(fn), "Owned constant input function"); - BuilderNode *node = builder.insert_function(fn); r_new_origins.copy_from(node->outputs()); } diff --git a/source/blender/functions/frontends/data_flow_nodes/vtree_data_graph.cpp b/source/blender/functions/frontends/data_flow_nodes/vtree_data_graph.cpp index 93a2613d99d..b306b1da401 100644 --- a/source/blender/functions/frontends/data_flow_nodes/vtree_data_graph.cpp +++ b/source/blender/functions/frontends/data_flow_nodes/vtree_data_graph.cpp @@ -42,9 +42,9 @@ Vector<VirtualSocket *> VTreeDataGraph::find_placeholder_dependencies(ArrayRef<D } else { uint node_id = m_graph->node_id_of_output(socket); - SharedFunction &fn = m_graph->function_of_node(node_id); - if (fn->has_body<VNodePlaceholderBody>()) { - auto &body = fn->body<VNodePlaceholderBody>(); + Function &fn = m_graph->function_of_node(node_id); + if (fn.has_body<VNodePlaceholderBody>()) { + auto &body = fn.body<VNodePlaceholderBody>(); VirtualNode *vnode = body.vnode(); uint data_output_index = m_graph->index_of_output(socket); VirtualSocket *vsocket = this->find_data_output(vnode, data_output_index); diff --git a/source/blender/functions/frontends/data_flow_nodes/vtree_data_graph_builder.cpp b/source/blender/functions/frontends/data_flow_nodes/vtree_data_graph_builder.cpp index 8bcf4f2c2dc..43ff7109e36 100644 --- a/source/blender/functions/frontends/data_flow_nodes/vtree_data_graph_builder.cpp +++ b/source/blender/functions/frontends/data_flow_nodes/vtree_data_graph_builder.cpp @@ -107,20 +107,19 @@ class NodeSource : public SourceInfo { } }; -BuilderNode *VTreeDataGraphBuilder::insert_function(SharedFunction &fn) +BuilderNode *VTreeDataGraphBuilder::insert_function(Function &fn) { return m_graph_builder.insert_function(fn); } -BuilderNode *VTreeDataGraphBuilder::insert_matching_function(SharedFunction &fn, - VirtualNode *vnode) +BuilderNode *VTreeDataGraphBuilder::insert_matching_function(Function &fn, VirtualNode *vnode) { BuilderNode *node = this->insert_function(fn, vnode); this->map_sockets(node, vnode); return node; } -BuilderNode *VTreeDataGraphBuilder::insert_function(SharedFunction &fn, VirtualNode *vnode) +BuilderNode *VTreeDataGraphBuilder::insert_function(Function &fn, VirtualNode *vnode) { BLI_assert(vnode != nullptr); NodeSource *source = m_graph_builder.new_source_info<NodeSource>(vnode->btree(), vnode->bnode()); @@ -147,9 +146,11 @@ BuilderNode *VTreeDataGraphBuilder::insert_placeholder(VirtualNode *vnode) } } - auto fn = fn_builder.build(vnode->name()); + std::unique_ptr<Function> fn = fn_builder.build(vnode->name()); fn->add_body<VNodePlaceholderBody>(vnode, std::move(vsocket_inputs)); - BuilderNode *node = this->insert_function(fn); + BuilderNode *node = this->insert_function(*fn); + this->add_resource(std::move(fn), "placeholder function"); + this->map_data_sockets(node, vnode); m_placeholder_nodes.append(node); return node; diff --git a/source/blender/functions/frontends/data_flow_nodes/vtree_data_graph_builder.hpp b/source/blender/functions/frontends/data_flow_nodes/vtree_data_graph_builder.hpp index f9f6380f59f..672bf85c61c 100644 --- a/source/blender/functions/frontends/data_flow_nodes/vtree_data_graph_builder.hpp +++ b/source/blender/functions/frontends/data_flow_nodes/vtree_data_graph_builder.hpp @@ -36,9 +36,9 @@ class VTreeDataGraphBuilder { return m_socket_map; } - BuilderNode *insert_function(SharedFunction &fn); - BuilderNode *insert_matching_function(SharedFunction &fn, VirtualNode *vnode); - BuilderNode *insert_function(SharedFunction &fn, VirtualNode *vnode); + BuilderNode *insert_function(Function &fn); + BuilderNode *insert_matching_function(Function &fn, VirtualNode *vnode); + BuilderNode *insert_function(Function &fn, VirtualNode *vnode); BuilderNode *insert_placeholder(VirtualNode *vnode); template<typename T> void add_resource(std::unique_ptr<T> resource, const char *name) diff --git a/source/blender/functions/functions/array_execution.cpp b/source/blender/functions/functions/array_execution.cpp index 2e11c4d2e48..afa70f1960a 100644 --- a/source/blender/functions/functions/array_execution.cpp +++ b/source/blender/functions/functions/array_execution.cpp @@ -11,12 +11,12 @@ ArrayExecution::~ArrayExecution() { } -ArrayExecution::ArrayExecution(SharedFunction function) : m_function(std::move(function)) +ArrayExecution::ArrayExecution(Function &function) : m_function(function) { - for (Type *type : m_function->input_types()) { + for (Type *type : m_function.input_types()) { m_input_sizes.append(type->extension<CPPTypeInfo>().size()); } - for (Type *type : m_function->output_types()) { + for (Type *type : m_function.output_types()) { m_output_sizes.append(type->extension<CPPTypeInfo>().size()); } } @@ -26,9 +26,9 @@ ArrayExecution::ArrayExecution(SharedFunction function) : m_function(std::move(f class TupleCallArrayExecution : public ArrayExecution { public: - TupleCallArrayExecution(SharedFunction function) : ArrayExecution(std::move(function)) + TupleCallArrayExecution(Function &function) : ArrayExecution(function) { - BLI_assert(m_function->has_body<TupleCallBody>()); + BLI_assert(m_function.has_body<TupleCallBody>()); } void call(ArrayRef<uint> indices, @@ -36,13 +36,13 @@ class TupleCallArrayExecution : public ArrayExecution { MutableArrayRef<void *> output_buffers, ExecutionContext &execution_context) override { - uint input_amount = m_function->input_amount(); - uint output_amount = m_function->output_amount(); + uint input_amount = m_function.input_amount(); + uint output_amount = m_function.output_amount(); BLI_assert(input_amount == input_buffers.size()); BLI_assert(output_amount == output_buffers.size()); - TupleCallBody &body = m_function->body<TupleCallBody>(); + TupleCallBody &body = m_function.body<TupleCallBody>(); FN_TUPLE_CALL_ALLOC_TUPLES(body, fn_in, fn_out); for (uint index : indices) { @@ -61,9 +61,9 @@ class TupleCallArrayExecution : public ArrayExecution { } }; -std::unique_ptr<ArrayExecution> get_tuple_call_array_execution(SharedFunction function) +std::unique_ptr<ArrayExecution> get_tuple_call_array_execution(Function &function) { - return std::unique_ptr<ArrayExecution>(new TupleCallArrayExecution(std::move(function))); + return std::unique_ptr<ArrayExecution>(new TupleCallArrayExecution(function)); } /* LLVM Array Execution @@ -82,11 +82,11 @@ class LLVMArrayExecution : public ArrayExecution { std::unique_ptr<CompiledLLVM> m_compiled_function; public: - LLVMArrayExecution(SharedFunction function) : ArrayExecution(std::move(function)) + LLVMArrayExecution(Function &function) : ArrayExecution(function) { - BLI_assert(m_function->has_body<LLVMBuildIRBody>()); - m_input_type_infos = m_function->input_extensions<LLVMTypeInfo>(); - m_output_type_infos = m_function->output_extensions<LLVMTypeInfo>(); + BLI_assert(m_function.has_body<LLVMBuildIRBody>()); + m_input_type_infos = m_function.input_extensions<LLVMTypeInfo>(); + m_output_type_infos = m_function.output_extensions<LLVMTypeInfo>(); this->compile(); } @@ -108,7 +108,7 @@ class LLVMArrayExecution : public ArrayExecution { void compile() { llvm::LLVMContext *context = aquire_llvm_context(); - llvm::Module *module = new llvm::Module(m_function->name() + " (Array Execution)", *context); + llvm::Module *module = new llvm::Module(m_function.name() + " (Array Execution)", *context); llvm::Function *function = this->build_function_ir(module); m_compiled_function = CompiledLLVM::FromIR(module, function); release_llvm_context(context); @@ -116,7 +116,7 @@ class LLVMArrayExecution : public ArrayExecution { llvm::Function *build_function_ir(llvm::Module *module) { llvm::LLVMContext &context = module->getContext(); - LLVMBuildIRBody &body = m_function->body<LLVMBuildIRBody>(); + LLVMBuildIRBody &body = m_function.body<LLVMBuildIRBody>(); /* Create the main function. */ llvm::FunctionType *ftype = llvm::TypeBuilder<CompiledFunctionSignature, false>::get(context); @@ -151,7 +151,7 @@ class LLVMArrayExecution : public ArrayExecution { FunctionIRCache function_cache; BuildIRSettings settings; llvm::Function *actual_function = body.build_function( - module, m_function->name(), settings, function_cache); + module, m_function.name(), settings, function_cache); llvm::Value *result = body_builder.CreateCall(actual_function, input_values); /* Store the computed results in the output buffers. */ @@ -168,12 +168,12 @@ class LLVMArrayExecution : public ArrayExecution { Vector<llvm::Value *> get_input_buffers(CodeBuilder &builder, llvm::Value *input_buffers_arg) { Vector<llvm::Value *> input_buffers; - for (uint i = 0; i < m_function->input_amount(); i++) { + for (uint i = 0; i < m_function.input_amount(); i++) { uint element_size = m_input_sizes[i]; llvm::Value *input_buffer = builder.CreateLoadAtIndex(input_buffers_arg, i); llvm::Value *typed_input_buffer = builder.CastToPointerWithStride(input_buffer, element_size); - typed_input_buffer->setName(to_llvm(m_function->input_name(i) + " Array")); + typed_input_buffer->setName(to_llvm(m_function.input_name(i) + " Array")); input_buffers.append(typed_input_buffer); } return input_buffers; @@ -182,7 +182,7 @@ class LLVMArrayExecution : public ArrayExecution { Vector<llvm::Value *> get_output_buffers(CodeBuilder &builder, llvm::Value *output_buffers_arg) { Vector<llvm::Value *> output_buffers; - for (uint i = 0; i < m_function->output_amount(); i++) { + for (uint i = 0; i < m_function.output_amount(); i++) { uint element_size = m_output_sizes[i]; llvm::Value *output_buffer = builder.CreateLoadAtIndex(output_buffers_arg, i); llvm::Value *typed_output_buffer = builder.CastToPointerWithStride(output_buffer, @@ -197,10 +197,10 @@ class LLVMArrayExecution : public ArrayExecution { llvm::Value *index_to_process) { Vector<llvm::Value *> input_values; - for (uint i = 0; i < m_function->input_amount(); i++) { + for (uint i = 0; i < m_function.input_amount(); i++) { llvm::Value *addr = builder.CreateGEP(input_buffers[i], index_to_process); llvm::Value *value = m_input_type_infos[i]->build_load_ir__copy(builder, addr); - value->setName(to_llvm(m_function->input_name(i))); + value->setName(to_llvm(m_function.input_name(i))); input_values.append(value); } return input_values; @@ -211,18 +211,18 @@ class LLVMArrayExecution : public ArrayExecution { llvm::Value *index_to_process, llvm::Value *computed_results) { - for (uint i = 0; i < m_function->output_amount(); i++) { + for (uint i = 0; i < m_function.output_amount(); i++) { llvm::Value *addr = builder.CreateGEP(output_buffers[i], index_to_process); llvm::Value *value = builder.CreateExtractValue(computed_results, i); - value->setName(to_llvm(m_function->output_name(i))); + value->setName(to_llvm(m_function.output_name(i))); m_output_type_infos[i]->build_store_ir__relocate(builder, value, addr); } } }; -std::unique_ptr<ArrayExecution> get_precompiled_array_execution(SharedFunction function) +std::unique_ptr<ArrayExecution> get_precompiled_array_execution(Function &function) { - return std::unique_ptr<ArrayExecution>(new LLVMArrayExecution(std::move(function))); + return std::unique_ptr<ArrayExecution>(new LLVMArrayExecution(function)); } } // namespace Functions diff --git a/source/blender/functions/functions/array_execution.hpp b/source/blender/functions/functions/array_execution.hpp index 2a04d2b7aaf..c69e11a3a32 100644 --- a/source/blender/functions/functions/array_execution.hpp +++ b/source/blender/functions/functions/array_execution.hpp @@ -9,12 +9,12 @@ namespace Functions { class ArrayExecution { protected: - SharedFunction m_function; + Function &m_function; Vector<uint> m_input_sizes; Vector<uint> m_output_sizes; public: - ArrayExecution(SharedFunction function); + ArrayExecution(Function &function); virtual ~ArrayExecution(); virtual void call(ArrayRef<uint> indices, @@ -23,8 +23,8 @@ class ArrayExecution { ExecutionContext &execution_context) = 0; }; -std::unique_ptr<ArrayExecution> get_tuple_call_array_execution(SharedFunction function); -std::unique_ptr<ArrayExecution> get_precompiled_array_execution(SharedFunction function); +std::unique_ptr<ArrayExecution> get_tuple_call_array_execution(Function &function); +std::unique_ptr<ArrayExecution> get_precompiled_array_execution(Function &function); } // namespace Functions } // namespace FN diff --git a/source/blender/functions/functions/auto_vectorization.cpp b/source/blender/functions/functions/auto_vectorization.cpp index 526067890fb..c367636d47b 100644 --- a/source/blender/functions/functions/auto_vectorization.cpp +++ b/source/blender/functions/functions/auto_vectorization.cpp @@ -23,9 +23,9 @@ class IterationStackFrame : public StackFrame { class AutoVectorizationGen : public LLVMBuildIRBody { private: - SharedFunction m_main; + Function &m_main; Vector<bool> m_input_is_list; - Vector<SharedFunction> m_empty_list_value_builders; + Vector<Function *> m_empty_list_value_builders; struct InputInfo { bool is_list; @@ -43,17 +43,17 @@ class AutoVectorizationGen : public LLVMBuildIRBody { Vector<OutputInfo> m_output_info; public: - AutoVectorizationGen(SharedFunction main, + AutoVectorizationGen(Function &main, ArrayRef<bool> input_is_list, - ArrayRef<SharedFunction> empty_list_value_builders) + ArrayRef<Function *> empty_list_value_builders) : m_main(main), m_input_is_list(input_is_list), m_empty_list_value_builders(empty_list_value_builders) { - BLI_assert(main->has_body<LLVMBuildIRBody>()); + BLI_assert(main.has_body<LLVMBuildIRBody>()); BLI_assert(input_is_list.contains(true)); - for (uint i = 0; i < main->input_amount(); i++) { - Type *base_type = main->input_type(i); + for (uint i = 0; i < main.input_amount(); i++) { + Type *base_type = main.input_type(i); Type *list_type = get_list_type(base_type); InputInfo info; info.is_list = input_is_list[i]; @@ -62,7 +62,7 @@ class AutoVectorizationGen : public LLVMBuildIRBody { info.list_llvm_type = &list_type->extension<LLVMTypeInfo>(); m_input_info.append(info); } - for (auto &base_type : main->output_types()) { + for (auto &base_type : main.output_types()) { OutputInfo info; info.base_cpp_type = &base_type->extension<CPPTypeInfo>(); info.base_llvm_type = &base_type->extension<LLVMTypeInfo>(); @@ -91,7 +91,7 @@ class AutoVectorizationGen : public LLVMBuildIRBody { Vector<llvm::Value *> main_outputs(m_output_info.size()); CodeInterface main_interface( main_inputs, main_outputs, interface.context_ptr(), interface.function_ir_cache()); - auto &body = m_main->body<LLVMBuildIRBody>(); + auto &body = m_main.body<LLVMBuildIRBody>(); body.build_ir(body_builder, main_interface, settings); this->store_computed_values_in_output_lists( @@ -160,7 +160,7 @@ class AutoVectorizationGen : public LLVMBuildIRBody { Vector<llvm::Value *> data_pointers; for (uint i = 0; i < m_output_info.size(); i++) { uint stride = m_output_info[i].base_cpp_type->size(); - Type *output_type = m_main->output_type(i); + Type *output_type = m_main.output_type(i); llvm::Value *output_list = builder.CreateCallPointer( (void *)callback__new_list, @@ -212,8 +212,8 @@ class AutoVectorizationGen : public LLVMBuildIRBody { CodeBuilder &else_builder = ifthenelse.else_builder(); /* Use default value when list has no elements. */ - const SharedFunction &default_builder = m_empty_list_value_builders[list_input_index]; - auto &default_builder_body = default_builder->body<LLVMBuildIRBody>(); + const Function &default_builder = *m_empty_list_value_builders[list_input_index]; + auto &default_builder_body = default_builder.body<LLVMBuildIRBody>(); Vector<llvm::Value *> default_builder_inputs(0); Vector<llvm::Value *> default_builder_outputs(1); CodeInterface default_builder_interface(default_builder_inputs, @@ -260,7 +260,7 @@ class AutoVectorizationGen : public LLVMBuildIRBody { class AutoVectorization : public TupleCallBody { private: - SharedFunction m_main; + Function &m_main; TupleCallBody &m_main_body; const Vector<bool> m_input_is_list; @@ -274,8 +274,8 @@ class AutoVectorization : public TupleCallBody { Vector<TupleCallBody *> m_append_bodies; public: - AutoVectorization(SharedFunction main, const Vector<bool> &input_is_list) - : m_main(main), m_main_body(main->body<TupleCallBody>()), m_input_is_list(input_is_list) + AutoVectorization(Function &main, const Vector<bool> &input_is_list) + : m_main(main), m_main_body(main.body<TupleCallBody>()), m_input_is_list(input_is_list) { for (uint i = 0; i < input_is_list.size(); i++) { if (input_is_list[i]) { @@ -283,9 +283,9 @@ class AutoVectorization : public TupleCallBody { } } for (uint i : m_list_inputs) { - Type *base_type = main->input_type(i); - m_get_length_bodies.append(&GET_FN_list_length(base_type)->body<TupleCallBody>()); - m_get_element_bodies.append(&GET_FN_get_list_element(base_type)->body<TupleCallBody>()); + Type *base_type = main.input_type(i); + m_get_length_bodies.append(&GET_FN_list_length(base_type).body<TupleCallBody>()); + m_get_element_bodies.append(&GET_FN_get_list_element(base_type).body<TupleCallBody>()); } m_max_len_in_size = 0; @@ -295,9 +295,9 @@ class AutoVectorization : public TupleCallBody { m_max_len_out_size = std::max(m_max_len_out_size, body->meta_out().size_of_full_tuple()); } - for (auto base_type : main->output_types()) { - m_create_empty_bodies.append(&GET_FN_empty_list(base_type)->body<TupleCallBody>()); - m_append_bodies.append(&GET_FN_append_to_list(base_type)->body<TupleCallBody>()); + for (auto base_type : main.output_types()) { + m_create_empty_bodies.append(&GET_FN_empty_list(base_type).body<TupleCallBody>()); + m_append_bodies.append(&GET_FN_append_to_list(base_type).body<TupleCallBody>()); } } @@ -312,7 +312,7 @@ class AutoVectorization : public TupleCallBody { FN_TUPLE_CALL_ALLOC_TUPLES(m_main_body, main_in, main_out); IterationStackFrame iteration_frame; - TextStackFrame function_name_frame(m_main->name().data()); + TextStackFrame function_name_frame(m_main.name().data()); ctx.stack().push(&iteration_frame); ctx.stack().push(&function_name_frame); @@ -332,7 +332,7 @@ class AutoVectorization : public TupleCallBody { iteration_frame.m_iteration = iteration; m_main_body.call(main_in, main_out, ctx); - for (uint i = 0; i < m_main->output_amount(); i++) { + for (uint i = 0; i < m_main.output_amount(); i++) { this->append_to_output(main_out, fn_out, i, ctx); } } @@ -390,7 +390,7 @@ class AutoVectorization : public TupleCallBody { void initialize_empty_lists(Tuple &fn_out, ExecutionContext &ctx) const { - for (uint i = 0; i < m_main->output_amount(); i++) { + for (uint i = 0; i < m_main.output_amount(); i++) { this->initialize_empty_list(fn_out, i, ctx); } } @@ -416,23 +416,23 @@ class AutoVectorization : public TupleCallBody { } }; -static SharedFunction to_vectorized_function_internal( - SharedFunction &original_fn, +static std::unique_ptr<Function> to_vectorized_function_internal( + Function &original_fn, ArrayRef<bool> &vectorized_inputs_mask, - ArrayRef<SharedFunction> &empty_list_value_builders) + ArrayRef<Function *> &empty_list_value_builders) { - uint input_amount = original_fn->input_amount(); - uint output_amount = original_fn->output_amount(); + uint input_amount = original_fn.input_amount(); + uint output_amount = original_fn.output_amount(); BLI_assert(vectorized_inputs_mask.size() == input_amount); BLI_assert(vectorized_inputs_mask.contains(true)); BLI_assert(empty_list_value_builders.size() == vectorized_inputs_mask.count(true)); - BLI_assert(original_fn->has_body<TupleCallBody>() || original_fn->has_body<LLVMBuildIRBody>()); + BLI_assert(original_fn.has_body<TupleCallBody>() || original_fn.has_body<LLVMBuildIRBody>()); FunctionBuilder builder; for (uint i = 0; i < input_amount; i++) { - StringRef original_name = original_fn->input_name(i); - Type *original_type = original_fn->input_type(i); + StringRef original_name = original_fn.input_name(i); + Type *original_type = original_fn.input_type(i); if (vectorized_inputs_mask[i]) { Type *list_type = get_list_type(original_type); builder.add_input(original_name + " (List)", list_type); @@ -443,15 +443,15 @@ static SharedFunction to_vectorized_function_internal( } for (uint i = 0; i < output_amount; i++) { - StringRef original_name = original_fn->output_name(i); - Type *original_type = original_fn->output_type(i); + StringRef original_name = original_fn.output_name(i); + Type *original_type = original_fn.output_type(i); Type *list_type = get_list_type(original_type); builder.add_output(original_name + " (List)", list_type); } - std::string name = original_fn->name() + " (Vectorized)"; + std::string name = original_fn.name() + " (Vectorized)"; auto fn = builder.build(name); - if (original_fn->has_body<LLVMBuildIRBody>()) { + if (original_fn.has_body<LLVMBuildIRBody>()) { fn->add_body<AutoVectorizationGen>( original_fn, vectorized_inputs_mask, empty_list_value_builders); } @@ -461,22 +461,14 @@ static SharedFunction to_vectorized_function_internal( return fn; } -SharedFunction to_vectorized_function(SharedFunction &original_fn, - ArrayRef<bool> vectorized_inputs_mask, - ArrayRef<SharedFunction> empty_list_value_builders) -{ - return to_vectorized_function_internal( - original_fn, vectorized_inputs_mask, empty_list_value_builders); -} - struct AutoVectorizationInput { - SharedFunction m_original_fn; + Function &m_original_fn; Vector<bool> m_vectorized_inputs_mask; - Vector<SharedFunction> m_empty_list_value_builders; + Vector<Function *> m_empty_list_value_builders; - AutoVectorizationInput(SharedFunction &original_fn, + AutoVectorizationInput(Function &original_fn, ArrayRef<bool> vectorized_inputs_mask, - ArrayRef<SharedFunction> empty_list_value_builders) + ArrayRef<Function *> empty_list_value_builders) : m_original_fn(original_fn), m_vectorized_inputs_mask(vectorized_inputs_mask), m_empty_list_value_builders(empty_list_value_builders) @@ -487,30 +479,39 @@ struct AutoVectorizationInput { { return (a.m_original_fn == b.m_original_fn && Vector<bool>::all_equal(a.m_vectorized_inputs_mask, b.m_vectorized_inputs_mask) && - Vector<SharedFunction>::all_equal(a.m_empty_list_value_builders, - b.m_empty_list_value_builders)); + Vector<Function *>::all_equal(a.m_empty_list_value_builders, + b.m_empty_list_value_builders)); } }; -using VectorizeCacheMap = Map<AutoVectorizationInput, SharedFunction>; +using VectorizeCacheMap = Map<AutoVectorizationInput, std::unique_ptr<Function>>; BLI_LAZY_INIT_STATIC(VectorizeCacheMap, get_vectorized_function_cache) { return VectorizeCacheMap{}; } -SharedFunction to_vectorized_function__with_cache( - SharedFunction &original_fn, - ArrayRef<bool> vectorized_inputs_mask, - ArrayRef<SharedFunction> empty_list_value_builders) +Function &to_vectorized_function__with_cache(Function &original_fn, + ArrayRef<bool> vectorized_inputs_mask, + ArrayRef<Function *> empty_list_value_builders) { static VectorizeCacheMap &cache = get_vectorized_function_cache(); AutoVectorizationInput cache_key(original_fn, vectorized_inputs_mask, empty_list_value_builders); - return cache.lookup_or_add(cache_key, [&]() { + + std::unique_ptr<Function> &vectorized_function = cache.lookup_or_add(cache_key, [&]() { return to_vectorized_function_internal( original_fn, vectorized_inputs_mask, empty_list_value_builders); }); + return *vectorized_function; +} + +std::unique_ptr<Function> to_vectorized_function__without_cache( + Function &fn, + ArrayRef<bool> vectorized_inputs_mask, + ArrayRef<Function *> empty_list_value_builders) +{ + return to_vectorized_function_internal(fn, vectorized_inputs_mask, empty_list_value_builders); } } // namespace Functions @@ -521,7 +522,7 @@ template<> struct DefaultHash<FN::Functions::AutoVectorizationInput> { uint32_t operator()(const FN::Functions::AutoVectorizationInput &value) const { /* TODO: take other struct fields into account. */ - void *ptr = (void *)value.m_original_fn.ptr(); + void *ptr = (void *)&value.m_original_fn; return DefaultHash<void *>{}(ptr); } }; diff --git a/source/blender/functions/functions/auto_vectorization.hpp b/source/blender/functions/functions/auto_vectorization.hpp index 72ba2e9cebb..dc7ec3c0385 100644 --- a/source/blender/functions/functions/auto_vectorization.hpp +++ b/source/blender/functions/functions/auto_vectorization.hpp @@ -5,14 +5,14 @@ namespace FN { namespace Functions { -SharedFunction to_vectorized_function(SharedFunction &fn, - ArrayRef<bool> vectorized_inputs_mask, - ArrayRef<SharedFunction> empty_list_value_builders); +Function &to_vectorized_function__with_cache(Function &fn, + ArrayRef<bool> vectorized_inputs_mask, + ArrayRef<Function *> empty_list_value_builders); -SharedFunction to_vectorized_function__with_cache( - SharedFunction &fn, +std::unique_ptr<Function> to_vectorized_function__without_cache( + Function &fn, ArrayRef<bool> vectorized_inputs_mask, - ArrayRef<SharedFunction> empty_list_value_builders); + ArrayRef<Function *> empty_list_value_builders); } // namespace Functions } // namespace FN diff --git a/source/blender/functions/functions/boolean.cpp b/source/blender/functions/functions/boolean.cpp index d1c09289a96..6dc155f504a 100644 --- a/source/blender/functions/functions/boolean.cpp +++ b/source/blender/functions/functions/boolean.cpp @@ -10,7 +10,7 @@ namespace Functions { using namespace Types; -static SharedFunction get_boolean_function__one_input(StringRef name) +static std::unique_ptr<Function> get_boolean_function__one_input(StringRef name) { FunctionBuilder builder; builder.add_input("Value", TYPE_bool); @@ -18,7 +18,7 @@ static SharedFunction get_boolean_function__one_input(StringRef name) return builder.build(name); } -static SharedFunction get_boolean_function__two_inputs(StringRef name) +static std::unique_ptr<Function> get_boolean_function__two_inputs(StringRef name) { FunctionBuilder builder; builder.add_input("A", TYPE_bool); @@ -37,7 +37,7 @@ class AndBoolean : public TupleCallBody { } }; -BLI_LAZY_INIT(SharedFunction, GET_FN_and) +BLI_LAZY_INIT_REF(Function, GET_FN_and) { auto fn = get_boolean_function__two_inputs("And"); fn->add_body<AndBoolean>(); @@ -54,7 +54,7 @@ class OrBoolean : public TupleCallBody { } }; -BLI_LAZY_INIT(SharedFunction, GET_FN_or) +BLI_LAZY_INIT_REF(Function, GET_FN_or) { auto fn = get_boolean_function__two_inputs("Or"); fn->add_body<OrBoolean>(); @@ -70,7 +70,7 @@ class NotBoolean : public TupleCallBody { } }; -BLI_LAZY_INIT(SharedFunction, GET_FN_not) +BLI_LAZY_INIT_REF(Function, GET_FN_not) { auto fn = get_boolean_function__one_input("Not"); fn->add_body<NotBoolean>(); diff --git a/source/blender/functions/functions/boolean.hpp b/source/blender/functions/functions/boolean.hpp index c75d189ebf2..ec701014f06 100644 --- a/source/blender/functions/functions/boolean.hpp +++ b/source/blender/functions/functions/boolean.hpp @@ -5,9 +5,9 @@ namespace FN { namespace Functions { -SharedFunction &GET_FN_and(); -SharedFunction &GET_FN_or(); -SharedFunction &GET_FN_not(); +Function &GET_FN_and(); +Function &GET_FN_or(); +Function &GET_FN_not(); } // namespace Functions } // namespace FN diff --git a/source/blender/functions/functions/color.cpp b/source/blender/functions/functions/color.cpp index 4d9eec42c69..e8b4ea2dff2 100644 --- a/source/blender/functions/functions/color.cpp +++ b/source/blender/functions/functions/color.cpp @@ -22,7 +22,7 @@ class SeparateColor : public TupleCallBody { } }; -BLI_LAZY_INIT(SharedFunction, GET_FN_separate_color) +BLI_LAZY_INIT_REF(Function, GET_FN_separate_color) { FunctionBuilder fn_builder; fn_builder.add_input("Color", TYPE_rgba_f); @@ -50,7 +50,7 @@ class CombineColor : public TupleCallBody { } }; -BLI_LAZY_INIT(SharedFunction, GET_FN_combine_color) +BLI_LAZY_INIT_REF(Function, GET_FN_combine_color) { FunctionBuilder fn_builder; fn_builder.add_input("Red", TYPE_float); diff --git a/source/blender/functions/functions/color.hpp b/source/blender/functions/functions/color.hpp index 424b4b9bf63..6a74966ab9a 100644 --- a/source/blender/functions/functions/color.hpp +++ b/source/blender/functions/functions/color.hpp @@ -5,8 +5,8 @@ namespace FN { namespace Functions { -SharedFunction &GET_FN_separate_color(); -SharedFunction &GET_FN_combine_color(); +Function &GET_FN_separate_color(); +Function &GET_FN_combine_color(); } // namespace Functions } // namespace FN diff --git a/source/blender/functions/functions/comparisons.cpp b/source/blender/functions/functions/comparisons.cpp index a56b90bd78e..8747a9269e8 100644 --- a/source/blender/functions/functions/comparisons.cpp +++ b/source/blender/functions/functions/comparisons.cpp @@ -19,7 +19,7 @@ template<typename T> class LessThan : public TupleCallBody { } }; -BLI_LAZY_INIT(SharedFunction, GET_FN_less_than_float) +BLI_LAZY_INIT_REF(Function, GET_FN_less_than_float) { FunctionBuilder builder; builder.add_input("A", TYPE_float); @@ -31,7 +31,7 @@ BLI_LAZY_INIT(SharedFunction, GET_FN_less_than_float) return fn; } -BLI_LAZY_INIT(SharedFunction, GET_FN_less_than_int32) +BLI_LAZY_INIT_REF(Function, GET_FN_less_than_int32) { FunctionBuilder builder; builder.add_input("A", TYPE_int32); diff --git a/source/blender/functions/functions/comparisons.hpp b/source/blender/functions/functions/comparisons.hpp index a97cd1ce62b..78d6f8893d1 100644 --- a/source/blender/functions/functions/comparisons.hpp +++ b/source/blender/functions/functions/comparisons.hpp @@ -5,8 +5,8 @@ namespace FN { namespace Functions { -SharedFunction &GET_FN_less_than_float(); -SharedFunction &GET_FN_less_than_int32(); +Function &GET_FN_less_than_float(); +Function &GET_FN_less_than_int32(); } // namespace Functions } // namespace FN diff --git a/source/blender/functions/functions/constants.cpp b/source/blender/functions/functions/constants.cpp index 7c226fc2acb..d050c9aa314 100644 --- a/source/blender/functions/functions/constants.cpp +++ b/source/blender/functions/functions/constants.cpp @@ -79,7 +79,7 @@ class ConstBoolGen : public LLVMBuildIRBody { } }; -static SharedFunction get_output_int32_function(int32_t value) +static std::unique_ptr<Function> get_output_int32_function(int32_t value) { FunctionBuilder builder; builder.add_output("Value", TYPE_int32); @@ -89,17 +89,17 @@ static SharedFunction get_output_int32_function(int32_t value) return fn; } -BLI_LAZY_INIT(SharedFunction, GET_FN_output_int32_0) +BLI_LAZY_INIT_REF(Function, GET_FN_output_int32_0) { return get_output_int32_function(0); } -BLI_LAZY_INIT(SharedFunction, GET_FN_output_int32_1) +BLI_LAZY_INIT_REF(Function, GET_FN_output_int32_1) { return get_output_int32_function(1); } -static SharedFunction get_output_float_function(float value) +static std::unique_ptr<Function> get_output_float_function(float value) { FunctionBuilder builder; builder.add_output("Value", TYPE_float); @@ -109,17 +109,17 @@ static SharedFunction get_output_float_function(float value) return fn; } -BLI_LAZY_INIT(SharedFunction, GET_FN_output_float_0) +BLI_LAZY_INIT_REF(Function, GET_FN_output_float_0) { return get_output_float_function(0.0f); } -BLI_LAZY_INIT(SharedFunction, GET_FN_output_float_1) +BLI_LAZY_INIT_REF(Function, GET_FN_output_float_1) { return get_output_float_function(1.0f); } -static SharedFunction get_output_bool_function(bool value) +static std::unique_ptr<Function> get_output_bool_function(bool value) { FunctionBuilder builder; builder.add_output("Value", TYPE_bool); @@ -129,12 +129,12 @@ static SharedFunction get_output_bool_function(bool value) return fn; } -BLI_LAZY_INIT(SharedFunction, GET_FN_output_false) +BLI_LAZY_INIT_REF(Function, GET_FN_output_false) { return get_output_bool_function(false); } -BLI_LAZY_INIT(SharedFunction, GET_FN_output_true) +BLI_LAZY_INIT_REF(Function, GET_FN_output_true) { return get_output_bool_function(true); } @@ -162,7 +162,7 @@ template<uint N> class ConstFloatArrayGen : public LLVMBuildIRBody { } }; -static SharedFunction get_output_float3_function(float3 vector) +static std::unique_ptr<Function> get_output_float3_function(float3 vector) { FunctionBuilder builder; auto &float3_type = TYPE_float3; @@ -173,17 +173,17 @@ static SharedFunction get_output_float3_function(float3 vector) return fn; } -BLI_LAZY_INIT(SharedFunction, GET_FN_output_float3_0) +BLI_LAZY_INIT_REF(Function, GET_FN_output_float3_0) { return get_output_float3_function(float3(0, 0, 0)); } -BLI_LAZY_INIT(SharedFunction, GET_FN_output_float3_1) +BLI_LAZY_INIT_REF(Function, GET_FN_output_float3_1) { return get_output_float3_function(float3(1, 1, 1)); } -static SharedFunction get_output_rgba_f_function(rgba_f color) +static std::unique_ptr<Function> get_output_rgba_f_function(rgba_f color) { FunctionBuilder builder; auto &rgba_f_type = TYPE_rgba_f; @@ -194,12 +194,12 @@ static SharedFunction get_output_rgba_f_function(rgba_f color) return fn; } -BLI_LAZY_INIT(SharedFunction, GET_FN_output_magenta) +BLI_LAZY_INIT_REF(Function, GET_FN_output_magenta) { return get_output_rgba_f_function(rgba_f(1, 0, 1, 1)); } -BLI_LAZY_INIT(SharedFunction, GET_FN_none) +BLI_LAZY_INIT_REF(Function, GET_FN_none) { FunctionBuilder builder; auto fn = builder.build("None"); diff --git a/source/blender/functions/functions/constants.hpp b/source/blender/functions/functions/constants.hpp index e7710597aa7..ab34257dcae 100644 --- a/source/blender/functions/functions/constants.hpp +++ b/source/blender/functions/functions/constants.hpp @@ -5,21 +5,21 @@ namespace FN { namespace Functions { -SharedFunction &GET_FN_output_int32_0(); -SharedFunction &GET_FN_output_int32_1(); +Function &GET_FN_output_int32_0(); +Function &GET_FN_output_int32_1(); -SharedFunction &GET_FN_output_float_0(); -SharedFunction &GET_FN_output_float_1(); +Function &GET_FN_output_float_0(); +Function &GET_FN_output_float_1(); -SharedFunction &GET_FN_output_false(); -SharedFunction &GET_FN_output_true(); +Function &GET_FN_output_false(); +Function &GET_FN_output_true(); -SharedFunction &GET_FN_output_float3_0(); -SharedFunction &GET_FN_output_float3_1(); +Function &GET_FN_output_float3_0(); +Function &GET_FN_output_float3_1(); -SharedFunction &GET_FN_output_magenta(); +Function &GET_FN_output_magenta(); -SharedFunction &GET_FN_none(); +Function &GET_FN_none(); } // namespace Functions } // namespace FN diff --git a/source/blender/functions/functions/lists.cpp b/source/blender/functions/functions/lists.cpp index ebcffd953cc..2ab811d441c 100644 --- a/source/blender/functions/functions/lists.cpp +++ b/source/blender/functions/functions/lists.cpp @@ -26,7 +26,7 @@ class CreateEmptyList : public TupleCallBody { } }; -static SharedFunction build_create_empty_list_function(Type *base_type, Type *list_type) +static std::unique_ptr<Function> build_create_empty_list_function(Type *base_type, Type *list_type) { FunctionBuilder builder; builder.add_output("List", list_type); @@ -61,7 +61,8 @@ class CreateSingleElementListDependencies : public DepsBody { } }; -static SharedFunction build_create_single_element_list_function(Type *base_type, Type *list_type) +static std::unique_ptr<Function> build_create_single_element_list_function(Type *base_type, + Type *list_type) { FunctionBuilder builder; builder.add_input("Value", base_type); @@ -102,7 +103,7 @@ class AppendToListDependencies : public DepsBody { } }; -static SharedFunction build_append_function(Type *base_type, Type *list_type) +static std::unique_ptr<Function> build_append_function(Type *base_type, Type *list_type) { FunctionBuilder builder; builder.add_input("List", list_type); @@ -149,7 +150,7 @@ class GetListElementDependencies : public DepsBody { } }; -static SharedFunction build_get_element_function(Type *base_type, Type *list_type) +static std::unique_ptr<Function> build_get_element_function(Type *base_type, Type *list_type) { FunctionBuilder builder; builder.add_input("List", list_type); @@ -195,7 +196,7 @@ class CombineListsDependencies : public DepsBody { } }; -static SharedFunction build_combine_lists_function(Type *base_type, Type *list_type) +static std::unique_ptr<Function> build_combine_lists_function(Type *base_type, Type *list_type) { FunctionBuilder builder; builder.add_input("List 1", list_type); @@ -220,7 +221,7 @@ class ListLength : public TupleCallBody { } }; -static SharedFunction build_list_length_function(Type *base_type, Type *list_type) +static std::unique_ptr<Function> build_list_length_function(Type *base_type, Type *list_type) { FunctionBuilder builder; builder.add_input("List", list_type); @@ -235,7 +236,7 @@ static SharedFunction build_list_length_function(Type *base_type, Type *list_typ /* Build List Functions *************************************/ -using FunctionPerType = Map<Type *, SharedFunction>; +using FunctionPerType = Map<Type *, std::unique_ptr<Function>>; struct ListFunctions { FunctionPerType m_create_empty; @@ -275,52 +276,52 @@ BLI_LAZY_INIT_STATIC(ListFunctions, get_list_functions) /* Access List Functions *************************************/ -SharedFunction &GET_FN_empty_list(Type *base_type) +Function &GET_FN_empty_list(Type *base_type) { FunctionPerType &functions = get_list_functions().m_create_empty; BLI_assert(functions.contains(base_type)); - return functions.lookup(base_type); + return *functions.lookup(base_type); } -SharedFunction &GET_FN_list_from_element(Type *base_type) +Function &GET_FN_list_from_element(Type *base_type) { FunctionPerType &functions = get_list_functions().m_from_element; BLI_assert(functions.contains(base_type)); - return functions.lookup(base_type); + return *functions.lookup(base_type); } -SharedFunction &GET_FN_append_to_list(Type *base_type) +Function &GET_FN_append_to_list(Type *base_type) { FunctionPerType &functions = get_list_functions().m_append; BLI_assert(functions.contains(base_type)); - return functions.lookup(base_type); + return *functions.lookup(base_type); } -SharedFunction &GET_FN_get_list_element(Type *base_type) +Function &GET_FN_get_list_element(Type *base_type) { FunctionPerType &functions = get_list_functions().m_get_element; BLI_assert(functions.contains(base_type)); - return functions.lookup(base_type); + return *functions.lookup(base_type); } -SharedFunction &GET_FN_combine_lists(Type *base_type) +Function &GET_FN_combine_lists(Type *base_type) { FunctionPerType &functions = get_list_functions().m_combine; BLI_assert(functions.contains(base_type)); - return functions.lookup(base_type); + return *functions.lookup(base_type); } -SharedFunction &GET_FN_list_length(Type *base_type) +Function &GET_FN_list_length(Type *base_type) { FunctionPerType &functions = get_list_functions().m_length; BLI_assert(functions.contains(base_type)); - return functions.lookup(base_type); + return *functions.lookup(base_type); } Type *get_list_type(Type *base_type) { - SharedFunction &fn = GET_FN_append_to_list(base_type); - return fn->input_type(0); + Function &fn = GET_FN_append_to_list(base_type); + return fn.input_type(0); } } // namespace Functions diff --git a/source/blender/functions/functions/lists.hpp b/source/blender/functions/functions/lists.hpp index d4623ae94a0..5fad8fae2a0 100644 --- a/source/blender/functions/functions/lists.hpp +++ b/source/blender/functions/functions/lists.hpp @@ -8,12 +8,12 @@ namespace Functions { Type *get_list_type(Type *base_type); -SharedFunction &GET_FN_empty_list(Type *base_type); -SharedFunction &GET_FN_list_from_element(Type *base_type); -SharedFunction &GET_FN_append_to_list(Type *base_type); -SharedFunction &GET_FN_get_list_element(Type *base_type); -SharedFunction &GET_FN_combine_lists(Type *base_type); -SharedFunction &GET_FN_list_length(Type *base_type); +Function &GET_FN_empty_list(Type *base_type); +Function &GET_FN_list_from_element(Type *base_type); +Function &GET_FN_append_to_list(Type *base_type); +Function &GET_FN_get_list_element(Type *base_type); +Function &GET_FN_combine_lists(Type *base_type); +Function &GET_FN_list_length(Type *base_type); } // namespace Functions } // namespace FN diff --git a/source/blender/functions/functions/object_input.cpp b/source/blender/functions/functions/object_input.cpp index ad3269d2f04..d2f1874b260 100644 --- a/source/blender/functions/functions/object_input.cpp +++ b/source/blender/functions/functions/object_input.cpp @@ -35,7 +35,7 @@ class ObjectLocationDeps : public DepsBody { } }; -BLI_LAZY_INIT(SharedFunction, GET_FN_object_location) +BLI_LAZY_INIT_REF(Function, GET_FN_object_location) { FunctionBuilder builder; builder.add_input("Object", TYPE_object); @@ -81,7 +81,7 @@ class ObjectMeshDeps : public DepsBody { } }; -BLI_LAZY_INIT(SharedFunction, GET_FN_object_mesh_vertices) +BLI_LAZY_INIT_REF(Function, GET_FN_object_mesh_vertices) { FunctionBuilder builder; builder.add_input("Object", TYPE_object); diff --git a/source/blender/functions/functions/object_input.hpp b/source/blender/functions/functions/object_input.hpp index 013b37f277b..0e5a08b37b0 100644 --- a/source/blender/functions/functions/object_input.hpp +++ b/source/blender/functions/functions/object_input.hpp @@ -5,8 +5,8 @@ namespace FN { namespace Functions { -SharedFunction &GET_FN_object_location(); -SharedFunction &GET_FN_object_mesh_vertices(); +Function &GET_FN_object_location(); +Function &GET_FN_object_mesh_vertices(); } // namespace Functions } // namespace FN diff --git a/source/blender/functions/functions/random.cpp b/source/blender/functions/functions/random.cpp index e8a05fec4ae..6328e5a811a 100644 --- a/source/blender/functions/functions/random.cpp +++ b/source/blender/functions/functions/random.cpp @@ -36,7 +36,7 @@ class RandomNumber : public TupleCallBody { } }; -BLI_LAZY_INIT(SharedFunction, GET_FN_random_number) +BLI_LAZY_INIT_REF(Function, GET_FN_random_number) { FunctionBuilder builder; builder.add_input("Seed", TYPE_float); diff --git a/source/blender/functions/functions/random.hpp b/source/blender/functions/functions/random.hpp index e8f9863dd39..d0c37b2f193 100644 --- a/source/blender/functions/functions/random.hpp +++ b/source/blender/functions/functions/random.hpp @@ -5,6 +5,6 @@ namespace FN { namespace Functions { -SharedFunction &GET_FN_random_number(); +Function &GET_FN_random_number(); } } // namespace FN diff --git a/source/blender/functions/functions/ranges.cpp b/source/blender/functions/functions/ranges.cpp index 05abf6f6ab7..efbc19d09d3 100644 --- a/source/blender/functions/functions/ranges.cpp +++ b/source/blender/functions/functions/ranges.cpp @@ -37,7 +37,7 @@ class FloatRange : public TupleCallBody { } }; -BLI_LAZY_INIT(SharedFunction, GET_FN_float_range) +BLI_LAZY_INIT_REF(Function, GET_FN_float_range) { FunctionBuilder builder; builder.add_input("Amount", TYPE_int32); diff --git a/source/blender/functions/functions/ranges.hpp b/source/blender/functions/functions/ranges.hpp index e6b549a1654..3517ca99ea8 100644 --- a/source/blender/functions/functions/ranges.hpp +++ b/source/blender/functions/functions/ranges.hpp @@ -5,6 +5,6 @@ namespace FN { namespace Functions { -SharedFunction &GET_FN_float_range(); +Function &GET_FN_float_range(); } } // namespace FN diff --git a/source/blender/functions/functions/scalar_math.cpp b/source/blender/functions/functions/scalar_math.cpp index 22dc7854f1c..eb2af7917cb 100644 --- a/source/blender/functions/functions/scalar_math.cpp +++ b/source/blender/functions/functions/scalar_math.cpp @@ -12,7 +12,7 @@ namespace Functions { using namespace Types; -static SharedFunction get_math_function__one_input(std::string name) +static std::unique_ptr<Function> get_math_function__one_input(std::string name) { FunctionBuilder builder; builder.add_input("Value", TYPE_float); @@ -20,7 +20,7 @@ static SharedFunction get_math_function__one_input(std::string name) return builder.build(name); } -static SharedFunction get_math_function__two_inputs(std::string name) +static std::unique_ptr<Function> get_math_function__two_inputs(std::string name) { FunctionBuilder builder; builder.add_input("A", TYPE_float); @@ -48,7 +48,7 @@ class AddFloatsGen : public LLVMBuildIRBody { } }; -BLI_LAZY_INIT(SharedFunction, GET_FN_add_floats) +BLI_LAZY_INIT_REF(Function, GET_FN_add_floats) { auto fn = get_math_function__two_inputs("Add Floats"); fn->add_body<AddFloats>(); @@ -75,7 +75,7 @@ class SubFloatsGen : public LLVMBuildIRBody { } }; -BLI_LAZY_INIT(SharedFunction, GET_FN_sub_floats) +BLI_LAZY_INIT_REF(Function, GET_FN_sub_floats) { auto fn = get_math_function__two_inputs("Sub Floats"); fn->add_body<SubFloats>(); @@ -102,7 +102,7 @@ class MultiplyFloatsGen : public LLVMBuildIRBody { } }; -BLI_LAZY_INIT(SharedFunction, GET_FN_multiply_floats) +BLI_LAZY_INIT_REF(Function, GET_FN_multiply_floats) { auto fn = get_math_function__two_inputs("Multiply Floats"); fn->add_body<MultiplyFloats>(); @@ -126,7 +126,7 @@ class DivideFloats : public TupleCallBody { } }; -BLI_LAZY_INIT(SharedFunction, GET_FN_divide_floats) +BLI_LAZY_INIT_REF(Function, GET_FN_divide_floats) { auto fn = get_math_function__two_inputs("Divide Floats"); fn->add_body<DivideFloats>(); @@ -147,7 +147,7 @@ class PowerFloats : public TupleCallBody { } }; -BLI_LAZY_INIT(SharedFunction, GET_FN_power_floats) +BLI_LAZY_INIT_REF(Function, GET_FN_power_floats) { auto fn = get_math_function__two_inputs("Power Floats"); fn->add_body<PowerFloats>(); @@ -167,7 +167,7 @@ class LogarithmFloats : public TupleCallBody { } }; -BLI_LAZY_INIT(SharedFunction, GET_FN_log_floats) +BLI_LAZY_INIT_REF(Function, GET_FN_log_floats) { auto fn = get_math_function__two_inputs("Logarithm"); fn->add_body<LogarithmFloats>(); @@ -182,7 +182,7 @@ class SqrtFloat : public TupleCallBody { } }; -BLI_LAZY_INIT(SharedFunction, GET_FN_sqrt_float) +BLI_LAZY_INIT_REF(Function, GET_FN_sqrt_float) { auto fn = get_math_function__one_input("Square Root"); fn->add_body<SqrtFloat>(); @@ -197,7 +197,7 @@ class AbsFloat : public TupleCallBody { } }; -BLI_LAZY_INIT(SharedFunction, GET_FN_abs_float) +BLI_LAZY_INIT_REF(Function, GET_FN_abs_float) { auto fn = get_math_function__one_input("Absolute Float"); fn->add_body<AbsFloat>(); @@ -213,7 +213,7 @@ class MinFloats : public TupleCallBody { } }; -BLI_LAZY_INIT(SharedFunction, GET_FN_min_floats) +BLI_LAZY_INIT_REF(Function, GET_FN_min_floats) { auto fn = get_math_function__two_inputs("Minimum"); fn->add_body<MinFloats>(); @@ -229,7 +229,7 @@ class MaxFloats : public TupleCallBody { } }; -BLI_LAZY_INIT(SharedFunction, GET_FN_max_floats) +BLI_LAZY_INIT_REF(Function, GET_FN_max_floats) { auto fn = get_math_function__two_inputs("Maximum"); fn->add_body<MaxFloats>(); @@ -254,7 +254,7 @@ class SinFloatGen : public LLVMBuildIRBody { } }; -BLI_LAZY_INIT(SharedFunction, GET_FN_sin_float) +BLI_LAZY_INIT_REF(Function, GET_FN_sin_float) { auto fn = get_math_function__one_input("Sin"); fn->add_body<SinFloat>(); @@ -280,7 +280,7 @@ class CosFloatGen : public LLVMBuildIRBody { } }; -BLI_LAZY_INIT(SharedFunction, GET_FN_cos_float) +BLI_LAZY_INIT_REF(Function, GET_FN_cos_float) { auto fn = get_math_function__one_input("Cos"); fn->add_body<CosFloat>(); @@ -300,7 +300,7 @@ class TanFloat : public TupleCallBody { } }; -BLI_LAZY_INIT(SharedFunction, GET_FN_tan_float) +BLI_LAZY_INIT_REF(Function, GET_FN_tan_float) { auto fn = get_math_function__one_input("Tan"); fn->add_body<TanFloat>(); @@ -315,7 +315,7 @@ class ArcsineFloat : public TupleCallBody { } }; -BLI_LAZY_INIT(SharedFunction, GET_FN_asin_float) +BLI_LAZY_INIT_REF(Function, GET_FN_asin_float) { auto fn = get_math_function__one_input("Arcsine"); fn->add_body<ArcsineFloat>(); @@ -330,7 +330,7 @@ class ArccosineFloat : public TupleCallBody { } }; -BLI_LAZY_INIT(SharedFunction, GET_FN_acos_float) +BLI_LAZY_INIT_REF(Function, GET_FN_acos_float) { auto fn = get_math_function__one_input("Arccosine"); fn->add_body<ArccosineFloat>(); @@ -345,7 +345,7 @@ class ArctangentFloat : public TupleCallBody { } }; -BLI_LAZY_INIT(SharedFunction, GET_FN_atan_float) +BLI_LAZY_INIT_REF(Function, GET_FN_atan_float) { auto fn = get_math_function__one_input("Arctangent"); fn->add_body<ArctangentFloat>(); @@ -361,7 +361,7 @@ class Arctangent2Floats : public TupleCallBody { } }; -BLI_LAZY_INIT(SharedFunction, GET_FN_atan2_floats) +BLI_LAZY_INIT_REF(Function, GET_FN_atan2_floats) { auto fn = get_math_function__two_inputs("Arctangent2"); fn->add_body<Arctangent2Floats>(); @@ -381,7 +381,7 @@ class ModuloFloats : public TupleCallBody { } }; -BLI_LAZY_INIT(SharedFunction, GET_FN_mod_floats) +BLI_LAZY_INIT_REF(Function, GET_FN_mod_floats) { auto fn = get_math_function__two_inputs("Modulo Floats"); fn->add_body<ModuloFloats>(); @@ -397,7 +397,7 @@ class FractFloat : public TupleCallBody { } }; -BLI_LAZY_INIT(SharedFunction, GET_FN_fract_float) +BLI_LAZY_INIT_REF(Function, GET_FN_fract_float) { auto fn = get_math_function__one_input("Fract Float"); fn->add_body<FractFloat>(); @@ -412,7 +412,7 @@ class CeilFloat : public TupleCallBody { } }; -BLI_LAZY_INIT(SharedFunction, GET_FN_ceil_float) +BLI_LAZY_INIT_REF(Function, GET_FN_ceil_float) { auto fn = get_math_function__one_input("Ceil Float"); fn->add_body<CeilFloat>(); @@ -427,7 +427,7 @@ class FloorFloat : public TupleCallBody { } }; -BLI_LAZY_INIT(SharedFunction, GET_FN_floor_float) +BLI_LAZY_INIT_REF(Function, GET_FN_floor_float) { auto fn = get_math_function__one_input("Floor Float"); fn->add_body<FloorFloat>(); @@ -442,7 +442,7 @@ class RoundFloat : public TupleCallBody { } }; -BLI_LAZY_INIT(SharedFunction, GET_FN_round_float) +BLI_LAZY_INIT_REF(Function, GET_FN_round_float) { auto fn = get_math_function__one_input("Round Float"); fn->add_body<RoundFloat>(); @@ -464,7 +464,7 @@ class SnapFloats : public TupleCallBody { } }; -BLI_LAZY_INIT(SharedFunction, GET_FN_snap_floats) +BLI_LAZY_INIT_REF(Function, GET_FN_snap_floats) { auto fn = get_math_function__two_inputs("Snap Floats"); fn->add_body<SnapFloats>(); @@ -497,7 +497,7 @@ class MapRange : public TupleCallBody { } }; -BLI_LAZY_INIT(SharedFunction, GET_FN_map_range) +BLI_LAZY_INIT_REF(Function, GET_FN_map_range) { FunctionBuilder builder; builder.add_input("Value", TYPE_float); diff --git a/source/blender/functions/functions/scalar_math.hpp b/source/blender/functions/functions/scalar_math.hpp index a8e0e12d496..202d64f7d32 100644 --- a/source/blender/functions/functions/scalar_math.hpp +++ b/source/blender/functions/functions/scalar_math.hpp @@ -5,35 +5,35 @@ namespace FN { namespace Functions { -SharedFunction &GET_FN_add_floats(); -SharedFunction &GET_FN_sub_floats(); -SharedFunction &GET_FN_multiply_floats(); -SharedFunction &GET_FN_divide_floats(); - -SharedFunction &GET_FN_power_floats(); -SharedFunction &GET_FN_log_floats(); -SharedFunction &GET_FN_sqrt_float(); - -SharedFunction &GET_FN_abs_float(); -SharedFunction &GET_FN_min_floats(); -SharedFunction &GET_FN_max_floats(); -SharedFunction &GET_FN_mod_floats(); - -SharedFunction &GET_FN_sin_float(); -SharedFunction &GET_FN_cos_float(); -SharedFunction &GET_FN_tan_float(); -SharedFunction &GET_FN_asin_float(); -SharedFunction &GET_FN_acos_float(); -SharedFunction &GET_FN_atan_float(); -SharedFunction &GET_FN_atan2_floats(); - -SharedFunction &GET_FN_fract_float(); -SharedFunction &GET_FN_ceil_float(); -SharedFunction &GET_FN_floor_float(); -SharedFunction &GET_FN_round_float(); -SharedFunction &GET_FN_snap_floats(); - -SharedFunction &GET_FN_map_range(); +Function &GET_FN_add_floats(); +Function &GET_FN_sub_floats(); +Function &GET_FN_multiply_floats(); +Function &GET_FN_divide_floats(); + +Function &GET_FN_power_floats(); +Function &GET_FN_log_floats(); +Function &GET_FN_sqrt_float(); + +Function &GET_FN_abs_float(); +Function &GET_FN_min_floats(); +Function &GET_FN_max_floats(); +Function &GET_FN_mod_floats(); + +Function &GET_FN_sin_float(); +Function &GET_FN_cos_float(); +Function &GET_FN_tan_float(); +Function &GET_FN_asin_float(); +Function &GET_FN_acos_float(); +Function &GET_FN_atan_float(); +Function &GET_FN_atan2_floats(); + +Function &GET_FN_fract_float(); +Function &GET_FN_ceil_float(); +Function &GET_FN_floor_float(); +Function &GET_FN_round_float(); +Function &GET_FN_snap_floats(); + +Function &GET_FN_map_range(); } // namespace Functions } // namespace FN diff --git a/source/blender/functions/functions/simple_conversions.cpp b/source/blender/functions/functions/simple_conversions.cpp index aaf00ccaad0..9ce8c450a3f 100644 --- a/source/blender/functions/functions/simple_conversions.cpp +++ b/source/blender/functions/functions/simple_conversions.cpp @@ -18,7 +18,7 @@ template<typename From, typename To> class ImplicitConversion : public TupleCall } }; -static SharedFunction get_simple_conversion_function(Type *from_type, Type *to_type) +static std::unique_ptr<Function> get_simple_conversion_function(Type *from_type, Type *to_type) { FunctionBuilder builder; builder.add_input("In", from_type); @@ -28,7 +28,7 @@ static SharedFunction get_simple_conversion_function(Type *from_type, Type *to_t } template<typename From, typename To> -static SharedFunction get_implicit_conversion_function(Type *from_type, Type *to_type) +static std::unique_ptr<Function> get_implicit_conversion_function(Type *from_type, Type *to_type) { auto fn = get_simple_conversion_function(from_type, to_type); fn->add_body<ImplicitConversion<From, To>>(); @@ -37,66 +37,72 @@ static SharedFunction get_implicit_conversion_function(Type *from_type, Type *to /* Individual Element Conversion */ -BLI_LAZY_INIT(SharedFunction, GET_FN_bool_to_int32) +BLI_LAZY_INIT_REF(Function, GET_FN_bool_to_int32) { return get_implicit_conversion_function<bool, int32_t>(TYPE_bool, TYPE_int32); } -BLI_LAZY_INIT(SharedFunction, GET_FN_bool_to_float) +BLI_LAZY_INIT_REF(Function, GET_FN_bool_to_float) { return get_implicit_conversion_function<bool, float>(TYPE_bool, TYPE_float); } -BLI_LAZY_INIT(SharedFunction, GET_FN_int32_to_float) +BLI_LAZY_INIT_REF(Function, GET_FN_int32_to_float) { return get_implicit_conversion_function<int32_t, float>(TYPE_int32, TYPE_float); } -BLI_LAZY_INIT(SharedFunction, GET_FN_int32_to_bool) +BLI_LAZY_INIT_REF(Function, GET_FN_int32_to_bool) { return get_implicit_conversion_function<int32_t, bool>(TYPE_int32, TYPE_bool); } -BLI_LAZY_INIT(SharedFunction, GET_FN_float_to_int32) +BLI_LAZY_INIT_REF(Function, GET_FN_float_to_int32) { return get_implicit_conversion_function<float, int32_t>(TYPE_float, TYPE_int32); } -BLI_LAZY_INIT(SharedFunction, GET_FN_float_to_bool) +BLI_LAZY_INIT_REF(Function, GET_FN_float_to_bool) { return get_implicit_conversion_function<float, bool>(TYPE_float, TYPE_bool); } /* List Conversions */ -BLI_LAZY_INIT(SharedFunction, GET_FN_bool_list_to_int32_list) +BLI_LAZY_INIT_REF(Function, GET_FN_bool_list_to_int32_list) { - return to_vectorized_function(GET_FN_bool_to_int32(), {true}, {GET_FN_output_false()}); + return to_vectorized_function__without_cache( + GET_FN_bool_to_int32(), {true}, {&GET_FN_output_false()}); } -BLI_LAZY_INIT(SharedFunction, GET_FN_bool_list_to_float_list) +BLI_LAZY_INIT_REF(Function, GET_FN_bool_list_to_float_list) { - return to_vectorized_function(GET_FN_bool_to_float(), {true}, {GET_FN_output_false()}); + return to_vectorized_function__without_cache( + GET_FN_bool_to_float(), {true}, {&GET_FN_output_false()}); } -BLI_LAZY_INIT(SharedFunction, GET_FN_int32_list_to_float_list) +BLI_LAZY_INIT_REF(Function, GET_FN_int32_list_to_float_list) { - return to_vectorized_function(GET_FN_int32_to_float(), {true}, {GET_FN_output_int32_0()}); + return to_vectorized_function__without_cache( + GET_FN_int32_to_float(), {true}, {&GET_FN_output_int32_0()}); } -BLI_LAZY_INIT(SharedFunction, GET_FN_int32_list_to_bool_list) +BLI_LAZY_INIT_REF(Function, GET_FN_int32_list_to_bool_list) { - return to_vectorized_function(GET_FN_int32_to_bool(), {true}, {GET_FN_output_int32_0()}); + return to_vectorized_function__without_cache( + GET_FN_int32_to_bool(), {true}, {&GET_FN_output_int32_0()}); } -BLI_LAZY_INIT(SharedFunction, GET_FN_float_list_to_int32_list) +BLI_LAZY_INIT_REF(Function, GET_FN_float_list_to_int32_list) { - return to_vectorized_function(GET_FN_float_to_int32(), {true}, {GET_FN_output_float_0()}); + return to_vectorized_function__without_cache( + GET_FN_float_to_int32(), {true}, {&GET_FN_output_float_0()}); } -BLI_LAZY_INIT(SharedFunction, GET_FN_float_list_to_bool_list) +BLI_LAZY_INIT_REF(Function, GET_FN_float_list_to_bool_list) { - return to_vectorized_function(GET_FN_float_to_bool(), {true}, {GET_FN_output_float_0()}); + return to_vectorized_function__without_cache( + GET_FN_float_to_bool(), {true}, {&GET_FN_output_float_0()}); } } // namespace Functions diff --git a/source/blender/functions/functions/simple_conversions.hpp b/source/blender/functions/functions/simple_conversions.hpp index be2911f6684..1cc5aa671ce 100644 --- a/source/blender/functions/functions/simple_conversions.hpp +++ b/source/blender/functions/functions/simple_conversions.hpp @@ -5,19 +5,19 @@ namespace FN { namespace Functions { -SharedFunction &GET_FN_bool_to_int32(); -SharedFunction &GET_FN_bool_to_float(); -SharedFunction &GET_FN_int32_to_float(); -SharedFunction &GET_FN_int32_to_bool(); -SharedFunction &GET_FN_float_to_int32(); -SharedFunction &GET_FN_float_to_bool(); +Function &GET_FN_bool_to_int32(); +Function &GET_FN_bool_to_float(); +Function &GET_FN_int32_to_float(); +Function &GET_FN_int32_to_bool(); +Function &GET_FN_float_to_int32(); +Function &GET_FN_float_to_bool(); -SharedFunction &GET_FN_bool_list_to_int32_list(); -SharedFunction &GET_FN_bool_list_to_float_list(); -SharedFunction &GET_FN_int32_list_to_float_list(); -SharedFunction &GET_FN_int32_list_to_bool_list(); -SharedFunction &GET_FN_float_list_to_int32_list(); -SharedFunction &GET_FN_float_list_to_bool_list(); +Function &GET_FN_bool_list_to_int32_list(); +Function &GET_FN_bool_list_to_float_list(); +Function &GET_FN_int32_list_to_float_list(); +Function &GET_FN_int32_list_to_bool_list(); +Function &GET_FN_float_list_to_int32_list(); +Function &GET_FN_float_list_to_bool_list(); } // namespace Functions } // namespace FN diff --git a/source/blender/functions/functions/string.cpp b/source/blender/functions/functions/string.cpp index 4891ed56e81..cb52ccd5c00 100644 --- a/source/blender/functions/functions/string.cpp +++ b/source/blender/functions/functions/string.cpp @@ -19,7 +19,7 @@ class StringLength : public TupleCallBody { } }; -BLI_LAZY_INIT(SharedFunction, GET_FN_string_length) +BLI_LAZY_INIT_REF(Function, GET_FN_string_length) { FunctionBuilder builder; builder.add_input("String", TYPE_string); diff --git a/source/blender/functions/functions/string.hpp b/source/blender/functions/functions/string.hpp index 7bb58f0bb0b..ad7d92c2cbf 100644 --- a/source/blender/functions/functions/string.hpp +++ b/source/blender/functions/functions/string.hpp @@ -5,6 +5,6 @@ namespace FN { namespace Functions { -SharedFunction &GET_FN_string_length(); +Function &GET_FN_string_length(); } } // namespace FN diff --git a/source/blender/functions/functions/switch.cpp b/source/blender/functions/functions/switch.cpp index 7d4477b0d7e..50422abdeeb 100644 --- a/source/blender/functions/functions/switch.cpp +++ b/source/blender/functions/functions/switch.cpp @@ -55,7 +55,7 @@ class LazyBoolSwitch : public LazyInTupleCallBody { } }; -static SharedFunction build_bool_switch_function(Type *data_type) +static std::unique_ptr<Function> build_bool_switch_function(Type *data_type) { FunctionBuilder builder; builder.add_input("Condition", TYPE_bool); @@ -69,20 +69,16 @@ static SharedFunction build_bool_switch_function(Type *data_type) return fn; } -using CacheMap = Map<Type *, SharedFunction>; +using CacheMap = Map<Type *, std::unique_ptr<Function>>; BLI_LAZY_INIT_STATIC(CacheMap, get_cache) { return {}; } -SharedFunction &GET_FN_bool_switch(Type *data_type) +Function &GET_FN_bool_switch(Type *data_type) { CacheMap &cache = get_cache(); - if (!cache.contains(data_type)) { - SharedFunction fn = build_bool_switch_function(data_type); - cache.add(data_type, fn); - } - return cache.lookup(data_type); + return *cache.lookup_or_add(data_type, [&]() { return build_bool_switch_function(data_type); }); } } // namespace Functions diff --git a/source/blender/functions/functions/switch.hpp b/source/blender/functions/functions/switch.hpp index 1846a3c762c..f4908c6ac35 100644 --- a/source/blender/functions/functions/switch.hpp +++ b/source/blender/functions/functions/switch.hpp @@ -5,6 +5,6 @@ namespace FN { namespace Functions { -SharedFunction &GET_FN_bool_switch(Type *data_type); +Function &GET_FN_bool_switch(Type *data_type); } } // namespace FN diff --git a/source/blender/functions/functions/vectors.cpp b/source/blender/functions/functions/vectors.cpp index babb59ce2d1..64f1b008313 100644 --- a/source/blender/functions/functions/vectors.cpp +++ b/source/blender/functions/functions/vectors.cpp @@ -26,7 +26,7 @@ class CombineVectorGen : public LLVMBuildIRBody { } }; -BLI_LAZY_INIT(SharedFunction, GET_FN_combine_vector) +BLI_LAZY_INIT_REF(Function, GET_FN_combine_vector) { FunctionBuilder builder; builder.add_input("X", TYPE_float); @@ -51,7 +51,7 @@ class SeparateVector : public LLVMBuildIRBody { } }; -BLI_LAZY_INIT(SharedFunction, GET_FN_separate_vector) +BLI_LAZY_INIT_REF(Function, GET_FN_separate_vector) { FunctionBuilder builder; builder.add_input("Vector", TYPE_float3); @@ -73,7 +73,7 @@ class VectorDistance : public TupleCallBody { } }; -BLI_LAZY_INIT(SharedFunction, GET_FN_vector_distance) +BLI_LAZY_INIT_REF(Function, GET_FN_vector_distance) { FunctionBuilder builder; builder.add_input("A", TYPE_float3); @@ -85,7 +85,7 @@ BLI_LAZY_INIT(SharedFunction, GET_FN_vector_distance) return fn; } -static SharedFunction get_math_function__two_inputs(std::string name) +static std::unique_ptr<Function> get_math_function__two_inputs(std::string name) { FunctionBuilder builder; builder.add_input("A", TYPE_float3); @@ -115,7 +115,7 @@ class AddVectorsGen : public LLVMBuildIRBody { } }; -BLI_LAZY_INIT(SharedFunction, GET_FN_add_vectors) +BLI_LAZY_INIT_REF(Function, GET_FN_add_vectors) { auto fn = get_math_function__two_inputs("Add Vectors"); fn->add_body<AddVectors>(); @@ -144,7 +144,7 @@ class SubVectorsGen : public LLVMBuildIRBody { } }; -BLI_LAZY_INIT(SharedFunction, GET_FN_sub_vectors) +BLI_LAZY_INIT_REF(Function, GET_FN_sub_vectors) { auto fn = get_math_function__two_inputs("Subtract Vectors"); fn->add_body<SubVectors>(); @@ -172,7 +172,7 @@ class MultiplyVectorsGen : public LLVMBuildIRBody { } }; -BLI_LAZY_INIT(SharedFunction, GET_FN_mul_vectors) +BLI_LAZY_INIT_REF(Function, GET_FN_mul_vectors) { auto fn = get_math_function__two_inputs("Multiply Vectors"); fn->add_body<MultiplyVectors>(); @@ -189,7 +189,7 @@ class DivideVectors : public TupleCallBody { } }; -BLI_LAZY_INIT(SharedFunction, GET_FN_div_vectors) +BLI_LAZY_INIT_REF(Function, GET_FN_div_vectors) { auto fn = get_math_function__two_inputs("Divide Vectors"); fn->add_body<DivideVectors>(); @@ -244,7 +244,7 @@ class CrossProductVectorsGen : public LLVMBuildIRBody { } }; -BLI_LAZY_INIT(SharedFunction, GET_FN_cross_vectors) +BLI_LAZY_INIT_REF(Function, GET_FN_cross_vectors) { auto fn = get_math_function__two_inputs("Cross Product"); fn->add_body<CrossProductVectors>(); @@ -261,7 +261,7 @@ class ReflectVector : public TupleCallBody { } }; -BLI_LAZY_INIT(SharedFunction, GET_FN_reflect_vector) +BLI_LAZY_INIT_REF(Function, GET_FN_reflect_vector) { auto fn = get_math_function__two_inputs("Reflect Vector"); fn->add_body<ReflectVector>(); @@ -280,7 +280,7 @@ class ProjectVector : public TupleCallBody { } }; -BLI_LAZY_INIT(SharedFunction, GET_FN_project_vector) +BLI_LAZY_INIT_REF(Function, GET_FN_project_vector) { auto fn = get_math_function__two_inputs("Project Vector"); fn->add_body<ProjectVector>(); @@ -298,7 +298,7 @@ class VectorDotProduct : public TupleCallBody { } }; -BLI_LAZY_INIT(SharedFunction, GET_FN_dot_product) +BLI_LAZY_INIT_REF(Function, GET_FN_dot_product) { FunctionBuilder builder; builder.add_input("A", TYPE_float3); diff --git a/source/blender/functions/functions/vectors.hpp b/source/blender/functions/functions/vectors.hpp index fe7dae882de..3c47fdb111b 100644 --- a/source/blender/functions/functions/vectors.hpp +++ b/source/blender/functions/functions/vectors.hpp @@ -5,17 +5,17 @@ namespace FN { namespace Functions { -SharedFunction &GET_FN_combine_vector(); -SharedFunction &GET_FN_separate_vector(); -SharedFunction &GET_FN_vector_distance(); -SharedFunction &GET_FN_add_vectors(); -SharedFunction &GET_FN_sub_vectors(); -SharedFunction &GET_FN_mul_vectors(); -SharedFunction &GET_FN_div_vectors(); -SharedFunction &GET_FN_cross_vectors(); -SharedFunction &GET_FN_reflect_vector(); -SharedFunction &GET_FN_project_vector(); -SharedFunction &GET_FN_dot_product(); +Function &GET_FN_combine_vector(); +Function &GET_FN_separate_vector(); +Function &GET_FN_vector_distance(); +Function &GET_FN_add_vectors(); +Function &GET_FN_sub_vectors(); +Function &GET_FN_mul_vectors(); +Function &GET_FN_div_vectors(); +Function &GET_FN_cross_vectors(); +Function &GET_FN_reflect_vector(); +Function &GET_FN_project_vector(); +Function &GET_FN_dot_product(); } // namespace Functions } // namespace FN diff --git a/source/blender/simulations/bparticles/action_interface.hpp b/source/blender/simulations/bparticles/action_interface.hpp index 31f6674d39b..5f7f36a4fb4 100644 --- a/source/blender/simulations/bparticles/action_interface.hpp +++ b/source/blender/simulations/bparticles/action_interface.hpp @@ -13,7 +13,7 @@ namespace BParticles { using BLI::TemporaryArray; using BLI::TemporaryVector; using FN::ExecutionContext; -using FN::SharedFunction; +using FN::Function; using FN::Tuple; using FN::TupleCallBody; diff --git a/source/blender/simulations/bparticles/emitters.hpp b/source/blender/simulations/bparticles/emitters.hpp index f10e48e1082..29749eaa66b 100644 --- a/source/blender/simulations/bparticles/emitters.hpp +++ b/source/blender/simulations/bparticles/emitters.hpp @@ -8,7 +8,7 @@ namespace BParticles { -using FN::SharedFunction; +using FN::Function; using FN::TupleCallBody; class SurfaceEmitter : public Emitter { diff --git a/source/blender/simulations/bparticles/forces.cpp b/source/blender/simulations/bparticles/forces.cpp index 973a2e12740..9533c7de5e7 100644 --- a/source/blender/simulations/bparticles/forces.cpp +++ b/source/blender/simulations/bparticles/forces.cpp @@ -15,7 +15,7 @@ void GravityForce::add_force(ForceInterface &interface) auto inputs = m_inputs_fn->compute(interface); for (uint pindex : interface.pindices()) { - float3 acceleration = inputs->get<float3>("Direction", 0, pindex); + float3 acceleration = inputs->get<float3>("Acceleration", 0, pindex); float weight = inputs->get<float>("Weight", 1, pindex); destination[pindex] += acceleration * weight; } diff --git a/source/blender/simulations/bparticles/node_frontend.cpp b/source/blender/simulations/bparticles/node_frontend.cpp index 8e8976894be..016de9bf482 100644 --- a/source/blender/simulations/bparticles/node_frontend.cpp +++ b/source/blender/simulations/bparticles/node_frontend.cpp @@ -68,7 +68,7 @@ class VTreeData { VTreeDataGraph &m_vtree_data_graph; Vector<std::unique_ptr<ParticleFunction>> m_particle_functions; - Vector<SharedFunction> m_functions; + Vector<std::unique_ptr<Function>> m_functions; Vector<destruct_ptr<Tuple>> m_tuples; Vector<destruct_ptr<FunctionOutputNamesProvider>> m_name_providers; Vector<destruct_ptr<Vector<std::string>>> m_string_vectors; @@ -238,9 +238,9 @@ class VTreeData { FunctionGraph fgraph(m_vtree_data_graph.graph(), {}, sockets_to_compute); auto fn = fgraph.new_function(vnode->name()); - FN::fgraph_add_TupleCallBody(fn, fgraph); - m_functions.append(fn); - return &fn->body<TupleCallBody>(); + FN::fgraph_add_TupleCallBody(*fn, fgraph); + m_functions.append(std::move(fn)); + return &m_functions.last()->body<TupleCallBody>(); } Vector<VirtualSocket *> find_execute_sockets(VirtualNode *vnode, StringRef name_prefix) diff --git a/source/blender/simulations/bparticles/particle_function.cpp b/source/blender/simulations/bparticles/particle_function.cpp index e3a8f281694..c0520e329a7 100644 --- a/source/blender/simulations/bparticles/particle_function.cpp +++ b/source/blender/simulations/bparticles/particle_function.cpp @@ -9,8 +9,8 @@ ParticleFunctionInputProvider::~ParticleFunctionInputProvider() { } -ParticleFunction::ParticleFunction(SharedFunction fn_no_deps, - SharedFunction fn_with_deps, +ParticleFunction::ParticleFunction(std::unique_ptr<Function> fn_no_deps, + std::unique_ptr<Function> fn_with_deps, Vector<ParticleFunctionInputProvider *> input_providers, Vector<bool> parameter_depends_on_particle) : m_fn_no_deps(std::move(fn_no_deps)), @@ -37,7 +37,7 @@ ParticleFunction::ParticleFunction(SharedFunction fn_no_deps, if (m_fn_with_deps->output_amount() > 0) { // m_array_execution = FN::Functions::get_precompiled_array_execution(m_fn_with_deps); - m_array_execution = FN::Functions::get_tuple_call_array_execution(m_fn_with_deps); + m_array_execution = FN::Functions::get_tuple_call_array_execution(*m_fn_with_deps); } } @@ -95,8 +95,8 @@ std::unique_ptr<ParticleFunctionResult> ParticleFunction::compute(ArrayRef<uint> 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); - result->m_fn_no_deps = m_fn_no_deps.ptr(); - result->m_fn_with_deps = m_fn_with_deps.ptr(); + result->m_fn_no_deps = m_fn_no_deps.get(); + result->m_fn_with_deps = m_fn_with_deps.get(); result->m_output_indices = m_output_indices; result->m_pindices = pindices; diff --git a/source/blender/simulations/bparticles/particle_function.hpp b/source/blender/simulations/bparticles/particle_function.hpp index 7ed281ba092..2727910f896 100644 --- a/source/blender/simulations/bparticles/particle_function.hpp +++ b/source/blender/simulations/bparticles/particle_function.hpp @@ -18,7 +18,7 @@ using BLI::Vector; using FN::CPPTypeInfo; using FN::ExecutionContext; using FN::ExecutionStack; -using FN::SharedFunction; +using FN::Function; using FN::TupleCallBody; using FN::Type; @@ -217,16 +217,16 @@ class ParticleFunctionInputProvider { class ParticleFunction { private: - SharedFunction m_fn_no_deps; - SharedFunction m_fn_with_deps; + std::unique_ptr<Function> m_fn_no_deps; + std::unique_ptr<Function> m_fn_with_deps; Vector<ParticleFunctionInputProvider *> m_input_providers; Vector<bool> m_parameter_depends_on_particle; Vector<uint> m_output_indices; std::unique_ptr<FN::Functions::ArrayExecution> m_array_execution; public: - ParticleFunction(SharedFunction fn_no_deps, - SharedFunction fn_with_deps, + ParticleFunction(std::unique_ptr<Function> fn_no_deps, + std::unique_ptr<Function> fn_with_deps, Vector<ParticleFunctionInputProvider *> input_providers, Vector<bool> parameter_depends_on_particle); diff --git a/source/blender/simulations/bparticles/particle_function_builder.cpp b/source/blender/simulations/bparticles/particle_function_builder.cpp index cda1fb71038..cf7d7d3aa60 100644 --- a/source/blender/simulations/bparticles/particle_function_builder.cpp +++ b/source/blender/simulations/bparticles/particle_function_builder.cpp @@ -15,9 +15,9 @@ using BLI::float2; using BLI::rgba_b; using FN::DataGraph; using FN::DataSocket; +using FN::Function; using FN::FunctionBuilder; using FN::FunctionGraph; -using FN::SharedFunction; using FN::Type; using FN::Types::StringW; @@ -114,8 +114,8 @@ static ParticleFunctionInputProvider *INPUT_surface_image(VTreeDataGraph &vtree_ FunctionGraph fgraph(vtree_data_graph.graph(), {}, {vtree_data_graph.lookup_socket(vsocket->vnode()->input(0))}); - FN::SharedFunction fn = fgraph.new_function(vsocket->vnode()->name()); - FN::fgraph_add_TupleCallBody(fn, fgraph); + std::unique_ptr<Function> fn = fgraph.new_function(vsocket->vnode()->name()); + FN::fgraph_add_TupleCallBody(*fn, fgraph); FN::TupleCallBody &body = fn->body<TupleCallBody>(); FN_TUPLE_CALL_ALLOC_TUPLES(body, fn_in, fn_out); @@ -147,8 +147,8 @@ static ParticleFunctionInputProvider *INPUT_is_in_group(VTreeDataGraph &vtree_da { FunctionGraph fgraph( vtree_data_graph.graph(), {}, {vtree_data_graph.lookup_socket(vsocket->vnode()->input(0))}); - FN::SharedFunction fn = fgraph.new_function(vsocket->vnode()->name()); - FN::fgraph_add_TupleCallBody(fn, fgraph); + std::unique_ptr<Function> fn = fgraph.new_function(vsocket->vnode()->name()); + FN::fgraph_add_TupleCallBody(*fn, fgraph); FN::TupleCallBody &body = fn->body<TupleCallBody>(); FN_TUPLE_CALL_ALLOC_TUPLES(body, fn_in, fn_out); @@ -182,7 +182,7 @@ static ParticleFunctionInputProvider *create_input_provider(VTreeDataGraph &vtre return provider; } -static SharedFunction create_function__with_deps( +static std::unique_ptr<Function> create_function__with_deps( VTreeDataGraph &data_graph, StringRef function_name, ArrayRef<DataSocket> sockets_to_compute, @@ -202,22 +202,21 @@ static SharedFunction create_function__with_deps( r_input_providers[i] = create_input_provider(data_graph, input_vsockets[i]); } - SharedFunction fn = fn_builder.build(function_name); + std::unique_ptr<Function> fn = fn_builder.build(function_name); FunctionGraph fgraph(data_graph.graph(), input_sockets, sockets_to_compute); - FN::fgraph_add_TupleCallBody(fn, fgraph); - FN::fgraph_add_LLVMBuildIRBody(fn, fgraph); + FN::fgraph_add_TupleCallBody(*fn, fgraph); + FN::fgraph_add_LLVMBuildIRBody(*fn, fgraph); return fn; } -static SharedFunction create_function__without_deps(DataGraph &graph, - StringRef function_name, - ArrayRef<DataSocket> sockets_to_compute) +static std::unique_ptr<Function> create_function__without_deps( + DataGraph &graph, StringRef function_name, ArrayRef<DataSocket> sockets_to_compute) { FunctionBuilder fn_builder; fn_builder.add_outputs(graph, sockets_to_compute); - SharedFunction fn = fn_builder.build(function_name); + std::unique_ptr<Function> fn = fn_builder.build(function_name); FunctionGraph fgraph(graph, {}, sockets_to_compute); - FN::fgraph_add_TupleCallBody(fn, fgraph); + FN::fgraph_add_TupleCallBody(*fn, fgraph); return fn; } @@ -241,13 +240,15 @@ static Optional<std::unique_ptr<ParticleFunction>> create_particle_function_from Vector<ParticleFunctionInputProvider *> input_providers(dependencies.size(), nullptr); - SharedFunction fn_without_deps = create_function__without_deps( + std::unique_ptr<Function> fn_without_deps = create_function__without_deps( data_graph.graph(), name, sockets_without_deps); - SharedFunction fn_with_deps = create_function__with_deps( + std::unique_ptr<Function> fn_with_deps = create_function__with_deps( data_graph, name, sockets_with_deps, dependencies, input_providers); - return make_unique<ParticleFunction>( - fn_without_deps, fn_with_deps, input_providers, depends_on_particle_flags); + return make_unique<ParticleFunction>(std::move(fn_without_deps), + std::move(fn_with_deps), + input_providers, + depends_on_particle_flags); } Optional<std::unique_ptr<ParticleFunction>> create_particle_function(VirtualNode *vnode, |