From 0dce68333f18ce346091dc672bc51e789438c30e Mon Sep 17 00:00:00 2001 From: Harley Acheson Date: Wed, 19 Feb 2025 00:19:08 +0100 Subject: [PATCH 01/31] UI: Vertically Aligned Grip Icon Add a variation of the current Grip icon that is vertically-aligned. the current ICON_GRIP works great when it has lots of horizontal space, but ICON_GRIP_V might be needed for horizontally constrained uses. Pull Request: https://projects.blender.org/blender/blender/pulls/134777 --- release/datafiles/icons_svg/grip_v.svg | 1 + source/blender/editors/datafiles/CMakeLists.txt | 1 + source/blender/editors/include/UI_icons.hh | 1 + 3 files changed, 3 insertions(+) create mode 100644 release/datafiles/icons_svg/grip_v.svg diff --git a/release/datafiles/icons_svg/grip_v.svg b/release/datafiles/icons_svg/grip_v.svg new file mode 100644 index 00000000000..a858e0891e7 --- /dev/null +++ b/release/datafiles/icons_svg/grip_v.svg @@ -0,0 +1 @@ + \ No newline at end of file diff --git a/source/blender/editors/datafiles/CMakeLists.txt b/source/blender/editors/datafiles/CMakeLists.txt index 5d7a42a7e40..1ed25dcd347 100644 --- a/source/blender/editors/datafiles/CMakeLists.txt +++ b/source/blender/editors/datafiles/CMakeLists.txt @@ -401,6 +401,7 @@ if(WITH_BLENDER) greasepencil_layer_group grid grip + grip_v group group_bone group_uvs diff --git a/source/blender/editors/include/UI_icons.hh b/source/blender/editors/include/UI_icons.hh index 62a98646d03..adce49950d1 100644 --- a/source/blender/editors/include/UI_icons.hh +++ b/source/blender/editors/include/UI_icons.hh @@ -122,6 +122,7 @@ DEF_ICON(FULLSCREEN_EXIT) DEF_ICON(GHOST_DISABLED) DEF_ICON(GHOST_ENABLED) DEF_ICON(GRIP) +DEF_ICON(GRIP_V) DEF_ICON(HAND) DEF_ICON(HELP) DEF_ICON(LINKED) From 9e0c8a41cd6a95ccb55e09035dd41f5cbeaa5c02 Mon Sep 17 00:00:00 2001 From: Campbell Barton Date: Wed, 19 Feb 2025 11:06:31 +1100 Subject: [PATCH 02/31] Object Mode: conversion no longer depends on the active object Conversion was only possible if the active object was editable & selected, this complicated overriding the operator from Python since it wasn't enough to override the selection & active-object. Now it's possible to use bpy.ops.object.convert() from Python overriding the selected_editable_objects only. For users the difference isn't so significant: - Having an active object is no longer required. - It's possible there are no objects to operate on, as previously the active object was used to check at least one object could be converted, although this check wasn't fool-proof as it didn't check the objects data-type. Resolves #100664. Ref !134728. --- scripts/startup/bl_ui/space_view3d.py | 9 ++-- source/blender/editors/object/object_add.cc | 53 +++++++++++++-------- 2 files changed, 40 insertions(+), 22 deletions(-) diff --git a/scripts/startup/bl_ui/space_view3d.py b/scripts/startup/bl_ui/space_view3d.py index bbda275b645..6b51d0846b8 100644 --- a/scripts/startup/bl_ui/space_view3d.py +++ b/scripts/startup/bl_ui/space_view3d.py @@ -3383,16 +3383,19 @@ def draw(self, context): layout = self.layout ob = context.active_object - if ob and ob.type != 'EMPTY': - layout.operator_enum("object.convert", "target") + layout.operator_enum("object.convert", "target") - else: + if ob and ob.type == 'EMPTY': # Potrace lib dependency. if bpy.app.build_options.potrace: + layout.separator() + layout.operator("image.convert_to_mesh_plane", text="Convert to Mesh Plane", icon='MESH_PLANE') layout.operator("grease_pencil.trace_image", icon='OUTLINER_OB_GREASEPENCIL') if ob and ob.type == 'CURVES': + layout.separator() + layout.operator("curves.convert_to_particle_system", text="Particle System") layout.template_node_operator_asset_menu_items(catalog_path="Object/Convert") diff --git a/source/blender/editors/object/object_add.cc b/source/blender/editors/object/object_add.cc index 4f6c94b7acb..9f603a08525 100644 --- a/source/blender/editors/object/object_add.cc +++ b/source/blender/editors/object/object_add.cc @@ -2802,17 +2802,21 @@ static void object_data_convert_curve_to_mesh(Main *bmain, Depsgraph *depsgraph, static bool object_convert_poll(bContext *C) { Scene *scene = CTX_data_scene(C); - Base *base_act = CTX_data_active_base(C); - Object *obact = base_act ? base_act->object : nullptr; - - if (obact == nullptr || obact->data == nullptr || !ID_IS_EDITABLE(obact) || - ID_IS_OVERRIDE_LIBRARY(obact) || ID_IS_OVERRIDE_LIBRARY(obact->data)) - { + if (!ID_IS_EDITABLE(scene)) { + return false; + } + ViewLayer *view_layer = CTX_data_view_layer(C); + BKE_view_layer_synced_ensure(scene, view_layer); + /* Don't use `active_object` in the context, it's important this value + * is from the view-layer as it's used to check if Blender is in edit-mode. */ + Object *obact = BKE_view_layer_active_object_get(view_layer); + if (obact && BKE_object_is_in_editmode(obact)) { return false; } - return (ID_IS_EDITABLE(scene) && (BKE_object_is_in_editmode(obact) == false) && - (base_act->flag & BASE_SELECTED)); + /* Note that `obact` may not be editable, + * only check the active object to ensure Blender is not in edit-mode. */ + return true; } /* Helper for object_convert_exec */ @@ -2872,6 +2876,10 @@ struct ObjectConversionInfo { Depsgraph *depsgraph; Scene *scene; ViewLayer *view_layer; + /** + * Note that this is not used for conversion operation, + * only to ensure the active-object doesn't change from a user perspective. + */ Object *obact; bool keep_original; bool do_merge_customdata; @@ -3843,7 +3851,7 @@ static Object *convert_mball_to_mesh(Base &base, newob->data = mesh; newob->type = OB_MESH; - if (info.obact->type == OB_MBALL) { + if (info.obact && (info.obact->type == OB_MBALL)) { *r_act_base = *r_new_base; } @@ -3906,11 +3914,20 @@ static int object_convert_exec(bContext *C, wmOperator *op) Depsgraph *depsgraph = CTX_data_ensure_evaluated_depsgraph(C); Scene *scene = CTX_data_scene(C); ViewLayer *view_layer = CTX_data_view_layer(C); - Object *obact = CTX_data_active_object(C); + const short target = RNA_enum_get(op->ptr, "target"); bool keep_original = RNA_boolean_get(op->ptr, "keep_original"); const bool do_merge_customdata = RNA_boolean_get(op->ptr, "merge_customdata"); + Vector selected_editable_bases; + CTX_data_selected_editable_bases(C, &selected_editable_bases); + + /* Too expensive to detect on poll(). */ + if (selected_editable_bases.is_empty()) { + BKE_report(op->reports, RPT_INFO, "No editable objects to convert"); + return OPERATOR_CANCELLED; + } + /* don't forget multiple users! */ { @@ -3936,15 +3953,12 @@ static int object_convert_exec(bContext *C, wmOperator *op) FOREACH_SCENE_OBJECT_END; } - Vector selected_editable_bases; - CTX_data_selected_editable_bases(C, &selected_editable_bases); - ObjectConversionInfo info; info.bmain = bmain; info.depsgraph = depsgraph; info.scene = scene; info.view_layer = view_layer; - info.obact = obact; + info.obact = BKE_view_layer_active_object_get(view_layer); info.keep_original = keep_original; info.do_merge_customdata = do_merge_customdata; info.op_props = op->ptr; @@ -4048,7 +4062,7 @@ static int object_convert_exec(bContext *C, wmOperator *op) /* If the original object is active then make this object active */ if (new_base) { - if (ob == obact) { + if (info.obact && (info.obact == ob)) { /* Store new active base to update view layer. */ act_base = new_base; } @@ -4104,10 +4118,11 @@ static int object_convert_exec(bContext *C, wmOperator *op) } else { BKE_view_layer_synced_ensure(scene, view_layer); - Object *object = BKE_view_layer_active_object_get(view_layer); - if (object->flag & OB_DONE) { - WM_event_add_notifier(C, NC_OBJECT | ND_MODIFIER, object); - WM_event_add_notifier(C, NC_OBJECT | ND_DATA, object); + if (Object *object = BKE_view_layer_active_object_get(view_layer)) { + if (object->flag & OB_DONE) { + WM_event_add_notifier(C, NC_OBJECT | ND_MODIFIER, object); + WM_event_add_notifier(C, NC_OBJECT | ND_DATA, object); + } } } From e850a097625d2e527fa4caf1dbf21a9cf44cc543 Mon Sep 17 00:00:00 2001 From: Harley Acheson Date: Wed, 19 Feb 2025 01:11:24 +0100 Subject: [PATCH 03/31] UI: Add Icons to Represent Error Conditions This PR adds three SVG Icons. One to represent that an icon is not found - ICON_NOT_FOUND - so represent when an out-of-range value was used to specify an icon. The second - ICON_CHAR_NOTDEF - is to represent that a text character is not found in the specified font or font stack. The third - ICON_CHAR_REPLACEMENT - is to indicate the portion of a text string that contains invalid bytes. Pull Request: https://projects.blender.org/blender/blender/pulls/134008 --- release/datafiles/icons_svg/char_notdef.svg | 1 + release/datafiles/icons_svg/char_replacement.svg | 1 + release/datafiles/icons_svg/not_found.svg | 1 + source/blender/editors/datafiles/CMakeLists.txt | 3 +++ source/blender/editors/include/UI_icons.hh | 5 +++++ 5 files changed, 11 insertions(+) create mode 100644 release/datafiles/icons_svg/char_notdef.svg create mode 100644 release/datafiles/icons_svg/char_replacement.svg create mode 100644 release/datafiles/icons_svg/not_found.svg diff --git a/release/datafiles/icons_svg/char_notdef.svg b/release/datafiles/icons_svg/char_notdef.svg new file mode 100644 index 00000000000..341d7dd44bc --- /dev/null +++ b/release/datafiles/icons_svg/char_notdef.svg @@ -0,0 +1 @@ + \ No newline at end of file diff --git a/release/datafiles/icons_svg/char_replacement.svg b/release/datafiles/icons_svg/char_replacement.svg new file mode 100644 index 00000000000..f051ba2357b --- /dev/null +++ b/release/datafiles/icons_svg/char_replacement.svg @@ -0,0 +1 @@ + \ No newline at end of file diff --git a/release/datafiles/icons_svg/not_found.svg b/release/datafiles/icons_svg/not_found.svg new file mode 100644 index 00000000000..1b8290c586b --- /dev/null +++ b/release/datafiles/icons_svg/not_found.svg @@ -0,0 +1 @@ + \ No newline at end of file diff --git a/source/blender/editors/datafiles/CMakeLists.txt b/source/blender/editors/datafiles/CMakeLists.txt index 1ed25dcd347..1095c6d0c2b 100644 --- a/source/blender/editors/datafiles/CMakeLists.txt +++ b/source/blender/editors/datafiles/CMakeLists.txt @@ -234,6 +234,8 @@ if(WITH_BLENDER) cancel cancel_large center_only + char_notdef + char_replacement checkbox_dehlt checkbox_hlt checkmark @@ -640,6 +642,7 @@ if(WITH_BLENDER) normals_face normals_vertex normals_vertex_face + not_found object_data object_datamode object_hidden diff --git a/source/blender/editors/include/UI_icons.hh b/source/blender/editors/include/UI_icons.hh index adce49950d1..36d3ba6eb7f 100644 --- a/source/blender/editors/include/UI_icons.hh +++ b/source/blender/editors/include/UI_icons.hh @@ -40,6 +40,11 @@ /* ICON_NONE has to be the first item here because it is hard-coded in places as 0. */ DEF_ICON(NONE) +/* Keep these here, in this order. Their IDs should be static. */ +DEF_ICON(CHAR_NOTDEF) +DEF_ICON(CHAR_REPLACEMENT) +DEF_ICON(NOT_FOUND) + /* Blank is no real icon, but used as placeholder or spacers, * it takes the space of an icon but is empty. */ DEF_ICON(BLANK1) From efe02a99434ae527aa0cc98bfd9392ddaef1fc32 Mon Sep 17 00:00:00 2001 From: Campbell Barton Date: Wed, 19 Feb 2025 11:47:44 +1100 Subject: [PATCH 04/31] Cleanup: function argument flags for UIList.draw_item Correct two mistakes in [0] which accidentally assigned flags to the previously declared parameter as well as assigning an argument to `prop`, then setting the flags on `parm`. While it seems that "active_property" only became optional by accident leave this as-is to avoid breaking scripts. [0]: 113997a03c9b1ecc7ec6460f24781d54fd9efb57 Ref #134379. --- source/blender/makesrna/intern/rna_ui.cc | 11 ++++++----- 1 file changed, 6 insertions(+), 5 deletions(-) diff --git a/source/blender/makesrna/intern/rna_ui.cc b/source/blender/makesrna/intern/rna_ui.cc index 09f30620efa..c6caf1daae6 100644 --- a/source/blender/makesrna/intern/rna_ui.cc +++ b/source/blender/makesrna/intern/rna_ui.cc @@ -2073,12 +2073,13 @@ static void rna_def_uilist(BlenderRNA *brna) 0, "", "Identifier of property in active_data, for the active element"); - RNA_def_parameter_flags(parm, PropertyFlag(0), PARM_REQUIRED); - RNA_def_int(func, "index", 0, 0, INT_MAX, "", "Index of the item in the collection", 0, INT_MAX); - RNA_def_parameter_flags(parm, PropertyFlag(0), PARM_REQUIRED | PARM_PYFUNC_OPTIONAL); - prop = RNA_def_property(func, "flt_flag", PROP_INT, PROP_UNSIGNED); - RNA_def_property_ui_text(prop, "", "The filter-flag result for this item"); RNA_def_parameter_flags(parm, PropertyFlag(0), PARM_REQUIRED | PARM_PYFUNC_OPTIONAL); + parm = RNA_def_int( + func, "index", 0, 0, INT_MAX, "", "Index of the item in the collection", 0, INT_MAX); + RNA_def_parameter_flags(parm, PropertyFlag(0), PARM_REQUIRED); + parm = RNA_def_property(func, "flt_flag", PROP_INT, PROP_UNSIGNED); + RNA_def_property_ui_text(parm, "", "The filter-flag result for this item"); + RNA_def_parameter_flags(parm, PropertyFlag(0), PARM_REQUIRED); /* draw_filter */ func = RNA_def_function(srna, "draw_filter", nullptr); From 4ec5d600cd8f19a6ec38887ac31dec566ab903b5 Mon Sep 17 00:00:00 2001 From: Bastien Montagne Date: Wed, 19 Feb 2025 10:55:05 +0100 Subject: [PATCH 05/31] Refactor: Core: Make `BKE_libblock_alloc_notest` return ID pointer. --- source/blender/blenkernel/BKE_lib_id.hh | 2 +- source/blender/blenkernel/intern/lib_id.cc | 6 +++--- source/blender/blenloader/intern/readfile.cc | 2 +- source/blender/depsgraph/intern/node/deg_node_id.cc | 2 +- 4 files changed, 6 insertions(+), 6 deletions(-) diff --git a/source/blender/blenkernel/BKE_lib_id.hh b/source/blender/blenkernel/BKE_lib_id.hh index ed08482c2e4..fe8efa997de 100644 --- a/source/blender/blenkernel/BKE_lib_id.hh +++ b/source/blender/blenkernel/BKE_lib_id.hh @@ -59,7 +59,7 @@ size_t BKE_libblock_get_alloc_info(short type, const char **r_name); * Allocates and returns memory of the right size for the specified block type, * initialized to zero. */ -void *BKE_libblock_alloc_notest(short type) ATTR_WARN_UNUSED_RESULT; +ID *BKE_libblock_alloc_notest(short type) ATTR_WARN_UNUSED_RESULT; /** * Allocates and returns an ID block of the specified type, with the specified name * (adjusted as necessary to ensure uniqueness), and appended to the specified list. diff --git a/source/blender/blenkernel/intern/lib_id.cc b/source/blender/blenkernel/intern/lib_id.cc index 9cd9ccb5956..3be47c8bd72 100644 --- a/source/blender/blenkernel/intern/lib_id.cc +++ b/source/blender/blenkernel/intern/lib_id.cc @@ -1313,12 +1313,12 @@ size_t BKE_libblock_get_alloc_info(short type, const char **r_name) return id_type->struct_size; } -void *BKE_libblock_alloc_notest(short type) +ID *BKE_libblock_alloc_notest(short type) { const char *name; size_t size = BKE_libblock_get_alloc_info(type, &name); if (size != 0) { - return MEM_callocN(size, name); + return static_cast(MEM_callocN(size, name)); } BLI_assert_msg(0, "Request to allocate unknown data type"); return nullptr; @@ -1334,7 +1334,7 @@ void *BKE_libblock_alloc_in_lib(Main *bmain, BLI_assert((flag & LIB_ID_CREATE_NO_MAIN) != 0 || bmain != nullptr); BLI_assert((flag & LIB_ID_CREATE_NO_MAIN) != 0 || (flag & LIB_ID_CREATE_LOCAL) == 0); - ID *id = static_cast(BKE_libblock_alloc_notest(type)); + ID *id = BKE_libblock_alloc_notest(type); if (id) { if ((flag & LIB_ID_CREATE_NO_MAIN) != 0) { diff --git a/source/blender/blenloader/intern/readfile.cc b/source/blender/blenloader/intern/readfile.cc index bea78cd7b7f..98dddd86298 100644 --- a/source/blender/blenloader/intern/readfile.cc +++ b/source/blender/blenloader/intern/readfile.cc @@ -2491,7 +2491,7 @@ static ID *create_placeholder(Main *mainvar, const bool was_liboverride) { ListBase *lb = which_libbase(mainvar, idcode); - ID *ph_id = static_cast(BKE_libblock_alloc_notest(idcode)); + ID *ph_id = BKE_libblock_alloc_notest(idcode); *((short *)ph_id->name) = idcode; BLI_strncpy(ph_id->name + 2, idname, sizeof(ph_id->name) - 2); diff --git a/source/blender/depsgraph/intern/node/deg_node_id.cc b/source/blender/depsgraph/intern/node/deg_node_id.cc index a9270e10066..c33604c5ff4 100644 --- a/source/blender/depsgraph/intern/node/deg_node_id.cc +++ b/source/blender/depsgraph/intern/node/deg_node_id.cc @@ -90,7 +90,7 @@ void IDNode::init_copy_on_write(Depsgraph &depsgraph, ID *id_cow_hint) } } else if (deg_eval_copy_is_needed(id_orig)) { - id_cow = (ID *)BKE_libblock_alloc_notest(GS(id_orig->name)); + id_cow = BKE_libblock_alloc_notest(GS(id_orig->name)); DEG_COW_PRINT( "Create shallow copy for %s: id_orig=%p id_cow=%p\n", id_orig->name, id_orig, id_cow); deg_tag_eval_copy_id(depsgraph, id_cow, id_orig); From ac2cd6c1effdbbfbf3fc4962cc99362b21f34439 Mon Sep 17 00:00:00 2001 From: Jacques Lucke Date: Wed, 19 Feb 2025 11:10:59 +0100 Subject: [PATCH 06/31] Geometry Nodes: make CSV parser more reliable and faster This reimplements the CSV parser used by the (still experimental) Import CSV node. Reliability is improved by: * Properly handling quoted fields. * Unit tests. * Generalizing the parser to be able to handle customized delimiter, quote and escape characters (those are not exposed in the node yet though). * More accurate detection of column types by actually taking all values of a column into account instead of only the first row. Performance is improved by designing the parser in a way that supports multi-threaded parsing. I'm measuring about 5x performance improvement which mainly comes from multi-threading. Some files I wanted to use for benchmarking didn't load in the version that's in `main` but do load fine with this new version. The implementation is now split up into two parts: 1. A general CSV parser in `blenlib` that manages splitting a buffer into records and their fields. 2. Application specific parsing of fields into e.g. floats and integers which remains in `io/csv/importer`. This separation simplifies unit testing and makes the core code more reusable. Pull Request: https://projects.blender.org/blender/blender/pulls/134715 --- source/blender/blenlib/BLI_csv_parse.hh | 231 +++++++++ source/blender/blenlib/CMakeLists.txt | 3 + source/blender/blenlib/intern/csv_parse.cc | 286 +++++++++++ .../blenlib/tests/BLI_csv_parse_test.cc | 259 ++++++++++ source/blender/io/csv/importer/csv_reader.cc | 486 ++++++++++-------- 5 files changed, 1057 insertions(+), 208 deletions(-) create mode 100644 source/blender/blenlib/BLI_csv_parse.hh create mode 100644 source/blender/blenlib/intern/csv_parse.cc create mode 100644 source/blender/blenlib/tests/BLI_csv_parse_test.cc diff --git a/source/blender/blenlib/BLI_csv_parse.hh b/source/blender/blenlib/BLI_csv_parse.hh new file mode 100644 index 00000000000..9f4138340d0 --- /dev/null +++ b/source/blender/blenlib/BLI_csv_parse.hh @@ -0,0 +1,231 @@ +/* SPDX-FileCopyrightText: 2025 Blender Authors + * + * SPDX-License-Identifier: GPL-2.0-or-later */ + +#include "BLI_any.hh" +#include "BLI_function_ref.hh" +#include "BLI_offset_indices.hh" +#include "BLI_string_ref.hh" +#include "BLI_vector.hh" + +namespace blender::csv_parse { + +/** + * Contains the fields of a single record of a .csv file. Usually that corresponds to a single + * line. + */ +class CsvRecord { + private: + Span> fields_; + + public: + CsvRecord(Span> fields); + + /** Number of fields in the record. */ + int64_t size() const; + IndexRange index_range() const; + + /** Get the field at the given index. Empty data is returned if the index is too large. */ + Span field(const int64_t index) const; + StringRef field_str(const int64_t index) const; +}; + +/** + * Contains the fields of multiple records. + */ +class CsvRecords { + private: + OffsetIndices offsets_; + Span> fields_; + + public: + CsvRecords(OffsetIndices offsets, Span> fields); + + /** Number of records (rows). */ + int64_t size() const; + IndexRange index_range() const; + + /** Get the record at the given index. */ + CsvRecord record(const int64_t index) const; +}; + +struct CsvParseOptions { + /** The character that separates fields within a row. */ + char delimiter = ','; + /** + * The character that can be used to enclose fields which contain the delimiter or span multiple + * lines. + */ + char quote = '"'; + /** + * Characters that can be used to escape the quote character. By default, "" or \" both represent + * an escaped quote. + */ + Span quote_escape_chars = Span(StringRef("\"\\")); + /** Approximate number of bytes per chunk that the input is split into. */ + int64_t chunk_size_bytes = 64 * 1024; +}; + +/** + * Parses a .csv file. There are two important aspects to the way this interface is designed: + * 1. It allows the file to be split into chunks that can be parsed in parallel. + * 2. Splitting the file into individual records and fields is separated from parsing the actual + * content into e.g. floats. This simplifies the implementation of both parts because the + * logical parsing does not have to worry about e.g. the delimiter or quote characters. It also + * simplifies unit testing. + * + * \param buffer: The buffer containing the .csv file. + * \param options: Options that control how the file is parsed. + * \param process_header: A function that is called at most once and contains the fields of the + * first row/record. + * \param process_records: A function that is called potentially many times in parallel and that + * processes a chunk of parsed records. Typically this function parses raw byte fields into e.g. + * ints or floats. The result of the parsing process has to be returned. Note that under specific + * circumstances, this function may be called twice for the same records. That can happen when + * the .csv file contains multi-line fields which were split incorrectly at first. + * \return A vector containing the return values of the `process_records` function in the correct + * order. Nullopt is returned if the file was malformed, e.g. if it has a quoted field that is + * not closed. + */ +std::optional>> parse_csv_in_chunks( + const Span buffer, + const CsvParseOptions &options, + FunctionRef process_header, + FunctionRef(const CsvRecords &records)> process_records); + +/** + * Same as above, but uses a templated chunk type instead of using #Any which can be more + * convenient to use. + */ +template +inline std::optional> parse_csv_in_chunks( + const Span buffer, + const CsvParseOptions &options, + FunctionRef process_header, + FunctionRef process_records) +{ + std::optional>> result = parse_csv_in_chunks( + buffer, options, process_header, [&](const CsvRecords &records) { + return Any<>(process_records(records)); + }); + if (!result.has_value()) { + return std::nullopt; + } + Vector result_chunks; + result_chunks.reserve(result->size()); + for (Any<> &value : *result) { + result_chunks.append(std::move(value.get())); + } + return result_chunks; +} + +/* -------------------------------------------------------------------- */ +/** \name #CsvRecord inline functions. + * \{ */ + +inline CsvRecord::CsvRecord(Span> fields) : fields_(fields) {} + +inline int64_t CsvRecord::size() const +{ + return fields_.size(); +} + +inline IndexRange CsvRecord::index_range() const +{ + return fields_.index_range(); +} + +inline Span CsvRecord::field(const int64_t index) const +{ + BLI_assert(index >= 0); + if (index >= fields_.size()) { + return {}; + } + return fields_[index]; +} + +inline StringRef CsvRecord::field_str(const int64_t index) const +{ + const Span value = this->field(index); + return StringRef(value.data(), value.size()); +} + +/** \} */ + +/* -------------------------------------------------------------------- */ +/** \name #CsvRecords inline functions. + * \{ */ + +inline CsvRecords::CsvRecords(const OffsetIndices offsets, const Span> fields) + : offsets_(offsets), fields_(fields) +{ +} + +inline int64_t CsvRecords::size() const +{ + return offsets_.size(); +} + +inline IndexRange CsvRecords::index_range() const +{ + return offsets_.index_range(); +} + +inline CsvRecord CsvRecords::record(const int64_t index) const +{ + return CsvRecord(fields_.slice(offsets_[index])); +} + +/** \} */ + +/* -------------------------------------------------------------------- */ +/** \name Internal functions exposed for testing. + * \{ */ + +namespace detail { + +/** + * Find the index that ends the current field, i.e. the index of the next delimiter of newline. + * The start index has to be the index of the first character in the field. It may also be the + * end of the field already if it is empty. + * + * \param start: The index of the first character in the field. This may also be the end of the + * field already if it is empty. + * \param delimiter: The character that ends the field. + * \return Index of the next delimiter, a newline character or the end of the buffer. + */ +int64_t find_end_of_simple_field(Span buffer, int64_t start, char delimiter); + +/** + * Find the index of the quote that ends the current field. + * + * \param start: The index after the opening quote. + * \param quote: The quote character that ends the field. + * \param escape_chars: The characters that may be used to escape the quote character. + * \return Index of the quote character that ends the field, or std::nullopt if the field is + * malformed and does not have an end. + */ +std::optional find_end_of_quoted_field(Span buffer, + int64_t start, + char quote, + Span escape_chars); + +/** + * Finds all fields for the record starting at the given index. Typically, the record ends with a + * newline, but quoted multiline records are supported as well. + * + * \return Index of the the start of the next record or the end of the buffer. Nullopt is returned + * if the buffer has a malformed record at the end, i.e. a quoted field that is not closed. + */ +std::optional parse_record_fields(const Span buffer, + const int64_t start, + const char delimiter, + const char quote, + const Span quote_escape_chars, + Vector> &r_fields); + +} // namespace detail + +/** \} */ + +} // namespace blender::csv_parse diff --git a/source/blender/blenlib/CMakeLists.txt b/source/blender/blenlib/CMakeLists.txt index 2301347f9df..1bfe1e330b8 100644 --- a/source/blender/blenlib/CMakeLists.txt +++ b/source/blender/blenlib/CMakeLists.txt @@ -58,6 +58,7 @@ set(SRC intern/convexhull_2d.cc intern/cpp_type.cc intern/cpp_types.cc + intern/csv_parse.cc intern/delaunay_2d.cc intern/dot_export.cc intern/easing.cc @@ -215,6 +216,7 @@ set(SRC BLI_cpp_type_make.hh BLI_cpp_types.hh BLI_cpp_types_make.hh + BLI_csv_parse.hh BLI_delaunay_2d.hh BLI_devirtualize_parameters.hh BLI_dial_2d.h @@ -527,6 +529,7 @@ if(WITH_GTESTS) tests/BLI_color_test.cc tests/BLI_convexhull_2d_test.cc tests/BLI_cpp_type_test.cc + tests/BLI_csv_parse_test.cc tests/BLI_delaunay_2d_test.cc tests/BLI_disjoint_set_test.cc tests/BLI_expr_pylike_eval_test.cc diff --git a/source/blender/blenlib/intern/csv_parse.cc b/source/blender/blenlib/intern/csv_parse.cc new file mode 100644 index 00000000000..5ae3ab82732 --- /dev/null +++ b/source/blender/blenlib/intern/csv_parse.cc @@ -0,0 +1,286 @@ +/* SPDX-FileCopyrightText: 2025 Blender Authors + * + * SPDX-License-Identifier: GPL-2.0-or-later */ + +#include "BLI_csv_parse.hh" +#include "BLI_enumerable_thread_specific.hh" +#include "BLI_task.hh" + +namespace blender::csv_parse { + +/** + * Returns a guess for the start of the next record. Note that this could split up quoted fields. + * This case needs to be detected at a higher level. + */ +static int64_t guess_next_record_start(const Span buffer, const int64_t start) +{ + int64_t i = start; + while (i < buffer.size()) { + const char c = buffer[i]; + if (c == '\n') { + return i + 1; + } + i++; + } + return buffer.size(); +} + +/** + * Split the buffer into chunks of approximately the given size. The function attempts to align the + * chunks so that records are not split. This works in the majority of cases, but can fail with + * multi-line fields. This has to be detected at a higher level. + */ +static Vector> split_into_aligned_chunks(const Span buffer, + int64_t approximate_chunk_size) +{ + approximate_chunk_size = std::max(approximate_chunk_size, 1); + Vector> chunks; + int64_t start = 0; + while (start < buffer.size()) { + int64_t end = std::min(start + approximate_chunk_size, buffer.size()); + end = guess_next_record_start(buffer, end); + chunks.append(buffer.slice(IndexRange::from_begin_end(start, end))); + start = end; + } + return chunks; +} + +/** + * Parses the given buffer into records and their fields. + * + * r_data_offsets and r_data_fields are passed into to be able to reuse their memory. + */ +static std::optional parse_records(const Span buffer, + const CsvParseOptions &options, + Vector &r_data_offsets, + Vector> &r_data_fields) +{ + using namespace detail; + /* Clear the data that may still be in there, but do not free the memory. */ + r_data_offsets.clear(); + r_data_fields.clear(); + + r_data_offsets.append(0); + int64_t start = 0; + while (start < buffer.size()) { + const std::optional next_record_start = parse_record_fields( + buffer, + start, + options.delimiter, + options.quote, + options.quote_escape_chars, + r_data_fields); + if (!next_record_start.has_value()) { + return std::nullopt; + } + r_data_offsets.append(r_data_fields.size()); + start = *next_record_start; + } + return CsvRecords(OffsetIndices(r_data_offsets), r_data_fields); +} + +std::optional>> parse_csv_in_chunks( + const Span buffer, + const CsvParseOptions &options, + FunctionRef process_header, + FunctionRef(const CsvRecords &records)> process_records) +{ + using namespace detail; + + /* First parse the first row to get the column names. */ + Vector> header_fields; + const std::optional first_data_record_start = parse_record_fields( + buffer, 0, options.delimiter, options.quote, options.quote_escape_chars, header_fields); + if (!first_data_record_start.has_value()) { + return std::nullopt; + } + /* Call this before starting to process the remaining data. This allows the caller to do some + * preprocessing that is used during chunk parsing. */ + process_header(CsvRecord(header_fields)); + + /* This buffer contains only the data records, without the header. */ + const Span data_buffer = buffer.drop_front(*first_data_record_start); + /* Split the buffer into chunks that can be processed in parallel. */ + const Vector> data_buffer_chunks = split_into_aligned_chunks( + data_buffer, options.chunk_size_bytes); + + /* It's not common, but it can happen that .csv files contain quoted multi-line values. In the + * unlucky case that we split the buffer in the middle of such a multi-line field, there will be + * malformed chunks. In this case we fallback to parsing the whole buffer with a single thread. + * If this case becomes more common, we could try to avoid splitting into malformed chunks by + * making the splitting logic a bit smarter. */ + std::atomic found_malformed_chunk = false; + Vector>> chunk_results(data_buffer_chunks.size()); + struct TLS { + Vector data_offsets; + Vector> data_fields; + }; + threading::EnumerableThreadSpecific all_tls; + threading::parallel_for(chunk_results.index_range(), 1, [&](const IndexRange range) { + TLS &tls = all_tls.local(); + for (const int64_t i : range) { + if (found_malformed_chunk.load(std::memory_order_relaxed)) { + /* All work is cancelled when there was a malformed chunk. */ + return; + } + const Span chunk_buffer = data_buffer_chunks[i]; + const std::optional records = parse_records( + chunk_buffer, options, tls.data_offsets, tls.data_fields); + if (!records.has_value()) { + found_malformed_chunk.store(true, std::memory_order_relaxed); + return; + } + chunk_results[i] = process_records(*records); + } + }); + + /* If there was a malformed chunk, process the data again in a single thread without splitting + * the input into chunks. This should happen quite rarely but is important for overall + * correctness. */ + if (found_malformed_chunk) { + chunk_results.clear(); + TLS &tls = all_tls.local(); + const std::optional records = parse_records( + data_buffer, options, tls.data_offsets, tls.data_fields); + if (!records.has_value()) { + return std::nullopt; + } + chunk_results.append(process_records(*records)); + } + + /* Prepare the return value. */ + Vector> results; + for (std::optional> &result : chunk_results) { + BLI_assert(result.has_value()); + results.append(std::move(result.value())); + } + return results; +} + +namespace detail { + +std::optional parse_record_fields(const Span buffer, + const int64_t start, + const char delimiter, + const char quote, + const Span quote_escape_chars, + Vector> &r_fields) +{ + using namespace detail; + + const auto handle_potentially_trailing_delimiter = [&](const int64_t i) { + if (i <= buffer.size()) { + if (i < buffer.size()) { + if (ELEM(buffer[i], '\n', '\r')) { + r_fields.append({}); + } + } + else { + r_fields.append({}); + } + } + }; + + int64_t i = start; + while (i < buffer.size()) { + const char c = buffer[i]; + if (c == '\n') { + return i + 1; + } + if (c == '\r') { + i++; + continue; + } + if (c == delimiter) { + r_fields.append({}); + i++; + handle_potentially_trailing_delimiter(i); + continue; + } + if (c == quote) { + i++; + const std::optional end_of_field = find_end_of_quoted_field( + buffer, i, quote, quote_escape_chars); + if (!end_of_field.has_value()) { + return std::nullopt; + } + r_fields.append(buffer.slice(IndexRange::from_begin_end(i, *end_of_field))); + i = *end_of_field; + while (i < buffer.size()) { + const char inner_c = buffer[i]; + if (inner_c == quote) { + i++; + continue; + } + if (inner_c == delimiter) { + i++; + handle_potentially_trailing_delimiter(i); + break; + } + if (ELEM(inner_c, '\n', '\r')) { + break; + } + i++; + } + continue; + } + const int64_t end_of_field = find_end_of_simple_field(buffer, i, delimiter); + r_fields.append(buffer.slice(IndexRange::from_begin_end(i, end_of_field))); + i = end_of_field; + while (i < buffer.size()) { + const char inner_c = buffer[i]; + if (inner_c == delimiter) { + i++; + handle_potentially_trailing_delimiter(i); + break; + } + if (ELEM(inner_c, '\n', '\r')) { + break; + } + BLI_assert_unreachable(); + } + } + + return buffer.size(); +} + +int64_t find_end_of_simple_field(const Span buffer, + const int64_t start, + const char delimiter) +{ + int64_t i = start; + while (i < buffer.size()) { + const char c = buffer[i]; + if (ELEM(c, delimiter, '\n', '\r')) { + return i; + } + i++; + } + return buffer.size(); +} + +std::optional find_end_of_quoted_field(const Span buffer, + const int64_t start, + const char quote, + const Span escape_chars) +{ + int64_t i = start; + while (i < buffer.size()) { + const char c = buffer[i]; + if (escape_chars.contains(c)) { + if (i + 1 < buffer.size() && buffer[i + 1] == quote) { + i += 2; + continue; + } + } + if (c == quote) { + return i; + } + i++; + } + return std::nullopt; +} + +} // namespace detail + +} // namespace blender::csv_parse diff --git a/source/blender/blenlib/tests/BLI_csv_parse_test.cc b/source/blender/blenlib/tests/BLI_csv_parse_test.cc new file mode 100644 index 00000000000..effc2bb2994 --- /dev/null +++ b/source/blender/blenlib/tests/BLI_csv_parse_test.cc @@ -0,0 +1,259 @@ +/* SPDX-FileCopyrightText: 2025 Blender Authors + * + * SPDX-License-Identifier: Apache-2.0 */ + +#include "testing/testing.h" + +#include "BLI_csv_parse.hh" +#include "BLI_string_ref.hh" + +namespace blender::csv_parse::tests { + +static std::optional find_end_of_simple_field(const StringRef buffer, + const int64_t start, + const char delimiter = ',') +{ + return detail::find_end_of_simple_field(Span(buffer), start, delimiter); +} + +static std::optional find_end_of_quoted_field( + const StringRef buffer, + const int64_t start, + const char quote = '"', + const Span escape_chars = Span(StringRef("\"\\"))) +{ + return detail::find_end_of_quoted_field(Span(buffer), start, quote, escape_chars); +} + +static std::optional> parse_record_fields( + const StringRef buffer, + const int64_t start = 0, + const char delimiter = ',', + const char quote = '"', + const Span quote_escape_chars = Span{'"', '\\'}) +{ + Vector> fields; + const std::optional end_of_record = detail::parse_record_fields( + Span(buffer), start, delimiter, quote, quote_escape_chars, fields); + if (!end_of_record.has_value()) { + return std::nullopt; + } + Vector result; + for (const Span field : fields) { + result.append(std::string(field.begin(), field.end())); + } + return result; +} + +struct StrParseResult { + bool success = false; + Vector column_names; + Vector> records; +}; + +static StrParseResult parse_csv_fields(const StringRef str, const CsvParseOptions &options) +{ + struct Chunk { + Vector> fields; + }; + + StrParseResult result; + const std::optional> chunks = parse_csv_in_chunks( + Span(str), + options, + [&](const CsvRecord &record) { + for (const int64_t i : record.index_range()) { + result.column_names.append(record.field_str(i)); + } + }, + [&](const CsvRecords &records) { + Chunk result; + for (const int64_t record_i : records.index_range()) { + const CsvRecord record = records.record(record_i); + Vector fields; + for (const int64_t column_i : record.index_range()) { + fields.append(record.field_str(column_i)); + } + result.fields.append(std::move(fields)); + } + return result; + }); + if (!chunks.has_value()) { + result.success = false; + return result; + } + result.success = true; + for (const Chunk &chunk : *chunks) { + result.records.extend(std::move(chunk.fields)); + } + return result; +} + +TEST(csv_parse, FindEndOfSimpleField) +{ + EXPECT_EQ(find_end_of_simple_field("123", 0), 3); + EXPECT_EQ(find_end_of_simple_field("123", 1), 3); + EXPECT_EQ(find_end_of_simple_field("123", 2), 3); + EXPECT_EQ(find_end_of_simple_field("123", 3), 3); + EXPECT_EQ(find_end_of_simple_field("1'3", 3), 3); + EXPECT_EQ(find_end_of_simple_field("123,", 0), 3); + EXPECT_EQ(find_end_of_simple_field("123,456", 0), 3); + EXPECT_EQ(find_end_of_simple_field("123,456,789", 0), 3); + EXPECT_EQ(find_end_of_simple_field(" 23", 0), 3); + EXPECT_EQ(find_end_of_simple_field("", 0), 0); + EXPECT_EQ(find_end_of_simple_field("\n", 0), 0); + EXPECT_EQ(find_end_of_simple_field("12\n", 0), 2); + EXPECT_EQ(find_end_of_simple_field("0,12\n", 0), 1); + EXPECT_EQ(find_end_of_simple_field("0,12\n", 2), 4); + EXPECT_EQ(find_end_of_simple_field("\r\n", 0), 0); + EXPECT_EQ(find_end_of_simple_field("12\r\n", 0), 2); + EXPECT_EQ(find_end_of_simple_field("0,12\r\n", 0), 1); + EXPECT_EQ(find_end_of_simple_field("0,12\r\n", 2), 4); + EXPECT_EQ(find_end_of_simple_field("0,\t12\r\n", 2), 5); + EXPECT_EQ(find_end_of_simple_field("0,\t12\r\n", 2, '\t'), 2); +} + +TEST(csv_parse, FindEndOfQuotedField) +{ + EXPECT_EQ(find_end_of_quoted_field("", 0), std::nullopt); + EXPECT_EQ(find_end_of_quoted_field("123", 0), std::nullopt); + EXPECT_EQ(find_end_of_quoted_field("123\n", 0), std::nullopt); + EXPECT_EQ(find_end_of_quoted_field("123\r\n", 0), std::nullopt); + EXPECT_EQ(find_end_of_quoted_field("123\"", 0), 3); + EXPECT_EQ(find_end_of_quoted_field("\"", 0), 0); + EXPECT_EQ(find_end_of_quoted_field("\"\"", 0), std::nullopt); + EXPECT_EQ(find_end_of_quoted_field("\"\"\"", 0), 2); + EXPECT_EQ(find_end_of_quoted_field("123\"\"", 0), std::nullopt); + EXPECT_EQ(find_end_of_quoted_field("123\"\"\"", 0), 5); + EXPECT_EQ(find_end_of_quoted_field("123\"\"\"\"", 0), std::nullopt); + EXPECT_EQ(find_end_of_quoted_field("123\"\"\"\"\"", 0), 7); + EXPECT_EQ(find_end_of_quoted_field("123\"\"0\"\"\"", 0), 8); + EXPECT_EQ(find_end_of_quoted_field(",", 0), std::nullopt); + EXPECT_EQ(find_end_of_quoted_field(",\"", 0), 1); + EXPECT_EQ(find_end_of_quoted_field("0,1\"", 0), 3); + EXPECT_EQ(find_end_of_quoted_field("0,1\n", 0), std::nullopt); + EXPECT_EQ(find_end_of_quoted_field("0,1\"\"", 0), std::nullopt); + EXPECT_EQ(find_end_of_quoted_field("0,1\"\"\"", 0), 5); + EXPECT_EQ(find_end_of_quoted_field("0\n1\n\"", 0), 4); + EXPECT_EQ(find_end_of_quoted_field("\n\"", 0), 1); + EXPECT_EQ(find_end_of_quoted_field("\\\"", 0), std::nullopt); + EXPECT_EQ(find_end_of_quoted_field("\\\"\"", 0), 2); + EXPECT_EQ(find_end_of_quoted_field("\\\"\"\"", 0), std::nullopt); + EXPECT_EQ(find_end_of_quoted_field("\\\"\"\"\"", 0), 4); +} + +TEST(csv_parse, ParseRecordFields) +{ + using StrVec = Vector; + EXPECT_EQ(parse_record_fields(""), StrVec()); + EXPECT_EQ(parse_record_fields("1"), StrVec{"1"}); + EXPECT_EQ(parse_record_fields("1,2"), StrVec({"1", "2"})); + EXPECT_EQ(parse_record_fields("1,2,3"), StrVec({"1", "2", "3"})); + EXPECT_EQ(parse_record_fields("1\n,2,3"), StrVec({"1"})); + EXPECT_EQ(parse_record_fields("1, 2\n,3"), StrVec({"1", " 2"})); + EXPECT_EQ(parse_record_fields("1, 2\r\n,3"), StrVec({"1", " 2"})); + EXPECT_EQ(parse_record_fields("\"1,2,3\""), StrVec({"1,2,3"})); + EXPECT_EQ(parse_record_fields("\"1,2,3"), std::nullopt); + EXPECT_EQ(parse_record_fields("\"1,\n2\t\r\n,3\""), StrVec({"1,\n2\t\r\n,3"})); + EXPECT_EQ(parse_record_fields("\"1,2,3\",\"4,5\""), StrVec({"1,2,3", "4,5"})); + EXPECT_EQ(parse_record_fields(","), StrVec({"", ""})); + EXPECT_EQ(parse_record_fields(",,"), StrVec({"", "", ""})); + EXPECT_EQ(parse_record_fields(",,\n"), StrVec({"", "", ""})); + EXPECT_EQ(parse_record_fields("\r\n,,"), StrVec()); + EXPECT_EQ(parse_record_fields("\"a\"\"b\""), StrVec({"a\"\"b"})); + EXPECT_EQ(parse_record_fields("\"a\\\"b\""), StrVec({"a\\\"b"})); + EXPECT_EQ(parse_record_fields("\"a\"\nb"), StrVec({"a"})); + EXPECT_EQ(parse_record_fields("\"a\" \nb"), StrVec({"a"})); +} + +TEST(csv_parse, ParseCsvBasic) +{ + CsvParseOptions options; + options.chunk_size_bytes = 1; + StrParseResult result = parse_csv_fields("a,b,c\n1,2,3,4\n4\n77,88,99\n", options); + + EXPECT_TRUE(result.success); + + EXPECT_EQ(result.column_names.size(), 3); + EXPECT_EQ(result.column_names[0], "a"); + EXPECT_EQ(result.column_names[1], "b"); + EXPECT_EQ(result.column_names[2], "c"); + + EXPECT_EQ(result.records.size(), 3); + EXPECT_EQ(result.records[0].size(), 4); + EXPECT_EQ(result.records[1].size(), 1); + EXPECT_EQ(result.records[2].size(), 3); + + EXPECT_EQ(result.records[0][0], "1"); + EXPECT_EQ(result.records[0][1], "2"); + EXPECT_EQ(result.records[0][2], "3"); + EXPECT_EQ(result.records[0][3], "4"); + + EXPECT_EQ(result.records[1][0], "4"); + + EXPECT_EQ(result.records[2][0], "77"); + EXPECT_EQ(result.records[2][1], "88"); + EXPECT_EQ(result.records[2][2], "99"); +} + +TEST(csv_parse, ParseCsvMissingEnd) +{ + CsvParseOptions options; + options.chunk_size_bytes = 1; + StrParseResult result = parse_csv_fields("a,b,c\n1,\"2", options); + EXPECT_FALSE(result.success); +} + +TEST(csv_parse, ParseCsvMultiLine) +{ + CsvParseOptions options; + options.chunk_size_bytes = 1; + StrParseResult result = parse_csv_fields("a,b,c\n1,\"2\n\n\",3,4", options); + EXPECT_TRUE(result.success); + EXPECT_EQ(result.records.size(), 1); + EXPECT_EQ(result.records[0].size(), 4); + EXPECT_EQ(result.records[0][0], "1"); + EXPECT_EQ(result.records[0][1], "2\n\n"); + EXPECT_EQ(result.records[0][2], "3"); + EXPECT_EQ(result.records[0][3], "4"); +} + +TEST(csv_parse, ParseCsvEmpty) +{ + CsvParseOptions options; + options.chunk_size_bytes = 1; + StrParseResult result = parse_csv_fields("", options); + EXPECT_TRUE(result.success); + EXPECT_EQ(result.column_names.size(), 0); + EXPECT_EQ(result.records.size(), 0); +} + +TEST(csv_parse, ParseCsvTitlesOnly) +{ + CsvParseOptions options; + options.chunk_size_bytes = 1; + StrParseResult result = parse_csv_fields("a,b,c", options); + EXPECT_TRUE(result.success); + EXPECT_EQ(result.column_names.size(), 3); + EXPECT_EQ(result.column_names[0], "a"); + EXPECT_EQ(result.column_names[1], "b"); + EXPECT_EQ(result.column_names[2], "c"); + EXPECT_TRUE(result.records.is_empty()); +} + +TEST(csv_parse, ParseCsvTrailingNewline) +{ + CsvParseOptions options; + options.chunk_size_bytes = 1; + StrParseResult result = parse_csv_fields("a\n1\n2\n", options); + EXPECT_TRUE(result.success); + EXPECT_EQ(result.column_names.size(), 1); + EXPECT_EQ(result.column_names[0], "a"); + EXPECT_EQ(result.records.size(), 2); + EXPECT_EQ(result.records[0].size(), 1); + EXPECT_EQ(result.records[0][0], "1"); + EXPECT_EQ(result.records[1].size(), 1); + EXPECT_EQ(result.records[1][0], "2"); +} + +} // namespace blender::csv_parse::tests diff --git a/source/blender/io/csv/importer/csv_reader.cc b/source/blender/io/csv/importer/csv_reader.cc index ffa53eb7d35..90476e944c4 100644 --- a/source/blender/io/csv/importer/csv_reader.cc +++ b/source/blender/io/csv/importer/csv_reader.cc @@ -6,207 +6,257 @@ * \ingroup csv */ +#include +#include #include +#include +#include "fast_float.h" + +#include "BKE_anonymous_attribute_id.hh" #include "BKE_attribute.hh" #include "BKE_pointcloud.hh" #include "BKE_report.hh" +#include "BLI_csv_parse.hh" #include "BLI_fileops.hh" -#include "BLI_generic_span.hh" +#include "BLI_implicit_sharing.hh" #include "BLI_vector.hh" #include "IO_csv.hh" -#include "IO_string_utils.hh" namespace blender::io::csv { -static Vector parse_column_names(const StringRef line) -{ - Vector columns; - const char delim = ','; - const char *start = line.begin(), *end = line.end(); - const char *cell_start = start, *cell_end = start; - - int64_t delim_index = line.find_first_of(delim); - - while (delim_index != StringRef::not_found) { - cell_end = start + delim_index; - - columns.append_as(cell_start, cell_end); - - cell_start = cell_end + 1; - delim_index = line.find_first_of(delim, delim_index + 1); - } - - columns.append_as(cell_start, end); - - return columns; -} - -static std::optional get_column_type(const char *start, const char *end) +struct ColumnInfo { + StringRef name; + bool has_invalid_name = false; + std::atomic found_invalid = false; + std::atomic found_int = false; + std::atomic found_float = false; +}; + +using ColumnData = std::variant, Vector>; + +struct ChunkResult { + int rows_num; + Vector columns; +}; + +struct ParseFloatColumnResult { + Vector data; + bool found_invalid = false; +}; + +struct ParseIntColumnResult { + Vector data; + bool found_invalid = false; + bool found_float = false; +}; + +static ParseFloatColumnResult parse_column_as_floats(const csv_parse::CsvRecords &records, + const int column_i) { - bool success = false; - - int _val_int = 0; - try_parse_int(start, end, 0, success, _val_int); - - if (success) { - return CD_PROP_INT32; - } - - float _val_float = 0.0f; - try_parse_float(start, end, 0.0f, success, _val_float); - - if (success) { - return CD_PROP_FLOAT; - } - - return std::nullopt; -} - -static bool get_column_types(const StringRef line, Vector &column_types) -{ - const char delim = ','; - const char *start = line.begin(), *end = line.end(); - const char *cell_start = start, *cell_end = start; - - int64_t delim_index = line.find_first_of(delim); - - while (delim_index != StringRef::not_found) { - cell_end = start + delim_index; - - std::optional column_type = get_column_type(cell_start, cell_end); - if (!column_type.has_value()) { - return false; + ParseFloatColumnResult result; + result.data.reserve(records.size()); + for (const int row_i : records.index_range()) { + const Span value_span = records.record(row_i).field(column_i); + const char *value_begin = value_span.begin(); + const char *value_end = value_span.end(); + /* Skip leading whitespace and plus sign. */ + while (value_begin < value_end && ELEM(*value_begin, ' ', '+')) { + value_begin++; } - column_types.append(column_type.value()); - - cell_start = cell_end + 1; - delim_index = line.find_first_of(delim, delim_index + 1); - } - - std::optional column_type = get_column_type(cell_start, end); - if (!column_type.has_value()) { - return false; + float value; + fast_float::from_chars_result res = fast_float::from_chars(value_begin, value_end, value); + if (res.ec != std::errc()) { + result.found_invalid = true; + return result; + } + if (res.ptr < value_end) { + /* Allow trailing whitespace in the value. */ + while (res.ptr < value_end && res.ptr[0] == ' ') { + res.ptr++; + } + if (res.ptr < value_end) { + result.found_invalid = true; + return result; + } + } + result.data.append(value); } - column_types.append(column_type.value()); - - return true; + return result; } -static int64_t get_row_count(StringRef buffer) +static ParseIntColumnResult parse_column_as_ints(const csv_parse::CsvRecords &records, + const int column_i) { - int64_t row_count = 1; - - while (!buffer.is_empty()) { - read_next_line(buffer); - row_count++; + ParseIntColumnResult result; + result.data.reserve(records.size()); + for (const int row_i : records.index_range()) { + const Span value_span = records.record(row_i).field(column_i); + const char *value_begin = value_span.begin(); + const char *value_end = value_span.end(); + /* Skip leading whitespace and plus sign. */ + while (value_begin < value_end && ELEM(*value_begin, ' ', '+')) { + value_begin++; + } + int value; + std::from_chars_result res = std::from_chars(value_begin, value_end, value); + if (res.ec != std::errc()) { + result.found_invalid = true; + return result; + } + if (res.ptr < value_end) { + /* If the next character after the value is a dot, it should be parsed again as float. */ + if (res.ptr[0] == '.') { + result.found_float = true; + return result; + } + /* Allow trailing whitespace in the value. */ + while (res.ptr < value_end && res.ptr[0] == ' ') { + res.ptr++; + } + if (res.ptr < value_end) { + result.found_invalid = true; + return result; + } + } + result.data.append(value); } - - return row_count; + return result; } -static void parse_csv_cell(const Span data, - const Span types, - const Span column_names, - const int64_t row_index, - const int64_t col_index, - const char *start, - const char *end, - const CSVImportParams &import_params) +static ChunkResult parse_records_chunk(const csv_parse::CsvRecords &records, + MutableSpan columns_info) { - bool success = false; - - switch (types[col_index]) { - case CD_PROP_INT32: { - int value = 0; - try_parse_int(start, end, 0, success, value); - data[col_index].typed()[row_index] = value; - if (!success) { - StringRef column_name = column_names[col_index]; - BKE_reportf(import_params.reports, - RPT_ERROR, - "CSV Import: file '%s' has an unexpected value at row %d for column %s of " - "type Integer", - import_params.filepath, - int(row_index), - std::string(column_name).c_str()); - } - break; + const int columns_num = columns_info.size(); + ChunkResult chunk_result; + chunk_result.rows_num = records.size(); + chunk_result.columns.resize(columns_num); + for (const int column_i : IndexRange(columns_num)) { + ColumnInfo &column_info = columns_info[column_i]; + if (column_info.has_invalid_name) { + /* Column can be ignored. */ + continue; } - case CD_PROP_FLOAT: { - float value = 0.0f; - try_parse_float(start, end, 0.0f, success, value); - data[col_index].typed()[row_index] = value; - if (!success) { - StringRef column_name = column_names[col_index]; - BKE_reportf(import_params.reports, - RPT_ERROR, - "CSV Import: file '%s' has an unexpected value at row %d for column %s of " - "type Float", - import_params.filepath, - int(row_index), - std::string(column_name).c_str()); + if (column_info.found_invalid.load(std::memory_order_relaxed)) { + /* Invalid values have been found in this column already, skip it. */ + continue; + } + /* A float was found in this column already, so parse everything as floats. */ + const bool found_float = column_info.found_float.load(std::memory_order_relaxed); + if (found_float) { + ParseFloatColumnResult float_column_result = parse_column_as_floats(records, column_i); + if (float_column_result.found_invalid) { + column_info.found_invalid.store(true, std::memory_order_relaxed); + continue; } - break; + chunk_result.columns[column_i] = std::move(float_column_result.data); + continue; } - default: { - StringRef column_name = column_names[col_index]; - BKE_reportf(import_params.reports, - RPT_ERROR, - "CSV Import: file '%s' has an unsupported value at row %d for column %s", - import_params.filepath, - int(row_index), - std::string(column_name).c_str()); - break; + /* No float was found so far in this column, so attempt to parse it as integers. */ + ParseIntColumnResult int_column_result = parse_column_as_ints(records, column_i); + if (int_column_result.found_invalid) { + column_info.found_invalid.store(true, std::memory_order_relaxed); + continue; } + if (!int_column_result.found_float) { + chunk_result.columns[column_i] = std::move(int_column_result.data); + column_info.found_int.store(true, std::memory_order_relaxed); + continue; + } + /* While parsing it as integers, floats were detected. So parse it as floats again. */ + column_info.found_float.store(true, std::memory_order_relaxed); + ParseFloatColumnResult float_column_result = parse_column_as_floats(records, column_i); + if (float_column_result.found_invalid) { + column_info.found_invalid.store(true, std::memory_order_relaxed); + continue; + } + chunk_result.columns[column_i] = std::move(float_column_result.data); } + return chunk_result; } -static void parse_csv_line(const Span data, - const Span types, - const Span column_names, - int64_t row_index, - const StringRef line, - const CSVImportParams &import_params) -{ - const char delim = ','; - const char *start = line.begin(), *end = line.end(); - const char *cell_start = start, *cell_end = start; - - int64_t col_index = 0; - - int64_t delim_index = line.find_first_of(delim); - - while (delim_index != StringRef::not_found) { - cell_end = start + delim_index; - - parse_csv_cell( - data, types, column_names, row_index, col_index, cell_start, cell_end, import_params); - col_index++; - - cell_start = cell_end + 1; - delim_index = line.find_first_of(delim, delim_index + 1); - } - - parse_csv_cell(data, types, column_names, row_index, col_index, cell_start, end, import_params); -} - -static void parse_csv_data(const Span data, - const Span types, - const Span column_names, - StringRef buffer, - const CSVImportParams &import_params) +/** + * So far, the parsed data is still split into many chunks. This function flattens the chunks into + * continuous buffers that can be used as attributes. + */ +static Array>> flatten_valid_attribute_chunks( + const Span columns_info, + OffsetIndices chunk_offsets, + MutableSpan chunks) { - int64_t row_index = 0; - while (!buffer.is_empty()) { - const StringRef line = read_next_line(buffer); - - parse_csv_line(data, types, column_names, row_index, line, import_params); - - row_index++; - } + const int points_num = chunk_offsets.total_size(); + Array>> flattened_attributes(columns_info.size()); + + threading::parallel_for(columns_info.index_range(), 1, [&](const IndexRange columns_range) { + for (const int column_i : columns_range) { + const ColumnInfo &column_info = columns_info[column_i]; + if (column_info.has_invalid_name || column_info.found_invalid) { + /* Column can be ignored. */ + continue; + } + if (column_info.found_float) { + /* Should read column as floats. */ + GArray<> attribute(CPPType::get(), points_num); + float *attribute_buffer = static_cast(attribute.data()); + threading::parallel_for(chunks.index_range(), 1, [&](const IndexRange chunks_range) { + for (const int chunk_i : chunks_range) { + const IndexRange dst_range = chunk_offsets[chunk_i]; + ChunkResult &chunk = chunks[chunk_i]; + ColumnData &column_data = chunk.columns[column_i]; + if (const auto *float_vec = std::get_if>(&column_data)) { + BLI_assert(float_vec->size() == dst_range.size()); + uninitialized_copy_n( + float_vec->data(), dst_range.size(), attribute_buffer + dst_range.first()); + } + else if (const auto *int_vec = std::get_if>(&column_data)) { + /* This chunk was read entirely as integers, so it still has to be converted to + * floats. */ + BLI_assert(int_vec->size() == dst_range.size()); + uninitialized_convert_n(int_vec->data(), dst_range.size(), attribute_buffer); + } + else { + /* Expected data to be available, because the `found_invalid` flag was not + * set. */ + BLI_assert_unreachable(); + } + /* Free data for chunk. */ + column_data = std::monostate{}; + } + }); + flattened_attributes[column_i] = std::move(attribute); + continue; + } + if (column_info.found_int) { + /* Should read column as ints. */ + GArray<> attribute(CPPType::get(), points_num); + int *attribute_buffer = static_cast(attribute.data()); + threading::parallel_for(chunks.index_range(), 1, [&](const IndexRange chunks_range) { + for (const int chunk_i : chunks_range) { + const IndexRange dst_range = chunk_offsets[chunk_i]; + ChunkResult &chunk = chunks[chunk_i]; + ColumnData &column_data = chunk.columns[column_i]; + if (const auto *int_vec = std::get_if>(&column_data)) { + BLI_assert(int_vec->size() == dst_range.size()); + uninitialized_copy_n( + int_vec->data(), dst_range.size(), attribute_buffer + dst_range.first()); + } + else { + /* Expected data to be available, because the `found_invalid` and + * `found_float` flags were not set. */ + BLI_assert_unreachable(); + } + /* Free data for chunk. */ + column_data = std::monostate{}; + } + }); + flattened_attributes[column_i] = std::move(attribute); + continue; + } + } + }); + return flattened_attributes; } PointCloud *import_csv_as_point_cloud(const CSVImportParams &import_params) @@ -220,62 +270,82 @@ PointCloud *import_csv_as_point_cloud(const CSVImportParams &import_params) import_params.filepath); return nullptr; } - BLI_SCOPED_DEFER([&]() { MEM_freeN(buffer); }); - - StringRef buffer_str{static_cast(buffer), int64_t(buffer_len)}; - if (buffer_str.is_empty()) { + if (buffer_len == 0) { BKE_reportf( import_params.reports, RPT_ERROR, "CSV Import: empty file '%s'", import_params.filepath); return nullptr; } - const StringRef header = read_next_line(buffer_str); - const Vector names = parse_column_names(header); + Array columns_info; + + const auto parse_header = [&](const csv_parse::CsvRecord &record) { + columns_info.reinitialize(record.size()); + for (const int i : record.index_range()) { + ColumnInfo &column_info = columns_info[i]; + const StringRef name = record.field_str(i); + column_info.name = name; + if (!bke::allow_procedural_attribute_access(name) || + bke::attribute_name_is_anonymous(name) || name.is_empty()) + { + column_info.has_invalid_name = true; + continue; + } + } + }; + const auto parse_data_chunk = [&](const csv_parse::CsvRecords &records) { + return parse_records_chunk(records, columns_info); + }; - if (buffer_str.is_empty()) { + const Span buffer_span{static_cast(buffer), int64_t(buffer_len)}; + csv_parse::CsvParseOptions parse_options; + std::optional> parsed_chunks = csv_parse::parse_csv_in_chunks( + buffer_span, parse_options, parse_header, parse_data_chunk); + + if (!parsed_chunks.has_value()) { BKE_reportf(import_params.reports, RPT_ERROR, - "CSV Import: no rows in file '%s'", + "CSV import: failed to parse file '%s'", import_params.filepath); return nullptr; } - /* Shallow copy buffer to preserve pointers from first row for parsing */ - const StringRef data_buffer(buffer_str.begin(), buffer_str.end()); - - const StringRef first_row = read_next_line(buffer_str); - - Vector column_types; - if (!get_column_types(first_row, column_types)) { - std::string column_name = names[column_types.size()]; - BKE_reportf(import_params.reports, - RPT_ERROR, - "CSV Import: file '%s', Column %s is of unsupported data type", - import_params.filepath, - column_name.c_str()); - return nullptr; + /* Count the total number of records and compute the offset of each chunk which is used when + * flattening the parsed data. */ + Vector chunk_offsets_vec; + chunk_offsets_vec.append(0); + for (const ChunkResult &chunk : *parsed_chunks) { + chunk_offsets_vec.append(chunk_offsets_vec.last() + chunk.rows_num); } + const OffsetIndices chunk_offsets(chunk_offsets_vec); + const int points_num = chunk_offsets_vec.last(); - const int64_t rows_num = get_row_count(buffer_str); - - PointCloud *pointcloud = BKE_pointcloud_new_nomain(rows_num); - pointcloud->positions_for_write().fill(float3(0)); + PointCloud *pointcloud = BKE_pointcloud_new_nomain(points_num); - Array attribute_writers(names.size()); - Array attribute_data(names.size()); + Array>> flattened_attributes; + threading::memory_bandwidth_bound_task(points_num * 16, [&]() { + threading::parallel_invoke([&]() { pointcloud->positions_for_write().fill(float3(0)); }, + [&]() { + flattened_attributes = flatten_valid_attribute_chunks( + columns_info, chunk_offsets, *parsed_chunks); + }); + }); + /* Add all valid attributes to the pointcloud. */ bke::MutableAttributeAccessor attributes = pointcloud->attributes_for_write(); - for (const int i : names.index_range()) { - attribute_writers[i] = attributes.lookup_or_add_for_write_span( - names[i], bke::AttrDomain::Point, column_types[i]); - attribute_data[i] = attribute_writers[i].span; - } - - parse_csv_data(attribute_data, column_types, names, data_buffer, import_params); - - for (bke::GSpanAttributeWriter &attr : attribute_writers) { - attr.finish(); + for (const int column_i : columns_info.index_range()) { + const std::optional> &attribute = flattened_attributes[column_i]; + if (!attribute.has_value()) { + continue; + } + const auto *data = new ImplicitSharedValue>(std::move(*attribute)); + const eCustomDataType type = bke::cpp_type_to_custom_data_type(attribute->type()); + const ColumnInfo &column_info = columns_info[column_i]; + attributes.add(column_info.name, + bke::AttrDomain::Point, + type, + bke::AttributeInitShared{data->data.data(), *data}); + data->remove_user_and_delete_if_last(); } return pointcloud; From 3004848372e3aa9fdd4e3300604d9254fa673946 Mon Sep 17 00:00:00 2001 From: Brecht Van Lommel Date: Wed, 19 Feb 2025 10:39:08 +0100 Subject: [PATCH 07/31] Fix #134756: Internal text datablock filepath considered missing When the text datablock was marked as external at one point and the filepath was allocated, it would be considered missing. --- source/blender/blenkernel/intern/text.cc | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/source/blender/blenkernel/intern/text.cc b/source/blender/blenkernel/intern/text.cc index 0b75f8b0f4d..b46880a6a66 100644 --- a/source/blender/blenkernel/intern/text.cc +++ b/source/blender/blenkernel/intern/text.cc @@ -154,7 +154,7 @@ static void text_foreach_path(ID *id, BPathForeachPathData *bpath_data) { Text *text = (Text *)id; - if (text->filepath != nullptr) { + if (text->filepath != nullptr && text->filepath[0] != '\0') { BKE_bpath_foreach_path_allocated_process(bpath_data, &text->filepath); } } From 4d17638212ab509c442af649df220113318da729 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Cl=C3=A9ment=20Foucault?= Date: Wed, 19 Feb 2025 11:50:48 +0100 Subject: [PATCH 08/31] Fix: EEVEE: Broken Metal blocklist This was the cause of the tests not passing on buildbot. --- tests/python/eevee_next_render_tests.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tests/python/eevee_next_render_tests.py b/tests/python/eevee_next_render_tests.py index 486ab271973..7308a3eb9c9 100644 --- a/tests/python/eevee_next_render_tests.py +++ b/tests/python/eevee_next_render_tests.py @@ -47,7 +47,7 @@ def _get_render_arguments(self, arguments_cb, filepath, base_output_filepath): "light_link_exclude.blend", "light_link_instanced_receiver.blend", # Blocked due to difference in volume lightprobe bakes(maybe?) (to be fixed). - "volume_zero_extinction.blend" + "volume_zero_extinction_channel.blend", # Blocked due to difference in screen space tracing (to be fixed). "sss_reflection_clamp.blend", # Blocked due to difference in volume rendering (to be fixed). From 3263dd6333791099ee0656ef40902252714e643e Mon Sep 17 00:00:00 2001 From: Jacques Lucke Date: Wed, 19 Feb 2025 12:36:12 +0100 Subject: [PATCH 09/31] Fix: Geometry Nodes: unescape column names after csv import --- source/blender/blenlib/BLI_csv_parse.hh | 10 +++++++ source/blender/blenlib/BLI_string_ref.hh | 3 ++ source/blender/blenlib/intern/csv_parse.cc | 28 +++++++++++++++++++ .../blenlib/tests/BLI_csv_parse_test.cc | 14 ++++++++++ .../blenlib/tests/BLI_string_ref_test.cc | 6 ++++ source/blender/io/csv/importer/csv_reader.cc | 6 ++-- 6 files changed, 65 insertions(+), 2 deletions(-) diff --git a/source/blender/blenlib/BLI_csv_parse.hh b/source/blender/blenlib/BLI_csv_parse.hh index 9f4138340d0..c37780b36ca 100644 --- a/source/blender/blenlib/BLI_csv_parse.hh +++ b/source/blender/blenlib/BLI_csv_parse.hh @@ -4,6 +4,7 @@ #include "BLI_any.hh" #include "BLI_function_ref.hh" +#include "BLI_linear_allocator.hh" #include "BLI_offset_indices.hh" #include "BLI_string_ref.hh" #include "BLI_vector.hh" @@ -119,6 +120,15 @@ inline std::optional> parse_csv_in_chunks( return result_chunks; } +/** + * Fields in a csv file may contain escaped quote caracters (e.g. "" or \"). This function replaces + * these with just the quote character. The returned string may be reference the input string if + * it's the same. Otherwise the returned string is allocated in the given allocator. + */ +StringRef unescape_field(const StringRef str, + const CsvParseOptions &options, + LinearAllocator<> &allocator); + /* -------------------------------------------------------------------- */ /** \name #CsvRecord inline functions. * \{ */ diff --git a/source/blender/blenlib/BLI_string_ref.hh b/source/blender/blenlib/BLI_string_ref.hh index 33cd01b9dfa..f50465ad6bb 100644 --- a/source/blender/blenlib/BLI_string_ref.hh +++ b/source/blender/blenlib/BLI_string_ref.hh @@ -144,6 +144,7 @@ class StringRef : public StringRefBase { constexpr StringRef(const char *str, int64_t length); constexpr StringRef(const char *begin, const char *one_after_end); constexpr StringRef(std::string_view view); + constexpr StringRef(Span span); StringRef(const std::string &str); constexpr StringRef drop_prefix(int64_t n) const; @@ -558,6 +559,8 @@ constexpr StringRef::StringRef(std::string_view view) { } +constexpr StringRef::StringRef(Span span) : StringRefBase(span.data(), span.size()) {} + /** \} */ /* -------------------------------------------------------------------- */ diff --git a/source/blender/blenlib/intern/csv_parse.cc b/source/blender/blenlib/intern/csv_parse.cc index 5ae3ab82732..6ddd0d8daa3 100644 --- a/source/blender/blenlib/intern/csv_parse.cc +++ b/source/blender/blenlib/intern/csv_parse.cc @@ -157,6 +157,34 @@ std::optional>> parse_csv_in_chunks( return results; } +StringRef unescape_field(const StringRef str, + const CsvParseOptions &options, + LinearAllocator<> &allocator) +{ + const StringRef escape_chars{options.quote_escape_chars}; + if (str.find_first_of(escape_chars) == StringRef::not_found) { + return str; + } + /* The actual unescaped string may be shorter, but not longer. */ + MutableSpan unescaped_str = allocator.allocate_array(str.size()); + int64_t i = 0; + int64_t escaped_size = 0; + while (i < str.size()) { + const char c = str[i]; + if (options.quote_escape_chars.contains(c)) { + if (i + 1 < str.size() && str[i + 1] == options.quote) { + /* Ignore the current escape character. */ + unescaped_str[escaped_size++] = options.quote; + i += 2; + continue; + } + } + unescaped_str[escaped_size++] = c; + i++; + } + return StringRef(unescaped_str.take_front(escaped_size)); +} + namespace detail { std::optional parse_record_fields(const Span buffer, diff --git a/source/blender/blenlib/tests/BLI_csv_parse_test.cc b/source/blender/blenlib/tests/BLI_csv_parse_test.cc index effc2bb2994..53f9ecb87a2 100644 --- a/source/blender/blenlib/tests/BLI_csv_parse_test.cc +++ b/source/blender/blenlib/tests/BLI_csv_parse_test.cc @@ -256,4 +256,18 @@ TEST(csv_parse, ParseCsvTrailingNewline) EXPECT_EQ(result.records[1][0], "2"); } +TEST(csv_parse, UnescapeField) +{ + LinearAllocator<> allocator; + CsvParseOptions options; + EXPECT_EQ(unescape_field("", options, allocator), ""); + EXPECT_EQ(unescape_field("a", options, allocator), "a"); + EXPECT_EQ(unescape_field("abcd", options, allocator), "abcd"); + EXPECT_EQ(unescape_field("ab\\cd", options, allocator), "ab\\cd"); + EXPECT_EQ(unescape_field("ab\\\"cd", options, allocator), "ab\"cd"); + EXPECT_EQ(unescape_field("ab\"\"cd", options, allocator), "ab\"cd"); + EXPECT_EQ(unescape_field("ab\"\"\"\"cd", options, allocator), "ab\"\"cd"); + EXPECT_EQ(unescape_field("ab\"\"\\\"cd", options, allocator), "ab\"\"cd"); +} + } // namespace blender::csv_parse::tests diff --git a/source/blender/blenlib/tests/BLI_string_ref_test.cc b/source/blender/blenlib/tests/BLI_string_ref_test.cc index 7628bdca9d4..356e9a56118 100644 --- a/source/blender/blenlib/tests/BLI_string_ref_test.cc +++ b/source/blender/blenlib/tests/BLI_string_ref_test.cc @@ -163,6 +163,12 @@ TEST(string_ref, StdStringConstructor) EXPECT_EQ(ref.data(), str.data()); } +TEST(string_ref, SpanConstructor) +{ + EXPECT_EQ(StringRef(Span("hello", 5)), "hello"); + EXPECT_EQ(StringRef(Span("hello", 2)), "he"); +} + TEST(string_ref, SubscriptOperator) { StringRef ref("hello"); diff --git a/source/blender/io/csv/importer/csv_reader.cc b/source/blender/io/csv/importer/csv_reader.cc index 90476e944c4..ebc95fc6340 100644 --- a/source/blender/io/csv/importer/csv_reader.cc +++ b/source/blender/io/csv/importer/csv_reader.cc @@ -277,13 +277,16 @@ PointCloud *import_csv_as_point_cloud(const CSVImportParams &import_params) return nullptr; } + LinearAllocator<> allocator; Array columns_info; + csv_parse::CsvParseOptions parse_options; const auto parse_header = [&](const csv_parse::CsvRecord &record) { columns_info.reinitialize(record.size()); for (const int i : record.index_range()) { ColumnInfo &column_info = columns_info[i]; - const StringRef name = record.field_str(i); + const StringRef name = csv_parse::unescape_field( + record.field_str(i), parse_options, allocator); column_info.name = name; if (!bke::allow_procedural_attribute_access(name) || bke::attribute_name_is_anonymous(name) || name.is_empty()) @@ -298,7 +301,6 @@ PointCloud *import_csv_as_point_cloud(const CSVImportParams &import_params) }; const Span buffer_span{static_cast(buffer), int64_t(buffer_len)}; - csv_parse::CsvParseOptions parse_options; std::optional> parsed_chunks = csv_parse::parse_csv_in_chunks( buffer_span, parse_options, parse_header, parse_data_chunk); From 119fc054f854a0923037a7942b0ed2e1e7816047 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=D0=B8=D0=BB=D1=8C=D1=8F=20=5F?= Date: Wed, 19 Feb 2025 13:44:11 +0100 Subject: [PATCH 10/31] Cleanup: BKE: Nodes: Pass-by-reference Restriction of the nodes api to clearly define never-null function arguments. Side effects: some assertions and null-check (with early return) were removed. On the caller side is ensured to never derefer null to pass argument (mainly in RNA). In addition, one pointer argument now actually a return type. By-reference return types instead of pointers going to be separate kind of change since also imply of cleaning up variables created from reference. Also good future improvement would be to mark a copy-constructor as explicit for DNA node types. Pull Request: https://projects.blender.org/blender/blender/pulls/134627 --- source/blender/blenkernel/BKE_node.hh | 170 ++-- .../intern/grease_pencil_convert_legacy.cc | 102 +-- source/blender/blenkernel/intern/linestyle.cc | 12 +- source/blender/blenkernel/intern/material.cc | 52 +- .../blenkernel/intern/mesh_legacy_convert.cc | 112 +-- source/blender/blenkernel/intern/node.cc | 772 +++++++++--------- .../intern/node_tree_field_inferencing.cc | 2 +- .../blenkernel/intern/node_tree_interface.cc | 2 +- .../blenkernel/intern/node_tree_update.cc | 2 +- source/blender/blenloader/intern/readfile.cc | 4 +- .../blenloader/intern/versioning_250.cc | 4 +- .../blenloader/intern/versioning_260.cc | 12 +- .../blenloader/intern/versioning_270.cc | 16 +- .../blenloader/intern/versioning_280.cc | 309 +++---- .../blenloader/intern/versioning_290.cc | 10 +- .../blenloader/intern/versioning_300.cc | 179 ++-- .../blenloader/intern/versioning_400.cc | 465 ++++++----- .../blenloader/intern/versioning_common.cc | 28 +- .../blenloader/intern/versioning_defaults.cc | 6 +- .../draw/engines/eevee_next/eevee_lookdev.cc | 40 +- .../draw/engines/eevee_next/eevee_material.cc | 76 +- .../draw/engines/eevee_next/eevee_world.cc | 14 +- .../blender/editors/animation/anim_filter.cc | 2 +- .../editors/curves/intern/curves_add.cc | 26 +- .../interface_template_node_inputs.cc | 2 +- .../blender/editors/object/object_bake_api.cc | 2 +- .../editors/sculpt_paint/paint_image_proj.cc | 44 +- .../editors/space_buttons/buttons_texture.cc | 4 +- .../blender/editors/space_node/clipboard.cc | 16 +- .../editors/space_node/link_drag_search.cc | 36 +- source/blender/editors/space_node/node_add.cc | 40 +- .../blender/editors/space_node/node_draw.cc | 28 +- .../blender/editors/space_node/node_edit.cc | 100 +-- .../blender/editors/space_node/node_gizmo.cc | 14 +- .../blender/editors/space_node/node_group.cc | 79 +- .../editors/space_node/node_relationships.cc | 100 +-- .../blender/editors/space_node/node_select.cc | 46 +- .../editors/space_node/node_shader_preview.cc | 45 +- .../editors/space_node/node_templates.cc | 24 +- .../blender/editors/space_node/space_node.cc | 4 +- .../transform/transform_convert_node.cc | 2 +- source/blender/editors/util/ed_viewer_path.cc | 2 +- source/blender/editors/uvedit/uvedit_ops.cc | 4 +- .../BlenderStrokeRenderer.cpp | 64 +- source/blender/io/collada/Materials.cpp | 30 +- source/blender/io/collada/collada_utils.cpp | 8 +- .../io/usd/intern/usd_light_convert.cc | 40 +- .../io/usd/intern/usd_reader_material.cc | 37 +- .../usd/intern/usd_reader_pointinstancer.cc | 102 +-- .../io/usd/intern/usd_writer_material.cc | 37 +- .../wavefront_obj/exporter/obj_export_mtl.cc | 2 +- .../wavefront_obj/importer/obj_import_mtl.cc | 12 +- .../blender/makesrna/intern/rna_material.cc | 2 +- .../makesrna/intern/rna_node_socket.cc | 6 +- .../intern/rna_node_tree_interface.cc | 2 +- .../blender/makesrna/intern/rna_nodetree.cc | 150 ++-- source/blender/nodes/NOD_socket_items.hh | 5 +- source/blender/nodes/NOD_socket_items_ops.hh | 2 +- .../nodes/composite/node_composite_tree.cc | 8 +- .../nodes/composite/node_composite_util.cc | 2 +- .../nodes/node_composite_alpha_over.cc | 4 +- .../nodes/node_composite_antialiasing.cc | 6 +- .../nodes/node_composite_bilateralblur.cc | 4 +- .../composite/nodes/node_composite_blur.cc | 4 +- .../nodes/node_composite_bokehblur.cc | 2 +- .../nodes/node_composite_bokehimage.cc | 4 +- .../composite/nodes/node_composite_boxmask.cc | 4 +- .../nodes/node_composite_brightness.cc | 2 +- .../nodes/node_composite_channel_matte.cc | 4 +- .../nodes/node_composite_chroma_matte.cc | 4 +- .../nodes/node_composite_color_matte.cc | 4 +- .../nodes/node_composite_color_spill.cc | 4 +- .../nodes/node_composite_colorbalance.cc | 6 +- .../nodes/node_composite_colorcorrection.cc | 6 +- .../composite/nodes/node_composite_common.cc | 6 +- .../nodes/node_composite_composite.cc | 2 +- .../node_composite_convert_color_space.cc | 6 +- .../nodes/node_composite_cornerpin.cc | 2 +- .../composite/nodes/node_composite_crop.cc | 4 +- .../nodes/node_composite_cryptomatte.cc | 16 +- .../composite/nodes/node_composite_curves.cc | 18 +- .../composite/nodes/node_composite_defocus.cc | 4 +- .../composite/nodes/node_composite_denoise.cc | 4 +- .../nodes/node_composite_despeckle.cc | 2 +- .../nodes/node_composite_diff_matte.cc | 4 +- .../composite/nodes/node_composite_dilate.cc | 4 +- .../nodes/node_composite_directionalblur.cc | 4 +- .../nodes/node_composite_displace.cc | 2 +- .../nodes/node_composite_distance_matte.cc | 4 +- .../nodes/node_composite_double_edge_mask.cc | 2 +- .../nodes/node_composite_ellipsemask.cc | 6 +- .../nodes/node_composite_exposure.cc | 2 +- .../nodes/node_composite_file_output.cc | 12 +- .../composite/nodes/node_composite_filter.cc | 2 +- .../composite/nodes/node_composite_flip.cc | 2 +- .../composite/nodes/node_composite_gamma.cc | 2 +- .../composite/nodes/node_composite_glare.cc | 32 +- .../nodes/node_composite_hue_sat_val.cc | 2 +- .../nodes/node_composite_huecorrect.cc | 6 +- .../composite/nodes/node_composite_id_mask.cc | 2 +- .../composite/nodes/node_composite_image.cc | 20 +- .../composite/nodes/node_composite_inpaint.cc | 2 +- .../composite/nodes/node_composite_invert.cc | 2 +- .../composite/nodes/node_composite_keying.cc | 4 +- .../nodes/node_composite_keyingscreen.cc | 4 +- .../nodes/node_composite_kuwahara.cc | 4 +- .../nodes/node_composite_lensdist.cc | 4 +- .../composite/nodes/node_composite_levels.cc | 2 +- .../nodes/node_composite_luma_matte.cc | 4 +- .../nodes/node_composite_map_range.cc | 2 +- .../composite/nodes/node_composite_map_uv.cc | 2 +- .../nodes/node_composite_map_value.cc | 4 +- .../composite/nodes/node_composite_mask.cc | 4 +- .../composite/nodes/node_composite_math.cc | 2 +- .../composite/nodes/node_composite_mixrgb.cc | 2 +- .../nodes/node_composite_movieclip.cc | 4 +- .../nodes/node_composite_moviedistortion.cc | 4 +- .../composite/nodes/node_composite_normal.cc | 2 +- .../nodes/node_composite_normalize.cc | 2 +- .../nodes/node_composite_pixelate.cc | 2 +- .../nodes/node_composite_planetrackdeform.cc | 4 +- .../nodes/node_composite_posterize.cc | 2 +- .../nodes/node_composite_premulkey.cc | 2 +- .../composite/nodes/node_composite_rgb.cc | 4 +- .../composite/nodes/node_composite_rotate.cc | 2 +- .../composite/nodes/node_composite_scale.cc | 4 +- .../nodes/node_composite_scene_time.cc | 2 +- .../nodes/node_composite_sepcomb_color.cc | 8 +- .../nodes/node_composite_sepcomb_hsva.cc | 4 +- .../nodes/node_composite_sepcomb_rgba.cc | 4 +- .../nodes/node_composite_sepcomb_xyz.cc | 4 +- .../nodes/node_composite_sepcomb_ycca.cc | 4 +- .../nodes/node_composite_sepcomb_yuva.cc | 4 +- .../nodes/node_composite_setalpha.cc | 4 +- .../composite/nodes/node_composite_split.cc | 2 +- .../nodes/node_composite_stabilize2d.cc | 2 +- .../nodes/node_composite_sunbeams.cc | 4 +- .../composite/nodes/node_composite_switch.cc | 4 +- .../nodes/node_composite_switchview.cc | 2 +- .../composite/nodes/node_composite_texture.cc | 2 +- .../composite/nodes/node_composite_tonemap.cc | 4 +- .../nodes/node_composite_trackpos.cc | 4 +- .../nodes/node_composite_transform.cc | 2 +- .../nodes/node_composite_translate.cc | 4 +- .../nodes/node_composite_val_to_rgb.cc | 10 +- .../composite/nodes/node_composite_value.cc | 4 +- .../nodes/node_composite_vec_blur.cc | 4 +- .../composite/nodes/node_composite_viewer.cc | 4 +- .../nodes/node_composite_zcombine.cc | 2 +- .../nodes/function/node_function_util.cc | 2 +- .../nodes/node_fn_align_euler_to_vector.cc | 2 +- .../nodes/node_fn_align_rotation_to_vector.cc | 2 +- .../nodes/node_fn_axes_to_rotation.cc | 2 +- .../nodes/node_fn_axis_angle_to_rotation.cc | 2 +- .../function/nodes/node_fn_boolean_math.cc | 4 +- .../function/nodes/node_fn_combine_color.cc | 4 +- .../function/nodes/node_fn_combine_matrix.cc | 2 +- .../nodes/node_fn_combine_transform.cc | 2 +- .../nodes/function/nodes/node_fn_compare.cc | 18 +- .../nodes/node_fn_euler_to_rotation.cc | 2 +- .../function/nodes/node_fn_find_in_string.cc | 2 +- .../function/nodes/node_fn_float_to_int.cc | 2 +- .../function/nodes/node_fn_hash_value.cc | 2 +- .../function/nodes/node_fn_input_bool.cc | 4 +- .../function/nodes/node_fn_input_color.cc | 4 +- .../nodes/function/nodes/node_fn_input_int.cc | 4 +- .../function/nodes/node_fn_input_rotation.cc | 4 +- .../nodes/node_fn_input_special_characters.cc | 2 +- .../function/nodes/node_fn_input_string.cc | 4 +- .../function/nodes/node_fn_input_vector.cc | 4 +- .../function/nodes/node_fn_integer_math.cc | 6 +- .../function/nodes/node_fn_invert_matrix.cc | 2 +- .../function/nodes/node_fn_invert_rotation.cc | 2 +- .../nodes/node_fn_matrix_determinant.cc | 2 +- .../function/nodes/node_fn_matrix_multiply.cc | 2 +- .../function/nodes/node_fn_project_point.cc | 2 +- .../nodes/node_fn_quaternion_to_rotation.cc | 2 +- .../function/nodes/node_fn_random_value.cc | 28 +- .../function/nodes/node_fn_replace_string.cc | 2 +- .../function/nodes/node_fn_rotate_euler.cc | 8 +- .../function/nodes/node_fn_rotate_rotation.cc | 2 +- .../function/nodes/node_fn_rotate_vector.cc | 2 +- .../nodes/node_fn_rotation_to_axis_angle.cc | 2 +- .../nodes/node_fn_rotation_to_euler.cc | 2 +- .../nodes/node_fn_rotation_to_quaternion.cc | 2 +- .../function/nodes/node_fn_separate_color.cc | 4 +- .../function/nodes/node_fn_separate_matrix.cc | 2 +- .../nodes/node_fn_separate_transform.cc | 2 +- .../function/nodes/node_fn_slice_string.cc | 2 +- .../function/nodes/node_fn_string_length.cc | 2 +- .../nodes/node_fn_transform_direction.cc | 2 +- .../function/nodes/node_fn_transform_point.cc | 2 +- .../nodes/node_fn_transpose_matrix.cc | 2 +- .../function/nodes/node_fn_value_to_string.cc | 2 +- .../nodes/geometry/node_geometry_tree.cc | 36 +- .../nodes/geometry/node_geometry_util.cc | 2 +- .../nodes/node_geo_accumulate_field.cc | 4 +- .../nodes/node_geo_attribute_capture.cc | 4 +- .../nodes/node_geo_attribute_domain_size.cc | 2 +- .../nodes/node_geo_attribute_statistic.cc | 2 +- .../nodes/geometry/nodes/node_geo_bake.cc | 5 +- .../geometry/nodes/node_geo_blur_attribute.cc | 2 +- .../nodes/geometry/nodes/node_geo_boolean.cc | 2 +- .../geometry/nodes/node_geo_bounding_box.cc | 2 +- .../nodes/node_geo_collection_info.cc | 8 +- .../nodes/geometry/nodes/node_geo_common.cc | 7 +- .../geometry/nodes/node_geo_convex_hull.cc | 2 +- .../node_geo_curve_endpoint_selection.cc | 2 +- .../geometry/nodes/node_geo_curve_fill.cc | 4 +- .../geometry/nodes/node_geo_curve_fillet.cc | 4 +- .../node_geo_curve_handle_type_selection.cc | 4 +- .../geometry/nodes/node_geo_curve_length.cc | 2 +- .../nodes/node_geo_curve_primitive_arc.cc | 4 +- ...node_geo_curve_primitive_bezier_segment.cc | 4 +- .../nodes/node_geo_curve_primitive_circle.cc | 4 +- .../nodes/node_geo_curve_primitive_line.cc | 4 +- ...de_geo_curve_primitive_quadratic_bezier.cc | 2 +- .../node_geo_curve_primitive_quadrilateral.cc | 4 +- .../nodes/node_geo_curve_primitive_spiral.cc | 2 +- .../nodes/node_geo_curve_primitive_star.cc | 2 +- .../geometry/nodes/node_geo_curve_resample.cc | 4 +- .../geometry/nodes/node_geo_curve_reverse.cc | 2 +- .../geometry/nodes/node_geo_curve_sample.cc | 4 +- .../nodes/node_geo_curve_set_handle_type.cc | 4 +- .../nodes/node_geo_curve_spline_parameter.cc | 2 +- .../nodes/node_geo_curve_spline_type.cc | 4 +- .../nodes/node_geo_curve_subdivide.cc | 2 +- .../geometry/nodes/node_geo_curve_to_mesh.cc | 2 +- .../nodes/node_geo_curve_to_points.cc | 4 +- .../node_geo_curve_topology_curve_of_point.cc | 2 +- ...node_geo_curve_topology_points_of_curve.cc | 2 +- .../geometry/nodes/node_geo_curve_trim.cc | 4 +- .../nodes/node_geo_curves_to_grease_pencil.cc | 4 +- .../node_geo_deform_curves_on_surface.cc | 4 +- .../nodes/node_geo_delete_geometry.cc | 8 +- .../node_geo_distribute_points_in_grid.cc | 4 +- .../node_geo_distribute_points_in_volume.cc | 6 +- .../node_geo_distribute_points_on_faces.cc | 4 +- .../geometry/nodes/node_geo_dual_mesh.cc | 2 +- .../nodes/node_geo_duplicate_elements.cc | 4 +- .../nodes/node_geo_edge_paths_to_curves.cc | 2 +- .../nodes/node_geo_edge_paths_to_selection.cc | 4 +- .../geometry/nodes/node_geo_edge_split.cc | 2 +- .../nodes/node_geo_edges_to_face_groups.cc | 2 +- .../nodes/node_geo_evaluate_at_index.cc | 2 +- .../nodes/node_geo_evaluate_on_domain.cc | 2 +- .../geometry/nodes/node_geo_extrude_mesh.cc | 4 +- .../geometry/nodes/node_geo_flip_faces.cc | 2 +- .../node_geo_foreach_geometry_element.cc | 8 +- .../nodes/node_geo_geometry_to_instance.cc | 4 +- .../geometry/nodes/node_geo_get_named_grid.cc | 2 +- .../geometry/nodes/node_geo_gizmo_dial.cc | 4 +- .../geometry/nodes/node_geo_gizmo_linear.cc | 4 +- .../nodes/node_geo_gizmo_transform.cc | 8 +- .../nodes/node_geo_grease_pencil_to_curves.cc | 4 +- .../geometry/nodes/node_geo_grid_to_mesh.cc | 2 +- .../nodes/geometry/nodes/node_geo_image.cc | 4 +- .../geometry/nodes/node_geo_image_info.cc | 4 +- .../geometry/nodes/node_geo_image_texture.cc | 6 +- .../geometry/nodes/node_geo_import_csv.cc | 2 +- .../geometry/nodes/node_geo_import_obj.cc | 2 +- .../geometry/nodes/node_geo_import_ply.cc | 2 +- .../geometry/nodes/node_geo_import_stl.cc | 2 +- .../nodes/node_geo_index_of_nearest.cc | 2 +- .../geometry/nodes/node_geo_index_switch.cc | 4 +- .../nodes/node_geo_input_active_camera.cc | 2 +- .../nodes/node_geo_input_collection.cc | 2 +- .../nodes/node_geo_input_curve_handles.cc | 4 +- .../nodes/node_geo_input_curve_tilt.cc | 2 +- .../nodes/node_geo_input_edge_smooth.cc | 2 +- .../nodes/node_geo_input_face_smooth.cc | 2 +- .../nodes/geometry/nodes/node_geo_input_id.cc | 2 +- .../geometry/nodes/node_geo_input_index.cc | 2 +- .../nodes/node_geo_input_instance_rotation.cc | 2 +- .../nodes/node_geo_input_instance_scale.cc | 2 +- .../node_geo_input_instance_transform.cc | 2 +- .../geometry/nodes/node_geo_input_material.cc | 2 +- .../nodes/node_geo_input_material_index.cc | 2 +- .../nodes/node_geo_input_mesh_edge_angle.cc | 2 +- .../node_geo_input_mesh_edge_neighbors.cc | 2 +- .../node_geo_input_mesh_edge_vertices.cc | 2 +- .../nodes/node_geo_input_mesh_face_area.cc | 2 +- .../node_geo_input_mesh_face_is_planar.cc | 2 +- .../node_geo_input_mesh_face_neighbors.cc | 4 +- .../nodes/node_geo_input_mesh_island.cc | 2 +- .../node_geo_input_mesh_vertex_neighbors.cc | 2 +- .../nodes/node_geo_input_named_attribute.cc | 4 +- .../node_geo_input_named_layer_selection.cc | 2 +- .../geometry/nodes/node_geo_input_normal.cc | 2 +- .../geometry/nodes/node_geo_input_object.cc | 2 +- .../geometry/nodes/node_geo_input_position.cc | 2 +- .../geometry/nodes/node_geo_input_radius.cc | 2 +- .../nodes/node_geo_input_scene_time.cc | 2 +- .../node_geo_input_shortest_edge_paths.cc | 2 +- .../nodes/node_geo_input_spline_cyclic.cc | 2 +- .../nodes/node_geo_input_spline_length.cc | 2 +- .../nodes/node_geo_input_spline_resolution.cc | 2 +- .../geometry/nodes/node_geo_input_tangent.cc | 2 +- .../nodes/node_geo_instance_on_points.cc | 2 +- .../nodes/node_geo_instances_to_points.cc | 2 +- .../nodes/node_geo_interpolate_curves.cc | 2 +- .../geometry/nodes/node_geo_is_viewport.cc | 2 +- .../geometry/nodes/node_geo_join_geometry.cc | 2 +- .../nodes/node_geo_material_replace.cc | 2 +- .../nodes/node_geo_material_selection.cc | 2 +- .../geometry/nodes/node_geo_menu_switch.cc | 4 +- .../nodes/node_geo_merge_by_distance.cc | 4 +- .../geometry/nodes/node_geo_merge_layers.cc | 4 +- .../node_geo_mesh_face_group_boundaries.cc | 4 +- .../nodes/node_geo_mesh_primitive_circle.cc | 4 +- .../nodes/node_geo_mesh_primitive_cone.cc | 4 +- .../nodes/node_geo_mesh_primitive_cube.cc | 2 +- .../nodes/node_geo_mesh_primitive_cylinder.cc | 4 +- .../nodes/node_geo_mesh_primitive_grid.cc | 2 +- .../node_geo_mesh_primitive_ico_sphere.cc | 2 +- .../nodes/node_geo_mesh_primitive_line.cc | 12 +- .../node_geo_mesh_primitive_uv_sphere.cc | 2 +- .../geometry/nodes/node_geo_mesh_subdivide.cc | 2 +- .../geometry/nodes/node_geo_mesh_to_curve.cc | 2 +- .../nodes/node_geo_mesh_to_density_grid.cc | 2 +- .../geometry/nodes/node_geo_mesh_to_points.cc | 4 +- .../nodes/node_geo_mesh_to_sdf_grid.cc | 2 +- .../geometry/nodes/node_geo_mesh_to_volume.cc | 6 +- .../node_geo_mesh_topology_corners_of_edge.cc | 2 +- .../node_geo_mesh_topology_corners_of_face.cc | 2 +- ...ode_geo_mesh_topology_corners_of_vertex.cc | 2 +- .../node_geo_mesh_topology_edges_of_corner.cc | 2 +- .../node_geo_mesh_topology_edges_of_vertex.cc | 2 +- .../node_geo_mesh_topology_face_of_corner.cc | 2 +- ...geo_mesh_topology_offset_corner_in_face.cc | 2 +- ...node_geo_mesh_topology_vertex_of_corner.cc | 2 +- .../geometry/nodes/node_geo_mouse_position.cc | 2 +- .../geometry/nodes/node_geo_object_info.cc | 4 +- .../nodes/node_geo_offset_point_in_curve.cc | 2 +- .../nodes/geometry/nodes/node_geo_points.cc | 2 +- .../nodes/node_geo_points_to_curves.cc | 2 +- .../nodes/node_geo_points_to_sdf_grid.cc | 2 +- .../nodes/node_geo_points_to_vertices.cc | 2 +- .../nodes/node_geo_points_to_volume.cc | 10 +- .../geometry/nodes/node_geo_proximity.cc | 4 +- .../nodes/geometry/nodes/node_geo_raycast.cc | 6 +- .../nodes/node_geo_realize_instances.cc | 2 +- .../nodes/node_geo_remove_attribute.cc | 4 +- .../nodes/geometry/nodes/node_geo_repeat.cc | 8 +- .../nodes/node_geo_rotate_instances.cc | 2 +- .../geometry/nodes/node_geo_sample_grid.cc | 2 +- .../nodes/node_geo_sample_grid_index.cc | 2 +- .../geometry/nodes/node_geo_sample_index.cc | 4 +- .../geometry/nodes/node_geo_sample_nearest.cc | 2 +- .../nodes/node_geo_sample_nearest_surface.cc | 4 +- .../nodes/node_geo_sample_uv_surface.cc | 2 +- .../geometry/nodes/node_geo_scale_elements.cc | 2 +- .../nodes/node_geo_scale_instances.cc | 2 +- .../nodes/node_geo_sdf_grid_boolean.cc | 2 +- .../geometry/nodes/node_geo_self_object.cc | 2 +- .../nodes/node_geo_separate_components.cc | 2 +- .../nodes/node_geo_separate_geometry.cc | 4 +- .../nodes/node_geo_set_curve_handles.cc | 4 +- .../nodes/node_geo_set_curve_normal.cc | 2 +- .../nodes/node_geo_set_curve_radius.cc | 2 +- .../geometry/nodes/node_geo_set_curve_tilt.cc | 2 +- .../nodes/node_geo_set_geometry_name.cc | 2 +- .../nodes/geometry/nodes/node_geo_set_id.cc | 2 +- .../nodes/node_geo_set_instance_transform.cc | 4 +- .../geometry/nodes/node_geo_set_material.cc | 2 +- .../nodes/node_geo_set_material_index.cc | 2 +- .../nodes/node_geo_set_point_radius.cc | 2 +- .../geometry/nodes/node_geo_set_position.cc | 2 +- .../nodes/node_geo_set_shade_smooth.cc | 2 +- .../nodes/node_geo_set_spline_cyclic.cc | 2 +- .../nodes/node_geo_set_spline_resolution.cc | 2 +- .../geometry/nodes/node_geo_simulation.cc | 8 +- .../geometry/nodes/node_geo_sort_elements.cc | 2 +- .../nodes/node_geo_split_to_instances.cc | 2 +- .../nodes/node_geo_store_named_attribute.cc | 6 +- .../nodes/node_geo_store_named_grid.cc | 2 +- .../geometry/nodes/node_geo_string_join.cc | 2 +- .../nodes/node_geo_string_to_curves.cc | 10 +- .../nodes/node_geo_subdivision_surface.cc | 6 +- .../nodes/geometry/nodes/node_geo_switch.cc | 4 +- .../geometry/nodes/node_geo_tool_3d_cursor.cc | 2 +- .../nodes/node_geo_tool_active_element.cc | 2 +- .../geometry/nodes/node_geo_tool_face_set.cc | 2 +- .../geometry/nodes/node_geo_tool_selection.cc | 2 +- .../nodes/node_geo_tool_set_face_set.cc | 2 +- .../nodes/node_geo_tool_set_selection.cc | 2 +- .../nodes/node_geo_transform_geometry.cc | 2 +- .../nodes/node_geo_translate_instances.cc | 2 +- .../geometry/nodes/node_geo_triangulate.cc | 2 +- .../nodes/node_geo_uv_pack_islands.cc | 2 +- .../geometry/nodes/node_geo_uv_unwrap.cc | 4 +- .../nodes/geometry/nodes/node_geo_viewer.cc | 14 +- .../nodes/node_geo_viewport_transform.cc | 2 +- .../geometry/nodes/node_geo_volume_cube.cc | 2 +- .../geometry/nodes/node_geo_volume_to_mesh.cc | 6 +- .../nodes/geometry/nodes/node_geo_warning.cc | 2 +- source/blender/nodes/intern/node_common.cc | 32 +- source/blender/nodes/intern/node_register.cc | 2 +- source/blender/nodes/intern/node_socket.cc | 86 +- .../nodes/intern/node_socket_declarations.cc | 56 +- source/blender/nodes/intern/node_util.cc | 8 +- .../nodes/intern/socket_search_link.cc | 4 +- .../blender/nodes/shader/node_shader_tree.cc | 181 ++-- .../blender/nodes/shader/node_shader_util.cc | 18 +- .../shader/nodes/node_shader_add_shader.cc | 2 +- .../nodes/node_shader_ambient_occlusion.cc | 2 +- .../shader/nodes/node_shader_attribute.cc | 4 +- .../shader/nodes/node_shader_background.cc | 2 +- .../nodes/shader/nodes/node_shader_bevel.cc | 2 +- .../shader/nodes/node_shader_blackbody.cc | 4 +- .../shader/nodes/node_shader_brightness.cc | 2 +- .../shader/nodes/node_shader_bsdf_diffuse.cc | 4 +- .../shader/nodes/node_shader_bsdf_glass.cc | 4 +- .../shader/nodes/node_shader_bsdf_glossy.cc | 6 +- .../shader/nodes/node_shader_bsdf_hair.cc | 4 +- .../nodes/node_shader_bsdf_hair_principled.cc | 26 +- .../shader/nodes/node_shader_bsdf_metallic.cc | 12 +- .../nodes/node_shader_bsdf_principled.cc | 15 +- .../nodes/node_shader_bsdf_ray_portal.cc | 2 +- .../nodes/node_shader_bsdf_refraction.cc | 4 +- .../shader/nodes/node_shader_bsdf_sheen.cc | 2 +- .../shader/nodes/node_shader_bsdf_toon.cc | 4 +- .../nodes/node_shader_bsdf_translucent.cc | 2 +- .../nodes/node_shader_bsdf_transparent.cc | 2 +- .../nodes/shader/nodes/node_shader_bump.cc | 2 +- .../nodes/shader/nodes/node_shader_camera.cc | 2 +- .../nodes/shader/nodes/node_shader_clamp.cc | 2 +- .../shader/nodes/node_shader_color_ramp.cc | 6 +- .../nodes/shader/nodes/node_shader_common.cc | 6 +- .../nodes/shader/nodes/node_shader_curves.cc | 18 +- .../shader/nodes/node_shader_displacement.cc | 2 +- .../nodes/node_shader_eevee_specular.cc | 2 +- .../shader/nodes/node_shader_emission.cc | 2 +- .../nodes/shader/nodes/node_shader_fresnel.cc | 2 +- .../nodes/shader/nodes/node_shader_gamma.cc | 2 +- .../shader/nodes/node_shader_geometry.cc | 2 +- .../shader/nodes/node_shader_hair_info.cc | 2 +- .../nodes/shader/nodes/node_shader_holdout.cc | 2 +- .../shader/nodes/node_shader_hueSatVal.cc | 4 +- .../shader/nodes/node_shader_ies_light.cc | 4 +- .../nodes/shader/nodes/node_shader_invert.cc | 2 +- .../shader/nodes/node_shader_layer_weight.cc | 2 +- .../shader/nodes/node_shader_light_falloff.cc | 4 +- .../shader/nodes/node_shader_light_path.cc | 2 +- .../shader/nodes/node_shader_map_range.cc | 8 +- .../nodes/shader/nodes/node_shader_mapping.cc | 6 +- .../nodes/shader/nodes/node_shader_math.cc | 2 +- .../nodes/shader/nodes/node_shader_mix.cc | 12 +- .../nodes/shader/nodes/node_shader_mix_rgb.cc | 2 +- .../shader/nodes/node_shader_mix_shader.cc | 2 +- .../nodes/shader/nodes/node_shader_normal.cc | 2 +- .../shader/nodes/node_shader_normal_map.cc | 6 +- .../shader/nodes/node_shader_object_info.cc | 2 +- .../shader/nodes/node_shader_output_aov.cc | 4 +- .../shader/nodes/node_shader_output_light.cc | 2 +- .../nodes/node_shader_output_linestyle.cc | 2 +- .../nodes/node_shader_output_material.cc | 2 +- .../shader/nodes/node_shader_output_world.cc | 2 +- .../shader/nodes/node_shader_particle_info.cc | 2 +- .../shader/nodes/node_shader_point_info.cc | 2 +- .../nodes/shader/nodes/node_shader_rgb.cc | 2 +- .../shader/nodes/node_shader_rgb_to_bw.cc | 2 +- .../nodes/shader/nodes/node_shader_script.cc | 4 +- .../shader/nodes/node_shader_sepcomb_color.cc | 8 +- .../shader/nodes/node_shader_sepcomb_hsv.cc | 4 +- .../shader/nodes/node_shader_sepcomb_rgb.cc | 4 +- .../shader/nodes/node_shader_sepcomb_xyz.cc | 4 +- .../shader/nodes/node_shader_shader_to_rgb.cc | 2 +- .../nodes/shader/nodes/node_shader_squeeze.cc | 2 +- .../node_shader_subsurface_scattering.cc | 8 +- .../nodes/shader/nodes/node_shader_tangent.cc | 6 +- .../shader/nodes/node_shader_tex_brick.cc | 6 +- .../shader/nodes/node_shader_tex_checker.cc | 4 +- .../shader/nodes/node_shader_tex_coord.cc | 2 +- .../nodes/node_shader_tex_environment.cc | 6 +- .../shader/nodes/node_shader_tex_gabor.cc | 13 +- .../shader/nodes/node_shader_tex_gradient.cc | 4 +- .../shader/nodes/node_shader_tex_image.cc | 6 +- .../shader/nodes/node_shader_tex_magic.cc | 4 +- .../shader/nodes/node_shader_tex_noise.cc | 24 +- .../nodes/node_shader_tex_pointdensity.cc | 4 +- .../nodes/shader/nodes/node_shader_tex_sky.cc | 10 +- .../shader/nodes/node_shader_tex_voronoi.cc | 62 +- .../shader/nodes/node_shader_tex_wave.cc | 6 +- .../nodes/node_shader_tex_white_noise.cc | 10 +- .../nodes/node_shader_uv_along_stroke.cc | 2 +- .../nodes/shader/nodes/node_shader_uvmap.cc | 6 +- .../nodes/shader/nodes/node_shader_value.cc | 2 +- .../nodes/node_shader_vector_displacement.cc | 2 +- .../shader/nodes/node_shader_vector_math.cc | 26 +- .../shader/nodes/node_shader_vector_rotate.cc | 14 +- .../nodes/node_shader_vector_transform.cc | 4 +- .../shader/nodes/node_shader_vertex_color.cc | 4 +- .../nodes/node_shader_volume_absorption.cc | 2 +- .../shader/nodes/node_shader_volume_info.cc | 2 +- .../nodes/node_shader_volume_principled.cc | 4 +- .../nodes/node_shader_volume_scatter.cc | 13 +- .../shader/nodes/node_shader_wavelength.cc | 4 +- .../shader/nodes/node_shader_wireframe.cc | 2 +- .../nodes/texture/node_texture_tree.cc | 8 +- .../nodes/texture/node_texture_util.cc | 2 +- .../nodes/texture/nodes/node_texture_at.cc | 4 +- .../texture/nodes/node_texture_bricks.cc | 4 +- .../texture/nodes/node_texture_checker.cc | 2 +- .../nodes/node_texture_combine_color.cc | 2 +- .../texture/nodes/node_texture_common.cc | 6 +- .../texture/nodes/node_texture_compose.cc | 2 +- .../nodes/texture/nodes/node_texture_coord.cc | 2 +- .../texture/nodes/node_texture_curves.cc | 12 +- .../texture/nodes/node_texture_decompose.cc | 2 +- .../texture/nodes/node_texture_distance.cc | 2 +- .../texture/nodes/node_texture_hueSatVal.cc | 4 +- .../nodes/texture/nodes/node_texture_image.cc | 4 +- .../texture/nodes/node_texture_invert.cc | 2 +- .../nodes/texture/nodes/node_texture_math.cc | 2 +- .../texture/nodes/node_texture_mixRgb.cc | 2 +- .../texture/nodes/node_texture_output.cc | 6 +- .../nodes/texture/nodes/node_texture_proc.cc | 6 +- .../texture/nodes/node_texture_rotate.cc | 2 +- .../nodes/texture/nodes/node_texture_scale.cc | 2 +- .../nodes/node_texture_separate_color.cc | 2 +- .../texture/nodes/node_texture_texture.cc | 2 +- .../texture/nodes/node_texture_translate.cc | 2 +- .../texture/nodes/node_texture_valToNor.cc | 2 +- .../texture/nodes/node_texture_valToRgb.cc | 8 +- .../texture/nodes/node_texture_viewer.cc | 2 +- 526 files changed, 2874 insertions(+), 2856 deletions(-) diff --git a/source/blender/blenkernel/BKE_node.hh b/source/blender/blenkernel/BKE_node.hh index 1281813c3be..ba0dff7c6d1 100644 --- a/source/blender/blenkernel/BKE_node.hh +++ b/source/blender/blenkernel/BKE_node.hh @@ -516,9 +516,9 @@ struct bNodeTreeType { * \{ */ bNodeTreeType *node_tree_type_find(StringRef idname); -void node_tree_type_add(bNodeTreeType *nt); -void node_tree_type_free_link(const bNodeTreeType *nt); -bool node_tree_is_registered(const bNodeTree *ntree); +void node_tree_type_add(bNodeTreeType &nt); +void node_tree_type_free_link(const bNodeTreeType &nt); +bool node_tree_is_registered(const bNodeTree &ntree); Span node_tree_types_get(); @@ -530,7 +530,7 @@ Span node_tree_types_get(); * In that case the update_typeinfo function will set type-info on registration * and do necessary updates. */ -void node_tree_set_type(const bContext *C, bNodeTree *ntree); +void node_tree_set_type(const bContext *C, bNodeTree &ntree); bNodeTree *node_tree_add_tree(Main *bmain, StringRef name, StringRef idname); @@ -566,8 +566,8 @@ void node_tree_free_local_tree(bNodeTree *ntree); /** * Check recursively if a node tree contains another. */ -bool node_tree_contains_tree(const bNodeTree *tree_to_search_in, - const bNodeTree *tree_to_search_for); +bool node_tree_contains_tree(const bNodeTree &tree_to_search_in, + const bNodeTree &tree_to_search_for); void node_tree_update_all_users(Main *main, ID *id); @@ -576,7 +576,7 @@ void node_tree_update_all_users(Main *main, ID *id); * node types and last active selection. * New tree types have a per-output socket flag to indicate the final output to use explicitly. */ -void node_tree_set_output(bNodeTree *ntree); +void node_tree_set_output(bNodeTree &ntree); /** * Returns localized tree for execution in threads. @@ -599,17 +599,17 @@ void node_tree_blend_write(BlendWriter *writer, bNodeTree *ntree); bNodeType *node_type_find(StringRef idname); StringRefNull node_type_find_alias(StringRefNull alias); -void node_register_type(bNodeType *ntype); -void node_unregister_type(bNodeType *ntype); -void node_register_alias(bNodeType *nt, StringRef alias); +void node_register_type(bNodeType &ntype); +void node_unregister_type(bNodeType &ntype); +void node_register_alias(bNodeType &nt, StringRef alias); Span node_types_get(); bNodeSocketType *node_socket_type_find(StringRef idname); -void node_register_socket_type(bNodeSocketType *stype); -void node_unregister_socket_type(bNodeSocketType *stype); -bool node_socket_is_registered(const bNodeSocket *sock); -StringRefNull node_socket_type_label(const bNodeSocketType *stype); +void node_register_socket_type(bNodeSocketType &stype); +void node_unregister_socket_type(bNodeSocketType &stype); +bool node_socket_is_registered(const bNodeSocket &sock); +StringRefNull node_socket_type_label(const bNodeSocketType &stype); std::optional node_static_socket_type(int type, int subtype); std::optional node_static_socket_interface_type_new(int type, int subtype); @@ -617,62 +617,62 @@ std::optional node_static_socket_label(int type, int subtype); Span node_socket_types_get(); -bNodeSocket *node_find_socket(bNode *node, eNodeSocketInOut in_out, StringRef identifier); -const bNodeSocket *node_find_socket(const bNode *node, +bNodeSocket *node_find_socket(bNode &node, eNodeSocketInOut in_out, StringRef identifier); +const bNodeSocket *node_find_socket(const bNode &node, eNodeSocketInOut in_out, StringRef identifier); -bNodeSocket *node_add_socket(bNodeTree *ntree, - bNode *node, +bNodeSocket *node_add_socket(bNodeTree &ntree, + bNode &node, eNodeSocketInOut in_out, StringRefNull idname, StringRefNull identifier, StringRefNull name); -bNodeSocket *node_add_static_socket(bNodeTree *ntree, - bNode *node, +bNodeSocket *node_add_static_socket(bNodeTree &ntree, + bNode &node, eNodeSocketInOut in_out, int type, int subtype, StringRefNull identifier, StringRefNull name); -void node_remove_socket(bNodeTree *ntree, bNode *node, bNodeSocket *sock); +void node_remove_socket(bNodeTree &ntree, bNode &node, bNodeSocket &sock); void node_modify_socket_type_static( bNodeTree *ntree, bNode *node, bNodeSocket *sock, int type, int subtype); -bNode *node_add_node(const bContext *C, bNodeTree *ntree, StringRef idname); -bNode *node_add_static_node(const bContext *C, bNodeTree *ntree, int type); +bNode *node_add_node(const bContext *C, bNodeTree &ntree, StringRef idname); +bNode *node_add_static_node(const bContext *C, bNodeTree &ntree, int type); /** * Find the first available, non-duplicate name for a given node. */ -void node_unique_name(bNodeTree *ntree, bNode *node); +void node_unique_name(bNodeTree &ntree, bNode &node); /** * Create a new unique integer identifier for the node. Also set the node's * index in the tree, which is an eagerly maintained cache. */ -void node_unique_id(bNodeTree *ntree, bNode *node); +void node_unique_id(bNodeTree &ntree, bNode &node); /** * Delete node, associated animation data and ID user count. */ -void node_remove_node(Main *bmain, bNodeTree *ntree, bNode *node, bool do_id_user); +void node_remove_node(Main *bmain, bNodeTree &ntree, bNode &node, bool do_id_user); -void node_dimensions_get(const bNode *node, float *r_width, float *r_height); -void node_tag_update_id(bNode *node); -void node_internal_links(bNode *node, bNodeLink **r_links, int *r_len); +float2 node_dimensions_get(const bNode &node); +void node_tag_update_id(bNode &node); +void node_internal_links(bNode &node, bNodeLink **r_links, int *r_len); /** * Also used via RNA API, so we check for proper input output direction. */ -bNodeLink *node_add_link( - bNodeTree *ntree, bNode *fromnode, bNodeSocket *fromsock, bNode *tonode, bNodeSocket *tosock); -void node_remove_link(bNodeTree *ntree, bNodeLink *link); -void node_remove_socket_links(bNodeTree *ntree, bNodeSocket *sock); +bNodeLink &node_add_link( + bNodeTree &ntree, bNode &fromnode, bNodeSocket &fromsock, bNode &tonode, bNodeSocket &tosock); +void node_remove_link(bNodeTree *ntree, bNodeLink &link); +void node_remove_socket_links(bNodeTree &ntree, bNodeSocket &sock); -bool node_link_is_hidden(const bNodeLink *link); +bool node_link_is_hidden(const bNodeLink &link); -void node_attach_node(bNodeTree *ntree, bNode *node, bNode *parent); -void node_detach_node(bNodeTree *ntree, bNode *node); +void node_attach_node(bNodeTree &ntree, bNode &node, bNode &parent); +void node_detach_node(bNodeTree &ntree, bNode &node); /** * Finds a node based on given socket, returning null in the case where the socket is not part of @@ -691,33 +691,33 @@ const bNode &node_find_node(const bNodeTree &ntree, const bNodeSocket &socket); /** * Finds a node based on its name. */ -bNode *node_find_node_by_name(bNodeTree *ntree, StringRefNull name); +bNode *node_find_node_by_name(bNodeTree &ntree, StringRefNull name); /** Try to find an input item with the given identifier in the entire node interface tree. */ const bNodeTreeInterfaceSocket *node_find_interface_input_by_identifier(const bNodeTree &ntree, StringRef identifier); -bool node_is_parent_and_child(const bNode *parent, const bNode *child); +bool node_is_parent_and_child(const bNode &parent, const bNode &child); -int node_count_socket_links(const bNodeTree *ntree, const bNodeSocket *sock); +int node_count_socket_links(const bNodeTree &ntree, const bNodeSocket &sock); /** * Selects or deselects the node. If the node is deselected, all its sockets are deselected too. * \return True if any selection was changed. */ -bool node_set_selected(bNode *node, bool select); +bool node_set_selected(bNode &node, bool select); /** * Two active flags, ID nodes have special flag for buttons display. */ -void node_set_active(bNodeTree *ntree, bNode *node); -bNode *node_get_active(bNodeTree *ntree); -void node_clear_active(bNodeTree *ntree); +void node_set_active(bNodeTree &ntree, bNode &node); +bNode *node_get_active(bNodeTree &ntree); +void node_clear_active(bNodeTree &ntree); /** * Two active flags, ID nodes have special flag for buttons display. */ -bNode *node_get_active_texture(bNodeTree *ntree); +bNode *node_get_active_texture(bNodeTree &ntree); -int node_socket_link_limit(const bNodeSocket *sock); +int node_socket_link_limit(const bNodeSocket &sock); /** * Node Instance Hash. @@ -766,7 +766,7 @@ bool node_group_poll(const bNodeTree *nodetree, const bNodeTree *grouptree, const char **r_disabled_hint); -void node_type_base_custom(bNodeType *ntype, +void node_type_base_custom(bNodeType &ntype, StringRefNull idname, StringRefNull name, StringRefNull enum_name, @@ -777,7 +777,7 @@ void node_type_base_custom(bNodeType *ntype, * Otherwise nodes will reload as undefined (#46619). * #storagename is optional due to some compositor nodes use non-DNA storage type. */ -void node_type_storage(bNodeType *ntype, +void node_type_storage(bNodeType &ntype, std::optional storagename, void (*freefunc)(bNode *node), void (*copyfunc)(bNodeTree *dest_ntree, @@ -893,19 +893,19 @@ bNodeTree *node_tree_add_tree_embedded(Main *bmain, * Free (or release) any data used by this node-tree. * Does not free the node-tree itself and does no ID user counting. */ -void node_tree_free_tree(bNodeTree *ntree); +void node_tree_free_tree(bNodeTree &ntree); -bNodeTree *node_tree_copy_tree_ex(const bNodeTree *ntree, Main *bmain, bool do_id_user); -bNodeTree *node_tree_copy_tree(Main *bmain, const bNodeTree *ntree); +bNodeTree *node_tree_copy_tree_ex(const bNodeTree &ntree, Main *bmain, bool do_id_user); +bNodeTree *node_tree_copy_tree(Main *bmain, const bNodeTree &ntree); -void node_tree_free_local_node(bNodeTree *ntree, bNode *node); +void node_tree_free_local_node(bNodeTree &ntree, bNode &node); -void node_tree_update_all_new(Main *main); +void node_tree_update_all_new(Main &main); /** Update asset meta-data cache of data-block properties. */ void node_update_asset_metadata(bNodeTree &node_tree); -void node_tree_node_flag_set(const bNodeTree *ntree, int flag, bool enable); +void node_tree_node_flag_set(const bNodeTree &ntree, int flag, bool enable); /** * Merge local tree results back, and free local tree. @@ -919,30 +919,30 @@ void node_tree_local_merge(Main *bmain, bNodeTree *localtree, bNodeTree *ntree); */ void node_tree_blend_read_data(BlendDataReader *reader, ID *owner_id, bNodeTree *ntree); -bool node_type_is_undefined(const bNode *node); +bool node_type_is_undefined(const bNode &node); -bool node_is_static_socket_type(const bNodeSocketType *stype); +bool node_is_static_socket_type(const bNodeSocketType &stype); StringRefNull node_socket_sub_type_label(int subtype); -void node_remove_socket_ex(bNodeTree *ntree, bNode *node, bNodeSocket *sock, bool do_id_user); +void node_remove_socket_ex(bNodeTree &ntree, bNode &node, bNodeSocket &sock, bool do_id_user); -void node_modify_socket_type(bNodeTree *ntree, - bNode *node, - bNodeSocket *sock, +void node_modify_socket_type(bNodeTree &ntree, + bNode &node, + bNodeSocket &sock, StringRefNull idname); /** * \note Goes over entire tree. */ -void node_unlink_node(bNodeTree *ntree, bNode *node); +void node_unlink_node(bNodeTree &ntree, bNode &node); /** * Rebuild the `node_by_id` runtime vector set. Call after removing a node if not handled * separately. This is important instead of just using `nodes_by_id.remove()` since it maintains * the node order. */ -void node_rebuild_id_vector(bNodeTree *node_tree); +void node_rebuild_id_vector(bNodeTree &node_tree); /** * \note keeps socket list order identical, for copying links. @@ -975,7 +975,7 @@ void node_socket_move_default_value(Main &bmain, * * \note ID user reference-counting and changing the `nodes_by_id` vector are up to the caller. */ -void node_free_node(bNodeTree *tree, bNode *node); +void node_free_node(bNodeTree *tree, bNode &node); /** * Iterate over all ID usages of the given node. @@ -988,23 +988,23 @@ void node_node_foreach_id(bNode *node, LibraryForeachIDData *data); /** * Set the mute status of a single link. */ -void node_link_set_mute(bNodeTree *ntree, bNodeLink *link, const bool muted); +void node_link_set_mute(bNodeTree &ntree, bNodeLink &link, const bool muted); -bool node_link_is_selected(const bNodeLink *link); +bool node_link_is_selected(const bNodeLink &link); -void node_internal_relink(bNodeTree *ntree, bNode *node); +void node_internal_relink(bNodeTree &ntree, bNode &node); -void node_position_relative(bNode *from_node, - const bNode *to_node, - const bNodeSocket *from_sock, - const bNodeSocket *to_sock); +void node_position_relative(bNode &from_node, + const bNode &to_node, + const bNodeSocket &from_sock, + const bNodeSocket &to_sock); -void node_position_propagate(bNode *node); +void node_position_propagate(bNode &node); /** * \note Recursive. */ -bNode *node_find_root_parent(bNode *node); +bNode *node_find_root_parent(bNode &node); /** * Iterate over a chain of nodes, starting with \a node_start, executing @@ -1051,30 +1051,30 @@ void node_parents_iterator(bNode *node, bool (*callback)(bNode *, void *), void * A dangling reroute node is a reroute node that does *not* have a "data source", i.e. no * non-reroute node is connected to its input. */ -bool node_is_dangling_reroute(const bNodeTree *ntree, const bNode *node); +bool node_is_dangling_reroute(const bNodeTree &ntree, const bNode &node); -bNode *node_get_active_paint_canvas(bNodeTree *ntree); +bNode *node_get_active_paint_canvas(bNodeTree &ntree); /** * \brief Does the given node supports the sub active flag. * * \param sub_active: The active flag to check. #NODE_ACTIVE_TEXTURE / #NODE_ACTIVE_PAINT_CANVAS. */ -bool node_supports_active_flag(const bNode *node, int sub_activity); +bool node_supports_active_flag(const bNode &node, int sub_activity); -void node_set_socket_availability(bNodeTree *ntree, bNodeSocket *sock, bool is_available); +void node_set_socket_availability(bNodeTree &ntree, bNodeSocket &sock, bool is_available); /** * If the node implements a `declare` function, this function makes sure that `node->declaration` * is up to date. It is expected that the sockets of the node are up to date already. */ -bool node_declaration_ensure(bNodeTree *ntree, bNode *node); +bool node_declaration_ensure(bNodeTree &ntree, bNode &node); /** * Just update `node->declaration` if necessary. This can also be called on nodes that may not be * up to date (e.g. because the need versioning or are dynamic). */ -bool node_declaration_ensure_on_outdated_node(bNodeTree *ntree, bNode *node); +bool node_declaration_ensure_on_outdated_node(bNodeTree &ntree, bNode &node); /** * Update `socket->declaration` for all sockets in the node. This assumes that the node declaration @@ -1126,7 +1126,7 @@ BLI_INLINE bool node_instance_hash_iterator_done(bNodeInstanceHashIterator *iter blender::bke::node_instance_hash_iterator_step(&iter_)) /* Node Previews */ -bool node_preview_used(const bNode *node); +bool node_preview_used(const bNode &node); bNodePreview *node_preview_verify( bNodeInstanceHash *previews, bNodeInstanceKey key, int xsize, int ysize, bool create); @@ -1145,23 +1145,23 @@ void node_preview_merge_tree(bNodeTree *to_ntree, bNodeTree *from_ntree, bool re /** \name Node Type Access * \{ */ -void nodeLabel(const bNodeTree *ntree, const bNode *node, char *label, int label_maxncpy); +void nodeLabel(const bNodeTree &ntree, const bNode &node, char *label, int label_maxncpy); /** * Get node socket label if it is set. */ -StringRefNull nodeSocketLabel(const bNodeSocket *sock); +StringRefNull nodeSocketLabel(const bNodeSocket &sock); /** * Get node socket short label if it is set. * It is used when grouping sockets under panels, to avoid redundancy in the label. */ -std::optional nodeSocketShortLabel(const bNodeSocket *sock); +std::optional nodeSocketShortLabel(const bNodeSocket &sock); /** * Initialize a new node type struct with default values and callbacks. */ -void node_type_base(bNodeType *ntype, +void node_type_base(bNodeType &ntype, std::string idname, std::optional legacy_type = std::nullopt); @@ -1169,7 +1169,7 @@ void node_type_socket_templates(bNodeType *ntype, bNodeSocketTemplate *inputs, bNodeSocketTemplate *outputs); -void node_type_size(bNodeType *ntype, int width, int minwidth, int maxwidth); +void node_type_size(bNodeType &ntype, int width, int minwidth, int maxwidth); enum class eNodeSizePreset : int8_t { Default, @@ -1178,13 +1178,13 @@ enum class eNodeSizePreset : int8_t { Large, }; -void node_type_size_preset(bNodeType *ntype, eNodeSizePreset size); +void node_type_size_preset(bNodeType &ntype, eNodeSizePreset size); /* -------------------------------------------------------------------- */ /** \name Node Generic Functions * \{ */ -bool node_is_connected_to_output(const bNodeTree *ntree, const bNode *node); +bool node_is_connected_to_output(const bNodeTree &ntree, const bNode &node); bNodeSocket *node_find_enabled_socket(bNode &node, eNodeSocketInOut in_out, StringRef name); diff --git a/source/blender/blenkernel/intern/grease_pencil_convert_legacy.cc b/source/blender/blenkernel/intern/grease_pencil_convert_legacy.cc index 68997f82901..81443f64a89 100644 --- a/source/blender/blenkernel/intern/grease_pencil_convert_legacy.cc +++ b/source/blender/blenkernel/intern/grease_pencil_convert_legacy.cc @@ -1210,80 +1210,80 @@ static bNodeTree *offset_radius_node_tree_add(ConversionData &conversion_data, L group->tree_interface.add_socket( DATA_("Layer"), "", "NodeSocketString", NODE_INTERFACE_SOCKET_INPUT, nullptr); - bNode *group_output = bke::node_add_node(nullptr, group, "NodeGroupOutput"); + bNode *group_output = bke::node_add_node(nullptr, *group, "NodeGroupOutput"); group_output->location[0] = 800; group_output->location[1] = 160; - bNode *group_input = bke::node_add_node(nullptr, group, "NodeGroupInput"); + bNode *group_input = bke::node_add_node(nullptr, *group, "NodeGroupInput"); group_input->location[0] = 0; group_input->location[1] = 160; - bNode *set_curve_radius = bke::node_add_node(nullptr, group, "GeometryNodeSetCurveRadius"); + bNode *set_curve_radius = bke::node_add_node(nullptr, *group, "GeometryNodeSetCurveRadius"); set_curve_radius->location[0] = 600; set_curve_radius->location[1] = 160; bNode *named_layer_selection = bke::node_add_node( - nullptr, group, "GeometryNodeInputNamedLayerSelection"); + nullptr, *group, "GeometryNodeInputNamedLayerSelection"); named_layer_selection->location[0] = 200; named_layer_selection->location[1] = 100; - bNode *input_radius = bke::node_add_node(nullptr, group, "GeometryNodeInputRadius"); + bNode *input_radius = bke::node_add_node(nullptr, *group, "GeometryNodeInputRadius"); input_radius->location[0] = 0; input_radius->location[1] = 0; - bNode *add = bke::node_add_node(nullptr, group, "ShaderNodeMath"); + bNode *add = bke::node_add_node(nullptr, *group, "ShaderNodeMath"); add->custom1 = NODE_MATH_ADD; add->location[0] = 200; add->location[1] = 0; - bNode *clamp_radius = bke::node_add_node(nullptr, group, "ShaderNodeClamp"); + bNode *clamp_radius = bke::node_add_node(nullptr, *group, "ShaderNodeClamp"); clamp_radius->location[0] = 400; clamp_radius->location[1] = 0; - bNodeSocket *sock_max = bke::node_find_socket(clamp_radius, SOCK_IN, "Max"); + bNodeSocket *sock_max = bke::node_find_socket(*clamp_radius, SOCK_IN, "Max"); static_cast(sock_max->default_value)->value = FLT_MAX; - bke::node_add_link(group, - group_input, - bke::node_find_socket(group_input, SOCK_OUT, "Socket_0"), - set_curve_radius, - bke::node_find_socket(set_curve_radius, SOCK_IN, "Curve")); - bke::node_add_link(group, - set_curve_radius, - bke::node_find_socket(set_curve_radius, SOCK_OUT, "Curve"), - group_output, - bke::node_find_socket(group_output, SOCK_IN, "Socket_1")); - - bke::node_add_link(group, - group_input, - bke::node_find_socket(group_input, SOCK_OUT, "Socket_3"), - named_layer_selection, - bke::node_find_socket(named_layer_selection, SOCK_IN, "Name")); - bke::node_add_link(group, - named_layer_selection, - bke::node_find_socket(named_layer_selection, SOCK_OUT, "Selection"), - set_curve_radius, - bke::node_find_socket(set_curve_radius, SOCK_IN, "Selection")); - - bke::node_add_link(group, - group_input, - bke::node_find_socket(group_input, SOCK_OUT, "Socket_2"), - add, - bke::node_find_socket(add, SOCK_IN, "Value")); - bke::node_add_link(group, - input_radius, - bke::node_find_socket(input_radius, SOCK_OUT, "Radius"), - add, - bke::node_find_socket(add, SOCK_IN, "Value_001")); - bke::node_add_link(group, - add, - bke::node_find_socket(add, SOCK_OUT, "Value"), - clamp_radius, - bke::node_find_socket(clamp_radius, SOCK_IN, "Value")); - bke::node_add_link(group, - clamp_radius, - bke::node_find_socket(clamp_radius, SOCK_OUT, "Result"), - set_curve_radius, - bke::node_find_socket(set_curve_radius, SOCK_IN, "Radius")); + bke::node_add_link(*group, + *group_input, + *bke::node_find_socket(*group_input, SOCK_OUT, "Socket_0"), + *set_curve_radius, + *bke::node_find_socket(*set_curve_radius, SOCK_IN, "Curve")); + bke::node_add_link(*group, + *set_curve_radius, + *bke::node_find_socket(*set_curve_radius, SOCK_OUT, "Curve"), + *group_output, + *bke::node_find_socket(*group_output, SOCK_IN, "Socket_1")); + + bke::node_add_link(*group, + *group_input, + *bke::node_find_socket(*group_input, SOCK_OUT, "Socket_3"), + *named_layer_selection, + *bke::node_find_socket(*named_layer_selection, SOCK_IN, "Name")); + bke::node_add_link(*group, + *named_layer_selection, + *bke::node_find_socket(*named_layer_selection, SOCK_OUT, "Selection"), + *set_curve_radius, + *bke::node_find_socket(*set_curve_radius, SOCK_IN, "Selection")); + + bke::node_add_link(*group, + *group_input, + *bke::node_find_socket(*group_input, SOCK_OUT, "Socket_2"), + *add, + *bke::node_find_socket(*add, SOCK_IN, "Value")); + bke::node_add_link(*group, + *input_radius, + *bke::node_find_socket(*input_radius, SOCK_OUT, "Radius"), + *add, + *bke::node_find_socket(*add, SOCK_IN, "Value_001")); + bke::node_add_link(*group, + *add, + *bke::node_find_socket(*add, SOCK_OUT, "Value"), + *clamp_radius, + *bke::node_find_socket(*clamp_radius, SOCK_IN, "Value")); + bke::node_add_link(*group, + *clamp_radius, + *bke::node_find_socket(*clamp_radius, SOCK_OUT, "Result"), + *set_curve_radius, + *bke::node_find_socket(*set_curve_radius, SOCK_IN, "Radius")); LISTBASE_FOREACH (bNode *, node, &group->nodes) { - bke::node_set_selected(node, false); + bke::node_set_selected(*node, false); } return group; diff --git a/source/blender/blenkernel/intern/linestyle.cc b/source/blender/blenkernel/intern/linestyle.cc index ffddb6e0968..e80b4c12758 100644 --- a/source/blender/blenkernel/intern/linestyle.cc +++ b/source/blender/blenkernel/intern/linestyle.cc @@ -1936,30 +1936,30 @@ void BKE_linestyle_default_shader(const bContext *C, FreestyleLineStyle *linesty ntree = blender::bke::node_tree_add_tree_embedded( nullptr, &linestyle->id, "stroke_shader", "ShaderNodeTree"); - uv_along_stroke = blender::bke::node_add_static_node(C, ntree, SH_NODE_UVALONGSTROKE); + uv_along_stroke = blender::bke::node_add_static_node(C, *ntree, SH_NODE_UVALONGSTROKE); uv_along_stroke->location[0] = 0.0f; uv_along_stroke->location[1] = 300.0f; uv_along_stroke->custom1 = 0; /* use_tips */ - input_texture = blender::bke::node_add_static_node(C, ntree, SH_NODE_TEX_IMAGE); + input_texture = blender::bke::node_add_static_node(C, *ntree, SH_NODE_TEX_IMAGE); input_texture->location[0] = 200.0f; input_texture->location[1] = 300.0f; - output_linestyle = blender::bke::node_add_static_node(C, ntree, SH_NODE_OUTPUT_LINESTYLE); + output_linestyle = blender::bke::node_add_static_node(C, *ntree, SH_NODE_OUTPUT_LINESTYLE); output_linestyle->location[0] = 400.0f; output_linestyle->location[1] = 300.0f; output_linestyle->custom1 = MA_RAMP_BLEND; output_linestyle->custom2 = 0; /* use_clamp */ - blender::bke::node_set_active(ntree, input_texture); + blender::bke::node_set_active(*ntree, *input_texture); fromsock = static_cast(BLI_findlink(&uv_along_stroke->outputs, 0)); /* UV */ tosock = static_cast(BLI_findlink(&input_texture->inputs, 0)); /* UV */ - blender::bke::node_add_link(ntree, uv_along_stroke, fromsock, input_texture, tosock); + blender::bke::node_add_link(*ntree, *uv_along_stroke, *fromsock, *input_texture, *tosock); fromsock = static_cast(BLI_findlink(&input_texture->outputs, 0)); /* Color */ tosock = static_cast(BLI_findlink(&output_linestyle->inputs, 0)); /* Color */ - blender::bke::node_add_link(ntree, input_texture, fromsock, output_linestyle, tosock); + blender::bke::node_add_link(*ntree, *input_texture, *fromsock, *output_linestyle, *tosock); BKE_ntree_update_after_single_tree_change(*CTX_data_main(C), *ntree); } diff --git a/source/blender/blenkernel/intern/material.cc b/source/blender/blenkernel/intern/material.cc index 169a52fda24..0310b2a5b29 100644 --- a/source/blender/blenkernel/intern/material.cc +++ b/source/blender/blenkernel/intern/material.cc @@ -1655,7 +1655,7 @@ void BKE_texpaint_slot_refresh_cache(Scene *scene, Material *ma, const Object *o ma->texpaintslot = static_cast( MEM_callocN(sizeof(TexPaintSlot) * count, "texpaint_slots")); - bNode *active_node = blender::bke::node_get_active_paint_canvas(ma->nodetree); + bNode *active_node = blender::bke::node_get_active_paint_canvas(*ma->nodetree); fill_texpaint_slots_recursive(ma->nodetree, active_node, ob, ma, count, slot_filter); @@ -2030,24 +2030,24 @@ static void material_default_surface_init(Material *ma) nullptr, &ma->id, "Shader Nodetree", ntreeType_Shader->idname); ma->use_nodes = true; - bNode *principled = blender::bke::node_add_static_node(nullptr, ntree, SH_NODE_BSDF_PRINCIPLED); - bNodeSocket *base_color = blender::bke::node_find_socket(principled, SOCK_IN, "Base Color"); + bNode *principled = blender::bke::node_add_static_node(nullptr, *ntree, SH_NODE_BSDF_PRINCIPLED); + bNodeSocket *base_color = blender::bke::node_find_socket(*principled, SOCK_IN, "Base Color"); copy_v3_v3(((bNodeSocketValueRGBA *)base_color->default_value)->value, &ma->r); - bNode *output = blender::bke::node_add_static_node(nullptr, ntree, SH_NODE_OUTPUT_MATERIAL); + bNode *output = blender::bke::node_add_static_node(nullptr, *ntree, SH_NODE_OUTPUT_MATERIAL); - blender::bke::node_add_link(ntree, - principled, - blender::bke::node_find_socket(principled, SOCK_OUT, "BSDF"), - output, - blender::bke::node_find_socket(output, SOCK_IN, "Surface")); + blender::bke::node_add_link(*ntree, + *principled, + *blender::bke::node_find_socket(*principled, SOCK_OUT, "BSDF"), + *output, + *blender::bke::node_find_socket(*output, SOCK_IN, "Surface")); principled->location[0] = 10.0f; principled->location[1] = 300.0f; output->location[0] = 300.0f; output->location[1] = 300.0f; - blender::bke::node_set_active(ntree, output); + blender::bke::node_set_active(*ntree, *output); } static void material_default_volume_init(Material *ma) @@ -2059,21 +2059,21 @@ static void material_default_volume_init(Material *ma) ma->use_nodes = true; bNode *principled = blender::bke::node_add_static_node( - nullptr, ntree, SH_NODE_VOLUME_PRINCIPLED); - bNode *output = blender::bke::node_add_static_node(nullptr, ntree, SH_NODE_OUTPUT_MATERIAL); + nullptr, *ntree, SH_NODE_VOLUME_PRINCIPLED); + bNode *output = blender::bke::node_add_static_node(nullptr, *ntree, SH_NODE_OUTPUT_MATERIAL); - blender::bke::node_add_link(ntree, - principled, - blender::bke::node_find_socket(principled, SOCK_OUT, "Volume"), - output, - blender::bke::node_find_socket(output, SOCK_IN, "Volume")); + blender::bke::node_add_link(*ntree, + *principled, + *blender::bke::node_find_socket(*principled, SOCK_OUT, "Volume"), + *output, + *blender::bke::node_find_socket(*output, SOCK_IN, "Volume")); principled->location[0] = 10.0f; principled->location[1] = 300.0f; output->location[0] = 300.0f; output->location[1] = 300.0f; - blender::bke::node_set_active(ntree, output); + blender::bke::node_set_active(*ntree, *output); } static void material_default_holdout_init(Material *ma) @@ -2084,21 +2084,21 @@ static void material_default_holdout_init(Material *ma) nullptr, &ma->id, "Shader Nodetree", ntreeType_Shader->idname); ma->use_nodes = true; - bNode *holdout = blender::bke::node_add_static_node(nullptr, ntree, SH_NODE_HOLDOUT); - bNode *output = blender::bke::node_add_static_node(nullptr, ntree, SH_NODE_OUTPUT_MATERIAL); + bNode *holdout = blender::bke::node_add_static_node(nullptr, *ntree, SH_NODE_HOLDOUT); + bNode *output = blender::bke::node_add_static_node(nullptr, *ntree, SH_NODE_OUTPUT_MATERIAL); - blender::bke::node_add_link(ntree, - holdout, - blender::bke::node_find_socket(holdout, SOCK_OUT, "Holdout"), - output, - blender::bke::node_find_socket(output, SOCK_IN, "Surface")); + blender::bke::node_add_link(*ntree, + *holdout, + *blender::bke::node_find_socket(*holdout, SOCK_OUT, "Holdout"), + *output, + *blender::bke::node_find_socket(*output, SOCK_IN, "Surface")); holdout->location[0] = 10.0f; holdout->location[1] = 300.0f; output->location[0] = 300.0f; output->location[1] = 300.0f; - blender::bke::node_set_active(ntree, output); + blender::bke::node_set_active(*ntree, *output); } Material *BKE_material_default_empty() diff --git a/source/blender/blenkernel/intern/mesh_legacy_convert.cc b/source/blender/blenkernel/intern/mesh_legacy_convert.cc index 65f3438f22c..f0de440c80d 100644 --- a/source/blender/blenkernel/intern/mesh_legacy_convert.cc +++ b/source/blender/blenkernel/intern/mesh_legacy_convert.cc @@ -2139,10 +2139,10 @@ static bNodeTree *add_auto_smooth_node_tree(Main &bmain, Library *owner_library) angle_data.max = DEG2RADF(180.0f); angle_data.subtype = PROP_ANGLE; - bNode *group_output = node_add_node(nullptr, group, "NodeGroupOutput"); + bNode *group_output = node_add_node(nullptr, *group, "NodeGroupOutput"); group_output->location[0] = 480.0f; group_output->location[1] = -100.0f; - bNode *group_input_angle = node_add_node(nullptr, group, "NodeGroupInput"); + bNode *group_input_angle = node_add_node(nullptr, *group, "NodeGroupInput"); group_input_angle->location[0] = -420.0f; group_input_angle->location[1] = -300.0f; LISTBASE_FOREACH (bNodeSocket *, socket, &group_input_angle->outputs) { @@ -2150,7 +2150,7 @@ static bNodeTree *add_auto_smooth_node_tree(Main &bmain, Library *owner_library) socket->flag |= SOCK_HIDDEN; } } - bNode *group_input_mesh = node_add_node(nullptr, group, "NodeGroupInput"); + bNode *group_input_mesh = node_add_node(nullptr, *group, "NodeGroupInput"); group_input_mesh->location[0] = -60.0f; group_input_mesh->location[1] = -100.0f; LISTBASE_FOREACH (bNodeSocket *, socket, &group_input_mesh->outputs) { @@ -2158,81 +2158,81 @@ static bNodeTree *add_auto_smooth_node_tree(Main &bmain, Library *owner_library) socket->flag |= SOCK_HIDDEN; } } - bNode *shade_smooth_edge = node_add_node(nullptr, group, "GeometryNodeSetShadeSmooth"); + bNode *shade_smooth_edge = node_add_node(nullptr, *group, "GeometryNodeSetShadeSmooth"); shade_smooth_edge->custom1 = int16_t(bke::AttrDomain::Edge); shade_smooth_edge->location[0] = 120.0f; shade_smooth_edge->location[1] = -100.0f; - bNode *shade_smooth_face = node_add_node(nullptr, group, "GeometryNodeSetShadeSmooth"); + bNode *shade_smooth_face = node_add_node(nullptr, *group, "GeometryNodeSetShadeSmooth"); shade_smooth_face->custom1 = int16_t(bke::AttrDomain::Face); shade_smooth_face->location[0] = 300.0f; shade_smooth_face->location[1] = -100.0f; - bNode *edge_angle = node_add_node(nullptr, group, "GeometryNodeInputMeshEdgeAngle"); + bNode *edge_angle = node_add_node(nullptr, *group, "GeometryNodeInputMeshEdgeAngle"); edge_angle->location[0] = -420.0f; edge_angle->location[1] = -220.0f; - bNode *edge_smooth = node_add_node(nullptr, group, "GeometryNodeInputEdgeSmooth"); + bNode *edge_smooth = node_add_node(nullptr, *group, "GeometryNodeInputEdgeSmooth"); edge_smooth->location[0] = -60.0f; edge_smooth->location[1] = -160.0f; - bNode *face_smooth = node_add_node(nullptr, group, "GeometryNodeInputShadeSmooth"); + bNode *face_smooth = node_add_node(nullptr, *group, "GeometryNodeInputShadeSmooth"); face_smooth->location[0] = -240.0f; face_smooth->location[1] = -340.0f; - bNode *boolean_and = node_add_node(nullptr, group, "FunctionNodeBooleanMath"); + bNode *boolean_and = node_add_node(nullptr, *group, "FunctionNodeBooleanMath"); boolean_and->custom1 = NODE_BOOLEAN_MATH_AND; boolean_and->location[0] = -60.0f; boolean_and->location[1] = -220.0f; - bNode *less_than_or_equal = node_add_node(nullptr, group, "FunctionNodeCompare"); + bNode *less_than_or_equal = node_add_node(nullptr, *group, "FunctionNodeCompare"); static_cast(less_than_or_equal->storage)->operation = NODE_COMPARE_LESS_EQUAL; less_than_or_equal->location[0] = -240.0f; less_than_or_equal->location[1] = -180.0f; - node_add_link(group, - edge_angle, - node_find_socket(edge_angle, SOCK_OUT, "Unsigned Angle"), - less_than_or_equal, - node_find_socket(less_than_or_equal, SOCK_IN, "A")); - node_add_link(group, - shade_smooth_face, - node_find_socket(shade_smooth_face, SOCK_OUT, "Geometry"), - group_output, - node_find_socket(group_output, SOCK_IN, "Socket_0")); - node_add_link(group, - group_input_angle, - node_find_socket(group_input_angle, SOCK_OUT, "Socket_2"), - less_than_or_equal, - node_find_socket(less_than_or_equal, SOCK_IN, "B")); - node_add_link(group, - less_than_or_equal, - node_find_socket(less_than_or_equal, SOCK_OUT, "Result"), - boolean_and, - node_find_socket(boolean_and, SOCK_IN, "Boolean")); - node_add_link(group, - face_smooth, - node_find_socket(face_smooth, SOCK_OUT, "Smooth"), - boolean_and, - node_find_socket(boolean_and, SOCK_IN, "Boolean_001")); - node_add_link(group, - group_input_mesh, - node_find_socket(group_input_mesh, SOCK_OUT, "Socket_1"), - shade_smooth_edge, - node_find_socket(shade_smooth_edge, SOCK_IN, "Geometry")); - node_add_link(group, - edge_smooth, - node_find_socket(edge_smooth, SOCK_OUT, "Smooth"), - shade_smooth_edge, - node_find_socket(shade_smooth_edge, SOCK_IN, "Selection")); - node_add_link(group, - shade_smooth_edge, - node_find_socket(shade_smooth_edge, SOCK_OUT, "Geometry"), - shade_smooth_face, - node_find_socket(shade_smooth_face, SOCK_IN, "Geometry")); - node_add_link(group, - boolean_and, - node_find_socket(boolean_and, SOCK_OUT, "Boolean"), - shade_smooth_edge, - node_find_socket(shade_smooth_edge, SOCK_IN, "Shade Smooth")); + node_add_link(*group, + *edge_angle, + *node_find_socket(*edge_angle, SOCK_OUT, "Unsigned Angle"), + *less_than_or_equal, + *node_find_socket(*less_than_or_equal, SOCK_IN, "A")); + node_add_link(*group, + *shade_smooth_face, + *node_find_socket(*shade_smooth_face, SOCK_OUT, "Geometry"), + *group_output, + *node_find_socket(*group_output, SOCK_IN, "Socket_0")); + node_add_link(*group, + *group_input_angle, + *node_find_socket(*group_input_angle, SOCK_OUT, "Socket_2"), + *less_than_or_equal, + *node_find_socket(*less_than_or_equal, SOCK_IN, "B")); + node_add_link(*group, + *less_than_or_equal, + *node_find_socket(*less_than_or_equal, SOCK_OUT, "Result"), + *boolean_and, + *node_find_socket(*boolean_and, SOCK_IN, "Boolean")); + node_add_link(*group, + *face_smooth, + *node_find_socket(*face_smooth, SOCK_OUT, "Smooth"), + *boolean_and, + *node_find_socket(*boolean_and, SOCK_IN, "Boolean_001")); + node_add_link(*group, + *group_input_mesh, + *node_find_socket(*group_input_mesh, SOCK_OUT, "Socket_1"), + *shade_smooth_edge, + *node_find_socket(*shade_smooth_edge, SOCK_IN, "Geometry")); + node_add_link(*group, + *edge_smooth, + *node_find_socket(*edge_smooth, SOCK_OUT, "Smooth"), + *shade_smooth_edge, + *node_find_socket(*shade_smooth_edge, SOCK_IN, "Selection")); + node_add_link(*group, + *shade_smooth_edge, + *node_find_socket(*shade_smooth_edge, SOCK_OUT, "Geometry"), + *shade_smooth_face, + *node_find_socket(*shade_smooth_face, SOCK_IN, "Geometry")); + node_add_link(*group, + *boolean_and, + *node_find_socket(*boolean_and, SOCK_OUT, "Boolean"), + *shade_smooth_edge, + *node_find_socket(*shade_smooth_edge, SOCK_IN, "Shade Smooth")); LISTBASE_FOREACH (bNode *, node, &group->nodes) { - node_set_selected(node, false); + node_set_selected(*node, false); } BKE_ntree_update_after_single_tree_change(bmain, *group); diff --git a/source/blender/blenkernel/intern/node.cc b/source/blender/blenkernel/intern/node.cc index c47ac7121db..34b7e68ff75 100644 --- a/source/blender/blenkernel/intern/node.cc +++ b/source/blender/blenkernel/intern/node.cc @@ -183,7 +183,7 @@ static void ntree_copy_data(Main * /*bmain*/, } for (bNode *node : ntree_dst->all_nodes()) { - node_declaration_ensure(ntree_dst, node); + node_declaration_ensure(*ntree_dst, *node); } ntree_dst->tree_interface.copy_data(ntree_src->tree_interface, flag); @@ -270,7 +270,7 @@ static void ntree_free_data(ID *id) BLI_freelistN(&ntree->links); LISTBASE_FOREACH_MUTABLE (bNode *, node, &ntree->nodes) { - node_free_node(ntree, node); + node_free_node(ntree, *node); } ntree->tree_interface.free_data(); @@ -1085,7 +1085,7 @@ void node_tree_blend_read_data(BlendDataReader *reader, ID *owner_id, bNodeTree /* Create the `nodes_by_id` cache eagerly so it can be expected to be valid. Because * we create it here we also have to check for zero identifiers from previous versions. */ if (node->identifier == 0 || ntree->runtime->nodes_by_id.contains_as(node->identifier)) { - node_unique_id(ntree, node); + node_unique_id(*ntree, *node); } else { ntree->runtime->nodes_by_id.add_new(node); @@ -1289,7 +1289,7 @@ static void ntree_blend_read_after_liblink(BlendLibReader *reader, ID *id) * first versioning that can change types still without functions that * update the `typeinfo` pointers. Versioning after lib linking needs * these top be valid. */ - node_tree_set_type(nullptr, ntree); + node_tree_set_type(nullptr, *ntree); /* For nodes with static socket layout, add/remove sockets as needed * to match the static layout. */ @@ -1461,7 +1461,7 @@ static void node_init(const bContext *C, bNodeTree *ntree, bNode *node) * This solution may be a bit rougher than nodeLabel()'s returned string, but it's simpler * than adding "do_translate" flags to this func (and labelfunc() as well). */ DATA_(ntype->ui_name).copy_utf8_truncated(node->name); - node_unique_name(ntree, node); + node_unique_name(*ntree, *node); /* Generally sockets should be added after the initialization, because the set of sockets might * depend on node properties. */ @@ -1602,21 +1602,21 @@ static void update_typeinfo(Main *bmain, FOREACH_NODETREE_END; } -void node_tree_set_type(const bContext *C, bNodeTree *ntree) +void node_tree_set_type(const bContext *C, bNodeTree &ntree) { - ntree_set_typeinfo(ntree, node_tree_type_find(ntree->idname)); + ntree_set_typeinfo(&ntree, node_tree_type_find(ntree.idname)); - for (bNode *node : ntree->all_nodes()) { + for (bNode *node : ntree.all_nodes()) { /* Set socket typeinfo first because node initialization may rely on socket typeinfo for * generating declarations. */ LISTBASE_FOREACH (bNodeSocket *, sock, &node->inputs) { - node_socket_set_typeinfo(ntree, sock, node_socket_type_find(sock->idname)); + node_socket_set_typeinfo(&ntree, sock, node_socket_type_find(sock->idname)); } LISTBASE_FOREACH (bNodeSocket *, sock, &node->outputs) { - node_socket_set_typeinfo(ntree, sock, node_socket_type_find(sock->idname)); + node_socket_set_typeinfo(&ntree, sock, node_socket_type_find(sock->idname)); } - node_set_typeinfo(C, ntree, node, node_type_find(node->idname)); + node_set_typeinfo(C, &ntree, node, node_type_find(node->idname)); } } @@ -1688,13 +1688,13 @@ static void defer_free_socket_type(bNodeSocketType *stype) }); } -void node_tree_type_add(bNodeTreeType *nt) +void node_tree_type_add(bNodeTreeType &nt) { - get_node_tree_type_map().add(nt); + get_node_tree_type_map().add(&nt); /* XXX pass Main to register function? */ /* Probably not. It is pretty much expected we want to update G_MAIN here I think - * or we'd want to update *all* active Mains, which we cannot do anyway currently. */ - update_typeinfo(G_MAIN, nullptr, nt, nullptr, nullptr, false); + update_typeinfo(G_MAIN, nullptr, &nt, nullptr, nullptr, false); } static void ntree_free_type(void *treetype_v) @@ -1711,15 +1711,15 @@ static void ntree_free_type(void *treetype_v) defer_free_tree_type(treetype); } -void node_tree_type_free_link(const bNodeTreeType *nt) +void node_tree_type_free_link(const bNodeTreeType &nt) { - get_node_tree_type_map().remove(const_cast(nt)); - ntree_free_type(const_cast(nt)); + get_node_tree_type_map().remove(const_cast(&nt)); + ntree_free_type(const_cast(&nt)); } -bool node_tree_is_registered(const bNodeTree *ntree) +bool node_tree_is_registered(const bNodeTree &ntree) { - return (ntree->typeinfo != &NodeTreeTypeUndefined); + return (ntree.typeinfo != &NodeTreeTypeUndefined); } Span node_tree_types_get() @@ -1764,35 +1764,35 @@ static void node_free_type(void *nodetype_v) defer_free_node_type(nodetype); } -void node_register_type(bNodeType *nt) +void node_register_type(bNodeType &nt) { /* debug only: basic verification of registered types */ - BLI_assert(!nt->idname.empty()); - BLI_assert(nt->poll != nullptr); + BLI_assert(!nt.idname.empty()); + BLI_assert(nt.poll != nullptr); - RNA_def_struct_ui_text(nt->rna_ext.srna, nt->ui_name.c_str(), nt->ui_description.c_str()); + RNA_def_struct_ui_text(nt.rna_ext.srna, nt.ui_name.c_str(), nt.ui_description.c_str()); - if (!nt->enum_name_legacy) { + if (!nt.enum_name_legacy) { /* For new nodes, use the idname as a unique identifier. */ - nt->enum_name_legacy = nt->idname.c_str(); + nt.enum_name_legacy = nt.idname.c_str(); } - if (nt->declare) { - nt->static_declaration = new nodes::NodeDeclaration(); - nodes::build_node_declaration(*nt, *nt->static_declaration, nullptr, nullptr); + if (nt.declare) { + nt.static_declaration = new nodes::NodeDeclaration(); + nodes::build_node_declaration(nt, *nt.static_declaration, nullptr, nullptr); } - get_node_type_map().add_new(nt); + get_node_type_map().add_new(&nt); /* XXX pass Main to register function? */ /* Probably not. It is pretty much expected we want to update G_MAIN here I think - * or we'd want to update *all* active Mains, which we cannot do anyway currently. */ - update_typeinfo(G_MAIN, nullptr, nullptr, nt, nullptr, false); + update_typeinfo(G_MAIN, nullptr, nullptr, &nt, nullptr, false); } -void node_unregister_type(bNodeType *nt) +void node_unregister_type(bNodeType &nt) { - get_node_type_map().remove(nt); - node_free_type(nt); + get_node_type_map().remove(&nt); + node_free_type(&nt); } Span node_types_get() @@ -1800,19 +1800,19 @@ Span node_types_get() return get_node_type_map().as_span(); } -void node_register_alias(bNodeType *nt, const StringRef alias) +void node_register_alias(bNodeType &nt, const StringRef alias) { - get_node_type_alias_map().add_new(alias, nt->idname); + get_node_type_alias_map().add_new(alias, nt.idname); } -bool node_type_is_undefined(const bNode *node) +bool node_type_is_undefined(const bNode &node) { - if (node->typeinfo == &NodeTypeUndefined) { + if (node.typeinfo == &NodeTypeUndefined) { return true; } - if (node->is_group()) { - const ID *group_tree = node->id; + if (node.is_group()) { + const ID *group_tree = node.id; if (group_tree == nullptr) { return false; } @@ -1855,33 +1855,33 @@ static void node_free_socket_type(void *socktype_v) defer_free_socket_type(socktype); } -void node_register_socket_type(bNodeSocketType *st) +void node_register_socket_type(bNodeSocketType &st) { - get_socket_type_map().add(st); + get_socket_type_map().add(&st); /* XXX pass Main to register function? */ /* Probably not. It is pretty much expected we want to update G_MAIN here I think - * or we'd want to update *all* active Mains, which we cannot do anyway currently. */ - update_typeinfo(G_MAIN, nullptr, nullptr, nullptr, st, false); + update_typeinfo(G_MAIN, nullptr, nullptr, nullptr, &st, false); } -void node_unregister_socket_type(bNodeSocketType *st) +void node_unregister_socket_type(bNodeSocketType &st) { - get_socket_type_map().remove(st); - node_free_socket_type(st); + get_socket_type_map().remove(&st); + node_free_socket_type(&st); } -bool node_socket_is_registered(const bNodeSocket *sock) +bool node_socket_is_registered(const bNodeSocket &sock) { - return (sock->typeinfo != &NodeSocketTypeUndefined); + return (sock.typeinfo != &NodeSocketTypeUndefined); } -StringRefNull node_socket_type_label(const bNodeSocketType *stype) +StringRefNull node_socket_type_label(const bNodeSocketType &stype) { /* Use socket type name as a fallback if label is undefined. */ - if (stype->label[0] == '\0') { - return RNA_struct_ui_name(stype->ext_socket.srna); + if (stype.label[0] == '\0') { + return RNA_struct_ui_name(stype.ext_socket.srna); } - return stype->label; + return stype.label; } StringRefNull node_socket_sub_type_label(int subtype) @@ -1893,11 +1893,11 @@ StringRefNull node_socket_sub_type_label(int subtype) return ""; } -bNodeSocket *node_find_socket(bNode *node, +bNodeSocket *node_find_socket(bNode &node, const eNodeSocketInOut in_out, const StringRef identifier) { - const ListBase *sockets = (in_out == SOCK_IN) ? &node->inputs : &node->outputs; + const ListBase *sockets = (in_out == SOCK_IN) ? &node.inputs : &node.outputs; LISTBASE_FOREACH (bNodeSocket *, sock, sockets) { if (sock->identifier == identifier) { return sock; @@ -1906,12 +1906,12 @@ bNodeSocket *node_find_socket(bNode *node, return nullptr; } -const bNodeSocket *node_find_socket(const bNode *node, +const bNodeSocket *node_find_socket(const bNode &node, const eNodeSocketInOut in_out, const StringRef identifier) { /* Reuse the implementation of the mutable accessor. */ - return node_find_socket(const_cast(node), in_out, identifier); + return node_find_socket(*const_cast(&node), in_out, identifier); } bNodeSocket *node_find_enabled_socket(bNode &node, @@ -2084,9 +2084,9 @@ static bool socket_id_user_decrement(bNodeSocket *sock) return false; } -void node_modify_socket_type(bNodeTree *ntree, - bNode * /*node*/, - bNodeSocket *sock, +void node_modify_socket_type(bNodeTree &ntree, + bNode & /*node*/, + bNodeSocket &sock, const StringRefNull idname) { bNodeSocketType *socktype = node_socket_type_find(idname); @@ -2096,32 +2096,32 @@ void node_modify_socket_type(bNodeTree *ntree, return; } - if (sock->default_value) { - if (sock->type != socktype->type) { + if (sock.default_value) { + if (sock.type != socktype->type) { /* Only reallocate the default value if the type changed so that UI data like min and max * isn't removed. This assumes that the default value is stored in the same format for all * socket types with the same #eNodeSocketDatatype. */ - socket_id_user_decrement(sock); - MEM_freeN(sock->default_value); - sock->default_value = nullptr; + socket_id_user_decrement(&sock); + MEM_freeN(sock.default_value); + sock.default_value = nullptr; } else { /* Update the socket subtype when the storage isn't freed and recreated. */ - switch (eNodeSocketDatatype(sock->type)) { + switch (eNodeSocketDatatype(sock.type)) { case SOCK_FLOAT: { - sock->default_value_typed()->subtype = socktype->subtype; + sock.default_value_typed()->subtype = socktype->subtype; break; } case SOCK_VECTOR: { - sock->default_value_typed()->subtype = socktype->subtype; + sock.default_value_typed()->subtype = socktype->subtype; break; } case SOCK_INT: { - sock->default_value_typed()->subtype = socktype->subtype; + sock.default_value_typed()->subtype = socktype->subtype; break; } case SOCK_STRING: { - sock->default_value_typed()->subtype = socktype->subtype; + sock.default_value_typed()->subtype = socktype->subtype; break; } case SOCK_RGBA: @@ -2142,8 +2142,8 @@ void node_modify_socket_type(bNodeTree *ntree, } } - idname.copy_utf8_truncated(sock->idname); - node_socket_set_typeinfo(ntree, sock, socktype); + idname.copy_utf8_truncated(sock.idname); + node_socket_set_typeinfo(&ntree, &sock, socktype); } void node_modify_socket_type_static( @@ -2156,38 +2156,38 @@ void node_modify_socket_type_static( return; } - node_modify_socket_type(ntree, node, sock, *idname); + node_modify_socket_type(*ntree, *node, *sock, *idname); } -bNodeSocket *node_add_socket(bNodeTree *ntree, - bNode *node, +bNodeSocket *node_add_socket(bNodeTree &ntree, + bNode &node, const eNodeSocketInOut in_out, const StringRefNull idname, const StringRefNull identifier, const StringRefNull name) { - BLI_assert(!node->is_frame()); - BLI_assert(!(in_out == SOCK_IN && node->is_group_input())); - BLI_assert(!(in_out == SOCK_OUT && node->is_group_output())); + BLI_assert(!node.is_frame()); + BLI_assert(!(in_out == SOCK_IN && node.is_group_input())); + BLI_assert(!(in_out == SOCK_OUT && node.is_group_output())); - ListBase *lb = (in_out == SOCK_IN ? &node->inputs : &node->outputs); - bNodeSocket *sock = make_socket(ntree, node, in_out, lb, idname, identifier, name); + ListBase *lb = (in_out == SOCK_IN ? &node.inputs : &node.outputs); + bNodeSocket *sock = make_socket(&ntree, &node, in_out, lb, idname, identifier, name); BLI_remlink(lb, sock); /* does nothing for new socket */ BLI_addtail(lb, sock); - BKE_ntree_update_tag_socket_new(ntree, sock); + BKE_ntree_update_tag_socket_new(&ntree, sock); return sock; } -bool node_is_static_socket_type(const bNodeSocketType *stype) +bool node_is_static_socket_type(const bNodeSocketType &stype) { /* * Cannot rely on type==SOCK_CUSTOM here, because type is 0 by default * and can be changed on custom sockets. */ - return RNA_struct_is_a(stype->ext_socket.srna, &RNA_NodeSocketStandard); + return RNA_struct_is_a(stype.ext_socket.srna, &RNA_NodeSocketStandard); } std::optional node_static_socket_type(const int type, const int subtype) @@ -2424,8 +2424,8 @@ std::optional node_static_socket_label(const int type, const int return std::nullopt; } -bNodeSocket *node_add_static_socket(bNodeTree *ntree, - bNode *node, +bNodeSocket *node_add_static_socket(bNodeTree &ntree, + bNode &node, eNodeSocketInOut in_out, int type, int subtype, @@ -2470,42 +2470,42 @@ static void node_socket_free(bNodeSocket *sock, const bool do_id_user) MEM_delete(sock->runtime); } -void node_remove_socket(bNodeTree *ntree, bNode *node, bNodeSocket *sock) +void node_remove_socket(bNodeTree &ntree, bNode &node, bNodeSocket &sock) { node_remove_socket_ex(ntree, node, sock, true); } -void node_remove_socket_ex(bNodeTree *ntree, bNode *node, bNodeSocket *sock, const bool do_id_user) +void node_remove_socket_ex(bNodeTree &ntree, bNode &node, bNodeSocket &sock, const bool do_id_user) { - LISTBASE_FOREACH_MUTABLE (bNodeLink *, link, &ntree->links) { - if (link->fromsock == sock || link->tosock == sock) { - node_remove_link(ntree, link); + LISTBASE_FOREACH_MUTABLE (bNodeLink *, link, &ntree.links) { + if (link->fromsock == &sock || link->tosock == &sock) { + node_remove_link(&ntree, *link); } } - for (const int64_t i : node->runtime->internal_links.index_range()) { - const bNodeLink &link = node->runtime->internal_links[i]; - if (link.fromsock == sock || link.tosock == sock) { - node->runtime->internal_links.remove_and_reorder(i); - BKE_ntree_update_tag_node_internal_link(ntree, node); + for (const int64_t i : node.runtime->internal_links.index_range()) { + const bNodeLink &link = node.runtime->internal_links[i]; + if (link.fromsock == &sock || link.tosock == &sock) { + node.runtime->internal_links.remove_and_reorder(i); + BKE_ntree_update_tag_node_internal_link(&ntree, &node); break; } } /* this is fast, this way we don't need an in_out argument */ - BLI_remlink(&node->inputs, sock); - BLI_remlink(&node->outputs, sock); + BLI_remlink(&node.inputs, &sock); + BLI_remlink(&node.outputs, &sock); - node_socket_free(sock, do_id_user); - MEM_freeN(sock); + node_socket_free(&sock, do_id_user); + MEM_freeN(&sock); - BKE_ntree_update_tag_socket_removed(ntree); + BKE_ntree_update_tag_socket_removed(&ntree); } -bNode *node_find_node_by_name(bNodeTree *ntree, const StringRefNull name) +bNode *node_find_node_by_name(bNodeTree &ntree, const StringRefNull name) { return reinterpret_cast( - BLI_findstring(&ntree->nodes, name.c_str(), offsetof(bNode, name))); + BLI_findstring(&ntree.nodes, name.c_str(), offsetof(bNode, name))); } bNode &node_find_node(bNodeTree &ntree, bNodeSocket &socket) @@ -2545,9 +2545,9 @@ const bNodeTreeInterfaceSocket *node_find_interface_input_by_identifier(const bN return nullptr; } -bNode *node_find_root_parent(bNode *node) +bNode *node_find_root_parent(bNode &node) { - bNode *parent_iter = node; + bNode *parent_iter = &node; while (parent_iter->parent != nullptr) { parent_iter = parent_iter->parent; } @@ -2557,10 +2557,10 @@ bNode *node_find_root_parent(bNode *node) return parent_iter; } -bool node_is_parent_and_child(const bNode *parent, const bNode *child) +bool node_is_parent_and_child(const bNode &parent, const bNode &child) { - for (const bNode *child_iter = child; child_iter; child_iter = child_iter->parent) { - if (child_iter == parent) { + for (const bNode *child_iter = &child; child_iter; child_iter = child_iter->parent) { + if (child_iter == &parent) { return true; } } @@ -2659,13 +2659,13 @@ void node_parents_iterator(bNode *node, bool (*callback)(bNode *, void *), void } } -void node_unique_name(bNodeTree *ntree, bNode *node) +void node_unique_name(bNodeTree &ntree, bNode &node) { BLI_uniquename( - &ntree->nodes, node, DATA_("Node"), '.', offsetof(bNode, name), sizeof(node->name)); + &ntree.nodes, &node, DATA_("Node"), '.', offsetof(bNode, name), sizeof(node.name)); } -void node_unique_id(bNodeTree *ntree, bNode *node) +void node_unique_id(bNodeTree &ntree, bNode &node) { /* Use a pointer cast to avoid overflow warnings. */ const double time = BLI_time_now_seconds() * 1000000.0; @@ -2673,33 +2673,33 @@ void node_unique_id(bNodeTree *ntree, bNode *node) /* In the unlikely case that the random ID doesn't match, choose a new one until it does. */ int32_t new_id = id_rng.get_int32(); - while (ntree->runtime->nodes_by_id.contains_as(new_id) || new_id <= 0) { + while (ntree.runtime->nodes_by_id.contains_as(new_id) || new_id <= 0) { new_id = id_rng.get_int32(); } - node->identifier = new_id; - ntree->runtime->nodes_by_id.add_new(node); - node->runtime->index_in_tree = ntree->runtime->nodes_by_id.index_range().last(); - BLI_assert(node->runtime->index_in_tree == ntree->runtime->nodes_by_id.index_of(node)); + node.identifier = new_id; + ntree.runtime->nodes_by_id.add_new(&node); + node.runtime->index_in_tree = ntree.runtime->nodes_by_id.index_range().last(); + BLI_assert(node.runtime->index_in_tree == ntree.runtime->nodes_by_id.index_of(&node)); } -bNode *node_add_node(const bContext *C, bNodeTree *ntree, const StringRef idname) +bNode *node_add_node(const bContext *C, bNodeTree &ntree, const StringRef idname) { bNode *node = MEM_cnew(__func__); node->runtime = MEM_new(__func__); - BLI_addtail(&ntree->nodes, node); - node_unique_id(ntree, node); - node->ui_order = ntree->all_nodes().size(); + BLI_addtail(&ntree.nodes, node); + node_unique_id(ntree, *node); + node->ui_order = ntree.all_nodes().size(); idname.copy_utf8_truncated(node->idname); - node_set_typeinfo(C, ntree, node, node_type_find(idname)); + node_set_typeinfo(C, &ntree, node, node_type_find(idname)); - BKE_ntree_update_tag_node_new(ntree, node); + BKE_ntree_update_tag_node_new(&ntree, node); return node; } -bNode *node_add_static_node(const bContext *C, bNodeTree *ntree, const int type) +bNode *node_add_static_node(const bContext *C, bNodeTree &ntree, const int type) { std::optional idname; @@ -2711,7 +2711,7 @@ bNode *node_add_static_node(const bContext *C, bNodeTree *ntree, const int type) } const char *disabled_hint; - if (ntype->poll && ntype->poll(ntype, ntree, &disabled_hint)) { + if (ntype->poll && ntype->poll(ntype, &ntree, &disabled_hint)) { idname = ntype->idname; break; } @@ -2766,8 +2766,8 @@ bNode *node_copy_with_mapping(bNodeTree *dst_tree, /* Can be called for nodes outside a node tree (e.g. clipboard). */ if (dst_tree) { if (use_unique) { - node_unique_name(dst_tree, node_dst); - node_unique_id(dst_tree, node_dst); + node_unique_name(*dst_tree, *node_dst); + node_unique_id(*dst_tree, *node_dst); } BLI_addtail(&dst_tree->nodes, node_dst); } @@ -2969,95 +2969,86 @@ static int node_count_links(const bNodeTree *ntree, const bNodeSocket *socket) return count; } -bNodeLink *node_add_link( - bNodeTree *ntree, bNode *fromnode, bNodeSocket *fromsock, bNode *tonode, bNodeSocket *tosock) +bNodeLink &node_add_link( + bNodeTree &ntree, bNode &fromnode, bNodeSocket &fromsock, bNode &tonode, bNodeSocket &tosock) { - BLI_assert(fromnode); - BLI_assert(tonode); - BLI_assert(ntree->all_nodes().contains(fromnode)); - BLI_assert(ntree->all_nodes().contains(tonode)); + BLI_assert(ntree.all_nodes().contains(&fromnode)); + BLI_assert(ntree.all_nodes().contains(&tonode)); bNodeLink *link = nullptr; - if (eNodeSocketInOut(fromsock->in_out) == SOCK_OUT && - eNodeSocketInOut(tosock->in_out) == SOCK_IN) + if (eNodeSocketInOut(fromsock.in_out) == SOCK_OUT && eNodeSocketInOut(tosock.in_out) == SOCK_IN) { link = MEM_cnew(__func__); - if (ntree) { - BLI_addtail(&ntree->links, link); - } - link->fromnode = fromnode; - link->fromsock = fromsock; - link->tonode = tonode; - link->tosock = tosock; - } - else if (eNodeSocketInOut(fromsock->in_out) == SOCK_IN && - eNodeSocketInOut(tosock->in_out) == SOCK_OUT) + BLI_addtail(&ntree.links, link); + link->fromnode = &fromnode; + link->fromsock = &fromsock; + link->tonode = &tonode; + link->tosock = &tosock; + } + else if (eNodeSocketInOut(fromsock.in_out) == SOCK_IN && + eNodeSocketInOut(tosock.in_out) == SOCK_OUT) { /* OK but flip */ link = MEM_cnew(__func__); - if (ntree) { - BLI_addtail(&ntree->links, link); - } - link->fromnode = tonode; - link->fromsock = tosock; - link->tonode = fromnode; - link->tosock = fromsock; + BLI_addtail(&ntree.links, link); + link->fromnode = &tonode; + link->fromsock = &tosock; + link->tonode = &fromnode; + link->tosock = &fromsock; } - if (ntree) { - BKE_ntree_update_tag_link_added(ntree, link); - } + BKE_ntree_update_tag_link_added(&ntree, link); if (link != nullptr && link->tosock->is_multi_input()) { - link->multi_input_sort_id = node_count_links(ntree, link->tosock) - 1; + link->multi_input_sort_id = node_count_links(&ntree, link->tosock) - 1; } - return link; + return *link; } -void node_remove_link(bNodeTree *ntree, bNodeLink *link) +void node_remove_link(bNodeTree *ntree, bNodeLink &link) { /* Can be called for links outside a node tree (e.g. clipboard). */ if (ntree) { - BLI_remlink(&ntree->links, link); + BLI_remlink(&ntree->links, &link); } - if (link->tosock) { - link->tosock->link = nullptr; + if (link.tosock) { + link.tosock->link = nullptr; } - MEM_freeN(link); + MEM_freeN(&link); if (ntree) { BKE_ntree_update_tag_link_removed(ntree); } } -void node_link_set_mute(bNodeTree *ntree, bNodeLink *link, const bool muted) +void node_link_set_mute(bNodeTree &ntree, bNodeLink &link, const bool muted) { - const bool was_muted = link->is_muted(); - SET_FLAG_FROM_TEST(link->flag, muted, NODE_LINK_MUTED); + const bool was_muted = link.is_muted(); + SET_FLAG_FROM_TEST(link.flag, muted, NODE_LINK_MUTED); if (muted != was_muted) { - BKE_ntree_update_tag_link_mute(ntree, link); + BKE_ntree_update_tag_link_mute(&ntree, &link); } } -void node_remove_socket_links(bNodeTree *ntree, bNodeSocket *sock) +void node_remove_socket_links(bNodeTree &ntree, bNodeSocket &sock) { - LISTBASE_FOREACH_MUTABLE (bNodeLink *, link, &ntree->links) { - if (link->fromsock == sock || link->tosock == sock) { - node_remove_link(ntree, link); + LISTBASE_FOREACH_MUTABLE (bNodeLink *, link, &ntree.links) { + if (link->fromsock == &sock || link->tosock == &sock) { + node_remove_link(&ntree, *link); } } } -bool node_link_is_hidden(const bNodeLink *link) +bool node_link_is_hidden(const bNodeLink &link) { - return !(link->fromsock->is_visible() && link->tosock->is_visible()); + return !(link.fromsock->is_visible() && link.tosock->is_visible()); } -bool node_link_is_selected(const bNodeLink *link) +bool node_link_is_selected(const bNodeLink &link) { - return (link->fromnode->flag & NODE_SELECT) || (link->tonode->flag & NODE_SELECT); + return (link.fromnode->flag & NODE_SELECT) || (link.tonode->flag & NODE_SELECT); } /* Adjust the indices of links connected to the given multi input socket after deleting the link at @@ -3076,19 +3067,19 @@ static void adjust_multi_input_indices_after_removed_link(bNodeTree *ntree, } } -void node_internal_relink(bNodeTree *ntree, bNode *node) +void node_internal_relink(bNodeTree &ntree, bNode &node) { /* store link pointers in output sockets, for efficient lookup */ - for (bNodeLink &link : node->runtime->internal_links) { + for (bNodeLink &link : node.runtime->internal_links) { link.tosock->link = &link; } Vector duplicate_links_to_remove; /* redirect downstream links */ - LISTBASE_FOREACH_MUTABLE (bNodeLink *, link, &ntree->links) { + LISTBASE_FOREACH_MUTABLE (bNodeLink *, link, &ntree.links) { /* do we have internal link? */ - if (link->fromnode != node) { + if (link->fromnode != &node) { continue; } @@ -3098,20 +3089,20 @@ void node_internal_relink(bNodeTree *ntree, bNode *node) if (fromlink == nullptr) { if (link->tosock->is_multi_input()) { adjust_multi_input_indices_after_removed_link( - ntree, link->tosock, link->multi_input_sort_id); + &ntree, link->tosock, link->multi_input_sort_id); } - node_remove_link(ntree, link); + node_remove_link(&ntree, *link); continue; } if (link->tosock->is_multi_input()) { /* remove the link that would be the same as the relinked one */ - LISTBASE_FOREACH_MUTABLE (bNodeLink *, link_to_compare, &ntree->links) { + LISTBASE_FOREACH_MUTABLE (bNodeLink *, link_to_compare, &ntree.links) { if (link_to_compare->fromsock == fromlink->fromsock && link_to_compare->tosock == link->tosock) { adjust_multi_input_indices_after_removed_link( - ntree, link_to_compare->tosock, link_to_compare->multi_input_sort_id); + &ntree, link_to_compare->tosock, link_to_compare->multi_input_sort_id); duplicate_links_to_remove.append_non_duplicates(link_to_compare); } } @@ -3131,55 +3122,55 @@ void node_internal_relink(bNodeTree *ntree, bNode *node) link->flag |= NODE_LINK_MUTED; } - BKE_ntree_update_tag_link_changed(ntree); + BKE_ntree_update_tag_link_changed(&ntree); } for (bNodeLink *link : duplicate_links_to_remove) { - node_remove_link(ntree, link); + node_remove_link(&ntree, *link); } /* remove remaining upstream links */ - LISTBASE_FOREACH_MUTABLE (bNodeLink *, link, &ntree->links) { - if (link->tonode == node) { - node_remove_link(ntree, link); + LISTBASE_FOREACH_MUTABLE (bNodeLink *, link, &ntree.links) { + if (link->tonode == &node) { + node_remove_link(&ntree, *link); } } } -void node_attach_node(bNodeTree *ntree, bNode *node, bNode *parent) +void node_attach_node(bNodeTree &ntree, bNode &node, bNode &parent) { - BLI_assert(parent->is_frame()); + BLI_assert(parent.is_frame()); BLI_assert(!node_is_parent_and_child(parent, node)); - node->parent = parent; - BKE_ntree_update_tag_parent_change(ntree, node); + node.parent = &parent; + BKE_ntree_update_tag_parent_change(&ntree, &node); } -void node_detach_node(bNodeTree *ntree, bNode *node) +void node_detach_node(bNodeTree &ntree, bNode &node) { - if (node->parent) { - BLI_assert(node->parent->is_frame()); - node->parent = nullptr; - BKE_ntree_update_tag_parent_change(ntree, node); + if (node.parent) { + BLI_assert(node.parent->is_frame()); + node.parent = nullptr; + BKE_ntree_update_tag_parent_change(&ntree, &node); } } -void node_position_relative(bNode *from_node, - const bNode *to_node, - const bNodeSocket *from_sock, - const bNodeSocket *to_sock) +void node_position_relative(bNode &from_node, + const bNode &to_node, + const bNodeSocket &from_sock, + const bNodeSocket &to_sock) { float offset_x; int tot_sock_idx; /* Socket to plug into. */ - if (eNodeSocketInOut(to_sock->in_out) == SOCK_IN) { - offset_x = -(from_node->typeinfo->width + 50); - tot_sock_idx = BLI_listbase_count(&to_node->outputs); - tot_sock_idx += BLI_findindex(&to_node->inputs, to_sock); + if (eNodeSocketInOut(to_sock.in_out) == SOCK_IN) { + offset_x = -(from_node.typeinfo->width + 50); + tot_sock_idx = BLI_listbase_count(&to_node.outputs); + tot_sock_idx += BLI_findindex(&to_node.inputs, &to_sock); } else { - offset_x = to_node->typeinfo->width + 50; - tot_sock_idx = BLI_findindex(&to_node->outputs, to_sock); + offset_x = to_node.typeinfo->width + 50; + tot_sock_idx = BLI_findindex(&to_node.outputs, &to_sock); } BLI_assert(tot_sock_idx != -1); @@ -3187,31 +3178,29 @@ void node_position_relative(bNode *from_node, float offset_y = U.widget_unit * tot_sock_idx; /* Output socket. */ - if (from_sock) { - if (eNodeSocketInOut(from_sock->in_out) == SOCK_IN) { - tot_sock_idx = BLI_listbase_count(&from_node->outputs); - tot_sock_idx += BLI_findindex(&from_node->inputs, from_sock); - } - else { - tot_sock_idx = BLI_findindex(&from_node->outputs, from_sock); - } + if (eNodeSocketInOut(from_sock.in_out) == SOCK_IN) { + tot_sock_idx = BLI_listbase_count(&from_node.outputs); + tot_sock_idx += BLI_findindex(&from_node.inputs, &from_sock); + } + else { + tot_sock_idx = BLI_findindex(&from_node.outputs, &from_sock); } BLI_assert(tot_sock_idx != -1); offset_y -= U.widget_unit * tot_sock_idx; - from_node->location[0] = to_node->location[0] + offset_x; - from_node->location[1] = to_node->location[1] - offset_y; + from_node.location[0] = to_node.location[0] + offset_x; + from_node.location[1] = to_node.location[1] - offset_y; } -void node_position_propagate(bNode *node) +void node_position_propagate(bNode &node) { - LISTBASE_FOREACH (bNodeSocket *, socket, &node->inputs) { + LISTBASE_FOREACH (bNodeSocket *, socket, &node.inputs) { if (socket->link != nullptr) { bNodeLink *link = socket->link; - node_position_relative(link->fromnode, link->tonode, link->fromsock, link->tosock); - node_position_propagate(link->fromnode); + node_position_relative(*link->fromnode, *link->tonode, *link->fromsock, *link->tosock); + node_position_propagate(*link->fromnode); } } } @@ -3274,15 +3263,15 @@ bNodeTree *node_tree_add_tree_embedded(Main * /*bmain*/, return node_tree_add_tree_do(nullptr, std::nullopt, owner_id, true, name, idname); } -bNodeTree *node_tree_copy_tree_ex(const bNodeTree *ntree, Main *bmain, const bool do_id_user) +bNodeTree *node_tree_copy_tree_ex(const bNodeTree &ntree, Main *bmain, const bool do_id_user) { const int flag = do_id_user ? 0 : LIB_ID_CREATE_NO_USER_REFCOUNT | LIB_ID_CREATE_NO_MAIN; bNodeTree *ntree_copy = reinterpret_cast( - BKE_id_copy_ex(bmain, reinterpret_cast(ntree), nullptr, flag)); + BKE_id_copy_ex(bmain, reinterpret_cast(&ntree), nullptr, flag)); return ntree_copy; } -bNodeTree *node_tree_copy_tree(Main *bmain, const bNodeTree *ntree) +bNodeTree *node_tree_copy_tree(Main *bmain, const bNodeTree &ntree) { return node_tree_copy_tree_ex(ntree, bmain, true); } @@ -3294,10 +3283,10 @@ bNodeTree *node_tree_copy_tree(Main *bmain, const bNodeTree *ntree) * using node_preview_init_tree to set up previews for a whole node tree in advance. * This should be left more to the individual node tree implementations. */ -bool node_preview_used(const bNode *node) +bool node_preview_used(const bNode &node) { /* XXX check for closed nodes? */ - return (node->typeinfo->flag & NODE_PREVIEW) != 0; + return (node.typeinfo->flag & NODE_PREVIEW) != 0; } bNodePreview *node_preview_verify(bNodeInstanceHash *previews, @@ -3358,7 +3347,7 @@ static void node_preview_init_tree_recursive(bNodeInstanceHash *previews, for (bNode *node : ntree->all_nodes()) { bNodeInstanceKey key = node_instance_key(parent_key, ntree, node); - if (node_preview_used(node)) { + if (node_preview_used(*node)) { node_preview_verify(previews, key, xsize, ysize, false); } @@ -3389,7 +3378,7 @@ static void node_preview_tag_used_recursive(bNodeInstanceHash *previews, for (bNode *node : ntree->all_nodes()) { bNodeInstanceKey key = node_instance_key(parent_key, ntree, node); - if (node_preview_used(node)) { + if (node_preview_used(*node)) { node_instance_hash_tag_key(previews, key); } @@ -3452,26 +3441,26 @@ void node_preview_merge_tree(bNodeTree *to_ntree, bNodeTree *from_ntree, bool re } } -void node_unlink_node(bNodeTree *ntree, bNode *node) +void node_unlink_node(bNodeTree &ntree, bNode &node) { - LISTBASE_FOREACH_MUTABLE (bNodeLink *, link, &ntree->links) { + LISTBASE_FOREACH_MUTABLE (bNodeLink *, link, &ntree.links) { ListBase *lb = nullptr; - if (link->fromnode == node) { - lb = &node->outputs; + if (link->fromnode == &node) { + lb = &node.outputs; } - else if (link->tonode == node) { - lb = &node->inputs; + else if (link->tonode == &node) { + lb = &node.inputs; } if (lb) { /* Only bother adjusting if the socket is not on the node we're deleting. */ - if (link->tonode != node && link->tosock->is_multi_input()) { + if (link->tonode != &node && link->tosock->is_multi_input()) { adjust_multi_input_indices_after_removed_link( - ntree, link->tosock, link->multi_input_sort_id); + &ntree, link->tosock, link->multi_input_sort_id); } LISTBASE_FOREACH (const bNodeSocket *, sock, lb) { if (link->fromsock == sock || link->tosock == sock) { - node_remove_link(ntree, link); + node_remove_link(&ntree, *link); break; } } @@ -3483,31 +3472,31 @@ static void node_unlink_attached(bNodeTree *ntree, const bNode *parent) { for (bNode *node : ntree->all_nodes()) { if (node->parent == parent) { - node_detach_node(ntree, node); + node_detach_node(*ntree, *node); } } } -void node_rebuild_id_vector(bNodeTree *node_tree) +void node_rebuild_id_vector(bNodeTree &node_tree) { /* Rebuild nodes #VectorSet which must have the same order as the list. */ - node_tree->runtime->nodes_by_id.clear(); + node_tree.runtime->nodes_by_id.clear(); int i; - LISTBASE_FOREACH_INDEX (bNode *, node, &node_tree->nodes, i) { - node_tree->runtime->nodes_by_id.add_new(node); + LISTBASE_FOREACH_INDEX (bNode *, node, &node_tree.nodes, i) { + node_tree.runtime->nodes_by_id.add_new(node); node->runtime->index_in_tree = i; } } -void node_free_node(bNodeTree *ntree, bNode *node) +void node_free_node(bNodeTree *ntree, bNode &node) { /* since it is called while free database, node->id is undefined */ /* can be called for nodes outside a node tree (e.g. clipboard) */ if (ntree) { - BLI_remlink(&ntree->nodes, node); + BLI_remlink(&ntree->nodes, &node); /* Rebuild nodes #VectorSet which must have the same order as the list. */ - node_rebuild_id_vector(ntree); + node_rebuild_id_vector(*ntree); /* texture node has bad habit of keeping exec data around */ if (ntree->type == NTREE_TEXTURE && ntree->runtime->execdata) { @@ -3516,83 +3505,82 @@ void node_free_node(bNodeTree *ntree, bNode *node) } } - if (node->typeinfo->freefunc) { - node->typeinfo->freefunc(node); + if (node.typeinfo->freefunc) { + node.typeinfo->freefunc(&node); } - LISTBASE_FOREACH_MUTABLE (bNodeSocket *, sock, &node->inputs) { + LISTBASE_FOREACH_MUTABLE (bNodeSocket *, sock, &node.inputs) { /* Remember, no ID user refcount management here! */ node_socket_free(sock, false); MEM_freeN(sock); } - LISTBASE_FOREACH_MUTABLE (bNodeSocket *, sock, &node->outputs) { + LISTBASE_FOREACH_MUTABLE (bNodeSocket *, sock, &node.outputs) { /* Remember, no ID user refcount management here! */ node_socket_free(sock, false); MEM_freeN(sock); } - MEM_SAFE_FREE(node->panel_states_array); + MEM_SAFE_FREE(node.panel_states_array); - if (node->prop) { + if (node.prop) { /* Remember, no ID user refcount management here! */ - IDP_FreePropertyContent_ex(node->prop, false); - MEM_freeN(node->prop); + IDP_FreePropertyContent_ex(node.prop, false); + MEM_freeN(node.prop); } - if (node->runtime->declaration) { + if (node.runtime->declaration) { /* Only free if this declaration is not shared with the node type, which can happen if it does * not depend on any context. */ - if (node->runtime->declaration != node->typeinfo->static_declaration) { - delete node->runtime->declaration; + if (node.runtime->declaration != node.typeinfo->static_declaration) { + delete node.runtime->declaration; } } - MEM_delete(node->runtime); - MEM_freeN(node); + MEM_delete(node.runtime); + MEM_freeN(&node); if (ntree) { BKE_ntree_update_tag_node_removed(ntree); } } -void node_tree_free_local_node(bNodeTree *ntree, bNode *node) +void node_tree_free_local_node(bNodeTree &ntree, bNode &node) { /* For removing nodes while editing localized node trees. */ - BLI_assert((ntree->id.tag & ID_TAG_LOCALIZED) != 0); + BLI_assert((ntree.id.tag & ID_TAG_LOCALIZED) != 0); /* These two lines assume the caller might want to free a single node and maintain * a valid state in the node tree. */ node_unlink_node(ntree, node); - node_unlink_attached(ntree, node); + node_unlink_attached(&ntree, &node); - node_free_node(ntree, node); + node_free_node(&ntree, node); node_rebuild_id_vector(ntree); } -void node_remove_node(Main *bmain, bNodeTree *ntree, bNode *node, const bool do_id_user) +void node_remove_node(Main *bmain, bNodeTree &ntree, bNode &node, const bool do_id_user) { - BLI_assert(ntree != nullptr); /* This function is not for localized node trees, we do not want * do to ID user reference-counting and removal of animation data then. */ - BLI_assert((ntree->id.tag & ID_TAG_LOCALIZED) == 0); + BLI_assert((ntree.id.tag & ID_TAG_LOCALIZED) == 0); if (do_id_user) { /* Free callback for NodeCustomGroup. */ - if (node->typeinfo->freefunc_api) { - PointerRNA ptr = RNA_pointer_create_discrete(&ntree->id, &RNA_Node, node); + if (node.typeinfo->freefunc_api) { + PointerRNA ptr = RNA_pointer_create_discrete(&ntree.id, &RNA_Node, &node); - node->typeinfo->freefunc_api(&ptr); + node.typeinfo->freefunc_api(&ptr); } /* Do user counting. */ - if (node->id) { - id_us_min(node->id); + if (node.id) { + id_us_min(node.id); } - LISTBASE_FOREACH (bNodeSocket *, sock, &node->inputs) { + LISTBASE_FOREACH (bNodeSocket *, sock, &node.inputs) { socket_id_user_decrement(sock); } - LISTBASE_FOREACH (bNodeSocket *, sock, &node->outputs) { + LISTBASE_FOREACH (bNodeSocket *, sock, &node.outputs) { socket_id_user_decrement(sock); } } @@ -3601,20 +3589,20 @@ void node_remove_node(Main *bmain, bNodeTree *ntree, bNode *node, const bool do_ char propname_esc[MAX_IDPROP_NAME * 2]; char prefix[MAX_IDPROP_NAME * 2]; - BLI_str_escape(propname_esc, node->name, sizeof(propname_esc)); + BLI_str_escape(propname_esc, node.name, sizeof(propname_esc)); SNPRINTF(prefix, "nodes[\"%s\"]", propname_esc); - if (BKE_animdata_fix_paths_remove(&ntree->id, prefix)) { + if (BKE_animdata_fix_paths_remove(&ntree.id, prefix)) { if (bmain != nullptr) { DEG_relations_tag_update(bmain); } } node_unlink_node(ntree, node); - node_unlink_attached(ntree, node); + node_unlink_attached(&ntree, &node); /* Free node itself. */ - node_free_node(ntree, node); + node_free_node(&ntree, node); node_rebuild_id_vector(ntree); } @@ -3631,21 +3619,21 @@ static void free_localized_node_groups(bNodeTree *ntree) LISTBASE_FOREACH (bNode *, node, &ntree->nodes) { bNodeTree *ngroup = reinterpret_cast(node->id); if (node->is_group() && ngroup != nullptr) { - node_tree_free_tree(ngroup); + node_tree_free_tree(*ngroup); MEM_freeN(ngroup); } } } -void node_tree_free_tree(bNodeTree *ntree) +void node_tree_free_tree(bNodeTree &ntree) { - ntree_free_data(&ntree->id); - BKE_animdata_free(&ntree->id, false); + ntree_free_data(&ntree.id); + BKE_animdata_free(&ntree.id, false); } void node_tree_free_embedded_tree(bNodeTree *ntree) { - node_tree_free_tree(ntree); + node_tree_free_tree(*ntree); BKE_libblock_free_data(&ntree->id, true); BKE_libblock_free_data_py(&ntree->id); } @@ -3653,19 +3641,19 @@ void node_tree_free_embedded_tree(bNodeTree *ntree) void node_tree_free_local_tree(bNodeTree *ntree) { if (ntree->id.tag & ID_TAG_LOCALIZED) { - node_tree_free_tree(ntree); + node_tree_free_tree(*ntree); } else { - node_tree_free_tree(ntree); + node_tree_free_tree(*ntree); BKE_libblock_free_data(&ntree->id, true); } } -void node_tree_set_output(bNodeTree *ntree) +void node_tree_set_output(bNodeTree &ntree) { - const bool is_compositor = ntree->type == NTREE_COMPOSIT; + const bool is_compositor = ntree.type == NTREE_COMPOSIT; /* find the active outputs, might become tree type dependent handler */ - LISTBASE_FOREACH (bNode *, node, &ntree->nodes) { + LISTBASE_FOREACH (bNode *, node, &ntree.nodes) { if (node->typeinfo->nclass == NODE_CLASS_OUTPUT) { /* we need a check for which output node should be tagged like this, below an exception */ if (ELEM(node->type_legacy, CMP_NODE_OUTPUT_FILE, GEO_NODE_VIEWER)) { @@ -3676,7 +3664,7 @@ void node_tree_set_output(bNodeTree *ntree) int output = 0; /* there is more types having output class, each one is checked */ - LISTBASE_FOREACH (bNode *, tnode, &ntree->nodes) { + LISTBASE_FOREACH (bNode *, tnode, &ntree.nodes) { if (tnode->typeinfo->nclass != NODE_CLASS_OUTPUT) { continue; } @@ -3708,7 +3696,7 @@ void node_tree_set_output(bNodeTree *ntree) /* group node outputs use this flag too */ if (node->is_group_output()) { int output = 0; - LISTBASE_FOREACH (bNode *, tnode, &ntree->nodes) { + LISTBASE_FOREACH (bNode *, tnode, &ntree.nodes) { if (!tnode->is_group_output()) { continue; } @@ -3759,9 +3747,9 @@ bNodeTree *node_tree_from_id(ID *id) return (nodetree != nullptr) ? *nodetree : nullptr; } -void node_tree_node_flag_set(const bNodeTree *ntree, const int flag, const bool enable) +void node_tree_node_flag_set(const bNodeTree &ntree, const int flag, const bool enable) { - LISTBASE_FOREACH (bNode *, node, &ntree->nodes) { + LISTBASE_FOREACH (bNode *, node, &ntree.nodes) { if (enable) { node->flag |= flag; } @@ -3797,7 +3785,7 @@ bNodeTree *node_tree_localize(bNodeTree *ntree, std::optional new_owner_id } /* Ensures only a single output node is enabled. */ - node_tree_set_output(ntree); + node_tree_set_output(*ntree); bNode *node_src = reinterpret_cast(ntree->nodes.first); bNode *node_local = reinterpret_cast(ltree->nodes.first); @@ -3823,16 +3811,16 @@ void node_tree_local_merge(Main *bmain, bNodeTree *localtree, bNodeTree *ntree) } } -static bool ntree_contains_tree_exec(const bNodeTree *tree_to_search_in, - const bNodeTree *tree_to_search_for, +static bool ntree_contains_tree_exec(const bNodeTree &tree_to_search_in, + const bNodeTree &tree_to_search_for, Set &already_passed) { - if (tree_to_search_in == tree_to_search_for) { + if (&tree_to_search_in == &tree_to_search_for) { return true; } - tree_to_search_in->ensure_topology_cache(); - for (const bNode *node_group : tree_to_search_in->group_nodes()) { + tree_to_search_in.ensure_topology_cache(); + for (const bNode *node_group : tree_to_search_in.group_nodes()) { const bNodeTree *sub_tree_search_in = reinterpret_cast(node_group->id); if (!sub_tree_search_in) { continue; @@ -3840,7 +3828,7 @@ static bool ntree_contains_tree_exec(const bNodeTree *tree_to_search_in, if (!already_passed.add(sub_tree_search_in)) { continue; } - if (ntree_contains_tree_exec(sub_tree_search_in, tree_to_search_for, already_passed)) { + if (ntree_contains_tree_exec(*sub_tree_search_in, tree_to_search_for, already_passed)) { return true; } } @@ -3848,10 +3836,10 @@ static bool ntree_contains_tree_exec(const bNodeTree *tree_to_search_in, return false; } -bool node_tree_contains_tree(const bNodeTree *tree_to_search_in, - const bNodeTree *tree_to_search_for) +bool node_tree_contains_tree(const bNodeTree &tree_to_search_in, + const bNodeTree &tree_to_search_for) { - if (tree_to_search_in == tree_to_search_for) { + if (&tree_to_search_in == &tree_to_search_for) { return true; } @@ -3859,24 +3847,20 @@ bool node_tree_contains_tree(const bNodeTree *tree_to_search_in, return ntree_contains_tree_exec(tree_to_search_in, tree_to_search_for, already_passed); } -int node_count_socket_links(const bNodeTree *ntree, const bNodeSocket *sock) +int node_count_socket_links(const bNodeTree &ntree, const bNodeSocket &sock) { int tot = 0; - LISTBASE_FOREACH (const bNodeLink *, link, &ntree->links) { - if (link->fromsock == sock || link->tosock == sock) { + LISTBASE_FOREACH (const bNodeLink *, link, &ntree.links) { + if (link->fromsock == &sock || link->tosock == &sock) { tot++; } } return tot; } -bNode *node_get_active(bNodeTree *ntree) +bNode *node_get_active(bNodeTree &ntree) { - if (ntree == nullptr) { - return nullptr; - } - - for (bNode *node : ntree->all_nodes()) { + for (bNode *node : ntree.all_nodes()) { if (node->flag & NODE_ACTIVE) { return node; } @@ -3884,40 +3868,36 @@ bNode *node_get_active(bNodeTree *ntree) return nullptr; } -bool node_set_selected(bNode *node, const bool select) +bool node_set_selected(bNode &node, const bool select) { bool changed = false; - if (select != ((node->flag & NODE_SELECT) != 0)) { + if (select != ((node.flag & NODE_SELECT) != 0)) { changed = true; - SET_FLAG_FROM_TEST(node->flag, select, NODE_SELECT); + SET_FLAG_FROM_TEST(node.flag, select, NODE_SELECT); } if (select) { return changed; } /* Deselect sockets too. */ - LISTBASE_FOREACH (bNodeSocket *, sock, &node->inputs) { + LISTBASE_FOREACH (bNodeSocket *, sock, &node.inputs) { changed |= (sock->flag & NODE_SELECT) != 0; sock->flag &= ~NODE_SELECT; } - LISTBASE_FOREACH (bNodeSocket *, sock, &node->outputs) { + LISTBASE_FOREACH (bNodeSocket *, sock, &node.outputs) { changed |= (sock->flag & NODE_SELECT) != 0; sock->flag &= ~NODE_SELECT; } return changed; } -void node_clear_active(bNodeTree *ntree) +void node_clear_active(bNodeTree &ntree) { - if (ntree == nullptr) { - return; - } - - for (bNode *node : ntree->all_nodes()) { + for (bNode *node : ntree.all_nodes()) { node->flag &= ~NODE_ACTIVE; } } -void node_set_active(bNodeTree *ntree, bNode *node) +void node_set_active(bNodeTree &ntree, bNode &node) { const bool is_paint_canvas = node_supports_active_flag(node, NODE_ACTIVE_PAINT_CANVAS); const bool is_texture_class = node_supports_active_flag(node, NODE_ACTIVE_TEXTURE); @@ -3926,40 +3906,40 @@ void node_set_active(bNodeTree *ntree, bNode *node) SET_FLAG_FROM_TEST(flags_to_set, is_texture_class, NODE_ACTIVE_TEXTURE); /* Make sure only one node is active per node tree. */ - for (bNode *tnode : ntree->all_nodes()) { + for (bNode *tnode : ntree.all_nodes()) { tnode->flag &= ~flags_to_set; } - node->flag |= flags_to_set; + node.flag |= flags_to_set; } -void node_set_socket_availability(bNodeTree *ntree, bNodeSocket *sock, const bool is_available) +void node_set_socket_availability(bNodeTree &ntree, bNodeSocket &sock, const bool is_available) { - if (is_available == sock->is_available()) { + if (is_available == sock.is_available()) { return; } if (is_available) { - sock->flag &= ~SOCK_UNAVAIL; + sock.flag &= ~SOCK_UNAVAIL; } else { - sock->flag |= SOCK_UNAVAIL; + sock.flag |= SOCK_UNAVAIL; } - BKE_ntree_update_tag_socket_availability(ntree, sock); + BKE_ntree_update_tag_socket_availability(&ntree, &sock); } -int node_socket_link_limit(const bNodeSocket *sock) +int node_socket_link_limit(const bNodeSocket &sock) { - if (sock->is_multi_input()) { + if (sock.is_multi_input()) { return 4095; } - if (sock->typeinfo == nullptr) { - return sock->limit; + if (sock.typeinfo == nullptr) { + return sock.limit; } - const bNodeSocketType &stype = *sock->typeinfo; + const bNodeSocketType &stype = *sock.typeinfo; if (!stype.use_link_limits_of_type) { - return sock->limit; + return sock.limit; } - return eNodeSocketInOut(sock->in_out) == SOCK_IN ? stype.input_link_limit : - stype.output_link_limit; + return eNodeSocketInOut(sock.in_out) == SOCK_IN ? stype.input_link_limit : + stype.output_link_limit; } static void update_socket_declarations(ListBase *sockets, @@ -3991,52 +3971,50 @@ void node_socket_declarations_update(bNode *node) update_socket_declarations(&node->outputs, node->runtime->declaration->outputs); } -bool node_declaration_ensure_on_outdated_node(bNodeTree *ntree, bNode *node) +bool node_declaration_ensure_on_outdated_node(bNodeTree &ntree, bNode &node) { - if (node->runtime->declaration != nullptr) { + if (node.runtime->declaration != nullptr) { return false; } - if (node->typeinfo->declare) { - if (node->typeinfo->static_declaration) { - if (!node->typeinfo->static_declaration->is_context_dependent) { - node->runtime->declaration = node->typeinfo->static_declaration; + if (node.typeinfo->declare) { + if (node.typeinfo->static_declaration) { + if (!node.typeinfo->static_declaration->is_context_dependent) { + node.runtime->declaration = node.typeinfo->static_declaration; return true; } } } - if (node->typeinfo->declare) { - BLI_assert(ntree != nullptr); - BLI_assert(node != nullptr); - nodes::update_node_declaration_and_sockets(*ntree, *node); + if (node.typeinfo->declare) { + nodes::update_node_declaration_and_sockets(ntree, node); return true; } return false; } -bool node_declaration_ensure(bNodeTree *ntree, bNode *node) +bool node_declaration_ensure(bNodeTree &ntree, bNode &node) { if (node_declaration_ensure_on_outdated_node(ntree, node)) { - node_socket_declarations_update(node); + node_socket_declarations_update(&node); return true; } return false; } -void node_dimensions_get(const bNode *node, float *r_width, float *r_height) +float2 node_dimensions_get(const bNode &node) { - *r_width = node->runtime->draw_bounds.xmax - node->runtime->draw_bounds.xmin; - *r_height = node->runtime->draw_bounds.ymax - node->runtime->draw_bounds.ymin; + return float2(node.runtime->draw_bounds.xmax, node.runtime->draw_bounds.ymax) - + float2(node.runtime->draw_bounds.xmin, node.runtime->draw_bounds.ymin); } -void node_tag_update_id(bNode *node) +void node_tag_update_id(bNode &node) { - node->runtime->update |= NODE_UPDATE_ID; + node.runtime->update |= NODE_UPDATE_ID; } -void node_internal_links(bNode *node, bNodeLink **r_links, int *r_len) +void node_internal_links(bNode &node, bNodeLink **r_links, int *r_len) { - *r_links = node->runtime->internal_links.data(); - *r_len = node->runtime->internal_links.size(); + *r_links = node.runtime->internal_links.data(); + *r_len = node.runtime->internal_links.size(); } /* Node Instance Hash */ @@ -4235,7 +4213,7 @@ static void node_replace_undefined_types(bNode *node) } } -void node_tree_update_all_new(Main *main) +void node_tree_update_all_new(Main &main) { /* Replace unknown node types with "Undefined". * This happens when loading files from newer Blender versions. Such nodes cannot be read @@ -4244,7 +4222,7 @@ void node_tree_update_all_new(Main *main) * * Replacement has to happen after after-liblink-versioning, since some node types still get * replaced in those late versioning steps. */ - FOREACH_NODETREE_BEGIN (main, ntree, owner_id) { + FOREACH_NODETREE_BEGIN (&main, ntree, owner_id) { LISTBASE_FOREACH (bNode *, node, &ntree->nodes) { node_replace_undefined_types(node); } @@ -4253,13 +4231,13 @@ void node_tree_update_all_new(Main *main) /* Update all new node trees on file read or append, to add/remove sockets * in groups nodes if the group changed, and handle any update flags that * might have been set in file reading or versioning. */ - FOREACH_NODETREE_BEGIN (main, ntree, owner_id) { + FOREACH_NODETREE_BEGIN (&main, ntree, owner_id) { if (owner_id->tag & ID_TAG_NEW) { BKE_ntree_update_tag_all(ntree); } } FOREACH_NODETREE_END; - BKE_ntree_update(*main); + BKE_ntree_update(main); } void node_tree_update_all_users(Main *main, ID *id) @@ -4287,47 +4265,47 @@ void node_tree_update_all_users(Main *main, ID *id) /* ************* node type access ********** */ -void nodeLabel(const bNodeTree *ntree, const bNode *node, char *label, const int label_maxncpy) +void nodeLabel(const bNodeTree &ntree, const bNode &node, char *label, const int label_maxncpy) { label[0] = '\0'; - if (node->label[0] != '\0') { - BLI_strncpy(label, node->label, label_maxncpy); + if (node.label[0] != '\0') { + BLI_strncpy(label, node.label, label_maxncpy); } - else if (node->typeinfo->labelfunc) { - node->typeinfo->labelfunc(ntree, node, label, label_maxncpy); + else if (node.typeinfo->labelfunc) { + node.typeinfo->labelfunc(&ntree, &node, label, label_maxncpy); } if (label[0] != '\0') { /* The previous methods (labelfunc) could not provide an adequate label for the node. */ return; } - BLI_strncpy(label, IFACE_(node->typeinfo->ui_name.c_str()), label_maxncpy); + BLI_strncpy(label, IFACE_(node.typeinfo->ui_name.c_str()), label_maxncpy); } -std::optional nodeSocketShortLabel(const bNodeSocket *sock) +std::optional nodeSocketShortLabel(const bNodeSocket &sock) { - if (sock->runtime->declaration != nullptr) { - StringRefNull short_label = sock->runtime->declaration->short_label; + if (sock.runtime->declaration != nullptr) { + StringRefNull short_label = sock.runtime->declaration->short_label; if (!short_label.is_empty()) { - return sock->runtime->declaration->short_label.data(); + return sock.runtime->declaration->short_label.data(); } } return std::nullopt; } -StringRefNull nodeSocketLabel(const bNodeSocket *sock) +StringRefNull nodeSocketLabel(const bNodeSocket &sock) { - return (sock->label[0] != '\0') ? sock->label : sock->name; + return (sock.label[0] != '\0') ? sock.label : sock.name; } -static void node_type_base_defaults(bNodeType *ntype) +static void node_type_base_defaults(bNodeType &ntype) { /* default size values */ node_type_size_preset(ntype, eNodeSizePreset::Default); - ntype->height = 100; - ntype->minheight = 30; - ntype->maxheight = FLT_MAX; + ntype.height = 100; + ntype.minheight = 30; + ntype.maxheight = FLT_MAX; } /* allow this node for any tree type */ @@ -4358,9 +4336,9 @@ static int16_t get_next_auto_legacy_type() return new_type; } -void node_type_base(bNodeType *ntype, std::string idname, std::optional legacy_type) +void node_type_base(bNodeType &ntype, std::string idname, std::optional legacy_type) { - ntype->idname = std::move(idname); + ntype.idname = std::move(idname); if (!legacy_type.has_value()) { /* Still auto-generate a legacy type for this node type if none was specified. This is @@ -4370,35 +4348,35 @@ void node_type_base(bNodeType *ntype, std::string idname, std::optional } if (!ELEM(*legacy_type, NODE_CUSTOM, NODE_UNDEFINED)) { - StructRNA *srna = RNA_struct_find(ntype->idname.c_str()); + StructRNA *srna = RNA_struct_find(ntype.idname.c_str()); BLI_assert(srna != nullptr); - ntype->rna_ext.srna = srna; - RNA_struct_blender_type_set(srna, ntype); + ntype.rna_ext.srna = srna; + RNA_struct_blender_type_set(srna, &ntype); } /* make sure we have a valid type (everything registered) */ - BLI_assert(ntype->idname[0] != '\0'); + BLI_assert(ntype.idname[0] != '\0'); - ntype->type_legacy = *legacy_type; - ntype->nclass = NODE_CLASS_CONVERTER; + ntype.type_legacy = *legacy_type; + ntype.nclass = NODE_CLASS_CONVERTER; node_type_base_defaults(ntype); - ntype->poll = node_poll_default; - ntype->poll_instance = node_poll_instance_default; + ntype.poll = node_poll_default; + ntype.poll_instance = node_poll_instance_default; } -void node_type_base_custom(bNodeType *ntype, +void node_type_base_custom(bNodeType &ntype, const StringRefNull idname, const StringRefNull name, const StringRefNull enum_name, const short nclass) { - ntype->idname = idname; - ntype->type_legacy = NODE_CUSTOM; - ntype->ui_name = name; - ntype->nclass = nclass; - ntype->enum_name_legacy = enum_name.c_str(); + ntype.idname = idname; + ntype.type_legacy = NODE_CUSTOM; + ntype.ui_name = name; + ntype.nclass = nclass; + ntype.enum_name_legacy = enum_name.c_str(); node_type_base_defaults(ntype); } @@ -4626,19 +4604,19 @@ void node_type_socket_templates(bNodeType *ntype, } } -void node_type_size(bNodeType *ntype, const int width, const int minwidth, const int maxwidth) +void node_type_size(bNodeType &ntype, const int width, const int minwidth, const int maxwidth) { - ntype->width = width; - ntype->minwidth = minwidth; + ntype.width = width; + ntype.minwidth = minwidth; if (maxwidth <= minwidth) { - ntype->maxwidth = FLT_MAX; + ntype.maxwidth = FLT_MAX; } else { - ntype->maxwidth = maxwidth; + ntype.maxwidth = maxwidth; } } -void node_type_size_preset(bNodeType *ntype, const eNodeSizePreset size) +void node_type_size_preset(bNodeType &ntype, const eNodeSizePreset size) { switch (size) { case eNodeSizePreset::Default: @@ -4656,16 +4634,16 @@ void node_type_size_preset(bNodeType *ntype, const eNodeSizePreset size) } } -void node_type_storage(bNodeType *ntype, +void node_type_storage(bNodeType &ntype, const std::optional storagename, void (*freefunc)(bNode *node), void (*copyfunc)(bNodeTree *dest_ntree, bNode *dest_node, const bNode *src_node)) { - ntype->storagename = storagename.value_or(""); - ntype->copyfunc = copyfunc; - ntype->freefunc = freefunc; + ntype.storagename = storagename.value_or(""); + ntype.copyfunc = copyfunc; + ntype.freefunc = freefunc; } void node_system_init() diff --git a/source/blender/blenkernel/intern/node_tree_field_inferencing.cc b/source/blender/blenkernel/intern/node_tree_field_inferencing.cc index 6ad93d5a6ee..e2f458e7761 100644 --- a/source/blender/blenkernel/intern/node_tree_field_inferencing.cc +++ b/source/blender/blenkernel/intern/node_tree_field_inferencing.cc @@ -128,7 +128,7 @@ static const FieldInferencingInterface &get_node_field_inferencing_interface(con static const FieldInferencingInterface empty_interface; return empty_interface; } - if (!bke::node_tree_is_registered(group)) { + if (!bke::node_tree_is_registered(*group)) { /* This can happen when there is a linked node group that was not found (see #92799). */ return get_dummy_field_inferencing_interface(node, scope); } diff --git a/source/blender/blenkernel/intern/node_tree_interface.cc b/source/blender/blenkernel/intern/node_tree_interface.cc index 2eb54e09f9d..b2ec23d6f82 100644 --- a/source/blender/blenkernel/intern/node_tree_interface.cc +++ b/source/blender/blenkernel/intern/node_tree_interface.cc @@ -50,7 +50,7 @@ static std::optional try_get_supported_socket_type(const StringRef so return std::nullopt; } /* For builtin socket types only the base type is supported. */ - if (node_is_static_socket_type(typeinfo)) { + if (node_is_static_socket_type(*typeinfo)) { if (const std::optional type_name = bke::node_static_socket_type(typeinfo->type, PROP_NONE)) { diff --git a/source/blender/blenkernel/intern/node_tree_update.cc b/source/blender/blenkernel/intern/node_tree_update.cc index ae51844b179..bef7dd9ee92 100644 --- a/source/blender/blenkernel/intern/node_tree_update.cc +++ b/source/blender/blenkernel/intern/node_tree_update.cc @@ -573,7 +573,7 @@ class NodeTreeMainUpdater { void update_individual_nodes(bNodeTree &ntree) { for (bNode *node : ntree.all_nodes()) { - bke::node_declaration_ensure(&ntree, node); + bke::node_declaration_ensure(ntree, *node); if (this->should_update_individual_node(ntree, *node)) { bke::bNodeType &ntype = *node->typeinfo; if (ntype.group_update_func) { diff --git a/source/blender/blenloader/intern/readfile.cc b/source/blender/blenloader/intern/readfile.cc index 98dddd86298..70e53834285 100644 --- a/source/blender/blenloader/intern/readfile.cc +++ b/source/blender/blenloader/intern/readfile.cc @@ -3901,7 +3901,7 @@ BlendFileData *blo_read_file_internal(FileData *fd, const char *filepath) /* After all data has been read and versioned, uses ID_TAG_NEW. Theoretically this should * not be calculated in the undo case, but it is currently needed even on undo to recalculate * a cache. */ - blender::bke::node_tree_update_all_new(bfd->main); + blender::bke::node_tree_update_all_new(*bfd->main); placeholders_ensure_valid(bfd->main); @@ -4553,7 +4553,7 @@ static void library_link_end(Main *mainl, FileData **fd, const int flag) BKE_main_id_refcount_recompute(mainvar, false); /* After all data has been read and versioned, uses ID_TAG_NEW. */ - blender::bke::node_tree_update_all_new(mainvar); + blender::bke::node_tree_update_all_new(*mainvar); placeholders_ensure_valid(mainvar); diff --git a/source/blender/blenloader/intern/versioning_250.cc b/source/blender/blenloader/intern/versioning_250.cc index ff81e685a70..c2e3bc5bf76 100644 --- a/source/blender/blenloader/intern/versioning_250.cc +++ b/source/blender/blenloader/intern/versioning_250.cc @@ -1027,7 +1027,7 @@ void blo_do_versions_250(FileData *fd, Library * /*lib*/, Main *bmain) bNode *node = static_cast(ntree->nodes.first); while (node) { - blender::bke::node_unique_name(ntree, node); + blender::bke::node_unique_name(*ntree, *node); node = node->next; } @@ -1859,7 +1859,7 @@ void blo_do_versions_250(FileData *fd, Library * /*lib*/, Main *bmain) } } LISTBASE_FOREACH (bNodeSocket *, sock, &node->outputs) { - if (blender::bke::node_count_socket_links(ntree, sock) == 0 && + if (blender::bke::node_count_socket_links(*ntree, *sock) == 0 && !((sock->flag & (SOCK_HIDDEN | SOCK_UNAVAIL)) != 0)) { bNodeSocket *gsock = do_versions_node_group_add_socket_2_56_2( diff --git a/source/blender/blenloader/intern/versioning_260.cc b/source/blender/blenloader/intern/versioning_260.cc index b1e1c59df2e..f8d6953a35c 100644 --- a/source/blender/blenloader/intern/versioning_260.cc +++ b/source/blender/blenloader/intern/versioning_260.cc @@ -319,8 +319,8 @@ static void do_versions_nodetree_multi_file_output_format_2_62_1(Scene *sce, bNo } } - blender::bke::node_remove_socket(ntree, node, old_image); - blender::bke::node_remove_socket(ntree, node, old_z); + blender::bke::node_remove_socket(*ntree, *node, *old_image); + blender::bke::node_remove_socket(*ntree, *node, *old_z); if (old_data) { MEM_freeN(old_data); } @@ -1104,7 +1104,7 @@ static bNode *version_add_group_in_out_node(bNodeTree *ntree, const int type) node->runtime = MEM_new(__func__); BLI_addtail(&ntree->nodes, node); - blender::bke::node_unique_id(ntree, node); + blender::bke::node_unique_id(*ntree, *node); /* Manual initialization of the node, * node->typeinfo is only set after versioning. */ @@ -2256,7 +2256,7 @@ void blo_do_versions_260(FileData *fd, Library * /*lib*/, Main *bmain) } LISTBASE_FOREACH (bNode *, node, &ntree->nodes) { - blender::bke::node_unique_name(ntree, node); + blender::bke::node_unique_name(*ntree, *node); } } FOREACH_NODETREE_END; @@ -2345,7 +2345,7 @@ void blo_do_versions_260(FileData *fd, Library * /*lib*/, Main *bmain) } if (free_link) { - blender::bke::node_remove_link(ntree, link); + blender::bke::node_remove_link(ntree, *link); } } @@ -2374,7 +2374,7 @@ void blo_do_versions_260(FileData *fd, Library * /*lib*/, Main *bmain) { next_link = link->next; if (link->fromnode == nullptr || link->tonode == nullptr) { - blender::bke::node_remove_link(ntree, link); + blender::bke::node_remove_link(ntree, *link); } } } diff --git a/source/blender/blenloader/intern/versioning_270.cc b/source/blender/blenloader/intern/versioning_270.cc index c5d88fb240f..093d9eeca77 100644 --- a/source/blender/blenloader/intern/versioning_270.cc +++ b/source/blender/blenloader/intern/versioning_270.cc @@ -278,20 +278,20 @@ static void do_version_hue_sat_node(bNodeTree *ntree, bNode *node) /* Convert value from old storage to new sockets. */ NodeHueSat *nhs = static_cast(node->storage); - bNodeSocket *hue = blender::bke::node_find_socket(node, SOCK_IN, "Hue"); - bNodeSocket *saturation = blender::bke::node_find_socket(node, SOCK_IN, "Saturation"); - bNodeSocket *value = blender::bke::node_find_socket(node, SOCK_IN, "Value"); + bNodeSocket *hue = blender::bke::node_find_socket(*node, SOCK_IN, "Hue"); + bNodeSocket *saturation = blender::bke::node_find_socket(*node, SOCK_IN, "Saturation"); + bNodeSocket *value = blender::bke::node_find_socket(*node, SOCK_IN, "Value"); if (hue == nullptr) { hue = blender::bke::node_add_static_socket( - ntree, node, SOCK_IN, SOCK_FLOAT, PROP_FACTOR, "Hue", "Hue"); + *ntree, *node, SOCK_IN, SOCK_FLOAT, PROP_FACTOR, "Hue", "Hue"); } if (saturation == nullptr) { saturation = blender::bke::node_add_static_socket( - ntree, node, SOCK_IN, SOCK_FLOAT, PROP_FACTOR, "Saturation", "Saturation"); + *ntree, *node, SOCK_IN, SOCK_FLOAT, PROP_FACTOR, "Saturation", "Saturation"); } if (value == nullptr) { value = blender::bke::node_add_static_socket( - ntree, node, SOCK_IN, SOCK_FLOAT, PROP_FACTOR, "Value", "Value"); + *ntree, *node, SOCK_IN, SOCK_FLOAT, PROP_FACTOR, "Value", "Value"); } ((bNodeSocketValueFloat *)hue->default_value)->value = nhs->hue; @@ -1456,7 +1456,7 @@ void blo_do_versions_270(FileData *fd, Library * /*lib*/, Main *bmain) if (!DNA_struct_member_exists(fd->filesdna, "NodeGlare", "char", "star_45")) { FOREACH_NODETREE_BEGIN (bmain, ntree, id) { if (ntree->type == NTREE_COMPOSIT) { - blender::bke::node_tree_set_type(nullptr, ntree); + blender::bke::node_tree_set_type(nullptr, *ntree); LISTBASE_FOREACH (bNode *, node, &ntree->nodes) { if (node->type_legacy == CMP_NODE_GLARE) { NodeGlare *ndg = static_cast(node->storage); @@ -1608,7 +1608,7 @@ void do_versions_after_linking_270(Main *bmain) if (!MAIN_VERSION_FILE_ATLEAST(bmain, 279, 0)) { FOREACH_NODETREE_BEGIN (bmain, ntree, id) { if (ntree->type == NTREE_COMPOSIT) { - blender::bke::node_tree_set_type(nullptr, ntree); + blender::bke::node_tree_set_type(nullptr, *ntree); LISTBASE_FOREACH (bNode *, node, &ntree->nodes) { if (node->type_legacy == CMP_NODE_HUE_SAT) { do_version_hue_sat_node(ntree, node); diff --git a/source/blender/blenloader/intern/versioning_280.cc b/source/blender/blenloader/intern/versioning_280.cc index e490bca3353..cc92a4bdba4 100644 --- a/source/blender/blenloader/intern/versioning_280.cc +++ b/source/blender/blenloader/intern/versioning_280.cc @@ -664,38 +664,39 @@ static void do_versions_material_convert_legacy_blend_mode(bNodeTree *ntree, cha MA_BM_MULTIPLY = 2, }; if (blend_method == MA_BM_ADD) { - blender::bke::node_remove_link(ntree, link); + blender::bke::node_remove_link(ntree, *link); - bNode *add_node = blender::bke::node_add_static_node(nullptr, ntree, SH_NODE_ADD_SHADER); + bNode *add_node = blender::bke::node_add_static_node(nullptr, *ntree, SH_NODE_ADD_SHADER); add_node->locx_legacy = 0.5f * (fromnode->locx_legacy + tonode->locx_legacy); add_node->locy_legacy = 0.5f * (fromnode->locy_legacy + tonode->locy_legacy); bNodeSocket *shader1_socket = static_cast(add_node->inputs.first); bNodeSocket *shader2_socket = static_cast(add_node->inputs.last); - bNodeSocket *add_socket = blender::bke::node_find_socket(add_node, SOCK_OUT, "Shader"); + bNodeSocket *add_socket = blender::bke::node_find_socket(*add_node, SOCK_OUT, "Shader"); bNode *transp_node = blender::bke::node_add_static_node( - nullptr, ntree, SH_NODE_BSDF_TRANSPARENT); + nullptr, *ntree, SH_NODE_BSDF_TRANSPARENT); transp_node->locx_legacy = add_node->locx_legacy; transp_node->locy_legacy = add_node->locy_legacy - 110.0f; - bNodeSocket *transp_socket = blender::bke::node_find_socket(transp_node, SOCK_OUT, "BSDF"); + bNodeSocket *transp_socket = blender::bke::node_find_socket(*transp_node, SOCK_OUT, "BSDF"); /* Link to input and material output node. */ - blender::bke::node_add_link(ntree, fromnode, fromsock, add_node, shader1_socket); - blender::bke::node_add_link(ntree, transp_node, transp_socket, add_node, shader2_socket); - blender::bke::node_add_link(ntree, add_node, add_socket, tonode, tosock); + blender::bke::node_add_link(*ntree, *fromnode, *fromsock, *add_node, *shader1_socket); + blender::bke::node_add_link( + *ntree, *transp_node, *transp_socket, *add_node, *shader2_socket); + blender::bke::node_add_link(*ntree, *add_node, *add_socket, *tonode, *tosock); need_update = true; } else if (blend_method == MA_BM_MULTIPLY) { - blender::bke::node_remove_link(ntree, link); + blender::bke::node_remove_link(ntree, *link); bNode *transp_node = blender::bke::node_add_static_node( - nullptr, ntree, SH_NODE_BSDF_TRANSPARENT); + nullptr, *ntree, SH_NODE_BSDF_TRANSPARENT); - bNodeSocket *color_socket = blender::bke::node_find_socket(transp_node, SOCK_IN, "Color"); - bNodeSocket *transp_socket = blender::bke::node_find_socket(transp_node, SOCK_OUT, "BSDF"); + bNodeSocket *color_socket = blender::bke::node_find_socket(*transp_node, SOCK_IN, "Color"); + bNodeSocket *transp_socket = blender::bke::node_find_socket(*transp_node, SOCK_OUT, "BSDF"); /* If incoming link is from a closure socket, we need to convert it. */ if (fromsock->type == SOCK_SHADER) { @@ -703,26 +704,28 @@ static void do_versions_material_convert_legacy_blend_mode(bNodeTree *ntree, cha transp_node->locy_legacy = 0.33f * fromnode->locy_legacy + 0.66f * tonode->locy_legacy; bNode *shtorgb_node = blender::bke::node_add_static_node( - nullptr, ntree, SH_NODE_SHADERTORGB); + nullptr, *ntree, SH_NODE_SHADERTORGB); shtorgb_node->locx_legacy = 0.66f * fromnode->locx_legacy + 0.33f * tonode->locx_legacy; shtorgb_node->locy_legacy = 0.66f * fromnode->locy_legacy + 0.33f * tonode->locy_legacy; bNodeSocket *shader_socket = blender::bke::node_find_socket( - shtorgb_node, SOCK_IN, "Shader"); - bNodeSocket *rgba_socket = blender::bke::node_find_socket(shtorgb_node, SOCK_OUT, "Color"); + *shtorgb_node, SOCK_IN, "Shader"); + bNodeSocket *rgba_socket = blender::bke::node_find_socket( + *shtorgb_node, SOCK_OUT, "Color"); - blender::bke::node_add_link(ntree, fromnode, fromsock, shtorgb_node, shader_socket); - blender::bke::node_add_link(ntree, shtorgb_node, rgba_socket, transp_node, color_socket); + blender::bke::node_add_link(*ntree, *fromnode, *fromsock, *shtorgb_node, *shader_socket); + blender::bke::node_add_link( + *ntree, *shtorgb_node, *rgba_socket, *transp_node, *color_socket); } else { transp_node->locx_legacy = 0.5f * (fromnode->locx_legacy + tonode->locx_legacy); transp_node->locy_legacy = 0.5f * (fromnode->locy_legacy + tonode->locy_legacy); - blender::bke::node_add_link(ntree, fromnode, fromsock, transp_node, color_socket); + blender::bke::node_add_link(*ntree, *fromnode, *fromsock, *transp_node, *color_socket); } /* Link to input and material output node. */ - blender::bke::node_add_link(ntree, transp_node, transp_socket, tonode, tosock); + blender::bke::node_add_link(*ntree, *transp_node, *transp_socket, *tonode, *tosock); need_update = true; } @@ -1018,26 +1021,26 @@ static void displacement_node_insert(bNodeTree *ntree) } /* Replace link with displacement node. */ - blender::bke::node_remove_link(ntree, link); + blender::bke::node_remove_link(ntree, *link); /* Add displacement node. */ - bNode *node = blender::bke::node_add_static_node(nullptr, ntree, SH_NODE_DISPLACEMENT); + bNode *node = blender::bke::node_add_static_node(nullptr, *ntree, SH_NODE_DISPLACEMENT); node->locx_legacy = 0.5f * (fromnode->locx_legacy + tonode->locx_legacy); node->locy_legacy = 0.5f * (fromnode->locy_legacy + tonode->locy_legacy); - bNodeSocket *scale_socket = blender::bke::node_find_socket(node, SOCK_IN, "Scale"); - bNodeSocket *midlevel_socket = blender::bke::node_find_socket(node, SOCK_IN, "Midlevel"); - bNodeSocket *height_socket = blender::bke::node_find_socket(node, SOCK_IN, "Height"); + bNodeSocket *scale_socket = blender::bke::node_find_socket(*node, SOCK_IN, "Scale"); + bNodeSocket *midlevel_socket = blender::bke::node_find_socket(*node, SOCK_IN, "Midlevel"); + bNodeSocket *height_socket = blender::bke::node_find_socket(*node, SOCK_IN, "Height"); bNodeSocket *displacement_socket = blender::bke::node_find_socket( - node, SOCK_OUT, "Displacement"); + *node, SOCK_OUT, "Displacement"); /* Set default values for compatibility. */ *version_cycles_node_socket_float_value(scale_socket) = 0.1f; *version_cycles_node_socket_float_value(midlevel_socket) = 0.0f; /* Link to input and material output node. */ - blender::bke::node_add_link(ntree, fromnode, fromsock, node, height_socket); - blender::bke::node_add_link(ntree, node, displacement_socket, tonode, tosock); + blender::bke::node_add_link(*ntree, *fromnode, *fromsock, *node, *height_socket); + blender::bke::node_add_link(*ntree, *node, *displacement_socket, *tonode, *tosock); need_update = true; } @@ -1079,7 +1082,7 @@ static void square_roughness_node_insert(bNodeTree *ntree) bNode *tonode, bNodeSocket *tosock) { /* Add `sqrt` node. */ - bNode *node = blender::bke::node_add_static_node(nullptr, ntree, SH_NODE_MATH); + bNode *node = blender::bke::node_add_static_node(nullptr, *ntree, SH_NODE_MATH); node->custom1 = NODE_MATH_POWER; node->locx_legacy = 0.5f * (fromnode->locx_legacy + tonode->locx_legacy); node->locy_legacy = 0.5f * (fromnode->locy_legacy + tonode->locy_legacy); @@ -1087,9 +1090,9 @@ static void square_roughness_node_insert(bNodeTree *ntree) /* Link to input and material output node. */ *version_cycles_node_socket_float_value(static_cast(node->inputs.last)) = 0.5f; blender::bke::node_add_link( - ntree, fromnode, fromsock, node, static_cast(node->inputs.first)); + *ntree, *fromnode, *fromsock, *node, *static_cast(node->inputs.first)); blender::bke::node_add_link( - ntree, node, static_cast(node->outputs.first), tonode, tosock); + *ntree, *node, *static_cast(node->outputs.first), *tonode, *tosock); }; version_update_node_input(ntree, check_node, "Roughness", update_input, update_input_link); @@ -1138,7 +1141,7 @@ static void ambient_occlusion_node_relink(bNodeTree *ntree) node->custom1 = 1; /* samples */ node->custom2 &= ~SHD_AO_LOCAL; - bNodeSocket *distance_socket = blender::bke::node_find_socket(node, SOCK_IN, "Distance"); + bNodeSocket *distance_socket = blender::bke::node_find_socket(*node, SOCK_IN, "Distance"); *version_cycles_node_socket_float_value(distance_socket) = 0.0f; } } @@ -1155,9 +1158,9 @@ static void ambient_occlusion_node_relink(bNodeTree *ntree) } /* Replace links with color socket. */ - blender::bke::node_remove_link(ntree, link); - bNodeSocket *color_socket = blender::bke::node_find_socket(fromnode, SOCK_OUT, "Color"); - blender::bke::node_add_link(ntree, fromnode, color_socket, tonode, tosock); + blender::bke::node_remove_link(ntree, *link); + bNodeSocket *color_socket = blender::bke::node_find_socket(*fromnode, SOCK_OUT, "Color"); + blender::bke::node_add_link(*ntree, *fromnode, *color_socket, *tonode, *tosock); need_update = true; } @@ -1225,8 +1228,8 @@ static void light_emission_node_to_energy(Light *light, float *energy, float col /* Don't convert if anything is linked */ bNodeSocket *strength_socket = blender::bke::node_find_socket( - emission_node, SOCK_IN, "Strength"); - bNodeSocket *color_socket = blender::bke::node_find_socket(emission_node, SOCK_IN, "Color"); + *emission_node, SOCK_IN, "Strength"); + bNodeSocket *color_socket = blender::bke::node_find_socket(*emission_node, SOCK_IN, "Color"); if ((strength_socket->flag & SOCK_IS_LINKED) || (color_socket->flag & SOCK_IS_LINKED)) { return; @@ -1305,8 +1308,8 @@ static void update_math_node_single_operand_operators(bNodeTree *ntree) bNodeSocket *sockB = static_cast(BLI_findlink(&node->inputs, 1)); if (!sockA->link && sockB->link) { blender::bke::node_add_link( - ntree, sockB->link->fromnode, sockB->link->fromsock, node, sockA); - blender::bke::node_remove_link(ntree, sockB->link); + *ntree, *sockB->link->fromnode, *sockB->link->fromsock, *node, *sockA); + blender::bke::node_remove_link(ntree, *sockB->link); need_update = true; } } @@ -1338,40 +1341,40 @@ static void update_vector_math_node_add_and_subtract_operators(bNodeTree *ntree) LISTBASE_FOREACH (bNode *, node, &ntree->nodes) { if (node->type_legacy == SH_NODE_VECTOR_MATH) { - bNodeSocket *sockOutValue = blender::bke::node_find_socket(node, SOCK_OUT, "Value"); + bNodeSocket *sockOutValue = blender::bke::node_find_socket(*node, SOCK_OUT, "Value"); if (version_node_socket_is_used(sockOutValue) && ELEM(node->custom1, NODE_VECTOR_MATH_ADD, NODE_VECTOR_MATH_SUBTRACT)) { - bNode *absNode = blender::bke::node_add_static_node(nullptr, ntree, SH_NODE_VECTOR_MATH); + bNode *absNode = blender::bke::node_add_static_node(nullptr, *ntree, SH_NODE_VECTOR_MATH); absNode->custom1 = NODE_VECTOR_MATH_ABSOLUTE; absNode->locx_legacy = node->locx_legacy + node->width + 20.0f; absNode->locy_legacy = node->locy_legacy; - bNode *dotNode = blender::bke::node_add_static_node(nullptr, ntree, SH_NODE_VECTOR_MATH); + bNode *dotNode = blender::bke::node_add_static_node(nullptr, *ntree, SH_NODE_VECTOR_MATH); dotNode->custom1 = NODE_VECTOR_MATH_DOT_PRODUCT; dotNode->locx_legacy = absNode->locx_legacy + absNode->width + 20.0f; dotNode->locy_legacy = absNode->locy_legacy; bNodeSocket *sockDotB = static_cast(BLI_findlink(&dotNode->inputs, 1)); - bNodeSocket *sockDotOutValue = blender::bke::node_find_socket(dotNode, SOCK_OUT, "Value"); + bNodeSocket *sockDotOutValue = blender::bke::node_find_socket(*dotNode, SOCK_OUT, "Value"); copy_v3_fl(version_cycles_node_socket_vector_value(sockDotB), 1 / 3.0f); LISTBASE_FOREACH_BACKWARD_MUTABLE (bNodeLink *, link, &ntree->links) { if (link->fromsock == sockOutValue) { blender::bke::node_add_link( - ntree, dotNode, sockDotOutValue, link->tonode, link->tosock); - blender::bke::node_remove_link(ntree, link); + *ntree, *dotNode, *sockDotOutValue, *link->tonode, *link->tosock); + blender::bke::node_remove_link(ntree, *link); } } bNodeSocket *sockAbsA = static_cast(BLI_findlink(&absNode->inputs, 0)); bNodeSocket *sockDotA = static_cast(BLI_findlink(&dotNode->inputs, 0)); - bNodeSocket *sockOutVector = blender::bke::node_find_socket(node, SOCK_OUT, "Vector"); + bNodeSocket *sockOutVector = blender::bke::node_find_socket(*node, SOCK_OUT, "Vector"); bNodeSocket *sockAbsOutVector = blender::bke::node_find_socket( - absNode, SOCK_OUT, "Vector"); + *absNode, SOCK_OUT, "Vector"); - blender::bke::node_add_link(ntree, node, sockOutVector, absNode, sockAbsA); - blender::bke::node_add_link(ntree, absNode, sockAbsOutVector, dotNode, sockDotA); + blender::bke::node_add_link(*ntree, *node, *sockOutVector, *absNode, *sockAbsA); + blender::bke::node_add_link(*ntree, *absNode, *sockAbsOutVector, *dotNode, *sockDotA); need_update = true; } @@ -1393,7 +1396,7 @@ static void update_vector_math_node_dot_product_operator(bNodeTree *ntree) LISTBASE_FOREACH (bNode *, node, &ntree->nodes) { if (node->type_legacy == SH_NODE_VECTOR_MATH) { - bNodeSocket *sockOutVector = blender::bke::node_find_socket(node, SOCK_OUT, "Vector"); + bNodeSocket *sockOutVector = blender::bke::node_find_socket(*node, SOCK_OUT, "Vector"); if (version_node_socket_is_used(sockOutVector) && node->custom1 == NODE_VECTOR_MATH_DOT_PRODUCT) { @@ -1410,7 +1413,7 @@ static void update_vector_math_node_dot_product_operator(bNodeTree *ntree) copy_v4_fl(version_cycles_node_socket_rgba_value(link->tosock), 0.0f); break; } - blender::bke::node_remove_link(ntree, link); + blender::bke::node_remove_link(ntree, *link); } } need_update = true; @@ -1435,34 +1438,35 @@ static void update_vector_math_node_cross_product_operator(bNodeTree *ntree) LISTBASE_FOREACH (bNode *, node, &ntree->nodes) { if (node->type_legacy == SH_NODE_VECTOR_MATH) { if (node->custom1 == NODE_VECTOR_MATH_CROSS_PRODUCT) { - bNodeSocket *sockOutVector = blender::bke::node_find_socket(node, SOCK_OUT, "Vector"); + bNodeSocket *sockOutVector = blender::bke::node_find_socket(*node, SOCK_OUT, "Vector"); if (version_node_socket_is_used(sockOutVector)) { bNode *normalizeNode = blender::bke::node_add_static_node( - nullptr, ntree, SH_NODE_VECTOR_MATH); + nullptr, *ntree, SH_NODE_VECTOR_MATH); normalizeNode->custom1 = NODE_VECTOR_MATH_NORMALIZE; normalizeNode->locx_legacy = node->locx_legacy + node->width + 20.0f; normalizeNode->locy_legacy = node->locy_legacy; bNodeSocket *sockNormalizeOut = blender::bke::node_find_socket( - normalizeNode, SOCK_OUT, "Vector"); + *normalizeNode, SOCK_OUT, "Vector"); LISTBASE_FOREACH_BACKWARD_MUTABLE (bNodeLink *, link, &ntree->links) { if (link->fromsock == sockOutVector) { blender::bke::node_add_link( - ntree, normalizeNode, sockNormalizeOut, link->tonode, link->tosock); - blender::bke::node_remove_link(ntree, link); + *ntree, *normalizeNode, *sockNormalizeOut, *link->tonode, *link->tosock); + blender::bke::node_remove_link(ntree, *link); } } bNodeSocket *sockNormalizeA = static_cast( BLI_findlink(&normalizeNode->inputs, 0)); - blender::bke::node_add_link(ntree, node, sockOutVector, normalizeNode, sockNormalizeA); + blender::bke::node_add_link( + *ntree, *node, *sockOutVector, *normalizeNode, *sockNormalizeA); need_update = true; } - bNodeSocket *sockOutValue = blender::bke::node_find_socket(node, SOCK_OUT, "Value"); + bNodeSocket *sockOutValue = blender::bke::node_find_socket(*node, SOCK_OUT, "Value"); if (version_node_socket_is_used(sockOutValue)) { bNode *lengthNode = blender::bke::node_add_static_node( - nullptr, ntree, SH_NODE_VECTOR_MATH); + nullptr, *ntree, SH_NODE_VECTOR_MATH); lengthNode->custom1 = NODE_VECTOR_MATH_LENGTH; lengthNode->locx_legacy = node->locx_legacy + node->width + 20.0f; if (version_node_socket_is_used(sockOutVector)) { @@ -1472,18 +1476,18 @@ static void update_vector_math_node_cross_product_operator(bNodeTree *ntree) lengthNode->locy_legacy = node->locy_legacy; } bNodeSocket *sockLengthOut = blender::bke::node_find_socket( - lengthNode, SOCK_OUT, "Value"); + *lengthNode, SOCK_OUT, "Value"); LISTBASE_FOREACH_BACKWARD_MUTABLE (bNodeLink *, link, &ntree->links) { if (link->fromsock == sockOutValue) { blender::bke::node_add_link( - ntree, lengthNode, sockLengthOut, link->tonode, link->tosock); - blender::bke::node_remove_link(ntree, link); + *ntree, *lengthNode, *sockLengthOut, *link->tonode, *link->tosock); + blender::bke::node_remove_link(ntree, *link); } } bNodeSocket *sockLengthA = static_cast( BLI_findlink(&lengthNode->inputs, 0)); - blender::bke::node_add_link(ntree, node, sockOutVector, lengthNode, sockLengthA); + blender::bke::node_add_link(*ntree, *node, *sockOutVector, *lengthNode, *sockLengthA); need_update = true; } @@ -1508,24 +1512,24 @@ static void update_vector_math_node_normalize_operator(bNodeTree *ntree) LISTBASE_FOREACH (bNode *, node, &ntree->nodes) { if (node->type_legacy == SH_NODE_VECTOR_MATH) { - bNodeSocket *sockOutValue = blender::bke::node_find_socket(node, SOCK_OUT, "Value"); + bNodeSocket *sockOutValue = blender::bke::node_find_socket(*node, SOCK_OUT, "Value"); if (node->custom1 == NODE_VECTOR_MATH_NORMALIZE && version_node_socket_is_used(sockOutValue)) { - bNodeSocket *sockOutVector = blender::bke::node_find_socket(node, SOCK_OUT, "Vector"); + bNodeSocket *sockOutVector = blender::bke::node_find_socket(*node, SOCK_OUT, "Vector"); if (version_node_socket_is_used(sockOutVector)) { bNode *lengthNode = blender::bke::node_add_static_node( - nullptr, ntree, SH_NODE_VECTOR_MATH); + nullptr, *ntree, SH_NODE_VECTOR_MATH); lengthNode->custom1 = NODE_VECTOR_MATH_LENGTH; lengthNode->locx_legacy = node->locx_legacy + node->width + 20.0f; lengthNode->locy_legacy = node->locy_legacy; bNodeSocket *sockLengthValue = blender::bke::node_find_socket( - lengthNode, SOCK_OUT, "Value"); + *lengthNode, SOCK_OUT, "Value"); LISTBASE_FOREACH_BACKWARD_MUTABLE (bNodeLink *, link, &ntree->links) { if (link->fromsock == sockOutValue) { blender::bke::node_add_link( - ntree, lengthNode, sockLengthValue, link->tonode, link->tosock); - blender::bke::node_remove_link(ntree, link); + *ntree, *lengthNode, *sockLengthValue, *link->tonode, *link->tosock); + blender::bke::node_remove_link(ntree, *link); } } bNodeSocket *sockA = static_cast(BLI_findlink(&node->inputs, 0)); @@ -1534,7 +1538,7 @@ static void update_vector_math_node_normalize_operator(bNodeTree *ntree) if (sockA->link) { bNodeLink *link = sockA->link; blender::bke::node_add_link( - ntree, link->fromnode, link->fromsock, lengthNode, sockLengthA); + *ntree, *link->fromnode, *link->fromsock, *lengthNode, *sockLengthA); } else { copy_v3_v3(version_cycles_node_socket_vector_value(sockLengthA), @@ -1602,34 +1606,35 @@ static void update_vector_math_node_average_operator(bNodeTree *ntree) /* See update_vector_math_node_operators_enum_mapping. */ if (node->custom1 == -1) { node->custom1 = NODE_VECTOR_MATH_ADD; - bNodeSocket *sockOutVector = blender::bke::node_find_socket(node, SOCK_OUT, "Vector"); + bNodeSocket *sockOutVector = blender::bke::node_find_socket(*node, SOCK_OUT, "Vector"); if (version_node_socket_is_used(sockOutVector)) { bNode *normalizeNode = blender::bke::node_add_static_node( - nullptr, ntree, SH_NODE_VECTOR_MATH); + nullptr, *ntree, SH_NODE_VECTOR_MATH); normalizeNode->custom1 = NODE_VECTOR_MATH_NORMALIZE; normalizeNode->locx_legacy = node->locx_legacy + node->width + 20.0f; normalizeNode->locy_legacy = node->locy_legacy; bNodeSocket *sockNormalizeOut = blender::bke::node_find_socket( - normalizeNode, SOCK_OUT, "Vector"); + *normalizeNode, SOCK_OUT, "Vector"); LISTBASE_FOREACH_BACKWARD_MUTABLE (bNodeLink *, link, &ntree->links) { if (link->fromsock == sockOutVector) { blender::bke::node_add_link( - ntree, normalizeNode, sockNormalizeOut, link->tonode, link->tosock); - blender::bke::node_remove_link(ntree, link); + *ntree, *normalizeNode, *sockNormalizeOut, *link->tonode, *link->tosock); + blender::bke::node_remove_link(ntree, *link); } } bNodeSocket *sockNormalizeA = static_cast( BLI_findlink(&normalizeNode->inputs, 0)); - blender::bke::node_add_link(ntree, node, sockOutVector, normalizeNode, sockNormalizeA); + blender::bke::node_add_link( + *ntree, *node, *sockOutVector, *normalizeNode, *sockNormalizeA); need_update = true; } - bNodeSocket *sockOutValue = blender::bke::node_find_socket(node, SOCK_OUT, "Value"); + bNodeSocket *sockOutValue = blender::bke::node_find_socket(*node, SOCK_OUT, "Value"); if (version_node_socket_is_used(sockOutValue)) { bNode *lengthNode = blender::bke::node_add_static_node( - nullptr, ntree, SH_NODE_VECTOR_MATH); + nullptr, *ntree, SH_NODE_VECTOR_MATH); lengthNode->custom1 = NODE_VECTOR_MATH_LENGTH; lengthNode->locx_legacy = node->locx_legacy + node->width + 20.0f; if (version_node_socket_is_used(sockOutVector)) { @@ -1639,18 +1644,18 @@ static void update_vector_math_node_average_operator(bNodeTree *ntree) lengthNode->locy_legacy = node->locy_legacy; } bNodeSocket *sockLengthOut = blender::bke::node_find_socket( - lengthNode, SOCK_OUT, "Value"); + *lengthNode, SOCK_OUT, "Value"); LISTBASE_FOREACH_BACKWARD_MUTABLE (bNodeLink *, link, &ntree->links) { if (link->fromsock == sockOutValue) { blender::bke::node_add_link( - ntree, lengthNode, sockLengthOut, link->tonode, link->tosock); - blender::bke::node_remove_link(ntree, link); + *ntree, *lengthNode, *sockLengthOut, *link->tonode, *link->tosock); + blender::bke::node_remove_link(ntree, *link); } } bNodeSocket *sockLengthA = static_cast( BLI_findlink(&lengthNode->inputs, 0)); - blender::bke::node_add_link(ntree, node, sockOutVector, lengthNode, sockLengthA); + blender::bke::node_add_link(*ntree, *node, *sockOutVector, *lengthNode, *sockLengthA); need_update = true; } @@ -1758,16 +1763,16 @@ static void update_mapping_node_inputs_and_properties(bNodeTree *ntree) node->custom1 = mapping->type; node->width = 140.0f; - bNodeSocket *sockLocation = blender::bke::node_find_socket(node, SOCK_IN, "Location"); + bNodeSocket *sockLocation = blender::bke::node_find_socket(*node, SOCK_IN, "Location"); copy_v3_v3(version_cycles_node_socket_vector_value(sockLocation), mapping->loc); - bNodeSocket *sockRotation = blender::bke::node_find_socket(node, SOCK_IN, "Rotation"); + bNodeSocket *sockRotation = blender::bke::node_find_socket(*node, SOCK_IN, "Rotation"); copy_v3_v3(version_cycles_node_socket_vector_value(sockRotation), mapping->rot); - bNodeSocket *sockScale = blender::bke::node_find_socket(node, SOCK_IN, "Scale"); + bNodeSocket *sockScale = blender::bke::node_find_socket(*node, SOCK_IN, "Scale"); copy_v3_v3(version_cycles_node_socket_vector_value(sockScale), mapping->size); bNode *maximumNode = nullptr; if (mapping->flag & TEXMAP_CLIP_MIN) { - maximumNode = blender::bke::node_add_static_node(nullptr, ntree, SH_NODE_VECTOR_MATH); + maximumNode = blender::bke::node_add_static_node(nullptr, *ntree, SH_NODE_VECTOR_MATH); maximumNode->custom1 = NODE_VECTOR_MATH_MAXIMUM; if (mapping->flag & TEXMAP_CLIP_MAX) { maximumNode->locx_legacy = node->locx_legacy + (node->width + 20.0f) * 2.0f; @@ -1779,21 +1784,22 @@ static void update_mapping_node_inputs_and_properties(bNodeTree *ntree) bNodeSocket *sockMaximumB = static_cast( BLI_findlink(&maximumNode->inputs, 1)); copy_v3_v3(version_cycles_node_socket_vector_value(sockMaximumB), mapping->min); - bNodeSocket *sockMappingResult = blender::bke::node_find_socket(node, SOCK_OUT, "Vector"); + bNodeSocket *sockMappingResult = blender::bke::node_find_socket(*node, SOCK_OUT, "Vector"); LISTBASE_FOREACH_BACKWARD_MUTABLE (bNodeLink *, link, &ntree->links) { if (link->fromsock == sockMappingResult) { bNodeSocket *sockMaximumResult = blender::bke::node_find_socket( - maximumNode, SOCK_OUT, "Vector"); + *maximumNode, SOCK_OUT, "Vector"); blender::bke::node_add_link( - ntree, maximumNode, sockMaximumResult, link->tonode, link->tosock); - blender::bke::node_remove_link(ntree, link); + *ntree, *maximumNode, *sockMaximumResult, *link->tonode, *link->tosock); + blender::bke::node_remove_link(ntree, *link); } } if (!(mapping->flag & TEXMAP_CLIP_MAX)) { bNodeSocket *sockMaximumA = static_cast( BLI_findlink(&maximumNode->inputs, 0)); - blender::bke::node_add_link(ntree, node, sockMappingResult, maximumNode, sockMaximumA); + blender::bke::node_add_link( + *ntree, *node, *sockMappingResult, *maximumNode, *sockMaximumA); } need_update = true; @@ -1801,7 +1807,7 @@ static void update_mapping_node_inputs_and_properties(bNodeTree *ntree) bNode *minimumNode = nullptr; if (mapping->flag & TEXMAP_CLIP_MAX) { - minimumNode = blender::bke::node_add_static_node(nullptr, ntree, SH_NODE_VECTOR_MATH); + minimumNode = blender::bke::node_add_static_node(nullptr, *ntree, SH_NODE_VECTOR_MATH); minimumNode->custom1 = NODE_VECTOR_MATH_MINIMUM; minimumNode->locx_legacy = node->locx_legacy + node->width + 20.0f; minimumNode->locy_legacy = node->locy_legacy; @@ -1810,27 +1816,28 @@ static void update_mapping_node_inputs_and_properties(bNodeTree *ntree) copy_v3_v3(version_cycles_node_socket_vector_value(sockMinimumB), mapping->max); bNodeSocket *sockMinimumResult = blender::bke::node_find_socket( - minimumNode, SOCK_OUT, "Vector"); - bNodeSocket *sockMappingResult = blender::bke::node_find_socket(node, SOCK_OUT, "Vector"); + *minimumNode, SOCK_OUT, "Vector"); + bNodeSocket *sockMappingResult = blender::bke::node_find_socket(*node, SOCK_OUT, "Vector"); if (maximumNode) { bNodeSocket *sockMaximumA = static_cast( BLI_findlink(&maximumNode->inputs, 0)); blender::bke::node_add_link( - ntree, minimumNode, sockMinimumResult, maximumNode, sockMaximumA); + *ntree, *minimumNode, *sockMinimumResult, *maximumNode, *sockMaximumA); } else { LISTBASE_FOREACH_BACKWARD_MUTABLE (bNodeLink *, link, &ntree->links) { if (link->fromsock == sockMappingResult) { blender::bke::node_add_link( - ntree, minimumNode, sockMinimumResult, link->tonode, link->tosock); - blender::bke::node_remove_link(ntree, link); + *ntree, *minimumNode, *sockMinimumResult, *link->tonode, *link->tosock); + blender::bke::node_remove_link(ntree, *link); } } } bNodeSocket *sockMinimumA = static_cast( BLI_findlink(&minimumNode->inputs, 0)); - blender::bke::node_add_link(ntree, node, sockMappingResult, minimumNode, sockMinimumA); + blender::bke::node_add_link( + *ntree, *node, *sockMappingResult, *minimumNode, *sockMinimumA); need_update = true; } @@ -1952,15 +1959,15 @@ static void update_voronoi_node_crackle(bNodeTree *ntree) LISTBASE_FOREACH (bNode *, node, &ntree->nodes) { if (node->type_legacy == SH_NODE_TEX_VORONOI && node->storage) { NodeTexVoronoi *tex = (NodeTexVoronoi *)node->storage; - bNodeSocket *sockDistance = blender::bke::node_find_socket(node, SOCK_OUT, "Distance"); - bNodeSocket *sockColor = blender::bke::node_find_socket(node, SOCK_OUT, "Color"); + bNodeSocket *sockDistance = blender::bke::node_find_socket(*node, SOCK_OUT, "Distance"); + bNodeSocket *sockColor = blender::bke::node_find_socket(*node, SOCK_OUT, "Color"); if (tex->feature == 4 && (version_node_socket_is_used(sockDistance) || version_node_socket_is_used(sockColor))) { tex->feature = SHD_VORONOI_F1; bNode *voronoiNode = blender::bke::node_add_static_node( - nullptr, ntree, SH_NODE_TEX_VORONOI); + nullptr, *ntree, SH_NODE_TEX_VORONOI); NodeTexVoronoi *texVoronoi = (NodeTexVoronoi *)voronoiNode->storage; texVoronoi->feature = SHD_VORONOI_F2; texVoronoi->distance = tex->distance; @@ -1968,67 +1975,67 @@ static void update_voronoi_node_crackle(bNodeTree *ntree) voronoiNode->locx_legacy = node->locx_legacy + node->width + 20.0f; voronoiNode->locy_legacy = node->locy_legacy; - bNodeSocket *sockVector = blender::bke::node_find_socket(node, SOCK_IN, "Vector"); - bNodeSocket *sockScale = blender::bke::node_find_socket(node, SOCK_IN, "Scale"); - bNodeSocket *sockExponent = blender::bke::node_find_socket(node, SOCK_IN, "Exponent"); + bNodeSocket *sockVector = blender::bke::node_find_socket(*node, SOCK_IN, "Vector"); + bNodeSocket *sockScale = blender::bke::node_find_socket(*node, SOCK_IN, "Scale"); + bNodeSocket *sockExponent = blender::bke::node_find_socket(*node, SOCK_IN, "Exponent"); bNodeSocket *sockVoronoiVector = blender::bke::node_find_socket( - voronoiNode, SOCK_IN, "Vector"); + *voronoiNode, SOCK_IN, "Vector"); bNodeSocket *sockVoronoiScale = blender::bke::node_find_socket( - voronoiNode, SOCK_IN, "Scale"); + *voronoiNode, SOCK_IN, "Scale"); bNodeSocket *sockVoronoiExponent = blender::bke::node_find_socket( - voronoiNode, SOCK_IN, "Exponent"); + *voronoiNode, SOCK_IN, "Exponent"); if (sockVector->link) { - blender::bke::node_add_link(ntree, - sockVector->link->fromnode, - sockVector->link->fromsock, - voronoiNode, - sockVoronoiVector); + blender::bke::node_add_link(*ntree, + *sockVector->link->fromnode, + *sockVector->link->fromsock, + *voronoiNode, + *sockVoronoiVector); } *version_cycles_node_socket_float_value( sockVoronoiScale) = *version_cycles_node_socket_float_value(sockScale); if (sockScale->link) { - blender::bke::node_add_link(ntree, - sockScale->link->fromnode, - sockScale->link->fromsock, - voronoiNode, - sockVoronoiScale); + blender::bke::node_add_link(*ntree, + *sockScale->link->fromnode, + *sockScale->link->fromsock, + *voronoiNode, + *sockVoronoiScale); } *version_cycles_node_socket_float_value( sockVoronoiExponent) = *version_cycles_node_socket_float_value(sockExponent); if (sockExponent->link) { - blender::bke::node_add_link(ntree, - sockExponent->link->fromnode, - sockExponent->link->fromsock, - voronoiNode, - sockVoronoiExponent); + blender::bke::node_add_link(*ntree, + *sockExponent->link->fromnode, + *sockExponent->link->fromsock, + *voronoiNode, + *sockVoronoiExponent); } - bNode *subtractNode = blender::bke::node_add_static_node(nullptr, ntree, SH_NODE_MATH); + bNode *subtractNode = blender::bke::node_add_static_node(nullptr, *ntree, SH_NODE_MATH); subtractNode->custom1 = NODE_MATH_SUBTRACT; subtractNode->locx_legacy = voronoiNode->locx_legacy + voronoiNode->width + 20.0f; subtractNode->locy_legacy = voronoiNode->locy_legacy; bNodeSocket *sockSubtractOutValue = blender::bke::node_find_socket( - subtractNode, SOCK_OUT, "Value"); + *subtractNode, SOCK_OUT, "Value"); LISTBASE_FOREACH_BACKWARD_MUTABLE (bNodeLink *, link, &ntree->links) { if (link->fromnode == node) { blender::bke::node_add_link( - ntree, subtractNode, sockSubtractOutValue, link->tonode, link->tosock); - blender::bke::node_remove_link(ntree, link); + *ntree, *subtractNode, *sockSubtractOutValue, *link->tonode, *link->tosock); + blender::bke::node_remove_link(ntree, *link); } } - bNodeSocket *sockDistanceF1 = blender::bke::node_find_socket(node, SOCK_OUT, "Distance"); + bNodeSocket *sockDistanceF1 = blender::bke::node_find_socket(*node, SOCK_OUT, "Distance"); bNodeSocket *sockDistanceF2 = blender::bke::node_find_socket( - voronoiNode, SOCK_OUT, "Distance"); + *voronoiNode, SOCK_OUT, "Distance"); bNodeSocket *sockSubtractA = static_cast( BLI_findlink(&subtractNode->inputs, 0)); bNodeSocket *sockSubtractB = static_cast( BLI_findlink(&subtractNode->inputs, 1)); - blender::bke::node_add_link(ntree, node, sockDistanceF1, subtractNode, sockSubtractB); + blender::bke::node_add_link(*ntree, *node, *sockDistanceF1, *subtractNode, *sockSubtractB); blender::bke::node_add_link( - ntree, voronoiNode, sockDistanceF2, subtractNode, sockSubtractA); + *ntree, *voronoiNode, *sockDistanceF2, *subtractNode, *sockSubtractA); need_update = true; } @@ -2057,20 +2064,20 @@ static void update_voronoi_node_coloring(bNodeTree *ntree) if (node && node->type_legacy == SH_NODE_TEX_VORONOI && node->storage) { NodeTexVoronoi *tex = (NodeTexVoronoi *)node->storage; if (tex->coloring == 0) { - bNodeSocket *sockColor = blender::bke::node_find_socket(node, SOCK_OUT, "Color"); + bNodeSocket *sockColor = blender::bke::node_find_socket(*node, SOCK_OUT, "Color"); if (link->fromsock == sockColor) { - bNodeSocket *sockDistance = blender::bke::node_find_socket(node, SOCK_OUT, "Distance"); - blender::bke::node_add_link(ntree, node, sockDistance, link->tonode, link->tosock); - blender::bke::node_remove_link(ntree, link); + bNodeSocket *sockDistance = blender::bke::node_find_socket(*node, SOCK_OUT, "Distance"); + blender::bke::node_add_link(*ntree, *node, *sockDistance, *link->tonode, *link->tosock); + blender::bke::node_remove_link(ntree, *link); need_update = true; } } else { - bNodeSocket *sockDistance = blender::bke::node_find_socket(node, SOCK_OUT, "Distance"); + bNodeSocket *sockDistance = blender::bke::node_find_socket(*node, SOCK_OUT, "Distance"); if (link->fromsock == sockDistance) { - bNodeSocket *sockColor = blender::bke::node_find_socket(node, SOCK_OUT, "Color"); - blender::bke::node_add_link(ntree, node, sockColor, link->tonode, link->tosock); - blender::bke::node_remove_link(ntree, link); + bNodeSocket *sockColor = blender::bke::node_find_socket(*node, SOCK_OUT, "Color"); + blender::bke::node_add_link(*ntree, *node, *sockColor, *link->tonode, *link->tosock); + blender::bke::node_remove_link(ntree, *link); need_update = true; } } @@ -2093,22 +2100,22 @@ static void update_voronoi_node_square_distance(bNodeTree *ntree) LISTBASE_FOREACH (bNode *, node, &ntree->nodes) { if (node->type_legacy == SH_NODE_TEX_VORONOI && node->storage) { NodeTexVoronoi *tex = (NodeTexVoronoi *)node->storage; - bNodeSocket *sockDistance = blender::bke::node_find_socket(node, SOCK_OUT, "Distance"); + bNodeSocket *sockDistance = blender::bke::node_find_socket(*node, SOCK_OUT, "Distance"); if (tex->distance == SHD_VORONOI_EUCLIDEAN && ELEM(tex->feature, SHD_VORONOI_F1, SHD_VORONOI_F2) && version_node_socket_is_used(sockDistance)) { - bNode *multiplyNode = blender::bke::node_add_static_node(nullptr, ntree, SH_NODE_MATH); + bNode *multiplyNode = blender::bke::node_add_static_node(nullptr, *ntree, SH_NODE_MATH); multiplyNode->custom1 = NODE_MATH_MULTIPLY; multiplyNode->locx_legacy = node->locx_legacy + node->width + 20.0f; multiplyNode->locy_legacy = node->locy_legacy; - bNodeSocket *sockValue = blender::bke::node_find_socket(multiplyNode, SOCK_OUT, "Value"); + bNodeSocket *sockValue = blender::bke::node_find_socket(*multiplyNode, SOCK_OUT, "Value"); LISTBASE_FOREACH_BACKWARD_MUTABLE (bNodeLink *, link, &ntree->links) { if (link->fromsock == sockDistance) { blender::bke::node_add_link( - ntree, multiplyNode, sockValue, link->tonode, link->tosock); - blender::bke::node_remove_link(ntree, link); + *ntree, *multiplyNode, *sockValue, *link->tonode, *link->tosock); + blender::bke::node_remove_link(ntree, *link); } } @@ -2117,8 +2124,8 @@ static void update_voronoi_node_square_distance(bNodeTree *ntree) bNodeSocket *sockMultiplyB = static_cast( BLI_findlink(&multiplyNode->inputs, 1)); - blender::bke::node_add_link(ntree, node, sockDistance, multiplyNode, sockMultiplyA); - blender::bke::node_add_link(ntree, node, sockDistance, multiplyNode, sockMultiplyB); + blender::bke::node_add_link(*ntree, *node, *sockDistance, *multiplyNode, *sockMultiplyA); + blender::bke::node_add_link(*ntree, *node, *sockDistance, *multiplyNode, *sockMultiplyB); need_update = true; } @@ -2142,14 +2149,14 @@ static void update_noise_and_wave_distortion(bNodeTree *ntree) LISTBASE_FOREACH (bNode *, node, &ntree->nodes) { if (ELEM(node->type_legacy, SH_NODE_TEX_NOISE, SH_NODE_TEX_WAVE)) { - bNodeSocket *sockDistortion = blender::bke::node_find_socket(node, SOCK_IN, "Distortion"); + bNodeSocket *sockDistortion = blender::bke::node_find_socket(*node, SOCK_IN, "Distortion"); float *distortion = version_cycles_node_socket_float_value(sockDistortion); if (version_node_socket_is_used(sockDistortion) && sockDistortion->link != nullptr) { bNode *distortionInputNode = sockDistortion->link->fromnode; bNodeSocket *distortionInputSock = sockDistortion->link->fromsock; - bNode *mulNode = blender::bke::node_add_static_node(nullptr, ntree, SH_NODE_MATH); + bNode *mulNode = blender::bke::node_add_static_node(nullptr, *ntree, SH_NODE_MATH); mulNode->custom1 = NODE_MATH_MULTIPLY; mulNode->locx_legacy = node->locx_legacy; mulNode->locy_legacy = node->locy_legacy - 240.0f; @@ -2157,12 +2164,12 @@ static void update_noise_and_wave_distortion(bNodeTree *ntree) bNodeSocket *mulSockA = static_cast(BLI_findlink(&mulNode->inputs, 0)); bNodeSocket *mulSockB = static_cast(BLI_findlink(&mulNode->inputs, 1)); *version_cycles_node_socket_float_value(mulSockB) = 0.5f; - bNodeSocket *mulSockOut = blender::bke::node_find_socket(mulNode, SOCK_OUT, "Value"); + bNodeSocket *mulSockOut = blender::bke::node_find_socket(*mulNode, SOCK_OUT, "Value"); - blender::bke::node_remove_link(ntree, sockDistortion->link); + blender::bke::node_remove_link(ntree, *sockDistortion->link); blender::bke::node_add_link( - ntree, distortionInputNode, distortionInputSock, mulNode, mulSockA); - blender::bke::node_add_link(ntree, mulNode, mulSockOut, node, sockDistortion); + *ntree, *distortionInputNode, *distortionInputSock, *mulNode, *mulSockA); + blender::bke::node_add_link(*ntree, *mulNode, *mulSockOut, *node, *sockDistortion); need_update = true; } @@ -2197,7 +2204,7 @@ static void update_wave_node_directions_and_offset(bNodeTree *ntree) if (tex->wave_profile == SHD_WAVE_PROFILE_SIN) { bNodeSocket *sockPhaseOffset = blender::bke::node_find_socket( - node, SOCK_IN, "Phase Offset"); + *node, SOCK_IN, "Phase Offset"); *version_cycles_node_socket_float_value(sockPhaseOffset) = M_PI_2; } } diff --git a/source/blender/blenloader/intern/versioning_290.cc b/source/blender/blenloader/intern/versioning_290.cc index 061785d99ff..29ba87d1271 100644 --- a/source/blender/blenloader/intern/versioning_290.cc +++ b/source/blender/blenloader/intern/versioning_290.cc @@ -398,10 +398,10 @@ static void version_node_socket_duplicate(bNodeTree *ntree, LISTBASE_FOREACH_MUTABLE (bNodeLink *, link, &ntree->links) { if (link->tonode->type_legacy == node_type) { bNode *node = link->tonode; - bNodeSocket *dest_socket = blender::bke::node_find_socket(node, SOCK_IN, new_name); + bNodeSocket *dest_socket = blender::bke::node_find_socket(*node, SOCK_IN, new_name); BLI_assert(dest_socket); if (STREQ(link->tosock->name, old_name)) { - blender::bke::node_add_link(ntree, link->fromnode, link->fromsock, node, dest_socket); + blender::bke::node_add_link(*ntree, *link->fromnode, *link->fromsock, *node, *dest_socket); } } } @@ -409,8 +409,8 @@ static void version_node_socket_duplicate(bNodeTree *ntree, /* Duplicate the default value from the old socket and assign it to the new socket. */ LISTBASE_FOREACH (bNode *, node, &ntree->nodes) { if (node->type_legacy == node_type) { - bNodeSocket *source_socket = blender::bke::node_find_socket(node, SOCK_IN, old_name); - bNodeSocket *dest_socket = blender::bke::node_find_socket(node, SOCK_IN, new_name); + bNodeSocket *source_socket = blender::bke::node_find_socket(*node, SOCK_IN, old_name); + bNodeSocket *dest_socket = blender::bke::node_find_socket(*node, SOCK_IN, new_name); BLI_assert(source_socket && dest_socket); if (dest_socket->default_value) { MEM_freeN(dest_socket->default_value); @@ -808,7 +808,7 @@ static void version_node_join_geometry_for_multi_input_socket(bNodeTree *ntree) bNodeSocket *socket = static_cast(node->inputs.first); socket->flag |= SOCK_MULTI_INPUT; socket->limit = 4095; - blender::bke::node_remove_socket(ntree, node, socket->next); + blender::bke::node_remove_socket(*ntree, *node, *socket->next); } } } diff --git a/source/blender/blenloader/intern/versioning_300.cc b/source/blender/blenloader/intern/versioning_300.cc index 7cda595ed6e..241182487f4 100644 --- a/source/blender/blenloader/intern/versioning_300.cc +++ b/source/blender/blenloader/intern/versioning_300.cc @@ -561,71 +561,71 @@ static bNodeTree *add_realize_node_tree(Main *bmain) node_tree->tree_interface.add_socket( "Geometry", "", "NodeSocketGeometry", NODE_INTERFACE_SOCKET_INPUT, nullptr); - bNode *group_input = blender::bke::node_add_static_node(nullptr, node_tree, NODE_GROUP_INPUT); + bNode *group_input = blender::bke::node_add_static_node(nullptr, *node_tree, NODE_GROUP_INPUT); group_input->locx_legacy = -400.0f; - bNode *group_output = blender::bke::node_add_static_node(nullptr, node_tree, NODE_GROUP_OUTPUT); + bNode *group_output = blender::bke::node_add_static_node(nullptr, *node_tree, NODE_GROUP_OUTPUT); group_output->locx_legacy = 500.0f; group_output->flag |= NODE_DO_OUTPUT; - bNode *join = blender::bke::node_add_static_node(nullptr, node_tree, GEO_NODE_JOIN_GEOMETRY); + bNode *join = blender::bke::node_add_static_node(nullptr, *node_tree, GEO_NODE_JOIN_GEOMETRY); join->locx_legacy = group_output->locx_legacy - 175.0f; join->locy_legacy = group_output->locy_legacy; bNode *conv = blender::bke::node_add_static_node( - nullptr, node_tree, GEO_NODE_POINTS_TO_VERTICES); + nullptr, *node_tree, GEO_NODE_POINTS_TO_VERTICES); conv->locx_legacy = join->locx_legacy - 175.0f; conv->locy_legacy = join->locy_legacy - 70.0; bNode *separate = blender::bke::node_add_static_node( - nullptr, node_tree, GEO_NODE_SEPARATE_COMPONENTS); + nullptr, *node_tree, GEO_NODE_SEPARATE_COMPONENTS); separate->locx_legacy = join->locx_legacy - 350.0f; separate->locy_legacy = join->locy_legacy + 50.0f; bNode *realize = blender::bke::node_add_static_node( - nullptr, node_tree, GEO_NODE_REALIZE_INSTANCES); + nullptr, *node_tree, GEO_NODE_REALIZE_INSTANCES); realize->locx_legacy = separate->locx_legacy - 200.0f; realize->locy_legacy = join->locy_legacy; - blender::bke::node_add_link(node_tree, - group_input, - static_cast(group_input->outputs.first), - realize, - static_cast(realize->inputs.first)); - blender::bke::node_add_link(node_tree, - realize, - static_cast(realize->outputs.first), - separate, - static_cast(separate->inputs.first)); - blender::bke::node_add_link(node_tree, - conv, - static_cast(conv->outputs.first), - join, - static_cast(join->inputs.first)); - blender::bke::node_add_link(node_tree, - separate, - static_cast(BLI_findlink(&separate->outputs, 3)), - join, - static_cast(join->inputs.first)); - blender::bke::node_add_link(node_tree, - separate, - static_cast(BLI_findlink(&separate->outputs, 1)), - conv, - static_cast(conv->inputs.first)); - blender::bke::node_add_link(node_tree, - separate, - static_cast(BLI_findlink(&separate->outputs, 2)), - join, - static_cast(join->inputs.first)); - blender::bke::node_add_link(node_tree, - separate, - static_cast(separate->outputs.first), - join, - static_cast(join->inputs.first)); - blender::bke::node_add_link(node_tree, - join, - static_cast(join->outputs.first), - group_output, - static_cast(group_output->inputs.first)); + blender::bke::node_add_link(*node_tree, + *group_input, + *static_cast(group_input->outputs.first), + *realize, + *static_cast(realize->inputs.first)); + blender::bke::node_add_link(*node_tree, + *realize, + *static_cast(realize->outputs.first), + *separate, + *static_cast(separate->inputs.first)); + blender::bke::node_add_link(*node_tree, + *conv, + *static_cast(conv->outputs.first), + *join, + *static_cast(join->inputs.first)); + blender::bke::node_add_link(*node_tree, + *separate, + *static_cast(BLI_findlink(&separate->outputs, 3)), + *join, + *static_cast(join->inputs.first)); + blender::bke::node_add_link(*node_tree, + *separate, + *static_cast(BLI_findlink(&separate->outputs, 1)), + *conv, + *static_cast(conv->inputs.first)); + blender::bke::node_add_link(*node_tree, + *separate, + *static_cast(BLI_findlink(&separate->outputs, 2)), + *join, + *static_cast(join->inputs.first)); + blender::bke::node_add_link(*node_tree, + *separate, + *static_cast(separate->outputs.first), + *join, + *static_cast(join->inputs.first)); + blender::bke::node_add_link(*node_tree, + *join, + *static_cast(join->outputs.first), + *group_output, + *static_cast(group_output->inputs.first)); LISTBASE_FOREACH (bNode *, node, &node_tree->nodes) { - blender::bke::node_set_selected(node, false); + blender::bke::node_set_selected(*node, false); } version_socket_update_is_used(node_tree); @@ -684,18 +684,18 @@ static void version_geometry_nodes_replace_transfer_attribute_node(bNodeTree *nt using namespace blender; using namespace blender::bke; /* Otherwise `ntree->typeInfo` is null. */ - blender::bke::node_tree_set_type(nullptr, ntree); + blender::bke::node_tree_set_type(nullptr, *ntree); LISTBASE_FOREACH_MUTABLE (bNode *, node, &ntree->nodes) { if (node->type_legacy != GEO_NODE_TRANSFER_ATTRIBUTE_DEPRECATED) { continue; } - bNodeSocket *old_geometry_socket = blender::bke::node_find_socket(node, SOCK_IN, "Source"); + bNodeSocket *old_geometry_socket = blender::bke::node_find_socket(*node, SOCK_IN, "Source"); const NodeGeometryTransferAttribute *storage = (const NodeGeometryTransferAttribute *) node->storage; switch (storage->mode) { case GEO_NODE_ATTRIBUTE_TRANSFER_NEAREST_FACE_INTERPOLATED: { bNode *sample_nearest_surface = blender::bke::node_add_static_node( - nullptr, ntree, GEO_NODE_SAMPLE_NEAREST_SURFACE); + nullptr, *ntree, GEO_NODE_SAMPLE_NEAREST_SURFACE); sample_nearest_surface->parent = node->parent; sample_nearest_surface->custom1 = storage->data_type; sample_nearest_surface->locx_legacy = node->locx_legacy; @@ -724,7 +724,7 @@ static void version_geometry_nodes_replace_transfer_attribute_node(bNodeTree *nt /* Use a sample index node to retrieve the data with this node's index output. */ bNode *sample_index = blender::bke::node_add_static_node( - nullptr, ntree, GEO_NODE_SAMPLE_INDEX); + nullptr, *ntree, GEO_NODE_SAMPLE_INDEX); NodeGeometrySampleIndex *sample_storage = static_cast( sample_index->storage); sample_storage->data_type = storage->data_type; @@ -734,15 +734,15 @@ static void version_geometry_nodes_replace_transfer_attribute_node(bNodeTree *nt sample_index->locy_legacy = node->locy_legacy; if (old_geometry_socket->link) { blender::bke::node_add_link( - ntree, - old_geometry_socket->link->fromnode, - old_geometry_socket->link->fromsock, - sample_index, - blender::bke::node_find_socket(sample_index, SOCK_IN, "Geometry")); + *ntree, + *old_geometry_socket->link->fromnode, + *old_geometry_socket->link->fromsock, + *sample_index, + *blender::bke::node_find_socket(*sample_index, SOCK_IN, "Geometry")); } bNode *sample_nearest = blender::bke::node_add_static_node( - nullptr, ntree, GEO_NODE_SAMPLE_NEAREST); + nullptr, *ntree, GEO_NODE_SAMPLE_NEAREST); sample_nearest->parent = node->parent; sample_nearest->custom1 = storage->data_type; sample_nearest->custom2 = int8_t(domain); @@ -750,11 +750,11 @@ static void version_geometry_nodes_replace_transfer_attribute_node(bNodeTree *nt sample_nearest->locy_legacy = node->locy_legacy; if (old_geometry_socket->link) { blender::bke::node_add_link( - ntree, - old_geometry_socket->link->fromnode, - old_geometry_socket->link->fromsock, - sample_nearest, - blender::bke::node_find_socket(sample_nearest, SOCK_IN, "Geometry")); + *ntree, + *old_geometry_socket->link->fromnode, + *old_geometry_socket->link->fromsock, + *sample_nearest, + *blender::bke::node_find_socket(*sample_nearest, SOCK_IN, "Geometry")); } static auto sample_nearest_remap = []() { Map map; @@ -776,16 +776,16 @@ static void version_geometry_nodes_replace_transfer_attribute_node(bNodeTree *nt node_tree_relink_with_socket_id_map(*ntree, *node, *sample_index, sample_index_remap); blender::bke::node_add_link( - ntree, - sample_nearest, - blender::bke::node_find_socket(sample_nearest, SOCK_OUT, "Index"), - sample_index, - blender::bke::node_find_socket(sample_index, SOCK_IN, "Index")); + *ntree, + *sample_nearest, + *blender::bke::node_find_socket(*sample_nearest, SOCK_OUT, "Index"), + *sample_index, + *blender::bke::node_find_socket(*sample_index, SOCK_IN, "Index")); break; } case GEO_NODE_ATTRIBUTE_TRANSFER_INDEX: { bNode *sample_index = blender::bke::node_add_static_node( - nullptr, ntree, GEO_NODE_SAMPLE_INDEX); + nullptr, *ntree, GEO_NODE_SAMPLE_INDEX); NodeGeometrySampleIndex *sample_storage = static_cast( sample_index->storage); sample_storage->data_type = storage->data_type; @@ -795,7 +795,7 @@ static void version_geometry_nodes_replace_transfer_attribute_node(bNodeTree *nt sample_index->locx_legacy = node->locx_legacy; sample_index->locy_legacy = node->locy_legacy; const bool index_was_linked = - blender::bke::node_find_socket(node, SOCK_IN, "Index")->link != nullptr; + blender::bke::node_find_socket(*node, SOCK_IN, "Index")->link != nullptr; static auto socket_remap = []() { Map map; map.add_new("Attribute", "Value"); @@ -811,23 +811,23 @@ static void version_geometry_nodes_replace_transfer_attribute_node(bNodeTree *nt if (!index_was_linked) { /* Add an index input node, since the new node doesn't use an implicit input. */ - bNode *index = blender::bke::node_add_static_node(nullptr, ntree, GEO_NODE_INPUT_INDEX); + bNode *index = blender::bke::node_add_static_node(nullptr, *ntree, GEO_NODE_INPUT_INDEX); index->parent = node->parent; index->locx_legacy = node->locx_legacy - 25.0f; index->locy_legacy = node->locy_legacy - 25.0f; blender::bke::node_add_link( - ntree, - index, - blender::bke::node_find_socket(index, SOCK_OUT, "Index"), - sample_index, - blender::bke::node_find_socket(sample_index, SOCK_IN, "Index")); + *ntree, + *index, + *blender::bke::node_find_socket(*index, SOCK_OUT, "Index"), + *sample_index, + *blender::bke::node_find_socket(*sample_index, SOCK_IN, "Index")); } break; } } /* The storage must be freed manually because the node type isn't defined anymore. */ MEM_freeN(node->storage); - blender::bke::node_remove_node(nullptr, ntree, node, false); + blender::bke::node_remove_node(nullptr, *ntree, *node, false); } } @@ -915,7 +915,7 @@ static void version_geometry_nodes_primitive_uv_maps(bNodeTree &ntree) BLI_addhead(&ntree.nodes, node); } if (!new_nodes.is_empty()) { - blender::bke::node_rebuild_id_vector(&ntree); + blender::bke::node_rebuild_id_vector(ntree); } } @@ -937,8 +937,8 @@ static void version_geometry_nodes_extrude_smooth_propagation(bNodeTree &ntree) { continue; } - bNodeSocket *geometry_in_socket = blender::bke::node_find_socket(node, SOCK_IN, "Mesh"); - bNodeSocket *geometry_out_socket = blender::bke::node_find_socket(node, SOCK_OUT, "Mesh"); + bNodeSocket *geometry_in_socket = blender::bke::node_find_socket(*node, SOCK_IN, "Mesh"); + bNodeSocket *geometry_out_socket = blender::bke::node_find_socket(*node, SOCK_OUT, "Mesh"); Map in_links_per_socket; MultiValueMap out_links_per_socket; @@ -966,7 +966,7 @@ static void version_geometry_nodes_extrude_smooth_propagation(bNodeTree &ntree) return false; } bNodeSocket *capture_in_socket = blender::bke::node_find_socket( - capture_node, SOCK_IN, "Value_003"); + *capture_node, SOCK_IN, "Value_003"); bNodeLink *capture_in_link = in_links_per_socket.lookup_default(capture_in_socket, nullptr); if (!capture_in_link) { return false; @@ -983,7 +983,7 @@ static void version_geometry_nodes_extrude_smooth_propagation(bNodeTree &ntree) } bNode *set_smooth_node = geometry_out_link->tonode; bNodeSocket *smooth_in_socket = blender::bke::node_find_socket( - set_smooth_node, SOCK_IN, "Shade Smooth"); + *set_smooth_node, SOCK_IN, "Shade Smooth"); bNodeLink *connecting_link = in_links_per_socket.lookup_default(smooth_in_socket, nullptr); if (!connecting_link) { return false; @@ -1061,7 +1061,7 @@ static void version_geometry_nodes_extrude_smooth_propagation(bNodeTree &ntree) BLI_addhead(&ntree.nodes, node); } if (!new_nodes.is_empty()) { - blender::bke::node_rebuild_id_vector(&ntree); + blender::bke::node_rebuild_id_vector(ntree); } } @@ -1491,10 +1491,10 @@ static bNodeSocket *do_version_replace_float_size_with_vector(bNodeTree *ntree, { const bNodeSocketValueFloat *socket_value = (const bNodeSocketValueFloat *)socket->default_value; const float old_value = socket_value->value; - blender::bke::node_remove_socket(ntree, node, socket); + blender::bke::node_remove_socket(*ntree, *node, *socket); bNodeSocket *new_socket = blender::bke::node_add_socket( - ntree, - node, + *ntree, + *node, SOCK_IN, *blender::bke::node_static_socket_type(SOCK_VECTOR, PROP_TRANSLATION), "Size", @@ -1706,7 +1706,7 @@ static void version_geometry_nodes_set_position_node_offset(bNodeTree *ntree) /* Change identifier of old socket, so that the there is no name collision. */ STRNCPY(old_offset_socket->identifier, "Offset_old"); blender::bke::node_add_static_socket( - ntree, node, SOCK_IN, SOCK_VECTOR, PROP_TRANSLATION, "Offset", "Offset"); + *ntree, *node, SOCK_IN, SOCK_VECTOR, PROP_TRANSLATION, "Offset", "Offset"); } /* Relink links that were connected to Position while Offset was enabled. */ @@ -1735,7 +1735,7 @@ static void version_geometry_nodes_set_position_node_offset(bNodeTree *ntree) continue; } bNodeSocket *old_offset_socket = static_cast(BLI_findlink(&node->inputs, 3)); - blender::bke::node_remove_socket(ntree, node, old_offset_socket); + blender::bke::node_remove_socket(*ntree, *node, *old_offset_socket); } } @@ -2858,7 +2858,8 @@ void blo_do_versions_300(FileData *fd, Library * /*lib*/, Main *bmain) bNodeSocket *new_socket = do_version_replace_float_size_with_vector( ntree, node, socket); - blender::bke::node_add_link(ntree, link_fromnode, link_fromsock, node, new_socket); + blender::bke::node_add_link( + *ntree, *link_fromnode, *link_fromsock, *node, *new_socket); } } } @@ -4157,7 +4158,7 @@ void blo_do_versions_300(FileData *fd, Library * /*lib*/, Main *bmain) } static_cast(node->storage)->use_all_curves = true; static_cast(node->storage)->data_type = CD_PROP_FLOAT; - bNodeSocket *curve_socket = blender::bke::node_find_socket(node, SOCK_IN, "Curve"); + bNodeSocket *curve_socket = blender::bke::node_find_socket(*node, SOCK_IN, "Curve"); BLI_assert(curve_socket != nullptr); STRNCPY(curve_socket->name, "Curves"); STRNCPY(curve_socket->identifier, "Curves"); diff --git a/source/blender/blenloader/intern/versioning_400.cc b/source/blender/blenloader/intern/versioning_400.cc index 9954b903137..7f2ea61a1fa 100644 --- a/source/blender/blenloader/intern/versioning_400.cc +++ b/source/blender/blenloader/intern/versioning_400.cc @@ -397,8 +397,9 @@ static void versioning_eevee_material_shadow_none(Material *material) return; } - bNodeSocket *existing_out_sock = blender::bke::node_find_socket(output_node, SOCK_IN, "Surface"); - bNodeSocket *volume_sock = blender::bke::node_find_socket(output_node, SOCK_IN, "Volume"); + bNodeSocket *existing_out_sock = blender::bke::node_find_socket( + *output_node, SOCK_IN, "Surface"); + bNodeSocket *volume_sock = blender::bke::node_find_socket(*output_node, SOCK_IN, "Volume"); if (existing_out_sock->link == nullptr && volume_sock->link) { /* Don't apply versioning to a material that only has a volumetric input as this makes the * object surface opaque to the camera, hiding the volume inside. */ @@ -409,18 +410,19 @@ static void versioning_eevee_material_shadow_none(Material *material) /* We do not want to affect Cycles. So we split the output into two specific outputs. */ output_node->custom1 = SHD_OUTPUT_CYCLES; - bNode *new_output = blender::bke::node_add_node(nullptr, ntree, "ShaderNodeOutputMaterial"); + bNode *new_output = blender::bke::node_add_node(nullptr, *ntree, "ShaderNodeOutputMaterial"); new_output->custom1 = SHD_OUTPUT_EEVEE; new_output->parent = output_node->parent; new_output->locx_legacy = output_node->locx_legacy; new_output->locy_legacy = output_node->locy_legacy - output_node->height - 120; auto copy_link = [&](const char *socket_name) { - bNodeSocket *sock = blender::bke::node_find_socket(output_node, SOCK_IN, socket_name); + bNodeSocket *sock = blender::bke::node_find_socket(*output_node, SOCK_IN, socket_name); if (sock && sock->link) { bNodeLink *link = sock->link; - bNodeSocket *to_sock = blender::bke::node_find_socket(new_output, SOCK_IN, socket_name); - blender::bke::node_add_link(ntree, link->fromnode, link->fromsock, new_output, to_sock); + bNodeSocket *to_sock = blender::bke::node_find_socket(*new_output, SOCK_IN, socket_name); + blender::bke::node_add_link( + *ntree, *link->fromnode, *link->fromsock, *new_output, *to_sock); } }; @@ -432,11 +434,11 @@ static void versioning_eevee_material_shadow_none(Material *material) output_node = new_output; } - bNodeSocket *out_sock = blender::bke::node_find_socket(output_node, SOCK_IN, "Surface"); - bNodeSocket *old_out_sock = blender::bke::node_find_socket(old_output_node, SOCK_IN, "Surface"); + bNodeSocket *out_sock = blender::bke::node_find_socket(*output_node, SOCK_IN, "Surface"); + bNodeSocket *old_out_sock = blender::bke::node_find_socket(*old_output_node, SOCK_IN, "Surface"); /* Add mix node for mixing between original material, and transparent BSDF for shadows */ - bNode *mix_node = blender::bke::node_add_node(nullptr, ntree, "ShaderNodeMixShader"); + bNode *mix_node = blender::bke::node_add_node(nullptr, *ntree, "ShaderNodeMixShader"); STRNCPY(mix_node->label, "Disable Shadow"); mix_node->flag |= NODE_HIDDEN; mix_node->parent = output_node->parent; @@ -447,22 +449,25 @@ static void versioning_eevee_material_shadow_none(Material *material) bNodeSocket *mix_in_2 = static_cast(BLI_findlink(&mix_node->inputs, 2)); bNodeSocket *mix_out = static_cast(BLI_findlink(&mix_node->outputs, 0)); if (old_out_sock->link != nullptr) { - blender::bke::node_add_link( - ntree, old_out_sock->link->fromnode, old_out_sock->link->fromsock, mix_node, mix_in_1); + blender::bke::node_add_link(*ntree, + *old_out_sock->link->fromnode, + *old_out_sock->link->fromsock, + *mix_node, + *mix_in_1); if (out_sock->link != nullptr) { - blender::bke::node_remove_link(ntree, out_sock->link); + blender::bke::node_remove_link(ntree, *out_sock->link); } } - blender::bke::node_add_link(ntree, mix_node, mix_out, output_node, out_sock); + blender::bke::node_add_link(*ntree, *mix_node, *mix_out, *output_node, *out_sock); /* Add light path node to control shadow visibility */ - bNode *lp_node = blender::bke::node_add_node(nullptr, ntree, "ShaderNodeLightPath"); + bNode *lp_node = blender::bke::node_add_node(nullptr, *ntree, "ShaderNodeLightPath"); lp_node->flag |= NODE_HIDDEN; lp_node->parent = output_node->parent; lp_node->locx_legacy = output_node->locx_legacy; lp_node->locy_legacy = mix_node->locy_legacy + 35; - bNodeSocket *is_shadow = blender::bke::node_find_socket(lp_node, SOCK_OUT, "Is Shadow Ray"); - blender::bke::node_add_link(ntree, lp_node, is_shadow, mix_node, mix_fac); + bNodeSocket *is_shadow = blender::bke::node_find_socket(*lp_node, SOCK_OUT, "Is Shadow Ray"); + blender::bke::node_add_link(*ntree, *lp_node, *is_shadow, *mix_node, *mix_fac); /* Hide unconnected sockets for cleaner look. */ LISTBASE_FOREACH (bNodeSocket *, sock, &lp_node->outputs) { if (sock != is_shadow) { @@ -471,13 +476,13 @@ static void versioning_eevee_material_shadow_none(Material *material) } /* Add transparent BSDF to make shadows transparent. */ - bNode *bsdf_node = blender::bke::node_add_node(nullptr, ntree, "ShaderNodeBsdfTransparent"); + bNode *bsdf_node = blender::bke::node_add_node(nullptr, *ntree, "ShaderNodeBsdfTransparent"); bsdf_node->flag |= NODE_HIDDEN; bsdf_node->parent = output_node->parent; bsdf_node->locx_legacy = output_node->locx_legacy; bsdf_node->locy_legacy = mix_node->locy_legacy - 35; - bNodeSocket *bsdf_out = blender::bke::node_find_socket(bsdf_node, SOCK_OUT, "BSDF"); - blender::bke::node_add_link(ntree, bsdf_node, bsdf_out, mix_node, mix_in_2); + bNodeSocket *bsdf_out = blender::bke::node_find_socket(*bsdf_node, SOCK_OUT, "BSDF"); + blender::bke::node_add_link(*ntree, *bsdf_node, *bsdf_out, *mix_node, *mix_in_2); } /** @@ -608,7 +613,7 @@ static AlphaSource versioning_eevee_alpha_source_get(bNodeSocket *socket, int de } case SH_NODE_BSDF_TRANSPARENT: { - bNodeSocket *socket = blender::bke::node_find_socket(node, SOCK_IN, "Color"); + bNodeSocket *socket = blender::bke::node_find_socket(*node, SOCK_IN, "Color"); if (socket->link == nullptr) { float *socket_color_value = version_cycles_node_socket_rgba_value(socket); if ((socket_color_value[0] == 0.0f) && (socket_color_value[1] == 0.0f) && @@ -626,7 +631,7 @@ static AlphaSource versioning_eevee_alpha_source_get(bNodeSocket *socket, int de } case SH_NODE_MIX_SHADER: { - bNodeSocket *socket = blender::bke::node_find_socket(node, SOCK_IN, "Fac"); + bNodeSocket *socket = blender::bke::node_find_socket(*node, SOCK_IN, "Fac"); AlphaSource src0 = versioning_eevee_alpha_source_get( static_cast(BLI_findlink(&node->inputs, 1)), depth + 1); AlphaSource src1 = versioning_eevee_alpha_source_get( @@ -653,7 +658,7 @@ static AlphaSource versioning_eevee_alpha_source_get(bNodeSocket *socket, int de } case SH_NODE_BSDF_PRINCIPLED: { - bNodeSocket *socket = blender::bke::node_find_socket(node, SOCK_IN, "Alpha"); + bNodeSocket *socket = blender::bke::node_find_socket(*node, SOCK_IN, "Alpha"); if (socket->link == nullptr) { float socket_value = *version_cycles_node_socket_float_value(socket); if (socket_value == 0.0f) { @@ -667,7 +672,7 @@ static AlphaSource versioning_eevee_alpha_source_get(bNodeSocket *socket, int de } case SH_NODE_EEVEE_SPECULAR: { - bNodeSocket *socket = blender::bke::node_find_socket(node, SOCK_IN, "Transparency"); + bNodeSocket *socket = blender::bke::node_find_socket(*node, SOCK_IN, "Transparency"); if (socket->link == nullptr) { float socket_value = *version_cycles_node_socket_float_value(socket); if (socket_value == 0.0f) { @@ -699,7 +704,7 @@ static bool versioning_eevee_material_blend_mode_settings(bNodeTree *ntree, floa if (output_node == nullptr) { return true; } - bNodeSocket *surface_socket = blender::bke::node_find_socket(output_node, SOCK_IN, "Surface"); + bNodeSocket *surface_socket = blender::bke::node_find_socket(*output_node, SOCK_IN, "Surface"); AlphaSource alpha = versioning_eevee_alpha_source_get(surface_socket); @@ -713,7 +718,7 @@ static bool versioning_eevee_material_blend_mode_settings(bNodeTree *ntree, floa bool is_opaque = (threshold == 2.0f); if (is_opaque) { if (alpha.socket->link != nullptr) { - blender::bke::node_remove_link(ntree, alpha.socket->link); + blender::bke::node_remove_link(ntree, *alpha.socket->link); } float value = (alpha.is_transparency) ? 0.0f : 1.0f; @@ -734,9 +739,9 @@ static bool versioning_eevee_material_blend_mode_settings(bNodeTree *ntree, floa bNode *from_node = alpha.socket->link->fromnode; bNodeSocket *to_socket = alpha.socket->link->tosock; bNodeSocket *from_socket = alpha.socket->link->fromsock; - blender::bke::node_remove_link(ntree, alpha.socket->link); + blender::bke::node_remove_link(ntree, *alpha.socket->link); - bNode *math_node = blender::bke::node_add_node(nullptr, ntree, "ShaderNodeMath"); + bNode *math_node = blender::bke::node_add_node(nullptr, *ntree, "ShaderNodeMath"); math_node->custom1 = NODE_MATH_GREATER_THAN; math_node->flag |= NODE_HIDDEN; math_node->parent = to_node->parent; @@ -749,8 +754,8 @@ static bool versioning_eevee_material_blend_mode_settings(bNodeTree *ntree, floa bNodeSocket *alpha_sock = input_1; bNodeSocket *threshold_sock = input_2; - blender::bke::node_add_link(ntree, from_node, from_socket, math_node, alpha_sock); - blender::bke::node_add_link(ntree, math_node, output, to_node, to_socket); + blender::bke::node_add_link(*ntree, *from_node, *from_socket, *math_node, *alpha_sock); + blender::bke::node_add_link(*ntree, *math_node, *output, *to_node, *to_socket); *version_cycles_node_socket_float_value(threshold_sock) = alpha.is_transparency ? 1.0f - threshold : @@ -793,17 +798,17 @@ static void versioning_replace_splitviewer(bNodeTree *ntree) MEM_freeN(node->storage); node->storage = nullptr; - bNode *viewer_node = blender::bke::node_add_static_node(nullptr, ntree, CMP_NODE_VIEWER); + bNode *viewer_node = blender::bke::node_add_static_node(nullptr, *ntree, CMP_NODE_VIEWER); /* Nodes are created stacked on top of each other, so separate them a bit. */ viewer_node->locx_legacy = node->locx_legacy + node->width + viewer_node->width / 4.0f; viewer_node->locy_legacy = node->locy_legacy; viewer_node->flag &= ~NODE_PREVIEW; bNodeSocket *split_out_socket = blender::bke::node_add_static_socket( - ntree, node, SOCK_OUT, SOCK_IMAGE, PROP_NONE, "Image", "Image"); - bNodeSocket *viewer_in_socket = blender::bke::node_find_socket(viewer_node, SOCK_IN, "Image"); + *ntree, *node, SOCK_OUT, SOCK_IMAGE, PROP_NONE, "Image", "Image"); + bNodeSocket *viewer_in_socket = blender::bke::node_find_socket(*viewer_node, SOCK_IN, "Image"); - blender::bke::node_add_link(ntree, node, split_out_socket, viewer_node, viewer_in_socket); + blender::bke::node_add_link(*ntree, *node, *split_out_socket, *viewer_node, *viewer_in_socket); } } @@ -1082,8 +1087,8 @@ static void do_version_glare_node_options_to_inputs(const Scene *scene, } /* Relink from the Image output to the Glare output. */ - blender::bke::node_add_link(node_tree, node, glare_output, link->tonode, link->tosock); - blender::bke::node_remove_link(node_tree, link); + blender::bke::node_add_link(*node_tree, *node, *glare_output, *link->tonode, *link->tosock); + blender::bke::node_remove_link(node_tree, *link); } } } @@ -1227,13 +1232,13 @@ static void do_version_color_to_float_conversion(bNodeTree *node_tree) *existing_link->fromsock, *link->tonode, *link->tosock); - blender::bke::node_remove_link(node_tree, link); + blender::bke::node_remove_link(node_tree, *link); continue; } /* Add a hidden dot product node. */ bNode *dot_product_node = blender::bke::node_add_static_node( - nullptr, node_tree, CMP_NODE_NORMAL); + nullptr, *node_tree, CMP_NODE_NORMAL); dot_product_node->flag |= NODE_HIDDEN; dot_product_node->location[0] = link->fromnode->location[0] + link->fromnode->width + 10.0f; dot_product_node->location[1] = link->fromnode->location[1]; @@ -1253,7 +1258,7 @@ static void do_version_color_to_float_conversion(bNodeTree *node_tree) -1.0f); /* Add a hidden multiply node. */ - bNode *multiply_node = blender::bke::node_add_static_node(nullptr, node_tree, CMP_NODE_MATH); + bNode *multiply_node = blender::bke::node_add_static_node(nullptr, *node_tree, CMP_NODE_MATH); multiply_node->custom1 = NODE_MATH_MULTIPLY; multiply_node->flag |= NODE_HIDDEN; multiply_node->location[0] = dot_product_node->location[0] + dot_product_node->width + 10.0f; @@ -1283,7 +1288,7 @@ static void do_version_color_to_float_conversion(bNodeTree *node_tree) color_to_float_links.add_new(link->fromsock, final_link); /* Remove the old link. */ - blender::bke::node_remove_link(node_tree, link); + blender::bke::node_remove_link(node_tree, *link); } } @@ -1736,7 +1741,7 @@ static void version_mesh_crease_generic(Main &bmain) "GeometryNodeStoreNamedAttribute", "GeometryNodeInputNamedAttribute")) { - bNodeSocket *socket = blender::bke::node_find_socket(node, SOCK_IN, "Name"); + bNodeSocket *socket = blender::bke::node_find_socket(*node, SOCK_IN, "Name"); if (STREQ(socket->default_value_typed()->value, "crease")) { STRNCPY(socket->default_value_typed()->value, "crease_edge"); } @@ -1794,7 +1799,7 @@ static void versioning_remove_microfacet_sharp_distribution(bNodeTree *ntree) } if (socket->link != nullptr) { - blender::bke::node_remove_link(ntree, socket->link); + blender::bke::node_remove_link(ntree, *socket->link); } bNodeSocketValueFloat *socket_value = (bNodeSocketValueFloat *)socket->default_value; socket_value->value = 0.0f; @@ -1819,23 +1824,23 @@ static void version_replace_texcoord_normal_socket(bNodeTree *ntree) STREQ(link->fromsock->identifier, "Normal")) { if (geometry_node == nullptr) { - geometry_node = blender::bke::node_add_static_node(nullptr, ntree, SH_NODE_NEW_GEOMETRY); - incoming_socket = blender::bke::node_find_socket(geometry_node, SOCK_OUT, "Incoming"); + geometry_node = blender::bke::node_add_static_node(nullptr, *ntree, SH_NODE_NEW_GEOMETRY); + incoming_socket = blender::bke::node_find_socket(*geometry_node, SOCK_OUT, "Incoming"); transform_node = blender::bke::node_add_static_node( - nullptr, ntree, SH_NODE_VECT_TRANSFORM); - vec_in_socket = blender::bke::node_find_socket(transform_node, SOCK_IN, "Vector"); - vec_out_socket = blender::bke::node_find_socket(transform_node, SOCK_OUT, "Vector"); + nullptr, *ntree, SH_NODE_VECT_TRANSFORM); + vec_in_socket = blender::bke::node_find_socket(*transform_node, SOCK_IN, "Vector"); + vec_out_socket = blender::bke::node_find_socket(*transform_node, SOCK_OUT, "Vector"); NodeShaderVectTransform *nodeprop = (NodeShaderVectTransform *)transform_node->storage; nodeprop->type = SHD_VECT_TRANSFORM_TYPE_NORMAL; blender::bke::node_add_link( - ntree, geometry_node, incoming_socket, transform_node, vec_in_socket); + *ntree, *geometry_node, *incoming_socket, *transform_node, *vec_in_socket); } blender::bke::node_add_link( - ntree, transform_node, vec_out_socket, link->tonode, link->tosock); - blender::bke::node_remove_link(ntree, link); + *ntree, *transform_node, *vec_out_socket, *link->tonode, *link->tosock); + blender::bke::node_remove_link(ntree, *link); } } } @@ -1846,9 +1851,9 @@ static void version_principled_transmission_roughness(bNodeTree *ntree) if (node->type_legacy != SH_NODE_BSDF_PRINCIPLED) { continue; } - bNodeSocket *sock = blender::bke::node_find_socket(node, SOCK_IN, "Transmission Roughness"); + bNodeSocket *sock = blender::bke::node_find_socket(*node, SOCK_IN, "Transmission Roughness"); if (sock != nullptr) { - blender::bke::node_remove_socket(ntree, node, sock); + blender::bke::node_remove_socket(*ntree, *node, *sock); } } } @@ -1860,7 +1865,7 @@ static void version_replace_velvet_sheen_node(bNodeTree *ntree) if (node->type_legacy == SH_NODE_BSDF_SHEEN) { STRNCPY(node->idname, "ShaderNodeBsdfSheen"); - bNodeSocket *sigmaInput = blender::bke::node_find_socket(node, SOCK_IN, "Sigma"); + bNodeSocket *sigmaInput = blender::bke::node_find_socket(*node, SOCK_IN, "Sigma"); if (sigmaInput != nullptr) { node->custom1 = SHD_SHEEN_ASHIKHMIN; STRNCPY(sigmaInput->identifier, "Roughness"); @@ -1875,7 +1880,7 @@ static void version_principled_bsdf_sheen(bNodeTree *ntree) { auto check_node = [](const bNode *node) { return (node->type_legacy == SH_NODE_BSDF_PRINCIPLED) && - (blender::bke::node_find_socket(node, SOCK_IN, "Sheen Roughness") == nullptr); + (blender::bke::node_find_socket(*node, SOCK_IN, "Sheen Roughness") == nullptr); }; auto update_input = [ntree](bNode *node, bNodeSocket *input) { /* Change socket type to Color. */ @@ -1884,7 +1889,7 @@ static void version_principled_bsdf_sheen(bNodeTree *ntree) /* Account for the change in intensity between the old and new model. * If the Sheen input is set to a fixed value, adjust it and set the tint to white. * Otherwise, if it's connected, keep it as-is but set the tint to 0.2 instead. */ - bNodeSocket *sheen = blender::bke::node_find_socket(node, SOCK_IN, "Sheen"); + bNodeSocket *sheen = blender::bke::node_find_socket(*node, SOCK_IN, "Sheen"); if (sheen != nullptr && sheen->link == nullptr) { *version_cycles_node_socket_float_value(sheen) *= 0.2f; @@ -1912,7 +1917,7 @@ static void version_refraction_depth_to_thickness_value(bNodeTree *ntree, float continue; } - bNodeSocket *thickness_socket = blender::bke::node_find_socket(node, SOCK_IN, "Thickness"); + bNodeSocket *thickness_socket = blender::bke::node_find_socket(*node, SOCK_IN, "Thickness"); if (thickness_socket == nullptr) { continue; } @@ -1928,15 +1933,15 @@ static void version_refraction_depth_to_thickness_value(bNodeTree *ntree, float if (has_link) { continue; } - bNode *value_node = blender::bke::node_add_static_node(nullptr, ntree, SH_NODE_VALUE); + bNode *value_node = blender::bke::node_add_static_node(nullptr, *ntree, SH_NODE_VALUE); value_node->parent = node->parent; value_node->locx_legacy = node->locx_legacy; value_node->locy_legacy = node->locy_legacy - 160.0f; - bNodeSocket *socket_value = blender::bke::node_find_socket(value_node, SOCK_OUT, "Value"); + bNodeSocket *socket_value = blender::bke::node_find_socket(*value_node, SOCK_OUT, "Value"); *version_cycles_node_socket_float_value(socket_value) = thickness; - blender::bke::node_add_link(ntree, value_node, socket_value, node, thickness_socket); + blender::bke::node_add_link(*ntree, *value_node, *socket_value, *node, *thickness_socket); } version_socket_update_is_used(ntree); @@ -1951,7 +1956,7 @@ static void versioning_update_noise_texture_node(bNodeTree *ntree) (static_cast(node->storage))->type = SHD_NOISE_FBM; - bNodeSocket *roughness_socket = blender::bke::node_find_socket(node, SOCK_IN, "Roughness"); + bNodeSocket *roughness_socket = blender::bke::node_find_socket(*node, SOCK_IN, "Roughness"); if (roughness_socket == nullptr) { /* Noise Texture node was created before the Roughness input was added. */ continue; @@ -1975,26 +1980,27 @@ static void versioning_update_noise_texture_node(bNodeTree *ntree) if (roughness_link != nullptr) { /* Add Clamp node before Roughness input. */ - bNode *clamp_node = blender::bke::node_add_static_node(nullptr, ntree, SH_NODE_CLAMP); + bNode *clamp_node = blender::bke::node_add_static_node(nullptr, *ntree, SH_NODE_CLAMP); clamp_node->parent = node->parent; clamp_node->custom1 = NODE_CLAMP_MINMAX; clamp_node->locx_legacy = node->locx_legacy; clamp_node->locy_legacy = node->locy_legacy - 300.0f; clamp_node->flag |= NODE_HIDDEN; bNodeSocket *clamp_socket_value = blender::bke::node_find_socket( - clamp_node, SOCK_IN, "Value"); - bNodeSocket *clamp_socket_min = blender::bke::node_find_socket(clamp_node, SOCK_IN, "Min"); - bNodeSocket *clamp_socket_max = blender::bke::node_find_socket(clamp_node, SOCK_IN, "Max"); + *clamp_node, SOCK_IN, "Value"); + bNodeSocket *clamp_socket_min = blender::bke::node_find_socket(*clamp_node, SOCK_IN, "Min"); + bNodeSocket *clamp_socket_max = blender::bke::node_find_socket(*clamp_node, SOCK_IN, "Max"); bNodeSocket *clamp_socket_out = blender::bke::node_find_socket( - clamp_node, SOCK_OUT, "Result"); + *clamp_node, SOCK_OUT, "Result"); *version_cycles_node_socket_float_value(clamp_socket_min) = 0.0f; *version_cycles_node_socket_float_value(clamp_socket_max) = 1.0f; - blender::bke::node_remove_link(ntree, roughness_link); + blender::bke::node_remove_link(ntree, *roughness_link); + blender::bke::node_add_link( + *ntree, *roughness_from_node, *roughness_from_socket, *clamp_node, *clamp_socket_value); blender::bke::node_add_link( - ntree, roughness_from_node, roughness_from_socket, clamp_node, clamp_socket_value); - blender::bke::node_add_link(ntree, clamp_node, clamp_socket_out, node, roughness_socket); + *ntree, *clamp_node, *clamp_socket_out, *node, *roughness_socket); } else { *roughness = std::clamp(*roughness, 0.0f, 1.0f); @@ -2058,11 +2064,11 @@ static void versioning_replace_musgrave_texture_node(bNodeTree *ntree) uint8_t noise_type = (static_cast(node->storage))->type; float locy_offset = 0.0f; - bNodeSocket *fac_socket = blender::bke::node_find_socket(node, SOCK_OUT, "Fac"); + bNodeSocket *fac_socket = blender::bke::node_find_socket(*node, SOCK_OUT, "Fac"); /* Clear label because Musgrave output socket label is set to "Height" instead of "Fac". */ fac_socket->label[0] = '\0'; - bNodeSocket *detail_socket = blender::bke::node_find_socket(node, SOCK_IN, "Detail"); + bNodeSocket *detail_socket = blender::bke::node_find_socket(*node, SOCK_IN, "Detail"); float *detail = version_cycles_node_socket_float_value(detail_socket); if (detail_link != nullptr) { @@ -2070,7 +2076,7 @@ static void versioning_replace_musgrave_texture_node(bNodeTree *ntree) /* Add Minimum Math node and Subtract Math node before Detail input. */ - bNode *min_node = blender::bke::node_add_static_node(nullptr, ntree, SH_NODE_MATH); + bNode *min_node = blender::bke::node_add_static_node(nullptr, *ntree, SH_NODE_MATH); min_node->parent = node->parent; min_node->custom1 = NODE_MATH_MINIMUM; min_node->locx_legacy = node->locx_legacy; @@ -2078,9 +2084,9 @@ static void versioning_replace_musgrave_texture_node(bNodeTree *ntree) min_node->flag |= NODE_HIDDEN; bNodeSocket *min_socket_A = static_cast(BLI_findlink(&min_node->inputs, 0)); bNodeSocket *min_socket_B = static_cast(BLI_findlink(&min_node->inputs, 1)); - bNodeSocket *min_socket_out = blender::bke::node_find_socket(min_node, SOCK_OUT, "Value"); + bNodeSocket *min_socket_out = blender::bke::node_find_socket(*min_node, SOCK_OUT, "Value"); - bNode *sub1_node = blender::bke::node_add_static_node(nullptr, ntree, SH_NODE_MATH); + bNode *sub1_node = blender::bke::node_add_static_node(nullptr, *ntree, SH_NODE_MATH); sub1_node->parent = node->parent; sub1_node->custom1 = NODE_MATH_SUBTRACT; sub1_node->locx_legacy = node->locx_legacy; @@ -2088,23 +2094,23 @@ static void versioning_replace_musgrave_texture_node(bNodeTree *ntree) sub1_node->flag |= NODE_HIDDEN; bNodeSocket *sub1_socket_A = static_cast(BLI_findlink(&sub1_node->inputs, 0)); bNodeSocket *sub1_socket_B = static_cast(BLI_findlink(&sub1_node->inputs, 1)); - bNodeSocket *sub1_socket_out = blender::bke::node_find_socket(sub1_node, SOCK_OUT, "Value"); + bNodeSocket *sub1_socket_out = blender::bke::node_find_socket(*sub1_node, SOCK_OUT, "Value"); *version_cycles_node_socket_float_value(min_socket_B) = 14.0f; *version_cycles_node_socket_float_value(sub1_socket_B) = 1.0f; - blender::bke::node_remove_link(ntree, detail_link); + blender::bke::node_remove_link(ntree, *detail_link); blender::bke::node_add_link( - ntree, detail_from_node, detail_from_socket, sub1_node, sub1_socket_A); - blender::bke::node_add_link(ntree, sub1_node, sub1_socket_out, min_node, min_socket_A); - blender::bke::node_add_link(ntree, min_node, min_socket_out, node, detail_socket); + *ntree, *detail_from_node, *detail_from_socket, *sub1_node, *sub1_socket_A); + blender::bke::node_add_link(*ntree, *sub1_node, *sub1_socket_out, *min_node, *min_socket_A); + blender::bke::node_add_link(*ntree, *min_node, *min_socket_out, *node, *detail_socket); if (ELEM(noise_type, SHD_NOISE_RIDGED_MULTIFRACTAL, SHD_NOISE_HETERO_TERRAIN)) { locy_offset -= 40.0f; /* Add Greater Than Math node before Subtract Math node. */ - bNode *greater_node = blender::bke::node_add_static_node(nullptr, ntree, SH_NODE_MATH); + bNode *greater_node = blender::bke::node_add_static_node(nullptr, *ntree, SH_NODE_MATH); greater_node->parent = node->parent; greater_node->custom1 = NODE_MATH_GREATER_THAN; greater_node->locx_legacy = node->locx_legacy; @@ -2115,32 +2121,34 @@ static void versioning_replace_musgrave_texture_node(bNodeTree *ntree) bNodeSocket *greater_socket_B = static_cast( BLI_findlink(&greater_node->inputs, 1)); bNodeSocket *greater_socket_out = blender::bke::node_find_socket( - greater_node, SOCK_OUT, "Value"); + *greater_node, SOCK_OUT, "Value"); *version_cycles_node_socket_float_value(greater_socket_B) = 1.0f; blender::bke::node_add_link( - ntree, detail_from_node, detail_from_socket, greater_node, greater_socket_A); + *ntree, *detail_from_node, *detail_from_socket, *greater_node, *greater_socket_A); blender::bke::node_add_link( - ntree, greater_node, greater_socket_out, sub1_node, sub1_socket_B); + *ntree, *greater_node, *greater_socket_out, *sub1_node, *sub1_socket_B); } else { /* Add Clamp node and Multiply Math node behind Fac output. */ - bNode *clamp_node = blender::bke::node_add_static_node(nullptr, ntree, SH_NODE_CLAMP); + bNode *clamp_node = blender::bke::node_add_static_node(nullptr, *ntree, SH_NODE_CLAMP); clamp_node->parent = node->parent; clamp_node->custom1 = NODE_CLAMP_MINMAX; clamp_node->locx_legacy = node->locx_legacy; clamp_node->locy_legacy = node->locy_legacy + 40.0f; clamp_node->flag |= NODE_HIDDEN; bNodeSocket *clamp_socket_value = blender::bke::node_find_socket( - clamp_node, SOCK_IN, "Value"); - bNodeSocket *clamp_socket_min = blender::bke::node_find_socket(clamp_node, SOCK_IN, "Min"); - bNodeSocket *clamp_socket_max = blender::bke::node_find_socket(clamp_node, SOCK_IN, "Max"); + *clamp_node, SOCK_IN, "Value"); + bNodeSocket *clamp_socket_min = blender::bke::node_find_socket( + *clamp_node, SOCK_IN, "Min"); + bNodeSocket *clamp_socket_max = blender::bke::node_find_socket( + *clamp_node, SOCK_IN, "Max"); bNodeSocket *clamp_socket_out = blender::bke::node_find_socket( - clamp_node, SOCK_OUT, "Result"); + *clamp_node, SOCK_OUT, "Result"); - bNode *mul_node = blender::bke::node_add_static_node(nullptr, ntree, SH_NODE_MATH); + bNode *mul_node = blender::bke::node_add_static_node(nullptr, *ntree, SH_NODE_MATH); mul_node->parent = node->parent; mul_node->custom1 = NODE_MATH_MULTIPLY; mul_node->locx_legacy = node->locx_legacy; @@ -2148,7 +2156,7 @@ static void versioning_replace_musgrave_texture_node(bNodeTree *ntree) mul_node->flag |= NODE_HIDDEN; bNodeSocket *mul_socket_A = static_cast(BLI_findlink(&mul_node->inputs, 0)); bNodeSocket *mul_socket_B = static_cast(BLI_findlink(&mul_node->inputs, 1)); - bNodeSocket *mul_socket_out = blender::bke::node_find_socket(mul_node, SOCK_OUT, "Value"); + bNodeSocket *mul_socket_out = blender::bke::node_find_socket(*mul_node, SOCK_OUT, "Value"); *version_cycles_node_socket_float_value(clamp_socket_min) = 0.0f; *version_cycles_node_socket_float_value(clamp_socket_max) = 1.0f; @@ -2156,7 +2164,7 @@ static void versioning_replace_musgrave_texture_node(bNodeTree *ntree) if (noise_type == SHD_NOISE_MULTIFRACTAL) { /* Add Subtract Math node and Add Math node after Multiply Math node. */ - bNode *sub2_node = blender::bke::node_add_static_node(nullptr, ntree, SH_NODE_MATH); + bNode *sub2_node = blender::bke::node_add_static_node(nullptr, *ntree, SH_NODE_MATH); sub2_node->parent = node->parent; sub2_node->custom1 = NODE_MATH_SUBTRACT; sub2_node->custom2 = SHD_MATH_CLAMP; @@ -2168,9 +2176,9 @@ static void versioning_replace_musgrave_texture_node(bNodeTree *ntree) bNodeSocket *sub2_socket_B = static_cast( BLI_findlink(&sub2_node->inputs, 1)); bNodeSocket *sub2_socket_out = blender::bke::node_find_socket( - sub2_node, SOCK_OUT, "Value"); + *sub2_node, SOCK_OUT, "Value"); - bNode *add_node = blender::bke::node_add_static_node(nullptr, ntree, SH_NODE_MATH); + bNode *add_node = blender::bke::node_add_static_node(nullptr, *ntree, SH_NODE_MATH); add_node->parent = node->parent; add_node->custom1 = NODE_MATH_ADD; add_node->locx_legacy = node->locx_legacy; @@ -2181,37 +2189,40 @@ static void versioning_replace_musgrave_texture_node(bNodeTree *ntree) bNodeSocket *add_socket_B = static_cast( BLI_findlink(&add_node->inputs, 1)); bNodeSocket *add_socket_out = blender::bke::node_find_socket( - add_node, SOCK_OUT, "Value"); + *add_node, SOCK_OUT, "Value"); *version_cycles_node_socket_float_value(sub2_socket_A) = 1.0f; LISTBASE_FOREACH_BACKWARD_MUTABLE (bNodeLink *, link, &ntree->links) { if (link->fromsock == fac_socket) { blender::bke::node_add_link( - ntree, add_node, add_socket_out, link->tonode, link->tosock); - blender::bke::node_remove_link(ntree, link); + *ntree, *add_node, *add_socket_out, *link->tonode, *link->tosock); + blender::bke::node_remove_link(ntree, *link); } } - blender::bke::node_add_link(ntree, mul_node, mul_socket_out, add_node, add_socket_A); blender::bke::node_add_link( - ntree, detail_from_node, detail_from_socket, sub2_node, sub2_socket_B); - blender::bke::node_add_link(ntree, sub2_node, sub2_socket_out, add_node, add_socket_B); + *ntree, *mul_node, *mul_socket_out, *add_node, *add_socket_A); + blender::bke::node_add_link( + *ntree, *detail_from_node, *detail_from_socket, *sub2_node, *sub2_socket_B); + blender::bke::node_add_link( + *ntree, *sub2_node, *sub2_socket_out, *add_node, *add_socket_B); } else { LISTBASE_FOREACH_BACKWARD_MUTABLE (bNodeLink *, link, &ntree->links) { if (link->fromsock == fac_socket) { blender::bke::node_add_link( - ntree, mul_node, mul_socket_out, link->tonode, link->tosock); - blender::bke::node_remove_link(ntree, link); + *ntree, *mul_node, *mul_socket_out, *link->tonode, *link->tosock); + blender::bke::node_remove_link(ntree, *link); } } } - blender::bke::node_add_link(ntree, node, fac_socket, mul_node, mul_socket_A); + blender::bke::node_add_link(*ntree, *node, *fac_socket, *mul_node, *mul_socket_A); + blender::bke::node_add_link( + *ntree, *detail_from_node, *detail_from_socket, *clamp_node, *clamp_socket_value); blender::bke::node_add_link( - ntree, detail_from_node, detail_from_socket, clamp_node, clamp_socket_value); - blender::bke::node_add_link(ntree, clamp_node, clamp_socket_out, mul_node, mul_socket_B); + *ntree, *clamp_node, *clamp_socket_out, *mul_node, *mul_socket_B); } } else { @@ -2219,7 +2230,7 @@ static void versioning_replace_musgrave_texture_node(bNodeTree *ntree) if (!ELEM(noise_type, SHD_NOISE_RIDGED_MULTIFRACTAL, SHD_NOISE_HETERO_TERRAIN)) { /* Add Multiply Math node behind Fac output. */ - bNode *mul_node = blender::bke::node_add_static_node(nullptr, ntree, SH_NODE_MATH); + bNode *mul_node = blender::bke::node_add_static_node(nullptr, *ntree, SH_NODE_MATH); mul_node->parent = node->parent; mul_node->custom1 = NODE_MATH_MULTIPLY; mul_node->locx_legacy = node->locx_legacy; @@ -2230,14 +2241,14 @@ static void versioning_replace_musgrave_texture_node(bNodeTree *ntree) bNodeSocket *mul_socket_B = static_cast( BLI_findlink(&mul_node->inputs, 1)); bNodeSocket *mul_socket_out = blender::bke::node_find_socket( - mul_node, SOCK_OUT, "Value"); + *mul_node, SOCK_OUT, "Value"); *version_cycles_node_socket_float_value(mul_socket_B) = *detail; if (noise_type == SHD_NOISE_MULTIFRACTAL) { /* Add an Add Math node after Multiply Math node. */ - bNode *add_node = blender::bke::node_add_static_node(nullptr, ntree, SH_NODE_MATH); + bNode *add_node = blender::bke::node_add_static_node(nullptr, *ntree, SH_NODE_MATH); add_node->parent = node->parent; add_node->custom1 = NODE_MATH_ADD; add_node->locx_legacy = node->locx_legacy; @@ -2248,31 +2259,32 @@ static void versioning_replace_musgrave_texture_node(bNodeTree *ntree) bNodeSocket *add_socket_B = static_cast( BLI_findlink(&add_node->inputs, 1)); bNodeSocket *add_socket_out = blender::bke::node_find_socket( - add_node, SOCK_OUT, "Value"); + *add_node, SOCK_OUT, "Value"); *version_cycles_node_socket_float_value(add_socket_B) = 1.0f - *detail; LISTBASE_FOREACH_BACKWARD_MUTABLE (bNodeLink *, link, &ntree->links) { if (link->fromsock == fac_socket) { blender::bke::node_add_link( - ntree, add_node, add_socket_out, link->tonode, link->tosock); - blender::bke::node_remove_link(ntree, link); + *ntree, *add_node, *add_socket_out, *link->tonode, *link->tosock); + blender::bke::node_remove_link(ntree, *link); } } - blender::bke::node_add_link(ntree, mul_node, mul_socket_out, add_node, add_socket_A); + blender::bke::node_add_link( + *ntree, *mul_node, *mul_socket_out, *add_node, *add_socket_A); } else { LISTBASE_FOREACH_BACKWARD_MUTABLE (bNodeLink *, link, &ntree->links) { if (link->fromsock == fac_socket) { blender::bke::node_add_link( - ntree, mul_node, mul_socket_out, link->tonode, link->tosock); - blender::bke::node_remove_link(ntree, link); + *ntree, *mul_node, *mul_socket_out, *link->tonode, *link->tosock); + blender::bke::node_remove_link(ntree, *link); } } } - blender::bke::node_add_link(ntree, node, fac_socket, mul_node, mul_socket_A); + blender::bke::node_add_link(*ntree, *node, *fac_socket, *mul_node, *mul_socket_A); *detail = 0.0f; } @@ -2282,9 +2294,9 @@ static void versioning_replace_musgrave_texture_node(bNodeTree *ntree) } } - bNodeSocket *roughness_socket = blender::bke::node_find_socket(node, SOCK_IN, "Roughness"); + bNodeSocket *roughness_socket = blender::bke::node_find_socket(*node, SOCK_IN, "Roughness"); float *roughness = version_cycles_node_socket_float_value(roughness_socket); - bNodeSocket *lacunarity_socket = blender::bke::node_find_socket(node, SOCK_IN, "Lacunarity"); + bNodeSocket *lacunarity_socket = blender::bke::node_find_socket(*node, SOCK_IN, "Lacunarity"); float *lacunarity = version_cycles_node_socket_float_value(lacunarity_socket); *roughness = std::fmaxf(*roughness, 1e-5f); @@ -2294,7 +2306,7 @@ static void versioning_replace_musgrave_texture_node(bNodeTree *ntree) /* Add Maximum Math node after output of roughness_from_node. Add Multiply Math node and * Power Math node before Roughness input. */ - bNode *max1_node = blender::bke::node_add_static_node(nullptr, ntree, SH_NODE_MATH); + bNode *max1_node = blender::bke::node_add_static_node(nullptr, *ntree, SH_NODE_MATH); max1_node->parent = node->parent; max1_node->custom1 = NODE_MATH_MAXIMUM; max1_node->locx_legacy = node->locx_legacy; @@ -2302,9 +2314,9 @@ static void versioning_replace_musgrave_texture_node(bNodeTree *ntree) max1_node->flag |= NODE_HIDDEN; bNodeSocket *max1_socket_A = static_cast(BLI_findlink(&max1_node->inputs, 0)); bNodeSocket *max1_socket_B = static_cast(BLI_findlink(&max1_node->inputs, 1)); - bNodeSocket *max1_socket_out = blender::bke::node_find_socket(max1_node, SOCK_OUT, "Value"); + bNodeSocket *max1_socket_out = blender::bke::node_find_socket(*max1_node, SOCK_OUT, "Value"); - bNode *mul_node = blender::bke::node_add_static_node(nullptr, ntree, SH_NODE_MATH); + bNode *mul_node = blender::bke::node_add_static_node(nullptr, *ntree, SH_NODE_MATH); mul_node->parent = node->parent; mul_node->custom1 = NODE_MATH_MULTIPLY; mul_node->locx_legacy = node->locx_legacy; @@ -2312,9 +2324,9 @@ static void versioning_replace_musgrave_texture_node(bNodeTree *ntree) mul_node->flag |= NODE_HIDDEN; bNodeSocket *mul_socket_A = static_cast(BLI_findlink(&mul_node->inputs, 0)); bNodeSocket *mul_socket_B = static_cast(BLI_findlink(&mul_node->inputs, 1)); - bNodeSocket *mul_socket_out = blender::bke::node_find_socket(mul_node, SOCK_OUT, "Value"); + bNodeSocket *mul_socket_out = blender::bke::node_find_socket(*mul_node, SOCK_OUT, "Value"); - bNode *pow_node = blender::bke::node_add_static_node(nullptr, ntree, SH_NODE_MATH); + bNode *pow_node = blender::bke::node_add_static_node(nullptr, *ntree, SH_NODE_MATH); pow_node->parent = node->parent; pow_node->custom1 = NODE_MATH_POWER; pow_node->locx_legacy = node->locx_legacy; @@ -2322,23 +2334,23 @@ static void versioning_replace_musgrave_texture_node(bNodeTree *ntree) pow_node->flag |= NODE_HIDDEN; bNodeSocket *pow_socket_A = static_cast(BLI_findlink(&pow_node->inputs, 0)); bNodeSocket *pow_socket_B = static_cast(BLI_findlink(&pow_node->inputs, 1)); - bNodeSocket *pow_socket_out = blender::bke::node_find_socket(pow_node, SOCK_OUT, "Value"); + bNodeSocket *pow_socket_out = blender::bke::node_find_socket(*pow_node, SOCK_OUT, "Value"); *version_cycles_node_socket_float_value(max1_socket_B) = -1e-5f; *version_cycles_node_socket_float_value(mul_socket_B) = -1.0f; *version_cycles_node_socket_float_value(pow_socket_A) = *lacunarity; - blender::bke::node_remove_link(ntree, roughness_link); + blender::bke::node_remove_link(ntree, *roughness_link); blender::bke::node_add_link( - ntree, roughness_from_node, roughness_from_socket, max1_node, max1_socket_A); - blender::bke::node_add_link(ntree, max1_node, max1_socket_out, mul_node, mul_socket_A); - blender::bke::node_add_link(ntree, mul_node, mul_socket_out, pow_node, pow_socket_B); - blender::bke::node_add_link(ntree, pow_node, pow_socket_out, node, roughness_socket); + *ntree, *roughness_from_node, *roughness_from_socket, *max1_node, *max1_socket_A); + blender::bke::node_add_link(*ntree, *max1_node, *max1_socket_out, *mul_node, *mul_socket_A); + blender::bke::node_add_link(*ntree, *mul_node, *mul_socket_out, *pow_node, *pow_socket_B); + blender::bke::node_add_link(*ntree, *pow_node, *pow_socket_out, *node, *roughness_socket); if (lacunarity_link != nullptr) { /* Add Maximum Math node after output of lacunarity_from_node. */ - bNode *max2_node = blender::bke::node_add_static_node(nullptr, ntree, SH_NODE_MATH); + bNode *max2_node = blender::bke::node_add_static_node(nullptr, *ntree, SH_NODE_MATH); max2_node->parent = node->parent; max2_node->custom1 = NODE_MATH_MAXIMUM; max2_node->locx_legacy = node->locx_legacy; @@ -2349,22 +2361,24 @@ static void versioning_replace_musgrave_texture_node(bNodeTree *ntree) bNodeSocket *max2_socket_B = static_cast( BLI_findlink(&max2_node->inputs, 1)); bNodeSocket *max2_socket_out = blender::bke::node_find_socket( - max2_node, SOCK_OUT, "Value"); + *max2_node, SOCK_OUT, "Value"); *version_cycles_node_socket_float_value(max2_socket_B) = -1e-5f; - blender::bke::node_remove_link(ntree, lacunarity_link); + blender::bke::node_remove_link(ntree, *lacunarity_link); + blender::bke::node_add_link( + *ntree, *lacunarity_from_node, *lacunarity_from_socket, *max2_node, *max2_socket_A); blender::bke::node_add_link( - ntree, lacunarity_from_node, lacunarity_from_socket, max2_node, max2_socket_A); - blender::bke::node_add_link(ntree, max2_node, max2_socket_out, pow_node, pow_socket_A); - blender::bke::node_add_link(ntree, max2_node, max2_socket_out, node, lacunarity_socket); + *ntree, *max2_node, *max2_socket_out, *pow_node, *pow_socket_A); + blender::bke::node_add_link( + *ntree, *max2_node, *max2_socket_out, *node, *lacunarity_socket); } } else if ((lacunarity_link != nullptr) && (roughness_link == nullptr)) { /* Add Maximum Math node after output of lacunarity_from_node. Add Power Math node before * Roughness input. */ - bNode *max2_node = blender::bke::node_add_static_node(nullptr, ntree, SH_NODE_MATH); + bNode *max2_node = blender::bke::node_add_static_node(nullptr, *ntree, SH_NODE_MATH); max2_node->parent = node->parent; max2_node->custom1 = NODE_MATH_MAXIMUM; max2_node->locx_legacy = node->locx_legacy; @@ -2372,9 +2386,9 @@ static void versioning_replace_musgrave_texture_node(bNodeTree *ntree) max2_node->flag |= NODE_HIDDEN; bNodeSocket *max2_socket_A = static_cast(BLI_findlink(&max2_node->inputs, 0)); bNodeSocket *max2_socket_B = static_cast(BLI_findlink(&max2_node->inputs, 1)); - bNodeSocket *max2_socket_out = blender::bke::node_find_socket(max2_node, SOCK_OUT, "Value"); + bNodeSocket *max2_socket_out = blender::bke::node_find_socket(*max2_node, SOCK_OUT, "Value"); - bNode *pow_node = blender::bke::node_add_static_node(nullptr, ntree, SH_NODE_MATH); + bNode *pow_node = blender::bke::node_add_static_node(nullptr, *ntree, SH_NODE_MATH); pow_node->parent = node->parent; pow_node->custom1 = NODE_MATH_POWER; pow_node->locx_legacy = node->locx_legacy; @@ -2382,18 +2396,18 @@ static void versioning_replace_musgrave_texture_node(bNodeTree *ntree) pow_node->flag |= NODE_HIDDEN; bNodeSocket *pow_socket_A = static_cast(BLI_findlink(&pow_node->inputs, 0)); bNodeSocket *pow_socket_B = static_cast(BLI_findlink(&pow_node->inputs, 1)); - bNodeSocket *pow_socket_out = blender::bke::node_find_socket(pow_node, SOCK_OUT, "Value"); + bNodeSocket *pow_socket_out = blender::bke::node_find_socket(*pow_node, SOCK_OUT, "Value"); *version_cycles_node_socket_float_value(max2_socket_B) = -1e-5f; *version_cycles_node_socket_float_value(pow_socket_A) = *lacunarity; *version_cycles_node_socket_float_value(pow_socket_B) = -(*roughness); - blender::bke::node_remove_link(ntree, lacunarity_link); + blender::bke::node_remove_link(ntree, *lacunarity_link); blender::bke::node_add_link( - ntree, lacunarity_from_node, lacunarity_from_socket, max2_node, max2_socket_A); - blender::bke::node_add_link(ntree, max2_node, max2_socket_out, pow_node, pow_socket_A); - blender::bke::node_add_link(ntree, max2_node, max2_socket_out, node, lacunarity_socket); - blender::bke::node_add_link(ntree, pow_node, pow_socket_out, node, roughness_socket); + *ntree, *lacunarity_from_node, *lacunarity_from_socket, *max2_node, *max2_socket_A); + blender::bke::node_add_link(*ntree, *max2_node, *max2_socket_out, *pow_node, *pow_socket_A); + blender::bke::node_add_link(*ntree, *max2_node, *max2_socket_out, *node, *lacunarity_socket); + blender::bke::node_add_link(*ntree, *pow_node, *pow_socket_out, *node, *roughness_socket); } else { *roughness = std::pow(*lacunarity, -(*roughness)); @@ -2418,16 +2432,16 @@ static void version_principled_bsdf_subsurface(bNodeTree *ntree) if (node->type_legacy != SH_NODE_BSDF_PRINCIPLED) { continue; } - if (blender::bke::node_find_socket(node, SOCK_IN, "Subsurface Scale")) { + if (blender::bke::node_find_socket(*node, SOCK_IN, "Subsurface Scale")) { /* Node is already updated. */ continue; } /* Add Scale input */ bNodeSocket *scale_in = blender::bke::node_add_static_socket( - ntree, node, SOCK_IN, SOCK_FLOAT, PROP_DISTANCE, "Subsurface Scale", "Subsurface Scale"); + *ntree, *node, SOCK_IN, SOCK_FLOAT, PROP_DISTANCE, "Subsurface Scale", "Subsurface Scale"); - bNodeSocket *subsurf = blender::bke::node_find_socket(node, SOCK_IN, "Subsurface"); + bNodeSocket *subsurf = blender::bke::node_find_socket(*node, SOCK_IN, "Subsurface"); float *subsurf_val = version_cycles_node_socket_float_value(subsurf); if (!subsurf->link && *subsurf_val == 0.0f) { @@ -2443,21 +2457,21 @@ static void version_principled_bsdf_subsurface(bNodeTree *ntree) } /* Fix up Subsurface Color input */ - bNodeSocket *base_col = blender::bke::node_find_socket(node, SOCK_IN, "Base Color"); - bNodeSocket *subsurf_col = blender::bke::node_find_socket(node, SOCK_IN, "Subsurface Color"); + bNodeSocket *base_col = blender::bke::node_find_socket(*node, SOCK_IN, "Base Color"); + bNodeSocket *subsurf_col = blender::bke::node_find_socket(*node, SOCK_IN, "Subsurface Color"); float *base_col_val = version_cycles_node_socket_rgba_value(base_col); float *subsurf_col_val = version_cycles_node_socket_rgba_value(subsurf_col); /* If any of the three inputs is dynamic, we need a Mix node. */ if (subsurf->link || subsurf_col->link || base_col->link) { - bNode *mix = blender::bke::node_add_static_node(nullptr, ntree, SH_NODE_MIX); + bNode *mix = blender::bke::node_add_static_node(nullptr, *ntree, SH_NODE_MIX); static_cast(mix->storage)->data_type = SOCK_RGBA; mix->locx_legacy = node->locx_legacy - 170; mix->locy_legacy = node->locy_legacy - 120; - bNodeSocket *a_in = blender::bke::node_find_socket(mix, SOCK_IN, "A_Color"); - bNodeSocket *b_in = blender::bke::node_find_socket(mix, SOCK_IN, "B_Color"); - bNodeSocket *fac_in = blender::bke::node_find_socket(mix, SOCK_IN, "Factor_Float"); - bNodeSocket *result_out = blender::bke::node_find_socket(mix, SOCK_OUT, "Result_Color"); + bNodeSocket *a_in = blender::bke::node_find_socket(*mix, SOCK_IN, "A_Color"); + bNodeSocket *b_in = blender::bke::node_find_socket(*mix, SOCK_IN, "B_Color"); + bNodeSocket *fac_in = blender::bke::node_find_socket(*mix, SOCK_IN, "Factor_Float"); + bNodeSocket *result_out = blender::bke::node_find_socket(*mix, SOCK_OUT, "Result_Color"); copy_v4_v4(version_cycles_node_socket_rgba_value(a_in), base_col_val); copy_v4_v4(version_cycles_node_socket_rgba_value(b_in), subsurf_col_val); @@ -2465,22 +2479,22 @@ static void version_principled_bsdf_subsurface(bNodeTree *ntree) if (base_col->link) { blender::bke::node_add_link( - ntree, base_col->link->fromnode, base_col->link->fromsock, mix, a_in); - blender::bke::node_remove_link(ntree, base_col->link); + *ntree, *base_col->link->fromnode, *base_col->link->fromsock, *mix, *a_in); + blender::bke::node_remove_link(ntree, *base_col->link); } if (subsurf_col->link) { blender::bke::node_add_link( - ntree, subsurf_col->link->fromnode, subsurf_col->link->fromsock, mix, b_in); - blender::bke::node_remove_link(ntree, subsurf_col->link); + *ntree, *subsurf_col->link->fromnode, *subsurf_col->link->fromsock, *mix, *b_in); + blender::bke::node_remove_link(ntree, *subsurf_col->link); } if (subsurf->link) { blender::bke::node_add_link( - ntree, subsurf->link->fromnode, subsurf->link->fromsock, mix, fac_in); + *ntree, *subsurf->link->fromnode, *subsurf->link->fromsock, *mix, *fac_in); blender::bke::node_add_link( - ntree, subsurf->link->fromnode, subsurf->link->fromsock, node, scale_in); - blender::bke::node_remove_link(ntree, subsurf->link); + *ntree, *subsurf->link->fromnode, *subsurf->link->fromsock, *node, *scale_in); + blender::bke::node_remove_link(ntree, *subsurf->link); } - blender::bke::node_add_link(ntree, mix, result_out, node, base_col); + blender::bke::node_add_link(*ntree, *mix, *result_out, *node, *base_col); } /* Mix the fixed values. */ interp_v4_v4v4(base_col_val, base_col_val, subsurf_col_val, *subsurf_val); @@ -2489,7 +2503,7 @@ static void version_principled_bsdf_subsurface(bNodeTree *ntree) *subsurf_val = 1.0f; /* Delete Subsurface Color input */ - blender::bke::node_remove_socket(ntree, node, subsurf_col); + blender::bke::node_remove_socket(*ntree, *node, *subsurf_col); } } @@ -2506,16 +2520,16 @@ static void version_principled_bsdf_emission(bNodeTree *ntree) if (node->type_legacy != SH_NODE_BSDF_PRINCIPLED) { continue; } - if (!blender::bke::node_find_socket(node, SOCK_IN, "Emission")) { + if (!blender::bke::node_find_socket(*node, SOCK_IN, "Emission")) { /* Old enough to have neither, new defaults are fine. */ continue; } - if (blender::bke::node_find_socket(node, SOCK_IN, "Emission Strength")) { + if (blender::bke::node_find_socket(*node, SOCK_IN, "Emission Strength")) { /* New enough to have both, no need to do anything. */ continue; } bNodeSocket *sock = blender::bke::node_add_static_socket( - ntree, node, SOCK_IN, SOCK_FLOAT, PROP_NONE, "Emission Strength", "Emission Strength"); + *ntree, *node, SOCK_IN, SOCK_FLOAT, PROP_NONE, "Emission Strength", "Emission Strength"); *version_cycles_node_socket_float_value(sock) = 1.0f; } } @@ -2576,18 +2590,18 @@ static void change_input_socket_to_rotation_type(bNodeTree &ntree, /* Make versioning idempotent. */ continue; } - bNode *convert = blender::bke::node_add_node(nullptr, &ntree, "FunctionNodeEulerToRotation"); + bNode *convert = blender::bke::node_add_node(nullptr, ntree, "FunctionNodeEulerToRotation"); convert->parent = node.parent; convert->locx_legacy = node.locx_legacy - 40; convert->locy_legacy = node.locy_legacy; link->tonode = convert; - link->tosock = blender::bke::node_find_socket(convert, SOCK_IN, "Euler"); + link->tosock = blender::bke::node_find_socket(*convert, SOCK_IN, "Euler"); - blender::bke::node_add_link(&ntree, - convert, - blender::bke::node_find_socket(convert, SOCK_OUT, "Rotation"), - &node, - &socket); + blender::bke::node_add_link(ntree, + *convert, + *blender::bke::node_find_socket(*convert, SOCK_OUT, "Rotation"), + node, + socket); } } @@ -2608,18 +2622,18 @@ static void change_output_socket_to_rotation_type(bNodeTree &ntree, { /* Make versioning idempotent. */ continue; } - bNode *convert = blender::bke::node_add_node(nullptr, &ntree, "FunctionNodeRotationToEuler"); + bNode *convert = blender::bke::node_add_node(nullptr, ntree, "FunctionNodeRotationToEuler"); convert->parent = node.parent; convert->locx_legacy = node.locx_legacy + 40; convert->locy_legacy = node.locy_legacy; link->fromnode = convert; - link->fromsock = blender::bke::node_find_socket(convert, SOCK_OUT, "Euler"); + link->fromsock = blender::bke::node_find_socket(*convert, SOCK_OUT, "Euler"); - blender::bke::node_add_link(&ntree, - &node, - &socket, - convert, - blender::bke::node_find_socket(convert, SOCK_IN, "Rotation")); + blender::bke::node_add_link(ntree, + node, + socket, + *convert, + *blender::bke::node_find_socket(*convert, SOCK_IN, "Rotation")); } } @@ -2631,7 +2645,7 @@ static void version_geometry_nodes_use_rotation_socket(bNodeTree &ntree) "GeometryNodeRotateInstances", "GeometryNodeTransform")) { - bNodeSocket *socket = blender::bke::node_find_socket(node, SOCK_IN, "Rotation"); + bNodeSocket *socket = blender::bke::node_find_socket(*node, SOCK_IN, "Rotation"); change_input_socket_to_rotation_type(ntree, *node, *socket); } if (STR_ELEM(node->idname, @@ -2639,7 +2653,7 @@ static void version_geometry_nodes_use_rotation_socket(bNodeTree &ntree) "GeometryNodeObjectInfo", "GeometryNodeInputInstanceRotation")) { - bNodeSocket *socket = blender::bke::node_find_socket(node, SOCK_OUT, "Rotation"); + bNodeSocket *socket = blender::bke::node_find_socket(*node, SOCK_OUT, "Rotation"); change_output_socket_to_rotation_type(ntree, *node, *socket); } } @@ -2764,14 +2778,14 @@ static void version_principled_bsdf_coat(bNodeTree *ntree) if (node->type_legacy != SH_NODE_BSDF_PRINCIPLED) { continue; } - if (blender::bke::node_find_socket(node, SOCK_IN, "Coat IOR") != nullptr) { + if (blender::bke::node_find_socket(*node, SOCK_IN, "Coat IOR") != nullptr) { continue; } bNodeSocket *coat_ior_input = blender::bke::node_add_static_socket( - ntree, node, SOCK_IN, SOCK_FLOAT, PROP_NONE, "Coat IOR", "Coat IOR"); + *ntree, *node, SOCK_IN, SOCK_FLOAT, PROP_NONE, "Coat IOR", "Coat IOR"); /* Adjust for 4x change in intensity. */ - bNodeSocket *coat_input = blender::bke::node_find_socket(node, SOCK_IN, "Clearcoat"); + bNodeSocket *coat_input = blender::bke::node_find_socket(*node, SOCK_IN, "Clearcoat"); *version_cycles_node_socket_float_value(coat_input) *= 0.25f; /* When the coat input is dynamic, instead of inserting a *0.25 math node, set the Coat IOR * to 1.2 instead - this also roughly quarters reflectivity compared to the 1.5 default. */ @@ -2804,8 +2818,8 @@ static void remove_triangulate_node_min_size_input(bNodeTree *tree) } for (bNode *triangulate : triangulate_nodes) { - bNodeSocket *selection = bke::node_find_socket(triangulate, SOCK_IN, "Selection"); - bNodeSocket *min_verts = bke::node_find_socket(triangulate, SOCK_IN, "Minimum Vertices"); + bNodeSocket *selection = bke::node_find_socket(*triangulate, SOCK_IN, "Selection"); + bNodeSocket *min_verts = bke::node_find_socket(*triangulate, SOCK_IN, "Minimum Vertices"); if (!min_verts) { /* Make versioning idempotent. */ continue; @@ -2854,15 +2868,15 @@ static void remove_triangulate_node_min_size_input(bNodeTree *tree) greater_or_equal.flag &= ~NODE_OPTIONS; version_node_add_link(*tree, corners_of_face, - *bke::node_find_socket(&corners_of_face, SOCK_OUT, "Total"), + *bke::node_find_socket(*&corners_of_face, SOCK_OUT, "Total"), greater_or_equal, - *bke::node_find_socket(&greater_or_equal, SOCK_IN, "A_INT")); + *bke::node_find_socket(*&greater_or_equal, SOCK_IN, "A_INT")); if (bNodeLink **min_verts_link = input_links.lookup_ptr(min_verts)) { (*min_verts_link)->tonode = &greater_or_equal; - (*min_verts_link)->tosock = bke::node_find_socket(&greater_or_equal, SOCK_IN, "B_INT"); + (*min_verts_link)->tosock = bke::node_find_socket(*&greater_or_equal, SOCK_IN, "B_INT"); } else { - bNodeSocket *new_min_verts = bke::node_find_socket(&greater_or_equal, SOCK_IN, "B_INT"); + bNodeSocket *new_min_verts = bke::node_find_socket(*&greater_or_equal, SOCK_IN, "B_INT"); static_cast(new_min_verts->default_value)->value = old_min_verts; } @@ -2881,29 +2895,29 @@ static void remove_triangulate_node_min_size_input(bNodeTree *tree) boolean_and.custom1 = NODE_BOOLEAN_MATH_AND; (*selection_link)->tonode = &boolean_and; - (*selection_link)->tosock = bke::node_find_socket(&boolean_and, SOCK_IN, "Boolean"); + (*selection_link)->tosock = bke::node_find_socket(*&boolean_and, SOCK_IN, "Boolean"); version_node_add_link(*tree, greater_or_equal, - *bke::node_find_socket(&greater_or_equal, SOCK_OUT, "Result"), + *bke::node_find_socket(*&greater_or_equal, SOCK_OUT, "Result"), boolean_and, - *bke::node_find_socket(&boolean_and, SOCK_IN, "Boolean_001")); + *bke::node_find_socket(*&boolean_and, SOCK_IN, "Boolean_001")); version_node_add_link(*tree, boolean_and, - *bke::node_find_socket(&boolean_and, SOCK_OUT, "Boolean"), + *bke::node_find_socket(*&boolean_and, SOCK_OUT, "Boolean"), *triangulate, *selection); } else { version_node_add_link(*tree, greater_or_equal, - *bke::node_find_socket(&greater_or_equal, SOCK_OUT, "Result"), + *bke::node_find_socket(*&greater_or_equal, SOCK_OUT, "Result"), *triangulate, *selection); } /* Make versioning idempotent. */ - bke::node_remove_socket(tree, triangulate, min_verts); + bke::node_remove_socket(*tree, *triangulate, *min_verts); } } /* Convert specular tint in Principled BSDF. */ @@ -2914,14 +2928,14 @@ static void version_principled_bsdf_specular_tint(bNodeTree *ntree) continue; } bNodeSocket *specular_tint_sock = blender::bke::node_find_socket( - node, SOCK_IN, "Specular Tint"); + *node, SOCK_IN, "Specular Tint"); if (specular_tint_sock->type == SOCK_RGBA) { /* Node is already updated. */ continue; } - bNodeSocket *base_color_sock = blender::bke::node_find_socket(node, SOCK_IN, "Base Color"); - bNodeSocket *metallic_sock = blender::bke::node_find_socket(node, SOCK_IN, "Metallic"); + bNodeSocket *base_color_sock = blender::bke::node_find_socket(*node, SOCK_IN, "Base Color"); + bNodeSocket *metallic_sock = blender::bke::node_find_socket(*node, SOCK_IN, "Metallic"); float specular_tint_old = *version_cycles_node_socket_float_value(specular_tint_sock); float *base_color = version_cycles_node_socket_rgba_value(base_color_sock); float metallic = *version_cycles_node_socket_float_value(metallic_sock); @@ -2955,27 +2969,30 @@ static void version_principled_bsdf_specular_tint(bNodeTree *ntree) bNode *metallic_mix_node = nullptr; if (metallic_sock->link || (base_color_sock->link && metallic > 0.0f)) { /* Metallic Mix needs to be dynamically mixed. */ - bNode *mix = blender::bke::node_add_static_node(nullptr, ntree, SH_NODE_MIX); + bNode *mix = blender::bke::node_add_static_node(nullptr, *ntree, SH_NODE_MIX); static_cast(mix->storage)->data_type = SOCK_RGBA; mix->locx_legacy = node->locx_legacy - 270; mix->locy_legacy = node->locy_legacy - 120; - bNodeSocket *a_in = blender::bke::node_find_socket(mix, SOCK_IN, "A_Color"); - bNodeSocket *b_in = blender::bke::node_find_socket(mix, SOCK_IN, "B_Color"); - bNodeSocket *fac_in = blender::bke::node_find_socket(mix, SOCK_IN, "Factor_Float"); - metallic_mix_out = blender::bke::node_find_socket(mix, SOCK_OUT, "Result_Color"); + bNodeSocket *a_in = blender::bke::node_find_socket(*mix, SOCK_IN, "A_Color"); + bNodeSocket *b_in = blender::bke::node_find_socket(*mix, SOCK_IN, "B_Color"); + bNodeSocket *fac_in = blender::bke::node_find_socket(*mix, SOCK_IN, "Factor_Float"); + metallic_mix_out = blender::bke::node_find_socket(*mix, SOCK_OUT, "Result_Color"); metallic_mix_node = mix; copy_v4_v4(version_cycles_node_socket_rgba_value(a_in), base_color); if (base_color_sock->link) { - blender::bke::node_add_link( - ntree, base_color_sock->link->fromnode, base_color_sock->link->fromsock, mix, a_in); + blender::bke::node_add_link(*ntree, + *base_color_sock->link->fromnode, + *base_color_sock->link->fromsock, + *mix, + *a_in); } copy_v4_v4(version_cycles_node_socket_rgba_value(b_in), one); *version_cycles_node_socket_float_value(fac_in) = metallic; if (metallic_sock->link) { blender::bke::node_add_link( - ntree, metallic_sock->link->fromnode, metallic_sock->link->fromsock, mix, fac_in); + *ntree, *metallic_sock->link->fromnode, *metallic_sock->link->fromsock, *mix, *fac_in); } } else if (base_color_sock->link) { @@ -2987,31 +3004,31 @@ static void version_principled_bsdf_specular_tint(bNodeTree *ntree) /* Similar to above, if the Specular Tint input is dynamic, or fixed > 0 and metallic mix * is dynamic, we need to insert a node to compute the new specular tint. */ if (specular_tint_sock->link || (metallic_mix_out && specular_tint_old > 0.0f)) { - bNode *mix = blender::bke::node_add_static_node(nullptr, ntree, SH_NODE_MIX); + bNode *mix = blender::bke::node_add_static_node(nullptr, *ntree, SH_NODE_MIX); static_cast(mix->storage)->data_type = SOCK_RGBA; mix->locx_legacy = node->locx_legacy - 170; mix->locy_legacy = node->locy_legacy - 120; - bNodeSocket *a_in = blender::bke::node_find_socket(mix, SOCK_IN, "A_Color"); - bNodeSocket *b_in = blender::bke::node_find_socket(mix, SOCK_IN, "B_Color"); - bNodeSocket *fac_in = blender::bke::node_find_socket(mix, SOCK_IN, "Factor_Float"); - bNodeSocket *result_out = blender::bke::node_find_socket(mix, SOCK_OUT, "Result_Color"); + bNodeSocket *a_in = blender::bke::node_find_socket(*mix, SOCK_IN, "A_Color"); + bNodeSocket *b_in = blender::bke::node_find_socket(*mix, SOCK_IN, "B_Color"); + bNodeSocket *fac_in = blender::bke::node_find_socket(*mix, SOCK_IN, "Factor_Float"); + bNodeSocket *result_out = blender::bke::node_find_socket(*mix, SOCK_OUT, "Result_Color"); copy_v4_v4(version_cycles_node_socket_rgba_value(a_in), one); copy_v4_v4(version_cycles_node_socket_rgba_value(b_in), metallic_mix); if (metallic_mix_out) { - blender::bke::node_add_link(ntree, metallic_mix_node, metallic_mix_out, mix, b_in); + blender::bke::node_add_link(*ntree, *metallic_mix_node, *metallic_mix_out, *mix, *b_in); } *version_cycles_node_socket_float_value(fac_in) = specular_tint_old; if (specular_tint_sock->link) { - blender::bke::node_add_link(ntree, - specular_tint_sock->link->fromnode, - specular_tint_sock->link->fromsock, - mix, - fac_in); - blender::bke::node_remove_link(ntree, specular_tint_sock->link); + blender::bke::node_add_link(*ntree, + *specular_tint_sock->link->fromnode, + *specular_tint_sock->link->fromsock, + *mix, + *fac_in); + blender::bke::node_remove_link(ntree, *specular_tint_sock->link); } - blender::bke::node_add_link(ntree, mix, result_out, node, specular_tint_sock); + blender::bke::node_add_link(*ntree, *mix, *result_out, *node, *specular_tint_sock); } } } @@ -3308,21 +3325,21 @@ static void fix_geometry_nodes_object_info_scale(bNodeTree &ntree) if (node->type_legacy != GEO_NODE_OBJECT_INFO) { continue; } - bNodeSocket *scale = blender::bke::node_find_socket(node, SOCK_OUT, "Scale"); + bNodeSocket *scale = blender::bke::node_find_socket(*node, SOCK_OUT, "Scale"); const Span links = out_links_per_socket.lookup(scale); if (links.is_empty()) { continue; } - bNode *absolute_value = blender::bke::node_add_node(nullptr, &ntree, "ShaderNodeVectorMath"); + bNode *absolute_value = blender::bke::node_add_node(nullptr, ntree, "ShaderNodeVectorMath"); absolute_value->custom1 = NODE_VECTOR_MATH_ABSOLUTE; absolute_value->parent = node->parent; absolute_value->locx_legacy = node->locx_legacy + 100; absolute_value->locy_legacy = node->locy_legacy - 50; - blender::bke::node_add_link(&ntree, - node, - scale, - absolute_value, - static_cast(absolute_value->inputs.first)); + blender::bke::node_add_link(*&ntree, + *node, + *scale, + *absolute_value, + *static_cast(absolute_value->inputs.first)); for (bNodeLink *link : links) { link->fromnode = absolute_value; link->fromsock = static_cast(absolute_value->outputs.first); diff --git a/source/blender/blenloader/intern/versioning_common.cc b/source/blender/blenloader/intern/versioning_common.cc index 76a576a5811..b79bb055614 100644 --- a/source/blender/blenloader/intern/versioning_common.cc +++ b/source/blender/blenloader/intern/versioning_common.cc @@ -211,11 +211,11 @@ bNode &version_node_add_empty(bNodeTree &ntree, const char *idname) bNode *node = MEM_cnew(__func__); node->runtime = MEM_new(__func__); BLI_addtail(&ntree.nodes, node); - blender::bke::node_unique_id(&ntree, node); + blender::bke::node_unique_id(ntree, *node); STRNCPY(node->idname, idname); DATA_(ntype->ui_name).copy_utf8_truncated(node->name); - blender::bke::node_unique_name(&ntree, node); + blender::bke::node_unique_name(ntree, *node); node->flag = NODE_SELECT | NODE_OPTIONS | NODE_INIT; node->width = ntype->width; @@ -292,12 +292,12 @@ bNodeSocket *version_node_add_socket_if_not_exist(bNodeTree *ntree, const char *identifier, const char *name) { - bNodeSocket *sock = blender::bke::node_find_socket(node, eNodeSocketInOut(in_out), identifier); + bNodeSocket *sock = blender::bke::node_find_socket(*node, eNodeSocketInOut(in_out), identifier); if (sock != nullptr) { return sock; } return blender::bke::node_add_static_socket( - ntree, node, eNodeSocketInOut(in_out), type, subtype, identifier, name); + *ntree, *node, eNodeSocketInOut(in_out), type, subtype, identifier, name); } void version_node_id(bNodeTree *ntree, const int node_type, const char *new_name) @@ -387,7 +387,7 @@ void node_tree_relink_with_socket_id_map(bNodeTree &ntree, if (old_socket->is_available()) { if (const std::string *new_identifier = map.lookup_ptr_as(old_socket->identifier)) { bNodeSocket *new_socket = blender::bke::node_find_socket( - &new_node, SOCK_IN, *new_identifier); + *&new_node, SOCK_IN, *new_identifier); link->tonode = &new_node; link->tosock = new_socket; old_socket->link = nullptr; @@ -399,7 +399,7 @@ void node_tree_relink_with_socket_id_map(bNodeTree &ntree, if (old_socket->is_available()) { if (const std::string *new_identifier = map.lookup_ptr_as(old_socket->identifier)) { bNodeSocket *new_socket = blender::bke::node_find_socket( - &new_node, SOCK_OUT, *new_identifier); + *&new_node, SOCK_OUT, *new_identifier); link->fromnode = &new_node; link->fromsock = new_socket; old_socket->link = nullptr; @@ -433,15 +433,15 @@ void add_realize_instances_before_socket(bNodeTree *ntree, } bNode *realize_node = blender::bke::node_add_static_node( - nullptr, ntree, GEO_NODE_REALIZE_INSTANCES); + nullptr, *ntree, GEO_NODE_REALIZE_INSTANCES); realize_node->parent = node->parent; realize_node->locx_legacy = node->locx_legacy - 100; realize_node->locy_legacy = node->locy_legacy; - blender::bke::node_add_link(ntree, - link->fromnode, - link->fromsock, - realize_node, - static_cast(realize_node->inputs.first)); + blender::bke::node_add_link(*ntree, + *link->fromnode, + *link->fromsock, + *realize_node, + *static_cast(realize_node->inputs.first)); link->fromnode = realize_node; link->fromsock = static_cast(realize_node->outputs.first); } @@ -545,7 +545,7 @@ void version_update_node_input( } /* Replace links with updated equivalent */ - blender::bke::node_remove_link(ntree, link); + blender::bke::node_remove_link(ntree, *link); update_input_link(fromnode, fromsock, tonode, tosock); need_update = true; @@ -555,7 +555,7 @@ void version_update_node_input( * Do this after the link update in case it changes the identifier. */ LISTBASE_FOREACH (bNode *, node, &ntree->nodes) { if (check_node(node)) { - bNodeSocket *input = blender::bke::node_find_socket(node, SOCK_IN, socket_identifier); + bNodeSocket *input = blender::bke::node_find_socket(*node, SOCK_IN, socket_identifier); if (input != nullptr) { update_input(node, input); } diff --git a/source/blender/blenloader/intern/versioning_defaults.cc b/source/blender/blenloader/intern/versioning_defaults.cc index d2d45c38d4c..334156ea421 100644 --- a/source/blender/blenloader/intern/versioning_defaults.cc +++ b/source/blender/blenloader/intern/versioning_defaults.cc @@ -657,12 +657,12 @@ void BLO_update_defaults_startup_blend(Main *bmain, const char *app_template) for (bNode *node : ma->nodetree->all_nodes()) { if (node->type_legacy == SH_NODE_BSDF_PRINCIPLED) { bNodeSocket *roughness_socket = blender::bke::node_find_socket( - node, SOCK_IN, "Roughness"); + *node, SOCK_IN, "Roughness"); *version_cycles_node_socket_float_value(roughness_socket) = 0.5f; - bNodeSocket *emission = blender::bke::node_find_socket(node, SOCK_IN, "Emission Color"); + bNodeSocket *emission = blender::bke::node_find_socket(*node, SOCK_IN, "Emission Color"); copy_v4_fl(version_cycles_node_socket_rgba_value(emission), 1.0f); bNodeSocket *emission_strength = blender::bke::node_find_socket( - node, SOCK_IN, "Emission Strength"); + *node, SOCK_IN, "Emission Strength"); *version_cycles_node_socket_float_value(emission_strength) = 0.0f; node->custom1 = SHD_GLOSSY_MULTI_GGX; diff --git a/source/blender/draw/engines/eevee_next/eevee_lookdev.cc b/source/blender/draw/engines/eevee_next/eevee_lookdev.cc index 71e50f8979c..f0a8e3076c7 100644 --- a/source/blender/draw/engines/eevee_next/eevee_lookdev.cc +++ b/source/blender/draw/engines/eevee_next/eevee_lookdev.cc @@ -34,36 +34,36 @@ LookdevWorld::LookdevWorld() bNodeTree *ntree = bke::node_tree_add_tree( nullptr, "Lookdev World Nodetree", ntreeType_Shader->idname); - bNode *coordinate = bke::node_add_static_node(nullptr, ntree, SH_NODE_TEX_COORD); - bNodeSocket *coordinate_out = bke::node_find_socket(coordinate, SOCK_OUT, "Generated"); + bNode *coordinate = bke::node_add_static_node(nullptr, *ntree, SH_NODE_TEX_COORD); + bNodeSocket *coordinate_out = bke::node_find_socket(*coordinate, SOCK_OUT, "Generated"); - bNode *rotate = bke::node_add_static_node(nullptr, ntree, SH_NODE_VECTOR_ROTATE); + bNode *rotate = bke::node_add_static_node(nullptr, *ntree, SH_NODE_VECTOR_ROTATE); rotate->custom1 = NODE_VECTOR_ROTATE_TYPE_AXIS_Z; - bNodeSocket *rotate_vector_in = bke::node_find_socket(rotate, SOCK_IN, "Vector"); + bNodeSocket *rotate_vector_in = bke::node_find_socket(*rotate, SOCK_IN, "Vector"); angle_socket_ = static_cast( - bke::node_find_socket(rotate, SOCK_IN, "Angle")->default_value); - bNodeSocket *rotate_out = bke::node_find_socket(rotate, SOCK_OUT, "Vector"); + bke::node_find_socket(*rotate, SOCK_IN, "Angle")->default_value); + bNodeSocket *rotate_out = bke::node_find_socket(*rotate, SOCK_OUT, "Vector"); - bNode *environment = bke::node_add_static_node(nullptr, ntree, SH_NODE_TEX_ENVIRONMENT); + bNode *environment = bke::node_add_static_node(nullptr, *ntree, SH_NODE_TEX_ENVIRONMENT); environment_node_ = environment; NodeTexImage *environment_storage = static_cast(environment->storage); - bNodeSocket *environment_vector_in = bke::node_find_socket(environment, SOCK_IN, "Vector"); - bNodeSocket *environment_out = bke::node_find_socket(environment, SOCK_OUT, "Color"); + bNodeSocket *environment_vector_in = bke::node_find_socket(*environment, SOCK_IN, "Vector"); + bNodeSocket *environment_out = bke::node_find_socket(*environment, SOCK_OUT, "Color"); - bNode *background = bke::node_add_static_node(nullptr, ntree, SH_NODE_BACKGROUND); - bNodeSocket *background_out = bke::node_find_socket(background, SOCK_OUT, "Background"); - bNodeSocket *background_color_in = bke::node_find_socket(background, SOCK_IN, "Color"); + bNode *background = bke::node_add_static_node(nullptr, *ntree, SH_NODE_BACKGROUND); + bNodeSocket *background_out = bke::node_find_socket(*background, SOCK_OUT, "Background"); + bNodeSocket *background_color_in = bke::node_find_socket(*background, SOCK_IN, "Color"); intensity_socket_ = static_cast( - bke::node_find_socket(background, SOCK_IN, "Strength")->default_value); + bke::node_find_socket(*background, SOCK_IN, "Strength")->default_value); - bNode *output = bke::node_add_static_node(nullptr, ntree, SH_NODE_OUTPUT_WORLD); - bNodeSocket *output_in = bke::node_find_socket(output, SOCK_IN, "Surface"); + bNode *output = bke::node_add_static_node(nullptr, *ntree, SH_NODE_OUTPUT_WORLD); + bNodeSocket *output_in = bke::node_find_socket(*output, SOCK_IN, "Surface"); - bke::node_add_link(ntree, coordinate, coordinate_out, rotate, rotate_vector_in); - bke::node_add_link(ntree, rotate, rotate_out, environment, environment_vector_in); - bke::node_add_link(ntree, environment, environment_out, background, background_color_in); - bke::node_add_link(ntree, background, background_out, output, output_in); - bke::node_set_active(ntree, output); + bke::node_add_link(*ntree, *coordinate, *coordinate_out, *rotate, *rotate_vector_in); + bke::node_add_link(*ntree, *rotate, *rotate_out, *environment, *environment_vector_in); + bke::node_add_link(*ntree, *environment, *environment_out, *background, *background_color_in); + bke::node_add_link(*ntree, *background, *background_out, *output, *output_in); + bke::node_set_active(*ntree, *output); /* Create a dummy image data block to hold GPU textures generated by studio-lights. */ STRNCPY(image.id.name, "IMLookdev"); diff --git a/source/blender/draw/engines/eevee_next/eevee_material.cc b/source/blender/draw/engines/eevee_next/eevee_material.cc index 9929fd9dc23..52cba332acc 100644 --- a/source/blender/draw/engines/eevee_next/eevee_material.cc +++ b/source/blender/draw/engines/eevee_next/eevee_material.cc @@ -28,21 +28,21 @@ namespace blender::eevee { DefaultSurfaceNodeTree::DefaultSurfaceNodeTree() { bNodeTree *ntree = bke::node_tree_add_tree(nullptr, "Shader Nodetree", ntreeType_Shader->idname); - bNode *bsdf = bke::node_add_static_node(nullptr, ntree, SH_NODE_BSDF_PRINCIPLED); - bNode *output = bke::node_add_static_node(nullptr, ntree, SH_NODE_OUTPUT_MATERIAL); - bNodeSocket *bsdf_out = bke::node_find_socket(bsdf, SOCK_OUT, "BSDF"); - bNodeSocket *output_in = bke::node_find_socket(output, SOCK_IN, "Surface"); - bke::node_add_link(ntree, bsdf, bsdf_out, output, output_in); - bke::node_set_active(ntree, output); + bNode *bsdf = bke::node_add_static_node(nullptr, *ntree, SH_NODE_BSDF_PRINCIPLED); + bNode *output = bke::node_add_static_node(nullptr, *ntree, SH_NODE_OUTPUT_MATERIAL); + bNodeSocket *bsdf_out = bke::node_find_socket(*bsdf, SOCK_OUT, "BSDF"); + bNodeSocket *output_in = bke::node_find_socket(*output, SOCK_IN, "Surface"); + bke::node_add_link(*ntree, *bsdf, *bsdf_out, *output, *output_in); + bke::node_set_active(*ntree, *output); color_socket_ = - (bNodeSocketValueRGBA *)bke::node_find_socket(bsdf, SOCK_IN, "Base Color")->default_value; + (bNodeSocketValueRGBA *)bke::node_find_socket(*bsdf, SOCK_IN, "Base Color")->default_value; metallic_socket_ = - (bNodeSocketValueFloat *)bke::node_find_socket(bsdf, SOCK_IN, "Metallic")->default_value; + (bNodeSocketValueFloat *)bke::node_find_socket(*bsdf, SOCK_IN, "Metallic")->default_value; roughness_socket_ = - (bNodeSocketValueFloat *)bke::node_find_socket(bsdf, SOCK_IN, "Roughness")->default_value; + (bNodeSocketValueFloat *)bke::node_find_socket(*bsdf, SOCK_IN, "Roughness")->default_value; specular_socket_ = (bNodeSocketValueFloat *)bke::node_find_socket( - bsdf, SOCK_IN, "Specular IOR Level") + *bsdf, SOCK_IN, "Specular IOR Level") ->default_value; ntree_ = ntree; } @@ -82,19 +82,19 @@ MaterialModule::MaterialModule(Instance &inst) : inst_(inst) /* Use 0.18 as it is close to middle gray. Middle gray is typically defined as 18% reflectance * of visible light and commonly used for VFX balls. */ - bNode *bsdf = bke::node_add_static_node(nullptr, ntree, SH_NODE_BSDF_DIFFUSE); - bNodeSocket *base_color = bke::node_find_socket(bsdf, SOCK_IN, "Color"); + bNode *bsdf = bke::node_add_static_node(nullptr, *ntree, SH_NODE_BSDF_DIFFUSE); + bNodeSocket *base_color = bke::node_find_socket(*bsdf, SOCK_IN, "Color"); copy_v3_fl(((bNodeSocketValueRGBA *)base_color->default_value)->value, 0.18f); - bNode *output = bke::node_add_static_node(nullptr, ntree, SH_NODE_OUTPUT_MATERIAL); + bNode *output = bke::node_add_static_node(nullptr, *ntree, SH_NODE_OUTPUT_MATERIAL); - bke::node_add_link(ntree, - bsdf, - bke::node_find_socket(bsdf, SOCK_OUT, "BSDF"), - output, - bke::node_find_socket(output, SOCK_IN, "Surface")); + bke::node_add_link(*ntree, + *bsdf, + *bke::node_find_socket(*bsdf, SOCK_OUT, "BSDF"), + *output, + *bke::node_find_socket(*output, SOCK_IN, "Surface")); - bke::node_set_active(ntree, output); + bke::node_set_active(*ntree, *output); } { metallic_mat = (::Material *)BKE_id_new_nomain(ID_MA, "EEVEE default metal"); @@ -103,21 +103,21 @@ MaterialModule::MaterialModule(Instance &inst) : inst_(inst) metallic_mat->use_nodes = true; metallic_mat->surface_render_method = MA_SURFACE_METHOD_FORWARD; - bNode *bsdf = bke::node_add_static_node(nullptr, ntree, SH_NODE_BSDF_GLOSSY); - bNodeSocket *base_color = bke::node_find_socket(bsdf, SOCK_IN, "Color"); + bNode *bsdf = bke::node_add_static_node(nullptr, *ntree, SH_NODE_BSDF_GLOSSY); + bNodeSocket *base_color = bke::node_find_socket(*bsdf, SOCK_IN, "Color"); copy_v3_fl(((bNodeSocketValueRGBA *)base_color->default_value)->value, 1.0f); - bNodeSocket *roughness = bke::node_find_socket(bsdf, SOCK_IN, "Roughness"); + bNodeSocket *roughness = bke::node_find_socket(*bsdf, SOCK_IN, "Roughness"); ((bNodeSocketValueFloat *)roughness->default_value)->value = 0.0f; - bNode *output = bke::node_add_static_node(nullptr, ntree, SH_NODE_OUTPUT_MATERIAL); + bNode *output = bke::node_add_static_node(nullptr, *ntree, SH_NODE_OUTPUT_MATERIAL); - bke::node_add_link(ntree, - bsdf, - bke::node_find_socket(bsdf, SOCK_OUT, "BSDF"), - output, - bke::node_find_socket(output, SOCK_IN, "Surface")); + bke::node_add_link(*ntree, + *bsdf, + *bke::node_find_socket(*bsdf, SOCK_OUT, "BSDF"), + *output, + *bke::node_find_socket(*output, SOCK_IN, "Surface")); - bke::node_set_active(ntree, output); + bke::node_set_active(*ntree, *output); } { error_mat_ = (::Material *)BKE_id_new_nomain(ID_MA, "EEVEE default error"); @@ -126,19 +126,19 @@ MaterialModule::MaterialModule(Instance &inst) : inst_(inst) error_mat_->use_nodes = true; /* Use emission and output material to be compatible with both World and Material. */ - bNode *bsdf = bke::node_add_static_node(nullptr, ntree, SH_NODE_EMISSION); - bNodeSocket *color = bke::node_find_socket(bsdf, SOCK_IN, "Color"); + bNode *bsdf = bke::node_add_static_node(nullptr, *ntree, SH_NODE_EMISSION); + bNodeSocket *color = bke::node_find_socket(*bsdf, SOCK_IN, "Color"); copy_v3_fl3(((bNodeSocketValueRGBA *)color->default_value)->value, 1.0f, 0.0f, 1.0f); - bNode *output = bke::node_add_static_node(nullptr, ntree, SH_NODE_OUTPUT_MATERIAL); + bNode *output = bke::node_add_static_node(nullptr, *ntree, SH_NODE_OUTPUT_MATERIAL); - bke::node_add_link(ntree, - bsdf, - bke::node_find_socket(bsdf, SOCK_OUT, "Emission"), - output, - bke::node_find_socket(output, SOCK_IN, "Surface")); + bke::node_add_link(*ntree, + *bsdf, + *bke::node_find_socket(*bsdf, SOCK_OUT, "Emission"), + *output, + *bke::node_find_socket(*output, SOCK_IN, "Surface")); - bke::node_set_active(ntree, output); + bke::node_set_active(*ntree, *output); } } diff --git a/source/blender/draw/engines/eevee_next/eevee_world.cc b/source/blender/draw/engines/eevee_next/eevee_world.cc index a2c90b654d0..1a97e55d12f 100644 --- a/source/blender/draw/engines/eevee_next/eevee_world.cc +++ b/source/blender/draw/engines/eevee_next/eevee_world.cc @@ -24,15 +24,15 @@ namespace blender::eevee { DefaultWorldNodeTree::DefaultWorldNodeTree() { bNodeTree *ntree = bke::node_tree_add_tree(nullptr, "World Nodetree", ntreeType_Shader->idname); - bNode *background = bke::node_add_static_node(nullptr, ntree, SH_NODE_BACKGROUND); - bNode *output = bke::node_add_static_node(nullptr, ntree, SH_NODE_OUTPUT_WORLD); - bNodeSocket *background_out = bke::node_find_socket(background, SOCK_OUT, "Background"); - bNodeSocket *output_in = bke::node_find_socket(output, SOCK_IN, "Surface"); - bke::node_add_link(ntree, background, background_out, output, output_in); - bke::node_set_active(ntree, output); + bNode *background = bke::node_add_static_node(nullptr, *ntree, SH_NODE_BACKGROUND); + bNode *output = bke::node_add_static_node(nullptr, *ntree, SH_NODE_OUTPUT_WORLD); + bNodeSocket *background_out = bke::node_find_socket(*background, SOCK_OUT, "Background"); + bNodeSocket *output_in = bke::node_find_socket(*output, SOCK_IN, "Surface"); + bke::node_add_link(*ntree, *background, *background_out, *output, *output_in); + bke::node_set_active(*ntree, *output); color_socket_ = - (bNodeSocketValueRGBA *)bke::node_find_socket(background, SOCK_IN, "Color")->default_value; + (bNodeSocketValueRGBA *)bke::node_find_socket(*background, SOCK_IN, "Color")->default_value; ntree_ = ntree; } diff --git a/source/blender/editors/animation/anim_filter.cc b/source/blender/editors/animation/anim_filter.cc index 8279b2969bb..7fd9ed2f769 100644 --- a/source/blender/editors/animation/anim_filter.cc +++ b/source/blender/editors/animation/anim_filter.cc @@ -1061,7 +1061,7 @@ static bool skip_fcurve_selected_data(bAnimContext *ac, BLI_str_quoted_substr(fcu->rna_path, "nodes[", node_name, sizeof(node_name))) { /* Get strip name, and check if this strip is selected. */ - node = bke::node_find_node_by_name(ntree, node_name); + node = bke::node_find_node_by_name(*ntree, node_name); /* Can only add this F-Curve if it is selected. */ if (node) { diff --git a/source/blender/editors/curves/intern/curves_add.cc b/source/blender/editors/curves/intern/curves_add.cc index b3a6c988cbd..74e44f9ddf6 100644 --- a/source/blender/editors/curves/intern/curves_add.cc +++ b/source/blender/editors/curves/intern/curves_add.cc @@ -86,22 +86,22 @@ void ensure_surface_deformation_node_exists(bContext &C, Object &curves_ob) "Geometry", "", "NodeSocketGeometry", NODE_INTERFACE_SOCKET_OUTPUT, nullptr); ntree->tree_interface.add_socket( "Geometry", "", "NodeSocketGeometry", NODE_INTERFACE_SOCKET_INPUT, nullptr); - bNode *group_input = bke::node_add_static_node(&C, ntree, NODE_GROUP_INPUT); - bNode *group_output = bke::node_add_static_node(&C, ntree, NODE_GROUP_OUTPUT); - bNode *deform_node = bke::node_add_static_node(&C, ntree, GEO_NODE_DEFORM_CURVES_ON_SURFACE); + bNode *group_input = bke::node_add_static_node(&C, *ntree, NODE_GROUP_INPUT); + bNode *group_output = bke::node_add_static_node(&C, *ntree, NODE_GROUP_OUTPUT); + bNode *deform_node = bke::node_add_static_node(&C, *ntree, GEO_NODE_DEFORM_CURVES_ON_SURFACE); BKE_main_ensure_invariants(*bmain, nmd.node_group->id); - bke::node_add_link(ntree, - group_input, - static_cast(group_input->outputs.first), - deform_node, - bke::node_find_socket(deform_node, SOCK_IN, "Curves")); - bke::node_add_link(ntree, - deform_node, - bke::node_find_socket(deform_node, SOCK_OUT, "Curves"), - group_output, - static_cast(group_output->inputs.first)); + bke::node_add_link(*ntree, + *group_input, + *static_cast(group_input->outputs.first), + *deform_node, + *bke::node_find_socket(*deform_node, SOCK_IN, "Curves")); + bke::node_add_link(*ntree, + *deform_node, + *bke::node_find_socket(*deform_node, SOCK_OUT, "Curves"), + *group_output, + *static_cast(group_output->inputs.first)); group_input->location[0] = -200; group_output->location[0] = 200; diff --git a/source/blender/editors/interface/templates/interface_template_node_inputs.cc b/source/blender/editors/interface/templates/interface_template_node_inputs.cc index dd99dbb9751..8f7587f4325 100644 --- a/source/blender/editors/interface/templates/interface_template_node_inputs.cc +++ b/source/blender/editors/interface/templates/interface_template_node_inputs.cc @@ -69,7 +69,7 @@ static void draw_node_input(bContext *C, PointerRNA socket_ptr = RNA_pointer_create_discrete( node_ptr->owner_id, &RNA_NodeSocket, &socket); - const StringRefNull text(IFACE_(bke::nodeSocketLabel(&socket).c_str())); + const StringRefNull text(IFACE_(bke::nodeSocketLabel(socket).c_str())); uiLayout *row = uiLayoutRow(layout, true); socket.typeinfo->draw(C, row, &socket_ptr, node_ptr, text); } diff --git a/source/blender/editors/object/object_bake_api.cc b/source/blender/editors/object/object_bake_api.cc index 2a56e82333c..a1395b8f398 100644 --- a/source/blender/editors/object/object_bake_api.cc +++ b/source/blender/editors/object/object_bake_api.cc @@ -522,7 +522,7 @@ static bool bake_object_check(const Scene *scene, if (image) { if (node) { - if (bke::node_is_connected_to_output(ntree, node)) { + if (bke::node_is_connected_to_output(*ntree, *node)) { /* we don't return false since this may be a false positive * this can't be RPT_ERROR though, otherwise it prevents * multiple highpoly objects to be baked at once */ diff --git a/source/blender/editors/sculpt_paint/paint_image_proj.cc b/source/blender/editors/sculpt_paint/paint_image_proj.cc index f41b9e8efd3..2efd3f04140 100644 --- a/source/blender/editors/sculpt_paint/paint_image_proj.cc +++ b/source/blender/editors/sculpt_paint/paint_image_proj.cc @@ -6617,10 +6617,10 @@ static void default_paint_slot_color_get(int layer_type, Material *ma, float col * Copy default color values from a default Principled BSDF instead. */ ntree = blender::bke::node_tree_add_tree( nullptr, "Temporary Shader Nodetree", ntreeType_Shader->idname); - in_node = blender::bke::node_add_static_node(nullptr, ntree, SH_NODE_BSDF_PRINCIPLED); + in_node = blender::bke::node_add_static_node(nullptr, *ntree, SH_NODE_BSDF_PRINCIPLED); } bNodeSocket *in_sock = blender::bke::node_find_socket( - in_node, SOCK_IN, layer_type_items[layer_type].name); + *in_node, SOCK_IN, layer_type_items[layer_type].name); switch (in_sock->type) { case SOCK_FLOAT: { bNodeSocketValueFloat *socket_data = static_cast( @@ -6644,7 +6644,7 @@ static void default_paint_slot_color_get(int layer_type, Material *ma, float col } /* Cleanup */ if (ntree) { - blender::bke::node_tree_free_tree(ntree); + blender::bke::node_tree_free_tree(*ntree); MEM_freeN(ntree); } return; @@ -6698,13 +6698,13 @@ static bool proj_paint_add_slot(bContext *C, wmOperator *op) /* Create a new node. */ switch (slot_type) { case PAINT_CANVAS_SOURCE_IMAGE: { - new_node = blender::bke::node_add_static_node(C, ntree, SH_NODE_TEX_IMAGE); + new_node = blender::bke::node_add_static_node(C, *ntree, SH_NODE_TEX_IMAGE); ima = proj_paint_image_create(op, bmain, is_data); new_node->id = &ima->id; break; } case PAINT_CANVAS_SOURCE_COLOR_ATTRIBUTE: { - new_node = blender::bke::node_add_static_node(C, ntree, SH_NODE_ATTRIBUTE); + new_node = blender::bke::node_add_static_node(C, *ntree, SH_NODE_ATTRIBUTE); if (const char *name = proj_paint_color_attribute_create(op, *ob)) { STRNCPY_UTF8(((NodeShaderAttribute *)new_node->storage)->name, name); } @@ -6714,7 +6714,7 @@ static bool proj_paint_add_slot(bContext *C, wmOperator *op) BLI_assert_unreachable(); return false; } - blender::bke::node_set_active(ntree, new_node); + blender::bke::node_set_active(*ntree, *new_node); /* Connect to first available principled BSDF node. */ ntree->ensure_topology_cache(); @@ -6723,33 +6723,33 @@ static bool proj_paint_add_slot(bContext *C, wmOperator *op) bNode *out_node = new_node; if (in_node != nullptr) { - bNodeSocket *out_sock = blender::bke::node_find_socket(out_node, SOCK_OUT, "Color"); + bNodeSocket *out_sock = blender::bke::node_find_socket(*out_node, SOCK_OUT, "Color"); bNodeSocket *in_sock = nullptr; if (type >= LAYER_BASE_COLOR && type < LAYER_NORMAL) { - in_sock = blender::bke::node_find_socket(in_node, SOCK_IN, layer_type_items[type].name); + in_sock = blender::bke::node_find_socket(*in_node, SOCK_IN, layer_type_items[type].name); } else if (type == LAYER_NORMAL) { bNode *nor_node; - nor_node = blender::bke::node_add_static_node(C, ntree, SH_NODE_NORMAL_MAP); + nor_node = blender::bke::node_add_static_node(C, *ntree, SH_NODE_NORMAL_MAP); - in_sock = blender::bke::node_find_socket(nor_node, SOCK_IN, "Color"); - blender::bke::node_add_link(ntree, out_node, out_sock, nor_node, in_sock); + in_sock = blender::bke::node_find_socket(*nor_node, SOCK_IN, "Color"); + blender::bke::node_add_link(*ntree, *out_node, *out_sock, *nor_node, *in_sock); - in_sock = blender::bke::node_find_socket(in_node, SOCK_IN, "Normal"); - out_sock = blender::bke::node_find_socket(nor_node, SOCK_OUT, "Normal"); + in_sock = blender::bke::node_find_socket(*in_node, SOCK_IN, "Normal"); + out_sock = blender::bke::node_find_socket(*nor_node, SOCK_OUT, "Normal"); out_node = nor_node; } else if (type == LAYER_BUMP) { bNode *bump_node; - bump_node = blender::bke::node_add_static_node(C, ntree, SH_NODE_BUMP); + bump_node = blender::bke::node_add_static_node(C, *ntree, SH_NODE_BUMP); - in_sock = blender::bke::node_find_socket(bump_node, SOCK_IN, "Height"); - blender::bke::node_add_link(ntree, out_node, out_sock, bump_node, in_sock); + in_sock = blender::bke::node_find_socket(*bump_node, SOCK_IN, "Height"); + blender::bke::node_add_link(*ntree, *out_node, *out_sock, *bump_node, *in_sock); - in_sock = blender::bke::node_find_socket(in_node, SOCK_IN, "Normal"); - out_sock = blender::bke::node_find_socket(bump_node, SOCK_OUT, "Normal"); + in_sock = blender::bke::node_find_socket(*in_node, SOCK_IN, "Normal"); + out_sock = blender::bke::node_find_socket(*bump_node, SOCK_OUT, "Normal"); out_node = bump_node; } @@ -6760,7 +6760,7 @@ static bool proj_paint_add_slot(bContext *C, wmOperator *op) in_node = output_nodes.is_empty() ? nullptr : output_nodes.first(); if (in_node != nullptr) { - in_sock = blender::bke::node_find_socket(in_node, SOCK_IN, layer_type_items[type].name); + in_sock = blender::bke::node_find_socket(*in_node, SOCK_IN, layer_type_items[type].name); } else { in_sock = nullptr; @@ -6770,15 +6770,15 @@ static bool proj_paint_add_slot(bContext *C, wmOperator *op) /* Check if the socket in already connected to something */ bNodeLink *link = in_sock ? in_sock->link : nullptr; if (in_sock != nullptr && link == nullptr) { - blender::bke::node_add_link(ntree, out_node, out_sock, in_node, in_sock); + blender::bke::node_add_link(*ntree, *out_node, *out_sock, *in_node, *in_sock); - blender::bke::node_position_relative(out_node, in_node, out_sock, in_sock); + blender::bke::node_position_relative(*out_node, *in_node, *out_sock, *in_sock); } } BKE_main_ensure_invariants(*bmain); /* In case we added more than one node, position them too. */ - blender::bke::node_position_propagate(out_node); + blender::bke::node_position_propagate(*out_node); if (ima) { BKE_texpaint_slot_refresh_cache(scene, ma, ob); diff --git a/source/blender/editors/space_buttons/buttons_texture.cc b/source/blender/editors/space_buttons/buttons_texture.cc index cd7bca2b2ee..0f77d83088a 100644 --- a/source/blender/editors/space_buttons/buttons_texture.cc +++ b/source/blender/editors/space_buttons/buttons_texture.cc @@ -435,9 +435,9 @@ static void template_texture_select(bContext *C, void *user_p, void * /*arg*/) /* Not totally sure if we should also change selection? */ for (bNode *node : user->ntree->all_nodes()) { - blender::bke::node_set_selected(node, false); + blender::bke::node_set_selected(*node, false); } - blender::bke::node_set_selected(user->node, true); + blender::bke::node_set_selected(*user->node, true); WM_event_add_notifier(C, NC_NODE | NA_SELECTED, nullptr); } if (user->ptr.data) { diff --git a/source/blender/editors/space_node/clipboard.cc b/source/blender/editors/space_node/clipboard.cc index 039822dca8e..8a57d1152d8 100644 --- a/source/blender/editors/space_node/clipboard.cc +++ b/source/blender/editors/space_node/clipboard.cc @@ -86,7 +86,7 @@ struct NodeClipboard { void clear() { for (NodeClipboardItem &item : this->nodes) { - bke::node_free_node(nullptr, item.node); + bke::node_free_node(nullptr, *item.node); } this->nodes.clear_and_shrink(); this->links.clear_and_shrink(); @@ -304,7 +304,7 @@ static int node_clipboard_copy_exec(bContext *C, wmOperator * /*op*/) new_node->parent = node_map.lookup(new_node->parent); } else { - bke::node_detach_node(&tree, new_node); + bke::node_detach_node(tree, *new_node); } } } @@ -412,7 +412,7 @@ static int node_clipboard_paste_exec(bContext *C, wmOperator *op) } for (bNode *new_node : node_map.values()) { - bke::node_set_selected(new_node, true); + bke::node_set_selected(*new_node, true); new_node->flag &= ~NODE_ACTIVE; @@ -450,7 +450,7 @@ static int node_clipboard_paste_exec(bContext *C, wmOperator *op) remap_node_pairing(tree, node_map); for (bNode *new_node : node_map.values()) { - bke::node_declaration_ensure(&tree, new_node); + bke::node_declaration_ensure(tree, *new_node); } /* Add links between existing nodes. */ @@ -460,13 +460,13 @@ static int node_clipboard_paste_exec(bContext *C, wmOperator *op) if (!from_node || !to_node) { continue; } - bNodeSocket *from = bke::node_find_socket(from_node, SOCK_OUT, link.from_socket.c_str()); - bNodeSocket *to = bke::node_find_socket(to_node, SOCK_IN, link.to_socket.c_str()); + bNodeSocket *from = bke::node_find_socket(*from_node, SOCK_OUT, link.from_socket.c_str()); + bNodeSocket *to = bke::node_find_socket(*to_node, SOCK_IN, link.to_socket.c_str()); if (!from || !to) { continue; } - bNodeLink *new_link = bke::node_add_link(&tree, from_node, from, to_node, to); - new_link->multi_input_sort_id = link.multi_input_sort_id; + bNodeLink &new_link = bke::node_add_link(tree, *from_node, *from, *to_node, *to); + new_link.multi_input_sort_id = link.multi_input_sort_id; } tree.ensure_topology_cache(); diff --git a/source/blender/editors/space_node/link_drag_search.cc b/source/blender/editors/space_node/link_drag_search.cc index 93b362bb633..89fc697f1df 100644 --- a/source/blender/editors/space_node/link_drag_search.cc +++ b/source/blender/editors/space_node/link_drag_search.cc @@ -70,18 +70,18 @@ static void add_reroute_node_fn(nodes::LinkSearchOpParams ¶ms) { bNode &reroute = params.add_node("NodeReroute"); if (params.socket.in_out == SOCK_IN) { - bke::node_add_link(¶ms.node_tree, - &reroute, - static_cast(reroute.outputs.first), - ¶ms.node, - ¶ms.socket); + bke::node_add_link(params.node_tree, + reroute, + *static_cast(reroute.outputs.first), + params.node, + params.socket); } else { - bke::node_add_link(¶ms.node_tree, - ¶ms.node, - ¶ms.socket, - &reroute, - static_cast(reroute.inputs.first)); + bke::node_add_link(params.node_tree, + params.node, + params.socket, + reroute, + *static_cast(reroute.inputs.first)); } } @@ -106,7 +106,7 @@ static void add_group_input_node_fn(nodes::LinkSearchOpParams ¶ms) for (bNode *node : params.node_tree.all_nodes()) { if (node->is_group_input()) { bNodeSocket *new_group_input_socket = bke::node_find_socket( - node, SOCK_OUT, socket_iface->identifier); + *node, SOCK_OUT, socket_iface->identifier); if (new_group_input_socket) { new_group_input_socket->flag |= SOCK_HIDDEN; } @@ -118,11 +118,11 @@ static void add_group_input_node_fn(nodes::LinkSearchOpParams ¶ms) socket->flag |= SOCK_HIDDEN; } - bNodeSocket *socket = bke::node_find_socket(&group_input, SOCK_OUT, socket_iface->identifier); + bNodeSocket *socket = bke::node_find_socket(group_input, SOCK_OUT, socket_iface->identifier); if (socket) { /* Unhide the socket for the new input in the new node and make a connection to it. */ socket->flag &= ~SOCK_HIDDEN; - bke::node_add_link(¶ms.node_tree, &group_input, socket, ¶ms.node, ¶ms.socket); + bke::node_add_link(params.node_tree, group_input, *socket, params.node, params.socket); bke::node_socket_move_default_value( *CTX_data_main(¶ms.C), params.node_tree, params.socket, *socket); @@ -143,10 +143,10 @@ static void add_existing_group_input_fn(nodes::LinkSearchOpParams ¶ms, socket->flag |= SOCK_HIDDEN; } - bNodeSocket *socket = bke::node_find_socket(&group_input, SOCK_OUT, interface_socket.identifier); + bNodeSocket *socket = bke::node_find_socket(group_input, SOCK_OUT, interface_socket.identifier); if (socket != nullptr) { socket->flag &= ~SOCK_HIDDEN; - bke::node_add_link(¶ms.node_tree, &group_input, socket, ¶ms.node, ¶ms.socket); + bke::node_add_link(params.node_tree, group_input, *socket, params.node, params.socket); } } @@ -224,7 +224,7 @@ static void search_link_ops_for_asset_metadata(const bNodeTree &node_tree, if (new_node_socket != nullptr) { /* Rely on the way #node_add_link switches in/out if necessary. */ bke::node_add_link( - ¶ms.node_tree, ¶ms.node, ¶ms.socket, &node, new_node_socket); + params.node_tree, params.node, params.socket, node, *new_node_socket); } }, weight}); @@ -380,8 +380,8 @@ static void link_drag_search_exec_fn(bContext *C, void *arg1, void *arg2) new_node->location[0] -= new_node->width; } - bke::node_set_selected(new_node, true); - bke::node_set_active(&node_tree, new_node); + bke::node_set_selected(*new_node, true); + bke::node_set_active(node_tree, *new_node); /* Ideally it would be possible to tag the node tree in some way so it updates only after the * translate operation is finished, but normally moving nodes around doesn't cause updates. */ diff --git a/source/blender/editors/space_node/node_add.cc b/source/blender/editors/space_node/node_add.cc index 8072233cc5c..e56d954bd0e 100644 --- a/source/blender/editors/space_node/node_add.cc +++ b/source/blender/editors/space_node/node_add.cc @@ -82,12 +82,12 @@ bNode *add_node(const bContext &C, const StringRef idname, const float2 &locatio const std::string idname_str = idname; - bNode *node = bke::node_add_node(&C, &node_tree, idname_str.c_str()); + bNode *node = bke::node_add_node(&C, node_tree, idname_str.c_str()); BLI_assert(node && node->typeinfo); position_node_based_on_mouse(*node, location); - bke::node_set_selected(node, true); + bke::node_set_selected(*node, true); ED_node_set_active(&bmain, &snode, &node_tree, node, nullptr); BKE_main_ensure_invariants(bmain, node_tree.id); @@ -102,12 +102,12 @@ bNode *add_static_node(const bContext &C, int type, const float2 &location) node_deselect_all(node_tree); - bNode *node = bke::node_add_static_node(&C, &node_tree, type); + bNode *node = bke::node_add_static_node(&C, node_tree, type); BLI_assert(node && node->typeinfo); position_node_based_on_mouse(*node, location); - bke::node_set_selected(node, true); + bke::node_set_selected(*node, true); ED_node_set_active(&bmain, &snode, &node_tree, node, nullptr); BKE_main_ensure_invariants(bmain, node_tree.id); @@ -195,13 +195,13 @@ static int add_reroute_exec(bContext *C, wmOperator *op) for (const auto item : cuts_per_socket.items()) { const Map &cuts = item.value.links; - bNode *reroute = bke::node_add_static_node(C, &ntree, NODE_REROUTE); + bNode *reroute = bke::node_add_static_node(C, ntree, NODE_REROUTE); - bke::node_add_link(&ntree, - item.value.from_node, - item.key, - reroute, - static_cast(reroute->inputs.first)); + bke::node_add_link(ntree, + *item.value.from_node, + *item.key, + *reroute, + *static_cast(reroute->inputs.first)); /* Reconnect links from the original output socket to the new reroute. */ for (bNodeLink *link : cuts.keys()) { @@ -221,7 +221,7 @@ static int add_reroute_exec(bContext *C, wmOperator *op) for (const int i : frame_nodes.index_range()) { bNode *frame_node = frame_nodes.last(i); if (BLI_rctf_isect_pt_v(&frame_node->runtime->draw_bounds, insert_point)) { - bke::node_attach_node(&ntree, reroute, frame_node); + bke::node_attach_node(ntree, *reroute, *frame_node); break; } } @@ -332,7 +332,7 @@ static int node_add_group_exec(bContext *C, wmOperator *op) id_us_plus(group_node->id); BKE_ntree_update_tag_node_property(snode->edittree, group_node); - bke::node_set_active(ntree, group_node); + bke::node_set_active(*ntree, *group_node); BKE_main_ensure_invariants(*bmain); WM_event_add_notifier(C, NC_NODE | NA_ADDED, nullptr); DEG_relations_tag_update(bmain); @@ -435,7 +435,7 @@ static bool add_node_group_asset(const bContext &C, id_us_plus(group_node->id); BKE_ntree_update_tag_node_property(&edit_tree, group_node); - bke::node_set_active(&edit_tree, group_node); + bke::node_set_active(edit_tree, *group_node); BKE_main_ensure_invariants(bmain); WM_event_add_notifier(&C, NC_NODE | NA_ADDED, nullptr); DEG_relations_tag_update(&bmain); @@ -535,7 +535,7 @@ static int node_add_object_exec(bContext *C, wmOperator *op) return OPERATOR_CANCELLED; } - bNodeSocket *sock = bke::node_find_socket(object_node, SOCK_IN, "Object"); + bNodeSocket *sock = bke::node_find_socket(*object_node, SOCK_IN, "Object"); if (!sock) { BLI_assert_unreachable(); return OPERATOR_CANCELLED; @@ -546,7 +546,7 @@ static int node_add_object_exec(bContext *C, wmOperator *op) id_us_plus(&object->id); BKE_ntree_update_tag_socket_property(ntree, sock); - bke::node_set_active(ntree, object_node); + bke::node_set_active(*ntree, *object_node); BKE_main_ensure_invariants(*bmain, ntree->id); DEG_relations_tag_update(bmain); @@ -622,7 +622,7 @@ static int node_add_collection_exec(bContext *C, wmOperator *op) return OPERATOR_CANCELLED; } - bNodeSocket *sock = bke::node_find_socket(collection_node, SOCK_IN, "Collection"); + bNodeSocket *sock = bke::node_find_socket(*collection_node, SOCK_IN, "Collection"); if (!sock) { BKE_report(op->reports, RPT_WARNING, "Could not find node collection socket"); return OPERATOR_CANCELLED; @@ -633,7 +633,7 @@ static int node_add_collection_exec(bContext *C, wmOperator *op) id_us_plus(&collection->id); BKE_ntree_update_tag_socket_property(&ntree, sock); - bke::node_set_active(&ntree, collection_node); + bke::node_set_active(ntree, *collection_node); BKE_main_ensure_invariants(*bmain, ntree.id); DEG_relations_tag_update(bmain); @@ -807,7 +807,7 @@ static int node_add_file_exec(bContext *C, wmOperator *op) } else { node->id = (ID *)image; - blender::bke::node_tag_update_id(node); + blender::bke::node_tag_update_id(*node); } BKE_ntree_update_tag_node_property(&node_tree, node); nodes.append(node); @@ -822,7 +822,7 @@ static int node_add_file_exec(bContext *C, wmOperator *op) /* Set new nodes as selected. */ node_deselect_all(node_tree); for (bNode *node : nodes) { - bke::node_set_selected(node, true); + bke::node_set_selected(*node, true); } ED_node_set_active(bmain, &snode, &node_tree, nodes[0], nullptr); @@ -1094,7 +1094,7 @@ static int node_add_color_exec(bContext *C, wmOperator *op) copy_v4_v4(socket_data->value, color); } - bke::node_set_active(ntree, color_node); + bke::node_set_active(*ntree, *color_node); BKE_main_ensure_invariants(*bmain, ntree->id); return OPERATOR_FINISHED; diff --git a/source/blender/editors/space_node/node_draw.cc b/source/blender/editors/space_node/node_draw.cc index 202abb1e0a8..3b8c8877b25 100644 --- a/source/blender/editors/space_node/node_draw.cc +++ b/source/blender/editors/space_node/node_draw.cc @@ -445,14 +445,14 @@ const char *node_socket_get_label(const bNodeSocket *socket, const char *panel_l { /* Get the short label if possible. This is used when grouping sockets under panels, * to avoid redundancy in the label. */ - const std::optional socket_short_label = bke::nodeSocketShortLabel(socket); + const std::optional socket_short_label = bke::nodeSocketShortLabel(*socket); const char *socket_translation_context = node_socket_get_translation_context(*socket); if (socket_short_label.has_value()) { return CTX_IFACE_(socket_translation_context, socket_short_label->c_str()); } - const StringRefNull socket_label = bke::nodeSocketLabel(socket); + const StringRefNull socket_label = bke::nodeSocketLabel(*socket); const char *translated_socket_label = CTX_IFACE_(socket_translation_context, socket_label.c_str()); @@ -1393,7 +1393,7 @@ static void node_draw_mute_line(const bContext &C, GPU_blend(GPU_BLEND_ALPHA); for (const bNodeLink &link : node.internal_links()) { - if (!bke::node_link_is_hidden(&link)) { + if (!bke::node_link_is_hidden(link)) { node_draw_link_bezier(C, v2d, snode, link, TH_WIRE_INNER, TH_WIRE_INNER, TH_WIRE, false); } } @@ -2111,14 +2111,14 @@ static std::string node_socket_get_tooltip(const SpaceNode *snode, const bNode &node = socket.owner_node(); if (node.is_reroute()) { char reroute_name[MAX_NAME]; - bke::nodeLabel(&ntree, &node, reroute_name, sizeof(reroute_name)); + bke::nodeLabel(ntree, node, reroute_name, sizeof(reroute_name)); output << reroute_name; } else if (is_extend) { output << TIP_("Connect a link to create a new socket"); } else { - output << bke::nodeSocketLabel(&socket); + output << bke::nodeSocketLabel(socket); } if (ntree.type == NTREE_GEOMETRY && !is_extend) { @@ -3549,7 +3549,7 @@ static void node_draw_basis(const bContext &C, } char showname[128]; - bke::nodeLabel(&ntree, &node, showname, sizeof(showname)); + bke::nodeLabel(ntree, node, showname, sizeof(showname)); uiBut *but = uiDefBut(&block, UI_BTYPE_LABEL, @@ -3588,7 +3588,7 @@ static void node_draw_basis(const bContext &C, const float outline_width = U.pixelsize; { /* Use warning color to indicate undefined types. */ - if (bke::node_type_is_undefined(&node)) { + if (bke::node_type_is_undefined(node)) { UI_GetThemeColorBlend4f(TH_REDALERT, TH_NODE, 0.4f, color); } /* Muted nodes get a mix of the background with the node color. */ @@ -3666,7 +3666,7 @@ static void node_draw_basis(const bContext &C, if (node.flag & SELECT) { UI_GetThemeColor4fv((node.flag & NODE_ACTIVE) ? TH_ACTIVE : TH_SELECT, color_outline); } - else if (bke::node_type_is_undefined(&node)) { + else if (bke::node_type_is_undefined(node)) { UI_GetThemeColor4fv(TH_REDALERT, color_outline); } else if (const bke::bNodeZoneType *zone_type = bke::zone_type_by_node_type(node.type_legacy)) { @@ -3730,7 +3730,7 @@ static void node_draw_hidden(const bContext &C, /* Body. */ float color[4]; { - if (bke::node_type_is_undefined(&node)) { + if (bke::node_type_is_undefined(node)) { /* Use warning color to indicate undefined types. */ UI_GetThemeColorBlend4f(TH_REDALERT, TH_NODE, 0.4f, color); } @@ -3801,7 +3801,7 @@ static void node_draw_hidden(const bContext &C, } char showname[128]; - bke::nodeLabel(&ntree, &node, showname, sizeof(showname)); + bke::nodeLabel(ntree, node, showname, sizeof(showname)); uiBut *but = uiDefBut(&block, UI_BTYPE_LABEL, @@ -3832,7 +3832,7 @@ static void node_draw_hidden(const bContext &C, if (node.flag & SELECT) { UI_GetThemeColor4fv((node.flag & NODE_ACTIVE) ? TH_ACTIVE : TH_SELECT, color_outline); } - else if (bke::node_type_is_undefined(&node)) { + else if (bke::node_type_is_undefined(node)) { UI_GetThemeColor4fv(TH_REDALERT, color_outline); } else { @@ -4100,7 +4100,7 @@ static void frame_node_draw_label(TreeDrawContext &tree_draw_ctx, const float font_size = data->label_size / aspect; char label[MAX_NAME]; - bke::nodeLabel(&ntree, &node, label, sizeof(label)); + bke::nodeLabel(ntree, node, label, sizeof(label)); BLF_enable(fontid, BLF_ASPECT); BLF_aspect(fontid, aspect, aspect, 1.0f); @@ -4756,14 +4756,14 @@ static void node_draw_nodetree(const bContext &C, nodelink_batch_start(snode); for (const bNodeLink *link : ntree.all_links()) { - if (!bke::node_link_is_hidden(link) && !bke::node_link_is_selected(link)) { + if (!bke::node_link_is_hidden(*link) && !bke::node_link_is_selected(*link)) { node_draw_link(C, region.v2d, snode, *link, false); } } /* Draw selected node links after the unselected ones, so they are shown on top. */ for (const bNodeLink *link : ntree.all_links()) { - if (!bke::node_link_is_hidden(link) && bke::node_link_is_selected(link)) { + if (!bke::node_link_is_hidden(*link) && bke::node_link_is_selected(*link)) { node_draw_link(C, region.v2d, snode, *link, true); } } diff --git a/source/blender/editors/space_node/node_edit.cc b/source/blender/editors/space_node/node_edit.cc index 70134df6e7a..3665011020f 100644 --- a/source/blender/editors/space_node/node_edit.cc +++ b/source/blender/editors/space_node/node_edit.cc @@ -225,7 +225,7 @@ static void compo_freejob(void *cjv) bke::node_tree_local_merge(cj->bmain, cj->localtree, cj->ntree); } - bke::node_tree_free_tree(cj->localtree); + bke::node_tree_free_tree(*cj->localtree); MEM_freeN(cj->localtree); } @@ -588,11 +588,11 @@ void ED_node_shader_default(const bContext *C, ID *id) ma_default = BKE_material_default_surface(); } - ma->nodetree = blender::bke::node_tree_copy_tree(bmain, ma_default->nodetree); + ma->nodetree = blender::bke::node_tree_copy_tree(bmain, *ma_default->nodetree); ma->nodetree->owner_id = &ma->id; for (bNode *node_iter : ma->nodetree->all_nodes()) { STRNCPY_UTF8(node_iter->name, DATA_(node_iter->name)); - blender::bke::node_unique_name(ma->nodetree, node_iter); + blender::bke::node_unique_name(*ma->nodetree, *node_iter); } BKE_ntree_update_after_single_tree_change(*bmain, *ma->nodetree); @@ -606,32 +606,32 @@ void ED_node_shader_default(const bContext *C, ID *id) if (GS(id->name) == ID_WO) { World *world = (World *)id; - shader = blender::bke::node_add_static_node(nullptr, ntree, SH_NODE_BACKGROUND); - output = blender::bke::node_add_static_node(nullptr, ntree, SH_NODE_OUTPUT_WORLD); - blender::bke::node_add_link(ntree, - shader, - blender::bke::node_find_socket(shader, SOCK_OUT, "Background"), - output, - blender::bke::node_find_socket(output, SOCK_IN, "Surface")); + shader = blender::bke::node_add_static_node(nullptr, *ntree, SH_NODE_BACKGROUND); + output = blender::bke::node_add_static_node(nullptr, *ntree, SH_NODE_OUTPUT_WORLD); + blender::bke::node_add_link(*ntree, + *shader, + *blender::bke::node_find_socket(*shader, SOCK_OUT, "Background"), + *output, + *blender::bke::node_find_socket(*output, SOCK_IN, "Surface")); - bNodeSocket *color_sock = blender::bke::node_find_socket(shader, SOCK_IN, "Color"); + bNodeSocket *color_sock = blender::bke::node_find_socket(*shader, SOCK_IN, "Color"); copy_v3_v3(((bNodeSocketValueRGBA *)color_sock->default_value)->value, &world->horr); } else { - shader = blender::bke::node_add_static_node(nullptr, ntree, SH_NODE_EMISSION); - output = blender::bke::node_add_static_node(nullptr, ntree, SH_NODE_OUTPUT_LIGHT); - blender::bke::node_add_link(ntree, - shader, - blender::bke::node_find_socket(shader, SOCK_OUT, "Emission"), - output, - blender::bke::node_find_socket(output, SOCK_IN, "Surface")); + shader = blender::bke::node_add_static_node(nullptr, *ntree, SH_NODE_EMISSION); + output = blender::bke::node_add_static_node(nullptr, *ntree, SH_NODE_OUTPUT_LIGHT); + blender::bke::node_add_link(*ntree, + *shader, + *blender::bke::node_find_socket(*shader, SOCK_OUT, "Emission"), + *output, + *blender::bke::node_find_socket(*output, SOCK_IN, "Surface")); } shader->location[0] = 10.0f; shader->location[1] = 300.0f; output->location[0] = 300.0f; output->location[1] = 300.0f; - blender::bke::node_set_active(ntree, output); + blender::bke::node_set_active(*ntree, *output); BKE_ntree_update_after_single_tree_change(*bmain, *ntree); } else { @@ -653,19 +653,19 @@ void ED_node_composit_default(const bContext *C, Scene *sce) sce->nodetree = blender::bke::node_tree_add_tree_embedded( nullptr, &sce->id, "Compositing Nodetree", ntreeType_Composite->idname); - bNode *out = blender::bke::node_add_static_node(C, sce->nodetree, CMP_NODE_COMPOSITE); + bNode *out = blender::bke::node_add_static_node(C, *sce->nodetree, CMP_NODE_COMPOSITE); out->location[0] = 200.0f; out->location[1] = 200.0f; - bNode *in = blender::bke::node_add_static_node(C, sce->nodetree, CMP_NODE_R_LAYERS); + bNode *in = blender::bke::node_add_static_node(C, *sce->nodetree, CMP_NODE_R_LAYERS); in->location[0] = -200.0f; in->location[1] = 200.0f; - blender::bke::node_set_active(sce->nodetree, in); + blender::bke::node_set_active(*sce->nodetree, *in); /* Links from color to color. */ bNodeSocket *fromsock = (bNodeSocket *)in->outputs.first; bNodeSocket *tosock = (bNodeSocket *)out->inputs.first; - blender::bke::node_add_link(sce->nodetree, in, fromsock, out, tosock); + blender::bke::node_add_link(*sce->nodetree, *in, *fromsock, *out, *tosock); BKE_ntree_update_after_single_tree_change(*CTX_data_main(C), *sce->nodetree); } @@ -682,18 +682,18 @@ void ED_node_texture_default(const bContext *C, Tex *tex) tex->nodetree = blender::bke::node_tree_add_tree_embedded( nullptr, &tex->id, "Texture Nodetree", ntreeType_Texture->idname); - bNode *out = blender::bke::node_add_static_node(C, tex->nodetree, TEX_NODE_OUTPUT); + bNode *out = blender::bke::node_add_static_node(C, *tex->nodetree, TEX_NODE_OUTPUT); out->location[0] = 300.0f; out->location[1] = 300.0f; - bNode *in = blender::bke::node_add_static_node(C, tex->nodetree, TEX_NODE_CHECKER); + bNode *in = blender::bke::node_add_static_node(C, *tex->nodetree, TEX_NODE_CHECKER); in->location[0] = 10.0f; in->location[1] = 300.0f; - blender::bke::node_set_active(tex->nodetree, in); + blender::bke::node_set_active(*tex->nodetree, *in); bNodeSocket *fromsock = (bNodeSocket *)in->outputs.first; bNodeSocket *tosock = (bNodeSocket *)out->inputs.first; - blender::bke::node_add_link(tex->nodetree, in, fromsock, out, tosock); + blender::bke::node_add_link(*tex->nodetree, *in, *fromsock, *out, *tosock); BKE_ntree_update_after_single_tree_change(*CTX_data_main(C), *tex->nodetree); } @@ -751,7 +751,7 @@ void ED_node_set_active( *r_active_texture_changed = false; } - blender::bke::node_set_active(ntree, node); + blender::bke::node_set_active(*ntree, *node); if (node->type_legacy == NODE_GROUP) { return; } @@ -798,7 +798,7 @@ void ED_node_set_active( /* If active texture changed, free GLSL materials. */ LISTBASE_FOREACH (Material *, ma, &bmain->materials) { if (ma->nodetree && ma->use_nodes && - blender::bke::node_tree_contains_tree(ma->nodetree, ntree)) + blender::bke::node_tree_contains_tree(*ma->nodetree, *ntree)) { GPU_material_free(&ma->gpumaterial); @@ -819,7 +819,7 @@ void ED_node_set_active( LISTBASE_FOREACH (World *, wo, &bmain->worlds) { if (wo->nodetree && wo->use_nodes && - blender::bke::node_tree_contains_tree(wo->nodetree, ntree)) + blender::bke::node_tree_contains_tree(*wo->nodetree, *ntree)) { GPU_material_free(&wo->gpumaterial); } @@ -974,7 +974,7 @@ static void node_resize_exit(bContext *C, wmOperator *op, bool cancel) /* Restore old data on cancel. */ if (cancel) { SpaceNode *snode = CTX_wm_space_node(C); - bNode *node = bke::node_get_active(snode->edittree); + bNode *node = bke::node_get_active(*snode->edittree); NodeSizeWidget *nsw = (NodeSizeWidget *)op->customdata; node->location[0] = nsw->oldlocx; @@ -1033,7 +1033,7 @@ static int node_resize_modal(bContext *C, wmOperator *op, const wmEvent *event) { SpaceNode *snode = CTX_wm_space_node(C); ARegion *region = CTX_wm_region(C); - bNode *node = bke::node_get_active(snode->edittree); + bNode *node = bke::node_get_active(*snode->edittree); NodeSizeWidget *nsw = (NodeSizeWidget *)op->customdata; if (event->type == EVT_MODAL_MAP) { @@ -1132,7 +1132,7 @@ static int node_resize_invoke(bContext *C, wmOperator *op, const wmEvent *event) { SpaceNode *snode = CTX_wm_space_node(C); ARegion *region = CTX_wm_region(C); - const bNode *node = bke::node_get_active(snode->edittree); + const bNode *node = bke::node_get_active(*snode->edittree); if (node == nullptr) { return OPERATOR_CANCELLED | OPERATOR_PASS_THROUGH; @@ -1370,7 +1370,7 @@ float node_link_dim_factor(const View2D &v2d, const bNodeLink &link) bool node_link_is_hidden_or_dimmed(const View2D &v2d, const bNodeLink &link) { - return bke::node_link_is_hidden(&link) || node_link_dim_factor(v2d, link) < 0.5f; + return bke::node_link_is_hidden(link) || node_link_dim_factor(v2d, link) < 0.5f; } /** \} */ @@ -1398,8 +1398,8 @@ static void node_duplicate_reparent_recursive(bNodeTree *ntree, } /* Reparent node copy to parent copy. */ if (parent) { - bke::node_detach_node(ntree, node_map.lookup(node)); - bke::node_attach_node(ntree, node_map.lookup(node), node_map.lookup(parent)); + bke::node_detach_node(*ntree, *node_map.lookup(node)); + bke::node_attach_node(*ntree, *node_map.lookup(node), *node_map.lookup(parent)); } } @@ -1505,7 +1505,7 @@ static int node_duplicate_exec(bContext *C, wmOperator *op) } for (bNode *node : node_map.values()) { - blender::bke::node_declaration_ensure(ntree, node); + blender::bke::node_declaration_ensure(*ntree, *node); } ntree->ensure_topology_cache(); @@ -1538,9 +1538,9 @@ static int node_duplicate_exec(bContext *C, wmOperator *op) bNode *src_node = item.key; bNode *dst_node = item.value; - bke::node_set_selected(src_node, false); + bke::node_set_selected(*src_node, false); src_node->flag &= ~(NODE_ACTIVE | NODE_ACTIVE_TEXTURE); - bke::node_set_selected(dst_node, true); + bke::node_set_selected(*dst_node, true); } tree_draw_order_update(*snode->edittree); @@ -1985,7 +1985,7 @@ static int node_delete_exec(bContext *C, wmOperator * /*op*/) LISTBASE_FOREACH_MUTABLE (bNode *, node, &snode->edittree->nodes) { if (node->flag & SELECT) { - bke::node_remove_node(bmain, snode->edittree, node, true); + bke::node_remove_node(bmain, *snode->edittree, *node, true); } } @@ -2027,8 +2027,8 @@ static int node_delete_reconnect_exec(bContext *C, wmOperator * /*op*/) LISTBASE_FOREACH_MUTABLE (bNode *, node, &snode->edittree->nodes) { if (node->flag & SELECT) { - blender::bke::node_internal_relink(snode->edittree, node); - bke::node_remove_node(bmain, snode->edittree, node, true); + blender::bke::node_internal_relink(*snode->edittree, *node); + bke::node_remove_node(bmain, *snode->edittree, *node, true); /* Since this node might have been animated, and that animation data been * deleted, a notifier call is necessary to redraw any animation editor. */ @@ -2077,7 +2077,7 @@ static int node_output_file_add_socket_exec(bContext *C, wmOperator *op) } else if (snode && snode->edittree) { ntree = snode->edittree; - node = bke::node_get_active(snode->edittree); + node = bke::node_get_active(*snode->edittree); } if (!node || node->type_legacy != CMP_NODE_OUTPUT_FILE) { @@ -2129,7 +2129,7 @@ static int node_output_file_remove_active_socket_exec(bContext *C, wmOperator * } else if (snode && snode->edittree) { ntree = snode->edittree; - node = bke::node_get_active(snode->edittree); + node = bke::node_get_active(*snode->edittree); } if (!node || node->type_legacy != CMP_NODE_OUTPUT_FILE) { @@ -2176,7 +2176,7 @@ static int node_output_file_move_active_socket_exec(bContext *C, wmOperator *op) node = (bNode *)ptr.data; } else if (snode && snode->edittree) { - node = bke::node_get_active(snode->edittree); + node = bke::node_get_active(*snode->edittree); } if (!node || node->type_legacy != CMP_NODE_OUTPUT_FILE) { @@ -2248,7 +2248,7 @@ static int node_copy_color_exec(bContext *C, wmOperator * /*op*/) SpaceNode &snode = *CTX_wm_space_node(C); bNodeTree &ntree = *snode.edittree; - bNode *active_node = bke::node_get_active(&ntree); + bNode *active_node = bke::node_get_active(ntree); if (!active_node) { return OPERATOR_CANCELLED; } @@ -2306,7 +2306,7 @@ static bool node_shader_script_update_poll(bContext *C) bNode *node = (bNode *)CTX_data_pointer_get_type(C, "node", &RNA_ShaderNodeScript).data; if (!node && snode && snode->edittree) { - node = bke::node_get_active(snode->edittree); + node = bke::node_get_active(*snode->edittree); } if (node && node->type_legacy == SH_NODE_SCRIPT) { @@ -2377,7 +2377,7 @@ static int node_shader_script_update_exec(bContext *C, wmOperator *op) } else if (snode && snode->edittree) { ntree_base = snode->edittree; - node = bke::node_get_active(snode->edittree); + node = bke::node_get_active(*snode->edittree); } if (node) { @@ -2575,7 +2575,7 @@ static int node_cryptomatte_add_socket_exec(bContext *C, wmOperator * /*op*/) } else if (snode && snode->edittree) { ntree = snode->edittree; - node = bke::node_get_active(snode->edittree); + node = bke::node_get_active(*snode->edittree); } if (!node || node->type_legacy != CMP_NODE_CRYPTOMATTE_LEGACY) { @@ -2623,7 +2623,7 @@ static int node_cryptomatte_remove_socket_exec(bContext *C, wmOperator * /*op*/) } else if (snode && snode->edittree) { ntree = snode->edittree; - node = bke::node_get_active(snode->edittree); + node = bke::node_get_active(*snode->edittree); } if (!node || node->type_legacy != CMP_NODE_CRYPTOMATTE_LEGACY) { diff --git a/source/blender/editors/space_node/node_gizmo.cc b/source/blender/editors/space_node/node_gizmo.cc index be58a9abba2..893804a847e 100644 --- a/source/blender/editors/space_node/node_gizmo.cc +++ b/source/blender/editors/space_node/node_gizmo.cc @@ -103,7 +103,7 @@ static bool WIDGETGROUP_node_transform_poll(const bContext *C, wmGizmoGroupType } if (snode && snode->edittree && snode->edittree->type == NTREE_COMPOSIT) { - bNode *node = bke::node_get_active(snode->edittree); + bNode *node = bke::node_get_active(*snode->edittree); if (node && ELEM(node->type_legacy, CMP_NODE_VIEWER)) { return true; @@ -300,7 +300,7 @@ static bool WIDGETGROUP_node_crop_poll(const bContext *C, wmGizmoGroupType * /*g } if (snode && snode->edittree && snode->edittree->type == NTREE_COMPOSIT) { - bNode *node = bke::node_get_active(snode->edittree); + bNode *node = bke::node_get_active(*snode->edittree); if (node && ELEM(node->type_legacy, CMP_NODE_CROP)) { /* ignore 'use_crop_size', we can't usefully edit the crop in this case. */ @@ -357,7 +357,7 @@ static void WIDGETGROUP_node_crop_refresh(const bContext *C, wmGizmoGroup *gzgro WM_gizmo_set_flag(gz, WM_GIZMO_HIDDEN, false); SpaceNode *snode = CTX_wm_space_node(C); - bNode *node = bke::node_get_active(snode->edittree); + bNode *node = bke::node_get_active(*snode->edittree); crop_group->update_data.context = (bContext *)C; crop_group->update_data.ptr = RNA_pointer_create_discrete( @@ -417,7 +417,7 @@ static bool WIDGETGROUP_node_sbeam_poll(const bContext *C, wmGizmoGroupType * /* } if (snode && snode->edittree && snode->edittree->type == NTREE_COMPOSIT) { - bNode *node = bke::node_get_active(snode->edittree); + bNode *node = bke::node_get_active(*snode->edittree); if (node && ELEM(node->type_legacy, CMP_NODE_SUNBEAMS)) { return true; @@ -470,7 +470,7 @@ static void WIDGETGROUP_node_sbeam_refresh(const bContext *C, wmGizmoGroup *gzgr copy_v2_v2(sbeam_group->state.offset, ima->runtime.backdrop_offset); SpaceNode *snode = CTX_wm_space_node(C); - bNode *node = bke::node_get_active(snode->edittree); + bNode *node = bke::node_get_active(*snode->edittree); /* Need to set property here for undo. TODO: would prefer to do this in _init. */ PointerRNA nodeptr = RNA_pointer_create_discrete( @@ -524,7 +524,7 @@ static bool WIDGETGROUP_node_corner_pin_poll(const bContext *C, wmGizmoGroupType } if (snode && snode->edittree && snode->edittree->type == NTREE_COMPOSIT) { - bNode *node = bke::node_get_active(snode->edittree); + bNode *node = bke::node_get_active(*snode->edittree); if (node && ELEM(node->type_legacy, CMP_NODE_CORNERPIN)) { return true; @@ -584,7 +584,7 @@ static void WIDGETGROUP_node_corner_pin_refresh(const bContext *C, wmGizmoGroup copy_v2_v2(cpin_group->state.offset, ima->runtime.backdrop_offset); SpaceNode *snode = CTX_wm_space_node(C); - bNode *node = bke::node_get_active(snode->edittree); + bNode *node = bke::node_get_active(*snode->edittree); /* need to set property here for undo. TODO: would prefer to do this in _init. */ int i = 0; diff --git a/source/blender/editors/space_node/node_group.cc b/source/blender/editors/space_node/node_group.cc index 00869a3f7c6..92806de3434 100644 --- a/source/blender/editors/space_node/node_group.cc +++ b/source/blender/editors/space_node/node_group.cc @@ -135,7 +135,7 @@ StringRef node_group_idname(bContext *C) static bNode *node_group_get_active(bContext *C, const StringRef node_idname) { SpaceNode *snode = CTX_wm_space_node(C); - bNode *node = bke::node_get_active(snode->edittree); + bNode *node = bke::node_get_active(*snode->edittree); if (node && node->idname == node_idname) { return node; @@ -281,7 +281,7 @@ static void node_group_ungroup(Main *bmain, bNodeTree *ntree, bNode *gnode) * - `ngroup` (i.e. the source NodeTree) is left unscathed. * - Temp copy. do change ID user-count for the copies. */ - bNodeTree *wgroup = bke::node_tree_copy_tree(bmain, ngroup); + bNodeTree *wgroup = bke::node_tree_copy_tree(bmain, *ngroup); /* Add the nodes into the `ntree`. */ Vector new_nodes; @@ -308,8 +308,8 @@ static void node_group_ungroup(Main *bmain, bNodeTree *ntree, bNode *gnode) BLI_remlink(&wgroup->nodes, node); BLI_addtail(&ntree->nodes, node); const int32_t old_identifier = node->identifier; - bke::node_unique_id(ntree, node); - bke::node_unique_name(ntree, node); + bke::node_unique_id(*ntree, *node); + bke::node_unique_name(*ntree, *node); node_identifier_map.add(old_identifier, node->identifier); BKE_ntree_update_tag_node_new(ntree, node); @@ -388,7 +388,7 @@ static void node_group_ungroup(Main *bmain, bNodeTree *ntree, bNode *gnode) { if (tlink->tonode == gnode && STREQ(tlink->tosock->identifier, identifier)) { bke::node_add_link( - ntree, tlink->fromnode, tlink->fromsock, link->tonode, link->tosock); + *ntree, *tlink->fromnode, *tlink->fromsock, *link->tonode, *link->tosock); num_external_links++; } } @@ -427,7 +427,7 @@ static void node_group_ungroup(Main *bmain, bNodeTree *ntree, bNode *gnode) if (tlink->tonode->is_group_output() && (tlink->tonode->flag & NODE_DO_OUTPUT)) { if (STREQ(tlink->tosock->identifier, identifier)) { bke::node_add_link( - ntree, tlink->fromnode, tlink->fromsock, link->tonode, link->tosock); + *ntree, *tlink->fromnode, *tlink->fromsock, *link->tonode, *link->tosock); num_internal_links++; } } @@ -449,13 +449,13 @@ static void node_group_ungroup(Main *bmain, bNodeTree *ntree, bNode *gnode) } for (bNode *node : nodes_delayed_free) { - bke::node_remove_node(bmain, ntree, node, false); + bke::node_remove_node(bmain, *ntree, *node, false); } update_nested_node_refs_after_ungroup(*ntree, *ngroup, *gnode, node_identifier_map); /* delete the group instance and dereference group tree */ - bke::node_remove_node(bmain, ntree, gnode, true); + bke::node_remove_node(bmain, *ntree, *gnode, true); } static int node_group_ungroup_exec(bContext *C, wmOperator * /*op*/) @@ -537,8 +537,8 @@ static bool node_group_separate_selected( BLI_remlink(&ngroup.nodes, newnode); BLI_addtail(&ntree.nodes, newnode); const int32_t old_identifier = node->identifier; - bke::node_unique_id(&ntree, newnode); - bke::node_unique_name(&ntree, newnode); + bke::node_unique_id(ntree, *newnode); + bke::node_unique_name(ntree, *newnode); node_identifier_map.add(old_identifier, newnode->identifier); } node_map.add_new(node, newnode); @@ -554,7 +554,7 @@ static bool node_group_separate_selected( /* ensure valid parent pointers, detach if parent stays inside the group */ if (newnode->parent && !(newnode->parent->flag & NODE_SELECT)) { - bke::node_detach_node(&ngroup, newnode); + bke::node_detach_node(ngroup, *newnode); } if (!newnode->parent) { @@ -563,7 +563,7 @@ static bool node_group_separate_selected( } } if (!make_copy) { - bke::node_rebuild_id_vector(&ngroup); + bke::node_rebuild_id_vector(ngroup); } /* add internal links to the ntree */ @@ -574,11 +574,11 @@ static bool node_group_separate_selected( if (make_copy) { /* make a copy of internal links */ if (fromselect && toselect) { - bke::node_add_link(&ntree, - node_map.lookup(link->fromnode), - socket_map.lookup(link->fromsock), - node_map.lookup(link->tonode), - socket_map.lookup(link->tosock)); + bke::node_add_link(ntree, + *node_map.lookup(link->fromnode), + *socket_map.lookup(link->fromsock), + *node_map.lookup(link->tonode), + *socket_map.lookup(link->tosock)); } } else { @@ -588,7 +588,7 @@ static bool node_group_separate_selected( BLI_addtail(&ntree.links, link); } else if (fromselect || toselect) { - bke::node_remove_link(&ngroup, link); + bke::node_remove_link(&ngroup, *link); } } } @@ -596,7 +596,7 @@ static bool node_group_separate_selected( remap_pairing(ntree, nodes_to_move, node_identifier_map); for (bNode *node : node_map.values()) { - bke::node_declaration_ensure(&ntree, node); + bke::node_declaration_ensure(ntree, *node); } /* and copy across the animation, @@ -731,7 +731,7 @@ static bool node_group_make_test_selected(bNodeTree &ntree, /* make a local pseudo node tree to pass to the node poll functions */ bNodeTree *ngroup = bke::node_tree_add_tree(nullptr, "Pseudo Node Group", ntree_idname); BLI_SCOPED_DEFER([&]() { - bke::node_tree_free_tree(ngroup); + bke::node_tree_free_tree(*ngroup); MEM_freeN(ngroup); }); @@ -954,13 +954,13 @@ static void node_group_make_insert_selected(const bContext &C, if (bNode *node = group.group_output_node()) { return node; } - bNode *output_node = bke::node_add_static_node(&C, &group, NODE_GROUP_OUTPUT); + bNode *output_node = bke::node_add_static_node(&C, group, NODE_GROUP_OUTPUT); output_node->location[0] = real_max[0] - center[0] + 50.0f; return output_node; }(); /* Create new group input node for easier organization of the new nodes inside the group. */ - bNode *input_node = bke::node_add_static_node(&C, &group, NODE_GROUP_INPUT); + bNode *input_node = bke::node_add_static_node(&C, group, NODE_GROUP_INPUT); input_node->location[0] = real_min[0] - center[0] - 200.0f; struct InputSocketInfo { @@ -1003,7 +1003,7 @@ static void node_group_make_insert_selected(const bContext &C, } for (bNodeLink *link : output_socket->directly_linked_links()) { - if (bke::node_link_is_hidden(link)) { + if (bke::node_link_is_hidden(*link)) { links_to_remove.add(link); continue; } @@ -1044,7 +1044,7 @@ static void node_group_make_insert_selected(const bContext &C, } for (bNodeLink *link : input_socket->directly_linked_links()) { - if (bke::node_link_is_hidden(link)) { + if (bke::node_link_is_hidden(*link)) { links_to_remove.add(link); continue; } @@ -1076,12 +1076,12 @@ static void node_group_make_insert_selected(const bContext &C, /* Un-parent nodes when only the parent or child moves into the group. */ for (bNode *node : ntree.all_nodes()) { if (node->parent && nodes_to_move.contains(node->parent) && !nodes_to_move.contains(node)) { - bke::node_detach_node(&ntree, node); + bke::node_detach_node(ntree, *node); } } for (bNode *node : nodes_to_move) { if (node->parent && !nodes_to_move.contains(node->parent)) { - bke::node_detach_node(&ntree, node); + bke::node_detach_node(ntree, *node); } } @@ -1107,15 +1107,15 @@ static void node_group_make_insert_selected(const bContext &C, BLI_remlink(&ntree.nodes, node); BLI_addtail(&group.nodes, node); - bke::node_unique_id(&group, node); - bke::node_unique_name(&group, node); + bke::node_unique_id(group, *node); + bke::node_unique_name(group, *node); node_identifier_map.add(old_identifier, node->identifier); BKE_ntree_update_tag_node_removed(&ntree); BKE_ntree_update_tag_node_new(&group, node); } - bke::node_rebuild_id_vector(&ntree); + bke::node_rebuild_id_vector(ntree); /* Update input and output node first, since the group node declaration can depend on them. */ nodes::update_node_declaration_and_sockets(group, *input_node); @@ -1137,7 +1137,7 @@ static void node_group_make_insert_selected(const bContext &C, } for (bNodeLink *link : links_to_remove) { - bke::node_remove_link(&ntree, link); + bke::node_remove_link(&ntree, *link); } /* Handle links to the new group inputs. */ @@ -1161,7 +1161,8 @@ static void node_group_make_insert_selected(const bContext &C, /* Create a new link inside of the group. */ const StringRefNull io_identifier = info.interface_socket->identifier; bNodeSocket *output_sock = node_group_output_find_socket(output_node, io_identifier); - bke::node_add_link(&group, info.link->fromnode, info.link->fromsock, output_node, output_sock); + bke::node_add_link( + group, *info.link->fromnode, *info.link->fromsock, *output_node, *output_sock); } /* Handle new links inside the group. */ @@ -1169,11 +1170,11 @@ static void node_group_make_insert_selected(const bContext &C, const StringRefNull io_identifier = info.interface_socket->identifier; if (info.socket->in_out == SOCK_IN) { bNodeSocket *input_socket = node_group_input_find_socket(input_node, io_identifier); - bke::node_add_link(&group, input_node, input_socket, info.node, info.socket); + bke::node_add_link(group, *input_node, *input_socket, *info.node, *info.socket); } else { bNodeSocket *output_socket = node_group_output_find_socket(output_node, io_identifier); - bke::node_add_link(&group, info.node, info.socket, output_node, output_socket); + bke::node_add_link(group, *info.node, *info.socket, *output_node, *output_socket); } } @@ -1188,7 +1189,7 @@ static void node_group_make_insert_selected(const bContext &C, for (const auto item : input_links.items()) { const StringRefNull interface_identifier = item.value.interface_socket->identifier; bNodeSocket *group_node_socket = node_group_find_input_socket(gnode, interface_identifier); - bke::node_add_link(&ntree, item.value.from_node, item.key, gnode, group_node_socket); + bke::node_add_link(ntree, *item.value.from_node, *item.key, *gnode, *group_node_socket); } /* Add new links to outputs outside the group. */ @@ -1220,7 +1221,7 @@ static bNode *node_group_make_from_nodes(const bContext &C, BKE_id_move_to_same_lib(*bmain, ngroup->id, ntree.id); /* make group node */ - bNode *gnode = bke::node_add_node(&C, &ntree, ntype); + bNode *gnode = bke::node_add_node(&C, ntree, ntype); gnode->id = (ID *)ngroup; gnode->location[0] = 0.5f * (min[0] + max[0]); @@ -1251,7 +1252,7 @@ static int node_group_make_exec(bContext *C, wmOperator *op) if (gnode) { bNodeTree *ngroup = (bNodeTree *)gnode->id; - bke::node_set_active(&ntree, gnode); + bke::node_set_active(ntree, *gnode); if (ngroup) { ED_node_tree_push(&snode, ngroup, gnode); } @@ -1307,7 +1308,7 @@ static int node_group_insert_exec(bContext *C, wmOperator *op) if (!group->is_group() || group->id == nullptr) { continue; } - if (bke::node_tree_contains_tree(reinterpret_cast(group->id), ngroup)) { + if (bke::node_tree_contains_tree(*reinterpret_cast(group->id), *ngroup)) { BKE_reportf( op->reports, RPT_WARNING, "Cannot insert group '%s' in '%s'", group->name, gnode->name); return OPERATOR_CANCELLED; @@ -1320,7 +1321,7 @@ static int node_group_insert_exec(bContext *C, wmOperator *op) node_group_make_insert_selected(*C, *ntree, gnode, nodes_to_group); - bke::node_set_active(ntree, gnode); + bke::node_set_active(*ntree, *gnode); ED_node_tree_push(snode, ngroup, gnode); return OPERATOR_FINISHED; @@ -1383,7 +1384,7 @@ static int node_default_group_width_set_exec(bContext *C, wmOperator * /*op*/) return OPERATOR_CANCELLED; } parent_ntree->ensure_topology_cache(); - bNode *parent_node = bke::node_find_node_by_name(parent_ntree, last_path_item->node_name); + bNode *parent_node = bke::node_find_node_by_name(*parent_ntree, last_path_item->node_name); if (!parent_node) { return OPERATOR_CANCELLED; } diff --git a/source/blender/editors/space_node/node_relationships.cc b/source/blender/editors/space_node/node_relationships.cc index 1e198b0ff29..28a69d2fc57 100644 --- a/source/blender/editors/space_node/node_relationships.cc +++ b/source/blender/editors/space_node/node_relationships.cc @@ -94,7 +94,7 @@ static void pick_link(bNodeLinkDrag &nldrag, bNodeLink link = create_drag_link(*link_to_pick.fromnode, *link_to_pick.fromsock); nldrag.links.append(link); - bke::node_remove_link(snode.edittree, &link_to_pick); + bke::node_remove_link(snode.edittree, link_to_pick); snode.edittree->ensure_topology_cache(); BLI_assert(nldrag.last_node_hovered_while_dragging_a_link != nullptr); update_multi_input_indices_for_removed_links(*nldrag.last_node_hovered_while_dragging_a_link); @@ -268,10 +268,10 @@ static bool snode_autoconnect_input(SpaceNode &snode, bNodeTree *ntree = snode.edittree; if (replace) { - bke::node_remove_socket_links(ntree, sock_to); + bke::node_remove_socket_links(*ntree, *sock_to); } - bke::node_add_link(ntree, node_fr, sock_fr, node_to, sock_to); + bke::node_add_link(*ntree, *node_fr, *sock_fr, *node_to, *sock_to); return true; } @@ -488,7 +488,7 @@ static void remove_links_to_unavailable_viewer_sockets(bNodeTree &btree, bNode & LISTBASE_FOREACH_MUTABLE (bNodeLink *, link, &btree.links) { if (link->tonode == &viewer_node) { if (link->tosock->flag & SOCK_UNAVAIL) { - bke::node_remove_link(&btree, link); + bke::node_remove_link(&btree, *link); } } } @@ -788,8 +788,8 @@ static int view_socket(const bContext &C, } } if (viewer_link == nullptr) { - viewer_link = bke::node_add_link( - &btree, &bnode_to_view, &bsocket_to_view, viewer_node, viewer_bsocket); + viewer_link = &bke::node_add_link( + btree, bnode_to_view, bsocket_to_view, *viewer_node, *viewer_bsocket); } else { viewer_link->fromnode = &bnode_to_view; @@ -829,7 +829,7 @@ static int node_link_viewer(const bContext &C, bNode &bnode_to_view, bNodeSocket static int node_active_link_viewer_exec(bContext *C, wmOperator * /*op*/) { SpaceNode &snode = *CTX_wm_space_node(C); - bNode *node = bke::node_get_active(snode.edittree); + bNode *node = bke::node_get_active(*snode.edittree); if (!node) { return OPERATOR_CANCELLED; @@ -1014,7 +1014,7 @@ static bNodeSocket *node_find_linkable_socket(const bNodeTree &ntree, const bool sockets_are_compatible = socket->typeinfo == socket_to_match->typeinfo; if (sockets_are_compatible) { const int link_count = node_socket_count_links(ntree, *socket); - const bool socket_has_capacity = link_count < bke::node_socket_link_limit(socket); + const bool socket_has_capacity = link_count < bke::node_socket_link_limit(*socket); if (socket_has_capacity) { /* Found a valid free socket we can swap to. */ return socket; @@ -1044,7 +1044,7 @@ static void displace_links(bNodeTree *ntree, const bNode *node, bNodeLink *inser bNodeLink *displaced_link = linked_socket->directly_linked_links().first(); if (!replacement_socket) { - bke::node_remove_link(ntree, displaced_link); + bke::node_remove_link(ntree, *displaced_link); return; } @@ -1054,7 +1054,7 @@ static void displace_links(bNodeTree *ntree, const bNode *node, bNodeLink *inser /* Check for duplicate links when linking to multi input sockets. */ for (bNodeLink *existing_link : replacement_socket->runtime->directly_linked_links) { if (existing_link->fromsock == displaced_link->fromsock) { - bke::node_remove_link(ntree, displaced_link); + bke::node_remove_link(ntree, *displaced_link); return; } } @@ -1073,7 +1073,7 @@ static void displace_links(bNodeTree *ntree, const bNode *node, bNodeLink *inser BKE_ntree_update_tag_link_changed(ntree); } else { - bke::node_remove_link(ntree, link); + bke::node_remove_link(ntree, *link); BKE_ntree_update_tag_link_removed(ntree); } } @@ -1107,7 +1107,7 @@ static void node_swap_links(bNodeLinkDrag &nldrag, bNodeTree &ntree) } if (link->fromnode == start_node) { /* Don't link a node to itself. */ - bke::node_remove_link(&ntree, link); + bke::node_remove_link(&ntree, *link); continue; } @@ -1122,7 +1122,7 @@ static void node_swap_links(bNodeLinkDrag &nldrag, bNodeTree &ntree) } if (link->tonode == start_node) { /* Don't link a node to itself. */ - bke::node_remove_link(&ntree, link); + bke::node_remove_link(&ntree, *link); continue; } link->fromsock = start_socket; @@ -1138,7 +1138,7 @@ static void node_remove_existing_links_if_needed(bNodeLinkDrag &nldrag, bNodeTre bNodeSocket &linked_socket = *nldrag.hovered_socket; int link_count = node_socket_count_links(ntree, linked_socket); - const int link_limit = bke::node_socket_link_limit(&linked_socket); + const int link_limit = bke::node_socket_link_limit(linked_socket); Set links_to_remove; ntree.ensure_topology_cache(); @@ -1175,7 +1175,7 @@ static void node_remove_existing_links_if_needed(bNodeLinkDrag &nldrag, bNodeTre } for (bNodeLink *link : links_to_remove) { - bke::node_remove_link(&ntree, link); + bke::node_remove_link(&ntree, *link); } } @@ -1437,7 +1437,7 @@ static void remove_unavailable_links(bNodeTree &tree, bNodeSocket &socket) Vector links = socket.directly_linked_links(); for (bNodeLink *link : links) { if (!link->is_available()) { - bke::node_remove_link(&tree, link); + bke::node_remove_link(&tree, *link); } } } @@ -1455,8 +1455,8 @@ static std::unique_ptr node_link_init(ARegion ®ion, std::unique_ptr nldrag = std::make_unique(); nldrag->start_node = &node; nldrag->start_socket = sock; - nldrag->start_link_count = bke::node_count_socket_links(snode.edittree, sock); - int link_limit = bke::node_socket_link_limit(sock); + nldrag->start_link_count = bke::node_count_socket_links(*snode.edittree, *sock); + int link_limit = bke::node_socket_link_limit(*sock); if (nldrag->start_link_count > 0 && (nldrag->start_link_count >= link_limit || detach)) { /* Dragged links are fixed on input side. */ nldrag->in_out = SOCK_IN; @@ -1468,7 +1468,7 @@ static std::unique_ptr node_link_init(ARegion ®ion, oplink.flag |= NODE_LINK_VALID; nldrag->links.append(oplink); - bke::node_remove_link(snode.edittree, link); + bke::node_remove_link(snode.edittree, *link); } } } @@ -1489,7 +1489,7 @@ static std::unique_ptr node_link_init(ARegion ®ion, nldrag->start_node = &node; nldrag->start_socket = sock; - nldrag->start_link_count = bke::node_count_socket_links(snode.edittree, sock); + nldrag->start_link_count = bke::node_count_socket_links(*snode.edittree, *sock); if (nldrag->start_link_count > 0) { /* Dragged links are fixed on output side. */ nldrag->in_out = SOCK_OUT; @@ -1507,7 +1507,7 @@ static std::unique_ptr node_link_init(ARegion ®ion, oplink.flag |= NODE_LINK_VALID; nldrag->links.append(oplink); - bke::node_remove_link(snode.edittree, link_to_pick); + bke::node_remove_link(snode.edittree, *link_to_pick); /* Send changed event to original link->tonode. */ BKE_ntree_update_tag_node_property(snode.edittree, &node); @@ -1699,7 +1699,7 @@ static int cut_links_exec(bContext *C, wmOperator *op) Set affected_nodes; for (bNodeLink *link : links_to_remove) { bNode *to_node = link->tonode; - bke::node_remove_link(snode.edittree, link); + bke::node_remove_link(snode.edittree, *link); affected_nodes.add(to_node); } @@ -1803,7 +1803,7 @@ static int mute_links_exec(bContext *C, wmOperator *op) bke::node_tree_runtime::AllowUsingOutdatedInfo allow_outdated_info{ntree}; for (bNodeLink *link : affected_links) { - bke::node_link_set_mute(&ntree, link, !(link->flag & NODE_LINK_MUTED)); + bke::node_link_set_mute(ntree, *link, !(link->flag & NODE_LINK_MUTED)); const bool muted = link->flag & NODE_LINK_MUTED; /* Propagate mute status downstream past reroute nodes. */ @@ -1812,7 +1812,7 @@ static int mute_links_exec(bContext *C, wmOperator *op) links.push_multiple(link->tonode->output_socket(0).directly_linked_links()); while (!links.is_empty()) { bNodeLink *link = links.pop(); - bke::node_link_set_mute(&ntree, link, muted); + bke::node_link_set_mute(ntree, *link, muted); if (!link->tonode->is_reroute()) { continue; } @@ -1826,7 +1826,7 @@ static int mute_links_exec(bContext *C, wmOperator *op) links.push_multiple(link->fromnode->input_socket(0).directly_linked_links()); while (!links.is_empty()) { bNodeLink *link = links.pop(); - bke::node_link_set_mute(&ntree, link, muted); + bke::node_link_set_mute(ntree, *link, muted); if (!link->fromnode->is_reroute()) { continue; } @@ -1882,7 +1882,7 @@ static int detach_links_exec(bContext *C, wmOperator * /*op*/) for (bNode *node : ntree.all_nodes()) { if (node->flag & SELECT) { - bke::node_internal_relink(&ntree, node); + bke::node_internal_relink(ntree, *node); } } @@ -1914,7 +1914,7 @@ static int node_parent_set_exec(bContext *C, wmOperator * /*op*/) { SpaceNode &snode = *CTX_wm_space_node(C); bNodeTree &ntree = *snode.edittree; - bNode *frame = bke::node_get_active(&ntree); + bNode *frame = bke::node_get_active(ntree); if (!frame || !frame->is_frame()) { return OPERATOR_CANCELLED; } @@ -1924,8 +1924,8 @@ static int node_parent_set_exec(bContext *C, wmOperator * /*op*/) continue; } if (node->flag & NODE_SELECT) { - bke::node_detach_node(&ntree, node); - bke::node_attach_node(&ntree, node, frame); + bke::node_detach_node(ntree, *node); + bke::node_attach_node(ntree, *node, *frame); } } @@ -1984,13 +1984,13 @@ static void node_join_attach_recursive(bNodeTree &ntree, } else if (selected_nodes.contains(node)) { /* if parent is not an descendant of the frame, reattach the node */ - bke::node_detach_node(&ntree, node); - bke::node_attach_node(&ntree, node, frame); + bke::node_detach_node(ntree, *node); + bke::node_attach_node(ntree, *node, *frame); join_states[node->index()].descendent = true; } } else if (selected_nodes.contains(node)) { - bke::node_attach_node(&ntree, node, frame); + bke::node_attach_node(ntree, *node, *frame); join_states[node->index()].descendent = true; } } @@ -2042,8 +2042,8 @@ static int node_join_exec(bContext *C, wmOperator * /*op*/) const VectorSet selected_nodes = get_selected_nodes(ntree); - bNode *frame_node = bke::node_add_static_node(C, &ntree, NODE_FRAME); - bke::node_set_active(&ntree, frame_node); + bNode *frame_node = bke::node_add_static_node(C, ntree, NODE_FRAME); + bke::node_set_active(ntree, *frame_node); frame_node->parent = const_cast(find_common_parent_node(selected_nodes.as_span())); ntree.ensure_topology_cache(); @@ -2122,12 +2122,12 @@ static int node_attach_invoke(bContext *C, wmOperator * /*op*/, const wmEvent *e } /* Disallow moving a parent into its child. */ - if (node->is_frame() && bke::node_is_parent_and_child(node, frame)) { + if (node->is_frame() && bke::node_is_parent_and_child(*node, *frame)) { continue; } if (node->parent == nullptr) { - bke::node_attach_node(&ntree, node, frame); + bke::node_attach_node(ntree, *node, *frame); changed = true; continue; } @@ -2137,13 +2137,13 @@ static int node_attach_invoke(bContext *C, wmOperator * /*op*/, const wmEvent *e } /* Attach nodes which share parent with the frame. */ - const bool share_parent = bke::node_is_parent_and_child(node->parent, frame); + const bool share_parent = bke::node_is_parent_and_child(*node->parent, *frame); if (!share_parent) { continue; } - bke::node_detach_node(&ntree, node); - bke::node_attach_node(&ntree, node, frame); + bke::node_detach_node(ntree, *node); + bke::node_attach_node(ntree, *node, *frame); changed = true; } @@ -2196,7 +2196,7 @@ static void node_detach_recursive(bNodeTree &ntree, } else if (node->flag & NODE_SELECT) { /* If parent is not a descendant of a selected node, detach. */ - bke::node_detach_node(&ntree, node); + bke::node_detach_node(ntree, *node); detach_states[node->index()].descendent = true; } } @@ -2467,14 +2467,14 @@ void node_insert_on_link_flags(Main &bmain, SpaceNode &snode, bool is_new_node) BKE_ntree_update_tag_link_changed(&ntree); } else { - bke::node_remove_link(&ntree, old_link); + bke::node_remove_link(&ntree, *old_link); } if (best_input != nullptr) { /* Don't change an existing link. */ if (!best_input_is_linked) { /* Add a new link that connects the node on the left to the newly inserted node. */ - bke::node_add_link(&ntree, from_node, from_socket, node_to_insert, best_input); + bke::node_add_link(ntree, *from_node, *from_socket, *node_to_insert, *best_input); } } @@ -2535,7 +2535,7 @@ bNodeSocket *get_main_socket(bNodeTree &ntree, bNode &node, eNodeSocketInOut in_ ListBase *sockets = (in_out == SOCK_IN) ? &node.inputs : &node.outputs; /* Try to get the main socket based on the socket declaration. */ - bke::node_declaration_ensure(&ntree, &node); + bke::node_declaration_ensure(ntree, node); const nodes::NodeDeclaration *node_decl = node.declaration(); if (node_decl != nullptr) { Span socket_decls = (in_out == SOCK_IN) ? node_decl->inputs : @@ -2597,7 +2597,7 @@ static void node_parent_offset_apply(NodeInsertOfsData *data, bNode *parent, con /* Flag all children as offset to prevent them from being offset * separately (they've already moved with the parent). */ for (bNode *node : data->ntree->all_nodes()) { - if (bke::node_is_parent_and_child(parent, node)) { + if (bke::node_is_parent_and_child(*parent, *node)) { /* NODE_TEST is used to flag nodes that shouldn't be offset (again) */ node->flag |= NODE_TEST; } @@ -2637,7 +2637,7 @@ static void node_link_insert_offset_frame_chains(bNodeTree *ntree, const bool reversed) { for (bNode *node : ntree->all_nodes()) { - if (bke::node_is_parent_and_child(parent, node)) { + if (bke::node_is_parent_and_child(*parent, *node)) { bke::node_chain_iterator( ntree, node, node_link_insert_offset_frame_chain_cb, data, reversed); } @@ -2665,12 +2665,12 @@ static bool node_link_insert_offset_chain_cb(bNode *fromnode, node_offset_apply(*ofs_node, data->offset_x); } - if (!bke::node_is_parent_and_child(data->insert_parent, ofs_node)) { + if (!bke::node_is_parent_and_child(*data->insert_parent, *ofs_node)) { data->insert_parent = nullptr; } } else if (ofs_node->parent) { - bNode *node = bke::node_find_root_parent(ofs_node); + bNode *node = bke::node_find_root_parent(*ofs_node); node_offset_apply(*node, data->offset_x); } else { @@ -2698,7 +2698,7 @@ static void node_link_insert_offset_ntree(NodeInsertOfsData *iofsd, float margin = width; /* NODE_TEST will be used later, so disable for all nodes */ - bke::node_tree_node_flag_set(ntree, NODE_TEST, false); + bke::node_tree_node_flag_set(*ntree, NODE_TEST, false); /* `insert.draw_bounds` isn't updated yet, * so `totr_insert` is used to get the correct world-space coords. */ @@ -2767,12 +2767,12 @@ static void node_link_insert_offset_ntree(NodeInsertOfsData *iofsd, if (needs_alignment) { bNode *offs_node = right_alignment ? next : prev; if (!offs_node->parent || offs_node->parent == insert.parent || - bke::node_is_parent_and_child(offs_node->parent, &insert)) + bke::node_is_parent_and_child(*offs_node->parent, insert)) { node_offset_apply(*offs_node, addval); } else if (!insert.parent && offs_node->parent) { - node_offset_apply(*bke::node_find_root_parent(offs_node), addval); + node_offset_apply(*bke::node_find_root_parent(*offs_node), addval); } margin = addval; } diff --git a/source/blender/editors/space_node/node_select.cc b/source/blender/editors/space_node/node_select.cc index 2f853add063..1d4fcb95ecb 100644 --- a/source/blender/editors/space_node/node_select.cc +++ b/source/blender/editors/space_node/node_select.cc @@ -221,7 +221,7 @@ bool node_deselect_all(bNodeTree &node_tree) { bool changed = false; for (bNode *node : node_tree.all_nodes()) { - changed |= bke::node_set_selected(node, false); + changed |= bke::node_set_selected(*node, false); } return changed; } @@ -328,7 +328,7 @@ static bool node_select_grouped_type(bNodeTree &node_tree, bNode &node_act) for (bNode *node : node_tree.all_nodes()) { if ((node->flag & SELECT) == 0) { if (node->type_legacy == node_act.type_legacy) { - bke::node_set_selected(node, true); + bke::node_set_selected(*node, true); changed = true; } } @@ -342,7 +342,7 @@ static bool node_select_grouped_color(bNodeTree &node_tree, bNode &node_act) for (bNode *node : node_tree.all_nodes()) { if ((node->flag & SELECT) == 0) { if (compare_v3v3(node->color, node_act.color, 0.005f)) { - bke::node_set_selected(node, true); + bke::node_set_selected(*node, true); changed = true; } } @@ -383,7 +383,7 @@ static bool node_select_grouped_name(bNodeTree &node_tree, bNode &node_act, cons (!from_right && (pref_len_act == pref_len_curr) && STREQLEN(node_act.name, node->name, pref_len_act))) { - bke::node_set_selected(node, true); + bke::node_set_selected(*node, true); changed = true; } } @@ -402,7 +402,7 @@ static int node_select_grouped_exec(bContext *C, wmOperator *op) { SpaceNode &snode = *CTX_wm_space_node(C); bNodeTree &node_tree = *snode.edittree; - bNode *node_act = bke::node_get_active(snode.edittree); + bNode *node_act = bke::node_get_active(*snode.edittree); if (node_act == nullptr) { return OPERATOR_CANCELLED; @@ -415,7 +415,7 @@ static int node_select_grouped_exec(bContext *C, wmOperator *op) if (!extend) { node_deselect_all(node_tree); } - bke::node_set_selected(node_act, true); + bke::node_set_selected(*node_act, true); switch (type) { case NODE_SELECT_GROUPED_TYPE: @@ -495,10 +495,10 @@ void node_select_single(bContext &C, bNode &node) for (bNode *node_iter : node_tree.all_nodes()) { if (node_iter != &node) { - bke::node_set_selected(node_iter, false); + bke::node_set_selected(*node_iter, false); } } - bke::node_set_selected(&node, true); + bke::node_set_selected(node, true); ED_node_set_active(bmain, &snode, &node_tree, &node, &active_texture_changed); ED_node_set_active_viewer_key(&snode); @@ -613,19 +613,19 @@ static bool node_mouse_select(bContext *C, if (found) { switch (params->sel_op) { case SEL_OP_ADD: - bke::node_set_selected(node, true); + bke::node_set_selected(*node, true); break; case SEL_OP_SUB: - bke::node_set_selected(node, false); + bke::node_set_selected(*node, false); break; case SEL_OP_XOR: { /* Check active so clicking on an inactive node activates it. */ bool is_selected = (node->flag & NODE_SELECT) && (node->flag & NODE_ACTIVE); - bke::node_set_selected(node, !is_selected); + bke::node_set_selected(*node, !is_selected); break; } case SEL_OP_SET: - bke::node_set_selected(node, true); + bke::node_set_selected(*node, true); break; case SEL_OP_AND: /* Doesn't make sense for picking. */ @@ -777,7 +777,7 @@ static int node_box_select_exec(bContext *C, wmOperator *op) if (BLI_rctf_isect(&rectf, &node->runtime->draw_bounds, nullptr) && !BLI_rctf_inside_rctf(&frame_inside, &rectf)) { - bke::node_set_selected(node, select); + bke::node_set_selected(*node, select); is_inside = true; } break; @@ -789,7 +789,7 @@ static int node_box_select_exec(bContext *C, wmOperator *op) } if (is_inside) { - bke::node_set_selected(node, select); + bke::node_set_selected(*node, select); } } @@ -883,13 +883,13 @@ static int node_circleselect_exec(bContext *C, wmOperator *op) if (BLI_rctf_isect_circle(&node->runtime->draw_bounds, offset, radius_adjusted) && !BLI_rctf_isect_circle(&frame_inside, offset, radius_adjusted)) { - bke::node_set_selected(node, select); + bke::node_set_selected(*node, select); } break; } default: { if (BLI_rctf_isect_circle(&node->runtime->draw_bounds, offset, radius / zoom)) { - bke::node_set_selected(node, select); + bke::node_set_selected(*node, select); } break; } @@ -975,7 +975,7 @@ static bool do_lasso_select_node(bContext *C, const Span mcoords, eSelectO if (BLI_rctf_isect(&rectf, &node->runtime->draw_bounds, nullptr) && !BLI_rctf_inside_rctf(&frame_inside, &rectf)) { - bke::node_set_selected(node, select); + bke::node_set_selected(*node, select); changed = true; } break; @@ -991,7 +991,7 @@ static bool do_lasso_select_node(bContext *C, const Span mcoords, eSelectO BLI_rcti_isect_pt(&rect, screen_co.x, screen_co.y) && BLI_lasso_is_point_inside(mcoords, screen_co.x, screen_co.y, INT_MAX)) { - bke::node_set_selected(node, select); + bke::node_set_selected(*node, select); changed = true; } break; @@ -1085,7 +1085,7 @@ static int node_select_all_exec(bContext *C, wmOperator *op) switch (action) { case SEL_SELECT: for (bNode *node : node_tree.all_nodes()) { - bke::node_set_selected(node, true); + bke::node_set_selected(*node, true); } break; case SEL_DESELECT: @@ -1093,7 +1093,7 @@ static int node_select_all_exec(bContext *C, wmOperator *op) break; case SEL_INVERT: for (bNode *node : node_tree.all_nodes()) { - bke::node_set_selected(node, !(node->flag & SELECT)); + bke::node_set_selected(*node, !(node->flag & SELECT)); } break; } @@ -1146,7 +1146,7 @@ static int node_select_linked_to_exec(bContext *C, wmOperator * /*op*/) if (!input_socket->is_available()) { continue; } - bke::node_set_selected(&input_socket->owner_node(), true); + bke::node_set_selected(input_socket->owner_node(), true); } } } @@ -1196,7 +1196,7 @@ static int node_select_linked_from_exec(bContext *C, wmOperator * /*op*/) if (!output_socket->is_available()) { continue; } - bke::node_set_selected(&output_socket->owner_node(), true); + bke::node_set_selected(output_socket->owner_node(), true); } } } @@ -1238,7 +1238,7 @@ static int node_select_same_type_step_exec(bContext *C, wmOperator *op) SpaceNode *snode = CTX_wm_space_node(C); ARegion *region = CTX_wm_region(C); const bool prev = RNA_boolean_get(op->ptr, "prev"); - bNode *active_node = bke::node_get_active(snode->edittree); + bNode *active_node = bke::node_get_active(*snode->edittree); if (active_node == nullptr) { return OPERATOR_CANCELLED; diff --git a/source/blender/editors/space_node/node_shader_preview.cc b/source/blender/editors/space_node/node_shader_preview.cc index 727bfa59f73..d2933e1ac18 100644 --- a/source/blender/editors/space_node/node_shader_preview.cc +++ b/source/blender/editors/space_node/node_shader_preview.cc @@ -121,7 +121,7 @@ static std::optional get_compute_context_hash_for_node_edito for (const int i : treepath.index_range().drop_back(1)) { /* The tree path contains the name of the node but not its ID. */ bNodeTree *tree = treepath[i]->nodetree; - const bNode *node = bke::node_find_node_by_name(tree, treepath[i + 1]->node_name); + const bNode *node = bke::node_find_node_by_name(*tree, treepath[i + 1]->node_name); if (node == nullptr) { /* The current tree path is invalid, probably because some parent group node has been * deleted. */ @@ -374,7 +374,7 @@ static void connect_nested_node_to_node(const Span treepath, } } if (output_node == nullptr) { - output_node = bke::node_add_static_node(nullptr, nested_nt, NODE_GROUP_OUTPUT); + output_node = bke::node_add_static_node(nullptr, *nested_nt, NODE_GROUP_OUTPUT); output_node->flag |= NODE_DO_OUTPUT; } @@ -384,12 +384,13 @@ static void connect_nested_node_to_node(const Span treepath, bNodeSocket *out_socket = blender::bke::node_find_enabled_input_socket(*output_node, route_name); - bke::node_add_link(nested_nt, nested_node_iter, nested_socket_iter, output_node, out_socket); + bke::node_add_link( + *nested_nt, *nested_node_iter, *nested_socket_iter, *output_node, *out_socket); BKE_ntree_update_after_single_tree_change(*G.pr_main, *nested_nt); /* Change the `nested_node` pointer to the nested node-group instance node. The tree path * contains the name of the instance node but not its ID. */ - nested_node_iter = bke::node_find_node_by_name(path_prev->nodetree, path->node_name); + nested_node_iter = bke::node_find_node_by_name(*path_prev->nodetree, path->node_name); /* Update the sockets of the node because we added a new interface. */ BKE_ntree_update_tag_node_property(path_prev->nodetree, nested_node_iter); @@ -401,11 +402,11 @@ static void connect_nested_node_to_node(const Span treepath, route_name); } - bke::node_add_link(treepath.first()->nodetree, - nested_node_iter, - nested_socket_iter, - &final_node, - &final_socket); + bke::node_add_link(*treepath.first()->nodetree, + *nested_node_iter, + *nested_socket_iter, + final_node, + final_socket); } /* Connect the node to the output of the first nodetree from `treepath`. Last element of `treepath` @@ -427,10 +428,10 @@ static void connect_node_to_surface_output(const Span treepath, socket_preview = socket_preview->link->fromsock; } /* Ensure output is usable. */ - out_surface_socket = bke::node_find_socket(&output_node, SOCK_IN, "Surface"); + out_surface_socket = bke::node_find_socket(output_node, SOCK_IN, "Surface"); if (out_surface_socket->link) { /* Make sure no node is already wired to the output before wiring. */ - bke::node_remove_link(main_nt, out_surface_socket->link); + bke::node_remove_link(main_nt, *out_surface_socket->link); } connect_nested_node_to_node(treepath, @@ -456,13 +457,13 @@ static void connect_nodes_to_aovs(const Span treepath, bNode *node_preview = nodesocket.first; bNodeSocket *socket_preview = nodesocket.second; - bNode *aov_node = bke::node_add_static_node(nullptr, main_nt, SH_NODE_OUTPUT_AOV); + bNode *aov_node = bke::node_add_static_node(nullptr, *main_nt, SH_NODE_OUTPUT_AOV); STRNCPY(reinterpret_cast(aov_node->storage)->name, nodesocket.first->name); if (socket_preview == nullptr) { continue; } - bNodeSocket *aov_socket = bke::node_find_socket(aov_node, SOCK_IN, "Color"); + bNodeSocket *aov_socket = bke::node_find_socket(*aov_node, SOCK_IN, "Color"); if (socket_preview->in_out == SOCK_IN) { if (socket_preview->link == nullptr) { /* Copy the custom value of the socket directly to the AOV node. @@ -523,13 +524,13 @@ static bool prepare_viewlayer_update(void *pvl_data, ViewLayer *vl, Depsgraph *d } bNodeSocket *displacement_socket = bke::node_find_socket( - job_data->mat_output_copy, SOCK_IN, "Displacement"); + *job_data->mat_output_copy, SOCK_IN, "Displacement"); if (job_data->mat_displacement_copy.first != nullptr && displacement_socket->link == nullptr) { - bke::node_add_link(job_data->treepath_copy.first()->nodetree, - job_data->mat_displacement_copy.first, - job_data->mat_displacement_copy.second, - job_data->mat_output_copy, - displacement_socket); + bke::node_add_link(*job_data->treepath_copy.first()->nodetree, + *job_data->mat_displacement_copy.first, + *job_data->mat_displacement_copy.second, + *job_data->mat_output_copy, + *displacement_socket); } connect_node_to_surface_output(job_data->treepath_copy, nodesocket, *job_data->mat_output_copy); @@ -698,7 +699,7 @@ static void shader_preview_startjob(void *customdata, wmJobWorkerStatus *worker_ for (bNode *node_iter : job_data->mat_copy->nodetree->all_nodes()) { if (node_iter->flag & NODE_DO_OUTPUT) { node_iter->flag &= ~NODE_DO_OUTPUT; - bNodeSocket *disp_socket = bke::node_find_socket(node_iter, SOCK_IN, "Displacement"); + bNodeSocket *disp_socket = bke::node_find_socket(*node_iter, SOCK_IN, "Displacement"); if (disp_socket != nullptr && disp_socket->link != nullptr) { job_data->mat_displacement_copy = std::make_pair(disp_socket->link->fromnode, disp_socket->link->fromsock); @@ -710,7 +711,7 @@ static void shader_preview_startjob(void *customdata, wmJobWorkerStatus *worker_ /* Add a new output node used only for the previews. This is useful to keep the previously * connected links (for previewing the output nodes for example). */ job_data->mat_output_copy = bke::node_add_static_node( - nullptr, job_data->mat_copy->nodetree, SH_NODE_OUTPUT_MATERIAL); + nullptr, *job_data->mat_copy->nodetree, SH_NODE_OUTPUT_MATERIAL); job_data->mat_output_copy->flag |= NODE_DO_OUTPUT; bNodeTree *active_nodetree = job_data->treepath_copy.last()->nodetree; @@ -812,7 +813,7 @@ static void ensure_nodetree_previews(const bContext &C, original_path; original_path = original_path->next) { - bNode *parent = bke::node_find_node_by_name(job_data->treepath_copy.last()->nodetree, + bNode *parent = bke::node_find_node_by_name(*job_data->treepath_copy.last()->nodetree, original_path->node_name); if (parent == nullptr) { /* In some cases (e.g. muted nodes), there may not be an equivalent node in the copied diff --git a/source/blender/editors/space_node/node_templates.cc b/source/blender/editors/space_node/node_templates.cc index 33efbeb6a2c..de6a0f15f07 100644 --- a/source/blender/editors/space_node/node_templates.cc +++ b/source/blender/editors/space_node/node_templates.cc @@ -159,7 +159,7 @@ static void node_remove_linked(Main *bmain, bNodeTree *ntree, bNode *rem_node) next = node->next; if (node->flag & NODE_TEST) { - bke::node_remove_node(bmain, ntree, node, true); + bke::node_remove_node(bmain, *ntree, *node, true); } } } @@ -174,7 +174,7 @@ static void node_socket_disconnect(Main *bmain, return; } - bke::node_remove_link(ntree, sock_to->link); + bke::node_remove_link(ntree, *sock_to->link); sock_to->flag |= SOCK_COLLAPSED; BKE_ntree_update_tag_node_property(ntree, node_to); @@ -211,7 +211,7 @@ static void node_socket_add_replace(const bContext *C, /* unlink existing node */ if (sock_to->link) { node_prev = sock_to->link->fromnode; - bke::node_remove_link(ntree, sock_to->link); + bke::node_remove_link(ntree, *sock_to->link); } /* find existing node that we can use */ @@ -234,7 +234,7 @@ static void node_socket_add_replace(const bContext *C, node_from = node_prev; } else if (!node_from) { - node_from = bke::node_add_static_node(C, ntree, type); + node_from = bke::node_add_static_node(C, *ntree, type); if (node_prev != nullptr) { /* If we're replacing existing node, use its location. */ node_from->location[0] = node_prev->location[0]; @@ -242,26 +242,26 @@ static void node_socket_add_replace(const bContext *C, } else { sock_from_tmp = (bNodeSocket *)BLI_findlink(&node_from->outputs, item->socket_index); - bke::node_position_relative(node_from, node_to, sock_from_tmp, sock_to); + bke::node_position_relative(*node_from, *node_to, *sock_from_tmp, *sock_to); } node_link_item_apply(ntree, node_from, item); BKE_main_ensure_invariants(*bmain, ntree->id); } - bke::node_set_active(ntree, node_from); + bke::node_set_active(*ntree, *node_from); /* add link */ sock_from_tmp = (bNodeSocket *)BLI_findlink(&node_from->outputs, item->socket_index); - bke::node_add_link(ntree, node_from, sock_from_tmp, node_to, sock_to); + bke::node_add_link(*ntree, *node_from, *sock_from_tmp, *node_to, *sock_to); sock_to->flag &= ~SOCK_COLLAPSED; /* copy input sockets from previous node */ if (node_prev && node_from != node_prev) { LISTBASE_FOREACH (bNodeSocket *, sock_prev, &node_prev->inputs) { LISTBASE_FOREACH (bNodeSocket *, sock_from, &node_from->inputs) { - if (bke::node_count_socket_links(ntree, sock_from) >= - bke::node_socket_link_limit(sock_from)) + if (bke::node_count_socket_links(*ntree, *sock_from) >= + bke::node_socket_link_limit(*sock_from)) { continue; } @@ -272,8 +272,8 @@ static void node_socket_add_replace(const bContext *C, bNodeLink *link = sock_prev->link; if (link && link->fromnode) { - bke::node_add_link(ntree, link->fromnode, link->fromsock, node_from, sock_from); - bke::node_remove_link(ntree, link); + bke::node_add_link(*ntree, *link->fromnode, *link->fromsock, *node_from, *sock_from); + bke::node_remove_link(ntree, *link); } node_socket_copy_default_value(sock_from, sock_prev); @@ -431,7 +431,7 @@ static void ui_node_sock_name(const bNodeTree *ntree, bNode *node = sock->link->fromnode; char node_name[UI_MAX_NAME_STR]; - bke::nodeLabel(ntree, node, node_name, sizeof(node_name)); + bke::nodeLabel(*ntree, *node, node_name, sizeof(node_name)); if (BLI_listbase_is_empty(&node->inputs) && node->outputs.first != node->outputs.last) { BLI_snprintf( diff --git a/source/blender/editors/space_node/space_node.cc b/source/blender/editors/space_node/space_node.cc index b22939101cf..a683934dc75 100644 --- a/source/blender/editors/space_node/space_node.cc +++ b/source/blender/editors/space_node/space_node.cc @@ -353,7 +353,7 @@ bool push_compute_context_for_tree_path(const SpaceNode &snode, for (const int i : tree_path.index_range().drop_back(1)) { bNodeTree *tree = tree_path[i]->nodetree; const char *group_node_name = tree_path[i + 1]->node_name; - const bNode *group_node = blender::bke::node_find_node_by_name(tree, group_node_name); + const bNode *group_node = blender::bke::node_find_node_by_name(*tree, group_node_name); if (group_node == nullptr) { return false; } @@ -1059,7 +1059,7 @@ static int /*eContextResult*/ node_context(const bContext *C, } if (CTX_data_equals(member, "active_node")) { if (snode->edittree) { - bNode *node = bke::node_get_active(snode->edittree); + bNode *node = bke::node_get_active(*snode->edittree); CTX_data_pointer_set(result, &snode->edittree->id, &RNA_Node, node); } diff --git a/source/blender/editors/transform/transform_convert_node.cc b/source/blender/editors/transform/transform_convert_node.cc index a40cbbbf72e..28edd053534 100644 --- a/source/blender/editors/transform/transform_convert_node.cc +++ b/source/blender/editors/transform/transform_convert_node.cc @@ -280,7 +280,7 @@ static void special_aftertrans_update__node(bContext *C, TransInfo *t) if (ntree) { LISTBASE_FOREACH_MUTABLE (bNode *, node, &ntree->nodes) { if (node->flag & NODE_SELECT) { - bke::node_remove_node(bmain, ntree, node, true); + bke::node_remove_node(bmain, *ntree, *node, true); } } BKE_main_ensure_invariants(*bmain, ntree->id); diff --git a/source/blender/editors/util/ed_viewer_path.cc b/source/blender/editors/util/ed_viewer_path.cc index 92b0caf2bb5..ae0008f5264 100644 --- a/source/blender/editors/util/ed_viewer_path.cc +++ b/source/blender/editors/util/ed_viewer_path.cc @@ -109,7 +109,7 @@ static void viewer_path_for_geometry_node(const SpaceNode &snode, bNodeTree *tree = tree_path[i]->nodetree; /* The tree path contains the name of the node but not its ID. */ const char *node_name = tree_path[i + 1]->node_name; - const bNode *node = bke::node_find_node_by_name(tree, node_name); + const bNode *node = bke::node_find_node_by_name(*tree, node_name); /* The name in the tree path should match a group node in the tree. Sometimes, the tree-path is * out of date though. */ if (node == nullptr) { diff --git a/source/blender/editors/uvedit/uvedit_ops.cc b/source/blender/editors/uvedit/uvedit_ops.cc index e361743cd95..7492efe43ba 100644 --- a/source/blender/editors/uvedit/uvedit_ops.cc +++ b/source/blender/editors/uvedit/uvedit_ops.cc @@ -123,7 +123,7 @@ bool ED_object_get_active_image(Object *ob, Material *ma = DEG_is_evaluated_object(ob) ? BKE_object_material_get_eval(ob, mat_nr) : BKE_object_material_get(ob, mat_nr); bNodeTree *ntree = (ma && ma->use_nodes) ? ma->nodetree : nullptr; - bNode *node = (ntree) ? bke::node_get_active_texture(ntree) : nullptr; + bNode *node = (ntree) ? bke::node_get_active_texture(*ntree) : nullptr; if (node && is_image_texture_node(node)) { if (r_ima) { @@ -168,7 +168,7 @@ bool ED_object_get_active_image(Object *ob, void ED_object_assign_active_image(Main *bmain, Object *ob, int mat_nr, Image *ima) { Material *ma = BKE_object_material_get(ob, mat_nr); - bNode *node = (ma && ma->use_nodes) ? bke::node_get_active_texture(ma->nodetree) : nullptr; + bNode *node = (ma && ma->use_nodes) ? bke::node_get_active_texture(*ma->nodetree) : nullptr; if (node && is_image_texture_node(node)) { node->id = &ima->id; diff --git a/source/blender/freestyle/intern/blender_interface/BlenderStrokeRenderer.cpp b/source/blender/freestyle/intern/blender_interface/BlenderStrokeRenderer.cpp index 4d3f572909d..28da052210f 100644 --- a/source/blender/freestyle/intern/blender_interface/BlenderStrokeRenderer.cpp +++ b/source/blender/freestyle/intern/blender_interface/BlenderStrokeRenderer.cpp @@ -217,7 +217,7 @@ Material *BlenderStrokeRenderer::GetStrokeShader(Main *bmain, if (iNodeTree) { // make a copy of linestyle->nodetree - ntree = blender::bke::node_tree_copy_tree_ex(iNodeTree, bmain, do_id_user); + ntree = blender::bke::node_tree_copy_tree_ex(*iNodeTree, bmain, do_id_user); // find the active Output Line Style node LISTBASE_FOREACH (bNode *, node, &ntree->nodes) { @@ -235,14 +235,14 @@ Material *BlenderStrokeRenderer::GetStrokeShader(Main *bmain, ma->use_nodes = true; ma->blend_method = MA_BM_HASHED; - bNode *input_attr_color = blender::bke::node_add_static_node(nullptr, ntree, SH_NODE_ATTRIBUTE); + bNode *input_attr_color = blender::bke::node_add_static_node(nullptr, *ntree, SH_NODE_ATTRIBUTE); input_attr_color->location[0] = 0.0f; input_attr_color->location[1] = -200.0f; storage = (NodeShaderAttribute *)input_attr_color->storage; STRNCPY(storage->name, "Color"); bNode *mix_rgb_color = blender::bke::node_add_static_node( - nullptr, ntree, SH_NODE_MIX_RGB_LEGACY); + nullptr, *ntree, SH_NODE_MIX_RGB_LEGACY); mix_rgb_color->custom1 = MA_RAMP_BLEND; // Mix mix_rgb_color->location[0] = 200.0f; mix_rgb_color->location[1] = -200.0f; @@ -250,14 +250,14 @@ Material *BlenderStrokeRenderer::GetStrokeShader(Main *bmain, toptr = RNA_pointer_create_discrete((ID *)ntree, &RNA_NodeSocket, tosock); RNA_float_set(&toptr, "default_value", 0.0f); - bNode *input_attr_alpha = blender::bke::node_add_static_node(nullptr, ntree, SH_NODE_ATTRIBUTE); + bNode *input_attr_alpha = blender::bke::node_add_static_node(nullptr, *ntree, SH_NODE_ATTRIBUTE); input_attr_alpha->location[0] = 400.0f; input_attr_alpha->location[1] = 300.0f; storage = (NodeShaderAttribute *)input_attr_alpha->storage; STRNCPY(storage->name, "Alpha"); bNode *mix_rgb_alpha = blender::bke::node_add_static_node( - nullptr, ntree, SH_NODE_MIX_RGB_LEGACY); + nullptr, *ntree, SH_NODE_MIX_RGB_LEGACY); mix_rgb_alpha->custom1 = MA_RAMP_BLEND; // Mix mix_rgb_alpha->location[0] = 600.0f; mix_rgb_alpha->location[1] = 300.0f; @@ -265,67 +265,70 @@ Material *BlenderStrokeRenderer::GetStrokeShader(Main *bmain, toptr = RNA_pointer_create_discrete((ID *)ntree, &RNA_NodeSocket, tosock); RNA_float_set(&toptr, "default_value", 0.0f); - bNode *shader_emission = blender::bke::node_add_static_node(nullptr, ntree, SH_NODE_EMISSION); + bNode *shader_emission = blender::bke::node_add_static_node(nullptr, *ntree, SH_NODE_EMISSION); shader_emission->location[0] = 400.0f; shader_emission->location[1] = -200.0f; - bNode *input_light_path = blender::bke::node_add_static_node(nullptr, ntree, SH_NODE_LIGHT_PATH); + bNode *input_light_path = blender::bke::node_add_static_node( + nullptr, *ntree, SH_NODE_LIGHT_PATH); input_light_path->location[0] = 400.0f; input_light_path->location[1] = 100.0f; - bNode *mix_shader_color = blender::bke::node_add_static_node(nullptr, ntree, SH_NODE_MIX_SHADER); + bNode *mix_shader_color = blender::bke::node_add_static_node( + nullptr, *ntree, SH_NODE_MIX_SHADER); mix_shader_color->location[0] = 600.0f; mix_shader_color->location[1] = -100.0f; bNode *shader_transparent = blender::bke::node_add_static_node( - nullptr, ntree, SH_NODE_BSDF_TRANSPARENT); + nullptr, *ntree, SH_NODE_BSDF_TRANSPARENT); shader_transparent->location[0] = 600.0f; shader_transparent->location[1] = 100.0f; - bNode *mix_shader_alpha = blender::bke::node_add_static_node(nullptr, ntree, SH_NODE_MIX_SHADER); + bNode *mix_shader_alpha = blender::bke::node_add_static_node( + nullptr, *ntree, SH_NODE_MIX_SHADER); mix_shader_alpha->location[0] = 800.0f; mix_shader_alpha->location[1] = 100.0f; bNode *output_material = blender::bke::node_add_static_node( - nullptr, ntree, SH_NODE_OUTPUT_MATERIAL); + nullptr, *ntree, SH_NODE_OUTPUT_MATERIAL); output_material->location[0] = 1000.0f; output_material->location[1] = 100.0f; fromsock = (bNodeSocket *)BLI_findlink(&input_attr_color->outputs, 0); // Color tosock = (bNodeSocket *)BLI_findlink(&mix_rgb_color->inputs, 1); // Color1 - blender::bke::node_add_link(ntree, input_attr_color, fromsock, mix_rgb_color, tosock); + blender::bke::node_add_link(*ntree, *input_attr_color, *fromsock, *mix_rgb_color, *tosock); fromsock = (bNodeSocket *)BLI_findlink(&mix_rgb_color->outputs, 0); // Color tosock = (bNodeSocket *)BLI_findlink(&shader_emission->inputs, 0); // Color - blender::bke::node_add_link(ntree, mix_rgb_color, fromsock, shader_emission, tosock); + blender::bke::node_add_link(*ntree, *mix_rgb_color, *fromsock, *shader_emission, *tosock); fromsock = (bNodeSocket *)BLI_findlink(&shader_emission->outputs, 0); // Emission tosock = (bNodeSocket *)BLI_findlink(&mix_shader_color->inputs, 2); // Shader (second) - blender::bke::node_add_link(ntree, shader_emission, fromsock, mix_shader_color, tosock); + blender::bke::node_add_link(*ntree, *shader_emission, *fromsock, *mix_shader_color, *tosock); fromsock = (bNodeSocket *)BLI_findlink(&input_light_path->outputs, 0); // In Camera Ray tosock = (bNodeSocket *)BLI_findlink(&mix_shader_color->inputs, 0); // Fac - blender::bke::node_add_link(ntree, input_light_path, fromsock, mix_shader_color, tosock); + blender::bke::node_add_link(*ntree, *input_light_path, *fromsock, *mix_shader_color, *tosock); fromsock = (bNodeSocket *)BLI_findlink(&mix_rgb_alpha->outputs, 0); // Color tosock = (bNodeSocket *)BLI_findlink(&mix_shader_alpha->inputs, 0); // Fac - blender::bke::node_add_link(ntree, mix_rgb_alpha, fromsock, mix_shader_alpha, tosock); + blender::bke::node_add_link(*ntree, *mix_rgb_alpha, *fromsock, *mix_shader_alpha, *tosock); fromsock = (bNodeSocket *)BLI_findlink(&input_attr_alpha->outputs, 0); // Color tosock = (bNodeSocket *)BLI_findlink(&mix_rgb_alpha->inputs, 1); // Color1 - blender::bke::node_add_link(ntree, input_attr_alpha, fromsock, mix_rgb_alpha, tosock); + blender::bke::node_add_link(*ntree, *input_attr_alpha, *fromsock, *mix_rgb_alpha, *tosock); fromsock = (bNodeSocket *)BLI_findlink(&shader_transparent->outputs, 0); // BSDF tosock = (bNodeSocket *)BLI_findlink(&mix_shader_alpha->inputs, 1); // Shader (first) - blender::bke::node_add_link(ntree, shader_transparent, fromsock, mix_shader_alpha, tosock); + blender::bke::node_add_link(*ntree, *shader_transparent, *fromsock, *mix_shader_alpha, *tosock); fromsock = (bNodeSocket *)BLI_findlink(&mix_shader_color->outputs, 0); // Shader tosock = (bNodeSocket *)BLI_findlink(&mix_shader_alpha->inputs, 2); // Shader (second) - blender::bke::node_add_link(ntree, mix_shader_color, fromsock, mix_shader_alpha, tosock); + blender::bke::node_add_link(*ntree, *mix_shader_color, *fromsock, *mix_shader_alpha, *tosock); fromsock = (bNodeSocket *)BLI_findlink(&mix_shader_alpha->outputs, 0); // Shader tosock = (bNodeSocket *)BLI_findlink(&output_material->inputs, 0); // Surface - blender::bke::node_add_link(ntree, mix_shader_alpha, fromsock, output_material, tosock); + blender::bke::node_add_link(*ntree, *mix_shader_alpha, *fromsock, *output_material, *tosock); if (output_linestyle) { bNodeSocket *outsock; @@ -338,7 +341,8 @@ Material *BlenderStrokeRenderer::GetStrokeShader(Main *bmain, tosock = (bNodeSocket *)BLI_findlink(&mix_rgb_color->inputs, 2); // Color2 link = (bNodeLink *)BLI_findptr(&ntree->links, outsock, offsetof(bNodeLink, tosock)); if (link) { - blender::bke::node_add_link(ntree, link->fromnode, link->fromsock, mix_rgb_color, tosock); + blender::bke::node_add_link( + *ntree, *link->fromnode, *link->fromsock, *mix_rgb_color, *tosock); } else { float color[4]; @@ -352,7 +356,8 @@ Material *BlenderStrokeRenderer::GetStrokeShader(Main *bmain, tosock = (bNodeSocket *)BLI_findlink(&mix_rgb_color->inputs, 0); // Fac link = (bNodeLink *)BLI_findptr(&ntree->links, outsock, offsetof(bNodeLink, tosock)); if (link) { - blender::bke::node_add_link(ntree, link->fromnode, link->fromsock, mix_rgb_color, tosock); + blender::bke::node_add_link( + *ntree, *link->fromnode, *link->fromsock, *mix_rgb_color, *tosock); } else { fromptr = RNA_pointer_create_discrete((ID *)ntree, &RNA_NodeSocket, outsock); @@ -364,7 +369,8 @@ Material *BlenderStrokeRenderer::GetStrokeShader(Main *bmain, tosock = (bNodeSocket *)BLI_findlink(&mix_rgb_alpha->inputs, 2); // Color2 link = (bNodeLink *)BLI_findptr(&ntree->links, outsock, offsetof(bNodeLink, tosock)); if (link) { - blender::bke::node_add_link(ntree, link->fromnode, link->fromsock, mix_rgb_alpha, tosock); + blender::bke::node_add_link( + *ntree, *link->fromnode, *link->fromsock, *mix_rgb_alpha, *tosock); } else { float color[4]; @@ -379,7 +385,8 @@ Material *BlenderStrokeRenderer::GetStrokeShader(Main *bmain, tosock = (bNodeSocket *)BLI_findlink(&mix_rgb_alpha->inputs, 0); // Fac link = (bNodeLink *)BLI_findptr(&ntree->links, outsock, offsetof(bNodeLink, tosock)); if (link) { - blender::bke::node_add_link(ntree, link->fromnode, link->fromsock, mix_rgb_alpha, tosock); + blender::bke::node_add_link( + *ntree, *link->fromnode, *link->fromsock, *mix_rgb_alpha, *tosock); } else { fromptr = RNA_pointer_create_discrete((ID *)ntree, &RNA_NodeSocket, outsock); @@ -393,7 +400,7 @@ Material *BlenderStrokeRenderer::GetStrokeShader(Main *bmain, bNodeSocket *sock = (bNodeSocket *)BLI_findlink(&node->outputs, 0); // add new UV Map node - bNode *input_uvmap = blender::bke::node_add_static_node(nullptr, ntree, SH_NODE_UVMAP); + bNode *input_uvmap = blender::bke::node_add_static_node(nullptr, *ntree, SH_NODE_UVMAP); input_uvmap->location[0] = node->location[0] - 200.0f; input_uvmap->location[1] = node->location[1]; NodeShaderUVMap *storage = (NodeShaderUVMap *)input_uvmap->storage; @@ -408,15 +415,16 @@ Material *BlenderStrokeRenderer::GetStrokeShader(Main *bmain, // replace links from the UV Along Stroke node by links from the UV Map node LISTBASE_FOREACH (bNodeLink *, link, &ntree->links) { if (link->fromnode == node && link->fromsock == sock) { - blender::bke::node_add_link(ntree, input_uvmap, fromsock, link->tonode, link->tosock); + blender::bke::node_add_link( + *ntree, *input_uvmap, *fromsock, *link->tonode, *link->tosock); } } - blender::bke::node_remove_socket_links(ntree, sock); + blender::bke::node_remove_socket_links(*ntree, *sock); } } } - blender::bke::node_set_active(ntree, output_material); + blender::bke::node_set_active(*ntree, *output_material); BKE_ntree_update_after_single_tree_change(*bmain, *ntree); return ma; diff --git a/source/blender/io/collada/Materials.cpp b/source/blender/io/collada/Materials.cpp index 874844317c6..fa18cac1946 100644 --- a/source/blender/io/collada/Materials.cpp +++ b/source/blender/io/collada/Materials.cpp @@ -108,7 +108,7 @@ void MaterialNode::update_material_nodetree() bNode *MaterialNode::add_node(int node_type, int locx, int locy, std::string label) { - bNode *node = blender::bke::node_add_static_node(mContext, ntree, node_type); + bNode *node = blender::bke::node_add_static_node(mContext, *ntree, node_type); if (node) { if (label.length() > 0) { STRNCPY(node->label, label.c_str()); @@ -126,7 +126,7 @@ void MaterialNode::add_link(bNode *from_node, int from_index, bNode *to_node, in bNodeSocket *from_socket = (bNodeSocket *)BLI_findlink(&from_node->outputs, from_index); bNodeSocket *to_socket = (bNodeSocket *)BLI_findlink(&to_node->inputs, to_index); - blender::bke::node_add_link(ntree, from_node, from_socket, to_node, to_socket); + blender::bke::node_add_link(*ntree, *from_node, *from_socket, *to_node, *to_socket); } void MaterialNode::add_link(bNode *from_node, @@ -134,11 +134,11 @@ void MaterialNode::add_link(bNode *from_node, bNode *to_node, const char *to_label) { - bNodeSocket *from_socket = blender::bke::node_find_socket(from_node, SOCK_OUT, from_label); - bNodeSocket *to_socket = blender::bke::node_find_socket(to_node, SOCK_IN, to_label); + bNodeSocket *from_socket = blender::bke::node_find_socket(*from_node, SOCK_OUT, from_label); + bNodeSocket *to_socket = blender::bke::node_find_socket(*to_node, SOCK_IN, to_label); if (from_socket && to_socket) { - blender::bke::node_add_link(ntree, from_node, from_socket, to_node, to_socket); + blender::bke::node_add_link(*ntree, *from_node, *from_socket, *to_node, *to_socket); } } @@ -146,7 +146,7 @@ void MaterialNode::set_reflectivity(COLLADAFW::FloatOrParam &val) { float reflectivity = val.getFloatValue(); if (reflectivity >= 0) { - bNodeSocket *socket = blender::bke::node_find_socket(shader_node, SOCK_IN, "Metallic"); + bNodeSocket *socket = blender::bke::node_find_socket(*shader_node, SOCK_IN, "Metallic"); ((bNodeSocketValueFloat *)socket->default_value)->value = reflectivity; material->metallic = reflectivity; } @@ -158,7 +158,7 @@ void MaterialNode::set_shininess(COLLADAFW::FloatOrParam &val) { float roughness = val.getFloatValue(); if (roughness >= 0) { - bNodeSocket *socket = blender::bke::node_find_socket(shader_node, SOCK_IN, "Roughness"); + bNodeSocket *socket = blender::bke::node_find_socket(*shader_node, SOCK_IN, "Roughness"); ((bNodeSocketValueFloat *)socket->default_value)->value = roughness; } } @@ -174,7 +174,7 @@ void MaterialNode::set_ior(COLLADAFW::FloatOrParam &val) return; } - bNodeSocket *socket = blender::bke::node_find_socket(shader_node, SOCK_IN, "IOR"); + bNodeSocket *socket = blender::bke::node_find_socket(*shader_node, SOCK_IN, "IOR"); ((bNodeSocketValueFloat *)socket->default_value)->value = ior; } @@ -213,7 +213,7 @@ void MaterialNode::set_alpha(COLLADAFW::EffectCommon::OpaqueMode mode, alpha = 1 - alpha; } - bNodeSocket *socket = blender::bke::node_find_socket(shader_node, SOCK_IN, "Alpha"); + bNodeSocket *socket = blender::bke::node_find_socket(*shader_node, SOCK_IN, "Alpha"); ((bNodeSocketValueFloat *)socket->default_value)->value = alpha; material->a = alpha; } @@ -234,7 +234,7 @@ void MaterialNode::set_diffuse(COLLADAFW::ColorOrTexture &cot) } } else { - bNodeSocket *socket = blender::bke::node_find_socket(shader_node, SOCK_IN, "Base Color"); + bNodeSocket *socket = blender::bke::node_find_socket(*shader_node, SOCK_IN, "Base Color"); float *fcol = (float *)socket->default_value; if (cot.isColor()) { @@ -263,7 +263,7 @@ Image *MaterialNode::get_diffuse_image() } const bNode *shader = nodes.first(); - const bNodeSocket *in_socket = blender::bke::node_find_socket(shader, SOCK_IN, "Base Color"); + const bNodeSocket *in_socket = blender::bke::node_find_socket(*shader, SOCK_IN, "Base Color"); if (in_socket == nullptr) { return nullptr; } @@ -334,7 +334,7 @@ void MaterialNode::set_emission(COLLADAFW::ColorOrTexture &cot) int locy = -300 * (node_map.size() - 2); if (cot.isColor()) { COLLADAFW::Color col = cot.getColor(); - bNodeSocket *socket = blender::bke::node_find_socket(shader_node, SOCK_IN, "Emission Color"); + bNodeSocket *socket = blender::bke::node_find_socket(*shader_node, SOCK_IN, "Emission Color"); float *fcol = (float *)socket->default_value; fcol[0] = col.getRed(); @@ -350,7 +350,7 @@ void MaterialNode::set_emission(COLLADAFW::ColorOrTexture &cot) } } - bNodeSocket *socket = blender::bke::node_find_socket(shader_node, SOCK_IN, "Emission Strength"); + bNodeSocket *socket = blender::bke::node_find_socket(*shader_node, SOCK_IN, "Emission Strength"); if (socket) { *(float *)socket->default_value = 1.0f; } @@ -371,7 +371,7 @@ void MaterialNode::set_opacity(COLLADAFW::ColorOrTexture &cot) alpha *= col.getAlpha(); /* Assuming A_ONE opaque mode */ } - bNodeSocket *socket = blender::bke::node_find_socket(shader_node, SOCK_IN, "Alpha"); + bNodeSocket *socket = blender::bke::node_find_socket(*shader_node, SOCK_IN, "Alpha"); ((bNodeSocketValueFloat *)socket->default_value)->value = alpha; } /* texture */ @@ -412,7 +412,7 @@ void MaterialNode::set_specular(COLLADAFW::ColorOrTexture &cot) * way to handle specularity in general. Also note that currently we * do not export specularity values, see EffectExporter::operator() */ bNodeSocket *socket = blender::bke::node_find_socket( - shader_node, SOCK_IN, "Specular IOR Level"); + *shader_node, SOCK_IN, "Specular IOR Level"); ((bNodeSocketValueFloat *)socket->default_value)->value = 0.0f; } } diff --git a/source/blender/io/collada/collada_utils.cpp b/source/blender/io/collada/collada_utils.cpp index a200cd91358..348ff38b86c 100644 --- a/source/blender/io/collada/collada_utils.cpp +++ b/source/blender/io/collada/collada_utils.cpp @@ -1111,7 +1111,7 @@ static bNodeTree *prepare_material_nodetree(Material *ma) static bNode *bc_add_node( bContext *C, bNodeTree *ntree, int node_type, int locx, int locy, std::string label) { - bNode *node = blender::bke::node_add_static_node(C, ntree, node_type); + bNode *node = blender::bke::node_add_static_node(C, *ntree, node_type); if (node) { if (label.length() > 0) { STRNCPY(node->label, label.c_str()); @@ -1134,7 +1134,7 @@ static void bc_node_add_link( bNodeSocket *from_socket = (bNodeSocket *)BLI_findlink(&from_node->outputs, from_index); bNodeSocket *to_socket = (bNodeSocket *)BLI_findlink(&to_node->inputs, to_index); - blender::bke::node_add_link(ntree, from_node, from_socket, to_node, to_socket); + blender::bke::node_add_link(*ntree, *from_node, *from_socket, *to_node, *to_socket); } void bc_add_default_shader(bContext *C, Material *ma) @@ -1269,7 +1269,7 @@ double bc_get_reflectivity(Material *ma) bool bc_get_float_from_shader(bNode *shader, double &val, std::string nodeid) { - bNodeSocket *socket = blender::bke::node_find_socket(shader, SOCK_IN, nodeid); + bNodeSocket *socket = blender::bke::node_find_socket(*shader, SOCK_IN, nodeid); if (socket) { bNodeSocketValueFloat *ref = (bNodeSocketValueFloat *)socket->default_value; val = double(ref->value); @@ -1283,7 +1283,7 @@ COLLADASW::ColorOrTexture bc_get_cot_from_shader(bNode *shader, Color &default_color, bool with_alpha) { - bNodeSocket *socket = blender::bke::node_find_socket(shader, SOCK_IN, nodeid); + bNodeSocket *socket = blender::bke::node_find_socket(*shader, SOCK_IN, nodeid); if (socket) { bNodeSocketValueRGBA *dcol = (bNodeSocketValueRGBA *)socket->default_value; float *col = dcol->value; diff --git a/source/blender/io/usd/intern/usd_light_convert.cc b/source/blender/io/usd/intern/usd_light_convert.cc index f056c0143ee..386871d4746 100644 --- a/source/blender/io/usd/intern/usd_light_convert.cc +++ b/source/blender/io/usd/intern/usd_light_convert.cc @@ -184,16 +184,16 @@ static bNode *append_node(bNode *dst_node, bNodeTree *ntree, float offset) { - bNode *src_node = bke::node_add_static_node(nullptr, ntree, new_node_type); + bNode *src_node = bke::node_add_static_node(nullptr, *ntree, new_node_type); if (!src_node) { return nullptr; } - bke::node_add_link(ntree, - src_node, - bke::node_find_socket(src_node, SOCK_OUT, out_sock), - dst_node, - bke::node_find_socket(dst_node, SOCK_IN, in_sock)); + bke::node_add_link(*ntree, + *src_node, + *bke::node_find_socket(*src_node, SOCK_OUT, out_sock), + *dst_node, + *bke::node_find_socket(*dst_node, SOCK_IN, in_sock)); src_node->location[0] = dst_node->location[0] - offset; src_node->location[1] = dst_node->location[1]; @@ -219,10 +219,10 @@ static bool node_search(bNode *fromnode, if (!res->background_found && fromnode->type_legacy == SH_NODE_BACKGROUND) { /* Get light color and intensity */ - const bNodeSocketValueRGBA *color_data = bke::node_find_socket(fromnode, SOCK_IN, "Color") + const bNodeSocketValueRGBA *color_data = bke::node_find_socket(*fromnode, SOCK_IN, "Color") ->default_value_typed(); const bNodeSocketValueFloat *strength_data = - bke::node_find_socket(fromnode, SOCK_IN, "Strength") + bke::node_find_socket(*fromnode, SOCK_IN, "Strength") ->default_value_typed(); res->background_found = true; @@ -249,7 +249,7 @@ static bool node_search(bNode *fromnode, if (fromnode->custom1 == NODE_VECTOR_MATH_MULTIPLY) { res->mult_found = true; - bNodeSocket *vec_sock = bke::node_find_socket(fromnode, SOCK_IN, "Vector"); + bNodeSocket *vec_sock = bke::node_find_socket(*fromnode, SOCK_IN, "Vector"); if (vec_sock) { vec_sock = vec_sock->next; } @@ -261,7 +261,7 @@ static bool node_search(bNode *fromnode, } else if (res->env_tex_found && fromnode->type_legacy == SH_NODE_MAPPING) { copy_v3_fl(res->mapping_rot, 0.0f); - if (bNodeSocket *socket = bke::node_find_socket(fromnode, SOCK_IN, "Rotation")) { + if (bNodeSocket *socket = bke::node_find_socket(*fromnode, SOCK_IN, "Rotation")) { const bNodeSocketValueVector *rot_value = static_cast( socket->default_value); copy_v3_v3(res->mapping_rot, rot_value->value); @@ -437,7 +437,7 @@ void dome_light_to_world_material(const USDImportParams ¶ms, /* Create the output and background shader nodes, if they don't exist. */ if (!output) { - output = bke::node_add_static_node(nullptr, ntree, SH_NODE_OUTPUT_WORLD); + output = bke::node_add_static_node(nullptr, *ntree, SH_NODE_OUTPUT_WORLD); if (!output) { CLOG_WARN(&LOG, "Couldn't create world output node"); @@ -457,15 +457,15 @@ void dome_light_to_world_material(const USDImportParams ¶ms, } /* Set the default background color. */ - bNodeSocket *color_sock = bke::node_find_socket(bgshader, SOCK_IN, "Color"); + bNodeSocket *color_sock = bke::node_find_socket(*bgshader, SOCK_IN, "Color"); copy_v3_v3(((bNodeSocketValueRGBA *)color_sock->default_value)->value, &scene->world->horr); } /* Make sure the first input to the shader node is disconnected. */ - bNodeSocket *shader_input = bke::node_find_socket(bgshader, SOCK_IN, "Color"); + bNodeSocket *shader_input = bke::node_find_socket(*bgshader, SOCK_IN, "Color"); if (shader_input && shader_input->link) { - bke::node_remove_link(ntree, shader_input->link); + bke::node_remove_link(ntree, *shader_input->link); } /* Set the background shader intensity. */ @@ -478,7 +478,7 @@ void dome_light_to_world_material(const USDImportParams ¶ms, intensity *= params.light_intensity_scale; - bNodeSocket *strength_sock = bke::node_find_socket(bgshader, SOCK_IN, "Strength"); + bNodeSocket *strength_sock = bke::node_find_socket(*bgshader, SOCK_IN, "Strength"); ((bNodeSocketValueFloat *)strength_sock->default_value)->value = intensity; /* Get the dome light texture file and color. */ @@ -497,11 +497,11 @@ void dome_light_to_world_material(const USDImportParams ¶ms, /* No texture file is authored on the dome light. Set the color, if it was authored, * and return early. */ if (has_color) { - bNodeSocket *color_sock = bke::node_find_socket(bgshader, SOCK_IN, "Color"); + bNodeSocket *color_sock = bke::node_find_socket(*bgshader, SOCK_IN, "Color"); copy_v3_v3(((bNodeSocketValueRGBA *)color_sock->default_value)->value, color.data()); } - bke::node_set_active(ntree, output); + bke::node_set_active(*ntree, *output); BKE_ntree_update_after_single_tree_change(*bmain, *ntree); return; @@ -522,7 +522,7 @@ void dome_light_to_world_material(const USDImportParams ¶ms, mult->custom1 = NODE_VECTOR_MATH_MULTIPLY; /* Set the color in the vector math node's second socket. */ - bNodeSocket *vec_sock = bke::node_find_socket(mult, SOCK_IN, "Vector"); + bNodeSocket *vec_sock = bke::node_find_socket(*mult, SOCK_IN, "Vector"); if (vec_sock) { vec_sock = vec_sock->next; } @@ -608,13 +608,13 @@ void dome_light_to_world_material(const USDImportParams ¶ms, /* Convert degrees to radians. */ rot_vec *= M_PI / 180.0f; - if (bNodeSocket *socket = bke::node_find_socket(mapping, SOCK_IN, "Rotation")) { + if (bNodeSocket *socket = bke::node_find_socket(*mapping, SOCK_IN, "Rotation")) { bNodeSocketValueVector *rot_value = static_cast( socket->default_value); copy_v3_v3(rot_value->value, rot_vec.data()); } - bke::node_set_active(ntree, output); + bke::node_set_active(*ntree, *output); DEG_id_tag_update(&ntree->id, ID_RECALC_NTREE_OUTPUT); BKE_ntree_update_after_single_tree_change(*bmain, *ntree); } diff --git a/source/blender/io/usd/intern/usd_reader_material.cc b/source/blender/io/usd/intern/usd_reader_material.cc index 19b2667524a..696fa3d3774 100644 --- a/source/blender/io/usd/intern/usd_reader_material.cc +++ b/source/blender/io/usd/intern/usd_reader_material.cc @@ -134,7 +134,7 @@ static void cache_node(ShaderToNodeMap &node_cache, static bNode *add_node( const bContext *C, bNodeTree *ntree, const int type, const float locx, const float locy) { - bNode *new_node = blender::bke::node_add_static_node(C, ntree, type); + bNode *new_node = blender::bke::node_add_static_node(C, *ntree, type); if (new_node) { new_node->location[0] = locx; @@ -148,21 +148,21 @@ static bNode *add_node( static void link_nodes( bNodeTree *ntree, bNode *source, const char *sock_out, bNode *dest, const char *sock_in) { - bNodeSocket *source_socket = blender::bke::node_find_socket(source, SOCK_OUT, sock_out); + bNodeSocket *source_socket = blender::bke::node_find_socket(*source, SOCK_OUT, sock_out); if (!source_socket) { CLOG_ERROR(&LOG, "Couldn't find output socket %s", sock_out); return; } - bNodeSocket *dest_socket = blender::bke::node_find_socket(dest, SOCK_IN, sock_in); + bNodeSocket *dest_socket = blender::bke::node_find_socket(*dest, SOCK_IN, sock_in); if (!dest_socket) { CLOG_ERROR(&LOG, "Couldn't find input socket %s", sock_in); return; } /* Only add the link if this is the first one to be connected. */ - if (blender::bke::node_count_socket_links(ntree, dest_socket) == 0) { - blender::bke::node_add_link(ntree, source, source_socket, dest, dest_socket); + if (blender::bke::node_count_socket_links(*ntree, *dest_socket) == 0) { + blender::bke::node_add_link(*ntree, *source, *source_socket, *dest, *dest_socket); } } @@ -410,7 +410,7 @@ static pxr::UsdShadeInput get_input(const pxr::UsdShadeShader &usd_shader, static bNodeSocket *get_input_socket(bNode *node, const char *identifier, ReportList *reports) { - bNodeSocket *sock = blender::bke::node_find_socket(node, SOCK_IN, identifier); + bNodeSocket *sock = blender::bke::node_find_socket(*node, SOCK_IN, identifier); if (!sock) { BKE_reportf(reports, RPT_ERROR, @@ -541,7 +541,7 @@ void USDMaterialReader::import_usd_preview_nodes(Material *mtl, mtl->displacement_method = MA_DISPLACEMENT_BOTH; } - blender::bke::node_set_active(ntree, output); + blender::bke::node_set_active(*ntree, *output); BKE_ntree_update_after_single_tree_change(*bmain_, *ntree); @@ -585,7 +585,7 @@ void USDMaterialReader::set_principled_node_inputs(bNode *principled, } bNodeSocket *emission_strength_sock = blender::bke::node_find_socket( - principled, SOCK_IN, "Emission Strength"); + *principled, SOCK_IN, "Emission Strength"); ((bNodeSocketValueFloat *)emission_strength_sock->default_value)->value = emission_strength; if (pxr::UsdShadeInput specular_input = usd_shader.GetInput(usdtokens::specularColor)) { @@ -657,7 +657,7 @@ bool USDMaterialReader::set_displacement_node_inputs(bNodeTree *ntree, /* If the displacement input is not connected, then this is "constant" displacement. * We need to adjust the Height input by our default Midlevel value of 0.5. */ if (!displacement_input.HasConnectedSource()) { - bNodeSocket *sock = blender::bke::node_find_socket(displacement_node, SOCK_IN, sock_name); + bNodeSocket *sock = blender::bke::node_find_socket(*displacement_node, SOCK_IN, sock_name); if (!sock) { CLOG_ERROR(&LOG, "Couldn't get destination node socket %s", sock_name); return false; @@ -691,7 +691,7 @@ bool USDMaterialReader::set_node_input(const pxr::UsdShadeInput &usd_input, /* Set the destination node socket value from the USD shader input value. */ - bNodeSocket *sock = blender::bke::node_find_socket(dest_node, SOCK_IN, dest_socket_name); + bNodeSocket *sock = blender::bke::node_find_socket(*dest_node, SOCK_IN, dest_socket_name); if (!sock) { CLOG_ERROR(&LOG, "Couldn't get destination node socket %s", dest_socket_name); return false; @@ -825,8 +825,9 @@ static IntermediateNode add_scale_bias(const pxr::UsdShadeShader &usd_shader, scale_bias.sock_input_name = "Vector"; scale_bias.sock_output_name = "Vector"; - bNodeSocket *sock_scale = blender::bke::node_find_socket(scale_bias.node, SOCK_IN, "Vector_001"); - bNodeSocket *sock_bias = blender::bke::node_find_socket(scale_bias.node, SOCK_IN, "Vector_002"); + bNodeSocket *sock_scale = blender::bke::node_find_socket( + *scale_bias.node, SOCK_IN, "Vector_001"); + bNodeSocket *sock_bias = blender::bke::node_find_socket(*scale_bias.node, SOCK_IN, "Vector_002"); copy_v3_v3(((bNodeSocketValueVector *)sock_scale->default_value)->value, scale.data()); copy_v3_v3(((bNodeSocketValueVector *)sock_bias->default_value)->value, bias.data()); @@ -847,8 +848,8 @@ static IntermediateNode add_scale_bias_adjust(bNodeTree *ntree, adjust.sock_input_name = "Vector"; adjust.sock_output_name = "Vector"; - bNodeSocket *sock_scale = blender::bke::node_find_socket(adjust.node, SOCK_IN, "Vector_001"); - bNodeSocket *sock_bias = blender::bke::node_find_socket(adjust.node, SOCK_IN, "Vector_002"); + bNodeSocket *sock_scale = blender::bke::node_find_socket(*adjust.node, SOCK_IN, "Vector_001"); + bNodeSocket *sock_bias = blender::bke::node_find_socket(*adjust.node, SOCK_IN, "Vector_002"); copy_v3_fl3(((bNodeSocketValueVector *)sock_scale->default_value)->value, 0.5f, 0.5f, 0.5f); copy_v3_fl3(((bNodeSocketValueVector *)sock_bias->default_value)->value, 0.5f, 0.5f, 0.5f); @@ -910,7 +911,7 @@ static IntermediateNode add_lessthan(bNodeTree *ntree, lessthan.sock_input_name = "Value"; lessthan.sock_output_name = "Value"; - bNodeSocket *thresh_sock = blender::bke::node_find_socket(lessthan.node, SOCK_IN, "Value_001"); + bNodeSocket *thresh_sock = blender::bke::node_find_socket(*lessthan.node, SOCK_IN, "Value_001"); ((bNodeSocketValueFloat *)thresh_sock->default_value)->value = threshold; return lessthan; @@ -929,7 +930,7 @@ static IntermediateNode add_oneminus(bNodeTree *ntree, int column, NodePlacement oneminus.sock_input_name = "Value_001"; oneminus.sock_output_name = "Value"; - bNodeSocket *val_sock = blender::bke::node_find_socket(oneminus.node, SOCK_IN, "Value"); + bNodeSocket *val_sock = blender::bke::node_find_socket(*oneminus.node, SOCK_IN, "Value"); ((bNodeSocketValueFloat *)val_sock->default_value)->value = 1.0f; return oneminus; @@ -955,8 +956,8 @@ static void configure_displacement(const pxr::UsdShadeShader &usd_shader, bNode const float scale_avg = (scale[0] + scale[1] + scale[2]) / 3.0f; const float bias_avg = (bias[0] + bias[1] + bias[2]) / 3.0f; - bNodeSocket *sock_mid = blender::bke::node_find_socket(displacement_node, SOCK_IN, "Midlevel"); - bNodeSocket *sock_scale = blender::bke::node_find_socket(displacement_node, SOCK_IN, "Scale"); + bNodeSocket *sock_mid = blender::bke::node_find_socket(*displacement_node, SOCK_IN, "Midlevel"); + bNodeSocket *sock_scale = blender::bke::node_find_socket(*displacement_node, SOCK_IN, "Scale"); ((bNodeSocketValueFloat *)sock_mid->default_value)->value = -1.0f * (bias_avg / scale_avg); ((bNodeSocketValueFloat *)sock_scale->default_value)->value = scale_avg; } diff --git a/source/blender/io/usd/intern/usd_reader_pointinstancer.cc b/source/blender/io/usd/intern/usd_reader_pointinstancer.cc index bcb9b3386ea..11eea849f37 100644 --- a/source/blender/io/usd/intern/usd_reader_pointinstancer.cc +++ b/source/blender/io/usd/intern/usd_reader_pointinstancer.cc @@ -29,11 +29,11 @@ namespace blender::io::usd { */ static bNode *add_input_named_attrib_node(bNodeTree *ntree, const char *name, int8_t prop_type) { - bNode *node = bke::node_add_static_node(nullptr, ntree, GEO_NODE_INPUT_NAMED_ATTRIBUTE); + bNode *node = bke::node_add_static_node(nullptr, *ntree, GEO_NODE_INPUT_NAMED_ATTRIBUTE); auto *storage = reinterpret_cast(node->storage); storage->data_type = prop_type; - bNodeSocket *socket = bke::node_find_socket(node, SOCK_IN, "Name"); + bNodeSocket *socket = bke::node_find_socket(*node, SOCK_IN, "Name"); bNodeSocketValueString *str_value = static_cast(socket->default_value); BLI_strncpy(str_value->value, name, MAX_NAME); return node; @@ -170,16 +170,16 @@ void USDPointInstancerReader::read_object_data(Main *bmain, const double motionS "Geometry", "", "NodeSocketGeometry", NODE_INTERFACE_SOCKET_OUTPUT, nullptr); ntree->tree_interface.add_socket( "Geometry", "", "NodeSocketGeometry", NODE_INTERFACE_SOCKET_INPUT, nullptr); - bNode *group_input = bke::node_add_static_node(nullptr, ntree, NODE_GROUP_INPUT); + bNode *group_input = bke::node_add_static_node(nullptr, *ntree, NODE_GROUP_INPUT); group_input->location[0] = -400.0f; - bNode *group_output = bke::node_add_static_node(nullptr, ntree, NODE_GROUP_OUTPUT); + bNode *group_output = bke::node_add_static_node(nullptr, *ntree, NODE_GROUP_OUTPUT); group_output->location[0] = 500.0f; group_output->flag |= NODE_DO_OUTPUT; bNode *instance_on_points_node = bke::node_add_static_node( - nullptr, ntree, GEO_NODE_INSTANCE_ON_POINTS); + nullptr, *ntree, GEO_NODE_INSTANCE_ON_POINTS); instance_on_points_node->location[0] = 300.0f; - bNodeSocket *socket = bke::node_find_socket(instance_on_points_node, SOCK_IN, "Pick Instance"); + bNodeSocket *socket = bke::node_find_socket(*instance_on_points_node, SOCK_IN, "Pick Instance"); socket->default_value_typed()->value = true; bNode *mask_attrib_node = add_input_named_attrib_node(ntree, "mask", CD_PROP_BOOL); @@ -187,10 +187,10 @@ void USDPointInstancerReader::read_object_data(Main *bmain, const double motionS mask_attrib_node->location[1] = -100.0f; bNode *collection_info_node = bke::node_add_static_node( - nullptr, ntree, GEO_NODE_COLLECTION_INFO); + nullptr, *ntree, GEO_NODE_COLLECTION_INFO); collection_info_node->location[0] = 100.0f; collection_info_node->location[1] = -300.0f; - socket = bke::node_find_socket(collection_info_node, SOCK_IN, "Separate Children"); + socket = bke::node_find_socket(*collection_info_node, SOCK_IN, "Separate Children"); socket->default_value_typed()->value = true; bNode *indices_attrib_node = add_input_named_attrib_node(ntree, "proto_index", CD_PROP_INT32); @@ -206,47 +206,47 @@ void USDPointInstancerReader::read_object_data(Main *bmain, const double motionS scale_attrib_node->location[0] = 100.0f; scale_attrib_node->location[1] = -900.0f; - bke::node_add_link(ntree, - group_input, - static_cast(group_input->outputs.first), - instance_on_points_node, - bke::node_find_socket(instance_on_points_node, SOCK_IN, "Points")); - - bke::node_add_link(ntree, - mask_attrib_node, - bke::node_find_socket(mask_attrib_node, SOCK_OUT, "Attribute"), - instance_on_points_node, - bke::node_find_socket(instance_on_points_node, SOCK_IN, "Selection")); - - bke::node_add_link(ntree, - indices_attrib_node, - bke::node_find_socket(indices_attrib_node, SOCK_OUT, "Attribute"), - instance_on_points_node, - bke::node_find_socket(instance_on_points_node, SOCK_IN, "Instance Index")); - - bke::node_add_link(ntree, - scale_attrib_node, - bke::node_find_socket(scale_attrib_node, SOCK_OUT, "Attribute"), - instance_on_points_node, - bke::node_find_socket(instance_on_points_node, SOCK_IN, "Scale")); - - bke::node_add_link(ntree, - rotation_attrib_node, - bke::node_find_socket(rotation_attrib_node, SOCK_OUT, "Attribute"), - instance_on_points_node, - bke::node_find_socket(instance_on_points_node, SOCK_IN, "Rotation")); - - bke::node_add_link(ntree, - collection_info_node, - bke::node_find_socket(collection_info_node, SOCK_OUT, "Instances"), - instance_on_points_node, - bke::node_find_socket(instance_on_points_node, SOCK_IN, "Instance")); - - bke::node_add_link(ntree, - instance_on_points_node, - bke::node_find_socket(instance_on_points_node, SOCK_OUT, "Instances"), - group_output, - static_cast(group_output->inputs.first)); + bke::node_add_link(*ntree, + *group_input, + *static_cast(group_input->outputs.first), + *instance_on_points_node, + *bke::node_find_socket(*instance_on_points_node, SOCK_IN, "Points")); + + bke::node_add_link(*ntree, + *mask_attrib_node, + *bke::node_find_socket(*mask_attrib_node, SOCK_OUT, "Attribute"), + *instance_on_points_node, + *bke::node_find_socket(*instance_on_points_node, SOCK_IN, "Selection")); + + bke::node_add_link(*ntree, + *indices_attrib_node, + *bke::node_find_socket(*indices_attrib_node, SOCK_OUT, "Attribute"), + *instance_on_points_node, + *bke::node_find_socket(*instance_on_points_node, SOCK_IN, "Instance Index")); + + bke::node_add_link(*ntree, + *scale_attrib_node, + *bke::node_find_socket(*scale_attrib_node, SOCK_OUT, "Attribute"), + *instance_on_points_node, + *bke::node_find_socket(*instance_on_points_node, SOCK_IN, "Scale")); + + bke::node_add_link(*ntree, + *rotation_attrib_node, + *bke::node_find_socket(*rotation_attrib_node, SOCK_OUT, "Attribute"), + *instance_on_points_node, + *bke::node_find_socket(*instance_on_points_node, SOCK_IN, "Rotation")); + + bke::node_add_link(*ntree, + *collection_info_node, + *bke::node_find_socket(*collection_info_node, SOCK_OUT, "Instances"), + *instance_on_points_node, + *bke::node_find_socket(*instance_on_points_node, SOCK_IN, "Instance")); + + bke::node_add_link(*ntree, + *instance_on_points_node, + *bke::node_find_socket(*instance_on_points_node, SOCK_OUT, "Instances"), + *group_output, + *static_cast(group_output->inputs.first)); BKE_ntree_update_after_single_tree_change(*bmain, *ntree); @@ -282,13 +282,13 @@ void USDPointInstancerReader::set_collection(Main *bmain, Collection &coll) return; } - bNode *collection_node = bke::node_find_node_by_name(ntree, "Collection Info"); + bNode *collection_node = bke::node_find_node_by_name(*ntree, "Collection Info"); if (!collection_node) { BLI_assert_unreachable(); return; } - bNodeSocket *sock = bke::node_find_socket(collection_node, SOCK_IN, "Collection"); + bNodeSocket *sock = bke::node_find_socket(*collection_node, SOCK_IN, "Collection"); if (!sock) { BLI_assert_unreachable(); return; diff --git a/source/blender/io/usd/intern/usd_writer_material.cc b/source/blender/io/usd/intern/usd_writer_material.cc index 28d79da2530..ff5066e7a40 100644 --- a/source/blender/io/usd/intern/usd_writer_material.cc +++ b/source/blender/io/usd/intern/usd_writer_material.cc @@ -191,7 +191,7 @@ static void process_inputs(const USDExporterContext &usd_export_context, if (input_spec.input_name == usdtokens::emissive_color) { /* Don't export emission color if strength is zero. */ const bNodeSocket *emission_strength_sock = bke::node_find_socket( - node, SOCK_IN, "Emission Strength"); + *node, SOCK_IN, "Emission Strength"); if (!emission_strength_sock) { continue; } @@ -263,16 +263,17 @@ static void process_inputs(const USDExporterContext &usd_export_context, if (vector_math_node->custom1 == NODE_VECTOR_MATH_MULTIPLY_ADD) { /* Attempt one more traversal in case the current node is not the * correct NODE_VECTOR_MATH_MULTIPLY_ADD (see code in usd_reader_material). */ - bNodeSocket *sock_current = bke::node_find_socket(vector_math_node, SOCK_IN, "Vector"); + bNodeSocket *sock_current = bke::node_find_socket( + *vector_math_node, SOCK_IN, "Vector"); bNodeLink *temp_link = traverse_channel(sock_current, SH_NODE_VECTOR_MATH); if (temp_link && temp_link->fromnode->custom1 == NODE_VECTOR_MATH_MULTIPLY_ADD) { vector_math_node = temp_link->fromnode; } bNodeSocket *sock_scale = bke::node_find_socket( - vector_math_node, SOCK_IN, "Vector_001"); + *vector_math_node, SOCK_IN, "Vector_001"); bNodeSocket *sock_bias = bke::node_find_socket( - vector_math_node, SOCK_IN, "Vector_002"); + *vector_math_node, SOCK_IN, "Vector_002"); const float *scale_value = static_cast(sock_scale->default_value)->value; const float *bias_value = @@ -285,8 +286,8 @@ static void process_inputs(const USDExporterContext &usd_export_context, } } else { - const bNodeSocket *sock_midlevel = bke::node_find_socket(node, SOCK_IN, "Midlevel"); - const bNodeSocket *sock_scale = bke::node_find_socket(node, SOCK_IN, "Scale"); + const bNodeSocket *sock_midlevel = bke::node_find_socket(*node, SOCK_IN, "Midlevel"); + const bNodeSocket *sock_scale = bke::node_find_socket(*node, SOCK_IN, "Scale"); const float midlevel_value = sock_midlevel->default_value_typed()->value; const float scale_value = sock_scale->default_value_typed()->value; @@ -298,7 +299,7 @@ static void process_inputs(const USDExporterContext &usd_export_context, } /* Look for a connected uvmap node. */ - if (bNodeSocket *socket = bke::node_find_socket(input_node, SOCK_IN, "Vector")) { + if (bNodeSocket *socket = bke::node_find_socket(*input_node, SOCK_IN, "Vector")) { if (pxr::UsdShadeInput st_input = usd_shader.CreateInput(usdtokens::st, pxr::SdfValueTypeNames->Float2)) { @@ -321,9 +322,9 @@ static void process_inputs(const USDExporterContext &usd_export_context, } else if (math_node->custom1 == NODE_MATH_SUBTRACT) { /* If this is the 1-minus node, we need to search upstream to find the less-than. */ - bNodeSocket *math_sock = blender::bke::node_find_socket(math_node, SOCK_IN, "Value"); + bNodeSocket *math_sock = blender::bke::node_find_socket(*math_node, SOCK_IN, "Value"); if (((bNodeSocketValueFloat *)math_sock->default_value)->value == 1.0f) { - math_sock = blender::bke::node_find_socket(math_node, SOCK_IN, "Value_001"); + math_sock = blender::bke::node_find_socket(*math_node, SOCK_IN, "Value_001"); math_link = traverse_channel(math_sock, SH_NODE_MATH); if (math_link && math_link->fromnode) { math_node = math_link->fromnode; @@ -331,7 +332,7 @@ static void process_inputs(const USDExporterContext &usd_export_context, if (math_node->custom1 == NODE_MATH_LESS_THAN) { /* We found the upstream less-than with the threshold value. */ bNodeSocket *threshold_sock = blender::bke::node_find_socket( - math_node, SOCK_IN, "Value_001"); + *math_node, SOCK_IN, "Value_001"); threshold = ((bNodeSocketValueFloat *)threshold_sock->default_value)->value; } } @@ -403,8 +404,8 @@ static void create_usd_preview_surface_material(const USDExporterContext &usd_ex return; } - bNodeSocket *sock_mid = bke::node_find_socket(displacement_node, SOCK_IN, "Midlevel"); - bNodeSocket *sock_scale = bke::node_find_socket(displacement_node, SOCK_IN, "Scale"); + bNodeSocket *sock_mid = bke::node_find_socket(*displacement_node, SOCK_IN, "Midlevel"); + bNodeSocket *sock_scale = bke::node_find_socket(*displacement_node, SOCK_IN, "Scale"); if (sock_mid->link || sock_scale->link) { CLOG_WARN(&LOG, "Skipping displacement. Midlevel and Scale must be constants."); return; @@ -413,7 +414,7 @@ static void create_usd_preview_surface_material(const USDExporterContext &usd_ex usd_material.CreateDisplacementOutput().ConnectToSource(preview_surface.ConnectableAPI(), usdtokens::displacement); - bNodeSocket *sock_height = bke::node_find_socket(displacement_node, SOCK_IN, "Height"); + bNodeSocket *sock_height = bke::node_find_socket(*displacement_node, SOCK_IN, "Height"); if (sock_height->link) { process_inputs(usd_export_context, usd_material, @@ -579,7 +580,7 @@ static void create_transform2d_shader(const USDExporterContext &usd_export_conte } if (mapping_node->custom1 != TEXMAP_TYPE_POINT) { - if (bNodeSocket *socket = bke::node_find_socket(mapping_node, SOCK_IN, "Vector")) { + if (bNodeSocket *socket = bke::node_find_socket(*mapping_node, SOCK_IN, "Vector")) { create_uv_input(usd_export_context, socket, usd_material, usd_input, uvmap_name, reports); } return; @@ -599,19 +600,19 @@ static void create_transform2d_shader(const USDExporterContext &usd_export_conte float loc[3] = {0.0f, 0.0f, 0.0f}; float rot[3] = {0.0f, 0.0f, 0.0f}; - if (bNodeSocket *scale_socket = bke::node_find_socket(mapping_node, SOCK_IN, "Scale")) { + if (bNodeSocket *scale_socket = bke::node_find_socket(*mapping_node, SOCK_IN, "Scale")) { copy_v3_v3(scale, ((bNodeSocketValueVector *)scale_socket->default_value)->value); /* Ignore the Z scale. */ scale[2] = 1.0f; } - if (bNodeSocket *loc_socket = bke::node_find_socket(mapping_node, SOCK_IN, "Location")) { + if (bNodeSocket *loc_socket = bke::node_find_socket(*mapping_node, SOCK_IN, "Location")) { copy_v3_v3(loc, ((bNodeSocketValueVector *)loc_socket->default_value)->value); /* Ignore the Z translation. */ loc[2] = 0.0f; } - if (bNodeSocket *rot_socket = bke::node_find_socket(mapping_node, SOCK_IN, "Rotation")) { + if (bNodeSocket *rot_socket = bke::node_find_socket(*mapping_node, SOCK_IN, "Rotation")) { copy_v3_v3(rot, ((bNodeSocketValueVector *)rot_socket->default_value)->value); /* Ignore the X and Y rotations. */ rot[0] = 0.0f; @@ -640,7 +641,7 @@ static void create_transform2d_shader(const USDExporterContext &usd_export_conte rot_input.Set(rot_val); } - if (bNodeSocket *socket = bke::node_find_socket(mapping_node, SOCK_IN, "Vector")) { + if (bNodeSocket *socket = bke::node_find_socket(*mapping_node, SOCK_IN, "Vector")) { if (pxr::UsdShadeInput in_input = transform2d_shader.CreateInput( usdtokens::in, pxr::SdfValueTypeNames->Float2)) { diff --git a/source/blender/io/wavefront_obj/exporter/obj_export_mtl.cc b/source/blender/io/wavefront_obj/exporter/obj_export_mtl.cc index c595485e298..b25832a141e 100644 --- a/source/blender/io/wavefront_obj/exporter/obj_export_mtl.cc +++ b/source/blender/io/wavefront_obj/exporter/obj_export_mtl.cc @@ -52,7 +52,7 @@ static void copy_property_from_node(const eNodeSocketDatatype property_type, return; } const bNodeSocket *socket = bke::node_find_socket( - const_cast(node), SOCK_IN, identifier); + *const_cast(node), SOCK_IN, identifier); BLI_assert(socket && socket->type == property_type); if (!socket) { return; diff --git a/source/blender/io/wavefront_obj/importer/obj_import_mtl.cc b/source/blender/io/wavefront_obj/importer/obj_import_mtl.cc index d24d7eb56c9..c3ae9cb0ae1 100644 --- a/source/blender/io/wavefront_obj/importer/obj_import_mtl.cc +++ b/source/blender/io/wavefront_obj/importer/obj_import_mtl.cc @@ -38,7 +38,7 @@ static void set_property_of_socket(eNodeSocketDatatype property_type, bNode *r_node) { BLI_assert(r_node); - bNodeSocket *socket{bke::node_find_socket(r_node, SOCK_IN, socket_id)}; + bNodeSocket *socket{bke::node_find_socket(*r_node, SOCK_IN, socket_id)}; BLI_assert(socket && socket->type == property_type); switch (property_type) { case SOCK_FLOAT: { @@ -158,7 +158,7 @@ const float node_locy_step = 300.0f; /* Add a node of the given type at the given location. */ static bNode *add_node(bNodeTree *ntree, int type, float x, float y) { - bNode *node = bke::node_add_static_node(nullptr, ntree, type); + bNode *node = bke::node_add_static_node(nullptr, *ntree, type); node->location[0] = x; node->location[1] = y; return node; @@ -170,10 +170,10 @@ static void link_sockets(bNodeTree *ntree, bNode *to_node, const char *to_node_id) { - bNodeSocket *from_sock{bke::node_find_socket(from_node, SOCK_OUT, from_node_id)}; - bNodeSocket *to_sock{bke::node_find_socket(to_node, SOCK_IN, to_node_id)}; + bNodeSocket *from_sock{bke::node_find_socket(*from_node, SOCK_OUT, from_node_id)}; + bNodeSocket *to_sock{bke::node_find_socket(*to_node, SOCK_IN, to_node_id)}; BLI_assert(from_sock && to_sock); - bke::node_add_link(ntree, from_node, from_sock, to_node, to_sock); + bke::node_add_link(*ntree, *from_node, *from_sock, *to_node, *to_sock); } static void set_bsdf_socket_values(bNode *bsdf, Material *mat, const MTLMaterial &mtl_mat) @@ -428,7 +428,7 @@ bNodeTree *create_mtl_node_tree(Main *bmain, set_bsdf_socket_values(bsdf, mat, mtl_mat); add_image_textures(bmain, ntree, bsdf, mat, mtl_mat, relative_paths); link_sockets(ntree, bsdf, "BSDF", output, "Surface"); - bke::node_set_active(ntree, output); + bke::node_set_active(*ntree, *output); return ntree; } diff --git a/source/blender/makesrna/intern/rna_material.cc b/source/blender/makesrna/intern/rna_material.cc index 2b509a740e3..83322c8c60f 100644 --- a/source/blender/makesrna/intern/rna_material.cc +++ b/source/blender/makesrna/intern/rna_material.cc @@ -156,7 +156,7 @@ static void rna_Material_active_paint_texture_index_update(bContext *C, PointerR bNode *node = BKE_texpaint_slot_material_find_node(ma, ma->paint_active_slot); if (node) { - blender::bke::node_set_active(ma->nodetree, node); + blender::bke::node_set_active(*ma->nodetree, *node); } } diff --git a/source/blender/makesrna/intern/rna_node_socket.cc b/source/blender/makesrna/intern/rna_node_socket.cc index 144645cf168..1eb7320988e 100644 --- a/source/blender/makesrna/intern/rna_node_socket.cc +++ b/source/blender/makesrna/intern/rna_node_socket.cc @@ -141,7 +141,7 @@ static bool rna_NodeSocket_unregister(Main *bmain, StructRNA *type) RNA_struct_free_extension(type, &st->ext_socket); RNA_struct_free(&BLENDER_RNA, type); - blender::bke::node_unregister_socket_type(st); + blender::bke::node_unregister_socket_type(*st); /* update while blender is running */ WM_main_add_notifier(NC_NODE | NA_EDITED, nullptr); @@ -188,7 +188,7 @@ static StructRNA *rna_NodeSocket_register(Main *bmain, if (!st) { /* create a new node socket type */ st = MEM_new(__func__, dummy_st); - blender::bke::node_register_socket_type(st); + blender::bke::node_register_socket_type(*st); } st->free_self = [](blender::bke::bNodeSocketType *stype) { MEM_delete(stype); }; @@ -372,7 +372,7 @@ static bool rna_NodeSocket_is_output_get(PointerRNA *ptr) static int rna_NodeSocket_link_limit_get(PointerRNA *ptr) { bNodeSocket *sock = static_cast(ptr->data); - return blender::bke::node_socket_link_limit(sock); + return blender::bke::node_socket_link_limit(*sock); } static void rna_NodeSocket_link_limit_set(PointerRNA *ptr, int value) diff --git a/source/blender/makesrna/intern/rna_node_tree_interface.cc b/source/blender/makesrna/intern/rna_node_tree_interface.cc index 7c87015e7ec..7763ff69aa7 100644 --- a/source/blender/makesrna/intern/rna_node_tree_interface.cc +++ b/source/blender/makesrna/intern/rna_node_tree_interface.cc @@ -290,7 +290,7 @@ static StructRNA *rna_NodeTreeInterfaceSocket_register(Main * /*bmain*/, st = MEM_new(__func__); st->idname = dummy_socket.socket_type; - blender::bke::node_register_socket_type(st); + blender::bke::node_register_socket_type(*st); } st->free_self = [](blender::bke::bNodeSocketType *type) { MEM_delete(type); }; diff --git a/source/blender/makesrna/intern/rna_nodetree.cc b/source/blender/makesrna/intern/rna_nodetree.cc index 56f050ec21b..7182d33c7e3 100644 --- a/source/blender/makesrna/intern/rna_nodetree.cc +++ b/source/blender/makesrna/intern/rna_nodetree.cc @@ -771,7 +771,7 @@ const EnumPropertyItem *rna_node_socket_type_itemf( tmp.value = i; tmp.identifier = stype->idname.c_str(); tmp.icon = RNA_struct_ui_icon(srna); - tmp.name = blender::bke::node_socket_type_label(stype).c_str(); + tmp.name = blender::bke::node_socket_type_label(*stype).c_str(); tmp.description = RNA_struct_ui_description(srna); RNA_enum_item_add(&item, &totitem, &tmp); @@ -1033,7 +1033,7 @@ static bool rna_NodeTree_unregister(Main *bmain, StructRNA *type) RNA_struct_free_extension(type, &nt->rna_ext); RNA_struct_free(&BLENDER_RNA, type); - blender::bke::node_tree_type_free_link(nt); + blender::bke::node_tree_type_free_link(*nt); /* update while blender is running */ WM_main_add_notifier(NC_NODE | NA_EDITED, nullptr); @@ -1113,7 +1113,7 @@ static StructRNA *rna_NodeTree_register(Main *bmain, nt->get_from_context = (have_function[2]) ? rna_NodeTree_get_from_context : nullptr; nt->valid_socket_type = (have_function[3]) ? rna_NodeTree_valid_socket_type : nullptr; - blender::bke::node_tree_type_add(nt); + blender::bke::node_tree_type_add(*nt); /* update while blender is running */ WM_main_add_notifier(NC_NODE | NA_EDITED, nullptr); @@ -1123,7 +1123,7 @@ static StructRNA *rna_NodeTree_register(Main *bmain, static bool rna_NodeTree_check(bNodeTree *ntree, ReportList *reports) { - if (!blender::bke::node_tree_is_registered(ntree)) { + if (!blender::bke::node_tree_is_registered(*ntree)) { if (reports) { BKE_reportf(reports, RPT_ERROR, @@ -1249,7 +1249,7 @@ static bNode *rna_NodeTree_node_new(bNodeTree *ntree, } } - node = blender::bke::node_add_node(C, ntree, type); + node = blender::bke::node_add_node(C, *ntree, type); BLI_assert(node && node->typeinfo); if (ntree->type == NTREE_TEXTURE) { @@ -1279,7 +1279,7 @@ static void rna_NodeTree_node_remove(bNodeTree *ntree, return; } - blender::bke::node_remove_node(bmain, ntree, node, true); + blender::bke::node_remove_node(bmain, *ntree, *node, true); node_ptr->invalidate(); @@ -1298,7 +1298,7 @@ static void rna_NodeTree_node_clear(bNodeTree *ntree, Main *bmain, ReportList *r while (node) { bNode *next_node = node->next; - blender::bke::node_remove_node(bmain, ntree, node, true); + blender::bke::node_remove_node(bmain, *ntree, *node, true); node = next_node; } @@ -1310,7 +1310,7 @@ static void rna_NodeTree_node_clear(bNodeTree *ntree, Main *bmain, ReportList *r static PointerRNA rna_NodeTree_active_node_get(PointerRNA *ptr) { bNodeTree *ntree = static_cast(ptr->data); - bNode *node = blender::bke::node_get_active(ntree); + bNode *node = blender::bke::node_get_active(*ntree); return RNA_pointer_create_with_parent(*ptr, &RNA_Node, node); } @@ -1322,7 +1322,7 @@ static void rna_NodeTree_active_node_set(PointerRNA *ptr, bNode *node = static_cast(value.data); if (node && BLI_findindex(&ntree->nodes, node) != -1) { - blender::bke::node_set_active(ntree, node); + blender::bke::node_set_active(*ntree, *node); /* Handle NODE_DO_OUTPUT as well. */ if (node->typeinfo->nclass == NODE_CLASS_OUTPUT && node->type_legacy != CMP_NODE_OUTPUT_FILE) { @@ -1334,12 +1334,12 @@ static void rna_NodeTree_active_node_set(PointerRNA *ptr, } } node->flag |= NODE_DO_OUTPUT; - blender::bke::node_tree_set_output(ntree); + blender::bke::node_tree_set_output(*ntree); BKE_ntree_update_tag_active_output_changed(ntree); } } else { - blender::bke::node_clear_active(ntree); + blender::bke::node_clear_active(*ntree); } } @@ -1412,37 +1412,35 @@ static bNodeLink *rna_NodeTree_link_new(bNodeTree *ntree, if (verify_limits) { /* remove other socket links if limit is exceeded */ - if (blender::bke::node_count_socket_links(ntree, fromsock) + 1 > - blender::bke::node_socket_link_limit(fromsock)) + if (blender::bke::node_count_socket_links(*ntree, *fromsock) + 1 > + blender::bke::node_socket_link_limit(*fromsock)) { - blender::bke::node_remove_socket_links(ntree, fromsock); + blender::bke::node_remove_socket_links(*ntree, *fromsock); } - if (blender::bke::node_count_socket_links(ntree, tosock) + 1 > - blender::bke::node_socket_link_limit(tosock)) + if (blender::bke::node_count_socket_links(*ntree, *tosock) + 1 > + blender::bke::node_socket_link_limit(*tosock)) { - blender::bke::node_remove_socket_links(ntree, tosock); + blender::bke::node_remove_socket_links(*ntree, *tosock); } if (tosock->flag & SOCK_MULTI_INPUT) { LISTBASE_FOREACH_MUTABLE (bNodeLink *, link, &ntree->links) { if (link->fromsock == fromsock && link->tosock == tosock) { - blender::bke::node_remove_link(ntree, link); + blender::bke::node_remove_link(ntree, *link); } } } } - bNodeLink *ret = blender::bke::node_add_link(ntree, fromnode, fromsock, tonode, tosock); + bNodeLink &ret = blender::bke::node_add_link(*ntree, *fromnode, *fromsock, *tonode, *tosock); - if (ret) { + /* not an issue from the UI, clear hidden from API to keep valid state. */ + fromsock->flag &= ~SOCK_HIDDEN; + tosock->flag &= ~SOCK_HIDDEN; - /* not an issue from the UI, clear hidden from API to keep valid state. */ - fromsock->flag &= ~SOCK_HIDDEN; - tosock->flag &= ~SOCK_HIDDEN; + BKE_main_ensure_invariants(*bmain, ntree->id); + WM_main_add_notifier(NC_NODE | NA_EDITED, ntree); - BKE_main_ensure_invariants(*bmain, ntree->id); - WM_main_add_notifier(NC_NODE | NA_EDITED, ntree); - } - return ret; + return &ret; } static void rna_NodeTree_link_remove(bNodeTree *ntree, @@ -1461,7 +1459,7 @@ static void rna_NodeTree_link_remove(bNodeTree *ntree, return; } - blender::bke::node_remove_link(ntree, link); + blender::bke::node_remove_link(ntree, *link); link_ptr->invalidate(); BKE_main_ensure_invariants(*bmain, ntree->id); @@ -1479,7 +1477,7 @@ static void rna_NodeTree_link_clear(bNodeTree *ntree, Main *bmain, ReportList *r while (link) { bNodeLink *next_link = link->next; - blender::bke::node_remove_link(ntree, link); + blender::bke::node_remove_link(ntree, *link); link = next_link; } @@ -1489,7 +1487,7 @@ static void rna_NodeTree_link_clear(bNodeTree *ntree, Main *bmain, ReportList *r static bool rna_NodeTree_contains_tree(bNodeTree *tree, bNodeTree *sub_tree) { - return blender::bke::node_tree_contains_tree(tree, sub_tree); + return blender::bke::node_tree_contains_tree(*tree, *sub_tree); } static void rna_NodeTree_bl_idname_get(PointerRNA *ptr, char *value) @@ -1644,7 +1642,7 @@ static void rna_NodeTree_interface_update(bNodeTree *ntree, bContext *C) static bool rna_NodeLink_is_hidden_get(PointerRNA *ptr) { bNodeLink *link = static_cast(ptr->data); - return blender::bke::node_link_is_hidden(link); + return blender::bke::node_link_is_hidden(*link); } static void rna_NodeLink_swap_multi_input_sort_id( @@ -1945,7 +1943,7 @@ static bool rna_Node_unregister(Main *bmain, StructRNA *type) RNA_struct_free(&BLENDER_RNA, type); /* this also frees the allocated nt pointer, no MEM_free call needed! */ - blender::bke::node_unregister_type(nt); + blender::bke::node_unregister_type(*nt); /* update while blender is running */ WM_main_add_notifier(NC_NODE | NA_EDITED, nullptr); @@ -1974,7 +1972,7 @@ static blender::bke::bNodeType *rna_Node_register_base(Main *bmain, /* setup dummy node & node type to store static properties in */ blender::bke::bNodeType dummy_nt = {}; /* this does some additional initialization of default values */ - blender::bke::node_type_base_custom(&dummy_nt, identifier, "", "CUSTOM", 0); + blender::bke::node_type_base_custom(dummy_nt, identifier, "", "CUSTOM", 0); memset(&dummy_node, 0, sizeof(bNode)); dummy_node.typeinfo = &dummy_nt; @@ -2086,7 +2084,7 @@ static StructRNA *rna_Node_register(Main *bmain, return nullptr; } - blender::bke::node_register_type(nt); + blender::bke::node_register_type(*nt); /* update while blender is running */ WM_main_add_notifier(NC_NODE | NA_EDITED, nullptr); @@ -2286,7 +2284,7 @@ static StructRNA *rna_ShaderNode_register(Main *bmain, return nullptr; } - blender::bke::node_register_type(nt); + blender::bke::node_register_type(*nt); /* update while blender is running */ WM_main_add_notifier(NC_NODE | NA_EDITED, nullptr); @@ -2308,7 +2306,7 @@ static StructRNA *rna_CompositorNode_register(Main *bmain, return nullptr; } - blender::bke::node_register_type(nt); + blender::bke::node_register_type(*nt); /* update while blender is running */ WM_main_add_notifier(NC_NODE | NA_EDITED, nullptr); @@ -2330,7 +2328,7 @@ static StructRNA *rna_TextureNode_register(Main *bmain, return nullptr; } - blender::bke::node_register_type(nt); + blender::bke::node_register_type(*nt); /* update while blender is running */ WM_main_add_notifier(NC_NODE | NA_EDITED, nullptr); @@ -2352,7 +2350,7 @@ static StructRNA *rna_GeometryNode_register(Main *bmain, return nullptr; } - blender::bke::node_register_type(nt); + blender::bke::node_register_type(*nt); /* update while blender is running */ WM_main_add_notifier(NC_NODE | NA_EDITED, nullptr); @@ -2374,7 +2372,7 @@ static StructRNA *rna_FunctionNode_register(Main *bmain, return nullptr; } - blender::bke::node_register_type(nt); + blender::bke::node_register_type(*nt); /* update while blender is running */ WM_main_add_notifier(NC_NODE | NA_EDITED, nullptr); @@ -2395,7 +2393,7 @@ static void rna_Node_parent_set(PointerRNA *ptr, PointerRNA value, ReportList * bNodeTree *ntree = reinterpret_cast(ptr->owner_id); if (!parent) { - blender::bke::node_detach_node(ntree, node); + blender::bke::node_detach_node(*ntree, *node); return; } @@ -2406,12 +2404,12 @@ static void rna_Node_parent_set(PointerRNA *ptr, PointerRNA value, ReportList * return; } - if (blender::bke::node_is_parent_and_child(node, parent)) { + if (blender::bke::node_is_parent_and_child(*node, *parent)) { return; } - blender::bke::node_detach_node(ntree, node); - blender::bke::node_attach_node(ntree, node, parent); + blender::bke::node_detach_node(*ntree, *node); + blender::bke::node_attach_node(*ntree, *node, *parent); } static void rna_Node_internal_links_begin(CollectionPropertyIterator *iter, PointerRNA *ptr) @@ -2419,7 +2417,7 @@ static void rna_Node_internal_links_begin(CollectionPropertyIterator *iter, Poin bNode *node = static_cast(ptr->data); bNodeLink *begin; int len; - blender::bke::node_internal_links(node, &begin, &len); + blender::bke::node_internal_links(*node, &begin, &len); rna_iterator_array_begin(iter, ptr, begin, sizeof(bNodeLink), len, false, nullptr); } @@ -2496,7 +2494,7 @@ static bool rna_Node_parent_poll(PointerRNA *ptr, PointerRNA value) return false; } - if (node->is_frame() && blender::bke::node_is_parent_and_child(node, parent)) { + if (node->is_frame() && blender::bke::node_is_parent_and_child(*node, *parent)) { return false; } @@ -2590,7 +2588,7 @@ static void rna_Node_socket_value_update(ID *id, bNode * /*node*/, bContext *C) static void rna_Node_select_set(PointerRNA *ptr, bool value) { bNode *node = static_cast(ptr->data); - blender::bke::node_set_selected(node, value); + blender::bke::node_set_selected(*node, value); } static void rna_Node_name_set(PointerRNA *ptr, const char *value) @@ -2604,7 +2602,7 @@ static void rna_Node_name_set(PointerRNA *ptr, const char *value) /* set new name */ STRNCPY_UTF8(node->name, value); - blender::bke::node_unique_name(ntree, node); + blender::bke::node_unique_name(*ntree, *node); /* fix all the animation data which may link to this */ BKE_animdata_fix_paths_rename_all(nullptr, "nodes", oldname, node->name); @@ -2686,7 +2684,8 @@ static bNodeSocket *rna_Node_inputs_new(ID *id, } bNodeTree *ntree = reinterpret_cast(id); - bNodeSocket *sock = blender::bke::node_add_socket(ntree, node, SOCK_IN, type, identifier, name); + bNodeSocket *sock = blender::bke::node_add_socket( + *ntree, *node, SOCK_IN, type, identifier, name); if (sock == nullptr) { BKE_report(reports, RPT_ERROR, "Unable to create socket"); @@ -2727,7 +2726,8 @@ static bNodeSocket *rna_Node_outputs_new(ID *id, } bNodeTree *ntree = reinterpret_cast(id); - bNodeSocket *sock = blender::bke::node_add_socket(ntree, node, SOCK_OUT, type, identifier, name); + bNodeSocket *sock = blender::bke::node_add_socket( + *ntree, *node, SOCK_OUT, type, identifier, name); if (sock == nullptr) { BKE_report(reports, RPT_ERROR, "Unable to create socket"); @@ -2754,7 +2754,7 @@ static void rna_Node_socket_remove( BKE_reportf(reports, RPT_ERROR, "Unable to locate socket '%s' in node", sock->identifier); } else { - blender::bke::node_remove_socket(ntree, node, sock); + blender::bke::node_remove_socket(*ntree, *node, *sock); BKE_main_ensure_invariants(*bmain, ntree->id); WM_main_add_notifier(NC_NODE | NA_EDITED, ntree); @@ -2773,7 +2773,7 @@ static void rna_Node_inputs_clear(ID *id, bNode *node, Main *bmain, ReportList * for (sock = static_cast(node->inputs.first); sock; sock = nextsock) { nextsock = sock->next; - blender::bke::node_remove_socket(ntree, node, sock); + blender::bke::node_remove_socket(*ntree, *node, *sock); } BKE_main_ensure_invariants(*bmain, ntree->id); @@ -2792,7 +2792,7 @@ static void rna_Node_outputs_clear(ID *id, bNode *node, Main *bmain, ReportList for (sock = static_cast(node->outputs.first); sock; sock = nextsock) { nextsock = sock->next; - blender::bke::node_remove_socket(ntree, node, sock); + blender::bke::node_remove_socket(*ntree, *node, *sock); } BKE_main_ensure_invariants(*bmain, ntree->id); @@ -2896,7 +2896,9 @@ static void rna_Node_height_range( static void rna_Node_dimensions_get(PointerRNA *ptr, float *value) { bNode *node = static_cast(ptr->data); - blender::bke::node_dimensions_get(node, &value[0], &value[1]); + const float2 dimensions = blender::bke::node_dimensions_get(*node); + value[0] = dimensions[0]; + value[1] = dimensions[1]; } /* ******** Node Types ******** */ @@ -3038,7 +3040,7 @@ static StructRNA *rna_NodeCustomGroup_register(Main *bmain, return nullptr; } - blender::bke::node_register_type(nt); + blender::bke::node_register_type(*nt); /* update while blender is running */ WM_main_add_notifier(NC_NODE | NA_EDITED, nullptr); @@ -3065,7 +3067,7 @@ static StructRNA *rna_GeometryNodeCustomGroup_register(Main *bmain, register_node_type_geo_custom_group(nt); - blender::bke::node_register_type(nt); + blender::bke::node_register_type(*nt); WM_main_add_notifier(NC_NODE | NA_EDITED, nullptr); @@ -3093,7 +3095,7 @@ static StructRNA *rna_ShaderNodeCustomGroup_register(Main *bmain, register_node_type_sh_custom_group(nt); - blender::bke::node_register_type(nt); + blender::bke::node_register_type(*nt); WM_main_add_notifier(NC_NODE | NA_EDITED, nullptr); @@ -3118,7 +3120,7 @@ static StructRNA *rna_CompositorNodeCustomGroup_register(Main *bmain, register_node_type_cmp_custom_group(nt); - blender::bke::node_register_type(nt); + blender::bke::node_register_type(*nt); WM_main_add_notifier(NC_NODE | NA_EDITED, nullptr); @@ -3560,7 +3562,7 @@ static void rna_Image_Node_update_id(Main *bmain, Scene *scene, PointerRNA *ptr) { bNode *node = static_cast(ptr->data); - blender::bke::node_tag_update_id(node); + blender::bke::node_tag_update_id(*node); rna_Node_update_relations(bmain, scene, ptr); } @@ -3603,7 +3605,7 @@ static void rna_NodeColorBalance_update_cdl(Main *bmain, Scene *scene, PointerRN static float rna_NodeGlare_threshold_get(PointerRNA *ptr) { bNode *node = static_cast(ptr->data); - bNodeSocket *input = blender::bke::node_find_socket(node, SOCK_IN, "Threshold"); + bNodeSocket *input = blender::bke::node_find_socket(*node, SOCK_IN, "Threshold"); PointerRNA input_rna_pointer = RNA_pointer_create_discrete( ptr->owner_id, &RNA_NodeSocket, input); return RNA_float_get(&input_rna_pointer, "default_value"); @@ -3612,7 +3614,7 @@ static float rna_NodeGlare_threshold_get(PointerRNA *ptr) static void rna_NodeGlare_threshold_set(PointerRNA *ptr, const float value) { bNode *node = static_cast(ptr->data); - bNodeSocket *input = blender::bke::node_find_socket(node, SOCK_IN, "Threshold"); + bNodeSocket *input = blender::bke::node_find_socket(*node, SOCK_IN, "Threshold"); PointerRNA input_rna_pointer = RNA_pointer_create_discrete( ptr->owner_id, &RNA_NodeSocket, input); RNA_float_set(&input_rna_pointer, "default_value", value); @@ -3621,7 +3623,7 @@ static void rna_NodeGlare_threshold_set(PointerRNA *ptr, const float value) static float rna_NodeGlare_mix_get(PointerRNA *ptr) { bNode *node = static_cast(ptr->data); - bNodeSocket *input = blender::bke::node_find_socket(node, SOCK_IN, "Strength"); + bNodeSocket *input = blender::bke::node_find_socket(*node, SOCK_IN, "Strength"); PointerRNA input_rna_pointer = RNA_pointer_create_discrete( ptr->owner_id, &RNA_NodeSocket, input); return RNA_float_get(&input_rna_pointer, "default_value") - 1; @@ -3630,7 +3632,7 @@ static float rna_NodeGlare_mix_get(PointerRNA *ptr) static void rna_NodeGlare_mix_set(PointerRNA *ptr, const float value) { bNode *node = static_cast(ptr->data); - bNodeSocket *input = blender::bke::node_find_socket(node, SOCK_IN, "Strength"); + bNodeSocket *input = blender::bke::node_find_socket(*node, SOCK_IN, "Strength"); PointerRNA input_rna_pointer = RNA_pointer_create_discrete( ptr->owner_id, &RNA_NodeSocket, input); const float mix_value = 1.0f - blender::math::clamp(-value, 0.0f, 1.0f); @@ -3640,7 +3642,7 @@ static void rna_NodeGlare_mix_set(PointerRNA *ptr, const float value) static int rna_NodeGlare_size_get(PointerRNA *ptr) { bNode *node = static_cast(ptr->data); - bNodeSocket *input = blender::bke::node_find_socket(node, SOCK_IN, "Size"); + bNodeSocket *input = blender::bke::node_find_socket(*node, SOCK_IN, "Size"); PointerRNA input_rna_pointer = RNA_pointer_create_discrete( ptr->owner_id, &RNA_NodeSocket, input); const float size_value = RNA_float_get(&input_rna_pointer, "default_value"); @@ -3653,7 +3655,7 @@ static int rna_NodeGlare_size_get(PointerRNA *ptr) static void rna_NodeGlare_size_set(PointerRNA *ptr, const int value) { bNode *node = static_cast(ptr->data); - bNodeSocket *input = blender::bke::node_find_socket(node, SOCK_IN, "Size"); + bNodeSocket *input = blender::bke::node_find_socket(*node, SOCK_IN, "Size"); PointerRNA input_rna_pointer = RNA_pointer_create_discrete( ptr->owner_id, &RNA_NodeSocket, input); const float size_value = blender::math::pow(2.0f, float(value - 9)); @@ -3663,7 +3665,7 @@ static void rna_NodeGlare_size_set(PointerRNA *ptr, const int value) static int rna_NodeGlare_streaks_get(PointerRNA *ptr) { bNode *node = static_cast(ptr->data); - bNodeSocket *input = blender::bke::node_find_socket(node, SOCK_IN, "Streaks"); + bNodeSocket *input = blender::bke::node_find_socket(*node, SOCK_IN, "Streaks"); PointerRNA input_rna_pointer = RNA_pointer_create_discrete( ptr->owner_id, &RNA_NodeSocket, input); return blender::math::clamp(RNA_int_get(&input_rna_pointer, "default_value"), 1, 16); @@ -3672,7 +3674,7 @@ static int rna_NodeGlare_streaks_get(PointerRNA *ptr) static void rna_NodeGlare_streaks_set(PointerRNA *ptr, const int value) { bNode *node = static_cast(ptr->data); - bNodeSocket *input = blender::bke::node_find_socket(node, SOCK_IN, "Streaks"); + bNodeSocket *input = blender::bke::node_find_socket(*node, SOCK_IN, "Streaks"); PointerRNA input_rna_pointer = RNA_pointer_create_discrete( ptr->owner_id, &RNA_NodeSocket, input); RNA_int_set(&input_rna_pointer, "default_value", blender::math::clamp(value, 1, 16)); @@ -3681,7 +3683,7 @@ static void rna_NodeGlare_streaks_set(PointerRNA *ptr, const int value) static float rna_NodeGlare_angle_offset_get(PointerRNA *ptr) { bNode *node = static_cast(ptr->data); - bNodeSocket *input = blender::bke::node_find_socket(node, SOCK_IN, "Streaks Angle"); + bNodeSocket *input = blender::bke::node_find_socket(*node, SOCK_IN, "Streaks Angle"); PointerRNA input_rna_pointer = RNA_pointer_create_discrete( ptr->owner_id, &RNA_NodeSocket, input); return RNA_float_get(&input_rna_pointer, "default_value"); @@ -3690,7 +3692,7 @@ static float rna_NodeGlare_angle_offset_get(PointerRNA *ptr) static void rna_NodeGlare_angle_offset_set(PointerRNA *ptr, const float value) { bNode *node = static_cast(ptr->data); - bNodeSocket *input = blender::bke::node_find_socket(node, SOCK_IN, "Streaks Angle"); + bNodeSocket *input = blender::bke::node_find_socket(*node, SOCK_IN, "Streaks Angle"); PointerRNA input_rna_pointer = RNA_pointer_create_discrete( ptr->owner_id, &RNA_NodeSocket, input); RNA_float_set(&input_rna_pointer, "default_value", value); @@ -3699,7 +3701,7 @@ static void rna_NodeGlare_angle_offset_set(PointerRNA *ptr, const float value) static int rna_NodeGlare_iterations_get(PointerRNA *ptr) { bNode *node = static_cast(ptr->data); - bNodeSocket *input = blender::bke::node_find_socket(node, SOCK_IN, "Iterations"); + bNodeSocket *input = blender::bke::node_find_socket(*node, SOCK_IN, "Iterations"); PointerRNA input_rna_pointer = RNA_pointer_create_discrete( ptr->owner_id, &RNA_NodeSocket, input); return blender::math::clamp(RNA_int_get(&input_rna_pointer, "default_value"), 2, 5); @@ -3708,7 +3710,7 @@ static int rna_NodeGlare_iterations_get(PointerRNA *ptr) static void rna_NodeGlare_iterations_set(PointerRNA *ptr, const int value) { bNode *node = static_cast(ptr->data); - bNodeSocket *input = blender::bke::node_find_socket(node, SOCK_IN, "Iterations"); + bNodeSocket *input = blender::bke::node_find_socket(*node, SOCK_IN, "Iterations"); PointerRNA input_rna_pointer = RNA_pointer_create_discrete( ptr->owner_id, &RNA_NodeSocket, input); RNA_int_set(&input_rna_pointer, "default_value", blender::math::clamp(value, 2, 5)); @@ -3717,7 +3719,7 @@ static void rna_NodeGlare_iterations_set(PointerRNA *ptr, const int value) static float rna_NodeGlare_fade_get(PointerRNA *ptr) { bNode *node = static_cast(ptr->data); - bNodeSocket *input = blender::bke::node_find_socket(node, SOCK_IN, "Fade"); + bNodeSocket *input = blender::bke::node_find_socket(*node, SOCK_IN, "Fade"); PointerRNA input_rna_pointer = RNA_pointer_create_discrete( ptr->owner_id, &RNA_NodeSocket, input); return blender::math::clamp(RNA_float_get(&input_rna_pointer, "default_value"), 0.75f, 1.0f); @@ -3726,7 +3728,7 @@ static float rna_NodeGlare_fade_get(PointerRNA *ptr) static void rna_NodeGlare_fade_set(PointerRNA *ptr, const float value) { bNode *node = static_cast(ptr->data); - bNodeSocket *input = blender::bke::node_find_socket(node, SOCK_IN, "Fade"); + bNodeSocket *input = blender::bke::node_find_socket(*node, SOCK_IN, "Fade"); PointerRNA input_rna_pointer = RNA_pointer_create_discrete( ptr->owner_id, &RNA_NodeSocket, input); RNA_float_set(&input_rna_pointer, "default_value", blender::math::clamp(value, 0.75f, 1.0f)); @@ -3735,7 +3737,7 @@ static void rna_NodeGlare_fade_set(PointerRNA *ptr, const float value) static float rna_NodeGlare_color_modulation_get(PointerRNA *ptr) { bNode *node = static_cast(ptr->data); - bNodeSocket *input = blender::bke::node_find_socket(node, SOCK_IN, "Color Modulation"); + bNodeSocket *input = blender::bke::node_find_socket(*node, SOCK_IN, "Color Modulation"); PointerRNA input_rna_pointer = RNA_pointer_create_discrete( ptr->owner_id, &RNA_NodeSocket, input); return blender::math::clamp(RNA_float_get(&input_rna_pointer, "default_value"), 0.0f, 1.0f); @@ -3744,7 +3746,7 @@ static float rna_NodeGlare_color_modulation_get(PointerRNA *ptr) static void rna_NodeGlare_color_modulation_set(PointerRNA *ptr, const float value) { bNode *node = static_cast(ptr->data); - bNodeSocket *input = blender::bke::node_find_socket(node, SOCK_IN, "Color Modulation"); + bNodeSocket *input = blender::bke::node_find_socket(*node, SOCK_IN, "Color Modulation"); PointerRNA input_rna_pointer = RNA_pointer_create_discrete( ptr->owner_id, &RNA_NodeSocket, input); RNA_float_set(&input_rna_pointer, "default_value", blender::math::clamp(value, 0.0f, 1.0f)); diff --git a/source/blender/nodes/NOD_socket_items.hh b/source/blender/nodes/NOD_socket_items.hh index 8c2480c48a1..b847a696894 100644 --- a/source/blender/nodes/NOD_socket_items.hh +++ b/source/blender/nodes/NOD_socket_items.hh @@ -255,14 +255,13 @@ template update_node_declaration_and_sockets(ntree, extend_node); if (extend_socket.is_input()) { const std::string item_identifier = get_socket_identifier(*item, SOCK_IN); - bNodeSocket *new_socket = bke::node_find_socket( - &extend_node, SOCK_IN, item_identifier.c_str()); + bNodeSocket *new_socket = bke::node_find_socket(extend_node, SOCK_IN, item_identifier.c_str()); link.tosock = new_socket; } else { const std::string item_identifier = get_socket_identifier(*item, SOCK_OUT); bNodeSocket *new_socket = bke::node_find_socket( - &extend_node, SOCK_OUT, item_identifier.c_str()); + extend_node, SOCK_OUT, item_identifier.c_str()); link.fromsock = new_socket; } return true; diff --git a/source/blender/nodes/NOD_socket_items_ops.hh b/source/blender/nodes/NOD_socket_items_ops.hh index 73309f9d36a..91758e7cba1 100644 --- a/source/blender/nodes/NOD_socket_items_ops.hh +++ b/source/blender/nodes/NOD_socket_items_ops.hh @@ -40,7 +40,7 @@ inline PointerRNA get_active_node_to_operate_on(bContext *C, const int node_type if (!zones) { return PointerRNA_NULL; } - bNode *active_node = bke::node_get_active(snode->edittree); + bNode *active_node = bke::node_get_active(*snode->edittree); if (!active_node) { return PointerRNA_NULL; } diff --git a/source/blender/nodes/composite/node_composite_tree.cc b/source/blender/nodes/composite/node_composite_tree.cc index 1c3e0aa26eb..c35ffac4130 100644 --- a/source/blender/nodes/composite/node_composite_tree.cc +++ b/source/blender/nodes/composite/node_composite_tree.cc @@ -94,7 +94,7 @@ static void local_merge(Main *bmain, bNodeTree *localtree, bNodeTree *ntree) blender::bke::node_preview_merge_tree(ntree, localtree, true); LISTBASE_FOREACH (bNode *, lnode, &localtree->nodes) { - if (bNode *orig_node = blender::bke::node_find_node_by_name(ntree, lnode->name)) { + if (bNode *orig_node = blender::bke::node_find_node_by_name(*ntree, lnode->name)) { if (lnode->type_legacy == CMP_NODE_VIEWER) { if (lnode->id && (lnode->flag & NODE_DO_OUTPUT)) { /* image_merge does sanity check for pointers */ @@ -119,7 +119,7 @@ static void local_merge(Main *bmain, bNodeTree *localtree, bNodeTree *ntree) static void update(bNodeTree *ntree) { - blender::bke::node_tree_set_output(ntree); + blender::bke::node_tree_set_output(*ntree); ntree_update_reroute_nodes(ntree); } @@ -137,7 +137,7 @@ static void composite_node_add_init(bNodeTree * /*bnodetree*/, bNode *bnode) static bool composite_node_tree_socket_type_valid(blender::bke::bNodeTreeType * /*ntreetype*/, blender::bke::bNodeSocketType *socket_type) { - return blender::bke::node_is_static_socket_type(socket_type) && + return blender::bke::node_is_static_socket_type(*socket_type) && ELEM(socket_type->type, SOCK_FLOAT, SOCK_INT, SOCK_VECTOR, SOCK_RGBA); } @@ -165,7 +165,7 @@ void register_node_tree_type_cmp() tt->rna_ext.srna = &RNA_CompositorNodeTree; - blender::bke::node_tree_type_add(tt); + blender::bke::node_tree_type_add(*tt); } /* *********************************************** */ diff --git a/source/blender/nodes/composite/node_composite_util.cc b/source/blender/nodes/composite/node_composite_util.cc index 758b114f066..99058c5d620 100644 --- a/source/blender/nodes/composite/node_composite_util.cc +++ b/source/blender/nodes/composite/node_composite_util.cc @@ -34,7 +34,7 @@ void cmp_node_type_base(blender::bke::bNodeType *ntype, std::string idname, const std::optional legacy_type) { - blender::bke::node_type_base(ntype, idname, legacy_type); + blender::bke::node_type_base(*ntype, idname, legacy_type); ntype->poll = cmp_node_poll_default; ntype->updatefunc = cmp_node_update_default; diff --git a/source/blender/nodes/composite/nodes/node_composite_alpha_over.cc b/source/blender/nodes/composite/nodes/node_composite_alpha_over.cc index a7337a05dd3..9e15921b540 100644 --- a/source/blender/nodes/composite/nodes/node_composite_alpha_over.cc +++ b/source/blender/nodes/composite/nodes/node_composite_alpha_over.cc @@ -193,9 +193,9 @@ void register_node_type_cmp_alphaover() ntype.draw_buttons = file_ns::node_composit_buts_alphaover; ntype.initfunc = file_ns::node_alphaover_init; blender::bke::node_type_storage( - &ntype, "NodeTwoFloats", node_free_standard_storage, node_copy_standard_storage); + ntype, "NodeTwoFloats", node_free_standard_storage, node_copy_standard_storage); ntype.gpu_fn = file_ns::node_gpu_material; ntype.build_multi_function = file_ns::node_build_multi_function; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } diff --git a/source/blender/nodes/composite/nodes/node_composite_antialiasing.cc b/source/blender/nodes/composite/nodes/node_composite_antialiasing.cc index 79c5a5a0848..3d93f712ba8 100644 --- a/source/blender/nodes/composite/nodes/node_composite_antialiasing.cc +++ b/source/blender/nodes/composite/nodes/node_composite_antialiasing.cc @@ -109,11 +109,11 @@ void register_node_type_cmp_antialiasing() ntype.declare = file_ns::cmp_node_antialiasing_declare; ntype.draw_buttons = file_ns::node_composit_buts_antialiasing; ntype.flag |= NODE_PREVIEW; - blender::bke::node_type_size(&ntype, 170, 140, 200); + blender::bke::node_type_size(ntype, 170, 140, 200); ntype.initfunc = file_ns::node_composit_init_antialiasing; blender::bke::node_type_storage( - &ntype, "NodeAntiAliasingData", node_free_standard_storage, node_copy_standard_storage); + ntype, "NodeAntiAliasingData", node_free_standard_storage, node_copy_standard_storage); ntype.get_compositor_operation = file_ns::get_compositor_operation; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } diff --git a/source/blender/nodes/composite/nodes/node_composite_bilateralblur.cc b/source/blender/nodes/composite/nodes/node_composite_bilateralblur.cc index ced83e04dc7..15359250f5a 100644 --- a/source/blender/nodes/composite/nodes/node_composite_bilateralblur.cc +++ b/source/blender/nodes/composite/nodes/node_composite_bilateralblur.cc @@ -191,8 +191,8 @@ void register_node_type_cmp_bilateralblur() ntype.draw_buttons = file_ns::node_composit_buts_bilateralblur; ntype.initfunc = file_ns::node_composit_init_bilateralblur; blender::bke::node_type_storage( - &ntype, "NodeBilateralBlurData", node_free_standard_storage, node_copy_standard_storage); + ntype, "NodeBilateralBlurData", node_free_standard_storage, node_copy_standard_storage); ntype.get_compositor_operation = file_ns::get_compositor_operation; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } diff --git a/source/blender/nodes/composite/nodes/node_composite_blur.cc b/source/blender/nodes/composite/nodes/node_composite_blur.cc index ff5a902582a..5fe9db0840b 100644 --- a/source/blender/nodes/composite/nodes/node_composite_blur.cc +++ b/source/blender/nodes/composite/nodes/node_composite_blur.cc @@ -532,8 +532,8 @@ void register_node_type_cmp_blur() ntype.flag |= NODE_PREVIEW; ntype.initfunc = file_ns::node_composit_init_blur; blender::bke::node_type_storage( - &ntype, "NodeBlurData", node_free_standard_storage, node_copy_standard_storage); + ntype, "NodeBlurData", node_free_standard_storage, node_copy_standard_storage); ntype.get_compositor_operation = file_ns::get_compositor_operation; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } diff --git a/source/blender/nodes/composite/nodes/node_composite_bokehblur.cc b/source/blender/nodes/composite/nodes/node_composite_bokehblur.cc index fc31b6ed614..211ad01fe6d 100644 --- a/source/blender/nodes/composite/nodes/node_composite_bokehblur.cc +++ b/source/blender/nodes/composite/nodes/node_composite_bokehblur.cc @@ -425,5 +425,5 @@ void register_node_type_cmp_bokehblur() ntype.initfunc = file_ns::node_composit_init_bokehblur; ntype.get_compositor_operation = file_ns::get_compositor_operation; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } diff --git a/source/blender/nodes/composite/nodes/node_composite_bokehimage.cc b/source/blender/nodes/composite/nodes/node_composite_bokehimage.cc index 532d14852fc..b8b4a6112cf 100644 --- a/source/blender/nodes/composite/nodes/node_composite_bokehimage.cc +++ b/source/blender/nodes/composite/nodes/node_composite_bokehimage.cc @@ -114,8 +114,8 @@ void register_node_type_cmp_bokehimage() ntype.flag |= NODE_PREVIEW; ntype.initfunc = file_ns::node_composit_init_bokehimage; blender::bke::node_type_storage( - &ntype, "NodeBokehImage", node_free_standard_storage, node_copy_standard_storage); + ntype, "NodeBokehImage", node_free_standard_storage, node_copy_standard_storage); ntype.get_compositor_operation = file_ns::get_compositor_operation; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } diff --git a/source/blender/nodes/composite/nodes/node_composite_boxmask.cc b/source/blender/nodes/composite/nodes/node_composite_boxmask.cc index 5bcc8ed9729..b0274f91a9b 100644 --- a/source/blender/nodes/composite/nodes/node_composite_boxmask.cc +++ b/source/blender/nodes/composite/nodes/node_composite_boxmask.cc @@ -313,8 +313,8 @@ void register_node_type_cmp_boxmask() ntype.draw_buttons = file_ns::node_composit_buts_boxmask; ntype.initfunc = file_ns::node_composit_init_boxmask; blender::bke::node_type_storage( - &ntype, "NodeBoxMask", node_free_standard_storage, node_copy_standard_storage); + ntype, "NodeBoxMask", node_free_standard_storage, node_copy_standard_storage); ntype.get_compositor_operation = file_ns::get_compositor_operation; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } diff --git a/source/blender/nodes/composite/nodes/node_composite_brightness.cc b/source/blender/nodes/composite/nodes/node_composite_brightness.cc index 20df5eaee77..56a30efd0cd 100644 --- a/source/blender/nodes/composite/nodes/node_composite_brightness.cc +++ b/source/blender/nodes/composite/nodes/node_composite_brightness.cc @@ -147,5 +147,5 @@ void register_node_type_cmp_brightcontrast() ntype.gpu_fn = file_ns::node_gpu_material; ntype.build_multi_function = file_ns::node_build_multi_function; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } diff --git a/source/blender/nodes/composite/nodes/node_composite_channel_matte.cc b/source/blender/nodes/composite/nodes/node_composite_channel_matte.cc index 7237ffcf161..7fdbda77f2f 100644 --- a/source/blender/nodes/composite/nodes/node_composite_channel_matte.cc +++ b/source/blender/nodes/composite/nodes/node_composite_channel_matte.cc @@ -297,9 +297,9 @@ void register_node_type_cmp_channel_matte() ntype.flag |= NODE_PREVIEW; ntype.initfunc = file_ns::node_composit_init_channel_matte; blender::bke::node_type_storage( - &ntype, "NodeChroma", node_free_standard_storage, node_copy_standard_storage); + ntype, "NodeChroma", node_free_standard_storage, node_copy_standard_storage); ntype.gpu_fn = file_ns::node_gpu_material; ntype.build_multi_function = file_ns::node_build_multi_function; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } diff --git a/source/blender/nodes/composite/nodes/node_composite_chroma_matte.cc b/source/blender/nodes/composite/nodes/node_composite_chroma_matte.cc index 7a1edef9d72..09c101541ed 100644 --- a/source/blender/nodes/composite/nodes/node_composite_chroma_matte.cc +++ b/source/blender/nodes/composite/nodes/node_composite_chroma_matte.cc @@ -187,9 +187,9 @@ void register_node_type_cmp_chroma_matte() ntype.flag |= NODE_PREVIEW; ntype.initfunc = file_ns::node_composit_init_chroma_matte; blender::bke::node_type_storage( - &ntype, "NodeChroma", node_free_standard_storage, node_copy_standard_storage); + ntype, "NodeChroma", node_free_standard_storage, node_copy_standard_storage); ntype.gpu_fn = file_ns::node_gpu_material; ntype.build_multi_function = file_ns::node_build_multi_function; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } diff --git a/source/blender/nodes/composite/nodes/node_composite_color_matte.cc b/source/blender/nodes/composite/nodes/node_composite_color_matte.cc index 3f5e3cd250a..6ae10e2ec30 100644 --- a/source/blender/nodes/composite/nodes/node_composite_color_matte.cc +++ b/source/blender/nodes/composite/nodes/node_composite_color_matte.cc @@ -180,9 +180,9 @@ void register_node_type_cmp_color_matte() ntype.flag |= NODE_PREVIEW; ntype.initfunc = file_ns::node_composit_init_color_matte; blender::bke::node_type_storage( - &ntype, "NodeChroma", node_free_standard_storage, node_copy_standard_storage); + ntype, "NodeChroma", node_free_standard_storage, node_copy_standard_storage); ntype.gpu_fn = file_ns::node_gpu_material; ntype.build_multi_function = file_ns::node_build_multi_function; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } diff --git a/source/blender/nodes/composite/nodes/node_composite_color_spill.cc b/source/blender/nodes/composite/nodes/node_composite_color_spill.cc index c629b1b9f05..7adc7d79764 100644 --- a/source/blender/nodes/composite/nodes/node_composite_color_spill.cc +++ b/source/blender/nodes/composite/nodes/node_composite_color_spill.cc @@ -225,9 +225,9 @@ void register_node_type_cmp_color_spill() ntype.draw_buttons = file_ns::node_composit_buts_color_spill; ntype.initfunc = file_ns::node_composit_init_color_spill; blender::bke::node_type_storage( - &ntype, "NodeColorspill", node_free_standard_storage, node_copy_standard_storage); + ntype, "NodeColorspill", node_free_standard_storage, node_copy_standard_storage); ntype.gpu_fn = file_ns::node_gpu_material; ntype.build_multi_function = file_ns::node_build_multi_function; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } diff --git a/source/blender/nodes/composite/nodes/node_composite_colorbalance.cc b/source/blender/nodes/composite/nodes/node_composite_colorbalance.cc index efb5d637f36..fb4517b913b 100644 --- a/source/blender/nodes/composite/nodes/node_composite_colorbalance.cc +++ b/source/blender/nodes/composite/nodes/node_composite_colorbalance.cc @@ -388,12 +388,12 @@ void register_node_type_cmp_colorbalance() ntype.declare = file_ns::cmp_node_colorbalance_declare; ntype.draw_buttons = file_ns::node_composit_buts_colorbalance; ntype.draw_buttons_ex = file_ns::node_composit_buts_colorbalance_ex; - blender::bke::node_type_size(&ntype, 400, 200, 400); + blender::bke::node_type_size(ntype, 400, 200, 400); ntype.initfunc = file_ns::node_composit_init_colorbalance; blender::bke::node_type_storage( - &ntype, "NodeColorBalance", node_free_standard_storage, node_copy_standard_storage); + ntype, "NodeColorBalance", node_free_standard_storage, node_copy_standard_storage); ntype.gpu_fn = file_ns::node_gpu_material; ntype.build_multi_function = file_ns::node_build_multi_function; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } diff --git a/source/blender/nodes/composite/nodes/node_composite_colorcorrection.cc b/source/blender/nodes/composite/nodes/node_composite_colorcorrection.cc index 79faa6fbadd..eac9ceae9e6 100644 --- a/source/blender/nodes/composite/nodes/node_composite_colorcorrection.cc +++ b/source/blender/nodes/composite/nodes/node_composite_colorcorrection.cc @@ -509,12 +509,12 @@ void register_node_type_cmp_colorcorrection() ntype.declare = file_ns::cmp_node_colorcorrection_declare; ntype.draw_buttons = file_ns::node_composit_buts_colorcorrection; ntype.draw_buttons_ex = file_ns::node_composit_buts_colorcorrection_ex; - blender::bke::node_type_size(&ntype, 400, 200, 600); + blender::bke::node_type_size(ntype, 400, 200, 600); ntype.initfunc = file_ns::node_composit_init_colorcorrection; blender::bke::node_type_storage( - &ntype, "NodeColorCorrection", node_free_standard_storage, node_copy_standard_storage); + ntype, "NodeColorCorrection", node_free_standard_storage, node_copy_standard_storage); ntype.gpu_fn = file_ns::node_gpu_material; ntype.build_multi_function = file_ns::node_build_multi_function; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } diff --git a/source/blender/nodes/composite/nodes/node_composite_common.cc b/source/blender/nodes/composite/nodes/node_composite_common.cc index 2aaf4620d1e..3f9bb24ed9f 100644 --- a/source/blender/nodes/composite/nodes/node_composite_common.cc +++ b/source/blender/nodes/composite/nodes/node_composite_common.cc @@ -23,7 +23,7 @@ void register_node_type_cmp_group() /* NOTE: Cannot use sh_node_type_base for node group, because it would map the node type * to the shared NODE_GROUP integer type id. */ blender::bke::node_type_base_custom( - &ntype, "CompositorNodeGroup", "Group", "GROUP", NODE_CLASS_GROUP); + ntype, "CompositorNodeGroup", "Group", "GROUP", NODE_CLASS_GROUP); ntype.enum_name_legacy = "GROUP"; ntype.type_legacy = NODE_GROUP; ntype.poll = cmp_node_poll_default; @@ -35,11 +35,11 @@ void register_node_type_cmp_group() BLI_assert(ntype.rna_ext.srna != nullptr); RNA_struct_blender_type_set(ntype.rna_ext.srna, &ntype); - blender::bke::node_type_size(&ntype, 140, 60, 400); + blender::bke::node_type_size(ntype, 140, 60, 400); ntype.labelfunc = node_group_label; ntype.declare = blender::nodes::node_group_declare; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } void register_node_type_cmp_custom_group(blender::bke::bNodeType *ntype) diff --git a/source/blender/nodes/composite/nodes/node_composite_composite.cc b/source/blender/nodes/composite/nodes/node_composite_composite.cc index 5a964da38a2..99359aaac25 100644 --- a/source/blender/nodes/composite/nodes/node_composite_composite.cc +++ b/source/blender/nodes/composite/nodes/node_composite_composite.cc @@ -298,5 +298,5 @@ void register_node_type_cmp_composite() ntype.get_compositor_operation = file_ns::get_compositor_operation; ntype.no_muting = true; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } diff --git a/source/blender/nodes/composite/nodes/node_composite_convert_color_space.cc b/source/blender/nodes/composite/nodes/node_composite_convert_color_space.cc index 9797557a166..8e8d3767465 100644 --- a/source/blender/nodes/composite/nodes/node_composite_convert_color_space.cc +++ b/source/blender/nodes/composite/nodes/node_composite_convert_color_space.cc @@ -203,11 +203,11 @@ void register_node_type_cmp_convert_color_space() ntype.nclass = NODE_CLASS_CONVERTER; ntype.declare = file_ns::CMP_NODE_CONVERT_COLOR_SPACE_declare; ntype.draw_buttons = file_ns::node_composit_buts_convert_colorspace; - blender::bke::node_type_size_preset(&ntype, blender::bke::eNodeSizePreset::Middle); + blender::bke::node_type_size_preset(ntype, blender::bke::eNodeSizePreset::Middle); ntype.initfunc = file_ns::node_composit_init_convert_colorspace; blender::bke::node_type_storage( - &ntype, "NodeConvertColorSpace", node_free_standard_storage, node_copy_standard_storage); + ntype, "NodeConvertColorSpace", node_free_standard_storage, node_copy_standard_storage); ntype.get_compositor_operation = file_ns::get_compositor_operation; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } diff --git a/source/blender/nodes/composite/nodes/node_composite_cornerpin.cc b/source/blender/nodes/composite/nodes/node_composite_cornerpin.cc index 35300f8e9dc..5bf9c0614bc 100644 --- a/source/blender/nodes/composite/nodes/node_composite_cornerpin.cc +++ b/source/blender/nodes/composite/nodes/node_composite_cornerpin.cc @@ -273,5 +273,5 @@ void register_node_type_cmp_cornerpin() ntype.declare = file_ns::cmp_node_cornerpin_declare; ntype.get_compositor_operation = file_ns::get_compositor_operation; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } diff --git a/source/blender/nodes/composite/nodes/node_composite_crop.cc b/source/blender/nodes/composite/nodes/node_composite_crop.cc index 42a7af4b460..2fdc8ef95f0 100644 --- a/source/blender/nodes/composite/nodes/node_composite_crop.cc +++ b/source/blender/nodes/composite/nodes/node_composite_crop.cc @@ -303,8 +303,8 @@ void register_node_type_cmp_crop() ntype.draw_buttons = file_ns::node_composit_buts_crop; ntype.initfunc = file_ns::node_composit_init_crop; blender::bke::node_type_storage( - &ntype, "NodeTwoXYs", node_free_standard_storage, node_copy_standard_storage); + ntype, "NodeTwoXYs", node_free_standard_storage, node_copy_standard_storage); ntype.get_compositor_operation = file_ns::get_compositor_operation; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } diff --git a/source/blender/nodes/composite/nodes/node_composite_cryptomatte.cc b/source/blender/nodes/composite/nodes/node_composite_cryptomatte.cc index adac39555b1..568a1a37203 100644 --- a/source/blender/nodes/composite/nodes/node_composite_cryptomatte.cc +++ b/source/blender/nodes/composite/nodes/node_composite_cryptomatte.cc @@ -917,16 +917,16 @@ void register_node_type_cmp_cryptomatte() ntype.enum_name_legacy = "CRYPTOMATTE"; ntype.nclass = NODE_CLASS_MATTE; ntype.declare = file_ns::cmp_node_cryptomatte_declare; - blender::bke::node_type_size(&ntype, 240, 100, 700); + blender::bke::node_type_size(ntype, 240, 100, 700); ntype.initfunc = file_ns::node_init_cryptomatte; ntype.initfunc_api = file_ns::node_init_api_cryptomatte; ntype.poll = file_ns::node_poll_cryptomatte; ntype.updatefunc = file_ns::node_update_cryptomatte; blender::bke::node_type_storage( - &ntype, "NodeCryptomatte", file_ns::node_free_cryptomatte, file_ns::node_copy_cryptomatte); + ntype, "NodeCryptomatte", file_ns::node_free_cryptomatte, file_ns::node_copy_cryptomatte); ntype.get_compositor_operation = file_ns::get_compositor_operation; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } /** \} */ @@ -943,7 +943,7 @@ bNodeSocket *ntreeCompositCryptomatteAddSocket(bNodeTree *ntree, bNode *node) n->inputs_num++; SNPRINTF(sockname, "Crypto %.2d", n->inputs_num - 1); bNodeSocket *sock = blender::bke::node_add_static_socket( - ntree, node, SOCK_IN, SOCK_RGBA, PROP_NONE, "", sockname); + *ntree, *node, SOCK_IN, SOCK_RGBA, PROP_NONE, "", sockname); return sock; } @@ -955,7 +955,7 @@ int ntreeCompositCryptomatteRemoveSocket(bNodeTree *ntree, bNode *node) return 0; } bNodeSocket *sock = static_cast(node->inputs.last); - blender::bke::node_remove_socket(ntree, node, sock); + blender::bke::node_remove_socket(*ntree, *node, *sock); n->inputs_num--; return 1; } @@ -967,7 +967,7 @@ static void node_init_cryptomatte_legacy(bNodeTree *ntree, bNode *node) namespace file_ns = blender::nodes::node_composite_cryptomatte_cc; file_ns::node_init_cryptomatte(ntree, node); - bke::node_add_static_socket(ntree, node, SOCK_IN, SOCK_RGBA, PROP_NONE, "image", "Image"); + bke::node_add_static_socket(*ntree, *node, SOCK_IN, SOCK_RGBA, PROP_NONE, "image", "Image"); /* Add three inputs by default, as recommended by the Cryptomatte specification. */ ntreeCompositCryptomatteAddSocket(ntree, node); @@ -1026,11 +1026,11 @@ void register_node_type_cmp_cryptomatte_legacy() blender::bke::node_type_socket_templates(&ntype, nullptr, file_ns::cmp_node_cryptomatte_out); ntype.initfunc = legacy_file_ns::node_init_cryptomatte_legacy; blender::bke::node_type_storage( - &ntype, "NodeCryptomatte", file_ns::node_free_cryptomatte, file_ns::node_copy_cryptomatte); + ntype, "NodeCryptomatte", file_ns::node_free_cryptomatte, file_ns::node_copy_cryptomatte); ntype.gather_link_search_ops = nullptr; ntype.get_compositor_operation = legacy_file_ns::get_compositor_operation; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } /** \} */ diff --git a/source/blender/nodes/composite/nodes/node_composite_curves.cc b/source/blender/nodes/composite/nodes/node_composite_curves.cc index e91999f9281..58afad872da 100644 --- a/source/blender/nodes/composite/nodes/node_composite_curves.cc +++ b/source/blender/nodes/composite/nodes/node_composite_curves.cc @@ -114,12 +114,12 @@ void register_node_type_cmp_curve_time() ntype.enum_name_legacy = "TIME"; ntype.nclass = NODE_CLASS_INPUT; ntype.declare = file_ns::cmp_node_time_declare; - blender::bke::node_type_size(&ntype, 200, 140, 320); + blender::bke::node_type_size(ntype, 200, 140, 320); ntype.initfunc = file_ns::node_composit_init_curves_time; - blender::bke::node_type_storage(&ntype, "CurveMapping", node_free_curves, node_copy_curves); + blender::bke::node_type_storage(ntype, "CurveMapping", node_free_curves, node_copy_curves); ntype.get_compositor_operation = file_ns::get_compositor_operation; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } /* **************** CURVE VEC ******************** */ @@ -221,13 +221,13 @@ void register_node_type_cmp_curve_vec() ntype.nclass = NODE_CLASS_OP_VECTOR; ntype.declare = file_ns::cmp_node_curve_vec_declare; ntype.draw_buttons = file_ns::node_buts_curvevec; - blender::bke::node_type_size(&ntype, 200, 140, 320); + blender::bke::node_type_size(ntype, 200, 140, 320); ntype.initfunc = file_ns::node_composit_init_curve_vec; - blender::bke::node_type_storage(&ntype, "CurveMapping", node_free_curves, node_copy_curves); + blender::bke::node_type_storage(ntype, "CurveMapping", node_free_curves, node_copy_curves); ntype.gpu_fn = file_ns::node_gpu_material; ntype.build_multi_function = file_ns::node_build_multi_function; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } /* **************** CURVE RGB ******************** */ @@ -383,11 +383,11 @@ void register_node_type_cmp_curve_rgb() ntype.enum_name_legacy = "CURVE_RGB"; ntype.nclass = NODE_CLASS_OP_COLOR; ntype.declare = file_ns::cmp_node_rgbcurves_declare; - blender::bke::node_type_size(&ntype, 200, 140, 320); + blender::bke::node_type_size(ntype, 200, 140, 320); ntype.initfunc = file_ns::node_composit_init_curve_rgb; - blender::bke::node_type_storage(&ntype, "CurveMapping", node_free_curves, node_copy_curves); + blender::bke::node_type_storage(ntype, "CurveMapping", node_free_curves, node_copy_curves); ntype.gpu_fn = file_ns::node_gpu_material; ntype.build_multi_function = file_ns::node_build_multi_function; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } diff --git a/source/blender/nodes/composite/nodes/node_composite_defocus.cc b/source/blender/nodes/composite/nodes/node_composite_defocus.cc index 6e7db58adf8..45e23e8ac2d 100644 --- a/source/blender/nodes/composite/nodes/node_composite_defocus.cc +++ b/source/blender/nodes/composite/nodes/node_composite_defocus.cc @@ -565,8 +565,8 @@ void register_node_type_cmp_defocus() ntype.draw_buttons = file_ns::node_composit_buts_defocus; ntype.initfunc = file_ns::node_composit_init_defocus; blender::bke::node_type_storage( - &ntype, "NodeDefocus", node_free_standard_storage, node_copy_standard_storage); + ntype, "NodeDefocus", node_free_standard_storage, node_copy_standard_storage); ntype.get_compositor_operation = file_ns::get_compositor_operation; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } diff --git a/source/blender/nodes/composite/nodes/node_composite_denoise.cc b/source/blender/nodes/composite/nodes/node_composite_denoise.cc index 1cf132e54c8..9ef30a156ca 100644 --- a/source/blender/nodes/composite/nodes/node_composite_denoise.cc +++ b/source/blender/nodes/composite/nodes/node_composite_denoise.cc @@ -332,8 +332,8 @@ void register_node_type_cmp_denoise() ntype.draw_buttons = file_ns::node_composit_buts_denoise; ntype.initfunc = file_ns::node_composit_init_denonise; blender::bke::node_type_storage( - &ntype, "NodeDenoise", node_free_standard_storage, node_copy_standard_storage); + ntype, "NodeDenoise", node_free_standard_storage, node_copy_standard_storage); ntype.get_compositor_operation = file_ns::get_compositor_operation; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } diff --git a/source/blender/nodes/composite/nodes/node_composite_despeckle.cc b/source/blender/nodes/composite/nodes/node_composite_despeckle.cc index 47bd75708a4..4a23212e406 100644 --- a/source/blender/nodes/composite/nodes/node_composite_despeckle.cc +++ b/source/blender/nodes/composite/nodes/node_composite_despeckle.cc @@ -215,5 +215,5 @@ void register_node_type_cmp_despeckle() ntype.initfunc = file_ns::node_composit_init_despeckle; ntype.get_compositor_operation = file_ns::get_compositor_operation; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } diff --git a/source/blender/nodes/composite/nodes/node_composite_diff_matte.cc b/source/blender/nodes/composite/nodes/node_composite_diff_matte.cc index 72a7e405f85..f9c7a209291 100644 --- a/source/blender/nodes/composite/nodes/node_composite_diff_matte.cc +++ b/source/blender/nodes/composite/nodes/node_composite_diff_matte.cc @@ -135,9 +135,9 @@ void register_node_type_cmp_diff_matte() ntype.flag |= NODE_PREVIEW; ntype.initfunc = file_ns::node_composit_init_diff_matte; blender::bke::node_type_storage( - &ntype, "NodeChroma", node_free_standard_storage, node_copy_standard_storage); + ntype, "NodeChroma", node_free_standard_storage, node_copy_standard_storage); ntype.gpu_fn = file_ns::node_gpu_material; ntype.build_multi_function = file_ns::node_build_multi_function; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } diff --git a/source/blender/nodes/composite/nodes/node_composite_dilate.cc b/source/blender/nodes/composite/nodes/node_composite_dilate.cc index 8d8f963c671..8fbe568ed2e 100644 --- a/source/blender/nodes/composite/nodes/node_composite_dilate.cc +++ b/source/blender/nodes/composite/nodes/node_composite_dilate.cc @@ -565,8 +565,8 @@ void register_node_type_cmp_dilateerode() ntype.declare = file_ns::cmp_node_dilate_declare; ntype.initfunc = file_ns::node_composit_init_dilateerode; blender::bke::node_type_storage( - &ntype, "NodeDilateErode", node_free_standard_storage, node_copy_standard_storage); + ntype, "NodeDilateErode", node_free_standard_storage, node_copy_standard_storage); ntype.get_compositor_operation = file_ns::get_compositor_operation; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } diff --git a/source/blender/nodes/composite/nodes/node_composite_directionalblur.cc b/source/blender/nodes/composite/nodes/node_composite_directionalblur.cc index b4af7b37202..12909d8d15f 100644 --- a/source/blender/nodes/composite/nodes/node_composite_directionalblur.cc +++ b/source/blender/nodes/composite/nodes/node_composite_directionalblur.cc @@ -266,8 +266,8 @@ void register_node_type_cmp_dblur() ntype.draw_buttons = file_ns::node_composit_buts_dblur; ntype.initfunc = file_ns::node_composit_init_dblur; blender::bke::node_type_storage( - &ntype, "NodeDBlurData", node_free_standard_storage, node_copy_standard_storage); + ntype, "NodeDBlurData", node_free_standard_storage, node_copy_standard_storage); ntype.get_compositor_operation = file_ns::get_compositor_operation; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } diff --git a/source/blender/nodes/composite/nodes/node_composite_displace.cc b/source/blender/nodes/composite/nodes/node_composite_displace.cc index 502e6dbe7e2..6b3ffc67c59 100644 --- a/source/blender/nodes/composite/nodes/node_composite_displace.cc +++ b/source/blender/nodes/composite/nodes/node_composite_displace.cc @@ -227,5 +227,5 @@ void register_node_type_cmp_displace() ntype.declare = file_ns::cmp_node_displace_declare; ntype.get_compositor_operation = file_ns::get_compositor_operation; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } diff --git a/source/blender/nodes/composite/nodes/node_composite_distance_matte.cc b/source/blender/nodes/composite/nodes/node_composite_distance_matte.cc index 02c39448566..132288f0750 100644 --- a/source/blender/nodes/composite/nodes/node_composite_distance_matte.cc +++ b/source/blender/nodes/composite/nodes/node_composite_distance_matte.cc @@ -204,9 +204,9 @@ void register_node_type_cmp_distance_matte() ntype.flag |= NODE_PREVIEW; ntype.initfunc = file_ns::node_composit_init_distance_matte; blender::bke::node_type_storage( - &ntype, "NodeChroma", node_free_standard_storage, node_copy_standard_storage); + ntype, "NodeChroma", node_free_standard_storage, node_copy_standard_storage); ntype.gpu_fn = file_ns::node_gpu_material; ntype.build_multi_function = file_ns::node_build_multi_function; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } diff --git a/source/blender/nodes/composite/nodes/node_composite_double_edge_mask.cc b/source/blender/nodes/composite/nodes/node_composite_double_edge_mask.cc index 6d2e86066b8..4398297335e 100644 --- a/source/blender/nodes/composite/nodes/node_composite_double_edge_mask.cc +++ b/source/blender/nodes/composite/nodes/node_composite_double_edge_mask.cc @@ -329,5 +329,5 @@ void register_node_type_cmp_doubleedgemask() ntype.draw_buttons = file_ns::node_composit_buts_double_edge_mask; ntype.get_compositor_operation = file_ns::get_compositor_operation; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } diff --git a/source/blender/nodes/composite/nodes/node_composite_ellipsemask.cc b/source/blender/nodes/composite/nodes/node_composite_ellipsemask.cc index f75bd0445c7..d02da497a39 100644 --- a/source/blender/nodes/composite/nodes/node_composite_ellipsemask.cc +++ b/source/blender/nodes/composite/nodes/node_composite_ellipsemask.cc @@ -309,11 +309,11 @@ void register_node_type_cmp_ellipsemask() ntype.nclass = NODE_CLASS_MATTE; ntype.declare = file_ns::cmp_node_ellipsemask_declare; ntype.draw_buttons = file_ns::node_composit_buts_ellipsemask; - blender::bke::node_type_size(&ntype, 260, 110, 320); + blender::bke::node_type_size(ntype, 260, 110, 320); ntype.initfunc = file_ns::node_composit_init_ellipsemask; blender::bke::node_type_storage( - &ntype, "NodeEllipseMask", node_free_standard_storage, node_copy_standard_storage); + ntype, "NodeEllipseMask", node_free_standard_storage, node_copy_standard_storage); ntype.get_compositor_operation = file_ns::get_compositor_operation; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } diff --git a/source/blender/nodes/composite/nodes/node_composite_exposure.cc b/source/blender/nodes/composite/nodes/node_composite_exposure.cc index d625636a16c..a260f29bae7 100644 --- a/source/blender/nodes/composite/nodes/node_composite_exposure.cc +++ b/source/blender/nodes/composite/nodes/node_composite_exposure.cc @@ -70,5 +70,5 @@ void register_node_type_cmp_exposure() ntype.gpu_fn = file_ns::node_gpu_material; ntype.build_multi_function = file_ns::node_build_multi_function; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } diff --git a/source/blender/nodes/composite/nodes/node_composite_file_output.cc b/source/blender/nodes/composite/nodes/node_composite_file_output.cc index 09277f123eb..fa2cffb14bf 100644 --- a/source/blender/nodes/composite/nodes/node_composite_file_output.cc +++ b/source/blender/nodes/composite/nodes/node_composite_file_output.cc @@ -143,7 +143,7 @@ bNodeSocket *ntreeCompositOutputFileAddSocket(bNodeTree *ntree, { NodeImageMultiFile *nimf = (NodeImageMultiFile *)node->storage; bNodeSocket *sock = blender::bke::node_add_static_socket( - ntree, node, SOCK_IN, SOCK_RGBA, PROP_NONE, "", name); + *ntree, *node, SOCK_IN, SOCK_RGBA, PROP_NONE, "", name); /* create format data for the input socket */ NodeImageMultiFileSocket *sockdata = MEM_cnew(__func__); @@ -192,7 +192,7 @@ int ntreeCompositOutputFileRemoveActiveSocket(bNodeTree *ntree, bNode *node) /* free format data */ MEM_freeN(sock->storage); - blender::bke::node_remove_socket(ntree, node, sock); + blender::bke::node_remove_socket(*ntree, *node, *sock); return 1; } @@ -290,11 +290,11 @@ static void update_output_file(bNodeTree *ntree, bNode *node) */ LISTBASE_FOREACH_MUTABLE (bNodeSocket *, sock, &node->inputs) { if (sock->storage == nullptr) { - blender::bke::node_remove_socket(ntree, node, sock); + blender::bke::node_remove_socket(*ntree, *node, *sock); } } LISTBASE_FOREACH_MUTABLE (bNodeSocket *, sock, &node->outputs) { - blender::bke::node_remove_socket(ntree, node, sock); + blender::bke::node_remove_socket(*ntree, *node, *sock); } cmp_node_update_default(ntree, node); @@ -914,9 +914,9 @@ void register_node_type_cmp_output_file() ntype.initfunc_api = file_ns::init_output_file; ntype.flag |= NODE_PREVIEW; blender::bke::node_type_storage( - &ntype, "NodeImageMultiFile", file_ns::free_output_file, file_ns::copy_output_file); + ntype, "NodeImageMultiFile", file_ns::free_output_file, file_ns::copy_output_file); ntype.updatefunc = file_ns::update_output_file; ntype.get_compositor_operation = file_ns::get_compositor_operation; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } diff --git a/source/blender/nodes/composite/nodes/node_composite_filter.cc b/source/blender/nodes/composite/nodes/node_composite_filter.cc index 282550baae9..ed799834c18 100644 --- a/source/blender/nodes/composite/nodes/node_composite_filter.cc +++ b/source/blender/nodes/composite/nodes/node_composite_filter.cc @@ -258,5 +258,5 @@ void register_node_type_cmp_filter() ntype.flag |= NODE_PREVIEW; ntype.get_compositor_operation = file_ns::get_compositor_operation; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } diff --git a/source/blender/nodes/composite/nodes/node_composite_flip.cc b/source/blender/nodes/composite/nodes/node_composite_flip.cc index 0c6125090ca..06a1b2c231d 100644 --- a/source/blender/nodes/composite/nodes/node_composite_flip.cc +++ b/source/blender/nodes/composite/nodes/node_composite_flip.cc @@ -138,5 +138,5 @@ void register_node_type_cmp_flip() ntype.draw_buttons = file_ns::node_composit_buts_flip; ntype.get_compositor_operation = file_ns::get_compositor_operation; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } diff --git a/source/blender/nodes/composite/nodes/node_composite_gamma.cc b/source/blender/nodes/composite/nodes/node_composite_gamma.cc index 243fb037842..5f4d17dd8bd 100644 --- a/source/blender/nodes/composite/nodes/node_composite_gamma.cc +++ b/source/blender/nodes/composite/nodes/node_composite_gamma.cc @@ -74,5 +74,5 @@ void register_node_type_cmp_gamma() ntype.gpu_fn = file_ns::node_gpu_material; ntype.build_multi_function = file_ns::node_build_multi_function; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } diff --git a/source/blender/nodes/composite/nodes/node_composite_glare.cc b/source/blender/nodes/composite/nodes/node_composite_glare.cc index 51816c25662..3d0cc463241 100644 --- a/source/blender/nodes/composite/nodes/node_composite_glare.cc +++ b/source/blender/nodes/composite/nodes/node_composite_glare.cc @@ -183,33 +183,33 @@ static void node_update(bNodeTree *ntree, bNode *node) { const CMPNodeGlareType glare_type = static_cast(node_storage(*node).type); - bNodeSocket *size_input = bke::node_find_socket(node, SOCK_IN, "Size"); + bNodeSocket *size_input = bke::node_find_socket(*node, SOCK_IN, "Size"); blender::bke::node_set_socket_availability( - ntree, size_input, ELEM(glare_type, CMP_NODE_GLARE_FOG_GLOW, CMP_NODE_GLARE_BLOOM)); + *ntree, *size_input, ELEM(glare_type, CMP_NODE_GLARE_FOG_GLOW, CMP_NODE_GLARE_BLOOM)); - bNodeSocket *iterations_input = bke::node_find_socket(node, SOCK_IN, "Iterations"); + bNodeSocket *iterations_input = bke::node_find_socket(*node, SOCK_IN, "Iterations"); blender::bke::node_set_socket_availability( - ntree, - iterations_input, + *ntree, + *iterations_input, ELEM(glare_type, CMP_NODE_GLARE_SIMPLE_STAR, CMP_NODE_GLARE_GHOST, CMP_NODE_GLARE_STREAKS)); - bNodeSocket *fade_input = bke::node_find_socket(node, SOCK_IN, "Fade"); + bNodeSocket *fade_input = bke::node_find_socket(*node, SOCK_IN, "Fade"); blender::bke::node_set_socket_availability( - ntree, fade_input, ELEM(glare_type, CMP_NODE_GLARE_SIMPLE_STAR, CMP_NODE_GLARE_STREAKS)); + *ntree, *fade_input, ELEM(glare_type, CMP_NODE_GLARE_SIMPLE_STAR, CMP_NODE_GLARE_STREAKS)); - bNodeSocket *color_modulation_input = bke::node_find_socket(node, SOCK_IN, "Color Modulation"); + bNodeSocket *color_modulation_input = bke::node_find_socket(*node, SOCK_IN, "Color Modulation"); blender::bke::node_set_socket_availability( - ntree, - color_modulation_input, + *ntree, + *color_modulation_input, ELEM(glare_type, CMP_NODE_GLARE_GHOST, CMP_NODE_GLARE_STREAKS)); - bNodeSocket *streaks_input = bke::node_find_socket(node, SOCK_IN, "Streaks"); + bNodeSocket *streaks_input = bke::node_find_socket(*node, SOCK_IN, "Streaks"); blender::bke::node_set_socket_availability( - ntree, streaks_input, glare_type == CMP_NODE_GLARE_STREAKS); + *ntree, *streaks_input, glare_type == CMP_NODE_GLARE_STREAKS); - bNodeSocket *streaks_angle_input = bke::node_find_socket(node, SOCK_IN, "Streaks Angle"); + bNodeSocket *streaks_angle_input = bke::node_find_socket(*node, SOCK_IN, "Streaks Angle"); blender::bke::node_set_socket_availability( - ntree, streaks_angle_input, glare_type == CMP_NODE_GLARE_STREAKS); + *ntree, *streaks_angle_input, glare_type == CMP_NODE_GLARE_STREAKS); } using namespace blender::compositor; @@ -2381,8 +2381,8 @@ void register_node_type_cmp_glare() ntype.updatefunc = file_ns::node_update; ntype.initfunc = file_ns::node_composit_init_glare; blender::bke::node_type_storage( - &ntype, "NodeGlare", node_free_standard_storage, node_copy_standard_storage); + ntype, "NodeGlare", node_free_standard_storage, node_copy_standard_storage); ntype.get_compositor_operation = file_ns::get_compositor_operation; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } diff --git a/source/blender/nodes/composite/nodes/node_composite_hue_sat_val.cc b/source/blender/nodes/composite/nodes/node_composite_hue_sat_val.cc index dda3dc6d81e..e2aa2cb31d1 100644 --- a/source/blender/nodes/composite/nodes/node_composite_hue_sat_val.cc +++ b/source/blender/nodes/composite/nodes/node_composite_hue_sat_val.cc @@ -110,5 +110,5 @@ void register_node_type_cmp_hue_sat() ntype.gpu_fn = file_ns::node_gpu_material; ntype.build_multi_function = file_ns::node_build_multi_function; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } diff --git a/source/blender/nodes/composite/nodes/node_composite_huecorrect.cc b/source/blender/nodes/composite/nodes/node_composite_huecorrect.cc index 286385fac7b..19100cc56f5 100644 --- a/source/blender/nodes/composite/nodes/node_composite_huecorrect.cc +++ b/source/blender/nodes/composite/nodes/node_composite_huecorrect.cc @@ -151,11 +151,11 @@ void register_node_type_cmp_huecorrect() ntype.enum_name_legacy = "HUECORRECT"; ntype.nclass = NODE_CLASS_OP_COLOR; ntype.declare = file_ns::cmp_node_huecorrect_declare; - blender::bke::node_type_size(&ntype, 320, 140, 500); + blender::bke::node_type_size(ntype, 320, 140, 500); ntype.initfunc = file_ns::node_composit_init_huecorrect; - blender::bke::node_type_storage(&ntype, "CurveMapping", node_free_curves, node_copy_curves); + blender::bke::node_type_storage(ntype, "CurveMapping", node_free_curves, node_copy_curves); ntype.gpu_fn = file_ns::node_gpu_material; ntype.build_multi_function = file_ns::node_build_multi_function; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } diff --git a/source/blender/nodes/composite/nodes/node_composite_id_mask.cc b/source/blender/nodes/composite/nodes/node_composite_id_mask.cc index 5a1f5e0faad..5b5a63cf326 100644 --- a/source/blender/nodes/composite/nodes/node_composite_id_mask.cc +++ b/source/blender/nodes/composite/nodes/node_composite_id_mask.cc @@ -152,5 +152,5 @@ void register_node_type_cmp_idmask() ntype.draw_buttons = file_ns::node_composit_buts_id_mask; ntype.get_compositor_operation = file_ns::get_compositor_operation; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } diff --git a/source/blender/nodes/composite/nodes/node_composite_image.cc b/source/blender/nodes/composite/nodes/node_composite_image.cc index ed2a1427afd..fc1abaee01e 100644 --- a/source/blender/nodes/composite/nodes/node_composite_image.cc +++ b/source/blender/nodes/composite/nodes/node_composite_image.cc @@ -95,7 +95,7 @@ static void cmp_node_image_add_pass_output(bNodeTree *ntree, /* Replace if types don't match. */ if (sock && sock->type != type) { - blender::bke::node_remove_socket(ntree, node, sock); + blender::bke::node_remove_socket(*ntree, *node, *sock); sock = nullptr; } @@ -107,7 +107,7 @@ static void cmp_node_image_add_pass_output(bNodeTree *ntree, } else { sock = blender::bke::node_add_static_socket( - ntree, node, SOCK_OUT, type, PROP_NONE, name, name); + *ntree, *node, SOCK_OUT, type, PROP_NONE, name, name); } /* extra socket info */ NodeImageLayer *sockdata = MEM_cnew(__func__); @@ -367,7 +367,7 @@ static void cmp_node_image_verify_outputs(bNodeTree *ntree, bNode *node, bool rl sock_next = sock->next; if (BLI_linklist_index(available_sockets.list, sock) >= 0) { sock->flag &= ~SOCK_HIDDEN; - blender::bke::node_set_socket_availability(ntree, sock, true); + blender::bke::node_set_socket_availability(*ntree, *sock, true); } else { bNodeLink *link; @@ -378,10 +378,10 @@ static void cmp_node_image_verify_outputs(bNodeTree *ntree, bNode *node, bool rl } if (!link && (!rlayer || sock_index >= NUM_LEGACY_SOCKETS)) { MEM_freeN(sock->storage); - blender::bke::node_remove_socket(ntree, node, sock); + blender::bke::node_remove_socket(*ntree, *node, *sock); } else { - blender::bke::node_set_socket_availability(ntree, sock, false); + blender::bke::node_set_socket_availability(*ntree, *sock, false); } } } @@ -515,13 +515,13 @@ void register_node_type_cmp_image() ntype.nclass = NODE_CLASS_INPUT; ntype.initfunc = file_ns::node_composit_init_image; blender::bke::node_type_storage( - &ntype, "ImageUser", file_ns::node_composit_free_image, file_ns::node_composit_copy_image); + ntype, "ImageUser", file_ns::node_composit_free_image, file_ns::node_composit_copy_image); ntype.updatefunc = file_ns::cmp_node_image_update; ntype.get_compositor_operation = file_ns::get_compositor_operation; ntype.labelfunc = node_image_label; ntype.flag |= NODE_PREVIEW; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } /* **************** RENDER RESULT ******************** */ @@ -834,13 +834,13 @@ void register_node_type_cmp_rlayers() ntype.compositor_unsupported_message = N_( "Render passes in the Viewport compositor are only supported in EEVEE"); ntype.flag |= NODE_PREVIEW; - blender::bke::node_type_storage(&ntype, + blender::bke::node_type_storage(ntype, std::nullopt, file_ns::node_composit_free_rlayers, file_ns::node_composit_copy_rlayers); ntype.updatefunc = file_ns::cmp_node_rlayers_update; ntype.initfunc = node_cmp_rlayers_outputs; - blender::bke::node_type_size_preset(&ntype, blender::bke::eNodeSizePreset::Large); + blender::bke::node_type_size_preset(ntype, blender::bke::eNodeSizePreset::Large); - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } diff --git a/source/blender/nodes/composite/nodes/node_composite_inpaint.cc b/source/blender/nodes/composite/nodes/node_composite_inpaint.cc index b3b0b1d7964..229153b6ce7 100644 --- a/source/blender/nodes/composite/nodes/node_composite_inpaint.cc +++ b/source/blender/nodes/composite/nodes/node_composite_inpaint.cc @@ -371,5 +371,5 @@ void register_node_type_cmp_inpaint() ntype.draw_buttons = file_ns::node_composit_buts_inpaint; ntype.get_compositor_operation = file_ns::get_compositor_operation; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } diff --git a/source/blender/nodes/composite/nodes/node_composite_invert.cc b/source/blender/nodes/composite/nodes/node_composite_invert.cc index a47d7ab047f..870b2c1d7c2 100644 --- a/source/blender/nodes/composite/nodes/node_composite_invert.cc +++ b/source/blender/nodes/composite/nodes/node_composite_invert.cc @@ -160,5 +160,5 @@ void register_node_type_cmp_invert() ntype.gpu_fn = file_ns::node_gpu_material; ntype.build_multi_function = file_ns::node_build_multi_function; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } diff --git a/source/blender/nodes/composite/nodes/node_composite_keying.cc b/source/blender/nodes/composite/nodes/node_composite_keying.cc index c763a7407e4..f7b3ba4805b 100644 --- a/source/blender/nodes/composite/nodes/node_composite_keying.cc +++ b/source/blender/nodes/composite/nodes/node_composite_keying.cc @@ -688,8 +688,8 @@ void register_node_type_cmp_keying() ntype.draw_buttons = file_ns::node_composit_buts_keying; ntype.initfunc = file_ns::node_composit_init_keying; blender::bke::node_type_storage( - &ntype, "NodeKeyingData", node_free_standard_storage, node_copy_standard_storage); + ntype, "NodeKeyingData", node_free_standard_storage, node_copy_standard_storage); ntype.get_compositor_operation = file_ns::get_compositor_operation; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } diff --git a/source/blender/nodes/composite/nodes/node_composite_keyingscreen.cc b/source/blender/nodes/composite/nodes/node_composite_keyingscreen.cc index 9c1e703bfb5..8af9beaca2a 100644 --- a/source/blender/nodes/composite/nodes/node_composite_keyingscreen.cc +++ b/source/blender/nodes/composite/nodes/node_composite_keyingscreen.cc @@ -177,8 +177,8 @@ void register_node_type_cmp_keyingscreen() ntype.draw_buttons = file_ns::node_composit_buts_keyingscreen; ntype.initfunc_api = file_ns::node_composit_init_keyingscreen; blender::bke::node_type_storage( - &ntype, "NodeKeyingScreenData", node_free_standard_storage, node_copy_standard_storage); + ntype, "NodeKeyingScreenData", node_free_standard_storage, node_copy_standard_storage); ntype.get_compositor_operation = file_ns::get_compositor_operation; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } diff --git a/source/blender/nodes/composite/nodes/node_composite_kuwahara.cc b/source/blender/nodes/composite/nodes/node_composite_kuwahara.cc index 426272773cf..d6769068997 100644 --- a/source/blender/nodes/composite/nodes/node_composite_kuwahara.cc +++ b/source/blender/nodes/composite/nodes/node_composite_kuwahara.cc @@ -795,8 +795,8 @@ void register_node_type_cmp_kuwahara() ntype.draw_buttons = file_ns::node_composit_buts_kuwahara; ntype.initfunc = file_ns::node_composit_init_kuwahara; blender::bke::node_type_storage( - &ntype, "NodeKuwaharaData", node_free_standard_storage, node_copy_standard_storage); + ntype, "NodeKuwaharaData", node_free_standard_storage, node_copy_standard_storage); ntype.get_compositor_operation = file_ns::get_compositor_operation; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } diff --git a/source/blender/nodes/composite/nodes/node_composite_lensdist.cc b/source/blender/nodes/composite/nodes/node_composite_lensdist.cc index be273e89573..20364e123af 100644 --- a/source/blender/nodes/composite/nodes/node_composite_lensdist.cc +++ b/source/blender/nodes/composite/nodes/node_composite_lensdist.cc @@ -514,8 +514,8 @@ void register_node_type_cmp_lensdist() ntype.draw_buttons = file_ns::node_composit_buts_lensdist; ntype.initfunc = file_ns::node_composit_init_lensdist; blender::bke::node_type_storage( - &ntype, "NodeLensDist", node_free_standard_storage, node_copy_standard_storage); + ntype, "NodeLensDist", node_free_standard_storage, node_copy_standard_storage); ntype.get_compositor_operation = file_ns::get_compositor_operation; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } diff --git a/source/blender/nodes/composite/nodes/node_composite_levels.cc b/source/blender/nodes/composite/nodes/node_composite_levels.cc index 36a49d71047..2889af4c9ae 100644 --- a/source/blender/nodes/composite/nodes/node_composite_levels.cc +++ b/source/blender/nodes/composite/nodes/node_composite_levels.cc @@ -209,5 +209,5 @@ void register_node_type_cmp_view_levels() ntype.initfunc = file_ns::node_composit_init_view_levels; ntype.get_compositor_operation = file_ns::get_compositor_operation; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } diff --git a/source/blender/nodes/composite/nodes/node_composite_luma_matte.cc b/source/blender/nodes/composite/nodes/node_composite_luma_matte.cc index d7400a86765..7765a2a1b3d 100644 --- a/source/blender/nodes/composite/nodes/node_composite_luma_matte.cc +++ b/source/blender/nodes/composite/nodes/node_composite_luma_matte.cc @@ -136,9 +136,9 @@ void register_node_type_cmp_luma_matte() ntype.flag |= NODE_PREVIEW; ntype.initfunc = file_ns::node_composit_init_luma_matte; blender::bke::node_type_storage( - &ntype, "NodeChroma", node_free_standard_storage, node_copy_standard_storage); + ntype, "NodeChroma", node_free_standard_storage, node_copy_standard_storage); ntype.gpu_fn = file_ns::node_gpu_material; ntype.build_multi_function = file_ns::node_build_multi_function; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } diff --git a/source/blender/nodes/composite/nodes/node_composite_map_range.cc b/source/blender/nodes/composite/nodes/node_composite_map_range.cc index 0a396841bda..1ea9da8776a 100644 --- a/source/blender/nodes/composite/nodes/node_composite_map_range.cc +++ b/source/blender/nodes/composite/nodes/node_composite_map_range.cc @@ -169,5 +169,5 @@ void register_node_type_cmp_map_range() ntype.gpu_fn = file_ns::node_gpu_material; ntype.build_multi_function = file_ns::node_build_multi_function; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } diff --git a/source/blender/nodes/composite/nodes/node_composite_map_uv.cc b/source/blender/nodes/composite/nodes/node_composite_map_uv.cc index 721862aa014..1a07e66b7cf 100644 --- a/source/blender/nodes/composite/nodes/node_composite_map_uv.cc +++ b/source/blender/nodes/composite/nodes/node_composite_map_uv.cc @@ -312,5 +312,5 @@ void register_node_type_cmp_mapuv() ntype.get_compositor_operation = file_ns::get_compositor_operation; ntype.initfunc = file_ns::node_composit_init_map_uv; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } diff --git a/source/blender/nodes/composite/nodes/node_composite_map_value.cc b/source/blender/nodes/composite/nodes/node_composite_map_value.cc index be247d24e1e..053f2717f96 100644 --- a/source/blender/nodes/composite/nodes/node_composite_map_value.cc +++ b/source/blender/nodes/composite/nodes/node_composite_map_value.cc @@ -191,9 +191,9 @@ void register_node_type_cmp_map_value() ntype.draw_buttons = file_ns::node_composit_buts_map_value; ntype.initfunc = file_ns::node_composit_init_map_value; blender::bke::node_type_storage( - &ntype, "TexMapping", node_free_standard_storage, node_copy_standard_storage); + ntype, "TexMapping", node_free_standard_storage, node_copy_standard_storage); ntype.gpu_fn = file_ns::node_gpu_material; ntype.build_multi_function = file_ns::node_build_multi_function; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } diff --git a/source/blender/nodes/composite/nodes/node_composite_mask.cc b/source/blender/nodes/composite/nodes/node_composite_mask.cc index 3b43ef409a1..dd7aa775a6f 100644 --- a/source/blender/nodes/composite/nodes/node_composite_mask.cc +++ b/source/blender/nodes/composite/nodes/node_composite_mask.cc @@ -189,7 +189,7 @@ void register_node_type_cmp_mask() ntype.get_compositor_operation = file_ns::get_compositor_operation; blender::bke::node_type_storage( - &ntype, "NodeMask", node_free_standard_storage, node_copy_standard_storage); + ntype, "NodeMask", node_free_standard_storage, node_copy_standard_storage); - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } diff --git a/source/blender/nodes/composite/nodes/node_composite_math.cc b/source/blender/nodes/composite/nodes/node_composite_math.cc index cf9dfc21afd..47604de0df3 100644 --- a/source/blender/nodes/composite/nodes/node_composite_math.cc +++ b/source/blender/nodes/composite/nodes/node_composite_math.cc @@ -128,5 +128,5 @@ void register_node_type_cmp_math() ntype.gather_link_search_ops = file_ns::node_gather_link_searches; ntype.build_multi_function = blender::nodes::node_math_build_multi_function; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } diff --git a/source/blender/nodes/composite/nodes/node_composite_mixrgb.cc b/source/blender/nodes/composite/nodes/node_composite_mixrgb.cc index afdf15d099d..3c2c7790870 100644 --- a/source/blender/nodes/composite/nodes/node_composite_mixrgb.cc +++ b/source/blender/nodes/composite/nodes/node_composite_mixrgb.cc @@ -248,5 +248,5 @@ void register_node_type_cmp_mix_rgb() ntype.gpu_fn = file_ns::node_gpu_material; ntype.build_multi_function = file_ns::node_build_multi_function; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } diff --git a/source/blender/nodes/composite/nodes/node_composite_movieclip.cc b/source/blender/nodes/composite/nodes/node_composite_movieclip.cc index c0cb065d8ea..ade661f0634 100644 --- a/source/blender/nodes/composite/nodes/node_composite_movieclip.cc +++ b/source/blender/nodes/composite/nodes/node_composite_movieclip.cc @@ -279,7 +279,7 @@ void register_node_type_cmp_movieclip() ntype.initfunc_api = file_ns::init; ntype.flag |= NODE_PREVIEW; blender::bke::node_type_storage( - &ntype, "MovieClipUser", node_free_standard_storage, node_copy_standard_storage); + ntype, "MovieClipUser", node_free_standard_storage, node_copy_standard_storage); - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } diff --git a/source/blender/nodes/composite/nodes/node_composite_moviedistortion.cc b/source/blender/nodes/composite/nodes/node_composite_moviedistortion.cc index 16aa774ad3b..5eee6f542d4 100644 --- a/source/blender/nodes/composite/nodes/node_composite_moviedistortion.cc +++ b/source/blender/nodes/composite/nodes/node_composite_moviedistortion.cc @@ -179,8 +179,8 @@ void register_node_type_cmp_moviedistortion() ntype.draw_buttons = file_ns::node_composit_buts_moviedistortion; ntype.initfunc_api = file_ns::init; blender::bke::node_type_storage( - &ntype, std::nullopt, file_ns::storage_free, file_ns::storage_copy); + ntype, std::nullopt, file_ns::storage_free, file_ns::storage_copy); ntype.get_compositor_operation = file_ns::get_compositor_operation; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } diff --git a/source/blender/nodes/composite/nodes/node_composite_normal.cc b/source/blender/nodes/composite/nodes/node_composite_normal.cc index 0c4156ba931..95726928add 100644 --- a/source/blender/nodes/composite/nodes/node_composite_normal.cc +++ b/source/blender/nodes/composite/nodes/node_composite_normal.cc @@ -95,5 +95,5 @@ void register_node_type_cmp_normal() ntype.gpu_fn = file_ns::node_gpu_material; ntype.build_multi_function = file_ns::node_build_multi_function; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } diff --git a/source/blender/nodes/composite/nodes/node_composite_normalize.cc b/source/blender/nodes/composite/nodes/node_composite_normalize.cc index b6d3c0bae12..349a0c09406 100644 --- a/source/blender/nodes/composite/nodes/node_composite_normalize.cc +++ b/source/blender/nodes/composite/nodes/node_composite_normalize.cc @@ -123,5 +123,5 @@ void register_node_type_cmp_normalize() ntype.declare = file_ns::cmp_node_normalize_declare; ntype.get_compositor_operation = file_ns::get_compositor_operation; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } diff --git a/source/blender/nodes/composite/nodes/node_composite_pixelate.cc b/source/blender/nodes/composite/nodes/node_composite_pixelate.cc index a9789c6b5ba..5edfdcb5f10 100644 --- a/source/blender/nodes/composite/nodes/node_composite_pixelate.cc +++ b/source/blender/nodes/composite/nodes/node_composite_pixelate.cc @@ -144,5 +144,5 @@ void register_node_type_cmp_pixelate() ntype.initfunc = file_ns::node_composit_init_pixelate; ntype.get_compositor_operation = file_ns::get_compositor_operation; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } diff --git a/source/blender/nodes/composite/nodes/node_composite_planetrackdeform.cc b/source/blender/nodes/composite/nodes/node_composite_planetrackdeform.cc index 4b434c295c9..77de89a03d4 100644 --- a/source/blender/nodes/composite/nodes/node_composite_planetrackdeform.cc +++ b/source/blender/nodes/composite/nodes/node_composite_planetrackdeform.cc @@ -446,8 +446,8 @@ void register_node_type_cmp_planetrackdeform() ntype.draw_buttons = file_ns::node_composit_buts_planetrackdeform; ntype.initfunc_api = file_ns::init; blender::bke::node_type_storage( - &ntype, "NodePlaneTrackDeformData", node_free_standard_storage, node_copy_standard_storage); + ntype, "NodePlaneTrackDeformData", node_free_standard_storage, node_copy_standard_storage); ntype.get_compositor_operation = file_ns::get_compositor_operation; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } diff --git a/source/blender/nodes/composite/nodes/node_composite_posterize.cc b/source/blender/nodes/composite/nodes/node_composite_posterize.cc index a1a3c39f998..2b7ec2dee8b 100644 --- a/source/blender/nodes/composite/nodes/node_composite_posterize.cc +++ b/source/blender/nodes/composite/nodes/node_composite_posterize.cc @@ -76,5 +76,5 @@ void register_node_type_cmp_posterize() ntype.gpu_fn = file_ns::node_gpu_material; ntype.build_multi_function = file_ns::node_build_multi_function; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } diff --git a/source/blender/nodes/composite/nodes/node_composite_premulkey.cc b/source/blender/nodes/composite/nodes/node_composite_premulkey.cc index c84d9ddc41e..8ec90f9f439 100644 --- a/source/blender/nodes/composite/nodes/node_composite_premulkey.cc +++ b/source/blender/nodes/composite/nodes/node_composite_premulkey.cc @@ -104,5 +104,5 @@ void register_node_type_cmp_premulkey() ntype.gpu_fn = file_ns::node_gpu_material; ntype.build_multi_function = file_ns::node_build_multi_function; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } diff --git a/source/blender/nodes/composite/nodes/node_composite_rgb.cc b/source/blender/nodes/composite/nodes/node_composite_rgb.cc index f7614161cd9..f1f1bf2dd8e 100644 --- a/source/blender/nodes/composite/nodes/node_composite_rgb.cc +++ b/source/blender/nodes/composite/nodes/node_composite_rgb.cc @@ -60,8 +60,8 @@ void register_node_type_cmp_rgb() ntype.enum_name_legacy = "RGB"; ntype.nclass = NODE_CLASS_INPUT; ntype.declare = file_ns::cmp_node_rgb_declare; - blender::bke::node_type_size_preset(&ntype, blender::bke::eNodeSizePreset::Default); + blender::bke::node_type_size_preset(ntype, blender::bke::eNodeSizePreset::Default); ntype.get_compositor_operation = file_ns::get_compositor_operation; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } diff --git a/source/blender/nodes/composite/nodes/node_composite_rotate.cc b/source/blender/nodes/composite/nodes/node_composite_rotate.cc index 660a718b3af..7b4637d1821 100644 --- a/source/blender/nodes/composite/nodes/node_composite_rotate.cc +++ b/source/blender/nodes/composite/nodes/node_composite_rotate.cc @@ -104,5 +104,5 @@ void register_node_type_cmp_rotate() ntype.initfunc = file_ns::node_composit_init_rotate; ntype.get_compositor_operation = file_ns::get_compositor_operation; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } diff --git a/source/blender/nodes/composite/nodes/node_composite_scale.cc b/source/blender/nodes/composite/nodes/node_composite_scale.cc index 0d35f7b929e..523f1af0394 100644 --- a/source/blender/nodes/composite/nodes/node_composite_scale.cc +++ b/source/blender/nodes/composite/nodes/node_composite_scale.cc @@ -59,7 +59,7 @@ static void node_composite_update_scale(bNodeTree *ntree, bNode *node) /* Only show X/Y scale factor inputs for modes using them! */ LISTBASE_FOREACH (bNodeSocket *, sock, &node->inputs) { if (STR_ELEM(sock->name, "X", "Y")) { - bke::node_set_socket_availability(ntree, sock, use_xy_scale); + bke::node_set_socket_availability(*ntree, *sock, use_xy_scale); } } } @@ -330,5 +330,5 @@ void register_node_type_cmp_scale() ntype.updatefunc = file_ns::node_composite_update_scale; ntype.get_compositor_operation = file_ns::get_compositor_operation; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } diff --git a/source/blender/nodes/composite/nodes/node_composite_scene_time.cc b/source/blender/nodes/composite/nodes/node_composite_scene_time.cc index 6037237143b..581f4494643 100644 --- a/source/blender/nodes/composite/nodes/node_composite_scene_time.cc +++ b/source/blender/nodes/composite/nodes/node_composite_scene_time.cc @@ -63,5 +63,5 @@ void register_node_type_cmp_scene_time() ntype.declare = blender::nodes::cmp_node_scene_time_declare; ntype.get_compositor_operation = blender::nodes::get_compositor_operation; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } diff --git a/source/blender/nodes/composite/nodes/node_composite_sepcomb_color.cc b/source/blender/nodes/composite/nodes/node_composite_sepcomb_color.cc index adb914fca57..b4ade27d0c0 100644 --- a/source/blender/nodes/composite/nodes/node_composite_sepcomb_color.cc +++ b/source/blender/nodes/composite/nodes/node_composite_sepcomb_color.cc @@ -235,12 +235,12 @@ void register_node_type_cmp_separate_color() ntype.declare = file_ns::cmp_node_separate_color_declare; ntype.initfunc = node_cmp_combsep_color_init; blender::bke::node_type_storage( - &ntype, "NodeCMPCombSepColor", node_free_standard_storage, node_copy_standard_storage); + ntype, "NodeCMPCombSepColor", node_free_standard_storage, node_copy_standard_storage); ntype.updatefunc = file_ns::cmp_node_separate_color_update; ntype.gpu_fn = file_ns::node_gpu_material; ntype.build_multi_function = file_ns::node_build_multi_function; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } /* **************** COMBINE COLOR ******************** */ @@ -450,10 +450,10 @@ void register_node_type_cmp_combine_color() ntype.declare = file_ns::cmp_node_combine_color_declare; ntype.initfunc = node_cmp_combsep_color_init; blender::bke::node_type_storage( - &ntype, "NodeCMPCombSepColor", node_free_standard_storage, node_copy_standard_storage); + ntype, "NodeCMPCombSepColor", node_free_standard_storage, node_copy_standard_storage); ntype.updatefunc = file_ns::cmp_node_combine_color_update; ntype.gpu_fn = file_ns::node_gpu_material; ntype.build_multi_function = file_ns::node_build_multi_function; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } diff --git a/source/blender/nodes/composite/nodes/node_composite_sepcomb_hsva.cc b/source/blender/nodes/composite/nodes/node_composite_sepcomb_hsva.cc index 903c7fc1137..f28a60b195f 100644 --- a/source/blender/nodes/composite/nodes/node_composite_sepcomb_hsva.cc +++ b/source/blender/nodes/composite/nodes/node_composite_sepcomb_hsva.cc @@ -73,7 +73,7 @@ void register_node_type_cmp_sephsva() ntype.gpu_fn = file_ns::node_gpu_material; ntype.build_multi_function = file_ns::node_build_multi_function; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } /* **************** COMBINE HSVA ******************** */ @@ -149,5 +149,5 @@ void register_node_type_cmp_combhsva() ntype.gpu_fn = file_ns::node_gpu_material; ntype.build_multi_function = file_ns::node_build_multi_function; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } diff --git a/source/blender/nodes/composite/nodes/node_composite_sepcomb_rgba.cc b/source/blender/nodes/composite/nodes/node_composite_sepcomb_rgba.cc index 2961a9c07f7..7167d9d72ac 100644 --- a/source/blender/nodes/composite/nodes/node_composite_sepcomb_rgba.cc +++ b/source/blender/nodes/composite/nodes/node_composite_sepcomb_rgba.cc @@ -74,7 +74,7 @@ void register_node_type_cmp_seprgba() ntype.gpu_fn = file_ns::node_gpu_material; ntype.build_multi_function = file_ns::node_build_multi_function; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } /* **************** COMBINE RGBA ******************** */ @@ -147,5 +147,5 @@ void register_node_type_cmp_combrgba() ntype.gpu_fn = file_ns::node_gpu_material; ntype.build_multi_function = file_ns::node_build_multi_function; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } diff --git a/source/blender/nodes/composite/nodes/node_composite_sepcomb_xyz.cc b/source/blender/nodes/composite/nodes/node_composite_sepcomb_xyz.cc index f157a50d911..ae166848ae2 100644 --- a/source/blender/nodes/composite/nodes/node_composite_sepcomb_xyz.cc +++ b/source/blender/nodes/composite/nodes/node_composite_sepcomb_xyz.cc @@ -69,7 +69,7 @@ void register_node_type_cmp_separate_xyz() ntype.gpu_fn = file_ns::node_gpu_material; ntype.build_multi_function = file_ns::node_build_multi_function; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } /* **************** COMBINE XYZ ******************** */ @@ -121,5 +121,5 @@ void register_node_type_cmp_combine_xyz() ntype.gpu_fn = file_ns::node_gpu_material; ntype.build_multi_function = file_ns::node_build_multi_function; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } diff --git a/source/blender/nodes/composite/nodes/node_composite_sepcomb_ycca.cc b/source/blender/nodes/composite/nodes/node_composite_sepcomb_ycca.cc index aaafb2aa96c..035242efa09 100644 --- a/source/blender/nodes/composite/nodes/node_composite_sepcomb_ycca.cc +++ b/source/blender/nodes/composite/nodes/node_composite_sepcomb_ycca.cc @@ -127,7 +127,7 @@ void register_node_type_cmp_sepycca() ntype.gpu_fn = file_ns::node_gpu_material; ntype.build_multi_function = file_ns::node_build_multi_function; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } /* **************** COMBINE YCCA ******************** */ @@ -269,5 +269,5 @@ void register_node_type_cmp_combycca() ntype.gpu_fn = file_ns::node_gpu_material; ntype.build_multi_function = file_ns::node_build_multi_function; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } diff --git a/source/blender/nodes/composite/nodes/node_composite_sepcomb_yuva.cc b/source/blender/nodes/composite/nodes/node_composite_sepcomb_yuva.cc index b9049814903..a4b77703320 100644 --- a/source/blender/nodes/composite/nodes/node_composite_sepcomb_yuva.cc +++ b/source/blender/nodes/composite/nodes/node_composite_sepcomb_yuva.cc @@ -73,7 +73,7 @@ void register_node_type_cmp_sepyuva() ntype.gpu_fn = file_ns::node_gpu_material; ntype.build_multi_function = file_ns::node_build_multi_function; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } /* **************** COMBINE YUVA ******************** */ @@ -149,5 +149,5 @@ void register_node_type_cmp_combyuva() ntype.gpu_fn = file_ns::node_gpu_material; ntype.build_multi_function = file_ns::node_build_multi_function; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } diff --git a/source/blender/nodes/composite/nodes/node_composite_setalpha.cc b/source/blender/nodes/composite/nodes/node_composite_setalpha.cc index 97559d6bdaf..cea1e975c87 100644 --- a/source/blender/nodes/composite/nodes/node_composite_setalpha.cc +++ b/source/blender/nodes/composite/nodes/node_composite_setalpha.cc @@ -112,9 +112,9 @@ void register_node_type_cmp_setalpha() ntype.draw_buttons = file_ns::node_composit_buts_set_alpha; ntype.initfunc = file_ns::node_composit_init_setalpha; blender::bke::node_type_storage( - &ntype, "NodeSetAlpha", node_free_standard_storage, node_copy_standard_storage); + ntype, "NodeSetAlpha", node_free_standard_storage, node_copy_standard_storage); ntype.gpu_fn = file_ns::node_gpu_material; ntype.build_multi_function = file_ns::node_build_multi_function; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } diff --git a/source/blender/nodes/composite/nodes/node_composite_split.cc b/source/blender/nodes/composite/nodes/node_composite_split.cc index 41fa9445495..471fd19a3c5 100644 --- a/source/blender/nodes/composite/nodes/node_composite_split.cc +++ b/source/blender/nodes/composite/nodes/node_composite_split.cc @@ -163,5 +163,5 @@ void register_node_type_cmp_split() ntype.no_muting = true; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } diff --git a/source/blender/nodes/composite/nodes/node_composite_stabilize2d.cc b/source/blender/nodes/composite/nodes/node_composite_stabilize2d.cc index 69b66ccc683..acd9a2dc030 100644 --- a/source/blender/nodes/composite/nodes/node_composite_stabilize2d.cc +++ b/source/blender/nodes/composite/nodes/node_composite_stabilize2d.cc @@ -153,5 +153,5 @@ void register_node_type_cmp_stabilize2d() ntype.initfunc_api = file_ns::init; ntype.get_compositor_operation = file_ns::get_compositor_operation; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } diff --git a/source/blender/nodes/composite/nodes/node_composite_sunbeams.cc b/source/blender/nodes/composite/nodes/node_composite_sunbeams.cc index 55dd4950100..7532549c0aa 100644 --- a/source/blender/nodes/composite/nodes/node_composite_sunbeams.cc +++ b/source/blender/nodes/composite/nodes/node_composite_sunbeams.cc @@ -179,8 +179,8 @@ void register_node_type_cmp_sunbeams() ntype.draw_buttons = file_ns::node_composit_buts_sunbeams; ntype.initfunc = file_ns::init; blender::bke::node_type_storage( - &ntype, "NodeSunBeams", node_free_standard_storage, node_copy_standard_storage); + ntype, "NodeSunBeams", node_free_standard_storage, node_copy_standard_storage); ntype.get_compositor_operation = file_ns::get_compositor_operation; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } diff --git a/source/blender/nodes/composite/nodes/node_composite_switch.cc b/source/blender/nodes/composite/nodes/node_composite_switch.cc index 9e6cdc3b9ab..3bffc5c4652 100644 --- a/source/blender/nodes/composite/nodes/node_composite_switch.cc +++ b/source/blender/nodes/composite/nodes/node_composite_switch.cc @@ -68,8 +68,8 @@ void register_node_type_cmp_switch() ntype.nclass = NODE_CLASS_CONVERTER; ntype.declare = file_ns::cmp_node_switch_declare; ntype.draw_buttons = file_ns::node_composit_buts_switch; - blender::bke::node_type_size_preset(&ntype, blender::bke::eNodeSizePreset::Default); + blender::bke::node_type_size_preset(ntype, blender::bke::eNodeSizePreset::Default); ntype.get_compositor_operation = file_ns::get_compositor_operation; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } diff --git a/source/blender/nodes/composite/nodes/node_composite_switchview.cc b/source/blender/nodes/composite/nodes/node_composite_switchview.cc index 0d994fd5465..794710bb379 100644 --- a/source/blender/nodes/composite/nodes/node_composite_switchview.cc +++ b/source/blender/nodes/composite/nodes/node_composite_switchview.cc @@ -97,5 +97,5 @@ void register_node_type_cmp_switch_view() ntype.initfunc_api = file_ns::init_switch_view; ntype.get_compositor_operation = file_ns::get_compositor_operation; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } diff --git a/source/blender/nodes/composite/nodes/node_composite_texture.cc b/source/blender/nodes/composite/nodes/node_composite_texture.cc index 2a8507b8bc9..04d36c2e0cc 100644 --- a/source/blender/nodes/composite/nodes/node_composite_texture.cc +++ b/source/blender/nodes/composite/nodes/node_composite_texture.cc @@ -120,5 +120,5 @@ void register_node_type_cmp_texture() ntype.flag |= NODE_PREVIEW; ntype.get_compositor_operation = file_ns::get_compositor_operation; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } diff --git a/source/blender/nodes/composite/nodes/node_composite_tonemap.cc b/source/blender/nodes/composite/nodes/node_composite_tonemap.cc index c0b06342b5e..b1d4f983245 100644 --- a/source/blender/nodes/composite/nodes/node_composite_tonemap.cc +++ b/source/blender/nodes/composite/nodes/node_composite_tonemap.cc @@ -439,8 +439,8 @@ void register_node_type_cmp_tonemap() ntype.draw_buttons = file_ns::node_composit_buts_tonemap; ntype.initfunc = file_ns::node_composit_init_tonemap; blender::bke::node_type_storage( - &ntype, "NodeTonemap", node_free_standard_storage, node_copy_standard_storage); + ntype, "NodeTonemap", node_free_standard_storage, node_copy_standard_storage); ntype.get_compositor_operation = file_ns::get_compositor_operation; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } diff --git a/source/blender/nodes/composite/nodes/node_composite_trackpos.cc b/source/blender/nodes/composite/nodes/node_composite_trackpos.cc index 8cc68003099..741b28b2772 100644 --- a/source/blender/nodes/composite/nodes/node_composite_trackpos.cc +++ b/source/blender/nodes/composite/nodes/node_composite_trackpos.cc @@ -365,8 +365,8 @@ void register_node_type_cmp_trackpos() ntype.draw_buttons = file_ns::node_composit_buts_trackpos; ntype.initfunc_api = file_ns::init; blender::bke::node_type_storage( - &ntype, "NodeTrackPosData", node_free_standard_storage, node_copy_standard_storage); + ntype, "NodeTrackPosData", node_free_standard_storage, node_copy_standard_storage); ntype.get_compositor_operation = file_ns::get_compositor_operation; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } diff --git a/source/blender/nodes/composite/nodes/node_composite_transform.cc b/source/blender/nodes/composite/nodes/node_composite_transform.cc index b84ac83fed6..9be1436552d 100644 --- a/source/blender/nodes/composite/nodes/node_composite_transform.cc +++ b/source/blender/nodes/composite/nodes/node_composite_transform.cc @@ -117,5 +117,5 @@ void register_node_type_cmp_transform() ntype.draw_buttons = file_ns::node_composit_buts_transform; ntype.get_compositor_operation = file_ns::get_compositor_operation; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } diff --git a/source/blender/nodes/composite/nodes/node_composite_translate.cc b/source/blender/nodes/composite/nodes/node_composite_translate.cc index 817889d780f..ee600cf4e59 100644 --- a/source/blender/nodes/composite/nodes/node_composite_translate.cc +++ b/source/blender/nodes/composite/nodes/node_composite_translate.cc @@ -139,8 +139,8 @@ void register_node_type_cmp_translate() ntype.draw_buttons = file_ns::node_composit_buts_translate; ntype.initfunc = file_ns::node_composit_init_translate; blender::bke::node_type_storage( - &ntype, "NodeTranslateData", node_free_standard_storage, node_copy_standard_storage); + ntype, "NodeTranslateData", node_free_standard_storage, node_copy_standard_storage); ntype.get_compositor_operation = file_ns::get_compositor_operation; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } diff --git a/source/blender/nodes/composite/nodes/node_composite_val_to_rgb.cc b/source/blender/nodes/composite/nodes/node_composite_val_to_rgb.cc index 927724e7702..8e7b952fbc7 100644 --- a/source/blender/nodes/composite/nodes/node_composite_val_to_rgb.cc +++ b/source/blender/nodes/composite/nodes/node_composite_val_to_rgb.cc @@ -142,14 +142,14 @@ void register_node_type_cmp_valtorgb() ntype.enum_name_legacy = "VALTORGB"; ntype.nclass = NODE_CLASS_CONVERTER; ntype.declare = file_ns::cmp_node_valtorgb_declare; - blender::bke::node_type_size(&ntype, 240, 200, 320); + blender::bke::node_type_size(ntype, 240, 200, 320); ntype.initfunc = file_ns::node_composit_init_valtorgb; blender::bke::node_type_storage( - &ntype, "ColorBand", node_free_standard_storage, node_copy_standard_storage); + ntype, "ColorBand", node_free_standard_storage, node_copy_standard_storage); ntype.gpu_fn = file_ns::node_gpu_material; ntype.build_multi_function = file_ns::node_build_multi_function; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } /* **************** RGBTOBW ******************** */ @@ -208,9 +208,9 @@ void register_node_type_cmp_rgbtobw() ntype.enum_name_legacy = "RGBTOBW"; ntype.nclass = NODE_CLASS_CONVERTER; ntype.declare = file_ns::cmp_node_rgbtobw_declare; - blender::bke::node_type_size_preset(&ntype, blender::bke::eNodeSizePreset::Default); + blender::bke::node_type_size_preset(ntype, blender::bke::eNodeSizePreset::Default); ntype.gpu_fn = file_ns::node_gpu_material; ntype.build_multi_function = file_ns::node_build_multi_function; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } diff --git a/source/blender/nodes/composite/nodes/node_composite_value.cc b/source/blender/nodes/composite/nodes/node_composite_value.cc index 71344cf5aaf..2d9eda47e5b 100644 --- a/source/blender/nodes/composite/nodes/node_composite_value.cc +++ b/source/blender/nodes/composite/nodes/node_composite_value.cc @@ -56,8 +56,8 @@ void register_node_type_cmp_value() ntype.enum_name_legacy = "VALUE"; ntype.nclass = NODE_CLASS_INPUT; ntype.declare = file_ns::cmp_node_value_declare; - blender::bke::node_type_size_preset(&ntype, blender::bke::eNodeSizePreset::Default); + blender::bke::node_type_size_preset(ntype, blender::bke::eNodeSizePreset::Default); ntype.get_compositor_operation = file_ns::get_compositor_operation; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } diff --git a/source/blender/nodes/composite/nodes/node_composite_vec_blur.cc b/source/blender/nodes/composite/nodes/node_composite_vec_blur.cc index b1a54a1a5e7..ec13a9ea2b2 100644 --- a/source/blender/nodes/composite/nodes/node_composite_vec_blur.cc +++ b/source/blender/nodes/composite/nodes/node_composite_vec_blur.cc @@ -686,8 +686,8 @@ void register_node_type_cmp_vecblur() ntype.draw_buttons = file_ns::node_composit_buts_vecblur; ntype.initfunc = file_ns::node_composit_init_vecblur; blender::bke::node_type_storage( - &ntype, "NodeBlurData", node_free_standard_storage, node_copy_standard_storage); + ntype, "NodeBlurData", node_free_standard_storage, node_copy_standard_storage); ntype.get_compositor_operation = file_ns::get_compositor_operation; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } diff --git a/source/blender/nodes/composite/nodes/node_composite_viewer.cc b/source/blender/nodes/composite/nodes/node_composite_viewer.cc index e7a7153ada9..608a187dc56 100644 --- a/source/blender/nodes/composite/nodes/node_composite_viewer.cc +++ b/source/blender/nodes/composite/nodes/node_composite_viewer.cc @@ -336,10 +336,10 @@ void register_node_type_cmp_viewer() ntype.draw_buttons = file_ns::node_composit_buts_viewer; ntype.initfunc = file_ns::node_composit_init_viewer; blender::bke::node_type_storage( - &ntype, "ImageUser", node_free_standard_storage, node_copy_standard_storage); + ntype, "ImageUser", node_free_standard_storage, node_copy_standard_storage); ntype.get_compositor_operation = file_ns::get_compositor_operation; ntype.no_muting = true; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } diff --git a/source/blender/nodes/composite/nodes/node_composite_zcombine.cc b/source/blender/nodes/composite/nodes/node_composite_zcombine.cc index 71d0dae96d8..ac942eb622d 100644 --- a/source/blender/nodes/composite/nodes/node_composite_zcombine.cc +++ b/source/blender/nodes/composite/nodes/node_composite_zcombine.cc @@ -389,5 +389,5 @@ void register_node_type_cmp_zcombine() ntype.draw_buttons = file_ns::node_composit_buts_zcombine; ntype.get_compositor_operation = file_ns::get_compositor_operation; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } diff --git a/source/blender/nodes/function/node_function_util.cc b/source/blender/nodes/function/node_function_util.cc index 0d6912b1203..4c44780a64c 100644 --- a/source/blender/nodes/function/node_function_util.cc +++ b/source/blender/nodes/function/node_function_util.cc @@ -25,7 +25,7 @@ void fn_node_type_base(blender::bke::bNodeType *ntype, std::string idname, const std::optional legacy_type) { - blender::bke::node_type_base(ntype, idname, legacy_type); + blender::bke::node_type_base(*ntype, idname, legacy_type); ntype->poll = fn_node_poll_default; ntype->insert_link = node_insert_link_default; ntype->gather_link_search_ops = blender::nodes::search_link_ops_for_basic_node; diff --git a/source/blender/nodes/function/nodes/node_fn_align_euler_to_vector.cc b/source/blender/nodes/function/nodes/node_fn_align_euler_to_vector.cc index 9738876bb1b..10befede940 100644 --- a/source/blender/nodes/function/nodes/node_fn_align_euler_to_vector.cc +++ b/source/blender/nodes/function/nodes/node_fn_align_euler_to_vector.cc @@ -267,7 +267,7 @@ static void node_register() ntype.draw_buttons = node_layout; ntype.build_multi_function = node_build_multi_function; ntype.deprecation_notice = N_("Use the \"Align Rotation to Vector\" node instead"); - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); node_rna(ntype.rna_ext.srna); } diff --git a/source/blender/nodes/function/nodes/node_fn_align_rotation_to_vector.cc b/source/blender/nodes/function/nodes/node_fn_align_rotation_to_vector.cc index 375944f095c..262a7c6ae97 100644 --- a/source/blender/nodes/function/nodes/node_fn_align_rotation_to_vector.cc +++ b/source/blender/nodes/function/nodes/node_fn_align_rotation_to_vector.cc @@ -236,7 +236,7 @@ static void node_register() ntype.initfunc = node_init; ntype.draw_buttons = node_layout; ntype.build_multi_function = node_build_multi_function; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); node_rna(ntype.rna_ext.srna); } diff --git a/source/blender/nodes/function/nodes/node_fn_axes_to_rotation.cc b/source/blender/nodes/function/nodes/node_fn_axes_to_rotation.cc index eb489abba5c..9c760f4dcd6 100644 --- a/source/blender/nodes/function/nodes/node_fn_axes_to_rotation.cc +++ b/source/blender/nodes/function/nodes/node_fn_axes_to_rotation.cc @@ -187,7 +187,7 @@ static void node_register() ntype.draw_buttons = node_layout; ntype.get_extra_info = node_extra_info; node_rna(ntype.rna_ext.srna); - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } NOD_REGISTER_NODE(node_register) diff --git a/source/blender/nodes/function/nodes/node_fn_axis_angle_to_rotation.cc b/source/blender/nodes/function/nodes/node_fn_axis_angle_to_rotation.cc index beb9fbcd330..b279d6fc7b5 100644 --- a/source/blender/nodes/function/nodes/node_fn_axis_angle_to_rotation.cc +++ b/source/blender/nodes/function/nodes/node_fn_axis_angle_to_rotation.cc @@ -76,7 +76,7 @@ static void node_register() ntype.eval_elem = node_eval_elem; ntype.eval_inverse_elem = node_eval_inverse_elem; ntype.eval_inverse = node_eval_inverse; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } NOD_REGISTER_NODE(node_register) diff --git a/source/blender/nodes/function/nodes/node_fn_boolean_math.cc b/source/blender/nodes/function/nodes/node_fn_boolean_math.cc index c2528a2b394..3c3d43f652f 100644 --- a/source/blender/nodes/function/nodes/node_fn_boolean_math.cc +++ b/source/blender/nodes/function/nodes/node_fn_boolean_math.cc @@ -37,7 +37,7 @@ static void node_update(bNodeTree *ntree, bNode *node) { bNodeSocket *sockB = (bNodeSocket *)BLI_findlink(&node->inputs, 1); - bke::node_set_socket_availability(ntree, sockB, !ELEM(node->custom1, NODE_BOOLEAN_MATH_NOT)); + bke::node_set_socket_availability(*ntree, *sockB, !ELEM(node->custom1, NODE_BOOLEAN_MATH_NOT)); } static void node_label(const bNodeTree * /*tree*/, @@ -202,7 +202,7 @@ static void node_register() ntype.eval_elem = node_eval_elem; ntype.eval_inverse_elem = node_eval_inverse_elem; ntype.eval_inverse = node_eval_inverse; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); node_rna(ntype.rna_ext.srna); } diff --git a/source/blender/nodes/function/nodes/node_fn_combine_color.cc b/source/blender/nodes/function/nodes/node_fn_combine_color.cc index 76193b5ad22..fc7dbfb1247 100644 --- a/source/blender/nodes/function/nodes/node_fn_combine_color.cc +++ b/source/blender/nodes/function/nodes/node_fn_combine_color.cc @@ -105,11 +105,11 @@ static void node_register() ntype.updatefunc = node_update; ntype.initfunc = node_init; blender::bke::node_type_storage( - &ntype, "NodeCombSepColor", node_free_standard_storage, node_copy_standard_storage); + ntype, "NodeCombSepColor", node_free_standard_storage, node_copy_standard_storage); ntype.build_multi_function = node_build_multi_function; ntype.draw_buttons = node_layout; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); node_rna(ntype.rna_ext.srna); } diff --git a/source/blender/nodes/function/nodes/node_fn_combine_matrix.cc b/source/blender/nodes/function/nodes/node_fn_combine_matrix.cc index 75d7ba2ef3e..93ab157b495 100644 --- a/source/blender/nodes/function/nodes/node_fn_combine_matrix.cc +++ b/source/blender/nodes/function/nodes/node_fn_combine_matrix.cc @@ -244,7 +244,7 @@ static void node_register() ntype.eval_elem = node_eval_elem; ntype.eval_inverse_elem = node_eval_inverse_elem; ntype.eval_inverse = node_eval_inverse; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } NOD_REGISTER_NODE(node_register) diff --git a/source/blender/nodes/function/nodes/node_fn_combine_transform.cc b/source/blender/nodes/function/nodes/node_fn_combine_transform.cc index f5144c4c80e..ab7ec3de751 100644 --- a/source/blender/nodes/function/nodes/node_fn_combine_transform.cc +++ b/source/blender/nodes/function/nodes/node_fn_combine_transform.cc @@ -121,7 +121,7 @@ static void node_register() ntype.eval_elem = node_eval_elem; ntype.eval_inverse_elem = node_eval_inverse_elem; ntype.eval_inverse = node_eval_inverse; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } NOD_REGISTER_NODE(node_register) diff --git a/source/blender/nodes/function/nodes/node_fn_compare.cc b/source/blender/nodes/function/nodes/node_fn_compare.cc index 316fdfbe14c..b40d9e35a65 100644 --- a/source/blender/nodes/function/nodes/node_fn_compare.cc +++ b/source/blender/nodes/function/nodes/node_fn_compare.cc @@ -77,22 +77,22 @@ static void node_update(bNodeTree *ntree, bNode *node) LISTBASE_FOREACH (bNodeSocket *, socket, &node->inputs) { bke::node_set_socket_availability( - ntree, socket, socket->type == (eNodeSocketDatatype)data->data_type); + *ntree, *socket, socket->type == (eNodeSocketDatatype)data->data_type); } bke::node_set_socket_availability( - ntree, - sock_epsilon, + *ntree, + *sock_epsilon, ELEM(data->operation, NODE_COMPARE_EQUAL, NODE_COMPARE_NOT_EQUAL) && !ELEM(data->data_type, SOCK_INT, SOCK_STRING)); - bke::node_set_socket_availability(ntree, - sock_comp, + bke::node_set_socket_availability(*ntree, + *sock_comp, ELEM(data->mode, NODE_COMPARE_MODE_DOT_PRODUCT) && data->data_type == SOCK_VECTOR); - bke::node_set_socket_availability(ntree, - sock_angle, + bke::node_set_socket_availability(*ntree, + *sock_angle, ELEM(data->mode, NODE_COMPARE_MODE_DIRECTION) && data->data_type == SOCK_VECTOR); } @@ -745,11 +745,11 @@ static void node_register() ntype.updatefunc = node_update; ntype.initfunc = node_init; blender::bke::node_type_storage( - &ntype, "NodeFunctionCompare", node_free_standard_storage, node_copy_standard_storage); + ntype, "NodeFunctionCompare", node_free_standard_storage, node_copy_standard_storage); ntype.build_multi_function = node_build_multi_function; ntype.draw_buttons = node_layout; ntype.gather_link_search_ops = node_gather_link_searches; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); node_rna(ntype.rna_ext.srna); } diff --git a/source/blender/nodes/function/nodes/node_fn_euler_to_rotation.cc b/source/blender/nodes/function/nodes/node_fn_euler_to_rotation.cc index 35114610273..04940a412d6 100644 --- a/source/blender/nodes/function/nodes/node_fn_euler_to_rotation.cc +++ b/source/blender/nodes/function/nodes/node_fn_euler_to_rotation.cc @@ -64,7 +64,7 @@ static void node_register() ntype.eval_elem = node_eval_elem; ntype.eval_inverse_elem = node_eval_inverse_elem; ntype.eval_inverse = node_eval_inverse; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } NOD_REGISTER_NODE(node_register) diff --git a/source/blender/nodes/function/nodes/node_fn_find_in_string.cc b/source/blender/nodes/function/nodes/node_fn_find_in_string.cc index 7f79066b588..9129ec426d5 100644 --- a/source/blender/nodes/function/nodes/node_fn_find_in_string.cc +++ b/source/blender/nodes/function/nodes/node_fn_find_in_string.cc @@ -63,7 +63,7 @@ static void node_register() ntype.nclass = NODE_CLASS_CONVERTER; ntype.declare = node_declare; ntype.build_multi_function = node_build_multi_function; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } NOD_REGISTER_NODE(node_register) diff --git a/source/blender/nodes/function/nodes/node_fn_float_to_int.cc b/source/blender/nodes/function/nodes/node_fn_float_to_int.cc index 26b524463db..277b5ce81ed 100644 --- a/source/blender/nodes/function/nodes/node_fn_float_to_int.cc +++ b/source/blender/nodes/function/nodes/node_fn_float_to_int.cc @@ -85,7 +85,7 @@ static void node_register() ntype.labelfunc = node_label; ntype.build_multi_function = node_build_multi_function; ntype.draw_buttons = node_layout; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } NOD_REGISTER_NODE(node_register) diff --git a/source/blender/nodes/function/nodes/node_fn_hash_value.cc b/source/blender/nodes/function/nodes/node_fn_hash_value.cc index 1fb39c03691..83dde72c277 100644 --- a/source/blender/nodes/function/nodes/node_fn_hash_value.cc +++ b/source/blender/nodes/function/nodes/node_fn_hash_value.cc @@ -184,7 +184,7 @@ static void node_register() ntype.build_multi_function = node_build_multi_function; ntype.draw_buttons = node_layout; ntype.gather_link_search_ops = node_gather_link_searches; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); node_rna(ntype.rna_ext.srna); } diff --git a/source/blender/nodes/function/nodes/node_fn_input_bool.cc b/source/blender/nodes/function/nodes/node_fn_input_bool.cc index 5619e5bc3d0..daccbe4caa0 100644 --- a/source/blender/nodes/function/nodes/node_fn_input_bool.cc +++ b/source/blender/nodes/function/nodes/node_fn_input_bool.cc @@ -44,10 +44,10 @@ static void node_register() ntype.declare = node_declare; ntype.initfunc = node_init; blender::bke::node_type_storage( - &ntype, "NodeInputBool", node_free_standard_storage, node_copy_standard_storage); + ntype, "NodeInputBool", node_free_standard_storage, node_copy_standard_storage); ntype.build_multi_function = node_build_multi_function; ntype.draw_buttons = node_layout; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } NOD_REGISTER_NODE(node_register) diff --git a/source/blender/nodes/function/nodes/node_fn_input_color.cc b/source/blender/nodes/function/nodes/node_fn_input_color.cc index 1b4cdbfb190..bb7e428d3c5 100644 --- a/source/blender/nodes/function/nodes/node_fn_input_color.cc +++ b/source/blender/nodes/function/nodes/node_fn_input_color.cc @@ -48,10 +48,10 @@ static void node_register() ntype.declare = node_declare; ntype.initfunc = node_init; blender::bke::node_type_storage( - &ntype, "NodeInputColor", node_free_standard_storage, node_copy_standard_storage); + ntype, "NodeInputColor", node_free_standard_storage, node_copy_standard_storage); ntype.build_multi_function = node_build_multi_function; ntype.draw_buttons = node_layout; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } NOD_REGISTER_NODE(node_register) diff --git a/source/blender/nodes/function/nodes/node_fn_input_int.cc b/source/blender/nodes/function/nodes/node_fn_input_int.cc index 7150ccec9dc..147969897c5 100644 --- a/source/blender/nodes/function/nodes/node_fn_input_int.cc +++ b/source/blender/nodes/function/nodes/node_fn_input_int.cc @@ -44,10 +44,10 @@ static void node_register() ntype.declare = node_declare; ntype.initfunc = node_init; blender::bke::node_type_storage( - &ntype, "NodeInputInt", node_free_standard_storage, node_copy_standard_storage); + ntype, "NodeInputInt", node_free_standard_storage, node_copy_standard_storage); ntype.build_multi_function = node_build_multi_function; ntype.draw_buttons = node_layout; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } NOD_REGISTER_NODE(node_register) diff --git a/source/blender/nodes/function/nodes/node_fn_input_rotation.cc b/source/blender/nodes/function/nodes/node_fn_input_rotation.cc index 8f14d96662e..d333245b520 100644 --- a/source/blender/nodes/function/nodes/node_fn_input_rotation.cc +++ b/source/blender/nodes/function/nodes/node_fn_input_rotation.cc @@ -52,10 +52,10 @@ static void node_register() ntype.declare = node_declare; ntype.initfunc = node_init; blender::bke::node_type_storage( - &ntype, "NodeInputRotation", node_free_standard_storage, node_copy_standard_storage); + ntype, "NodeInputRotation", node_free_standard_storage, node_copy_standard_storage); ntype.build_multi_function = node_build_multi_function; ntype.draw_buttons = node_layout; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } NOD_REGISTER_NODE(node_register) diff --git a/source/blender/nodes/function/nodes/node_fn_input_special_characters.cc b/source/blender/nodes/function/nodes/node_fn_input_special_characters.cc index 8dd7219f833..3811b0ea6f1 100644 --- a/source/blender/nodes/function/nodes/node_fn_input_special_characters.cc +++ b/source/blender/nodes/function/nodes/node_fn_input_special_characters.cc @@ -55,7 +55,7 @@ static void node_register() ntype.nclass = NODE_CLASS_INPUT; ntype.declare = node_declare; ntype.build_multi_function = node_build_multi_function; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } NOD_REGISTER_NODE(node_register) diff --git a/source/blender/nodes/function/nodes/node_fn_input_string.cc b/source/blender/nodes/function/nodes/node_fn_input_string.cc index 5cc1ca517b8..8e7c232aa31 100644 --- a/source/blender/nodes/function/nodes/node_fn_input_string.cc +++ b/source/blender/nodes/function/nodes/node_fn_input_string.cc @@ -67,10 +67,10 @@ static void node_register() ntype.nclass = NODE_CLASS_INPUT; ntype.declare = node_declare; ntype.initfunc = node_init; - blender::bke::node_type_storage(&ntype, "NodeInputString", node_storage_free, node_storage_copy); + blender::bke::node_type_storage(ntype, "NodeInputString", node_storage_free, node_storage_copy); ntype.build_multi_function = node_build_multi_function; ntype.draw_buttons = node_layout; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } NOD_REGISTER_NODE(node_register) diff --git a/source/blender/nodes/function/nodes/node_fn_input_vector.cc b/source/blender/nodes/function/nodes/node_fn_input_vector.cc index 44219d2697c..a2eec27ca2e 100644 --- a/source/blender/nodes/function/nodes/node_fn_input_vector.cc +++ b/source/blender/nodes/function/nodes/node_fn_input_vector.cc @@ -45,10 +45,10 @@ static void node_register() ntype.declare = node_declare; ntype.initfunc = node_init; blender::bke::node_type_storage( - &ntype, "NodeInputVector", node_free_standard_storage, node_copy_standard_storage); + ntype, "NodeInputVector", node_free_standard_storage, node_copy_standard_storage); ntype.build_multi_function = node_build_multi_function; ntype.draw_buttons = node_layout; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } NOD_REGISTER_NODE(node_register) diff --git a/source/blender/nodes/function/nodes/node_fn_integer_math.cc b/source/blender/nodes/function/nodes/node_fn_integer_math.cc index 8a448a2e8b1..4e17afb34ad 100644 --- a/source/blender/nodes/function/nodes/node_fn_integer_math.cc +++ b/source/blender/nodes/function/nodes/node_fn_integer_math.cc @@ -44,8 +44,8 @@ static void node_update(bNodeTree *ntree, bNode *node) bNodeSocket *sockB = sockA->next; bNodeSocket *sockC = sockB->next; - bke::node_set_socket_availability(ntree, sockB, !one_input_ops); - bke::node_set_socket_availability(ntree, sockC, three_input_ops); + bke::node_set_socket_availability(*ntree, *sockB, !one_input_ops); + bke::node_set_socket_availability(*ntree, *sockC, three_input_ops); node_sock_label_clear(sockA); node_sock_label_clear(sockB); @@ -314,7 +314,7 @@ static void node_register() ntype.eval_inverse_elem = node_eval_inverse_elem; ntype.eval_inverse = node_eval_inverse; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); node_rna(ntype.rna_ext.srna); } diff --git a/source/blender/nodes/function/nodes/node_fn_invert_matrix.cc b/source/blender/nodes/function/nodes/node_fn_invert_matrix.cc index 58898bd2cfc..e6128b54c06 100644 --- a/source/blender/nodes/function/nodes/node_fn_invert_matrix.cc +++ b/source/blender/nodes/function/nodes/node_fn_invert_matrix.cc @@ -68,7 +68,7 @@ static void node_register() ntype.nclass = NODE_CLASS_CONVERTER; ntype.declare = node_declare; ntype.build_multi_function = node_build_multi_function; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } NOD_REGISTER_NODE(node_register) diff --git a/source/blender/nodes/function/nodes/node_fn_invert_rotation.cc b/source/blender/nodes/function/nodes/node_fn_invert_rotation.cc index 78a7ba6a1d8..0e0f0de65f5 100644 --- a/source/blender/nodes/function/nodes/node_fn_invert_rotation.cc +++ b/source/blender/nodes/function/nodes/node_fn_invert_rotation.cc @@ -31,7 +31,7 @@ static void node_register() ntype.nclass = NODE_CLASS_CONVERTER; ntype.declare = node_declare; ntype.build_multi_function = node_build_multi_function; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } NOD_REGISTER_NODE(node_register) diff --git a/source/blender/nodes/function/nodes/node_fn_matrix_determinant.cc b/source/blender/nodes/function/nodes/node_fn_matrix_determinant.cc index 0f2db31c13f..6b419d653db 100644 --- a/source/blender/nodes/function/nodes/node_fn_matrix_determinant.cc +++ b/source/blender/nodes/function/nodes/node_fn_matrix_determinant.cc @@ -31,7 +31,7 @@ static void node_register() ntype.nclass = NODE_CLASS_CONVERTER; ntype.declare = node_declare; ntype.build_multi_function = node_build_multi_function; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } NOD_REGISTER_NODE(node_register) diff --git a/source/blender/nodes/function/nodes/node_fn_matrix_multiply.cc b/source/blender/nodes/function/nodes/node_fn_matrix_multiply.cc index 9eff6606879..d157af0e766 100644 --- a/source/blender/nodes/function/nodes/node_fn_matrix_multiply.cc +++ b/source/blender/nodes/function/nodes/node_fn_matrix_multiply.cc @@ -59,7 +59,7 @@ static void node_register() ntype.eval_elem = node_eval_elem; ntype.eval_inverse_elem = node_eval_inverse_elem; ntype.eval_inverse = node_eval_inverse; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } NOD_REGISTER_NODE(node_register) diff --git a/source/blender/nodes/function/nodes/node_fn_project_point.cc b/source/blender/nodes/function/nodes/node_fn_project_point.cc index 143d441ea71..f603ee19d3d 100644 --- a/source/blender/nodes/function/nodes/node_fn_project_point.cc +++ b/source/blender/nodes/function/nodes/node_fn_project_point.cc @@ -35,7 +35,7 @@ static void node_register() ntype.nclass = NODE_CLASS_CONVERTER; ntype.declare = node_declare; ntype.build_multi_function = node_build_multi_function; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } NOD_REGISTER_NODE(node_register) diff --git a/source/blender/nodes/function/nodes/node_fn_quaternion_to_rotation.cc b/source/blender/nodes/function/nodes/node_fn_quaternion_to_rotation.cc index 72f5ca07a6b..caf857ecae4 100644 --- a/source/blender/nodes/function/nodes/node_fn_quaternion_to_rotation.cc +++ b/source/blender/nodes/function/nodes/node_fn_quaternion_to_rotation.cc @@ -37,7 +37,7 @@ static void node_register() ntype.nclass = NODE_CLASS_CONVERTER; ntype.declare = node_declare; ntype.build_multi_function = node_build_multi_function; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } NOD_REGISTER_NODE(node_register) diff --git a/source/blender/nodes/function/nodes/node_fn_random_value.cc b/source/blender/nodes/function/nodes/node_fn_random_value.cc index 3b99182a98e..e8bb8564a3c 100644 --- a/source/blender/nodes/function/nodes/node_fn_random_value.cc +++ b/source/blender/nodes/function/nodes/node_fn_random_value.cc @@ -74,18 +74,18 @@ static void fn_node_random_value_update(bNodeTree *ntree, bNode *node) bNodeSocket *sock_out_int = sock_out_float->next; bNodeSocket *sock_out_bool = sock_out_int->next; - bke::node_set_socket_availability(ntree, sock_min_vector, data_type == CD_PROP_FLOAT3); - bke::node_set_socket_availability(ntree, sock_max_vector, data_type == CD_PROP_FLOAT3); - bke::node_set_socket_availability(ntree, sock_min_float, data_type == CD_PROP_FLOAT); - bke::node_set_socket_availability(ntree, sock_max_float, data_type == CD_PROP_FLOAT); - bke::node_set_socket_availability(ntree, sock_min_int, data_type == CD_PROP_INT32); - bke::node_set_socket_availability(ntree, sock_max_int, data_type == CD_PROP_INT32); - bke::node_set_socket_availability(ntree, sock_probability, data_type == CD_PROP_BOOL); - - bke::node_set_socket_availability(ntree, sock_out_vector, data_type == CD_PROP_FLOAT3); - bke::node_set_socket_availability(ntree, sock_out_float, data_type == CD_PROP_FLOAT); - bke::node_set_socket_availability(ntree, sock_out_int, data_type == CD_PROP_INT32); - bke::node_set_socket_availability(ntree, sock_out_bool, data_type == CD_PROP_BOOL); + bke::node_set_socket_availability(*ntree, *sock_min_vector, data_type == CD_PROP_FLOAT3); + bke::node_set_socket_availability(*ntree, *sock_max_vector, data_type == CD_PROP_FLOAT3); + bke::node_set_socket_availability(*ntree, *sock_min_float, data_type == CD_PROP_FLOAT); + bke::node_set_socket_availability(*ntree, *sock_max_float, data_type == CD_PROP_FLOAT); + bke::node_set_socket_availability(*ntree, *sock_min_int, data_type == CD_PROP_INT32); + bke::node_set_socket_availability(*ntree, *sock_max_int, data_type == CD_PROP_INT32); + bke::node_set_socket_availability(*ntree, *sock_probability, data_type == CD_PROP_BOOL); + + bke::node_set_socket_availability(*ntree, *sock_out_vector, data_type == CD_PROP_FLOAT3); + bke::node_set_socket_availability(*ntree, *sock_out_float, data_type == CD_PROP_FLOAT); + bke::node_set_socket_availability(*ntree, *sock_out_int, data_type == CD_PROP_INT32); + bke::node_set_socket_availability(*ntree, *sock_out_bool, data_type == CD_PROP_BOOL); } static std::optional node_type_from_other_socket(const bNodeSocket &socket) @@ -212,8 +212,8 @@ static void node_register() ntype.build_multi_function = node_build_multi_function; ntype.gather_link_search_ops = node_gather_link_search_ops; blender::bke::node_type_storage( - &ntype, "NodeRandomValue", node_free_standard_storage, node_copy_standard_storage); - blender::bke::node_register_type(&ntype); + ntype, "NodeRandomValue", node_free_standard_storage, node_copy_standard_storage); + blender::bke::node_register_type(ntype); } NOD_REGISTER_NODE(node_register) diff --git a/source/blender/nodes/function/nodes/node_fn_replace_string.cc b/source/blender/nodes/function/nodes/node_fn_replace_string.cc index 38c33b192aa..e7df1f489ca 100644 --- a/source/blender/nodes/function/nodes/node_fn_replace_string.cc +++ b/source/blender/nodes/function/nodes/node_fn_replace_string.cc @@ -48,7 +48,7 @@ static void node_register() ntype.nclass = NODE_CLASS_CONVERTER; ntype.declare = node_declare; ntype.build_multi_function = node_build_multi_function; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } NOD_REGISTER_NODE(node_register) diff --git a/source/blender/nodes/function/nodes/node_fn_rotate_euler.cc b/source/blender/nodes/function/nodes/node_fn_rotate_euler.cc index bcb0c893573..db0a35d4da3 100644 --- a/source/blender/nodes/function/nodes/node_fn_rotate_euler.cc +++ b/source/blender/nodes/function/nodes/node_fn_rotate_euler.cc @@ -41,11 +41,11 @@ static void node_update(bNodeTree *ntree, bNode *node) bNodeSocket *angle_socket = static_cast(BLI_findlink(&node->inputs, 3)); bke::node_set_socket_availability( - ntree, rotate_by_socket, ELEM(node->custom1, FN_NODE_ROTATE_EULER_TYPE_EULER)); + *ntree, *rotate_by_socket, ELEM(node->custom1, FN_NODE_ROTATE_EULER_TYPE_EULER)); bke::node_set_socket_availability( - ntree, axis_socket, ELEM(node->custom1, FN_NODE_ROTATE_EULER_TYPE_AXIS_ANGLE)); + *ntree, *axis_socket, ELEM(node->custom1, FN_NODE_ROTATE_EULER_TYPE_AXIS_ANGLE)); bke::node_set_socket_availability( - ntree, angle_socket, ELEM(node->custom1, FN_NODE_ROTATE_EULER_TYPE_AXIS_ANGLE)); + *ntree, *angle_socket, ELEM(node->custom1, FN_NODE_ROTATE_EULER_TYPE_AXIS_ANGLE)); } static void node_layout(uiLayout *layout, bContext * /*C*/, PointerRNA *ptr) @@ -140,7 +140,7 @@ static void node_register() ntype.updatefunc = node_update; ntype.build_multi_function = node_build_multi_function; ntype.deprecation_notice = N_("Use the \"Rotate Rotation\" node instead"); - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } NOD_REGISTER_NODE(node_register) diff --git a/source/blender/nodes/function/nodes/node_fn_rotate_rotation.cc b/source/blender/nodes/function/nodes/node_fn_rotate_rotation.cc index e311ed1ee93..c800036cd77 100644 --- a/source/blender/nodes/function/nodes/node_fn_rotate_rotation.cc +++ b/source/blender/nodes/function/nodes/node_fn_rotate_rotation.cc @@ -81,7 +81,7 @@ static void node_register() ntype.declare = node_declare; ntype.draw_buttons = node_layout; ntype.build_multi_function = node_build_multi_function; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); node_rna(ntype.rna_ext.srna); } diff --git a/source/blender/nodes/function/nodes/node_fn_rotate_vector.cc b/source/blender/nodes/function/nodes/node_fn_rotate_vector.cc index 8b718b4b362..8e58db2c5f2 100644 --- a/source/blender/nodes/function/nodes/node_fn_rotate_vector.cc +++ b/source/blender/nodes/function/nodes/node_fn_rotate_vector.cc @@ -33,7 +33,7 @@ static void node_register() ntype.nclass = NODE_CLASS_CONVERTER; ntype.declare = node_declare; ntype.build_multi_function = node_build_multi_function; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } NOD_REGISTER_NODE(node_register) diff --git a/source/blender/nodes/function/nodes/node_fn_rotation_to_axis_angle.cc b/source/blender/nodes/function/nodes/node_fn_rotation_to_axis_angle.cc index f138067e876..e81eb9653d6 100644 --- a/source/blender/nodes/function/nodes/node_fn_rotation_to_axis_angle.cc +++ b/source/blender/nodes/function/nodes/node_fn_rotation_to_axis_angle.cc @@ -98,7 +98,7 @@ static void node_register() ntype.eval_elem = node_eval_elem; ntype.eval_inverse_elem = node_eval_inverse_elem; ntype.eval_inverse = node_eval_inverse; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } NOD_REGISTER_NODE(node_register) diff --git a/source/blender/nodes/function/nodes/node_fn_rotation_to_euler.cc b/source/blender/nodes/function/nodes/node_fn_rotation_to_euler.cc index 3c07e1026d9..ac43d06efe1 100644 --- a/source/blender/nodes/function/nodes/node_fn_rotation_to_euler.cc +++ b/source/blender/nodes/function/nodes/node_fn_rotation_to_euler.cc @@ -63,7 +63,7 @@ static void node_register() ntype.eval_elem = node_eval_elem; ntype.eval_inverse_elem = node_eval_inverse_elem; ntype.eval_inverse = node_eval_inverse; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } NOD_REGISTER_NODE(node_register) diff --git a/source/blender/nodes/function/nodes/node_fn_rotation_to_quaternion.cc b/source/blender/nodes/function/nodes/node_fn_rotation_to_quaternion.cc index aa7db5a0174..ebc73ded922 100644 --- a/source/blender/nodes/function/nodes/node_fn_rotation_to_quaternion.cc +++ b/source/blender/nodes/function/nodes/node_fn_rotation_to_quaternion.cc @@ -65,7 +65,7 @@ static void node_register() ntype.nclass = NODE_CLASS_CONVERTER; ntype.declare = node_declare; ntype.build_multi_function = node_build_multi_function; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } NOD_REGISTER_NODE(node_register) diff --git a/source/blender/nodes/function/nodes/node_fn_separate_color.cc b/source/blender/nodes/function/nodes/node_fn_separate_color.cc index 6c3c4aa63ac..4a9a3b00a53 100644 --- a/source/blender/nodes/function/nodes/node_fn_separate_color.cc +++ b/source/blender/nodes/function/nodes/node_fn_separate_color.cc @@ -223,11 +223,11 @@ static void node_register() ntype.updatefunc = node_update; ntype.initfunc = node_init; blender::bke::node_type_storage( - &ntype, "NodeCombSepColor", node_free_standard_storage, node_copy_standard_storage); + ntype, "NodeCombSepColor", node_free_standard_storage, node_copy_standard_storage); ntype.build_multi_function = node_build_multi_function; ntype.draw_buttons = node_layout; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); node_rna(ntype.rna_ext.srna); } diff --git a/source/blender/nodes/function/nodes/node_fn_separate_matrix.cc b/source/blender/nodes/function/nodes/node_fn_separate_matrix.cc index 90196338f92..7ef04805de8 100644 --- a/source/blender/nodes/function/nodes/node_fn_separate_matrix.cc +++ b/source/blender/nodes/function/nodes/node_fn_separate_matrix.cc @@ -283,7 +283,7 @@ static void node_register() ntype.eval_elem = node_eval_elem; ntype.eval_inverse_elem = node_eval_inverse_elem; ntype.eval_inverse = node_eval_inverse; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } NOD_REGISTER_NODE(node_register) diff --git a/source/blender/nodes/function/nodes/node_fn_separate_transform.cc b/source/blender/nodes/function/nodes/node_fn_separate_transform.cc index 27b8e67cb3a..93f8552e80c 100644 --- a/source/blender/nodes/function/nodes/node_fn_separate_transform.cc +++ b/source/blender/nodes/function/nodes/node_fn_separate_transform.cc @@ -115,7 +115,7 @@ static void node_register() ntype.eval_elem = node_eval_elem; ntype.eval_inverse_elem = node_eval_inverse_elem; ntype.eval_inverse = node_eval_inverse; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } NOD_REGISTER_NODE(node_register) diff --git a/source/blender/nodes/function/nodes/node_fn_slice_string.cc b/source/blender/nodes/function/nodes/node_fn_slice_string.cc index b254b8e13e3..ed12b638b65 100644 --- a/source/blender/nodes/function/nodes/node_fn_slice_string.cc +++ b/source/blender/nodes/function/nodes/node_fn_slice_string.cc @@ -38,7 +38,7 @@ static void node_register() ntype.nclass = NODE_CLASS_CONVERTER; ntype.declare = node_declare; ntype.build_multi_function = node_build_multi_function; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } NOD_REGISTER_NODE(node_register) diff --git a/source/blender/nodes/function/nodes/node_fn_string_length.cc b/source/blender/nodes/function/nodes/node_fn_string_length.cc index 1a3701e0eec..db99961a7f1 100644 --- a/source/blender/nodes/function/nodes/node_fn_string_length.cc +++ b/source/blender/nodes/function/nodes/node_fn_string_length.cc @@ -31,7 +31,7 @@ static void node_register() ntype.nclass = NODE_CLASS_CONVERTER; ntype.declare = node_declare; ntype.build_multi_function = node_build_multi_function; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } NOD_REGISTER_NODE(node_register) diff --git a/source/blender/nodes/function/nodes/node_fn_transform_direction.cc b/source/blender/nodes/function/nodes/node_fn_transform_direction.cc index 161e60f072c..fbbd6c9694c 100644 --- a/source/blender/nodes/function/nodes/node_fn_transform_direction.cc +++ b/source/blender/nodes/function/nodes/node_fn_transform_direction.cc @@ -34,7 +34,7 @@ static void node_register() ntype.nclass = NODE_CLASS_CONVERTER; ntype.declare = node_declare; ntype.build_multi_function = node_build_multi_function; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } NOD_REGISTER_NODE(node_register) diff --git a/source/blender/nodes/function/nodes/node_fn_transform_point.cc b/source/blender/nodes/function/nodes/node_fn_transform_point.cc index c4bb25c66bc..845d6620b28 100644 --- a/source/blender/nodes/function/nodes/node_fn_transform_point.cc +++ b/source/blender/nodes/function/nodes/node_fn_transform_point.cc @@ -33,7 +33,7 @@ static void node_register() ntype.nclass = NODE_CLASS_CONVERTER; ntype.declare = node_declare; ntype.build_multi_function = node_build_multi_function; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } NOD_REGISTER_NODE(node_register) diff --git a/source/blender/nodes/function/nodes/node_fn_transpose_matrix.cc b/source/blender/nodes/function/nodes/node_fn_transpose_matrix.cc index 0f9a6e1e542..72f8f2e05b8 100644 --- a/source/blender/nodes/function/nodes/node_fn_transpose_matrix.cc +++ b/source/blender/nodes/function/nodes/node_fn_transpose_matrix.cc @@ -31,7 +31,7 @@ static void node_register() ntype.nclass = NODE_CLASS_CONVERTER; ntype.declare = node_declare; ntype.build_multi_function = node_build_multi_function; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } NOD_REGISTER_NODE(node_register) diff --git a/source/blender/nodes/function/nodes/node_fn_value_to_string.cc b/source/blender/nodes/function/nodes/node_fn_value_to_string.cc index 1b071c4f35d..0dcd11b551c 100644 --- a/source/blender/nodes/function/nodes/node_fn_value_to_string.cc +++ b/source/blender/nodes/function/nodes/node_fn_value_to_string.cc @@ -135,7 +135,7 @@ static void node_register() ntype.draw_buttons = node_layout; ntype.build_multi_function = node_build_multi_function; ntype.gather_link_search_ops = node_gather_link_searches; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); node_rna(ntype.rna_ext.srna); } diff --git a/source/blender/nodes/geometry/node_geometry_tree.cc b/source/blender/nodes/geometry/node_geometry_tree.cc index ba9489a1e20..398ea584278 100644 --- a/source/blender/nodes/geometry/node_geometry_tree.cc +++ b/source/blender/nodes/geometry/node_geometry_tree.cc @@ -66,7 +66,7 @@ static void geometry_node_tree_get_from_context(const bContext *C, static void geometry_node_tree_update(bNodeTree *ntree) { - blender::bke::node_tree_set_output(ntree); + blender::bke::node_tree_set_output(*ntree); /* Needed to give correct types to reroutes. */ ntree_update_reroute_nodes(ntree); @@ -116,22 +116,22 @@ static bool geometry_node_tree_validate_link(eNodeSocketDatatype type_a, static bool geometry_node_tree_socket_type_valid(blender::bke::bNodeTreeType * /*treetype*/, blender::bke::bNodeSocketType *socket_type) { - return blender::bke::node_is_static_socket_type(socket_type) && ELEM(socket_type->type, - SOCK_FLOAT, - SOCK_VECTOR, - SOCK_RGBA, - SOCK_BOOLEAN, - SOCK_ROTATION, - SOCK_MATRIX, - SOCK_INT, - SOCK_STRING, - SOCK_OBJECT, - SOCK_GEOMETRY, - SOCK_COLLECTION, - SOCK_TEXTURE, - SOCK_IMAGE, - SOCK_MATERIAL, - SOCK_MENU); + return blender::bke::node_is_static_socket_type(*socket_type) && ELEM(socket_type->type, + SOCK_FLOAT, + SOCK_VECTOR, + SOCK_RGBA, + SOCK_BOOLEAN, + SOCK_ROTATION, + SOCK_MATRIX, + SOCK_INT, + SOCK_STRING, + SOCK_OBJECT, + SOCK_GEOMETRY, + SOCK_COLLECTION, + SOCK_TEXTURE, + SOCK_IMAGE, + SOCK_MATERIAL, + SOCK_MENU); } void register_node_tree_type_geo() @@ -151,7 +151,7 @@ void register_node_tree_type_geo() tt->valid_socket_type = geometry_node_tree_socket_type_valid; tt->validate_link = geometry_node_tree_validate_link; - blender::bke::node_tree_type_add(tt); + blender::bke::node_tree_type_add(*tt); } bool is_layer_selection_field(const bNodeTreeInterfaceSocket &socket) diff --git a/source/blender/nodes/geometry/node_geometry_util.cc b/source/blender/nodes/geometry/node_geometry_util.cc index 138ed1173de..088807f7fe9 100644 --- a/source/blender/nodes/geometry/node_geometry_util.cc +++ b/source/blender/nodes/geometry/node_geometry_util.cc @@ -142,7 +142,7 @@ void geo_node_type_base(blender::bke::bNodeType *ntype, std::string idname, const std::optional legacy_type) { - blender::bke::node_type_base(ntype, idname, legacy_type); + blender::bke::node_type_base(*ntype, idname, legacy_type); ntype->poll = geo_node_poll_default; ntype->insert_link = node_insert_link_default; ntype->gather_link_search_ops = blender::nodes::search_link_ops_for_basic_node; diff --git a/source/blender/nodes/geometry/nodes/node_geo_accumulate_field.cc b/source/blender/nodes/geometry/nodes/node_geo_accumulate_field.cc index 3eccd0d3176..424a285ac0c 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_accumulate_field.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_accumulate_field.cc @@ -439,8 +439,8 @@ static void node_register() ntype.declare = node_declare; ntype.gather_link_search_ops = node_gather_link_searches; blender::bke::node_type_storage( - &ntype, "NodeAccumulateField", node_free_standard_storage, node_copy_standard_storage); - blender::bke::node_register_type(&ntype); + ntype, "NodeAccumulateField", node_free_standard_storage, node_copy_standard_storage); + blender::bke::node_register_type(ntype); node_rna(ntype.rna_ext.srna); } diff --git a/source/blender/nodes/geometry/nodes/node_geo_attribute_capture.cc b/source/blender/nodes/geometry/nodes/node_geo_attribute_capture.cc index 09a78e39325..bd3194ef1d1 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_attribute_capture.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_attribute_capture.cc @@ -257,7 +257,7 @@ static void node_register() ntype.enum_name_legacy = "CAPTURE_ATTRIBUTE"; ntype.nclass = NODE_CLASS_ATTRIBUTE; blender::bke::node_type_storage( - &ntype, "NodeGeometryAttributeCapture", node_free_storage, node_copy_storage); + ntype, "NodeGeometryAttributeCapture", node_free_storage, node_copy_storage); ntype.initfunc = node_init; ntype.declare = node_declare; ntype.geometry_node_execute = node_geo_exec; @@ -266,7 +266,7 @@ static void node_register() ntype.draw_buttons_ex = node_layout_ex; ntype.register_operators = node_operators; ntype.gather_link_search_ops = node_gather_link_searches; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } NOD_REGISTER_NODE(node_register) diff --git a/source/blender/nodes/geometry/nodes/node_geo_attribute_domain_size.cc b/source/blender/nodes/geometry/nodes/node_geo_attribute_domain_size.cc index 9979fb0ae36..35e7b5b6ebd 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_attribute_domain_size.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_attribute_domain_size.cc @@ -182,7 +182,7 @@ static void node_register() ntype.draw_buttons = node_layout; ntype.initfunc = node_init; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); node_rna(ntype.rna_ext.srna); } diff --git a/source/blender/nodes/geometry/nodes/node_geo_attribute_statistic.cc b/source/blender/nodes/geometry/nodes/node_geo_attribute_statistic.cc index 7d4a936c4ed..bc26b581816 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_attribute_statistic.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_attribute_statistic.cc @@ -392,7 +392,7 @@ static void node_register() ntype.geometry_node_execute = node_geo_exec; ntype.draw_buttons = node_layout; ntype.gather_link_search_ops = node_gather_link_searches; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); node_rna(ntype.rna_ext.srna); } diff --git a/source/blender/nodes/geometry/nodes/node_geo_bake.cc b/source/blender/nodes/geometry/nodes/node_geo_bake.cc index 8a3c72dc158..0e5d3d7dce3 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_bake.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_bake.cc @@ -581,9 +581,8 @@ static void node_register() ntype.get_extra_info = node_extra_info; ntype.register_operators = node_operators; ntype.gather_link_search_ops = node_gather_link_searches; - blender::bke::node_type_storage( - &ntype, "NodeGeometryBake", node_free_storage, node_copy_storage); - blender::bke::node_register_type(&ntype); + blender::bke::node_type_storage(ntype, "NodeGeometryBake", node_free_storage, node_copy_storage); + blender::bke::node_register_type(ntype); } NOD_REGISTER_NODE(node_register) diff --git a/source/blender/nodes/geometry/nodes/node_geo_blur_attribute.cc b/source/blender/nodes/geometry/nodes/node_geo_blur_attribute.cc index 14ab7a45ad7..0c827abe7b8 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_blur_attribute.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_blur_attribute.cc @@ -504,7 +504,7 @@ static void node_register() ntype.draw_buttons = node_layout; ntype.geometry_node_execute = node_geo_exec; ntype.gather_link_search_ops = node_gather_link_searches; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); node_rna(ntype.rna_ext.srna); } diff --git a/source/blender/nodes/geometry/nodes/node_geo_boolean.cc b/source/blender/nodes/geometry/nodes/node_geo_boolean.cc index 89dd13be1ff..cb70e741ec7 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_boolean.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_boolean.cc @@ -298,7 +298,7 @@ static void node_register() ntype.draw_buttons = node_layout; ntype.initfunc = node_init; ntype.geometry_node_execute = node_geo_exec; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); node_rna(ntype.rna_ext.srna); } diff --git a/source/blender/nodes/geometry/nodes/node_geo_bounding_box.cc b/source/blender/nodes/geometry/nodes/node_geo_bounding_box.cc index b52e4257c61..8672eb612f0 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_bounding_box.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_bounding_box.cc @@ -77,7 +77,7 @@ static void node_register() ntype.nclass = NODE_CLASS_GEOMETRY; ntype.declare = node_declare; ntype.geometry_node_execute = node_geo_exec; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } NOD_REGISTER_NODE(node_register) diff --git a/source/blender/nodes/geometry/nodes/node_geo_collection_info.cc b/source/blender/nodes/geometry/nodes/node_geo_collection_info.cc index 365df6437e1..a0f068613e9 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_collection_info.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_collection_info.cc @@ -195,13 +195,11 @@ static void node_register() ntype.nclass = NODE_CLASS_INPUT; ntype.declare = node_declare; ntype.initfunc = node_node_init; - blender::bke::node_type_storage(&ntype, - "NodeGeometryCollectionInfo", - node_free_standard_storage, - node_copy_standard_storage); + blender::bke::node_type_storage( + ntype, "NodeGeometryCollectionInfo", node_free_standard_storage, node_copy_standard_storage); ntype.geometry_node_execute = node_geo_exec; ntype.draw_buttons = node_layout; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); node_rna(ntype.rna_ext.srna); } diff --git a/source/blender/nodes/geometry/nodes/node_geo_common.cc b/source/blender/nodes/geometry/nodes/node_geo_common.cc index 6188b58c8e2..9f1ea7fcfd5 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_common.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_common.cc @@ -18,7 +18,7 @@ static void register_node_type_geo_group() { static blender::bke::bNodeType ntype; - bke::node_type_base_custom(&ntype, "GeometryNodeGroup", "Group", "GROUP", NODE_CLASS_GROUP); + bke::node_type_base_custom(ntype, "GeometryNodeGroup", "Group", "GROUP", NODE_CLASS_GROUP); ntype.enum_name_legacy = "GROUP"; ntype.type_legacy = NODE_GROUP; ntype.poll = geo_node_poll_default; @@ -30,12 +30,11 @@ static void register_node_type_geo_group() BLI_assert(ntype.rna_ext.srna != nullptr); RNA_struct_blender_type_set(ntype.rna_ext.srna, &ntype); - bke::node_type_size( - &ntype, GROUP_NODE_DEFAULT_WIDTH, GROUP_NODE_MIN_WIDTH, GROUP_NODE_MAX_WIDTH); + bke::node_type_size(ntype, GROUP_NODE_DEFAULT_WIDTH, GROUP_NODE_MIN_WIDTH, GROUP_NODE_MAX_WIDTH); ntype.labelfunc = node_group_label; ntype.declare = node_group_declare; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } NOD_REGISTER_NODE(register_node_type_geo_group) diff --git a/source/blender/nodes/geometry/nodes/node_geo_convex_hull.cc b/source/blender/nodes/geometry/nodes/node_geo_convex_hull.cc index 50c95e23901..57199064e5c 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_convex_hull.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_convex_hull.cc @@ -294,7 +294,7 @@ static void node_register() ntype.nclass = NODE_CLASS_GEOMETRY; ntype.declare = node_declare; ntype.geometry_node_execute = node_geo_exec; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } NOD_REGISTER_NODE(node_register) diff --git a/source/blender/nodes/geometry/nodes/node_geo_curve_endpoint_selection.cc b/source/blender/nodes/geometry/nodes/node_geo_curve_endpoint_selection.cc index 5d550024a34..2a3f66e00a2 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_curve_endpoint_selection.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_curve_endpoint_selection.cc @@ -129,7 +129,7 @@ static void node_register() ntype.declare = node_declare; ntype.geometry_node_execute = node_geo_exec; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } NOD_REGISTER_NODE(node_register) diff --git a/source/blender/nodes/geometry/nodes/node_geo_curve_fill.cc b/source/blender/nodes/geometry/nodes/node_geo_curve_fill.cc index 348b2199646..a479de44713 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_curve_fill.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_curve_fill.cc @@ -347,11 +347,11 @@ static void node_register() ntype.nclass = NODE_CLASS_GEOMETRY; ntype.initfunc = node_init; blender::bke::node_type_storage( - &ntype, "NodeGeometryCurveFill", node_free_standard_storage, node_copy_standard_storage); + ntype, "NodeGeometryCurveFill", node_free_standard_storage, node_copy_standard_storage); ntype.declare = node_declare; ntype.geometry_node_execute = node_geo_exec; ntype.draw_buttons = node_layout; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); node_rna(ntype.rna_ext.srna); } diff --git a/source/blender/nodes/geometry/nodes/node_geo_curve_fillet.cc b/source/blender/nodes/geometry/nodes/node_geo_curve_fillet.cc index 52c70a3e46d..1ea91be59eb 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_curve_fillet.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_curve_fillet.cc @@ -204,11 +204,11 @@ static void node_register() ntype.nclass = NODE_CLASS_GEOMETRY; ntype.draw_buttons = node_layout; blender::bke::node_type_storage( - &ntype, "NodeGeometryCurveFillet", node_free_standard_storage, node_copy_standard_storage); + ntype, "NodeGeometryCurveFillet", node_free_standard_storage, node_copy_standard_storage); ntype.declare = node_declare; ntype.initfunc = node_init; ntype.geometry_node_execute = node_geo_exec; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); node_rna(ntype.rna_ext.srna); } diff --git a/source/blender/nodes/geometry/nodes/node_geo_curve_handle_type_selection.cc b/source/blender/nodes/geometry/nodes/node_geo_curve_handle_type_selection.cc index 421ffb125ba..60817383012 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_curve_handle_type_selection.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_curve_handle_type_selection.cc @@ -143,13 +143,13 @@ static void node_register() ntype.declare = node_declare; ntype.geometry_node_execute = node_geo_exec; ntype.initfunc = node_init; - blender::bke::node_type_storage(&ntype, + blender::bke::node_type_storage(ntype, "NodeGeometryCurveSelectHandles", node_free_standard_storage, node_copy_standard_storage); ntype.draw_buttons = node_layout; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } NOD_REGISTER_NODE(node_register) diff --git a/source/blender/nodes/geometry/nodes/node_geo_curve_length.cc b/source/blender/nodes/geometry/nodes/node_geo_curve_length.cc index b55a8b2d02c..7905572f554 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_curve_length.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_curve_length.cc @@ -68,7 +68,7 @@ static void node_register() ntype.nclass = NODE_CLASS_GEOMETRY; ntype.declare = node_declare; ntype.geometry_node_execute = node_geo_exec; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } NOD_REGISTER_NODE(node_register) diff --git a/source/blender/nodes/geometry/nodes/node_geo_curve_primitive_arc.cc b/source/blender/nodes/geometry/nodes/node_geo_curve_primitive_arc.cc index 1a4f50f43b5..cc97303e74d 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_curve_primitive_arc.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_curve_primitive_arc.cc @@ -376,14 +376,14 @@ static void node_register() ntype.enum_name_legacy = "CURVE_PRIMITIVE_ARC"; ntype.nclass = NODE_CLASS_GEOMETRY; ntype.initfunc = node_init; - blender::bke::node_type_storage(&ntype, + blender::bke::node_type_storage(ntype, "NodeGeometryCurvePrimitiveArc", node_free_standard_storage, node_copy_standard_storage); ntype.declare = node_declare; ntype.geometry_node_execute = node_geo_exec; ntype.draw_buttons = node_layout; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); node_rna(ntype.rna_ext.srna); } diff --git a/source/blender/nodes/geometry/nodes/node_geo_curve_primitive_bezier_segment.cc b/source/blender/nodes/geometry/nodes/node_geo_curve_primitive_bezier_segment.cc index a81e2e8d57a..2e4a5b59d01 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_curve_primitive_bezier_segment.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_curve_primitive_bezier_segment.cc @@ -150,14 +150,14 @@ static void node_register() ntype.enum_name_legacy = "CURVE_PRIMITIVE_BEZIER_SEGMENT"; ntype.nclass = NODE_CLASS_GEOMETRY; ntype.initfunc = node_init; - blender::bke::node_type_storage(&ntype, + blender::bke::node_type_storage(ntype, "NodeGeometryCurvePrimitiveBezierSegment", node_free_standard_storage, node_copy_standard_storage); ntype.declare = node_declare; ntype.draw_buttons = node_layout; ntype.geometry_node_execute = node_geo_exec; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); node_rna(ntype.rna_ext.srna); } diff --git a/source/blender/nodes/geometry/nodes/node_geo_curve_primitive_circle.cc b/source/blender/nodes/geometry/nodes/node_geo_curve_primitive_circle.cc index 52a652e8b39..e721e241b5e 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_curve_primitive_circle.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_curve_primitive_circle.cc @@ -237,14 +237,14 @@ static void node_register() ntype.enum_name_legacy = "CURVE_PRIMITIVE_CIRCLE"; ntype.nclass = NODE_CLASS_GEOMETRY; ntype.initfunc = node_init; - blender::bke::node_type_storage(&ntype, + blender::bke::node_type_storage(ntype, "NodeGeometryCurvePrimitiveCircle", node_free_standard_storage, node_copy_standard_storage); ntype.declare = node_declare; ntype.geometry_node_execute = node_geo_exec; ntype.draw_buttons = node_layout; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); node_rna(ntype.rna_ext.srna); } diff --git a/source/blender/nodes/geometry/nodes/node_geo_curve_primitive_line.cc b/source/blender/nodes/geometry/nodes/node_geo_curve_primitive_line.cc index 68da8d239d3..a4894c10978 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_curve_primitive_line.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_curve_primitive_line.cc @@ -145,14 +145,14 @@ static void node_register() ntype.enum_name_legacy = "CURVE_PRIMITIVE_LINE"; ntype.nclass = NODE_CLASS_GEOMETRY; ntype.initfunc = node_init; - blender::bke::node_type_storage(&ntype, + blender::bke::node_type_storage(ntype, "NodeGeometryCurvePrimitiveLine", node_free_standard_storage, node_copy_standard_storage); ntype.declare = node_declare; ntype.geometry_node_execute = node_geo_exec; ntype.draw_buttons = node_layout; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); node_rna(ntype.rna_ext.srna); } diff --git a/source/blender/nodes/geometry/nodes/node_geo_curve_primitive_quadratic_bezier.cc b/source/blender/nodes/geometry/nodes/node_geo_curve_primitive_quadratic_bezier.cc index 6e4c92aeabc..9a4e4c1c358 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_curve_primitive_quadratic_bezier.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_curve_primitive_quadratic_bezier.cc @@ -73,7 +73,7 @@ static void node_register() ntype.nclass = NODE_CLASS_GEOMETRY; ntype.declare = node_declare; ntype.geometry_node_execute = node_geo_exec; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } NOD_REGISTER_NODE(node_register) diff --git a/source/blender/nodes/geometry/nodes/node_geo_curve_primitive_quadrilateral.cc b/source/blender/nodes/geometry/nodes/node_geo_curve_primitive_quadrilateral.cc index ea940d65cd9..b3546d45549 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_curve_primitive_quadrilateral.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_curve_primitive_quadrilateral.cc @@ -320,12 +320,12 @@ static void node_register() ntype.geometry_node_execute = node_geo_exec; ntype.draw_buttons = node_layout; ntype.initfunc = node_init; - blender::bke::node_type_storage(&ntype, + blender::bke::node_type_storage(ntype, "NodeGeometryCurvePrimitiveQuad", node_free_standard_storage, node_copy_standard_storage); ntype.gather_link_search_ops = node_gather_link_searches; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); node_rna(ntype.rna_ext.srna); } diff --git a/source/blender/nodes/geometry/nodes/node_geo_curve_primitive_spiral.cc b/source/blender/nodes/geometry/nodes/node_geo_curve_primitive_spiral.cc index 6abe7fee6c1..856eb35f6b3 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_curve_primitive_spiral.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_curve_primitive_spiral.cc @@ -96,7 +96,7 @@ static void node_register() ntype.nclass = NODE_CLASS_GEOMETRY; ntype.declare = node_declare; ntype.geometry_node_execute = node_geo_exec; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } NOD_REGISTER_NODE(node_register) diff --git a/source/blender/nodes/geometry/nodes/node_geo_curve_primitive_star.cc b/source/blender/nodes/geometry/nodes/node_geo_curve_primitive_star.cc index 19a3832d7f4..6b3513ce84f 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_curve_primitive_star.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_curve_primitive_star.cc @@ -98,7 +98,7 @@ static void node_register() ntype.nclass = NODE_CLASS_GEOMETRY; ntype.declare = node_declare; ntype.geometry_node_execute = node_geo_exec; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } NOD_REGISTER_NODE(node_register) diff --git a/source/blender/nodes/geometry/nodes/node_geo_curve_resample.cc b/source/blender/nodes/geometry/nodes/node_geo_curve_resample.cc index e614f0e0a3e..41710719f37 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_curve_resample.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_curve_resample.cc @@ -221,10 +221,10 @@ static void node_register() ntype.draw_buttons = node_layout; ntype.draw_buttons_ex = node_layout_ex; blender::bke::node_type_storage( - &ntype, "NodeGeometryCurveResample", node_free_standard_storage, node_copy_standard_storage); + ntype, "NodeGeometryCurveResample", node_free_standard_storage, node_copy_standard_storage); ntype.initfunc = node_init; ntype.geometry_node_execute = node_geo_exec; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); node_rna(ntype.rna_ext.srna); } diff --git a/source/blender/nodes/geometry/nodes/node_geo_curve_reverse.cc b/source/blender/nodes/geometry/nodes/node_geo_curve_reverse.cc index abe41f2c3c4..253221493d5 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_curve_reverse.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_curve_reverse.cc @@ -78,7 +78,7 @@ static void node_register() ntype.nclass = NODE_CLASS_GEOMETRY; ntype.declare = node_declare; ntype.geometry_node_execute = node_geo_exec; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } NOD_REGISTER_NODE(node_register) diff --git a/source/blender/nodes/geometry/nodes/node_geo_curve_sample.cc b/source/blender/nodes/geometry/nodes/node_geo_curve_sample.cc index a262c49034d..7928a8c62eb 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_curve_sample.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_curve_sample.cc @@ -506,10 +506,10 @@ static void node_register() ntype.declare = node_declare; ntype.initfunc = node_init; blender::bke::node_type_storage( - &ntype, "NodeGeometryCurveSample", node_free_standard_storage, node_copy_standard_storage); + ntype, "NodeGeometryCurveSample", node_free_standard_storage, node_copy_standard_storage); ntype.draw_buttons = node_layout; ntype.gather_link_search_ops = node_gather_link_searches; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } NOD_REGISTER_NODE(node_register) diff --git a/source/blender/nodes/geometry/nodes/node_geo_curve_set_handle_type.cc b/source/blender/nodes/geometry/nodes/node_geo_curve_set_handle_type.cc index 0b3a1bc9862..a53213840b6 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_curve_set_handle_type.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_curve_set_handle_type.cc @@ -128,13 +128,13 @@ static void node_register() ntype.declare = node_declare; ntype.geometry_node_execute = node_geo_exec; ntype.initfunc = node_init; - blender::bke::node_type_storage(&ntype, + blender::bke::node_type_storage(ntype, "NodeGeometryCurveSetHandles", node_free_standard_storage, node_copy_standard_storage); ntype.draw_buttons = node_layout; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } NOD_REGISTER_NODE(node_register) diff --git a/source/blender/nodes/geometry/nodes/node_geo_curve_spline_parameter.cc b/source/blender/nodes/geometry/nodes/node_geo_curve_spline_parameter.cc index 52fdb97eea6..881ec43c3a9 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_curve_spline_parameter.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_curve_spline_parameter.cc @@ -300,7 +300,7 @@ static void node_register() ntype.nclass = NODE_CLASS_INPUT; ntype.geometry_node_execute = node_geo_exec; ntype.declare = node_declare; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } NOD_REGISTER_NODE(node_register) diff --git a/source/blender/nodes/geometry/nodes/node_geo_curve_spline_type.cc b/source/blender/nodes/geometry/nodes/node_geo_curve_spline_type.cc index 8d53d028191..b1b23c88678 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_curve_spline_type.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_curve_spline_type.cc @@ -100,13 +100,13 @@ static void node_register() ntype.declare = node_declare; ntype.geometry_node_execute = node_geo_exec; ntype.initfunc = node_init; - blender::bke::node_type_storage(&ntype, + blender::bke::node_type_storage(ntype, "NodeGeometryCurveSplineType", node_free_standard_storage, node_copy_standard_storage); ntype.draw_buttons = node_layout; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); node_rna(ntype.rna_ext.srna); } diff --git a/source/blender/nodes/geometry/nodes/node_geo_curve_subdivide.cc b/source/blender/nodes/geometry/nodes/node_geo_curve_subdivide.cc index fe2672a3abc..d7500569e27 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_curve_subdivide.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_curve_subdivide.cc @@ -111,7 +111,7 @@ static void node_register() ntype.nclass = NODE_CLASS_GEOMETRY; ntype.declare = node_declare; ntype.geometry_node_execute = node_geo_exec; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } NOD_REGISTER_NODE(node_register) diff --git a/source/blender/nodes/geometry/nodes/node_geo_curve_to_mesh.cc b/source/blender/nodes/geometry/nodes/node_geo_curve_to_mesh.cc index 72a4977a716..77008670f8f 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_curve_to_mesh.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_curve_to_mesh.cc @@ -140,7 +140,7 @@ static void node_register() ntype.nclass = NODE_CLASS_GEOMETRY; ntype.declare = node_declare; ntype.geometry_node_execute = node_geo_exec; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } NOD_REGISTER_NODE(node_register) diff --git a/source/blender/nodes/geometry/nodes/node_geo_curve_to_points.cc b/source/blender/nodes/geometry/nodes/node_geo_curve_to_points.cc index 2e47c0fbda8..17335b796ac 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_curve_to_points.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_curve_to_points.cc @@ -380,9 +380,9 @@ static void node_register() ntype.geometry_node_execute = node_geo_exec; ntype.draw_buttons = node_layout; blender::bke::node_type_storage( - &ntype, "NodeGeometryCurveToPoints", node_free_standard_storage, node_copy_standard_storage); + ntype, "NodeGeometryCurveToPoints", node_free_standard_storage, node_copy_standard_storage); ntype.initfunc = node_init; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); node_rna(ntype.rna_ext.srna); } diff --git a/source/blender/nodes/geometry/nodes/node_geo_curve_topology_curve_of_point.cc b/source/blender/nodes/geometry/nodes/node_geo_curve_topology_curve_of_point.cc index e7f0fc25f2e..c5f5df73aee 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_curve_topology_curve_of_point.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_curve_topology_curve_of_point.cc @@ -122,7 +122,7 @@ static void node_register() ntype.nclass = NODE_CLASS_INPUT; ntype.geometry_node_execute = node_geo_exec; ntype.declare = node_declare; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } NOD_REGISTER_NODE(node_register) diff --git a/source/blender/nodes/geometry/nodes/node_geo_curve_topology_points_of_curve.cc b/source/blender/nodes/geometry/nodes/node_geo_curve_topology_points_of_curve.cc index 1e6857d71a2..90e32050be1 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_curve_topology_points_of_curve.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_curve_topology_points_of_curve.cc @@ -255,7 +255,7 @@ static void node_register() ntype.nclass = NODE_CLASS_INPUT; ntype.geometry_node_execute = node_geo_exec; ntype.declare = node_declare; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } NOD_REGISTER_NODE(node_register) diff --git a/source/blender/nodes/geometry/nodes/node_geo_curve_trim.cc b/source/blender/nodes/geometry/nodes/node_geo_curve_trim.cc index 1f7d9a8e305..2203d3afc8d 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_curve_trim.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_curve_trim.cc @@ -268,10 +268,10 @@ static void node_register() ntype.draw_buttons = node_layout; ntype.declare = node_declare; blender::bke::node_type_storage( - &ntype, "NodeGeometryCurveTrim", node_free_standard_storage, node_copy_standard_storage); + ntype, "NodeGeometryCurveTrim", node_free_standard_storage, node_copy_standard_storage); ntype.initfunc = node_init; ntype.gather_link_search_ops = node_gather_link_searches; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); node_rna(ntype.rna_ext.srna); } diff --git a/source/blender/nodes/geometry/nodes/node_geo_curves_to_grease_pencil.cc b/source/blender/nodes/geometry/nodes/node_geo_curves_to_grease_pencil.cc index 8bd192d7b1e..1716e2daf6e 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_curves_to_grease_pencil.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_curves_to_grease_pencil.cc @@ -227,9 +227,9 @@ static void node_register() ntype.nclass = NODE_CLASS_GEOMETRY; ntype.geometry_node_execute = node_geo_exec; ntype.declare = node_declare; - bke::node_type_size(&ntype, 160, 100, 320); + bke::node_type_size(ntype, 160, 100, 320); - bke::node_register_type(&ntype); + bke::node_register_type(ntype); } NOD_REGISTER_NODE(node_register) diff --git a/source/blender/nodes/geometry/nodes/node_geo_deform_curves_on_surface.cc b/source/blender/nodes/geometry/nodes/node_geo_deform_curves_on_surface.cc index e264174f363..94963a69d0f 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_deform_curves_on_surface.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_deform_curves_on_surface.cc @@ -404,8 +404,8 @@ static void node_register() ntype.nclass = NODE_CLASS_GEOMETRY; ntype.geometry_node_execute = node_geo_exec; ntype.declare = node_declare; - blender::bke::node_type_size(&ntype, 170, 120, 700); - blender::bke::node_register_type(&ntype); + blender::bke::node_type_size(ntype, 170, 120, 700); + blender::bke::node_register_type(ntype); } NOD_REGISTER_NODE(node_register) diff --git a/source/blender/nodes/geometry/nodes/node_geo_delete_geometry.cc b/source/blender/nodes/geometry/nodes/node_geo_delete_geometry.cc index 8fd147593de..35bce79bb4b 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_delete_geometry.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_delete_geometry.cc @@ -117,16 +117,14 @@ static void node_register() ntype.ui_description = "Remove selected elements of a geometry"; ntype.enum_name_legacy = "DELETE_GEOMETRY"; ntype.nclass = NODE_CLASS_GEOMETRY; - blender::bke::node_type_storage(&ntype, - "NodeGeometryDeleteGeometry", - node_free_standard_storage, - node_copy_standard_storage); + blender::bke::node_type_storage( + ntype, "NodeGeometryDeleteGeometry", node_free_standard_storage, node_copy_standard_storage); ntype.initfunc = node_init; ntype.declare = node_declare; ntype.geometry_node_execute = node_geo_exec; ntype.draw_buttons = node_layout; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); node_rna(ntype.rna_ext.srna); } diff --git a/source/blender/nodes/geometry/nodes/node_geo_distribute_points_in_grid.cc b/source/blender/nodes/geometry/nodes/node_geo_distribute_points_in_grid.cc index c88bba7b615..a8e629586b4 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_distribute_points_in_grid.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_distribute_points_in_grid.cc @@ -260,12 +260,12 @@ static void node_register() ntype.enum_name_legacy = "DISTRIBUTE_POINTS_IN_GRID"; ntype.nclass = NODE_CLASS_GEOMETRY; ntype.initfunc = node_init; - blender::bke::node_type_size(&ntype, 170, 100, 320); + blender::bke::node_type_size(ntype, 170, 100, 320); ntype.declare = node_declare; ntype.geometry_node_execute = node_geo_exec; ntype.draw_buttons = node_layout; ntype.gather_link_search_ops = search_link_ops_for_volume_grid_node; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); node_rna(ntype.rna_ext.srna); } diff --git a/source/blender/nodes/geometry/nodes/node_geo_distribute_points_in_volume.cc b/source/blender/nodes/geometry/nodes/node_geo_distribute_points_in_volume.cc index ccf45221017..b4b586b9538 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_distribute_points_in_volume.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_distribute_points_in_volume.cc @@ -288,16 +288,16 @@ static void node_register() ntype.ui_description = "Generate points inside a volume"; ntype.enum_name_legacy = "DISTRIBUTE_POINTS_IN_VOLUME"; ntype.nclass = NODE_CLASS_GEOMETRY; - blender::bke::node_type_storage(&ntype, + blender::bke::node_type_storage(ntype, "NodeGeometryDistributePointsInVolume", node_free_standard_storage, node_copy_standard_storage); ntype.initfunc = node_init; - blender::bke::node_type_size(&ntype, 170, 100, 320); + blender::bke::node_type_size(ntype, 170, 100, 320); ntype.declare = node_declare; ntype.geometry_node_execute = node_geo_exec; ntype.draw_buttons = node_layout; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); node_rna(ntype.rna_ext.srna); } diff --git a/source/blender/nodes/geometry/nodes/node_geo_distribute_points_on_faces.cc b/source/blender/nodes/geometry/nodes/node_geo_distribute_points_on_faces.cc index c716a5005d5..0cc1022ccc2 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_distribute_points_on_faces.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_distribute_points_on_faces.cc @@ -613,12 +613,12 @@ static void node_register() ntype.ui_description = "Generate points spread out on the surface of a mesh"; ntype.enum_name_legacy = "DISTRIBUTE_POINTS_ON_FACES"; ntype.nclass = NODE_CLASS_GEOMETRY; - blender::bke::node_type_size(&ntype, 170, 100, 320); + blender::bke::node_type_size(ntype, 170, 100, 320); ntype.declare = node_declare; ntype.geometry_node_execute = node_geo_exec; ntype.draw_buttons = node_layout; ntype.draw_buttons_ex = node_layout_ex; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } NOD_REGISTER_NODE(node_register) diff --git a/source/blender/nodes/geometry/nodes/node_geo_dual_mesh.cc b/source/blender/nodes/geometry/nodes/node_geo_dual_mesh.cc index adcb0e0472e..a2f2f018457 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_dual_mesh.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_dual_mesh.cc @@ -937,7 +937,7 @@ static void node_register() ntype.nclass = NODE_CLASS_GEOMETRY; ntype.declare = node_declare; ntype.geometry_node_execute = node_geo_exec; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } NOD_REGISTER_NODE(node_register) diff --git a/source/blender/nodes/geometry/nodes/node_geo_duplicate_elements.cc b/source/blender/nodes/geometry/nodes/node_geo_duplicate_elements.cc index b42ddd91b6d..c7af019ee18 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_duplicate_elements.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_duplicate_elements.cc @@ -1249,7 +1249,7 @@ static void node_register() ntype.ui_description = "Generate an arbitrary number copies of each selected input element"; ntype.enum_name_legacy = "DUPLICATE_ELEMENTS"; ntype.nclass = NODE_CLASS_GEOMETRY; - blender::bke::node_type_storage(&ntype, + blender::bke::node_type_storage(ntype, "NodeGeometryDuplicateElements", node_free_standard_storage, node_copy_standard_storage); @@ -1258,7 +1258,7 @@ static void node_register() ntype.draw_buttons = node_layout; ntype.geometry_node_execute = node_geo_exec; ntype.declare = node_declare; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); node_rna(ntype.rna_ext.srna); } diff --git a/source/blender/nodes/geometry/nodes/node_geo_edge_paths_to_curves.cc b/source/blender/nodes/geometry/nodes/node_geo_edge_paths_to_curves.cc index dfd2dee71c2..186065c1427 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_edge_paths_to_curves.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_edge_paths_to_curves.cc @@ -109,7 +109,7 @@ static void node_register() ntype.nclass = NODE_CLASS_GEOMETRY; ntype.declare = node_declare; ntype.geometry_node_execute = node_geo_exec; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } NOD_REGISTER_NODE(node_register) diff --git a/source/blender/nodes/geometry/nodes/node_geo_edge_paths_to_selection.cc b/source/blender/nodes/geometry/nodes/node_geo_edge_paths_to_selection.cc index 8f4ea7c555d..616b2721de5 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_edge_paths_to_selection.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_edge_paths_to_selection.cc @@ -134,9 +134,9 @@ static void node_register() ntype.enum_name_legacy = "EDGE_PATHS_TO_SELECTION"; ntype.nclass = NODE_CLASS_INPUT; ntype.declare = node_declare; - blender::bke::node_type_size(&ntype, 150, 100, 300); + blender::bke::node_type_size(ntype, 150, 100, 300); ntype.geometry_node_execute = node_geo_exec; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } NOD_REGISTER_NODE(node_register) diff --git a/source/blender/nodes/geometry/nodes/node_geo_edge_split.cc b/source/blender/nodes/geometry/nodes/node_geo_edge_split.cc index 35fa0366cb2..baa3172dc1a 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_edge_split.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_edge_split.cc @@ -53,7 +53,7 @@ static void node_register() ntype.nclass = NODE_CLASS_GEOMETRY; ntype.geometry_node_execute = node_geo_exec; ntype.declare = node_declare; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } NOD_REGISTER_NODE(node_register) diff --git a/source/blender/nodes/geometry/nodes/node_geo_edges_to_face_groups.cc b/source/blender/nodes/geometry/nodes/node_geo_edges_to_face_groups.cc index 1be4ec92801..ca3a310ed13 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_edges_to_face_groups.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_edges_to_face_groups.cc @@ -111,7 +111,7 @@ static void node_register() ntype.geometry_node_execute = geo_node_exec; ntype.declare = node_declare; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } NOD_REGISTER_NODE(node_register) diff --git a/source/blender/nodes/geometry/nodes/node_geo_evaluate_at_index.cc b/source/blender/nodes/geometry/nodes/node_geo_evaluate_at_index.cc index c884cef6d1d..89422e9acd1 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_evaluate_at_index.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_evaluate_at_index.cc @@ -106,7 +106,7 @@ static void node_register() ntype.initfunc = node_init; ntype.declare = node_declare; ntype.gather_link_search_ops = node_gather_link_searches; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); node_rna(ntype.rna_ext.srna); } diff --git a/source/blender/nodes/geometry/nodes/node_geo_evaluate_on_domain.cc b/source/blender/nodes/geometry/nodes/node_geo_evaluate_on_domain.cc index 3440ad9778d..5129d66681b 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_evaluate_on_domain.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_evaluate_on_domain.cc @@ -100,7 +100,7 @@ static void node_register() ntype.initfunc = node_init; ntype.declare = node_declare; ntype.gather_link_search_ops = node_gather_link_searches; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); node_rna(ntype.rna_ext.srna); } diff --git a/source/blender/nodes/geometry/nodes/node_geo_extrude_mesh.cc b/source/blender/nodes/geometry/nodes/node_geo_extrude_mesh.cc index fcabe23cc08..13ff8e49ef3 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_extrude_mesh.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_extrude_mesh.cc @@ -1555,9 +1555,9 @@ static void node_register() ntype.initfunc = node_init; ntype.geometry_node_execute = node_geo_exec; blender::bke::node_type_storage( - &ntype, "NodeGeometryExtrudeMesh", node_free_standard_storage, node_copy_standard_storage); + ntype, "NodeGeometryExtrudeMesh", node_free_standard_storage, node_copy_standard_storage); ntype.draw_buttons = node_layout; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); node_rna(ntype.rna_ext.srna); } diff --git a/source/blender/nodes/geometry/nodes/node_geo_flip_faces.cc b/source/blender/nodes/geometry/nodes/node_geo_flip_faces.cc index c7b6987bf16..1b6c0b04e12 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_flip_faces.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_flip_faces.cc @@ -52,7 +52,7 @@ static void node_register() ntype.nclass = NODE_CLASS_GEOMETRY; ntype.geometry_node_execute = node_geo_exec; ntype.declare = node_declare; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } NOD_REGISTER_NODE(node_register) diff --git a/source/blender/nodes/geometry/nodes/node_geo_foreach_geometry_element.cc b/source/blender/nodes/geometry/nodes/node_geo_foreach_geometry_element.cc index 2d017cc1e09..664584c8286 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_foreach_geometry_element.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_foreach_geometry_element.cc @@ -214,11 +214,11 @@ static void node_register() ntype.insert_link = node_insert_link; ntype.gather_link_search_ops = nullptr; ntype.no_muting = true; - blender::bke::node_type_storage(&ntype, + blender::bke::node_type_storage(ntype, "NodeGeometryForeachGeometryElementInput", node_free_standard_storage, node_copy_standard_storage); - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } NOD_REGISTER_NODE(node_register) @@ -389,8 +389,8 @@ static void node_register() ntype.get_extra_info = node_extra_info; ntype.no_muting = true; blender::bke::node_type_storage( - &ntype, "NodeGeometryForeachGeometryElementOutput", node_free_storage, node_copy_storage); - blender::bke::node_register_type(&ntype); + ntype, "NodeGeometryForeachGeometryElementOutput", node_free_storage, node_copy_storage); + blender::bke::node_register_type(ntype); } NOD_REGISTER_NODE(node_register) diff --git a/source/blender/nodes/geometry/nodes/node_geo_geometry_to_instance.cc b/source/blender/nodes/geometry/nodes/node_geo_geometry_to_instance.cc index da15097b6a7..b6bf836bbc3 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_geometry_to_instance.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_geometry_to_instance.cc @@ -40,10 +40,10 @@ static void node_register() "Geometry node when the inputs are large"; ntype.enum_name_legacy = "GEOMETRY_TO_INSTANCE"; ntype.nclass = NODE_CLASS_GEOMETRY; - blender::bke::node_type_size(&ntype, 160, 100, 300); + blender::bke::node_type_size(ntype, 160, 100, 300); ntype.geometry_node_execute = node_geo_exec; ntype.declare = node_declare; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } NOD_REGISTER_NODE(node_register) diff --git a/source/blender/nodes/geometry/nodes/node_geo_get_named_grid.cc b/source/blender/nodes/geometry/nodes/node_geo_get_named_grid.cc index 2b195ef6699..634100af298 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_get_named_grid.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_get_named_grid.cc @@ -105,7 +105,7 @@ static void node_register() ntype.draw_buttons = node_layout; ntype.initfunc = node_init; ntype.geometry_node_execute = node_geo_exec; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); node_rna(ntype.rna_ext.srna); } diff --git a/source/blender/nodes/geometry/nodes/node_geo_gizmo_dial.cc b/source/blender/nodes/geometry/nodes/node_geo_gizmo_dial.cc index 4a9d9490150..09b50eb9945 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_gizmo_dial.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_gizmo_dial.cc @@ -58,11 +58,11 @@ static void node_register() ntype.enum_name_legacy = "GIZMO_DIAL"; ntype.nclass = NODE_CLASS_INTERFACE; bke::node_type_storage( - &ntype, "NodeGeometryDialGizmo", node_free_standard_storage, node_copy_standard_storage); + ntype, "NodeGeometryDialGizmo", node_free_standard_storage, node_copy_standard_storage); ntype.declare = node_declare; ntype.draw_buttons = node_layout; ntype.initfunc = node_init; - bke::node_register_type(&ntype); + bke::node_register_type(ntype); node_rna(ntype.rna_ext.srna); } diff --git a/source/blender/nodes/geometry/nodes/node_geo_gizmo_linear.cc b/source/blender/nodes/geometry/nodes/node_geo_gizmo_linear.cc index 2bfa963b4ba..9def116b0eb 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_gizmo_linear.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_gizmo_linear.cc @@ -63,11 +63,11 @@ static void node_register() ntype.enum_name_legacy = "GIZMO_LINEAR"; ntype.nclass = NODE_CLASS_INTERFACE; bke::node_type_storage( - &ntype, "NodeGeometryLinearGizmo", node_free_standard_storage, node_copy_standard_storage); + ntype, "NodeGeometryLinearGizmo", node_free_standard_storage, node_copy_standard_storage); ntype.declare = node_declare; ntype.draw_buttons = node_layout; ntype.initfunc = node_init; - bke::node_register_type(&ntype); + bke::node_register_type(ntype); node_rna(ntype.rna_ext.srna); } diff --git a/source/blender/nodes/geometry/nodes/node_geo_gizmo_transform.cc b/source/blender/nodes/geometry/nodes/node_geo_gizmo_transform.cc index bc47c2afd7c..eac9747cc10 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_gizmo_transform.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_gizmo_transform.cc @@ -70,14 +70,12 @@ static void node_register() ntype.ui_description = "Show a transform gizmo in the viewport"; ntype.enum_name_legacy = "GIZMO_TRANSFORM"; ntype.nclass = NODE_CLASS_INTERFACE; - bke::node_type_storage(&ntype, - "NodeGeometryTransformGizmo", - node_free_standard_storage, - node_copy_standard_storage); + bke::node_type_storage( + ntype, "NodeGeometryTransformGizmo", node_free_standard_storage, node_copy_standard_storage); ntype.declare = node_declare; ntype.draw_buttons_ex = node_layout_ex; ntype.initfunc = node_init; - bke::node_register_type(&ntype); + bke::node_register_type(ntype); } NOD_REGISTER_NODE(node_register) diff --git a/source/blender/nodes/geometry/nodes/node_geo_grease_pencil_to_curves.cc b/source/blender/nodes/geometry/nodes/node_geo_grease_pencil_to_curves.cc index a33e3422522..784dfc5cf54 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_grease_pencil_to_curves.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_grease_pencil_to_curves.cc @@ -150,9 +150,9 @@ static void node_register() ntype.nclass = NODE_CLASS_GEOMETRY; ntype.geometry_node_execute = node_geo_exec; ntype.declare = node_declare; - bke::node_type_size(&ntype, 160, 100, 320); + bke::node_type_size(ntype, 160, 100, 320); - bke::node_register_type(&ntype); + bke::node_register_type(ntype); } NOD_REGISTER_NODE(node_register) diff --git a/source/blender/nodes/geometry/nodes/node_geo_grid_to_mesh.cc b/source/blender/nodes/geometry/nodes/node_geo_grid_to_mesh.cc index afa3c7ea54c..02a2e588e97 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_grid_to_mesh.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_grid_to_mesh.cc @@ -56,7 +56,7 @@ static void node_register() ntype.declare = node_declare; ntype.geometry_node_execute = node_geo_exec; ntype.gather_link_search_ops = search_link_ops_for_volume_grid_node; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } NOD_REGISTER_NODE(node_register) diff --git a/source/blender/nodes/geometry/nodes/node_geo_image.cc b/source/blender/nodes/geometry/nodes/node_geo_image.cc index 7f49d96eff2..1505e7ef825 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_image.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_image.cc @@ -37,8 +37,8 @@ static void node_register() ntype.geometry_node_execute = node_geo_exec; ntype.draw_buttons = node_layout; ntype.declare = node_declare; - blender::bke::node_type_size_preset(&ntype, blender::bke::eNodeSizePreset::Large); - blender::bke::node_register_type(&ntype); + blender::bke::node_type_size_preset(ntype, blender::bke::eNodeSizePreset::Large); + blender::bke::node_register_type(ntype); } NOD_REGISTER_NODE(node_register) diff --git a/source/blender/nodes/geometry/nodes/node_geo_image_info.cc b/source/blender/nodes/geometry/nodes/node_geo_image_info.cc index 42c8534383a..edaef2f566a 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_image_info.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_image_info.cc @@ -82,8 +82,8 @@ static void node_register() ntype.nclass = NODE_CLASS_INPUT; ntype.declare = node_declare; ntype.geometry_node_execute = node_geo_exec; - blender::bke::node_type_size_preset(&ntype, blender::bke::eNodeSizePreset::Large); - blender::bke::node_register_type(&ntype); + blender::bke::node_type_size_preset(ntype, blender::bke::eNodeSizePreset::Large); + blender::bke::node_register_type(ntype); } NOD_REGISTER_NODE(node_register) diff --git a/source/blender/nodes/geometry/nodes/node_geo_image_texture.cc b/source/blender/nodes/geometry/nodes/node_geo_image_texture.cc index 297802dbf2f..cd06a82ceaa 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_image_texture.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_image_texture.cc @@ -428,11 +428,11 @@ static void node_register() ntype.draw_buttons = node_layout; ntype.initfunc = node_init; blender::bke::node_type_storage( - &ntype, "NodeGeometryImageTexture", node_free_standard_storage, node_copy_standard_storage); - blender::bke::node_type_size_preset(&ntype, blender::bke::eNodeSizePreset::Large); + ntype, "NodeGeometryImageTexture", node_free_standard_storage, node_copy_standard_storage); + blender::bke::node_type_size_preset(ntype, blender::bke::eNodeSizePreset::Large); ntype.geometry_node_execute = node_geo_exec; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } NOD_REGISTER_NODE(node_register) diff --git a/source/blender/nodes/geometry/nodes/node_geo_import_csv.cc b/source/blender/nodes/geometry/nodes/node_geo_import_csv.cc index c28d9a1745f..749b4318298 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_import_csv.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_import_csv.cc @@ -75,7 +75,7 @@ static void node_register() ntype.declare = node_declare; ntype.gather_link_search_ops = search_link_ops_for_import_node; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } NOD_REGISTER_NODE(node_register) diff --git a/source/blender/nodes/geometry/nodes/node_geo_import_obj.cc b/source/blender/nodes/geometry/nodes/node_geo_import_obj.cc index d540972a89c..aafca0a50a7 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_import_obj.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_import_obj.cc @@ -89,7 +89,7 @@ static void node_register() ntype.declare = node_declare; ntype.gather_link_search_ops = search_link_ops_for_import_node; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } NOD_REGISTER_NODE(node_register) diff --git a/source/blender/nodes/geometry/nodes/node_geo_import_ply.cc b/source/blender/nodes/geometry/nodes/node_geo_import_ply.cc index 51d698b4cef..35ce0055f08 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_import_ply.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_import_ply.cc @@ -78,7 +78,7 @@ static void node_register() ntype.declare = node_declare; ntype.gather_link_search_ops = search_link_ops_for_import_node; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } NOD_REGISTER_NODE(node_register) diff --git a/source/blender/nodes/geometry/nodes/node_geo_import_stl.cc b/source/blender/nodes/geometry/nodes/node_geo_import_stl.cc index 551e2740b29..c4f0a9846f4 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_import_stl.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_import_stl.cc @@ -80,7 +80,7 @@ static void node_register() ntype.declare = node_declare; ntype.gather_link_search_ops = search_link_ops_for_import_node; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } NOD_REGISTER_NODE(node_register) diff --git a/source/blender/nodes/geometry/nodes/node_geo_index_of_nearest.cc b/source/blender/nodes/geometry/nodes/node_geo_index_of_nearest.cc index c02f746757d..fc6779bcadf 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_index_of_nearest.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_index_of_nearest.cc @@ -251,7 +251,7 @@ static void node_register() ntype.nclass = NODE_CLASS_CONVERTER; ntype.geometry_node_execute = node_geo_exec; ntype.declare = node_declare; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } NOD_REGISTER_NODE(node_register) diff --git a/source/blender/nodes/geometry/nodes/node_geo_index_switch.cc b/source/blender/nodes/geometry/nodes/node_geo_index_switch.cc index 31852a007d9..fee63fba9ae 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_index_switch.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_index_switch.cc @@ -378,12 +378,12 @@ static void register_node() ntype.declare = node_declare; ntype.initfunc = node_init; ntype.insert_link = node_insert_link; - blender::bke::node_type_storage(&ntype, "NodeIndexSwitch", node_free_storage, node_copy_storage); + blender::bke::node_type_storage(ntype, "NodeIndexSwitch", node_free_storage, node_copy_storage); ntype.gather_link_search_ops = node_gather_link_searches; ntype.draw_buttons = node_layout; ntype.draw_buttons_ex = node_layout_ex; ntype.register_operators = node_operators; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); node_rna(ntype.rna_ext.srna); } diff --git a/source/blender/nodes/geometry/nodes/node_geo_input_active_camera.cc b/source/blender/nodes/geometry/nodes/node_geo_input_active_camera.cc index 478d1ef83bf..7f75e6a19f8 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_input_active_camera.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_input_active_camera.cc @@ -31,7 +31,7 @@ static void node_register() ntype.nclass = NODE_CLASS_INPUT; ntype.geometry_node_execute = node_exec; ntype.declare = node_declare; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } NOD_REGISTER_NODE(node_register) diff --git a/source/blender/nodes/geometry/nodes/node_geo_input_collection.cc b/source/blender/nodes/geometry/nodes/node_geo_input_collection.cc index 0a1ff010969..e96e38c1017 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_input_collection.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_input_collection.cc @@ -37,7 +37,7 @@ static void node_register() ntype.draw_buttons = node_layout; ntype.declare = node_declare; ntype.geometry_node_execute = node_geo_exec; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } NOD_REGISTER_NODE(node_register) diff --git a/source/blender/nodes/geometry/nodes/node_geo_input_curve_handles.cc b/source/blender/nodes/geometry/nodes/node_geo_input_curve_handles.cc index 6d166649df8..6ecd615e1d6 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_input_curve_handles.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_input_curve_handles.cc @@ -124,10 +124,10 @@ static void node_register() ntype.ui_description = "Retrieve the position of each Bézier control point's handles"; ntype.enum_name_legacy = "INPUT_CURVE_HANDLES"; ntype.nclass = NODE_CLASS_INPUT; - blender::bke::node_type_size_preset(&ntype, blender::bke::eNodeSizePreset::Middle); + blender::bke::node_type_size_preset(ntype, blender::bke::eNodeSizePreset::Middle); ntype.geometry_node_execute = node_geo_exec; ntype.declare = node_declare; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } NOD_REGISTER_NODE(node_register) diff --git a/source/blender/nodes/geometry/nodes/node_geo_input_curve_tilt.cc b/source/blender/nodes/geometry/nodes/node_geo_input_curve_tilt.cc index ca38821d140..282a64a7d75 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_input_curve_tilt.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_input_curve_tilt.cc @@ -30,7 +30,7 @@ static void node_register() ntype.nclass = NODE_CLASS_INPUT; ntype.geometry_node_execute = node_geo_exec; ntype.declare = node_declare; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } NOD_REGISTER_NODE(node_register) diff --git a/source/blender/nodes/geometry/nodes/node_geo_input_edge_smooth.cc b/source/blender/nodes/geometry/nodes/node_geo_input_edge_smooth.cc index b3c6a4fb15c..60d3d297278 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_input_edge_smooth.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_input_edge_smooth.cc @@ -28,7 +28,7 @@ static void node_register() ntype.nclass = NODE_CLASS_INPUT; ntype.geometry_node_execute = node_geo_exec; ntype.declare = node_declare; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } NOD_REGISTER_NODE(node_register) diff --git a/source/blender/nodes/geometry/nodes/node_geo_input_face_smooth.cc b/source/blender/nodes/geometry/nodes/node_geo_input_face_smooth.cc index d56f8c912d9..304193a6098 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_input_face_smooth.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_input_face_smooth.cc @@ -28,7 +28,7 @@ static void node_register() ntype.nclass = NODE_CLASS_INPUT; ntype.geometry_node_execute = node_geo_exec; ntype.declare = node_declare; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } NOD_REGISTER_NODE(node_register) diff --git a/source/blender/nodes/geometry/nodes/node_geo_input_id.cc b/source/blender/nodes/geometry/nodes/node_geo_input_id.cc index f8461c06615..c0e69daa498 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_input_id.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_input_id.cc @@ -32,7 +32,7 @@ static void node_register() ntype.nclass = NODE_CLASS_INPUT; ntype.geometry_node_execute = node_geo_exec; ntype.declare = node_declare; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } NOD_REGISTER_NODE(node_register) diff --git a/source/blender/nodes/geometry/nodes/node_geo_input_index.cc b/source/blender/nodes/geometry/nodes/node_geo_input_index.cc index c1a38de0fd0..23a1813119f 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_input_index.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_input_index.cc @@ -30,7 +30,7 @@ static void node_register() ntype.nclass = NODE_CLASS_INPUT; ntype.geometry_node_execute = node_geo_exec; ntype.declare = node_declare; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } NOD_REGISTER_NODE(node_register) diff --git a/source/blender/nodes/geometry/nodes/node_geo_input_instance_rotation.cc b/source/blender/nodes/geometry/nodes/node_geo_input_instance_rotation.cc index c08865fee99..e1a8d90508e 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_input_instance_rotation.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_input_instance_rotation.cc @@ -59,7 +59,7 @@ static void node_register() ntype.nclass = NODE_CLASS_INPUT; ntype.geometry_node_execute = node_geo_exec; ntype.declare = node_declare; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } NOD_REGISTER_NODE(node_register) diff --git a/source/blender/nodes/geometry/nodes/node_geo_input_instance_scale.cc b/source/blender/nodes/geometry/nodes/node_geo_input_instance_scale.cc index dd59fff12ef..3e6f830fcaa 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_input_instance_scale.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_input_instance_scale.cc @@ -55,7 +55,7 @@ static void node_register() ntype.nclass = NODE_CLASS_INPUT; ntype.geometry_node_execute = node_geo_exec; ntype.declare = node_declare; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } NOD_REGISTER_NODE(node_register) diff --git a/source/blender/nodes/geometry/nodes/node_geo_input_instance_transform.cc b/source/blender/nodes/geometry/nodes/node_geo_input_instance_transform.cc index e1fedddbf57..f140b605bc4 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_input_instance_transform.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_input_instance_transform.cc @@ -28,7 +28,7 @@ static void node_register() ntype.nclass = NODE_CLASS_INPUT; ntype.geometry_node_execute = node_geo_exec; ntype.declare = node_declare; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } NOD_REGISTER_NODE(node_register) diff --git a/source/blender/nodes/geometry/nodes/node_geo_input_material.cc b/source/blender/nodes/geometry/nodes/node_geo_input_material.cc index e3e09f0a6aa..2e933792a74 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_input_material.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_input_material.cc @@ -37,7 +37,7 @@ static void node_register() ntype.draw_buttons = node_layout; ntype.declare = node_declare; ntype.geometry_node_execute = node_geo_exec; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } NOD_REGISTER_NODE(node_register) diff --git a/source/blender/nodes/geometry/nodes/node_geo_input_material_index.cc b/source/blender/nodes/geometry/nodes/node_geo_input_material_index.cc index c5bf429d81d..c421cc464ed 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_input_material_index.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_input_material_index.cc @@ -30,7 +30,7 @@ static void node_register() ntype.nclass = NODE_CLASS_INPUT; ntype.geometry_node_execute = node_geo_exec; ntype.declare = node_declare; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } NOD_REGISTER_NODE(node_register) diff --git a/source/blender/nodes/geometry/nodes/node_geo_input_mesh_edge_angle.cc b/source/blender/nodes/geometry/nodes/node_geo_input_mesh_edge_angle.cc index 379a1c39e60..671635bec01 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_input_mesh_edge_angle.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_input_mesh_edge_angle.cc @@ -224,7 +224,7 @@ static void node_register() ntype.nclass = NODE_CLASS_INPUT; ntype.declare = node_declare; ntype.geometry_node_execute = node_geo_exec; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } NOD_REGISTER_NODE(node_register) diff --git a/source/blender/nodes/geometry/nodes/node_geo_input_mesh_edge_neighbors.cc b/source/blender/nodes/geometry/nodes/node_geo_input_mesh_edge_neighbors.cc index 776065c9b5c..bd6397a1be2 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_input_mesh_edge_neighbors.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_input_mesh_edge_neighbors.cc @@ -69,7 +69,7 @@ static void node_register() ntype.nclass = NODE_CLASS_INPUT; ntype.declare = node_declare; ntype.geometry_node_execute = node_geo_exec; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } NOD_REGISTER_NODE(node_register) diff --git a/source/blender/nodes/geometry/nodes/node_geo_input_mesh_edge_vertices.cc b/source/blender/nodes/geometry/nodes/node_geo_input_mesh_edge_vertices.cc index 16d165c57c7..7e6d4ff9f8d 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_input_mesh_edge_vertices.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_input_mesh_edge_vertices.cc @@ -161,7 +161,7 @@ static void node_register() ntype.nclass = NODE_CLASS_INPUT; ntype.declare = node_declare; ntype.geometry_node_execute = node_geo_exec; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } NOD_REGISTER_NODE(node_register) diff --git a/source/blender/nodes/geometry/nodes/node_geo_input_mesh_face_area.cc b/source/blender/nodes/geometry/nodes/node_geo_input_mesh_face_area.cc index 026c30efcc6..d1e2aa70c4d 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_input_mesh_face_area.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_input_mesh_face_area.cc @@ -76,7 +76,7 @@ static void node_register() ntype.nclass = NODE_CLASS_INPUT; ntype.declare = node_declare; ntype.geometry_node_execute = node_geo_exec; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } NOD_REGISTER_NODE(node_register) diff --git a/source/blender/nodes/geometry/nodes/node_geo_input_mesh_face_is_planar.cc b/source/blender/nodes/geometry/nodes/node_geo_input_mesh_face_is_planar.cc index eb09ec66dbd..b187944a002 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_input_mesh_face_is_planar.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_input_mesh_face_is_planar.cc @@ -119,7 +119,7 @@ static void node_register() ntype.nclass = NODE_CLASS_INPUT; ntype.geometry_node_execute = geo_node_exec; ntype.declare = node_declare; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } NOD_REGISTER_NODE(node_register) diff --git a/source/blender/nodes/geometry/nodes/node_geo_input_mesh_face_neighbors.cc b/source/blender/nodes/geometry/nodes/node_geo_input_mesh_face_neighbors.cc index 4dd48e7abea..2032a58fb45 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_input_mesh_face_neighbors.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_input_mesh_face_neighbors.cc @@ -161,10 +161,10 @@ static void node_register() ntype.ui_description = "Retrieve topology information relating to each face of a mesh"; ntype.enum_name_legacy = "MESH_FACE_NEIGHBORS"; ntype.nclass = NODE_CLASS_INPUT; - blender::bke::node_type_size_preset(&ntype, blender::bke::eNodeSizePreset::Middle); + blender::bke::node_type_size_preset(ntype, blender::bke::eNodeSizePreset::Middle); ntype.declare = node_declare; ntype.geometry_node_execute = node_geo_exec; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } NOD_REGISTER_NODE(node_register) diff --git a/source/blender/nodes/geometry/nodes/node_geo_input_mesh_island.cc b/source/blender/nodes/geometry/nodes/node_geo_input_mesh_island.cc index 609b3add13f..2628748586c 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_input_mesh_island.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_input_mesh_island.cc @@ -130,7 +130,7 @@ static void node_register() ntype.nclass = NODE_CLASS_INPUT; ntype.declare = node_declare; ntype.geometry_node_execute = node_geo_exec; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } NOD_REGISTER_NODE(node_register) diff --git a/source/blender/nodes/geometry/nodes/node_geo_input_mesh_vertex_neighbors.cc b/source/blender/nodes/geometry/nodes/node_geo_input_mesh_vertex_neighbors.cc index 8d15aac45df..2a882a69596 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_input_mesh_vertex_neighbors.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_input_mesh_vertex_neighbors.cc @@ -114,7 +114,7 @@ static void node_register() ntype.nclass = NODE_CLASS_INPUT; ntype.declare = node_declare; ntype.geometry_node_execute = node_geo_exec; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } NOD_REGISTER_NODE(node_register) diff --git a/source/blender/nodes/geometry/nodes/node_geo_input_named_attribute.cc b/source/blender/nodes/geometry/nodes/node_geo_input_named_attribute.cc index 00724385c3f..0816022df07 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_input_named_attribute.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_input_named_attribute.cc @@ -131,11 +131,11 @@ static void node_register() ntype.gather_link_search_ops = node_gather_link_searches; ntype.declare = node_declare; ntype.initfunc = node_init; - blender::bke::node_type_storage(&ntype, + blender::bke::node_type_storage(ntype, "NodeGeometryInputNamedAttribute", node_free_standard_storage, node_copy_standard_storage); - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); node_rna(ntype.rna_ext.srna); } diff --git a/source/blender/nodes/geometry/nodes/node_geo_input_named_layer_selection.cc b/source/blender/nodes/geometry/nodes/node_geo_input_named_layer_selection.cc index 1143f263039..58ed4593e8e 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_input_named_layer_selection.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_input_named_layer_selection.cc @@ -39,7 +39,7 @@ static void node_register() ntype.nclass = NODE_CLASS_INPUT; ntype.declare = node_declare; ntype.geometry_node_execute = node_geo_exec; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } NOD_REGISTER_NODE(node_register) diff --git a/source/blender/nodes/geometry/nodes/node_geo_input_normal.cc b/source/blender/nodes/geometry/nodes/node_geo_input_normal.cc index 385491e317a..af100faebf3 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_input_normal.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_input_normal.cc @@ -39,7 +39,7 @@ static void node_register() ntype.geometry_node_execute = node_geo_exec; ntype.declare = node_declare; ntype.draw_buttons_ex = node_layout_ex; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } NOD_REGISTER_NODE(node_register) diff --git a/source/blender/nodes/geometry/nodes/node_geo_input_object.cc b/source/blender/nodes/geometry/nodes/node_geo_input_object.cc index 1f95d559470..89eb0b50737 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_input_object.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_input_object.cc @@ -37,7 +37,7 @@ static void node_register() ntype.draw_buttons = node_layout; ntype.declare = node_declare; ntype.geometry_node_execute = node_geo_exec; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } NOD_REGISTER_NODE(node_register) diff --git a/source/blender/nodes/geometry/nodes/node_geo_input_position.cc b/source/blender/nodes/geometry/nodes/node_geo_input_position.cc index 8c2db9c91d3..f76167ec021 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_input_position.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_input_position.cc @@ -28,7 +28,7 @@ static void node_register() ntype.nclass = NODE_CLASS_INPUT; ntype.geometry_node_execute = node_geo_exec; ntype.declare = node_declare; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } NOD_REGISTER_NODE(node_register) diff --git a/source/blender/nodes/geometry/nodes/node_geo_input_radius.cc b/source/blender/nodes/geometry/nodes/node_geo_input_radius.cc index eccc0534771..352e4a829e7 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_input_radius.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_input_radius.cc @@ -28,7 +28,7 @@ static void node_register() ntype.nclass = NODE_CLASS_INPUT; ntype.geometry_node_execute = node_geo_exec; ntype.declare = node_declare; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } NOD_REGISTER_NODE(node_register) diff --git a/source/blender/nodes/geometry/nodes/node_geo_input_scene_time.cc b/source/blender/nodes/geometry/nodes/node_geo_input_scene_time.cc index 39eaf67a254..343ddaedb55 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_input_scene_time.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_input_scene_time.cc @@ -36,7 +36,7 @@ static void node_register() ntype.nclass = NODE_CLASS_INPUT; ntype.geometry_node_execute = node_exec; ntype.declare = node_declare; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } NOD_REGISTER_NODE(node_register) diff --git a/source/blender/nodes/geometry/nodes/node_geo_input_shortest_edge_paths.cc b/source/blender/nodes/geometry/nodes/node_geo_input_shortest_edge_paths.cc index b96c0c27005..b30fdb9aea9 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_input_shortest_edge_paths.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_input_shortest_edge_paths.cc @@ -272,7 +272,7 @@ static void node_register() ntype.nclass = NODE_CLASS_INPUT; ntype.declare = node_declare; ntype.geometry_node_execute = node_geo_exec; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } NOD_REGISTER_NODE(node_register) diff --git a/source/blender/nodes/geometry/nodes/node_geo_input_spline_cyclic.cc b/source/blender/nodes/geometry/nodes/node_geo_input_spline_cyclic.cc index 44f6290db2b..2ae08b60b9d 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_input_spline_cyclic.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_input_spline_cyclic.cc @@ -28,7 +28,7 @@ static void node_register() ntype.nclass = NODE_CLASS_INPUT; ntype.geometry_node_execute = node_geo_exec; ntype.declare = node_declare; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } NOD_REGISTER_NODE(node_register) diff --git a/source/blender/nodes/geometry/nodes/node_geo_input_spline_length.cc b/source/blender/nodes/geometry/nodes/node_geo_input_spline_length.cc index ef3e0422a28..533ac24b389 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_input_spline_length.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_input_spline_length.cc @@ -86,7 +86,7 @@ static void node_register() ntype.nclass = NODE_CLASS_INPUT; ntype.geometry_node_execute = node_geo_exec; ntype.declare = node_declare; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } NOD_REGISTER_NODE(node_register) diff --git a/source/blender/nodes/geometry/nodes/node_geo_input_spline_resolution.cc b/source/blender/nodes/geometry/nodes/node_geo_input_spline_resolution.cc index 2e0cbf9c92e..f4f004db77a 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_input_spline_resolution.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_input_spline_resolution.cc @@ -62,7 +62,7 @@ static void node_register() ntype.nclass = NODE_CLASS_INPUT; ntype.geometry_node_execute = node_geo_exec; ntype.declare = node_declare; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } NOD_REGISTER_NODE(node_register) diff --git a/source/blender/nodes/geometry/nodes/node_geo_input_tangent.cc b/source/blender/nodes/geometry/nodes/node_geo_input_tangent.cc index cefd4640155..df1b1dd8855 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_input_tangent.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_input_tangent.cc @@ -138,7 +138,7 @@ static void node_register() ntype.nclass = NODE_CLASS_INPUT; ntype.geometry_node_execute = node_geo_exec; ntype.declare = node_declare; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } NOD_REGISTER_NODE(node_register) diff --git a/source/blender/nodes/geometry/nodes/node_geo_instance_on_points.cc b/source/blender/nodes/geometry/nodes/node_geo_instance_on_points.cc index d59967e809f..44fe8fa925c 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_instance_on_points.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_instance_on_points.cc @@ -299,7 +299,7 @@ static void node_register() ntype.nclass = NODE_CLASS_GEOMETRY; ntype.declare = node_declare; ntype.geometry_node_execute = node_geo_exec; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } NOD_REGISTER_NODE(node_register) diff --git a/source/blender/nodes/geometry/nodes/node_geo_instances_to_points.cc b/source/blender/nodes/geometry/nodes/node_geo_instances_to_points.cc index 5e555989bb4..81928b7ae46 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_instances_to_points.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_instances_to_points.cc @@ -119,7 +119,7 @@ static void node_register() ntype.nclass = NODE_CLASS_GEOMETRY; ntype.declare = node_declare; ntype.geometry_node_execute = node_geo_exec; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } NOD_REGISTER_NODE(node_register) diff --git a/source/blender/nodes/geometry/nodes/node_geo_interpolate_curves.cc b/source/blender/nodes/geometry/nodes/node_geo_interpolate_curves.cc index 85242c359fb..e7184b3e2d3 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_interpolate_curves.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_interpolate_curves.cc @@ -881,7 +881,7 @@ static void node_register() ntype.nclass = NODE_CLASS_GEOMETRY; ntype.geometry_node_execute = node_geo_exec; ntype.declare = node_declare; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } NOD_REGISTER_NODE(node_register) diff --git a/source/blender/nodes/geometry/nodes/node_geo_is_viewport.cc b/source/blender/nodes/geometry/nodes/node_geo_is_viewport.cc index 0338fb31091..72fdcbf04af 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_is_viewport.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_is_viewport.cc @@ -35,7 +35,7 @@ static void node_register() ntype.nclass = NODE_CLASS_INPUT; ntype.geometry_node_execute = node_geo_exec; ntype.declare = node_declare; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } NOD_REGISTER_NODE(node_register) diff --git a/source/blender/nodes/geometry/nodes/node_geo_join_geometry.cc b/source/blender/nodes/geometry/nodes/node_geo_join_geometry.cc index 59ff11f0bc5..c5abb583336 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_join_geometry.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_join_geometry.cc @@ -40,7 +40,7 @@ static void node_register() ntype.nclass = NODE_CLASS_GEOMETRY; ntype.geometry_node_execute = node_geo_exec; ntype.declare = node_declare; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } NOD_REGISTER_NODE(node_register) diff --git a/source/blender/nodes/geometry/nodes/node_geo_material_replace.cc b/source/blender/nodes/geometry/nodes/node_geo_material_replace.cc index f07310649e1..050315420eb 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_material_replace.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_material_replace.cc @@ -62,7 +62,7 @@ static void node_register() ntype.nclass = NODE_CLASS_GEOMETRY; ntype.declare = node_declare; ntype.geometry_node_execute = node_geo_exec; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } NOD_REGISTER_NODE(node_register) diff --git a/source/blender/nodes/geometry/nodes/node_geo_material_selection.cc b/source/blender/nodes/geometry/nodes/node_geo_material_selection.cc index d31311418a4..cd0337385b2 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_material_selection.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_material_selection.cc @@ -168,7 +168,7 @@ static void node_register() ntype.nclass = NODE_CLASS_GEOMETRY; ntype.declare = node_declare; ntype.geometry_node_execute = node_geo_exec; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } NOD_REGISTER_NODE(node_register) diff --git a/source/blender/nodes/geometry/nodes/node_geo_menu_switch.cc b/source/blender/nodes/geometry/nodes/node_geo_menu_switch.cc index e42f6748d9f..9e666d3344e 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_menu_switch.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_menu_switch.cc @@ -415,13 +415,13 @@ static void register_node() ntype.nclass = NODE_CLASS_CONVERTER; ntype.declare = node_declare; ntype.initfunc = node_init; - blender::bke::node_type_storage(&ntype, "NodeMenuSwitch", node_free_storage, node_copy_storage); + blender::bke::node_type_storage(ntype, "NodeMenuSwitch", node_free_storage, node_copy_storage); ntype.gather_link_search_ops = node_gather_link_searches; ntype.draw_buttons = node_layout; ntype.draw_buttons_ex = node_layout_ex; ntype.register_operators = node_operators; ntype.insert_link = node_insert_link; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); node_rna(ntype.rna_ext.srna); } diff --git a/source/blender/nodes/geometry/nodes/node_geo_merge_by_distance.cc b/source/blender/nodes/geometry/nodes/node_geo_merge_by_distance.cc index 614c8028090..398b0d73422 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_merge_by_distance.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_merge_by_distance.cc @@ -165,14 +165,14 @@ static void node_register() ntype.enum_name_legacy = "MERGE_BY_DISTANCE"; ntype.nclass = NODE_CLASS_GEOMETRY; ntype.initfunc = node_init; - blender::bke::node_type_storage(&ntype, + blender::bke::node_type_storage(ntype, "NodeGeometryMergeByDistance", node_free_standard_storage, node_copy_standard_storage); ntype.declare = node_declare; ntype.geometry_node_execute = node_geo_exec; ntype.draw_buttons = node_layout; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); node_rna(ntype.rna_ext.srna); } diff --git a/source/blender/nodes/geometry/nodes/node_geo_merge_layers.cc b/source/blender/nodes/geometry/nodes/node_geo_merge_layers.cc index d2f2f28cd4e..3da659ab9f8 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_merge_layers.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_merge_layers.cc @@ -208,8 +208,8 @@ static void node_register() ntype.draw_buttons = node_layout; ntype.geometry_node_execute = node_geo_exec; blender::bke::node_type_storage( - &ntype, "NodeGeometryMergeLayers", node_free_standard_storage, node_copy_standard_storage); - blender::bke::node_register_type(&ntype); + ntype, "NodeGeometryMergeLayers", node_free_standard_storage, node_copy_standard_storage); + blender::bke::node_register_type(ntype); node_rna(ntype.rna_ext.srna); } diff --git a/source/blender/nodes/geometry/nodes/node_geo_mesh_face_group_boundaries.cc b/source/blender/nodes/geometry/nodes/node_geo_mesh_face_group_boundaries.cc index 1037be48aca..d61f6fa5f3a 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_mesh_face_group_boundaries.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_mesh_face_group_boundaries.cc @@ -132,10 +132,10 @@ static void node_register() "Find edges on the boundaries between groups of faces with the same ID value"; ntype.enum_name_legacy = "MESH_FACE_SET_BOUNDARIES"; ntype.nclass = NODE_CLASS_INPUT; - bke::node_type_size_preset(&ntype, bke::eNodeSizePreset::Middle); + bke::node_type_size_preset(ntype, bke::eNodeSizePreset::Middle); ntype.declare = node_declare; ntype.geometry_node_execute = node_geo_exec; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } NOD_REGISTER_NODE(node_register) diff --git a/source/blender/nodes/geometry/nodes/node_geo_mesh_primitive_circle.cc b/source/blender/nodes/geometry/nodes/node_geo_mesh_primitive_circle.cc index e027abca86e..6942cbb41e7 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_mesh_primitive_circle.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_mesh_primitive_circle.cc @@ -228,11 +228,11 @@ static void node_register() ntype.nclass = NODE_CLASS_GEOMETRY; ntype.initfunc = node_init; blender::bke::node_type_storage( - &ntype, "NodeGeometryMeshCircle", node_free_standard_storage, node_copy_standard_storage); + ntype, "NodeGeometryMeshCircle", node_free_standard_storage, node_copy_standard_storage); ntype.geometry_node_execute = node_geo_exec; ntype.draw_buttons = node_layout; ntype.declare = node_declare; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); node_rna(ntype.rna_ext.srna); } diff --git a/source/blender/nodes/geometry/nodes/node_geo_mesh_primitive_cone.cc b/source/blender/nodes/geometry/nodes/node_geo_mesh_primitive_cone.cc index ccd298aa2a4..ae69987c714 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_mesh_primitive_cone.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_mesh_primitive_cone.cc @@ -160,11 +160,11 @@ static void node_register() ntype.nclass = NODE_CLASS_GEOMETRY; ntype.initfunc = node_init; blender::bke::node_type_storage( - &ntype, "NodeGeometryMeshCone", node_free_standard_storage, node_copy_standard_storage); + ntype, "NodeGeometryMeshCone", node_free_standard_storage, node_copy_standard_storage); ntype.geometry_node_execute = node_geo_exec; ntype.draw_buttons = node_layout; ntype.declare = node_declare; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); node_rna(ntype.rna_ext.srna); } diff --git a/source/blender/nodes/geometry/nodes/node_geo_mesh_primitive_cube.cc b/source/blender/nodes/geometry/nodes/node_geo_mesh_primitive_cube.cc index 0575d4f6460..de2261323a0 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_mesh_primitive_cube.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_mesh_primitive_cube.cc @@ -123,7 +123,7 @@ static void node_register() ntype.nclass = NODE_CLASS_GEOMETRY; ntype.declare = node_declare; ntype.geometry_node_execute = node_geo_exec; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } NOD_REGISTER_NODE(node_register) diff --git a/source/blender/nodes/geometry/nodes/node_geo_mesh_primitive_cylinder.cc b/source/blender/nodes/geometry/nodes/node_geo_mesh_primitive_cylinder.cc index 183f39b275b..2cf26bb2148 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_mesh_primitive_cylinder.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_mesh_primitive_cylinder.cc @@ -150,11 +150,11 @@ static void node_register() ntype.nclass = NODE_CLASS_GEOMETRY; ntype.initfunc = node_init; blender::bke::node_type_storage( - &ntype, "NodeGeometryMeshCylinder", node_free_standard_storage, node_copy_standard_storage); + ntype, "NodeGeometryMeshCylinder", node_free_standard_storage, node_copy_standard_storage); ntype.declare = node_declare; ntype.geometry_node_execute = node_geo_exec; ntype.draw_buttons = node_layout; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); node_rna(ntype.rna_ext.srna); } diff --git a/source/blender/nodes/geometry/nodes/node_geo_mesh_primitive_grid.cc b/source/blender/nodes/geometry/nodes/node_geo_mesh_primitive_grid.cc index 0b85b4aa09d..938210a4862 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_mesh_primitive_grid.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_mesh_primitive_grid.cc @@ -67,7 +67,7 @@ static void node_register() ntype.nclass = NODE_CLASS_GEOMETRY; ntype.declare = node_declare; ntype.geometry_node_execute = node_geo_exec; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } NOD_REGISTER_NODE(node_register) diff --git a/source/blender/nodes/geometry/nodes/node_geo_mesh_primitive_ico_sphere.cc b/source/blender/nodes/geometry/nodes/node_geo_mesh_primitive_ico_sphere.cc index 1e52ebea8b1..f68672ecd43 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_mesh_primitive_ico_sphere.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_mesh_primitive_ico_sphere.cc @@ -141,7 +141,7 @@ static void node_register() ntype.nclass = NODE_CLASS_GEOMETRY; ntype.declare = node_declare; ntype.geometry_node_execute = node_geo_exec; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } NOD_REGISTER_NODE(node_register) diff --git a/source/blender/nodes/geometry/nodes/node_geo_mesh_primitive_line.cc b/source/blender/nodes/geometry/nodes/node_geo_mesh_primitive_line.cc index c8159112c34..4c4730c7325 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_mesh_primitive_line.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_mesh_primitive_line.cc @@ -80,12 +80,12 @@ static void node_update(bNodeTree *ntree, bNode *node) (mode == GEO_NODE_MESH_LINE_MODE_END_POINTS) ? N_("End Location") : N_("Offset")); - bke::node_set_socket_availability(ntree, - resolution_socket, + bke::node_set_socket_availability(*ntree, + *resolution_socket, mode == GEO_NODE_MESH_LINE_MODE_END_POINTS && count_mode == GEO_NODE_MESH_LINE_COUNT_RESOLUTION); - bke::node_set_socket_availability(ntree, - count_socket, + bke::node_set_socket_availability(*ntree, + *count_socket, mode == GEO_NODE_MESH_LINE_MODE_OFFSET || count_mode == GEO_NODE_MESH_LINE_COUNT_TOTAL); } @@ -232,12 +232,12 @@ static void node_register() ntype.declare = node_declare; ntype.initfunc = node_init; blender::bke::node_type_storage( - &ntype, "NodeGeometryMeshLine", node_free_standard_storage, node_copy_standard_storage); + ntype, "NodeGeometryMeshLine", node_free_standard_storage, node_copy_standard_storage); ntype.geometry_node_execute = node_geo_exec; ntype.draw_buttons = node_layout; ntype.updatefunc = node_update; ntype.gather_link_search_ops = node_gather_link_searches; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); node_rna(ntype.rna_ext.srna); } diff --git a/source/blender/nodes/geometry/nodes/node_geo_mesh_primitive_uv_sphere.cc b/source/blender/nodes/geometry/nodes/node_geo_mesh_primitive_uv_sphere.cc index 229caf4b0e4..f25f74c6767 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_mesh_primitive_uv_sphere.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_mesh_primitive_uv_sphere.cc @@ -65,7 +65,7 @@ static void node_register() ntype.nclass = NODE_CLASS_GEOMETRY; ntype.declare = node_declare; ntype.geometry_node_execute = node_geo_exec; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } NOD_REGISTER_NODE(node_register) diff --git a/source/blender/nodes/geometry/nodes/node_geo_mesh_subdivide.cc b/source/blender/nodes/geometry/nodes/node_geo_mesh_subdivide.cc index f20100dd0b5..fa9e6aad849 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_mesh_subdivide.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_mesh_subdivide.cc @@ -87,7 +87,7 @@ static void node_register() ntype.nclass = NODE_CLASS_GEOMETRY; ntype.declare = node_declare; ntype.geometry_node_execute = node_geo_exec; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } NOD_REGISTER_NODE(node_register) diff --git a/source/blender/nodes/geometry/nodes/node_geo_mesh_to_curve.cc b/source/blender/nodes/geometry/nodes/node_geo_mesh_to_curve.cc index 87557bb19d9..82be221a3b8 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_mesh_to_curve.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_mesh_to_curve.cc @@ -58,7 +58,7 @@ static void node_register() ntype.nclass = NODE_CLASS_GEOMETRY; ntype.declare = node_declare; ntype.geometry_node_execute = node_geo_exec; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } NOD_REGISTER_NODE(node_register) diff --git a/source/blender/nodes/geometry/nodes/node_geo_mesh_to_density_grid.cc b/source/blender/nodes/geometry/nodes/node_geo_mesh_to_density_grid.cc index c575d6f27df..2bbdeecc71d 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_mesh_to_density_grid.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_mesh_to_density_grid.cc @@ -66,7 +66,7 @@ static void node_register() ntype.declare = node_declare; ntype.geometry_node_execute = node_geo_exec; ntype.gather_link_search_ops = search_link_ops_for_volume_grid_node; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } NOD_REGISTER_NODE(node_register) diff --git a/source/blender/nodes/geometry/nodes/node_geo_mesh_to_points.cc b/source/blender/nodes/geometry/nodes/node_geo_mesh_to_points.cc index a17b45ac50e..367f889f259 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_mesh_to_points.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_mesh_to_points.cc @@ -252,8 +252,8 @@ static void node_register() ntype.initfunc = node_init; ntype.draw_buttons = node_layout; blender::bke::node_type_storage( - &ntype, "NodeGeometryMeshToPoints", node_free_standard_storage, node_copy_standard_storage); - blender::bke::node_register_type(&ntype); + ntype, "NodeGeometryMeshToPoints", node_free_standard_storage, node_copy_standard_storage); + blender::bke::node_register_type(ntype); node_rna(ntype.rna_ext.srna); } diff --git a/source/blender/nodes/geometry/nodes/node_geo_mesh_to_sdf_grid.cc b/source/blender/nodes/geometry/nodes/node_geo_mesh_to_sdf_grid.cc index e5dbf27c5e8..4ce9642bbdd 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_mesh_to_sdf_grid.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_mesh_to_sdf_grid.cc @@ -61,7 +61,7 @@ static void node_register() ntype.declare = node_declare; ntype.geometry_node_execute = node_geo_exec; ntype.gather_link_search_ops = search_link_ops_for_volume_grid_node; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } NOD_REGISTER_NODE(node_register) diff --git a/source/blender/nodes/geometry/nodes/node_geo_mesh_to_volume.cc b/source/blender/nodes/geometry/nodes/node_geo_mesh_to_volume.cc index 2344a076ba9..4d4bee59eb1 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_mesh_to_volume.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_mesh_to_volume.cc @@ -169,13 +169,13 @@ static void node_register() ntype.enum_name_legacy = "MESH_TO_VOLUME"; ntype.nclass = NODE_CLASS_GEOMETRY; ntype.declare = node_declare; - bke::node_type_size(&ntype, 200, 120, 700); + bke::node_type_size(ntype, 200, 120, 700); ntype.initfunc = node_init; ntype.geometry_node_execute = node_geo_exec; ntype.draw_buttons = node_layout; blender::bke::node_type_storage( - &ntype, "NodeGeometryMeshToVolume", node_free_standard_storage, node_copy_standard_storage); - blender::bke::node_register_type(&ntype); + ntype, "NodeGeometryMeshToVolume", node_free_standard_storage, node_copy_standard_storage); + blender::bke::node_register_type(ntype); node_rna(ntype.rna_ext.srna); } diff --git a/source/blender/nodes/geometry/nodes/node_geo_mesh_topology_corners_of_edge.cc b/source/blender/nodes/geometry/nodes/node_geo_mesh_topology_corners_of_edge.cc index fc69bceebca..e4a8399c2b8 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_mesh_topology_corners_of_edge.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_mesh_topology_corners_of_edge.cc @@ -198,7 +198,7 @@ static void node_register() ntype.nclass = NODE_CLASS_INPUT; ntype.geometry_node_execute = node_geo_exec; ntype.declare = node_declare; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } NOD_REGISTER_NODE(node_register) diff --git a/source/blender/nodes/geometry/nodes/node_geo_mesh_topology_corners_of_face.cc b/source/blender/nodes/geometry/nodes/node_geo_mesh_topology_corners_of_face.cc index 6e84d32847e..7afb0506bce 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_mesh_topology_corners_of_face.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_mesh_topology_corners_of_face.cc @@ -198,7 +198,7 @@ static void node_register() ntype.nclass = NODE_CLASS_INPUT; ntype.geometry_node_execute = node_geo_exec; ntype.declare = node_declare; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } NOD_REGISTER_NODE(node_register) diff --git a/source/blender/nodes/geometry/nodes/node_geo_mesh_topology_corners_of_vertex.cc b/source/blender/nodes/geometry/nodes/node_geo_mesh_topology_corners_of_vertex.cc index b3ab36dfbdc..ab0153abd6b 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_mesh_topology_corners_of_vertex.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_mesh_topology_corners_of_vertex.cc @@ -205,7 +205,7 @@ static void node_register() ntype.nclass = NODE_CLASS_INPUT; ntype.geometry_node_execute = node_geo_exec; ntype.declare = node_declare; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } NOD_REGISTER_NODE(node_register) diff --git a/source/blender/nodes/geometry/nodes/node_geo_mesh_topology_edges_of_corner.cc b/source/blender/nodes/geometry/nodes/node_geo_mesh_topology_edges_of_corner.cc index 6ecdcadc833..47f3059edc4 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_mesh_topology_edges_of_corner.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_mesh_topology_edges_of_corner.cc @@ -124,7 +124,7 @@ static void node_register() ntype.nclass = NODE_CLASS_INPUT; ntype.geometry_node_execute = node_geo_exec; ntype.declare = node_declare; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } NOD_REGISTER_NODE(node_register) diff --git a/source/blender/nodes/geometry/nodes/node_geo_mesh_topology_edges_of_vertex.cc b/source/blender/nodes/geometry/nodes/node_geo_mesh_topology_edges_of_vertex.cc index 89e18c1e752..8319a012af3 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_mesh_topology_edges_of_vertex.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_mesh_topology_edges_of_vertex.cc @@ -211,7 +211,7 @@ static void node_register() ntype.nclass = NODE_CLASS_INPUT; ntype.geometry_node_execute = node_geo_exec; ntype.declare = node_declare; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } NOD_REGISTER_NODE(node_register) diff --git a/source/blender/nodes/geometry/nodes/node_geo_mesh_topology_face_of_corner.cc b/source/blender/nodes/geometry/nodes/node_geo_mesh_topology_face_of_corner.cc index efd7590bd29..8f8ee5a34c5 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_mesh_topology_face_of_corner.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_mesh_topology_face_of_corner.cc @@ -116,7 +116,7 @@ static void node_register() ntype.nclass = NODE_CLASS_INPUT; ntype.geometry_node_execute = node_geo_exec; ntype.declare = node_declare; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } NOD_REGISTER_NODE(node_register) diff --git a/source/blender/nodes/geometry/nodes/node_geo_mesh_topology_offset_corner_in_face.cc b/source/blender/nodes/geometry/nodes/node_geo_mesh_topology_offset_corner_in_face.cc index 6f234e61338..00215b6a68a 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_mesh_topology_offset_corner_in_face.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_mesh_topology_offset_corner_in_face.cc @@ -113,7 +113,7 @@ static void node_register() ntype.nclass = NODE_CLASS_INPUT; ntype.geometry_node_execute = node_geo_exec; ntype.declare = node_declare; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } NOD_REGISTER_NODE(node_register) diff --git a/source/blender/nodes/geometry/nodes/node_geo_mesh_topology_vertex_of_corner.cc b/source/blender/nodes/geometry/nodes/node_geo_mesh_topology_vertex_of_corner.cc index 79faebd49fd..c25d9d036f1 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_mesh_topology_vertex_of_corner.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_mesh_topology_vertex_of_corner.cc @@ -71,7 +71,7 @@ static void node_register() ntype.nclass = NODE_CLASS_INPUT; ntype.geometry_node_execute = node_geo_exec; ntype.declare = node_declare; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } NOD_REGISTER_NODE(node_register) diff --git a/source/blender/nodes/geometry/nodes/node_geo_mouse_position.cc b/source/blender/nodes/geometry/nodes/node_geo_mouse_position.cc index 959444fdc0b..8a1514b384f 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_mouse_position.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_mouse_position.cc @@ -40,7 +40,7 @@ static void node_register() ntype.declare = node_declare; ntype.geometry_node_execute = node_geo_exec; ntype.gather_link_search_ops = search_link_ops_for_tool_node; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } NOD_REGISTER_NODE(node_register) diff --git a/source/blender/nodes/geometry/nodes/node_geo_object_info.cc b/source/blender/nodes/geometry/nodes/node_geo_object_info.cc index 886f603b134..0b064181546 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_object_info.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_object_info.cc @@ -206,11 +206,11 @@ static void node_register() ntype.nclass = NODE_CLASS_INPUT; ntype.initfunc = node_node_init; blender::bke::node_type_storage( - &ntype, "NodeGeometryObjectInfo", node_free_standard_storage, node_copy_standard_storage); + ntype, "NodeGeometryObjectInfo", node_free_standard_storage, node_copy_standard_storage); ntype.geometry_node_execute = node_geo_exec; ntype.draw_buttons = node_layout; ntype.declare = node_declare; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); node_rna(ntype.rna_ext.srna); } diff --git a/source/blender/nodes/geometry/nodes/node_geo_offset_point_in_curve.cc b/source/blender/nodes/geometry/nodes/node_geo_offset_point_in_curve.cc index c1ac6c80d25..adcb5b3850c 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_offset_point_in_curve.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_offset_point_in_curve.cc @@ -187,7 +187,7 @@ static void node_register() ntype.nclass = NODE_CLASS_INPUT; ntype.geometry_node_execute = node_geo_exec; ntype.declare = node_declare; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } NOD_REGISTER_NODE(node_register) diff --git a/source/blender/nodes/geometry/nodes/node_geo_points.cc b/source/blender/nodes/geometry/nodes/node_geo_points.cc index cfb004dd98e..4f8ace39a7c 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_points.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_points.cc @@ -93,7 +93,7 @@ static void node_register() ntype.nclass = NODE_CLASS_GEOMETRY; ntype.geometry_node_execute = node_geo_exec; ntype.declare = node_declare; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } NOD_REGISTER_NODE(node_register) diff --git a/source/blender/nodes/geometry/nodes/node_geo_points_to_curves.cc b/source/blender/nodes/geometry/nodes/node_geo_points_to_curves.cc index b3c3f16e054..ddb49ed5932 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_points_to_curves.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_points_to_curves.cc @@ -198,7 +198,7 @@ static void node_register() ntype.nclass = NODE_CLASS_GEOMETRY; ntype.geometry_node_execute = node_geo_exec; ntype.declare = node_declare; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } NOD_REGISTER_NODE(node_register) diff --git a/source/blender/nodes/geometry/nodes/node_geo_points_to_sdf_grid.cc b/source/blender/nodes/geometry/nodes/node_geo_points_to_sdf_grid.cc index c9418cdad45..f326c7d978d 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_points_to_sdf_grid.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_points_to_sdf_grid.cc @@ -115,7 +115,7 @@ static void node_register() ntype.declare = node_declare; ntype.geometry_node_execute = node_geo_exec; ntype.gather_link_search_ops = search_link_ops_for_volume_grid_node; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } NOD_REGISTER_NODE(node_register) diff --git a/source/blender/nodes/geometry/nodes/node_geo_points_to_vertices.cc b/source/blender/nodes/geometry/nodes/node_geo_points_to_vertices.cc index c8d68e121e0..1d1abe12028 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_points_to_vertices.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_points_to_vertices.cc @@ -110,7 +110,7 @@ static void node_register() ntype.nclass = NODE_CLASS_GEOMETRY; ntype.declare = node_declare; ntype.geometry_node_execute = node_geo_exec; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } NOD_REGISTER_NODE(node_register) diff --git a/source/blender/nodes/geometry/nodes/node_geo_points_to_volume.cc b/source/blender/nodes/geometry/nodes/node_geo_points_to_volume.cc index d35a25f6547..8c04b0dea1d 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_points_to_volume.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_points_to_volume.cc @@ -224,16 +224,14 @@ static void node_register() ntype.ui_description = "Generate a fog volume sphere around every point"; ntype.enum_name_legacy = "POINTS_TO_VOLUME"; ntype.nclass = NODE_CLASS_GEOMETRY; - blender::bke::node_type_storage(&ntype, - "NodeGeometryPointsToVolume", - node_free_standard_storage, - node_copy_standard_storage); - bke::node_type_size(&ntype, 170, 120, 700); + blender::bke::node_type_storage( + ntype, "NodeGeometryPointsToVolume", node_free_standard_storage, node_copy_standard_storage); + bke::node_type_size(ntype, 170, 120, 700); ntype.initfunc = node_init; ntype.declare = node_declare; ntype.geometry_node_execute = node_geo_exec; ntype.draw_buttons = node_layout; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); node_rna(ntype.rna_ext.srna); } diff --git a/source/blender/nodes/geometry/nodes/node_geo_proximity.cc b/source/blender/nodes/geometry/nodes/node_geo_proximity.cc index d61e8bb3746..cfd5622d7d3 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_proximity.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_proximity.cc @@ -314,11 +314,11 @@ static void node_register() ntype.nclass = NODE_CLASS_GEOMETRY; ntype.initfunc = geo_proximity_init; blender::bke::node_type_storage( - &ntype, "NodeGeometryProximity", node_free_standard_storage, node_copy_standard_storage); + ntype, "NodeGeometryProximity", node_free_standard_storage, node_copy_standard_storage); ntype.declare = node_declare; ntype.geometry_node_execute = node_geo_exec; ntype.draw_buttons = node_layout; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); node_rna(ntype.rna_ext.srna); } diff --git a/source/blender/nodes/geometry/nodes/node_geo_raycast.cc b/source/blender/nodes/geometry/nodes/node_geo_raycast.cc index fb252f6540f..eb17b4739b2 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_raycast.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_raycast.cc @@ -310,15 +310,15 @@ static void node_register() "each hit point"; ntype.enum_name_legacy = "RAYCAST"; ntype.nclass = NODE_CLASS_GEOMETRY; - bke::node_type_size_preset(&ntype, bke::eNodeSizePreset::Middle); + bke::node_type_size_preset(ntype, bke::eNodeSizePreset::Middle); ntype.initfunc = node_init; blender::bke::node_type_storage( - &ntype, "NodeGeometryRaycast", node_free_standard_storage, node_copy_standard_storage); + ntype, "NodeGeometryRaycast", node_free_standard_storage, node_copy_standard_storage); ntype.declare = node_declare; ntype.geometry_node_execute = node_geo_exec; ntype.draw_buttons = node_layout; ntype.gather_link_search_ops = node_gather_link_searches; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); node_rna(ntype.rna_ext.srna); } diff --git a/source/blender/nodes/geometry/nodes/node_geo_realize_instances.cc b/source/blender/nodes/geometry/nodes/node_geo_realize_instances.cc index 1cec087eef6..8b2d124e601 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_realize_instances.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_realize_instances.cc @@ -95,7 +95,7 @@ static void node_register() ntype.nclass = NODE_CLASS_GEOMETRY; ntype.declare = node_declare; ntype.geometry_node_execute = node_geo_exec; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } NOD_REGISTER_NODE(node_register) diff --git a/source/blender/nodes/geometry/nodes/node_geo_remove_attribute.cc b/source/blender/nodes/geometry/nodes/node_geo_remove_attribute.cc index 83a5e26bc69..f0b8456c88a 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_remove_attribute.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_remove_attribute.cc @@ -180,9 +180,9 @@ static void node_register() ntype.nclass = NODE_CLASS_ATTRIBUTE; ntype.declare = node_declare; ntype.draw_buttons = node_layout; - bke::node_type_size(&ntype, 170, 100, 700); + bke::node_type_size(ntype, 170, 100, 700); ntype.geometry_node_execute = node_geo_exec; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); node_rna(ntype.rna_ext.srna); } diff --git a/source/blender/nodes/geometry/nodes/node_geo_repeat.cc b/source/blender/nodes/geometry/nodes/node_geo_repeat.cc index 5f92557b463..6b50fc9dc57 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_repeat.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_repeat.cc @@ -141,8 +141,8 @@ static void node_register() ntype.no_muting = true; ntype.draw_buttons_ex = node_layout_ex; blender::bke::node_type_storage( - &ntype, "NodeGeometryRepeatInput", node_free_standard_storage, node_copy_standard_storage); - blender::bke::node_register_type(&ntype); + ntype, "NodeGeometryRepeatInput", node_free_standard_storage, node_copy_standard_storage); + blender::bke::node_register_type(ntype); } NOD_REGISTER_NODE(node_register) @@ -235,8 +235,8 @@ static void node_register() ntype.draw_buttons_ex = node_layout_ex; ntype.register_operators = node_operators; blender::bke::node_type_storage( - &ntype, "NodeGeometryRepeatOutput", node_free_storage, node_copy_storage); - blender::bke::node_register_type(&ntype); + ntype, "NodeGeometryRepeatOutput", node_free_storage, node_copy_storage); + blender::bke::node_register_type(ntype); } NOD_REGISTER_NODE(node_register) diff --git a/source/blender/nodes/geometry/nodes/node_geo_rotate_instances.cc b/source/blender/nodes/geometry/nodes/node_geo_rotate_instances.cc index 111da00d737..a19fa934c7c 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_rotate_instances.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_rotate_instances.cc @@ -100,7 +100,7 @@ static void node_register() ntype.nclass = NODE_CLASS_GEOMETRY; ntype.geometry_node_execute = node_geo_exec; ntype.declare = node_declare; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } NOD_REGISTER_NODE(node_register) diff --git a/source/blender/nodes/geometry/nodes/node_geo_sample_grid.cc b/source/blender/nodes/geometry/nodes/node_geo_sample_grid.cc index b1aa2532f02..393dd05558e 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_sample_grid.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_sample_grid.cc @@ -294,7 +294,7 @@ static void node_register() ntype.geometry_node_execute = node_geo_exec; ntype.draw_buttons = node_layout; ntype.geometry_node_execute = node_geo_exec; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); node_rna(ntype.rna_ext.srna); } diff --git a/source/blender/nodes/geometry/nodes/node_geo_sample_grid_index.cc b/source/blender/nodes/geometry/nodes/node_geo_sample_grid_index.cc index 534799bacaa..f34df16e74c 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_sample_grid_index.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_sample_grid_index.cc @@ -253,7 +253,7 @@ static void node_register() ntype.geometry_node_execute = node_geo_exec; ntype.draw_buttons = node_layout; ntype.geometry_node_execute = node_geo_exec; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); node_rna(ntype.rna_ext.srna); } diff --git a/source/blender/nodes/geometry/nodes/node_geo_sample_index.cc b/source/blender/nodes/geometry/nodes/node_geo_sample_index.cc index 1be77a273ba..8a3867f4dae 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_sample_index.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_sample_index.cc @@ -252,11 +252,11 @@ static void node_register() ntype.initfunc = node_init; ntype.declare = node_declare; blender::bke::node_type_storage( - &ntype, "NodeGeometrySampleIndex", node_free_standard_storage, node_copy_standard_storage); + ntype, "NodeGeometrySampleIndex", node_free_standard_storage, node_copy_standard_storage); ntype.geometry_node_execute = node_geo_exec; ntype.draw_buttons = node_layout; ntype.gather_link_search_ops = node_gather_link_searches; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } NOD_REGISTER_NODE(node_register) diff --git a/source/blender/nodes/geometry/nodes/node_geo_sample_nearest.cc b/source/blender/nodes/geometry/nodes/node_geo_sample_nearest.cc index 074e9e37f29..079ca2ed093 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_sample_nearest.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_sample_nearest.cc @@ -342,7 +342,7 @@ static void node_register() ntype.declare = node_declare; ntype.geometry_node_execute = node_geo_exec; ntype.draw_buttons = node_layout; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); node_rna(ntype.rna_ext.srna); } diff --git a/source/blender/nodes/geometry/nodes/node_geo_sample_nearest_surface.cc b/source/blender/nodes/geometry/nodes/node_geo_sample_nearest_surface.cc index be49f8a3434..03786463d3e 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_sample_nearest_surface.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_sample_nearest_surface.cc @@ -242,11 +242,11 @@ static void node_register() ntype.nclass = NODE_CLASS_GEOMETRY; ntype.initfunc = node_init; ntype.declare = node_declare; - blender::bke::node_type_size_preset(&ntype, blender::bke::eNodeSizePreset::Middle); + blender::bke::node_type_size_preset(ntype, blender::bke::eNodeSizePreset::Middle); ntype.geometry_node_execute = node_geo_exec; ntype.draw_buttons = node_layout; ntype.gather_link_search_ops = node_gather_link_searches; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); node_rna(ntype.rna_ext.srna); } diff --git a/source/blender/nodes/geometry/nodes/node_geo_sample_uv_surface.cc b/source/blender/nodes/geometry/nodes/node_geo_sample_uv_surface.cc index 2f673ff5cc8..665d57dba9e 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_sample_uv_surface.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_sample_uv_surface.cc @@ -207,7 +207,7 @@ static void node_register() ntype.geometry_node_execute = node_geo_exec; ntype.draw_buttons = node_layout; ntype.gather_link_search_ops = node_gather_link_searches; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); node_rna(ntype.rna_ext.srna); } diff --git a/source/blender/nodes/geometry/nodes/node_geo_scale_elements.cc b/source/blender/nodes/geometry/nodes/node_geo_scale_elements.cc index cd0d804b7d9..8f3d7563ad6 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_scale_elements.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_scale_elements.cc @@ -572,7 +572,7 @@ static void node_register() ntype.declare = node_declare; ntype.draw_buttons = node_layout; ntype.initfunc = node_init; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); node_rna(ntype.rna_ext.srna); } diff --git a/source/blender/nodes/geometry/nodes/node_geo_scale_instances.cc b/source/blender/nodes/geometry/nodes/node_geo_scale_instances.cc index c8ff98e5839..cecded153c1 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_scale_instances.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_scale_instances.cc @@ -79,7 +79,7 @@ static void node_register() ntype.nclass = NODE_CLASS_GEOMETRY; ntype.geometry_node_execute = node_geo_exec; ntype.declare = node_declare; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } NOD_REGISTER_NODE(node_register) diff --git a/source/blender/nodes/geometry/nodes/node_geo_sdf_grid_boolean.cc b/source/blender/nodes/geometry/nodes/node_geo_sdf_grid_boolean.cc index 1cb2fe7f544..108585ef74a 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_sdf_grid_boolean.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_sdf_grid_boolean.cc @@ -188,7 +188,7 @@ static void node_register() ntype.draw_buttons = node_layout; ntype.geometry_node_execute = node_geo_exec; ntype.gather_link_search_ops = search_link_ops_for_volume_grid_node; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); node_rna(ntype.rna_ext.srna); } NOD_REGISTER_NODE(node_register) diff --git a/source/blender/nodes/geometry/nodes/node_geo_self_object.cc b/source/blender/nodes/geometry/nodes/node_geo_self_object.cc index 2de1be3a38f..49c57d26af1 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_self_object.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_self_object.cc @@ -28,7 +28,7 @@ static void node_register() ntype.nclass = NODE_CLASS_INPUT; ntype.geometry_node_execute = node_geo_exec; ntype.declare = node_declare; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } NOD_REGISTER_NODE(node_register) diff --git a/source/blender/nodes/geometry/nodes/node_geo_separate_components.cc b/source/blender/nodes/geometry/nodes/node_geo_separate_components.cc index 57398c20877..7a16e2d7e58 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_separate_components.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_separate_components.cc @@ -77,7 +77,7 @@ static void node_register() ntype.nclass = NODE_CLASS_GEOMETRY; ntype.declare = node_declare; ntype.geometry_node_execute = node_geo_exec; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } NOD_REGISTER_NODE(node_register) diff --git a/source/blender/nodes/geometry/nodes/node_geo_separate_geometry.cc b/source/blender/nodes/geometry/nodes/node_geo_separate_geometry.cc index b8d6e4cdce1..e825ed4ead6 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_separate_geometry.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_separate_geometry.cc @@ -113,7 +113,7 @@ static void node_register() ntype.ui_description = "Split a geometry into two geometry outputs based on a selection"; ntype.enum_name_legacy = "SEPARATE_GEOMETRY"; ntype.nclass = NODE_CLASS_GEOMETRY; - blender::bke::node_type_storage(&ntype, + blender::bke::node_type_storage(ntype, "NodeGeometrySeparateGeometry", node_free_standard_storage, node_copy_standard_storage); @@ -123,7 +123,7 @@ static void node_register() ntype.declare = node_declare; ntype.geometry_node_execute = node_geo_exec; ntype.draw_buttons = node_layout; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); node_rna(ntype.rna_ext.srna); } diff --git a/source/blender/nodes/geometry/nodes/node_geo_set_curve_handles.cc b/source/blender/nodes/geometry/nodes/node_geo_set_curve_handles.cc index 204d992f77d..03b45b8cb8f 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_set_curve_handles.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_set_curve_handles.cc @@ -210,12 +210,12 @@ static void node_register() ntype.declare = node_declare; ntype.minwidth = 100.0f; ntype.initfunc = node_init; - blender::bke::node_type_storage(&ntype, + blender::bke::node_type_storage(ntype, "NodeGeometrySetCurveHandlePositions", node_free_standard_storage, node_copy_standard_storage); ntype.draw_buttons = node_layout; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); node_rna(ntype.rna_ext.srna); } diff --git a/source/blender/nodes/geometry/nodes/node_geo_set_curve_normal.cc b/source/blender/nodes/geometry/nodes/node_geo_set_curve_normal.cc index 636cb0d0255..3e4262d8671 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_set_curve_normal.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_set_curve_normal.cc @@ -146,7 +146,7 @@ static void node_register() ntype.initfunc = node_init; ntype.draw_buttons = node_layout; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); node_rna(ntype.rna_ext.srna); } diff --git a/source/blender/nodes/geometry/nodes/node_geo_set_curve_radius.cc b/source/blender/nodes/geometry/nodes/node_geo_set_curve_radius.cc index 67c9ce90333..2fc12fdbbfa 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_set_curve_radius.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_set_curve_radius.cc @@ -77,7 +77,7 @@ static void node_register() ntype.nclass = NODE_CLASS_GEOMETRY; ntype.geometry_node_execute = node_geo_exec; ntype.declare = node_declare; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } NOD_REGISTER_NODE(node_register) diff --git a/source/blender/nodes/geometry/nodes/node_geo_set_curve_tilt.cc b/source/blender/nodes/geometry/nodes/node_geo_set_curve_tilt.cc index 39c3626e750..42a304362b9 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_set_curve_tilt.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_set_curve_tilt.cc @@ -80,7 +80,7 @@ static void node_register() ntype.nclass = NODE_CLASS_GEOMETRY; ntype.geometry_node_execute = node_geo_exec; ntype.declare = node_declare; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } NOD_REGISTER_NODE(node_register) diff --git a/source/blender/nodes/geometry/nodes/node_geo_set_geometry_name.cc b/source/blender/nodes/geometry/nodes/node_geo_set_geometry_name.cc index 4b41055fa85..2e1a4fb09c3 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_set_geometry_name.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_set_geometry_name.cc @@ -32,7 +32,7 @@ static void node_register() ntype.nclass = NODE_CLASS_GEOMETRY; ntype.geometry_node_execute = node_geo_exec; ntype.declare = node_declare; - bke::node_register_type(&ntype); + bke::node_register_type(ntype); } NOD_REGISTER_NODE(node_register) diff --git a/source/blender/nodes/geometry/nodes/node_geo_set_id.cc b/source/blender/nodes/geometry/nodes/node_geo_set_id.cc index 40a5d5d80f6..a27f7d77ac0 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_set_id.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_set_id.cc @@ -83,7 +83,7 @@ static void node_register() ntype.nclass = NODE_CLASS_GEOMETRY; ntype.geometry_node_execute = node_geo_exec; ntype.declare = node_declare; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } NOD_REGISTER_NODE(node_register) diff --git a/source/blender/nodes/geometry/nodes/node_geo_set_instance_transform.cc b/source/blender/nodes/geometry/nodes/node_geo_set_instance_transform.cc index a06c436e81d..e41b4ed47bb 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_set_instance_transform.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_set_instance_transform.cc @@ -42,8 +42,8 @@ static void node_register() ntype.nclass = NODE_CLASS_GEOMETRY; ntype.geometry_node_execute = node_geo_exec; ntype.declare = node_declare; - bke::node_type_size(&ntype, 160, 100, 700); - node_register_type(&ntype); + bke::node_type_size(ntype, 160, 100, 700); + node_register_type(ntype); } NOD_REGISTER_NODE(node_register) diff --git a/source/blender/nodes/geometry/nodes/node_geo_set_material.cc b/source/blender/nodes/geometry/nodes/node_geo_set_material.cc index 59cbe1d66f9..d75184d7bd3 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_set_material.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_set_material.cc @@ -169,7 +169,7 @@ static void node_register() ntype.nclass = NODE_CLASS_GEOMETRY; ntype.declare = node_declare; ntype.geometry_node_execute = node_geo_exec; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } NOD_REGISTER_NODE(node_register) diff --git a/source/blender/nodes/geometry/nodes/node_geo_set_material_index.cc b/source/blender/nodes/geometry/nodes/node_geo_set_material_index.cc index 6c39e222681..970c1ec2ad6 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_set_material_index.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_set_material_index.cc @@ -74,7 +74,7 @@ static void node_register() ntype.nclass = NODE_CLASS_GEOMETRY; ntype.geometry_node_execute = node_geo_exec; ntype.declare = node_declare; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } NOD_REGISTER_NODE(node_register) diff --git a/source/blender/nodes/geometry/nodes/node_geo_set_point_radius.cc b/source/blender/nodes/geometry/nodes/node_geo_set_point_radius.cc index deca7267cd9..11933f9a6cb 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_set_point_radius.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_set_point_radius.cc @@ -51,7 +51,7 @@ static void node_register() ntype.nclass = NODE_CLASS_GEOMETRY; ntype.geometry_node_execute = node_geo_exec; ntype.declare = node_declare; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } NOD_REGISTER_NODE(node_register) diff --git a/source/blender/nodes/geometry/nodes/node_geo_set_position.cc b/source/blender/nodes/geometry/nodes/node_geo_set_position.cc index b1a4364d91e..2a8fab432ca 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_set_position.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_set_position.cc @@ -172,7 +172,7 @@ static void node_register() ntype.nclass = NODE_CLASS_GEOMETRY; ntype.geometry_node_execute = node_geo_exec; ntype.declare = node_declare; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } NOD_REGISTER_NODE(node_register) diff --git a/source/blender/nodes/geometry/nodes/node_geo_set_shade_smooth.cc b/source/blender/nodes/geometry/nodes/node_geo_set_shade_smooth.cc index 900c0498f20..a9ce374ae98 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_set_shade_smooth.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_set_shade_smooth.cc @@ -121,7 +121,7 @@ static void node_register() ntype.declare = node_declare; ntype.initfunc = node_init; ntype.draw_buttons = node_layout; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); node_rna(ntype.rna_ext.srna); } diff --git a/source/blender/nodes/geometry/nodes/node_geo_set_spline_cyclic.cc b/source/blender/nodes/geometry/nodes/node_geo_set_spline_cyclic.cc index de223f7d261..6710c6790c3 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_set_spline_cyclic.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_set_spline_cyclic.cc @@ -81,7 +81,7 @@ static void node_register() ntype.nclass = NODE_CLASS_GEOMETRY; ntype.geometry_node_execute = node_geo_exec; ntype.declare = node_declare; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } NOD_REGISTER_NODE(node_register) diff --git a/source/blender/nodes/geometry/nodes/node_geo_set_spline_resolution.cc b/source/blender/nodes/geometry/nodes/node_geo_set_spline_resolution.cc index 0ba58d9a03b..bf6509013a3 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_set_spline_resolution.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_set_spline_resolution.cc @@ -81,7 +81,7 @@ static void node_register() ntype.nclass = NODE_CLASS_GEOMETRY; ntype.geometry_node_execute = node_geo_exec; ntype.declare = node_declare; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } NOD_REGISTER_NODE(node_register) diff --git a/source/blender/nodes/geometry/nodes/node_geo_simulation.cc b/source/blender/nodes/geometry/nodes/node_geo_simulation.cc index 817b59b07ec..7dde30cc198 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_simulation.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_simulation.cc @@ -485,11 +485,11 @@ static void node_register() ntype.gather_link_search_ops = nullptr; ntype.no_muting = true; ntype.draw_buttons_ex = node_layout_ex; - blender::bke::node_type_storage(&ntype, + blender::bke::node_type_storage(ntype, "NodeGeometrySimulationInput", node_free_standard_storage, node_copy_standard_storage); - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } NOD_REGISTER_NODE(node_register) @@ -866,8 +866,8 @@ static void node_register() ntype.register_operators = node_operators; ntype.get_extra_info = node_extra_info; blender::bke::node_type_storage( - &ntype, "NodeGeometrySimulationOutput", node_free_storage, node_copy_storage); - blender::bke::node_register_type(&ntype); + ntype, "NodeGeometrySimulationOutput", node_free_storage, node_copy_storage); + blender::bke::node_register_type(ntype); } NOD_REGISTER_NODE(node_register) diff --git a/source/blender/nodes/geometry/nodes/node_geo_sort_elements.cc b/source/blender/nodes/geometry/nodes/node_geo_sort_elements.cc index f161f5849ea..e239ce28c52 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_sort_elements.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_sort_elements.cc @@ -304,7 +304,7 @@ static void node_register() ntype.initfunc = node_init; ntype.geometry_node_execute = node_geo_exec; ntype.draw_buttons = node_layout; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); node_rna(ntype.rna_ext.srna); } diff --git a/source/blender/nodes/geometry/nodes/node_geo_split_to_instances.cc b/source/blender/nodes/geometry/nodes/node_geo_split_to_instances.cc index 93957da38ca..08e16704486 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_split_to_instances.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_split_to_instances.cc @@ -362,7 +362,7 @@ static void node_register() ntype.geometry_node_execute = node_geo_exec; ntype.declare = node_declare; ntype.draw_buttons = node_layout; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); node_rna(ntype.rna_ext.srna); } diff --git a/source/blender/nodes/geometry/nodes/node_geo_store_named_attribute.cc b/source/blender/nodes/geometry/nodes/node_geo_store_named_attribute.cc index 5bada1bc44f..fe2667470db 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_store_named_attribute.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_store_named_attribute.cc @@ -214,17 +214,17 @@ static void node_register() "Store the result of a field on a geometry as an attribute with the specified name"; ntype.enum_name_legacy = "STORE_NAMED_ATTRIBUTE"; ntype.nclass = NODE_CLASS_ATTRIBUTE; - blender::bke::node_type_storage(&ntype, + blender::bke::node_type_storage(ntype, "NodeGeometryStoreNamedAttribute", node_free_standard_storage, node_copy_standard_storage); - blender::bke::node_type_size(&ntype, 140, 100, 700); + blender::bke::node_type_size(ntype, 140, 100, 700); ntype.initfunc = node_init; ntype.declare = node_declare; ntype.gather_link_search_ops = node_gather_link_searches; ntype.geometry_node_execute = node_geo_exec; ntype.draw_buttons = node_layout; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); node_rna(ntype.rna_ext.srna); } diff --git a/source/blender/nodes/geometry/nodes/node_geo_store_named_grid.cc b/source/blender/nodes/geometry/nodes/node_geo_store_named_grid.cc index 594bf6d0690..ca69fb25db7 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_store_named_grid.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_store_named_grid.cc @@ -144,7 +144,7 @@ static void node_register() ntype.draw_buttons = node_layout; ntype.initfunc = node_init; ntype.geometry_node_execute = node_geo_exec; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); node_rna(ntype.rna_ext.srna); } diff --git a/source/blender/nodes/geometry/nodes/node_geo_string_join.cc b/source/blender/nodes/geometry/nodes/node_geo_string_join.cc index cb330506270..7d7378549d9 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_string_join.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_string_join.cc @@ -39,7 +39,7 @@ static void node_register() ntype.nclass = NODE_CLASS_CONVERTER; ntype.geometry_node_execute = node_geo_exec; ntype.declare = node_declare; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } NOD_REGISTER_NODE(node_register) diff --git a/source/blender/nodes/geometry/nodes/node_geo_string_to_curves.cc b/source/blender/nodes/geometry/nodes/node_geo_string_to_curves.cc index a08493fa85b..b77d3235d4f 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_string_to_curves.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_string_to_curves.cc @@ -388,13 +388,11 @@ static void node_register() ntype.declare = node_declare; ntype.geometry_node_execute = node_geo_exec; ntype.initfunc = node_init; - blender::bke::node_type_size(&ntype, 190, 120, 700); - blender::bke::node_type_storage(&ntype, - "NodeGeometryStringToCurves", - node_free_standard_storage, - node_copy_standard_storage); + blender::bke::node_type_size(ntype, 190, 120, 700); + blender::bke::node_type_storage( + ntype, "NodeGeometryStringToCurves", node_free_standard_storage, node_copy_standard_storage); ntype.draw_buttons = node_layout; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } NOD_REGISTER_NODE(node_register) diff --git a/source/blender/nodes/geometry/nodes/node_geo_subdivision_surface.cc b/source/blender/nodes/geometry/nodes/node_geo_subdivision_surface.cc index 785ce3d43f1..65070d3763e 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_subdivision_surface.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_subdivision_surface.cc @@ -241,12 +241,12 @@ static void node_register() ntype.geometry_node_execute = node_geo_exec; ntype.draw_buttons = node_layout; ntype.initfunc = node_init; - bke::node_type_size_preset(&ntype, bke::eNodeSizePreset::Middle); - blender::bke::node_type_storage(&ntype, + bke::node_type_size_preset(ntype, bke::eNodeSizePreset::Middle); + blender::bke::node_type_storage(ntype, "NodeGeometrySubdivisionSurface", node_free_standard_storage, node_copy_standard_storage); - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); node_rna(ntype.rna_ext.srna); } diff --git a/source/blender/nodes/geometry/nodes/node_geo_switch.cc b/source/blender/nodes/geometry/nodes/node_geo_switch.cc index d20cc9a846b..b508efafcd4 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_switch.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_switch.cc @@ -256,10 +256,10 @@ static void register_node() ntype.declare = node_declare; ntype.initfunc = node_init; blender::bke::node_type_storage( - &ntype, "NodeSwitch", node_free_standard_storage, node_copy_standard_storage); + ntype, "NodeSwitch", node_free_standard_storage, node_copy_standard_storage); ntype.gather_link_search_ops = node_gather_link_searches; ntype.draw_buttons = node_layout; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); node_rna(ntype.rna_ext.srna); } diff --git a/source/blender/nodes/geometry/nodes/node_geo_tool_3d_cursor.cc b/source/blender/nodes/geometry/nodes/node_geo_tool_3d_cursor.cc index 7c8ac13f171..9de6cbb7552 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_tool_3d_cursor.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_tool_3d_cursor.cc @@ -45,7 +45,7 @@ static void node_register() ntype.declare = node_declare; ntype.geometry_node_execute = node_geo_exec; ntype.gather_link_search_ops = search_link_ops_for_tool_node; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } NOD_REGISTER_NODE(node_register) diff --git a/source/blender/nodes/geometry/nodes/node_geo_tool_active_element.cc b/source/blender/nodes/geometry/nodes/node_geo_tool_active_element.cc index c143d2ed055..d1235063b87 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_tool_active_element.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_tool_active_element.cc @@ -91,7 +91,7 @@ static void node_register() ntype.declare = node_declare; ntype.gather_link_search_ops = search_link_ops_for_tool_node; ntype.draw_buttons = node_layout; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); node_rna(ntype.rna_ext.srna); } diff --git a/source/blender/nodes/geometry/nodes/node_geo_tool_face_set.cc b/source/blender/nodes/geometry/nodes/node_geo_tool_face_set.cc index fb663cef3b6..8eb09b807ca 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_tool_face_set.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_tool_face_set.cc @@ -34,7 +34,7 @@ static void node_register() ntype.declare = node_declare; ntype.geometry_node_execute = node_geo_exec; ntype.gather_link_search_ops = search_link_ops_for_tool_node; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } NOD_REGISTER_NODE(node_register) diff --git a/source/blender/nodes/geometry/nodes/node_geo_tool_selection.cc b/source/blender/nodes/geometry/nodes/node_geo_tool_selection.cc index 7698fd210ee..bb82da8c491 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_tool_selection.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_tool_selection.cc @@ -182,7 +182,7 @@ static void node_register() ntype.declare = node_declare; ntype.geometry_node_execute = node_geo_exec; ntype.gather_link_search_ops = search_link_ops_for_tool_node; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } NOD_REGISTER_NODE(node_register) diff --git a/source/blender/nodes/geometry/nodes/node_geo_tool_set_face_set.cc b/source/blender/nodes/geometry/nodes/node_geo_tool_set_face_set.cc index ee593c39222..70418dc11ad 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_tool_set_face_set.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_tool_set_face_set.cc @@ -62,7 +62,7 @@ static void node_register() ntype.declare = node_declare; ntype.geometry_node_execute = node_geo_exec; ntype.gather_link_search_ops = search_link_ops_for_tool_node; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } NOD_REGISTER_NODE(node_register) diff --git a/source/blender/nodes/geometry/nodes/node_geo_tool_set_selection.cc b/source/blender/nodes/geometry/nodes/node_geo_tool_set_selection.cc index 27e6075d7d1..08ecad57d40 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_tool_set_selection.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_tool_set_selection.cc @@ -213,7 +213,7 @@ static void node_register() ntype.geometry_node_execute = node_geo_exec; ntype.draw_buttons = node_layout; ntype.gather_link_search_ops = search_link_ops_for_tool_node; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); node_rna(ntype.rna_ext.srna); } diff --git a/source/blender/nodes/geometry/nodes/node_geo_transform_geometry.cc b/source/blender/nodes/geometry/nodes/node_geo_transform_geometry.cc index 06495ead3f0..0cd7a12f232 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_transform_geometry.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_transform_geometry.cc @@ -135,7 +135,7 @@ static void register_node() ntype.declare = node_declare; ntype.geometry_node_execute = node_geo_exec; ntype.draw_buttons = node_layout; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); node_rna(ntype.rna_ext.srna); } diff --git a/source/blender/nodes/geometry/nodes/node_geo_translate_instances.cc b/source/blender/nodes/geometry/nodes/node_geo_translate_instances.cc index 6f057d6bbb5..41e32dce254 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_translate_instances.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_translate_instances.cc @@ -66,7 +66,7 @@ static void register_node() ntype.nclass = NODE_CLASS_GEOMETRY; ntype.geometry_node_execute = node_geo_exec; ntype.declare = node_declare; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } NOD_REGISTER_NODE(register_node) diff --git a/source/blender/nodes/geometry/nodes/node_geo_triangulate.cc b/source/blender/nodes/geometry/nodes/node_geo_triangulate.cc index 97d8aa82262..5cb4407dbee 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_triangulate.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_triangulate.cc @@ -163,7 +163,7 @@ static void node_register() ntype.initfunc = geo_triangulate_init; ntype.geometry_node_execute = node_geo_exec; ntype.draw_buttons = node_layout; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); node_rna(ntype.rna_ext.srna); } diff --git a/source/blender/nodes/geometry/nodes/node_geo_uv_pack_islands.cc b/source/blender/nodes/geometry/nodes/node_geo_uv_pack_islands.cc index 907d5702c78..859a3eb9104 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_uv_pack_islands.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_uv_pack_islands.cc @@ -150,7 +150,7 @@ static void node_register() ntype.nclass = NODE_CLASS_CONVERTER; ntype.declare = node_declare; ntype.geometry_node_execute = node_geo_exec; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } NOD_REGISTER_NODE(node_register) diff --git a/source/blender/nodes/geometry/nodes/node_geo_uv_unwrap.cc b/source/blender/nodes/geometry/nodes/node_geo_uv_unwrap.cc index 642d69b0a04..0fd228c8aca 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_uv_unwrap.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_uv_unwrap.cc @@ -219,11 +219,11 @@ static void node_register() ntype.nclass = NODE_CLASS_CONVERTER; ntype.initfunc = node_init; blender::bke::node_type_storage( - &ntype, "NodeGeometryUVUnwrap", node_free_standard_storage, node_copy_standard_storage); + ntype, "NodeGeometryUVUnwrap", node_free_standard_storage, node_copy_standard_storage); ntype.declare = node_declare; ntype.geometry_node_execute = node_geo_exec; ntype.draw_buttons = node_layout; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); node_rna(ntype.rna_ext.srna); } diff --git a/source/blender/nodes/geometry/nodes/node_geo_viewer.cc b/source/blender/nodes/geometry/nodes/node_geo_viewer.cc index e3b239a60d3..87bb25ad20e 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_viewer.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_viewer.cc @@ -93,11 +93,11 @@ static void node_gather_link_searches(GatherLinkSearchOpParams ¶ms) /* If the source node has a geometry socket, connect it to the new viewer node as well. */ LISTBASE_FOREACH (bNodeSocket *, socket, ¶ms.node.outputs) { if (socket->type == SOCK_GEOMETRY && socket->is_visible()) { - bke::node_add_link(¶ms.node_tree, - ¶ms.node, - socket, - &node, - static_cast(node.inputs.first)); + bke::node_add_link(params.node_tree, + params.node, + *socket, + node, + *static_cast(node.inputs.first)); break; } } @@ -150,7 +150,7 @@ static void node_register() ntype.enum_name_legacy = "VIEWER"; ntype.nclass = NODE_CLASS_OUTPUT; blender::bke::node_type_storage( - &ntype, "NodeGeometryViewer", node_free_standard_storage, node_copy_standard_storage); + ntype, "NodeGeometryViewer", node_free_standard_storage, node_copy_standard_storage); ntype.declare = node_declare; ntype.initfunc = node_init; ntype.draw_buttons = node_layout; @@ -158,7 +158,7 @@ static void node_register() ntype.gather_link_search_ops = node_gather_link_searches; ntype.no_muting = true; ntype.get_extra_info = node_extra_info; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); node_rna(ntype.rna_ext.srna); } diff --git a/source/blender/nodes/geometry/nodes/node_geo_viewport_transform.cc b/source/blender/nodes/geometry/nodes/node_geo_viewport_transform.cc index 481622d682c..2e50cde0e46 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_viewport_transform.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_viewport_transform.cc @@ -43,7 +43,7 @@ static void node_register() ntype.declare = node_declare; ntype.geometry_node_execute = node_geo_exec; ntype.gather_link_search_ops = search_link_ops_for_tool_node; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } NOD_REGISTER_NODE(node_register) diff --git a/source/blender/nodes/geometry/nodes/node_geo_volume_cube.cc b/source/blender/nodes/geometry/nodes/node_geo_volume_cube.cc index 62b74a16cda..f985d52d706 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_volume_cube.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_volume_cube.cc @@ -191,7 +191,7 @@ static void node_register() ntype.nclass = NODE_CLASS_GEOMETRY; ntype.declare = node_declare; ntype.geometry_node_execute = node_geo_exec; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } NOD_REGISTER_NODE(node_register) diff --git a/source/blender/nodes/geometry/nodes/node_geo_volume_to_mesh.cc b/source/blender/nodes/geometry/nodes/node_geo_volume_to_mesh.cc index 217b0caa71f..94af3d30673 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_volume_to_mesh.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_volume_to_mesh.cc @@ -251,12 +251,12 @@ static void node_register() ntype.nclass = NODE_CLASS_GEOMETRY; ntype.declare = node_declare; blender::bke::node_type_storage( - &ntype, "NodeGeometryVolumeToMesh", node_free_standard_storage, node_copy_standard_storage); - blender::bke::node_type_size(&ntype, 170, 120, 700); + ntype, "NodeGeometryVolumeToMesh", node_free_standard_storage, node_copy_standard_storage); + blender::bke::node_type_size(ntype, 170, 120, 700); ntype.initfunc = node_init; ntype.geometry_node_execute = node_geo_exec; ntype.draw_buttons = node_layout; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); node_rna(ntype.rna_ext.srna); } diff --git a/source/blender/nodes/geometry/nodes/node_geo_warning.cc b/source/blender/nodes/geometry/nodes/node_geo_warning.cc index 96108a14cda..aea76601b7b 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_warning.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_warning.cc @@ -110,7 +110,7 @@ static void node_register() ntype.declare = node_declare; ntype.labelfunc = node_label; ntype.draw_buttons = node_layout; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); node_rna(ntype.rna_ext.srna); } diff --git a/source/blender/nodes/intern/node_common.cc b/source/blender/nodes/intern/node_common.cc index a45b862eb14..632c2b2cf81 100644 --- a/source/blender/nodes/intern/node_common.cc +++ b/source/blender/nodes/intern/node_common.cc @@ -511,7 +511,7 @@ void register_node_type_frame() blender::bke::bNodeType *ntype = MEM_new("frame node type"); ntype->free_self = [](blender::bke::bNodeType *type) { MEM_delete(type); }; - blender::bke::node_type_base(ntype, "NodeFrame", NODE_FRAME); + blender::bke::node_type_base(*ntype, "NodeFrame", NODE_FRAME); ntype->ui_name = "Frame"; ntype->ui_description = "Collect related nodes together in a common area. Useful for organization when the " @@ -520,11 +520,11 @@ void register_node_type_frame() ntype->enum_name_legacy = "FRAME"; ntype->initfunc = node_frame_init; blender::bke::node_type_storage( - ntype, "NodeFrame", node_free_standard_storage, node_copy_standard_storage); - blender::bke::node_type_size(ntype, 150, 100, 0); + *ntype, "NodeFrame", node_free_standard_storage, node_copy_standard_storage); + blender::bke::node_type_size(*ntype, 150, 100, 0); ntype->flag |= NODE_BACKGROUND; - blender::bke::node_register_type(ntype); + blender::bke::node_register_type(*ntype); } /** \} */ @@ -559,7 +559,7 @@ void register_node_type_reroute() blender::bke::bNodeType *ntype = MEM_new("frame node type"); ntype->free_self = [](blender::bke::bNodeType *type) { MEM_delete(type); }; - blender::bke::node_type_base(ntype, "NodeReroute", NODE_REROUTE); + blender::bke::node_type_base(*ntype, "NodeReroute", NODE_REROUTE); ntype->ui_name = "Reroute"; ntype->ui_description = "A single-socket organization tool that supports one input and multiple outputs"; @@ -567,9 +567,9 @@ void register_node_type_reroute() ntype->nclass = NODE_CLASS_LAYOUT; ntype->declare = node_reroute_declare; ntype->initfunc = node_reroute_init; - node_type_storage(ntype, "NodeReroute", node_free_standard_storage, node_copy_standard_storage); + node_type_storage(*ntype, "NodeReroute", node_free_standard_storage, node_copy_standard_storage); - blender::bke::node_register_type(ntype); + blender::bke::node_register_type(*ntype); } struct RerouteTargetPriority { @@ -703,11 +703,11 @@ void ntree_update_reroute_nodes(bNodeTree *ntree) } } -bool blender::bke::node_is_connected_to_output(const bNodeTree *ntree, const bNode *node) +bool blender::bke::node_is_connected_to_output(const bNodeTree &ntree, const bNode &node) { - ntree->ensure_topology_cache(); + ntree.ensure_topology_cache(); Stack nodes_to_check; - for (const bNodeSocket *socket : node->output_sockets()) { + for (const bNodeSocket *socket : node.output_sockets()) { for (const bNodeLink *link : socket->directly_linked_links()) { nodes_to_check.push(link->tonode); } @@ -841,17 +841,17 @@ void register_node_type_group_input() blender::bke::bNodeType *ntype = MEM_new("node type"); ntype->free_self = [](blender::bke::bNodeType *type) { MEM_delete(type); }; - blender::bke::node_type_base(ntype, "NodeGroupInput", NODE_GROUP_INPUT); + blender::bke::node_type_base(*ntype, "NodeGroupInput", NODE_GROUP_INPUT); ntype->ui_name = "Group Input"; ntype->ui_description = "Expose connected data from inside a node group as inputs to its interface"; ntype->enum_name_legacy = "GROUP_INPUT"; ntype->nclass = NODE_CLASS_INTERFACE; - blender::bke::node_type_size(ntype, 140, 80, 400); + blender::bke::node_type_size(*ntype, 140, 80, 400); ntype->declare = blender::nodes::group_input_declare; ntype->insert_link = blender::nodes::group_input_insert_link; - blender::bke::node_register_type(ntype); + blender::bke::node_register_type(*ntype); } bNodeSocket *node_group_output_find_socket(bNode *node, const StringRef identifier) @@ -870,18 +870,18 @@ void register_node_type_group_output() blender::bke::bNodeType *ntype = MEM_new("node type"); ntype->free_self = [](blender::bke::bNodeType *type) { MEM_delete(type); }; - blender::bke::node_type_base(ntype, "NodeGroupOutput", NODE_GROUP_OUTPUT); + blender::bke::node_type_base(*ntype, "NodeGroupOutput", NODE_GROUP_OUTPUT); ntype->ui_name = "Group Output"; ntype->ui_description = "Output data from inside of a node group"; ntype->enum_name_legacy = "GROUP_OUTPUT"; ntype->nclass = NODE_CLASS_INTERFACE; - blender::bke::node_type_size(ntype, 140, 80, 400); + blender::bke::node_type_size(*ntype, 140, 80, 400); ntype->declare = blender::nodes::group_output_declare; ntype->insert_link = blender::nodes::group_output_insert_link; ntype->no_muting = true; - blender::bke::node_register_type(ntype); + blender::bke::node_register_type(*ntype); } /** \} */ diff --git a/source/blender/nodes/intern/node_register.cc b/source/blender/nodes/intern/node_register.cc index 46c85dba621..2f0b01202eb 100644 --- a/source/blender/nodes/intern/node_register.cc +++ b/source/blender/nodes/intern/node_register.cc @@ -34,7 +34,7 @@ static void register_undefined_types() blender::bke::NodeTreeTypeUndefined.ui_description = N_("Undefined Node Tree Type"); blender::bke::node_type_base_custom( - &blender::bke::NodeTypeUndefined, "NodeUndefined", "Undefined", "UNDEFINED", 0); + blender::bke::NodeTypeUndefined, "NodeUndefined", "Undefined", "UNDEFINED", 0); blender::bke::NodeTypeUndefined.poll = node_undefined_poll; blender::bke::NodeSocketTypeUndefined.idname = "NodeSocketUndefined"; diff --git a/source/blender/nodes/intern/node_socket.cc b/source/blender/nodes/intern/node_socket.cc index 8dc8a5c831b..a64eb301259 100644 --- a/source/blender/nodes/intern/node_socket.cc +++ b/source/blender/nodes/intern/node_socket.cc @@ -47,7 +47,7 @@ bNodeSocket *node_add_socket_from_template(bNodeTree *ntree, eNodeSocketInOut in_out) { bNodeSocket *sock = bke::node_add_static_socket( - ntree, node, in_out, stemp->type, stemp->subtype, stemp->identifier, stemp->name); + *ntree, *node, in_out, stemp->type, stemp->subtype, stemp->identifier, stemp->name); sock->flag |= stemp->flag; @@ -138,7 +138,7 @@ static void verify_socket_template_list(bNodeTree *ntree, if (stemp_first == nullptr) { for (sock = (bNodeSocket *)socklist->first; sock; sock = nextsock) { nextsock = sock->next; - bke::node_remove_socket(ntree, node, sock); + bke::node_remove_socket(*ntree, *node, *sock); } } else { @@ -151,7 +151,7 @@ static void verify_socket_template_list(bNodeTree *ntree, /* leftovers are removed */ for (sock = (bNodeSocket *)socklist->first; sock; sock = nextsock) { nextsock = sock->next; - bke::node_remove_socket(ntree, node, sock); + bke::node_remove_socket(*ntree, *node, *sock); } /* and we put back the verified sockets */ @@ -470,12 +470,12 @@ static void refresh_node_sockets_and_panels(bNodeTree &ntree, /* Destroy any remaining sockets that are no longer in the declaration. */ LISTBASE_FOREACH_MUTABLE (bNodeSocket *, old_socket, &node.inputs) { if (!new_inputs.contains(old_socket)) { - blender::bke::node_remove_socket_ex(&ntree, &node, old_socket, do_id_user); + blender::bke::node_remove_socket_ex(ntree, node, *old_socket, do_id_user); } } LISTBASE_FOREACH_MUTABLE (bNodeSocket *, old_socket, &node.outputs) { if (!new_outputs.contains(old_socket)) { - blender::bke::node_remove_socket_ex(&ntree, &node, old_socket, do_id_user); + blender::bke::node_remove_socket_ex(ntree, node, *old_socket, do_id_user); } } @@ -544,7 +544,7 @@ void node_verify_sockets(bNodeTree *ntree, bNode *node, bool do_id_user) return; } if (ntype->declare) { - blender::bke::node_declaration_ensure_on_outdated_node(ntree, node); + blender::bke::node_declaration_ensure_on_outdated_node(*ntree, *node); refresh_node(*ntree, *node, *node->runtime->declaration, do_id_user); return; } @@ -1153,55 +1153,55 @@ void register_standard_node_socket_types() { /* Draw callbacks are set in `drawnode.cc` to avoid bad-level calls. */ - bke::node_register_socket_type(make_socket_type_float(PROP_NONE)); - bke::node_register_socket_type(make_socket_type_float(PROP_UNSIGNED)); - bke::node_register_socket_type(make_socket_type_float(PROP_PERCENTAGE)); - bke::node_register_socket_type(make_socket_type_float(PROP_FACTOR)); - bke::node_register_socket_type(make_socket_type_float(PROP_ANGLE)); - bke::node_register_socket_type(make_socket_type_float(PROP_TIME)); - bke::node_register_socket_type(make_socket_type_float(PROP_TIME_ABSOLUTE)); - bke::node_register_socket_type(make_socket_type_float(PROP_DISTANCE)); - bke::node_register_socket_type(make_socket_type_float(PROP_WAVELENGTH)); - bke::node_register_socket_type(make_socket_type_float(PROP_COLOR_TEMPERATURE)); - bke::node_register_socket_type(make_socket_type_float(PROP_FREQUENCY)); + bke::node_register_socket_type(*make_socket_type_float(PROP_NONE)); + bke::node_register_socket_type(*make_socket_type_float(PROP_UNSIGNED)); + bke::node_register_socket_type(*make_socket_type_float(PROP_PERCENTAGE)); + bke::node_register_socket_type(*make_socket_type_float(PROP_FACTOR)); + bke::node_register_socket_type(*make_socket_type_float(PROP_ANGLE)); + bke::node_register_socket_type(*make_socket_type_float(PROP_TIME)); + bke::node_register_socket_type(*make_socket_type_float(PROP_TIME_ABSOLUTE)); + bke::node_register_socket_type(*make_socket_type_float(PROP_DISTANCE)); + bke::node_register_socket_type(*make_socket_type_float(PROP_WAVELENGTH)); + bke::node_register_socket_type(*make_socket_type_float(PROP_COLOR_TEMPERATURE)); + bke::node_register_socket_type(*make_socket_type_float(PROP_FREQUENCY)); - bke::node_register_socket_type(make_socket_type_int(PROP_NONE)); - bke::node_register_socket_type(make_socket_type_int(PROP_UNSIGNED)); - bke::node_register_socket_type(make_socket_type_int(PROP_PERCENTAGE)); - bke::node_register_socket_type(make_socket_type_int(PROP_FACTOR)); + bke::node_register_socket_type(*make_socket_type_int(PROP_NONE)); + bke::node_register_socket_type(*make_socket_type_int(PROP_UNSIGNED)); + bke::node_register_socket_type(*make_socket_type_int(PROP_PERCENTAGE)); + bke::node_register_socket_type(*make_socket_type_int(PROP_FACTOR)); - bke::node_register_socket_type(make_socket_type_bool()); - bke::node_register_socket_type(make_socket_type_rotation()); - bke::node_register_socket_type(make_socket_type_matrix()); + bke::node_register_socket_type(*make_socket_type_bool()); + bke::node_register_socket_type(*make_socket_type_rotation()); + bke::node_register_socket_type(*make_socket_type_matrix()); - bke::node_register_socket_type(make_socket_type_vector(PROP_NONE)); - bke::node_register_socket_type(make_socket_type_vector(PROP_TRANSLATION)); - bke::node_register_socket_type(make_socket_type_vector(PROP_DIRECTION)); - bke::node_register_socket_type(make_socket_type_vector(PROP_VELOCITY)); - bke::node_register_socket_type(make_socket_type_vector(PROP_ACCELERATION)); - bke::node_register_socket_type(make_socket_type_vector(PROP_EULER)); - bke::node_register_socket_type(make_socket_type_vector(PROP_XYZ)); + bke::node_register_socket_type(*make_socket_type_vector(PROP_NONE)); + bke::node_register_socket_type(*make_socket_type_vector(PROP_TRANSLATION)); + bke::node_register_socket_type(*make_socket_type_vector(PROP_DIRECTION)); + bke::node_register_socket_type(*make_socket_type_vector(PROP_VELOCITY)); + bke::node_register_socket_type(*make_socket_type_vector(PROP_ACCELERATION)); + bke::node_register_socket_type(*make_socket_type_vector(PROP_EULER)); + bke::node_register_socket_type(*make_socket_type_vector(PROP_XYZ)); - bke::node_register_socket_type(make_socket_type_rgba()); + bke::node_register_socket_type(*make_socket_type_rgba()); - bke::node_register_socket_type(make_socket_type_string(PROP_NONE)); - bke::node_register_socket_type(make_socket_type_string(PROP_FILEPATH)); + bke::node_register_socket_type(*make_socket_type_string(PROP_NONE)); + bke::node_register_socket_type(*make_socket_type_string(PROP_FILEPATH)); - bke::node_register_socket_type(make_socket_type_menu()); + bke::node_register_socket_type(*make_socket_type_menu()); - bke::node_register_socket_type(make_standard_socket_type(SOCK_SHADER, PROP_NONE)); + bke::node_register_socket_type(*make_standard_socket_type(SOCK_SHADER, PROP_NONE)); - bke::node_register_socket_type(make_socket_type_object()); + bke::node_register_socket_type(*make_socket_type_object()); - bke::node_register_socket_type(make_socket_type_geometry()); + bke::node_register_socket_type(*make_socket_type_geometry()); - bke::node_register_socket_type(make_socket_type_collection()); + bke::node_register_socket_type(*make_socket_type_collection()); - bke::node_register_socket_type(make_socket_type_texture()); + bke::node_register_socket_type(*make_socket_type_texture()); - bke::node_register_socket_type(make_socket_type_image()); + bke::node_register_socket_type(*make_socket_type_image()); - bke::node_register_socket_type(make_socket_type_material()); + bke::node_register_socket_type(*make_socket_type_material()); - bke::node_register_socket_type(make_socket_type_virtual()); + bke::node_register_socket_type(*make_socket_type_virtual()); } diff --git a/source/blender/nodes/intern/node_socket_declarations.cc b/source/blender/nodes/intern/node_socket_declarations.cc index f53ffe868c2..5f5d70291f2 100644 --- a/source/blender/nodes/intern/node_socket_declarations.cc +++ b/source/blender/nodes/intern/node_socket_declarations.cc @@ -74,8 +74,8 @@ static void modify_subtype_except_for_storage(bNodeSocket &socket, int new_subty bNodeSocket &Float::build(bNodeTree &ntree, bNode &node) const { - bNodeSocket &socket = *bke::node_add_static_socket(&ntree, - &node, + bNodeSocket &socket = *bke::node_add_static_socket(ntree, + node, this->in_out, SOCK_FLOAT, this->subtype, @@ -146,8 +146,8 @@ bNodeSocket &Float::update_or_build(bNodeTree &ntree, bNode &node, bNodeSocket & bNodeSocket &Int::build(bNodeTree &ntree, bNode &node) const { - bNodeSocket &socket = *bke::node_add_static_socket(&ntree, - &node, + bNodeSocket &socket = *bke::node_add_static_socket(ntree, + node, this->in_out, SOCK_INT, this->subtype, @@ -215,8 +215,8 @@ bNodeSocket &Int::update_or_build(bNodeTree &ntree, bNode &node, bNodeSocket &so bNodeSocket &Vector::build(bNodeTree &ntree, bNode &node) const { - bNodeSocket &socket = *bke::node_add_static_socket(&ntree, - &node, + bNodeSocket &socket = *bke::node_add_static_socket(ntree, + node, this->in_out, SOCK_VECTOR, this->subtype, @@ -288,8 +288,8 @@ bNodeSocket &Vector::update_or_build(bNodeTree &ntree, bNode &node, bNodeSocket bNodeSocket &Bool::build(bNodeTree &ntree, bNode &node) const { - bNodeSocket &socket = *bke::node_add_static_socket(&ntree, - &node, + bNodeSocket &socket = *bke::node_add_static_socket(ntree, + node, this->in_out, SOCK_BOOLEAN, PROP_NONE, @@ -338,8 +338,8 @@ bNodeSocket &Bool::update_or_build(bNodeTree &ntree, bNode &node, bNodeSocket &s bNodeSocket &Color::build(bNodeTree &ntree, bNode &node) const { - bNodeSocket &socket = *bke::node_add_static_socket(&ntree, - &node, + bNodeSocket &socket = *bke::node_add_static_socket(ntree, + node, this->in_out, SOCK_RGBA, PROP_NONE, @@ -387,8 +387,8 @@ bNodeSocket &Color::update_or_build(bNodeTree &ntree, bNode &node, bNodeSocket & bNodeSocket &Rotation::build(bNodeTree &ntree, bNode &node) const { - bNodeSocket &socket = *bke::node_add_static_socket(&ntree, - &node, + bNodeSocket &socket = *bke::node_add_static_socket(ntree, + node, this->in_out, SOCK_ROTATION, PROP_NONE, @@ -440,8 +440,8 @@ bNodeSocket &Rotation::update_or_build(bNodeTree &ntree, bNode &node, bNodeSocke bNodeSocket &Matrix::build(bNodeTree &ntree, bNode &node) const { - bNodeSocket &socket = *bke::node_add_static_socket(&ntree, - &node, + bNodeSocket &socket = *bke::node_add_static_socket(ntree, + node, this->in_out, SOCK_MATRIX, PROP_NONE, @@ -491,8 +491,8 @@ bNodeSocket &Matrix::update_or_build(bNodeTree &ntree, bNode &node, bNodeSocket bNodeSocket &String::build(bNodeTree &ntree, bNode &node) const { - bNodeSocket &socket = *bke::node_add_static_socket(&ntree, - &node, + bNodeSocket &socket = *bke::node_add_static_socket(ntree, + node, this->in_out, SOCK_STRING, this->subtype, @@ -545,8 +545,8 @@ bNodeSocket &String::update_or_build(bNodeTree &ntree, bNode &node, bNodeSocket bNodeSocket &Menu::build(bNodeTree &ntree, bNode &node) const { - bNodeSocket &socket = *bke::node_add_static_socket(&ntree, - &node, + bNodeSocket &socket = *bke::node_add_static_socket(ntree, + node, this->in_out, SOCK_MENU, PROP_NONE, @@ -593,7 +593,7 @@ bNodeSocket &Menu::update_or_build(bNodeTree &ntree, bNode &node, bNodeSocket &s bNodeSocket &IDSocketDeclaration::build(bNodeTree &ntree, bNode &node) const { bNodeSocket &socket = *bke::node_add_socket( - &ntree, &node, this->in_out, this->idname, this->identifier.c_str(), this->name.c_str()); + ntree, node, this->in_out, this->idname, this->identifier.c_str(), this->name.c_str()); if (this->default_value_fn) { ID *id = this->default_value_fn(node); /* Assumes that all ID sockets like #bNodeSocketValueObject and #bNodeSocketValueImage have the @@ -641,8 +641,8 @@ bNodeSocket &IDSocketDeclaration::update_or_build(bNodeTree &ntree, bNodeSocket &Geometry::build(bNodeTree &ntree, bNode &node) const { - bNodeSocket &socket = *bke::node_add_socket(&ntree, - &node, + bNodeSocket &socket = *bke::node_add_socket(ntree, + node, this->in_out, "NodeSocketGeometry", this->identifier.c_str(), @@ -715,12 +715,8 @@ GeometryBuilder &GeometryBuilder::only_instances(bool value) bNodeSocket &Shader::build(bNodeTree &ntree, bNode &node) const { - bNodeSocket &socket = *bke::node_add_socket(&ntree, - &node, - this->in_out, - "NodeSocketShader", - this->identifier.c_str(), - this->name.c_str()); + bNodeSocket &socket = *bke::node_add_socket( + ntree, node, this->in_out, "NodeSocketShader", this->identifier.c_str(), this->name.c_str()); this->set_common_flags(socket); return socket; } @@ -757,8 +753,8 @@ bool Shader::can_connect(const bNodeSocket &socket) const bNodeSocket &Extend::build(bNodeTree &ntree, bNode &node) const { - bNodeSocket &socket = *bke::node_add_socket(&ntree, - &node, + bNodeSocket &socket = *bke::node_add_socket(ntree, + node, this->in_out, "NodeSocketVirtual", this->identifier.c_str(), @@ -795,7 +791,7 @@ bNodeSocket &Extend::update_or_build(bNodeTree & /*ntree*/, bNodeSocket &Custom::build(bNodeTree &ntree, bNode &node) const { bNodeSocket &socket = *bke::node_add_socket( - &ntree, &node, this->in_out, idname_, this->identifier.c_str(), this->name.c_str()); + ntree, node, this->in_out, idname_, this->identifier.c_str(), this->name.c_str()); if (this->init_socket_fn) { this->init_socket_fn(node, socket, "interface"); } diff --git a/source/blender/nodes/intern/node_util.cc b/source/blender/nodes/intern/node_util.cc index 2f3f6f2c498..bb12b578fce 100644 --- a/source/blender/nodes/intern/node_util.cc +++ b/source/blender/nodes/intern/node_util.cc @@ -87,8 +87,8 @@ void node_math_update(bNodeTree *ntree, bNode *node) bNodeSocket *sock1 = static_cast(BLI_findlink(&node->inputs, 0)); bNodeSocket *sock2 = static_cast(BLI_findlink(&node->inputs, 1)); bNodeSocket *sock3 = static_cast(BLI_findlink(&node->inputs, 2)); - blender::bke::node_set_socket_availability(ntree, - sock2, + blender::bke::node_set_socket_availability(*ntree, + *sock2, !ELEM(node->custom1, NODE_MATH_SQRT, NODE_MATH_SIGN, @@ -112,8 +112,8 @@ void node_math_update(bNodeTree *ntree, bNode *node) NODE_MATH_COSH, NODE_MATH_SINH, NODE_MATH_TANH)); - blender::bke::node_set_socket_availability(ntree, - sock3, + blender::bke::node_set_socket_availability(*ntree, + *sock3, ELEM(node->custom1, NODE_MATH_COMPARE, NODE_MATH_MULTIPLY_ADD, diff --git a/source/blender/nodes/intern/socket_search_link.cc b/source/blender/nodes/intern/socket_search_link.cc index e802b2a0af3..36f07c4e147 100644 --- a/source/blender/nodes/intern/socket_search_link.cc +++ b/source/blender/nodes/intern/socket_search_link.cc @@ -67,7 +67,7 @@ void LinkSearchOpParams::connect_available_socket(bNode &new_node, StringRef soc BLI_assert_unreachable(); return; } - bke::node_add_link(&node_tree, &new_node, new_node_socket, &node, &socket); + bke::node_add_link(node_tree, new_node, *new_node_socket, node, socket); if (in_out == SOCK_OUT) { /* If the old socket already contained a value, then transfer it to a new one, from * which this value will get there. */ @@ -78,7 +78,7 @@ void LinkSearchOpParams::connect_available_socket(bNode &new_node, StringRef soc bNode &LinkSearchOpParams::add_node(StringRef idname) { std::string idname_str = idname; - bNode *node = bke::node_add_node(&C, &node_tree, idname_str.c_str()); + bNode *node = bke::node_add_node(&C, node_tree, idname_str.c_str()); BLI_assert(node != nullptr); added_nodes_.append(node); return *node; diff --git a/source/blender/nodes/shader/node_shader_tree.cc b/source/blender/nodes/shader/node_shader_tree.cc index b51a2ca11d8..a935ce715fc 100644 --- a/source/blender/nodes/shader/node_shader_tree.cc +++ b/source/blender/nodes/shader/node_shader_tree.cc @@ -132,20 +132,20 @@ static void localize(bNodeTree *localtree, bNodeTree * /*ntree*/) if (node->is_group() && node->id) { /* Free the group like in #ntree_shader_groups_flatten. */ bNodeTree *group = reinterpret_cast(node->id); - blender::bke::node_tree_free_tree(group); + blender::bke::node_tree_free_tree(*group); MEM_freeN(group); node->id = nullptr; } - blender::bke::node_internal_relink(localtree, node); - blender::bke::node_tree_free_local_node(localtree, node); + blender::bke::node_internal_relink(*localtree, *node); + blender::bke::node_tree_free_local_node(*localtree, *node); } } } static void update(bNodeTree *ntree) { - blender::bke::node_tree_set_output(ntree); + blender::bke::node_tree_set_output(*ntree); ntree_update_reroute_nodes(ntree); } @@ -163,13 +163,13 @@ static bool shader_validate_link(eNodeSocketDatatype from, eNodeSocketDatatype t static bool shader_node_tree_socket_type_valid(blender::bke::bNodeTreeType * /*ntreetype*/, blender::bke::bNodeSocketType *socket_type) { - return blender::bke::node_is_static_socket_type(socket_type) && ELEM(socket_type->type, - SOCK_FLOAT, - SOCK_INT, - SOCK_BOOLEAN, - SOCK_VECTOR, - SOCK_RGBA, - SOCK_SHADER); + return blender::bke::node_is_static_socket_type(*socket_type) && ELEM(socket_type->type, + SOCK_FLOAT, + SOCK_INT, + SOCK_BOOLEAN, + SOCK_VECTOR, + SOCK_RGBA, + SOCK_SHADER); } blender::bke::bNodeTreeType *ntreeType_Shader; @@ -196,7 +196,7 @@ void register_node_tree_type_sh() tt->rna_ext.srna = &RNA_ShaderNodeTree; - blender::bke::node_tree_type_add(tt); + blender::bke::node_tree_type_add(*tt); } /* GPU material from shader nodes */ @@ -204,7 +204,7 @@ void register_node_tree_type_sh() bNode *ntreeShaderOutputNode(bNodeTree *ntree, int target) { /* Make sure we only have single node tagged as output. */ - blender::bke::node_tree_set_output(ntree); + blender::bke::node_tree_set_output(*ntree); /* Find output node that matches type and target. If there are * multiple, we prefer exact target match and active nodes. */ @@ -295,7 +295,7 @@ static bool ntree_shader_expand_socket_default(bNodeTree *localtree, switch (socket->type) { case SOCK_VECTOR: - value_node = blender::bke::node_add_static_node(nullptr, localtree, SH_NODE_RGB); + value_node = blender::bke::node_add_static_node(nullptr, *localtree, SH_NODE_RGB); value_socket = ntree_shader_node_find_output(value_node, "Color"); BLI_assert(value_socket != nullptr); src_vector = static_cast(socket->default_value); @@ -304,7 +304,7 @@ static bool ntree_shader_expand_socket_default(bNodeTree *localtree, dst_rgba->value[3] = 1.0f; /* should never be read */ break; case SOCK_RGBA: - value_node = blender::bke::node_add_static_node(nullptr, localtree, SH_NODE_RGB); + value_node = blender::bke::node_add_static_node(nullptr, *localtree, SH_NODE_RGB); value_socket = ntree_shader_node_find_output(value_node, "Color"); BLI_assert(value_socket != nullptr); src_rgba = static_cast(socket->default_value); @@ -313,7 +313,7 @@ static bool ntree_shader_expand_socket_default(bNodeTree *localtree, break; case SOCK_BOOLEAN: /* HACK: Support as float. */ - value_node = blender::bke::node_add_static_node(nullptr, localtree, SH_NODE_VALUE); + value_node = blender::bke::node_add_static_node(nullptr, *localtree, SH_NODE_VALUE); value_socket = ntree_shader_node_find_output(value_node, "Value"); BLI_assert(value_socket != nullptr); src_bool = static_cast(socket->default_value); @@ -322,7 +322,7 @@ static bool ntree_shader_expand_socket_default(bNodeTree *localtree, break; case SOCK_INT: /* HACK: Support as float. */ - value_node = blender::bke::node_add_static_node(nullptr, localtree, SH_NODE_VALUE); + value_node = blender::bke::node_add_static_node(nullptr, *localtree, SH_NODE_VALUE); value_socket = ntree_shader_node_find_output(value_node, "Value"); BLI_assert(value_socket != nullptr); src_int = static_cast(socket->default_value); @@ -330,7 +330,7 @@ static bool ntree_shader_expand_socket_default(bNodeTree *localtree, dst_float->value = float(src_int->value); break; case SOCK_FLOAT: - value_node = blender::bke::node_add_static_node(nullptr, localtree, SH_NODE_VALUE); + value_node = blender::bke::node_add_static_node(nullptr, *localtree, SH_NODE_VALUE); value_socket = ntree_shader_node_find_output(value_node, "Value"); BLI_assert(value_socket != nullptr); src_float = static_cast(socket->default_value); @@ -340,7 +340,7 @@ static bool ntree_shader_expand_socket_default(bNodeTree *localtree, default: return false; } - blender::bke::node_add_link(localtree, value_node, value_socket, node, socket); + blender::bke::node_add_link(*localtree, *value_node, *value_socket, *node, *socket); return true; } @@ -364,7 +364,7 @@ static void ntree_shader_unlink_hidden_value_sockets(bNode *group_node, bNodeSoc ntree_shader_unlink_hidden_value_sockets(node, sock); } else { - blender::bke::node_remove_link(group_ntree, sock->link); + blender::bke::node_remove_link(group_ntree, *sock->link); removed_link = true; } } @@ -400,18 +400,22 @@ static void ntree_shader_groups_expand_inputs(bNodeTree *localtree) * We only do the case of lossy conversion to float. */ if ((socket->type == SOCK_FLOAT) && (link->fromsock->type != link->tosock->type)) { if (link->fromsock->type == SOCK_RGBA) { - bNode *tmp = blender::bke::node_add_static_node(nullptr, localtree, SH_NODE_RGBTOBW); - blender::bke::node_add_link(localtree, - link->fromnode, - link->fromsock, - tmp, - static_cast(tmp->inputs.first)); - blender::bke::node_add_link( - localtree, tmp, static_cast(tmp->outputs.first), node, socket); + bNode *tmp = blender::bke::node_add_static_node( + nullptr, *localtree, SH_NODE_RGBTOBW); + blender::bke::node_add_link(*localtree, + *link->fromnode, + *link->fromsock, + *tmp, + *static_cast(tmp->inputs.first)); + blender::bke::node_add_link(*localtree, + *tmp, + *static_cast(tmp->outputs.first), + *node, + *socket); } else if (link->fromsock->type == SOCK_VECTOR) { bNode *tmp = blender::bke::node_add_static_node( - nullptr, localtree, SH_NODE_VECTOR_MATH); + nullptr, *localtree, SH_NODE_VECTOR_MATH); tmp->custom1 = NODE_VECTOR_MATH_DOT_PRODUCT; bNodeSocket *dot_input1 = static_cast(tmp->inputs.first); bNodeSocket *dot_input2 = static_cast(dot_input1->next); @@ -419,9 +423,12 @@ static void ntree_shader_groups_expand_inputs(bNodeTree *localtree) dot_input2->default_value); copy_v3_fl(input2_socket_value->value, 1.0f / 3.0f); blender::bke::node_add_link( - localtree, link->fromnode, link->fromsock, tmp, dot_input1); - blender::bke::node_add_link( - localtree, tmp, static_cast(tmp->outputs.last), node, socket); + *localtree, *link->fromnode, *link->fromsock, *tmp, *dot_input1); + blender::bke::node_add_link(*localtree, + *tmp, + *static_cast(tmp->outputs.last), + *node, + *socket); } } continue; @@ -456,7 +463,7 @@ static void ntree_shader_groups_remove_muted_links(bNodeTree *ntree) } LISTBASE_FOREACH_MUTABLE (bNodeLink *, link, &ntree->links) { if (link->flag & NODE_LINK_MUTED) { - blender::bke::node_remove_link(ntree, link); + blender::bke::node_remove_link(ntree, *link); } } } @@ -477,7 +484,7 @@ static void flatten_group_do(bNodeTree *ntree, bNode *gnode) /* migrate node */ BLI_remlink(&ngroup->nodes, node); BLI_addtail(&ntree->nodes, node); - blender::bke::node_unique_id(ntree, node); + blender::bke::node_unique_id(*ntree, *node); /* ensure unique node name in the node tree */ /* This is very slow and it has no use for GPU nodetree. (see #70609) */ // blender::bke::node_unique_name(ntree, node); @@ -508,7 +515,7 @@ static void flatten_group_do(bNodeTree *ntree, bNode *gnode) { if (tlink->tonode == gnode && STREQ(tlink->tosock->identifier, identifier)) { blender::bke::node_add_link( - ntree, tlink->fromnode, tlink->fromsock, link->tonode, link->tosock); + *ntree, *tlink->fromnode, *tlink->fromsock, *link->tonode, *link->tosock); } } } @@ -528,7 +535,7 @@ static void flatten_group_do(bNodeTree *ntree, bNode *gnode) if (link->tonode->is_group_output() && (link->tonode->flag & NODE_DO_OUTPUT)) { if (STREQ(link->tosock->identifier, identifier)) { blender::bke::node_add_link( - ntree, link->fromnode, link->fromsock, tlink->tonode, tlink->tosock); + *ntree, *link->fromnode, *link->fromsock, *tlink->tonode, *tlink->tosock); } } } @@ -538,7 +545,7 @@ static void flatten_group_do(bNodeTree *ntree, bNode *gnode) while (group_interface_nodes) { bNode *node = static_cast(BLI_linklist_pop(&group_interface_nodes)); - blender::bke::node_tree_free_local_node(ntree, node); + blender::bke::node_tree_free_local_node(*ntree, *node); } BKE_ntree_update_tag_all(ntree); @@ -558,8 +565,8 @@ static void ntree_shader_groups_flatten(bNodeTree *localtree) node_next = node->next; /* delete the group instance and its localtree. */ bNodeTree *ngroup = (bNodeTree *)node->id; - blender::bke::node_tree_free_local_node(localtree, node); - blender::bke::node_tree_free_tree(ngroup); + blender::bke::node_tree_free_local_node(*localtree, *node); + blender::bke::node_tree_free_tree(*ngroup); BLI_assert(!ngroup->id.py_instance); /* Or call #BKE_libblock_free_data_py. */ MEM_freeN(ngroup); } @@ -630,7 +637,7 @@ static void ntree_shader_copy_branch(bNodeTree *ntree, ntree, *node, LIB_ID_CREATE_NO_USER_REFCOUNT | LIB_ID_CREATE_NO_MAIN, false); /* But identifiers must be created for the `bNodeTree::all_nodes()` vector, * so they won't match the original. */ - blender::bke::node_unique_id(ntree, nodes_copy[id]); + blender::bke::node_unique_id(*ntree, *nodes_copy[id]); bNode *copy = nodes_copy[id]; copy->runtime->tmp_flag = -2; /* Copy */ @@ -653,29 +660,30 @@ static void ntree_shader_copy_branch(bNodeTree *ntree, bNode *from_node = nodes_copy[link->fromnode->runtime->tmp_flag]; bNode *to_node = nodes_copy[link->tonode->runtime->tmp_flag]; blender::bke::node_add_link( - ntree, - from_node, - ntree_shader_node_find_output(from_node, link->fromsock->identifier), - to_node, - ntree_shader_node_find_input(to_node, link->tosock->identifier)); + *ntree, + *from_node, + *ntree_shader_node_find_output(from_node, link->fromsock->identifier), + *to_node, + *ntree_shader_node_find_input(to_node, link->tosock->identifier)); } else if (to_copy) { bNode *to_node = nodes_copy[link->tonode->runtime->tmp_flag]; - blender::bke::node_add_link(ntree, - link->fromnode, - link->fromsock, - to_node, - ntree_shader_node_find_input(to_node, link->tosock->identifier)); + blender::bke::node_add_link( + *ntree, + *link->fromnode, + *link->fromsock, + *to_node, + *ntree_shader_node_find_input(to_node, link->tosock->identifier)); } else if (from_copy && branch_nodes.contains(link->tonode)) { bNode *from_node = nodes_copy[link->fromnode->runtime->tmp_flag]; blender::bke::node_add_link( - ntree, - from_node, - ntree_shader_node_find_output(from_node, link->fromsock->identifier), - link->tonode, - link->tosock); - blender::bke::node_remove_link(ntree, link); + *ntree, + *from_node, + *ntree_shader_node_find_output(from_node, link->fromsock->identifier), + *link->tonode, + *link->tosock); + blender::bke::node_remove_link(ntree, *link); } } } @@ -688,12 +696,13 @@ static bool ntree_shader_implicit_closure_cast(bNodeTree *ntree) bool modified = false; LISTBASE_FOREACH_MUTABLE (bNodeLink *, link, &ntree->links) { if ((link->fromsock->type != SOCK_SHADER) && (link->tosock->type == SOCK_SHADER)) { - bNode *emission_node = blender::bke::node_add_static_node(nullptr, ntree, SH_NODE_EMISSION); + bNode *emission_node = blender::bke::node_add_static_node(nullptr, *ntree, SH_NODE_EMISSION); bNodeSocket *in_sock = ntree_shader_node_find_input(emission_node, "Color"); bNodeSocket *out_sock = ntree_shader_node_find_output(emission_node, "Emission"); - blender::bke::node_add_link(ntree, link->fromnode, link->fromsock, emission_node, in_sock); - blender::bke::node_add_link(ntree, emission_node, out_sock, link->tonode, link->tosock); - blender::bke::node_remove_link(ntree, link); + blender::bke::node_add_link( + *ntree, *link->fromnode, *link->fromsock, *emission_node, *in_sock); + blender::bke::node_add_link(*ntree, *emission_node, *out_sock, *link->tonode, *link->tosock); + blender::bke::node_remove_link(ntree, *link); modified = true; } else if ((link->fromsock->type == SOCK_SHADER) && (link->tosock->type != SOCK_SHADER)) { @@ -716,16 +725,17 @@ static void ntree_weight_tree_merge_weight(bNodeTree *ntree, bNode **tonode, bNodeSocket **tosock) { - bNode *addnode = blender::bke::node_add_static_node(nullptr, ntree, SH_NODE_MATH); + bNode *addnode = blender::bke::node_add_static_node(nullptr, *ntree, SH_NODE_MATH); addnode->custom1 = NODE_MATH_ADD; addnode->runtime->tmp_flag = -2; /* Copy */ bNodeSocket *addsock_out = ntree_shader_node_output_get(addnode, 0); bNodeSocket *addsock_in0 = ntree_shader_node_input_get(addnode, 0); bNodeSocket *addsock_in1 = ntree_shader_node_input_get(addnode, 1); bNodeLink *oldlink = fromsock->link; - blender::bke::node_add_link(ntree, oldlink->fromnode, oldlink->fromsock, addnode, addsock_in0); - blender::bke::node_add_link(ntree, *tonode, *tosock, addnode, addsock_in1); - blender::bke::node_remove_link(ntree, oldlink); + blender::bke::node_add_link( + *ntree, *oldlink->fromnode, *oldlink->fromsock, *addnode, *addsock_in0); + blender::bke::node_add_link(*ntree, **tonode, **tosock, *addnode, *addsock_in1); + blender::bke::node_remove_link(ntree, *oldlink); *tonode = addnode; *tosock = addsock_out; } @@ -791,7 +801,7 @@ static void ntree_shader_weight_tree_invert(bNodeTree *ntree, bNode *output_node case SH_NODE_OUTPUT_WORLD: case SH_NODE_OUTPUT_MATERIAL: { /* Start the tree with full weight. */ - nodes_copy[id] = blender::bke::node_add_static_node(nullptr, ntree, SH_NODE_VALUE); + nodes_copy[id] = blender::bke::node_add_static_node(nullptr, *ntree, SH_NODE_VALUE); nodes_copy[id]->runtime->tmp_flag = -2; /* Copy */ ((bNodeSocketValueFloat *)ntree_shader_node_output_get(nodes_copy[id], 0)->default_value) ->value = 1.0f; @@ -800,7 +810,7 @@ static void ntree_shader_weight_tree_invert(bNodeTree *ntree, bNode *output_node case SH_NODE_ADD_SHADER: { /* Simple passthrough node. Each original inputs will get the same weight. */ /* TODO(fclem): Better use some kind of reroute node? */ - nodes_copy[id] = blender::bke::node_add_static_node(nullptr, ntree, SH_NODE_MATH); + nodes_copy[id] = blender::bke::node_add_static_node(nullptr, *ntree, SH_NODE_MATH); nodes_copy[id]->custom1 = NODE_MATH_ADD; nodes_copy[id]->runtime->tmp_flag = -2; /* Copy */ ((bNodeSocketValueFloat *)ntree_shader_node_input_get(nodes_copy[id], 0)->default_value) @@ -813,17 +823,17 @@ static void ntree_shader_weight_tree_invert(bNodeTree *ntree, bNode *output_node bNodeSocket *fromsock, *tosock; int id_start = id; /* output = (factor * input_weight) */ - nodes_copy[id] = blender::bke::node_add_static_node(nullptr, ntree, SH_NODE_MATH); + nodes_copy[id] = blender::bke::node_add_static_node(nullptr, *ntree, SH_NODE_MATH); nodes_copy[id]->custom1 = NODE_MATH_MULTIPLY; nodes_copy[id]->runtime->tmp_flag = -2; /* Copy */ id++; /* output = ((1.0 - factor) * input_weight) <=> (input_weight - factor * input_weight) */ - nodes_copy[id] = blender::bke::node_add_static_node(nullptr, ntree, SH_NODE_MATH); + nodes_copy[id] = blender::bke::node_add_static_node(nullptr, *ntree, SH_NODE_MATH); nodes_copy[id]->custom1 = NODE_MATH_SUBTRACT; nodes_copy[id]->runtime->tmp_flag = -2; /* Copy */ id++; /* Node sanitizes the input mix factor by clamping it. */ - nodes_copy[id] = blender::bke::node_add_static_node(nullptr, ntree, SH_NODE_MATH); + nodes_copy[id] = blender::bke::node_add_static_node(nullptr, *ntree, SH_NODE_MATH); nodes_copy[id]->custom1 = NODE_MATH_ADD; nodes_copy[id]->custom2 = SHD_MATH_CLAMP; nodes_copy[id]->runtime->tmp_flag = -2; /* Copy */ @@ -839,7 +849,7 @@ static void ntree_shader_weight_tree_invert(bNodeTree *ntree, bNode *output_node id++; /* Reroute the weight input to the 3 processing nodes. Simplify linking later-on. */ /* TODO(fclem): Better use some kind of reroute node? */ - nodes_copy[id] = blender::bke::node_add_static_node(nullptr, ntree, SH_NODE_MATH); + nodes_copy[id] = blender::bke::node_add_static_node(nullptr, *ntree, SH_NODE_MATH); nodes_copy[id]->custom1 = NODE_MATH_ADD; nodes_copy[id]->runtime->tmp_flag = -2; /* Copy */ ((bNodeSocketValueFloat *)ntree_shader_node_input_get(nodes_copy[id], 0)->default_value) @@ -850,22 +860,22 @@ static void ntree_shader_weight_tree_invert(bNodeTree *ntree, bNode *output_node tonode = nodes_copy[id_start + 1]; fromsock = ntree_shader_node_output_get(fromnode, 0); tosock = ntree_shader_node_input_get(tonode, 1); - blender::bke::node_add_link(ntree, fromnode, fromsock, tonode, tosock); + blender::bke::node_add_link(*ntree, *fromnode, *fromsock, *tonode, *tosock); /* Link mix input to first node. */ fromnode = nodes_copy[id_start + 2]; tonode = nodes_copy[id_start]; fromsock = ntree_shader_node_output_get(fromnode, 0); tosock = ntree_shader_node_input_get(tonode, 1); - blender::bke::node_add_link(ntree, fromnode, fromsock, tonode, tosock); + blender::bke::node_add_link(*ntree, *fromnode, *fromsock, *tonode, *tosock); /* Link weight input to both multiply nodes. */ fromnode = nodes_copy[id_start + 3]; fromsock = ntree_shader_node_output_get(fromnode, 0); tonode = nodes_copy[id_start]; tosock = ntree_shader_node_input_get(tonode, 0); - blender::bke::node_add_link(ntree, fromnode, fromsock, tonode, tosock); + blender::bke::node_add_link(*ntree, *fromnode, *fromsock, *tonode, *tosock); tonode = nodes_copy[id_start + 1]; tosock = ntree_shader_node_input_get(tonode, 0); - blender::bke::node_add_link(ntree, fromnode, fromsock, tonode, tosock); + blender::bke::node_add_link(*ntree, *fromnode, *fromsock, *tonode, *tosock); break; } default: @@ -974,7 +984,8 @@ static void ntree_shader_weight_tree_invert(bNodeTree *ntree, bNode *output_node /* Manually add the link to the socket to avoid calling: * `BKE_ntree_update(G.main, oop)`. */ - fromsock->link = blender::bke::node_add_link(ntree, fromnode, fromsock, tonode, tosock); + fromsock->link = &blender::bke::node_add_link( + *ntree, *fromnode, *fromsock, *tonode, *tosock); BLI_assert(fromsock->link); } } @@ -982,12 +993,18 @@ static void ntree_shader_weight_tree_invert(bNodeTree *ntree, bNode *output_node } /* Restore displacement & thickness link. */ if (displace_link) { - blender::bke::node_add_link( - ntree, displace_link->fromnode, displace_link->fromsock, output_node, displace_output); + blender::bke::node_add_link(*ntree, + *displace_link->fromnode, + *displace_link->fromsock, + *output_node, + *displace_output); } if (thickness_link) { - blender::bke::node_add_link( - ntree, thickness_link->fromnode, thickness_link->fromsock, output_node, thickness_output); + blender::bke::node_add_link(*ntree, + *thickness_link->fromnode, + *thickness_link->fromsock, + *output_node, + *thickness_output); } BKE_ntree_update_after_single_tree_change(*G.main, *ntree); } @@ -1078,7 +1095,7 @@ static void shader_node_disconnect_input(bNodeTree *ntree, bNode *node, int inde { bNodeLink *link = ntree_shader_node_input_get(node, index)->link; if (link) { - blender::bke::node_remove_link(ntree, link); + blender::bke::node_remove_link(ntree, *link); } } @@ -1197,7 +1214,7 @@ static void ntree_shader_pruned_unused(bNodeTree *ntree, bNode *output_node) LISTBASE_FOREACH_MUTABLE (bNode *, node, &ntree->nodes) { if (node->runtime->tmp_flag == 0) { - blender::bke::node_tree_free_local_node(ntree, node); + blender::bke::node_tree_free_local_node(*ntree, *node); changed = true; } } @@ -1259,7 +1276,7 @@ bNodeTreeExec *ntreeShaderBeginExecTree_internal(bNodeExecContext *context, bNodeInstanceKey parent_key) { /* ensures only a single output node is enabled */ - blender::bke::node_tree_set_output(ntree); + blender::bke::node_tree_set_output(*ntree); /* common base initialization */ bNodeTreeExec *exec = ntree_exec_begin(context, ntree, parent_key); diff --git a/source/blender/nodes/shader/node_shader_util.cc b/source/blender/nodes/shader/node_shader_util.cc index 840aa667114..c8bd93d9b45 100644 --- a/source/blender/nodes/shader/node_shader_util.cc +++ b/source/blender/nodes/shader/node_shader_util.cc @@ -53,7 +53,7 @@ void sh_node_type_base(blender::bke::bNodeType *ntype, std::string idname, const std::optional legacy_type) { - blender::bke::node_type_base(ntype, idname, legacy_type); + blender::bke::node_type_base(*ntype, idname, legacy_type); ntype->poll = sh_node_poll_default; ntype->insert_link = node_insert_link_default; @@ -227,14 +227,14 @@ static void data_from_gpu_stack_list(ListBase *sockets, bNodeStack **ns, GPUNode } } -bool blender::bke::node_supports_active_flag(const bNode *node, int sub_activity) +bool blender::bke::node_supports_active_flag(const bNode &node, int sub_activity) { BLI_assert(ELEM(sub_activity, NODE_ACTIVE_TEXTURE, NODE_ACTIVE_PAINT_CANVAS)); switch (sub_activity) { case NODE_ACTIVE_TEXTURE: - return node->typeinfo->nclass == NODE_CLASS_TEXTURE; + return node.typeinfo->nclass == NODE_CLASS_TEXTURE; case NODE_ACTIVE_PAINT_CANVAS: - return ELEM(node->type_legacy, SH_NODE_TEX_IMAGE, SH_NODE_ATTRIBUTE); + return ELEM(node.type_legacy, SH_NODE_TEX_IMAGE, SH_NODE_ATTRIBUTE); } return false; } @@ -258,7 +258,7 @@ static bNode *node_get_active(bNodeTree *ntree, int sub_activity) return node; } } - else if (!inactivenode && blender::bke::node_supports_active_flag(node, sub_activity)) { + else if (!inactivenode && blender::bke::node_supports_active_flag(*node, sub_activity)) { inactivenode = node; } else if (node->type_legacy == NODE_GROUP) { @@ -301,14 +301,14 @@ static bNode *node_get_active(bNodeTree *ntree, int sub_activity) namespace blender::bke { -bNode *node_get_active_texture(bNodeTree *ntree) +bNode *node_get_active_texture(bNodeTree &ntree) { - return node_get_active(ntree, NODE_ACTIVE_TEXTURE); + return node_get_active(&ntree, NODE_ACTIVE_TEXTURE); } -bNode *node_get_active_paint_canvas(bNodeTree *ntree) +bNode *node_get_active_paint_canvas(bNodeTree &ntree) { - return node_get_active(ntree, NODE_ACTIVE_PAINT_CANVAS); + return node_get_active(&ntree, NODE_ACTIVE_PAINT_CANVAS); } } // namespace blender::bke diff --git a/source/blender/nodes/shader/nodes/node_shader_add_shader.cc b/source/blender/nodes/shader/nodes/node_shader_add_shader.cc index 7aa6dada06e..761287380a1 100644 --- a/source/blender/nodes/shader/nodes/node_shader_add_shader.cc +++ b/source/blender/nodes/shader/nodes/node_shader_add_shader.cc @@ -67,5 +67,5 @@ void register_node_type_sh_add_shader() ntype.gpu_fn = file_ns::node_shader_gpu_add_shader; ntype.materialx_fn = file_ns::node_shader_materialx; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } diff --git a/source/blender/nodes/shader/nodes/node_shader_ambient_occlusion.cc b/source/blender/nodes/shader/nodes/node_shader_ambient_occlusion.cc index 78c6a112666..483b15d26a9 100644 --- a/source/blender/nodes/shader/nodes/node_shader_ambient_occlusion.cc +++ b/source/blender/nodes/shader/nodes/node_shader_ambient_occlusion.cc @@ -94,5 +94,5 @@ void register_node_type_sh_ambient_occlusion() ntype.gpu_fn = file_ns::node_shader_gpu_ambient_occlusion; ntype.materialx_fn = file_ns::node_shader_materialx; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } diff --git a/source/blender/nodes/shader/nodes/node_shader_attribute.cc b/source/blender/nodes/shader/nodes/node_shader_attribute.cc index 4c12d788557..ab580a616b1 100644 --- a/source/blender/nodes/shader/nodes/node_shader_attribute.cc +++ b/source/blender/nodes/shader/nodes/node_shader_attribute.cc @@ -115,9 +115,9 @@ void register_node_type_sh_attribute() ntype.draw_buttons = file_ns::node_shader_buts_attribute; ntype.initfunc = file_ns::node_shader_init_attribute; blender::bke::node_type_storage( - &ntype, "NodeShaderAttribute", node_free_standard_storage, node_copy_standard_storage); + ntype, "NodeShaderAttribute", node_free_standard_storage, node_copy_standard_storage); ntype.gpu_fn = file_ns::node_shader_gpu_attribute; ntype.materialx_fn = file_ns::node_shader_materialx; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } diff --git a/source/blender/nodes/shader/nodes/node_shader_background.cc b/source/blender/nodes/shader/nodes/node_shader_background.cc index 326611f2481..b2d1d2f2c9e 100644 --- a/source/blender/nodes/shader/nodes/node_shader_background.cc +++ b/source/blender/nodes/shader/nodes/node_shader_background.cc @@ -50,5 +50,5 @@ void register_node_type_sh_background() ntype.add_ui_poll = world_shader_nodes_poll; ntype.gpu_fn = file_ns::node_shader_gpu_background; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } diff --git a/source/blender/nodes/shader/nodes/node_shader_bevel.cc b/source/blender/nodes/shader/nodes/node_shader_bevel.cc index 858259a689c..c8720605954 100644 --- a/source/blender/nodes/shader/nodes/node_shader_bevel.cc +++ b/source/blender/nodes/shader/nodes/node_shader_bevel.cc @@ -70,5 +70,5 @@ void register_node_type_sh_bevel() ntype.gpu_fn = file_ns::gpu_shader_bevel; ntype.materialx_fn = file_ns::node_shader_materialx; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } diff --git a/source/blender/nodes/shader/nodes/node_shader_blackbody.cc b/source/blender/nodes/shader/nodes/node_shader_blackbody.cc index 8cd7523b7bc..78d287a9034 100644 --- a/source/blender/nodes/shader/nodes/node_shader_blackbody.cc +++ b/source/blender/nodes/shader/nodes/node_shader_blackbody.cc @@ -76,10 +76,10 @@ void register_node_type_sh_blackbody() ntype.enum_name_legacy = "BLACKBODY"; ntype.nclass = NODE_CLASS_CONVERTER; ntype.declare = file_ns::node_declare; - blender::bke::node_type_size_preset(&ntype, blender::bke::eNodeSizePreset::Middle); + blender::bke::node_type_size_preset(ntype, blender::bke::eNodeSizePreset::Middle); ntype.gpu_fn = file_ns::node_shader_gpu_blackbody; ntype.build_multi_function = file_ns::sh_node_blackbody_build_multi_function; ntype.materialx_fn = file_ns::node_shader_materialx; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } diff --git a/source/blender/nodes/shader/nodes/node_shader_brightness.cc b/source/blender/nodes/shader/nodes/node_shader_brightness.cc index 118e7a197f8..60dd2c94b8a 100644 --- a/source/blender/nodes/shader/nodes/node_shader_brightness.cc +++ b/source/blender/nodes/shader/nodes/node_shader_brightness.cc @@ -66,5 +66,5 @@ void register_node_type_sh_brightcontrast() ntype.gpu_fn = file_ns::gpu_shader_brightcontrast; ntype.materialx_fn = file_ns::node_shader_materialx; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } diff --git a/source/blender/nodes/shader/nodes/node_shader_bsdf_diffuse.cc b/source/blender/nodes/shader/nodes/node_shader_bsdf_diffuse.cc index 36536c3b576..a36bd751908 100644 --- a/source/blender/nodes/shader/nodes/node_shader_bsdf_diffuse.cc +++ b/source/blender/nodes/shader/nodes/node_shader_bsdf_diffuse.cc @@ -68,9 +68,9 @@ void register_node_type_sh_bsdf_diffuse() ntype.nclass = NODE_CLASS_SHADER; ntype.declare = file_ns::node_declare; ntype.add_ui_poll = object_shader_nodes_poll; - blender::bke::node_type_size_preset(&ntype, blender::bke::eNodeSizePreset::Middle); + blender::bke::node_type_size_preset(ntype, blender::bke::eNodeSizePreset::Middle); ntype.gpu_fn = file_ns::node_shader_gpu_bsdf_diffuse; ntype.materialx_fn = file_ns::node_shader_materialx; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } diff --git a/source/blender/nodes/shader/nodes/node_shader_bsdf_glass.cc b/source/blender/nodes/shader/nodes/node_shader_bsdf_glass.cc index 476e3cb2377..1450de8e0f1 100644 --- a/source/blender/nodes/shader/nodes/node_shader_bsdf_glass.cc +++ b/source/blender/nodes/shader/nodes/node_shader_bsdf_glass.cc @@ -81,10 +81,10 @@ void register_node_type_sh_bsdf_glass() ntype.nclass = NODE_CLASS_SHADER; ntype.declare = file_ns::node_declare; ntype.add_ui_poll = object_shader_nodes_poll; - blender::bke::node_type_size_preset(&ntype, blender::bke::eNodeSizePreset::Middle); + blender::bke::node_type_size_preset(ntype, blender::bke::eNodeSizePreset::Middle); ntype.initfunc = file_ns::node_shader_init_glass; ntype.gpu_fn = file_ns::node_shader_gpu_bsdf_glass; ntype.materialx_fn = file_ns::node_shader_materialx; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } diff --git a/source/blender/nodes/shader/nodes/node_shader_bsdf_glossy.cc b/source/blender/nodes/shader/nodes/node_shader_bsdf_glossy.cc index 46a455a3ec0..e5897ced28f 100644 --- a/source/blender/nodes/shader/nodes/node_shader_bsdf_glossy.cc +++ b/source/blender/nodes/shader/nodes/node_shader_bsdf_glossy.cc @@ -104,14 +104,14 @@ void register_node_type_sh_bsdf_glossy() ntype.declare = file_ns::node_declare; ntype.add_ui_poll = object_shader_nodes_poll; ntype.draw_buttons = file_ns::node_shader_buts_glossy; - blender::bke::node_type_size_preset(&ntype, blender::bke::eNodeSizePreset::Middle); + blender::bke::node_type_size_preset(ntype, blender::bke::eNodeSizePreset::Middle); ntype.initfunc = file_ns::node_shader_init_glossy; ntype.gpu_fn = file_ns::node_shader_gpu_bsdf_glossy; ntype.materialx_fn = file_ns::node_shader_materialx; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); /* Needed to preserve API compatibility with older versions which had separate * Glossy and Anisotropic nodes. */ - blender::bke::node_register_alias(&ntype, "ShaderNodeBsdfGlossy"); + blender::bke::node_register_alias(ntype, "ShaderNodeBsdfGlossy"); } diff --git a/source/blender/nodes/shader/nodes/node_shader_bsdf_hair.cc b/source/blender/nodes/shader/nodes/node_shader_bsdf_hair.cc index 5a51f53b87c..70a61cc283f 100644 --- a/source/blender/nodes/shader/nodes/node_shader_bsdf_hair.cc +++ b/source/blender/nodes/shader/nodes/node_shader_bsdf_hair.cc @@ -62,8 +62,8 @@ void register_node_type_sh_bsdf_hair() ntype.declare = file_ns::node_declare; ntype.add_ui_poll = object_cycles_shader_nodes_poll; ntype.draw_buttons = file_ns::node_shader_buts_hair; - blender::bke::node_type_size(&ntype, 150, 60, 200); + blender::bke::node_type_size(ntype, 150, 60, 200); ntype.gpu_fn = file_ns::node_shader_gpu_bsdf_hair; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } diff --git a/source/blender/nodes/shader/nodes/node_shader_bsdf_hair_principled.cc b/source/blender/nodes/shader/nodes/node_shader_bsdf_hair_principled.cc index 638dc92ce64..c198bc2d887 100644 --- a/source/blender/nodes/shader/nodes/node_shader_bsdf_hair_principled.cc +++ b/source/blender/nodes/shader/nodes/node_shader_bsdf_hair_principled.cc @@ -155,39 +155,39 @@ static void node_shader_update_hair_principled(bNodeTree *ntree, bNode *node) LISTBASE_FOREACH (bNodeSocket *, sock, &node->inputs) { if (STREQ(sock->name, "Color")) { bke::node_set_socket_availability( - ntree, sock, parametrization == SHD_PRINCIPLED_HAIR_REFLECTANCE); + *ntree, *sock, parametrization == SHD_PRINCIPLED_HAIR_REFLECTANCE); } else if (STREQ(sock->name, "Melanin")) { bke::node_set_socket_availability( - ntree, sock, parametrization == SHD_PRINCIPLED_HAIR_PIGMENT_CONCENTRATION); + *ntree, *sock, parametrization == SHD_PRINCIPLED_HAIR_PIGMENT_CONCENTRATION); } else if (STREQ(sock->name, "Melanin Redness")) { bke::node_set_socket_availability( - ntree, sock, parametrization == SHD_PRINCIPLED_HAIR_PIGMENT_CONCENTRATION); + *ntree, *sock, parametrization == SHD_PRINCIPLED_HAIR_PIGMENT_CONCENTRATION); } else if (STREQ(sock->name, "Tint")) { bke::node_set_socket_availability( - ntree, sock, parametrization == SHD_PRINCIPLED_HAIR_PIGMENT_CONCENTRATION); + *ntree, *sock, parametrization == SHD_PRINCIPLED_HAIR_PIGMENT_CONCENTRATION); } else if (STREQ(sock->name, "Absorption Coefficient")) { bke::node_set_socket_availability( - ntree, sock, parametrization == SHD_PRINCIPLED_HAIR_DIRECT_ABSORPTION); + *ntree, *sock, parametrization == SHD_PRINCIPLED_HAIR_DIRECT_ABSORPTION); } else if (STREQ(sock->name, "Random Color")) { bke::node_set_socket_availability( - ntree, sock, parametrization == SHD_PRINCIPLED_HAIR_PIGMENT_CONCENTRATION); + *ntree, *sock, parametrization == SHD_PRINCIPLED_HAIR_PIGMENT_CONCENTRATION); } else if (STREQ(sock->name, "Radial Roughness")) { - bke::node_set_socket_availability(ntree, sock, model == SHD_PRINCIPLED_HAIR_CHIANG); + bke::node_set_socket_availability(*ntree, *sock, model == SHD_PRINCIPLED_HAIR_CHIANG); } else if (STREQ(sock->name, "Coat")) { - bke::node_set_socket_availability(ntree, sock, model == SHD_PRINCIPLED_HAIR_CHIANG); + bke::node_set_socket_availability(*ntree, *sock, model == SHD_PRINCIPLED_HAIR_CHIANG); } else if (STREQ(sock->name, "Aspect Ratio")) { - bke::node_set_socket_availability(ntree, sock, model == SHD_PRINCIPLED_HAIR_HUANG); + bke::node_set_socket_availability(*ntree, *sock, model == SHD_PRINCIPLED_HAIR_HUANG); } else if (STR_ELEM(sock->name, "Reflection", "Transmission", "Secondary Reflection")) { - bke::node_set_socket_availability(ntree, sock, model == SHD_PRINCIPLED_HAIR_HUANG); + bke::node_set_socket_availability(*ntree, *sock, model == SHD_PRINCIPLED_HAIR_HUANG); } } } @@ -220,12 +220,12 @@ void register_node_type_sh_bsdf_hair_principled() ntype.declare = file_ns::node_declare; ntype.add_ui_poll = object_cycles_shader_nodes_poll; ntype.draw_buttons = file_ns::node_shader_buts_principled_hair; - blender::bke::node_type_size_preset(&ntype, blender::bke::eNodeSizePreset::Large); + blender::bke::node_type_size_preset(ntype, blender::bke::eNodeSizePreset::Large); ntype.initfunc = file_ns::node_shader_init_hair_principled; ntype.updatefunc = file_ns::node_shader_update_hair_principled; ntype.gpu_fn = file_ns::node_shader_gpu_hair_principled; blender::bke::node_type_storage( - &ntype, "NodeShaderHairPrincipled", node_free_standard_storage, node_copy_standard_storage); + ntype, "NodeShaderHairPrincipled", node_free_standard_storage, node_copy_standard_storage); - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } diff --git a/source/blender/nodes/shader/nodes/node_shader_bsdf_metallic.cc b/source/blender/nodes/shader/nodes/node_shader_bsdf_metallic.cc index 2793bf08150..c47ef7ef600 100644 --- a/source/blender/nodes/shader/nodes/node_shader_bsdf_metallic.cc +++ b/source/blender/nodes/shader/nodes/node_shader_bsdf_metallic.cc @@ -98,13 +98,13 @@ static void node_shader_update_metallic(bNodeTree *ntree, bNode *node) const bool is_physical = (node->custom2 == SHD_PHYSICAL_CONDUCTOR); bke::node_set_socket_availability( - ntree, bke::node_find_socket(node, SOCK_IN, "Base Color"), !is_physical); + *ntree, *bke::node_find_socket(*node, SOCK_IN, "Base Color"), !is_physical); bke::node_set_socket_availability( - ntree, bke::node_find_socket(node, SOCK_IN, "Edge Tint"), !is_physical); + *ntree, *bke::node_find_socket(*node, SOCK_IN, "Edge Tint"), !is_physical); bke::node_set_socket_availability( - ntree, bke::node_find_socket(node, SOCK_IN, "IOR"), is_physical); + *ntree, *bke::node_find_socket(*node, SOCK_IN, "IOR"), is_physical); bke::node_set_socket_availability( - ntree, bke::node_find_socket(node, SOCK_IN, "Extinction"), is_physical); + *ntree, *bke::node_find_socket(*node, SOCK_IN, "Extinction"), is_physical); } NODE_SHADER_MATERIALX_BEGIN @@ -162,11 +162,11 @@ void register_node_type_sh_bsdf_metallic() ntype.declare = file_ns::node_declare; ntype.add_ui_poll = object_shader_nodes_poll; ntype.draw_buttons = file_ns::node_shader_buts_metallic; - blender::bke::node_type_size_preset(&ntype, blender::bke::eNodeSizePreset::Large); + blender::bke::node_type_size_preset(ntype, blender::bke::eNodeSizePreset::Large); ntype.initfunc = file_ns::node_shader_init_metallic; ntype.gpu_fn = file_ns::node_shader_gpu_bsdf_metallic; ntype.updatefunc = file_ns::node_shader_update_metallic; ntype.materialx_fn = file_ns::node_shader_materialx; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } diff --git a/source/blender/nodes/shader/nodes/node_shader_bsdf_principled.cc b/source/blender/nodes/shader/nodes/node_shader_bsdf_principled.cc index 4ce5938f5ff..3f555e6aea4 100644 --- a/source/blender/nodes/shader/nodes/node_shader_bsdf_principled.cc +++ b/source/blender/nodes/shader/nodes/node_shader_bsdf_principled.cc @@ -361,12 +361,13 @@ static void node_shader_update_principled(bNodeTree *ntree, bNode *node) { const int sss_method = node->custom2; - bke::node_set_socket_availability(ntree, - bke::node_find_socket(node, SOCK_IN, "Subsurface IOR"), + bke::node_set_socket_availability(*ntree, + *bke::node_find_socket(*node, SOCK_IN, "Subsurface IOR"), sss_method == SHD_SUBSURFACE_RANDOM_WALK_SKIN); - bke::node_set_socket_availability(ntree, - bke::node_find_socket(node, SOCK_IN, "Subsurface Anisotropy"), - sss_method != SHD_SUBSURFACE_BURLEY); + bke::node_set_socket_availability( + *ntree, + *bke::node_find_socket(*node, SOCK_IN, "Subsurface Anisotropy"), + sss_method != SHD_SUBSURFACE_BURLEY); } NODE_SHADER_MATERIALX_BEGIN @@ -669,11 +670,11 @@ void register_node_type_sh_bsdf_principled() ntype.nclass = NODE_CLASS_SHADER; ntype.declare = file_ns::node_declare; ntype.add_ui_poll = object_shader_nodes_poll; - blender::bke::node_type_size_preset(&ntype, blender::bke::eNodeSizePreset::Large); + blender::bke::node_type_size_preset(ntype, blender::bke::eNodeSizePreset::Large); ntype.initfunc = file_ns::node_shader_init_principled; ntype.gpu_fn = file_ns::node_shader_gpu_bsdf_principled; ntype.updatefunc = file_ns::node_shader_update_principled; ntype.materialx_fn = file_ns::node_shader_materialx; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } diff --git a/source/blender/nodes/shader/nodes/node_shader_bsdf_ray_portal.cc b/source/blender/nodes/shader/nodes/node_shader_bsdf_ray_portal.cc index 874edb80070..1f4b04021b4 100644 --- a/source/blender/nodes/shader/nodes/node_shader_bsdf_ray_portal.cc +++ b/source/blender/nodes/shader/nodes/node_shader_bsdf_ray_portal.cc @@ -70,5 +70,5 @@ void register_node_type_sh_bsdf_ray_portal() ntype.gpu_fn = file_ns::node_shader_gpu_bsdf_ray_portal; ntype.materialx_fn = file_ns::node_shader_materialx; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } diff --git a/source/blender/nodes/shader/nodes/node_shader_bsdf_refraction.cc b/source/blender/nodes/shader/nodes/node_shader_bsdf_refraction.cc index c936c2c104d..d2c70e04036 100644 --- a/source/blender/nodes/shader/nodes/node_shader_bsdf_refraction.cc +++ b/source/blender/nodes/shader/nodes/node_shader_bsdf_refraction.cc @@ -81,10 +81,10 @@ void register_node_type_sh_bsdf_refraction() ntype.nclass = NODE_CLASS_SHADER; ntype.declare = file_ns::node_declare; ntype.add_ui_poll = object_shader_nodes_poll; - blender::bke::node_type_size_preset(&ntype, blender::bke::eNodeSizePreset::Middle); + blender::bke::node_type_size_preset(ntype, blender::bke::eNodeSizePreset::Middle); ntype.initfunc = file_ns::node_shader_init_refraction; ntype.gpu_fn = file_ns::node_shader_gpu_bsdf_refraction; ntype.materialx_fn = file_ns::node_shader_materialx; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } diff --git a/source/blender/nodes/shader/nodes/node_shader_bsdf_sheen.cc b/source/blender/nodes/shader/nodes/node_shader_bsdf_sheen.cc index 7befe79c0e5..32458248164 100644 --- a/source/blender/nodes/shader/nodes/node_shader_bsdf_sheen.cc +++ b/source/blender/nodes/shader/nodes/node_shader_bsdf_sheen.cc @@ -100,5 +100,5 @@ void register_node_type_sh_bsdf_sheen() ntype.draw_buttons = file_ns::node_shader_buts_sheen; ntype.materialx_fn = file_ns::node_shader_materialx; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } diff --git a/source/blender/nodes/shader/nodes/node_shader_bsdf_toon.cc b/source/blender/nodes/shader/nodes/node_shader_bsdf_toon.cc index c19d3902b38..c4b48d4c99b 100644 --- a/source/blender/nodes/shader/nodes/node_shader_bsdf_toon.cc +++ b/source/blender/nodes/shader/nodes/node_shader_bsdf_toon.cc @@ -56,8 +56,8 @@ void register_node_type_sh_bsdf_toon() ntype.declare = file_ns::node_declare; ntype.add_ui_poll = object_cycles_shader_nodes_poll; ntype.draw_buttons = file_ns::node_shader_buts_toon; - blender::bke::node_type_size_preset(&ntype, blender::bke::eNodeSizePreset::Middle); + blender::bke::node_type_size_preset(ntype, blender::bke::eNodeSizePreset::Middle); ntype.gpu_fn = file_ns::node_shader_gpu_bsdf_toon; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } diff --git a/source/blender/nodes/shader/nodes/node_shader_bsdf_translucent.cc b/source/blender/nodes/shader/nodes/node_shader_bsdf_translucent.cc index 140ec8d24df..db701a9777a 100644 --- a/source/blender/nodes/shader/nodes/node_shader_bsdf_translucent.cc +++ b/source/blender/nodes/shader/nodes/node_shader_bsdf_translucent.cc @@ -64,5 +64,5 @@ void register_node_type_sh_bsdf_translucent() ntype.gpu_fn = file_ns::node_shader_gpu_bsdf_translucent; ntype.materialx_fn = file_ns::node_shader_materialx; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } diff --git a/source/blender/nodes/shader/nodes/node_shader_bsdf_transparent.cc b/source/blender/nodes/shader/nodes/node_shader_bsdf_transparent.cc index bb7bb27dd1f..1597814543b 100644 --- a/source/blender/nodes/shader/nodes/node_shader_bsdf_transparent.cc +++ b/source/blender/nodes/shader/nodes/node_shader_bsdf_transparent.cc @@ -70,5 +70,5 @@ void register_node_type_sh_bsdf_transparent() ntype.gpu_fn = file_ns::node_shader_gpu_bsdf_transparent; ntype.materialx_fn = file_ns::node_shader_materialx; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } diff --git a/source/blender/nodes/shader/nodes/node_shader_bump.cc b/source/blender/nodes/shader/nodes/node_shader_bump.cc index 2903bf5dc90..e93271eab5b 100644 --- a/source/blender/nodes/shader/nodes/node_shader_bump.cc +++ b/source/blender/nodes/shader/nodes/node_shader_bump.cc @@ -127,5 +127,5 @@ void register_node_type_sh_bump() ntype.gpu_fn = file_ns::gpu_shader_bump; ntype.materialx_fn = file_ns::node_shader_materialx; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } diff --git a/source/blender/nodes/shader/nodes/node_shader_camera.cc b/source/blender/nodes/shader/nodes/node_shader_camera.cc index e7533761480..fca82dd5a6f 100644 --- a/source/blender/nodes/shader/nodes/node_shader_camera.cc +++ b/source/blender/nodes/shader/nodes/node_shader_camera.cc @@ -54,5 +54,5 @@ void register_node_type_sh_camera() ntype.gpu_fn = file_ns::gpu_shader_camera; ntype.materialx_fn = file_ns::node_shader_materialx; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } diff --git a/source/blender/nodes/shader/nodes/node_shader_clamp.cc b/source/blender/nodes/shader/nodes/node_shader_clamp.cc index 21cec997d75..e0651c239da 100644 --- a/source/blender/nodes/shader/nodes/node_shader_clamp.cc +++ b/source/blender/nodes/shader/nodes/node_shader_clamp.cc @@ -111,5 +111,5 @@ void register_node_type_sh_clamp() ntype.build_multi_function = file_ns::sh_node_clamp_build_multi_function; ntype.materialx_fn = file_ns::node_shader_materialx; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } diff --git a/source/blender/nodes/shader/nodes/node_shader_color_ramp.cc b/source/blender/nodes/shader/nodes/node_shader_color_ramp.cc index 8e2f142f082..5fa06f893cc 100644 --- a/source/blender/nodes/shader/nodes/node_shader_color_ramp.cc +++ b/source/blender/nodes/shader/nodes/node_shader_color_ramp.cc @@ -169,12 +169,12 @@ void register_node_type_sh_valtorgb() ntype.nclass = NODE_CLASS_CONVERTER; ntype.declare = file_ns::sh_node_valtorgb_declare; ntype.initfunc = file_ns::node_shader_init_valtorgb; - blender::bke::node_type_size_preset(&ntype, blender::bke::eNodeSizePreset::Large); + blender::bke::node_type_size_preset(ntype, blender::bke::eNodeSizePreset::Large); blender::bke::node_type_storage( - &ntype, "ColorBand", node_free_standard_storage, node_copy_standard_storage); + ntype, "ColorBand", node_free_standard_storage, node_copy_standard_storage); ntype.gpu_fn = file_ns::gpu_shader_valtorgb; ntype.build_multi_function = file_ns::sh_node_valtorgb_build_multi_function; ntype.materialx_fn = file_ns::node_shader_materialx; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } diff --git a/source/blender/nodes/shader/nodes/node_shader_common.cc b/source/blender/nodes/shader/nodes/node_shader_common.cc index 6a56ca1102a..d4a338858f3 100644 --- a/source/blender/nodes/shader/nodes/node_shader_common.cc +++ b/source/blender/nodes/shader/nodes/node_shader_common.cc @@ -85,7 +85,7 @@ void register_node_type_sh_group() * to the shared #NODE_GROUP integer type id. */ blender::bke::node_type_base_custom( - &ntype, "ShaderNodeGroup", "Group", "GROUP", NODE_CLASS_GROUP); + ntype, "ShaderNodeGroup", "Group", "GROUP", NODE_CLASS_GROUP); ntype.enum_name_legacy = "GROUP"; ntype.type_legacy = NODE_GROUP; ntype.poll = sh_node_poll_default; @@ -97,12 +97,12 @@ void register_node_type_sh_group() BLI_assert(ntype.rna_ext.srna != nullptr); RNA_struct_blender_type_set(ntype.rna_ext.srna, &ntype); - blender::bke::node_type_size(&ntype, 140, 60, 400); + blender::bke::node_type_size(ntype, 140, 60, 400); ntype.labelfunc = node_group_label; ntype.declare = blender::nodes::node_group_declare; ntype.gpu_fn = gpu_group_execute; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } void register_node_type_sh_custom_group(blender::bke::bNodeType *ntype) diff --git a/source/blender/nodes/shader/nodes/node_shader_curves.cc b/source/blender/nodes/shader/nodes/node_shader_curves.cc index 93ec89f8820..1761b246dac 100644 --- a/source/blender/nodes/shader/nodes/node_shader_curves.cc +++ b/source/blender/nodes/shader/nodes/node_shader_curves.cc @@ -139,13 +139,13 @@ void register_node_type_sh_curve_vec() ntype.nclass = NODE_CLASS_OP_VECTOR; ntype.declare = file_ns::sh_node_curve_vec_declare; ntype.initfunc = file_ns::node_shader_init_curve_vec; - blender::bke::node_type_size_preset(&ntype, blender::bke::eNodeSizePreset::Large); - blender::bke::node_type_storage(&ntype, "CurveMapping", node_free_curves, node_copy_curves); + blender::bke::node_type_size_preset(ntype, blender::bke::eNodeSizePreset::Large); + blender::bke::node_type_storage(ntype, "CurveMapping", node_free_curves, node_copy_curves); ntype.gpu_fn = file_ns::gpu_shader_curve_vec; ntype.build_multi_function = file_ns::sh_node_curve_vec_build_multi_function; ntype.materialx_fn = file_ns::node_shader_materialx; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } /* **************** CURVE RGB ******************** */ @@ -303,13 +303,13 @@ void register_node_type_sh_curve_rgb() ntype.nclass = NODE_CLASS_OP_COLOR; ntype.declare = file_ns::sh_node_curve_rgb_declare; ntype.initfunc = file_ns::node_shader_init_curve_rgb; - blender::bke::node_type_size_preset(&ntype, blender::bke::eNodeSizePreset::Large); - blender::bke::node_type_storage(&ntype, "CurveMapping", node_free_curves, node_copy_curves); + blender::bke::node_type_size_preset(ntype, blender::bke::eNodeSizePreset::Large); + blender::bke::node_type_storage(ntype, "CurveMapping", node_free_curves, node_copy_curves); ntype.gpu_fn = file_ns::gpu_shader_curve_rgb; ntype.build_multi_function = file_ns::sh_node_curve_rgb_build_multi_function; ntype.materialx_fn = file_ns::node_shader_materialx; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } /* **************** CURVE FLOAT ******************** */ @@ -435,11 +435,11 @@ void register_node_type_sh_curve_float() ntype.nclass = NODE_CLASS_CONVERTER; ntype.declare = file_ns::sh_node_curve_float_declare; ntype.initfunc = file_ns::node_shader_init_curve_float; - blender::bke::node_type_size_preset(&ntype, blender::bke::eNodeSizePreset::Large); - blender::bke::node_type_storage(&ntype, "CurveMapping", node_free_curves, node_copy_curves); + blender::bke::node_type_size_preset(ntype, blender::bke::eNodeSizePreset::Large); + blender::bke::node_type_storage(ntype, "CurveMapping", node_free_curves, node_copy_curves); ntype.gpu_fn = file_ns::gpu_shader_curve_float; ntype.build_multi_function = file_ns::sh_node_curve_float_build_multi_function; ntype.materialx_fn = file_ns::node_shader_materialx; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } diff --git a/source/blender/nodes/shader/nodes/node_shader_displacement.cc b/source/blender/nodes/shader/nodes/node_shader_displacement.cc index f8122120072..611530b2402 100644 --- a/source/blender/nodes/shader/nodes/node_shader_displacement.cc +++ b/source/blender/nodes/shader/nodes/node_shader_displacement.cc @@ -84,5 +84,5 @@ void register_node_type_sh_displacement() ntype.gpu_fn = file_ns::gpu_shader_displacement; ntype.materialx_fn = file_ns::node_shader_materialx; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } diff --git a/source/blender/nodes/shader/nodes/node_shader_eevee_specular.cc b/source/blender/nodes/shader/nodes/node_shader_eevee_specular.cc index 7b4b8de9837..d2fc742bad9 100644 --- a/source/blender/nodes/shader/nodes/node_shader_eevee_specular.cc +++ b/source/blender/nodes/shader/nodes/node_shader_eevee_specular.cc @@ -93,5 +93,5 @@ void register_node_type_sh_eevee_specular() ntype.add_ui_poll = object_eevee_shader_nodes_poll; ntype.gpu_fn = file_ns::node_shader_gpu_eevee_specular; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } diff --git a/source/blender/nodes/shader/nodes/node_shader_emission.cc b/source/blender/nodes/shader/nodes/node_shader_emission.cc index 210a7edd885..3d754525bf2 100644 --- a/source/blender/nodes/shader/nodes/node_shader_emission.cc +++ b/source/blender/nodes/shader/nodes/node_shader_emission.cc @@ -61,5 +61,5 @@ void register_node_type_sh_emission() ntype.gpu_fn = file_ns::node_shader_gpu_emission; ntype.materialx_fn = file_ns::node_shader_materialx; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } diff --git a/source/blender/nodes/shader/nodes/node_shader_fresnel.cc b/source/blender/nodes/shader/nodes/node_shader_fresnel.cc index 2434d1bbe5e..4bcd7ea9ea9 100644 --- a/source/blender/nodes/shader/nodes/node_shader_fresnel.cc +++ b/source/blender/nodes/shader/nodes/node_shader_fresnel.cc @@ -57,5 +57,5 @@ void register_node_type_sh_fresnel() ntype.gpu_fn = file_ns::node_shader_gpu_fresnel; ntype.materialx_fn = file_ns::node_shader_materialx; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } diff --git a/source/blender/nodes/shader/nodes/node_shader_gamma.cc b/source/blender/nodes/shader/nodes/node_shader_gamma.cc index f9a561b7b3c..d9054479e9e 100644 --- a/source/blender/nodes/shader/nodes/node_shader_gamma.cc +++ b/source/blender/nodes/shader/nodes/node_shader_gamma.cc @@ -59,5 +59,5 @@ void register_node_type_sh_gamma() ntype.gpu_fn = file_ns::node_shader_gpu_gamma; ntype.materialx_fn = file_ns::node_shader_materialx; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } diff --git a/source/blender/nodes/shader/nodes/node_shader_geometry.cc b/source/blender/nodes/shader/nodes/node_shader_geometry.cc index 83f431a87c4..df3f09df959 100644 --- a/source/blender/nodes/shader/nodes/node_shader_geometry.cc +++ b/source/blender/nodes/shader/nodes/node_shader_geometry.cc @@ -100,5 +100,5 @@ void register_node_type_sh_geometry() ntype.gpu_fn = file_ns::node_shader_gpu_geometry; ntype.materialx_fn = file_ns::node_shader_materialx; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } diff --git a/source/blender/nodes/shader/nodes/node_shader_hair_info.cc b/source/blender/nodes/shader/nodes/node_shader_hair_info.cc index c8f0c444038..bf88e038182 100644 --- a/source/blender/nodes/shader/nodes/node_shader_hair_info.cc +++ b/source/blender/nodes/shader/nodes/node_shader_hair_info.cc @@ -56,5 +56,5 @@ void register_node_type_sh_hair_info() ntype.gpu_fn = file_ns::node_shader_gpu_hair_info; ntype.materialx_fn = file_ns::node_shader_materialx; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } diff --git a/source/blender/nodes/shader/nodes/node_shader_holdout.cc b/source/blender/nodes/shader/nodes/node_shader_holdout.cc index 71eb975bb6d..1fafddf7903 100644 --- a/source/blender/nodes/shader/nodes/node_shader_holdout.cc +++ b/source/blender/nodes/shader/nodes/node_shader_holdout.cc @@ -42,5 +42,5 @@ void register_node_type_sh_holdout() ntype.declare = file_ns::node_declare; ntype.gpu_fn = file_ns::gpu_shader_rgb; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } diff --git a/source/blender/nodes/shader/nodes/node_shader_hueSatVal.cc b/source/blender/nodes/shader/nodes/node_shader_hueSatVal.cc index 216d4844736..59a1270be2a 100644 --- a/source/blender/nodes/shader/nodes/node_shader_hueSatVal.cc +++ b/source/blender/nodes/shader/nodes/node_shader_hueSatVal.cc @@ -87,9 +87,9 @@ void register_node_type_sh_hue_sat() ntype.enum_name_legacy = "HUE_SAT"; ntype.nclass = NODE_CLASS_OP_COLOR; ntype.declare = file_ns::node_declare; - blender::bke::node_type_size_preset(&ntype, blender::bke::eNodeSizePreset::Middle); + blender::bke::node_type_size_preset(ntype, blender::bke::eNodeSizePreset::Middle); ntype.gpu_fn = file_ns::gpu_shader_hue_sat; ntype.materialx_fn = file_ns::node_shader_materialx; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } diff --git a/source/blender/nodes/shader/nodes/node_shader_ies_light.cc b/source/blender/nodes/shader/nodes/node_shader_ies_light.cc index 403562ef7a7..23efbfb6225 100644 --- a/source/blender/nodes/shader/nodes/node_shader_ies_light.cc +++ b/source/blender/nodes/shader/nodes/node_shader_ies_light.cc @@ -68,7 +68,7 @@ void register_node_type_sh_tex_ies() ntype.draw_buttons = file_ns::node_shader_buts_ies; ntype.initfunc = file_ns::node_shader_init_tex_ies; blender::bke::node_type_storage( - &ntype, "NodeShaderTexIES", node_free_standard_storage, node_copy_standard_storage); + ntype, "NodeShaderTexIES", node_free_standard_storage, node_copy_standard_storage); - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } diff --git a/source/blender/nodes/shader/nodes/node_shader_invert.cc b/source/blender/nodes/shader/nodes/node_shader_invert.cc index 41d757b2cb3..ad7286a9709 100644 --- a/source/blender/nodes/shader/nodes/node_shader_invert.cc +++ b/source/blender/nodes/shader/nodes/node_shader_invert.cc @@ -60,5 +60,5 @@ void register_node_type_sh_invert() ntype.gpu_fn = file_ns::gpu_shader_invert; ntype.materialx_fn = file_ns::node_shader_materialx; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } diff --git a/source/blender/nodes/shader/nodes/node_shader_layer_weight.cc b/source/blender/nodes/shader/nodes/node_shader_layer_weight.cc index 0c6e54aa92f..d23ee3f2d63 100644 --- a/source/blender/nodes/shader/nodes/node_shader_layer_weight.cc +++ b/source/blender/nodes/shader/nodes/node_shader_layer_weight.cc @@ -57,5 +57,5 @@ void register_node_type_sh_layer_weight() ntype.gpu_fn = file_ns::node_shader_gpu_layer_weight; ntype.materialx_fn = file_ns::node_shader_materialx; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } diff --git a/source/blender/nodes/shader/nodes/node_shader_light_falloff.cc b/source/blender/nodes/shader/nodes/node_shader_light_falloff.cc index 440a29852dd..8a9a679fde4 100644 --- a/source/blender/nodes/shader/nodes/node_shader_light_falloff.cc +++ b/source/blender/nodes/shader/nodes/node_shader_light_falloff.cc @@ -63,9 +63,9 @@ void register_node_type_sh_light_falloff() ntype.enum_name_legacy = "LIGHT_FALLOFF"; ntype.nclass = NODE_CLASS_OP_COLOR; ntype.declare = file_ns::node_declare; - blender::bke::node_type_size_preset(&ntype, blender::bke::eNodeSizePreset::Middle); + blender::bke::node_type_size_preset(ntype, blender::bke::eNodeSizePreset::Middle); ntype.gpu_fn = file_ns::node_shader_gpu_light_falloff; ntype.materialx_fn = file_ns::node_shader_materialx; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } diff --git a/source/blender/nodes/shader/nodes/node_shader_light_path.cc b/source/blender/nodes/shader/nodes/node_shader_light_path.cc index 41ae166123a..75fc41f2984 100644 --- a/source/blender/nodes/shader/nodes/node_shader_light_path.cc +++ b/source/blender/nodes/shader/nodes/node_shader_light_path.cc @@ -69,5 +69,5 @@ void register_node_type_sh_light_path() ntype.gpu_fn = file_ns::node_shader_gpu_light_path; ntype.materialx_fn = file_ns::node_shader_materialx; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } diff --git a/source/blender/nodes/shader/nodes/node_shader_map_range.cc b/source/blender/nodes/shader/nodes/node_shader_map_range.cc index 6254a883b40..aef4bce6cd9 100644 --- a/source/blender/nodes/shader/nodes/node_shader_map_range.cc +++ b/source/blender/nodes/shader/nodes/node_shader_map_range.cc @@ -97,10 +97,10 @@ static void node_shader_update_map_range(bNodeTree *ntree, bNode *node) } LISTBASE_FOREACH_INDEX (bNodeSocket *, socket, &node->inputs, index) { - bke::node_set_socket_availability(ntree, socket, new_input_availability[index]); + bke::node_set_socket_availability(*ntree, *socket, new_input_availability[index]); } LISTBASE_FOREACH_INDEX (bNodeSocket *, socket, &node->outputs, index) { - bke::node_set_socket_availability(ntree, socket, new_output_availability[index]); + bke::node_set_socket_availability(*ntree, *socket, new_output_availability[index]); } } @@ -534,11 +534,11 @@ void register_node_type_sh_map_range() ntype.ui_class = file_ns::node_shader_map_range_ui_class; ntype.initfunc = file_ns::node_shader_init_map_range; blender::bke::node_type_storage( - &ntype, "NodeMapRange", node_free_standard_storage, node_copy_standard_storage); + ntype, "NodeMapRange", node_free_standard_storage, node_copy_standard_storage); ntype.updatefunc = file_ns::node_shader_update_map_range; ntype.gpu_fn = file_ns::gpu_shader_map_range; ntype.build_multi_function = file_ns::sh_node_map_range_build_multi_function; ntype.gather_link_search_ops = file_ns::node_map_range_gather_link_searches; ntype.materialx_fn = file_ns::node_shader_materialx; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } diff --git a/source/blender/nodes/shader/nodes/node_shader_mapping.cc b/source/blender/nodes/shader/nodes/node_shader_mapping.cc index 9a753fb5799..11c1db6ec71 100644 --- a/source/blender/nodes/shader/nodes/node_shader_mapping.cc +++ b/source/blender/nodes/shader/nodes/node_shader_mapping.cc @@ -76,9 +76,9 @@ static int gpu_shader_mapping(GPUMaterial *mat, static void node_shader_update_mapping(bNodeTree *ntree, bNode *node) { - bNodeSocket *sock = bke::node_find_socket(node, SOCK_IN, "Location"); + bNodeSocket *sock = bke::node_find_socket(*node, SOCK_IN, "Location"); bke::node_set_socket_availability( - ntree, sock, ELEM(node->custom1, NODE_MAPPING_TYPE_POINT, NODE_MAPPING_TYPE_TEXTURE)); + *ntree, *sock, ELEM(node->custom1, NODE_MAPPING_TYPE_POINT, NODE_MAPPING_TYPE_TEXTURE)); } NODE_SHADER_MATERIALX_BEGIN @@ -132,5 +132,5 @@ void register_node_type_sh_mapping() ntype.updatefunc = file_ns::node_shader_update_mapping; ntype.materialx_fn = file_ns::node_shader_materialx; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } diff --git a/source/blender/nodes/shader/nodes/node_shader_math.cc b/source/blender/nodes/shader/nodes/node_shader_math.cc index dd0fb449417..11ec6c9502c 100644 --- a/source/blender/nodes/shader/nodes/node_shader_math.cc +++ b/source/blender/nodes/shader/nodes/node_shader_math.cc @@ -377,5 +377,5 @@ void register_node_type_sh_math() ntype.eval_inverse_elem = file_ns::node_eval_inverse_elem; ntype.eval_inverse = file_ns::node_eval_inverse; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } diff --git a/source/blender/nodes/shader/nodes/node_shader_mix.cc b/source/blender/nodes/shader/nodes/node_shader_mix.cc index dd339240496..311bfb289ba 100644 --- a/source/blender/nodes/shader/nodes/node_shader_mix.cc +++ b/source/blender/nodes/shader/nodes/node_shader_mix.cc @@ -158,16 +158,16 @@ static void sh_node_mix_update(bNodeTree *ntree, bNode *node) bool use_vector_factor = data_type == SOCK_VECTOR && storage.factor_mode != NODE_MIX_MODE_UNIFORM; - bke::node_set_socket_availability(ntree, sock_factor, !use_vector_factor); + bke::node_set_socket_availability(*ntree, *sock_factor, !use_vector_factor); - bke::node_set_socket_availability(ntree, sock_factor_vec, use_vector_factor); + bke::node_set_socket_availability(*ntree, *sock_factor_vec, use_vector_factor); for (bNodeSocket *socket = sock_factor_vec->next; socket != nullptr; socket = socket->next) { - bke::node_set_socket_availability(ntree, socket, socket->type == data_type); + bke::node_set_socket_availability(*ntree, *socket, socket->type == data_type); } LISTBASE_FOREACH (bNodeSocket *, socket, &node->outputs) { - bke::node_set_socket_availability(ntree, socket, socket->type == data_type); + bke::node_set_socket_availability(*ntree, *socket, socket->type == data_type); } } @@ -610,12 +610,12 @@ void register_node_type_sh_mix() ntype.updatefunc = file_ns::sh_node_mix_update; ntype.initfunc = file_ns::node_mix_init; blender::bke::node_type_storage( - &ntype, "NodeShaderMix", node_free_standard_storage, node_copy_standard_storage); + ntype, "NodeShaderMix", node_free_standard_storage, node_copy_standard_storage); ntype.build_multi_function = file_ns::sh_node_mix_build_multi_function; ntype.draw_buttons = file_ns::sh_node_mix_layout; ntype.labelfunc = file_ns::sh_node_mix_label; ntype.gather_link_search_ops = file_ns::node_mix_gather_link_searches; ntype.materialx_fn = file_ns::node_shader_materialx; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } diff --git a/source/blender/nodes/shader/nodes/node_shader_mix_rgb.cc b/source/blender/nodes/shader/nodes/node_shader_mix_rgb.cc index 1ac27f6ee1c..ac20b82822d 100644 --- a/source/blender/nodes/shader/nodes/node_shader_mix_rgb.cc +++ b/source/blender/nodes/shader/nodes/node_shader_mix_rgb.cc @@ -168,5 +168,5 @@ void register_node_type_sh_mix_rgb() ntype.gpu_fn = file_ns::gpu_shader_mix_rgb; ntype.build_multi_function = file_ns::sh_node_mix_rgb_build_multi_function; ntype.gather_link_search_ops = nullptr; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } diff --git a/source/blender/nodes/shader/nodes/node_shader_mix_shader.cc b/source/blender/nodes/shader/nodes/node_shader_mix_shader.cc index a5ae8628932..7440c31c8a1 100644 --- a/source/blender/nodes/shader/nodes/node_shader_mix_shader.cc +++ b/source/blender/nodes/shader/nodes/node_shader_mix_shader.cc @@ -74,5 +74,5 @@ void register_node_type_sh_mix_shader() ntype.gpu_fn = file_ns::node_shader_gpu_mix_shader; ntype.materialx_fn = file_ns::node_shader_materialx; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } diff --git a/source/blender/nodes/shader/nodes/node_shader_normal.cc b/source/blender/nodes/shader/nodes/node_shader_normal.cc index 54676cb1cf1..1b3a05c9f72 100644 --- a/source/blender/nodes/shader/nodes/node_shader_normal.cc +++ b/source/blender/nodes/shader/nodes/node_shader_normal.cc @@ -70,5 +70,5 @@ void register_node_type_sh_normal() ntype.gpu_fn = file_ns::gpu_shader_normal; ntype.materialx_fn = file_ns::node_shader_materialx; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } diff --git a/source/blender/nodes/shader/nodes/node_shader_normal_map.cc b/source/blender/nodes/shader/nodes/node_shader_normal_map.cc index 1b92c079e1b..96f7cebda33 100644 --- a/source/blender/nodes/shader/nodes/node_shader_normal_map.cc +++ b/source/blender/nodes/shader/nodes/node_shader_normal_map.cc @@ -202,12 +202,12 @@ void register_node_type_sh_normal_map() ntype.nclass = NODE_CLASS_OP_VECTOR; ntype.declare = file_ns::node_declare; ntype.draw_buttons = file_ns::node_shader_buts_normal_map; - blender::bke::node_type_size_preset(&ntype, blender::bke::eNodeSizePreset::Middle); + blender::bke::node_type_size_preset(ntype, blender::bke::eNodeSizePreset::Middle); ntype.initfunc = file_ns::node_shader_init_normal_map; blender::bke::node_type_storage( - &ntype, "NodeShaderNormalMap", node_free_standard_storage, node_copy_standard_storage); + ntype, "NodeShaderNormalMap", node_free_standard_storage, node_copy_standard_storage); ntype.gpu_fn = file_ns::gpu_shader_normal_map; ntype.materialx_fn = file_ns::node_shader_materialx; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } diff --git a/source/blender/nodes/shader/nodes/node_shader_object_info.cc b/source/blender/nodes/shader/nodes/node_shader_object_info.cc index b1291fb5b4d..87b0991de69 100644 --- a/source/blender/nodes/shader/nodes/node_shader_object_info.cc +++ b/source/blender/nodes/shader/nodes/node_shader_object_info.cc @@ -68,5 +68,5 @@ void register_node_type_sh_object_info() ntype.gpu_fn = file_ns::node_shader_gpu_object_info; ntype.materialx_fn = file_ns::node_shader_materialx; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } diff --git a/source/blender/nodes/shader/nodes/node_shader_output_aov.cc b/source/blender/nodes/shader/nodes/node_shader_output_aov.cc index f301033778c..3f6c3a1b75a 100644 --- a/source/blender/nodes/shader/nodes/node_shader_output_aov.cc +++ b/source/blender/nodes/shader/nodes/node_shader_output_aov.cc @@ -70,10 +70,10 @@ void register_node_type_sh_output_aov() ntype.draw_buttons = file_ns::node_shader_buts_output_aov; ntype.initfunc = file_ns::node_shader_init_output_aov; blender::bke::node_type_storage( - &ntype, "NodeShaderOutputAOV", node_free_standard_storage, node_copy_standard_storage); + ntype, "NodeShaderOutputAOV", node_free_standard_storage, node_copy_standard_storage); ntype.gpu_fn = file_ns::node_shader_gpu_output_aov; ntype.no_muting = true; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } diff --git a/source/blender/nodes/shader/nodes/node_shader_output_light.cc b/source/blender/nodes/shader/nodes/node_shader_output_light.cc index cda6a4a26c0..57f23e1d60f 100644 --- a/source/blender/nodes/shader/nodes/node_shader_output_light.cc +++ b/source/blender/nodes/shader/nodes/node_shader_output_light.cc @@ -47,5 +47,5 @@ void register_node_type_sh_output_light() ntype.no_muting = true; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } diff --git a/source/blender/nodes/shader/nodes/node_shader_output_linestyle.cc b/source/blender/nodes/shader/nodes/node_shader_output_linestyle.cc index 8f583924fb3..34344fee3f1 100644 --- a/source/blender/nodes/shader/nodes/node_shader_output_linestyle.cc +++ b/source/blender/nodes/shader/nodes/node_shader_output_linestyle.cc @@ -53,5 +53,5 @@ void register_node_type_sh_output_linestyle() ntype.draw_buttons = file_ns::node_buts_output_linestyle; ntype.no_muting = true; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } diff --git a/source/blender/nodes/shader/nodes/node_shader_output_material.cc b/source/blender/nodes/shader/nodes/node_shader_output_material.cc index 8dc954774f2..2f7c01a8d96 100644 --- a/source/blender/nodes/shader/nodes/node_shader_output_material.cc +++ b/source/blender/nodes/shader/nodes/node_shader_output_material.cc @@ -90,5 +90,5 @@ void register_node_type_sh_output_material() ntype.no_muting = true; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } diff --git a/source/blender/nodes/shader/nodes/node_shader_output_world.cc b/source/blender/nodes/shader/nodes/node_shader_output_world.cc index 179754d8eed..be09f7d60ad 100644 --- a/source/blender/nodes/shader/nodes/node_shader_output_world.cc +++ b/source/blender/nodes/shader/nodes/node_shader_output_world.cc @@ -50,5 +50,5 @@ void register_node_type_sh_output_world() ntype.no_muting = true; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } diff --git a/source/blender/nodes/shader/nodes/node_shader_particle_info.cc b/source/blender/nodes/shader/nodes/node_shader_particle_info.cc index f740a0002ed..b4648c94088 100644 --- a/source/blender/nodes/shader/nodes/node_shader_particle_info.cc +++ b/source/blender/nodes/shader/nodes/node_shader_particle_info.cc @@ -61,5 +61,5 @@ void register_node_type_sh_particle_info() ntype.gpu_fn = file_ns::gpu_shader_particle_info; ntype.materialx_fn = file_ns::node_shader_materialx; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } diff --git a/source/blender/nodes/shader/nodes/node_shader_point_info.cc b/source/blender/nodes/shader/nodes/node_shader_point_info.cc index 8e33b550fa5..59a8ae89228 100644 --- a/source/blender/nodes/shader/nodes/node_shader_point_info.cc +++ b/source/blender/nodes/shader/nodes/node_shader_point_info.cc @@ -49,5 +49,5 @@ void register_node_type_sh_point_info() ntype.gpu_fn = file_ns::node_shader_gpu_point_info; ntype.materialx_fn = file_ns::node_shader_materialx; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } diff --git a/source/blender/nodes/shader/nodes/node_shader_rgb.cc b/source/blender/nodes/shader/nodes/node_shader_rgb.cc index 3f3e2ac211b..cc6bcbb5888 100644 --- a/source/blender/nodes/shader/nodes/node_shader_rgb.cc +++ b/source/blender/nodes/shader/nodes/node_shader_rgb.cc @@ -52,5 +52,5 @@ void register_node_type_sh_rgb() ntype.gpu_fn = file_ns::gpu_shader_rgb; ntype.materialx_fn = file_ns::node_shader_materialx; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } diff --git a/source/blender/nodes/shader/nodes/node_shader_rgb_to_bw.cc b/source/blender/nodes/shader/nodes/node_shader_rgb_to_bw.cc index b4ae1c96b26..856b89130c8 100644 --- a/source/blender/nodes/shader/nodes/node_shader_rgb_to_bw.cc +++ b/source/blender/nodes/shader/nodes/node_shader_rgb_to_bw.cc @@ -57,5 +57,5 @@ void register_node_type_sh_rgbtobw() ntype.gpu_fn = file_ns::gpu_shader_rgbtobw; ntype.materialx_fn = file_ns::node_shader_materialx; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } diff --git a/source/blender/nodes/shader/nodes/node_shader_script.cc b/source/blender/nodes/shader/nodes/node_shader_script.cc index d434fefe8d6..92e0e59c149 100644 --- a/source/blender/nodes/shader/nodes/node_shader_script.cc +++ b/source/blender/nodes/shader/nodes/node_shader_script.cc @@ -98,7 +98,7 @@ void register_node_type_sh_script() ntype.draw_buttons_ex = file_ns::node_shader_buts_script_ex; ntype.initfunc = file_ns::init; blender::bke::node_type_storage( - &ntype, "NodeShaderScript", file_ns::node_free_script, file_ns::node_copy_script); + ntype, "NodeShaderScript", file_ns::node_free_script, file_ns::node_copy_script); - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } diff --git a/source/blender/nodes/shader/nodes/node_shader_sepcomb_color.cc b/source/blender/nodes/shader/nodes/node_shader_sepcomb_color.cc index 5f8f443573c..eef7790cf86 100644 --- a/source/blender/nodes/shader/nodes/node_shader_sepcomb_color.cc +++ b/source/blender/nodes/shader/nodes/node_shader_sepcomb_color.cc @@ -108,11 +108,11 @@ void register_node_type_sh_sepcolor() ntype.updatefunc = file_ns::node_sepcolor_update; ntype.initfunc = node_combsep_color_init; blender::bke::node_type_storage( - &ntype, "NodeCombSepColor", node_free_standard_storage, node_copy_standard_storage); + ntype, "NodeCombSepColor", node_free_standard_storage, node_copy_standard_storage); ntype.gpu_fn = file_ns::gpu_shader_sepcolor; ntype.materialx_fn = file_ns::node_shader_materialx; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } /* **************** COMBINE COLOR ******************** */ @@ -213,9 +213,9 @@ void register_node_type_sh_combcolor() ntype.updatefunc = file_ns::node_combcolor_update; ntype.initfunc = node_combsep_color_init; blender::bke::node_type_storage( - &ntype, "NodeCombSepColor", node_free_standard_storage, node_copy_standard_storage); + ntype, "NodeCombSepColor", node_free_standard_storage, node_copy_standard_storage); ntype.gpu_fn = file_ns::gpu_shader_combcolor; ntype.materialx_fn = file_ns::node_shader_materialx; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } diff --git a/source/blender/nodes/shader/nodes/node_shader_sepcomb_hsv.cc b/source/blender/nodes/shader/nodes/node_shader_sepcomb_hsv.cc index 7d9f18c7e58..2d156266398 100644 --- a/source/blender/nodes/shader/nodes/node_shader_sepcomb_hsv.cc +++ b/source/blender/nodes/shader/nodes/node_shader_sepcomb_hsv.cc @@ -46,7 +46,7 @@ void register_node_type_sh_sephsv() ntype.gpu_fn = file_ns::gpu_shader_sephsv; ntype.gather_link_search_ops = nullptr; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } namespace blender::nodes::node_shader_sepcomb_hsv_cc { @@ -87,5 +87,5 @@ void register_node_type_sh_combhsv() ntype.gpu_fn = file_ns::gpu_shader_combhsv; ntype.gather_link_search_ops = nullptr; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } diff --git a/source/blender/nodes/shader/nodes/node_shader_sepcomb_rgb.cc b/source/blender/nodes/shader/nodes/node_shader_sepcomb_rgb.cc index 35d5fced42a..801ffd42ff5 100644 --- a/source/blender/nodes/shader/nodes/node_shader_sepcomb_rgb.cc +++ b/source/blender/nodes/shader/nodes/node_shader_sepcomb_rgb.cc @@ -89,7 +89,7 @@ void register_node_type_sh_seprgb() ntype.build_multi_function = file_ns::sh_node_seprgb_build_multi_function; ntype.gather_link_search_ops = nullptr; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } namespace blender::nodes::node_shader_sepcomb_rgb_cc { @@ -137,5 +137,5 @@ void register_node_type_sh_combrgb() ntype.build_multi_function = file_ns::sh_node_combrgb_build_multi_function; ntype.gather_link_search_ops = nullptr; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } diff --git a/source/blender/nodes/shader/nodes/node_shader_sepcomb_xyz.cc b/source/blender/nodes/shader/nodes/node_shader_sepcomb_xyz.cc index 59219b8f346..1039de8d834 100644 --- a/source/blender/nodes/shader/nodes/node_shader_sepcomb_xyz.cc +++ b/source/blender/nodes/shader/nodes/node_shader_sepcomb_xyz.cc @@ -150,7 +150,7 @@ void register_node_type_sh_sepxyz() ntype.eval_inverse_elem = file_ns::sh_node_sepxyz_eval_inverse_elem; ntype.eval_inverse = file_ns::sh_node_sepxyz_eval_inverse; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } namespace blender::nodes::node_shader_sepcomb_xyz_cc::comb { @@ -242,5 +242,5 @@ void register_node_type_sh_combxyz() ntype.eval_inverse_elem = file_ns::sh_node_combxyz_eval_inverse_elem; ntype.eval_inverse = file_ns::sh_node_combxyz_eval_inverse; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } diff --git a/source/blender/nodes/shader/nodes/node_shader_shader_to_rgb.cc b/source/blender/nodes/shader/nodes/node_shader_shader_to_rgb.cc index 01c2ed7f27a..9e2f6cbc631 100644 --- a/source/blender/nodes/shader/nodes/node_shader_shader_to_rgb.cc +++ b/source/blender/nodes/shader/nodes/node_shader_shader_to_rgb.cc @@ -45,5 +45,5 @@ void register_node_type_sh_shadertorgb() ntype.add_ui_poll = object_eevee_shader_nodes_poll; ntype.gpu_fn = file_ns::node_shader_gpu_shadertorgb; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } diff --git a/source/blender/nodes/shader/nodes/node_shader_squeeze.cc b/source/blender/nodes/shader/nodes/node_shader_squeeze.cc index 6c5d33a3caf..8a7d0ebb27e 100644 --- a/source/blender/nodes/shader/nodes/node_shader_squeeze.cc +++ b/source/blender/nodes/shader/nodes/node_shader_squeeze.cc @@ -44,5 +44,5 @@ void register_node_type_sh_squeeze() ntype.declare = file_ns::node_declare; ntype.gpu_fn = file_ns::gpu_shader_squeeze; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } diff --git a/source/blender/nodes/shader/nodes/node_shader_subsurface_scattering.cc b/source/blender/nodes/shader/nodes/node_shader_subsurface_scattering.cc index a6519cc623a..32bb291b255 100644 --- a/source/blender/nodes/shader/nodes/node_shader_subsurface_scattering.cc +++ b/source/blender/nodes/shader/nodes/node_shader_subsurface_scattering.cc @@ -71,10 +71,10 @@ static void node_shader_update_subsurface_scattering(bNodeTree *ntree, bNode *no LISTBASE_FOREACH (bNodeSocket *, sock, &node->inputs) { if (STR_ELEM(sock->name, "IOR", "Anisotropy")) { - bke::node_set_socket_availability(ntree, sock, sss_method != SHD_SUBSURFACE_BURLEY); + bke::node_set_socket_availability(*ntree, *sock, sss_method != SHD_SUBSURFACE_BURLEY); } if (STR_ELEM(sock->name, "Roughness")) { - bke::node_set_socket_availability(ntree, sock, sss_method == SHD_SUBSURFACE_RANDOM_WALK); + bke::node_set_socket_availability(*ntree, *sock, sss_method == SHD_SUBSURFACE_RANDOM_WALK); } } } @@ -127,11 +127,11 @@ void register_node_type_sh_subsurface_scattering() ntype.declare = file_ns::node_declare; ntype.add_ui_poll = object_shader_nodes_poll; ntype.draw_buttons = file_ns::node_shader_buts_subsurface; - blender::bke::node_type_size_preset(&ntype, blender::bke::eNodeSizePreset::Middle); + blender::bke::node_type_size_preset(ntype, blender::bke::eNodeSizePreset::Middle); ntype.initfunc = file_ns::node_shader_init_subsurface_scattering; ntype.gpu_fn = file_ns::node_shader_gpu_subsurface_scattering; ntype.updatefunc = file_ns::node_shader_update_subsurface_scattering; ntype.materialx_fn = file_ns::node_shader_materialx; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } diff --git a/source/blender/nodes/shader/nodes/node_shader_tangent.cc b/source/blender/nodes/shader/nodes/node_shader_tangent.cc index dfe8b381732..64c26bc324f 100644 --- a/source/blender/nodes/shader/nodes/node_shader_tangent.cc +++ b/source/blender/nodes/shader/nodes/node_shader_tangent.cc @@ -112,12 +112,12 @@ void register_node_type_sh_tangent() ntype.nclass = NODE_CLASS_INPUT; ntype.declare = file_ns::node_declare; ntype.draw_buttons = file_ns::node_shader_buts_tangent; - blender::bke::node_type_size_preset(&ntype, blender::bke::eNodeSizePreset::Middle); + blender::bke::node_type_size_preset(ntype, blender::bke::eNodeSizePreset::Middle); ntype.initfunc = file_ns::node_shader_init_tangent; ntype.gpu_fn = file_ns::node_shader_gpu_tangent; blender::bke::node_type_storage( - &ntype, "NodeShaderTangent", node_free_standard_storage, node_copy_standard_storage); + ntype, "NodeShaderTangent", node_free_standard_storage, node_copy_standard_storage); ntype.materialx_fn = file_ns::node_shader_materialx; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } diff --git a/source/blender/nodes/shader/nodes/node_shader_tex_brick.cc b/source/blender/nodes/shader/nodes/node_shader_tex_brick.cc index 208f51106e3..dd53796dbf0 100644 --- a/source/blender/nodes/shader/nodes/node_shader_tex_brick.cc +++ b/source/blender/nodes/shader/nodes/node_shader_tex_brick.cc @@ -308,12 +308,12 @@ void register_node_type_sh_tex_brick() ntype.nclass = NODE_CLASS_TEXTURE; ntype.declare = file_ns::sh_node_tex_brick_declare; ntype.draw_buttons = file_ns::node_shader_buts_tex_brick; - blender::bke::node_type_size_preset(&ntype, blender::bke::eNodeSizePreset::Middle); + blender::bke::node_type_size_preset(ntype, blender::bke::eNodeSizePreset::Middle); ntype.initfunc = file_ns::node_shader_init_tex_brick; blender::bke::node_type_storage( - &ntype, "NodeTexBrick", node_free_standard_storage, node_copy_standard_storage); + ntype, "NodeTexBrick", node_free_standard_storage, node_copy_standard_storage); ntype.gpu_fn = file_ns::node_shader_gpu_tex_brick; ntype.build_multi_function = file_ns::sh_node_brick_build_multi_function; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } diff --git a/source/blender/nodes/shader/nodes/node_shader_tex_checker.cc b/source/blender/nodes/shader/nodes/node_shader_tex_checker.cc index d89e09ea325..35106911c1a 100644 --- a/source/blender/nodes/shader/nodes/node_shader_tex_checker.cc +++ b/source/blender/nodes/shader/nodes/node_shader_tex_checker.cc @@ -147,10 +147,10 @@ void register_node_type_sh_tex_checker() ntype.declare = file_ns::sh_node_tex_checker_declare; ntype.initfunc = file_ns::node_shader_init_tex_checker; blender::bke::node_type_storage( - &ntype, "NodeTexChecker", node_free_standard_storage, node_copy_standard_storage); + ntype, "NodeTexChecker", node_free_standard_storage, node_copy_standard_storage); ntype.gpu_fn = file_ns::node_shader_gpu_tex_checker; ntype.build_multi_function = file_ns::sh_node_tex_checker_build_multi_function; ntype.materialx_fn = file_ns::node_shader_materialx; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } diff --git a/source/blender/nodes/shader/nodes/node_shader_tex_coord.cc b/source/blender/nodes/shader/nodes/node_shader_tex_coord.cc index 641a1d769d2..1519f5cc257 100644 --- a/source/blender/nodes/shader/nodes/node_shader_tex_coord.cc +++ b/source/blender/nodes/shader/nodes/node_shader_tex_coord.cc @@ -118,5 +118,5 @@ void register_node_type_sh_tex_coord() ntype.gpu_fn = file_ns::node_shader_gpu_tex_coord; ntype.materialx_fn = file_ns::node_shader_materialx; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } diff --git a/source/blender/nodes/shader/nodes/node_shader_tex_environment.cc b/source/blender/nodes/shader/nodes/node_shader_tex_environment.cc index 976c45bc077..33eeea69b6d 100644 --- a/source/blender/nodes/shader/nodes/node_shader_tex_environment.cc +++ b/source/blender/nodes/shader/nodes/node_shader_tex_environment.cc @@ -199,11 +199,11 @@ void register_node_type_sh_tex_environment() ntype.declare = file_ns::node_declare; ntype.initfunc = file_ns::node_shader_init_tex_environment; blender::bke::node_type_storage( - &ntype, "NodeTexEnvironment", node_free_standard_storage, node_copy_standard_storage); + ntype, "NodeTexEnvironment", node_free_standard_storage, node_copy_standard_storage); ntype.gpu_fn = file_ns::node_shader_gpu_tex_environment; ntype.labelfunc = node_image_label; - blender::bke::node_type_size_preset(&ntype, blender::bke::eNodeSizePreset::Large); + blender::bke::node_type_size_preset(ntype, blender::bke::eNodeSizePreset::Large); ntype.materialx_fn = file_ns::node_shader_materialx; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } diff --git a/source/blender/nodes/shader/nodes/node_shader_tex_gabor.cc b/source/blender/nodes/shader/nodes/node_shader_tex_gabor.cc index 4dcfbe60ddf..9bf077bf57c 100644 --- a/source/blender/nodes/shader/nodes/node_shader_tex_gabor.cc +++ b/source/blender/nodes/shader/nodes/node_shader_tex_gabor.cc @@ -80,13 +80,13 @@ static void node_shader_update_tex_gabor(bNodeTree *ntree, bNode *node) { const NodeTexGabor &storage = node_storage(*node); - bNodeSocket *orientation_2d_socket = bke::node_find_socket(node, SOCK_IN, "Orientation 2D"); + bNodeSocket *orientation_2d_socket = bke::node_find_socket(*node, SOCK_IN, "Orientation 2D"); bke::node_set_socket_availability( - ntree, orientation_2d_socket, storage.type == SHD_GABOR_TYPE_2D); + *ntree, *orientation_2d_socket, storage.type == SHD_GABOR_TYPE_2D); - bNodeSocket *orientation_3d_socket = bke::node_find_socket(node, SOCK_IN, "Orientation 3D"); + bNodeSocket *orientation_3d_socket = bke::node_find_socket(*node, SOCK_IN, "Orientation 3D"); bke::node_set_socket_availability( - ntree, orientation_3d_socket, storage.type == SHD_GABOR_TYPE_3D); + *ntree, *orientation_3d_socket, storage.type == SHD_GABOR_TYPE_3D); } static int node_shader_gpu_tex_gabor(GPUMaterial *material, @@ -215,11 +215,10 @@ void register_node_type_sh_tex_gabor() ntype.declare = file_ns::sh_node_tex_gabor_declare; ntype.draw_buttons = file_ns::node_shader_buts_tex_gabor; ntype.initfunc = file_ns::node_shader_init_tex_gabor; - node_type_storage( - &ntype, "NodeTexGabor", node_free_standard_storage, node_copy_standard_storage); + node_type_storage(ntype, "NodeTexGabor", node_free_standard_storage, node_copy_standard_storage); ntype.gpu_fn = file_ns::node_shader_gpu_tex_gabor; ntype.updatefunc = file_ns::node_shader_update_tex_gabor; ntype.build_multi_function = file_ns::build_multi_function; - node_register_type(&ntype); + node_register_type(ntype); } diff --git a/source/blender/nodes/shader/nodes/node_shader_tex_gradient.cc b/source/blender/nodes/shader/nodes/node_shader_tex_gradient.cc index 0a8d9a31695..844fdbc89ce 100644 --- a/source/blender/nodes/shader/nodes/node_shader_tex_gradient.cc +++ b/source/blender/nodes/shader/nodes/node_shader_tex_gradient.cc @@ -207,10 +207,10 @@ void register_node_type_sh_tex_gradient() ntype.draw_buttons = file_ns::node_shader_buts_tex_gradient; ntype.initfunc = file_ns::node_shader_init_tex_gradient; blender::bke::node_type_storage( - &ntype, "NodeTexGradient", node_free_standard_storage, node_copy_standard_storage); + ntype, "NodeTexGradient", node_free_standard_storage, node_copy_standard_storage); ntype.gpu_fn = file_ns::node_shader_gpu_tex_gradient; ntype.build_multi_function = file_ns::sh_node_gradient_tex_build_multi_function; ntype.materialx_fn = file_ns::node_shader_materialx; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } diff --git a/source/blender/nodes/shader/nodes/node_shader_tex_image.cc b/source/blender/nodes/shader/nodes/node_shader_tex_image.cc index 84e59031344..3f4e1629b45 100644 --- a/source/blender/nodes/shader/nodes/node_shader_tex_image.cc +++ b/source/blender/nodes/shader/nodes/node_shader_tex_image.cc @@ -286,11 +286,11 @@ void register_node_type_sh_tex_image() ntype.declare = file_ns::sh_node_tex_image_declare; ntype.initfunc = file_ns::node_shader_init_tex_image; blender::bke::node_type_storage( - &ntype, "NodeTexImage", node_free_standard_storage, node_copy_standard_storage); + ntype, "NodeTexImage", node_free_standard_storage, node_copy_standard_storage); ntype.gpu_fn = file_ns::node_shader_gpu_tex_image; ntype.labelfunc = node_image_label; - blender::bke::node_type_size_preset(&ntype, blender::bke::eNodeSizePreset::Large); + blender::bke::node_type_size_preset(ntype, blender::bke::eNodeSizePreset::Large); ntype.materialx_fn = file_ns::node_shader_materialx; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } diff --git a/source/blender/nodes/shader/nodes/node_shader_tex_magic.cc b/source/blender/nodes/shader/nodes/node_shader_tex_magic.cc index 5ea4f8fa608..1a5d29a9aea 100644 --- a/source/blender/nodes/shader/nodes/node_shader_tex_magic.cc +++ b/source/blender/nodes/shader/nodes/node_shader_tex_magic.cc @@ -192,9 +192,9 @@ void register_node_type_sh_tex_magic() ntype.draw_buttons = file_ns::node_shader_buts_tex_magic; ntype.initfunc = file_ns::node_shader_init_tex_magic; blender::bke::node_type_storage( - &ntype, "NodeTexMagic", node_free_standard_storage, node_copy_standard_storage); + ntype, "NodeTexMagic", node_free_standard_storage, node_copy_standard_storage); ntype.gpu_fn = file_ns::node_shader_gpu_tex_magic; ntype.build_multi_function = file_ns::sh_node_magic_tex_build_multi_function; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } diff --git a/source/blender/nodes/shader/nodes/node_shader_tex_noise.cc b/source/blender/nodes/shader/nodes/node_shader_tex_noise.cc index 95259021db9..5a1a50368f4 100644 --- a/source/blender/nodes/shader/nodes/node_shader_tex_noise.cc +++ b/source/blender/nodes/shader/nodes/node_shader_tex_noise.cc @@ -145,21 +145,21 @@ static int node_shader_gpu_tex_noise(GPUMaterial *mat, static void node_shader_update_tex_noise(bNodeTree *ntree, bNode *node) { - bNodeSocket *sockVector = bke::node_find_socket(node, SOCK_IN, "Vector"); - bNodeSocket *sockW = bke::node_find_socket(node, SOCK_IN, "W"); - bNodeSocket *inOffsetSock = bke::node_find_socket(node, SOCK_IN, "Offset"); - bNodeSocket *inGainSock = bke::node_find_socket(node, SOCK_IN, "Gain"); + bNodeSocket *sockVector = bke::node_find_socket(*node, SOCK_IN, "Vector"); + bNodeSocket *sockW = bke::node_find_socket(*node, SOCK_IN, "W"); + bNodeSocket *inOffsetSock = bke::node_find_socket(*node, SOCK_IN, "Offset"); + bNodeSocket *inGainSock = bke::node_find_socket(*node, SOCK_IN, "Gain"); const NodeTexNoise &storage = node_storage(*node); - bke::node_set_socket_availability(ntree, sockVector, storage.dimensions != 1); + bke::node_set_socket_availability(*ntree, *sockVector, storage.dimensions != 1); bke::node_set_socket_availability( - ntree, sockW, storage.dimensions == 1 || storage.dimensions == 4); - bke::node_set_socket_availability(ntree, - inOffsetSock, + *ntree, *sockW, storage.dimensions == 1 || storage.dimensions == 4); + bke::node_set_socket_availability(*ntree, + *inOffsetSock, storage.type != SHD_NOISE_MULTIFRACTAL && storage.type != SHD_NOISE_FBM); - bke::node_set_socket_availability(ntree, - inGainSock, + bke::node_set_socket_availability(*ntree, + *inGainSock, storage.type == SHD_NOISE_HYBRID_MULTIFRACTAL || storage.type == SHD_NOISE_RIDGED_MULTIFRACTAL); } @@ -470,11 +470,11 @@ void register_node_type_sh_tex_noise() ntype.draw_buttons = file_ns::node_shader_buts_tex_noise; ntype.initfunc = file_ns::node_shader_init_tex_noise; blender::bke::node_type_storage( - &ntype, "NodeTexNoise", node_free_standard_storage, node_copy_standard_storage); + ntype, "NodeTexNoise", node_free_standard_storage, node_copy_standard_storage); ntype.gpu_fn = file_ns::node_shader_gpu_tex_noise; ntype.updatefunc = file_ns::node_shader_update_tex_noise; ntype.build_multi_function = file_ns::sh_node_noise_build_multi_function; ntype.materialx_fn = file_ns::node_shader_materialx; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } diff --git a/source/blender/nodes/shader/nodes/node_shader_tex_pointdensity.cc b/source/blender/nodes/shader/nodes/node_shader_tex_pointdensity.cc index 2a609baf962..8d00c56f396 100644 --- a/source/blender/nodes/shader/nodes/node_shader_tex_pointdensity.cc +++ b/source/blender/nodes/shader/nodes/node_shader_tex_pointdensity.cc @@ -120,10 +120,10 @@ void register_node_type_sh_tex_pointdensity() ntype.declare = file_ns::node_declare; ntype.draw_buttons = file_ns::node_shader_buts_tex_pointdensity; ntype.initfunc = file_ns::node_shader_init_tex_pointdensity; - blender::bke::node_type_storage(&ntype, + blender::bke::node_type_storage(ntype, "NodeShaderTexPointDensity", file_ns::node_shader_free_tex_pointdensity, file_ns::node_shader_copy_tex_pointdensity); - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } diff --git a/source/blender/nodes/shader/nodes/node_shader_tex_sky.cc b/source/blender/nodes/shader/nodes/node_shader_tex_sky.cc index a777d7b42ed..bfe284e66dd 100644 --- a/source/blender/nodes/shader/nodes/node_shader_tex_sky.cc +++ b/source/blender/nodes/shader/nodes/node_shader_tex_sky.cc @@ -277,11 +277,11 @@ static int node_shader_gpu_tex_sky(GPUMaterial *mat, static void node_shader_update_sky(bNodeTree *ntree, bNode *node) { - bNodeSocket *sockVector = bke::node_find_socket(node, SOCK_IN, "Vector"); + bNodeSocket *sockVector = bke::node_find_socket(*node, SOCK_IN, "Vector"); NodeTexSky *tex = (NodeTexSky *)node->storage; bke::node_set_socket_availability( - ntree, sockVector, !(tex->sky_model == 2 && tex->sun_disc == 1)); + *ntree, *sockVector, !(tex->sky_model == 2 && tex->sun_disc == 1)); } static void node_gather_link_searches(GatherLinkSearchOpParams ¶ms) @@ -319,14 +319,14 @@ void register_node_type_sh_tex_sky() ntype.nclass = NODE_CLASS_TEXTURE; ntype.declare = file_ns::node_declare; ntype.draw_buttons = file_ns::node_shader_buts_tex_sky; - blender::bke::node_type_size_preset(&ntype, blender::bke::eNodeSizePreset::Middle); + blender::bke::node_type_size_preset(ntype, blender::bke::eNodeSizePreset::Middle); ntype.initfunc = file_ns::node_shader_init_tex_sky; blender::bke::node_type_storage( - &ntype, "NodeTexSky", node_free_standard_storage, node_copy_standard_storage); + ntype, "NodeTexSky", node_free_standard_storage, node_copy_standard_storage); ntype.gpu_fn = file_ns::node_shader_gpu_tex_sky; /* Remove vector input for Nishita sky model. */ ntype.updatefunc = file_ns::node_shader_update_sky; ntype.gather_link_search_ops = file_ns::node_gather_link_searches; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } diff --git a/source/blender/nodes/shader/nodes/node_shader_tex_voronoi.cc b/source/blender/nodes/shader/nodes/node_shader_tex_voronoi.cc index 89ff84dd061..02b20d43047 100644 --- a/source/blender/nodes/shader/nodes/node_shader_tex_voronoi.cc +++ b/source/blender/nodes/shader/nodes/node_shader_tex_voronoi.cc @@ -168,57 +168,57 @@ static int node_shader_gpu_tex_voronoi(GPUMaterial *mat, static void node_shader_update_tex_voronoi(bNodeTree *ntree, bNode *node) { - bNodeSocket *inVectorSock = bke::node_find_socket(node, SOCK_IN, "Vector"); - bNodeSocket *inWSock = bke::node_find_socket(node, SOCK_IN, "W"); - bNodeSocket *inDetailSock = bke::node_find_socket(node, SOCK_IN, "Detail"); - bNodeSocket *inRoughnessSock = bke::node_find_socket(node, SOCK_IN, "Roughness"); - bNodeSocket *inLacunaritySock = bke::node_find_socket(node, SOCK_IN, "Lacunarity"); - bNodeSocket *inSmoothnessSock = bke::node_find_socket(node, SOCK_IN, "Smoothness"); - bNodeSocket *inExponentSock = bke::node_find_socket(node, SOCK_IN, "Exponent"); - - bNodeSocket *outDistanceSock = bke::node_find_socket(node, SOCK_OUT, "Distance"); - bNodeSocket *outColorSock = bke::node_find_socket(node, SOCK_OUT, "Color"); - bNodeSocket *outPositionSock = bke::node_find_socket(node, SOCK_OUT, "Position"); - bNodeSocket *outWSock = bke::node_find_socket(node, SOCK_OUT, "W"); - bNodeSocket *outRadiusSock = bke::node_find_socket(node, SOCK_OUT, "Radius"); + bNodeSocket *inVectorSock = bke::node_find_socket(*node, SOCK_IN, "Vector"); + bNodeSocket *inWSock = bke::node_find_socket(*node, SOCK_IN, "W"); + bNodeSocket *inDetailSock = bke::node_find_socket(*node, SOCK_IN, "Detail"); + bNodeSocket *inRoughnessSock = bke::node_find_socket(*node, SOCK_IN, "Roughness"); + bNodeSocket *inLacunaritySock = bke::node_find_socket(*node, SOCK_IN, "Lacunarity"); + bNodeSocket *inSmoothnessSock = bke::node_find_socket(*node, SOCK_IN, "Smoothness"); + bNodeSocket *inExponentSock = bke::node_find_socket(*node, SOCK_IN, "Exponent"); + + bNodeSocket *outDistanceSock = bke::node_find_socket(*node, SOCK_OUT, "Distance"); + bNodeSocket *outColorSock = bke::node_find_socket(*node, SOCK_OUT, "Color"); + bNodeSocket *outPositionSock = bke::node_find_socket(*node, SOCK_OUT, "Position"); + bNodeSocket *outWSock = bke::node_find_socket(*node, SOCK_OUT, "W"); + bNodeSocket *outRadiusSock = bke::node_find_socket(*node, SOCK_OUT, "Radius"); const NodeTexVoronoi &storage = node_storage(*node); bke::node_set_socket_availability( - ntree, inWSock, storage.dimensions == 1 || storage.dimensions == 4); - bke::node_set_socket_availability(ntree, inVectorSock, storage.dimensions != 1); + *ntree, *inWSock, storage.dimensions == 1 || storage.dimensions == 4); + bke::node_set_socket_availability(*ntree, *inVectorSock, storage.dimensions != 1); bke::node_set_socket_availability( - ntree, - inExponentSock, + *ntree, + *inExponentSock, storage.distance == SHD_VORONOI_MINKOWSKI && storage.dimensions != 1 && !ELEM(storage.feature, SHD_VORONOI_DISTANCE_TO_EDGE, SHD_VORONOI_N_SPHERE_RADIUS)); bke::node_set_socket_availability( - ntree, inDetailSock, storage.feature != SHD_VORONOI_N_SPHERE_RADIUS); + *ntree, *inDetailSock, storage.feature != SHD_VORONOI_N_SPHERE_RADIUS); bke::node_set_socket_availability( - ntree, inRoughnessSock, storage.feature != SHD_VORONOI_N_SPHERE_RADIUS); + *ntree, *inRoughnessSock, storage.feature != SHD_VORONOI_N_SPHERE_RADIUS); bke::node_set_socket_availability( - ntree, inLacunaritySock, storage.feature != SHD_VORONOI_N_SPHERE_RADIUS); + *ntree, *inLacunaritySock, storage.feature != SHD_VORONOI_N_SPHERE_RADIUS); bke::node_set_socket_availability( - ntree, inSmoothnessSock, storage.feature == SHD_VORONOI_SMOOTH_F1); + *ntree, *inSmoothnessSock, storage.feature == SHD_VORONOI_SMOOTH_F1); bke::node_set_socket_availability( - ntree, outDistanceSock, storage.feature != SHD_VORONOI_N_SPHERE_RADIUS); - bke::node_set_socket_availability(ntree, - outColorSock, + *ntree, *outDistanceSock, storage.feature != SHD_VORONOI_N_SPHERE_RADIUS); + bke::node_set_socket_availability(*ntree, + *outColorSock, storage.feature != SHD_VORONOI_DISTANCE_TO_EDGE && storage.feature != SHD_VORONOI_N_SPHERE_RADIUS); - bke::node_set_socket_availability(ntree, - outPositionSock, + bke::node_set_socket_availability(*ntree, + *outPositionSock, storage.feature != SHD_VORONOI_DISTANCE_TO_EDGE && storage.feature != SHD_VORONOI_N_SPHERE_RADIUS && storage.dimensions != 1); - bke::node_set_socket_availability(ntree, - outWSock, + bke::node_set_socket_availability(*ntree, + *outWSock, storage.feature != SHD_VORONOI_DISTANCE_TO_EDGE && storage.feature != SHD_VORONOI_N_SPHERE_RADIUS && ELEM(storage.dimensions, 1, 4)); bke::node_set_socket_availability( - ntree, outRadiusSock, storage.feature == SHD_VORONOI_N_SPHERE_RADIUS); + *ntree, *outRadiusSock, storage.feature == SHD_VORONOI_N_SPHERE_RADIUS); } static mf::MultiFunction::ExecutionHints voronoi_execution_hints{50, false}; @@ -829,10 +829,10 @@ void register_node_type_sh_tex_voronoi() ntype.draw_buttons = file_ns::node_shader_buts_tex_voronoi; ntype.initfunc = file_ns::node_shader_init_tex_voronoi; blender::bke::node_type_storage( - &ntype, "NodeTexVoronoi", node_free_standard_storage, node_copy_standard_storage); + ntype, "NodeTexVoronoi", node_free_standard_storage, node_copy_standard_storage); ntype.gpu_fn = file_ns::node_shader_gpu_tex_voronoi; ntype.updatefunc = file_ns::node_shader_update_tex_voronoi; ntype.build_multi_function = file_ns::sh_node_voronoi_build_multi_function; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } diff --git a/source/blender/nodes/shader/nodes/node_shader_tex_wave.cc b/source/blender/nodes/shader/nodes/node_shader_tex_wave.cc index f22dcff71f1..f72d7afcc1f 100644 --- a/source/blender/nodes/shader/nodes/node_shader_tex_wave.cc +++ b/source/blender/nodes/shader/nodes/node_shader_tex_wave.cc @@ -342,13 +342,13 @@ void register_node_type_sh_tex_wave() ntype.nclass = NODE_CLASS_TEXTURE; ntype.declare = file_ns::sh_node_tex_wave_declare; ntype.draw_buttons = file_ns::node_shader_buts_tex_wave; - blender::bke::node_type_size_preset(&ntype, blender::bke::eNodeSizePreset::Middle); + blender::bke::node_type_size_preset(ntype, blender::bke::eNodeSizePreset::Middle); ntype.initfunc = file_ns::node_shader_init_tex_wave; blender::bke::node_type_storage( - &ntype, "NodeTexWave", node_free_standard_storage, node_copy_standard_storage); + ntype, "NodeTexWave", node_free_standard_storage, node_copy_standard_storage); ntype.gpu_fn = file_ns::node_shader_gpu_tex_wave; ntype.build_multi_function = file_ns::sh_node_wave_tex_build_multi_function; ntype.materialx_fn = file_ns::node_shader_materialx; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } diff --git a/source/blender/nodes/shader/nodes/node_shader_tex_white_noise.cc b/source/blender/nodes/shader/nodes/node_shader_tex_white_noise.cc index 82bdede6498..b23e9fea0ac 100644 --- a/source/blender/nodes/shader/nodes/node_shader_tex_white_noise.cc +++ b/source/blender/nodes/shader/nodes/node_shader_tex_white_noise.cc @@ -63,11 +63,11 @@ static int gpu_shader_tex_white_noise(GPUMaterial *mat, static void node_shader_update_tex_white_noise(bNodeTree *ntree, bNode *node) { - bNodeSocket *sockVector = bke::node_find_socket(node, SOCK_IN, "Vector"); - bNodeSocket *sockW = bke::node_find_socket(node, SOCK_IN, "W"); + bNodeSocket *sockVector = bke::node_find_socket(*node, SOCK_IN, "Vector"); + bNodeSocket *sockW = bke::node_find_socket(*node, SOCK_IN, "W"); - bke::node_set_socket_availability(ntree, sockVector, node->custom1 != 1); - bke::node_set_socket_availability(ntree, sockW, node->custom1 == 1 || node->custom1 == 4); + bke::node_set_socket_availability(*ntree, *sockVector, node->custom1 != 1); + bke::node_set_socket_availability(*ntree, *sockW, node->custom1 == 1 || node->custom1 == 4); } class WhiteNoiseFunction : public mf::MultiFunction { @@ -273,5 +273,5 @@ void register_node_type_sh_tex_white_noise() ntype.build_multi_function = file_ns::sh_node_noise_build_multi_function; ntype.materialx_fn = file_ns::node_shader_materialx; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } diff --git a/source/blender/nodes/shader/nodes/node_shader_uv_along_stroke.cc b/source/blender/nodes/shader/nodes/node_shader_uv_along_stroke.cc index 6ba801faa40..b282db1ce31 100644 --- a/source/blender/nodes/shader/nodes/node_shader_uv_along_stroke.cc +++ b/source/blender/nodes/shader/nodes/node_shader_uv_along_stroke.cc @@ -36,5 +36,5 @@ void register_node_type_sh_uvalongstroke() ntype.add_ui_poll = line_style_shader_nodes_poll; ntype.draw_buttons = file_ns::node_shader_buts_uvalongstroke; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } diff --git a/source/blender/nodes/shader/nodes/node_shader_uvmap.cc b/source/blender/nodes/shader/nodes/node_shader_uvmap.cc index 51501049821..f2318330a5f 100644 --- a/source/blender/nodes/shader/nodes/node_shader_uvmap.cc +++ b/source/blender/nodes/shader/nodes/node_shader_uvmap.cc @@ -101,12 +101,12 @@ void register_node_type_sh_uvmap() ntype.nclass = NODE_CLASS_INPUT; ntype.declare = file_ns::node_declare; ntype.draw_buttons = file_ns::node_shader_buts_uvmap; - blender::bke::node_type_size_preset(&ntype, blender::bke::eNodeSizePreset::Middle); + blender::bke::node_type_size_preset(ntype, blender::bke::eNodeSizePreset::Middle); ntype.initfunc = file_ns::node_shader_init_uvmap; blender::bke::node_type_storage( - &ntype, "NodeShaderUVMap", node_free_standard_storage, node_copy_standard_storage); + ntype, "NodeShaderUVMap", node_free_standard_storage, node_copy_standard_storage); ntype.gpu_fn = file_ns::node_shader_gpu_uvmap; ntype.materialx_fn = file_ns::node_shader_materialx; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } diff --git a/source/blender/nodes/shader/nodes/node_shader_value.cc b/source/blender/nodes/shader/nodes/node_shader_value.cc index 290b29285c8..beebfb78409 100644 --- a/source/blender/nodes/shader/nodes/node_shader_value.cc +++ b/source/blender/nodes/shader/nodes/node_shader_value.cc @@ -64,5 +64,5 @@ void register_node_type_sh_value() ntype.build_multi_function = file_ns::sh_node_value_build_multi_function; ntype.materialx_fn = file_ns::node_shader_materialx; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } diff --git a/source/blender/nodes/shader/nodes/node_shader_vector_displacement.cc b/source/blender/nodes/shader/nodes/node_shader_vector_displacement.cc index b50bc68fd0b..7d7a5a8c22f 100644 --- a/source/blender/nodes/shader/nodes/node_shader_vector_displacement.cc +++ b/source/blender/nodes/shader/nodes/node_shader_vector_displacement.cc @@ -88,5 +88,5 @@ void register_node_type_sh_vector_displacement() ntype.gpu_fn = file_ns::gpu_shader_vector_displacement; ntype.materialx_fn = file_ns::node_shader_materialx; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } diff --git a/source/blender/nodes/shader/nodes/node_shader_vector_math.cc b/source/blender/nodes/shader/nodes/node_shader_vector_math.cc index ac49ccddc1f..76594715c4a 100644 --- a/source/blender/nodes/shader/nodes/node_shader_vector_math.cc +++ b/source/blender/nodes/shader/nodes/node_shader_vector_math.cc @@ -165,13 +165,13 @@ static void node_shader_update_vector_math(bNodeTree *ntree, bNode *node) { bNodeSocket *sockB = (bNodeSocket *)BLI_findlink(&node->inputs, 1); bNodeSocket *sockC = (bNodeSocket *)BLI_findlink(&node->inputs, 2); - bNodeSocket *sockScale = bke::node_find_socket(node, SOCK_IN, "Scale"); + bNodeSocket *sockScale = bke::node_find_socket(*node, SOCK_IN, "Scale"); - bNodeSocket *sockVector = bke::node_find_socket(node, SOCK_OUT, "Vector"); - bNodeSocket *sockValue = bke::node_find_socket(node, SOCK_OUT, "Value"); + bNodeSocket *sockVector = bke::node_find_socket(*node, SOCK_OUT, "Vector"); + bNodeSocket *sockValue = bke::node_find_socket(*node, SOCK_OUT, "Value"); - bke::node_set_socket_availability(ntree, - sockB, + bke::node_set_socket_availability(*ntree, + *sockB, !ELEM(node->custom1, NODE_VECTOR_MATH_SINE, NODE_VECTOR_MATH_COSINE, @@ -183,22 +183,22 @@ static void node_shader_update_vector_math(bNodeTree *ntree, bNode *node) NODE_VECTOR_MATH_ABSOLUTE, NODE_VECTOR_MATH_FRACTION, NODE_VECTOR_MATH_NORMALIZE)); - bke::node_set_socket_availability(ntree, - sockC, + bke::node_set_socket_availability(*ntree, + *sockC, ELEM(node->custom1, NODE_VECTOR_MATH_WRAP, NODE_VECTOR_MATH_FACEFORWARD, NODE_VECTOR_MATH_MULTIPLY_ADD)); bke::node_set_socket_availability( - ntree, sockScale, ELEM(node->custom1, NODE_VECTOR_MATH_SCALE, NODE_VECTOR_MATH_REFRACT)); - bke::node_set_socket_availability(ntree, - sockVector, + *ntree, *sockScale, ELEM(node->custom1, NODE_VECTOR_MATH_SCALE, NODE_VECTOR_MATH_REFRACT)); + bke::node_set_socket_availability(*ntree, + *sockVector, !ELEM(node->custom1, NODE_VECTOR_MATH_LENGTH, NODE_VECTOR_MATH_DISTANCE, NODE_VECTOR_MATH_DOT_PRODUCT)); - bke::node_set_socket_availability(ntree, - sockValue, + bke::node_set_socket_availability(*ntree, + *sockValue, ELEM(node->custom1, NODE_VECTOR_MATH_LENGTH, NODE_VECTOR_MATH_DISTANCE, @@ -573,5 +573,5 @@ void register_node_type_sh_vect_math() ntype.eval_inverse_elem = file_ns::node_eval_inverse_elem; ntype.eval_inverse = file_ns::node_eval_inverse; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } diff --git a/source/blender/nodes/shader/nodes/node_shader_vector_rotate.cc b/source/blender/nodes/shader/nodes/node_shader_vector_rotate.cc index d5506d47e0d..e6e687c5fb7 100644 --- a/source/blender/nodes/shader/nodes/node_shader_vector_rotate.cc +++ b/source/blender/nodes/shader/nodes/node_shader_vector_rotate.cc @@ -206,15 +206,15 @@ static void sh_node_vector_rotate_build_multi_function(NodeMultiFunctionBuilder static void node_shader_update_vector_rotate(bNodeTree *ntree, bNode *node) { - bNodeSocket *sock_rotation = bke::node_find_socket(node, SOCK_IN, "Rotation"); + bNodeSocket *sock_rotation = bke::node_find_socket(*node, SOCK_IN, "Rotation"); bke::node_set_socket_availability( - ntree, sock_rotation, ELEM(node->custom1, NODE_VECTOR_ROTATE_TYPE_EULER_XYZ)); - bNodeSocket *sock_axis = bke::node_find_socket(node, SOCK_IN, "Axis"); + *ntree, *sock_rotation, ELEM(node->custom1, NODE_VECTOR_ROTATE_TYPE_EULER_XYZ)); + bNodeSocket *sock_axis = bke::node_find_socket(*node, SOCK_IN, "Axis"); bke::node_set_socket_availability( - ntree, sock_axis, ELEM(node->custom1, NODE_VECTOR_ROTATE_TYPE_AXIS)); - bNodeSocket *sock_angle = bke::node_find_socket(node, SOCK_IN, "Angle"); + *ntree, *sock_axis, ELEM(node->custom1, NODE_VECTOR_ROTATE_TYPE_AXIS)); + bNodeSocket *sock_angle = bke::node_find_socket(*node, SOCK_IN, "Angle"); bke::node_set_socket_availability( - ntree, sock_angle, !ELEM(node->custom1, NODE_VECTOR_ROTATE_TYPE_EULER_XYZ)); + *ntree, *sock_angle, !ELEM(node->custom1, NODE_VECTOR_ROTATE_TYPE_EULER_XYZ)); } NODE_SHADER_MATERIALX_BEGIN @@ -280,5 +280,5 @@ void register_node_type_sh_vector_rotate() ntype.build_multi_function = file_ns::sh_node_vector_rotate_build_multi_function; ntype.materialx_fn = file_ns::node_shader_materialx; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } diff --git a/source/blender/nodes/shader/nodes/node_shader_vector_transform.cc b/source/blender/nodes/shader/nodes/node_shader_vector_transform.cc index aa8f804ce08..55388e75fa4 100644 --- a/source/blender/nodes/shader/nodes/node_shader_vector_transform.cc +++ b/source/blender/nodes/shader/nodes/node_shader_vector_transform.cc @@ -218,9 +218,9 @@ void register_node_type_sh_vect_transform() ntype.draw_buttons = file_ns::node_shader_buts_vect_transform; ntype.initfunc = file_ns::node_shader_init_vect_transform; blender::bke::node_type_storage( - &ntype, "NodeShaderVectTransform", node_free_standard_storage, node_copy_standard_storage); + ntype, "NodeShaderVectTransform", node_free_standard_storage, node_copy_standard_storage); ntype.gpu_fn = file_ns::gpu_shader_vect_transform; ntype.materialx_fn = file_ns::node_shader_materialx; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } diff --git a/source/blender/nodes/shader/nodes/node_shader_vertex_color.cc b/source/blender/nodes/shader/nodes/node_shader_vertex_color.cc index bfe754a58c0..1f815326df3 100644 --- a/source/blender/nodes/shader/nodes/node_shader_vertex_color.cc +++ b/source/blender/nodes/shader/nodes/node_shader_vertex_color.cc @@ -98,9 +98,9 @@ void register_node_type_sh_vertex_color() ntype.draw_buttons = file_ns::node_shader_buts_vertex_color; ntype.initfunc = file_ns::node_shader_init_vertex_color; blender::bke::node_type_storage( - &ntype, "NodeShaderVertexColor", node_free_standard_storage, node_copy_standard_storage); + ntype, "NodeShaderVertexColor", node_free_standard_storage, node_copy_standard_storage); ntype.gpu_fn = file_ns::node_shader_gpu_vertex_color; ntype.materialx_fn = file_ns::node_shader_materialx; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } diff --git a/source/blender/nodes/shader/nodes/node_shader_volume_absorption.cc b/source/blender/nodes/shader/nodes/node_shader_volume_absorption.cc index 358abbb6e94..ce30d721996 100644 --- a/source/blender/nodes/shader/nodes/node_shader_volume_absorption.cc +++ b/source/blender/nodes/shader/nodes/node_shader_volume_absorption.cc @@ -48,5 +48,5 @@ void register_node_type_sh_volume_absorption() ntype.declare = file_ns::node_declare; ntype.gpu_fn = file_ns::node_shader_gpu_volume_absorption; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } diff --git a/source/blender/nodes/shader/nodes/node_shader_volume_info.cc b/source/blender/nodes/shader/nodes/node_shader_volume_info.cc index f435e076b90..aef8a740a32 100644 --- a/source/blender/nodes/shader/nodes/node_shader_volume_info.cc +++ b/source/blender/nodes/shader/nodes/node_shader_volume_info.cc @@ -56,5 +56,5 @@ void register_node_type_sh_volume_info() ntype.declare = file_ns::node_declare; ntype.gpu_fn = file_ns::node_shader_gpu_volume_info; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } diff --git a/source/blender/nodes/shader/nodes/node_shader_volume_principled.cc b/source/blender/nodes/shader/nodes/node_shader_volume_principled.cc index e2fe88634b0..95fd81a8d6d 100644 --- a/source/blender/nodes/shader/nodes/node_shader_volume_principled.cc +++ b/source/blender/nodes/shader/nodes/node_shader_volume_principled.cc @@ -170,8 +170,8 @@ void register_node_type_sh_volume_principled() ntype.enum_name_legacy = "PRINCIPLED_VOLUME"; ntype.nclass = NODE_CLASS_SHADER; ntype.declare = file_ns::node_declare; - blender::bke::node_type_size_preset(&ntype, blender::bke::eNodeSizePreset::Large); + blender::bke::node_type_size_preset(ntype, blender::bke::eNodeSizePreset::Large); ntype.gpu_fn = file_ns::node_shader_gpu_volume_principled; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } diff --git a/source/blender/nodes/shader/nodes/node_shader_volume_scatter.cc b/source/blender/nodes/shader/nodes/node_shader_volume_scatter.cc index b7a701847a9..234386ea069 100644 --- a/source/blender/nodes/shader/nodes/node_shader_volume_scatter.cc +++ b/source/blender/nodes/shader/nodes/node_shader_volume_scatter.cc @@ -65,17 +65,18 @@ static void node_shader_update_scatter(bNodeTree *ntree, bNode *node) LISTBASE_FOREACH (bNodeSocket *, sock, &node->inputs) { if (STR_ELEM(sock->name, "IOR", "Backscatter")) { - bke::node_set_socket_availability(ntree, sock, phase_function == SHD_PHASE_FOURNIER_FORAND); + bke::node_set_socket_availability( + *ntree, *sock, phase_function == SHD_PHASE_FOURNIER_FORAND); } else if (STR_ELEM(sock->name, "Anisotropy")) { bke::node_set_socket_availability( - ntree, sock, ELEM(phase_function, SHD_PHASE_HENYEY_GREENSTEIN, SHD_PHASE_DRAINE)); + *ntree, *sock, ELEM(phase_function, SHD_PHASE_HENYEY_GREENSTEIN, SHD_PHASE_DRAINE)); } else if (STR_ELEM(sock->name, "Alpha")) { - bke::node_set_socket_availability(ntree, sock, phase_function == SHD_PHASE_DRAINE); + bke::node_set_socket_availability(*ntree, *sock, phase_function == SHD_PHASE_DRAINE); } else if (STR_ELEM(sock->name, "Diameter")) { - bke::node_set_socket_availability(ntree, sock, phase_function == SHD_PHASE_MIE); + bke::node_set_socket_availability(*ntree, *sock, phase_function == SHD_PHASE_MIE); } } } @@ -115,10 +116,10 @@ void register_node_type_sh_volume_scatter() ntype.declare = file_ns::node_declare; ntype.add_ui_poll = object_shader_nodes_poll; ntype.draw_buttons = file_ns::node_shader_buts_scatter; - blender::bke::node_type_size_preset(&ntype, blender::bke::eNodeSizePreset::Middle); + blender::bke::node_type_size_preset(ntype, blender::bke::eNodeSizePreset::Middle); ntype.initfunc = file_ns::node_shader_init_scatter; ntype.gpu_fn = file_ns::node_shader_gpu_volume_scatter; ntype.updatefunc = file_ns::node_shader_update_scatter; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } diff --git a/source/blender/nodes/shader/nodes/node_shader_wavelength.cc b/source/blender/nodes/shader/nodes/node_shader_wavelength.cc index 863d7d3e583..8c765646e07 100644 --- a/source/blender/nodes/shader/nodes/node_shader_wavelength.cc +++ b/source/blender/nodes/shader/nodes/node_shader_wavelength.cc @@ -49,8 +49,8 @@ void register_node_type_sh_wavelength() ntype.enum_name_legacy = "WAVELENGTH"; ntype.nclass = NODE_CLASS_CONVERTER; ntype.declare = file_ns::node_declare; - blender::bke::node_type_size_preset(&ntype, blender::bke::eNodeSizePreset::Middle); + blender::bke::node_type_size_preset(ntype, blender::bke::eNodeSizePreset::Middle); ntype.gpu_fn = file_ns::node_shader_gpu_wavelength; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } diff --git a/source/blender/nodes/shader/nodes/node_shader_wireframe.cc b/source/blender/nodes/shader/nodes/node_shader_wireframe.cc index bc58eabedcf..1606b634b44 100644 --- a/source/blender/nodes/shader/nodes/node_shader_wireframe.cc +++ b/source/blender/nodes/shader/nodes/node_shader_wireframe.cc @@ -68,5 +68,5 @@ void register_node_type_sh_wireframe() ntype.gpu_fn = file_ns::node_shader_gpu_wireframe; ntype.materialx_fn = file_ns::node_shader_materialx; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } diff --git a/source/blender/nodes/texture/node_texture_tree.cc b/source/blender/nodes/texture/node_texture_tree.cc index 9155c01d311..d71fa5a8f27 100644 --- a/source/blender/nodes/texture/node_texture_tree.cc +++ b/source/blender/nodes/texture/node_texture_tree.cc @@ -106,8 +106,8 @@ static void localize(bNodeTree *localtree, bNodeTree * /*ntree*/) node_next = node->next; if (node->is_muted() || node->is_reroute()) { - blender::bke::node_internal_relink(localtree, node); - blender::bke::node_tree_free_local_node(localtree, node); + blender::bke::node_internal_relink(*localtree, *node); + blender::bke::node_tree_free_local_node(*localtree, *node); } } } @@ -123,7 +123,7 @@ static void update(bNodeTree *ntree) static bool texture_node_tree_socket_type_valid(blender::bke::bNodeTreeType * /*ntreetype*/, blender::bke::bNodeSocketType *socket_type) { - return blender::bke::node_is_static_socket_type(socket_type) && + return blender::bke::node_is_static_socket_type(*socket_type) && ELEM(socket_type->type, SOCK_FLOAT, SOCK_VECTOR, SOCK_RGBA); } @@ -149,7 +149,7 @@ void register_node_tree_type_tex() tt->rna_ext.srna = &RNA_TextureNodeTree; - blender::bke::node_tree_type_add(tt); + blender::bke::node_tree_type_add(*tt); } /**** Material/Texture trees ****/ diff --git a/source/blender/nodes/texture/node_texture_util.cc b/source/blender/nodes/texture/node_texture_util.cc index f6c8ac039a6..9ce51436485 100644 --- a/source/blender/nodes/texture/node_texture_util.cc +++ b/source/blender/nodes/texture/node_texture_util.cc @@ -47,7 +47,7 @@ void tex_node_type_base(blender::bke::bNodeType *ntype, std::string idname, const std::optional legacy_type) { - blender::bke::node_type_base(ntype, idname, legacy_type); + blender::bke::node_type_base(*ntype, idname, legacy_type); ntype->poll = tex_node_poll_default; ntype->insert_link = node_insert_link_default; diff --git a/source/blender/nodes/texture/nodes/node_texture_at.cc b/source/blender/nodes/texture/nodes/node_texture_at.cc index b69b5749fce..c43521a1919 100644 --- a/source/blender/nodes/texture/nodes/node_texture_at.cc +++ b/source/blender/nodes/texture/nodes/node_texture_at.cc @@ -47,8 +47,8 @@ void register_node_type_tex_at() ntype.enum_name_legacy = "AT"; ntype.nclass = NODE_CLASS_DISTORT; blender::bke::node_type_socket_templates(&ntype, inputs, outputs); - blender::bke::node_type_size(&ntype, 140, 100, 320); + blender::bke::node_type_size(ntype, 140, 100, 320); ntype.exec_fn = exec; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } diff --git a/source/blender/nodes/texture/nodes/node_texture_bricks.cc b/source/blender/nodes/texture/nodes/node_texture_bricks.cc index 3d1f52ed43e..ad933d662bd 100644 --- a/source/blender/nodes/texture/nodes/node_texture_bricks.cc +++ b/source/blender/nodes/texture/nodes/node_texture_bricks.cc @@ -112,10 +112,10 @@ void register_node_type_tex_bricks() ntype.enum_name_legacy = "BRICKS"; ntype.nclass = NODE_CLASS_PATTERN; blender::bke::node_type_socket_templates(&ntype, inputs, outputs); - blender::bke::node_type_size_preset(&ntype, blender::bke::eNodeSizePreset::Middle); + blender::bke::node_type_size_preset(ntype, blender::bke::eNodeSizePreset::Middle); ntype.initfunc = init; ntype.exec_fn = exec; ntype.flag |= NODE_PREVIEW; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } diff --git a/source/blender/nodes/texture/nodes/node_texture_checker.cc b/source/blender/nodes/texture/nodes/node_texture_checker.cc index b80b9240cc1..43dda59a1f9 100644 --- a/source/blender/nodes/texture/nodes/node_texture_checker.cc +++ b/source/blender/nodes/texture/nodes/node_texture_checker.cc @@ -62,5 +62,5 @@ void register_node_type_tex_checker() ntype.exec_fn = exec; ntype.flag |= NODE_PREVIEW; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } diff --git a/source/blender/nodes/texture/nodes/node_texture_combine_color.cc b/source/blender/nodes/texture/nodes/node_texture_combine_color.cc index aea606714e1..754d03d1272 100644 --- a/source/blender/nodes/texture/nodes/node_texture_combine_color.cc +++ b/source/blender/nodes/texture/nodes/node_texture_combine_color.cc @@ -76,5 +76,5 @@ void register_node_type_tex_combine_color() ntype.exec_fn = exec; ntype.updatefunc = update; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } diff --git a/source/blender/nodes/texture/nodes/node_texture_common.cc b/source/blender/nodes/texture/nodes/node_texture_common.cc index 8884ec7cc66..b558048f333 100644 --- a/source/blender/nodes/texture/nodes/node_texture_common.cc +++ b/source/blender/nodes/texture/nodes/node_texture_common.cc @@ -147,7 +147,7 @@ void register_node_type_tex_group() * to the shared #NODE_GROUP integer type id. */ blender::bke::node_type_base_custom( - &ntype, "TextureNodeGroup", "Group", "GROUP", NODE_CLASS_GROUP); + ntype, "TextureNodeGroup", "Group", "GROUP", NODE_CLASS_GROUP); ntype.enum_name_legacy = "GROUP"; ntype.type_legacy = NODE_GROUP; ntype.poll = tex_node_poll_default; @@ -157,12 +157,12 @@ void register_node_type_tex_group() BLI_assert(ntype.rna_ext.srna != nullptr); RNA_struct_blender_type_set(ntype.rna_ext.srna, &ntype); - blender::bke::node_type_size(&ntype, 140, 60, 400); + blender::bke::node_type_size(ntype, 140, 60, 400); ntype.labelfunc = node_group_label; ntype.declare = blender::nodes::node_group_declare; ntype.init_exec_fn = group_initexec; ntype.free_exec_fn = group_freeexec; ntype.exec_fn = group_execute; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } diff --git a/source/blender/nodes/texture/nodes/node_texture_compose.cc b/source/blender/nodes/texture/nodes/node_texture_compose.cc index 4d9b4ab760a..83388d73874 100644 --- a/source/blender/nodes/texture/nodes/node_texture_compose.cc +++ b/source/blender/nodes/texture/nodes/node_texture_compose.cc @@ -49,5 +49,5 @@ void register_node_type_tex_compose() blender::bke::node_type_socket_templates(&ntype, inputs, outputs); ntype.exec_fn = exec; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } diff --git a/source/blender/nodes/texture/nodes/node_texture_coord.cc b/source/blender/nodes/texture/nodes/node_texture_coord.cc index 12aba6114a3..46ccc8b6776 100644 --- a/source/blender/nodes/texture/nodes/node_texture_coord.cc +++ b/source/blender/nodes/texture/nodes/node_texture_coord.cc @@ -41,5 +41,5 @@ void register_node_type_tex_coord() blender::bke::node_type_socket_templates(&ntype, nullptr, outputs); ntype.exec_fn = exec; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } diff --git a/source/blender/nodes/texture/nodes/node_texture_curves.cc b/source/blender/nodes/texture/nodes/node_texture_curves.cc index 1496aa85fac..72c3dd1f343 100644 --- a/source/blender/nodes/texture/nodes/node_texture_curves.cc +++ b/source/blender/nodes/texture/nodes/node_texture_curves.cc @@ -59,13 +59,13 @@ void register_node_type_tex_curve_time() ntype.enum_name_legacy = "CURVE_TIME"; ntype.nclass = NODE_CLASS_INPUT; blender::bke::node_type_socket_templates(&ntype, nullptr, time_outputs); - blender::bke::node_type_size_preset(&ntype, blender::bke::eNodeSizePreset::Large); + blender::bke::node_type_size_preset(ntype, blender::bke::eNodeSizePreset::Large); ntype.initfunc = time_init; - blender::bke::node_type_storage(&ntype, "CurveMapping", node_free_curves, node_copy_curves); + blender::bke::node_type_storage(ntype, "CurveMapping", node_free_curves, node_copy_curves); ntype.init_exec_fn = node_initexec_curves; ntype.exec_fn = time_exec; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } /* **************** CURVE RGB ******************** */ @@ -112,11 +112,11 @@ void register_node_type_tex_curve_rgb() ntype.enum_name_legacy = "CURVE_RGB"; ntype.nclass = NODE_CLASS_OP_COLOR; blender::bke::node_type_socket_templates(&ntype, rgb_inputs, rgb_outputs); - blender::bke::node_type_size_preset(&ntype, blender::bke::eNodeSizePreset::Large); + blender::bke::node_type_size_preset(ntype, blender::bke::eNodeSizePreset::Large); ntype.initfunc = rgb_init; - blender::bke::node_type_storage(&ntype, "CurveMapping", node_free_curves, node_copy_curves); + blender::bke::node_type_storage(ntype, "CurveMapping", node_free_curves, node_copy_curves); ntype.init_exec_fn = node_initexec_curves; ntype.exec_fn = rgb_exec; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } diff --git a/source/blender/nodes/texture/nodes/node_texture_decompose.cc b/source/blender/nodes/texture/nodes/node_texture_decompose.cc index 195cb87cd66..a8dced26967 100644 --- a/source/blender/nodes/texture/nodes/node_texture_decompose.cc +++ b/source/blender/nodes/texture/nodes/node_texture_decompose.cc @@ -69,5 +69,5 @@ void register_node_type_tex_decompose() blender::bke::node_type_socket_templates(&ntype, inputs, outputs); ntype.exec_fn = exec; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } diff --git a/source/blender/nodes/texture/nodes/node_texture_distance.cc b/source/blender/nodes/texture/nodes/node_texture_distance.cc index 71ccfc799e9..c15dcb19161 100644 --- a/source/blender/nodes/texture/nodes/node_texture_distance.cc +++ b/source/blender/nodes/texture/nodes/node_texture_distance.cc @@ -51,5 +51,5 @@ void register_node_type_tex_distance() blender::bke::node_type_socket_templates(&ntype, inputs, outputs); ntype.exec_fn = exec; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } diff --git a/source/blender/nodes/texture/nodes/node_texture_hueSatVal.cc b/source/blender/nodes/texture/nodes/node_texture_hueSatVal.cc index b4e01581452..b75f0e0047e 100644 --- a/source/blender/nodes/texture/nodes/node_texture_hueSatVal.cc +++ b/source/blender/nodes/texture/nodes/node_texture_hueSatVal.cc @@ -98,8 +98,8 @@ void register_node_type_tex_hue_sat() ntype.enum_name_legacy = "HUE_SAT"; ntype.nclass = NODE_CLASS_OP_COLOR; blender::bke::node_type_socket_templates(&ntype, inputs, outputs); - blender::bke::node_type_size_preset(&ntype, blender::bke::eNodeSizePreset::Middle); + blender::bke::node_type_size_preset(ntype, blender::bke::eNodeSizePreset::Middle); ntype.exec_fn = exec; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } diff --git a/source/blender/nodes/texture/nodes/node_texture_image.cc b/source/blender/nodes/texture/nodes/node_texture_image.cc index 88f29bc1974..b05e0fa9ac7 100644 --- a/source/blender/nodes/texture/nodes/node_texture_image.cc +++ b/source/blender/nodes/texture/nodes/node_texture_image.cc @@ -103,10 +103,10 @@ void register_node_type_tex_image() blender::bke::node_type_socket_templates(&ntype, nullptr, outputs); ntype.initfunc = init; blender::bke::node_type_storage( - &ntype, "ImageUser", node_free_standard_storage, node_copy_standard_storage); + ntype, "ImageUser", node_free_standard_storage, node_copy_standard_storage); ntype.exec_fn = exec; ntype.labelfunc = node_image_label; ntype.flag |= NODE_PREVIEW; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } diff --git a/source/blender/nodes/texture/nodes/node_texture_invert.cc b/source/blender/nodes/texture/nodes/node_texture_invert.cc index e8a11a9de70..4a4108402cd 100644 --- a/source/blender/nodes/texture/nodes/node_texture_invert.cc +++ b/source/blender/nodes/texture/nodes/node_texture_invert.cc @@ -55,5 +55,5 @@ void register_node_type_tex_invert() blender::bke::node_type_socket_templates(&ntype, inputs, outputs); ntype.exec_fn = exec; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } diff --git a/source/blender/nodes/texture/nodes/node_texture_math.cc b/source/blender/nodes/texture/nodes/node_texture_math.cc index cc0f2c0d0fd..f55b7fcc31c 100644 --- a/source/blender/nodes/texture/nodes/node_texture_math.cc +++ b/source/blender/nodes/texture/nodes/node_texture_math.cc @@ -340,5 +340,5 @@ void register_node_type_tex_math() ntype.exec_fn = exec; ntype.updatefunc = node_math_update; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } diff --git a/source/blender/nodes/texture/nodes/node_texture_mixRgb.cc b/source/blender/nodes/texture/nodes/node_texture_mixRgb.cc index 5460beba8eb..4c617baefb1 100644 --- a/source/blender/nodes/texture/nodes/node_texture_mixRgb.cc +++ b/source/blender/nodes/texture/nodes/node_texture_mixRgb.cc @@ -66,5 +66,5 @@ void register_node_type_tex_mix_rgb() ntype.labelfunc = node_blend_label; ntype.exec_fn = exec; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } diff --git a/source/blender/nodes/texture/nodes/node_texture_output.cc b/source/blender/nodes/texture/nodes/node_texture_output.cc index 2216f7bc4b0..10c425e84aa 100644 --- a/source/blender/nodes/texture/nodes/node_texture_output.cc +++ b/source/blender/nodes/texture/nodes/node_texture_output.cc @@ -143,13 +143,13 @@ void register_node_type_tex_output() ntype.enum_name_legacy = "OUTPUT"; ntype.nclass = NODE_CLASS_OUTPUT; blender::bke::node_type_socket_templates(&ntype, inputs, nullptr); - blender::bke::node_type_size_preset(&ntype, blender::bke::eNodeSizePreset::Middle); + blender::bke::node_type_size_preset(ntype, blender::bke::eNodeSizePreset::Middle); ntype.initfunc = init; - blender::bke::node_type_storage(&ntype, "TexNodeOutput", node_free_standard_storage, copy); + blender::bke::node_type_storage(ntype, "TexNodeOutput", node_free_standard_storage, copy); ntype.exec_fn = exec; ntype.flag |= NODE_PREVIEW; ntype.no_muting = true; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } diff --git a/source/blender/nodes/texture/nodes/node_texture_proc.cc b/source/blender/nodes/texture/nodes/node_texture_proc.cc index c1973e9df6b..3687018a04f 100644 --- a/source/blender/nodes/texture/nodes/node_texture_proc.cc +++ b/source/blender/nodes/texture/nodes/node_texture_proc.cc @@ -262,14 +262,14 @@ static void init(bNodeTree * /*ntree*/, bNode *node) ntype.enum_name_legacy = EnumNameLegacy; \ ntype.nclass = NODE_CLASS_TEXTURE; \ blender::bke::node_type_socket_templates(&ntype, name##_inputs, outputs); \ - blender::bke::node_type_size_preset(&ntype, blender::bke::eNodeSizePreset::Middle); \ + blender::bke::node_type_size_preset(ntype, blender::bke::eNodeSizePreset::Middle); \ ntype.initfunc = init; \ blender::bke::node_type_storage( \ - &ntype, "Tex", node_free_standard_storage, node_copy_standard_storage); \ + ntype, "Tex", node_free_standard_storage, node_copy_standard_storage); \ ntype.exec_fn = name##_exec; \ ntype.flag |= NODE_PREVIEW; \ \ - blender::bke::node_register_type(&ntype); \ + blender::bke::node_register_type(ntype); \ } #define C outputs_color_only diff --git a/source/blender/nodes/texture/nodes/node_texture_rotate.cc b/source/blender/nodes/texture/nodes/node_texture_rotate.cc index de5214fc0ed..273f9f4c1bc 100644 --- a/source/blender/nodes/texture/nodes/node_texture_rotate.cc +++ b/source/blender/nodes/texture/nodes/node_texture_rotate.cc @@ -88,5 +88,5 @@ void register_node_type_tex_rotate() blender::bke::node_type_socket_templates(&ntype, inputs, outputs); ntype.exec_fn = exec; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } diff --git a/source/blender/nodes/texture/nodes/node_texture_scale.cc b/source/blender/nodes/texture/nodes/node_texture_scale.cc index b3c79e8c3c0..ce6307d5780 100644 --- a/source/blender/nodes/texture/nodes/node_texture_scale.cc +++ b/source/blender/nodes/texture/nodes/node_texture_scale.cc @@ -61,5 +61,5 @@ void register_node_type_tex_scale() blender::bke::node_type_socket_templates(&ntype, inputs, outputs); ntype.exec_fn = exec; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } diff --git a/source/blender/nodes/texture/nodes/node_texture_separate_color.cc b/source/blender/nodes/texture/nodes/node_texture_separate_color.cc index d323da21008..ae10a666561 100644 --- a/source/blender/nodes/texture/nodes/node_texture_separate_color.cc +++ b/source/blender/nodes/texture/nodes/node_texture_separate_color.cc @@ -102,5 +102,5 @@ void register_node_type_tex_separate_color() ntype.exec_fn = exec; ntype.updatefunc = update; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } diff --git a/source/blender/nodes/texture/nodes/node_texture_texture.cc b/source/blender/nodes/texture/nodes/node_texture_texture.cc index bdd7dbc4996..b4fd861c8e4 100644 --- a/source/blender/nodes/texture/nodes/node_texture_texture.cc +++ b/source/blender/nodes/texture/nodes/node_texture_texture.cc @@ -92,5 +92,5 @@ void register_node_type_tex_texture() ntype.exec_fn = exec; ntype.flag |= NODE_PREVIEW; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } diff --git a/source/blender/nodes/texture/nodes/node_texture_translate.cc b/source/blender/nodes/texture/nodes/node_texture_translate.cc index e3de1a9654d..b432745bca4 100644 --- a/source/blender/nodes/texture/nodes/node_texture_translate.cc +++ b/source/blender/nodes/texture/nodes/node_texture_translate.cc @@ -54,5 +54,5 @@ void register_node_type_tex_translate() blender::bke::node_type_socket_templates(&ntype, inputs, outputs); ntype.exec_fn = exec; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } diff --git a/source/blender/nodes/texture/nodes/node_texture_valToNor.cc b/source/blender/nodes/texture/nodes/node_texture_valToNor.cc index ee28049539d..6977691c5c7 100644 --- a/source/blender/nodes/texture/nodes/node_texture_valToNor.cc +++ b/source/blender/nodes/texture/nodes/node_texture_valToNor.cc @@ -71,5 +71,5 @@ void register_node_type_tex_valtonor() blender::bke::node_type_socket_templates(&ntype, inputs, outputs); ntype.exec_fn = exec; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } diff --git a/source/blender/nodes/texture/nodes/node_texture_valToRgb.cc b/source/blender/nodes/texture/nodes/node_texture_valToRgb.cc index a829c8429c7..b196a917300 100644 --- a/source/blender/nodes/texture/nodes/node_texture_valToRgb.cc +++ b/source/blender/nodes/texture/nodes/node_texture_valToRgb.cc @@ -54,13 +54,13 @@ void register_node_type_tex_valtorgb() ntype.enum_name_legacy = "VALTORGB"; ntype.nclass = NODE_CLASS_CONVERTER; blender::bke::node_type_socket_templates(&ntype, valtorgb_in, valtorgb_out); - blender::bke::node_type_size_preset(&ntype, blender::bke::eNodeSizePreset::Large); + blender::bke::node_type_size_preset(ntype, blender::bke::eNodeSizePreset::Large); ntype.initfunc = valtorgb_init; blender::bke::node_type_storage( - &ntype, "ColorBand", node_free_standard_storage, node_copy_standard_storage); + ntype, "ColorBand", node_free_standard_storage, node_copy_standard_storage); ntype.exec_fn = valtorgb_exec; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } /* **************** RGBTOBW ******************** */ @@ -102,5 +102,5 @@ void register_node_type_tex_rgbtobw() blender::bke::node_type_socket_templates(&ntype, rgbtobw_in, rgbtobw_out); ntype.exec_fn = rgbtobw_exec; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } diff --git a/source/blender/nodes/texture/nodes/node_texture_viewer.cc b/source/blender/nodes/texture/nodes/node_texture_viewer.cc index dfa935e78ba..16f0ed57f6f 100644 --- a/source/blender/nodes/texture/nodes/node_texture_viewer.cc +++ b/source/blender/nodes/texture/nodes/node_texture_viewer.cc @@ -45,5 +45,5 @@ void register_node_type_tex_viewer() ntype.no_muting = true; ntype.flag |= NODE_PREVIEW; - blender::bke::node_register_type(&ntype); + blender::bke::node_register_type(ntype); } From d5c662a305a7088e0878d863be7d44d75594831e Mon Sep 17 00:00:00 2001 From: Omar Emara Date: Wed, 19 Feb 2025 13:56:06 +0100 Subject: [PATCH 11/31] Fix #134436: Compositor is much slower on Windows The new CPU compositor in v4.4 is much slower than the old CPU compositor in v4.3 on Windows. This is because MSVC does not inline many of the core methods in the Result class of the compositor. To fix this, we force inline those methods, adding a new macro for inlining methods in the process, since the existing macro has the static keyword, which only works for functions, not methods. Pull Request: https://projects.blender.org/blender/blender/pulls/134748 --- source/blender/blenlib/BLI_compiler_compat.h | 6 ++ source/blender/compositor/COM_result.hh | 90 +++++++++++--------- 2 files changed, 55 insertions(+), 41 deletions(-) diff --git a/source/blender/blenlib/BLI_compiler_compat.h b/source/blender/blenlib/BLI_compiler_compat.h index 80fb3994ecd..0b6ddac6712 100644 --- a/source/blender/blenlib/BLI_compiler_compat.h +++ b/source/blender/blenlib/BLI_compiler_compat.h @@ -37,6 +37,12 @@ template static inline T decltype_helper(T x) # define BLI_INLINE static inline __attribute__((always_inline)) __attribute__((__unused__)) #endif +#if defined(_MSC_VER) +# define BLI_INLINE_METHOD __forceinline +#else +# define BLI_INLINE_METHOD inline __attribute__((always_inline)) __attribute__((__unused__)) +#endif + #if defined(__GNUC__) # define BLI_NOINLINE __attribute__((noinline)) #elif defined(_MSC_VER) diff --git a/source/blender/compositor/COM_result.hh b/source/blender/compositor/COM_result.hh index d3c923bbd6a..ecaf7f0ab0d 100644 --- a/source/blender/compositor/COM_result.hh +++ b/source/blender/compositor/COM_result.hh @@ -513,12 +513,12 @@ class Result { /* Inline Methods. */ -inline const Domain &Result::domain() const +BLI_INLINE_METHOD const Domain &Result::domain() const { return domain_; } -inline int64_t Result::channels_count() const +BLI_INLINE_METHOD int64_t Result::channels_count() const { switch (type_) { case ResultType::Float: @@ -536,19 +536,19 @@ inline int64_t Result::channels_count() const return 4; } -inline float *Result::float_texture() const +BLI_INLINE_METHOD float *Result::float_texture() const { BLI_assert(storage_type_ == ResultStorageType::FloatCPU); return float_texture_; } -inline int *Result::integer_texture() const +BLI_INLINE_METHOD int *Result::integer_texture() const { BLI_assert(storage_type_ == ResultStorageType::IntegerCPU); return integer_texture_; } -inline void *Result::data() const +BLI_INLINE_METHOD void *Result::data() const { switch (storage_type_) { case ResultStorageType::FloatCPU: @@ -563,7 +563,7 @@ inline void *Result::data() const return nullptr; } -template inline const T &Result::get_single_value() const +template BLI_INLINE_METHOD const T &Result::get_single_value() const { BLI_assert(this->is_single_value()); static_assert(Result::is_supported_type()); @@ -597,12 +597,13 @@ template inline const T &Result::get_single_value() const } } -template inline T &Result::get_single_value() +template BLI_INLINE_METHOD T &Result::get_single_value() { return const_cast(std::as_const(*this).get_single_value()); } -template inline T Result::get_single_value_default(const T &default_value) const +template +BLI_INLINE_METHOD T Result::get_single_value_default(const T &default_value) const { if (this->is_single_value()) { return this->get_single_value(); @@ -610,7 +611,7 @@ template inline T Result::get_single_value_default(const T &default_ return default_value; } -template inline void Result::set_single_value(const T &value) +template BLI_INLINE_METHOD void Result::set_single_value(const T &value) { BLI_assert(this->is_allocated()); BLI_assert(this->is_single_value()); @@ -660,7 +661,8 @@ template inline void Result::set_single_value(const T &value) } } -template inline T Result::load_pixel(const int2 &texel) const +template +BLI_INLINE_METHOD T Result::load_pixel(const int2 &texel) const { if constexpr (CouldBeSingleValue) { if (is_single_value_) { @@ -680,7 +682,7 @@ template inline T Result::load_pixel(const } template -inline T Result::load_pixel_extended(const int2 &texel) const +BLI_INLINE_METHOD T Result::load_pixel_extended(const int2 &texel) const { if constexpr (CouldBeSingleValue) { if (is_single_value_) { @@ -701,7 +703,7 @@ inline T Result::load_pixel_extended(const int2 &texel) const } template -inline T Result::load_pixel_fallback(const int2 &texel, const T &fallback) const +BLI_INLINE_METHOD T Result::load_pixel_fallback(const int2 &texel, const T &fallback) const { if constexpr (CouldBeSingleValue) { if (is_single_value_) { @@ -725,12 +727,12 @@ inline T Result::load_pixel_fallback(const int2 &texel, const T &fallback) const } template -inline T Result::load_pixel_zero(const int2 &texel) const +BLI_INLINE_METHOD T Result::load_pixel_zero(const int2 &texel) const { return this->load_pixel_fallback(texel, T(0)); } -inline float4 Result::load_pixel_generic_type(const int2 &texel) const +BLI_INLINE_METHOD float4 Result::load_pixel_generic_type(const int2 &texel) const { float4 pixel_value = float4(0.0f, 0.0f, 0.0f, 1.0f); if (is_single_value_) { @@ -742,7 +744,8 @@ inline float4 Result::load_pixel_generic_type(const int2 &texel) const return pixel_value; } -template inline void Result::store_pixel(const int2 &texel, const T &pixel_value) +template +BLI_INLINE_METHOD void Result::store_pixel(const int2 &texel, const T &pixel_value) { if constexpr (std::is_scalar_v) { *this->get_pixel(texel) = pixel_value; @@ -753,12 +756,13 @@ template inline void Result::store_pixel(const int2 &texel, const T } } -inline void Result::store_pixel_generic_type(const int2 &texel, const float4 &pixel_value) +BLI_INLINE_METHOD void Result::store_pixel_generic_type(const int2 &texel, + const float4 &pixel_value) { this->copy_pixel(this->get_float_pixel(texel), pixel_value); } -inline float4 Result::sample_nearest_zero(const float2 &coordinates) const +BLI_INLINE_METHOD float4 Result::sample_nearest_zero(const float2 &coordinates) const { float4 pixel_value = float4(0.0f, 0.0f, 0.0f, 1.0f); if (is_single_value_) { @@ -779,9 +783,9 @@ inline float4 Result::sample_nearest_zero(const float2 &coordinates) const return pixel_value; } -inline float4 Result::sample_nearest_wrap(const float2 &coordinates, - bool wrap_x, - bool wrap_y) const +BLI_INLINE_METHOD float4 Result::sample_nearest_wrap(const float2 &coordinates, + bool wrap_x, + bool wrap_y) const { float4 pixel_value = float4(0.0f, 0.0f, 0.0f, 1.0f); if (is_single_value_) { @@ -805,9 +809,9 @@ inline float4 Result::sample_nearest_wrap(const float2 &coordinates, return pixel_value; } -inline float4 Result::sample_bilinear_wrap(const float2 &coordinates, - bool wrap_x, - bool wrap_y) const +BLI_INLINE_METHOD float4 Result::sample_bilinear_wrap(const float2 &coordinates, + bool wrap_x, + bool wrap_y) const { float4 pixel_value = float4(0.0f, 0.0f, 0.0f, 1.0f); if (is_single_value_) { @@ -831,7 +835,9 @@ inline float4 Result::sample_bilinear_wrap(const float2 &coordinates, return pixel_value; } -inline float4 Result::sample_cubic_wrap(const float2 &coordinates, bool wrap_x, bool wrap_y) const +BLI_INLINE_METHOD float4 Result::sample_cubic_wrap(const float2 &coordinates, + bool wrap_x, + bool wrap_y) const { float4 pixel_value = float4(0.0f, 0.0f, 0.0f, 1.0f); if (is_single_value_) { @@ -855,7 +861,7 @@ inline float4 Result::sample_cubic_wrap(const float2 &coordinates, bool wrap_x, return pixel_value; } -inline float4 Result::sample_bilinear_zero(const float2 &coordinates) const +BLI_INLINE_METHOD float4 Result::sample_bilinear_zero(const float2 &coordinates) const { float4 pixel_value = float4(0.0f, 0.0f, 0.0f, 1.0f); if (is_single_value_) { @@ -876,7 +882,7 @@ inline float4 Result::sample_bilinear_zero(const float2 &coordinates) const return pixel_value; } -inline float4 Result::sample_nearest_extended(const float2 &coordinates) const +BLI_INLINE_METHOD float4 Result::sample_nearest_extended(const float2 &coordinates) const { float4 pixel_value = float4(0.0f, 0.0f, 0.0f, 1.0f); if (is_single_value_) { @@ -897,7 +903,7 @@ inline float4 Result::sample_nearest_extended(const float2 &coordinates) const return pixel_value; } -inline float4 Result::sample_bilinear_extended(const float2 &coordinates) const +BLI_INLINE_METHOD float4 Result::sample_bilinear_extended(const float2 &coordinates) const { float4 pixel_value = float4(0.0f, 0.0f, 0.0f, 1.0f); if (is_single_value_) { @@ -929,9 +935,9 @@ static void sample_ewa_extended_read_callback(void *userdata, int x, int y, floa copy_v4_v4(result, sampled_result); } -inline float4 Result::sample_ewa_extended(const float2 &coordinates, - const float2 &x_gradient, - const float2 &y_gradient) const +BLI_INLINE_METHOD float4 Result::sample_ewa_extended(const float2 &coordinates, + const float2 &x_gradient, + const float2 &y_gradient) const { BLI_assert(type_ == ResultType::Color); @@ -966,9 +972,9 @@ static void sample_ewa_zero_read_callback(void *userdata, int x, int y, float re copy_v4_v4(result, sampled_result); } -inline float4 Result::sample_ewa_zero(const float2 &coordinates, - const float2 &x_gradient, - const float2 &y_gradient) const +BLI_INLINE_METHOD float4 Result::sample_ewa_zero(const float2 &coordinates, + const float2 &x_gradient, + const float2 &y_gradient) const { BLI_assert(type_ == ResultType::Color); @@ -1017,7 +1023,7 @@ template constexpr bool Result::is_supported_type() return is_same_any_v; } -template inline int64_t Result::get_pixel_index(const int2 &texel) const +template BLI_INLINE_METHOD int64_t Result::get_pixel_index(const int2 &texel) const { BLI_assert(!is_single_value_); BLI_assert(this->is_allocated()); @@ -1030,7 +1036,7 @@ template inline int64_t Result::get_pixel_index(const int2 &texel) c return (int64_t(texel.y) * domain_.size.x + texel.x) * channels_count; } -inline int64_t Result::get_pixel_index(const int2 &texel) const +BLI_INLINE_METHOD int64_t Result::get_pixel_index(const int2 &texel) const { BLI_assert(!is_single_value_); BLI_assert(this->is_allocated()); @@ -1039,7 +1045,7 @@ inline int64_t Result::get_pixel_index(const int2 &texel) const } template -inline std::conditional_t(), int, float> *Result::get_pixel( +BLI_INLINE_METHOD std::conditional_t(), int, float> *Result::get_pixel( const int2 &texel) const { if constexpr (Result::is_int_type()) { @@ -1050,19 +1056,21 @@ inline std::conditional_t(), int, float> *Result::get_pix } } -inline float *Result::get_float_pixel(const int2 &texel) const +BLI_INLINE_METHOD float *Result::get_float_pixel(const int2 &texel) const { BLI_assert(storage_type_ == ResultStorageType::FloatCPU); return float_texture_ + this->get_pixel_index(texel); } -inline int *Result::get_integer_pixel(const int2 &texel) const +BLI_INLINE_METHOD int *Result::get_integer_pixel(const int2 &texel) const { BLI_assert(storage_type_ == ResultStorageType::IntegerCPU); return integer_texture_ + this->get_pixel_index(texel); } -inline void Result::copy_pixel(float *target, const float *source, const int channels_count) +BLI_INLINE_METHOD void Result::copy_pixel(float *target, + const float *source, + const int channels_count) { switch (channels_count) { case 1: @@ -1083,7 +1091,7 @@ inline void Result::copy_pixel(float *target, const float *source, const int cha } } -inline void Result::copy_pixel(int *target, const int *source, const int channels_count) +BLI_INLINE_METHOD void Result::copy_pixel(int *target, const int *source, const int channels_count) { switch (channels_count) { case 1: @@ -1098,7 +1106,7 @@ inline void Result::copy_pixel(int *target, const int *source, const int channel } } -inline void Result::copy_pixel(float *target, const float *source) const +BLI_INLINE_METHOD void Result::copy_pixel(float *target, const float *source) const { switch (type_) { case ResultType::Float: From 3dc9211b8f81c52e1dab83799e94a6c35246df2f Mon Sep 17 00:00:00 2001 From: Philipp Oeser Date: Wed, 19 Feb 2025 14:28:14 +0100 Subject: [PATCH 12/31] Fix #134662: Video Sequencer: reset transforms ignores auto keyframing Just call the appropriate autokeyframe functions when this operator changes StripTransform properties. Pull Request: https://projects.blender.org/blender/blender/pulls/134667 --- .../editors/space_sequencer/sequencer_edit.cc | 44 +++++++++++++++++++ 1 file changed, 44 insertions(+) diff --git a/source/blender/editors/space_sequencer/sequencer_edit.cc b/source/blender/editors/space_sequencer/sequencer_edit.cc index 61997a8b115..676b31cd177 100644 --- a/source/blender/editors/space_sequencer/sequencer_edit.cc +++ b/source/blender/editors/space_sequencer/sequencer_edit.cc @@ -3238,20 +3238,47 @@ static int sequencer_strip_transform_clear_exec(bContext *C, wmOperator *op) const Editing *ed = SEQ_editing_get(scene); const int property = RNA_enum_get(op->ptr, "property"); + const bool use_autokeyframe = blender::animrig::is_autokey_on(scene); + const bool only_when_keyed = blender::animrig::is_keying_flag(scene, + AUTOKEY_FLAG_INSERTAVAILABLE); + LISTBASE_FOREACH (Strip *, strip, ed->seqbasep) { if (strip->flag & SELECT && strip->type != STRIP_TYPE_SOUND_RAM) { StripTransform *transform = strip->data->transform; + PropertyRNA *prop; + PointerRNA ptr = RNA_pointer_create_discrete(&scene->id, &RNA_StripTransform, transform); switch (property) { case STRIP_TRANSFORM_POSITION: transform->xofs = 0; transform->yofs = 0; + if (use_autokeyframe) { + prop = RNA_struct_find_property(&ptr, "offset_x"); + blender::animrig::autokeyframe_property( + C, scene, &ptr, prop, -1, scene->r.cfra, only_when_keyed); + prop = RNA_struct_find_property(&ptr, "offset_y"); + blender::animrig::autokeyframe_property( + C, scene, &ptr, prop, -1, scene->r.cfra, only_when_keyed); + } break; case STRIP_TRANSFORM_SCALE: transform->scale_x = 1.0f; transform->scale_y = 1.0f; + if (use_autokeyframe) { + prop = RNA_struct_find_property(&ptr, "scale_x"); + blender::animrig::autokeyframe_property( + C, scene, &ptr, prop, -1, scene->r.cfra, only_when_keyed); + prop = RNA_struct_find_property(&ptr, "scale_y"); + blender::animrig::autokeyframe_property( + C, scene, &ptr, prop, -1, scene->r.cfra, only_when_keyed); + } break; case STRIP_TRANSFORM_ROTATION: transform->rotation = 0.0f; + if (use_autokeyframe) { + prop = RNA_struct_find_property(&ptr, "rotation"); + blender::animrig::autokeyframe_property( + C, scene, &ptr, prop, -1, scene->r.cfra, only_when_keyed); + } break; case STRIP_TRANSFORM_ALL: transform->xofs = 0; @@ -3259,6 +3286,23 @@ static int sequencer_strip_transform_clear_exec(bContext *C, wmOperator *op) transform->scale_x = 1.0f; transform->scale_y = 1.0f; transform->rotation = 0.0f; + if (use_autokeyframe) { + prop = RNA_struct_find_property(&ptr, "offset_x"); + blender::animrig::autokeyframe_property( + C, scene, &ptr, prop, -1, scene->r.cfra, only_when_keyed); + prop = RNA_struct_find_property(&ptr, "offset_y"); + blender::animrig::autokeyframe_property( + C, scene, &ptr, prop, -1, scene->r.cfra, only_when_keyed); + prop = RNA_struct_find_property(&ptr, "scale_x"); + blender::animrig::autokeyframe_property( + C, scene, &ptr, prop, -1, scene->r.cfra, only_when_keyed); + prop = RNA_struct_find_property(&ptr, "scale_y"); + blender::animrig::autokeyframe_property( + C, scene, &ptr, prop, -1, scene->r.cfra, only_when_keyed); + prop = RNA_struct_find_property(&ptr, "rotation"); + blender::animrig::autokeyframe_property( + C, scene, &ptr, prop, -1, scene->r.cfra, only_when_keyed); + } break; } SEQ_relations_invalidate_cache_preprocessed(scene, strip); From 7847df4686b0259a1f0ab61530599a45e0a50fde Mon Sep 17 00:00:00 2001 From: Philipp Oeser Date: Wed, 19 Feb 2025 15:06:06 +0100 Subject: [PATCH 13/31] Pointcloud: Integration with transverts (cursor snapping) This adds: - support for snapping for the pointcloud object (selection to cursor/ grid, cursor to selection) - as usual, "Warp" an "Randomize" operators come along "for free" with this Pull Request: https://projects.blender.org/blender/blender/pulls/134799 --- scripts/startup/bl_ui/space_view3d.py | 1 + source/blender/editors/util/ed_transverts.cc | 30 +++++++++++++++++++- 2 files changed, 30 insertions(+), 1 deletion(-) diff --git a/scripts/startup/bl_ui/space_view3d.py b/scripts/startup/bl_ui/space_view3d.py index 0d95b12ee7f..061ae76adc2 100644 --- a/scripts/startup/bl_ui/space_view3d.py +++ b/scripts/startup/bl_ui/space_view3d.py @@ -1285,6 +1285,7 @@ def draw(self, context): 'EDIT_CURVES', 'EDIT_LATTICE', 'EDIT_METABALL', + 'EDIT_POINT_CLOUD', }: layout.operator("transform.vertex_warp", text="Warp") layout.operator_context = 'EXEC_REGION_WIN' diff --git a/source/blender/editors/util/ed_transverts.cc b/source/blender/editors/util/ed_transverts.cc index da217df418a..282a0777954 100644 --- a/source/blender/editors/util/ed_transverts.cc +++ b/source/blender/editors/util/ed_transverts.cc @@ -14,6 +14,7 @@ #include "DNA_lattice_types.h" #include "DNA_meta_types.h" #include "DNA_object_types.h" +#include "DNA_pointcloud_types.h" #include "DNA_scene_types.h" #include "BLI_listbase.h" @@ -31,6 +32,7 @@ #include "ED_armature.hh" #include "ED_curves.hh" +#include "ED_point_cloud.hh" #include "ANIM_bone_collections.hh" @@ -163,6 +165,10 @@ void ED_transverts_update_obedit(TransVertStore *tvs, Object *obedit) curves.tag_positions_changed(); curves.calculate_bezier_auto_handles(); } + else if (obedit->type == OB_POINTCLOUD) { + PointCloud *pointcloud = static_cast(obedit->data); + pointcloud->tag_positions_changed(); + } } static void set_mapped_co(void *vuserdata, int index, const float co[3], const float /*no*/[3]) @@ -200,11 +206,14 @@ bool ED_transverts_check_obedit(const Object *obedit) OB_SURF, OB_CURVES_LEGACY, OB_MBALL, - OB_CURVES); + OB_CURVES, + OB_POINTCLOUD); } void ED_transverts_create_from_obedit(TransVertStore *tvs, const Object *obedit, const int mode) { + using namespace blender; + Nurb *nu; BezTriple *bezt; BPoint *bp; @@ -507,6 +516,25 @@ void ED_transverts_create_from_obedit(TransVertStore *tvs, const Object *obedit, Curves *curves_id = static_cast(obedit->data); blender::ed::curves::transverts_from_curves_positions_create(curves_id->geometry.wrap(), tvs); } + else if (obedit->type == OB_POINTCLOUD) { + PointCloud *pointcloud = static_cast(obedit->data); + + IndexMaskMemory memory; + const IndexMask selection = blender::ed::point_cloud::retrieve_selected_points(*pointcloud, + memory); + MutableSpan positions = pointcloud->positions_for_write(); + + tvs->transverts = static_cast( + MEM_calloc_arrayN(selection.size(), sizeof(TransVert), __func__)); + tvs->transverts_tot = selection.size(); + + selection.foreach_index(GrainSize(1024), [&](const int64_t i, const int64_t pos) { + TransVert &tv = tvs->transverts[pos]; + tv.loc = positions[i]; + tv.flag = SELECT; + copy_v3_v3(tv.oldloc, tv.loc); + }); + } if (!tvs->transverts_tot && tvs->transverts) { /* Prevent memory leak. happens for curves/lattices due to From cc2d85ae7c995dd28254d7ab189c99b7b31dbb9b Mon Sep 17 00:00:00 2001 From: Hans Goudey Date: Wed, 19 Feb 2025 08:26:56 -0500 Subject: [PATCH 14/31] Point Cloud: Support view selected operator in edit mode --- .../editors/space_view3d/view3d_snap.cc | 40 ++++++++++++++----- 1 file changed, 29 insertions(+), 11 deletions(-) diff --git a/source/blender/editors/space_view3d/view3d_snap.cc b/source/blender/editors/space_view3d/view3d_snap.cc index 3f6ae2cdbe4..166e1a6a4c8 100644 --- a/source/blender/editors/space_view3d/view3d_snap.cc +++ b/source/blender/editors/space_view3d/view3d_snap.cc @@ -8,6 +8,7 @@ #include "DNA_armature_types.h" #include "DNA_object_types.h" +#include "DNA_pointcloud_types.h" #include "BLI_bounds.hh" #include "BLI_listbase.h" @@ -45,6 +46,7 @@ #include "ED_grease_pencil.hh" #include "ED_keyframing.hh" #include "ED_object.hh" +#include "ED_point_cloud.hh" #include "ED_screen.hh" #include "ED_transverts.hh" @@ -1042,6 +1044,23 @@ bool ED_view3d_minmax_verts(const Scene *scene, Object *obedit, float r_min[3], } return changed; } + if (obedit->type == OB_POINTCLOUD) { + const Object &ob_orig = *DEG_get_original_object(obedit); + const PointCloud &pointcloud = *static_cast(ob_orig.data); + + IndexMaskMemory memory; + const IndexMask mask = point_cloud::retrieve_selected_points(pointcloud, memory); + + const std::optional> bounds = bounds_min_max_with_transform( + obedit->object_to_world(), pointcloud.positions(), mask); + + if (bounds) { + minmax_v3v3_v3(r_min, r_max, bounds->min); + minmax_v3v3_v3(r_min, r_max, bounds->max); + return true; + } + return false; + } if (obedit->type == OB_CURVES) { const Object &ob_orig = *DEG_get_original_object(obedit); const Curves &curves_id = *static_cast(ob_orig.data); @@ -1053,12 +1072,12 @@ bool ED_view3d_minmax_verts(const Scene *scene, Object *obedit, float r_min[3], const bke::crazyspace::GeometryDeformation deformation = bke::crazyspace::get_evaluated_curves_deformation(obedit, ob_orig); - const std::optional> curves_bounds = bounds_min_max_with_transform( + const std::optional> bounds = bounds_min_max_with_transform( obedit->object_to_world(), deformation.positions, mask); - if (curves_bounds) { - minmax_v3v3_v3(r_min, r_max, curves_bounds->min); - minmax_v3v3_v3(r_min, r_max, curves_bounds->max); + if (bounds) { + minmax_v3v3_v3(r_min, r_max, bounds->min); + minmax_v3v3_v3(r_min, r_max, bounds->max); return true; } return false; @@ -1067,7 +1086,7 @@ bool ED_view3d_minmax_verts(const Scene *scene, Object *obedit, float r_min[3], Object &ob_orig = *DEG_get_original_object(obedit); GreasePencil &grease_pencil = *static_cast(ob_orig.data); - std::optional> grease_pencil_bounds = std::nullopt; + std::optional> bounds = std::nullopt; const Vector drawings = greasepencil::retrieve_editable_drawings(*scene, grease_pencil); @@ -1091,14 +1110,13 @@ bool ED_view3d_minmax_verts(const Scene *scene, Object *obedit, float r_min[3], const bke::greasepencil::Layer &layer = grease_pencil.layer(info.layer_index); const float4x4 layer_to_world = layer.to_world_space(*obedit); - grease_pencil_bounds = bounds::merge( - grease_pencil_bounds, - bounds_min_max_with_transform(layer_to_world, deformation.positions, points)); + bounds = bounds::merge( + bounds, bounds_min_max_with_transform(layer_to_world, deformation.positions, points)); } - if (grease_pencil_bounds) { - minmax_v3v3_v3(r_min, r_max, grease_pencil_bounds->min); - minmax_v3v3_v3(r_min, r_max, grease_pencil_bounds->max); + if (bounds) { + minmax_v3v3_v3(r_min, r_max, bounds->min); + minmax_v3v3_v3(r_min, r_max, bounds->max); return true; } return false; From 2f01da564df9da45725d04b5470cb66d5b189146 Mon Sep 17 00:00:00 2001 From: Hans Goudey Date: Wed, 19 Feb 2025 09:14:26 -0500 Subject: [PATCH 15/31] Fix: Point Cloud: Properly handle caches in undo step decode Previously the bounds and BVH caches could be incorrect after redo. --- .../editors/point_cloud/intern/point_cloud_undo.cc | 11 +++++++++++ 1 file changed, 11 insertions(+) diff --git a/source/blender/editors/point_cloud/intern/point_cloud_undo.cc b/source/blender/editors/point_cloud/intern/point_cloud_undo.cc index a2b061b8424..d2d5fabdb8c 100644 --- a/source/blender/editors/point_cloud/intern/point_cloud_undo.cc +++ b/source/blender/editors/point_cloud/intern/point_cloud_undo.cc @@ -40,6 +40,8 @@ struct StepObject { UndoRefID_Object obedit_ref = {}; CustomData custom_data = {}; int totpoint = 0; + /* Store the bounds cache because it's small. */ + SharedCache> bounds_cache; }; struct PointCloudUndoStep { @@ -68,6 +70,7 @@ static bool step_encode(bContext *C, Main *bmain, UndoStep *us_p) object.obedit_ref.ptr = ob; CustomData_init_from( &point_cloud.pdata, &object.custom_data, CD_MASK_ALL, point_cloud.totpoint); + object.bounds_cache = point_cloud.runtime->bounds_cache; object.totpoint = point_cloud.totpoint; } }); @@ -96,9 +99,17 @@ static void step_decode( for (const StepObject &object : us->objects) { PointCloud &point_cloud = *static_cast(object.obedit_ref.ptr->data); + const bool positions_changed = + CustomData_get_layer_named(&point_cloud.pdata, CD_PROP_FLOAT3, "position") != + CustomData_get_layer_named(&object.custom_data, CD_PROP_FLOAT3, "position"); + CustomData_free(&point_cloud.pdata); CustomData_init_from(&object.custom_data, &point_cloud.pdata, CD_MASK_ALL, object.totpoint); point_cloud.totpoint = object.totpoint; + point_cloud.runtime->bounds_cache = object.bounds_cache; + if (positions_changed) { + point_cloud.runtime->bvh_cache.tag_dirty(); + } DEG_id_tag_update(&point_cloud.id, ID_RECALC_GEOMETRY); } From 5a6d2e1ce29bafabae0f3f706834cbb0b4acd172 Mon Sep 17 00:00:00 2001 From: Hans Goudey Date: Wed, 19 Feb 2025 15:24:29 +0100 Subject: [PATCH 16/31] Curves: Implement join operator Previously the object join operator wasn't implemented for the new curves type. This commit implements the joining by passing the selected curves geometry as instances to the realize instances function. That way the complexity of the new code just relates to dealing with objects. Pull Request: https://projects.blender.org/blender/blender/pulls/134691 --- source/blender/editors/curves/CMakeLists.txt | 1 + source/blender/editors/curves/intern/join.cc | 87 ++++++++++++++++++++ source/blender/editors/include/ED_curves.hh | 3 + source/blender/editors/object/object_add.cc | 6 +- 4 files changed, 96 insertions(+), 1 deletion(-) create mode 100644 source/blender/editors/curves/intern/join.cc diff --git a/source/blender/editors/curves/CMakeLists.txt b/source/blender/editors/curves/CMakeLists.txt index bd76b37b5e5..36d04971b14 100644 --- a/source/blender/editors/curves/CMakeLists.txt +++ b/source/blender/editors/curves/CMakeLists.txt @@ -24,6 +24,7 @@ set(SRC intern/curves_ops.cc intern/curves_selection.cc intern/curves_undo.cc + intern/join.cc intern/select_linked_pick.cc intern/separate.cc ) diff --git a/source/blender/editors/curves/intern/join.cc b/source/blender/editors/curves/intern/join.cc new file mode 100644 index 00000000000..37dd987b793 --- /dev/null +++ b/source/blender/editors/curves/intern/join.cc @@ -0,0 +1,87 @@ +/* SPDX-FileCopyrightText: 2025 Blender Authors + * + * SPDX-License-Identifier: GPL-2.0-or-later */ + +#include "DNA_scene_types.h" + +#include "BKE_context.hh" +#include "BKE_instances.hh" +#include "BKE_report.hh" + +#include "DEG_depsgraph.hh" +#include "DEG_depsgraph_build.hh" + +#include "WM_api.hh" +#include "WM_types.hh" + +#include "ED_curves.hh" +#include "ED_object.hh" + +#include "GEO_realize_instances.hh" + +namespace blender::ed::curves { + +int join_objects(bContext *C, wmOperator *op) +{ + Main *bmain = CTX_data_main(C); + Scene *scene = CTX_data_scene(C); + Object *active_object = CTX_data_active_object(C); + BLI_assert(active_object); + BLI_assert(active_object->type == OB_CURVES); + Curves &active_curves = *static_cast(active_object->data); + const float4x4 &world_to_active = active_object->world_to_object(); + + Vector objects{active_object}; + bool active_object_selected = false; + CTX_DATA_BEGIN (C, Object *, object, selected_editable_objects) { + if (object == active_object) { + active_object_selected = true; + continue; + } + if (object->type != OB_CURVES) { + continue; + } + objects.append(object); + } + CTX_DATA_END; + + if (!active_object_selected) { + BKE_report(op->reports, RPT_WARNING, "Active object is not a selected curves object"); + return OPERATOR_CANCELLED; + } + + bke::Instances instances; + instances.resize(objects.size()); + MutableSpan transforms = instances.transforms_for_write(); + MutableSpan references = instances.reference_handles_for_write(); + Map reference_by_orig_curves; + for (const int i : objects.index_range()) { + transforms[i] = world_to_active * objects[i]->object_to_world(); + const Curves *orig_curves = static_cast(objects[i]->data); + references[i] = reference_by_orig_curves.lookup_or_add_cb(orig_curves, [&]() { + auto geometry = bke::GeometrySet::from_curves(BKE_curves_copy_for_eval(orig_curves)); + return instances.add_new_reference(std::move(geometry)); + }); + } + + bke::GeometrySet realized_geometry = geometry::realize_instances( + bke::GeometrySet::from_instances(&instances, bke::GeometryOwnershipType::ReadOnly), + geometry::RealizeInstancesOptions()); + + Curves *realized_curves = realized_geometry.get_curves_for_write(); + active_curves.geometry.wrap() = std::move(realized_curves->geometry.wrap()); + + for (Object *object : objects.as_span().drop_front(1)) { + object::base_free_and_unlink(bmain, scene, object); + } + + DEG_relations_tag_update(bmain); + DEG_id_tag_update(&active_object->id, ID_RECALC_TRANSFORM | ID_RECALC_GEOMETRY); + DEG_id_tag_update(&scene->id, ID_RECALC_SELECT); + WM_event_add_notifier(C, NC_SCENE | ND_OB_ACTIVE, scene); + WM_event_add_notifier(C, NC_SCENE | ND_LAYER_CONTENT, scene); + + return OPERATOR_FINISHED; +} + +} // namespace blender::ed::curves diff --git a/source/blender/editors/include/ED_curves.hh b/source/blender/editors/include/ED_curves.hh index f9ab7c8bb5b..13afe48d9a8 100644 --- a/source/blender/editors/include/ED_curves.hh +++ b/source/blender/editors/include/ED_curves.hh @@ -26,6 +26,7 @@ struct ViewContext; struct rcti; struct TransVertStore; struct wmKeyConfig; +struct wmOperator; namespace blender::bke { enum class AttrDomain : int8_t; struct GSpanAttributeWriter; @@ -461,6 +462,8 @@ void resize_curves(bke::CurvesGeometry &curves, */ void reorder_curves(bke::CurvesGeometry &curves, Span old_by_new_indices_map); +int join_objects(bContext *C, wmOperator *op); + /** \} */ } // namespace blender::ed::curves diff --git a/source/blender/editors/object/object_add.cc b/source/blender/editors/object/object_add.cc index a4e300a3ed6..b8ef46e4d95 100644 --- a/source/blender/editors/object/object_add.cc +++ b/source/blender/editors/object/object_add.cc @@ -4714,7 +4714,8 @@ static bool object_join_poll(bContext *C) return false; } - if (ELEM(ob->type, OB_MESH, OB_CURVES_LEGACY, OB_SURF, OB_ARMATURE, OB_GREASE_PENCIL)) { + if (ELEM(ob->type, OB_MESH, OB_CURVES_LEGACY, OB_SURF, OB_ARMATURE, OB_GREASE_PENCIL, OB_CURVES)) + { return true; } return false; @@ -4751,6 +4752,9 @@ static int object_join_exec(bContext *C, wmOperator *op) else if (ob->type == OB_ARMATURE) { ret = ED_armature_join_objects_exec(C, op); } + else if (ob->type == OB_CURVES) { + ret = curves::join_objects(C, op); + } else if (ob->type == OB_GREASE_PENCIL) { ret = ED_grease_pencil_join_objects_exec(C, op); } From 0fd79c3613698e786b4da15a55160a9fc5b95ba8 Mon Sep 17 00:00:00 2001 From: Hans Goudey Date: Wed, 19 Feb 2025 15:30:12 +0100 Subject: [PATCH 17/31] Point Cloud: Implement join operator Similar to !134691. Pull Request: https://projects.blender.org/blender/blender/pulls/134702 --- .../blender/editors/include/ED_point_cloud.hh | 3 + source/blender/editors/object/object_add.cc | 13 ++- .../editors/point_cloud/CMakeLists.txt | 2 + .../editors/point_cloud/intern/join.cc | 91 +++++++++++++++++++ 4 files changed, 108 insertions(+), 1 deletion(-) create mode 100644 source/blender/editors/point_cloud/intern/join.cc diff --git a/source/blender/editors/include/ED_point_cloud.hh b/source/blender/editors/include/ED_point_cloud.hh index 7a7855685f6..57ba47340dc 100644 --- a/source/blender/editors/include/ED_point_cloud.hh +++ b/source/blender/editors/include/ED_point_cloud.hh @@ -24,6 +24,7 @@ struct PointCloud; struct rcti; struct UndoType; struct wmKeyConfig; +struct wmOperator; struct wmOperatorType; namespace blender::bke { struct GSpanAttributeWriter; @@ -143,6 +144,8 @@ void POINT_CLOUD_OT_attribute_set(wmOperatorType *ot); void POINT_CLOUD_OT_duplicate(wmOperatorType *ot); void POINT_CLOUD_OT_separate(wmOperatorType *ot); +int join_objects(bContext *C, wmOperator *op); + /** \} */ } // namespace blender::ed::point_cloud diff --git a/source/blender/editors/object/object_add.cc b/source/blender/editors/object/object_add.cc index b8ef46e4d95..375ed9d3939 100644 --- a/source/blender/editors/object/object_add.cc +++ b/source/blender/editors/object/object_add.cc @@ -121,6 +121,7 @@ #include "ED_object.hh" #include "ED_outliner.hh" #include "ED_physics.hh" +#include "ED_point_cloud.hh" #include "ED_render.hh" #include "ED_screen.hh" #include "ED_select_utils.hh" @@ -4714,7 +4715,14 @@ static bool object_join_poll(bContext *C) return false; } - if (ELEM(ob->type, OB_MESH, OB_CURVES_LEGACY, OB_SURF, OB_ARMATURE, OB_GREASE_PENCIL, OB_CURVES)) + if (ELEM(ob->type, + OB_MESH, + OB_CURVES_LEGACY, + OB_SURF, + OB_ARMATURE, + OB_CURVES, + OB_GREASE_PENCIL, + OB_POINTCLOUD)) { return true; } @@ -4752,6 +4760,9 @@ static int object_join_exec(bContext *C, wmOperator *op) else if (ob->type == OB_ARMATURE) { ret = ED_armature_join_objects_exec(C, op); } + else if (ob->type == OB_POINTCLOUD) { + ret = point_cloud::join_objects(C, op); + } else if (ob->type == OB_CURVES) { ret = curves::join_objects(C, op); } diff --git a/source/blender/editors/point_cloud/CMakeLists.txt b/source/blender/editors/point_cloud/CMakeLists.txt index 67f5f6583d1..eea0550657f 100644 --- a/source/blender/editors/point_cloud/CMakeLists.txt +++ b/source/blender/editors/point_cloud/CMakeLists.txt @@ -16,6 +16,7 @@ set(INC_SYS set(SRC intern/attribute_set.cc intern/duplicate.cc + intern/join.cc intern/point_cloud_edit.cc intern/point_cloud_ops.cc intern/point_cloud_selection.cc @@ -28,6 +29,7 @@ set(LIB PRIVATE bf::blenlib PRIVATE bf::depsgraph PRIVATE bf::dna + PRIVATE bf::geometry PRIVATE bf::functions PRIVATE bf::intern::clog PRIVATE bf::intern::guardedalloc diff --git a/source/blender/editors/point_cloud/intern/join.cc b/source/blender/editors/point_cloud/intern/join.cc new file mode 100644 index 00000000000..053e33c2077 --- /dev/null +++ b/source/blender/editors/point_cloud/intern/join.cc @@ -0,0 +1,91 @@ +/* SPDX-FileCopyrightText: 2025 Blender Authors + * + * SPDX-License-Identifier: GPL-2.0-or-later */ + +#include "BLI_map.hh" + +#include "DNA_scene_types.h" + +#include "BKE_context.hh" +#include "BKE_instances.hh" +#include "BKE_pointcloud.hh" +#include "BKE_report.hh" + +#include "DEG_depsgraph.hh" +#include "DEG_depsgraph_build.hh" + +#include "WM_api.hh" +#include "WM_types.hh" + +#include "ED_object.hh" +#include "ED_point_cloud.hh" + +#include "GEO_realize_instances.hh" + +namespace blender::ed::point_cloud { + +int join_objects(bContext *C, wmOperator *op) +{ + Main *bmain = CTX_data_main(C); + Scene *scene = CTX_data_scene(C); + Object *active_object = CTX_data_active_object(C); + BLI_assert(active_object); + BLI_assert(active_object->type == OB_POINTCLOUD); + PointCloud &active_pointcloud = *static_cast(active_object->data); + const float4x4 &world_to_active = active_object->world_to_object(); + + Vector objects{active_object}; + bool active_object_selected = false; + CTX_DATA_BEGIN (C, Object *, object, selected_editable_objects) { + if (object == active_object) { + active_object_selected = true; + continue; + } + if (object->type != OB_POINTCLOUD) { + continue; + } + objects.append(object); + } + CTX_DATA_END; + + if (!active_object_selected) { + BKE_report(op->reports, RPT_WARNING, "Active object is not a selected point cloud object"); + return OPERATOR_CANCELLED; + } + + bke::Instances instances; + instances.resize(objects.size()); + MutableSpan transforms = instances.transforms_for_write(); + MutableSpan references = instances.reference_handles_for_write(); + Map reference_by_orig_points; + for (const int i : objects.index_range()) { + transforms[i] = world_to_active * objects[i]->object_to_world(); + const PointCloud *orig_points = static_cast(objects[i]->data); + references[i] = reference_by_orig_points.lookup_or_add_cb(orig_points, [&]() { + auto geometry = bke::GeometrySet::from_pointcloud(BKE_pointcloud_copy_for_eval(orig_points)); + return instances.add_new_reference(std::move(geometry)); + }); + } + + bke::GeometrySet realized_geometry = geometry::realize_instances( + bke::GeometrySet::from_instances(&instances, bke::GeometryOwnershipType::ReadOnly), + geometry::RealizeInstancesOptions()); + + PointCloud *realized_points = + realized_geometry.get_component_for_write().release(); + BKE_pointcloud_nomain_to_pointcloud(realized_points, &active_pointcloud); + + for (Object *object : objects.as_span().drop_front(1)) { + object::base_free_and_unlink(bmain, scene, object); + } + + DEG_relations_tag_update(bmain); + DEG_id_tag_update(&active_object->id, ID_RECALC_TRANSFORM | ID_RECALC_GEOMETRY); + DEG_id_tag_update(&scene->id, ID_RECALC_SELECT); + WM_event_add_notifier(C, NC_SCENE | ND_OB_ACTIVE, scene); + WM_event_add_notifier(C, NC_SCENE | ND_LAYER_CONTENT, scene); + + return OPERATOR_FINISHED; +} + +} // namespace blender::ed::point_cloud From 234810f01d18fe38172477e1a4387b5105704624 Mon Sep 17 00:00:00 2001 From: Jacques Lucke Date: Wed, 19 Feb 2025 15:33:37 +0100 Subject: [PATCH 18/31] Fix: Geometry Nodes: support relative paths in import nodes Previously, the code would assert in `BLI_fopen` when the path is relative. There are two main options to make the path absolute: 1. Always use the path of the current .blend file as base. 2. Is the path of the .blend file "owns" the current node as base. So when the Import node is part of a linked node tree, the path of the linked .blend file is used as base. Both options are useful depending on the specific use-case, but the latter seems more consistent with other places in Blender. For more advanced functionality, we might need nodes that give the current .blend file path and one node to join paths. Pull Request: https://projects.blender.org/blender/blender/pulls/134794 --- source/blender/nodes/NOD_geometry_exec.hh | 6 +++++ .../geometry/nodes/node_geo_import_csv.cc | 7 +++--- .../geometry/nodes/node_geo_import_obj.cc | 7 +++--- .../geometry/nodes/node_geo_import_ply.cc | 7 +++--- .../geometry/nodes/node_geo_import_stl.cc | 7 +++--- .../nodes/intern/node_geometry_exec.cc | 25 +++++++++++++++++++ 6 files changed, 47 insertions(+), 12 deletions(-) diff --git a/source/blender/nodes/NOD_geometry_exec.hh b/source/blender/nodes/NOD_geometry_exec.hh index 1b852a81f42..75bc330603c 100644 --- a/source/blender/nodes/NOD_geometry_exec.hh +++ b/source/blender/nodes/NOD_geometry_exec.hh @@ -306,6 +306,12 @@ class GeoNodeExecParams { return NodeAttributeFilter(set); } + /** + * If the path is relative, attempt to make it absolute. If the current node tree is linked, + * the path is relative to the linked file. Otherwise, the path is relative to the current file. + */ + std::optional ensure_absolute_path(StringRefNull path) const; + private: /* Utilities for detecting common errors at when using this class. */ void check_input_access(StringRef identifier, const CPPType *requested_type = nullptr) const; diff --git a/source/blender/nodes/geometry/nodes/node_geo_import_csv.cc b/source/blender/nodes/geometry/nodes/node_geo_import_csv.cc index 749b4318298..70473045db2 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_import_csv.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_import_csv.cc @@ -26,14 +26,15 @@ static void node_declare(NodeDeclarationBuilder &b) static void node_geo_exec(GeoNodeExecParams params) { #ifdef WITH_IO_CSV - const std::string path = params.extract_input("Path"); - if (path.empty()) { + const std::optional path = params.ensure_absolute_path( + params.extract_input("Path")); + if (!path) { params.set_default_remaining_outputs(); return; } blender::io::csv::CSVImportParams import_params{}; - STRNCPY(import_params.filepath, path.c_str()); + STRNCPY(import_params.filepath, path->c_str()); ReportList reports; BKE_reports_init(&reports, RPT_STORE); diff --git a/source/blender/nodes/geometry/nodes/node_geo_import_obj.cc b/source/blender/nodes/geometry/nodes/node_geo_import_obj.cc index aafca0a50a7..851f7be7047 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_import_obj.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_import_obj.cc @@ -27,14 +27,15 @@ static void node_declare(NodeDeclarationBuilder &b) static void node_geo_exec(GeoNodeExecParams params) { #ifdef WITH_IO_WAVEFRONT_OBJ - const std::string path = params.extract_input("Path"); - if (path.empty()) { + const std::optional path = params.ensure_absolute_path( + params.extract_input("Path")); + if (!path) { params.set_default_remaining_outputs(); return; } OBJImportParams import_params; - STRNCPY(import_params.filepath, path.c_str()); + STRNCPY(import_params.filepath, path->c_str()); ReportList reports; BKE_reports_init(&reports, RPT_STORE); diff --git a/source/blender/nodes/geometry/nodes/node_geo_import_ply.cc b/source/blender/nodes/geometry/nodes/node_geo_import_ply.cc index 35ce0055f08..979a425717e 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_import_ply.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_import_ply.cc @@ -26,14 +26,15 @@ static void node_declare(NodeDeclarationBuilder &b) static void node_geo_exec(GeoNodeExecParams params) { #ifdef WITH_IO_PLY - const std::string path = params.extract_input("Path"); - if (path.empty()) { + const std::optional path = params.ensure_absolute_path( + params.extract_input("Path")); + if (!path) { params.set_default_remaining_outputs(); return; } PLYImportParams import_params; - STRNCPY(import_params.filepath, path.c_str()); + STRNCPY(import_params.filepath, path->c_str()); import_params.import_attributes = true; ReportList reports; diff --git a/source/blender/nodes/geometry/nodes/node_geo_import_stl.cc b/source/blender/nodes/geometry/nodes/node_geo_import_stl.cc index c4f0a9846f4..7e5260057f7 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_import_stl.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_import_stl.cc @@ -26,14 +26,15 @@ static void node_declare(NodeDeclarationBuilder &b) static void node_geo_exec(GeoNodeExecParams params) { #ifdef WITH_IO_STL - const std::string path = params.extract_input("Path"); - if (path.empty()) { + const std::optional path = params.ensure_absolute_path( + params.extract_input("Path")); + if (!path) { params.set_default_remaining_outputs(); return; } STLImportParams import_params; - STRNCPY(import_params.filepath, path.c_str()); + STRNCPY(import_params.filepath, path->c_str()); import_params.forward_axis = IO_AXIS_NEGATIVE_Z; import_params.up_axis = IO_AXIS_Y; diff --git a/source/blender/nodes/intern/node_geometry_exec.cc b/source/blender/nodes/intern/node_geometry_exec.cc index 1646cf866fe..ed69a90941a 100644 --- a/source/blender/nodes/intern/node_geometry_exec.cc +++ b/source/blender/nodes/intern/node_geometry_exec.cc @@ -12,8 +12,13 @@ #include "DEG_depsgraph_query.hh" #include "BKE_curves.hh" +#include "BKE_library.hh" +#include "BKE_main.hh" #include "BKE_node_runtime.hh" +#include "BLI_path_utils.hh" +#include "BLI_string.h" + #include "BLT_translation.hh" #include "NOD_geometry_exec.hh" @@ -258,4 +263,24 @@ AttributeFilter::Result NodeAttributeFilter::filter(const StringRef attribute_na return AttributeFilter::Result::AllowSkip; } +std::optional GeoNodeExecParams::ensure_absolute_path(const StringRefNull path) const +{ + if (path.is_empty()) { + return std::nullopt; + } + if (!BLI_path_is_rel(path.c_str())) { + return path; + } + const Main &bmain = *this->bmain(); + const bNodeTree &tree = node_.owner_tree(); + const char *base_path = ID_BLEND_PATH(&bmain, &tree.id); + if (!base_path || base_path[0] == '\0') { + return std::nullopt; + } + char absolute_path[FILE_MAX]; + STRNCPY(absolute_path, path.c_str()); + BLI_path_abs(absolute_path, base_path); + return absolute_path; +} + } // namespace blender::nodes From d6682af7864370d896156ffd49e39219b16e5f2a Mon Sep 17 00:00:00 2001 From: Miguel Pozo Date: Wed, 19 Feb 2025 17:08:38 +0100 Subject: [PATCH 19/31] Fix: Compiler warnings on Mac Caused by #133557 Pull Request: https://projects.blender.org/blender/blender/pulls/134776 --- source/creator/creator_args.cc | 2 ++ 1 file changed, 2 insertions(+) diff --git a/source/creator/creator_args.cc b/source/creator/creator_args.cc index b64de841eb9..6bdcbb75c0a 100644 --- a/source/creator/creator_args.cc +++ b/source/creator/creator_args.cc @@ -2510,6 +2510,7 @@ static int arg_handle_addons_set(int argc, const char **argv, void *data) return 0; } +# ifdef WITH_OPENGL_BACKEND static const char arg_handle_profile_gpu_set_doc[] = "\n" "\tEnable CPU & GPU performance profiling for GPU debug groups\n" @@ -2519,6 +2520,7 @@ static int arg_handle_profile_gpu_set(int /*argc*/, const char ** /*argv*/, void G.profile_gpu = true; return 0; } +# endif /** * Implementation for #arg_handle_load_last_file, also used by `--open-last`. From 1584cd9aa504b124d7d4a1a9604b1509b55e441e Mon Sep 17 00:00:00 2001 From: Dalai Felinto Date: Wed, 19 Feb 2025 17:11:08 +0100 Subject: [PATCH 20/31] Cleanup: Rename point cloud to pointcloud / POINT_CLOUD to POINTCLOUD Though "Point Cloud" written as two words is technically correct and should be used in the UI, as one word it's typically easier to write and parse when reading. We had a mix of both before this patch, so better to unify this as well. This commit also renames the editor/intern/ files to remove pointcloud_ prefix. point_cloud was only preserved on the user facing strings: * is_type_point_cloud * use_new_point_cloud_type Pull Request: https://projects.blender.org/blender/blender/pulls/134803 --- .../keyconfig/keymap_data/blender_default.py | 14 +-- .../keymap_data/industry_compatible_data.py | 12 +-- .../startup/bl_ui/space_toolsystem_toolbar.py | 2 +- scripts/startup/bl_ui/space_view3d.py | 24 ++--- source/blender/blenkernel/BKE_context.hh | 2 +- source/blender/blenkernel/intern/bvhutils.cc | 10 +- source/blender/blenkernel/intern/context.cc | 4 +- .../blender/blenkernel/intern/geometry_set.cc | 4 +- .../intern/pointcloud_attributes.cc | 4 +- source/blender/draw/CMakeLists.txt | 4 +- .../draw/engines/eevee_next/eevee_instance.cc | 2 +- .../draw/engines/eevee_next/eevee_material.hh | 4 +- .../draw/engines/eevee_next/eevee_shader.cc | 8 +- .../draw/engines/eevee_next/eevee_sync.cc | 6 +- .../draw/engines/eevee_next/eevee_sync.hh | 2 +- .../engines/eevee_next/shaders/CMakeLists.txt | 4 +- ...l => eevee_attributes_pointcloud_lib.glsl} | 0 .../shaders/eevee_attributes_volume_lib.glsl | 2 +- ...t.glsl => eevee_geom_pointcloud_vert.glsl} | 14 +-- .../shaders/eevee_nodetree_lib.glsl | 2 +- .../shaders/eevee_surf_volume_frag.glsl | 2 +- .../shaders/infos/eevee_material_info.hh | 20 ++-- .../overlay/overlay_next_attribute_viewer.hh | 4 +- .../engines/overlay/overlay_next_instance.cc | 2 +- .../engines/overlay/overlay_next_outline.hh | 2 +- .../engines/overlay/overlay_next_prepass.hh | 12 +-- .../engines/overlay/overlay_next_private.hh | 2 +- .../shaders/overlay_edit_pointcloud_vert.glsl | 27 ++++++ .../engines/workbench/workbench_engine.cc | 6 +- source/blender/draw/intern/draw_common.hh | 12 +-- source/blender/draw/intern/draw_common_c.hh | 4 +- source/blender/draw/intern/draw_manager_c.cc | 14 +-- source/blender/draw/intern/draw_manager_c.hh | 2 +- source/blender/draw/intern/draw_pointcloud.cc | 34 +++---- source/blender/editors/CMakeLists.txt | 2 +- .../editors/geometry/node_group_operator.cc | 4 +- .../{ED_point_cloud.hh => ED_pointcloud.hh} | 34 +++---- source/blender/editors/object/CMakeLists.txt | 2 +- source/blender/editors/object/object_add.cc | 34 +++---- source/blender/editors/object/object_edit.cc | 2 +- .../editors/point_cloud/intern/duplicate.cc | 72 -------------- .../CMakeLists.txt | 12 +-- .../intern/attribute_set.cc | 26 ++--- .../editors/pointcloud/intern/duplicate.cc | 72 ++++++++++++++ .../intern/edit.cc} | 16 ++-- .../intern/join.cc | 6 +- .../intern/operators.cc} | 95 +++++++++---------- .../intern/selection.cc} | 50 +++++----- .../intern/separate.cc | 12 +-- .../intern/undo.cc} | 34 +++---- .../blender/editors/space_api/spacetypes.cc | 8 +- .../editors/space_buttons/CMakeLists.txt | 2 +- .../editors/space_buttons/buttons_context.cc | 6 +- .../editors/space_view3d/space_view3d.cc | 4 +- .../editors/space_view3d/view3d_select.cc | 52 +++++----- .../editors/space_view3d/view3d_snap.cc | 4 +- .../blender/editors/transform/CMakeLists.txt | 2 +- .../editors/transform/transform_convert.cc | 4 +- .../editors/transform/transform_convert.hh | 4 +- ...oud.cc => transform_convert_pointcloud.cc} | 33 ++++--- .../editors/transform/transform_gizmo_3d.cc | 6 +- .../blender/editors/undo/undo_system_types.cc | 4 +- source/blender/editors/util/CMakeLists.txt | 2 +- source/blender/editors/util/ed_transverts.cc | 6 +- source/blender/geometry/intern/reorder.cc | 4 +- .../geometry/intern/separate_geometry.cc | 4 +- .../gpu_shader_material_point_info.glsl | 8 +- .../io/alembic/intern/abc_reader_points.cc | 26 ++--- source/blender/io/csv/IO_csv.hh | 2 +- source/blender/io/csv/importer/csv_reader.cc | 2 +- .../usd/intern/usd_reader_pointinstancer.cc | 26 ++--- .../io/usd/intern/usd_reader_points.cc | 39 ++++---- .../io/usd/intern/usd_reader_points.hh | 4 +- source/blender/makesdna/DNA_node_types.h | 2 +- source/blender/makesrna/intern/CMakeLists.txt | 2 +- .../blender/makesrna/intern/rna_attribute.cc | 4 +- source/blender/makesrna/intern/rna_context.cc | 2 +- .../blender/makesrna/intern/rna_nodetree.cc | 18 ++-- .../geometry/nodes/node_geo_import_csv.cc | 4 +- .../nodes/node_geo_separate_components.cc | 8 +- .../geometry/nodes/node_geo_set_position.cc | 6 +- source/blender/windowmanager/WM_types.hh | 2 +- .../windowmanager/intern/wm_keymap_utils.cc | 6 +- 83 files changed, 535 insertions(+), 511 deletions(-) rename source/blender/draw/engines/eevee_next/shaders/{eevee_attributes_point_cloud_lib.glsl => eevee_attributes_pointcloud_lib.glsl} (100%) rename source/blender/draw/engines/eevee_next/shaders/{eevee_geom_point_cloud_vert.glsl => eevee_geom_pointcloud_vert.glsl} (81%) create mode 100644 source/blender/draw/engines/overlay/shaders/overlay_edit_pointcloud_vert.glsl rename source/blender/editors/include/{ED_point_cloud.hh => ED_pointcloud.hh} (82%) delete mode 100644 source/blender/editors/point_cloud/intern/duplicate.cc rename source/blender/editors/{point_cloud => pointcloud}/CMakeLists.txt (69%) rename source/blender/editors/{point_cloud => pointcloud}/intern/attribute_set.cc (90%) create mode 100644 source/blender/editors/pointcloud/intern/duplicate.cc rename source/blender/editors/{point_cloud/intern/point_cloud_edit.cc => pointcloud/intern/edit.cc} (71%) rename source/blender/editors/{point_cloud => pointcloud}/intern/join.cc (96%) rename source/blender/editors/{point_cloud/intern/point_cloud_ops.cc => pointcloud/intern/operators.cc} (54%) rename source/blender/editors/{point_cloud/intern/point_cloud_selection.cc => pointcloud/intern/selection.cc} (87%) rename source/blender/editors/{point_cloud => pointcloud}/intern/separate.cc (93%) rename source/blender/editors/{point_cloud/intern/point_cloud_undo.cc => pointcloud/intern/undo.cc} (80%) rename source/blender/editors/transform/{transform_convert_point_cloud.cc => transform_convert_pointcloud.cc} (79%) diff --git a/scripts/presets/keyconfig/keymap_data/blender_default.py b/scripts/presets/keyconfig/keymap_data/blender_default.py index 4a974d12e6c..3fe6528c156 100644 --- a/scripts/presets/keyconfig/keymap_data/blender_default.py +++ b/scripts/presets/keyconfig/keymap_data/blender_default.py @@ -5799,7 +5799,7 @@ def km_edit_curves(params): # Point cloud edit mode. -def km_edit_point_cloud(params): +def km_edit_pointcloud(params): items = [] keymap = ( "Point Cloud", @@ -5811,11 +5811,11 @@ def km_edit_point_cloud(params): # Transform Actions. *_template_items_transform_actions(params, use_bend=True, use_mirror=True), - ("point_cloud.duplicate_move", {"type": 'D', "value": 'PRESS', "shift": True}, None), - *_template_items_select_actions(params, "point_cloud.select_all"), - ("point_cloud.delete", {"type": 'X', "value": 'PRESS'}, None), - ("point_cloud.delete", {"type": 'DEL', "value": 'PRESS'}, None), - ("point_cloud.separate", {"type": 'P', "value": 'PRESS'}, None), + ("pointcloud.duplicate_move", {"type": 'D', "value": 'PRESS', "shift": True}, None), + *_template_items_select_actions(params, "pointcloud.select_all"), + ("pointcloud.delete", {"type": 'X', "value": 'PRESS'}, None), + ("pointcloud.delete", {"type": 'DEL', "value": 'PRESS'}, None), + ("pointcloud.separate", {"type": 'P', "value": 'PRESS'}, None), ("transform.transform", {"type": 'S', "value": 'PRESS', "alt": True}, {"properties": [("mode", 'CURVE_SHRINKFATTEN')]}), ]) @@ -8378,7 +8378,7 @@ def generate_keymaps(params=None): km_edit_font(params), km_edit_curve_legacy(params), km_edit_curves(params), - km_edit_point_cloud(params), + km_edit_pointcloud(params), # Modal maps. km_eyedropper_modal_map(params), diff --git a/scripts/presets/keyconfig/keymap_data/industry_compatible_data.py b/scripts/presets/keyconfig/keymap_data/industry_compatible_data.py index 1eceb8af0c7..200bb29133d 100644 --- a/scripts/presets/keyconfig/keymap_data/industry_compatible_data.py +++ b/scripts/presets/keyconfig/keymap_data/industry_compatible_data.py @@ -3418,7 +3418,7 @@ def km_sculpt_curves(params): # Point cloud edit mode. -def km_point_cloud(params): +def km_pointcloud(params): items = [] keymap = ( "Point Cloud", @@ -3428,14 +3428,14 @@ def km_point_cloud(params): items.extend([ # Selection Operators - ("point_cloud.select_all", {"type": 'A', "value": 'PRESS', + ("pointcloud.select_all", {"type": 'A', "value": 'PRESS', "ctrl": True}, {"properties": [("action", 'SELECT')]}), - ("point_cloud.select_all", {"type": 'A', "value": 'PRESS', "shift": True, + ("pointcloud.select_all", {"type": 'A', "value": 'PRESS', "shift": True, "ctrl": True}, {"properties": [("action", 'DESELECT')]}), - ("point_cloud.select_all", {"type": 'I', "value": 'PRESS', + ("pointcloud.select_all", {"type": 'I', "value": 'PRESS', "ctrl": True}, {"properties": [("action", 'INVERT')]}), # Delete - ("point_cloud.delete", {"type": 'DEL', "value": 'PRESS'}, None), + ("pointcloud.delete", {"type": 'DEL', "value": 'PRESS'}, None), ]) return keymap @@ -3794,7 +3794,7 @@ def generate_keymaps_impl(params=None): km_font(params), km_curves(params), km_sculpt_curves(params), - km_point_cloud(params), + km_pointcloud(params), km_object_non_modal(params), # Modal maps. diff --git a/scripts/startup/bl_ui/space_toolsystem_toolbar.py b/scripts/startup/bl_ui/space_toolsystem_toolbar.py index 09f216566f8..06e9bac3d59 100644 --- a/scripts/startup/bl_ui/space_toolsystem_toolbar.py +++ b/scripts/startup/bl_ui/space_toolsystem_toolbar.py @@ -3478,7 +3478,7 @@ def tools_all(cls): None, *_tools_annotate, ], - 'EDIT_POINT_CLOUD': [ + 'EDIT_POINTCLOUD': [ *_tools_select, _defs_view3d_generic.cursor, None, diff --git a/scripts/startup/bl_ui/space_view3d.py b/scripts/startup/bl_ui/space_view3d.py index 061ae76adc2..5b136a43353 100644 --- a/scripts/startup/bl_ui/space_view3d.py +++ b/scripts/startup/bl_ui/space_view3d.py @@ -1202,7 +1202,7 @@ def draw(self, context): elif mode_string in {'EDIT_CURVE', 'EDIT_SURFACE'}: layout.menu("VIEW3D_MT_edit_curve_ctrlpoints") layout.menu("VIEW3D_MT_edit_curve_segments") - elif mode_string == 'EDIT_POINT_CLOUD': + elif mode_string == 'EDIT_POINTCLOUD': layout.template_node_operator_asset_root_items() elif mode_string == 'EDIT_CURVES': layout.menu("VIEW3D_MT_edit_curves_control_points") @@ -1285,7 +1285,7 @@ def draw(self, context): 'EDIT_CURVES', 'EDIT_LATTICE', 'EDIT_METABALL', - 'EDIT_POINT_CLOUD', + 'EDIT_POINTCLOUD', }: layout.operator("transform.vertex_warp", text="Warp") layout.operator_context = 'EXEC_REGION_WIN' @@ -1304,7 +1304,7 @@ def draw(self, context): if context.mode == 'EDIT_MESH': layout.operator("transform.shrink_fatten", text="Shrink/Fatten") layout.operator("transform.skin_resize") - elif context.mode in {'EDIT_CURVE', 'EDIT_GREASE_PENCIL', 'EDIT_CURVES', 'EDIT_POINT_CLOUD'}: + elif context.mode in {'EDIT_CURVE', 'EDIT_GREASE_PENCIL', 'EDIT_CURVES', 'EDIT_POINTCLOUD'}: layout.operator("transform.transform", text="Radius").mode = 'CURVE_SHRINKFATTEN' if context.mode != 'EDIT_CURVES' and context.mode != 'EDIT_GREASE_PENCIL': @@ -2315,15 +2315,15 @@ def draw(self, _context): layout.operator("paint.vert_select_ungrouped", text="Ungrouped Vertices") -class VIEW3D_MT_select_edit_point_cloud(Menu): +class VIEW3D_MT_select_edit_pointcloud(Menu): bl_label = "Select" def draw(self, _context): layout = self.layout - layout.operator("point_cloud.select_all", text="All").action = 'SELECT' - layout.operator("point_cloud.select_all", text="None").action = 'DESELECT' - layout.operator("point_cloud.select_all", text="Invert").action = 'INVERT' + layout.operator("pointcloud.select_all", text="All").action = 'SELECT' + layout.operator("pointcloud.select_all", text="None").action = 'DESELECT' + layout.operator("pointcloud.select_all", text="Invert").action = 'INVERT' layout.template_node_operator_asset_menu_items(catalog_path=self.bl_label) @@ -5905,11 +5905,11 @@ def draw(self, context): layout = self.layout layout.menu("VIEW3D_MT_transform") layout.separator() - layout.operator("point_cloud.duplicate_move") + layout.operator("pointcloud.duplicate_move") layout.separator() - layout.operator("point_cloud.attribute_set") - layout.operator("point_cloud.delete") - layout.operator("point_cloud.separate") + layout.operator("pointcloud.attribute_set") + layout.operator("pointcloud.delete") + layout.operator("pointcloud.separate") layout.template_node_operator_asset_menu_items(catalog_path=self.bl_label) @@ -8956,7 +8956,7 @@ class VIEW3D_AST_brush_gpencil_weight(AssetShelfHiddenByDefault, View3DAssetShel VIEW3D_MT_select_edit_grease_pencil, VIEW3D_MT_select_paint_mask, VIEW3D_MT_select_paint_mask_vertex, - VIEW3D_MT_select_edit_point_cloud, + VIEW3D_MT_select_edit_pointcloud, VIEW3D_MT_edit_curves_select_more_less, VIEW3D_MT_select_edit_curves, VIEW3D_MT_select_sculpt_curves, diff --git a/source/blender/blenkernel/BKE_context.hh b/source/blender/blenkernel/BKE_context.hh index 2359f2465f8..900cb48730c 100644 --- a/source/blender/blenkernel/BKE_context.hh +++ b/source/blender/blenkernel/BKE_context.hh @@ -125,7 +125,7 @@ enum eContextObjectMode { CTX_MODE_EDIT_LATTICE, CTX_MODE_EDIT_CURVES, CTX_MODE_EDIT_GREASE_PENCIL, - CTX_MODE_EDIT_POINT_CLOUD, + CTX_MODE_EDIT_POINTCLOUD, CTX_MODE_POSE, CTX_MODE_SCULPT, CTX_MODE_PAINT_WEIGHT, diff --git a/source/blender/blenkernel/intern/bvhutils.cc b/source/blender/blenkernel/intern/bvhutils.cc index 3587dbf0e06..65efec1cb09 100644 --- a/source/blender/blenkernel/intern/bvhutils.cc +++ b/source/blender/blenkernel/intern/bvhutils.cc @@ -822,8 +822,8 @@ static BVHTreeFromPointCloud create_points_tree_data(const BVHTree *tree, return data; } -static BVHTreeFromPointCloud create_point_cloud_tree_data(const BVHTree *tree, - const Span positions) +static BVHTreeFromPointCloud create_pointcloud_tree_data(const BVHTree *tree, + const Span positions) { BVHTreeFromPointCloud data{}; data.tree = tree; @@ -831,7 +831,7 @@ static BVHTreeFromPointCloud create_point_cloud_tree_data(const BVHTree *tree, return data; } -static BVHTreeFromPointCloud create_point_cloud_tree_data( +static BVHTreeFromPointCloud create_pointcloud_tree_data( std::unique_ptr tree, const Span positions) { BVHTreeFromPointCloud data = create_points_tree_data(tree.get(), positions); @@ -846,7 +846,7 @@ BVHTreeFromPointCloud bvhtree_from_pointcloud_get(const PointCloud &pointcloud, return pointcloud.bvh_tree(); } const Span positions = pointcloud.positions(); - return create_point_cloud_tree_data(create_tree_from_verts(positions, points_mask), positions); + return create_pointcloud_tree_data(create_tree_from_verts(positions, points_mask), positions); } } // namespace blender::bke @@ -859,7 +859,7 @@ blender::bke::BVHTreeFromPointCloud PointCloud::bvh_tree() const this->runtime->bvh_cache.ensure([&](std::unique_ptr &data) { data = create_tree_from_verts(positions, positions.index_range()); }); - return create_point_cloud_tree_data(this->runtime->bvh_cache.data().get(), positions); + return create_pointcloud_tree_data(this->runtime->bvh_cache.data().get(), positions); } /** \} */ diff --git a/source/blender/blenkernel/intern/context.cc b/source/blender/blenkernel/intern/context.cc index f68cd8f271b..5ea4003a781 100644 --- a/source/blender/blenkernel/intern/context.cc +++ b/source/blender/blenkernel/intern/context.cc @@ -1242,7 +1242,7 @@ enum eContextObjectMode CTX_data_mode_enum_ex(const Object *obedit, case OB_GREASE_PENCIL: return CTX_MODE_EDIT_GREASE_PENCIL; case OB_POINTCLOUD: - return CTX_MODE_EDIT_POINT_CLOUD; + return CTX_MODE_EDIT_POINTCLOUD; } } else { @@ -1320,7 +1320,7 @@ static const char *data_mode_strings[] = { "lattice_edit", "curves_edit", "grease_pencil_edit", - "point_cloud_edit", + "pointcloud_edit", "posemode", "sculpt_mode", "weightpaint", diff --git a/source/blender/blenkernel/intern/geometry_set.cc b/source/blender/blenkernel/intern/geometry_set.cc index 7f8f28258c5..2124e15d29e 100644 --- a/source/blender/blenkernel/intern/geometry_set.cc +++ b/source/blender/blenkernel/intern/geometry_set.cc @@ -230,8 +230,8 @@ std::ostream &operator<<(std::ostream &stream, const GeometrySet &geometry_set) if (const GreasePencil *grease_pencil = geometry_set.get_grease_pencil()) { parts.append(std::to_string(grease_pencil->layers().size()) + " Grease Pencil layers"); } - if (const PointCloud *point_cloud = geometry_set.get_pointcloud()) { - parts.append(std::to_string(point_cloud->totpoint) + " points"); + if (const PointCloud *pointcloud = geometry_set.get_pointcloud()) { + parts.append(std::to_string(pointcloud->totpoint) + " points"); } if (const Volume *volume = geometry_set.get_volume()) { parts.append(std::to_string(BKE_volume_num_grids(volume)) + " volume grids"); diff --git a/source/blender/blenkernel/intern/pointcloud_attributes.cc b/source/blender/blenkernel/intern/pointcloud_attributes.cc index ab44af45119..e3fa4746e0d 100644 --- a/source/blender/blenkernel/intern/pointcloud_attributes.cc +++ b/source/blender/blenkernel/intern/pointcloud_attributes.cc @@ -26,7 +26,7 @@ static void tag_component_radius_changed(void *owner) * In this function all the attribute providers for a point cloud component are created. Most data * in this function is statically allocated, because it does not change over time. */ -static GeometryAttributeProviders create_attribute_providers_for_point_cloud() +static GeometryAttributeProviders create_attribute_providers_for_pointcloud() { static CustomDataAccessInfo point_access = { [](void *owner) -> CustomData * { @@ -66,7 +66,7 @@ static GeometryAttributeProviders create_attribute_providers_for_point_cloud() static AttributeAccessorFunctions get_pointcloud_accessor_functions() { - static const GeometryAttributeProviders providers = create_attribute_providers_for_point_cloud(); + static const GeometryAttributeProviders providers = create_attribute_providers_for_pointcloud(); AttributeAccessorFunctions fn = attribute_accessor_functions::accessor_functions_for_providers(); fn.domain_size = [](const void *owner, const AttrDomain domain) { diff --git a/source/blender/draw/CMakeLists.txt b/source/blender/draw/CMakeLists.txt index 9304c142c2a..2919410d031 100644 --- a/source/blender/draw/CMakeLists.txt +++ b/source/blender/draw/CMakeLists.txt @@ -318,7 +318,7 @@ set(GLSL_SRC engines/eevee_next/shaders/eevee_attributes_curves_lib.glsl engines/eevee_next/shaders/eevee_attributes_gpencil_lib.glsl engines/eevee_next/shaders/eevee_attributes_mesh_lib.glsl - engines/eevee_next/shaders/eevee_attributes_point_cloud_lib.glsl + engines/eevee_next/shaders/eevee_attributes_pointcloud_lib.glsl engines/eevee_next/shaders/eevee_attributes_volume_lib.glsl engines/eevee_next/shaders/eevee_attributes_world_lib.glsl engines/eevee_next/shaders/eevee_bxdf_lib.glsl @@ -375,7 +375,7 @@ set(GLSL_SRC engines/eevee_next/shaders/eevee_geom_curves_vert.glsl engines/eevee_next/shaders/eevee_geom_gpencil_vert.glsl engines/eevee_next/shaders/eevee_geom_mesh_vert.glsl - engines/eevee_next/shaders/eevee_geom_point_cloud_vert.glsl + engines/eevee_next/shaders/eevee_geom_pointcloud_vert.glsl engines/eevee_next/shaders/eevee_geom_volume_vert.glsl engines/eevee_next/shaders/eevee_geom_world_vert.glsl engines/eevee_next/shaders/eevee_hiz_debug_frag.glsl diff --git a/source/blender/draw/engines/eevee_next/eevee_instance.cc b/source/blender/draw/engines/eevee_next/eevee_instance.cc index 7a98646149b..234f2a011e9 100644 --- a/source/blender/draw/engines/eevee_next/eevee_instance.cc +++ b/source/blender/draw/engines/eevee_next/eevee_instance.cc @@ -291,7 +291,7 @@ void Instance::object_sync(ObjectRef &ob_ref) } break; case OB_POINTCLOUD: - sync.sync_point_cloud(ob, ob_handle, ob_ref); + sync.sync_pointcloud(ob, ob_handle, ob_ref); break; case OB_VOLUME: sync.sync_volume(ob, ob_handle, ob_ref); diff --git a/source/blender/draw/engines/eevee_next/eevee_material.hh b/source/blender/draw/engines/eevee_next/eevee_material.hh index 3c0d82707db..ecdb244df82 100644 --- a/source/blender/draw/engines/eevee_next/eevee_material.hh +++ b/source/blender/draw/engines/eevee_next/eevee_material.hh @@ -50,7 +50,7 @@ enum eMaterialPipeline { enum eMaterialGeometry { /* These maps directly to object types. */ MAT_GEOM_MESH = 0, - MAT_GEOM_POINT_CLOUD, + MAT_GEOM_POINTCLOUD, MAT_GEOM_CURVES, MAT_GEOM_GPENCIL, MAT_GEOM_VOLUME, @@ -195,7 +195,7 @@ static inline eMaterialGeometry to_material_geometry(const Object *ob) case OB_GPENCIL_LEGACY: return MAT_GEOM_GPENCIL; case OB_POINTCLOUD: - return MAT_GEOM_POINT_CLOUD; + return MAT_GEOM_POINTCLOUD; default: return MAT_GEOM_MESH; } diff --git a/source/blender/draw/engines/eevee_next/eevee_shader.cc b/source/blender/draw/engines/eevee_next/eevee_shader.cc index 85b0ba26c44..b51715993b5 100644 --- a/source/blender/draw/engines/eevee_next/eevee_shader.cc +++ b/source/blender/draw/engines/eevee_next/eevee_shader.cc @@ -417,7 +417,7 @@ class SamplerSlots { bool has_shader_to_rgba) { index_ = 0; - if (ELEM(geometry_type, MAT_GEOM_POINT_CLOUD, MAT_GEOM_CURVES)) { + if (ELEM(geometry_type, MAT_GEOM_POINTCLOUD, MAT_GEOM_CURVES)) { index_ = 1; } else if (geometry_type == MAT_GEOM_GPENCIL) { @@ -645,7 +645,7 @@ void ShaderModule::material_create_info_amend(GPUMaterial *gpumat, GPUCodegenOut info.additional_info("draw_volume_infos"); } break; - case MAT_GEOM_POINT_CLOUD: + case MAT_GEOM_POINTCLOUD: case MAT_GEOM_CURVES: /** Hair attributes come from sampler buffer. Transfer attributes to sampler. */ for (auto &input : info.vertex_inputs_) { @@ -815,8 +815,8 @@ void ShaderModule::material_create_info_amend(GPUMaterial *gpumat, GPUCodegenOut case MAT_GEOM_MESH: info.additional_info("eevee_geom_mesh"); break; - case MAT_GEOM_POINT_CLOUD: - info.additional_info("eevee_geom_point_cloud"); + case MAT_GEOM_POINTCLOUD: + info.additional_info("eevee_geom_pointcloud"); break; case MAT_GEOM_VOLUME: info.additional_info("eevee_geom_volume"); diff --git a/source/blender/draw/engines/eevee_next/eevee_sync.cc b/source/blender/draw/engines/eevee_next/eevee_sync.cc index d43a793e94b..64f898e6d99 100644 --- a/source/blender/draw/engines/eevee_next/eevee_sync.cc +++ b/source/blender/draw/engines/eevee_next/eevee_sync.cc @@ -256,7 +256,7 @@ bool SyncModule::sync_sculpt(Object *ob, ObjectHandle &ob_handle, const ObjectRe /** \name Point Cloud * \{ */ -void SyncModule::sync_point_cloud(Object *ob, ObjectHandle &ob_handle, const ObjectRef &ob_ref) +void SyncModule::sync_pointcloud(Object *ob, ObjectHandle &ob_handle, const ObjectRef &ob_ref) { const int material_slot = POINTCLOUD_MATERIAL_NR; @@ -266,14 +266,14 @@ void SyncModule::sync_point_cloud(Object *ob, ObjectHandle &ob_handle, const Obj ob_handle.object_key, ob_ref, ob_handle.recalc, res_handle); Material &material = inst_.materials.material_get( - ob, has_motion, material_slot - 1, MAT_GEOM_POINT_CLOUD); + ob, has_motion, material_slot - 1, MAT_GEOM_POINTCLOUD); auto drawcall_add = [&](MaterialPass &matpass) { if (matpass.sub_pass == nullptr) { return; } PassMain::Sub &object_pass = matpass.sub_pass->sub("Point Cloud Sub Pass"); - gpu::Batch *geometry = point_cloud_sub_pass_setup(object_pass, ob, matpass.gpumat); + gpu::Batch *geometry = pointcloud_sub_pass_setup(object_pass, ob, matpass.gpumat); object_pass.draw(geometry, res_handle); }; diff --git a/source/blender/draw/engines/eevee_next/eevee_sync.hh b/source/blender/draw/engines/eevee_next/eevee_sync.hh index c26ebab7cc2..76cbb83513d 100644 --- a/source/blender/draw/engines/eevee_next/eevee_sync.hh +++ b/source/blender/draw/engines/eevee_next/eevee_sync.hh @@ -164,7 +164,7 @@ class SyncModule { void sync_mesh(Object *ob, ObjectHandle &ob_handle, const ObjectRef &ob_ref); bool sync_sculpt(Object *ob, ObjectHandle &ob_handle, const ObjectRef &ob_ref); - void sync_point_cloud(Object *ob, ObjectHandle &ob_handle, const ObjectRef &ob_ref); + void sync_pointcloud(Object *ob, ObjectHandle &ob_handle, const ObjectRef &ob_ref); void sync_volume(Object *ob, ObjectHandle &ob_handle, const ObjectRef &ob_ref); void sync_curves(Object *ob, ObjectHandle &ob_handle, diff --git a/source/blender/draw/engines/eevee_next/shaders/CMakeLists.txt b/source/blender/draw/engines/eevee_next/shaders/CMakeLists.txt index 7a22b81eebb..e0f6ec373ff 100644 --- a/source/blender/draw/engines/eevee_next/shaders/CMakeLists.txt +++ b/source/blender/draw/engines/eevee_next/shaders/CMakeLists.txt @@ -32,7 +32,7 @@ set(SRC_GLSL_VERT eevee_geom_curves_vert.glsl # eevee_geom_gpencil_vert.glsl # Not yet supported eevee_geom_mesh_vert.glsl - eevee_geom_point_cloud_vert.glsl + eevee_geom_pointcloud_vert.glsl eevee_geom_volume_vert.glsl eevee_geom_world_vert.glsl eevee_lookdev_display_vert.glsl @@ -158,7 +158,7 @@ set(SRC_GLSL_LIB eevee_attributes_curves_lib.glsl eevee_attributes_gpencil_lib.glsl eevee_attributes_mesh_lib.glsl - eevee_attributes_point_cloud_lib.glsl + eevee_attributes_pointcloud_lib.glsl eevee_attributes_volume_lib.glsl eevee_attributes_world_lib.glsl eevee_bxdf_diffuse_lib.glsl diff --git a/source/blender/draw/engines/eevee_next/shaders/eevee_attributes_point_cloud_lib.glsl b/source/blender/draw/engines/eevee_next/shaders/eevee_attributes_pointcloud_lib.glsl similarity index 100% rename from source/blender/draw/engines/eevee_next/shaders/eevee_attributes_point_cloud_lib.glsl rename to source/blender/draw/engines/eevee_next/shaders/eevee_attributes_pointcloud_lib.glsl diff --git a/source/blender/draw/engines/eevee_next/shaders/eevee_attributes_volume_lib.glsl b/source/blender/draw/engines/eevee_next/shaders/eevee_attributes_volume_lib.glsl index 30c5eb43b3a..39777804785 100644 --- a/source/blender/draw/engines/eevee_next/shaders/eevee_attributes_volume_lib.glsl +++ b/source/blender/draw/engines/eevee_next/shaders/eevee_attributes_volume_lib.glsl @@ -23,7 +23,7 @@ int g_attr_id = 0; /* Point clouds and curves are not compatible with volume grids. * They will fallback to their own attributes loading. */ -#if defined(MAT_VOLUME) && !defined(MAT_GEOM_CURVES) && !defined(MAT_GEOM_POINT_CLOUD) +#if defined(MAT_VOLUME) && !defined(MAT_GEOM_CURVES) && !defined(MAT_GEOM_POINTCLOUD) # if defined(VOLUME_INFO_LIB) && !defined(MAT_GEOM_WORLD) # define GRID_ATTRIBUTES # endif diff --git a/source/blender/draw/engines/eevee_next/shaders/eevee_geom_point_cloud_vert.glsl b/source/blender/draw/engines/eevee_next/shaders/eevee_geom_pointcloud_vert.glsl similarity index 81% rename from source/blender/draw/engines/eevee_next/shaders/eevee_geom_point_cloud_vert.glsl rename to source/blender/draw/engines/eevee_next/shaders/eevee_geom_pointcloud_vert.glsl index ba4a9cc067d..a73fea8e4d4 100644 --- a/source/blender/draw/engines/eevee_next/shaders/eevee_geom_point_cloud_vert.glsl +++ b/source/blender/draw/engines/eevee_next/shaders/eevee_geom_pointcloud_vert.glsl @@ -5,11 +5,11 @@ #include "infos/eevee_material_info.hh" VERTEX_SHADER_CREATE_INFO(eevee_clip_plane) -VERTEX_SHADER_CREATE_INFO(eevee_geom_point_cloud) +VERTEX_SHADER_CREATE_INFO(eevee_geom_pointcloud) #include "draw_model_lib.glsl" #include "draw_pointcloud_lib.glsl" -#include "eevee_attributes_point_cloud_lib.glsl" +#include "eevee_attributes_pointcloud_lib.glsl" #include "eevee_nodetree_lib.glsl" #include "eevee_surf_lib.glsl" #include "eevee_velocity_lib.glsl" @@ -24,21 +24,21 @@ void main() init_interface(); - point_cloud_interp_flat.id = pointcloud_get_point_id(); - pointcloud_get_pos_and_radius(point_cloud_interp.position, point_cloud_interp.radius); + pointcloud_interp_flat.id = pointcloud_get_point_id(); + pointcloud_get_pos_and_radius(pointcloud_interp.position, pointcloud_interp.radius); pointcloud_get_pos_and_nor(interp.P, interp.N); #ifdef MAT_SHADOW /* Since point clouds always face the view, camera and shadow orientation don't match. * Apply a bias to avoid self-shadow issues. */ /* TODO(fclem): remove multiplication here. Here only for keeping the size correct for now. */ - float actual_radius = point_cloud_interp.radius * 0.01; + float actual_radius = pointcloud_interp.radius * 0.01; interp.P -= drw_world_incident_vector(interp.P) * actual_radius; #endif #ifdef MAT_VELOCITY - vec3 lP = drw_point_world_to_object(point_cloud_interp.position); + vec3 lP = drw_point_world_to_object(pointcloud_interp.position); vec3 prv, nxt; - velocity_local_pos_get(lP, point_cloud_interp_flat.id, prv, nxt); + velocity_local_pos_get(lP, pointcloud_interp_flat.id, prv, nxt); /* FIXME(fclem): Evaluating before displacement avoid displacement being treated as motion but * ignores motion from animated displacement. Supporting animated displacement motion vectors * would require evaluating the nodetree multiple time with different nodetree UBOs evaluated at diff --git a/source/blender/draw/engines/eevee_next/shaders/eevee_nodetree_lib.glsl b/source/blender/draw/engines/eevee_next/shaders/eevee_nodetree_lib.glsl index b65ec9f6920..f41acc1bf79 100644 --- a/source/blender/draw/engines/eevee_next/shaders/eevee_nodetree_lib.glsl +++ b/source/blender/draw/engines/eevee_next/shaders/eevee_nodetree_lib.glsl @@ -743,7 +743,7 @@ float texture_lod_bias_get() /* Point clouds and curves are not compatible with volume grids. * They will fallback to their own attributes loading. */ -#if defined(MAT_VOLUME) && !defined(MAT_GEOM_CURVES) && !defined(MAT_GEOM_POINT_CLOUD) +#if defined(MAT_VOLUME) && !defined(MAT_GEOM_CURVES) && !defined(MAT_GEOM_POINTCLOUD) # if defined(VOLUME_INFO_LIB) && !defined(MAT_GEOM_WORLD) /* We could just check for GRID_ATTRIBUTES but this avoids for header dependency. */ # define GRID_ATTRIBUTES_LOAD_POST diff --git a/source/blender/draw/engines/eevee_next/shaders/eevee_surf_volume_frag.glsl b/source/blender/draw/engines/eevee_next/shaders/eevee_surf_volume_frag.glsl index 09d4f345c85..2b0fabac6be 100644 --- a/source/blender/draw/engines/eevee_next/shaders/eevee_surf_volume_frag.glsl +++ b/source/blender/draw/engines/eevee_next/shaders/eevee_surf_volume_frag.glsl @@ -55,7 +55,7 @@ VolumeProperties eval_froxel(ivec3 froxel, float jitter) vec3 vP = volume_jitter_to_view(uvw); vec3 wP = drw_point_view_to_world(vP); -#if !defined(MAT_GEOM_CURVES) && !defined(MAT_GEOM_POINT_CLOUD) +#if !defined(MAT_GEOM_CURVES) && !defined(MAT_GEOM_POINTCLOUD) # ifdef GRID_ATTRIBUTES g_lP = drw_point_world_to_object(wP); # else diff --git a/source/blender/draw/engines/eevee_next/shaders/infos/eevee_material_info.hh b/source/blender/draw/engines/eevee_next/shaders/infos/eevee_material_info.hh index 16c8657ac06..a421270c5db 100644 --- a/source/blender/draw/engines/eevee_next/shaders/infos/eevee_material_info.hh +++ b/source/blender/draw/engines/eevee_next/shaders/infos/eevee_material_info.hh @@ -55,21 +55,21 @@ ADDITIONAL_INFO(draw_resource_id_varying) ADDITIONAL_INFO(draw_view) GPU_SHADER_CREATE_END() -GPU_SHADER_NAMED_INTERFACE_INFO(eevee_surf_point_cloud_iface, point_cloud_interp) +GPU_SHADER_NAMED_INTERFACE_INFO(eevee_surf_pointcloud_iface, pointcloud_interp) SMOOTH(FLOAT, radius) SMOOTH(VEC3, position) -GPU_SHADER_NAMED_INTERFACE_END(point_cloud_interp) -GPU_SHADER_NAMED_INTERFACE_INFO(eevee_surf_point_cloud_flat_iface, point_cloud_interp_flat) +GPU_SHADER_NAMED_INTERFACE_END(pointcloud_interp) +GPU_SHADER_NAMED_INTERFACE_INFO(eevee_surf_pointcloud_flat_iface, pointcloud_interp_flat) FLAT(INT, id) -GPU_SHADER_NAMED_INTERFACE_END(point_cloud_interp_flat) +GPU_SHADER_NAMED_INTERFACE_END(pointcloud_interp_flat) -GPU_SHADER_CREATE_INFO(eevee_geom_point_cloud) +GPU_SHADER_CREATE_INFO(eevee_geom_pointcloud) ADDITIONAL_INFO(eevee_shared) -DEFINE("MAT_GEOM_POINT_CLOUD") -VERTEX_SOURCE("eevee_geom_point_cloud_vert.glsl") +DEFINE("MAT_GEOM_POINTCLOUD") +VERTEX_SOURCE("eevee_geom_pointcloud_vert.glsl") VERTEX_OUT(eevee_surf_iface) -VERTEX_OUT(eevee_surf_point_cloud_iface) -VERTEX_OUT(eevee_surf_point_cloud_flat_iface) +VERTEX_OUT(eevee_surf_pointcloud_iface) +VERTEX_OUT(eevee_surf_pointcloud_flat_iface) ADDITIONAL_INFO(draw_pointcloud_new) ADDITIONAL_INFO(draw_modelmat_new) ADDITIONAL_INFO(draw_object_infos_new) @@ -364,7 +364,7 @@ GPU_SHADER_CREATE_END() /* CREATE_INFO_VARIANT(prefix##_gpencil, eevee_geom_gpencil, __VA_ARGS__) */ \ CREATE_INFO_VARIANT(prefix##_curves, eevee_geom_curves, __VA_ARGS__) \ CREATE_INFO_VARIANT(prefix##_mesh, eevee_geom_mesh, __VA_ARGS__) \ - CREATE_INFO_VARIANT(prefix##_point_cloud, eevee_geom_point_cloud, __VA_ARGS__) \ + CREATE_INFO_VARIANT(prefix##_pointcloud, eevee_geom_pointcloud, __VA_ARGS__) \ CREATE_INFO_VARIANT(prefix##_volume, eevee_geom_volume, __VA_ARGS__) # define EEVEE_MAT_PIPE_VARIATIONS(name, ...) \ diff --git a/source/blender/draw/engines/overlay/overlay_next_attribute_viewer.hh b/source/blender/draw/engines/overlay/overlay_next_attribute_viewer.hh index d8d45d63931..9f4358b4fdd 100644 --- a/source/blender/draw/engines/overlay/overlay_next_attribute_viewer.hh +++ b/source/blender/draw/engines/overlay/overlay_next_attribute_viewer.hh @@ -142,7 +142,7 @@ class AttributeViewer : Overlay { } case OB_POINTCLOUD: { auto &sub = *pointcloud_sub_; - gpu::Batch *batch = point_cloud_sub_pass_setup(sub, &object, nullptr); + gpu::Batch *batch = pointcloud_sub_pass_setup(sub, &object, nullptr); sub.push_constant("ucolor", float4(color)); sub.draw(batch, manager.unique_handle(ob_ref)); break; @@ -196,7 +196,7 @@ class AttributeViewer : Overlay { if (attribute_type_supports_viewer_overlay(meta_data->data_type)) { gpu::VertBuf **vertbuf = DRW_pointcloud_evaluated_attribute(pointcloud, ".viewer"); auto &sub = *pointcloud_sub_; - gpu::Batch *batch = point_cloud_sub_pass_setup(sub, &object, nullptr); + gpu::Batch *batch = pointcloud_sub_pass_setup(sub, &object, nullptr); sub.push_constant("opacity", opacity); sub.bind_texture("attribute_tx", vertbuf); sub.draw(batch, manager.unique_handle(ob_ref)); diff --git a/source/blender/draw/engines/overlay/overlay_next_instance.cc b/source/blender/draw/engines/overlay/overlay_next_instance.cc index 9c32f47430e..76689b1daa8 100644 --- a/source/blender/draw/engines/overlay/overlay_next_instance.cc +++ b/source/blender/draw/engines/overlay/overlay_next_instance.cc @@ -940,7 +940,7 @@ bool Instance::object_is_edit_mode(const Object *object) case OB_CURVES: return state.ctx_mode == CTX_MODE_EDIT_CURVES; case OB_POINTCLOUD: - return state.ctx_mode == CTX_MODE_EDIT_POINT_CLOUD; + return state.ctx_mode == CTX_MODE_EDIT_POINTCLOUD; case OB_GREASE_PENCIL: return state.ctx_mode == CTX_MODE_EDIT_GREASE_PENCIL; case OB_VOLUME: diff --git a/source/blender/draw/engines/overlay/overlay_next_outline.hh b/source/blender/draw/engines/overlay/overlay_next_outline.hh index ffce48ae3e5..94fe38e4815 100644 --- a/source/blender/draw/engines/overlay/overlay_next_outline.hh +++ b/source/blender/draw/engines/overlay/overlay_next_outline.hh @@ -169,7 +169,7 @@ class Outline : Overlay { /* Looks bad in wireframe mode. Could be relaxed if we draw a wireframe of some sort in * the future. */ if (!state.is_wireframe_mode) { - geom = point_cloud_sub_pass_setup(*prepass_pointcloud_ps_, ob_ref.object); + geom = pointcloud_sub_pass_setup(*prepass_pointcloud_ps_, ob_ref.object); prepass_pointcloud_ps_->draw(geom, manager.unique_handle(ob_ref)); } break; diff --git a/source/blender/draw/engines/overlay/overlay_next_prepass.hh b/source/blender/draw/engines/overlay/overlay_next_prepass.hh index 0a628963e6b..d5096af189d 100644 --- a/source/blender/draw/engines/overlay/overlay_next_prepass.hh +++ b/source/blender/draw/engines/overlay/overlay_next_prepass.hh @@ -64,7 +64,7 @@ class Prepass : Overlay { PassMain::Sub *mesh_flat_ps_ = nullptr; PassMain::Sub *hair_ps_ = nullptr; PassMain::Sub *curves_ps_ = nullptr; - PassMain::Sub *point_cloud_ps_ = nullptr; + PassMain::Sub *pointcloud_ps_ = nullptr; PassMain::Sub *grease_pencil_ps_ = nullptr; bool use_material_slot_selection_ = false; @@ -79,7 +79,7 @@ class Prepass : Overlay { ps_.init(); mesh_ps_ = nullptr; curves_ps_ = nullptr; - point_cloud_ps_ = nullptr; + pointcloud_ps_ = nullptr; return; } @@ -117,8 +117,8 @@ class Prepass : Overlay { } { auto &sub = ps_.sub("PointCloud"); - sub.shader_set(res.shaders.depth_point_cloud.get()); - point_cloud_ps_ = ⊂ + sub.shader_set(res.shaders.depth_pointcloud.get()); + pointcloud_ps_ = ⊂ } { auto &sub = ps_.sub("GreasePencil"); @@ -248,8 +248,8 @@ class Prepass : Overlay { } break; case OB_POINTCLOUD: - geom_single = point_cloud_sub_pass_setup(*point_cloud_ps_, ob_ref.object); - pass = point_cloud_ps_; + geom_single = pointcloud_sub_pass_setup(*pointcloud_ps_, ob_ref.object); + pass = pointcloud_ps_; break; case OB_CURVES: geom_single = curves_sub_pass_setup(*curves_ps_, state.scene, ob_ref.object); diff --git a/source/blender/draw/engines/overlay/overlay_next_private.hh b/source/blender/draw/engines/overlay/overlay_next_private.hh index a2d1db2cce1..b733388fcb0 100644 --- a/source/blender/draw/engines/overlay/overlay_next_private.hh +++ b/source/blender/draw/engines/overlay/overlay_next_private.hh @@ -554,7 +554,7 @@ class ShaderModule { ShaderPtr depth_grease_pencil = shader_selectable("overlay_depth_gpencil"); ShaderPtr depth_mesh = shader_selectable("overlay_depth_mesh"); ShaderPtr depth_mesh_conservative = shader_selectable("overlay_depth_mesh_conservative"); - ShaderPtr depth_point_cloud = shader_selectable("overlay_depth_pointcloud"); + ShaderPtr depth_pointcloud = shader_selectable("overlay_depth_pointcloud"); ShaderPtr extra_shape = shader_selectable("overlay_extra"); ShaderPtr extra_point = shader_selectable("overlay_extra_point"); ShaderPtr extra_wire = shader_selectable("overlay_extra_wire"); diff --git a/source/blender/draw/engines/overlay/shaders/overlay_edit_pointcloud_vert.glsl b/source/blender/draw/engines/overlay/shaders/overlay_edit_pointcloud_vert.glsl new file mode 100644 index 00000000000..d7f229ed0c0 --- /dev/null +++ b/source/blender/draw/engines/overlay/shaders/overlay_edit_pointcloud_vert.glsl @@ -0,0 +1,27 @@ +/* SPDX-FileCopyrightText: 2025 Blender Authors + * + * SPDX-License-Identifier: GPL-2.0-or-later */ + +#include "common_view_clipping_lib.glsl" +#include "draw_model_lib.glsl" +#include "draw_view_lib.glsl" + +void main() +{ + gl_PointSize = sizeVertex * 2.0; + + if ((data & VERT_SELECTED) != 0u) { + finalColor = colorVertexSelect; + } + else { + gl_PointSize = 0.0; + } + + vec3 world_pos = drw_point_object_to_world(pos); + gl_Position = drw_point_world_to_homogenous(world_pos); + + /* Small offset in Z */ + gl_Position.z -= 3e-4; + + view_clipping_distances(world_pos); +} diff --git a/source/blender/draw/engines/workbench/workbench_engine.cc b/source/blender/draw/engines/workbench/workbench_engine.cc index 0c17ddf17f3..1ded56d9585 100644 --- a/source/blender/draw/engines/workbench/workbench_engine.cc +++ b/source/blender/draw/engines/workbench/workbench_engine.cc @@ -176,7 +176,7 @@ class Instance { emitter_handle = handle; } else if (ob->type == OB_POINTCLOUD) { - this->point_cloud_sync(manager, ob_ref, object_state); + this->pointcloud_sync(manager, ob_ref, object_state); } else if (ob->type == OB_CURVES) { this->curves_sync(manager, ob_ref, object_state); @@ -359,7 +359,7 @@ class Instance { } } - void point_cloud_sync(Manager &manager, ObjectRef &ob_ref, const ObjectState &object_state) + void pointcloud_sync(Manager &manager, ObjectRef &ob_ref, const ObjectState &object_state) { ResourceHandle handle = manager.resource_handle(ob_ref); @@ -370,7 +370,7 @@ class Instance { this->draw_to_mesh_pass(ob_ref, mat.is_transparent(), [&](MeshPass &mesh_pass) { PassMain::Sub &pass = mesh_pass.get_subpass(eGeometryType::POINTCLOUD).sub("Point Cloud SubPass"); - gpu::Batch *batch = point_cloud_sub_pass_setup(pass, ob_ref.object); + gpu::Batch *batch = pointcloud_sub_pass_setup(pass, ob_ref.object); pass.draw(batch, handle, material_index); }); } diff --git a/source/blender/draw/intern/draw_common.hh b/source/blender/draw/intern/draw_common.hh index 28fa7b56aab..0e6b4e4ca17 100644 --- a/source/blender/draw/intern/draw_common.hh +++ b/source/blender/draw/intern/draw_common.hh @@ -53,13 +53,13 @@ gpu::Batch *curves_sub_pass_setup(PassSimple::Sub &ps, /* Point cloud. */ -gpu::Batch *point_cloud_sub_pass_setup(PassMain::Sub &sub_ps, - Object *object, - GPUMaterial *gpu_material = nullptr); +gpu::Batch *pointcloud_sub_pass_setup(PassMain::Sub &sub_ps, + Object *object, + GPUMaterial *gpu_material = nullptr); -gpu::Batch *point_cloud_sub_pass_setup(PassSimple::Sub &sub_ps, - Object *object, - GPUMaterial *gpu_material = nullptr); +gpu::Batch *pointcloud_sub_pass_setup(PassSimple::Sub &sub_ps, + Object *object, + GPUMaterial *gpu_material = nullptr); /** Volume. */ diff --git a/source/blender/draw/intern/draw_common_c.hh b/source/blender/draw/intern/draw_common_c.hh index c34faad62cf..9be9b8eed5a 100644 --- a/source/blender/draw/intern/draw_common_c.hh +++ b/source/blender/draw/intern/draw_common_c.hh @@ -62,8 +62,8 @@ void DRW_curves_update(draw::Manager &manager); /* draw_pointcloud.cc */ /* If drw_data is nullptr, DST global is accessed to get it. */ -void DRW_point_cloud_init(DRWData *drw_data = nullptr); -void DRW_point_cloud_module_free(draw::PointCloudModule *module); +void DRW_pointcloud_init(DRWData *drw_data = nullptr); +void DRW_pointcloud_module_free(draw::PointCloudModule *module); /* draw_volume.cc */ diff --git a/source/blender/draw/intern/draw_manager_c.cc b/source/blender/draw/intern/draw_manager_c.cc index 314f64be973..924ab8a81a7 100644 --- a/source/blender/draw/intern/draw_manager_c.cc +++ b/source/blender/draw/intern/draw_manager_c.cc @@ -353,7 +353,7 @@ void DRW_viewport_data_free(DRWData *drw_data) DRW_view_data_free(drw_data->view_data[i]); } DRW_volume_module_free(drw_data->volume_module); - DRW_point_cloud_module_free(drw_data->point_cloud_module); + DRW_pointcloud_module_free(drw_data->pointcloud_module); DRW_curves_module_free(drw_data->curves_module); delete drw_data->default_view; MEM_freeN(drw_data); @@ -1489,7 +1489,7 @@ void DRW_draw_render_loop_ex(Depsgraph *depsgraph, drw_engines_data_validate(); drw_debug_init(); - DRW_point_cloud_init(DST.vmempool); + DRW_pointcloud_init(DST.vmempool); DRW_curves_init(DST.vmempool); DRW_volume_init(DST.vmempool); DRW_smoke_init(DST.vmempool); @@ -1850,7 +1850,7 @@ void DRW_render_object_iter( { using namespace blender::draw; const DRWContextState *draw_ctx = DRW_context_state_get(); - DRW_point_cloud_init(DST.vmempool); + DRW_pointcloud_init(DST.vmempool); DRW_curves_init(DST.vmempool); DRW_volume_init(DST.vmempool); DRW_smoke_init(DST.vmempool); @@ -1908,7 +1908,7 @@ void DRW_custom_pipeline_begin(DrawEngineType *draw_engine_type, Depsgraph *deps drw_manager_init(&DST, nullptr, nullptr); - DRW_point_cloud_init(DST.vmempool); + DRW_pointcloud_init(DST.vmempool); DRW_curves_init(DST.vmempool); DRW_volume_init(DST.vmempool); DRW_smoke_init(DST.vmempool); @@ -1957,7 +1957,7 @@ void DRW_cache_restart() drw_manager_init(&DST, DST.viewport, blender::int2{int(DST.size[0]), int(DST.size[1])}); - DRW_point_cloud_init(DST.vmempool); + DRW_pointcloud_init(DST.vmempool); DRW_curves_init(DST.vmempool); DRW_volume_init(DST.vmempool); DRW_smoke_init(DST.vmempool); @@ -2236,7 +2236,7 @@ void DRW_draw_select_loop(Depsgraph *depsgraph, /* Init engines */ drw_engines_init(); - DRW_point_cloud_init(DST.vmempool); + DRW_pointcloud_init(DST.vmempool); DRW_curves_init(DST.vmempool); DRW_volume_init(DST.vmempool); DRW_smoke_init(DST.vmempool); @@ -2407,7 +2407,7 @@ void DRW_draw_depth_loop(Depsgraph *depsgraph, /* Init engines */ drw_engines_init(); - DRW_point_cloud_init(DST.vmempool); + DRW_pointcloud_init(DST.vmempool); DRW_curves_init(DST.vmempool); DRW_volume_init(DST.vmempool); DRW_smoke_init(DST.vmempool); diff --git a/source/blender/draw/intern/draw_manager_c.hh b/source/blender/draw/intern/draw_manager_c.hh index 7b25f7c90f1..7ff4f2b707c 100644 --- a/source/blender/draw/intern/draw_manager_c.hh +++ b/source/blender/draw/intern/draw_manager_c.hh @@ -73,7 +73,7 @@ struct DRWData { /** Module storage. */ blender::draw::CurvesModule *curves_module; blender::draw::VolumeModule *volume_module; - blender::draw::PointCloudModule *point_cloud_module; + blender::draw::PointCloudModule *pointcloud_module; /** Default view that feeds every engine. */ blender::draw::View *default_view; }; diff --git a/source/blender/draw/intern/draw_pointcloud.cc b/source/blender/draw/intern/draw_pointcloud.cc index 8eccbd70fa3..326f7f0bcb8 100644 --- a/source/blender/draw/intern/draw_pointcloud.cc +++ b/source/blender/draw/intern/draw_pointcloud.cc @@ -50,30 +50,30 @@ struct PointCloudModule { } }; -void DRW_point_cloud_init(DRWData *drw_data) +void DRW_pointcloud_init(DRWData *drw_data) { if (drw_data == nullptr) { drw_data = DST.vmempool; } - if (drw_data->point_cloud_module == nullptr) { - drw_data->point_cloud_module = MEM_new("PointCloudModule"); + if (drw_data->pointcloud_module == nullptr) { + drw_data->pointcloud_module = MEM_new("PointCloudModule"); } } -void DRW_point_cloud_module_free(PointCloudModule *point_cloud_module) +void DRW_pointcloud_module_free(PointCloudModule *pointcloud_module) { - MEM_delete(point_cloud_module); + MEM_delete(pointcloud_module); } template -gpu::Batch *point_cloud_sub_pass_setup_implementation(PassT &sub_ps, - Object *object, - GPUMaterial *gpu_material) +gpu::Batch *pointcloud_sub_pass_setup_implementation(PassT &sub_ps, + Object *object, + GPUMaterial *gpu_material) { BLI_assert(object->type == OB_POINTCLOUD); PointCloud &pointcloud = *static_cast(object->data); - PointCloudModule &module = *DST.vmempool->point_cloud_module; + PointCloudModule &module = *DST.vmempool->pointcloud_module; /* Fix issue with certain driver not drawing anything if there is no texture bound to * "ac", "au", "u" or "c". */ sub_ps.bind_texture("u", module.dummy_vbo); @@ -101,18 +101,18 @@ gpu::Batch *point_cloud_sub_pass_setup_implementation(PassT &sub_ps, return geom; } -gpu::Batch *point_cloud_sub_pass_setup(PassMain::Sub &sub_ps, - Object *object, - GPUMaterial *gpu_material) +gpu::Batch *pointcloud_sub_pass_setup(PassMain::Sub &sub_ps, + Object *object, + GPUMaterial *gpu_material) { - return point_cloud_sub_pass_setup_implementation(sub_ps, object, gpu_material); + return pointcloud_sub_pass_setup_implementation(sub_ps, object, gpu_material); } -gpu::Batch *point_cloud_sub_pass_setup(PassSimple::Sub &sub_ps, - Object *object, - GPUMaterial *gpu_material) +gpu::Batch *pointcloud_sub_pass_setup(PassSimple::Sub &sub_ps, + Object *object, + GPUMaterial *gpu_material) { - return point_cloud_sub_pass_setup_implementation(sub_ps, object, gpu_material); + return pointcloud_sub_pass_setup_implementation(sub_ps, object, gpu_material); } } // namespace blender::draw diff --git a/source/blender/editors/CMakeLists.txt b/source/blender/editors/CMakeLists.txt index e3cf1fa58c2..83b8d7d5f55 100644 --- a/source/blender/editors/CMakeLists.txt +++ b/source/blender/editors/CMakeLists.txt @@ -25,7 +25,7 @@ if(WITH_BLENDER) add_subdirectory(metaball) add_subdirectory(object) add_subdirectory(physics) - add_subdirectory(point_cloud) + add_subdirectory(pointcloud) add_subdirectory(render) add_subdirectory(scene) add_subdirectory(sculpt_paint) diff --git a/source/blender/editors/geometry/node_group_operator.cc b/source/blender/editors/geometry/node_group_operator.cc index 9211091e16f..6204a2d157e 100644 --- a/source/blender/editors/geometry/node_group_operator.cc +++ b/source/blender/editors/geometry/node_group_operator.cc @@ -1037,9 +1037,9 @@ static GeometryNodeAssetTraitFlag asset_flag_for_context(const ObjectType type, case OB_POINTCLOUD: { switch (mode) { case OB_MODE_OBJECT: - return (GEO_NODE_ASSET_TOOL | GEO_NODE_ASSET_OBJECT | GEO_NODE_ASSET_POINT_CLOUD); + return (GEO_NODE_ASSET_TOOL | GEO_NODE_ASSET_OBJECT | GEO_NODE_ASSET_POINTCLOUD); case OB_MODE_EDIT: - return (GEO_NODE_ASSET_TOOL | GEO_NODE_ASSET_EDIT | GEO_NODE_ASSET_POINT_CLOUD); + return (GEO_NODE_ASSET_TOOL | GEO_NODE_ASSET_EDIT | GEO_NODE_ASSET_POINTCLOUD); default: break; } diff --git a/source/blender/editors/include/ED_point_cloud.hh b/source/blender/editors/include/ED_pointcloud.hh similarity index 82% rename from source/blender/editors/include/ED_point_cloud.hh rename to source/blender/editors/include/ED_pointcloud.hh index 57ba47340dc..9e5c58cbecb 100644 --- a/source/blender/editors/include/ED_point_cloud.hh +++ b/source/blender/editors/include/ED_pointcloud.hh @@ -34,14 +34,14 @@ class GMutableSpan; } // namespace blender enum eSelectOp : int8_t; -namespace blender::ed::point_cloud { +namespace blender::ed::pointcloud { -void operatortypes_point_cloud(); -void operatormacros_point_cloud(); -void keymap_point_cloud(wmKeyConfig *keyconf); +void operatortypes_pointcloud(); +void operatormacros_pointcloud(); +void keymap_pointcloud(wmKeyConfig *keyconf); void undosys_type_register(UndoType *ut); -VectorSet get_unique_editable_point_clouds(const bContext &C); +VectorSet get_unique_editable_pointclouds(const bContext &C); /* -------------------------------------------------------------------- */ /** \name Selection @@ -62,7 +62,7 @@ void fill_selection_true(GMutableSpan selection, const IndexMask &mask); /** * Return true if any element is selected, on either domain with either type. */ -bool has_anything_selected(const PointCloud &point_cloud); +bool has_anything_selected(const PointCloud &pointcloud); /** * (De)select all the points. @@ -70,27 +70,27 @@ bool has_anything_selected(const PointCloud &point_cloud); * \param action: One of #SEL_TOGGLE, #SEL_SELECT, #SEL_DESELECT, or #SEL_INVERT. * See `ED_select_utils.hh`. */ -void select_all(PointCloud &point_cloud, int action); +void select_all(PointCloud &pointcloud, int action); /** * If the selection_id attribute doesn't exist, create it with the requested type (bool or float). */ -bke::GSpanAttributeWriter ensure_selection_attribute(PointCloud &point_cloud, +bke::GSpanAttributeWriter ensure_selection_attribute(PointCloud &pointcloud, eCustomDataType create_type); -bool select_box(PointCloud &point_cloud, +bool select_box(PointCloud &pointcloud, const ARegion ®ion, const float4x4 &projection, const rcti &rect, const eSelectOp sel_op); -bool select_lasso(PointCloud &point_cloud, +bool select_lasso(PointCloud &pointcloud, const ARegion ®ion, const float4x4 &projection, const Span lasso_coords, const eSelectOp sel_op); -bool select_circle(PointCloud &point_cloud, +bool select_circle(PointCloud &pointcloud, const ARegion ®ion, const float4x4 &projection, const int2 coord, @@ -123,7 +123,7 @@ IndexMask retrieve_selected_points(const PointCloud &pointcloud, IndexMaskMemory * Remove selected points based on the ".selection" attribute. * \returns true if any point was removed. */ -bool remove_selection(PointCloud &point_cloud); +bool remove_selection(PointCloud &pointcloud); PointCloud *copy_selection(const PointCloud &src, const IndexMask &mask); /** \} */ @@ -132,7 +132,7 @@ PointCloud *copy_selection(const PointCloud &src, const IndexMask &mask); /** \name Poll Functions * \{ */ -bool editable_point_cloud_in_edit_mode_poll(bContext *C); +bool editable_pointcloud_in_edit_mode_poll(bContext *C); /** \} */ @@ -140,12 +140,12 @@ bool editable_point_cloud_in_edit_mode_poll(bContext *C); /** \name Operators * \{ */ -void POINT_CLOUD_OT_attribute_set(wmOperatorType *ot); -void POINT_CLOUD_OT_duplicate(wmOperatorType *ot); -void POINT_CLOUD_OT_separate(wmOperatorType *ot); +void POINTCLOUD_OT_attribute_set(wmOperatorType *ot); +void POINTCLOUD_OT_duplicate(wmOperatorType *ot); +void POINTCLOUD_OT_separate(wmOperatorType *ot); int join_objects(bContext *C, wmOperator *op); /** \} */ -} // namespace blender::ed::point_cloud +} // namespace blender::ed::pointcloud diff --git a/source/blender/editors/object/CMakeLists.txt b/source/blender/editors/object/CMakeLists.txt index 612cbec9a07..8e9067ff15d 100644 --- a/source/blender/editors/object/CMakeLists.txt +++ b/source/blender/editors/object/CMakeLists.txt @@ -80,7 +80,7 @@ endif() if(WITH_EXPERIMENTAL_FEATURES) add_definitions(-DWITH_SIMULATION_DATABLOCK) - add_definitions(-DWITH_POINT_CLOUD) + add_definitions(-DWITH_pointcloud) endif() blender_add_lib(bf_editor_object "${SRC}" "${INC}" "${INC_SYS}" "${LIB}") diff --git a/source/blender/editors/object/object_add.cc b/source/blender/editors/object/object_add.cc index 375ed9d3939..069a7ea05d1 100644 --- a/source/blender/editors/object/object_add.cc +++ b/source/blender/editors/object/object_add.cc @@ -121,7 +121,7 @@ #include "ED_object.hh" #include "ED_outliner.hh" #include "ED_physics.hh" -#include "ED_point_cloud.hh" +#include "ED_pointcloud.hh" #include "ED_render.hh" #include "ED_screen.hh" #include "ED_select_utils.hh" @@ -2720,12 +2720,12 @@ static const EnumPropertyItem convert_target_items[] = { "MESH", ICON_OUTLINER_OB_MESH, "Mesh", -#ifdef WITH_POINT_CLOUD +#ifdef WITH_POINTCLOUD "Mesh from Curve, Surface, Metaball, Text, or Point Cloud objects"}, #else "Mesh from Curve, Surface, Metaball, or Text objects"}, #endif -#ifdef WITH_POINT_CLOUD +#ifdef WITH_POINTCLOUD {OB_POINTCLOUD, "POINTCLOUD", ICON_OUTLINER_OB_POINTCLOUD, @@ -3031,9 +3031,9 @@ static Object *convert_mesh_to_curves(Base &base, ObjectConversionInfo &info, Ba return convert_grease_pencil_component_to_curves(base, info, r_new_base); } -static Object *convert_mesh_to_point_cloud(Base &base, - ObjectConversionInfo &info, - Base **r_new_base) +static Object *convert_mesh_to_pointcloud(Base &base, + ObjectConversionInfo &info, + Base **r_new_base) { Object *ob = base.object; ob->flag |= OB_DONE; @@ -3324,7 +3324,7 @@ static Object *convert_mesh(Base &base, case OB_CURVES: return convert_mesh_to_curves(base, info, r_new_base); case OB_POINTCLOUD: - return convert_mesh_to_point_cloud(base, info, r_new_base); + return convert_mesh_to_pointcloud(base, info, r_new_base); case OB_MESH: return convert_mesh_to_mesh(base, info, r_new_base); case OB_GREASE_PENCIL: @@ -3879,9 +3879,9 @@ static Object *convert_mball(Base &base, } } -static Object *convert_point_cloud_to_mesh(Base &base, - ObjectConversionInfo &info, - Base **r_new_base) +static Object *convert_pointcloud_to_mesh(Base &base, + ObjectConversionInfo &info, + Base **r_new_base) { Object *ob = base.object; ob->flag |= OB_DONE; @@ -3897,14 +3897,14 @@ static Object *convert_point_cloud_to_mesh(Base &base, return newob; } -static Object *convert_point_cloud(Base &base, - const ObjectType target, - ObjectConversionInfo &info, - Base **r_new_base) +static Object *convert_pointcloud(Base &base, + const ObjectType target, + ObjectConversionInfo &info, + Base **r_new_base) { switch (target) { case OB_MESH: - return convert_point_cloud_to_mesh(base, info, r_new_base); + return convert_pointcloud_to_mesh(base, info, r_new_base); default: return nullptr; } @@ -4048,7 +4048,7 @@ static int object_convert_exec(bContext *C, wmOperator *op) newob = convert_mball(*base, target_type, info, mball_converted, &new_base, &act_base); break; case OB_POINTCLOUD: - newob = convert_point_cloud(*base, target_type, info, &new_base); + newob = convert_pointcloud(*base, target_type, info, &new_base); break; default: continue; @@ -4761,7 +4761,7 @@ static int object_join_exec(bContext *C, wmOperator *op) ret = ED_armature_join_objects_exec(C, op); } else if (ob->type == OB_POINTCLOUD) { - ret = point_cloud::join_objects(C, op); + ret = pointcloud::join_objects(C, op); } else if (ob->type == OB_CURVES) { ret = curves::join_objects(C, op); diff --git a/source/blender/editors/object/object_edit.cc b/source/blender/editors/object/object_edit.cc index f162e079775..59a9820c0bd 100644 --- a/source/blender/editors/object/object_edit.cc +++ b/source/blender/editors/object/object_edit.cc @@ -897,7 +897,7 @@ bool editmode_enter_ex(Main *bmain, Scene *scene, Object *ob, int flag) } else if (ob->type == OB_POINTCLOUD) { ok = true; - WM_main_add_notifier(NC_SCENE | ND_MODE | NS_EDITMODE_POINT_CLOUD, scene); + WM_main_add_notifier(NC_SCENE | ND_MODE | NS_EDITMODE_POINTCLOUD, scene); } if (ok) { diff --git a/source/blender/editors/point_cloud/intern/duplicate.cc b/source/blender/editors/point_cloud/intern/duplicate.cc deleted file mode 100644 index 66325c52065..00000000000 --- a/source/blender/editors/point_cloud/intern/duplicate.cc +++ /dev/null @@ -1,72 +0,0 @@ -/* SPDX-FileCopyrightText: 2025 Blender Authors - * - * SPDX-License-Identifier: GPL-2.0-or-later */ - -#include "BLI_array_utils.hh" - -#include "BKE_attribute.hh" -#include "BKE_pointcloud.hh" - -#include "ED_point_cloud.hh" - -#include "DNA_pointcloud_types.h" - -#include "DEG_depsgraph.hh" - -#include "WM_api.hh" - -namespace blender::ed::point_cloud { - -static void duplicate_points(PointCloud &point_cloud, const IndexMask &mask) -{ - PointCloud *new_point_cloud = BKE_pointcloud_new_nomain(point_cloud.totpoint + mask.size()); - bke::MutableAttributeAccessor dst_attributes = new_point_cloud->attributes_for_write(); - point_cloud.attributes().foreach_attribute([&](const bke::AttributeIter &iter) { - const GVArray src = *iter.get(); - bke::GSpanAttributeWriter dst = dst_attributes.lookup_or_add_for_write_only_span( - iter.name, iter.domain, iter.data_type); - array_utils::copy(src, dst.span.take_front(point_cloud.totpoint)); - array_utils::gather(src, mask, dst.span.take_back(mask.size())); - dst.finish(); - }); - BKE_pointcloud_nomain_to_pointcloud(new_point_cloud, &point_cloud); -} - -static int duplicate_exec(bContext *C, wmOperator * /*op*/) -{ - for (PointCloud *point_cloud : get_unique_editable_point_clouds(*C)) { - IndexMaskMemory memory; - const IndexMask selection = retrieve_selected_points(*point_cloud, memory); - if (selection.is_empty()) { - continue; - } - - point_cloud->attributes_for_write().remove(".selection"); - - duplicate_points(*point_cloud, selection); - - bke::SpanAttributeWriter selection_attr = - point_cloud->attributes_for_write().lookup_or_add_for_write_span( - ".selection", bke::AttrDomain::Point); - selection_attr.span.take_back(selection.size()).fill(true); - selection_attr.finish(); - - DEG_id_tag_update(&point_cloud->id, ID_RECALC_GEOMETRY); - WM_event_add_notifier(C, NC_GEOM | ND_DATA, point_cloud); - } - return OPERATOR_FINISHED; -} - -void POINT_CLOUD_OT_duplicate(wmOperatorType *ot) -{ - ot->name = "Duplicate"; - ot->idname = "POINT_CLOUD_OT_duplicate"; - ot->description = "Copy selected points "; - - ot->exec = duplicate_exec; - ot->poll = editable_point_cloud_in_edit_mode_poll; - - ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO; -} - -} // namespace blender::ed::point_cloud diff --git a/source/blender/editors/point_cloud/CMakeLists.txt b/source/blender/editors/pointcloud/CMakeLists.txt similarity index 69% rename from source/blender/editors/point_cloud/CMakeLists.txt rename to source/blender/editors/pointcloud/CMakeLists.txt index eea0550657f..873ccaeef7b 100644 --- a/source/blender/editors/point_cloud/CMakeLists.txt +++ b/source/blender/editors/pointcloud/CMakeLists.txt @@ -16,12 +16,12 @@ set(INC_SYS set(SRC intern/attribute_set.cc intern/duplicate.cc + intern/edit.cc intern/join.cc - intern/point_cloud_edit.cc - intern/point_cloud_ops.cc - intern/point_cloud_selection.cc - intern/point_cloud_undo.cc + intern/operators.cc + intern/selection.cc intern/separate.cc + intern/undo.cc ) set(LIB @@ -36,5 +36,5 @@ set(LIB PRIVATE bf::windowmanager ) -blender_add_lib(bf_editor_point_cloud "${SRC}" "${INC}" "${INC_SYS}" "${LIB}") -add_dependencies(bf_editor_point_cloud bf_rna) +blender_add_lib(bf_editor_pointcloud "${SRC}" "${INC}" "${INC_SYS}" "${LIB}") +add_dependencies(bf_editor_pointcloud bf_rna) diff --git a/source/blender/editors/point_cloud/intern/attribute_set.cc b/source/blender/editors/pointcloud/intern/attribute_set.cc similarity index 90% rename from source/blender/editors/point_cloud/intern/attribute_set.cc rename to source/blender/editors/pointcloud/intern/attribute_set.cc index ee4d1c4366d..c188f26f5b8 100644 --- a/source/blender/editors/point_cloud/intern/attribute_set.cc +++ b/source/blender/editors/pointcloud/intern/attribute_set.cc @@ -19,7 +19,7 @@ #include "ED_geometry.hh" #include "ED_object.hh" -#include "ED_point_cloud.hh" +#include "ED_pointcloud.hh" #include "ED_screen.hh" #include "ED_transform.hh" #include "ED_view3d.hh" @@ -39,11 +39,11 @@ /** \name Delete Operator * \{ */ -namespace blender::ed::point_cloud { +namespace blender::ed::pointcloud { static bool active_attribute_poll(bContext *C) { - if (!editable_point_cloud_in_edit_mode_poll(C)) { + if (!editable_pointcloud_in_edit_mode_poll(C)) { return false; } const Object *object = CTX_data_active_object(C); @@ -79,9 +79,9 @@ static void validate_value(const bke::AttributeAccessor attributes, static int set_attribute_exec(bContext *C, wmOperator *op) { Object *active_object = CTX_data_active_object(C); - PointCloud &active_point_cloud = *static_cast(active_object->data); + PointCloud &active_pointcloud = *static_cast(active_object->data); - AttributeOwner active_owner = AttributeOwner::from_id(&active_point_cloud.id); + AttributeOwner active_owner = AttributeOwner::from_id(&active_pointcloud.id); CustomDataLayer *active_attribute = BKE_attributes_active_get(active_owner); const StringRef name = active_attribute->name; const eCustomDataType active_type = eCustomDataType(active_attribute->type); @@ -94,7 +94,7 @@ static int set_attribute_exec(bContext *C, wmOperator *op) const bke::DataTypeConversions &conversions = bke::get_implicit_type_conversions(); - for (PointCloud *pointcloud : get_unique_editable_point_clouds(*C)) { + for (PointCloud *pointcloud : get_unique_editable_pointclouds(*C)) { bke::MutableAttributeAccessor attributes = pointcloud->attributes_for_write(); bke::GSpanAttributeWriter attribute = attributes.lookup_for_write_span(name); if (!attribute) { @@ -133,15 +133,15 @@ static int set_attribute_exec(bContext *C, wmOperator *op) static int set_attribute_invoke(bContext *C, wmOperator *op, const wmEvent *event) { Object *active_object = CTX_data_active_object(C); - PointCloud &active_point_cloud = *static_cast(active_object->data); + PointCloud &active_pointcloud = *static_cast(active_object->data); - AttributeOwner owner = AttributeOwner::from_id(&active_point_cloud.id); + AttributeOwner owner = AttributeOwner::from_id(&active_pointcloud.id); CustomDataLayer *active_attribute = BKE_attributes_active_get(owner); - const bke::AttributeAccessor attributes = active_point_cloud.attributes(); + const bke::AttributeAccessor attributes = active_pointcloud.attributes(); const bke::GAttributeReader attribute = attributes.lookup(active_attribute->name); IndexMaskMemory memory; - const IndexMask selection = retrieve_selected_points(active_point_cloud, memory); + const IndexMask selection = retrieve_selected_points(active_pointcloud, memory); const CPPType &type = attribute.varray.type(); @@ -184,11 +184,11 @@ static void set_attribute_ui(bContext *C, wmOperator *op) uiItemR(layout, op->ptr, prop_name, UI_ITEM_NONE, name, ICON_NONE); } -void POINT_CLOUD_OT_attribute_set(wmOperatorType *ot) +void POINTCLOUD_OT_attribute_set(wmOperatorType *ot) { ot->name = "Set Attribute"; ot->description = "Set values of the active attribute for selected elements"; - ot->idname = "POINT_CLOUD_OT_attribute_set"; + ot->idname = "POINTCLOUD_OT_attribute_set"; ot->exec = set_attribute_exec; ot->invoke = set_attribute_invoke; @@ -200,6 +200,6 @@ void POINT_CLOUD_OT_attribute_set(wmOperatorType *ot) geometry::register_rna_properties_for_attribute_types(*ot->srna); } -} // namespace blender::ed::point_cloud +} // namespace blender::ed::pointcloud /** \} */ diff --git a/source/blender/editors/pointcloud/intern/duplicate.cc b/source/blender/editors/pointcloud/intern/duplicate.cc new file mode 100644 index 00000000000..ec2f164793e --- /dev/null +++ b/source/blender/editors/pointcloud/intern/duplicate.cc @@ -0,0 +1,72 @@ +/* SPDX-FileCopyrightText: 2025 Blender Authors + * + * SPDX-License-Identifier: GPL-2.0-or-later */ + +#include "BLI_array_utils.hh" + +#include "BKE_attribute.hh" +#include "BKE_pointcloud.hh" + +#include "ED_pointcloud.hh" + +#include "DNA_pointcloud_types.h" + +#include "DEG_depsgraph.hh" + +#include "WM_api.hh" + +namespace blender::ed::pointcloud { + +static void duplicate_points(PointCloud &pointcloud, const IndexMask &mask) +{ + PointCloud *new_pointcloud = BKE_pointcloud_new_nomain(pointcloud.totpoint + mask.size()); + bke::MutableAttributeAccessor dst_attributes = new_pointcloud->attributes_for_write(); + pointcloud.attributes().foreach_attribute([&](const bke::AttributeIter &iter) { + const GVArray src = *iter.get(); + bke::GSpanAttributeWriter dst = dst_attributes.lookup_or_add_for_write_only_span( + iter.name, iter.domain, iter.data_type); + array_utils::copy(src, dst.span.take_front(pointcloud.totpoint)); + array_utils::gather(src, mask, dst.span.take_back(mask.size())); + dst.finish(); + }); + BKE_pointcloud_nomain_to_pointcloud(new_pointcloud, &pointcloud); +} + +static int duplicate_exec(bContext *C, wmOperator * /*op*/) +{ + for (PointCloud *pointcloud : get_unique_editable_pointclouds(*C)) { + IndexMaskMemory memory; + const IndexMask selection = retrieve_selected_points(*pointcloud, memory); + if (selection.is_empty()) { + continue; + } + + pointcloud->attributes_for_write().remove(".selection"); + + duplicate_points(*pointcloud, selection); + + bke::SpanAttributeWriter selection_attr = + pointcloud->attributes_for_write().lookup_or_add_for_write_span( + ".selection", bke::AttrDomain::Point); + selection_attr.span.take_back(selection.size()).fill(true); + selection_attr.finish(); + + DEG_id_tag_update(&pointcloud->id, ID_RECALC_GEOMETRY); + WM_event_add_notifier(C, NC_GEOM | ND_DATA, pointcloud); + } + return OPERATOR_FINISHED; +} + +void POINTCLOUD_OT_duplicate(wmOperatorType *ot) +{ + ot->name = "Duplicate"; + ot->idname = "POINTCLOUD_OT_duplicate"; + ot->description = "Copy selected points "; + + ot->exec = duplicate_exec; + ot->poll = editable_pointcloud_in_edit_mode_poll; + + ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO; +} + +} // namespace blender::ed::pointcloud diff --git a/source/blender/editors/point_cloud/intern/point_cloud_edit.cc b/source/blender/editors/pointcloud/intern/edit.cc similarity index 71% rename from source/blender/editors/point_cloud/intern/point_cloud_edit.cc rename to source/blender/editors/pointcloud/intern/edit.cc index 13d821c29f1..9215d1a7adf 100644 --- a/source/blender/editors/point_cloud/intern/point_cloud_edit.cc +++ b/source/blender/editors/pointcloud/intern/edit.cc @@ -9,9 +9,9 @@ #include "BKE_attribute.hh" #include "BKE_pointcloud.hh" -#include "ED_point_cloud.hh" +#include "ED_pointcloud.hh" -namespace blender::ed::point_cloud { +namespace blender::ed::pointcloud { PointCloud *copy_selection(const PointCloud &src, const IndexMask &mask) { @@ -29,20 +29,20 @@ PointCloud *copy_selection(const PointCloud &src, const IndexMask &mask) return dst; } -bool remove_selection(PointCloud &point_cloud) +bool remove_selection(PointCloud &pointcloud) { - const bke::AttributeAccessor attributes = point_cloud.attributes(); + const bke::AttributeAccessor attributes = pointcloud.attributes(); const VArray selection = *attributes.lookup_or_default( ".selection", bke::AttrDomain::Point, true); IndexMaskMemory memory; const IndexMask mask = IndexMask::from_bools_inverse(selection, memory); - if (mask.size() == point_cloud.totpoint) { + if (mask.size() == pointcloud.totpoint) { return false; } - PointCloud *point_cloud_new = copy_selection(point_cloud, mask); - BKE_pointcloud_nomain_to_pointcloud(point_cloud_new, &point_cloud); + PointCloud *pointcloud_new = copy_selection(pointcloud, mask); + BKE_pointcloud_nomain_to_pointcloud(pointcloud_new, &pointcloud); return true; } -} // namespace blender::ed::point_cloud +} // namespace blender::ed::pointcloud diff --git a/source/blender/editors/point_cloud/intern/join.cc b/source/blender/editors/pointcloud/intern/join.cc similarity index 96% rename from source/blender/editors/point_cloud/intern/join.cc rename to source/blender/editors/pointcloud/intern/join.cc index 053e33c2077..0d139e02684 100644 --- a/source/blender/editors/point_cloud/intern/join.cc +++ b/source/blender/editors/pointcloud/intern/join.cc @@ -18,11 +18,11 @@ #include "WM_types.hh" #include "ED_object.hh" -#include "ED_point_cloud.hh" +#include "ED_pointcloud.hh" #include "GEO_realize_instances.hh" -namespace blender::ed::point_cloud { +namespace blender::ed::pointcloud { int join_objects(bContext *C, wmOperator *op) { @@ -88,4 +88,4 @@ int join_objects(bContext *C, wmOperator *op) return OPERATOR_FINISHED; } -} // namespace blender::ed::point_cloud +} // namespace blender::ed::pointcloud diff --git a/source/blender/editors/point_cloud/intern/point_cloud_ops.cc b/source/blender/editors/pointcloud/intern/operators.cc similarity index 54% rename from source/blender/editors/point_cloud/intern/point_cloud_ops.cc rename to source/blender/editors/pointcloud/intern/operators.cc index d16e135c5f9..968b6140d44 100644 --- a/source/blender/editors/point_cloud/intern/point_cloud_ops.cc +++ b/source/blender/editors/pointcloud/intern/operators.cc @@ -11,7 +11,7 @@ #include "BKE_context.hh" #include "BKE_lib_id.hh" -#include "ED_point_cloud.hh" +#include "ED_pointcloud.hh" #include "ED_screen.hh" #include "ED_select_utils.hh" @@ -27,9 +27,9 @@ #include "WM_api.hh" -namespace blender::ed::point_cloud { +namespace blender::ed::pointcloud { -static bool object_has_editable_point_cloud(const Main &bmain, const Object &object) +static bool object_has_editable_pointcloud(const Main &bmain, const Object &object) { if (object.type != OB_POINTCLOUD) { return false; @@ -43,9 +43,9 @@ static bool object_has_editable_point_cloud(const Main &bmain, const Object &obj return true; } -static bool point_cloud_poll_impl(bContext *C, - const bool check_editable, - const bool check_edit_mode) +static bool pointcloud_poll_impl(bContext *C, + const bool check_editable, + const bool check_edit_mode) { Object *object = CTX_data_active_object(C); if (object == nullptr || object->type != OB_POINTCLOUD) { @@ -64,29 +64,29 @@ static bool point_cloud_poll_impl(bContext *C, return true; } -static bool editable_point_cloud_poll(bContext *C) +static bool editable_pointcloud_poll(bContext *C) { - return point_cloud_poll_impl(C, false, false); + return pointcloud_poll_impl(C, false, false); } -bool editable_point_cloud_in_edit_mode_poll(bContext *C) +bool editable_pointcloud_in_edit_mode_poll(bContext *C) { - return point_cloud_poll_impl(C, true, true); + return pointcloud_poll_impl(C, true, true); } -VectorSet get_unique_editable_point_clouds(const bContext &C) +VectorSet get_unique_editable_pointclouds(const bContext &C) { VectorSet unique_points; const Main &bmain = *CTX_data_main(&C); Object *object = CTX_data_active_object(&C); - if (object && object_has_editable_point_cloud(bmain, *object)) { + if (object && object_has_editable_pointcloud(bmain, *object)) { unique_points.add_new(static_cast(object->data)); } CTX_DATA_BEGIN (&C, Object *, object, selected_objects) { - if (object_has_editable_point_cloud(bmain, *object)) { + if (object_has_editable_pointcloud(bmain, *object)) { unique_points.add(static_cast(object->data)); } } @@ -95,108 +95,107 @@ VectorSet get_unique_editable_point_clouds(const bContext &C) return unique_points; } -static bool has_anything_selected(const Span point_cloud_ids) +static bool has_anything_selected(const Span pointclouds) { - return std::any_of( - point_cloud_ids.begin(), point_cloud_ids.end(), [](const PointCloud *point_cloud_id) { - return has_anything_selected(*point_cloud_id); - }); + return std::any_of(pointclouds.begin(), pointclouds.end(), [](const PointCloud *pointcloud) { + return has_anything_selected(*pointcloud); + }); } static int select_all_exec(bContext *C, wmOperator *op) { int action = RNA_enum_get(op->ptr, "action"); - VectorSet unique_point_cloud = get_unique_editable_point_clouds(*C); + VectorSet unique_pointcloud = get_unique_editable_pointclouds(*C); if (action == SEL_TOGGLE) { - action = has_anything_selected(unique_point_cloud) ? SEL_DESELECT : SEL_SELECT; + action = has_anything_selected(unique_pointcloud) ? SEL_DESELECT : SEL_SELECT; } - for (PointCloud *point_cloud_id : unique_point_cloud) { + for (PointCloud *pointcloud : unique_pointcloud) { /* (De)select all the curves. */ - select_all(*point_cloud_id, action); + select_all(*pointcloud, action); /* Use #ID_RECALC_GEOMETRY instead of #ID_RECALC_SELECT because it is handled as a generic * attribute for now. */ - DEG_id_tag_update(&point_cloud_id->id, ID_RECALC_GEOMETRY); - WM_event_add_notifier(C, NC_GEOM | ND_DATA, point_cloud_id); + DEG_id_tag_update(&pointcloud->id, ID_RECALC_GEOMETRY); + WM_event_add_notifier(C, NC_GEOM | ND_DATA, pointcloud); } return OPERATOR_FINISHED; } -static void POINT_CLOUD_OT_select_all(wmOperatorType *ot) +static void POINTCLOUD_OT_select_all(wmOperatorType *ot) { ot->name = "(De)select All"; - ot->idname = "POINT_CLOUD_OT_select_all"; + ot->idname = "POINTCLOUD_OT_select_all"; ot->description = "(De)select all point cloud"; ot->exec = select_all_exec; - ot->poll = editable_point_cloud_poll; + ot->poll = editable_pointcloud_poll; ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO; WM_operator_properties_select_all(ot); } -namespace point_cloud_delete { +namespace pointcloud_delete { static int delete_exec(bContext *C, wmOperator * /*op*/) { - for (PointCloud *point_cloud : get_unique_editable_point_clouds(*C)) { - if (remove_selection(*point_cloud)) { - DEG_id_tag_update(&point_cloud->id, ID_RECALC_GEOMETRY); - WM_event_add_notifier(C, NC_GEOM | ND_DATA, &point_cloud); + for (PointCloud *pointcloud : get_unique_editable_pointclouds(*C)) { + if (remove_selection(*pointcloud)) { + DEG_id_tag_update(&pointcloud->id, ID_RECALC_GEOMETRY); + WM_event_add_notifier(C, NC_GEOM | ND_DATA, &pointcloud); } } return OPERATOR_FINISHED; } -} // namespace point_cloud_delete +} // namespace pointcloud_delete -static void POINT_CLOUD_OT_delete(wmOperatorType *ot) +static void POINTCLOUD_OT_delete(wmOperatorType *ot) { ot->name = "Delete"; ot->idname = __func__; ot->description = "Remove selected points"; - ot->exec = point_cloud_delete::delete_exec; - ot->poll = editable_point_cloud_in_edit_mode_poll; + ot->exec = pointcloud_delete::delete_exec; + ot->poll = editable_pointcloud_in_edit_mode_poll; ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO; } -void operatortypes_point_cloud() +void operatortypes_pointcloud() { - WM_operatortype_append(POINT_CLOUD_OT_attribute_set); - WM_operatortype_append(POINT_CLOUD_OT_delete); - WM_operatortype_append(POINT_CLOUD_OT_duplicate); - WM_operatortype_append(POINT_CLOUD_OT_select_all); - WM_operatortype_append(POINT_CLOUD_OT_separate); + WM_operatortype_append(POINTCLOUD_OT_attribute_set); + WM_operatortype_append(POINTCLOUD_OT_delete); + WM_operatortype_append(POINTCLOUD_OT_duplicate); + WM_operatortype_append(POINTCLOUD_OT_select_all); + WM_operatortype_append(POINTCLOUD_OT_separate); } -void operatormacros_point_cloud() +void operatormacros_pointcloud() { wmOperatorType *ot; wmOperatorTypeMacro *otmacro; - ot = WM_operatortype_append_macro("POINT_CLOUD_OT_duplicate_move", + ot = WM_operatortype_append_macro("POINTCLOUD_OT_duplicate_move", "Duplicate", "Make copies of selected elements and move them", OPTYPE_UNDO | OPTYPE_REGISTER); - WM_operatortype_macro_define(ot, "POINT_CLOUD_OT_duplicate"); + WM_operatortype_macro_define(ot, "POINTCLOUD_OT_duplicate"); otmacro = WM_operatortype_macro_define(ot, "TRANSFORM_OT_translate"); RNA_boolean_set(otmacro->ptr, "use_proportional_edit", false); RNA_boolean_set(otmacro->ptr, "mirror", false); } -void keymap_point_cloud(wmKeyConfig *keyconf) +void keymap_pointcloud(wmKeyConfig *keyconf) { /* Only set in editmode point cloud, by space_view3d listener. */ wmKeyMap *keymap = WM_keymap_ensure(keyconf, "Point Cloud", SPACE_EMPTY, RGN_TYPE_WINDOW); - keymap->poll = editable_point_cloud_in_edit_mode_poll; + keymap->poll = editable_pointcloud_in_edit_mode_poll; } -} // namespace blender::ed::point_cloud +} // namespace blender::ed::pointcloud diff --git a/source/blender/editors/point_cloud/intern/point_cloud_selection.cc b/source/blender/editors/pointcloud/intern/selection.cc similarity index 87% rename from source/blender/editors/point_cloud/intern/point_cloud_selection.cc rename to source/blender/editors/pointcloud/intern/selection.cc index b3e46870c83..96d7c39cbed 100644 --- a/source/blender/editors/point_cloud/intern/point_cloud_selection.cc +++ b/source/blender/editors/pointcloud/intern/selection.cc @@ -14,13 +14,13 @@ #include "BKE_attribute.hh" -#include "ED_point_cloud.hh" +#include "ED_pointcloud.hh" #include "ED_select_utils.hh" #include "ED_view3d.hh" #include "DNA_pointcloud_types.h" -namespace blender::ed::point_cloud { +namespace blender::ed::pointcloud { static bool contains(const VArray &varray, const IndexMask &indices_to_check, @@ -87,23 +87,23 @@ static bool contains(const VArray &varray, const IndexRange range_to_check return contains(varray, IndexMask(range_to_check), value); } -bool has_anything_selected(const PointCloud &point_cloud) +bool has_anything_selected(const PointCloud &pointcloud) { - const VArray selection = *point_cloud.attributes().lookup(".selection"); + const VArray selection = *pointcloud.attributes().lookup(".selection"); return !selection || contains(selection, selection.index_range(), true); } -bke::GSpanAttributeWriter ensure_selection_attribute(PointCloud &point_cloud, +bke::GSpanAttributeWriter ensure_selection_attribute(PointCloud &pointcloud, eCustomDataType create_type) { const bke::AttrDomain selection_domain = bke::AttrDomain::Point; const StringRef attribute_name = ".selection"; - bke::MutableAttributeAccessor attributes = point_cloud.attributes_for_write(); + bke::MutableAttributeAccessor attributes = pointcloud.attributes_for_write(); if (attributes.contains(attribute_name)) { return attributes.lookup_for_write_span(attribute_name); } - const int domain_size = point_cloud.totpoint; + const int domain_size = pointcloud.totpoint; switch (create_type) { case CD_PROP_BOOL: attributes.add(attribute_name, @@ -159,19 +159,19 @@ static void invert_selection(GMutableSpan selection, const IndexMask &mask) } } -static void select_all(PointCloud &point_cloud, const IndexMask &mask, int action) +static void select_all(PointCloud &pointcloud, const IndexMask &mask, int action) { if (action == SEL_SELECT) { std::optional range = mask.to_range(); - if (range.has_value() && (*range == IndexRange(point_cloud.totpoint))) { - bke::MutableAttributeAccessor attributes = point_cloud.attributes_for_write(); + if (range.has_value() && (*range == IndexRange(pointcloud.totpoint))) { + bke::MutableAttributeAccessor attributes = pointcloud.attributes_for_write(); /* As an optimization, just remove the selection attributes when everything is selected. */ attributes.remove(".selection"); return; } } - bke::GSpanAttributeWriter selection = ensure_selection_attribute(point_cloud, CD_PROP_BOOL); + bke::GSpanAttributeWriter selection = ensure_selection_attribute(pointcloud, CD_PROP_BOOL); if (action == SEL_SELECT) { fill_selection_true(selection.span, mask); } @@ -184,17 +184,17 @@ static void select_all(PointCloud &point_cloud, const IndexMask &mask, int actio selection.finish(); } -void select_all(PointCloud &point_cloud, int action) +void select_all(PointCloud &pointcloud, int action) { - select_all(point_cloud, IndexRange(point_cloud.totpoint), action); + select_all(pointcloud, IndexRange(pointcloud.totpoint), action); } -static bool apply_selection_operation(PointCloud &point_cloud, +static bool apply_selection_operation(PointCloud &pointcloud, const IndexMask &mask, eSelectOp sel_op) { bool changed = false; - bke::GSpanAttributeWriter selection = ensure_selection_attribute(point_cloud, CD_PROP_BOOL); + bke::GSpanAttributeWriter selection = ensure_selection_attribute(pointcloud, CD_PROP_BOOL); if (sel_op == SEL_OP_SET) { fill_selection_false(selection.span, IndexRange(selection.span.size())); changed = true; @@ -218,13 +218,13 @@ static bool apply_selection_operation(PointCloud &point_cloud, return changed; } -bool select_box(PointCloud &point_cloud, +bool select_box(PointCloud &pointcloud, const ARegion ®ion, const float4x4 &projection, const rcti &rect, const eSelectOp sel_op) { - const Span positions = point_cloud.positions(); + const Span positions = pointcloud.positions(); IndexMaskMemory memory; const IndexMask mask = IndexMask::from_predicate( @@ -234,10 +234,10 @@ bool select_box(PointCloud &point_cloud, return BLI_rcti_isect_pt_v(&rect, int2(pos_proj)); }); - return apply_selection_operation(point_cloud, mask, sel_op); + return apply_selection_operation(pointcloud, mask, sel_op); } -bool select_lasso(PointCloud &point_cloud, +bool select_lasso(PointCloud &pointcloud, const ARegion ®ion, const float4x4 &projection, const Span lasso_coords, @@ -246,7 +246,7 @@ bool select_lasso(PointCloud &point_cloud, rcti bbox; BLI_lasso_boundbox(&bbox, lasso_coords); - const Span positions = point_cloud.positions(); + const Span positions = pointcloud.positions(); IndexMaskMemory memory; const IndexMask mask = IndexMask::from_predicate( @@ -263,10 +263,10 @@ bool select_lasso(PointCloud &point_cloud, return true; }); - return apply_selection_operation(point_cloud, mask, sel_op); + return apply_selection_operation(pointcloud, mask, sel_op); } -bool select_circle(PointCloud &point_cloud, +bool select_circle(PointCloud &pointcloud, const ARegion ®ion, const float4x4 &projection, const int2 coord, @@ -275,7 +275,7 @@ bool select_circle(PointCloud &point_cloud, { const float radius_sq = radius * radius; - const Span positions = point_cloud.positions(); + const Span positions = pointcloud.positions(); IndexMaskMemory memory; const IndexMask mask = IndexMask::from_predicate( @@ -285,7 +285,7 @@ bool select_circle(PointCloud &point_cloud, return math::distance_squared(pos_proj, float2(coord)) <= radius_sq; }); - return apply_selection_operation(point_cloud, mask, sel_op); + return apply_selection_operation(pointcloud, mask, sel_op); } static FindClosestData closer_elem(const FindClosestData &a, const FindClosestData &b) @@ -341,4 +341,4 @@ IndexMask retrieve_selected_points(const PointCloud &pointcloud, IndexMaskMemory return IndexMask::from_bools(selection, memory); } -} // namespace blender::ed::point_cloud +} // namespace blender::ed::pointcloud diff --git a/source/blender/editors/point_cloud/intern/separate.cc b/source/blender/editors/pointcloud/intern/separate.cc similarity index 93% rename from source/blender/editors/point_cloud/intern/separate.cc rename to source/blender/editors/pointcloud/intern/separate.cc index 4db8deb3bf9..a5d2d2963dc 100644 --- a/source/blender/editors/point_cloud/intern/separate.cc +++ b/source/blender/editors/pointcloud/intern/separate.cc @@ -14,7 +14,7 @@ #include "DEG_depsgraph_build.hh" #include "ED_object.hh" -#include "ED_point_cloud.hh" +#include "ED_pointcloud.hh" #include "DNA_layer_types.h" #include "DNA_pointcloud_types.h" @@ -23,7 +23,7 @@ #include "WM_api.hh" -namespace blender::ed::point_cloud { +namespace blender::ed::pointcloud { static int separate_exec(bContext *C, wmOperator * /*op*/) { @@ -97,16 +97,16 @@ static int separate_exec(bContext *C, wmOperator * /*op*/) return OPERATOR_FINISHED; } -void POINT_CLOUD_OT_separate(wmOperatorType *ot) +void POINTCLOUD_OT_separate(wmOperatorType *ot) { ot->name = "Separate"; - ot->idname = "POINT_CLOUD_OT_separate"; + ot->idname = "POINTCLOUD_OT_separate"; ot->description = "Separate selected geometry into a new point cloud"; ot->exec = separate_exec; - ot->poll = editable_point_cloud_in_edit_mode_poll; + ot->poll = editable_pointcloud_in_edit_mode_poll; ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO; } -} // namespace blender::ed::point_cloud +} // namespace blender::ed::pointcloud diff --git a/source/blender/editors/point_cloud/intern/point_cloud_undo.cc b/source/blender/editors/pointcloud/intern/undo.cc similarity index 80% rename from source/blender/editors/point_cloud/intern/point_cloud_undo.cc rename to source/blender/editors/pointcloud/intern/undo.cc index d2d5fabdb8c..16e70d59ebd 100644 --- a/source/blender/editors/point_cloud/intern/point_cloud_undo.cc +++ b/source/blender/editors/pointcloud/intern/undo.cc @@ -19,15 +19,15 @@ #include "DEG_depsgraph.hh" -#include "ED_point_cloud.hh" +#include "ED_pointcloud.hh" #include "ED_undo.hh" #include "WM_api.hh" #include "WM_types.hh" -static CLG_LogRef LOG = {"ed.undo.point_cloud"}; +static CLG_LogRef LOG = {"ed.undo.pointcloud"}; -namespace blender::ed::point_cloud { +namespace blender::ed::pointcloud { namespace undo { /* -------------------------------------------------------------------- */ @@ -66,12 +66,12 @@ static bool step_encode(bContext *C, Main *bmain, UndoStep *us_p) for (const int i : range) { Object *ob = objects[i]; StepObject &object = us->objects[i]; - PointCloud &point_cloud = *static_cast(ob->data); + PointCloud &pointcloud = *static_cast(ob->data); object.obedit_ref.ptr = ob; CustomData_init_from( - &point_cloud.pdata, &object.custom_data, CD_MASK_ALL, point_cloud.totpoint); - object.bounds_cache = point_cloud.runtime->bounds_cache; - object.totpoint = point_cloud.totpoint; + &pointcloud.pdata, &object.custom_data, CD_MASK_ALL, pointcloud.totpoint); + object.bounds_cache = pointcloud.runtime->bounds_cache; + object.totpoint = pointcloud.totpoint; } }); @@ -98,19 +98,19 @@ static void step_decode( BLI_assert(BKE_object_is_in_editmode(us->objects.first().obedit_ref.ptr)); for (const StepObject &object : us->objects) { - PointCloud &point_cloud = *static_cast(object.obedit_ref.ptr->data); + PointCloud &pointcloud = *static_cast(object.obedit_ref.ptr->data); const bool positions_changed = - CustomData_get_layer_named(&point_cloud.pdata, CD_PROP_FLOAT3, "position") != + CustomData_get_layer_named(&pointcloud.pdata, CD_PROP_FLOAT3, "position") != CustomData_get_layer_named(&object.custom_data, CD_PROP_FLOAT3, "position"); - CustomData_free(&point_cloud.pdata); - CustomData_init_from(&object.custom_data, &point_cloud.pdata, CD_MASK_ALL, object.totpoint); - point_cloud.totpoint = object.totpoint; - point_cloud.runtime->bounds_cache = object.bounds_cache; + CustomData_free(&pointcloud.pdata); + CustomData_init_from(&object.custom_data, &pointcloud.pdata, CD_MASK_ALL, object.totpoint); + pointcloud.totpoint = object.totpoint; + pointcloud.runtime->bounds_cache = object.bounds_cache; if (positions_changed) { - point_cloud.runtime->bvh_cache.tag_dirty(); + pointcloud.runtime->bvh_cache.tag_dirty(); } - DEG_id_tag_update(&point_cloud.id, ID_RECALC_GEOMETRY); + DEG_id_tag_update(&pointcloud.id, ID_RECALC_GEOMETRY); } ED_undo_object_set_active_or_warn( @@ -149,7 +149,7 @@ static void foreach_ID_ref(UndoStep *us_p, void undosys_type_register(UndoType *ut) { ut->name = "Edit Point Cloud"; - ut->poll = editable_point_cloud_in_edit_mode_poll; + ut->poll = editable_pointcloud_in_edit_mode_poll; ut->step_encode = undo::step_encode; ut->step_decode = undo::step_decode; ut->step_free = undo::step_free; @@ -161,4 +161,4 @@ void undosys_type_register(UndoType *ut) ut->step_size = sizeof(undo::PointCloudUndoStep); } -} // namespace blender::ed::point_cloud +} // namespace blender::ed::pointcloud diff --git a/source/blender/editors/space_api/spacetypes.cc b/source/blender/editors/space_api/spacetypes.cc index 7d1bef4da27..7998ed2a143 100644 --- a/source/blender/editors/space_api/spacetypes.cc +++ b/source/blender/editors/space_api/spacetypes.cc @@ -43,7 +43,7 @@ #include "ED_object.hh" #include "ED_paint.hh" #include "ED_physics.hh" -#include "ED_point_cloud.hh" +#include "ED_pointcloud.hh" #include "ED_render.hh" #include "ED_scene.hh" #include "ED_screen.hh" @@ -106,7 +106,7 @@ void ED_spacetypes_init() ED_operatortypes_physics(); ED_operatortypes_curve(); curves::operatortypes_curves(); - point_cloud::operatortypes_point_cloud(); + pointcloud::operatortypes_pointcloud(); ED_operatortypes_armature(); ED_operatortypes_marker(); ED_operatortypes_metaball(); @@ -164,7 +164,7 @@ void ED_spacemacros_init() ED_operatormacros_clip(); ED_operatormacros_curve(); curves::operatormacros_curves(); - point_cloud::operatormacros_point_cloud(); + pointcloud::operatormacros_pointcloud(); ED_operatormacros_mask(); ED_operatormacros_sequencer(); ED_operatormacros_paint(); @@ -194,7 +194,7 @@ void ED_spacetypes_keymap(wmKeyConfig *keyconf) ED_keymap_uvedit(keyconf); ED_keymap_curve(keyconf); curves::keymap_curves(keyconf); - point_cloud::keymap_point_cloud(keyconf); + pointcloud::keymap_pointcloud(keyconf); ED_keymap_armature(keyconf); ED_keymap_physics(keyconf); ED_keymap_metaball(keyconf); diff --git a/source/blender/editors/space_buttons/CMakeLists.txt b/source/blender/editors/space_buttons/CMakeLists.txt index 08ad313017e..21f9ad00ad2 100644 --- a/source/blender/editors/space_buttons/CMakeLists.txt +++ b/source/blender/editors/space_buttons/CMakeLists.txt @@ -41,7 +41,7 @@ endif() if(WITH_EXPERIMENTAL_FEATURES) add_definitions(-DWITH_SIMULATION_DATABLOCK) - add_definitions(-DWITH_POINT_CLOUD) + add_definitions(-DWITH_pointcloud) endif() blender_add_lib(bf_editor_space_buttons "${SRC}" "${INC}" "${INC_SYS}" "${LIB}") diff --git a/source/blender/editors/space_buttons/buttons_context.cc b/source/blender/editors/space_buttons/buttons_context.cc index 7fc66c5c8a2..6ad098e86f6 100644 --- a/source/blender/editors/space_buttons/buttons_context.cc +++ b/source/blender/editors/space_buttons/buttons_context.cc @@ -264,7 +264,7 @@ static bool buttons_context_path_data(ButsContextPath *path, int type) if (RNA_struct_is_a(ptr->type, &RNA_Curves) && ELEM(type, -1, OB_CURVES)) { return true; } -#ifdef WITH_POINT_CLOUD +#ifdef WITH_POINTCLOUD if (RNA_struct_is_a(ptr->type, &RNA_PointCloud) && ELEM(type, -1, OB_POINTCLOUD)) { return true; } @@ -842,7 +842,7 @@ const char *buttons_context_dir[] = { "gpencil", "grease_pencil", "curves", -#ifdef WITH_POINT_CLOUD +#ifdef WITH_POINTCLOUD "pointcloud", #endif "volume", @@ -939,7 +939,7 @@ int /*eContextResult*/ buttons_context(const bContext *C, set_pointer_type(path, result, &RNA_Curves); return CTX_RESULT_OK; } -#ifdef WITH_POINT_CLOUD +#ifdef WITH_POINTCLOUD if (CTX_data_equals(member, "pointcloud")) { set_pointer_type(path, result, &RNA_PointCloud); return CTX_RESULT_OK; diff --git a/source/blender/editors/space_view3d/space_view3d.cc b/source/blender/editors/space_view3d/space_view3d.cc index b7384ebb930..7dc390fc4b1 100644 --- a/source/blender/editors/space_view3d/space_view3d.cc +++ b/source/blender/editors/space_view3d/space_view3d.cc @@ -1734,8 +1734,8 @@ void ED_view3d_buttons_region_layout_ex(const bContext *C, case CTX_MODE_VERTEX_GREASE_PENCIL: ARRAY_SET_ITEMS(contexts, ".greasepencil_vertex"); break; - case CTX_MODE_EDIT_POINT_CLOUD: - ARRAY_SET_ITEMS(contexts, ".point_cloud_edit"); + case CTX_MODE_EDIT_POINTCLOUD: + ARRAY_SET_ITEMS(contexts, ".pointcloud_edit"); break; case CTX_MODE_POSE: ARRAY_SET_ITEMS(contexts, ".posemode"); diff --git a/source/blender/editors/space_view3d/view3d_select.cc b/source/blender/editors/space_view3d/view3d_select.cc index 0e30a37f63e..81d8b023f26 100644 --- a/source/blender/editors/space_view3d/view3d_select.cc +++ b/source/blender/editors/space_view3d/view3d_select.cc @@ -79,7 +79,7 @@ #include "ED_object.hh" #include "ED_outliner.hh" #include "ED_particle.hh" -#include "ED_point_cloud.hh" +#include "ED_pointcloud.hh" #include "ED_screen.hh" #include "ED_sculpt.hh" #include "ED_select_utils.hh" @@ -1439,10 +1439,10 @@ static bool view3d_lasso_select(bContext *C, break; } case OB_POINTCLOUD: { - PointCloud &point_cloud = *static_cast(vc->obedit->data); + PointCloud &pointcloud = *static_cast(vc->obedit->data); const float4x4 projection = ED_view3d_ob_project_mat_get(vc->rv3d, vc->obedit); - changed = ed::point_cloud::select_lasso( - point_cloud, *vc->region, projection, mcoords, sel_op); + changed = ed::pointcloud::select_lasso( + pointcloud, *vc->region, projection, mcoords, sel_op); if (changed) { /* Use #ID_RECALC_GEOMETRY instead of #ID_RECALC_SELECT because it is handled as a * generic attribute for now. */ @@ -3075,7 +3075,7 @@ static bool ed_wpaint_vertex_select_pick(bContext *C, struct ClosestPointCloud { PointCloud *pointcloud = nullptr; - blender::ed::point_cloud::FindClosestData elem; + blender::ed::pointcloud::FindClosestData elem; }; /** @@ -3083,7 +3083,7 @@ struct ClosestPointCloud { * * \returns true if the selection changed. */ -static bool point_cloud_select_pick(bContext &C, const int2 mval, const SelectPick_Params ¶ms) +static bool pointcloud_select_pick(bContext &C, const int2 mval, const SelectPick_Params ¶ms) { using namespace blender; using namespace blender::ed; @@ -3105,14 +3105,14 @@ static bool point_cloud_select_pick(bContext &C, const int2 mval, const SelectPi PointCloud &pointcloud = *static_cast(object.data); const float4x4 projection = ED_view3d_ob_project_mat_get(vc.rv3d, &object); - std::optional new_closest_elem = - point_cloud::find_closest_point_to_screen_co(*vc.region, - pointcloud.positions(), - projection, - IndexMask(pointcloud.totpoint), - float2(mval), - ED_view3d_select_dist_px(), - new_closest.elem); + std::optional new_closest_elem = + pointcloud::find_closest_point_to_screen_co(*vc.region, + pointcloud.positions(), + projection, + IndexMask(pointcloud.totpoint), + float2(mval), + ED_view3d_select_dist_px(), + new_closest.elem); if (new_closest_elem) { new_closest.elem = *new_closest_elem; new_closest.pointcloud = &pointcloud; @@ -3129,13 +3129,13 @@ static bool point_cloud_select_pick(bContext &C, const int2 mval, const SelectPi threading::parallel_for(bases.index_range(), 1L, [&](const IndexRange range) { for (Base *base : bases.as_span().slice(range)) { PointCloud &pointcloud = *static_cast(base->object->data); - if (!point_cloud::has_anything_selected(pointcloud)) { + if (!pointcloud::has_anything_selected(pointcloud)) { continue; } - bke::GSpanAttributeWriter selection = point_cloud::ensure_selection_attribute( - pointcloud, CD_PROP_BOOL); - point_cloud::fill_selection_false(selection.span, IndexMask(pointcloud.totpoint)); + bke::GSpanAttributeWriter selection = pointcloud::ensure_selection_attribute(pointcloud, + CD_PROP_BOOL); + pointcloud::fill_selection_false(selection.span, IndexMask(pointcloud.totpoint)); selection.finish(); deselected = true; @@ -3151,8 +3151,8 @@ static bool point_cloud_select_pick(bContext &C, const int2 mval, const SelectPi return deselected; } - bke::GSpanAttributeWriter selection = point_cloud::ensure_selection_attribute( - *closest.pointcloud, CD_PROP_BOOL); + bke::GSpanAttributeWriter selection = pointcloud::ensure_selection_attribute(*closest.pointcloud, + CD_PROP_BOOL); curves::apply_selection_operation_at_index(selection.span, closest.elem.index, params.sel_op); selection.finish(); @@ -3548,7 +3548,7 @@ static int view3d_select_exec(bContext *C, wmOperator *op) changed = ED_curve_editfont_select_pick(C, mval, ¶ms); } else if (obedit->type == OB_POINTCLOUD) { - changed = point_cloud_select_pick(*C, mval, params); + changed = pointcloud_select_pick(*C, mval, params); } else if (obedit->type == OB_CURVES) { changed = ed_curves_select_pick(*C, mval, params); @@ -4510,9 +4510,9 @@ static int view3d_box_select_exec(bContext *C, wmOperator *op) break; } case OB_POINTCLOUD: { - PointCloud &point_cloud = *static_cast(vc.obedit->data); + PointCloud &pointcloud = *static_cast(vc.obedit->data); const float4x4 projection = ED_view3d_ob_project_mat_get(vc.rv3d, vc.obedit); - changed = ed::point_cloud::select_box(point_cloud, *vc.region, projection, rect, sel_op); + changed = ed::pointcloud::select_box(pointcloud, *vc.region, projection, rect, sel_op); if (changed) { /* Use #ID_RECALC_GEOMETRY instead of #ID_RECALC_SELECT because it is handled as a * generic attribute for now. */ @@ -5359,10 +5359,10 @@ static bool obedit_circle_select(bContext *C, break; } case OB_POINTCLOUD: { - PointCloud &point_cloud = *static_cast(vc->obedit->data); + PointCloud &pointcloud = *static_cast(vc->obedit->data); const float4x4 projection = ED_view3d_ob_project_mat_get(vc->rv3d, vc->obedit); - changed = ed::point_cloud::select_circle( - point_cloud, *vc->region, projection, mval, rad, sel_op); + changed = ed::pointcloud::select_circle( + pointcloud, *vc->region, projection, mval, rad, sel_op); if (changed) { /* Use #ID_RECALC_GEOMETRY instead of #ID_RECALC_SELECT because it is handled as a * generic attribute for now. */ diff --git a/source/blender/editors/space_view3d/view3d_snap.cc b/source/blender/editors/space_view3d/view3d_snap.cc index 166e1a6a4c8..8285cd33ad4 100644 --- a/source/blender/editors/space_view3d/view3d_snap.cc +++ b/source/blender/editors/space_view3d/view3d_snap.cc @@ -46,7 +46,7 @@ #include "ED_grease_pencil.hh" #include "ED_keyframing.hh" #include "ED_object.hh" -#include "ED_point_cloud.hh" +#include "ED_pointcloud.hh" #include "ED_screen.hh" #include "ED_transverts.hh" @@ -1049,7 +1049,7 @@ bool ED_view3d_minmax_verts(const Scene *scene, Object *obedit, float r_min[3], const PointCloud &pointcloud = *static_cast(ob_orig.data); IndexMaskMemory memory; - const IndexMask mask = point_cloud::retrieve_selected_points(pointcloud, memory); + const IndexMask mask = pointcloud::retrieve_selected_points(pointcloud, memory); const std::optional> bounds = bounds_min_max_with_transform( obedit->object_to_world(), pointcloud.positions(), mask); diff --git a/source/blender/editors/transform/CMakeLists.txt b/source/blender/editors/transform/CMakeLists.txt index dfafbe41a18..6626e6e3182 100644 --- a/source/blender/editors/transform/CMakeLists.txt +++ b/source/blender/editors/transform/CMakeLists.txt @@ -37,7 +37,7 @@ set(SRC transform_convert_object_texspace.cc transform_convert_paintcurve.cc transform_convert_particle.cc - transform_convert_point_cloud.cc + transform_convert_pointcloud.cc transform_convert_sculpt.cc transform_convert_sequencer.cc transform_convert_sequencer_image.cc diff --git a/source/blender/editors/transform/transform_convert.cc b/source/blender/editors/transform/transform_convert.cc index eea84772eea..55cc4bf7cc0 100644 --- a/source/blender/editors/transform/transform_convert.cc +++ b/source/blender/editors/transform/transform_convert.cc @@ -788,7 +788,7 @@ static void init_TransDataContainers(TransInfo *t, Object *obact, Span &TransConvertType_Curve, &curves::TransConvertType_Curves, &greasepencil::TransConvertType_GreasePencil, - &point_cloud::TransConvertType_PointCloud, + &pointcloud::TransConvertType_PointCloud, &TransConvertType_Lattice, &TransConvertType_MBall, &TransConvertType_Mesh, @@ -976,7 +976,7 @@ static TransConvertTypeInfo *convert_type_get(const TransInfo *t, Object **r_obj return &curves::TransConvertType_Curves; } if (t->obedit_type == OB_POINTCLOUD) { - return &point_cloud::TransConvertType_PointCloud; + return &pointcloud::TransConvertType_PointCloud; } return nullptr; } diff --git a/source/blender/editors/transform/transform_convert.hh b/source/blender/editors/transform/transform_convert.hh index 2b490cd135d..906b9762ed7 100644 --- a/source/blender/editors/transform/transform_convert.hh +++ b/source/blender/editors/transform/transform_convert.hh @@ -242,9 +242,9 @@ namespace curves { extern TransConvertTypeInfo TransConvertType_Curves; } -/* `transform_convert_point_cloud.cc` */ +/* `transform_convert_pointcloud.cc` */ -namespace point_cloud { +namespace pointcloud { extern TransConvertTypeInfo TransConvertType_PointCloud; } diff --git a/source/blender/editors/transform/transform_convert_point_cloud.cc b/source/blender/editors/transform/transform_convert_pointcloud.cc similarity index 79% rename from source/blender/editors/transform/transform_convert_point_cloud.cc rename to source/blender/editors/transform/transform_convert_pointcloud.cc index 35b99e145ff..71deaaa37af 100644 --- a/source/blender/editors/transform/transform_convert_point_cloud.cc +++ b/source/blender/editors/transform/transform_convert_pointcloud.cc @@ -28,7 +28,7 @@ /** \name Curve/Surfaces Transform Creation * \{ */ -namespace blender::ed::transform::point_cloud { +namespace blender::ed::transform::pointcloud { struct PointCloudTransformData { IndexMaskMemory memory; @@ -56,8 +56,8 @@ static void createTransPointCloudVerts(bContext * /*C*/, TransInfo *t) for (const int i : trans_data_contrainers.index_range()) { TransDataContainer &tc = trans_data_contrainers[i]; - PointCloud &point_cloud = *static_cast(tc.obedit->data); - bke::MutableAttributeAccessor attributes = point_cloud.attributes_for_write(); + PointCloud &pointcloud = *static_cast(tc.obedit->data); + bke::MutableAttributeAccessor attributes = pointcloud.attributes_for_write(); PointCloudTransformData &transform_data = *create_transform_custom_data(tc.custom.type); const VArray selection_attr = *attributes.lookup_or_default( ".selection", bke::AttrDomain::Point, true); @@ -72,14 +72,14 @@ static void createTransPointCloudVerts(bContext * /*C*/, TransInfo *t) MutableSpan tc_data = MutableSpan(tc.data, tc.data_len); transform_data.positions.reinitialize(tc.data_len); - array_utils::gather(point_cloud.positions(), + array_utils::gather(pointcloud.positions(), transform_data.selection, transform_data.positions.as_mutable_span()); if (t->mode == TFM_CURVE_SHRINKFATTEN) { transform_data.radii.reinitialize(transform_data.selection.size()); array_utils::gather( - point_cloud.radius(), transform_data.selection, transform_data.radii.as_mutable_span()); + pointcloud.radius(), transform_data.selection, transform_data.radii.as_mutable_span()); } const float4x4 &transform = tc.obedit->object_to_world(); @@ -111,26 +111,25 @@ static void createTransPointCloudVerts(bContext * /*C*/, TransInfo *t) } } -static void recalcData_point_cloud(TransInfo *t) +static void recalcData_pointcloud(TransInfo *t) { const Span trans_data_contrainers(t->data_container, t->data_container_len); for (const TransDataContainer &tc : trans_data_contrainers) { const PointCloudTransformData &transform_data = *static_cast( tc.custom.type.data); - PointCloud &point_cloud = *static_cast(tc.obedit->data); + PointCloud &pointcloud = *static_cast(tc.obedit->data); if (t->mode == TFM_CURVE_SHRINKFATTEN) { - array_utils::scatter(transform_data.radii.as_span(), - transform_data.selection, - point_cloud.radius_for_write()); - point_cloud.tag_radii_changed(); + array_utils::scatter( + transform_data.radii.as_span(), transform_data.selection, pointcloud.radius_for_write()); + pointcloud.tag_radii_changed(); } else { array_utils::scatter(transform_data.positions.as_span(), transform_data.selection, - point_cloud.positions_for_write()); - point_cloud.tag_positions_changed(); + pointcloud.positions_for_write()); + pointcloud.tag_positions_changed(); } - DEG_id_tag_update(&point_cloud.id, ID_RECALC_GEOMETRY); + DEG_id_tag_update(&pointcloud.id, ID_RECALC_GEOMETRY); } } @@ -138,9 +137,9 @@ static void recalcData_point_cloud(TransInfo *t) TransConvertTypeInfo TransConvertType_PointCloud = { /*flags*/ (T_EDIT | T_POINTS), - /*create_trans_data*/ point_cloud::createTransPointCloudVerts, - /*recalc_data*/ point_cloud::recalcData_point_cloud, + /*create_trans_data*/ pointcloud::createTransPointCloudVerts, + /*recalc_data*/ pointcloud::recalcData_pointcloud, /*special_aftertrans_update*/ nullptr, }; -} // namespace blender::ed::transform::point_cloud +} // namespace blender::ed::transform::pointcloud diff --git a/source/blender/editors/transform/transform_gizmo_3d.cc b/source/blender/editors/transform/transform_gizmo_3d.cc index 1646ac2f496..d7421ae2415 100644 --- a/source/blender/editors/transform/transform_gizmo_3d.cc +++ b/source/blender/editors/transform/transform_gizmo_3d.cc @@ -759,20 +759,20 @@ static int gizmo_3d_foreach_selected(const bContext *C, } else if (obedit->type == OB_POINTCLOUD) { FOREACH_EDIT_OBJECT_BEGIN (ob_iter, use_mat_local) { - const PointCloud &point_cloud = *static_cast(ob_iter->data); + const PointCloud &pointcloud = *static_cast(ob_iter->data); float4x4 mat_local; if (use_mat_local) { mat_local = obedit->world_to_object() * ob_iter->object_to_world(); } - const bke::AttributeAccessor attributes = point_cloud.attributes(); + const bke::AttributeAccessor attributes = pointcloud.attributes(); const VArray selection = *attributes.lookup_or_default( ".selection", bke::AttrDomain::Point, true); IndexMaskMemory memory; const IndexMask mask = IndexMask::from_bools(selection, memory); - const Span positions = point_cloud.positions(); + const Span positions = pointcloud.positions(); totsel += mask.size(); mask.foreach_index([&](const int point) { run_coord_with_matrix(positions[point], use_mat_local, mat_local.ptr()); diff --git a/source/blender/editors/undo/undo_system_types.cc b/source/blender/editors/undo/undo_system_types.cc index 1b2e8672b30..2a395e61c09 100644 --- a/source/blender/editors/undo/undo_system_types.cc +++ b/source/blender/editors/undo/undo_system_types.cc @@ -17,7 +17,7 @@ #include "ED_mesh.hh" #include "ED_paint.hh" #include "ED_particle.hh" -#include "ED_point_cloud.hh" +#include "ED_pointcloud.hh" #include "ED_sculpt.hh" #include "ED_text.hh" #include "ED_undo.hh" @@ -38,7 +38,7 @@ void ED_undosys_type_init() BKE_undosys_type_append(ED_mball_undosys_type); BKE_undosys_type_append(ED_mesh_undosys_type); BKE_undosys_type_append(curves::undosys_type_register); - BKE_undosys_type_append(point_cloud::undosys_type_register); + BKE_undosys_type_append(pointcloud::undosys_type_register); BKE_undosys_type_append(ED_undosys_type_grease_pencil); /* Paint Modes */ diff --git a/source/blender/editors/util/CMakeLists.txt b/source/blender/editors/util/CMakeLists.txt index 95c313a9db5..b8640f607ab 100644 --- a/source/blender/editors/util/CMakeLists.txt +++ b/source/blender/editors/util/CMakeLists.txt @@ -65,7 +65,7 @@ set(SRC ../include/ED_paint.hh ../include/ED_particle.hh ../include/ED_physics.hh - ../include/ED_point_cloud.hh + ../include/ED_pointcloud.hh ../include/ED_render.hh ../include/ED_scene.hh ../include/ED_screen.hh diff --git a/source/blender/editors/util/ed_transverts.cc b/source/blender/editors/util/ed_transverts.cc index 282a0777954..4bc322eca46 100644 --- a/source/blender/editors/util/ed_transverts.cc +++ b/source/blender/editors/util/ed_transverts.cc @@ -32,7 +32,7 @@ #include "ED_armature.hh" #include "ED_curves.hh" -#include "ED_point_cloud.hh" +#include "ED_pointcloud.hh" #include "ANIM_bone_collections.hh" @@ -520,8 +520,8 @@ void ED_transverts_create_from_obedit(TransVertStore *tvs, const Object *obedit, PointCloud *pointcloud = static_cast(obedit->data); IndexMaskMemory memory; - const IndexMask selection = blender::ed::point_cloud::retrieve_selected_points(*pointcloud, - memory); + const IndexMask selection = blender::ed::pointcloud::retrieve_selected_points(*pointcloud, + memory); MutableSpan positions = pointcloud->positions_for_write(); tvs->transverts = static_cast( diff --git a/source/blender/geometry/intern/reorder.cc b/source/blender/geometry/intern/reorder.cc index 0e326311429..89ef895249b 100644 --- a/source/blender/geometry/intern/reorder.cc +++ b/source/blender/geometry/intern/reorder.cc @@ -384,9 +384,9 @@ bke::GeometryComponentPtr reordered_component(const bke::GeometryComponent &src_ if (const bke::PointCloudComponent *src_points_component = dynamic_cast(&src_component)) { - PointCloud *result_point_cloud = reorder_points( + PointCloud *result_pointcloud = reorder_points( *src_points_component->get(), old_by_new_map, attribute_filter); - return bke::GeometryComponentPtr(new bke::PointCloudComponent(result_point_cloud)); + return bke::GeometryComponentPtr(new bke::PointCloudComponent(result_pointcloud)); } if (const bke::CurveComponent *src_curves_component = dynamic_cast( &src_component)) diff --git a/source/blender/geometry/intern/separate_geometry.cc b/source/blender/geometry/intern/separate_geometry.cc index 19d3a3d29f0..1145f7193e1 100644 --- a/source/blender/geometry/intern/separate_geometry.cc +++ b/source/blender/geometry/intern/separate_geometry.cc @@ -51,7 +51,7 @@ static std::optional separate_curves_selection( } /** \return std::nullopt if the geometry should remain unchanged. */ -static std::optional separate_point_cloud_selection( +static std::optional separate_pointcloud_selection( const PointCloud &src_pointcloud, const fn::Field &selection_field, const bke::AttributeFilter &attribute_filter) @@ -182,7 +182,7 @@ void separate_geometry(bke::GeometrySet &geometry_set, bool some_valid_domain = false; if (const PointCloud *points = geometry_set.get_pointcloud()) { if (domain == AttrDomain::Point) { - std::optional dst_points = separate_point_cloud_selection( + std::optional dst_points = separate_pointcloud_selection( *points, selection, attribute_filter); if (dst_points) { geometry_set.replace_pointcloud(*dst_points); diff --git a/source/blender/gpu/shaders/material/gpu_shader_material_point_info.glsl b/source/blender/gpu/shaders/material/gpu_shader_material_point_info.glsl index 2cd8fd40118..97f26fc951a 100644 --- a/source/blender/gpu/shaders/material/gpu_shader_material_point_info.glsl +++ b/source/blender/gpu/shaders/material/gpu_shader_material_point_info.glsl @@ -6,11 +6,11 @@ void node_point_info(out vec3 position, out float radius, out float random) { -#ifdef MAT_GEOM_POINT_CLOUD +#ifdef MAT_GEOM_POINTCLOUD /* EEVEE-Next case. */ - position = point_cloud_interp.position; - radius = point_cloud_interp.radius; - random = wang_hash_noise(uint(point_cloud_interp_flat.id)); + position = pointcloud_interp.position; + radius = pointcloud_interp.radius; + random = wang_hash_noise(uint(pointcloud_interp_flat.id)); #elif defined(POINTCLOUD_SHADER) /* EEVEE-Legacy case. */ position = pointPosition; diff --git a/source/blender/io/alembic/intern/abc_reader_points.cc b/source/blender/io/alembic/intern/abc_reader_points.cc index 87aa3cfbd59..daee1de12aa 100644 --- a/source/blender/io/alembic/intern/abc_reader_points.cc +++ b/source/blender/io/alembic/intern/abc_reader_points.cc @@ -58,21 +58,21 @@ bool AbcPointsReader::accepts_object_type( void AbcPointsReader::readObjectData(Main *bmain, const Alembic::Abc::ISampleSelector &sample_sel) { - PointCloud *point_cloud = BKE_pointcloud_add_default(bmain, m_data_name.c_str()); + PointCloud *pointcloud = BKE_pointcloud_add_default(bmain, m_data_name.c_str()); bke::GeometrySet geometry_set = bke::GeometrySet::from_pointcloud( - point_cloud, bke::GeometryOwnershipType::Editable); + pointcloud, bke::GeometryOwnershipType::Editable); read_geometry(geometry_set, sample_sel, 0, "", 1.0f, nullptr); - PointCloud *read_point_cloud = + PointCloud *read_pointcloud = geometry_set.get_component_for_write().release(); - if (read_point_cloud != point_cloud) { - BKE_pointcloud_nomain_to_pointcloud(read_point_cloud, point_cloud); + if (read_pointcloud != pointcloud) { + BKE_pointcloud_nomain_to_pointcloud(read_pointcloud, pointcloud); } m_object = BKE_object_add_only_object(bmain, OB_POINTCLOUD, m_object_name.c_str()); - m_object->data = point_cloud; + m_object->data = pointcloud; if (m_settings->always_add_cache_reader || has_animations(m_schema, m_settings)) { addCacheModifier(); @@ -134,8 +134,8 @@ void AbcPointsReader::read_geometry(bke::GeometrySet &geometry_set, return; } - PointCloud *existing_point_cloud = geometry_set.get_pointcloud_for_write(); - PointCloud *point_cloud = existing_point_cloud; + PointCloud *existing_pointcloud = geometry_set.get_pointcloud_for_write(); + PointCloud *pointcloud = existing_pointcloud; const P3fArraySamplePtr &positions = sample.getPositions(); @@ -147,11 +147,11 @@ void AbcPointsReader::read_geometry(bke::GeometrySet &geometry_set, radii = wsample.getVals(); } - if (point_cloud->totpoint != positions->size()) { - point_cloud = BKE_pointcloud_new_nomain(positions->size()); + if (pointcloud->totpoint != positions->size()) { + pointcloud = BKE_pointcloud_new_nomain(positions->size()); } - bke::MutableAttributeAccessor attribute_accessor = point_cloud->attributes_for_write(); + bke::MutableAttributeAccessor attribute_accessor = pointcloud->attributes_for_write(); bke::SpanAttributeWriter positions_writer = attribute_accessor.lookup_or_add_for_write_span("position", bke::AttrDomain::Point); @@ -186,7 +186,7 @@ void AbcPointsReader::read_geometry(bke::GeometrySet &geometry_set, if (velocity_name != nullptr && velocity_scale != 0.0f) { V3fArraySamplePtr velocities = get_velocity_prop(m_schema, sample_sel, velocity_name); - if (velocities && point_cloud->totpoint == int(velocities->size())) { + if (velocities && pointcloud->totpoint == int(velocities->size())) { bke::SpanAttributeWriter velocity_writer = attribute_accessor.lookup_or_add_for_write_span("velocity", bke::AttrDomain::Point); @@ -200,7 +200,7 @@ void AbcPointsReader::read_geometry(bke::GeometrySet &geometry_set, } } - geometry_set.replace_pointcloud(point_cloud); + geometry_set.replace_pointcloud(pointcloud); } } // namespace blender::io::alembic diff --git a/source/blender/io/csv/IO_csv.hh b/source/blender/io/csv/IO_csv.hh index bdbeabf44ac..918d67210ed 100644 --- a/source/blender/io/csv/IO_csv.hh +++ b/source/blender/io/csv/IO_csv.hh @@ -22,6 +22,6 @@ struct CSVImportParams { ReportList *reports = nullptr; }; -PointCloud *import_csv_as_point_cloud(const CSVImportParams &import_params); +PointCloud *import_csv_as_pointcloud(const CSVImportParams &import_params); } // namespace blender::io::csv diff --git a/source/blender/io/csv/importer/csv_reader.cc b/source/blender/io/csv/importer/csv_reader.cc index ebc95fc6340..ab60ccf841e 100644 --- a/source/blender/io/csv/importer/csv_reader.cc +++ b/source/blender/io/csv/importer/csv_reader.cc @@ -259,7 +259,7 @@ static Array>> flatten_valid_attribute_chunks( return flattened_attributes; } -PointCloud *import_csv_as_point_cloud(const CSVImportParams &import_params) +PointCloud *import_csv_as_pointcloud(const CSVImportParams &import_params) { size_t buffer_len; void *buffer = BLI_file_read_text_as_mem(import_params.filepath, 0, &buffer_len); diff --git a/source/blender/io/usd/intern/usd_reader_pointinstancer.cc b/source/blender/io/usd/intern/usd_reader_pointinstancer.cc index 11eea849f37..6d58d76214f 100644 --- a/source/blender/io/usd/intern/usd_reader_pointinstancer.cc +++ b/source/blender/io/usd/intern/usd_reader_pointinstancer.cc @@ -41,9 +41,9 @@ static bNode *add_input_named_attrib_node(bNodeTree *ntree, const char *name, in void USDPointInstancerReader::create_object(Main *bmain, const double /*motionSampleTime*/) { - PointCloud *point_cloud = BKE_pointcloud_add(bmain, name_.c_str()); + PointCloud *pointcloud = BKE_pointcloud_add(bmain, name_.c_str()); this->object_ = BKE_object_add_only_object(bmain, OB_POINTCLOUD, name_.c_str()); - this->object_->data = point_cloud; + this->object_->data = pointcloud; } void USDPointInstancerReader::read_geometry(bke::GeometrySet &geometry_set, @@ -61,16 +61,16 @@ void USDPointInstancerReader::read_geometry(bke::GeometrySet &geometry_set, point_instancer_prim_.GetOrientationsAttr().Get(&orientations, params.motion_sample_time); point_instancer_prim_.GetProtoIndicesAttr().Get(&proto_indices, params.motion_sample_time); - PointCloud *point_cloud = geometry_set.get_pointcloud_for_write(); - if (point_cloud->totpoint != positions.size()) { + PointCloud *pointcloud = geometry_set.get_pointcloud_for_write(); + if (pointcloud->totpoint != positions.size()) { /* Size changed so we must reallocate. */ - point_cloud = BKE_pointcloud_new_nomain(positions.size()); + pointcloud = BKE_pointcloud_new_nomain(positions.size()); } - MutableSpan point_positions = point_cloud->positions_for_write(); + MutableSpan point_positions = pointcloud->positions_for_write(); point_positions.copy_from(Span(positions.data(), positions.size()).cast()); - bke::MutableAttributeAccessor attributes = point_cloud->attributes_for_write(); + bke::MutableAttributeAccessor attributes = pointcloud->attributes_for_write(); bke::SpanAttributeWriter scales_attribute = attributes.lookup_or_add_for_write_only_span("scale", bke::AttrDomain::Point); @@ -130,26 +130,26 @@ void USDPointInstancerReader::read_geometry(bke::GeometrySet &geometry_set, mask_attribute.finish(); - geometry_set.replace_pointcloud(point_cloud); + geometry_set.replace_pointcloud(pointcloud); } void USDPointInstancerReader::read_object_data(Main *bmain, const double motionSampleTime) { - PointCloud *point_cloud = static_cast(object_->data); + PointCloud *pointcloud = static_cast(object_->data); bke::GeometrySet geometry_set = bke::GeometrySet::from_pointcloud( - point_cloud, bke::GeometryOwnershipType::Editable); + pointcloud, bke::GeometryOwnershipType::Editable); const USDMeshReadParams params = create_mesh_read_params(motionSampleTime, import_params_.mesh_read_flag); read_geometry(geometry_set, params, nullptr); - PointCloud *read_point_cloud = + PointCloud *read_pointcloud = geometry_set.get_component_for_write().release(); - if (read_point_cloud != point_cloud) { - BKE_pointcloud_nomain_to_pointcloud(read_point_cloud, point_cloud); + if (read_pointcloud != pointcloud) { + BKE_pointcloud_nomain_to_pointcloud(read_pointcloud, pointcloud); } if (is_animated()) { diff --git a/source/blender/io/usd/intern/usd_reader_points.cc b/source/blender/io/usd/intern/usd_reader_points.cc index 496f2bb5243..801f8bf81d1 100644 --- a/source/blender/io/usd/intern/usd_reader_points.cc +++ b/source/blender/io/usd/intern/usd_reader_points.cc @@ -21,9 +21,9 @@ namespace blender::io::usd { void USDPointsReader::create_object(Main *bmain, double /*motionSampleTime*/) { - PointCloud *point_cloud = BKE_pointcloud_add(bmain, name_.c_str()); + PointCloud *pointcloud = BKE_pointcloud_add(bmain, name_.c_str()); object_ = BKE_object_add_only_object(bmain, OB_POINTCLOUD, name_.c_str()); - object_->data = point_cloud; + object_->data = pointcloud; } void USDPointsReader::read_object_data(Main *bmain, double motionSampleTime) @@ -31,18 +31,18 @@ void USDPointsReader::read_object_data(Main *bmain, double motionSampleTime) const USDMeshReadParams params = create_mesh_read_params(motionSampleTime, import_params_.mesh_read_flag); - PointCloud *point_cloud = static_cast(object_->data); + PointCloud *pointcloud = static_cast(object_->data); bke::GeometrySet geometry_set = bke::GeometrySet::from_pointcloud( - point_cloud, bke::GeometryOwnershipType::Editable); + pointcloud, bke::GeometryOwnershipType::Editable); read_geometry(geometry_set, params, nullptr); - PointCloud *read_point_cloud = + PointCloud *read_pointcloud = geometry_set.get_component_for_write().release(); - if (read_point_cloud != point_cloud) { - BKE_pointcloud_nomain_to_pointcloud(read_point_cloud, point_cloud); + if (read_pointcloud != pointcloud) { + BKE_pointcloud_nomain_to_pointcloud(read_pointcloud, pointcloud); } if (is_animated()) { @@ -59,27 +59,27 @@ void USDPointsReader::read_geometry(bke::GeometrySet &geometry_set, USDMeshReadParams params, const char ** /*r_err_str*/) { - PointCloud *point_cloud = geometry_set.get_pointcloud_for_write(); + PointCloud *pointcloud = geometry_set.get_pointcloud_for_write(); /* Get the existing point cloud data. */ pxr::VtVec3fArray usd_positions; points_prim_.GetPointsAttr().Get(&usd_positions, params.motion_sample_time); - if (point_cloud->totpoint != usd_positions.size()) { + if (pointcloud->totpoint != usd_positions.size()) { /* Size changed so we must reallocate. */ - point_cloud = BKE_pointcloud_new_nomain(usd_positions.size()); + pointcloud = BKE_pointcloud_new_nomain(usd_positions.size()); } /* Update point positions and radii */ static_assert(sizeof(pxr::GfVec3f) == sizeof(float3)); - MutableSpan positions = point_cloud->positions_for_write(); + MutableSpan positions = pointcloud->positions_for_write(); positions.copy_from(Span(usd_positions.data(), usd_positions.size()).cast()); pxr::VtFloatArray usd_widths; points_prim_.GetWidthsAttr().Get(&usd_widths, params.motion_sample_time); if (!usd_widths.empty()) { - bke::MutableAttributeAccessor attributes = point_cloud->attributes_for_write(); + bke::MutableAttributeAccessor attributes = pointcloud->attributes_for_write(); bke::SpanAttributeWriter radii = attributes.lookup_or_add_for_write_only_span( "radius", bke::AttrDomain::Point); @@ -100,19 +100,19 @@ void USDPointsReader::read_geometry(bke::GeometrySet &geometry_set, * See UsdGeomPoints::GetIdsAttr and UsdGeomPointBased::GetNormalsAttr */ /* Read in velocity and generic data. */ - read_velocities(point_cloud, params.motion_sample_time); - read_custom_data(point_cloud, params.motion_sample_time); + read_velocities(pointcloud, params.motion_sample_time); + read_custom_data(pointcloud, params.motion_sample_time); - geometry_set.replace_pointcloud(point_cloud); + geometry_set.replace_pointcloud(pointcloud); } -void USDPointsReader::read_velocities(PointCloud *point_cloud, const double motionSampleTime) const +void USDPointsReader::read_velocities(PointCloud *pointcloud, const double motionSampleTime) const { pxr::VtVec3fArray velocities; points_prim_.GetVelocitiesAttr().Get(&velocities, motionSampleTime); if (!velocities.empty()) { - bke::MutableAttributeAccessor attributes = point_cloud->attributes_for_write(); + bke::MutableAttributeAccessor attributes = pointcloud->attributes_for_write(); bke::SpanAttributeWriter velocity = attributes.lookup_or_add_for_write_only_span("velocity", bke::AttrDomain::Point); @@ -122,8 +122,7 @@ void USDPointsReader::read_velocities(PointCloud *point_cloud, const double moti } } -void USDPointsReader::read_custom_data(PointCloud *point_cloud, - const double motionSampleTime) const +void USDPointsReader::read_custom_data(PointCloud *pointcloud, const double motionSampleTime) const { pxr::UsdGeomPrimvarsAPI pv_api(points_prim_); @@ -140,7 +139,7 @@ void USDPointsReader::read_custom_data(PointCloud *point_cloud, return; } - bke::MutableAttributeAccessor attributes = point_cloud->attributes_for_write(); + bke::MutableAttributeAccessor attributes = pointcloud->attributes_for_write(); copy_primvar_to_blender_attribute(pv, motionSampleTime, *type, domain, {}, attributes); } } diff --git a/source/blender/io/usd/intern/usd_reader_points.hh b/source/blender/io/usd/intern/usd_reader_points.hh index 8e7a8412e59..5b24ca3436b 100644 --- a/source/blender/io/usd/intern/usd_reader_points.hh +++ b/source/blender/io/usd/intern/usd_reader_points.hh @@ -45,8 +45,8 @@ class USDPointsReader : public USDGeomReader { USDMeshReadParams params, const char **r_err_str) override; - void read_velocities(PointCloud *point_cloud, const double motionSampleTime) const; - void read_custom_data(PointCloud *point_cloud, const double motionSampleTime) const; + void read_velocities(PointCloud *pointcloud, const double motionSampleTime) const; + void read_custom_data(PointCloud *pointcloud, const double motionSampleTime) const; /* Return true if the USD data may be time varying. */ bool is_animated() const; diff --git a/source/blender/makesdna/DNA_node_types.h b/source/blender/makesdna/DNA_node_types.h index 5ff8266dc60..7d15ca26ddb 100644 --- a/source/blender/makesdna/DNA_node_types.h +++ b/source/blender/makesdna/DNA_node_types.h @@ -1028,7 +1028,7 @@ typedef enum GeometryNodeAssetTraitFlag { GEO_NODE_ASSET_SCULPT = (1 << 2), GEO_NODE_ASSET_MESH = (1 << 3), GEO_NODE_ASSET_CURVE = (1 << 4), - GEO_NODE_ASSET_POINT_CLOUD = (1 << 5), + GEO_NODE_ASSET_POINTCLOUD = (1 << 5), GEO_NODE_ASSET_MODIFIER = (1 << 6), GEO_NODE_ASSET_OBJECT = (1 << 7), GEO_NODE_ASSET_WAIT_FOR_CURSOR = (1 << 8), diff --git a/source/blender/makesrna/intern/CMakeLists.txt b/source/blender/makesrna/intern/CMakeLists.txt index 4e6e70c31e6..529a39f06b8 100644 --- a/source/blender/makesrna/intern/CMakeLists.txt +++ b/source/blender/makesrna/intern/CMakeLists.txt @@ -497,7 +497,7 @@ set(LIB bf_editor_mesh bf_editor_object bf_editor_physics - bf_editor_point_cloud + bf_editor_pointcloud bf_editor_render bf_editor_scene bf_editor_sculpt_paint diff --git a/source/blender/makesrna/intern/rna_attribute.cc b/source/blender/makesrna/intern/rna_attribute.cc index 873a8e4ce82..931743fa6a5 100644 --- a/source/blender/makesrna/intern/rna_attribute.cc +++ b/source/blender/makesrna/intern/rna_attribute.cc @@ -1670,7 +1670,7 @@ static void rna_def_attribute_group_mesh(BlenderRNA *brna) "The name of the active color attribute for display and editing"); } -static void rna_def_attribute_group_point_cloud(BlenderRNA *brna) +static void rna_def_attribute_group_pointcloud(BlenderRNA *brna) { StructRNA *srna; @@ -1852,7 +1852,7 @@ void RNA_def_attribute(BlenderRNA *brna) { rna_def_attribute(brna); rna_def_attribute_group_mesh(brna); - rna_def_attribute_group_point_cloud(brna); + rna_def_attribute_group_pointcloud(brna); rna_def_attribute_group_curves(brna); rna_def_attribute_group_grease_pencil(brna); rna_def_attribute_group_grease_pencil_drawing(brna); diff --git a/source/blender/makesrna/intern/rna_context.cc b/source/blender/makesrna/intern/rna_context.cc index 55441b6b28d..3a1f2a3b935 100644 --- a/source/blender/makesrna/intern/rna_context.cc +++ b/source/blender/makesrna/intern/rna_context.cc @@ -26,7 +26,7 @@ const EnumPropertyItem rna_enum_context_mode_items[] = { {CTX_MODE_EDIT_METABALL, "EDIT_METABALL", 0, "Metaball Edit", ""}, {CTX_MODE_EDIT_LATTICE, "EDIT_LATTICE", 0, "Lattice Edit", ""}, {CTX_MODE_EDIT_GREASE_PENCIL, "EDIT_GREASE_PENCIL", 0, "Grease Pencil Edit", ""}, - {CTX_MODE_EDIT_POINT_CLOUD, "EDIT_POINT_CLOUD", 0, "Point Cloud Edit", ""}, + {CTX_MODE_EDIT_POINTCLOUD, "EDIT_POINTCLOUD", 0, "Point Cloud Edit", ""}, {CTX_MODE_POSE, "POSE", 0, "Pose", ""}, {CTX_MODE_SCULPT, "SCULPT", 0, "Sculpt", ""}, {CTX_MODE_PAINT_WEIGHT, "PAINT_WEIGHT", 0, "Weight Paint", ""}, diff --git a/source/blender/makesrna/intern/rna_nodetree.cc b/source/blender/makesrna/intern/rna_nodetree.cc index 7182d33c7e3..1a7fbc27252 100644 --- a/source/blender/makesrna/intern/rna_nodetree.cc +++ b/source/blender/makesrna/intern/rna_nodetree.cc @@ -2193,13 +2193,13 @@ static void rna_GeometryNodeTree_is_type_curve_set(PointerRNA *ptr, bool value) geometry_node_asset_trait_flag_set(ptr, GEO_NODE_ASSET_CURVE, value); } -static bool rna_GeometryNodeTree_is_type_point_cloud_get(PointerRNA *ptr) +static bool rna_GeometryNodeTree_is_type_pointcloud_get(PointerRNA *ptr) { - return geometry_node_asset_trait_flag_get(ptr, GEO_NODE_ASSET_POINT_CLOUD); + return geometry_node_asset_trait_flag_get(ptr, GEO_NODE_ASSET_POINTCLOUD); } -static void rna_GeometryNodeTree_is_type_point_cloud_set(PointerRNA *ptr, bool value) +static void rna_GeometryNodeTree_is_type_pointcloud_set(PointerRNA *ptr, bool value) { - geometry_node_asset_trait_flag_set(ptr, GEO_NODE_ASSET_POINT_CLOUD, value); + geometry_node_asset_trait_flag_set(ptr, GEO_NODE_ASSET_POINTCLOUD, value); } static bool rna_GeometryNodeTree_use_wait_for_click_get(PointerRNA *ptr) @@ -12036,17 +12036,17 @@ static void rna_def_geometry_nodetree(BlenderRNA *brna) prop, "rna_GeometryNodeTree_is_type_curve_get", "rna_GeometryNodeTree_is_type_curve_set"); RNA_def_property_update(prop, NC_NODE | ND_DISPLAY, "rna_NodeTree_update_asset"); - prop = RNA_def_property(srna, "is_type_point_cloud", PROP_BOOLEAN, PROP_NONE); - RNA_def_property_boolean_sdna(prop, nullptr, "flag", GEO_NODE_ASSET_POINT_CLOUD); + prop = RNA_def_property(srna, "is_type_pointcloud", PROP_BOOLEAN, PROP_NONE); + RNA_def_property_boolean_sdna(prop, nullptr, "flag", GEO_NODE_ASSET_POINTCLOUD); RNA_def_property_clear_flag(prop, PROP_ANIMATABLE); RNA_def_property_ui_text(prop, "Point Cloud", "The node group is used for point clouds"); RNA_def_property_boolean_funcs(prop, - "rna_GeometryNodeTree_is_type_point_cloud_get", - "rna_GeometryNodeTree_is_type_point_cloud_set"); + "rna_GeometryNodeTree_is_type_pointcloud_get", + "rna_GeometryNodeTree_is_type_pointcloud_set"); RNA_def_property_update(prop, NC_NODE | ND_DISPLAY, "rna_NodeTree_update_asset"); prop = RNA_def_property(srna, "use_wait_for_click", PROP_BOOLEAN, PROP_NONE); - RNA_def_property_boolean_sdna(prop, nullptr, "flag", GEO_NODE_ASSET_POINT_CLOUD); + RNA_def_property_boolean_sdna(prop, nullptr, "flag", GEO_NODE_ASSET_POINTCLOUD); RNA_def_property_clear_flag(prop, PROP_ANIMATABLE); RNA_def_property_ui_text(prop, "Wait for Click", diff --git a/source/blender/nodes/geometry/nodes/node_geo_import_csv.cc b/source/blender/nodes/geometry/nodes/node_geo_import_csv.cc index 70473045db2..8a9f127655f 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_import_csv.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_import_csv.cc @@ -41,7 +41,7 @@ static void node_geo_exec(GeoNodeExecParams params) BLI_SCOPED_DEFER([&]() { BKE_reports_free(&reports); }) import_params.reports = &reports; - PointCloud *point_cloud = blender::io::csv::import_csv_as_point_cloud(import_params); + PointCloud *pointcloud = blender::io::csv::import_csv_as_pointcloud(import_params); LISTBASE_FOREACH (Report *, report, &(import_params.reports)->list) { NodeWarningType type; @@ -56,7 +56,7 @@ static void node_geo_exec(GeoNodeExecParams params) params.error_message_add(type, TIP_(report->message)); } - params.set_output("Point Cloud", GeometrySet::from_pointcloud(point_cloud)); + params.set_output("Point Cloud", GeometrySet::from_pointcloud(pointcloud)); #else params.error_message_add(NodeWarningType::Error, TIP_("Disabled, Blender was compiled without CSV I/O")); diff --git a/source/blender/nodes/geometry/nodes/node_geo_separate_components.cc b/source/blender/nodes/geometry/nodes/node_geo_separate_components.cc index 7a16e2d7e58..456f8473301 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_separate_components.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_separate_components.cc @@ -26,7 +26,7 @@ static void node_geo_exec(GeoNodeExecParams params) GeometrySet meshes; GeometrySet curves; GeometrySet grease_pencil; - GeometrySet point_clouds; + GeometrySet pointclouds; GeometrySet volumes; GeometrySet instances; @@ -34,7 +34,7 @@ static void node_geo_exec(GeoNodeExecParams params) meshes.name = name; curves.name = name; grease_pencil.name = name; - point_clouds.name = name; + pointclouds.name = name; volumes.name = name; instances.name = name; @@ -48,7 +48,7 @@ static void node_geo_exec(GeoNodeExecParams params) grease_pencil.add(*geometry_set.get_component()); } if (geometry_set.has()) { - point_clouds.add(*geometry_set.get_component()); + pointclouds.add(*geometry_set.get_component()); } if (geometry_set.has()) { volumes.add(*geometry_set.get_component()); @@ -60,7 +60,7 @@ static void node_geo_exec(GeoNodeExecParams params) params.set_output("Mesh", meshes); params.set_output("Curve", curves); params.set_output("Grease Pencil", grease_pencil); - params.set_output("Point Cloud", point_clouds); + params.set_output("Point Cloud", pointclouds); params.set_output("Volume", volumes); params.set_output("Instances", instances); } diff --git a/source/blender/nodes/geometry/nodes/node_geo_set_position.cc b/source/blender/nodes/geometry/nodes/node_geo_set_position.cc index 2a8fab432ca..89aca22bf6a 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_set_position.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_set_position.cc @@ -138,9 +138,9 @@ static void node_geo_exec(GeoNodeExecParams params) selection_field, position_field); } - if (PointCloud *point_cloud = geometry.get_pointcloud_for_write()) { - set_points_position(point_cloud->attributes_for_write(), - bke::PointCloudFieldContext(*point_cloud), + if (PointCloud *pointcloud = geometry.get_pointcloud_for_write()) { + set_points_position(pointcloud->attributes_for_write(), + bke::PointCloudFieldContext(*pointcloud), selection_field, position_field); } diff --git a/source/blender/windowmanager/WM_types.hh b/source/blender/windowmanager/WM_types.hh index c4a28c61cfc..628217c924b 100644 --- a/source/blender/windowmanager/WM_types.hh +++ b/source/blender/windowmanager/WM_types.hh @@ -557,7 +557,7 @@ struct wmNotifier { #define NS_MODE_PARTICLE (10 << 8) #define NS_EDITMODE_CURVES (11 << 8) #define NS_EDITMODE_GREASE_PENCIL (12 << 8) -#define NS_EDITMODE_POINT_CLOUD (13 << 8) +#define NS_EDITMODE_POINTCLOUD (13 << 8) /* Subtype 3d view editing. */ #define NS_VIEW3D_GPU (16 << 8) diff --git a/source/blender/windowmanager/intern/wm_keymap_utils.cc b/source/blender/windowmanager/intern/wm_keymap_utils.cc index 6ffecb3e3cd..862ef26b5d0 100644 --- a/source/blender/windowmanager/intern/wm_keymap_utils.cc +++ b/source/blender/windowmanager/intern/wm_keymap_utils.cc @@ -121,7 +121,7 @@ wmKeyMap *WM_keymap_guess_from_context(const bContext *C) case CTX_MODE_EDIT_GREASE_PENCIL: km_id = "Grease Pencil Edit Mode"; break; - case CTX_MODE_EDIT_POINT_CLOUD: + case CTX_MODE_EDIT_POINTCLOUD: km_id = "Point Cloud"; break; case CTX_MODE_POSE: @@ -341,7 +341,7 @@ wmKeyMap *WM_keymap_guess_opname(const bContext *C, const char *opname) else if (STRPREFIX(opname, "PARTICLE_OT")) { km = WM_keymap_find_all(wm, "Particle", SPACE_EMPTY, RGN_TYPE_WINDOW); } - else if (STRPREFIX(opname, "POINT_CLOUD_OT")) { + else if (STRPREFIX(opname, "POINTCLOUD_OT")) { km = WM_keymap_find_all(wm, "Point Cloud", SPACE_EMPTY, RGN_TYPE_WINDOW); } else if (STRPREFIX(opname, "FONT_OT")) { @@ -501,7 +501,7 @@ wmKeyMap *WM_keymap_guess_opname(const bContext *C, const char *opname) case CTX_MODE_EDIT_CURVES: km = WM_keymap_find_all(wm, "Curves", SPACE_EMPTY, RGN_TYPE_WINDOW); break; - case CTX_MODE_EDIT_POINT_CLOUD: + case CTX_MODE_EDIT_POINTCLOUD: km = WM_keymap_find_all(wm, "Point Cloud", SPACE_EMPTY, RGN_TYPE_WINDOW); break; case CTX_MODE_SCULPT: From 9d06f327613f3122cf7616eb73fbf8650b2d5ec0 Mon Sep 17 00:00:00 2001 From: Dalai Felinto Date: Wed, 19 Feb 2025 17:23:37 +0100 Subject: [PATCH 21/31] Point Cloud: Select Random Move the mask_random function to BLI_index_mask.hh, so it can be shared between curves, grease pencil and point cloud. Copied/inspired by the curves select code. Pull Request: https://projects.blender.org/blender/blender/pulls/134624 --- scripts/startup/bl_ui/space_view3d.py | 4 ++ source/blender/blenlib/BLI_index_mask.hh | 20 ++++++ source/blender/blenlib/intern/index_mask.cc | 26 +++++++ .../editors/curves/intern/curves_masks.cc | 30 -------- .../editors/curves/intern/curves_ops.cc | 3 +- .../intern/grease_pencil_select.cc | 12 ++-- source/blender/editors/include/ED_curves.hh | 20 ------ .../blender/editors/include/ED_pointcloud.hh | 1 + .../editors/pointcloud/intern/operators.cc | 69 +++++++++++++++++++ .../editors/pointcloud/intern/selection.cc | 5 ++ 10 files changed, 132 insertions(+), 58 deletions(-) diff --git a/scripts/startup/bl_ui/space_view3d.py b/scripts/startup/bl_ui/space_view3d.py index 5b136a43353..54de1753fb9 100644 --- a/scripts/startup/bl_ui/space_view3d.py +++ b/scripts/startup/bl_ui/space_view3d.py @@ -2325,6 +2325,10 @@ def draw(self, _context): layout.operator("pointcloud.select_all", text="None").action = 'DESELECT' layout.operator("pointcloud.select_all", text="Invert").action = 'INVERT' + layout.separator() + + layout.operator("pointcloud.select_random") + layout.template_node_operator_asset_menu_items(catalog_path=self.bl_label) diff --git a/source/blender/blenlib/BLI_index_mask.hh b/source/blender/blenlib/BLI_index_mask.hh index f2111a7ba09..6c3ee40fc77 100644 --- a/source/blender/blenlib/BLI_index_mask.hh +++ b/source/blender/blenlib/BLI_index_mask.hh @@ -1112,6 +1112,26 @@ inline void index_range_to_mask_segments(const IndexRange range, } } +/** + * Return a mask of random points or curves. + * + * \param mask: (optional) The elements that should be used in the resulting mask. + * \param universe_size: The size of the mask. + * \param random_seed: The seed for the \a RandomNumberGenerator. + * \param probability: Determines how likely a point/curve will be chosen. + * If set to 0.0, nothing will be in the mask, if set to 1.0 everything will be in the mask. + */ +IndexMask random_mask(const IndexMask &mask, + const int64_t universe_size, + const uint32_t random_seed, + const float probability, + IndexMaskMemory &memory); + +IndexMask random_mask(const int64_t universe_size, + const uint32_t random_seed, + const float probability, + IndexMaskMemory &memory); + } // namespace blender::index_mask namespace blender { diff --git a/source/blender/blenlib/intern/index_mask.cc b/source/blender/blenlib/intern/index_mask.cc index 6bc4b97cbbd..21ce39e8350 100644 --- a/source/blender/blenlib/intern/index_mask.cc +++ b/source/blender/blenlib/intern/index_mask.cc @@ -16,6 +16,7 @@ #include "BLI_index_mask_expression.hh" #include "BLI_index_ranges_builder.hh" #include "BLI_math_base.hh" +#include "BLI_rand.hh" #include "BLI_set.hh" #include "BLI_sort.hh" #include "BLI_task.hh" @@ -1227,4 +1228,29 @@ template IndexMask IndexMask::from_ranges(OffsetIndices, const IndexMask &, IndexMaskMemory &); +IndexMask random_mask(const IndexMask &mask, + const int64_t universe_size, + const uint32_t random_seed, + const float probability, + IndexMaskMemory &memory) +{ + RandomNumberGenerator rng{random_seed}; + const auto next_bool_random_value = [&]() { return rng.get_float() <= probability; }; + + Array random(universe_size, false); + mask.foreach_index_optimized( + [&](const int64_t i) { random[i] = next_bool_random_value(); }); + + return IndexMask::from_bools(IndexRange(universe_size), random, memory); +} + +IndexMask random_mask(const int64_t universe_size, + const uint32_t random_seed, + const float probability, + IndexMaskMemory &memory) +{ + const IndexRange selection(universe_size); + return random_mask(selection, universe_size, random_seed, probability, memory); +} + } // namespace blender::index_mask diff --git a/source/blender/editors/curves/intern/curves_masks.cc b/source/blender/editors/curves/intern/curves_masks.cc index a9222ba1166..e0ac255f533 100644 --- a/source/blender/editors/curves/intern/curves_masks.cc +++ b/source/blender/editors/curves/intern/curves_masks.cc @@ -7,7 +7,6 @@ */ #include "BLI_offset_indices.hh" -#include "BLI_rand.hh" #include "BKE_attribute.hh" #include "BKE_curves.hh" @@ -65,33 +64,4 @@ IndexMask end_points(const bke::CurvesGeometry &curves, return end_points(curves, curves.curves_range(), amount_start, amount_end, inverted, memory); } -IndexMask random_mask(const bke::CurvesGeometry &curves, - const IndexMask &mask, - const bke::AttrDomain selection_domain, - const uint32_t random_seed, - const float probability, - IndexMaskMemory &memory) -{ - RandomNumberGenerator rng{random_seed}; - const auto next_bool_random_value = [&]() { return rng.get_float() <= probability; }; - - const int64_t domain_size = curves.attributes().domain_size(selection_domain); - - Array random(domain_size, false); - mask.foreach_index_optimized( - [&](const int64_t i) { random[i] = next_bool_random_value(); }); - - return IndexMask::from_bools(IndexRange(domain_size), random, memory); -} - -IndexMask random_mask(const bke::CurvesGeometry &curves, - const bke::AttrDomain selection_domain, - const uint32_t random_seed, - const float probability, - IndexMaskMemory &memory) -{ - const IndexRange selection(curves.attributes().domain_size(selection_domain)); - return random_mask(curves, selection, selection_domain, random_seed, probability, memory); -} - } // namespace blender::ed::curves diff --git a/source/blender/editors/curves/intern/curves_ops.cc b/source/blender/editors/curves/intern/curves_ops.cc index 7d4a5f8c9ff..18ec15c5e68 100644 --- a/source/blender/editors/curves/intern/curves_ops.cc +++ b/source/blender/editors/curves/intern/curves_ops.cc @@ -914,8 +914,7 @@ static int select_random_exec(bContext *C, wmOperator *op) const int domain_size = curves.attributes().domain_size(selection_domain); IndexMaskMemory memory; - const IndexMask inv_random_elements = random_mask( - curves, selection_domain, seed, probability, memory) + const IndexMask inv_random_elements = random_mask(domain_size, seed, probability, memory) .complement(IndexRange(domain_size), memory); const bool was_anything_selected = has_anything_selected(curves); diff --git a/source/blender/editors/grease_pencil/intern/grease_pencil_select.cc b/source/blender/editors/grease_pencil/intern/grease_pencil_select.cc index ff138ae9922..110112a26ce 100644 --- a/source/blender/editors/grease_pencil/intern/grease_pencil_select.cc +++ b/source/blender/editors/grease_pencil/intern/grease_pencil_select.cc @@ -13,6 +13,7 @@ #include "BKE_object.hh" #include "BLI_enumerable_thread_specific.hh" +#include "BLI_index_mask.hh" #include "BLI_offset_indices.hh" #include "BLI_task.hh" @@ -501,12 +502,11 @@ static int select_random_exec(bContext *C, wmOperator *op) if (selectable_elements.is_empty()) { return {}; } - return ed::curves::random_mask(info.drawing.strokes(), - selectable_elements, - selection_domain, - blender::get_default_hash(seed, info.layer_index), - ratio, - memory); + return random_mask(selectable_elements, + info.drawing.strokes().points_num(), + blender::get_default_hash(seed, info.layer_index), + ratio, + memory); }); /* Use #ID_RECALC_GEOMETRY instead of #ID_RECALC_SELECT because it is handled as a generic diff --git a/source/blender/editors/include/ED_curves.hh b/source/blender/editors/include/ED_curves.hh index 13afe48d9a8..1979f44f57c 100644 --- a/source/blender/editors/include/ED_curves.hh +++ b/source/blender/editors/include/ED_curves.hh @@ -176,26 +176,6 @@ IndexMask end_points(const bke::CurvesGeometry &curves, bool inverted, IndexMaskMemory &memory); -/** - * Return a mask of random points or curves. - * - * \param mask: (optional) The elements that should be used in the resulting mask. This mask should - * be in the same domain as the \a selection_domain. \param random_seed: The seed for the \a - * RandomNumberGenerator. \param probability: Determines how likely a point/curve will be chosen. - * If set to 0.0, nothing will be in the mask, if set to 1.0 everything will be in the mask. - */ -IndexMask random_mask(const bke::CurvesGeometry &curves, - bke::AttrDomain selection_domain, - uint32_t random_seed, - float probability, - IndexMaskMemory &memory); -IndexMask random_mask(const bke::CurvesGeometry &curves, - const IndexMask &mask, - bke::AttrDomain selection_domain, - uint32_t random_seed, - float probability, - IndexMaskMemory &memory); - /** \} */ /* -------------------------------------------------------------------- */ diff --git a/source/blender/editors/include/ED_pointcloud.hh b/source/blender/editors/include/ED_pointcloud.hh index 9e5c58cbecb..17294c0b6da 100644 --- a/source/blender/editors/include/ED_pointcloud.hh +++ b/source/blender/editors/include/ED_pointcloud.hh @@ -56,6 +56,7 @@ VectorSet get_unique_editable_pointclouds(const bContext &C); * helpful utilities on top of that. * \{ */ +void fill_selection_true(GMutableSpan span); void fill_selection_false(GMutableSpan selection, const IndexMask &mask); void fill_selection_true(GMutableSpan selection, const IndexMask &mask); diff --git a/source/blender/editors/pointcloud/intern/operators.cc b/source/blender/editors/pointcloud/intern/operators.cc index 968b6140d44..1fcea6b725f 100644 --- a/source/blender/editors/pointcloud/intern/operators.cc +++ b/source/blender/editors/pointcloud/intern/operators.cc @@ -139,6 +139,74 @@ static void POINTCLOUD_OT_select_all(wmOperatorType *ot) WM_operator_properties_select_all(ot); } +static int select_random_exec(bContext *C, wmOperator *op) +{ + const int seed = RNA_int_get(op->ptr, "seed"); + const float probability = RNA_float_get(op->ptr, "probability"); + + for (PointCloud *pointcloud : get_unique_editable_pointclouds(*C)) { + IndexMaskMemory memory; + const IndexMask inv_random_elements = random_mask( + pointcloud->totpoint, seed, probability, memory) + .complement(IndexRange(pointcloud->totpoint), + memory); + const bool was_anything_selected = has_anything_selected(*pointcloud); + bke::GSpanAttributeWriter selection = ensure_selection_attribute(*pointcloud, CD_PROP_BOOL); + if (!was_anything_selected) { + pointcloud::fill_selection_true(selection.span); + } + + pointcloud::fill_selection_false(selection.span, inv_random_elements); + selection.finish(); + + /* Use #ID_RECALC_GEOMETRY instead of #ID_RECALC_SELECT because it is handled as a generic + * attribute for now. */ + DEG_id_tag_update(&pointcloud->id, ID_RECALC_GEOMETRY); + WM_event_add_notifier(C, NC_GEOM | ND_DATA, pointcloud); + } + return OPERATOR_FINISHED; +} + +static void select_random_ui(bContext * /*C*/, wmOperator *op) +{ + uiLayout *layout = op->layout; + + uiItemR(layout, op->ptr, "seed", UI_ITEM_NONE, std::nullopt, ICON_NONE); + uiItemR(layout, op->ptr, "probability", UI_ITEM_R_SLIDER, std::nullopt, ICON_NONE); +} + +static void POINTCLOUD_OT_select_random(wmOperatorType *ot) +{ + ot->name = "Select Random"; + ot->idname = __func__; + ot->description = "Randomizes existing selection or create new random selection"; + + ot->exec = select_random_exec; + ot->poll = editable_pointcloud_poll; + ot->ui = select_random_ui; + + ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO; + + RNA_def_int(ot->srna, + "seed", + 0, + INT32_MIN, + INT32_MAX, + "Seed", + "Source of randomness", + INT32_MIN, + INT32_MAX); + RNA_def_float(ot->srna, + "probability", + 0.5f, + 0.0f, + 1.0f, + "Probability", + "Chance of every point being included in the selection", + 0.0f, + 1.0f); +} + namespace pointcloud_delete { static int delete_exec(bContext *C, wmOperator * /*op*/) @@ -173,6 +241,7 @@ void operatortypes_pointcloud() WM_operatortype_append(POINTCLOUD_OT_delete); WM_operatortype_append(POINTCLOUD_OT_duplicate); WM_operatortype_append(POINTCLOUD_OT_select_all); + WM_operatortype_append(POINTCLOUD_OT_select_random); WM_operatortype_append(POINTCLOUD_OT_separate); } diff --git a/source/blender/editors/pointcloud/intern/selection.cc b/source/blender/editors/pointcloud/intern/selection.cc index 96d7c39cbed..0a0742d620e 100644 --- a/source/blender/editors/pointcloud/intern/selection.cc +++ b/source/blender/editors/pointcloud/intern/selection.cc @@ -133,6 +133,11 @@ void fill_selection_false(GMutableSpan selection, const IndexMask &mask) } } +void fill_selection_true(GMutableSpan selection) +{ + fill_selection_true(selection, IndexMask(selection.size())); +} + void fill_selection_true(GMutableSpan selection, const IndexMask &mask) { if (selection.type().is()) { From f8195e0bb439ab6d59de00045a50973b5c5907b6 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Cl=C3=A9ment=20Foucault?= Date: Wed, 19 Feb 2025 17:46:04 +0100 Subject: [PATCH 22/31] Fix: Overlay: Broken shader compilation Caused by the changes in UBO members. This removes the duplicated lib used by overlay and reuse the same side clip plane UBO mechanism as workbench. --- source/blender/draw/CMakeLists.txt | 1 - .../overlay/overlay_next_antialiasing.hh | 1 + .../engines/overlay/overlay_next_armature.hh | 1 + .../overlay/overlay_next_attribute_viewer.hh | 1 + .../draw/engines/overlay/overlay_next_axes.hh | 1 + .../overlay/overlay_next_background.hh | 1 + .../engines/overlay/overlay_next_bounds.hh | 1 + .../engines/overlay/overlay_next_camera.hh | 2 + .../engines/overlay/overlay_next_curve.hh | 3 ++ .../engines/overlay/overlay_next_edit_text.hh | 1 + .../engines/overlay/overlay_next_empty.hh | 3 ++ .../engines/overlay/overlay_next_facing.hh | 1 + .../engines/overlay/overlay_next_fluid.hh | 1 + .../overlay/overlay_next_force_field.hh | 1 + .../overlay/overlay_next_grease_pencil.hh | 2 + .../draw/engines/overlay/overlay_next_grid.hh | 1 + .../engines/overlay/overlay_next_instance.cc | 21 ++++++++ .../engines/overlay/overlay_next_lattice.hh | 1 + .../engines/overlay/overlay_next_light.hh | 1 + .../overlay/overlay_next_lightprobe.hh | 2 + .../draw/engines/overlay/overlay_next_mesh.hh | 11 +++++ .../engines/overlay/overlay_next_metaball.hh | 1 + .../overlay/overlay_next_mode_transfer.hh | 1 + .../overlay/overlay_next_motion_path.hh | 1 + .../engines/overlay/overlay_next_origin.hh | 1 + .../engines/overlay/overlay_next_outline.hh | 3 ++ .../engines/overlay/overlay_next_paint.hh | 3 ++ .../engines/overlay/overlay_next_particle.hh | 2 + .../engines/overlay/overlay_next_prepass.hh | 1 + .../engines/overlay/overlay_next_private.hh | 2 + .../engines/overlay/overlay_next_relation.hh | 1 + .../engines/overlay/overlay_next_sculpt.hh | 2 + .../engines/overlay/overlay_next_speaker.hh | 1 + .../engines/overlay/overlay_next_wireframe.hh | 1 + .../shaders/infos/overlay_common_info.hh | 7 +-- .../shaders/overlay_armature_dof_vert.glsl | 2 +- ...verlay_armature_envelope_outline_vert.glsl | 2 +- .../overlay_armature_envelope_solid_vert.glsl | 2 +- .../overlay_armature_shape_outline_vert.glsl | 2 +- .../overlay_armature_shape_solid_vert.glsl | 2 +- .../overlay_armature_shape_wire_vert.glsl | 2 +- .../overlay_armature_sphere_outline_vert.glsl | 2 +- .../overlay_armature_sphere_solid_vert.glsl | 2 +- .../shaders/overlay_armature_stick_vert.glsl | 2 +- .../shaders/overlay_armature_wire_vert.glsl | 2 +- .../overlay_depth_only_curves_vert.glsl | 2 +- .../overlay_depth_only_gpencil_vert.glsl | 2 +- ...lay_depth_only_mesh_conservative_vert.glsl | 2 +- .../overlay_depth_only_pointcloud_vert.glsl | 2 +- .../shaders/overlay_depth_only_vert.glsl | 2 +- .../overlay_edit_curve_handle_vert.glsl | 2 +- .../overlay_edit_curve_point_vert.glsl | 2 +- .../overlay_edit_curve_wire_next_vert.glsl | 2 +- .../shaders/overlay_edit_curve_wire_vert.glsl | 2 +- .../overlay_edit_curves_handle_vert.glsl | 2 +- .../overlay_edit_gpencil_canvas_vert.glsl | 2 +- .../shaders/overlay_edit_gpencil_vert.glsl | 2 +- .../overlay_edit_lattice_point_vert.glsl | 2 +- .../overlay_edit_lattice_wire_vert.glsl | 2 +- .../overlay_edit_mesh_analysis_vert.glsl | 2 +- .../shaders/overlay_edit_mesh_depth_vert.glsl | 2 +- .../shaders/overlay_edit_mesh_edge_vert.glsl | 2 +- .../shaders/overlay_edit_mesh_lib.glsl | 2 +- .../overlay_edit_mesh_normal_vert.glsl | 2 +- .../overlay_edit_mesh_skin_root_vert.glsl | 2 +- .../shaders/overlay_edit_mesh_vert.glsl | 2 +- .../overlay_edit_particle_point_vert.glsl | 2 +- .../overlay_edit_particle_strand_vert.glsl | 2 +- .../overlay_extra_groundline_vert.glsl | 2 +- .../overlay_extra_lightprobe_grid_vert.glsl | 2 +- .../overlay_extra_loose_point_vert.glsl | 2 +- .../shaders/overlay_extra_point_vert.glsl | 2 +- .../overlay/shaders/overlay_extra_vert.glsl | 2 +- .../shaders/overlay_extra_wire_vert.glsl | 2 +- .../overlay/shaders/overlay_facing_vert.glsl | 2 +- .../overlay/shaders/overlay_image_vert.glsl | 2 +- .../overlay_motion_path_line_vert.glsl | 2 +- .../overlay_motion_path_point_vert.glsl | 2 +- .../overlay_outline_prepass_curves_vert.glsl | 2 +- .../overlay_outline_prepass_gpencil_vert.glsl | 2 +- ...erlay_outline_prepass_pointcloud_vert.glsl | 2 +- .../shaders/overlay_outline_prepass_vert.glsl | 2 +- .../overlay_outline_prepass_wire_vert.glsl | 2 +- .../shaders/overlay_paint_face_vert.glsl | 2 +- .../shaders/overlay_paint_point_vert.glsl | 2 +- .../shaders/overlay_paint_texture_vert.glsl | 2 +- .../shaders/overlay_paint_weight_vert.glsl | 2 +- .../shaders/overlay_paint_wire_vert.glsl | 2 +- .../shaders/overlay_particle_hair_vert.glsl | 2 +- .../shaders/overlay_particle_shape_vert.glsl | 2 +- .../shaders/overlay_particle_vert.glsl | 2 +- .../overlay_sculpt_curves_cage_vert.glsl | 2 +- .../overlay_sculpt_curves_selection_vert.glsl | 2 +- .../shaders/overlay_sculpt_mask_vert.glsl | 2 +- .../overlay_viewer_attribute_curve_vert.glsl | 2 +- .../overlay_viewer_attribute_curves_vert.glsl | 2 +- .../overlay_viewer_attribute_mesh_vert.glsl | 2 +- ...rlay_viewer_attribute_pointcloud_vert.glsl | 2 +- .../shaders/overlay_wireframe_vert.glsl | 2 +- .../shaders/common_view_clipping_lib.glsl | 48 ------------------- .../shaders/draw_view_clipping_lib.glsl | 11 ----- 101 files changed, 142 insertions(+), 130 deletions(-) delete mode 100644 source/blender/draw/intern/shaders/common_view_clipping_lib.glsl diff --git a/source/blender/draw/CMakeLists.txt b/source/blender/draw/CMakeLists.txt index 2919410d031..f99eacdf2ab 100644 --- a/source/blender/draw/CMakeLists.txt +++ b/source/blender/draw/CMakeLists.txt @@ -563,7 +563,6 @@ set(GLSL_SRC intern/shaders/subdiv_vbo_edituv_strech_area_comp.glsl intern/shaders/subdiv_vbo_lnor_comp.glsl intern/shaders/subdiv_vbo_sculpt_data_comp.glsl - intern/shaders/common_view_clipping_lib.glsl intern/shaders/draw_command_generate_comp.glsl intern/shaders/draw_debug_draw_display_frag.glsl intern/shaders/draw_debug_draw_display_vert.glsl diff --git a/source/blender/draw/engines/overlay/overlay_next_antialiasing.hh b/source/blender/draw/engines/overlay/overlay_next_antialiasing.hh index c6eab0dcb99..d34c6b00490 100644 --- a/source/blender/draw/engines/overlay/overlay_next_antialiasing.hh +++ b/source/blender/draw/engines/overlay/overlay_next_antialiasing.hh @@ -71,6 +71,7 @@ class AntiAliasing : Overlay { pass.state_set(DRW_STATE_WRITE_COLOR | DRW_STATE_BLEND_ALPHA_PREMUL); pass.shader_set(res.shaders.anti_aliasing.get()); pass.bind_ubo(OVERLAY_GLOBALS_SLOT, &res.globals_buf); + pass.bind_ubo(DRW_CLIPPING_UBO_SLOT, &res.clip_planes_buf); pass.bind_texture("depthTex", &res.depth_tx); pass.bind_texture("colorTex", &res.overlay_tx); pass.bind_texture("lineTex", &res.line_tx); diff --git a/source/blender/draw/engines/overlay/overlay_next_armature.hh b/source/blender/draw/engines/overlay/overlay_next_armature.hh index f54ae070621..7418b2de0eb 100644 --- a/source/blender/draw/engines/overlay/overlay_next_armature.hh +++ b/source/blender/draw/engines/overlay/overlay_next_armature.hh @@ -163,6 +163,7 @@ class Armatures : Overlay { armature_ps_.init(); armature_ps_.bind_ubo(OVERLAY_GLOBALS_SLOT, &res.globals_buf); + armature_ps_.bind_ubo(DRW_CLIPPING_UBO_SLOT, &res.clip_planes_buf); res.select_bind(armature_ps_); /* Envelope distances and degrees of freedom need to be drawn first as they use additive diff --git a/source/blender/draw/engines/overlay/overlay_next_attribute_viewer.hh b/source/blender/draw/engines/overlay/overlay_next_attribute_viewer.hh index 9f4358b4fdd..af0a2fb4d73 100644 --- a/source/blender/draw/engines/overlay/overlay_next_attribute_viewer.hh +++ b/source/blender/draw/engines/overlay/overlay_next_attribute_viewer.hh @@ -43,6 +43,7 @@ class AttributeViewer : Overlay { return; }; ps_.bind_ubo(OVERLAY_GLOBALS_SLOT, &res.globals_buf); + ps_.bind_ubo(DRW_CLIPPING_UBO_SLOT, &res.clip_planes_buf); ps_.state_set(DRW_STATE_WRITE_COLOR | DRW_STATE_DEPTH_LESS_EQUAL | DRW_STATE_BLEND_ALPHA, state.clipping_plane_count); diff --git a/source/blender/draw/engines/overlay/overlay_next_axes.hh b/source/blender/draw/engines/overlay/overlay_next_axes.hh index 1911ed7b7d8..23a8403d030 100644 --- a/source/blender/draw/engines/overlay/overlay_next_axes.hh +++ b/source/blender/draw/engines/overlay/overlay_next_axes.hh @@ -84,6 +84,7 @@ class Axes : Overlay { ps_.state_set(state_common | DRW_STATE_DEPTH_LESS_EQUAL, state.clipping_plane_count); ps_.shader_set(res.shaders.extra_shape.get()); ps_.bind_ubo(OVERLAY_GLOBALS_SLOT, &res.globals_buf); + ps_.bind_ubo(DRW_CLIPPING_UBO_SLOT, &res.clip_planes_buf); res.select_bind(ps_); axes_buf.end_sync(ps_, res.shapes.arrows.get()); diff --git a/source/blender/draw/engines/overlay/overlay_next_background.hh b/source/blender/draw/engines/overlay/overlay_next_background.hh index 4c0ea14313f..2142a4a8555 100644 --- a/source/blender/draw/engines/overlay/overlay_next_background.hh +++ b/source/blender/draw/engines/overlay/overlay_next_background.hh @@ -91,6 +91,7 @@ class Background : Overlay { bg_ps_.state_set(pass_state); bg_ps_.shader_set(res.shaders.background_fill.get()); bg_ps_.bind_ubo(OVERLAY_GLOBALS_SLOT, &res.globals_buf); + bg_ps_.bind_ubo(DRW_CLIPPING_UBO_SLOT, &res.clip_planes_buf); bg_ps_.bind_texture("colorBuffer", &res.color_render_tx); bg_ps_.bind_texture("depthBuffer", &res.depth_tx); bg_ps_.push_constant("colorOverride", color_override); diff --git a/source/blender/draw/engines/overlay/overlay_next_bounds.hh b/source/blender/draw/engines/overlay/overlay_next_bounds.hh index 8837a0408f3..9bf4d775a6d 100644 --- a/source/blender/draw/engines/overlay/overlay_next_bounds.hh +++ b/source/blender/draw/engines/overlay/overlay_next_bounds.hh @@ -203,6 +203,7 @@ class Bounds : Overlay { state.clipping_plane_count); ps_.shader_set(res.shaders.extra_shape.get()); ps_.bind_ubo(OVERLAY_GLOBALS_SLOT, &res.globals_buf); + ps_.bind_ubo(DRW_CLIPPING_UBO_SLOT, &res.clip_planes_buf); res.select_bind(ps_); call_buffers_.box.end_sync(ps_, res.shapes.cube.get()); diff --git a/source/blender/draw/engines/overlay/overlay_next_camera.hh b/source/blender/draw/engines/overlay/overlay_next_camera.hh index 3533d18582a..697e6db6dca 100644 --- a/source/blender/draw/engines/overlay/overlay_next_camera.hh +++ b/source/blender/draw/engines/overlay/overlay_next_camera.hh @@ -124,6 +124,7 @@ class Cameras : Overlay { pass.state_set(draw_state, state.clipping_plane_count); pass.shader_set(res.shaders.image_plane_depth_bias.get()); pass.bind_ubo(OVERLAY_GLOBALS_SLOT, &res.globals_buf); + pass.bind_ubo(DRW_CLIPPING_UBO_SLOT, &res.clip_planes_buf); pass.push_constant("depth_bias_winmat", &depth_bias_winmat_); res.select_bind(pass); }; @@ -167,6 +168,7 @@ class Cameras : Overlay { ps_.init(); ps_.bind_ubo(OVERLAY_GLOBALS_SLOT, &res.globals_buf); + ps_.bind_ubo(DRW_CLIPPING_UBO_SLOT, &res.clip_planes_buf); res.select_bind(ps_); { diff --git a/source/blender/draw/engines/overlay/overlay_next_curve.hh b/source/blender/draw/engines/overlay/overlay_next_curve.hh index 1e495204f22..1c4885aacc5 100644 --- a/source/blender/draw/engines/overlay/overlay_next_curve.hh +++ b/source/blender/draw/engines/overlay/overlay_next_curve.hh @@ -62,6 +62,7 @@ class Curves : Overlay { auto &pass = edit_curves_ps_; pass.init(); pass.bind_ubo(OVERLAY_GLOBALS_SLOT, &res.globals_buf); + pass.bind_ubo(DRW_CLIPPING_UBO_SLOT, &res.clip_planes_buf); { auto &sub = pass.sub("Lines"); sub.state_set(DRW_STATE_WRITE_COLOR | DRW_STATE_DEPTH_LESS_EQUAL | DRW_STATE_BLEND_ALPHA | @@ -103,6 +104,7 @@ class Curves : Overlay { auto &pass = edit_legacy_curve_ps_; pass.init(); pass.bind_ubo(OVERLAY_GLOBALS_SLOT, &res.globals_buf); + pass.bind_ubo(DRW_CLIPPING_UBO_SLOT, &res.clip_planes_buf); { auto &sub = pass.sub("Wires"); sub.state_set(DRW_STATE_WRITE_COLOR | DRW_STATE_DEPTH_LESS_EQUAL | DRW_STATE_WRITE_DEPTH, @@ -149,6 +151,7 @@ class Curves : Overlay { auto &pass = edit_legacy_surface_handles_ps; pass.init(); pass.bind_ubo(OVERLAY_GLOBALS_SLOT, &res.globals_buf); + pass.bind_ubo(DRW_CLIPPING_UBO_SLOT, &res.clip_planes_buf); auto create_sub = [&](const char *name, DRWState drw_state, float alpha) { auto &sub = pass.sub(name); diff --git a/source/blender/draw/engines/overlay/overlay_next_edit_text.hh b/source/blender/draw/engines/overlay/overlay_next_edit_text.hh index 8e64f1a0b4d..8da02da187f 100644 --- a/source/blender/draw/engines/overlay/overlay_next_edit_text.hh +++ b/source/blender/draw/engines/overlay/overlay_next_edit_text.hh @@ -49,6 +49,7 @@ class EditText : Overlay { ps_.init(); ps_.bind_ubo(OVERLAY_GLOBALS_SLOT, &res.globals_buf); + ps_.bind_ubo(DRW_CLIPPING_UBO_SLOT, &res.clip_planes_buf); res.select_bind(ps_); { DRWState default_state = DRW_STATE_WRITE_COLOR | DRW_STATE_BLEND_ALPHA; diff --git a/source/blender/draw/engines/overlay/overlay_next_empty.hh b/source/blender/draw/engines/overlay/overlay_next_empty.hh index 7c13c80f4a4..16cdbe30d5d 100644 --- a/source/blender/draw/engines/overlay/overlay_next_empty.hh +++ b/source/blender/draw/engines/overlay/overlay_next_empty.hh @@ -71,6 +71,7 @@ class Empties : Overlay { pass.shader_set(res.shaders.image_plane_depth_bias.get()); pass.push_constant("depth_bias_winmat", &depth_bias_winmat_); pass.bind_ubo(OVERLAY_GLOBALS_SLOT, &res.globals_buf); + pass.bind_ubo(DRW_CLIPPING_UBO_SLOT, &res.clip_planes_buf); res.select_bind(pass); }; @@ -185,6 +186,7 @@ class Empties : Overlay { state.clipping_plane_count); ps.shader_set(res.shaders.extra_shape.get()); ps.bind_ubo(OVERLAY_GLOBALS_SLOT, &res.globals_buf); + ps.bind_ubo(DRW_CLIPPING_UBO_SLOT, &res.clip_planes_buf); call_buffers.plain_axes_buf.end_sync(ps, res.shapes.plain_axes.get()); call_buffers.single_arrow_buf.end_sync(ps, res.shapes.single_arrow.get()); @@ -365,6 +367,7 @@ class Empties : Overlay { sub.shader_set(res.shaders.image_plane.get()); } sub.bind_ubo(OVERLAY_GLOBALS_SLOT, &res.globals_buf); + sub.bind_ubo(DRW_CLIPPING_UBO_SLOT, &res.clip_planes_buf); return sub; }; diff --git a/source/blender/draw/engines/overlay/overlay_next_facing.hh b/source/blender/draw/engines/overlay/overlay_next_facing.hh index a6143a4190b..ce2d54afd59 100644 --- a/source/blender/draw/engines/overlay/overlay_next_facing.hh +++ b/source/blender/draw/engines/overlay/overlay_next_facing.hh @@ -53,6 +53,7 @@ class Facing : Overlay { state.clipping_plane_count); ps_.shader_set(res.shaders.facing.get()); ps_.bind_ubo(OVERLAY_GLOBALS_SLOT, &res.globals_buf); + ps_.bind_ubo(DRW_CLIPPING_UBO_SLOT, &res.clip_planes_buf); } void object_sync(Manager &manager, diff --git a/source/blender/draw/engines/overlay/overlay_next_fluid.hh b/source/blender/draw/engines/overlay/overlay_next_fluid.hh index 792728974af..a0bfad02278 100644 --- a/source/blender/draw/engines/overlay/overlay_next_fluid.hh +++ b/source/blender/draw/engines/overlay/overlay_next_fluid.hh @@ -237,6 +237,7 @@ class Fluids : Overlay { { fluid_ps_.shader_set(res.shaders.extra_shape.get()); fluid_ps_.bind_ubo(OVERLAY_GLOBALS_SLOT, &res.globals_buf); + fluid_ps_.bind_ubo(DRW_CLIPPING_UBO_SLOT, &res.clip_planes_buf); cube_buf_.end_sync(fluid_ps_, res.shapes.cube.get()); } diff --git a/source/blender/draw/engines/overlay/overlay_next_force_field.hh b/source/blender/draw/engines/overlay/overlay_next_force_field.hh index 56379e45522..edb8a51b6fd 100644 --- a/source/blender/draw/engines/overlay/overlay_next_force_field.hh +++ b/source/blender/draw/engines/overlay/overlay_next_force_field.hh @@ -159,6 +159,7 @@ class ForceFields : Overlay { state.clipping_plane_count); ps_.shader_set(res.shaders.extra_shape.get()); ps_.bind_ubo(OVERLAY_GLOBALS_SLOT, &res.globals_buf); + ps_.bind_ubo(DRW_CLIPPING_UBO_SLOT, &res.clip_planes_buf); call_buffers_.field_force_buf.end_sync(ps_, res.shapes.field_force.get()); call_buffers_.field_wind_buf.end_sync(ps_, res.shapes.field_wind.get()); diff --git a/source/blender/draw/engines/overlay/overlay_next_grease_pencil.hh b/source/blender/draw/engines/overlay/overlay_next_grease_pencil.hh index edf20e5dec3..d7fd0bfc207 100644 --- a/source/blender/draw/engines/overlay/overlay_next_grease_pencil.hh +++ b/source/blender/draw/engines/overlay/overlay_next_grease_pencil.hh @@ -114,6 +114,7 @@ class GreasePencil : Overlay { auto &pass = edit_grease_pencil_ps_; pass.init(); pass.bind_ubo(OVERLAY_GLOBALS_SLOT, &res.globals_buf); + pass.bind_ubo(DRW_CLIPPING_UBO_SLOT, &res.clip_planes_buf); pass.state_set(DRW_STATE_WRITE_COLOR | DRW_STATE_WRITE_DEPTH | DRW_STATE_DEPTH_LESS_EQUAL | DRW_STATE_BLEND_ALPHA, state.clipping_plane_count); @@ -155,6 +156,7 @@ class GreasePencil : Overlay { state.overlay.gpencil_grid_opacity); pass.shader_set(res.shaders.grid_grease_pencil.get()); pass.bind_ubo(OVERLAY_GLOBALS_SLOT, &res.globals_buf); + pass.bind_ubo(DRW_CLIPPING_UBO_SLOT, &res.clip_planes_buf); pass.push_constant("color", col_grid); } } diff --git a/source/blender/draw/engines/overlay/overlay_next_grid.hh b/source/blender/draw/engines/overlay/overlay_next_grid.hh index 702c2438680..9928c1a1917 100644 --- a/source/blender/draw/engines/overlay/overlay_next_grid.hh +++ b/source/blender/draw/engines/overlay/overlay_next_grid.hh @@ -62,6 +62,7 @@ class Grid : Overlay { grid_ps_.init(); grid_ps_.bind_ubo(OVERLAY_GLOBALS_SLOT, &res.globals_buf); + grid_ps_.bind_ubo(DRW_CLIPPING_UBO_SLOT, &res.clip_planes_buf); grid_ps_.state_set(DRW_STATE_WRITE_COLOR | DRW_STATE_BLEND_ALPHA); if (state.is_space_image()) { /* Add quad background. */ diff --git a/source/blender/draw/engines/overlay/overlay_next_instance.cc b/source/blender/draw/engines/overlay/overlay_next_instance.cc index 76689b1daa8..6d395a43e83 100644 --- a/source/blender/draw/engines/overlay/overlay_next_instance.cc +++ b/source/blender/draw/engines/overlay/overlay_next_instance.cc @@ -108,6 +108,7 @@ void Instance::init() } resources.update_theme_settings(state); + resources.update_clip_planes(state); ensure_weight_ramp_texture(); @@ -196,6 +197,26 @@ void Instance::ensure_weight_ramp_texture() GPU_texture_update(resources.weight_ramp_tx, GPU_DATA_UBYTE, pixels_ubyte); } +void Resources::update_clip_planes(const State &state) +{ + if (!state.is_space_v3d() || state.clipping_plane_count == 0) { + /* Unused, do not care about content but still fullfil the bindings. */ + clip_planes_buf.push_update(); + return; + } + + for (int i : IndexRange(6)) { + clip_planes_buf[i] = float4(0); + } + + int plane_len = (RV3D_LOCK_FLAGS(state.rv3d) & RV3D_BOXCLIP) ? 4 : 6; + for (int i : IndexRange(plane_len)) { + clip_planes_buf[i] = float4(state.rv3d->clip[i]); + } + + clip_planes_buf.push_update(); +} + void Resources::update_theme_settings(const State &state) { using namespace math; diff --git a/source/blender/draw/engines/overlay/overlay_next_lattice.hh b/source/blender/draw/engines/overlay/overlay_next_lattice.hh index b4200c92969..7645d2df375 100644 --- a/source/blender/draw/engines/overlay/overlay_next_lattice.hh +++ b/source/blender/draw/engines/overlay/overlay_next_lattice.hh @@ -47,6 +47,7 @@ class Lattices : Overlay { ps_.state_set(DRW_STATE_WRITE_COLOR | DRW_STATE_WRITE_DEPTH | DRW_STATE_DEPTH_LESS_EQUAL, state.clipping_plane_count); ps_.bind_ubo(OVERLAY_GLOBALS_SLOT, &res.globals_buf); + ps_.bind_ubo(DRW_CLIPPING_UBO_SLOT, &res.clip_planes_buf); res.select_bind(ps_); edit_lattice_wire_ps_ = create_sub_pass( "edit_lattice_wire", res.shaders.lattice_wire.get(), true); diff --git a/source/blender/draw/engines/overlay/overlay_next_light.hh b/source/blender/draw/engines/overlay/overlay_next_light.hh index d589e5ddd5e..8cc4bd486f2 100644 --- a/source/blender/draw/engines/overlay/overlay_next_light.hh +++ b/source/blender/draw/engines/overlay/overlay_next_light.hh @@ -167,6 +167,7 @@ class Lights : Overlay { DRW_STATE_DEPTH_LESS_EQUAL; ps_.init(); ps_.bind_ubo(OVERLAY_GLOBALS_SLOT, &res.globals_buf); + ps_.bind_ubo(DRW_CLIPPING_UBO_SLOT, &res.clip_planes_buf); res.select_bind(ps_); { diff --git a/source/blender/draw/engines/overlay/overlay_next_lightprobe.hh b/source/blender/draw/engines/overlay/overlay_next_lightprobe.hh index 7d0c42ed68d..85a500abc61 100644 --- a/source/blender/draw/engines/overlay/overlay_next_lightprobe.hh +++ b/source/blender/draw/engines/overlay/overlay_next_lightprobe.hh @@ -65,6 +65,7 @@ class LightProbes : Overlay { ps_dots_.state_set(DRW_STATE_WRITE_COLOR, state.clipping_plane_count); ps_dots_.shader_set(res.shaders.extra_grid.get()); ps_dots_.bind_ubo(OVERLAY_GLOBALS_SLOT, &res.globals_buf); + ps_dots_.bind_ubo(DRW_CLIPPING_UBO_SLOT, &res.clip_planes_buf); ps_dots_.bind_texture("depthBuffer", &res.depth_tx); ps_dots_.push_constant("isTransform", (G.moving & G_TRANSFORM_OBJ) != 0); res.select_bind(ps_dots_); @@ -193,6 +194,7 @@ class LightProbes : Overlay { ps_.init(); ps_.bind_ubo(OVERLAY_GLOBALS_SLOT, &res.globals_buf); + ps_.bind_ubo(DRW_CLIPPING_UBO_SLOT, &res.clip_planes_buf); res.select_bind(ps_); DRWState pass_state = DRW_STATE_WRITE_COLOR | DRW_STATE_WRITE_DEPTH | diff --git a/source/blender/draw/engines/overlay/overlay_next_mesh.hh b/source/blender/draw/engines/overlay/overlay_next_mesh.hh index 97d863baf5f..b95378718a0 100644 --- a/source/blender/draw/engines/overlay/overlay_next_mesh.hh +++ b/source/blender/draw/engines/overlay/overlay_next_mesh.hh @@ -141,6 +141,7 @@ class Meshes : Overlay { pass.shader_set(res.shaders.mesh_edit_depth.get()); pass.push_constant("retopologyOffset", retopology_offset); pass.bind_ubo(OVERLAY_GLOBALS_SLOT, &res.globals_buf); + pass.bind_ubo(DRW_CLIPPING_UBO_SLOT, &res.clip_planes_buf); } { /* Normals */ @@ -157,6 +158,7 @@ class Meshes : Overlay { auto &pass = edit_mesh_normals_ps_; pass.init(); pass.bind_ubo(OVERLAY_GLOBALS_SLOT, &res.globals_buf); + pass.bind_ubo(DRW_CLIPPING_UBO_SLOT, &res.clip_planes_buf); pass.state_set(pass_state, state.clipping_plane_count); auto shader_pass = [&](GPUShader *shader, const char *name) { @@ -199,6 +201,7 @@ class Meshes : Overlay { pass.shader_set(shadeless ? res.shaders.paint_weight.get() : res.shaders.paint_weight_fake_shading.get()); pass.bind_ubo(OVERLAY_GLOBALS_SLOT, &res.globals_buf); + pass.bind_ubo(DRW_CLIPPING_UBO_SLOT, &res.clip_planes_buf); pass.bind_texture("colorramp", &res.weight_ramp_tx); pass.push_constant("drawContours", false); pass.push_constant("opacity", state.overlay.weight_paint_mode_opacity); @@ -228,6 +231,7 @@ class Meshes : Overlay { pass.push_constant("ndc_offset", ndc_offset); pass.push_constant("dataMask", int4(data_mask)); pass.bind_ubo(OVERLAY_GLOBALS_SLOT, &res.globals_buf); + pass.bind_ubo(DRW_CLIPPING_UBO_SLOT, &res.clip_planes_buf); }; { @@ -286,6 +290,7 @@ class Meshes : Overlay { pass.shader_set(res.shaders.mesh_edit_skin_root.get()); pass.push_constant("retopologyOffset", retopology_offset); pass.bind_ubo(OVERLAY_GLOBALS_SLOT, &res.globals_buf); + pass.bind_ubo(DRW_CLIPPING_UBO_SLOT, &res.clip_planes_buf); } } @@ -643,6 +648,7 @@ class MeshUVs : Overlay { DRW_STATE_BLEND_ALPHA); pass.shader_set(res.shaders.uv_wireframe.get()); pass.bind_ubo(OVERLAY_GLOBALS_SLOT, &res.globals_buf); + pass.bind_ubo(DRW_CLIPPING_UBO_SLOT, &res.clip_planes_buf); pass.push_constant("alpha", space_image->uv_opacity); pass.push_constant("doSmoothWire", do_smooth_wire); } @@ -657,6 +663,7 @@ class MeshUVs : Overlay { pass.specialize_constant(sh, "use_edge_select", !show_vert_); pass.shader_set(sh); pass.bind_ubo(OVERLAY_GLOBALS_SLOT, &res.globals_buf); + pass.bind_ubo(DRW_CLIPPING_UBO_SLOT, &res.clip_planes_buf); pass.push_constant("lineStyle", int(edit_uv_line_style_from_space_image(space_image))); pass.push_constant("alpha", space_image->uv_opacity); pass.push_constant("dashLength", dash_length); @@ -675,6 +682,7 @@ class MeshUVs : Overlay { DRW_STATE_BLEND_ALPHA); pass.shader_set(res.shaders.uv_edit_vert.get()); pass.bind_ubo(OVERLAY_GLOBALS_SLOT, &res.globals_buf); + pass.bind_ubo(DRW_CLIPPING_UBO_SLOT, &res.clip_planes_buf); pass.push_constant("pointSize", (point_size + 1.5f) * float(M_SQRT2)); pass.push_constant("outlineWidth", 0.75f); pass.push_constant("color", theme_color); @@ -689,6 +697,7 @@ class MeshUVs : Overlay { DRW_STATE_BLEND_ALPHA); pass.shader_set(res.shaders.uv_edit_facedot.get()); pass.bind_ubo(OVERLAY_GLOBALS_SLOT, &res.globals_buf); + pass.bind_ubo(DRW_CLIPPING_UBO_SLOT, &res.clip_planes_buf); pass.push_constant("pointSize", point_size); } @@ -698,6 +707,7 @@ class MeshUVs : Overlay { pass.state_set(DRW_STATE_WRITE_COLOR | DRW_STATE_DEPTH_ALWAYS | DRW_STATE_BLEND_ALPHA); pass.shader_set(res.shaders.uv_edit_face.get()); pass.bind_ubo(OVERLAY_GLOBALS_SLOT, &res.globals_buf); + pass.bind_ubo(DRW_CLIPPING_UBO_SLOT, &res.clip_planes_buf); pass.push_constant("uvOpacity", space_image->uv_opacity); } @@ -709,6 +719,7 @@ class MeshUVs : Overlay { res.shaders.uv_analysis_stretch_angle.get() : res.shaders.uv_analysis_stretch_area.get()); pass.bind_ubo(OVERLAY_GLOBALS_SLOT, &res.globals_buf); + pass.bind_ubo(DRW_CLIPPING_UBO_SLOT, &res.clip_planes_buf); pass.push_constant("aspect", state.image_uv_aspect); pass.push_constant("stretch_opacity", space_image->stretch_opacity); pass.push_constant("totalAreaRatio", &total_area_ratio_); diff --git a/source/blender/draw/engines/overlay/overlay_next_metaball.hh b/source/blender/draw/engines/overlay/overlay_next_metaball.hh index 45f3828dd6e..32aae1a9991 100644 --- a/source/blender/draw/engines/overlay/overlay_next_metaball.hh +++ b/source/blender/draw/engines/overlay/overlay_next_metaball.hh @@ -95,6 +95,7 @@ class Metaballs : Overlay { * just a circle facing the camera. */ ps_.shader_set(res.shaders.armature_sphere_outline.get()); ps_.bind_ubo(OVERLAY_GLOBALS_SLOT, &res.globals_buf); + ps_.bind_ubo(DRW_CLIPPING_UBO_SLOT, &res.clip_planes_buf); res.select_bind(ps_); circle_buf_.end_sync(ps_, res.shapes.metaball_wire_circle.get()); diff --git a/source/blender/draw/engines/overlay/overlay_next_mode_transfer.hh b/source/blender/draw/engines/overlay/overlay_next_mode_transfer.hh index 9002d957bba..6194bfef934 100644 --- a/source/blender/draw/engines/overlay/overlay_next_mode_transfer.hh +++ b/source/blender/draw/engines/overlay/overlay_next_mode_transfer.hh @@ -55,6 +55,7 @@ class ModeTransfer : Overlay { state.clipping_plane_count); ps_.shader_set(res.shaders.uniform_color.get()); ps_.bind_ubo(OVERLAY_GLOBALS_SLOT, &res.globals_buf); + ps_.bind_ubo(DRW_CLIPPING_UBO_SLOT, &res.clip_planes_buf); any_animated_ = false; } diff --git a/source/blender/draw/engines/overlay/overlay_next_motion_path.hh b/source/blender/draw/engines/overlay/overlay_next_motion_path.hh index 3a61d78dbd4..96c4bbfbcee 100644 --- a/source/blender/draw/engines/overlay/overlay_next_motion_path.hh +++ b/source/blender/draw/engines/overlay/overlay_next_motion_path.hh @@ -45,6 +45,7 @@ class MotionPath : Overlay { PassSimple &pass = motion_path_ps_; pass.init(); pass.bind_ubo(OVERLAY_GLOBALS_SLOT, &res.globals_buf); + pass.bind_ubo(DRW_CLIPPING_UBO_SLOT, &res.clip_planes_buf); pass.state_set(DRW_STATE_WRITE_COLOR, state.clipping_plane_count); { PassSimple::Sub &sub = pass.sub("Lines"); diff --git a/source/blender/draw/engines/overlay/overlay_next_origin.hh b/source/blender/draw/engines/overlay/overlay_next_origin.hh index 526f3fcca54..7a6c9ef182a 100644 --- a/source/blender/draw/engines/overlay/overlay_next_origin.hh +++ b/source/blender/draw/engines/overlay/overlay_next_origin.hh @@ -84,6 +84,7 @@ class Origins : Overlay { res.select_bind(ps_); ps_.shader_set(res.shaders.extra_point.get()); ps_.bind_ubo(OVERLAY_GLOBALS_SLOT, &res.globals_buf); + ps_.bind_ubo(DRW_CLIPPING_UBO_SLOT, &res.clip_planes_buf); select_buf_.select_bind(ps_); point_buf_.push_update(); ps_.bind_ssbo("data_buf", &point_buf_); diff --git a/source/blender/draw/engines/overlay/overlay_next_outline.hh b/source/blender/draw/engines/overlay/overlay_next_outline.hh index 94fe38e4815..89127f442c1 100644 --- a/source/blender/draw/engines/overlay/overlay_next_outline.hh +++ b/source/blender/draw/engines/overlay/overlay_next_outline.hh @@ -64,6 +64,7 @@ class Outline : Overlay { auto &pass = outline_prepass_ps_; pass.init(); pass.bind_ubo(OVERLAY_GLOBALS_SLOT, &res.globals_buf); + pass.bind_ubo(DRW_CLIPPING_UBO_SLOT, &res.clip_planes_buf); pass.framebuffer_set(&prepass_fb_); pass.clear_color_depth_stencil(float4(0.0f), 1.0f, 0x0); pass.state_set(DRW_STATE_WRITE_COLOR | DRW_STATE_WRITE_DEPTH | DRW_STATE_DEPTH_LESS_EQUAL, @@ -119,6 +120,7 @@ class Outline : Overlay { pass.bind_texture("sceneDepth", &res.depth_tx); pass.bind_texture("outlineDepth", &tmp_depth_tx_); pass.bind_ubo(OVERLAY_GLOBALS_SLOT, &res.globals_buf); + pass.bind_ubo(DRW_CLIPPING_UBO_SLOT, &res.clip_planes_buf); pass.draw_procedural(GPU_PRIM_TRIS, 1, 3); } } @@ -199,6 +201,7 @@ class Outline : Overlay { /* Note: We need a dedicated pass since we have to populated it for each redraw. */ auto &pass = outline_prepass_flat_ps_; pass.bind_ubo(OVERLAY_GLOBALS_SLOT, &res.globals_buf); + pass.bind_ubo(DRW_CLIPPING_UBO_SLOT, &res.clip_planes_buf); pass.framebuffer_set(&prepass_fb_); pass.state_set(DRW_STATE_WRITE_COLOR | DRW_STATE_WRITE_DEPTH | DRW_STATE_DEPTH_LESS_EQUAL, state.clipping_plane_count); diff --git a/source/blender/draw/engines/overlay/overlay_next_paint.hh b/source/blender/draw/engines/overlay/overlay_next_paint.hh index 22304706900..53e8199d6c5 100644 --- a/source/blender/draw/engines/overlay/overlay_next_paint.hh +++ b/source/blender/draw/engines/overlay/overlay_next_paint.hh @@ -64,6 +64,7 @@ class Paints : Overlay { { auto &pass = paint_region_ps_; pass.bind_ubo(OVERLAY_GLOBALS_SLOT, &res.globals_buf); + pass.bind_ubo(DRW_CLIPPING_UBO_SLOT, &res.clip_planes_buf); { auto &sub = pass.sub("Face"); sub.state_set(DRW_STATE_WRITE_COLOR | DRW_STATE_WRITE_DEPTH | DRW_STATE_DEPTH_LESS_EQUAL | @@ -110,6 +111,7 @@ class Paints : Overlay { pass.shader_set(shadeless ? res.shaders.paint_weight.get() : res.shaders.paint_weight_fake_shading.get()); pass.bind_ubo(OVERLAY_GLOBALS_SLOT, &res.globals_buf); + pass.bind_ubo(DRW_CLIPPING_UBO_SLOT, &res.clip_planes_buf); pass.bind_texture("colorramp", &res.weight_ramp_tx); pass.push_constant("drawContours", draw_contours); pass.push_constant("opacity", state.overlay.weight_paint_mode_opacity); @@ -134,6 +136,7 @@ class Paints : Overlay { state.clipping_plane_count); pass.shader_set(res.shaders.paint_texture.get()); pass.bind_ubo(OVERLAY_GLOBALS_SLOT, &res.globals_buf); + pass.bind_ubo(DRW_CLIPPING_UBO_SLOT, &res.clip_planes_buf); pass.bind_texture("maskImage", mask_texture); pass.push_constant("maskPremult", mask_premult); pass.push_constant("maskInvertStencil", mask_inverted); diff --git a/source/blender/draw/engines/overlay/overlay_next_particle.hh b/source/blender/draw/engines/overlay/overlay_next_particle.hh index ca6225ccc3e..ca0f3d8f115 100644 --- a/source/blender/draw/engines/overlay/overlay_next_particle.hh +++ b/source/blender/draw/engines/overlay/overlay_next_particle.hh @@ -62,6 +62,7 @@ class Particles : Overlay { auto &pass = particle_ps_; pass.init(); pass.bind_ubo(OVERLAY_GLOBALS_SLOT, &res.globals_buf); + pass.bind_ubo(DRW_CLIPPING_UBO_SLOT, &res.clip_planes_buf); pass.state_set(DRW_STATE_WRITE_COLOR | DRW_STATE_WRITE_DEPTH | DRW_STATE_DEPTH_LESS_EQUAL, state.clipping_plane_count); res.select_bind(pass); @@ -90,6 +91,7 @@ class Particles : Overlay { auto &pass = edit_particle_ps_; pass.init(); pass.bind_ubo(OVERLAY_GLOBALS_SLOT, &res.globals_buf); + pass.bind_ubo(DRW_CLIPPING_UBO_SLOT, &res.clip_planes_buf); pass.state_set(DRW_STATE_WRITE_COLOR | DRW_STATE_WRITE_DEPTH | DRW_STATE_DEPTH_LESS_EQUAL, state.clipping_plane_count); res.select_bind(pass); diff --git a/source/blender/draw/engines/overlay/overlay_next_prepass.hh b/source/blender/draw/engines/overlay/overlay_next_prepass.hh index d5096af189d..74590e6e118 100644 --- a/source/blender/draw/engines/overlay/overlay_next_prepass.hh +++ b/source/blender/draw/engines/overlay/overlay_next_prepass.hh @@ -91,6 +91,7 @@ class Prepass : Overlay { ps_.init(); ps_.bind_ubo(OVERLAY_GLOBALS_SLOT, &res.globals_buf); + ps_.bind_ubo(DRW_CLIPPING_UBO_SLOT, &res.clip_planes_buf); ps_.state_set(DRW_STATE_WRITE_DEPTH | DRW_STATE_DEPTH_LESS_EQUAL | backface_cull_state, state.clipping_plane_count); res.select_bind(ps_); diff --git a/source/blender/draw/engines/overlay/overlay_next_private.hh b/source/blender/draw/engines/overlay/overlay_next_private.hh index b733388fcb0..d33f3a2bfdc 100644 --- a/source/blender/draw/engines/overlay/overlay_next_private.hh +++ b/source/blender/draw/engines/overlay/overlay_next_private.hh @@ -662,6 +662,7 @@ struct Resources : public select::SelectMap { draw::UniformBuffer globals_buf; GlobalsUboStorage &theme_settings = globals_buf; + draw::UniformArrayBuffer clip_planes_buf; /* Wrappers around #DefaultTextureList members. */ TextureRef depth_in_front_tx; TextureRef color_overlay_tx; @@ -703,6 +704,7 @@ struct Resources : public select::SelectMap { } void update_theme_settings(const State &state); + void update_clip_planes(const State &state); void begin_sync() { diff --git a/source/blender/draw/engines/overlay/overlay_next_relation.hh b/source/blender/draw/engines/overlay/overlay_next_relation.hh index 0c2a04bfb33..3f0a44f8f77 100644 --- a/source/blender/draw/engines/overlay/overlay_next_relation.hh +++ b/source/blender/draw/engines/overlay/overlay_next_relation.hh @@ -196,6 +196,7 @@ class Relations : Overlay { ps_.init(); ps_.bind_ubo(OVERLAY_GLOBALS_SLOT, &res.globals_buf); + ps_.bind_ubo(DRW_CLIPPING_UBO_SLOT, &res.clip_planes_buf); res.select_bind(ps_); { PassSimple::Sub &sub_pass = ps_.sub("lines"); diff --git a/source/blender/draw/engines/overlay/overlay_next_sculpt.hh b/source/blender/draw/engines/overlay/overlay_next_sculpt.hh index 90c1c506f20..a1c0d60c816 100644 --- a/source/blender/draw/engines/overlay/overlay_next_sculpt.hh +++ b/source/blender/draw/engines/overlay/overlay_next_sculpt.hh @@ -69,6 +69,7 @@ class Sculpts : Overlay { { sculpt_mask_.init(); sculpt_mask_.bind_ubo(OVERLAY_GLOBALS_SLOT, &res.globals_buf); + sculpt_mask_.bind_ubo(DRW_CLIPPING_UBO_SLOT, &res.clip_planes_buf); sculpt_mask_.state_set(DRW_STATE_WRITE_COLOR | DRW_STATE_DEPTH_LESS_EQUAL | DRW_STATE_BLEND_MUL, state.clipping_plane_count); @@ -93,6 +94,7 @@ class Sculpts : Overlay { state.clipping_plane_count); pass.shader_set(res.shaders.sculpt_curves_cage.get()); pass.bind_ubo(OVERLAY_GLOBALS_SLOT, &res.globals_buf); + pass.bind_ubo(DRW_CLIPPING_UBO_SLOT, &res.clip_planes_buf); pass.push_constant("opacity", curve_cage_opacity); } } diff --git a/source/blender/draw/engines/overlay/overlay_next_speaker.hh b/source/blender/draw/engines/overlay/overlay_next_speaker.hh index b28968733d7..149571efec3 100644 --- a/source/blender/draw/engines/overlay/overlay_next_speaker.hh +++ b/source/blender/draw/engines/overlay/overlay_next_speaker.hh @@ -67,6 +67,7 @@ class Speakers : Overlay { state.clipping_plane_count); ps_.shader_set(res.shaders.extra_shape.get()); ps_.bind_ubo(OVERLAY_GLOBALS_SLOT, &res.globals_buf); + ps_.bind_ubo(DRW_CLIPPING_UBO_SLOT, &res.clip_planes_buf); res.select_bind(ps_); speaker_buf_.end_sync(ps_, res.shapes.speaker.get()); diff --git a/source/blender/draw/engines/overlay/overlay_next_wireframe.hh b/source/blender/draw/engines/overlay/overlay_next_wireframe.hh index 91a8a2e9404..444a6e66e11 100644 --- a/source/blender/draw/engines/overlay/overlay_next_wireframe.hh +++ b/source/blender/draw/engines/overlay/overlay_next_wireframe.hh @@ -73,6 +73,7 @@ class Wireframe : Overlay { auto &pass = wireframe_ps_; pass.init(); pass.bind_ubo(OVERLAY_GLOBALS_SLOT, &res.globals_buf); + pass.bind_ubo(DRW_CLIPPING_UBO_SLOT, &res.clip_planes_buf); pass.state_set(DRW_STATE_FIRST_VERTEX_CONVENTION | DRW_STATE_WRITE_COLOR | DRW_STATE_WRITE_DEPTH | DRW_STATE_DEPTH_LESS_EQUAL, state.clipping_plane_count); diff --git a/source/blender/draw/engines/overlay/shaders/infos/overlay_common_info.hh b/source/blender/draw/engines/overlay/shaders/infos/overlay_common_info.hh index 53a9adb3ba6..af82fda6394 100644 --- a/source/blender/draw/engines/overlay/shaders/infos/overlay_common_info.hh +++ b/source/blender/draw/engines/overlay/shaders/infos/overlay_common_info.hh @@ -17,11 +17,6 @@ TYPEDEF_SOURCE("draw_common_shader_shared.hh") UNIFORM_BUF_FREQ(OVERLAY_GLOBALS_SLOT, GlobalsUboStorage, globalsBlock, PASS) GPU_SHADER_CREATE_END() -GPU_SHADER_CREATE_INFO(overlay_clipped) -DEFINE("OVERLAY_NEXT") /* Needed for view_clipping_lib. */ -DEFINE("USE_WORLD_CLIP_PLANES") -GPU_SHADER_CREATE_END() - GPU_SHADER_CREATE_INFO(overlay_select) DEFINE("SELECT_ENABLE") ADDITIONAL_INFO(select_id_patch) @@ -31,7 +26,7 @@ GPU_SHADER_CREATE_END() GPU_SHADER_CREATE_INFO(name##_clipped) \ DO_STATIC_COMPILATION() \ ADDITIONAL_INFO(name) \ - ADDITIONAL_INFO(overlay_clipped) \ + ADDITIONAL_INFO(drw_clipped) \ GPU_SHADER_CREATE_END() #define OVERLAY_INFO_SELECT_VARIATION(name) \ diff --git a/source/blender/draw/engines/overlay/shaders/overlay_armature_dof_vert.glsl b/source/blender/draw/engines/overlay/shaders/overlay_armature_dof_vert.glsl index 1cac2b96ddf..2a02c3ffd12 100644 --- a/source/blender/draw/engines/overlay/shaders/overlay_armature_dof_vert.glsl +++ b/source/blender/draw/engines/overlay/shaders/overlay_armature_dof_vert.glsl @@ -2,7 +2,7 @@ * * SPDX-License-Identifier: GPL-2.0-or-later */ -#include "common_view_clipping_lib.glsl" +#include "draw_view_clipping_lib.glsl" #include "draw_view_lib.glsl" vec3 sphere_project(float ax, float az) diff --git a/source/blender/draw/engines/overlay/shaders/overlay_armature_envelope_outline_vert.glsl b/source/blender/draw/engines/overlay/shaders/overlay_armature_envelope_outline_vert.glsl index 60bebb2b1f8..1c7d0cf7504 100644 --- a/source/blender/draw/engines/overlay/shaders/overlay_armature_envelope_outline_vert.glsl +++ b/source/blender/draw/engines/overlay/shaders/overlay_armature_envelope_outline_vert.glsl @@ -2,7 +2,7 @@ * * SPDX-License-Identifier: GPL-2.0-or-later */ -#include "common_view_clipping_lib.glsl" +#include "draw_view_clipping_lib.glsl" #include "draw_view_lib.glsl" #include "select_lib.glsl" diff --git a/source/blender/draw/engines/overlay/shaders/overlay_armature_envelope_solid_vert.glsl b/source/blender/draw/engines/overlay/shaders/overlay_armature_envelope_solid_vert.glsl index a313579cb12..5da0c4e5c06 100644 --- a/source/blender/draw/engines/overlay/shaders/overlay_armature_envelope_solid_vert.glsl +++ b/source/blender/draw/engines/overlay/shaders/overlay_armature_envelope_solid_vert.glsl @@ -2,7 +2,7 @@ * * SPDX-License-Identifier: GPL-2.0-or-later */ -#include "common_view_clipping_lib.glsl" +#include "draw_view_clipping_lib.glsl" #include "draw_view_lib.glsl" #include "select_lib.glsl" diff --git a/source/blender/draw/engines/overlay/shaders/overlay_armature_shape_outline_vert.glsl b/source/blender/draw/engines/overlay/shaders/overlay_armature_shape_outline_vert.glsl index 62a25d9decd..b8af72af9e1 100644 --- a/source/blender/draw/engines/overlay/shaders/overlay_armature_shape_outline_vert.glsl +++ b/source/blender/draw/engines/overlay/shaders/overlay_armature_shape_outline_vert.glsl @@ -2,7 +2,7 @@ * * SPDX-License-Identifier: GPL-2.0-or-later */ -#include "common_view_clipping_lib.glsl" +#include "draw_view_clipping_lib.glsl" #include "draw_view_lib.glsl" #include "gpu_shader_attribute_load_lib.glsl" #include "gpu_shader_index_load_lib.glsl" diff --git a/source/blender/draw/engines/overlay/shaders/overlay_armature_shape_solid_vert.glsl b/source/blender/draw/engines/overlay/shaders/overlay_armature_shape_solid_vert.glsl index 44001ca8435..9b5e0448dc2 100644 --- a/source/blender/draw/engines/overlay/shaders/overlay_armature_shape_solid_vert.glsl +++ b/source/blender/draw/engines/overlay/shaders/overlay_armature_shape_solid_vert.glsl @@ -2,7 +2,7 @@ * * SPDX-License-Identifier: GPL-2.0-or-later */ -#include "common_view_clipping_lib.glsl" +#include "draw_view_clipping_lib.glsl" #include "draw_view_lib.glsl" #include "overlay_common_lib.glsl" #include "select_lib.glsl" diff --git a/source/blender/draw/engines/overlay/shaders/overlay_armature_shape_wire_vert.glsl b/source/blender/draw/engines/overlay/shaders/overlay_armature_shape_wire_vert.glsl index e4798d0c32a..3be3e69d440 100644 --- a/source/blender/draw/engines/overlay/shaders/overlay_armature_shape_wire_vert.glsl +++ b/source/blender/draw/engines/overlay/shaders/overlay_armature_shape_wire_vert.glsl @@ -2,7 +2,7 @@ * * SPDX-License-Identifier: GPL-2.0-or-later */ -#include "common_view_clipping_lib.glsl" +#include "draw_view_clipping_lib.glsl" #include "draw_view_lib.glsl" #include "gpu_shader_attribute_load_lib.glsl" #include "gpu_shader_index_load_lib.glsl" diff --git a/source/blender/draw/engines/overlay/shaders/overlay_armature_sphere_outline_vert.glsl b/source/blender/draw/engines/overlay/shaders/overlay_armature_sphere_outline_vert.glsl index 763d5fdfe34..50e28111bd8 100644 --- a/source/blender/draw/engines/overlay/shaders/overlay_armature_sphere_outline_vert.glsl +++ b/source/blender/draw/engines/overlay/shaders/overlay_armature_sphere_outline_vert.glsl @@ -2,7 +2,7 @@ * * SPDX-License-Identifier: GPL-2.0-or-later */ -#include "common_view_clipping_lib.glsl" +#include "draw_view_clipping_lib.glsl" #include "draw_view_lib.glsl" #include "overlay_common_lib.glsl" #include "select_lib.glsl" diff --git a/source/blender/draw/engines/overlay/shaders/overlay_armature_sphere_solid_vert.glsl b/source/blender/draw/engines/overlay/shaders/overlay_armature_sphere_solid_vert.glsl index 631a050a21e..fdce20aff3f 100644 --- a/source/blender/draw/engines/overlay/shaders/overlay_armature_sphere_solid_vert.glsl +++ b/source/blender/draw/engines/overlay/shaders/overlay_armature_sphere_solid_vert.glsl @@ -2,7 +2,7 @@ * * SPDX-License-Identifier: GPL-2.0-or-later */ -#include "common_view_clipping_lib.glsl" +#include "draw_view_clipping_lib.glsl" #include "draw_view_lib.glsl" #include "overlay_common_lib.glsl" #include "select_lib.glsl" diff --git a/source/blender/draw/engines/overlay/shaders/overlay_armature_stick_vert.glsl b/source/blender/draw/engines/overlay/shaders/overlay_armature_stick_vert.glsl index a71cb4ef4f7..5f2b5d4bfb9 100644 --- a/source/blender/draw/engines/overlay/shaders/overlay_armature_stick_vert.glsl +++ b/source/blender/draw/engines/overlay/shaders/overlay_armature_stick_vert.glsl @@ -2,8 +2,8 @@ * * SPDX-License-Identifier: GPL-2.0-or-later */ -#include "common_view_clipping_lib.glsl" #include "draw_model_lib.glsl" +#include "draw_view_clipping_lib.glsl" #include "draw_view_lib.glsl" #include "gpu_shader_utildefines_lib.glsl" #include "select_lib.glsl" diff --git a/source/blender/draw/engines/overlay/shaders/overlay_armature_wire_vert.glsl b/source/blender/draw/engines/overlay/shaders/overlay_armature_wire_vert.glsl index 169340f8baa..f46c11da130 100644 --- a/source/blender/draw/engines/overlay/shaders/overlay_armature_wire_vert.glsl +++ b/source/blender/draw/engines/overlay/shaders/overlay_armature_wire_vert.glsl @@ -2,8 +2,8 @@ * * SPDX-License-Identifier: GPL-2.0-or-later */ -#include "common_view_clipping_lib.glsl" #include "draw_model_lib.glsl" +#include "draw_view_clipping_lib.glsl" #include "draw_view_lib.glsl" #include "select_lib.glsl" diff --git a/source/blender/draw/engines/overlay/shaders/overlay_depth_only_curves_vert.glsl b/source/blender/draw/engines/overlay/shaders/overlay_depth_only_curves_vert.glsl index 446ecf65459..8758c2e9a46 100644 --- a/source/blender/draw/engines/overlay/shaders/overlay_depth_only_curves_vert.glsl +++ b/source/blender/draw/engines/overlay/shaders/overlay_depth_only_curves_vert.glsl @@ -3,8 +3,8 @@ * SPDX-License-Identifier: GPL-2.0-or-later */ #include "common_hair_lib.glsl" -#include "common_view_clipping_lib.glsl" #include "draw_model_lib.glsl" +#include "draw_view_clipping_lib.glsl" #include "draw_view_lib.glsl" #include "select_lib.glsl" diff --git a/source/blender/draw/engines/overlay/shaders/overlay_depth_only_gpencil_vert.glsl b/source/blender/draw/engines/overlay/shaders/overlay_depth_only_gpencil_vert.glsl index 84eb05e1e0d..3d013c953ae 100644 --- a/source/blender/draw/engines/overlay/shaders/overlay_depth_only_gpencil_vert.glsl +++ b/source/blender/draw/engines/overlay/shaders/overlay_depth_only_gpencil_vert.glsl @@ -3,8 +3,8 @@ * SPDX-License-Identifier: GPL-2.0-or-later */ #include "common_gpencil_lib.glsl" -#include "common_view_clipping_lib.glsl" #include "draw_model_lib.glsl" +#include "draw_view_clipping_lib.glsl" #include "draw_view_lib.glsl" #include "select_lib.glsl" diff --git a/source/blender/draw/engines/overlay/shaders/overlay_depth_only_mesh_conservative_vert.glsl b/source/blender/draw/engines/overlay/shaders/overlay_depth_only_mesh_conservative_vert.glsl index cfa46eb9e38..c1910c829d1 100644 --- a/source/blender/draw/engines/overlay/shaders/overlay_depth_only_mesh_conservative_vert.glsl +++ b/source/blender/draw/engines/overlay/shaders/overlay_depth_only_mesh_conservative_vert.glsl @@ -2,8 +2,8 @@ * * SPDX-License-Identifier: GPL-2.0-or-later */ -#include "common_view_clipping_lib.glsl" #include "draw_model_lib.glsl" +#include "draw_view_clipping_lib.glsl" #include "draw_view_lib.glsl" #include "gpu_shader_attribute_load_lib.glsl" #include "gpu_shader_index_load_lib.glsl" diff --git a/source/blender/draw/engines/overlay/shaders/overlay_depth_only_pointcloud_vert.glsl b/source/blender/draw/engines/overlay/shaders/overlay_depth_only_pointcloud_vert.glsl index e6ba82802c7..2200b25bf21 100644 --- a/source/blender/draw/engines/overlay/shaders/overlay_depth_only_pointcloud_vert.glsl +++ b/source/blender/draw/engines/overlay/shaders/overlay_depth_only_pointcloud_vert.glsl @@ -3,8 +3,8 @@ * SPDX-License-Identifier: GPL-2.0-or-later */ #include "common_pointcloud_lib.glsl" -#include "common_view_clipping_lib.glsl" #include "draw_model_lib.glsl" +#include "draw_view_clipping_lib.glsl" #include "draw_view_lib.glsl" #include "select_lib.glsl" diff --git a/source/blender/draw/engines/overlay/shaders/overlay_depth_only_vert.glsl b/source/blender/draw/engines/overlay/shaders/overlay_depth_only_vert.glsl index 7d46fc075f1..4a7fd607fb2 100644 --- a/source/blender/draw/engines/overlay/shaders/overlay_depth_only_vert.glsl +++ b/source/blender/draw/engines/overlay/shaders/overlay_depth_only_vert.glsl @@ -2,8 +2,8 @@ * * SPDX-License-Identifier: GPL-2.0-or-later */ -#include "common_view_clipping_lib.glsl" #include "draw_model_lib.glsl" +#include "draw_view_clipping_lib.glsl" #include "draw_view_lib.glsl" #include "select_lib.glsl" diff --git a/source/blender/draw/engines/overlay/shaders/overlay_edit_curve_handle_vert.glsl b/source/blender/draw/engines/overlay/shaders/overlay_edit_curve_handle_vert.glsl index 867f93efa92..2ab12f027a2 100644 --- a/source/blender/draw/engines/overlay/shaders/overlay_edit_curve_handle_vert.glsl +++ b/source/blender/draw/engines/overlay/shaders/overlay_edit_curve_handle_vert.glsl @@ -2,8 +2,8 @@ * * SPDX-License-Identifier: GPL-2.0-or-later */ -#include "common_view_clipping_lib.glsl" #include "draw_model_lib.glsl" +#include "draw_view_clipping_lib.glsl" #include "draw_view_lib.glsl" #include "gpu_shader_attribute_load_lib.glsl" #include "gpu_shader_index_load_lib.glsl" diff --git a/source/blender/draw/engines/overlay/shaders/overlay_edit_curve_point_vert.glsl b/source/blender/draw/engines/overlay/shaders/overlay_edit_curve_point_vert.glsl index 1c83a2a3978..4780acb9d98 100644 --- a/source/blender/draw/engines/overlay/shaders/overlay_edit_curve_point_vert.glsl +++ b/source/blender/draw/engines/overlay/shaders/overlay_edit_curve_point_vert.glsl @@ -2,8 +2,8 @@ * * SPDX-License-Identifier: GPL-2.0-or-later */ -#include "common_view_clipping_lib.glsl" #include "draw_model_lib.glsl" +#include "draw_view_clipping_lib.glsl" #include "draw_view_lib.glsl" void main() diff --git a/source/blender/draw/engines/overlay/shaders/overlay_edit_curve_wire_next_vert.glsl b/source/blender/draw/engines/overlay/shaders/overlay_edit_curve_wire_next_vert.glsl index 1569a671371..826baa8c0dd 100644 --- a/source/blender/draw/engines/overlay/shaders/overlay_edit_curve_wire_next_vert.glsl +++ b/source/blender/draw/engines/overlay/shaders/overlay_edit_curve_wire_next_vert.glsl @@ -2,8 +2,8 @@ * * SPDX-License-Identifier: GPL-2.0-or-later */ -#include "common_view_clipping_lib.glsl" #include "draw_model_lib.glsl" +#include "draw_view_clipping_lib.glsl" #include "draw_view_lib.glsl" #include "gpu_shader_attribute_load_lib.glsl" #include "gpu_shader_index_load_lib.glsl" diff --git a/source/blender/draw/engines/overlay/shaders/overlay_edit_curve_wire_vert.glsl b/source/blender/draw/engines/overlay/shaders/overlay_edit_curve_wire_vert.glsl index cd04fbdfad4..3ca19da2c6e 100644 --- a/source/blender/draw/engines/overlay/shaders/overlay_edit_curve_wire_vert.glsl +++ b/source/blender/draw/engines/overlay/shaders/overlay_edit_curve_wire_vert.glsl @@ -2,8 +2,8 @@ * * SPDX-License-Identifier: GPL-2.0-or-later */ -#include "common_view_clipping_lib.glsl" #include "draw_model_lib.glsl" +#include "draw_view_clipping_lib.glsl" #include "draw_view_lib.glsl" void main() diff --git a/source/blender/draw/engines/overlay/shaders/overlay_edit_curves_handle_vert.glsl b/source/blender/draw/engines/overlay/shaders/overlay_edit_curves_handle_vert.glsl index 0e315b63fc4..07070701eb0 100644 --- a/source/blender/draw/engines/overlay/shaders/overlay_edit_curves_handle_vert.glsl +++ b/source/blender/draw/engines/overlay/shaders/overlay_edit_curves_handle_vert.glsl @@ -2,8 +2,8 @@ * * SPDX-License-Identifier: GPL-2.0-or-later */ -#include "common_view_clipping_lib.glsl" #include "draw_model_lib.glsl" +#include "draw_view_clipping_lib.glsl" #include "draw_view_lib.glsl" #include "gpu_shader_attribute_load_lib.glsl" #include "gpu_shader_index_load_lib.glsl" diff --git a/source/blender/draw/engines/overlay/shaders/overlay_edit_gpencil_canvas_vert.glsl b/source/blender/draw/engines/overlay/shaders/overlay_edit_gpencil_canvas_vert.glsl index d03c7766313..407d9da20ce 100644 --- a/source/blender/draw/engines/overlay/shaders/overlay_edit_gpencil_canvas_vert.glsl +++ b/source/blender/draw/engines/overlay/shaders/overlay_edit_gpencil_canvas_vert.glsl @@ -2,7 +2,7 @@ * * SPDX-License-Identifier: GPL-2.0-or-later */ -#include "common_view_clipping_lib.glsl" +#include "draw_view_clipping_lib.glsl" #include "draw_view_lib.glsl" void main() diff --git a/source/blender/draw/engines/overlay/shaders/overlay_edit_gpencil_vert.glsl b/source/blender/draw/engines/overlay/shaders/overlay_edit_gpencil_vert.glsl index 0f41567f1cd..d2922d878a6 100644 --- a/source/blender/draw/engines/overlay/shaders/overlay_edit_gpencil_vert.glsl +++ b/source/blender/draw/engines/overlay/shaders/overlay_edit_gpencil_vert.glsl @@ -2,8 +2,8 @@ * * SPDX-License-Identifier: GPL-2.0-or-later */ -#include "common_view_clipping_lib.glsl" #include "draw_model_lib.glsl" +#include "draw_view_clipping_lib.glsl" #include "draw_view_lib.glsl" void discard_vert() diff --git a/source/blender/draw/engines/overlay/shaders/overlay_edit_lattice_point_vert.glsl b/source/blender/draw/engines/overlay/shaders/overlay_edit_lattice_point_vert.glsl index 1a8d802d42f..b4c3142ce9a 100644 --- a/source/blender/draw/engines/overlay/shaders/overlay_edit_lattice_point_vert.glsl +++ b/source/blender/draw/engines/overlay/shaders/overlay_edit_lattice_point_vert.glsl @@ -2,8 +2,8 @@ * * SPDX-License-Identifier: GPL-2.0-or-later */ -#include "common_view_clipping_lib.glsl" #include "draw_model_lib.glsl" +#include "draw_view_clipping_lib.glsl" #include "draw_view_lib.glsl" void main() diff --git a/source/blender/draw/engines/overlay/shaders/overlay_edit_lattice_wire_vert.glsl b/source/blender/draw/engines/overlay/shaders/overlay_edit_lattice_wire_vert.glsl index 72a33476eeb..03afed826c5 100644 --- a/source/blender/draw/engines/overlay/shaders/overlay_edit_lattice_wire_vert.glsl +++ b/source/blender/draw/engines/overlay/shaders/overlay_edit_lattice_wire_vert.glsl @@ -2,8 +2,8 @@ * * SPDX-License-Identifier: GPL-2.0-or-later */ -#include "common_view_clipping_lib.glsl" #include "draw_model_lib.glsl" +#include "draw_view_clipping_lib.glsl" #include "draw_view_lib.glsl" #define no_active_weight 666.0 diff --git a/source/blender/draw/engines/overlay/shaders/overlay_edit_mesh_analysis_vert.glsl b/source/blender/draw/engines/overlay/shaders/overlay_edit_mesh_analysis_vert.glsl index 3b77b79b20a..4e7383dd364 100644 --- a/source/blender/draw/engines/overlay/shaders/overlay_edit_mesh_analysis_vert.glsl +++ b/source/blender/draw/engines/overlay/shaders/overlay_edit_mesh_analysis_vert.glsl @@ -2,8 +2,8 @@ * * SPDX-License-Identifier: GPL-2.0-or-later */ -#include "common_view_clipping_lib.glsl" #include "draw_model_lib.glsl" +#include "draw_view_clipping_lib.glsl" #include "draw_view_lib.glsl" vec3 weight_to_rgb(float t) diff --git a/source/blender/draw/engines/overlay/shaders/overlay_edit_mesh_depth_vert.glsl b/source/blender/draw/engines/overlay/shaders/overlay_edit_mesh_depth_vert.glsl index eeb0ae733e7..d048bcd7c0b 100644 --- a/source/blender/draw/engines/overlay/shaders/overlay_edit_mesh_depth_vert.glsl +++ b/source/blender/draw/engines/overlay/shaders/overlay_edit_mesh_depth_vert.glsl @@ -2,8 +2,8 @@ * * SPDX-License-Identifier: GPL-2.0-or-later */ -#include "common_view_clipping_lib.glsl" #include "draw_model_lib.glsl" +#include "draw_view_clipping_lib.glsl" #include "draw_view_lib.glsl" #include "overlay_common_lib.glsl" diff --git a/source/blender/draw/engines/overlay/shaders/overlay_edit_mesh_edge_vert.glsl b/source/blender/draw/engines/overlay/shaders/overlay_edit_mesh_edge_vert.glsl index 399297fb351..0a8a220f645 100644 --- a/source/blender/draw/engines/overlay/shaders/overlay_edit_mesh_edge_vert.glsl +++ b/source/blender/draw/engines/overlay/shaders/overlay_edit_mesh_edge_vert.glsl @@ -2,8 +2,8 @@ * * SPDX-License-Identifier: GPL-2.0-or-later */ -#include "common_view_clipping_lib.glsl" #include "draw_model_lib.glsl" +#include "draw_view_clipping_lib.glsl" #include "draw_view_lib.glsl" #include "gpu_shader_attribute_load_lib.glsl" #include "gpu_shader_index_load_lib.glsl" diff --git a/source/blender/draw/engines/overlay/shaders/overlay_edit_mesh_lib.glsl b/source/blender/draw/engines/overlay/shaders/overlay_edit_mesh_lib.glsl index 420d5cff6a1..ad2dcb51ca8 100644 --- a/source/blender/draw/engines/overlay/shaders/overlay_edit_mesh_lib.glsl +++ b/source/blender/draw/engines/overlay/shaders/overlay_edit_mesh_lib.glsl @@ -4,8 +4,8 @@ #pragma once -#include "common_view_clipping_lib.glsl" #include "draw_model_lib.glsl" +#include "draw_view_clipping_lib.glsl" #include "draw_view_lib.glsl" #include "gpu_shader_math_vector_lib.glsl" #include "gpu_shader_utildefines_lib.glsl" diff --git a/source/blender/draw/engines/overlay/shaders/overlay_edit_mesh_normal_vert.glsl b/source/blender/draw/engines/overlay/shaders/overlay_edit_mesh_normal_vert.glsl index af09892f193..532597cea2a 100644 --- a/source/blender/draw/engines/overlay/shaders/overlay_edit_mesh_normal_vert.glsl +++ b/source/blender/draw/engines/overlay/shaders/overlay_edit_mesh_normal_vert.glsl @@ -2,8 +2,8 @@ * * SPDX-License-Identifier: GPL-2.0-or-later */ -#include "common_view_clipping_lib.glsl" #include "draw_model_lib.glsl" +#include "draw_view_clipping_lib.glsl" #include "draw_view_lib.glsl" #include "gpu_shader_attribute_load_lib.glsl" #include "gpu_shader_index_load_lib.glsl" diff --git a/source/blender/draw/engines/overlay/shaders/overlay_edit_mesh_skin_root_vert.glsl b/source/blender/draw/engines/overlay/shaders/overlay_edit_mesh_skin_root_vert.glsl index 6a825c8a4d0..e31ea2de57e 100644 --- a/source/blender/draw/engines/overlay/shaders/overlay_edit_mesh_skin_root_vert.glsl +++ b/source/blender/draw/engines/overlay/shaders/overlay_edit_mesh_skin_root_vert.glsl @@ -2,8 +2,8 @@ * * SPDX-License-Identifier: GPL-2.0-or-later */ -#include "common_view_clipping_lib.glsl" #include "draw_model_lib.glsl" +#include "draw_view_clipping_lib.glsl" #include "draw_view_lib.glsl" #include "gpu_shader_math_base_lib.glsl" diff --git a/source/blender/draw/engines/overlay/shaders/overlay_edit_mesh_vert.glsl b/source/blender/draw/engines/overlay/shaders/overlay_edit_mesh_vert.glsl index b103de295b4..1da952f863b 100644 --- a/source/blender/draw/engines/overlay/shaders/overlay_edit_mesh_vert.glsl +++ b/source/blender/draw/engines/overlay/shaders/overlay_edit_mesh_vert.glsl @@ -2,8 +2,8 @@ * * SPDX-License-Identifier: GPL-2.0-or-later */ -#include "common_view_clipping_lib.glsl" #include "draw_model_lib.glsl" +#include "draw_view_clipping_lib.glsl" #include "draw_view_lib.glsl" #include "overlay_common_lib.glsl" #include "overlay_edit_mesh_common_lib.glsl" diff --git a/source/blender/draw/engines/overlay/shaders/overlay_edit_particle_point_vert.glsl b/source/blender/draw/engines/overlay/shaders/overlay_edit_particle_point_vert.glsl index 0373b00bdb5..ae4f700b095 100644 --- a/source/blender/draw/engines/overlay/shaders/overlay_edit_particle_point_vert.glsl +++ b/source/blender/draw/engines/overlay/shaders/overlay_edit_particle_point_vert.glsl @@ -2,8 +2,8 @@ * * SPDX-License-Identifier: GPL-2.0-or-later */ -#include "common_view_clipping_lib.glsl" #include "draw_model_lib.glsl" +#include "draw_view_clipping_lib.glsl" #include "draw_view_lib.glsl" #define no_active_weight 666.0 diff --git a/source/blender/draw/engines/overlay/shaders/overlay_edit_particle_strand_vert.glsl b/source/blender/draw/engines/overlay/shaders/overlay_edit_particle_strand_vert.glsl index 0f6cd4a80f7..311f7758338 100644 --- a/source/blender/draw/engines/overlay/shaders/overlay_edit_particle_strand_vert.glsl +++ b/source/blender/draw/engines/overlay/shaders/overlay_edit_particle_strand_vert.glsl @@ -2,8 +2,8 @@ * * SPDX-License-Identifier: GPL-2.0-or-later */ -#include "common_view_clipping_lib.glsl" #include "draw_model_lib.glsl" +#include "draw_view_clipping_lib.glsl" #include "draw_view_lib.glsl" #define no_active_weight 666.0 diff --git a/source/blender/draw/engines/overlay/shaders/overlay_extra_groundline_vert.glsl b/source/blender/draw/engines/overlay/shaders/overlay_extra_groundline_vert.glsl index 9e7513021f3..a11c12e058e 100644 --- a/source/blender/draw/engines/overlay/shaders/overlay_extra_groundline_vert.glsl +++ b/source/blender/draw/engines/overlay/shaders/overlay_extra_groundline_vert.glsl @@ -2,7 +2,7 @@ * * SPDX-License-Identifier: GPL-2.0-or-later */ -#include "common_view_clipping_lib.glsl" +#include "draw_view_clipping_lib.glsl" #include "draw_view_lib.glsl" #include "overlay_common_lib.glsl" #include "select_lib.glsl" diff --git a/source/blender/draw/engines/overlay/shaders/overlay_extra_lightprobe_grid_vert.glsl b/source/blender/draw/engines/overlay/shaders/overlay_extra_lightprobe_grid_vert.glsl index 04e0b2d4151..a29a5314593 100644 --- a/source/blender/draw/engines/overlay/shaders/overlay_extra_lightprobe_grid_vert.glsl +++ b/source/blender/draw/engines/overlay/shaders/overlay_extra_lightprobe_grid_vert.glsl @@ -2,8 +2,8 @@ * * SPDX-License-Identifier: GPL-2.0-or-later */ -#include "common_view_clipping_lib.glsl" #include "draw_model_lib.glsl" +#include "draw_view_clipping_lib.glsl" #include "draw_view_lib.glsl" #include "select_lib.glsl" diff --git a/source/blender/draw/engines/overlay/shaders/overlay_extra_loose_point_vert.glsl b/source/blender/draw/engines/overlay/shaders/overlay_extra_loose_point_vert.glsl index 12424eb9c54..fb7b60bf001 100644 --- a/source/blender/draw/engines/overlay/shaders/overlay_extra_loose_point_vert.glsl +++ b/source/blender/draw/engines/overlay/shaders/overlay_extra_loose_point_vert.glsl @@ -2,8 +2,8 @@ * * SPDX-License-Identifier: GPL-2.0-or-later */ -#include "common_view_clipping_lib.glsl" #include "draw_model_lib.glsl" +#include "draw_view_clipping_lib.glsl" #include "draw_view_lib.glsl" void main() diff --git a/source/blender/draw/engines/overlay/shaders/overlay_extra_point_vert.glsl b/source/blender/draw/engines/overlay/shaders/overlay_extra_point_vert.glsl index 6102ab19507..ad3436eaa61 100644 --- a/source/blender/draw/engines/overlay/shaders/overlay_extra_point_vert.glsl +++ b/source/blender/draw/engines/overlay/shaders/overlay_extra_point_vert.glsl @@ -2,8 +2,8 @@ * * SPDX-License-Identifier: GPL-2.0-or-later */ -#include "common_view_clipping_lib.glsl" #include "draw_model_lib.glsl" +#include "draw_view_clipping_lib.glsl" #include "draw_view_lib.glsl" #include "select_lib.glsl" diff --git a/source/blender/draw/engines/overlay/shaders/overlay_extra_vert.glsl b/source/blender/draw/engines/overlay/shaders/overlay_extra_vert.glsl index 16d2d41c16c..4aba3d17c93 100644 --- a/source/blender/draw/engines/overlay/shaders/overlay_extra_vert.glsl +++ b/source/blender/draw/engines/overlay/shaders/overlay_extra_vert.glsl @@ -2,7 +2,7 @@ * * SPDX-License-Identifier: GPL-2.0-or-later */ -#include "common_view_clipping_lib.glsl" +#include "draw_view_clipping_lib.glsl" #include "draw_view_lib.glsl" #include "overlay_common_lib.glsl" #include "select_lib.glsl" diff --git a/source/blender/draw/engines/overlay/shaders/overlay_extra_wire_vert.glsl b/source/blender/draw/engines/overlay/shaders/overlay_extra_wire_vert.glsl index f22556ff50a..5fa681ea577 100644 --- a/source/blender/draw/engines/overlay/shaders/overlay_extra_wire_vert.glsl +++ b/source/blender/draw/engines/overlay/shaders/overlay_extra_wire_vert.glsl @@ -2,8 +2,8 @@ * * SPDX-License-Identifier: GPL-2.0-or-later */ -#include "common_view_clipping_lib.glsl" #include "draw_model_lib.glsl" +#include "draw_view_clipping_lib.glsl" #include "draw_view_lib.glsl" #include "select_lib.glsl" diff --git a/source/blender/draw/engines/overlay/shaders/overlay_facing_vert.glsl b/source/blender/draw/engines/overlay/shaders/overlay_facing_vert.glsl index e937fb19f73..e3565b17f62 100644 --- a/source/blender/draw/engines/overlay/shaders/overlay_facing_vert.glsl +++ b/source/blender/draw/engines/overlay/shaders/overlay_facing_vert.glsl @@ -2,8 +2,8 @@ * * SPDX-License-Identifier: GPL-2.0-or-later */ -#include "common_view_clipping_lib.glsl" #include "draw_model_lib.glsl" +#include "draw_view_clipping_lib.glsl" #include "draw_view_lib.glsl" void main() diff --git a/source/blender/draw/engines/overlay/shaders/overlay_image_vert.glsl b/source/blender/draw/engines/overlay/shaders/overlay_image_vert.glsl index 6878c191566..79f769a4b6f 100644 --- a/source/blender/draw/engines/overlay/shaders/overlay_image_vert.glsl +++ b/source/blender/draw/engines/overlay/shaders/overlay_image_vert.glsl @@ -2,8 +2,8 @@ * * SPDX-License-Identifier: GPL-2.0-or-later */ -#include "common_view_clipping_lib.glsl" #include "draw_model_lib.glsl" +#include "draw_view_clipping_lib.glsl" #include "draw_view_lib.glsl" #include "select_lib.glsl" diff --git a/source/blender/draw/engines/overlay/shaders/overlay_motion_path_line_vert.glsl b/source/blender/draw/engines/overlay/shaders/overlay_motion_path_line_vert.glsl index 50c33944214..94e84749d24 100644 --- a/source/blender/draw/engines/overlay/shaders/overlay_motion_path_line_vert.glsl +++ b/source/blender/draw/engines/overlay/shaders/overlay_motion_path_line_vert.glsl @@ -2,7 +2,7 @@ * * SPDX-License-Identifier: GPL-2.0-or-later */ -#include "common_view_clipping_lib.glsl" +#include "draw_view_clipping_lib.glsl" #include "draw_view_lib.glsl" #include "gpu_shader_attribute_load_lib.glsl" diff --git a/source/blender/draw/engines/overlay/shaders/overlay_motion_path_point_vert.glsl b/source/blender/draw/engines/overlay/shaders/overlay_motion_path_point_vert.glsl index 2eeb7aa6768..66161e11c78 100644 --- a/source/blender/draw/engines/overlay/shaders/overlay_motion_path_point_vert.glsl +++ b/source/blender/draw/engines/overlay/shaders/overlay_motion_path_point_vert.glsl @@ -2,7 +2,7 @@ * * SPDX-License-Identifier: GPL-2.0-or-later */ -#include "common_view_clipping_lib.glsl" +#include "draw_view_clipping_lib.glsl" #include "draw_view_lib.glsl" #define pointSize mpathPointSettings.x diff --git a/source/blender/draw/engines/overlay/shaders/overlay_outline_prepass_curves_vert.glsl b/source/blender/draw/engines/overlay/shaders/overlay_outline_prepass_curves_vert.glsl index 223f5721cfc..6b42ada23cf 100644 --- a/source/blender/draw/engines/overlay/shaders/overlay_outline_prepass_curves_vert.glsl +++ b/source/blender/draw/engines/overlay/shaders/overlay_outline_prepass_curves_vert.glsl @@ -3,8 +3,8 @@ * SPDX-License-Identifier: GPL-2.0-or-later */ #include "common_hair_lib.glsl" -#include "common_view_clipping_lib.glsl" #include "draw_model_lib.glsl" +#include "draw_view_clipping_lib.glsl" #include "draw_view_lib.glsl" #include "gpu_shader_utildefines_lib.glsl" diff --git a/source/blender/draw/engines/overlay/shaders/overlay_outline_prepass_gpencil_vert.glsl b/source/blender/draw/engines/overlay/shaders/overlay_outline_prepass_gpencil_vert.glsl index ed2a262e998..f1c5520cfcf 100644 --- a/source/blender/draw/engines/overlay/shaders/overlay_outline_prepass_gpencil_vert.glsl +++ b/source/blender/draw/engines/overlay/shaders/overlay_outline_prepass_gpencil_vert.glsl @@ -3,8 +3,8 @@ * SPDX-License-Identifier: GPL-2.0-or-later */ #include "common_gpencil_lib.glsl" -#include "common_view_clipping_lib.glsl" #include "draw_model_lib.glsl" +#include "draw_view_clipping_lib.glsl" #include "draw_view_lib.glsl" uint outline_colorid_get() diff --git a/source/blender/draw/engines/overlay/shaders/overlay_outline_prepass_pointcloud_vert.glsl b/source/blender/draw/engines/overlay/shaders/overlay_outline_prepass_pointcloud_vert.glsl index dc10de41985..651e484d6e6 100644 --- a/source/blender/draw/engines/overlay/shaders/overlay_outline_prepass_pointcloud_vert.glsl +++ b/source/blender/draw/engines/overlay/shaders/overlay_outline_prepass_pointcloud_vert.glsl @@ -3,8 +3,8 @@ * SPDX-License-Identifier: GPL-2.0-or-later */ #include "common_pointcloud_lib.glsl" -#include "common_view_clipping_lib.glsl" #include "draw_model_lib.glsl" +#include "draw_view_clipping_lib.glsl" #include "draw_view_lib.glsl" #include "gpu_shader_utildefines_lib.glsl" diff --git a/source/blender/draw/engines/overlay/shaders/overlay_outline_prepass_vert.glsl b/source/blender/draw/engines/overlay/shaders/overlay_outline_prepass_vert.glsl index f10c8450c49..50312f3242b 100644 --- a/source/blender/draw/engines/overlay/shaders/overlay_outline_prepass_vert.glsl +++ b/source/blender/draw/engines/overlay/shaders/overlay_outline_prepass_vert.glsl @@ -2,8 +2,8 @@ * * SPDX-License-Identifier: GPL-2.0-or-later */ -#include "common_view_clipping_lib.glsl" #include "draw_model_lib.glsl" +#include "draw_view_clipping_lib.glsl" #include "draw_view_lib.glsl" #include "gpu_shader_utildefines_lib.glsl" diff --git a/source/blender/draw/engines/overlay/shaders/overlay_outline_prepass_wire_vert.glsl b/source/blender/draw/engines/overlay/shaders/overlay_outline_prepass_wire_vert.glsl index f1f12148b98..f2d7d4317c6 100644 --- a/source/blender/draw/engines/overlay/shaders/overlay_outline_prepass_wire_vert.glsl +++ b/source/blender/draw/engines/overlay/shaders/overlay_outline_prepass_wire_vert.glsl @@ -2,8 +2,8 @@ * * SPDX-License-Identifier: GPL-2.0-or-later */ -#include "common_view_clipping_lib.glsl" #include "draw_model_lib.glsl" +#include "draw_view_clipping_lib.glsl" #include "draw_view_lib.glsl" #include "gpu_shader_attribute_load_lib.glsl" #include "gpu_shader_index_load_lib.glsl" diff --git a/source/blender/draw/engines/overlay/shaders/overlay_paint_face_vert.glsl b/source/blender/draw/engines/overlay/shaders/overlay_paint_face_vert.glsl index 7263fc2b296..93aa78c8040 100644 --- a/source/blender/draw/engines/overlay/shaders/overlay_paint_face_vert.glsl +++ b/source/blender/draw/engines/overlay/shaders/overlay_paint_face_vert.glsl @@ -2,8 +2,8 @@ * * SPDX-License-Identifier: GPL-2.0-or-later */ -#include "common_view_clipping_lib.glsl" #include "draw_model_lib.glsl" +#include "draw_view_clipping_lib.glsl" #include "draw_view_lib.glsl" void main() diff --git a/source/blender/draw/engines/overlay/shaders/overlay_paint_point_vert.glsl b/source/blender/draw/engines/overlay/shaders/overlay_paint_point_vert.glsl index f1987f01e69..2d7b5c7fd18 100644 --- a/source/blender/draw/engines/overlay/shaders/overlay_paint_point_vert.glsl +++ b/source/blender/draw/engines/overlay/shaders/overlay_paint_point_vert.glsl @@ -2,8 +2,8 @@ * * SPDX-License-Identifier: GPL-2.0-or-later */ -#include "common_view_clipping_lib.glsl" #include "draw_model_lib.glsl" +#include "draw_view_clipping_lib.glsl" #include "draw_view_lib.glsl" void main() diff --git a/source/blender/draw/engines/overlay/shaders/overlay_paint_texture_vert.glsl b/source/blender/draw/engines/overlay/shaders/overlay_paint_texture_vert.glsl index 37647897e3d..e14b4b50602 100644 --- a/source/blender/draw/engines/overlay/shaders/overlay_paint_texture_vert.glsl +++ b/source/blender/draw/engines/overlay/shaders/overlay_paint_texture_vert.glsl @@ -2,8 +2,8 @@ * * SPDX-License-Identifier: GPL-2.0-or-later */ -#include "common_view_clipping_lib.glsl" #include "draw_model_lib.glsl" +#include "draw_view_clipping_lib.glsl" #include "draw_view_lib.glsl" void main() diff --git a/source/blender/draw/engines/overlay/shaders/overlay_paint_weight_vert.glsl b/source/blender/draw/engines/overlay/shaders/overlay_paint_weight_vert.glsl index 1cf4cafb0f1..519673f4cda 100644 --- a/source/blender/draw/engines/overlay/shaders/overlay_paint_weight_vert.glsl +++ b/source/blender/draw/engines/overlay/shaders/overlay_paint_weight_vert.glsl @@ -2,8 +2,8 @@ * * SPDX-License-Identifier: GPL-2.0-or-later */ -#include "common_view_clipping_lib.glsl" #include "draw_model_lib.glsl" +#include "draw_view_clipping_lib.glsl" #include "draw_view_lib.glsl" void main() diff --git a/source/blender/draw/engines/overlay/shaders/overlay_paint_wire_vert.glsl b/source/blender/draw/engines/overlay/shaders/overlay_paint_wire_vert.glsl index 38e14a4bcfa..421511e1743 100644 --- a/source/blender/draw/engines/overlay/shaders/overlay_paint_wire_vert.glsl +++ b/source/blender/draw/engines/overlay/shaders/overlay_paint_wire_vert.glsl @@ -2,8 +2,8 @@ * * SPDX-License-Identifier: GPL-2.0-or-later */ -#include "common_view_clipping_lib.glsl" #include "draw_model_lib.glsl" +#include "draw_view_clipping_lib.glsl" #include "draw_view_lib.glsl" void main() diff --git a/source/blender/draw/engines/overlay/shaders/overlay_particle_hair_vert.glsl b/source/blender/draw/engines/overlay/shaders/overlay_particle_hair_vert.glsl index c81375e3061..7a496a816f5 100644 --- a/source/blender/draw/engines/overlay/shaders/overlay_particle_hair_vert.glsl +++ b/source/blender/draw/engines/overlay/shaders/overlay_particle_hair_vert.glsl @@ -6,8 +6,8 @@ * Draw particles as shapes using primitive expansion. */ -#include "common_view_clipping_lib.glsl" #include "draw_model_lib.glsl" +#include "draw_view_clipping_lib.glsl" #include "draw_view_lib.glsl" #include "gpu_shader_math_base_lib.glsl" #include "gpu_shader_utildefines_lib.glsl" diff --git a/source/blender/draw/engines/overlay/shaders/overlay_particle_shape_vert.glsl b/source/blender/draw/engines/overlay/shaders/overlay_particle_shape_vert.glsl index c302cd988cb..c8806f583a8 100644 --- a/source/blender/draw/engines/overlay/shaders/overlay_particle_shape_vert.glsl +++ b/source/blender/draw/engines/overlay/shaders/overlay_particle_shape_vert.glsl @@ -6,7 +6,7 @@ * Draw particles as shapes using primitive expansion. */ -#include "common_view_clipping_lib.glsl" +#include "draw_view_clipping_lib.glsl" #include "draw_view_lib.glsl" #include "gpu_shader_math_matrix_lib.glsl" #include "select_lib.glsl" diff --git a/source/blender/draw/engines/overlay/shaders/overlay_particle_vert.glsl b/source/blender/draw/engines/overlay/shaders/overlay_particle_vert.glsl index 3d1bddd1093..68dc7b4aca8 100644 --- a/source/blender/draw/engines/overlay/shaders/overlay_particle_vert.glsl +++ b/source/blender/draw/engines/overlay/shaders/overlay_particle_vert.glsl @@ -2,7 +2,7 @@ * * SPDX-License-Identifier: GPL-2.0-or-later */ -#include "common_view_clipping_lib.glsl" +#include "draw_view_clipping_lib.glsl" #include "draw_view_lib.glsl" #include "select_lib.glsl" diff --git a/source/blender/draw/engines/overlay/shaders/overlay_sculpt_curves_cage_vert.glsl b/source/blender/draw/engines/overlay/shaders/overlay_sculpt_curves_cage_vert.glsl index 6284b3db84c..9f3e46076c1 100644 --- a/source/blender/draw/engines/overlay/shaders/overlay_sculpt_curves_cage_vert.glsl +++ b/source/blender/draw/engines/overlay/shaders/overlay_sculpt_curves_cage_vert.glsl @@ -2,8 +2,8 @@ * * SPDX-License-Identifier: GPL-2.0-or-later */ -#include "common_view_clipping_lib.glsl" #include "draw_model_lib.glsl" +#include "draw_view_clipping_lib.glsl" #include "draw_view_lib.glsl" void main() diff --git a/source/blender/draw/engines/overlay/shaders/overlay_sculpt_curves_selection_vert.glsl b/source/blender/draw/engines/overlay/shaders/overlay_sculpt_curves_selection_vert.glsl index 4843b1ee421..700ea66749c 100644 --- a/source/blender/draw/engines/overlay/shaders/overlay_sculpt_curves_selection_vert.glsl +++ b/source/blender/draw/engines/overlay/shaders/overlay_sculpt_curves_selection_vert.glsl @@ -3,8 +3,8 @@ * SPDX-License-Identifier: GPL-2.0-or-later */ #include "common_hair_lib.glsl" -#include "common_view_clipping_lib.glsl" #include "draw_model_lib.glsl" +#include "draw_view_clipping_lib.glsl" #include "draw_view_lib.glsl" float retrieve_selection() diff --git a/source/blender/draw/engines/overlay/shaders/overlay_sculpt_mask_vert.glsl b/source/blender/draw/engines/overlay/shaders/overlay_sculpt_mask_vert.glsl index 915899b982b..113074bce22 100644 --- a/source/blender/draw/engines/overlay/shaders/overlay_sculpt_mask_vert.glsl +++ b/source/blender/draw/engines/overlay/shaders/overlay_sculpt_mask_vert.glsl @@ -2,8 +2,8 @@ * * SPDX-License-Identifier: GPL-2.0-or-later */ -#include "common_view_clipping_lib.glsl" #include "draw_model_lib.glsl" +#include "draw_view_clipping_lib.glsl" #include "draw_view_lib.glsl" void main() diff --git a/source/blender/draw/engines/overlay/shaders/overlay_viewer_attribute_curve_vert.glsl b/source/blender/draw/engines/overlay/shaders/overlay_viewer_attribute_curve_vert.glsl index 7c123d48185..aa761d20fe5 100644 --- a/source/blender/draw/engines/overlay/shaders/overlay_viewer_attribute_curve_vert.glsl +++ b/source/blender/draw/engines/overlay/shaders/overlay_viewer_attribute_curve_vert.glsl @@ -2,8 +2,8 @@ * * SPDX-License-Identifier: GPL-2.0-or-later */ -#include "common_view_clipping_lib.glsl" #include "draw_model_lib.glsl" +#include "draw_view_clipping_lib.glsl" #include "draw_view_lib.glsl" void main() diff --git a/source/blender/draw/engines/overlay/shaders/overlay_viewer_attribute_curves_vert.glsl b/source/blender/draw/engines/overlay/shaders/overlay_viewer_attribute_curves_vert.glsl index 6a0cf9c8c0e..0df7bb6c556 100644 --- a/source/blender/draw/engines/overlay/shaders/overlay_viewer_attribute_curves_vert.glsl +++ b/source/blender/draw/engines/overlay/shaders/overlay_viewer_attribute_curves_vert.glsl @@ -3,8 +3,8 @@ * SPDX-License-Identifier: GPL-2.0-or-later */ #include "common_hair_lib.glsl" -#include "common_view_clipping_lib.glsl" #include "draw_model_lib.glsl" +#include "draw_view_clipping_lib.glsl" #include "draw_view_lib.glsl" void main() diff --git a/source/blender/draw/engines/overlay/shaders/overlay_viewer_attribute_mesh_vert.glsl b/source/blender/draw/engines/overlay/shaders/overlay_viewer_attribute_mesh_vert.glsl index 7c123d48185..aa761d20fe5 100644 --- a/source/blender/draw/engines/overlay/shaders/overlay_viewer_attribute_mesh_vert.glsl +++ b/source/blender/draw/engines/overlay/shaders/overlay_viewer_attribute_mesh_vert.glsl @@ -2,8 +2,8 @@ * * SPDX-License-Identifier: GPL-2.0-or-later */ -#include "common_view_clipping_lib.glsl" #include "draw_model_lib.glsl" +#include "draw_view_clipping_lib.glsl" #include "draw_view_lib.glsl" void main() diff --git a/source/blender/draw/engines/overlay/shaders/overlay_viewer_attribute_pointcloud_vert.glsl b/source/blender/draw/engines/overlay/shaders/overlay_viewer_attribute_pointcloud_vert.glsl index a23332cc3b5..14f5f37e3c4 100644 --- a/source/blender/draw/engines/overlay/shaders/overlay_viewer_attribute_pointcloud_vert.glsl +++ b/source/blender/draw/engines/overlay/shaders/overlay_viewer_attribute_pointcloud_vert.glsl @@ -3,8 +3,8 @@ * SPDX-License-Identifier: GPL-2.0-or-later */ #include "common_pointcloud_lib.glsl" -#include "common_view_clipping_lib.glsl" #include "draw_model_lib.glsl" +#include "draw_view_clipping_lib.glsl" #include "draw_view_lib.glsl" void main() diff --git a/source/blender/draw/engines/overlay/shaders/overlay_wireframe_vert.glsl b/source/blender/draw/engines/overlay/shaders/overlay_wireframe_vert.glsl index 93808fa8244..89695daadff 100644 --- a/source/blender/draw/engines/overlay/shaders/overlay_wireframe_vert.glsl +++ b/source/blender/draw/engines/overlay/shaders/overlay_wireframe_vert.glsl @@ -2,8 +2,8 @@ * * SPDX-License-Identifier: GPL-2.0-or-later */ -#include "common_view_clipping_lib.glsl" #include "draw_model_lib.glsl" +#include "draw_view_clipping_lib.glsl" #include "draw_view_lib.glsl" #include "gpu_shader_utildefines_lib.glsl" #include "overlay_common_lib.glsl" diff --git a/source/blender/draw/intern/shaders/common_view_clipping_lib.glsl b/source/blender/draw/intern/shaders/common_view_clipping_lib.glsl deleted file mode 100644 index c082ba68fd9..00000000000 --- a/source/blender/draw/intern/shaders/common_view_clipping_lib.glsl +++ /dev/null @@ -1,48 +0,0 @@ -/* SPDX-FileCopyrightText: 2022-2023 Blender Authors - * - * SPDX-License-Identifier: GPL-2.0-or-later */ - -#pragma once - -#if defined(GPU_VERTEX_SHADER) || defined(GPU_GEOMETRY_SHADER) - -void view_clipping_distances(vec3 wpos) -{ -# ifdef USE_WORLD_CLIP_PLANES - vec4 pos_4d = vec4(wpos, 1.0); - gl_ClipDistance[0] = dot(globalsBlock.clip_planes[0], pos_4d); - gl_ClipDistance[1] = dot(globalsBlock.clip_planes[1], pos_4d); - gl_ClipDistance[2] = dot(globalsBlock.clip_planes[2], pos_4d); - gl_ClipDistance[3] = dot(globalsBlock.clip_planes[3], pos_4d); - gl_ClipDistance[4] = dot(globalsBlock.clip_planes[4], pos_4d); - gl_ClipDistance[5] = dot(globalsBlock.clip_planes[5], pos_4d); -# endif -} - -void view_clipping_distances_bypass() -{ -# ifdef USE_WORLD_CLIP_PLANES - gl_ClipDistance[0] = 1.0; - gl_ClipDistance[1] = 1.0; - gl_ClipDistance[2] = 1.0; - gl_ClipDistance[3] = 1.0; - gl_ClipDistance[4] = 1.0; - gl_ClipDistance[5] = 1.0; -# endif -} - -/* Kept as define for compiler compatibility. */ -# ifdef USE_WORLD_CLIP_PLANES -# define view_clipping_distances_set(c) \ - gl_ClipDistance[0] = (c).gl_ClipDistance[0]; \ - gl_ClipDistance[1] = (c).gl_ClipDistance[1]; \ - gl_ClipDistance[2] = (c).gl_ClipDistance[2]; \ - gl_ClipDistance[3] = (c).gl_ClipDistance[3]; \ - gl_ClipDistance[4] = (c).gl_ClipDistance[4]; \ - gl_ClipDistance[5] = (c).gl_ClipDistance[5]; - -# else -# define view_clipping_distances_set(c) -# endif - -#endif diff --git a/source/blender/draw/intern/shaders/draw_view_clipping_lib.glsl b/source/blender/draw/intern/shaders/draw_view_clipping_lib.glsl index 81afa320e72..cd66dbedea0 100644 --- a/source/blender/draw/intern/shaders/draw_view_clipping_lib.glsl +++ b/source/blender/draw/intern/shaders/draw_view_clipping_lib.glsl @@ -4,8 +4,6 @@ #pragma once -#include "draw_view_info.hh" - #if defined(GPU_VERTEX_SHADER) || defined(GPU_GEOMETRY_SHADER) VERTEX_SHADER_CREATE_INFO(drw_clipped) @@ -14,21 +12,12 @@ void view_clipping_distances(vec3 wpos) { # ifdef USE_WORLD_CLIP_PLANES vec4 pos_4d = vec4(wpos, 1.0); -# ifdef OVERLAY_NEXT - gl_ClipDistance[0] = dot(globalsBlock.clip_planes[0], pos_4d); - gl_ClipDistance[1] = dot(globalsBlock.clip_planes[1], pos_4d); - gl_ClipDistance[2] = dot(globalsBlock.clip_planes[2], pos_4d); - gl_ClipDistance[3] = dot(globalsBlock.clip_planes[3], pos_4d); - gl_ClipDistance[4] = dot(globalsBlock.clip_planes[4], pos_4d); - gl_ClipDistance[5] = dot(globalsBlock.clip_planes[5], pos_4d); -# else gl_ClipDistance[0] = dot(drw_clipping_[0], pos_4d); gl_ClipDistance[1] = dot(drw_clipping_[1], pos_4d); gl_ClipDistance[2] = dot(drw_clipping_[2], pos_4d); gl_ClipDistance[3] = dot(drw_clipping_[3], pos_4d); gl_ClipDistance[4] = dot(drw_clipping_[4], pos_4d); gl_ClipDistance[5] = dot(drw_clipping_[5], pos_4d); -# endif # endif } From 9c374fbb935befe274f088b7e12f349883a0177a Mon Sep 17 00:00:00 2001 From: Harley Acheson Date: Wed, 19 Feb 2025 19:25:14 +0100 Subject: [PATCH 23/31] UI: Skip Internal Operators For Idle Status Bar During idle time, just moving your mouse into an editor, the Status Bar only shows operations attached to mouse events. Hovering into Properties shows an item on the left mouse called "Set Active Modifier". This is always shown because it is an internal operator always running in that area. This PR just skips OPTYPE_INTERNAL operators for this idle display. Pull Request: https://projects.blender.org/blender/blender/pulls/134782 --- source/blender/windowmanager/intern/wm_event_system.cc | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/source/blender/windowmanager/intern/wm_event_system.cc b/source/blender/windowmanager/intern/wm_event_system.cc index 3aec66efc8b..02ab952de22 100644 --- a/source/blender/windowmanager/intern/wm_event_system.cc +++ b/source/blender/windowmanager/intern/wm_event_system.cc @@ -6596,6 +6596,10 @@ void WM_window_cursor_keymap_status_refresh(bContext *C, wmWindow *win) name = TIP_("Options"); } else if (ot) { + /* Skip internal operators. */ + if (ot->flag & OPTYPE_INTERNAL) { + continue; + } name = WM_operatortype_name(ot, kmi->ptr); } else { From 0425940794e64d8e6ce309d82f59896936d1b207 Mon Sep 17 00:00:00 2001 From: Harley Acheson Date: Wed, 19 Feb 2025 20:03:55 +0100 Subject: [PATCH 24/31] Fix #134630: Do Not Set Area Subtype For Previously Stored Editors When changing editors within an area we are currently always setting the subtype if there are modes. This causes problems when returning to a previous editor versus starting with the correct one. We have tried various ways of returning to the old editor, but never quite works. This PR only sets the subtype if we are creating a new area. If not just leave it as it was so we naturally return to its old state. Pull Request: https://projects.blender.org/blender/blender/pulls/134642 --- source/blender/editors/screen/area.cc | 9 ++++++--- 1 file changed, 6 insertions(+), 3 deletions(-) diff --git a/source/blender/editors/screen/area.cc b/source/blender/editors/screen/area.cc index f370fe9b74b..23f37fb8495 100644 --- a/source/blender/editors/screen/area.cc +++ b/source/blender/editors/screen/area.cc @@ -2601,6 +2601,9 @@ void ED_area_newspace(bContext *C, ScrArea *area, int type, const bool skip_regi wmWindow *win = CTX_wm_window(C); SpaceType *st = BKE_spacetype_from_id(type); + /* Are we reusing a space already stored in this area? */ + bool is_restored_space = false; + if (area->spacetype != type) { SpaceLink *slold = static_cast(area->spacedata.first); /* store area->type->exit callback */ @@ -2664,6 +2667,7 @@ void ED_area_newspace(bContext *C, ScrArea *area, int type, const bool skip_regi if (sl) { /* swap regions */ + is_restored_space = true; slold->regionbase = area->regionbase; area->regionbase = sl->regionbase; BLI_listbase_clear(&sl->regionbase); @@ -2709,11 +2713,10 @@ void ED_area_newspace(bContext *C, ScrArea *area, int type, const bool skip_regi ED_area_tag_refresh(area); } - /* Set area space subtype if applicable. */ - if (st->space_subtype_item_extend != nullptr) { + /* Set area space subtype if applicable and newly created. */ + if (!is_restored_space && st && st->space_subtype_item_extend != nullptr) { st->space_subtype_set(area, area->butspacetype_subtype); } - area->butspacetype_subtype = 0; if (BLI_listbase_is_single(&CTX_wm_screen(C)->areabase)) { /* If there is only one area update the window title. */ From 2e90aace03b3a4fbb855f085042a38d45379bf51 Mon Sep 17 00:00:00 2001 From: Harley Acheson Date: Wed, 19 Feb 2025 20:24:33 +0100 Subject: [PATCH 25/31] Fix #134796: Adjust Error Theme Color for Widget Text When using the Error theme color for widget text color, this has to be altered to provide sufficient contrast with other content. This was done with label text color, before recent changes to make these colors themeable, by blending with text color. This PR makes similar changes and gives similar results. Pull Request: https://projects.blender.org/blender/blender/pulls/134807 --- source/blender/editors/interface/interface_widgets.cc | 10 ++++++++-- 1 file changed, 8 insertions(+), 2 deletions(-) diff --git a/source/blender/editors/interface/interface_widgets.cc b/source/blender/editors/interface/interface_widgets.cc index 9b66d21a1a0..1f951177a3e 100644 --- a/source/blender/editors/interface/interface_widgets.cc +++ b/source/blender/editors/interface/interface_widgets.cc @@ -2541,7 +2541,10 @@ static void widget_state(uiWidgetType *wt, const uiWidgetStateInfo *state, eUIEm UI_GetThemeColor3ubv(TH_REDALERT, wt->wcol.inner); } else { - UI_GetThemeColor3ubv(TH_REDALERT, wt->wcol.text); + uchar red[4]; + UI_GetThemeColor3ubv(TH_REDALERT, red); + color_mul_hsl_v3(red, 1.0f, 1.5f, 1.5f); + color_blend_v3_v3(wt->wcol.text, red, 0.5f); } } @@ -4351,7 +4354,10 @@ static void widget_state_label(uiWidgetType *wt, } if (state->but_flag & UI_BUT_REDALERT) { - UI_GetThemeColor3ubv(TH_REDALERT, wt->wcol.text); + uchar red[4]; + UI_GetThemeColor3ubv(TH_REDALERT, red); + color_mul_hsl_v3(red, 1.0f, 1.5f, 1.5f); + color_blend_v3_v3(wt->wcol.text, red, 0.5f); } } From 24d9eedc15ff87c69707e13d413f87d216a7b2e9 Mon Sep 17 00:00:00 2001 From: IREXTIA Date: Wed, 19 Feb 2025 21:51:55 +0100 Subject: [PATCH 26/31] UI: Rename 'Inverse' to 'Invert' in File/Asset Browser Rename 'Inverse' to 'Invert' for consistency with other select menus. Pull Request: https://projects.blender.org/blender/blender/pulls/134514 --- scripts/startup/bl_ui/space_filebrowser.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/scripts/startup/bl_ui/space_filebrowser.py b/scripts/startup/bl_ui/space_filebrowser.py index dbb09499dc2..98d115b2291 100644 --- a/scripts/startup/bl_ui/space_filebrowser.py +++ b/scripts/startup/bl_ui/space_filebrowser.py @@ -529,7 +529,7 @@ def draw(self, _context): layout.operator("file.select_all", text="All").action = 'SELECT' layout.operator("file.select_all", text="None").action = 'DESELECT' - layout.operator("file.select_all", text="Inverse").action = 'INVERT' + layout.operator("file.select_all", text="Invert").action = 'INVERT' layout.separator() From 05c6446c386ef4b665cd92ec87cb123dd9930a79 Mon Sep 17 00:00:00 2001 From: Julian Eisel Date: Wed, 19 Feb 2025 21:53:15 +0100 Subject: [PATCH 27/31] Fix #128966: Update Dopesheet playhead in separate window The playhead is redrawn as an overlay, so instead of a full region redraw using `ARegionType.draw()`, at least an overlay only redraw using `ARegion.draw_overlay()` needs to be triggered. Any redrawing within a window is skipped if neither the screen, nor any of its areas or regions are tagged for redraw. So since there are no other areas or regions to be fully redrawn in this window, no redrawing will happen. The screen needs to be tagged for redraw, which will skip most drawing in this case, and just draw the overlays as wanted. Pull Request: https://projects.blender.org/blender/blender/pulls/134579 --- source/blender/editors/screen/screen_ops.cc | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/source/blender/editors/screen/screen_ops.cc b/source/blender/editors/screen/screen_ops.cc index 0993687ce4b..60dcf5dfa28 100644 --- a/source/blender/editors/screen/screen_ops.cc +++ b/source/blender/editors/screen/screen_ops.cc @@ -5554,7 +5554,7 @@ static int screen_animation_step_invoke(bContext *C, wmOperator * /*op*/, const } LISTBASE_FOREACH (wmWindow *, window, &wm->windows) { - const bScreen *win_screen = WM_window_get_active_screen(window); + bScreen *win_screen = WM_window_get_active_screen(window); LISTBASE_FOREACH (ScrArea *, area, &win_screen->areabase) { LISTBASE_FOREACH (ARegion *, region, &area->regionbase) { @@ -5573,6 +5573,9 @@ static int screen_animation_step_invoke(bContext *C, wmOperator * /*op*/, const if (redraw) { screen_animation_region_tag_redraw( C, area, region, scene, eScreen_Redraws_Flag(sad->redraws)); + /* Doesn't trigger a full redraw of the screeen but makes sure at least overlay drawing + * (#ARegionType.draw_overlay()) is triggered, which is how the playhead is drawn. */ + win_screen->do_draw = true; } } } From af8da338a0ee86f876eac4d06c4910a9d1002f0e Mon Sep 17 00:00:00 2001 From: Sean Kim Date: Wed, 19 Feb 2025 21:58:49 +0100 Subject: [PATCH 28/31] Fix #134770: Multires persistent base doesn't work randomly The previous attempt to restore this behavior was in 0a2d5d58013e579bf06c67d50b49497ce23ccbcb That commit introduced clearing the related `SculptSession` variables when the paint BVH was freed to avoid bad behaviors seen in 4.2 and prior. However, this solution is somewhat incorrect, as the prior state of this data is not necessarily restored when the BVH is recreated, unlike other temporary mapping data. This results in the persistent base data being cleared occasionally with no indication to the user that this is happening, causing the setting to appear to be inactive. To fix this, this commit makes a few changes: * Removes clearing this data in the `BKE_sculptsession_free_pbvh` function. * Initializes the displacement arrays to the same size as the position and normal array. * Introduce new variables to track the saved multires grid size so that it is not deleted, only considered invalid when the topology changes. Pull Request: https://projects.blender.org/blender/blender/pulls/134780 --- source/blender/blenkernel/BKE_paint.hh | 30 +++++++++++++++++-- source/blender/blenkernel/intern/paint.cc | 22 +++++++++++--- .../editors/sculpt_paint/brushes/layer.cc | 16 +++++----- .../editors/sculpt_paint/sculpt_cloth.cc | 6 ++-- .../editors/sculpt_paint/sculpt_ops.cc | 8 +++-- 5 files changed, 63 insertions(+), 19 deletions(-) diff --git a/source/blender/blenkernel/BKE_paint.hh b/source/blender/blenkernel/BKE_paint.hh index 1c3d2e56a3f..f580f28dd40 100644 --- a/source/blender/blenkernel/BKE_paint.hh +++ b/source/blender/blenkernel/BKE_paint.hh @@ -367,6 +367,13 @@ struct SculptTopologyIslandCache { using ActiveVert = std::variant; +/* Helper return struct for associated data. */ +struct PersistentMultiresData { + blender::Span positions; + blender::Span normals; + blender::MutableSpan displacements; +}; + struct SculptSession : blender::NonCopyable, blender::NonMovable { /* Mesh data (not copied) can come either directly from a Mesh, or from a MultiresDM */ struct { /* Special handling for multires meshes */ @@ -448,9 +455,17 @@ struct SculptSession : blender::NonCopyable, blender::NonMovable { /* "Persistent" positions and normals for multires. (For mesh the * ".sculpt_persistent_co" attribute is used, etc.). */ - blender::Array sculpt_persistent_co; - blender::Array sculpt_persistent_no; - blender::Array sculpt_persistent_disp; + struct { + blender::Array sculpt_persistent_co; + blender::Array sculpt_persistent_no; + blender::Array sculpt_persistent_disp; + + /* The stored state for the SubdivCCG at the time of attribute poulation, used to roughly + * determine if the topology when accessed at a current point in time is equivalent to when + * it was originally stored. */ + int grids_num = -1; + int grid_size = -1; + } persistent; SculptVertexInfo vertex_info = {}; SculptFakeNeighbors fake_neighbors = {}; @@ -554,6 +569,15 @@ struct SculptSession : blender::NonCopyable, blender::NonMovable { void set_active_vert(ActiveVert vert); void clear_active_vert(bool persist_last_active); + + /** + * Retrieves the current persistent multires data. + * + * Potentially used for the layer and cloth brushes. + * + * \returns an empty optional if the current data cannot be used + */ + std::optional persistent_multires_data(); }; void BKE_sculptsession_free(Object *ob); diff --git a/source/blender/blenkernel/intern/paint.cc b/source/blender/blenkernel/intern/paint.cc index 52500e6dcca..7bb2c56bb9e 100644 --- a/source/blender/blenkernel/intern/paint.cc +++ b/source/blender/blenkernel/intern/paint.cc @@ -2090,10 +2090,6 @@ void BKE_sculptsession_free_pbvh(Object &object) ss->fake_neighbors.fake_neighbor_index = {}; ss->topology_island_cache.reset(); - ss->sculpt_persistent_co = {}; - ss->sculpt_persistent_no = {}; - ss->sculpt_persistent_disp = {}; - ss->clear_active_vert(false); } @@ -2227,6 +2223,24 @@ void SculptSession::set_active_vert(const ActiveVert vert) active_vert_ = vert; } +std::optional SculptSession::persistent_multires_data() +{ + BLI_assert(subdiv_ccg); + if (persistent.grids_num == -1 || persistent.grid_size == -1) { + return std::nullopt; + } + + if (this->subdiv_ccg->grids_num != persistent.grids_num || + this->subdiv_ccg->grid_size != persistent.grid_size) + { + return std::nullopt; + } + + return PersistentMultiresData{persistent.sculpt_persistent_co, + persistent.sculpt_persistent_no, + persistent.sculpt_persistent_disp}; +} + static MultiresModifierData *sculpt_multires_modifier_get(const Scene *scene, Object *ob, const bool auto_create_mdisps) diff --git a/source/blender/editors/sculpt_paint/brushes/layer.cc b/source/blender/editors/sculpt_paint/brushes/layer.cc index fc6290cc1c1..6f3a6efe0b3 100644 --- a/source/blender/editors/sculpt_paint/brushes/layer.cc +++ b/source/blender/editors/sculpt_paint/brushes/layer.cc @@ -451,18 +451,20 @@ void do_layer_brush(const Depsgraph &depsgraph, SubdivCCG &subdiv_ccg = *object.sculpt->subdiv_ccg; MutableSpan positions = subdiv_ccg.positions; - const Span persistent_position = ss.sculpt_persistent_co; - const Span persistent_normal = ss.sculpt_persistent_no; + const std::optional persistent_multires_data = + ss.persistent_multires_data(); + + Span persistent_position; + Span persistent_normal; bool use_persistent_base = false; MutableSpan displacement; if (brush.flag & BRUSH_PERSISTENT) { - if (!persistent_position.is_empty() && !persistent_normal.is_empty()) { - if (ss.sculpt_persistent_disp.is_empty()) { - ss.sculpt_persistent_disp = Array(positions.size(), 0.0f); - } + if (persistent_multires_data) { use_persistent_base = true; - displacement = ss.sculpt_persistent_disp; + persistent_position = persistent_multires_data->positions; + persistent_normal = persistent_multires_data->normals; + displacement = persistent_multires_data->displacements; } } diff --git a/source/blender/editors/sculpt_paint/sculpt_cloth.cc b/source/blender/editors/sculpt_paint/sculpt_cloth.cc index 5be16acc0dc..e60aa0e664b 100644 --- a/source/blender/editors/sculpt_paint/sculpt_cloth.cc +++ b/source/blender/editors/sculpt_paint/sculpt_cloth.cc @@ -574,8 +574,10 @@ void ensure_nodes_constraints(const Sculpt &sd, Span init_positions; Span persistent_position; - if (brush != nullptr && brush->flag & BRUSH_PERSISTENT) { - persistent_position = ss.sculpt_persistent_co; + const std::optional persistent_multires_data = + ss.persistent_multires_data(); + if (brush != nullptr && brush->flag & BRUSH_PERSISTENT && persistent_multires_data) { + persistent_position = persistent_multires_data->positions; } if (persistent_position.is_empty()) { init_positions = cloth_sim.init_pos; diff --git a/source/blender/editors/sculpt_paint/sculpt_ops.cc b/source/blender/editors/sculpt_paint/sculpt_ops.cc index b7660a626df..c2b8dcc1533 100644 --- a/source/blender/editors/sculpt_paint/sculpt_ops.cc +++ b/source/blender/editors/sculpt_paint/sculpt_ops.cc @@ -129,9 +129,11 @@ static int set_persistent_base_exec(bContext *C, wmOperator * /*op*/) } case bke::pbvh::Type::Grids: { const SubdivCCG &subdiv_ccg = *ss->subdiv_ccg; - ss->sculpt_persistent_co = subdiv_ccg.positions; - ss->sculpt_persistent_no = subdiv_ccg.normals; - ss->sculpt_persistent_disp = {}; + ss->persistent.sculpt_persistent_co = subdiv_ccg.positions; + ss->persistent.sculpt_persistent_no = subdiv_ccg.normals; + ss->persistent.sculpt_persistent_disp = Array(subdiv_ccg.positions.size(), 0.0f); + ss->persistent.grid_size = subdiv_ccg.grid_size; + ss->persistent.grids_num = subdiv_ccg.grids_num; break; } case bke::pbvh::Type::BMesh: { From f1fca48a4fcfb2e11a0d5480d72a9203b770bdba Mon Sep 17 00:00:00 2001 From: Sean Kim Date: Wed, 19 Feb 2025 22:00:39 +0100 Subject: [PATCH 29/31] Fix #134292: Clone brush cannot access local blendfile images With the brush assets project, brushes were moved from being local to the working blendfile to being linked from asset libraries. This breaks the Image Paint 'Clone' brush, as it has a brush property that links to other Image datablocks. To support this functionality, this commit adds the corresponding properties into the `ImagePaintSettings` struct so that it is stored locally with the images that will be used by the tool, inside the main blendfile. The source image property is shared with the 3D version of the 'Clone' brush instead of adding a separate field to preserve old behavior. Notably, this has the following limitations: * If clone brush assets have been made and shared with external packs, they would not work out of the box with linked image assets. * Despite these settings being stored on the scene, they are populated inside the tool window under "Brush Settings" which is potentially misleading. However, this is already the case for the 3D version of the brush, so further UI refinement will happen outside of this PR. * Users will be unable to use separate images simultaneously for the Image editor and the 3D viewport, unlike in pre-4.3 versions. This can be adjusted in the future if it is a critical workflow. Because the intended design and functionality of this tool is currently questionable, this commit opts to make these changes instead of doing further design to support both accessing data on the brush and on the scene. Pull Request: https://projects.blender.org/blender/blender/pulls/134474 --- .../startup/bl_ui/properties_paint_common.py | 6 ++--- scripts/startup/bl_ui/space_image.py | 2 +- scripts/startup/bl_ui/space_view3d_toolbar.py | 2 +- .../blender/blenkernel/BKE_blender_version.h | 2 +- source/blender/blenkernel/intern/brush.cc | 14 ---------- .../blenloader/intern/versioning_300.cc | 8 ------ .../blenloader/intern/versioning_400.cc | 7 +++++ .../draw/engines/overlay/overlay_next_mesh.hh | 13 +++++----- .../editors/sculpt_paint/paint_image.cc | 25 +++++++++++------- .../editors/sculpt_paint/paint_image_2d.cc | 9 ++++--- source/blender/makesdna/DNA_brush_defaults.h | 1 - source/blender/makesdna/DNA_brush_types.h | 11 -------- source/blender/makesdna/DNA_scene_defaults.h | 1 + source/blender/makesdna/DNA_scene_types.h | 5 ++++ source/blender/makesrna/intern/rna_brush.cc | 26 ------------------- .../makesrna/intern/rna_sculpt_paint.cc | 12 +++++++++ 16 files changed, 60 insertions(+), 84 deletions(-) diff --git a/scripts/startup/bl_ui/properties_paint_common.py b/scripts/startup/bl_ui/properties_paint_common.py index 80d8d3a6b1a..a19a80f4cd8 100644 --- a/scripts/startup/bl_ui/properties_paint_common.py +++ b/scripts/startup/bl_ui/properties_paint_common.py @@ -1171,7 +1171,7 @@ def brush_shared_settings(layout, context, brush, popover=False): layout.row().prop(brush, "direction", expand=True) -def brush_settings_advanced(layout, context, brush, popover=False): +def brush_settings_advanced(layout, context, settings, brush, popover=False): """Draw advanced brush settings for Sculpt, Texture/Vertex/Weight Paint modes.""" mode = UnifiedPaintPanel.get_brush_mode(context) @@ -1317,8 +1317,8 @@ def brush_settings_advanced(layout, context, brush, popover=False): elif brush.image_tool == 'CLONE': if mode == 'PAINT_2D': - layout.prop(brush, "clone_image", text="Image") - layout.prop(brush, "clone_alpha", text="Alpha") + layout.prop(settings, "clone_image", text="Image") + layout.prop(settings, "clone_alpha", text="Alpha") # Vertex Paint # elif mode == 'PAINT_VERTEX': diff --git a/scripts/startup/bl_ui/space_image.py b/scripts/startup/bl_ui/space_image.py index a39c003473a..56fe8815e06 100644 --- a/scripts/startup/bl_ui/space_image.py +++ b/scripts/startup/bl_ui/space_image.py @@ -1255,7 +1255,7 @@ def draw(self, context): settings = context.tool_settings.image_paint brush = settings.brush if brush: - brush_settings_advanced(layout.column(), context, brush, self.is_popover) + brush_settings_advanced(layout.column(), context, settings, brush, self.is_popover) class IMAGE_PT_paint_color(Panel, ImagePaintPanel): diff --git a/scripts/startup/bl_ui/space_view3d_toolbar.py b/scripts/startup/bl_ui/space_view3d_toolbar.py index dc548b85f4c..ebbd6de1158 100644 --- a/scripts/startup/bl_ui/space_view3d_toolbar.py +++ b/scripts/startup/bl_ui/space_view3d_toolbar.py @@ -408,7 +408,7 @@ def draw(self, context): settings = UnifiedPaintPanel.paint_settings(context) brush = settings.brush - brush_settings_advanced(layout.column(), context, brush, self.is_popover) + brush_settings_advanced(layout.column(), context, settings, brush, self.is_popover) class VIEW3D_PT_tools_brush_color(Panel, View3DPaintPanel): diff --git a/source/blender/blenkernel/BKE_blender_version.h b/source/blender/blenkernel/BKE_blender_version.h index abaff3b9430..d5668563e8a 100644 --- a/source/blender/blenkernel/BKE_blender_version.h +++ b/source/blender/blenkernel/BKE_blender_version.h @@ -31,7 +31,7 @@ extern "C" { /* Blender file format version. */ #define BLENDER_FILE_VERSION BLENDER_VERSION -#define BLENDER_FILE_SUBVERSION 28 +#define BLENDER_FILE_SUBVERSION 29 /* Minimum Blender version that supports reading file written with the current * version. Older Blender versions will test this and cancel loading the file, showing a warning to diff --git a/source/blender/blenkernel/intern/brush.cc b/source/blender/blenkernel/intern/brush.cc index 92e73634ce7..e10a5f6b92a 100644 --- a/source/blender/blenkernel/intern/brush.cc +++ b/source/blender/blenkernel/intern/brush.cc @@ -162,18 +162,6 @@ static void brush_make_local(Main *bmain, ID *id, const int flags) bool force_local, force_copy; BKE_lib_id_make_local_generic_action_define(bmain, id, flags, &force_local, &force_copy); - if (brush->clone.image) { - /* Special case: `ima` always local immediately. - * Clone image should only have one user anyway. */ - /* FIXME: Recursive calls affecting other non-embedded IDs are really bad and should be avoided - * in IDType callbacks. Higher-level ID management code usually does not expect such things and - * does not deal properly with it. */ - /* NOTE: assert below ensures that the comment above is valid, and that exception is - * acceptable for the time being. */ - BKE_lib_id_make_local(bmain, &brush->clone.image->id, LIB_ID_MAKELOCAL_ASSET_DATA_CLEAR); - BLI_assert(!ID_IS_LINKED(brush->clone.image) && brush->clone.image->id.newid == nullptr); - } - if (force_local) { BKE_lib_id_clear_library_data(bmain, &brush->id, flags); BKE_lib_id_expand_local(bmain, &brush->id, flags); @@ -200,7 +188,6 @@ static void brush_foreach_id(ID *id, LibraryForeachIDData *data) Brush *brush = (Brush *)id; BKE_LIB_FOREACHID_PROCESS_IDSUPER(data, brush->toggle_brush, IDWALK_CB_NOP); - BKE_LIB_FOREACHID_PROCESS_IDSUPER(data, brush->clone.image, IDWALK_CB_NOP); BKE_LIB_FOREACHID_PROCESS_IDSUPER(data, brush->paint_curve, IDWALK_CB_USER); if (brush->gpencil_settings) { BKE_LIB_FOREACHID_PROCESS_IDSUPER(data, brush->gpencil_settings->material, IDWALK_CB_USER); @@ -505,7 +492,6 @@ static void brush_defaults(Brush *brush) FROM_DEFAULT(disconnected_distance_max); FROM_DEFAULT(sculpt_plane); FROM_DEFAULT(plane_offset); - FROM_DEFAULT(clone.alpha); FROM_DEFAULT(normal_weight); FROM_DEFAULT(fill_threshold); FROM_DEFAULT(flag); diff --git a/source/blender/blenloader/intern/versioning_300.cc b/source/blender/blenloader/intern/versioning_300.cc index 7cda595ed6e..085bbbd4ebe 100644 --- a/source/blender/blenloader/intern/versioning_300.cc +++ b/source/blender/blenloader/intern/versioning_300.cc @@ -1142,14 +1142,6 @@ void do_versions_after_linking_300(FileData * /*fd*/, Main *bmain) imapaint->clone = nullptr; } } - - LISTBASE_FOREACH (Brush *, brush, &bmain->brushes) { - if (brush->clone.image != nullptr && - ELEM(brush->clone.image->type, IMA_TYPE_R_RESULT, IMA_TYPE_COMPOSITE)) - { - brush->clone.image = nullptr; - } - } } if (!MAIN_VERSION_FILE_ATLEAST(bmain, 300, 28)) { diff --git a/source/blender/blenloader/intern/versioning_400.cc b/source/blender/blenloader/intern/versioning_400.cc index 9c122ba5b26..fc4290f15e2 100644 --- a/source/blender/blenloader/intern/versioning_400.cc +++ b/source/blender/blenloader/intern/versioning_400.cc @@ -5828,6 +5828,13 @@ void blo_do_versions_400(FileData *fd, Library * /*lib*/, Main *bmain) } } + if (!MAIN_VERSION_FILE_ATLEAST(bmain, 404, 29)) { + LISTBASE_FOREACH (Scene *, scene, &bmain->scenes) { + ToolSettings *ts = scene->toolsettings; + ts->imapaint.clone_alpha = 0.5f; + } + } + /* Always run this versioning; meshes are written with the legacy format which always needs to * be converted to the new format on file load. Can be moved to a subversion check in a larger * breaking release. */ diff --git a/source/blender/draw/engines/overlay/overlay_next_mesh.hh b/source/blender/draw/engines/overlay/overlay_next_mesh.hh index 56b63483d52..6d3c23b93e2 100644 --- a/source/blender/draw/engines/overlay/overlay_next_mesh.hh +++ b/source/blender/draw/engines/overlay/overlay_next_mesh.hh @@ -615,10 +615,11 @@ class MeshUVs : Overlay { } { /* Brush Stencil Overlay. */ - const Brush *brush = BKE_paint_brush_for_read(&tool_setting->imapaint.paint); + const ImagePaintSettings &image_paint_settings = tool_setting->imapaint; + const Brush *brush = BKE_paint_brush_for_read(&image_paint_settings.paint); show_stencil_ = space_mode_is_paint && brush && (brush->image_brush_type == IMAGE_PAINT_BRUSH_TYPE_CLONE) && - brush->clone.image; + image_paint_settings.clone; } { /* UDIM Overlay. */ @@ -860,8 +861,8 @@ class MeshUVs : Overlay { pass.state_set(DRW_STATE_WRITE_COLOR | DRW_STATE_DEPTH_ALWAYS | DRW_STATE_BLEND_ALPHA_PREMUL); - const Brush *brush = BKE_paint_brush_for_read(&tool_setting->imapaint.paint); - ::Image *stencil_image = brush->clone.image; + const ImagePaintSettings &image_paint_settings = tool_setting->imapaint; + ::Image *stencil_image = image_paint_settings.clone; TextureRef stencil_texture; stencil_texture.wrap(BKE_image_get_gpu_texture(stencil_image, nullptr)); @@ -873,8 +874,8 @@ class MeshUVs : Overlay { pass.bind_texture("imgTexture", stencil_texture); pass.push_constant("imgPremultiplied", true); pass.push_constant("imgAlphaBlend", true); - pass.push_constant("ucolor", float4(1.0f, 1.0f, 1.0f, brush->clone.alpha)); - pass.push_constant("brush_offset", float2(brush->clone.offset)); + pass.push_constant("ucolor", float4(1.0f, 1.0f, 1.0f, image_paint_settings.clone_alpha)); + pass.push_constant("brush_offset", float2(image_paint_settings.clone_offset)); pass.push_constant("brush_scale", float2(stencil_texture.size().xy()) / size_image); pass.draw(res.shapes.quad_solid.get()); } diff --git a/source/blender/editors/sculpt_paint/paint_image.cc b/source/blender/editors/sculpt_paint/paint_image.cc index ea99d61f221..bb458305b58 100644 --- a/source/blender/editors/sculpt_paint/paint_image.cc +++ b/source/blender/editors/sculpt_paint/paint_image.cc @@ -326,11 +326,14 @@ static bool image_paint_poll_ignore_tool(bContext *C) static bool image_paint_2d_clone_poll(bContext *C) { + const Scene *scene = CTX_data_scene(C); + const ToolSettings *settings = scene->toolsettings; + const ImagePaintSettings &image_paint_settings = settings->imapaint; Brush *brush = image_paint_brush(C); if (!CTX_wm_region_view3d(C) && ED_image_tools_paint_poll(C)) { if (brush && (brush->image_brush_type == IMAGE_PAINT_BRUSH_TYPE_CLONE)) { - if (brush->clone.image) { + if (image_paint_settings.clone) { return true; } } @@ -514,12 +517,13 @@ struct GrabClone { static void grab_clone_apply(bContext *C, wmOperator *op) { - Brush *brush = image_paint_brush(C); + const Scene *scene = CTX_data_scene(C); + ToolSettings *settings = scene->toolsettings; + ImagePaintSettings &image_paint_settings = settings->imapaint; float delta[2]; RNA_float_get_array(op->ptr, "delta", delta); - add_v2_v2(brush->clone.offset, delta); - BKE_brush_tag_unsaved_changes(brush); + add_v2_v2(image_paint_settings.clone_offset, delta); ED_region_tag_redraw(CTX_wm_region(C)); } @@ -532,11 +536,13 @@ static int grab_clone_exec(bContext *C, wmOperator *op) static int grab_clone_invoke(bContext *C, wmOperator *op, const wmEvent *event) { - Brush *brush = image_paint_brush(C); + const Scene *scene = CTX_data_scene(C); + const ToolSettings *settings = scene->toolsettings; + const ImagePaintSettings &image_paint_settings = settings->imapaint; GrabClone *cmv; cmv = MEM_cnew("GrabClone"); - copy_v2_v2(cmv->startoffset, brush->clone.offset); + copy_v2_v2(cmv->startoffset, image_paint_settings.clone_offset); cmv->startx = event->xy[0]; cmv->starty = event->xy[1]; op->customdata = cmv; @@ -548,7 +554,9 @@ static int grab_clone_invoke(bContext *C, wmOperator *op, const wmEvent *event) static int grab_clone_modal(bContext *C, wmOperator *op, const wmEvent *event) { - Brush *brush = image_paint_brush(C); + const Scene *scene = CTX_data_scene(C); + ToolSettings *settings = scene->toolsettings; + ImagePaintSettings &image_paint_settings = settings->imapaint; ARegion *region = CTX_wm_region(C); GrabClone *cmv = static_cast(op->customdata); float startfx, startfy, fx, fy, delta[2]; @@ -570,8 +578,7 @@ static int grab_clone_modal(bContext *C, wmOperator *op, const wmEvent *event) delta[1] = fy - startfy; RNA_float_set_array(op->ptr, "delta", delta); - copy_v2_v2(brush->clone.offset, cmv->startoffset); - BKE_brush_tag_unsaved_changes(brush); + copy_v2_v2(image_paint_settings.clone_offset, cmv->startoffset); grab_clone_apply(C, op); break; diff --git a/source/blender/editors/sculpt_paint/paint_image_2d.cc b/source/blender/editors/sculpt_paint/paint_image_2d.cc index b69ed410782..970e898ff77 100644 --- a/source/blender/editors/sculpt_paint/paint_image_2d.cc +++ b/source/blender/editors/sculpt_paint/paint_image_2d.cc @@ -1299,13 +1299,14 @@ static int paint_2d_op(void *state, const float pos[2]) { ImagePaintState *s = ((ImagePaintState *)state); + const ImagePaintSettings &image_paint_settings = s->scene->toolsettings->imapaint; ImBuf *clonebuf = nullptr, *frombuf; ImBuf *canvas = tile->canvas; ImBuf *ibufb = tile->cache.ibuf; ImagePaintRegion region[4]; short paint_tile = s->symmetry & (PAINT_TILE_X | PAINT_TILE_Y); short blend = s->blend; - const float *offset = s->brush->clone.offset; + const float *offset = image_paint_settings.clone_offset; float liftpos[2]; float mask_max = BKE_brush_alpha_get(s->scene, s->brush); int bpos[2], blastpos[2], bliftpos[2]; @@ -1424,7 +1425,8 @@ static int paint_2d_canvas_set(ImagePaintState *s) { /* set clone canvas */ if (s->brush_type == IMAGE_PAINT_BRUSH_TYPE_CLONE) { - Image *ima = s->brush->clone.image; + const ImagePaintSettings &image_paint_settings = s->scene->toolsettings->imapaint; + Image *ima = image_paint_settings.clone; ImBuf *ibuf = BKE_image_acquire_ibuf(ima, nullptr, nullptr); if (!ima || !ibuf || !(ibuf->byte_buffer.data || ibuf->float_buffer.data)) { @@ -1454,7 +1456,8 @@ static void paint_2d_canvas_free(ImagePaintState *s) for (int i = 0; i < s->num_tiles; i++) { BKE_image_release_ibuf(s->image, s->tiles[i].canvas, nullptr); } - BKE_image_release_ibuf(s->brush->clone.image, s->clonecanvas, nullptr); + const ImagePaintSettings &image_paint_settings = s->scene->toolsettings->imapaint; + BKE_image_release_ibuf(image_paint_settings.clone, s->clonecanvas, nullptr); if (s->blurkernel) { paint_delete_blur_kernel(s->blurkernel); diff --git a/source/blender/makesdna/DNA_brush_defaults.h b/source/blender/makesdna/DNA_brush_defaults.h index 881c497584e..c070f4df0c2 100644 --- a/source/blender/makesdna/DNA_brush_defaults.h +++ b/source/blender/makesdna/DNA_brush_defaults.h @@ -44,7 +44,6 @@ /* How far above or below the plane that is found by averaging the faces. */ \ .plane_offset = 0.0f, \ .plane_trim = 0.5f, \ - .clone.alpha = 0.5f, \ .normal_weight = 0.0f, \ .fill_threshold = 0.2f, \ \ diff --git a/source/blender/makesdna/DNA_brush_types.h b/source/blender/makesdna/DNA_brush_types.h index 3234a691c3f..2a71f86a5e7 100644 --- a/source/blender/makesdna/DNA_brush_types.h +++ b/source/blender/makesdna/DNA_brush_types.h @@ -19,16 +19,6 @@ struct Image; struct MTex; struct Material; -typedef struct BrushClone { - /** Image for clone tool. */ - struct Image *image; - /** Offset of clone image from canvas. */ - float offset[2]; - /** Transparency for drawing of clone image. */ - float alpha; - char _pad[4]; -} BrushClone; - typedef struct BrushGpencilSettings { /** Amount of smoothing to apply to newly created strokes. */ float draw_smoothfac; @@ -175,7 +165,6 @@ typedef struct Brush { ID id; - struct BrushClone clone; /** Falloff curve. */ struct CurveMapping *curve; struct MTex mtex; diff --git a/source/blender/makesdna/DNA_scene_defaults.h b/source/blender/makesdna/DNA_scene_defaults.h index 953f977931c..8033b7bb989 100644 --- a/source/blender/makesdna/DNA_scene_defaults.h +++ b/source/blender/makesdna/DNA_scene_defaults.h @@ -280,6 +280,7 @@ .paint.flags = PAINT_SHOW_BRUSH, \ .normal_angle = 80, \ .seam_bleed = 2, \ + .clone_alpha = 0.5f, \ } #define _DNA_DEFAULTS_ParticleBrushData \ diff --git a/source/blender/makesdna/DNA_scene_types.h b/source/blender/makesdna/DNA_scene_types.h index 7f56ce983ad..152239204b2 100644 --- a/source/blender/makesdna/DNA_scene_types.h +++ b/source/blender/makesdna/DNA_scene_types.h @@ -1041,6 +1041,11 @@ typedef struct ImagePaintSettings { /** Display texture interpolation method. */ int interp; char _pad[4]; + /** Offset of clone image from canvas in Image editor. */ + float clone_offset[2]; + /** Transparency for drawing of clone image in Image editor. */ + float clone_alpha; + char _pad2[4]; } ImagePaintSettings; /** \} */ diff --git a/source/blender/makesrna/intern/rna_brush.cc b/source/blender/makesrna/intern/rna_brush.cc index 86bf971e70a..85919420a7b 100644 --- a/source/blender/makesrna/intern/rna_brush.cc +++ b/source/blender/makesrna/intern/rna_brush.cc @@ -802,12 +802,6 @@ static void rna_Brush_icon_update(Main * /*bmain*/, Scene * /*scene*/, PointerRN WM_main_add_notifier(NC_BRUSH | NA_EDITED, br); } -static bool rna_Brush_imagetype_poll(PointerRNA * /*ptr*/, PointerRNA value) -{ - Image *image = (Image *)value.owner_id; - return image->type != IMA_TYPE_R_RESULT && image->type != IMA_TYPE_COMPOSITE; -} - static void rna_TextureSlot_brush_angle_update(bContext *C, PointerRNA *ptr) { Scene *scene = CTX_data_scene(C); @@ -3906,26 +3900,6 @@ static void rna_def_brush(BlenderRNA *brna) RNA_def_property_ui_text(prop, "Brush Icon Filepath", "File path to brush icon"); RNA_def_property_update(prop, 0, "rna_Brush_icon_update"); - /* clone brush */ - prop = RNA_def_property(srna, "clone_image", PROP_POINTER, PROP_NONE); - RNA_def_property_pointer_sdna(prop, nullptr, "clone.image"); - RNA_def_property_flag(prop, PROP_EDITABLE); - RNA_def_property_ui_text(prop, "Clone Image", "Image for clone brushes"); - RNA_def_property_update(prop, NC_SPACE | ND_SPACE_IMAGE, "rna_Brush_update"); - RNA_def_property_pointer_funcs(prop, nullptr, nullptr, nullptr, "rna_Brush_imagetype_poll"); - - prop = RNA_def_property(srna, "clone_alpha", PROP_FLOAT, PROP_FACTOR); - RNA_def_property_float_sdna(prop, nullptr, "clone.alpha"); - RNA_def_property_range(prop, 0.0f, 1.0f); - RNA_def_property_ui_text(prop, "Clone Alpha", "Opacity of clone image display"); - RNA_def_property_update(prop, NC_SPACE | ND_SPACE_IMAGE, "rna_Brush_update"); - - prop = RNA_def_property(srna, "clone_offset", PROP_FLOAT, PROP_XYZ); - RNA_def_property_float_sdna(prop, nullptr, "clone.offset"); - RNA_def_property_ui_text(prop, "Clone Offset", ""); - RNA_def_property_ui_range(prop, -1.0f, 1.0f, 10.0f, 3); - RNA_def_property_update(prop, NC_SPACE | ND_SPACE_IMAGE, "rna_Brush_update"); - prop = RNA_def_property(srna, "brush_capabilities", PROP_POINTER, PROP_NONE); RNA_def_property_flag(prop, PROP_NEVER_NULL); RNA_def_property_struct_type(prop, "BrushCapabilities"); diff --git a/source/blender/makesrna/intern/rna_sculpt_paint.cc b/source/blender/makesrna/intern/rna_sculpt_paint.cc index fbe4397ae04..9694ed03a6d 100644 --- a/source/blender/makesrna/intern/rna_sculpt_paint.cc +++ b/source/blender/makesrna/intern/rna_sculpt_paint.cc @@ -1210,6 +1210,18 @@ static void rna_def_image_paint(BlenderRNA *brna) RNA_def_property_ui_text( prop, "Missing Texture", "Image Painting does not have a texture to paint on"); RNA_def_property_clear_flag(prop, PROP_EDITABLE); + + prop = RNA_def_property(srna, "clone_alpha", PROP_FLOAT, PROP_FACTOR); + RNA_def_property_float_sdna(prop, nullptr, "clone_alpha"); + RNA_def_property_range(prop, 0.0f, 1.0f); + RNA_def_property_ui_text(prop, "Clone Alpha", "Opacity of clone image display"); + RNA_def_property_update(prop, NC_SCENE | ND_TOOLSETTINGS, nullptr); + + prop = RNA_def_property(srna, "clone_offset", PROP_FLOAT, PROP_XYZ); + RNA_def_property_float_sdna(prop, nullptr, "clone_offset"); + RNA_def_property_ui_text(prop, "Clone Offset", ""); + RNA_def_property_ui_range(prop, -1.0f, 1.0f, 10.0f, 3); + RNA_def_property_update(prop, NC_SCENE | ND_TOOLSETTINGS, nullptr); } static void rna_def_particle_edit(BlenderRNA *brna) From f3377aa7e80a592f83749fb6345a5fb5f555b05f Mon Sep 17 00:00:00 2001 From: Sean Kim Date: Wed, 19 Feb 2025 22:05:37 +0100 Subject: [PATCH 30/31] Fix: Set Persistent Base doesn't work for cloth brushes The `init_positions` variable that the `ss.sculpt_persistent_co` member gets set to was not passed into the corresponding calculation function, resulting in a no-op. Pull Request: https://projects.blender.org/blender/blender/pulls/134781 --- source/blender/editors/sculpt_paint/sculpt_cloth.cc | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/source/blender/editors/sculpt_paint/sculpt_cloth.cc b/source/blender/editors/sculpt_paint/sculpt_cloth.cc index e60aa0e664b..c3d0ca594e6 100644 --- a/source/blender/editors/sculpt_paint/sculpt_cloth.cc +++ b/source/blender/editors/sculpt_paint/sculpt_cloth.cc @@ -594,7 +594,7 @@ void ensure_nodes_constraints(const Sculpt &sd, brush, initial_location, radius, - cloth_sim.init_pos, + init_positions, cloth_sim.node_state_index.lookup(&nodes[i]), verts, neighbors, From 0acd86abcac0af783662819cfeca2c15f892d4c6 Mon Sep 17 00:00:00 2001 From: Sean Kim Date: Wed, 19 Feb 2025 22:07:34 +0100 Subject: [PATCH 31/31] Fix: Vertex Paint average brush produces incorrect results This commit moves the initialization of the node-sized accumulation array out of the parallel loop to avoid odd optimization errors when differing between debug and release builds as well as errors due to integer overflow in both builds. Additionally it only accumulates results from affected nodes. Pull Request: https://projects.blender.org/blender/blender/pulls/134720 --- source/blender/editors/sculpt_paint/paint_vertex.cc | 10 ++++------ 1 file changed, 4 insertions(+), 6 deletions(-) diff --git a/source/blender/editors/sculpt_paint/paint_vertex.cc b/source/blender/editors/sculpt_paint/paint_vertex.cc index eaeb4121fe9..de23d04df0a 100644 --- a/source/blender/editors/sculpt_paint/paint_vertex.cc +++ b/source/blender/editors/sculpt_paint/paint_vertex.cc @@ -1567,12 +1567,10 @@ static void calculate_average_color(VPaintData &vpd, using Blend = typename Traits::BlendType; const Span colors = attribute.typed().template cast(); - Array> accum(nodes.size()); + Array> accum(nodes.size(), {0, {0, 0, 0}}); node_mask.foreach_index(GrainSize(1), [&](const int i) { - LocalData &tls = all_tls.local(); VPaintAverageAccum &accum2 = accum[i]; - accum2.len = 0; - memset(accum2.value, 0, sizeof(accum2.value)); + LocalData &tls = all_tls.local(); const Span verts = nodes[i].verts(); tls.factors.resize(verts.size()); @@ -1620,12 +1618,12 @@ static void calculate_average_color(VPaintData &vpd, Blend accum_value[3] = {0}; Color blend(0, 0, 0, 0); - for (int i = 0; i < nodes.size(); i++) { + node_mask.foreach_index([&](const int i) { accum_len += accum[i].len; accum_value[0] += accum[i].value[0]; accum_value[1] += accum[i].value[1]; accum_value[2] += accum[i].value[2]; - } + }); if (accum_len != 0) { blend.r = Traits::round(sqrtf(Traits::divide_round(accum_value[0], accum_len))); blend.g = Traits::round(sqrtf(Traits::divide_round(accum_value[1], accum_len)));