archive/blender-archive
Archived
1
1
Fork 0
Code Pull Requests Packages Activity
This repository has been archived on 2023-10-09. You can view files and clone it, but cannot push or open issues or pull requests.
Files
b51d6d50688e653d42c3ca8566df2f9518c462e3
blender-archive/source/blender/nodes/NOD_node_tree_ref.hh

Ignoring revisions in .git-blame-ignore-revs. Click here to bypass and see the normal blame view.

772 lines
18 KiB
C++
Raw Normal View History

File headers: SPDX License migration Use a shorter/simpler license convention, stops the header taking so much space. Follow the SPDX license specification: https://spdx.org/licenses - C/C++/objc/objc++ - Python - Shell Scripts - CMake, GNUmakefile While most of the source tree has been included - `./extern/` was left out. - `./intern/cycles` & `./intern/atomic` are also excluded because they use different header conventions. doc/license/SPDX-license-identifiers.txt has been added to list SPDX all used identifiers. See P2788 for the script that automated these edits. Reviewed By: brecht, mont29, sergey Ref D14069
2022-02-11 09:07:11 +11:00
/* SPDX-License-Identifier: GPL-2.0-or-later */
Nodes: efficient node tree queries and inlining This adds two data structures that wrap a node tree. However, they work on different abstraction levels. `NodeTreeRef` is an immutable structure that makes working with a node tree in C++ much more efficient and convenient. It supports various queries efficiently, that are not easily possible using just `bNodeTree`. `DerivedNodeTree` builds on top of `NodeTreeRef`. It contains a flattened view on the node tree, i.e. with node groups being inlined. Every inlined node still knows its "call stack". It supports pretty much the same queries as `NodeTreeRef`. Both data structures come with a dot graph exporter for debugging purposes. Reviewers: brecht Differential Revision: https://developer.blender.org/D7628
2020-06-09 17:08:41 +02:00
Nodes: move some code from blenkernel directory to nodes This also introduces the `blender::nodes` namespace. Eventually, we want to move most/all of the node implementation files into this namespace. The reason for this file-move is that the code fits much better into the `nodes` directory than in the `blenkernel` directory.
2020-07-17 11:36:59 +02:00
#pragma once
Nodes: efficient node tree queries and inlining This adds two data structures that wrap a node tree. However, they work on different abstraction levels. `NodeTreeRef` is an immutable structure that makes working with a node tree in C++ much more efficient and convenient. It supports various queries efficiently, that are not easily possible using just `bNodeTree`. `DerivedNodeTree` builds on top of `NodeTreeRef`. It contains a flattened view on the node tree, i.e. with node groups being inlined. Every inlined node still knows its "call stack". It supports pretty much the same queries as `NodeTreeRef`. Both data structures come with a dot graph exporter for debugging purposes. Reviewers: brecht Differential Revision: https://developer.blender.org/D7628
2020-06-09 17:08:41 +02:00
/** \file
Nodes: move some code from blenkernel directory to nodes This also introduces the `blender::nodes` namespace. Eventually, we want to move most/all of the node implementation files into this namespace. The reason for this file-move is that the code fits much better into the `nodes` directory than in the `blenkernel` directory.
2020-07-17 11:36:59 +02:00
* \ingroup nodes
Nodes: efficient node tree queries and inlining This adds two data structures that wrap a node tree. However, they work on different abstraction levels. `NodeTreeRef` is an immutable structure that makes working with a node tree in C++ much more efficient and convenient. It supports various queries efficiently, that are not easily possible using just `bNodeTree`. `DerivedNodeTree` builds on top of `NodeTreeRef`. It contains a flattened view on the node tree, i.e. with node groups being inlined. Every inlined node still knows its "call stack". It supports pretty much the same queries as `NodeTreeRef`. Both data structures come with a dot graph exporter for debugging purposes. Reviewers: brecht Differential Revision: https://developer.blender.org/D7628
2020-06-09 17:08:41 +02:00
*
* NodeTreeRef makes querying information about a bNodeTree more efficient. It is an immutable data
* structure. It should not be used after anymore, after the underlying node tree changed.
*
* The following queries are supported efficiently:
* - socket -> index of socket
* - socket -> directly linked sockets
Nodes: store references to bNodeLinks in NodeTreeRef Sometimes it is useful to have this information available to be able to read information from links.
2021-03-03 07:59:07 +01:00
* - socket -> directly linked links
Nodes: efficient node tree queries and inlining This adds two data structures that wrap a node tree. However, they work on different abstraction levels. `NodeTreeRef` is an immutable structure that makes working with a node tree in C++ much more efficient and convenient. It supports various queries efficiently, that are not easily possible using just `bNodeTree`. `DerivedNodeTree` builds on top of `NodeTreeRef`. It contains a flattened view on the node tree, i.e. with node groups being inlined. Every inlined node still knows its "call stack". It supports pretty much the same queries as `NodeTreeRef`. Both data structures come with a dot graph exporter for debugging purposes. Reviewers: brecht Differential Revision: https://developer.blender.org/D7628
2020-06-09 17:08:41 +02:00
* - socket -> linked sockets when skipping reroutes
* - socket -> node
* - socket/node -> rna pointer
* - node -> inputs/outputs
* - node -> tree
* - tree -> all nodes
* - tree -> all (input/output) sockets
* - idname -> nodes
*
* Every socket has an id. The id-space is shared between input and output sockets.
* When storing data per socket, it is often better to use the id as index into an array, instead
* of a hash table.
*
* Every node has an id as well. The same rule regarding hash tables applies.
*
* There is an utility to export this data structure as graph in dot format.
*/
#include "BLI_array.hh"
Nodes: make derived link data more obvious in NodeTreeRef `NodeTreeRef` is a thin wrapper on top of `bNodeTree`. By default it should not hide anything from the underlying `bNodeTree` (before this it was hiding muted links). For convenience some "derived" data is cached on sockets. For example all the connected sockets when reroutes and muted links are ignored. A nice side benefit of this refactor is that `NodeTreeRef` requires less memory than before.
2021-03-17 16:43:06 +01:00
#include "BLI_function_ref.hh"
Nodes: efficient node tree queries and inlining This adds two data structures that wrap a node tree. However, they work on different abstraction levels. `NodeTreeRef` is an immutable structure that makes working with a node tree in C++ much more efficient and convenient. It supports various queries efficiently, that are not easily possible using just `bNodeTree`. `DerivedNodeTree` builds on top of `NodeTreeRef`. It contains a flattened view on the node tree, i.e. with node groups being inlined. Every inlined node still knows its "call stack". It supports pretty much the same queries as `NodeTreeRef`. Both data structures come with a dot graph exporter for debugging purposes. Reviewers: brecht Differential Revision: https://developer.blender.org/D7628
2020-06-09 17:08:41 +02:00
#include "BLI_linear_allocator.hh"
#include "BLI_map.hh"
BLI: add MultiValueMap This is a convenience wrapper for `Map<Key, Vector<Value>>`. It does not provide any performance benefits (yet). I need this kind of map in a couple of places and before I was duplicating the lookup logic in many places.
2020-07-24 12:15:13 +02:00
#include "BLI_multi_value_map.hh"
Nodes: efficient node tree queries and inlining This adds two data structures that wrap a node tree. However, they work on different abstraction levels. `NodeTreeRef` is an immutable structure that makes working with a node tree in C++ much more efficient and convenient. It supports various queries efficiently, that are not easily possible using just `bNodeTree`. `DerivedNodeTree` builds on top of `NodeTreeRef`. It contains a flattened view on the node tree, i.e. with node groups being inlined. Every inlined node still knows its "call stack". It supports pretty much the same queries as `NodeTreeRef`. Both data structures come with a dot graph exporter for debugging purposes. Reviewers: brecht Differential Revision: https://developer.blender.org/D7628
2020-06-09 17:08:41 +02:00
#include "BLI_string_ref.hh"
#include "BLI_timeit.hh"
#include "BLI_utility_mixins.hh"
#include "BLI_vector.hh"
#include "BKE_node.h"
#include "DNA_node_types.h"
#include "RNA_access.h"
Nodes: move some code from blenkernel directory to nodes This also introduces the `blender::nodes` namespace. Eventually, we want to move most/all of the node implementation files into this namespace. The reason for this file-move is that the code fits much better into the `nodes` directory than in the `blenkernel` directory.
2020-07-17 11:36:59 +02:00
namespace blender::nodes {
Nodes: efficient node tree queries and inlining This adds two data structures that wrap a node tree. However, they work on different abstraction levels. `NodeTreeRef` is an immutable structure that makes working with a node tree in C++ much more efficient and convenient. It supports various queries efficiently, that are not easily possible using just `bNodeTree`. `DerivedNodeTree` builds on top of `NodeTreeRef`. It contains a flattened view on the node tree, i.e. with node groups being inlined. Every inlined node still knows its "call stack". It supports pretty much the same queries as `NodeTreeRef`. Both data structures come with a dot graph exporter for debugging purposes. Reviewers: brecht Differential Revision: https://developer.blender.org/D7628
2020-06-09 17:08:41 +02:00
class SocketRef;
class InputSocketRef;
class OutputSocketRef;
class NodeRef;
class NodeTreeRef;
Nodes: store references to bNodeLinks in NodeTreeRef Sometimes it is useful to have this information available to be able to read information from links.
2021-03-03 07:59:07 +01:00
class LinkRef;
Nodes: improve NodeTreeRef This adds a couple more utility methods to various node tree ref types. Also `InternalLinkRef` has been added to get simpler access to internal links.
2021-03-04 18:15:22 +01:00
class InternalLinkRef;
Nodes: efficient node tree queries and inlining This adds two data structures that wrap a node tree. However, they work on different abstraction levels. `NodeTreeRef` is an immutable structure that makes working with a node tree in C++ much more efficient and convenient. It supports various queries efficiently, that are not easily possible using just `bNodeTree`. `DerivedNodeTree` builds on top of `NodeTreeRef`. It contains a flattened view on the node tree, i.e. with node groups being inlined. Every inlined node still knows its "call stack". It supports pretty much the same queries as `NodeTreeRef`. Both data structures come with a dot graph exporter for debugging purposes. Reviewers: brecht Differential Revision: https://developer.blender.org/D7628
2020-06-09 17:08:41 +02:00
Nodes: cache socket identifier to index mapping While this preprocessing does take some time upfront, it avoids longer lookup later on, especially as nodes get more sockets. It's probably possible to make this more efficient in some cases but this is good enough for now.
2021-06-11 16:21:08 +02:00
using SocketIndexByIdentifierMap = Map<std::string, int>;
Cleanup: remove unnecessary namespace specifiers
2020-06-30 10:35:50 +02:00
class SocketRef : NonCopyable, NonMovable {
Nodes: efficient node tree queries and inlining This adds two data structures that wrap a node tree. However, they work on different abstraction levels. `NodeTreeRef` is an immutable structure that makes working with a node tree in C++ much more efficient and convenient. It supports various queries efficiently, that are not easily possible using just `bNodeTree`. `DerivedNodeTree` builds on top of `NodeTreeRef`. It contains a flattened view on the node tree, i.e. with node groups being inlined. Every inlined node still knows its "call stack". It supports pretty much the same queries as `NodeTreeRef`. Both data structures come with a dot graph exporter for debugging purposes. Reviewers: brecht Differential Revision: https://developer.blender.org/D7628
2020-06-09 17:08:41 +02:00
protected:
Cleanup: Use trailing underscore for non-public data members This makes the code conform better with our style guide.
2020-07-03 14:15:05 +02:00
NodeRef *node_;
bNodeSocket *bsocket_;
bool is_input_;
Refactor: Update integer type usage This updates the usage of integer types in code I wrote according to our new style guides. Major changes: * Use signed instead of unsigned integers in many places. * C++ containers in blenlib use `int64_t` for size and indices now (instead of `uint`). * Hash values for C++ containers are 64 bit wide now (instead of 32 bit). I do hope that I broke no builds, but it is quite likely that some compiler reports slightly different errors. Please let me know when there are any errors. If the fix is small, feel free to commit it yourself. I compiled successfully on linux with gcc and on windows.
2020-07-20 12:16:20 +02:00
int id_;
int index_;
Cleanup: Use trailing underscore for non-public data members This makes the code conform better with our style guide.
2020-07-03 14:15:05 +02:00
PointerRNA rna_;
Nodes: store references to bNodeLinks in NodeTreeRef Sometimes it is useful to have this information available to be able to read information from links.
2021-03-03 07:59:07 +01:00
Vector<LinkRef *> directly_linked_links_;
Nodes: make distinction between directly and logically linked sockets more clear This also moves the handling of muted nodes from derived node tree to node tree ref.
2021-03-19 21:10:55 +01:00
Cleanup: spelling, doxygen comment formatting
2021-03-21 13:18:20 +11:00
/* These sockets are linked directly, i.e. with a single link in between. */
Geometry Nodes: add socket value logging capability The node tree evaluator now calls a callback for every used socket with its corresponding value(s). Right now the callback does nothing. However, we can use it to collect attribute name hints, socket values for debugging or data that will be displayed in the spreadsheet. The main difficulty here was to also call the callback for sockets in nodes that are not directly executed (such as group nodes, muted nodes and reroutes). No functional changes are expected.
2021-04-01 13:10:22 +02:00
MutableSpan<const SocketRef *> directly_linked_sockets_;
Nodes: make distinction between directly and logically linked sockets more clear This also moves the handling of muted nodes from derived node tree to node tree ref.
2021-03-19 21:10:55 +01:00
/* These sockets are linked when reroutes, muted links and muted nodes have been taken into
* account. */
Geometry Nodes: add socket value logging capability The node tree evaluator now calls a callback for every used socket with its corresponding value(s). Right now the callback does nothing. However, we can use it to collect attribute name hints, socket values for debugging or data that will be displayed in the spreadsheet. The main difficulty here was to also call the callback for sockets in nodes that are not directly executed (such as group nodes, muted nodes and reroutes). No functional changes are expected.
2021-04-01 13:10:22 +02:00
MutableSpan<const SocketRef *> logically_linked_sockets_;
Cleanup: spelling
2021-04-01 22:20:53 +11:00
/* These are the sockets that have been skipped when searching for logically linked sockets.
* That includes for example the input and output socket of an intermediate reroute node. */
Geometry Nodes: add socket value logging capability The node tree evaluator now calls a callback for every used socket with its corresponding value(s). Right now the callback does nothing. However, we can use it to collect attribute name hints, socket values for debugging or data that will be displayed in the spreadsheet. The main difficulty here was to also call the callback for sockets in nodes that are not directly executed (such as group nodes, muted nodes and reroutes). No functional changes are expected.
2021-04-01 13:10:22 +02:00
MutableSpan<const SocketRef *> logically_linked_skipped_sockets_;
Nodes: efficient node tree queries and inlining This adds two data structures that wrap a node tree. However, they work on different abstraction levels. `NodeTreeRef` is an immutable structure that makes working with a node tree in C++ much more efficient and convenient. It supports various queries efficiently, that are not easily possible using just `bNodeTree`. `DerivedNodeTree` builds on top of `NodeTreeRef`. It contains a flattened view on the node tree, i.e. with node groups being inlined. Every inlined node still knows its "call stack". It supports pretty much the same queries as `NodeTreeRef`. Both data structures come with a dot graph exporter for debugging purposes. Reviewers: brecht Differential Revision: https://developer.blender.org/D7628
2020-06-09 17:08:41 +02:00
friend NodeTreeRef;
public:
Nodes: make distinction between directly and logically linked sockets more clear This also moves the handling of muted nodes from derived node tree to node tree ref.
2021-03-19 21:10:55 +01:00
Span<const SocketRef *> logically_linked_sockets() const;
Geometry Nodes: add socket value logging capability The node tree evaluator now calls a callback for every used socket with its corresponding value(s). Right now the callback does nothing. However, we can use it to collect attribute name hints, socket values for debugging or data that will be displayed in the spreadsheet. The main difficulty here was to also call the callback for sockets in nodes that are not directly executed (such as group nodes, muted nodes and reroutes). No functional changes are expected.
2021-04-01 13:10:22 +02:00
Span<const SocketRef *> logically_linked_skipped_sockets() const;
Nodes: efficient node tree queries and inlining This adds two data structures that wrap a node tree. However, they work on different abstraction levels. `NodeTreeRef` is an immutable structure that makes working with a node tree in C++ much more efficient and convenient. It supports various queries efficiently, that are not easily possible using just `bNodeTree`. `DerivedNodeTree` builds on top of `NodeTreeRef`. It contains a flattened view on the node tree, i.e. with node groups being inlined. Every inlined node still knows its "call stack". It supports pretty much the same queries as `NodeTreeRef`. Both data structures come with a dot graph exporter for debugging purposes. Reviewers: brecht Differential Revision: https://developer.blender.org/D7628
2020-06-09 17:08:41 +02:00
Span<const SocketRef *> directly_linked_sockets() const;
Nodes: store references to bNodeLinks in NodeTreeRef Sometimes it is useful to have this information available to be able to read information from links.
2021-03-03 07:59:07 +01:00
Span<const LinkRef *> directly_linked_links() const;
Nodes: make distinction between directly and logically linked sockets more clear This also moves the handling of muted nodes from derived node tree to node tree ref.
2021-03-19 21:10:55 +01:00
bool is_directly_linked() const;
bool is_logically_linked() const;
Nodes: efficient node tree queries and inlining This adds two data structures that wrap a node tree. However, they work on different abstraction levels. `NodeTreeRef` is an immutable structure that makes working with a node tree in C++ much more efficient and convenient. It supports various queries efficiently, that are not easily possible using just `bNodeTree`. `DerivedNodeTree` builds on top of `NodeTreeRef`. It contains a flattened view on the node tree, i.e. with node groups being inlined. Every inlined node still knows its "call stack". It supports pretty much the same queries as `NodeTreeRef`. Both data structures come with a dot graph exporter for debugging purposes. Reviewers: brecht Differential Revision: https://developer.blender.org/D7628
2020-06-09 17:08:41 +02:00
const NodeRef &node() const;
const NodeTreeRef &tree() const;
Refactor: Update integer type usage This updates the usage of integer types in code I wrote according to our new style guides. Major changes: * Use signed instead of unsigned integers in many places. * C++ containers in blenlib use `int64_t` for size and indices now (instead of `uint`). * Hash values for C++ containers are 64 bit wide now (instead of 32 bit). I do hope that I broke no builds, but it is quite likely that some compiler reports slightly different errors. Please let me know when there are any errors. If the fix is small, feel free to commit it yourself. I compiled successfully on linux with gcc and on windows.
2020-07-20 12:16:20 +02:00
int id() const;
int index() const;
Nodes: efficient node tree queries and inlining This adds two data structures that wrap a node tree. However, they work on different abstraction levels. `NodeTreeRef` is an immutable structure that makes working with a node tree in C++ much more efficient and convenient. It supports various queries efficiently, that are not easily possible using just `bNodeTree`. `DerivedNodeTree` builds on top of `NodeTreeRef`. It contains a flattened view on the node tree, i.e. with node groups being inlined. Every inlined node still knows its "call stack". It supports pretty much the same queries as `NodeTreeRef`. Both data structures come with a dot graph exporter for debugging purposes. Reviewers: brecht Differential Revision: https://developer.blender.org/D7628
2020-06-09 17:08:41 +02:00
bool is_input() const;
bool is_output() const;
const SocketRef &as_base() const;
const InputSocketRef &as_input() const;
const OutputSocketRef &as_output() const;
PointerRNA *rna() const;
StringRefNull idname() const;
StringRefNull name() const;
Geometry Nodes: initial scattering and geometry nodes This is the initial merge from the geometry-nodes branch. Nodes: * Attribute Math * Boolean * Edge Split * Float Compare * Object Info * Point Distribute * Point Instance * Random Attribute * Random Float * Subdivision Surface * Transform * Triangulate It includes the initial evaluation of geometry node groups in the Geometry Nodes modifier. Notes on the Generic attribute access API The API adds an indirection for attribute access. That has the following benefits: * Most code does not have to care about how an attribute is stored internally. This is mainly necessary, because we have to deal with "legacy" attributes such as vertex weights and attributes that are embedded into other structs such as vertex positions. * When reading from an attribute, we generally don't care what domain the attribute is stored on. So we want to abstract away the interpolation that that adapts attributes from one domain to another domain (this is not actually implemented yet). Other possible improvements for later iterations include: * Actually implement interpolation between domains. * Don't use inheritance for the different attribute types. A single class for read access and one for write access might be enough, because we know all the ways in which attributes are stored internally. We don't want more different internal structures in the future. On the contrary, ideally we can consolidate the different storage formats in the future to reduce the need for this indirection. * Remove the need for heap allocations when creating attribute accessors. It includes commits from: * Dalai Felinto * Hans Goudey * Jacques Lucke * Léo Depoix
2020-12-02 13:25:25 +01:00
StringRefNull identifier() const;
Nodes: improve NodeTreeRef This adds a couple more utility methods to various node tree ref types. Also `InternalLinkRef` has been added to get simpler access to internal links.
2021-03-04 18:15:22 +01:00
bNodeSocketType *typeinfo() const;
Nodes: efficient node tree queries and inlining This adds two data structures that wrap a node tree. However, they work on different abstraction levels. `NodeTreeRef` is an immutable structure that makes working with a node tree in C++ much more efficient and convenient. It supports various queries efficiently, that are not easily possible using just `bNodeTree`. `DerivedNodeTree` builds on top of `NodeTreeRef`. It contains a flattened view on the node tree, i.e. with node groups being inlined. Every inlined node still knows its "call stack". It supports pretty much the same queries as `NodeTreeRef`. Both data structures come with a dot graph exporter for debugging purposes. Reviewers: brecht Differential Revision: https://developer.blender.org/D7628
2020-06-09 17:08:41 +02:00
bNodeSocket *bsocket() const;
bNode *bnode() const;
bNodeTree *btree() const;
Nodes: improve NodeTreeRef This adds a couple more utility methods to various node tree ref types. Also `InternalLinkRef` has been added to get simpler access to internal links.
2021-03-04 18:15:22 +01:00
bool is_available() const;
Nodes: add utilities to check if there are undefined nodes/sockets
2021-06-11 14:54:44 +02:00
bool is_undefined() const;
Nodes: provide access to type specific data through node tree ref
2021-03-19 20:35:48 +01:00
void *default_value() const;
template<typename T> T *default_value() const;
Nodes: efficient node tree queries and inlining This adds two data structures that wrap a node tree. However, they work on different abstraction levels. `NodeTreeRef` is an immutable structure that makes working with a node tree in C++ much more efficient and convenient. It supports various queries efficiently, that are not easily possible using just `bNodeTree`. `DerivedNodeTree` builds on top of `NodeTreeRef`. It contains a flattened view on the node tree, i.e. with node groups being inlined. Every inlined node still knows its "call stack". It supports pretty much the same queries as `NodeTreeRef`. Both data structures come with a dot graph exporter for debugging purposes. Reviewers: brecht Differential Revision: https://developer.blender.org/D7628
2020-06-09 17:08:41 +02:00
};
class InputSocketRef final : public SocketRef {
public:
Fix T87659: crash when creating reroute loop in geometry nodes This was a regression introduced in rB0ff3f96a1b0193d69dae5ca69e7c93d6cdf34558.
2021-04-21 16:21:54 +02:00
friend NodeTreeRef;
Nodes: make distinction between directly and logically linked sockets more clear This also moves the handling of muted nodes from derived node tree to node tree ref.
2021-03-19 21:10:55 +01:00
Span<const OutputSocketRef *> logically_linked_sockets() const;
Nodes: efficient node tree queries and inlining This adds two data structures that wrap a node tree. However, they work on different abstraction levels. `NodeTreeRef` is an immutable structure that makes working with a node tree in C++ much more efficient and convenient. It supports various queries efficiently, that are not easily possible using just `bNodeTree`. `DerivedNodeTree` builds on top of `NodeTreeRef`. It contains a flattened view on the node tree, i.e. with node groups being inlined. Every inlined node still knows its "call stack". It supports pretty much the same queries as `NodeTreeRef`. Both data structures come with a dot graph exporter for debugging purposes. Reviewers: brecht Differential Revision: https://developer.blender.org/D7628
2020-06-09 17:08:41 +02:00
Span<const OutputSocketRef *> directly_linked_sockets() const;
Nodes: improve NodeTreeRef This adds a couple more utility methods to various node tree ref types. Also `InternalLinkRef` has been added to get simpler access to internal links.
2021-03-04 18:15:22 +01:00
bool is_multi_input_socket() const;
Geometry Nodes: add socket value logging capability The node tree evaluator now calls a callback for every used socket with its corresponding value(s). Right now the callback does nothing. However, we can use it to collect attribute name hints, socket values for debugging or data that will be displayed in the spreadsheet. The main difficulty here was to also call the callback for sockets in nodes that are not directly executed (such as group nodes, muted nodes and reroutes). No functional changes are expected.
2021-04-01 13:10:22 +02:00
Fix T87659: crash when creating reroute loop in geometry nodes This was a regression introduced in rB0ff3f96a1b0193d69dae5ca69e7c93d6cdf34558.
2021-04-21 16:21:54 +02:00
private:
Geometry Nodes: add socket value logging capability The node tree evaluator now calls a callback for every used socket with its corresponding value(s). Right now the callback does nothing. However, we can use it to collect attribute name hints, socket values for debugging or data that will be displayed in the spreadsheet. The main difficulty here was to also call the callback for sockets in nodes that are not directly executed (such as group nodes, muted nodes and reroutes). No functional changes are expected.
2021-04-01 13:10:22 +02:00
void foreach_logical_origin(FunctionRef<void(const OutputSocketRef &)> origin_fn,
FunctionRef<void(const SocketRef &)> skipped_fn,
Fix T87659: crash when creating reroute loop in geometry nodes This was a regression introduced in rB0ff3f96a1b0193d69dae5ca69e7c93d6cdf34558.
2021-04-21 16:21:54 +02:00
bool only_follow_first_input_link,
Fix T89390: crash when join geometry node has only muted inputs
2021-06-24 15:45:43 +02:00
Vector<const InputSocketRef *> &seen_sockets_stack) const;
Nodes: efficient node tree queries and inlining This adds two data structures that wrap a node tree. However, they work on different abstraction levels. `NodeTreeRef` is an immutable structure that makes working with a node tree in C++ much more efficient and convenient. It supports various queries efficiently, that are not easily possible using just `bNodeTree`. `DerivedNodeTree` builds on top of `NodeTreeRef`. It contains a flattened view on the node tree, i.e. with node groups being inlined. Every inlined node still knows its "call stack". It supports pretty much the same queries as `NodeTreeRef`. Both data structures come with a dot graph exporter for debugging purposes. Reviewers: brecht Differential Revision: https://developer.blender.org/D7628
2020-06-09 17:08:41 +02:00
};
class OutputSocketRef final : public SocketRef {
public:
Fix T87659: crash when creating reroute loop in geometry nodes This was a regression introduced in rB0ff3f96a1b0193d69dae5ca69e7c93d6cdf34558.
2021-04-21 16:21:54 +02:00
friend NodeTreeRef;
Nodes: make distinction between directly and logically linked sockets more clear This also moves the handling of muted nodes from derived node tree to node tree ref.
2021-03-19 21:10:55 +01:00
Span<const InputSocketRef *> logically_linked_sockets() const;
Nodes: efficient node tree queries and inlining This adds two data structures that wrap a node tree. However, they work on different abstraction levels. `NodeTreeRef` is an immutable structure that makes working with a node tree in C++ much more efficient and convenient. It supports various queries efficiently, that are not easily possible using just `bNodeTree`. `DerivedNodeTree` builds on top of `NodeTreeRef`. It contains a flattened view on the node tree, i.e. with node groups being inlined. Every inlined node still knows its "call stack". It supports pretty much the same queries as `NodeTreeRef`. Both data structures come with a dot graph exporter for debugging purposes. Reviewers: brecht Differential Revision: https://developer.blender.org/D7628
2020-06-09 17:08:41 +02:00
Span<const InputSocketRef *> directly_linked_sockets() const;
Geometry Nodes: add socket value logging capability The node tree evaluator now calls a callback for every used socket with its corresponding value(s). Right now the callback does nothing. However, we can use it to collect attribute name hints, socket values for debugging or data that will be displayed in the spreadsheet. The main difficulty here was to also call the callback for sockets in nodes that are not directly executed (such as group nodes, muted nodes and reroutes). No functional changes are expected.
2021-04-01 13:10:22 +02:00
Fix T87659: crash when creating reroute loop in geometry nodes This was a regression introduced in rB0ff3f96a1b0193d69dae5ca69e7c93d6cdf34558.
2021-04-21 16:21:54 +02:00
private:
Geometry Nodes: add socket value logging capability The node tree evaluator now calls a callback for every used socket with its corresponding value(s). Right now the callback does nothing. However, we can use it to collect attribute name hints, socket values for debugging or data that will be displayed in the spreadsheet. The main difficulty here was to also call the callback for sockets in nodes that are not directly executed (such as group nodes, muted nodes and reroutes). No functional changes are expected.
2021-04-01 13:10:22 +02:00
void foreach_logical_target(FunctionRef<void(const InputSocketRef &)> target_fn,
Fix T87659: crash when creating reroute loop in geometry nodes This was a regression introduced in rB0ff3f96a1b0193d69dae5ca69e7c93d6cdf34558.
2021-04-21 16:21:54 +02:00
FunctionRef<void(const SocketRef &)> skipped_fn,
Fix T89390: crash when join geometry node has only muted inputs
2021-06-24 15:45:43 +02:00
Vector<const OutputSocketRef *> &seen_sockets_stack) const;
Nodes: efficient node tree queries and inlining This adds two data structures that wrap a node tree. However, they work on different abstraction levels. `NodeTreeRef` is an immutable structure that makes working with a node tree in C++ much more efficient and convenient. It supports various queries efficiently, that are not easily possible using just `bNodeTree`. `DerivedNodeTree` builds on top of `NodeTreeRef`. It contains a flattened view on the node tree, i.e. with node groups being inlined. Every inlined node still knows its "call stack". It supports pretty much the same queries as `NodeTreeRef`. Both data structures come with a dot graph exporter for debugging purposes. Reviewers: brecht Differential Revision: https://developer.blender.org/D7628
2020-06-09 17:08:41 +02:00
};
Cleanup: remove unnecessary namespace specifiers
2020-06-30 10:35:50 +02:00
class NodeRef : NonCopyable, NonMovable {
Nodes: efficient node tree queries and inlining This adds two data structures that wrap a node tree. However, they work on different abstraction levels. `NodeTreeRef` is an immutable structure that makes working with a node tree in C++ much more efficient and convenient. It supports various queries efficiently, that are not easily possible using just `bNodeTree`. `DerivedNodeTree` builds on top of `NodeTreeRef`. It contains a flattened view on the node tree, i.e. with node groups being inlined. Every inlined node still knows its "call stack". It supports pretty much the same queries as `NodeTreeRef`. Both data structures come with a dot graph exporter for debugging purposes. Reviewers: brecht Differential Revision: https://developer.blender.org/D7628
2020-06-09 17:08:41 +02:00
private:
Cleanup: Use trailing underscore for non-public data members This makes the code conform better with our style guide.
2020-07-03 14:15:05 +02:00
NodeTreeRef *tree_;
bNode *bnode_;
PointerRNA rna_;
Refactor: Update integer type usage This updates the usage of integer types in code I wrote according to our new style guides. Major changes: * Use signed instead of unsigned integers in many places. * C++ containers in blenlib use `int64_t` for size and indices now (instead of `uint`). * Hash values for C++ containers are 64 bit wide now (instead of 32 bit). I do hope that I broke no builds, but it is quite likely that some compiler reports slightly different errors. Please let me know when there are any errors. If the fix is small, feel free to commit it yourself. I compiled successfully on linux with gcc and on windows.
2020-07-20 12:16:20 +02:00
int id_;
Cleanup: Use trailing underscore for non-public data members This makes the code conform better with our style guide.
2020-07-03 14:15:05 +02:00
Vector<InputSocketRef *> inputs_;
Vector<OutputSocketRef *> outputs_;
Nodes: improve NodeTreeRef This adds a couple more utility methods to various node tree ref types. Also `InternalLinkRef` has been added to get simpler access to internal links.
2021-03-04 18:15:22 +01:00
Vector<InternalLinkRef *> internal_links_;
Nodes: cache socket identifier to index mapping While this preprocessing does take some time upfront, it avoids longer lookup later on, especially as nodes get more sockets. It's probably possible to make this more efficient in some cases but this is good enough for now.
2021-06-11 16:21:08 +02:00
SocketIndexByIdentifierMap *input_index_by_identifier_;
SocketIndexByIdentifierMap *output_index_by_identifier_;
Nodes: efficient node tree queries and inlining This adds two data structures that wrap a node tree. However, they work on different abstraction levels. `NodeTreeRef` is an immutable structure that makes working with a node tree in C++ much more efficient and convenient. It supports various queries efficiently, that are not easily possible using just `bNodeTree`. `DerivedNodeTree` builds on top of `NodeTreeRef`. It contains a flattened view on the node tree, i.e. with node groups being inlined. Every inlined node still knows its "call stack". It supports pretty much the same queries as `NodeTreeRef`. Both data structures come with a dot graph exporter for debugging purposes. Reviewers: brecht Differential Revision: https://developer.blender.org/D7628
2020-06-09 17:08:41 +02:00
friend NodeTreeRef;
public:
const NodeTreeRef &tree() const;
Span<const InputSocketRef *> inputs() const;
Span<const OutputSocketRef *> outputs() const;
Nodes: improve NodeTreeRef This adds a couple more utility methods to various node tree ref types. Also `InternalLinkRef` has been added to get simpler access to internal links.
2021-03-04 18:15:22 +01:00
Span<const InternalLinkRef *> internal_links() const;
Geometry Nodes: Initial socket visualization for fields. This implements the update logic for the vizualization of which sockets pass data or constants directly, and which pass functions. The socket shapes may still have to be updated. That should be done separately, because it might be a bit more involved, because socket shapes are currently linked to keyframe shapes. Currently the circle and diamond shapes are used with the following meanings: - Input Sockets: - Circle: Required to be a single value. - Diamond: This input supports fields. - Output Sockets: - Circle: This output is a single value. - Diamond: This output may be a field. Connecting a field to a circle input socket is an error, since a field cannot be converted to a single value. If the socket shape is a diamond with a dot in the middle, it means it is currently a single value, but could be a field. In addition to socket shapes, the intention is to draw node links differently based on the field status. However, the exact method for conveying that isn't decided yet. Differential Revision: https://developer.blender.org/D12584
2021-09-23 15:21:31 -05:00
Span<const SocketRef *> sockets(eNodeSocketInOut in_out) const;
Nodes: efficient node tree queries and inlining This adds two data structures that wrap a node tree. However, they work on different abstraction levels. `NodeTreeRef` is an immutable structure that makes working with a node tree in C++ much more efficient and convenient. It supports various queries efficiently, that are not easily possible using just `bNodeTree`. `DerivedNodeTree` builds on top of `NodeTreeRef`. It contains a flattened view on the node tree, i.e. with node groups being inlined. Every inlined node still knows its "call stack". It supports pretty much the same queries as `NodeTreeRef`. Both data structures come with a dot graph exporter for debugging purposes. Reviewers: brecht Differential Revision: https://developer.blender.org/D7628
2020-06-09 17:08:41 +02:00
Refactor: Update integer type usage This updates the usage of integer types in code I wrote according to our new style guides. Major changes: * Use signed instead of unsigned integers in many places. * C++ containers in blenlib use `int64_t` for size and indices now (instead of `uint`). * Hash values for C++ containers are 64 bit wide now (instead of 32 bit). I do hope that I broke no builds, but it is quite likely that some compiler reports slightly different errors. Please let me know when there are any errors. If the fix is small, feel free to commit it yourself. I compiled successfully on linux with gcc and on windows.
2020-07-20 12:16:20 +02:00
const InputSocketRef &input(int index) const;
const OutputSocketRef &output(int index) const;
Nodes: efficient node tree queries and inlining This adds two data structures that wrap a node tree. However, they work on different abstraction levels. `NodeTreeRef` is an immutable structure that makes working with a node tree in C++ much more efficient and convenient. It supports various queries efficiently, that are not easily possible using just `bNodeTree`. `DerivedNodeTree` builds on top of `NodeTreeRef`. It contains a flattened view on the node tree, i.e. with node groups being inlined. Every inlined node still knows its "call stack". It supports pretty much the same queries as `NodeTreeRef`. Both data structures come with a dot graph exporter for debugging purposes. Reviewers: brecht Differential Revision: https://developer.blender.org/D7628
2020-06-09 17:08:41 +02:00
Nodes: cache socket identifier to index mapping While this preprocessing does take some time upfront, it avoids longer lookup later on, especially as nodes get more sockets. It's probably possible to make this more efficient in some cases but this is good enough for now.
2021-06-11 16:21:08 +02:00
const InputSocketRef &input_by_identifier(StringRef identifier) const;
const OutputSocketRef &output_by_identifier(StringRef identifier) const;
Geometry Nodes: Initial socket visualization for fields. This implements the update logic for the vizualization of which sockets pass data or constants directly, and which pass functions. The socket shapes may still have to be updated. That should be done separately, because it might be a bit more involved, because socket shapes are currently linked to keyframe shapes. Currently the circle and diamond shapes are used with the following meanings: - Input Sockets: - Circle: Required to be a single value. - Diamond: This input supports fields. - Output Sockets: - Circle: This output is a single value. - Diamond: This output may be a field. Connecting a field to a circle input socket is an error, since a field cannot be converted to a single value. If the socket shape is a diamond with a dot in the middle, it means it is currently a single value, but could be a field. In addition to socket shapes, the intention is to draw node links differently based on the field status. However, the exact method for conveying that isn't decided yet. Differential Revision: https://developer.blender.org/D12584
2021-09-23 15:21:31 -05:00
bool any_input_is_directly_linked() const;
bool any_output_is_directly_linked() const;
bool any_socket_is_directly_linked(eNodeSocketInOut in_out) const;
Nodes: efficient node tree queries and inlining This adds two data structures that wrap a node tree. However, they work on different abstraction levels. `NodeTreeRef` is an immutable structure that makes working with a node tree in C++ much more efficient and convenient. It supports various queries efficiently, that are not easily possible using just `bNodeTree`. `DerivedNodeTree` builds on top of `NodeTreeRef`. It contains a flattened view on the node tree, i.e. with node groups being inlined. Every inlined node still knows its "call stack". It supports pretty much the same queries as `NodeTreeRef`. Both data structures come with a dot graph exporter for debugging purposes. Reviewers: brecht Differential Revision: https://developer.blender.org/D7628
2020-06-09 17:08:41 +02:00
bNode *bnode() const;
bNodeTree *btree() const;
PointerRNA *rna() const;
StringRefNull idname() const;
StringRefNull name() const;
Geometry Nodes: remove reference to anonymous attributes in tooltips This changes socket inspection for fields according to T91881. Differential Revision: https://developer.blender.org/D13006
2021-10-26 15:32:01 +02:00
StringRefNull label() const;
StringRefNull label_or_name() const;
Nodes: improve NodeTreeRef This adds a couple more utility methods to various node tree ref types. Also `InternalLinkRef` has been added to get simpler access to internal links.
2021-03-04 18:15:22 +01:00
bNodeType *typeinfo() const;
Geometry Nodes: Initial socket visualization for fields. This implements the update logic for the vizualization of which sockets pass data or constants directly, and which pass functions. The socket shapes may still have to be updated. That should be done separately, because it might be a bit more involved, because socket shapes are currently linked to keyframe shapes. Currently the circle and diamond shapes are used with the following meanings: - Input Sockets: - Circle: Required to be a single value. - Diamond: This input supports fields. - Output Sockets: - Circle: This output is a single value. - Diamond: This output may be a field. Connecting a field to a circle input socket is an error, since a field cannot be converted to a single value. If the socket shape is a diamond with a dot in the middle, it means it is currently a single value, but could be a field. In addition to socket shapes, the intention is to draw node links differently based on the field status. However, the exact method for conveying that isn't decided yet. Differential Revision: https://developer.blender.org/D12584
2021-09-23 15:21:31 -05:00
const NodeDeclaration *declaration() const;
Nodes: efficient node tree queries and inlining This adds two data structures that wrap a node tree. However, they work on different abstraction levels. `NodeTreeRef` is an immutable structure that makes working with a node tree in C++ much more efficient and convenient. It supports various queries efficiently, that are not easily possible using just `bNodeTree`. `DerivedNodeTree` builds on top of `NodeTreeRef`. It contains a flattened view on the node tree, i.e. with node groups being inlined. Every inlined node still knows its "call stack". It supports pretty much the same queries as `NodeTreeRef`. Both data structures come with a dot graph exporter for debugging purposes. Reviewers: brecht Differential Revision: https://developer.blender.org/D7628
2020-06-09 17:08:41 +02:00
Refactor: Update integer type usage This updates the usage of integer types in code I wrote according to our new style guides. Major changes: * Use signed instead of unsigned integers in many places. * C++ containers in blenlib use `int64_t` for size and indices now (instead of `uint`). * Hash values for C++ containers are 64 bit wide now (instead of 32 bit). I do hope that I broke no builds, but it is quite likely that some compiler reports slightly different errors. Please let me know when there are any errors. If the fix is small, feel free to commit it yourself. I compiled successfully on linux with gcc and on windows.
2020-07-20 12:16:20 +02:00
int id() const;
Nodes: efficient node tree queries and inlining This adds two data structures that wrap a node tree. However, they work on different abstraction levels. `NodeTreeRef` is an immutable structure that makes working with a node tree in C++ much more efficient and convenient. It supports various queries efficiently, that are not easily possible using just `bNodeTree`. `DerivedNodeTree` builds on top of `NodeTreeRef`. It contains a flattened view on the node tree, i.e. with node groups being inlined. Every inlined node still knows its "call stack". It supports pretty much the same queries as `NodeTreeRef`. Both data structures come with a dot graph exporter for debugging purposes. Reviewers: brecht Differential Revision: https://developer.blender.org/D7628
2020-06-09 17:08:41 +02:00
bool is_reroute_node() const;
bool is_group_node() const;
bool is_group_input_node() const;
bool is_group_output_node() const;
Geometry Nodes: support muted nodes The handling of muted nodes is handled at the derived node tree level now. This is also where expanding node groups is handled. Muted nodes are relinked and removed from the derived tree during construction. The geometry node evaluation code does not have to know about muted nodes this way.
2020-11-27 19:38:14 +01:00
bool is_muted() const;
Nodes: expose tree name and whether a node is a frame in node tree ref
2021-03-19 22:33:43 +01:00
bool is_frame() const;
Nodes: add utilities to check if there are undefined nodes/sockets
2021-06-11 14:54:44 +02:00
bool is_undefined() const;
Nodes: provide access to type specific data through node tree ref
2021-03-19 20:35:48 +01:00
void *storage() const;
template<typename T> T *storage() const;
Nodes: efficient node tree queries and inlining This adds two data structures that wrap a node tree. However, they work on different abstraction levels. `NodeTreeRef` is an immutable structure that makes working with a node tree in C++ much more efficient and convenient. It supports various queries efficiently, that are not easily possible using just `bNodeTree`. `DerivedNodeTree` builds on top of `NodeTreeRef`. It contains a flattened view on the node tree, i.e. with node groups being inlined. Every inlined node still knows its "call stack". It supports pretty much the same queries as `NodeTreeRef`. Both data structures come with a dot graph exporter for debugging purposes. Reviewers: brecht Differential Revision: https://developer.blender.org/D7628
2020-06-09 17:08:41 +02:00
};
Nodes: store references to bNodeLinks in NodeTreeRef Sometimes it is useful to have this information available to be able to read information from links.
2021-03-03 07:59:07 +01:00
class LinkRef : NonCopyable, NonMovable {
private:
OutputSocketRef *from_;
InputSocketRef *to_;
bNodeLink *blink_;
friend NodeTreeRef;
public:
const OutputSocketRef &from() const;
const InputSocketRef &to() const;
bNodeLink *blink() const;
Nodes: make derived link data more obvious in NodeTreeRef `NodeTreeRef` is a thin wrapper on top of `bNodeTree`. By default it should not hide anything from the underlying `bNodeTree` (before this it was hiding muted links). For convenience some "derived" data is cached on sockets. For example all the connected sockets when reroutes and muted links are ignored. A nice side benefit of this refactor is that `NodeTreeRef` requires less memory than before.
2021-03-17 16:43:06 +01:00
bool is_muted() const;
Nodes: store references to bNodeLinks in NodeTreeRef Sometimes it is useful to have this information available to be able to read information from links.
2021-03-03 07:59:07 +01:00
};
Nodes: improve NodeTreeRef This adds a couple more utility methods to various node tree ref types. Also `InternalLinkRef` has been added to get simpler access to internal links.
2021-03-04 18:15:22 +01:00
class InternalLinkRef : NonCopyable, NonMovable {
private:
InputSocketRef *from_;
OutputSocketRef *to_;
bNodeLink *blink_;
friend NodeTreeRef;
public:
const InputSocketRef &from() const;
const OutputSocketRef &to() const;
bNodeLink *blink() const;
};
Cleanup: remove unnecessary namespace specifiers
2020-06-30 10:35:50 +02:00
class NodeTreeRef : NonCopyable, NonMovable {
Nodes: efficient node tree queries and inlining This adds two data structures that wrap a node tree. However, they work on different abstraction levels. `NodeTreeRef` is an immutable structure that makes working with a node tree in C++ much more efficient and convenient. It supports various queries efficiently, that are not easily possible using just `bNodeTree`. `DerivedNodeTree` builds on top of `NodeTreeRef`. It contains a flattened view on the node tree, i.e. with node groups being inlined. Every inlined node still knows its "call stack". It supports pretty much the same queries as `NodeTreeRef`. Both data structures come with a dot graph exporter for debugging purposes. Reviewers: brecht Differential Revision: https://developer.blender.org/D7628
2020-06-09 17:08:41 +02:00
private:
Cleanup: Use trailing underscore for non-public data members This makes the code conform better with our style guide.
2020-07-03 14:15:05 +02:00
LinearAllocator<> allocator_;
bNodeTree *btree_;
Vector<NodeRef *> nodes_by_id_;
Vector<SocketRef *> sockets_by_id_;
Vector<InputSocketRef *> input_sockets_;
Vector<OutputSocketRef *> output_sockets_;
Nodes: store references to bNodeLinks in NodeTreeRef Sometimes it is useful to have this information available to be able to read information from links.
2021-03-03 07:59:07 +01:00
Vector<LinkRef *> links_;
BLI: add MultiValueMap This is a convenience wrapper for `Map<Key, Vector<Value>>`. It does not provide any performance benefits (yet). I need this kind of map in a couple of places and before I was duplicating the lookup logic in many places.
2020-07-24 12:15:13 +02:00
MultiValueMap<const bNodeType *, NodeRef *> nodes_by_type_;
Nodes: cache socket identifier to index mapping While this preprocessing does take some time upfront, it avoids longer lookup later on, especially as nodes get more sockets. It's probably possible to make this more efficient in some cases but this is good enough for now.
2021-06-11 16:21:08 +02:00
Vector<std::unique_ptr<SocketIndexByIdentifierMap>> owned_identifier_maps_;
Fix T94162: incorrect handling when there are multiple group outputs Typically a node group should only have a single Group Output node. However, currently Blender already supports having multiple group outputs, one of which is active. This wasn't handled correctly by geometry nodes. Differential Revision: https://developer.blender.org/D13611
2021-12-24 12:34:04 +01:00
const NodeRef *group_output_node_ = nullptr;
Nodes: efficient node tree queries and inlining This adds two data structures that wrap a node tree. However, they work on different abstraction levels. `NodeTreeRef` is an immutable structure that makes working with a node tree in C++ much more efficient and convenient. It supports various queries efficiently, that are not easily possible using just `bNodeTree`. `DerivedNodeTree` builds on top of `NodeTreeRef`. It contains a flattened view on the node tree, i.e. with node groups being inlined. Every inlined node still knows its "call stack". It supports pretty much the same queries as `NodeTreeRef`. Both data structures come with a dot graph exporter for debugging purposes. Reviewers: brecht Differential Revision: https://developer.blender.org/D7628
2020-06-09 17:08:41 +02:00
public:
NodeTreeRef(bNodeTree *btree);
~NodeTreeRef();
Span<const NodeRef *> nodes() const;
Nodes: store nodes by bNodeType instead of idname This is more efficient in most cases.
2020-06-30 13:35:38 +02:00
Span<const NodeRef *> nodes_by_type(StringRefNull idname) const;
Span<const NodeRef *> nodes_by_type(const bNodeType *nodetype) const;
Nodes: efficient node tree queries and inlining This adds two data structures that wrap a node tree. However, they work on different abstraction levels. `NodeTreeRef` is an immutable structure that makes working with a node tree in C++ much more efficient and convenient. It supports various queries efficiently, that are not easily possible using just `bNodeTree`. `DerivedNodeTree` builds on top of `NodeTreeRef`. It contains a flattened view on the node tree, i.e. with node groups being inlined. Every inlined node still knows its "call stack". It supports pretty much the same queries as `NodeTreeRef`. Both data structures come with a dot graph exporter for debugging purposes. Reviewers: brecht Differential Revision: https://developer.blender.org/D7628
2020-06-09 17:08:41 +02:00
Span<const SocketRef *> sockets() const;
Span<const InputSocketRef *> input_sockets() const;
Span<const OutputSocketRef *> output_sockets() const;
Nodes: store references to bNodeLinks in NodeTreeRef Sometimes it is useful to have this information available to be able to read information from links.
2021-03-03 07:59:07 +01:00
Span<const LinkRef *> links() const;
Nodes: add utility to find NodeRef for node In the future `NodeTreeRef` could have a lazy initialized map, but for now this is good enough.
2021-10-21 15:38:41 +02:00
const NodeRef *find_node(const bNode &bnode) const;
Fix T94162: incorrect handling when there are multiple group outputs Typically a node group should only have a single Group Output node. However, currently Blender already supports having multiple group outputs, one of which is active. This wasn't handled correctly by geometry nodes. Differential Revision: https://developer.blender.org/D13611
2021-12-24 12:34:04 +01:00
/**
* This is the active group output node if there are multiple.
*/
const NodeRef *group_output_node() const;
Cleanup: move public doc-strings into headers for 'nodes' Ref T92709
2021-12-10 21:40:30 +11:00
/**
* \return True when there is a link cycle. Unavailable sockets are ignored.
*/
Geometry Nodes: initial scattering and geometry nodes This is the initial merge from the geometry-nodes branch. Nodes: * Attribute Math * Boolean * Edge Split * Float Compare * Object Info * Point Distribute * Point Instance * Random Attribute * Random Float * Subdivision Surface * Transform * Triangulate It includes the initial evaluation of geometry node groups in the Geometry Nodes modifier. Notes on the Generic attribute access API The API adds an indirection for attribute access. That has the following benefits: * Most code does not have to care about how an attribute is stored internally. This is mainly necessary, because we have to deal with "legacy" attributes such as vertex weights and attributes that are embedded into other structs such as vertex positions. * When reading from an attribute, we generally don't care what domain the attribute is stored on. So we want to abstract away the interpolation that that adapts attributes from one domain to another domain (this is not actually implemented yet). Other possible improvements for later iterations include: * Actually implement interpolation between domains. * Don't use inheritance for the different attribute types. A single class for read access and one for write access might be enough, because we know all the ways in which attributes are stored internally. We don't want more different internal structures in the future. On the contrary, ideally we can consolidate the different storage formats in the future to reduce the need for this indirection. * Remove the need for heap allocations when creating attribute accessors. It includes commits from: * Dalai Felinto * Hans Goudey * Jacques Lucke * Léo Depoix
2020-12-02 13:25:25 +01:00
bool has_link_cycles() const;
Nodes: add utilities to check if there are undefined nodes/sockets
2021-06-11 14:54:44 +02:00
bool has_undefined_nodes_or_sockets() const;
Geometry Nodes: initial scattering and geometry nodes This is the initial merge from the geometry-nodes branch. Nodes: * Attribute Math * Boolean * Edge Split * Float Compare * Object Info * Point Distribute * Point Instance * Random Attribute * Random Float * Subdivision Surface * Transform * Triangulate It includes the initial evaluation of geometry node groups in the Geometry Nodes modifier. Notes on the Generic attribute access API The API adds an indirection for attribute access. That has the following benefits: * Most code does not have to care about how an attribute is stored internally. This is mainly necessary, because we have to deal with "legacy" attributes such as vertex weights and attributes that are embedded into other structs such as vertex positions. * When reading from an attribute, we generally don't care what domain the attribute is stored on. So we want to abstract away the interpolation that that adapts attributes from one domain to another domain (this is not actually implemented yet). Other possible improvements for later iterations include: * Actually implement interpolation between domains. * Don't use inheritance for the different attribute types. A single class for read access and one for write access might be enough, because we know all the ways in which attributes are stored internally. We don't want more different internal structures in the future. On the contrary, ideally we can consolidate the different storage formats in the future to reduce the need for this indirection. * Remove the need for heap allocations when creating attribute accessors. It includes commits from: * Dalai Felinto * Hans Goudey * Jacques Lucke * Léo Depoix
2020-12-02 13:25:25 +01:00
Geometry Nodes: Initial socket visualization for fields. This implements the update logic for the vizualization of which sockets pass data or constants directly, and which pass functions. The socket shapes may still have to be updated. That should be done separately, because it might be a bit more involved, because socket shapes are currently linked to keyframe shapes. Currently the circle and diamond shapes are used with the following meanings: - Input Sockets: - Circle: Required to be a single value. - Diamond: This input supports fields. - Output Sockets: - Circle: This output is a single value. - Diamond: This output may be a field. Connecting a field to a circle input socket is an error, since a field cannot be converted to a single value. If the socket shape is a diamond with a dot in the middle, it means it is currently a single value, but could be a field. In addition to socket shapes, the intention is to draw node links differently based on the field status. However, the exact method for conveying that isn't decided yet. Differential Revision: https://developer.blender.org/D12584
2021-09-23 15:21:31 -05:00
enum class ToposortDirection {
LeftToRight,
RightToLeft,
};
Fix T92328: crash during field inferencing when there is a link cycle The toposort did not handle link cycles which it should.
2021-10-27 12:29:46 +02:00
struct ToposortResult {
Vector<const NodeRef *> sorted_nodes;
/**
Cleanup: spelling, use C comments
2021-11-01 14:00:58 +11:00
* There can't be a correct topological sort of the nodes when there is a cycle. The nodes will
Fix T92328: crash during field inferencing when there is a link cycle The toposort did not handle link cycles which it should.
2021-10-27 12:29:46 +02:00
* still be sorted to some degree. The caller has to decide whether it can handle non-perfect
* sorts or not.
*/
bool has_cycle = false;
};
Cleanup: move public doc-strings into headers for 'nodes' Ref T92709
2021-12-10 21:40:30 +11:00
/**
* Sort nodes topologically from left to right or right to left.
* In the future the result if this could be cached on #NodeTreeRef.
*/
Fix T92328: crash during field inferencing when there is a link cycle The toposort did not handle link cycles which it should.
2021-10-27 12:29:46 +02:00
ToposortResult toposort(ToposortDirection direction) const;
Geometry Nodes: Initial socket visualization for fields. This implements the update logic for the vizualization of which sockets pass data or constants directly, and which pass functions. The socket shapes may still have to be updated. That should be done separately, because it might be a bit more involved, because socket shapes are currently linked to keyframe shapes. Currently the circle and diamond shapes are used with the following meanings: - Input Sockets: - Circle: Required to be a single value. - Diamond: This input supports fields. - Output Sockets: - Circle: This output is a single value. - Diamond: This output may be a field. Connecting a field to a circle input socket is an error, since a field cannot be converted to a single value. If the socket shape is a diamond with a dot in the middle, it means it is currently a single value, but could be a field. In addition to socket shapes, the intention is to draw node links differently based on the field status. However, the exact method for conveying that isn't decided yet. Differential Revision: https://developer.blender.org/D12584
2021-09-23 15:21:31 -05:00
Nodes: efficient node tree queries and inlining This adds two data structures that wrap a node tree. However, they work on different abstraction levels. `NodeTreeRef` is an immutable structure that makes working with a node tree in C++ much more efficient and convenient. It supports various queries efficiently, that are not easily possible using just `bNodeTree`. `DerivedNodeTree` builds on top of `NodeTreeRef`. It contains a flattened view on the node tree, i.e. with node groups being inlined. Every inlined node still knows its "call stack". It supports pretty much the same queries as `NodeTreeRef`. Both data structures come with a dot graph exporter for debugging purposes. Reviewers: brecht Differential Revision: https://developer.blender.org/D7628
2020-06-09 17:08:41 +02:00
bNodeTree *btree() const;
Nodes: expose tree name and whether a node is a frame in node tree ref
2021-03-19 22:33:43 +01:00
StringRefNull name() const;
Nodes: efficient node tree queries and inlining This adds two data structures that wrap a node tree. However, they work on different abstraction levels. `NodeTreeRef` is an immutable structure that makes working with a node tree in C++ much more efficient and convenient. It supports various queries efficiently, that are not easily possible using just `bNodeTree`. `DerivedNodeTree` builds on top of `NodeTreeRef`. It contains a flattened view on the node tree, i.e. with node groups being inlined. Every inlined node still knows its "call stack". It supports pretty much the same queries as `NodeTreeRef`. Both data structures come with a dot graph exporter for debugging purposes. Reviewers: brecht Differential Revision: https://developer.blender.org/D7628
2020-06-09 17:08:41 +02:00
std::string to_dot() const;
private:
/* Utility functions used during construction. */
InputSocketRef &find_input_socket(Map<bNode *, NodeRef *> &node_mapping,
bNode *bnode,
bNodeSocket *bsocket);
OutputSocketRef &find_output_socket(Map<bNode *, NodeRef *> &node_mapping,
bNode *bnode,
bNodeSocket *bsocket);
Nodes: make derived link data more obvious in NodeTreeRef `NodeTreeRef` is a thin wrapper on top of `bNodeTree`. By default it should not hide anything from the underlying `bNodeTree` (before this it was hiding muted links). For convenience some "derived" data is cached on sockets. For example all the connected sockets when reroutes and muted links are ignored. A nice side benefit of this refactor is that `NodeTreeRef` requires less memory than before.
2021-03-17 16:43:06 +01:00
void create_linked_socket_caches();
Nodes: cache socket identifier to index mapping While this preprocessing does take some time upfront, it avoids longer lookup later on, especially as nodes get more sockets. It's probably possible to make this more efficient in some cases but this is good enough for now.
2021-06-11 16:21:08 +02:00
void create_socket_identifier_maps();
Nodes: efficient node tree queries and inlining This adds two data structures that wrap a node tree. However, they work on different abstraction levels. `NodeTreeRef` is an immutable structure that makes working with a node tree in C++ much more efficient and convenient. It supports various queries efficiently, that are not easily possible using just `bNodeTree`. `DerivedNodeTree` builds on top of `NodeTreeRef`. It contains a flattened view on the node tree, i.e. with node groups being inlined. Every inlined node still knows its "call stack". It supports pretty much the same queries as `NodeTreeRef`. Both data structures come with a dot graph exporter for debugging purposes. Reviewers: brecht Differential Revision: https://developer.blender.org/D7628
2020-06-09 17:08:41 +02:00
};
Nodes: improve NodeTreeRef This adds a couple more utility methods to various node tree ref types. Also `InternalLinkRef` has been added to get simpler access to internal links.
2021-03-04 18:15:22 +01:00
using NodeTreeRefMap = Map<bNodeTree *, std::unique_ptr<const NodeTreeRef>>;
const NodeTreeRef &get_tree_ref_from_map(NodeTreeRefMap &node_tree_refs, bNodeTree &btree);
namespace node_tree_ref_types {
using nodes::InputSocketRef;
using nodes::NodeRef;
using nodes::NodeTreeRef;
using nodes::NodeTreeRefMap;
using nodes::OutputSocketRef;
using nodes::SocketRef;
} // namespace node_tree_ref_types
Cleanup: use doxygen sections
2021-10-05 11:10:25 +11:00
/* -------------------------------------------------------------------- */
/** \name #SocketRef Inline Methods
* \{ */
Nodes: efficient node tree queries and inlining This adds two data structures that wrap a node tree. However, they work on different abstraction levels. `NodeTreeRef` is an immutable structure that makes working with a node tree in C++ much more efficient and convenient. It supports various queries efficiently, that are not easily possible using just `bNodeTree`. `DerivedNodeTree` builds on top of `NodeTreeRef`. It contains a flattened view on the node tree, i.e. with node groups being inlined. Every inlined node still knows its "call stack". It supports pretty much the same queries as `NodeTreeRef`. Both data structures come with a dot graph exporter for debugging purposes. Reviewers: brecht Differential Revision: https://developer.blender.org/D7628
2020-06-09 17:08:41 +02:00
Nodes: make distinction between directly and logically linked sockets more clear This also moves the handling of muted nodes from derived node tree to node tree ref.
2021-03-19 21:10:55 +01:00
inline Span<const SocketRef *> SocketRef::logically_linked_sockets() const
Nodes: efficient node tree queries and inlining This adds two data structures that wrap a node tree. However, they work on different abstraction levels. `NodeTreeRef` is an immutable structure that makes working with a node tree in C++ much more efficient and convenient. It supports various queries efficiently, that are not easily possible using just `bNodeTree`. `DerivedNodeTree` builds on top of `NodeTreeRef`. It contains a flattened view on the node tree, i.e. with node groups being inlined. Every inlined node still knows its "call stack". It supports pretty much the same queries as `NodeTreeRef`. Both data structures come with a dot graph exporter for debugging purposes. Reviewers: brecht Differential Revision: https://developer.blender.org/D7628
2020-06-09 17:08:41 +02:00
{
Nodes: make distinction between directly and logically linked sockets more clear This also moves the handling of muted nodes from derived node tree to node tree ref.
2021-03-19 21:10:55 +01:00
return logically_linked_sockets_;
Nodes: efficient node tree queries and inlining This adds two data structures that wrap a node tree. However, they work on different abstraction levels. `NodeTreeRef` is an immutable structure that makes working with a node tree in C++ much more efficient and convenient. It supports various queries efficiently, that are not easily possible using just `bNodeTree`. `DerivedNodeTree` builds on top of `NodeTreeRef`. It contains a flattened view on the node tree, i.e. with node groups being inlined. Every inlined node still knows its "call stack". It supports pretty much the same queries as `NodeTreeRef`. Both data structures come with a dot graph exporter for debugging purposes. Reviewers: brecht Differential Revision: https://developer.blender.org/D7628
2020-06-09 17:08:41 +02:00
}
Geometry Nodes: add socket value logging capability The node tree evaluator now calls a callback for every used socket with its corresponding value(s). Right now the callback does nothing. However, we can use it to collect attribute name hints, socket values for debugging or data that will be displayed in the spreadsheet. The main difficulty here was to also call the callback for sockets in nodes that are not directly executed (such as group nodes, muted nodes and reroutes). No functional changes are expected.
2021-04-01 13:10:22 +02:00
inline Span<const SocketRef *> SocketRef::logically_linked_skipped_sockets() const
{
return logically_linked_skipped_sockets_;
}
Nodes: efficient node tree queries and inlining This adds two data structures that wrap a node tree. However, they work on different abstraction levels. `NodeTreeRef` is an immutable structure that makes working with a node tree in C++ much more efficient and convenient. It supports various queries efficiently, that are not easily possible using just `bNodeTree`. `DerivedNodeTree` builds on top of `NodeTreeRef`. It contains a flattened view on the node tree, i.e. with node groups being inlined. Every inlined node still knows its "call stack". It supports pretty much the same queries as `NodeTreeRef`. Both data structures come with a dot graph exporter for debugging purposes. Reviewers: brecht Differential Revision: https://developer.blender.org/D7628
2020-06-09 17:08:41 +02:00
inline Span<const SocketRef *> SocketRef::directly_linked_sockets() const
{
Cleanup: remove unnecessary calls to as_span This uses the new implicit conversions and constructors that have been committed in the previous commit. I tested these changes on Linux with gcc and on Windows.
2020-07-08 22:29:10 +02:00
return directly_linked_sockets_;
Nodes: efficient node tree queries and inlining This adds two data structures that wrap a node tree. However, they work on different abstraction levels. `NodeTreeRef` is an immutable structure that makes working with a node tree in C++ much more efficient and convenient. It supports various queries efficiently, that are not easily possible using just `bNodeTree`. `DerivedNodeTree` builds on top of `NodeTreeRef`. It contains a flattened view on the node tree, i.e. with node groups being inlined. Every inlined node still knows its "call stack". It supports pretty much the same queries as `NodeTreeRef`. Both data structures come with a dot graph exporter for debugging purposes. Reviewers: brecht Differential Revision: https://developer.blender.org/D7628
2020-06-09 17:08:41 +02:00
}
Nodes: store references to bNodeLinks in NodeTreeRef Sometimes it is useful to have this information available to be able to read information from links.
2021-03-03 07:59:07 +01:00
inline Span<const LinkRef *> SocketRef::directly_linked_links() const
{
return directly_linked_links_;
}
Nodes: make distinction between directly and logically linked sockets more clear This also moves the handling of muted nodes from derived node tree to node tree ref.
2021-03-19 21:10:55 +01:00
inline bool SocketRef::is_directly_linked() const
{
return directly_linked_sockets_.size() > 0;
}
inline bool SocketRef::is_logically_linked() const
Nodes: efficient node tree queries and inlining This adds two data structures that wrap a node tree. However, they work on different abstraction levels. `NodeTreeRef` is an immutable structure that makes working with a node tree in C++ much more efficient and convenient. It supports various queries efficiently, that are not easily possible using just `bNodeTree`. `DerivedNodeTree` builds on top of `NodeTreeRef`. It contains a flattened view on the node tree, i.e. with node groups being inlined. Every inlined node still knows its "call stack". It supports pretty much the same queries as `NodeTreeRef`. Both data structures come with a dot graph exporter for debugging purposes. Reviewers: brecht Differential Revision: https://developer.blender.org/D7628
2020-06-09 17:08:41 +02:00
{
Nodes: make distinction between directly and logically linked sockets more clear This also moves the handling of muted nodes from derived node tree to node tree ref.
2021-03-19 21:10:55 +01:00
return logically_linked_sockets_.size() > 0;
Nodes: efficient node tree queries and inlining This adds two data structures that wrap a node tree. However, they work on different abstraction levels. `NodeTreeRef` is an immutable structure that makes working with a node tree in C++ much more efficient and convenient. It supports various queries efficiently, that are not easily possible using just `bNodeTree`. `DerivedNodeTree` builds on top of `NodeTreeRef`. It contains a flattened view on the node tree, i.e. with node groups being inlined. Every inlined node still knows its "call stack". It supports pretty much the same queries as `NodeTreeRef`. Both data structures come with a dot graph exporter for debugging purposes. Reviewers: brecht Differential Revision: https://developer.blender.org/D7628
2020-06-09 17:08:41 +02:00
}
inline const NodeRef &SocketRef::node() const
{
Cleanup: Use trailing underscore for non-public data members This makes the code conform better with our style guide.
2020-07-03 14:15:05 +02:00
return *node_;
Nodes: efficient node tree queries and inlining This adds two data structures that wrap a node tree. However, they work on different abstraction levels. `NodeTreeRef` is an immutable structure that makes working with a node tree in C++ much more efficient and convenient. It supports various queries efficiently, that are not easily possible using just `bNodeTree`. `DerivedNodeTree` builds on top of `NodeTreeRef`. It contains a flattened view on the node tree, i.e. with node groups being inlined. Every inlined node still knows its "call stack". It supports pretty much the same queries as `NodeTreeRef`. Both data structures come with a dot graph exporter for debugging purposes. Reviewers: brecht Differential Revision: https://developer.blender.org/D7628
2020-06-09 17:08:41 +02:00
}
inline const NodeTreeRef &SocketRef::tree() const
{
Cleanup: Use trailing underscore for non-public data members This makes the code conform better with our style guide.
2020-07-03 14:15:05 +02:00
return node_->tree();
Nodes: efficient node tree queries and inlining This adds two data structures that wrap a node tree. However, they work on different abstraction levels. `NodeTreeRef` is an immutable structure that makes working with a node tree in C++ much more efficient and convenient. It supports various queries efficiently, that are not easily possible using just `bNodeTree`. `DerivedNodeTree` builds on top of `NodeTreeRef`. It contains a flattened view on the node tree, i.e. with node groups being inlined. Every inlined node still knows its "call stack". It supports pretty much the same queries as `NodeTreeRef`. Both data structures come with a dot graph exporter for debugging purposes. Reviewers: brecht Differential Revision: https://developer.blender.org/D7628
2020-06-09 17:08:41 +02:00
}
Refactor: Update integer type usage This updates the usage of integer types in code I wrote according to our new style guides. Major changes: * Use signed instead of unsigned integers in many places. * C++ containers in blenlib use `int64_t` for size and indices now (instead of `uint`). * Hash values for C++ containers are 64 bit wide now (instead of 32 bit). I do hope that I broke no builds, but it is quite likely that some compiler reports slightly different errors. Please let me know when there are any errors. If the fix is small, feel free to commit it yourself. I compiled successfully on linux with gcc and on windows.
2020-07-20 12:16:20 +02:00
inline int SocketRef::id() const
Nodes: efficient node tree queries and inlining This adds two data structures that wrap a node tree. However, they work on different abstraction levels. `NodeTreeRef` is an immutable structure that makes working with a node tree in C++ much more efficient and convenient. It supports various queries efficiently, that are not easily possible using just `bNodeTree`. `DerivedNodeTree` builds on top of `NodeTreeRef`. It contains a flattened view on the node tree, i.e. with node groups being inlined. Every inlined node still knows its "call stack". It supports pretty much the same queries as `NodeTreeRef`. Both data structures come with a dot graph exporter for debugging purposes. Reviewers: brecht Differential Revision: https://developer.blender.org/D7628
2020-06-09 17:08:41 +02:00
{
Cleanup: Use trailing underscore for non-public data members This makes the code conform better with our style guide.
2020-07-03 14:15:05 +02:00
return id_;
Nodes: efficient node tree queries and inlining This adds two data structures that wrap a node tree. However, they work on different abstraction levels. `NodeTreeRef` is an immutable structure that makes working with a node tree in C++ much more efficient and convenient. It supports various queries efficiently, that are not easily possible using just `bNodeTree`. `DerivedNodeTree` builds on top of `NodeTreeRef`. It contains a flattened view on the node tree, i.e. with node groups being inlined. Every inlined node still knows its "call stack". It supports pretty much the same queries as `NodeTreeRef`. Both data structures come with a dot graph exporter for debugging purposes. Reviewers: brecht Differential Revision: https://developer.blender.org/D7628
2020-06-09 17:08:41 +02:00
}
Refactor: Update integer type usage This updates the usage of integer types in code I wrote according to our new style guides. Major changes: * Use signed instead of unsigned integers in many places. * C++ containers in blenlib use `int64_t` for size and indices now (instead of `uint`). * Hash values for C++ containers are 64 bit wide now (instead of 32 bit). I do hope that I broke no builds, but it is quite likely that some compiler reports slightly different errors. Please let me know when there are any errors. If the fix is small, feel free to commit it yourself. I compiled successfully on linux with gcc and on windows.
2020-07-20 12:16:20 +02:00
inline int SocketRef::index() const
Nodes: efficient node tree queries and inlining This adds two data structures that wrap a node tree. However, they work on different abstraction levels. `NodeTreeRef` is an immutable structure that makes working with a node tree in C++ much more efficient and convenient. It supports various queries efficiently, that are not easily possible using just `bNodeTree`. `DerivedNodeTree` builds on top of `NodeTreeRef`. It contains a flattened view on the node tree, i.e. with node groups being inlined. Every inlined node still knows its "call stack". It supports pretty much the same queries as `NodeTreeRef`. Both data structures come with a dot graph exporter for debugging purposes. Reviewers: brecht Differential Revision: https://developer.blender.org/D7628
2020-06-09 17:08:41 +02:00
{
Cleanup: Use trailing underscore for non-public data members This makes the code conform better with our style guide.
2020-07-03 14:15:05 +02:00
return index_;
Nodes: efficient node tree queries and inlining This adds two data structures that wrap a node tree. However, they work on different abstraction levels. `NodeTreeRef` is an immutable structure that makes working with a node tree in C++ much more efficient and convenient. It supports various queries efficiently, that are not easily possible using just `bNodeTree`. `DerivedNodeTree` builds on top of `NodeTreeRef`. It contains a flattened view on the node tree, i.e. with node groups being inlined. Every inlined node still knows its "call stack". It supports pretty much the same queries as `NodeTreeRef`. Both data structures come with a dot graph exporter for debugging purposes. Reviewers: brecht Differential Revision: https://developer.blender.org/D7628
2020-06-09 17:08:41 +02:00
}
inline bool SocketRef::is_input() const
{
Cleanup: Use trailing underscore for non-public data members This makes the code conform better with our style guide.
2020-07-03 14:15:05 +02:00
return is_input_;
Nodes: efficient node tree queries and inlining This adds two data structures that wrap a node tree. However, they work on different abstraction levels. `NodeTreeRef` is an immutable structure that makes working with a node tree in C++ much more efficient and convenient. It supports various queries efficiently, that are not easily possible using just `bNodeTree`. `DerivedNodeTree` builds on top of `NodeTreeRef`. It contains a flattened view on the node tree, i.e. with node groups being inlined. Every inlined node still knows its "call stack". It supports pretty much the same queries as `NodeTreeRef`. Both data structures come with a dot graph exporter for debugging purposes. Reviewers: brecht Differential Revision: https://developer.blender.org/D7628
2020-06-09 17:08:41 +02:00
}
inline bool SocketRef::is_output() const
{
Cleanup: Use trailing underscore for non-public data members This makes the code conform better with our style guide.
2020-07-03 14:15:05 +02:00
return !is_input_;
Nodes: efficient node tree queries and inlining This adds two data structures that wrap a node tree. However, they work on different abstraction levels. `NodeTreeRef` is an immutable structure that makes working with a node tree in C++ much more efficient and convenient. It supports various queries efficiently, that are not easily possible using just `bNodeTree`. `DerivedNodeTree` builds on top of `NodeTreeRef`. It contains a flattened view on the node tree, i.e. with node groups being inlined. Every inlined node still knows its "call stack". It supports pretty much the same queries as `NodeTreeRef`. Both data structures come with a dot graph exporter for debugging purposes. Reviewers: brecht Differential Revision: https://developer.blender.org/D7628
2020-06-09 17:08:41 +02:00
}
inline const SocketRef &SocketRef::as_base() const
{
return *this;
}
inline const InputSocketRef &SocketRef::as_input() const
{
BLI_assert(this->is_input());
Cleanup: use C++ style casts in various places
2020-08-07 18:24:59 +02:00
return static_cast<const InputSocketRef &>(*this);
Nodes: efficient node tree queries and inlining This adds two data structures that wrap a node tree. However, they work on different abstraction levels. `NodeTreeRef` is an immutable structure that makes working with a node tree in C++ much more efficient and convenient. It supports various queries efficiently, that are not easily possible using just `bNodeTree`. `DerivedNodeTree` builds on top of `NodeTreeRef`. It contains a flattened view on the node tree, i.e. with node groups being inlined. Every inlined node still knows its "call stack". It supports pretty much the same queries as `NodeTreeRef`. Both data structures come with a dot graph exporter for debugging purposes. Reviewers: brecht Differential Revision: https://developer.blender.org/D7628
2020-06-09 17:08:41 +02:00
}
inline const OutputSocketRef &SocketRef::as_output() const
{
BLI_assert(this->is_output());
Cleanup: use C++ style casts in various places
2020-08-07 18:24:59 +02:00
return static_cast<const OutputSocketRef &>(*this);
Nodes: efficient node tree queries and inlining This adds two data structures that wrap a node tree. However, they work on different abstraction levels. `NodeTreeRef` is an immutable structure that makes working with a node tree in C++ much more efficient and convenient. It supports various queries efficiently, that are not easily possible using just `bNodeTree`. `DerivedNodeTree` builds on top of `NodeTreeRef`. It contains a flattened view on the node tree, i.e. with node groups being inlined. Every inlined node still knows its "call stack". It supports pretty much the same queries as `NodeTreeRef`. Both data structures come with a dot graph exporter for debugging purposes. Reviewers: brecht Differential Revision: https://developer.blender.org/D7628
2020-06-09 17:08:41 +02:00
}
inline PointerRNA *SocketRef::rna() const
{
Cleanup: Use trailing underscore for non-public data members This makes the code conform better with our style guide.
2020-07-03 14:15:05 +02:00
return const_cast<PointerRNA *>(&rna_);
Nodes: efficient node tree queries and inlining This adds two data structures that wrap a node tree. However, they work on different abstraction levels. `NodeTreeRef` is an immutable structure that makes working with a node tree in C++ much more efficient and convenient. It supports various queries efficiently, that are not easily possible using just `bNodeTree`. `DerivedNodeTree` builds on top of `NodeTreeRef`. It contains a flattened view on the node tree, i.e. with node groups being inlined. Every inlined node still knows its "call stack". It supports pretty much the same queries as `NodeTreeRef`. Both data structures come with a dot graph exporter for debugging purposes. Reviewers: brecht Differential Revision: https://developer.blender.org/D7628
2020-06-09 17:08:41 +02:00
}
inline StringRefNull SocketRef::idname() const
{
Cleanup: Use trailing underscore for non-public data members This makes the code conform better with our style guide.
2020-07-03 14:15:05 +02:00
return bsocket_->idname;
Nodes: efficient node tree queries and inlining This adds two data structures that wrap a node tree. However, they work on different abstraction levels. `NodeTreeRef` is an immutable structure that makes working with a node tree in C++ much more efficient and convenient. It supports various queries efficiently, that are not easily possible using just `bNodeTree`. `DerivedNodeTree` builds on top of `NodeTreeRef`. It contains a flattened view on the node tree, i.e. with node groups being inlined. Every inlined node still knows its "call stack". It supports pretty much the same queries as `NodeTreeRef`. Both data structures come with a dot graph exporter for debugging purposes. Reviewers: brecht Differential Revision: https://developer.blender.org/D7628
2020-06-09 17:08:41 +02:00
}
inline StringRefNull SocketRef::name() const
{
Cleanup: Use trailing underscore for non-public data members This makes the code conform better with our style guide.
2020-07-03 14:15:05 +02:00
return bsocket_->name;
Nodes: efficient node tree queries and inlining This adds two data structures that wrap a node tree. However, they work on different abstraction levels. `NodeTreeRef` is an immutable structure that makes working with a node tree in C++ much more efficient and convenient. It supports various queries efficiently, that are not easily possible using just `bNodeTree`. `DerivedNodeTree` builds on top of `NodeTreeRef`. It contains a flattened view on the node tree, i.e. with node groups being inlined. Every inlined node still knows its "call stack". It supports pretty much the same queries as `NodeTreeRef`. Both data structures come with a dot graph exporter for debugging purposes. Reviewers: brecht Differential Revision: https://developer.blender.org/D7628
2020-06-09 17:08:41 +02:00
}
Geometry Nodes: initial scattering and geometry nodes This is the initial merge from the geometry-nodes branch. Nodes: * Attribute Math * Boolean * Edge Split * Float Compare * Object Info * Point Distribute * Point Instance * Random Attribute * Random Float * Subdivision Surface * Transform * Triangulate It includes the initial evaluation of geometry node groups in the Geometry Nodes modifier. Notes on the Generic attribute access API The API adds an indirection for attribute access. That has the following benefits: * Most code does not have to care about how an attribute is stored internally. This is mainly necessary, because we have to deal with "legacy" attributes such as vertex weights and attributes that are embedded into other structs such as vertex positions. * When reading from an attribute, we generally don't care what domain the attribute is stored on. So we want to abstract away the interpolation that that adapts attributes from one domain to another domain (this is not actually implemented yet). Other possible improvements for later iterations include: * Actually implement interpolation between domains. * Don't use inheritance for the different attribute types. A single class for read access and one for write access might be enough, because we know all the ways in which attributes are stored internally. We don't want more different internal structures in the future. On the contrary, ideally we can consolidate the different storage formats in the future to reduce the need for this indirection. * Remove the need for heap allocations when creating attribute accessors. It includes commits from: * Dalai Felinto * Hans Goudey * Jacques Lucke * Léo Depoix
2020-12-02 13:25:25 +01:00
inline StringRefNull SocketRef::identifier() const
{
return bsocket_->identifier;
}
Nodes: improve NodeTreeRef This adds a couple more utility methods to various node tree ref types. Also `InternalLinkRef` has been added to get simpler access to internal links.
2021-03-04 18:15:22 +01:00
inline bNodeSocketType *SocketRef::typeinfo() const
{
return bsocket_->typeinfo;
}
Nodes: efficient node tree queries and inlining This adds two data structures that wrap a node tree. However, they work on different abstraction levels. `NodeTreeRef` is an immutable structure that makes working with a node tree in C++ much more efficient and convenient. It supports various queries efficiently, that are not easily possible using just `bNodeTree`. `DerivedNodeTree` builds on top of `NodeTreeRef`. It contains a flattened view on the node tree, i.e. with node groups being inlined. Every inlined node still knows its "call stack". It supports pretty much the same queries as `NodeTreeRef`. Both data structures come with a dot graph exporter for debugging purposes. Reviewers: brecht Differential Revision: https://developer.blender.org/D7628
2020-06-09 17:08:41 +02:00
inline bNodeSocket *SocketRef::bsocket() const
{
Cleanup: Use trailing underscore for non-public data members This makes the code conform better with our style guide.
2020-07-03 14:15:05 +02:00
return bsocket_;
Nodes: efficient node tree queries and inlining This adds two data structures that wrap a node tree. However, they work on different abstraction levels. `NodeTreeRef` is an immutable structure that makes working with a node tree in C++ much more efficient and convenient. It supports various queries efficiently, that are not easily possible using just `bNodeTree`. `DerivedNodeTree` builds on top of `NodeTreeRef`. It contains a flattened view on the node tree, i.e. with node groups being inlined. Every inlined node still knows its "call stack". It supports pretty much the same queries as `NodeTreeRef`. Both data structures come with a dot graph exporter for debugging purposes. Reviewers: brecht Differential Revision: https://developer.blender.org/D7628
2020-06-09 17:08:41 +02:00
}
inline bNode *SocketRef::bnode() const
{
Cleanup: Use trailing underscore for non-public data members This makes the code conform better with our style guide.
2020-07-03 14:15:05 +02:00
return node_->bnode();
Nodes: efficient node tree queries and inlining This adds two data structures that wrap a node tree. However, they work on different abstraction levels. `NodeTreeRef` is an immutable structure that makes working with a node tree in C++ much more efficient and convenient. It supports various queries efficiently, that are not easily possible using just `bNodeTree`. `DerivedNodeTree` builds on top of `NodeTreeRef`. It contains a flattened view on the node tree, i.e. with node groups being inlined. Every inlined node still knows its "call stack". It supports pretty much the same queries as `NodeTreeRef`. Both data structures come with a dot graph exporter for debugging purposes. Reviewers: brecht Differential Revision: https://developer.blender.org/D7628
2020-06-09 17:08:41 +02:00
}
inline bNodeTree *SocketRef::btree() const
{
Cleanup: Use trailing underscore for non-public data members This makes the code conform better with our style guide.
2020-07-03 14:15:05 +02:00
return node_->btree();
Nodes: efficient node tree queries and inlining This adds two data structures that wrap a node tree. However, they work on different abstraction levels. `NodeTreeRef` is an immutable structure that makes working with a node tree in C++ much more efficient and convenient. It supports various queries efficiently, that are not easily possible using just `bNodeTree`. `DerivedNodeTree` builds on top of `NodeTreeRef`. It contains a flattened view on the node tree, i.e. with node groups being inlined. Every inlined node still knows its "call stack". It supports pretty much the same queries as `NodeTreeRef`. Both data structures come with a dot graph exporter for debugging purposes. Reviewers: brecht Differential Revision: https://developer.blender.org/D7628
2020-06-09 17:08:41 +02:00
}
Nodes: improve NodeTreeRef This adds a couple more utility methods to various node tree ref types. Also `InternalLinkRef` has been added to get simpler access to internal links.
2021-03-04 18:15:22 +01:00
inline bool SocketRef::is_available() const
{
return (bsocket_->flag & SOCK_UNAVAIL) == 0;
}
Nodes: add utilities to check if there are undefined nodes/sockets
2021-06-11 14:54:44 +02:00
inline bool SocketRef::is_undefined() const
{
return bsocket_->typeinfo == &NodeSocketTypeUndefined;
}
Nodes: provide access to type specific data through node tree ref
2021-03-19 20:35:48 +01:00
inline void *SocketRef::default_value() const
{
return bsocket_->default_value;
}
template<typename T> inline T *SocketRef::default_value() const
{
return (T *)bsocket_->default_value;
}
Cleanup: use doxygen sections
2021-10-05 11:10:25 +11:00
/** \} */
/* -------------------------------------------------------------------- */
/** \name #InputSocketRef Inline Methods
* \{ */
Nodes: efficient node tree queries and inlining This adds two data structures that wrap a node tree. However, they work on different abstraction levels. `NodeTreeRef` is an immutable structure that makes working with a node tree in C++ much more efficient and convenient. It supports various queries efficiently, that are not easily possible using just `bNodeTree`. `DerivedNodeTree` builds on top of `NodeTreeRef`. It contains a flattened view on the node tree, i.e. with node groups being inlined. Every inlined node still knows its "call stack". It supports pretty much the same queries as `NodeTreeRef`. Both data structures come with a dot graph exporter for debugging purposes. Reviewers: brecht Differential Revision: https://developer.blender.org/D7628
2020-06-09 17:08:41 +02:00
Nodes: make distinction between directly and logically linked sockets more clear This also moves the handling of muted nodes from derived node tree to node tree ref.
2021-03-19 21:10:55 +01:00
inline Span<const OutputSocketRef *> InputSocketRef::logically_linked_sockets() const
Nodes: efficient node tree queries and inlining This adds two data structures that wrap a node tree. However, they work on different abstraction levels. `NodeTreeRef` is an immutable structure that makes working with a node tree in C++ much more efficient and convenient. It supports various queries efficiently, that are not easily possible using just `bNodeTree`. `DerivedNodeTree` builds on top of `NodeTreeRef`. It contains a flattened view on the node tree, i.e. with node groups being inlined. Every inlined node still knows its "call stack". It supports pretty much the same queries as `NodeTreeRef`. Both data structures come with a dot graph exporter for debugging purposes. Reviewers: brecht Differential Revision: https://developer.blender.org/D7628
2020-06-09 17:08:41 +02:00
{
Nodes: make distinction between directly and logically linked sockets more clear This also moves the handling of muted nodes from derived node tree to node tree ref.
2021-03-19 21:10:55 +01:00
return logically_linked_sockets_.as_span().cast<const OutputSocketRef *>();
Nodes: efficient node tree queries and inlining This adds two data structures that wrap a node tree. However, they work on different abstraction levels. `NodeTreeRef` is an immutable structure that makes working with a node tree in C++ much more efficient and convenient. It supports various queries efficiently, that are not easily possible using just `bNodeTree`. `DerivedNodeTree` builds on top of `NodeTreeRef`. It contains a flattened view on the node tree, i.e. with node groups being inlined. Every inlined node still knows its "call stack". It supports pretty much the same queries as `NodeTreeRef`. Both data structures come with a dot graph exporter for debugging purposes. Reviewers: brecht Differential Revision: https://developer.blender.org/D7628
2020-06-09 17:08:41 +02:00
}
inline Span<const OutputSocketRef *> InputSocketRef::directly_linked_sockets() const
{
Nodes: make derived link data more obvious in NodeTreeRef `NodeTreeRef` is a thin wrapper on top of `bNodeTree`. By default it should not hide anything from the underlying `bNodeTree` (before this it was hiding muted links). For convenience some "derived" data is cached on sockets. For example all the connected sockets when reroutes and muted links are ignored. A nice side benefit of this refactor is that `NodeTreeRef` requires less memory than before.
2021-03-17 16:43:06 +01:00
return directly_linked_sockets_.cast<const OutputSocketRef *>();
Nodes: efficient node tree queries and inlining This adds two data structures that wrap a node tree. However, they work on different abstraction levels. `NodeTreeRef` is an immutable structure that makes working with a node tree in C++ much more efficient and convenient. It supports various queries efficiently, that are not easily possible using just `bNodeTree`. `DerivedNodeTree` builds on top of `NodeTreeRef`. It contains a flattened view on the node tree, i.e. with node groups being inlined. Every inlined node still knows its "call stack". It supports pretty much the same queries as `NodeTreeRef`. Both data structures come with a dot graph exporter for debugging purposes. Reviewers: brecht Differential Revision: https://developer.blender.org/D7628
2020-06-09 17:08:41 +02:00
}
Nodes: improve NodeTreeRef This adds a couple more utility methods to various node tree ref types. Also `InternalLinkRef` has been added to get simpler access to internal links.
2021-03-04 18:15:22 +01:00
inline bool InputSocketRef::is_multi_input_socket() const
{
return bsocket_->flag & SOCK_MULTI_INPUT;
}
Cleanup: use doxygen sections
2021-10-05 11:10:25 +11:00
/** \} */
/* -------------------------------------------------------------------- */
/** \name #OutputSocketRef Inline Methods
* \{ */
Nodes: efficient node tree queries and inlining This adds two data structures that wrap a node tree. However, they work on different abstraction levels. `NodeTreeRef` is an immutable structure that makes working with a node tree in C++ much more efficient and convenient. It supports various queries efficiently, that are not easily possible using just `bNodeTree`. `DerivedNodeTree` builds on top of `NodeTreeRef`. It contains a flattened view on the node tree, i.e. with node groups being inlined. Every inlined node still knows its "call stack". It supports pretty much the same queries as `NodeTreeRef`. Both data structures come with a dot graph exporter for debugging purposes. Reviewers: brecht Differential Revision: https://developer.blender.org/D7628
2020-06-09 17:08:41 +02:00
Nodes: make distinction between directly and logically linked sockets more clear This also moves the handling of muted nodes from derived node tree to node tree ref.
2021-03-19 21:10:55 +01:00
inline Span<const InputSocketRef *> OutputSocketRef::logically_linked_sockets() const
Nodes: efficient node tree queries and inlining This adds two data structures that wrap a node tree. However, they work on different abstraction levels. `NodeTreeRef` is an immutable structure that makes working with a node tree in C++ much more efficient and convenient. It supports various queries efficiently, that are not easily possible using just `bNodeTree`. `DerivedNodeTree` builds on top of `NodeTreeRef`. It contains a flattened view on the node tree, i.e. with node groups being inlined. Every inlined node still knows its "call stack". It supports pretty much the same queries as `NodeTreeRef`. Both data structures come with a dot graph exporter for debugging purposes. Reviewers: brecht Differential Revision: https://developer.blender.org/D7628
2020-06-09 17:08:41 +02:00
{
Nodes: make distinction between directly and logically linked sockets more clear This also moves the handling of muted nodes from derived node tree to node tree ref.
2021-03-19 21:10:55 +01:00
return logically_linked_sockets_.as_span().cast<const InputSocketRef *>();
Nodes: efficient node tree queries and inlining This adds two data structures that wrap a node tree. However, they work on different abstraction levels. `NodeTreeRef` is an immutable structure that makes working with a node tree in C++ much more efficient and convenient. It supports various queries efficiently, that are not easily possible using just `bNodeTree`. `DerivedNodeTree` builds on top of `NodeTreeRef`. It contains a flattened view on the node tree, i.e. with node groups being inlined. Every inlined node still knows its "call stack". It supports pretty much the same queries as `NodeTreeRef`. Both data structures come with a dot graph exporter for debugging purposes. Reviewers: brecht Differential Revision: https://developer.blender.org/D7628
2020-06-09 17:08:41 +02:00
}
inline Span<const InputSocketRef *> OutputSocketRef::directly_linked_sockets() const
{
Nodes: make derived link data more obvious in NodeTreeRef `NodeTreeRef` is a thin wrapper on top of `bNodeTree`. By default it should not hide anything from the underlying `bNodeTree` (before this it was hiding muted links). For convenience some "derived" data is cached on sockets. For example all the connected sockets when reroutes and muted links are ignored. A nice side benefit of this refactor is that `NodeTreeRef` requires less memory than before.
2021-03-17 16:43:06 +01:00
return directly_linked_sockets_.cast<const InputSocketRef *>();
Nodes: efficient node tree queries and inlining This adds two data structures that wrap a node tree. However, they work on different abstraction levels. `NodeTreeRef` is an immutable structure that makes working with a node tree in C++ much more efficient and convenient. It supports various queries efficiently, that are not easily possible using just `bNodeTree`. `DerivedNodeTree` builds on top of `NodeTreeRef`. It contains a flattened view on the node tree, i.e. with node groups being inlined. Every inlined node still knows its "call stack". It supports pretty much the same queries as `NodeTreeRef`. Both data structures come with a dot graph exporter for debugging purposes. Reviewers: brecht Differential Revision: https://developer.blender.org/D7628
2020-06-09 17:08:41 +02:00
}
Cleanup: use doxygen sections
2021-10-05 11:10:25 +11:00
/** \} */
/* -------------------------------------------------------------------- */
/** \name #NodeRef Inline Methods
* \{ */
Nodes: efficient node tree queries and inlining This adds two data structures that wrap a node tree. However, they work on different abstraction levels. `NodeTreeRef` is an immutable structure that makes working with a node tree in C++ much more efficient and convenient. It supports various queries efficiently, that are not easily possible using just `bNodeTree`. `DerivedNodeTree` builds on top of `NodeTreeRef`. It contains a flattened view on the node tree, i.e. with node groups being inlined. Every inlined node still knows its "call stack". It supports pretty much the same queries as `NodeTreeRef`. Both data structures come with a dot graph exporter for debugging purposes. Reviewers: brecht Differential Revision: https://developer.blender.org/D7628
2020-06-09 17:08:41 +02:00
inline const NodeTreeRef &NodeRef::tree() const
{
Cleanup: Use trailing underscore for non-public data members This makes the code conform better with our style guide.
2020-07-03 14:15:05 +02:00
return *tree_;
Nodes: efficient node tree queries and inlining This adds two data structures that wrap a node tree. However, they work on different abstraction levels. `NodeTreeRef` is an immutable structure that makes working with a node tree in C++ much more efficient and convenient. It supports various queries efficiently, that are not easily possible using just `bNodeTree`. `DerivedNodeTree` builds on top of `NodeTreeRef`. It contains a flattened view on the node tree, i.e. with node groups being inlined. Every inlined node still knows its "call stack". It supports pretty much the same queries as `NodeTreeRef`. Both data structures come with a dot graph exporter for debugging purposes. Reviewers: brecht Differential Revision: https://developer.blender.org/D7628
2020-06-09 17:08:41 +02:00
}
inline Span<const InputSocketRef *> NodeRef::inputs() const
{
Cleanup: remove unnecessary calls to as_span This uses the new implicit conversions and constructors that have been committed in the previous commit. I tested these changes on Linux with gcc and on Windows.
2020-07-08 22:29:10 +02:00
return inputs_;
Nodes: efficient node tree queries and inlining This adds two data structures that wrap a node tree. However, they work on different abstraction levels. `NodeTreeRef` is an immutable structure that makes working with a node tree in C++ much more efficient and convenient. It supports various queries efficiently, that are not easily possible using just `bNodeTree`. `DerivedNodeTree` builds on top of `NodeTreeRef`. It contains a flattened view on the node tree, i.e. with node groups being inlined. Every inlined node still knows its "call stack". It supports pretty much the same queries as `NodeTreeRef`. Both data structures come with a dot graph exporter for debugging purposes. Reviewers: brecht Differential Revision: https://developer.blender.org/D7628
2020-06-09 17:08:41 +02:00
}
inline Span<const OutputSocketRef *> NodeRef::outputs() const
{
Cleanup: remove unnecessary calls to as_span This uses the new implicit conversions and constructors that have been committed in the previous commit. I tested these changes on Linux with gcc and on Windows.
2020-07-08 22:29:10 +02:00
return outputs_;
Nodes: efficient node tree queries and inlining This adds two data structures that wrap a node tree. However, they work on different abstraction levels. `NodeTreeRef` is an immutable structure that makes working with a node tree in C++ much more efficient and convenient. It supports various queries efficiently, that are not easily possible using just `bNodeTree`. `DerivedNodeTree` builds on top of `NodeTreeRef`. It contains a flattened view on the node tree, i.e. with node groups being inlined. Every inlined node still knows its "call stack". It supports pretty much the same queries as `NodeTreeRef`. Both data structures come with a dot graph exporter for debugging purposes. Reviewers: brecht Differential Revision: https://developer.blender.org/D7628
2020-06-09 17:08:41 +02:00
}
Geometry Nodes: Initial socket visualization for fields. This implements the update logic for the vizualization of which sockets pass data or constants directly, and which pass functions. The socket shapes may still have to be updated. That should be done separately, because it might be a bit more involved, because socket shapes are currently linked to keyframe shapes. Currently the circle and diamond shapes are used with the following meanings: - Input Sockets: - Circle: Required to be a single value. - Diamond: This input supports fields. - Output Sockets: - Circle: This output is a single value. - Diamond: This output may be a field. Connecting a field to a circle input socket is an error, since a field cannot be converted to a single value. If the socket shape is a diamond with a dot in the middle, it means it is currently a single value, but could be a field. In addition to socket shapes, the intention is to draw node links differently based on the field status. However, the exact method for conveying that isn't decided yet. Differential Revision: https://developer.blender.org/D12584
2021-09-23 15:21:31 -05:00
inline Span<const SocketRef *> NodeRef::sockets(const eNodeSocketInOut in_out) const
{
return in_out == SOCK_IN ? inputs_.as_span().cast<const SocketRef *>() :
outputs_.as_span().cast<const SocketRef *>();
}
Nodes: improve NodeTreeRef This adds a couple more utility methods to various node tree ref types. Also `InternalLinkRef` has been added to get simpler access to internal links.
2021-03-04 18:15:22 +01:00
inline Span<const InternalLinkRef *> NodeRef::internal_links() const
{
return internal_links_;
}
Refactor: Update integer type usage This updates the usage of integer types in code I wrote according to our new style guides. Major changes: * Use signed instead of unsigned integers in many places. * C++ containers in blenlib use `int64_t` for size and indices now (instead of `uint`). * Hash values for C++ containers are 64 bit wide now (instead of 32 bit). I do hope that I broke no builds, but it is quite likely that some compiler reports slightly different errors. Please let me know when there are any errors. If the fix is small, feel free to commit it yourself. I compiled successfully on linux with gcc and on windows.
2020-07-20 12:16:20 +02:00
inline const InputSocketRef &NodeRef::input(int index) const
Nodes: efficient node tree queries and inlining This adds two data structures that wrap a node tree. However, they work on different abstraction levels. `NodeTreeRef` is an immutable structure that makes working with a node tree in C++ much more efficient and convenient. It supports various queries efficiently, that are not easily possible using just `bNodeTree`. `DerivedNodeTree` builds on top of `NodeTreeRef`. It contains a flattened view on the node tree, i.e. with node groups being inlined. Every inlined node still knows its "call stack". It supports pretty much the same queries as `NodeTreeRef`. Both data structures come with a dot graph exporter for debugging purposes. Reviewers: brecht Differential Revision: https://developer.blender.org/D7628
2020-06-09 17:08:41 +02:00
{
Cleanup: Use trailing underscore for non-public data members This makes the code conform better with our style guide.
2020-07-03 14:15:05 +02:00
return *inputs_[index];
Nodes: efficient node tree queries and inlining This adds two data structures that wrap a node tree. However, they work on different abstraction levels. `NodeTreeRef` is an immutable structure that makes working with a node tree in C++ much more efficient and convenient. It supports various queries efficiently, that are not easily possible using just `bNodeTree`. `DerivedNodeTree` builds on top of `NodeTreeRef`. It contains a flattened view on the node tree, i.e. with node groups being inlined. Every inlined node still knows its "call stack". It supports pretty much the same queries as `NodeTreeRef`. Both data structures come with a dot graph exporter for debugging purposes. Reviewers: brecht Differential Revision: https://developer.blender.org/D7628
2020-06-09 17:08:41 +02:00
}
Refactor: Update integer type usage This updates the usage of integer types in code I wrote according to our new style guides. Major changes: * Use signed instead of unsigned integers in many places. * C++ containers in blenlib use `int64_t` for size and indices now (instead of `uint`). * Hash values for C++ containers are 64 bit wide now (instead of 32 bit). I do hope that I broke no builds, but it is quite likely that some compiler reports slightly different errors. Please let me know when there are any errors. If the fix is small, feel free to commit it yourself. I compiled successfully on linux with gcc and on windows.
2020-07-20 12:16:20 +02:00
inline const OutputSocketRef &NodeRef::output(int index) const
Nodes: efficient node tree queries and inlining This adds two data structures that wrap a node tree. However, they work on different abstraction levels. `NodeTreeRef` is an immutable structure that makes working with a node tree in C++ much more efficient and convenient. It supports various queries efficiently, that are not easily possible using just `bNodeTree`. `DerivedNodeTree` builds on top of `NodeTreeRef`. It contains a flattened view on the node tree, i.e. with node groups being inlined. Every inlined node still knows its "call stack". It supports pretty much the same queries as `NodeTreeRef`. Both data structures come with a dot graph exporter for debugging purposes. Reviewers: brecht Differential Revision: https://developer.blender.org/D7628
2020-06-09 17:08:41 +02:00
{
Cleanup: Use trailing underscore for non-public data members This makes the code conform better with our style guide.
2020-07-03 14:15:05 +02:00
return *outputs_[index];
Nodes: efficient node tree queries and inlining This adds two data structures that wrap a node tree. However, they work on different abstraction levels. `NodeTreeRef` is an immutable structure that makes working with a node tree in C++ much more efficient and convenient. It supports various queries efficiently, that are not easily possible using just `bNodeTree`. `DerivedNodeTree` builds on top of `NodeTreeRef`. It contains a flattened view on the node tree, i.e. with node groups being inlined. Every inlined node still knows its "call stack". It supports pretty much the same queries as `NodeTreeRef`. Both data structures come with a dot graph exporter for debugging purposes. Reviewers: brecht Differential Revision: https://developer.blender.org/D7628
2020-06-09 17:08:41 +02:00
}
Nodes: cache socket identifier to index mapping While this preprocessing does take some time upfront, it avoids longer lookup later on, especially as nodes get more sockets. It's probably possible to make this more efficient in some cases but this is good enough for now.
2021-06-11 16:21:08 +02:00
inline const InputSocketRef &NodeRef::input_by_identifier(StringRef identifier) const
{
const int index = input_index_by_identifier_->lookup_as(identifier);
return this->input(index);
}
inline const OutputSocketRef &NodeRef::output_by_identifier(StringRef identifier) const
{
const int index = output_index_by_identifier_->lookup_as(identifier);
return this->output(index);
}
Nodes: efficient node tree queries and inlining This adds two data structures that wrap a node tree. However, they work on different abstraction levels. `NodeTreeRef` is an immutable structure that makes working with a node tree in C++ much more efficient and convenient. It supports various queries efficiently, that are not easily possible using just `bNodeTree`. `DerivedNodeTree` builds on top of `NodeTreeRef`. It contains a flattened view on the node tree, i.e. with node groups being inlined. Every inlined node still knows its "call stack". It supports pretty much the same queries as `NodeTreeRef`. Both data structures come with a dot graph exporter for debugging purposes. Reviewers: brecht Differential Revision: https://developer.blender.org/D7628
2020-06-09 17:08:41 +02:00
inline bNode *NodeRef::bnode() const
{
Cleanup: Use trailing underscore for non-public data members This makes the code conform better with our style guide.
2020-07-03 14:15:05 +02:00
return bnode_;
Nodes: efficient node tree queries and inlining This adds two data structures that wrap a node tree. However, they work on different abstraction levels. `NodeTreeRef` is an immutable structure that makes working with a node tree in C++ much more efficient and convenient. It supports various queries efficiently, that are not easily possible using just `bNodeTree`. `DerivedNodeTree` builds on top of `NodeTreeRef`. It contains a flattened view on the node tree, i.e. with node groups being inlined. Every inlined node still knows its "call stack". It supports pretty much the same queries as `NodeTreeRef`. Both data structures come with a dot graph exporter for debugging purposes. Reviewers: brecht Differential Revision: https://developer.blender.org/D7628
2020-06-09 17:08:41 +02:00
}
inline bNodeTree *NodeRef::btree() const
{
Cleanup: Use trailing underscore for non-public data members This makes the code conform better with our style guide.
2020-07-03 14:15:05 +02:00
return tree_->btree();
Nodes: efficient node tree queries and inlining This adds two data structures that wrap a node tree. However, they work on different abstraction levels. `NodeTreeRef` is an immutable structure that makes working with a node tree in C++ much more efficient and convenient. It supports various queries efficiently, that are not easily possible using just `bNodeTree`. `DerivedNodeTree` builds on top of `NodeTreeRef`. It contains a flattened view on the node tree, i.e. with node groups being inlined. Every inlined node still knows its "call stack". It supports pretty much the same queries as `NodeTreeRef`. Both data structures come with a dot graph exporter for debugging purposes. Reviewers: brecht Differential Revision: https://developer.blender.org/D7628
2020-06-09 17:08:41 +02:00
}
inline PointerRNA *NodeRef::rna() const
{
Cleanup: Use trailing underscore for non-public data members This makes the code conform better with our style guide.
2020-07-03 14:15:05 +02:00
return const_cast<PointerRNA *>(&rna_);
Nodes: efficient node tree queries and inlining This adds two data structures that wrap a node tree. However, they work on different abstraction levels. `NodeTreeRef` is an immutable structure that makes working with a node tree in C++ much more efficient and convenient. It supports various queries efficiently, that are not easily possible using just `bNodeTree`. `DerivedNodeTree` builds on top of `NodeTreeRef`. It contains a flattened view on the node tree, i.e. with node groups being inlined. Every inlined node still knows its "call stack". It supports pretty much the same queries as `NodeTreeRef`. Both data structures come with a dot graph exporter for debugging purposes. Reviewers: brecht Differential Revision: https://developer.blender.org/D7628
2020-06-09 17:08:41 +02:00
}
inline StringRefNull NodeRef::idname() const
{
Cleanup: Use trailing underscore for non-public data members This makes the code conform better with our style guide.
2020-07-03 14:15:05 +02:00
return bnode_->idname;
Nodes: efficient node tree queries and inlining This adds two data structures that wrap a node tree. However, they work on different abstraction levels. `NodeTreeRef` is an immutable structure that makes working with a node tree in C++ much more efficient and convenient. It supports various queries efficiently, that are not easily possible using just `bNodeTree`. `DerivedNodeTree` builds on top of `NodeTreeRef`. It contains a flattened view on the node tree, i.e. with node groups being inlined. Every inlined node still knows its "call stack". It supports pretty much the same queries as `NodeTreeRef`. Both data structures come with a dot graph exporter for debugging purposes. Reviewers: brecht Differential Revision: https://developer.blender.org/D7628
2020-06-09 17:08:41 +02:00
}
inline StringRefNull NodeRef::name() const
{
Cleanup: Use trailing underscore for non-public data members This makes the code conform better with our style guide.
2020-07-03 14:15:05 +02:00
return bnode_->name;
Nodes: efficient node tree queries and inlining This adds two data structures that wrap a node tree. However, they work on different abstraction levels. `NodeTreeRef` is an immutable structure that makes working with a node tree in C++ much more efficient and convenient. It supports various queries efficiently, that are not easily possible using just `bNodeTree`. `DerivedNodeTree` builds on top of `NodeTreeRef`. It contains a flattened view on the node tree, i.e. with node groups being inlined. Every inlined node still knows its "call stack". It supports pretty much the same queries as `NodeTreeRef`. Both data structures come with a dot graph exporter for debugging purposes. Reviewers: brecht Differential Revision: https://developer.blender.org/D7628
2020-06-09 17:08:41 +02:00
}
Geometry Nodes: remove reference to anonymous attributes in tooltips This changes socket inspection for fields according to T91881. Differential Revision: https://developer.blender.org/D13006
2021-10-26 15:32:01 +02:00
inline StringRefNull NodeRef::label() const
{
return bnode_->label;
}
inline StringRefNull NodeRef::label_or_name() const
{
const StringRefNull label = this->label();
if (!label.is_empty()) {
return label;
}
return this->name();
}
Nodes: improve NodeTreeRef This adds a couple more utility methods to various node tree ref types. Also `InternalLinkRef` has been added to get simpler access to internal links.
2021-03-04 18:15:22 +01:00
inline bNodeType *NodeRef::typeinfo() const
{
return bnode_->typeinfo;
}
Geometry Nodes: Initial socket visualization for fields. This implements the update logic for the vizualization of which sockets pass data or constants directly, and which pass functions. The socket shapes may still have to be updated. That should be done separately, because it might be a bit more involved, because socket shapes are currently linked to keyframe shapes. Currently the circle and diamond shapes are used with the following meanings: - Input Sockets: - Circle: Required to be a single value. - Diamond: This input supports fields. - Output Sockets: - Circle: This output is a single value. - Diamond: This output may be a field. Connecting a field to a circle input socket is an error, since a field cannot be converted to a single value. If the socket shape is a diamond with a dot in the middle, it means it is currently a single value, but could be a field. In addition to socket shapes, the intention is to draw node links differently based on the field status. However, the exact method for conveying that isn't decided yet. Differential Revision: https://developer.blender.org/D12584
2021-09-23 15:21:31 -05:00
/* Returns a pointer because not all nodes have declarations currently. */
inline const NodeDeclaration *NodeRef::declaration() const
{
nodeDeclarationEnsure(this->tree().btree(), bnode_);
return bnode_->declaration;
}
Refactor: Update integer type usage This updates the usage of integer types in code I wrote according to our new style guides. Major changes: * Use signed instead of unsigned integers in many places. * C++ containers in blenlib use `int64_t` for size and indices now (instead of `uint`). * Hash values for C++ containers are 64 bit wide now (instead of 32 bit). I do hope that I broke no builds, but it is quite likely that some compiler reports slightly different errors. Please let me know when there are any errors. If the fix is small, feel free to commit it yourself. I compiled successfully on linux with gcc and on windows.
2020-07-20 12:16:20 +02:00
inline int NodeRef::id() const
Nodes: efficient node tree queries and inlining This adds two data structures that wrap a node tree. However, they work on different abstraction levels. `NodeTreeRef` is an immutable structure that makes working with a node tree in C++ much more efficient and convenient. It supports various queries efficiently, that are not easily possible using just `bNodeTree`. `DerivedNodeTree` builds on top of `NodeTreeRef`. It contains a flattened view on the node tree, i.e. with node groups being inlined. Every inlined node still knows its "call stack". It supports pretty much the same queries as `NodeTreeRef`. Both data structures come with a dot graph exporter for debugging purposes. Reviewers: brecht Differential Revision: https://developer.blender.org/D7628
2020-06-09 17:08:41 +02:00
{
Cleanup: Use trailing underscore for non-public data members This makes the code conform better with our style guide.
2020-07-03 14:15:05 +02:00
return id_;
Nodes: efficient node tree queries and inlining This adds two data structures that wrap a node tree. However, they work on different abstraction levels. `NodeTreeRef` is an immutable structure that makes working with a node tree in C++ much more efficient and convenient. It supports various queries efficiently, that are not easily possible using just `bNodeTree`. `DerivedNodeTree` builds on top of `NodeTreeRef`. It contains a flattened view on the node tree, i.e. with node groups being inlined. Every inlined node still knows its "call stack". It supports pretty much the same queries as `NodeTreeRef`. Both data structures come with a dot graph exporter for debugging purposes. Reviewers: brecht Differential Revision: https://developer.blender.org/D7628
2020-06-09 17:08:41 +02:00
}
inline bool NodeRef::is_reroute_node() const
{
Cleanup: Use trailing underscore for non-public data members This makes the code conform better with our style guide.
2020-07-03 14:15:05 +02:00
return bnode_->type == NODE_REROUTE;
Nodes: efficient node tree queries and inlining This adds two data structures that wrap a node tree. However, they work on different abstraction levels. `NodeTreeRef` is an immutable structure that makes working with a node tree in C++ much more efficient and convenient. It supports various queries efficiently, that are not easily possible using just `bNodeTree`. `DerivedNodeTree` builds on top of `NodeTreeRef`. It contains a flattened view on the node tree, i.e. with node groups being inlined. Every inlined node still knows its "call stack". It supports pretty much the same queries as `NodeTreeRef`. Both data structures come with a dot graph exporter for debugging purposes. Reviewers: brecht Differential Revision: https://developer.blender.org/D7628
2020-06-09 17:08:41 +02:00
}
inline bool NodeRef::is_group_node() const
{
Fix: Missing GeometryNodeCustomGroup This is a minor change to add some plumbing code to support custom geo nodes. This is working the same way as the custom cycles and compositor nodes. An example add-in is attached to D10784 Reviewed By: JacquesLucke Differential Revision: http://developer.blender.org/D10784
2021-04-08 16:25:09 -06:00
return bnode_->type == NODE_GROUP || bnode_->type == NODE_CUSTOM_GROUP;
Nodes: efficient node tree queries and inlining This adds two data structures that wrap a node tree. However, they work on different abstraction levels. `NodeTreeRef` is an immutable structure that makes working with a node tree in C++ much more efficient and convenient. It supports various queries efficiently, that are not easily possible using just `bNodeTree`. `DerivedNodeTree` builds on top of `NodeTreeRef`. It contains a flattened view on the node tree, i.e. with node groups being inlined. Every inlined node still knows its "call stack". It supports pretty much the same queries as `NodeTreeRef`. Both data structures come with a dot graph exporter for debugging purposes. Reviewers: brecht Differential Revision: https://developer.blender.org/D7628
2020-06-09 17:08:41 +02:00
}
inline bool NodeRef::is_group_input_node() const
{
Cleanup: Use trailing underscore for non-public data members This makes the code conform better with our style guide.
2020-07-03 14:15:05 +02:00
return bnode_->type == NODE_GROUP_INPUT;
Nodes: efficient node tree queries and inlining This adds two data structures that wrap a node tree. However, they work on different abstraction levels. `NodeTreeRef` is an immutable structure that makes working with a node tree in C++ much more efficient and convenient. It supports various queries efficiently, that are not easily possible using just `bNodeTree`. `DerivedNodeTree` builds on top of `NodeTreeRef`. It contains a flattened view on the node tree, i.e. with node groups being inlined. Every inlined node still knows its "call stack". It supports pretty much the same queries as `NodeTreeRef`. Both data structures come with a dot graph exporter for debugging purposes. Reviewers: brecht Differential Revision: https://developer.blender.org/D7628
2020-06-09 17:08:41 +02:00
}
inline bool NodeRef::is_group_output_node() const
{
Cleanup: Use trailing underscore for non-public data members This makes the code conform better with our style guide.
2020-07-03 14:15:05 +02:00
return bnode_->type == NODE_GROUP_OUTPUT;
Nodes: efficient node tree queries and inlining This adds two data structures that wrap a node tree. However, they work on different abstraction levels. `NodeTreeRef` is an immutable structure that makes working with a node tree in C++ much more efficient and convenient. It supports various queries efficiently, that are not easily possible using just `bNodeTree`. `DerivedNodeTree` builds on top of `NodeTreeRef`. It contains a flattened view on the node tree, i.e. with node groups being inlined. Every inlined node still knows its "call stack". It supports pretty much the same queries as `NodeTreeRef`. Both data structures come with a dot graph exporter for debugging purposes. Reviewers: brecht Differential Revision: https://developer.blender.org/D7628
2020-06-09 17:08:41 +02:00
}
Nodes: expose tree name and whether a node is a frame in node tree ref
2021-03-19 22:33:43 +01:00
inline bool NodeRef::is_frame() const
{
return bnode_->type == NODE_FRAME;
}
Nodes: add utilities to check if there are undefined nodes/sockets
2021-06-11 14:54:44 +02:00
inline bool NodeRef::is_undefined() const
{
return bnode_->typeinfo == &NodeTypeUndefined;
}
Geometry Nodes: support muted nodes The handling of muted nodes is handled at the derived node tree level now. This is also where expanding node groups is handled. Muted nodes are relinked and removed from the derived tree during construction. The geometry node evaluation code does not have to know about muted nodes this way.
2020-11-27 19:38:14 +01:00
inline bool NodeRef::is_muted() const
{
return (bnode_->flag & NODE_MUTED) != 0;
}
Nodes: provide access to type specific data through node tree ref
2021-03-19 20:35:48 +01:00
inline void *NodeRef::storage() const
{
return bnode_->storage;
}
template<typename T> inline T *NodeRef::storage() const
{
return (T *)bnode_->storage;
}
Cleanup: use doxygen sections
2021-10-05 11:10:25 +11:00
/** \} */
/* -------------------------------------------------------------------- */
/** \name #LinkRef Inline Methods
* \{ */
Nodes: store references to bNodeLinks in NodeTreeRef Sometimes it is useful to have this information available to be able to read information from links.
2021-03-03 07:59:07 +01:00
inline const OutputSocketRef &LinkRef::from() const
{
return *from_;
}
inline const InputSocketRef &LinkRef::to() const
{
return *to_;
}
inline bNodeLink *LinkRef::blink() const
Nodes: improve NodeTreeRef This adds a couple more utility methods to various node tree ref types. Also `InternalLinkRef` has been added to get simpler access to internal links.
2021-03-04 18:15:22 +01:00
{
return blink_;
}
Nodes: make derived link data more obvious in NodeTreeRef `NodeTreeRef` is a thin wrapper on top of `bNodeTree`. By default it should not hide anything from the underlying `bNodeTree` (before this it was hiding muted links). For convenience some "derived" data is cached on sockets. For example all the connected sockets when reroutes and muted links are ignored. A nice side benefit of this refactor is that `NodeTreeRef` requires less memory than before.
2021-03-17 16:43:06 +01:00
inline bool LinkRef::is_muted() const
{
return blink_->flag & NODE_LINK_MUTED;
}
Cleanup: use doxygen sections
2021-10-05 11:10:25 +11:00
/** \} */
/* -------------------------------------------------------------------- */
/** \name #InternalLinkRef Inline Methods
* \{ */
Nodes: improve NodeTreeRef This adds a couple more utility methods to various node tree ref types. Also `InternalLinkRef` has been added to get simpler access to internal links.
2021-03-04 18:15:22 +01:00
inline const InputSocketRef &InternalLinkRef::from() const
{
return *from_;
}
inline const OutputSocketRef &InternalLinkRef::to() const
{
return *to_;
}
inline bNodeLink *InternalLinkRef::blink() const
Nodes: store references to bNodeLinks in NodeTreeRef Sometimes it is useful to have this information available to be able to read information from links.
2021-03-03 07:59:07 +01:00
{
return blink_;
}
Cleanup: use doxygen sections
2021-10-05 11:10:25 +11:00
/** \} */
/* -------------------------------------------------------------------- */
/** \name #NodeTreeRef Inline Methods
* \{ */
Nodes: efficient node tree queries and inlining This adds two data structures that wrap a node tree. However, they work on different abstraction levels. `NodeTreeRef` is an immutable structure that makes working with a node tree in C++ much more efficient and convenient. It supports various queries efficiently, that are not easily possible using just `bNodeTree`. `DerivedNodeTree` builds on top of `NodeTreeRef`. It contains a flattened view on the node tree, i.e. with node groups being inlined. Every inlined node still knows its "call stack". It supports pretty much the same queries as `NodeTreeRef`. Both data structures come with a dot graph exporter for debugging purposes. Reviewers: brecht Differential Revision: https://developer.blender.org/D7628
2020-06-09 17:08:41 +02:00
inline Span<const NodeRef *> NodeTreeRef::nodes() const
{
Cleanup: remove unnecessary calls to as_span This uses the new implicit conversions and constructors that have been committed in the previous commit. I tested these changes on Linux with gcc and on Windows.
2020-07-08 22:29:10 +02:00
return nodes_by_id_;
Nodes: efficient node tree queries and inlining This adds two data structures that wrap a node tree. However, they work on different abstraction levels. `NodeTreeRef` is an immutable structure that makes working with a node tree in C++ much more efficient and convenient. It supports various queries efficiently, that are not easily possible using just `bNodeTree`. `DerivedNodeTree` builds on top of `NodeTreeRef`. It contains a flattened view on the node tree, i.e. with node groups being inlined. Every inlined node still knows its "call stack". It supports pretty much the same queries as `NodeTreeRef`. Both data structures come with a dot graph exporter for debugging purposes. Reviewers: brecht Differential Revision: https://developer.blender.org/D7628
2020-06-09 17:08:41 +02:00
}
Nodes: store nodes by bNodeType instead of idname This is more efficient in most cases.
2020-06-30 13:35:38 +02:00
inline Span<const NodeRef *> NodeTreeRef::nodes_by_type(StringRefNull idname) const
Nodes: efficient node tree queries and inlining This adds two data structures that wrap a node tree. However, they work on different abstraction levels. `NodeTreeRef` is an immutable structure that makes working with a node tree in C++ much more efficient and convenient. It supports various queries efficiently, that are not easily possible using just `bNodeTree`. `DerivedNodeTree` builds on top of `NodeTreeRef`. It contains a flattened view on the node tree, i.e. with node groups being inlined. Every inlined node still knows its "call stack". It supports pretty much the same queries as `NodeTreeRef`. Both data structures come with a dot graph exporter for debugging purposes. Reviewers: brecht Differential Revision: https://developer.blender.org/D7628
2020-06-09 17:08:41 +02:00
{
BLI: add StringRefNull.c_str() method This should be used whenever you rely on the fact, that the returned pointer points to the beginning of a null-terminated array.
2020-07-17 12:38:15 +02:00
const bNodeType *nodetype = nodeTypeFind(idname.c_str());
Nodes: store nodes by bNodeType instead of idname This is more efficient in most cases.
2020-06-30 13:35:38 +02:00
return this->nodes_by_type(nodetype);
}
inline Span<const NodeRef *> NodeTreeRef::nodes_by_type(const bNodeType *nodetype) const
{
BLI: add MultiValueMap This is a convenience wrapper for `Map<Key, Vector<Value>>`. It does not provide any performance benefits (yet). I need this kind of map in a couple of places and before I was duplicating the lookup logic in many places.
2020-07-24 12:15:13 +02:00
return nodes_by_type_.lookup(nodetype);
Nodes: efficient node tree queries and inlining This adds two data structures that wrap a node tree. However, they work on different abstraction levels. `NodeTreeRef` is an immutable structure that makes working with a node tree in C++ much more efficient and convenient. It supports various queries efficiently, that are not easily possible using just `bNodeTree`. `DerivedNodeTree` builds on top of `NodeTreeRef`. It contains a flattened view on the node tree, i.e. with node groups being inlined. Every inlined node still knows its "call stack". It supports pretty much the same queries as `NodeTreeRef`. Both data structures come with a dot graph exporter for debugging purposes. Reviewers: brecht Differential Revision: https://developer.blender.org/D7628
2020-06-09 17:08:41 +02:00
}
inline Span<const SocketRef *> NodeTreeRef::sockets() const
{
Cleanup: remove unnecessary calls to as_span This uses the new implicit conversions and constructors that have been committed in the previous commit. I tested these changes on Linux with gcc and on Windows.
2020-07-08 22:29:10 +02:00
return sockets_by_id_;
Nodes: efficient node tree queries and inlining This adds two data structures that wrap a node tree. However, they work on different abstraction levels. `NodeTreeRef` is an immutable structure that makes working with a node tree in C++ much more efficient and convenient. It supports various queries efficiently, that are not easily possible using just `bNodeTree`. `DerivedNodeTree` builds on top of `NodeTreeRef`. It contains a flattened view on the node tree, i.e. with node groups being inlined. Every inlined node still knows its "call stack". It supports pretty much the same queries as `NodeTreeRef`. Both data structures come with a dot graph exporter for debugging purposes. Reviewers: brecht Differential Revision: https://developer.blender.org/D7628
2020-06-09 17:08:41 +02:00
}
inline Span<const InputSocketRef *> NodeTreeRef::input_sockets() const
{
Cleanup: remove unnecessary calls to as_span This uses the new implicit conversions and constructors that have been committed in the previous commit. I tested these changes on Linux with gcc and on Windows.
2020-07-08 22:29:10 +02:00
return input_sockets_;
Nodes: efficient node tree queries and inlining This adds two data structures that wrap a node tree. However, they work on different abstraction levels. `NodeTreeRef` is an immutable structure that makes working with a node tree in C++ much more efficient and convenient. It supports various queries efficiently, that are not easily possible using just `bNodeTree`. `DerivedNodeTree` builds on top of `NodeTreeRef`. It contains a flattened view on the node tree, i.e. with node groups being inlined. Every inlined node still knows its "call stack". It supports pretty much the same queries as `NodeTreeRef`. Both data structures come with a dot graph exporter for debugging purposes. Reviewers: brecht Differential Revision: https://developer.blender.org/D7628
2020-06-09 17:08:41 +02:00
}
inline Span<const OutputSocketRef *> NodeTreeRef::output_sockets() const
{
Cleanup: remove unnecessary calls to as_span This uses the new implicit conversions and constructors that have been committed in the previous commit. I tested these changes on Linux with gcc and on Windows.
2020-07-08 22:29:10 +02:00
return output_sockets_;
Nodes: efficient node tree queries and inlining This adds two data structures that wrap a node tree. However, they work on different abstraction levels. `NodeTreeRef` is an immutable structure that makes working with a node tree in C++ much more efficient and convenient. It supports various queries efficiently, that are not easily possible using just `bNodeTree`. `DerivedNodeTree` builds on top of `NodeTreeRef`. It contains a flattened view on the node tree, i.e. with node groups being inlined. Every inlined node still knows its "call stack". It supports pretty much the same queries as `NodeTreeRef`. Both data structures come with a dot graph exporter for debugging purposes. Reviewers: brecht Differential Revision: https://developer.blender.org/D7628
2020-06-09 17:08:41 +02:00
}
Nodes: store references to bNodeLinks in NodeTreeRef Sometimes it is useful to have this information available to be able to read information from links.
2021-03-03 07:59:07 +01:00
inline Span<const LinkRef *> NodeTreeRef::links() const
{
return links_;
}
Fix T94162: incorrect handling when there are multiple group outputs Typically a node group should only have a single Group Output node. However, currently Blender already supports having multiple group outputs, one of which is active. This wasn't handled correctly by geometry nodes. Differential Revision: https://developer.blender.org/D13611
2021-12-24 12:34:04 +01:00
inline const NodeRef *NodeTreeRef::group_output_node() const
{
return group_output_node_;
}
Nodes: efficient node tree queries and inlining This adds two data structures that wrap a node tree. However, they work on different abstraction levels. `NodeTreeRef` is an immutable structure that makes working with a node tree in C++ much more efficient and convenient. It supports various queries efficiently, that are not easily possible using just `bNodeTree`. `DerivedNodeTree` builds on top of `NodeTreeRef`. It contains a flattened view on the node tree, i.e. with node groups being inlined. Every inlined node still knows its "call stack". It supports pretty much the same queries as `NodeTreeRef`. Both data structures come with a dot graph exporter for debugging purposes. Reviewers: brecht Differential Revision: https://developer.blender.org/D7628
2020-06-09 17:08:41 +02:00
inline bNodeTree *NodeTreeRef::btree() const
{
Cleanup: Use trailing underscore for non-public data members This makes the code conform better with our style guide.
2020-07-03 14:15:05 +02:00
return btree_;
Nodes: efficient node tree queries and inlining This adds two data structures that wrap a node tree. However, they work on different abstraction levels. `NodeTreeRef` is an immutable structure that makes working with a node tree in C++ much more efficient and convenient. It supports various queries efficiently, that are not easily possible using just `bNodeTree`. `DerivedNodeTree` builds on top of `NodeTreeRef`. It contains a flattened view on the node tree, i.e. with node groups being inlined. Every inlined node still knows its "call stack". It supports pretty much the same queries as `NodeTreeRef`. Both data structures come with a dot graph exporter for debugging purposes. Reviewers: brecht Differential Revision: https://developer.blender.org/D7628
2020-06-09 17:08:41 +02:00
}
Nodes: expose tree name and whether a node is a frame in node tree ref
2021-03-19 22:33:43 +01:00
inline StringRefNull NodeTreeRef::name() const
{
return btree_->id.name + 2;
}
Cleanup: use doxygen sections
2021-10-05 11:10:25 +11:00
/** \} */
Nodes: move some code from blenkernel directory to nodes This also introduces the `blender::nodes` namespace. Eventually, we want to move most/all of the node implementation files into this namespace. The reason for this file-move is that the code fits much better into the `nodes` directory than in the `blenkernel` directory.
2020-07-17 11:36:59 +02:00
} // namespace blender::nodes
Copy Permalink