Blender V5.3
tex_coord.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
8
10#include "kernel/geom/object.h"
12
15#include "kernel/svm/types.h"
16#include "kernel/svm/util.h"
17#include "util/math_base.h"
18
20
21/* Smooth normal with screen-space derivatives for texture coordinate use.
22 * Returns the interpolated normal in object space, with dx/dy representing
23 * the per-pixel change from ray differentials. */
25{
26 if ((sd->type & PRIMITIVE_TRIANGLE) && (sd->shader & SHADER_SMOOTH_NORMAL)) {
27 float3 N_x, N_y;
28 float3 N;
29 if (sd->type == PRIMITIVE_TRIANGLE) {
31 sd->Ng,
32 sd->object,
33 sd->object_flag,
34 sd->prim,
35 sd->u,
36 sd->v,
37 sd->du,
38 sd->dv,
39 N_x,
40 N_y);
41 }
42 else {
44 kg, sd->Ng, sd->object, sd->prim, sd->time, sd->u, sd->v, sd->du, sd->dv, N_x, N_y);
45 }
46 if (sd->runtime_flag & SR_BACKFACING) {
47 N = -N;
48 N_x = -N_x;
49 N_y = -N_y;
50 }
51 if (sd->object_flag & SD_OBJECT_TRANSFORM_APPLIED) {
55 }
56 return dual3(N, N_x - N, N_y - N);
57 }
58
59 /* Flat normal or non-triangle: no derivative. */
60 float3 N = sd->N;
62 return dual3(N);
63}
64
65/* Texture Coordinate Node */
66
67template<typename Float3Type>
68ccl_device_inline Float3Type svm_texco_reflection(const ccl_private ShaderData *sd)
69{
70 Float3Type data = shading_incoming<Float3Type>(sd);
71 if (sd->object != OBJECT_NONE) {
72 data = -reflect(data, sd->N);
73 }
74 return data;
75}
76
77template<typename Float3Type>
79 const ccl_private ShaderData *sd,
80 const ccl_private Float3Type &P)
81{
82 Float3Type data(P);
83 const Transform tfm = kernel_data.cam.worldtocamera;
84 if (sd->object == OBJECT_NONE) {
85 data = data + camera_position(kg);
86 }
87 data = transform_point(&tfm, data);
88 return data;
89}
90
91template<typename Float3Type>
93 ccl_private ShaderData *sd,
94 const PathRayVisibility path_visibility,
95 const NodeTexCoord type,
96 ccl_private int *offset)
97{
98 Float3Type data;
99
100 switch (type) {
104 if (type == NODE_TEXCO_OBJECT) {
106 }
107 else {
109 data = transform_point(&tfm, data);
110 }
111 break;
112 }
113 case NODE_TEXCO_NORMAL: {
114 if constexpr (is_dual_v<Float3Type>) {
115 data = svm_texco_smooth_normal(kg, sd);
116 }
117 else {
118 data = sd->N;
119 object_inverse_normal_transform(kg, sd, &data);
120 }
121 break;
122 }
123 case NODE_TEXCO_CAMERA: {
124 const Float3Type P = shading_position<Float3Type>(sd);
125 data = svm_texco_camera<Float3Type>(kg, sd, P);
126 break;
127 }
128 case NODE_TEXCO_WINDOW: {
129 if ((path_visibility & PATH_RAY_VISIBILITY_CAMERA) && sd->object == OBJECT_NONE &&
131 {
132 data = Float3Type(camera_world_to_ndc(kg, sd, sd->ray_P));
133 }
134 else {
135 data = Float3Type(camera_world_to_ndc(kg, sd, sd->P));
136 if constexpr (is_dual_v<Float3Type>) {
137 data.dx.x = 1.0f / kernel_data.cam.width;
138 data.dy.y = 1.0f / kernel_data.cam.height;
139 }
140 }
141 if constexpr (is_dual_v<Float3Type>) {
142 data.val.z = 0.0f;
143 }
144 else {
145 data.z = 0.0f;
146 }
147 break;
148 }
151 break;
152 }
154 data = Float3Type(object_dupli_generated(kg, sd->object));
155 break;
156 }
157 case NODE_TEXCO_DUPLI_UV: {
158 data = Float3Type(object_dupli_uv(kg, sd->object));
159 break;
160 }
163
164#ifdef __VOLUME__
165 if (sd->object != OBJECT_NONE) {
166 data = volume_normalized_position<Float3Type>(kg, sd, data);
167 }
168#endif
169 break;
170 }
171 default:
172 data = make_zero<Float3Type>();
173 break;
174 }
175
176 return data;
177}
178
180 ccl_private ShaderData *sd,
181 const PathRayVisibility path_visibility,
182 ccl_private float *ccl_restrict stack,
184 int offset)
185{
187 kg, sd, path_visibility, node.texco_type, &offset);
188 stack_store(stack, node.out_offset, data);
189 return offset;
190}
191
193 int offset)
194{
195 if (node.texco_type == NODE_TEXCO_OBJECT_WITH_TRANSFORM) {
196 offset += sizeof(PackedTransform) / sizeof(uint);
197 }
198 return offset;
199}
200
202 KernelGlobals kg,
203 ccl_private ShaderData *sd,
204 const PathRayVisibility path_visibility,
205 ccl_private float *ccl_restrict stack,
207 int offset)
208{
209 dual3 data = svm_node_tex_coord_eval<dual3>(kg, sd, path_visibility, node.texco_type, &offset);
210 if (node.bump_offset == NODE_BUMP_OFFSET_DX) {
211 data.val += data.dx * node.bump_filter_width;
212 }
213 else if (node.bump_offset == NODE_BUMP_OFFSET_DY) {
214 data.val += data.dy * node.bump_filter_width;
215 }
216 /* Normal texture coordinate must be normalized after bump offset, matching OSL. */
217 if (node.texco_type == NODE_TEXCO_NORMAL) {
218 data = safe_normalize(data);
219 }
220 if (node.store_derivatives) {
221 stack_store(stack, node.out_offset, data);
222 }
223 else {
224 stack_store(stack, node.out_offset, data.val);
225 }
226 return offset;
227}
228
230 ccl_private ShaderData *sd,
231 ccl_private float *ccl_restrict stack,
233{
234 float3 color = stack_load(stack, node.color);
235 color = 2.0f * make_float3(color.x - 0.5f, color.y - 0.5f, color.z - 0.5f);
236
237 if (node.invert_green) {
238 color.y = -color.y;
239 }
240
241 const bool is_backfacing = (sd->runtime_flag & SR_BACKFACING) != 0;
242 float3 N;
243 float strength = stack_load(stack, node.strength);
244 bool linear_interpolate_strength = false;
245
246 if (node.space == NODE_NORMAL_MAP_TANGENT) {
247 /* tangent space */
248 if (sd->object == OBJECT_NONE || (sd->type & PRIMITIVE_TRIANGLE) == 0) {
249 /* Fall back to unperturbed normal. */
250 stack_store_float3(stack, node.normal_offset, sd->N);
251 return;
252 }
253
254 /* first try to get tangent attribute */
255 const AttributeDescriptor attr = find_attribute(kg, sd, node.attr);
256 const AttributeDescriptor attr_sign = find_attribute(kg, sd, node.attr_sign);
257
258 if (!is_attribute_found(attr) || !is_attribute_found(attr_sign)) {
259 /* Fall back to unperturbed normal. */
260 stack_store_float3(stack, node.normal_offset, sd->N);
261 return;
262 }
263
264 /* get _unnormalized_ interpolated normal and tangent */
265 const float3 tangent = primitive_surface_attribute<float3>(kg, sd, attr);
266 const float sign = primitive_surface_attribute<float>(kg, sd, attr_sign);
267 float3 normal;
268
269 if (sd->shader & SHADER_SMOOTH_NORMAL) {
270 const AttributeDescriptor attr_undisplaced_normal =
271 (node.use_original_base) ?
272 find_attribute(kg, sd->object, sd->prim, ATTR_STD_NORMAL_UNDISPLACED) :
274 if (is_attribute_found(attr_undisplaced_normal)) {
275 normal = primitive_surface_attribute<float3>(kg, sd, attr_undisplaced_normal);
276 /* Can't interpolate in tangent space as the displaced normal is not used
277 * for the tangent frame. */
278 linear_interpolate_strength = true;
279 }
280 else {
282 }
283 }
284 else {
285 normal = sd->Ng;
286
287 /* the normal is already inverted, which is too soon for the math here */
288 if (is_backfacing) {
289 normal = -normal;
290 }
291
292 object_inverse_normal_transform(kg, sd, &normal);
293 }
294 /* Apply strength in the tangent case. */
295 if (!linear_interpolate_strength) {
296 color.x *= strength;
297 color.y *= strength;
298 color.z = mix(1.0f, color.z, saturatef(strength));
299 }
300
301 /* apply normal map */
302 const float3 B = sign * cross(normal, tangent);
303 N = safe_normalize(to_global(color, tangent, B, normal));
304
305 /* transform to world space */
306 object_normal_transform(kg, sd, &N);
307
308 /* invert normal for backfacing polygons */
309 if (is_backfacing) {
310 N = -N;
311 }
312 }
313 else {
314 linear_interpolate_strength = true;
315
316 /* strange blender convention */
319 {
320 color.y = -color.y;
321 color.z = -color.z;
322 }
323
324 /* object, world space */
325 N = color;
326
328 object_normal_transform(kg, sd, &N);
329 }
330 else {
331 N = safe_normalize(N);
332 }
333
334 /* invert normal for backfacing polygons */
335 if (is_backfacing) {
336 N = -N;
337 }
338 }
339
340 /* Use simple linear interpolation if we can't do it in tangent space. */
341 if (linear_interpolate_strength && strength != 1.0f) {
342 strength = max(strength, 0.0f);
343 N = safe_normalize(sd->N + (N - sd->N) * strength);
344 }
345
346 if (is_zero(N) || !isfinite_safe(N)) {
347 N = sd->N;
348 }
349
350 stack_store_float3(stack, node.normal_offset, N);
351}
352
353template<typename Float3Type>
355 ccl_private ShaderData *sd,
356 ccl_private float *stack,
358{
359 const AttributeDescriptor desc = find_attribute(kg, sd, node.attr);
360
361 Float3Type tangent;
362 if (node.direction_type == NODE_TANGENT_UVMAP) {
363 /* UV map */
364 if (!is_attribute_found(desc)) {
365 stack_store(stack, node.tangent_offset, Float3Type());
366 return;
367 }
368 if (desc.type == NODE_ATTR_FLOAT2) {
369 if constexpr (is_dual_v<Float3Type>) {
370 tangent = make_float3(primitive_surface_attribute<dual2>(kg, sd, desc));
371 }
372 else {
373 tangent = make_float3(primitive_surface_attribute<float2>(kg, sd, desc));
374 }
375 }
376 else {
377 tangent = primitive_surface_attribute<Float3Type>(kg, sd, desc);
378 }
379 }
380 else {
381 /* radial */
382 Float3Type generated;
383 if (!is_attribute_found(desc)) {
384 generated = shading_position<Float3Type>(sd);
385 }
386 else if (desc.type == NODE_ATTR_FLOAT2) {
387 if constexpr (is_dual_v<Float3Type>) {
388 generated = make_float3(primitive_surface_attribute<dual2>(kg, sd, desc));
389 }
390 else {
391 generated = make_float3(primitive_surface_attribute<float2>(kg, sd, desc));
392 }
393 }
394 else {
395 generated = primitive_surface_attribute<Float3Type>(kg, sd, desc);
396 }
397
398 if constexpr (is_dual_v<Float3Type>) {
399 using FloatType = dual_scalar_t<Float3Type>;
400 if (node.axis == NODE_TANGENT_AXIS_X) {
401 tangent = make_float3(FloatType(), -(generated.z() - 0.5f), (generated.y() - 0.5f));
402 }
403 else if (node.axis == NODE_TANGENT_AXIS_Y) {
404 tangent = make_float3(-(generated.z() - 0.5f), FloatType(), (generated.x() - 0.5f));
405 }
406 else {
407 tangent = make_float3(-(generated.y() - 0.5f), (generated.x() - 0.5f), FloatType());
408 }
409 }
410 else {
411 if (node.axis == NODE_TANGENT_AXIS_X) {
412 tangent = make_float3(0.0f, -(generated.z - 0.5f), (generated.y - 0.5f));
413 }
414 else if (node.axis == NODE_TANGENT_AXIS_Y) {
415 tangent = make_float3(-(generated.z - 0.5f), 0.0f, (generated.x - 0.5f));
416 }
417 else {
418 tangent = make_float3(-(generated.y - 0.5f), (generated.x - 0.5f), 0.0f);
419 }
420 }
421 }
422
423 object_normal_transform(kg, sd, &tangent);
424 tangent = cross(sd->N, normalize(cross(tangent, sd->N)));
425 stack_store(stack, node.tangent_offset, tangent);
426}
427
btScalar max
ccl_device_inline void stack_store_float3(ccl_private float *stack, const uint a, const float3 f)
ccl_device_inline void stack_store(ccl_private float *stack, const uint a, const float f)
ccl_device_inline Float3Type shading_incoming(const ccl_private ShaderData *sd)
ccl_device_inline Float3Type shading_position(const ccl_private ShaderData *sd)
ccl_device_inline const ccl_global T & svm_node_get(KernelGlobals kg, ccl_private int *const offset)
ccl_device_inline T stack_load(const ccl_private float *stack, const uint a)
#define kernel_data
#define ccl_restrict
#define OBJECT_NONE
#define ccl_private
#define ccl_device_inline
#define ccl_global
#define ccl_device_noinline
#define CCL_NAMESPACE_END
#define saturatef(x)
ccl_device_forceinline float3 make_float3(const float x, const float y, const float z)
ccl_device_inline float3 triangle_smooth_normal(KernelGlobals kg, float3 Ng, int object, int object_flag, int prim, float u, float v)
ccl_device_inline float3 triangle_smooth_normal_unnormalized_object_space(KernelGlobals kg, ccl_private const ShaderData *sd)
VecBase< T, D > reflect(VecOp< T, D >, VecOp< T, D >) RET
VecBase< float, D > normalize(VecOp< float, D >) RET
constexpr T sign(T) RET
VecBase< float, 3 > cross(VecOp< float, 3 >, VecOp< float, 3 >) RET
bool is_zero(float3x3 a)
float3 transform_point(float3x3 mat, float3 point)
VecT safe_normalize(VecT vector)
ccl_device_inline float3 camera_position(KernelGlobals kg)
ccl_device_inline float3 camera_world_to_ndc(KernelGlobals kg, ccl_private ShaderData *sd, float3 P)
ccl_device_inline AttributeDescriptor attribute_not_found()
CCL_NAMESPACE_BEGIN ccl_device_forceinline bool is_attribute_found(const ccl_private AttributeDescriptor &desc)
ccl_device_inline AttributeDescriptor find_attribute(const ccl_global AttributeMap *attributes_map, uint attr_offset, const int prim, const uint64_t id)
ccl_device_inline float3 object_dupli_uv(KernelGlobals kg, const int object)
ccl_device_inline void object_normal_transform(KernelGlobals kg, const ccl_private ShaderData *sd, ccl_private T *N)
ccl_device_inline float3 object_dupli_generated(KernelGlobals kg, const int object)
ccl_device_inline void object_inverse_position_transform_if_object(KernelGlobals kg, const ccl_private ShaderData *sd, ccl_private Float3Type *P)
ccl_device_inline void object_inverse_normal_transform(KernelGlobals kg, const ccl_private ShaderData *sd, ccl_private float3 *N)
@ NODE_ATTR_FLOAT2
@ NODE_BUMP_OFFSET_DY
@ NODE_BUMP_OFFSET_DX
@ NODE_TANGENT_AXIS_Y
@ NODE_TANGENT_AXIS_X
@ NODE_TANGENT_UVMAP
NodeTexCoord
@ NODE_TEXCO_VOLUME_GENERATED
@ NODE_TEXCO_REFLECTION
@ NODE_TEXCO_WINDOW
@ NODE_TEXCO_OBJECT
@ NODE_TEXCO_DUPLI_UV
@ NODE_TEXCO_OBJECT_WITH_TRANSFORM
@ NODE_TEXCO_DUPLI_GENERATED
@ NODE_TEXCO_CAMERA
@ NODE_TEXCO_NORMAL
@ NODE_NORMAL_MAP_TANGENT
@ NODE_NORMAL_MAP_BLENDER_WORLD
@ NODE_NORMAL_MAP_BLENDER_OBJECT
@ NODE_NORMAL_MAP_OBJECT
uint32_t PathRayVisibility
@ SR_BACKFACING
@ PRIMITIVE_TRIANGLE
@ PATH_RAY_VISIBILITY_CAMERA
@ SD_OBJECT_TRANSFORM_APPLIED
@ SHADER_SMOOTH_NORMAL
@ ATTR_STD_NORMAL_UNDISPLACED
@ CAMERA_ORTHOGRAPHIC
ccl_device_inline bool isfinite_safe(const float f)
Definition math_base.h:362
ccl_device_inline T make_zero()
Definition math_dual.h:20
#define N
#define B
ccl_device_inline float3 motion_triangle_smooth_normal(KernelGlobals kg, const float3 Ng, const int object, const int prim, const uint3 tri_vindex, const int numsteps, const int step, const float t, const float u, const float v)
CCL_NAMESPACE_BEGIN ccl_device_forceinline T primitive_surface_attribute(KernelGlobals kg, const ccl_private ShaderData *sd, const AttributeDescriptor desc)
Definition primitive.h:32
#define mix
NodeAttributeType type
float z
Definition sky_math.h:136
float y
Definition sky_math.h:136
float x
Definition sky_math.h:136
ccl_device_noinline int svm_node_tex_coord_derivative(KernelGlobals kg, ccl_private ShaderData *sd, const PathRayVisibility path_visibility, ccl_private float *ccl_restrict stack, const ccl_global SVMNodeTexCoord &ccl_restrict node, int offset)
Definition tex_coord.h:201
CCL_NAMESPACE_BEGIN ccl_device_inline dual3 svm_texco_smooth_normal(KernelGlobals kg, const ccl_private ShaderData *sd)
Definition tex_coord.h:24
ccl_device_noinline Float3Type svm_node_tex_coord_eval(KernelGlobals kg, ccl_private ShaderData *sd, const PathRayVisibility path_visibility, const NodeTexCoord type, ccl_private int *offset)
Definition tex_coord.h:92
ccl_device_inline int svm_node_tex_coord_skip(const ccl_global SVMNodeTexCoord &ccl_restrict node, int offset)
Definition tex_coord.h:192
ccl_device_noinline void svm_node_tangent(KernelGlobals kg, ccl_private ShaderData *sd, ccl_private float *stack, const ccl_global SVMNodeTangent &ccl_restrict node)
Definition tex_coord.h:354
ccl_device_inline Float3Type svm_texco_reflection(const ccl_private ShaderData *sd)
Definition tex_coord.h:68
ccl_device_noinline int svm_node_tex_coord(KernelGlobals kg, ccl_private ShaderData *sd, const PathRayVisibility path_visibility, ccl_private float *ccl_restrict stack, const ccl_global SVMNodeTexCoord &ccl_restrict node, int offset)
Definition tex_coord.h:179
ccl_device_noinline void svm_node_normal_map(KernelGlobals kg, ccl_private ShaderData *sd, ccl_private float *ccl_restrict stack, const ccl_global SVMNodeNormalMap &ccl_restrict node)
Definition tex_coord.h:229
ccl_device_inline Float3Type svm_texco_camera(KernelGlobals kg, const ccl_private ShaderData *sd, const ccl_private Float3Type &P)
Definition tex_coord.h:78
CCL_NAMESPACE_BEGIN ccl_device_inline T to_global(const float2 p, const T X, const T Y)
Definition transform.h:21
ccl_device_inline Transform make_transform(const float a, const float b, const float c, const float d, const float e, const float f, const float g, const float h, const float i, const float j, const float k, const float l)
Definition transform.h:185
ccl_static_constexpr bool is_dual_v
Definition types_dual.h:118
typename dual_scalar_type< T >::type dual_scalar_t
Definition types_dual.h:141
dual< float3 > dual3
Definition types_dual.h:106