1 /*
2 * Copyright 2011-2013 Blender Foundation
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17 /*
18 * ShaderData, used in four steps:
19 *
20 * Setup from incoming ray, sampled position and background.
21 * Execute for surface, volume or displacement.
22 * Evaluate one or more closures.
23 * Release.
24 */
25
26 // clang-format off
27 #include "kernel/closure/alloc.h"
28 #include "kernel/closure/bsdf_util.h"
29 #include "kernel/closure/bsdf.h"
30 #include "kernel/closure/emissive.h"
31 // clang-format on
32
33 #include "kernel/svm/svm.h"
34
35 CCL_NAMESPACE_BEGIN
36
37 /* ShaderData setup from incoming ray */
38
39 #ifdef __OBJECT_MOTION__
shader_setup_object_transforms(KernelGlobals * kg,ShaderData * sd,float time)40 ccl_device void shader_setup_object_transforms(KernelGlobals *kg, ShaderData *sd, float time)
41 {
42 if (sd->object_flag & SD_OBJECT_MOTION) {
43 sd->ob_tfm = object_fetch_transform_motion(kg, sd->object, time);
44 sd->ob_itfm = transform_quick_inverse(sd->ob_tfm);
45 }
46 else {
47 sd->ob_tfm = object_fetch_transform(kg, sd->object, OBJECT_TRANSFORM);
48 sd->ob_itfm = object_fetch_transform(kg, sd->object, OBJECT_INVERSE_TRANSFORM);
49 }
50 }
51 #endif
52
53 #ifdef __KERNEL_OPTIX__
54 ccl_device_inline
55 #else
56 ccl_device_noinline
57 #endif
58 void
shader_setup_from_ray(KernelGlobals * kg,ShaderData * sd,const Intersection * isect,const Ray * ray)59 shader_setup_from_ray(KernelGlobals *kg,
60 ShaderData *sd,
61 const Intersection *isect,
62 const Ray *ray)
63 {
64 PROFILING_INIT(kg, PROFILING_SHADER_SETUP);
65
66 sd->object = (isect->object == OBJECT_NONE) ? kernel_tex_fetch(__prim_object, isect->prim) :
67 isect->object;
68 sd->lamp = LAMP_NONE;
69
70 sd->type = isect->type;
71 sd->flag = 0;
72 sd->object_flag = kernel_tex_fetch(__object_flag, sd->object);
73
74 /* matrices and time */
75 #ifdef __OBJECT_MOTION__
76 shader_setup_object_transforms(kg, sd, ray->time);
77 #endif
78 sd->time = ray->time;
79
80 sd->prim = kernel_tex_fetch(__prim_index, isect->prim);
81 sd->ray_length = isect->t;
82
83 sd->u = isect->u;
84 sd->v = isect->v;
85
86 #ifdef __HAIR__
87 if (sd->type & PRIMITIVE_ALL_CURVE) {
88 /* curve */
89 curve_shader_setup(kg, sd, isect, ray);
90 }
91 else
92 #endif
93 if (sd->type & PRIMITIVE_TRIANGLE) {
94 /* static triangle */
95 float3 Ng = triangle_normal(kg, sd);
96 sd->shader = kernel_tex_fetch(__tri_shader, sd->prim);
97
98 /* vectors */
99 sd->P = triangle_refine(kg, sd, isect, ray);
100 sd->Ng = Ng;
101 sd->N = Ng;
102
103 /* smooth normal */
104 if (sd->shader & SHADER_SMOOTH_NORMAL)
105 sd->N = triangle_smooth_normal(kg, Ng, sd->prim, sd->u, sd->v);
106
107 #ifdef __DPDU__
108 /* dPdu/dPdv */
109 triangle_dPdudv(kg, sd->prim, &sd->dPdu, &sd->dPdv);
110 #endif
111 }
112 else {
113 /* motion triangle */
114 motion_triangle_shader_setup(kg, sd, isect, ray, false);
115 }
116
117 sd->I = -ray->D;
118
119 sd->flag |= kernel_tex_fetch(__shaders, (sd->shader & SHADER_MASK)).flags;
120
121 if (isect->object != OBJECT_NONE) {
122 /* instance transform */
123 object_normal_transform_auto(kg, sd, &sd->N);
124 object_normal_transform_auto(kg, sd, &sd->Ng);
125 #ifdef __DPDU__
126 object_dir_transform_auto(kg, sd, &sd->dPdu);
127 object_dir_transform_auto(kg, sd, &sd->dPdv);
128 #endif
129 }
130
131 /* backfacing test */
132 bool backfacing = (dot(sd->Ng, sd->I) < 0.0f);
133
134 if (backfacing) {
135 sd->flag |= SD_BACKFACING;
136 sd->Ng = -sd->Ng;
137 sd->N = -sd->N;
138 #ifdef __DPDU__
139 sd->dPdu = -sd->dPdu;
140 sd->dPdv = -sd->dPdv;
141 #endif
142 }
143
144 #ifdef __RAY_DIFFERENTIALS__
145 /* differentials */
146 differential_transfer(&sd->dP, ray->dP, ray->D, ray->dD, sd->Ng, isect->t);
147 differential_incoming(&sd->dI, ray->dD);
148 differential_dudv(&sd->du, &sd->dv, sd->dPdu, sd->dPdv, sd->dP, sd->Ng);
149 #endif
150
151 PROFILING_SHADER(sd->shader);
152 PROFILING_OBJECT(sd->object);
153 }
154
155 /* ShaderData setup from BSSRDF scatter */
156
157 #ifdef __SUBSURFACE__
158 # ifndef __KERNEL_CUDA__
159 ccl_device
160 # else
161 ccl_device_inline
162 # endif
163 void
shader_setup_from_subsurface(KernelGlobals * kg,ShaderData * sd,const Intersection * isect,const Ray * ray)164 shader_setup_from_subsurface(KernelGlobals *kg,
165 ShaderData *sd,
166 const Intersection *isect,
167 const Ray *ray)
168 {
169 PROFILING_INIT(kg, PROFILING_SHADER_SETUP);
170
171 const bool backfacing = sd->flag & SD_BACKFACING;
172
173 /* object, matrices, time, ray_length stay the same */
174 sd->flag = 0;
175 sd->object_flag = kernel_tex_fetch(__object_flag, sd->object);
176 sd->prim = kernel_tex_fetch(__prim_index, isect->prim);
177 sd->type = isect->type;
178
179 sd->u = isect->u;
180 sd->v = isect->v;
181
182 /* fetch triangle data */
183 if (sd->type == PRIMITIVE_TRIANGLE) {
184 float3 Ng = triangle_normal(kg, sd);
185 sd->shader = kernel_tex_fetch(__tri_shader, sd->prim);
186
187 /* static triangle */
188 sd->P = triangle_refine_local(kg, sd, isect, ray);
189 sd->Ng = Ng;
190 sd->N = Ng;
191
192 if (sd->shader & SHADER_SMOOTH_NORMAL)
193 sd->N = triangle_smooth_normal(kg, Ng, sd->prim, sd->u, sd->v);
194
195 # ifdef __DPDU__
196 /* dPdu/dPdv */
197 triangle_dPdudv(kg, sd->prim, &sd->dPdu, &sd->dPdv);
198 # endif
199 }
200 else {
201 /* motion triangle */
202 motion_triangle_shader_setup(kg, sd, isect, ray, true);
203 }
204
205 sd->flag |= kernel_tex_fetch(__shaders, (sd->shader & SHADER_MASK)).flags;
206
207 if (isect->object != OBJECT_NONE) {
208 /* instance transform */
209 object_normal_transform_auto(kg, sd, &sd->N);
210 object_normal_transform_auto(kg, sd, &sd->Ng);
211 # ifdef __DPDU__
212 object_dir_transform_auto(kg, sd, &sd->dPdu);
213 object_dir_transform_auto(kg, sd, &sd->dPdv);
214 # endif
215 }
216
217 /* backfacing test */
218 if (backfacing) {
219 sd->flag |= SD_BACKFACING;
220 sd->Ng = -sd->Ng;
221 sd->N = -sd->N;
222 # ifdef __DPDU__
223 sd->dPdu = -sd->dPdu;
224 sd->dPdv = -sd->dPdv;
225 # endif
226 }
227
228 /* should not get used in principle as the shading will only use a diffuse
229 * BSDF, but the shader might still access it */
230 sd->I = sd->N;
231
232 # ifdef __RAY_DIFFERENTIALS__
233 /* differentials */
234 differential_dudv(&sd->du, &sd->dv, sd->dPdu, sd->dPdv, sd->dP, sd->Ng);
235 /* don't modify dP and dI */
236 # endif
237
238 PROFILING_SHADER(sd->shader);
239 }
240 #endif
241
242 /* ShaderData setup from position sampled on mesh */
243
shader_setup_from_sample(KernelGlobals * kg,ShaderData * sd,const float3 P,const float3 Ng,const float3 I,int shader,int object,int prim,float u,float v,float t,float time,bool object_space,int lamp)244 ccl_device_inline void shader_setup_from_sample(KernelGlobals *kg,
245 ShaderData *sd,
246 const float3 P,
247 const float3 Ng,
248 const float3 I,
249 int shader,
250 int object,
251 int prim,
252 float u,
253 float v,
254 float t,
255 float time,
256 bool object_space,
257 int lamp)
258 {
259 PROFILING_INIT(kg, PROFILING_SHADER_SETUP);
260
261 /* vectors */
262 sd->P = P;
263 sd->N = Ng;
264 sd->Ng = Ng;
265 sd->I = I;
266 sd->shader = shader;
267 if (prim != PRIM_NONE)
268 sd->type = PRIMITIVE_TRIANGLE;
269 else if (lamp != LAMP_NONE)
270 sd->type = PRIMITIVE_LAMP;
271 else
272 sd->type = PRIMITIVE_NONE;
273
274 /* primitive */
275 sd->object = object;
276 sd->lamp = LAMP_NONE;
277 /* currently no access to bvh prim index for strand sd->prim*/
278 sd->prim = prim;
279 sd->u = u;
280 sd->v = v;
281 sd->time = time;
282 sd->ray_length = t;
283
284 sd->flag = kernel_tex_fetch(__shaders, (sd->shader & SHADER_MASK)).flags;
285 sd->object_flag = 0;
286 if (sd->object != OBJECT_NONE) {
287 sd->object_flag |= kernel_tex_fetch(__object_flag, sd->object);
288
289 #ifdef __OBJECT_MOTION__
290 shader_setup_object_transforms(kg, sd, time);
291 }
292 else if (lamp != LAMP_NONE) {
293 sd->ob_tfm = lamp_fetch_transform(kg, lamp, false);
294 sd->ob_itfm = lamp_fetch_transform(kg, lamp, true);
295 sd->lamp = lamp;
296 #else
297 }
298 else if (lamp != LAMP_NONE) {
299 sd->lamp = lamp;
300 #endif
301 }
302
303 /* transform into world space */
304 if (object_space) {
305 object_position_transform_auto(kg, sd, &sd->P);
306 object_normal_transform_auto(kg, sd, &sd->Ng);
307 sd->N = sd->Ng;
308 object_dir_transform_auto(kg, sd, &sd->I);
309 }
310
311 if (sd->type & PRIMITIVE_TRIANGLE) {
312 /* smooth normal */
313 if (sd->shader & SHADER_SMOOTH_NORMAL) {
314 sd->N = triangle_smooth_normal(kg, Ng, sd->prim, sd->u, sd->v);
315
316 if (!(sd->object_flag & SD_OBJECT_TRANSFORM_APPLIED)) {
317 object_normal_transform_auto(kg, sd, &sd->N);
318 }
319 }
320
321 /* dPdu/dPdv */
322 #ifdef __DPDU__
323 triangle_dPdudv(kg, sd->prim, &sd->dPdu, &sd->dPdv);
324
325 if (!(sd->object_flag & SD_OBJECT_TRANSFORM_APPLIED)) {
326 object_dir_transform_auto(kg, sd, &sd->dPdu);
327 object_dir_transform_auto(kg, sd, &sd->dPdv);
328 }
329 #endif
330 }
331 else {
332 #ifdef __DPDU__
333 sd->dPdu = make_float3(0.0f, 0.0f, 0.0f);
334 sd->dPdv = make_float3(0.0f, 0.0f, 0.0f);
335 #endif
336 }
337
338 /* backfacing test */
339 if (sd->prim != PRIM_NONE) {
340 bool backfacing = (dot(sd->Ng, sd->I) < 0.0f);
341
342 if (backfacing) {
343 sd->flag |= SD_BACKFACING;
344 sd->Ng = -sd->Ng;
345 sd->N = -sd->N;
346 #ifdef __DPDU__
347 sd->dPdu = -sd->dPdu;
348 sd->dPdv = -sd->dPdv;
349 #endif
350 }
351 }
352
353 #ifdef __RAY_DIFFERENTIALS__
354 /* no ray differentials here yet */
355 sd->dP = differential3_zero();
356 sd->dI = differential3_zero();
357 sd->du = differential_zero();
358 sd->dv = differential_zero();
359 #endif
360
361 PROFILING_SHADER(sd->shader);
362 PROFILING_OBJECT(sd->object);
363 }
364
365 /* ShaderData setup for displacement */
366
shader_setup_from_displace(KernelGlobals * kg,ShaderData * sd,int object,int prim,float u,float v)367 ccl_device void shader_setup_from_displace(
368 KernelGlobals *kg, ShaderData *sd, int object, int prim, float u, float v)
369 {
370 float3 P, Ng, I = make_float3(0.0f, 0.0f, 0.0f);
371 int shader;
372
373 triangle_point_normal(kg, object, prim, u, v, &P, &Ng, &shader);
374
375 /* force smooth shading for displacement */
376 shader |= SHADER_SMOOTH_NORMAL;
377
378 shader_setup_from_sample(
379 kg,
380 sd,
381 P,
382 Ng,
383 I,
384 shader,
385 object,
386 prim,
387 u,
388 v,
389 0.0f,
390 0.5f,
391 !(kernel_tex_fetch(__object_flag, object) & SD_OBJECT_TRANSFORM_APPLIED),
392 LAMP_NONE);
393 }
394
395 /* ShaderData setup from ray into background */
396
shader_setup_from_background(KernelGlobals * kg,ShaderData * sd,const Ray * ray)397 ccl_device_inline void shader_setup_from_background(KernelGlobals *kg,
398 ShaderData *sd,
399 const Ray *ray)
400 {
401 PROFILING_INIT(kg, PROFILING_SHADER_SETUP);
402
403 /* vectors */
404 sd->P = ray->D;
405 sd->N = -ray->D;
406 sd->Ng = -ray->D;
407 sd->I = -ray->D;
408 sd->shader = kernel_data.background.surface_shader;
409 sd->flag = kernel_tex_fetch(__shaders, (sd->shader & SHADER_MASK)).flags;
410 sd->object_flag = 0;
411 sd->time = ray->time;
412 sd->ray_length = 0.0f;
413
414 sd->object = OBJECT_NONE;
415 sd->lamp = LAMP_NONE;
416 sd->prim = PRIM_NONE;
417 sd->u = 0.0f;
418 sd->v = 0.0f;
419
420 #ifdef __DPDU__
421 /* dPdu/dPdv */
422 sd->dPdu = make_float3(0.0f, 0.0f, 0.0f);
423 sd->dPdv = make_float3(0.0f, 0.0f, 0.0f);
424 #endif
425
426 #ifdef __RAY_DIFFERENTIALS__
427 /* differentials */
428 sd->dP = ray->dD;
429 differential_incoming(&sd->dI, sd->dP);
430 sd->du = differential_zero();
431 sd->dv = differential_zero();
432 #endif
433
434 /* for NDC coordinates */
435 sd->ray_P = ray->P;
436
437 PROFILING_SHADER(sd->shader);
438 PROFILING_OBJECT(sd->object);
439 }
440
441 /* ShaderData setup from point inside volume */
442
443 #ifdef __VOLUME__
shader_setup_from_volume(KernelGlobals * kg,ShaderData * sd,const Ray * ray)444 ccl_device_inline void shader_setup_from_volume(KernelGlobals *kg, ShaderData *sd, const Ray *ray)
445 {
446 PROFILING_INIT(kg, PROFILING_SHADER_SETUP);
447
448 /* vectors */
449 sd->P = ray->P;
450 sd->N = -ray->D;
451 sd->Ng = -ray->D;
452 sd->I = -ray->D;
453 sd->shader = SHADER_NONE;
454 sd->flag = 0;
455 sd->object_flag = 0;
456 sd->time = ray->time;
457 sd->ray_length = 0.0f; /* todo: can we set this to some useful value? */
458
459 sd->object = OBJECT_NONE; /* todo: fill this for texture coordinates */
460 sd->lamp = LAMP_NONE;
461 sd->prim = PRIM_NONE;
462 sd->type = PRIMITIVE_NONE;
463
464 sd->u = 0.0f;
465 sd->v = 0.0f;
466
467 # ifdef __DPDU__
468 /* dPdu/dPdv */
469 sd->dPdu = make_float3(0.0f, 0.0f, 0.0f);
470 sd->dPdv = make_float3(0.0f, 0.0f, 0.0f);
471 # endif
472
473 # ifdef __RAY_DIFFERENTIALS__
474 /* differentials */
475 sd->dP = ray->dD;
476 differential_incoming(&sd->dI, sd->dP);
477 sd->du = differential_zero();
478 sd->dv = differential_zero();
479 # endif
480
481 /* for NDC coordinates */
482 sd->ray_P = ray->P;
483 sd->ray_dP = ray->dP;
484
485 PROFILING_SHADER(sd->shader);
486 PROFILING_OBJECT(sd->object);
487 }
488 #endif /* __VOLUME__ */
489
490 /* Merging */
491
492 #if defined(__BRANCHED_PATH__) || defined(__VOLUME__)
shader_merge_closures(ShaderData * sd)493 ccl_device_inline void shader_merge_closures(ShaderData *sd)
494 {
495 /* merge identical closures, better when we sample a single closure at a time */
496 for (int i = 0; i < sd->num_closure; i++) {
497 ShaderClosure *sci = &sd->closure[i];
498
499 for (int j = i + 1; j < sd->num_closure; j++) {
500 ShaderClosure *scj = &sd->closure[j];
501
502 if (sci->type != scj->type)
503 continue;
504 if (!bsdf_merge(sci, scj))
505 continue;
506
507 sci->weight += scj->weight;
508 sci->sample_weight += scj->sample_weight;
509
510 int size = sd->num_closure - (j + 1);
511 if (size > 0) {
512 for (int k = 0; k < size; k++) {
513 scj[k] = scj[k + 1];
514 }
515 }
516
517 sd->num_closure--;
518 kernel_assert(sd->num_closure >= 0);
519 j--;
520 }
521 }
522 }
523 #endif /* __BRANCHED_PATH__ || __VOLUME__ */
524
525 /* Defensive sampling. */
526
shader_prepare_closures(ShaderData * sd,ccl_addr_space PathState * state)527 ccl_device_inline void shader_prepare_closures(ShaderData *sd, ccl_addr_space PathState *state)
528 {
529 /* We can likely also do defensive sampling at deeper bounces, particularly
530 * for cases like a perfect mirror but possibly also others. This will need
531 * a good heuristic. */
532 if (state->bounce + state->transparent_bounce == 0 && sd->num_closure > 1) {
533 float sum = 0.0f;
534
535 for (int i = 0; i < sd->num_closure; i++) {
536 ShaderClosure *sc = &sd->closure[i];
537 if (CLOSURE_IS_BSDF_OR_BSSRDF(sc->type)) {
538 sum += sc->sample_weight;
539 }
540 }
541
542 for (int i = 0; i < sd->num_closure; i++) {
543 ShaderClosure *sc = &sd->closure[i];
544 if (CLOSURE_IS_BSDF_OR_BSSRDF(sc->type)) {
545 sc->sample_weight = max(sc->sample_weight, 0.125f * sum);
546 }
547 }
548 }
549 }
550
551 /* BSDF */
552
_shader_bsdf_multi_eval(KernelGlobals * kg,ShaderData * sd,const float3 omega_in,float * pdf,const ShaderClosure * skip_sc,BsdfEval * result_eval,float sum_pdf,float sum_sample_weight)553 ccl_device_inline void _shader_bsdf_multi_eval(KernelGlobals *kg,
554 ShaderData *sd,
555 const float3 omega_in,
556 float *pdf,
557 const ShaderClosure *skip_sc,
558 BsdfEval *result_eval,
559 float sum_pdf,
560 float sum_sample_weight)
561 {
562 /* this is the veach one-sample model with balance heuristic, some pdf
563 * factors drop out when using balance heuristic weighting */
564 for (int i = 0; i < sd->num_closure; i++) {
565 const ShaderClosure *sc = &sd->closure[i];
566
567 if (sc != skip_sc && CLOSURE_IS_BSDF(sc->type)) {
568 float bsdf_pdf = 0.0f;
569 float3 eval = bsdf_eval(kg, sd, sc, omega_in, &bsdf_pdf);
570
571 if (bsdf_pdf != 0.0f) {
572 bsdf_eval_accum(result_eval, sc->type, eval * sc->weight, 1.0f);
573 sum_pdf += bsdf_pdf * sc->sample_weight;
574 }
575
576 sum_sample_weight += sc->sample_weight;
577 }
578 }
579
580 *pdf = (sum_sample_weight > 0.0f) ? sum_pdf / sum_sample_weight : 0.0f;
581 }
582
583 #ifdef __BRANCHED_PATH__
_shader_bsdf_multi_eval_branched(KernelGlobals * kg,ShaderData * sd,const float3 omega_in,BsdfEval * result_eval,float light_pdf,bool use_mis)584 ccl_device_inline void _shader_bsdf_multi_eval_branched(KernelGlobals *kg,
585 ShaderData *sd,
586 const float3 omega_in,
587 BsdfEval *result_eval,
588 float light_pdf,
589 bool use_mis)
590 {
591 for (int i = 0; i < sd->num_closure; i++) {
592 const ShaderClosure *sc = &sd->closure[i];
593 if (CLOSURE_IS_BSDF(sc->type)) {
594 float bsdf_pdf = 0.0f;
595 float3 eval = bsdf_eval(kg, sd, sc, omega_in, &bsdf_pdf);
596 if (bsdf_pdf != 0.0f) {
597 float mis_weight = use_mis ? power_heuristic(light_pdf, bsdf_pdf) : 1.0f;
598 bsdf_eval_accum(result_eval, sc->type, eval * sc->weight, mis_weight);
599 }
600 }
601 }
602 }
603 #endif /* __BRANCHED_PATH__ */
604
605 #ifndef __KERNEL_CUDA__
606 ccl_device
607 #else
608 ccl_device_inline
609 #endif
610 void
shader_bsdf_eval(KernelGlobals * kg,ShaderData * sd,const float3 omega_in,BsdfEval * eval,float light_pdf,bool use_mis)611 shader_bsdf_eval(KernelGlobals *kg,
612 ShaderData *sd,
613 const float3 omega_in,
614 BsdfEval *eval,
615 float light_pdf,
616 bool use_mis)
617 {
618 PROFILING_INIT(kg, PROFILING_CLOSURE_EVAL);
619
620 bsdf_eval_init(
621 eval, NBUILTIN_CLOSURES, make_float3(0.0f, 0.0f, 0.0f), kernel_data.film.use_light_pass);
622
623 #ifdef __BRANCHED_PATH__
624 if (kernel_data.integrator.branched)
625 _shader_bsdf_multi_eval_branched(kg, sd, omega_in, eval, light_pdf, use_mis);
626 else
627 #endif
628 {
629 float pdf;
630 _shader_bsdf_multi_eval(kg, sd, omega_in, &pdf, NULL, eval, 0.0f, 0.0f);
631 if (use_mis) {
632 float weight = power_heuristic(light_pdf, pdf);
633 bsdf_eval_mis(eval, weight);
634 }
635 }
636 }
637
shader_bsdf_pick(ShaderData * sd,float * randu)638 ccl_device_inline const ShaderClosure *shader_bsdf_pick(ShaderData *sd, float *randu)
639 {
640 /* Note the sampling here must match shader_bssrdf_pick,
641 * since we reuse the same random number. */
642 int sampled = 0;
643
644 if (sd->num_closure > 1) {
645 /* Pick a BSDF or based on sample weights. */
646 float sum = 0.0f;
647
648 for (int i = 0; i < sd->num_closure; i++) {
649 const ShaderClosure *sc = &sd->closure[i];
650
651 if (CLOSURE_IS_BSDF_OR_BSSRDF(sc->type)) {
652 sum += sc->sample_weight;
653 }
654 }
655
656 float r = (*randu) * sum;
657 float partial_sum = 0.0f;
658
659 for (int i = 0; i < sd->num_closure; i++) {
660 const ShaderClosure *sc = &sd->closure[i];
661
662 if (CLOSURE_IS_BSDF_OR_BSSRDF(sc->type)) {
663 float next_sum = partial_sum + sc->sample_weight;
664
665 if (r < next_sum) {
666 sampled = i;
667
668 /* Rescale to reuse for direction sample, to better preserve stratification. */
669 *randu = (r - partial_sum) / sc->sample_weight;
670 break;
671 }
672
673 partial_sum = next_sum;
674 }
675 }
676 }
677
678 const ShaderClosure *sc = &sd->closure[sampled];
679 return CLOSURE_IS_BSDF(sc->type) ? sc : NULL;
680 }
681
shader_bssrdf_pick(ShaderData * sd,ccl_addr_space float3 * throughput,float * randu)682 ccl_device_inline const ShaderClosure *shader_bssrdf_pick(ShaderData *sd,
683 ccl_addr_space float3 *throughput,
684 float *randu)
685 {
686 /* Note the sampling here must match shader_bsdf_pick,
687 * since we reuse the same random number. */
688 int sampled = 0;
689
690 if (sd->num_closure > 1) {
691 /* Pick a BSDF or BSSRDF or based on sample weights. */
692 float sum_bsdf = 0.0f;
693 float sum_bssrdf = 0.0f;
694
695 for (int i = 0; i < sd->num_closure; i++) {
696 const ShaderClosure *sc = &sd->closure[i];
697
698 if (CLOSURE_IS_BSDF(sc->type)) {
699 sum_bsdf += sc->sample_weight;
700 }
701 else if (CLOSURE_IS_BSSRDF(sc->type)) {
702 sum_bssrdf += sc->sample_weight;
703 }
704 }
705
706 float r = (*randu) * (sum_bsdf + sum_bssrdf);
707 float partial_sum = 0.0f;
708
709 for (int i = 0; i < sd->num_closure; i++) {
710 const ShaderClosure *sc = &sd->closure[i];
711
712 if (CLOSURE_IS_BSDF_OR_BSSRDF(sc->type)) {
713 float next_sum = partial_sum + sc->sample_weight;
714
715 if (r < next_sum) {
716 if (CLOSURE_IS_BSDF(sc->type)) {
717 *throughput *= (sum_bsdf + sum_bssrdf) / sum_bsdf;
718 return NULL;
719 }
720 else {
721 *throughput *= (sum_bsdf + sum_bssrdf) / sum_bssrdf;
722 sampled = i;
723
724 /* Rescale to reuse for direction sample, to better preserve stratification. */
725 *randu = (r - partial_sum) / sc->sample_weight;
726 break;
727 }
728 }
729
730 partial_sum = next_sum;
731 }
732 }
733 }
734
735 const ShaderClosure *sc = &sd->closure[sampled];
736 return CLOSURE_IS_BSSRDF(sc->type) ? sc : NULL;
737 }
738
shader_bsdf_sample(KernelGlobals * kg,ShaderData * sd,float randu,float randv,BsdfEval * bsdf_eval,float3 * omega_in,differential3 * domega_in,float * pdf)739 ccl_device_inline int shader_bsdf_sample(KernelGlobals *kg,
740 ShaderData *sd,
741 float randu,
742 float randv,
743 BsdfEval *bsdf_eval,
744 float3 *omega_in,
745 differential3 *domega_in,
746 float *pdf)
747 {
748 PROFILING_INIT(kg, PROFILING_CLOSURE_SAMPLE);
749
750 const ShaderClosure *sc = shader_bsdf_pick(sd, &randu);
751 if (sc == NULL) {
752 *pdf = 0.0f;
753 return LABEL_NONE;
754 }
755
756 /* BSSRDF should already have been handled elsewhere. */
757 kernel_assert(CLOSURE_IS_BSDF(sc->type));
758
759 int label;
760 float3 eval = make_float3(0.0f, 0.0f, 0.0f);
761
762 *pdf = 0.0f;
763 label = bsdf_sample(kg, sd, sc, randu, randv, &eval, omega_in, domega_in, pdf);
764
765 if (*pdf != 0.0f) {
766 bsdf_eval_init(bsdf_eval, sc->type, eval * sc->weight, kernel_data.film.use_light_pass);
767
768 if (sd->num_closure > 1) {
769 float sweight = sc->sample_weight;
770 _shader_bsdf_multi_eval(kg, sd, *omega_in, pdf, sc, bsdf_eval, *pdf * sweight, sweight);
771 }
772 }
773
774 return label;
775 }
776
shader_bsdf_sample_closure(KernelGlobals * kg,ShaderData * sd,const ShaderClosure * sc,float randu,float randv,BsdfEval * bsdf_eval,float3 * omega_in,differential3 * domega_in,float * pdf)777 ccl_device int shader_bsdf_sample_closure(KernelGlobals *kg,
778 ShaderData *sd,
779 const ShaderClosure *sc,
780 float randu,
781 float randv,
782 BsdfEval *bsdf_eval,
783 float3 *omega_in,
784 differential3 *domega_in,
785 float *pdf)
786 {
787 PROFILING_INIT(kg, PROFILING_CLOSURE_SAMPLE);
788
789 int label;
790 float3 eval = make_float3(0.0f, 0.0f, 0.0f);
791
792 *pdf = 0.0f;
793 label = bsdf_sample(kg, sd, sc, randu, randv, &eval, omega_in, domega_in, pdf);
794
795 if (*pdf != 0.0f)
796 bsdf_eval_init(bsdf_eval, sc->type, eval * sc->weight, kernel_data.film.use_light_pass);
797
798 return label;
799 }
800
shader_bsdf_average_roughness(ShaderData * sd)801 ccl_device float shader_bsdf_average_roughness(ShaderData *sd)
802 {
803 float roughness = 0.0f;
804 float sum_weight = 0.0f;
805
806 for (int i = 0; i < sd->num_closure; i++) {
807 ShaderClosure *sc = &sd->closure[i];
808
809 if (CLOSURE_IS_BSDF(sc->type)) {
810 /* sqrt once to undo the squaring from multiplying roughness on the
811 * two axes, and once for the squared roughness convention. */
812 float weight = fabsf(average(sc->weight));
813 roughness += weight * sqrtf(safe_sqrtf(bsdf_get_roughness_squared(sc)));
814 sum_weight += weight;
815 }
816 }
817
818 return (sum_weight > 0.0f) ? roughness / sum_weight : 0.0f;
819 }
820
shader_bsdf_blur(KernelGlobals * kg,ShaderData * sd,float roughness)821 ccl_device void shader_bsdf_blur(KernelGlobals *kg, ShaderData *sd, float roughness)
822 {
823 for (int i = 0; i < sd->num_closure; i++) {
824 ShaderClosure *sc = &sd->closure[i];
825
826 if (CLOSURE_IS_BSDF(sc->type))
827 bsdf_blur(kg, sc, roughness);
828 }
829 }
830
shader_bsdf_transparency(KernelGlobals * kg,const ShaderData * sd)831 ccl_device float3 shader_bsdf_transparency(KernelGlobals *kg, const ShaderData *sd)
832 {
833 if (sd->flag & SD_HAS_ONLY_VOLUME) {
834 return make_float3(1.0f, 1.0f, 1.0f);
835 }
836 else if (sd->flag & SD_TRANSPARENT) {
837 return sd->closure_transparent_extinction;
838 }
839 else {
840 return make_float3(0.0f, 0.0f, 0.0f);
841 }
842 }
843
shader_bsdf_disable_transparency(KernelGlobals * kg,ShaderData * sd)844 ccl_device void shader_bsdf_disable_transparency(KernelGlobals *kg, ShaderData *sd)
845 {
846 if (sd->flag & SD_TRANSPARENT) {
847 for (int i = 0; i < sd->num_closure; i++) {
848 ShaderClosure *sc = &sd->closure[i];
849
850 if (sc->type == CLOSURE_BSDF_TRANSPARENT_ID) {
851 sc->sample_weight = 0.0f;
852 sc->weight = make_float3(0.0f, 0.0f, 0.0f);
853 }
854 }
855
856 sd->flag &= ~SD_TRANSPARENT;
857 }
858 }
859
shader_bsdf_alpha(KernelGlobals * kg,ShaderData * sd)860 ccl_device float3 shader_bsdf_alpha(KernelGlobals *kg, ShaderData *sd)
861 {
862 float3 alpha = make_float3(1.0f, 1.0f, 1.0f) - shader_bsdf_transparency(kg, sd);
863
864 alpha = max(alpha, make_float3(0.0f, 0.0f, 0.0f));
865 alpha = min(alpha, make_float3(1.0f, 1.0f, 1.0f));
866
867 return alpha;
868 }
869
shader_bsdf_diffuse(KernelGlobals * kg,ShaderData * sd)870 ccl_device float3 shader_bsdf_diffuse(KernelGlobals *kg, ShaderData *sd)
871 {
872 float3 eval = make_float3(0.0f, 0.0f, 0.0f);
873
874 for (int i = 0; i < sd->num_closure; i++) {
875 ShaderClosure *sc = &sd->closure[i];
876
877 if (CLOSURE_IS_BSDF_DIFFUSE(sc->type) || CLOSURE_IS_BSSRDF(sc->type) ||
878 CLOSURE_IS_BSDF_BSSRDF(sc->type))
879 eval += sc->weight;
880 }
881
882 return eval;
883 }
884
shader_bsdf_glossy(KernelGlobals * kg,ShaderData * sd)885 ccl_device float3 shader_bsdf_glossy(KernelGlobals *kg, ShaderData *sd)
886 {
887 float3 eval = make_float3(0.0f, 0.0f, 0.0f);
888
889 for (int i = 0; i < sd->num_closure; i++) {
890 ShaderClosure *sc = &sd->closure[i];
891
892 if (CLOSURE_IS_BSDF_GLOSSY(sc->type))
893 eval += sc->weight;
894 }
895
896 return eval;
897 }
898
shader_bsdf_transmission(KernelGlobals * kg,ShaderData * sd)899 ccl_device float3 shader_bsdf_transmission(KernelGlobals *kg, ShaderData *sd)
900 {
901 float3 eval = make_float3(0.0f, 0.0f, 0.0f);
902
903 for (int i = 0; i < sd->num_closure; i++) {
904 ShaderClosure *sc = &sd->closure[i];
905
906 if (CLOSURE_IS_BSDF_TRANSMISSION(sc->type))
907 eval += sc->weight;
908 }
909
910 return eval;
911 }
912
shader_bsdf_average_normal(KernelGlobals * kg,ShaderData * sd)913 ccl_device float3 shader_bsdf_average_normal(KernelGlobals *kg, ShaderData *sd)
914 {
915 float3 N = make_float3(0.0f, 0.0f, 0.0f);
916
917 for (int i = 0; i < sd->num_closure; i++) {
918 ShaderClosure *sc = &sd->closure[i];
919 if (CLOSURE_IS_BSDF_OR_BSSRDF(sc->type))
920 N += sc->N * fabsf(average(sc->weight));
921 }
922
923 return (is_zero(N)) ? sd->N : normalize(N);
924 }
925
shader_bsdf_ao(KernelGlobals * kg,ShaderData * sd,float ao_factor,float3 * N_)926 ccl_device float3 shader_bsdf_ao(KernelGlobals *kg, ShaderData *sd, float ao_factor, float3 *N_)
927 {
928 float3 eval = make_float3(0.0f, 0.0f, 0.0f);
929 float3 N = make_float3(0.0f, 0.0f, 0.0f);
930
931 for (int i = 0; i < sd->num_closure; i++) {
932 ShaderClosure *sc = &sd->closure[i];
933
934 if (CLOSURE_IS_BSDF_DIFFUSE(sc->type)) {
935 const DiffuseBsdf *bsdf = (const DiffuseBsdf *)sc;
936 eval += sc->weight * ao_factor;
937 N += bsdf->N * fabsf(average(sc->weight));
938 }
939 }
940
941 *N_ = (is_zero(N)) ? sd->N : normalize(N);
942 return eval;
943 }
944
945 #ifdef __SUBSURFACE__
shader_bssrdf_sum(ShaderData * sd,float3 * N_,float * texture_blur_)946 ccl_device float3 shader_bssrdf_sum(ShaderData *sd, float3 *N_, float *texture_blur_)
947 {
948 float3 eval = make_float3(0.0f, 0.0f, 0.0f);
949 float3 N = make_float3(0.0f, 0.0f, 0.0f);
950 float texture_blur = 0.0f, weight_sum = 0.0f;
951
952 for (int i = 0; i < sd->num_closure; i++) {
953 ShaderClosure *sc = &sd->closure[i];
954
955 if (CLOSURE_IS_BSSRDF(sc->type)) {
956 const Bssrdf *bssrdf = (const Bssrdf *)sc;
957 float avg_weight = fabsf(average(sc->weight));
958
959 N += bssrdf->N * avg_weight;
960 eval += sc->weight;
961 texture_blur += bssrdf->texture_blur * avg_weight;
962 weight_sum += avg_weight;
963 }
964 }
965
966 if (N_)
967 *N_ = (is_zero(N)) ? sd->N : normalize(N);
968
969 if (texture_blur_)
970 *texture_blur_ = safe_divide(texture_blur, weight_sum);
971
972 return eval;
973 }
974 #endif /* __SUBSURFACE__ */
975
976 /* Constant emission optimization */
977
shader_constant_emission_eval(KernelGlobals * kg,int shader,float3 * eval)978 ccl_device bool shader_constant_emission_eval(KernelGlobals *kg, int shader, float3 *eval)
979 {
980 int shader_index = shader & SHADER_MASK;
981 int shader_flag = kernel_tex_fetch(__shaders, shader_index).flags;
982
983 if (shader_flag & SD_HAS_CONSTANT_EMISSION) {
984 *eval = make_float3(kernel_tex_fetch(__shaders, shader_index).constant_emission[0],
985 kernel_tex_fetch(__shaders, shader_index).constant_emission[1],
986 kernel_tex_fetch(__shaders, shader_index).constant_emission[2]);
987
988 return true;
989 }
990
991 return false;
992 }
993
994 /* Background */
995
shader_background_eval(ShaderData * sd)996 ccl_device float3 shader_background_eval(ShaderData *sd)
997 {
998 if (sd->flag & SD_EMISSION) {
999 return sd->closure_emission_background;
1000 }
1001 else {
1002 return make_float3(0.0f, 0.0f, 0.0f);
1003 }
1004 }
1005
1006 /* Emission */
1007
shader_emissive_eval(ShaderData * sd)1008 ccl_device float3 shader_emissive_eval(ShaderData *sd)
1009 {
1010 if (sd->flag & SD_EMISSION) {
1011 return emissive_simple_eval(sd->Ng, sd->I) * sd->closure_emission_background;
1012 }
1013 else {
1014 return make_float3(0.0f, 0.0f, 0.0f);
1015 }
1016 }
1017
1018 /* Holdout */
1019
shader_holdout_apply(KernelGlobals * kg,ShaderData * sd)1020 ccl_device float3 shader_holdout_apply(KernelGlobals *kg, ShaderData *sd)
1021 {
1022 float3 weight = make_float3(0.0f, 0.0f, 0.0f);
1023
1024 /* For objects marked as holdout, preserve transparency and remove all other
1025 * closures, replacing them with a holdout weight. */
1026 if (sd->object_flag & SD_OBJECT_HOLDOUT_MASK) {
1027 if ((sd->flag & SD_TRANSPARENT) && !(sd->flag & SD_HAS_ONLY_VOLUME)) {
1028 weight = make_float3(1.0f, 1.0f, 1.0f) - sd->closure_transparent_extinction;
1029
1030 for (int i = 0; i < sd->num_closure; i++) {
1031 ShaderClosure *sc = &sd->closure[i];
1032 if (!CLOSURE_IS_BSDF_TRANSPARENT(sc->type)) {
1033 sc->type = NBUILTIN_CLOSURES;
1034 }
1035 }
1036
1037 sd->flag &= ~(SD_CLOSURE_FLAGS - (SD_TRANSPARENT | SD_BSDF));
1038 }
1039 else {
1040 weight = make_float3(1.0f, 1.0f, 1.0f);
1041 }
1042 }
1043 else {
1044 for (int i = 0; i < sd->num_closure; i++) {
1045 ShaderClosure *sc = &sd->closure[i];
1046 if (CLOSURE_IS_HOLDOUT(sc->type)) {
1047 weight += sc->weight;
1048 }
1049 }
1050 }
1051
1052 return weight;
1053 }
1054
1055 /* Surface Evaluation */
1056
shader_eval_surface(KernelGlobals * kg,ShaderData * sd,ccl_addr_space PathState * state,ccl_global float * buffer,int path_flag)1057 ccl_device void shader_eval_surface(KernelGlobals *kg,
1058 ShaderData *sd,
1059 ccl_addr_space PathState *state,
1060 ccl_global float *buffer,
1061 int path_flag)
1062 {
1063 PROFILING_INIT(kg, PROFILING_SHADER_EVAL);
1064
1065 /* If path is being terminated, we are tracing a shadow ray or evaluating
1066 * emission, then we don't need to store closures. The emission and shadow
1067 * shader data also do not have a closure array to save GPU memory. */
1068 int max_closures;
1069 if (path_flag & (PATH_RAY_TERMINATE | PATH_RAY_SHADOW | PATH_RAY_EMISSION)) {
1070 max_closures = 0;
1071 }
1072 else {
1073 max_closures = kernel_data.integrator.max_closures;
1074 }
1075
1076 sd->num_closure = 0;
1077 sd->num_closure_left = max_closures;
1078
1079 #ifdef __OSL__
1080 if (kg->osl) {
1081 if (sd->object == OBJECT_NONE && sd->lamp == LAMP_NONE) {
1082 OSLShader::eval_background(kg, sd, state, path_flag);
1083 }
1084 else {
1085 OSLShader::eval_surface(kg, sd, state, path_flag);
1086 }
1087 }
1088 else
1089 #endif
1090 {
1091 #ifdef __SVM__
1092 svm_eval_nodes(kg, sd, state, buffer, SHADER_TYPE_SURFACE, path_flag);
1093 #else
1094 if (sd->object == OBJECT_NONE) {
1095 sd->closure_emission_background = make_float3(0.8f, 0.8f, 0.8f);
1096 sd->flag |= SD_EMISSION;
1097 }
1098 else {
1099 DiffuseBsdf *bsdf = (DiffuseBsdf *)bsdf_alloc(
1100 sd, sizeof(DiffuseBsdf), make_float3(0.8f, 0.8f, 0.8f));
1101 if (bsdf != NULL) {
1102 bsdf->N = sd->N;
1103 sd->flag |= bsdf_diffuse_setup(bsdf);
1104 }
1105 }
1106 #endif
1107 }
1108
1109 if (sd->flag & SD_BSDF_NEEDS_LCG) {
1110 sd->lcg_state = lcg_state_init_addrspace(state, 0xb4bc3953);
1111 }
1112 }
1113
1114 /* Volume */
1115
1116 #ifdef __VOLUME__
1117
_shader_volume_phase_multi_eval(const ShaderData * sd,const float3 omega_in,float * pdf,int skip_phase,BsdfEval * result_eval,float sum_pdf,float sum_sample_weight)1118 ccl_device_inline void _shader_volume_phase_multi_eval(const ShaderData *sd,
1119 const float3 omega_in,
1120 float *pdf,
1121 int skip_phase,
1122 BsdfEval *result_eval,
1123 float sum_pdf,
1124 float sum_sample_weight)
1125 {
1126 for (int i = 0; i < sd->num_closure; i++) {
1127 if (i == skip_phase)
1128 continue;
1129
1130 const ShaderClosure *sc = &sd->closure[i];
1131
1132 if (CLOSURE_IS_PHASE(sc->type)) {
1133 float phase_pdf = 0.0f;
1134 float3 eval = volume_phase_eval(sd, sc, omega_in, &phase_pdf);
1135
1136 if (phase_pdf != 0.0f) {
1137 bsdf_eval_accum(result_eval, sc->type, eval, 1.0f);
1138 sum_pdf += phase_pdf * sc->sample_weight;
1139 }
1140
1141 sum_sample_weight += sc->sample_weight;
1142 }
1143 }
1144
1145 *pdf = (sum_sample_weight > 0.0f) ? sum_pdf / sum_sample_weight : 0.0f;
1146 }
1147
shader_volume_phase_eval(KernelGlobals * kg,const ShaderData * sd,const float3 omega_in,BsdfEval * eval,float * pdf)1148 ccl_device void shader_volume_phase_eval(
1149 KernelGlobals *kg, const ShaderData *sd, const float3 omega_in, BsdfEval *eval, float *pdf)
1150 {
1151 PROFILING_INIT(kg, PROFILING_CLOSURE_VOLUME_EVAL);
1152
1153 bsdf_eval_init(
1154 eval, NBUILTIN_CLOSURES, make_float3(0.0f, 0.0f, 0.0f), kernel_data.film.use_light_pass);
1155
1156 _shader_volume_phase_multi_eval(sd, omega_in, pdf, -1, eval, 0.0f, 0.0f);
1157 }
1158
shader_volume_phase_sample(KernelGlobals * kg,const ShaderData * sd,float randu,float randv,BsdfEval * phase_eval,float3 * omega_in,differential3 * domega_in,float * pdf)1159 ccl_device int shader_volume_phase_sample(KernelGlobals *kg,
1160 const ShaderData *sd,
1161 float randu,
1162 float randv,
1163 BsdfEval *phase_eval,
1164 float3 *omega_in,
1165 differential3 *domega_in,
1166 float *pdf)
1167 {
1168 PROFILING_INIT(kg, PROFILING_CLOSURE_VOLUME_SAMPLE);
1169
1170 int sampled = 0;
1171
1172 if (sd->num_closure > 1) {
1173 /* pick a phase closure based on sample weights */
1174 float sum = 0.0f;
1175
1176 for (sampled = 0; sampled < sd->num_closure; sampled++) {
1177 const ShaderClosure *sc = &sd->closure[sampled];
1178
1179 if (CLOSURE_IS_PHASE(sc->type))
1180 sum += sc->sample_weight;
1181 }
1182
1183 float r = randu * sum;
1184 float partial_sum = 0.0f;
1185
1186 for (sampled = 0; sampled < sd->num_closure; sampled++) {
1187 const ShaderClosure *sc = &sd->closure[sampled];
1188
1189 if (CLOSURE_IS_PHASE(sc->type)) {
1190 float next_sum = partial_sum + sc->sample_weight;
1191
1192 if (r <= next_sum) {
1193 /* Rescale to reuse for BSDF direction sample. */
1194 randu = (r - partial_sum) / sc->sample_weight;
1195 break;
1196 }
1197
1198 partial_sum = next_sum;
1199 }
1200 }
1201
1202 if (sampled == sd->num_closure) {
1203 *pdf = 0.0f;
1204 return LABEL_NONE;
1205 }
1206 }
1207
1208 /* todo: this isn't quite correct, we don't weight anisotropy properly
1209 * depending on color channels, even if this is perhaps not a common case */
1210 const ShaderClosure *sc = &sd->closure[sampled];
1211 int label;
1212 float3 eval = make_float3(0.0f, 0.0f, 0.0f);
1213
1214 *pdf = 0.0f;
1215 label = volume_phase_sample(sd, sc, randu, randv, &eval, omega_in, domega_in, pdf);
1216
1217 if (*pdf != 0.0f) {
1218 bsdf_eval_init(phase_eval, sc->type, eval, kernel_data.film.use_light_pass);
1219 }
1220
1221 return label;
1222 }
1223
shader_phase_sample_closure(KernelGlobals * kg,const ShaderData * sd,const ShaderClosure * sc,float randu,float randv,BsdfEval * phase_eval,float3 * omega_in,differential3 * domega_in,float * pdf)1224 ccl_device int shader_phase_sample_closure(KernelGlobals *kg,
1225 const ShaderData *sd,
1226 const ShaderClosure *sc,
1227 float randu,
1228 float randv,
1229 BsdfEval *phase_eval,
1230 float3 *omega_in,
1231 differential3 *domega_in,
1232 float *pdf)
1233 {
1234 PROFILING_INIT(kg, PROFILING_CLOSURE_VOLUME_SAMPLE);
1235
1236 int label;
1237 float3 eval = make_float3(0.0f, 0.0f, 0.0f);
1238
1239 *pdf = 0.0f;
1240 label = volume_phase_sample(sd, sc, randu, randv, &eval, omega_in, domega_in, pdf);
1241
1242 if (*pdf != 0.0f)
1243 bsdf_eval_init(phase_eval, sc->type, eval, kernel_data.film.use_light_pass);
1244
1245 return label;
1246 }
1247
1248 /* Volume Evaluation */
1249
shader_eval_volume(KernelGlobals * kg,ShaderData * sd,ccl_addr_space PathState * state,ccl_addr_space VolumeStack * stack,int path_flag)1250 ccl_device_inline void shader_eval_volume(KernelGlobals *kg,
1251 ShaderData *sd,
1252 ccl_addr_space PathState *state,
1253 ccl_addr_space VolumeStack *stack,
1254 int path_flag)
1255 {
1256 /* If path is being terminated, we are tracing a shadow ray or evaluating
1257 * emission, then we don't need to store closures. The emission and shadow
1258 * shader data also do not have a closure array to save GPU memory. */
1259 int max_closures;
1260 if (path_flag & (PATH_RAY_TERMINATE | PATH_RAY_SHADOW | PATH_RAY_EMISSION)) {
1261 max_closures = 0;
1262 }
1263 else {
1264 max_closures = kernel_data.integrator.max_closures;
1265 }
1266
1267 /* reset closures once at the start, we will be accumulating the closures
1268 * for all volumes in the stack into a single array of closures */
1269 sd->num_closure = 0;
1270 sd->num_closure_left = max_closures;
1271 sd->flag = 0;
1272 sd->object_flag = 0;
1273
1274 for (int i = 0; stack[i].shader != SHADER_NONE; i++) {
1275 /* setup shaderdata from stack. it's mostly setup already in
1276 * shader_setup_from_volume, this switching should be quick */
1277 sd->object = stack[i].object;
1278 sd->lamp = LAMP_NONE;
1279 sd->shader = stack[i].shader;
1280
1281 sd->flag &= ~SD_SHADER_FLAGS;
1282 sd->flag |= kernel_tex_fetch(__shaders, (sd->shader & SHADER_MASK)).flags;
1283 sd->object_flag &= ~SD_OBJECT_FLAGS;
1284
1285 if (sd->object != OBJECT_NONE) {
1286 sd->object_flag |= kernel_tex_fetch(__object_flag, sd->object);
1287
1288 # ifdef __OBJECT_MOTION__
1289 /* todo: this is inefficient for motion blur, we should be
1290 * caching matrices instead of recomputing them each step */
1291 shader_setup_object_transforms(kg, sd, sd->time);
1292 # endif
1293 }
1294
1295 /* evaluate shader */
1296 # ifdef __SVM__
1297 # ifdef __OSL__
1298 if (kg->osl) {
1299 OSLShader::eval_volume(kg, sd, state, path_flag);
1300 }
1301 else
1302 # endif
1303 {
1304 svm_eval_nodes(kg, sd, state, NULL, SHADER_TYPE_VOLUME, path_flag);
1305 }
1306 # endif
1307
1308 /* merge closures to avoid exceeding number of closures limit */
1309 if (i > 0)
1310 shader_merge_closures(sd);
1311 }
1312 }
1313
1314 #endif /* __VOLUME__ */
1315
1316 /* Displacement Evaluation */
1317
shader_eval_displacement(KernelGlobals * kg,ShaderData * sd,ccl_addr_space PathState * state)1318 ccl_device void shader_eval_displacement(KernelGlobals *kg,
1319 ShaderData *sd,
1320 ccl_addr_space PathState *state)
1321 {
1322 sd->num_closure = 0;
1323 sd->num_closure_left = 0;
1324
1325 /* this will modify sd->P */
1326 #ifdef __SVM__
1327 # ifdef __OSL__
1328 if (kg->osl)
1329 OSLShader::eval_displacement(kg, sd, state);
1330 else
1331 # endif
1332 {
1333 svm_eval_nodes(kg, sd, state, NULL, SHADER_TYPE_DISPLACEMENT, 0);
1334 }
1335 #endif
1336 }
1337
1338 /* Transparent Shadows */
1339
1340 #ifdef __TRANSPARENT_SHADOWS__
shader_transparent_shadow(KernelGlobals * kg,Intersection * isect)1341 ccl_device bool shader_transparent_shadow(KernelGlobals *kg, Intersection *isect)
1342 {
1343 int prim = kernel_tex_fetch(__prim_index, isect->prim);
1344 int shader = 0;
1345
1346 # ifdef __HAIR__
1347 if (isect->type & PRIMITIVE_ALL_TRIANGLE) {
1348 # endif
1349 shader = kernel_tex_fetch(__tri_shader, prim);
1350 # ifdef __HAIR__
1351 }
1352 else {
1353 float4 str = kernel_tex_fetch(__curves, prim);
1354 shader = __float_as_int(str.z);
1355 }
1356 # endif
1357 int flag = kernel_tex_fetch(__shaders, (shader & SHADER_MASK)).flags;
1358
1359 return (flag & SD_HAS_TRANSPARENT_SHADOW) != 0;
1360 }
1361 #endif /* __TRANSPARENT_SHADOWS__ */
1362
shader_cryptomatte_id(KernelGlobals * kg,int shader)1363 ccl_device float shader_cryptomatte_id(KernelGlobals *kg, int shader)
1364 {
1365 return kernel_tex_fetch(__shaders, (shader & SHADER_MASK)).cryptomatte_id;
1366 }
1367
1368 CCL_NAMESPACE_END
1369