Blender V4.3
kernel/svm/attribute.h
Go to the documentation of this file.
1/* SPDX-FileCopyrightText: 2011-2022 Blender Foundation
2 *
3 * SPDX-License-Identifier: Apache-2.0 */
4
5#pragma once
6
7CCL_NAMESPACE_BEGIN
8
9/* Attribute Node */
10
11ccl_device AttributeDescriptor svm_node_attr_init(KernelGlobals kg,
12 ccl_private ShaderData *sd,
13 uint4 node,
14 ccl_private NodeAttributeOutputType *type,
15 ccl_private uint *out_offset)
16{
17 *out_offset = node.z;
18 *type = (NodeAttributeOutputType)node.w;
19
20 AttributeDescriptor desc;
21
22 if (sd->object != OBJECT_NONE) {
23 desc = find_attribute(kg, sd, node.y);
24 if (desc.offset == ATTR_STD_NOT_FOUND) {
25 desc = attribute_not_found();
26 desc.offset = 0;
27 desc.type = (NodeAttributeType)node.w;
28 }
29 }
30 else {
31 /* background */
32 desc = attribute_not_found();
33 desc.offset = 0;
34 desc.type = (NodeAttributeType)node.w;
35 }
36
37 return desc;
38}
39
40template<uint node_feature_mask>
41ccl_device_noinline void svm_node_attr(KernelGlobals kg,
42 ccl_private ShaderData *sd,
43 ccl_private float *stack,
44 uint4 node)
45{
46 NodeAttributeOutputType type = NODE_ATTR_OUTPUT_FLOAT;
47 uint out_offset = 0;
48 AttributeDescriptor desc = svm_node_attr_init(kg, sd, node, &type, &out_offset);
49
50#ifdef __VOLUME__
51 IF_KERNEL_NODES_FEATURE(VOLUME)
52 {
53 /* Volumes
54 * NOTE: moving this into its own node type might help improve performance. */
55 if (primitive_is_volume_attribute(sd, desc)) {
56 const float4 value = volume_attribute_float4(kg, sd, desc);
57
58 if (type == NODE_ATTR_OUTPUT_FLOAT) {
59 const float f = volume_attribute_value_to_float(value);
60 stack_store_float(stack, out_offset, f);
61 }
62 else if (type == NODE_ATTR_OUTPUT_FLOAT3) {
63 const float3 f = volume_attribute_value_to_float3(value);
64 stack_store_float3(stack, out_offset, f);
65 }
66 else {
67 const float f = volume_attribute_value_to_alpha(value);
68 stack_store_float(stack, out_offset, f);
69 }
70 return;
71 }
72 }
73#endif
74
75 if (sd->type == PRIMITIVE_LAMP && node.y == ATTR_STD_UV) {
76 stack_store_float3(stack, out_offset, make_float3(1.0f - sd->u - sd->v, sd->u, 0.0f));
77 return;
78 }
79
80 if (node.y == ATTR_STD_GENERATED && desc.element == ATTR_ELEMENT_NONE) {
81 /* No generated attribute, fall back to object coordinates. */
82 float3 f = sd->P;
83 if (sd->object != OBJECT_NONE) {
84 object_inverse_position_transform(kg, sd, &f);
85 }
86 if (type == NODE_ATTR_OUTPUT_FLOAT) {
87 stack_store_float(stack, out_offset, average(f));
88 }
89 else if (type == NODE_ATTR_OUTPUT_FLOAT3) {
90 stack_store_float3(stack, out_offset, f);
91 }
92 else {
93 stack_store_float(stack, out_offset, 1.0f);
94 }
95 return;
96 }
97
98 /* Surface. */
99 if (desc.type == NODE_ATTR_FLOAT) {
100 float f = primitive_surface_attribute_float(kg, sd, desc, NULL, NULL);
101 if (type == NODE_ATTR_OUTPUT_FLOAT) {
102 stack_store_float(stack, out_offset, f);
103 }
104 else if (type == NODE_ATTR_OUTPUT_FLOAT3) {
105 stack_store_float3(stack, out_offset, make_float3(f, f, f));
106 }
107 else {
108 stack_store_float(stack, out_offset, 1.0f);
109 }
110 }
111 else if (desc.type == NODE_ATTR_FLOAT2) {
112 float2 f = primitive_surface_attribute_float2(kg, sd, desc, NULL, NULL);
113 if (type == NODE_ATTR_OUTPUT_FLOAT) {
114 stack_store_float(stack, out_offset, f.x);
115 }
116 else if (type == NODE_ATTR_OUTPUT_FLOAT3) {
117 stack_store_float3(stack, out_offset, make_float3(f.x, f.y, 0.0f));
118 }
119 else {
120 stack_store_float(stack, out_offset, 1.0f);
121 }
122 }
123 else if (desc.type == NODE_ATTR_FLOAT4 || desc.type == NODE_ATTR_RGBA) {
124 float4 f = primitive_surface_attribute_float4(kg, sd, desc, NULL, NULL);
125 if (type == NODE_ATTR_OUTPUT_FLOAT) {
126 stack_store_float(stack, out_offset, average(float4_to_float3(f)));
127 }
128 else if (type == NODE_ATTR_OUTPUT_FLOAT3) {
129 stack_store_float3(stack, out_offset, float4_to_float3(f));
130 }
131 else {
132 stack_store_float(stack, out_offset, f.w);
133 }
134 }
135 else {
136 float3 f = primitive_surface_attribute_float3(kg, sd, desc, NULL, NULL);
137 if (type == NODE_ATTR_OUTPUT_FLOAT) {
138 stack_store_float(stack, out_offset, average(f));
139 }
140 else if (type == NODE_ATTR_OUTPUT_FLOAT3) {
141 stack_store_float3(stack, out_offset, f);
142 }
143 else {
144 stack_store_float(stack, out_offset, 1.0f);
145 }
146 }
147}
148
153
158
159ccl_device_noinline void svm_node_attr_bump_dx(KernelGlobals kg,
160 ccl_private ShaderData *sd,
161 ccl_private float *stack,
162 uint4 node)
163{
164 NodeAttributeOutputType type = NODE_ATTR_OUTPUT_FLOAT;
165 uint out_offset = 0;
166 AttributeDescriptor desc = svm_node_attr_init(kg, sd, node, &type, &out_offset);
167
168#ifdef __VOLUME__
169 /* Volume */
170 if (primitive_is_volume_attribute(sd, desc)) {
171 if (type == NODE_ATTR_OUTPUT_FLOAT) {
172 stack_store_float(stack, out_offset, 0.0f);
173 }
174 else if (type == NODE_ATTR_OUTPUT_FLOAT3) {
175 stack_store_float3(stack, out_offset, make_float3(0.0f, 0.0f, 0.0f));
176 }
177 else {
178 stack_store_float(stack, out_offset, 1.0f);
179 }
180 return;
181 }
182#endif
183
184 if (node.y == ATTR_STD_GENERATED && desc.element == ATTR_ELEMENT_NONE) {
185 /* No generated attribute, fall back to object coordinates. */
186 float3 f = svm_node_bump_P_dx(sd);
187 if (sd->object != OBJECT_NONE) {
188 object_inverse_position_transform(kg, sd, &f);
189 }
190 if (type == NODE_ATTR_OUTPUT_FLOAT) {
191 stack_store_float(stack, out_offset, average(f));
192 }
193 else if (type == NODE_ATTR_OUTPUT_FLOAT3) {
194 stack_store_float3(stack, out_offset, f);
195 }
196 else {
197 stack_store_float(stack, out_offset, 1.0f);
198 }
199 return;
200 }
201
202 /* Surface */
203 if (desc.type == NODE_ATTR_FLOAT) {
204 float dx;
205 float f = primitive_surface_attribute_float(kg, sd, desc, &dx, NULL);
206 if (type == NODE_ATTR_OUTPUT_FLOAT) {
207 stack_store_float(stack, out_offset, f + dx);
208 }
209 else if (type == NODE_ATTR_OUTPUT_FLOAT3) {
210 stack_store_float3(stack, out_offset, make_float3(f + dx, f + dx, f + dx));
211 }
212 else {
213 stack_store_float(stack, out_offset, 1.0f);
214 }
215 }
216 else if (desc.type == NODE_ATTR_FLOAT2) {
217 float2 dx;
218 float2 f = primitive_surface_attribute_float2(kg, sd, desc, &dx, NULL);
219 if (type == NODE_ATTR_OUTPUT_FLOAT) {
220 stack_store_float(stack, out_offset, f.x + dx.x);
221 }
222 else if (type == NODE_ATTR_OUTPUT_FLOAT3) {
223 stack_store_float3(stack, out_offset, make_float3(f.x + dx.x, f.y + dx.y, 0.0f));
224 }
225 else {
226 stack_store_float(stack, out_offset, 1.0f);
227 }
228 }
229 else if (desc.type == NODE_ATTR_FLOAT4 || desc.type == NODE_ATTR_RGBA) {
230 float4 dx;
231 float4 f = primitive_surface_attribute_float4(kg, sd, desc, &dx, NULL);
232 if (type == NODE_ATTR_OUTPUT_FLOAT) {
233 stack_store_float(stack, out_offset, average(float4_to_float3(f + dx)));
234 }
235 else if (type == NODE_ATTR_OUTPUT_FLOAT3) {
236 stack_store_float3(stack, out_offset, float4_to_float3(f + dx));
237 }
238 else {
239 stack_store_float(stack, out_offset, f.w + dx.w);
240 }
241 }
242 else {
243 float3 dx;
244 float3 f = primitive_surface_attribute_float3(kg, sd, desc, &dx, NULL);
245 if (type == NODE_ATTR_OUTPUT_FLOAT) {
246 stack_store_float(stack, out_offset, average(f + dx));
247 }
248 else if (type == NODE_ATTR_OUTPUT_FLOAT3) {
249 stack_store_float3(stack, out_offset, f + dx);
250 }
251 else {
252 stack_store_float(stack, out_offset, 1.0f);
253 }
254 }
255}
256
257ccl_device_noinline void svm_node_attr_bump_dy(KernelGlobals kg,
258 ccl_private ShaderData *sd,
259 ccl_private float *stack,
260 uint4 node)
261{
262 NodeAttributeOutputType type = NODE_ATTR_OUTPUT_FLOAT;
263 uint out_offset = 0;
264 AttributeDescriptor desc = svm_node_attr_init(kg, sd, node, &type, &out_offset);
265
266#ifdef __VOLUME__
267 /* Volume */
268 if (primitive_is_volume_attribute(sd, desc)) {
269 if (type == NODE_ATTR_OUTPUT_FLOAT) {
270 stack_store_float(stack, out_offset, 0.0f);
271 }
272 else if (type == NODE_ATTR_OUTPUT_FLOAT3) {
273 stack_store_float3(stack, out_offset, make_float3(0.0f, 0.0f, 0.0f));
274 }
275 else {
276 stack_store_float(stack, out_offset, 1.0f);
277 }
278 return;
279 }
280#endif
281
282 if (node.y == ATTR_STD_GENERATED && desc.element == ATTR_ELEMENT_NONE) {
283 /* No generated attribute, fall back to object coordinates. */
284 float3 f = svm_node_bump_P_dy(sd);
285 if (sd->object != OBJECT_NONE) {
286 object_inverse_position_transform(kg, sd, &f);
287 }
288 if (type == NODE_ATTR_OUTPUT_FLOAT) {
289 stack_store_float(stack, out_offset, average(f));
290 }
291 else if (type == NODE_ATTR_OUTPUT_FLOAT3) {
292 stack_store_float3(stack, out_offset, f);
293 }
294 else {
295 stack_store_float(stack, out_offset, 1.0f);
296 }
297 return;
298 }
299
300 /* Surface */
301 if (desc.type == NODE_ATTR_FLOAT) {
302 float dy;
303 float f = primitive_surface_attribute_float(kg, sd, desc, NULL, &dy);
304 if (type == NODE_ATTR_OUTPUT_FLOAT) {
305 stack_store_float(stack, out_offset, f + dy);
306 }
307 else if (type == NODE_ATTR_OUTPUT_FLOAT3) {
308 stack_store_float3(stack, out_offset, make_float3(f + dy, f + dy, f + dy));
309 }
310 else {
311 stack_store_float(stack, out_offset, 1.0f);
312 }
313 }
314 else if (desc.type == NODE_ATTR_FLOAT2) {
315 float2 dy;
316 float2 f = primitive_surface_attribute_float2(kg, sd, desc, NULL, &dy);
317 if (type == NODE_ATTR_OUTPUT_FLOAT) {
318 stack_store_float(stack, out_offset, f.x + dy.x);
319 }
320 else if (type == NODE_ATTR_OUTPUT_FLOAT3) {
321 stack_store_float3(stack, out_offset, make_float3(f.x + dy.x, f.y + dy.y, 0.0f));
322 }
323 else {
324 stack_store_float(stack, out_offset, 1.0f);
325 }
326 }
327 else if (desc.type == NODE_ATTR_FLOAT4 || desc.type == NODE_ATTR_RGBA) {
328 float4 dy;
329 float4 f = primitive_surface_attribute_float4(kg, sd, desc, NULL, &dy);
330 if (type == NODE_ATTR_OUTPUT_FLOAT) {
331 stack_store_float(stack, out_offset, average(float4_to_float3(f + dy)));
332 }
333 else if (type == NODE_ATTR_OUTPUT_FLOAT3) {
334 stack_store_float3(stack, out_offset, float4_to_float3(f + dy));
335 }
336 else {
337 stack_store_float(stack, out_offset, f.w + dy.w);
338 }
339 }
340 else {
341 float3 dy;
342 float3 f = primitive_surface_attribute_float3(kg, sd, desc, NULL, &dy);
343 if (type == NODE_ATTR_OUTPUT_FLOAT) {
344 stack_store_float(stack, out_offset, average(f + dy));
345 }
346 else if (type == NODE_ATTR_OUTPUT_FLOAT3) {
347 stack_store_float3(stack, out_offset, f + dy);
348 }
349 else {
350 stack_store_float(stack, out_offset, 1.0f);
351 }
352 }
353}
354
355CCL_NAMESPACE_END
uint
unsigned int uint
Definition BLI_sys_types.h:68
KernelGlobals
const KernelGlobalsCPU *ccl_restrict KernelGlobals
Definition device/cpu/globals.h:71
ccl_device_forceinline
#define ccl_device_forceinline
Definition device/cuda/compat.h:37
ccl_device
#define ccl_device
Definition device/cuda/compat.h:33
ccl_private
#define ccl_private
Definition device/cuda/compat.h:51
ccl_device_noinline
#define ccl_device_noinline
Definition device/cuda/compat.h:42
CCL_NAMESPACE_END
#define CCL_NAMESPACE_END
Definition device/cuda/compat.h:10
make_float3
ccl_device_forceinline float3 make_float3(const float x, const float y, const float z)
Definition device/metal/compat.h:229
NULL
#define NULL
Definition device/metal/compat.h:315
differential_from_compact
ccl_device_forceinline differential3 differential_from_compact(const float3 D, const float dD)
Definition differential.h:139
attribute_not_found
ccl_device_inline AttributeDescriptor attribute_not_found()
Definition kernel/geom/attribute.h:35
object_inverse_position_transform
ccl_device_inline void object_inverse_position_transform(KernelGlobals kg, ccl_private const ShaderData *sd, ccl_private float3 *P)
Definition kernel/geom/object.h:151
svm_node_bump_P_dx
ccl_device_forceinline float3 svm_node_bump_P_dx(const ccl_private ShaderData *sd)
Definition kernel/svm/attribute.h:149
svm_node_attr_bump_dx
ccl_device_noinline void svm_node_attr_bump_dx(KernelGlobals kg, ccl_private ShaderData *sd, ccl_private float *stack, uint4 node)
Definition kernel/svm/attribute.h:159
svm_node_attr
ccl_device_noinline void svm_node_attr(KernelGlobals kg, ccl_private ShaderData *sd, ccl_private float *stack, uint4 node)
Definition kernel/svm/attribute.h:41
svm_node_bump_P_dy
ccl_device_forceinline float3 svm_node_bump_P_dy(const ccl_private ShaderData *sd)
Definition kernel/svm/attribute.h:154
svm_node_attr_init
CCL_NAMESPACE_BEGIN ccl_device AttributeDescriptor svm_node_attr_init(KernelGlobals kg, ccl_private ShaderData *sd, uint4 node, ccl_private NodeAttributeOutputType *type, ccl_private uint *out_offset)
Definition kernel/svm/attribute.h:11
svm_node_attr_bump_dy
ccl_device_noinline void svm_node_attr_bump_dy(KernelGlobals kg, ccl_private ShaderData *sd, ccl_private float *stack, uint4 node)
Definition kernel/svm/attribute.h:257
stack_store_float3
ccl_device_inline void stack_store_float3(ccl_private float *stack, uint a, float3 f)
Definition kernel/svm/svm.h:42
stack_store_float
ccl_device_inline void stack_store_float(ccl_private float *stack, uint a, float f)
Definition kernel/svm/svm.h:64
NodeAttributeOutputType
NodeAttributeOutputType
Definition kernel/svm/types.h:26
NODE_ATTR_OUTPUT_FLOAT
@ NODE_ATTR_OUTPUT_FLOAT
Definition kernel/svm/types.h:28
NODE_ATTR_OUTPUT_FLOAT3
@ NODE_ATTR_OUTPUT_FLOAT3
Definition kernel/svm/types.h:27
NodeAttributeType
NodeAttributeType
Definition kernel/svm/types.h:32
NODE_ATTR_FLOAT
@ NODE_ATTR_FLOAT
Definition kernel/svm/types.h:33
NODE_ATTR_RGBA
@ NODE_ATTR_RGBA
Definition kernel/svm/types.h:37
NODE_ATTR_FLOAT2
@ NODE_ATTR_FLOAT2
Definition kernel/svm/types.h:34
NODE_ATTR_FLOAT4
@ NODE_ATTR_FLOAT4
Definition kernel/svm/types.h:36
PRIMITIVE_LAMP
@ PRIMITIVE_LAMP
Definition kernel/types.h:819
ATTR_STD_UV
@ ATTR_STD_UV
Definition kernel/types.h:880
ATTR_STD_NOT_FOUND
@ ATTR_STD_NOT_FOUND
Definition kernel/types.h:911
ATTR_STD_GENERATED
@ ATTR_STD_GENERATED
Definition kernel/types.h:884
IF_KERNEL_NODES_FEATURE
#define IF_KERNEL_NODES_FEATURE(feature)
Definition kernel/types.h:163
OBJECT_NONE
#define OBJECT_NONE
Definition kernel/types.h:49
ShaderData
ShaderData
Definition kernel/types.h:1210
ATTR_ELEMENT_NONE
@ ATTR_ELEMENT_NONE
Definition kernel/types.h:862
average
ccl_device_inline float average(const float2 a)
Definition math_float2.h:128
CCL_NAMESPACE_BEGIN
Definition python.cpp:44
primitive_surface_attribute_float3
ccl_device_forceinline float3 primitive_surface_attribute_float3(KernelGlobals kg, ccl_private const ShaderData *sd, const AttributeDescriptor desc, ccl_private float3 *dx, ccl_private float3 *dy)
Definition primitive.h:84
primitive_surface_attribute_float2
ccl_device_forceinline float2 primitive_surface_attribute_float2(KernelGlobals kg, ccl_private const ShaderData *sd, const AttributeDescriptor desc, ccl_private float2 *dx, ccl_private float2 *dy)
Definition primitive.h:53
primitive_surface_attribute_float4
ccl_device_forceinline float4 primitive_surface_attribute_float4(KernelGlobals kg, ccl_private const ShaderData *sd, const AttributeDescriptor desc, ccl_private float4 *dx, ccl_private float4 *dy)
Definition primitive.h:115
primitive_surface_attribute_float
CCL_NAMESPACE_BEGIN ccl_device_forceinline float primitive_surface_attribute_float(KernelGlobals kg, ccl_private const ShaderData *sd, const AttributeDescriptor desc, ccl_private float *dx, ccl_private float *dy)
Definition primitive.h:22
find_attribute
static bool find_attribute(const std::string &attributes, const char *search_attribute)
Definition storage_apple.mm:71
AttributeDescriptor::element
AttributeElement element
Definition kernel/types.h:920
AttributeDescriptor::type
NodeAttributeType type
Definition kernel/types.h:921
float2::x
float x
Definition types_float2.h:15
float2::y
float y
Definition types_float2.h:15
float4_to_float3
ccl_device_inline float3 float4_to_float3(const float4 a)
Definition util/math.h:535
Generated on Thu Feb 6 2025 07:36:39 for Blender by  doxygen 1.11.0