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. You cannot open issues or pull requests or push a commit.
Files
5c9ab3e003d2cdca46c078c33c946ec1d7ab7626
blender-archive/source/blender/compositor/intern/COM_Debug.cc

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

488 lines
17 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
* Copyright 2013 Blender Foundation. */
Cleanup and improvements of the compositor debug output. Debug code for graphviz output moved to a dedicated file COM_Debug.h/cpp. The DebugInfo class has only static functions, which are called from a number of places to keep track of what is happening in the compositor. If debugging is disabled these are just inline stubs, so we don't need #ifdefs everywhere and don't get any overhead. The graphviz output is much more useful now. DebugInfo keeps track of node names in a static string map for meaningful names. It uses a number of colors for various special operation classes. ExecutionGroups are indicated in graphviz with clusters. Currently the graphviz .dot files are stored in the BLI_temporary_dir() folder. A separate dot file is generated for each stage of the ExecutionGroup scheduling, this is intended to give some idea of the compositor progress, but could still be improved.
2013-09-13 13:36:47 +00:00
#include "COM_Debug.h"
extern "C" {
Fix: Compile Error COM_Debug. We should replace `ifdef COM_Debug` with a constexpr function.
2021-03-30 09:18:40 +02:00
#include "BLI_fileops.h"
#include "BLI_path_util.h"
#include "BKE_appdir.h"
Compositor: Export operation results as debug option When fixing issues, seeing operation results can be helpful for detecting which operation went wrong. This commit adds an option for exporting all operations results to image files. Exceptions are: - Output operations: They are already exported or can be seen in UI. - Constant operations: There are too many and is rarely useful. They are exported to "<temp session folder>/COM_operations/" with filenames "<operation class name>_<operation id>.png". Only works on full frame execution mode. Reviewed By: jbakker Differential Revision: https://developer.blender.org/D11722
2021-07-19 19:55:15 +02:00
#include "IMB_imbuf.h"
#include "IMB_imbuf_types.h"
Cleanup and improvements of the compositor debug output. Debug code for graphviz output moved to a dedicated file COM_Debug.h/cpp. The DebugInfo class has only static functions, which are called from a number of places to keep track of what is happening in the compositor. If debugging is disabled these are just inline stubs, so we don't need #ifdefs everywhere and don't get any overhead. The graphviz output is much more useful now. DebugInfo keeps track of node names in a static string map for meaningful names. It uses a number of colors for various special operation classes. ExecutionGroups are indicated in graphviz with clusters. Currently the graphviz .dot files are stored in the BLI_temporary_dir() folder. A separate dot file is generated for each stage of the ExecutionGroup scheduling, this is intended to give some idea of the compositor progress, but could still be improved.
2013-09-13 13:36:47 +00:00
}
Cleanup: remove unused includes in Compositor And move unneeded includes in frequently used headers to source files. Slightly reduces compile time.
2021-10-13 23:00:24 +02:00
#include "COM_ExecutionGroup.h"
Fix: Compile Error COM_Debug. We should replace `ifdef COM_Debug` with a constexpr function.
2021-03-30 09:18:40 +02:00
#include "COM_ReadBufferOperation.h"
Compositor: Graphviz improvements Graphs are usually large, needing a lot of horizontal scrolling and they can include more information for debugging. This patch makes graph more compact horizontally by splitting labels in lines and removing namespaces. Furthermore it adds following information: - Operation ID. - SetValueOperation float value. - Optionally, operation node name. Reviewed By: jbakker Differential Revision: https://developer.blender.org/D11720
2021-07-06 16:37:23 +02:00
#include "COM_SetValueOperation.h"
Fix: Compile Error COM_Debug. We should replace `ifdef COM_Debug` with a constexpr function.
2021-03-30 09:18:40 +02:00
#include "COM_ViewerOperation.h"
#include "COM_WriteBufferOperation.h"
namespace blender::compositor {
Cleanup: replace members `m_` prefix by `_` suffix in Compositor To convert old code to the current convention and use a single code style.
2021-10-13 23:01:04 +02:00
int DebugInfo::file_index_ = 0;
DebugInfo::NodeNameMap DebugInfo::node_names_;
DebugInfo::OpNameMap DebugInfo::op_names_;
std::string DebugInfo::current_node_name_;
std::string DebugInfo::current_op_name_;
DebugInfo::GroupStateMap DebugInfo::group_states_;
Cleanup and improvements of the compositor debug output. Debug code for graphviz output moved to a dedicated file COM_Debug.h/cpp. The DebugInfo class has only static functions, which are called from a number of places to keep track of what is happening in the compositor. If debugging is disabled these are just inline stubs, so we don't need #ifdefs everywhere and don't get any overhead. The graphviz output is much more useful now. DebugInfo keeps track of node names in a static string map for meaningful names. It uses a number of colors for various special operation classes. ExecutionGroups are indicated in graphviz with clusters. Currently the graphviz .dot files are stored in the BLI_temporary_dir() folder. A separate dot file is generated for each stage of the ExecutionGroup scheduling, this is intended to give some idea of the compositor progress, but could still be improved.
2013-09-13 13:36:47 +00:00
Compositor: Export operation results as debug option When fixing issues, seeing operation results can be helpful for detecting which operation went wrong. This commit adds an option for exporting all operations results to image files. Exceptions are: - Output operations: They are already exported or can be seen in UI. - Constant operations: There are too many and is rarely useful. They are exported to "<temp session folder>/COM_operations/" with filenames "<operation class name>_<operation id>.png". Only works on full frame execution mode. Reviewed By: jbakker Differential Revision: https://developer.blender.org/D11722
2021-07-19 19:55:15 +02:00
static std::string operation_class_name(const NodeOperation *op)
Compositor: Graphviz improvements Graphs are usually large, needing a lot of horizontal scrolling and they can include more information for debugging. This patch makes graph more compact horizontally by splitting labels in lines and removing namespaces. Furthermore it adds following information: - Operation ID. - SetValueOperation float value. - Optionally, operation node name. Reviewed By: jbakker Differential Revision: https://developer.blender.org/D11720
2021-07-06 16:37:23 +02:00
{
std::string full_name = typeid(*op).name();
Cleanup: spelling in comments
2021-07-07 12:55:19 +10:00
/* Remove name-spaces. */
Compositor: Graphviz improvements Graphs are usually large, needing a lot of horizontal scrolling and they can include more information for debugging. This patch makes graph more compact horizontally by splitting labels in lines and removing namespaces. Furthermore it adds following information: - Operation ID. - SetValueOperation float value. - Optionally, operation node name. Reviewed By: jbakker Differential Revision: https://developer.blender.org/D11720
2021-07-06 16:37:23 +02:00
size_t pos = full_name.find_last_of(':');
BLI_assert(pos != std::string::npos);
return full_name.substr(pos + 1);
}
Structural cleanup and improvements for the compositor. Many parts of the compositor are unnecessarily complicated. This patch aims at reducing the complexity of writing nodes and making the code more transparent. == Separating Nodes and Operations == Currently these are both mixed in the same graph, even though they have very different purposes and are used at distinct stages in the compositing process. The patch introduces dedicated graph classes for nodes and for operations. This removes the need for a lot of special case checks (isOperation etc.) and explicit type casts. It simplifies the code since it becomes clear at every stage what type of node we are dealing with. The compiler can use static typing to avoid common bugs from mixing up these types and fewer runtime sanity checks are needed. == Simplified Node Conversion == Converting nodes to operations was previously based on "relinking", i.e. nodes would start with by mirroring links in the Blender DNA node trees, then add operations and redirect these links to them. This was very hard to follow in many cases and required a lot of attention to avoid invalid states. Now there is a helper class called the NodeConverter, which is passed to nodes and implements a much simpler API for this process. Nodes can add operations and explicit connections as before, but defining "external" links to the inputs/outputs of the original node now uses mapping instead of directly modifying link data. Input data (node graph) and result (operations graph) are cleanly separated. == Removed Redundant Data Structures == A few redundant data structures have been removed, notably the SocketConnection. These are only needed temporarily during graph construction. For executing the compositor operations it is perfectly sufficient to store only the direct input link pointers. A common pointer indirection is avoided this way (which might also give a little performance improvement). == Avoid virtual recursive functions == Recursive virtual functions are evil. They are very hard to follow during debugging. At least in the parts this patch is concerned with these functions have been replaced by a non-virtual recursive core function (which might then call virtual non-recursive functions if needed). See for example NodeOperationBuilder::group_operations.
2014-04-15 16:06:12 +02:00
std::string DebugInfo::node_name(const Node *node)
Cleanup and improvements of the compositor debug output. Debug code for graphviz output moved to a dedicated file COM_Debug.h/cpp. The DebugInfo class has only static functions, which are called from a number of places to keep track of what is happening in the compositor. If debugging is disabled these are just inline stubs, so we don't need #ifdefs everywhere and don't get any overhead. The graphviz output is much more useful now. DebugInfo keeps track of node names in a static string map for meaningful names. It uses a number of colors for various special operation classes. ExecutionGroups are indicated in graphviz with clusters. Currently the graphviz .dot files are stored in the BLI_temporary_dir() folder. A separate dot file is generated for each stage of the ExecutionGroup scheduling, this is intended to give some idea of the compositor progress, but could still be improved.
2013-09-13 13:36:47 +00:00
{
Cleanup: replace members `m_` prefix by `_` suffix in Compositor To convert old code to the current convention and use a single code style.
2021-10-13 23:01:04 +02:00
NodeNameMap::const_iterator it = node_names_.find(node);
if (it != node_names_.end()) {
Cleanup and improvements of the compositor debug output. Debug code for graphviz output moved to a dedicated file COM_Debug.h/cpp. The DebugInfo class has only static functions, which are called from a number of places to keep track of what is happening in the compositor. If debugging is disabled these are just inline stubs, so we don't need #ifdefs everywhere and don't get any overhead. The graphviz output is much more useful now. DebugInfo keeps track of node names in a static string map for meaningful names. It uses a number of colors for various special operation classes. ExecutionGroups are indicated in graphviz with clusters. Currently the graphviz .dot files are stored in the BLI_temporary_dir() folder. A separate dot file is generated for each stage of the ExecutionGroup scheduling, this is intended to give some idea of the compositor progress, but could still be improved.
2013-09-13 13:36:47 +00:00
return it->second;
Cleanup: style, use braces for compositor
2019-04-23 11:21:22 +10:00
}
Cleanup: fix clang-tidy errors when COM_debug is active.
2021-03-12 14:32:24 +01:00
return "";
Cleanup and improvements of the compositor debug output. Debug code for graphviz output moved to a dedicated file COM_Debug.h/cpp. The DebugInfo class has only static functions, which are called from a number of places to keep track of what is happening in the compositor. If debugging is disabled these are just inline stubs, so we don't need #ifdefs everywhere and don't get any overhead. The graphviz output is much more useful now. DebugInfo keeps track of node names in a static string map for meaningful names. It uses a number of colors for various special operation classes. ExecutionGroups are indicated in graphviz with clusters. Currently the graphviz .dot files are stored in the BLI_temporary_dir() folder. A separate dot file is generated for each stage of the ExecutionGroup scheduling, this is intended to give some idea of the compositor progress, but could still be improved.
2013-09-13 13:36:47 +00:00
}
Structural cleanup and improvements for the compositor. Many parts of the compositor are unnecessarily complicated. This patch aims at reducing the complexity of writing nodes and making the code more transparent. == Separating Nodes and Operations == Currently these are both mixed in the same graph, even though they have very different purposes and are used at distinct stages in the compositing process. The patch introduces dedicated graph classes for nodes and for operations. This removes the need for a lot of special case checks (isOperation etc.) and explicit type casts. It simplifies the code since it becomes clear at every stage what type of node we are dealing with. The compiler can use static typing to avoid common bugs from mixing up these types and fewer runtime sanity checks are needed. == Simplified Node Conversion == Converting nodes to operations was previously based on "relinking", i.e. nodes would start with by mirroring links in the Blender DNA node trees, then add operations and redirect these links to them. This was very hard to follow in many cases and required a lot of attention to avoid invalid states. Now there is a helper class called the NodeConverter, which is passed to nodes and implements a much simpler API for this process. Nodes can add operations and explicit connections as before, but defining "external" links to the inputs/outputs of the original node now uses mapping instead of directly modifying link data. Input data (node graph) and result (operations graph) are cleanly separated. == Removed Redundant Data Structures == A few redundant data structures have been removed, notably the SocketConnection. These are only needed temporarily during graph construction. For executing the compositor operations it is perfectly sufficient to store only the direct input link pointers. A common pointer indirection is avoided this way (which might also give a little performance improvement). == Avoid virtual recursive functions == Recursive virtual functions are evil. They are very hard to follow during debugging. At least in the parts this patch is concerned with these functions have been replaced by a non-virtual recursive core function (which might then call virtual non-recursive functions if needed). See for example NodeOperationBuilder::group_operations.
2014-04-15 16:06:12 +02:00
std::string DebugInfo::operation_name(const NodeOperation *op)
{
Cleanup: replace members `m_` prefix by `_` suffix in Compositor To convert old code to the current convention and use a single code style.
2021-10-13 23:01:04 +02:00
OpNameMap::const_iterator it = op_names_.find(op);
if (it != op_names_.end()) {
Structural cleanup and improvements for the compositor. Many parts of the compositor are unnecessarily complicated. This patch aims at reducing the complexity of writing nodes and making the code more transparent. == Separating Nodes and Operations == Currently these are both mixed in the same graph, even though they have very different purposes and are used at distinct stages in the compositing process. The patch introduces dedicated graph classes for nodes and for operations. This removes the need for a lot of special case checks (isOperation etc.) and explicit type casts. It simplifies the code since it becomes clear at every stage what type of node we are dealing with. The compiler can use static typing to avoid common bugs from mixing up these types and fewer runtime sanity checks are needed. == Simplified Node Conversion == Converting nodes to operations was previously based on "relinking", i.e. nodes would start with by mirroring links in the Blender DNA node trees, then add operations and redirect these links to them. This was very hard to follow in many cases and required a lot of attention to avoid invalid states. Now there is a helper class called the NodeConverter, which is passed to nodes and implements a much simpler API for this process. Nodes can add operations and explicit connections as before, but defining "external" links to the inputs/outputs of the original node now uses mapping instead of directly modifying link data. Input data (node graph) and result (operations graph) are cleanly separated. == Removed Redundant Data Structures == A few redundant data structures have been removed, notably the SocketConnection. These are only needed temporarily during graph construction. For executing the compositor operations it is perfectly sufficient to store only the direct input link pointers. A common pointer indirection is avoided this way (which might also give a little performance improvement). == Avoid virtual recursive functions == Recursive virtual functions are evil. They are very hard to follow during debugging. At least in the parts this patch is concerned with these functions have been replaced by a non-virtual recursive core function (which might then call virtual non-recursive functions if needed). See for example NodeOperationBuilder::group_operations.
2014-04-15 16:06:12 +02:00
return it->second;
Cleanup: style, use braces for compositor
2019-04-23 11:21:22 +10:00
}
Cleanup: fix clang-tidy errors when COM_debug is active.
2021-03-12 14:32:24 +01:00
return "";
Structural cleanup and improvements for the compositor. Many parts of the compositor are unnecessarily complicated. This patch aims at reducing the complexity of writing nodes and making the code more transparent. == Separating Nodes and Operations == Currently these are both mixed in the same graph, even though they have very different purposes and are used at distinct stages in the compositing process. The patch introduces dedicated graph classes for nodes and for operations. This removes the need for a lot of special case checks (isOperation etc.) and explicit type casts. It simplifies the code since it becomes clear at every stage what type of node we are dealing with. The compiler can use static typing to avoid common bugs from mixing up these types and fewer runtime sanity checks are needed. == Simplified Node Conversion == Converting nodes to operations was previously based on "relinking", i.e. nodes would start with by mirroring links in the Blender DNA node trees, then add operations and redirect these links to them. This was very hard to follow in many cases and required a lot of attention to avoid invalid states. Now there is a helper class called the NodeConverter, which is passed to nodes and implements a much simpler API for this process. Nodes can add operations and explicit connections as before, but defining "external" links to the inputs/outputs of the original node now uses mapping instead of directly modifying link data. Input data (node graph) and result (operations graph) are cleanly separated. == Removed Redundant Data Structures == A few redundant data structures have been removed, notably the SocketConnection. These are only needed temporarily during graph construction. For executing the compositor operations it is perfectly sufficient to store only the direct input link pointers. A common pointer indirection is avoided this way (which might also give a little performance improvement). == Avoid virtual recursive functions == Recursive virtual functions are evil. They are very hard to follow during debugging. At least in the parts this patch is concerned with these functions have been replaced by a non-virtual recursive core function (which might then call virtual non-recursive functions if needed). See for example NodeOperationBuilder::group_operations.
2014-04-15 16:06:12 +02:00
}
int DebugInfo::graphviz_operation(const ExecutionSystem *system,
Fix: Compile Error COM_Debug. We should replace `ifdef COM_Debug` with a constexpr function.
2021-03-30 09:18:40 +02:00
NodeOperation *operation,
Structural cleanup and improvements for the compositor. Many parts of the compositor are unnecessarily complicated. This patch aims at reducing the complexity of writing nodes and making the code more transparent. == Separating Nodes and Operations == Currently these are both mixed in the same graph, even though they have very different purposes and are used at distinct stages in the compositing process. The patch introduces dedicated graph classes for nodes and for operations. This removes the need for a lot of special case checks (isOperation etc.) and explicit type casts. It simplifies the code since it becomes clear at every stage what type of node we are dealing with. The compiler can use static typing to avoid common bugs from mixing up these types and fewer runtime sanity checks are needed. == Simplified Node Conversion == Converting nodes to operations was previously based on "relinking", i.e. nodes would start with by mirroring links in the Blender DNA node trees, then add operations and redirect these links to them. This was very hard to follow in many cases and required a lot of attention to avoid invalid states. Now there is a helper class called the NodeConverter, which is passed to nodes and implements a much simpler API for this process. Nodes can add operations and explicit connections as before, but defining "external" links to the inputs/outputs of the original node now uses mapping instead of directly modifying link data. Input data (node graph) and result (operations graph) are cleanly separated. == Removed Redundant Data Structures == A few redundant data structures have been removed, notably the SocketConnection. These are only needed temporarily during graph construction. For executing the compositor operations it is perfectly sufficient to store only the direct input link pointers. A common pointer indirection is avoided this way (which might also give a little performance improvement). == Avoid virtual recursive functions == Recursive virtual functions are evil. They are very hard to follow during debugging. At least in the parts this patch is concerned with these functions have been replaced by a non-virtual recursive core function (which might then call virtual non-recursive functions if needed). See for example NodeOperationBuilder::group_operations.
2014-04-15 16:06:12 +02:00
const ExecutionGroup *group,
char *str,
int maxlen)
Cleanup and improvements of the compositor debug output. Debug code for graphviz output moved to a dedicated file COM_Debug.h/cpp. The DebugInfo class has only static functions, which are called from a number of places to keep track of what is happening in the compositor. If debugging is disabled these are just inline stubs, so we don't need #ifdefs everywhere and don't get any overhead. The graphviz output is much more useful now. DebugInfo keeps track of node names in a static string map for meaningful names. It uses a number of colors for various special operation classes. ExecutionGroups are indicated in graphviz with clusters. Currently the graphviz .dot files are stored in the BLI_temporary_dir() folder. A separate dot file is generated for each stage of the ExecutionGroup scheduling, this is intended to give some idea of the compositor progress, but could still be improved.
2013-09-13 13:36:47 +00:00
{
int len = 0;
ClangFormat: apply to source, most of intern Apply clang format as proposed in T53211. For details on usage and instructions for migrating branches without conflicts, see: https://wiki.blender.org/wiki/Tools/ClangFormat
2019-04-17 06:17:24 +02:00
Cleanup and improvements of the compositor debug output. Debug code for graphviz output moved to a dedicated file COM_Debug.h/cpp. The DebugInfo class has only static functions, which are called from a number of places to keep track of what is happening in the compositor. If debugging is disabled these are just inline stubs, so we don't need #ifdefs everywhere and don't get any overhead. The graphviz output is much more useful now. DebugInfo keeps track of node names in a static string map for meaningful names. It uses a number of colors for various special operation classes. ExecutionGroups are indicated in graphviz with clusters. Currently the graphviz .dot files are stored in the BLI_temporary_dir() folder. A separate dot file is generated for each stage of the ExecutionGroup scheduling, this is intended to give some idea of the compositor progress, but could still be improved.
2013-09-13 13:36:47 +00:00
std::string fillcolor = "gainsboro";
Fix: Compile Error COM_Debug. We should replace `ifdef COM_Debug` with a constexpr function.
2021-03-30 09:18:40 +02:00
if (operation->get_flags().is_viewer_operation) {
Structural cleanup and improvements for the compositor. Many parts of the compositor are unnecessarily complicated. This patch aims at reducing the complexity of writing nodes and making the code more transparent. == Separating Nodes and Operations == Currently these are both mixed in the same graph, even though they have very different purposes and are used at distinct stages in the compositing process. The patch introduces dedicated graph classes for nodes and for operations. This removes the need for a lot of special case checks (isOperation etc.) and explicit type casts. It simplifies the code since it becomes clear at every stage what type of node we are dealing with. The compiler can use static typing to avoid common bugs from mixing up these types and fewer runtime sanity checks are needed. == Simplified Node Conversion == Converting nodes to operations was previously based on "relinking", i.e. nodes would start with by mirroring links in the Blender DNA node trees, then add operations and redirect these links to them. This was very hard to follow in many cases and required a lot of attention to avoid invalid states. Now there is a helper class called the NodeConverter, which is passed to nodes and implements a much simpler API for this process. Nodes can add operations and explicit connections as before, but defining "external" links to the inputs/outputs of the original node now uses mapping instead of directly modifying link data. Input data (node graph) and result (operations graph) are cleanly separated. == Removed Redundant Data Structures == A few redundant data structures have been removed, notably the SocketConnection. These are only needed temporarily during graph construction. For executing the compositor operations it is perfectly sufficient to store only the direct input link pointers. A common pointer indirection is avoided this way (which might also give a little performance improvement). == Avoid virtual recursive functions == Recursive virtual functions are evil. They are very hard to follow during debugging. At least in the parts this patch is concerned with these functions have been replaced by a non-virtual recursive core function (which might then call virtual non-recursive functions if needed). See for example NodeOperationBuilder::group_operations.
2014-04-15 16:06:12 +02:00
const ViewerOperation *viewer = (const ViewerOperation *)operation;
Cleanup: convert camelCase naming to snake_case in Compositor To convert old code to the current convention and use a single code style.
2021-10-13 23:01:15 +02:00
if (viewer->is_active_viewer_output()) {
Cleanup and improvements of the compositor debug output. Debug code for graphviz output moved to a dedicated file COM_Debug.h/cpp. The DebugInfo class has only static functions, which are called from a number of places to keep track of what is happening in the compositor. If debugging is disabled these are just inline stubs, so we don't need #ifdefs everywhere and don't get any overhead. The graphviz output is much more useful now. DebugInfo keeps track of node names in a static string map for meaningful names. It uses a number of colors for various special operation classes. ExecutionGroups are indicated in graphviz with clusters. Currently the graphviz .dot files are stored in the BLI_temporary_dir() folder. A separate dot file is generated for each stage of the ExecutionGroup scheduling, this is intended to give some idea of the compositor progress, but could still be improved.
2013-09-13 13:36:47 +00:00
fillcolor = "lightskyblue1";
}
else {
fillcolor = "lightskyblue3";
ClangFormat: apply to source, most of intern Apply clang format as proposed in T53211. For details on usage and instructions for migrating branches without conflicts, see: https://wiki.blender.org/wiki/Tools/ClangFormat
2019-04-17 06:17:24 +02:00
}
Cleanup and improvements of the compositor debug output. Debug code for graphviz output moved to a dedicated file COM_Debug.h/cpp. The DebugInfo class has only static functions, which are called from a number of places to keep track of what is happening in the compositor. If debugging is disabled these are just inline stubs, so we don't need #ifdefs everywhere and don't get any overhead. The graphviz output is much more useful now. DebugInfo keeps track of node names in a static string map for meaningful names. It uses a number of colors for various special operation classes. ExecutionGroups are indicated in graphviz with clusters. Currently the graphviz .dot files are stored in the BLI_temporary_dir() folder. A separate dot file is generated for each stage of the ExecutionGroup scheduling, this is intended to give some idea of the compositor progress, but could still be improved.
2013-09-13 13:36:47 +00:00
}
Cleanup: convert camelCase naming to snake_case in Compositor To convert old code to the current convention and use a single code style.
2021-10-13 23:01:15 +02:00
else if (operation->is_output_operation(system->get_context().is_rendering())) {
Cleanup and improvements of the compositor debug output. Debug code for graphviz output moved to a dedicated file COM_Debug.h/cpp. The DebugInfo class has only static functions, which are called from a number of places to keep track of what is happening in the compositor. If debugging is disabled these are just inline stubs, so we don't need #ifdefs everywhere and don't get any overhead. The graphviz output is much more useful now. DebugInfo keeps track of node names in a static string map for meaningful names. It uses a number of colors for various special operation classes. ExecutionGroups are indicated in graphviz with clusters. Currently the graphviz .dot files are stored in the BLI_temporary_dir() folder. A separate dot file is generated for each stage of the ExecutionGroup scheduling, this is intended to give some idea of the compositor progress, but could still be improved.
2013-09-13 13:36:47 +00:00
fillcolor = "dodgerblue1";
}
Fix: Compile Error COM_Debug. We should replace `ifdef COM_Debug` with a constexpr function.
2021-03-30 09:18:40 +02:00
else if (operation->get_flags().is_set_operation) {
Cleanup and improvements of the compositor debug output. Debug code for graphviz output moved to a dedicated file COM_Debug.h/cpp. The DebugInfo class has only static functions, which are called from a number of places to keep track of what is happening in the compositor. If debugging is disabled these are just inline stubs, so we don't need #ifdefs everywhere and don't get any overhead. The graphviz output is much more useful now. DebugInfo keeps track of node names in a static string map for meaningful names. It uses a number of colors for various special operation classes. ExecutionGroups are indicated in graphviz with clusters. Currently the graphviz .dot files are stored in the BLI_temporary_dir() folder. A separate dot file is generated for each stage of the ExecutionGroup scheduling, this is intended to give some idea of the compositor progress, but could still be improved.
2013-09-13 13:36:47 +00:00
fillcolor = "khaki1";
}
Cleanup: Replace `is...Operation()` methods with a flag.
2021-03-29 16:54:02 +02:00
else if (operation->get_flags().is_read_buffer_operation) {
Cleanup and improvements of the compositor debug output. Debug code for graphviz output moved to a dedicated file COM_Debug.h/cpp. The DebugInfo class has only static functions, which are called from a number of places to keep track of what is happening in the compositor. If debugging is disabled these are just inline stubs, so we don't need #ifdefs everywhere and don't get any overhead. The graphviz output is much more useful now. DebugInfo keeps track of node names in a static string map for meaningful names. It uses a number of colors for various special operation classes. ExecutionGroups are indicated in graphviz with clusters. Currently the graphviz .dot files are stored in the BLI_temporary_dir() folder. A separate dot file is generated for each stage of the ExecutionGroup scheduling, this is intended to give some idea of the compositor progress, but could still be improved.
2013-09-13 13:36:47 +00:00
fillcolor = "darkolivegreen3";
}
Cleanup: Replace `is...Operation()` methods with a flag.
2021-03-29 16:54:02 +02:00
else if (operation->get_flags().is_write_buffer_operation) {
Cleanup and improvements of the compositor debug output. Debug code for graphviz output moved to a dedicated file COM_Debug.h/cpp. The DebugInfo class has only static functions, which are called from a number of places to keep track of what is happening in the compositor. If debugging is disabled these are just inline stubs, so we don't need #ifdefs everywhere and don't get any overhead. The graphviz output is much more useful now. DebugInfo keeps track of node names in a static string map for meaningful names. It uses a number of colors for various special operation classes. ExecutionGroups are indicated in graphviz with clusters. Currently the graphviz .dot files are stored in the BLI_temporary_dir() folder. A separate dot file is generated for each stage of the ExecutionGroup scheduling, this is intended to give some idea of the compositor progress, but could still be improved.
2013-09-13 13:36:47 +00:00
fillcolor = "darkorange";
}
ClangFormat: apply to source, most of intern Apply clang format as proposed in T53211. For details on usage and instructions for migrating branches without conflicts, see: https://wiki.blender.org/wiki/Tools/ClangFormat
2019-04-17 06:17:24 +02:00
style cleanup
2013-09-18 23:08:23 +00:00
len += snprintf(str + len, maxlen > len ? maxlen - len : 0, "// OPERATION: %p\r\n", operation);
Cleanup: style, use braces for compositor
2019-04-23 11:21:22 +10:00
if (group) {
style cleanup
2013-09-18 23:08:23 +00:00
len += snprintf(str + len, maxlen > len ? maxlen - len : 0, "\"O_%p_%p\"", operation, group);
Cleanup: style, use braces for compositor
2019-04-23 11:21:22 +10:00
}
else {
style cleanup
2013-09-18 23:08:23 +00:00
len += snprintf(str + len, maxlen > len ? maxlen - len : 0, "\"O_%p\"", operation);
Cleanup: style, use braces for compositor
2019-04-23 11:21:22 +10:00
}
style cleanup
2013-09-18 23:08:23 +00:00
len += snprintf(str + len,
maxlen > len ? maxlen - len : 0,
" [fillcolor=%s,style=filled,shape=record,label=\"{",
fillcolor.c_str());
ClangFormat: apply to source, most of intern Apply clang format as proposed in T53211. For details on usage and instructions for migrating branches without conflicts, see: https://wiki.blender.org/wiki/Tools/ClangFormat
2019-04-17 06:17:24 +02:00
Cleanup: convert camelCase naming to snake_case in Compositor To convert old code to the current convention and use a single code style.
2021-10-13 23:01:15 +02:00
int totinputs = operation->get_number_of_input_sockets();
Cleanup and improvements of the compositor debug output. Debug code for graphviz output moved to a dedicated file COM_Debug.h/cpp. The DebugInfo class has only static functions, which are called from a number of places to keep track of what is happening in the compositor. If debugging is disabled these are just inline stubs, so we don't need #ifdefs everywhere and don't get any overhead. The graphviz output is much more useful now. DebugInfo keeps track of node names in a static string map for meaningful names. It uses a number of colors for various special operation classes. ExecutionGroups are indicated in graphviz with clusters. Currently the graphviz .dot files are stored in the BLI_temporary_dir() folder. A separate dot file is generated for each stage of the ExecutionGroup scheduling, this is intended to give some idea of the compositor progress, but could still be improved.
2013-09-13 13:36:47 +00:00
if (totinputs != 0) {
style cleanup
2013-09-18 23:08:23 +00:00
len += snprintf(str + len, maxlen > len ? maxlen - len : 0, "{");
Cleanup and improvements of the compositor debug output. Debug code for graphviz output moved to a dedicated file COM_Debug.h/cpp. The DebugInfo class has only static functions, which are called from a number of places to keep track of what is happening in the compositor. If debugging is disabled these are just inline stubs, so we don't need #ifdefs everywhere and don't get any overhead. The graphviz output is much more useful now. DebugInfo keeps track of node names in a static string map for meaningful names. It uses a number of colors for various special operation classes. ExecutionGroups are indicated in graphviz with clusters. Currently the graphviz .dot files are stored in the BLI_temporary_dir() folder. A separate dot file is generated for each stage of the ExecutionGroup scheduling, this is intended to give some idea of the compositor progress, but could still be improved.
2013-09-13 13:36:47 +00:00
for (int k = 0; k < totinputs; k++) {
Cleanup: convert camelCase naming to snake_case in Compositor To convert old code to the current convention and use a single code style.
2021-10-13 23:01:15 +02:00
NodeOperationInput *socket = operation->get_input_socket(k);
Cleanup and improvements of the compositor debug output. Debug code for graphviz output moved to a dedicated file COM_Debug.h/cpp. The DebugInfo class has only static functions, which are called from a number of places to keep track of what is happening in the compositor. If debugging is disabled these are just inline stubs, so we don't need #ifdefs everywhere and don't get any overhead. The graphviz output is much more useful now. DebugInfo keeps track of node names in a static string map for meaningful names. It uses a number of colors for various special operation classes. ExecutionGroups are indicated in graphviz with clusters. Currently the graphviz .dot files are stored in the BLI_temporary_dir() folder. A separate dot file is generated for each stage of the ExecutionGroup scheduling, this is intended to give some idea of the compositor progress, but could still be improved.
2013-09-13 13:36:47 +00:00
if (k != 0) {
style cleanup
2013-09-18 23:08:23 +00:00
len += snprintf(str + len, maxlen > len ? maxlen - len : 0, "|");
Cleanup and improvements of the compositor debug output. Debug code for graphviz output moved to a dedicated file COM_Debug.h/cpp. The DebugInfo class has only static functions, which are called from a number of places to keep track of what is happening in the compositor. If debugging is disabled these are just inline stubs, so we don't need #ifdefs everywhere and don't get any overhead. The graphviz output is much more useful now. DebugInfo keeps track of node names in a static string map for meaningful names. It uses a number of colors for various special operation classes. ExecutionGroups are indicated in graphviz with clusters. Currently the graphviz .dot files are stored in the BLI_temporary_dir() folder. A separate dot file is generated for each stage of the ExecutionGroup scheduling, this is intended to give some idea of the compositor progress, but could still be improved.
2013-09-13 13:36:47 +00:00
}
style cleanup
2013-09-18 23:08:23 +00:00
len += snprintf(str + len, maxlen > len ? maxlen - len : 0, "<IN_%p>", socket);
Cleanup: convert camelCase naming to snake_case in Compositor To convert old code to the current convention and use a single code style.
2021-10-13 23:01:15 +02:00
switch (socket->get_data_type()) {
Cleanup: Use enum class for DataType.
2021-03-19 14:26:24 +01:00
case DataType::Value:
style cleanup
2013-09-18 23:08:23 +00:00
len += snprintf(str + len, maxlen > len ? maxlen - len : 0, "Value");
Cleanup and improvements of the compositor debug output. Debug code for graphviz output moved to a dedicated file COM_Debug.h/cpp. The DebugInfo class has only static functions, which are called from a number of places to keep track of what is happening in the compositor. If debugging is disabled these are just inline stubs, so we don't need #ifdefs everywhere and don't get any overhead. The graphviz output is much more useful now. DebugInfo keeps track of node names in a static string map for meaningful names. It uses a number of colors for various special operation classes. ExecutionGroups are indicated in graphviz with clusters. Currently the graphviz .dot files are stored in the BLI_temporary_dir() folder. A separate dot file is generated for each stage of the ExecutionGroup scheduling, this is intended to give some idea of the compositor progress, but could still be improved.
2013-09-13 13:36:47 +00:00
break;
Cleanup: Use enum class for DataType.
2021-03-19 14:26:24 +01:00
case DataType::Vector:
style cleanup
2013-09-18 23:08:23 +00:00
len += snprintf(str + len, maxlen > len ? maxlen - len : 0, "Vector");
Cleanup and improvements of the compositor debug output. Debug code for graphviz output moved to a dedicated file COM_Debug.h/cpp. The DebugInfo class has only static functions, which are called from a number of places to keep track of what is happening in the compositor. If debugging is disabled these are just inline stubs, so we don't need #ifdefs everywhere and don't get any overhead. The graphviz output is much more useful now. DebugInfo keeps track of node names in a static string map for meaningful names. It uses a number of colors for various special operation classes. ExecutionGroups are indicated in graphviz with clusters. Currently the graphviz .dot files are stored in the BLI_temporary_dir() folder. A separate dot file is generated for each stage of the ExecutionGroup scheduling, this is intended to give some idea of the compositor progress, but could still be improved.
2013-09-13 13:36:47 +00:00
break;
Cleanup: Use enum class for DataType.
2021-03-19 14:26:24 +01:00
case DataType::Color:
style cleanup
2013-09-18 23:08:23 +00:00
len += snprintf(str + len, maxlen > len ? maxlen - len : 0, "Color");
Cleanup and improvements of the compositor debug output. Debug code for graphviz output moved to a dedicated file COM_Debug.h/cpp. The DebugInfo class has only static functions, which are called from a number of places to keep track of what is happening in the compositor. If debugging is disabled these are just inline stubs, so we don't need #ifdefs everywhere and don't get any overhead. The graphviz output is much more useful now. DebugInfo keeps track of node names in a static string map for meaningful names. It uses a number of colors for various special operation classes. ExecutionGroups are indicated in graphviz with clusters. Currently the graphviz .dot files are stored in the BLI_temporary_dir() folder. A separate dot file is generated for each stage of the ExecutionGroup scheduling, this is intended to give some idea of the compositor progress, but could still be improved.
2013-09-13 13:36:47 +00:00
break;
ClangFormat: apply to source, most of intern Apply clang format as proposed in T53211. For details on usage and instructions for migrating branches without conflicts, see: https://wiki.blender.org/wiki/Tools/ClangFormat
2019-04-17 06:17:24 +02:00
}
Cleanup and improvements of the compositor debug output. Debug code for graphviz output moved to a dedicated file COM_Debug.h/cpp. The DebugInfo class has only static functions, which are called from a number of places to keep track of what is happening in the compositor. If debugging is disabled these are just inline stubs, so we don't need #ifdefs everywhere and don't get any overhead. The graphviz output is much more useful now. DebugInfo keeps track of node names in a static string map for meaningful names. It uses a number of colors for various special operation classes. ExecutionGroups are indicated in graphviz with clusters. Currently the graphviz .dot files are stored in the BLI_temporary_dir() folder. A separate dot file is generated for each stage of the ExecutionGroup scheduling, this is intended to give some idea of the compositor progress, but could still be improved.
2013-09-13 13:36:47 +00:00
}
style cleanup
2013-09-18 23:08:23 +00:00
len += snprintf(str + len, maxlen > len ? maxlen - len : 0, "}");
len += snprintf(str + len, maxlen > len ? maxlen - len : 0, "|");
Cleanup and improvements of the compositor debug output. Debug code for graphviz output moved to a dedicated file COM_Debug.h/cpp. The DebugInfo class has only static functions, which are called from a number of places to keep track of what is happening in the compositor. If debugging is disabled these are just inline stubs, so we don't need #ifdefs everywhere and don't get any overhead. The graphviz output is much more useful now. DebugInfo keeps track of node names in a static string map for meaningful names. It uses a number of colors for various special operation classes. ExecutionGroups are indicated in graphviz with clusters. Currently the graphviz .dot files are stored in the BLI_temporary_dir() folder. A separate dot file is generated for each stage of the ExecutionGroup scheduling, this is intended to give some idea of the compositor progress, but could still be improved.
2013-09-13 13:36:47 +00:00
}
ClangFormat: apply to source, most of intern Apply clang format as proposed in T53211. For details on usage and instructions for migrating branches without conflicts, see: https://wiki.blender.org/wiki/Tools/ClangFormat
2019-04-17 06:17:24 +02:00
Compositor: Graphviz improvements Graphs are usually large, needing a lot of horizontal scrolling and they can include more information for debugging. This patch makes graph more compact horizontally by splitting labels in lines and removing namespaces. Furthermore it adds following information: - Operation ID. - SetValueOperation float value. - Optionally, operation node name. Reviewed By: jbakker Differential Revision: https://developer.blender.org/D11720
2021-07-06 16:37:23 +02:00
if (COM_GRAPHVIZ_SHOW_NODE_NAME) {
std::string op_node_name = operation->get_name();
if (!op_node_name.empty()) {
len += snprintf(
str + len, maxlen > len ? maxlen - len : 0, "%s\\n", (op_node_name + " Node").c_str());
}
}
Structural cleanup and improvements for the compositor. Many parts of the compositor are unnecessarily complicated. This patch aims at reducing the complexity of writing nodes and making the code more transparent. == Separating Nodes and Operations == Currently these are both mixed in the same graph, even though they have very different purposes and are used at distinct stages in the compositing process. The patch introduces dedicated graph classes for nodes and for operations. This removes the need for a lot of special case checks (isOperation etc.) and explicit type casts. It simplifies the code since it becomes clear at every stage what type of node we are dealing with. The compiler can use static typing to avoid common bugs from mixing up these types and fewer runtime sanity checks are needed. == Simplified Node Conversion == Converting nodes to operations was previously based on "relinking", i.e. nodes would start with by mirroring links in the Blender DNA node trees, then add operations and redirect these links to them. This was very hard to follow in many cases and required a lot of attention to avoid invalid states. Now there is a helper class called the NodeConverter, which is passed to nodes and implements a much simpler API for this process. Nodes can add operations and explicit connections as before, but defining "external" links to the inputs/outputs of the original node now uses mapping instead of directly modifying link data. Input data (node graph) and result (operations graph) are cleanly separated. == Removed Redundant Data Structures == A few redundant data structures have been removed, notably the SocketConnection. These are only needed temporarily during graph construction. For executing the compositor operations it is perfectly sufficient to store only the direct input link pointers. A common pointer indirection is avoided this way (which might also give a little performance improvement). == Avoid virtual recursive functions == Recursive virtual functions are evil. They are very hard to follow during debugging. At least in the parts this patch is concerned with these functions have been replaced by a non-virtual recursive core function (which might then call virtual non-recursive functions if needed). See for example NodeOperationBuilder::group_operations.
2014-04-15 16:06:12 +02:00
len += snprintf(str + len,
maxlen > len ? maxlen - len : 0,
Compositor: Graphviz improvements Graphs are usually large, needing a lot of horizontal scrolling and they can include more information for debugging. This patch makes graph more compact horizontally by splitting labels in lines and removing namespaces. Furthermore it adds following information: - Operation ID. - SetValueOperation float value. - Optionally, operation node name. Reviewed By: jbakker Differential Revision: https://developer.blender.org/D11720
2021-07-06 16:37:23 +02:00
"%s\\n",
operation_class_name(operation).c_str());
ClangFormat: apply to source, most of intern Apply clang format as proposed in T53211. For details on usage and instructions for migrating branches without conflicts, see: https://wiki.blender.org/wiki/Tools/ClangFormat
2019-04-17 06:17:24 +02:00
Compositor: Fix strict compilation warnings when debug is enabled
2017-10-02 15:18:10 +05:00
len += snprintf(str + len,
maxlen > len ? maxlen - len : 0,
Compositor: Replace resolution concept by canvas This is a code refactor in preparation of supporting canvas compositing. See {D12466}. No functional changes, all canvases are at (0,0) position matching tiled implementation. Differential Revision: https://developer.blender.org/D12465
2021-09-28 19:32:49 +02:00
"#%d (%i,%i) (%u,%u)",
Compositor: Graphviz improvements Graphs are usually large, needing a lot of horizontal scrolling and they can include more information for debugging. This patch makes graph more compact horizontally by splitting labels in lines and removing namespaces. Furthermore it adds following information: - Operation ID. - SetValueOperation float value. - Optionally, operation node name. Reviewed By: jbakker Differential Revision: https://developer.blender.org/D11720
2021-07-06 16:37:23 +02:00
operation->get_id(),
Compositor: Replace resolution concept by canvas This is a code refactor in preparation of supporting canvas compositing. See {D12466}. No functional changes, all canvases are at (0,0) position matching tiled implementation. Differential Revision: https://developer.blender.org/D12465
2021-09-28 19:32:49 +02:00
operation->get_canvas().xmin,
operation->get_canvas().ymin,
Cleanup: convert camelCase naming to snake_case in Compositor To convert old code to the current convention and use a single code style.
2021-10-13 23:01:15 +02:00
operation->get_width(),
operation->get_height());
ClangFormat: apply to source, most of intern Apply clang format as proposed in T53211. For details on usage and instructions for migrating branches without conflicts, see: https://wiki.blender.org/wiki/Tools/ClangFormat
2019-04-17 06:17:24 +02:00
Cleanup: convert camelCase naming to snake_case in Compositor To convert old code to the current convention and use a single code style.
2021-10-13 23:01:15 +02:00
int totoutputs = operation->get_number_of_output_sockets();
Cleanup and improvements of the compositor debug output. Debug code for graphviz output moved to a dedicated file COM_Debug.h/cpp. The DebugInfo class has only static functions, which are called from a number of places to keep track of what is happening in the compositor. If debugging is disabled these are just inline stubs, so we don't need #ifdefs everywhere and don't get any overhead. The graphviz output is much more useful now. DebugInfo keeps track of node names in a static string map for meaningful names. It uses a number of colors for various special operation classes. ExecutionGroups are indicated in graphviz with clusters. Currently the graphviz .dot files are stored in the BLI_temporary_dir() folder. A separate dot file is generated for each stage of the ExecutionGroup scheduling, this is intended to give some idea of the compositor progress, but could still be improved.
2013-09-13 13:36:47 +00:00
if (totoutputs != 0) {
style cleanup
2013-09-18 23:08:23 +00:00
len += snprintf(str + len, maxlen > len ? maxlen - len : 0, "|");
len += snprintf(str + len, maxlen > len ? maxlen - len : 0, "{");
Cleanup and improvements of the compositor debug output. Debug code for graphviz output moved to a dedicated file COM_Debug.h/cpp. The DebugInfo class has only static functions, which are called from a number of places to keep track of what is happening in the compositor. If debugging is disabled these are just inline stubs, so we don't need #ifdefs everywhere and don't get any overhead. The graphviz output is much more useful now. DebugInfo keeps track of node names in a static string map for meaningful names. It uses a number of colors for various special operation classes. ExecutionGroups are indicated in graphviz with clusters. Currently the graphviz .dot files are stored in the BLI_temporary_dir() folder. A separate dot file is generated for each stage of the ExecutionGroup scheduling, this is intended to give some idea of the compositor progress, but could still be improved.
2013-09-13 13:36:47 +00:00
for (int k = 0; k < totoutputs; k++) {
Cleanup: convert camelCase naming to snake_case in Compositor To convert old code to the current convention and use a single code style.
2021-10-13 23:01:15 +02:00
NodeOperationOutput *socket = operation->get_output_socket(k);
Cleanup and improvements of the compositor debug output. Debug code for graphviz output moved to a dedicated file COM_Debug.h/cpp. The DebugInfo class has only static functions, which are called from a number of places to keep track of what is happening in the compositor. If debugging is disabled these are just inline stubs, so we don't need #ifdefs everywhere and don't get any overhead. The graphviz output is much more useful now. DebugInfo keeps track of node names in a static string map for meaningful names. It uses a number of colors for various special operation classes. ExecutionGroups are indicated in graphviz with clusters. Currently the graphviz .dot files are stored in the BLI_temporary_dir() folder. A separate dot file is generated for each stage of the ExecutionGroup scheduling, this is intended to give some idea of the compositor progress, but could still be improved.
2013-09-13 13:36:47 +00:00
if (k != 0) {
style cleanup
2013-09-18 23:08:23 +00:00
len += snprintf(str + len, maxlen > len ? maxlen - len : 0, "|");
Cleanup and improvements of the compositor debug output. Debug code for graphviz output moved to a dedicated file COM_Debug.h/cpp. The DebugInfo class has only static functions, which are called from a number of places to keep track of what is happening in the compositor. If debugging is disabled these are just inline stubs, so we don't need #ifdefs everywhere and don't get any overhead. The graphviz output is much more useful now. DebugInfo keeps track of node names in a static string map for meaningful names. It uses a number of colors for various special operation classes. ExecutionGroups are indicated in graphviz with clusters. Currently the graphviz .dot files are stored in the BLI_temporary_dir() folder. A separate dot file is generated for each stage of the ExecutionGroup scheduling, this is intended to give some idea of the compositor progress, but could still be improved.
2013-09-13 13:36:47 +00:00
}
style cleanup
2013-09-18 23:08:23 +00:00
len += snprintf(str + len, maxlen > len ? maxlen - len : 0, "<OUT_%p>", socket);
Cleanup: convert camelCase naming to snake_case in Compositor To convert old code to the current convention and use a single code style.
2021-10-13 23:01:15 +02:00
switch (socket->get_data_type()) {
Compositor: Full frame input nodes Adds full frame implementation to "Bokeh Image" node, "Track Position" node, `SetVectorOperation` and `MovieClipAttribute`. The other nodes in "Input" submenu are implemented separately. `MovieClipAttribute` needs resolution to calculate its constant value, it can't be constant folded, which requires it to be a `ConstantOperation`. Now `ConstantOperation` contemplate this case and any operation that is always constant without depending on inputs should implement it. If in the future an operation needs to get an input constant element during `determineResolution` it must first determine its input resolution. The nodes have no functional changes. Reviewed By: jbakker Differential Revision: https://developer.blender.org/D12090
2021-08-10 15:24:28 +02:00
case DataType::Value: {
ConstantOperation *constant = operation->get_flags().is_constant_operation ?
static_cast<ConstantOperation *>(operation) :
nullptr;
if (constant && constant->can_get_constant_elem()) {
const float value = *constant->get_constant_elem();
Compositor: Graphviz improvements Graphs are usually large, needing a lot of horizontal scrolling and they can include more information for debugging. This patch makes graph more compact horizontally by splitting labels in lines and removing namespaces. Furthermore it adds following information: - Operation ID. - SetValueOperation float value. - Optionally, operation node name. Reviewed By: jbakker Differential Revision: https://developer.blender.org/D11720
2021-07-06 16:37:23 +02:00
len += snprintf(str + len, maxlen > len ? maxlen - len : 0, "Value\\n%12.4g", value);
}
else {
len += snprintf(str + len, maxlen > len ? maxlen - len : 0, "Value");
}
Cleanup and improvements of the compositor debug output. Debug code for graphviz output moved to a dedicated file COM_Debug.h/cpp. The DebugInfo class has only static functions, which are called from a number of places to keep track of what is happening in the compositor. If debugging is disabled these are just inline stubs, so we don't need #ifdefs everywhere and don't get any overhead. The graphviz output is much more useful now. DebugInfo keeps track of node names in a static string map for meaningful names. It uses a number of colors for various special operation classes. ExecutionGroups are indicated in graphviz with clusters. Currently the graphviz .dot files are stored in the BLI_temporary_dir() folder. A separate dot file is generated for each stage of the ExecutionGroup scheduling, this is intended to give some idea of the compositor progress, but could still be improved.
2013-09-13 13:36:47 +00:00
break;
Compositor: Full frame input nodes Adds full frame implementation to "Bokeh Image" node, "Track Position" node, `SetVectorOperation` and `MovieClipAttribute`. The other nodes in "Input" submenu are implemented separately. `MovieClipAttribute` needs resolution to calculate its constant value, it can't be constant folded, which requires it to be a `ConstantOperation`. Now `ConstantOperation` contemplate this case and any operation that is always constant without depending on inputs should implement it. If in the future an operation needs to get an input constant element during `determineResolution` it must first determine its input resolution. The nodes have no functional changes. Reviewed By: jbakker Differential Revision: https://developer.blender.org/D12090
2021-08-10 15:24:28 +02:00
}
case DataType::Vector: {
style cleanup
2013-09-18 23:08:23 +00:00
len += snprintf(str + len, maxlen > len ? maxlen - len : 0, "Vector");
Cleanup and improvements of the compositor debug output. Debug code for graphviz output moved to a dedicated file COM_Debug.h/cpp. The DebugInfo class has only static functions, which are called from a number of places to keep track of what is happening in the compositor. If debugging is disabled these are just inline stubs, so we don't need #ifdefs everywhere and don't get any overhead. The graphviz output is much more useful now. DebugInfo keeps track of node names in a static string map for meaningful names. It uses a number of colors for various special operation classes. ExecutionGroups are indicated in graphviz with clusters. Currently the graphviz .dot files are stored in the BLI_temporary_dir() folder. A separate dot file is generated for each stage of the ExecutionGroup scheduling, this is intended to give some idea of the compositor progress, but could still be improved.
2013-09-13 13:36:47 +00:00
break;
Compositor: Full frame input nodes Adds full frame implementation to "Bokeh Image" node, "Track Position" node, `SetVectorOperation` and `MovieClipAttribute`. The other nodes in "Input" submenu are implemented separately. `MovieClipAttribute` needs resolution to calculate its constant value, it can't be constant folded, which requires it to be a `ConstantOperation`. Now `ConstantOperation` contemplate this case and any operation that is always constant without depending on inputs should implement it. If in the future an operation needs to get an input constant element during `determineResolution` it must first determine its input resolution. The nodes have no functional changes. Reviewed By: jbakker Differential Revision: https://developer.blender.org/D12090
2021-08-10 15:24:28 +02:00
}
case DataType::Color: {
style cleanup
2013-09-18 23:08:23 +00:00
len += snprintf(str + len, maxlen > len ? maxlen - len : 0, "Color");
Cleanup and improvements of the compositor debug output. Debug code for graphviz output moved to a dedicated file COM_Debug.h/cpp. The DebugInfo class has only static functions, which are called from a number of places to keep track of what is happening in the compositor. If debugging is disabled these are just inline stubs, so we don't need #ifdefs everywhere and don't get any overhead. The graphviz output is much more useful now. DebugInfo keeps track of node names in a static string map for meaningful names. It uses a number of colors for various special operation classes. ExecutionGroups are indicated in graphviz with clusters. Currently the graphviz .dot files are stored in the BLI_temporary_dir() folder. A separate dot file is generated for each stage of the ExecutionGroup scheduling, this is intended to give some idea of the compositor progress, but could still be improved.
2013-09-13 13:36:47 +00:00
break;
Compositor: Full frame input nodes Adds full frame implementation to "Bokeh Image" node, "Track Position" node, `SetVectorOperation` and `MovieClipAttribute`. The other nodes in "Input" submenu are implemented separately. `MovieClipAttribute` needs resolution to calculate its constant value, it can't be constant folded, which requires it to be a `ConstantOperation`. Now `ConstantOperation` contemplate this case and any operation that is always constant without depending on inputs should implement it. If in the future an operation needs to get an input constant element during `determineResolution` it must first determine its input resolution. The nodes have no functional changes. Reviewed By: jbakker Differential Revision: https://developer.blender.org/D12090
2021-08-10 15:24:28 +02:00
}
Cleanup and improvements of the compositor debug output. Debug code for graphviz output moved to a dedicated file COM_Debug.h/cpp. The DebugInfo class has only static functions, which are called from a number of places to keep track of what is happening in the compositor. If debugging is disabled these are just inline stubs, so we don't need #ifdefs everywhere and don't get any overhead. The graphviz output is much more useful now. DebugInfo keeps track of node names in a static string map for meaningful names. It uses a number of colors for various special operation classes. ExecutionGroups are indicated in graphviz with clusters. Currently the graphviz .dot files are stored in the BLI_temporary_dir() folder. A separate dot file is generated for each stage of the ExecutionGroup scheduling, this is intended to give some idea of the compositor progress, but could still be improved.
2013-09-13 13:36:47 +00:00
}
ClangFormat: apply to source, most of intern Apply clang format as proposed in T53211. For details on usage and instructions for migrating branches without conflicts, see: https://wiki.blender.org/wiki/Tools/ClangFormat
2019-04-17 06:17:24 +02:00
}
style cleanup
2013-09-18 23:08:23 +00:00
len += snprintf(str + len, maxlen > len ? maxlen - len : 0, "}");
Cleanup and improvements of the compositor debug output. Debug code for graphviz output moved to a dedicated file COM_Debug.h/cpp. The DebugInfo class has only static functions, which are called from a number of places to keep track of what is happening in the compositor. If debugging is disabled these are just inline stubs, so we don't need #ifdefs everywhere and don't get any overhead. The graphviz output is much more useful now. DebugInfo keeps track of node names in a static string map for meaningful names. It uses a number of colors for various special operation classes. ExecutionGroups are indicated in graphviz with clusters. Currently the graphviz .dot files are stored in the BLI_temporary_dir() folder. A separate dot file is generated for each stage of the ExecutionGroup scheduling, this is intended to give some idea of the compositor progress, but could still be improved.
2013-09-13 13:36:47 +00:00
}
style cleanup
2013-09-18 23:08:23 +00:00
len += snprintf(str + len, maxlen > len ? maxlen - len : 0, "}\"]");
len += snprintf(str + len, maxlen > len ? maxlen - len : 0, "\r\n");
ClangFormat: apply to source, most of intern Apply clang format as proposed in T53211. For details on usage and instructions for migrating branches without conflicts, see: https://wiki.blender.org/wiki/Tools/ClangFormat
2019-04-17 06:17:24 +02:00
Cleanup and improvements of the compositor debug output. Debug code for graphviz output moved to a dedicated file COM_Debug.h/cpp. The DebugInfo class has only static functions, which are called from a number of places to keep track of what is happening in the compositor. If debugging is disabled these are just inline stubs, so we don't need #ifdefs everywhere and don't get any overhead. The graphviz output is much more useful now. DebugInfo keeps track of node names in a static string map for meaningful names. It uses a number of colors for various special operation classes. ExecutionGroups are indicated in graphviz with clusters. Currently the graphviz .dot files are stored in the BLI_temporary_dir() folder. A separate dot file is generated for each stage of the ExecutionGroup scheduling, this is intended to give some idea of the compositor progress, but could still be improved.
2013-09-13 13:36:47 +00:00
return len;
}
int DebugInfo::graphviz_legend_color(const char *name, const char *color, char *str, int maxlen)
{
int len = 0;
style cleanup
2013-09-18 23:08:23 +00:00
len += snprintf(str + len,
maxlen > len ? maxlen - len : 0,
"<TR><TD>%s</TD><TD BGCOLOR=\"%s\"></TD></TR>\r\n",
name,
color);
Cleanup and improvements of the compositor debug output. Debug code for graphviz output moved to a dedicated file COM_Debug.h/cpp. The DebugInfo class has only static functions, which are called from a number of places to keep track of what is happening in the compositor. If debugging is disabled these are just inline stubs, so we don't need #ifdefs everywhere and don't get any overhead. The graphviz output is much more useful now. DebugInfo keeps track of node names in a static string map for meaningful names. It uses a number of colors for various special operation classes. ExecutionGroups are indicated in graphviz with clusters. Currently the graphviz .dot files are stored in the BLI_temporary_dir() folder. A separate dot file is generated for each stage of the ExecutionGroup scheduling, this is intended to give some idea of the compositor progress, but could still be improved.
2013-09-13 13:36:47 +00:00
return len;
}
Compositor: Code cleanup, debug mode is now fine with strict flags
2015-03-27 16:47:11 +05:00
int DebugInfo::graphviz_legend_line(
const char * /*name*/, const char * /*color*/, const char * /*style*/, char *str, int maxlen)
Cleanup and improvements of the compositor debug output. Debug code for graphviz output moved to a dedicated file COM_Debug.h/cpp. The DebugInfo class has only static functions, which are called from a number of places to keep track of what is happening in the compositor. If debugging is disabled these are just inline stubs, so we don't need #ifdefs everywhere and don't get any overhead. The graphviz output is much more useful now. DebugInfo keeps track of node names in a static string map for meaningful names. It uses a number of colors for various special operation classes. ExecutionGroups are indicated in graphviz with clusters. Currently the graphviz .dot files are stored in the BLI_temporary_dir() folder. A separate dot file is generated for each stage of the ExecutionGroup scheduling, this is intended to give some idea of the compositor progress, but could still be improved.
2013-09-13 13:36:47 +00:00
{
/* XXX TODO */
int len = 0;
style cleanup
2013-09-18 23:08:23 +00:00
len += snprintf(str + len, maxlen > len ? maxlen - len : 0, "\r\n");
Cleanup and improvements of the compositor debug output. Debug code for graphviz output moved to a dedicated file COM_Debug.h/cpp. The DebugInfo class has only static functions, which are called from a number of places to keep track of what is happening in the compositor. If debugging is disabled these are just inline stubs, so we don't need #ifdefs everywhere and don't get any overhead. The graphviz output is much more useful now. DebugInfo keeps track of node names in a static string map for meaningful names. It uses a number of colors for various special operation classes. ExecutionGroups are indicated in graphviz with clusters. Currently the graphviz .dot files are stored in the BLI_temporary_dir() folder. A separate dot file is generated for each stage of the ExecutionGroup scheduling, this is intended to give some idea of the compositor progress, but could still be improved.
2013-09-13 13:36:47 +00:00
return len;
}
Compositor: Code cleanup, debug mode is now fine with strict flags
2015-03-27 16:47:11 +05:00
int DebugInfo::graphviz_legend_group(
const char *name, const char *color, const char * /*style*/, char *str, int maxlen)
Cleanup and improvements of the compositor debug output. Debug code for graphviz output moved to a dedicated file COM_Debug.h/cpp. The DebugInfo class has only static functions, which are called from a number of places to keep track of what is happening in the compositor. If debugging is disabled these are just inline stubs, so we don't need #ifdefs everywhere and don't get any overhead. The graphviz output is much more useful now. DebugInfo keeps track of node names in a static string map for meaningful names. It uses a number of colors for various special operation classes. ExecutionGroups are indicated in graphviz with clusters. Currently the graphviz .dot files are stored in the BLI_temporary_dir() folder. A separate dot file is generated for each stage of the ExecutionGroup scheduling, this is intended to give some idea of the compositor progress, but could still be improved.
2013-09-13 13:36:47 +00:00
{
int len = 0;
style cleanup
2013-09-18 23:08:23 +00:00
len += snprintf(str + len,
maxlen > len ? maxlen - len : 0,
"<TR><TD>%s</TD><TD CELLPADDING=\"4\"><TABLE BORDER=\"1\" CELLBORDER=\"0\" "
"CELLSPACING=\"0\" CELLPADDING=\"0\"><TR><TD "
"BGCOLOR=\"%s\"></TD></TR></TABLE></TD></TR>\r\n",
name,
color);
Cleanup and improvements of the compositor debug output. Debug code for graphviz output moved to a dedicated file COM_Debug.h/cpp. The DebugInfo class has only static functions, which are called from a number of places to keep track of what is happening in the compositor. If debugging is disabled these are just inline stubs, so we don't need #ifdefs everywhere and don't get any overhead. The graphviz output is much more useful now. DebugInfo keeps track of node names in a static string map for meaningful names. It uses a number of colors for various special operation classes. ExecutionGroups are indicated in graphviz with clusters. Currently the graphviz .dot files are stored in the BLI_temporary_dir() folder. A separate dot file is generated for each stage of the ExecutionGroup scheduling, this is intended to give some idea of the compositor progress, but could still be improved.
2013-09-13 13:36:47 +00:00
return len;
}
Compositor: Full-frame base system This patch adds the base code needed to make the full-frame system work for both current tiled/per-pixel implementation of operations and full-frame. Two execution models: - Tiled: Current implementation. Renders execution groups in tiles from outputs to input. Not all operations are buffered. Runs the tiled/per-pixel implementation. - FullFrame: All operations are buffered. Fully renders operations from inputs to outputs. Runs full-frame implementation of operations if available otherwise the current tiled/per-pixel. Creates output buffers on first read and free them as soon as all its readers have finished, reducing peak memory usage of complex/long trees. Operations are multi-threaded but do not run in parallel as Tiled (will be done in another patch). This should allow us to convert operations to full-frame in small steps with the system already working and solve the problem of high memory usage. FullFrame breaking changes respect Tiled system, mainly: - Translate, Rotate, Scale, and Transform take effect immediately instead of next buffered operation. - Any sampling is always done over inputs instead of last buffered operation. Reviewed By: jbakker Differential Revision: https://developer.blender.org/D11113
2021-06-01 10:25:38 +02:00
int DebugInfo::graphviz_legend(char *str, int maxlen, const bool has_execution_groups)
Cleanup and improvements of the compositor debug output. Debug code for graphviz output moved to a dedicated file COM_Debug.h/cpp. The DebugInfo class has only static functions, which are called from a number of places to keep track of what is happening in the compositor. If debugging is disabled these are just inline stubs, so we don't need #ifdefs everywhere and don't get any overhead. The graphviz output is much more useful now. DebugInfo keeps track of node names in a static string map for meaningful names. It uses a number of colors for various special operation classes. ExecutionGroups are indicated in graphviz with clusters. Currently the graphviz .dot files are stored in the BLI_temporary_dir() folder. A separate dot file is generated for each stage of the ExecutionGroup scheduling, this is intended to give some idea of the compositor progress, but could still be improved.
2013-09-13 13:36:47 +00:00
{
int len = 0;
ClangFormat: apply to source, most of intern Apply clang format as proposed in T53211. For details on usage and instructions for migrating branches without conflicts, see: https://wiki.blender.org/wiki/Tools/ClangFormat
2019-04-17 06:17:24 +02:00
style cleanup
2013-09-18 23:08:23 +00:00
len += snprintf(str + len, maxlen > len ? maxlen - len : 0, "{\r\n");
Compositor: Full-frame base system This patch adds the base code needed to make the full-frame system work for both current tiled/per-pixel implementation of operations and full-frame. Two execution models: - Tiled: Current implementation. Renders execution groups in tiles from outputs to input. Not all operations are buffered. Runs the tiled/per-pixel implementation. - FullFrame: All operations are buffered. Fully renders operations from inputs to outputs. Runs full-frame implementation of operations if available otherwise the current tiled/per-pixel. Creates output buffers on first read and free them as soon as all its readers have finished, reducing peak memory usage of complex/long trees. Operations are multi-threaded but do not run in parallel as Tiled (will be done in another patch). This should allow us to convert operations to full-frame in small steps with the system already working and solve the problem of high memory usage. FullFrame breaking changes respect Tiled system, mainly: - Translate, Rotate, Scale, and Transform take effect immediately instead of next buffered operation. - Any sampling is always done over inputs instead of last buffered operation. Reviewed By: jbakker Differential Revision: https://developer.blender.org/D11113
2021-06-01 10:25:38 +02:00
if (has_execution_groups) {
len += snprintf(str + len, maxlen > len ? maxlen - len : 0, "rank = sink;\r\n");
}
style cleanup
2013-09-18 23:08:23 +00:00
len += snprintf(
str + len, maxlen > len ? maxlen - len : 0, "Legend [shape=none, margin=0, label=<\r\n");
ClangFormat: apply to source, most of intern Apply clang format as proposed in T53211. For details on usage and instructions for migrating branches without conflicts, see: https://wiki.blender.org/wiki/Tools/ClangFormat
2019-04-17 06:17:24 +02:00
style cleanup
2013-09-18 23:08:23 +00:00
len += snprintf(
str + len,
maxlen > len ? maxlen - len : 0,
" <TABLE BORDER=\"0\" CELLBORDER=\"1\" CELLSPACING=\"0\" CELLPADDING=\"4\">\r\n");
len += snprintf(str + len,
maxlen > len ? maxlen - len : 0,
"<TR><TD COLSPAN=\"2\"><B>Legend</B></TD></TR>\r\n");
ClangFormat: apply to source, most of intern Apply clang format as proposed in T53211. For details on usage and instructions for migrating branches without conflicts, see: https://wiki.blender.org/wiki/Tools/ClangFormat
2019-04-17 06:17:24 +02:00
Structural cleanup and improvements for the compositor. Many parts of the compositor are unnecessarily complicated. This patch aims at reducing the complexity of writing nodes and making the code more transparent. == Separating Nodes and Operations == Currently these are both mixed in the same graph, even though they have very different purposes and are used at distinct stages in the compositing process. The patch introduces dedicated graph classes for nodes and for operations. This removes the need for a lot of special case checks (isOperation etc.) and explicit type casts. It simplifies the code since it becomes clear at every stage what type of node we are dealing with. The compiler can use static typing to avoid common bugs from mixing up these types and fewer runtime sanity checks are needed. == Simplified Node Conversion == Converting nodes to operations was previously based on "relinking", i.e. nodes would start with by mirroring links in the Blender DNA node trees, then add operations and redirect these links to them. This was very hard to follow in many cases and required a lot of attention to avoid invalid states. Now there is a helper class called the NodeConverter, which is passed to nodes and implements a much simpler API for this process. Nodes can add operations and explicit connections as before, but defining "external" links to the inputs/outputs of the original node now uses mapping instead of directly modifying link data. Input data (node graph) and result (operations graph) are cleanly separated. == Removed Redundant Data Structures == A few redundant data structures have been removed, notably the SocketConnection. These are only needed temporarily during graph construction. For executing the compositor operations it is perfectly sufficient to store only the direct input link pointers. A common pointer indirection is avoided this way (which might also give a little performance improvement). == Avoid virtual recursive functions == Recursive virtual functions are evil. They are very hard to follow during debugging. At least in the parts this patch is concerned with these functions have been replaced by a non-virtual recursive core function (which might then call virtual non-recursive functions if needed). See for example NodeOperationBuilder::group_operations.
2014-04-15 16:06:12 +02:00
len += graphviz_legend_color(
"NodeOperation", "gainsboro", str + len, maxlen > len ? maxlen - len : 0);
style cleanup
2013-09-18 23:08:23 +00:00
len += graphviz_legend_color(
"Output", "dodgerblue1", str + len, maxlen > len ? maxlen - len : 0);
len += graphviz_legend_color(
"Viewer", "lightskyblue3", str + len, maxlen > len ? maxlen - len : 0);
len += graphviz_legend_color(
"Active Viewer", "lightskyblue1", str + len, maxlen > len ? maxlen - len : 0);
Compositor: Full-frame base system This patch adds the base code needed to make the full-frame system work for both current tiled/per-pixel implementation of operations and full-frame. Two execution models: - Tiled: Current implementation. Renders execution groups in tiles from outputs to input. Not all operations are buffered. Runs the tiled/per-pixel implementation. - FullFrame: All operations are buffered. Fully renders operations from inputs to outputs. Runs full-frame implementation of operations if available otherwise the current tiled/per-pixel. Creates output buffers on first read and free them as soon as all its readers have finished, reducing peak memory usage of complex/long trees. Operations are multi-threaded but do not run in parallel as Tiled (will be done in another patch). This should allow us to convert operations to full-frame in small steps with the system already working and solve the problem of high memory usage. FullFrame breaking changes respect Tiled system, mainly: - Translate, Rotate, Scale, and Transform take effect immediately instead of next buffered operation. - Any sampling is always done over inputs instead of last buffered operation. Reviewed By: jbakker Differential Revision: https://developer.blender.org/D11113
2021-06-01 10:25:38 +02:00
if (has_execution_groups) {
len += graphviz_legend_color(
"Write Buffer", "darkorange", str + len, maxlen > len ? maxlen - len : 0);
len += graphviz_legend_color(
"Read Buffer", "darkolivegreen3", str + len, maxlen > len ? maxlen - len : 0);
}
style cleanup
2013-09-18 23:08:23 +00:00
len += graphviz_legend_color(
"Input Value", "khaki1", str + len, maxlen > len ? maxlen - len : 0);
ClangFormat: apply to source, most of intern Apply clang format as proposed in T53211. For details on usage and instructions for migrating branches without conflicts, see: https://wiki.blender.org/wiki/Tools/ClangFormat
2019-04-17 06:17:24 +02:00
Compositor: Full-frame base system This patch adds the base code needed to make the full-frame system work for both current tiled/per-pixel implementation of operations and full-frame. Two execution models: - Tiled: Current implementation. Renders execution groups in tiles from outputs to input. Not all operations are buffered. Runs the tiled/per-pixel implementation. - FullFrame: All operations are buffered. Fully renders operations from inputs to outputs. Runs full-frame implementation of operations if available otherwise the current tiled/per-pixel. Creates output buffers on first read and free them as soon as all its readers have finished, reducing peak memory usage of complex/long trees. Operations are multi-threaded but do not run in parallel as Tiled (will be done in another patch). This should allow us to convert operations to full-frame in small steps with the system already working and solve the problem of high memory usage. FullFrame breaking changes respect Tiled system, mainly: - Translate, Rotate, Scale, and Transform take effect immediately instead of next buffered operation. - Any sampling is always done over inputs instead of last buffered operation. Reviewed By: jbakker Differential Revision: https://developer.blender.org/D11113
2021-06-01 10:25:38 +02:00
if (has_execution_groups) {
len += snprintf(str + len, maxlen > len ? maxlen - len : 0, "<TR><TD></TD></TR>\r\n");
len += graphviz_legend_group(
"Group Waiting", "white", "dashed", str + len, maxlen > len ? maxlen - len : 0);
len += graphviz_legend_group(
"Group Running", "firebrick1", "solid", str + len, maxlen > len ? maxlen - len : 0);
len += graphviz_legend_group(
"Group Finished", "chartreuse4", "solid", str + len, maxlen > len ? maxlen - len : 0);
}
ClangFormat: apply to source, most of intern Apply clang format as proposed in T53211. For details on usage and instructions for migrating branches without conflicts, see: https://wiki.blender.org/wiki/Tools/ClangFormat
2019-04-17 06:17:24 +02:00
style cleanup
2013-09-18 23:08:23 +00:00
len += snprintf(str + len, maxlen > len ? maxlen - len : 0, "</TABLE>\r\n");
len += snprintf(str + len, maxlen > len ? maxlen - len : 0, ">];\r\n");
len += snprintf(str + len, maxlen > len ? maxlen - len : 0, "}\r\n");
ClangFormat: apply to source, most of intern Apply clang format as proposed in T53211. For details on usage and instructions for migrating branches without conflicts, see: https://wiki.blender.org/wiki/Tools/ClangFormat
2019-04-17 06:17:24 +02:00
Cleanup and improvements of the compositor debug output. Debug code for graphviz output moved to a dedicated file COM_Debug.h/cpp. The DebugInfo class has only static functions, which are called from a number of places to keep track of what is happening in the compositor. If debugging is disabled these are just inline stubs, so we don't need #ifdefs everywhere and don't get any overhead. The graphviz output is much more useful now. DebugInfo keeps track of node names in a static string map for meaningful names. It uses a number of colors for various special operation classes. ExecutionGroups are indicated in graphviz with clusters. Currently the graphviz .dot files are stored in the BLI_temporary_dir() folder. A separate dot file is generated for each stage of the ExecutionGroup scheduling, this is intended to give some idea of the compositor progress, but could still be improved.
2013-09-13 13:36:47 +00:00
return len;
}
Structural cleanup and improvements for the compositor. Many parts of the compositor are unnecessarily complicated. This patch aims at reducing the complexity of writing nodes and making the code more transparent. == Separating Nodes and Operations == Currently these are both mixed in the same graph, even though they have very different purposes and are used at distinct stages in the compositing process. The patch introduces dedicated graph classes for nodes and for operations. This removes the need for a lot of special case checks (isOperation etc.) and explicit type casts. It simplifies the code since it becomes clear at every stage what type of node we are dealing with. The compiler can use static typing to avoid common bugs from mixing up these types and fewer runtime sanity checks are needed. == Simplified Node Conversion == Converting nodes to operations was previously based on "relinking", i.e. nodes would start with by mirroring links in the Blender DNA node trees, then add operations and redirect these links to them. This was very hard to follow in many cases and required a lot of attention to avoid invalid states. Now there is a helper class called the NodeConverter, which is passed to nodes and implements a much simpler API for this process. Nodes can add operations and explicit connections as before, but defining "external" links to the inputs/outputs of the original node now uses mapping instead of directly modifying link data. Input data (node graph) and result (operations graph) are cleanly separated. == Removed Redundant Data Structures == A few redundant data structures have been removed, notably the SocketConnection. These are only needed temporarily during graph construction. For executing the compositor operations it is perfectly sufficient to store only the direct input link pointers. A common pointer indirection is avoided this way (which might also give a little performance improvement). == Avoid virtual recursive functions == Recursive virtual functions are evil. They are very hard to follow during debugging. At least in the parts this patch is concerned with these functions have been replaced by a non-virtual recursive core function (which might then call virtual non-recursive functions if needed). See for example NodeOperationBuilder::group_operations.
2014-04-15 16:06:12 +02:00
bool DebugInfo::graphviz_system(const ExecutionSystem *system, char *str, int maxlen)
Cleanup and improvements of the compositor debug output. Debug code for graphviz output moved to a dedicated file COM_Debug.h/cpp. The DebugInfo class has only static functions, which are called from a number of places to keep track of what is happening in the compositor. If debugging is disabled these are just inline stubs, so we don't need #ifdefs everywhere and don't get any overhead. The graphviz output is much more useful now. DebugInfo keeps track of node names in a static string map for meaningful names. It uses a number of colors for various special operation classes. ExecutionGroups are indicated in graphviz with clusters. Currently the graphviz .dot files are stored in the BLI_temporary_dir() folder. A separate dot file is generated for each stage of the ExecutionGroup scheduling, this is intended to give some idea of the compositor progress, but could still be improved.
2013-09-13 13:36:47 +00:00
{
char strbuf[64];
int len = 0;
ClangFormat: apply to source, most of intern Apply clang format as proposed in T53211. For details on usage and instructions for migrating branches without conflicts, see: https://wiki.blender.org/wiki/Tools/ClangFormat
2019-04-17 06:17:24 +02:00
style cleanup
2013-09-18 23:08:23 +00:00
len += snprintf(str + len, maxlen > len ? maxlen - len : 0, "digraph compositorexecution {\r\n");
len += snprintf(str + len, maxlen > len ? maxlen - len : 0, "ranksep=1.5\r\n");
Structural cleanup and improvements for the compositor. Many parts of the compositor are unnecessarily complicated. This patch aims at reducing the complexity of writing nodes and making the code more transparent. == Separating Nodes and Operations == Currently these are both mixed in the same graph, even though they have very different purposes and are used at distinct stages in the compositing process. The patch introduces dedicated graph classes for nodes and for operations. This removes the need for a lot of special case checks (isOperation etc.) and explicit type casts. It simplifies the code since it becomes clear at every stage what type of node we are dealing with. The compiler can use static typing to avoid common bugs from mixing up these types and fewer runtime sanity checks are needed. == Simplified Node Conversion == Converting nodes to operations was previously based on "relinking", i.e. nodes would start with by mirroring links in the Blender DNA node trees, then add operations and redirect these links to them. This was very hard to follow in many cases and required a lot of attention to avoid invalid states. Now there is a helper class called the NodeConverter, which is passed to nodes and implements a much simpler API for this process. Nodes can add operations and explicit connections as before, but defining "external" links to the inputs/outputs of the original node now uses mapping instead of directly modifying link data. Input data (node graph) and result (operations graph) are cleanly separated. == Removed Redundant Data Structures == A few redundant data structures have been removed, notably the SocketConnection. These are only needed temporarily during graph construction. For executing the compositor operations it is perfectly sufficient to store only the direct input link pointers. A common pointer indirection is avoided this way (which might also give a little performance improvement). == Avoid virtual recursive functions == Recursive virtual functions are evil. They are very hard to follow during debugging. At least in the parts this patch is concerned with these functions have been replaced by a non-virtual recursive core function (which might then call virtual non-recursive functions if needed). See for example NodeOperationBuilder::group_operations.
2014-04-15 16:06:12 +02:00
len += snprintf(str + len, maxlen > len ? maxlen - len : 0, "rankdir=LR\r\n");
style cleanup
2013-09-18 23:08:23 +00:00
len += snprintf(str + len, maxlen > len ? maxlen - len : 0, "splines=false\r\n");
ClangFormat: apply to source, most of intern Apply clang format as proposed in T53211. For details on usage and instructions for migrating branches without conflicts, see: https://wiki.blender.org/wiki/Tools/ClangFormat
2019-04-17 06:17:24 +02:00
Cleanup and improvements of the compositor debug output. Debug code for graphviz output moved to a dedicated file COM_Debug.h/cpp. The DebugInfo class has only static functions, which are called from a number of places to keep track of what is happening in the compositor. If debugging is disabled these are just inline stubs, so we don't need #ifdefs everywhere and don't get any overhead. The graphviz output is much more useful now. DebugInfo keeps track of node names in a static string map for meaningful names. It uses a number of colors for various special operation classes. ExecutionGroups are indicated in graphviz with clusters. Currently the graphviz .dot files are stored in the BLI_temporary_dir() folder. A separate dot file is generated for each stage of the ExecutionGroup scheduling, this is intended to give some idea of the compositor progress, but could still be improved.
2013-09-13 13:36:47 +00:00
std::map<NodeOperation *, std::vector<std::string>> op_groups;
Cleanup: Modernize iter.
2021-03-16 13:45:26 +01:00
int index = 0;
Cleanup: replace members `m_` prefix by `_` suffix in Compositor To convert old code to the current convention and use a single code style.
2021-10-13 23:01:04 +02:00
for (const ExecutionGroup *group : system->groups_) {
Cleanup: Modernize iter.
2021-03-16 13:45:26 +01:00
len += snprintf(str + len, maxlen > len ? maxlen - len : 0, "// GROUP: %d\r\n", index);
len += snprintf(str + len, maxlen > len ? maxlen - len : 0, "subgraph cluster_%d{\r\n", index);
Cleanup and improvements of the compositor debug output. Debug code for graphviz output moved to a dedicated file COM_Debug.h/cpp. The DebugInfo class has only static functions, which are called from a number of places to keep track of what is happening in the compositor. If debugging is disabled these are just inline stubs, so we don't need #ifdefs everywhere and don't get any overhead. The graphviz output is much more useful now. DebugInfo keeps track of node names in a static string map for meaningful names. It uses a number of colors for various special operation classes. ExecutionGroups are indicated in graphviz with clusters. Currently the graphviz .dot files are stored in the BLI_temporary_dir() folder. A separate dot file is generated for each stage of the ExecutionGroup scheduling, this is intended to give some idea of the compositor progress, but could still be improved.
2013-09-13 13:36:47 +00:00
/* used as a check for executing group */
Cleanup: replace members `m_` prefix by `_` suffix in Compositor To convert old code to the current convention and use a single code style.
2021-10-13 23:01:04 +02:00
if (group_states_[group] == EG_WAIT) {
style cleanup
2013-09-18 23:08:23 +00:00
len += snprintf(str + len, maxlen > len ? maxlen - len : 0, "style=dashed\r\n");
Cleanup and improvements of the compositor debug output. Debug code for graphviz output moved to a dedicated file COM_Debug.h/cpp. The DebugInfo class has only static functions, which are called from a number of places to keep track of what is happening in the compositor. If debugging is disabled these are just inline stubs, so we don't need #ifdefs everywhere and don't get any overhead. The graphviz output is much more useful now. DebugInfo keeps track of node names in a static string map for meaningful names. It uses a number of colors for various special operation classes. ExecutionGroups are indicated in graphviz with clusters. Currently the graphviz .dot files are stored in the BLI_temporary_dir() folder. A separate dot file is generated for each stage of the ExecutionGroup scheduling, this is intended to give some idea of the compositor progress, but could still be improved.
2013-09-13 13:36:47 +00:00
}
Cleanup: replace members `m_` prefix by `_` suffix in Compositor To convert old code to the current convention and use a single code style.
2021-10-13 23:01:04 +02:00
else if (group_states_[group] == EG_RUNNING) {
style cleanup
2013-09-18 23:08:23 +00:00
len += snprintf(str + len, maxlen > len ? maxlen - len : 0, "style=filled\r\n");
len += snprintf(str + len, maxlen > len ? maxlen - len : 0, "color=black\r\n");
len += snprintf(str + len, maxlen > len ? maxlen - len : 0, "fillcolor=firebrick1\r\n");
Cleanup and improvements of the compositor debug output. Debug code for graphviz output moved to a dedicated file COM_Debug.h/cpp. The DebugInfo class has only static functions, which are called from a number of places to keep track of what is happening in the compositor. If debugging is disabled these are just inline stubs, so we don't need #ifdefs everywhere and don't get any overhead. The graphviz output is much more useful now. DebugInfo keeps track of node names in a static string map for meaningful names. It uses a number of colors for various special operation classes. ExecutionGroups are indicated in graphviz with clusters. Currently the graphviz .dot files are stored in the BLI_temporary_dir() folder. A separate dot file is generated for each stage of the ExecutionGroup scheduling, this is intended to give some idea of the compositor progress, but could still be improved.
2013-09-13 13:36:47 +00:00
}
Cleanup: replace members `m_` prefix by `_` suffix in Compositor To convert old code to the current convention and use a single code style.
2021-10-13 23:01:04 +02:00
else if (group_states_[group] == EG_FINISHED) {
style cleanup
2013-09-18 23:08:23 +00:00
len += snprintf(str + len, maxlen > len ? maxlen - len : 0, "style=filled\r\n");
len += snprintf(str + len, maxlen > len ? maxlen - len : 0, "color=black\r\n");
len += snprintf(str + len, maxlen > len ? maxlen - len : 0, "fillcolor=chartreuse4\r\n");
Cleanup and improvements of the compositor debug output. Debug code for graphviz output moved to a dedicated file COM_Debug.h/cpp. The DebugInfo class has only static functions, which are called from a number of places to keep track of what is happening in the compositor. If debugging is disabled these are just inline stubs, so we don't need #ifdefs everywhere and don't get any overhead. The graphviz output is much more useful now. DebugInfo keeps track of node names in a static string map for meaningful names. It uses a number of colors for various special operation classes. ExecutionGroups are indicated in graphviz with clusters. Currently the graphviz .dot files are stored in the BLI_temporary_dir() folder. A separate dot file is generated for each stage of the ExecutionGroup scheduling, this is intended to give some idea of the compositor progress, but could still be improved.
2013-09-13 13:36:47 +00:00
}
ClangFormat: apply to source, most of intern Apply clang format as proposed in T53211. For details on usage and instructions for migrating branches without conflicts, see: https://wiki.blender.org/wiki/Tools/ClangFormat
2019-04-17 06:17:24 +02:00
Cleanup: replace members `m_` prefix by `_` suffix in Compositor To convert old code to the current convention and use a single code style.
2021-10-13 23:01:04 +02:00
for (NodeOperation *operation : group->operations_) {
ClangFormat: apply to source, most of intern Apply clang format as proposed in T53211. For details on usage and instructions for migrating branches without conflicts, see: https://wiki.blender.org/wiki/Tools/ClangFormat
2019-04-17 06:17:24 +02:00
Cleanup and improvements of the compositor debug output. Debug code for graphviz output moved to a dedicated file COM_Debug.h/cpp. The DebugInfo class has only static functions, which are called from a number of places to keep track of what is happening in the compositor. If debugging is disabled these are just inline stubs, so we don't need #ifdefs everywhere and don't get any overhead. The graphviz output is much more useful now. DebugInfo keeps track of node names in a static string map for meaningful names. It uses a number of colors for various special operation classes. ExecutionGroups are indicated in graphviz with clusters. Currently the graphviz .dot files are stored in the BLI_temporary_dir() folder. A separate dot file is generated for each stage of the ExecutionGroup scheduling, this is intended to give some idea of the compositor progress, but could still be improved.
2013-09-13 13:36:47 +00:00
sprintf(strbuf, "_%p", group);
op_groups[operation].push_back(std::string(strbuf));
ClangFormat: apply to source, most of intern Apply clang format as proposed in T53211. For details on usage and instructions for migrating branches without conflicts, see: https://wiki.blender.org/wiki/Tools/ClangFormat
2019-04-17 06:17:24 +02:00
style cleanup
2013-09-18 23:08:23 +00:00
len += graphviz_operation(
system, operation, group, str + len, maxlen > len ? maxlen - len : 0);
Cleanup and improvements of the compositor debug output. Debug code for graphviz output moved to a dedicated file COM_Debug.h/cpp. The DebugInfo class has only static functions, which are called from a number of places to keep track of what is happening in the compositor. If debugging is disabled these are just inline stubs, so we don't need #ifdefs everywhere and don't get any overhead. The graphviz output is much more useful now. DebugInfo keeps track of node names in a static string map for meaningful names. It uses a number of colors for various special operation classes. ExecutionGroups are indicated in graphviz with clusters. Currently the graphviz .dot files are stored in the BLI_temporary_dir() folder. A separate dot file is generated for each stage of the ExecutionGroup scheduling, this is intended to give some idea of the compositor progress, but could still be improved.
2013-09-13 13:36:47 +00:00
}
ClangFormat: apply to source, most of intern Apply clang format as proposed in T53211. For details on usage and instructions for migrating branches without conflicts, see: https://wiki.blender.org/wiki/Tools/ClangFormat
2019-04-17 06:17:24 +02:00
style cleanup
2013-09-18 23:08:23 +00:00
len += snprintf(str + len, maxlen > len ? maxlen - len : 0, "}\r\n");
Cleanup: Modernize iter.
2021-03-16 13:45:26 +01:00
index++;
Cleanup and improvements of the compositor debug output. Debug code for graphviz output moved to a dedicated file COM_Debug.h/cpp. The DebugInfo class has only static functions, which are called from a number of places to keep track of what is happening in the compositor. If debugging is disabled these are just inline stubs, so we don't need #ifdefs everywhere and don't get any overhead. The graphviz output is much more useful now. DebugInfo keeps track of node names in a static string map for meaningful names. It uses a number of colors for various special operation classes. ExecutionGroups are indicated in graphviz with clusters. Currently the graphviz .dot files are stored in the BLI_temporary_dir() folder. A separate dot file is generated for each stage of the ExecutionGroup scheduling, this is intended to give some idea of the compositor progress, but could still be improved.
2013-09-13 13:36:47 +00:00
}
ClangFormat: apply to source, most of intern Apply clang format as proposed in T53211. For details on usage and instructions for migrating branches without conflicts, see: https://wiki.blender.org/wiki/Tools/ClangFormat
2019-04-17 06:17:24 +02:00
Cleanup and improvements of the compositor debug output. Debug code for graphviz output moved to a dedicated file COM_Debug.h/cpp. The DebugInfo class has only static functions, which are called from a number of places to keep track of what is happening in the compositor. If debugging is disabled these are just inline stubs, so we don't need #ifdefs everywhere and don't get any overhead. The graphviz output is much more useful now. DebugInfo keeps track of node names in a static string map for meaningful names. It uses a number of colors for various special operation classes. ExecutionGroups are indicated in graphviz with clusters. Currently the graphviz .dot files are stored in the BLI_temporary_dir() folder. A separate dot file is generated for each stage of the ExecutionGroup scheduling, this is intended to give some idea of the compositor progress, but could still be improved.
2013-09-13 13:36:47 +00:00
/* operations not included in any group */
Cleanup: replace members `m_` prefix by `_` suffix in Compositor To convert old code to the current convention and use a single code style.
2021-10-13 23:01:04 +02:00
for (NodeOperation *operation : system->operations_) {
Cleanup: style, use braces for compositor
2019-04-23 11:21:22 +10:00
if (op_groups.find(operation) != op_groups.end()) {
Cleanup and improvements of the compositor debug output. Debug code for graphviz output moved to a dedicated file COM_Debug.h/cpp. The DebugInfo class has only static functions, which are called from a number of places to keep track of what is happening in the compositor. If debugging is disabled these are just inline stubs, so we don't need #ifdefs everywhere and don't get any overhead. The graphviz output is much more useful now. DebugInfo keeps track of node names in a static string map for meaningful names. It uses a number of colors for various special operation classes. ExecutionGroups are indicated in graphviz with clusters. Currently the graphviz .dot files are stored in the BLI_temporary_dir() folder. A separate dot file is generated for each stage of the ExecutionGroup scheduling, this is intended to give some idea of the compositor progress, but could still be improved.
2013-09-13 13:36:47 +00:00
continue;
Cleanup: style, use braces for compositor
2019-04-23 11:21:22 +10:00
}
ClangFormat: apply to source, most of intern Apply clang format as proposed in T53211. For details on usage and instructions for migrating branches without conflicts, see: https://wiki.blender.org/wiki/Tools/ClangFormat
2019-04-17 06:17:24 +02:00
Cleanup and improvements of the compositor debug output. Debug code for graphviz output moved to a dedicated file COM_Debug.h/cpp. The DebugInfo class has only static functions, which are called from a number of places to keep track of what is happening in the compositor. If debugging is disabled these are just inline stubs, so we don't need #ifdefs everywhere and don't get any overhead. The graphviz output is much more useful now. DebugInfo keeps track of node names in a static string map for meaningful names. It uses a number of colors for various special operation classes. ExecutionGroups are indicated in graphviz with clusters. Currently the graphviz .dot files are stored in the BLI_temporary_dir() folder. A separate dot file is generated for each stage of the ExecutionGroup scheduling, this is intended to give some idea of the compositor progress, but could still be improved.
2013-09-13 13:36:47 +00:00
op_groups[operation].push_back(std::string(""));
ClangFormat: apply to source, most of intern Apply clang format as proposed in T53211. For details on usage and instructions for migrating branches without conflicts, see: https://wiki.blender.org/wiki/Tools/ClangFormat
2019-04-17 06:17:24 +02:00
Cleanup: fix clang-tidy errors when COM_debug is active.
2021-03-12 14:32:24 +01:00
len += graphviz_operation(
system, operation, nullptr, str + len, maxlen > len ? maxlen - len : 0);
Cleanup and improvements of the compositor debug output. Debug code for graphviz output moved to a dedicated file COM_Debug.h/cpp. The DebugInfo class has only static functions, which are called from a number of places to keep track of what is happening in the compositor. If debugging is disabled these are just inline stubs, so we don't need #ifdefs everywhere and don't get any overhead. The graphviz output is much more useful now. DebugInfo keeps track of node names in a static string map for meaningful names. It uses a number of colors for various special operation classes. ExecutionGroups are indicated in graphviz with clusters. Currently the graphviz .dot files are stored in the BLI_temporary_dir() folder. A separate dot file is generated for each stage of the ExecutionGroup scheduling, this is intended to give some idea of the compositor progress, but could still be improved.
2013-09-13 13:36:47 +00:00
}
ClangFormat: apply to source, most of intern Apply clang format as proposed in T53211. For details on usage and instructions for migrating branches without conflicts, see: https://wiki.blender.org/wiki/Tools/ClangFormat
2019-04-17 06:17:24 +02:00
Cleanup: replace members `m_` prefix by `_` suffix in Compositor To convert old code to the current convention and use a single code style.
2021-10-13 23:01:04 +02:00
for (NodeOperation *operation : system->operations_) {
Cleanup: Replace `is...Operation()` methods with a flag.
2021-03-29 16:54:02 +02:00
if (operation->get_flags().is_read_buffer_operation) {
Cleanup and improvements of the compositor debug output. Debug code for graphviz output moved to a dedicated file COM_Debug.h/cpp. The DebugInfo class has only static functions, which are called from a number of places to keep track of what is happening in the compositor. If debugging is disabled these are just inline stubs, so we don't need #ifdefs everywhere and don't get any overhead. The graphviz output is much more useful now. DebugInfo keeps track of node names in a static string map for meaningful names. It uses a number of colors for various special operation classes. ExecutionGroups are indicated in graphviz with clusters. Currently the graphviz .dot files are stored in the BLI_temporary_dir() folder. A separate dot file is generated for each stage of the ExecutionGroup scheduling, this is intended to give some idea of the compositor progress, but could still be improved.
2013-09-13 13:36:47 +00:00
ReadBufferOperation *read = (ReadBufferOperation *)operation;
Cleanup: convert camelCase naming to snake_case in Compositor To convert old code to the current convention and use a single code style.
2021-10-13 23:01:15 +02:00
WriteBufferOperation *write = read->get_memory_proxy()->get_write_buffer_operation();
Cleanup and improvements of the compositor debug output. Debug code for graphviz output moved to a dedicated file COM_Debug.h/cpp. The DebugInfo class has only static functions, which are called from a number of places to keep track of what is happening in the compositor. If debugging is disabled these are just inline stubs, so we don't need #ifdefs everywhere and don't get any overhead. The graphviz output is much more useful now. DebugInfo keeps track of node names in a static string map for meaningful names. It uses a number of colors for various special operation classes. ExecutionGroups are indicated in graphviz with clusters. Currently the graphviz .dot files are stored in the BLI_temporary_dir() folder. A separate dot file is generated for each stage of the ExecutionGroup scheduling, this is intended to give some idea of the compositor progress, but could still be improved.
2013-09-13 13:36:47 +00:00
std::vector<std::string> &read_groups = op_groups[read];
std::vector<std::string> &write_groups = op_groups[write];
ClangFormat: apply to source, most of intern Apply clang format as proposed in T53211. For details on usage and instructions for migrating branches without conflicts, see: https://wiki.blender.org/wiki/Tools/ClangFormat
2019-04-17 06:17:24 +02:00
Cleanup: use post increment/decrement When the result isn't used, prefer post increment/decrement (already used nearly everywhere in Blender).
2019-09-08 00:12:26 +10:00
for (int k = 0; k < write_groups.size(); k++) {
for (int l = 0; l < read_groups.size(); l++) {
style cleanup
2013-09-18 23:08:23 +00:00
len += snprintf(str + len,
maxlen > len ? maxlen - len : 0,
"\"O_%p%s\" -> \"O_%p%s\" [style=dotted]\r\n",
write,
write_groups[k].c_str(),
read,
read_groups[l].c_str());
ClangFormat: apply to source, most of intern Apply clang format as proposed in T53211. For details on usage and instructions for migrating branches without conflicts, see: https://wiki.blender.org/wiki/Tools/ClangFormat
2019-04-17 06:17:24 +02:00
}
}
Cleanup and improvements of the compositor debug output. Debug code for graphviz output moved to a dedicated file COM_Debug.h/cpp. The DebugInfo class has only static functions, which are called from a number of places to keep track of what is happening in the compositor. If debugging is disabled these are just inline stubs, so we don't need #ifdefs everywhere and don't get any overhead. The graphviz output is much more useful now. DebugInfo keeps track of node names in a static string map for meaningful names. It uses a number of colors for various special operation classes. ExecutionGroups are indicated in graphviz with clusters. Currently the graphviz .dot files are stored in the BLI_temporary_dir() folder. A separate dot file is generated for each stage of the ExecutionGroup scheduling, this is intended to give some idea of the compositor progress, but could still be improved.
2013-09-13 13:36:47 +00:00
}
}
ClangFormat: apply to source, most of intern Apply clang format as proposed in T53211. For details on usage and instructions for migrating branches without conflicts, see: https://wiki.blender.org/wiki/Tools/ClangFormat
2019-04-17 06:17:24 +02:00
Cleanup: replace members `m_` prefix by `_` suffix in Compositor To convert old code to the current convention and use a single code style.
2021-10-13 23:01:04 +02:00
for (NodeOperation *op : system->operations_) {
for (NodeOperationInput &to : op->inputs_) {
Cleanup: convert camelCase naming to snake_case in Compositor To convert old code to the current convention and use a single code style.
2021-10-13 23:01:15 +02:00
NodeOperationOutput *from = to.get_link();
ClangFormat: apply to source, most of intern Apply clang format as proposed in T53211. For details on usage and instructions for migrating branches without conflicts, see: https://wiki.blender.org/wiki/Tools/ClangFormat
2019-04-17 06:17:24 +02:00
Cleanup: style, use braces for compositor
2019-04-23 11:21:22 +10:00
if (!from) {
Structural cleanup and improvements for the compositor. Many parts of the compositor are unnecessarily complicated. This patch aims at reducing the complexity of writing nodes and making the code more transparent. == Separating Nodes and Operations == Currently these are both mixed in the same graph, even though they have very different purposes and are used at distinct stages in the compositing process. The patch introduces dedicated graph classes for nodes and for operations. This removes the need for a lot of special case checks (isOperation etc.) and explicit type casts. It simplifies the code since it becomes clear at every stage what type of node we are dealing with. The compiler can use static typing to avoid common bugs from mixing up these types and fewer runtime sanity checks are needed. == Simplified Node Conversion == Converting nodes to operations was previously based on "relinking", i.e. nodes would start with by mirroring links in the Blender DNA node trees, then add operations and redirect these links to them. This was very hard to follow in many cases and required a lot of attention to avoid invalid states. Now there is a helper class called the NodeConverter, which is passed to nodes and implements a much simpler API for this process. Nodes can add operations and explicit connections as before, but defining "external" links to the inputs/outputs of the original node now uses mapping instead of directly modifying link data. Input data (node graph) and result (operations graph) are cleanly separated. == Removed Redundant Data Structures == A few redundant data structures have been removed, notably the SocketConnection. These are only needed temporarily during graph construction. For executing the compositor operations it is perfectly sufficient to store only the direct input link pointers. A common pointer indirection is avoided this way (which might also give a little performance improvement). == Avoid virtual recursive functions == Recursive virtual functions are evil. They are very hard to follow during debugging. At least in the parts this patch is concerned with these functions have been replaced by a non-virtual recursive core function (which might then call virtual non-recursive functions if needed). See for example NodeOperationBuilder::group_operations.
2014-04-15 16:06:12 +02:00
continue;
Cleanup: style, use braces for compositor
2019-04-23 11:21:22 +10:00
}
ClangFormat: apply to source, most of intern Apply clang format as proposed in T53211. For details on usage and instructions for migrating branches without conflicts, see: https://wiki.blender.org/wiki/Tools/ClangFormat
2019-04-17 06:17:24 +02:00
Structural cleanup and improvements for the compositor. Many parts of the compositor are unnecessarily complicated. This patch aims at reducing the complexity of writing nodes and making the code more transparent. == Separating Nodes and Operations == Currently these are both mixed in the same graph, even though they have very different purposes and are used at distinct stages in the compositing process. The patch introduces dedicated graph classes for nodes and for operations. This removes the need for a lot of special case checks (isOperation etc.) and explicit type casts. It simplifies the code since it becomes clear at every stage what type of node we are dealing with. The compiler can use static typing to avoid common bugs from mixing up these types and fewer runtime sanity checks are needed. == Simplified Node Conversion == Converting nodes to operations was previously based on "relinking", i.e. nodes would start with by mirroring links in the Blender DNA node trees, then add operations and redirect these links to them. This was very hard to follow in many cases and required a lot of attention to avoid invalid states. Now there is a helper class called the NodeConverter, which is passed to nodes and implements a much simpler API for this process. Nodes can add operations and explicit connections as before, but defining "external" links to the inputs/outputs of the original node now uses mapping instead of directly modifying link data. Input data (node graph) and result (operations graph) are cleanly separated. == Removed Redundant Data Structures == A few redundant data structures have been removed, notably the SocketConnection. These are only needed temporarily during graph construction. For executing the compositor operations it is perfectly sufficient to store only the direct input link pointers. A common pointer indirection is avoided this way (which might also give a little performance improvement). == Avoid virtual recursive functions == Recursive virtual functions are evil. They are very hard to follow during debugging. At least in the parts this patch is concerned with these functions have been replaced by a non-virtual recursive core function (which might then call virtual non-recursive functions if needed). See for example NodeOperationBuilder::group_operations.
2014-04-15 16:06:12 +02:00
std::string color;
Cleanup: convert camelCase naming to snake_case in Compositor To convert old code to the current convention and use a single code style.
2021-10-13 23:01:15 +02:00
switch (from->get_data_type()) {
Cleanup: Use enum class for DataType.
2021-03-19 14:26:24 +01:00
case DataType::Value:
Cleanup: spelling grey -> gray
2015-03-19 14:14:48 +11:00
color = "gray";
Cleanup and improvements of the compositor debug output. Debug code for graphviz output moved to a dedicated file COM_Debug.h/cpp. The DebugInfo class has only static functions, which are called from a number of places to keep track of what is happening in the compositor. If debugging is disabled these are just inline stubs, so we don't need #ifdefs everywhere and don't get any overhead. The graphviz output is much more useful now. DebugInfo keeps track of node names in a static string map for meaningful names. It uses a number of colors for various special operation classes. ExecutionGroups are indicated in graphviz with clusters. Currently the graphviz .dot files are stored in the BLI_temporary_dir() folder. A separate dot file is generated for each stage of the ExecutionGroup scheduling, this is intended to give some idea of the compositor progress, but could still be improved.
2013-09-13 13:36:47 +00:00
break;
Cleanup: Use enum class for DataType.
2021-03-19 14:26:24 +01:00
case DataType::Vector:
Cleanup and improvements of the compositor debug output. Debug code for graphviz output moved to a dedicated file COM_Debug.h/cpp. The DebugInfo class has only static functions, which are called from a number of places to keep track of what is happening in the compositor. If debugging is disabled these are just inline stubs, so we don't need #ifdefs everywhere and don't get any overhead. The graphviz output is much more useful now. DebugInfo keeps track of node names in a static string map for meaningful names. It uses a number of colors for various special operation classes. ExecutionGroups are indicated in graphviz with clusters. Currently the graphviz .dot files are stored in the BLI_temporary_dir() folder. A separate dot file is generated for each stage of the ExecutionGroup scheduling, this is intended to give some idea of the compositor progress, but could still be improved.
2013-09-13 13:36:47 +00:00
color = "blue";
break;
Cleanup: Use enum class for DataType.
2021-03-19 14:26:24 +01:00
case DataType::Color:
Cleanup and improvements of the compositor debug output. Debug code for graphviz output moved to a dedicated file COM_Debug.h/cpp. The DebugInfo class has only static functions, which are called from a number of places to keep track of what is happening in the compositor. If debugging is disabled these are just inline stubs, so we don't need #ifdefs everywhere and don't get any overhead. The graphviz output is much more useful now. DebugInfo keeps track of node names in a static string map for meaningful names. It uses a number of colors for various special operation classes. ExecutionGroups are indicated in graphviz with clusters. Currently the graphviz .dot files are stored in the BLI_temporary_dir() folder. A separate dot file is generated for each stage of the ExecutionGroup scheduling, this is intended to give some idea of the compositor progress, but could still be improved.
2013-09-13 13:36:47 +00:00
color = "orange";
break;
}
ClangFormat: apply to source, most of intern Apply clang format as proposed in T53211. For details on usage and instructions for migrating branches without conflicts, see: https://wiki.blender.org/wiki/Tools/ClangFormat
2019-04-17 06:17:24 +02:00
Cleanup: convert camelCase naming to snake_case in Compositor To convert old code to the current convention and use a single code style.
2021-10-13 23:01:15 +02:00
NodeOperation *to_op = &to.get_operation();
NodeOperation *from_op = &from->get_operation();
Cleanup and improvements of the compositor debug output. Debug code for graphviz output moved to a dedicated file COM_Debug.h/cpp. The DebugInfo class has only static functions, which are called from a number of places to keep track of what is happening in the compositor. If debugging is disabled these are just inline stubs, so we don't need #ifdefs everywhere and don't get any overhead. The graphviz output is much more useful now. DebugInfo keeps track of node names in a static string map for meaningful names. It uses a number of colors for various special operation classes. ExecutionGroups are indicated in graphviz with clusters. Currently the graphviz .dot files are stored in the BLI_temporary_dir() folder. A separate dot file is generated for each stage of the ExecutionGroup scheduling, this is intended to give some idea of the compositor progress, but could still be improved.
2013-09-13 13:36:47 +00:00
std::vector<std::string> &from_groups = op_groups[from_op];
std::vector<std::string> &to_groups = op_groups[to_op];
ClangFormat: apply to source, most of intern Apply clang format as proposed in T53211. For details on usage and instructions for migrating branches without conflicts, see: https://wiki.blender.org/wiki/Tools/ClangFormat
2019-04-17 06:17:24 +02:00
Structural cleanup and improvements for the compositor. Many parts of the compositor are unnecessarily complicated. This patch aims at reducing the complexity of writing nodes and making the code more transparent. == Separating Nodes and Operations == Currently these are both mixed in the same graph, even though they have very different purposes and are used at distinct stages in the compositing process. The patch introduces dedicated graph classes for nodes and for operations. This removes the need for a lot of special case checks (isOperation etc.) and explicit type casts. It simplifies the code since it becomes clear at every stage what type of node we are dealing with. The compiler can use static typing to avoid common bugs from mixing up these types and fewer runtime sanity checks are needed. == Simplified Node Conversion == Converting nodes to operations was previously based on "relinking", i.e. nodes would start with by mirroring links in the Blender DNA node trees, then add operations and redirect these links to them. This was very hard to follow in many cases and required a lot of attention to avoid invalid states. Now there is a helper class called the NodeConverter, which is passed to nodes and implements a much simpler API for this process. Nodes can add operations and explicit connections as before, but defining "external" links to the inputs/outputs of the original node now uses mapping instead of directly modifying link data. Input data (node graph) and result (operations graph) are cleanly separated. == Removed Redundant Data Structures == A few redundant data structures have been removed, notably the SocketConnection. These are only needed temporarily during graph construction. For executing the compositor operations it is perfectly sufficient to store only the direct input link pointers. A common pointer indirection is avoided this way (which might also give a little performance improvement). == Avoid virtual recursive functions == Recursive virtual functions are evil. They are very hard to follow during debugging. At least in the parts this patch is concerned with these functions have been replaced by a non-virtual recursive core function (which might then call virtual non-recursive functions if needed). See for example NodeOperationBuilder::group_operations.
2014-04-15 16:06:12 +02:00
len += snprintf(str + len,
maxlen > len ? maxlen - len : 0,
"// CONNECTION: %p.%p -> %p.%p\r\n",
from_op,
from,
to_op,
Fix: Compile Error COM_Debug. We should replace `ifdef COM_Debug` with a constexpr function.
2021-03-30 09:18:40 +02:00
&to);
Cleanup: use post increment/decrement When the result isn't used, prefer post increment/decrement (already used nearly everywhere in Blender).
2019-09-08 00:12:26 +10:00
for (int k = 0; k < from_groups.size(); k++) {
for (int l = 0; l < to_groups.size(); l++) {
Structural cleanup and improvements for the compositor. Many parts of the compositor are unnecessarily complicated. This patch aims at reducing the complexity of writing nodes and making the code more transparent. == Separating Nodes and Operations == Currently these are both mixed in the same graph, even though they have very different purposes and are used at distinct stages in the compositing process. The patch introduces dedicated graph classes for nodes and for operations. This removes the need for a lot of special case checks (isOperation etc.) and explicit type casts. It simplifies the code since it becomes clear at every stage what type of node we are dealing with. The compiler can use static typing to avoid common bugs from mixing up these types and fewer runtime sanity checks are needed. == Simplified Node Conversion == Converting nodes to operations was previously based on "relinking", i.e. nodes would start with by mirroring links in the Blender DNA node trees, then add operations and redirect these links to them. This was very hard to follow in many cases and required a lot of attention to avoid invalid states. Now there is a helper class called the NodeConverter, which is passed to nodes and implements a much simpler API for this process. Nodes can add operations and explicit connections as before, but defining "external" links to the inputs/outputs of the original node now uses mapping instead of directly modifying link data. Input data (node graph) and result (operations graph) are cleanly separated. == Removed Redundant Data Structures == A few redundant data structures have been removed, notably the SocketConnection. These are only needed temporarily during graph construction. For executing the compositor operations it is perfectly sufficient to store only the direct input link pointers. A common pointer indirection is avoided this way (which might also give a little performance improvement). == Avoid virtual recursive functions == Recursive virtual functions are evil. They are very hard to follow during debugging. At least in the parts this patch is concerned with these functions have been replaced by a non-virtual recursive core function (which might then call virtual non-recursive functions if needed). See for example NodeOperationBuilder::group_operations.
2014-04-15 16:06:12 +02:00
len += snprintf(str + len,
maxlen > len ? maxlen - len : 0,
Cleanup: fix clang-tidy errors when COM_debug is active.
2021-03-12 14:32:24 +01:00
R"("O_%p%s":"OUT_%p":e -> "O_%p%s":"IN_%p":w)",
Structural cleanup and improvements for the compositor. Many parts of the compositor are unnecessarily complicated. This patch aims at reducing the complexity of writing nodes and making the code more transparent. == Separating Nodes and Operations == Currently these are both mixed in the same graph, even though they have very different purposes and are used at distinct stages in the compositing process. The patch introduces dedicated graph classes for nodes and for operations. This removes the need for a lot of special case checks (isOperation etc.) and explicit type casts. It simplifies the code since it becomes clear at every stage what type of node we are dealing with. The compiler can use static typing to avoid common bugs from mixing up these types and fewer runtime sanity checks are needed. == Simplified Node Conversion == Converting nodes to operations was previously based on "relinking", i.e. nodes would start with by mirroring links in the Blender DNA node trees, then add operations and redirect these links to them. This was very hard to follow in many cases and required a lot of attention to avoid invalid states. Now there is a helper class called the NodeConverter, which is passed to nodes and implements a much simpler API for this process. Nodes can add operations and explicit connections as before, but defining "external" links to the inputs/outputs of the original node now uses mapping instead of directly modifying link data. Input data (node graph) and result (operations graph) are cleanly separated. == Removed Redundant Data Structures == A few redundant data structures have been removed, notably the SocketConnection. These are only needed temporarily during graph construction. For executing the compositor operations it is perfectly sufficient to store only the direct input link pointers. A common pointer indirection is avoided this way (which might also give a little performance improvement). == Avoid virtual recursive functions == Recursive virtual functions are evil. They are very hard to follow during debugging. At least in the parts this patch is concerned with these functions have been replaced by a non-virtual recursive core function (which might then call virtual non-recursive functions if needed). See for example NodeOperationBuilder::group_operations.
2014-04-15 16:06:12 +02:00
from_op,
from_groups[k].c_str(),
from,
to_op,
to_groups[l].c_str(),
Fix: Compile Error COM_Debug. We should replace `ifdef COM_Debug` with a constexpr function.
2021-03-30 09:18:40 +02:00
&to);
style cleanup
2013-09-18 23:08:23 +00:00
len += snprintf(
str + len, maxlen > len ? maxlen - len : 0, " [color=%s]", color.c_str());
len += snprintf(str + len, maxlen > len ? maxlen - len : 0, "\r\n");
Cleanup and improvements of the compositor debug output. Debug code for graphviz output moved to a dedicated file COM_Debug.h/cpp. The DebugInfo class has only static functions, which are called from a number of places to keep track of what is happening in the compositor. If debugging is disabled these are just inline stubs, so we don't need #ifdefs everywhere and don't get any overhead. The graphviz output is much more useful now. DebugInfo keeps track of node names in a static string map for meaningful names. It uses a number of colors for various special operation classes. ExecutionGroups are indicated in graphviz with clusters. Currently the graphviz .dot files are stored in the BLI_temporary_dir() folder. A separate dot file is generated for each stage of the ExecutionGroup scheduling, this is intended to give some idea of the compositor progress, but could still be improved.
2013-09-13 13:36:47 +00:00
}
}
}
ClangFormat: apply to source, most of intern Apply clang format as proposed in T53211. For details on usage and instructions for migrating branches without conflicts, see: https://wiki.blender.org/wiki/Tools/ClangFormat
2019-04-17 06:17:24 +02:00
}
Cleanup: convert camelCase naming to snake_case in Compositor To convert old code to the current convention and use a single code style.
2021-10-13 23:01:15 +02:00
const bool has_execution_groups = system->get_context().get_execution_model() ==
Compositor: Merge equal operations Some operations can take a lot of time to execute and any duplication should be avoided. This patch implements a compile step that detects operations with the same type, inputs and parameters that produce the same result and merge them. Now operations can generate a hash that represents their output result. They only need to implement `hash_output_params` and hash any parameter that affects the output result. Reviewed By: jbakker Differential Revision: https://developer.blender.org/D12341
2021-09-04 16:59:02 +02:00
eExecutionModel::Tiled &&
Cleanup: replace members `m_` prefix by `_` suffix in Compositor To convert old code to the current convention and use a single code style.
2021-10-13 23:01:04 +02:00
system->groups_.size() > 0;
Compositor: Full-frame base system This patch adds the base code needed to make the full-frame system work for both current tiled/per-pixel implementation of operations and full-frame. Two execution models: - Tiled: Current implementation. Renders execution groups in tiles from outputs to input. Not all operations are buffered. Runs the tiled/per-pixel implementation. - FullFrame: All operations are buffered. Fully renders operations from inputs to outputs. Runs full-frame implementation of operations if available otherwise the current tiled/per-pixel. Creates output buffers on first read and free them as soon as all its readers have finished, reducing peak memory usage of complex/long trees. Operations are multi-threaded but do not run in parallel as Tiled (will be done in another patch). This should allow us to convert operations to full-frame in small steps with the system already working and solve the problem of high memory usage. FullFrame breaking changes respect Tiled system, mainly: - Translate, Rotate, Scale, and Transform take effect immediately instead of next buffered operation. - Any sampling is always done over inputs instead of last buffered operation. Reviewed By: jbakker Differential Revision: https://developer.blender.org/D11113
2021-06-01 10:25:38 +02:00
len += graphviz_legend(str + len, maxlen > len ? maxlen - len : 0, has_execution_groups);
ClangFormat: apply to source, most of intern Apply clang format as proposed in T53211. For details on usage and instructions for migrating branches without conflicts, see: https://wiki.blender.org/wiki/Tools/ClangFormat
2019-04-17 06:17:24 +02:00
style cleanup
2013-09-18 23:08:23 +00:00
len += snprintf(str + len, maxlen > len ? maxlen - len : 0, "}\r\n");
ClangFormat: apply to source, most of intern Apply clang format as proposed in T53211. For details on usage and instructions for migrating branches without conflicts, see: https://wiki.blender.org/wiki/Tools/ClangFormat
2019-04-17 06:17:24 +02:00
Cleanup and improvements of the compositor debug output. Debug code for graphviz output moved to a dedicated file COM_Debug.h/cpp. The DebugInfo class has only static functions, which are called from a number of places to keep track of what is happening in the compositor. If debugging is disabled these are just inline stubs, so we don't need #ifdefs everywhere and don't get any overhead. The graphviz output is much more useful now. DebugInfo keeps track of node names in a static string map for meaningful names. It uses a number of colors for various special operation classes. ExecutionGroups are indicated in graphviz with clusters. Currently the graphviz .dot files are stored in the BLI_temporary_dir() folder. A separate dot file is generated for each stage of the ExecutionGroup scheduling, this is intended to give some idea of the compositor progress, but could still be improved.
2013-09-13 13:36:47 +00:00
return (len < maxlen);
}
Compositor: Constant folding Currently there is no clear way to know if an operation is constant (i.e. when all rendered pixels have same values). Operations may need to get constant input values before rendering to determine their resolution or areas of interest. This is the case of scale, rotate and translate operations. Only "set operations" are known as constant but many more are constant when all their inputs are so. Such cases can be optimized by only rendering one pixel. Current solution for tiled implementation is to get first pixel from input. This works for root execution groups, others need previous groups to be rendered. On full frame implementation this is not possible, because buffers are created on rendering to reduce peak memory and there is no per pixel calls. This patch evaluates all operations that are constant into primitive operations (Value/Vector/Color) before determining resolutions. Reviewed By: jbakker Differential Revision: https://developer.blender.org/D11490
2021-07-06 16:16:08 +02:00
void DebugInfo::graphviz(const ExecutionSystem *system, StringRefNull name)
Cleanup and improvements of the compositor debug output. Debug code for graphviz output moved to a dedicated file COM_Debug.h/cpp. The DebugInfo class has only static functions, which are called from a number of places to keep track of what is happening in the compositor. If debugging is disabled these are just inline stubs, so we don't need #ifdefs everywhere and don't get any overhead. The graphviz output is much more useful now. DebugInfo keeps track of node names in a static string map for meaningful names. It uses a number of colors for various special operation classes. ExecutionGroups are indicated in graphviz with clusters. Currently the graphviz .dot files are stored in the BLI_temporary_dir() folder. A separate dot file is generated for each stage of the ExecutionGroup scheduling, this is intended to give some idea of the compositor progress, but could still be improved.
2013-09-13 13:36:47 +00:00
{
Replace COM_DEBUG #define with constexpr. Fixes T87035 Reviewed By: jbakker Maniphest Tasks: T87035 Differential Revision: https://developer.blender.org/D11068
2021-04-28 07:56:11 +02:00
if (!COM_EXPORT_GRAPHVIZ) {
return;
}
Fix: Large stack allocation in compositor When COM_EXPORT_GRAPHVIZ is enabled, DebugInfo::graphviz uses a char[1000000] as local variable. When this function is called this is allocated on the stack, which has a size of just 1MB on mac and may cause a stack overflow. This patch allocates the memory on the heap and frees the memory at the end of the function. Reviewed By: LazyDodo Differential Revision: https://developer.blender.org/D13628
2021-12-22 13:49:52 -07:00
const int max_textlength = 1000000;
char *str = (char *)MEM_mallocN(max_textlength, __func__);
if (graphviz_system(system, str, max_textlength - 1)) {
Cleanup and improvements of the compositor debug output. Debug code for graphviz output moved to a dedicated file COM_Debug.h/cpp. The DebugInfo class has only static functions, which are called from a number of places to keep track of what is happening in the compositor. If debugging is disabled these are just inline stubs, so we don't need #ifdefs everywhere and don't get any overhead. The graphviz output is much more useful now. DebugInfo keeps track of node names in a static string map for meaningful names. It uses a number of colors for various special operation classes. ExecutionGroups are indicated in graphviz with clusters. Currently the graphviz .dot files are stored in the BLI_temporary_dir() folder. A separate dot file is generated for each stage of the ExecutionGroup scheduling, this is intended to give some idea of the compositor progress, but could still be improved.
2013-09-13 13:36:47 +00:00
char basename[FILE_MAX];
Cleanup: use term 'filepath' for full file paths
2022-05-17 11:38:05 +10:00
char filepath[FILE_MAX];
ClangFormat: apply to source, most of intern Apply clang format as proposed in T53211. For details on usage and instructions for migrating branches without conflicts, see: https://wiki.blender.org/wiki/Tools/ClangFormat
2019-04-17 06:17:24 +02:00
Compositor: Constant folding Currently there is no clear way to know if an operation is constant (i.e. when all rendered pixels have same values). Operations may need to get constant input values before rendering to determine their resolution or areas of interest. This is the case of scale, rotate and translate operations. Only "set operations" are known as constant but many more are constant when all their inputs are so. Such cases can be optimized by only rendering one pixel. Current solution for tiled implementation is to get first pixel from input. This works for root execution groups, others need previous groups to be rendered. On full frame implementation this is not possible, because buffers are created on rendering to reduce peak memory and there is no per pixel calls. This patch evaluates all operations that are constant into primitive operations (Value/Vector/Color) before determining resolutions. Reviewed By: jbakker Differential Revision: https://developer.blender.org/D11490
2021-07-06 16:16:08 +02:00
if (name.is_empty()) {
Cleanup: replace members `m_` prefix by `_` suffix in Compositor To convert old code to the current convention and use a single code style.
2021-10-13 23:01:04 +02:00
BLI_snprintf(basename, sizeof(basename), "compositor_%d.dot", file_index_);
Compositor: Constant folding Currently there is no clear way to know if an operation is constant (i.e. when all rendered pixels have same values). Operations may need to get constant input values before rendering to determine their resolution or areas of interest. This is the case of scale, rotate and translate operations. Only "set operations" are known as constant but many more are constant when all their inputs are so. Such cases can be optimized by only rendering one pixel. Current solution for tiled implementation is to get first pixel from input. This works for root execution groups, others need previous groups to be rendered. On full frame implementation this is not possible, because buffers are created on rendering to reduce peak memory and there is no per pixel calls. This patch evaluates all operations that are constant into primitive operations (Value/Vector/Color) before determining resolutions. Reviewed By: jbakker Differential Revision: https://developer.blender.org/D11490
2021-07-06 16:16:08 +02:00
}
else {
BLI_strncpy(basename, (name + ".dot").c_str(), sizeof(basename));
}
Cleanup: use term 'filepath' for full file paths
2022-05-17 11:38:05 +10:00
BLI_join_dirfile(filepath, sizeof(filepath), BKE_tempdir_session(), basename);
Cleanup: replace members `m_` prefix by `_` suffix in Compositor To convert old code to the current convention and use a single code style.
2021-10-13 23:01:04 +02:00
file_index_++;
ClangFormat: apply to source, most of intern Apply clang format as proposed in T53211. For details on usage and instructions for migrating branches without conflicts, see: https://wiki.blender.org/wiki/Tools/ClangFormat
2019-04-17 06:17:24 +02:00
Cleanup: use term 'filepath' for full file paths
2022-05-17 11:38:05 +10:00
std::cout << "Writing compositor debug to: " << filepath << "\n";
Compositor: Output where debug is stored.
2021-04-09 15:37:09 +02:00
Cleanup: use term 'filepath' for full file paths
2022-05-17 11:38:05 +10:00
FILE *fp = BLI_fopen(filepath, "wb");
Cleanup and improvements of the compositor debug output. Debug code for graphviz output moved to a dedicated file COM_Debug.h/cpp. The DebugInfo class has only static functions, which are called from a number of places to keep track of what is happening in the compositor. If debugging is disabled these are just inline stubs, so we don't need #ifdefs everywhere and don't get any overhead. The graphviz output is much more useful now. DebugInfo keeps track of node names in a static string map for meaningful names. It uses a number of colors for various special operation classes. ExecutionGroups are indicated in graphviz with clusters. Currently the graphviz .dot files are stored in the BLI_temporary_dir() folder. A separate dot file is generated for each stage of the ExecutionGroup scheduling, this is intended to give some idea of the compositor progress, but could still be improved.
2013-09-13 13:36:47 +00:00
fputs(str, fp);
fclose(fp);
}
Fix: Large stack allocation in compositor When COM_EXPORT_GRAPHVIZ is enabled, DebugInfo::graphviz uses a char[1000000] as local variable. When this function is called this is allocated on the stack, which has a size of just 1MB on mac and may cause a stack overflow. This patch allocates the memory on the heap and frees the memory at the end of the function. Reviewed By: LazyDodo Differential Revision: https://developer.blender.org/D13628
2021-12-22 13:49:52 -07:00
MEM_freeN(str);
Cleanup and improvements of the compositor debug output. Debug code for graphviz output moved to a dedicated file COM_Debug.h/cpp. The DebugInfo class has only static functions, which are called from a number of places to keep track of what is happening in the compositor. If debugging is disabled these are just inline stubs, so we don't need #ifdefs everywhere and don't get any overhead. The graphviz output is much more useful now. DebugInfo keeps track of node names in a static string map for meaningful names. It uses a number of colors for various special operation classes. ExecutionGroups are indicated in graphviz with clusters. Currently the graphviz .dot files are stored in the BLI_temporary_dir() folder. A separate dot file is generated for each stage of the ExecutionGroup scheduling, this is intended to give some idea of the compositor progress, but could still be improved.
2013-09-13 13:36:47 +00:00
}
Compositor: Export operation results as debug option When fixing issues, seeing operation results can be helpful for detecting which operation went wrong. This commit adds an option for exporting all operations results to image files. Exceptions are: - Output operations: They are already exported or can be seen in UI. - Constant operations: There are too many and is rarely useful. They are exported to "<temp session folder>/COM_operations/" with filenames "<operation class name>_<operation id>.png". Only works on full frame execution mode. Reviewed By: jbakker Differential Revision: https://developer.blender.org/D11722
2021-07-19 19:55:15 +02:00
static std::string get_operations_export_dir()
{
return std::string(BKE_tempdir_session()) + "COM_operations" + SEP_STR;
}
void DebugInfo::export_operation(const NodeOperation *op, MemoryBuffer *render)
{
Cleanup: convert camelCase naming to snake_case in Compositor To convert old code to the current convention and use a single code style.
2021-10-13 23:01:15 +02:00
const int width = render->get_width();
const int height = render->get_height();
Compositor: Fix crash exporting buffers on debug ImBuf allocates 4 channels, use copying to support buffers with 1 and 3 channels.
2021-09-18 19:04:47 +02:00
const int num_channels = render->get_num_channels();
ImBuf *ibuf = IMB_allocImBuf(width, height, 8 * num_channels, IB_rectfloat);
MemoryBuffer mem_ibuf(ibuf->rect_float, 4, width, height);
mem_ibuf.copy_from(render, render->get_rect(), 0, num_channels, 0);
Compositor: Export operation results as debug option When fixing issues, seeing operation results can be helpful for detecting which operation went wrong. This commit adds an option for exporting all operations results to image files. Exceptions are: - Output operations: They are already exported or can be seen in UI. - Constant operations: There are too many and is rarely useful. They are exported to "<temp session folder>/COM_operations/" with filenames "<operation class name>_<operation id>.png". Only works on full frame execution mode. Reviewed By: jbakker Differential Revision: https://developer.blender.org/D11722
2021-07-19 19:55:15 +02:00
const std::string file_name = operation_class_name(op) + "_" + std::to_string(op->get_id()) +
".png";
const std::string path = get_operations_export_dir() + file_name;
BLI_make_existing_file(path.c_str());
IMB_saveiff(ibuf, path.c_str(), ibuf->flags);
IMB_freeImBuf(ibuf);
}
void DebugInfo::delete_operation_exports()
{
const std::string dir = get_operations_export_dir();
if (BLI_exists(dir.c_str())) {
struct direntry *file_list;
Cleanup: use count or num instead of nbr Follow conventions from T85728.
2022-03-25 12:04:20 +11:00
int file_list_num = BLI_filelist_dir_contents(dir.c_str(), &file_list);
for (int i = 0; i < file_list_num; i++) {
Compositor: Export operation results as debug option When fixing issues, seeing operation results can be helpful for detecting which operation went wrong. This commit adds an option for exporting all operations results to image files. Exceptions are: - Output operations: They are already exported or can be seen in UI. - Constant operations: There are too many and is rarely useful. They are exported to "<temp session folder>/COM_operations/" with filenames "<operation class name>_<operation id>.png". Only works on full frame execution mode. Reviewed By: jbakker Differential Revision: https://developer.blender.org/D11722
2021-07-19 19:55:15 +02:00
direntry *file = &file_list[i];
const eFileAttributes file_attrs = BLI_file_attributes(file->path);
if (file_attrs & FILE_ATTR_ANY_LINK) {
continue;
}
if (BLI_is_file(file->path) && BLI_path_extension_check(file->path, ".png")) {
BLI_delete(file->path, false, false);
}
}
Cleanup: use count or num instead of nbr Follow conventions from T85728.
2022-03-25 12:04:20 +11:00
BLI_filelist_free(file_list, file_list_num);
Compositor: Export operation results as debug option When fixing issues, seeing operation results can be helpful for detecting which operation went wrong. This commit adds an option for exporting all operations results to image files. Exceptions are: - Output operations: They are already exported or can be seen in UI. - Constant operations: There are too many and is rarely useful. They are exported to "<temp session folder>/COM_operations/" with filenames "<operation class name>_<operation id>.png". Only works on full frame execution mode. Reviewed By: jbakker Differential Revision: https://developer.blender.org/D11722
2021-07-19 19:55:15 +02:00
}
}
Cleanup: Add namespace to compositor.
2021-03-23 17:12:27 +01:00
} // namespace blender::compositor
Copy Permalink