Blender V5.3
node_shader_sepcomb_xyz.cc
Go to the documentation of this file.
1/* SPDX-FileCopyrightText: 2014 Blender Authors
2 *
3 * SPDX-License-Identifier: GPL-2.0-or-later */
4
8
9#include "node_shader_util.hh"
10
12
14#include "NOD_multi_function.hh"
16
17namespace blender {
18
20
22{
23 b.is_function_node();
24 b.add_input<decl::Vector>("Vector"_ustr).min(-10000.0f).max(10000.0f);
25 b.add_output<decl::Float>("X"_ustr);
26 b.add_output<decl::Float>("Y"_ustr);
27 b.add_output<decl::Float>("Z"_ustr);
28}
29
31 bNode *node,
32 bNodeExecData * /*execdata*/,
35{
36 return GPU_stack_link(mat, node, "separate_xyz", in, out);
37}
38
39class MF_SeparateXYZ : public mf::MultiFunction {
40 public:
42 {
43 static const mf::Signature signature = []() {
44 mf::Signature signature;
45 mf::SignatureBuilder builder{"Separate XYZ", signature};
46 builder.single_input<float3>("XYZ");
47 builder.single_output<float>("X", mf::ParamFlag::SupportsUnusedOutput);
48 builder.single_output<float>("Y", mf::ParamFlag::SupportsUnusedOutput);
49 builder.single_output<float>("Z", mf::ParamFlag::SupportsUnusedOutput);
50 return signature;
51 }();
53 }
54
55 void call(const IndexMask &mask, mf::Params params, mf::Context /*context*/) const override
56 {
57 const VArray<float3> &vectors = params.readonly_single_input<float3>(0, "XYZ");
58 MutableSpan<float> xs = params.uninitialized_single_output_if_required<float>(1, "X");
59 MutableSpan<float> ys = params.uninitialized_single_output_if_required<float>(2, "Y");
60 MutableSpan<float> zs = params.uninitialized_single_output_if_required<float>(3, "Z");
61
62 std::array<MutableSpan<float>, 3> outputs = {xs, ys, zs};
63 Vector<int> used_outputs;
64 if (!xs.is_empty()) {
65 used_outputs.append(0);
66 }
67 if (!ys.is_empty()) {
68 used_outputs.append(1);
69 }
70 if (!zs.is_empty()) {
71 used_outputs.append(2);
72 }
73
74 devirtualize_varray(vectors, [&](auto vectors) {
75 mask.foreach_segment_optimized([&](const auto segment) {
76 const int used_outputs_num = used_outputs.size();
77 const int *used_outputs_data = used_outputs.data();
78
79 for (const int64_t i : segment) {
80 const float3 &vector = vectors[i];
81 for (const int out_i : IndexRange(used_outputs_num)) {
82 const int coordinate = used_outputs_data[out_i];
83 outputs[coordinate][i] = vector[coordinate];
84 }
85 }
86 });
87 });
88 }
89};
90
92{
93 static MF_SeparateXYZ separate_fn;
94 builder.set_matching_fn(separate_fn);
95}
96
98{
99 using namespace value_elem;
100 const VectorElem vector_elem = params.get_input_elem<VectorElem>("Vector"_ustr);
101 params.set_output_elem("X"_ustr, vector_elem.x);
102 params.set_output_elem("Y"_ustr, vector_elem.y);
103 params.set_output_elem("Z"_ustr, vector_elem.z);
104}
105
107{
108 using namespace value_elem;
110 result.x = params.get_output_elem<FloatElem>("X"_ustr);
111 result.y = params.get_output_elem<FloatElem>("Y"_ustr);
112 result.z = params.get_output_elem<FloatElem>("Z"_ustr);
113 params.set_input_elem("Vector"_ustr, result);
114}
115
117{
118 params.set_input("Vector"_ustr,
119 float3(params.get_output<float>("X"_ustr),
120 params.get_output<float>("Y"_ustr),
121 params.get_output<float>("Z"_ustr)));
122}
123
125#ifdef WITH_MATERIALX
126{
127 NodeItem vector = get_input_value("Vector", NodeItem::Type::Vector3);
128 int index = STREQ(socket_out_->identifier, "X") ? 0 :
129 STREQ(socket_out_->identifier, "Y") ? 1 :
130 2;
131 return vector[index];
132}
133#endif
135
136} // namespace nodes::node_shader_sepcomb_xyz_cc::sep
137
139{
140 namespace file_ns = nodes::node_shader_sepcomb_xyz_cc::sep;
141
142 static bke::bNodeType ntype;
143
144 common_node_type_base(&ntype, "ShaderNodeSeparateXYZ"_ustr, SH_NODE_SEPXYZ);
145 ntype.ui_name = "Separate XYZ";
146 ntype.ui_description = "Split a vector into its X, Y, and Z components";
147 ntype.enum_name_legacy = "SEPXYZ";
149 ntype.declare = file_ns::sh_node_sepxyz_declare;
150 ntype.gpu_fn = file_ns::gpu_shader_sepxyz;
151 ntype.build_multi_function = file_ns::sh_node_sepxyz_build_multi_function;
152 ntype.materialx_fn = file_ns::node_shader_materialx;
153 ntype.eval_elem = file_ns::sh_node_sepxyz_eval_elem;
154 ntype.eval_inverse_elem = file_ns::sh_node_sepxyz_eval_inverse_elem;
155 ntype.eval_inverse = file_ns::sh_node_sepxyz_eval_inverse;
156
158}
159
161
163{
164 b.is_function_node();
165 b.add_input<decl::Float>("X"_ustr).min(-10000.0f).max(10000.0f);
166 b.add_input<decl::Float>("Y"_ustr).min(-10000.0f).max(10000.0f);
167 b.add_input<decl::Float>("Z"_ustr).min(-10000.0f).max(10000.0f);
168 b.add_output<decl::Vector>("Vector"_ustr);
169}
170
172 bNode *node,
173 bNodeExecData * /*execdata*/,
176{
177 return GPU_stack_link(mat, node, "combine_xyz", in, out);
178}
179
181{
182 static auto fn = mf::build::SI3_SO<float, float, float, float3>(
183 "Combine Vector",
184 [](float x, float y, float z) { return float3(x, y, z); },
185 mf::build::exec_presets::AllSpanOrSingle());
186 builder.set_matching_fn(fn);
187}
188
190{
191 using namespace value_elem;
192 VectorElem vector_elem;
193 vector_elem.x = params.get_input_elem<FloatElem>("X"_ustr);
194 vector_elem.y = params.get_input_elem<FloatElem>("Y"_ustr);
195 vector_elem.z = params.get_input_elem<FloatElem>("Z"_ustr);
196 params.set_output_elem("Vector"_ustr, vector_elem);
197}
198
200{
201 using namespace value_elem;
202 const VectorElem output_elem = params.get_output_elem<VectorElem>("Vector"_ustr);
203 params.set_input_elem("X"_ustr, output_elem.x);
204 params.set_input_elem("Y"_ustr, output_elem.y);
205 params.set_input_elem("Z"_ustr, output_elem.z);
206}
207
209{
210 const float3 output = params.get_output<float3>("Vector"_ustr);
211 params.set_input("X"_ustr, output.x);
212 params.set_input("Y"_ustr, output.y);
213 params.set_input("Z"_ustr, output.z);
214}
215
217#ifdef WITH_MATERIALX
218{
219 NodeItem x = get_input_value("X", NodeItem::Type::Float);
220 NodeItem y = get_input_value("Y", NodeItem::Type::Float);
221 NodeItem z = get_input_value("Z", NodeItem::Type::Float);
222
223 return create_node("combine3", NodeItem::Type::Vector3, {{"in1", x}, {"in2", y}, {"in3", z}});
224}
225#endif
227
228} // namespace nodes::node_shader_sepcomb_xyz_cc::comb
229
231{
232 namespace file_ns = nodes::node_shader_sepcomb_xyz_cc::comb;
233
234 static bke::bNodeType ntype;
235
236 common_node_type_base(&ntype, "ShaderNodeCombineXYZ"_ustr, SH_NODE_COMBXYZ);
237 ntype.ui_name = "Combine XYZ";
238 ntype.ui_description = "Create a vector from X, Y, and Z components";
239 ntype.enum_name_legacy = "COMBXYZ";
241 ntype.declare = file_ns::sh_node_combxyz_declare;
242 ntype.gpu_fn = file_ns::gpu_shader_combxyz;
243 ntype.build_multi_function = file_ns::sh_node_combxyz_build_multi_function;
244 ntype.materialx_fn = file_ns::node_shader_materialx;
245 ntype.eval_elem = file_ns::sh_node_combxyz_eval_elem;
246 ntype.eval_inverse_elem = file_ns::sh_node_combxyz_eval_inverse_elem;
247 ntype.eval_inverse = file_ns::sh_node_combxyz_eval_inverse;
248
250}
251
252} // namespace blender
#define NODE_CLASS_CONVERTER
Definition BKE_node.hh:484
#define SH_NODE_COMBXYZ
#define SH_NODE_SEPXYZ
#define STREQ(a, b)
#define output
SIMD_FORCE_INLINE const btScalar & z() const
Return the z value.
Definition btQuadWord.h:117
constexpr IndexRange()=default
int64_t size() const
void append(const T &value)
void set_signature(const Signature *signature)
void set_matching_fn(const mf::MultiFunction *fn)
void set_input(const UString identifier, T value)
void call(const IndexMask &mask, mf::Params params, mf::Context) const override
T get_input_elem(const UString identifier) const
void set_output_elem(const UString identifier, T elem)
void set_input_elem(const UString identifier, T elem)
void node_register_type(bNodeType &ntype)
Definition node.cc:2920
static int gpu_shader_combxyz(GPUMaterial *mat, bNode *node, bNodeExecData *, GPUNodeStack *in, GPUNodeStack *out)
static void sh_node_combxyz_eval_inverse_elem(value_elem::InverseElemEvalParams &params)
static void sh_node_combxyz_eval_elem(value_elem::ElemEvalParams &params)
static void sh_node_combxyz_eval_inverse(inverse_eval::InverseEvalParams &params)
static void sh_node_combxyz_build_multi_function(NodeMultiFunctionBuilder &builder)
static void sh_node_combxyz_declare(NodeDeclarationBuilder &b)
static void sh_node_sepxyz_build_multi_function(NodeMultiFunctionBuilder &builder)
static void sh_node_sepxyz_eval_inverse_elem(value_elem::InverseElemEvalParams &params)
static int gpu_shader_sepxyz(GPUMaterial *mat, bNode *node, bNodeExecData *, GPUNodeStack *in, GPUNodeStack *out)
static void sh_node_sepxyz_eval_elem(value_elem::ElemEvalParams &params)
static void sh_node_sepxyz_declare(NodeDeclarationBuilder &b)
static void sh_node_sepxyz_eval_inverse(inverse_eval::InverseEvalParams &params)
BMesh Iterators.
bool GPU_stack_link(GPUMaterial *mat, const bNode *node, const char *name, GPUNodeStack *in, GPUNodeStack *out,...)
__int64 int64_t
Definition BKE_text.h:90
void devirtualize_varray(const VArray< T > &varray, const Func &func, bool enable=true)
void register_node_type_sh_sepxyz()
void register_node_type_sh_combxyz()
VecBase< float, 3 > float3
void common_node_type_base(bke::bNodeType *ntype, UString idname, const std::optional< int16_t > legacy_type)
#define NODE_SHADER_MATERIALX_BEGIN
#define NODE_SHADER_MATERIALX_END
#define min(a, b)
Definition sort.cc:38
Defines a node type.
Definition BKE_node.hh:265
NodeInverseElemEvalFunction eval_inverse_elem
Definition BKE_node.hh:434
NodeMaterialXFunction materialx_fn
Definition BKE_node.hh:375
NodeInverseEvalFunction eval_inverse
Definition BKE_node.hh:441
std::string ui_description
Definition BKE_node.hh:271
NodeGPUExecFunction gpu_fn
Definition BKE_node.hh:373
NodeElemEvalFunction eval_elem
Definition BKE_node.hh:428
NodeMultiFunctionBuildFunction build_multi_function
Definition BKE_node.hh:382
const char * enum_name_legacy
Definition BKE_node.hh:274
NodeDeclareFunction declare
Definition BKE_node.hh:393