Blender V5.3
node_composite_ellipse_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 "COM_node_operation.hh"
14#include "COM_utilities.hh"
15
17
19
21 {CMP_NODE_MASKTYPE_ADD, "ADD", 0, N_("Add"), ""},
22 {CMP_NODE_MASKTYPE_SUBTRACT, "SUBTRACT", 0, N_("Subtract"), ""},
23 {CMP_NODE_MASKTYPE_MULTIPLY, "MULTIPLY", 0, N_("Multiply"), ""},
24 {CMP_NODE_MASKTYPE_NOT, "NOT", 0, N_("Not"), ""},
25 {0, nullptr, 0, nullptr, nullptr},
26};
27
29{
30 b.add_input<decl::Menu>("Operation"_ustr)
31 .default_value(CMP_NODE_MASKTYPE_ADD)
32 .static_items(operation_items)
34 b.add_input<decl::Float>("Mask"_ustr)
35 .subtype(PROP_FACTOR)
36 .default_value(0.0f)
37 .min(0.0f)
38 .max(1.0f)
39 .structure_type(StructureType::Dynamic);
40 b.add_input<decl::Float>("Value"_ustr)
41 .subtype(PROP_FACTOR)
42 .default_value(1.0f)
43 .min(0.0f)
44 .max(1.0f)
45 .structure_type(StructureType::Dynamic);
46 b.add_input<decl::Vector>("Position"_ustr)
47 .subtype(PROP_FACTOR)
48 .dimensions(2)
49 .default_value({0.5f, 0.5f})
50 .min(-0.5f)
51 .max(1.5f);
52 b.add_input<decl::Vector>("Size"_ustr)
53 .subtype(PROP_FACTOR)
54 .dimensions(2)
55 .default_value({0.2f, 0.1f})
56 .min(0.0f)
57 .max(1.0f);
58 b.add_input<decl::Float>("Rotation"_ustr).subtype(PROP_ANGLE);
59
60 b.add_output<decl::Float>("Mask"_ustr).structure_type(StructureType::Dynamic);
61}
62
63using namespace blender::compositor;
64
65template<CMPNodeMaskType MaskType>
66static void ellipse_mask(const Result &base_mask,
67 const Result &value_mask,
68 Result &output_mask,
69 const Domain &domain,
70 const float2 &location,
71 const float2 &radius,
72 const float cos_angle,
73 const float sin_angle)
74{
75 parallel_for(domain.data_size, [&](const int2 texel) {
76 float2 uv = float2(texel + domain.data_offset) / float2(domain.display_size - int2(1));
77 uv -= location;
78 uv.y *= float(domain.display_size.y) / float(domain.display_size.x);
79 uv = float2x2(float2(cos_angle, -sin_angle), float2(sin_angle, cos_angle)) * uv;
80 bool is_inside = math::length(uv / radius) < 1.0f;
81
82 float base_mask_value = base_mask.load_pixel<float, true>(texel);
83 float value = value_mask.load_pixel<float, true>(texel);
84
85 float output_mask_value = 0.0f;
86 if constexpr (MaskType == CMP_NODE_MASKTYPE_ADD) {
87 output_mask_value = is_inside ? math::max(base_mask_value, value) : base_mask_value;
88 }
89 else if constexpr (MaskType == CMP_NODE_MASKTYPE_SUBTRACT) {
90 output_mask_value = is_inside ? math::clamp(base_mask_value - value, 0.0f, 1.0f) :
91 base_mask_value;
92 }
93 else if constexpr (MaskType == CMP_NODE_MASKTYPE_MULTIPLY) {
94 output_mask_value = is_inside ? base_mask_value * value : 0.0f;
95 }
96 else if constexpr (MaskType == CMP_NODE_MASKTYPE_NOT) {
97 output_mask_value = is_inside ? (base_mask_value > 0.0f ? 0.0f : value) : base_mask_value;
98 }
99
100 output_mask.store_pixel(texel, output_mask_value);
101 });
102}
103
105 public:
107
108 void execute() override
109 {
110 const Result &input_mask = get_input("Mask");
111 Result &output_mask = get_result("Mask");
112 const float2 size = this->get_size();
113 if (math::is_any_zero(size)) {
114 output_mask.share_data(input_mask);
115 return;
116 }
117
118 if (this->context().use_gpu()) {
119 this->execute_gpu();
120 }
121 else {
122 this->execute_cpu();
123 }
124 }
125
127 {
128 gpu::Shader *shader = context().get_shader(get_shader_name());
130
131 const Domain domain = compute_domain();
132
133 GPU_shader_uniform_2iv(shader, "display_size", domain.display_size);
134 GPU_shader_uniform_2iv(shader, "data_offset", domain.data_offset);
135
137 GPU_shader_uniform_2fv(shader, "radius", get_size() / 2.0f);
138 GPU_shader_uniform_1f(shader, "cos_angle", std::cos(get_angle()));
139 GPU_shader_uniform_1f(shader, "sin_angle", std::sin(get_angle()));
140
141 const Result &input_mask = get_input("Mask");
142 gpu::Texture *base_mask_texture = input_mask.bind_as_texture_or_single_value(shader,
143 "base_mask_tx");
144
145 const Result &value = get_input("Value");
146 gpu::Texture *value_mask_texture = value.bind_as_texture_or_single_value(shader,
147 "mask_value_tx");
148
149 Result &output_mask = get_result("Mask");
150 output_mask.allocate_texture(domain);
151 output_mask.bind_as_image(shader, "output_mask_img");
152
154
155 input_mask.unbind_as_texture_or_single_value(base_mask_texture);
156 value.unbind_as_texture_or_single_value(value_mask_texture);
157 output_mask.unbind_as_image();
159 }
160
161 const char *get_shader_name()
162 {
163 switch (this->get_operation()) {
165 return "compositor_ellipse_mask_add";
167 return "compositor_ellipse_mask_subtract";
169 return "compositor_ellipse_mask_multiply";
171 return "compositor_ellipse_mask_not";
172 }
173
174 return "compositor_ellipse_mask_add";
175 }
176
178 {
179 const Result &base_mask = this->get_input("Mask");
180 const Result &value_mask = this->get_input("Value");
181
182 Result &output_mask = this->get_result("Mask");
183 const Domain domain = this->compute_domain();
184 output_mask.allocate_texture(domain);
185
186 const float2 location = this->get_location();
187 const float2 radius = this->get_size() / 2.0f;
188 const float cos_angle = math::cos(this->get_angle());
189 const float sin_angle = math::sin(this->get_angle());
190
191 switch (this->get_operation()) {
194 base_mask, value_mask, output_mask, domain, location, radius, cos_angle, sin_angle);
195 return;
198 base_mask, value_mask, output_mask, domain, location, radius, cos_angle, sin_angle);
199 return;
202 base_mask, value_mask, output_mask, domain, location, radius, cos_angle, sin_angle);
203 return;
206 base_mask, value_mask, output_mask, domain, location, radius, cos_angle, sin_angle);
207 return;
208 }
209
211 base_mask, value_mask, output_mask, domain, location, radius, cos_angle, sin_angle);
212 }
213
215 {
216 if (get_input("Mask").is_single_value()) {
217 return context().get_compositing_domain();
218 }
219 return get_input("Mask").domain();
220 }
221
223 {
224 return this->get_input("Position").get_single_value_default<float2>();
225 }
226
228 {
229 return math::max(float2(0.0f), this->get_input("Size").get_single_value_default<float2>());
230 }
231
232 float get_angle()
233 {
234 return this->get_input("Rotation").get_single_value_default<float>();
235 }
236
238 {
239 return CMPNodeMaskType(
240 this->get_input("Operation").get_single_value_default<MenuValue>().value);
241 }
242};
243
245{
246 return new EllipseMaskOperation(context, node);
247}
248
249static void node_register()
250{
251 static bke::bNodeType ntype;
252
253 cmp_node_type_base(&ntype, "CompositorNodeEllipseMask"_ustr, CMP_NODE_MASK_ELLIPSE);
254 ntype.ui_name = "Ellipse Mask";
255 ntype.ui_description =
256 "Create elliptical mask suitable for use as a simple matte or vignette mask";
257 ntype.enum_name_legacy = "ELLIPSEMASK";
258 ntype.nclass = NODE_CLASS_MATTE;
259 ntype.declare = node_declare;
261
263}
264NOD_REGISTER_NODE(node_register)
265
266} // namespace blender::nodes::node_composite_ellipse_mask_cc
#define NODE_CLASS_MATTE
Definition BKE_node.hh:485
#define CMP_NODE_MASK_ELLIPSE
#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 share_data(const Result &source)
Definition result.cc:996
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)
bool is_any_zero(const T &a)
T sin(const AngleRadianBase< T > &a)
T max(const T &a, const T &b)
static void ellipse_mask(const Result &base_mask, const Result &value_mask, Result &output_mask, const Domain &domain, const float2 &location, const float2 &radius, const float cos_angle, const float sin_angle)
static NodeOperation * get_compositor_operation(Context &context, const bNode &node)
static void node_declare(NodeDeclarationBuilder &b)
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)