griefith/test2
1
0
Fork 0
Code Issues Pull Requests Actions 1 Packages Projects Releases Wiki Activity
Files
2db026ef67bc66f951dc45ccba37544c200e94de
test2/intern/cycles/test/render_graph_finalize_test.cpp

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

1542 lines
51 KiB
C++
Raw Normal View History

License headers: use SPDX-FileCopyrightText in intern/cycles
2023-06-14 16:52:36 +10:00
/* SPDX-FileCopyrightText: 2011-2022 Blender Foundation
*
* SPDX-License-Identifier: Apache-2.0 */
Cycles: Add fundamentals to test constant folding This commit adds some easy to use way to check whether the graph was properly optimized. The idea is based on using mock glog sync which keeps track on all messages and expects specific log message to appear in the logging. This means each optimization step should report that it optimized something (specifying what exactly was optimized) and what was used for optimization. There's also some ease-ish way to define shader networks which we might want to make a bit more global and available for all tests in the future. For now only RGBToBW node is covered as an example, really hope to get help from active guys in the community to finish covering all existing optimization cases. Ready to fix any possible issues with builder when needed tho :)
2016-07-29 18:44:29 +02:00
#include "testing/mock_log.h"
Cleanup: `make format` after SortedIncludes change
2020-03-19 09:33:03 +01:00
#include "testing/testing.h"
Cycles: Add fundamentals to test constant folding This commit adds some easy to use way to check whether the graph was properly optimized. The idea is based on using mock glog sync which keeps track on all messages and expects specific log message to appear in the logging. This means each optimization step should report that it optimized something (specifying what exactly was optimized) and what was used for optimization. There's also some ease-ish way to define shader networks which we might want to make a bit more global and available for all tests in the future. For now only RGBToBW node is covered as an example, really hope to get help from active guys in the community to finish covering all existing optimization cases. Ready to fix any possible issues with builder when needed tho :)
2016-07-29 18:44:29 +02:00
Cleanup: minor refactoring around DeviceTask
2020-06-05 11:39:11 +02:00
#include "device/device.h"
Fix warnings in Cycles graph test output Harmless, but is quite noisy and easy to avoid. Pull Request: https://projects.blender.org/blender/blender/pulls/105985
2023-03-23 09:55:54 +01:00
#include "scene/colorspace.h"
Cycles: changes to source code folders structure * Split render/ into scene/ and session/. The scene/ folder now contains the scene and its nodes. The session/ folder contains the render session and associated data structures like drivers and render buffers. * Move top level kernel headers into new folders kernel/camera/, kernel/film/, kernel/light/, kernel/sample/, kernel/util/ * Move integrator related kernel headers into kernel/integrator/ * Move OSL shaders from kernel/shaders/ to kernel/osl/shaders/ For patches and branches, git merge and rebase should be able to detect the renames and move over code to the right file.
2021-10-24 14:19:19 +02:00
#include "scene/scene.h"
#include "scene/shader_graph.h"
#include "scene/shader_nodes.h"
Cleanup: minor refactoring around DeviceTask
2020-06-05 11:39:11 +02:00
Cycles: remove prefix from source code file names Remove prefix of filenames that is the same as the folder name. This used to help when #includes were using individual files, but now they are always relative to the cycles root directory and so the prefixes are redundant. For patches and branches, git merge and rebase should be able to detect the renames and move over code to the right file.
2021-10-24 14:19:19 +02:00
#include "util/array.h"
#include "util/log.h"
#include "util/stats.h"
#include "util/string.h"
#include "util/vector.h"
Cycles: Add fundamentals to test constant folding This commit adds some easy to use way to check whether the graph was properly optimized. The idea is based on using mock glog sync which keeps track on all messages and expects specific log message to appear in the logging. This means each optimization step should report that it optimized something (specifying what exactly was optimized) and what was used for optimization. There's also some ease-ish way to define shader networks which we might want to make a bit more global and available for all tests in the future. For now only RGBToBW node is covered as an example, really hope to get help from active guys in the community to finish covering all existing optimization cases. Ready to fix any possible issues with builder when needed tho :)
2016-07-29 18:44:29 +02:00
using testing::_;
using testing::AnyNumber;
using testing::HasSubstr;
using testing::ScopedMockLog;
CCL_NAMESPACE_BEGIN
namespace {
template<typename T> class ShaderNodeBuilder {
public:
Cycles: fix missing ShaderNode ownership in render_graph_finalize_test
2020-10-13 15:36:52 +02:00
ShaderNodeBuilder(ShaderGraph &graph, const string &name) : name_(name)
Cycles: Add fundamentals to test constant folding This commit adds some easy to use way to check whether the graph was properly optimized. The idea is based on using mock glog sync which keeps track on all messages and expects specific log message to appear in the logging. This means each optimization step should report that it optimized something (specifying what exactly was optimized) and what was used for optimization. There's also some ease-ish way to define shader networks which we might want to make a bit more global and available for all tests in the future. For now only RGBToBW node is covered as an example, really hope to get help from active guys in the community to finish covering all existing optimization cases. Ready to fix any possible issues with builder when needed tho :)
2016-07-29 18:44:29 +02:00
{
Cycles: fix missing ShaderNode ownership in render_graph_finalize_test
2020-10-13 15:36:52 +02:00
node_ = graph.create_node<T>();
Cycles: add unit tests for supported constant folding rules. Code coverage of different combinations of secondary conditions is obviously not complete because there are so many of them, but all main rules should be there. The reason for CORRECT vs INVALID is that both words have the same number of characters so calls line up, but look quite different. Reviewers: #cycles, sergey Reviewed By: #cycles, sergey Subscribers: dingto, sergey, brecht Differential Revision: https://developer.blender.org/D2130
2016-08-01 18:53:20 +03:00
node_->name = name;
Cycles: Add fundamentals to test constant folding This commit adds some easy to use way to check whether the graph was properly optimized. The idea is based on using mock glog sync which keeps track on all messages and expects specific log message to appear in the logging. This means each optimization step should report that it optimized something (specifying what exactly was optimized) and what was used for optimization. There's also some ease-ish way to define shader networks which we might want to make a bit more global and available for all tests in the future. For now only RGBToBW node is covered as an example, really hope to get help from active guys in the community to finish covering all existing optimization cases. Ready to fix any possible issues with builder when needed tho :)
2016-07-29 18:44:29 +02: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
Cycles: Add fundamentals to test constant folding This commit adds some easy to use way to check whether the graph was properly optimized. The idea is based on using mock glog sync which keeps track on all messages and expects specific log message to appear in the logging. This means each optimization step should report that it optimized something (specifying what exactly was optimized) and what was used for optimization. There's also some ease-ish way to define shader networks which we might want to make a bit more global and available for all tests in the future. For now only RGBToBW node is covered as an example, really hope to get help from active guys in the community to finish covering all existing optimization cases. Ready to fix any possible issues with builder when needed tho :)
2016-07-29 18:44:29 +02:00
const string &name() const
{
return name_;
}
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
Cycles: Add fundamentals to test constant folding This commit adds some easy to use way to check whether the graph was properly optimized. The idea is based on using mock glog sync which keeps track on all messages and expects specific log message to appear in the logging. This means each optimization step should report that it optimized something (specifying what exactly was optimized) and what was used for optimization. There's also some ease-ish way to define shader networks which we might want to make a bit more global and available for all tests in the future. For now only RGBToBW node is covered as an example, really hope to get help from active guys in the community to finish covering all existing optimization cases. Ready to fix any possible issues with builder when needed tho :)
2016-07-29 18:44:29 +02:00
ShaderNode *node() const
{
return node_;
}
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
Cycles: Add fundamentals to test constant folding This commit adds some easy to use way to check whether the graph was properly optimized. The idea is based on using mock glog sync which keeps track on all messages and expects specific log message to appear in the logging. This means each optimization step should report that it optimized something (specifying what exactly was optimized) and what was used for optimization. There's also some ease-ish way to define shader networks which we might want to make a bit more global and available for all tests in the future. For now only RGBToBW node is covered as an example, really hope to get help from active guys in the community to finish covering all existing optimization cases. Ready to fix any possible issues with builder when needed tho :)
2016-07-29 18:44:29 +02:00
template<typename V> ShaderNodeBuilder &set(const string &input_name, V value)
{
ShaderInput *input_socket = node_->input(input_name.c_str());
Refactor: Cycles: Use nullptr instead of NULL Pull Request: https://projects.blender.org/blender/blender/pulls/132361
2024-12-26 17:53:55 +01:00
EXPECT_NE((void *)nullptr, input_socket);
Cycles: Add fundamentals to test constant folding This commit adds some easy to use way to check whether the graph was properly optimized. The idea is based on using mock glog sync which keeps track on all messages and expects specific log message to appear in the logging. This means each optimization step should report that it optimized something (specifying what exactly was optimized) and what was used for optimization. There's also some ease-ish way to define shader networks which we might want to make a bit more global and available for all tests in the future. For now only RGBToBW node is covered as an example, really hope to get help from active guys in the community to finish covering all existing optimization cases. Ready to fix any possible issues with builder when needed tho :)
2016-07-29 18:44:29 +02:00
input_socket->set(value);
return *this;
}
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
Cycles API: encapsulate Node socket members This encapsulates Node socket members behind a set of specific methods; as such it is no longer possible to directly access Node class members from exporters and parts of Cycles. The methods are defined via the NODE_SOCKET_API macros in `graph/ node.h`, and are for getting or setting a specific socket's value, as well as querying or modifying the state of its update flag. The setters will check whether the value has changed and tag the socket as modified appropriately. This will let us know how a Node has changed and what to update, which is the first concrete step toward a more granular scene update system. Since the setters will tag the Node sockets as modified when passed different data, this patch also removes the various modified methods on Nodes in favor of Node::is_modified which checks the sockets' update flags status. Reviewed By: brecht Maniphest Tasks: T79174 Differential Revision: https://developer.blender.org/D8544
2020-11-04 11:17:38 +01:00
template<typename V> ShaderNodeBuilder &set_param(const string &input_name, V value)
Cycles: add unit tests for supported constant folding rules. Code coverage of different combinations of secondary conditions is obviously not complete because there are so many of them, but all main rules should be there. The reason for CORRECT vs INVALID is that both words have the same number of characters so calls line up, but look quite different. Reviewers: #cycles, sergey Reviewed By: #cycles, sergey Subscribers: dingto, sergey, brecht Differential Revision: https://developer.blender.org/D2130
2016-08-01 18:53:20 +03:00
{
Cycles API: encapsulate Node socket members This encapsulates Node socket members behind a set of specific methods; as such it is no longer possible to directly access Node class members from exporters and parts of Cycles. The methods are defined via the NODE_SOCKET_API macros in `graph/ node.h`, and are for getting or setting a specific socket's value, as well as querying or modifying the state of its update flag. The setters will check whether the value has changed and tag the socket as modified appropriately. This will let us know how a Node has changed and what to update, which is the first concrete step toward a more granular scene update system. Since the setters will tag the Node sockets as modified when passed different data, this patch also removes the various modified methods on Nodes in favor of Node::is_modified which checks the sockets' update flags status. Reviewed By: brecht Maniphest Tasks: T79174 Differential Revision: https://developer.blender.org/D8544
2020-11-04 11:17:38 +01:00
const SocketType *input_socket = node_->type->find_input(ustring(input_name.c_str()));
Refactor: Cycles: Use nullptr instead of NULL Pull Request: https://projects.blender.org/blender/blender/pulls/132361
2024-12-26 17:53:55 +01:00
EXPECT_NE((void *)nullptr, input_socket);
Cycles API: encapsulate Node socket members This encapsulates Node socket members behind a set of specific methods; as such it is no longer possible to directly access Node class members from exporters and parts of Cycles. The methods are defined via the NODE_SOCKET_API macros in `graph/ node.h`, and are for getting or setting a specific socket's value, as well as querying or modifying the state of its update flag. The setters will check whether the value has changed and tag the socket as modified appropriately. This will let us know how a Node has changed and what to update, which is the first concrete step toward a more granular scene update system. Since the setters will tag the Node sockets as modified when passed different data, this patch also removes the various modified methods on Nodes in favor of Node::is_modified which checks the sockets' update flags status. Reviewed By: brecht Maniphest Tasks: T79174 Differential Revision: https://developer.blender.org/D8544
2020-11-04 11:17:38 +01:00
node_->set(*input_socket, value);
Cycles: add unit tests for supported constant folding rules. Code coverage of different combinations of secondary conditions is obviously not complete because there are so many of them, but all main rules should be there. The reason for CORRECT vs INVALID is that both words have the same number of characters so calls line up, but look quite different. Reviewers: #cycles, sergey Reviewed By: #cycles, sergey Subscribers: dingto, sergey, brecht Differential Revision: https://developer.blender.org/D2130
2016-08-01 18:53:20 +03:00
return *this;
}
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
Cycles: Add fundamentals to test constant folding This commit adds some easy to use way to check whether the graph was properly optimized. The idea is based on using mock glog sync which keeps track on all messages and expects specific log message to appear in the logging. This means each optimization step should report that it optimized something (specifying what exactly was optimized) and what was used for optimization. There's also some ease-ish way to define shader networks which we might want to make a bit more global and available for all tests in the future. For now only RGBToBW node is covered as an example, really hope to get help from active guys in the community to finish covering all existing optimization cases. Ready to fix any possible issues with builder when needed tho :)
2016-07-29 18:44:29 +02:00
protected:
string name_;
ShaderNode *node_;
};
class ShaderGraphBuilder {
public:
Cycles: Fix memory leak in test and simplify code
2017-10-24 11:12:28 +02:00
ShaderGraphBuilder(ShaderGraph *graph) : graph_(graph)
Cycles: Add fundamentals to test constant folding This commit adds some easy to use way to check whether the graph was properly optimized. The idea is based on using mock glog sync which keeps track on all messages and expects specific log message to appear in the logging. This means each optimization step should report that it optimized something (specifying what exactly was optimized) and what was used for optimization. There's also some ease-ish way to define shader networks which we might want to make a bit more global and available for all tests in the future. For now only RGBToBW node is covered as an example, really hope to get help from active guys in the community to finish covering all existing optimization cases. Ready to fix any possible issues with builder when needed tho :)
2016-07-29 18:44:29 +02:00
{
Cycles: add unit tests for supported constant folding rules. Code coverage of different combinations of secondary conditions is obviously not complete because there are so many of them, but all main rules should be there. The reason for CORRECT vs INVALID is that both words have the same number of characters so calls line up, but look quite different. Reviewers: #cycles, sergey Reviewed By: #cycles, sergey Subscribers: dingto, sergey, brecht Differential Revision: https://developer.blender.org/D2130
2016-08-01 18:53:20 +03:00
node_map_["Output"] = graph->output();
Cycles: Add fundamentals to test constant folding This commit adds some easy to use way to check whether the graph was properly optimized. The idea is based on using mock glog sync which keeps track on all messages and expects specific log message to appear in the logging. This means each optimization step should report that it optimized something (specifying what exactly was optimized) and what was used for optimization. There's also some ease-ish way to define shader networks which we might want to make a bit more global and available for all tests in the future. For now only RGBToBW node is covered as an example, really hope to get help from active guys in the community to finish covering all existing optimization cases. Ready to fix any possible issues with builder when needed tho :)
2016-07-29 18:44:29 +02: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
Cycles: Add fundamentals to test constant folding This commit adds some easy to use way to check whether the graph was properly optimized. The idea is based on using mock glog sync which keeps track on all messages and expects specific log message to appear in the logging. This means each optimization step should report that it optimized something (specifying what exactly was optimized) and what was used for optimization. There's also some ease-ish way to define shader networks which we might want to make a bit more global and available for all tests in the future. For now only RGBToBW node is covered as an example, really hope to get help from active guys in the community to finish covering all existing optimization cases. Ready to fix any possible issues with builder when needed tho :)
2016-07-29 18:44:29 +02:00
ShaderNode *find_node(const string &name)
{
Refactor: Cycles: Add const keyword where possible, using clang-tidy Check was misc-const-correctness, combined with readability-isolate-declaration as suggested by the docs. Temporarily clang-format "QualifierAlignment: Left" was used to get consistency with the prevailing order of keywords. Pull Request: https://projects.blender.org/blender/blender/pulls/132361
2024-12-29 17:32:00 +01:00
const map<string, ShaderNode *>::iterator it = node_map_.find(name);
Cycles: Add fundamentals to test constant folding This commit adds some easy to use way to check whether the graph was properly optimized. The idea is based on using mock glog sync which keeps track on all messages and expects specific log message to appear in the logging. This means each optimization step should report that it optimized something (specifying what exactly was optimized) and what was used for optimization. There's also some ease-ish way to define shader networks which we might want to make a bit more global and available for all tests in the future. For now only RGBToBW node is covered as an example, really hope to get help from active guys in the community to finish covering all existing optimization cases. Ready to fix any possible issues with builder when needed tho :)
2016-07-29 18:44:29 +02:00
if (it == node_map_.end()) {
Refactor: Cycles: Use nullptr instead of NULL Pull Request: https://projects.blender.org/blender/blender/pulls/132361
2024-12-26 17:53:55 +01:00
return nullptr;
Cycles: Add fundamentals to test constant folding This commit adds some easy to use way to check whether the graph was properly optimized. The idea is based on using mock glog sync which keeps track on all messages and expects specific log message to appear in the logging. This means each optimization step should report that it optimized something (specifying what exactly was optimized) and what was used for optimization. There's also some ease-ish way to define shader networks which we might want to make a bit more global and available for all tests in the future. For now only RGBToBW node is covered as an example, really hope to get help from active guys in the community to finish covering all existing optimization cases. Ready to fix any possible issues with builder when needed tho :)
2016-07-29 18:44:29 +02:00
}
return it->second;
}
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
Cycles: Add fundamentals to test constant folding This commit adds some easy to use way to check whether the graph was properly optimized. The idea is based on using mock glog sync which keeps track on all messages and expects specific log message to appear in the logging. This means each optimization step should report that it optimized something (specifying what exactly was optimized) and what was used for optimization. There's also some ease-ish way to define shader networks which we might want to make a bit more global and available for all tests in the future. For now only RGBToBW node is covered as an example, really hope to get help from active guys in the community to finish covering all existing optimization cases. Ready to fix any possible issues with builder when needed tho :)
2016-07-29 18:44:29 +02:00
template<typename T> ShaderGraphBuilder &add_node(const T &node)
{
Refactor: Cycles: Use nullptr instead of NULL Pull Request: https://projects.blender.org/blender/blender/pulls/132361
2024-12-26 17:53:55 +01:00
EXPECT_EQ(find_node(node.name()), (void *)nullptr);
Cycles: Add fundamentals to test constant folding This commit adds some easy to use way to check whether the graph was properly optimized. The idea is based on using mock glog sync which keeps track on all messages and expects specific log message to appear in the logging. This means each optimization step should report that it optimized something (specifying what exactly was optimized) and what was used for optimization. There's also some ease-ish way to define shader networks which we might want to make a bit more global and available for all tests in the future. For now only RGBToBW node is covered as an example, really hope to get help from active guys in the community to finish covering all existing optimization cases. Ready to fix any possible issues with builder when needed tho :)
2016-07-29 18:44:29 +02:00
node_map_[node.name()] = node.node();
return *this;
}
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
Cycles: Add fundamentals to test constant folding This commit adds some easy to use way to check whether the graph was properly optimized. The idea is based on using mock glog sync which keeps track on all messages and expects specific log message to appear in the logging. This means each optimization step should report that it optimized something (specifying what exactly was optimized) and what was used for optimization. There's also some ease-ish way to define shader networks which we might want to make a bit more global and available for all tests in the future. For now only RGBToBW node is covered as an example, really hope to get help from active guys in the community to finish covering all existing optimization cases. Ready to fix any possible issues with builder when needed tho :)
2016-07-29 18:44:29 +02:00
ShaderGraphBuilder &add_connection(const string &from, const string &to)
{
Refactor: Cycles: Add const keyword where possible, using clang-tidy Check was misc-const-correctness, combined with readability-isolate-declaration as suggested by the docs. Temporarily clang-format "QualifierAlignment: Left" was used to get consistency with the prevailing order of keywords. Pull Request: https://projects.blender.org/blender/blender/pulls/132361
2024-12-29 17:32:00 +01:00
vector<string> tokens_from;
vector<string> tokens_to;
Cycles: Add fundamentals to test constant folding This commit adds some easy to use way to check whether the graph was properly optimized. The idea is based on using mock glog sync which keeps track on all messages and expects specific log message to appear in the logging. This means each optimization step should report that it optimized something (specifying what exactly was optimized) and what was used for optimization. There's also some ease-ish way to define shader networks which we might want to make a bit more global and available for all tests in the future. For now only RGBToBW node is covered as an example, really hope to get help from active guys in the community to finish covering all existing optimization cases. Ready to fix any possible issues with builder when needed tho :)
2016-07-29 18:44:29 +02:00
string_split(tokens_from, from, "::");
string_split(tokens_to, to, "::");
Cycles: Cleanup, order of arguments to EXPECT_EQ The order was wrong from the semantic point of view, caused by some legacy workarounds in Libmv. Didn't realize it's was not how things were expected to be used.
2017-02-03 11:35:34 +01:00
EXPECT_EQ(tokens_from.size(), 2);
EXPECT_EQ(tokens_to.size(), 2);
Refactor: Cycles: Add const keyword where possible, using clang-tidy Check was misc-const-correctness, combined with readability-isolate-declaration as suggested by the docs. Temporarily clang-format "QualifierAlignment: Left" was used to get consistency with the prevailing order of keywords. Pull Request: https://projects.blender.org/blender/blender/pulls/132361
2024-12-29 17:32:00 +01:00
ShaderNode *node_from = find_node(tokens_from[0]);
ShaderNode *node_to = find_node(tokens_to[0]);
Refactor: Cycles: Use nullptr instead of NULL Pull Request: https://projects.blender.org/blender/blender/pulls/132361
2024-12-26 17:53:55 +01:00
EXPECT_NE((void *)nullptr, node_from);
EXPECT_NE((void *)nullptr, node_to);
Cycles: Add fundamentals to test constant folding This commit adds some easy to use way to check whether the graph was properly optimized. The idea is based on using mock glog sync which keeps track on all messages and expects specific log message to appear in the logging. This means each optimization step should report that it optimized something (specifying what exactly was optimized) and what was used for optimization. There's also some ease-ish way to define shader networks which we might want to make a bit more global and available for all tests in the future. For now only RGBToBW node is covered as an example, really hope to get help from active guys in the community to finish covering all existing optimization cases. Ready to fix any possible issues with builder when needed tho :)
2016-07-29 18:44:29 +02:00
EXPECT_NE(node_from, node_to);
ShaderOutput *socket_from = node_from->output(tokens_from[1].c_str());
ShaderInput *socket_to = node_to->input(tokens_to[1].c_str());
Refactor: Cycles: Use nullptr instead of NULL Pull Request: https://projects.blender.org/blender/blender/pulls/132361
2024-12-26 17:53:55 +01:00
EXPECT_NE((void *)nullptr, socket_from);
EXPECT_NE((void *)nullptr, socket_to);
Cycles: Add fundamentals to test constant folding This commit adds some easy to use way to check whether the graph was properly optimized. The idea is based on using mock glog sync which keeps track on all messages and expects specific log message to appear in the logging. This means each optimization step should report that it optimized something (specifying what exactly was optimized) and what was used for optimization. There's also some ease-ish way to define shader networks which we might want to make a bit more global and available for all tests in the future. For now only RGBToBW node is covered as an example, really hope to get help from active guys in the community to finish covering all existing optimization cases. Ready to fix any possible issues with builder when needed tho :)
2016-07-29 18:44:29 +02:00
graph_->connect(socket_from, socket_to);
return *this;
}
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
Cycles: add unit tests for supported constant folding rules. Code coverage of different combinations of secondary conditions is obviously not complete because there are so many of them, but all main rules should be there. The reason for CORRECT vs INVALID is that both words have the same number of characters so calls line up, but look quite different. Reviewers: #cycles, sergey Reviewed By: #cycles, sergey Subscribers: dingto, sergey, brecht Differential Revision: https://developer.blender.org/D2130
2016-08-01 18:53:20 +03:00
/* Common input/output boilerplate. */
ShaderGraphBuilder &add_attribute(const string &name)
{
Cycles API: encapsulate Node socket members This encapsulates Node socket members behind a set of specific methods; as such it is no longer possible to directly access Node class members from exporters and parts of Cycles. The methods are defined via the NODE_SOCKET_API macros in `graph/ node.h`, and are for getting or setting a specific socket's value, as well as querying or modifying the state of its update flag. The setters will check whether the value has changed and tag the socket as modified appropriately. This will let us know how a Node has changed and what to update, which is the first concrete step toward a more granular scene update system. Since the setters will tag the Node sockets as modified when passed different data, this patch also removes the various modified methods on Nodes in favor of Node::is_modified which checks the sockets' update flags status. Reviewed By: brecht Maniphest Tasks: T79174 Differential Revision: https://developer.blender.org/D8544
2020-11-04 11:17:38 +01:00
return (*this).add_node(
ShaderNodeBuilder<AttributeNode>(*graph_, name).set_param("attribute", ustring(name)));
Cycles: add unit tests for supported constant folding rules. Code coverage of different combinations of secondary conditions is obviously not complete because there are so many of them, but all main rules should be there. The reason for CORRECT vs INVALID is that both words have the same number of characters so calls line up, but look quite different. Reviewers: #cycles, sergey Reviewed By: #cycles, sergey Subscribers: dingto, sergey, brecht Differential Revision: https://developer.blender.org/D2130
2016-08-01 18:53:20 +03: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
Cycles: add unit tests for supported constant folding rules. Code coverage of different combinations of secondary conditions is obviously not complete because there are so many of them, but all main rules should be there. The reason for CORRECT vs INVALID is that both words have the same number of characters so calls line up, but look quite different. Reviewers: #cycles, sergey Reviewed By: #cycles, sergey Subscribers: dingto, sergey, brecht Differential Revision: https://developer.blender.org/D2130
2016-08-01 18:53:20 +03:00
ShaderGraphBuilder &output_closure(const string &from)
{
return (*this).add_connection(from, "Output::Surface");
}
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
Cycles: add unit tests for supported constant folding rules. Code coverage of different combinations of secondary conditions is obviously not complete because there are so many of them, but all main rules should be there. The reason for CORRECT vs INVALID is that both words have the same number of characters so calls line up, but look quite different. Reviewers: #cycles, sergey Reviewed By: #cycles, sergey Subscribers: dingto, sergey, brecht Differential Revision: https://developer.blender.org/D2130
2016-08-01 18:53:20 +03:00
ShaderGraphBuilder &output_color(const string &from)
{
return (*this)
Cycles: fix missing ShaderNode ownership in render_graph_finalize_test
2020-10-13 15:36:52 +02:00
.add_node(ShaderNodeBuilder<EmissionNode>(*graph_, "EmissionNode"))
Cycles: add unit tests for supported constant folding rules. Code coverage of different combinations of secondary conditions is obviously not complete because there are so many of them, but all main rules should be there. The reason for CORRECT vs INVALID is that both words have the same number of characters so calls line up, but look quite different. Reviewers: #cycles, sergey Reviewed By: #cycles, sergey Subscribers: dingto, sergey, brecht Differential Revision: https://developer.blender.org/D2130
2016-08-01 18:53:20 +03:00
.add_connection(from, "EmissionNode::Color")
.output_closure("EmissionNode::Emission");
}
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
Cycles: tweak some folding tests to avoid unnecessary type conversion. It's easy to connect a simple value to output without forcing conversion to color by using the Strength socket of Emission.
2016-08-02 12:08:04 +03:00
ShaderGraphBuilder &output_value(const string &from)
{
return (*this)
Cycles: fix missing ShaderNode ownership in render_graph_finalize_test
2020-10-13 15:36:52 +02:00
.add_node(ShaderNodeBuilder<EmissionNode>(*graph_, "EmissionNode"))
Cycles: tweak some folding tests to avoid unnecessary type conversion. It's easy to connect a simple value to output without forcing conversion to color by using the Strength socket of Emission.
2016-08-02 12:08:04 +03:00
.add_connection(from, "EmissionNode::Strength")
.output_closure("EmissionNode::Emission");
}
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
Cycles: fix missing ShaderNode ownership in render_graph_finalize_test
2020-10-13 15:36:52 +02:00
ShaderGraph &graph()
{
return *graph_;
}
Cycles: Add fundamentals to test constant folding This commit adds some easy to use way to check whether the graph was properly optimized. The idea is based on using mock glog sync which keeps track on all messages and expects specific log message to appear in the logging. This means each optimization step should report that it optimized something (specifying what exactly was optimized) and what was used for optimization. There's also some ease-ish way to define shader networks which we might want to make a bit more global and available for all tests in the future. For now only RGBToBW node is covered as an example, really hope to get help from active guys in the community to finish covering all existing optimization cases. Ready to fix any possible issues with builder when needed tho :)
2016-07-29 18:44:29 +02:00
protected:
ShaderGraph *graph_;
map<string, ShaderNode *> node_map_;
};
} // namespace
Cycles: Fix memory leak in test and simplify code
2017-10-24 11:12:28 +02:00
class RenderGraph : public testing::Test {
protected:
ScopedMockLog log;
Stats stats;
Fix T58183: crash with CPU + GPU rendering after profiling changes. Multi-device was not passing along profiler to the CPU.
2018-11-29 23:30:17 +01:00
Profiler profiler;
Cycles: Fix memory leak in test and simplify code
2017-10-24 11:12:28 +02:00
DeviceInfo device_info;
Refactor: Cycles: Replace new/delete by unique_ptr, in simple cases Pull Request: https://projects.blender.org/blender/blender/pulls/132361
2024-12-29 23:13:45 +01:00
unique_ptr<Device> device_cpu;
Cycles: Fix memory leak in test and simplify code
2017-10-24 11:12:28 +02:00
SceneParams scene_params;
Refactor: Cycles: Replace new/delete by unique_ptr, in simple cases Pull Request: https://projects.blender.org/blender/blender/pulls/132361
2024-12-29 23:13:45 +01:00
unique_ptr<Scene> scene;
Cycles: Fix memory leak in test and simplify code
2017-10-24 11:12:28 +02:00
ShaderGraph graph;
ShaderGraphBuilder builder;
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
Clang-Format: Allow empty functions to be single-line For example ``` OIIOOutputDriver::~OIIOOutputDriver() { } ``` becomes ``` OIIOOutputDriver::~OIIOOutputDriver() {} ``` Saves quite some vertical space, which is especially handy for constructors. Pull Request: https://projects.blender.org/blender/blender/pulls/105594
2023-03-29 16:50:54 +02:00
RenderGraph() : testing::Test(), builder(&graph) {}
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
Refactor: Cycles: Automated clang-tidy fixups in Cycles * Use .empty() and .data() * Use nullptr instead of 0 * No else after return * Simple class member initialization * Add override for virtual methods * Include C++ instead of C headers * Remove some unused includes * Use default constructors * Always use braces * Consistent names in definition and declaration * Change typedef to using Pull Request: https://projects.blender.org/blender/blender/pulls/132361
2024-12-26 17:53:59 +01:00
void SetUp() override
Cycles: Fix memory leak in test and simplify code
2017-10-24 11:12:28 +02:00
{
Fix warnings in Cycles graph test output Harmless, but is quite noisy and easy to avoid. Pull Request: https://projects.blender.org/blender/blender/pulls/105985
2023-03-23 09:55:54 +01:00
/* The test is running outside of the typical application configuration when the OCIO is
* initialized prior to Cycles. Explicitly create the raw configuration to avoid the warning
* printed by the OCIO when accessing non-figured environment.
* Functionally it is the same as not doing this explicit call: the OCIO will warn and then do
* the same raw configuration. */
ColorSpaceManager::init_fallback_config();
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
Fix: Command line Cycles render crash on multi-CUDA device Since #118841 there are more cases where Cycles would check for the graphics interop support. This could lead to a crash when graphics interop functions are called without having active graphics context. This change makes it so there is no graphics interop calls when doing headless render. In order to achieve this the device creation is now aware of the headless mode. Pull Request: https://projects.blender.org/blender/blender/pulls/122844
2024-06-07 17:53:44 +02:00
device_cpu = Device::create(device_info, stats, profiler, true);
Refactor: Cycles: Replace new/delete by unique_ptr, in simple cases Pull Request: https://projects.blender.org/blender/blender/pulls/132361
2024-12-29 23:13:45 +01:00
scene = make_unique<Scene>(scene_params, device_cpu.get());
Fix warnings in Cycles graph test output Harmless, but is quite noisy and easy to avoid. Pull Request: https://projects.blender.org/blender/blender/pulls/105985
2023-03-23 09:55:54 +01:00
/* Initialize logging after the creation of the essential resources. This way the logging
* mock sink does not warn about uninteresting messages which happens prior to the setup of
* the actual mock sinks. */
util_logging_start();
util_logging_verbosity_set(5);
Cycles: Fix memory leak in test and simplify code
2017-10-24 11:12:28 +02: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
Refactor: Cycles: Automated clang-tidy fixups in Cycles * Use .empty() and .data() * Use nullptr instead of 0 * No else after return * Simple class member initialization * Add override for virtual methods * Include C++ instead of C headers * Remove some unused includes * Use default constructors * Always use braces * Consistent names in definition and declaration * Change typedef to using Pull Request: https://projects.blender.org/blender/blender/pulls/132361
2024-12-26 17:53:59 +01:00
void TearDown() override
Cycles: Fix memory leak in test and simplify code
2017-10-24 11:12:28 +02:00
{
Fix warnings in Cycles graph test output Harmless, but is quite noisy and easy to avoid. Pull Request: https://projects.blender.org/blender/blender/pulls/105985
2023-03-23 09:55:54 +01:00
/* Effectively disable logging, so that the next test suit starts in an environment which is
* not logging by default. */
util_logging_verbosity_set(0);
Refactor: Cycles: Replace new/delete by unique_ptr, in simple cases Pull Request: https://projects.blender.org/blender/blender/pulls/132361
2024-12-29 23:13:45 +01:00
scene.reset();
device_cpu.reset();
Cycles: Fix memory leak in test and simplify code
2017-10-24 11:12:28 +02:00
}
};
Cycles: Add fundamentals to test constant folding This commit adds some easy to use way to check whether the graph was properly optimized. The idea is based on using mock glog sync which keeps track on all messages and expects specific log message to appear in the logging. This means each optimization step should report that it optimized something (specifying what exactly was optimized) and what was used for optimization. There's also some ease-ish way to define shader networks which we might want to make a bit more global and available for all tests in the future. For now only RGBToBW node is covered as an example, really hope to get help from active guys in the community to finish covering all existing optimization cases. Ready to fix any possible issues with builder when needed tho :)
2016-07-29 18:44:29 +02:00
Cycles: add unit tests for supported constant folding rules. Code coverage of different combinations of secondary conditions is obviously not complete because there are so many of them, but all main rules should be there. The reason for CORRECT vs INVALID is that both words have the same number of characters so calls line up, but look quite different. Reviewers: #cycles, sergey Reviewed By: #cycles, sergey Subscribers: dingto, sergey, brecht Differential Revision: https://developer.blender.org/D2130
2016-08-01 18:53:20 +03:00
#define EXPECT_ANY_MESSAGE(log) EXPECT_CALL(log, Log(_, _, _)).Times(AnyNumber());
#define CORRECT_INFO_MESSAGE(log, message) \
EXPECT_CALL(log, Log(google::INFO, _, HasSubstr(message)));
#define INVALID_INFO_MESSAGE(log, message) \
EXPECT_CALL(log, Log(google::INFO, _, HasSubstr(message))).Times(0);
/*
* Test deduplication of nodes that have inputs, some of them folded.
*/
Cycles: Fix memory leak in test and simplify code
2017-10-24 11:12:28 +02:00
TEST_F(RenderGraph, deduplicate_deep)
Cycles: add unit tests for supported constant folding rules. Code coverage of different combinations of secondary conditions is obviously not complete because there are so many of them, but all main rules should be there. The reason for CORRECT vs INVALID is that both words have the same number of characters so calls line up, but look quite different. Reviewers: #cycles, sergey Reviewed By: #cycles, sergey Subscribers: dingto, sergey, brecht Differential Revision: https://developer.blender.org/D2130
2016-08-01 18:53:20 +03:00
{
EXPECT_ANY_MESSAGE(log);
CORRECT_INFO_MESSAGE(log, "Folding Value1::Value to constant (0.8).");
CORRECT_INFO_MESSAGE(log, "Folding Value2::Value to constant (0.8).");
Cycles: log how many nodes were deduplicated for use in tests. To make the number more meaningful, also skip deduplicating obviously unused nodes with no outgoing links.
2016-08-02 19:26:57 +03:00
CORRECT_INFO_MESSAGE(log, "Deduplicated 2 nodes.");
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
Cycles: fix missing ShaderNode ownership in render_graph_finalize_test
2020-10-13 15:36:52 +02:00
builder.add_node(ShaderNodeBuilder<GeometryNode>(graph, "Geometry1"))
.add_node(ShaderNodeBuilder<GeometryNode>(graph, "Geometry2"))
Cycles API: encapsulate Node socket members This encapsulates Node socket members behind a set of specific methods; as such it is no longer possible to directly access Node class members from exporters and parts of Cycles. The methods are defined via the NODE_SOCKET_API macros in `graph/ node.h`, and are for getting or setting a specific socket's value, as well as querying or modifying the state of its update flag. The setters will check whether the value has changed and tag the socket as modified appropriately. This will let us know how a Node has changed and what to update, which is the first concrete step toward a more granular scene update system. Since the setters will tag the Node sockets as modified when passed different data, this patch also removes the various modified methods on Nodes in favor of Node::is_modified which checks the sockets' update flags status. Reviewed By: brecht Maniphest Tasks: T79174 Differential Revision: https://developer.blender.org/D8544
2020-11-04 11:17:38 +01:00
.add_node(ShaderNodeBuilder<ValueNode>(graph, "Value1").set_param("value", 0.8f))
.add_node(ShaderNodeBuilder<ValueNode>(graph, "Value2").set_param("value", 0.8f))
Cycles: fix missing ShaderNode ownership in render_graph_finalize_test
2020-10-13 15:36:52 +02:00
.add_node(ShaderNodeBuilder<NoiseTextureNode>(graph, "Noise1"))
.add_node(ShaderNodeBuilder<NoiseTextureNode>(graph, "Noise2"))
.add_node(ShaderNodeBuilder<MixNode>(graph, "Mix")
Cycles API: encapsulate Node socket members This encapsulates Node socket members behind a set of specific methods; as such it is no longer possible to directly access Node class members from exporters and parts of Cycles. The methods are defined via the NODE_SOCKET_API macros in `graph/ node.h`, and are for getting or setting a specific socket's value, as well as querying or modifying the state of its update flag. The setters will check whether the value has changed and tag the socket as modified appropriately. This will let us know how a Node has changed and what to update, which is the first concrete step toward a more granular scene update system. Since the setters will tag the Node sockets as modified when passed different data, this patch also removes the various modified methods on Nodes in favor of Node::is_modified which checks the sockets' update flags status. Reviewed By: brecht Maniphest Tasks: T79174 Differential Revision: https://developer.blender.org/D8544
2020-11-04 11:17:38 +01:00
.set_param("mix_type", NODE_MIX_BLEND)
Cycles: fix missing ShaderNode ownership in render_graph_finalize_test
2020-10-13 15:36:52 +02:00
.set("Fac", 0.5f))
Cycles: add unit tests for supported constant folding rules. Code coverage of different combinations of secondary conditions is obviously not complete because there are so many of them, but all main rules should be there. The reason for CORRECT vs INVALID is that both words have the same number of characters so calls line up, but look quite different. Reviewers: #cycles, sergey Reviewed By: #cycles, sergey Subscribers: dingto, sergey, brecht Differential Revision: https://developer.blender.org/D2130
2016-08-01 18:53:20 +03:00
.add_connection("Geometry1::Parametric", "Noise1::Vector")
.add_connection("Value1::Value", "Noise1::Scale")
.add_connection("Noise1::Color", "Mix::Color1")
.add_connection("Geometry2::Parametric", "Noise2::Vector")
.add_connection("Value2::Value", "Noise2::Scale")
.add_connection("Noise2::Color", "Mix::Color2")
.output_color("Mix::Color");
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
Refactor: Cycles: Replace new/delete by unique_ptr, in simple cases Pull Request: https://projects.blender.org/blender/blender/pulls/132361
2024-12-29 23:13:45 +01:00
graph.finalize(scene.get());
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
Cycles: add unit tests for supported constant folding rules. Code coverage of different combinations of secondary conditions is obviously not complete because there are so many of them, but all main rules should be there. The reason for CORRECT vs INVALID is that both words have the same number of characters so calls line up, but look quite different. Reviewers: #cycles, sergey Reviewed By: #cycles, sergey Subscribers: dingto, sergey, brecht Differential Revision: https://developer.blender.org/D2130
2016-08-01 18:53:20 +03:00
EXPECT_EQ(graph.nodes.size(), 5);
}
/*
* Test RGB to BW node.
*/
Cycles: Fix memory leak in test and simplify code
2017-10-24 11:12:28 +02:00
TEST_F(RenderGraph, constant_fold_rgb_to_bw)
Cycles: Add fundamentals to test constant folding This commit adds some easy to use way to check whether the graph was properly optimized. The idea is based on using mock glog sync which keeps track on all messages and expects specific log message to appear in the logging. This means each optimization step should report that it optimized something (specifying what exactly was optimized) and what was used for optimization. There's also some ease-ish way to define shader networks which we might want to make a bit more global and available for all tests in the future. For now only RGBToBW node is covered as an example, really hope to get help from active guys in the community to finish covering all existing optimization cases. Ready to fix any possible issues with builder when needed tho :)
2016-07-29 18:44:29 +02:00
{
Cycles: add unit tests for supported constant folding rules. Code coverage of different combinations of secondary conditions is obviously not complete because there are so many of them, but all main rules should be there. The reason for CORRECT vs INVALID is that both words have the same number of characters so calls line up, but look quite different. Reviewers: #cycles, sergey Reviewed By: #cycles, sergey Subscribers: dingto, sergey, brecht Differential Revision: https://developer.blender.org/D2130
2016-08-01 18:53:20 +03:00
EXPECT_ANY_MESSAGE(log);
CORRECT_INFO_MESSAGE(log, "Folding RGBToBWNodeNode::Val to constant (0.8).");
CORRECT_INFO_MESSAGE(log,
"Folding convert_float_to_color::value_color to constant (0.8, 0.8, 0.8).");
Cycles: Add fundamentals to test constant folding This commit adds some easy to use way to check whether the graph was properly optimized. The idea is based on using mock glog sync which keeps track on all messages and expects specific log message to appear in the logging. This means each optimization step should report that it optimized something (specifying what exactly was optimized) and what was used for optimization. There's also some ease-ish way to define shader networks which we might want to make a bit more global and available for all tests in the future. For now only RGBToBW node is covered as an example, really hope to get help from active guys in the community to finish covering all existing optimization cases. Ready to fix any possible issues with builder when needed tho :)
2016-07-29 18:44:29 +02:00
builder
Cycles: fix missing ShaderNode ownership in render_graph_finalize_test
2020-10-13 15:36:52 +02:00
.add_node(ShaderNodeBuilder<RGBToBWNode>(graph, "RGBToBWNodeNode")
Cycles: Add fundamentals to test constant folding This commit adds some easy to use way to check whether the graph was properly optimized. The idea is based on using mock glog sync which keeps track on all messages and expects specific log message to appear in the logging. This means each optimization step should report that it optimized something (specifying what exactly was optimized) and what was used for optimization. There's also some ease-ish way to define shader networks which we might want to make a bit more global and available for all tests in the future. For now only RGBToBW node is covered as an example, really hope to get help from active guys in the community to finish covering all existing optimization cases. Ready to fix any possible issues with builder when needed tho :)
2016-07-29 18:44:29 +02:00
.set("Color", make_float3(0.8f, 0.8f, 0.8f)))
Cycles: add unit tests for supported constant folding rules. Code coverage of different combinations of secondary conditions is obviously not complete because there are so many of them, but all main rules should be there. The reason for CORRECT vs INVALID is that both words have the same number of characters so calls line up, but look quite different. Reviewers: #cycles, sergey Reviewed By: #cycles, sergey Subscribers: dingto, sergey, brecht Differential Revision: https://developer.blender.org/D2130
2016-08-01 18:53:20 +03:00
.output_color("RGBToBWNodeNode::Val");
Refactor: Cycles: Replace new/delete by unique_ptr, in simple cases Pull Request: https://projects.blender.org/blender/blender/pulls/132361
2024-12-29 23:13:45 +01:00
graph.finalize(scene.get());
Cycles: add unit tests for supported constant folding rules. Code coverage of different combinations of secondary conditions is obviously not complete because there are so many of them, but all main rules should be there. The reason for CORRECT vs INVALID is that both words have the same number of characters so calls line up, but look quite different. Reviewers: #cycles, sergey Reviewed By: #cycles, sergey Subscribers: dingto, sergey, brecht Differential Revision: https://developer.blender.org/D2130
2016-08-01 18:53:20 +03:00
}
/*
* Tests:
* - folding of Emission nodes that don't emit to nothing.
*/
Cycles: Fix memory leak in test and simplify code
2017-10-24 11:12:28 +02:00
TEST_F(RenderGraph, constant_fold_emission1)
Cycles: add unit tests for supported constant folding rules. Code coverage of different combinations of secondary conditions is obviously not complete because there are so many of them, but all main rules should be there. The reason for CORRECT vs INVALID is that both words have the same number of characters so calls line up, but look quite different. Reviewers: #cycles, sergey Reviewed By: #cycles, sergey Subscribers: dingto, sergey, brecht Differential Revision: https://developer.blender.org/D2130
2016-08-01 18:53:20 +03:00
{
EXPECT_ANY_MESSAGE(log);
CORRECT_INFO_MESSAGE(log, "Discarding closure Emission.");
Cycles: add utility functions for zero float2/float3/float4/transform Ref D8237, T78710
2021-02-17 01:47:18 +01:00
builder.add_node(ShaderNodeBuilder<EmissionNode>(graph, "Emission").set("Color", zero_float3()))
Cycles: add unit tests for supported constant folding rules. Code coverage of different combinations of secondary conditions is obviously not complete because there are so many of them, but all main rules should be there. The reason for CORRECT vs INVALID is that both words have the same number of characters so calls line up, but look quite different. Reviewers: #cycles, sergey Reviewed By: #cycles, sergey Subscribers: dingto, sergey, brecht Differential Revision: https://developer.blender.org/D2130
2016-08-01 18:53:20 +03:00
.output_closure("Emission::Emission");
Refactor: Cycles: Replace new/delete by unique_ptr, in simple cases Pull Request: https://projects.blender.org/blender/blender/pulls/132361
2024-12-29 23:13:45 +01:00
graph.finalize(scene.get());
Cycles: add unit tests for supported constant folding rules. Code coverage of different combinations of secondary conditions is obviously not complete because there are so many of them, but all main rules should be there. The reason for CORRECT vs INVALID is that both words have the same number of characters so calls line up, but look quite different. Reviewers: #cycles, sergey Reviewed By: #cycles, sergey Subscribers: dingto, sergey, brecht Differential Revision: https://developer.blender.org/D2130
2016-08-01 18:53:20 +03:00
}
Cycles: Fix memory leak in test and simplify code
2017-10-24 11:12:28 +02:00
TEST_F(RenderGraph, constant_fold_emission2)
Cycles: add unit tests for supported constant folding rules. Code coverage of different combinations of secondary conditions is obviously not complete because there are so many of them, but all main rules should be there. The reason for CORRECT vs INVALID is that both words have the same number of characters so calls line up, but look quite different. Reviewers: #cycles, sergey Reviewed By: #cycles, sergey Subscribers: dingto, sergey, brecht Differential Revision: https://developer.blender.org/D2130
2016-08-01 18:53:20 +03:00
{
EXPECT_ANY_MESSAGE(log);
CORRECT_INFO_MESSAGE(log, "Discarding closure Emission.");
Cycles: fix missing ShaderNode ownership in render_graph_finalize_test
2020-10-13 15:36:52 +02:00
builder.add_node(ShaderNodeBuilder<EmissionNode>(graph, "Emission").set("Strength", 0.0f))
Cycles: add unit tests for supported constant folding rules. Code coverage of different combinations of secondary conditions is obviously not complete because there are so many of them, but all main rules should be there. The reason for CORRECT vs INVALID is that both words have the same number of characters so calls line up, but look quite different. Reviewers: #cycles, sergey Reviewed By: #cycles, sergey Subscribers: dingto, sergey, brecht Differential Revision: https://developer.blender.org/D2130
2016-08-01 18:53:20 +03:00
.output_closure("Emission::Emission");
Refactor: Cycles: Replace new/delete by unique_ptr, in simple cases Pull Request: https://projects.blender.org/blender/blender/pulls/132361
2024-12-29 23:13:45 +01:00
graph.finalize(scene.get());
Cycles: add unit tests for supported constant folding rules. Code coverage of different combinations of secondary conditions is obviously not complete because there are so many of them, but all main rules should be there. The reason for CORRECT vs INVALID is that both words have the same number of characters so calls line up, but look quite different. Reviewers: #cycles, sergey Reviewed By: #cycles, sergey Subscribers: dingto, sergey, brecht Differential Revision: https://developer.blender.org/D2130
2016-08-01 18:53:20 +03:00
}
/*
* Tests:
* - folding of Background nodes that don't emit to nothing.
*/
Cycles: Fix memory leak in test and simplify code
2017-10-24 11:12:28 +02:00
TEST_F(RenderGraph, constant_fold_background1)
Cycles: add unit tests for supported constant folding rules. Code coverage of different combinations of secondary conditions is obviously not complete because there are so many of them, but all main rules should be there. The reason for CORRECT vs INVALID is that both words have the same number of characters so calls line up, but look quite different. Reviewers: #cycles, sergey Reviewed By: #cycles, sergey Subscribers: dingto, sergey, brecht Differential Revision: https://developer.blender.org/D2130
2016-08-01 18:53:20 +03:00
{
EXPECT_ANY_MESSAGE(log);
CORRECT_INFO_MESSAGE(log, "Discarding closure Background.");
builder
Cycles: add utility functions for zero float2/float3/float4/transform Ref D8237, T78710
2021-02-17 01:47:18 +01:00
.add_node(ShaderNodeBuilder<BackgroundNode>(graph, "Background").set("Color", zero_float3()))
Cycles: add unit tests for supported constant folding rules. Code coverage of different combinations of secondary conditions is obviously not complete because there are so many of them, but all main rules should be there. The reason for CORRECT vs INVALID is that both words have the same number of characters so calls line up, but look quite different. Reviewers: #cycles, sergey Reviewed By: #cycles, sergey Subscribers: dingto, sergey, brecht Differential Revision: https://developer.blender.org/D2130
2016-08-01 18:53:20 +03:00
.output_closure("Background::Background");
Refactor: Cycles: Replace new/delete by unique_ptr, in simple cases Pull Request: https://projects.blender.org/blender/blender/pulls/132361
2024-12-29 23:13:45 +01:00
graph.finalize(scene.get());
Cycles: add unit tests for supported constant folding rules. Code coverage of different combinations of secondary conditions is obviously not complete because there are so many of them, but all main rules should be there. The reason for CORRECT vs INVALID is that both words have the same number of characters so calls line up, but look quite different. Reviewers: #cycles, sergey Reviewed By: #cycles, sergey Subscribers: dingto, sergey, brecht Differential Revision: https://developer.blender.org/D2130
2016-08-01 18:53:20 +03:00
}
Cycles: Fix memory leak in test and simplify code
2017-10-24 11:12:28 +02:00
TEST_F(RenderGraph, constant_fold_background2)
Cycles: add unit tests for supported constant folding rules. Code coverage of different combinations of secondary conditions is obviously not complete because there are so many of them, but all main rules should be there. The reason for CORRECT vs INVALID is that both words have the same number of characters so calls line up, but look quite different. Reviewers: #cycles, sergey Reviewed By: #cycles, sergey Subscribers: dingto, sergey, brecht Differential Revision: https://developer.blender.org/D2130
2016-08-01 18:53:20 +03:00
{
EXPECT_ANY_MESSAGE(log);
CORRECT_INFO_MESSAGE(log, "Discarding closure Background.");
Cycles: fix missing ShaderNode ownership in render_graph_finalize_test
2020-10-13 15:36:52 +02:00
builder.add_node(ShaderNodeBuilder<BackgroundNode>(graph, "Background").set("Strength", 0.0f))
Cycles: add unit tests for supported constant folding rules. Code coverage of different combinations of secondary conditions is obviously not complete because there are so many of them, but all main rules should be there. The reason for CORRECT vs INVALID is that both words have the same number of characters so calls line up, but look quite different. Reviewers: #cycles, sergey Reviewed By: #cycles, sergey Subscribers: dingto, sergey, brecht Differential Revision: https://developer.blender.org/D2130
2016-08-01 18:53:20 +03:00
.output_closure("Background::Background");
Refactor: Cycles: Replace new/delete by unique_ptr, in simple cases Pull Request: https://projects.blender.org/blender/blender/pulls/132361
2024-12-29 23:13:45 +01:00
graph.finalize(scene.get());
Cycles: add unit tests for supported constant folding rules. Code coverage of different combinations of secondary conditions is obviously not complete because there are so many of them, but all main rules should be there. The reason for CORRECT vs INVALID is that both words have the same number of characters so calls line up, but look quite different. Reviewers: #cycles, sergey Reviewed By: #cycles, sergey Subscribers: dingto, sergey, brecht Differential Revision: https://developer.blender.org/D2130
2016-08-01 18:53:20 +03:00
}
/*
* Tests:
* - Folding of Add Closure with only one input.
*/
Cycles: Fix memory leak in test and simplify code
2017-10-24 11:12:28 +02:00
TEST_F(RenderGraph, constant_fold_shader_add)
Cycles: add unit tests for supported constant folding rules. Code coverage of different combinations of secondary conditions is obviously not complete because there are so many of them, but all main rules should be there. The reason for CORRECT vs INVALID is that both words have the same number of characters so calls line up, but look quite different. Reviewers: #cycles, sergey Reviewed By: #cycles, sergey Subscribers: dingto, sergey, brecht Differential Revision: https://developer.blender.org/D2130
2016-08-01 18:53:20 +03:00
{
EXPECT_ANY_MESSAGE(log);
CORRECT_INFO_MESSAGE(log, "Folding AddClosure1::Closure to socket Diffuse::BSDF.");
CORRECT_INFO_MESSAGE(log, "Folding AddClosure2::Closure to socket Diffuse::BSDF.");
INVALID_INFO_MESSAGE(log, "Folding AddClosure3");
Cycles: fix missing ShaderNode ownership in render_graph_finalize_test
2020-10-13 15:36:52 +02:00
builder.add_node(ShaderNodeBuilder<DiffuseBsdfNode>(graph, "Diffuse"))
.add_node(ShaderNodeBuilder<AddClosureNode>(graph, "AddClosure1"))
.add_node(ShaderNodeBuilder<AddClosureNode>(graph, "AddClosure2"))
.add_node(ShaderNodeBuilder<AddClosureNode>(graph, "AddClosure3"))
Cycles: add unit tests for supported constant folding rules. Code coverage of different combinations of secondary conditions is obviously not complete because there are so many of them, but all main rules should be there. The reason for CORRECT vs INVALID is that both words have the same number of characters so calls line up, but look quite different. Reviewers: #cycles, sergey Reviewed By: #cycles, sergey Subscribers: dingto, sergey, brecht Differential Revision: https://developer.blender.org/D2130
2016-08-01 18:53:20 +03:00
.add_connection("Diffuse::BSDF", "AddClosure1::Closure1")
.add_connection("Diffuse::BSDF", "AddClosure2::Closure2")
.add_connection("AddClosure1::Closure", "AddClosure3::Closure1")
.add_connection("AddClosure2::Closure", "AddClosure3::Closure2")
.output_closure("AddClosure3::Closure");
Refactor: Cycles: Replace new/delete by unique_ptr, in simple cases Pull Request: https://projects.blender.org/blender/blender/pulls/132361
2024-12-29 23:13:45 +01:00
graph.finalize(scene.get());
Cycles: add unit tests for supported constant folding rules. Code coverage of different combinations of secondary conditions is obviously not complete because there are so many of them, but all main rules should be there. The reason for CORRECT vs INVALID is that both words have the same number of characters so calls line up, but look quite different. Reviewers: #cycles, sergey Reviewed By: #cycles, sergey Subscribers: dingto, sergey, brecht Differential Revision: https://developer.blender.org/D2130
2016-08-01 18:53:20 +03:00
}
/*
* Tests:
* - Folding of Mix Closure with 0 or 1 fac.
* - Folding of Mix Closure with both inputs folded to the same node.
*/
Cycles: Fix memory leak in test and simplify code
2017-10-24 11:12:28 +02:00
TEST_F(RenderGraph, constant_fold_shader_mix)
Cycles: add unit tests for supported constant folding rules. Code coverage of different combinations of secondary conditions is obviously not complete because there are so many of them, but all main rules should be there. The reason for CORRECT vs INVALID is that both words have the same number of characters so calls line up, but look quite different. Reviewers: #cycles, sergey Reviewed By: #cycles, sergey Subscribers: dingto, sergey, brecht Differential Revision: https://developer.blender.org/D2130
2016-08-01 18:53:20 +03:00
{
EXPECT_ANY_MESSAGE(log);
CORRECT_INFO_MESSAGE(log, "Folding MixClosure1::Closure to socket Diffuse::BSDF.");
CORRECT_INFO_MESSAGE(log, "Folding MixClosure2::Closure to socket Diffuse::BSDF.");
CORRECT_INFO_MESSAGE(log, "Folding MixClosure3::Closure to socket Diffuse::BSDF.");
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
Cycles: add unit tests for supported constant folding rules. Code coverage of different combinations of secondary conditions is obviously not complete because there are so many of them, but all main rules should be there. The reason for CORRECT vs INVALID is that both words have the same number of characters so calls line up, but look quite different. Reviewers: #cycles, sergey Reviewed By: #cycles, sergey Subscribers: dingto, sergey, brecht Differential Revision: https://developer.blender.org/D2130
2016-08-01 18:53:20 +03:00
builder.add_attribute("Attribute")
Cycles: fix missing ShaderNode ownership in render_graph_finalize_test
2020-10-13 15:36:52 +02:00
.add_node(ShaderNodeBuilder<DiffuseBsdfNode>(graph, "Diffuse"))
Cycles: add unit tests for supported constant folding rules. Code coverage of different combinations of secondary conditions is obviously not complete because there are so many of them, but all main rules should be there. The reason for CORRECT vs INVALID is that both words have the same number of characters so calls line up, but look quite different. Reviewers: #cycles, sergey Reviewed By: #cycles, sergey Subscribers: dingto, sergey, brecht Differential Revision: https://developer.blender.org/D2130
2016-08-01 18:53:20 +03:00
/* choose left */
Cycles: fix missing ShaderNode ownership in render_graph_finalize_test
2020-10-13 15:36:52 +02:00
.add_node(ShaderNodeBuilder<MixClosureNode>(graph, "MixClosure1").set("Fac", 0.0f))
Cycles: add unit tests for supported constant folding rules. Code coverage of different combinations of secondary conditions is obviously not complete because there are so many of them, but all main rules should be there. The reason for CORRECT vs INVALID is that both words have the same number of characters so calls line up, but look quite different. Reviewers: #cycles, sergey Reviewed By: #cycles, sergey Subscribers: dingto, sergey, brecht Differential Revision: https://developer.blender.org/D2130
2016-08-01 18:53:20 +03:00
.add_connection("Diffuse::BSDF", "MixClosure1::Closure1")
/* choose right */
Cycles: fix missing ShaderNode ownership in render_graph_finalize_test
2020-10-13 15:36:52 +02:00
.add_node(ShaderNodeBuilder<MixClosureNode>(graph, "MixClosure2").set("Fac", 1.0f))
Cycles: add unit tests for supported constant folding rules. Code coverage of different combinations of secondary conditions is obviously not complete because there are so many of them, but all main rules should be there. The reason for CORRECT vs INVALID is that both words have the same number of characters so calls line up, but look quite different. Reviewers: #cycles, sergey Reviewed By: #cycles, sergey Subscribers: dingto, sergey, brecht Differential Revision: https://developer.blender.org/D2130
2016-08-01 18:53:20 +03:00
.add_connection("Diffuse::BSDF", "MixClosure2::Closure2")
/* both inputs folded the same */
Cycles: fix missing ShaderNode ownership in render_graph_finalize_test
2020-10-13 15:36:52 +02:00
.add_node(ShaderNodeBuilder<MixClosureNode>(graph, "MixClosure3"))
Cycles: add unit tests for supported constant folding rules. Code coverage of different combinations of secondary conditions is obviously not complete because there are so many of them, but all main rules should be there. The reason for CORRECT vs INVALID is that both words have the same number of characters so calls line up, but look quite different. Reviewers: #cycles, sergey Reviewed By: #cycles, sergey Subscribers: dingto, sergey, brecht Differential Revision: https://developer.blender.org/D2130
2016-08-01 18:53:20 +03:00
.add_connection("Attribute::Fac", "MixClosure3::Fac")
.add_connection("MixClosure1::Closure", "MixClosure3::Closure1")
.add_connection("MixClosure2::Closure", "MixClosure3::Closure2")
.output_closure("MixClosure3::Closure");
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
Refactor: Cycles: Replace new/delete by unique_ptr, in simple cases Pull Request: https://projects.blender.org/blender/blender/pulls/132361
2024-12-29 23:13:45 +01:00
graph.finalize(scene.get());
Cycles: add unit tests for supported constant folding rules. Code coverage of different combinations of secondary conditions is obviously not complete because there are so many of them, but all main rules should be there. The reason for CORRECT vs INVALID is that both words have the same number of characters so calls line up, but look quite different. Reviewers: #cycles, sergey Reviewed By: #cycles, sergey Subscribers: dingto, sergey, brecht Differential Revision: https://developer.blender.org/D2130
2016-08-01 18:53:20 +03:00
}
/*
* Tests:
* - Folding of Invert with all constant inputs.
*/
Cycles: Fix memory leak in test and simplify code
2017-10-24 11:12:28 +02:00
TEST_F(RenderGraph, constant_fold_invert)
Cycles: add unit tests for supported constant folding rules. Code coverage of different combinations of secondary conditions is obviously not complete because there are so many of them, but all main rules should be there. The reason for CORRECT vs INVALID is that both words have the same number of characters so calls line up, but look quite different. Reviewers: #cycles, sergey Reviewed By: #cycles, sergey Subscribers: dingto, sergey, brecht Differential Revision: https://developer.blender.org/D2130
2016-08-01 18:53:20 +03:00
{
EXPECT_ANY_MESSAGE(log);
CORRECT_INFO_MESSAGE(log, "Folding Invert::Color to constant (0.68, 0.5, 0.32).");
builder
Cycles: fix missing ShaderNode ownership in render_graph_finalize_test
2020-10-13 15:36:52 +02:00
.add_node(ShaderNodeBuilder<InvertNode>(graph, "Invert")
Cycles: add unit tests for supported constant folding rules. Code coverage of different combinations of secondary conditions is obviously not complete because there are so many of them, but all main rules should be there. The reason for CORRECT vs INVALID is that both words have the same number of characters so calls line up, but look quite different. Reviewers: #cycles, sergey Reviewed By: #cycles, sergey Subscribers: dingto, sergey, brecht Differential Revision: https://developer.blender.org/D2130
2016-08-01 18:53:20 +03:00
.set("Fac", 0.8f)
.set("Color", make_float3(0.2f, 0.5f, 0.8f)))
.output_color("Invert::Color");
Refactor: Cycles: Replace new/delete by unique_ptr, in simple cases Pull Request: https://projects.blender.org/blender/blender/pulls/132361
2024-12-29 23:13:45 +01:00
graph.finalize(scene.get());
Cycles: add unit tests for supported constant folding rules. Code coverage of different combinations of secondary conditions is obviously not complete because there are so many of them, but all main rules should be there. The reason for CORRECT vs INVALID is that both words have the same number of characters so calls line up, but look quite different. Reviewers: #cycles, sergey Reviewed By: #cycles, sergey Subscribers: dingto, sergey, brecht Differential Revision: https://developer.blender.org/D2130
2016-08-01 18:53:20 +03:00
}
/*
* Tests:
* - Folding of Invert with zero Fac.
*/
Cycles: Fix memory leak in test and simplify code
2017-10-24 11:12:28 +02:00
TEST_F(RenderGraph, constant_fold_invert_fac_0)
Cycles: add unit tests for supported constant folding rules. Code coverage of different combinations of secondary conditions is obviously not complete because there are so many of them, but all main rules should be there. The reason for CORRECT vs INVALID is that both words have the same number of characters so calls line up, but look quite different. Reviewers: #cycles, sergey Reviewed By: #cycles, sergey Subscribers: dingto, sergey, brecht Differential Revision: https://developer.blender.org/D2130
2016-08-01 18:53:20 +03:00
{
EXPECT_ANY_MESSAGE(log);
CORRECT_INFO_MESSAGE(log, "Folding Invert::Color to socket Attribute::Color.");
builder.add_attribute("Attribute")
Cycles: fix missing ShaderNode ownership in render_graph_finalize_test
2020-10-13 15:36:52 +02:00
.add_node(ShaderNodeBuilder<InvertNode>(graph, "Invert").set("Fac", 0.0f))
Cycles: add unit tests for supported constant folding rules. Code coverage of different combinations of secondary conditions is obviously not complete because there are so many of them, but all main rules should be there. The reason for CORRECT vs INVALID is that both words have the same number of characters so calls line up, but look quite different. Reviewers: #cycles, sergey Reviewed By: #cycles, sergey Subscribers: dingto, sergey, brecht Differential Revision: https://developer.blender.org/D2130
2016-08-01 18:53:20 +03:00
.add_connection("Attribute::Color", "Invert::Color")
.output_color("Invert::Color");
Refactor: Cycles: Replace new/delete by unique_ptr, in simple cases Pull Request: https://projects.blender.org/blender/blender/pulls/132361
2024-12-29 23:13:45 +01:00
graph.finalize(scene.get());
Cycles: add unit tests for supported constant folding rules. Code coverage of different combinations of secondary conditions is obviously not complete because there are so many of them, but all main rules should be there. The reason for CORRECT vs INVALID is that both words have the same number of characters so calls line up, but look quite different. Reviewers: #cycles, sergey Reviewed By: #cycles, sergey Subscribers: dingto, sergey, brecht Differential Revision: https://developer.blender.org/D2130
2016-08-01 18:53:20 +03:00
}
Fix T49136: full constant Curves with zero Fac input crashes in assert. The if branches were reordered when the original patch was committed, which broke the implicit non-NULL guarantee on link. To prevent re-occurrence, add a couple of unit tests.
2016-08-22 11:11:45 +03:00
/*
* Tests:
* - Folding of Invert with zero Fac and constant input.
*/
Cycles: Fix memory leak in test and simplify code
2017-10-24 11:12:28 +02:00
TEST_F(RenderGraph, constant_fold_invert_fac_0_const)
Fix T49136: full constant Curves with zero Fac input crashes in assert. The if branches were reordered when the original patch was committed, which broke the implicit non-NULL guarantee on link. To prevent re-occurrence, add a couple of unit tests.
2016-08-22 11:11:45 +03:00
{
EXPECT_ANY_MESSAGE(log);
CORRECT_INFO_MESSAGE(log, "Folding Invert::Color to constant (0.2, 0.5, 0.8).");
builder
Cycles: fix missing ShaderNode ownership in render_graph_finalize_test
2020-10-13 15:36:52 +02:00
.add_node(ShaderNodeBuilder<InvertNode>(graph, "Invert")
Fix T49136: full constant Curves with zero Fac input crashes in assert. The if branches were reordered when the original patch was committed, which broke the implicit non-NULL guarantee on link. To prevent re-occurrence, add a couple of unit tests.
2016-08-22 11:11:45 +03:00
.set("Fac", 0.0f)
.set("Color", make_float3(0.2f, 0.5f, 0.8f)))
.output_color("Invert::Color");
Refactor: Cycles: Replace new/delete by unique_ptr, in simple cases Pull Request: https://projects.blender.org/blender/blender/pulls/132361
2024-12-29 23:13:45 +01:00
graph.finalize(scene.get());
Fix T49136: full constant Curves with zero Fac input crashes in assert. The if branches were reordered when the original patch was committed, which broke the implicit non-NULL guarantee on link. To prevent re-occurrence, add a couple of unit tests.
2016-08-22 11:11:45 +03:00
}
Cycles: add unit tests for supported constant folding rules. Code coverage of different combinations of secondary conditions is obviously not complete because there are so many of them, but all main rules should be there. The reason for CORRECT vs INVALID is that both words have the same number of characters so calls line up, but look quite different. Reviewers: #cycles, sergey Reviewed By: #cycles, sergey Subscribers: dingto, sergey, brecht Differential Revision: https://developer.blender.org/D2130
2016-08-01 18:53:20 +03:00
/*
* Tests:
* - Folding of MixRGB Add with all constant inputs (clamp false).
*/
Cycles: Fix memory leak in test and simplify code
2017-10-24 11:12:28 +02:00
TEST_F(RenderGraph, constant_fold_mix_add)
Cycles: add unit tests for supported constant folding rules. Code coverage of different combinations of secondary conditions is obviously not complete because there are so many of them, but all main rules should be there. The reason for CORRECT vs INVALID is that both words have the same number of characters so calls line up, but look quite different. Reviewers: #cycles, sergey Reviewed By: #cycles, sergey Subscribers: dingto, sergey, brecht Differential Revision: https://developer.blender.org/D2130
2016-08-01 18:53:20 +03:00
{
EXPECT_ANY_MESSAGE(log);
CORRECT_INFO_MESSAGE(log, "Folding MixAdd::Color to constant (0.62, 1.14, 1.42).");
builder
Cycles: fix missing ShaderNode ownership in render_graph_finalize_test
2020-10-13 15:36:52 +02:00
.add_node(ShaderNodeBuilder<MixNode>(graph, "MixAdd")
Cycles API: encapsulate Node socket members This encapsulates Node socket members behind a set of specific methods; as such it is no longer possible to directly access Node class members from exporters and parts of Cycles. The methods are defined via the NODE_SOCKET_API macros in `graph/ node.h`, and are for getting or setting a specific socket's value, as well as querying or modifying the state of its update flag. The setters will check whether the value has changed and tag the socket as modified appropriately. This will let us know how a Node has changed and what to update, which is the first concrete step toward a more granular scene update system. Since the setters will tag the Node sockets as modified when passed different data, this patch also removes the various modified methods on Nodes in favor of Node::is_modified which checks the sockets' update flags status. Reviewed By: brecht Maniphest Tasks: T79174 Differential Revision: https://developer.blender.org/D8544
2020-11-04 11:17:38 +01:00
.set_param("mix_type", NODE_MIX_ADD)
.set_param("use_clamp", false)
Cycles: add unit tests for supported constant folding rules. Code coverage of different combinations of secondary conditions is obviously not complete because there are so many of them, but all main rules should be there. The reason for CORRECT vs INVALID is that both words have the same number of characters so calls line up, but look quite different. Reviewers: #cycles, sergey Reviewed By: #cycles, sergey Subscribers: dingto, sergey, brecht Differential Revision: https://developer.blender.org/D2130
2016-08-01 18:53:20 +03:00
.set("Fac", 0.8f)
Fix build error on macOS after recent changes
2020-09-04 19:23:51 +02:00
.set("Color1", make_float3(0.3f, 0.5f, 0.7f))
.set("Color2", make_float3(0.4f, 0.8f, 0.9f)))
Cycles: add unit tests for supported constant folding rules. Code coverage of different combinations of secondary conditions is obviously not complete because there are so many of them, but all main rules should be there. The reason for CORRECT vs INVALID is that both words have the same number of characters so calls line up, but look quite different. Reviewers: #cycles, sergey Reviewed By: #cycles, sergey Subscribers: dingto, sergey, brecht Differential Revision: https://developer.blender.org/D2130
2016-08-01 18:53:20 +03:00
.output_color("MixAdd::Color");
Refactor: Cycles: Replace new/delete by unique_ptr, in simple cases Pull Request: https://projects.blender.org/blender/blender/pulls/132361
2024-12-29 23:13:45 +01:00
graph.finalize(scene.get());
Cycles: add unit tests for supported constant folding rules. Code coverage of different combinations of secondary conditions is obviously not complete because there are so many of them, but all main rules should be there. The reason for CORRECT vs INVALID is that both words have the same number of characters so calls line up, but look quite different. Reviewers: #cycles, sergey Reviewed By: #cycles, sergey Subscribers: dingto, sergey, brecht Differential Revision: https://developer.blender.org/D2130
2016-08-01 18:53:20 +03:00
}
/*
* Tests:
* - Folding of MixRGB Add with all constant inputs (clamp true).
*/
Cycles: Fix memory leak in test and simplify code
2017-10-24 11:12:28 +02:00
TEST_F(RenderGraph, constant_fold_mix_add_clamp)
Cycles: add unit tests for supported constant folding rules. Code coverage of different combinations of secondary conditions is obviously not complete because there are so many of them, but all main rules should be there. The reason for CORRECT vs INVALID is that both words have the same number of characters so calls line up, but look quite different. Reviewers: #cycles, sergey Reviewed By: #cycles, sergey Subscribers: dingto, sergey, brecht Differential Revision: https://developer.blender.org/D2130
2016-08-01 18:53:20 +03:00
{
EXPECT_ANY_MESSAGE(log);
CORRECT_INFO_MESSAGE(log, "Folding MixAdd::Color to constant (0.62, 1, 1).");
builder
Cycles: fix missing ShaderNode ownership in render_graph_finalize_test
2020-10-13 15:36:52 +02:00
.add_node(ShaderNodeBuilder<MixNode>(graph, "MixAdd")
Cycles API: encapsulate Node socket members This encapsulates Node socket members behind a set of specific methods; as such it is no longer possible to directly access Node class members from exporters and parts of Cycles. The methods are defined via the NODE_SOCKET_API macros in `graph/ node.h`, and are for getting or setting a specific socket's value, as well as querying or modifying the state of its update flag. The setters will check whether the value has changed and tag the socket as modified appropriately. This will let us know how a Node has changed and what to update, which is the first concrete step toward a more granular scene update system. Since the setters will tag the Node sockets as modified when passed different data, this patch also removes the various modified methods on Nodes in favor of Node::is_modified which checks the sockets' update flags status. Reviewed By: brecht Maniphest Tasks: T79174 Differential Revision: https://developer.blender.org/D8544
2020-11-04 11:17:38 +01:00
.set_param("mix_type", NODE_MIX_ADD)
.set_param("use_clamp", true)
Cycles: add unit tests for supported constant folding rules. Code coverage of different combinations of secondary conditions is obviously not complete because there are so many of them, but all main rules should be there. The reason for CORRECT vs INVALID is that both words have the same number of characters so calls line up, but look quite different. Reviewers: #cycles, sergey Reviewed By: #cycles, sergey Subscribers: dingto, sergey, brecht Differential Revision: https://developer.blender.org/D2130
2016-08-01 18:53:20 +03:00
.set("Fac", 0.8f)
Fix build error on macOS after recent changes
2020-09-04 19:23:51 +02:00
.set("Color1", make_float3(0.3f, 0.5f, 0.7f))
.set("Color2", make_float3(0.4f, 0.8f, 0.9f)))
Cycles: add unit tests for supported constant folding rules. Code coverage of different combinations of secondary conditions is obviously not complete because there are so many of them, but all main rules should be there. The reason for CORRECT vs INVALID is that both words have the same number of characters so calls line up, but look quite different. Reviewers: #cycles, sergey Reviewed By: #cycles, sergey Subscribers: dingto, sergey, brecht Differential Revision: https://developer.blender.org/D2130
2016-08-01 18:53:20 +03:00
.output_color("MixAdd::Color");
Refactor: Cycles: Replace new/delete by unique_ptr, in simple cases Pull Request: https://projects.blender.org/blender/blender/pulls/132361
2024-12-29 23:13:45 +01:00
graph.finalize(scene.get());
Cycles: add unit tests for supported constant folding rules. Code coverage of different combinations of secondary conditions is obviously not complete because there are so many of them, but all main rules should be there. The reason for CORRECT vs INVALID is that both words have the same number of characters so calls line up, but look quite different. Reviewers: #cycles, sergey Reviewed By: #cycles, sergey Subscribers: dingto, sergey, brecht Differential Revision: https://developer.blender.org/D2130
2016-08-01 18:53:20 +03:00
}
/*
* Tests:
* - No folding on fac 0 for dodge.
*/
Cycles: Fix memory leak in test and simplify code
2017-10-24 11:12:28 +02:00
TEST_F(RenderGraph, constant_fold_part_mix_dodge_no_fac_0)
Cycles: add unit tests for supported constant folding rules. Code coverage of different combinations of secondary conditions is obviously not complete because there are so many of them, but all main rules should be there. The reason for CORRECT vs INVALID is that both words have the same number of characters so calls line up, but look quite different. Reviewers: #cycles, sergey Reviewed By: #cycles, sergey Subscribers: dingto, sergey, brecht Differential Revision: https://developer.blender.org/D2130
2016-08-01 18:53:20 +03:00
{
EXPECT_ANY_MESSAGE(log);
INVALID_INFO_MESSAGE(log, "Folding ");
builder.add_attribute("Attribute1")
.add_attribute("Attribute2")
Cycles: fix missing ShaderNode ownership in render_graph_finalize_test
2020-10-13 15:36:52 +02:00
.add_node(ShaderNodeBuilder<MixNode>(graph, "Mix")
Cycles API: encapsulate Node socket members This encapsulates Node socket members behind a set of specific methods; as such it is no longer possible to directly access Node class members from exporters and parts of Cycles. The methods are defined via the NODE_SOCKET_API macros in `graph/ node.h`, and are for getting or setting a specific socket's value, as well as querying or modifying the state of its update flag. The setters will check whether the value has changed and tag the socket as modified appropriately. This will let us know how a Node has changed and what to update, which is the first concrete step toward a more granular scene update system. Since the setters will tag the Node sockets as modified when passed different data, this patch also removes the various modified methods on Nodes in favor of Node::is_modified which checks the sockets' update flags status. Reviewed By: brecht Maniphest Tasks: T79174 Differential Revision: https://developer.blender.org/D8544
2020-11-04 11:17:38 +01:00
.set_param("mix_type", NODE_MIX_DODGE)
.set_param("use_clamp", false)
Cycles: add unit tests for supported constant folding rules. Code coverage of different combinations of secondary conditions is obviously not complete because there are so many of them, but all main rules should be there. The reason for CORRECT vs INVALID is that both words have the same number of characters so calls line up, but look quite different. Reviewers: #cycles, sergey Reviewed By: #cycles, sergey Subscribers: dingto, sergey, brecht Differential Revision: https://developer.blender.org/D2130
2016-08-01 18:53:20 +03:00
.set("Fac", 0.0f))
.add_connection("Attribute1::Color", "Mix::Color1")
.add_connection("Attribute2::Color", "Mix::Color2")
.output_color("Mix::Color");
Refactor: Cycles: Replace new/delete by unique_ptr, in simple cases Pull Request: https://projects.blender.org/blender/blender/pulls/132361
2024-12-29 23:13:45 +01:00
graph.finalize(scene.get());
Cycles: add unit tests for supported constant folding rules. Code coverage of different combinations of secondary conditions is obviously not complete because there are so many of them, but all main rules should be there. The reason for CORRECT vs INVALID is that both words have the same number of characters so calls line up, but look quite different. Reviewers: #cycles, sergey Reviewed By: #cycles, sergey Subscribers: dingto, sergey, brecht Differential Revision: https://developer.blender.org/D2130
2016-08-01 18:53:20 +03:00
}
/*
* Tests:
* - No folding on fac 0 for light.
*/
Cycles: Fix memory leak in test and simplify code
2017-10-24 11:12:28 +02:00
TEST_F(RenderGraph, constant_fold_part_mix_light_no_fac_0)
Cycles: add unit tests for supported constant folding rules. Code coverage of different combinations of secondary conditions is obviously not complete because there are so many of them, but all main rules should be there. The reason for CORRECT vs INVALID is that both words have the same number of characters so calls line up, but look quite different. Reviewers: #cycles, sergey Reviewed By: #cycles, sergey Subscribers: dingto, sergey, brecht Differential Revision: https://developer.blender.org/D2130
2016-08-01 18:53:20 +03:00
{
EXPECT_ANY_MESSAGE(log);
INVALID_INFO_MESSAGE(log, "Folding ");
builder.add_attribute("Attribute1")
.add_attribute("Attribute2")
Cycles: fix missing ShaderNode ownership in render_graph_finalize_test
2020-10-13 15:36:52 +02:00
.add_node(ShaderNodeBuilder<MixNode>(graph, "Mix")
Cycles API: encapsulate Node socket members This encapsulates Node socket members behind a set of specific methods; as such it is no longer possible to directly access Node class members from exporters and parts of Cycles. The methods are defined via the NODE_SOCKET_API macros in `graph/ node.h`, and are for getting or setting a specific socket's value, as well as querying or modifying the state of its update flag. The setters will check whether the value has changed and tag the socket as modified appropriately. This will let us know how a Node has changed and what to update, which is the first concrete step toward a more granular scene update system. Since the setters will tag the Node sockets as modified when passed different data, this patch also removes the various modified methods on Nodes in favor of Node::is_modified which checks the sockets' update flags status. Reviewed By: brecht Maniphest Tasks: T79174 Differential Revision: https://developer.blender.org/D8544
2020-11-04 11:17:38 +01:00
.set_param("mix_type", NODE_MIX_LIGHT)
.set_param("use_clamp", false)
Cycles: add unit tests for supported constant folding rules. Code coverage of different combinations of secondary conditions is obviously not complete because there are so many of them, but all main rules should be there. The reason for CORRECT vs INVALID is that both words have the same number of characters so calls line up, but look quite different. Reviewers: #cycles, sergey Reviewed By: #cycles, sergey Subscribers: dingto, sergey, brecht Differential Revision: https://developer.blender.org/D2130
2016-08-01 18:53:20 +03:00
.set("Fac", 0.0f))
.add_connection("Attribute1::Color", "Mix::Color1")
.add_connection("Attribute2::Color", "Mix::Color2")
.output_color("Mix::Color");
Refactor: Cycles: Replace new/delete by unique_ptr, in simple cases Pull Request: https://projects.blender.org/blender/blender/pulls/132361
2024-12-29 23:13:45 +01:00
graph.finalize(scene.get());
Cycles: add unit tests for supported constant folding rules. Code coverage of different combinations of secondary conditions is obviously not complete because there are so many of them, but all main rules should be there. The reason for CORRECT vs INVALID is that both words have the same number of characters so calls line up, but look quite different. Reviewers: #cycles, sergey Reviewed By: #cycles, sergey Subscribers: dingto, sergey, brecht Differential Revision: https://developer.blender.org/D2130
2016-08-01 18:53:20 +03:00
}
/*
* Tests:
* - No folding on fac 0 for burn.
*/
Cycles: Fix memory leak in test and simplify code
2017-10-24 11:12:28 +02:00
TEST_F(RenderGraph, constant_fold_part_mix_burn_no_fac_0)
Cycles: add unit tests for supported constant folding rules. Code coverage of different combinations of secondary conditions is obviously not complete because there are so many of them, but all main rules should be there. The reason for CORRECT vs INVALID is that both words have the same number of characters so calls line up, but look quite different. Reviewers: #cycles, sergey Reviewed By: #cycles, sergey Subscribers: dingto, sergey, brecht Differential Revision: https://developer.blender.org/D2130
2016-08-01 18:53:20 +03:00
{
EXPECT_ANY_MESSAGE(log);
INVALID_INFO_MESSAGE(log, "Folding ");
builder.add_attribute("Attribute1")
.add_attribute("Attribute2")
Cycles: fix missing ShaderNode ownership in render_graph_finalize_test
2020-10-13 15:36:52 +02:00
.add_node(ShaderNodeBuilder<MixNode>(graph, "Mix")
Cycles API: encapsulate Node socket members This encapsulates Node socket members behind a set of specific methods; as such it is no longer possible to directly access Node class members from exporters and parts of Cycles. The methods are defined via the NODE_SOCKET_API macros in `graph/ node.h`, and are for getting or setting a specific socket's value, as well as querying or modifying the state of its update flag. The setters will check whether the value has changed and tag the socket as modified appropriately. This will let us know how a Node has changed and what to update, which is the first concrete step toward a more granular scene update system. Since the setters will tag the Node sockets as modified when passed different data, this patch also removes the various modified methods on Nodes in favor of Node::is_modified which checks the sockets' update flags status. Reviewed By: brecht Maniphest Tasks: T79174 Differential Revision: https://developer.blender.org/D8544
2020-11-04 11:17:38 +01:00
.set_param("mix_type", NODE_MIX_BURN)
.set_param("use_clamp", false)
Cycles: add unit tests for supported constant folding rules. Code coverage of different combinations of secondary conditions is obviously not complete because there are so many of them, but all main rules should be there. The reason for CORRECT vs INVALID is that both words have the same number of characters so calls line up, but look quite different. Reviewers: #cycles, sergey Reviewed By: #cycles, sergey Subscribers: dingto, sergey, brecht Differential Revision: https://developer.blender.org/D2130
2016-08-01 18:53:20 +03:00
.set("Fac", 0.0f))
.add_connection("Attribute1::Color", "Mix::Color1")
.add_connection("Attribute2::Color", "Mix::Color2")
.output_color("Mix::Color");
Refactor: Cycles: Replace new/delete by unique_ptr, in simple cases Pull Request: https://projects.blender.org/blender/blender/pulls/132361
2024-12-29 23:13:45 +01:00
graph.finalize(scene.get());
Cycles: add unit tests for supported constant folding rules. Code coverage of different combinations of secondary conditions is obviously not complete because there are so many of them, but all main rules should be there. The reason for CORRECT vs INVALID is that both words have the same number of characters so calls line up, but look quite different. Reviewers: #cycles, sergey Reviewed By: #cycles, sergey Subscribers: dingto, sergey, brecht Differential Revision: https://developer.blender.org/D2130
2016-08-01 18:53:20 +03:00
}
/*
* Tests:
* - No folding on fac 0 for clamped blend.
*/
Cycles: Fix memory leak in test and simplify code
2017-10-24 11:12:28 +02:00
TEST_F(RenderGraph, constant_fold_part_mix_blend_clamped_no_fac_0)
Cycles: add unit tests for supported constant folding rules. Code coverage of different combinations of secondary conditions is obviously not complete because there are so many of them, but all main rules should be there. The reason for CORRECT vs INVALID is that both words have the same number of characters so calls line up, but look quite different. Reviewers: #cycles, sergey Reviewed By: #cycles, sergey Subscribers: dingto, sergey, brecht Differential Revision: https://developer.blender.org/D2130
2016-08-01 18:53:20 +03:00
{
EXPECT_ANY_MESSAGE(log);
INVALID_INFO_MESSAGE(log, "Folding ");
builder.add_attribute("Attribute1")
.add_attribute("Attribute2")
Cycles: fix missing ShaderNode ownership in render_graph_finalize_test
2020-10-13 15:36:52 +02:00
.add_node(ShaderNodeBuilder<MixNode>(graph, "Mix")
Cycles API: encapsulate Node socket members This encapsulates Node socket members behind a set of specific methods; as such it is no longer possible to directly access Node class members from exporters and parts of Cycles. The methods are defined via the NODE_SOCKET_API macros in `graph/ node.h`, and are for getting or setting a specific socket's value, as well as querying or modifying the state of its update flag. The setters will check whether the value has changed and tag the socket as modified appropriately. This will let us know how a Node has changed and what to update, which is the first concrete step toward a more granular scene update system. Since the setters will tag the Node sockets as modified when passed different data, this patch also removes the various modified methods on Nodes in favor of Node::is_modified which checks the sockets' update flags status. Reviewed By: brecht Maniphest Tasks: T79174 Differential Revision: https://developer.blender.org/D8544
2020-11-04 11:17:38 +01:00
.set_param("mix_type", NODE_MIX_BLEND)
.set_param("use_clamp", true)
Cycles: add unit tests for supported constant folding rules. Code coverage of different combinations of secondary conditions is obviously not complete because there are so many of them, but all main rules should be there. The reason for CORRECT vs INVALID is that both words have the same number of characters so calls line up, but look quite different. Reviewers: #cycles, sergey Reviewed By: #cycles, sergey Subscribers: dingto, sergey, brecht Differential Revision: https://developer.blender.org/D2130
2016-08-01 18:53:20 +03:00
.set("Fac", 0.0f))
.add_connection("Attribute1::Color", "Mix::Color1")
.add_connection("Attribute2::Color", "Mix::Color2")
.output_color("Mix::Color");
Refactor: Cycles: Replace new/delete by unique_ptr, in simple cases Pull Request: https://projects.blender.org/blender/blender/pulls/132361
2024-12-29 23:13:45 +01:00
graph.finalize(scene.get());
Cycles: add unit tests for supported constant folding rules. Code coverage of different combinations of secondary conditions is obviously not complete because there are so many of them, but all main rules should be there. The reason for CORRECT vs INVALID is that both words have the same number of characters so calls line up, but look quite different. Reviewers: #cycles, sergey Reviewed By: #cycles, sergey Subscribers: dingto, sergey, brecht Differential Revision: https://developer.blender.org/D2130
2016-08-01 18:53:20 +03:00
}
/*
* Tests:
* - Folding of Mix with 0 or 1 Fac.
* - Folding of Mix with both inputs folded to the same node.
*/
Cycles: Fix memory leak in test and simplify code
2017-10-24 11:12:28 +02:00
TEST_F(RenderGraph, constant_fold_part_mix_blend)
Cycles: add unit tests for supported constant folding rules. Code coverage of different combinations of secondary conditions is obviously not complete because there are so many of them, but all main rules should be there. The reason for CORRECT vs INVALID is that both words have the same number of characters so calls line up, but look quite different. Reviewers: #cycles, sergey Reviewed By: #cycles, sergey Subscribers: dingto, sergey, brecht Differential Revision: https://developer.blender.org/D2130
2016-08-01 18:53:20 +03:00
{
EXPECT_ANY_MESSAGE(log);
CORRECT_INFO_MESSAGE(log, "Folding MixBlend1::Color to socket Attribute1::Color.");
CORRECT_INFO_MESSAGE(log, "Folding MixBlend2::Color to socket Attribute1::Color.");
CORRECT_INFO_MESSAGE(log, "Folding MixBlend3::Color to socket Attribute1::Color.");
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
Cycles: add unit tests for supported constant folding rules. Code coverage of different combinations of secondary conditions is obviously not complete because there are so many of them, but all main rules should be there. The reason for CORRECT vs INVALID is that both words have the same number of characters so calls line up, but look quite different. Reviewers: #cycles, sergey Reviewed By: #cycles, sergey Subscribers: dingto, sergey, brecht Differential Revision: https://developer.blender.org/D2130
2016-08-01 18:53:20 +03:00
builder.add_attribute("Attribute1")
.add_attribute("Attribute2")
/* choose left */
Cycles: fix missing ShaderNode ownership in render_graph_finalize_test
2020-10-13 15:36:52 +02:00
.add_node(ShaderNodeBuilder<MixNode>(graph, "MixBlend1")
Cycles API: encapsulate Node socket members This encapsulates Node socket members behind a set of specific methods; as such it is no longer possible to directly access Node class members from exporters and parts of Cycles. The methods are defined via the NODE_SOCKET_API macros in `graph/ node.h`, and are for getting or setting a specific socket's value, as well as querying or modifying the state of its update flag. The setters will check whether the value has changed and tag the socket as modified appropriately. This will let us know how a Node has changed and what to update, which is the first concrete step toward a more granular scene update system. Since the setters will tag the Node sockets as modified when passed different data, this patch also removes the various modified methods on Nodes in favor of Node::is_modified which checks the sockets' update flags status. Reviewed By: brecht Maniphest Tasks: T79174 Differential Revision: https://developer.blender.org/D8544
2020-11-04 11:17:38 +01:00
.set_param("mix_type", NODE_MIX_BLEND)
.set_param("use_clamp", false)
Cycles: add unit tests for supported constant folding rules. Code coverage of different combinations of secondary conditions is obviously not complete because there are so many of them, but all main rules should be there. The reason for CORRECT vs INVALID is that both words have the same number of characters so calls line up, but look quite different. Reviewers: #cycles, sergey Reviewed By: #cycles, sergey Subscribers: dingto, sergey, brecht Differential Revision: https://developer.blender.org/D2130
2016-08-01 18:53:20 +03:00
.set("Fac", 0.0f))
.add_connection("Attribute1::Color", "MixBlend1::Color1")
.add_connection("Attribute2::Color", "MixBlend1::Color2")
/* choose right */
Cycles: fix missing ShaderNode ownership in render_graph_finalize_test
2020-10-13 15:36:52 +02:00
.add_node(ShaderNodeBuilder<MixNode>(graph, "MixBlend2")
Cycles API: encapsulate Node socket members This encapsulates Node socket members behind a set of specific methods; as such it is no longer possible to directly access Node class members from exporters and parts of Cycles. The methods are defined via the NODE_SOCKET_API macros in `graph/ node.h`, and are for getting or setting a specific socket's value, as well as querying or modifying the state of its update flag. The setters will check whether the value has changed and tag the socket as modified appropriately. This will let us know how a Node has changed and what to update, which is the first concrete step toward a more granular scene update system. Since the setters will tag the Node sockets as modified when passed different data, this patch also removes the various modified methods on Nodes in favor of Node::is_modified which checks the sockets' update flags status. Reviewed By: brecht Maniphest Tasks: T79174 Differential Revision: https://developer.blender.org/D8544
2020-11-04 11:17:38 +01:00
.set_param("mix_type", NODE_MIX_BLEND)
.set_param("use_clamp", false)
Cycles: add unit tests for supported constant folding rules. Code coverage of different combinations of secondary conditions is obviously not complete because there are so many of them, but all main rules should be there. The reason for CORRECT vs INVALID is that both words have the same number of characters so calls line up, but look quite different. Reviewers: #cycles, sergey Reviewed By: #cycles, sergey Subscribers: dingto, sergey, brecht Differential Revision: https://developer.blender.org/D2130
2016-08-01 18:53:20 +03:00
.set("Fac", 1.0f))
.add_connection("Attribute1::Color", "MixBlend2::Color2")
.add_connection("Attribute2::Color", "MixBlend2::Color1")
/* both inputs folded to Attribute1 */
Cycles: fix missing ShaderNode ownership in render_graph_finalize_test
2020-10-13 15:36:52 +02:00
.add_node(ShaderNodeBuilder<MixNode>(graph, "MixBlend3")
Cycles API: encapsulate Node socket members This encapsulates Node socket members behind a set of specific methods; as such it is no longer possible to directly access Node class members from exporters and parts of Cycles. The methods are defined via the NODE_SOCKET_API macros in `graph/ node.h`, and are for getting or setting a specific socket's value, as well as querying or modifying the state of its update flag. The setters will check whether the value has changed and tag the socket as modified appropriately. This will let us know how a Node has changed and what to update, which is the first concrete step toward a more granular scene update system. Since the setters will tag the Node sockets as modified when passed different data, this patch also removes the various modified methods on Nodes in favor of Node::is_modified which checks the sockets' update flags status. Reviewed By: brecht Maniphest Tasks: T79174 Differential Revision: https://developer.blender.org/D8544
2020-11-04 11:17:38 +01:00
.set_param("mix_type", NODE_MIX_BLEND)
.set_param("use_clamp", false))
Cycles: add unit tests for supported constant folding rules. Code coverage of different combinations of secondary conditions is obviously not complete because there are so many of them, but all main rules should be there. The reason for CORRECT vs INVALID is that both words have the same number of characters so calls line up, but look quite different. Reviewers: #cycles, sergey Reviewed By: #cycles, sergey Subscribers: dingto, sergey, brecht Differential Revision: https://developer.blender.org/D2130
2016-08-01 18:53:20 +03:00
.add_connection("Attribute1::Fac", "MixBlend3::Fac")
.add_connection("MixBlend1::Color", "MixBlend3::Color1")
.add_connection("MixBlend2::Color", "MixBlend3::Color2")
.output_color("MixBlend3::Color");
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
Refactor: Cycles: Replace new/delete by unique_ptr, in simple cases Pull Request: https://projects.blender.org/blender/blender/pulls/132361
2024-12-29 23:13:45 +01:00
graph.finalize(scene.get());
Cycles: add unit tests for supported constant folding rules. Code coverage of different combinations of secondary conditions is obviously not complete because there are so many of them, but all main rules should be there. The reason for CORRECT vs INVALID is that both words have the same number of characters so calls line up, but look quite different. Reviewers: #cycles, sergey Reviewed By: #cycles, sergey Subscribers: dingto, sergey, brecht Differential Revision: https://developer.blender.org/D2130
2016-08-01 18:53:20 +03:00
}
/*
* Tests:
Cleanup: spelling in comments
2023-08-25 08:56:58 +10:00
* - NOT folding of MixRGB Subtract with the same inputs and fac NOT 1.
Cycles: add unit tests for supported constant folding rules. Code coverage of different combinations of secondary conditions is obviously not complete because there are so many of them, but all main rules should be there. The reason for CORRECT vs INVALID is that both words have the same number of characters so calls line up, but look quite different. Reviewers: #cycles, sergey Reviewed By: #cycles, sergey Subscribers: dingto, sergey, brecht Differential Revision: https://developer.blender.org/D2130
2016-08-01 18:53:20 +03:00
*/
Cycles: Fix memory leak in test and simplify code
2017-10-24 11:12:28 +02:00
TEST_F(RenderGraph, constant_fold_part_mix_sub_same_fac_bad)
Cycles: add unit tests for supported constant folding rules. Code coverage of different combinations of secondary conditions is obviously not complete because there are so many of them, but all main rules should be there. The reason for CORRECT vs INVALID is that both words have the same number of characters so calls line up, but look quite different. Reviewers: #cycles, sergey Reviewed By: #cycles, sergey Subscribers: dingto, sergey, brecht Differential Revision: https://developer.blender.org/D2130
2016-08-01 18:53:20 +03:00
{
EXPECT_ANY_MESSAGE(log);
INVALID_INFO_MESSAGE(log, "Folding Mix::");
builder.add_attribute("Attribute")
Cycles: fix missing ShaderNode ownership in render_graph_finalize_test
2020-10-13 15:36:52 +02:00
.add_node(ShaderNodeBuilder<MixNode>(graph, "Mix")
Cycles API: encapsulate Node socket members This encapsulates Node socket members behind a set of specific methods; as such it is no longer possible to directly access Node class members from exporters and parts of Cycles. The methods are defined via the NODE_SOCKET_API macros in `graph/ node.h`, and are for getting or setting a specific socket's value, as well as querying or modifying the state of its update flag. The setters will check whether the value has changed and tag the socket as modified appropriately. This will let us know how a Node has changed and what to update, which is the first concrete step toward a more granular scene update system. Since the setters will tag the Node sockets as modified when passed different data, this patch also removes the various modified methods on Nodes in favor of Node::is_modified which checks the sockets' update flags status. Reviewed By: brecht Maniphest Tasks: T79174 Differential Revision: https://developer.blender.org/D8544
2020-11-04 11:17:38 +01:00
.set_param("mix_type", NODE_MIX_SUB)
.set_param("use_clamp", true)
Cycles: add unit tests for supported constant folding rules. Code coverage of different combinations of secondary conditions is obviously not complete because there are so many of them, but all main rules should be there. The reason for CORRECT vs INVALID is that both words have the same number of characters so calls line up, but look quite different. Reviewers: #cycles, sergey Reviewed By: #cycles, sergey Subscribers: dingto, sergey, brecht Differential Revision: https://developer.blender.org/D2130
2016-08-01 18:53:20 +03:00
.set("Fac", 0.5f))
.add_connection("Attribute::Color", "Mix::Color1")
.add_connection("Attribute::Color", "Mix::Color2")
.output_color("Mix::Color");
Refactor: Cycles: Replace new/delete by unique_ptr, in simple cases Pull Request: https://projects.blender.org/blender/blender/pulls/132361
2024-12-29 23:13:45 +01:00
graph.finalize(scene.get());
Cycles: add unit tests for supported constant folding rules. Code coverage of different combinations of secondary conditions is obviously not complete because there are so many of them, but all main rules should be there. The reason for CORRECT vs INVALID is that both words have the same number of characters so calls line up, but look quite different. Reviewers: #cycles, sergey Reviewed By: #cycles, sergey Subscribers: dingto, sergey, brecht Differential Revision: https://developer.blender.org/D2130
2016-08-01 18:53:20 +03:00
}
/*
* Tests:
Cleanup: spelling in comments
2023-08-25 08:56:58 +10:00
* - Folding of MixRGB Subtract with the same inputs and fac 1.
Cycles: add unit tests for supported constant folding rules. Code coverage of different combinations of secondary conditions is obviously not complete because there are so many of them, but all main rules should be there. The reason for CORRECT vs INVALID is that both words have the same number of characters so calls line up, but look quite different. Reviewers: #cycles, sergey Reviewed By: #cycles, sergey Subscribers: dingto, sergey, brecht Differential Revision: https://developer.blender.org/D2130
2016-08-01 18:53:20 +03:00
*/
Cycles: Fix memory leak in test and simplify code
2017-10-24 11:12:28 +02:00
TEST_F(RenderGraph, constant_fold_part_mix_sub_same_fac_1)
Cycles: add unit tests for supported constant folding rules. Code coverage of different combinations of secondary conditions is obviously not complete because there are so many of them, but all main rules should be there. The reason for CORRECT vs INVALID is that both words have the same number of characters so calls line up, but look quite different. Reviewers: #cycles, sergey Reviewed By: #cycles, sergey Subscribers: dingto, sergey, brecht Differential Revision: https://developer.blender.org/D2130
2016-08-01 18:53:20 +03:00
{
EXPECT_ANY_MESSAGE(log);
CORRECT_INFO_MESSAGE(log, "Folding Mix::Color to constant (0, 0, 0).");
builder.add_attribute("Attribute")
Cycles: fix missing ShaderNode ownership in render_graph_finalize_test
2020-10-13 15:36:52 +02:00
.add_node(ShaderNodeBuilder<MixNode>(graph, "Mix")
Cycles API: encapsulate Node socket members This encapsulates Node socket members behind a set of specific methods; as such it is no longer possible to directly access Node class members from exporters and parts of Cycles. The methods are defined via the NODE_SOCKET_API macros in `graph/ node.h`, and are for getting or setting a specific socket's value, as well as querying or modifying the state of its update flag. The setters will check whether the value has changed and tag the socket as modified appropriately. This will let us know how a Node has changed and what to update, which is the first concrete step toward a more granular scene update system. Since the setters will tag the Node sockets as modified when passed different data, this patch also removes the various modified methods on Nodes in favor of Node::is_modified which checks the sockets' update flags status. Reviewed By: brecht Maniphest Tasks: T79174 Differential Revision: https://developer.blender.org/D8544
2020-11-04 11:17:38 +01:00
.set_param("mix_type", NODE_MIX_SUB)
.set_param("use_clamp", true)
Cycles: add unit tests for supported constant folding rules. Code coverage of different combinations of secondary conditions is obviously not complete because there are so many of them, but all main rules should be there. The reason for CORRECT vs INVALID is that both words have the same number of characters so calls line up, but look quite different. Reviewers: #cycles, sergey Reviewed By: #cycles, sergey Subscribers: dingto, sergey, brecht Differential Revision: https://developer.blender.org/D2130
2016-08-01 18:53:20 +03:00
.set("Fac", 1.0f))
.add_connection("Attribute::Color", "Mix::Color1")
.add_connection("Attribute::Color", "Mix::Color2")
.output_color("Mix::Color");
Refactor: Cycles: Replace new/delete by unique_ptr, in simple cases Pull Request: https://projects.blender.org/blender/blender/pulls/132361
2024-12-29 23:13:45 +01:00
graph.finalize(scene.get());
Cycles: add unit tests for supported constant folding rules. Code coverage of different combinations of secondary conditions is obviously not complete because there are so many of them, but all main rules should be there. The reason for CORRECT vs INVALID is that both words have the same number of characters so calls line up, but look quite different. Reviewers: #cycles, sergey Reviewed By: #cycles, sergey Subscribers: dingto, sergey, brecht Differential Revision: https://developer.blender.org/D2130
2016-08-01 18:53:20 +03:00
}
/*
* Graph for testing partial folds of MixRGB with one constant argument.
* Includes 4 tests: constant on each side with fac either unknown or 1.
*/
static void build_mix_partial_test_graph(ShaderGraphBuilder &builder,
NodeMix type,
Refactor: Cycles: Add const keyword to more function parameters Pull Request: https://projects.blender.org/blender/blender/pulls/132361
2025-01-01 18:15:54 +01:00
const float3 constval)
Cycles: add unit tests for supported constant folding rules. Code coverage of different combinations of secondary conditions is obviously not complete because there are so many of them, but all main rules should be there. The reason for CORRECT vs INVALID is that both words have the same number of characters so calls line up, but look quite different. Reviewers: #cycles, sergey Reviewed By: #cycles, sergey Subscribers: dingto, sergey, brecht Differential Revision: https://developer.blender.org/D2130
2016-08-01 18:53:20 +03:00
{
builder
.add_attribute("Attribute")
/* constant on the left */
Cycles: fix missing ShaderNode ownership in render_graph_finalize_test
2020-10-13 15:36:52 +02:00
.add_node(ShaderNodeBuilder<MixNode>(builder.graph(), "Mix_Cx_Fx")
Cycles API: encapsulate Node socket members This encapsulates Node socket members behind a set of specific methods; as such it is no longer possible to directly access Node class members from exporters and parts of Cycles. The methods are defined via the NODE_SOCKET_API macros in `graph/ node.h`, and are for getting or setting a specific socket's value, as well as querying or modifying the state of its update flag. The setters will check whether the value has changed and tag the socket as modified appropriately. This will let us know how a Node has changed and what to update, which is the first concrete step toward a more granular scene update system. Since the setters will tag the Node sockets as modified when passed different data, this patch also removes the various modified methods on Nodes in favor of Node::is_modified which checks the sockets' update flags status. Reviewed By: brecht Maniphest Tasks: T79174 Differential Revision: https://developer.blender.org/D8544
2020-11-04 11:17:38 +01:00
.set_param("mix_type", type)
.set_param("use_clamp", false)
Cycles: add unit tests for supported constant folding rules. Code coverage of different combinations of secondary conditions is obviously not complete because there are so many of them, but all main rules should be there. The reason for CORRECT vs INVALID is that both words have the same number of characters so calls line up, but look quite different. Reviewers: #cycles, sergey Reviewed By: #cycles, sergey Subscribers: dingto, sergey, brecht Differential Revision: https://developer.blender.org/D2130
2016-08-01 18:53:20 +03:00
.set("Color1", constval))
Cycles: fix missing ShaderNode ownership in render_graph_finalize_test
2020-10-13 15:36:52 +02:00
.add_node(ShaderNodeBuilder<MixNode>(builder.graph(), "Mix_Cx_F1")
Cycles API: encapsulate Node socket members This encapsulates Node socket members behind a set of specific methods; as such it is no longer possible to directly access Node class members from exporters and parts of Cycles. The methods are defined via the NODE_SOCKET_API macros in `graph/ node.h`, and are for getting or setting a specific socket's value, as well as querying or modifying the state of its update flag. The setters will check whether the value has changed and tag the socket as modified appropriately. This will let us know how a Node has changed and what to update, which is the first concrete step toward a more granular scene update system. Since the setters will tag the Node sockets as modified when passed different data, this patch also removes the various modified methods on Nodes in favor of Node::is_modified which checks the sockets' update flags status. Reviewed By: brecht Maniphest Tasks: T79174 Differential Revision: https://developer.blender.org/D8544
2020-11-04 11:17:38 +01:00
.set_param("mix_type", type)
.set_param("use_clamp", false)
Cycles: add unit tests for supported constant folding rules. Code coverage of different combinations of secondary conditions is obviously not complete because there are so many of them, but all main rules should be there. The reason for CORRECT vs INVALID is that both words have the same number of characters so calls line up, but look quite different. Reviewers: #cycles, sergey Reviewed By: #cycles, sergey Subscribers: dingto, sergey, brecht Differential Revision: https://developer.blender.org/D2130
2016-08-01 18:53:20 +03:00
.set("Color1", constval)
.set("Fac", 1.0f))
.add_connection("Attribute::Fac", "Mix_Cx_Fx::Fac")
.add_connection("Attribute::Color", "Mix_Cx_Fx::Color2")
.add_connection("Attribute::Color", "Mix_Cx_F1::Color2")
/* constant on the right */
Cycles: fix missing ShaderNode ownership in render_graph_finalize_test
2020-10-13 15:36:52 +02:00
.add_node(ShaderNodeBuilder<MixNode>(builder.graph(), "Mix_xC_Fx")
Cycles API: encapsulate Node socket members This encapsulates Node socket members behind a set of specific methods; as such it is no longer possible to directly access Node class members from exporters and parts of Cycles. The methods are defined via the NODE_SOCKET_API macros in `graph/ node.h`, and are for getting or setting a specific socket's value, as well as querying or modifying the state of its update flag. The setters will check whether the value has changed and tag the socket as modified appropriately. This will let us know how a Node has changed and what to update, which is the first concrete step toward a more granular scene update system. Since the setters will tag the Node sockets as modified when passed different data, this patch also removes the various modified methods on Nodes in favor of Node::is_modified which checks the sockets' update flags status. Reviewed By: brecht Maniphest Tasks: T79174 Differential Revision: https://developer.blender.org/D8544
2020-11-04 11:17:38 +01:00
.set_param("mix_type", type)
.set_param("use_clamp", false)
Cycles: add unit tests for supported constant folding rules. Code coverage of different combinations of secondary conditions is obviously not complete because there are so many of them, but all main rules should be there. The reason for CORRECT vs INVALID is that both words have the same number of characters so calls line up, but look quite different. Reviewers: #cycles, sergey Reviewed By: #cycles, sergey Subscribers: dingto, sergey, brecht Differential Revision: https://developer.blender.org/D2130
2016-08-01 18:53:20 +03:00
.set("Color2", constval))
Cycles: fix missing ShaderNode ownership in render_graph_finalize_test
2020-10-13 15:36:52 +02:00
.add_node(ShaderNodeBuilder<MixNode>(builder.graph(), "Mix_xC_F1")
Cycles API: encapsulate Node socket members This encapsulates Node socket members behind a set of specific methods; as such it is no longer possible to directly access Node class members from exporters and parts of Cycles. The methods are defined via the NODE_SOCKET_API macros in `graph/ node.h`, and are for getting or setting a specific socket's value, as well as querying or modifying the state of its update flag. The setters will check whether the value has changed and tag the socket as modified appropriately. This will let us know how a Node has changed and what to update, which is the first concrete step toward a more granular scene update system. Since the setters will tag the Node sockets as modified when passed different data, this patch also removes the various modified methods on Nodes in favor of Node::is_modified which checks the sockets' update flags status. Reviewed By: brecht Maniphest Tasks: T79174 Differential Revision: https://developer.blender.org/D8544
2020-11-04 11:17:38 +01:00
.set_param("mix_type", type)
.set_param("use_clamp", false)
Cycles: add unit tests for supported constant folding rules. Code coverage of different combinations of secondary conditions is obviously not complete because there are so many of them, but all main rules should be there. The reason for CORRECT vs INVALID is that both words have the same number of characters so calls line up, but look quite different. Reviewers: #cycles, sergey Reviewed By: #cycles, sergey Subscribers: dingto, sergey, brecht Differential Revision: https://developer.blender.org/D2130
2016-08-01 18:53:20 +03:00
.set("Color2", constval)
.set("Fac", 1.0f))
.add_connection("Attribute::Fac", "Mix_xC_Fx::Fac")
.add_connection("Attribute::Color", "Mix_xC_Fx::Color1")
.add_connection("Attribute::Color", "Mix_xC_F1::Color1")
/* results of actual tests simply added up to connect to output */
Cycles: fix missing ShaderNode ownership in render_graph_finalize_test
2020-10-13 15:36:52 +02:00
.add_node(ShaderNodeBuilder<MixNode>(builder.graph(), "Out12")
Cycles API: encapsulate Node socket members This encapsulates Node socket members behind a set of specific methods; as such it is no longer possible to directly access Node class members from exporters and parts of Cycles. The methods are defined via the NODE_SOCKET_API macros in `graph/ node.h`, and are for getting or setting a specific socket's value, as well as querying or modifying the state of its update flag. The setters will check whether the value has changed and tag the socket as modified appropriately. This will let us know how a Node has changed and what to update, which is the first concrete step toward a more granular scene update system. Since the setters will tag the Node sockets as modified when passed different data, this patch also removes the various modified methods on Nodes in favor of Node::is_modified which checks the sockets' update flags status. Reviewed By: brecht Maniphest Tasks: T79174 Differential Revision: https://developer.blender.org/D8544
2020-11-04 11:17:38 +01:00
.set_param("mix_type", NODE_MIX_ADD)
.set_param("use_clamp", true)
Cycles: add unit tests for supported constant folding rules. Code coverage of different combinations of secondary conditions is obviously not complete because there are so many of them, but all main rules should be there. The reason for CORRECT vs INVALID is that both words have the same number of characters so calls line up, but look quite different. Reviewers: #cycles, sergey Reviewed By: #cycles, sergey Subscribers: dingto, sergey, brecht Differential Revision: https://developer.blender.org/D2130
2016-08-01 18:53:20 +03:00
.set("Fac", 1.0f))
Cycles: fix missing ShaderNode ownership in render_graph_finalize_test
2020-10-13 15:36:52 +02:00
.add_node(ShaderNodeBuilder<MixNode>(builder.graph(), "Out34")
Cycles API: encapsulate Node socket members This encapsulates Node socket members behind a set of specific methods; as such it is no longer possible to directly access Node class members from exporters and parts of Cycles. The methods are defined via the NODE_SOCKET_API macros in `graph/ node.h`, and are for getting or setting a specific socket's value, as well as querying or modifying the state of its update flag. The setters will check whether the value has changed and tag the socket as modified appropriately. This will let us know how a Node has changed and what to update, which is the first concrete step toward a more granular scene update system. Since the setters will tag the Node sockets as modified when passed different data, this patch also removes the various modified methods on Nodes in favor of Node::is_modified which checks the sockets' update flags status. Reviewed By: brecht Maniphest Tasks: T79174 Differential Revision: https://developer.blender.org/D8544
2020-11-04 11:17:38 +01:00
.set_param("mix_type", NODE_MIX_ADD)
.set_param("use_clamp", true)
Cycles: add unit tests for supported constant folding rules. Code coverage of different combinations of secondary conditions is obviously not complete because there are so many of them, but all main rules should be there. The reason for CORRECT vs INVALID is that both words have the same number of characters so calls line up, but look quite different. Reviewers: #cycles, sergey Reviewed By: #cycles, sergey Subscribers: dingto, sergey, brecht Differential Revision: https://developer.blender.org/D2130
2016-08-01 18:53:20 +03:00
.set("Fac", 1.0f))
Cycles: fix missing ShaderNode ownership in render_graph_finalize_test
2020-10-13 15:36:52 +02:00
.add_node(ShaderNodeBuilder<MixNode>(builder.graph(), "Out1234")
Cycles API: encapsulate Node socket members This encapsulates Node socket members behind a set of specific methods; as such it is no longer possible to directly access Node class members from exporters and parts of Cycles. The methods are defined via the NODE_SOCKET_API macros in `graph/ node.h`, and are for getting or setting a specific socket's value, as well as querying or modifying the state of its update flag. The setters will check whether the value has changed and tag the socket as modified appropriately. This will let us know how a Node has changed and what to update, which is the first concrete step toward a more granular scene update system. Since the setters will tag the Node sockets as modified when passed different data, this patch also removes the various modified methods on Nodes in favor of Node::is_modified which checks the sockets' update flags status. Reviewed By: brecht Maniphest Tasks: T79174 Differential Revision: https://developer.blender.org/D8544
2020-11-04 11:17:38 +01:00
.set_param("mix_type", NODE_MIX_ADD)
.set_param("use_clamp", true)
Cycles: add unit tests for supported constant folding rules. Code coverage of different combinations of secondary conditions is obviously not complete because there are so many of them, but all main rules should be there. The reason for CORRECT vs INVALID is that both words have the same number of characters so calls line up, but look quite different. Reviewers: #cycles, sergey Reviewed By: #cycles, sergey Subscribers: dingto, sergey, brecht Differential Revision: https://developer.blender.org/D2130
2016-08-01 18:53:20 +03:00
.set("Fac", 1.0f))
.add_connection("Mix_Cx_Fx::Color", "Out12::Color1")
.add_connection("Mix_Cx_F1::Color", "Out12::Color2")
.add_connection("Mix_xC_Fx::Color", "Out34::Color1")
.add_connection("Mix_xC_F1::Color", "Out34::Color2")
.add_connection("Out12::Color", "Out1234::Color1")
.add_connection("Out34::Color", "Out1234::Color2")
.output_color("Out1234::Color");
}
/*
* Tests: partial folding for RGB Add with known 0.
*/
Cycles: Fix memory leak in test and simplify code
2017-10-24 11:12:28 +02:00
TEST_F(RenderGraph, constant_fold_part_mix_add_0)
Cycles: add unit tests for supported constant folding rules. Code coverage of different combinations of secondary conditions is obviously not complete because there are so many of them, but all main rules should be there. The reason for CORRECT vs INVALID is that both words have the same number of characters so calls line up, but look quite different. Reviewers: #cycles, sergey Reviewed By: #cycles, sergey Subscribers: dingto, sergey, brecht Differential Revision: https://developer.blender.org/D2130
2016-08-01 18:53:20 +03:00
{
EXPECT_ANY_MESSAGE(log);
/* 0 + X (fac 1) == X */
INVALID_INFO_MESSAGE(log, "Folding Mix_Cx_Fx::Color");
CORRECT_INFO_MESSAGE(log, "Folding Mix_Cx_F1::Color to socket Attribute::Color.");
/* X + 0 (fac ?) == X */
CORRECT_INFO_MESSAGE(log, "Folding Mix_xC_Fx::Color to socket Attribute::Color.");
CORRECT_INFO_MESSAGE(log, "Folding Mix_xC_F1::Color to socket Attribute::Color.");
INVALID_INFO_MESSAGE(log, "Folding Out");
build_mix_partial_test_graph(builder, NODE_MIX_ADD, make_float3(0, 0, 0));
Refactor: Cycles: Replace new/delete by unique_ptr, in simple cases Pull Request: https://projects.blender.org/blender/blender/pulls/132361
2024-12-29 23:13:45 +01:00
graph.finalize(scene.get());
Cycles: add unit tests for supported constant folding rules. Code coverage of different combinations of secondary conditions is obviously not complete because there are so many of them, but all main rules should be there. The reason for CORRECT vs INVALID is that both words have the same number of characters so calls line up, but look quite different. Reviewers: #cycles, sergey Reviewed By: #cycles, sergey Subscribers: dingto, sergey, brecht Differential Revision: https://developer.blender.org/D2130
2016-08-01 18:53:20 +03:00
}
/*
Cleanup: spelling in comments
2023-08-25 08:56:58 +10:00
* Tests: partial folding for RGB Subtract with known 0.
Cycles: add unit tests for supported constant folding rules. Code coverage of different combinations of secondary conditions is obviously not complete because there are so many of them, but all main rules should be there. The reason for CORRECT vs INVALID is that both words have the same number of characters so calls line up, but look quite different. Reviewers: #cycles, sergey Reviewed By: #cycles, sergey Subscribers: dingto, sergey, brecht Differential Revision: https://developer.blender.org/D2130
2016-08-01 18:53:20 +03:00
*/
Cycles: Fix memory leak in test and simplify code
2017-10-24 11:12:28 +02:00
TEST_F(RenderGraph, constant_fold_part_mix_sub_0)
Cycles: add unit tests for supported constant folding rules. Code coverage of different combinations of secondary conditions is obviously not complete because there are so many of them, but all main rules should be there. The reason for CORRECT vs INVALID is that both words have the same number of characters so calls line up, but look quite different. Reviewers: #cycles, sergey Reviewed By: #cycles, sergey Subscribers: dingto, sergey, brecht Differential Revision: https://developer.blender.org/D2130
2016-08-01 18:53:20 +03:00
{
EXPECT_ANY_MESSAGE(log);
INVALID_INFO_MESSAGE(log, "Folding Mix_Cx_Fx::Color");
INVALID_INFO_MESSAGE(log, "Folding Mix_Cx_F1::Color");
/* X - 0 (fac ?) == X */
CORRECT_INFO_MESSAGE(log, "Folding Mix_xC_Fx::Color to socket Attribute::Color.");
CORRECT_INFO_MESSAGE(log, "Folding Mix_xC_F1::Color to socket Attribute::Color.");
INVALID_INFO_MESSAGE(log, "Folding Out");
build_mix_partial_test_graph(builder, NODE_MIX_SUB, make_float3(0, 0, 0));
Refactor: Cycles: Replace new/delete by unique_ptr, in simple cases Pull Request: https://projects.blender.org/blender/blender/pulls/132361
2024-12-29 23:13:45 +01:00
graph.finalize(scene.get());
Cycles: add unit tests for supported constant folding rules. Code coverage of different combinations of secondary conditions is obviously not complete because there are so many of them, but all main rules should be there. The reason for CORRECT vs INVALID is that both words have the same number of characters so calls line up, but look quite different. Reviewers: #cycles, sergey Reviewed By: #cycles, sergey Subscribers: dingto, sergey, brecht Differential Revision: https://developer.blender.org/D2130
2016-08-01 18:53:20 +03:00
}
/*
Cleanup: spelling in comments
2023-08-25 08:56:58 +10:00
* Tests: partial folding for RGB Multiply with known 1.
Cycles: add unit tests for supported constant folding rules. Code coverage of different combinations of secondary conditions is obviously not complete because there are so many of them, but all main rules should be there. The reason for CORRECT vs INVALID is that both words have the same number of characters so calls line up, but look quite different. Reviewers: #cycles, sergey Reviewed By: #cycles, sergey Subscribers: dingto, sergey, brecht Differential Revision: https://developer.blender.org/D2130
2016-08-01 18:53:20 +03:00
*/
Cycles: Fix memory leak in test and simplify code
2017-10-24 11:12:28 +02:00
TEST_F(RenderGraph, constant_fold_part_mix_mul_1)
Cycles: add unit tests for supported constant folding rules. Code coverage of different combinations of secondary conditions is obviously not complete because there are so many of them, but all main rules should be there. The reason for CORRECT vs INVALID is that both words have the same number of characters so calls line up, but look quite different. Reviewers: #cycles, sergey Reviewed By: #cycles, sergey Subscribers: dingto, sergey, brecht Differential Revision: https://developer.blender.org/D2130
2016-08-01 18:53:20 +03:00
{
EXPECT_ANY_MESSAGE(log);
/* 1 * X (fac 1) == X */
INVALID_INFO_MESSAGE(log, "Folding Mix_Cx_Fx::Color");
CORRECT_INFO_MESSAGE(log, "Folding Mix_Cx_F1::Color to socket Attribute::Color.");
/* X * 1 (fac ?) == X */
CORRECT_INFO_MESSAGE(log, "Folding Mix_xC_Fx::Color to socket Attribute::Color.");
CORRECT_INFO_MESSAGE(log, "Folding Mix_xC_F1::Color to socket Attribute::Color.");
INVALID_INFO_MESSAGE(log, "Folding Out");
build_mix_partial_test_graph(builder, NODE_MIX_MUL, make_float3(1, 1, 1));
Refactor: Cycles: Replace new/delete by unique_ptr, in simple cases Pull Request: https://projects.blender.org/blender/blender/pulls/132361
2024-12-29 23:13:45 +01:00
graph.finalize(scene.get());
Cycles: add unit tests for supported constant folding rules. Code coverage of different combinations of secondary conditions is obviously not complete because there are so many of them, but all main rules should be there. The reason for CORRECT vs INVALID is that both words have the same number of characters so calls line up, but look quite different. Reviewers: #cycles, sergey Reviewed By: #cycles, sergey Subscribers: dingto, sergey, brecht Differential Revision: https://developer.blender.org/D2130
2016-08-01 18:53:20 +03:00
}
/*
Cleanup: spelling in comments
2023-08-25 08:56:58 +10:00
* Tests: partial folding for RGB Divide with known 1.
Cycles: add unit tests for supported constant folding rules. Code coverage of different combinations of secondary conditions is obviously not complete because there are so many of them, but all main rules should be there. The reason for CORRECT vs INVALID is that both words have the same number of characters so calls line up, but look quite different. Reviewers: #cycles, sergey Reviewed By: #cycles, sergey Subscribers: dingto, sergey, brecht Differential Revision: https://developer.blender.org/D2130
2016-08-01 18:53:20 +03:00
*/
Cycles: Fix memory leak in test and simplify code
2017-10-24 11:12:28 +02:00
TEST_F(RenderGraph, constant_fold_part_mix_div_1)
Cycles: add unit tests for supported constant folding rules. Code coverage of different combinations of secondary conditions is obviously not complete because there are so many of them, but all main rules should be there. The reason for CORRECT vs INVALID is that both words have the same number of characters so calls line up, but look quite different. Reviewers: #cycles, sergey Reviewed By: #cycles, sergey Subscribers: dingto, sergey, brecht Differential Revision: https://developer.blender.org/D2130
2016-08-01 18:53:20 +03:00
{
EXPECT_ANY_MESSAGE(log);
INVALID_INFO_MESSAGE(log, "Folding Mix_Cx_Fx::Color");
INVALID_INFO_MESSAGE(log, "Folding Mix_Cx_F1::Color");
/* X / 1 (fac ?) == X */
CORRECT_INFO_MESSAGE(log, "Folding Mix_xC_Fx::Color to socket Attribute::Color.");
CORRECT_INFO_MESSAGE(log, "Folding Mix_xC_F1::Color to socket Attribute::Color.");
INVALID_INFO_MESSAGE(log, "Folding Out");
build_mix_partial_test_graph(builder, NODE_MIX_DIV, make_float3(1, 1, 1));
Refactor: Cycles: Replace new/delete by unique_ptr, in simple cases Pull Request: https://projects.blender.org/blender/blender/pulls/132361
2024-12-29 23:13:45 +01:00
graph.finalize(scene.get());
Cycles: add unit tests for supported constant folding rules. Code coverage of different combinations of secondary conditions is obviously not complete because there are so many of them, but all main rules should be there. The reason for CORRECT vs INVALID is that both words have the same number of characters so calls line up, but look quite different. Reviewers: #cycles, sergey Reviewed By: #cycles, sergey Subscribers: dingto, sergey, brecht Differential Revision: https://developer.blender.org/D2130
2016-08-01 18:53:20 +03:00
}
/*
Cleanup: spelling in comments
2023-08-25 08:56:58 +10:00
* Tests: partial folding for RGB Multiply with known 0.
Cycles: add unit tests for supported constant folding rules. Code coverage of different combinations of secondary conditions is obviously not complete because there are so many of them, but all main rules should be there. The reason for CORRECT vs INVALID is that both words have the same number of characters so calls line up, but look quite different. Reviewers: #cycles, sergey Reviewed By: #cycles, sergey Subscribers: dingto, sergey, brecht Differential Revision: https://developer.blender.org/D2130
2016-08-01 18:53:20 +03:00
*/
Cycles: Fix memory leak in test and simplify code
2017-10-24 11:12:28 +02:00
TEST_F(RenderGraph, constant_fold_part_mix_mul_0)
Cycles: add unit tests for supported constant folding rules. Code coverage of different combinations of secondary conditions is obviously not complete because there are so many of them, but all main rules should be there. The reason for CORRECT vs INVALID is that both words have the same number of characters so calls line up, but look quite different. Reviewers: #cycles, sergey Reviewed By: #cycles, sergey Subscribers: dingto, sergey, brecht Differential Revision: https://developer.blender.org/D2130
2016-08-01 18:53:20 +03:00
{
EXPECT_ANY_MESSAGE(log);
/* 0 * ? (fac ?) == 0 */
CORRECT_INFO_MESSAGE(log, "Folding Mix_Cx_Fx::Color to constant (0, 0, 0).");
CORRECT_INFO_MESSAGE(log, "Folding Mix_Cx_F1::Color to constant (0, 0, 0).");
/* ? * 0 (fac 1) == 0 */
INVALID_INFO_MESSAGE(log, "Folding Mix_xC_Fx::Color");
CORRECT_INFO_MESSAGE(log, "Folding Mix_xC_F1::Color to constant (0, 0, 0).");
CORRECT_INFO_MESSAGE(log, "Folding Out12::Color to constant (0, 0, 0).");
INVALID_INFO_MESSAGE(log, "Folding Out1234");
build_mix_partial_test_graph(builder, NODE_MIX_MUL, make_float3(0, 0, 0));
Refactor: Cycles: Replace new/delete by unique_ptr, in simple cases Pull Request: https://projects.blender.org/blender/blender/pulls/132361
2024-12-29 23:13:45 +01:00
graph.finalize(scene.get());
Cycles: add unit tests for supported constant folding rules. Code coverage of different combinations of secondary conditions is obviously not complete because there are so many of them, but all main rules should be there. The reason for CORRECT vs INVALID is that both words have the same number of characters so calls line up, but look quite different. Reviewers: #cycles, sergey Reviewed By: #cycles, sergey Subscribers: dingto, sergey, brecht Differential Revision: https://developer.blender.org/D2130
2016-08-01 18:53:20 +03:00
}
/*
Cleanup: spelling in comments
2023-08-25 08:56:58 +10:00
* Tests: partial folding for RGB Divide with known 0.
Cycles: add unit tests for supported constant folding rules. Code coverage of different combinations of secondary conditions is obviously not complete because there are so many of them, but all main rules should be there. The reason for CORRECT vs INVALID is that both words have the same number of characters so calls line up, but look quite different. Reviewers: #cycles, sergey Reviewed By: #cycles, sergey Subscribers: dingto, sergey, brecht Differential Revision: https://developer.blender.org/D2130
2016-08-01 18:53:20 +03:00
*/
Cycles: Fix memory leak in test and simplify code
2017-10-24 11:12:28 +02:00
TEST_F(RenderGraph, constant_fold_part_mix_div_0)
Cycles: add unit tests for supported constant folding rules. Code coverage of different combinations of secondary conditions is obviously not complete because there are so many of them, but all main rules should be there. The reason for CORRECT vs INVALID is that both words have the same number of characters so calls line up, but look quite different. Reviewers: #cycles, sergey Reviewed By: #cycles, sergey Subscribers: dingto, sergey, brecht Differential Revision: https://developer.blender.org/D2130
2016-08-01 18:53:20 +03:00
{
EXPECT_ANY_MESSAGE(log);
/* 0 / ? (fac ?) == 0 */
CORRECT_INFO_MESSAGE(log, "Folding Mix_Cx_Fx::Color to constant (0, 0, 0).");
CORRECT_INFO_MESSAGE(log, "Folding Mix_Cx_F1::Color to constant (0, 0, 0).");
INVALID_INFO_MESSAGE(log, "Folding Mix_xC_Fx::Color");
INVALID_INFO_MESSAGE(log, "Folding Mix_xC_F1::Color");
CORRECT_INFO_MESSAGE(log, "Folding Out12::Color to constant (0, 0, 0).");
INVALID_INFO_MESSAGE(log, "Folding Out1234");
build_mix_partial_test_graph(builder, NODE_MIX_DIV, make_float3(0, 0, 0));
Refactor: Cycles: Replace new/delete by unique_ptr, in simple cases Pull Request: https://projects.blender.org/blender/blender/pulls/132361
2024-12-29 23:13:45 +01:00
graph.finalize(scene.get());
Cycles: add unit tests for supported constant folding rules. Code coverage of different combinations of secondary conditions is obviously not complete because there are so many of them, but all main rules should be there. The reason for CORRECT vs INVALID is that both words have the same number of characters so calls line up, but look quite different. Reviewers: #cycles, sergey Reviewed By: #cycles, sergey Subscribers: dingto, sergey, brecht Differential Revision: https://developer.blender.org/D2130
2016-08-01 18:53:20 +03:00
}
/*
* Tests: Separate/Combine RGB with all constant inputs.
*/
Cycles: Fix memory leak in test and simplify code
2017-10-24 11:12:28 +02:00
TEST_F(RenderGraph, constant_fold_separate_combine_rgb)
Cycles: add unit tests for supported constant folding rules. Code coverage of different combinations of secondary conditions is obviously not complete because there are so many of them, but all main rules should be there. The reason for CORRECT vs INVALID is that both words have the same number of characters so calls line up, but look quite different. Reviewers: #cycles, sergey Reviewed By: #cycles, sergey Subscribers: dingto, sergey, brecht Differential Revision: https://developer.blender.org/D2130
2016-08-01 18:53:20 +03:00
{
EXPECT_ANY_MESSAGE(log);
CORRECT_INFO_MESSAGE(log, "Folding SeparateRGB::R to constant (0.3).");
CORRECT_INFO_MESSAGE(log, "Folding SeparateRGB::G to constant (0.5).");
CORRECT_INFO_MESSAGE(log, "Folding SeparateRGB::B to constant (0.7).");
CORRECT_INFO_MESSAGE(log, "Folding CombineRGB::Image to constant (0.3, 0.5, 0.7).");
builder
Cycles: fix missing ShaderNode ownership in render_graph_finalize_test
2020-10-13 15:36:52 +02:00
.add_node(ShaderNodeBuilder<SeparateRGBNode>(graph, "SeparateRGB")
Cycles: add unit tests for supported constant folding rules. Code coverage of different combinations of secondary conditions is obviously not complete because there are so many of them, but all main rules should be there. The reason for CORRECT vs INVALID is that both words have the same number of characters so calls line up, but look quite different. Reviewers: #cycles, sergey Reviewed By: #cycles, sergey Subscribers: dingto, sergey, brecht Differential Revision: https://developer.blender.org/D2130
2016-08-01 18:53:20 +03:00
.set("Image", make_float3(0.3f, 0.5f, 0.7f)))
Cycles: fix missing ShaderNode ownership in render_graph_finalize_test
2020-10-13 15:36:52 +02:00
.add_node(ShaderNodeBuilder<CombineRGBNode>(graph, "CombineRGB"))
Cycles: add unit tests for supported constant folding rules. Code coverage of different combinations of secondary conditions is obviously not complete because there are so many of them, but all main rules should be there. The reason for CORRECT vs INVALID is that both words have the same number of characters so calls line up, but look quite different. Reviewers: #cycles, sergey Reviewed By: #cycles, sergey Subscribers: dingto, sergey, brecht Differential Revision: https://developer.blender.org/D2130
2016-08-01 18:53:20 +03:00
.add_connection("SeparateRGB::R", "CombineRGB::R")
.add_connection("SeparateRGB::G", "CombineRGB::G")
.add_connection("SeparateRGB::B", "CombineRGB::B")
.output_color("CombineRGB::Image");
Refactor: Cycles: Replace new/delete by unique_ptr, in simple cases Pull Request: https://projects.blender.org/blender/blender/pulls/132361
2024-12-29 23:13:45 +01:00
graph.finalize(scene.get());
Cycles: add unit tests for supported constant folding rules. Code coverage of different combinations of secondary conditions is obviously not complete because there are so many of them, but all main rules should be there. The reason for CORRECT vs INVALID is that both words have the same number of characters so calls line up, but look quite different. Reviewers: #cycles, sergey Reviewed By: #cycles, sergey Subscribers: dingto, sergey, brecht Differential Revision: https://developer.blender.org/D2130
2016-08-01 18:53:20 +03:00
}
/*
* Tests: Separate/Combine XYZ with all constant inputs.
*/
Cycles: Fix memory leak in test and simplify code
2017-10-24 11:12:28 +02:00
TEST_F(RenderGraph, constant_fold_separate_combine_xyz)
Cycles: add unit tests for supported constant folding rules. Code coverage of different combinations of secondary conditions is obviously not complete because there are so many of them, but all main rules should be there. The reason for CORRECT vs INVALID is that both words have the same number of characters so calls line up, but look quite different. Reviewers: #cycles, sergey Reviewed By: #cycles, sergey Subscribers: dingto, sergey, brecht Differential Revision: https://developer.blender.org/D2130
2016-08-01 18:53:20 +03:00
{
EXPECT_ANY_MESSAGE(log);
CORRECT_INFO_MESSAGE(log, "Folding SeparateXYZ::X to constant (0.3).");
CORRECT_INFO_MESSAGE(log, "Folding SeparateXYZ::Y to constant (0.5).");
CORRECT_INFO_MESSAGE(log, "Folding SeparateXYZ::Z to constant (0.7).");
CORRECT_INFO_MESSAGE(log, "Folding CombineXYZ::Vector to constant (0.3, 0.5, 0.7).");
CORRECT_INFO_MESSAGE(
log, "Folding convert_vector_to_color::value_color to constant (0.3, 0.5, 0.7).");
builder
Cycles: fix missing ShaderNode ownership in render_graph_finalize_test
2020-10-13 15:36:52 +02:00
.add_node(ShaderNodeBuilder<SeparateXYZNode>(graph, "SeparateXYZ")
Cycles: add unit tests for supported constant folding rules. Code coverage of different combinations of secondary conditions is obviously not complete because there are so many of them, but all main rules should be there. The reason for CORRECT vs INVALID is that both words have the same number of characters so calls line up, but look quite different. Reviewers: #cycles, sergey Reviewed By: #cycles, sergey Subscribers: dingto, sergey, brecht Differential Revision: https://developer.blender.org/D2130
2016-08-01 18:53:20 +03:00
.set("Vector", make_float3(0.3f, 0.5f, 0.7f)))
Cycles: fix missing ShaderNode ownership in render_graph_finalize_test
2020-10-13 15:36:52 +02:00
.add_node(ShaderNodeBuilder<CombineXYZNode>(graph, "CombineXYZ"))
Cycles: add unit tests for supported constant folding rules. Code coverage of different combinations of secondary conditions is obviously not complete because there are so many of them, but all main rules should be there. The reason for CORRECT vs INVALID is that both words have the same number of characters so calls line up, but look quite different. Reviewers: #cycles, sergey Reviewed By: #cycles, sergey Subscribers: dingto, sergey, brecht Differential Revision: https://developer.blender.org/D2130
2016-08-01 18:53:20 +03:00
.add_connection("SeparateXYZ::X", "CombineXYZ::X")
.add_connection("SeparateXYZ::Y", "CombineXYZ::Y")
.add_connection("SeparateXYZ::Z", "CombineXYZ::Z")
.output_color("CombineXYZ::Vector");
Refactor: Cycles: Replace new/delete by unique_ptr, in simple cases Pull Request: https://projects.blender.org/blender/blender/pulls/132361
2024-12-29 23:13:45 +01:00
graph.finalize(scene.get());
Cycles: add unit tests for supported constant folding rules. Code coverage of different combinations of secondary conditions is obviously not complete because there are so many of them, but all main rules should be there. The reason for CORRECT vs INVALID is that both words have the same number of characters so calls line up, but look quite different. Reviewers: #cycles, sergey Reviewed By: #cycles, sergey Subscribers: dingto, sergey, brecht Differential Revision: https://developer.blender.org/D2130
2016-08-01 18:53:20 +03:00
}
/*
* Tests: Separate/Combine HSV with all constant inputs.
*/
Cycles: Fix memory leak in test and simplify code
2017-10-24 11:12:28 +02:00
TEST_F(RenderGraph, constant_fold_separate_combine_hsv)
Cycles: add unit tests for supported constant folding rules. Code coverage of different combinations of secondary conditions is obviously not complete because there are so many of them, but all main rules should be there. The reason for CORRECT vs INVALID is that both words have the same number of characters so calls line up, but look quite different. Reviewers: #cycles, sergey Reviewed By: #cycles, sergey Subscribers: dingto, sergey, brecht Differential Revision: https://developer.blender.org/D2130
2016-08-01 18:53:20 +03:00
{
EXPECT_ANY_MESSAGE(log);
CORRECT_INFO_MESSAGE(log, "Folding SeparateHSV::H to constant (0.583333).");
CORRECT_INFO_MESSAGE(log, "Folding SeparateHSV::S to constant (0.571429).");
CORRECT_INFO_MESSAGE(log, "Folding SeparateHSV::V to constant (0.7).");
CORRECT_INFO_MESSAGE(log, "Folding CombineHSV::Color to constant (0.3, 0.5, 0.7).");
builder
Cycles: fix missing ShaderNode ownership in render_graph_finalize_test
2020-10-13 15:36:52 +02:00
.add_node(ShaderNodeBuilder<SeparateHSVNode>(graph, "SeparateHSV")
Cycles: add unit tests for supported constant folding rules. Code coverage of different combinations of secondary conditions is obviously not complete because there are so many of them, but all main rules should be there. The reason for CORRECT vs INVALID is that both words have the same number of characters so calls line up, but look quite different. Reviewers: #cycles, sergey Reviewed By: #cycles, sergey Subscribers: dingto, sergey, brecht Differential Revision: https://developer.blender.org/D2130
2016-08-01 18:53:20 +03:00
.set("Color", make_float3(0.3f, 0.5f, 0.7f)))
Cycles: fix missing ShaderNode ownership in render_graph_finalize_test
2020-10-13 15:36:52 +02:00
.add_node(ShaderNodeBuilder<CombineHSVNode>(graph, "CombineHSV"))
Cycles: add unit tests for supported constant folding rules. Code coverage of different combinations of secondary conditions is obviously not complete because there are so many of them, but all main rules should be there. The reason for CORRECT vs INVALID is that both words have the same number of characters so calls line up, but look quite different. Reviewers: #cycles, sergey Reviewed By: #cycles, sergey Subscribers: dingto, sergey, brecht Differential Revision: https://developer.blender.org/D2130
2016-08-01 18:53:20 +03:00
.add_connection("SeparateHSV::H", "CombineHSV::H")
.add_connection("SeparateHSV::S", "CombineHSV::S")
.add_connection("SeparateHSV::V", "CombineHSV::V")
.output_color("CombineHSV::Color");
Refactor: Cycles: Replace new/delete by unique_ptr, in simple cases Pull Request: https://projects.blender.org/blender/blender/pulls/132361
2024-12-29 23:13:45 +01:00
graph.finalize(scene.get());
Cycles: add unit tests for supported constant folding rules. Code coverage of different combinations of secondary conditions is obviously not complete because there are so many of them, but all main rules should be there. The reason for CORRECT vs INVALID is that both words have the same number of characters so calls line up, but look quite different. Reviewers: #cycles, sergey Reviewed By: #cycles, sergey Subscribers: dingto, sergey, brecht Differential Revision: https://developer.blender.org/D2130
2016-08-01 18:53:20 +03:00
}
/*
* Tests: Gamma with all constant inputs.
*/
Cycles: Fix memory leak in test and simplify code
2017-10-24 11:12:28 +02:00
TEST_F(RenderGraph, constant_fold_gamma)
Cycles: add unit tests for supported constant folding rules. Code coverage of different combinations of secondary conditions is obviously not complete because there are so many of them, but all main rules should be there. The reason for CORRECT vs INVALID is that both words have the same number of characters so calls line up, but look quite different. Reviewers: #cycles, sergey Reviewed By: #cycles, sergey Subscribers: dingto, sergey, brecht Differential Revision: https://developer.blender.org/D2130
2016-08-01 18:53:20 +03:00
{
EXPECT_ANY_MESSAGE(log);
CORRECT_INFO_MESSAGE(log, "Folding Gamma::Color to constant (0.164317, 0.353553, 0.585662).");
builder
Cycles: fix missing ShaderNode ownership in render_graph_finalize_test
2020-10-13 15:36:52 +02:00
.add_node(ShaderNodeBuilder<GammaNode>(graph, "Gamma")
Cycles: add unit tests for supported constant folding rules. Code coverage of different combinations of secondary conditions is obviously not complete because there are so many of them, but all main rules should be there. The reason for CORRECT vs INVALID is that both words have the same number of characters so calls line up, but look quite different. Reviewers: #cycles, sergey Reviewed By: #cycles, sergey Subscribers: dingto, sergey, brecht Differential Revision: https://developer.blender.org/D2130
2016-08-01 18:53:20 +03:00
.set("Color", make_float3(0.3f, 0.5f, 0.7f))
.set("Gamma", 1.5f))
.output_color("Gamma::Color");
Refactor: Cycles: Replace new/delete by unique_ptr, in simple cases Pull Request: https://projects.blender.org/blender/blender/pulls/132361
2024-12-29 23:13:45 +01:00
graph.finalize(scene.get());
Cycles: add unit tests for supported constant folding rules. Code coverage of different combinations of secondary conditions is obviously not complete because there are so many of them, but all main rules should be there. The reason for CORRECT vs INVALID is that both words have the same number of characters so calls line up, but look quite different. Reviewers: #cycles, sergey Reviewed By: #cycles, sergey Subscribers: dingto, sergey, brecht Differential Revision: https://developer.blender.org/D2130
2016-08-01 18:53:20 +03:00
}
Cycles: implement partial constant folding for exponentiation. This is also an important mathematical operation that can be folded if it is known that one argument is a certain constant. For colors the operation is provided as a Gamma node. The SVM Gamma node needs a small fix to make it follow the 0 ^ 0 == 1 rule, same as the Power node, or the Gamma node itself in OSL mode. Reviewers: #cycles Differential Revision: https://developer.blender.org/D2263
2016-09-29 00:35:53 +03:00
/*
* Tests: Gamma with one constant 0 input.
*/
Cycles: Fix memory leak in test and simplify code
2017-10-24 11:12:28 +02:00
TEST_F(RenderGraph, constant_fold_gamma_part_0)
Cycles: implement partial constant folding for exponentiation. This is also an important mathematical operation that can be folded if it is known that one argument is a certain constant. For colors the operation is provided as a Gamma node. The SVM Gamma node needs a small fix to make it follow the 0 ^ 0 == 1 rule, same as the Power node, or the Gamma node itself in OSL mode. Reviewers: #cycles Differential Revision: https://developer.blender.org/D2263
2016-09-29 00:35:53 +03:00
{
EXPECT_ANY_MESSAGE(log);
INVALID_INFO_MESSAGE(log, "Folding Gamma_Cx::");
CORRECT_INFO_MESSAGE(log, "Folding Gamma_xC::Color to constant (1, 1, 1).");
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
Cycles: implement partial constant folding for exponentiation. This is also an important mathematical operation that can be folded if it is known that one argument is a certain constant. For colors the operation is provided as a Gamma node. The SVM Gamma node needs a small fix to make it follow the 0 ^ 0 == 1 rule, same as the Power node, or the Gamma node itself in OSL mode. Reviewers: #cycles Differential Revision: https://developer.blender.org/D2263
2016-09-29 00:35:53 +03:00
builder
.add_attribute("Attribute")
/* constant on the left */
Cycles: add utility functions for zero float2/float3/float4/transform Ref D8237, T78710
2021-02-17 01:47:18 +01:00
.add_node(ShaderNodeBuilder<GammaNode>(graph, "Gamma_Cx").set("Color", zero_float3()))
Cycles: implement partial constant folding for exponentiation. This is also an important mathematical operation that can be folded if it is known that one argument is a certain constant. For colors the operation is provided as a Gamma node. The SVM Gamma node needs a small fix to make it follow the 0 ^ 0 == 1 rule, same as the Power node, or the Gamma node itself in OSL mode. Reviewers: #cycles Differential Revision: https://developer.blender.org/D2263
2016-09-29 00:35:53 +03:00
.add_connection("Attribute::Fac", "Gamma_Cx::Gamma")
/* constant on the right */
Cycles: fix missing ShaderNode ownership in render_graph_finalize_test
2020-10-13 15:36:52 +02:00
.add_node(ShaderNodeBuilder<GammaNode>(graph, "Gamma_xC").set("Gamma", 0.0f))
Cycles: implement partial constant folding for exponentiation. This is also an important mathematical operation that can be folded if it is known that one argument is a certain constant. For colors the operation is provided as a Gamma node. The SVM Gamma node needs a small fix to make it follow the 0 ^ 0 == 1 rule, same as the Power node, or the Gamma node itself in OSL mode. Reviewers: #cycles Differential Revision: https://developer.blender.org/D2263
2016-09-29 00:35:53 +03:00
.add_connection("Attribute::Color", "Gamma_xC::Color")
/* output sum */
Cycles: fix missing ShaderNode ownership in render_graph_finalize_test
2020-10-13 15:36:52 +02:00
.add_node(ShaderNodeBuilder<MixNode>(graph, "Out")
Cycles API: encapsulate Node socket members This encapsulates Node socket members behind a set of specific methods; as such it is no longer possible to directly access Node class members from exporters and parts of Cycles. The methods are defined via the NODE_SOCKET_API macros in `graph/ node.h`, and are for getting or setting a specific socket's value, as well as querying or modifying the state of its update flag. The setters will check whether the value has changed and tag the socket as modified appropriately. This will let us know how a Node has changed and what to update, which is the first concrete step toward a more granular scene update system. Since the setters will tag the Node sockets as modified when passed different data, this patch also removes the various modified methods on Nodes in favor of Node::is_modified which checks the sockets' update flags status. Reviewed By: brecht Maniphest Tasks: T79174 Differential Revision: https://developer.blender.org/D8544
2020-11-04 11:17:38 +01:00
.set_param("mix_type", NODE_MIX_ADD)
.set_param("use_clamp", true)
Cycles: implement partial constant folding for exponentiation. This is also an important mathematical operation that can be folded if it is known that one argument is a certain constant. For colors the operation is provided as a Gamma node. The SVM Gamma node needs a small fix to make it follow the 0 ^ 0 == 1 rule, same as the Power node, or the Gamma node itself in OSL mode. Reviewers: #cycles Differential Revision: https://developer.blender.org/D2263
2016-09-29 00:35:53 +03:00
.set("Fac", 1.0f))
.add_connection("Gamma_Cx::Color", "Out::Color1")
.add_connection("Gamma_xC::Color", "Out::Color2")
.output_color("Out::Color");
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
Refactor: Cycles: Replace new/delete by unique_ptr, in simple cases Pull Request: https://projects.blender.org/blender/blender/pulls/132361
2024-12-29 23:13:45 +01:00
graph.finalize(scene.get());
Cycles: implement partial constant folding for exponentiation. This is also an important mathematical operation that can be folded if it is known that one argument is a certain constant. For colors the operation is provided as a Gamma node. The SVM Gamma node needs a small fix to make it follow the 0 ^ 0 == 1 rule, same as the Power node, or the Gamma node itself in OSL mode. Reviewers: #cycles Differential Revision: https://developer.blender.org/D2263
2016-09-29 00:35:53 +03:00
}
/*
* Tests: Gamma with one constant 1 input.
*/
Cycles: Fix memory leak in test and simplify code
2017-10-24 11:12:28 +02:00
TEST_F(RenderGraph, constant_fold_gamma_part_1)
Cycles: implement partial constant folding for exponentiation. This is also an important mathematical operation that can be folded if it is known that one argument is a certain constant. For colors the operation is provided as a Gamma node. The SVM Gamma node needs a small fix to make it follow the 0 ^ 0 == 1 rule, same as the Power node, or the Gamma node itself in OSL mode. Reviewers: #cycles Differential Revision: https://developer.blender.org/D2263
2016-09-29 00:35:53 +03:00
{
EXPECT_ANY_MESSAGE(log);
CORRECT_INFO_MESSAGE(log, "Folding Gamma_Cx::Color to constant (1, 1, 1).");
CORRECT_INFO_MESSAGE(log, "Folding Gamma_xC::Color to socket Attribute::Color.");
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
Cycles: implement partial constant folding for exponentiation. This is also an important mathematical operation that can be folded if it is known that one argument is a certain constant. For colors the operation is provided as a Gamma node. The SVM Gamma node needs a small fix to make it follow the 0 ^ 0 == 1 rule, same as the Power node, or the Gamma node itself in OSL mode. Reviewers: #cycles Differential Revision: https://developer.blender.org/D2263
2016-09-29 00:35:53 +03:00
builder
.add_attribute("Attribute")
/* constant on the left */
Cycles: add utility functions for zero float2/float3/float4/transform Ref D8237, T78710
2021-02-17 01:47:18 +01:00
.add_node(ShaderNodeBuilder<GammaNode>(graph, "Gamma_Cx").set("Color", one_float3()))
Cycles: implement partial constant folding for exponentiation. This is also an important mathematical operation that can be folded if it is known that one argument is a certain constant. For colors the operation is provided as a Gamma node. The SVM Gamma node needs a small fix to make it follow the 0 ^ 0 == 1 rule, same as the Power node, or the Gamma node itself in OSL mode. Reviewers: #cycles Differential Revision: https://developer.blender.org/D2263
2016-09-29 00:35:53 +03:00
.add_connection("Attribute::Fac", "Gamma_Cx::Gamma")
/* constant on the right */
Cycles: fix missing ShaderNode ownership in render_graph_finalize_test
2020-10-13 15:36:52 +02:00
.add_node(ShaderNodeBuilder<GammaNode>(graph, "Gamma_xC").set("Gamma", 1.0f))
Cycles: implement partial constant folding for exponentiation. This is also an important mathematical operation that can be folded if it is known that one argument is a certain constant. For colors the operation is provided as a Gamma node. The SVM Gamma node needs a small fix to make it follow the 0 ^ 0 == 1 rule, same as the Power node, or the Gamma node itself in OSL mode. Reviewers: #cycles Differential Revision: https://developer.blender.org/D2263
2016-09-29 00:35:53 +03:00
.add_connection("Attribute::Color", "Gamma_xC::Color")
/* output sum */
Cycles: fix missing ShaderNode ownership in render_graph_finalize_test
2020-10-13 15:36:52 +02:00
.add_node(ShaderNodeBuilder<MixNode>(graph, "Out")
Cycles API: encapsulate Node socket members This encapsulates Node socket members behind a set of specific methods; as such it is no longer possible to directly access Node class members from exporters and parts of Cycles. The methods are defined via the NODE_SOCKET_API macros in `graph/ node.h`, and are for getting or setting a specific socket's value, as well as querying or modifying the state of its update flag. The setters will check whether the value has changed and tag the socket as modified appropriately. This will let us know how a Node has changed and what to update, which is the first concrete step toward a more granular scene update system. Since the setters will tag the Node sockets as modified when passed different data, this patch also removes the various modified methods on Nodes in favor of Node::is_modified which checks the sockets' update flags status. Reviewed By: brecht Maniphest Tasks: T79174 Differential Revision: https://developer.blender.org/D8544
2020-11-04 11:17:38 +01:00
.set_param("mix_type", NODE_MIX_ADD)
.set_param("use_clamp", true)
Cycles: implement partial constant folding for exponentiation. This is also an important mathematical operation that can be folded if it is known that one argument is a certain constant. For colors the operation is provided as a Gamma node. The SVM Gamma node needs a small fix to make it follow the 0 ^ 0 == 1 rule, same as the Power node, or the Gamma node itself in OSL mode. Reviewers: #cycles Differential Revision: https://developer.blender.org/D2263
2016-09-29 00:35:53 +03:00
.set("Fac", 1.0f))
.add_connection("Gamma_Cx::Color", "Out::Color1")
.add_connection("Gamma_xC::Color", "Out::Color2")
.output_color("Out::Color");
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
Refactor: Cycles: Replace new/delete by unique_ptr, in simple cases Pull Request: https://projects.blender.org/blender/blender/pulls/132361
2024-12-29 23:13:45 +01:00
graph.finalize(scene.get());
Cycles: implement partial constant folding for exponentiation. This is also an important mathematical operation that can be folded if it is known that one argument is a certain constant. For colors the operation is provided as a Gamma node. The SVM Gamma node needs a small fix to make it follow the 0 ^ 0 == 1 rule, same as the Power node, or the Gamma node itself in OSL mode. Reviewers: #cycles Differential Revision: https://developer.blender.org/D2263
2016-09-29 00:35:53 +03:00
}
Cycles: add unit tests for supported constant folding rules. Code coverage of different combinations of secondary conditions is obviously not complete because there are so many of them, but all main rules should be there. The reason for CORRECT vs INVALID is that both words have the same number of characters so calls line up, but look quite different. Reviewers: #cycles, sergey Reviewed By: #cycles, sergey Subscribers: dingto, sergey, brecht Differential Revision: https://developer.blender.org/D2130
2016-08-01 18:53:20 +03:00
/*
* Tests: BrightnessContrast with all constant inputs.
*/
Cycles: Fix memory leak in test and simplify code
2017-10-24 11:12:28 +02:00
TEST_F(RenderGraph, constant_fold_bright_contrast)
Cycles: add unit tests for supported constant folding rules. Code coverage of different combinations of secondary conditions is obviously not complete because there are so many of them, but all main rules should be there. The reason for CORRECT vs INVALID is that both words have the same number of characters so calls line up, but look quite different. Reviewers: #cycles, sergey Reviewed By: #cycles, sergey Subscribers: dingto, sergey, brecht Differential Revision: https://developer.blender.org/D2130
2016-08-01 18:53:20 +03:00
{
EXPECT_ANY_MESSAGE(log);
CORRECT_INFO_MESSAGE(log, "Folding BrightContrast::Color to constant (0.16, 0.6, 1.04).");
builder
Cycles: fix missing ShaderNode ownership in render_graph_finalize_test
2020-10-13 15:36:52 +02:00
.add_node(ShaderNodeBuilder<BrightContrastNode>(graph, "BrightContrast")
Cycles: add unit tests for supported constant folding rules. Code coverage of different combinations of secondary conditions is obviously not complete because there are so many of them, but all main rules should be there. The reason for CORRECT vs INVALID is that both words have the same number of characters so calls line up, but look quite different. Reviewers: #cycles, sergey Reviewed By: #cycles, sergey Subscribers: dingto, sergey, brecht Differential Revision: https://developer.blender.org/D2130
2016-08-01 18:53:20 +03:00
.set("Color", make_float3(0.3f, 0.5f, 0.7f))
.set("Bright", 0.1f)
.set("Contrast", 1.2f))
.output_color("BrightContrast::Color");
Refactor: Cycles: Replace new/delete by unique_ptr, in simple cases Pull Request: https://projects.blender.org/blender/blender/pulls/132361
2024-12-29 23:13:45 +01:00
graph.finalize(scene.get());
Cycles: add unit tests for supported constant folding rules. Code coverage of different combinations of secondary conditions is obviously not complete because there are so many of them, but all main rules should be there. The reason for CORRECT vs INVALID is that both words have the same number of characters so calls line up, but look quite different. Reviewers: #cycles, sergey Reviewed By: #cycles, sergey Subscribers: dingto, sergey, brecht Differential Revision: https://developer.blender.org/D2130
2016-08-01 18:53:20 +03:00
}
/*
* Tests: blackbody with all constant inputs.
*/
Cycles: Fix memory leak in test and simplify code
2017-10-24 11:12:28 +02:00
TEST_F(RenderGraph, constant_fold_blackbody)
Cycles: add unit tests for supported constant folding rules. Code coverage of different combinations of secondary conditions is obviously not complete because there are so many of them, but all main rules should be there. The reason for CORRECT vs INVALID is that both words have the same number of characters so calls line up, but look quite different. Reviewers: #cycles, sergey Reviewed By: #cycles, sergey Subscribers: dingto, sergey, brecht Differential Revision: https://developer.blender.org/D2130
2016-08-01 18:53:20 +03:00
{
EXPECT_ANY_MESSAGE(log);
Fix T98036: Cycles blackbody inaccurate for low temperature and wide gamut Regenerate blackbody RGB curve fit to not clamp values, and extend down to 800K since it does now change below 965K. Note that as before, blackbody is only defined in the range 800K to 12000K and has a fixed value outside of that. But within that range there should be no more unnecessary gamut clamping.
2022-05-23 20:27:13 +02:00
CORRECT_INFO_MESSAGE(log, "Folding Blackbody::Color to constant (3.96553, 0.227897, 0).");
Cycles: add unit tests for supported constant folding rules. Code coverage of different combinations of secondary conditions is obviously not complete because there are so many of them, but all main rules should be there. The reason for CORRECT vs INVALID is that both words have the same number of characters so calls line up, but look quite different. Reviewers: #cycles, sergey Reviewed By: #cycles, sergey Subscribers: dingto, sergey, brecht Differential Revision: https://developer.blender.org/D2130
2016-08-01 18:53:20 +03:00
Cycles: fix missing ShaderNode ownership in render_graph_finalize_test
2020-10-13 15:36:52 +02:00
builder
.add_node(ShaderNodeBuilder<BlackbodyNode>(graph, "Blackbody").set("Temperature", 1200.0f))
Cycles: add unit tests for supported constant folding rules. Code coverage of different combinations of secondary conditions is obviously not complete because there are so many of them, but all main rules should be there. The reason for CORRECT vs INVALID is that both words have the same number of characters so calls line up, but look quite different. Reviewers: #cycles, sergey Reviewed By: #cycles, sergey Subscribers: dingto, sergey, brecht Differential Revision: https://developer.blender.org/D2130
2016-08-01 18:53:20 +03:00
.output_color("Blackbody::Color");
Refactor: Cycles: Replace new/delete by unique_ptr, in simple cases Pull Request: https://projects.blender.org/blender/blender/pulls/132361
2024-12-29 23:13:45 +01:00
graph.finalize(scene.get());
Cycles: add unit tests for supported constant folding rules. Code coverage of different combinations of secondary conditions is obviously not complete because there are so many of them, but all main rules should be there. The reason for CORRECT vs INVALID is that both words have the same number of characters so calls line up, but look quite different. Reviewers: #cycles, sergey Reviewed By: #cycles, sergey Subscribers: dingto, sergey, brecht Differential Revision: https://developer.blender.org/D2130
2016-08-01 18:53:20 +03:00
}
Cycles Tests: Fix Math tests when use_clamp is true. The clamp option is implemented using graph expansion, where a Clamp node named "clamp" is added and connected to the output. So the final result is actually from the node "clamp". Reviewers: brecht Differential Revision: https://developer.blender.org/D5540
2019-08-20 17:20:16 +02:00
/* A Note About The Math Node
*
* The clamp option is implemented using graph expansion, where a
* Clamp node named "clamp" is added and connected to the output.
* So the final result is actually from the node "clamp".
*/
Cycles: add unit tests for supported constant folding rules. Code coverage of different combinations of secondary conditions is obviously not complete because there are so many of them, but all main rules should be there. The reason for CORRECT vs INVALID is that both words have the same number of characters so calls line up, but look quite different. Reviewers: #cycles, sergey Reviewed By: #cycles, sergey Subscribers: dingto, sergey, brecht Differential Revision: https://developer.blender.org/D2130
2016-08-01 18:53:20 +03:00
/*
* Tests: Math with all constant inputs (clamp false).
*/
Cycles: Fix memory leak in test and simplify code
2017-10-24 11:12:28 +02:00
TEST_F(RenderGraph, constant_fold_math)
Cycles: add unit tests for supported constant folding rules. Code coverage of different combinations of secondary conditions is obviously not complete because there are so many of them, but all main rules should be there. The reason for CORRECT vs INVALID is that both words have the same number of characters so calls line up, but look quite different. Reviewers: #cycles, sergey Reviewed By: #cycles, sergey Subscribers: dingto, sergey, brecht Differential Revision: https://developer.blender.org/D2130
2016-08-01 18:53:20 +03:00
{
EXPECT_ANY_MESSAGE(log);
CORRECT_INFO_MESSAGE(log, "Folding Math::Value to constant (1.6).");
builder
Cycles: fix missing ShaderNode ownership in render_graph_finalize_test
2020-10-13 15:36:52 +02:00
.add_node(ShaderNodeBuilder<MathNode>(graph, "Math")
Cycles API: encapsulate Node socket members This encapsulates Node socket members behind a set of specific methods; as such it is no longer possible to directly access Node class members from exporters and parts of Cycles. The methods are defined via the NODE_SOCKET_API macros in `graph/ node.h`, and are for getting or setting a specific socket's value, as well as querying or modifying the state of its update flag. The setters will check whether the value has changed and tag the socket as modified appropriately. This will let us know how a Node has changed and what to update, which is the first concrete step toward a more granular scene update system. Since the setters will tag the Node sockets as modified when passed different data, this patch also removes the various modified methods on Nodes in favor of Node::is_modified which checks the sockets' update flags status. Reviewed By: brecht Maniphest Tasks: T79174 Differential Revision: https://developer.blender.org/D8544
2020-11-04 11:17:38 +01:00
.set_param("math_type", NODE_MATH_ADD)
.set_param("use_clamp", false)
Cycles: add unit tests for supported constant folding rules. Code coverage of different combinations of secondary conditions is obviously not complete because there are so many of them, but all main rules should be there. The reason for CORRECT vs INVALID is that both words have the same number of characters so calls line up, but look quite different. Reviewers: #cycles, sergey Reviewed By: #cycles, sergey Subscribers: dingto, sergey, brecht Differential Revision: https://developer.blender.org/D2130
2016-08-01 18:53:20 +03:00
.set("Value1", 0.7f)
.set("Value2", 0.9f))
Cycles: tweak some folding tests to avoid unnecessary type conversion. It's easy to connect a simple value to output without forcing conversion to color by using the Strength socket of Emission.
2016-08-02 12:08:04 +03:00
.output_value("Math::Value");
Cycles: add unit tests for supported constant folding rules. Code coverage of different combinations of secondary conditions is obviously not complete because there are so many of them, but all main rules should be there. The reason for CORRECT vs INVALID is that both words have the same number of characters so calls line up, but look quite different. Reviewers: #cycles, sergey Reviewed By: #cycles, sergey Subscribers: dingto, sergey, brecht Differential Revision: https://developer.blender.org/D2130
2016-08-01 18:53:20 +03:00
Refactor: Cycles: Replace new/delete by unique_ptr, in simple cases Pull Request: https://projects.blender.org/blender/blender/pulls/132361
2024-12-29 23:13:45 +01:00
graph.finalize(scene.get());
Cycles: add unit tests for supported constant folding rules. Code coverage of different combinations of secondary conditions is obviously not complete because there are so many of them, but all main rules should be there. The reason for CORRECT vs INVALID is that both words have the same number of characters so calls line up, but look quite different. Reviewers: #cycles, sergey Reviewed By: #cycles, sergey Subscribers: dingto, sergey, brecht Differential Revision: https://developer.blender.org/D2130
2016-08-01 18:53:20 +03:00
}
/*
* Tests: Math with all constant inputs (clamp true).
*/
Cycles: Fix memory leak in test and simplify code
2017-10-24 11:12:28 +02:00
TEST_F(RenderGraph, constant_fold_math_clamp)
Cycles: add unit tests for supported constant folding rules. Code coverage of different combinations of secondary conditions is obviously not complete because there are so many of them, but all main rules should be there. The reason for CORRECT vs INVALID is that both words have the same number of characters so calls line up, but look quite different. Reviewers: #cycles, sergey Reviewed By: #cycles, sergey Subscribers: dingto, sergey, brecht Differential Revision: https://developer.blender.org/D2130
2016-08-01 18:53:20 +03:00
{
EXPECT_ANY_MESSAGE(log);
Cycles Tests: Fix Math tests when use_clamp is true. The clamp option is implemented using graph expansion, where a Clamp node named "clamp" is added and connected to the output. So the final result is actually from the node "clamp". Reviewers: brecht Differential Revision: https://developer.blender.org/D5540
2019-08-20 17:20:16 +02:00
CORRECT_INFO_MESSAGE(log, "Folding clamp::Result to constant (1).");
Cycles: add unit tests for supported constant folding rules. Code coverage of different combinations of secondary conditions is obviously not complete because there are so many of them, but all main rules should be there. The reason for CORRECT vs INVALID is that both words have the same number of characters so calls line up, but look quite different. Reviewers: #cycles, sergey Reviewed By: #cycles, sergey Subscribers: dingto, sergey, brecht Differential Revision: https://developer.blender.org/D2130
2016-08-01 18:53:20 +03:00
builder
Cycles: fix missing ShaderNode ownership in render_graph_finalize_test
2020-10-13 15:36:52 +02:00
.add_node(ShaderNodeBuilder<MathNode>(graph, "Math")
Cycles API: encapsulate Node socket members This encapsulates Node socket members behind a set of specific methods; as such it is no longer possible to directly access Node class members from exporters and parts of Cycles. The methods are defined via the NODE_SOCKET_API macros in `graph/ node.h`, and are for getting or setting a specific socket's value, as well as querying or modifying the state of its update flag. The setters will check whether the value has changed and tag the socket as modified appropriately. This will let us know how a Node has changed and what to update, which is the first concrete step toward a more granular scene update system. Since the setters will tag the Node sockets as modified when passed different data, this patch also removes the various modified methods on Nodes in favor of Node::is_modified which checks the sockets' update flags status. Reviewed By: brecht Maniphest Tasks: T79174 Differential Revision: https://developer.blender.org/D8544
2020-11-04 11:17:38 +01:00
.set_param("math_type", NODE_MATH_ADD)
.set_param("use_clamp", true)
Cycles: add unit tests for supported constant folding rules. Code coverage of different combinations of secondary conditions is obviously not complete because there are so many of them, but all main rules should be there. The reason for CORRECT vs INVALID is that both words have the same number of characters so calls line up, but look quite different. Reviewers: #cycles, sergey Reviewed By: #cycles, sergey Subscribers: dingto, sergey, brecht Differential Revision: https://developer.blender.org/D2130
2016-08-01 18:53:20 +03:00
.set("Value1", 0.7f)
.set("Value2", 0.9f))
Cycles: tweak some folding tests to avoid unnecessary type conversion. It's easy to connect a simple value to output without forcing conversion to color by using the Strength socket of Emission.
2016-08-02 12:08:04 +03:00
.output_value("Math::Value");
Cycles: add unit tests for supported constant folding rules. Code coverage of different combinations of secondary conditions is obviously not complete because there are so many of them, but all main rules should be there. The reason for CORRECT vs INVALID is that both words have the same number of characters so calls line up, but look quite different. Reviewers: #cycles, sergey Reviewed By: #cycles, sergey Subscribers: dingto, sergey, brecht Differential Revision: https://developer.blender.org/D2130
2016-08-01 18:53:20 +03:00
Refactor: Cycles: Replace new/delete by unique_ptr, in simple cases Pull Request: https://projects.blender.org/blender/blender/pulls/132361
2024-12-29 23:13:45 +01:00
graph.finalize(scene.get());
Cycles: add unit tests for supported constant folding rules. Code coverage of different combinations of secondary conditions is obviously not complete because there are so many of them, but all main rules should be there. The reason for CORRECT vs INVALID is that both words have the same number of characters so calls line up, but look quite different. Reviewers: #cycles, sergey Reviewed By: #cycles, sergey Subscribers: dingto, sergey, brecht Differential Revision: https://developer.blender.org/D2130
2016-08-01 18:53:20 +03:00
}
/*
* Graph for testing partial folds of Math with one constant argument.
* Includes 2 tests: constant on each side.
*/
static void build_math_partial_test_graph(ShaderGraphBuilder &builder,
Shading: Refactor Math node and use dynamic inputs. - Implement dynamic inputs. The second input is now unavailable in single operand math operators. - Reimplemenet the clamp option using graph expansion for Cycles. - Clean up code and unify naming between Blender and Cycles. - Remove unused code. Reviewers: brecht Differential Revision: https://developer.blender.org/D5481
2019-08-18 11:16:04 +02:00
NodeMathType type,
Refactor: Cycles: Add const keyword to more function parameters Pull Request: https://projects.blender.org/blender/blender/pulls/132361
2025-01-01 18:15:54 +01:00
const float constval)
Cycles: add unit tests for supported constant folding rules. Code coverage of different combinations of secondary conditions is obviously not complete because there are so many of them, but all main rules should be there. The reason for CORRECT vs INVALID is that both words have the same number of characters so calls line up, but look quite different. Reviewers: #cycles, sergey Reviewed By: #cycles, sergey Subscribers: dingto, sergey, brecht Differential Revision: https://developer.blender.org/D2130
2016-08-01 18:53:20 +03:00
{
builder
.add_attribute("Attribute")
/* constant on the left */
Cycles: fix missing ShaderNode ownership in render_graph_finalize_test
2020-10-13 15:36:52 +02:00
.add_node(ShaderNodeBuilder<MathNode>(builder.graph(), "Math_Cx")
Cycles API: encapsulate Node socket members This encapsulates Node socket members behind a set of specific methods; as such it is no longer possible to directly access Node class members from exporters and parts of Cycles. The methods are defined via the NODE_SOCKET_API macros in `graph/ node.h`, and are for getting or setting a specific socket's value, as well as querying or modifying the state of its update flag. The setters will check whether the value has changed and tag the socket as modified appropriately. This will let us know how a Node has changed and what to update, which is the first concrete step toward a more granular scene update system. Since the setters will tag the Node sockets as modified when passed different data, this patch also removes the various modified methods on Nodes in favor of Node::is_modified which checks the sockets' update flags status. Reviewed By: brecht Maniphest Tasks: T79174 Differential Revision: https://developer.blender.org/D8544
2020-11-04 11:17:38 +01:00
.set_param("math_type", type)
.set_param("use_clamp", false)
Cycles: add unit tests for supported constant folding rules. Code coverage of different combinations of secondary conditions is obviously not complete because there are so many of them, but all main rules should be there. The reason for CORRECT vs INVALID is that both words have the same number of characters so calls line up, but look quite different. Reviewers: #cycles, sergey Reviewed By: #cycles, sergey Subscribers: dingto, sergey, brecht Differential Revision: https://developer.blender.org/D2130
2016-08-01 18:53:20 +03:00
.set("Value1", constval))
.add_connection("Attribute::Fac", "Math_Cx::Value2")
/* constant on the right */
Cycles: fix missing ShaderNode ownership in render_graph_finalize_test
2020-10-13 15:36:52 +02:00
.add_node(ShaderNodeBuilder<MathNode>(builder.graph(), "Math_xC")
Cycles API: encapsulate Node socket members This encapsulates Node socket members behind a set of specific methods; as such it is no longer possible to directly access Node class members from exporters and parts of Cycles. The methods are defined via the NODE_SOCKET_API macros in `graph/ node.h`, and are for getting or setting a specific socket's value, as well as querying or modifying the state of its update flag. The setters will check whether the value has changed and tag the socket as modified appropriately. This will let us know how a Node has changed and what to update, which is the first concrete step toward a more granular scene update system. Since the setters will tag the Node sockets as modified when passed different data, this patch also removes the various modified methods on Nodes in favor of Node::is_modified which checks the sockets' update flags status. Reviewed By: brecht Maniphest Tasks: T79174 Differential Revision: https://developer.blender.org/D8544
2020-11-04 11:17:38 +01:00
.set_param("math_type", type)
.set_param("use_clamp", false)
Cycles: add unit tests for supported constant folding rules. Code coverage of different combinations of secondary conditions is obviously not complete because there are so many of them, but all main rules should be there. The reason for CORRECT vs INVALID is that both words have the same number of characters so calls line up, but look quite different. Reviewers: #cycles, sergey Reviewed By: #cycles, sergey Subscribers: dingto, sergey, brecht Differential Revision: https://developer.blender.org/D2130
2016-08-01 18:53:20 +03:00
.set("Value2", constval))
.add_connection("Attribute::Fac", "Math_xC::Value1")
/* output sum */
Cycles: fix missing ShaderNode ownership in render_graph_finalize_test
2020-10-13 15:36:52 +02:00
.add_node(ShaderNodeBuilder<MathNode>(builder.graph(), "Out")
Cycles API: encapsulate Node socket members This encapsulates Node socket members behind a set of specific methods; as such it is no longer possible to directly access Node class members from exporters and parts of Cycles. The methods are defined via the NODE_SOCKET_API macros in `graph/ node.h`, and are for getting or setting a specific socket's value, as well as querying or modifying the state of its update flag. The setters will check whether the value has changed and tag the socket as modified appropriately. This will let us know how a Node has changed and what to update, which is the first concrete step toward a more granular scene update system. Since the setters will tag the Node sockets as modified when passed different data, this patch also removes the various modified methods on Nodes in favor of Node::is_modified which checks the sockets' update flags status. Reviewed By: brecht Maniphest Tasks: T79174 Differential Revision: https://developer.blender.org/D8544
2020-11-04 11:17:38 +01:00
.set_param("math_type", NODE_MATH_ADD)
.set_param("use_clamp", true))
Cycles: add unit tests for supported constant folding rules. Code coverage of different combinations of secondary conditions is obviously not complete because there are so many of them, but all main rules should be there. The reason for CORRECT vs INVALID is that both words have the same number of characters so calls line up, but look quite different. Reviewers: #cycles, sergey Reviewed By: #cycles, sergey Subscribers: dingto, sergey, brecht Differential Revision: https://developer.blender.org/D2130
2016-08-01 18:53:20 +03:00
.add_connection("Math_Cx::Value", "Out::Value1")
.add_connection("Math_xC::Value", "Out::Value2")
Cycles: tweak some folding tests to avoid unnecessary type conversion. It's easy to connect a simple value to output without forcing conversion to color by using the Strength socket of Emission.
2016-08-02 12:08:04 +03:00
.output_value("Out::Value");
Cycles: add unit tests for supported constant folding rules. Code coverage of different combinations of secondary conditions is obviously not complete because there are so many of them, but all main rules should be there. The reason for CORRECT vs INVALID is that both words have the same number of characters so calls line up, but look quite different. Reviewers: #cycles, sergey Reviewed By: #cycles, sergey Subscribers: dingto, sergey, brecht Differential Revision: https://developer.blender.org/D2130
2016-08-01 18:53:20 +03:00
}
/*
* Tests: partial folding for Math Add with known 0.
*/
Cycles: Fix memory leak in test and simplify code
2017-10-24 11:12:28 +02:00
TEST_F(RenderGraph, constant_fold_part_math_add_0)
Cycles: add unit tests for supported constant folding rules. Code coverage of different combinations of secondary conditions is obviously not complete because there are so many of them, but all main rules should be there. The reason for CORRECT vs INVALID is that both words have the same number of characters so calls line up, but look quite different. Reviewers: #cycles, sergey Reviewed By: #cycles, sergey Subscribers: dingto, sergey, brecht Differential Revision: https://developer.blender.org/D2130
2016-08-01 18:53:20 +03:00
{
EXPECT_ANY_MESSAGE(log);
/* X + 0 == 0 + X == X */
CORRECT_INFO_MESSAGE(log, "Folding Math_Cx::Value to socket Attribute::Fac.");
CORRECT_INFO_MESSAGE(log, "Folding Math_xC::Value to socket Attribute::Fac.");
Cycles Tests: Fix Math tests when use_clamp is true. The clamp option is implemented using graph expansion, where a Clamp node named "clamp" is added and connected to the output. So the final result is actually from the node "clamp". Reviewers: brecht Differential Revision: https://developer.blender.org/D5540
2019-08-20 17:20:16 +02:00
INVALID_INFO_MESSAGE(log, "Folding clamp::");
Cycles: add unit tests for supported constant folding rules. Code coverage of different combinations of secondary conditions is obviously not complete because there are so many of them, but all main rules should be there. The reason for CORRECT vs INVALID is that both words have the same number of characters so calls line up, but look quite different. Reviewers: #cycles, sergey Reviewed By: #cycles, sergey Subscribers: dingto, sergey, brecht Differential Revision: https://developer.blender.org/D2130
2016-08-01 18:53:20 +03:00
build_math_partial_test_graph(builder, NODE_MATH_ADD, 0.0f);
Refactor: Cycles: Replace new/delete by unique_ptr, in simple cases Pull Request: https://projects.blender.org/blender/blender/pulls/132361
2024-12-29 23:13:45 +01:00
graph.finalize(scene.get());
Cycles: add unit tests for supported constant folding rules. Code coverage of different combinations of secondary conditions is obviously not complete because there are so many of them, but all main rules should be there. The reason for CORRECT vs INVALID is that both words have the same number of characters so calls line up, but look quite different. Reviewers: #cycles, sergey Reviewed By: #cycles, sergey Subscribers: dingto, sergey, brecht Differential Revision: https://developer.blender.org/D2130
2016-08-01 18:53:20 +03:00
}
/*
Cleanup: spelling in comments
2023-08-25 08:56:58 +10:00
* Tests: partial folding for Math Subtract with known 0.
Cycles: add unit tests for supported constant folding rules. Code coverage of different combinations of secondary conditions is obviously not complete because there are so many of them, but all main rules should be there. The reason for CORRECT vs INVALID is that both words have the same number of characters so calls line up, but look quite different. Reviewers: #cycles, sergey Reviewed By: #cycles, sergey Subscribers: dingto, sergey, brecht Differential Revision: https://developer.blender.org/D2130
2016-08-01 18:53:20 +03:00
*/
Cycles: Fix memory leak in test and simplify code
2017-10-24 11:12:28 +02:00
TEST_F(RenderGraph, constant_fold_part_math_sub_0)
Cycles: add unit tests for supported constant folding rules. Code coverage of different combinations of secondary conditions is obviously not complete because there are so many of them, but all main rules should be there. The reason for CORRECT vs INVALID is that both words have the same number of characters so calls line up, but look quite different. Reviewers: #cycles, sergey Reviewed By: #cycles, sergey Subscribers: dingto, sergey, brecht Differential Revision: https://developer.blender.org/D2130
2016-08-01 18:53:20 +03:00
{
EXPECT_ANY_MESSAGE(log);
/* X - 0 == X */
INVALID_INFO_MESSAGE(log, "Folding Math_Cx::");
CORRECT_INFO_MESSAGE(log, "Folding Math_xC::Value to socket Attribute::Fac.");
Cycles Tests: Fix Math tests when use_clamp is true. The clamp option is implemented using graph expansion, where a Clamp node named "clamp" is added and connected to the output. So the final result is actually from the node "clamp". Reviewers: brecht Differential Revision: https://developer.blender.org/D5540
2019-08-20 17:20:16 +02:00
INVALID_INFO_MESSAGE(log, "Folding clamp::");
Cycles: add unit tests for supported constant folding rules. Code coverage of different combinations of secondary conditions is obviously not complete because there are so many of them, but all main rules should be there. The reason for CORRECT vs INVALID is that both words have the same number of characters so calls line up, but look quite different. Reviewers: #cycles, sergey Reviewed By: #cycles, sergey Subscribers: dingto, sergey, brecht Differential Revision: https://developer.blender.org/D2130
2016-08-01 18:53:20 +03:00
build_math_partial_test_graph(builder, NODE_MATH_SUBTRACT, 0.0f);
Refactor: Cycles: Replace new/delete by unique_ptr, in simple cases Pull Request: https://projects.blender.org/blender/blender/pulls/132361
2024-12-29 23:13:45 +01:00
graph.finalize(scene.get());
Cycles: add unit tests for supported constant folding rules. Code coverage of different combinations of secondary conditions is obviously not complete because there are so many of them, but all main rules should be there. The reason for CORRECT vs INVALID is that both words have the same number of characters so calls line up, but look quite different. Reviewers: #cycles, sergey Reviewed By: #cycles, sergey Subscribers: dingto, sergey, brecht Differential Revision: https://developer.blender.org/D2130
2016-08-01 18:53:20 +03:00
}
/*
Cleanup: spelling in comments
2023-08-25 08:56:58 +10:00
* Tests: partial folding for Math Multiply with known 1.
Cycles: add unit tests for supported constant folding rules. Code coverage of different combinations of secondary conditions is obviously not complete because there are so many of them, but all main rules should be there. The reason for CORRECT vs INVALID is that both words have the same number of characters so calls line up, but look quite different. Reviewers: #cycles, sergey Reviewed By: #cycles, sergey Subscribers: dingto, sergey, brecht Differential Revision: https://developer.blender.org/D2130
2016-08-01 18:53:20 +03:00
*/
Cycles: Fix memory leak in test and simplify code
2017-10-24 11:12:28 +02:00
TEST_F(RenderGraph, constant_fold_part_math_mul_1)
Cycles: add unit tests for supported constant folding rules. Code coverage of different combinations of secondary conditions is obviously not complete because there are so many of them, but all main rules should be there. The reason for CORRECT vs INVALID is that both words have the same number of characters so calls line up, but look quite different. Reviewers: #cycles, sergey Reviewed By: #cycles, sergey Subscribers: dingto, sergey, brecht Differential Revision: https://developer.blender.org/D2130
2016-08-01 18:53:20 +03:00
{
EXPECT_ANY_MESSAGE(log);
/* X * 1 == 1 * X == X */
CORRECT_INFO_MESSAGE(log, "Folding Math_Cx::Value to socket Attribute::Fac.");
CORRECT_INFO_MESSAGE(log, "Folding Math_xC::Value to socket Attribute::Fac.");
Cycles Tests: Fix Math tests when use_clamp is true. The clamp option is implemented using graph expansion, where a Clamp node named "clamp" is added and connected to the output. So the final result is actually from the node "clamp". Reviewers: brecht Differential Revision: https://developer.blender.org/D5540
2019-08-20 17:20:16 +02:00
INVALID_INFO_MESSAGE(log, "Folding clamp::");
Cycles: add unit tests for supported constant folding rules. Code coverage of different combinations of secondary conditions is obviously not complete because there are so many of them, but all main rules should be there. The reason for CORRECT vs INVALID is that both words have the same number of characters so calls line up, but look quite different. Reviewers: #cycles, sergey Reviewed By: #cycles, sergey Subscribers: dingto, sergey, brecht Differential Revision: https://developer.blender.org/D2130
2016-08-01 18:53:20 +03:00
build_math_partial_test_graph(builder, NODE_MATH_MULTIPLY, 1.0f);
Refactor: Cycles: Replace new/delete by unique_ptr, in simple cases Pull Request: https://projects.blender.org/blender/blender/pulls/132361
2024-12-29 23:13:45 +01:00
graph.finalize(scene.get());
Cycles: add unit tests for supported constant folding rules. Code coverage of different combinations of secondary conditions is obviously not complete because there are so many of them, but all main rules should be there. The reason for CORRECT vs INVALID is that both words have the same number of characters so calls line up, but look quite different. Reviewers: #cycles, sergey Reviewed By: #cycles, sergey Subscribers: dingto, sergey, brecht Differential Revision: https://developer.blender.org/D2130
2016-08-01 18:53:20 +03:00
}
/*
Cleanup: spelling in comments
2023-08-25 08:56:58 +10:00
* Tests: partial folding for Math Divide with known 1.
Cycles: add unit tests for supported constant folding rules. Code coverage of different combinations of secondary conditions is obviously not complete because there are so many of them, but all main rules should be there. The reason for CORRECT vs INVALID is that both words have the same number of characters so calls line up, but look quite different. Reviewers: #cycles, sergey Reviewed By: #cycles, sergey Subscribers: dingto, sergey, brecht Differential Revision: https://developer.blender.org/D2130
2016-08-01 18:53:20 +03:00
*/
Cycles: Fix memory leak in test and simplify code
2017-10-24 11:12:28 +02:00
TEST_F(RenderGraph, constant_fold_part_math_div_1)
Cycles: add unit tests for supported constant folding rules. Code coverage of different combinations of secondary conditions is obviously not complete because there are so many of them, but all main rules should be there. The reason for CORRECT vs INVALID is that both words have the same number of characters so calls line up, but look quite different. Reviewers: #cycles, sergey Reviewed By: #cycles, sergey Subscribers: dingto, sergey, brecht Differential Revision: https://developer.blender.org/D2130
2016-08-01 18:53:20 +03:00
{
EXPECT_ANY_MESSAGE(log);
/* X / 1 == X */
INVALID_INFO_MESSAGE(log, "Folding Math_Cx::");
CORRECT_INFO_MESSAGE(log, "Folding Math_xC::Value to socket Attribute::Fac.");
Cycles Tests: Fix Math tests when use_clamp is true. The clamp option is implemented using graph expansion, where a Clamp node named "clamp" is added and connected to the output. So the final result is actually from the node "clamp". Reviewers: brecht Differential Revision: https://developer.blender.org/D5540
2019-08-20 17:20:16 +02:00
INVALID_INFO_MESSAGE(log, "Folding clamp::");
Cycles: add unit tests for supported constant folding rules. Code coverage of different combinations of secondary conditions is obviously not complete because there are so many of them, but all main rules should be there. The reason for CORRECT vs INVALID is that both words have the same number of characters so calls line up, but look quite different. Reviewers: #cycles, sergey Reviewed By: #cycles, sergey Subscribers: dingto, sergey, brecht Differential Revision: https://developer.blender.org/D2130
2016-08-01 18:53:20 +03:00
build_math_partial_test_graph(builder, NODE_MATH_DIVIDE, 1.0f);
Refactor: Cycles: Replace new/delete by unique_ptr, in simple cases Pull Request: https://projects.blender.org/blender/blender/pulls/132361
2024-12-29 23:13:45 +01:00
graph.finalize(scene.get());
Cycles: add unit tests for supported constant folding rules. Code coverage of different combinations of secondary conditions is obviously not complete because there are so many of them, but all main rules should be there. The reason for CORRECT vs INVALID is that both words have the same number of characters so calls line up, but look quite different. Reviewers: #cycles, sergey Reviewed By: #cycles, sergey Subscribers: dingto, sergey, brecht Differential Revision: https://developer.blender.org/D2130
2016-08-01 18:53:20 +03:00
}
/*
Cleanup: spelling in comments
2023-08-25 08:56:58 +10:00
* Tests: partial folding for Math Multiply with known 0.
Cycles: add unit tests for supported constant folding rules. Code coverage of different combinations of secondary conditions is obviously not complete because there are so many of them, but all main rules should be there. The reason for CORRECT vs INVALID is that both words have the same number of characters so calls line up, but look quite different. Reviewers: #cycles, sergey Reviewed By: #cycles, sergey Subscribers: dingto, sergey, brecht Differential Revision: https://developer.blender.org/D2130
2016-08-01 18:53:20 +03:00
*/
Cycles: Fix memory leak in test and simplify code
2017-10-24 11:12:28 +02:00
TEST_F(RenderGraph, constant_fold_part_math_mul_0)
Cycles: add unit tests for supported constant folding rules. Code coverage of different combinations of secondary conditions is obviously not complete because there are so many of them, but all main rules should be there. The reason for CORRECT vs INVALID is that both words have the same number of characters so calls line up, but look quite different. Reviewers: #cycles, sergey Reviewed By: #cycles, sergey Subscribers: dingto, sergey, brecht Differential Revision: https://developer.blender.org/D2130
2016-08-01 18:53:20 +03:00
{
EXPECT_ANY_MESSAGE(log);
/* X * 0 == 0 * X == 0 */
CORRECT_INFO_MESSAGE(log, "Folding Math_Cx::Value to constant (0).");
CORRECT_INFO_MESSAGE(log, "Folding Math_xC::Value to constant (0).");
Cycles Tests: Fix Math tests when use_clamp is true. The clamp option is implemented using graph expansion, where a Clamp node named "clamp" is added and connected to the output. So the final result is actually from the node "clamp". Reviewers: brecht Differential Revision: https://developer.blender.org/D5540
2019-08-20 17:20:16 +02:00
CORRECT_INFO_MESSAGE(log, "Folding clamp::Result to constant (0)");
Cycles: add unit tests for supported constant folding rules. Code coverage of different combinations of secondary conditions is obviously not complete because there are so many of them, but all main rules should be there. The reason for CORRECT vs INVALID is that both words have the same number of characters so calls line up, but look quite different. Reviewers: #cycles, sergey Reviewed By: #cycles, sergey Subscribers: dingto, sergey, brecht Differential Revision: https://developer.blender.org/D2130
2016-08-01 18:53:20 +03:00
CORRECT_INFO_MESSAGE(log, "Discarding closure EmissionNode.");
build_math_partial_test_graph(builder, NODE_MATH_MULTIPLY, 0.0f);
Refactor: Cycles: Replace new/delete by unique_ptr, in simple cases Pull Request: https://projects.blender.org/blender/blender/pulls/132361
2024-12-29 23:13:45 +01:00
graph.finalize(scene.get());
Cycles: add unit tests for supported constant folding rules. Code coverage of different combinations of secondary conditions is obviously not complete because there are so many of them, but all main rules should be there. The reason for CORRECT vs INVALID is that both words have the same number of characters so calls line up, but look quite different. Reviewers: #cycles, sergey Reviewed By: #cycles, sergey Subscribers: dingto, sergey, brecht Differential Revision: https://developer.blender.org/D2130
2016-08-01 18:53:20 +03:00
}
/*
Cleanup: spelling in comments
2023-08-25 08:56:58 +10:00
* Tests: partial folding for Math Divide with known 0.
Cycles: add unit tests for supported constant folding rules. Code coverage of different combinations of secondary conditions is obviously not complete because there are so many of them, but all main rules should be there. The reason for CORRECT vs INVALID is that both words have the same number of characters so calls line up, but look quite different. Reviewers: #cycles, sergey Reviewed By: #cycles, sergey Subscribers: dingto, sergey, brecht Differential Revision: https://developer.blender.org/D2130
2016-08-01 18:53:20 +03:00
*/
Cycles: Fix memory leak in test and simplify code
2017-10-24 11:12:28 +02:00
TEST_F(RenderGraph, constant_fold_part_math_div_0)
Cycles: add unit tests for supported constant folding rules. Code coverage of different combinations of secondary conditions is obviously not complete because there are so many of them, but all main rules should be there. The reason for CORRECT vs INVALID is that both words have the same number of characters so calls line up, but look quite different. Reviewers: #cycles, sergey Reviewed By: #cycles, sergey Subscribers: dingto, sergey, brecht Differential Revision: https://developer.blender.org/D2130
2016-08-01 18:53:20 +03:00
{
EXPECT_ANY_MESSAGE(log);
/* 0 / X == 0 */
CORRECT_INFO_MESSAGE(log, "Folding Math_Cx::Value to constant (0).");
INVALID_INFO_MESSAGE(log, "Folding Math_xC::");
Cycles Tests: Fix Math tests when use_clamp is true. The clamp option is implemented using graph expansion, where a Clamp node named "clamp" is added and connected to the output. So the final result is actually from the node "clamp". Reviewers: brecht Differential Revision: https://developer.blender.org/D5540
2019-08-20 17:20:16 +02:00
INVALID_INFO_MESSAGE(log, "Folding clamp::");
Cycles: add unit tests for supported constant folding rules. Code coverage of different combinations of secondary conditions is obviously not complete because there are so many of them, but all main rules should be there. The reason for CORRECT vs INVALID is that both words have the same number of characters so calls line up, but look quite different. Reviewers: #cycles, sergey Reviewed By: #cycles, sergey Subscribers: dingto, sergey, brecht Differential Revision: https://developer.blender.org/D2130
2016-08-01 18:53:20 +03:00
build_math_partial_test_graph(builder, NODE_MATH_DIVIDE, 0.0f);
Refactor: Cycles: Replace new/delete by unique_ptr, in simple cases Pull Request: https://projects.blender.org/blender/blender/pulls/132361
2024-12-29 23:13:45 +01:00
graph.finalize(scene.get());
Cycles: add unit tests for supported constant folding rules. Code coverage of different combinations of secondary conditions is obviously not complete because there are so many of them, but all main rules should be there. The reason for CORRECT vs INVALID is that both words have the same number of characters so calls line up, but look quite different. Reviewers: #cycles, sergey Reviewed By: #cycles, sergey Subscribers: dingto, sergey, brecht Differential Revision: https://developer.blender.org/D2130
2016-08-01 18:53:20 +03:00
}
Cycles: implement partial constant folding for exponentiation. This is also an important mathematical operation that can be folded if it is known that one argument is a certain constant. For colors the operation is provided as a Gamma node. The SVM Gamma node needs a small fix to make it follow the 0 ^ 0 == 1 rule, same as the Power node, or the Gamma node itself in OSL mode. Reviewers: #cycles Differential Revision: https://developer.blender.org/D2263
2016-09-29 00:35:53 +03:00
/*
* Tests: partial folding for Math Power with known 0.
*/
Cycles: Fix memory leak in test and simplify code
2017-10-24 11:12:28 +02:00
TEST_F(RenderGraph, constant_fold_part_math_pow_0)
Cycles: implement partial constant folding for exponentiation. This is also an important mathematical operation that can be folded if it is known that one argument is a certain constant. For colors the operation is provided as a Gamma node. The SVM Gamma node needs a small fix to make it follow the 0 ^ 0 == 1 rule, same as the Power node, or the Gamma node itself in OSL mode. Reviewers: #cycles Differential Revision: https://developer.blender.org/D2263
2016-09-29 00:35:53 +03:00
{
EXPECT_ANY_MESSAGE(log);
/* X ^ 0 == 1 */
INVALID_INFO_MESSAGE(log, "Folding Math_Cx::");
CORRECT_INFO_MESSAGE(log, "Folding Math_xC::Value to constant (1).");
Cycles Tests: Fix Math tests when use_clamp is true. The clamp option is implemented using graph expansion, where a Clamp node named "clamp" is added and connected to the output. So the final result is actually from the node "clamp". Reviewers: brecht Differential Revision: https://developer.blender.org/D5540
2019-08-20 17:20:16 +02:00
INVALID_INFO_MESSAGE(log, "Folding clamp::");
Cycles: implement partial constant folding for exponentiation. This is also an important mathematical operation that can be folded if it is known that one argument is a certain constant. For colors the operation is provided as a Gamma node. The SVM Gamma node needs a small fix to make it follow the 0 ^ 0 == 1 rule, same as the Power node, or the Gamma node itself in OSL mode. Reviewers: #cycles Differential Revision: https://developer.blender.org/D2263
2016-09-29 00:35:53 +03:00
build_math_partial_test_graph(builder, NODE_MATH_POWER, 0.0f);
Refactor: Cycles: Replace new/delete by unique_ptr, in simple cases Pull Request: https://projects.blender.org/blender/blender/pulls/132361
2024-12-29 23:13:45 +01:00
graph.finalize(scene.get());
Cycles: implement partial constant folding for exponentiation. This is also an important mathematical operation that can be folded if it is known that one argument is a certain constant. For colors the operation is provided as a Gamma node. The SVM Gamma node needs a small fix to make it follow the 0 ^ 0 == 1 rule, same as the Power node, or the Gamma node itself in OSL mode. Reviewers: #cycles Differential Revision: https://developer.blender.org/D2263
2016-09-29 00:35:53 +03:00
}
/*
* Tests: partial folding for Math Power with known 1.
*/
Cycles: Fix memory leak in test and simplify code
2017-10-24 11:12:28 +02:00
TEST_F(RenderGraph, constant_fold_part_math_pow_1)
Cycles: implement partial constant folding for exponentiation. This is also an important mathematical operation that can be folded if it is known that one argument is a certain constant. For colors the operation is provided as a Gamma node. The SVM Gamma node needs a small fix to make it follow the 0 ^ 0 == 1 rule, same as the Power node, or the Gamma node itself in OSL mode. Reviewers: #cycles Differential Revision: https://developer.blender.org/D2263
2016-09-29 00:35:53 +03:00
{
EXPECT_ANY_MESSAGE(log);
/* 1 ^ X == 1; X ^ 1 == X */
CORRECT_INFO_MESSAGE(log, "Folding Math_Cx::Value to constant (1)");
CORRECT_INFO_MESSAGE(log, "Folding Math_xC::Value to socket Attribute::Fac.");
Cycles Tests: Fix Math tests when use_clamp is true. The clamp option is implemented using graph expansion, where a Clamp node named "clamp" is added and connected to the output. So the final result is actually from the node "clamp". Reviewers: brecht Differential Revision: https://developer.blender.org/D5540
2019-08-20 17:20:16 +02:00
INVALID_INFO_MESSAGE(log, "Folding clamp::");
Cycles: implement partial constant folding for exponentiation. This is also an important mathematical operation that can be folded if it is known that one argument is a certain constant. For colors the operation is provided as a Gamma node. The SVM Gamma node needs a small fix to make it follow the 0 ^ 0 == 1 rule, same as the Power node, or the Gamma node itself in OSL mode. Reviewers: #cycles Differential Revision: https://developer.blender.org/D2263
2016-09-29 00:35:53 +03:00
build_math_partial_test_graph(builder, NODE_MATH_POWER, 1.0f);
Refactor: Cycles: Replace new/delete by unique_ptr, in simple cases Pull Request: https://projects.blender.org/blender/blender/pulls/132361
2024-12-29 23:13:45 +01:00
graph.finalize(scene.get());
Cycles: implement partial constant folding for exponentiation. This is also an important mathematical operation that can be folded if it is known that one argument is a certain constant. For colors the operation is provided as a Gamma node. The SVM Gamma node needs a small fix to make it follow the 0 ^ 0 == 1 rule, same as the Power node, or the Gamma node itself in OSL mode. Reviewers: #cycles Differential Revision: https://developer.blender.org/D2263
2016-09-29 00:35:53 +03:00
}
Cycles: add unit tests for supported constant folding rules. Code coverage of different combinations of secondary conditions is obviously not complete because there are so many of them, but all main rules should be there. The reason for CORRECT vs INVALID is that both words have the same number of characters so calls line up, but look quite different. Reviewers: #cycles, sergey Reviewed By: #cycles, sergey Subscribers: dingto, sergey, brecht Differential Revision: https://developer.blender.org/D2130
2016-08-01 18:53:20 +03:00
/*
* Tests: Vector Math with all constant inputs.
*/
Cycles: Fix memory leak in test and simplify code
2017-10-24 11:12:28 +02:00
TEST_F(RenderGraph, constant_fold_vector_math)
Cycles: add unit tests for supported constant folding rules. Code coverage of different combinations of secondary conditions is obviously not complete because there are so many of them, but all main rules should be there. The reason for CORRECT vs INVALID is that both words have the same number of characters so calls line up, but look quite different. Reviewers: #cycles, sergey Reviewed By: #cycles, sergey Subscribers: dingto, sergey, brecht Differential Revision: https://developer.blender.org/D2130
2016-08-01 18:53:20 +03:00
{
EXPECT_ANY_MESSAGE(log);
CORRECT_INFO_MESSAGE(log, "Folding VectorMath::Vector to constant (3, 0, 0).");
builder
Cycles: fix missing ShaderNode ownership in render_graph_finalize_test
2020-10-13 15:36:52 +02:00
.add_node(ShaderNodeBuilder<VectorMathNode>(graph, "VectorMath")
Cycles API: encapsulate Node socket members This encapsulates Node socket members behind a set of specific methods; as such it is no longer possible to directly access Node class members from exporters and parts of Cycles. The methods are defined via the NODE_SOCKET_API macros in `graph/ node.h`, and are for getting or setting a specific socket's value, as well as querying or modifying the state of its update flag. The setters will check whether the value has changed and tag the socket as modified appropriately. This will let us know how a Node has changed and what to update, which is the first concrete step toward a more granular scene update system. Since the setters will tag the Node sockets as modified when passed different data, this patch also removes the various modified methods on Nodes in favor of Node::is_modified which checks the sockets' update flags status. Reviewed By: brecht Maniphest Tasks: T79174 Differential Revision: https://developer.blender.org/D8544
2020-11-04 11:17:38 +01:00
.set_param("math_type", NODE_VECTOR_MATH_SUBTRACT)
Cycles: add unit tests for supported constant folding rules. Code coverage of different combinations of secondary conditions is obviously not complete because there are so many of them, but all main rules should be there. The reason for CORRECT vs INVALID is that both words have the same number of characters so calls line up, but look quite different. Reviewers: #cycles, sergey Reviewed By: #cycles, sergey Subscribers: dingto, sergey, brecht Differential Revision: https://developer.blender.org/D2130
2016-08-01 18:53:20 +03:00
.set("Vector1", make_float3(1.3f, 0.5f, 0.7f))
.set("Vector2", make_float3(-1.7f, 0.5f, 0.7f)))
Shading: Add more operators to Vector Math node. Add Multiply, Divide, Project, Reflect, Distance, Length, Scale, Snap, Floor, Ceil, Modulo, Fraction, Absolute, Minimum, and Maximum operators to the Vector Math node. The Value output has been removed from operators whose output is a vector, and the other way around. All of those removals has been handled properly in versioning code. The patch doesn't include tests for the new operators. Tests will be added in a later patch. Reviewers: brecht, JacquesLucke Differential Revision: https://developer.blender.org/D5523
2019-08-21 19:36:33 +02:00
.output_color("VectorMath::Vector");
Cycles: add unit tests for supported constant folding rules. Code coverage of different combinations of secondary conditions is obviously not complete because there are so many of them, but all main rules should be there. The reason for CORRECT vs INVALID is that both words have the same number of characters so calls line up, but look quite different. Reviewers: #cycles, sergey Reviewed By: #cycles, sergey Subscribers: dingto, sergey, brecht Differential Revision: https://developer.blender.org/D2130
2016-08-01 18:53:20 +03:00
Refactor: Cycles: Replace new/delete by unique_ptr, in simple cases Pull Request: https://projects.blender.org/blender/blender/pulls/132361
2024-12-29 23:13:45 +01:00
graph.finalize(scene.get());
Cycles: add unit tests for supported constant folding rules. Code coverage of different combinations of secondary conditions is obviously not complete because there are so many of them, but all main rules should be there. The reason for CORRECT vs INVALID is that both words have the same number of characters so calls line up, but look quite different. Reviewers: #cycles, sergey Reviewed By: #cycles, sergey Subscribers: dingto, sergey, brecht Differential Revision: https://developer.blender.org/D2130
2016-08-01 18:53:20 +03:00
}
/*
* Graph for testing partial folds of Vector Math with one constant argument.
* Includes 2 tests: constant on each side.
*/
static void build_vecmath_partial_test_graph(ShaderGraphBuilder &builder,
Shading: Add more operators to Vector Math node. Add Multiply, Divide, Project, Reflect, Distance, Length, Scale, Snap, Floor, Ceil, Modulo, Fraction, Absolute, Minimum, and Maximum operators to the Vector Math node. The Value output has been removed from operators whose output is a vector, and the other way around. All of those removals has been handled properly in versioning code. The patch doesn't include tests for the new operators. Tests will be added in a later patch. Reviewers: brecht, JacquesLucke Differential Revision: https://developer.blender.org/D5523
2019-08-21 19:36:33 +02:00
NodeVectorMathType type,
Refactor: Cycles: Add const keyword to more function parameters Pull Request: https://projects.blender.org/blender/blender/pulls/132361
2025-01-01 18:15:54 +01:00
const float3 constval)
Cycles: add unit tests for supported constant folding rules. Code coverage of different combinations of secondary conditions is obviously not complete because there are so many of them, but all main rules should be there. The reason for CORRECT vs INVALID is that both words have the same number of characters so calls line up, but look quite different. Reviewers: #cycles, sergey Reviewed By: #cycles, sergey Subscribers: dingto, sergey, brecht Differential Revision: https://developer.blender.org/D2130
2016-08-01 18:53:20 +03:00
{
builder
.add_attribute("Attribute")
/* constant on the left */
Cycles: fix missing ShaderNode ownership in render_graph_finalize_test
2020-10-13 15:36:52 +02:00
.add_node(ShaderNodeBuilder<VectorMathNode>(builder.graph(), "Math_Cx")
Cycles API: encapsulate Node socket members This encapsulates Node socket members behind a set of specific methods; as such it is no longer possible to directly access Node class members from exporters and parts of Cycles. The methods are defined via the NODE_SOCKET_API macros in `graph/ node.h`, and are for getting or setting a specific socket's value, as well as querying or modifying the state of its update flag. The setters will check whether the value has changed and tag the socket as modified appropriately. This will let us know how a Node has changed and what to update, which is the first concrete step toward a more granular scene update system. Since the setters will tag the Node sockets as modified when passed different data, this patch also removes the various modified methods on Nodes in favor of Node::is_modified which checks the sockets' update flags status. Reviewed By: brecht Maniphest Tasks: T79174 Differential Revision: https://developer.blender.org/D8544
2020-11-04 11:17:38 +01:00
.set_param("math_type", type)
Cycles: add unit tests for supported constant folding rules. Code coverage of different combinations of secondary conditions is obviously not complete because there are so many of them, but all main rules should be there. The reason for CORRECT vs INVALID is that both words have the same number of characters so calls line up, but look quite different. Reviewers: #cycles, sergey Reviewed By: #cycles, sergey Subscribers: dingto, sergey, brecht Differential Revision: https://developer.blender.org/D2130
2016-08-01 18:53:20 +03:00
.set("Vector1", constval))
.add_connection("Attribute::Vector", "Math_Cx::Vector2")
/* constant on the right */
Cycles: fix missing ShaderNode ownership in render_graph_finalize_test
2020-10-13 15:36:52 +02:00
.add_node(ShaderNodeBuilder<VectorMathNode>(builder.graph(), "Math_xC")
Cycles API: encapsulate Node socket members This encapsulates Node socket members behind a set of specific methods; as such it is no longer possible to directly access Node class members from exporters and parts of Cycles. The methods are defined via the NODE_SOCKET_API macros in `graph/ node.h`, and are for getting or setting a specific socket's value, as well as querying or modifying the state of its update flag. The setters will check whether the value has changed and tag the socket as modified appropriately. This will let us know how a Node has changed and what to update, which is the first concrete step toward a more granular scene update system. Since the setters will tag the Node sockets as modified when passed different data, this patch also removes the various modified methods on Nodes in favor of Node::is_modified which checks the sockets' update flags status. Reviewed By: brecht Maniphest Tasks: T79174 Differential Revision: https://developer.blender.org/D8544
2020-11-04 11:17:38 +01:00
.set_param("math_type", type)
Cycles: add unit tests for supported constant folding rules. Code coverage of different combinations of secondary conditions is obviously not complete because there are so many of them, but all main rules should be there. The reason for CORRECT vs INVALID is that both words have the same number of characters so calls line up, but look quite different. Reviewers: #cycles, sergey Reviewed By: #cycles, sergey Subscribers: dingto, sergey, brecht Differential Revision: https://developer.blender.org/D2130
2016-08-01 18:53:20 +03:00
.set("Vector2", constval))
.add_connection("Attribute::Vector", "Math_xC::Vector1")
/* output sum */
Cycles: fix missing ShaderNode ownership in render_graph_finalize_test
2020-10-13 15:36:52 +02:00
.add_node(ShaderNodeBuilder<VectorMathNode>(builder.graph(), "Out")
Cycles API: encapsulate Node socket members This encapsulates Node socket members behind a set of specific methods; as such it is no longer possible to directly access Node class members from exporters and parts of Cycles. The methods are defined via the NODE_SOCKET_API macros in `graph/ node.h`, and are for getting or setting a specific socket's value, as well as querying or modifying the state of its update flag. The setters will check whether the value has changed and tag the socket as modified appropriately. This will let us know how a Node has changed and what to update, which is the first concrete step toward a more granular scene update system. Since the setters will tag the Node sockets as modified when passed different data, this patch also removes the various modified methods on Nodes in favor of Node::is_modified which checks the sockets' update flags status. Reviewed By: brecht Maniphest Tasks: T79174 Differential Revision: https://developer.blender.org/D8544
2020-11-04 11:17:38 +01:00
.set_param("math_type", NODE_VECTOR_MATH_ADD))
Cycles: add unit tests for supported constant folding rules. Code coverage of different combinations of secondary conditions is obviously not complete because there are so many of them, but all main rules should be there. The reason for CORRECT vs INVALID is that both words have the same number of characters so calls line up, but look quite different. Reviewers: #cycles, sergey Reviewed By: #cycles, sergey Subscribers: dingto, sergey, brecht Differential Revision: https://developer.blender.org/D2130
2016-08-01 18:53:20 +03:00
.add_connection("Math_Cx::Vector", "Out::Vector1")
.add_connection("Math_xC::Vector", "Out::Vector2")
.output_color("Out::Vector");
}
/*
* Tests: partial folding for Vector Math Add with known 0.
*/
Cycles: Fix memory leak in test and simplify code
2017-10-24 11:12:28 +02:00
TEST_F(RenderGraph, constant_fold_part_vecmath_add_0)
Cycles: add unit tests for supported constant folding rules. Code coverage of different combinations of secondary conditions is obviously not complete because there are so many of them, but all main rules should be there. The reason for CORRECT vs INVALID is that both words have the same number of characters so calls line up, but look quite different. Reviewers: #cycles, sergey Reviewed By: #cycles, sergey Subscribers: dingto, sergey, brecht Differential Revision: https://developer.blender.org/D2130
2016-08-01 18:53:20 +03:00
{
EXPECT_ANY_MESSAGE(log);
/* X + 0 == 0 + X == X */
CORRECT_INFO_MESSAGE(log, "Folding Math_Cx::Vector to socket Attribute::Vector.");
CORRECT_INFO_MESSAGE(log, "Folding Math_xC::Vector to socket Attribute::Vector.");
INVALID_INFO_MESSAGE(log, "Folding Out::");
build_vecmath_partial_test_graph(builder, NODE_VECTOR_MATH_ADD, make_float3(0, 0, 0));
Refactor: Cycles: Replace new/delete by unique_ptr, in simple cases Pull Request: https://projects.blender.org/blender/blender/pulls/132361
2024-12-29 23:13:45 +01:00
graph.finalize(scene.get());
Cycles: add unit tests for supported constant folding rules. Code coverage of different combinations of secondary conditions is obviously not complete because there are so many of them, but all main rules should be there. The reason for CORRECT vs INVALID is that both words have the same number of characters so calls line up, but look quite different. Reviewers: #cycles, sergey Reviewed By: #cycles, sergey Subscribers: dingto, sergey, brecht Differential Revision: https://developer.blender.org/D2130
2016-08-01 18:53:20 +03:00
}
/*
Cleanup: spelling in comments
2023-08-25 08:56:58 +10:00
* Tests: partial folding for Vector Math Subtract with known 0.
Cycles: add unit tests for supported constant folding rules. Code coverage of different combinations of secondary conditions is obviously not complete because there are so many of them, but all main rules should be there. The reason for CORRECT vs INVALID is that both words have the same number of characters so calls line up, but look quite different. Reviewers: #cycles, sergey Reviewed By: #cycles, sergey Subscribers: dingto, sergey, brecht Differential Revision: https://developer.blender.org/D2130
2016-08-01 18:53:20 +03:00
*/
Cycles: Fix memory leak in test and simplify code
2017-10-24 11:12:28 +02:00
TEST_F(RenderGraph, constant_fold_part_vecmath_sub_0)
Cycles: add unit tests for supported constant folding rules. Code coverage of different combinations of secondary conditions is obviously not complete because there are so many of them, but all main rules should be there. The reason for CORRECT vs INVALID is that both words have the same number of characters so calls line up, but look quite different. Reviewers: #cycles, sergey Reviewed By: #cycles, sergey Subscribers: dingto, sergey, brecht Differential Revision: https://developer.blender.org/D2130
2016-08-01 18:53:20 +03:00
{
EXPECT_ANY_MESSAGE(log);
/* X - 0 == X */
INVALID_INFO_MESSAGE(log, "Folding Math_Cx::");
CORRECT_INFO_MESSAGE(log, "Folding Math_xC::Vector to socket Attribute::Vector.");
INVALID_INFO_MESSAGE(log, "Folding Out::");
build_vecmath_partial_test_graph(builder, NODE_VECTOR_MATH_SUBTRACT, make_float3(0, 0, 0));
Refactor: Cycles: Replace new/delete by unique_ptr, in simple cases Pull Request: https://projects.blender.org/blender/blender/pulls/132361
2024-12-29 23:13:45 +01:00
graph.finalize(scene.get());
Cycles: add unit tests for supported constant folding rules. Code coverage of different combinations of secondary conditions is obviously not complete because there are so many of them, but all main rules should be there. The reason for CORRECT vs INVALID is that both words have the same number of characters so calls line up, but look quite different. Reviewers: #cycles, sergey Reviewed By: #cycles, sergey Subscribers: dingto, sergey, brecht Differential Revision: https://developer.blender.org/D2130
2016-08-01 18:53:20 +03:00
}
/*
* Tests: partial folding for Vector Math Cross Product with known 0.
*/
Cycles: Fix memory leak in test and simplify code
2017-10-24 11:12:28 +02:00
TEST_F(RenderGraph, constant_fold_part_vecmath_cross_0)
Cycles: add unit tests for supported constant folding rules. Code coverage of different combinations of secondary conditions is obviously not complete because there are so many of them, but all main rules should be there. The reason for CORRECT vs INVALID is that both words have the same number of characters so calls line up, but look quite different. Reviewers: #cycles, sergey Reviewed By: #cycles, sergey Subscribers: dingto, sergey, brecht Differential Revision: https://developer.blender.org/D2130
2016-08-01 18:53:20 +03:00
{
EXPECT_ANY_MESSAGE(log);
/* X * 0 == 0 * X == X */
CORRECT_INFO_MESSAGE(log, "Folding Math_Cx::Vector to constant (0, 0, 0).");
CORRECT_INFO_MESSAGE(log, "Folding Math_xC::Vector to constant (0, 0, 0).");
CORRECT_INFO_MESSAGE(log, "Folding Out::Vector to constant (0, 0, 0).");
CORRECT_INFO_MESSAGE(log, "Discarding closure EmissionNode.");
build_vecmath_partial_test_graph(builder, NODE_VECTOR_MATH_CROSS_PRODUCT, make_float3(0, 0, 0));
Refactor: Cycles: Replace new/delete by unique_ptr, in simple cases Pull Request: https://projects.blender.org/blender/blender/pulls/132361
2024-12-29 23:13:45 +01:00
graph.finalize(scene.get());
Cycles: add unit tests for supported constant folding rules. Code coverage of different combinations of secondary conditions is obviously not complete because there are so many of them, but all main rules should be there. The reason for CORRECT vs INVALID is that both words have the same number of characters so calls line up, but look quite different. Reviewers: #cycles, sergey Reviewed By: #cycles, sergey Subscribers: dingto, sergey, brecht Differential Revision: https://developer.blender.org/D2130
2016-08-01 18:53:20 +03:00
}
/*
* Tests: Bump with no height input folded to Normal input.
*/
Cycles: Fix memory leak in test and simplify code
2017-10-24 11:12:28 +02:00
TEST_F(RenderGraph, constant_fold_bump)
Cycles: add unit tests for supported constant folding rules. Code coverage of different combinations of secondary conditions is obviously not complete because there are so many of them, but all main rules should be there. The reason for CORRECT vs INVALID is that both words have the same number of characters so calls line up, but look quite different. Reviewers: #cycles, sergey Reviewed By: #cycles, sergey Subscribers: dingto, sergey, brecht Differential Revision: https://developer.blender.org/D2130
2016-08-01 18:53:20 +03:00
{
EXPECT_ANY_MESSAGE(log);
CORRECT_INFO_MESSAGE(log, "Folding Bump::Normal to socket Geometry1::Normal.");
Cycles: fix missing ShaderNode ownership in render_graph_finalize_test
2020-10-13 15:36:52 +02:00
builder.add_node(ShaderNodeBuilder<GeometryNode>(graph, "Geometry1"))
.add_node(ShaderNodeBuilder<BumpNode>(graph, "Bump"))
Cycles: add unit tests for supported constant folding rules. Code coverage of different combinations of secondary conditions is obviously not complete because there are so many of them, but all main rules should be there. The reason for CORRECT vs INVALID is that both words have the same number of characters so calls line up, but look quite different. Reviewers: #cycles, sergey Reviewed By: #cycles, sergey Subscribers: dingto, sergey, brecht Differential Revision: https://developer.blender.org/D2130
2016-08-01 18:53:20 +03:00
.add_connection("Geometry1::Normal", "Bump::Normal")
.output_color("Bump::Normal");
Refactor: Cycles: Replace new/delete by unique_ptr, in simple cases Pull Request: https://projects.blender.org/blender/blender/pulls/132361
2024-12-29 23:13:45 +01:00
graph.finalize(scene.get());
Cycles: add unit tests for supported constant folding rules. Code coverage of different combinations of secondary conditions is obviously not complete because there are so many of them, but all main rules should be there. The reason for CORRECT vs INVALID is that both words have the same number of characters so calls line up, but look quite different. Reviewers: #cycles, sergey Reviewed By: #cycles, sergey Subscribers: dingto, sergey, brecht Differential Revision: https://developer.blender.org/D2130
2016-08-01 18:53:20 +03:00
}
/*
* Tests: Bump with no inputs folded to Geometry::Normal.
*/
Cycles: Fix memory leak in test and simplify code
2017-10-24 11:12:28 +02:00
TEST_F(RenderGraph, constant_fold_bump_no_input)
Cycles: add unit tests for supported constant folding rules. Code coverage of different combinations of secondary conditions is obviously not complete because there are so many of them, but all main rules should be there. The reason for CORRECT vs INVALID is that both words have the same number of characters so calls line up, but look quite different. Reviewers: #cycles, sergey Reviewed By: #cycles, sergey Subscribers: dingto, sergey, brecht Differential Revision: https://developer.blender.org/D2130
2016-08-01 18:53:20 +03:00
{
EXPECT_ANY_MESSAGE(log);
CORRECT_INFO_MESSAGE(log, "Folding Bump::Normal to socket geometry::Normal.");
Cycles: fix missing ShaderNode ownership in render_graph_finalize_test
2020-10-13 15:36:52 +02:00
builder.add_node(ShaderNodeBuilder<BumpNode>(graph, "Bump")).output_color("Bump::Normal");
Cycles: add unit tests for supported constant folding rules. Code coverage of different combinations of secondary conditions is obviously not complete because there are so many of them, but all main rules should be there. The reason for CORRECT vs INVALID is that both words have the same number of characters so calls line up, but look quite different. Reviewers: #cycles, sergey Reviewed By: #cycles, sergey Subscribers: dingto, sergey, brecht Differential Revision: https://developer.blender.org/D2130
2016-08-01 18:53:20 +03:00
Refactor: Cycles: Replace new/delete by unique_ptr, in simple cases Pull Request: https://projects.blender.org/blender/blender/pulls/132361
2024-12-29 23:13:45 +01:00
graph.finalize(scene.get());
Cycles: add unit tests for supported constant folding rules. Code coverage of different combinations of secondary conditions is obviously not complete because there are so many of them, but all main rules should be there. The reason for CORRECT vs INVALID is that both words have the same number of characters so calls line up, but look quite different. Reviewers: #cycles, sergey Reviewed By: #cycles, sergey Subscribers: dingto, sergey, brecht Differential Revision: https://developer.blender.org/D2130
2016-08-01 18:53:20 +03:00
}
Refactor: Cycles: Add const keyword to more function parameters Pull Request: https://projects.blender.org/blender/blender/pulls/132361
2025-01-01 18:15:54 +01:00
template<class T> void init_test_curve(array<T> &buffer, T start, T end, const int steps)
Cycles: add unit tests for supported constant folding rules. Code coverage of different combinations of secondary conditions is obviously not complete because there are so many of them, but all main rules should be there. The reason for CORRECT vs INVALID is that both words have the same number of characters so calls line up, but look quite different. Reviewers: #cycles, sergey Reviewed By: #cycles, sergey Subscribers: dingto, sergey, brecht Differential Revision: https://developer.blender.org/D2130
2016-08-01 18:53:20 +03:00
{
buffer.resize(steps);
Cycles: Cleanup, style
2016-10-24 12:26:12 +02:00
for (int i = 0; i < steps; i++) {
Cleanup: remove redundant lerp function, mix already does the same
2023-05-12 19:55:46 +02:00
buffer[i] = mix(start, end, float(i) / (steps - 1));
Cycles: Cleanup, style
2016-10-24 12:26:12 +02:00
}
Cycles: add unit tests for supported constant folding rules. Code coverage of different combinations of secondary conditions is obviously not complete because there are so many of them, but all main rules should be there. The reason for CORRECT vs INVALID is that both words have the same number of characters so calls line up, but look quite different. Reviewers: #cycles, sergey Reviewed By: #cycles, sergey Subscribers: dingto, sergey, brecht Differential Revision: https://developer.blender.org/D2130
2016-08-01 18:53:20 +03:00
}
/*
* Tests:
* - Folding of RGB Curves with all constant inputs.
*/
Cycles: Fix memory leak in test and simplify code
2017-10-24 11:12:28 +02:00
TEST_F(RenderGraph, constant_fold_rgb_curves)
Cycles: add unit tests for supported constant folding rules. Code coverage of different combinations of secondary conditions is obviously not complete because there are so many of them, but all main rules should be there. The reason for CORRECT vs INVALID is that both words have the same number of characters so calls line up, but look quite different. Reviewers: #cycles, sergey Reviewed By: #cycles, sergey Subscribers: dingto, sergey, brecht Differential Revision: https://developer.blender.org/D2130
2016-08-01 18:53:20 +03:00
{
EXPECT_ANY_MESSAGE(log);
CORRECT_INFO_MESSAGE(log, "Folding Curves::Color to constant (0.275, 0.5, 0.475).");
array<float3> curve;
init_test_curve(curve, make_float3(0.0f, 0.25f, 1.0f), make_float3(1.0f, 0.75f, 0.0f), 257);
builder
Cycles: fix missing ShaderNode ownership in render_graph_finalize_test
2020-10-13 15:36:52 +02:00
.add_node(ShaderNodeBuilder<RGBCurvesNode>(graph, "Curves")
Cycles API: encapsulate Node socket members This encapsulates Node socket members behind a set of specific methods; as such it is no longer possible to directly access Node class members from exporters and parts of Cycles. The methods are defined via the NODE_SOCKET_API macros in `graph/ node.h`, and are for getting or setting a specific socket's value, as well as querying or modifying the state of its update flag. The setters will check whether the value has changed and tag the socket as modified appropriately. This will let us know how a Node has changed and what to update, which is the first concrete step toward a more granular scene update system. Since the setters will tag the Node sockets as modified when passed different data, this patch also removes the various modified methods on Nodes in favor of Node::is_modified which checks the sockets' update flags status. Reviewed By: brecht Maniphest Tasks: T79174 Differential Revision: https://developer.blender.org/D8544
2020-11-04 11:17:38 +01:00
.set_param("curves", curve)
.set_param("min_x", 0.1f)
.set_param("max_x", 0.9f)
Cycles: add unit tests for supported constant folding rules. Code coverage of different combinations of secondary conditions is obviously not complete because there are so many of them, but all main rules should be there. The reason for CORRECT vs INVALID is that both words have the same number of characters so calls line up, but look quite different. Reviewers: #cycles, sergey Reviewed By: #cycles, sergey Subscribers: dingto, sergey, brecht Differential Revision: https://developer.blender.org/D2130
2016-08-01 18:53:20 +03:00
.set("Fac", 0.5f)
.set("Color", make_float3(0.3f, 0.5f, 0.7f)))
.output_color("Curves::Color");
Refactor: Cycles: Replace new/delete by unique_ptr, in simple cases Pull Request: https://projects.blender.org/blender/blender/pulls/132361
2024-12-29 23:13:45 +01:00
graph.finalize(scene.get());
Cycles: add unit tests for supported constant folding rules. Code coverage of different combinations of secondary conditions is obviously not complete because there are so many of them, but all main rules should be there. The reason for CORRECT vs INVALID is that both words have the same number of characters so calls line up, but look quite different. Reviewers: #cycles, sergey Reviewed By: #cycles, sergey Subscribers: dingto, sergey, brecht Differential Revision: https://developer.blender.org/D2130
2016-08-01 18:53:20 +03:00
}
/*
* Tests:
* - Folding of RGB Curves with zero Fac.
*/
Cycles: Fix memory leak in test and simplify code
2017-10-24 11:12:28 +02:00
TEST_F(RenderGraph, constant_fold_rgb_curves_fac_0)
Cycles: add unit tests for supported constant folding rules. Code coverage of different combinations of secondary conditions is obviously not complete because there are so many of them, but all main rules should be there. The reason for CORRECT vs INVALID is that both words have the same number of characters so calls line up, but look quite different. Reviewers: #cycles, sergey Reviewed By: #cycles, sergey Subscribers: dingto, sergey, brecht Differential Revision: https://developer.blender.org/D2130
2016-08-01 18:53:20 +03:00
{
EXPECT_ANY_MESSAGE(log);
CORRECT_INFO_MESSAGE(log, "Folding Curves::Color to socket Attribute::Color.");
array<float3> curve;
init_test_curve(curve, make_float3(0.0f, 0.25f, 1.0f), make_float3(1.0f, 0.75f, 0.0f), 257);
builder.add_attribute("Attribute")
Cycles: fix missing ShaderNode ownership in render_graph_finalize_test
2020-10-13 15:36:52 +02:00
.add_node(ShaderNodeBuilder<RGBCurvesNode>(graph, "Curves")
Cycles API: encapsulate Node socket members This encapsulates Node socket members behind a set of specific methods; as such it is no longer possible to directly access Node class members from exporters and parts of Cycles. The methods are defined via the NODE_SOCKET_API macros in `graph/ node.h`, and are for getting or setting a specific socket's value, as well as querying or modifying the state of its update flag. The setters will check whether the value has changed and tag the socket as modified appropriately. This will let us know how a Node has changed and what to update, which is the first concrete step toward a more granular scene update system. Since the setters will tag the Node sockets as modified when passed different data, this patch also removes the various modified methods on Nodes in favor of Node::is_modified which checks the sockets' update flags status. Reviewed By: brecht Maniphest Tasks: T79174 Differential Revision: https://developer.blender.org/D8544
2020-11-04 11:17:38 +01:00
.set_param("curves", curve)
.set_param("min_x", 0.1f)
.set_param("max_x", 0.9f)
Cycles: add unit tests for supported constant folding rules. Code coverage of different combinations of secondary conditions is obviously not complete because there are so many of them, but all main rules should be there. The reason for CORRECT vs INVALID is that both words have the same number of characters so calls line up, but look quite different. Reviewers: #cycles, sergey Reviewed By: #cycles, sergey Subscribers: dingto, sergey, brecht Differential Revision: https://developer.blender.org/D2130
2016-08-01 18:53:20 +03:00
.set("Fac", 0.0f))
.add_connection("Attribute::Color", "Curves::Color")
.output_color("Curves::Color");
Refactor: Cycles: Replace new/delete by unique_ptr, in simple cases Pull Request: https://projects.blender.org/blender/blender/pulls/132361
2024-12-29 23:13:45 +01:00
graph.finalize(scene.get());
Cycles: add unit tests for supported constant folding rules. Code coverage of different combinations of secondary conditions is obviously not complete because there are so many of them, but all main rules should be there. The reason for CORRECT vs INVALID is that both words have the same number of characters so calls line up, but look quite different. Reviewers: #cycles, sergey Reviewed By: #cycles, sergey Subscribers: dingto, sergey, brecht Differential Revision: https://developer.blender.org/D2130
2016-08-01 18:53:20 +03:00
}
Fix T49136: full constant Curves with zero Fac input crashes in assert. The if branches were reordered when the original patch was committed, which broke the implicit non-NULL guarantee on link. To prevent re-occurrence, add a couple of unit tests.
2016-08-22 11:11:45 +03:00
/*
* Tests:
* - Folding of RGB Curves with zero Fac and all constant inputs.
*/
Cycles: Fix memory leak in test and simplify code
2017-10-24 11:12:28 +02:00
TEST_F(RenderGraph, constant_fold_rgb_curves_fac_0_const)
Fix T49136: full constant Curves with zero Fac input crashes in assert. The if branches were reordered when the original patch was committed, which broke the implicit non-NULL guarantee on link. To prevent re-occurrence, add a couple of unit tests.
2016-08-22 11:11:45 +03:00
{
EXPECT_ANY_MESSAGE(log);
CORRECT_INFO_MESSAGE(log, "Folding Curves::Color to constant (0.3, 0.5, 0.7).");
array<float3> curve;
init_test_curve(curve, make_float3(0.0f, 0.25f, 1.0f), make_float3(1.0f, 0.75f, 0.0f), 257);
builder
Cycles: fix missing ShaderNode ownership in render_graph_finalize_test
2020-10-13 15:36:52 +02:00
.add_node(ShaderNodeBuilder<RGBCurvesNode>(graph, "Curves")
Cycles API: encapsulate Node socket members This encapsulates Node socket members behind a set of specific methods; as such it is no longer possible to directly access Node class members from exporters and parts of Cycles. The methods are defined via the NODE_SOCKET_API macros in `graph/ node.h`, and are for getting or setting a specific socket's value, as well as querying or modifying the state of its update flag. The setters will check whether the value has changed and tag the socket as modified appropriately. This will let us know how a Node has changed and what to update, which is the first concrete step toward a more granular scene update system. Since the setters will tag the Node sockets as modified when passed different data, this patch also removes the various modified methods on Nodes in favor of Node::is_modified which checks the sockets' update flags status. Reviewed By: brecht Maniphest Tasks: T79174 Differential Revision: https://developer.blender.org/D8544
2020-11-04 11:17:38 +01:00
.set_param("curves", curve)
.set_param("min_x", 0.1f)
.set_param("max_x", 0.9f)
Fix T49136: full constant Curves with zero Fac input crashes in assert. The if branches were reordered when the original patch was committed, which broke the implicit non-NULL guarantee on link. To prevent re-occurrence, add a couple of unit tests.
2016-08-22 11:11:45 +03:00
.set("Fac", 0.0f)
.set("Color", make_float3(0.3f, 0.5f, 0.7f)))
.output_color("Curves::Color");
Refactor: Cycles: Replace new/delete by unique_ptr, in simple cases Pull Request: https://projects.blender.org/blender/blender/pulls/132361
2024-12-29 23:13:45 +01:00
graph.finalize(scene.get());
Fix T49136: full constant Curves with zero Fac input crashes in assert. The if branches were reordered when the original patch was committed, which broke the implicit non-NULL guarantee on link. To prevent re-occurrence, add a couple of unit tests.
2016-08-22 11:11:45 +03:00
}
Cycles: add unit tests for supported constant folding rules. Code coverage of different combinations of secondary conditions is obviously not complete because there are so many of them, but all main rules should be there. The reason for CORRECT vs INVALID is that both words have the same number of characters so calls line up, but look quite different. Reviewers: #cycles, sergey Reviewed By: #cycles, sergey Subscribers: dingto, sergey, brecht Differential Revision: https://developer.blender.org/D2130
2016-08-01 18:53:20 +03:00
/*
* Tests:
* - Folding of Vector Curves with all constant inputs.
*/
Cycles: Fix memory leak in test and simplify code
2017-10-24 11:12:28 +02:00
TEST_F(RenderGraph, constant_fold_vector_curves)
Cycles: add unit tests for supported constant folding rules. Code coverage of different combinations of secondary conditions is obviously not complete because there are so many of them, but all main rules should be there. The reason for CORRECT vs INVALID is that both words have the same number of characters so calls line up, but look quite different. Reviewers: #cycles, sergey Reviewed By: #cycles, sergey Subscribers: dingto, sergey, brecht Differential Revision: https://developer.blender.org/D2130
2016-08-01 18:53:20 +03:00
{
EXPECT_ANY_MESSAGE(log);
CORRECT_INFO_MESSAGE(log, "Folding Curves::Vector to constant (0.275, 0.5, 0.475).");
array<float3> curve;
init_test_curve(curve, make_float3(0.0f, 0.25f, 1.0f), make_float3(1.0f, 0.75f, 0.0f), 257);
builder
Cycles: fix missing ShaderNode ownership in render_graph_finalize_test
2020-10-13 15:36:52 +02:00
.add_node(ShaderNodeBuilder<VectorCurvesNode>(graph, "Curves")
Cycles API: encapsulate Node socket members This encapsulates Node socket members behind a set of specific methods; as such it is no longer possible to directly access Node class members from exporters and parts of Cycles. The methods are defined via the NODE_SOCKET_API macros in `graph/ node.h`, and are for getting or setting a specific socket's value, as well as querying or modifying the state of its update flag. The setters will check whether the value has changed and tag the socket as modified appropriately. This will let us know how a Node has changed and what to update, which is the first concrete step toward a more granular scene update system. Since the setters will tag the Node sockets as modified when passed different data, this patch also removes the various modified methods on Nodes in favor of Node::is_modified which checks the sockets' update flags status. Reviewed By: brecht Maniphest Tasks: T79174 Differential Revision: https://developer.blender.org/D8544
2020-11-04 11:17:38 +01:00
.set_param("curves", curve)
.set_param("min_x", 0.1f)
.set_param("max_x", 0.9f)
Cycles: add unit tests for supported constant folding rules. Code coverage of different combinations of secondary conditions is obviously not complete because there are so many of them, but all main rules should be there. The reason for CORRECT vs INVALID is that both words have the same number of characters so calls line up, but look quite different. Reviewers: #cycles, sergey Reviewed By: #cycles, sergey Subscribers: dingto, sergey, brecht Differential Revision: https://developer.blender.org/D2130
2016-08-01 18:53:20 +03:00
.set("Fac", 0.5f)
.set("Vector", make_float3(0.3f, 0.5f, 0.7f)))
.output_color("Curves::Vector");
Refactor: Cycles: Replace new/delete by unique_ptr, in simple cases Pull Request: https://projects.blender.org/blender/blender/pulls/132361
2024-12-29 23:13:45 +01:00
graph.finalize(scene.get());
Cycles: add unit tests for supported constant folding rules. Code coverage of different combinations of secondary conditions is obviously not complete because there are so many of them, but all main rules should be there. The reason for CORRECT vs INVALID is that both words have the same number of characters so calls line up, but look quite different. Reviewers: #cycles, sergey Reviewed By: #cycles, sergey Subscribers: dingto, sergey, brecht Differential Revision: https://developer.blender.org/D2130
2016-08-01 18:53:20 +03:00
}
/*
* Tests:
* - Folding of Vector Curves with zero Fac.
*/
Cycles: Fix memory leak in test and simplify code
2017-10-24 11:12:28 +02:00
TEST_F(RenderGraph, constant_fold_vector_curves_fac_0)
Cycles: add unit tests for supported constant folding rules. Code coverage of different combinations of secondary conditions is obviously not complete because there are so many of them, but all main rules should be there. The reason for CORRECT vs INVALID is that both words have the same number of characters so calls line up, but look quite different. Reviewers: #cycles, sergey Reviewed By: #cycles, sergey Subscribers: dingto, sergey, brecht Differential Revision: https://developer.blender.org/D2130
2016-08-01 18:53:20 +03:00
{
EXPECT_ANY_MESSAGE(log);
CORRECT_INFO_MESSAGE(log, "Folding Curves::Vector to socket Attribute::Vector.");
array<float3> curve;
init_test_curve(curve, make_float3(0.0f, 0.25f, 1.0f), make_float3(1.0f, 0.75f, 0.0f), 257);
builder.add_attribute("Attribute")
Cycles: fix missing ShaderNode ownership in render_graph_finalize_test
2020-10-13 15:36:52 +02:00
.add_node(ShaderNodeBuilder<VectorCurvesNode>(graph, "Curves")
Cycles API: encapsulate Node socket members This encapsulates Node socket members behind a set of specific methods; as such it is no longer possible to directly access Node class members from exporters and parts of Cycles. The methods are defined via the NODE_SOCKET_API macros in `graph/ node.h`, and are for getting or setting a specific socket's value, as well as querying or modifying the state of its update flag. The setters will check whether the value has changed and tag the socket as modified appropriately. This will let us know how a Node has changed and what to update, which is the first concrete step toward a more granular scene update system. Since the setters will tag the Node sockets as modified when passed different data, this patch also removes the various modified methods on Nodes in favor of Node::is_modified which checks the sockets' update flags status. Reviewed By: brecht Maniphest Tasks: T79174 Differential Revision: https://developer.blender.org/D8544
2020-11-04 11:17:38 +01:00
.set_param("curves", curve)
.set_param("min_x", 0.1f)
.set_param("max_x", 0.9f)
Cycles: add unit tests for supported constant folding rules. Code coverage of different combinations of secondary conditions is obviously not complete because there are so many of them, but all main rules should be there. The reason for CORRECT vs INVALID is that both words have the same number of characters so calls line up, but look quite different. Reviewers: #cycles, sergey Reviewed By: #cycles, sergey Subscribers: dingto, sergey, brecht Differential Revision: https://developer.blender.org/D2130
2016-08-01 18:53:20 +03:00
.set("Fac", 0.0f))
.add_connection("Attribute::Vector", "Curves::Vector")
.output_color("Curves::Vector");
Refactor: Cycles: Replace new/delete by unique_ptr, in simple cases Pull Request: https://projects.blender.org/blender/blender/pulls/132361
2024-12-29 23:13:45 +01:00
graph.finalize(scene.get());
Cycles: add unit tests for supported constant folding rules. Code coverage of different combinations of secondary conditions is obviously not complete because there are so many of them, but all main rules should be there. The reason for CORRECT vs INVALID is that both words have the same number of characters so calls line up, but look quite different. Reviewers: #cycles, sergey Reviewed By: #cycles, sergey Subscribers: dingto, sergey, brecht Differential Revision: https://developer.blender.org/D2130
2016-08-01 18:53:20 +03:00
}
/*
* Tests:
* - Folding of Color Ramp with all constant inputs.
*/
Cycles: Fix memory leak in test and simplify code
2017-10-24 11:12:28 +02:00
TEST_F(RenderGraph, constant_fold_rgb_ramp)
Cycles: add unit tests for supported constant folding rules. Code coverage of different combinations of secondary conditions is obviously not complete because there are so many of them, but all main rules should be there. The reason for CORRECT vs INVALID is that both words have the same number of characters so calls line up, but look quite different. Reviewers: #cycles, sergey Reviewed By: #cycles, sergey Subscribers: dingto, sergey, brecht Differential Revision: https://developer.blender.org/D2130
2016-08-01 18:53:20 +03:00
{
EXPECT_ANY_MESSAGE(log);
CORRECT_INFO_MESSAGE(log, "Folding Ramp::Color to constant (0.14, 0.39, 0.64).");
CORRECT_INFO_MESSAGE(log, "Folding Ramp::Alpha to constant (0.89).");
array<float3> curve;
array<float> alpha;
init_test_curve(curve, make_float3(0.0f, 0.25f, 0.5f), make_float3(0.25f, 0.5f, 0.75f), 9);
init_test_curve(alpha, 0.75f, 1.0f, 9);
builder
Cycles: fix missing ShaderNode ownership in render_graph_finalize_test
2020-10-13 15:36:52 +02:00
.add_node(ShaderNodeBuilder<RGBRampNode>(graph, "Ramp")
Cycles API: encapsulate Node socket members This encapsulates Node socket members behind a set of specific methods; as such it is no longer possible to directly access Node class members from exporters and parts of Cycles. The methods are defined via the NODE_SOCKET_API macros in `graph/ node.h`, and are for getting or setting a specific socket's value, as well as querying or modifying the state of its update flag. The setters will check whether the value has changed and tag the socket as modified appropriately. This will let us know how a Node has changed and what to update, which is the first concrete step toward a more granular scene update system. Since the setters will tag the Node sockets as modified when passed different data, this patch also removes the various modified methods on Nodes in favor of Node::is_modified which checks the sockets' update flags status. Reviewed By: brecht Maniphest Tasks: T79174 Differential Revision: https://developer.blender.org/D8544
2020-11-04 11:17:38 +01:00
.set_param("ramp", curve)
.set_param("ramp_alpha", alpha)
.set_param("interpolate", true)
Cycles: add unit tests for supported constant folding rules. Code coverage of different combinations of secondary conditions is obviously not complete because there are so many of them, but all main rules should be there. The reason for CORRECT vs INVALID is that both words have the same number of characters so calls line up, but look quite different. Reviewers: #cycles, sergey Reviewed By: #cycles, sergey Subscribers: dingto, sergey, brecht Differential Revision: https://developer.blender.org/D2130
2016-08-01 18:53:20 +03:00
.set("Fac", 0.56f))
Cycles API: encapsulate Node socket members This encapsulates Node socket members behind a set of specific methods; as such it is no longer possible to directly access Node class members from exporters and parts of Cycles. The methods are defined via the NODE_SOCKET_API macros in `graph/ node.h`, and are for getting or setting a specific socket's value, as well as querying or modifying the state of its update flag. The setters will check whether the value has changed and tag the socket as modified appropriately. This will let us know how a Node has changed and what to update, which is the first concrete step toward a more granular scene update system. Since the setters will tag the Node sockets as modified when passed different data, this patch also removes the various modified methods on Nodes in favor of Node::is_modified which checks the sockets' update flags status. Reviewed By: brecht Maniphest Tasks: T79174 Differential Revision: https://developer.blender.org/D8544
2020-11-04 11:17:38 +01:00
.add_node(ShaderNodeBuilder<MixNode>(graph, "Mix").set_param("mix_type", NODE_MIX_ADD))
Cycles: add unit tests for supported constant folding rules. Code coverage of different combinations of secondary conditions is obviously not complete because there are so many of them, but all main rules should be there. The reason for CORRECT vs INVALID is that both words have the same number of characters so calls line up, but look quite different. Reviewers: #cycles, sergey Reviewed By: #cycles, sergey Subscribers: dingto, sergey, brecht Differential Revision: https://developer.blender.org/D2130
2016-08-01 18:53:20 +03:00
.add_connection("Ramp::Color", "Mix::Color1")
.add_connection("Ramp::Alpha", "Mix::Color2")
.output_color("Mix::Color");
Refactor: Cycles: Replace new/delete by unique_ptr, in simple cases Pull Request: https://projects.blender.org/blender/blender/pulls/132361
2024-12-29 23:13:45 +01:00
graph.finalize(scene.get());
Cycles: add unit tests for supported constant folding rules. Code coverage of different combinations of secondary conditions is obviously not complete because there are so many of them, but all main rules should be there. The reason for CORRECT vs INVALID is that both words have the same number of characters so calls line up, but look quite different. Reviewers: #cycles, sergey Reviewed By: #cycles, sergey Subscribers: dingto, sergey, brecht Differential Revision: https://developer.blender.org/D2130
2016-08-01 18:53:20 +03:00
}
/*
* Tests:
* - Folding of Color Ramp with all constant inputs (interpolate false).
*/
Cycles: Fix memory leak in test and simplify code
2017-10-24 11:12:28 +02:00
TEST_F(RenderGraph, constant_fold_rgb_ramp_flat)
Cycles: add unit tests for supported constant folding rules. Code coverage of different combinations of secondary conditions is obviously not complete because there are so many of them, but all main rules should be there. The reason for CORRECT vs INVALID is that both words have the same number of characters so calls line up, but look quite different. Reviewers: #cycles, sergey Reviewed By: #cycles, sergey Subscribers: dingto, sergey, brecht Differential Revision: https://developer.blender.org/D2130
2016-08-01 18:53:20 +03:00
{
EXPECT_ANY_MESSAGE(log);
CORRECT_INFO_MESSAGE(log, "Folding Ramp::Color to constant (0.125, 0.375, 0.625).");
CORRECT_INFO_MESSAGE(log, "Folding Ramp::Alpha to constant (0.875).");
array<float3> curve;
array<float> alpha;
init_test_curve(curve, make_float3(0.0f, 0.25f, 0.5f), make_float3(0.25f, 0.5f, 0.75f), 9);
init_test_curve(alpha, 0.75f, 1.0f, 9);
builder
Cycles: fix missing ShaderNode ownership in render_graph_finalize_test
2020-10-13 15:36:52 +02:00
.add_node(ShaderNodeBuilder<RGBRampNode>(graph, "Ramp")
Cycles API: encapsulate Node socket members This encapsulates Node socket members behind a set of specific methods; as such it is no longer possible to directly access Node class members from exporters and parts of Cycles. The methods are defined via the NODE_SOCKET_API macros in `graph/ node.h`, and are for getting or setting a specific socket's value, as well as querying or modifying the state of its update flag. The setters will check whether the value has changed and tag the socket as modified appropriately. This will let us know how a Node has changed and what to update, which is the first concrete step toward a more granular scene update system. Since the setters will tag the Node sockets as modified when passed different data, this patch also removes the various modified methods on Nodes in favor of Node::is_modified which checks the sockets' update flags status. Reviewed By: brecht Maniphest Tasks: T79174 Differential Revision: https://developer.blender.org/D8544
2020-11-04 11:17:38 +01:00
.set_param("ramp", curve)
.set_param("ramp_alpha", alpha)
.set_param("interpolate", false)
Cycles: add unit tests for supported constant folding rules. Code coverage of different combinations of secondary conditions is obviously not complete because there are so many of them, but all main rules should be there. The reason for CORRECT vs INVALID is that both words have the same number of characters so calls line up, but look quite different. Reviewers: #cycles, sergey Reviewed By: #cycles, sergey Subscribers: dingto, sergey, brecht Differential Revision: https://developer.blender.org/D2130
2016-08-01 18:53:20 +03:00
.set("Fac", 0.56f))
Cycles API: encapsulate Node socket members This encapsulates Node socket members behind a set of specific methods; as such it is no longer possible to directly access Node class members from exporters and parts of Cycles. The methods are defined via the NODE_SOCKET_API macros in `graph/ node.h`, and are for getting or setting a specific socket's value, as well as querying or modifying the state of its update flag. The setters will check whether the value has changed and tag the socket as modified appropriately. This will let us know how a Node has changed and what to update, which is the first concrete step toward a more granular scene update system. Since the setters will tag the Node sockets as modified when passed different data, this patch also removes the various modified methods on Nodes in favor of Node::is_modified which checks the sockets' update flags status. Reviewed By: brecht Maniphest Tasks: T79174 Differential Revision: https://developer.blender.org/D8544
2020-11-04 11:17:38 +01:00
.add_node(ShaderNodeBuilder<MixNode>(graph, "Mix").set_param("mix_type", NODE_MIX_ADD))
Cycles: add unit tests for supported constant folding rules. Code coverage of different combinations of secondary conditions is obviously not complete because there are so many of them, but all main rules should be there. The reason for CORRECT vs INVALID is that both words have the same number of characters so calls line up, but look quite different. Reviewers: #cycles, sergey Reviewed By: #cycles, sergey Subscribers: dingto, sergey, brecht Differential Revision: https://developer.blender.org/D2130
2016-08-01 18:53:20 +03:00
.add_connection("Ramp::Color", "Mix::Color1")
.add_connection("Ramp::Alpha", "Mix::Color2")
.output_color("Mix::Color");
Cycles: Add fundamentals to test constant folding This commit adds some easy to use way to check whether the graph was properly optimized. The idea is based on using mock glog sync which keeps track on all messages and expects specific log message to appear in the logging. This means each optimization step should report that it optimized something (specifying what exactly was optimized) and what was used for optimization. There's also some ease-ish way to define shader networks which we might want to make a bit more global and available for all tests in the future. For now only RGBToBW node is covered as an example, really hope to get help from active guys in the community to finish covering all existing optimization cases. Ready to fix any possible issues with builder when needed tho :)
2016-07-29 18:44:29 +02:00
Refactor: Cycles: Replace new/delete by unique_ptr, in simple cases Pull Request: https://projects.blender.org/blender/blender/pulls/132361
2024-12-29 23:13:45 +01:00
graph.finalize(scene.get());
Cycles: Add fundamentals to test constant folding This commit adds some easy to use way to check whether the graph was properly optimized. The idea is based on using mock glog sync which keeps track on all messages and expects specific log message to appear in the logging. This means each optimization step should report that it optimized something (specifying what exactly was optimized) and what was used for optimization. There's also some ease-ish way to define shader networks which we might want to make a bit more global and available for all tests in the future. For now only RGBToBW node is covered as an example, really hope to get help from active guys in the community to finish covering all existing optimization cases. Ready to fix any possible issues with builder when needed tho :)
2016-07-29 18:44:29 +02:00
}
Cycles: add folding for redundant A to B to A conversions. As a result of other folding simplifications it may happen that two type conversion nodes end up directly connected. In some cases it may be possible to then remove both. A realistic case might be an optimized out Mix RGB node used to blend vectors. It seems it's safe to optimize when B is a float3 type (color, vector), and A is float3 or float. Reviewers: #cycles, sergey Reviewed By: #cycles, sergey Subscribers: sergey Differential Revision: https://developer.blender.org/D2134
2016-08-02 12:22:43 +03:00
/*
* Tests:
* - Folding of redundant conversion of float to color to float.
*/
Cycles: Fix memory leak in test and simplify code
2017-10-24 11:12:28 +02:00
TEST_F(RenderGraph, constant_fold_convert_float_color_float)
Cycles: add folding for redundant A to B to A conversions. As a result of other folding simplifications it may happen that two type conversion nodes end up directly connected. In some cases it may be possible to then remove both. A realistic case might be an optimized out Mix RGB node used to blend vectors. It seems it's safe to optimize when B is a float3 type (color, vector), and A is float3 or float. Reviewers: #cycles, sergey Reviewed By: #cycles, sergey Subscribers: sergey Differential Revision: https://developer.blender.org/D2134
2016-08-02 12:22:43 +03:00
{
EXPECT_ANY_MESSAGE(log);
CORRECT_INFO_MESSAGE(log,
"Folding Invert::Color to socket convert_float_to_color::value_color.");
CORRECT_INFO_MESSAGE(log,
"Folding convert_color_to_float::value_float to socket Attribute::Fac.");
builder.add_attribute("Attribute")
Cycles: fix missing ShaderNode ownership in render_graph_finalize_test
2020-10-13 15:36:52 +02:00
.add_node(ShaderNodeBuilder<InvertNode>(graph, "Invert").set("Fac", 0.0f))
Cycles: add folding for redundant A to B to A conversions. As a result of other folding simplifications it may happen that two type conversion nodes end up directly connected. In some cases it may be possible to then remove both. A realistic case might be an optimized out Mix RGB node used to blend vectors. It seems it's safe to optimize when B is a float3 type (color, vector), and A is float3 or float. Reviewers: #cycles, sergey Reviewed By: #cycles, sergey Subscribers: sergey Differential Revision: https://developer.blender.org/D2134
2016-08-02 12:22:43 +03:00
.add_connection("Attribute::Fac", "Invert::Color")
.output_value("Invert::Color");
Refactor: Cycles: Replace new/delete by unique_ptr, in simple cases Pull Request: https://projects.blender.org/blender/blender/pulls/132361
2024-12-29 23:13:45 +01:00
graph.finalize(scene.get());
Cycles: add folding for redundant A to B to A conversions. As a result of other folding simplifications it may happen that two type conversion nodes end up directly connected. In some cases it may be possible to then remove both. A realistic case might be an optimized out Mix RGB node used to blend vectors. It seems it's safe to optimize when B is a float3 type (color, vector), and A is float3 or float. Reviewers: #cycles, sergey Reviewed By: #cycles, sergey Subscribers: sergey Differential Revision: https://developer.blender.org/D2134
2016-08-02 12:22:43 +03:00
}
/*
* Tests:
* - Folding of redundant conversion of color to vector to color.
*/
Cycles: Fix memory leak in test and simplify code
2017-10-24 11:12:28 +02:00
TEST_F(RenderGraph, constant_fold_convert_color_vector_color)
Cycles: add folding for redundant A to B to A conversions. As a result of other folding simplifications it may happen that two type conversion nodes end up directly connected. In some cases it may be possible to then remove both. A realistic case might be an optimized out Mix RGB node used to blend vectors. It seems it's safe to optimize when B is a float3 type (color, vector), and A is float3 or float. Reviewers: #cycles, sergey Reviewed By: #cycles, sergey Subscribers: sergey Differential Revision: https://developer.blender.org/D2134
2016-08-02 12:22:43 +03:00
{
EXPECT_ANY_MESSAGE(log);
CORRECT_INFO_MESSAGE(log,
"Folding VecAdd::Vector to socket convert_color_to_vector::value_vector.");
CORRECT_INFO_MESSAGE(log,
"Folding convert_vector_to_color::value_color to socket Attribute::Color.");
builder.add_attribute("Attribute")
Cycles: fix missing ShaderNode ownership in render_graph_finalize_test
2020-10-13 15:36:52 +02:00
.add_node(ShaderNodeBuilder<VectorMathNode>(graph, "VecAdd")
Cycles API: encapsulate Node socket members This encapsulates Node socket members behind a set of specific methods; as such it is no longer possible to directly access Node class members from exporters and parts of Cycles. The methods are defined via the NODE_SOCKET_API macros in `graph/ node.h`, and are for getting or setting a specific socket's value, as well as querying or modifying the state of its update flag. The setters will check whether the value has changed and tag the socket as modified appropriately. This will let us know how a Node has changed and what to update, which is the first concrete step toward a more granular scene update system. Since the setters will tag the Node sockets as modified when passed different data, this patch also removes the various modified methods on Nodes in favor of Node::is_modified which checks the sockets' update flags status. Reviewed By: brecht Maniphest Tasks: T79174 Differential Revision: https://developer.blender.org/D8544
2020-11-04 11:17:38 +01:00
.set_param("math_type", NODE_VECTOR_MATH_ADD)
Cycles: add folding for redundant A to B to A conversions. As a result of other folding simplifications it may happen that two type conversion nodes end up directly connected. In some cases it may be possible to then remove both. A realistic case might be an optimized out Mix RGB node used to blend vectors. It seems it's safe to optimize when B is a float3 type (color, vector), and A is float3 or float. Reviewers: #cycles, sergey Reviewed By: #cycles, sergey Subscribers: sergey Differential Revision: https://developer.blender.org/D2134
2016-08-02 12:22:43 +03:00
.set("Vector2", make_float3(0, 0, 0)))
.add_connection("Attribute::Color", "VecAdd::Vector1")
.output_color("VecAdd::Vector");
Refactor: Cycles: Replace new/delete by unique_ptr, in simple cases Pull Request: https://projects.blender.org/blender/blender/pulls/132361
2024-12-29 23:13:45 +01:00
graph.finalize(scene.get());
Cycles: add folding for redundant A to B to A conversions. As a result of other folding simplifications it may happen that two type conversion nodes end up directly connected. In some cases it may be possible to then remove both. A realistic case might be an optimized out Mix RGB node used to blend vectors. It seems it's safe to optimize when B is a float3 type (color, vector), and A is float3 or float. Reviewers: #cycles, sergey Reviewed By: #cycles, sergey Subscribers: sergey Differential Revision: https://developer.blender.org/D2134
2016-08-02 12:22:43 +03:00
}
/*
* Tests:
* - NOT folding conversion of color to float to color.
*/
Cycles: Fix memory leak in test and simplify code
2017-10-24 11:12:28 +02:00
TEST_F(RenderGraph, constant_fold_convert_color_float_color)
Cycles: add folding for redundant A to B to A conversions. As a result of other folding simplifications it may happen that two type conversion nodes end up directly connected. In some cases it may be possible to then remove both. A realistic case might be an optimized out Mix RGB node used to blend vectors. It seems it's safe to optimize when B is a float3 type (color, vector), and A is float3 or float. Reviewers: #cycles, sergey Reviewed By: #cycles, sergey Subscribers: sergey Differential Revision: https://developer.blender.org/D2134
2016-08-02 12:22:43 +03:00
{
EXPECT_ANY_MESSAGE(log);
CORRECT_INFO_MESSAGE(log,
"Folding MathAdd::Value to socket convert_color_to_float::value_float.");
INVALID_INFO_MESSAGE(log, "Folding convert_float_to_color::");
builder.add_attribute("Attribute")
Cycles: fix missing ShaderNode ownership in render_graph_finalize_test
2020-10-13 15:36:52 +02:00
.add_node(ShaderNodeBuilder<MathNode>(graph, "MathAdd")
Cycles API: encapsulate Node socket members This encapsulates Node socket members behind a set of specific methods; as such it is no longer possible to directly access Node class members from exporters and parts of Cycles. The methods are defined via the NODE_SOCKET_API macros in `graph/ node.h`, and are for getting or setting a specific socket's value, as well as querying or modifying the state of its update flag. The setters will check whether the value has changed and tag the socket as modified appropriately. This will let us know how a Node has changed and what to update, which is the first concrete step toward a more granular scene update system. Since the setters will tag the Node sockets as modified when passed different data, this patch also removes the various modified methods on Nodes in favor of Node::is_modified which checks the sockets' update flags status. Reviewed By: brecht Maniphest Tasks: T79174 Differential Revision: https://developer.blender.org/D8544
2020-11-04 11:17:38 +01:00
.set_param("math_type", NODE_MATH_ADD)
Cycles: add folding for redundant A to B to A conversions. As a result of other folding simplifications it may happen that two type conversion nodes end up directly connected. In some cases it may be possible to then remove both. A realistic case might be an optimized out Mix RGB node used to blend vectors. It seems it's safe to optimize when B is a float3 type (color, vector), and A is float3 or float. Reviewers: #cycles, sergey Reviewed By: #cycles, sergey Subscribers: sergey Differential Revision: https://developer.blender.org/D2134
2016-08-02 12:22:43 +03:00
.set("Value2", 0.0f))
.add_connection("Attribute::Color", "MathAdd::Value1")
.output_color("MathAdd::Value");
Refactor: Cycles: Replace new/delete by unique_ptr, in simple cases Pull Request: https://projects.blender.org/blender/blender/pulls/132361
2024-12-29 23:13:45 +01:00
graph.finalize(scene.get());
Cycles: add folding for redundant A to B to A conversions. As a result of other folding simplifications it may happen that two type conversion nodes end up directly connected. In some cases it may be possible to then remove both. A realistic case might be an optimized out Mix RGB node used to blend vectors. It seems it's safe to optimize when B is a float3 type (color, vector), and A is float3 or float. Reviewers: #cycles, sergey Reviewed By: #cycles, sergey Subscribers: sergey Differential Revision: https://developer.blender.org/D2134
2016-08-02 12:22:43 +03:00
}
Cycles: Add fundamentals to test constant folding This commit adds some easy to use way to check whether the graph was properly optimized. The idea is based on using mock glog sync which keeps track on all messages and expects specific log message to appear in the logging. This means each optimization step should report that it optimized something (specifying what exactly was optimized) and what was used for optimization. There's also some ease-ish way to define shader networks which we might want to make a bit more global and available for all tests in the future. For now only RGBToBW node is covered as an example, really hope to get help from active guys in the community to finish covering all existing optimization cases. Ready to fix any possible issues with builder when needed tho :)
2016-07-29 18:44:29 +02:00
CCL_NAMESPACE_END
Reference in New Issue Copy Permalink