From b5c2c3aba886f521a0cade5b8450683c20843d3a Mon Sep 17 00:00:00 2001 From: Jacques Lucke Date: Thu, 1 Apr 2021 15:55:08 +0200 Subject: BLI: rename resource collector to resource scope Differential Revision: https://developer.blender.org/D10857 --- source/blender/blenlib/BLI_resource_collector.hh | 158 ------------------- source/blender/blenlib/BLI_resource_scope.hh | 170 +++++++++++++++++++++ source/blender/blenlib/CMakeLists.txt | 2 +- .../editors/space_spreadsheet/space_spreadsheet.cc | 10 +- .../space_spreadsheet/spreadsheet_from_geometry.cc | 20 +-- .../space_spreadsheet/spreadsheet_from_geometry.hh | 4 +- .../FN_multi_function_network_optimization.hh | 4 +- .../blender/functions/FN_multi_function_params.hh | 18 +-- .../intern/multi_function_network_evaluation.cc | 109 +++++++------ .../intern/multi_function_network_optimization.cc | 27 ++-- source/blender/modifiers/intern/MOD_nodes.cc | 6 +- .../blender/nodes/NOD_node_tree_multi_function.hh | 17 +-- .../nodes/intern/node_tree_multi_function.cc | 21 ++- source/blender/nodes/intern/type_callbacks.cc | 3 +- 14 files changed, 286 insertions(+), 283 deletions(-) delete mode 100644 source/blender/blenlib/BLI_resource_collector.hh create mode 100644 source/blender/blenlib/BLI_resource_scope.hh diff --git a/source/blender/blenlib/BLI_resource_collector.hh b/source/blender/blenlib/BLI_resource_collector.hh deleted file mode 100644 index 70804ceb1f1..00000000000 --- a/source/blender/blenlib/BLI_resource_collector.hh +++ /dev/null @@ -1,158 +0,0 @@ -/* - * This program is free software; you can redistribute it and/or - * modify it under the terms of the GNU General Public License - * as published by the Free Software Foundation; either version 2 - * of the License, or (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program; if not, write to the Free Software Foundation, - * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. - */ - -#pragma once - -/** \file - * \ingroup bli - * - * A ResourceCollector holds an arbitrary set of resources, that will be destructed and/or freed - * when the ResourceCollector is destructed. This is useful when some object has to take ownership - * of other objects, but it does not know the type of those other objects. - * - * Resources owned by the ResourceCollector will be freed in reverse order. That allows resources - * that are added later to depend on resources that have been added before. - */ - -#include "BLI_linear_allocator.hh" -#include "BLI_utility_mixins.hh" -#include "BLI_vector.hh" - -namespace blender { - -class ResourceCollector : NonCopyable, NonMovable { - private: - struct ResourceData { - void *data; - void (*free)(void *data); - const char *debug_name; - }; - - LinearAllocator<> m_allocator; - Vector m_resources; - - public: - ResourceCollector() = default; - - ~ResourceCollector() - { - /* Free in reversed order. */ - for (int64_t i = m_resources.size(); i--;) { - ResourceData &data = m_resources[i]; - data.free(data.data); - } - } - - /** - * Pass ownership of the resource to the ResourceCollector. It will be destructed and freed when - * the collector is destructed. - */ - template void add(std::unique_ptr resource, const char *name) - { - BLI_assert(resource.get() != nullptr); - this->add( - resource.release(), - [](void *data) { - T *typed_data = reinterpret_cast(data); - delete typed_data; - }, - name); - } - - /** - * Pass ownership of the resource to the ResourceCollector. It will be destructed when the - * collector is destructed. - */ - template void add(destruct_ptr resource, const char *name) - { - /* There is no need to keep track of such types. */ - if (std::is_trivially_destructible_v) { - resource.release(); - return; - } - - BLI_assert(resource.get() != nullptr); - this->add( - resource.release(), - [](void *data) { - T *typed_data = reinterpret_cast(data); - typed_data->~T(); - }, - name); - } - - /** - * Pass ownership of some resource to the ResourceCollector. The given free function will be - * called when the collector is destructed. - */ - void add(void *userdata, void (*free)(void *), const char *name) - { - ResourceData data; - data.debug_name = name; - data.data = userdata; - data.free = free; - m_resources.append(data); - } - - /** - * Construct an object with the same value in the ResourceCollector and return a reference to the - * new value. - */ - template T &add_value(T &&value, const char *name) - { - return this->construct(name, std::forward(value)); - } - - /** - * Returns a reference to a linear allocator that is owned by the ResourcesCollector. Memory - * allocated through this allocator will be freed when the collector is destructed. - */ - LinearAllocator<> &linear_allocator() - { - return m_allocator; - } - - /** - * Utility method to construct an instance of type T that will be owned by the ResourceCollector. - */ - template T &construct(const char *name, Args &&... args) - { - destruct_ptr value_ptr = m_allocator.construct(std::forward(args)...); - T &value_ref = *value_ptr; - this->add(std::move(value_ptr), name); - return value_ref; - } - - /** - * Print the names of all the resources that are owned by this ResourceCollector. This can be - * useful for debugging. - */ - void print(StringRef name) const - { - if (m_resources.size() == 0) { - std::cout << "\"" << name << "\" has no resources.\n"; - return; - } - else { - std::cout << "Resources for \"" << name << "\":\n"; - for (const ResourceData &data : m_resources) { - std::cout << " " << data.data << ": " << data.debug_name << '\n'; - } - } - } -}; - -} // namespace blender diff --git a/source/blender/blenlib/BLI_resource_scope.hh b/source/blender/blenlib/BLI_resource_scope.hh new file mode 100644 index 00000000000..f606dc0c0a1 --- /dev/null +++ b/source/blender/blenlib/BLI_resource_scope.hh @@ -0,0 +1,170 @@ +/* + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + */ + +#pragma once + +/** \file + * \ingroup bli + * + * A `ResourceScope` takes ownership of arbitrary data/resources. Those resources will be + * destructed and/or freed when the `ResourceScope` is destructed. Destruction happens in reverse + * order. That allows resources do depend on other resources that have been added before. + * + * A `ResourceScope` can also be thought of as a dynamic/runtime version of normal scopes in C++ + * that are surrounded by braces. + * + * The main purpose of a `ResourceScope` is to allow functions to inject data into the scope of the + * caller. Traditionally, that can only be done by returning a value that owns everything it needs. + * This is fine until one has to deal with optional ownership. There are many ways to have a type + * optionally own something else, all of which are fairly annoying. A `ResourceScope` can be used + * to avoid having to deal with optional ownership. If some value would be owned, it can just be + * added to the resource scope, otherwise not. + * + * When a function takes a `ResourceScope` as parameter, it usually means that its return value + * will live at least as long as the passed in resources scope. However, it might also live longer. + * That can happen when the function returns a reference to statically allocated data or + * dynamically allocated data depending on some condition. + */ + +#include "BLI_linear_allocator.hh" +#include "BLI_utility_mixins.hh" +#include "BLI_vector.hh" + +namespace blender { + +class ResourceScope : NonCopyable, NonMovable { + private: + struct ResourceData { + void *data; + void (*free)(void *data); + const char *debug_name; + }; + + LinearAllocator<> m_allocator; + Vector m_resources; + + public: + ResourceScope() = default; + + ~ResourceScope() + { + /* Free in reversed order. */ + for (int64_t i = m_resources.size(); i--;) { + ResourceData &data = m_resources[i]; + data.free(data.data); + } + } + + /** + * Pass ownership of the resource to the ResourceScope. It will be destructed and freed when + * the collector is destructed. + */ + template void add(std::unique_ptr resource, const char *name) + { + BLI_assert(resource.get() != nullptr); + this->add( + resource.release(), + [](void *data) { + T *typed_data = reinterpret_cast(data); + delete typed_data; + }, + name); + } + + /** + * Pass ownership of the resource to the ResourceScope. It will be destructed when the + * collector is destructed. + */ + template void add(destruct_ptr resource, const char *name) + { + /* There is no need to keep track of such types. */ + if (std::is_trivially_destructible_v) { + resource.release(); + return; + } + + BLI_assert(resource.get() != nullptr); + this->add( + resource.release(), + [](void *data) { + T *typed_data = reinterpret_cast(data); + typed_data->~T(); + }, + name); + } + + /** + * Pass ownership of some resource to the ResourceScope. The given free function will be + * called when the collector is destructed. + */ + void add(void *userdata, void (*free)(void *), const char *name) + { + ResourceData data; + data.debug_name = name; + data.data = userdata; + data.free = free; + m_resources.append(data); + } + + /** + * Construct an object with the same value in the ResourceScope and return a reference to the + * new value. + */ + template T &add_value(T &&value, const char *name) + { + return this->construct(name, std::forward(value)); + } + + /** + * Returns a reference to a linear allocator that is owned by the ResourcesCollector. Memory + * allocated through this allocator will be freed when the collector is destructed. + */ + LinearAllocator<> &linear_allocator() + { + return m_allocator; + } + + /** + * Utility method to construct an instance of type T that will be owned by the ResourceScope. + */ + template T &construct(const char *name, Args &&... args) + { + destruct_ptr value_ptr = m_allocator.construct(std::forward(args)...); + T &value_ref = *value_ptr; + this->add(std::move(value_ptr), name); + return value_ref; + } + + /** + * Print the names of all the resources that are owned by this ResourceScope. This can be + * useful for debugging. + */ + void print(StringRef name) const + { + if (m_resources.size() == 0) { + std::cout << "\"" << name << "\" has no resources.\n"; + return; + } + else { + std::cout << "Resources for \"" << name << "\":\n"; + for (const ResourceData &data : m_resources) { + std::cout << " " << data.data << ": " << data.debug_name << '\n'; + } + } + } +}; + +} // namespace blender diff --git a/source/blender/blenlib/CMakeLists.txt b/source/blender/blenlib/CMakeLists.txt index d7a27cc4531..e66049c9bd6 100644 --- a/source/blender/blenlib/CMakeLists.txt +++ b/source/blender/blenlib/CMakeLists.txt @@ -258,7 +258,7 @@ set(SRC BLI_rand.h BLI_rand.hh BLI_rect.h - BLI_resource_collector.hh + BLI_resource_scope.hh BLI_scanfill.h BLI_session_uuid.h BLI_set.hh diff --git a/source/blender/editors/space_spreadsheet/space_spreadsheet.cc b/source/blender/editors/space_spreadsheet/space_spreadsheet.cc index 0f7709b464e..403e6cd6206 100644 --- a/source/blender/editors/space_spreadsheet/space_spreadsheet.cc +++ b/source/blender/editors/space_spreadsheet/space_spreadsheet.cc @@ -17,7 +17,7 @@ #include #include "BLI_listbase.h" -#include "BLI_resource_collector.hh" +#include "BLI_resource_scope.hh" #include "BKE_screen.h" @@ -138,7 +138,7 @@ class FallbackSpreadsheetDrawer : public SpreadsheetDrawer { static void gather_spreadsheet_columns(const bContext *C, SpreadsheetColumnLayout &column_layout, - blender::ResourceCollector &resources) + blender::ResourceScope &scope) { Depsgraph *depsgraph = CTX_data_depsgraph_pointer(C); ID *used_id = get_used_id(C); @@ -158,16 +158,16 @@ static void gather_spreadsheet_columns(const bContext *C, return; } - return spreadsheet_columns_from_geometry(C, object_eval, column_layout, resources); + return spreadsheet_columns_from_geometry(C, object_eval, column_layout, scope); } static void spreadsheet_main_region_draw(const bContext *C, ARegion *region) { SpaceSpreadsheet *sspreadsheet = CTX_wm_space_spreadsheet(C); - blender::ResourceCollector resources; + blender::ResourceScope scope; SpreadsheetColumnLayout column_layout; - gather_spreadsheet_columns(C, column_layout, resources); + gather_spreadsheet_columns(C, column_layout, scope); sspreadsheet->runtime->visible_rows = column_layout.row_indices.size(); sspreadsheet->runtime->tot_columns = column_layout.columns.size(); diff --git a/source/blender/editors/space_spreadsheet/spreadsheet_from_geometry.cc b/source/blender/editors/space_spreadsheet/spreadsheet_from_geometry.cc index 910bc0a34ec..7eea6c48676 100644 --- a/source/blender/editors/space_spreadsheet/spreadsheet_from_geometry.cc +++ b/source/blender/editors/space_spreadsheet/spreadsheet_from_geometry.cc @@ -41,13 +41,13 @@ using blender::bke::ReadAttributePtr; static void add_columns_for_instances(const InstancesComponent &instances_component, SpreadsheetColumnLayout &column_layout, - ResourceCollector &resources) + ResourceScope &scope) { Span instance_data = instances_component.instanced_data(); Span transforms = instances_component.transforms(); Vector> &columns = - resources.construct>>("columns"); + scope.construct>>("columns"); columns.append(spreadsheet_column_from_function( "Name", [instance_data](int index, CellValue &r_cell_value) { @@ -330,13 +330,13 @@ static Span filter_mesh_elements_by_selection(const bContext *C, Object *object_eval, const MeshComponent *component, const AttributeDomain domain, - ResourceCollector &resources) + ResourceScope &scope) { SpaceSpreadsheet *sspreadsheet = CTX_wm_space_spreadsheet(C); const bool show_only_selected = sspreadsheet->filter_flag & SPREADSHEET_FILTER_SELECTED_ONLY; if (object_eval->mode == OB_MODE_EDIT && show_only_selected) { Object *object_orig = DEG_get_original_object(object_eval); - Vector &visible_rows = resources.construct>("visible rows"); + Vector &visible_rows = scope.construct>("visible rows"); const Mesh *mesh_eval = component->get_for_read(); Mesh *mesh_orig = (Mesh *)object_orig->data; BMesh *bm = mesh_orig->edit_mesh->bm; @@ -389,14 +389,14 @@ static GeometryComponentType get_display_component_type(const bContext *C, Objec void spreadsheet_columns_from_geometry(const bContext *C, Object *object_eval, SpreadsheetColumnLayout &column_layout, - ResourceCollector &resources) + ResourceScope &scope) { SpaceSpreadsheet *sspreadsheet = CTX_wm_space_spreadsheet(C); const AttributeDomain domain = (AttributeDomain)sspreadsheet->attribute_domain; const GeometryComponentType component_type = get_display_component_type(C, object_eval); /* Create a resource collector that owns stuff that needs to live until drawing is done. */ - GeometrySet &geometry_set = resources.add_value( + GeometrySet &geometry_set = scope.add_value( get_display_geometry_set(sspreadsheet, object_eval, component_type), "geometry set"); const GeometryComponent *component = geometry_set.get_component_for_read(component_type); @@ -405,7 +405,7 @@ void spreadsheet_columns_from_geometry(const bContext *C, } if (component_type == GEO_COMPONENT_TYPE_INSTANCES) { add_columns_for_instances( - *static_cast(component), column_layout, resources); + *static_cast(component), column_layout, scope); return; } @@ -416,12 +416,12 @@ void spreadsheet_columns_from_geometry(const bContext *C, Vector attribute_names = get_sorted_attribute_names_to_display(*component, domain); Vector> &columns = - resources.construct>>("columns"); + scope.construct>>("columns"); for (StringRefNull attribute_name : attribute_names) { ReadAttributePtr attribute_ptr = component->attribute_try_get_for_read(attribute_name); ReadAttribute &attribute = *attribute_ptr; - resources.add(std::move(attribute_ptr), "attribute"); + scope.add(std::move(attribute_ptr), "attribute"); add_columns_for_attribute(&attribute, attribute_name, columns); } @@ -433,7 +433,7 @@ void spreadsheet_columns_from_geometry(const bContext *C, Span visible_rows; if (component_type == GEO_COMPONENT_TYPE_MESH) { visible_rows = filter_mesh_elements_by_selection( - C, object_eval, static_cast(component), domain, resources); + C, object_eval, static_cast(component), domain, scope); } else { visible_rows = IndexRange(component->attribute_domain_size(domain)).as_span(); diff --git a/source/blender/editors/space_spreadsheet/spreadsheet_from_geometry.hh b/source/blender/editors/space_spreadsheet/spreadsheet_from_geometry.hh index cef731517b9..ff45b8517d1 100644 --- a/source/blender/editors/space_spreadsheet/spreadsheet_from_geometry.hh +++ b/source/blender/editors/space_spreadsheet/spreadsheet_from_geometry.hh @@ -18,7 +18,7 @@ #include "BKE_geometry_set.hh" -#include "BLI_resource_collector.hh" +#include "BLI_resource_scope.hh" #include "spreadsheet_column_layout.hh" @@ -29,6 +29,6 @@ namespace blender::ed::spreadsheet { void spreadsheet_columns_from_geometry(const bContext *C, Object *object_eval, SpreadsheetColumnLayout &column_layout, - ResourceCollector &resources); + ResourceScope &scope); } // namespace blender::ed::spreadsheet diff --git a/source/blender/functions/FN_multi_function_network_optimization.hh b/source/blender/functions/FN_multi_function_network_optimization.hh index 6d0165643ce..96664fa368e 100644 --- a/source/blender/functions/FN_multi_function_network_optimization.hh +++ b/source/blender/functions/FN_multi_function_network_optimization.hh @@ -18,12 +18,12 @@ #include "FN_multi_function_network.hh" -#include "BLI_resource_collector.hh" +#include "BLI_resource_scope.hh" namespace blender::fn::mf_network_optimization { void dead_node_removal(MFNetwork &network); -void constant_folding(MFNetwork &network, ResourceCollector &resources); +void constant_folding(MFNetwork &network, ResourceScope &scope); void common_subnetwork_elimination(MFNetwork &network); } // namespace blender::fn::mf_network_optimization diff --git a/source/blender/functions/FN_multi_function_params.hh b/source/blender/functions/FN_multi_function_params.hh index 2d3a8dd650e..72ebc0d9b94 100644 --- a/source/blender/functions/FN_multi_function_params.hh +++ b/source/blender/functions/FN_multi_function_params.hh @@ -25,7 +25,7 @@ * the function. `MFParams` is then used inside the called function to access the parameters. */ -#include "BLI_resource_collector.hh" +#include "BLI_resource_scope.hh" #include "FN_generic_vector_array.hh" #include "FN_generic_virtual_vector_array.hh" @@ -35,7 +35,7 @@ namespace blender::fn { class MFParamsBuilder { private: - ResourceCollector resources_; + ResourceScope scope_; const MFSignature *signature_; int64_t min_array_size_; Vector virtual_arrays_; @@ -55,13 +55,13 @@ class MFParamsBuilder { template void add_readonly_single_input(const T *value, StringRef expected_name = "") { - this->add_readonly_single_input(resources_.construct( + this->add_readonly_single_input(scope_.construct( __func__, CPPType::get(), min_array_size_, value), expected_name); } void add_readonly_single_input(const GSpan span, StringRef expected_name = "") { - this->add_readonly_single_input(resources_.construct(__func__, span), + this->add_readonly_single_input(scope_.construct(__func__, span), expected_name); } void add_readonly_single_input(const GVArray &ref, StringRef expected_name = "") @@ -74,7 +74,7 @@ class MFParamsBuilder { void add_readonly_vector_input(const GVectorArray &vector_array, StringRef expected_name = "") { this->add_readonly_vector_input( - resources_.construct(__func__, vector_array), expected_name); + scope_.construct(__func__, vector_array), expected_name); } void add_readonly_vector_input(const GVVectorArray &ref, StringRef expected_name = "") { @@ -136,9 +136,9 @@ class MFParamsBuilder { return *vector_arrays_[data_index]; } - ResourceCollector &resources() + ResourceScope &resource_scope() { - return resources_; + return scope_; } private: @@ -177,7 +177,7 @@ class MFParams { template const VArray &readonly_single_input(int param_index, StringRef name = "") { const GVArray &array = this->readonly_single_input(param_index, name); - return builder_->resources_.construct>(__func__, array); + return builder_->scope_.construct>(__func__, array); } const GVArray &readonly_single_input(int param_index, StringRef name = "") { @@ -202,7 +202,7 @@ class MFParams { const VVectorArray &readonly_vector_input(int param_index, StringRef name = "") { const GVVectorArray &vector_array = this->readonly_vector_input(param_index, name); - return builder_->resources_.construct>(__func__, vector_array); + return builder_->scope_.construct>(__func__, vector_array); } const GVVectorArray &readonly_vector_input(int param_index, StringRef name = "") { diff --git a/source/blender/functions/intern/multi_function_network_evaluation.cc b/source/blender/functions/intern/multi_function_network_evaluation.cc index daa0a42963a..86ac4f6a179 100644 --- a/source/blender/functions/intern/multi_function_network_evaluation.cc +++ b/source/blender/functions/intern/multi_function_network_evaluation.cc @@ -37,7 +37,7 @@ #include "FN_multi_function_network_evaluation.hh" -#include "BLI_resource_collector.hh" +#include "BLI_resource_scope.hh" #include "BLI_stack.hh" namespace blender::fn { @@ -70,13 +70,10 @@ class MFNetworkEvaluationStorage { void add_vector_output_from_caller(const MFOutputSocket &socket, GVectorArray &vector_array); /* Get input buffers for function node evaluations. */ - const GVArray &get_single_input__full(const MFInputSocket &socket, ResourceCollector &resources); - const GVArray &get_single_input__single(const MFInputSocket &socket, - ResourceCollector &resources); - const GVVectorArray &get_vector_input__full(const MFInputSocket &socket, - ResourceCollector &resources); - const GVVectorArray &get_vector_input__single(const MFInputSocket &socket, - ResourceCollector &resources); + const GVArray &get_single_input__full(const MFInputSocket &socket, ResourceScope &scope); + const GVArray &get_single_input__single(const MFInputSocket &socket, ResourceScope &scope); + const GVVectorArray &get_vector_input__full(const MFInputSocket &socket, ResourceScope &scope); + const GVVectorArray &get_vector_input__single(const MFInputSocket &socket, ResourceScope &scope); /* Get output buffers for function node evaluations. */ GMutableSpan get_single_output__full(const MFOutputSocket &socket); @@ -87,16 +84,16 @@ class MFNetworkEvaluationStorage { /* Get mutable buffers for function node evaluations. */ GMutableSpan get_mutable_single__full(const MFInputSocket &input, const MFOutputSocket &output, - ResourceCollector &resources); + ResourceScope &scope); GMutableSpan get_mutable_single__single(const MFInputSocket &input, const MFOutputSocket &output, - ResourceCollector &resources); + ResourceScope &scope); GVectorArray &get_mutable_vector__full(const MFInputSocket &input, const MFOutputSocket &output, - ResourceCollector &resources); + ResourceScope &scope); GVectorArray &get_mutable_vector__single(const MFInputSocket &input, const MFOutputSocket &output, - ResourceCollector &resources); + ResourceScope &scope); /* Mark a node as being done with evaluation. This might free temporary buffers that are no * longer needed. */ @@ -277,20 +274,20 @@ BLI_NOINLINE void MFNetworkEvaluator::evaluate_function(MFContext &global_contex /* The function output would be the same for all elements. Therefore, it is enough to call the * function only on a single element. This can avoid many duplicate computations. */ MFParamsBuilder params{function, 1}; - ResourceCollector &resources = params.resources(); + ResourceScope &scope = params.resource_scope(); for (int param_index : function.param_indices()) { MFParamType param_type = function.param_type(param_index); switch (param_type.category()) { case MFParamType::SingleInput: { const MFInputSocket &socket = function_node.input_for_param(param_index); - const GVArray &values = storage.get_single_input__single(socket, resources); + const GVArray &values = storage.get_single_input__single(socket, scope); params.add_readonly_single_input(values); break; } case MFParamType::VectorInput: { const MFInputSocket &socket = function_node.input_for_param(param_index); - const GVVectorArray &values = storage.get_vector_input__single(socket, resources); + const GVVectorArray &values = storage.get_vector_input__single(socket, scope); params.add_readonly_vector_input(values); break; } @@ -309,14 +306,14 @@ BLI_NOINLINE void MFNetworkEvaluator::evaluate_function(MFContext &global_contex case MFParamType::SingleMutable: { const MFInputSocket &input = function_node.input_for_param(param_index); const MFOutputSocket &output = function_node.output_for_param(param_index); - GMutableSpan values = storage.get_mutable_single__single(input, output, resources); + GMutableSpan values = storage.get_mutable_single__single(input, output, scope); params.add_single_mutable(values); break; } case MFParamType::VectorMutable: { const MFInputSocket &input = function_node.input_for_param(param_index); const MFOutputSocket &output = function_node.output_for_param(param_index); - GVectorArray &values = storage.get_mutable_vector__single(input, output, resources); + GVectorArray &values = storage.get_mutable_vector__single(input, output, scope); params.add_vector_mutable(values); break; } @@ -327,20 +324,20 @@ BLI_NOINLINE void MFNetworkEvaluator::evaluate_function(MFContext &global_contex } else { MFParamsBuilder params{function, storage.mask().min_array_size()}; - ResourceCollector &resources = params.resources(); + ResourceScope &scope = params.resource_scope(); for (int param_index : function.param_indices()) { MFParamType param_type = function.param_type(param_index); switch (param_type.category()) { case MFParamType::SingleInput: { const MFInputSocket &socket = function_node.input_for_param(param_index); - const GVArray &values = storage.get_single_input__full(socket, resources); + const GVArray &values = storage.get_single_input__full(socket, scope); params.add_readonly_single_input(values); break; } case MFParamType::VectorInput: { const MFInputSocket &socket = function_node.input_for_param(param_index); - const GVVectorArray &values = storage.get_vector_input__full(socket, resources); + const GVVectorArray &values = storage.get_vector_input__full(socket, scope); params.add_readonly_vector_input(values); break; } @@ -359,14 +356,14 @@ BLI_NOINLINE void MFNetworkEvaluator::evaluate_function(MFContext &global_contex case MFParamType::SingleMutable: { const MFInputSocket &input = function_node.input_for_param(param_index); const MFOutputSocket &output = function_node.output_for_param(param_index); - GMutableSpan values = storage.get_mutable_single__full(input, output, resources); + GMutableSpan values = storage.get_mutable_single__full(input, output, scope); params.add_single_mutable(values); break; } case MFParamType::VectorMutable: { const MFInputSocket &input = function_node.input_for_param(param_index); const MFOutputSocket &output = function_node.output_for_param(param_index); - GVectorArray &values = storage.get_mutable_vector__full(input, output, resources); + GVectorArray &values = storage.get_mutable_vector__full(input, output, scope); params.add_vector_mutable(values); break; } @@ -400,19 +397,19 @@ bool MFNetworkEvaluator::can_do_single_value_evaluation(const MFFunctionNode &fu BLI_NOINLINE void MFNetworkEvaluator::initialize_remaining_outputs( MFParams params, Storage &storage, Span remaining_outputs) const { - ResourceCollector resources; + ResourceScope scope; for (const MFInputSocket *socket : remaining_outputs) { int param_index = inputs_.size() + outputs_.first_index_of(socket); switch (socket->data_type().category()) { case MFDataType::Single: { - const GVArray &values = storage.get_single_input__full(*socket, resources); + const GVArray &values = storage.get_single_input__full(*socket, scope); GMutableSpan output_values = params.uninitialized_single_output(param_index); values.materialize_to_uninitialized(storage.mask(), output_values.data()); break; } case MFDataType::Vector: { - const GVVectorArray &values = storage.get_vector_input__full(*socket, resources); + const GVVectorArray &values = storage.get_vector_input__full(*socket, scope); GVectorArray &output_values = params.vector_output(param_index); output_values.extend(storage.mask(), values); break; @@ -796,7 +793,7 @@ GVectorArray &MFNetworkEvaluationStorage::get_vector_output__single(const MFOutp GMutableSpan MFNetworkEvaluationStorage::get_mutable_single__full(const MFInputSocket &input, const MFOutputSocket &output, - ResourceCollector &resources) + ResourceScope &scope) { const MFOutputSocket &from = *input.origin(); const MFOutputSocket &to = output; @@ -810,7 +807,7 @@ GMutableSpan MFNetworkEvaluationStorage::get_mutable_single__full(const MFInputS if (to_any_value != nullptr) { BLI_assert(to_any_value->type == ValueType::OutputSingle); GMutableSpan span = static_cast(to_any_value)->span; - const GVArray &virtual_array = this->get_single_input__full(input, resources); + const GVArray &virtual_array = this->get_single_input__full(input, scope); virtual_array.materialize_to_uninitialized(mask_, span.data()); return span; } @@ -825,7 +822,7 @@ GMutableSpan MFNetworkEvaluationStorage::get_mutable_single__full(const MFInputS } } - const GVArray &virtual_array = this->get_single_input__full(input, resources); + const GVArray &virtual_array = this->get_single_input__full(input, scope); void *new_buffer = MEM_mallocN_aligned(min_array_size_ * type.size(), type.alignment(), AT); GMutableSpan new_array_ref(type, new_buffer, min_array_size_); virtual_array.materialize_to_uninitialized(mask_, new_array_ref.data()); @@ -838,7 +835,7 @@ GMutableSpan MFNetworkEvaluationStorage::get_mutable_single__full(const MFInputS GMutableSpan MFNetworkEvaluationStorage::get_mutable_single__single(const MFInputSocket &input, const MFOutputSocket &output, - ResourceCollector &resources) + ResourceScope &scope) { const MFOutputSocket &from = *input.origin(); const MFOutputSocket &to = output; @@ -853,7 +850,7 @@ GMutableSpan MFNetworkEvaluationStorage::get_mutable_single__single(const MFInpu BLI_assert(to_any_value->type == ValueType::OutputSingle); GMutableSpan span = static_cast(to_any_value)->span; BLI_assert(span.size() == 1); - const GVArray &virtual_array = this->get_single_input__single(input, resources); + const GVArray &virtual_array = this->get_single_input__single(input, scope); virtual_array.get_single_to_uninitialized(span[0]); return span; } @@ -869,7 +866,7 @@ GMutableSpan MFNetworkEvaluationStorage::get_mutable_single__single(const MFInpu } } - const GVArray &virtual_array = this->get_single_input__single(input, resources); + const GVArray &virtual_array = this->get_single_input__single(input, scope); void *new_buffer = allocator_.allocate(type.size(), type.alignment()); virtual_array.get_single_to_uninitialized(new_buffer); @@ -883,7 +880,7 @@ GMutableSpan MFNetworkEvaluationStorage::get_mutable_single__single(const MFInpu GVectorArray &MFNetworkEvaluationStorage::get_mutable_vector__full(const MFInputSocket &input, const MFOutputSocket &output, - ResourceCollector &resources) + ResourceScope &scope) { const MFOutputSocket &from = *input.origin(); const MFOutputSocket &to = output; @@ -897,7 +894,7 @@ GVectorArray &MFNetworkEvaluationStorage::get_mutable_vector__full(const MFInput if (to_any_value != nullptr) { BLI_assert(to_any_value->type == ValueType::OutputVector); GVectorArray &vector_array = *static_cast(to_any_value)->vector_array; - const GVVectorArray &virtual_vector_array = this->get_vector_input__full(input, resources); + const GVVectorArray &virtual_vector_array = this->get_vector_input__full(input, scope); vector_array.extend(mask_, virtual_vector_array); return vector_array; } @@ -912,7 +909,7 @@ GVectorArray &MFNetworkEvaluationStorage::get_mutable_vector__full(const MFInput } } - const GVVectorArray &virtual_vector_array = this->get_vector_input__full(input, resources); + const GVVectorArray &virtual_vector_array = this->get_vector_input__full(input, scope); GVectorArray *new_vector_array = new GVectorArray(base_type, min_array_size_); new_vector_array->extend(mask_, virtual_vector_array); @@ -926,7 +923,7 @@ GVectorArray &MFNetworkEvaluationStorage::get_mutable_vector__full(const MFInput GVectorArray &MFNetworkEvaluationStorage::get_mutable_vector__single(const MFInputSocket &input, const MFOutputSocket &output, - ResourceCollector &resources) + ResourceScope &scope) { const MFOutputSocket &from = *input.origin(); const MFOutputSocket &to = output; @@ -941,7 +938,7 @@ GVectorArray &MFNetworkEvaluationStorage::get_mutable_vector__single(const MFInp BLI_assert(to_any_value->type == ValueType::OutputVector); GVectorArray &vector_array = *static_cast(to_any_value)->vector_array; BLI_assert(vector_array.size() == 1); - const GVVectorArray &virtual_vector_array = this->get_vector_input__single(input, resources); + const GVVectorArray &virtual_vector_array = this->get_vector_input__single(input, scope); vector_array.extend({0}, virtual_vector_array); return vector_array; } @@ -956,7 +953,7 @@ GVectorArray &MFNetworkEvaluationStorage::get_mutable_vector__single(const MFInp } } - const GVVectorArray &virtual_vector_array = this->get_vector_input__single(input, resources); + const GVVectorArray &virtual_vector_array = this->get_vector_input__single(input, scope); GVectorArray *new_vector_array = new GVectorArray(base_type, 1); new_vector_array->extend({0}, virtual_vector_array); @@ -968,7 +965,7 @@ GVectorArray &MFNetworkEvaluationStorage::get_mutable_vector__single(const MFInp } const GVArray &MFNetworkEvaluationStorage::get_single_input__full(const MFInputSocket &socket, - ResourceCollector &resources) + ResourceScope &scope) { const MFOutputSocket &origin = *socket.origin(); Value *any_value = value_per_output_id_[origin.id()]; @@ -977,11 +974,11 @@ const GVArray &MFNetworkEvaluationStorage::get_single_input__full(const MFInputS if (any_value->type == ValueType::OwnSingle) { OwnSingleValue *value = static_cast(any_value); if (value->is_single_allocated) { - return resources.construct( + return scope.construct( __func__, value->span.type(), min_array_size_, value->span.data()); } - return resources.construct(__func__, value->span); + return scope.construct(__func__, value->span); } if (any_value->type == ValueType::InputSingle) { InputSingleValue *value = static_cast(any_value); @@ -990,15 +987,15 @@ const GVArray &MFNetworkEvaluationStorage::get_single_input__full(const MFInputS if (any_value->type == ValueType::OutputSingle) { OutputSingleValue *value = static_cast(any_value); BLI_assert(value->is_computed); - return resources.construct(__func__, value->span); + return scope.construct(__func__, value->span); } BLI_assert(false); - return resources.construct(__func__, CPPType::get()); + return scope.construct(__func__, CPPType::get()); } const GVArray &MFNetworkEvaluationStorage::get_single_input__single(const MFInputSocket &socket, - ResourceCollector &resources) + ResourceScope &scope) { const MFOutputSocket &origin = *socket.origin(); Value *any_value = value_per_output_id_[origin.id()]; @@ -1007,7 +1004,7 @@ const GVArray &MFNetworkEvaluationStorage::get_single_input__single(const MFInpu if (any_value->type == ValueType::OwnSingle) { OwnSingleValue *value = static_cast(any_value); BLI_assert(value->span.size() == 1); - return resources.construct(__func__, value->span); + return scope.construct(__func__, value->span); } if (any_value->type == ValueType::InputSingle) { InputSingleValue *value = static_cast(any_value); @@ -1018,15 +1015,15 @@ const GVArray &MFNetworkEvaluationStorage::get_single_input__single(const MFInpu OutputSingleValue *value = static_cast(any_value); BLI_assert(value->is_computed); BLI_assert(value->span.size() == 1); - return resources.construct(__func__, value->span); + return scope.construct(__func__, value->span); } BLI_assert(false); - return resources.construct(__func__, CPPType::get()); + return scope.construct(__func__, CPPType::get()); } const GVVectorArray &MFNetworkEvaluationStorage::get_vector_input__full( - const MFInputSocket &socket, ResourceCollector &resources) + const MFInputSocket &socket, ResourceScope &scope) { const MFOutputSocket &origin = *socket.origin(); Value *any_value = value_per_output_id_[origin.id()]; @@ -1036,10 +1033,10 @@ const GVVectorArray &MFNetworkEvaluationStorage::get_vector_input__full( OwnVectorValue *value = static_cast(any_value); if (value->vector_array->size() == 1) { GSpan span = (*value->vector_array)[0]; - return resources.construct(__func__, span, min_array_size_); + return scope.construct(__func__, span, min_array_size_); } - return resources.construct(__func__, *value->vector_array); + return scope.construct(__func__, *value->vector_array); } if (any_value->type == ValueType::InputVector) { InputVectorValue *value = static_cast(any_value); @@ -1047,16 +1044,15 @@ const GVVectorArray &MFNetworkEvaluationStorage::get_vector_input__full( } if (any_value->type == ValueType::OutputVector) { OutputVectorValue *value = static_cast(any_value); - return resources.construct(__func__, *value->vector_array); + return scope.construct(__func__, *value->vector_array); } BLI_assert(false); - return resources.construct( - __func__, GSpan(CPPType::get()), 0); + return scope.construct(__func__, GSpan(CPPType::get()), 0); } const GVVectorArray &MFNetworkEvaluationStorage::get_vector_input__single( - const MFInputSocket &socket, ResourceCollector &resources) + const MFInputSocket &socket, ResourceScope &scope) { const MFOutputSocket &origin = *socket.origin(); Value *any_value = value_per_output_id_[origin.id()]; @@ -1065,7 +1061,7 @@ const GVVectorArray &MFNetworkEvaluationStorage::get_vector_input__single( if (any_value->type == ValueType::OwnVector) { OwnVectorValue *value = static_cast(any_value); BLI_assert(value->vector_array->size() == 1); - return resources.construct(__func__, *value->vector_array); + return scope.construct(__func__, *value->vector_array); } if (any_value->type == ValueType::InputVector) { InputVectorValue *value = static_cast(any_value); @@ -1075,12 +1071,11 @@ const GVVectorArray &MFNetworkEvaluationStorage::get_vector_input__single( if (any_value->type == ValueType::OutputVector) { OutputVectorValue *value = static_cast(any_value); BLI_assert(value->vector_array->size() == 1); - return resources.construct(__func__, *value->vector_array); + return scope.construct(__func__, *value->vector_array); } BLI_assert(false); - return resources.construct( - __func__, GSpan(CPPType::get()), 0); + return scope.construct(__func__, GSpan(CPPType::get()), 0); } /** \} */ diff --git a/source/blender/functions/intern/multi_function_network_optimization.cc b/source/blender/functions/intern/multi_function_network_optimization.cc index 6c418dee2c1..4b6b3e81393 100644 --- a/source/blender/functions/intern/multi_function_network_optimization.cc +++ b/source/blender/functions/intern/multi_function_network_optimization.cc @@ -219,7 +219,7 @@ static Vector find_constant_inputs_to_fold( static void prepare_params_for_constant_folding(const MultiFunction &network_fn, MFParamsBuilder ¶ms, - ResourceCollector &resources) + ResourceScope &scope) { for (int param_index : network_fn.param_indices()) { MFParamType param_type = network_fn.param_type(param_index); @@ -229,8 +229,7 @@ static void prepare_params_for_constant_folding(const MultiFunction &network_fn, case MFDataType::Single: { /* Allocates memory for a single constant folded value. */ const CPPType &cpp_type = data_type.single_type(); - void *buffer = resources.linear_allocator().allocate(cpp_type.size(), - cpp_type.alignment()); + void *buffer = scope.linear_allocator().allocate(cpp_type.size(), cpp_type.alignment()); GMutableSpan array{cpp_type, buffer, 1}; params.add_uninitialized_single_output(array); break; @@ -238,7 +237,7 @@ static void prepare_params_for_constant_folding(const MultiFunction &network_fn, case MFDataType::Vector: { /* Allocates memory for a constant folded vector. */ const CPPType &cpp_type = data_type.vector_base_type(); - GVectorArray &vector_array = resources.construct(AT, cpp_type, 1); + GVectorArray &vector_array = scope.construct(AT, cpp_type, 1); params.add_vector_output(vector_array); break; } @@ -248,7 +247,7 @@ static void prepare_params_for_constant_folding(const MultiFunction &network_fn, static Array add_constant_folded_sockets(const MultiFunction &network_fn, MFParamsBuilder ¶ms, - ResourceCollector &resources, + ResourceScope &scope, MFNetwork &network) { Array folded_sockets{network_fn.param_indices().size(), nullptr}; @@ -264,15 +263,15 @@ static Array add_constant_folded_sockets(const MultiFunction & const CPPType &cpp_type = data_type.single_type(); GMutableSpan array = params.computed_array(param_index); void *buffer = array.data(); - resources.add(buffer, array.type().destruct_cb(), AT); + scope.add(buffer, array.type().destruct_cb(), AT); - constant_fn = &resources.construct(AT, cpp_type, buffer); + constant_fn = &scope.construct(AT, cpp_type, buffer); break; } case MFDataType::Vector: { GVectorArray &vector_array = params.computed_vector_array(param_index); GSpan array = vector_array[0]; - constant_fn = &resources.construct(AT, array); + constant_fn = &scope.construct(AT, array); break; } } @@ -284,17 +283,15 @@ static Array add_constant_folded_sockets(const MultiFunction & } static Array compute_constant_sockets_and_add_folded_nodes( - MFNetwork &network, - Span sockets_to_compute, - ResourceCollector &resources) + MFNetwork &network, Span sockets_to_compute, ResourceScope &scope) { MFNetworkEvaluator network_fn{{}, sockets_to_compute}; MFContextBuilder context; MFParamsBuilder params{network_fn, 1}; - prepare_params_for_constant_folding(network_fn, params, resources); + prepare_params_for_constant_folding(network_fn, params, scope); network_fn.call({0}, params, context); - return add_constant_folded_sockets(network_fn, params, resources, network); + return add_constant_folded_sockets(network_fn, params, scope, network); } class MyClass { @@ -304,7 +301,7 @@ class MyClass { /** * Find function nodes that always output the same value and replace those with constant nodes. */ -void constant_folding(MFNetwork &network, ResourceCollector &resources) +void constant_folding(MFNetwork &network, ResourceScope &scope) { Vector temporary_nodes; Vector inputs_to_fold = find_constant_inputs_to_fold(network, temporary_nodes); @@ -313,7 +310,7 @@ void constant_folding(MFNetwork &network, ResourceCollector &resources) } Array folded_sockets = compute_constant_sockets_and_add_folded_nodes( - network, inputs_to_fold, resources); + network, inputs_to_fold, scope); for (int i : inputs_to_fold.index_range()) { MFOutputSocket &original_socket = *inputs_to_fold[i]->origin(); diff --git a/source/blender/modifiers/intern/MOD_nodes.cc b/source/blender/modifiers/intern/MOD_nodes.cc index 267c4be5571..843797e0f72 100644 --- a/source/blender/modifiers/intern/MOD_nodes.cc +++ b/source/blender/modifiers/intern/MOD_nodes.cc @@ -1100,9 +1100,9 @@ static GeometrySet compute_geometry(const DerivedNodeTree &tree, NodesModifierData *nmd, const ModifierEvalContext *ctx) { - blender::ResourceCollector resources; - blender::LinearAllocator<> &allocator = resources.linear_allocator(); - blender::nodes::MultiFunctionByNode mf_by_node = get_multi_function_per_node(tree, resources); + blender::ResourceScope scope; + blender::LinearAllocator<> &allocator = scope.linear_allocator(); + blender::nodes::MultiFunctionByNode mf_by_node = get_multi_function_per_node(tree, scope); PersistentDataHandleMap handle_map; fill_data_handle_map(nmd->settings, tree, handle_map); diff --git a/source/blender/nodes/NOD_node_tree_multi_function.hh b/source/blender/nodes/NOD_node_tree_multi_function.hh index df31ee18369..de1f5a0dc70 100644 --- a/source/blender/nodes/NOD_node_tree_multi_function.hh +++ b/source/blender/nodes/NOD_node_tree_multi_function.hh @@ -29,7 +29,7 @@ #include "NOD_type_callbacks.hh" #include "BLI_multi_value_map.hh" -#include "BLI_resource_collector.hh" +#include "BLI_resource_scope.hh" namespace blender::nodes { @@ -190,7 +190,7 @@ class MFNetworkTreeMap { * This data is necessary throughout the generation of a MFNetwork from a node tree. */ struct CommonMFNetworkBuilderData { - ResourceCollector &resources; + ResourceScope &scope; fn::MFNetwork &network; MFNetworkTreeMap &network_map; const DerivedNodeTree &tree; @@ -225,9 +225,9 @@ class MFNetworkBuilderBase { * Returns a resource collector that will only be destructed after the multi-function network is * destructed. */ - ResourceCollector &resources() + ResourceScope &resource_scope() { - return common_.resources; + return common_.scope; } /** @@ -236,9 +236,9 @@ class MFNetworkBuilderBase { template T &construct_fn(Args &&... args) { BLI_STATIC_ASSERT((std::is_base_of_v), ""); - void *buffer = common_.resources.linear_allocator().allocate(sizeof(T), alignof(T)); + void *buffer = common_.scope.linear_allocator().allocate(sizeof(T), alignof(T)); T *fn = new (buffer) T(std::forward(args)...); - common_.resources.add(destruct_ptr(fn), fn->name().c_str()); + common_.scope.add(destruct_ptr(fn), fn->name().c_str()); return *fn; } }; @@ -382,11 +382,10 @@ class NodeMFNetworkBuilder : public MFNetworkBuilderBase { MFNetworkTreeMap insert_node_tree_into_mf_network(fn::MFNetwork &network, const DerivedNodeTree &tree, - ResourceCollector &resources); + ResourceScope &scope); using MultiFunctionByNode = Map; -MultiFunctionByNode get_multi_function_per_node(const DerivedNodeTree &tree, - ResourceCollector &resources); +MultiFunctionByNode get_multi_function_per_node(const DerivedNodeTree &tree, ResourceScope &scope); class DataTypeConversions { private: diff --git a/source/blender/nodes/intern/node_tree_multi_function.cc b/source/blender/nodes/intern/node_tree_multi_function.cc index c77a6b42f97..1fb86661dff 100644 --- a/source/blender/nodes/intern/node_tree_multi_function.cc +++ b/source/blender/nodes/intern/node_tree_multi_function.cc @@ -250,11 +250,11 @@ static fn::MFOutputSocket &insert_default_value_for_type(CommonMFNetworkBuilderD { const fn::MultiFunction *default_fn; if (type.is_single()) { - default_fn = &common.resources.construct( + default_fn = &common.scope.construct( AT, type.single_type(), type.single_type().default_value()); } else { - default_fn = &common.resources.construct( + default_fn = &common.scope.construct( AT, fn::GSpan(type.vector_base_type())); } @@ -349,11 +349,11 @@ static void insert_links_and_unlinked_inputs(CommonMFNetworkBuilderData &common) */ MFNetworkTreeMap insert_node_tree_into_mf_network(fn::MFNetwork &network, const DerivedNodeTree &tree, - ResourceCollector &resources) + ResourceScope &scope) { MFNetworkTreeMap network_map{tree, network}; - CommonMFNetworkBuilderData common{resources, network, network_map, tree}; + CommonMFNetworkBuilderData common{scope, network, network_map, tree}; insert_nodes(common); insert_links_and_unlinked_inputs(common); @@ -427,7 +427,7 @@ static const fn::MultiFunction &create_function_for_node_that_expands_into_multi const DNode &dnode, fn::MFNetwork &network, MFNetworkTreeMap &network_map, - ResourceCollector &resources) + ResourceScope &scope) { Vector dummy_fn_inputs; for (const InputSocketRef *dsocket : dnode->inputs()) { @@ -452,7 +452,7 @@ static const fn::MultiFunction &create_function_for_node_that_expands_into_multi } } - fn::MFNetworkEvaluator &fn_evaluator = resources.construct( + fn::MFNetworkEvaluator &fn_evaluator = scope.construct( __func__, std::move(dummy_fn_inputs), std::move(dummy_fn_outputs)); return fn_evaluator; } @@ -461,16 +461,15 @@ static const fn::MultiFunction &create_function_for_node_that_expands_into_multi * Returns a single multi-function for every node that supports it. This makes it easier to reuse * the multi-function implementation of nodes in different contexts. */ -MultiFunctionByNode get_multi_function_per_node(const DerivedNodeTree &tree, - ResourceCollector &resources) +MultiFunctionByNode get_multi_function_per_node(const DerivedNodeTree &tree, ResourceScope &scope) { /* Build a network that nodes can insert themselves into. However, the individual nodes are not * connected. */ - fn::MFNetwork &network = resources.construct(__func__); + fn::MFNetwork &network = scope.construct(__func__); MFNetworkTreeMap network_map{tree, network}; MultiFunctionByNode functions_by_node; - CommonMFNetworkBuilderData common{resources, network, network_map, tree}; + CommonMFNetworkBuilderData common{scope, network, network_map, tree}; tree.foreach_node([&](DNode dnode) { const bNodeType *node_type = dnode->typeinfo(); @@ -499,7 +498,7 @@ MultiFunctionByNode get_multi_function_per_node(const DerivedNodeTree &tree, /* If a node expanded into multiple functions, a new function has to be created that * combines those. */ const fn::MultiFunction &fn = create_function_for_node_that_expands_into_multiple( - dnode, network, network_map, resources); + dnode, network, network_map, scope); functions_by_node.add_new(dnode, &fn); break; } diff --git a/source/blender/nodes/intern/type_callbacks.cc b/source/blender/nodes/intern/type_callbacks.cc index 26eeaebc6d4..5160432aea5 100644 --- a/source/blender/nodes/intern/type_callbacks.cc +++ b/source/blender/nodes/intern/type_callbacks.cc @@ -64,7 +64,8 @@ void socket_expand_in_mf_network(SocketMFNetworkBuilder &builder) } else if (socket.typeinfo->get_cpp_value != nullptr) { const CPPType &type = *socket_cpp_type_get(*socket.typeinfo); - void *buffer = builder.resources().linear_allocator().allocate(type.size(), type.alignment()); + void *buffer = builder.resource_scope().linear_allocator().allocate(type.size(), + type.alignment()); socket.typeinfo->get_cpp_value(socket, buffer); builder.set_constant_value(type, buffer); } -- cgit v1.2.3