Blender V5.3
node_composite_id_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"
9
10#include "GPU_shader.hh"
11
12#include "COM_algorithm_smaa.hh"
13#include "COM_node_operation.hh"
14#include "COM_utilities.hh"
15
17
19
21{
22 b.add_input<decl::Float>("ID value"_ustr)
23 .default_value(1.0f)
24 .min(0.0f)
25 .max(1.0f)
26 .structure_type(StructureType::Dynamic);
27 b.add_input<decl::Int>("Index"_ustr).default_value(0).min(0);
28 b.add_input<decl::Bool>("Anti-Alias"_ustr).default_value(false);
29
30 b.add_output<decl::Float>("Alpha"_ustr).structure_type(StructureType::Dynamic);
31}
32
33using namespace blender::compositor;
34
36 public:
38
39 void execute() override
40 {
41 const Result &input_mask = get_input("ID value");
42 if (input_mask.is_single_value()) {
44 return;
45 }
46
47 /* If anti-aliasing is disabled, write to the output directly, otherwise, write to a temporary
48 * result to later perform anti-aliasing. */
49 Result non_anti_aliased_mask = context().create_result(ResultType::Float);
50 Result &output_mask = use_anti_aliasing() ? non_anti_aliased_mask : get_result("Alpha");
51
52 if (this->context().use_gpu()) {
53 this->execute_gpu(output_mask);
54 }
55 else {
56 this->execute_cpu(output_mask);
57 }
58
59 if (this->use_anti_aliasing()) {
60 smaa(context(), non_anti_aliased_mask, get_result("Alpha"));
61 non_anti_aliased_mask.release();
62 }
63 }
64
65 void execute_gpu(Result &output_mask)
66 {
67 gpu::Shader *shader = context().get_shader("compositor_id_mask");
69
71
72 const Result &input_mask = get_input("ID value");
73 input_mask.bind_as_texture(shader, "input_mask_tx");
74
75 const Domain domain = compute_domain();
76 output_mask.allocate_texture(domain);
77 output_mask.bind_as_image(shader, "output_mask_img");
78
80
81 input_mask.unbind_as_texture();
82 output_mask.unbind_as_image();
84 }
85
86 void execute_cpu(Result &output_mask)
87 {
88 const int index = this->get_index();
89
90 const Result &input_mask = get_input("ID value");
91
92 const Domain domain = compute_domain();
93 output_mask.allocate_texture(domain);
94
95 parallel_for(domain.data_size, [&](const int2 texel) {
96 float input_mask_value = input_mask.load_pixel<float>(texel);
97 float mask = int(math::round(input_mask_value)) == index ? 1.0f : 0.0f;
98 output_mask.store_pixel(texel, mask);
99 });
100 }
101
103 {
104 const float input_mask_value = get_input("ID value").get_single_value<float>();
105 const float mask = int(round(input_mask_value)) == get_index() ? 1.0f : 0.0f;
108 }
109
111 {
112 return math::max(0, this->get_input("Index").get_single_value_default<int>());
113 }
114
116 {
117 return this->get_input("Anti-Alias").get_single_value_default<bool>();
118 }
119};
120
122{
123 return new IDMaskOperation(context, node);
124}
125
126static void node_register()
127{
128 static bke::bNodeType ntype;
129
130 cmp_node_type_base(&ntype, "CompositorNodeIDMask"_ustr, CMP_NODE_ID_MASK);
131 ntype.ui_name = "ID Mask";
132 ntype.ui_description = "Create a matte from an object or material index pass";
133 ntype.enum_name_legacy = "ID_MASK";
135 ntype.declare = node_declare;
137
139}
141
142} // namespace blender::nodes::node_composite_id_mask_cc
#define NODE_CLASS_CONVERTER
Definition BKE_node.hh:484
#define CMP_NODE_ID_MASK
#define NOD_REGISTER_NODE(REGISTER_FUNC)
Result create_result(ResultType type, ResultPrecision precision)
gpu::Shader * get_shader(const char *info_name, ResultPrecision precision)
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
virtual Domain compute_domain()
Definition operation.cc:62
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_texture() const
Definition result.cc:964
void set_single_value(const T &value)
void bind_as_texture(gpu::Shader *shader, const char *texture_name) const
Definition result.cc:854
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
const T & get_single_value() const
#define round
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 smaa(Context &context, const Result &input, Result &output, const float threshold=0.1f, const float local_contrast_adaptation_factor=2.0f, const int corner_rounding=25)
Definition smaa.cc:1693
void parallel_for(const int2 range, const Function &function)
T max(const T &a, const T &b)
static void node_declare(NodeDeclarationBuilder &b)
static NodeOperation * get_compositor_operation(Context &context, const bNode &node)
void GPU_shader_unbind()
void GPU_shader_bind(gpu::Shader *shader, const gpu::shader::SpecializationConstants *constants_state=nullptr)
void GPU_shader_uniform_1i(gpu::Shader *sh, const char *name, int value)
void cmp_node_type_base(bke::bNodeType *ntype, UString idname, const std::optional< int16_t > legacy_type)
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