[Bf-blender-cvs] [c0e3d2c1030] temp-viewport-compositor-compiler: Viewport Compositor: Introduce input domain priority
Omar Emara
noreply at git.blender.org
Wed Mar 30 11:56:05 CEST 2022
Commit: c0e3d2c10304a6eda455f1664abe4847dfce83b6
Author: Omar Emara
Date: Wed Mar 30 11:09:42 2022 +0200
Branches: temp-viewport-compositor-compiler
https://developer.blender.org/rBc0e3d2c10304a6eda455f1664abe4847dfce83b6
Viewport Compositor: Introduce input domain priority
Inputs now declare a domain priority value instead of declaring
themselves as domain inputs. This allows multiple inputs to assume
domain inference role, and the best option is chosen based on the
priority and other factors.
===================================================================
M source/blender/nodes/NOD_compositor_execute.hh
M source/blender/nodes/NOD_node_declaration.hh
M source/blender/nodes/composite/nodes/node_composite_transform.cc
M source/blender/nodes/intern/node_compositor_execute.cc
===================================================================
diff --git a/source/blender/nodes/NOD_compositor_execute.hh b/source/blender/nodes/NOD_compositor_execute.hh
index 3d107a7f24d..6171f859c33 100644
--- a/source/blender/nodes/NOD_compositor_execute.hh
+++ b/source/blender/nodes/NOD_compositor_execute.hh
@@ -137,11 +137,11 @@ class Context {
* operation domain. To abstract away the different domains of the inputs, any input that have a
* different domain than the operation domain is realized on the operation domain through a
* RealizeOnDomainProcessorOperation, except inputs whose descriptor sets skip_realization or
- * is_domain, see InputDescriptor. The realization process simply projects the input domain on the
- * operation domain, copies the area of input that intersects the operation domain, and fill the
- * rest with zeros. This process is illustrated below. It follows that operations should expect all
- * their inputs to have the same domain and consequently size, except possibly for inputs that skip
- * realization.
+ * expects_single_value, see InputDescriptor for more information. The realization process simply
+ * projects the input domain on the operation domain, copies the area of input that intersects the
+ * operation domain, and fill the rest with zeros. This process is illustrated below. It follows
+ * that operations should expect all their inputs to have the same domain and consequently size,
+ * except for inputs that explicitly skip realization.
*
* Realized Result
* +-------------+ +-------------+
@@ -151,18 +151,16 @@ class Context {
* +-----------+ | |-----+ |
* | | C | | | C | |
* | +-----|-------+ +-----|-------+
- * | Input |
- * | Domain |
+ * | Domain Of |
+ * | Input |
* +-----------+
*
* Each operation can define an arbitrary operation domain, but in most cases, the operation domain
* is inferred from the inputs. By default, the operation domain is computed as follows. Typically,
- * one input of the operation is said to be a domain input and it defines the operation domain. So
- * if the operation have an input whose descriptor sets is_domain and is not a single value input,
- * then the operation domain will be the same domain as the first such input. See the
- * InputDescriptor class. Otherwise, if no domain inputs exists or all are single value inputs,
- * then the first non single value input is used to define the operation domain. If all inputs are
- * single values, then the operation domain is irrelevant and an identity domain is set. See
+ * one input of the operation is said to be the domain input and the operation domain is inferred
+ * from it. The domain input is determined to be the non-single value input that have the highest
+ * domain priority, a zero value being the highest priority. If all inputs are single values, then
+ * the operation domain is irrelevant and an identity domain is set. See
* NodeOperation::compute_domain.
*
* The aforementioned logic for operation domain computation is only a default that works for most
@@ -171,15 +169,17 @@ class Context {
* identity transformation, their operation domain doesn't depend on the inputs at all.
*
* For instance, a filter operation have two inputs, a factor and a color, the latter of which
- * is a domain input. If the color input is not a single value, then the domain of this operation
- * is computed to be the same size and transformation as the color input. And if the factor input
+ * has a domain priority of 0 and the former has a domain priority of 1. If the color input is not
+ * a single value, then the domain of this operation is computed to be the same size and
+ * transformation as the color input, because it has the highest priority. And if the factor input
* have a different size and/or transformation from the computed domain of the operation, it will
* be projected and realized on it to have the same size as described above. It follows that the
- * color input, which is a domain input, will not need to be realized because it already has the
- * same size and transformation as the domain of the operation, because the operation domain is
- * derived from it. On the other hand, if the color input is a single value input, then the
- * operation domain will be the same as the domain of the factor input. Finally, if both inputs are
- * single value inputs, the operation domain will be an identity and is irrelevant. */
+ * color input, will not need to be realized because it already has the same size and
+ * transformation as the domain of the operation, because the operation domain is inferred from it.
+ * On the other hand, if the color input is a single value input, then the operation domain will be
+ * the same as the domain of the factor input, because it has the second highest domain priority.
+ * Finally, if both inputs are single value inputs, the operation domain will be an identity and is
+ * irrelevant. */
class Domain {
public:
/* The size of the domain in pixels. */
@@ -220,8 +220,8 @@ class Result {
private:
/* The base type of the texture or the type of the single value. */
ResultType type_;
- /* If true, the result is a texture, otherwise, the result is a single value. */
- bool is_texture_;
+ /* If true, the result is a single value, otherwise, the result is a texture. */
+ bool is_single_value_;
/* A GPU texture storing the result data. This will be a 1x1 texture if the result is a single
* value, the value of which will be identical to that of the value member. See class description
* for more information. */
@@ -375,10 +375,16 @@ class InputDescriptor {
/* If true, then the input does not need to be realized on the domain of the operation before its
* execution. See the Domain class for more information. */
bool skip_realization = false;
- /* If true, then the input is considered to be a domain input that is used by default to define
- * the domain of the operation, this is typically the main input of the operation. See the Domain
- * class for more information. */
- bool is_domain = false;
+ /* The priority of the input for determining the operation domain. The non-single value input
+ * with the highest priority will be used to infer the operation domain, the highest priority
+ * being zero. See the Domain class for more information. */
+ int domain_priority = 0;
+ /* If true, the input expects a single value, and if a non-single value is provided, a default
+ * single value will be used instead, see the get_*_value_default methods in the Result
+ * class. It follows that this also imply skip_realization, because we don't need to realize a
+ * result that will be discarded anyways. If false, the input can work with both single and
+ * non-single values. */
+ bool expects_single_value = false;
};
/* --------------------------------------------------------------------
diff --git a/source/blender/nodes/NOD_node_declaration.hh b/source/blender/nodes/NOD_node_declaration.hh
index 8fef760a1f1..afc507752f9 100644
--- a/source/blender/nodes/NOD_node_declaration.hh
+++ b/source/blender/nodes/NOD_node_declaration.hh
@@ -102,8 +102,13 @@ class SocketDeclaration {
InputSocketFieldType input_field_type_ = InputSocketFieldType::None;
OutputFieldDependency output_field_dependency_;
- /** This input is a domain input. See viewport_compositor::InputDescriptor. */
- bool is_compositor_domain_input_ = false;
+ /** The priority of the input for determining the domain of the node. See
+ * viewport_compositor::InputDescriptor for more information. */
+ int compositor_domain_priority_ = 0;
+
+ /** This input expects a single value and can't operate on non-single values. See
+ * viewport_compositor::InputDescriptor for more information. */
+ bool compositor_expects_single_value_ = false;
/** Utility method to make the socket available if there is a straightforward way to do so. */
std::function<void(bNode &)> make_available_fn_;
@@ -141,7 +146,8 @@ class SocketDeclaration {
InputSocketFieldType input_field_type() const;
const OutputFieldDependency &output_field_dependency() const;
- bool is_compositor_domain_input() const;
+ int compositor_domain_priority() const;
+ bool compositor_expects_single_value() const;
protected:
void set_common_flags(bNodeSocket &socket) const;
@@ -257,10 +263,19 @@ class SocketDeclarationBuilder : public BaseSocketDeclarationBuilder {
return *(Self *)this;
}
- /** This input is a domain input. See viewport_compositor::InputDescriptor. */
- Self &is_compositor_domain_input(bool value = true)
+ /** The priority of the input for determining the domain of the node. See
+ * viewport_compositor::InputDescriptor for more information. */
+ Self &compositor_domain_priority(int priority)
+ {
+ decl_->compositor_domain_priority_ = priority;
+ return *(Self *)this;
+ }
+
+ /** This input expects a single value and can't operate on non-single values. See
+ * viewport_compositor::InputDescriptor for more information. */
+ Self &compositor_expects_single_value(bool value = true)
{
- decl_->is_compositor_domain_input_ = value;
+ decl_->compositor_expects_single_value_ = value;
return *(Self *)this;
}
@@ -454,9 +469,14 @@ inline const OutputFieldDependency &SocketDeclaration::output_field_dependency()
return output_field_dependency_;
}
-inline bool SocketDeclaration::is_compositor_domain_input() const
+inline int SocketDeclaration::compositor_domain_priority() const
+{
+ return compositor_domain_priority_;
+}
+
+inline bool SocketDeclaration::compositor_expects_single_value() const
{
- return is_compositor_domain_input_;
+ return compositor_expects_single_value_;
}
inline void SocketDeclaration::make_available(bNode &node) const
diff --git a/source/blender/nodes/composite/nodes/node_composite_transform.cc b/source/blender/nodes/composite/nodes/node_composite_transform.cc
index aaaac45333b..d6f2734b54d 100644
--- a/source/blender/nodes/composite/nodes/node_composite_transform.cc
+++ b/source/blender/nodes/composi
@@ Diff output truncated at 10240 characters. @@
More information about the Bf-blender-cvs
mailing list