Blender V5.3
node_composite_box_mask.cc
Go to the documentation of this file.
1/* SPDX-FileCopyrightText: 2006 Blender Authors
2 *
3 * SPDX-License-Identifier: GPL-2.0-or-later */
4
5#include <cmath>
6
7#include "BLI_math_base.hh"
10
11#include "GPU_shader.hh"
12
13#include "BKE_node.hh"
14
15#include "COM_node_operation.hh"
16#include "COM_utilities.hh"
17
19
21
23 {CMP_NODE_MASKTYPE_ADD, "ADD", 0, N_("Add"), ""},
24 {CMP_NODE_MASKTYPE_SUBTRACT, "SUBTRACT", 0, N_("Subtract"), ""},
25 {CMP_NODE_MASKTYPE_MULTIPLY, "MULTIPLY", 0, N_("Multiply"), ""},
26 {CMP_NODE_MASKTYPE_NOT, "NOT", 0, N_("Not"), ""},
27 {0, nullptr, 0, nullptr, nullptr},
28};
29
31{
32 b.add_input<decl::Menu>("Operation"_ustr)
33 .default_value(CMP_NODE_MASKTYPE_ADD)
34 .static_items(operation_items)
36 b.add_input<decl::Float>("Mask"_ustr)
37 .subtype(PROP_FACTOR)
38 .default_value(0.0f)
39 .min(0.0f)
40 .max(1.0f)
41 .structure_type(StructureType::Dynamic);
42 b.add_input<decl::Float>("Value"_ustr)
43 .subtype(PROP_FACTOR)
44 .default_value(1.0f)
45 .min(0.0f)
46 .max(1.0f)
47 .structure_type(StructureType::Dynamic);
48 b.add_input<decl::Vector>("Position"_ustr)
49 .subtype(PROP_FACTOR)
50 .dimensions(2)
51 .default_value({0.5f, 0.5f})
52 .min(-0.5f)
53 .max(1.5f);
54 b.add_input<decl::Vector>("Size"_ustr)
55 .subtype(PROP_FACTOR)
56 .dimensions(2)
57 .default_value({0.2f, 0.1f})
58 .min(0.0f)
59 .max(1.0f);
60 b.add_input<decl::Float>("Rotation"_ustr).subtype(PROP_ANGLE);
61
62 b.add_output<decl::Float>("Mask"_ustr).structure_type(StructureType::Dynamic);
63}
64
65using namespace blender::compositor;
66
67template<CMPNodeMaskType MaskType>
68static void box_mask(const Result &base_mask,
69 const Result &value_mask,
70 Result &output_mask,
71 const Domain &domain,
72 const float2 &location,
73 const float2 &size,
74 const float cos_angle,
75 const float sin_angle)
76{
77 parallel_for(domain.data_size, [&](const int2 texel) {
78 float2 uv = float2(texel + domain.data_offset) / float2(domain.display_size - int2(1));
79 uv -= location;
80 uv.y *= float(domain.display_size.y) / float(domain.display_size.x);
81 uv = float2x2(float2(cos_angle, -sin_angle), float2(sin_angle, cos_angle)) * uv;
82 bool is_inside = math::abs(uv.x) < size.x && math::abs(uv.y) < size.y;
83
84 float base_mask_value = base_mask.load_pixel<float, true>(texel);
85 float value = value_mask.load_pixel<float, true>(texel);
86
87 float output_mask_value = 0.0f;
88 if constexpr (MaskType == CMP_NODE_MASKTYPE_ADD) {
89 output_mask_value = is_inside ? math::max(base_mask_value, value) : base_mask_value;
90 }
91 else if constexpr (MaskType == CMP_NODE_MASKTYPE_SUBTRACT) {
92 output_mask_value = is_inside ? math::clamp(base_mask_value - value, 0.0f, 1.0f) :
93 base_mask_value;
94 }
95 else if constexpr (MaskType == CMP_NODE_MASKTYPE_MULTIPLY) {
96 output_mask_value = is_inside ? base_mask_value * value : 0.0f;
97 }
98 else if constexpr (MaskType == CMP_NODE_MASKTYPE_NOT) {
99 output_mask_value = is_inside ? (base_mask_value > 0.0f ? 0.0f : value) : base_mask_value;
100 }
101
102 output_mask.store_pixel(texel, output_mask_value);
103 });
104}
105
107 public:
109
110 void execute() override
111 {
112 if (this->context().use_gpu()) {
113 this->execute_gpu();
114 }
115 else {
116 this->execute_cpu();
117 }
118 }
119
121 {
122 gpu::Shader *shader = context().get_shader(get_shader_name());
124
125 const Domain domain = compute_domain();
126
127 GPU_shader_uniform_2iv(shader, "display_size", domain.display_size);
128 GPU_shader_uniform_2iv(shader, "data_offset", domain.data_offset);
129
131 GPU_shader_uniform_2fv(shader, "size", get_size() / 2.0f);
132 GPU_shader_uniform_1f(shader, "cos_angle", std::cos(get_angle()));
133 GPU_shader_uniform_1f(shader, "sin_angle", std::sin(get_angle()));
134
135 const Result &input_mask = get_input("Mask");
136 gpu::Texture *base_mask_texture = input_mask.bind_as_texture_or_single_value(shader,
137 "base_mask_tx");
138
139 const Result &value = get_input("Value");
140 gpu::Texture *value_mask_texture = value.bind_as_texture_or_single_value(shader,
141 "mask_value_tx");
142
143 Result &output_mask = get_result("Mask");
144 output_mask.allocate_texture(domain);
145 output_mask.bind_as_image(shader, "output_mask_img");
146
148
149 input_mask.unbind_as_texture_or_single_value(base_mask_texture);
150 value.unbind_as_texture_or_single_value(value_mask_texture);
151 output_mask.unbind_as_image();
153 }
154
155 const char *get_shader_name()
156 {
157 switch (this->get_operation()) {
159 return "compositor_box_mask_add";
161 return "compositor_box_mask_subtract";
163 return "compositor_box_mask_multiply";
165 return "compositor_box_mask_not";
166 }
167
168 return "compositor_box_mask_add";
169 }
170
172 {
173 const Result &base_mask = this->get_input("Mask");
174 const Result &value_mask = this->get_input("Value");
175
176 Result &output_mask = this->get_result("Mask");
177 const Domain domain = this->compute_domain();
178 output_mask.allocate_texture(domain);
179
180 const float2 location = this->get_location();
181 const float2 size = this->get_size() / 2.0f;
182 const float cos_angle = math::cos(this->get_angle());
183 const float sin_angle = math::sin(this->get_angle());
184
185 switch (this->get_operation()) {
188 base_mask, value_mask, output_mask, domain, location, size, cos_angle, sin_angle);
189 return;
192 base_mask, value_mask, output_mask, domain, location, size, cos_angle, sin_angle);
193 return;
196 base_mask, value_mask, output_mask, domain, location, size, cos_angle, sin_angle);
197 return;
200 base_mask, value_mask, output_mask, domain, location, size, cos_angle, sin_angle);
201 return;
202 }
203
205 base_mask, value_mask, output_mask, domain, location, size, cos_angle, sin_angle);
206 }
207
209 {
210 if (get_input("Mask").is_single_value()) {
211 return context().get_compositing_domain();
212 }
213 return get_input("Mask").domain();
214 }
215
217 {
218 return this->get_input("Position").get_single_value_default<float2>();
219 }
220
222 {
223 return math::max(float2(0.0f), this->get_input("Size").get_single_value_default<float2>());
224 }
225
226 float get_angle()
227 {
228 return this->get_input("Rotation").get_single_value_default<float>();
229 }
230
232 {
233 return CMPNodeMaskType(
234 this->get_input("Operation").get_single_value_default<MenuValue>().value);
235 }
236};
237
239{
240 return new BoxMaskOperation(context, node);
241}
242
243static void node_register()
244{
245 static bke::bNodeType ntype;
246
247 cmp_node_type_base(&ntype, "CompositorNodeBoxMask"_ustr, CMP_NODE_MASK_BOX);
248 ntype.ui_name = "Box Mask";
249 ntype.ui_description = "Create rectangular mask suitable for use as a simple matte";
250 ntype.enum_name_legacy = "BOXMASK";
251 ntype.nclass = NODE_CLASS_MATTE;
252 ntype.declare = node_declare;
254
256}
257NOD_REGISTER_NODE(node_register)
258
259} // namespace blender::nodes::node_composite_box_mask_cc
#define NODE_CLASS_MATTE
Definition BKE_node.hh:485
#define CMP_NODE_MASK_BOX
#define NOD_REGISTER_NODE(REGISTER_FUNC)
NodeOperation(Context &context, const bNode &node)
Result & get_result(StringRef identifier)
Definition operation.cc:40
Context & context() const
Definition operation.cc:57
Result & get_input(StringRef identifier) const
Definition operation.cc:35
void unbind_as_texture_or_single_value(gpu::Texture *single_value_texture) const
Definition result.cc:970
void store_pixel(const int2 &texel, const T &pixel_value)
void allocate_texture(const Domain domain, const bool from_pool=true, const std::optional< ResultStorageType > storage_type=std::nullopt)
Definition result.cc:554
void unbind_as_image() const
Definition result.cc:990
void bind_as_image(gpu::Shader *shader, const char *image_name, bool read=false) const
Definition result.cc:951
gpu::Texture * bind_as_texture_or_single_value(gpu::Shader *shader, const char *texture_name) const
Definition result.cc:861
void node_register_type(bNodeType &ntype)
Definition node.cc:2920
void compute_dispatch_threads_at_least(gpu::Shader *shader, int2 threads_range, int2 local_size=int2(16))
Definition utilities.cc:235
void parallel_for(const int2 range, const Function &function)
T cos(const AngleRadianBase< T > &a)
T clamp(const T &a, const T &min, const T &max)
T sin(const AngleRadianBase< T > &a)
T max(const T &a, const T &b)
static void node_declare(NodeDeclarationBuilder &b)
static NodeOperation * get_compositor_operation(Context &context, const bNode &node)
static void box_mask(const Result &base_mask, const Result &value_mask, Result &output_mask, const Domain &domain, const float2 &location, const float2 &size, const float cos_angle, const float sin_angle)
void GPU_shader_uniform_2iv(gpu::Shader *sh, const char *name, const int data[2])
@ CMP_NODE_MASKTYPE_NOT
@ CMP_NODE_MASKTYPE_ADD
@ CMP_NODE_MASKTYPE_MULTIPLY
@ CMP_NODE_MASKTYPE_SUBTRACT
void GPU_shader_unbind()
void GPU_shader_bind(gpu::Shader *shader, const gpu::shader::SpecializationConstants *constants_state=nullptr)
void GPU_shader_uniform_2fv(gpu::Shader *sh, const char *name, const float data[2])
void GPU_shader_uniform_1f(gpu::Shader *sh, const char *name, float value)
@ PROP_FACTOR
Definition RNA_types.hh:308
void cmp_node_type_base(bke::bNodeType *ntype, UString idname, const std::optional< int16_t > legacy_type)
#define min(a, b)
Definition sort.cc:38
Defines a node type.
Definition BKE_node.hh:265
std::string ui_description
Definition BKE_node.hh:271
NodeGetCompositorOperationFunction get_compositor_operation
Definition BKE_node.hh:379
const char * enum_name_legacy
Definition BKE_node.hh:274
NodeDeclareFunction declare
Definition BKE_node.hh:393
#define N_(msgid)