Blender V5.3
shader_data.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/* Functions to initialize ShaderData given.
6 *
7 * Could be from an incoming ray, intersection or sampled position. */
8
9#pragma once
10
11#include "kernel/globals.h"
12
15#include "kernel/geom/object.h"
18
20
22
24
25/* ShaderData setup from incoming ray */
26
28 ccl_private ShaderData *ccl_restrict sd,
29 const float time)
30{
31#ifdef __OBJECT_MOTION__
32 if (sd->object_flag & SD_OBJECT_MOTION) {
33 sd->ob_tfm_motion = object_fetch_transform_motion(kg, sd->object, time);
34 sd->ob_itfm_motion = transform_inverse(sd->ob_tfm_motion);
35 }
36#endif
37}
38
39/* TODO: break this up if it helps reduce register pressure to load data from
40 * global memory as we write it to shader-data.
41 *
42 * HIP on Linux currently needs noinline to sidestep a probable compiler bug. */
43#ifdef __KERNEL_HIP__
45#else
47#endif
49 ccl_private ShaderData *ccl_restrict sd,
50 const ccl_private Ray *ccl_restrict ray,
52{
53 /* Read intersection data into shader globals.
54 *
55 * TODO: this is redundant, could potentially remove some of this from
56 * ShaderData but would need to ensure that it also works for shadow
57 * shader evaluation. */
58 sd->u = isect->u;
59 sd->v = isect->v;
60 sd->ray_length = isect->t;
61 sd->type = isect->type;
62 sd->object = isect->object;
63 sd->object_flag = kernel_data_fetch(object_flag, sd->object);
64 sd->prim = isect->prim;
65 sd->runtime_flag = 0;
66 sd->shader_flag = 0;
67
68 /* Read matrices and time. */
69 sd->time = ray->time;
70
71#ifdef __OBJECT_MOTION__
72 shader_setup_object_transforms(kg, sd, ray->time);
73#endif
74
75 /* Read ray data into shader globals. */
76 sd->wi = -ray->D;
77
78#ifdef __HAIR__
79 if (sd->type & PRIMITIVE_CURVE) {
80 /* curve */
81 curve_shader_setup(kg, sd, ray->P, ray->D, isect->t, isect->prim);
82 }
83 else
84#endif
85#ifdef __POINTCLOUD__
86 if (sd->type & PRIMITIVE_ANY_POINT)
87 {
88 /* point */
89 point_shader_setup(kg, sd, isect, ray);
90 }
91 else
92#endif
93 {
94 if (sd->type == PRIMITIVE_TRIANGLE) {
95 /* static triangle */
97 }
98 else {
100 /* motion triangle */
102 }
103
104 if (!(sd->object_flag & SD_OBJECT_TRANSFORM_APPLIED)) {
105 /* instance transform */
106 object_normal_transform(kg, sd, &sd->N);
107 object_normal_transform(kg, sd, &sd->Ng);
108#ifdef __DPDU__
109 object_dir_transform(kg, sd, &sd->dPdu);
110 object_dir_transform(kg, sd, &sd->dPdv);
111#endif
112 }
113 }
114
115 sd->shader_flag = kernel_data_fetch(shaders, (sd->shader & SHADER_MASK)).flags;
116
117 /* backfacing test */
118 const bool backfacing = (dot(sd->Ng, sd->wi) < 0.0f);
119
120 if (backfacing) {
121 sd->runtime_flag |= SR_BACKFACING;
122 sd->Ng = -sd->Ng;
123 sd->N = -sd->N;
124#ifdef __DPDU__
125 sd->dPdu = -sd->dPdu;
126 sd->dPdv = -sd->dPdv;
127#endif
128 }
129
130#ifdef __RAY_DIFFERENTIALS__
131 /* differentials */
132 sd->dP = differential_transfer_compact(ray->dP, ray->D, ray->dD, sd->ray_length);
133 sd->dI = differential_incoming_compact(ray->dD);
134 differential_dudv_compact(&sd->du, &sd->dv, sd->dPdu, sd->dPdv, sd->dP, sd->Ng);
135#endif
136}
137
138/* ShaderData setup from position sampled on mesh */
139
141 ccl_private ShaderData *ccl_restrict sd,
142 const float3 P,
143 const float3 Ng,
144 const float3 I,
145 const int shader,
146 const int object,
147 const int prim,
148 const float u,
149 const float v,
150 const float t,
151 const float time,
152 const bool object_space,
153 const bool is_lamp)
154{
155 /* vectors */
156 sd->P = P;
157 sd->N = Ng;
158 sd->Ng = Ng;
159 sd->wi = I;
160 sd->shader = shader;
161 if (is_lamp) {
162 sd->type = PRIMITIVE_LAMP;
163 }
164 else if (prim != PRIM_NONE) {
165 sd->type = PRIMITIVE_TRIANGLE;
166 }
167 else {
168 sd->type = PRIMITIVE_NONE;
169 }
170
171 /* primitive */
172 sd->object = object;
173 /* Currently no access to bvh prim index for strand sd->prim. */
174 sd->prim = prim;
175 sd->u = u;
176 sd->v = v;
177 sd->time = time;
178 sd->ray_length = t;
179 sd->runtime_flag = 0;
180 sd->shader_flag = kernel_data_fetch(shaders, (sd->shader & SHADER_MASK)).flags;
181 sd->object_flag = 0;
182 if (sd->object != OBJECT_NONE) {
183 sd->object_flag |= kernel_data_fetch(object_flag, sd->object);
184
185#ifdef __OBJECT_MOTION__
186 shader_setup_object_transforms(kg, sd, time);
187#endif
188
189 /* transform into world space */
190 if (object_space) {
191 object_position_transform(kg, sd, &sd->P);
192 object_normal_transform(kg, sd, &sd->Ng);
193 sd->N = sd->Ng;
194 object_dir_transform(kg, sd, &sd->wi);
195 }
196
197 if (sd->type == PRIMITIVE_TRIANGLE) {
198 /* smooth normal */
199 if (sd->shader & SHADER_SMOOTH_NORMAL) {
201 kg, Ng, sd->object, sd->object_flag, sd->prim, sd->u, sd->v);
202
203 if (!(sd->object_flag & SD_OBJECT_TRANSFORM_APPLIED)) {
204 object_normal_transform(kg, sd, &sd->N);
205 }
206 }
207
208 /* dPdu/dPdv */
209#ifdef __DPDU__
210 triangle_dPdudv(kg, sd->object, sd->prim, &sd->dPdu, &sd->dPdv);
211
212 if (!(sd->object_flag & SD_OBJECT_TRANSFORM_APPLIED)) {
213 object_dir_transform(kg, sd, &sd->dPdu);
214 object_dir_transform(kg, sd, &sd->dPdv);
215 }
216#endif
217 }
218 else {
219#ifdef __DPDU__
220 sd->dPdu = zero_float3();
221 sd->dPdv = zero_float3();
222#endif
223 }
224 }
225 else {
226#ifdef __DPDU__
227 sd->dPdu = zero_float3();
228 sd->dPdv = zero_float3();
229#endif
230 }
231
232 /* backfacing test */
233 if (sd->prim != PRIM_NONE) {
234 const bool backfacing = (dot(sd->Ng, sd->wi) < 0.0f);
235
236 if (backfacing) {
237 sd->runtime_flag |= SR_BACKFACING;
238 sd->Ng = -sd->Ng;
239 sd->N = -sd->N;
240#ifdef __DPDU__
241 sd->dPdu = -sd->dPdu;
242 sd->dPdv = -sd->dPdv;
243#endif
244 }
245 }
246
247#ifdef __RAY_DIFFERENTIALS__
248 /* no ray differentials here yet */
249 sd->dP = differential_zero_compact();
250 sd->dI = differential_zero_compact();
251 sd->du = differential_zero();
252 sd->dv = differential_zero();
253#endif
254}
255
256/* ShaderData setup for displacement */
257
259 ccl_private ShaderData *ccl_restrict sd,
260 const int object,
261 const int prim,
262 const float u,
263 const float v)
264{
265 float3 P;
266 float3 Ng;
267 const float3 I = zero_float3();
268 int shader;
269
270 triangle_point_normal(kg, object, prim, u, v, &P, &Ng, &shader);
271
272 /* force smooth shading for displacement */
273 shader |= SHADER_SMOOTH_NORMAL;
274
276 sd,
277 P,
278 Ng,
279 I,
280 shader,
281 object,
282 prim,
283 u,
284 v,
285 0.0f,
286 0.5f,
287 !(kernel_data_fetch(object_flag, object) & SD_OBJECT_TRANSFORM_APPLIED),
288 false);
289
290 /* Assign some incoming direction to avoid division by zero. */
291 sd->wi = sd->N;
292
293#ifdef __RAY_DIFFERENTIALS__
294 /* Set ray differentials based on triangle size for texture filtering.
295 * The parametric step across the triangle is 1.0, giving dPdx = dPdu
296 * and dPdy = dPdv.
297 * TODO: consider computing this based on all triangles adjacent to the vertex. */
298 sd->du.dx = 1.0f;
299 sd->du.dy = 0.0f;
300 sd->dv.dx = 0.0f;
301 sd->dv.dy = 1.0f;
302 sd->dP = 0.5f * (len(sd->dPdu) + len(sd->dPdv));
303#endif
304}
305
306/* ShaderData setup for point on curve. */
307
308#ifdef __HAIR__
309ccl_device void shader_setup_from_curve(KernelGlobals kg,
310 ccl_private ShaderData *ccl_restrict sd,
311 const int object,
312 const int prim,
313 const int segment,
314 const float u)
315{
316 /* Primitive */
318 sd->prim = prim;
319 sd->u = u;
320 sd->v = 0.0f;
321 sd->time = 0.5f;
322 sd->ray_length = 0.0f;
323
324 /* Shader */
325 sd->shader = kernel_data_fetch(curves, prim).shader_id;
326 sd->runtime_flag = 0;
327 sd->shader_flag = kernel_data_fetch(shaders, (sd->shader & SHADER_MASK)).flags;
328
329 /* Object */
330 sd->object = object;
331 sd->object_flag = kernel_data_fetch(object_flag, sd->object);
332# ifdef __OBJECT_MOTION__
333 shader_setup_object_transforms(kg, sd, sd->time);
334# endif
335
336 /* Get control points. */
337 const KernelCurve kcurve = kernel_data_fetch(curves, prim);
338
339 const int k0 = kcurve.first_key + PRIMITIVE_UNPACK_SEGMENT(sd->type);
340 const int k1 = k0 + 1;
341 const int ka = max(k0 - 1, kcurve.first_key);
342 const int kb = min(k1 + 1, kcurve.first_key + kcurve.num_keys - 1);
343
344 float4 P_curve[4];
345
346 const int position_offset = kernel_data_fetch(objects, object).position_offset;
347 P_curve[0] = kernel_data_fetch(curve_keys, position_offset + ka);
348 P_curve[1] = kernel_data_fetch(curve_keys, position_offset + k0);
349 P_curve[2] = kernel_data_fetch(curve_keys, position_offset + k1);
350 P_curve[3] = kernel_data_fetch(curve_keys, position_offset + kb);
351
352 /* Interpolate position and tangent. */
353 sd->P = (sd->type & PRIMITIVE_CURVE) == PRIMITIVE_CURVE_THICK_LINEAR ?
354 make_float3(linear_basis_eval(P_curve, sd->u)) :
355 make_float3(catmull_rom_basis_eval(P_curve, sd->u));
356# ifdef __DPDU__
357 sd->dPdu = (sd->type & PRIMITIVE_CURVE) == PRIMITIVE_CURVE_THICK_LINEAR ?
358 make_float3(linear_basis_derivative(P_curve, sd->u)) :
359 make_float3(catmull_rom_basis_derivative(P_curve, sd->u));
360# endif
361
362 /* Transform into world space */
363 if (!(sd->object_flag & SD_OBJECT_TRANSFORM_APPLIED)) {
364 object_position_transform(kg, sd, &sd->P);
365# ifdef __DPDU__
366 object_dir_transform(kg, sd, &sd->dPdu);
367# endif
368 }
369
370 /* Pick arbitrary view direction, normals and bitangent to avoid NaNs elsewhere. */
371 sd->wi = normalize(cross(make_float3(0, 1, 0), sd->dPdu));
372 sd->N = sd->wi;
373 sd->Ng = sd->wi;
374# ifdef __DPDU__
375 sd->dPdv = cross(sd->dPdu, sd->Ng);
376# endif
377
378 /* No ray differentials currently. */
379# ifdef __RAY_DIFFERENTIALS__
380 sd->dP = differential_zero_compact();
381 sd->dI = differential_zero_compact();
382 sd->du = differential_zero();
383 sd->dv = differential_zero();
384# endif
385}
386#endif /* __HAIR__ */
387
388/* ShaderData setup from ray into background */
389
391 ccl_private ShaderData *ccl_restrict sd,
392 const float3 ray_P,
393 const float3 ray_D,
394 const float ray_dD,
395 const float ray_time)
396{
397 /* for NDC coordinates */
398 sd->ray_P = ray_P;
399
400 /* vectors */
401 sd->P = ray_D;
402 sd->N = -ray_D;
403 sd->Ng = -ray_D;
404 sd->wi = -ray_D;
405 sd->shader = kernel_data.background.surface_shader;
406 sd->runtime_flag = 0;
407 sd->shader_flag = kernel_data_fetch(shaders, (sd->shader & SHADER_MASK)).flags;
408 sd->object_flag = 0;
409 sd->time = ray_time;
410 sd->ray_length = FLT_MAX;
411
412 sd->object = OBJECT_NONE;
413 sd->prim = PRIM_NONE;
414 sd->type = PRIMITIVE_NONE;
415 sd->u = 0.0f;
416 sd->v = 0.0f;
417
418#ifdef __DPDU__
419 /* dPdu/dPdv */
420 /* Construct arbitrary local coordinate system. */
421 make_orthonormals(sd->Ng, &sd->dPdu, &sd->dPdv);
422#endif
423
424#ifdef __RAY_DIFFERENTIALS__
425 /* differentials */
426 sd->dP = ray_dD;
427 sd->dI = differential_incoming_compact(ray_dD);
428 /* Make the uv coordinate system match the constructed local coordinate system. */
429 sd->du.dx = sd->dv.dy = sd->dP;
430 sd->du.dy = sd->dv.dx = 0.0f;
431#endif
432}
433
434/* ShaderData setup from point inside volume */
435
436#ifdef __VOLUME__
437ccl_device_inline void shader_setup_from_volume(ccl_private ShaderData *ccl_restrict sd,
438 const ccl_private Ray *ccl_restrict ray,
439 const int object)
440{
441
442 /* vectors */
443 sd->P = ray->P + ray->D * ray->tmin;
444 sd->N = -ray->D;
445 sd->Ng = -ray->D;
446 sd->wi = -ray->D;
447 sd->shader = SHADER_NONE;
448 sd->runtime_flag = 0;
449 sd->shader_flag = 0;
450 sd->object_flag = 0;
451 sd->time = ray->time;
452 sd->ray_length = 0.0f; /* todo: can we set this to some useful value? */
453
454 /* TODO: fill relevant fields for texture coordinates. */
455 sd->object = object;
456 sd->prim = PRIM_NONE;
457 sd->type = PRIMITIVE_VOLUME;
458
459 sd->u = 0.0f;
460 sd->v = 0.0f;
461
462# ifdef __DPDU__
463 /* dPdu/dPdv */
464 sd->dPdu = zero_float3();
465 sd->dPdv = zero_float3();
466# endif
467
468# ifdef __RAY_DIFFERENTIALS__
469 /* differentials */
470 sd->dP = differential_zero_compact(); /* TODO ray->dD */
471 sd->dI = differential_zero_compact();
472 sd->du = differential_zero();
473 sd->dv = differential_zero();
474# endif
475
476 /* for NDC coordinates */
477 sd->ray_P = ray->P;
478}
479#endif /* __VOLUME__ */
480
481#ifdef __SPECTRAL__
482/* If shader requires, draw a random number for sampling a wavelength. */
483ccl_device_inline void shader_setup_wavelength(KernelGlobals kg,
484 ccl_private ShaderData *ccl_restrict sd,
486{
487 if (sd->shader_flag & SD_REQUIRES_WAVELENGTH) {
488 const uint pixel = INTEGRATOR_STATE(state, path, rng_pixel);
489 const uint sample = INTEGRATOR_STATE(state, path, sample);
490 /* Same random number per path, irrelevant of the bounce. */
491 sd->rand_wavelength = path_rng_1D(kg, pixel, sample, PRNG_BOUNCE_NUM + PRNG_WAVELENGTH);
492 }
493}
494#endif
495
btScalar max
#define kernel_assert(cond)
#define PRIMITIVE_PACK_SEGMENT(type, segment)
#define kernel_data
#define ccl_restrict
#define kernel_data_fetch(name, index)
#define SHADER_NONE
#define PRIM_NONE
#define PRIMITIVE_UNPACK_SEGMENT(type)
#define OBJECT_NONE
#define ccl_private
#define ccl_device_inline
#define ccl_device_noinline
#define CCL_NAMESPACE_END
ccl_device_forceinline float3 make_float3(const float x, const float y, const float z)
ccl_device_forceinline float differential_transfer_compact(const float ray_dP, const float3, const float ray_dD, const float ray_t)
ccl_device_forceinline float differential_incoming_compact(const float dD)
ccl_device differential differential_zero()
ccl_device void differential_dudv_compact(ccl_private differential *du, ccl_private differential *dv, const float3 dPdu, const float3 dPdv, const float dP, const float3 Ng)
ccl_device_forceinline float differential_zero_compact()
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 void triangle_dPdudv(KernelGlobals kg, const int object, const int prim, ccl_private float3 *dPdu, ccl_private float3 *dPdv)
ccl_device_inline void triangle_point_normal(KernelGlobals kg, const int object, const int prim, const float u, const float v, ccl_private float3 *P, ccl_private float3 *Ng, ccl_private int *shader)
#define FLT_MAX
VecBase< float, D > normalize(VecOp< float, D >) RET
float dot(VecOp< float, D >, VecOp< float, D >) RET
VecBase< float, 3 > cross(VecOp< float, 3 >, VecOp< float, 3 >) RET
const int state
ccl_device_inline void object_dir_transform(KernelGlobals kg, const ccl_private ShaderData *sd, ccl_private float3 *D)
ccl_device_inline void object_normal_transform(KernelGlobals kg, const ccl_private ShaderData *sd, ccl_private T *N)
ccl_device_inline void object_position_transform(KernelGlobals kg, const ccl_private ShaderData *sd, ccl_private T *P)
@ SR_BACKFACING
@ SD_REQUIRES_WAVELENGTH
@ PRIMITIVE_LAMP
@ PRIMITIVE_CURVE_THICK_LINEAR
@ PRIMITIVE_MOTION_TRIANGLE
@ PRIMITIVE_NONE
@ PRIMITIVE_VOLUME
@ PRIMITIVE_CURVE
@ PRIMITIVE_CURVE_THICK
@ PRIMITIVE_ANY_POINT
@ PRIMITIVE_TRIANGLE
@ PRNG_BOUNCE_NUM
@ PRNG_WAVELENGTH
@ SD_OBJECT_MOTION
@ SD_OBJECT_TRANSFORM_APPLIED
@ SHADER_SMOOTH_NORMAL
@ SHADER_MASK
ccl_device_inline dual1 len(const ccl_private dual< T > &a)
Definition math_dual.h:263
CCL_NAMESPACE_BEGIN ccl_device_inline float3 zero_float3()
Definition math_float3.h:17
ccl_device_inline void make_orthonormals(const float3 N, ccl_private float3 *a, ccl_private float3 *b)
CCL_NAMESPACE_BEGIN ccl_device_noinline void motion_triangle_shader_setup(KernelGlobals kg, ccl_private ShaderData *sd)
unsigned int uint
Definition BKE_text.h:55
#define I
ccl_device_forceinline float path_rng_1D(KernelGlobals kg, const uint rng_pixel, const uint sample, const int dimension)
Definition pattern.h:66
#define ccl_device
ccl_device_inline void shader_setup_from_sample(KernelGlobals kg, ccl_private ShaderData *ccl_restrict sd, const float3 P, const float3 Ng, const float3 I, const int shader, const int object, const int prim, const float u, const float v, const float t, const float time, const bool object_space, const bool is_lamp)
ccl_device void shader_setup_from_displace(KernelGlobals kg, ccl_private ShaderData *ccl_restrict sd, const int object, const int prim, const float u, const float v)
ccl_device_inline void shader_setup_from_ray(KernelGlobals kg, ccl_private ShaderData *ccl_restrict sd, const ccl_private Ray *ccl_restrict ray, const ccl_private Intersection *ccl_restrict isect)
Definition shader_data.h:48
CCL_NAMESPACE_BEGIN ccl_device void shader_setup_object_transforms(KernelGlobals kg, ccl_private ShaderData *ccl_restrict sd, const float time)
Definition shader_data.h:27
ccl_device_inline void shader_setup_from_background(KernelGlobals kg, ccl_private ShaderData *ccl_restrict sd, const float3 ray_P, const float3 ray_D, const float ray_dD, const float ray_time)
#define min(a, b)
Definition sort.cc:38
#define INTEGRATOR_STATE(state, nested_struct, member)
Definition state.h:234
const IntegratorStateCPU * ConstIntegratorState
Definition state.h:228
ccl_device_inline Transform transform_inverse(const Transform tfm)
Definition transform.h:563
ccl_device_inline void triangle_shader_setup(KernelGlobals kg, ccl_private ShaderData *sd)